Index

Symbols

$, Variations on Loops

here, Expressions

prefix, Layout of a NASM Source Line, Numeric Constants

$$, Expressions

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

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

%clear, Standard Macros

%rep, TIMES: Repeating Instructions or Data

& operator, &: Bitwise AND Operator

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

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

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

+ operator

binary, + and -: Addition and Subtraction Operators

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

- operator

binary, + and -: Addition and Subtraction Operators

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

..@ symbol prefix, Local Labels

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

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

16-bit mode

versus 32-bit mode, BITS: Specifying Target Processor Mode

?, RESB and friends: Declaring Uninitialized Data

^ operator, ^: Bitwise XOR Operator

__FILE__, __FILE__ and __LINE__: File Name and Line Number

__LINE__, __FILE__ and __LINE__: File Name and Line Number

__NASM_MAJOR__, __NASM_MAJOR__ and __NASM_MINOR__: NASM Version

__NASM_MINOR__, __NASM_MAJOR__ and __NASM_MINOR__: NASM Version

__SECT__, The __SECT__ Macro, ABSOLUTE: Defining Absolute Labels

| operator, |: Bitwise OR Operator

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

A

a16, CMPSB, CMPSW, CMPSD: Compare Strings, INSB, INSW, INSD: Input String from I/O Port, LODSB, LODSW, LODSD: Load from String, MOVSB, MOVSW, MOVSD: Move String, OUTSB, OUTSW, OUTSD: Output String to I/O Port, POP: Pop Data from Stack, PUSH: Push Data on Stack, SCASB, SCASW, SCASD: Scan String, STOSB, STOSW, STOSD: Store Byte to String, XLATB: Translate Byte in Lookup Table

a32, CMPSB, CMPSW, CMPSD: Compare Strings, INSB, INSW, INSD: Input String from I/O Port, LODSB, LODSW, LODSD: Load from String, MOVSB, MOVSW, MOVSD: Move String, OUTSB, OUTSW, OUTSD: Output String to I/O Port, POP: Pop Data from Stack, PUSH: Push Data on Stack, SCASB, SCASW, SCASD: Scan String, STOSB, STOSW, STOSD: Store Byte to String, XLATB: Translate Byte in Lookup Table

AAA, AAA, AAS, AAM, AAD: ASCII Adjustments

AAD, AAA, AAS, AAM, AAD: ASCII Adjustments

AAM, AAA, AAS, AAM, AAD: ASCII Adjustments

AAS, AAA, AAS, AAM, AAD: ASCII Adjustments

ABSOLUTE, ABSOLUTE: Defining Absolute Labels

ADC, ADC: Add with Carry

ADD, ADD: Add Integers

Addition, + and -: Addition and Subtraction Operators

ADDPS, ADDPS: Add Packed Single-Precision FP Values

address-size prefixes, Layout of a NASM Source Line

ADDSS, ADDSS: Add Scalar Single-Precision FP Values

algebra, Effective Addresses

ALIGN, ALIGN and ALIGNB: Data Alignment

ALIGNB, ALIGN and ALIGNB: Data Alignment

AND, AND: Bitwise AND

ANDNPS, ANDNPS: Bitwise Logical AND NOT of Packed Single-Precision FP Values

ANDPS, ANDPS: Bitwise Logical AND For Single FP

argument, Entering Commands

ARPL, ARPL: Adjust RPL Field of Selector

Assembler Directives, Assembler Directives

assembly passes, Critical Expressions

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

B

batch files, Batch files

binary, Numeric Constants

Binary Files, INCBIN: Including External Binary Files

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

BITS, BITS: Specifying Target Processor Mode

Bitwise AND, &: Bitwise AND Operator

Bitwise OR, |: Bitwise OR Operator

Bitwise XOR, ^: Bitwise XOR Operator

BOUND, BOUND: Check Array Index against Bounds

Breakpoints, Breakpoints

BSF, BSF, BSR: Bit Scan

BSR, BSF, BSR: Bit Scan

BSWAP, BSWAP: Byte Swap

BT, BT, BTC, BTR, BTS: Bit Test

BTC, BT, BTC, BTR, BTS: Bit Test

BTR, BT, BTC, BTR, BTS: Bit Test

BTS, BT, BTC, BTR, BTS: Bit Test

C

CALL, CALL: Call Subroutine

CALL FAR, SEG and WRT

CBW, CBW, CWD, CDQ, CWDE: Sign Extensions

CDQ, CBW, CWD, CDQ, CWDE: Sign Extensions

changing sections, SECTION or SEGMENT: Changing and Defining Sections

character constant, DB and Friends: Declaring Initialized Data

Character Constants, Character Constants

CLC, CLC, CLD, CLI, CLTS: Clear Flags

CLD, CLC, CLD, CLI, CLTS: Clear Flags

CLFLUSH, CLFLUSH: Flush Cache Line

CLI, CLC, CLD, CLI, CLTS: Clear Flags

CLTS, CLC, CLD, CLI, CLTS: Clear Flags

CMC, CMC: Complement Carry Flag

CMDORDPS, CMPccPS: Packed Single-Precision FP Compare

CMOVcc, CMOVcc: Conditional Move

CMP, CMP: Compare Integers

CMPccPS, CMPccPS: Packed Single-Precision FP Compare

CMPEQPS, CMPccPS: Packed Single-Precision FP Compare

CMPLEPS, CMPccPS: Packed Single-Precision FP Compare

CMPLTPS, CMPccPS: Packed Single-Precision FP Compare

CMPNEQPS, CMPccPS: Packed Single-Precision FP Compare

CMPNLEPS, CMPccPS: Packed Single-Precision FP Compare

CMPNLTPS, CMPccPS: Packed Single-Precision FP Compare

CMPSB, CMPSB, CMPSW, CMPSD: Compare Strings

CMPSD, CMPSB, CMPSW, CMPSD: Compare Strings

CMPSW, CMPSB, CMPSW, CMPSD: Compare Strings

CMPUNORDPS, CMPccPS: Packed Single-Precision FP Compare

CMPXCHG, CMPXCHG: Compare and Exchange

CMPXCHG8B, CMPXCHG8B: Compare and Exchange Eight Bytes

colon, Layout of a NASM Source Line

COMISS, COMISS: Scalar Ordered Single-Precision FP Compare and Set EFLAGS

Command Prompt, Microsoft Windows / DOS

COMMON, COMMON: Defining Common Data Areas

common variables, COMMON: Defining Common Data Areas

Condition Codes, Condition Codes

Condition Predicates, CMPccPS: Packed Single-Precision FP Compare

conditional jump, Jcc: Conditional Branch

Constants, Constants

Control registers, Register Values

CPU, CPU: Defining CPU Dependencies

CPUID, Character Constants, CPUID: Get CPU Identification Code

critical expression, RESB and friends: Declaring Uninitialized Data, EQU: Defining Constants, ABSOLUTE: Defining Absolute Labels

Critical Expressions, Critical Expressions

CVTPI2PS, CVTPI2PS: Packed Signed INT32 to Packed Single-FP Conversion

CVTPS2PI, CVTPS2PI: Packed Single-Precision FP to Packed Signed INT32 Conversion

CVTSD2SS, CVTSD2SS: Scalar Double-Precision FP to Scalar Single-Precision FP Conversion

CVTSI2SS, CVTSI2SS: Signed INT32 to Scalar Single-Precision FP Conversion

CVTSS2SI, CVTSS2SI: Scalar Single-Precision FP to Signed INT32 Conversion

CVTTPS2PI, CVTTPS2PI: Packed Single-Precision FP to Packed Signed INT32 Conversion with Truncation

CVTTSS2SI, CVTTSS2SI: Scalar Single-Precision FP to Signed INT32 Conversion with Truncation

CWD, CBW, CWD, CDQ, CWDE: Sign Extensions

CWDE, CBW, CWD, CDQ, CWDE: Sign Extensions

D

DAA, DAA, DAS: Decimal Adjustments

DAS, DAA, DAS: Decimal Adjustments

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

Debug registers, Register Values

DEC, DEC: Decrement Integer

Declaring Structure, STRUC and ENDSTRUC: Declaring Structure Data Types

Defining Sections, SECTION or SEGMENT: Changing and Defining Sections

disk drive name, Files and Filenames

DIV, DIV: Unsigned Integer Divide

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

DIVPS, DIVPS: Packed Single-Precision FP Divide

DIVSS, DIVSS: Scalar Single-Precision FP Divide

DOS, Microsoft Windows / DOS

DOS prompt, Microsoft Windows / DOS

DQ, Pseudo-Instructions, DB and Friends: Declaring Initialized Data, String Constants, Floating-Point Constants

DT, Pseudo-Instructions, DB and Friends: Declaring Initialized Data, String Constants, Floating-Point Constants

DUP, TIMES: Repeating Instructions or Data

DW, Pseudo-Instructions, DB and Friends: Declaring Initialized Data, String Constants

DWORD, Layout of a NASM Source Line

E

effective address, Effective Addresses

effective addresses, Layout of a NASM Source Line, Effective Address Encoding: ModR/M and SIB

effective-address, Critical Expressions

EMMS, EMMS: Empty MMX State

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

ENTER, ENTER: Create Stack Frame

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

Exporting Symbols, GLOBAL: Exporting Symbols to Other Modules

Expressions, Expressions

extension, Files and Filenames

EXTERN, Rules for NASM Procedures that Call External Procedures, EXTERN: Importing Symbols from Other Modules

F

F2XM1, F2XM1: Calculate 2**X-1

FABS, FABS: Floating-Point Absolute Value

FADD, FADD, FADDP: Floating-Point Addition

FADDP, FADD, FADDP: Floating-Point Addition

far call, CALL: Call Subroutine

far jump, JMP: Jump

far pointer, SEG and WRT

FBLD, FBLD, FBSTP: BCD Floating-Point Load and Store

FBSTP, FBLD, FBSTP: BCD Floating-Point Load and Store

FCHS, FCHS: Floating-Point Change Sign

FCLEX, FCLEX, FNCLEX: Clear Floating-Point Exceptions

FCMOVcc, FCMOVcc: Floating-Point Conditional Move

FCOM, FCOM, FCOMP, FCOMPP, FCOMI, FCOMIP: Floating-Point Compare

FCOMI, FCOM, FCOMP, FCOMPP, FCOMI, FCOMIP: Floating-Point Compare

FCOMIP, FCOM, FCOMP, FCOMPP, FCOMI, FCOMIP: Floating-Point Compare

FCOMP, FCOM, FCOMP, FCOMPP, FCOMI, FCOMIP: Floating-Point Compare

FCOMPP, FCOM, FCOMP, FCOMPP, FCOMI, FCOMIP: Floating-Point Compare

FCOS, FCOS: Cosine

FDECSTP, FDECSTP: Decrement Floating-Point Stack Pointer

FDISI, FxDISI, FxENI: Disable and Enable Floating-Point Interrupts

FDIV, FDIV, FDIVP, FDIVR, FDIVRP: Floating-Point Division

FDIVP, FDIV, FDIVP, FDIVR, FDIVRP: Floating-Point Division

FDIVR, FDIV, FDIVP, FDIVR, FDIVRP: Floating-Point Division

FDIVRP, FDIV, FDIVP, FDIVR, FDIVRP: Floating-Point Division

FENI, FxDISI, FxENI: Disable and Enable Floating-Point Interrupts

FFREE, FFREE: Flag Floating-Point Register as Unused

FFREEP, FFREE: Flag Floating-Point Register as Unused

FIADD, FIADD: Floating-Point/Integer Addition

FICOM, FICOM, FICOMP: Floating-Point/Integer Compare

FICOMP, FICOM, FICOMP: Floating-Point/Integer Compare

FIDIV, FIDIV, FIDIVR: Floating-Point/Integer Division

FIDIVR, FIDIV, FIDIVR: Floating-Point/Integer Division

FILD, FILD, FIST, FISTP: Floating-Point/Integer Conversion

file specification, Files and Filenames

filename, Files and Filenames

FIMUL, FIMUL: Floating-Point/Integer Multiplication

FINCSTP, FINCSTP: Increment Floating-Point Stack Pointer

FINIT, FINIT, FNINIT: Initialise Floating-Point Unit

FIST, FILD, FIST, FISTP: Floating-Point/Integer Conversion

FISTP, FILD, FIST, FISTP: Floating-Point/Integer Conversion

FISUB, FISUB: Floating-Point/Integer Subtraction

FLD, FLD: Floating-Point Load

FLDCW, FLDCW: Load Floating-Point Control Word

FLDENV, FLDENV: Load Floating-Point Environment

FLDxx, FLDxx: Floating-Point Load Constants

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

constants, Floating-Point Constants

registers, Register Values

FMUL, FMUL, FMULP: Floating-Point Multiply

FMULP, FMUL, FMULP: Floating-Point Multiply

FNCLEX, FCLEX, FNCLEX: Clear Floating-Point Exceptions

FNDISI, FxDISI, FxENI: Disable and Enable Floating-Point Interrupts

FNENI, FxDISI, FxENI: Disable and Enable Floating-Point Interrupts

FNINIT, FINIT, FNINIT: Initialise Floating-Point Unit

FNOP, FNOP: Floating-Point No Operation

FNSAVE, FSAVE, FRSTOR: Save/Restore Floating-Point State

FNSTCW, FSTCW: Store Floating-Point Control Word

FNSTENV, FSTENV: Store Floating-Point Environment

FNSTSW, FSTSW: Store Floating-Point Status Word

format-specific directives, Assembler Directives

forward references, Critical Expressions

FPATAN, FPATAN, FPTAN: Arctangent and Tangent

FPREM, FPREM, FPREM1: Floating-Point Partial Remainder

FPREM1, FPREM, FPREM1: Floating-Point Partial Remainder

FPTAN, FPATAN, FPTAN: Arctangent and Tangent

FRNDINT, FRNDINT: Floating-Point Round to Integer

FRSTOR, FSAVE, FRSTOR: Save/Restore Floating-Point State

FSAVE, FSAVE, FRSTOR: Save/Restore Floating-Point State

FSCALE, FSCALE: Scale Floating-Point Value by Power of Two

FSETPM, FSETPM: Set Protected Mode

FSIN, FSIN, FSINCOS: Sine and Cosine

FSINCOS, FSIN, FSINCOS: Sine and Cosine

FSQRT, FSQRT: Floating-Point Square Root

FST, FST, FSTP: Floating-Point Store

FSTCW, FSTCW: Store Floating-Point Control Word

FSTENV, FSTENV: Store Floating-Point Environment

FSTP, FST, FSTP: Floating-Point Store

FSTSW, FSTSW: Store Floating-Point Status Word

FSUB, FSUB, FSUBP, FSUBR, FSUBRP: Floating-Point Subtract

FSUBP, FSUB, FSUBP, FSUBR, FSUBRP: Floating-Point Subtract

FSUBR, FSUB, FSUBP, FSUBR, FSUBRP: Floating-Point Subtract

FSUBRP, FSUB, FSUBP, FSUBR, FSUBRP: Floating-Point Subtract

FTST, FTST: Test ST0 Against Zero

FUCOMxx, FUCOMxx: Floating-Point Unordered Compare

FXAM, FXAM: Examine Class of Value in ST0

FXCH, FXCH: Floating-Point Exchange

FXRSTOR, FXRSTOR: Restore FPU, MMX, and XMM State

FXSAVE, FXSAVE: Store FPU, MMX, and XMM State

FXTRACT, FXTRACT: Extract Exponent and Significand

FYL2X, FYL2X, FYL2XP1: Compute Y times Log2(X) or Log2(X+1)

FYL2XP1, FYL2X, FYL2XP1: Compute Y times Log2(X) or Log2(X+1)

G

general purpose register, Key to Operand Specifications

GLOBAL, Rules for NASM Procedures that Call External Procedures, GLOBAL: Exporting Symbols to Other Modules

graphics, INCBIN: Including External Binary Files

groups, SEG and WRT

H

hex, Numeric Constants

HLT, HLT: Halt Processor

I

ICEBP, INT3, INT1, ICEBP, INT01: Breakpoints

IDIV, IDIV: Signed Integer Divide

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

immediate operand, Key to Operand Specifications

Importing Symbols, EXTERN: Importing Symbols from Other Modules

IMUL, IMUL: Signed Integer Multiply

IN, IN: Input from I/O Port

INC, INC: Increment Integer

INCBIN, Pseudo-Instructions, INCBIN: Including External Binary Files, String Constants

infinite loop, Expressions

Initialized, DB and Friends: Declaring Initialized Data

INSB, INSB, INSW, INSD: Input String from I/O Port

INSD, INSB, INSW, INSD: Input String from I/O Port

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

INSW, INSB, INSW, INSD: Input String from I/O Port

INT, INT: Software Interrupt

INT01, INT3, INT1, ICEBP, INT01: Breakpoints

INT1, INT3, INT1, ICEBP, INT01: Breakpoints

INT3, INT3, INT1, ICEBP, INT01: Breakpoints

integer overflow, Expressions

Intel number formats, Floating-Point Constants

interface specification, Argument Transmission

INTO, INTO: Interrupt if Overflow

INVD, INVD: Invalidate Internal Caches

INVLPG, INVLPG: Invalidate TLB Entry

IRET, IRET, IRETW, IRETD: Return from Interrupt

IRETD, IRET, IRETW, IRETD: Return from Interrupt

IRETW, IRET, IRETW, IRETD: Return from Interrupt

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

J

Jcc, Jcc: Conditional Branch

JCXZ, JCXZ, JECXZ: Jump if CX/ECX Zero

JECXZ, JCXZ, JECXZ: Jump if CX/ECX Zero

JMP, JMP: Jump

L

label prefix, Local Labels

LAHF, LAHF: Load AH from Flags

LAR, LAR: Load Access Rights

LDMXCSR, LDMXCSR: Load Streaming SIMD Extension Control/Status

LDS, LDS, LES, LFS, LGS, LSS: Load Far Pointer

LEA, LEA: Load Effective Address

LEAVE, LEAVE: Destroy Stack Frame

LES, LDS, LES, LFS, LGS, LSS: Load Far Pointer

LFENCE, LFENCE: Load Fence

LFS, LDS, LES, LFS, LGS, LSS: Load Far Pointer

LGDT, LGDT, LIDT, LLDT: Load Descriptor Tables

LGS, LDS, LES, LFS, LGS, LSS: Load Far Pointer

LIDT, LGDT, LIDT, LLDT: Load Descriptor Tables

little-endian, Character Constants

LLDT, LGDT, LIDT, LLDT: Load Descriptor Tables

LMSW, LMSW: Load/Store Machine Status Word

Local Labels, Local Labels

LODSB, LODSB, LODSW, LODSD: Load from String

LODSD, LODSB, LODSW, LODSD: Load from String

LODSW, LODSB, LODSW, LODSD: Load from String

LOOP, LOOP, LOOPE, LOOPZ, LOOPNE, LOOPNZ: Loop with Counter

LOOPE, LOOP, LOOPE, LOOPZ, LOOPNE, LOOPNZ: Loop with Counter

LOOPNE, LOOP, LOOPE, LOOPZ, LOOPNE, LOOPNZ: Loop with Counter

LOOPNZ, LOOP, LOOPE, LOOPZ, LOOPNE, LOOPNZ: Loop with Counter

LOOPZ, LOOP, LOOPE, LOOPZ, LOOPNE, LOOPNZ: Loop with Counter

LSL, LSL: Load Segment Limit

LSS, LDS, LES, LFS, LGS, LSS: Load Far Pointer

LTR, LTR: Load Task Register

M

macros, TIMES: Repeating Instructions or Data

Make, Batch files

MASKMOVQ, MASKMOVQ: Byte Mask Write

MAXPS, MAXPS: Return Packed Single-Precision FP Maximum

MAXSS, MAXSS: Return Scalar Single-Precision FP Maximum

memory operand, Layout of a NASM Source Line

memory reference, Effective Addresses, Key to Operand Specifications

MFENCE, MFENCE: Memory Fence

MINPS, MINPS: Return Packed Single-Precision FP Minimum

MINSS, MINSS: Return Scalar Single-Precision FP Minimum

MMX registers, Register Values

ModR/M byte, Key to Opcode Descriptions, Effective Address Encoding: ModR/M and SIB

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

MOV, MOV: Move Data

MOVAPS, MOVAPS: Move Aligned Packed Single-Precision FP Values

MOVD, MOVD: Move Doubleword to/from MMX Register

MOVHLPS, MOVHLPS: Move Packed Single-Precision FP High to Low

MOVHPS, MOVHPS: Move High Packed Single-Precision FP

MOVLHPS, MOVLHPS: Move Packed Single-Precision FP Low to High

MOVLPS, MOVLPS: Move Low Packed Single-Precision FP

MOVMSKPS, MOVMSKPS: Extract Packed Single-Precision FP Sign Mask

MOVNTPS, MOVNTPS: Move Aligned Four Packed Single-Precision FP Values Non Temporal

MOVNTQ, MOVNTQ: Move Quadword Non Temporal

MOVQ, MOVQ: Move Quadword to/from Packed Data Register

MOVSB, MOVSB, MOVSW, MOVSD: Move String

MOVSD, MOVSB, MOVSW, MOVSD: Move String

MOVSS, MOVSS: Move Scalar Single-Precision FP Value

MOVSW, MOVSB, MOVSW, MOVSD: Move String

MOVSX, MOVSX, MOVZX: Move Data with Sign or Zero Extend

MOVUPS, MOVUPS: Move Unaligned Packed Single-Precision FP Values

MOVZX, MOVSX, MOVZX: Move Data with Sign or Zero Extend

MUL, MUL: Unsigned Integer Multiply

MULPS, MULPS: Packed Single-Precision FP Multiply

MULSS, MULSS: Scalar Single-Precision FP Multiply

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

N

NASM Version, __NASM_MAJOR__ and __NASM_MINOR__: NASM Version

near call, CALL: Call Subroutine

near jump, JMP: Jump

NEG, NEG, NOT: Two's and One's Complement

NOP, NOP: No Operation

NOSPLIT, Effective Addresses

NOT, NEG, NOT: Two's and One's Complement

numeric constant, DB and Friends: Declaring Initialized Data

Numeric Constants, Numeric Constants

O

o16, POP: Pop Data from Stack, PUSH: Push Data on Stack

o32, POP: Pop Data from Stack, PUSH: Push Data on Stack

octal, Numeric Constants

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

OR, OR: Bitwise OR

orphan-labels, Layout of a NASM Source Line

ORPS, ORPS: Bit-wise Logical OR of Single-Precision FP Data

OUT, OUT: Output Data to I/O Port

OUTSB, OUTSB, OUTSW, OUTSD: Output String to I/O Port

OUTSD, OUTSB, OUTSW, OUTSD: Output String to I/O Port

OUTSW, OUTSB, OUTSW, OUTSD: Output String to I/O Port

overlapping segments, SEG and WRT

P

PACKSSDW, PACKSSDW, PACKSSWB, PACKUSWB: Pack Data

PACKSSWB, PACKSSDW, PACKSSWB, PACKUSWB: Pack Data

PACKUSWB, PACKSSDW, PACKSSWB, PACKUSWB: Pack Data

PADDB, PADDB, PADDW, PADDD: Add Packed Integers

PADDD, PADDB, PADDW, PADDD: Add Packed Integers

PADDQ, PADDQ: Add Packed Quadword Integers

PADDSB, PADDSB, PADDSW: Add Packed Signed Integers with Saturation

PADDSW, PADDSB, PADDSW: Add Packed Signed Integers with Saturation

PADDUSB, PADDUSB, PADDUSW: Add Packed Unsigned Integers with Saturation

PADDUSW, PADDUSB, PADDUSW: Add Packed Unsigned Integers with Saturation

PADDW, PADDB, PADDW, PADDD: Add Packed Integers

PAND, PAND, PANDN: Packed Integer Bitwise AND and AND-NOT

PANDN, PAND, PANDN: Packed Integer Bitwise AND and AND-NOT

paradox, Critical Expressions

passes, Critical Expressions

path, Files and Filenames

PAUSE, PAUSE: Spin Loop Hint

PAVGB, PAVGB, PAVGW: Average Packed Integers

PAVGW, PAVGB, PAVGW: Average Packed Integers

PCMPxx, PCMPxx: Compare Packed Integers

period, Local Labels

PEXTRW, PEXTRW: Extract Word

PINSRW, PINSRW: Insert Word

PMADDWD, PMADDWD: Packed Integer Multiply and Add

PMAXSW, PMAXSW: Packed Signed Integer Word Maximum

PMAXUB, PMAXUB: Packed Unsigned Integer Byte Maximum

PMINSW, PMINSW: Packed Signed Integer Word Minimum

PMINUB, PMINUB: Packed Unsigned Integer Byte Minimum

PMOVMSKB, PMOVMSKB: Move Byte Mask To Integer

PMULHUW, PMULHUW: Multiply Packed 16-bit Integers, and Store High Word

PMULHW, PMULHW, PMULLW: Multiply Packed 16-bit Integers and Store

PMULLW, PMULHW, PMULLW: Multiply Packed 16-bit Integers and Store

POP, POP: Pop Data from Stack

POPAx, POPAx: Pop All General-Purpose Registers

POPFx, POPFx: Pop Flags Register

POR, POR: Packed Data Bitwise OR

precedence, Expressions

preferred, SEG and WRT

PREFETCHh, PREFETCHh: Prefetch Data Into Caches

PREFETCHNTA, PREFETCHh: Prefetch Data Into Caches

PREFETCHT0, PREFETCHh: Prefetch Data Into Caches

PREFETCHT1, PREFETCHh: Prefetch Data Into Caches

PREFETCHT2, PREFETCHh: Prefetch Data Into Caches

preprocessor, EQU: Defining Constants

primitive directives, Assembler Directives

Processor Mode, BITS: Specifying Target Processor Mode

prompt, Microsoft Windows / DOS

PSADBW, PSADBW: Packed Sum of Absolute Differences

PSHUFW, PSHUFW: Shuffle Packed Words

PSLLx, PSLLx: Packed Data Bit Shift Left Logical

PSRAx, PSRAx: Packed Data Bit Shift Right Arithmetic

PSRLx, PSRLx: Packed Data Bit Shift Right Logical

PSUBSxx, PSUBSxx, PSUBUSx: Subtract Packed Integers with Saturation

PSUBUSx, PSUBSxx, PSUBUSx: Subtract Packed Integers with Saturation

PSUBx, PSUBx: Subtract Packed Integers

PUBLIC, GLOBAL: Exporting Symbols to Other Modules

PUNPCKxxx, PUNPCKxxx: Unpack and Interleave Data

PUSH, PUSH: Push Data on Stack

PUSHAx, PUSHAx: Push All General-Purpose Registers

PUSHFx, PUSHFx: Push Flags Register

PXOR, PXOR: Packed Data Bitwise XOR

Q

QWORD, Layout of a NASM Source Line

R

RCL, RCL, RCR: Bitwise Rotate through Carry Bit

RCPPS, RCPPS: Packed Single-Precision FP Reciprocal

RCPSS, RCPSS: Scalar Single-Precision FP Reciprocal

RCR, RCL, RCR: Bitwise Rotate through Carry Bit

RDMSR, RDMSR: Read Model-Specific Registers

RDPMC, RDPMC: Read Performance-Monitoring Counters

RDTSC, RDTSC: Read Time-Stamp Counter

register push, PUSH: Push Data on Stack

Repeating, TIMES: Repeating Instructions or Data

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

RESD, 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

Restricted memory references, Key to Operand Specifications

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

RET, RET, RETF, RETN: Return from Procedure Call

RETF, RET, RETF, RETN: Return from Procedure Call

RETN, RET, RETF, RETN: Return from Procedure Call

ROL, ROL, ROR: Bitwise Rotate

ROR, ROL, ROR: Bitwise Rotate

RPL, ARPL: Adjust RPL Field of Selector

RSM, RSM: Resume from System-Management Mode

RSQRTPS, RSQRTPS: Packed Single-Precision FP Square Root Reciprocal

RSQRTSS, RSQRTSS: Scalar Single-Precision FP Square Root Reciprocal

S

SAHF, SAHF: Store AH to Flags

SAL, SAL, SAR: Bitwise Arithmetic Shifts

SALC, SALC: Set AL from Carry Flag

SAR, SAL, SAR: Bitwise Arithmetic Shifts

SBB, SBB: Subtract with Borrow

SCASB, SCASB, SCASW, SCASD: Scan String

SCASD, SCASB, SCASW, SCASD: Scan String

SCASW, SCASB, SCASW, SCASD: Scan String

SECTION, SECTION or SEGMENT: Changing and Defining Sections

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

SEGMENT, SECTION or SEGMENT: Changing and Defining Sections

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

segment override, Layout of a NASM Source Line

Segment registers, Register Values

segments, SEG and WRT

SETcc, SETcc: Set Register from Condition

Setting a breakpoint, Breakpoints

SFENCE, SFENCE: Store Fence

SGDT, SGDT, SIDT, SLDT: Store Descriptor Table Pointers

SHL, SHL, SHR: Bitwise Logical Shifts

SHLD, SHLD, SHRD: Bitwise Double-Precision Shifts

SHR, SHL, SHR: Bitwise Logical Shifts

SHRD, SHLD, SHRD: Bitwise Double-Precision Shifts

SHUFPS, SHUFPS: Shuffle Packed Single-Precision FP Values

SIB byte, Key to Opcode Descriptions, Effective Address Encoding: ModR/M and SIB

SIDT, SGDT, SIDT, SLDT: Store Descriptor Table Pointers

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

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

SLDT, SGDT, SIDT, SLDT: Store Descriptor Table Pointers

SMSW, SMSW: Store Machine Status Word

sound, INCBIN: Including External Binary Files

SQRTPS, SQRTPS: Packed Single-Precision FP Square Root

SQRTSS, SQRTSS: Scalar Single-Precision FP Square Root

square brackets, Effective Addresses

SSE Condition Predicates, SSE Condition Predicates

Standard Macros, Standard Macros

standardized section names, SECTION or SEGMENT: Changing and Defining Sections

STC, STC, STD, STI: Set Flags

STD, STC, STD, STI: Set Flags

STI, STC, STD, STI: Set Flags

STMXCSR, STMXCSR: Store Streaming SIMD Extension Control/Status

STOSB, STOSB, STOSW, STOSD: Store Byte to String

STOSD, STOSB, STOSW, STOSD: Store Byte to String

STOSW, STOSB, STOSW, STOSD: Store Byte to String

STR, STR: Store Task Register

STRICT, STRICT: Inhibiting Optimization

string constant, DB and Friends: Declaring Initialized Data

String Constants, String Constants

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

SUB, SUB: Subtract Integers

SUBPS, SUBPS: Packed Single-Precision FP Subtract

SUBSS, SUBSS: Scalar Single-FP Subtract

Subtraction, + and -: Addition and Subtraction Operators

switching between sections, SECTION or SEGMENT: Changing and Defining Sections

SYSCALL, SYSCALL: Call Operating System

SYSENTER, SYSENTER: Fast System Call

SYSEXIT, SYSEXIT: Fast Return From System Call

SYSRET, SYSRET: Return From Operating System

system files, Files and Filenames

T

TEST, TEST: Test Bits (notional bitwise AND)

Test registers, Register Values

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

two-pass assembler, Critical Expressions

TWORD, Layout of a NASM Source Line

U

UCOMISS, UCOMISS: Unordered Scalar Single-Precision FP compare and set EFLAGS

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

uninitialized, Pseudo-Instructions, RESB and friends: Declaring Uninitialized Data

UNPCKHPS, UNPCKHPS: Unpack and Interleave High Packed Single-Precision FP Values

UNPCKLPS, UNPCKLPS: Unpack and Interleave Low Packed Single-Precision FP Data

unrolled loops, TIMES: Repeating Instructions or Data

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

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

USE16, USE16 and USE32: Aliases for BITS

USE32, USE16 and USE32: Aliases for BITS

user-level assembler directives, Standard Macros

user-level directives, Assembler Directives

V

Valid characters, Layout of a NASM Source Line

VERR, VERR, VERW: Verify Segment Readability/Writability

version number of NASM, __NASM_MAJOR__ and __NASM_MINOR__: NASM Version

VERW, VERR, VERW: Verify Segment Readability/Writability

W

WAIT, WAIT: Wait for Floating-Point Processor

WBINVD, WBINVD: Write Back and Invalidate Cache

wildcards, Wildcards

Windows, Microsoft Windows / DOS

WRMSR, WRMSR: Write Model-Specific Registers

WRT, SEG and WRT

X

XADD, XADD: Exchange and Add

XCHG, XCHG: Exchange

XLATB, XLATB: Translate Byte in Lookup Table

XOR, XOR: Bitwise Exclusive OR

XORPS, XORPS: Bitwise Logical XOR of Single-Precision FP Values