GNUSim8085

GNUSim8085
GNUSim8085 - debugging the N-queens program.
Desenvolvedor	Sridhar Ratnakumar
Lançado em	{2003}
Versão estável	1.3.7
Idioma(s)	English, Arabic, Asturian, Brazilian Portuguese, Esperanto, French, German, Greek, Gujarati, Italian, Kannada, Spanish, Tamil
Sistema Operacional	GNU/Linux, Microsoft Windows
Gênero(s)	Simulador Computacional
Licença	GNU General Public License
Página oficial	www.gnusim8085.org
Portal das Tecnologias de informação

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.

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;
}

Ligações externos

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