gcc/d/d-tree.h

   1 /* d-tree.h -- Definitions and declarations for code generation.
   2    Copyright (C) 2006-2022 Free Software Foundation, Inc.
   3
   4 GCC is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 3, or (at your option)
   7 any later version.
   8
   9 GCC is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with GCC; see the file COPYING3.  If not see
  16 <http://www.gnu.org/licenses/>.  */
  17
  18 #ifndef GCC_D_TREE_H
  19 #define GCC_D_TREE_H
  20
  21 /* Forward type declarations to avoid including unnecessary headers.  */
  22
  23 class Dsymbol;
  24 class Declaration;
  25 class AggregateDeclaration;
  26 class ClassDeclaration;
  27 class EnumDeclaration;
  28 class FuncDeclaration;
  29 class StructDeclaration;
  30 class TypeInfoDeclaration;
  31 class VarDeclaration;
  32 class Expression;
  33 class ClassReferenceExp;
  34 class IndexExp;
  35 class SliceExp;
  36 class Module;
  37 class Statement;
  38 class Type;
  39 class TypeFunction;
  40 class Parameter;
  41 struct BaseClass;
  42 struct Scope;
  43 struct Loc;
  44
  45 template <typename TYPE> struct Array;
  46 typedef Array <Expression *> Expressions;
  47
  48 /* Usage of TREE_LANG_FLAG_?:
  49    0: METHOD_CALL_EXPR
  50
  51    Usage of TYPE_LANG_FLAG_?:
  52    0: TYPE_SHARED
  53    1: TYPE_IMAGINARY_FLOAT (in REAL_TYPE).
  54       ANON_AGGR_TYPE_P (in RECORD_TYPE, UNION_TYPE).
  55    2: CLASS_TYPE_P (in RECORD_TYPE).
  56    3: TYPE_DYNAMIC_ARRAY (in RECORD_TYPE).
  57    4: TYPE_DELEGATE (in RECORD_TYPE).
  58    5: TYPE_ASSOCIATIVE_ARRAY (in RECORD_TYPE).
  59
  60    Usage of TYPE_LANG_SLOT_?:
  61    1: TYPE_FORWARD_REFERENCES (in RECORD_TYPE, UNION_TYPE).
  62
  63    Usage of DECL_LANG_FLAG_?:
  64    0: LABEL_VARIABLE_CASE (in LABEL_DECL).
  65       DECL_BUILT_IN_CTFE (in FUNCTION_DECL).
  66    1: DECL_IN_UNITTEST_CONDITION_P (in FUNCTION_DECL).
  67    2: DECL_INSTANTIATED (in FUNCTION_DECL, VAR_DECL).  */
  68
  69 /* Language-specific tree checkers.  */
  70
  71 #define VAR_OR_FUNCTION_DECL_CHECK(NODE) \
  72   TREE_CHECK2 (NODE, VAR_DECL, FUNCTION_DECL)
  73
  74 #define AGGREGATE_OR_ENUM_TYPE_CHECK(NODE) \
  75   TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, \
  76                QUAL_UNION_TYPE, ENUMERAL_TYPE)
  77
  78 /* The kinds of scopes we recognize.  */
  79
  80 enum level_kind
  81 {
  82   level_block,          /* An ordinary block scope.  */
  83   level_try,            /* A try-block.  */
  84   level_catch,          /* A catch-block.  */
  85   level_finally,        /* A finally-block.  */
  86   level_cond,           /* The scope for an if condition.  */
  87   level_switch,         /* The scope for a switch statement.  */
  88   level_loop,           /* A for, do-while, or unrolled-loop block.  */
  89   level_with,           /* The scope for a with statement.  */
  90   level_function        /* The block representing an entire function.  */
  91 };
  92
  93 /* List of codes for internally recognised compiler intrinsics.  */
  94
  95 enum intrinsic_code
  96 {
  97 #define DEF_D_INTRINSIC(CODE, B, N, M, D, C) CODE,
  98
  99 #include "intrinsics.def"
 100
 101 #undef DEF_D_INTRINSIC
 102   INTRINSIC_LAST
 103 };
 104
 105 /* For use with break and continue statements.  */
 106
 107 enum bc_kind
 108 {
 109   bc_break    = 0,
 110   bc_continue = 1
 111 };
 112
 113 /* The datatype used to implement D scope.  It is needed primarily to support
 114    the back-end, but also helps debugging information for local variables.  */
 115
 116 struct GTY((chain_next ("%h.level_chain"))) binding_level
 117 {
 118   /* A chain of declarations for all variables, constants and functions.
 119      These are in the reverse of the order supplied.  */
 120   tree names;
 121
 122   /* For each level (except the global one), a chain of BLOCK nodes for
 123      all the levels that were entered and exited one level down.  */
 124   tree blocks;
 125
 126   /* The binding level this one is contained in.  */
 127   binding_level *level_chain;
 128
 129   /* The kind of scope this object represents.  */
 130   ENUM_BITFIELD (level_kind) kind : 4;
 131 };
 132
 133 /* The binding level currently in effect.  */
 134 extern GTY(()) binding_level *current_binding_level;
 135 extern GTY(()) binding_level *global_binding_level;
 136
 137 /* Used only for jumps to as-yet undefined labels, since jumps to
 138    defined labels can have their validity checked immediately.  */
 139
 140 struct GTY((chain_next ("%h.next"))) d_label_use_entry
 141 {
 142   d_label_use_entry *next;
 143
 144   /* The frontend Statement associated with the jump.  */
 145   Statement * GTY((skip)) statement;
 146
 147   /* The binding level to which this entry is *currently* attached.
 148      This is initially the binding level in which the goto appeared,
 149      but is modified as scopes are closed.  */
 150   binding_level *level;
 151 };
 152
 153 /* A list of all LABEL_DECLs in the function that have names.  Here so
 154    we can clear out their names' definitions at the end of the
 155    function, and so we can check the validity of jumps to these labels.  */
 156
 157 struct GTY(()) d_label_entry
 158 {
 159   /* The label decl itself.  */
 160   tree label;
 161
 162   /* The frontend Statement associated with the label.  */
 163   Statement * GTY((skip)) statement;
 164
 165   /* The binding level to which the label is *currently* attached.
 166      This is initially set to the binding level in which the label
 167      is defined, but is modified as scopes are closed.  */
 168   binding_level *level;
 169
 170   /* A list of forward references of the label.  */
 171   d_label_use_entry *fwdrefs;
 172
 173   /* The following bits are set after the label is defined, and are
 174      updated as scopes are popped.  They indicate that a backward jump
 175      to the label will illegally enter a scope of the given flavor.  */
 176   bool in_try_scope;
 177   bool in_catch_scope;
 178
 179   /* If set, the label we reference represents a break/continue pair.  */
 180   bool bc_label;
 181 };
 182
 183 /* Frame information for a function declaration.  */
 184
 185 struct GTY(()) tree_frame_info
 186 {
 187   struct tree_common common;
 188   tree frame_type;
 189 };
 190
 191 /* True if the function creates a nested frame.  */
 192 #define FRAMEINFO_CREATES_FRAME(NODE) \
 193   (TREE_LANG_FLAG_0 (FUNCFRAME_INFO_CHECK (NODE)))
 194
 195 /* True if the function has a static chain passed in its DECL_ARGUMENTS.  */
 196 #define FRAMEINFO_STATIC_CHAIN(NODE) \
 197   (TREE_LANG_FLAG_1 (FUNCFRAME_INFO_CHECK (NODE)))
 198
 199 /* True if the function frame is a closure (initialized on the heap).  */
 200 #define FRAMEINFO_IS_CLOSURE(NODE) \
 201   (TREE_LANG_FLAG_2 (FUNCFRAME_INFO_CHECK (NODE)))
 202
 203 #define FRAMEINFO_TYPE(NODE) \
 204   (((tree_frame_info *) FUNCFRAME_INFO_CHECK (NODE))->frame_type)
 205
 206 /* Language-dependent contents of an identifier.  */
 207
 208 struct GTY(()) lang_identifier
 209 {
 210   struct tree_identifier common;
 211
 212   /* The identifier as the user sees it.  */
 213   tree pretty_ident;
 214
 215   /* The back-end tree associated with this identifier.  */
 216   tree decl_tree;
 217
 218   /* The frontend Declaration associated with this identifier.  */
 219   Declaration * GTY((skip)) dsymbol;
 220   AggregateDeclaration * GTY((skip)) daggregate;
 221 };
 222
 223 #define IDENTIFIER_LANG_SPECIFIC(NODE) \
 224   ((struct lang_identifier *) IDENTIFIER_NODE_CHECK (NODE))
 225
 226 #define IDENTIFIER_PRETTY_NAME(NODE) \
 227   (IDENTIFIER_LANG_SPECIFIC (NODE)->pretty_ident)
 228
 229 #define IDENTIFIER_DECL_TREE(NODE) \
 230   (IDENTIFIER_LANG_SPECIFIC (NODE)->decl_tree)
 231
 232 #define IDENTIFIER_DSYMBOL(NODE) \
 233   (IDENTIFIER_LANG_SPECIFIC (NODE)->dsymbol)
 234
 235 #define IDENTIFIER_DAGGREGATE(NODE) \
 236   (IDENTIFIER_LANG_SPECIFIC (NODE)->daggregate)
 237
 238 /* Global state pertinent to the current function.  */
 239
 240 struct GTY(()) language_function
 241 {
 242   /* Our function and enclosing module.  */
 243   FuncDeclaration * GTY((skip)) function;
 244   Module * GTY((skip)) module;
 245
 246   /* Static chain of function, for D2, this is a closure.  */
 247   tree static_chain;
 248
 249   /* Stack of statement lists being collected while we are
 250      compiling the function.  */
 251   vec <tree, va_gc> *stmt_list;
 252
 253   /* Variables that are in scope that will need destruction later.  */
 254   vec <tree, va_gc> *vars_in_scope;
 255
 256   /* Table of all used or defined labels in the function.  */
 257   hash_map <Statement *, d_label_entry> *labels;
 258 };
 259
 260 /* The D front end types have not been integrated into the GCC garbage
 261    collection system.  Handle this by using the "skip" attribute.  */
 262
 263 struct GTY(()) lang_decl
 264 {
 265   Declaration * GTY((skip)) decl;
 266
 267   /* FIELD_DECL in frame struct that this variable is allocated in.  */
 268   tree frame_field;
 269
 270   /* RESULT_DECL in a function that returns by nrvo.  */
 271   tree named_result;
 272
 273   /* Chain of DECL_LANG_THUNKS in a function.  */
 274   tree thunks;
 275
 276   /* In a FUNCTION_DECL, this is the THUNK_LANG_OFFSET.  */
 277   int offset;
 278
 279   /* In a FUNCTION_DECL, if this is an intrinsic, the code for it.  */
 280   enum intrinsic_code intrinsic;
 281
 282   /* FUNCFRAME_INFO in a function that has non-local references.  */
 283   tree frame_info;
 284 };
 285
 286 /* The current D per-function global variables.  */
 287
 288 #define d_function_chain (cfun ? cfun->language : NULL)
 289
 290 /* The D frontend Declaration AST for GCC decl NODE.  */
 291 #define DECL_LANG_FRONTEND(NODE) \
 292   (DECL_LANG_SPECIFIC (NODE) \
 293    ? DECL_LANG_SPECIFIC (NODE)->decl : NULL)
 294
 295 #define SET_DECL_LANG_FRAME_FIELD(NODE, VAL) \
 296   DECL_LANG_SPECIFIC (NODE)->frame_field = VAL
 297
 298 #define DECL_LANG_FRAME_FIELD(NODE) \
 299   (DECL_P (NODE) \
 300    ? DECL_LANG_SPECIFIC (NODE)->frame_field : NULL)
 301
 302 #define SET_DECL_LANG_NRVO(NODE, VAL) \
 303   DECL_LANG_SPECIFIC (NODE)->named_result = VAL
 304
 305 #define DECL_LANG_NRVO(NODE) \
 306   (DECL_P (NODE) \
 307    ? DECL_LANG_SPECIFIC (NODE)->named_result : NULL)
 308
 309 #define DECL_LANG_THUNKS(NODE) \
 310   DECL_LANG_SPECIFIC (NODE)->thunks
 311
 312 #define THUNK_LANG_OFFSET(NODE) \
 313   DECL_LANG_SPECIFIC (NODE)->offset
 314
 315 #define DECL_INTRINSIC_CODE(NODE) \
 316   DECL_LANG_SPECIFIC (NODE)->intrinsic
 317
 318 #define DECL_LANG_FRAMEINFO(NODE) \
 319   DECL_LANG_SPECIFIC (NODE)->frame_info
 320
 321 /* The lang_type field is not set for every GCC type.  */
 322
 323 struct GTY(()) lang_type
 324 {
 325   Type * GTY((skip)) type;
 326 };
 327
 328 /* The D frontend Type AST for GCC type NODE.  */
 329 #define TYPE_LANG_FRONTEND(NODE) \
 330   (TYPE_LANG_SPECIFIC (NODE) \
 331    ? TYPE_LANG_SPECIFIC (NODE)->type : NULL)
 332
 333
 334 enum d_tree_node_structure_enum
 335 {
 336   TS_D_GENERIC,
 337   TS_D_IDENTIFIER,
 338   TS_D_FRAMEINFO,
 339   LAST_TS_D_ENUM
 340 };
 341
 342 /* The resulting tree type.  */
 343
 344 union GTY((desc ("d_tree_node_structure (&%h)"),
 345            chain_next ("CODE_CONTAINS_STRUCT (TREE_CODE (&%h.generic), TS_COMMON)"
 346                        " ? ((union lang_tree_node *) TREE_CHAIN (&%h.generic)) : NULL")))
 347 lang_tree_node
 348 {
 349   union tree_node GTY ((tag ("TS_D_GENERIC"),
 350                         desc ("tree_node_structure (&%h)"))) generic;
 351   lang_identifier GTY ((tag ("TS_D_IDENTIFIER"))) identifier;
 352   tree_frame_info GTY ((tag ("TS_D_FRAMEINFO"))) frameinfo;
 353 };
 354
 355 /* True if the Tdelegate typed expression is not really a variable,
 356    but a literal function / method reference.  */
 357 #define METHOD_CALL_EXPR(NODE) \
 358   (TREE_LANG_FLAG_0 (NODE))
 359
 360 /* True if the type was declared 'shared'.  */
 361 #define TYPE_SHARED(NODE) \
 362   (TYPE_LANG_FLAG_0 (NODE))
 363
 364 /* True if the type is an imaginary float type.  */
 365 #define TYPE_IMAGINARY_FLOAT(NODE) \
 366   (TYPE_LANG_FLAG_1 (REAL_TYPE_CHECK (NODE)))
 367
 368 /* True if the type is an anonymous record or union.  */
 369 #define ANON_AGGR_TYPE_P(NODE) \
 370   (TYPE_LANG_FLAG_1 (RECORD_OR_UNION_CHECK (NODE)))
 371
 372 /* True if the type is the underlying record for a class.  */
 373 #define CLASS_TYPE_P(NODE) \
 374   (TYPE_LANG_FLAG_2 (RECORD_TYPE_CHECK (NODE)))
 375
 376 /* True if the type is a D dynamic array.  */
 377 #define TYPE_DYNAMIC_ARRAY(NODE) \
 378   (TYPE_LANG_FLAG_3 (RECORD_TYPE_CHECK (NODE)))
 379
 380 /* True if the type is a D delegate.  */
 381 #define TYPE_DELEGATE(NODE) \
 382   (TYPE_LANG_FLAG_4 (RECORD_TYPE_CHECK (NODE)))
 383
 384 /* True if the type is a D associative array.  */
 385 #define TYPE_ASSOCIATIVE_ARRAY(NODE) \
 386   (TYPE_LANG_FLAG_5 (RECORD_TYPE_CHECK (NODE)))
 387
 388 /* In an incomplete RECORD_TYPE, UNION_TYPE, or ENUMERAL_TYPE, a list of field
 389    declarations whose type would be completed by completing that type.  */
 390 #define TYPE_FORWARD_REFERENCES(NODE) \
 391   (TYPE_LANG_SLOT_1 (AGGREGATE_OR_ENUM_TYPE_CHECK (NODE)))
 392
 393 /* True if the decl is a variable case label decl.  */
 394 #define LABEL_VARIABLE_CASE(NODE) \
 395   (DECL_LANG_FLAG_0 (LABEL_DECL_CHECK (NODE)))
 396
 397 /* True if the decl is a CTFE built-in.  */
 398 #define DECL_BUILT_IN_CTFE(NODE) \
 399   (DECL_LANG_FLAG_0 (FUNCTION_DECL_CHECK (NODE)))
 400
 401 /* True if the decl is only compiled in when unittests are turned on.  */
 402 #define DECL_IN_UNITTEST_CONDITION_P(NODE) \
 403   (DECL_LANG_FLAG_1 (FUNCTION_DECL_CHECK (NODE)))
 404
 405 /* True if the decl comes from a template instance.  */
 406 #define DECL_INSTANTIATED(NODE) \
 407   (DECL_LANG_FLAG_2 (VAR_OR_FUNCTION_DECL_CHECK (NODE)))
 408
 409 enum d_tree_index
 410 {
 411   DTI_VTABLE_ENTRY_TYPE,
 412   DTI_VTBL_PTR_TYPE,
 413   DTI_VTBL_INTERFACE_TYPE,
 414
 415   DTI_BOOL_TYPE,
 416   DTI_CHAR_TYPE,
 417   DTI_WCHAR_TYPE,
 418   DTI_DCHAR_TYPE,
 419
 420   DTI_BYTE_TYPE,
 421   DTI_UBYTE_TYPE,
 422   DTI_SHORT_TYPE,
 423   DTI_USHORT_TYPE,
 424   DTI_INT_TYPE,
 425   DTI_UINT_TYPE,
 426   DTI_LONG_TYPE,
 427   DTI_ULONG_TYPE,
 428   DTI_CENT_TYPE,
 429   DTI_UCENT_TYPE,
 430
 431   DTI_IFLOAT_TYPE,
 432   DTI_IDOUBLE_TYPE,
 433   DTI_IREAL_TYPE,
 434
 435   DTI_UNKNOWN_TYPE,
 436
 437   DTI_ARRAY_TYPE,
 438   DTI_NULL_ARRAY,
 439   DTI_BOTTOM_TYPE,
 440
 441   DTI_MAX
 442 };
 443
 444 extern GTY(()) tree d_global_trees[DTI_MAX];
 445
 446 #define vtable_entry_type               d_global_trees[DTI_VTABLE_ENTRY_TYPE]
 447 #define vtbl_ptr_type_node              d_global_trees[DTI_VTBL_PTR_TYPE]
 448 #define vtbl_interface_type_node        d_global_trees[DTI_VTBL_INTERFACE_TYPE]
 449 /* D built-in language types.  */
 450 #define d_bool_type                     d_global_trees[DTI_BOOL_TYPE]
 451 #define d_byte_type                     d_global_trees[DTI_BYTE_TYPE]
 452 #define d_ubyte_type                    d_global_trees[DTI_UBYTE_TYPE]
 453 #define d_short_type                    d_global_trees[DTI_SHORT_TYPE]
 454 #define d_ushort_type                   d_global_trees[DTI_USHORT_TYPE]
 455 #define d_int_type                      d_global_trees[DTI_INT_TYPE]
 456 #define d_uint_type                     d_global_trees[DTI_UINT_TYPE]
 457 #define d_long_type                     d_global_trees[DTI_LONG_TYPE]
 458 #define d_ulong_type                    d_global_trees[DTI_ULONG_TYPE]
 459 #define d_cent_type                     d_global_trees[DTI_CENT_TYPE]
 460 #define d_ucent_type                    d_global_trees[DTI_UCENT_TYPE]
 461 /* Imaginary floating-point types.  */
 462 #define ifloat_type_node                d_global_trees[DTI_IFLOAT_TYPE]
 463 #define idouble_type_node               d_global_trees[DTI_IDOUBLE_TYPE]
 464 #define ireal_type_node                 d_global_trees[DTI_IREAL_TYPE]
 465 /* UTF-8, 16 and 32 types.  */
 466 #define char8_type_node                 d_global_trees[DTI_CHAR_TYPE]
 467 #define char16_type_node                d_global_trees[DTI_DCHAR_TYPE]
 468 #define char32_type_node                d_global_trees[DTI_WCHAR_TYPE]
 469 /* Empty record type used as placeholder when real type is unknown.  */
 470 #define unknown_type_node               d_global_trees[DTI_UNKNOWN_TYPE]
 471 /* Generic dynamic array type void[].  */
 472 #define array_type_node                 d_global_trees[DTI_ARRAY_TYPE]
 473 /* Null initializer for dynamic arrays.  */
 474 #define null_array_node                 d_global_trees[DTI_NULL_ARRAY]
 475 /* The bottom type, referred to as `noreturn` in code.  */
 476 #define noreturn_type_node              d_global_trees[DTI_BOTTOM_TYPE]
 477
 478 /* A prefix for internal variables, which are not user-visible.  */
 479 #if !defined (NO_DOT_IN_LABEL)
 480 # define GDC_PREFIX(x) "gdc." x
 481 #elif !defined (NO_DOLLAR_IN_LABEL)
 482 # define GDC_PREFIX(x) "gdc$" x
 483 #else
 484 # define GDC_PREFIX(x) "gdc_" x
 485 #endif
 486
 487 /* Internally recognised D runtime library functions.  */
 488
 489 enum libcall_fn
 490 {
 491 #define DEF_D_RUNTIME(CODE, N, T, P, F) LIBCALL_ ## CODE,
 492
 493 #include "runtime.def"
 494
 495 #undef DEF_D_RUNTIME
 496   LIBCALL_LAST
 497 };
 498
 499 /* Gate for when the D frontend makes an early call into the codegen pass, such
 500    as when it requires target information or CTFE evaluation.  As full semantic
 501    may not be completed, we only want to build the superficial tree structure
 502    without finishing any decls or types.  */
 503 extern bool doing_semantic_analysis_p;
 504
 505 /* In d-attribs.c.  */
 506 extern tree insert_type_attribute (tree, const char *, tree = NULL_TREE);
 507 extern tree insert_decl_attribute (tree, const char *, tree = NULL_TREE);
 508 extern void apply_user_attributes (Dsymbol *, tree);
 509
 510 /* In d-builtins.cc.  */
 511 extern const attribute_spec d_langhook_attribute_table[];
 512 extern const attribute_spec d_langhook_common_attribute_table[];
 513 extern Type *build_frontend_type (tree);
 514
 515 extern tree d_builtin_function (tree);
 516 extern tree d_builtin_function_ext_scope (tree);
 517 extern void d_init_builtins (void);
 518 extern void d_register_builtin_type (tree, const char *);
 519 extern void d_build_builtins_module (Module *);
 520 extern void d_maybe_set_builtin (Module *);
 521 extern Expression *d_eval_constant_expression (const Loc &, tree);
 522 extern void d_init_versions (void);
 523
 524 /* In d-codegen.cc.  */
 525 extern location_t make_location_t (const Loc &);
 526 extern tree d_decl_context (Dsymbol *);
 527 extern tree copy_aggregate_type (tree);
 528 extern bool declaration_reference_p (Declaration *);
 529 extern tree declaration_type (Declaration *);
 530 extern bool parameter_reference_p (Parameter *);
 531 extern tree parameter_type (Parameter *);
 532 extern tree build_integer_cst (dinteger_t, tree = d_int_type);
 533 extern tree build_float_cst (const real_t &, Type *);
 534 extern tree d_array_length (tree);
 535 extern tree d_array_ptr (tree);
 536 extern tree d_array_value (tree, tree, tree);
 537 extern tree get_array_length (tree, Type *);
 538 extern tree build_class_binfo (tree, ClassDeclaration *);
 539 extern tree build_interface_binfo (tree, ClassDeclaration *, unsigned &);
 540 extern tree delegate_method (tree);
 541 extern tree delegate_object (tree);
 542 extern tree build_delegate_cst (tree, tree, Type *);
 543 extern tree build_method_call (tree, tree, Type *);
 544 extern void extract_from_method_call (tree, tree &, tree &);
 545 extern tree build_typeof_null_value (Type *);
 546 extern tree build_vindex_ref (tree, tree, size_t);
 547 extern tree d_save_expr (tree);
 548 extern tree stabilize_expr (tree *);
 549 extern tree build_target_expr (tree, tree);
 550 extern tree force_target_expr (tree);
 551 extern tree build_address (tree);
 552 extern tree d_mark_addressable (tree);
 553 extern tree d_mark_used (tree);
 554 extern tree d_mark_read (tree);
 555 extern tree build_memcmp_call (tree, tree, tree);
 556 extern tree build_memcpy_call (tree, tree, tree);
 557 extern tree build_memset_call (tree, tree = NULL_TREE);
 558 extern bool identity_compare_p (StructDeclaration *);
 559 extern tree build_float_identity (tree_code, tree, tree);
 560 extern tree build_struct_comparison (tree_code, StructDeclaration *,
 561                                      tree, tree);
 562 extern tree build_array_struct_comparison (tree_code, StructDeclaration *,
 563                                            tree, tree, tree);
 564 extern tree build_struct_literal (tree, vec <constructor_elt, va_gc> *);
 565 extern tree component_ref (tree, tree);
 566 extern tree build_assign (tree_code, tree, tree);
 567 extern tree modify_expr (tree, tree);
 568 extern tree build_nop (tree, tree);
 569 extern tree build_vconvert (tree, tree);
 570 extern tree build_boolop (tree_code, tree, tree);
 571 extern tree build_condition (tree, tree, tree, tree);
 572 extern tree build_vcondition (tree, tree, tree);
 573 extern tree compound_expr (tree, tree);
 574 extern tree return_expr (tree);
 575 extern tree size_mult_expr (tree, tree);
 576 extern tree real_part (tree);
 577 extern tree imaginary_part (tree);
 578 extern tree complex_expr (tree, tree, tree);
 579 extern tree indirect_ref (tree, tree);
 580 extern tree build_deref (tree);
 581 extern tree build_array_index (tree, tree);
 582 extern tree build_offset_op (tree_code, tree, tree);
 583 extern tree build_offset (tree, tree);
 584 extern tree build_memref (tree, tree, tree);
 585 extern tree build_array_set (tree, tree, tree);
 586 extern tree build_array_from_val (Type *, tree);
 587 extern tree build_array_from_exprs (Type *, Expressions *, bool);
 588 extern tree void_okay_p (tree);
 589 extern tree build_assert_call (const Loc &, libcall_fn, tree = NULL_TREE);
 590 extern tree build_array_bounds_call (const Loc &);
 591 extern tree build_bounds_index_condition (IndexExp *, tree, tree);
 592 extern tree build_bounds_slice_condition (SliceExp *, tree, tree, tree);
 593 extern bool array_bounds_check (void);
 594 extern bool checkaction_trap_p (void);
 595 extern TypeFunction *get_function_type (Type *);
 596 extern bool call_by_alias_p (FuncDeclaration *, FuncDeclaration *);
 597 extern tree d_build_call_expr (FuncDeclaration *, tree, Expressions *);
 598 extern tree d_build_call (TypeFunction *, tree, tree, Expressions *);
 599 extern tree build_float_modulus (tree, tree, tree);
 600 extern tree build_vthis_function (tree, tree);
 601 extern tree error_no_frame_access (Dsymbol *);
 602 extern tree get_frame_for_symbol (Dsymbol *);
 603 extern tree build_vthis (AggregateDeclaration *);
 604 extern void build_closure (FuncDeclaration *);
 605 extern tree get_frameinfo (FuncDeclaration *);
 606 extern tree get_framedecl (FuncDeclaration *, FuncDeclaration *);
 607
 608 /* In d-convert.cc.  */
 609 extern bool decl_with_nonnull_addr_p (const_tree);
 610 extern tree d_truthvalue_conversion (tree);
 611 extern tree d_convert (tree, tree);
 612 extern tree convert_expr (tree, Type *, Type *);
 613 extern tree convert_for_rvalue (tree, Type *, Type *);
 614 extern tree convert_for_assignment (tree, Type *, Type *);
 615 extern tree convert_for_argument (tree, Parameter *);
 616 extern tree convert_for_condition (tree, Type *);
 617 extern tree d_array_convert (Expression *);
 618 extern tree d_array_convert (Type *, Expression *);
 619
 620 /* In d-gimplify.cc.  */
 621 extern int d_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
 622
 623 /* In d-incpath.cc.  */
 624 extern void add_import_paths (const char *, const char *, bool);
 625
 626 /* In d-lang.cc.  */
 627 extern void d_add_builtin_module (Module *);
 628 extern d_tree_node_structure_enum d_tree_node_structure (lang_tree_node *);
 629 extern struct lang_type *build_lang_type (Type *);
 630 extern struct lang_decl *build_lang_decl (Declaration *);
 631 extern tree d_pushdecl (tree);
 632 extern void d_keep (tree);
 633
 634 /* In decl.cc.  */
 635 extern const char *d_mangle_decl (Dsymbol *);
 636 extern tree mangle_internal_decl (Dsymbol *, const char *, const char *);
 637 extern void build_decl_tree (Dsymbol *);
 638 extern tree get_symbol_decl (Declaration *);
 639 extern tree declare_extern_var (tree, tree);
 640 extern void declare_local_var (VarDeclaration *);
 641 extern tree build_local_temp (tree);
 642 extern tree get_decl_tree (Declaration *);
 643 extern void d_finish_decl (tree);
 644 extern tree make_thunk (FuncDeclaration *, int);
 645 extern tree start_function (FuncDeclaration *);
 646 extern void finish_function (tree);
 647 extern tree get_vtable_decl (ClassDeclaration *);
 648 extern tree build_new_class_expr (ClassReferenceExp *);
 649 extern tree aggregate_initializer_decl (AggregateDeclaration *);
 650 extern tree layout_struct_initializer (StructDeclaration *);
 651 extern tree layout_class_initializer (ClassDeclaration *);
 652 extern tree enum_initializer_decl (EnumDeclaration *);
 653 extern tree build_artificial_decl (tree, tree, const char * = NULL);
 654 extern tree create_field_decl (tree, const char *, int, int);
 655 extern void build_type_decl (tree, Dsymbol *);
 656 extern void set_linkage_for_decl (tree);
 657 extern void set_visibility_for_decl (tree, Dsymbol *);
 658
 659 /* In expr.cc.  */
 660 extern tree build_expr (Expression *, bool = false, bool = false);
 661 extern tree build_expr_dtor (Expression *);
 662 extern tree build_return_dtor (Expression *, Type *, TypeFunction *);
 663
 664 /* In imports.cc.  */
 665 extern tree build_import_decl (Dsymbol *);
 666
 667 /* In intrinsics.cc.  */
 668 extern void maybe_set_intrinsic (FuncDeclaration *);
 669 extern tree maybe_expand_intrinsic (tree);
 670
 671 /* In modules.cc.  */
 672 extern void build_module_tree (Module *);
 673 extern tree d_module_context (void);
 674 extern void register_module_decl (Declaration *);
 675 extern void d_finish_compilation (tree *, int);
 676
 677 /* In runtime.cc.  */
 678 extern tree build_libcall (libcall_fn, Type *, int ...);
 679
 680 /* In typeinfo.cc.  */
 681 extern bool have_typeinfo_p (ClassDeclaration *);
 682 extern tree layout_typeinfo (TypeInfoDeclaration *);
 683 extern tree layout_classinfo (ClassDeclaration *);
 684 extern unsigned base_vtable_offset (ClassDeclaration *, BaseClass *);
 685 extern tree get_typeinfo_decl (TypeInfoDeclaration *);
 686 extern tree get_classinfo_decl (ClassDeclaration *);
 687 extern void check_typeinfo_type (const Loc &, Scope *, Expression * = NULL);
 688 extern tree build_typeinfo (const Loc &, Type *, Expression * = NULL);
 689 extern tree build_typeinfo (Expression *, Type *);
 690 extern void create_typeinfo (Type *, Module *);
 691 extern void create_tinfo_types (Module *);
 692 extern void layout_cpp_typeinfo (ClassDeclaration *);
 693 extern tree get_cpp_typeinfo_decl (ClassDeclaration *);
 694 extern bool speculative_type_p (Type *);
 695
 696 /* In toir.cc.  */
 697 extern void push_binding_level (level_kind);
 698 extern tree pop_binding_level (void);
 699 extern void push_stmt_list (void);
 700 extern tree pop_stmt_list (void);
 701 extern void add_stmt (tree);
 702 extern void build_function_body (FuncDeclaration *);
 703
 704 /* In types.cc.  */
 705 extern tree d_unsigned_type (tree);
 706 extern tree d_signed_type (tree);
 707 extern bool valist_array_p (Type *);
 708 extern bool empty_aggregate_p (tree);
 709 extern bool same_type_p (Type *, Type *);
 710 extern Type *get_object_type (void);
 711 extern tree make_array_type (Type *, unsigned HOST_WIDE_INT);
 712 extern tree make_struct_type (const char *, int n, ...);
 713 extern tree insert_type_modifiers (tree, unsigned);
 714 extern void insert_aggregate_field (tree, tree, size_t);
 715 extern void finish_aggregate_type (unsigned, unsigned, tree);
 716 extern tree build_ctype (Type *);
 717
 718 #endif  /* GCC_D_TREE_H  */