ProgMaster

Veja agora como você será monitorado

2012-01-26T11:22:00.001-03:00

O google lança sua nova "Política de Privacidade" que irá monitorar você 24 horas por dia em tudo que você faz na internet seja direto ou indiretamente por meio dos produtos fornecidos pela google ou pelos anúncios e vínculos de outros sites que utilizem os produtos da google.

A Nova Política de Privacidade explica:

•   Quais informações são coletadas e por que elas são coletadas.
•   Como serão usadas essas informações.
•   As opções que oferecem, incluindo o modo de acessar e atualizar informações.

Veja no link abaixo toda a nova política de privacidade do Google:
http://www.google.com.br/intl/pt-BR/policies/privacy/preview/

Como converter AnsiString para char[] (C ++ Builder)

2011-12-16T10:48:00.001-03:00

O exemplo a seguir leva um Button, um Label e 4 Edits no Form. Quando o usuário dá um clique no botão, o programa realiza algumas conversões entre AnsiString e char[] e vice-versa:

//-------------------------------------------------------------

 #include 
#pragma hdrstop

#include "Unit1.h"
//-------------------------------------------------------------

 #pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//-------------------------------------------------------------

 __fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//-------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
Edit1 -> Text = "String inicial de Edit1";        
}
//-------------------------------------------------------------

 void __fastcall TForm1::Button1Click(TObject *Sender)
{
char buffer[100] = "Valor inicial de buffer";
Label1 -> Caption = buffer;
Edit2 -> Text = buffer[0];

// converte Text de AnsiString para char*

strcpy (buffer, Edit1->Text.c_str());

Edit3 -> Text = buffer[0];
Edit4 -> Text = (String) buffer[0]+ buffer[1] + buffer[2];
}
//-------------------------------------------------------------

Como copiar arquivos com php?

2011-12-10T19:04:00.000-03:00

O código abaixo explica como copiar arquivos dentro de um servidor php, permitindo a qualquer momento mudar determinados arquivos de diretório, muito útil em backups.

// copia o arquivo testes.txt para o diretório /imagens
$de = "/site/public_html/testes.txt";
$para = "/site/imagens/testes.txt";

if(copy($de, $para))
echo "Arquivo copiado com sucesso.";
else
echo "Não foi possível copiar o arquivo.";
?>

ProgMaster - Validar Dados 1.0 + Source(Código-Fonte)

2011-12-10T10:26:00.001-03:00

Este programa testa dados pessoais como PIS , CNPJ , CEP , Título de Eleitor , CNH , Cartão de Crédito e CPF , foi Desenvolvido para pessoas que não querem revelar seus dados para criar uma conta em algum site ou outra coisa.

Download

Veja uma imagem do programa :

Banco de dados em Firebird com milhares de ENDEREÇOS e CEP’s de todo o Brasil!

2011-11-30T11:05:00.000-03:00

Banco de dados em Firebird com milhares de endereços cadastrados, importado do banco de dados do IBGE, muito útil para sistemas que possue cadastros extenso que contém endereços a serem preenchidos!

- Retirado os acentos no nomes do logradouros, facilitando assim a busca, já que nativamente o Firebird DIFERENCIA palavras acentuadas.

- Todas os nomes estão em maiúsculos, facilitando assim a busca, já que nativamente o Firebird é CASE SENSITIVE.

- As cidades já estão com seus respectivos códigos, inserir para facilitar no caso de utilizar a NF-e.

Em fim, um ótimo recurso para se utilizar e incrementar mais ainda os seus sistemas.

link : http://hotfile.com/dl/116023163/ad197a6/ENDERECO.FDB.html

Programa para rastrear computador perdido ou roubado (Free)

2011-11-29T09:01:00.002-03:00

Ferramenta gratuita permite monitorar até três dispositivos.

Prey é um programa gratuito para rastreamento
quando o notebook for perdido (Foto: Reprodução)

Os computadores portáteis tornaram-se ferramentas poderosas para quem precisa contar com um equipamento que possa ser levado a qualquer lugar. Porém, ninguém está livre de perder o equipamento, seja em situação de roubo, extravio ou esquecimento. Recentemente a polícia recuperou um laptop graças a programa que envia localização.

Dependendo da importância dos arquivos contidos nele, o prejuízo maior não é nem o valor da máquina, mas as informações armazenadas. Para prevenir, valem os cuidados de sempre, mas que tal contar com um aplicativo gratuito que disponibiliza a localização do computador num serviço na internet?
Nesta coluna, irei apresentar o Prey Project, um aplicativo de código aberto que permite rastrear o computador em caso de perda. O programa pode ser instalado no Windows, Linux, Mac e Android. A localização do equipamento fica disponível num serviço na internet, em que o usuário deve estar cadastrado previamente. A modalidade gratuita permite que sejam adicionados até três equipamentos para o monitoramento. Caso seja necessário adicionar mais computadores, é possível contar com a modalidade paga.
O instalador do Prey Project pode ser baixado no site do fabricante. Escolha a opção de download correspondente ao sistema operacional no computador a ser rastreado. Durante o processo de instalação, é necessário criar um usuário para acessar o painel de monitoramento no site. Esse usuário poderá ser adicionado em outras duas instalações de computadores, que também poderão ser rastreados. Para usuários do sistema operacional Windows, pode ser necessário autorizar a execução do aplicativo nos programas de segurança. Ao término da instalação, o agente de rastreamento ficará ativo e irá se reportar a cada 10 minutos ao painel de monitoramento. O tempo de envio da posição pode ser personalizado para cada equipamento.
Para acessar as configurações de usuário e verificar a situação dos computadores que estão sendo rastreados, basta acessar o site e autenticar no sistema. Já na página inicial ficam visíveis as máquinas monitoradas. Para definir configurações avançadas ou notificar a perda, é preciso clicar sobre a imagem corresponde ao dispositivo.

Dispositivos monitorados pelo Prey Project (Foto: Reprodução)

O sistema só irá gerar relatórios de rastreamento quando o usuário alterar o status do dispositivo para “missing”. Nessa mesma tela é possível definir a periodicidade de coleta de dados.

Tela responsável pelas configurações do sistema, assim como o acionamento da rastreamento quando o notebook for perdido (Foto: Reprodução)

Nos notebooks que possuírem webcam, durante o processo de coleta, o programa faz fotografias, a fim de registrar o rosto do usuário que está acessando o equipamento indevidamente. Além disso, o software registra informações sobre as configurações da rede, programas em uso e arquivos alterados.

Após sinalizar o notebook perdido, o sistema irá exibir em vermelho a ilustração do dispositivo (Foto: Reprodução)

Após definido como perdido, o programa irá enviar para página de monitoramento o relatório contendo as informações que foram configuradas. Nele também será enviada a localização usando serviço o Google Maps. A precisão do rastreamento impressiona. O relatório também é enviado para a conta de e-mail cadastrada pelo usuário.

Localização do notebook perdido (Foto: Reprodução)

Vale salientar que, para o Prey Project funcionar, o equipamento perdido não pode ter sido formatado e a sua localização só será possível quando ele estiver conectado à internet. Uma dica para desestimular a formatação num primeiro momento é deixar ativo um usuário visitante, sem senha, no sistema operacional. Afinal, é muito provável que quem estiver com o equipamento irá tentar usá-lo e, se estiver acessível, talvez a formatação nem ocorra.

Como consertar o pendrive depois de um vírus?

2011-11-19T14:10:00.004-03:00

Perder todos os seus arquivos que estavam em seu pendrive por causa de um vírus pode ser uma experiência bastante desagradável, mas perder todos os arquivos é uma coisa que evidentemente pode-se evitar, com apenas alguns comandos de atributos é possível recuperar e retirar possíveis vírus de seu pendriver. Primeiro temos que entender o que realmente os vírus de pendrive fazem e como eles funcionam em especial os que transformam pastas em atalhos.

Os vírus de pendrive (em especial os que transformam pastas em atalhos) apenas modificam o tipo de atributo das pastas para oculto e de sistema, para entender melhor se você estiver com um pendrive à mão siga os passos para entender:

1° pegue seu pendrive de preferência vazio e crie algumas pastas só para teste.

Crie 5 novas pastas.

Ex:

Deve ficar assim:

2° Agora vamos abrir o cmd e alterar os atributos de nossos arquivos e pastas do pendrive;

Clique em Iniciar>Executar

Ex:

Depois digite cmd e tecle ENTER ou pressione o botão OK

Ex:

Na tela do Pront de comando digite:

cd e tecle ENTER

Digite a letra que representa a unidade de seu pendrive e tecle ENTER; Ex F: ou G:

Para saber qual é a unidade de seu pendrive vá em: Meu Computador e olhe:

Ex:

No meu caso a letra que representa meu pendrive é H, então no pront vai ficar assim:

3° digite na tela do pront:

ATTRIB +H +S /D /S e tecle ENTER

Ex:

Agora vá novamente a seu pendrive e tente olhar o que tem por lá:

È isso que os vírus fazem, aparentemente sumiu tudo, mas não foi realmente isso que aconteceu, agora vamos executar alguns procedimentos para poder visualizar nossos documentos e pastas:

Clique em: FERRAMENTAs>OPÇÕES DE PASTAS

Ex:

Clique na Aba Modo de Exibição

Ex:

Procure a opção: Ocultar arquivos protegidos do sistema operacional (recomendado) e desmarque, irá aparecer uma mensagem clique em SIM.

Ex:

Agora procure a opção Mostrar Pastas e arquivos ocultos e marque-a.

E em seguida clique em OK

Ex:

Perceba agora que tudo que estava escondido apareceu no pendrive:

Ex:

Bom, agora que já sabemos como os vírus modificam os atributos das pastas, vamos aprender como remover os tais atributos:

1° ainda dentro do pront digite: ATTRIB –S –H /D /S e tecle ENTER

Ex:

2° Vá a seu pendrive e dê uma olhada, perceba que as pastas e arquivos voltaram ao normal:

Sempre que seu pendrive estiver com as pastas ocultas execute esse procedimento para alterar os atributos.

Até a próxima.

OBS: depois de terminar este procedimento marque novamente a opção de ocultar arquivos protegidos do sistema.

Super Keylogger - Keen eye | v. 2.1

2011-11-02T12:39:00.007-03:00

Muitas vezes você quer garantir a segurança de seus filhos, saber o que eles estão fazendo no computador enquanto você não está olhando, ou até mesmo você quer saber o que seus funcionários andam fazendo, e quem sabe deseja apenas garantir a segurança de seu computador, seja qual for o motivo nós estamos fornecendo um Keylogger de monitoramento, saiba tudo que é digitado, todas as URLs visitadas, janelas abertas, processos activos, conversas realizadas e muito mais... tudo isso 100% invisível.

O keylogger é de facíl instalação e requer apenas conhecimentos básicos de computação, apenas com alguns cliques você terá todo o controle sobre seu ou seus computadores.

Veja algumas funcionalidades do Keylogger:

Monitoramento 24 horas por dia 7 dias por semana.
Logs recebidos por emai.
Captura de todas as teclas digitadas.
Captura de todas as janelas abertas.
Informações com data e hora.
Logs recebidos com o nome do computador e o usuário logado no momento.
Criptografia de logs.
Captura de todas as janelas acessadas no windows.
Captura de todos os emails de conversas realizadas pelo MSN.
Captura do teclado virtual do windows.
Envio de logs via SMTP(email) ou FTP(servidor remoto).

Veja algumas Telas:

_______________________________________________

Adquira agora mesmo o serviço de monitoramento ProgMaster:(50,00 $)

Adquira o Super Keylogger + código fonte: (200,00 $)

FastScanner - ProgMaster

2011-10-30T11:49:00.001-03:00

Portas abertas podem significar uma falha de segurança em servidores da sua empresa e até mesmo em seu computador pessoal. Os Hackers estão sempre de olho em serviços com alguma falha que possa ser explorada por eles. O FastScanner - ProgMaster verifica o status das portas de computadores da sua rede ou da Internet, permitindo que você descubra portas que estão abertas sem necessidade.

O programa, além de leve, é fácil de usar. Não possui complicações, basta escolher o IP e as portas a serem escaneadas que ele exibe uma lista com o status de cada uma.

Clique aqui para Download

Escrevendo em arquivos de texto no delphi.

2011-10-15T12:58:00.001-03:00

Existem vários métodos em Delphi para gravar arquivos texto a partir de informações gravadas em bases de dados ou para ler arquivos texto e armazená-los em bases de dados.

Esta dica apresenta dois destes métodos: o uso de TextFiles e da classe TStringList.

Primeiro vamos usar o TextFiles ...

TextFile é um tipo de dado pré-definido no Delphi e corresponde ao tipo Text do Turbo Pascal e do Object Pascal.

Inicialmente para acessar um arquivo de texto, você precisa definir uma variável tipo TextFile, no local que você achar mais apropriado, da seguinte forma:

Var

F : TextFile;

Exemplo do uso do TextFile, siga os passos abaixo:

1° - Abra o Delphi.
2° - Insira um botão.
3° - Altere o Caption do botão para escrever texto com TextFile.
4° - Salve o projeto com o nome de ExemploProgmaster.dpr em uma pasta de sua escolha.
5° - Adicione uma variavel global logo abaixo de {$R *.dfm} da seguinte foma:
var F:Textfile;

6° - No evento OnClick do button1 adicione o seguinte código:

ssignfile(F,'log.txt');
        if not FileExists('log.txt') Then
        begin
            Rewrite(F);
            Closefile(F);
        End
        Else
            Assignfile(F,'log.txt');
        {$I-}
        Append(F);
        {$I+}
        If IOResult<> 0 Then
        Begin
            ShowMessage('-');
        End;
        Write(F,'Progmaster: Exemplo de como usar o TextFiles.');
        Closefile(F);

Download do exemplo acima

Agora vamos usar a Classe TStringList ...

Siga os passos abaixo:

1° Abra seu Delphi.
2° Insira um botão.
3° No Evento Onclick do Button adicione o seguinte código:

var

  Texto: TStringList;

begin

  Texto := TStringList.Create;

  try

    Texto.Add('Linha 1');

    Texto.Add('Linha 2');

    Texto.SaveToFile('c:\testeProgmaster.txt');

  finally

    Texto.Free;

  end;

end;

Download do exemplo acima

FBI rat. baseado no Aryan rat 0.5. by albinoskunk.

2011-09-13T09:10:00.002-03:00

Olá.

    Alguns de vocês podem ter visto o Aryan v0.5 bem, eu estou reescrevendo tudo, no caminho eu tenho adicionado algumas novas funcionalidades, melhora na estabilidade, acrescentou a criptografia para o transporte de dados e incluído injecção no navegador padrão.

F.B.I RAT (Integração Backdoor Full) V0.1

    Suporta xp / Vista / Windows 7, todos os recursos foram testados em injecção, incluindo esses OS, mas houve algumas limitações sobre o sniffer.

Características:

    Gerenciador de Arquivos:
    -Execute, Normal e Escondido.
    -Copiar e Colar, como o Windows Explorer.
    -Display tamanho do arquivo e o tipo.
    -Delete.
    -Download & Upload (re-coded) Multi-threaded downloads, que permite que você baixe vários arquivos de uma vez.
    -Stop, Pause e retomar a transferência de ativos.
    -Busca de arquivos.
    -Renomear arquivos.

System Manager:
    -Process Manager - Atualizar os processos em execução e pode dar kill
    -Window Manager - Atualizar e fecha janelas, mostra janelas escondidas e visíveis.
    -Programas Instalados - Nome da lista do programa e do diretório.
    -Serviços Instalados - Lista dos serviços instalados, permite parar, iniciar e pausar serviços.

    Keylogger:
    -Permite que o usuário tenha um tempo e data da janela ativa, bem como a codificação de cores personalizadas.
    -Usa um gancho de teclado, por isso não caiu como a maioria das chaves keyloggers, e 0 uso da CPU.
    -Offline keylogs e on-line, off-line são keylogs baixado uma vez que você iniciar o keylogger Online, e uma vez que a sessão tenha terminado keylogger on-line, o keylogger off-line começa novamente.

    Captura de tela:
    -Reworked transferência e captura.
    -Permite ao usuário selecionar a qualidade, a intervalos de capturas de tela e Stop & Start de captura de tela.

    Webcam:
    -Reworked transferência e captura.
    -Permite ao usuário parar e começar a captura, também permite um intervalo para o envio de captura.

    Packet Sniffer:
    - "Stat Net" Permite ao usuário visualizar as conexões locais no computador, e então selecionar qual conexão que você deseja usar o sniff, displays IP do servidor remoto e informações de IP e porta local, também o estado da conexão, toda esta informação vem da TCP pilha de janelas.
    -Packet sniffer, fareja os pacotes, utilizando sockets janelas e formatos RAW-los em texto para você ler, eu testei isso com sites do mundo real, e permitiu-me a roubar informações, como logins de site, mas devido às limitações do Vista e Windows 7, é provável que não vai funcionar, para aqueles dois sistemas operacionais.

    Escolha de injeção, Esta fonte vem com um outro projeto que permite injetar seu servidor para o browser padrão da Vítima, você também pode usar o exe e executá-lo normalmente, sem injeção, para testes, o código de injeção foi modificado de um velho fonte que eu encontrei, eu tirei a fonte tentei melhorá-la, tornou detectar o navegador padrão e tornou-carga da API indiretamente, assim você pode criptografar as cordas API, e ignorar AV.

Download Link: http://www.megaupload.com/?d=ROHUUZO7

-Thanks

Download

Ruby 1.9.2 download

2011-09-02T12:36:00.001-03:00

Ruby 1.9.2-p290 está disponível.
Esta versão não inclui a correcção de nenhuma vulnerabilidade de segurança, no entanto foram corrigidos muitos bugs.

Downloads

http://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.2-p290.tar.bz2

TAMANHO:

8811237 bytes

MD5:

096758c3e853b839dc980b183227b182

SHA256:

403b3093fbe8a08dc69c269753b8c6e7bd8f87fb79a7dd7d676913efe7642487
http://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.2-p290.tar.gz

TAMANHO:

11182217 bytes

MD5:

604da71839a6ae02b5b5b5e1b792d5eb

SHA256:

1cc817575c4944d3d78959024320ed1d5b7c2b4931a855772dacad7c3f6ebd7e
http://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.2-p290.zip

TAMANHO:

12600100 bytes

MD5:

6060b410aa15d09ac13b93033b8b5c66

SHA256:

bce3d1c8c78fbafb6a0d67df2b8dec5322301f7b4b0f7594656ad689e9cb461d

Ruby (linguagem de programação)

2011-09-02T12:34:00.000-03:00

Ruby é uma linguagem de programação interpretada multiparadigma, de tipagem dinâmica e forte, com gerenciamento de memória automático, originalmente planejada e desenvolvida no Japão em 1995, por Yukihiro "Matz" Matsumoto, para ser usada como linguagem de script. Matz queria uma linguagem de script que fosse mais poderosa do que Perl, e mais orientada a objetos do que Python.^[1] Ruby suporta programação funcional, orientada a objetos, imperativa e reflexiva. Foi inspirada principalmente por Python, Perl, Smalltalk, Eiffel, Ada e Lisp, sendo muito similar em vários aspectos a Python. Atualmente, Ruby é a 12º linguagem de programação mais popular do mundo, de acordo com o Índice Tiobe.

A implementação 1.8.7 padrão é escrita em C, como uma linguagem de programação de único passe. Não há qualquer especificação da linguagem, assim a implementação original é considerada de fato uma referência. Atualmente, há várias implementações alternativas da linguagem, incluindo YARV, JRuby, Rubinius, IronRuby, MacRuby e HotRuby, cada qual com uma abordagem diferente, com IronRuby, JRuby e MacRuby fornecendo compilação Just-In-Time e, JRubye MacRuby também fornecendo compilação Ahead-Of-Time. A série 1.9 usa YARV (Yet Another Ruby VirtualMachine), como também a 2.0 (em desenvolvimento), substituindo a lenta Ruby MRI (Matz's Ruby Interpreter).

História

Yukihiro Matsumoto, criador da linguagem Ruby

A linguagem Ruby foi concebida em 24 de fevereiro de 1993 por Yukihiro Matsumoto, que pretendia criar uma nova linguagem que balanceava programação funcional com a programação imperativa. Matsumoto afirmou: "Eu queria uma linguagem de script que fosse mais poderosa do que Perl, e mais orientada a objetos do que Python. É por isso que eu decidi desenvolver minha própria linguagem.".
Após o lançamento do Ruby 1.3 em 1999, iniciou-se a primeira lista de discussão em inglês chamada Ruby-Talk, marcando um interesse crescente na linguagem fora do Japão. Em setembro de 2000, o primeiro livro em inglês, Programming Ruby, foi impresso, sendo mais tarde liberado gratuitamente para o público, ajudando no processo de adoção de Ruby por falantes do inglês.
Por volta de 2005, o interesse pela linguagem Ruby subiu em conjunto com o Ruby on Rails, um framework de aplicações web popular escrito em Ruby. Rails é frequentemente creditada como a aplicação que tornou Ruby "famosa" e a associação é tão forte que ambos são muitas vezes confundidos por programadores que são novos a Ruby.

Etimologia do nome "Ruby"

O nome "Ruby", foi decidido durante uma sessão de bate-papo online entre Matsumoto (Matz) e Keiju Ishitsuka em 24 de fevereiro de 1993, antes que qualquer linha de código tivesse sido escrita para a linguagem. Inicialmente foram propostos dois nomes: "Coral" e "Ruby", sendo esse último nome proposto escolhido mais tarde por Matz em um e-mail para Ishitsuka. Matsumoto explicou mais tarde que o motivo de ter escolhido o nome "Ruby" foi porque essa era a pedra zodiacal de um de seus colegas.

Características

Uma série de características foram definidas para atender às propostas do Ruby:

Todas as variáveis são objetos, onde até os "tipos primitivos" (tais como inteiro, real, entre outros) são classes
Métodos de geração de código em tempo real, como os "attribute accessors"
Através do RubyGems, é possível instalar e atualizar bibliotecas com uma linha de comando, de maneira similar ao APT do Debian Linux
Code blocks (blocos de código) passados como parâmetros para métodos; permite a criação de closures
Mixins, uma forma de emular a herança múltipla
Tipagem dinâmica, mas forte. Isso significa que todas as variáveis devem ter um tipo (fazer parte de uma classe), mas a classe pode ser alterada dinamicamente

Ruby está disponível para diversas plataformas, como Microsoft Windows, Linux, Solaris e Mac OS X, além de também ser executável em cima da máquina virtual Java (através do JRuby) e haver um projeto para ser executável em cima da máquina virtual Microsoft .NET, o IronRuby.

Tipos de dados

Não existem "tipos primitivos" em Ruby; todos os tipos são classes:

Object é a classe mãe de todas as outras classes em Ruby
- Numeric é uma classe abstrata que representa números
  - Integer é uma classe que representa números inteiros
    - Fixnum representa números inteiros de precisão fixa
    - Bignum representa números inteiros de precisão infinita, dependente apenas da memória disponível
  - Float é uma classe que representa números de ponto flutuante (números reais)
- String uma cadeia de caracteres. Pode ser delimitado por apóstrofes (') ou aspas ("). Tudo o que há entre apóstrofes é interpretado literalmente, entre aspas o programador deve se utilizar de símbolos para representar caracteres específicos, como em C. Exemplos: 'azul', "a\nb\nc"
- Symbol é semelhante a uma string, mas dois símbolos iguais possuem o mesmo endereço de memória, sendo assim é ótimo para se utilizar como índice numa Hash. Porém, devido à sua natureza, o coletor de lixo do Ruby não os elimina. É definido com um sinal de dois pontos (:), por exemplo, :nome
- Array são arrays dinâmicos, que podem ser usados para representar matrizes e vetores. É delimitado por colchetes ([]) e cada valor é separado por vírgula. Exemplo: [4, 'azul', :termometro]
- Hash representa um vetor associativo, e, assim como as Arrays, é dinâmica. É delimitada por chaves ({}), e o índice precede o valor com um sinal '=>'. Exemplo: {:controller => 'user', :action => 'index'}. Qualquer objeto pode ser um índice, mas os mais usados são as Strings e os Symbols
- Regexp representa expressões regulares, delimitadas por //. Funciona de forma semelhante a Perl. Exemplo: /a|ae/

Declaração de variáveis

Um objeto em Ruby é declarado com uma atribuição comum:

var1 = 2
var2 = Classe.new
var3 = Classe2.new(parametro)

Uma variável local é declarada normalmente. Uma variável de instância é declarada com um "@" no nome. Uma variável de classe é declarada com "@@", e uma variável global é declarada com "$". Variáveis que iniciam com uma letra maiúscula são consideradas constantes.

local = "local"
@instancia = 42
@@classe = /f+/
$Pi = 3.1415926

Exemplos de código

Programa Olá Mundo

puts "Olá, Mundo!"

Strings

Há uma variedade de métodos para definir strings em Ruby. As definições a seguir são equivalentes e suportam interpolação:

a = "\nIsto é uma string de aspas duplas\n"
a = %Q{\nIsto é uma string de aspas duplas\n}
a = %{\nIsto é uma string de aspas duplas\n}
a = %/\nIsto é uma string de aspas duplas\n/
a = <

O código a seguir define duas strings "cruas" que são equivalentes:

a = 'Isto é uma string de aspas simples'
a = %q{Isto é uma string de aspas simples}

Coleções

Array

a = [1, 'oi', 3.14, 1, 2, [4, 5]]
 
a[2]                      # => 3.14
a.reverse                 # => [[4, 5], 2, 1, 3.14, 'oi', 1]
a.flatten.uniq            # => [1, 'oi', 3.14, 2, 4, 5]
a.push(23)                # a = [1, 'oi', 3.14, 1, 2, [4, 5], 23]
a << 22                   # a = [1, 'oi', 3.14, 1, 2, [4, 5], 23, 22]

Hash

hash = {'água' => 'molhada', 'fogo' => 'quente'}
puts hash['fogo'] # "quente"
 
hash.each_pair do |chave, valor|
  puts "#{chave} é #{valor}"
end
 
# Imprime:
 
# água é molhada
# fogo é quente
 
hash.delete_if {|chave, valor| chave == 'água'} # Apaga 'água' => 'molhada'

Blocos e iteradores

Blocos de código (ou code blocks) são trechos de código que são passados como parâmetros para métodos. Blocos são extremamente usados em Ruby.

class Paises
  @paises = ["Argentina", "Brasil", "Paraguai", "Uruguai"]
 
  def self.each
    for pais in @paises
      yield pais
    end
  end
end
 
Paises.each do |pais|
  puts "Olá, #{pais}!"
end

Iterando em arrays usando blocos:

array = [1, 'oi', 3.14]
 
array.each do |item|
  puts item
end
# => 1
# => 'oi'
# => 3.14
 
# Equivalente, usando chaves:
array.each { |item|
  puts item
}
# => 1
# => 'oi'
# => 3.14

Em Ruby, a estrutura de repetição for é apenas açúcar sintático para acessar o método each, existente em iteratores.

array = [1, 'oi', 3.14]
 
for item in array
  puts item
end
 
# => 1
# => 'oi'
# => 3.14

Blocos funcionam com muitos métodos padrão; no exemplo a seguir, o uso de blocos com arquivos:

File.open('arquivo.txt', 'w') do |arquivo|
  for i in (1..3) do
    arquivo.puts 'Olá, Mundo!'
  end
end                                  # O arquivo é fechado automaticamente aqui
 
File.readlines('arquivo.txt').each do |linha|
  puts linha
end
 
# => Olá, Mundo!
# => Olá, Mundo!
# => Olá, Mundo!

Criando uma função anônima:

proc {|arg| print arg}
Proc.new {|arg| print arg}
lambda {|arg| print arg}

Classes

O código a seguir define uma classe chamada Pessoa. Além de initialize, o construtor para criar novos objetos, essa classe tem dois métodos: um que sobre-escreve o operador de comparação > (maior), e sobre-escreve o método to_s (assim o comando puts pode formatar a saída). Aqui attr_reader é um exemplo de metaprogramação em Ruby: attr_reader define o método getter, attr_writer define o método setter, e attr_accessor define ambos. Em Ruby, todos os atributos são privados e todos os métodos públicos, por padrão. Ruby permite definir opcionalmente o tipo de acesso usando três palavras-chave: public (público), private (privado) e protected (protegido). Ruby não suporta sobrecarga de métodos, mas suporta argumentos padrão, que podem ser utilizados para o mesmo fim. Também, o último comando em um método é considerado o seu valor de retorno, permitindo a omissão de um explícito return.

class Pessoa
  attr_reader :nome, :idade
 
  def initialize(nome = "Desconhecido", idade)
    @nome, @idade = nome, idade
  end
 
  def >(pessoa)
    if self.idade > pessoa.idade
      return true
    else
      return false
    end
  end
 
  def to_s # Método usado pelo método puts() para formatar a saída
    "#@nome (#@idade anos)"
  end
end
 
pessoas = [
            Pessoa.new("Ricardo", 19),
            Pessoa.new(idade = 25)
          ]
 
puts pessoas[0]
puts pessoas[1]
puts pessoas[0] > pessoas[1] # O mesmo que: pessoas[0].>(pessoas[1])

O código acima irá imprimir:

Ricardo (19 anos)
Desconhecido (25 anos)
false

Classes abertas

Em Ruby, as classes nunca são fechadas: você pode sempre adicionar novos métodos a uma classe. Isso se aplica tanto para classes criadas por você, quanto para as classes padrão. Um exemplo simples de adição de um novo método a classe padrão String:

class String
  def iniciais
    ini = String.new
 
    for nome in self.split do
      ini += nome[0]
    end
 
    return ini
  end
end
 
puts "Ricardo Silva Veloso".iniciais # Imprime RSV

Herança

Ruby não suporta herança múltipla. Ao invés disso, Ruby usa Mixins para emular herança múltipla:

class Pessoa < Mamifero # Herança de Mamifero
  include Humano # Emulando herança múltipla
end

No exemplo acima, "Humano" é um módulo (module).

Modules

Além das classes normais, Ruby possui os "Modules", que são classes de classes, permitindo espaço de nomes:

module Humano
  class Classe1
    def info
      "#{self.class} (\##{self.object_id}): #{self.to_s}"
    end
  end
end

Tratamento de exceções

Como a maioria das linguagens modernas, Ruby também possui suporte para tratamento de exceção. As palavras-chave para isto são "begin", "rescue" e "ensure". "Begin" inicia um trecho que pode cair em alguma exceção (opcional), "Rescue" determina o comportamento em caso de uma exceção específica ou não e, "Ensure" é o código que será executado independente de ter havido exceção ou não.

begin
# Faça algo
rescue
# Trata alguma exceção
else
# Faça isto se nehuma exceção for lançada
ensure
# Faça isto se alguma ou nenhuma exceção for lançada
end

Ruby para administradores de sistemas

A maioria dos administradores de sistemas Unix utilizam Perl ou Shell Script como ferramenta para resolver os problemas. Mas é possível usar Ruby e Python para os mesmos fins. Abaixo, a idéia é fazer um pequeno script que verifica se o serviço da porta 80 (Web) de alguns servidores estavam ativos.

require 'net/http'
 
File.open("hosts.txt", "r").each_line do | host |
 
  conexao = Net::HTTP.new(host.chomp, 80)
  resposta, conteudo = conexao.get("/", nil)
 
  if resposta.code.to_i > 400
  # aqui vai a rotina pra enviar email...
  end
end

Repositórios e bibliotecas

Ruby possui repositórios de bibliotecas disponíveis em sites como Ruby Forge e Ruby Application Archive (RAA). Existe, ainda, uma ferramenta de instalação de bibliotecas, chamada RubyGems, semelhante aos gerenciadores de pacotes do Linux, como o APT. O projeto mais famoso desenvolvido em Ruby é o meta-framework Ruby on Rails.
Recentemente, muitas bibliotecas novas e existentes foram hospedadas no GitHub, que é focado em Git e tinha suporte nativo ao empacotamento do RubyGems.

2011-08-29T08:04:00.004-03:00

Smac - Programa que altera o MAC de sua placa de rede.

Link para download aqui => Download

Muito útil e bom.

Serial Incluso.

Wireshark download

2011-08-24T23:35:00.001-03:00

"Wireshark é uma Poderosa ferramenta para análise de protocolos”

O Wireshark é uma ferramenta profissional que auxilia quem precisa resolver problemas de conexão e rede. O aplicativo disponibiliza diversas informações para fazer uma análise apurada.
Analisar pacote de dados enviados e recebidos é uma forma de monitorar possíveis problemas com a conexão. Do mesmo jeito também é possível detectar o tráfego na rede. Mas como é que se pode controlar tais pacotes?
Todas as principais ferramentas para análise de dados estão presentes no Wireshark. O Wireshark oferece informações sobre a placa de rede, Bluetooth, USB, Frame Relay e outras partes importantes da máquina (depende da plataforma usada). Por ser desenvolvido em código aberto, os desenvolvedores atualizam o Wireshark constantemente com melhoras e conserto de pequenos bugs.
Se você não conhece muito de protocolos e deseja se aprofundar no tema, o Wireshark possui um fórum bastante movimentado. Se já conhece de redes, mão na massa porque o Wireshark é uma ótima utilidade.

Prós

Grátis
Analisa centenas de protocolos
Multiplataforma

Contras

Não tem versão em português
Não recomendável para iniciantes
Requer conhecimentos de análise de protocolos

Download

C / C++ e Orientação a Objetos em Ambiente Multiplataforma

2011-08-17T00:27:00.000-03:00

Apostila muito completa e ilustrativa abordando a linguagem C e C++ com orientação a objetos

Download

Apostila com exemplos de árvores binárias

2011-08-17T00:19:00.000-03:00

Apostila com alguns exemplos de árvores binárias

Download

Apostila completa sobre C/C++ em português

2011-08-17T00:05:00.001-03:00

A linguagem C tornou-se uma das linguagens de programação mais usadas. Flexível, ainda que poderosa, a linguagem C tem sido utilizada na criação de alguns dos mais importantes produtos de software dos últimos anos. O C ou o C++ tem possibilidades quase que infinitas...

Leia mais na ProgMaster: Apostila completa sobre C/C++ em português

Download

Delphi com assembly (Parte 7)

2011-08-16T00:02:00.000-03:00

- Reproduzindo sons com o PC speaker

As instruções assembler IN e OUT permitem ler e escrever em uma porta de
E/S respectivamente.

Para ler de uma porta:

IN acumulador, porta

IN le um byte, word ou doubleword da porta especificada para o registro
acumulador, isto é, AL, AX, ou EAX para byte, word ou doubleword
respectivamente. O número de porta pode ser uma constante do tipo byte
(0..255) um o registro DX (para acesso a todas as portas de E/S).

Para escrever em uma porta:

OUT porta, acumulador

OUT escreve o byte, word ou doubleword no registro acumulador para a
porta especificada. Novamente, o número da porta pode ser uma constate
do tipo byte ou o valor do registro DX.

NOTA: Uma vez que IN e OUT implicam no acesso direto ao hardware, e
      sabendo que os Windows NT/2000/XP não permitem que aplicativos
      do usuário acessem o hardware diretamente, essas instruções não
      funcionarão (irão gerar exceções) nesses sistemas operacionais
      (a não ser que estejam rodando em modo protegido no anel 0, ou
      modo kernel).

Abaixo, veremos um exemplo do uso de assembler na leitura e escrita
às portas de E/S para programar os chips 8253/8254 Contador/Timer e
o 8255 Programmable Peripheral Interface (PPI) na placa-mãe de modo
a fazer o PC speaker reproduzir um som.

Os passos para tocar um som usando os chips são os seguintes:

1) Prepare os 8253/8254 para receber a freqüência. Isso é feito ao
   escrever o valor $B6 no Timer Control Register (porta $43).

2) Escrever a freqüência do som no Frequency Register do 8253/8254
   (porta $42). Na verdade, não é a freqüência em Hertz que devemos
   escrever no registro, mas o resultado de 1331000 dividido nesta
   freqüência. Primeiramente devemos escrever o byte de mais baixa
   ordem do resultado para, em seguida, o byte de mais alta ordem.

3) Ligar o PC speaker e fazê-lo utilizar o 8253/8254 Counter/Timer.
   Isso é feito ao definir os dois primeiros bits da Porta B do 8255
   PPI (porta $61).

4) Desligar o PC speaker quando o som finalizar. Isso é feito ao
   zerar o segundo bit da porta B do 8255 PPI (porta $61).

A função assembler inline abaixo implementa os passos listados acima:

procedure SpeakerSound(Frequency: word; Duration: longint);
// Copyright (c) 2003 Ernesto De Spirito
// Visit: http://www.latiumsoftware.com
// Plays a tone thru the PC speaker using the 8253/8254
// Counter/Timer chip and the 8255 Programmable Peripheral
// Interface (PPI) chip on the motherboard.
// NOTE: This code won't work under Windows NT/2000/XP.
asm
    push edx          // Push Duration on the stack (for Sleep)
    mov cx, ax        // CX := Frequency;
    // Prepare the 8253/8254 to receive the frequency data
    mov al, $B6       // Function: Expect frequency data
    out $43, al       // Write to Timer Control Register
    // Compute the frequency data
    mov dx, $14       // DX:AX = $144F38
    mov ax, $4F38     //       = 1331000
    div cx            // AX := 1331000 / Frequency;
    // Send the frequency data to the 8253/8254 Counter/Timer chip
    out $42, al       // Write low byte to the Frequency Address
    mov al, ah        // AL := High byte of AX
    out $42, al       // Write high byte to the Frequency Address
    // Tell the 8255 PPI to start the sound
    in al, $61        // Read Port B of the 8255 PPI
    or al, $03        // Set bits 0 and 1:
                      // bit 0 --> use the 8253/8254
                      // bit 1 --> turn speaker on
    out $61, al       // Write to Port B of the 8255 PPI
    // Wait
    call Sleep        // Sleep(Duration); // requires Windows unit
    // Tell the 8255 PPI to stop the sound
    in al, $61        // Read Port B of the 8255 PPI
    and al, NOT 2     // Clear bit 1 (turn speaker off)
    out $61, al       // Write to Port B of the 8255 PPI
end;

Exemplo de chamada:

procedure TForm1.Button1Click(Sender: TObject);
var
    i: integer;
begin
    Randomize;
    for i := 1 to 3 do
      SpeakerSound(Random(900)+100, 200);
end;

NOTA: Usar o PC speaker para gerar som é OBSOLETO. Aplicações devem usar
      sons MIDI ou WAVE ao invés.

Download dos sources

Delphi com assembly (Parte 6)

2011-08-15T23:40:00.000-03:00

Aritmética Inteira de 128 bits (3)

Nessa terceira e última parte da série sobre inteiros de 128-bit (que
chamamos de inteiros gigantes, inteiros enormes ou inteiros largos)
vamos finalmente lidar com a aritimética propriamente dita- as quatro
operações fundamenteais (adição, subtração, multiplicação e divisão).

Antes de iniciar, gostaria de avisar que as rotinas introduzidas nas
duas partes anteriores foram corrigidas e também otimizadas. Ainda
não pude testá-las tanto quanto gostarias. Se você encontrar erros ou
tiver algum comentário sobre os fontes, por favor me envie um e-mail.

Adição
======

Como somamos dois números, cada um formado de quatro inteiros de 32-bit?
Bem, é bem fácil. Simplesmente somamos como faríamos com dois números de
quatro dígitos decimais (como 3597 e 0015, por exemplo), exceto que cada
dígito aqui pode ter aproximadamente 4 bilhões (2^32) de valores
distintos ao invés de apenas dez. O algoritmo é algo como:

function AddWithCarry(x: Longint; y: Longint;
                        var Carry: Boolean): Longint; forward;

function HugeAdd(x: Hugeint; y: Hugeint): Hugeint;
// Result := x + y;
var
    Carry: Boolean;
begin
    Carry := False;
    Result[0] := AddWithCarry(x[0], y[0], Carry);
    Result[1] := AddWithCarry(x[1], y[1], Carry);
    Result[2] := AddWithCarry(x[2], y[2], Carry);
    Result[3] := AddWithCarry(x[3], y[3], Carry);
end;

AddWithCarry é uma função fictícia que retorna um inteiro com os 32 bits
de mais baixa ordem do resultado da adição dos dois argumentos, mais um
se Carry (o terceiro argumento) for True. A rotina também altera o valor
de Carry com True o False dependendo da adição ter gerado um excesso ou
não (ou se o carry é 1 ou 0, se você prefere ver dessa forma). Na
prática, essa função não precisa ser fictícia:

function AddWithCarry(x: Longint; y: Longint;
                        var Carry: Boolean): integer;
asm
    // if Carry then CF := 1 else CF := 0;
    test byte ptr [ecx], -1   // efeito colateral: CF := 0;
    jz @@NoCarry
    stc                       // CF := 1;
@@NoCarry:
    // Result := x + y + CF; CF := GeneratedCarry;
    adc eax, edx
    // Carry := CF;
    setc byte ptr [ecx]
end;

É mais eficiente codificar HugeAdd inteiramente em assembler:

function HugeAdd(x: Hugeint; y: Hugeint): Hugeint;
// Result := x + y;
// Parameters: EAX = @x; EDX = @y; ECX = @Result
asm
    push esi

    mov esi, [eax+_0_]     // ESI := x[0];
    add esi, [edx+_0_]     // ESI := ESI + y[0];
    mov [ecx+_0_], esi     // Result[0] := ESI;

    mov esi, [eax+_1_]     // ESI := x[1];
    adc esi, [edx+_1_]     // ESI := ESI + y[1] + Carry;
    mov [ecx+_1_], esi     // Result[1] := ESI;

    mov esi, [eax+_2_]     // ESI := x[2];
    adc esi, [edx+_2_]     // ESI := ESI + y[2] + Carry;
    mov [ecx+_2_], esi     // Result[2] := ESI;

    mov esi, [eax+_3_]     // ESI := x[3];
    adc esi, [edx+_3_]     // ESI := ESI + y[3] + Carry;
    mov [ecx+_3_], esi     // Result[3] := ESI;

    pop esi
end;

Subtração
=========

A subtração acontece de forma semelhante à adição mas, ao invés de gerar
um excesso, a operação gera um "empréstimo" (também representado pelo
flag Carry) se o minuendo (primeiro operando) é menor que o subtraendo
(segundo operando):

function SubtractWithBorrow(x: Longint; y: Longint;
                              var Borrow: Boolean): Longint; forward;

function HugeSub(x: Hugeint; y: Hugeint): Hugeint;
// Result := x - y;
var
    Borrow: Boolean;
begin
    Borrow := False;
    Result[0] := SubtractWithBorrow(x[0], y[0], Borrow);
    Result[1] := SubtractWithBorrow(x[1], y[1], Borrow);
    Result[2] := SubtractWithBorrow(x[2], y[2], Borrow);
    Result[3] := SubtractWithBorrow(x[3], y[3], Borrow);
end;

function SubtractWithBorrow(x: Longint; y: Longint;
                              var Borrow: Boolean): Longint;
asm
    // if Borrow then CF := 1 else CF := 0;
    test byte ptr [ecx], -1   // Side-effect: CF := 0;
    jz @@NoBorrow
    stc                       // CF := 1;
@@NoBorrow:
    // Result := x - y - CF; CF := NeededBorrow;
    sbb eax, edx
    // Borrow := CF;
    setc byte ptr [ecx]
end;

Você deve estar pronto para escrever uma versão de HugeSub inteiramente
em assembler já que é análoga à HugeAdd; tudo que você deverá fazer é
substituir ADD e ADC com SUB e SBB respectivamente.

Número Oposto
=============

Dado um número, essas implementações de HugeNeg retornam seu oposto
(complemento de dois):

function HugeNeg(x: Hugeint): Hugeint;
begin
    // Result := (Not x) + 1;
    Result := HugeAdd(HugeNot(x), IntToHuge(1));
end;

function HugeNeg(x: Hugeint): Hugeint;
begin
    // Result := 0 - x;
    Result := HugeSub(IntToHuge(0), x);
end;

A segunda é mais simples e rápida pois involve uma operação apenas e, já
que sabemos subtrair, podemos implementá-la em assembler:

function HugeNeg(x: Hugeint): Hugeint;
// Result := -x;
// Parameters: EAX = @x; EDX = @Result
asm
    // Result := 0 - x;
    push esi
    xor esi, esi
    mov ecx, [eax+_0_]     // x[0]
    sub esi, ecx           // 0 - x[0]
    mov ecx, 0
    mov [edx+_0_], esi     // Result[0]
    mov esi, [eax+_1_]     // x[1]
    sbb ecx, esi           // 0 - x[1] - Borrow
    mov esi, 0
    mov [edx+_1_], ecx     // Result[1]
    mov ecx, [eax+_2_]     // x[2]
    sbb esi, ecx           // 0 - x[2] - Borrow
    mov ecx, 0
    mov [edx+_2_], esi     // Result[2]
    mov esi, [eax+_3_]     // x[3]
    sbb ecx, esi           // 0 - x[3] - Borrow
    mov [edx+_3_], ecx     // Result[3]
    pop esi
end;

Multiplicação
=============

Uma forma de multiplicar números é através de um laço de adições:

function HugeMul(x: Hugeint; y: Hugeint): Hugeint;
begin
    SetZero(Result);
    while not HugeIsZero(y) do begin
      Result := HugeAdd(Result, x);
      HugeSub(y, 1)
    end;
end;

Em termos computacionais, esse algoritmo é bastante pobre. Por exemplo,
se o valor de "y" for 4 milhões, o laço se repetiria 4 milhões de vezes!
De qualquer forma, a idéia ainda é boa se pudéssemos de alguma forma
acelerar o processo. Vamos então brincar um pouco com álgebra de bits:

x * y = x * (y[3]*2^96 + y[2]*2^64 + y[1]*2^32 + y[0]*2^0)
        = (x*y[3])*2^96 + (x*y[2])*2^64 + (x*y[1])*2^32 + (x*y[0])*2^0

Agora nós reduzimos o problema de multiplicar dois inteiros gigantes
ao de multiplicar um inteiro gigante por um inteiro de 32-bit. Quando
multiplicamos o primeiro operando pelos quatro inteiros que compõem o
segundo operando, então deslocamos os resultados parciais por 0, 32,
64 e 96 bits (multiplicação por 2^0, 2^32, 2^64 e 2^96) e finalmente
somamos esses valores para obter o resultado final.

function HugeMulInt(x: Hugeint; y: Longint): Hugeint; forward;

function HugeMul(x: Hugeint; y: Hugeint): Hugeint;
begin
    Result := HugeShl(HugeMulInt(x, y[3]), 96)
            + HugeShl(HugeMulInt(x, y[2]), 64)
            + HugeShl(HugeMulInt(x, y[1]), 32)
            +         HugeMulInt(x, y[0]);
end;

Essa é a exata forma que multiplicamos números decimais quando usamos
papel, exceto que aqui a base é 2^32 ao invés de dez. Vejamos como
multiplicar um inteiro gigante por um inteiro:

function MultiplyWithCarry(x: Longint; y: Longint;
                             var Carry: Longint): Longint; forward;

function HugeMulInt(x: Hugeint; y: Longint): Hugeint;
// Result := x * y;
var
    Carry: Longint;
begin
    Carry := 0;
    Result[0] := MultiplyWithCarry(x[0], y, Carry);
    Result[1] := MultiplyWithCarry(x[1], y, Carry);
    Result[2] := MultiplyWithCarry(x[2], y, Carry);
    Result[3] := MultiplyWithCarry(x[3], y, Carry);
end;

function MultiplyWithCarry(x: Longint; y: Longint;
                             var Carry: Longint): integer;
// Result := LoDWord(x * y + Carry);
// Carry := HiDWord(x * y + Carry);
asm
    // EDX:EAX := EAX * EDX; // x * y
    mul edx
    // Inc(EDX:EAX, Carry);
    add eax, [ecx]
    adc edx, 0
    // Carry := EDX;          // High order 32 bits of the result
    mov [ecx], edx;
end;

MultiplyWithCarry é muito semelhante a AddWithCarry mas realiza uma
multiplicação ao invés de uma adição, e gera um excesso de 32-bit ao
invés de um bit apenas (a multiplicação de dois valores de 32-bit gera
um valor de 64-bit enquanto sua soma gera um valor de 33-bit).

MultiplyWithCarry primeiramente realiza a multiplicação sem sinal de
"x" (EAX) por "y" (EDX), usando o opcode MUL. O resultado de 64-bit
é um inteiro sem sinal contido em EDX:EAX, ao qual a função soma o
valor do parâmetro Carry. A função retorna os 32 bits mais baixos do
resultado final (localizado em EAX) e os 32 bits mais altos (EDX)
constituem o excesso para a próxima multiplicação, que é armazenado
no parâmetro Carry (passado por referência).

Uma implementação em assembler de HugeMul e HugeMulInt encontra-se no
código em anexo. Por razões de simplificação, nos exemplos acima, as
funções consideram que os números não possuem sinais, mas o código
anexo considera os sinais. O código de HugeMul também não chama
HugeMulInt ou HugeShl e está bastante otimizado.

Ao invés de considerar um inteiro gigante como quatro inteiros de
32-bit, podemos considerá-lo como 128 inteiros de 1-bit multiplicados
por 128 potências de 2:

bit127 * 2^127 + bit126 * 2^126 + ... + bit1 * 2^1 + bit0 * 2^0

Como cada bit só pode ser 0 ou 1, o algoritmo acima pode ser muito
simplificado:

function HugeMul(x: Hugeint; y: Hugeint): Hugeint;
// Result := x * y;
var
    i: Longint;
begin
    SetZero(Result);
    for i := 0 to 127 do
      if BitTest(y, i) then
        Result := HugeAdd(Result, HugeShl(x, i));
end;

A idéia é somar diferentes potências de 2 de "x", dependendo essas
potências nos bits de "y". Por exemplo, se "y" for 20, os bits 5 e
3 estariam ligados (20 em decimal é 10100 em binário), de modo que
apenas duas adições são realizadas e o resultado é HugeShl(x, 3)
mais HugeShl(x, 5).

Esse algoritmo pode ser codificado de forma bastante eficiente em
assembler mas o primeiro algoritmo será ainda mais rápido. A razão de
mostrá-lo é que facilitará o entendimento do algoritmo que usaremos
para divisões.

Divisão
=======

Vamos primeiro ver o caso da divisão de um Hugeint por um inteiro de
32-bit, que deve ser fácil de entender:

function DivideWithRemainder(x: Longint; y: Longint;
                           var Remainder: Longint): Longint; forward;

function HugeDivInt(x: Hugeint; y: Longint): Hugeint;
// Result := x div y;
var
    Remainder: Longint;
begin
    Remainder := 0;
    Result[0] := DivideWithRemainder(x[3], y, Remainder);
    Result[1] := DivideWithRemainder(x[2], y, Remainder);
    Result[2] := DivideWithRemainder(x[1], y, Remainder);
    Result[3] := DivideWithRemainder(x[0], y, Remainder);
    asm
      mov edx, Remainder
    end;
end;

function DivideWithRemainder(x: Longint; y: Longint;
                               var Remainder: Longint): Longint;
// Result    := Remainder:x div y;
// Remainder := Remainder:x mod y;
asm
    push esi
    mov esi, edx         // y
    mov edx, [ecx]       // Remainder
    // EAX := EDX:EAX div ESI;
    // EDX := EDX:EAX mod ESI;
    div esi
    // Remainder := EDX;
    mov [ecx], edx;
    pop esi
end;

HugeDivInt deixa o resto da divisão em EDX, de modo que possa ser usado
em uma função que retorne o resto da divisão:

function HugeModInt(dividend: Hugeint; divisor: Longint): Longint;
// Result := dividend mod divisor;
// Parameters: EAX = @dividend; EDX = @divisor;
asm
    sub esp, TYPE(Hugeint) // Abrir espaço na pilha para um Hugeint
    mov ecx, esp           // com o resultado da divisão
    call HugeDivInt        // Realizar a divisão
    add esp, TYPE(Hugeint) // Restaurar o ponteiro da pilha
    mov eax, edx           // Result := Remainder;
                           // o resto foi deixado em EDX
end;

Para o caso de dois inteiros gigantes, temos que pensar no algoritmo que
usaríamos para dividir um número de quatro dígitos decimais no papel.
Mas esse procedimento é complexo e lento demais pois envolve além das
divisões, multiplicações, subtrações, antecipação de etapas, etc. Há
alternativa possível para o algoritmo? Sim:

function HugeDiv(dividend: Hugeint; divisor: Hugeint): Hugeint;
// Result := dividend div divisor;
begin
    if HugeIsZero(divisor) then
      raise EDivByZero.CreateRes(@sDivByZero);
    Result := 0;
    while HugeCmp(dividend, divisor) >= 0 do begin
      dividend := HugeSub(dividend, divisor);
      Result := HugeAdd(Result, IntToHuge(1));
    end;
end;

Claro, o algoritmo acaba sendo extremamente lento (se dividirmos
12 milhões por 3, o laço executará 4 milhões de vezes) mas podemos
acelerá-lo se subtrarimos do dividendo o divisor multiplicado por
diferentes potências de 2, da maior para a menor, definindo o bit
correspondente do resultado toda vez que efetuarmos a subtração (o
bit na posição da potência de 2 que foi usado). É o inverso do que
foi feito no caso da multiplicação acima. O processo de divisão seria
reduzido ao máximo de 128 subtrações.

No exemplo a seguir, o dividendo é 20 (10100 em binário) e o divisor
é 3 (11 em binário):

   10100 - 11 * 2^2 = 10100 - 1100 = 1000      Result := 100
    1000 - 11 * 2^1 = 1000 - 110 = 10        Result := 110

Inicialmente, 11 * 2^2 é o maior valor que é menor ou igual ao dividendo
então subtraímos esse valor do dividendo e definimos o bit 2 do
resultado pois subtraímos o divisor multiplicado por 2^2. Até o momento,
o resto da divisão é 8 (1000 em binário) e 11 * 2^1 é o maior valor que
é menor ou igual ao resto. Então subtraímos esse valor do resto e
definimos o bit 1 do resultado pois subtraímos o divisor multiplicado
por 2^1. O resto agora é 2 (10 em binátio) e como o divisor é maior que
esse valor, a divisão é interrompida. O resto da operação seria 2 (10 em
binário) e, como os bits 2 e 1 do resultado estão marcados, o resultado
é 110 em binário, ou 6 em notação decimal.

function HugeDiv(dividend: Hugeint; divisor: Hugeint): Hugeint;
var
    _r_: Hugeint; // remainder
    _d_: Hugeint; // divisor
    _q_: Hugeint; // quotient
    BitPosR, BitPosD, count: integer;
begin
    _r_ := dividend;
    _d_ := divisor;
    HugeSetZero(_q_);
    BitPosD := HugeBitScanReverse(_d_);
    if BitPosD = -1 then RaiseDivByZero;
    BitPosR := HugeBitScanReverse(_r_);
    count := BitPosD - BitPosR;
    if count > 0 then
      _d_ := HugeShl(_d_, count);
    repeat
      if HugeCmp(_d_, _r_) <= 0 then begin
        _r_ := HugeSub(_r_, _d_);
        HugeBitSet(_q_, count);
      end;
      _d_ := HugeShr(_d_, 1);
      dec(count);
    until count < 0;
    Result := _q_;
    asm
      lea edx, _r_
    end;
end;

HugeBitScanReverse é a função que retorna a posição do primeiro bit não
zero, realizando a busca a partir do bit 127 até o bit 0. Se todos os
bits são zero, o resultado é -1. Usamos HugeBitScanReverse para
determinar a primeira potência de dois que devemos multiplicar o divisor
para iniciar a divisão.

A implementação em assembler de HugeDiv no código anexo suporta inteiros
com sinais. É apenas uma primeira aproximação que pode ainda ser muito
melhorada.

A função deixa em EDX o endereço do resto de modo que ele possa ser
usado por uma função que retorna o módulo da divisão:

function HugeMod(dividend: Hugeint; divisor: Hugeint): Hugeint;
// Result := dividend Mod divisor;
// Parameters: EAX = @dividend; EDX = @divisor; ECX = @Result
asm
    push ecx              // @Result
    call HugeDiv          // EDX := @remainder;
    pop eax               // EAX := @Result;
    call HugeMov          // EAX^ := EDX^;
end;

Delphi com assembly (Parte 5)

2011-08-15T23:39:00.000-03:00

-Aritmética Inteira de 128 bits (2)
==================================

No código-fonte exemplo (anexado) você encontrará a implementação de
algumas funções para operações com o tipo Hugeint que foi introduzido no
artigo passado. A proposta é exemplificar as instruções que nós vimos há
muito tempo com algumas novas:

BT (Bit Test):

    BT dword ptr [eax], edx   --> CF = valor do EDX-ésimo bit na
                                       memória apontada por EAX

BTS (Bit Test and Set):

    BTS dword ptr [eax], edx --> atribui 1 para o EDX-ésimo bit na
                                  memória apontado por EAX
                                  CF = valor anterior deste bit

BTR (Bit Test and Reset):

    BTR dword ptr [eax], edx --> atribui 0 para o EDX-ésimo bit na
                                  memória apontado por EAX
                                  CF = valor anterior deste bit

BTC (Bit Test and Complement):

    BTC dword ptr [eax], edx --> inverte o valor do EDX-ésimo bit na
                                  memória apontada por EAX
                                  CF = valor anterior deste bit

Não reproduziremos as funções aqui, uma vez que você pode encontrá-los
no código-fonte anexo, mas mostraremos diferentes implementações da
função _IsNeg, simplesmente apresentando mais exemplos das instruções
que vimos tempos atrás:

function _IsNeg(x: Hugeint): boolean;
// Resultado := x < 0;
// Se x < 0 retorna True (1) senão retorna False (0)
// Parâmetros: EAX = @x
asm
    mov eax, [eax+_3_] // EAX := 32 bits de alta ordem de x
    shr eax, 31         // AL := Bit de alta ordem de EAX (sign bit)
end;

function _IsNeg(x: Hugeint): boolean;
asm
    cmp dword ptr [eax+_3_], 0   //   if x[3] < 0 then
    jl @@negative                //     goto @@negative
    mov al, 0                    //   Result := False;
    ret                          //   exit;
@@negative:                    // @@negative:
    mov al, 1                    //   Result := True;
end;

function _IsNeg(x: Hugeint): boolean;
asm
    // atribuir o Sign Flag e colocá-lo em AL
    mov eax, [eax+_3_] // EAX := 32 bits de alta ordem de x
    or eax, eax         // SF := Sign bit de EAX
                        // alt.: add eax, 0
                        //   ou: sub eax, 0
                        //   ou: and eax, eax
                        //   ou: and eax, -1   // ou qq valor negativo
                        //   ou: test eax, eax
                        //   ou: test eax, -1 // ou qq valor negativo
    sets al             // AL := SF; // Sign Flag
                        // alt.: lahf; shr ax, 31
                        //   ou: lahf; rol ax, 1; and al, $1
end;

function _IsNeg(x: Hugeint): boolean;
asm
    // atribui o Carry Flag com o Sign Bit e colocá-lo em AL
    mov eax, [eax+_3_] // EAX := 32 bits de alta ordem de x
    bt eax, 31          // CF := Sign bit de EAX
                        // alt.: shl/rol/rcl eax, 1
    setc al             // AL := CF; // Carry Flag
                        // alt.: mov al, 0; rcl, 1
                        //   ou: mov al, 0; adc al, al
                        //   ou: lahf; mov al, ah; and al, $1
                        //   ou: lahf; ror/rcr/shr/sar ax, 1; shr al, 7
                        //   ou: lahf; ror/shr/sar ax, 8; and al, $1
                        //   ou: lahf; rol ax, 8; and al, $1
                        //   ou: lahf; rcl ax, 9; and al, $1
end;

function _IsNeg(x: Hugeint): boolean;
asm
    // atribuir o Parity Flag e negá-lo em AL
    mov al, [eax+_3_+3] // EAX := 8 bits de alta ordem de x
    or al, $7F          // PF := Not Sign bit
                        // alt.: and eax, $80000000
    setnp al            // AL := Not PF; // Not Parity Flag
                        // alt.: lahf; rol/shl ax, 6 / rcl ax, 7;
                                 xor al,-1 / not al; and al, $1;
                        //   ou: lahf; ror/shr/sar ax, 10 / rcr ax, 11;
                                 xor al,-1 / not al; and al, $1;
end;

Na próxima parte veremos funções para adicionar, subtrair, multiplicar e
dividir inteiro HugeInt.

Delphi com assembly (Parte 4)

2011-08-15T23:38:00.000-03:00

Aritmética Inteira de 128 bits (1)

Introdução
==========

Com 32 bits podemos representar 2^32 números diferentes, isto é,
4294967296 (~4 bilhões) números diferentes, tais como inteiros com sinal
de -2147483648 até +2147483647 ou inteiros sem sinal de 0 até 4294967295
(Longint e Longword respectivamente).

Isso é suficiente para muitas finalidades como, por exemplo, guardar a
posição de um byte em um arquivo de 4GB. Mas às vezes precisamos
representar inteiros maiores e então podemos usar TLargeInteger
(Windows.pas) e Int64 (a partir do Delphi 4) para representar inteiros
de 64-bits (2^64 valores diferentes): 18446744073709551616 (~18
sestilhões) de valores, de -9223372036854775808 até +9223372036854775807
(~9 sestilhões, 17-18 dígitos).

Essa quantidade de dígitos é muito mais do que eu preciso e não consigo
imaginar qualquer uso prático para mais do que isso- a não ser Bill
Gates que conta seu dinheiro em sestilhões! ;) Mas de tempos em tempos
eu vejo alguém no fórum perguntar por mais dígitos que o Int64
oferece...

De qualquer maneira, se válido ou completamente inútil numa proposta
prática, veremos a implementação de várias procedures e functions
desenvolvidas para trabalhar com inteiros de 128-bits, que nos
servirão para mostrar exemplos de instruções básicas de assembler.
Este "inteiros longos", "inteiros grandes" ou "inteiros enormes"
podem manter 2^128 diferentes valores (38-39 dígitos).

Representação dos inteiros de 128-bits
======================================

Eu chamo o novo tipo Hugeint mas, por exemplo, Bigint (big integer) ou
Int128 podem ser nomes igualmente bons. Largeint pode ser confundido com
o tipo da unit Windows.pas que refere-se ao inteiro de 64-bits.

Quando precisamos representar o novo tipo, também existem várias formas
de fazê-lo. Eu optei pela representação mais simples- um array de 4
inteiros de 32 bits:

type
    Hugeint: packed array [0..3] of longword;

Também decidi pelo formato little-endian já que é o padrão na
arquitetura Intel e isto significa que o primeiro elemento do array
(endereço mais baixo) guardará os 32 bits de ordem mais baixa (menos
significativos) e o último elemento do array (endereço mais alto)
guardará os 32 bits de mais alta ordem (mais significativos).

Abaixo é a forma que os números 5 e 5000000000 ($12A05F200) serão
representados:

         +---- 32 bits de baixa ordem
         |
         v
+-------------+-------------+-------------+-------------+
| $00000005 | $00000000 | $00000000 | $00000000 | = 5
+-------------+-------------+-------------+-------------+
         0             1             2             3
+-------------+-------------+-------------+-------------+
| $2A05F200 | $00000001 | $00000000 | $00000000 | = 5000000000
+-------------+-------------+-------------+-------------+   $12A05F200
                                                   ^
                                                   |
                         32 bits de alta ordem ----+

Os próprios inteiros são armazenados no formato little-endian (primeiro
o byte de mais baixa ordem). Se você verificar a representação em bytes
de um número na memória, ela se pareceria com isso (valores em bytes
representados na notação hexadecimal):

     $00000005
+-------------+-------------+-------------+-------------+
| 05 00 00 00 | 00 00 00 00 | 00 00 00 00 | 00 00 00 00 | = 5
+-------------+-------------+-------------+-------------+
         0             1             2             3
+-------------+-------------+-------------+-------------+
| 00 F2 05 2A | 01 00 00 00 | 00 00 00 00 | 00 00 00 00 | = 5000000000
+-------------+-------------+-------------+-------------+   $12A05F200
     $2A05F200     $00000001

Entretanto, para quase todas as operações, podemos abstrair a ordem do
byte e considerar que os inteiros de 32-bits são unidades atômicas,
desde que a ordem do byte seja mantida transparentemente.

Algumas instruções úteis
========================

Antes de começarmos, vejamos algumas instruções úteis que usaremos neste
artigo (principalmente na continuação desta parte); antes, porém, é
preciso enfatizar que a proposta deste artigo não é ensiná-lo assembler.
Tudo que eu posso fazer neste espaço limitado é simplesmente mostrar
exemplos de algumas instruções. Como material de referência, recomendo
estes links:

* Intel 80386 Reference Programmer's Manual
Um versão HTML deste manual da Intel. O pseudocódigo ajuda a entender
as instruções e seus efeitos sobre os flags. Excelente.
http://people.freebsd.org/~jhb/386htm/toc.htm
Existem alguns links quebrados, mas as páginas estão lá. Tente
encontrá-los no diretório: http://people.freebsd.org/~jhb/386htm/

* iAPx86 - Norton Guide
Não é tão didático quanto o documento acima, mas contém todas as
instruções do 8086 do Pentium e Pentium Pro, com informações de
tamanho e tempo não inclusas no link acima.
http://www.clipx.net/ng/iapx86/index.php

* The IA-32 Intel Architecture Software Developer's Manual, Volume 2:
Instruction Set Reference
Manual em PDF descrevendo as instruções dos processadores IA-32
(Pentium, Pentium Pro, Pentium II, Pentium III, Pentium 4 e Xeon).
Inclui pseudocódigo que explica as instruções e como elas afetam os
flags dos registradores.
http://www.intel.com/design/pentium4/manuals/245471.htm

* Otimização

- How to optimize for the Pentium family of microprocessors
    Excelente guia de otimização escrito por Agner Fog
    http://fatphil.org/x86/pentopt/index.html

- Optimizations for Intel's 32-Bit Processors
    Outro excelente guia de otimização.
    http://x86.ddj.com/ftp/manuals/686/optimgd.pdf

OK, agora vamos ver as instruções.

Referência:

Z/ZF: Flag Zero
S/SF: Flag de Sinal
C/CF: Flag de Transporte (Carry)
P/PF: Flag de Paridade
A/AF: Flag Auxiliar

s: bit de sinal (bit de ordem mais alta)
o: bit ímpar (bit de ordem mais baixa)
x: valor do bit
0: o valor 0
1: o valor 1

r: bit invertido em relação ao valor anterior
u: bit não alterado desde o valor anterior

XX: valor desconhecido

Nos exemplos presumimos que o valor de AL antes de cada operação é
sxxxxxxo (bit de sinal, 6 bits desconhecidos e bit ímpar).

Aqui temos algumas instruções para começar:

SHL al,1    AL := xxxxxxo0 CF := s   Deslocamento à esquerda
SAL al,1    AL := xxxxxxo0 CF := s   Mesmo que SHL
SHR al,1    AL := 0sxxxxxx CF := o   Deslocamento à direita
SAR al,1    AL := ssxxxxxx CF := o   Deslocamento aritmético à
                                        direita
SAR al,7    AL := ssssssss CF := x   Reprodução do bit de sinal

ROL al,1    AL := xxxxxxos CF := s   Rotação à esquerda
ROR al,1    AL := osxxxxxx CF := o   Rotação à direita
RCL al,1    AL := xxxxxxoC CF := s   Rotação completa com transporte
                                        à esquerda
RCR al,1    AL := Csxxxxxx CF := o   Rotação completa com transporte
                                        à direita

AND al,al   AL := uuuuuuuu CF := 0   Define flags (veja abaixo)
AND al,-1   AL := uuuuuuuu CF := 0   -1 = $FF = 1111111
                                        Define flags (veja abaixo)
AND al,$01 AL := 0000000u CF := 0   $01 = 00000001
AND al,$80 AL := u0000000 CF := 0   $80 = 10000000
AND al,$5A AL := 0u0uu0u0 CF := 0   $5A = 01011010
AND al,0    AL := 00000000 CF := 0   XOR AL,AL ou MOV AL,0 são
                                        melhores

TEST AL,XX AL := uuuuuuuu
              TEST é como AND mas o resultado não é armazenado no
              destino. O resultado é usado para definir as flags (veja
              abaixo)
TEST AL,-1 É melhor que AND AL,-1 e OR AL,AL porque não escreve em
              AL, o que permite certas otimizações em alguns casos.

OR al,al   AL := uuuuuuuu CF := 0   Define as flags (veja abaixo)
OR al,$01 AL := uuuuuuu1 CF := 0   $01 = 00000001
OR al,$80 AL := 1uuuuuuu CF := 0   $80 = 10000000
OR al,$5A AL := u1u11u1u CF := 0   $5A = 01011010
OR al,-1   AL := 11111111 CF := 0   Mesmo que MOV AL,1

XOR al,al   AL := 0         CF := 0   Utilize MOV AL,0 para preservar
                                        as flags
XOR al,$5A AL := ururruru CF := 0   $5A = 01011010
XOR al,-1   AL := rrrrrrrr CF := 0   Mesmo que NOT AL

Exceto pelas instruções de rotação (ROL, RCL, ROR e RCR), todas acima
definem SF, ZF e PF baseados no resultado das operações:

SF = valor do bit de mais alta ordem do resultado
ZF = 1 ("definido") se o resultado for zero, 0 ("limpo") nos demais
       casos
PF = 1 ("definido") se o o byte de mais baixa ordem do resultado
       contém um número par de bits 1, senão 0 ("limpo")

Veja mais algumas instruções:

STC         CF := 1          Define o flag de Transporte
CLC         CF := 0          Limpa o flag de Transporte
CMC         CF := r          Complementa o flag de Transporte

LAHF        AH := SZxAxPxC
SAHF        Presumindo que AH é SZxAxPxC:
                ZF := S; ZF := Z; AF := A; PF := P; CF := C

SETc AL    AL := CF         Define se carry
SETs AL    AL := SF         Define se sign
SETz AL    AL := ZF         Define se zero
SETe AL    AL := ZF         Define se equal (sinônimo de SETZ)
SETp AL    AL := PF         Define se paridade
SETpe AL    AL := PF         Define se a paridade é par
                               (sinônimo de SETP)
SETo AL    AL := OF         Define se overflow
SETnc AL    AL := NOT CF     Define se não carry
SETns AL    AL := NOT SF     Define se não sign
SETnz AL    AL := NOT ZF     Define se não zero
SETne AL    AL := NOT ZF     Define se não equal (sinônimo de SETNZ)
SETnp AL    AL := NOT PF     Define se não paridade
SETpo AL    AL := NOT PF     Define se a paridade é ímpar
                               (sinônimo de SETNP)
SETno AL    AL := NOT OF     Define se não overflow

SETa (ou SETNbe), SETae (ou SETnb), SETb (ou SETnae), SETbe (SETna),
SETg (ou SETNle), SETge (ou SETnl), SETl (ou SETnge) e SETle (SETng)
definem o byte de destino para 1 ou 0 dependendo da condição
específica ser satisfeita ou não.

ADD AL,XX   AL := AL+XX     CF := 1 se a operação gera transporte;
                                    0 outros casos

SUB AL,XX   AL := AL-XX     CF := 1 se a operação precisa de um
                                     empréstimo; 0 outros casos
SUB AL,0    AL := uuuuuuuu Define os flags baseados no AL
SUB AL,AL   AL := 0         Mesmo que XOR AL,AL ou MOV AL,0

CMP AL,XX   CMP é como SUB mas o resultado não é armazenado no
               destino. A operação simplesmente define os flags.

ADC AL,XX   AL := AL+XX+C   CF := 1 se a operação gera um transporte;
                                    0 outros casos
SBB AL,XX   AL := AL-C-XX   CF := 1 se a operação necessitade um
                                    empréstimo; 0 outros casos

NEG AL      AL := -AL       CF := 1 se previamente AL <> 0
                                         NOT AL; INC AL é o mesmo
NOT AL      AL := rrrrrrrr CF := u    Mesmo que XOR AL,-1

Funções de Conversão
====================

Estas funções nos ajudarão a entender a representação dos inteiros
128-bits.

Longword para Hugeint
---------------------

Vamos começar convertendo de Longword para HugeInt. Os 32 bits de mais
baixa ordem do resultado serão os 32 bits do parâmetro e os 96 bits de
mais alta ordem serão zerados.

function UToHugeint(const x: Longword): Hugeint; overload;
// Result := Hugeint(x);
// Parâmetros: EAX = x; EDX = @Result;
asm
    xor ecx, ecx         // ECX := 0;
    mov [edx+_0_], eax   // Result[0] := x;
    mov [edx+_1_], ecx   // Result[1] := 0;
    mov [edx+_2_], ecx   // Result[2] := 0;
    mov [edx+_3_], ecx   // Result[3] := 0;
end;

Comentários:

* "_0_", "_1_", "_2_", e "_3_"? O que são?

São constantes que representam os deslocamentos dos quatro elementos
do vetor, permitindo-nos escrever um código mais limpo.

    const
      _0_ = 0;
      _1_ = 4;
      _2_ = 8;
      _3_ = 12;

Longint para Hugeint
--------------------

Os 32 bits inferiores do resultado serão os 32 bits do parâmetro. Se o
número for positivo ou zero, então os 96 bits superiores serão 0, senão
os 96 bits superiores serão 1.

Isso nos força a fazer uma comparação ou teste do sinal e então executar
um jump condicional baseado no resultado:

function ToHugeint(const x: Longint): Hugeint; overload;
// Result := Hugeint(x);
// Parâmetros: EAX = x; EDX = @Result;
asm
    or eax, eax        // EAX := EAX or EAX; // EAX não é alterado
                        // Efeito colateral:
                        //           SF (Flag de Sinal) := EAX < 0;
    mov ecx, 0          // ECX := 0;
    jns @@not_negative // if not SF then goto @@not_negative;
    dec ecx             // ECX := ECX - 1; // 0 - 1 = -1 = $FFFFFFFF
@@not_negative:
    mov [edx+_0_], eax // Result[0] := x;
    mov [edx+_1_], ecx // Result[1] := ECX; // 0 or $FFFFFFFF
    mov [edx+_2_], ecx // Result[2] := ECX; // 0 or $FFFFFFFF
    mov [edx+_3_], ecx // Result[3] := ECX; // 0 or $FFFFFFFF
end;

Comentários:

* Observe o uso do "MOV ECX, 0" no lugar de "XOR ECX, ECX" para evitar
alterar o estado do Flag de Sinal (SF) definido na instrução anterior
(OR) e então usado no jump condicional que aparece na instrução
seguinte (JNS). É claro que era desnecessário trocar a ordem das
operações para isto.

* Em vez de:

    or eax, eax
    jns @@not_negative

os pares de instruções abaixo realizariam o mesmo:

* and eax, eax         // EAX mantém o valor, mas SF recebe o sinal
    jns @@not_negative   // se SF = 0 então goto @@not_negative

* test eax, $80000000 // somente zero se o bit de sinal (bit 31) é 0
    jz @@not_negative    // se ZF então goto @@not_negative

* test eax, $87654321 // qualquer valor com o bit 31 definido
    jns @@not_negative   // se SF = 0 então goto @@not_negative

* cmp eax, 0           // compara eax com 0
    jge @@not_negative   // se maior ou igual então goto @@not_negative

* Observe o uso de "DEC ECX" para alterar o valor de ECX de $00000000
para $FFFFFFFF (decrementando o valor do registro). "NOT ECX" faz a
mesma coisa invertendo os bits, na mesma velocidade, e com o mesmo
número de bytes para codificar a instrução, mas não é uma instrução
par como o DEC. Por esta razão NOT é normalmente evitado e substituido
por:

- Se você sabe de antemão que o valor é zero, utilize DEC Dest
- Se você sabe de antemão que o valor é 1, use INC Dest
- Se você não conhece o valor, use XOR Dest, -1

* Também preste atenção na ordem das instruções para jamais utilizar um
registro que foi definido por um instrução imediatamente anterior.
Essa é uma das condições para que ocorra o pareamento. Você encontrará
mais informações sobre instruções de pareamento nos documentos sobre
otimização recomendados anteriormente.

Podemos simplificar a função obrigando a instrução CDQ que estende o
sinal de EAX para EDX. Veja o funcionamento (simplificado) de CDQ:

if EAX >= 0 then
    EDX := $0
else
    EDX := $FFFFFFFF;

Aqui é uma pequena e simples implementação usando CDQ:

function ToHugeint(const x: Longint): Hugeint; overload;
// Result := Hugeint(x);
// Parâmetros: EAX = x; EDX = @Result;
asm
    mov ecx, edx        // ECX := @Result;
    cdq                 // EDX := IIF(x>=0, 0, $FFFFFFFF);
    mov [ecx+_0_], eax // Result[0] := x;
    mov [ecx+_1_], edx // Result[1] := EDX; // 0 or $FFFFFFFF
    mov [ecx+_2_], edx // Result[2] := EDX; // 0 or $FFFFFFFF
    mov [ecx+_3_], edx // Result[3] := EDX; // 0 or $FFFFFFFF
end;

CDQ é usualmente substituído usando MOV e SAR, que oferecem a vantagem
de que a origem não precisa ser EAX e o destino não precisa ser EDX (mas
são instruções pareadas). Vejamos um exemplo:

function ToHugeint(const x: Longint): Hugeint; overload;
// Result := Hugeint(x);
// Parâmetros: EAX = x; EDX = @Result;
asm
    mov ecx, eax        // ECX := x;
    sar ecx, 31         // ECX := IIF(x>=0, 0, $FFFFFFFF);
    mov [edx+_0_], eax // Result[0] := x;
    mov [edx+_1_], ecx // Result[1] := EDX; // 0 or $FFFFFFFF
    mov [edx+_2_], ecx // Result[2] := EDX; // 0 or $FFFFFFFF
    mov [edx+_3_], ecx // Result[3] := EDX; // 0 or $FFFFFFFF
end;

Hugeint para Longint
--------------------

Um Hugeint pode ser convertido para Longint simplesmente pegando os
32 bits de mais baixa ordem. Os 96 bits altos do Hugeint podem ser todos
definidos para 0 ou 1 igualando o bit de sinal para que o resultado (bit
31) do Hugeint esteja dentro dos limites do Longint, mas a função não
checa isto e executa a conversão cegamente (da mesma forma que um
Longint é convertido para um Shortint, por exemplo).

function ToLongint(const x: Hugeint): Longint; overload;
// Result := Longint(x);
// Nenhuma exceção é gerada se o valor não estiver dentro dos limites
// (os 96 bits de mais alta ordem são descartados).
// Parâmetros: EAX = @x;
asm
    mov eax, [eax+_0_] // Result := x[0];
end;

Int64 para Hugeint
------------------

Parâmetros Int64 são passados para a pilha; assim, funções com
parâmetros Int64 automaticamente criam um quadro de pilha (stack frame).
Os 64 bits mais baixos do resultado serão os 64 bits do parâmetro
enquanto os 64 bits mais altos serão obtidos a partir do bit de sinal
do inteiro (32 bits) de mais alta ordem do Int64.

{$IFDEF DELPHI4}
function ToHugeint(const x: Int64): Hugeint; overload;
// Result := Hugeint(x);
// Parâmetros: x na pilha; EAX = @Result;
asm
    mov edx, dword[x+_0_] // EDX := x[0];
    mov ecx, dword[x+_1_] // ECX := x[1];
    mov [eax+_0_], edx     // Result[0] := x[0];
    mov [eax+_1_], ecx     // Result[1] := x[1];
    sar ecx, 31            // ECX := IIF(x[1]>=0, 0, $FFFFFFFF);
    mov [eax+_2_], ecx     // Result[2] := ECX; // 0 or $FFFFFFFF
    mov [eax+_3_], ecx     // Result[3] := ECX; // 0 or $FFFFFFFF
end;
{$ENDIF}

Valores Int64 são armazenados no formato little-endian; assim, o
inteiro inferior é o primeiro, com um deslocamento 0 do endereço base
da variável e o inteiro superior é o segundo, com um deslocamento 4 do
endereço base da variável. Nesse caso, o endereço base da variável é
EBP+8 (veja o primeiro capítulo desta série de artigos) e, assim, o
primeiro elemento está em EBP+8 (EBP+8+0) e o segundo elemento está em
EBP+12 (EBP+8+4). Eu poderia usar EBP+8 e EBP+12 para endereçar estes
elementos mas "x+_0_" e "x+_1_" referem-se aos endereços de forma mais
transparente. O especificador de tamanho (DWORD) é já que o assembler
recebe "x+_0_" e "x+_1_" como ponteiros para dados de 64 bits ("x" é
considerado um ponteiro de dados de 64-bits) e não permite mover o
valor referenciado para um registrador de 32-bits.

Hugeint para Int64
------------------

Um Hugeint pode ser convertido para um Int64 simplesmente pegando os 64
bits inferiores. Os 64 bits superiores do HugeInt podem ser definidos
como 0 ou 1 para igualar o bit de sinal para que o resultado (bit 32)
do valor Hugeint fique dentro dos limites de um Int64, mas a função não
checa isto e executa a conversão cegamente:

{$IFDEF DELPHI4}
function ToInt64(const x: Hugeint): Int64; overload;
// Result := Int64(x)
// Nenhuma exceção é gerada se o valor não estiver dentro dos limites
// (os 64 bits de mais alta ordem são descartados).
// Parâmetros: EAX = @x;
asm
    mov edx, [eax+_1_] // EDX := x[1];
    mov eax, [eax+_0_] // EAX := x[0];
    // Result = EDX:EAX = x[1]:x[0]
end;
{$ENDIF}

Commentários:

* Int64 retorna valores colocados em EDX (32 bits de alta ordem) e
EAX (32 bits de baixa ordem).

Por enquanto é isso. Nas próximas edições veremos funções que executam
funções lógicas e matemáticas com inteiros gigantes.

Delphi com assembly (Parte 3)

2011-08-15T11:23:00.000-03:00

Objetos são registros
=====================

Do ponto de vista do assembler, um objeto é como um registro, cujos
campos são seus próprios campos mais os campos de seus ancestrais,
mais um ponteiro à VMT (Virtual Methods Table - Tabela de Métodos
Virtuais). Vejamos isto através de um exemplo:

type
    TClass1 = class
      FieldA: integer;
      FieldB: string;
    end;

    TClass2 = class(TClass1)
      FieldC: integer;
    end;

No exemplo, TClass2 é de certo modo como um registro com quatro
campos:

TClass2 = record
    VMT: pointer;       // campo invisível, sempre o primeiro
    FieldA: integer;    // herdado de TClass1
    FieldB: string;     // herdado de TClass1
    FieldC: integer;    // declarado em TClass2
end;

Variáveis objeto são ponteiros
==============================

Uma variável objeto é somente um ponteiro para um objeto, ou seja, um
ponteiro para um registro.

var
    a, b: TClass2;
begin
    a := TClass2.Create;
    b := a;                // somente uma declaração de ponteiro
    a.Free;
end;

Um construtor aloca memória para uma instância (objeto) de sua classe,
inicializa-a e retorna um ponteiro para a memória alocada. Assim,
após a chamada a TClass.Create a variável "a" aponta para o registro
(o objeto):

+---+             +--------+
| a | ----------> |   VMT |
+---+             +--------+
                    | FieldA |
                    +--------+
                    | FieldB |
                    +--------+
                    | FieldC |
                    +--------+

A declaração "b := a" não cria um novo objeto, cópia do primeiro,
mas realmente faz com que ambas as variáveis apontem para o mesmo
objeto:

+---+             +--------+             +---+
| a | ----------> |   VMT | <---------- | b |
+---+             +--------+             +---+
                    | FieldA |
                    +--------+
                    | FieldB |
                    +--------+
                    | FieldC |
                    +--------+

Métodos assembler
=================

Os métodos recebem um primeiro parâmetro invisível, chamado Self, que
é um ponteiro para o objeto sobre o qual o método deve operar.

type
    TTest = class
      FCode: integer;
    public
      procedure SetCode(NewCode: integer);
    end;

procedure TTest.SetCode(NewCode: integer);
begin
    FCode := NewCode;
end;

var
    a: TTest;
begin
    :
    a.SetCode(2);
    :
end;

O código em Objetc Pascal acima é traduzido para para o Pascal padrão
como segue:

type
    TTest = record
      VMT: pointer;
      FCode: integer;
    end;

procedure SetCode(Self: TTest; NewCode: integer);
begin
    Self.FCode := NewCode;
end;

var
    a: ^TTest;
begin
    :
    SetCode(a, 2);
    :
end;

O exemplo serve para explicar que os métodos recebem o ponteiro Self
como seu primeiro parâmetro, ou seja, eles recebem o ponteiro Self no
registrador EAX e o primeiro parâmetro declarado é passado como um
segundo parâmetro em EDX etc. (o segundo parâmetro declarado é passado
como terceito em ECX e o resto dos parâmetros são passados em pilha).
O método SetCod pode ser escrito em assembler como:

procedure TTest.SetCode(NewCode: integer);
asm
    // EAX = Self = endereço da instância TTest
    // EDX = parâmetro NewCode

    // FCode := NewCode;
    mov TTest[eax].FCode, edx       // TTest(EAX)^.FCode := EDX;
end;

Como se pode ver, os campos de objeto são acessados da mesma forma que
os campos de registro.

NOTA: Propriedades não são campos e não podem ser acessadas diretamente
      a partir do assembler inline.

Eis um exemplo de um método chamando outro método:

procedure TTest.Increment;
asm
    // SetCode(Code+1);
    mov edx, TTest[eax].FCode       // ECX := TTest(EAX)^.FCode;
    inc edx
    call TTest.SetCode;
end;

Não fixamos o valor de EAX antes de fazer a chamada já que EAX já
contém o valor desejado (Self), assim o método chamado vai operar no
mesmo objeto.

NOTAS:

* Métodos virtuais podem ser chamados somente estaticamente, já que
uma referência à classe é necessária na declaração de chamada.

* Métodos sobrecarregados não podem ser distinguidos em assembler
inline.

Construtores assembler
======================

Construtores são métodos muito especiais. Os construtores podem ser
chamados para criar uma instância de uma classe (isto é, para alocar
a memória para o objeto e inicializá-lo), ou simplesmente para
reinicializar um objeto já criado:

a := TTest.Create;   // aloca memória
a.Create;            // apenas reinicializa um objeto existente

Para distinguir entre estas duas situações, os construtores passam
um segundo parâmetro invisível do tipo byte (ou seja, no registrador
DL) que pode ser positivo ou negativo respectivamente (o compilador
usa 1 e -1 respectivamente).

Se temos de chamar um construtor a partir do código assembler com
DL = $01 (para alocar memória para o objeto), temos de passar uma
referência à classe em EAX. Já que não há nenhum símbolo para acessá-lo
diretamente do assembler, temos que fazer algo similar ao que fizemos
com o tipo de informação dos registros:

var
    TTest_TypeInfo: pointer;

:

initialization
    TTest_TypeInfo := TTest;

Agora que inicializamos uma variável global com a referência à classe a
partir do nosso código Pascal, podemos usa-la em nosso código assembler:

var
    a: TTest;
begin
    // a := TTest.Create(2);
    asm
      mov eax, TTest_TypeInfo
      mov dl, 1
      mov ecx, 2
      call TTest.Create
      mov a, eax
    end;
    :
end;

Chamar um construtor para reinicializar o objeto é mais simples já que
não precisamos de uma referência à classe:

var
    a: TTest;
begin
    :
    // a.Create(2);
    asm
      mov eax, a
      mov dl, -1
      mov ecx, 2
      call TTest.Create
    end;
    :
end;

Não temos nada com que nos preocupar se temos que escrever um construtor
assembler já que o Delphi manuseia a alocação para nós na entrada do
construtor e, após isso, o registrador EAX aponta para o objeto, como
acontece com qualquer outro método. O que é relevante é que se o
construtor tem parâmetros, o primeiro parâmetro declarado será
internamente passado como terceito, ou seja, em ECX (ao invés de
segundo, em EDX, como acontece com outros métodos) e o resto dos
parâmetros serão passados em ordem, na pilha.

constructor TTest.Create(NewCode: integer);
asm
    // FCode := NewCode
    mov TTest[eax].FCode, ecx
end;

__________________

NOTA: Um exemplo com código fonte completo está anexado

Funções API e a convenção de chamada Stdcall
============================================

As funções API são chamadas de forma transparente a partir do assembler
nativo com a declaração CALL. Contudo, devemos levar em consideração que
passar parâmetros para funções API é diferente já que elas normalmente
usam o convenção de chamada Stdcall, ao invés da convenção de chamada
Register, que é a que vimos em várias ocasiões anteriores já que ela é a
convenção padrão.

Na convenção de chamada Stdcall, todos os parâmetros são passados para a
pilha, da direita para a esquerda, ou seja, o último parâmetro (o mais à
direita) é enviado primeiro e o primeiro (o mais à esquerda) é enviado
por último, e, portanto, ele será o primeiro no topo da pilha. Eis um
exemplo de um procedimento que chama uma função API:

procedure HideForm(Handle: THandle);
// Windows.ShowWindow(Handle, SW_HIDE);
asm
    push SW_HIDE             // push 0   // passa o segundo parâmetro
    push Handle              // push eax // passa o primeiro parâmetro
    call Windows.ShowWindow // chama a API ShowWindow
end;

Se temos que chamar um método que usa a convenção Stdcall, devemos
lembrar que o ponteiro Self é o primeiro parâmetro invisível, logo ele
será passado por último na pilha.

Se temos que escrever funções que usam a convenção Stdcall, não há nada
de especial para nos preocuparmos. O compilador sempre criará uma pilha
e referências aos nomes dos parâmetros serão convertidas em endereços
relativos ao ponteiro base:

function AddAndMultiply(i1, i2, i3: integer): integer; stdcall;
asm // ==> push ebp; mov ebp, esp
    // Result := (i1 + i2) * i3;
    mov eax, i1   // mov eax, [ebp+8]
    add eax, i2   // add eax, [ebp+12]
    imul i3       // imul [ebp+16]
end; // ==> pop ebp; ret 12

Este é um exemplo de chamada para a função:

asm
    // a := AddAndMultiply(1, 2, 3); // o resultado seria 9
    push 3
    push 2
    push 1
    call AddAndMultiply
    mov a, eax
end;

Após a entrada na função, a pilha se pareceria com isto:

|                |
+----------------+
|    Old EBP     | [EBP], [ESP]
+----------------+
| Return Address | [EBP+4]
+----------------+
|     i1 = 1     | [EBP+8]
+----------------+
|     i2 = 2     | [EBP+12]
+----------------+
|     i3 = 3     | [EBP+16]
+----------------+
|                |

Bibliotecas C/C++ e a convenção de chamada Cdecl
================================================

Algumas vezes precisamos acessar funções em arquivos objeto (.OBJ),
bibliotecas estáticas (.LIB) ou bibliotecas dinâmicas (.DLL) escritas
em C ou C++ e, muito freqüentemente, estas funções usam a convenção de
chamada Cdecl. Ela é muito parecida com a convenção Stdcall, mas a pilha
deve ser limpa por quem a chama, isto é, quem a chama deve invocar os
parâmetros que ela inicia ou- ainda melhor- incrementar o ponteiro da
pilha.

function AddAndMultiply(i1, i2, i3: integer): integer; cdecl;
asm // ==> push ebp; mov ebp, esp
    // Result := (i1 + i2) * i3;
    mov eax, i1   // mov eax, [ebp+8]
    add eax, i2   // add eax, [ebp+12]
    imul i3       // imul [ebp+16]
end; // ==> pop ebp; ret

Note-se no comentário da última linha que a função não move o ponteiro
da pilha como ocorreu no exemplo anterior que usou a convenção Stdcall;
logo, quem chamar esta função é que será o responsável por isso. Este é
um exemplo de chamada para esta função:

asm
    // a := AddAndMultiply(1, 2, 3); // seria 9
    push 3
    push 2
    push 1
    call AddAndMultiply
    add esp, 12           // limpa a pilha
    mov a, eax
end;

Note-se que se os parâmetros fossem do tipo Byte ao invés de Integer,
moveríamos ainda o ponteiro da pilha de 12 bytes já que cada parâmetro
usaria 32 bits (4 bytes) nos dois casos.

A convenção de chamada Pascal
=============================

Muitos programadores C/C++ preferem a convenção de chamada Pascal ao
invés da Cdecl porque ela é mais compacta e também mais rápida já que a
função chamada limpa a pilha na declaração RET, como ocorre na convenção
Stdcall. A convenção Pascal é como a Stdcall, mas os parâmetros são
passados da esquerda para a direita ao invés da direita para a esquerda,
isto é, o primeiro parâmetro (o mais a esquerda) é passado primeiro e o
último (o mais a direita) é passado por último:

function AddAndMultiply(i1, i2, i3: integer): integer; pascal;
asm // ==> push ebp; mov ebp, esp
    // Result := (i1 + i2) * i3;
    mov eax, i1   // mov eax, [ebp+16]
    add eax, i2   // add eax, [ebp+12]
    imul i3       // imul [ebp+8]
end; // ==> pop ebp; ret 12

Note-se como os endereços dos parâmetros são traduzidos de modo
diferente que nos exemplos anteriores.

Este é um exemplo de chamada desta função:

asm
    // a := AddAndMultiply(1, 2, 3); // seria 9
    push 1
    push 2
    push 3
    call AddAndMultiply
    mov a, eax
end;

Após a chamada da função, a pilha se pareceria com isto:

|                |
+----------------+
|      EBP       | [EBP], [ESP]
+----------------+
| Return Address | [EBP+4]
+----------------+
|     i3 = 3     | [EBP+8]
+----------------+
|     i2 = 2     | [EBP+12]
+----------------+
|     i1 = 1     | [EBP+16]
+----------------+
|                |

Delphi com assembly (Parte 2)

2011-08-15T02:39:00.000-03:00

Passando arrays estáticas como parâmetros
=========================================

Parâmetros de arrays estáticas são passados como ponteiros ao primeiro
elemento do array, independentemente do parâmetro ser passado por valor
ou por referência (como "var" ou como "const").

Dadas as seguintes declarações...

const
    ARRAY_MAX = 5;

type
    TArrayOfInt = packed array [0..ARRAY_MAX] of longint;

var
    a, b: TArrayOfInt;

procedure InitializeArray(var a: TArrayOfInt);
var
    i: integer;
begin
    for i := 0 to ARRAY_MAX do
      a[i] := i;
end;

... a chamada à procedure InitializeArray em assembler seria:

    // Em Object Pascal:
    //   InitializeArray(a);
    // Em Assembler Inline:
    asm
      mov eax, offset a        // EAX := @a;
      call InitializeArray     // InitializeArray;
    end;

OFFSET é um operador unário assembler que retorna o endereço de um
símbolo. O OFFSET não é aplicável para símbolos locais. Deve-se usar o
opcode LEA (veja abaixo), que é mais "universal".

Arrays estáticas passadas por valor
-----------------------------------

Se o array é passado por valor, é responsabilidade da função chamada
preservar o array. Quando a função precisa mudar os valores de um ou
mais elementos de um array passado por valor, normalmente ela cria uma
cópia local e trabalha com a cópia. O compilador cria uma cópia para nós
no "begin" das procedures e funções Pascal, mas em procedures e funções
em assembler puro temos de fazer isto nós mesmos. Um modo de se fazer
isto seria o seguinte:

procedure OperateOnArrayPassedByValue(a: TArrayOfInt);
var
    _a: TArrayOfInt;
asm
    // Copia os elementos de "a" (parâmetro) em "_a" (cópia local)
    push esi                      // Salva ESI na pilha
    push edi                      // Salva EDI na pilha
    mov esi, eax                  // ESI := EAX; // @a
    lea edi, _a                   // EDI := @_a;
    mov eax, edi                  // EAX := EDI; // @_a
    mov ecx, type TArrayOfInt     // ECX := sizeof(TArrayOfInt);
    rep movsb                     // Move(ESI^, EDI^, ECX);
    pop edi                       // Restaura EDI da pilha
    pop esi                       // Restaura ESI da pilha

    // Aqui vai o resto da função. Trabalharemos sobre o "_a" (a
    // cópia local), cujo primeiro elemento está agora apontado por EAX.
end;

O que encontramos de novo aqui são os opcods LEA e MOVSB, o prefixo REP
e o operador TYPE, descritos abaixo:

LEA (Load Effective Address)
----------------------------

Move para o primeiro operando o endereço do segundo. Aqui comparamos LEA
com MOV:

   Instrução             Traduzida como         Efeito
-------------------------------------------------------------------

   lea eax, localvar     lea eax, [ebp-$04]     EAX := @localvar;
                                                EAX := EBP - $04;

   mov eax, localvar     mov eax, [ebp-$04]     EAX := localvar;
                                                EAX := (EBP - $04)^;

MOVSB (MOVe String Byte)
------------------------

Copia o byte apontado por ESI ao local apontado por EDI, e incrementa
ESI e EDI de tal forma que eles apontem para o próximo byte. O trabalho
do MOVSB pode ser descrito como segue:

ESI^ := EDI^;    // Assume que ESI e EDI são do tipo PChar
Inc(ESI);
Inc(EDI);

Notas:

* MOVSW e MOVSD são as versões Word (16-bit) e DWord (32-bit)
   respectivamente (ESI e EDI são incrementadas de 2 e 4
   respectivamente).

* Os registradores são decrementados se o Direction Flag é setado.

REP
---

O prefixo REP é usado em operações de string para repetir a operação
de decremento ECX até que ECX seja zero. O trabalho do REP poderia ser
descrito como segue:

// rep string_instruction

@@rep:
    string_instruction
    loop @@rep

Notas:

* O REP não é um atalho para um código como o acima. Ele trabalha muito
mais rápido.

* O valor de ECX não é checado no começo do loop (se ECX fosse zero, a
instrução seria repetida 2^32 vezes, mas geraria um extenso AV antes
disto, tão logo ESI ou EDI apontassem para uma localição de memória
inválida).

TYPE
----

O operador TYPE é um operador unário avaliado em tempo de compilação que
retorna o tamanho em bytes de um operando, que deve ser um tipo de dados.
Por exemplo, TYPE WORD retornará 2 e TYPE INTEGER retornará 4.

Acessando os elementos de um array
==================================

Para acessar um elemento a[i] precisamos dos valores "@a[0]" e "i" nos
registradores (como EDX e ECX, por exemplo) para então podermos usar o
endereçamento de memória como segue:

lea edx, a                      // EDX := @a;
mov ecx, i                      // ECX := i;
mov ax, [edx+ecx*type integer] // AX := EDX[ECX]; // a[i];
       // PWord(EDX + ECX * SizeOf(integer))^

No exemplo, presumimos que os elementos têm 2 bytes (movemos o valor de
a[i] para AX, um registrador de 16 bits), que a array não é agrupada
(cada elemento realmente ocupa 4 bytes, o tamanho de um inteiro, logo
este valor foi usado para calcular a posição do elemento) e que o array
não começa pelo elemento 0, ou seja, não é um array "zero-based". Por
exemplo:

    var a: array [0..N] of word = (1, 2, 3, 6, ...);

    +------ EDX = @a
    |
    v
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+--
| 1 | 0 |   |   | 2 | 0 |   |   | 3 | 0 |   |   | 6 | 0 |   |   |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+--
    a[0]             a[1]            a[2]            a[3]
    [edx]          [edx+04]        [edx+08]        [edx+12]

Se o array não é zero-based, temos que ajustar o valor do índice para
torná-lo zero-based antes de endereçarmos o elemento. Exemplos:

// a[1..100]
:
mov ecx, i                      // ECX := i;
dec ecx                         // Dec(ECX); // Ajusta ECX
:

// a[-10..10]
:
mov ecx, i                      // ECX := i;
add ecx, 10                     // Inc(ECX, 10); // Ajusta ECX
:

A procedure InitializeArray (apresentada acima) pode ser implementada em
assembler do seguinte modo:

procedure InitializeArray(var a: TArrayOfInt);
asm                                // EAX = PByte(@a[0]);
    xor ecx, ecx                     // ECX := 0;
@@loop:
    mov [eax+ecx*type integer], ecx // PInteger(EAX+ECX*4)^ := ECX;
                                     // ...or EAX[ECX] := ECX;
    inc ecx                          // ECX := ECX + 1;
    cmp ecx, ARRAY_MAX               // if ECX <= ARRAY_MAX then
    jle @@loop                       //   goto @@loop;
end;

Ou assim:

procedure InitializeArray(var a: TArrayOfInt);
asm                      // EAX = @a[0];
    xor ecx, ecx           // ECX := 0;
@@loop:
    mov [eax], ecx         // EAX^ := ECX;
    inc ecx                // Inc(ECX);
    add eax, type integer // Inc(EAX); // Aponta para o próximo elemento
    cmp ecx, ARRAY_MAX     // if ECX <= ARRAY_MAX then
    jle @@loop             //   goto @@loop;
end;

Valores de retorno de arrays
============================

As funções que retornam arrays recebem um último parâmetro adicional que
é o ponteiro para a locação de memória onde deveam colocar seu valor de
retorno (a memória é alocada e liberada se necessário por quem acessou).
Por exemplo, consideremos a seguinte função:

function ReverseArray(const a: TArrayOfInt): TArrayOfInt;
var
    i: integer;
begin
    for i := 0 to ARRAY_MAX do
      Result[i] := a[ARRAY_MAX-i];
end;

A função recebe dois parâmetros:

1) EAX = endereço do primeiro elemento da array "a"
2) EDX = endereço do primeiro elemento de Result

A função pode ser reescrita em assembler como segue:

function ReverseArray(const a: TArrayOfInt): TArrayOfInt;
asm                                // EAX = @a[0]; EDX = @Result[0];
    push ebx                         // Save EBX
    mov ebx, eax                     // EBX := EAX;
    xor ecx, ecx                     // ECX := 0;
@@loop:
    mov eax, ARRAY_MAX
    sub eax, ecx                     // EAX := ARRAY_MAX-ECX;
    mov eax, [ebx+eax*type integer] // EAX := EBX[EAX];
    mov [edx+ecx*type integer], eax // EDX[ECX] := EAX;
    inc ecx                          // ECX := ECX + 1;
    cmp ecx, ARRAY_MAX               // if ECX <= ARRAY_MAX then
    jle @@loop                       //   goto @@loop;
    pop ebx                          // Restore EBX
end;

Bem, isto é tudo por enquanto. No próximo artigo veremos como trabalhar
com registros.

Passando records como parâmetros
================================

Como arrays estáticos, records são internamente passados como ponteiros
para os dados, independentemente se o parâmetro é passado por valor ou
por referência (também como "var" ou como "const").

Dada as seguintes declarações...

type
    TRecord = record
      Id: integer;
      Name: string;
    end;

var
    a, b: TRecord;

procedure InitRecord(var r: TRecord; Id: integer; const Name: string);
begin
    r.Id := Id;
    r.Name := Name;
end;

...uma chamada para a procedure InitRecord em assembler seria assim:

    // Em Object Pascal:
    //   InitRecord(a, n, s);
    // Em Inline Assembler:
    asm
      lea eax, a               // EAX := @a; // 1st parameter in EAX
      mov edx, n               // EDX := n; // 2nd parameter in EDX
      mov ecx, s               // ECX := s; // 3rd parameter in ECX
      call InitRecord          // InitRecord;
    end;

Acessando os campos de um record
================================

Campos de records estão localizados em um certo offset de um endereço do
record (o endereço do primeiro campo). No exemplo, assumindo que nós
temos o endereço do record do tipo TRecord no registrador EAX, o campo
Id está localizado em [EAX+0] (ou simplesmente [EAX]), e o campo Name
está localizado em [EAX+4], mas normalmente nós não escrevemos código
usando números explicitamente. Ao invés disto, para produzir código
auto-explicável e de fácil manutenção, nós temos cinco alternativas:

mov edx, [eax + TRecord.Name]
mov edx, (TRecord PTR [eax]).Name
mov edx, (TRecord [eax]).Name
mov edx, TRecord[eax].Name
mov edx, [eax].TRecord.Name

As cinco sentenças anteriores seriam montadas como:

mov edx, [eax + 4]

No lugar de um registrador (como EAX), as sintaxes também se aplicam
para nome de variáveis locais ou globais.

Você pode deduzir da primeira sintaxe que em inline assembler a
expressão RecordType.Field é avaliada em tempo de compilação como
uma constante representando o offset no qual o campo está localizado
no RecorType. Por exemplo, a seguinte sentença é válida:

mov ecx, TRecord.Name   // mov ecx, 4

Voltando ao assunto, a procedure InitRecord (apresentada acima) pode ser
implementada em assembler desta forma:

procedure InitRecord(var r: TRecord; Id: integer; const Name: string);
asm // EAX = @r; EDX = Id; ECX = @Name[1]
    mov (TRecord PTR [eax]).Id, edx    // EAX^.Id := EDX; // Id
    // _LStrAsg(@EAX^.Name, @Name) --> EAX^.Name := Name
    lea eax, (TRecord PTR [eax]).Name // EAX := @(EAX^.Name);
    mov edx, ecx                       // EDX := @Name[1];
    call System.@LStrAsg               // _LStrAsg(EAX, EDX)
end;

Na entrada da procedure, nós temos EAX apontando para o registro
(primeiro parâmetro), EDX contendo o Id (segundo parâmetro), EDX
apontando para o dado da string Name (terceiro parâmetro). Atribuir
um inteiro é bem simples, mas atribuir uma string é um pouco mais
complicado.

Se a string destino não é uma string vazia então
begin
    Decremente a contagem de referência da string destino;
    Se a contagem de referência da string destino chegou a zero então
      Libere a string destino;
end;

Se a String Origem não for uma string vazia então
    Incremente a contagem de referência da String origem;
Designe origem para o destino;

A procedure _LStrAsg (da Unit System) implementa esta lógica para nós. A
procedure recebe dois parâmetros: o primeiro (em EAX) é a string destino
passada por referência e o segundo (em EDX) é a string origem passada
por valor (o que é passado na verdade é o ponteiro, visto que strings
são ponteiros para os caracteres de fato). Então, no nosso caso, EAX
deveria ser o endereço de uma variável string que será atribuída (isto é
@r.Name), enquanto EDX deveria ser o valor a ser atribuído:

    EAX --> r.Name --> r.Name[1]   ==>   EAX = @r.Name
    EDX --> Name[1]                ==>   EDX = @Name[1]

    Ref.: "-->" significa "aponta para"

Então, preparamos EAX e EDX e então chamamos _LStrAsg:

    lea eax, (TRecord PTR [eax]).Name // EAX := @(EAX^.Name);
    mov edx, ecx                       // EDX := @Name[1];
    call System.@LStrAsg               // _LStrAsg(EAX, EDX)

Funções de baixo nível para trabalhar com records
=================================================

Como arrays estáticos, se o record é passado por valor, é
responsabilidade da função chamada preservar o record. Quando uma função
precisa trocar o valor de um ou mais campos do record passado por valor,
normalmente ela cria uma cópia local e trabalha com a cópia. O
compilador cria uma cópia para nós no "begin" das funções Pascal, mas
nas funções puramente assembler temos que fazê-lo nós mesmos. Um jeito
de fazer isto é como mostrado na parte III com arrays estáticos. Aqui
está outro modo:

procedure OperateOnRecordPassedByValue(r: TRecord);
var
    _r: TRecord;
asm
    // Copia os elementos de "r" (parâmetros) em "_r" (cópia local)
    // Move(r, _r, sizeof(TRecord));

    lea edx, _r                   // EDX := @_r;
    mov ecx, type TRecord         // ECX := sizeof(TRecord);
    call Move                     // Move(EAX^, EDX^, ECX);

    lea eax, _r                   // EAX := @_r;
    mov edx, TRecord_TypeInfo     // EDX := TRecord_TypeInfo;
    call System.@AddRefRecord     // System._AddRefRecord(EAX,EDX);

    lea eax, _r                   // EAX := @_r; // optional

    // Aqui vai o resto da função. Nós trabalharemos no
    // record "_r" (a cópia local), agora apontada por EAX.
end;

Desta vez nós chamamos a procedure Move ao invés de copiarmos os dados
com REP MOVSB. Deste modo, nós escrevemos menos código.

IMPORTANTE: Copiar os valores da memória apenas funciona com records que
não contém campos do tipo reference-counted tais como strings, arrays
dinâmicos ou variantes do tipo string ou arrays dinâmicos.

Se nós tivermos um ou mais campos string, ou campos de algum outro tipo
reference-counted, depois de copiar os valores de memória, nós temos que
incrementar seus respectivos contadores de referência. A procedure
_AddRefRecord (da Unit System) realiza isto. Ela possui dois parâmetros:
um ponteiro para o record (em EAX) e um ponteiro para informação do tipo
de dado para o record gerado pelo compilador (em EDX).

A informação de tipo para o record é basicamente uma estrutura de dados
que contém as posições e tipos de campos reference-counted do registro.
As procedures que trabalham com records declaradas na Unit System,
(_InitializeRecord, _AddRefRecord, _CopyRecord, e _FinalizeRecord)
requerem um ponteiro para a informação do tipo de dado como seu último
parâmetro.

Mas, onde estão os dados? Bem, infelizmente, não há um símbolo para
acessar sua localização diretamente. Nós temos que conseguir seu
endereço através de uma chamada para a função TypeInfo, mas não há uma
função que nós possamos chamar através do código assembler porque não é
uma função verdadeira, e sim uma função interna que o compilador resolve
em tempo de compilação.

Um possível contorno é inicializar uma variável global, chamando a
função TypeInfo de nosso código Pascal:

var
    TRecord_TypeInfo: pointer;

:

initialization
    TRecord_TypeInfo := TypeInfo(TRecord);

E então podemos usá-la como:

procedure OperateOnRecordPassedByValue(r: TRecord);
var
    _r: TRecord;
asm
    // Copiar os elementos de "r" (parâmetro) para "_r" (cópia local)
    // Move(_r, r, sizeof(TRecord));
    lea edx, _r                   // EDX := @_r;
    mov ecx, TYPE TRecord         // ECX := sizeof(TRecord);
    call Move                     // Move(EAX^, EDX^, ECX);
    // System._AddRefRecord(@_r, TypeInfo(TRecord));
    lea eax, _r                   // EAX := @_r;
    mov edx, TRecord_TypeInfo     // EDX := TypeInfo(TRecord);
    call System.@AddRefRecord     // System._AddRefRecord(EAX, EDX);

    lea eax, _r                   // EAX := @_r; // opcional

    // Aqui vai o resto da função. Nós trabalharemos no
    // record "_r" (a cópia local), agora apontada em EAX.

    // Nós temos que finalizar a cópia local antes de retornarmos
    // System._FinalizeRecord(@_r, TypeInfo(TRecord));
    lea eax, _r                   // EAX := @_r;
    mov edx, TRecord_TypeInfo     // EDX := TypeInfo(TRecord);
    call System.@FinalizeRecord   // System._FinalizeRecord(EAX, EDX);
end;

Note que antes da função retornar, nós temos que fazer a chamada a
_FinalizeRecord para destruir o record local (por exemplo, isto
decrementará a contagem de referência de strings apontadas por campos
string).

Chamar Move e então _AddRefRecord é um jeito válido de copiar records
se e apenas se o record de destino tenha sido inicializado (depois de
chamar _AddRefRecord, o record é inicializado). Se o record de destino
já estiver inicializado, então nós temos que chamar _CopyRecord ao invés
disto.

Por Exemplo:

procedure proc(const r: TRecord);
var
    _r: TRecord;
begin
    // _r := r;
    asm
      mov edx, eax                // EDX := @r;
      lea eax, _r                 // EAX := @_r;
      mov ecx, TRecord_TypeInfo   // ECX := TypeInfo(TRecord);
      call System.@CopyRecord     // System._CopyRecord(EAX, EDX, ECX);
    end;
end;

Note que como isto é uma função Pascal normal (não uma função Assembler
completa), o compilador automaticamente gera código para inicializar
e finalizar a variável record local (no "begin" e "end" da procedure
respectivamente).

A combinação Move mais _AddRefRecord é idêntica em efeito a
_InitializeRecord mais _CopyRecord:

procedure OperateOnRecordPassedByValue(r: TRecord);
var
    _r: TRecord;
asm
    // Copiar os elementos de "r" (parâmetro) para "_r" (cópia local)
    // Move(_r, r, sizeof(TRecord));
    // System._InitializeRecord(@_r, TypeInfo(TRecord));
    push eax                      // Push(EAX); // @r
    lea eax, _r                   // EAX := @_r;
    mov edx, TRecord_TypeInfo     // EDX := TypeInfo(TRecord);
    call System.@InitializeRecord // System._InitializeRecord(EAX, EDX);
    // _r := r;
    lea eax, _r                   // EAX := @_r;
    pop edx                       // EDX := Pop(); // @r
    mov ecx, TRecord_TypeInfo     // EDX := TypeInfo(TRecord);
    call System.@CopyRecord       // System._CopyRecord(EAX, EDX, ECX);

    lea eax, _r                   // EAX := @_r; // optional

    // Aqui vai o resto da função. Nós trabalharemos no
    // record "_r" (a cópia local), agora apontada em EAX.

    // Nós temos que finalizar a cópia local antes de retornarmos
    // System._FinalizeRecord(@_r, TypeInfo(TRecord));
    lea eax, _r                   // EAX := @_r;
    mov edx, TRecord_TypeInfo     // EDX := TypeInfo(TRecord);
    call System.@FinalizeRecord   // System._FinalizeRecord(EAX, EDX);
end;

Como _AddRefRecord, a procedure _InitializeRecord é apenas destinada
para ser usada com records não inicializados.

Retornando valores de records
=============================

Retornar valores de records é exatamente o mesmo que retornar valores de
array estático. Funções que retornam records recebem um último parâmetro
adicional que é o ponteiro para a localização em memória onde o valor de
retorno deve ser armazenado, isto é, o valor do último parâmetro é
@Result. A memória para o record de resultado deveria ser alocada,
inicializada e liberada pelo chamador (não é de responsabilidade da
função chamada). Por exemplo, vamos considerar a seguinte função:

function MakeRecord(Id: integer; const Name: string): TRecord;
begin
    Result.Id := Id;
    Result.Name := Name;
end;

A função é declarada para receber dois parâmetros e retornar um record,
mas internamente é como uma procedure com três parâmetros:

1) EAX = O Id para o novo record
2) EDX = O nome para o novo record
3) ECX = O endereço do record de resultado (@Result)

A função pode ser reescrita em assembler como segue :

function MakeRecord(Id: integer; const Name: string): TRecord;
asm // EAX = Id; EDX = @Name[1]; ECX = @Result
    mov (TRecord PTR [ecx]).Id, eax    // ECX^.Id := EAX; // Id
                                       // (@Result)^.Id := EAX;
                                       // Result.Id := EAX;
    // Result.Name := Name;
    // System.@LStrAsg(@(Result.Name), @Name[1])
    // System.@LStrAsg(@(ECX^.Name), @Name[1])
    lea eax, (TRecord PTR [ecx]).Name // EAX := @(ECX^.Name);
    call System.@LStrAsg               // _LStrAsg(EAX, EDX)
end;

NOTA: Nós não designamos o valor EDX antes de chamar _LStrAsg
        porque EDX já contém o valor desejado (passado como parâmetro)

Chamando funções que retornam records
=====================================

Considere o seguinte código:

a := MakeRecord(n, s);

Alguém seria tentado a pensar que o compilador traduz como:

asm
    mov eax, n
    mov edx, s
    lea ecx, a   // ECX := @a; // @Result
    call MakeRecord
end;

Mas as coisas não acontecem deste jeito, ao menos no Delphi 5. O
compilador aloca e inicializa uma variável local que armazena o
resultado e então copia o resultado do record para o record de destino.
Nós não temos apenas ineficiência realizando uma cópia que seria
desnecessária se usássemos um código como o acima, mas- como nós temos
visto acima- a cópia por si mesma não é tão inocente como uma chamada
para a procedure Move (_CopyRecord checa a informação de tipo de dado
em runtime para localizar os campos que requerem tratamento especial).
É claro, a variável local invisível é primeiro inicializada e
eventualmente finalizada. Este modo é extremamente ineficiente. Se
você precisa de velocidade, chame funções record-returning usando
assembler como mostrado acima, passando diretamente o endereço da
variável que irá guardar o resultado como o último parâmetro (@Result).

Bem, é isto por enquanto. Na próxima parte, veremos algumas coisas
básicas sobre o trabalho com objetos.

__________________

NOTA: O Código fonte e a aplicação DEMO estaram anexados no último post desse artigo.

Delphi com assembly (Parte 1)

2011-08-14T17:34:00.001-03:00

Este artigo irá introduzir os conceitos de assembler em linha (inline
assembler) no Delphi. O artigo dará uma noção básica do assunto mas não
pretende oferecer, em hipótese alguma, detalhes da programação assembler
que, por si só, precisariam de um livro inteiro ou mais...

Por que e Quando
================

Se você der uma olhada no código fonte da RTL e da VCL, você encontrará
declarações assembler inline em vários pontos. Por que a Borland optou
por escrever partes do código da RTL e da VCL em assembler? A resposta
é bem simples: para alcançar velocidade na execução. Nós sabemos que o
compilador produz código rápido mas um compilador jamais será tão bom
quanto um programador assembler profissional.

Agora, se o assembler é tão bom, por que não foi utilizado em toda a RTL
e VCL? A resposta é igualmente simples: porque na programação de mais
alto nível, é mais fácil codificar, depurar, ler e manter o código, de
modo que o sacrifício em velocidade fica compensado pelas conveniências
decorrentes. Isso ajuda a explicar quando o assembler deve ser
utilizado. Para ser curto, além do acesso ao sistema em baixo nível, o
assembler inline deve ser utilizado quando a diferença na velocidade de
execução justifica o trabalho adicional da codificação em assembler. Por
exemplo, na unidade Math.pas, há muito assembler, basicamente para
chamadas de sistema em baixo nível (para acesso às funções do
coprocessador); em System.pas, SysUtils.pas e Classes.pas há também
diversos blocos em assembler, desta vez para priorizar velocidade; no
é estranho já que essas podem ser consideradas as unidades centrais da
RTL e VCL.

Em geral, procedimentos e funções que tendem a ser chamadas de forma
repetida por um programa devem ser altamente otimizadas, mas codificação
em assembler deve ser evitada tanto quanto possível. Se desejamos ganhos
em velocidade, antes de optar por assembler devemos otimizar o algoritmo
propriamente dito; depois, otimizamos o código Pascal. Se optarmos por
assembler, o código Pascal otimizado pode servir como documentação e
pode ser utilizado como "código de contigência" no caso de problemas com
a manutenção do código assembler.

Os Registradores da CPU
=======================

Os registradores da CPU são como variáveis predefinidas residindo na CPU
e, por vezes, têm tarefas especiais. Eles não têm tipo e podem ser
vistos como inteiros de 32 bits com ou sem sinal ou como ponteiros,
dependendo da situação.

Como estão na própria CPU, é muito mais rápido acessar valores contidos
nos registradores do que na memória, fazendo dos registros ideais para
fazer cache de valores.

Como variáveis, os registradores também possuem nomes. Os nomes daqueles
que usaremos são EAX, EBX, ECX, EDX, ESI, EDI, EBP e ESP. Cada
registrador tem uma particularidade que o distingue dos demais:

- Para algumas instruções, a CPU foi otimizada para utilizar o
registrador EAX (também conhecido como acumulador) ou ao menos os
opcodes são menores. EAX é usado nas multiplicações e as divisões,
intructions de string, instruções de I/O, instruções de ajuste ASCII
e decimal, e em algumas instruções especiais (como CDQ, LAHF, SAHF e
XLAT).
- EBX é um registrador de uso geral, e é usado implicitamente por XLAT.
- ECX (também conhecido como contador) tem emprego especial nas
instruções LOOP, de rotação e deslocamento de bits e de manipulação
de literais.
- EDX é utilizado para armazenar os 32 bits mais altos do resultado de
uma multiplicação ou os os 32 bits mais altos do dividendo e do resto
de uma divisão.
- ESI e EDI (conhecidos como índice de origem (source index) e índice
de destino ("destination index") respectivamente) são como ponteiros
utilizados em instruções envolvendo strings.
- EBP (conhecido como ponteiro base) é normalmente usado para endereçar
valores na pilha (parâmetros e variáveis locais).
- ESP (conhecido como ponteiro da pilha) é utilizado para controlar a
pilha. É alterado automaticamente por instruções como PUSH, POP, CALL
e RET.

Os registradores EBX, ESI, EDI, EBP e ESP devem ser preservados, o que
significa que antes de usá-los, devemos salvar seus valores em algum
lugar (normalmente na pilha ou outro registradores) e, quando
terminarmos de usá-los, devemos restaurar seus valores originais (essas
operações implicam no uso de instruções e perda de algum tempo) de modo
que o uso desses registradores será feito somente quando justificável ou
quando houver uma necessidade inevitável.

Provavelmente você percebeu que os nomes dos registradores iniciam com
a letra "E". O "E" representa "Extended", estendido. Nos tempos do Intel
80286, os registradores tinham 16 bits e eram chamados AX, BX, CX, etc.
Esses registradores ainda existem e são exatamente os 16 bits menos
significativos dos registradores EAX, EBX, ECX, etc., respectivamente. A
propósito disso, os registradores AX, BX, CX e DX são divididos em dois
registradores de 8 bits. AL, BL, CL e DL são os bytes menos
significativos de AX, BX, CX e DX respectivamente, enquanto AH, BH, CH e
DH são os bytes mais significativos de AX, BX, CX e DX respectivamente.
Por exemplo, se o valor de EAX é $7AFD503C, então o valor de AX é $503C,
o valor de AH é $50 e o valor de AL é $3C:

                             7A FD 50 3C
                                     AH AL
                                     /----/
                                       AX
                             /------------/
                                  EAX

Se, na situação acima, armazenarmos o valor $99 em AH, então EAX
passaria a ter o valor $7AFD993C.

Existe um registrador especial, o registrador de indicadores (flags),
que armazena indicadores binários alterados por instruções matemáticas
e lógicas ou explicitamente por código, e que são normalmente usados
em instruções de desvio condicional. O indicador carry também é usado
em algumas instruções de rotação e o indicador de direção é utilizado
em instruções envolvendo literais.

Esse registrador não é acessível por nome como os demais registradores;
mas pode ser copiado e restaurado através da pilha, utilizando PUSHF e
POPF respectivamente, e pode também ser copiado e restaurado
parcialmente através do registrador AH, utilizando LAHF e SAHF
respectivamente.

Instruções Assembler
====================

Instruções assembler são dispostas em blocos asm..end blocks e têm a
seguinte forma:

[identificador:] [prefixo] opcode [operando1 [, operando2 [, ...]]]

Onde opcode é o nome da instrução como MOV, ADD, PUSH, etc.

Instruções podem ser separadas por ponto e vírgula, quebras de linhas
ou comentários. A propósito, comentários são no formato do Object
Pascal, isto é, o ponto e vírgula não é considerado o início de um
comentário até o final da linha, como no assembler tradicional.

A seguir, um exemplo de bloco asm..end com vários dos possíveis tipos de
instruções e separadores de comentários:

asm
    xchg ebx, edx; add eax, [ebx]; {ponto e vírgula separa declaração}
    // quebra de linha separa declaração
    mov ebx, p
    sub eax, [ebx] (*comentário separa declaração*) mov ebx, edx
end;

A convenção é utilizar quebras d elinhas para separação:

asm
    xchg ebx, edx
    add eax, [ebx]
    mov ebx, p
    sub eax, [ebx]
    mov ebx, edx
end;

No código da VCL, você verá que os opcodes e nomes de registradores são
escritos em maiúsculas e que instruções são indentadas em uma tabulação
(normalmente equivalente a oito caracteres), mas utilizaremos outra
convenção neste artigo.

Blocos asm..end podem ocorrer em qualquer ponto do código fonte onde uma
declaração Pascal ordinária puder aparecer; além disso, é possível
termos rotinas 100% assembler se, ao invés de "begin", utilizarmos
"asm":

procedure teste;
asm
    // declarações assembler
end;

Note que as duas implementações abaixo não são equivalentes:

function f(parâmetros): tipo;
begin
    asm
      // declarações assembler
    end;
end;

function f(parâmetros): tipo;
asm
    // declarações assembler
end;

A razão disso é que o compilador realiza certas otimizações quando
implementamos rotinas inteiramente em assembler, sem utilizar um bloco
begin..end.

As etiquetas devem ser declaradas em uma seção Label, como em qualquer
código Object Pascal, a menos que foram prefixadas por "@@":

function ENumeroMagico(x: integer): boolean;
asm
    cmp eax, NumeroMagico
    je @@Bingo
    xor eax, eax
    ret
@@Bingo:
    mov eax, 1
end;

As etiquetas prefixadas por "@@" são locais ao bloco asm..end em que são
usadas. Isto gerará um erro da compilaçao:

begin
    ....
    asm
      ....
      @@destino:
      ....
    end;
    ....
    asm
      ....
      jnz @@destino         // Error
      ....
    end;
    ....
end;

Para corrigi-lo, necessitamos usar uma etiqueta convencional, local ao
procedimento ou à função:

label
    destino;
begin
    ....
    asm
      ....
      destino:
      ....
    end;
    ....
    asm
      ....
      jnz destino           // Correto
      ....
    end;
    ....
end;

Operandos
=========

Certas vezes, um ou mais operandos são implícitos. Por exemplo, a
instrução CDQ (Converta Dword para Qword) parece não utilizar operando
algum; entretanto, essa instrução utiliza EDX e EAX: o bit mais alto
de EAX, o bit de sinal, é copiado para EDX de forma que, EDX:EAX passa
a representar o inteiro em EAX convertido para Int64, onde EAX carrega
os 32 bits menos significativos e EDX os 32 bits mais significativos.

Para a maioria das instruções, os operandos são registradores. Por
exemplo:

mov eax, ecx

copia o valor de ECX para EAX.

Operandos podem conter valores imediatos:

mov eax, 5
mov eax, 2 + 3 // expressão constante, resolvida na compilação
mov al, 'A'     // o código ASCII de 'A' é $41 (65)
mov eax, 'ABC' // equivalente a MOV EAX, $00414243

Operandos também podem conter referências de memória:

mov [ebx], eax // EBX^ := EAX;

Referências de memória aparecem de várias formas:

mov eax, [$000FFFC]     // Endereço absoluto
mov eax, [ebx]          // Registrador
mov eax, [ebp-12]       // Registrador mais/menos deslocamento
                          // constante
mov eax, [ebp+ebx]      // Registrador mais deslocamento em registro
mov eax, [ebp+ebx+8]    // Registrador mais deslocamento em registro
                          // mais/menos deslocamento constante
mov eax, [ebp+ebx*4]    // Registrador mais deslocamento em registro
                          // multiplicado por constante
mov eax, [ebp+ebx*4+8] // Registrador mais deslocamento em registro
                          // multiplicado por constante, mais/menos
                          // deslocamento constante

Os identificadores usuais do Pascal são traduzidos para uma das formas:

mov eax, parâmetro    // mov eax, [ebp + deslocamento_constante]
mov eax, varlocal     // mov eax, [ebp - deslocamento_constante]
mov eax, varglobal    // mov eax, [endereço_absoulto]
call procname         // chama endereço absoluto

Primeiro Exemplo
================

Agora que estamos prontos para aprender alguns opcodes, vamos aos
exemplos. Podemos começar com uma função simples:

function f(x: integer; y: integer): integer;
// f(x,y) = (-x-y+5)*7
{
    begin
      Result := (-x - y + 5) * 7;
    end;
}
asm
    // os parâmetros são passados em EAX (x) e EDX (y);
    neg eax       // EAX := -EAX;       // EAX = -x
    sub eax, edx // EAX := EAX - EDX; // EAX = -x-y
    add eax, 5    // EAX := EAX + 5;    // EAX = -x-y+5
    imul 7        // EAX := EAX * 7;    // EAX = (-x-y+5)*7
end;

Os três primeiros parâmetros (da esquerda para a direita) são passados
em EAX, EDX e ECX. Para métodos, o primeiro parâmetro é Self (passado
em EAX) e o primeiro parâmetro explicitamente declarado é, de fato, o
segundo parâmetro (passado em EDX) e o segundo parâmetro explícito é
de fato o terceiro parâmetro (passado em ECX).

O valor de retorno deve ser armazenado em EAX para valores ordinais de
32 bits (AX e AL devem ser utilizados para retornar valores de 16 e 8
bits respectivamente).

Os comentários explicam os opcodes de forma clara mas, para IMUL, temos
que acrescentar duas explicações:

* IMUL considera os operandos (EAX e 7 no exemplo) como inteiros com
sinal (devemos utilizar MUL quando os operandos não possuírem sinal).

* O resultado da multiplicação é um inteiro de 64 bits sendo que os 32
bits mais significativos do resultado são armazenados em EDX.

Multiplicações são relativamente caras em termos de tempo de CPU e, por
vezes, é mais fácil substitui-las por deslocamentos de bits (quando a
multiplicação ou divisão operarem com potências de dois), somas e
subtrações. Por exemplo:

a * 7 = a * (8 - 1)
        = a * 8 - a
        = a * 2^3 - a
a * 7 = a shl 3 - a

Ao invés de IMUL 7, podemos fazer o seguinte:

    mov ecx, eax // ECX := EAX;        // ECX = -x-y+5
    shl eax, 3    // EAX := EAX shl 3; // EAX = (-x-y+5)*8
    sub eax, ecx // EAX := EAX - ECX; // EAX = (-x-y+5)*8 - (-x-y+5)
                                        // EAX = (-x-y+5)*7

Vejamos outro exemplo:

function resto(x: integer; y: integer): integer;
// Retorna o resto de x dividido por y
{
    begin
      Result := x mod y;
    end;
}
asm
    // os parâmetros são passados em EAX (x) e EDX (y);
    mov ecx, edx   // ECX := EDX; // EDX = y
    cdq            // EDX:EAX := Int64(EAX); // EAX = x
    idiv ecx       // divisão inteira com sinal em 32 bits:
                   //   EAX := Int64(EDX:EAX) div integer(ECX);
                   //   EDX := Int64(EDX:EAX) mod integer(ECX);
    mov eax, edx   // Result := EDX; // resto
end;

A Pilha
=======

Quando um programa é carregado, ele receve uma pilha, que é uma região
de memória utilizada como uma estrutura LIFO, "Last In, First Out"
(último a chegar, primeiro a sair), controlada pelo registrador ESP
que aponta para o topo dessa pilha. ESP inicia apontando para o final
da região de modo que, cada vez que empilhamos um novo valor de 32 bits,
o registrador ESP é decrementado em 4 (bytes) e o valor é armazenado no
local apontado por ESP.

|           |
+-----------+
|           |
+-----------+
| $01234567 | <- ESP
+-----------+
|           |

PUSH $89ABCDEF   // SUB ESP,4; MOV [ESP],$89ABCDEF

|           |
+-----------+
| $89ABCDEF | <- ESP
+-----------+
| $01234567 |
+-----------+
|           |

De forma análoga, quando retiramos um valor de 32 bits da pilha, o valor
é recuperado do local apontado por ESP e ESP é incrementado em 4 (bytes).

POP EAX   // MOV EAX,[ESP]; ADD ESP,4

|           |
+-----------+             +-----------+
| $89ABCDEF |         EAX | $89ABCDEF |
+-----------+             +-----------+
| $01234567 | <- ESP
+-----------+
|           |

A pilha é utilizada para armazenar endereços de retorno de rotinas,
parâmetros, variáveis locais e resultados intermediários. No exemplo
a seguir, utilizamos a pilha para salvar o valor de um registrador
para uso posterior:

function IntDiv(x: integer; y: integer; r: pinteger = NIL): integer;
// Retorna o quociente inteiro x / y e o resto em r
{
    begin
      Result := x div y;
      if r <> NIL then r^ := x mod y;
    end;
}
asm
    // os parâmetros são passados em EAX (x), EDX (y) e ECX (r)
    push ecx         // Salve ECX (r) para uso posterior
    mov ecx, edx     // ECX := EDX; // ECX = y
    cdq              // EDX:EAX := Int64(EAX); // EAX = x
    idiv ecx         // divisão inteira com sinal em 32 bits:
                     //   EAX := Int64(EDX:EAX) div integer(ECX);
                     //   EDX := Int64(EDX:EAX) mod integer(ECX);
    pop ecx          // Restaura ECX (ECX := r)
    cmp ecx, 0       // if ECX = NIL then
    jz @@end         //   goto @@end;
    mov [ecx], edx   // ECX^ := EDX; // resto
@@end:             // identificador local (precedido por "@@")
end;

Note que, para cada PUSH que executamos, temos que executar um POP
correspondente de modo que ESP fique inalterado (ESP é um dos
registradores que temos que preservar).

A instrução CMP subtrai o segundo operador do primeiro (ECX-0 nesse
caso), como a instrução SUB, mas o resultado não é armazenado em lugar
algum, ainda que o indicador de Zero (Zero flag) seja marcado (ligado)
ou limpo (desligado) dependendo do resultado ser zero ou não, como em
qualquer instrução lógica ou matemática (com a exceção de certos casos).
Podemos então tirar vantagem desse fato e, ao invés de escrevermos

    cmp ecx, 0

podemos escrever

    or ecx, ecx      // ECX := ECX or ECX;

O resultado de ECX Or ECX é o próprio ECX; portanto, o valor armazenado
em ECX é o mesmo de antes, e como dissemos anteriormente o indicador de
Zero será marcado se o resultado for zero (isto é, se ECX era zero).

A instrução JZ, "Jump if Zero" (Desvie se Zero), desvia (salta) para o
identificador indicado como operando se o valor do indicador de Zero
estiver marcado (ligado) ou continua normalmente com o fluxo de execução
se o indicador de Zero estiver desmarcado (desligado).

Passando Parâmetros para a Pilha
--------------------------------

Voltemos para a pilha. Dissemos que os três primeiros parâmetros de
uma rotina são passados em EAX, EDX e ECX; mas, o que acontece quando
temos mais de três parâmetros? Parâmetros adicionais são passados na
pilha, da esquerda para a direita, de forma que o último parâmetro será
sempre o primeiro da pilha.

Suponha que temos a seguinte função

function Soma(a, b, c, d, e: integer): integer;
begin
    Result := a + b + c + d + e;
end;

e queremos fazer a chamada

Sum(1,2,3,4,5);

Em assembler, faríamos da seguinte forma:

mov eax, 1
mov edx, 2
mov ecx, 3
push 4
push 5
call Sum

A instrução CALL empilha o endereço de retorno na pilha e salta para
(inicia a execução) da função. A instrução RET (RETorna) gerada pelo
compilador quando o final de uma função é alcançado desempilha esse
endereço da pilha e salta para ele para continuar a execução a partir
desse ponto.

Note que quando empilhamos parâmetros na pilha mas não os desempilhamos.
Isso acontece pois limpar a pilha é responsabilidade da função chamada e
não da função que chama (exceto na convenção de chamada CDECL). Para
limpar os parâmetros, a instrução RET é utilizada com um operando que
indica o número de bytes que ESP deve ser incrementado (8 nesse caso já
que ESP foi decrementado em 4 bytes para cada parâmetro empilhado). O
compilador fica encarregado dessa tarefa portanto não temos com que nos
preocupar; mas, se você utilizar a janela de depuração da CPU e
encontrar uma instrução RET $08, agora você já sabe do que se trata.

Na entrada para Soma, a pilha estaria, em teoria, da seguinte forma:

|           |
+-----------+
| Ret_Addr | <- ESP
+-----------+
| $00000005 | (parâmetro e)
+-----------+
| $00000004 | (parâmetro d)
+-----------+
|           |

Quando uma função tem parâmetros na pilha (ou variáveis locais), o
compilador gera algumas instruções chamadas de "stack frame", quadro
da pilha. Na entrada da função (em "asm"), EBP é empilhado de modo a
ser preservado e ESP é atribuído a ele; e, antes de deixar a função,
(em "end"), o valor original de EBP é desempilhado:

function Soma(a, b, c, d, e: integer): integer;
asm // push ebp; mov ebp, esp;
    ....
end; // pop ebp; ret 8;

Assim, quando entramos em Soma, a pilha estaria de fato da seguinte
forma:

|           |
+-----------+
| Orig. EBP | <- EBP, ESP
+-----------+
| Ret_Addr |
+-----------+
| $00000005 | <- EBP+8   (parâmetro e)
+-----------+
| $00000004 | <- EBP+12 (parâmetro d)
+-----------+
|           |

Em [EBP] encontramos o valor original de EBP que foi empilhado para
ser preservado quando da construção do quadro de pilha; em [EBP+4]
encontramos o endereço de retorno da rotina; em [EBP+8] encontramos
o último parâmetro (o último parâmetro é empilhado por último e, por
isso, é o primeiro da pilha). O parâmetro seguinte (da direita para
a esquerda) fica em [EBP+12], e assim por diante se houvesse outros
parâmetros.

Agora vamos escrever a rotina Soma em assembler:

function Soma(a, b, c, d, e: integer): integer;
{
    begin
      Result := a + b + c + d + e;
    end;
}
asm
    add eax, b
    add eax, c
    add eax, d
    add eax, e
end;

Note que no bloco asm..end nós utilizamos "b", "c", "d" e "e" ao invés
de "EDX", "ECX", "[EBP+12]" e "[EBP+8]" respectivamente. Nós podemos
fazer assim já que o compilador fará as substituições adequadas.

Variáveis Locais na Pilha
-------------------------

Se nossa função assembler inline tiver variáveis locais, o compilador
criará espaço para essas variáveis na pilha, movendo o ponteiro da pilha
de modo que o quadro da pilha para uma função com duas variáveis locais
inteiras seria:

push ebp
mov ebp, esp
sub esp, 8      // Desloca ESP como se empilhássemos 8 bytes

...

add esp, 8      // Desloca ESP como se desempilhássemos 8 bytes
pop ebp

Para o propósito do exemplo, aqui vai uma variação da rotina Soma acima,
utilizando duas variáveis locais:

function SomaL(a, b, c, d, e: integer): integer;
var
    f, g: integer;
{
    begin
      f := b + c;
      g := d + e;
      Result := a + f + g;
    end;
}
asm // push ebp; mov ebp, esp; sub esp, 8;
    add edx, ecx
    mov f, edx     // b + c
    mov edx, d
    add edx, e
    mov g, edx     // d + e
    add eax, f
    add eax, g
end; // add esp, 8; pop ebp; ret 8

Nessa função, a pilha teria o seguinte aspecto:

|           |
+-----------+
| var. g | <- EBP-8, ESP
+-----------+
| var. f | <- EBP-4
+-----------+
| Orig. EBP | <- EBP
+-----------+
| Ret_Addr |
+-----------+
| Param e | <- EBP+8
+-----------+
| Param d | <- EBP+12
+-----------+
|           |

O Que Vem Agora?
================

Na continuação deste artigo, aprenderemos mais instruções e veremos
como passar e retornar outros tipos de parâmetros, como trabalhar com
arrays, como acessar campos de registros e objetos, como chamar métodos
e mais.

Nesse capítulo iremos aprender algumas novas instruções assembler e o
básico da manipulação de strings ANSI, também chamadas de strings longas.

Novos opcodes
=============

Abaixo os opcodes introduzidos neste atrigo:

* JL (Jump if Lower, desvie se menor): A descrição mais adequada levaria
muito tempo para ser explicada, então vamos dizer que JL salta (desvia)
para o label especificado desde que na operação CMP (ou SUB) anterior
o primeiro operando seja menor que o segundo numa comparação com sinal:

    // if signed(op1) < signed(op2) then goto @@label;
    cmp op1, op2
    jl @@label

JG (Jump if Greater, desvie se maior), JLE (Jump if Lower or Equal,
desvie se menor ou igual) e JGE (Jump if Greater or Equal, desvie se
maior ou igual) completa a família de desvios condicionais para
comparações com sinal.

* JA (Jump if Above, desvie se maior): salta (desvia) para o label
especificado desde que na operação CMP (ou SUB) anterior o primeiro
operando seja maior que o segundo numa comparação sem sinal:

    // if unsigned(op1) > unsigned(op2) then goto @@label;
    cmp op1, op2
    ja @@label

JB (Jump if Below, desvie se menor), JBE (Jump if Below or Equal,
desvie se menor ou igual) e JAE (Jump if Above or Equal, desvie se
maior ou igual) completam a família de desvios condicionais para
comparações sem sinais.

* LOOP: Decrementa ECX e, se não for zero, desvia para o label indicado.
LOOP @@label é o equivalente mais curto e rápido de:

    dec ecx       // ECX := ECX - 1;
    jnz @@label   // if ECX <> 0 then goto @@label

Examplo:

    xor eax, eax    // EAX := EAX xor EAX; // EAX := 0;
    mov ecx, 5      // ECX := 5;
@@label:
    add eax, ecx    // EAX := EAX + ECX; // Executado 5 vezes
    loop @@label    // Dec(ECX); if ECX <> 0 then goto @@label;

    // EAX seria 15 (5+4+3+2+1)

Trabalhando com strings ANSI
============================

Uma variável string é representada por um ponteiro de 32 bits. Se a
string é vazia (''), então o ponteiro é nil (zero), caso contrário,
esse ponteiro aponta para o primeiro caractere dessa string. O tamanho
da string e a contagem de referência são dois inteiros em deslocamentos
negativos a partir do primeiro byte da string:

          +-----------+
          | s: string |-------------------+
          +-----------+                   |
                                          V
--+-----------+-----------+-----------+---+---+---+---+---+---+---+--
    | allocSiz |   refCnt | length   | H | e | l | l | o | ! | #0|
--+-----------+-----------+-----------+---+---+---+---+---+---+---+--
      (longint)   (longint)   (longint)

    \-----------------v-----------------/
                StrRec record
     const skew = sizeof(StrRec); // 12

Quando passamos uma string como um parâmetro para uma função, o que de
fato é passado é o ponteiro de 32 bits. Os valores string são um pouco
mais complicados de explicar. A rotina que chamou a rotina que retorna
a string deve passar- como último e invisível parâmetro da chamada, um
tipo PString-o endereço de uma variável string que receberá o resultado
da função.

d := Uppercase(s); // Internamente convertido para: Uppercase(s, @d);

Se o resultado da função é usado em uma expressão ao invés de ser
atribuído diretamente à variável, a rotina que chama deve utilizar uma
variável temporária incializada com nil (string vazia). O compilador faz
tudo isso automaticamente no nosso código Object Pascal mas, se temos
que fazer isso por conta própria se optarmos por escrever código
assembler que chame rotinas que retornam strings.

Para algumas tarefas, não podemos chamar as clássicas funções de string
diretamente. Por exemplo, a função Length não é o nome de uma função de
verdade,. É uma construção interna do próprio compilador e o compilador
gera o código para a função apropriada, dependendo do parâmetro ser uma
string ou um array dinâmico. Em assembler, ao invés de Lenght, teríamos
que usar a função LStrLen (declarada na unidade System) para obter o
tamanho da string.

Existem mais coisas que deveríamos saber a respeito das strings mas o
que temos já é suficiente para um primeiro exemplo.

Versão Assembler de Uppercase
=============================

Eis a declaração da função:

function AsmUpperCase(const s: string): string;

O parâmetro "s" será passado em EAX e o endereço de "Result" será
passado como o segundo parâmetro, ou seja, em EDX.

Basicamente a função deve fazer:

1) Obter o comprimento da string a converter
2) Alocar memória para a string convertida
3) Copiar os caracteres um a um, convertidos para maiúsculas

1) Obter o comprimento da string a converter
--------------------------------------------

Faremos isso através de uma chamada a System.@LStrLen. A função espera
a string em EAX (ela já está lá) e o resultado será colocado em EAX;
então, temos que salvar o valor de EAX (o parâmetro "s") em algum lugar
antes de chamar a função de modo que "s" não seja perdido. Podemos salvar
numa variável local "src". Já que funções são livres para utilizar os
registradores EAX, ECX e EDX, presumimos que o valor em EDX ("@Result")
poderia também ser destruído após uma chamada a System.@LStrLen, de modo
que é útil salvar esse valor numa variável local, por exemplo, "psrc".
O resultado da chamada a System.@LStrLen, deixado em EAX, servirá como
parâmetro da chamada a System.@LStrSetLength (para alocar memória para
o conteúdo da string de resultado), como contador dos bytes a copiar, de
modo que esse valor também deve ser salvo, por exemplo, na variável "n":

var
    pdst: Pointer; // Endereço da string resultado
    src: PChar;     // String de origem
    n: Integer;     // Comprimento da string de origem
asm
    // O endereço da string de resultado é passado em EDX.
    // Salvamos esse valor na variável pdst:
    mov pdst, edx   // pdst := EDX;

    // Salvamos EAX (s) na variável local (src)
    mov src, eax    // src := EAX;

    // n := Length(s);
    call System.@LStrLen   // EAX := LStrLen(EAX);
    mov n, eax             // n := EAX;

2) Alocar memória para a string convertida
------------------------------------------

A alocação é realizada através de uma chamada a System.@LStrSetLength.
O procedimento espera dois parâmetros: o endereço da string (que
salvamos em "pdst") e o comprimento da string (que está em EAX).

    // SetLength(pdst^, n); // Alocar a string de resultado
    mov edx, eax // EDX := n;    // Segundo parâmetro p/LStrSetLength
    mov eax, pdst // EAX := pdst; // Primeiro parâmetro p/LStrSetLength
    call System.@LStrSetLength    // LStrSetLength(EAX, EDX);

3) Copiar os caracteres um a um, convertidos para maiúsculas
------------------------------------------------------------

Se o comprimento da string era zero, já terminamos:

    // if n = 0 then exit;
    mov ecx, n     // ECX := n;
    test ecx, ecx // Fazer and de ECX com ECX para definir flags
                   // (ECX inalterado)
    jz @@end       // Ir para @@end se o flag zero está marcado (ECX=0)

Não sendo esse o caso, devemos copiar os caracteres de uma string para
a outra, convertendo-os para maiúsculas conforme necessário. Nós vamos
utilizar ESI e EDX para apontar para os caracteres da string de origem
e destino respectivamente, AL para carregar os caracteres da string de
origem e realizar a mudança antes de armazená-los na string de destino e
ECX para controlar a instrução de LOOP que contará os caracteres. Já que
ESI é um registro que tem que ser preservado, devemos salvar seu valor
para restaurá-lo mais tarde. Decidi salvar ESI colocando-o na pilha.

    push esi         // Salve ESI na pilha

    // Inicializar ESI e EDX
    mov eax, pdst    // EAX := pdst; // Endereço da string de resultado
    mov esi, src     // ESI := src;   // String de origem
    mov edx, [eax]   // EDX := pdst^; // String de resultado

@@cycle:
    mov al, [esi]       // AL := ESI^;
    // if Shortint(AL) < Shortint(Ord('a')) then goto @@nochange
    cmp al, 'a'
    jl @@nochange
    // AL in ['a'..#127]
    // if Byte(AL) > Byte(Ord('a')) then goto @@nochange
    cmp al, 'z'
    ja @@nochange
    // AL in ['a'..'z']
    sub al, 'a'-'A'     // Dec(AL, Ord('a')-Ord('A'));
@@nochange:
    mov [edx], al       // EDX^ := AL;
    inc esi             // Inc(ESI);
    inc edx             // Inc(EDX);
    loop @@cycle        // Dec(ECX); if ECX <> 0 then goto cycle

    pop esi             // Restaurar ESI da pilha

@@end:
end;