nasm

Assemble source.asm into a binary file source, in the (default) raw binary format

$ nasm [source.asm]

$ nasm -f [format] [source.asm] -o [output_file]

$ nasm -hf

$ nasm -l [list_file] [source.asm]

$ nasm -i [path/to/include_dir/] [source.asm]

nasm [options] filename [-o outputfile] [-l listfile] [-f format]

filename
    The input assembly source file.

-o outputfile
    Specifies the output file name. If not specified, the assembler may attempt to determine a default name based on the input file name or the selected output format.

-l listfile
    Generates a listing file containing the assembled code alongside the source code.

-f format
    Specifies the output object file format. Common formats include bin (raw binary), elf32, elf64, coff, macho32, macho64, win32, win64, and aout. Use nasm -hf for a complete list.

-I path
    Adds a directory to the include file search path.

-D macro[=value]
    Defines a preprocessor macro.

-U macro
    Undefines a preprocessor macro.

-E
    Preprocess only (don't assemble).

-M
    Generate Makefile dependencies.

-w+warning
    Enable a specific warning.

-w-warning
    Disable a specific warning.

-g
    Enable debugging information output (e.g., DWARF).

NASM (Netwide Assembler) is a free and open-source assembler for the x86 architecture. It's designed for portability and modularity, supporting a wide range of object file formats, including those used by Linux, Windows, and other operating systems. NASM excels at assembling small, highly optimized code snippets for bootloaders, device drivers, system programming, and performance-critical sections of larger applications.

It features a simple and powerful macro system, allowing for code reuse and abstraction. NASM supports multiple assembly syntaxes and preprocessor directives. It's considered highly customizable and often preferred by developers needing fine-grained control over the generated machine code. Unlike some assemblers, NASM's primary focus is to generate efficient machine code, so it provides fewer features for direct linking or high-level debugging.

NASM is frequently used in the context of security research and exploit development due to its ability to create position-independent code (PIC) and control instruction encoding.

NASM does not perform linking. The resulting object files must be linked using a separate linker (e.g., ld). It supports limited high-level debugging functionality compared to compiler toolchains like GCC or Clang.

NASM uses the Intel syntax, which means the destination operand comes before the source operand in instructions (e.g., `mov eax, ebx`). It's important to be aware of this, especially if you're accustomed to AT&T syntax used by GNU assembler.

Assembly code is typically organized into sections, such as `.text` (for executable code), `.data` (for initialized data), and `.bss` (for uninitialized data). These sections are important for linking and loading the program.

NASM's macro system provides a powerful way to define reusable code snippets. Macros can take arguments and perform complex operations based on those arguments.

NASM was initially developed in the late 1990s by Julian Smart and Simon Tatham. Its primary goal was to create a portable, modular, and free x86 assembler. It quickly gained popularity due to its ease of use, support for multiple platforms, and powerful macro system. It is under active development to this day and continues to adapt to the evolving x86 instruction set architectures.

ld(1), objdump(1)