Netwide Assembler

Short description: Assembler for the Intel x86 architecture

NASM

Original author(s)| Simon Tatham, Julian Hall
Developer(s)| H. Peter Anvin, Chang Seok Bae, Jim Kukunas, Frank B. Kotler, Cyrill Gorcunov
Initial release| October 1996; 29 years ago (1996-10)
Stable release|

2.16.01 / December 21, 2022; 3 years ago (2022-12-21)

Written in| Assembly, C[1]
Operating system| Unix-like, Windows, OS/2, MS-DOS
Available in| English
Type| x86 assembler
License| BSD 2-clause
Website| www.nasm.us

The Netwide Assembler (NASM) is an assembler and disassembler for the Intel x86 architecture. It can be used to write 16-bit, 32-bit (IA-32) and 64-bit (x86-64) programs. It is considered one of the most popular assemblers for Linux and x86 chips.[2]

It was originally written by Simon Tatham with assistance from Julian Hall. As of 2016[update], it is maintained by a small team led by H. Peter Anvin.[3] It is open-source software released under the terms of a simplified (2-clause) BSD license.[4]

## Contents

* 1 Features
* 2 Sample programs
* 3 Linking
* 4 Development
* 4.1 RDOFF
* 5 See also
* 6 References
* 7 Further reading
* 8 External links

## Features

NASM can output several binary formats, including COFF, OMF, a.out, Executable and Linkable Format (ELF), Mach-O and binary file (.bin, binary disk image, used to compile operating systems), though position-independent code is supported only for ELF object files. It also has its own binary format called RDOFF.[5]

The variety of output formats allows retargeting programs to virtually any x86 operating system (OS). It can also create flat binary files, usable to write boot loaders, read-only memory (ROM) images, and in various facets of OS development.[5] It can run on non-x86 platforms as a cross assembler, such as PowerPC and SPARC, though it cannot generate programs usable by those machines.

NASM uses a variant of Intel assembly syntax instead of AT&T syntax.[6] It also avoids features such as automatic generation of segment overrides (and the related ASSUME directive) used by MASM and compatible assemblers.[5]

## Sample programs

A "Hello, world!" program for the DOS operating system:

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, '$'

An equivalent program for 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

An example of a similar program for 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

A 64-bit program for Apple OS X that inputs a keystroke and shows it on the screen:

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

NASM principally outputs object files, which are generally not executable by themselves. The only exception to this are flat binaries (e.g., .COM)[5] which are inherently limited in modern use. To translate the object files into executable programs, an appropriate linker must be used, such as the Visual Studio "LINK" utility for Windows or ld for Unix-like systems.

## Development

NASM version 0.90 was released in October 1996.[4]

Version 2.00 was released on 28 November 2007, adding support for x86-64 extensions.[3] The development versions are not uploaded to SourceForge.net, but are checked into GitHub with binary snapshots available from the project web page.

A search engine for NASM documentation is also available.[7]

In July 2009, as of version 2.07, NASM was released under the Simplified (2-clause) BSD license. Previously, because it was licensed under LGPL, it led to development of Yasm, a complete rewrite of under the New BSD License. Yasm offered support for x86-64 earlier than NASM. It also added support for GNU Assembler syntax.

### RDOFF

Relocatable Dynamic Object File Format (RDOFF) is used by developers to test the integrity of NASM's object file output abilities. It is based heavily on the internal structure of NASM,[8] essentially consisting of a header containing a serialization of the output driver function calls followed by an array of sections containing executable code or data. Tools for using the format, including a linker and loader, are included in the NASM distribution.

Until version 0.90 was released in October 1996, NASM supported output of only flat-format executable files (e.g., DOS COM files). In version 0.90, Simon Tatham added support for an object-file output interface, and for DOS .OBJ files for 16-bit code only.[9]

NASM thus lacked a 32-bit object format. To address this lack, and as an exercise to learn the object-file interface, developer Julian Hall put together the first version of RDOFF, which was released in NASM version 0.91.[9]

Since this initial version, there has been one major update to the RDOFF format, which added a record-length indicator on each header record,[10] allowing programs to skip over records whose format they do not recognise, and support for multiple segments; RDOFF1 only supported three segments: text, data and bss (containing uninitialized data).[8]

The RDOFF format is strongly deprecated and has been disabled starting in NASM 2.15.04.[11]

## See also

* Assembly language
* Comparison of assemblers

## References

1. ↑ "NASM, the Netwide Assembler". 25 October 2021. https://github.com/netwide-assembler/nasm.
2. ↑ Ram Narayan. "Linux assemblers: A comparison of GAS and NASM". http://www.ibm.com/developerworks/linux/library/l-gas-nasm/index.html. "two of the most popular assemblers for Linux, GNU Assembler (GAS) and Netwide Assembler (NASM)"
3. ↑ 3.0 3.1 "The Netwide Assembler". http://nasm.sourceforge.net/.
4. ↑ 4.0 4.1 "NASM Version History". https://www.nasm.us/doc/nasmdocc.html.
5. ↑ 5.0 5.1 5.2 5.3 "NASM Manual". http://alien.dowling.edu/~rohit/nasmdoc0.html.
6. ↑ Randall Hyde. "NASM: The Netwide Assembler". http://webster.cs.ucr.edu/AsmTools/NASM/.
7. ↑ "NASM Doc Search Engine". http://alien.dowling.edu/~rohit/search/srch/search.php.
8. ↑ 8.0 8.1 "NASM Manual Ch. 6". http://nasm.sourceforge.net/doc/nasmdoc6.html.
9. ↑ 9.0 9.1 "NASM CVS". 2008-06-08. http://nasm.cvs.sourceforge.net/nasm/nasm/CHANGES?revision=1.48&view=markup.
10. ↑ "V1-V2.txt". 2002-12-04. http://nasm.cvs.sourceforge.net/nasm/nasm/rdoff/doc/v1-v2.txt?revision=1.1&view=markup.
11. ↑ "Relocatable Dynamic Object File Format (deprecated)". https://www.nasm.us/doc/nasmdoc8.html#section-8.13.

## Further reading

* Jeff Duntemann (2000). Assembly Language Step by Step. J Wiley and Sons. ISBN 0-471-37523-3. https://archive.org/details/assemblylanguage0000dunt_c8n9.

## External links

* Netwide Assembler on SourceForge.net
* Special edition for Win32 and BeOS.
* A comparison of GAS and NASM at IBM
* "Netwide Assembler". http://freecode.com/projects/intel2gas/. : a converter between the source format of the assemblers NASM and GAS

* v
* t
* e

x86 assembly topics

Topics|

* Assembly language
* Comparison of assemblers
* Disassembler
* Instruction set
* Low-level programming language
* Machine code
* Microassembler
* x86 assembly language

Assemblers|

* A86/A386
* Flat Assembler (FASM)
* GNU Assembler (GAS)
* High Level Assembly (HLA)
* Microsoft Macro Assembler (MASM)
* Netwide Assembler (NASM)
* Turbo Assembler (TASM)
* Open Watcom Assembler (WASM)

Programming
issues|

* Call stack
* Flags
* Carry flag
* Direction flag
* Interrupt flag
* Overflow flag
* Zero flag
* Opcode
* Program counter
* Processor register
* Calling conventions
* Instruction listings
* Registers

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Netwide Assembler. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Software:Netwide_Assembler&oldid=735880"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template