Index

Index
Prev

Symbols

!=, %if: Testing Arbitrary Numeric Expressions

$

here, Expressions
prefix, Layout of a NASM Source Line, Numeric Constants

$$, Expressions, elf32 Special Symbols and WRT

% operator, *, /, //, % and %%: Multiplication and Division

%$, Context-Local Labels

%$$, Context-Local Labels

%%, Macro-Local Labels

%% operator, *, /, //, % and %%: Multiplication and Division

%+, Concatenating Single Line Macro Tokens: %+

%+1, Condition Codes as Macro Parameters

%-1, Condition Codes as Macro Parameters

%0, Default Macro Parameters, %0: Macro Parameter Counter

%assign, Preprocessor Variables: %assign

%clear, Standard Macros

%define, The Normal Way: %define

%elif, Conditional Assembly, %if: Testing Arbitrary Numeric Expressions

%elifctx, %ifctx: Testing the Context Stack

%elifdef, %ifdef: Testing Single-Line Macro Existence

%elifid, %ifid, %ifnum, %ifstr: Testing Token Types

%elifidn, %ifidn and %ifidni: Testing Exact Text Identity

%elifidni, %ifidn and %ifidni: Testing Exact Text Identity

%elifmacro, %ifmacro: Testing Multi-Line Macro Existence

%elifnctx, %ifctx: Testing the Context Stack

%elifndef, %ifdef: Testing Single-Line Macro Existence

%elifnid, %ifid, %ifnum, %ifstr: Testing Token Types

%elifnidn, %ifidn and %ifidni: Testing Exact Text Identity

%elifnidni, %ifidn and %ifidni: Testing Exact Text Identity

%elifnmacro, %ifmacro: Testing Multi-Line Macro Existence

%elifnnum, %ifid, %ifnum, %ifstr: Testing Token Types

%elifnstr, %ifid, %ifnum, %ifstr: Testing Token Types

%elifnum, %ifid, %ifnum, %ifstr: Testing Token Types

%elifstr, %ifid, %ifnum, %ifstr: Testing Token Types

%else, Conditional Assembly

%endrep, Preprocessor Loops

%error, %error: Reporting User-Defined Errors

%exitrep, Preprocessor Loops

%iassign, Preprocessor Variables: %assign

%idefine, The Normal Way: %define

%if, Conditional Assembly, %if: Testing Arbitrary Numeric Expressions

%ifctx, %ifctx: Testing the Context Stack, Example Use of the Context Stack: Block IFs

%ifdef, %ifdef: Testing Single-Line Macro Existence

%ifid, %ifid, %ifnum, %ifstr: Testing Token Types

%ifidn, %ifidn and %ifidni: Testing Exact Text Identity

%ifidni, %ifidn and %ifidni: Testing Exact Text Identity

%ifmacro, %ifmacro: Testing Multi-Line Macro Existence

%ifnctx, %ifctx: Testing the Context Stack

%ifndef, %ifdef: Testing Single-Line Macro Existence

%ifnid, %ifid, %ifnum, %ifstr: Testing Token Types

%ifnidn, %ifidn and %ifidni: Testing Exact Text Identity

%ifnidni, %ifidn and %ifidni: Testing Exact Text Identity

%ifnmacro, %ifmacro: Testing Multi-Line Macro Existence

%ifnnum, %ifid, %ifnum, %ifstr: Testing Token Types

%ifnstr, %ifid, %ifnum, %ifstr: Testing Token Types

%ifnum, %ifid, %ifnum, %ifstr: Testing Token Types

%ifstr, %ifid, %ifnum, %ifstr: Testing Token Types

%imacro, Multi-Line Macros

%include, Including Other Files

%macro, Multi-Line Macros

%pop, The Context Stack, %push and %pop: Creating and Removing Contexts

%push, The Context Stack, %push and %pop: Creating and Removing Contexts

%rep, TIMES: Repeating Instructions or Data, Preprocessor Loops

%repl, %repl: Renaming a Context

%rotate, %rotate: Rotating Macro Parameters

%strlen, String Handling in Macros, String Length: %strlen

%substr, String Handling in Macros, Sub-strings: %substr

%undef, Undefining macros: %undef

%xdefine, Enhancing %define: %xdefine

%xidefine, Enhancing %define: %xdefine

& operator, &: Bitwise AND Operator

&&, %if: Testing Arbitrary Numeric Expressions

* operator, *, /, //, % and %%: Multiplication and Division

+ modifier, Greedy Macro Parameters

+ operator

binary, + and -: Addition and Subtraction Operators
unary, Unary Operators: +, -, ~ and SEG

- operator

binary, + and -: Addition and Subtraction Operators
unary, Unary Operators: +, -, ~ and SEG

--mapfile, Map Files

-f, __YASM_OBJFMT__ and __OUTPUT_FORMAT__: Output Object Format Keyword

-P, Including Other Files

..@, Macro-Local Labels

..@ symbol prefix, Local Labels

..got, elf32 Special Symbols and WRT, elf64 Special Symbols and WRT

..gotoff, elf32 Special Symbols and WRT

..gotpc, elf32 Special Symbols and WRT

..gotpcrel, elf64 Special Symbols and WRT

..plt, elf32 Special Symbols and WRT, elf64 Special Symbols and WRT

..sym, elf32 Special Symbols and WRT, elf64 Special Symbols and WRT

.COM, bin: Flat-Form Binary Output

.nolist, Disabling Listing Expansion

.pdata, win64 Structured Exception Handling

.SYS, bin: Flat-Form Binary Output

.xdata, win64 Structured Exception Handling

/ operator, *, /, //, % and %%: Multiplication and Division

// operator, *, /, //, % and %%: Multiplication and Division

16-bit mode

versus 32-bit mode, BITS

32-bit mode

versus 64-bit mode, BITS

<, %if: Testing Arbitrary Numeric Expressions

<< operator, << and >>: Bit Shift Operators

<=, %if: Testing Arbitrary Numeric Expressions

<>, %if: Testing Arbitrary Numeric Expressions

=, %if: Testing Arbitrary Numeric Expressions

==, %if: Testing Arbitrary Numeric Expressions

>, %if: Testing Arbitrary Numeric Expressions

>=, %if: Testing Arbitrary Numeric Expressions

>> operator, << and >>: Bit Shift Operators

?, RESB and Friends: Declaring Uninitialized Data

[MAP], Map Files

^ operator, ^: Bitwise XOR Operator

^^, %if: Testing Arbitrary Numeric Expressions

_GLOBAL_OFFSET_TABLE_, elf32 Special Symbols and WRT

__FILE__, __FILE__ and __LINE__: File Name and Line Number

__LINE__, __FILE__ and __LINE__: File Name and Line Number

__OUTPUT_FORMAT__, __YASM_OBJFMT__ and __OUTPUT_FORMAT__: Output Object Format Keyword

__SECT__, The __SECT__ Macro, ABSOLUTE: Defining Absolute Labels

__YASM_BUILD__, __YASM_MAJOR__, etc: Yasm Version

__YASM_MAJOR__, __YASM_MAJOR__, etc: Yasm Version

__YASM_MINOR__, __YASM_MAJOR__, etc: Yasm Version

__YASM_OBJFMT__, __YASM_OBJFMT__ and __OUTPUT_FORMAT__: Output Object Format Keyword

__YASM_SUBMINOR__, __YASM_MAJOR__, etc: Yasm Version

__YASM_VERSION_ID__, __YASM_MAJOR__, etc: Yasm Version

__YASM_VER__, __YASM_MAJOR__, etc: Yasm Version

| operator, |: Bitwise OR Operator

||, %if: Testing Arbitrary Numeric Expressions

~ operator, Unary Operators: +, -, ~ and SEG

A

ABS, RIP Relative Addressing, DEFAULT: Change the assembler defaults

ABSOLUTE, ABSOLUTE: Defining Absolute Labels

Addition, + and -: Addition and Subtraction Operators

address-size prefixes, Layout of a NASM Source Line

algebra, Effective Addresses

ALIGN, ALIGN and ALIGNB: Data Alignment, bin Extensions to the SECTION Directive

ALIGNB, ALIGN and ALIGNB: Data Alignment

alignment

of common variables, ELF Extensions to the COMMON Directive

amd64, elf64: Executable and Linkable Format 64-bit Object Files, x86 Architecture

Assembler Directives, NASM Assembler Directives

assembly passes, Critical Expressions

AT, ISTRUC, AT and IEND: Declaring Instances of Structures

B

bin, bin: Flat-Form Binary Output

binary, Numeric Constants

Binary Files, INCBIN: Including External Binary Files

Binary origin, ORG: Binary Origin

Bit Shift, << and >>: Bit Shift Operators

BITS, BITS

Bitwise AND, &: Bitwise AND Operator

Bitwise OR, |: Bitwise OR Operator

Bitwise XOR, ^: Bitwise XOR Operator

Block IFs, Example Use of the Context Stack: Block IFs

braces

after % sign, Concatenating Macro Parameters
around macro parameters, Multi-Line Macros

C

CALL FAR, SEG and WRT

case sensitive, The Normal Way: %define, Enhancing %define: %xdefine, Preprocessor Variables: %assign

case-insensitive, %ifidn and %ifidni: Testing Exact Text Identity

case-sensitive, Multi-Line Macros

changing sections, Changing and Defining Sections

character constant, DB and Friends: Declaring Initialized Data

Character Constants, Character Constants

circular references, The Normal Way: %define

CodeView, cv8: CodeView Debugging Format for VC8

coff, coff: Common Object File Format

COFF

debugging, stabs: Stabs Debugging Format

colon, Layout of a NASM Source Line

commas in macro parameters, Greedy Macro Parameters

COMMON, COMMON: Defining Common Data Areas

Common Object File Format, coff: Common Object File Format

common variables, COMMON: Defining Common Data Areas

alignment in elf, ELF Extensions to the COMMON Directive

Concatenating Macro Parameters, Concatenating Macro Parameters

Condition Codes as Macro Parameters, Condition Codes as Macro Parameters

Conditional Assembly, Conditional Assembly

conditional-return macro, Condition Codes as Macro Parameters

Constants, Constants

Context Stack, The Context Stack, Example Use of the Context Stack: Block IFs

Context-Local Labels, Context-Local Labels

Context-Local Single-Line Macros, Context-Local Single-Line Macros

counting macro parameters, %0: Macro Parameter Counter

CPU, CPU: Defining CPU Dependencies

CPUID, Character Constants

creating contexts, %push and %pop: Creating and Removing Contexts

critical expression, RESB and Friends: Declaring Uninitialized Data, EQU: Defining Constants, Preprocessor Variables: %assign, ABSOLUTE: Defining Absolute Labels

Critical Expressions, Critical Expressions

cv8, cv8: CodeView Debugging Format for VC8

D

data, ELF Extensions to the GLOBAL Directive
DB, Pseudo-Instructions, DB and Friends: Declaring Initialized Data, String Constants
DD, Pseudo-Instructions, DB and Friends: Declaring Initialized Data, String Constants, Floating-Point Constants
DDQ, Pseudo-Instructions, DB and Friends: Declaring Initialized Data
DDQWORD, Layout of a NASM Source Line
Declaring Structure, STRUC and ENDSTRUC: Declaring Structure Data Types
DEFAULT, DEFAULT: Change the assembler defaults
default, ELF Extensions to the GLOBAL Directive
Default Macro Parameters, Default Macro Parameters
Defining Sections, Changing and Defining Sections
Disabling Listing Expansion, Disabling Listing Expansion
Division, *, /, //, % and %%: Multiplication and Division
DO, Pseudo-Instructions, DB and Friends: Declaring Initialized Data
DQ, Pseudo-Instructions, DB and Friends: Declaring Initialized Data, String Constants, Floating-Point Constants
DT, Pseudo-Instructions, DB and Friends: Declaring Initialized Data, Floating-Point Constants
DUP, TIMES: Repeating Instructions or Data
DW, Pseudo-Instructions, DB and Friends: Declaring Initialized Data, String Constants, Floating-Point Constants
DWARF, dwarf2: DWARF2 Debugging Format
dwarf2, dwarf2: DWARF2 Debugging Format
DWORD, Layout of a NASM Source Line

E

effective address, Effective Addresses

effective addresses, Layout of a NASM Source Line

effective-address, Critical Expressions

elf

directives, ELF Directives
elf32, elf32: Executable and Linkable Format 32-bit Object Files
elf64, elf64: Executable and Linkable Format 64-bit Object Files
SECTION, ELF Sections
symbol size, SIZE: Set symbol size
symbol type, TYPE: Set symbol type
weak reference, WEAK: Create weak symbol

ELF

32-bit shared libraries, elf32 Special Symbols and WRT
64-bit shared libraries, elf64 Special Symbols and WRT
debugging, dwarf2: DWARF2 Debugging Format, stabs: Stabs Debugging Format

ENDSTRUC, STRUC and ENDSTRUC: Declaring Structure Data Types, ABSOLUTE: Defining Absolute Labels

EQU, Pseudo-Instructions, EQU: Defining Constants, Critical Expressions

Executable and Linkable Format, elf32: Executable and Linkable Format 32-bit Object Files

64-bit, elf64: Executable and Linkable Format 64-bit Object Files

Exporting Symbols, GLOBAL: Exporting Symbols

Expressions, Expressions

Extended Dynamic Object, xdf: Extended Dynamic Object Format

EXTERN, EXTERN: Importing Symbols

F

far pointer, SEG and WRT

Flash, bin: Flat-Form Binary Output

Flat-Form Binary, bin: Flat-Form Binary Output

floating-point, Layout of a NASM Source Line, DB and Friends: Declaring Initialized Data

constants, Floating-Point Constants

FOLLOWS, bin Extensions to the SECTION Directive

format-specific directives, NASM Assembler Directives

forward references, Critical Expressions

FreeBSD, elf32: Executable and Linkable Format 32-bit Object Files

function, TYPE: Set symbol type, ELF Extensions to the GLOBAL Directive

L

label prefix, Local Labels

library, WEAK: Create weak symbol

Linux

elf, elf32: Executable and Linkable Format 32-bit Object Files, elf64: Executable and Linkable Format 64-bit Object Files

little-endian, Character Constants

LMA, bin Extensions to the SECTION Directive

Local Labels, Local Labels

logical AND, %if: Testing Arbitrary Numeric Expressions

logical OR, %if: Testing Arbitrary Numeric Expressions

logical XOR, %if: Testing Arbitrary Numeric Expressions

M

Mac OSX, macho32: Mach 32-bit Object File Format, macho64: Mach 64-bit Object File Format

Mach-O, macho32: Mach 32-bit Object File Format, macho64: Mach 64-bit Object File Format

macho

macho32, macho32: Mach 32-bit Object File Format
macho64, macho64: Mach 64-bit Object File Format

macro processor, The NASM Preprocessor

Macro-Local Labels, Macro-Local Labels

macros, TIMES: Repeating Instructions or Data

Map file, Map Files

memory operand, Layout of a NASM Source Line

memory reference, Effective Addresses

modulo operators, *, /, //, % and %%: Multiplication and Division

Multi-Line Macros, Multi-Line Macros

Multiplication, *, /, //, % and %%: Multiplication and Division

multipush, %rotate: Rotating Macro Parameters

N

NOSPLIT, Effective Addresses
numeric constant, DB and Friends: Declaring Initialized Data
Numeric Constants, Numeric Constants

O

object, TYPE: Set symbol type, ELF Extensions to the GLOBAL Directive

octal, Numeric Constants

omitted parameters, Default Macro Parameters

one's complement, Unary Operators: +, -, ~ and SEG

operand-size prefixes, Layout of a NASM Source Line

operands, Layout of a NASM Source Line

operators, Expressions

ORG, ORG: Binary Origin

Origin, ORG: Binary Origin

orphan-labels, Layout of a NASM Source Line

overlapping segments, SEG and WRT

overloading

multi-line macros, Overloading Multi-Line Macros
single-line macros, The Normal Way: %define

OWORD, Layout of a NASM Source Line

P

paradox, Critical Expressions
passes, Critical Expressions
PE32+, win64: PE32+ (Microsoft Win64) Object Files
period, Local Labels
PIC, elf32 Special Symbols and WRT, elf64 Special Symbols and WRT
PLT, elf32 Special Symbols and WRT, elf64 Special Symbols and WRT
Position-Independent Code, elf32 Special Symbols and WRT, elf64 Special Symbols and WRT
pre-define, The Normal Way: %define
precedence, Expressions
preferred, SEG and WRT
preprocessor, EQU: Defining Constants
Preprocessor Loops, Preprocessor Loops
Preprocessor Variables, Preprocessor Variables: %assign
primitive directives, NASM Assembler Directives
Processor Mode, Specifying Target Processor Mode
program linkage table, elf32 Special Symbols and WRT, elf64 Special Symbols and WRT
protected, ELF Extensions to the GLOBAL Directive
PUBLIC, GLOBAL: Exporting Symbols
pure binary, bin: Flat-Form Binary Output

Q

QWORD, Layout of a NASM Source Line

R

rdf, rdf: Relocatable Dynamic Object File Format

RDOFF, rdf: Relocatable Dynamic Object File Format

REL, RIP Relative Addressing, DEFAULT: Change the assembler defaults

relational operators, %if: Testing Arbitrary Numeric Expressions

Relocatable Dynamic Object File Format, rdf: Relocatable Dynamic Object File Format

relocations

PIC-specific, elf32 Special Symbols and WRT, elf64 Special Symbols and WRT

removing contexts, %push and %pop: Creating and Removing Contexts

renaming contexts, %repl: Renaming a Context

Repeating, TIMES: Repeating Instructions or Data

repeating code, Preprocessor Loops

RESB, Pseudo-Instructions, RESB and Friends: Declaring Uninitialized Data, Critical Expressions

RESD, Pseudo-Instructions, RESB and Friends: Declaring Uninitialized Data

RESDDQ, Pseudo-Instructions

RESDQ, RESB and Friends: Declaring Uninitialized Data

RESO, Pseudo-Instructions, RESB and Friends: Declaring Uninitialized Data

RESQ, Pseudo-Instructions, RESB and Friends: Declaring Uninitialized Data

REST, Pseudo-Instructions, RESB and Friends: Declaring Uninitialized Data

RESW, Pseudo-Instructions, RESB and Friends: Declaring Uninitialized Data

REX, BITS

RIP, RIP Relative Addressing

Rotating Macro Parameters, %rotate: Rotating Macro Parameters

S

searching for include files, Including Other Files

SECTION, SECTION and SEGMENT

section.length, bin Special Symbols

section.start, bin Special Symbols

section.vstart, bin Special Symbols

SEG, Unary Operators: +, -, ~ and SEG, SEG and WRT

SEGMENT, SECTION and SEGMENT

segment address, Unary Operators: +, -, ~ and SEG, SEG and WRT

segment override, Layout of a NASM Source Line

segments, SEG and WRT

shared library, ELF Extensions to the GLOBAL Directive

shift command, %rotate: Rotating Macro Parameters

signed division, *, /, //, % and %%: Multiplication and Division

signed modulo, *, /, //, % and %%: Multiplication and Division

Single-Line Macros, Single-Line Macros

SIZE, SIZE: Set symbol size

size

of symbols, SIZE: Set symbol size, ELF Extensions to the GLOBAL Directive

Solaris x86, elf32: Executable and Linkable Format 32-bit Object Files

Solaris x86-64, elf64: Executable and Linkable Format 64-bit Object Files

sound, INCBIN: Including External Binary Files

square brackets, Effective Addresses

stabs, stabs: Stabs Debugging Format

Standard Macros, Standard Macros

standardized section names, Standardized Section Names

STRICT, STRICT: Inhibiting Optimization

string constant, DB and Friends: Declaring Initialized Data

String Constants, String Constants

String Handling in Macros, String Handling in Macros

String Length, String Length: %strlen

STRUC, STRUC and ENDSTRUC: Declaring Structure Data Types, ABSOLUTE: Defining Absolute Labels

Sub-strings, Sub-strings: %substr

Subtraction, + and -: Addition and Subtraction Operators

switching between sections, Changing and Defining Sections

symbol sizes

specifying, SIZE: Set symbol size, ELF Extensions to the GLOBAL Directive

symbol types

specifying, TYPE: Set symbol type, ELF Extensions to the GLOBAL Directive

T

testing

arbitrary numeric expressions, %if: Testing Arbitrary Numeric Expressions
context stack, %ifctx: Testing the Context Stack
exact text identity, %ifidn and %ifidni: Testing Exact Text Identity
multi-line macro existence, %ifmacro: Testing Multi-Line Macro Existence
single-line macro existence, %ifdef: Testing Single-Line Macro Existence
token types, %ifid, %ifnum, %ifstr: Testing Token Types

TIMES, Pseudo-Instructions, TIMES: Repeating Instructions or Data, Critical Expressions

two-pass assembler, Critical Expressions

TWORD, Layout of a NASM Source Line

TYPE, TYPE: Set symbol type

type

of symbols, TYPE: Set symbol type, ELF Extensions to the GLOBAL Directive

U

Unary Operators, Unary Operators: +, -, ~ and SEG
uninitialized, Pseudo-Instructions
Uninitialized, RESB and Friends: Declaring Uninitialized Data
UnixWare, elf32: Executable and Linkable Format 32-bit Object Files
unrolled loops, TIMES: Repeating Instructions or Data
unsigned division, *, /, //, % and %%: Multiplication and Division
unsigned modulo, *, /, //, % and %%: Multiplication and Division
unwind data, win64 Structured Exception Handling
USE16, USE16, USE32, and USE64
USE32, USE16, USE32, and USE64
USE64, USE16, USE32, and USE64
User-Defined Errors, %error: Reporting User-Defined Errors
user-level assembler directives, Standard Macros
user-level directives, NASM Assembler Directives

V

Valid characters, Layout of a NASM Source Line
VALIGN, bin Extensions to the SECTION Directive
version control, IDENT: Add file identification
version number of Yasm, __YASM_MAJOR__, etc: Yasm Version
VFOLLOWS, bin Extensions to the SECTION Directive
Visual C++, win32: Microsoft Win32 Object Files, win64: PE32+ (Microsoft Win64) Object Files
Visual C++ 8.0, cv8: CodeView Debugging Format for VC8
Visual Studio 2005, cv8: CodeView Debugging Format for VC8
VMA, bin Extensions to the SECTION Directive

W

WEAK, WEAK: Create weak symbol

weak reference, WEAK: Create weak symbol

win32, win32: Microsoft Win32 Object Files

win64, win64: PE32+ (Microsoft Win64) Object Files

Windows

32-bit, win32: Microsoft Win32 Object Files
64-bit, win64: PE32+ (Microsoft Win64) Object Files

WRT, SEG and WRT, elf32 Special Symbols and WRT, elf64 Special Symbols and WRT

X

x64, win64: PE32+ (Microsoft Win64) Object Files

structured exceptions, win64 Structured Exception Handling

x86, x86 Architecture

xdf, xdf: Extended Dynamic Object Format

Y

Yasm Version, __YASM_MAJOR__, etc: Yasm Version

Prev
18.4. Segmentation	Home