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-2018, 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 FUNCTION_TYPEs, nonzero if the function returns by direct reference, 87 i.e. the callee returns a pointer to a memory location it has allocated 88 and the caller only needs to dereference the pointer. */ 89 #define TYPE_RETURN_BY_DIRECT_REF_P(NODE) \ 90 TYPE_LANG_FLAG_0 (FUNCTION_TYPE_CHECK (NODE)) 91 92 /* For INTEGER_TYPE, nonzero if this is a modular type with a modulus that 93 is not equal to two to the power of its mode's size. */ 94 #define TYPE_MODULAR_P(NODE) TYPE_LANG_FLAG_1 (INTEGER_TYPE_CHECK (NODE)) 95 96 /* For ARRAY_TYPE, nonzero if this type corresponds to a dimension of 97 an Ada array other than the first. */ 98 #define TYPE_MULTI_ARRAY_P(NODE) TYPE_LANG_FLAG_1 (ARRAY_TYPE_CHECK (NODE)) 99 100 /* For FUNCTION_TYPE, nonzero if this denotes a function returning an 101 unconstrained array or record. */ 102 #define TYPE_RETURN_UNCONSTRAINED_P(NODE) \ 103 TYPE_LANG_FLAG_1 (FUNCTION_TYPE_CHECK (NODE)) 104 105 /* For RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE, nonzero if this denotes 106 a justified modular type (will only be true for RECORD_TYPE). */ 107 #define TYPE_JUSTIFIED_MODULAR_P(NODE) \ 108 TYPE_LANG_FLAG_1 (RECORD_OR_UNION_CHECK (NODE)) 109 110 /* Nonzero in an arithmetic subtype if this is a subtype not known to the 111 front-end. */ 112 #define TYPE_EXTRA_SUBTYPE_P(NODE) TYPE_LANG_FLAG_2 (INTEGER_TYPE_CHECK (NODE)) 113 114 /* Nonzero for an aggregate type if this is a by-reference type. We also 115 set this on an ENUMERAL_TYPE that is dummy. */ 116 #define TYPE_BY_REFERENCE_P(NODE) \ 117 TYPE_LANG_FLAG_2 (TREE_CHECK5 (NODE, RECORD_TYPE, UNION_TYPE, \ 118 ARRAY_TYPE, UNCONSTRAINED_ARRAY_TYPE, \ 119 ENUMERAL_TYPE)) 120 121 #define TYPE_IS_BY_REFERENCE_P(NODE) \ 122 ((TREE_CODE (NODE) == RECORD_TYPE \ 123 || TREE_CODE (NODE) == UNION_TYPE \ 124 || TREE_CODE (NODE) == ARRAY_TYPE \ 125 || TREE_CODE (NODE) == UNCONSTRAINED_ARRAY_TYPE \ 126 || TREE_CODE (NODE) == ENUMERAL_TYPE) \ 127 && TYPE_BY_REFERENCE_P (NODE)) 128 129 /* For RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE, nonzero if this is the 130 type for an object whose type includes its template in addition to 131 its value (only true for RECORD_TYPE). */ 132 #define TYPE_CONTAINS_TEMPLATE_P(NODE) \ 133 TYPE_LANG_FLAG_3 (RECORD_OR_UNION_CHECK (NODE)) 134 135 /* For INTEGER_TYPE, nonzero if it implements a fixed-point type. */ 136 #define TYPE_FIXED_POINT_P(NODE) \ 137 TYPE_LANG_FLAG_3 (INTEGER_TYPE_CHECK (NODE)) 138 139 #define TYPE_IS_FIXED_POINT_P(NODE) \ 140 (TREE_CODE (NODE) == INTEGER_TYPE && TYPE_FIXED_POINT_P (NODE)) 141 142 /* True if NODE is a thin pointer. */ 143 #define TYPE_IS_THIN_POINTER_P(NODE) \ 144 (POINTER_TYPE_P (NODE) \ 145 && TREE_CODE (TREE_TYPE (NODE)) == RECORD_TYPE \ 146 && TYPE_CONTAINS_TEMPLATE_P (TREE_TYPE (NODE))) 147 148 /* True if TYPE is either a fat or thin pointer to an unconstrained 149 array. */ 150 #define TYPE_IS_FAT_OR_THIN_POINTER_P(NODE) \ 151 (TYPE_IS_FAT_POINTER_P (NODE) || TYPE_IS_THIN_POINTER_P (NODE)) 152 153 /* For INTEGER_TYPEs, nonzero if the type has a biased representation. */ 154 #define TYPE_BIASED_REPRESENTATION_P(NODE) \ 155 TYPE_LANG_FLAG_4 (INTEGER_TYPE_CHECK (NODE)) 156 157 /* For ARRAY_TYPEs, nonzero if the array type has Convention_Fortran. */ 158 #define TYPE_CONVENTION_FORTRAN_P(NODE) \ 159 TYPE_LANG_FLAG_4 (ARRAY_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 if objects of this type are guaranteed to be properly aligned. */ 190 #define TYPE_ALIGN_OK(NODE) TYPE_LANG_FLAG_7 (NODE) 191 192 /* True for types that implement a packed array and for original packed array 193 types. */ 194 #define TYPE_IMPL_PACKED_ARRAY_P(NODE) \ 195 ((TREE_CODE (NODE) == ARRAY_TYPE && TYPE_PACKED (NODE)) \ 196 || (TREE_CODE (NODE) == INTEGER_TYPE && TYPE_PACKED_ARRAY_TYPE_P (NODE))) 197 198 /* True for types that can hold a debug type. */ 199 #define TYPE_CAN_HAVE_DEBUG_TYPE_P(NODE) (!TYPE_IMPL_PACKED_ARRAY_P (NODE)) 200 201 /* For RECORD_TYPE, UNION_TYPE, and QUAL_UNION_TYPE, this holds the maximum 202 alignment value the type ought to have. */ 203 #define TYPE_MAX_ALIGN(NODE) (TYPE_PRECISION (RECORD_OR_UNION_CHECK (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 an ARRAY_TYPE with variable size, this is the padding type built for 239 the array type when it is itself the component type of another array. */ 240 #define TYPE_PADDING_FOR_COMPONENT(NODE) \ 241 TYPE_LANG_SLOT_1 (ARRAY_TYPE_CHECK (NODE)) 242 243 /* For a VECTOR_TYPE, this is the representative array type. */ 244 #define TYPE_REPRESENTATIVE_ARRAY(NODE) \ 245 TYPE_LANG_SLOT_1 (VECTOR_TYPE_CHECK (NODE)) 246 247 /* For numerical types, this holds various RM-defined values. */ 248 #define TYPE_RM_VALUES(NODE) TYPE_LANG_SLOT_1 (NUMERICAL_TYPE_CHECK (NODE)) 249 250 /* Macros to get and set the individual values in TYPE_RM_VALUES. */ 251 #define TYPE_RM_VALUE(NODE, N) \ 252 (TYPE_RM_VALUES (NODE) \ 253 ? TREE_VEC_ELT (TYPE_RM_VALUES (NODE), (N)) : NULL_TREE) 254 255 #define SET_TYPE_RM_VALUE(NODE, N, X) \ 256 do { \ 257 tree tmp = (X); \ 258 if (!TYPE_RM_VALUES (NODE)) \ 259 TYPE_RM_VALUES (NODE) = make_tree_vec (3); \ 260 /* ??? The field is not visited by the generic \ 261 code so we need to mark it manually. */ \ 262 MARK_VISITED (tmp); \ 263 TREE_VEC_ELT (TYPE_RM_VALUES (NODE), (N)) = tmp; \ 264 } while (0) 265 266 /* For numerical types, this is the RM size of the type, aka its precision. 267 There is a discrepancy between what is called precision here (and more 268 generally throughout gigi) and what is called precision in the GCC type 269 system: in the former case it's TYPE_RM_SIZE whereas it's TYPE_PRECISION 270 in the latter case. They are not identical because of the need to support 271 invalid values. 272 273 These values can be outside the range of values allowed by the RM size 274 but they must nevertheless be valid in the GCC type system, otherwise 275 the optimizer can pretend that they simply don't exist. Therefore they 276 must be within the range of values allowed by the precision in the GCC 277 sense, hence TYPE_PRECISION be set to the Esize, not the RM size. */ 278 #define TYPE_RM_SIZE(NODE) TYPE_RM_VALUE ((NODE), 0) 279 #define SET_TYPE_RM_SIZE(NODE, X) SET_TYPE_RM_VALUE ((NODE), 0, (X)) 280 281 /* For numerical types, this is the RM lower bound of the type. There is 282 again a discrepancy between this lower bound and the GCC lower bound, 283 again because of the need to support invalid values. 284 285 These values can be outside the range of values allowed by the RM lower 286 bound but they must nevertheless be valid in the GCC type system, otherwise 287 the optimizer can pretend that they simply don't exist. Therefore they 288 must be within the range of values allowed by the lower bound in the GCC 289 sense, hence the GCC lower bound be set to that of the base type. 290 291 This lower bound is translated directly without the adjustments that may 292 be required for type compatibility, so it will generally be necessary to 293 convert it to the base type of the numerical type before using it. */ 294 #define TYPE_RM_MIN_VALUE(NODE) TYPE_RM_VALUE ((NODE), 1) 295 #define SET_TYPE_RM_MIN_VALUE(NODE, X) SET_TYPE_RM_VALUE ((NODE), 1, (X)) 296 297 /* For numerical types, this is the RM upper bound of the type. There is 298 again a discrepancy between this upper bound and the GCC upper bound, 299 again because of the need to support invalid values. 300 301 These values can be outside the range of values allowed by the RM upper 302 bound but they must nevertheless be valid in the GCC type system, otherwise 303 the optimizer can pretend that they simply don't exist. Therefore they 304 must be within the range of values allowed by the upper bound in the GCC 305 sense, hence the GCC upper bound be set to that of the base type. 306 307 This upper bound is translated directly without the adjustments that may 308 be required for type compatibility, so it will generally be necessary to 309 convert it to the base type of the numerical type before using it. */ 310 #define TYPE_RM_MAX_VALUE(NODE) TYPE_RM_VALUE ((NODE), 2) 311 #define SET_TYPE_RM_MAX_VALUE(NODE, X) SET_TYPE_RM_VALUE ((NODE), 2, (X)) 312 313 /* For numerical types, this is the lower bound of the type, i.e. the RM lower 314 bound for language-defined types and the GCC lower bound for others. */ 315 #undef TYPE_MIN_VALUE 316 #define TYPE_MIN_VALUE(NODE) \ 317 (TYPE_RM_MIN_VALUE (NODE) \ 318 ? TYPE_RM_MIN_VALUE (NODE) : TYPE_GCC_MIN_VALUE (NODE)) 319 320 /* For numerical types, this is the upper bound of the type, i.e. the RM upper 321 bound for language-defined types and the GCC upper bound for others. */ 322 #undef TYPE_MAX_VALUE 323 #define TYPE_MAX_VALUE(NODE) \ 324 (TYPE_RM_MAX_VALUE (NODE) \ 325 ? TYPE_RM_MAX_VALUE (NODE) : TYPE_GCC_MAX_VALUE (NODE)) 326 327 /* For an INTEGER_TYPE with TYPE_MODULAR_P, this is the value of the 328 modulus. */ 329 #define TYPE_MODULUS(NODE) \ 330 GET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE)) 331 #define SET_TYPE_MODULUS(NODE, X) \ 332 SET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE), X) 333 334 /* For an INTEGER_TYPE that is the TYPE_DOMAIN of some ARRAY_TYPE, this is 335 the type corresponding to the Ada index type. It is necessary to keep 336 these 2 views for every array type because the TYPE_DOMAIN is subject 337 to strong constraints in GENERIC: it must be a subtype of SIZETYPE and 338 may not be superflat, i.e. the upper bound must always be larger or 339 equal to the lower bound minus 1 (i.e. the canonical length formula 340 must always yield a non-negative number), which means that at least 341 one of the bounds may need to be a conditional expression. There are 342 no such constraints on the TYPE_INDEX_TYPE because gigi is prepared to 343 deal with the superflat case; moreover the TYPE_INDEX_TYPE is used as 344 the index type for the debug info and, therefore, needs to be as close 345 as possible to the source index type. */ 346 #define TYPE_INDEX_TYPE(NODE) \ 347 GET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE)) 348 #define SET_TYPE_INDEX_TYPE(NODE, X) \ 349 SET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE), X) 350 351 /* For an INTEGER_TYPE with TYPE_HAS_ACTUAL_BOUNDS_P or an ARRAY_TYPE, this is 352 the index type that should be used when the actual bounds are required for 353 a template. This is used in the case of packed arrays. */ 354 #define TYPE_ACTUAL_BOUNDS(NODE) \ 355 GET_TYPE_LANG_SPECIFIC (TREE_CHECK2 (NODE, INTEGER_TYPE, ARRAY_TYPE)) 356 #define SET_TYPE_ACTUAL_BOUNDS(NODE, X) \ 357 SET_TYPE_LANG_SPECIFIC (TREE_CHECK2 (NODE, INTEGER_TYPE, ARRAY_TYPE), X) 358 359 /* For a POINTER_TYPE that points to the template type of an unconstrained 360 array type, this is the address to be used in a null fat pointer. */ 361 #define TYPE_NULL_BOUNDS(NODE) \ 362 GET_TYPE_LANG_SPECIFIC (POINTER_TYPE_CHECK (NODE)) 363 #define SET_TYPE_NULL_BOUNDS(NODE, X) \ 364 SET_TYPE_LANG_SPECIFIC (POINTER_TYPE_CHECK (NODE), X) 365 366 /* For a RECORD_TYPE that is a fat pointer, this is the type for the 367 unconstrained array. Likewise for a RECORD_TYPE that is pointed 368 to by a thin pointer, if it is made for the unconstrained array 369 type itself; the field is NULL_TREE if the RECORD_TYPE is made 370 for a constrained subtype of the array type. */ 371 #define TYPE_UNCONSTRAINED_ARRAY(NODE) \ 372 GET_TYPE_LANG_SPECIFIC (RECORD_TYPE_CHECK (NODE)) 373 #define SET_TYPE_UNCONSTRAINED_ARRAY(NODE, X) \ 374 SET_TYPE_LANG_SPECIFIC (RECORD_TYPE_CHECK (NODE), X) 375 376 /* For other RECORD_TYPEs and all UNION_TYPEs and QUAL_UNION_TYPEs, this is 377 the Ada size of the object. This differs from the GCC size in that it 378 does not include any rounding up to the alignment of the type. */ 379 #define TYPE_ADA_SIZE(NODE) \ 380 GET_TYPE_LANG_SPECIFIC (RECORD_OR_UNION_CHECK (NODE)) 381 #define SET_TYPE_ADA_SIZE(NODE, X) \ 382 SET_TYPE_LANG_SPECIFIC (RECORD_OR_UNION_CHECK (NODE), X) 383 384 /* For an INTEGER_TYPE with TYPE_IS_FIXED_POINT_P, this is the value of the 385 scale factor. Modular types, index types (sizetype subtypes) and 386 fixed-point types are totally distinct types, so there is no problem with 387 sharing type lang specific's first slot. */ 388 #define TYPE_SCALE_FACTOR(NODE) \ 389 GET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE)) 390 #define SET_TYPE_SCALE_FACTOR(NODE, X) \ 391 SET_TYPE_LANG_SPECIFIC (INTEGER_TYPE_CHECK (NODE), X) 392 393 /* For types with TYPE_CAN_HAVE_DEBUG_TYPE_P, this is the type to use in 394 debugging information. */ 395 #define TYPE_DEBUG_TYPE(NODE) \ 396 GET_TYPE_LANG_SPECIFIC2 (NODE) 397 #define SET_TYPE_DEBUG_TYPE(NODE, X) \ 398 SET_TYPE_LANG_SPECIFIC2 (NODE, X) 399 400 /* For types with TYPE_IMPL_PACKED_ARRAY_P, this is the original packed 401 array type. Note that this predicate is true for original packed array 402 types, so these cannot have a debug type. */ 403 #define TYPE_ORIGINAL_PACKED_ARRAY(NODE) \ 404 GET_TYPE_LANG_SPECIFIC2 (NODE) 405 #define SET_TYPE_ORIGINAL_PACKED_ARRAY(NODE, X) \ 406 SET_TYPE_LANG_SPECIFIC2 (NODE, X) 407 408 409 /* Flags added to decl nodes. */ 410 411 /* Nonzero in a FUNCTION_DECL that represents a stubbed function 412 discriminant. */ 413 #define DECL_STUBBED_P(NODE) DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE)) 414 415 /* Nonzero in a VAR_DECL if it is guaranteed to be constant after having 416 been elaborated and TREE_READONLY is not set on it. */ 417 #define DECL_READONLY_ONCE_ELAB(NODE) DECL_LANG_FLAG_0 (VAR_DECL_CHECK (NODE)) 418 419 /* Nonzero in a CONST_DECL if its value is (essentially) the address of a 420 constant CONSTRUCTOR. */ 421 #define DECL_CONST_ADDRESS_P(NODE) DECL_LANG_FLAG_0 (CONST_DECL_CHECK (NODE)) 422 423 /* Nonzero in a FIELD_DECL if it is declared as aliased. */ 424 #define DECL_ALIASED_P(NODE) DECL_LANG_FLAG_0 (FIELD_DECL_CHECK (NODE)) 425 426 /* Nonzero in a TYPE_DECL if this is the declaration of a Taft amendment type 427 in the main unit, i.e. the full declaration is available. */ 428 #define DECL_TAFT_TYPE_P(NODE) DECL_LANG_FLAG_0 (TYPE_DECL_CHECK (NODE)) 429 430 /* Nonzero in a PARM_DECL passed by reference but for which only a restricted 431 form of aliasing is allowed. The first restriction comes explicitly from 432 the RM 6.2(12) clause: there is no read-after-write dependency between a 433 store based on such a PARM_DECL and a load not based on this PARM_DECL, 434 so stores based on such PARM_DECLs can be sunk past all loads based on 435 a distinct object. The second restriction can be inferred from the same 436 clause: there is no write-after-write dependency between a store based 437 on such a PARM_DECL and a store based on a distinct such PARM_DECL, as 438 the compiler would be allowed to pass the parameters by copy and the 439 order of assignment to actual parameters after a call is arbitrary as 440 per the RM 6.4.1(17) clause, so stores based on distinct such PARM_DECLs 441 can be swapped. */ 442 #define DECL_RESTRICTED_ALIASING_P(NODE) \ 443 DECL_LANG_FLAG_0 (PARM_DECL_CHECK (NODE)) 444 445 /* Nonzero in a DECL if it is always used by reference, i.e. an INDIRECT_REF 446 is needed to access the object. */ 447 #define DECL_BY_REF_P(NODE) DECL_LANG_FLAG_1 (NODE) 448 449 /* Nonzero in a DECL if it is made for a pointer that can never be null. */ 450 #define DECL_CAN_NEVER_BE_NULL_P(NODE) DECL_LANG_FLAG_2 (NODE) 451 452 /* Nonzero in a VAR_DECL if it is made for a loop parameter. */ 453 #define DECL_LOOP_PARM_P(NODE) DECL_LANG_FLAG_3 (VAR_DECL_CHECK (NODE)) 454 455 /* Nonzero in a FIELD_DECL that is a dummy built for some internal reason. */ 456 #define DECL_INTERNAL_P(NODE) DECL_LANG_FLAG_3 (FIELD_DECL_CHECK (NODE)) 457 458 /* Nonzero in a PARM_DECL if it is made for an Ada array being passed to a 459 foreign convention subprogram. */ 460 #define DECL_BY_COMPONENT_PTR_P(NODE) DECL_LANG_FLAG_3 (PARM_DECL_CHECK (NODE)) 461 462 /* Nonzero in a FUNCTION_DECL that corresponds to an elaboration procedure. */ 463 #define DECL_ELABORATION_PROC_P(NODE) \ 464 DECL_LANG_FLAG_3 (FUNCTION_DECL_CHECK (NODE)) 465 466 /* Nonzero in a CONST_DECL, VAR_DECL or PARM_DECL if it is made for a pointer 467 that points to something which is readonly. */ 468 #define DECL_POINTS_TO_READONLY_P(NODE) DECL_LANG_FLAG_4 (NODE) 469 470 /* Nonzero in a FIELD_DECL if it is invariant once set, for example if it is 471 a discriminant of a discriminated type without default expression. */ 472 #define DECL_INVARIANT_P(NODE) DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) 473 474 /* Nonzero in a FUNCTION_DECL if this is a definition, i.e. if it was created 475 by a call to gnat_to_gnu_entity with definition set to True. */ 476 #define DECL_FUNCTION_IS_DEF(NODE) \ 477 DECL_LANG_FLAG_4 (FUNCTION_DECL_CHECK (NODE)) 478 479 /* Nonzero in a VAR_DECL if it is a temporary created to hold the return 480 value of a function call or 'reference to a function call. */ 481 #define DECL_RETURN_VALUE_P(NODE) DECL_LANG_FLAG_5 (VAR_DECL_CHECK (NODE)) 482 483 /* In a FIELD_DECL corresponding to a discriminant, contains the 484 discriminant number. */ 485 #define DECL_DISCRIMINANT_NUMBER(NODE) DECL_INITIAL (FIELD_DECL_CHECK (NODE)) 486 487 /* In a CONST_DECL, points to a VAR_DECL that is allocatable to 488 memory. Used when a scalar constant is aliased or has its 489 address taken. */ 490 #define DECL_CONST_CORRESPONDING_VAR(NODE) \ 491 GET_DECL_LANG_SPECIFIC (CONST_DECL_CHECK (NODE)) 492 #define SET_DECL_CONST_CORRESPONDING_VAR(NODE, X) \ 493 SET_DECL_LANG_SPECIFIC (CONST_DECL_CHECK (NODE), X) 494 495 /* In a FIELD_DECL, points to the FIELD_DECL that was the ultimate 496 source of the decl. */ 497 #define DECL_ORIGINAL_FIELD(NODE) \ 498 GET_DECL_LANG_SPECIFIC (FIELD_DECL_CHECK (NODE)) 499 #define SET_DECL_ORIGINAL_FIELD(NODE, X) \ 500 SET_DECL_LANG_SPECIFIC (FIELD_DECL_CHECK (NODE), X) 501 502 /* Set DECL_ORIGINAL_FIELD of FIELD1 to (that of) FIELD2. */ 503 #define SET_DECL_ORIGINAL_FIELD_TO_FIELD(FIELD1, FIELD2) \ 504 SET_DECL_ORIGINAL_FIELD ((FIELD1), \ 505 DECL_ORIGINAL_FIELD (FIELD2) \ 506 ? DECL_ORIGINAL_FIELD (FIELD2) : (FIELD2)) 507 508 /* Return true if FIELD1 and FIELD2 represent the same field. */ 509 #define SAME_FIELD_P(FIELD1, FIELD2) \ 510 ((FIELD1) == (FIELD2) \ 511 || DECL_ORIGINAL_FIELD (FIELD1) == (FIELD2) \ 512 || (FIELD1) == DECL_ORIGINAL_FIELD (FIELD2) \ 513 || (DECL_ORIGINAL_FIELD (FIELD1) \ 514 && (DECL_ORIGINAL_FIELD (FIELD1) == DECL_ORIGINAL_FIELD (FIELD2)))) 515 516 /* In a VAR_DECL with the DECL_LOOP_PARM_P flag set, points to the special 517 induction variable that is built under certain circumstances, if any. */ 518 #define DECL_INDUCTION_VAR(NODE) \ 519 GET_DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) 520 #define SET_DECL_INDUCTION_VAR(NODE, X) \ 521 SET_DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE), X) 522 523 /* In a VAR_DECL without the DECL_LOOP_PARM_P flag set and that is a renaming 524 pointer, points to the object being renamed, if any. */ 525 #define DECL_RENAMED_OBJECT(NODE) \ 526 GET_DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE)) 527 #define SET_DECL_RENAMED_OBJECT(NODE, X) \ 528 SET_DECL_LANG_SPECIFIC (VAR_DECL_CHECK (NODE), X) 529 530 /* In a TYPE_DECL, points to the parallel type if any, otherwise 0. */ 531 #define DECL_PARALLEL_TYPE(NODE) \ 532 GET_DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE)) 533 #define SET_DECL_PARALLEL_TYPE(NODE, X) \ 534 SET_DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE), X) 535 536 537 /* Flags added to ref nodes. */ 538 539 /* Nonzero means this node will not trap. */ 540 #undef TREE_THIS_NOTRAP 541 #define TREE_THIS_NOTRAP(NODE) \ 542 (TREE_CHECK4 (NODE, INDIRECT_REF, ARRAY_REF, UNCONSTRAINED_ARRAY_REF, \ 543 ARRAY_RANGE_REF)->base.nothrow_flag) 544 545 546 /* Fields and macros for statements. */ 547 #define IS_ADA_STMT(NODE) \ 548 (STATEMENT_CLASS_P (NODE) && TREE_CODE (NODE) >= STMT_STMT) 549 550 #define STMT_STMT_STMT(NODE) TREE_OPERAND_CHECK_CODE (NODE, STMT_STMT, 0) 551 552 #define LOOP_STMT_COND(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 0) 553 #define LOOP_STMT_UPDATE(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 1) 554 #define LOOP_STMT_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 2) 555 #define LOOP_STMT_LABEL(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_STMT, 3) 556 557 /* A loop statement is conceptually made up of 6 sub-statements: 558 559 loop: 560 TOP_CONDITION 561 TOP_UPDATE 562 BODY 563 BOTTOM_CONDITION 564 BOTTOM_UPDATE 565 GOTO loop 566 567 However, only 4 of them can exist for a given loop, the pair of conditions 568 and the pair of updates being mutually exclusive. The default setting is 569 TOP_CONDITION and BOTTOM_UPDATE and the following couple of flags are used 570 to toggle the individual settings. */ 571 #define LOOP_STMT_BOTTOM_COND_P(NODE) TREE_LANG_FLAG_0 (LOOP_STMT_CHECK (NODE)) 572 #define LOOP_STMT_TOP_UPDATE_P(NODE) TREE_LANG_FLAG_1 (LOOP_STMT_CHECK (NODE)) 573 574 /* Optimization hints on loops. */ 575 #define LOOP_STMT_IVDEP(NODE) TREE_LANG_FLAG_2 (LOOP_STMT_CHECK (NODE)) 576 #define LOOP_STMT_NO_UNROLL(NODE) TREE_LANG_FLAG_3 (LOOP_STMT_CHECK (NODE)) 577 #define LOOP_STMT_UNROLL(NODE) TREE_LANG_FLAG_4 (LOOP_STMT_CHECK (NODE)) 578 #define LOOP_STMT_NO_VECTOR(NODE) TREE_LANG_FLAG_5 (LOOP_STMT_CHECK (NODE)) 579 #define LOOP_STMT_VECTOR(NODE) TREE_LANG_FLAG_6 (LOOP_STMT_CHECK (NODE)) 580 581 #define EXIT_STMT_COND(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 0) 582 #define EXIT_STMT_LABEL(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_STMT, 1) 583