GNUSim8085

GNUSim8085 é um simulador gráfico, Montador e Depurador para o microprocessador Intel 8085 no GNU/Linux e no Windows. Está entre os 20 vencedores do FOSS India Awards anunciado em Fevereiro de 2008.

GNUSim8085
GNUSim8085 - debugging the N-queens program.
Desenvolvedor	Sridhar Ratnakumar
Lançamento	{2003}
Versão estável	1.4.1
Idioma(s)	English, Arabic, Asturian, Brazilian Portuguese, Esperanto, French, German, Greek, Gujarati, Italian, Canarês, Spanish, Tâmil
Sistema operacional	GNU/Linux, Microsoft Windows
Gênero(s)	Simulador Computacional
Licença	GNU General Public License
Página oficial	www.gnusim8085.org

Características

Editor

1. Editor de programa com uma interface interativa para a entrada de todas as instruções padrões.
2. Syntax highlighting para distinção entre instruções, operandos, comentários e etc.
3. Uma visão separada de opcodes, que mostra o código montado em hexadecimal.

Montador (Assembler)

1. Suporte a todas as instruções padrões do 8085
2. Suporte para diretivas do montador mais populares
3. O Montador fornece algumas características para facilitar o processo de codificação
4. O montador ignora qualquer coisa em uma linha após a virgula

Depurador (Debugger)

1. Completa visão dos registradores e flags
2. Suporte a breakpoints
3. Execução/Depuração de um programa passo a passo
4. Conversor Hexadecimal-Decimal
5. Inspector em tempo de execução da pilha e das variáveis definidas no código fonte.
6. Inspector e manipulador em tempo de execução da memória e das portas E/S.

Impressão

1. Impressão do programa direto do editor.

Utilização

1. O GNUSim8085 é um simulador gráfico do processador Intel 8085, a linguagem usada para as simulações é o Assembly. Ele é utilizado para o ensino de arquitetura computadores, o GNUSim8085 auxilia o entendimento do uso de registradores do processador facilitando o aprendizado e implementação de códigos devido a sua interface gráfica
2. O simulador gráfico GNUSim8085 simula o funcionamento do microprocessador Intel 8085, com as mesmas instruções disponíveis em processador real. A entrada e a saída dos processadores reais e o simuladores são iguais, embora o método de processamento interno podem ser diferentes. O simulador GNUSim8085 permite visualizar o conteúdo dos registradores, a memória e os valores de E/S, mas só é possível executar uma instrução de cada vez, e também escrever código em mnemônicos.

Exemplos de códigos

• Função de Divisão em assembler.

jmp start
;data
v_divisor: ds 1;
v_dividendo: ds 1;
v_resto: ds 1; 
v_resultado: ds 1;
;code
;função para_dividir_parte realiza a divisão por partes acrescentando 1 a cada "divisão"
para_dividir_parte: 
     nop
     ;salva endereço de retorno
     pop d;
     ;pega os parametros em BC
     pop b;
     ;joga o dividendo em A
     mov a,b;
     cmp c; compara se o divisor não é maior que o dividendo	
     jc fim_divisao
     ;a divisão é efetuada a partir daqui
divisao: 
     sub c; diminui o valor do divisor do dividendo
     inr h; incrementa o valor do resultado
     cmp c; compara se o dividendo é maior que o divisor
     jnc divisao; pula para a divisao se não for maior
fim_divisao: 
     mov b,a; pega o resto da divisão	
     push h;empilha o resultado
     push b;empilha o resto
     push d;empilha o retorno
     ret
start: 
     nop
     ;zerando todos os registradores
     mvi b,00h;
     mvi c,00h;
     mvi d,00h;
     mvi e,00h;
     mvi h,00h;
     mvi l,00h;
     ;dividendo = 10
     mvi a,02h;
     sta v_dividendo;
     ;divisor = 2
     mvi a,02h;
     sta v_divisor;
     ;zera resultado
     mvi a,00h;
     sta v_resultado;
     ;carrega os valores para BC
     lda v_dividendo;
     mov b,a;
     lda v_divisor;
     mov c,a;
     ;coloca os parametros na pilha
     push b;
     ;chama a divisão
     call para_dividir_parte;
     ;recupera o resto da divisão
     pop b;
     mov a,b;
     sta v_resto
     ;recupera o resultado da divisão
     pop h;
     mov a,h;
     sta v_resultado
     hlt;

• Função de Divisão em java

public static long divisor(long n) {
		long div = 2;
		int i;
		if (n > 0) {		
			div = div / n;
		}
		return (div);
	}

• Fatorial Iterativo em Assembler.

jmp start

;declarando as variaveis: fat, i, n; 
v_fat: ds 1;
v_i: ds 1;
v_n: ds 1;
;Fim da declaração;

start: 
        nop; inicio do programa;
	
	mvi a, 05h; n <= 5 (Registrador A);	
	sta v_n; variavel v_n armazena o valor do registador A;

call void_fatiter; chama o método void_fatiter;

void_fatiter: 
        nop; método fatiter{
	mvi a, 01h; fat <= 1 (Registrador A);	
	sta v_fat; variavel v_fat armazena o valor do registador A;

;inicio do if(n>0){ 
	
   	lda v_n; carrega o valor da variavel v_n para o registrador A;	
	mov b, a; move o valor do registrador A para o registrador B;	
	mvi a, 00h; zera o registrador A;	
	cmp b; compara o valor do registador B com o registrador A;	
	jnz fim_if; pula para função fim_if se não der zero (se o valor que estiver em B for = 0);

fim_if: jnc return_fat; chama função return_fat caso o if não seja satisfeito;

inicio_for: nop; inicio do for(i = 1; i <= n; i++){

	mvi a, 01h; i <= 1 (Registrador A);
	sta v_i; variavel v_i armazena o valor do registador A;

r1:	nop; rotina 1;
	mov c, a; move o valor do registrador A para o registrador C;
	lda v_n; carrega o valor da variavel v_n para o registrador A;
	cmp c; compara o valor do registador C com o registrador A;
	jc r4; pula para rotina 4 se der carry;

r4: 	call multi; rotina 4; chama função multi;

r3:	lda v_i; rotina 3; carrega o valor da variavel v_i para o registrador A;
	inr a; incrementa o valor do registrador A;
	sta v_i; variavel v_i armazena o valor do registador A;
	jmp r1; pula para rotina 1;

r2:	call return_fat; rotina 2; chama a função return_fat;

multi:  nop; função multi;
	lda v_fat; carrega o valor da variavel v_fat para o registrador A;
	mov b, a; move o valor do registrador A para o registrador B;
	lda v_i; carrega o valor da variavel v_i para o registrador A;
	mov d, a; move o valor do registrador A para o registrador D;
	mov e, a; move o valor do registrador A para o registrador E;
	cmp b; compara o valor do registador B com o registrador A;
	jz r3; pula para rotina 3 se der zero;
	dcr d; decrementa o valor do registrador D;
	lda v_fat; carrega o valor da variavel v_fat para o registrador A;

r5:	add b; rotina 5; soma o valor do registrador A com o valor do registrador B;
	dcr d; decrementa o valor do registrador D;
	jnz r5; pula para rotina 5 se não der zero;
	sta v_fat; variavel v_fat armazena o valor do registador A;
	lda v_n; carrega o valor da variavel v_n para o registrador A;
	cmp e; compara o valor do registador E com o registrador A;
	jz r2; pula para rotina 2 se der zero;
	ret; retorna para chamada da função multi;

;fim do for }
;fim do if }

return_fat: nop; função return_fat;

	lda v_fat; carrega o valor da variavel v_fat para o registrador A;

hlt; fim do programa;

• Fatorial iterativo em java.

public static long fatiter(long n) {
		long fat = 1;
		int i;
		if (n > 0) {
			for (i = 1; i <= n; i++) {
				fat = fat * i;
			}
		}
		return (fat);
	}

• Função de Multiplicação de dois Números

jmp start

;declaração das variáveis
multiplicando: ds 1;
multiplicador: ds 1;
resultado: ds 1;
; fim da declaração das  variáveis

;função de multiplicação dos números
multiplicacao: nop 
pop d;guarda na pilha o endereço do registrador d (endereço de retorno)
pop b;guarda na pilha o endereço do registrador d
mvi a,00h;move imediatamente o valor zero para o registrador a

multiplica: add b; soma o valor do registrador a com o valor do registrador b
dcr c; decrementa o numero de vezes que é multiplicado
jnz multiplica; volta a fução multiplica enquanto o registrador c for diferente de zero
 	mov h,a;move o valor do registrador a para o registrador h 
push h;guarda na pilha o valor do registrador h
push d;guarda na pilha o valor do registrador d

ret
;code
start: nop
mvi a,5h;move o valor 5H para o registrador a, que representa o multiplicando
sta multiplicando;armazena diretamente o conteúdo do registrador na variável multiplicando
mvi a,2h;move o valor 2H para o registrador a, que representa o multiplicador
sta multiplicador;Armazena diretamente o conteúdo do registrador na variável multiplicador
mvi a,00h;move imediatamente o valor zero para o registrador a
sta resultado;armazena o conteúdo do acumulador em resultado

lda multiplicando;carrega o acumulador no multiplicando
mov b,a;move o valor do registrador a para o registrador b
lda multiplicador;carrega o acumulador no multiplicador
mov c,a;move o valor do registrador a para o registrador c

push b;guarda na pilha o valor do registrador b
call multiplicacao;chama a função multiplicação

pop h;guarda na pilha o endereço do registrador h
mov a,h;move o valor do registrador h para o registrador a
sta resultado;armazena o conteúdo do acumulador em resultado

hlt

• Função de Multiplicação em java

public static long divisor(long n) {
		long mult = 2;
		int i;
		if (n > 0) {	
			mult = mult * n;
		}
		return (mult);
	}

• Fatorial recursivo em assembler

 
jmp start;salta para o inicio do programa
	
	V_N: ds 1 ; declaração de variável
	start: nop;inicio do programa

	mvi a,03h;adiciona o valor 3 para o acumulador
	mov h, a;move o valor do acumulador para o registrador H
	sta V_N;atribui o valor para a variável
	call fatrecu;chama o método do fatorial recursivo para retornar o fatorial

fatrecu: nop;metodo fat recursivo

	V_fat: ds 0;declara a variável
	mvi a,00h;move o valor o para o acumulador
	sta V_fat;atribui o valor para a variável
if:   	nop ;instrução  if(n == 0)
	lda V_N;puxa o valor da variável
	mov b, a;move o valor que esta no acumulador para registrador b
	mvi a, 00h;atribui o valor 0 para o acumulador
	cmp b;comparação se b = ao a se for igual a zera e true
	jnz else;se não, salta para o método falsidade else
	mvi a,01h;move o valor 1 para o acumulador
	sta V_fat; seta o valor do acumulador na variável
	call multfat;chama a multiplicação

else: 	nop; instrução de falsidade else
	lda V_N;puxa o valor da variável
	mov b, a;move o valor do acumulador para o registrador b	
	mvi a, 00h;atribui valo 0 para o acumulador
	cmp b;comparação se n > 0
	call mult;chama o método de multiplicação verificar o valor da variavel n
fim_if: nop;fim do laço de repetição if

mult:   nop; chamado da verificação do fatorial
	lda V_fat;puxa o valor da variável
	mov c, a;move o valor do acumulador para o registrador c
	lda V_N;puxa o valor da variável
	mov d, a;move o valor do acumulador para o registrador d
	mov e, d;move o valor do registrador d para o registrador e
	dcr e;decremento o valor do registrador e
	mov a, e;move o valor do registrador e para o acumulador  
	sta V_N;seta o valor na variável N
	jnz else;enquanto não der 0 retorna para o else
	call if;chama o if
multfat: nop ; metodo da multiplicação dos fatoriais
	lda V_fat;puxa o valor da variável
	mov c, a;move o valor do acumulador para o registrador c
	sta V_N;atribui o valor do acumulador para a variável
	mov d, a;move o valor do acumulador para o registrador d
	mov e, d;move o valor do registrador d para o registrador e
	mov a, e;move o valor do registrador e para o acumulador 
	mvi l, 00h;atribui o valor 00 para o registrador l
comp:	inr e;incrementa o registrador e
	inr l;incrementa o registrador l para verificação
	mov c, a; move o valor do  acumulador  para o registrador c
	mov a, l; move o valor do registrador l para o acumulador 	
	mov d, a;move o valor do  acumulador  para o registrador d
	mov b, e;move o valor do registrador e para o registrador b
	cmp h;compara o acumulador com o valor do registrador h atribuído o valor no começo do programa
	jnc return_fat;se for igual chama o método return_fat
	mvi a, 00h;atribui o valor 00 para o acumulador
	
mulf:  	add c ; adiciona o valor do acumulador no registrador c
	dcr b; decrementa o valor de b
	jnz mulf;salta para o método mulf
	call comp;chama o comp
	

return_fat: mov a, c;move o valor do registrador c para o acumulador
	    sta V_fat; seta a o valor do acumulador para a variável V_fat para o retorno do fatorial

hlt;fim do programa

• Fatorial Recursivo em Java.

 
public static long fatrec(long n) {
		long fat = 0;
		if (n == 0)
			fat = 1;
		else if (n > 0)
			fat = n * fatrec(n - 1);
		return (fat);

}

• Numero Primo em Assembler

;Numero__Primo

jmp start

v_par: ds 1

isPrimo: nop

;carrega valor imediato para o registrador
mvi h, 02h
;carrega valor imediato para o registrador
mvi l, 01h

jmp inicio_while

;função de dividir
funcao_divisao: nop
		
	cpi 01h
	jz f_1	

	divisao: nop

	;compara A com registrador L	
	cmp l
	;salta se o valor de L for igual ao valor contido em A
	jz incrementa_contador
	;compara se A com valor imediato 0
	cpi 00h
	;salta se o valor de A = valor imediato
	jz altera_boolean	
	;compara A com registrador H		
	cmp h
	;salta se valor de H maior que valor contido em A
	jc incrementa_contador
	;subtrai o valor de A por valor de H	
	sub h
	;salta se o valor de A for maior que o valor contido em H
	jnc divisao
		
	incrementa_contador: nop
	;incrementa registrador	H
	inr h
	;salto incondicional para fim_divisao	
	jmp fim_divisao

	altera_boolean: nop
	;incrementa registrador	L
	inr l
	;salto incondicional para fim_divisao
	jmp fim_divisao
	
	f_1: nop
	;incrementa registrador L
	inr l

fim_divisao: nop
;comando de retorno da chamada
ret

inicio_while: nop
	;verificar primeira condição
	;carregando valor imediato 1 para A	
	mvi a, 01h
	;compara o valor contido em A com o valor contido em L
	cmp l
	;salta se o valor contido em A for menor que o valor contido em L
	jc fim_while

	;verificar segunda condição
	;carrega o valor da variavel para A
	lda v_par
	;compara o valor contido em A com o valor contido em H
	cmp h
	;salta se o valor contido em A for igual ao valor contido em H
	jz fim_while

	;chamada para a funçao de dividir
	call funcao_divisao
		
	jmp inicio_while
		
fim_while: nop

;intrução de retorno da chamada
ret

start: nop

;carrega o valor 0 para o registrador H
mvi h, 00h
;carrega o valor 0 para o registrador L
mvi l, 00h

;carrega valor imediato para o Acumulador
mvi a, 05h
;grava o valor do Acumulador na variavel
sta v_par

;chama a função isPrimo
call isPrimo
;carrega valor do registrador para acumulador
mov a, l
	
hlt

• Numero Primo em java

public static boolean isPrimo(long numero) {
    int contador = 2;
    boolean primo = true;
    while ((primo) && (contador != numero)) {
        if (numero % contador == 0)
            primo = false;
            contador++;
    }
    return primo;
}

Referências

Ligações externos

• GNUSim8085 homepage
• Guia da linguagem assembly do GNUSim8085 (em inglês)