Execução de Programas
Partes de um programa:
‣ Dados
‣ Código (instruções)
Um programa necessita estar carregado em memória RAM para ser executado,
sendo assim, cada variável e cada instrução do programa está localizado em
algum endereço na memória.
O conteúdo da memória onde estão localizados os dados, está mudando
constantemente e o local onde estão armazenados os código, permanece
sempre com o mesmo conteúdo.
A execução do programa é feita instrução por instrução até que a instrução de
finalização de programa seja executada.
Utilizando o DEBUG
-r , mostra o conteúdo dos registradores ou altera o conteúdo de um
registrador.
-r
AX=0000 BX=0000
DS=0B52 ES=0B52
0B52:0100 7312
-r ax
AX 0000
:8
-r bx
BX 0000
:2
-r
AX=0008 BX=0002
DS=0B52 ES=0B52
0B52:0100 7312
CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
SS=0B52 CS=0B52 IP=0100 NV UP EI PL NZ NA PO NC
JNB 0114
CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
SS=0B52 CS=0B52 IP=0100 NV UP EI PL NZ NA PO NC
JNB 0114
Utilizando o DEBUG
e - editar um endereço de memória
-e 100
0B52:0100 73.01
-e 101
0B52:0101 12.d8
-r
AX=0008 BX=0002 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0100 NV UP EI PL NZ NA PO NC
0B52:0100 01D8
ADD AX,BX
Utilizando o DEBUG
t – Execução passo a passo da instrução apontada por IP.
-r
AX=0008 BX=0002 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0100 NV UP EI PL NZ NA PO NC
0B52:0100 01D8
ADD AX,BX
-t
AX=000A BX=0002 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0102 NV UP EI PL NZ NA PE NC
0B52:0102 2E
CS:
0B52:0103 A1AC95
MOV AX,[95AC]
CS:95AC=0000
Utilizando o Debug
Operação de Soma e Subtração com assembly.
ADD AX, BX
SUB AX, BX
O resultado da Soma do conteúdo de dois registradores é armazenado no
primeiro registrador, no exemplo acima ficaria AX = AX + BX
O resultado da subtração do conteúdo de dois registradores é armazenado no
primeiro registrador, no exemplo acima ficaria AX = AX - BX
Utilizando o DEBUG
A operação de Multiplicação utiliza sempre o registrador AX.
Mul BX
A instrução acima considera que o registrador bx será multiplicado por AX
A multiplicação de dois números de 16 bits, poderá gerar um número de 32 bits,
desta forma, o resultado da multiplicação é guardado em dois registradores no
formato DX:AX, onde parte mais significativa do resultado é armazenado em
DX e parte menos significativa é armazenado em AX
Exemplo:
AX = 7c4b
BX = 0100
AX * BX = 7C4B00
RESULTADO FINAL – DX=007C e AX=4B00
Utilizando o DEBUG
-r ax
AX 0000
:7c4b
-r bx
BX 0000
:0100
-r
AX=7C4B BX=0100 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0100 NV UP EI PL NZ NA PO NC
0B52:0100 BB0200
MOV BX,0002
-e 100
0B52:0100 BB.f7
-e 101
0B52:0101 02.e3
-r
AX=7C4B BX=0100 CX=0000 DX=0000 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0100 NV UP EI PL NZ NA PO NC
0B52:0100 F7E3
MUL BX
-t
AX=4B00 BX=0100 CX=0000 DX=007C SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0102 OV UP EI PL NZ NA PE CY
0B52:0102 00B80300 ADD [BX+SI+0003],BH
DS:0103=B8
Utilizando o DEBUG
A operação de divisão utiliza um número de 32 bits, desta forma, considera que
este número está armazenado no par de registrador DX:AX, onde o DX
armazena a parte mais significativa e AX a parte menos significativa
Div bx
A instrução acima assume que o número contido no par DX:AX será dividido
pelo conteúdo do registrado BX.
A parte inteira da divisão será armazenado no registrador AX e o resto da divisão
será armazenada no registrador DX.
Utilizando o DEBUG
-r dx
DX 0000
:007c
-r ax
AX 0000
:4b12
-r bx
BX 0000
:0100
-r
AX=4B12 BX=0100 CX=0000 DX=007C SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0100 NV UP EI PL NZ NA PO NC
0B52:0100 F7E3
MUL BX
-e 100
0B52:0100 F7.
-e 101
0B52:0101 E3.f3
-t
AX=7C4B BX=0100 CX=0000 DX=0012 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0102 NV UP EI PL NZ NA PO NC
0B52:0102 00B80300 ADD [BX+SI+0003],BH
DS:0103=B8
UTILIZANDO DEBUG
a – (assembly) escrever código em
assembler no endereço apontado pelo
registrador IP
F:\>debug
-a
0B52:0100 mov ax,0002
0B52:0103 mov bx,0003
0B52:0106 mov cx,0004
0B52:0109 mov dx,0005
0B52:010C add ax,bx
0B52:010E add bx,cx
0B52:0110 add cx,dx
0B52:0112 sub dx,1
0B52:0115
Utilizando o Debug
u – Mostra o código de máquina (unassembly) correpondente a posição apontado
pelo registrador IP.
-u
0B52:0100 B80200
0B52:0103 BB0300
0B52:0106 B90400
0B52:0109 BA0500
0B52:010C 01D8
0B52:010E 01CB
0B52:0110 01D1
0B52:0112 83EA01
MOV
MOV
MOV
MOV
ADD
ADD
ADD
SUB
AX,0002
BX,0003
CX,0004
DX,0005
AX,BX
BX,CX
CX,DX
DX,+01
Utilizando o Debug
Código de Multiplicação
-a
0B52:0100 mov ax,7c4b
0B52:0103 mov bx, 0100
0B52:0106 mul bx
0B52:0108
-u
0B52:0100 B84B7C
0B52:0103 BB0001
0B52:0106 F7E3
MOV
MOV
MUL
AX,7C4B
BX,0100
BX
Utilizando o Debug
Código da Divisão
F:\>debug
-a
0B52:0100 mov dx,007c
0B52:0103 mov ax,4b12
0B52:0106 mov bx,0100
0B52:0109 div bx
0B52:010B
-u
0B52:0100 BA7C00
MOV DX,007C
0B52:0103 B8124B
MOV AX,4B12
0B52:0106 BB0001
MOV BX,0100
0B52:0109 F7F3
DIV BX
Utilizando o DEBUG
Uma interrupção é uma situação que ocorre quando o código que está sendo
executado atualmente é paralisado e um outro programa entra em execução.
Uma interrupção é provocado por hardware ou por software (pode ser o
programa que está sendo executado atualmente).
A geração de interrupção por software no DOS é realizada através da instrução
INT.
Utilizando o Debug
g – Esta opção faz com que o debug execute todos os comandos entre o valor
atual contido no registrador IP até encontrar a instrução de encerramento de
programa (int 20)
0BB7:0100 BA7C00
0BB7:0103 B8124B
0BB7:0106 BB0001
0BB7:0109 F7F3
0BB7:010B CD20
-r ip
IP 0100
:100
-g
MOV DX,007C
MOV AX,4B12
MOV BX,0100
DIV BX
INT 20 (instrução de encerramento de programa)
O programa terminou de forma normal
Utilizando o DEBUG
Imprimindo uma letra através da interrupção INT 21
-r ax
AX 0041
:200
-r dx
DX 0041
:41
-e 100
0B52:0100 CD.cd
-e 101
0B52:0101 21.21
-r
AX=0200 BX=0000 CX=0000 DX=0041 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0102 NV UP EI PL NZ NA PO NC
0B52:0102 005300
ADD [BP+DI+00],DL
SS:0000=CD
0B52:0102 005300
ADD [BP+DI+00],DL
SS:0000=CD
Utilizando o DOS
-r ip
IP 0102
:100
-g 102
A --------------- Caracter que foi impresso pelo DOS
AX=0241 BX=0000 CX=0000 DX=0041 SP=FFEE BP=0000 SI=0000 DI=0000
DS=0B52 ES=0B52 SS=0B52 CS=0B52 IP=0102 NV UP EI PL NZ NA PO NC
0B52:0102 005300
ADD [BP+DI+00],DL
SS:0000=CD
-
Utilizando o DEBUG
Para salvar um programa feito no debug, seguir os seguintes passos.
1 - Digitar o programa (com a instrução INT 20)
2 - Verificar o tamanho do programa (em bytes)
3 - Dar um nome para o programa
4 - Colocar o tamanho do programa no registrador CX
5 - Zerar o registrador BX
6 - Gravar o arquivo
Utilizando o DEBUG
Passo 1- Escrever programa que imprime * na tela.
-a
0B52:0100 mov ah,02
0B52:0102 mov dl,2A
0B52:0104 int 21
0B52:0106 int 20
0B52:0108
-u 100
0B52:0100 B402
0B52:0102 B22A
0B52:0104 CD21
0B52:0106 CD20
MOV AH,02
MOV DL,2A
INT 21
INT 20
Passo 2.
O programa possui 8 bytes de tamanho
Utilizando o Debug
Passo 3
-N imp_letra.com
Passo 4/5/6
-N IMPLETRA.COM
-r bx
BX 0000
:0
-r cx
CX 0000
:8
-w
Gravando 00008 bytes
Utilizando DEBUG
IMPRIMINDO UM STRING.
A Interrupção INT 21 com o valor 02 no registrador AH imprime um caracter na
tela, com o valor 09 no mesmo registrador, a interrupção irá realizar a impressão
de uma string (conjunto de caracters) até encontrar o simbolo ´$´ cujo valor
decimal ASCII é 24h.
Devemos informar para a Interrupção INT 21 qual é o endereço de memória
onde inicia a string.
Utilizando o DEBUG
F:\>debug
-e 200
0B52:0200 4F.4f 6C.6c 6F.6f 2C.2c 20.20 44.44 4F.4f 53.53
0B52:0208 69.20 21.61 24.71 69.75 6F.21 5C.24
-a 100
0B52:0100 mov ah,09
0B52:0102 mov dx,0200
0B52:0105 int 21
0B52:0107 int 20
0B52:0109
0B52:0109
-g
Olo, DOS aqu!
O programa terminou de forma normal
Utilizando o DEBUG
-D 200
0B52:0200
0B52:0210
0B52:0220
0B52:0230
0B52:0240
0B52:0250
0B52:0260
0B52:0270
4F 6C 6F 2C 20 44 4F 53-20 61 71 75 21 24 56 43 Olo, DOS aqu!$VC
39 38 5C 61 74 6C 5C 69-6E 63 6C 75 64 65 3B 43 98\atl\include;C
3A 5C 41 72 71 75 69 76-6F 73 20 64 65 20 70 72 :\Arquivos de pr
6F 67 72 61 6D 61 73 5C-4D 69 63 72 6F 73 6F 66 ogramas\Microsof
74 20 56 69 73 75 61 6C-20 53 74 75 64 69 6F 5C t Visual Studio\
56 43 39 38 5C 6D 66 63-5C 69 6E 63 6C 75 64 65 VC98\mfc\include
3B 43 3A 5C 41 72 71 75-69 76 6F 73 20 64 65 20 ;C:\Arquivos de
70 72 6F 67 72 61 6D 61-73 5C 4D 69 63 72 6F 73 programas\Micros
Execução do Programa
‣ Para a execução de um programa são utilizados os registradores de
propósito geral e específicos.
‣ Registradores de propósito geral: AX, BX, CX, DX
Registradores de propósito especifico: CS, DS, IP, ES, SS
‣ Durante a execução dos programas, os registradores são alterados a cada
execução de instrução.
‣ O registrador IP aponta para o endereço da próxima instrução a ser
executada
CICLO DE UM PROGRAMA
PROGRAMAÇÃO
MEMÓRIA LÓGICA
‣ Durante o processo de compilação as variáveis são transformadas em
endereços.
‣ Uma tabela de simbolos guarda o endereço de cada variável.
‣ Constantes Strings são armazenadas na área de dados do programa.
‣ O endereçamento começa sempre no zero.
‣ Um contador é incrementado a cada nova variável.
‣ O plano de endereçamento utilizado durante a compilação é chamado
de endereçamento Lógico.
TITLE PROGRAMA MODELO
DOSSEG
.MODEL SMALL
.STACK 100H
.DATA
;------ Tamanho da Pilha -------
;--- Definicao de variaveis e constantes
HelloMessage DB 'Hello, world',13,10,'$'
var
DW
.CODE
;------ Codigo do programa
Main: ;------ Rotina Principal
;-- Inicia Registradores de Dados (DS) e Extra (ES)
MOV AX, @DATA
MOV DS, AX
MOV ES, AX
; ----- Corpo do Programa ----mov ah,9
;DOS print string function
mov dx,OFFSET HelloMessage ;point to "Hello, world"
int 21h
;display "Hello, world"
; ------ Encerramento do Programa ----FIM:
;
call clrscr
MOV AX, 4C00h
PROGRAMA EM DISCO
PROGRAMA EM MEMÓRIA RAM