Mostrando postagens com marcador Conceitos básicos de Assembly. Mostrar todas as postagens
Mostrando postagens com marcador Conceitos básicos de Assembly. Mostrar todas as postagens

Define - Como alocar memória Assembly - RES, como reservar memória

Se você estudou somente linguagens de altíssimo nível, como as de linguagens de script, com certeza nunca se preocupou em alocar memória, pois é tudo feito automaticamente por debaixo dos panos.

Se estudou linguagens como C ou Java, você alocava espaço na memória ao declarar variáveis e estruturas (em C é possível ainda, a alocação dinâmica de memória).

Nesse tutorial de nosso curso de Assembly, vamos aprender como reservar espaço em disco em Assembly, ver quais as diferenças e peculiaridades nessa linguagem de baixo nível.


Alocação de memória em programação

Em outras linguagens de programação, para declarar variáveis precisávamos definir o tipo antes.

Por exemplo, em C ou C++, escrevíamos 'int' para inteiros, 'float' ou 'double' para decimais, 'char' para caracteres, dentre outros tipos.

Ao fazermos isso, sem saber (diferente do Assembly, em que vemos claramente como as coisas são feitas), estamos dizendo muito mais do que simplesmente a alocação de memória em si.

O resultado de uma operação entre um inteiro e um decimal não é totalmente previsível, depende da variável em que vamos armazenar, da linguagem e de outras regra específicas.

Quando declaramos uma variável do tipo double ou float, já fica subentendido que haverá uma vírgula (ou ponto), representado sua parte decimal. Além disso, há divisões no espaço alocado de memória, para armazenar a parte decimal e a parte não decimal.

Enfim, acontece muito mais do que simplesmente reservar um espaço de memória. Muitas rotinas úteis, que facilitam a vida de programador acontecem por debaixo dos panos.





























Alocação de memória em Assembly - A diretiva define

Obviamente, em Assembly as coisas são um pouco diferente.

Essas coisas que atuam sem o conhecimento do programador simplesmente não existem, e o profissional que programa em Assembly ficará a cargo de tudo.

Em Assembly, você realmente irá alocar espaço em memória. E somente isso.

Por exemplo, usamos o mnemônico ADD para adicionar um número a outro. Mas ele não vai simplesmente adicionar todos e quais números automaticamente como costumamos fazer em outras linguagens.

Se o resultado der mais de dois dígitos, por exemplo, você terá que fazer uma rotina para exibir esses dois dígitos (sabe quando você soma no papel, fazendo continha e o valor da soma dá mais que 9, aí 'vai 1' ou 'sobe 1' ? é algo parecido) ; ao somar, ter cuidado para saber se somou o caractere '1' ou realmente o número 1. Case seja caractere, ou queira exibir, terá que fazer alterações, e por aí vai.

Como enfatizamos, Assembly é em baixo nível.

Trabalhamos com bits e bytes. E nesse nível, as coisas não vem prontas.

O programador Assembly é que o tem o poder e responsabilidade de absolutamente tudo. Por isso, ao alocar memória, temos que definir o número de bytes que vamos usar.

Vamos usar as seguintes variações da diretiva define: DB, DW, DD, DQ e DT.

Eles significam e alocam determinados número de bytes, veja:



DB = Define Byte            -> aloca 1 byte

DW = Define Word           -> aloca 2 bytes

DD = Define Doubleword  -> aloca 4 bytes

DQ = Define Quadword    -> aloca  8 bytes

DT = Define Ten              -> aloca 10 bytes



Sabendo disso, poderemos agora mostrar como é a sintaxe de uma instrução em Assembly para alocar memória:

Nome_da_Variavel diretiva_define valor



Por exemplo, para alocar espaço para o caractere 'A', fazemos:

letra1 DB 'A'



Lembramos que, na verdade, embora tenhamos escrito o caractere 'A', tudo são números.

Então, como na tabela ASCII o valor de 'A', em hexadecimal é 41, poderíamos ter feito:

letra1 DB 41H



Colocamos a letra H ao final do número para dizer que estamos representando em Hexadecimal.

Se fossemos colocar em binário, temos que colocar a letra B ao final:

letra1 DB 01000001B



Para saber mais sobre os caracteres em programação, consulte nosso artigo do site C Progressivo, que também mostra a tabela ASCII:

http://www.cprogressivo.net/2012/12/O-tipo-char-como-escrever-textos-na-linguagem-C.html



Um pouco de matemática

Em Assembly, trabalhamos sempre com bytes, onde um byte equivale a 8 bites.

Cada bit desse pode ser 0 ou 1, então podemos representar até: 2^8 = 256 caracteres com um byte.



Em Hexadecimal, podemos representar esses 256 caracteres usando os números 00H até FFH.

Ou seja, 41H caberia em um byte, pois é menor que FFH.

Agora 2112H só caberia em dois bytes, onde um armazenaríamos o byte 12H e no outro o byte 21H.



Vamos armazenar uma senha na variável 'senha', ela conterá 4 dígitos decimais: 1234

Esse número, em hexadecimal equivalem a 4660H.

Precisamos, então, definir dois bytes, ou uma palavra (word). Um byte armazena o 60H e o outro armazena o 46H.

Para alocar memória para essa senha, faríamos:

senha DW 466H



Outras maneiras de alocar memória em Assembly

E se quiséssemos alocar uma palavra, como 'curso', por exemplo?

Poderíamos alocar letra por letra:

letra1 DB 'c'

letra2 DB 'u'

letra3 DB 'r'

letra4 DB 's'

letra5 DB 'o'



Porém, seria muito trabalhoso, e há maneira mais fáceis de se fazer isso.

Em vez de ter que dar um nome para cada letra (isso não faz o menor sentido!), poderíamos dar um nome só para o conjunto de letras:

curso DB 'c'

DB 'u'

  DB 'r'

  DB 's'

  DB 'o'



E sempre que usarmos a variável curso, o Assembly saberá que se trata de conjunto de caracteres.

Porém, esse exemplo, assim como o anterior, tem mais caráter de informação para você, leitor de nosso curso Assembly Progressivo.



A maneira mais prática e utilizada para armazenar uma string, é utilizando a define DB e escrevendo uma string (que nada mais é que um texto, um conjunto de caracteres).

O Assembly irá alocar, automaticamente, todos os caracteres, como se tivéssemos feito o exemplo passado.



No exemplo do "Hello, world" em Assembly, nosso primeiro programa, fizemos isso:

helloWorld DB 'Curso Assembly Progressivo: online, gratis e completo'



Bem mais prático, não?



Reservando memória em Assembly

Até agora, usando a diretiva define e suas variações (DB, DW, DD, DQ e DT), alocamos memória em Assembly para armazenar e INICIALIZAR variáveis! Porém, nem sempre vamos inicializar, apenas queremos alocar.

Isso é comum para armazenar variáveis cujos valores serão fornecidos posteriormente, pelo seu programa, pelo usuário ou um dispositivo de entrada e saída.



Para reservar memória, usamos a diretiva RES, ao mesmo molde da diretiva DEFINE:

RESB = Reserve Byte             -> reserva 1 byte

RESW = Reserve Word            -> reserva 2 bytes

RESD = Reserve Doubleword   -> reserva 4 bytes

RESQ = Reserve Quadword     -> reserva 8 bytes

REST = Reserve Ten               -> reserva 10 bytes



A sintaxe é um pouco diferente da DEFINE, já que não vamos inicializar.

Assim, em vez de valor inicial, temos que dizer quanto de espaço queremos reservar, dependendo da diretiva que usamos.

Sintaxe para reservar memória:

nome_da_variavel diretiva_res numero_de_unidades



Por exemplo:

variavel1 RESB 1 ; nesse caso, reservamos apenas 1 byte

variavel2 RESB 2 ; aqui, reservamos 2 bytes

variavel3 RESW 3 ; 3 palavras são reservadas, o que nos dá 3*2 = 6 bytes

variavel4 REST 10 ; reservamos 10 unidades, de 10 bytes cada
Ler Tutorial

O que é e como usar um Label (rótulo) em Assembly

Agora que já vimos no artigo passado o escopo e organização de um programa em Assembly, vamos iniciar nossos estudos em programação mesmo, com exemplos reais de códigos ou trechos de código-fonte.

Neste tutorial de nosso curso Assembly Progressivo, vamos iniciar os nossos estudos das instruções em Assembly, explicando o que são os labels, labels internos (ou locais), dando exemplos de uso e mostrando para que servem.

O que são labels em Assembly e para quê servem

A tradução de label é 'rótulo', é uma nomenclatura que damos para dar nome a um trecho de código em Assembly.


Durante todo nosso curso de Assembly iremos traduzir algumas palavra dessa linguagem de programação, pois simplesmente entendendo o significado da palavra em inglês, saberemos a utilidade daquele comando.


O label, por exemplo, serve (como o nome diz) para rotular, nomear uma seção do código, para que possamos definir uma região do código através de um rótulo, de um nome que quisermos.


Para criar uma label, basta digitar o nome desse rótulo seguido de dois pontos, ' : '.

Em seguida, escrevemos nossas linhas de código em Assembly.


A sintaxe é a seguinte, então:


label:
 ;aqui vem o código
 ;que vai ser nomeado
 ;de 'label'
































Imagine que você criou uma rotina de códigos que tem por objetivo passar um número para outro registrador, subtrair esse valor daquele e depois substituir o valor original (não importa o que sua rotina esteja fazendo). Enfim, suponha que você criou um trecho de código que vai repetir várias vezes durante seu programa em Assembly.


Ou seja, esse código se repete, você vai usar mais de uma vez.
Vamos então criar um label chamado 'rotinaBase'.


rotinaBase:
  ;código super
  ;hiper mega complexo
  ;que aprendi no
  ;Assembly Progressivo




O que o label faz é nomear essa porção de linhas de código.

Para executar elas, em vez de escrever todas elas de novo em outra parte, você apenas se refere a "rotinaBase", e o trecho de código que você usou abaixo da label 'rotinaBase' será executado.


Lembrando que a linguagem Assembly está em baixo nível, ela sempre trata tudo em relação aos endereços na memória.Os labels estão intrinsecamente ligados com endereços de memória.


Um label serve para representar o endereço de um determinado trecho no código (ou para inicializar variáveis e constantes que podem ter seus endereços realocados).

Assim, se usarmos esse trecho de código várias vezes, em vez de repeti-lo basta voltar ao ponto (endereço) na memória que tem esses códigos.


Porém, é complicado para os humanos tratarem os endereços de memórias como números (em binário, hexadecimal ou mesmo decimal), por isso damos um nome a esse endereço de memória, um rótulo, e passamos a chamar esse local da memória pelo seu label. Bem mais simples, não?

No nosso código do Hello World em Assembly, usamos o label '_start', que serve para definir para o NASM onde vai começar nosso programa.

Como outro exemplo do uso de label em nossos códigos Assembly, vamos supor que durante a execução de um programa seja necessário incrementar uma variável 'numero' várias vezes.

O código para incrementar é:


inc numero ;numero++



Onde 'inc' é um mnemônico, ou seja, representa a operação de incrementação (adicionar +1 à variável 'numero'). Vamos criar um label para definir esse trecho de código, a label: 'incrementa'.

Ela ficaria assim:



incrementa:
  inc numero ;incrementa 'numero' em uma unidade




Pronto, agora podemos incrementar a variável número apenas invocando o label.



Labels internas ou Labels locais







O uso de labels é altamente recomendável, visto que os programas em baixo nível sempre são enormes, com códigos 'obscuros', números hexadecimais e outras complicações visuais.



Em sistemas mais complexos, onde é necessário o uso de centenas ou milhares de linhas de código, será interessante usar labels internas.

Você usará labels que vão representar centenas de linhas de código, e pode ser necessário usar labels dentro destas labels, e provavelmente que tenham o mesmo nome.



O NASM, que é o Assembler que estamos usando em nosso Curso de Assembly, permite a definição de labels locais.

Para isso, basta colocar um ponto, ' . ', antes do nome da label.



labelNormal -> label normal, sem ponto

.labelInterna -> label local, com ponto, ela está dentro('pertence) a label 'labelNormal'



Por exemplo, uma representação de um código que duas labels internas, de mesmo nome, mas em locais diferentes, que fazem a mesma coisa (incrementar), mas incrementam variáveis diferentes:



trecho1:
 ;trecho 1 do código
.incrementa:
 inc numero1 
 
 ;continuação trecho 1
 
trecho2:
 ;trecho 2 do código
.incrementa:
 inc numero2
 
 ;continuação do trecho 2


Note que uma label local se refere a label 'geral', imediatamente superior.

Cuidado para não se confundir.



Nossos estudos sobre labels não param por aqui, mas você já aprendeu uma ótima noção sobre os rótulos, embora ainda falte coisas importantes, como o ret, que é uma instrução de retorno, que serve para definir onde termina um rótulo/label.



Ao decorrer de nossa apostila online de Assembly usaremos bastante labels, então você aprenderá mais sobre elas vendo exemplos reais de código.
Ler Tutorial

Como programar em Assembly no Linux – Instalando o Assembler NASM

Para começarmos a programar na linguagem de programação Assembly, precisamos de um programando chamado Assembler, que irá converter nosso código para um código que a máquina irá entender.

Vamos usar o NASM (NetWide Assembler), que pode ser usado no Windows ou no Linux.

Nesse tutorial de nosso curso de Assembly, vamos ensinar como instalar esse Assembler no sistema operacional Linux.

Para programar em Assembly, iremos usar corriqueiramente o terminal do Linux, tanto na instalação como na montagem de nossos códigos-fonte, para criar os programas.


Baixando o NASM

Para baixar o NASM vá na página oficial do Netwide Assembler:

Como o projeto continua se desenvolvendo, não podemos especificar uma versão, pois no momento que você estiver lendo esse tutorial de Assembly a versão oficial do NASM pode ser diferente da versão usada pelo Assembly Progressivo.

Portanto, ao entrar no website, clique na seção de Downloads, e em seguida abra o diretório da versão mais recente.
Lá você verá um vários diretórios com nome dos mais diversos sistemas operacionais.

Aqui iremos baixar, descompactar e utilizar o NASM para GNU/Linux.





























Como instalar o NASM no Linux

Dentro da seção de Downloads você encontrará os arquivos para instalação no Linux, eles estão no formato nasm-xxx.tar.yy, onde xxx é a versão, e yy a extensão compactada.

Os arquivos nasm-xxx-xdoc.tar.yy  se referem a documentação oficial do Assembler NASM.


Já dentro do diretório linux/ você encontrará os arquivos rpm para instalar em distribuições Linux do tipo Red Hat, como o Fedora.


Após baixar e descompactar, pelo Terminal vá na pasta do NASM e rode o script para configurar a instalação, com o seguinte comando:

./configure


Para construir, digite o comando:

make


Após terminar o make, para instalar o NASM digite:

make install


E seu Assembler estará instalado em seu sistema operacional Linux.


PS: caso ocorra erros em sua instalação, efetue-a como super usuário, ou através do comando sudo antes de cada comando.


Ler Tutorial

Sections e _start: A divisão do código-fonte Assembly - A diretiva global

Quando um executável vai rodar, ele precisa saber a partir de onde, no código, ele começa a rodar.

Em programação, começar do começo não é algo comum.

Tendo em vista esses dados sobre a informação da ordem das coisas em um código, vamos falar neste tutorial de Assembly sobre as seções (sections) de um arquivo-fonte em Assembly.


Deixando seu código organizado

Programas feitos na linguagem de baixo nível Assembly tem uma características em comum: eles são grandes.


Sim, programar em Assembly é escrever bastante, pois é uma linguagem totalmente crua, onde muito pouco 'existe' e muito, quase tudo, é necessário criar.

Para se fazer um simples programa de cálculos matemáticos simples (somar, subtrair etc) é necessário que fazer uma rotina, manualmente, para essa tarefa, usando somente as instruções nativas do processador.


Em linguagens de alto nível, como C e Java, isso já vem totalmente pronto.

Não é necessário criar nada, somente utilizar.


Então, mais que todas as outras linguagens, é necessário ter organização para programar em Assembly. Seu código deve ser legível, organizado e comentado.


Visando essa organização, existe um comando (ou simplesmente rótulo, ou marcador) chamado section, que serve para definirmos seções em nosso código.

Para declarar uma section fazemos:
section .nomeDaSecao






























Como dividir um código Assembly: .data, .bss e .text

De uma maneira geral, os programadores Assembly utilizam três sections para organizar seus códigos. Seguir esses passos é interessante, visto que fará com que seus programas sejam organizados da maneira padrão, da maneira que é universalmente usada.



Na .data section, como o nome sugere, é uma região do código que será usada para tratar as informações, os dados, as variáveis.

Nesse trecho (geralmente o inicial), declaramos e inicializamos as variáveis.


Fazemos algo parecido na .bss section, porém não inicializamos as informações.


Por fim, a .text section é o local onde irá ficar armazenado suas instruções, que irão trabalhar com os dados previamente declarados.

Essa é a única seção obrigatória, pois conterá a label (rótulo) _start, que é o local onde os executáveis são inicializados.


Se já estudou C, C++ ou Java, por exemplo, a _start seria o main().

Logo, o esqueleto dos códigos em Assembly é:

section .dat
  ;declaração e inicialização de dados
 
section .bss
  ;declaração sem inicialização das informações que serão usadas
 
section .text
  ;o programa começa a rodar aqui, a partir da _start


Se comunicando com o mundo externo: global

Como as memórias e processadores estão ficando cada vez mais modernos e maiores (em relação ao tamanho da memória), está possível, cada vez mais, usar linguagens de alto nível (principalmente o C), para tarefas que eram feitas exclusivamente em Assembly.


Uma prova disso é o sistema operacional Linux, onde sua gigantesca parte é feita em C, com algumas pitadas em Assembly.

Essa pitada de Assembly no Kernel é justamente na parte que é necessária uma maior eficiência da máquina, pois como sabemos, em termos de eficiência nenhuma outra linguagem bate nossa amada linguagem.


Por isso, é bem comum a interação entre Assembly e outras linguagens. Um exemplo disso são os games de alto desempenho, que possuem rotinas feitas em Assembly, que se comunica com o resto do programa.

Ainda em nosso curso de Assembly veremos como usar funções das bibliotecas da linguagem C.


Uma maneira de fazer essa interação é através da diretiva (explicaremos o que é isso em breve) global.

A diretiva global mostra que o label relacionado é global, ou seja, é passível de uso externamente.

Geralmente usamos para declarar o label principal, o _start.

Portanto, o nosso esqueleto de código será:


section .dat
  ;declaração e inicialização de dados
 
section .bss
  ;declaração sem inicialização das informações que serão usadas
 
section .text
global _start
 
_start:
  ;o programa começa a rodar aqui, a partir daqui



Ler Tutorial

Como criar object files (código objeto) e linkar arquivos em Assembly

No tutorial passado de nossa apostila, ensinamos como criar um programa em Assembly, o famoso e simples "Hello world".

Lá, mostramos como criar o arquivo com a extensão asm.

Ao término deste tutorial, você irá aprender como transformar esse arquivo em executável, e executá-lo.



Como transformar um arquivo .asm em executável

Agora precisamos converter nosso código em Assembly, que é feito e entendido por nós humanos, para a linguagem de máquina, que é a linguagem que o computador realmente entende e roda.

Isso se faz em dois passos:

  • Criar o object file, que pega o .asm e cria, a partir dele, um arquivo com a extensão .o
  • Linkar nosso programa, fazendo com que o código-objeto se torne em um executável
Vamos ensinar como fazer isso utilizando o assembler NASM, no sistema operacional Linux.
Um importante detalhe: dependendo da arquitetura de seu sistema, 32 bits ou 64 bits, os comandos diferem um pouco, mas ensinaremos como trabalhar em ambos casos.

Como criar o object file em Assembly

Agora vamos criar o arquivo com extensão .o, que é o objeto (resultado da transformação do código para código de máquina).


Para isso, vamos finalmente usar o nasm.

Como Assembly é baixo níveo, o código vai se diferenciar levemente caso você use 32 ou 64 bits, mas nosso tutorial de Assembly vai explicar você a rodar seus programas em ambas arquiteturas.



Caso seja 32 bits, vá no diretório do hello.asm e digite o seguinte código no terminal:

nasm -f hello.asm


Caso seja 64 bits, digite:

nasm -f elf64 hello.asm


Se você notar bem, foi criado um arquivo com extensão .o, é o arquivo-objeto hello.o

























Como linkar arquivos em Assembly

O próximo passo é a linkagem, onde vamos transformar o(s) códigos objeto de nossos programas para torná-los executáveis.

Vamos usar o comando ld para isso.



32 ou 64 bits:

ld hello.o -o hello


Pronto, agora você tem seu arquivo executável "hello". Para rodá-lo, digite o comando a seguir, que deve mostrar uma mensagem na tela:

./hello


O resultado desses passos é:



Curso de Assembly online grátis





Como rodar o código Assembly - Tutorial Alternativo

Uma outra maneira de fazer todo esse processo é a seguinte:



1. Criar o código-objeto:

nasm -f hello.asm




2. Linkando



32 bits:

ld hello.o -o hello



64 bits:

ld -m elf_i386 hello.o -o hello
Ler Tutorial

Primeiro programa em Assembly - Como fazer o Hello World (Olá Mundo)

Agora que você já sabe instalar o NASM, vamos ensinar como criar seu programa em Assembly.

É um texto com o código em Assembly para você ir se familiarizando.

Tenha em mente que este é apenas o primeiro passo para programar nessa linguagem.

Nos próximos tutoriais vamos ensinar os procedimentos para executar um programa em Assembly, bem como explicar detalhadamente o significado de cada comando nessa verdadeira sopa de letrinhas.

Não se assuste, em breve você entenderá tudo perfeitamente e dominará esse bela e poderosa linguagem de programação.



Código do Hello World em Assembly

Crie um arquivo de texto com o nome "hello.asm" e escreve o seguinte código dentro dele:



section .data
msg     db      'Como programar em Assembly - Curso Assembly Progressivo', 0AH
len     equ     $-msg
 
section .text
global  _start
_start: mov     edx, len
        mov     ecx, msg
        mov     ebx, 1
        mov     eax, 4
        int     80h
 
        mov     ebx, 0
        mov     eax, 1
        int     80h




Sim, todas essas linhas de código são para exibir a mensagem "Como programar em Assembly - Curso Assembly Progressivo".


Esse, porém é um código 'humano', pois usamos mnemônicos, que são símbolos e códigos para que nós possamos entender.

Obviamente, os computadores não leem como as pessoas, eles simplesmente obedece aos comandos em binários.


E é isso que vamos ensinar no próximo tutorial, sobre como criar os object files (código objeto) e linkar arquivos em Assembly, nós vamos ensinar como transformar esse código humano em código binário.

Vamos montar (e não compilar) tal código, que é o que seu computador realmente vai entender e obedecer.


O código de máquina será o código objeto, que são arquivos com extensão .o

Em seguida, o próximo passo é reunir todos esses object files, bem como códigos que usamos de outras bibliotecas, e criar um executável. Ou seja, vamos linkar, agrupar tudo que é necessário para rodar o programa...

























Ler Tutorial

Como programar em Assembly no Windows – Instalando o Assembler NASM

Para começarmos a programar na linguagem de programação Assembly, precisamos de um programando chamado Assembler, que irá converter nosso código para um código que a
máquina irá entender.

Vamos usar o NASM (NetWide Assembler), que pode ser usado
no Windows ou no Linux.

Nesse tutorial de nosso curso de Assembly, vamos ensinar como instalar esse Assembler no sistema operacional Windows.


Diferente do que os usuários de Windows devem estar acostumados, a utilização desse programa se dará pelo terminal de comando, o MS-DOS (sim, aquela tela preta).


Baixando o NASM

Para baixar o NASM vá na página oficial do Netwide
Assembler:

Como o projeto continua se desenvolvendo, não podemos
especificar uma versão, pois no momento que você estiver lendo esse tutorial de
Assembly a versão oficial do NASM pode ser diferente da versão usada pelo
Assembly Progressivo.

Portanto, ao entrar no website, clique na seção de
Downloads, e em seguida abra o diretório da versão mais recente.
Lá você verá um vários diretórios com nome dos mais
diversos sistemas operacionais, neste tutorial vamos ensinar a instalação no Windows.





























Como instalar o NASM no Windows

Se estiver usando Windows, escolha o diretório Win32,
e dentro dele baixe diretamente o executável ou arquivo zipado.

No arquivo zipado, você deve descompactar o arquivo e
colocar o nasm.exe e outros arquivos/pasta no diretório de seu sistema
(geralmente é a pasta C:\Windows\System32), pois o NASM precisa estar no path do DOS (digite path no cmd.exe e
veja seu path).

Para checar se você instalou corretamente o NASM, vá no
menu iniciar e digite cmd, e abra o cmd.exe.
Uma tela do MS-DOS deverá abrir. Digite o seguinte
comando:
nasm –h

É o comando de help,
ou seja, para pedir ajuda ao NASM.
Caso apareça uma avalanche de texto, é porque está tudo
ok com seu Assembler.

Pronto, somente isso é o necessário para começar a programar em Assembly.


Ler Tutorial

Veja também: