C-style preprocessor directives

In this section:

Syntax

#define symbol text

#elif condition

#else

#endif

#error "message"

#if condition

#ifdef symbol

#ifndef symbol

#include {"filename" | <filename>}

#line line-no {"filename"}

#undef symbol

Parameters

`condition`	An absolute assembler expression, see Expressions, operands, and operators. The expression must not contain any assembler labels or symbols, and any non-zero value is considered as true. The C preprocessor operator `defined` can be used.
`filename`	Name of file to be included or referred.
`line-no`	Source line number.
`message`	Text to be displayed.
`symbol`	Preprocessor symbol to be defined, undefined, or tested.
`text`	Value to be assigned.

Description

The assembler has a C-style preprocessor that follows the C99 standard.

These C-language preprocessor directives are available:

Directive	Description
`#define`	Assigns a value to a preprocessor symbol.
`#elif`	Introduces a new condition in an `#if...#endif` block.
`#else`	Assembles instructions if a condition is false.
`#endif`	Ends an `#if`, `#ifdef`, or `#ifndef` block.
`#error`	Generates an error.
`#if`	Assembles instructions if a condition is true.
`#ifdef`	Assembles instructions if a preprocessor symbol is defined.
`#ifndef`	Assembles instructions if a preprocessor symbol is undefined.
`#include`	Includes a file.
`#line`	Changes the source references in the debug information.
`#pragma`	Controls extension features. The supported `#pragma` directives are described in Pragma directives.
`#undef`	Undefines a preprocessor symbol.

Table 129. C-style preprocessor directives

You must not mix assembler language and C-style preprocessor directives. Conceptually, they are different languages and mixing them might lead to unexpected behavior, as an assembler directive is not necessarily accepted as a part of the C preprocessor language.

Note

The preprocessor directives are processed before other directives. As an example, avoid constructs like:

redef       macro                   ; Avoid the following!
#define \1 \2
            endm

because the \1 and \2 macro arguments are not available during the preprocessing phase.

Defining and undefining preprocessor symbols

Use #define to define a value of a preprocessor symbol.

#define symbol value

Use #undef to undefine a symbol—the effect is as if it had not been defined.

Conditional preprocessor directives

Use the #if...#else...#endif directives to control the assembly process at assembly time. If the condition following the #if directive is not true, the subsequent instructions will not generate any code (that is, it will not be assembled or syntax checked) until an #endif or #else directive is found.

All assembler directives (except for END) and file inclusion can be disabled by the conditional directives. Each #if directive must be terminated by an #endif directive. The #else directive is optional and, if used, must be inside an #if...#endif block.

#if...#endif and #if...#else...#endif blocks can be nested to any level.

Use #ifdef to assemble instructions up to the next #else or #endif directive only if a symbol is defined.

Use #ifndef to assemble instructions up to the next #else or #endif directive only if a symbol is undefined.

This example defines the labels tweak and adjust. If adjust is defined, then the memory location calibration constant is decremented by an amount that depends on adjust, in this case 14.

            module  calibrate
            extern  calibrationConstant
            section .text:CODE(2)

#define     tweak  1
#define     adjust 3

calibrate   mov     calibrationConstant,r6
            ld.w    0[r6],r7
#ifdef      tweak
#if         adjust==1
            add     4,r7
#elif       adjust==2
            add     8,r7
#elif       adjust==3
            add     14,r7
#endif
#endif      /* ifdef tweak */
            st.w    r7,0[r6]
            jmp     [lp]
            end

Including source files

Use #include to insert the contents of a file into the source file at a specified point. The filename can be specified within double quotes or within angle brackets.

This is the full description of the assembler’s #include file search procedure:

If the name of the #include file is an absolute path, that file is opened.
When the assembler encounters the name of an #include file in angle brackets such as:
#include <iodevice.h>
it searches the following directories for the file to include:
1. The directories specified with the -I option, in the order that they were specified.
2. Any directories specified using the ARH850_INC environment variable.
3. The automatically set up library system include directories. See ‑‑no_system_include and ‑‑system_include_dir.

When the assembler encounters the name of an #include file in double quotes such as:
```
#include "vars.h"
```
it searches the directory of the source file in which the #include statement occurs, and then performs the same sequence as for angle-bracketed filenames.
If there are nested #include files, the assembler starts searching the directory of the file that was last included, iterating upwards for each included file, searching the source file directory last.

Use angle brackets for header files provided with the IAR Assembler for RH850, and double quotes for header files that are part of your application.

This example uses #include to include a file defining macros into the source file. For example, these macros could be defined in Macros.inc:

xch:        macro   a,b
            add     -4,sp
            st.w    \1,0[sp]
            mov     \2,\1
            ld.w    0[sp],\2
            add     4,sp
            endm

The macro definitions can then be included, using #include, as in this example:

            program includeFile
            section .text:CODE(2)

; Standard macro definitions.
#include "Macros.inc"

xchRegs     xch     r6,r7
            xch     r6,r8
            jmp     [lp]
            end

Comments in C-style preprocessor directives

If you make a comment within a define statement, use:

the C comment delimiters /* ... */ to comment sections
the C++ comment delimiter // to mark the rest of the line as comment.

Do not use assembler comments within a define statement as it leads to unexpected behavior.

This expression evaluates to 3 because the comment character is preserved by #define:

#define x 3    ; This is a misplaced comment.

            module  misplacedComment1
expression  equ     x * 8 + 5
            ;...
            end

This example illustrates some problems that might occur when assembler comments are used in the C-style preprocessor:

#define five  5     ; This comment is not OK.
#define six   6     // This comment is OK.
#define seven 7     /* This comment is OK. */

            module  misplacedComment2
            section MYCONST:CONST(2)

            DC32    five, 11, 12
; The previous line expands to:
;          "DC32    5     ; This comment is not OK., 11, 12"

            DC32    six + seven, 11, 12
; The previous line expands to:
;          "DC32    6 + 7, 11, 12"
            end

IAR Embedded Workbench for RH850 3.20.x