SOFTWARE BÁSICO

Objetivos da Disciplina Descrever o relacionamento entre a máquina, sua linguagem de baixo nível e as linguagens de alto nível usadas para programá-la, Programação em linguagem de alto nível para linguagens de baixo nível, Conversão de programa em linguagem de alto nível para linguagens de baixo nível, Conceitos sobre alocação de variáveis estáticas e dinâmicas, Técnicas de endereçamento.

Família INTEL 80X86 (32 bits) Registradores de Dados (32, 16, 8 bits)

Processador INTEL 80X86 Registradores: de propósito geral ou de dados; de endereços (segmentos, apontadores e índices); sinalizadores de estado e controle (FLAGS); Registradores de propósito geral (de dados): – AX, BX, CX e DX • são todos registradores de 16 ou 32 bits • utilizados nas operações aritméticas e lógicas • podem ser usados como registradores de 16 ou 8 bits:

Processador INTEL 80X86 Registradores de propósito geral (de dados): AX (acumulador)  utilizado como acumulador em operações aritméticas e lógicas; em instruções de E/S, ajuste decimal, conversão etc

Processador INTEL 80X86 Registradores de propósito geral (de dados): BX (base)  usado como registrador BASE para referenciar posições de memória; BX armazena o endereço BASE de uma tabela ou vetor de dados, a partir do qual outras posições são obtidas adicionando-se um valor de deslocamento (offset). CX (contador)  utilizado em operações iterativas e repetitivas para contar bits, bytes ou palavras, podendo ser incrementado ou decrementado; CL funciona como um contador de 8 bits.

Processador INTEL 80X86 Registradores de propósito geral (de dados): DX (dados)  utilizado em operações de multiplicação para armazenar parte de um produto de 32 bits, ou em operações de divisão, para armazenar o resto; utilizado em operações de E/S para especificar o endereço de uma porta de E/S.

Registro de Endereço

Registradores Apontador de Pilha e de índice: – SP (stack pointer - apontador de pilha) é utilizado em conjunto com SS, para acessar a área de pilha na memória; aponta para o topo da pilha – atualizado automaticamente. – BP (base pointer - apontador base) é o ponteiro que, em conjunto com SS, permite acesso a dados dentro do segmento de pilha. – SI (source index - índice fonte) usado como registrador índice em alguns modos de endereçamento indireto, em conjunto com DS. – DI (destination index - índice destino) similar ao SI, atuando em conjunto com ES. • Obs: SI e DI facilitam a movimentação de dados armazenados em seqüência entre posições fonte (indicado por SI) e posições destino (indicado por DI).

Registradores Apontador de Pilha e de índice: Registrador de Sinalizadores (FLAGS): – indica o estado do microprocessador após a execução de cada instrução; – conjunto de bits individuais, cada qual indicando alguma propriedade; – subdividem-se em: FLAGS da estado (status) e FLAGS de controle.

Registrador de Sinalizadores (FLAGS):

Registrador de Sinalizadores (FLAGS): Flags de Estados: – CF - Flag de Carry • CF = 1  após instruções de soma que geram "vai um“; após instruções de subtração que geram "empréstimo" ("empresta um"); • CF = 0  caso contrário. – PF - Flag de paridade • PF = 1  caso o byte inferior do resultado de alguma operação aritmética ou lógica apresentar um número par de "1's"; • PF = 0  caso contrário (número impar).

Registrador de Sinalizadores (FLAGS): ZF - Flag de Zero • ZF = 1  caso o resultado da última operação aritmética ou lógica seja igual a zero; • ZF = 0  caso contrário. SF - Flag de Sinal: utilizado para indicar se o número resultado é positivo ou negativo em termos da aritmética em Complemento de 2 (se não ocorrer erro de transbordamento - overflow). • SF = 1  número negativo; • SF = 0  número positivo. OF - Flag de Overflow (erro de transbordamento). • OF = 1  qualquer operação que produza overflow; • OF = 0  caso contrário.

Linguagem Assembly

Linguagem Assembly Campo Nome: – Pode ser um rótulo de instrução, um nome de sub-rotina, um nome de variável, contendo de 1 a 31 caracteres, iniciando por uma letra ou um caractere especial e contendo somente letras, números e os caracteres especiais ? . @ _ : % Exemplos: nomes válidos nomes inválidos - LOOP1: - DOIS BITS - .TEST - 2abc - @caracter - &A2.25 - SOMA_TOTAL4 - #33

Linguagem Assembly Campo de Código de Operação: – Contem o código de operação simbólico (mnemônico) – No caso de diretivas, contem o código de pseudoinstrução Exemplos: instruções diretivas - MOV - .MODEL - ADD - .STACK - INC - nome PROC - JMP

Linguagem Assembly Campo de operandos: • Instruções podem conter 0, 1 ou 2 operandos no 8086. Exemplos: NOP ; sem operandos: instrui para fazer nada INC AX ; um operando: soma 1 ao conteúdo de AX ADD $2, AX ; dois operandos: soma 2 ao conteúdo da ; palavra de memória A (variável A) Operandos imediatos (constrantes numéricas) devem começar com $

Linguagem Assembly No caso de instruções de dois operandos: – o primeiro, operando fonte: não modificado pela instrução; – o segundo, operando destino: registrador ou posição de memória onde o resultado será armazenado, o conteúdo inicial será modificado; – os operandos são separados por uma vírgula. Campo de Comentário: – Um ponto-e-vírgula ( # ) marca o início deste campo;

Linguagem Assembly Formato de dados, variáveis e constantes – decimal: $61 # é considerado decimal – hexa: 0x12 # é considerado hexadecimal

Linguagem Assembly Algumas instruções básicas do 8086 – mov origem, destino - movl origem, destino • Usada para transferir dados entre: – registrador e registrador – registrador e uma posição de memória – mover um número diretamente para um registrador ou posição de memória movw WORD1 ,%AX ; mov o conteúdo da mem WORD1 para AX movb $2, %AH ; transfere o num 2 para AH movb $0x4, %AH ; idem anterior: 4h para AH movb %BL, %AH ; mov o conteúdo BL para AH movw %CS, %AX ; transfere cópia do conteúdo de CS para AX

Linguagem Assembly Algumas instruções básicas do 8086 add origem, destino addl origem, destino sub origem, destino subl origem, destino and origem, destino andl origem, destino – Usadas para adicionar (ou subtrair) dados entre: • registrador e registrador • registrador e uma posição de memória • adicionar (ou subtrair) um número diretamente a (de) um registrador ou posição de memória

Linguagem Assembly Algumas instruções básicas do 8086 orl origem, destino xorl origem, destino imull origem, destino idivl origem, destino – Usadas para adicionar (ou subtrair) dados entre: • registrador e registrador • registrador e uma posição de memória • adicionar (ou subtrair) um número diretamente a (de) um registrador ou posição de memória

Linguagem Assembly Algumas instruções básicas do 8086 pushl f ; empilha origem popl d ; desempilha destino – Usadas para empilhar ou desempilhar: • pushl f ; (esp = esp – 4; mem[esp] = f) • popl d ; (d = mem[esp]; esp = esp + 4)

Linguagem Assembly ● f ou f1: operando fonte ou origem ● d: operando destino ou resultado ● Operandos imediatos (constantes numéricas) devem começar com $ ● Registradores devem iniciar com %eax ● Na mesma instrução, apenas um dos operandos pode ser do tipo mem ● O endereço de acesso à memória é calculado pela expressão: endereço(mem) = base + (index * scale) + disp ● A instrução cdq é usada para estender o sinal de %eax em %edx antes de executar a idivl

Linguagem Assembly

Linguagem Assembly

Linguagem Assembly Segmento de dados – Contem a definição e declaração das variáveis. – Pode-se também fazer a atribuição de símbolos para constantes. Sintaxe: .DATA (segment data) Exemplo: .DATA WORD1 DW A8h BYTE1 DB 5 MENSAGEM DB ‘Isto e uma mensagem’ LF EQU 0Ah

Linguagem Assembly

Procedimentos e Funções Uso da pilha: Endereço de retorno Passagem de parâmetros Armazenamento de variáveis locais ● Uso de registradores: %ebp é usado como apontador para parâmetros e variáveis locais na pilha O valor original do %ebp deve ser preservado Deve ser guardado na pilha no início da rotina e recuperado no final da rotina A instrução movl %esp,%ebp faz o %ebp apontar para os parâmetros e variáveis locais na pilha

Sequencia mínima de uma rotina push %ebp # quarda %ebp original na pilha movl %esp, %ebp # %ebp aponta para parâmetros e # variáveis locais subl $N, %esp # reserva N bytes na pilha para # variáveis locais . . . movl %ebp, %esp # libera espaço reservado na pilha # para variáveis locais popl %ebp # recupera %ebp original da pilha # retorna ● %eax guarda o valor de retorno de uma função.

Sequencia mínima de uma rotina

Sequencia mínima de uma rotina

Pseudo instruções .date indica um trecho de programa que será armazenado variáveis a: .int b: .int .text indica um trecho de programa que será armazenado no segmento de código .globl label declara o label global, visível por outros módulos

Sequencia mínima de uma rotina a = a + 10; addl $10,a #include <stdio.h> main() { int x; x = func(); printf("%d\n",x ); } .text .global func func: pushl %ebp movl %esp, %ebp subl $0, %esp movl $10, %eax movl %ebp,%esp popl %ebp ret

Sequencia mínima de uma rotina Uma instrução pode finalizar com l, w ou b, depende do tamanho do registrador da operação: "long" - 4 byte operands, instrução finaliza com 'l‘ - eax "word" - 2 byte operands, instrução finaliza com 'w' - ax "byte" - 1 byte operands, instrução finaliza com 'b' - ah #include <stdio.h> main() { int x; x = func(); printf("%d\n",x ); } .text .global func func: pushl %ebp movl %esp, %ebp subl $0, %esp movw $5, %ax addw $12, %ax movl %ebp,%esp popl %ebp ret

Sequencia mínima de uma rotina Uma instrução pode finalizar com l, w ou b, depende do tamanho do registrador da operação: "long" - 4 byte operands, instrução finaliza com 'l‘ - eax "word" - 2 byte operands, instrução finaliza com 'w' - ax "byte" - 1 byte operands, instrução finaliza com 'b' - ah #include <stdio.h> main() { int x; x = func(); printf("%d\n",x ); } .text .global func func: pushl %ebp movl %esp, %ebp subl $0, %esp movw $5, %ax addw $0x12, %ax movl %ebp,%esp popl %ebp ret

Sequencia mínima de uma rotina Uma instrução pode finalizar com l, w ou b, depende do tamanho do registrador da operação: "long" - 4 byte operands, instrução finaliza com 'l‘ - eax "word" - 2 byte operands, instrução finaliza com 'w' - ax "byte" - 1 byte operands, instrução finaliza com 'b' - ah #include <stdio.h> main() { int x; x = func(); printf("%d\n",x ); } .text .global func func: pushl %ebp movl %esp, %ebp subl $0, %esp movb $17, %al addb $15, %al movl %ebp,%esp popl %ebp ret

Sequencia mínima de uma rotina Uma instrução pode finalizar com l, w ou b, depende do tamanho do registrador da operação: "long" - 4 byte operands, instrução finaliza com 'l‘ - eax "word" - 2 byte operands, instrução finaliza com 'w' - ax "byte" - 1 byte operands, instrução finaliza com 'b' - ah #include <stdio.h> main() { int x; x = func(); printf("%d\n",x ); } .text .global func func: pushl %ebp movl %esp, %ebp subl $0, %esp movb $2, %al movb $2, %ah movl %ebp,%esp popl %ebp ret

Sequencia mínima de uma rotina a++ , a-- #include <stdio.h> main() { int x; x = func(); printf("%d\n",x ); } .text .global func func: pushl %ebp movl %esp, %ebp subl $0, %esp movl $12, %eax incl %eax decl %eax movl %ebp,%esp popl %ebp ret

Sequencia mínima de uma rotina a = a + b; a = a - b .text .globl func func: pushl %ebp movl %esp, %ebp subl $0, %esp movl $5,%eax addl $10,%eax movl %ebp,%esp popl %ebp ret movl $25,%eax subl $10,%eax

Sequencia mínima de uma rotina a = a & b; a = a * b .text .globl func func: pushl %ebp movl %esp, %ebp subl $0, %esp movl $11,%eax andl $10,%eax movl %ebp,%esp popl %ebp ret movl $5,%eax imull $6,%eax

Sequencia mínima de uma rotina a = a | b; a = a ^ b .text .globl func func: pushl %ebp movl %esp, %ebp subl $0, %esp movl $11,%eax orl $10,%eax movl %ebp,%esp popl %ebp ret xorl $10,%eax

Sequencia mínima de uma rotina section .data a: .int section .text .globl func func: pushl %ebp movl %esp, %ebp subl $0, %esp movl $15, a movl a, %eax addl $9, %eax movl %ebp,%esp popl %ebp ret b: .int movl $12, b addl b, %eax