# The Netwide Assembler: NASM

Next Chapter | Previous Chapter | Contents | Index

## Chapter 5: Standard Macro Packages

The `%use` directive (see section 4.6.4) includes one of the standard macro packages included with the NASM distribution and compiled into the NASM binary. It operates like the `%include` directive (see section 4.6.1), but the included contents is provided by NASM itself.

The names of standard macro packages are case insensitive, and can be quoted or not.

### 5.1 `altreg`: Alternate Register Names

The `altreg` standard macro package provides alternate register names. It provides numeric register names for all registers (not just `R8`-`R15`), the Intel-defined aliases `R8L`-`R15L` for the low bytes of register (as opposed to the NASM/AMD standard names `R8B`-`R15B`), and the names `R0H`-`R3H` (by analogy with `R0L`-`R3L`) for `AH`, `CH`, `DH`, and `BH`.

Example use:

    %use altreg

    proc:
          mov r0l,r3h                    ; mov al,bh
          ret

See also section 11.1.

### 5.2 `smartalign`: Smart `ALIGN` Macro

The `smartalign` standard macro package provides for an `ALIGN` macro which is more powerful than the default (and backwards-compatible) one (see section 4.12.12). When the `smartalign` package is enabled, when `ALIGN` is used without a second argument, NASM will generate a sequence of instructions more efficient than a series of `NOP`. Furthermore, if the padding exceeds a specific threshold, then NASM will generate a jump over the entire padding sequence.

The specific instructions generated can be controlled with the new `ALIGNMODE` macro. This macro takes two parameters: one mode, and an optional jump threshold override. If (for any reason) you need to turn off the jump completely just set jump threshold value to -1 (or set it to `nojmp`). The following modes are possible:

- `generic`: Works on all x86 CPUs and should have reasonable performance. The default jump threshold is 8. This is the default.
- `nop`: Pad out with `NOP` instructions. The only difference compared to the standard `ALIGN` macro is that NASM can still jump over a large padding area. The default jump threshold is 16.
- `k7`: Optimize for the AMD K7 (Athlon/Althon XP). These instructions should still work on all x86 CPUs. The default jump threshold is 16.
- `k8`: Optimize for the AMD K8 (Opteron/Althon 64). These instructions should still work on all x86 CPUs. The default jump threshold is 16.
- `p6`: Optimize for Intel CPUs. This uses the long `NOP` instructions first introduced in Pentium Pro. This is incompatible with all CPUs of family 5 or lower, as well as some VIA CPUs and several virtualization solutions. The default jump threshold is 16.

The macro `__ALIGNMODE__` is defined to contain the current alignment mode. A number of other macros beginning with `__ALIGN_` are used internally by this macro package.

### 5.3 `fp`: Floating-point macros

This packages contains the following floating-point convenience macros:

    %define Inf             __Infinity__
    %define NaN             __QNaN__
    %define QNaN            __QNaN__
    %define SNaN            __SNaN__

    %define float8(x)       __float8__(x)
    %define float16(x)      __float16__(x)
    %define float32(x)      __float32__(x)
    %define float64(x)      __float64__(x)
    %define float80m(x)     __float80m__(x)
    %define float80e(x)     __float80e__(x)
    %define float128l(x)    __float128l__(x)
    %define float128h(x)    __float128h__(x)

### 5.4 `ifunc`: Integer functions

This package contains a set of macros which implement integer functions. These are actually implemented as special operators, but are most conveniently accessed via this macro package.

The macros provided are:

#### 5.4.1 Integer logarithms

These functions calculate the integer logarithm base 2 of their argument, considered as an unsigned integer. The only differences between the functions is their behavior if the argument provided is not a power of two.

The function `ilog2e()` (alias `ilog2()`) generate an error if the argument is not a power of two.

The function `ilog2w()` generate a warning if the argument is not a power of two.

The function `ilog2f()` rounds the argument down to the nearest power of two; if the argument is zero it returns zero.

The function `ilog2c()` rounds the argument up to the nearest power of two.

Next Chapter | Previous Chapter | Contents | Index