Netwide Assembler
Lua error in package.lua at line 80: module 'strict' not found.
![]() |
|
Original author(s) | Simon Tatham, Julian Hall |
---|---|
Developer(s) | H. Peter Anvin, et al. |
Stable release | 2.11.08 / February 21, 2015 |
Operating system | Microsoft Windows, Unix-like, OS/2, OS X, DOS |
Available in | English |
Type | x86 assembler |
License | 2-clause BSD |
Website | www |
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. NASM is considered to be one of the most popular assemblers for Linux.[1]
NASM was originally written by Simon Tatham with assistance from Julian Hall and is currently maintained by a small team led by H. Peter Anvin.[2] It is open-source software available under the terms of the simplified (2-clause) BSD license.[3]
Contents
Features
NASM can output several binary formats including COFF, Portable Executable, a.out, ELF, Mach-O and .bin (binary disk image, used for compiling operating systems), though position-independent code is only supported for ELF object files. NASM also has its own binary format called RDOFF.[4]
The variety of output formats allows programs to be retargeted to virtually any x86 operating system. In addition, NASM can create flat binary files, usable in writing boot loaders, ROM images, and in various facets of OS development.[4] NASM can run on non-x86 platforms, such as SPARC and PowerPC, though it cannot generate programs usable by those machines.
NASM uses a variation of Intel assembly syntax instead of AT&T syntax.[5] It also avoids features such as automatic generation of segment overrides (and the related ASSUME directive) used by MASM and compatible assemblers.[4]
Examples of programs for various operating systems
This is 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 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
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));
mov eax, 1 ; exit
mov ebx, 0
int 0x80 ; exit(0)
section .data
msg: db "Hello, world!", 10
.len: equ $ - msg
Below is 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
mov rdi, 0
syscall
Linking
NASM principally outputs object files, which are generally not executable in and of themselves. The only exception to this are flat binaries (e.g., .COM)[4] 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
On 28 November 2007, version 2.00 was released, adding support for x86-64 extensions.[2] The development versions are not uploaded to SourceForge.net; instead, they are checked in to the project's own Git repository with binary snapshots available from the project web page.
A search engine for NASM docs is also available.[6]
As of version 2.07, NASM is now under the Simplified (2-clause) BSD license.
RDOFF
Developed by | Julian Hall |
---|---|
Type of format | Object file format |
Container for | Object code |
RDOFF (Relocatable Dynamic Object File Format) is used by developers to test the integrity of NASM's object file output capabilities. It is based heavily on the internal structure of NASM,[7] 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 of NASM was released in October 1996, NASM only supported output of flat-format executable files (e.g. MS-DOS COM files). In version 0.90, Simon Tatham added support for an object-file output interface, along with support for DOS .OBJ files for 16-bit code only.[8]
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.[8]
Since this initial version, there has been one major update to the RDOFF format, which added a record-length indicator on each header record,[9] 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).[7]
See also
References
- ↑ Lua error in package.lua at line 80: module 'strict' not found.
- ↑ 2.0 2.1 Lua error in package.lua at line 80: module 'strict' not found.
- ↑ Lua error in package.lua at line 80: module 'strict' not found.
- ↑ 4.0 4.1 4.2 4.3 Lua error in package.lua at line 80: module 'strict' not found.
- ↑ Lua error in package.lua at line 80: module 'strict' not found.
- ↑ Lua error in package.lua at line 80: module 'strict' not found.
- ↑ 7.0 7.1 Lua error in package.lua at line 80: module 'strict' not found.
- ↑ 8.0 8.1 Lua error in package.lua at line 80: module 'strict' not found.
- ↑ Lua error in package.lua at line 80: module 'strict' not found.
Further reading
- Lua error in package.lua at line 80: module 'strict' not found.
External links
- Netwide Assembler main page
- Netwide Assembler on SourceForge.net
- Special edition for Win32 and BeOS.
- A comparison of GAS and NASM at IBM
- intel2gas : a converter between the source format of the NASM and GAS assemblers