Objetivos
Instruções para Controle de Fluxo
As instruções de controle de fluxo são utilizadas para desviar o fluxo de execução de um programa alterando o
conteúdo do registrador CS e IP automaticamente.
Esse tipo de instrução é utilizada em conjunto com instruções de comparação para tomada de decisões,
executar código em loop, chamada de subrotinas, interrupções de software e outros.
A Stack e armazena endereços de retorno de subrotinas de acordo com a distância
onde residem no código. Se dentro dos 64K do segmento, a Stack armazena o IP, caso contrário CS e IP são
armazenados.
O compilador fica responsável pela verificação da distância e uso dos registradores CS, IP e também da Stack
e retorno gerando as instruções necessárias sem intervenção do usuário.
Notação utilizada:
|
|
label |
nome da função ou recurso |
= , !=, > , < |
Igual, Diferente, Maior e Menor |
; |
Comentário |
<- |
Atribuição |
nnnnh |
Endereço 16-bits |
nnnnh:nnnnh |
Endereço 32-bits |
Mais informações sobre os registradores e flags podem ser vistas
em Registradores e Flags.
JMP - Jump - Pulo/Desvio Incondicional
A instrução JMP desvia o fluxo de execução para um novo local onde a execução do programa deve
continuar. Um endereço imediato é utilizado pela instrução de acordo com a distância do desvio.
Operação
Perto:
IP <- nnnnh
Longe:
CS:IP <- nnnnh:nnnnh
Operandos
label
nnnnh
nnnnh:nnnnh
Ex:
inicio: ; função
JMP fim
; codigo omitido
;
fim:
JMP inicio
Jccc - Short Conditional Jump - Pulo/Desvio Curto Condicional
As instruções de Jccc são executadas sobre condições específicas das flags do 8086. Um
endereço imediato é utilizado como o novo local em que a execução do programa deve continuar.
Operação
Perto:
IP <- nnnnh
Operandos
label
nnnnh
Na tabela abaixo podemos conferir todas condições das flags de status para os jumps condicionais suportados
pela instrução Jccc.
*Apenas os 8 bits menos significativos do resultados são verificados pela instrução.
Tab. 1: Condições Jccc
Instrução |
Descrição |
Flags |
JA |
if Above |
Cy = 0 e Z = 0 |
JAE |
if Above or Equal |
Cy = 0 |
JB |
if Jump Below |
Cy = 1 |
JBE |
if Below or Equal |
Cy = 1 e Z = 1 |
JC |
if Carry Set |
Cy = 1 |
JCXZ |
if CX Equals 0 |
CX = 0 |
JE |
if Equal |
Z = 1 |
JG |
if Greater |
Z = 0 S = O |
JGE |
if Greater or Equal |
S = O |
JL |
if Less |
S != O |
JLE |
if Less or Equal |
S != O ou Z = 1 |
JNA |
if Not Above |
Cy = 1 ou Z = 1 |
JNAE |
if Not Above and Not Equal |
Cy = 1 |
JNB |
if Not Below |
Cy = 0 |
JNBE |
if Not Below and Not Equal |
Cy = 0 e Z = 0 |
JNC |
if Not Carry |
Cy = 0 |
JNE |
if Not Equal |
Z = 0 |
JNG |
if Not Great |
Z = 1 e S != O |
JNGE |
if Not Great and Not Equal |
S != O |
JNL |
if Not Less |
S = O |
JNLE |
if Not Less and Not Equal |
S = O e Z = 0 |
JNO |
if Not Overflow |
O = 0 |
JNP* |
if Not Parity |
P = 0 |
JNS |
if Not Signed |
S = 0 |
JNZ |
if Not Zero |
Z = 0 |
JO |
if Overflow |
O = 1 |
JP* |
if Parity |
P = 1 |
JPE* |
if Parity Even |
P = 1 |
JPO* |
if Parity Odd |
P = 0 |
JS |
if Signed |
S = 1 |
JZ |
if Zero |
Z = 1 |
Ex:
MOV AL, FFh
MOV BL, 01h
ADD AL, BL ; AL <- FF + 1 , Cy = 1
JC desvio ; Jmp se Cy = 1
; omitido
desvio:
;omitido
A instrução CALL é utilizada para desviar o fluxo de execução, com retorno, quando precisamos realizar uma
chamada de uma subrotina ou função em nossos programas.
O endereço da próxima instrução, após CALL, é salvo na Stack e um endereço imediato é atribuído ao IP
ou CS e IP de acordo com a distância, Perto(Near) ou Longe(Far), da subrotina.
A diferença entre as instruções JMP, Jccc e CALL é que a instrução CALL
obrigatóriamente deve conter uma instrução RET(Return) ou RETF(Return Far) para retorno
do fluxo de execução.
Operação
Perto:
SS:[SP] <- IP
IP <- nnnnh
Longe:
SS:[SP] <- CS
SS:[SP] <- IP
CS:IP <- nnnnh:nnnnh
Operandos
label
nnnnh
nnnnh:nnnnh
Ex:
;trecho omitido
CALL funcao1 ; Invoca funcao
;trecho omitido
;
funcao1:
;trecho omitido
RET
RET e RETF - Return from Subroutine
A instrução RET é utilizada em uma subrotina para informar que "chegou em seu fim" e
que o retorno do fluxo de execução de ser feito.
O endereço salvo na Stack pela instruções CALL é restaurado no registrador IP ou CS e IP, de acordo
com a distância, fazendo com que a execução continue a partir da instrução seguinte à call.
As instruções RET(Return) e RETF(Return Far) se diferem em relação à distancia da subrotina chamada por CALL.
RET é usado em subrotinas próximas e RETF para subrotinas distantes.
Operação
Perto:
IP <- SS:[SP]
Longe:
IP <- SS:[SP]
CS <- SS:[SP]
Operandos
-
Ex:
;trecho de codigo
CALL funcao ; Invoca funcao
; <- endereço salvo na STACK(1)
;
;
funcao:
;trecho omitido
RET ; retorna para fluxo(1)
INT e INTO - Software Interrupt
As instruções de INT e INTO são utilizadas para a chamada de interrupções de software, feitas
manualmente pelo programador, em qualquer parte do código. INTO é utilizado para invocar uma interrupção
quando ocorre Overflow, flag O igual a 1.
O VDI referente aos tipos 32~255 do 8086 deve armazenar os endereços das interrupções de software do usuário.
Esse assunto e outros podem ser vistos em
Interrupções.
Sintaxe
INT interrupcao(0~255)
Operação
SS:[SP] <- PSR
SS:[SP] <- CS
SS:[SP] <- IP
I <- 0
CS:IP <- endereço interrupcao
Operandos
IME(Byte)
Ex:
MOV AH, 0Eh
MOV AL, 'T'
INT 10h
Histórico de atualizações
- 18/02/2025 - revisão 1 - ajustes pontuais
- 11/12/2024 - versão inicial
Os cursos oferecidos nesta página são cursos fornecidos por parceiros. Ao comprar um curso clicando
em seu banner, você está ajudando a manter o projeto TutorialDev vivo. Os sites dos cursos parceiros utilizam cookies.