Ac Guiao

Arquitectura de Computadores
Aulas prticas
2009 Pedro Freire
Este documento tem alguns direitos reservados: Atribuio-Uso No-Comercial-No a Obras Derivadas 2.5 Portugal http://creativecommons.org/licenses/by-nc-nd/2.5/pt/ Isto significa que podes us-lo para fins de estudo. Para outras utilizaes, l a licena completa. Crdito ao autor deve incluir o nome (Pedro Freire) e referncia a www.pedrofreire.com.
REQUISITOS ................................................................................................................................................... 6 PARA PARA

A ESCOLA ............................................................................................................................................. 6 O ALUNO ............................................................................................................................................... 6
AULA 01 .......................................................................................................................................................... 7 AMBIENTE EXPLICAR

DE TRABALHO ................................................................................................................................ 7 E CORRER ........................................................................................................................ 7
MONTAR/COMPILAR
O PRIMEIRO EXEMPLO
.................................................................................................................. 8
HARDWARE: CPU, RAM
E ENDEREAMENTO ................................................................................................. 9
AULA 02 ........................................................................................................................................................ 11 CONSTANTES ................................................................................................................................................. 11 CARACTERES

E STRINGS .............................................................................................................................. 11 E VARIVEIS .......................................................................................................... 12
ETIQUETAS (LABELS)
DB, DW, DD, DQ ........................................................................................................................................ 12 EQU E
$....................................................................................................................................................... 14
AULA 03 ........................................................................................................................................................ 14 REGISTOS ..................................................................................................................................................... 14
FLAGS .......................................................................................................................................................... 14
SEGMENTOS/SECES ................................................................................................................................... 14 EXERCCIO ................................................................................................................................................... 14 AULA 04 ........................................................................................................................................................ 14
NOME.ASM ..................................................................................................................................................... 14 RESB, RESW, RESD, RESQ ......................................................................................................................... 14
LER
DADOS DO TECLADO .............................................................................................................................. 14 MEMRIA ............................................................................................................................ 14
REFERNCIAS
EXERCCIO ................................................................................................................................................... 14 AULA 05 ........................................................................................................................................................ 14

PALAVRAS.ASM ............................................................................................................................................. 14
EXERCCIOS ................................................................................................................................................. 14 AULA 06 ........................................................................................................................................................ 14

A06-CONVERTE2.ASM .................................................................................................................................. 14
EXERCCIOS ................................................................................................................................................. 14 AULA 07 ........................................................................................................................................................ 14

A07-CONVERTE2A.ASM ................................................................................................................................ 14
PILHA .......................................................................................................................................................... 14 EXEMPLO....................................................................................................................................................... 14 PASSAR

ARGUMENTOS A SUB-ROTINAS/FUNES USANDO A PILHA ............................................................ 14
EXERCCIO ................................................................................................................................................... 14 AULA 08 ........................................................................................................................................................ 14 LEITURA

DE FICHEIROS: A08-LE2.ASM .................................................................................................. 14 FICHEIROS.......................................................................................................................... 14
ABRIR/FECHAR
HANDLE (MAANETA
ESCRITA
OU NMERO DE FICHEIRO) .................................................................................... 14
ASCIIZ ...................................................................................................................................................... 14
PARA FICHEIROS: A08-ESCR.ASM ............................................................................................. 14
EXERCCIO ................................................................................................................................................... 14 AULA 09 ........................................................................................................................................................ 14 OPERAES DETECO MLTIPLA

ARITMTICAS: A09-CALCULADORA.ASM.................................................................................. 14 DE EXCESSO
(OVERFLOW) .......................................................................................................... 14
PRECISO.................................................................................................................................... 14
EXERCCIOS ................................................................................................................................................. 14 AULA 10 ........................................................................................................................................................ 14 OPERAES DETECO MLTIPLA

EM INTEIROS COM SINAL ......................................................................................................... 14 DE EXCESSO
(OVERFLOW) .......................................................................................................... 14
PRECISO.................................................................................................................................... 14
EXERCCIO ................................................................................................................................................... 14 AULA 11 ........................................................................................................................................................ 14 OPERAES

EM NMEROS FRACCIONRIOS ................................................................................................... 14
EXERCCIO ................................................................................................................................................... 14 AULA 12 ........................................................................................................................................................ 14 EXERCCIOS ................................................................................................................................................. 14 VIRTUALBOX LINUX ................................................................................................................................... 14 INSTALAR INSTALAR CRIAR USAR
O O SOFTWARE BASE ...................................................................................................................... 14 A IMAGEM DO
XUBUNTU .............................................................................................................. 14 XUBUNTU ................................................................................................... 14
A MQUINA VIRTUAL DO
XUBUNTU ......................................................................................................................................... 14
BIBLIOGRAFIA............................................................................................................................................. 14
Requisitos
Para a escola
Requisitos para as salas das aulas prticas de Arquitectura de Computadores: Um qualquer Linux instalado, desde que suporte o NASM (ver www.nasm.us), nativo, em dual-boot ou mquina virtual (VirtualPC ou VMware). Pode ainda ser acedido remotamente via Telnet/SSH desde que todo o processo de aceder ao sistema seja de forma visual em single-click at ao surgimento da prompt utilizador+senha. NASM (Netwide Assembler) instalado no Linux, e assegurar a existncia do linker (ld). Assegurar que o Linux tem ambiente visual instalado de fcil acesso (par utilizador+senha), assim como editor de texto visual ( semelhana do Bloco de Notas do Windows). Acesso Internet com um browser.
Deve haver 1 PC por aluno. Cada aula est programada para uma durao de 1,5h.
Para o aluno
Comparncia nas aulas. Este guio tem propositadamente omissos certos elementos importantes para a compreenso total da matria (notas histricas, relaes entre partes diferentes da matria, avisos sobre erros comuns, etc., ou seja, elementos para uma nota 20), embora seja suficiente para passar com nota bastante acima de 10. Deves ter instalado o Linux em computador prprio se quiseres acompanhar a matria em casa. Consulta www.pedrofreire.com para uma pequena introduo de como o fazer. O professor ir distribuir uma cpia de um Linux j preparado para as aulas aos alunos que tiverem dificuldade em instal-lo sozinhos: pede a cpia ao professor e consulta a seco VirtualBox Linux ao fim deste Guio. V tambm a seco acima para requisitos. No no entanto de todo necessrio que tenhas estes sistemas em casa para conseguires passar cadeira (podes us-los na escola). Esta cadeira assume que j tens experincia no uso de computadores (no necessariamente no Linux).
2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com
pg. 6
Aula 01
Introduo e contextualizao: o Assembly, o nasm e Linux. Hiperligaes. Referncias e avaliao.
Ambiente de trabalho
Os exerccios desta cadeira esto feitos para funcionarem sobre Linux. V em www.pedrofreire.com as tuas opes para instalar este sistema no teu computador. Existe uma pequena introduo ao final deste Guio para instalar um Linux fornecido pelo professor (seco VirtualBox Linux, antes da Bibliografia). Qualquer verso de Linux serve. Tens no entanto de instalar o nasm no teu. Consulta www.nasm.us ou pesquisa na Internet por uma verso rpm do nasm que ser mais fcil de instalar na maior parte dos Linux. Quando tiveres o Linux instalado localiza a consola/terminal (linha de comandos do Linux) e ambienta-te ao sistema de directrios, browser e editor de texto. Ambienta-te tambm aos comandos cd, ls, cp, mv e rm bsicos na linha de comandos. O comando man comando d-te ajuda sobre o comando comando.
Montar/compilar e correr
Descarrega o primeiro exemplo (hello.asm). Este o primeiro programa tpico de qualquer linguagem: exibe a frase Ol, mundo! (Hello, world!) no ecr. Para o experimentarmos vamos precisar de o montar (assemble outras linguagens usam a expresso compilar). Para montar qualquer programa prog.asm genrico, precisamos de correr os seguintes comandos na consola/terminal:
nasm -f elf prog.asm ld prog.o ./a.out
As partes a cor mais clara referem-se a este exemplo em particular, e devem ser alteradas em cada programa que se vai montar. Por exemplo, no nosso hello.asm, substitumos prog.asm por hello.asm e prog.o por hello.o.
pg. 7
Em algumas verses de Linux mais recentes, ser necessrio usar elf64 no primeiro comando, em vez de elf. Testa e experimenta a ver qual funciona para ti. Nota que se precisas de elf64 no vais conseguir correr alguns exemplos da cadeira. Os dois primeiros comandos no iro exibir nada se tudo correr bem. O ltimo comando corre o programa. No caso do hello.asm, isto simplesmente exibe no ecr: Hello, world!
Explicar o primeiro exemplo

Abre o hello.asm. Ele pode ser aberto com o Bloco de Notas (Notepad) no Windows, e deve abrir automaticamente com um duplo-clique em Unix (caso contrrio abre-o num editor de texto qualquer: gedit, kwrite, kate, vi, etc.).
section .data msg len db equ "Hello, world!",0xa $ - msg
section .text global _start _start: ;write our string to stdout mov mov mov mov int ;and exit mov mov int ebx,0 eax,1 0x80 edx,len ecx,msg ebx,1 eax,4 0x80
Legenda: Comentrios texto descritivo para o programador documentar o cdigo. ignorado pelo nasm e pelo computador (no far sequer parte do programa final). Comeam com um ; numa linha e so comentrios at ao final dessa linha. Vrios comentrios do ficheiro hello.asm foram eliminados na verso exibida acima. Directivas comandos que dizem ao nasm como organizar certas partes do programa. Veremos estas em mais detalhe em aula posterior. Instrues Cdigo real que ser executado pelo computador.
pg. 8
As instrues tm um nome, seguido de zero, um ou dois argumentos separados por vrgula. Este programa s usa duas instrues: mov (abreviatura de move) e int (abreviatura de interrupt). mov copia valores do seu segundo argumento para o primeiro e ento mov edx,len equivale (esquematicamente) a edx=len int 0x80 por seu lado usado no Linux para chamar o prprio Linux, i.e., para lhe pedir para fazer algum trabalho em nome da aplicao. Cada um dos dois blocos de cdigo (write our string to stdout e and exit) explicados na aula pede uma funcionalidade diferente ao Linux. O primeiro pede para se escrever uma mensagem no ecr e o segundo termina o programa.
Hardware: CPU, RAM e endereamento

O Assembly a nica linguagem que directamente entendida pelo prprio hardware (i.e., pelos circuitos que compem um computador). Dois destes circuitos so de extrema importncia:
Processador central (CPU)
Memria (RAM)
O processador central o crebro do computador. Ele quem reconhece as instrues e age de acordo com elas. A memria um grande bloco de notas do processador: guarda informao. A memria hoje em dia tem milhares de milhes de bytes (gigabytes). Precisamos de poder referir cada um desses bytes de forma independente. Precisamos de poder apontar para um e dizer ao CPU: escreve naquele ali. Isso faz-se usando endereamento, tal como temos moradas para entrega de correio dos CTT. No computador, cada morada de um byte um nmero inteiro de 0 em diante. Tudo o que temos na memria ento um fio de nmeros guardados em cada byte. Se esse nmero se refere a uma msica, a um vdeo, a uma carta, ou a um programa, s depende de como est a ser usado em cada momento. Quem d vida a um computador o software. Sem ele, o computador no mais do que uma mquina de calcular cara. Um ltimo conceito importante sobre a memria que todos os seus bytes tm sempre um valor numrico qualquer. Eu posso no saber de antemo que valor
pg. 9
esse (em cujo caso digo que ele desconhecido ou lixo), mas ele existe sempre. No h o conceito de um byte no ter nada.
pg. 10
Aula 02
Explicao de vrios elementos do hello.asm.
Constantes
Em vrias partes do nosso primeiro exemplo vemos constantes. O nasm suporta vrios tipos de constantes: Numricas decimais (e.g.: 75) Numricas hexadecimais (e.g.: 0x4B, 04Bh ou $04B) Numricas octais (e.g.: 113q ou 113o) Numricas binrias (e.g.: 1001011b) Numricas de vrgula flutuante, em decimal (e.g.: 75.0) Caracteres (e.g.: 'K') Strings (cadeias/sequncias de caracteres) (e.g.: "Letra K")
Exemplos e detalhes explicados na aula. Exerccio: Identifique as 8 constantes usadas no hello.asm e o seu respectivo tipo.
Caracteres e strings
Existe uma norma universal para correspondncia entre nmeros e caracteres ocidentais: o ASCII. Podes ver a tabela ASCII em http://pt.wikipedia.org/wiki/ASCII. Como podes ver, apenas esto definidos 128 cdigos ASCII. Isto cabe num byte. Ento por razes prticas, e para a totalidade de exerccios da cadeira, podemos assumir que 1 caracter = 1 byte. Dos 33 caracteres de controle, dois so importantes para a cadeira: o CR (Carriage Return, ou retorno do carro), cdigo 0xD, e o LF (Line Feed, ou alimentar linha), cdigo 0xA. Dependendo do sistema operativo onde estamos a trabalhar, diferentes combinaes destes caracteres compem uma quebra de linha (EOL): Windows: Unix (incluindo Linux): Apple Macintosh (antigo): 0xD, 0xA 0xA 0xD
pg. 11
Ver tambm http://pt.wikipedia.org/wiki/Nova_linha. Uma string (cadeira/sequncia de caracteres) no mais do que vrios caracteres escritos uns a seguir aos outros em memria.
Etiquetas (labels) e variveis

No hello.asm vemos 3 etiquetas ao todo: msg, len e _start. Uma etiqueta identifica uma zona do cdigo. Se precede uma instruo, deve ser seguida de dois pontos (:), como a _start. Quando usada por si mesma no cdigo, ela representa o endereo de memria da zona que identifica. Quando usada indirectamente para se aceder zona de memria que identifica, como em: [msg] podemos tambm chamar a essa etiqueta e zona de memria que identifica de varivel (como uma varivel matemtica). Mais sobre este uso em aula posterior. No hello.asm, podemos chamar a msg de varivel. Quando usada com a directiva equ (ver abaixo) podemos tambm chamar a essa etiqueta de constante (por si mesma). No hello.asm, podemos chamar a len de constante.
db, dw, dd, dq

Estas so as directivas define (definir). Definem nmeros de tamanhos diferentes, dependendo da segunda letra da directiva:
Define... db dw dd dq Bytes Words Double-words Quad-words Bits 8 16 32 64 Bytes 1 2 4 8 Mximo valor 255 65535 4 mil milhes 1,81019
As directivas define criam espao na memria do nosso programa com os dados especificados frente deles (nmeros, caracteres ou strings separados por vrgulas). Cada nmero especifica um byte, word, etc., diferente, dependendo da directiva. Exemplo:
db 1, 2, 3, 4
pg. 12
Esta directiva cria em memria os seguintes bytes:

1 2 3 4
Trivial. Mas, e esta directiva?

dw 1, 2, 3, 4
Bem, vamos ver. Como se representa o nmero 1 em binrio? 1. E se eu quiser que ele ocupe um byte inteiro (8 bits)? Adiciono zeros esquerda: 00000001 E se eu quiser que este nmero tenha 16 bits? Continuo a adicionar zeros esquerda: 00000000 00000001 Este nmero de 16 bits tem agora o tamanho de uma word. Podemos dividi-lo nos seus dois bytes componentes e reconverter para decimal: 00000000 = 0; 00000001 = 1 Os processadores Intel que estudamos guardam estes bytes em memria da direita para a esquerda (bytes menos significativos primeiro) formato little-endian: ver http://pt.wikipedia.org/wiki/Little_endian Ento o seu aspecto em memria vai ser:
1 0
Repetindo o processo para as restantes words do exemplo, ficamos com:

2 0 3 0 4 0
Seguindo o mesmo raciocnio, com esta directiva:

dd 1, 2
pg. 13
Vamos ver:
1 0 0 0 2 0 0 0
equ e $
A directiva equ a abreviatura de equate e significa igualar a. Torna a etiqueta sua esquerda uma constante por si mesma, com valor igual ao resultado da expresso que segue o equ. Exemplos:
PI PI_x_2 equ 3.141592653589793238462 equ PI * 2
Por conveno, as etiquetas das constantes costumam estar escritas em maisculas. Um smbolo especial que pode ser usado nas expresses equ e noutro qualquer stio onde seja aceite um inteiro o $. Ele representa o endereo inicial da linha onde est o $, ou o prximo endereo disponvel se esta no gerar cdigo. com recurso ao $ que o comprimento da string Hello, world! est a ser calculado no hello.asm. Mais detalhes na aula. Exemplos:
; Se aqui $=0, ento... db 1, 2 A equ $ dw 3 B equ $
; A = 2 ; B = 4
pg. 14
Aula 03
Todas as instrues mov do hello.asm usam registos e esto no segmento de cdigo.
Registos
Registos no so mais do que pequenas memrias internas do processador, usadas para clculos temporrios. Cada uma dessas memrias tem um nome diferente, tem um tamanho de 32-bits e guarda um nmero inteiro. Os registos mais comuns e que vamos usar nesta cadeira so: eax ebx ecx edx esi edi ebp cs ds es ss (Acumulador) (Base) (Contador) (Dados) (Endereo de origem Source Index) (Endereo de destino Destination Index) (Endereo base Base Pointer) (Segmento de cdigo) (Segmento de dados) (Segmento extra) (Segmento da pilha Stack Segment)
Os primeiros 4 so os registos de uso geral. Os restantes tm comportamentos especficos com certas instrues que veremos mais tarde. Os detalhes da utilizao de todos estes registos e do nome dado a cada um (acumulador, etc.) explicado na aula. Podemos escrever um valor num registo com a instruo mov:
mov eax, 420
Os registos podem ser lidos da mesma forma, e usados em quase todas as restantes instrues do processador. Os registos de uso geral tm outros nomes que se referem a partes do mesmo registo. Por exemplo, para o eax:
ax (16 bits) eax (32 bits) ah (8 bits) al (8 bits)
pg. 15
metade inferior do eax, chamamos de ax. Esta subdivide-se na metade alta (high) com o nome ah, e a metade baixa (low) com o nome al. Lembra-te no entanto que estes so nomes para partes diferentes do mesmo registo! Exerccio resolvido:
mov mov eax, 0xABCD1234 ax, 0xFFFF
Estas instrues so vlidas? Quantos bits tm cada um dos seus argumentos?* Depois destas duas linhas, qual o valor de eax? Porqu? Agora acrescento ainda esta linha:
mov ah, 0x00
Depois das trs linhas, qual o valor de eax? Porqu? Os registos esi, edi e ebp no tm verses de 8 bits. Os registos de segmentos so explicados abaixo.
Flags
O registo flags um registo especial, de 32 bits. No podemos aceder a este registo directamente, mas sim a alguns dos seus bits, em instrues especializadas. Isto porque cada um dos seus bits representa uma flag (bandeira ou bandeirola, mas vamos continuar a usar o estrangeirismo porque mais comum). Uma flag um bit que representa um estado de um resultado de uma operao, ou um estado indicador para o processador se comportar de certa maneira em certas situaes. Cada flag representada por uma nica letra. Vamos ver trs exemplos comuns. A flag Zero (Z) indica se a ultima operao aritmtica teve um resultado de zero. Se (por exemplo) fizermos a conta 5-5 em Assembly, a flag Z fica activa (a 1). Podemos depois testar essa flag com as instrues de salto condicional JZ e JNZ (em detalhe em aula posterior). A flag Carry (C) indica se a ultima operao aritmtica teve carry (transporte) no ltimo bit (do 32 para o 33 no caso de operaes de 32 bits). Se (por exemplo) somarmos 3 mil milhes a 3 mil milhes em Assembly, a flag C fica activa (a 1). Podemos depois testar essa flag com as instrues de salto condicional JC e JNC (em detalhe em aula posterior).
eax e 0xABCD1234 tm ambos 32 bits, logo a instruo vlida. ax e 0xFFFF tm ambos 16 bits pelo que a instruo tambm vlida. 0xABCDFFFF 0xABCD00FF
pg. 16
A flag de Direco (D) indica ao processador se as instrues de string devem varrer sequncias de bytes na direco normal (aumentando o endereo, quando D=0, o que se faz com CLD, Clear Direction flag) ou na direco inversa (diminuindo o endereo, quando D=1, o que se faz com STD, Set Direction flag). Mais detalhes sobre instrues de string em aula posterior.
Segmentos/seces
Segmentao uma estratgia para resolver dois problemas: relocation (mudana de endereo) e proteco de cdigo. Imagina que ligaste agora o computador. Corres o hello.asm. Porque h poucos programas a correr, ele carregado talvez no endereo 250 mil. E ento o endereo da mensagem Hello, world! (hipoteticamente) 250050. Mas agora ls notcias da Internet enquanto abres um filme de DVD e descarregas e-mail. Voltas a correr o hello.asm que fica no endereo 710 mil. O endereo da mensagem Hello, world! (hipoteticamente) 710050. Ento... que endereo deve o nasm colocar na linha
mov ecx,msg
para representar a mensagem? A segmentao resolve este problema com registos que mantm o endereo onde as vrias seces do programa foram colocadas: Cdigo (cs) Dados inicializados (ds e es) Dados no inicializados (ds e es) Pilha (ss)
Em qualquer acesso memria, agora o processador faz automaticamente a soma desses endereos iniciais com o endereo que se est a pedir no cdigo. Assim o nasm s tem de assumir que est num mundo perfeito onde as seces de qualquer programa comeam sempre no endereo zero (0). Claro que para isto se conseguir, o programador tem de identificar no seu cdigo a que seces pertence cada instruo e directiva. Isto faz-se com a directiva section que pode levar os seguintes argumentos: .text (seco/segmento de cdigo) .data (seco/segmento de dados inicializados) .bss (seco/segmento de dados no inicializados)
A pilha criada implicitamente. A proteco de cdigo tem a ver com assegurar-se que o nosso programa trabalha apenas nas zonas de memria que lhe foram reservadas e no fora delas, destruindo outros programas. O MS-DOS antigo e o Windows anterior ao
pg. 17
Windows NT e Windows 95 no usava estes mecanismos de proteco pelo que um nico programa com erros poderia trazer abaixo todo o sistema. Hoje em dia o Windows (e desde sempre, o Unix) usam as capacidades dos processadores de verificarem em cada acesso memria, se esse acesso est dentro dos limites conhecidos de cada segmento, e apenas permitem o acesso nessas condies. Por esta razo os registos de segmento (cs, ds, etc.) hoje em dia no so meros endereos iniciais das partes dos programas, mas coisas mais complexas e com mais informao. Por essa razo no se deve alterar os registos de segmento, excepto para copiar um para outro, e.g.:
mov mov eax, ds es, eax
Exerccio
Isto conclui a nossa anlise ao hello.asm. Deves agora ser capaz de compreender todo o cdigo deste programa em detalhe. Se isso no for verdade, consulta as aulas anteriores. Para testar os teus conhecimentos vamos tentar dois exerccios. 1. Altera o hello.asm para que em vez de ele dizer Ol, mundo!, diga Adeus mundo cruel!. 2. Altera o hello.asm para que ele exiba ambas as frases ao mesmo tempo (uma em cada linha). Faz isto com duas verses: uma alterando s a seco de dados, e outra que tambm acrescenta um novo bloco para exibir uma nova frase. Correco na aula.
pg. 18
Aula 04
Hoje vamos resolver um novo programa: o nome.asm. Monta-o e corre-o. O que faz?
nome.asm
Este programa tem algumas coisas novas. Comeamos por:
section .bss nome resb MAX_NOME
Na seco de dados no inicializados (.bss) estamos a definir uma etiqueta nome com recurso directiva resb. Esta uma nova directiva.
resb, resw, resd, resq

resb a abreviatura de Reserve Bytes (reservar bytes). Recebe um nico argumento que ser a quantidade de bytes a reservar. Existem variantes da instruo para outros tamanhos de reserva:
Reserve... resb resw resd resq Bytes Words Double-words Quad-words
Estas instrues reservam espao suficiente para guardar a quantidade pedida de bytes, words, etc.. Estes dados no estaro inicializados, pelo que pertencem seco .bss. Compare isto com os db, dw, etc., onde especificamos o valor inicial de cada elemento, da que sejam dados inicializados (seco .data).
pg. 19
Exemplo:
db 5 resb 5
Quantos bytes esto definidos em cada linha? E qual o valor inicial de cada byte?*
dw 1 resw 2
Quantos bytes esto definidos em cada linha? E qual o valor inicial de cada byte?
Ler dados do teclado

Do restante cdigo, s um novo bloco L nome novo:
; L nome mov mov mov mov int mov edx,MAX_NOME ecx,nome ebx,0 eax,3 0x80 [nome_len],eax
Este bloco, explicado na aula, s tem uma instruo de aspecto novo: a ltima.
Referncias memria
Sempre que usamos numa instruo os parntesis rectos, estamos a tentar ler/escrever na memria principal (RAM) do sistema. O valor que estiver dentro dos parntesis rectos (que deve ser um nmero inteiro, uma etiqueta, ou um registo de 32 bits) o endereo a partir do qual desejo ler/escrever. Ento, neste exemplo, se nome_len o endereo da double-word 0, ento [nome_len] l/escreve em cima do 0. por esta razo que uma etiqueta com parntesis rectos volta se pode chamar de varivel (ver aula anterior). Como a instruo mov copia sempre os valores da direita para a esquerda, a ltima linha do bloco acima:
mov [nome_len], eax
escreve eax na varivel nome_len.
db 5 define 1 byte com o valor 5; resb 5 define 5 bytes com valor indefinido (desconhecido).
dw 1 define 2 bytes com os valores 1 e 0 (ver aula anterior); resw 2 define 4 bytes com valor indefinido (desconhecido).
pg. 20
Ento obviamente
mov eax, [nome_len]
ser ento a forma de ler uma varivel.
Exerccio
Faz com que o programa responda no apenas Bem-vindo nome, mas Bemvindo nome a este PC. Correco na prxima aula.
pg. 21
Aula 05
Resoluo do exerccio da aula anterior. Para exibir mais uma frase vamos precisar de mais um bloco para escrever para o ecr. Como este bloco se vai referir a uma frase esttica, vamos copiar (por exemplo) o bloco Escreve o cumprimento, inserindo-o na posio certa do cdigo para ter o comportamento que desejamos no ecr: depois de Escreve o nome, mas antes do fim:
; Escreve "a este PC" mov mov mov mov int edx, ecx, ebx, eax, 0x80 glen greet 1 4
As letras mais claras referem-se s partes que copimos do bloco Escreve o cumprimento e que foram modificadas. No entanto este novo bloco, tal como est, escreve a frase greet (Bem-vindo) no ecr. Queremos que ele escreva outra frase que ainda no foi definida ao topo do cdigo. Ento temos de a definir, por exemplo logo abaixo de greet e glen:
greet2 db " a este PC!" g2len equ $ - greet2
As letras mais claras referem-se s partes que copimos de greet e glen e que foram modificadas. Note-se que demos um novo nome a esta nova string: greet2. O comprimento desta string tambm teve de ter um novo nome: g2len. Aplicamos ento estes novos nomes no novo bloco que adicionmos ao fim do cdigo:
; Escreve "a este PC" mov mov mov mov int edx, ecx, ebx, eax, 0x80 g2len greet2 1 4
As letras mais claras referem-se s alteraes.
pg. 22
Monta e corre. Verificas dois problemas: 1. A frase surge na linha abaixo do nome 2. A linha de comandos fica frente da frase, e no por baixo. Resolver o ponto 2 mais fcil. O que falta frase uma quebra de linha ao final. Tal como no hello.asm, isso resolve-se acrescentando o cdigo 0xA ao final:
greet2 db " a este PC!", 0xA
Monta e corre. Este problema foi resolvido. O primeiro problema mais estranho. O que acontece que se pedir ao Linux para ler texto do teclado e a pessoa escreve Ana seguido de Enter (), o Linux devolve no registo eax o valor 4 indicando que foram lidos 4 caracteres: A, n, a e o Enter em si (0xA)! Agora precisamos de eliminar esse 0xA. Como ele sempre o ltimo caracter lido, a soluo fcil: em vez de dar ao Linux o tamanho 4 para escrever para o ecr, damos o tamanho 3, efectivamente eliminando o 0xA da lista de caracteres a escrever para o ecr! Como o 0xA sempre o ltimo caracter, s temos sempre de subtrair 1 ao valor de eax recebido antes de enviar a frase para o ecr. Isto pode ser feito ao fim do bloco L nome (antes de escrever em nome_len), ou ao incio do bloco Escreve o nome (depois de ler nome_len). Vamos optar pela primeira e adicionar esta linha antes da ltima do bloco L nome:
sub eax, 1
sub uma instruo nova que faz uma subtraco. Mais detalhes abaixo. Monta e corre. Todos os problemas foram resolvidos. Questo: como farias a alterao se ela fosse no bloco Escreve o nome?
palavras.asm
Monta e corre este programa. O que faz ele? Este programa usa vrias novas instrues novas para trabalhar. Elas (e outras da mesma famlia) so as seguintes:
Operaes aritmticas add sub inc dec Adio. Tal como um mov, recebe dois argumentos, soma os dois, e guarda o resultado no primeiro. Subtraco ver add. Incrementar (i.e., somar 1). Recebe apenas um argumento (que incrementado). Decrementar (subtrair 1) ver inc.
pg. 23
Operaes de string lodss Load string (carregar a partir da string). No tem argumentos. Dependendo de s, carrega um nmero da memria no endereo em esi para al, ax ou eax, e soma (subtrai se a flag D for 1) um valor adequado a esi: s b w d Exemplo: section .data dados db 1, 2, 3 section .text mov esi, dados cld lodsb al ter agora o valor 1, e esi ter o endereo do 2. stoss movss cmpss Store string, move string e compare string. Operaes alternativas de strings explicadas em aulas posteriores. Registo al ax eax esi ... 1 2 4
Operaes condicionais (comparaes e saltos) cmp jmp Comparar. Faz o mesmo que sub, mas no guarda o resultado: altera apenas as flags de acordo com o resultado. Ver sub. Jump (salto incondicional). O CPU executa a prxima instruo na localizao marcada pela etiqueta (label) que segue o jmp como argumento. Jump if ... (salto condicional). O CPU s executa o salto se a condio c se verifica. A condio verificada simplesmente olhando para as flags e o seu nome faz sentido se colocado entre os dois argumentos de um cmp (ou sub) que o preceda. c pode ser: e ne a ae b be Exemplo: mov eax, 5 cmp eax, 8 jae destino O salto no executado porque 58 falso. Equal Not Equal Above Above or Equal Bellow Bellow or Equal = > <
jc
pg. 24
loop
Loop (ciclo). Decrementa ecx. Se o resultado aps a decrementao no for zero, salta para a etiqueta (label) que segue o loop.
Agora explicar o cdigo torna-se mais fcil. A seco de dados no tem nada de novo. A seco de cdigo comea com trs blocos conhecidos (escrever frase, ler frase e escrever nova frase). O ltimo bloco tambm o nosso habitual para terminar o programa. Os blocos do meio fazem o trabalho de exibir as duas palavras pela ordem inversa. O raciocnio (explicado em detalhe na aula) simples: procura-se pelo caracter espao que separa as duas palavras introduzidas. Depois s fazer contas para apenas exibir a segunda palavra (bloco Escreve a segunda palavra, aproveitando o 0xA desta para a separar da seguinte) e apenas escrever a seguir a primeira palavra (bloco Escreve a primeira palavra). Esquematicamente, aps o bloco Procura espao terminar, vamos ter (se voc escrever Ola mundo quando corre o programa):
1 palavra O l a m u palavra esi [palavras_len] 2 palavra n d o 0xA
Exerccios
Altere o programa palavra.asm para: 1. Limpa o texto exibido pelo programa. Deseja-se que as duas palavras surjam trocadas na mesma linha, separadas por um espao, com a linha de comandos a surgir por debaixo delas. 2. Detectar quando s se escreveu uma palavra. Nesse caso exibe uma mensagem de erro no ecr e volta a pedir duas palavras. Dicas: 1. Podemos escrever caracteres adicionais para o ecr criando blocos que s escrevem 1 caracter para o ecr. Mas nota que frente de cada palavra est um caracter que no preciso e posso alterar antes de enviar a frase para o ecr... 2. Detectamos que s se escreveu uma palavra se no havia nenhum espao nos dados. Descubra em que parte do cdigo ele passa nessa situao (e apenas nessa). a que tem de adicionar novo bloco de escrever (a mensagem de erro) e saltar para o bloco de inicio.
pg. 25
Aula 06
Correco do exerccio da aula anterior, na aula. Hoje vamos resolver um novo programa: o a06-converte2.asm. Monta-o e corre-o. O que faz?
a06-converte2.asm
Este programa usa vrias novas instrues novas para trabalhar. Elas (e outras da mesma famlia) so as seguintes:
Operaes bitwise (bit a bit) and or xor e lgico, bit a bit. Tal como um mov, recebe dois argumentos, faz e lgico entre os dois, e guarda o resultado no primeiro. ou lgico, bit a bit ver and. ou exclusivo lgico, bit a bit ver and. Uma propriedade interessante desta operao lgica, que quando os dois argumentos so o mesmo, o resultado sempre zero. Ou seja: xor eax,eax na realidade simplesmente coloca 0 em eax.
Deslocamentos e rotaes shl Shift left (deslocamento esquerda). Move todos os bits do 1 argumento tantos bits para a esquerda quantos os indicados pelo 2 argumento. Pelo lado oposto (direita) entram zeros. Exemplo: mov ax, 0x1234 shl ax, 4 ax tem agora 0x2340. shr Shift right (deslocamento direita). Semelhante a shl, mas funciona para o lado oposto (direita). Ver shl. Exemplo: mov ax, 0x1234 shr ax, 4 ax tem agora 0x0123. rol Rotate left (rodar esquerda). Semelhante a shl, mas em vez de entrarem sempre zeros pelo lado oposto, entram os bits que saem (da rodar). Ver shl. Exemplo: mov ax, 0x1234
pg. 26
rol ax, 4 ax tem agora 0x2341. ror Rotate right (rodar direita). Semelhante a rol, mas funciona para o lado oposto (direita). Ver rol. Exemplo: mov ax, 0x1234 ror ax, 4 ax tem agora 0x4123. Operaes de string stoss Store String (guardar na string). Dependendo de s, escreve al, ax ou eax em memria no endereo em edi e soma (subtrai se a flag D for 1) um valor adequado a edi. Ver lodss em aula anterior. Exemplo: section .data dados db 1, 2, 3 section .text mov edi, dados mov al, 8 cld stosb O primeiro byte de dados ter agora o valor 8, e edi ter o endereo do 2. lodss movss cmpss Load string, move string e compare string. Operaes alternativas de strings explicadas em aulas posteriores. lodss j foi explicada em aula anterior.
Agora explicar o cdigo torna-se mais fcil. A seco de dados no tem nada de novo. Todos os blocos da seco de cdigo so conhecidos, excepto o 3, 4 e 5. O bloco 4 trivial: incrementa uma posio de memria. Como esta instruo no tem nenhuma pista sobre que tamanho de dados existe naquela posio de memria (e.g.: um mov [num],eax seria de 32 bits porque est a usar um registo de 32 bits) usada a directiva dword antes dos parntesis rectos para dar a indicao que estamos a trabalhar com uma double-word (32 bits).
pg. 27
De facto, a lista de directivas para este propsito :

Enderea byte word Bytes Words
dword Double-words qword Quad-words
Os blocos 3 e 5 efectuam as converses de string (em hexadecimal) para inteiro e vice-versa, respectivamente. O algoritmo usado nestas converses no especfico de Assembly, mas genrico a qualquer linguagem de programao. Tambm no a nica soluo correcta para o problema de converso. De forma a funcionar com qualquer tamanho de string que se escreva no teclado, a converso string para inteiro converte a primeira caracter a caracter, representando cada um destes um dgito hexadecimal. Assim que a converso estiver pronta, abrimos espao num registo que guarda o resultado at agora (edx) fazendo um deslocamento para a esquerda do valor que l est, e acrescentamos o novo dgito convertido. Repetimos o processo at se esgotarem caracteres. A converso de caracter para dgito razoavelmente simples, uma vez que a tabela ASCII dispe os dgitos por ordem numrica e as letras por ordem alfabtica. Se eu subtrair 0x30 a um caracter com um dgito numrico, transformei um nmero entre 0x30 e 0x39 (cdigos ASCII dos dgitos numricos) num nmero entre 0 e 9. A nica dificuldade que a seguir ao caracter '9' em ASCII no vem a maiscula 'A', pelo que tenho de fazer um teste comparativo para saber o que estou a converter (um caracter numrico ou uma letra).
pg. 28
Esquematicamente (explicado na aula):

Incio
L um caracter do buffer Ele '9'? No Soma-lhe 9 Limpa todos os bits excepto os 4 mais direita e acrescenta-o ao resultado H mais caracteres? No
Sim
Sim
Fim
A converso inversa usa o mesmo raciocnio, mas de forma inversa. Mais detalhes na aula. Repare-se que no bloco 5 temos a seguinte linha:
add eax, 'A'-0xA
Aqui, a expresso 'A'-0xA envolve duas constantes pelo que o resultado pode ser calculado pelo nasm, sem gerar novas instrues Assembly. Essa a nica razo pela qual esta expresso permitida aqui.
Exerccios
Cria um novo programa que: 1. Elimina o bloco 8, mantendo o mesmo resultado. Dica: acrescenta ao final do buffer o caracter necessrio. 2. Trabalha com nmeros em octal (3 bits por dgito octal) em vez de hexadecimal. Correco na aula seguinte.
pg. 29
Aula 07
Correco do exerccio da aula anterior, na aula. Hoje vamos resolver um novo programa: o a07-converte2a.asm. Monta-o* e corre-o. O que faz?.
a07-converte2a.asm
Este programa igual em funcionalidade ao a06-converte2.asm, mas o bloco 3 est modificado e tem um novo bloco 10. Ele usa vrias novas instrues novas para trabalhar. Elas (e outras da mesma famlia) so as seguintes:
Gesto da pilha push pop Coloca um valor de 16 ou 32-bits (que segue a instruo) na pilha. Retira um valor de 16 ou 32-bits da pilha para o registo/memria que segue a instruo.
Chamadas a sub-rotinas / funes call ret Chama (calls) uma sub-rotina/funo. Guarda na pilha o endereo de retorno. Retorna ao endereo chamador (que dever estar na pilha), terminando a sub-rotina/funo.
Endereamento base+deslocamento [r] [r1+r2] [r*s] [r1+r2*s] Quando usado em qualquer instruo, l ou escreve na memria no endereo respectivo. r, r1 e r2 so registos e s um factor de escala (scaling factor) que pode ser 2, 4 ou 8. A qualquer uma destas formas de endereamento pode ainda ser adicionado ou subtrado um nmero inteiro (e.g.: [r+i]). Esta a mxima complexidade que se pode ter nas expresses que se podem usar ao enderear memria.
Se o teu Linux te obriga a montar os programas com -f elf64 ento no vais conseguir montar este. Isto porque em modo de 64 bits no podes manipular a pilha com 16 ou 32 bits.
pg. 30
Agora explicar o cdigo torna-se mais fcil. Aquilo que se fez foi colocar o antigo bloco 3 numa sub-rotina/funo independente. Chama-se essa sub-rotina com um call, e esta deve terminar com um ret, o que a faz retornar ao ponto de onde foi chamada. Claro que o ret s consegue fazer a sua funo se tiver anotado algures o ponto para onde deve voltar. Isso de facto foi o que a instruo call fez, guardando o ponto de retorno em memria, numa estrutura automtica chamada de pilha.
Pilha
A pilha do CPU no mais do que um buffer (espao de trabalho) em memria que usado numa sequncia muito previsvel. Ela guarda nmeros de 16 ou 32 bits (nunca 8 bits) que podem ser valores de registos, endereos, ou outros. Estes valores so guardados e retirados pela mesma ordem que se guarda e retira um livro de uma pilha de livros:
O ltimo livro a ser colocado na pilha (o do topo), ser o primeiro livro a ser retirado (last in, first out, ou LIFO). Por razes histricas, as pilhas nos CPUs que estamos a estudar crescem para baixo (para endereos menores), mas o conceito o mesmo, s que invertido. Temos instrues especiais para colocar e remover explicitamente elementos da pilha (push e pop descritas acima) e instrues que a usam implicitamente (como call e ret). Existe ento um registo especial (esp Stack Pointer) que mantm o endereo do topo da pilha. Todas as instrues que usam a pilha, escrevem em memria nesse endereo (e usando o segmento de pilha ss), e actualizam esp automaticamente.
Exemplo
Aps executar estas instrues:
mov mov mov push push esp, 20 eax, 1 ebx, 2 eax ebx
pg. 31
A pilha ter o seguinte aspecto:

20 19 18 17 16 15 14 13 12
... 0 0 0 1 0 0 0 2 esp = 12
11
Exemplo explicado em detalhe na aula. Questo: porque usam ento as instrues call e ret uma estrutura que tem este comportamento LIFO? Dica: pensa como se deveria comportar o CPU se uma sub-rotina A chama outra sub-rotina B que por sua vez chama outra sub-rotina C.
Passar argumentos a sub-rotinas/funes usando a pilha

Dada a flexibilidade da pilha, comum ser usada para se passar argumentos a sub-rotinas/funes. Isto to comum que temos um registo especial (ebp Base Pointer) que sempre que usado no endereamento de memria, assume o segmento da pilha. Ele foi desenhado para auxiliar ao acesso a argumentos passados desta forma. No bloco 3 passamos os argumentos que precisamos fazendo um push para cada. Depois da funo terminar asseguramo-nos que retirmos esses argumentos da pilha com
add esp, 8
Dentro da sub-rotina conv2num no bloco 10, vamos ler esses argumentos. Para tal guardamos temporariamente o ebp na prpria pilha (para a sub-rotina no o estragar), e copiamos o endereo do topo da pilha (esp) para ebp. A partir deste momento podemos aceder aos argumentos que esto na pilha a partir de ebp, e mesmo assim podemos fazer mais push/pop e call/ret (que usam a pilha) sem nos confundirmos com os novos valores de esp nesses instantes. Aceder aos argumentos agora uma questo de enderear a memria com base em ebp. Cdigo explicado na aula.
Exerccio
Altera o bloco 5 deste programa para tambm ele ser uma sub-rotina independente, recebendo os mesmos dois argumentos que o antigo bloco 10 (se ambos forem necessrios). Correco na aula seguinte.
2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com pg. 32
Aula 08
Hoje vamos resolver um novo programa: o a08-le2.asm. Monta-o e corre-o. O que faz?
Leitura de ficheiros: a08-le2.asm

Este programa l um ficheiro de texto e exibe-o no ecr. Vamos hoje ver como trabalhamos com ficheiros com Assembly em Unix/Linux. O raciocnio central deste programa no ler o ficheiro todo de uma vez e copilo para o ecr: isso limitaria o tamanho mximo do ficheiro que podia ser copiado aqueles que coubessem em memria. Em vez disso, o raciocino ler uma linha de cada vez e copi-la para o ecr, repetindo o processo enquanto houver linhas:
Incio
L uma linha do ficheiro (bloco 2) A linha est vazia? No Exibe essa linha no ecr (bloco 3)
Sim
Fim
De resto a estrutura deste programa muito semelhante aos anteriores, no existindo instrues novas. Existem s 3 novos conceitos: 1. Abrir o ficheiro (bloco 1) 2. Quando peo ao Linux para ler uma linha do ficheiro, ele diz-me que a quantidade de bytes lidos zero se ocorreu um erro ou j no h mais nada para ler (e.g.: cheguei ao fim do ficheiro) (bloco 2) 3. Fechar o ficheiro (bloco 4)
Abrir/fechar ficheiros
Qualquer programa pode precisar de trabalhar com mais do que um ficheiro ao mesmo tempo. Posso precisar de copiar o ficheiro A para o ficheiro B, posso
precisar de cruzar o ficheiro de facturas F, com o ficheiro de pagamentos P para gerar o ficheiro de avisos de pagamento A, etc.. Seria muito lento ter de procurar e localizar o ficheiro em disco (seguindo a estrutura de directrios indicada) e validar as minhas permisses de acesso a cada directrio e ao ficheiro correspondente em cada pequena leitura/escrita ao mesmo (e.g.: em cada leitura de uma linha do nosso programa). Nasce assim o conceito de abrir um ficheiro: Trabalhar com ficheiros: Abrir Ler/Escrever Fechar Abrir um ficheiro serve para o localizar, validar permisses e preparar estruturas do sistema operativo para que as operaes de leitura e/ou escrita que se sigam sejam rpidas. O conceito de fechar o ficheiro serve para dizer ao sistema operativo para libertar essas estruturas de forma a poupar memria para mais ficheiros.
Handle (maaneta ou nmero de ficheiro)

Como dizemos ns ao sistema operativo, de qual dos nossos ficheiros abertos queremos ler/escrever? Com um handle (maaneta). Este um nmero que o sistema operativo nos d quando abrimos um ficheiro e lhe temos de devolver para nos referirmos ao mesmo mais tarde. Todas as operaes sobre um ficheiro (leitura, escrita e fecho, entre outras) excepo de abrir, recebem um handle para identificar o ficheiro em que operam.
ASCIIZ
Repara como indicado o nome do ficheiro ao sistema operativo. Para ler/escrever dados precisamos de poder usar qualquer valor de um byte. por isso que para indicar dados precisamos de dois registos: um para o endereo inicial deles, e outro para o tamanho. Mas no podemos usar qualquer caracter no nome de um ficheiro (* e ? so invlidos, entre muitos outros). Ento usa-se uma sequncia de caracteres terminada no ASCII NUL (byte com o valor zero) abreviada ASCIIZ j que o caracter nulo (NUL) no vlido em nomes de ficheiros ou directrios. Assim apenas precisamos de um registo para indicar o nome do ficheiro ao sistema operativo. Restantes detalhes explicados na aula.
pg. 34
Vamos a seguir resolver um outro programa: o a08-escr.asm. Monta-o e corre-o. O que faz?
Escrita para ficheiros: a08-escr.asm

Este programa cria um ficheiro de texto. Todos os blocos so conhecidos, a este ponto. Note-se que como aqui podemos criar um ficheiro novo, necessrio indicar no registo edx quais devem ser as permisses Unix iniciais desse ficheiro, quando o vamos abrir (note-se como usamos a mesma funo para abrir um ficheiro existente ou para criar um novo ficheiro que fica aberto). No bloco 1 estamos a indicar as permisses 666 em octal (i.e., leitura e escrita para todos), que sero depois filtradas pelo umask antes do ficheiro ser criado. Mais detalhes na aula.
Exerccio
Crie um programa que l dados do teclado e os copia para um ficheiro fixo, semelhante ao a08-le2.asm. O programa deve terminar se eu escrever uma linha vazia. Correco na aula seguinte.
pg. 35
Aula 09
Correco do exerccio da aula anterior: vamos comear como base com o programa a08-le2.asm. Ele j tem um ciclo que l uma linha e a escreve (blocos 2 e 3). Mas o bloco 2 deve ler do teclado em vez do ficheiro, por isso altero
mov ebx, [fich_handle] ebx, 0
para
mov
Seguindo o mesmo raciocnio, tambm quero que o bloco 3 escreva para o ficheiro em vez do ecr e ento altero
mov ebx, 1 ebx, [fich_handle]
para
mov
Claro que isto s funciona se tiver aberto o ficheiro para lhe escrever (ou seja, com um valor adequado na varivel fich_abertura). Ento na seco de dados, altero o valor dessa varivel para 0101q (o mesmo que est no programa a08-escr.asm). Tambm tenho de adicionar ao topo do bloco 1 a mesma instruo inicial que est ao topo do mesmo bloco nesse programa:
mov edx, 0666q
Estamos quase prontos. Se o testares o programa funciona, mas no pra quando escreves uma linha vazia. Porqu? que as linhas lidas do teclado tm sempre o caracter 0xA (Enter) ao final (ver aula anterior na resoluo do exerccio do nome.asm). Ento uma linha vazia tem na realidade... 1 caracter! Assim alteramos no bloco 2, a instruo cmp para passar a ser:
cmp eax, 1
Testa: deve estar a funcionar.
pg. 36
Hoje vamos resolver um novo programa: o a09-calculadora.asm. Monta-o e corre-o. O que faz?
Operaes aritmticas: a09-calculadora.asm

Este programa simula uma calculadora hexadecimal muito simples. Este programa j no vai ser explicado bloco a bloco ser que o consegues entender sozinho? Algumas instrues novas:
Operaes aritmticas* mul Multiplica eax pelo nico argumento de 32 bits que a instruo recebe. O resultado sempre um nmero de 64 bits cujos 32 bits mais significativos (i.e., da esquerda) ficam em edx e os 32 bits menos significativos (i.e., da direita) ficam em eax. Isto costuma representar-se como edx:eax. Exemplo: mov mov mul eax, 0xFF123456 ebx, 0x100 ebx
edx:eax tem agora 0x000000FF:0x12345600. div Divide edx:eax (ver mul) pelo nico argumento de 32 bits que a instruo recebe. O resultado fica em eax e o resto da diviso em edx. Exemplo: mov mov mov div edx, 0x000000FF eax, 0x123456AB ebx, 0x100 ebx
eax tem agora 0xFF123456 e edx tem 0x000000AB. Salto condicional jecxz Salta se ecx zero (jump if ecx is zero). Esta instruo complementa a instruo loop para lidar com ciclos onde ecx pode ser logo partida 0.
Questo: porque ser que a instruo div assume o seu argumento da esquerda como um nmero de 64 bits (edx:eax)? Dica: pensa numa multiplicao de um nmero por uma fraco.
mul e div tambm podem ser usadas com argumentos de 8 e 16 bits. Consulta o manual de referncia [IA32-MAN] para mais detalhes (ver Bibliografia).
pg. 37
Deteco de excesso (overflow)

A deteco de quando o resultado no cabe em 32 bits (situao habitualmente chamada de excesso (overflow)), pode ser feito da seguinte forma: Para a adio e subtraco, a flag carry tem o valor do 33 bit de resultado (i.e., o transporte final). Se este bit for 1, o resultado no cabia em 32 bits! No caso da multiplicao detectar overflow trivial: se o resultado fica em edx:eax... quando que isto no cabe em 32 bits?* No caso da diviso, se os dois argumentos originais eram de 32 bits, o resultado sempre ao maior deles, excepto numa situao que temos de testar antes de fazer a diviso. Que situao essa?
Detecto a flag carry a 1 com o salto jc.
Mltipla preciso
As adies e subtraces j esto preparadas para lidar com nmeros inteiros arbitrariamente grandes. Imagina que quero somar dois nmeros de 64 bits (quad-words). Posso dividir cada um em dois nmeros de 32 bits que posso somar com add:
0000111100001110 0000111100001110 + = 1111000011110000 1111000011110000 1111111111111110 1111111111111111 1000111100001110 0000111100001110 1111000011110000 1111000011110000 0111111111111110 1111111111111110
Carry = 1
Comeo a fazer a soma da direita para a esquerda, como sempre. Quando somo os primeiros nmeros de 32 bits, a flag carry tem o 33 bit, ou seja o transporte aps a ltima soma do 32 bit de ambos os argumentos. No exemplo acima, a flag carry teria 1 pois 1b+1b=10b. Ento para continuar a somar os 32 bits da esquerda, teria apenas de fazer a soma normalmente e somar tambm o carry!
Quando aps a multiplicao, edx 0! O processador ajuda-nos e coloca a flag carry a 1 nesse caso. Quando o segundo argumento da diviso zero! Matematicamente o resultado seria (ou indeterminao no caso 0/0, mas isso significa que no sabemos se o resultado nesse caso + ou -, pelo que continua a ser uma situao de overflow).
pg. 38
Isto consegue-se com uma instruo especial: adc (add with carry). Para a subtraco temos o raciocnio inverso e a instruo sbb (subtract with borrow):
Operaes de mltipla preciso adc Somar com o transporte (add with carry). Idntica a add, mas tambm soma o valor da flag carry ao resultado. Subtrair com o transporte (subtract with borrow). Idntica a
sbb
sub, mas tambm subtrai o valor da flag carry do resultado. Exemplo:

section .data num1: ; dq 0x0F0E0F0E8F0E0F0E num1_l dd 0x8F0E0F0E num1_h dd 0x0F0E0F0E num2: num2_l num2_h ; dq 0xF0F0F0F0F0F0F0F0 dd 0xF0F0F0F0 dd 0xF0F0F0F0
resultado: ;dq 0 resultado_l dd 0 resultado_h dd 0 section .text mov add mov mov adc mov eax, eax, [resultado_l], eax, eax, [resultado_h], [num1_l] [num2_l] eax [num1_h] [num2_h] eax
Depois deste cdigo ter corrido, estar em [resultado] a soma de 64 bits de [num1] com [num2]. As instrues mov no alteram flags, por isso que posso ter instrues mov entre as duas adies. Lembra-te que os nmeros so guardados com os seus bytes do menos significativo para o mais significativo (little-endian ver aula anterior), pelo que os 32 bits da direita esto em [num1_l]=[num1], etc., e os 32 bits da esquerda esto em [num1_h]=[num1+4], etc.. Se isto te confunde, v tambm o exemplo na pgina seguinte. As operaes de aritmtica binria (and, or, xor e not), como funcionam com pares de bits e no propagam o resultado para outros bits, s tm de ser repetidas para todos os nmeros de 32 bits que compem o nosso nmero de mltipla preciso. Mas o mesmo no se pode dizer de deslocamentos. Quando desloco um nmero de mltipla preciso 1 bit para a esquerda (por exemplo), posso comear por fazer shl (shift left) nos 32 bits mais da direita, mas no posso repetir essa operao, pois quero que o bit que saiu pela esquerda destes primeiros 32 bits, entre pela direita dos 32 bits seguintes.
Por exemplo:
0000111100001110 0000111100001110 << shift left = 000111100001110 00001111000011101 000111100001110 00001111000011100 1000111100001110 0000111100001110
Carry = 1
Nos 32 bits da esquerda, entrou um bit com o valor 1 pela direita, pelo que obviamente no posso repetir o shl. Mas tenho sorte: quer o shl quer todas as outras operaes de deslocamentos e rotaes colocam na flag carry o ltimo bit que foi deslocado para fora. Ento nos 32 bits seguintes (da esquerda) s precisamos de usar uma instruo que faa entrar a flag carry, em vez de zero. Isto consegue-se com uma instruo especial, rcl:
Operaes de mltipla preciso rcl Rodar esquerda atravs da flag carry (rotate through carry, left). Idntica a rol, mas onde o argumento a ser rodado tem mais um bit (a flag carry). Por exemplo, mov stc rcl ax, 0 ; set carry flag ax, 1
O bit que entra pela direita em ax vem da flag carry, e o bit mais esquerda de ax e que vai sair, vai para esta mesma flag tambm. Assim aps estas instrues, ax tem 1 e carry tem zero. rcr Rodar direita atravs da flag carry (rotate through carry, right). Idntica a rcl, mas funciona no sentido oposto. Ver rcl, acima.
Exemplo:
section .data num1 dd 0x8F0E0F0E, 0x0F0E0F0E ; dq 0x0F0E0F0E8F0E0F0E section .text shl rcl dword[num1], 1 dword[num1+4], 1
Depois deste cdigo ter corrido, [num1] estar deslocado esquerda por 1 bit. No te esqueas que rcl e rcr s funcionam bem para este propsito se estiveres a deslocar um nico bit. Neste exemplo usmos uma nica varivel num1 com duas double-words. Novamente, a sua parte da direita (low) [num1] e a sua parte da esquerda (high) [num1+4].
Apesar de no existirem instrues de multiplicao e diviso de mltipla preciso, podemos usar as adies e deslocamentos de mltipla preciso em algoritmos de multiplicao e diviso.
Exerccios
Estes exerccios so muito semelhantes ao que te poder ser pedido no projecto final da cadeira, pelo que no ser feita correco: 1. Altera a calculadora para fazer deteco de overflow. 2. Altera a calculadora para lidar com nmeros de 64 bits. Em caso de dvida consulta o professor.
pg. 41
Aula 10
Hoje vamos falar de aritmtica inteira com sinal, em complemento para dois. Esta aula pode ser adiada pois precisas de conceitos importantes sobre representao de nmeros inteiros com sinal das aulas tericas. Precisas de saber o que o complemento para dois e a sua representao normalizada em binrio.
Operaes em inteiros com sinal

Todas as operaes aritmticas mencionadas at aqui trabalham sobre nmeros inteiros sem sinal (i.e., positivos e o zero). H vrias formas de representar nmeros inteiros com sinal. A forma preferida pelas instrues deste CPU em nmeros inteiros o complemento para dois. A razo para isso simples: somamos (e subtramos) nmeros em complemento para dois exactamente da mesma forma que nmero sem sinal! O resultado sempre correcto desde que seja interpretado como tambm ele um nmero com sinal. Ento as instrues para soma e subtraco de nmeros com sinal tambm so as mesmas: add e sub (assim como tambm so as mesmas inc e dec). Mais detalhes nas aulas (tericas). Mas o mesmo no se pode dizer da multiplicao e diviso. Para essas operaes temos instrues novas:
Operaes aritmticas, com sinal imul Multiplicao. Idntica em tudo a mul, mas assume que todos os argumentos (e o resultado) so nmeros com sinal em complemento para dois. Diviso. Idntica em tudo a div, mas assume que todos os argumentos (e o resultado) so nmeros com sinal em complemento para dois. Negao aritmtica. Troca o sinal do nmero que est no registo ou memria do argumento que recebe, assumindo-o como complemento para 2. Exemplo: mov ax, 0xFFFF neg ax
idiv
neg
ax tem agora 0x0001.
pg. 42
A instruo imul em particular pode ser usada com dois ou trs argumentos em situaes particulares que no vamos estudar. Consulta o manual de referncia [IA32-MAN] para mais detalhes (ver Bibliografia).
Deteco de excesso (overflow)

As somas e subtraces em nmeros com sinal podem gerar carry sem haver overflow. Por exemplo, se eu tiver o nmero 2 e lhe subtrair 5, o resultado -3 mas o processo de subtraco gera carry. O excesso em nmeros com sinal no detectado com carry, mas no transporte do penltimo bit para o ltimo, combinado com os sinais (ltimo bit) dos argumentos. Felizmente temos uma flag que j calcula isto e nos diz se houve excesso nestas operaes ou no. Chama-se flag overflow e tem a abreviatura O (letra O, no o nmero zero). A instruo que nos permite detectar o excesso com adies, subtraces e multiplicaes assim a jo (jump if overflow), correspondente jc das mesmas operaes sem sinal. A forma de detectar excesso na diviso idntica aritmtica sem sinal (porqu?). Existe apenas uma excepo, uma nica outra diviso que em nmeros com sinal pode resultar em excesso. Consegues descobrir qual ?*
Mltipla preciso
Como as operaes de adio e subtraco em nmeros com sinal so as mesmas das respectivas operaes em nmeros sem sinal, o mesmo se aplica s instrues usadas para mltipla preciso: adc e sbb.
Exerccio
Esta aula curta para te dar mais oportunidade de trabalhar nos exerccios da aula anterior. Quando os terminares, adiciona calculadora da aula anterior a capacidade de trabalhar com nmeros com sinal. Lembra-te de corrigir a deteco de overflow. No te esqueas que quando corres a calculadora, introduzes um nmero negativo em complemento para 2. Como introduzes ento -1?
A diviso do nmero mais prximo de por -1. Repara: qual a gama de nmeros disponvel em complemento para 2, em 32 bits?
A calculadora usa nmeros de 32 bits. Ento o complemento para dois de 1 (para o transformar em -1) : 0xFFFFFFFF.
pg. 43
Aula 11
Hoje vamos falar de aritmtica no-inteira (i.e., fraccionria, ou de vrgula flutuante). Esta aula pode ser adiada pois precisas de conceitos importantes sobre representao de nmeros de vrgula flutuante das aulas tericas. Precisas de saber o que o significando (tambm conhecido como coeficiente ou mantissa) e o expoente e a sua representao normalizada em binrio (formato IEEE 754).
Operaes em nmeros fraccionrios

Todas as operaes aritmticas mencionadas at aqui trabalham sobre nmeros inteiros com ou sem sinal. Os circuitos do CPU que trabalham com nmeros de vrgula flutuante eram opcionais e comprados parte at ao 80386. Era um co-processador chamado 80387. Tambm por esta razo ainda se d de forma muito notria um nome especial a estes circuitos: a FPU (floating-point unit ou unidade de vrgula flutuante). As instrues da FPU so novas e trabalham com oito novos registos que guardam um nmero de vrgula flutuante de 80 bits e funcionam como uma pilha. Por razes de eficincia esta pilha circular, mas acedida relativamente ao seu topo actual. Por exemplo a notao ST(0) ou ST0 significa stack top + 0. Todas as instrues da FPU que fazem operaes aritmticas lem os seus argumentos da pilha. Ento, para fazer um clculo, tenho de colocar os valores do mesmo na pilha (com instrues especficas), e s depois executo a instruo aritmtica em si. Esta instruo retira da pilha os seus argumentos e substitui-os pelo resultado da operao em si. Por exemplo, para fazer a conta ( 5,6 2,4 ) + ( 3,8 10,3 ) tenho de fazer os seguintes passos: 1. Colocar 5,6 na pilha 2. Colocar 2,4 na pilha 3. Executar o produto (na pilha saem os dois valores e fica o resultado) 4. Colocar 3,8 na pilha 5. Colocar 10,3 na pilha 6. Executar o produto (na pilha saem os dois valores e fica o resultado) (no esquecer que o resultado do produto anterior ainda l est)
pg. 44
7. Executar a soma Para simplificar estes passos, as instrues permitem geralmente que o ltimo argumento faa parte da instruo em si. Assim, a sequncia final de passos ser: 1. Colocar 5,6 na pilha 2. Multiplicar por 2,4 (na pilha sai o 5,6 e fica o resultado) 3. Colocar 3,8 na pilha 4. Multiplicar por 10,3 (na pilha sai o 3,8 e fica o resultado) (no esquecer que o resultado do produto anterior ainda l est) 5. Somar o topo da pilha pelo topo da pilha+1 Nota que todos os nmeros de vrgula flutuante usados devem estar em memria e eu devo referir-me a eles pelo seu endereo. O cdigo pode ento ser o seguinte:
section .data valor1 valor2 valor3 valor4 dq 5.6 dq 2.4 dq 3.8 dq 10.3
section .text fld fmul fld fmul fadd qword[valor1] qword[valor2] qword[valor3] qword[valor4] st1 ; ; ; ; ; Passo Passo Passo Passo Passo 1 2 3 4 5
Todas as instrues de vrgula flutuante comeam com a letra f que a abreviatura de floating-point. As instrues novas so as seguintes:
Operaes de vrgula flutuante fld r Carregar constante de vrgula flutuante (floating-point load). Faz o equivalente a um push, mas para a pilha de vrgula flutuante, de uma constante guardada numa quad-word em r. Soma o topo da pilha (ST0) com r. Substitui o topo da pilha pelo resultado. Subtrai do topo da pilha (ST0), r. Substitui o topo da pilha pelo resultado. Multiplica o topo da pilha (ST0) por r. Substitui o topo da pilha pelo resultado.
fadd r fsub r fmul r
pg. 45
fdiv r fst r
Divide o topo da pilha (ST0) por r. Substitui o topo da pilha pelo resultado. Guardar constante de vrgula flutuante (floating-point store). Faz o equivalente a um pop, mas da pilha de vrgula flutuante, para uma varivel r.
Em qualquer uma destas instrues, r pode ser uma referncia memria (e.g.: qword[numero]) ou pilha de vrgula flutuante (e.g.: ST0). Existem inmeras mais instrues disponveis, para fazer todo o tipo de operaes que encontrarias numa calculadora cientfica (senos, logaritmos, razes, arredondamentos, etc.). Consulta o manual de referncia [IA32-MAN] para mais detalhes (ver Bibliografia).
Exerccio
Pega na calculadora de 64 bits que construste. Assume que os nmeros que a pessoa introduz so constantes de vrgula flutuante de 64 bits, no seu formato IEEE 754. Assume tambm que o nmero hexadecimal que a calculadora vai exibir, o resultado da operao no mesmo formato IEEE 754. Altera ento as quatro operaes da calculadora para fazerem esses clculos em vrgula flutuante.
pg. 46
Exerccios
As aulas seguintes so de reviso e aprofundamento desta matria e no esto detalhadas neste guio. Elas servem para te acompanhar na execuo do projecto final da cadeira e para cimentar os conhecimentos aqui adquiridos. No deixes de ir s aulas.
pg. 49
VirtualBox Linux
O teu professor das aulas prticas pode fornecer-te uma mquina virtual Linux (Xubuntu para ser mais especfico) preparada para correr no Sun VirtualBox. Isto serve apenas para te ajudar a mais rapidamente comeares a trabalhar e no vai servir para outras cadeiras nem um exemplo de um Linux moderno ou popular.
Instalar o software base

Esta mquina no est disponvel pela Internet pois muito grande (quase 850Mb), pelo que ters de levar o teu computador porttil para a escola para a receberes. Os ficheiros que o professor te ir dar so 3: Sun VirtualBox 3.0.10 7-Zip 4.57 Imagem do disco Xubuntu 8.10 comprimida com 7-Zip*
Os dois primeiros ficheiros so executveis, mas foram gravados com a extenso e_e para limitar propagao de vrus antes de te chegarem s mos. Se mesmo assim estiveres preocupado com vrus, podes descarregar esses dois programas: Sun VirtualBox em: http://www.virtualbox.org/ 7-Zip em: http://www.7-zip.org/
Ambos so gratuitos. Se confiares nesses ficheiros, tens de trocar a extenso (terminao do nome) de ambos para exe. A seguir faz duplo clique em cada um e segue os passos exibidos no ecr para os instalar.
Instalar a imagem do Xubuntu

O teu professor escolheu o Xubuntu para ser o sistema Linux que te oferece j configurado por este ser muito pequeno e fcil de usar (2,5Gb aps descompresso da imagem).
*
Sim, verdade que se fosse comprimida em Zip normal no seria necessrio instalar qualquer programa adicional para a descomprimir, mas em Zip normal a imagem no cabe numa memria USB de 1Gb...
pg. 50
O Xubuntu no mais do que um popular sistema Linux (Ubuntu) com o ambiente de trabalho Xfce (rpido e pequeno). Podes saber mais sobre ele em: http://www.xubuntu.org/ Para extrair os ficheiros desta imagem, deves abrir a pasta principal do VirtualBox. Para isso, abre uma pasta qualquer no teu computador, e escreve na barra de endereos: %USERPROFILE%\.VirtualBox (maisculas e minsculas no so importantes, mas coloca todos os %, \ e . sem espaos tal como exibidos acima). Carrega em Enter. Deves ficar com algo semelhante a isto:
normal que a barra de endereos mude para outra coisa no teu computador. Se na pasta que abriste no existe uma pasta com o nome HardDisks (tal como no exemplo acima), tens de a criar. Entra nessa pasta (HardDisks) e extrai o ficheiro .7z, arrastando-o com o boto da direita do rato para l, largando-o e escolhendo do menu que surge: 7Zip Extract Here. Se ficares com estes ficheiros na pasta, tudo correu bem!
Podes apagar o ficheiro .7z.
pg. 51
Criar a mquina virtual do Xubuntu

Arranca o Sun VirtualBox a partir do menu de arranque (Start). Clica em Novo para criar uma nova mquina virtual.
Escolhe os seguintes valores e respostas para as caixas de dilogo que se seguem (Sistema operativo Linux, verso Ubuntu e 512Mb de RAM).
Se o teu computador tiver 1Gb de RAM ou menos, mantm o uso de RAM nos 384Mb recomendados pela Sun VirtualBox, seno o teu computador torna-se muito lento.
pg. 52
Ao escolher o disco rgido virtual, deves localizar os ficheiros que extraste anteriormente. Escolhe Usar um disco rgido existente e clica no smbolo de pasta que est direita.
No gestor de discos virtuais (acima), clica em Adicionar, escolhe o ficheiro Ubuntu.vmdk (abaixo) e acaba a criao da mquina virtual.
Se no vires estes ficheiros, instalaste incorrectamente a imagem do Xubuntu. Volta seco anterior e tenta repetir os passos.
pg. 53
A mquina virtual est agora instalada e pronta a arrancar (boto Iniciar)!
Usar o Xubuntu
Arranca a mquina virtual. Ela tem os programas que mais vais usar logo no painel superior. Experimenta arrancar o Firefox, vai ao site do professor e clica no guio e exerccios da aula.
Quando o Firefox te pedir, escolhe gravar o ficheiro. Ele ir gravar tudo o que recebe da Internet no ambiente de trabalho (desktop) para o encontrares mais facilmente.
pg. 54
Para poderes montar os programas Assembly das aulas, tens sempre de os extrair dos arquivos. Para isso abre o arquivo que descarregaste com um duplo-clique e arrasta o nome do ficheiro que pretendes de volta para o desktop.
Agora, com os ficheiros extrados, j podes mont-los. Abre a consola/terminal e corre os comandos referidos na Aula 01.
pg. 55
E tudo! Segue este Guio a partir da Aula 01 e aparece nas aulas para tirares dvidas. Se estragares algo, volta a instalar a imagem do Xubuntu. Para sares do Linux, escolhe Quit no menu Applications do painel superior e depois escolhe Shutdown. Podes tambm no menu Mquina da Sun VirtualBox escolher Fechar e depois Gravar o estado.
pg. 56
Bibliografia
[IA32-MAN] Intel 64 and IA-32 Architectures Software Developer's Manuals, Intel. No site da Intel em:
http://developer.intel.com/products/processor/manuals/
[80386-PG] Lance Leventhal, 80386 Programming Guide, Bantam Computer Books. Na Amazon do Reino Unido, em:
http://www.amazon.co.uk/80386-Programming-Guide-PC-Library/dp/055334529X/
(mais em breve)
pg. 57

Ac Guiao

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ac Guiao

Uploaded by

Copyright:

Available Formats

Arquitectura de Computadores

REQUISITOS ................................................................................................................................................... 6 PARA PARA

AULA 01 .......................................................................................................................................................... 7 AMBIENTE EXPLICAR

HARDWARE: CPU, RAM

DB, DW, DD, DQ ........................................................................................................................................ 12 EQU E

DADOS DO TECLADO .............................................................................................................................. 14 MEMRIA ............................................................................................................................ 14

OU NMERO DE FICHEIRO) .................................................................................... 14

XUBUNTU .............................................................................................................. 14 XUBUNTU ................................................................................................... 14

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Explicar o primeiro exemplo

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Hardware: CPU, RAM e endereamento

Processador central (CPU)

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Etiquetas (labels) e variveis

db, dw, dd, dq

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Esta directiva cria em memria os seguintes bytes:

Trivial. Mas, e esta directiva?

Repetindo o processo para as restantes words do exemplo, ficamos com:

Seguindo o mesmo raciocnio, com esta directiva:

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

resb, resw, resd, resq

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Ler dados do teclado

escreve eax na varivel nome_len.

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

ser ento a forma de ler uma varivel.

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

As letras mais claras referem-se s alteraes.

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

De facto, a lista de directivas para este propsito :

dword Double-words qword Quad-words

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Esquematicamente (explicado na aula):

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

A pilha ter o seguinte aspecto:

Passar argumentos a sub-rotinas/funes usando a pilha

Leitura de ficheiros: a08-le2.asm

Handle (maaneta ou nmero de ficheiro)

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Escrita para ficheiros: a08-escr.asm

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Testa: deve estar a funcionar.

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Operaes aritmticas: a09-calculadora.asm

2009 Pedro Freire // Arquitectura de Computadores www.pedrofreire.com

Deteco de excesso (overflow)