Basic Statements (GNU Compiler Collection (GCC) Internals)

#### 11.7.1 Basic Statements ¶

`ASM_EXPR`

  Used to represent an inline assembly statement. For an inline assembly statement like:

      asm ("mov x, y");

  The `ASM_STRING` macro will return a `STRING_CST` node for `"mov x, y"`. If the original statement made use of the extended-assembly syntax, then `ASM_OUTPUTS`, `ASM_INPUTS`, and `ASM_CLOBBERS` will be the outputs, inputs, and clobbers for the statement, represented as `STRING_CST` nodes. The extended-assembly syntax looks like:

      asm ("fsinx %1,%0" : "=f" (result) : "f" (angle));

  The first string is the `ASM_STRING`, containing the instruction template. The next two strings are the output and inputs, respectively; this statement has no clobbers. All of the strings will be `NUL`-terminated, and will contain no embedded `NUL`-characters.

  `ASM_BASIC_P` indicates whether the assembly statement used the “basic” syntax (as for the first example above) or whether it used the extended syntax (as for the second example above). In many cases this information could be inferred from other accessors, but the flag is necessary to distinguish extended statements that have no operands from basic statements. A key difference between the two is that `%` substitution is applied to `ASM_STRING` for extended statements but not for basic statements.

  If the assembly statement is declared `volatile`, or if the statement was not an extended assembly statement, and is therefore implicitly volatile, then the predicate `ASM_VOLATILE_P` will hold of the `ASM_EXPR`.

`DECL_EXPR`

  Used to represent a local declaration. The `DECL_EXPR_DECL` macro can be used to obtain the entity declared. This declaration may be a `LABEL_DECL`, indicating that the label declared is a local label. (As an extension, GCC allows the declaration of labels with scope.) In C, this declaration may be a `FUNCTION_DECL`, indicating the use of the GCC nested function extension. For more information, see Functions.

`LABEL_EXPR`

  Used to represent a label. The `LABEL_DECL` declared by this statement can be obtained with the `LABEL_EXPR_LABEL` macro. The `IDENTIFIER_NODE` giving the name of the label can be obtained from the `LABEL_DECL` with `DECL_NAME`.

`GOTO_EXPR`

  Used to represent a `goto` statement. The `GOTO_DESTINATION` will usually be a `LABEL_DECL`. However, if the “computed goto” extension has been used, the `GOTO_DESTINATION` will be an arbitrary expression indicating the destination. This expression will always have pointer type.

`RETURN_EXPR`

  Used to represent a `return` statement. Operand 0 represents the value to return. It should either be the `RESULT_DECL` for the containing function, or a `MODIFY_EXPR` or `INIT_EXPR` setting the function’s `RESULT_DECL`. It will be `NULL_TREE` if the statement was just

      return;

`LOOP_EXPR`

  These nodes represent “infinite” loops. The `LOOP_EXPR_BODY` represents the body of the loop. It should be executed forever, unless an `EXIT_EXPR` is encountered.

`EXIT_EXPR`

  These nodes represent conditional exits from the nearest enclosing `LOOP_EXPR`. The single operand is the condition; if it is nonzero, then the loop should be exited. An `EXIT_EXPR` will only appear within a `LOOP_EXPR`.

`SWITCH_EXPR`

  Used to represent a `switch` statement. The `SWITCH_COND` is the expression on which the switch is occurring. The `SWITCH_BODY` is the body of the switch statement. `SWITCH_ALL_CASES_P` is true if the switch includes a default label or the case label ranges cover all possible values of the condition expression.

  Note that `TREE_TYPE` for a `SWITCH_EXPR` represents the original type of switch expression as given in the source, before any compiler conversions, instead of the type of the switch expression itself (which is not meaningful).

`CASE_LABEL_EXPR`

  Use to represent a `case` label, range of `case` labels, or a `default` label. If `CASE_LOW` is `NULL_TREE`, then this is a `default` label. Otherwise, if `CASE_HIGH` is `NULL_TREE`, then this is an ordinary `case` label. In this case, `CASE_LOW` is an expression giving the value of the label. Both `CASE_LOW` and `CASE_HIGH` are `INTEGER_CST` nodes. These values will have the same type as the condition expression in the switch statement.

  Otherwise, if both `CASE_LOW` and `CASE_HIGH` are defined, the statement is a range of case labels. Such statements originate with the extension that allows users to write things of the form:

      case 2 ... 5:

  The first value will be `CASE_LOW`, while the second will be `CASE_HIGH`.

`DEBUG_BEGIN_STMT`

  Marks the beginning of a source statement, for purposes of debug information generation.