gcc/d/d-tree.h

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