paradigmas_de_programacao_1_X.pdf

Paradigmas de Programação
Ronaldo Ramos
Instituto Federal do Ceará
24 de julho de 2023

Programa do Curso
Noções Sobre Paradigmas de Programação
1 Paradigmas e Níveis de Abstração
2 Paradigma 1 - Imperativo
3 Paradigma 2 - Declarativo
4 Paradigma 3 - Misto
5 Baseada em Linguagem Natural (Quem viver Verá!!!)
Ronaldo Ramos (Instituto Federal do Ceará) Paradigmas de Programação 24 de julho de 2023 2 / 205

Programa do Curso
Paradigma Imperativo
1 Abstração Simples - Linear
2 Programação Estruturada
3 Programação Orientada a Objetos
4 Programação Por Aspectos

Programa do Curso
Paradigma Declarativo
1 Programação em Lógica
2 Programação Funcional

Importância da Linguagem
"Os limites da minha língua são os limites do meu mundo.”
Ludwig Wittgenstein

Linguagens de Programação a Serem Usadas
Assembly, Basic, Pascal, Ruby, Prolog, Haskel, Lisp, Python, etc etc

Paradigmas
que é um paradigma?
Um paradigma é um princípio ou elemento que funciona como um
pressuposto formando um modelo ou perspectiva para resolver problemas
ou abordar uma determinada área do conhecimento. Na ciência da
computação, os paradigmas de programação definem a forma como os
programas são estruturados, organizados e construídos.

Máquina de Turing
https://turingmachine.io/

Paradigma Imperativo
(Diga-me como fazer...)

Linguagem de Máquina
Formato do Arquivo.

Dados e Instruções

Primeira Abstração Mnemônicos e Montador/Tradutor
Mnemônicos e operadores aritméticos são usados para construir textos
equivalentes ao código de máquina porém bem mais fácil de entender.
Surge a linguagem Assembly ou linguagem de montagem. Usada para
’montar’ programas.

Elementos Para Programação em Assembly
1 Arquitetura do Processador. registradores de propósito geral,
registradores de status, registradores de ponteiro de instrução, etc.),
tamanhos de palavra (por exemplo, 8 bits, 16 bits, 32 bits, 64 bits) e
conjunto de instruções específicas.
2 Memória: Organização da memória (páginas e segmentos), como a
distinção entre memória de código (onde as instruções são
armazenadas) e memória de dados (onde os dados são armazenados).

1 Pilha: Pilha de execução (stack) e como ela é usada para armazenar
dados e endereços de retorno durante a execução de sub-rotinas
(funções).Registradores de ponteiros de pilha (stack pointers).
2 Interrupções e Modos de Execução: Interrupções e modos de
execução disponíveis no processador(modo usuário, modo kernel,
etc.).

1 Entrada e Saída
2 Regras de Codificação

Porque Usar Assembly?
1 Otimização de Desempenho
2 Acesso a Todos os Recursos do Hardware
3 Programação de Sistemas Embarcados
4 Comunicação Direta com o Hardware
5 Minimização do Tamanho do Programa Executável
6 Depuração em Baixo Nível
7 Estudo e Teste das Funcionalidades da Arquitetura do Hardware
8 Integração de Códigos em Baixo Nível

Uma Breve Introdução ao Assembly

O que vamos precisar
1 Um compilador ou montador (assembler)
2 Um link editor ou editor de ligação
3 Um editor de texto

Assemblers (Montadores/Compiladores)
1 NASM (Netwide Assembler): O NASM é um assembler de propósito
geral que suporta várias arquiteturas, incluindo x86 e x86-64. É
amplamente utilizado em sistemas Linux e Windows.
2 MASM (Microsoft Macro Assembler): Desenvolvido pela Microsoft, é
amplamente utilizado para desenvolvimento de software para sistemas
Windows. Suporta arquiteturas x86 e x64.
3 FASM (Flat Assembler): O FASM é um assembler de código aberto
que suporta várias arquiteturas, incluindo x86 e x86-64. Ele é
conhecido por seu tamanho pequeno e desempenho rápido.
4 TASM (Turbo Assembler): Desenvolvido pela Borland, era muito
popular no passado para desenvolvimento de software para MS-DOS e
Windows. Ainda é usado em alguns cenários legados.

Assemblers - continuação
1 GAS (GNU Assembler): O GAS é o assembler padrão da GNU
Compiler Collection (GCC) e é usado principalmente em projetos de
código aberto e sistemas Unix-like, como o Linux.
2 Keil A51 e A251: Compiladores assemblers específicos da Keil para
arquiteturas 8051 e 8052, amplamente utilizados para
desenvolvimento de sistemas embarcados.
3 ASM51: Assembler específico da Intel para a arquitetura 8051.
4 ARM Assemblers: Há vários compiladores assemblers específicos para
as diversas arquiteturas da família ARM, como ARMASM (para
ARM32), AARCH64 (para ARM64) e outros.
5 AVR Assemblers: Compiladores assemblers específicos para a
arquitetura AVR utilizada em microcontroladores, como o avr-as da
GNU Binutils.

Editores de Ligação (linkers)
1 GNU Linker (ld): O GNU Linker é o linker padrão usado na maioria
dos sistemas operacionais baseados em Unix, como Linux. É uma
parte importante das ferramentas GNU Binutils.
2 Microsoft Linker (link): O Microsoft Linker é o linker padrão para
sistemas Windows e faz parte do Microsoft Visual Studio e Microsoft
Developer Tools.
3 Apple ld: Esse linker é usado em sistemas macOS e iOS para fazer a
ligação de programas objetos.
4 Gold Linker: O Gold é um linker de alto desempenho desenvolvido
como uma alternativa mais rápida ao GNU Linker (ld) para sistemas
Linux.

Editores de Ligação (linkers) - Continuação
1 LLD (LLVM Linker): O LLD é o linker do projeto LLVM e é usado
para sistemas que utilizam o LLVM como infraestrutura de
compilação, como algumas distribuições Linux.
2 BFD (Binary File Descriptor) Linker: O BFD é uma biblioteca de
manipulação de formatos de arquivo binário que inclui funcionalidades
de ligação.
3 SunOS/Solaris Linker: Usado em sistemas Solaris e outros sistemas
baseados em SunOS.
4 OpenVMS Linker: Usado no sistema operacional OpenVMS.

Estrutura de Um Programa em Assembly
Um programa é dividido em seções tais como:
1 Seção de Dados (Data Section): Nesta seção, são definidas as
variáveis e constantes utilizadas no programa. As declarações de
dados podem incluir reservas de memória para armazenar valores ou
informações, bem como definições de constantes.
2 Seção de BSS (Block Started by Symbol): Nesta seção, são
declaradas variáveis que ocuparão espaço na memória, mas não são
inicializadas com um valor específico. Elas serão inicializadas com
zero quando o programa começar a ser executado.
3 Seção de Texto (Text Section ou Code Section): Essa é a parte
principal do programa, onde o código assembly é colocado. Aqui
estão as instruções que serão executadas pelo processador. É onde a
lógica do programa é implementada.

Seções de Um programa Assembly - Continuação
1 Seção de Inicialização (Initialization Section): Algumas arquiteturas
de processadores possuem uma seção especial de inicialização onde é
colocado o código responsável por configurar o ambiente antes de
iniciar a execução do programa principal.
2 Seção de Importação e Exportação (Import and Export Section): Essa
seção é usada em sistemas operacionais que suportam bibliotecas
compartilhadas (shared libraries) ou DLLs (Dynamic Link Libraries).
Ela contém informações sobre as funções que o programa usa de
outras bibliotecas (importação) e funções que o programa
disponibiliza para serem usadas por outros programas (exportação).
3 Seção de Tabelas (Tables Section): Em alguns programas,
especialmente em sistemas embarcados, são utilizadas seções de
tabelas para armazenar dados como vetores, matrizes, e outras
estruturas de dados pré-definidas.

Convenções de Sintaxes
1 Sintaxe Intel (ou x86): A sintaxe Intel é comumente usada em
processadores da arquitetura x86, como os fabricados pela Intel e
AMD. Nessa sintaxe, as operações são frequentemente escritas com o
nome do mnemônico seguido pelos operandos, separados por vírgulas.
Por exemplo: MOV AX, 42 ou ADD BX, AX.
2 Sintaxe AT&T (ou GNU): A sintaxe AT&T é comumente usada no
GNU Assembler (GAS) e em algumas ferramentas relacionadas ao
projeto GNU. Nessa sintaxe, os operandos são precedidos por sinais
de cifrão ($) para imediatos e por porcentagens (%) para endereços
de memória. Por exemplo: MOV $42, %AX ou ADD %AX, %BX.
3 Sintaxes ARM, MIPS, SPARC, etc.

Declarações em Assembly
1 Instruções ou instruções executáveis,
2 Diretivas de montadora ou pseudo-ops, e
3 Macros.

Sintaxe Básica (x86)
1 [label] mnemônico [operandos] [ ;comentários]
Exemplos:
1 INC COUNT ; Incrementar a variável de memória
COUNT.
2 MOV TOTAL , 48 ; Transferir o valor 48 para a
variável de memória TOTAL
3 ADD AH , BH ; Adicionar o conteúdo do registrador
BH ao registrador AH
4 AND MASK1 , 128 ; Realizar uma operação AND (E
lógico) entre a variável MASK1 e 128.
5 ADD MARKS , 10 ; Adicionar 10 à variável MARKS.
6 MOV AL , 10 ; Transferir o valor 10 para o
registrador AL.

Tipos de Declarações
1 Comentários - Ignorados pelo Montador
2 Elementos de Formatação (Diretivas, Sinais de Pontuação, etc). -
Usados para formatação geral do executável
3 Mnemônicos de Operações - Transformados em Códigos de
Operações (opcodes) da máquina alvo (ex. x86).

’Iniciando 001_start.asm’
1 ; nosso primeiro programa em assembly
2 ; adicionar comentários
3 global _start ; define o ponto de início de execução
do programa
4 _start:
5 mov eax ,1 ; coloca o 1 no reg. eax (proposito
geral)
6 ; neste caso o eax fornce o código
que identifica uma system call
7 ; nesta caso a system call sera
EXIT(X) onde o X será o valor no
registrador ebx
8 mov ebx ,42 ; coloca o valor 42 no registrador de
propósito geral ebx , e
9 int 0x80 ; chama uma iterrupção do kernel

Para Compilar
nasm -f elf 001_start.asm -o start.o

Para Fazer a Ligação
ld -m elf_i386 -s -o start start.o

Verificando o Código de Saída
echo $?

Olhando para o Executável ’desassemblado’
objdump -d ./start
./start: file format elf32-i386
Disassembly of section .text:
08049000 .text:
8049000: b8 01 00 00 00 mov $0x1,%eax
8049005: bb 2a 00 00 00 mov $0x2a,%ebx
804900a: cd 80 int $0x80
Obs.
No caso acima temos apenas um segmento (.text). Para visualizar o
arquivo usar comando hexeditor ./start
O assembly do lado direito está na sintaxe AT&T

O que é ELF (Executable and Linkable Format)
É um formato de arquivo binário amplamente utilizado em sistemas
operacionais Unix e Unix-like para representar executáveis, bibliotecas
compartilhadas e arquivos de objeto resultantes de compilação ou
montagem de código-fonte. O formato ELF é uma especificação
padronizada que define a estrutura interna dos arquivos executáveis e
objetos, permitindo que diferentes componentes de um programa (código,
dados, símbolos, seções, etc.) sejam organizados e interligados de maneira
consistente. Ele foi originalmente desenvolvido para a plataforma Unix
System V, mas foi adotado amplamente em outros sistemas Unix e em
sistemas operacionais semelhantes, como o Linux.

Opções do Linker
opção -m (formatos)
1 elf_i386: Especifica que o formato do arquivo de saída será o ELF
(Executable and Linkable Format) para a arquitetura x86 (32 bits).
2 elf_x86_64: Especifica que o formato do arquivo de saída será o ELF
para a arquitetura x86-64 (64 bits).
3 som: Especifica que o formato do arquivo de saída será o formato
SOM (System Object Module), que é um formato mais antigo usado
em algumas arquiteturas e sistemas operacionais.
4 etc

Opções do Linker
-s (limpeza)
1 usada para instruir o linker a remover informações de símbolos não
necessárias do arquivo executável final

Segundo Programa 002_exit.asm
1 ; nosso segundo programa em assembly
2 global _start
3 _start:
4 mov eax ,1 ; coloca o valor 1 no registrador eax
(proposito geral)
5 mov ebx ,42 ; coloca o valor 42 no registrador de
ropoosito geral ebx , e
6 add ebx ,10 ; soma o valor 10 ao 42 que está no
ebx e coloca no próprio ebx
7 int 0x80 ; chama uma iterrupção para que o
kernel execute uma system call

Segmentação da Memória
Todo programa segue um ’modelo de memória’ que é efetivamente
implantada na memória física do computador. Este modelo associa seções
do programa aos segmentos:
1 Segmento de dados - É representado por .data e pelo .bss. A seção
.data é declara a região de memória para os dados. Esta seção
permanece estática durante todo o programa.
2 Segmento de código - É representado por .text. Isso define uma área
na memória para os códigos de instrução. Esta também é uma área
fixa.
3 Stack - Este segmento contém valores de dados passados para
funções e procedimentos dentro do programa.

Registradores /Registros
1 Registros gerais
2 Registros de controle
3 Registros do segmento

Registradores Gerais
1 Registradores de Dados
2 Registradores de Ponteiros
3 Registradores de Índices

Registradores de Dados
1 Como registros completos de dados de 32 bits: EAX, EBX, ECX,
EDX.
2 Metades dos registros de 32 bits podem ser usadas como quatro
registros de dados de 16 bits: AX, BX, CX e DX.
3 Metades inferiores e superiores dos quatro registros acima
mencionados de 16 bits podem ser usados como oito registros de
dados de 8 bits: AH, AL, BH, BL, CH, CL, DH e DL.

Registradores

Operações Aritméticas com Registradores
1 AX é o acumulador primário; é usado em entrada/saída e na maioria
das instruções aritméticas. Por exemplo, na operação de
multiplicação, um operando é armazenado em EAX ou AX ou AL de
acordo com o tamanho do operando.
2 O BX é conhecido como registro base, pois pode ser usado em
endereçamento indexado.
3 CX é conhecido como o registro de contagem, como o ECX, CX
registra armazenar a contagem de loop em operações iterativas.
4 DX é conhecido como o registro de dados. Também é usado em
operações de entrada/saída. Também é usado com registro AX junto
com DX para operações de multiplicação e divisão envolvendo
grandes valores

Ponteiros
1 Indicador de instrução (IP) - O registro IP de 16 bits armazena o
endereço de deslocamento da próxima instrução a ser executada. O
IP em associação com o registro CS (como CS:IP) fornece o endereço
completo da instrução atual no segmento de código.
2 Stack Pointer (SP) - O registro de SP de 16 bits fornece o valor de
deslocamento dentro da pilha do programa. SP em associação com o
registro SS (SS:SP) refere-se a ser posição atual de dados ou
endereço dentro da pilha de programas.
3 Ponteiro base (BP) - O registro de BP de 16 bits ajuda
principalmente na referência às variáveis de parâmetros passadas para
uma subrotina. O endereço no registro SS é combinado com o
deslocamento em BP para obter a localização do parâmetro. A BP
também pode ser combinada com DI e SI como registro base para
endereçamento especial

Ponteiros

Registradores de Índices

Registradores de Controle
O registrador do ponteiro de instrução de 32 bits e o registrador de flags
de 32 bits combinados são considerados como os registros de controle.

Flags (Sinalizadores)
1 Flag de estouro (OF) - Indica o estouro de um bit de alta ordem (bit
mais à esquerda) de dados após uma operação aritmética.
2 Flag de direção (DF) - Determina a direção esquerda ou direita para
mover ou comparar dados de sequência. Quando o valor do DF é 0, a
operação de sequência toma a direção da esquerda para a direita e
quando o valor é definido para 1, a operação de sequência toma
direção da direita para a esquerda.
3 Flag de interrupção (IF) - Ele determina se as interrupções externas,
como a entrada do teclado, etc., devem ser ignoradas ou processadas.
Desativa a interrupção externa quando o valor é 0 e permite
interrupções quando definido para 1.
4 Trap Flag (TF) - Permite configurar o funcionamento do processador
no modo de etapa única. O programa DEBUG que usamos define a
bandeira da armadilha, para que pudéssemos passar pela execução
uma instrução de cada vez.

Flags - Continuação
1 Sinalização (SF) - Mostra o sinal do resultado de uma operação
aritmética. Este flag é definido de acordo com o sinal de um item de
dados após a operação aritmética. O sinal é indicado pela alta ordem
da parte mais esquerda. Um resultado positivo limpa o valor de SF
para 0 e o resultado negativo o coloca em 1.
2 Flag Zero (ZF) - Indica o resultado de uma operação aritmética ou de
comparação. Um resultado não zero libera a bandeira zero para 0, e
um resultado zero o coloca em 1.
3 Flag auxiliar de transporte (AF) - Contém o transporte do bit 3 ao bit
4 após uma operação aritmética; usado para aritmética especializada.
O AF é definido quando uma operação aritmética de 1 byte causa um
transporte do bit 3 para o bit 4.

Flags - Continuação
1 Flag de Paridade (PF) - Indica o número total de 1 bits no resultado
obtido a partir de uma operação aritmética. Um número par de 1 bits
limpa a bandeira de paridade para 0 e um número ímpar de 1 bits
define a bandeira de paridade para 1.
2 Carry Flag (CF) - Contém o transporte de 0 ou 1 de um bit de alta
ordem (mais à esquerda) após uma operação aritmética. Ele também
armazena o conteúdo de última parte de uma operação de turno ou
rotação.

Flags

Registradores de Segmento
1 Segmento de código - Contém todas as instruções a serem
executadas. Um registro do segmento de código de 16 bits ou registro
CS armazena o endereço inicial do segmento de código.
2 Segmento de Dados - Contém dados, constantes e áreas de trabalho.
Um registro do segmento de dados de 16 bits ou o registro DS
armazena o endereço inicial do segmento de dados.
3 Segmento de pilha - Contém dados e endereços de devolução de
procedimentos ou subrotinas. É implementado como uma estrutura
de dados ’stack’. O registro do Segmento stack ou o registro SS
armazena o endereço inicial da pilha.

Extras
Além dos registros de DS, CS e SS, existem outros registros extras do
segmento - ES (segmento extra), FS e GS, que fornecem segmentos
adicionais para armazenamento de dados.

Hora do Hello World, ou melhor, queima***
003_queima.asm
1 section .text
2 global _start ; deve ser declarado para o linker
(ld)
3 _start: ; ponto de entrada para o linker
4 mov edx ,len ; comprimento da mensagem em edx
5 mov ecx ,msg ; mensagem a ser escrita
6 mov ebx ,1 ; descritor de arquivo (stdout)
7 mov eax ,4 ; chamada do sistema (sys_write)
8 int 0x80 ; chama o kernel
9
10 mov eax ,1 ; chamada do sistema (sys_exit)
12
13 section .data
14 msg db ’Queima *** do IFCe!’, 0xa ; string
15 len equ $ - msg ; comprimento da string

Registradores de 64 Bits
De uso geral:
1 RAX, RBX, RCX, RDX: Registradores de uso geral de 64 bits que são
usados para armazenar dados e realizar operações aritméticas.
2 RSI, RDI, RBP, RSP: Mais registradores de uso geral que também são
usados para manipulação de dados e endereçamento.
3 R8 - R15: Registradores adicionais de uso geral disponíveis em
arquiteturas de 64 bits. Eles são frequentemente usados para
armazenar valores temporários e parâmetros de função.

Registradores de Ponto Flutuante
1 XMM0 - XMM15: Registradores de ponto flutuante de 128 bits. Eles
são usados para realizar operações de ponto flutuante em dados
individuais ou em vetores de dados.
Registradores de Vetor(SIM - Single Instruction Multiple Data)
1 YMM0 - YMM15: Registradores de vetor de 256 bits. Eles são
usados para executar instruções SIMD em dados vetoriais,
especialmente em operações de ponto flutuante de precisão única.
2 ZMM0 - ZMM31: Registradores de vetor de 512 bits. Eles são
encontrados em algumas arquiteturas avançadas de 64 bits e são
usados para realizar operações SIMD em dados vetoriais,
especialmente em operações de ponto flutuante de precisão dupla.

Registradores de Controle
1 RFLAGS: Registrador de 64 bits que armazena diversas informações
de status e controle, como flags de condição e de controle de
interrupções.
2 RIP: Registrador de 64 bits que contém o endereço da próxima
instrução a ser executada (instruction pointer).

Chamadas do Sistema (Linux) - Trap
1 Ponha o número da chamada ao Sistema no registrador EAX
2 Ponha os argumentos para a chamada no registrador EBX, ECX, etc
3 Chame a interrupção (80h).
4 O resultado estará no registrador EAX

Exemplo de Chamada ao Sistema
1 mov eax ,1 ; número da chamada ao sistema(sys_exit)

Chamadas ao Sistema Linux

Lista Completa de Linux System Calls
http://web.archive.org/web/20160303181025/http:
//docs.cs.up.ac.za/programming/asm/derick_tut/syscalls.html
Também podemos encontrar a lista no arquivo ’unistd.h’

Imprimindo Mensagens - 004_ninestar
1 section .text
2 global _start
3 _start:
4 mov edx ,len ; comprimento da mensagem
5 mov ecx ,msg ; mensagem para escrever
6 mov ebx ,1 ; descritor do arquivo (stdout)
7 mov eax ,4 ; número da chamada ao sistema
(sys_write)
9
10 mov edx ,9
11 mov ecx ,s2
12 mov ebx ,1
13 mov eax ,4
14 int 0x80

Imprimindo Mensagens
1
2 mov edx ,l2
3 mov ecx ,msg2
4 mov ebx ,1
5 mov eax ,4
6 int 0x80
7
8 mov eax ,1 ; (sys_exit)
10
11 section .data
12 msg db ’Imprimindo 9 asteriscos ’,0xa ; messagem
13 len equ $-msg ; Comprimento da mensagem
14 s2 times 9 db ’*’
15 msg2 db 0xa ; mudança de linha
16 l2 equ $ - msg2

Operandos
A maioria das instruções de linguagem de montagem exigem operandos
para serem processadas. Um endereço de operando fornece a localização
onde os dados a serem processados são armazenados. Algumas instruções
não requerem operandos, enquanto algumas outras instruções podem
exigir um, dois ou três operandos

Visualizando o Código Objeto
objdump -D 004_ninestar

Endereçamento
1 Quando uma instrução requer dois operandos. O primeiro
normalmente representa o destino o qual poderá conter dados ou
localização de memória e o segundo operador é a fonte.
2 A fonte conterá dados a serem entregues (endereçamento imediato)
ou o endereço (no registrador ou na memória) dos dados. Geralmente
as fontes permanecem inalteradas após a operação.

Modos de Endereçamento
1 Endereçamento de Registrados
2 Endereçamento Imediato
3 Endereçamento de Memória

Endereçamento de Registrador
Neste modo o registrador contém o operando. Dependendo da instrução o
operador pode ser o primeiro, o segundo ou ambos os operandos. Exs:
MOV DX, TAX_RATE ; O registrador no primeiro operando
MOV COUNT, CX ; Registrador no Segundo operando
MOV EAX, EBX ; Ambos os operandos são registradores

Endereçamento Imediato
O operando consiste em um valor constante ou uma expressão
BYTE_VALUE DB 150 ; Definido tipo chamado de BYTE_VALUE
WORD_VALUE DW 300 ; Definido tipo chamado de WORD_VALUE
ADD BYTE_VALUE, 65 ; Operando imediato 65
MOV AX, 45H ; Constante imediata 45H is transferida para AX

Endereçamento Direto na Memória
Neste caso faz-se necessário o uso do segmento de dados. Esse uso é
lento. Para saber a localização exata do dado na memória precisamos do
endereço inicial do segmento o qual normalmente se encontra no
registrador DS e um valor de offset. Este offset é chamado de endereço
efetivo.

Endereçamento Direto na Memória
O valor do offset é especificado diretamente como parte da instrução
normalmente indicado no nome da variável. O assembler calcula o valor do
offset e mantém uma tabela de símbolos que guarda os valores de offset de
todas as variáveis usadas no programa.

Endereçamento Direto da Memória
Um dos operandos se refere a uma localização de memória e o outro
referencia o registrador.
ADD BYTE_VALUE, DL ; Põe o registrador em uma posição de memória
MOV BX, WORD_VALUE ; O registrador recebe o valor da memória

Endereçamento Offset Direto
Este modo de endereçamento usa operadores aritméticos para modificar
um endereço.
Sejam os dados:
BYTE_TABLE DB 14, 15, 22, 45 ; Tabelas de bytes
WORD_TABLE DW 134, 345, 564, 123 ; Tabelas de words
As operações abaixo carregam dados da tabela nos registradores:
MOV CL, BYTE_TABLE[2] ; Pega o 3o elemento da tabela
BYTE_TABLE
MOV CL, BYTE_TABLE + 2 ; Pega o 3o elemento da tabela
BYTE_TABLE
MOV CX, WORD_TABLE[3] ; Pega o 4o elemento da tabela
WORD_TABLE
MOV CX, WORD_TABLE + 3 ; Pega o 4o elemento da tabela
WORD_TABLE

Endereçamento indireto da Memória
Este modo utiliza a capacidade do endereçamento segment:offset.
Geralmente os registradores de base (EBX, EBP ou BX,BP) e os
registradores de índice (DI,SI) codificados entre colchetes são usados para
estes propósitos.

Endereçamento Indireto da Memória
Este tipo de endereçamento é geralmente usado para variáveis contendo
vários elementos como matrizes que são armazenadas, digamos, no
registrador EBX.
A seguir vemos como acessar diferentes elementos das variáveis.
1 MY_TABLE TIMES 10 DW 0 ; Aloca 10 palavras
(word)(2 bytes) inicializadas com 0
2 MOV EBX , [MY_TABLE] ; Endereço efetivo de
MY_TABLE in EBX
3 MOV [EBX], 110 ; MY_TABLE [0] = 110
4 ADD EBX , 2 ; EBX = EBX +2
5 MOV [EBX], 123 ; MY_TABLE [1] = 123

A Instrução MOV
1 MOV destino ,fonte
2 MOV register , register
3 MOV register , immediate
4 MOV memory , immediate
5 MOV register , memory
6 MOV memory , register

Especificadores de Tipos

Variáveis
Alocação de memória para variáveis inicializadas
nome_variável diretiva_definição valor_inicial
Exs.
1 choice DB ’y’
2 number DW 12345
3 neg_number DW -12345
4 big_number DQ 123456789
5 real_number1 DD 1.234
6 real_number2 DQ 123 .456

Diretivas

Entrada e Saída - 005_entsaida
1 ; segmento de dados
2 section .data
3 ; mensagem solicitando a entrada de um número
4 userMsg db ’Digite um numero: ’
5 ; comprimento da mensagem
6 lenUserMsg equ $-userMsg
7 dispMsg db ’Voce digitou: ’
8 lenDispMsg equ $-dispMsg
9
10 ;Dados não inicializados
11 section .bss
12 num resb 5
13
14 ; segmento de código
15 section .text
16 global _start

1 _start:
2 ; Mensagem para o usuário (prompt)
3 ; Observe a sequência dos registradores A - Numero
SYSCALL , B - Descritor ,
4 ; C - mensagem , D - Comprimento
5 mov eax , 4
6 mov ebx , 1
7 mov ecx , userMsg
8 mov edx , lenUserMsg
9 int 80h
10
11 ; Lê e armazena a entrada fornecida pelo usuário
12 mov eax , 3
13 mov ebx , 2
14 mov ecx , num
15 ;5 bytes (numerico , 1 para o sinal (-/+))
16 mov edx , 5
17 int 80h

1 ; Saída da mensagem ’voce digitou ’
2 mov eax , 4
3 mov ebx , 1
4 mov ecx , dispMsg
5 mov edx , lenDispMsg
6 int 80h
7 ; saída do número digitado
8 mov eax , 4
9 mov ebx , 1
10 mov ecx , num
11 mov edx , 5
12 int 80h
13 ; saída final
14 mov eax , 1
15 mov ebx , 0
16 int 80h

Entrada e Saída - 006_mov
Chamadas a subrotinas são feitas com o comando call e saltos com o jmp.
Ver a listagem abaixo
1 section .data
2 nome db ’Mano Josuelito ’,0xa
3 lenUserMsg equ $-nome
4 newLineMsg db 0xa
5 newLineLen equ $-newLineMsg
6 section .text
7 global _start
8 _start:
9 ;Escrevendo o nome Manoel Josuelito
10 ;Comprimento da mensagem
11 mov edx ,lenUserMsg
12 ;Mensagem a ser escrita
13 mov ecx , nome
14 ;Descritor do arquivo (stdout)
15 mov ebx ,1

1 ;Chamada de Sistema
2 mov eax ,4
3 ;Chama o kernel
4 int 0x80
5 ;Muda o nome para ’Mary ’
6 mov [nome],dword ’Mary ’ ;dword
7 ;Escrevendo o nome
8 ;Comprimento
9 mov edx ,lenUserMsg
10 ;Mensagem a escrever
11 mov ecx ,nome
12 ;Descritor do Arquivo
13 mov ebx ,1
14 ;Chamada do sistema
15 mov eax ,4
16 ;Chama o kernel
17 int 0x80

1 ;chama subrotina
2 call _novaLinha
3 ;salta para saida
4 jmp _saida
5
6 _novaLinha:
7 mov edx ,newLineLen
8 mov ecx ,newLineMsg
9 mov ebx ,1
10 mov eax ,4
11 int 0x80
12 ret
13 _saida:
14 ; Chamada sys_exit
15 mov eax ,1
16 ;chama o kernel
17 int 0x80

Dados
1 Bytes de characteres são armazenados com seus valores ascii em
hexadecimal
2 Valores decimais são automaticamente convertidos para o seu
equivalente de 16 bits e armazenados como números hexadecimal
3 Processadores usam ordenamento de bytes little-endian
4 Números negativos são convertidos para sua representação em
complemento de 2
5 Números em ponto flutuante são representados usando 32 (short) e
64 bits (long)

Exemplo de Diretiva
1 section .text
2 global _start
3 _start:
4 ; comprimento da mensagem
5 mov edx ,1
6 ; Mensagem para escrever
7 mov ecx ,choice
8 ; Descritor de arquivo (stdout)
9 mov ebx ,1
10 ; Número da chamada ao sistema
11 mov eax ,4
12 int 0x80
13 ; sys_exit
14 mov eax ,1
15 int 0x80
16 section .data
17 choice DB ’y’

Alocação de Dados não Inicializados
Diretivas de reserva são usadas para reservar espaço para dados não
inicializados.
Os tipos de diretivas são:
Diretiva Objetivo
RESB Reserve a Byte
RESW Reserve a Word
RESD Reserve a Doubleword
RESQ Reserve a Quadword
REST Reserve a Ten Bytes

Definições e Inicializações
Podemos ter múltiplas definições e inicializações como:
choice DB ’Y’ ;ASCII of y = 79H
number1 DW 12345 ;12345D = 3039H
number2 DD 12345679 ;123456789D = 75BCD15H
A diretiva TIMES permite múltiplas inicializações para o mesmo valor. Por
exemplo uma matriz mat de tamanho 9 pode ser definida e inicializada
com zeros como segue:
mat TIMES 9 DW 0

Pequeno Detalhe do Times 008_times
Times pode ser usado para multiplicar bytes
1 section .text
2 global _start
3 _start:
4 ;comprimento da mensagem
5 mov edx ,9
6 ;Mensagem para escrever
7 mov ecx , stars
8 ; fd
9 mov ebx ,1
10 ; sys_write
11 mov eax ,4
12 int 0x80

Pequeno Detalhe do Times 008_times
1 _saida:
4 mov ebx ,1
5 mov eax ,4
6 int 0x80
7 ; sys_exit
8 mov eax ,1
9 int 0x80
10 section .data
11 ; usando times
12 stars times 9 db ’*’
13 newLineMsg db 0xa

Constantes - Diretivas
1 EQU
2 %assign
3 %define

EQU
EQU é usada para definir constantes.
CONSTANT_NAME EQU expression.
Ex.
TOTAL_STUDENTS equ 50

%assign
A diretiva %assign pode ser usada para definir constantes numéricas como
a diretiva EQU. Esta diretiva permite a redefinição. Esta diretiva é
semelhante a #define do c
Ex.
%define PTR [EBP+4]

009_equ.asm
1 %assign SYS_EXIT 1
2 %define SYS_WRITE 4
3 ;SYS_EXIT equ 1
4 ;SYS_WRITE equ 4
5 STDIN equ 0
6 STDOUT equ 1
7 section .text
8 global _start
9 _start:
10 mov eax , SYS_WRITE
11 mov ebx , STDOUT
12 mov ecx , msg1
13 mov edx , len1
14 int 0x80

009_equ.asm
2 mov ebx , STDOUT
3 mov ecx , msg2
4 mov edx , len2
5 int 0x80
7 mov ebx , STDOUT
8 mov ecx , msg3
9 mov edx , len3
10 int 0x80
11 mov eax ,SYS_EXIT
12 int 0x80

009_equ.asm
1 section .data
2 msg1 db ’Alo programadores!’,0xA ,0xD
3 len1 equ $ - msg1
4
5 msg2 db ’Benvindos ao mundo da ,’, 0xA ,0xD
6 len2 equ $ - msg2
7
8 msg3 db ’Programação Assembly Linux! ’,0xA ,0xD
9 len3 equ $- msg3

Aritmética em Assembly
A instrução INC é usada para incrementar um operador de um.
Funciona com somente um operando que pode ser um registrador ou estar
na memória.
Sintaxe:
INC destination
Exs:
1 INC EBX ; Incrementa registrador de 32-bit
2 INC DL ; Incrementa registrador de 8-bit register
3 INC [count] ; Incrementa a variável count

Aritmética em Assembly
Da forma semelhante ao operador INC, o operador DEC é utilizado para
decrementar valores.
Ex.
1 segment .data
2 count dw 0
3 value db 15
4
5 segment .text
6 inc [count]
7 dec [value]
8 mov ebx , count
9 inc word [ebx]
10 mov esi , value
11 dec byte [esi]

Adição e Subtração
Operadores ADD e SUB
ADD/SUB destination, source

010_addsub.asm
1 SYS_EXIT equ 1
2 SYS_READ equ 3
3 SYS_WRITE equ 4
4 STDIN equ 0
5 STDOUT equ 1
6 segment .data
7 msg1 db "Entre com um digito", 0xA ,0xD
8 len1 equ $- msg1
9 msg2 db "Entre com um segundo digito", 0xA ,0xD
10 len2 equ $- msg2
11 msg3 db "A soma eh: "
12 len3 equ $ - msg3
13 newLineMsg db 0xa

010_addsub.asm
1 segment .bss
2 num1 resb 2
3 num2 resb 2
4 res resb 1
5 section .text
6 global _start
7 _start:
9 mov ebx , STDOUT
10 mov ecx , msg1
11 mov edx , len1
12 int 0x80

010_addsub.asm
1 mov eax , SYS_READ
2 mov ebx , STDIN
3 mov ecx , num1
4 mov edx , 2
5 int 0x80
7 mov ebx , STDOUT
8 mov ecx , msg2
9 mov edx , len2
10 int 0x80
11 mov eax , SYS_READ
12 mov ebx , STDIN
13 mov ecx , num2
14 mov edx , 2
15 int 0x80

010_addsub.asm
2 mov ebx , STDOUT
3 mov ecx , msg3
4 mov edx , len3
5 int 0x80
6 ; movendo o primeiro número para o registrador eax
e o segundo para ebx
7 ; e subtraindo o ascii 0 para converter em número
decimal
8 mov eax , [num1]
9 sub eax , ’0’
10 mov ebx , [num2]
11 sub ebx , ’0’
12 ; soma eax e ebx
13 add eax , ebx

010_addsub.asm
1 ; adiciona 0 para converter a soma de decimal para
ASCII
2 add eax , ’0’
3 ; armazenando a soma no local de memoria
referenciado por res
4 mov [res], eax
5 ; imprime a soma
7 mov ebx , STDOUT
8 mov ecx , res
9 mov edx , 1
10 int 0x80
11 exit:
14 mov ebx ,STDOUT
15 mov eax ,SYS_WRITE
16 int 0x80

Multiplicação (Não tão simples)
MUL/IMUL operando
MUL = Números sem sinal
IMUL = Com sinal

Multiplicando dois Bytes
Um operando (multiplicando) está no registrador AL e o outro
(multiplicador) é um byte na memória ou em outro registrador. O produto
vai para AX. Os 8 bits de mais alta ordem (à esquerda) são armazenados
em AH e os 8 bits de mais baixa ordem vão para AL

Multiplicando dois Words
O Multiplicando deve estar no registro AX e o multiplicador é um word na
memória ou em outro registrador. Por exemplo MUL DX multiplica DX
por AX. O resultado é um doubleword o qual necessitará de dois
registradores. A parte de mais alta ordem do resultado vai para DX e a
parte de mais baixa ordem vai para AX

Multiplicando dois doublewords
Quando dois doublewords são multiplicados, o multiplicando deve estar em
EAX e o multiplicador será um doubleword na memória ou em outro
registrador. O produto ira para EDX:EAX (32 bits em cada)

Multiplicando (011_mult)
1 section .text
2 global _start
3 _start:
4 mov al ,’9’ ; al = 3
5 sub al ,’0’ ; al = numero
6 mov bl , ’2’ ; bl = ’2’
7 sub bl , ’0’ ; bl = 2
8 mul bl ; AH:AL = bl * al => 0:6
9 add al , ’0’ ; al = 6
10
11 mov [res], al ; al (6) é colocado na referência
de res
12 mov ecx ,msg ; mensagem preparada para ser
enviada
13 mov edx , len ; comprimento daq mensagem setada
14 mov ebx ,1 ;(stdout)
15 mov eax ,4 ; (sys_write)
16 int 0x80

1 mov ecx ,res ; resultado é copiado para o ecx
2 mov edx , 1 ; comprimento (1 byte)
5 int 0x80 ;
6
9 mov ebx ,1
10 mov eax ,4
11 int 0x80
12
13 xor ebx , ebx
15 int 0x80 ;

1 ; segmento de dados
2 section .data
3 msg db "O resultado eh:", 0xA ,0xD
4 len equ $- msg
5 newLineMsg db 0xa
7
8 ; dados não inicializados
9 segment .bss
10 res resb 1

Dividindo
A divisão gera dois elementos : o quociente e o resto. Pode ocorrer
overflow que gera uma interrupção.
1 DIV : Divisão sem sinal
2 IDIV : com sinal

Dividindo por Byte

Dividindo por Word

Dividindo por Doubleword

Dividindo (012_div)
1 section .text
2 global _start
3 _start:
4 mov ax ,’8’
5 sub ax ,’0’ ; eax conterá o número 8
6 mov bl , ’2’
7 sub bl , ’0’ ; bl conterá o número 2
8 div bl ; ax é dividido por bl
9 add ax , ’0’ ; convertido em número
10 mov [res], ax ; ax vai para res
11 mov ecx ,msg ; prepara msg
12 mov edx , len
13 mov ebx ,1
15 int 0x80

Dividindo (012_div)
1 mov ecx ,res ; res vai para ecx
2 mov edx , 1
4 mov eax ,4 ;(sys_write)
5 int 0x80
6 mov eax ,1 ;(sys_exit)
7 int 0x80
8
9 section .data
10 msg db "O resultado é:", 0xA ,0xD
11 len equ $- msg
12 segment .bss
13 res resb 1

Instruções Lógicas

And
A instrução AND é usada para dar suporte a expressões realizando a
operação AND bit a bit. A operação retorna 1 se os bits que se casam na
mesma posição são 1, senão retornam zero.
Também usada para limpeza de bits.

Dividindo (013_and)
1 section .text
2 global _start ;declaração do ponto de
entrada main
3 _start: ;declaraão para o linker
do ponto de entrada
4 mov ax , 7h ;ponto 8h no registro ax
5 and ax , 1 ;operação and com 1
6 jz evnn ; salta para o endereço
referenciado por evnn caso a ax seja zero
(número par)
7 mov eax , 4 ;(sys_write)
8 mov ebx , 1 ;(stdout)
9 mov ecx , odd_msg ;message to write
10 mov edx , len2 ;length of message
11 int 0x80 ;call kernel
12 jmp outprog

Dividindo (013_and)
1 evnn:
2 mov ah , 09h
5 mov ecx , even_msg ;mensagem
6 mov edx , len1 ;comprimento da mensagem
7 int 0x80
8 outprog:
11 mov ebx ,1
12 mov eax ,4
13 int 0x80
15 int 0x80

Dividindo (013_and)
1 section .data
2 even_msg db ’Número Par!’ ;mensagem par
3 len1 equ $ - even_msg
4
5 odd_msg db ’Número ímpar!’ ;mensagem ímpar
6 len2 equ $ - odd_msg
7
8 newLineMsg db 0xa

Or
Implementa o OU bit a bit

Or (014_or)
1 section .text
2 global _start
3 _start:
4 mov al , 5 ;pondo 5 no al
5 mov bl , 3 ;pondo 3 in the bl
6 or al , bl ;or al e bl , resultado = 7
7 add al , byte ’0’ ;convertendo decimal para ascii
8 mov [result],al
9 mov eax , 4
10 mov ebx , 1
11 mov ecx , result
12 mov edx , 1
13 int 0x80

Or (014_or)
1
2 outprog:
4 int 0x80
5 section .bss
6 result resb 1

Xor
Ou exclusivo Bit a Bit

Instrução Test
A instrução TEST funciona da mesma forma que a operação AND, mas
diferentemente dessa, ela não muda o primeiro operando.

Instrução Not
Operação NOT bit a bit

Comparações
A instrução CMP compara dois operandos. É geralmente usado em
execução condicional. Esta instrução basicamente subtrai um operando do
outro para comparar se os operandos são iguais ou não. Não modifica os
operandos. É usado juntamente com a instrução de salto condicional para
a tomada de decisões.

CMP
CMP destino, fonte
CMP compara dois campos de dados numéricos. O operando de destino
pode estar no registro ou na memória. O operando de origem pode ser
uma constante (imediata), registrador ou memória

CMP + JLE
1 CMP DX ,00 ; Compare o valor DX com zero
2 JE L7 ; Se sim , então pule para rótulo L7
3 L1:
4 INC EDX
5 CMP EDX , 10; Compara se o contador chegou a 10
6 JLE L1; Se for menor ou igual a 10, então salta
para L1:
7 L7:
8 ...

Desvios
1 Condicionais
2 Incondicionais

Desvios Incondicionais
Como mencionado anteriormente, isso é realizado pela instrução JMP.
(goto)

Desvios Condicionais
Se alguma condição especificada estiver satisfeita, no salto condicional, o
fluxo de controle será transferido para uma instrução de destino. Existem
inúmeras instruções de salto condicional, dependendo da condição e dos
dados.

Tipos de JUMPS
Jumps usado com comparações aritméticas de dados com sinal
Instrução Descrição Flag Testado
JE/JZ Jump Equal or Jump Zero ZF
JNE/JNZ Jump not Equal or Jump Not Zero ZF
JG/JNLE Jump Greater or Jump Not Less/Equal OF, SF, ZF
JGE/JNL Jump Greater/Equal or Jump Not Less OF, SF
JL/JNGE Jump Less or Jump Not Greater/Equal OF, SF
JLE/JNG Jump Less/Equal or Jump Not Greater OF, SF, ZF

Tipos de JUMPS
Jumps usado com comparações aritméticas de dados sem sinal
JE/JZ Jump Equal or Jump Zero ZF
JNE/JNZ Jump not Equal or Jump Not Zero ZF
JA/JNBE Jump Above or Jump Not Below/Equal CF, ZF
JAE/JNB Jump Above/Equal or Jump Not Below CF
JB/JNAE Jump Below or Jump Not Above/Equal CF
JBE/JNA Jump Below/Equal or Jump Not Above AF, CF

Testando os Registros de Flag
JXCZ Jump if CX is Zero none
JC Jump If Carry CF
JNC Jump If No Carry CF
JO Jump If Overflow OF
JNO Jump If No Overflow OF
JP/JPE Jump Parity or Jump Parity Even PF
JNP/JPO Jump No Parity or Jump Parity Odd PF
JS Jump Sign (negative value) SF
JNS Jump No Sign (positive value) SF

Jumps (015_jumps)
1 section .text
2 global _start
3 _start:
4 mov ecx , [num1]
5 cmp ecx , [num2]
6 jg check_third_num
7 mov ecx , [num2]
8 check_third_num :
9 cmp ecx , [num3]
10 jg _exit
11 mov ecx , [num3]
12 _exit:
13 mov [largest], ecx
14 mov ecx ,msg
15 mov edx , len
16 mov ebx ,1 ;file descriptor (stdout)
17 mov eax ,4 ;system call number (sys_write)
18 int 0x80 ;call kernel

Jumps (015_jumps)
1 mov ecx ,largest
2 mov edx , 2
3 mov ebx ,1
4 mov eax ,4 ;sys_write
5 int 0x80
6 mov eax , 1
7 int 80h
8 section .data
9 msg db "O maior digito eh: ", 0xA ,0xD
10 len equ $- msg
11 num1 dd ’47’
12 num2 dd ’22’
13 num3 dd ’31’
14
15 segment .bss
16 largest resb 2

Loops Simples
1 MOV CL , 10
2 L1:
3 <LOOP -BODY >
4 DEC CL
5 JNZ L1
Observe o controle que o jnz faz do loop após o valor de cl ser
decrementado.

Loop Automático
1 mov ECX ,10
2 l1:
3 <corpo do loop >
4 loop l1
O registrador ecx é usado para o controle do loop. No caso o loop será
executado 10 vezes.

Jumps (016_loops)
1 section .text
2 global _start
3 _start:
4 mov ecx ,10
5 mov eax , ’1’
6 l1:
7 mov [num], eax
8 mov eax , 4
9 mov ebx , 1
10 push ecx
11 mov ecx , num
12 mov edx , 1
13 int 0x80

Jumps (016_loops)
1 mov eax , [num]
2 sub eax , ’0’
3 inc eax
4 add eax , ’0’
5 pop ecx
6 loop l1
8 int 0x80
9 section .bss
10 num resb 1

Números
Para trabalharmos com números na memória temos convertido
oscaracteres ASCII no seu correspondente binário e vice versa através de
soma ou subtração. O números na entrada ou saída serão strings ASCII e
precisarão ser convertidos.

Representação ASCII de Números
Neste caso os números são representados em strings de códigos ASCII.
Ex.
1234 = 31 32 33 34H

Conversão de Números para ASCII
Para esta conversão temos as seguintes instruções:
AAA - ASCII Adjust After Addition
AAS - ASCII Adjust After Subtraction
AAM - ASCII Adjust After Multiplication
AAD - ASCII Adjust Before Division

Jumps (017_ajustaascii)
1 section .text
2 global _start
3 _start:
4 sub ah , ah
5 mov al , ’9’
6 sub al , ’3’
7 aas
8 or al , 30h
9 mov [res], ax
10 mov edx ,len ;comprimento da mensagem
11 mov ecx ,msg ;messagem a escrever
12 mov ebx ,1 ; (stdout)
14 int 0x80 ; kernel

Jumps (017_ajustaascii)
1 mov edx ,1 ; comprimento
2 mov ecx ,res ; mensagem
5 int 0x80 ; kernel
7 int 0x80 ; kernel
8 section .data
9 msg db ’O Resultado é:’,0xa
10 len equ $ - msg
11 section .bss
12 res resb 1

Representação BCD
Existem dois tipos de representação BCD:
1 Representação BCD não compactada
2 Representação BCD compactada
Na representação BCD não compactada, cada byte armazena o
equivalente binário de um dígito decimal. Por exemplo, o número 1234 é
armazenado como - 01 02 03 04H
Na representação compactada cada byte pode represetar dois dígitos sendo
cada dígito representado por 4 bits. Assim 1234 pode ser representado
como -12 34h

BCD Não Compactado
As instruções para tratar estes números são:
AAM - ASCII Adjust After Multiplication
AAD - ASCII Adjust Before Division
De fato as 4 instruções acima (slide anterior) podem ser usadas neste tipo
de dado.

BCD Compactado
As instruções para tratar estes números são:
DAA - Decimal Ajust After Addition
DAS - Decimal Ajust After Subtraction
Não há suporte para multiplicação e divisão na representação BCD
compactada.

BCD (018_ajusta_bcd)
1 section .text
2 global _start
3 _start:
4 mov esi , 4 ;posiçao do dígito mais à direita
5 mov ecx , 5 ;número de dígitos
6 clc ;Limpa o flag de carry
7 add_loop:
8 mov al , [num1 + esi] ; Adiciona o segundo
operando a AL , considerando o flag de carry
9 adc al , [num2 + esi] ; idem
10 aaa ; Ascii adjust after addition
11 pushf ;empurrar o valor do registro de flags do
processador na pilha
12 or al , 30h ;converte para o ascii correto
13 popf ;recupera os flags

1 mov [sum + esi], al ; vai guardando os digitos em
sum
2 dec esi
3 loop add_loop
4 mov edx ,len ; comprimento da mensagem
5 mov ecx ,msg ; mensagem
8 int 0x80 ; kernel
9 mov edx ,5 ; comrimento da mensagem
10 mov ecx ,sum ; mensagem

1 section .data
2 msg db ’A Soma é:’,0xa
3 len equ $ - msg
4 num1 db ’12345 ’
5 num2 db ’23456 ’
6 sum db ’ ’

Strings
Já usamos strings de comprimento variável em nossos exemplos anteriores.
As strings de comprimento variável podem ter quantos caracteres
necessários. Geralmente, especificamos o comprimento da sequência por
qualquer uma das duas maneiras:
1 Armazenamento explícito do comprimento da string
2 Usando um caractere sentinela

Caso 1 - Comprimento Definido
msg db ’Hello, world!’,0xa
len equ $ - msg
msg db ’Hello, world!’,0xa
len equ 13

Caso 2 - Uso de Caractere Sentinela
messagem DB ’O escambau do judas!’, 0

Comandos para Manipulação de Strings
1 MOVS. Esta instrução move 1 byte Word ou Doubleword de dados
do local de memória para outro.
2 LODS. Esta instrução carrega da memória. Se o operando é de um
byte, ele é carregado no registro al, se o operando é uma palavra, ele
é carregado no registro AX e uma palavra dupla é carregada no
registro EAX.
3 STOS. Esta instrução armazena dados do registro (AL, AX ou EAX)
para a memória.
4 CMPS. Esta instrução compara dois itens de dados na memória. Os
dados podem ser de tamanho byte, palavra ou palavra dupla.
5 SCAS. Esta instrução compara o conteúdo de um registro (AL, AX
ou EAX) com o conteúdo de um item na memória.

Versões das Operações com Strings
Instrução Base Operandos em Byte Word DWord
MOVS ES:DI, DS:SI MOVSB MOVSW MOVSD
LODS AX, DS:SI LODSB LODSW LODSD
STOS ES:DI, AX STOSB STOSW STOSD
CMPS DS:SI, ES: DI CMPSB CMPSW CMPSD
SCAS ES:DI, AX SCASB SCASW SCASD

Prefixo de Repetição
O prefixo REP, quando definido antes de uma instrução de string, por
exemplo - REP MOVSB, causa repetição da instrução com base em um
contador colocado no registro CX. O REP executa a instrução, diminui o
CX em 1 e verifica se o CX é zero. Ele repete o processamento de
instruções até que o CX seja zero.

REP
O FLAG de Direção determina o sentido da operação.
Use CLD (Clear Direction Flag, DF = 0) para fazer a operação da
esquerda para a direita.
Use SDT (Set Direction Flag, DF = 1) para tornar a operação da direita
para a esquerda.

Variações do REP
1 REP É a repetição incondicional. Repete a operação até que o CX
seja zero.
2 REPE ou REPZ: É uma repetição condicional. Ele repete a operação
enquanto a bandeira zero indica igual/zero. Para quando o ZF indica
não igual/zero ou quando o CX é zero.
3 REPNE ou REPNZ: Também é uma repetição condicional. Ele
repete a operação enquanto a bandeira zero indica não igual/zero.
Para quando o ZF indica igual/zero ou quando o CX é decrementado
a zero

Diretivas Para Definição de Arrays
Definindo variáveis Normais
MESES DW 12
MESES DW 0CH
MESES DW 0110B
Definindo Arrays de Uma Dimensão
NUMEROS DW 34, 45, 56, 67, 75, 89

Outra Forma de Definir Arrays
MTX DW 0
DW 0
DW 0
DW 0
DW 0
DW 0
DW 0
Ou
MTX DW 0, 0 , 0 , 0 , 0 , 0 , 0 , 0
MTX TIMES 8 DW 0

Matrizes (019_arrays)
1 section .text
2 global _start
3 _start:
4 mov eax ,3 ;numero de bytes a serem somados
5 mov ebx ,0 ;EBX guarda a soma
6 mov ecx ,x ;ECX aponta para o elemento atual a
ser somado
7 top:
8 add ebx , [ecx]
9 add ecx ,1 ;move ponteiro para o próximo
elemento
10 dec eax ;decrementa o contador
11 jnz top ;se o contador não é zero continua
12 done:
13 add ebx , ’0’
14 mov [sum], ebx ;finaliza guardando o resutado em
sum

1 display:
2 mov edx ,1 ;comprimento da mensagem
3 mov ecx , sum ;messagem a escrever
4 mov ebx , 1 ; (stdout)
5 mov eax , 4 ; (sys_write)
6 int 0x80
7 mov eax , 4
8 mov ebx ,1
11 int 0x80
12 mov eax , 1 ;(sys_exit)
13 int 0x80

1 section .data
2 newLineMsg db 0xa
4 global x
5 x:
6 db 2
7 db 4
8 db 3
9 sum:
10 db 0

Procedimentos
Sintaxe geral para procedimentos:
proc_name:
procedure body
...
ret
CALL proc_name

Procedimentos (020_procs)
1 section .text
2 global _start
3 _start:
4 mov ecx ,’4’
5 sub ecx , ’0’
6 mov edx , ’5’
7 sub edx , ’0’
8 call sum ;chama o procedimento soma
9 mov [res], eax
10 mov ecx , msg
11 mov edx , len
14 int 0x80

1 mov ecx , res
2 mov edx , 1
5 int 0x80 ;
6 mov eax ,4
7 mov ebx ,1
10 int 0x80
12 int 0x80
13 sum:
14 mov eax , ecx
15 add eax , edx
16 add eax , ’0’
17 ret

1 section .data
2 msg db "A soma eh: "
3 len equ $- msg
4 newLineMsg db 0xa
6
7 segment .bss
8 res resb 1

Pilha
Uma pilha é uma estrutura de dados semelhante a uma matriz na memória
na qual os dados podem ser armazenados e removidos de um local
chamado "topo"da pilha. Os dados que precisam ser armazenados são
’empurrados’ para dentro da pilha e os dados a serem recuperados são
’retirados’ da pilha. Trata-se de uma estrutura de dados LIFO, ou seja, os
dados armazenados primeiro são recuperados por último.

Operações sobre as Pilhas
1 PUSH operando
2 POP endereço/registrador

Implementação
A implementação da pilha é realizada no espaço de memória reservado
para este fim. Os registros SS e ESP (ou SP) são utilizados para a
implementação da pilha. A parte superior da pilha, que aponta para o
último item de dados inserido na pilha é apontada pelo registro SS:ESP,
onde o registro SS aponta para o início do segmento de pilha e o SP (ou
ESP) dá o deslocamento para o segmento de pilha.

Características do SS
1 Apenas palavras ou palavras duplas poderiam ser salvas na pilha, não
um byte.
2 A pilha cresce na direção inversa, ou seja, em direção ao endereço de
memória inferior
3 A parte superior da pilha aponta para o último item inserido na pilha;
ele aponta para o byte inferior da última palavra inserida.

Procedimentos (021_stack)
1 section .text
2 global _start
3 _start:
4 call display
6 int 0x80
7 display:
8 mov rcx , 256 ; uso em 64 bits
9 next:
10 push rcx
11 mov eax , 4
12 mov ebx , 1
13 mov rcx , achar
14 mov edx , 1
15 int 80h

Procedimentos (021_stack)
1 pop rcx
2 mov edx , [achar]
3 cmp byte [achar], 0dh
4 inc byte [achar]
5 loop next
6 ret
7 section .data
8 achar db ’0’

Recursividade 022_fatorial
Usando a recursividade em Assembly
1 section .text
2 global _start
3 _start:
4 mov bx , 3 ;calcular o fatorial de 3
5 call proc_fact
6 add ax , 30h
7 mov [fact], ax
8 mov edx ,len ;comprimento da mensagem
9 mov ecx ,msg ;mensagem a escrever
12 int 0x80

1 mov edx ,1 ;comprimento da mensagem
2 mov ecx ,fact ;mensagem para escrever
5 int 0x80
7 int 0x80
8 proc_fact:
9 cmp bl , 1
10 jg calcula
11 mov ax , 1
12 ret
13 calcula:
14 dec bl
15 call proc_fact
16 inc bl
17 mul bl ;ax = al * bl
18 ret

1 section .data
2 msg db ’Factorial 3 is:’,0xa
3 len equ $ - msg
4
5 section .bss
6 fact resb 1

Macros
1 Escrever uma macro é outra forma de garantir a programação
modular na linguagem de montagem.
2 Uma macro é uma sequência de instruções, atribuídas por um nome e
podem ser usadas em qualquer lugar do programa.
3 No NASM, as macros são definidas com as diretivas %macro e
%endmacro.
4 A macro começa com a diretiva %macro e termina com a diretiva
%endmacro.

Sintaxe para Construção de Macros
%macro nome_macro número_de_parâmetros
<macro body>
%endmacro...

Macros 023_macro
1 ; Uma macro com dois parâmmetros
2 ; implementa a system call write
3 %macro write_string 2
4 mov eax , 4
5 mov ebx , 1
6 mov ecx , %1
7 mov edx , %2
8 int 80h
9 %endmacro
10 section .text
11 global _start
12 _start:
13 write_string msg1 , len1
17 int 0x80

Macros 023_macro
1
2 section .data
3 msg1 db ’Alo programadoress... !’,0xA ,0xD
4 len1 equ $ - msg1
5 msg2 db ’Bem vindo ao mundo da ,’, 0xA ,0xD
6 len2 equ $- msg2
7 msg3 db ’Programação assembly para linux ’,0xA ,0xD
8 len3 equ $- msg3

Gerenciamento de Arquivos
O sistema considera qualquer dados de entrada ou saída como fluxo de
bytes. Existem três fluxos de arquivo padrão:
1 Entrada padrão (stdin),
2 Saída padrão (stdout)
3 Erro padrão (stderr).

Descritor de Arquivo
Um descritor de arquivo é um inteiro de 16 bits atribuído a um arquivo
como um id de arquivo. Quando um novo arquivo é criado ou um arquivo
existente é aberto, o descritor de arquivos é usado para acessar o arquivo.
Descritores de arquivos padrões stdin, stdout e stderr são 0, 1 e 2,
respectivamente.

Ponteiro de Arquivos
Um ponteiro de arquivo especifica o local para uma operação subsequente
de leitura/gravação no arquivo em termos de bytes. Cada arquivo é
considerado como uma sequência de bytes. Cada arquivo aberto está
associado a um ponteiro de arquivo que especifica um deslocamento em
bytes, em relação ao início do arquivo. Quando um arquivo é aberto, o
ponteiro do arquivo é definido como zero.

Chamadas ao Sistema para Gerenciamento de Arquivos
%EAX NOME %EBX %ECX %EDX
2 sys_fork struct pt_regs - -
3 sys_read unsigned int char * size_t
4 sys_write unsigned int const char * size_t
5 sys_open const char * int int
6 sys_close unsigned int - -
8 sys_creat const char * int -
19 sys_lseek unsigned int off_t unsigned int

Como Fazer Chamadas ao Sistema
1 Coloque o número de chamada do sistema no registro EAX.
2 Armazene os argumentos para a chamada do sistema nos registros
EBX, ECX, etc..
3 Ligue para a interrupção relevante (80h).
4 O resultado geralmente é devolvido no registro EAX.

Como Criar um Arquivo
1 Coloque a chamada do sistema sys_creat() número 8, no registro
EAX.
2 Coloque o nome do arquivo no registro EBX.
3 Coloque as permissões de arquivo no registro ECX.
4 A chamada do sistema retorna o descritor de arquivo do arquivo
criado no registro EAX, em caso de erro, o código de erro está no
registro EAX.

Abrindo Um Arquivo Existente
1 Coloque o sistema de chamada sys_open() número 5, no registro
EAX.
2 Coloque o nome do arquivo no registro EBX.
3 Coloque o modo de acesso ao arquivo no registro ECX.
4 Coloque as permissões de arquivo no registro EDX.
5 A chamada do sistema retorna o descritor de arquivo do arquivo
criado no registro EAX, em caso de erro, o código de erro está no
registro EAX.
6 Entre os modos de acesso ao arquivo, os mais utilizados são: somente
leitura (0), somente gravação (1) e leitura-gravação (2).

Lendo Um Arquivo
1 Coloque o sistema de chamada sys_read() número 3, no registro EAX.
2 Coloque o descritor de arquivos no registro EBX.
3 Coloque o ponteiro no buffer de entrada no registro ECX.
4 Coloque o tamanho do buffer, ou seja, o número de bytes para ler, no
registro EDX.
5 A chamada do sistema retorna o número de bytes lidos no registro
EAX, em caso de erro, o código de erro está no registro EAX.

Escrevendo em Um Arquivo
1 Coloque a chamada do sistema sys_write() número 4, no registro
EAX.
3 Coloque o ponteiro no buffer de saída no registro ECX.
4 Coloque o tamanho do buffer, ou seja, o número de bytes para
escrever, no registro EDX.
5 A chamada do sistema retorna o número real de bytes escritos no
registro EAX, em caso de erro, o código de erro está no registro EAX.

Fechando o Arquivo
1 Coloque a chamada do sistema sys_close() número 6, no registro
EAX.
3 A chamada do sistema retorna, em caso de erro, o código de erro no
registro EAX.

Atualizando o Arquivo
1 Coloque o sistema de chamada sys_lseek () número 19, no registro
EAX.
3 Coloque o valor de deslocamento no registro ECX.
4 Coloque a posição de referência para o deslocamento no registro EDX.

Posições de Referência
1 Início do arquivo - valor 0
2 Posição atual - valor 1
3 Fim do arquivo - valor 2

Macros 024_arquivos
1 section .text
2 global _start
3 _start:
4 ;create the file
5 mov eax , 8
6 mov ebx , file_name
7 mov edx , lenmsgfilename
8 mov ecx , 0777 ;ler , escrever e esecutar
por todos
9 int 0x80
10 mov [fd_out], eax
11 ;escrever no arquivo
12 mov edx ,lenmsg ;número de bytes
13 mov ecx , msg ;mensagem para escrever
14 mov ebx , [fd_out] ;descritor do arquivo
16 int 0x80

Macros 024_arquivos
1 ; fecha o arquivo
2 mov eax , 6
3 mov ebx , [fd_out]
4 ; escreve a mensagem indicando o fim do arquivos
5 mov eax , 4
6 mov ebx , 1
7 mov ecx , msg_done
8 mov edx , len_done
9 int 0x80
10
11 ;abre o arquivo para leitura
12 mov eax , 5
13 mov ebx , file_name
14 mov ecx , 0 ;para acesso somente de
leitura
15 mov edx , 0777 ;ler escrever e executar
por todos
16 int 0x80

Macros 024_arquivos
1 mov [fd_in], eax
2
3 ;ler do arquivo
4 mov eax , 3
5 mov ebx , [fd_in]
6 mov ecx , info
7 mov edx , 26
8 int 0x80
9
10 ; fechar o arquivo
11 mov eax , 6
12 mov ebx , [fd_in]
13 int 0x80
14
15 ; imprimir informações
16 mov eax , 4
17 mov ebx , 1
18 mov ecx , info

Macros 024_arquivos
1
2 section .data
3 file_name db ’myfile.txt ’,0
4 lenmsgfilename equ $-file_name
5 msg db ’Bem vindo ao assembly ’,0xa
6 lenmsg equ $-msg
7
8 msg_done db ’Escrito no arquivo ’, 0xa
9 len_done equ $-msg_done
10
11 section .bss
12 fd_out resb 1
13 fd_in resb 1
14 info resb 26

Gerenciamento de Memória
A chamada do sistema sys_brk() é fornecida pelo kernel para alocar
memória sem a necessidade de movê-la mais tarde. Esta chamada
aloca memória logo atrás da imagem do aplicativo na memória. Esta
função do sistema permite definir o endereço mais alto disponível na
seção de dados.
Esta chamada do sistema requer um parâmetro, que é o endereço de
memória mais alto necessário para ser definido. Esse valor é
armazenado no registro EBX.
Em caso de erro, sys_brk() retorna -1 ou retorna o próprio código de
erro negativo. O exemplo a seguir demonstra a alocação dinâmica da
memória

Memória 025_memoria
1 section .text
2 global _start
3 _start:
4 mov eax , 45 ;sys_brk
5 xor ebx , ebx
6 int 80h
7 add eax , 16384 ;número de bytes a ser reservado
8 mov ebx , eax
9 mov eax , 45 ;sys_brk
10 int 80h
11 cmp eax , 0
12 jl exit ;exit , caso erro
13 mov edi , eax ;EDI = endereço disponível mais
alto
14 sub edi , 4 ;apontando para a última DWORD
15 mov ecx , 4096 ;número de DWORDs allocadas
16 xor eax , eax ;limpa eax
17 std ;backward - retorna

Memória 025_memoria
1
2 rep stosd ;repete para toda a área
alocada
3 cld ;coloca o DF flag para o estado nomal
4 mov eax , 4
5 mov ebx , 1
6 mov ecx , msg
7 mov edx , len
8 int 80h ;imprime uma mensagem
9 exit:
10 mov eax , 1
11 xor ebx , ebx
12 int 80h
13 section .data
14 msg db "Aloca 16k de memória!", 10
15 len equ $ - msg

Fim da Primeira Parte

paradigmas_de_programacao_1_X.pdf

Mais conteúdo relacionado

Semelhante a paradigmas_de_programacao_1_X.pdf (20)

Mais de ronaldo ramos (20)

Último (20)

paradigmas_de_programacao_1_X.pdf