x86 Assembly Series Part 6: Complete Assembler Comparison

Mainstream Assemblers

NASM (Netwide Assembler)

NASM is the most popular cross-platform assembler, known for its clean Intel syntax and excellent documentation. It produces output for multiple object file formats including ELF, PE/COFF, Mach-O, and raw binary.

; hello_nasm.asm - 64-bit Linux
section .data
    msg db "Hello from NASM!", 10
    len equ $ - msg

section .text
    global _start

_start:
    mov rax, 1          ; sys_write
    mov rdi, 1          ; stdout
    mov rsi, msg        ; buffer
    mov rdx, len        ; length
    syscall

    mov rax, 60         ; sys_exit
    xor rdi, rdi        ; exit code 0
    syscall

Key NASM Features

• Preprocessor: Powerful macro system with %macro, %define, %rep
• Local labels: .done: syntax for procedure-scoped labels
• Data directives: db, dw, dd, dq for defining data
• Output formats: -f elf64, -f win64, -f macho64, -f bin

MASM (Microsoft Macro Assembler)

MASM is Microsoft's assembler, tightly integrated with Visual Studio. It offers high-level features like PROC/ENDP, INVOKE, and structured programming constructs that can simplify Windows development.

Key MASM Features

• PROC/ENDP: Procedure definition with automatic prologue/epilogue
• INVOKE: High-level function call syntax with type checking
• PROTO: Function prototype declarations for type safety
• Structured directives: .IF, .WHILE, .REPEAT
• Tools: ml.exe (32-bit), ml64.exe (64-bit)

; Using MASM's INVOKE for cleaner API calls
includelib kernel32.lib
includelib user32.lib

MessageBoxA PROTO :DWORD, :DWORD, :DWORD, :DWORD
ExitProcess PROTO :DWORD

.data
    szTitle  db "MASM Demo", 0
    szMsg    db "High-level INVOKE syntax!", 0

.code
main PROC
    INVOKE MessageBoxA, 0, ADDR szMsg, ADDR szTitle, 0
    INVOKE ExitProcess, 0
main ENDP
END main

GAS (GNU Assembler)

GAS (GNU Assembler, invoked as as) is part of GNU Binutils and the default assembler for GCC. It traditionally uses AT&T syntax but supports Intel syntax via directives. GAS is essential for kernel development and compiler output.

# hello_gas.s - 64-bit Linux (AT&T syntax)
.section .data
msg:
    .ascii "Hello from GAS!\n"
    len = . - msg

.section .text
.globl _start

_start:
    movq $1, %rax           # sys_write
    movq $1, %rdi           # stdout
    leaq msg(%rip), %rsi    # buffer (RIP-relative)
    movq $len, %rdx         # length
    syscall

    movq $60, %rax          # sys_exit
    xorq %rdi, %rdi         # exit code 0
    syscall

# hello_gas_intel.s - Using Intel syntax in GAS
.intel_syntax noprefix

.section .data
msg:
    .ascii "Hello from GAS (Intel)!\n"
    len = . - msg

.section .text
.globl _start

_start:
    mov rax, 1              # sys_write
    mov rdi, 1              # stdout
    lea rsi, [rip + msg]    # buffer
    mov rdx, len            # length
    syscall

    mov rax, 60             # sys_exit
    xor rdi, rdi
    syscall

Key GAS Features

• Directives: .section, .globl, .ascii, .byte, .long, .quad
• Syntax switch: .intel_syntax noprefix / .att_syntax
• Comments: # for line comments, /* */ for block comments
• Integration: Direct output from gcc -S, inline asm compatibility

Specialized Assemblers

FASM (Flat Assembler)

FASM is a self-hosting assembler (written in assembly!) known for its powerful macro system, minimal dependencies, and ability to create pure binary files. Popular in the demo scene and OS development communities.

; hello_fasm.asm - FASM syntax
format ELF64 executable
entry _start

segment readable executable

_start:
    mov eax, 1              ; sys_write
    mov edi, 1              ; stdout
    mov rsi, msg
    mov edx, msg_len
    syscall

    mov eax, 60             ; sys_exit
    xor edi, edi
    syscall

segment readable writeable

msg db 'Hello from FASM!', 10
msg_len = $ - msg

Key FASM Features

• Self-hosting: The assembler is written in itself—no runtime dependencies
• Multiple output: format PE64, format ELF64 executable, format binary
• Powerful macros: Can define complex structures and pseudo-instructions
• Direct executable: Can produce executables without a linker
• Variants: fasm (original), fasmg (next-gen with improved macro system)

; boot.asm - Simple bootloader in FASM
format binary
use16
org 0x7C00

start:
    mov ax, 0x07C0
    mov ds, ax
    mov si, message
    
print_loop:
    lodsb
    or al, al
    jz hang
    mov ah, 0x0E
    int 0x10
    jmp print_loop

hang:
    jmp hang

message db 'Hello from bootloader!', 0

times 510 - ($ - $$) db 0
dw 0xAA55

YASM

YASM is a rewrite of NASM designed for better performance and modularity. It's particularly popular for media codec development (x264, x265, FFmpeg) due to its speed and NASM compatibility.

; simd_yasm.asm - SIMD example (YASM/NASM compatible)
section .data
    align 16
    vec1: dd 1.0, 2.0, 3.0, 4.0
    vec2: dd 5.0, 6.0, 7.0, 8.0

section .bss
    align 16
    result: resd 4

section .text
    global vec_add

; void vec_add(void)
vec_add:
    movaps xmm0, [rel vec1]
    movaps xmm1, [rel vec2]
    addps xmm0, xmm1
    movaps [rel result], xmm0
    ret

Key YASM Features

• NASM-compatible: Drop-in replacement for most NASM code
• GAS-compatible: Can also parse GAS/AT&T syntax
• Performance: Generally faster assembly times than NASM
• Modular: Supports multiple parsers and output formats
• Note: Development has slowed; NASM has caught up in features

UASM

UASM (JWASM fork) is a MASM-compatible assembler that runs on multiple platforms. It offers MASM syntax compatibility with modern extensions, making it ideal when you need MASM features on non-Windows systems.

; hello_uasm.asm - MASM syntax on Linux via UASM
.686
.model flat, stdcall
option casemap:none

.data
    msg db "Hello from UASM!", 10, 0
    
.code
_start:
    ; sys_write(1, msg, 17)
    mov eax, 4
    mov ebx, 1
    mov ecx, OFFSET msg
    mov edx, 17
    int 80h
    
    ; sys_exit(0)
    mov eax, 1
    xor ebx, ebx
    int 80h

end _start

Key UASM Features

• MASM-compatible: Supports PROC, INVOKE, PROTO, structured directives
• Cross-platform: Runs on Windows, Linux, macOS
• Modern ISA: Full AVX, AVX2, AVX-512 support
• Output formats: ELF, PE/COFF, OMF, BIN
• HJWasm-64: Variant with enhanced 64-bit support

LLVM AS (LLVM Assembler)

LLVM AS (llvm-mc) is the assembler in the LLVM toolchain. It's primarily used in compiler pipelines and integrates with Clang. While you can use it directly, it's most commonly encountered when examining or generating LLVM/Clang output.

# hello_llvm.s - Using llvm-mc
.text
.globl _start

_start:
    movl $1, %eax           # sys_write
    movl $1, %edi           # stdout
    leaq msg(%rip), %rsi    # buffer
    movl $18, %edx          # length
    syscall

    movl $60, %eax          # sys_exit
    xorl %edi, %edi
    syscall

.data
msg:
    .ascii "Hello from LLVM!\n"

Key LLVM AS Features

• Multiple targets: x86, ARM, RISC-V, AArch64, and more
• Integration: Part of LLVM toolchain alongside lld linker
• Directives: Similar to GAS but with LLVM-specific extensions
• Tool: llvm-mc is the actual assembler binary
• Intel syntax: Use -x86-asm-syntax=intel flag

Syntax Comparison

Intel vs AT&T Syntax

Operand Size Handling

Memory Addressing Syntax

; General form: [base + index*scale + displacement]

; Intel syntax (NASM/MASM/FASM/YASM/UASM):
mov rax, [rbx + rcx*4 + 16]    ; Full addressing mode
mov rax, [rip + label]          ; RIP-relative (64-bit)

; AT&T syntax (GAS/LLVM):
movq 16(%rbx,%rcx,4), %rax     ; disp(base,index,scale)
leaq label(%rip), %rax          ; RIP-relative

Cross-Platform Strategies

When developing assembly code that needs to work across platforms, you have several approaches:

Strategy 1: Use NASM with Conditional Assembly

; cross_platform.asm - Single source, multiple targets
%ifdef LINUX
    %define SYS_write 1
    %define SYS_exit  60
%elifdef WINDOWS
    extern WriteFile
    extern ExitProcess
%endif

section .text
global _start

_start:
%ifdef LINUX
    mov rax, SYS_write
    mov rdi, 1
    mov rsi, msg
    mov rdx, len
    syscall
%elifdef WINDOWS
    ; Windows API calls would go here
%endif

Strategy 2: Separate Platform Files

Maintain separate source files per platform with shared logic in header files:

• core.inc - Shared macros and constants
• linux_x64.asm - Linux-specific entry points
• win_x64.asm - Windows-specific entry points

Strategy 3: Use UASM for MASM Portability

If you prefer MASM syntax but need to compile on Linux, UASM provides MASM compatibility across platforms.

Choosing the Right Assembler

Decision Matrix

Summary Recommendations

• NASM: Best all-around choice for learning and cross-platform work
• MASM: Best for Windows-only projects with Visual Studio
• GAS: Essential for Linux kernel work and understanding compiler output
• FASM: Best for OS development, bootloaders, and minimalist projects
• YASM: Good for multimedia projects (though NASM has caught up)
• UASM: Best when you need MASM features on non-Windows systems
• LLVM AS: Best for compiler developers and LLVM-based toolchains