#### 9.5.1 Working with declarations

Some macros can be used with any kind of declaration. These include:

`DECL_NAME`
  This macro returns an `IDENTIFIER_NODE` giving the name of the entity.
`TREE_TYPE`
  This macro returns the type of the entity declared.
`TREE_FILENAME`
  This macro returns the name of the file in which the entity was declared, as a `char*`. For an entity declared implicitly by the compiler (like `__builtin_memcpy`), this will be the string `"<internal>"`.
`TREE_LINENO`
  This macro returns the line number at which the entity was declared, as an `int`.
`DECL_ARTIFICIAL`
  This predicate holds if the declaration was implicitly generated by the compiler. For example, this predicate will hold of an implicitly declared member function, or of the `TYPE_DECL` implicitly generated for a class type. Recall that in C++ code like:

                struct S {};

  is roughly equivalent to C code like:

                struct S {};
                typedef struct S S;

  The implicitly generated `typedef` declaration is represented by a `TYPE_DECL` for which `DECL_ARTIFICIAL` holds.

`DECL_NAMESPACE_SCOPE_P`
  This predicate holds if the entity was declared at a namespace scope.
`DECL_CLASS_SCOPE_P`
  This predicate holds if the entity was declared at a class scope.
`DECL_FUNCTION_SCOPE_P`
  This predicate holds if the entity was declared inside a function body.

The various kinds of declarations include:

`LABEL_DECL`
  These nodes are used to represent labels in function bodies. For more information, see Functions. These nodes only appear in block scopes.
`CONST_DECL`
  These nodes are used to represent enumeration constants. The value of the constant is given by `DECL_INITIAL` which will be an `INTEGER_CST` with the same type as the `TREE_TYPE` of the `CONST_DECL`, i.e., an `ENUMERAL_TYPE`.
`RESULT_DECL`
  These nodes represent the value returned by a function. When a value is assigned to a `RESULT_DECL`, that indicates that the value should be returned, via bitwise copy, by the function. You can use `DECL_SIZE` and `DECL_ALIGN` on a `RESULT_DECL`, just as with a `VAR_DECL`.
`TYPE_DECL`
  These nodes represent `typedef` declarations. The `TREE_TYPE` is the type declared to have the name given by `DECL_NAME`. In some cases, there is no associated name.
`VAR_DECL`
  These nodes represent variables with namespace or block scope, as well as static data members. The `DECL_SIZE` and `DECL_ALIGN` are analogous to `TYPE_SIZE` and `TYPE_ALIGN`. For a declaration, you should always use the `DECL_SIZE` and `DECL_ALIGN` rather than the `TYPE_SIZE` and `TYPE_ALIGN` given by the `TREE_TYPE`, since special attributes may have been applied to the variable to give it a particular size and alignment. You may use the predicates `DECL_THIS_STATIC` or `DECL_THIS_EXTERN` to test whether the storage class specifiers `static` or `extern` were used to declare a variable.

  If this variable is initialized (but does not require a constructor), the `DECL_INITIAL` will be an expression for the initializer. The initializer should be evaluated, and a bitwise copy into the variable performed. If the `DECL_INITIAL` is the `error_mark_node`, there is an initializer, but it is given by an explicit statement later in the code; no bitwise copy is required.

  GCC provides an extension that allows either automatic variables, or global variables, to be placed in particular registers. This extension is being used for a particular `VAR_DECL` if `DECL_REGISTER` holds for the `VAR_DECL`, and if `DECL_ASSEMBLER_NAME` is not equal to `DECL_NAME`. In that case, `DECL_ASSEMBLER_NAME` is the name of the register into which the variable will be placed.

`PARM_DECL`
  Used to represent a parameter to a function. Treat these nodes similarly to `VAR_DECL` nodes. These nodes only appear in the `DECL_ARGUMENTS` for a `FUNCTION_DECL`.

  The `DECL_ARG_TYPE` for a `PARM_DECL` is the type that will actually be used when a value is passed to this function. It may be a wider type than the `TREE_TYPE` of the parameter; for example, the ordinary type might be `short` while the `DECL_ARG_TYPE` is `int`.

`FIELD_DECL`
  These nodes represent non-static data members. The `DECL_SIZE` and `DECL_ALIGN` behave as for `VAR_DECL` nodes. The position of the field within the parent record is specified by a combination of three attributes. `DECL_FIELD_OFFSET` is the position, counting in bytes, of the `DECL_OFFSET_ALIGN`-bit sized word containing the bit of the field closest to the beginning of the structure. `DECL_FIELD_BIT_OFFSET` is the bit offset of the first bit of the field within this word; this may be nonzero even for fields that are not bit-fields, since `DECL_OFFSET_ALIGN` may be greater than the natural alignment of the field's type.

  If `DECL_C_BIT_FIELD` holds, this field is a bit-field. In a bit-field, `DECL_BIT_FIELD_TYPE` also contains the type that was originally specified for it, while DECL_TYPE may be a modified type with lesser precision, according to the size of the bit field.

`NAMESPACE_DECL`
  See Namespaces.
`TEMPLATE_DECL`
  These nodes are used to represent class, function, and variable (static data member) templates. The `DECL_TEMPLATE_SPECIALIZATIONS` are a `TREE_LIST`. The `TREE_VALUE` of each node in the list is a `TEMPLATE_DECL`s or `FUNCTION_DECL`s representing specializations (including instantiations) of this template. Back ends can safely ignore `TEMPLATE_DECL`s, but should examine `FUNCTION_DECL` nodes on the specializations list just as they would ordinary `FUNCTION_DECL` nodes.

  For a class template, the `DECL_TEMPLATE_INSTANTIATIONS` list contains the instantiations. The `TREE_VALUE` of each node is an instantiation of the class. The `DECL_TEMPLATE_SPECIALIZATIONS` contains partial specializations of the class.

`USING_DECL`
  Back ends can safely ignore these nodes.