gcc/ada/gcc-interface/ada-tree.h

   1 /****************************************************************************
   2  *                                                                          *
   3  *                         GNAT COMPILER COMPONENTS                         *
   4  *                                                                          *
   5  *                             A D A - T R E E                              *
   6  *                                                                          *
   7  *                              C Header File                               *
   8  *                                                                          *
   9  *          Copyright (C) 1992-2017, Free Software Foundation, Inc.         *
  10  *                                                                          *
  11  * GNAT is free software;  you can  redistribute it  and/or modify it under *
  12  * terms of the  GNU General Public License as published  by the Free Soft- *
  13  * ware  Foundation;  either version 3,  or (at your option) any later ver- *
  14  * sion.  GNAT is distributed in the hope that it will be useful, but WITH- *
  15  * OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY *
  16  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License *
  17  * for  more details.  You should have received a copy of the GNU General   *
  18  * Public License along with GCC; see the file COPYING3.  If not see        *
  19  * <http://www.gnu.org/licenses/>.                                          *
  20  *                                                                          *
  21  * GNAT was originally developed  by the GNAT team at  New York University. *
  22  * Extensive contributions were provided by Ada Core Technologies Inc.      *
  23  *                                                                          *
  24  ****************************************************************************/
  25
  26 /* The resulting tree type.  */
  27 union GTY((desc ("0"),
  28            chain_next ("CODE_CONTAINS_STRUCT (TREE_CODE (&%h.generic), TS_COMMON) ? ((union lang_tree_node *) TREE_CHAIN (&%h.generic)) : NULL")))
  29   lang_tree_node
  30 {
  31   union tree_node GTY((tag ("0"),
  32                        desc ("tree_node_structure (&%h)"))) generic;
  33 };
  34
  35 /* Ada uses the lang_decl and lang_type fields to hold a tree.  */
  36 struct GTY(()) lang_type { tree t1; tree t2; };
  37 struct GTY(()) lang_decl { tree t; };
  38
  39 extern struct lang_type *get_lang_specific (tree node);
  40
  41 /* Macros to get and set the trees in TYPE_LANG_SPECIFIC.  */
  42 #define GET_TYPE_LANG_SPECIFIC(NODE) \
  43   (TYPE_LANG_SPECIFIC (NODE) ? TYPE_LANG_SPECIFIC (NODE)->t1 : NULL_TREE)
  44
  45 #define SET_TYPE_LANG_SPECIFIC(NODE, X) (get_lang_specific (NODE)->t1 = (X))
  46
  47 #define GET_TYPE_LANG_SPECIFIC2(NODE) \
  48   (TYPE_LANG_SPECIFIC (NODE) ? TYPE_LANG_SPECIFIC (NODE)->t2 : NULL_TREE)
  49
  50 #define SET_TYPE_LANG_SPECIFIC2(NODE, X) (get_lang_specific (NODE)->t2 = (X))
  51
  52 /* Macros to get and set the tree in DECL_LANG_SPECIFIC.  */
  53 #define GET_DECL_LANG_SPECIFIC(NODE) \
  54   (DECL_LANG_SPECIFIC (NODE) ? DECL_LANG_SPECIFIC (NODE)->t : NULL_TREE)
  55
  56 #define SET_DECL_LANG_SPECIFIC(NODE, X)                  \
  57 do {                                                     \
  58   tree tmp = (X);                                        \
  59   if (!DECL_LANG_SPECIFIC (NODE))                        \
  60     DECL_LANG_SPECIFIC (NODE)                            \
  61       = ggc_alloc<struct lang_decl> (); \
  62   DECL_LANG_SPECIFIC (NODE)->t = tmp;                    \
  63 } while (0)
  64
  65
  66 /* Flags added to type nodes.  */
  67
  68 /* For RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE, nonzero if this is a
  69    record being used as a fat pointer (only true for RECORD_TYPE).  */
  70 #define TYPE_FAT_POINTER_P(NODE) \
  71   TYPE_LANG_FLAG_0 (RECORD_OR_UNION_CHECK (NODE))
  72
  73 #define TYPE_IS_FAT_POINTER_P(NODE) \
  74   (TREE_CODE (NODE) == RECORD_TYPE && TYPE_FAT_POINTER_P (NODE))
  75
  76 /* For integral types and array types, nonzero if this is a packed array type
  77    used for bit-packed types.  Such types should not be extended to a larger
  78    size or validated against a specified size.  */
  79 #define TYPE_PACKED_ARRAY_TYPE_P(NODE) \
  80   TYPE_LANG_FLAG_0 (TREE_CHECK2 (NODE, INTEGER_TYPE, ARRAY_TYPE))
  81
  82 #define TYPE_IS_PACKED_ARRAY_TYPE_P(NODE) \
  83   ((TREE_CODE (NODE) == INTEGER_TYPE || TREE_CODE (NODE) == ARRAY_TYPE) \
  84    && TYPE_PACKED_ARRAY_TYPE_P (NODE))
  85
  86 /* For INTEGER_TYPE, nonzero if this is a modular type with a modulus that
  87    is not equal to two to the power of its mode's size.  */
  88 #define TYPE_MODULAR_P(NODE) TYPE_LANG_FLAG_1 (INTEGER_TYPE_CHECK (NODE))
  89
  90 /* For ARRAY_TYPE, nonzero if this type corresponds to a dimension of
  91    an Ada array other than the first.  */
  92 #define TYPE_MULTI_ARRAY_P(NODE) TYPE_LANG_FLAG_1 (ARRAY_TYPE_CHECK (NODE))
  93
  94 /* For FUNCTION_TYPE, nonzero if this denotes a function returning an
  95    unconstrained array or record.  */
  96 #define TYPE_RETURN_UNCONSTRAINED_P(NODE) \
  97   TYPE_LANG_FLAG_1 (FUNCTION_TYPE_CHECK (NODE))
  98
  99 /* For RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE, nonzero if this denotes
 100    a justified modular type (will only be true for RECORD_TYPE).  */
 101 #define TYPE_JUSTIFIED_MODULAR_P(NODE) \
 102   TYPE_LANG_FLAG_1 (RECORD_OR_UNION_CHECK (NODE))
 103
 104 /* Nonzero in an arithmetic subtype if this is a subtype not known to the
 105    front-end.  */
 106 #define TYPE_EXTRA_SUBTYPE_P(NODE) TYPE_LANG_FLAG_2 (INTEGER_TYPE_CHECK (NODE))
 107
 108 /* Nonzero for an aggregate type if this is a by-reference type.  We also
 109    set this on an ENUMERAL_TYPE that is dummy.  */
 110 #define TYPE_BY_REFERENCE_P(NODE)                                      \
 111   TYPE_LANG_FLAG_2 (TREE_CHECK5 (NODE, RECORD_TYPE, UNION_TYPE,        \
 112                                  ARRAY_TYPE, UNCONSTRAINED_ARRAY_TYPE, \
 113                                  ENUMERAL_TYPE))
 114
 115 #define TYPE_IS_BY_REFERENCE_P(NODE)                \
 116   ((TREE_CODE (NODE) == RECORD_TYPE                 \
 117     || TREE_CODE (NODE) == UNION_TYPE               \
 118     || TREE_CODE (NODE) == ARRAY_TYPE               \
 119     || TREE_CODE (NODE) == UNCONSTRAINED_ARRAY_TYPE \
 120     || TREE_CODE (NODE) == ENUMERAL_TYPE)           \
 121    && TYPE_BY_REFERENCE_P (NODE))
 122
 123 /* For RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE, nonzero if this is the
 124    type for an object whose type includes its template in addition to
 125    its value (only true for RECORD_TYPE).  */
 126 #define TYPE_CONTAINS_TEMPLATE_P(NODE) \
 127   TYPE_LANG_FLAG_3 (RECORD_OR_UNION_CHECK (NODE))
 128
 129 /* For INTEGER_TYPE, nonzero if it implements a fixed-point type.  */
 130 #define TYPE_FIXED_POINT_P(NODE) \
 131   TYPE_LANG_FLAG_3 (INTEGER_TYPE_CHECK (NODE))
 132
 133 #define TYPE_IS_FIXED_POINT_P(NODE) \
 134   (TREE_CODE (NODE) == INTEGER_TYPE && TYPE_FIXED_POINT_P (NODE))
 135
 136 /* True if NODE is a thin pointer.  */
 137 #define TYPE_IS_THIN_POINTER_P(NODE)                    \
 138   (POINTER_TYPE_P (NODE)                                \
 139    && TREE_CODE (TREE_TYPE (NODE)) == RECORD_TYPE       \
 140    && TYPE_CONTAINS_TEMPLATE_P (TREE_TYPE (NODE)))
 141
 142 /* True if TYPE is either a fat or thin pointer to an unconstrained
 143    array.  */
 144 #define TYPE_IS_FAT_OR_THIN_POINTER_P(NODE) \
 145   (TYPE_IS_FAT_POINTER_P (NODE) || TYPE_IS_THIN_POINTER_P (NODE))
 146
 147 /* For INTEGER_TYPEs, nonzero if the type has a biased representation.  */
 148 #define TYPE_BIASED_REPRESENTATION_P(NODE) \
 149   TYPE_LANG_FLAG_4 (INTEGER_TYPE_CHECK (NODE))
 150
 151 /* For ARRAY_TYPEs, nonzero if the array type has Convention_Fortran.  */
 152 #define TYPE_CONVENTION_FORTRAN_P(NODE) \
 153   TYPE_LANG_FLAG_4 (ARRAY_TYPE_CHECK (NODE))
 154
 155 /* For FUNCTION_TYPEs, nonzero if the function returns by direct reference,
 156    i.e. the callee returns a pointer to a memory location it has allocated
 157    and the caller only needs to dereference the pointer.  */
 158 #define TYPE_RETURN_BY_DIRECT_REF_P(NODE) \
 159   TYPE_LANG_FLAG_4 (FUNCTION_TYPE_CHECK (NODE))
 160
 161 /* For RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE, nonzero if this is a dummy
 162    type, made to correspond to a private or incomplete type.  */
 163 #define TYPE_DUMMY_P(NODE) \
 164   TYPE_LANG_FLAG_4 (TREE_CHECK3 (NODE, RECORD_TYPE, UNION_TYPE, ENUMERAL_TYPE))
 165
 166 #define TYPE_IS_DUMMY_P(NODE)             \
 167   ((TREE_CODE (NODE) == RECORD_TYPE       \
 168     || TREE_CODE (NODE) == UNION_TYPE     \
 169     || TREE_CODE (NODE) == ENUMERAL_TYPE) \
 170    && TYPE_DUMMY_P (NODE))
 171
 172 /* For an INTEGER_TYPE, nonzero if TYPE_ACTUAL_BOUNDS is present.  */
 173 #define TYPE_HAS_ACTUAL_BOUNDS_P(NODE) \
 174   TYPE_LANG_FLAG_5 (INTEGER_TYPE_CHECK (NODE))
 175
 176 /* For a RECORD_TYPE, nonzero if this was made just to supply needed
 177    padding or alignment.  */
 178 #define TYPE_PADDING_P(NODE) TYPE_LANG_FLAG_5 (RECORD_TYPE_CHECK (NODE))
 179
 180 #define TYPE_IS_PADDING_P(NODE) \
 181   (TREE_CODE (NODE) == RECORD_TYPE && TYPE_PADDING_P (NODE))
 182
 183 /* True for a non-dummy type if TYPE can alias any other types.  */
 184 #define TYPE_UNIVERSAL_ALIASING_P(NODE) TYPE_LANG_FLAG_6 (NODE)
 185
 186 /* True for a dummy type if TYPE appears in a profile.  */
 187 #define TYPE_DUMMY_IN_PROFILE_P(NODE) TYPE_LANG_FLAG_6 (NODE)
 188
 189 /* True for types that implement a packed array and for original packed array
 190    types.  */
 191 #define TYPE_IMPL_PACKED_ARRAY_P(NODE) \
 192   ((TREE_CODE (NODE) == ARRAY_TYPE && TYPE_PACKED (NODE)) \
 193    || (TREE_CODE (NODE) == INTEGER_TYPE && TYPE_PACKED_ARRAY_TYPE_P (NODE)))
 194
 195 /* True for types that can hold a debug type.  */
 196 #define TYPE_CAN_HAVE_DEBUG_TYPE_P(NODE) (!TYPE_IMPL_PACKED_ARRAY_P (NODE))
 197
 198 /* For RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE, this holds the maximum
 199    alignment value the type ought to have.  */
 200 #define TYPE_MAX_ALIGN(NODE) (TYPE_PRECISION (RECORD_OR_UNION_CHECK (NODE)))
 201
 202 /* True if objects of tagged types are guaranteed to be properly aligned.  */
 203 #define TYPE_ALIGN_OK(NODE) TYPE_LANG_FLAG_7 (NODE)
 204
 205 /* For an UNCONSTRAINED_ARRAY_TYPE, this is the record containing both the
 206    template and the object.
 207
 208    ??? We also put this on an ENUMERAL_TYPE that is dummy.  Technically,
 209    this is a conflict on the minval field, but there doesn't seem to be
 210    simple fix, so we'll live with this kludge for now.  */
 211 #define TYPE_OBJECT_RECORD_TYPE(NODE) \
 212   (TYPE_MIN_VALUE_RAW (TREE_CHECK2 ((NODE), UNCONSTRAINED_ARRAY_TYPE, \
 213                                     ENUMERAL_TYPE)))
 214
 215 /* For numerical types, this is the GCC lower bound of the type.  The GCC
 216    type system is based on the invariant that an object X of a given type
 217    cannot hold at run time a value smaller than its lower bound; otherwise
 218    the behavior is undefined.  The optimizer takes advantage of this and
 219    considers that the assertion X >= LB is always true.  */
 220 #define TYPE_GCC_MIN_VALUE(NODE) \
 221   (TYPE_MIN_VALUE_RAW (NUMERICAL_TYPE_CHECK (NODE)))
 222
 223 /* For numerical types, this is the GCC upper bound of the type.  The GCC
 224    type system is based on the invariant that an object X of a given type
 225    cannot hold at run time a value larger than its upper bound; otherwise
 226    the behavior is undefined.  The optimizer takes advantage of this and
 227    considers that the assertion X <= UB is always true.  */
 228 #define TYPE_GCC_MAX_VALUE(NODE) \
 229   (TYPE_MAX_VALUE_RAW (NUMERICAL_TYPE_CHECK (NODE)))
 230
 231 /* For a FUNCTION_TYPE, if the subprogram has parameters passed by copy in/
 232    copy out, this is the list of nodes used to specify the return values of
 233    the out (or in out) parameters that are passed by copy in/copy out.  For
 234    a full description of the copy in/copy out parameter passing mechanism
 235    refer to the routine gnat_to_gnu_entity.  */
 236 #define TYPE_CI_CO_LIST(NODE) TYPE_LANG_SLOT_1 (FUNCTION_TYPE_CHECK (NODE))
 237
 238 /* For a VECTOR_TYPE, this is the representative array type.  */
 239 #define TYPE_REPRESENTATIVE_ARRAY(NODE) \
 240   TYPE_LANG_SLOT_1 (VECTOR_TYPE_CHECK (NODE))
 241
 242 /* For numerical types, this holds various RM-defined values.  */
 243 #define TYPE_RM_VALUES(NODE) TYPE_LANG_SLOT_1 (NUMERICAL_TYPE_CHECK (NODE))
 244
 245 /* Macros to get and set the individual values in TYPE_RM_VALUES.  */
 246 #define TYPE_RM_VALUE(NODE, N)                              \
 247   (TYPE_RM_VALUES (NODE)                                    \
 248    ? TREE_VEC_ELT (TYPE_RM_VALUES (NODE), (N)) : NULL_TREE)
 249
 250 #define SET_TYPE_RM_VALUE(NODE, N, X)              \
 251 do {                                               \
 252   tree tmp = (X);                                  \
 253   if (!TYPE_RM_VALUES (NODE))                      \
 254     TYPE_RM_VALUES (NODE) = make_tree_vec (3);     \
 255   /* ??? The field is not visited by the generic   \
 256      code so we need to mark it manually.  */      \
 257   MARK_VISITED (tmp);                              \
 258   TREE_VEC_ELT (TYPE_RM_VALUES (NODE), (N)) = tmp; \
 259 } while (0)
 260
 261 /* For numerical types, this is the RM size of the type, aka its precision.
 262    There is a discrepancy between what is called precision here (and more
 263    generally throughout gigi) and what is called precision in the GCC type
 264    system: in the former case it's TYPE_RM_SIZE whereas it's TYPE_PRECISION
 265    in the latter case.  They are not identical because of the need to support
 266    invalid values.
 267
 268    These values can be outside the range of values allowed by the RM size
 269    but they must nevertheless be valid in the GCC type system, otherwise
 270    the optimizer can pretend that they simply don't exist.  Therefore they
 271    must be within the range of values allowed by the precision in the GCC
 272    sense, hence TYPE_PRECISION be set to the Esize, not the RM size.  */
 273 #define TYPE_RM_SIZE(NODE) TYPE_RM_VALUE ((NODE), 0)
 274 #define SET_TYPE_RM_SIZE(NODE, X) SET_TYPE_RM_VALUE ((NODE), 0, (X))
 275
 276 /* For numerical types, this is the RM lower bound of the type.  There is
 277    again a discrepancy between this lower bound and the GCC lower bound,
 278    again because of the need to support invalid values.
 279
 280    These values can be outside the range of values allowed by the RM lower
 281    bound but they must nevertheless be valid in the GCC type system, otherwise
 282    the optimizer can pretend that they simply don't exist.  Therefore they
 283    must be within the range of values allowed by the lower bound in the GCC
 284    sense, hence the GCC lower bound be set to that of the base type.
 285
 286    This lower bound is translated directly without the adjustments that may
 287    be required for type compatibility, so it will generally be necessary to
 288    convert it to the base type of the numerical type before using it.  */
 289 #define TYPE_RM_MIN_VALUE(NODE) TYPE_RM_VALUE ((NODE), 1)
 290 #define SET_TYPE_RM_MIN_VALUE(NODE, X) SET_TYPE_RM_VALUE ((NODE), 1, (X))
 291
 292 /* For numerical types, this is the RM upper bound of the type.  There is
 293    again a discrepancy between this upper bound and the GCC upper bound,
 294    again because of the need to support invalid values.
 295
 296    These values can be outside the range of values allowed by the RM upper
 297    bound but they must nevertheless be valid in the GCC type system, otherwise
 298    the optimizer can pretend that they simply don't exist.  Therefore they
 299    must be within the range of values allowed by the upper bound in the GCC
 300    sense, hence the GCC upper bound be set to that of the base type.
 301
 302    This upper bound is translated directly without the adjustments that may
 303    be required for type compatibility, so it will generally be necessary to
 304    convert it to the base type of the numerical type before using it.  */
 305 #define TYPE_RM_MAX_VALUE(NODE) TYPE_RM_VALUE ((NODE), 2)
 306 #define SET_TYPE_RM_MAX_VALUE(NODE, X) SET_TYPE_RM_VALUE ((NODE), 2, (X))
 307
 308 /* For numerical types, this is the lower bound of the type, i.e. the RM lower
 309    bound for language-defined types and the GCC lower bound for others.  */
 310 #undef TYPE_MIN_VALUE
 311 #define TYPE_MIN_VALUE(NODE) \
 312   (TYPE_RM_MIN_VALUE (NODE) \
 313    ? TYPE_RM_MIN_VALUE (NODE) : TYPE_GCC_MIN_VALUE (NODE))
 314
 315 /* For numerical types, this is the upper bound of the type, i.e. the RM upper
 316    bound for language-defined types and the GCC upper bound for others.  */
 317 #undef TYPE_MAX_VALUE
 318 #define TYPE_MAX_VALUE(NODE) \
 319   (TYPE_RM_MAX_VALUE (NODE) \
 320    ? TYPE_RM_MAX_VALUE (NODE) : TYPE_GCC_MAX_VALUE (NODE))
 321
 322 /* For an INTEGER_TYPE with TYPE_MODULAR_P, this is the value of the
 323    modulus. */
 324 #define TYPE_MODULUS(NODE) \
 325   GET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))
 326 #define SET_TYPE_MODULUS(NODE, X) \
 327   SET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE), X)
 328
 329 /* For an INTEGER_TYPE that is the TYPE_DOMAIN of some ARRAY_TYPE, this is
 330    the type corresponding to the Ada index type.  It is necessary to keep
 331    these 2 views for every array type because the TYPE_DOMAIN is subject
 332    to strong constraints in GENERIC: it must be a subtype of SIZETYPE and
 333    may not be superflat, i.e. the upper bound must always be larger or
 334    equal to the lower bound minus 1 (i.e. the canonical length formula
 335    must always yield a non-negative number), which means that at least
 336    one of the bounds may need to be a conditional expression.  There are
 337    no such constraints on the TYPE_INDEX_TYPE because gigi is prepared to
 338    deal with the superflat case; moreover the TYPE_INDEX_TYPE is used as
 339    the index type for the debug info and, therefore, needs to be as close
 340    as possible to the source index type.  */
 341 #define TYPE_INDEX_TYPE(NODE) \
 342   GET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))
 343 #define SET_TYPE_INDEX_TYPE(NODE, X) \
 344   SET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE), X)
 345
 346 /* For an INTEGER_TYPE with TYPE_HAS_ACTUAL_BOUNDS_P or an ARRAY_TYPE, this is
 347    the index type that should be used when the actual bounds are required for
 348    a template.  This is used in the case of packed arrays.  */
 349 #define TYPE_ACTUAL_BOUNDS(NODE) \
 350   GET_TYPE_LANG_SPECIFIC (TREE_CHECK2 (NODE, INTEGER_TYPE, ARRAY_TYPE))
 351 #define SET_TYPE_ACTUAL_BOUNDS(NODE, X) \
 352   SET_TYPE_LANG_SPECIFIC (TREE_CHECK2 (NODE, INTEGER_TYPE, ARRAY_TYPE), X)
 353
 354 /* For a POINTER_TYPE that points to the template type of an unconstrained
 355    array type, this is the address to be used in a null fat pointer.  */
 356 #define TYPE_NULL_BOUNDS(NODE) \
 357   GET_TYPE_LANG_SPECIFIC (POINTER_TYPE_CHECK (NODE))
 358 #define SET_TYPE_NULL_BOUNDS(NODE, X) \
 359   SET_TYPE_LANG_SPECIFIC (POINTER_TYPE_CHECK (NODE), X)
 360
 361 /* For a RECORD_TYPE that is a fat pointer, this is the type for the
 362    unconstrained array.  Likewise for a RECORD_TYPE that is pointed
 363    to by a thin pointer, if it is made for the unconstrained array
 364    type itself; the field is NULL_TREE if the RECORD_TYPE is made
 365    for a constrained subtype of the array type.  */
 366 #define TYPE_UNCONSTRAINED_ARRAY(NODE) \
 367   GET_TYPE_LANG_SPECIFIC (RECORD_TYPE_CHECK (NODE))
 368 #define SET_TYPE_UNCONSTRAINED_ARRAY(NODE, X) \
 369   SET_TYPE_LANG_SPECIFIC (RECORD_TYPE_CHECK (NODE), X)
 370
 371 /* For other RECORD_TYPEs and all UNION_TYPEs and QUAL_UNION_TYPEs, this is
 372    the Ada size of the object.  This differs from the GCC size in that it
 373    does not include any rounding up to the alignment of the type.  */
 374 #define TYPE_ADA_SIZE(NODE) \
 375   GET_TYPE_LANG_SPECIFIC (RECORD_OR_UNION_CHECK (NODE))
 376 #define SET_TYPE_ADA_SIZE(NODE, X) \
 377   SET_TYPE_LANG_SPECIFIC (RECORD_OR_UNION_CHECK (NODE), X)
 378
 379 /* For an INTEGER_TYPE with TYPE_IS_FIXED_POINT_P, this is the value of the
 380    scale factor.  Modular types, index types (sizetype subtypes) and
 381    fixed-point types are totally distinct types, so there is no problem with
 382    sharing type lang specific's first slot.  */
 383 #define TYPE_SCALE_FACTOR(NODE) \
 384   GET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE))
 385 #define SET_TYPE_SCALE_FACTOR(NODE, X) \
 386   SET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE), X)
 387
 388 /* For types with TYPE_CAN_HAVE_DEBUG_TYPE_P, this is the type to use in
 389    debugging information.  */
 390 #define TYPE_DEBUG_TYPE(NODE) \
 391   GET_TYPE_LANG_SPECIFIC2 (NODE)
 392 #define SET_TYPE_DEBUG_TYPE(NODE, X) \
 393   SET_TYPE_LANG_SPECIFIC2 (NODE, X)
 394
 395 /* For types with TYPE_IMPL_PACKED_ARRAY_P, this is the original packed
 396    array type.  Note that this predicate is true for original packed array
 397    types, so these cannot have a debug type.  */
 398 #define TYPE_ORIGINAL_PACKED_ARRAY(NODE) \
 399   GET_TYPE_LANG_SPECIFIC2 (NODE)
 400 #define SET_TYPE_ORIGINAL_PACKED_ARRAY(NODE, X) \
 401   SET_TYPE_LANG_SPECIFIC2 (NODE, X)
 402
 403
 404 /* Flags added to decl nodes.  */
 405
 406 /* Nonzero in a FUNCTION_DECL that represents a stubbed function
 407    discriminant.  */
 408 #define DECL_STUBBED_P(NODE) DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE))
 409
 410 /* Nonzero in a VAR_DECL if it is guaranteed to be constant after having
 411    been elaborated and TREE_READONLY is not set on it.  */
 412 #define DECL_READONLY_ONCE_ELAB(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE))
 413
 414 /* Nonzero in a CONST_DECL if its value is (essentially) the address of a
 415    constant CONSTRUCTOR.  */
 416 #define DECL_CONST_ADDRESS_P(NODE) DECL_LANG_FLAG_0 (CONST_DECL_CHECK (NODE))
 417
 418 /* Nonzero in a FIELD_DECL if it is declared as aliased.  */
 419 #define DECL_ALIASED_P(NODE) DECL_LANG_FLAG_0 (FIELD_DECL_CHECK (NODE))
 420
 421 /* Nonzero in a TYPE_DECL if this is the declaration of a Taft amendment type
 422    in the main unit, i.e. the full declaration is available.  */
 423 #define DECL_TAFT_TYPE_P(NODE) DECL_LANG_FLAG_0 (TYPE_DECL_CHECK (NODE))
 424
 425 /* Nonzero in a PARM_DECL passed by reference but for which only a restricted
 426    form of aliasing is allowed.  The first restriction comes explicitly from
 427    the RM 6.2(12) clause: there is no read-after-write dependency between a
 428    store based on such a PARM_DECL and a load not based on this PARM_DECL,
 429    so stores based on such PARM_DECLs can be sunk past all loads based on
 430    a distinct object.  The second restriction can be inferred from the same
 431    clause: there is no write-after-write dependency between a store based
 432    on such a PARM_DECL and a store based on a distinct such PARM_DECL, as
 433    the compiler would be allowed to pass the parameters by copy and the
 434    order of assignment to actual parameters after a call is arbitrary as
 435    per the RM 6.4.1(17) clause, so stores based on distinct such PARM_DECLs
 436    can be swapped.  */
 437 #define DECL_RESTRICTED_ALIASING_P(NODE) \
 438   DECL_LANG_FLAG_0 (PARM_DECL_CHECK (NODE))
 439
 440 /* Nonzero in a DECL if it is always used by reference, i.e. an INDIRECT_REF
 441    is needed to access the object.  */
 442 #define DECL_BY_REF_P(NODE) DECL_LANG_FLAG_1 (NODE)
 443
 444 /* Nonzero in a DECL if it is made for a pointer that can never be null.  */
 445 #define DECL_CAN_NEVER_BE_NULL_P(NODE) DECL_LANG_FLAG_2 (NODE)
 446
 447 /* Nonzero in a VAR_DECL if it is made for a loop parameter.  */
 448 #define DECL_LOOP_PARM_P(NODE) DECL_LANG_FLAG_3 (VAR_DECL_CHECK (NODE))
 449
 450 /* Nonzero in a FIELD_DECL that is a dummy built for some internal reason.  */
 451 #define DECL_INTERNAL_P(NODE) DECL_LANG_FLAG_3 (FIELD_DECL_CHECK (NODE))
 452
 453 /* Nonzero in a PARM_DECL if it is made for an Ada array being passed to a
 454    foreign convention subprogram.  */
 455 #define DECL_BY_COMPONENT_PTR_P(NODE) DECL_LANG_FLAG_3 (PARM_DECL_CHECK (NODE))
 456
 457 /* Nonzero in a FUNCTION_DECL that corresponds to an elaboration procedure.  */
 458 #define DECL_ELABORATION_PROC_P(NODE) \
 459   DECL_LANG_FLAG_3 (FUNCTION_DECL_CHECK (NODE))
 460
 461 /* Nonzero in a CONST_DECL, VAR_DECL or PARM_DECL if it is made for a pointer
 462    that points to something which is readonly.  */
 463 #define DECL_POINTS_TO_READONLY_P(NODE) DECL_LANG_FLAG_4 (NODE)
 464
 465 /* Nonzero in a FIELD_DECL if it is invariant once set, for example if it is
 466    a discriminant of a discriminated type without default expression.  */
 467 #define DECL_INVARIANT_P(NODE) DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE))
 468
 469 /* Nonzero in a FUNCTION_DECL if this is a definition, i.e. if it was created
 470    by a call to gnat_to_gnu_entity with definition set to True.  */
 471 #define DECL_FUNCTION_IS_DEF(NODE) \
 472   DECL_LANG_FLAG_4 (FUNCTION_DECL_CHECK (NODE))
 473
 474 /* Nonzero in a VAR_DECL if it is a temporary created to hold the return
 475    value of a function call or 'reference to a function call.  */
 476 #define DECL_RETURN_VALUE_P(NODE) DECL_LANG_FLAG_5 (VAR_DECL_CHECK (NODE))
 477
 478 /* In a FIELD_DECL corresponding to a discriminant, contains the
 479    discriminant number.  */
 480 #define DECL_DISCRIMINANT_NUMBER(NODE) DECL_INITIAL (FIELD_DECL_CHECK (NODE))
 481
 482 /* In a CONST_DECL, points to a VAR_DECL that is allocatable to
 483    memory.  Used when a scalar constant is aliased or has its
 484    address taken.  */
 485 #define DECL_CONST_CORRESPONDING_VAR(NODE) \
 486   GET_DECL_LANG_SPECIFIC (CONST_DECL_CHECK (NODE))
 487 #define SET_DECL_CONST_CORRESPONDING_VAR(NODE, X) \
 488   SET_DECL_LANG_SPECIFIC (CONST_DECL_CHECK (NODE), X)
 489
 490 /* In a FIELD_DECL, points to the FIELD_DECL that was the ultimate
 491    source of the decl.  */
 492 #define DECL_ORIGINAL_FIELD(NODE) \
 493   GET_DECL_LANG_SPECIFIC (FIELD_DECL_CHECK (NODE))
 494 #define SET_DECL_ORIGINAL_FIELD(NODE, X) \
 495   SET_DECL_LANG_SPECIFIC (FIELD_DECL_CHECK (NODE), X)
 496
 497 /* Set DECL_ORIGINAL_FIELD of FIELD1 to (that of) FIELD2.  */
 498 #define SET_DECL_ORIGINAL_FIELD_TO_FIELD(FIELD1, FIELD2)        \
 499   SET_DECL_ORIGINAL_FIELD ((FIELD1),                            \
 500                            DECL_ORIGINAL_FIELD (FIELD2)         \
 501                            ? DECL_ORIGINAL_FIELD (FIELD2) : (FIELD2))
 502
 503 /* Return true if FIELD1 and FIELD2 represent the same field.  */
 504 #define SAME_FIELD_P(FIELD1, FIELD2)                                    \
 505   ((FIELD1) == (FIELD2)                                                 \
 506    || DECL_ORIGINAL_FIELD (FIELD1) == (FIELD2)                          \
 507    || (FIELD1) == DECL_ORIGINAL_FIELD (FIELD2)                          \
 508    || (DECL_ORIGINAL_FIELD (FIELD1)                                     \
 509        && (DECL_ORIGINAL_FIELD (FIELD1) == DECL_ORIGINAL_FIELD (FIELD2))))
 510
 511 /* In a VAR_DECL with the DECL_LOOP_PARM_P flag set, points to the special
 512    induction variable that is built under certain circumstances, if any.  */
 513 #define DECL_INDUCTION_VAR(NODE) \
 514   GET_DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))
 515 #define SET_DECL_INDUCTION_VAR(NODE, X) \
 516   SET_DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE), X)
 517
 518 /* In a VAR_DECL without the DECL_LOOP_PARM_P flag set and that is a renaming
 519    pointer, points to the object being renamed, if any.  */
 520 #define DECL_RENAMED_OBJECT(NODE) \
 521   GET_DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE))
 522 #define SET_DECL_RENAMED_OBJECT(NODE, X) \
 523   SET_DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE), X)
 524
 525 /* In a TYPE_DECL, points to the parallel type if any, otherwise 0.  */
 526 #define DECL_PARALLEL_TYPE(NODE) \
 527   GET_DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE))
 528 #define SET_DECL_PARALLEL_TYPE(NODE, X) \
 529   SET_DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE), X)
 530
 531
 532 /* Flags added to ref nodes.  */
 533
 534 /* Nonzero means this node will not trap.  */
 535 #undef TREE_THIS_NOTRAP
 536 #define TREE_THIS_NOTRAP(NODE) \
 537   (TREE_CHECK4 (NODE, INDIRECT_REF, ARRAY_REF, UNCONSTRAINED_ARRAY_REF, \
 538                 ARRAY_RANGE_REF)->base.nothrow_flag)
 539
 540
 541 /* Fields and macros for statements.  */
 542 #define IS_ADA_STMT(NODE) \
 543   (STATEMENT_CLASS_P (NODE) && TREE_CODE (NODE) >= STMT_STMT)
 544
 545 #define STMT_STMT_STMT(NODE)     TREE_OPERAND_CHECK_CODE (NODE, STMT_STMT, 0)
 546
 547 #define LOOP_STMT_COND(NODE)     TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 0)
 548 #define LOOP_STMT_UPDATE(NODE)   TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 1)
 549 #define LOOP_STMT_BODY(NODE)     TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 2)
 550 #define LOOP_STMT_LABEL(NODE)    TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 3)
 551
 552 /* A loop statement is conceptually made up of 6 sub-statements:
 553
 554     loop:
 555       TOP_CONDITION
 556       TOP_UPDATE
 557       BODY
 558       BOTTOM_CONDITION
 559       BOTTOM_UPDATE
 560       GOTO loop
 561
 562   However, only 4 of them can exist for a given loop, the pair of conditions
 563   and the pair of updates being mutually exclusive.  The default setting is
 564   TOP_CONDITION and BOTTOM_UPDATE and the following couple of flags are used
 565   to toggle the individual settings.  */
 566 #define LOOP_STMT_BOTTOM_COND_P(NODE) TREE_LANG_FLAG_0 (LOOP_STMT_CHECK (NODE))
 567 #define LOOP_STMT_TOP_UPDATE_P(NODE)  TREE_LANG_FLAG_1 (LOOP_STMT_CHECK (NODE))
 568
 569 /* Optimization hints on loops.  */
 570 #define LOOP_STMT_IVDEP(NODE)     TREE_LANG_FLAG_2 (LOOP_STMT_CHECK (NODE))
 571 #define LOOP_STMT_NO_UNROLL(NODE) TREE_LANG_FLAG_3 (LOOP_STMT_CHECK (NODE))
 572 #define LOOP_STMT_UNROLL(NODE)    TREE_LANG_FLAG_4 (LOOP_STMT_CHECK (NODE))
 573 #define LOOP_STMT_NO_VECTOR(NODE) TREE_LANG_FLAG_5 (LOOP_STMT_CHECK (NODE))
 574 #define LOOP_STMT_VECTOR(NODE)    TREE_LANG_FLAG_6 (LOOP_STMT_CHECK (NODE))
 575
 576 #define EXIT_STMT_COND(NODE)     TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 0)
 577 #define EXIT_STMT_LABEL(NODE)    TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 1)