Netwide Assembler - Netwide Assembler

Netwide Assembler
Logotipo da NASM
Autor (es) original (is) Simon Tatham , Julian Hall
Desenvolvedor (s) H. Peter Anvin , et al.
lançamento inicial Outubro 1996 ; 24 anos atras  ( 1996-10 )
Versão estável
15/02/05/28 de agosto de 2020 ; 6 meses atrás  ( 2020-08-28 )
Repositório Edite isso no Wikidata
Escrito em Montagem , C
Sistema operacional Semelhante ao Unix , Windows , OS / 2 , MS-DOS
Disponível em inglês
Modelo x86 assembler
Licença BSD 2-cláusula
Local na rede Internet www .nasm .us

O Netwide Assembler ( NASM ) é um montador e desmontador para a arquitetura Intel x86 . Ele pode ser usado para escrever programas de 16 bits , 32 bits ( IA-32 ) e 64 bits ( x86-64 ). NASM é considerado um dos montadores mais populares para Linux .

NASM foi originalmente escrito por Simon Tatham com assistência de Julian Hall. Em 2016, ele é mantido por uma pequena equipe liderada por H. Peter Anvin . É um software de código aberto lançado sob os termos de uma licença BSD simplificada (2 cláusulas) .

Características

NASM pode produzir vários formatos binários, incluindo COFF , OMF, a.out , Executable and Linkable Format (ELF), Mach-O e arquivo binário (.bin, imagem de disco binário, usado para compilar sistemas operacionais ), embora código independente de posição é compatível apenas com arquivos de objeto ELF . NASM também tem seu próprio formato binário chamado RDOFF.

A variedade de formatos de saída permite programas de redirecionamento para virtualmente qualquer sistema operacional (SO) x86. Além disso, o NASM pode criar arquivos binários simples , utilizáveis ​​para gravar carregadores de inicialização , imagens de memória somente leitura (ROM) e em várias facetas de desenvolvimento de sistema operacional. O NASM pode ser executado em plataformas não x86 como um cross assembler , como PowerPC e SPARC , embora não possa gerar programas utilizáveis ​​por essas máquinas.

O NASM usa uma variante da sintaxe de montagem da Intel em vez da sintaxe AT&T . Ele também evita recursos como geração automática de substituições de segmento (e a diretiva ASSUME relacionada) usada por MASM e montadores compatíveis.

Exemplos de programas montados para vários sistemas operacionais

Este é um "Olá, mundo!" programa para o sistema operacional DOS . 

section .text
org 0x100
	mov	ah, 0x9
	mov	dx, hello
	int	0x21

	mov	ax, 0x4c00
	int	0x21

section .data
hello:	db 'Hello, world!', 13, 10, '$'

Um programa equivalente para Linux : 

global _start

section .text
_start:
	mov	eax, 4 ; write
	mov	ebx, 1 ; stdout
	mov	ecx, msg
	mov	edx, msg.len
	int	0x80   ; write(stdout, msg, strlen(msg));

	xor	eax, msg.len ; invert return value from write()
	xchg eax, ebx ; value for exit()
	mov	eax, 1 ; exit
	int	0x80   ; exit(...)

section .data
msg:	db	"Hello, world!", 10
.len:	equ	$ - msg

Um exemplo de programa semelhante para Microsoft Windows : 

global _main
extern _MessageBoxA@16
extern _ExitProcess@4

section code use32 class=code
_main:
	push	dword 0      ; UINT uType = MB_OK
	push	dword title  ; LPCSTR lpCaption
	push	dword banner ; LPCSTR lpText
	push	dword 0      ; HWND hWnd = NULL
	call	_MessageBoxA@16

	push	dword 0      ; UINT uExitCode
	call	_ExitProcess@4

section data use32 class=data
	banner:	db 'Hello, world!', 0
	title:	db 'Hello', 0

Abaixo está um programa de 64 bits para Apple OS X que insere um pressionamento de tecla e o mostra na tela 

global _start

section .data

	query_string:		db	"Enter a character:  "
	query_string_len:	equ	$ - query_string
	out_string:			db	"You have input:  "
	out_string_len:		equ	$ - out_string

section .bss

	in_char:			resw 4

section .text

_start:

	mov	rax, 0x2000004	 	; put the write-system-call-code into register rax
	mov	rdi, 1				; tell kernel to use stdout
	mov	rsi, query_string	; rsi is where the kernel expects to find the address of the message
	mov	rdx, query_string_len	; and rdx is where the kernel expects to find the length of the message 
	syscall

	; read in the character
	mov	rax, 0x2000003		; read system call
	mov	rdi, 0				; stdin
	mov	rsi, in_char		; address for storage, declared in section .bss
	mov	rdx, 2				; get 2 bytes from the kernel's buffer (one for the carriage return)
	syscall

	; show user the output
	mov	rax, 0x2000004		; write system call
	mov	rdi, 1				; stdout
	mov	rsi, out_string
	mov	rdx, out_string_len
	syscall

	mov	rax, 0x2000004		; write system call
	mov	rdi, 1				; stdout
	mov	rsi, in_char
	mov	rdx, 2				; the second byte is to apply the carriage return expected in the string
	syscall

	; exit system call
	mov	rax, 0x2000001		; exit system call
	xor     rdi, rdi
	syscall

Linking

O NASM produz principalmente arquivos de objeto , que geralmente não são executáveis ​​por si próprios. A única exceção a isso são os binários simples (por exemplo, .COM ), que são inerentemente limitados no uso moderno. Para traduzir os arquivos objeto em programas executáveis, um vinculador apropriado deve ser usado, como o utilitário "LINK" do Visual Studio para Windows ou ld para sistemas semelhantes ao Unix.

Desenvolvimento

O primeiro lançamento, versão 0.90, foi lançado em outubro de 1996.

Em 28 de novembro de 2007, a versão 2.00 foi lançada, adicionando suporte para extensões x86-64 . As versões de desenvolvimento não são carregadas no SourceForge.net ; em vez disso, eles são verificados no GitHub com instantâneos binários disponíveis na página da web do projeto.

Um mecanismo de busca para documentação NASM também está disponível.

Em julho de 2009, a partir da versão 2.07, o NASM foi lançado sob a licença BSD simplificada (2 cláusulas). Anteriormente, como o NASM era licenciado sob a LGPL , isso levou ao desenvolvimento do Yasm, uma reescrita completa do NASM sob a nova licença BSD . Yasm ofereceu suporte para x86-64 antes do NASM. Ele também adicionou suporte para sintaxe GNU Assembler .

RDOFF

RDOFF
Desenvolvido por Julian Hall
Tipo de formato Formato de arquivo de objeto
Recipiente para Código do objeto

O formato de arquivo de objeto dinâmico realocável (RDOFF) é usado por desenvolvedores para testar a integridade das habilidades de saída de arquivo de objeto do NASM. É muito baseado na estrutura interna do NASM, consistindo essencialmente em um cabeçalho contendo uma serialização das chamadas de função do driver de saída seguido por uma matriz de seções contendo código executável ou dados. Ferramentas para usar o formato, incluindo um vinculador e carregador, estão incluídas na distribuição NASM.

Até a versão 0.90 ser lançada em outubro de 1996, o NASM suportava a saída apenas de arquivos executáveis ​​de formato plano (por exemplo, arquivos DOS COM ). Na versão 0.90, Simon Tatham adicionou suporte para uma interface de saída de arquivo de objeto e para arquivos DOS .OBJ apenas para código de 16 bits.

NASM, portanto, não tinha um formato de objeto de 32 bits. Para resolver essa falta, e como um exercício para aprender a interface objeto-arquivo, o desenvolvedor Julian Hall montou a primeira versão do RDOFF, que foi lançado no NASM versão 0.91.

Desde esta versão inicial, houve uma grande atualização no formato RDOFF, que adicionou um indicador de comprimento de registro em cada registro de cabeçalho, permitindo que os programas ignorassem os registros cujo formato eles não reconhecem e suporte para vários segmentos; RDOFF1 suportava apenas três segmentos: texto , dados e bss (contendo dados não inicializados).

Veja também

Referências

Leitura adicional

links externos