A programação em Assembly é uma técnica que permite escrever códigos de baixo nível para serem convertidos diretamente em instruções de máquina, que são executadas pelo processador. Em suma, é uma maneira de se comunicar diretamente com os componentes do hardware do computador, como a CPU, memória, registradores e periféricos.
Em um programa em Assembly, cada linha de código corresponde a uma instrução de máquina que manipula diretamente os dados armazenados na memória ou em registradores, podendo incluir operações aritméticas, de comparação e desvio condicional.
Embora a programação em Assembly seja comumente usada em tarefas que exigem um alto nível de controle sobre o hardware do computador, como desenvolvimento de drivers de dispositivos, sistemas operacionais e microcontroladores, ela é complexa e requer conhecimentos avançados em arquitetura de processador e instruções de máquina. Além disso, a falta de recursos de alto nível, como bibliotecas e ferramentas de desenvolvimento modernas, torna essa técnica mais trabalhosa e demorada em comparação a outras formas de programação.
Um exemplo simples de um código em Assembly para somar dois números:
; Este é um comentário, que começa com o caractere ";"
; Ele é ignorado pelo processador e serve apenas para documentar o código
section .data
; Aqui definimos as variáveis do programa
; Neste caso, definimos as variáveis "num1" e "num2" com os valores 10 e 20, respectivamente
num1 dw 10
num2 dw 20
section .text
; Aqui começa o código do programa
global _start
_start:
; Esta é a primeira instrução a ser executada
; Ela carrega o valor de "num1" no registrador AX
mov ax, [num1]
; Esta instrução adiciona o valor de "num2" ao valor armazenado no registrador AX
; O resultado é armazenado no próprio registrador AX
add ax, [num2]
; Esta instrução imprime o valor armazenado no registrador AX na tela
; O valor é impresso como uma string ASCII
mov ah, 0x0E ; função de interrupção para imprimir caractere
mov al, [ax] ; movendo valor de ax para al (primeiro argumento para interrupção)
add al, 0x30 ; convertendo valor para seu caractere correspondente em ASCII
int 0x10 ; realizando a interrupção
; Esta instrução é uma chamada de sistema para encerrar o programa
; Ela retorna o valor 0 para o sistema operacional, indicando que o programa terminou sem erros
mov eax, 1 ; código de saída do programa
xor ebx, ebx ; status de saída do programa
int 0x80 ; realizando a interrupção
O código acima, começa com a definição das variáveis do programa, “num1” e “num2”, na seção “.data”. Na seção “.text”, o código começa com a label “_start”, que é a primeira instrução a ser executada.
As instruções mov, add e mov ah são usadas para carregar valores nos registradores e realizar operações matemáticas. A instrução int 0x10 é usada para imprimir o valor da soma na tela, como uma string ASCII.
Finalmente, a instrução mov eax, 1 é usada para indicar que o programa terminou sem erros, e a instrução int 0x80 é usada para encerrar o programa.
O NASM (Netwide Assembler) é um montador de linguagem Assembly para plataformas x86 e x86-64. O montador é responsável por converter o código Assembly em linguagem de máquina, que pode ser executado pelo processador.
O NASM é amplamente utilizado na comunidade de programação de sistemas, especialmente em sistemas operacionais e drivers de dispositivos. Ele suporta várias sintaxes da linguagem Assembly, incluindo Intel e AT&T, e é capaz de gerar arquivos executáveis para várias plataformas, incluindo Windows, Linux e macOS.
Cole no comentário um dos códigos desenvolvidos em Assembly, utilizando o montador NASM.
Curiosidade: a seguir, é possível ver como um programador desenvolveu um jogo em Assembly nas horas vagas.
ANDRÉ PRZYBYSZ 
Exercício 1:
section .data
x dw 0
y dw 0
z dw 0
section .text
global _start
_start:
mov ax, 7 ; Carrega o valor 7 em ax
mov [x], ax ; Move o valor de ax para a variável x
mov ax, 13 ; Carrega o valor 13 em ax
mov [y], ax ; Move o valor de ax para a variável y
mov ax, [x] ; Move o valor da variável x para ax
mov [z], ax ; Move o valor de ax para a variável z
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 2:
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start:
mov ax, [x] ; Move o valor de x para ax
add ax, 8 ; Adiciona 8 a ax
mov [x], ax ; Move o valor de ax para x
Exercício 3:
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start:
mov ax, [x] ; Move o valor de x para ax
imul ax, ax ; Multiplica ax por si mesmo (calcula o quadrado)
mov [sqr], ax ; Move o resultado para sqr
Exercício 4:
section .text
global _start
_start:
xor edx, edx ; Zera o registrador edx
Exercício 5:
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
_start:
; Inversão dos valores
push eax
push ebx
pop eax
pop ebx
; Impressão dos valores invertidos
mov eax, ebx
mov ebx, 1
mov ecx, eax
mov edx, 1
mov esi, format
mov edi, 0
call printf
mov eax, 0x1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
extern printf
_start:
; Inversão dos valores
push eax
push ebx
pop eax
pop ebx
; Impressão dos valores invertidos
mov eax, ebx
mov ebx, 1
mov ecx, eax
mov edx, 1
mov esi, format
mov edi, 0
call printf
Exercício 6:
section .data
prompt db “Digite um número: “, 0
result db “O fatorial é: “, 0
newline db 10, 0
section .bss
number resb 2
section .text
global _start
extern printf, scanf
_start:
; Imprimir prompt para digitar o número
mov eax, 0
mov ebx, 1
mov ecx, prompt
mov edx, 17
int 0x80
; Ler o número fornecido pelo usuário
mov eax, 3
mov ebx, 0
mov ecx, number
mov edx, 2
int 0x80
; Converter o número ASCII para um valor numérico
sub byte [number], ‘0’
; Calcular o fatorial
movzx eax, byte [number]
mov ecx, eax
dec ecx
mov edx, eax
cmp eax, 0
je print_result
loop_start:
mul ecx
loop loop_start
print_result:
; Imprimir o resultado do fatorial
push eax
push result
call printf
add esp, 8
; Imprimir uma nova linha
push newline
call printf
add esp, 4
Exercício 7:
section .data
values db “7”, “9”, “1”, “2”, 0
format db “O menor valor é: %d”, 10, 0
section .text
global _start
extern printf, sscanf
_start:
; Ler os valores fornecidos
mov eax, values
mov ebx, “%d”
lea ecx, [ebp-4]
push ecx
push ebx
push eax
call sscanf
add esp, 12
check_c:
mov ecx, [ebp-12]
cmp ecx, eax
jge check_d
mov eax, ecx
check_d:
mov edx, [ebp-16]
cmp edx, eax
jge print_result
mov eax, edx
print_result:
; Imprimir o menor valor
push eax
push format
call printf
add esp, 8
Exercício 8:
section .data
format db “A soma é: %d”, 10, 0
section .text
global _start
extern printf
_start:
; Realizar a soma dos valores abaixo da pilha
mov eax, 0
add eax, [esp+20]
add eax, [esp+16]
add eax, [esp+12]
add eax, [esp+8]
add eax, [esp+4]
CurtirCurtir
Aluno1: Pedro Henrique Silva Oliveira
Para construirmos os programas em Assembly, devemos estruturar o código fonte da seguinte forma:
Fonte: Professora Roberta L. G., 2021.
Exercício 01 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
Código:
.MODEL SMALL
.STACK
.DATA
x DW ?
y DW ?
z DW ?
.CODE
MAIN PROC
MOV AX, @DATA
MOV DS, AX
MAIN ENDP
END MAIN
Utilizando Instruções Aritméticas adição e subtração:
Fonte: Professora Roberta L. G., 2021.
Exercício 02 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
código:
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start:
mov ax, [x] ;
add ax, 8 ;
mov [x], ax ;
mov ax, [x];
add ax, [y];
mov [soma], ax;
mov ax, [x];
sub ax, 3;
mov [x], ax ;
mov ax, [x];
sub ax, [y];
mov [sub], ax;
mov eax, 1;
xor ebx, ebx;
int 0x80;
Utilizando Instruções Aritméticas multiplicação e divisão:
Fonte: Professora Roberta L. G., 2021.
Exercício 03 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
código:
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start:
mov ax, [x] ;
imul ax, ax ;
mov [sqr], ax ;
mov ax, [x];
cwd;
idiv word [y];
mov [dv], ax;
mov ax, [x];
cwd;
idiv word [y];
mov [rest], dx;
mov eax, 1;
xor ebx, ebx;
int 0x80;
Utilizando Instruções Aritméticas XOR, AND, OR, NOT:
Fonte: Professora Roberta L. G., 2021.
Exercício 04 – Implemente um trecho de código em Assembly que que troque o valor do registrador AH com o valor do registrador BH. Utilize apenas instruções lógicas XOR. Você pode utilizar outros registradores para guardar valores intermediários.
Fonte: Professora Roberta L. G., 2021.
código:
xor DH, DH ; DH = 0
xor DH, AH ; DH = AH
xor AH, BH ; AH = AH ^ BH
xor BH, AH ; BH = BH ^ AH
xor AH, BH ; AH = AH ^ BH
xor BH, DH ; BH = DH
Exercício 05 – Faça um programa em “nasm” que inverta os valores de mov ebx, 10 e mov eax, 20. Utilize os comandos abaixo para realizar a inversão. Após, mostre os resultados invertidos na tela.
código:
section .data
result_msg db “Valores invertidos:”, 0
ebx_msg db “EBX: “, 0
eax_msg db “EAX: “, 0
newline db 10, 0
section .text
global _start
_start:
; Inversão dos valores
mov ebx, 10
mov eax, 20
print_string:
mov eax, 4
mov ebx, 1
int 0x80
ret
print_number:
mov eax, ebx
xor ebx, ebx
mov ecx, 10
mov edi, 10
xor edx, edx
div ecx
print_digits:
pop edx
add dl, ‘0’
mov eax, 4
mov ebx, 1
int 0x80
ret
Exercício 06 – Faça um programa em “nasm” que calcule o fatorial de um número.
Código:
section .data
prompt db “Digite um número: “, 0
result_msg db “O fatorial de “, 0
result_msg2 db ” é: “, 0
newline db 10, 0
section .bss
number resb 2
section .text
global _start
_start:
; Exibir prompt para o usuário
mov eax, 4
mov ebx, 1
mov ecx, prompt
mov edx, 17
int 0x80
calc_fatorial:
mul ecx ; eax = eax * ecx
loop calc_fatorial ; repetir até que ecx seja zero
print_result:
; Exibir mensagem “O fatorial de {número} é: ”
mov eax, 4
mov ebx, 1
mov ecx, result_msg
mov edx, 16
int 0x80
Exercício 07 – Faça um programa em “nasm” que leia os valores apresentados abaixo, em seguida mostre o menor valor.
código:
section .data
prompt db “Digite um número: “, 0
result_msg db “O menor valor é: “, 0
newline db 10, 0
section .text
global _start
_start:
; Exibir prompt para o usuário
mov eax, 4
mov ebx, 1
mov ecx, prompt
mov edx, 17
int 0x80
check_third_num:
; Ler o terceiro número
mov eax, 3
mov ebx, 0
mov ecx, num3
mov edx, 2
int 0x80
print_result:
; Exibir mensagem “O menor valor é: ”
mov eax, 4
mov ebx, 1
mov ecx, result_msg
mov edx, 19
int 0x80
section .bss
num1 resb 2
num2 resb 2
num3 resb 2
Exercício 08 – Faça um programa em “nasm” que some os valores abaixo da pilha e retire da soma o primeiro valor (14).
código:
section .data
result_msg db “A soma é: “, 0
newline db 10, 0
section .text
global _start
_start:
; Somar os valores da pilha e retirar o primeiro valor (14)
pop eax ; Retirar o primeiro valor (14)
add eax, esp ; Adicionar os valores restantes da pilha a EAX
CurtirCurtir
;********************************************************************************************
; EXERCÍCIO 01
.DATA
x dw 0
y dw 0
z dw 0
section .text
global _start
_start:
; Move o valor depois da vírgula para o valor antes da vírgula
mov ax, 7
mov [x], ax
mov ax, 13
mov [y], ax
mov ax, [x]
mov [z], ax
mov eax, 1
; Retorno ao 0 e interrupção código 0x80
xor ebx, ebx
int 0x80
;********************************************************************************************
; EXERCÍCIO 02
.MODEL SMALL
.STACK
.CODE
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start: ; Início
; Move o valor de x para ax, Adiciona 8 a ax, Move o valor de ax para x
mov ax, [x]
add ax, 8
mov [x], ax
; Move x para ax, adiciona o valor de y para ax e move ax para a soma
mov ax, [x]
add ax, [y]
mov [soma], ax
; Move x para ax, tira 3 de ax, move ax para x
mov ax, [x]
sub ax, 3
mov [x], ax
; Move o valor de x para ax, subtrai y de ax e move-o para subtração
mov ax, [x]
sub ax, [y]
mov [sub], ax
; Move o valor 1 para eax
mov eax, 1
; Retorno ao 0 e interrupção código 0x80
xor ebx, ebx
int 0x80
;********************************************************************************************
; EXERCÍCIO 03
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start: ; Início das operações
; Move x para ax, calcula ax*ax, move o resultado para a variável sqr
mov ax, [x]
imul ax, ax
mov [sqr], ax
; Move x para ax, estende a capacidade de bits, calcula a divisão inteira e move o resultado para dv
mov ax, [x]
cwd
idiv word [y]
mov [dv], ax
; Move x para ax, estende ax, calcula a divisão e move o resto para a variável rest
mov ax, [x]
cwd
idiv word [y]
mov [rest], dx
; Finalização do algorítimo
mov eax, 1
xor ebx, ebx
int 0x80
;********************************************************************************************
; EXERCÍCIO 04
section .text
global _start
_start:
; Zera o registrador edx e move ah para dl
xor edx, edx
mov dl, ah
; Realiza operações XOR entre variáveis separadas pela virgula
xor ah, bh
xor bh, ah
xor ah, bh
; Move o valor de dl para bh e o valor 1 para eax
mov bh, dl
mov eax, 1
; Fim do programa
xor ebx, ebx
int 0x80
;********************************************************************************************
; EXERCÍCIO 05
_start: ; Início
;********************************************************************************************
; EXERCÍCIO 06
section .data
section .bss
number resb 2 ; Espaço para armazenar o número digitado pelo usuário
section .text
global _start
_start:
calc_fatorial:
dec ecx ; Decrementar o contador
mul ecx ; Multiplicar o fatorial pelo contador
cmp ecx, 1
jg calc_fatorial ; Repetir o cálculo enquanto o contador for maior que 1
print_result:
exit_program:
;********************************************************************************************
; EXERCÍCIO 07
section .data
msg db “O menor valor é: “, 0
section .text
global _start
_start:
check_ecx:
cmp ecx, eax
jl check_edx
mov eax, ecx
check_edx:
cmp edx, eax
jl print_result
print_result:
exit_program:
;********************************************************************************************
; EXERCÍCIO 08
section .data
result_msg db “A soma é: “, 0
section .text
global _start
_start:
sum_values:
add eax, [ebx] ; Adicionar o valor apontado por ebx a eax
add ebx, 4 ; Avançar para o próximo valor na pilha
cmp ebx, esp ; Comparar ebx com o topo da pilha
jne sum_values ; Repetir a soma enquanto não chegar ao fim da pilha
exit_program:
; FIM
CurtirCurtir
Exercício 1
section .data
x dw 0
y dw 0
z dw 0
section .text
global _start
_start:
; Inicializa x com o valor 7
mov ax, 7
mov [x], ax
; Inicializa y com o valor 13
mov ax, 13
mov [y], ax
; Atribui o valor de x a z
mov ax, [x]
mov [z], ax
; Encerra o programa
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 2
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start:
; Adiciona 8 ao valor de x
mov ax, [x]
add ax, 8
mov [x], ax
; Soma x e y e atribui o resultado a soma
mov ax, [x]
add ax, [y]
mov [soma], ax
; Subtrai 3 do valor de x
mov ax, [x]
sub ax, 3
mov [x], ax
; Subtrai o valor de y de x e atribui o resultado a sub
mov ax, [x]
sub ax, [y]
mov [sub], ax
; Encerra o programa
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 3
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start:
; Calcula o quadrado de x e armazena em sqr
mov ax, [x]
imul ax, ax
mov [sqr], ax
; Divide x por y e armazena o quociente em dv
mov ax, [x]
cwd
idiv word [y]
mov [dv], ax
; Divide x por y e armazena o resto em rest
mov ax, [x]
cwd
idiv word [y]
mov [rest], dx
; Encerra o programa
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 4
section .text
global _start
_start:
; Troca os valores de ah e bh
xor edx, edx
mov dl, ah
xor ah, bh
xor bh, ah
xor ah, bh
mov bh, dl
; Encerra o programa
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercicio 5
section .data
format db
“%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
_start:
; Inverte os valores de eax e ebx
push eax
push ebx
pop eax
pop ebx
; Imprime os valores invertidos
mov eax, ebx
mov ebx, 1
mov ecx, eax
mov edx, 1
mov esi, format
mov edi, 0
call printf
; Encerra o programa
mov eax, 0x1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 6
section .data
prompt db “Digite um número: “, 0
result db “O fatorial é: “, 0
newline db 10, 0
section .bss
number resb 2
section .text
global _start
extern printf, scanf
_start:
; Imprime a mensagem de solicitação para o usuário digitar um número
mov eax, 0
mov ebx, 1
mov ecx, prompt
mov edx, 17
int 0x80
; Lê o número fornecido pelo usuário
mov eax, 3
mov ebx, 0
mov ecx, number
mov edx, 2
int 0x80
; Converte o número ASCII para um valor numérico
sub byte [number], ‘0’
; Calcula o fatorial
movzx eax, byte [number]
mov ecx, eax
dec ecx
mov edx, eax
cmp eax, 0
je print_result
loop_start:
mul ecx
loop loop_start
print_result:
; Imprime o resultado do fatorial
push eax
push result
call printf
add esp, 8
; Imprime uma nova linha
push newline
call printf
add esp, 4
; Encerra o programa
mov eax, 1
xor ebx, ebx
int 0x80
Exercício 7
section .data
values db “7”, “9”, “1”, “2”, 0
format db “O menor valor é: %d”, 10, 0
section .text
global _start
extern printf, sscanf
_start:
; Lê os valores fornecidos
mov eax, values
mov ebx, “%d”
lea ecx, [ebp-4]
push ecx
push ebx
push eax
call sscanf
add esp, 12
; Compara os valores para encontrar o menor
mov eax, [ebp-4]
mov ebx, [ebp-8]
cmp eax, ebx
jge check_c
mov eax, ebx
check_c:
mov ecx, [ebp-12]
cmp ecx, eax
jge check_d
mov eax, ecx
check_d:
mov edx, [ebp-16]
cmp edx, eax
jge print_result
mov eax, edx
print_result:
; Imprime o menor valor
push eax
push format
call printf
add esp, 8
; Encerra o programa
mov eax, 1
xor ebx, ebx
int 0x80
Exercício 8
section .data
format db “A soma é: %d”, 10, 0
section .text
global _start
extern printf
_start:
section .data
format db “A soma é: %d”, 10, 0
section .text
global _start
extern printf
_start:
; Realiza a soma dos valores abaixo da pilha
mov eax, 0
add eax, [esp+20]
add eax, [esp+16]
add eax, [esp+12]
add eax, [esp+8]
add eax, [esp+4]
; Subtrai o primeiro valor (14) da soma
sub eax, 14
; Imprime o resultado da soma
push eax
push format
call printf
add esp, 8
; Encerra o programa
mov eax, 1
xor ebx, ebx
int 0x80
CurtirCurtir
; EXERCÍCIO 01
.DATA
x dw 0
y dw 0
z dw 0
section .text
global _start
_start:
; Inverte a ordem dos valores antes e depois da vírgula
mov ax, 7
mov [x], ax
mov ax, 13
mov [y], ax
mov ax, [z]
mov [x], ax
mov eax, 1
; Retorno ao 0 e interrupção código 0x80
xor ebx, ebx
int 0x80
; EXERCÍCIO 02
.MODEL SMALL
.STACK
.CODE
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start: ; Início
; Inverte a ordem das operações: subtração antes da soma
mov ax, [x]
sub ax, 3
mov [x], ax
mov ax, [x]
add ax, [y]
mov [soma], ax
mov ax, [x]
add ax, 8
mov [x], ax
mov ax, [x]
sub ax, 3
mov [sub], ax
; Move o valor 1 para eax
mov eax, 1
; Retorno ao 0 e interrupção código 0x80
xor ebx, ebx
int 0x80
; EXERCÍCIO 03
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start: ; Início das operações
; Inverte a ordem das operações: resto antes da divisão inteira
mov ax, [x]
cwd
idiv word [y]
mov [rest], dx
mov ax, [x]
imul ax, ax
mov [sqr], ax
mov ax, [x]
cwd
idiv word [y]
mov [dv], ax
; Finalização do algoritmo
mov eax, 1
xor ebx, ebx
int 0x80
; EXERCÍCIO 04
section .text
global _start
_start:
; Move ah para dl e zera o registrador edx
mov dl, ah
xor edx, edx
; Realiza operações XOR entre variáveis separadas pela vírgula
xor bh, ah
xor ah, bh
xor bh, ah
; Move o valor de dl para bh e o valor 1 para eax
mov bh, dl
mov eax, 1
; Fim do programa
xor ebx, ebx
int 0x80
; EXERCÍCIO 05
_start: ; Início
; Movendo os valores iniciais para eax e ebx
mov eax, 20
mov ebx, 10
; Mostrando a mensagem inicial
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, 19
int 0x80
; Invertendo os valores usando push e pop
push ebx
push eax
pop ebx
pop eax
; Mostrando os valores invertidos na tela
; Valor de ebx
mov eax, 4
mov ebx, 1
mov ecx, ebx
add ecx, ‘0’
mov edx, 1
int 0x80
; Valor de eax
mov eax, 4
mov ebx, 1
mov ecx, eax
add ecx, ‘0’
mov edx, 1
int 0x80
; Saindo do programa
mov eax, 1
xor ebx, ebx
int 0x80
; EXERCÍCIO 06
section .data
; Mensagens exibidas na tela
msg db “Digite um número: “, 0
result_msg db “O fatorial é: “, 0
newline db 10, 0 ; Nova linha
section .bss
number resb 2 ; Espaço para armazenar o número digitado pelo usuário
section .text
global _start
_start:
; Exibir mensagem para digitar um número
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, 17
int 0x80
; Ler número do usuário
mov eax, 3
mov ebx, 0
mov ecx, number
mov edx, 2
int 0x80
; Converter número ASCII para binário
movzx eax, byte [number]
sub eax, ‘0’
; Verificar se o número é zero
cmp eax, 0
jz print_result ; Pula diretamente para a impressão do resultado se o número for zero
; Calcular o fatorial
mov ebx, eax ; ebx = fatorial = número
mov ecx, eax ; ecx = contador = número – 1
calc_fatorial:
dec ecx ; Decrementar o contador
mul ecx ; Multiplicar o fatorial pelo contador
cmp ecx, 1
jg calc_fatorial ; Repetir o cálculo enquanto o contador for maior que 1
print_result:
; Exibir mensagem “O fatorial é: ”
mov eax, 4
mov ebx, 1
mov ecx, result_msg
mov edx, 15
int 0x80
; Exibir o resultado
add eax, ‘0’ ; Converter o fatorial para ASCII
mov [number], al
mov eax, 4
mov ebx, 1
mov ecx, number
mov edx, 1
int 0x80
; Exibir nova linha
mov eax, 4
mov ebx, 1
mov ecx, newline
mov edx, 1
int 0x80
exit_program:
; Sair do programa
mov eax, 1
xor ebx, ebx
int 0x80
; EXERCÍCIO 07
section .data
msg db “O menor valor é: “, 0
section .text
global _start
_start:
; Movendo os valores para os registradores
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
; Comparando os valores para encontrar o menor
cmp ecx, eax
jl check_ebx
mov eax, ecx
check_ebx:
cmp ebx, eax
jl check_edx
mov eax, ebx
check_edx:
cmp edx, eax
jl print_result
print_result:
; Exibir mensagem “O menor valor é: ”
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, 17
int 0x80
; Exibir o valor do menor na tela
add eax, ‘0’ ; Converter o valor para ASCII
mov edx, 1
int 0x80
exit_program:
; Sair do programa
mov eax, 1
xor ebx, ebx
int 0x80
ERCÍCIO 08
section .data
result_msg db “A soma é: “, 0
section .text
global _start
_start:
; Empilhando os valores
push 10
push 5
push 1
push 50
push 14
; Soma dos valores presentes na pilha
xor eax, eax ; Limpar o registrador eax
mov ebx, esp ; ebx aponta para o topo da pilha
sum_values:
add eax, [ebx] ; Adicionar o valor apontado por ebx a eax
add ebx, 4 ; Avançar para o próximo valor na pilha
cmp ebx, esp ; Comparar ebx com o topo da pilha
jne sum_values ; Repetir a soma enquanto não chegar ao fim da pilha
; Subtrair o primeiro valor (14) da soma
sub eax, 14
; Exibir mensagem “A soma é: ”
mov eax, 4
mov ebx, 1
mov ecx, result_msg
mov edx, 12
int 0x80
; Exibir o resultado na tela
mov ebx, eax
add ebx, ‘0’ ; Converter o valor para ASCII
mov eax, 4
mov ecx, ebx
mov edx, 1
int 0x80
exit_program:
; Sair do programa
mov eax, 1
xor ebx, ebx
int 0x80
CurtirCurtir
Exercício 1:
section .data
x dw 0
y dw 0
z dw 0
section .text
global _start
_start:
mov ax, 7 ; Carrega o valor 7 em ax
mov [x], ax ; Move o valor de ax para a variável x
mov ax, 13 ; Carrega o valor 13 em ax
mov [y], ax ; Move o valor de ax para a variável y
mov ax, [x] ; Move o valor da variável x para ax
mov [z], ax ; Move o valor de ax para a variável z
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 2:
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start:
mov ax, [x] ; Move o valor de x para ax
add ax, 8 ; Adiciona 8 a ax
mov [x], ax ; Move o valor de ax para x
mov ax, [x] ; Move o valor de x para ax
add ax, [y] ; Adiciona o valor de y a ax
mov [soma], ax ; Move o valor de ax para soma
mov ax, [x] ; Move o valor de x para ax
sub ax, 3 ; Subtrai 3 de ax
mov [x], ax ; Move o valor de ax para x
mov ax, [x] ; Move o valor de x para ax
sub ax, [y] ; Subtrai o valor de y de ax
mov [sub], ax ; Move o valor de ax para sub
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 3:
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start:
mov ax, [x] ; Move o valor de x para ax
imul ax, ax ; Multiplica ax por si mesmo (calcula o quadrado)
mov [sqr], ax ; Move o resultado para sqr
mov ax, [x] ; Move o valor de x para ax
cwd ; Estende o sinal de ax para dx:ax (32 bits)
idiv word [y] ; Divide dx:ax pelo valor de y (divisão inteira)
mov [dv], ax ; Move o quociente para dv
mov ax, [x] ; Move o valor de x para ax
cwd ; Estende o sinal de ax para dx:ax (32 bits)
idiv word [y] ; Divide dx:ax pelo valor de y (divisão inteira)
mov [rest], dx ; Move o resto para rest
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 4:
section .text
global _start
_start:
xor edx, edx ; Zera o registrador edx
mov dl, ah ; Move o valor de ah para dl
xor ah, bh ; Realiza a operação XOR entre ah e bh
xor bh, ah ; Realiza a operação XOR entre bh e ah
xor ah, bh ; Realiza a operação XOR entre ah e bh
mov bh, dl ; Move o valor de dl (armazenado anteriormente em ah) para bh
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 5:
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
_start:
; Inversão dos valores
push eax
push ebx
pop eax
pop ebx
; Impressão dos valores invertidos
mov eax, ebx
mov ebx, 1
mov ecx, eax
mov edx, 1
mov esi, format
mov edi, 0
call printf
mov eax, 0x1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
extern printf
_start:
; Inversão dos valores
push eax
push ebx
pop eax
pop ebx
; Impressão dos valores invertidos
mov eax, ebx
mov ebx, 1
mov ecx, eax
mov edx, 1
mov esi, format
mov edi, 0
call printf
mov eax, 0x1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 6:
section .data
prompt db “Digite um número: “, 0
result db “O fatorial é: “, 0
newline db 10, 0
section .bss
number resb 2
section .text
global _start
extern printf, scanf
_start:
; Imprimir prompt para digitar o número
mov eax, 0
mov ebx, 1
mov ecx, prompt
mov edx, 17
int 0x80
; Ler o número fornecido pelo usuário
mov eax, 3
mov ebx, 0
mov ecx, number
mov edx, 2
int 0x80
; Converter o número ASCII para um valor numérico
sub byte [number], ‘0’
; Calcular o fatorial
movzx eax, byte [number]
mov ecx, eax
dec ecx
mov edx, eax
cmp eax, 0
je print_result
loop_start:
mul ecx
loop loop_start
print_result:
; Imprimir o resultado do fatorial
push eax
push result
call printf
add esp, 8
; Imprimir uma nova linha
push newline
call printf
add esp, 4
; Encerrar o programa
mov eax, 1
xor ebx, ebx
int 0x80
Exercício 7:
section .data
values db “7”, “9”, “1”, “2”, 0
format db “O menor valor é: %d”, 10, 0
section .text
global _start
extern printf, sscanf
_start:
; Ler os valores fornecidos
mov eax, values
mov ebx, “%d”
lea ecx, [ebp-4]
push ecx
push ebx
push eax
call sscanf
add esp, 12
; Comparar os valores para encontrar o menor
mov eax, [ebp-4]
mov ebx, [ebp-8]
cmp eax, ebx
jge check_c
mov eax, ebx
check_c:
mov ecx, [ebp-12]
cmp ecx, eax
jge check_d
mov eax, ecx
check_d:
mov edx, [ebp-16]
cmp edx, eax
jge print_result
mov eax, edx
print_result:
; Imprimir o menor valor
push eax
push format
call printf
add esp, 8
; Encerrar o programa
mov eax, 1
xor ebx, ebx
int 0x80
Exercício 8:
section .data
format db “A soma é: %d”, 10, 0
section .text
global _start
extern printf
_start:
; Realizar a soma dos valores abaixo da pilha
mov eax, 0
add eax, [esp+20]
add eax, [esp+16]
add eax, [esp+12]
add eax, [esp+8]
add eax, [esp+4]
; Subtrair o primeiro valor (14) da soma
sub eax, 14
; Imprimir o resultado da soma
push eax
push format
call printf
add esp, 8
; Encerrar o programa
mov eax, 1
xor ebx, ebx
int 0x80
CurtirCurtir
EX 1:
global _main
extern _printf
section .text
_main:
section .data
x: dw 0
y: dw 0
z: dw 0
message: db “x=11”, 10, “y=13”, 10, “z=x”, 10
Ex 2:
section .text
global _main
extern _printf
_main:
add word[x], 8 ;x=x+8
mov DX, word[x] ;DX=x
add DX, word[y] ;DX=DX+y=x+y
mov word[soma], DX ;soma=DX=x+y
sub word[x], 3 ;x=x-3
mov DX, word[x] ;DX=x
sub DX, word[y] ;DX=DX-y=x-y
mov word[sub], DX ;sub=DX=x-y
push message
call _printf
add esp, 4
ret
segment .data
x: dw 8
y: dw 10
soma: dw 18
sub: dw 5
message: db ‘x=8’, 10, ‘y=10’, 10, ‘soma=x+y=18’, 10, ‘sub=x-3=5’
Ex 3:
section .text
global _main
extern _printf
_main:
mov AL, x ;AL=x
mul x ;AX=AL*x = x*x
mov sqr, AX ;sqr=AX = x*x
mov AL, x ;AL=x
mov AH, 0 ;AX [AH,AL]
div y ; AL=AX/y
;AH=resto(AX/y)
mov dv, AL ;dv=AL
mov rest, AH ;rest=AH
ret
segment .data
x: db 5
y: db 12
sqr: db 25
dv: db 2
rest: db 0,083
section .text
global _main
extern _printf
_main:
mov AL, x ;AL=x
mul x ;AX=AL*x = x*x
mov sqr, AX ;sqr=AX = x*x
mov AL, x ;AL=x
mov AH, 0 ;AX [AH,AL]
div y ; AL=AX/y
;AH=resto(AX/y)
mov dv, AL ;dv=AL
mov rest, AH ;rest=AH
ret
segment .data
x: db 5
y: db 12
sqr: db 25
dv: db 2
rest: db 0,083
section .text
global _main
extern _printf
_main:
mov AL, x ;AL=x
mul x ;AX=AL*x = x*x
mov sqr, AX ;sqr=AX = x*x
mov AL, x ;AL=x
mov AH, 0 ;AX [AH,AL]
div y ; AL=AX/y
;AH=resto(AX/y)
mov dv, AL ;dv=AL
mov rest, AH ;rest=AH
ret
segment .data
x: db 5
y: db 12
sqr: db 25
dv: db 2
rest: db 0,083
Ex 4:
section .text
global _start
_start:
; Troca os valores de ah e bh
xor edx, edx
mov dl, ah
xor ah, bh
xor bh, ah
xor ah, bh
mov bh, dl
; Encerra o programa
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Ex 5:
section .data
format db
“%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
_start:
; Inverte os valores de eax e ebx
push eax
push ebx
pop eax
pop ebx
; Imprime os valores invertidos
mov eax, ebx
mov ebx, 1
mov ecx, eax
mov edx, 1
mov esi, format
mov edi, 0
call printf
; Encerra o programa
mov eax, 0x1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Ex 6:
section .data
msg db “O fatorial de %d é: %d”, 0 ; Mensagem de saída
nl db 0Ah ; Caractere de nova linha
section .text
global _start
_start:
; Lê o número do fatorial a partir do usuário
mov eax, 5 ; Número para o fatorial (altere para o desejado)
mov ebx, eax ; Salva uma cópia do número em ebx
loop_start:
; Multiplica o fatorial atual pelo número atual
mul ecx ; eax *= ecx
section .data
printf db “%d”, 0
Ex 7:
section .data
msg db “O menor valor é: “, 0
section .text
global _start
_start:
; Movendo os valores para os registradores
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
; Comparando os valores para encontrar o menor
cmp eax, ebx
jl check_ecx
mov eax, ebx
check_ecx:
cmp ecx, eax
jl check_edx
mov eax, ecx
check_edx:
cmp edx, eax
jl print_result
print_result:
; Exibir mensagem “O menor valor é: ”
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, 17
int 0x80
; Exibir o valor do menor na tela
add eax, ‘0’ ; Converter o valor para ASCII
mov edx, 1
int 0x80
exit_program:
; Sair do programa
mov eax, 1
xor ebx, ebx
int 0x80
section .data
msg db “O menor valor é: “, 0
section .text
global _start
_start:
; Movendo os valores para os registradores
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
; Comparando os valores para encontrar o menor
cmp eax, ebx
jl check_ecx
mov eax, ebx
check_ecx:
cmp ecx, eax
jl check_edx
mov eax, ecx
check_edx:
cmp edx, eax
jl print_result
print_result:
; Exibir mensagem “O menor valor é: ”
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, 17
int 0x80
; Exibir o valor do menor na tela
add eax, ‘0’ ; Converter o valor para ASCII
mov edx, 1
int 0x80
exit_program:
; Sair do programa
mov eax, 1
xor ebx, ebx
int 0x80
section .data
msg db “O menor valor é: “, 0
section .text
global _start
_start:
; Movendo os valores para os registradores
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
; Comparando os valores para encontrar o menor
cmp eax, ebx
jl check_ecx
mov eax, ebx
check_ecx:
cmp ecx, eax
jl check_edx
mov eax, ecx
check_edx:
cmp edx, eax
jl print_result
print_result:
; Exibir mensagem “O menor valor é: ”
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, 17
int 0x80
; Exibir o valor do menor na tela
add eax, ‘0’ ; Converter o valor para ASCII
mov edx, 1
int 0x80
exit_program:
; Sair do programa
mov eax, 1
xor ebx, ebx
int 0x80
Ex 8:
section .data
result_msg db “A soma é: “, 0
section .text
global _start
_start:
; Empilhando os valores
push 10
push 5
push 1
push 50
push 14
; Soma dos valores presentes na pilha
xor eax, eax ; Limpar o registrador eax
mov ebx, esp ; ebx aponta para o topo da pilha
sum_values:
add eax, [ebx] ; Adicionar o valor apontado por ebx a eax
add ebx, 4 ; Avançar para o próximo valor na pilha
cmp ebx, esp ; Comparar ebx com o topo da pilha
jne sum_values ; Repetir a soma enquanto não chegar ao fim da pilha
; Subtrair o primeiro valor (14) da soma
sub eax, 14
; Exibir mensagem “A soma é: ”
mov eax, 4
mov ebx, 1
mov ecx, result_msg
mov edx, 12
int 0x80
; Exibir o resultado na tela
mov ebx, eax
add ebx, ‘0’ ; Converter o valor para ASCII
mov eax, 4
mov ecx, ebx
mov edx, 1
int 0x80
exit_program:
; Sair do programa
mov eax, 1
xor ebx, ebx
int 0x80
CurtirCurtir
Ex1:
global _main
extern _printf
section .text
_main:
section .data
x: dw 0
y: dw 0
z: dw 0
message: db 10, 10, 10
Ex2:
global _main
extern _printf
section .text
_main:
section .data
x: dw 5
y: dw 10
soma: dw 0
sub: dw 0
Ex;3:
global _main
extern _printf
section .text
_main:
mov AL, byte[x]
mul byte[x]
mov byte[sqr], AX
mov AL, byte[x]
mov AH, 0
div byte[y]
section .data
x: db 15
y: db 12
sqr: dw 0
dv: db 0
rest: db 0
Ex4:
global _main
extern _printf
section .text
_main:
Ex5:
global _main
extern _printf
section .text
_main:
mov ebx, 10
mov eax, 20
push eax
push ebx
pop eax
pop ebx
push eax
push valor
section .data
valor: db “Valor: eax = %d”, 10,0
valor1: db “Valor 1: ebx = %d”, 0
Ex6:
global _main
extern _printf
extern _scanf
section .text
_main:
loop1:
section .data
x: times 4 db 0
formato: db “%d”, 0
message: db “O valor e %d”, 10,0
Ex7:
global _main
extern _printf
section .text
_main:
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
menorValor1:
menorValor2:
finalValor:
section .data
formato: db “Menor valor eh %d”, 10,0
CurtirCurtir
Exercício 1
section .data
x dw 0
y dw 0
z dw 0
section .text
global _start
_start:
Exercício 2
.MODEL SMALL
.STACK
.CODE
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start:
Exercício 3
section .data
section .text
global _start
_start:
Exercício 4
section .text
global _start
_start:
xor edx, edx ; Zera o registrador EDX
mov dl, ah ; Move o valor de AH para DL
xor ah, bh ; Realiza a operação XOR entre AH e BH e armazena o resultado em AH
xor bh, ah ; Realiza a operação XOR entre BH e AH e armazena o resultado em BH
xor ah, bh ; Realiza a operação XOR entre AH e BH e armazena o resultado em AH
mov bh, dl ; Move o valor original de AH (armazenado em DL) para BH
mov eax, 1 ; Coloca o número do sistema de chamada (sys_exit) em EAX
xor ebx, ebx ; Zera o registrador EBX (código de retorno 0)
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 5
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
_start:
push eax ; Empurra o valor de eax para a pilha
push ebx ; Empurra o valor de ebx para a pilha
pop eax ; Desempilha o valor de ebx para eax
pop ebx ; Desempilha o valor de eax para ebx
mov eax, ebx ; Move o valor invertido de ebx para eax
mov ebx, 1 ; Move o identificador de arquivo (stdout) para ebx
mov ecx, eax ; Move o valor em eax para ecx (valor a ser impresso)
mov edx, 1 ; Move o tamanho da string para ser impressa (1 caractere)
mov esi, format ; Move o endereço do formato da string para esi
mov edi, 0 ; Move 0 para edi (nenhum argumento de largura)
call printf ; Chama a função printf para imprimir o valor
mov eax, 0x1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 6
section .data
prompt db “Digite um número: “, 0 ; Mensagem de solicitação para o usuário digitar um número
result db “O fatorial é: “, 0 ; Mensagem para imprimir o resultado do fatorial
newline db 10, 0 ; Caractere de nova linha
section .bss
number resb 2 ; Espaço reservado para armazenar o número fornecido pelo usuário
section .text
global _start
extern printf, scanf
_start:
mov eax, 0
mov ebx, 1
mov ecx, prompt
mov edx, 17
int 0x80
mov eax, 3
mov ebx, 0
mov ecx, number
mov edx, 2
int 0x80
sub byte [number], ‘0’
movzx eax, byte [number] ; Move o número para EAX e estende para 32 bits
mov ecx, eax ; Armazena uma cópia do número original em ECX
dec ecx ; Decrementa o número para ser usado como contador no loop
mov edx, eax ; Armazena uma cópia do número original em EDX
cmp eax, 0 ; Compara o número com 0 para tratar o caso especial de fatorial de 0
je print_result ; Se for 0, pula para imprimir o resultado
loop_start:
mul ecx ; Multiplica EAX pelo valor em ECX
loop loop_start ; Decrementa ECX e repete o loop até que ECX seja 0
print_result:
push eax
push result
call printf
add esp, 8
push newline
call printf
add esp, 4
mov eax, 1
xor ebx, ebx
int 0x80
Exercício 7
section .data
values db “7”, “9”, “1”, “2”, 0 ; Valores fornecidos como strings
format db “O menor valor é: %d”, 10, 0 ; Formato de string para imprimir o menor valor
section .text
global _start
extern printf, sscanf
_start:
mov eax, values ; Move o endereço dos valores para EAX
mov ebx, “%d” ; Move o formato para EBX
lea ecx, [ebp-4] ; Carrega o endereço para armazenar os valores lidos na pilha
push ecx
push ebx
push eax
call sscanf ; Chama a função sscanf para ler os valores
add esp, 12 ; Limpa os argumentos da pilha
mov eax, [ebp-4] ; Move o primeiro valor para EAX
mov ebx, [ebp-8] ; Move o segundo valor para EBX
cmp eax, ebx ; Compara EAX com EBX
jge check_c ; Se for maior ou igual, pula para check_c
mov eax, ebx ; Se for menor, move EBX para EAX
check_c:
mov ecx, [ebp-12] ; Move o terceiro valor para ECX
cmp ecx, eax ; Compara ECX com EAX
jge check_d ; Se for maior ou igual, pula para check_d
mov eax, ecx ; Se for menor, move ECX para EAX
check_d:
mov edx, [ebp-16] ; Move o quarto valor para EDX
cmp edx, eax ; Compara EDX com EAX
jge print_result ; Se for maior ou igual, pula para print_result
mov eax, edx ; Se for menor, move EDX para EAX
print_result:
push eax
push format
call printf
add esp, 8
; mov eax, 1
xor ebx, ebx
int 0x80
Exercício 8
section .data
format db “A soma é: %d”, 10, 0 ; Formato de string para imprimir a soma
section .text
global _start
extern printf
_start:
mov eax, 0
add eax, [esp+20] ; Soma o valor no endereço [esp+20] ao registrador EAX
add eax, [esp+16] ; Soma o valor no endereço [esp+16] ao registrador EAX
add eax, [esp+12] ; Soma o valor no endereço [esp+12] ao registrador EAX
add eax, [esp+8] ; Soma o valor no endereço [esp+8] ao registrador EAX
add eax, [esp+4] ; Soma o valor no endereço [esp+4] ao registrador EAX
sub eax, 14
push eax
push format
call printf
add esp, 8
mov eax, 1
xor ebx, ebx
int 0x80
CurtirCurtir
Exercício 01 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
Utilizando Instruções Aritméticas adição e subtração:
Fonte: Professora Roberta L. G., 2021.
; —————————————————————————-
; exercicio1.asm
; —————————————————————————-
global _main
extern _printf
section .text
_main:
section .data
x: dw 0
y: dw 0
z: dw 0
message: db “x=7”, 10, “y=13”, 10, “z=x”, 10
END
Exercício 02 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
Utilizando Instruções Aritméticas multiplicação e divisão:
Fonte: Professora Roberta L. G., 2021.
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start:
; x = x + 8
mov ax, [x]
add ax, 8
mov [x], ax
Exercício 03 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
Utilizando Instruções Aritméticas XOR, AND, OR, NOT:
Fonte: Professora Roberta L. G., 2021.
section .data
x dw 5
y dw 10
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start:
; sqr = x * x
mov ax, [x]
xor dx, dx
imul ax
mov [sqr], ax
Exercício 04 – Implemente um trecho de código em Assembly que que troque o valor do registrador AH com o valor do registrador BH. Utilize apenas instruções lógicas XOR. Você pode utilizar outros registradores para guardar valores intermediários.
Fonte: Professora Roberta L. G., 2021.
section .text
global _start
_start:
mov ah, 0x12 ; Valor inicial de AH
mov bh, 0x34 ; Valor inicial de BH
section .data
msg db “Valores trocados: AH = “, 0x00
msg_len equ $ – msg
Exercício 05 – Faça um programa em “nasm” que inverta os valores de mov ebx, 10 e mov eax, 20. Utilize os comandos abaixo para realizar a inversão. Após, mostre os resultados invertidos na tela.
section .data
output db “Valores invertidos: ebx = %d, eax = %d”, 0
section .text
global _start
_start:
; Inverte os valores de ebx e eax
push eax
push ebx
pop eax
pop ebx
section .data
output db “Valores invertidos: ebx = %d, eax = %d”, 0
output_len equ $-output
Exercício 06 – Faça um programa em “nasm” que calcule o fatorial de um número.
section .data
num db 5 ; número para calcular o fatorial
section .text
global _start
_start:
; Carrega o valor do número em um registrador
mov al, [num]
loop:
; Multiplica o valor atual do fatorial pelo valor atual do número
mul al
resultado:
; O resultado do fatorial estará em AX
; Você pode exibir o resultado ou usar para outros fins
Exercício 07 – Faça um programa em “nasm” que leia os valores apresentados abaixo, em seguida mostre o menor valor.
section .data
prompt db “Digite um número: “, 0
prompt_len equ $ – prompt
result db “O menor valor é: “, 0
result_len equ $ – result
section .bss
input resd 4
section .text
global _start
_start:
; Leitura do valor em eax
mov eax, 7
; Leitura do valor em ebx
mov ebx, 9
; Leitura do valor em ecx
mov ecx, 1
; Leitura do valor em edx
mov edx, 2
check_ecx:
cmp eax, ecx
jle check_edx
mov eax, ecx
check_edx:
cmp eax, edx
jle print_result
mov eax, edx
print_result:
; Exibição do menor valor na tela
mov ebx, 1
mov ecx, result
mov edx, result_len
mov esi, eax
call print_integer
exit:
; Encerra o programa
mov eax, 1
xor ebx, ebx
int 0x80
print_integer:
; Converte o número em esi para uma string e o exibe na tela
add esi, ‘0’
push eax
push ecx
push edx
mov eax, 4
mov edx, 1
int 0x80
pop edx
pop ecx
pop eax
ret
Exercício 08 – Faça um programa em “nasm” que some os valores abaixo da pilha e retire da soma o primeiro valor (14).
section .data
result db “Resultado: “, 0
result_len equ $ – result
section .bss
sum resd 1
section .text
global _start
_start:
; Empilha os valores
push dword 10
push dword 5
push dword 1
push dword 50
push dword 14
add_values:
pop edx ; Desempilha o próximo valor
add eax, edx ; Soma o valor em edx a eax
inc ebx ; Incrementa o contador de valores somados
cmp ebx, 1 ; Verifica se é o primeiro valor
jne add_values ; Se não for o primeiro valor, continua a soma
exit:
; Encerra o programa
mov eax, 1
xor ebx, ebx
int 0x80
print_string:
; Exibe uma string na tela
mov eax, 4
int 0x80
ret
CurtirCurtir
Exercicio 1:
global _main
extern _printf
section .text
_main:
section .data
x: dw 0
y: dw 0
z: dw 0
message: db “x=7”, 10, “y=13”, 10, “z=x”, 10
Exercicio 2:
section .model small
.stack
.code
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start:
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Adiciona 8 ao valor em AX
add ax, 8
; Armazena o valor de AX na variável x
mov [x], ax
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Adiciona o valor armazenado em y ao valor em AX
add ax, [y]
; Armazena o valor de AX na variável soma
mov [soma], ax
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Subtrai 3 do valor em AX
sub ax, 3
; Armazena o valor de AX na variável x
mov [x], ax
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Subtrai o valor armazenado em y do valor em AX
sub ax, [y]
; Armazena o valor de AX na variável subtração
mov [sub], ax
; Código de saída do programa
mov eax, 1
; Status de saída do programa
xor ebx, ebx
; Realiza a interrupção
int 0x80
Exercicio 3;
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start:
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Multiplica o valor em AX por ele mesmo
imul ax, ax
; Armazena o resultado em AX na variável sqr
mov [sqr], ax
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Estende o valor de AX para.
Exercício 4:
assembly
Copy code
section .data
x dw 15
y dw 4
divisao dw 0
resto dw 0
section .text
global _start
_start:
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Divide o valor em AX pelo valor armazenado em y
cwd
idiv word [y]
; Armazena o resultado da divisão em AX na variável divisao
mov [divisao], ax
; Armazena o resto da divisão em DX na variável resto
mov [resto], dx
; Código de saída do programa
mov eax, 1
; Status de saída do programa
xor ebx, ebx
; Realiza a interrupção
int 0x80
Exercício 5:
assembly
Copy code
section .data
x dw 8
y dw 3
multiplicacao dw 0
section .text
global _start
_start:
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Multiplica o valor em AX pelo valor armazenado em y
imul ax, word [y]
; Armazena o resultado da multiplicação em AX na variável multiplicacao
mov [multiplicacao], ax
; Código de saída do programa
mov eax, 1
; Status de saída do programa
xor ebx, ebx
; Realiza a interrupção
int 0x80
Exercício 6:
assembly
Copy code
section .data
x dw 17
y dw 5
resultado dw 0
section .text
global _start
_start:
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Move o valor armazenado em y para o registrador BX
mov bx, [y]
; Realiza a operação de multiplicação entre os registradores AX e BX
mul bx
; Armazena o resultado da multiplicação em AX na variável resultado
mov [resultado], ax
; Código de saída do programa
mov eax, 1
; Status de saída do programa
xor ebx, ebx
; Realiza a interrupção
int 0x80
Exercício 7:
assembly
Copy code
section .data
x dw 27
y dw 6
resultado dw 0
section .text
global _start
_start:
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Move o valor armazenado em y para o registrador BX
mov bx, [y]
; Realiza a operação de divisão entre os registradores AX e BX
xor dx, dx
div bx
; Armazena o resultado da divisão em AX na variável resultado
mov [resultado], ax
; Código de saída do programa
mov eax, 1
; Status de saída do programa
xor ebx, ebx
; Realiza a interrupção
int 0x80
Exercício 8:
assembly
Copy code
section .data
x dw 6
y dw 2
resultado dw 0
section .text
global _start
_start:
; Move o valor armazenado em x para o registrador AX
mov ax, [x]
; Move o valor armazenado em y para o registrador BX
mov bx, [y]
; Realiza a operação de divisão entre os registradores AX e BX
xor dx, dx
div bx
; Armazena o resto da divisão em DX na variável resultado
mov [resultado], dx
; Código de saída do programa
mov eax, 1
; Status de saída do programa
xor ebx, ebx
; Realiza a interrupção
int 0x80
CurtirCurtir
**** Exercício 1 ****
.DATA
x dw 0 ; Declaração da variável x como uma palavra (word) inicializada com 0
y dw 0 ; Declaração da variável y como uma palavra (word) inicializada com 0
z dw 0 ; Declaração da variável z como uma palavra (word) inicializada com 0
section .text
global _start
_start:
; Início
mov ax, 7 ; Move o valor 7 para o registrador ax
mov [x], ax ; Armazena o valor de ax na variável x
mov ax, 13 ; Move o valor 13 para o registrador ax
mov [y], ax ; Armazena o valor de ax na variável y
mov ax, [x] ; Move o valor da variável x para o registrador ax
mov [z], ax ; Armazena o valor de ax na variável z
mov eax, 1 ; Move o valor 1 para o registrador eax
; Fim
xor ebx, ebx ; Limpa o registrador ebx
int 0x80 ; Chama a interrupção 0x80 para encerrar o programa
**** Exercício 2 ****
.MODEL SMALL
.STACK
.CODE
section .data
x dw 5 ; Declaração da variável x como uma palavra (word) inicializada com 5
y dw 10 ; Declaração da variável y como uma palavra (word) inicializada com 10
soma dw 0 ; Declaração da variável soma como uma palavra (word) inicializada com 0
sub dw 0 ; Declaração da variável sub como uma palavra (word) inicializada com 0
section .text
global _start
_start: ; Início
; Move o valor de x para ax, adiciona 8 a ax, move o valor de ax para x
mov ax, [x] ; Move o valor da variável x para o registrador ax
add ax, 8 ; Adiciona o valor 8 ao registrador ax
mov [x], ax ; Armazena o valor de ax na variável x
; Move o valor de x para ax, adiciona o valor de y para ax e move ax para a soma
mov ax, [x] ; Move o valor da variável x para o registrador ax
add ax, [y] ; Adiciona o valor da variável y ao registrador ax
mov [soma], ax ; Armazena o valor de ax na variável soma
; Move o valor de x para ax, subtrai 3 de ax, move ax para x
mov ax, [x] ; Move o valor da variável x para o registrador ax
sub ax, 3 ; Subtrai o valor 3 do registrador ax
mov [x], ax ; Armazena o valor de ax na variável x
; Move o valor de x para ax, subtrai o valor de y de ax e move-o para subtração
mov ax, [x] ; Move o valor da variável x para o registrador ax
sub ax, [y] ; Subtrai o valor da variável y do registrador ax
mov [sub], ax ; Armazena o valor de ax na variável sub
; Move o valor 1 para eax
mov eax, 1
; Retorno ao 0 e interrupção código 0x80
xor ebx, ebx ; Limpa o registrador ebx
int 0x80 ; Chama a interrupção 0x80 para encerrar o programa
**** Exercício 3 ****
section .data
x dw 5 ; Declaração da variável x como uma palavra (word) inicializada com 5
y dw 12 ; Declaração da variável y como uma palavra (word) inicializada com 12
sqr dw 0 ; Declaração da variável sqr como uma palavra (word) inicializada com 0
dv dw 0 ; Declaração da variável dv como uma palavra (word) inicializada com 0
rest dw 0 ; Declaração da variável rest como uma palavra (word) inicializada com 0
section .text
global _start
_start: ; Início das operações
; Move x para ax, calcula ax*ax, move o resultado para a variável sqr
mov ax, [x] ; Move o valor da variável x para o registrador ax
imul ax, ax ; Multiplica o valor de ax por ele mesmo (ax*ax)
mov [sqr], ax ; Armazena o resultado do cálculo na variável sqr
; Move x para ax, estende a capacidade de bits, calcula a divisão inteira e move o resultado para dv
mov ax, [x] ; Move o valor da variável x para o registrador ax
cwd ; Estende o valor de ax para edx:eax (preparação para a divisão)
idiv word [y] ; Realiza a divisão de ax por y, armazena o quociente em ax e o resto em dx
mov [dv], ax ; Armazena o quociente da divisão na variável dv
; Move x para ax, estende ax, calcula a divisão e move o resto para a variável rest
mov ax, [x] ; Move o valor da variável x para o registrador ax
cwd ; Estende o valor de ax para edx:eax (preparação para a divisão)
idiv word [y] ; Realiza a divisão de ax por y, armazena o quociente em ax e o resto em dx
mov [rest], dx ; Armazena o resto da divisão na variável rest
; Finalização do algoritmo
mov eax, 1 ; Move o valor 1 para o registrador eax (código de saída)
xor ebx, ebx ; Limpa o registrador ebx
int 0x80 ; Chama a interrupção 0x80 para encerrar o programa
**** Exercício 4 ****
section .text
global _start
_start:
; Zera o registrador edx e move o conteúdo de ah para dl
xor edx, edx
mov dl, ah
; Realiza operações XOR entre as variáveis separadas por vírgulas
xor ah, bh
xor bh, ah
xor ah, bh
; Move o valor de dl para bh e o valor 1 para eax
mov bh, dl
mov eax, 1
; Fim do programa
xor ebx, ebx
int 0x80
**** Exercício 5 ****
_start: ; Início
; Movendo os valores iniciais para ebx e eax
mov ebx, 10 ; Move o valor 10 para o registrador ebx
mov eax, 20 ; Move o valor 20 para o registrador eax
; Mostrando a mensagem inicial
mov eax, 4 ; Número da chamada de sistema para escrever na tela
mov ebx, 1 ; Descritor de arquivo para a saída padrão (stdout)
mov ecx, msg ; Endereço da mensagem a ser escrita
mov edx, 19 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
; Invertendo os valores usando push e pop
push eax ; Empilha o valor de eax na pilha
push ebx ; Empilha o valor de ebx na pilha
pop eax ; Desempilha o valor de ebx para eax
pop ebx ; Desempilha o valor de eax para ebx
; Mostrando os valores invertidos na tela
; Valor de ebx
mov eax, 4 ; Número da chamada de sistema para escrever na tela
mov ebx, 1 ; Descritor de arquivo para a saída padrão (stdout)
mov ecx, ebx ; Valor de ebx a ser escrito na tela
add ecx, ‘0’ ; Converte o valor para o seu equivalente em caractere
mov edx, 1 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
; Valor de eax
mov eax, 4 ; Número da chamada de sistema para escrever na tela
mov ebx, 1 ; Descritor de arquivo para a saída padrão (stdout)
mov ecx, eax ; Valor de eax a ser escrito na tela
add ecx, ‘0’ ; Converte o valor para o seu equivalente em caractere
mov edx, 1 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
; Saindo do programa
mov eax, 1 ; Número da chamada de sistema para encerrar o programa
xor ebx, ebx ; Define ebx como zero
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema de encerramento
section .data
msg db ‘Valores iniciais: ebx = 10, eax = 20’, 0
**** Exercício 6 ****
section .data
; Mensagens exibidas na tela
msg db “Digite um número: “, 0
result_msg db “O fatorial é: “, 0
newline db 10, 0 ; Nova linha
section .bss
number resb 2 ; Espaço para armazenar o número digitado pelo usuário
section .text
global _start
_start:
; Exibir mensagem para digitar um número
mov eax, 4 ; Número da chamada de sistema para escrever na tela
mov ebx, 1 ; Descritor de arquivo para a saída padrão (stdout)
mov ecx, msg ; Endereço da mensagem a ser escrita
mov edx, 17 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
; Ler número do usuário
mov eax, 3 ; Número da chamada de sistema para ler da entrada padrão (stdin)
mov ebx, 0 ; Descritor de arquivo para a entrada padrão (stdin)
mov ecx, number ; Endereço do buffer para armazenar o número digitado
mov edx, 2 ; Tamanho máximo para a leitura (2 bytes)
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
; Converter número ASCII para binário
movzx eax, byte [number] ; Move o byte do número digitado para o registrador eax e estende com zeros à esquerda
sub eax, ‘0’ ; Subtrai o valor ASCII ‘0’ para obter o valor binário do número
; Verificar se o número é zero
cmp eax, 0 ; Compara o valor de eax com 0
jz print_result ; Salta diretamente para a impressão do resultado se o número for zero
; Calcular o fatorial
mov ebx, eax ; ebx = fatorial = número
mov ecx, eax ; ecx = contador = número – 1
calc_fatorial:
dec ecx ; Decrementa o contador
mul ecx ; Multiplica o fatorial pelo contador
cmp ecx, 1
jg calc_fatorial ; Repete o cálculo enquanto o contador for maior que 1
print_result:
; Exibir mensagem “O fatorial é: ”
mov eax, 4 ; Número da chamada de sistema para escrever na tela
mov ebx, 1 ; Descritor de arquivo para a saída padrão (stdout)
mov ecx, result_msg ; Endereço da mensagem a ser escrita
mov edx, 15 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
; Exibir o resultado
add eax, ‘0’ ; Converte o fatorial para ASCII, adicionando o valor ASCII ‘0’
mov [number], al ; Armazena o resultado convertido no buffer “number”
mov eax, 4 ; Número da chamada de sistema para escrever na tela
mov ebx, 1 ; Descritor de arquivo para a saída padrão (stdout)
mov ecx, number ; Endereço do buffer contendo o resultado
mov edx, 1 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80
**** Exercício 7 ****
section .data
msg db “O menor valor é: “, 0
section .text
global _start
_start:
; Movendo os valores para os registradores
mov eax, 7 ; Movendo o valor 7 para eax
mov ebx, 9 ; Movendo o valor 9 para ebx
mov ecx, 1 ; Movendo o valor 1 para ecx
mov edx, 2 ; Movendo o valor 2 para edx
; Comparando os valores para encontrar o menor
cmp eax, ebx ; Compara eax e ebx
jl check_ecx ; Salta para check_ecx se eax for menor que ebx
mov eax, ebx ; Se não for menor, move o valor de ebx para eax
check_ecx:
cmp ecx, eax ; Compara ecx e eax
jl check_edx ; Salta para check_edx se ecx for menor que eax
mov eax, ecx ; Se não for menor, move o valor de ecx para eax
check_edx:
cmp edx, eax ; Compara edx e eax
jl print_result ; Salta para print_result se edx for menor que eax
print_result:
; Exibir mensagem “O menor valor é: ”
mov eax, 4 ; Número da chamada de sistema para escrever na tela
mov ebx, 1 ; Descritor de arquivo para a saída padrão (stdout)
mov ecx, msg ; Endereço da mensagem a ser escrita
mov edx, 17 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
; Exibir o valor do menor na tela
add eax, ‘0’ ; Converte o valor para ASCII, adicionando o valor ASCII ‘0’
mov edx, 1 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
exit_program:
; Sair do programa
mov eax, 1 ; Número da chamada de sistema para encerrar o programa
xor ebx, ebx ; Define ebx como zero
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema de encerramento
**** Exercício 8 ****
section .data
result_msg db “A soma é: “, 0
section .text
global _start
_start:
; Empilhando os valores
push 10 ; Empilha o valor 10
push 5 ; Empilha o valor 5
push 1 ; Empilha o valor 1
push 50 ; Empilha o valor 50
push 14 ; Empilha o valor 14
; Soma dos valores presentes na pilha
xor eax, eax ; Limpa o registrador eax
mov ebx, esp ; ebx aponta para o topo da pilha
sum_values:
add eax, [ebx] ; Adiciona o valor apontado por ebx a eax
add ebx, 4 ; Avança para o próximo valor na pilha (4 bytes)
cmp ebx, esp ; Compara ebx com o topo da pilha
jne sum_values ; Repete a soma enquanto não chegar ao fim da pilha
; Subtrair o primeiro valor (14) da soma
sub eax, 14
; Exibir mensagem “A soma é: ”
mov eax, 4 ; Número da chamada de sistema para escrever na tela
mov ebx, 1 ; Descritor de arquivo para a saída padrão (stdout)
mov ecx, result_msg ; Endereço da mensagem a ser escrita
mov edx, 12 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
; Exibir o resultado na tela
mov ebx, eax
add ebx, ‘0’ ; Converte o valor para ASCII, adicionando o valor ASCII ‘0’
mov eax, 4 ; Número da chamada de sistema para escrever na tela
mov ecx, ebx ; Valor a ser escrito
mov edx, 1 ; Comprimento da mensagem
int 0x80 ; Chama a interrupção 0x80 para realizar a chamada de sistema
exit_program:
; Sair do programa
mov eax, 1 ; Número da chamada de sistema para encerrar o programa
xor ebx, ebx ; Define ebx como zero
int 0x80 ; Chama a interrupção 0x80
CurtirCurtir
Exercício 1
.DATA
x dw 5
y dw 10
z dw 0
section .text
global _start
_start:
mov ax, [y]
mov [z], ax
mov eax, 1
.MODEL SMALL
.STACK
.CODE
Exercício 2
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start:
mov ax, [x]
add ax, 3
mov [x], ax
Exercício 3
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start:
mov ax, [x]
imul ax, ax
mov [sqr], ax
Exercício 4
section .text
global _start
_start:
xor edx, edx
mov dl, bh
Exercício 5
section .text
global _start
_start:
mov ebx, 20
mov eax, 10
Exercício 6
section .data
msg db “Digite um número: “, 0
result_msg db “O quadrado é: “, 0
newline db 10, 0
section .bss
number resb 2
section .text
global _start
_start:
mov eax, 4
mov ebx, 1
mov ecx, msg
mov edx, 17
int 0x80
Exercício 7
section .data
msg db “O maior valor é: “, 0
section .text
global _start
_start:
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
Exercício 8
section .data
result_msg db “A subtração é: “, 0
section .text
global _start
_start:
push 10
push 5
push 1
push 50
push 14
CurtirCurtir
Exercício 1:
section .data
x dw 0
y dw 0
z dw 0
section .text
global _start
_start:
mov ax, 7 ;
mov [x], ax
mov ax, 13 ;
mov [y], ax ;
mov ax, [x] ;
mov [z], ax ;
mov eax, 1 ;
xor ebx, ebx ;
int 0x80 ;
Exercício 2:
section .data
x dw 5
y dw 10
soma dw 0
sub dw 0
section .text
global _start
_start:
mov ax, [x] ; Move o valor de x para ax
add ax, 8 ; Adiciona 8 a ax
mov [x], ax ; Move o valor de ax para x
mov ax, [x] ; Move o valor de x para ax
add ax, [y] ; Adiciona o valor de y a ax
mov [soma], ax ; Move o valor de ax para soma
mov ax, [x] ; Move o valor de x para ax
sub ax, 3 ; Subtrai 3 de ax
mov [x], ax ; Move o valor de ax para x
mov ax, [x] ; Move o valor de x para ax
sub ax, [y] ; Subtrai o valor de y de ax
mov [sub], ax ; Move o valor de ax para sub
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 3:
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start:
mov ax, [x] ; Move o valor de x para ax
imul ax, ax ; Multiplica ax por si mesmo (calcula o quadrado)
mov [sqr], ax ; Move o resultado para sqr
mov ax, [x] ; Move o valor de x para ax
cwd ; Estende o sinal de ax para dx:ax (32 bits)
idiv word [y] ; Divide dx:ax pelo valor de y (divisão inteira)
mov [dv], ax ; Move o quociente para dv
mov ax, [x] ; Move o valor de x para ax
cwd ; Estende o sinal de ax para dx:ax (32 bits)
idiv word [y] ; Divide dx:ax pelo valor de y (divisão inteira)
mov [rest], dx ; Move o resto para rest
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 4:
section .text
global _start
_start:
xor edx, edx ; Zera o registrador edx
mov dl, ah ; Move o valor de ah para dl
xor ah, bh ; Realiza a operação XOR entre ah e bh
xor bh, ah ; Realiza a operação XOR entre bh e ah
xor ah, bh ; Realiza a operação XOR entre ah e bh
mov bh, dl ; Move o valor de dl (armazenado anteriormente em ah) para bh
mov eax, 1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 5:
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
_start:
; Inversão dos valores
push eax
push ebx
pop eax
pop ebx
; Impressão dos valores invertidos
mov eax, ebx
mov ebx, 1
mov ecx, eax
mov edx, 1
mov esi, format
mov edi, 0
call printf
mov eax, 0x1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
section .data
format db “%d”, 0 ; Formato de string para imprimir números inteiros
section .text
global _start
extern printf
_start:
; Inversão dos valores
push eax
push ebx
pop eax
pop ebx
; Impressão dos valores invertidos
mov eax, ebx
mov ebx, 1
mov ecx, eax
mov edx, 1
mov esi, format
mov edi, 0
call printf
mov eax, 0x1 ; Número do sistema de chamada para sys_exit
xor ebx, ebx ; Código de retorno 0
int 0x80 ; Chama a interrupção 0x80 para sair do programa
Exercício 6:
section .data
prompt db “Digite um número: “, 0
result db “O fatorial é: “, 0
newline db 10, 0
section .bss
number resb 2
section .text
global _start
extern printf, scanf
_start:
; Imprimir prompt para digitar o número
mov eax, 0
mov ebx, 1
mov ecx, prompt
mov edx, 17
int 0x80
; Ler o número fornecido pelo usuário
mov eax, 3
mov ebx, 0
mov ecx, number
mov edx, 2
int 0x80
; Converter o número ASCII para um valor numérico
sub byte [number], ‘0’
; Calcular o fatorial
movzx eax, byte [number]
mov ecx, eax
dec ecx
mov edx, eax
cmp eax, 0
je print_result
loop_start:
mul ecx
loop loop_start
print_result:
; Imprimir o resultado do fatorial
push eax
push result
call printf
add esp, 8
; Imprimir uma nova linha
push newline
call printf
add esp, 4
; Encerrar o programa
mov eax, 1
xor ebx, ebx
int 0x80
Exercício 7:
section .data
values db “7”, “9”, “1”, “2”, 0
format db “O menor valor é: %d”, 10, 0
section .text
global _start
extern printf, sscanf
_start:
; Ler os valores fornecidos
mov eax, values
mov ebx, “%d”
lea ecx, [ebp-4]
push ecx
push ebx
push eax
call sscanf
add esp, 12
; Comparar os valores para encontrar o menor
mov eax, [ebp-4]
mov ebx, [ebp-8]
cmp eax, ebx
jge check_c
mov eax, ebx
check_c:
mov ecx, [ebp-12]
cmp ecx, eax
jge check_d
mov eax, ecx
check_d:
mov edx, [ebp-16]
cmp edx, eax
jge print_result
mov eax, edx
print_result:
; Imprimir o menor valor
push eax
push format
call printf
add esp, 8
; Encerrar o programa
mov eax, 1
xor ebx, ebx
int 0x80
Exercício 8:
section .data
format db “A soma é: %d”, 10, 0
section .text
global _start
extern printf
_start:
; Realizar a soma dos valores abaixo da pilha
mov eax, 0
add eax, [esp+20]
add eax, [esp+16]
add eax, [esp+12]
add eax, [esp+8]
add eax, [esp+4]
; Subtrair o primeiro valor (14) da soma
sub eax, 14
; Imprimir o resultado da soma
push eax
push format
call printf
add esp, 8
; Encerrar o programa
mov eax, 1
xor ebx, ebxint 0x80
CurtirCurtir
Exercício 01 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
Utilizando Instruções Aritméticas adição e subtração:
Fonte: Professora Roberta L. G., 2021.
Resposta:
section .data
a dw 5
b dw 10
c dw 0
section .text
global _start
_start:
mov ax, [a]
add ax, [b]
mov [c], ax
; Encerrar o programa (caso esteja rodando em Linux com NASM + ld)
mov eax, 1
int 0x80
Exercício 02 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
Utilizando Instruções Aritméticas multiplicação e divisão:
Fonte: Professora Roberta L. G., 2021.
Resposta:
section .data
a dw 20
b dw 8
c dw 0
section .text
global _start
_start:
mov ax, [a]
sub ax, [b]
mov [c], ax
; Fim
mov eax, 1
int 0x80
Exercício 03 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
Utilizando Instruções Aritméticas XOR, AND, OR, NOT:
Fonte: Professora Roberta L. G., 2021.
Resposta:
section .data
a dw 6
b dw 3
c dw 0
section .text
global _start
_start:
mov ax, [a]
mov bx, [b]
mul bx ; ax = ax * bx (resultado em AX)
mov [c], ax
; Fim
mov eax, 1
int 0x80
Exercício 04 – Implemente um trecho de código em Assembly que que troque o valor do registrador AH com o valor do registrador BH. Utilize apenas instruções lógicas XOR. Você pode utilizar outros registradores para guardar valores intermediários.
Fonte: Professora Roberta L. G., 2021.
Resposta:
section .text
global _start
_start:
mov ah, 5
mov bh, 9
; Troca usando XOR
xor ah, bh
xor bh, ah
xor ah, bh
; Fim
mov eax, 1
int 0x80
Exercício 05 – Faça um programa em “nasm” que inverta os valores de mov ebx, 10 e mov eax, 20. Utilize os comandos abaixo para realizar a inversão. Após, mostre os resultados invertidos na tela.
Resposta:
section .text
global _start
_start:
mov ebx, 10
mov eax, 20
; Inverter
xchg eax, ebx
; Fim
mov eax, 1
int 0x80
Exercício 06 – Faça um programa em “nasm” que calcule o fatorial de um número.
Resposta:
section .data
num dw 5
res dw 1
section .text
global _start
_start:
mov cx, [num]
mov ax, 1
fatorial_loop:
mul cx
loop fatorial_loop
mov [res], ax
; Fim
mov eax, 1
int 0x80
Exercício 07 – Faça um programa em “nasm” que leia os valores apresentados abaixo, em seguida mostre o menor valor.
Resposta:
section .data
val1 dw 10
val2 dw 3
val3 dw 7
menor dw 0
section .text
global _start
_start:
mov ax, [val1]
mov bx, [val2]
cmp ax, bx
jle menor1
mov ax, bx
menor1:
mov bx, [val3]
cmp ax, bx
jle menor2
mov ax, bx
menor2:
mov [menor], ax
; Fim
mov eax, 1
int 0x80
Exercício 08 – Faça um programa em “nasm” que some os valores abaixo da pilha e retire da soma o primeiro valor (14).
Resposta:
section .text
global _start
_start:
; Empilhar valores
push 14
push 6
push 10
push 3
; Desempilhar e somar
pop ax ; 3
pop bx ; 10
add ax, bx
pop bx ; 6
add ax, bx
pop bx ; 14
sub ax, bx ; ax = (3+10+6) – 14 = 5
; Fim
mov eax, 1
int 0x80
CurtirCurtir
Aluna: Elidia Cristina Moraes Moura
Ex1:global _mainextern _printfsection .text
_main:
mov word[x], 7 mov word[y], 13 mov DX, word[x] mov word[z], DX push message call _printf add esp, 4 retsection .data
x: dw 0y: dw 0z: dw 0message: db 10, 10, 10
Ex2:global _mainextern _printfsection .text
_main:
add word[x], 8 mov DX, word[x] add DX, word[y] mov word[soma], DX sub word[x], 3 mov DX, word[x] sub DX, word[y] mov word[sub], DXsection .data
x: dw 5y: dw 10soma: dw 0sub: dw 0
Ex;3:
global _main
extern _printf
section .text
_main:
mov AL, byte[x]
mul byte[x]
mov byte[sqr], AX
mov AL, byte[x]
mov AH, 0
div byte[y]
mov byte[dv], AL mov byte[rest], AH push message call _printf add esp, 4 retsection .data
x: db 15
y: db 12
sqr: dw 0
dv: db 0
rest: db 0
Ex4:global _mainextern _printfsection .text
_main:
xor DH, DH xor DH, AH xor AH, AH xor AH, BH xor BH, BH xor BH, DHEx5:global _mainextern _printfsection .text
_main:
mov ebx, 10
mov eax, 20
push eax
push ebx
pop eax
pop ebx
push eax
push valor
call _printf add esp, 8 push ebx push valor1 call _printf add esp, 8section .data
valor: db “Valor: eax = %d”, 10,0valor1: db “Valor 1: ebx = %d”, 0
Ex6:global _mainextern _printfextern _scanfsection .text
_main:
push x push formato call _scanf add esp, 8 xor eax, eax mov eax, 1 mov ecx, [x]loop1:mul ecx dec ecx cmp ecx, 0 ja loop1 push eax push message call _printf add esp, 8 ret
section .data
x: times 4 db 0formato: db “%d”, 0message: db “O valor e %d”, 10,0
Ex7:global _mainextern _printfsection .text
_main:
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
cmp eax, ebx jb menorValor1 mov eax, ebxmenorValor1:cmp eax, ecx jb menorValor2 mov eax, ecx
menorValor2:cmp eax, edx jb finalValor mov eax, edx
finalValor:push eax push formato call _printf add esp, 8
section .data
formato: db “Menor valor eh %d”, 10,0
CurtirCurtir
Exercício 01 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
.MODEL SMALL
.STACK
.DATA
x dw ?
y dw ?
z dw ?
.CODE
MOV AX, @DATA
MOV DS, AX
MOV x, 7
MOV y, 13
MOV AX, x
MOV z, AX
END
Utilizando Instruções Aritméticas adição e subtração:
Fonte: Professora Roberta L. G., 2021.
Exercício 02 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
.MODEL SMALL
.STACK
.DATA
x dw 5
y dw 10
soma dw ?
sub dw ?
.CODE
MOV AX, @DATA
MOV DS, AX
MOV AX, x
ADD AX, y
MOV soma, AX
MOV AX, x
SUB AX, y
MOV sub, AX
END
Utilizando Instruções Aritméticas multiplicação e divisão:
Fonte: Professora Roberta L. G., 2021.
Exercício 03 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
Fonte: Professora Roberta L. G., 2021.
.MODEL SMALL
.STACK
.DATA
x db 5
y db 12
sqr dw ?
dv db ?
rest db ?
.CODE
MOV AX, @DATA
MOV DS, AX
; sqr = x * x
MOV AL, x
MUL AL ; AX = AL * AL
MOV sqr, AX
; dv = x / y
MOV AL, x
MOV AH, 0
DIV y
MOV dv, AL
MOV rest, AH
END
Utilizando Instruções Aritméticas XOR, AND, OR, NOT:
Fonte: Professora Roberta L. G., 2021.
Exercício 04 – Implemente um trecho de código em Assembly que que troque o valor do registrador AH com o valor do registrador BH. Utilize apenas instruções lógicas XOR. Você pode utilizar outros registradores para guardar valores intermediários.
Fonte: Professora Roberta L. G., 2021.
.MODEL SMALL
.STACK
.DATA
.CODE
; Suponha que AH e BH já tenham valores
XOR DH, DH ; DH = 0
XOR DH, AH ; DH = AH
XOR AH, AH ; AH = 0
XOR AH, BH ; AH = BH
XOR BH, BH ; BH = 0
XOR BH, DH ; BH = antigo AH
END
Exercício 05 – Faça um programa em “nasm” que inverta os valores de mov ebx, 10 e mov eax, 20. Utilize os comandos abaixo para realizar a inversão. Após, mostre os resultados invertidos na tela.
.MODEL SMALL
.STACK 100H
.DATA
.CODE
MOV EBX, 10
MOV EAX, 20
PUSH EAX
PUSH EBX
POP EAX
POP EBX
; Agora EBX = 20, EAX = 10
END
Exercício 06 – Faça um programa em “nasm” que calcule o fatorial de um número.
.MODEL SMALL
.STACK
.DATA
num dw 5
fat dw 1
.CODE
MOV AX, @DATA
MOV DS, AX
MOV CX, num ; contador
MOV AX, 1 ; resultado parcial
fatorial_loop:
MUL CX ; AX = AX * CX
LOOP fatorial_loop
MOV fat, AX
END
Exercício 07 – Faça um programa em “nasm” que leia os valores apresentados abaixo, em seguida mostre o menor valor.
.MODEL SMALL
.STACK
.DATA
a db 15
b db 8
c db 12
menor db ?
.CODE
MOV AX, @DATA
MOV DS, AX
MOV AL, a
CMP AL, b
JLE check_c
MOV AL, b
check_c:
CMP AL, c
JLE fim
MOV AL, c
fim:
MOV menor, AL
END
Exercício 08 – Faça um programa em “nasm” que some os valores abaixo da pilha e retire da soma o primeiro valor (14).
.MODEL SMALL
.STACK 100H
.DATA
resultado dw ?
.CODE
MOV AX, @DATA
MOV DS, AX
PUSH 10
PUSH 5
PUSH 1
PUSH 50
PUSH 14
POP AX ; AX = 14 (primeiro valor, que será subtraído no fim)
MOV BX, AX ; BX = 14
POP AX ; AX = 50
POP CX ; CX = 1
ADD AX, CX
POP CX ; CX = 5
ADD AX, CX
POP CX ; CX = 10
ADD AX, CX
SUB AX, BX ; AX = soma – 14
MOV resultado, AX
END
CurtirCurtir
Exercicio 1
section .data
msg_a db ‘Digite o valor de a: ‘, 10
len_a equ $ – msg_a
msg_b db ‘Digite o valor de b: ‘, 10
len_b equ $ – msg_b
msg_c db ‘Resultado (c = a + b): ‘
len_c equ $ – msg_c
newline db ”, 10
section .bss
; Buffers para I/O
input_buffer resb 16 ; Buffer para ler o texto
output_buffer resb 16 ; Buffer para imprimir o texto
; Variáveis a resd 1 ; 4 bytes (define dword) b resd 1section .text
global _start
_start:
; Pedir ‘a’
mov eax, 4
mov ebx, 1
mov ecx, msg_a
mov edx, len_a
int 0x80
; Ler 'a' call _read_number mov [a], eax ; Salva o número convertido em 'a' ; Pedir 'b' mov eax, 4 mov ebx, 1 mov ecx, msg_b mov edx, len_b int 0x80 ; Ler 'b' call _read_number mov [b], eax ; Salva o número convertido em 'b' ; Calcular c = a + b mov eax, [a] ; eax = a add eax, [b] ; eax = a + b ; Imprimir a mensagem 'Resultado' mov eax, 4 mov ebx, 1 mov ecx, msg_c mov edx, len_c int 0x80 ; Imprimir o número (resultado está em EAX) call _print_number call _exit;
; Função _read_number: Lê da tela e converte ASCII para Inteiro
; Resultado: fica em EAX
_read_number:
; Ler a string do teclado (sys_read)
mov eax, 3
mov ebx, 0 ; stdin
mov ecx, input_buffer
mov edx, 16 ; max 16 bytes
int 0x80
; EAX agora tem o número de bytes lidos, vamos usá-lo mov esi, input_buffer ; Ponteiro para a string xor eax, eax ; EAX = 0 (nosso resultado) xor ecx, ecx ; ECX = 0 (dígito atual)atoi_loop:
mov cl, [esi] ; Pega o caractere
inc esi ; Avança o ponteiro
cmp cl, 10 ; É o 'Enter' (newline)? je atoi_done ; Se sim, termina cmp cl, '0' ; É menor que '0'? jl atoi_loop ; Se sim, ignora (não é dígito) cmp cl, '9' ; É maior que '9'? jg atoi_loop ; Se sim, ignora (não é dígito) ; Converter caractere para dígito sub cl, '0' ; '5' (53) - '0' (48) = 5 ; Multiplicar resultado por 10 mov edx, 10 mul edx ; EAX = EAX * 10 ; Adicionar o novo dígito add eax, ecx jmp atoi_loop ; Próximo caractereatoi_done:
ret
; Função _print_number: Converte Inteiro para ASCII e imprime
; Entrada: EAX (número a ser impresso)
_print_number:
; ESI aponta para o FIM do buffer de saída
mov esi, output_buffer + 15
mov byte [esi], 10 ; Adiciona um ‘newline’ (Enter) no final
dec esi
mov ebx, 10 ; Divisor ; Caso especial: se EAX for 0 cmp eax, 0 jne itoa_loop mov byte [esi], '0' ; Coloca '0' no buffer dec esi jmp itoa_printitoa_loop:
xor edx, edx ; Zera EDX (MUITO importante para divisão)
div ebx ; EAX = EAX / 10 (Quociente em EAX, Resto em EDX)
add edx, '0' ; Converte o resto (dígito) para ASCII mov [esi], dl ; Salva no buffer dec esi ; Move o ponteiro para trás cmp eax, 0 ; O quociente é 0? jne itoa_loop ; Se não, continua dividindoitoa_print:
inc esi ;
_exit:
mov eax, 1 ; sys_exit
xor ebx, ebx
int 0x80
;
Exercicio 2
;
section .text
global _start
_start:
; Pedir ‘a’
mov eax, 4
mov ebx, 1
mov ecx, msg_a
mov edx, len_a
int 0x80
; Ler 'a' call _read_number mov [a], eax ; Pedir 'b' mov eax, 4 mov ebx, 1 mov ecx, msg_b mov edx, len_b int 0x80 ; Ler 'b' call _read_number mov [b], eax ; Calcular c = a - b mov eax, [a] ; eax = a sub eax, [b] ; <<<<<<< MUDANÇA AQUI (SUB em vez de ADD) ; Imprimir a mensagem 'Resultado' mov eax, 4 mov ebx, 1 mov ecx, msg_c ; (Altere a msg_c em .data para 'c = a - b') mov edx, len_c int 0x80 ; Imprimir o número (resultado está em EAX) call _print_number call _exit;
Exercicio 3
section .data
msg_a db ‘Digite ‘a’ (dividendo): ‘, 10
len_a equ $ – msg_a
msg_b db ‘Digite ‘b’ (divisor): ‘, 10
len_b equ $ – msg_b
msg_q db ‘Quociente: ‘
len_q equ $ – msg_q
msg_r db ‘Resto: ‘
len_r equ $ – msg_r
newline db ”, 10
section .bss
input_buffer resb 16
output_buffer resb 16
a resd 1
b resd 1
section .text
global _start
_start:
; Pedir e Ler ‘a’
mov eax, 4
mov ebx, 1
mov ecx, msg_a
mov edx, len_a
int 0x80
call _read_number
mov [a], eax
; Pedir e Ler 'b' mov eax, 4 mov ebx, 1 mov ecx, msg_b mov edx, len_b int 0x80 call _read_number mov [b], eax ; Calcular a / b mov eax, [a] ; EAX = dividendo mov ebx, [b] ; EBX = divisor xor edx, edx ; ZERAR EDX (MUITO IMPORTANTE para divisão) div ebx ; Divisão (EAX = EAX / EBX) ; Resultado: Quociente em EAX, Resto em EDX ; Imprimir Quociente (está em EAX) mov eax, 4 mov ebx, 1 mov ecx, msg_q mov edx, len_q int 0x80 ; EAX já tem o quociente call _print_number ; Imprime EAX e uma newline ; Imprimir Resto (está em EDX) mov eax, 4 mov ebx, 1 mov ecx, msg_r mov edx, len_r int 0x80 mov eax, edx ; Mover o resto para EAX para impressão call _print_number ; Imprime EAX e uma newline call _exit;
Exercicio 4
section .data
msg_a db ‘Digite o primeiro numero (a): ‘, 10
len_a equ $ – msg_a
msg_b db ‘Digite o segundo numero (b): ‘, 10
len_b equ $ – msg_b
msg_swap_a db ‘Trocado – ‘a’ agora e: ‘
len_swap_a equ $ – msg_swap_a
msg_swap_b db ‘Trocado – ‘b’ agora e: ‘
len_swap_b equ $ – msg_swap_b
newline db ”, 10
section .bss
input_buffer resb 16
output_buffer resb 16
;
section .text
global _start
_start:
; Pedir e Ler ‘a’ -> EAX
mov eax, 4
mov ebx, 1
mov ecx, msg_a
mov edx, len_a
int 0x80
call _read_number
mov esi, eax ; Salva o primeiro número em ESI
; Pedir e Ler 'b' -> EAX mov eax, 4 mov ebx, 1 mov ecx, msg_b mov edx, len_b int 0x80 call _read_number mov edi, eax ; Salva o segundo número em EDI ; ESI = a, EDI = b ; Troca (Swap) com XOR xor esi, edi xor edi, esi xor esi, edi ; ESI = b, EDI = a ; Imprimir 'a' (que agora é EDI) mov eax, 4 mov ebx, 1 mov ecx, msg_swap_a mov edx, len_swap_a int 0x80 mov eax, edi ; Mover valor trocado para EAX call _print_number ; Imprimir 'b' (que agora é ESI) mov eax, 4 mov ebx, 1 mov ecx, msg_swap_b mov edx, len_swap_b int 0x80 mov eax, esi ; Mover valor trocado para EAX call _print_number call _exit;
Exercicio 5
section .data
msg_a db ‘Digite o primeiro numero (a): ‘, 10
len_a equ $ – msg_a
msg_b db ‘Digite o segundo numero (b): ‘, 10
len_b equ $ – msg_b
msg_swap_a db ‘Trocado – ‘a’ agora e: ‘
len_swap_a equ $ – msg_swap_a
msg_swap_b db ‘Trocado – ‘b’ agora e: ‘
len_swap_b equ $ – msg_swap_b
newline db ”, 10
section .bss
input_buffer resb 16
output_buffer resb 16
section .text
global _start
_start:
; Pedir e Ler ‘a’ -> EAX
mov eax, 4
mov ebx, 1
mov ecx, msg_a
mov edx, len_a
int 0x80
call _read_number
; EAX contém o primeiro número
; Pedir e Ler 'b' -> EBX mov eax, 4 mov ebx, 1 mov ecx, msg_b mov edx, len_b int 0x80 call _read_number mov ebx, eax ; Salva o segundo número em EBX ; EAX = a (lido primeiro), EBX = b (lido por último) ; Troca (Swap) com Pilha push eax push ebx pop eax pop ebx ; EAX = b, EBX = a ; Imprimir 'a' (que agora é EAX) mov eax, 4 mov ebx, 1 mov ecx, msg_swap_a mov edx, len_swap_a int 0x80 ; EAX já tem o valor trocado call _print_number ; Imprimir 'b' (que agora é EBX) mov eax, 4 mov ebx, 1 mov ecx, msg_swap_b mov edx, len_swap_b int 0x80 mov eax, ebx ; Mover valor trocado para EAX call _print_number call _exit;
Exercicio 6
section .data
msg_n db ‘Digite um numero para calcular o fatorial (0-12): ‘, 10
len_n equ $ – msg_n
msg_r db ‘O fatorial e: ‘
len_r equ $ – msg_r
newline db ”, 10
section .bss
input_buffer resb 16
output_buffer resb 16
section .text
global _start
_start:
; Pedir número
mov eax, 4
mov ebx, 1
mov ecx, msg_n
mov edx, len_n
int 0x80
; Ler número call _read_number ; EAX contém o N. ECX será o contador. mov ecx, eax ; EAX será o resultado. mov eax, 1 ; Caso especial: 0! ou 1! cmp ecx, 1 jle loop_done ; Se N for 0 ou 1, o resultado é 1 (já em EAX)loop_fat:
mul ecx ; EAX = EAX * ECX
dec ecx ; Decrementa o contador
cmp ecx, 1 ; Compara com 1
jg loop_fat ; Se (ECX > 1), continua
loop_done:
; Imprimir mensagem
mov eax, 4
mov ebx, 1
mov ecx, msg_r
mov edx, len_r
int 0x80
; Imprimir resultado (que está em EAX) call _print_number call _exit;
Exercicio 7
section .data
msg_qnt db ‘Quantos numeros voce quer comparar? ‘, 10
len_qnt equ $ – msg_qnt
msg_num db ‘Digite um numero: ‘, 10
len_num equ $ – msg_num
msg_menor db ‘O menor valor digitado foi: ‘
len_menor equ $ – msg_menor
newline db ”, 10
section .bss
input_buffer resb 16
output_buffer resb 16
section .text
global _start
_start:
; Perguntar quantos números
mov eax, 4
mov ebx, 1
mov ecx, msg_qnt
mov edx, len_qnt
int 0x80
call _read_number mov ecx, eax ; ECX = Contador (N) ; EBX guardará o menor número. ; Inicializamos com o maior valor 32-bit possível (0x7FFFFFFF) mov ebx, 0x7FFFFFFFloop_min:
; Pedir o próximo número
mov eax, 4
mov ebx, 1
mov ecx, msg_num
mov edx, len_num
int 0x80
; Ler o número call _read_number ; EAX tem o número atual cmp eax, ebx ; Compara EAX (num) com EBX (menor) jge proximo ; Se num >= menor, pule mov ebx, eax ; Novo menor encontrado, atualiza EBXproximo:dec ecx ; Decrementa o contador Ncmp ecx, 0jne loop_min ; Se N != 0, pede próximo número; Imprimir resultado mov eax, 4 mov ebx, 1 mov ecx, msg_menor mov edx, len_menor int 0x80 mov eax, ebx ; Mover o menor (de EBX) para EAX call _print_number call _exit
;
Exercicio 8
section .data
msg_qnt db ‘Quantos numeros (N)? ‘, 10
len_qnt equ $ – msg_qnt
msg_num db ‘Digite um numero: ‘, 10
len_num equ $ – msg_num
msg_soma db ‘Soma (exceto o primeiro): ‘
len_soma equ $ – msg_soma
newline db ”, 10
section .bss
input_buffer resb 16
output_buffer resb 16
section .text
global _start
_start:
; Perguntar quantos números
mov eax, 4
mov ebx, 1
mov ecx, msg_qnt
mov edx, len_qnt
int 0x80
call _read_number mov ecx, eax ; ECX = Contador (N) mov edi, eax ; EDI = Salva N para usar depoisloop_push:
; Pedir o número
mov eax, 4
mov ebx, 1
mov ecx, msg_num
mov edx, len_num
int 0x80
; Ler o número call _read_number push eax ; Empilha o número dec ecx ; Decrementa o contador cmp ecx, 0 jne loop_push ; Se N != 0, pede próximo número ; Agora vamos desempilhar e somar mov ecx, edi ; Restaura N (de EDI) para ECX mov ebx, 0 ; EBX = Somaloop_pop:
pop eax ; Pega o valor do topo
; O exercício pede para ignorar o *primeiro* valor (14). ; O primeiro a ser empilhado é o último a sair. cmp ecx, 1 je proximo_pop ; Se for o último (ECX=1), não soma add ebx, eax ; Somaproximo_pop:
dec ecx
cmp ecx, 0
jne loop_pop
; Imprimir resultado mov eax, 4 mov ebx, 1 mov ecx, msg_soma mov edx, len_soma int 0x80 mov eax, ebx ; Mover a soma (de EBX) para EAX call _print_number call _exit;
CurtirCurtir
;Douglas Silva Monteiro
;1 ////////////////////
.MODEL SMALL
.STACK 100h
.DATA
x dw ?
y dw ?
z dw ?
.CODE
main:
mov x, 7
mov y, 13
mov AX, x
mov z, AX
mov AX, 4C00h
int 21h
END main
;2 /////////////////
.MODEL SMALL
.STACK 100h
.DATA
x dw 5 ; unsigned int x = 5;
y dw 10 ; unsigned int y = 10;
soma dw ? ; unsigned int soma;
sub dw ? ; unsigned int sub;
.CODE
main:
; 1. x = x + 8;
add x, 8
; 2. soma = x + y; (x e y são de memória, então use AX como intermediário)
mov AX, x
add AX, y
mov soma, AX
; 3. x = x – 3;
sub x, 3
; 4. sub = x – y; (x e y são de memória, então use AX como intermediário)
mov AX, x
sub AX, y
mov sub, AX
; Fim do programa
mov AX, 4C00h
int 21h
END main
;3//////////////////////////
.MODEL SMALL
.STACK 100h
.DATA
x db 5
y db 12
sqr dw ?
dv db ?
rest db ?
.CODE
main:
; 1. sqr = x * x
mov AL, x
mul x
mov sqr, AX
mov AL, x
mov AH, 0
div y
mov dv, AL
mov rest, AH
mov AX, 4C00h
int 21h
END main
;4////////////////////
xor AH, BH
xor BH, AH
xor AH, BH
;5/////////////////
; Usando sintaxe Intel/NASM 32-bit (flat model)
section .data
msg_eax db “EAX invertido: “, 0
msg_ebx db “EBX invertido: “, 0
section .bss
buffer resb 12 ; Buffer para armazenar a string do número
section .text
global _start
_start:
; 1. Inicialização dos valores
mov ebx, 10
mov eax, 20
; 2. Inversão usando PUSH/POP
push eax ; Salva o valor de EAX (20) na Pilha
push ebx ; Salva o valor de EBX (10) na Pilha
; Estrutura da Pilha (LIFO – Last In, First Out):
; TOP -> [10 (EBX)]
; [20 (EAX)]
pop eax ; Retira o último valor (10) da Pilha para EAX. EAX = 10 (Valor original de EBX)
pop ebx ; Retira o próximo valor (20) da Pilha para EBX. EBX = 20 (Valor original de EAX)
; Resultados invertidos: EAX = 10, EBX = 20
; 3. Mostrar os resultados na tela (Funções de exemplo para 32-bit/Linux)
; O código para exibir o valor numérico em string é longo e complexo
; e é omitido aqui para manter o foco nas instruções PUSH/POP,
; mas a lógica de chamada do sistema seria:
; (Exibir EBX)
; mov eax, 4 ; sys_write
; mov ebx, 1 ; stdout
; mov ecx, msg_ebx
; mov edx, 15
; int 0x80
; (Exibir o valor de EBX – Requer conversão binário-ASCII)
; (Exibir EAX)
; mov eax, 4 ; sys_write
; mov ebx, 1 ; stdout
; mov ecx, msg_eax
; mov edx, 15
; int 0x80
; (Exibir o valor de EAX – Requer conversão binário-ASCII)
; 4. Saída do programa
mov eax, 1 ; sys_exit
xor ebx, ebx ; Código de saída 0
int 0x80
;6///////////////////////////////////////
; Define o número para o qual o fatorial será calculado (5! = 120)
%define NUMERO 5
section .data
; Variável para armazenar o resultado final do fatorial
resultado dd 0
section .text
global _start
_start:
; Inicializa ECX com o número para ser o contador do loop
mov ecx, NUMERO
; Inicializa EAX com 1, que é o valor inicial do fatorial (1! ou 0!)
; EAX será o acumulador do resultado
mov eax, 1
; Rótulo do loop de cálculo
fatorial_loop:
; Multiplica EAX (resultado acumulado) por ECX (contador atual)
; IMUL: EAX = EAX * ECX
imul ecx
; Decrementa ECX e salta para ‘fatorial_loop’ se ECX não for zero
; A instrução LOOP faz duas coisas:
; 1. dec ecx
; 2. jnz fatorial_loop
loop fatorial_loop
; O resultado (120) está em EAX
; Move o resultado para a variável de memória
mov [resultado], eax
; Fim do programa (Syscall de saída)
mov eax, 1 ; sys_exit
xor ebx, ebx ; Código de saída 0
int 0x80
;7////////////////////////////////////////
; Usando sintaxe Intel/NASM 32-bit (flat model)
section .data
; Variável para armazenar o menor valor (opcional, mas bom para referência)
menor_valor dd 0
section .text
global _start
_start:
; 1. Inicialização dos valores
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
; Inicializamos o menor valor provisório em EAX (7)
; O menor valor encontrado estará sempre em EAX
; 2. Comparar EAX (7) com EBX (9)
cmp eax, ebx ; Compara EAX com EBX
jle proximo_ecx ; Jump if Less or Equal: Se EAX <= EBX, EAX é menor (ou igual), vai para próxima comparação. mov eax, ebx ; Se EAX > EBX, EBX é o novo menor valor, move EBX para EAX.
proximo_ecx:
; 3. Comparar EAX (agora 7) com ECX (1)
cmp eax, ecx ; Compara EAX com ECX
jle proximo_edx ; Jump if Less or Equal: Se EAX <= ECX, EAX é menor (ou igual), vai para próxima comparação. mov eax, ecx ; Se EAX > ECX, ECX é o novo menor valor, move ECX para EAX.
proximo_edx:
; 4. Comparar EAX (agora 1) com EDX (2)
cmp eax, edx ; Compara EAX com EDX
jle fim_programa ; Jump if Less or Equal: Se EAX <= EDX, EAX é o menor, termina. mov eax, edx ; Se EAX > EDX, EDX é o novo menor valor, move EDX para EAX.
fim_programa:
; Neste ponto, EAX contém o menor valor (1)
mov [menor_valor], eax ; Salva o resultado na variável de memória
; 5. Saída do programa (Syscall de saída)
mov eax, 1 ; sys_exit
xor ebx, ebx ; Código de saída 0
int 0x80
;8 /////////////////
; Usando sintaxe Intel/NASM 32-bit (flat model)
section .data
; Variável para armazenar o resultado final (52)
resultado dd 0
section .text
global _start
_start:
; 1. Empilha os valores (o 14 é o primeiro, mas o topo é o 14)
push 10
push 5
push 1
push 50
push 14
; 2. Somar os valores (10 + 5 + 1 + 50)
; Esses valores estão “abaixo” na pilha, logo, é preciso retirar (POP) os valores de cima.
; POP para retirar o valor a ser subtraído (14) e movê-lo para EBX
pop ebx ; EBX = 14 (Primeiro valor empilhado. O topo)
; POPs e ADDs para somar os quatro valores de baixo (50, 1, 5, 10).
; A soma será acumulada em EAX.
pop eax ; EAX = 50
pop ecx ; ECX = 1
add eax, ecx ; EAX = 50 + 1 = 51
pop ecx ; ECX = 5
add eax, ecx ; EAX = 51 + 5 = 56
pop ecx ; ECX = 10
add eax, ecx ; EAX = 56 + 10 = 66 (Soma dos 4 valores de baixo)
; 3. Retirar da soma o primeiro valor (14)
; EAX (Soma = 66) – EBX (14)
sub eax, ebx ; EAX = 66 – 14 = 52
; O resultado (52) está em EAX
mov [resultado], eax ; Salva o resultado final na variável de memória
; 4. Saída do programa (Syscall de saída)
mov eax, 1 ; sys_exit
xor ebx, ebx ; Código de saída 0
int 0x80
CurtirCurtir
Aluno: Gustavo Rocha Barreto
RA: 2312573
Exercício 01 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
.MODEL SMALL
.STACK
.DATA
x dw ?
y dw ?
z dw ?
.CODE
mov x, 7
mov y, 13
mov DX, x
mov z, DX
mov AH, 4Ch
int 21h
END
Exercício 02 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
R:
.MODEL SMALL
.STACK
.CODE
; — Início do main() —
add x, 8 ; x = x + 8;
mov DX, x ; DX = x
add DX, y ; DX = DX + y (Agora DX = x + y)
mov soma, DX ; soma = DX
sub x, 3 ; x = x – 3;
mov DX, x ; DX = x
sub DX, y ; DX = DX – y (Agora DX = x – y)
mov sub, DX ; sub = DX
; — Finalização do Programa —
mov AH, 4Ch
int 21h
.DATA
x dw 5
y dw 10
soma dw ?
sub dw ?
END
Exercício 03 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
R:
.MODEL SMALL
.STACK
.CODE
mov AL, x
mul x
mov sqr, AX
mov AL, x
mov AH, 0
div y
mov dv, AL
mov rest, AH
mov AH, 4Ch
int 21h
.DATA
x db 5
y db 12
sqr dw ?
dv db ?
rest db ?
END
Exercício 04 – Implemente um trecho de código em Assembly que que troque o valor do registrador AH com o valor do registrador BH. Utilize apenas instruções lógicas XOR. Você pode utilizar outros registradores para guardar valores intermediários.
R:
.MODEL SMALL
.STACK
.CODE
mov AL, x
mul x
mov sqr, AX
mov AL, x
mov AH, 0
div y
mov dv, AL
mov rest, AH
mov BH, 10d
xor AH, BH
xor BH, AH
xor AH, BH
mov AH, 4Ch
int 21h
.DATA
x db 5
y db 12
sqr dw ?
dv db ?
rest db ?
END
Exercício 05 – Faça um programa em “nasm” que inverta os valores de mov ebx, 10 e mov eax, 20. Utilize os comandos abaixo para realizar a inversão. Após, mostre os resultados invertidos na tela.
R:
.MODEL SMALL
.STACK
.DATA
; Não precisamos de variáveis de dados se só vamos usar registradores
.CODE
; Inicialização dos valores (Como pedido no enunciado)
mov BX, 10d ; Usando registradores de 16 bits (BX, AX) para Small Model
mov AX, 20d
; Inversão dos valores
push AX ; Salva AX (20) na pilha
push BX ; Salva BX (10) na pilha
pop AX ; AX recebe o topo da pilha (10)
pop BX ; BX recebe o próximo valor (20)
; Finalização do programa (Retorno ao DOS)
mov AH, 4Ch
int 21h
END
Exercício 06 – Faça um programa em “nasm” que calcule o fatorial de um número.
R:
.MODEL SMALL
.STACK
.DATA
NUM DW 5
FAT DW 1
.CODE
START:
mov AX, 1
mov CX, NUM
CALC_LOOP:
mul CX
loop CALC_LOOP
mov FAT, AX
mov AH, 4Ch
int 21h
END START
Exercício 07 – Faça um programa em “nasm” que leia os valores apresentados abaixo, em seguida mostre o menor valor.
R:
section .data
msg db “O menor valor e: “, 0
len equ $ – msg
newline db “”, 0Ah
section .bss
resultado resb 2
section .text
global _start
_start:
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
cmp eax, ebx
jle .pular_ebx
mov eax, ebx
.pular_ebx:
cmp eax, ecx
jle .pular_ecx
mov eax, ecx
.pular_ecx:
cmp eax, edx
jle .pular_edx
mov eax, edx
.pular_edx:
movzx ebx, al
add bl, ‘0’
mov byte [resultado], bl
mov byte [resultado+1], 0Ah
mov edx, len
mov ecx, msg
mov ebx, 1
mov eax, 4
int 0x80
mov edx, 2
mov ecx, resultado
mov ebx, 1
mov eax, 4
int 0x80
mov ebx, 0
mov eax, 1
int 0x80
Exercício 08 – Faça um programa em “nasm” que some os valores abaixo da pilha e retire da soma o primeiro valor (14).
R:
.MODEL SMALL
.STACK 100h ; Aumenta o tamanho da pilha para garantir espaço
.DATA
VALOR_FINAL DW ? ; Variável para guardar o resultado final
.CODE
START:
; 1. Inicializa a Pilha (PUSH)
push 10
push 5
push 1
push 50
push 14 ; Este é o primeiro valor que será subtraído (14)
; 2. Retira o primeiro valor (14) para uso posterior (subtração)
pop DX ; DX = 14 (O topo da pilha)
; 3. Inicializa o Acumulador e Soma os 4 valores restantes
mov AX, 0 ; AX = 0 (Acumulador para a Soma)
pop BX ; BX = 50. Pilha: [1, 5, 10]
add AX, BX ; AX = 50
pop BX ; BX = 1. Pilha: [5, 10]
add AX, BX ; AX = 51
pop BX ; BX = 5. Pilha: [10]
add AX, BX ; AX = 56
pop BX ; BX = 10. Pilha: []
add AX, BX ; AX = 66 (Soma dos valores abaixo do 14)
; 4. Subtrai o primeiro valor (14) da Soma (66)
sub AX, DX ; AX = AX – DX (66 – 14 = 52)
; 5. Armazena e Finaliza
mov VALOR_FINAL, AX
mov AH, 4Ch
int 21h
END START
CurtirCurtir
Exercício 01 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
RESPOSTA:
section .data
x dw 0
y dw 0
z dw 0
section .text
global _start
_start:
mov word [x], 7
mov word [y], 13
mov ax, [x]
mov [z], ax
mov eax, 1
int 0x80
Exercício 02 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
RESPOSTA:
section .data
x dw 5
y dw 12
sqr dw 0
dv dw 0
rest dw 0
section .text
global _start
_start:
mov ax, [x]
mul word [x]
mov [sqr], ax
mov ax, [x]
xor dx, dx
div word [y]
mov [dv], ax
mov [rest], dx
mov eax, 1
int 0x80
Exercício 03 – Faça um programa em “nasm” correspondente ao seguinte “código C“ (use “mov” e “dw”).
RESPOSTA:
section .data
val1 dw 10101010b
val2 dw 11110000b
res_and dw 0
res_or dw 0
res_xor dw 0
section .text
global _start
_start:
mov ax, [val1]
and ax, [val2]
mov [res_and], ax
mov ax, [val1]
or ax, [val2]
mov [res_or], ax
mov ax, [val1]
xor ax, [val2]
mov [res_xor], ax
not word [val1]
mov eax, 1
int 0x80
Exercício 04 – Implemente um trecho de código em Assembly que que troque o valor do registrador AH com o valor do registrador BH. Utilize apenas instruções lógicas XOR. Você pode utilizar outros registradores para guardar valores intermediários.
RESPOSTA:
section .text
global _start
_start:
mov ah, 50
mov bh, 90
xor ah, bh
xor bh, ah
xor ah, bh
mov eax, 1
int 0x80
Exercício 05 – Faça um programa em “nasm” que inverta os valores de mov ebx, 10 e mov eax, 20. Utilize os comandos abaixo para realizar a inversão. Após, mostre os resultados invertidos na tela.
RESPOSTA:
section .text
global _start
_start:
mov ebx, 10
mov eax, 20
push eax
push ebx
pop eax
pop ebx
mov eax, 1
int 0x80
Exercício 06 – Faça um programa em “nasm” que calcule o fatorial de um número.
RESPOSTA:
section .data
num dd 5
fat dd 0
section .text
global _start
_start:
mov ecx, [num]
mov eax, 1
loop_fat:
cmp ecx, 1
jle fim_fat
mul ecx
dec ecx
jmp loop_fat
fim_fat:
mov [fat], eax
mov eax, 1
int 0x80
Exercício 07 – Faça um programa em “nasm” que leia os valores apresentados abaixo, em seguida mostre o menor valor.
RESPOSTA:
section .data
menor dd 0
section .text
global _start
_start:
mov eax, 7
mov ebx, 9
mov ecx, 1
mov edx, 2
mov esi, eax
cmp ebx, esi
jge check_ecx
mov esi, ebx
check_ecx:
cmp ecx, esi
jge check_edx
mov esi, ecx
check_edx:
cmp edx, esi
jge fim_menor
mov esi, edx
fim_menor:
mov [menor], esi
mov eax, 1
int 0x80
Exercício 08 – Faça um programa em “nasm” que some os valores abaixo da pilha e retire da soma o primeiro valor (14).
RESPOSTA:
section .text
global _start
_start:
push 10
push 5
push 1
push 50
push 14
mov ecx, 5
mov eax, 0
soma_pilha:
pop edx
add eax, edx
loop soma_pilha
sub eax, 14
mov eax, 1
int 0x80
CurtirCurtir