gcc/d/d-lang.cc

   1 /* d-lang.cc -- Language-dependent hooks for D.
   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 #include "config.h"
  19 #include "system.h"
  20 #include "coretypes.h"
  21
  22 #include "dmd/aggregate.h"
  23 #include "dmd/cond.h"
  24 #include "dmd/declaration.h"
  25 #include "dmd/doc.h"
  26 #include "dmd/errors.h"
  27 #include "dmd/expression.h"
  28 #include "dmd/hdrgen.h"
  29 #include "dmd/identifier.h"
  30 #include "dmd/json.h"
  31 #include "dmd/mangle.h"
  32 #include "dmd/mars.h"
  33 #include "dmd/module.h"
  34 #include "dmd/mtype.h"
  35 #include "dmd/target.h"
  36
  37 #include "opts.h"
  38 #include "alias.h"
  39 #include "tree.h"
  40 #include "diagnostic.h"
  41 #include "fold-const.h"
  42 #include "toplev.h"
  43 #include "langhooks.h"
  44 #include "langhooks-def.h"
  45 #include "target.h"
  46 #include "function.h"
  47 #include "stringpool.h"
  48 #include "stor-layout.h"
  49 #include "varasm.h"
  50 #include "output.h"
  51 #include "print-tree.h"
  52 #include "debug.h"
  53
  54 #include "d-tree.h"
  55 #include "id.h"
  56
  57
  58 /* Array of D frontend type/decl nodes.  */
  59 tree d_global_trees[DTI_MAX];
  60
  61 /* True if compilation is currently inside the D frontend semantic passes.  */
  62 bool doing_semantic_analysis_p = false;
  63
  64 /* Options handled by the compiler that are separate from the frontend.  */
  65 struct d_option_data
  66 {
  67   const char *fonly;                /* -fonly=<arg>  */
  68   const char *multilib;             /* -imultilib <dir>  */
  69   const char *prefix;               /* -iprefix <dir>  */
  70
  71   bool deps;                        /* -M  */
  72   bool deps_skip_system;            /* -MM  */
  73   const char *deps_filename;        /* -M[M]D  */
  74   const char *deps_filename_user;   /* -MF <arg>  */
  75   vec <const char *> deps_target;   /* -M[QT] <arg> */
  76   bool deps_phony;                  /* -MP  */
  77
  78   bool stdinc;                      /* -nostdinc  */
  79 }
  80 d_option;
  81
  82 /* List of modules being compiled.  */
  83 static Modules builtin_modules;
  84
  85 /* Module where `C main' is defined, compiled in if needed.  */
  86 static Module *entrypoint_module = NULL;
  87 static Module *entrypoint_root_module = NULL;
  88
  89 /* The current and global binding level in effect.  */
  90 struct binding_level *current_binding_level;
  91 struct binding_level *global_binding_level;
  92
  93 /* The context to be used for global declarations.  */
  94 static GTY(()) tree global_context;
  95
  96 /* Array of all global declarations to pass back to the middle-end.  */
  97 static GTY(()) vec <tree, va_gc> *global_declarations;
  98
  99 /* Support for GCC-style command-line make dependency generation.
 100    Adds TARGET to the make dependencies target buffer.
 101    QUOTED is true if the string should be quoted.  */
 102
 103 static void
 104 deps_add_target (const char *target, bool quoted)
 105 {
 106   obstack buffer;
 107   gcc_obstack_init (&buffer);
 108
 109   if (!quoted)
 110     {
 111       obstack_grow0 (&buffer, target, strlen (target));
 112       d_option.deps_target.safe_push ((const char *) obstack_finish (&buffer));
 113       return;
 114     }
 115
 116   /* Quote characters in target which are significant to Make.  */
 117   unsigned slashes = 0;
 118
 119   for (const char *p = target; *p != '\0'; p++)
 120     {
 121       switch (*p)
 122         {
 123         case '\\':
 124           slashes++;
 125           break;
 126
 127         case ' ':
 128         case '\t':
 129           while (slashes--)
 130             obstack_1grow (&buffer, '\\');
 131           obstack_1grow (&buffer, '\\');
 132           goto Ldef;
 133
 134         case '$':
 135           obstack_1grow (&buffer, '$');
 136           goto Ldef;
 137
 138         case '#':
 139         case ':':
 140           obstack_1grow (&buffer, '\\');
 141           goto Ldef;
 142
 143         default:
 144         Ldef:
 145           slashes = 0;
 146           break;
 147         }
 148
 149       obstack_1grow (&buffer, *p);
 150     }
 151
 152   obstack_1grow (&buffer, '\0');
 153   d_option.deps_target.safe_push ((const char *) obstack_finish (&buffer));
 154 }
 155
 156 /* Write STR, with a leading space to BUFFER, updating COLUMN as appropriate.
 157    COLMAX is the number of columns to word-wrap at (0 means don't wrap).  */
 158
 159 static void
 160 deps_write_string (const char *str, obstack *buffer, unsigned &column,
 161                    unsigned colmax = 72)
 162 {
 163   unsigned size = strlen (str);
 164
 165   if (column != 0)
 166     {
 167       if (colmax && column + size > colmax)
 168         {
 169           obstack_grow (buffer, " \\\n ", 4);
 170           column = 1;
 171         }
 172       else
 173         {
 174           obstack_1grow (buffer, ' ');
 175           column++;
 176         }
 177     }
 178
 179   column += size;
 180   obstack_grow (buffer, str, size);
 181 }
 182
 183 /* Write out all dependencies of a given MODULE to the specified BUFFER.  */
 184
 185 static void
 186 deps_write (Module *module, obstack *buffer)
 187 {
 188   hash_set <const char *> seen_modules;
 189   vec <const char *> dependencies = vNULL;
 190
 191   Modules modlist;
 192   modlist.push (module);
 193
 194   vec <const char *> phonylist = vNULL;
 195   unsigned column = 0;
 196
 197   /* Write out make target module name.  */
 198   if (d_option.deps_target.length ())
 199     {
 200       for (unsigned i = 0; i < d_option.deps_target.length (); i++)
 201         deps_write_string (d_option.deps_target[i], buffer, column);
 202     }
 203   else
 204     deps_write_string (module->objfile->name->str, buffer, column);
 205
 206   obstack_1grow (buffer, ':');
 207   column++;
 208
 209   /* Search all modules for file dependencies.  */
 210   while (modlist.length > 0)
 211     {
 212       Module *depmod = modlist.pop ();
 213
 214       const char *modstr = depmod->srcfile->name->str;
 215
 216       /* Skip modules that have already been looked at.  */
 217       if (seen_modules.add (modstr))
 218         continue;
 219
 220       dependencies.safe_push (modstr);
 221
 222       /* Add to list of phony targets if is not being compile.  */
 223       if (d_option.deps_phony && !depmod->isRoot ())
 224         phonylist.safe_push (modstr);
 225
 226       /* Add imported files to dependency list.  */
 227       for (size_t i = 0; i < depmod->contentImportedFiles.length; i++)
 228         {
 229           const char *impstr = depmod->contentImportedFiles[i];
 230           dependencies.safe_push (impstr);
 231           phonylist.safe_push (impstr);
 232         }
 233
 234       /* Search all imports of the module.  */
 235       for (size_t i = 0; i < depmod->aimports.length; i++)
 236         {
 237           Module *m = depmod->aimports[i];
 238
 239           /* Ignore compiler-generated modules.  */
 240           if ((m->ident == Identifier::idPool ("__entrypoint")
 241                || m->ident == Identifier::idPool ("__main"))
 242               && m->parent == NULL)
 243             continue;
 244
 245           /* Don't search system installed modules, this includes
 246              object, core.*, std.*, and gcc.* packages.  */
 247           if (d_option.deps_skip_system)
 248             {
 249               if (m->ident == Identifier::idPool ("object")
 250                   && m->parent == NULL)
 251                 continue;
 252
 253               if (m->md && m->md->packages)
 254                 {
 255                   Identifier *package = (*m->md->packages)[0];
 256
 257                   if (package == Identifier::idPool ("core")
 258                       || package == Identifier::idPool ("std")
 259                       || package == Identifier::idPool ("gcc"))
 260                     continue;
 261                 }
 262             }
 263
 264           modlist.push (m);
 265         }
 266     }
 267
 268   /* Write out all make dependencies.  */
 269   for (size_t i = 0; i < dependencies.length (); i++)
 270     deps_write_string (dependencies[i], buffer, column);
 271
 272   obstack_1grow (buffer, '\n');
 273
 274   /* Write out all phony targets.  */
 275   for (size_t i = 0; i < phonylist.length (); i++)
 276     {
 277       const char *str = phonylist[i];
 278       obstack_1grow (buffer, '\n');
 279       obstack_grow (buffer, str, strlen (str));
 280       obstack_grow (buffer, ":\n", 2);
 281     }
 282
 283   obstack_1grow (buffer, '\0');
 284 }
 285
 286 /* Implements the lang_hooks.init_options routine for language D.
 287    This initializes the global state for the D frontend before calling
 288    the option handlers.  */
 289
 290 static void
 291 d_init_options (unsigned int, cl_decoded_option *decoded_options)
 292 {
 293   /* Set default values.  */
 294   global._init ();
 295
 296   global.vendor = lang_hooks.name;
 297   global.params.argv0 = xstrdup (decoded_options[0].arg);
 298   global.params.link = true;
 299   global.params.useAssert = CHECKENABLEdefault;
 300   global.params.useInvariants = CHECKENABLEdefault;
 301   global.params.useIn = CHECKENABLEdefault;
 302   global.params.useOut = CHECKENABLEdefault;
 303   global.params.useArrayBounds = CHECKENABLEdefault;
 304   global.params.useSwitchError = CHECKENABLEdefault;
 305   global.params.checkAction = CHECKACTION_D;
 306   global.params.useModuleInfo = true;
 307   global.params.useTypeInfo = true;
 308   global.params.useExceptions = true;
 309   global.params.useInline = false;
 310   global.params.obj = true;
 311   global.params.hdrStripPlainFunctions = true;
 312   global.params.betterC = false;
 313   global.params.allInst = false;
 314   global.params.errorLimit = flag_max_errors;
 315
 316   /* Default extern(C++) mangling to C++14.  */
 317   global.params.cplusplus = CppStdRevisionCpp14;
 318
 319   /* Warnings and deprecations are disabled by default.  */
 320   global.params.useDeprecated = DIAGNOSTICinform;
 321   global.params.warnings = DIAGNOSTICoff;
 322
 323   global.params.imppath = new Strings ();
 324   global.params.fileImppath = new Strings ();
 325
 326   /* Extra GDC-specific options.  */
 327   d_option.fonly = NULL;
 328   d_option.multilib = NULL;
 329   d_option.prefix = NULL;
 330   d_option.deps = false;
 331   d_option.deps_skip_system = false;
 332   d_option.deps_filename = NULL;
 333   d_option.deps_filename_user = NULL;
 334   d_option.deps_target = vNULL;
 335   d_option.deps_phony = false;
 336   d_option.stdinc = true;
 337 }
 338
 339 /* Implements the lang_hooks.init_options_struct routine for language D.
 340    Initializes the options structure OPTS.  */
 341
 342 static void
 343 d_init_options_struct (gcc_options *opts)
 344 {
 345   /* GCC options.  */
 346   opts->x_flag_exceptions = 1;
 347
 348   /* Unlike C, there is no global `errno' variable.  */
 349   opts->x_flag_errno_math = 0;
 350   opts->frontend_set_flag_errno_math = true;
 351
 352   /* D says that signed overflow is precisely defined.  */
 353   opts->x_flag_wrapv = 1;
 354 }
 355
 356 /* Implements the lang_hooks.lang_mask routine for language D.
 357    Returns language mask for option parsing.  */
 358
 359 static unsigned int
 360 d_option_lang_mask (void)
 361 {
 362   return CL_D;
 363 }
 364
 365 /* Implements the lang_hooks.init routine for language D.  */
 366
 367 static bool
 368 d_init (void)
 369 {
 370   Type::_init ();
 371   Id::initialize ();
 372   Module::_init ();
 373   Expression::_init ();
 374   Objc::_init ();
 375
 376   /* Back-end init.  */
 377   global_binding_level = ggc_cleared_alloc <binding_level> ();
 378   current_binding_level = global_binding_level;
 379
 380   /* This allows the code in d-builtins.cc to not have to worry about
 381      converting (C signed char *) to (D char *) for string arguments of
 382      built-in functions.  The parameter (signed_char = false) specifies
 383      whether char is signed.  */
 384   build_common_tree_nodes (false);
 385
 386   d_init_builtins ();
 387
 388   if (flag_exceptions)
 389     using_eh_for_cleanups ();
 390
 391   if (!supports_one_only ())
 392     flag_weak_templates = 0;
 393
 394   /* This is the C main, not the D main.  */
 395   main_identifier_node = get_identifier ("main");
 396
 397   target._init (global.params);
 398   d_init_versions ();
 399
 400   /* Insert all library-configured identifiers and import paths.  */
 401   add_import_paths (d_option.prefix, d_option.multilib, d_option.stdinc);
 402
 403   return 1;
 404 }
 405
 406 /* Implements the lang_hooks.init_ts routine for language D.  */
 407
 408 static void
 409 d_init_ts (void)
 410 {
 411   MARK_TS_TYPED (FLOAT_MOD_EXPR);
 412   MARK_TS_TYPED (UNSIGNED_RSHIFT_EXPR);
 413 }
 414
 415 /* Implements the lang_hooks.handle_option routine for language D.
 416    Handles D specific options.  Return false if we didn't do anything.  */
 417
 418 static bool
 419 d_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
 420                  int kind ATTRIBUTE_UNUSED,
 421                  location_t loc ATTRIBUTE_UNUSED,
 422                  const cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 423 {
 424   opt_code code = (opt_code) scode;
 425   bool result = true;
 426
 427   switch (code)
 428     {
 429     case OPT_fall_instantiations:
 430       global.params.allInst = value;
 431       break;
 432
 433     case OPT_fassert:
 434       global.params.useAssert = value ? CHECKENABLEon : CHECKENABLEoff;
 435       break;
 436
 437     case OPT_fbounds_check:
 438       global.params.useArrayBounds = value ? CHECKENABLEon : CHECKENABLEoff;
 439       break;
 440
 441     case OPT_fbounds_check_:
 442       global.params.useArrayBounds = (value == 2) ? CHECKENABLEon
 443         : (value == 1) ? CHECKENABLEsafeonly : CHECKENABLEoff;
 444       break;
 445
 446     case OPT_fdebug:
 447       global.params.debuglevel = value ? 1 : 0;
 448       break;
 449
 450     case OPT_fdebug_:
 451       if (ISDIGIT (arg[0]))
 452         {
 453           int level = integral_argument (arg);
 454           if (level != -1)
 455             {
 456               global.params.debuglevel = level;
 457               break;
 458             }
 459         }
 460
 461       if (Identifier::isValidIdentifier (CONST_CAST (char *, arg)))
 462         {
 463           if (!global.params.debugids)
 464             global.params.debugids = new Strings ();
 465           global.params.debugids->push (arg);
 466           break;
 467         }
 468
 469       error ("bad argument for %<-fdebug%>: %qs", arg);
 470       break;
 471
 472     case OPT_fdoc:
 473       global.params.doDocComments = value;
 474       break;
 475
 476     case OPT_fdoc_dir_:
 477       global.params.doDocComments = true;
 478       global.params.docdir = arg;
 479       break;
 480
 481     case OPT_fdoc_file_:
 482       global.params.doDocComments = true;
 483       global.params.docname = arg;
 484       break;
 485
 486     case OPT_fdoc_inc_:
 487       global.params.ddocfiles.push (arg);
 488       break;
 489
 490     case OPT_fdruntime:
 491       global.params.betterC = !value;
 492       break;
 493
 494     case OPT_fdump_d_original:
 495       global.params.vcg_ast = value;
 496       break;
 497
 498     case OPT_fexceptions:
 499       global.params.useExceptions = value;
 500       break;
 501
 502     case OPT_fignore_unknown_pragmas:
 503       global.params.ignoreUnsupportedPragmas = value;
 504       break;
 505
 506     case OPT_finvariants:
 507       global.params.useInvariants = value ? CHECKENABLEon : CHECKENABLEoff;
 508       break;
 509
 510     case OPT_fmain:
 511       global.params.addMain = value;
 512       break;
 513
 514     case OPT_fmodule_file_:
 515       global.params.modFileAliasStrings.push (arg);
 516       if (!strchr (arg, '='))
 517         error ("bad argument for %<-fmodule-file%>: %qs", arg);
 518       break;
 519
 520     case OPT_fmoduleinfo:
 521       global.params.useModuleInfo = value;
 522       break;
 523
 524     case OPT_fonly_:
 525       d_option.fonly = arg;
 526       break;
 527
 528     case OPT_fpostconditions:
 529       global.params.useOut = value ? CHECKENABLEon : CHECKENABLEoff;
 530       break;
 531
 532     case OPT_fpreconditions:
 533       global.params.useIn = value ? CHECKENABLEon : CHECKENABLEoff;
 534       break;
 535
 536     case OPT_frelease:
 537       global.params.release = value;
 538       break;
 539
 540     case OPT_frtti:
 541       global.params.useTypeInfo = value;
 542       break;
 543
 544     case OPT_fswitch_errors:
 545       global.params.useSwitchError = value ? CHECKENABLEon : CHECKENABLEoff;
 546       break;
 547
 548     case OPT_ftransition_all:
 549       global.params.vtls = value;
 550       global.params.vfield = value;
 551       global.params.vcomplex = value;
 552       break;
 553
 554     case OPT_ftransition_complex:
 555       global.params.vcomplex = value;
 556       break;
 557
 558     case OPT_ftransition_dip1000:
 559       global.params.vsafe = value;
 560       global.params.useDIP25 = value;
 561       break;
 562
 563     case OPT_ftransition_dip25:
 564       global.params.useDIP25 = value;
 565       break;
 566
 567     case OPT_ftransition_field:
 568       global.params.vfield = value;
 569       break;
 570
 571     case OPT_ftransition_nogc:
 572       global.params.vgc = value;
 573       break;
 574
 575     case OPT_ftransition_tls:
 576       global.params.vtls = value;
 577       break;
 578
 579     case OPT_funittest:
 580       global.params.useUnitTests = value;
 581       break;
 582
 583     case OPT_fversion_:
 584       if (ISDIGIT (arg[0]))
 585         {
 586           int level = integral_argument (arg);
 587           if (level != -1)
 588             {
 589               global.params.versionlevel = level;
 590               break;
 591             }
 592         }
 593
 594       if (Identifier::isValidIdentifier (CONST_CAST (char *, arg)))
 595         {
 596           if (!global.params.versionids)
 597             global.params.versionids = new Strings ();
 598           global.params.versionids->push (arg);
 599           break;
 600         }
 601
 602       error ("bad argument for %<-fversion%>: %qs", arg);
 603       break;
 604
 605     case OPT_H:
 606       global.params.doHdrGeneration = true;
 607       break;
 608
 609     case OPT_Hd:
 610       global.params.doHdrGeneration = true;
 611       global.params.hdrdir = arg;
 612       break;
 613
 614     case OPT_Hf:
 615       global.params.doHdrGeneration = true;
 616       global.params.hdrname = arg;
 617       break;
 618
 619     case OPT_imultilib:
 620       d_option.multilib = arg;
 621       break;
 622
 623     case OPT_iprefix:
 624       d_option.prefix = arg;
 625       break;
 626
 627     case OPT_I:
 628       global.params.imppath->push (arg);
 629       break;
 630
 631     case OPT_J:
 632       global.params.fileImppath->push (arg);
 633       break;
 634
 635     case OPT_MM:
 636       d_option.deps_skip_system = true;
 637       /* Fall through.  */
 638
 639     case OPT_M:
 640       d_option.deps = true;
 641       break;
 642
 643     case OPT_MMD:
 644       d_option.deps_skip_system = true;
 645       /* Fall through.  */
 646
 647     case OPT_MD:
 648       d_option.deps = true;
 649       d_option.deps_filename = arg;
 650       break;
 651
 652     case OPT_MF:
 653       /* If specified multiple times, last one wins.  */
 654       d_option.deps_filename_user = arg;
 655       break;
 656
 657     case OPT_MP:
 658       d_option.deps_phony = true;
 659       break;
 660
 661     case OPT_MQ:
 662       deps_add_target (arg, true);
 663       break;
 664
 665     case OPT_MT:
 666       deps_add_target (arg, false);
 667       break;
 668
 669     case OPT_nostdinc:
 670       d_option.stdinc = false;
 671       break;
 672
 673     case OPT_v:
 674       global.params.verbose = value;
 675       break;
 676
 677     case OPT_Wall:
 678       if (value)
 679         global.params.warnings = DIAGNOSTICinform;
 680       break;
 681
 682     case OPT_Wdeprecated:
 683       global.params.useDeprecated = value ? DIAGNOSTICinform : DIAGNOSTICoff;
 684       break;
 685
 686     case OPT_Werror:
 687       if (value)
 688         global.params.warnings = DIAGNOSTICerror;
 689       break;
 690
 691     case OPT_Wspeculative:
 692       if (value)
 693         global.params.showGaggedErrors = 1;
 694       break;
 695
 696     case OPT_Xf:
 697       global.params.jsonfilename = arg;
 698       /* Fall through.  */
 699
 700     case OPT_X:
 701       global.params.doJsonGeneration = true;
 702       break;
 703
 704     default:
 705       break;
 706     }
 707
 708   D_handle_option_auto (&global_options, &global_options_set,
 709                         scode, arg, value,
 710                         d_option_lang_mask (), kind,
 711                         loc, handlers, global_dc);
 712
 713   return result;
 714 }
 715
 716 /* Implements the lang_hooks.post_options routine for language D.
 717    Deal with any options that imply the turning on/off of features.
 718    FN is the main input filename passed on the command line.  */
 719
 720 static bool
 721 d_post_options (const char ** fn)
 722 {
 723   /* Verify the input file name.  */
 724   const char *filename = *fn;
 725   if (!filename || strcmp (filename, "-") == 0)
 726     filename = "";
 727
 728   /* The front end considers the first input file to be the main one.  */
 729   *fn = filename;
 730
 731   /* Release mode doesn't turn off bounds checking for safe functions.  */
 732   if (global.params.useArrayBounds == CHECKENABLEdefault)
 733     {
 734       global.params.useArrayBounds = global.params.release
 735         ? CHECKENABLEsafeonly : CHECKENABLEon;
 736     }
 737
 738   /* Assert code is generated if unittests are being compiled also, even if
 739      release mode is turned on.  */
 740   if (global.params.useAssert == CHECKENABLEdefault)
 741     {
 742       if (global.params.useUnitTests || !global.params.release)
 743         global.params.useAssert = CHECKENABLEon;
 744       else
 745         global.params.useAssert = CHECKENABLEoff;
 746     }
 747
 748   /* Checks for switches without a default are turned off in release mode.  */
 749   if (global.params.useSwitchError == CHECKENABLEdefault)
 750     {
 751       global.params.useSwitchError = global.params.release
 752         ? CHECKENABLEoff : CHECKENABLEon;
 753     }
 754
 755   /* Contracts are turned off in release mode.  */
 756   if (global.params.useInvariants == CHECKENABLEdefault)
 757     {
 758       global.params.useInvariants = global.params.release
 759         ? CHECKENABLEoff : CHECKENABLEon;
 760     }
 761
 762   if (global.params.useIn == CHECKENABLEdefault)
 763     {
 764       global.params.useIn = global.params.release
 765         ? CHECKENABLEoff : CHECKENABLEon;
 766     }
 767
 768   if (global.params.useOut == CHECKENABLEdefault)
 769     {
 770       global.params.useOut = global.params.release
 771         ? CHECKENABLEoff : CHECKENABLEon;
 772     }
 773
 774   if (global.params.betterC)
 775     {
 776       if (!global_options_set.x_flag_moduleinfo)
 777         global.params.useModuleInfo = false;
 778
 779       if (!global_options_set.x_flag_rtti)
 780         global.params.useTypeInfo = false;
 781
 782       if (!global_options_set.x_flag_exceptions)
 783         global.params.useExceptions = false;
 784
 785       global.params.checkAction = CHECKACTION_C;
 786     }
 787
 788   /* Keep in sync with existing -fbounds-check flag.  */
 789   flag_bounds_check = (global.params.useArrayBounds == CHECKENABLEon);
 790
 791   /* Turn off partitioning unless it was explicitly requested, as it doesn't
 792      work with D exception chaining, where EH handler uses LSDA to determine
 793      whether two thrown exception are in the same context.  */
 794   if (!global_options_set.x_flag_reorder_blocks_and_partition)
 795     global_options.x_flag_reorder_blocks_and_partition = 0;
 796
 797   /* Error about use of deprecated features.  */
 798   if (global.params.useDeprecated == DIAGNOSTICinform
 799       && global.params.warnings == DIAGNOSTICerror)
 800     global.params.useDeprecated = DIAGNOSTICerror;
 801
 802   /* Make -fmax-errors visible to frontend's diagnostic machinery.  */
 803   if (global_options_set.x_flag_max_errors)
 804     global.params.errorLimit = flag_max_errors;
 805
 806   if (flag_excess_precision == EXCESS_PRECISION_DEFAULT)
 807     flag_excess_precision = EXCESS_PRECISION_STANDARD;
 808
 809   global.params.symdebug = write_symbols != NO_DEBUG;
 810   global.params.useInline = flag_inline_functions;
 811   global.params.showColumns = flag_show_column;
 812
 813   if (global.params.useInline)
 814     global.params.hdrStripPlainFunctions = false;
 815
 816   global.params.obj = !flag_syntax_only;
 817
 818   /* Has no effect yet.  */
 819   global.params.pic = flag_pic != 0;
 820
 821   /* Add in versions given on the command line.  */
 822   if (global.params.versionids)
 823     {
 824       for (size_t i = 0; i < global.params.versionids->length; i++)
 825         {
 826           const char *s = (*global.params.versionids)[i];
 827           VersionCondition::addGlobalIdent (s);
 828         }
 829     }
 830
 831   if (global.params.debugids)
 832     {
 833       for (size_t i = 0; i < global.params.debugids->length; i++)
 834         {
 835           const char *s = (*global.params.debugids)[i];
 836           DebugCondition::addGlobalIdent (s);
 837         }
 838     }
 839
 840   if (warn_return_type == -1)
 841     warn_return_type = 0;
 842
 843   return false;
 844 }
 845
 846 /* Add the module M to the list of modules that may declare GCC builtins.
 847    These are scanned after first semantic and before codegen passes.
 848    See d_maybe_set_builtin() for the implementation.  */
 849
 850 void
 851 d_add_builtin_module (Module *m)
 852 {
 853   builtin_modules.push (m);
 854 }
 855
 856 /* Record the entrypoint module ENTRY which will be compiled in the current
 857    compilation.  ROOT is the module scope where this was requested from.  */
 858
 859 void
 860 d_add_entrypoint_module (Module *entry, Module *root)
 861 {
 862   /* We are emitting this straight to object file.  */
 863   entrypoint_module = entry;
 864   entrypoint_root_module = root;
 865 }
 866
 867 /* Implements the lang_hooks.parse_file routine for language D.  */
 868
 869 static void
 870 d_parse_file (void)
 871 {
 872   if (global.params.verbose)
 873     {
 874       message ("binary    %s", global.params.argv0.ptr);
 875       message ("version   %s", global.version.ptr);
 876
 877       if (global.versionids)
 878         {
 879           obstack buffer;
 880           gcc_obstack_init (&buffer);
 881           obstack_grow (&buffer, "predefs  ", 9);
 882           for (size_t i = 0; i < global.versionids->length; i++)
 883             {
 884               Identifier *id = (*global.versionids)[i];
 885               const char *str = id->toChars ();
 886               obstack_1grow (&buffer, ' ');
 887               obstack_grow (&buffer, str, strlen (str));
 888             }
 889
 890           obstack_1grow (&buffer, '\0');
 891           message ("%s", (char *) obstack_finish (&buffer));
 892         }
 893     }
 894
 895   /* Start the main input file, if the debug writer wants it.  */
 896   if (debug_hooks->start_end_main_source_file)
 897     debug_hooks->start_source_file (0, main_input_filename);
 898
 899   /* Create Module's for all sources we will load.  */
 900   Modules modules;
 901   modules.reserve (num_in_fnames);
 902
 903   /* In this mode, the first file name is supposed to be a duplicate
 904      of one of the input files.  */
 905   if (d_option.fonly && strcmp (d_option.fonly, main_input_filename) != 0)
 906     error ("%<-fonly=%> argument is different from first input file name");
 907
 908   for (size_t i = 0; i < num_in_fnames; i++)
 909     {
 910       if (strcmp (in_fnames[i], "-") == 0)
 911         {
 912           /* Load the entire contents of stdin into memory.  8 kilobytes should
 913              be a good enough initial size, but double on each iteration.
 914              16 bytes are added for the final '\n' and 15 bytes of padding.  */
 915           ssize_t size = 8 * 1024;
 916           uchar *buffer = XNEWVEC (uchar, size + 16);
 917           ssize_t len = 0;
 918           ssize_t count;
 919
 920           while ((count = read (STDIN_FILENO, buffer + len, size - len)) > 0)
 921             {
 922               len += count;
 923               if (len == size)
 924                 {
 925                   size *= 2;
 926                   buffer = XRESIZEVEC (uchar, buffer, size + 16);
 927                 }
 928             }
 929
 930           if (count < 0)
 931             {
 932               error (Loc ("stdin", 0, 0), "%s", xstrerror (errno));
 933               free (buffer);
 934               continue;
 935             }
 936
 937           /* Handling stdin, generate a unique name for the module.  */
 938           Module *m = Module::create (in_fnames[i],
 939                                       Identifier::generateId ("__stdin"),
 940                                       global.params.doDocComments,
 941                                       global.params.doHdrGeneration);
 942           modules.push (m);
 943
 944           /* Overwrite the source file for the module, the one created by
 945              Module::create would have a forced a `.d' suffix.  */
 946           m->srcfile = File::create ("<stdin>");
 947           m->srcfile->len = len;
 948           m->srcfile->buffer = buffer;
 949         }
 950       else
 951         {
 952           /* Handling a D source file, strip off the path and extension.  */
 953           const char *basename = FileName::name (in_fnames[i]);
 954           const char *name = FileName::removeExt (basename);
 955
 956           Module *m = Module::create (in_fnames[i], Identifier::idPool (name),
 957                                       global.params.doDocComments,
 958                                       global.params.doHdrGeneration);
 959           modules.push (m);
 960           FileName::free (name);
 961         }
 962     }
 963
 964   /* Read all D source files.  */
 965   for (size_t i = 0; i < modules.length; i++)
 966     {
 967       Module *m = modules[i];
 968       m->read (Loc ());
 969     }
 970
 971   /* Parse all D source files.  */
 972   for (size_t i = 0; i < modules.length; i++)
 973     {
 974       Module *m = modules[i];
 975
 976       if (global.params.verbose)
 977         message ("parse     %s", m->toChars ());
 978
 979       if (!Module::rootModule)
 980         Module::rootModule = m;
 981
 982       m->importedFrom = m;
 983       m->parse ();
 984
 985       if (m->isDocFile)
 986         {
 987           gendocfile (m);
 988           /* Remove M from list of modules.  */
 989           modules.remove (i);
 990           i--;
 991         }
 992     }
 993
 994   /* Load the module containing D main.  */
 995   if (global.params.addMain)
 996     {
 997       unsigned errors = global.startGagging ();
 998       Module *m = Module::load (Loc (), NULL, Identifier::idPool ("__main"));
 999
1000       if (!global.endGagging (errors))
1001         {
1002           m->importedFrom = m;
1003           modules.push (m);
1004         }
1005     }
1006
1007   /* If an error occurs later during compilation, remember that we generated
1008      the headers, so that they can be removed before exit.  */
1009   bool dump_headers = false;
1010
1011   if (global.errors)
1012     goto had_errors;
1013
1014   if (global.params.doHdrGeneration)
1015     {
1016       /* Generate 'header' import files.  Since 'header' import files must be
1017          independent of command line switches and what else is imported, they
1018          are generated before any semantic analysis.  */
1019       for (size_t i = 0; i < modules.length; i++)
1020         {
1021           Module *m = modules[i];
1022           if (d_option.fonly && m != Module::rootModule)
1023             continue;
1024
1025           if (global.params.verbose)
1026             message ("import    %s", m->toChars ());
1027
1028           genhdrfile (m);
1029         }
1030
1031       dump_headers = true;
1032     }
1033
1034   if (global.errors)
1035     goto had_errors;
1036
1037   /* Load all unconditional imports for better symbol resolving.  */
1038   for (size_t i = 0; i < modules.length; i++)
1039     {
1040       Module *m = modules[i];
1041
1042       if (global.params.verbose)
1043         message ("importall %s", m->toChars ());
1044
1045       m->importAll (NULL);
1046     }
1047
1048   if (global.errors)
1049     goto had_errors;
1050
1051   /* Do semantic analysis.  */
1052   doing_semantic_analysis_p = true;
1053
1054   for (size_t i = 0; i < modules.length; i++)
1055     {
1056       Module *m = modules[i];
1057
1058       if (global.params.verbose)
1059         message ("semantic  %s", m->toChars ());
1060
1061       dsymbolSemantic (m, NULL);
1062     }
1063
1064   /* Do deferred semantic analysis.  */
1065   Module::dprogress = 1;
1066   Module::runDeferredSemantic ();
1067
1068   if (Module::deferred.length)
1069     {
1070       for (size_t i = 0; i < Module::deferred.length; i++)
1071         {
1072           Dsymbol *sd = Module::deferred[i];
1073           error_at (make_location_t (sd->loc),
1074                     "unable to resolve forward reference in definition");
1075         }
1076     }
1077
1078   /* Process all built-in modules or functions now for CTFE.  */
1079   while (builtin_modules.length != 0)
1080     {
1081       Module *m = builtin_modules.pop ();
1082       d_maybe_set_builtin (m);
1083     }
1084
1085   /* Do pass 2 semantic analysis.  */
1086   for (size_t i = 0; i < modules.length; i++)
1087     {
1088       Module *m = modules[i];
1089
1090       if (global.params.verbose)
1091         message ("semantic2 %s", m->toChars ());
1092
1093       semantic2 (m, NULL);
1094     }
1095
1096   Module::runDeferredSemantic2 ();
1097
1098   if (global.errors)
1099     goto had_errors;
1100
1101   /* Do pass 3 semantic analysis.  */
1102   for (size_t i = 0; i < modules.length; i++)
1103     {
1104       Module *m = modules[i];
1105
1106       if (global.params.verbose)
1107         message ("semantic3 %s", m->toChars ());
1108
1109       semantic3 (m, NULL);
1110     }
1111
1112   Module::runDeferredSemantic3 ();
1113
1114   /* Check again, incase semantic3 pass loaded any more modules.  */
1115   while (builtin_modules.length != 0)
1116     {
1117       Module *m = builtin_modules.pop ();
1118       d_maybe_set_builtin (m);
1119     }
1120
1121   /* Do not attempt to generate output files if errors or warnings occurred.  */
1122   if (global.errors || global.warnings)
1123     goto had_errors;
1124
1125   /* Generate output files.  */
1126   doing_semantic_analysis_p = false;
1127
1128   if (Module::rootModule)
1129     {
1130       /* Declare the name of the root module as the first global name in order
1131          to make the middle-end fully deterministic.  */
1132       OutBuffer buf;
1133       mangleToBuffer (Module::rootModule, &buf);
1134       first_global_object_name = buf.extractChars ();
1135     }
1136
1137   /* Make dependencies.  */
1138   if (d_option.deps)
1139     {
1140       obstack buffer;
1141       FILE *deps_stream;
1142
1143       gcc_obstack_init (&buffer);
1144
1145       for (size_t i = 0; i < modules.length; i++)
1146         deps_write (modules[i], &buffer);
1147
1148       /* -MF <arg> overrides -M[M]D.  */
1149       if (d_option.deps_filename_user)
1150         d_option.deps_filename = d_option.deps_filename_user;
1151
1152       if (d_option.deps_filename)
1153         {
1154           deps_stream = fopen (d_option.deps_filename, "w");
1155           if (!deps_stream)
1156             {
1157               fatal_error (input_location, "opening dependency file %s: %m",
1158                            d_option.deps_filename);
1159               goto had_errors;
1160             }
1161         }
1162       else
1163         deps_stream = stdout;
1164
1165       fprintf (deps_stream, "%s", (char *) obstack_finish (&buffer));
1166
1167       if (deps_stream != stdout
1168           && (ferror (deps_stream) || fclose (deps_stream)))
1169         {
1170           fatal_error (input_location, "closing dependency file %s: %m",
1171                        d_option.deps_filename);
1172         }
1173     }
1174
1175   /* Generate JSON files.  */
1176   if (global.params.doJsonGeneration)
1177     {
1178       OutBuffer buf;
1179       json_generate (&buf, &modules);
1180
1181       const char *name = global.params.jsonfilename.ptr;
1182       FILE *json_stream;
1183
1184       if (name && (name[0] != '-' || name[1] != '\0'))
1185         {
1186           const char *nameext
1187             = FileName::defaultExt (name, global.json_ext.ptr);
1188           json_stream = fopen (nameext, "w");
1189           if (!json_stream)
1190             {
1191               fatal_error (input_location, "opening json file %s: %m", nameext);
1192               goto had_errors;
1193             }
1194         }
1195       else
1196         json_stream = stdout;
1197
1198       fprintf (json_stream, "%s", buf.peekChars ());
1199
1200       if (json_stream != stdout
1201           && (ferror (json_stream) || fclose (json_stream)))
1202         fatal_error (input_location, "closing json file %s: %m", name);
1203     }
1204
1205   /* Generate Ddoc files.  */
1206   if (global.params.doDocComments && !global.errors && !errorcount)
1207     {
1208       for (size_t i = 0; i < modules.length; i++)
1209         {
1210           Module *m = modules[i];
1211           gendocfile (m);
1212         }
1213     }
1214
1215   /* Handle -fdump-d-original.  */
1216   if (global.params.vcg_ast)
1217     {
1218       for (size_t i = 0; i < modules.length; i++)
1219         {
1220           Module *m = modules[i];
1221           OutBuffer buf;
1222           buf.doindent = 1;
1223
1224           moduleToBuffer (&buf, m);
1225           message ("%s", buf.peekChars ());
1226         }
1227     }
1228
1229   for (size_t i = 0; i < modules.length; i++)
1230     {
1231       Module *m = modules[i];
1232       if (d_option.fonly && m != Module::rootModule)
1233         continue;
1234
1235       if (global.params.verbose)
1236         message ("code      %s", m->toChars ());
1237
1238       if (!flag_syntax_only)
1239         {
1240           if ((entrypoint_module != NULL) && (m == entrypoint_root_module))
1241             build_decl_tree (entrypoint_module);
1242
1243           build_decl_tree (m);
1244         }
1245     }
1246
1247   /* And end the main input file, if the debug writer wants it.  */
1248   if (debug_hooks->start_end_main_source_file)
1249     debug_hooks->end_source_file (0);
1250
1251  had_errors:
1252   /* Add the D frontend error count to the GCC error count to correctly
1253      exit with an error status.  */
1254   errorcount += (global.errors + global.warnings);
1255
1256   /* Remove generated .di files on error.  */
1257   if (errorcount && dump_headers)
1258     {
1259       for (size_t i = 0; i < modules.length; i++)
1260         {
1261           Module *m = modules[i];
1262           if (d_option.fonly && m != Module::rootModule)
1263             continue;
1264
1265           remove (m->hdrfile->toChars ());
1266         }
1267     }
1268
1269   /* Write out globals.  */
1270   d_finish_compilation (vec_safe_address (global_declarations),
1271                         vec_safe_length (global_declarations));
1272 }
1273
1274 /* Implements the lang_hooks.types.type_for_mode routine for language D.  */
1275
1276 static tree
1277 d_type_for_mode (machine_mode mode, int unsignedp)
1278 {
1279   if (mode == QImode)
1280     return unsignedp ? d_ubyte_type : d_byte_type;
1281
1282   if (mode == HImode)
1283     return unsignedp ? d_ushort_type : d_short_type;
1284
1285   if (mode == SImode)
1286     return unsignedp ? d_uint_type : d_int_type;
1287
1288   if (mode == DImode)
1289     return unsignedp ? d_ulong_type : d_long_type;
1290
1291   if (mode == TYPE_MODE (d_cent_type))
1292     return unsignedp ? d_ucent_type : d_cent_type;
1293
1294   if (mode == TYPE_MODE (float_type_node))
1295     return float_type_node;
1296
1297   if (mode == TYPE_MODE (double_type_node))
1298     return double_type_node;
1299
1300   if (mode == TYPE_MODE (long_double_type_node))
1301     return long_double_type_node;
1302
1303   if (mode == TYPE_MODE (build_pointer_type (char8_type_node)))
1304     return build_pointer_type (char8_type_node);
1305
1306   if (mode == TYPE_MODE (build_pointer_type (d_int_type)))
1307     return build_pointer_type (d_int_type);
1308
1309   for (int i = 0; i < NUM_INT_N_ENTS; i ++)
1310     {
1311       if (int_n_enabled_p[i] && mode == int_n_data[i].m)
1312         {
1313           if (unsignedp)
1314             return int_n_trees[i].unsigned_type;
1315           else
1316             return int_n_trees[i].signed_type;
1317         }
1318     }
1319
1320   if (COMPLEX_MODE_P (mode))
1321     {
1322       machine_mode inner_mode;
1323       tree inner_type;
1324
1325       if (mode == TYPE_MODE (complex_float_type_node))
1326         return complex_float_type_node;
1327       if (mode == TYPE_MODE (complex_double_type_node))
1328         return complex_double_type_node;
1329       if (mode == TYPE_MODE (complex_long_double_type_node))
1330         return complex_long_double_type_node;
1331
1332       inner_mode = (machine_mode) GET_MODE_INNER (mode);
1333       inner_type = d_type_for_mode (inner_mode, unsignedp);
1334       if (inner_type != NULL_TREE)
1335         return build_complex_type (inner_type);
1336     }
1337   else if (VECTOR_MODE_P (mode))
1338     {
1339       machine_mode inner_mode = (machine_mode) GET_MODE_INNER (mode);
1340       tree inner_type = d_type_for_mode (inner_mode, unsignedp);
1341       if (inner_type != NULL_TREE)
1342         return build_vector_type_for_mode (inner_type, mode);
1343     }
1344
1345   return 0;
1346 }
1347
1348 /* Implements the lang_hooks.types.type_for_size routine for language D.  */
1349
1350 static tree
1351 d_type_for_size (unsigned bits, int unsignedp)
1352 {
1353   if (bits <= TYPE_PRECISION (d_byte_type))
1354     return unsignedp ? d_ubyte_type : d_byte_type;
1355
1356   if (bits <= TYPE_PRECISION (d_short_type))
1357     return unsignedp ? d_ushort_type : d_short_type;
1358
1359   if (bits <= TYPE_PRECISION (d_int_type))
1360     return unsignedp ? d_uint_type : d_int_type;
1361
1362   if (bits <= TYPE_PRECISION (d_long_type))
1363     return unsignedp ? d_ulong_type : d_long_type;
1364
1365   if (bits <= TYPE_PRECISION (d_cent_type))
1366     return unsignedp ? d_ucent_type : d_cent_type;
1367
1368   for (int i = 0; i < NUM_INT_N_ENTS; i ++)
1369     {
1370       if (int_n_enabled_p[i] && bits == int_n_data[i].bitsize)
1371         {
1372           if (unsignedp)
1373             return int_n_trees[i].unsigned_type;
1374           else
1375             return int_n_trees[i].signed_type;
1376         }
1377     }
1378
1379   return 0;
1380 }
1381
1382 /* Implements the lang_hooks.types.type_promotes_to routine for language D.  */
1383
1384 static tree
1385 d_type_promotes_to (tree type)
1386 {
1387   /* Promotions are only applied on unnamed function arguments for declarations
1388      with `extern(C)' or `extern(C++)' linkage.  */
1389   if (cfun && DECL_LANG_FRONTEND (cfun->decl)
1390       && DECL_LANG_FRONTEND (cfun->decl)->linkage != LINKd)
1391     {
1392       /* In [type/integer-promotions], integer promotions are conversions of the
1393          following types:
1394
1395                 bool    int
1396                 byte    int
1397                 ubyte   int
1398                 short   int
1399                 ushort  int
1400                 char    int
1401                 wchar   int
1402                 dchar   uint
1403
1404          If an enum has as a base type one of the types in the left column, it
1405          is converted to the type in the right column.  */
1406       if (TREE_CODE (type) == ENUMERAL_TYPE && ENUM_IS_SCOPED (type))
1407         type = TREE_TYPE (type);
1408
1409       type = TYPE_MAIN_VARIANT (type);
1410
1411       /* Check for promotions of target-defined types first.  */
1412       tree promoted_type = targetm.promoted_type (type);
1413       if (promoted_type)
1414         return promoted_type;
1415
1416       if (TREE_CODE (type) == BOOLEAN_TYPE)
1417         return d_int_type;
1418
1419       if (INTEGRAL_TYPE_P (type))
1420         {
1421           if (type == d_byte_type || type == d_ubyte_type
1422               || type == d_short_type || type == d_ushort_type
1423               || type == char8_type_node || type == char16_type_node)
1424             return d_int_type;
1425
1426           if (type == char32_type_node)
1427             return d_uint_type;
1428
1429           if (TYPE_PRECISION (type) < TYPE_PRECISION (d_int_type))
1430             return d_int_type;
1431         }
1432
1433       /* Float arguments are converted to doubles.  */
1434       if (type == float_type_node)
1435         return double_type_node;
1436
1437       if (type == ifloat_type_node)
1438         return idouble_type_node;
1439     }
1440
1441   return type;
1442 }
1443
1444 /* Implements the lang_hooks.decls.global_bindings_p routine for language D.
1445    Return true if we are in the global binding level.  */
1446
1447 static bool
1448 d_global_bindings_p (void)
1449 {
1450   return (current_binding_level == global_binding_level);
1451 }
1452
1453 /* Return global_context, but create it first if need be.  */
1454
1455 static tree
1456 get_global_context (void)
1457 {
1458   if (!global_context)
1459     {
1460       global_context = build_translation_unit_decl (NULL_TREE);
1461       debug_hooks->register_main_translation_unit (global_context);
1462     }
1463
1464   return global_context;
1465 }
1466
1467 /* Implements the lang_hooks.decls.pushdecl routine for language D.
1468    Record DECL as belonging to the current lexical scope.  */
1469
1470 tree
1471 d_pushdecl (tree decl)
1472 {
1473   /* Set the context of the decl.  If current_function_decl did not help in
1474      determining the context, use global scope.  */
1475   if (!DECL_CONTEXT (decl))
1476     {
1477       if (current_function_decl)
1478         DECL_CONTEXT (decl) = current_function_decl;
1479       else
1480         DECL_CONTEXT (decl) = get_global_context ();
1481     }
1482
1483   /* Put decls on list in reverse order.  */
1484   if (TREE_STATIC (decl) || d_global_bindings_p ())
1485     vec_safe_push (global_declarations, decl);
1486   else
1487     {
1488       TREE_CHAIN (decl) = current_binding_level->names;
1489       current_binding_level->names = decl;
1490     }
1491
1492   return decl;
1493 }
1494
1495 /* Implements the lang_hooks.decls.getdecls routine for language D.
1496    Return the list of declarations of the current level.  */
1497
1498 static tree
1499 d_getdecls (void)
1500 {
1501   if (current_binding_level)
1502     return current_binding_level->names;
1503
1504   return NULL_TREE;
1505 }
1506
1507
1508 /* Implements the lang_hooks.get_alias_set routine for language D.
1509    Get the alias set corresponding to type or expression T.
1510    Return -1 if we don't do anything special.  */
1511
1512 static alias_set_type
1513 d_get_alias_set (tree)
1514 {
1515   /* For now in D, assume everything aliases everything else, until we define
1516      some solid rules backed by a specification.  There are also some parts
1517      of code generation routines that don't adhere to C alias rules, such as
1518      build_vconvert.  In any case, a lot of user code already assumes there
1519      is no strict aliasing and will break if we were to change that.  */
1520   return 0;
1521 }
1522
1523 /* Implements the lang_hooks.types_compatible_p routine for language D.
1524    Compares two types for equivalence in the D programming language.
1525    This routine should only return 1 if it is sure, even though the frontend
1526    should have already ensured that all types are compatible before handing
1527    over the parsed ASTs to the code generator.  */
1528
1529 static int
1530 d_types_compatible_p (tree x, tree y)
1531 {
1532   Type *tx = TYPE_LANG_FRONTEND (x);
1533   Type *ty = TYPE_LANG_FRONTEND (y);
1534
1535   /* Try validating the types in the frontend.  */
1536   if (tx != NULL && ty != NULL)
1537     {
1538       /* Types are equivalent.  */
1539       if (same_type_p (tx, ty))
1540         return true;
1541
1542       /* Type system allows implicit conversion between.  */
1543       if (tx->implicitConvTo (ty) || ty->implicitConvTo (tx))
1544         return true;
1545     }
1546
1547   /* Fallback on using type flags for comparison.  E.g: all dynamic arrays
1548      are distinct types in D, but are VIEW_CONVERT compatible.  */
1549   if (TREE_CODE (x) == RECORD_TYPE && TREE_CODE (y) == RECORD_TYPE)
1550     {
1551       if (TYPE_DYNAMIC_ARRAY (x) && TYPE_DYNAMIC_ARRAY (y))
1552         return true;
1553
1554       if (TYPE_DELEGATE (x) && TYPE_DELEGATE (y))
1555         return true;
1556
1557       if (TYPE_ASSOCIATIVE_ARRAY (x) && TYPE_ASSOCIATIVE_ARRAY (y))
1558         return true;
1559     }
1560
1561   return false;
1562 }
1563
1564 /* Implements the lang_hooks.finish_incomplete_decl routine for language D.  */
1565
1566 static void
1567 d_finish_incomplete_decl (tree decl)
1568 {
1569   if (VAR_P (decl))
1570     {
1571       /* D allows zero-length declarations.  Such a declaration ends up with
1572          DECL_SIZE (t) == NULL_TREE which is what the back-end function
1573          assembler_variable checks.  This could change in later versions, or
1574          maybe all of these variables should be aliased to one symbol.  */
1575       if (DECL_SIZE (decl) == 0)
1576         {
1577           DECL_SIZE (decl) = bitsize_zero_node;
1578           DECL_SIZE_UNIT (decl) = size_zero_node;
1579         }
1580     }
1581 }
1582
1583 /* Implements the lang_hooks.types.classify_record routine for language D.
1584    Return the true debug type for TYPE.  */
1585
1586 static classify_record
1587 d_classify_record (tree type)
1588 {
1589   Type *t = TYPE_LANG_FRONTEND (type);
1590   TypeClass *tc = t ? t->isTypeClass () : NULL;
1591
1592   if (tc != NULL)
1593     {
1594       /* extern(C++) interfaces get emitted as classes.  */
1595       if (tc->sym->isInterfaceDeclaration ()
1596           && !tc->sym->isCPPinterface ())
1597         return RECORD_IS_INTERFACE;
1598
1599       return RECORD_IS_CLASS;
1600     }
1601
1602   return RECORD_IS_STRUCT;
1603 }
1604
1605 /* Implements the lang_hooks.tree_size routine for language D.
1606    Determine the size of our tcc_constant or tcc_exceptional nodes.  */
1607
1608 static size_t
1609 d_tree_size (tree_code code)
1610 {
1611   switch (code)
1612     {
1613     case FUNCFRAME_INFO:
1614       return sizeof (tree_frame_info);
1615
1616     default:
1617       gcc_unreachable ();
1618     }
1619 }
1620
1621 /* Implements the lang_hooks.print_xnode routine for language D.  */
1622
1623 static void
1624 d_print_xnode (FILE *file, tree node, int indent)
1625 {
1626   switch (TREE_CODE (node))
1627     {
1628     case FUNCFRAME_INFO:
1629       print_node (file, "frame_type", FRAMEINFO_TYPE (node), indent + 4);
1630       break;
1631
1632     default:
1633       break;
1634     }
1635 }
1636
1637 /* Return which tree structure is used by NODE, or TS_D_GENERIC if NODE
1638    is one of the language-independent trees.  */
1639
1640 d_tree_node_structure_enum
1641 d_tree_node_structure (lang_tree_node *t)
1642 {
1643   switch (TREE_CODE (&t->generic))
1644     {
1645     case IDENTIFIER_NODE:
1646       return TS_D_IDENTIFIER;
1647
1648     case FUNCFRAME_INFO:
1649       return TS_D_FRAMEINFO;
1650
1651     default:
1652       return TS_D_GENERIC;
1653     }
1654 }
1655
1656 /* Allocate and return a lang specific structure for the frontend type.  */
1657
1658 struct lang_type *
1659 build_lang_type (Type *t)
1660 {
1661   struct lang_type *lt = ggc_cleared_alloc <struct lang_type> ();
1662   lt->type = t;
1663   return lt;
1664 }
1665
1666 /* Allocate and return a lang specific structure for the frontend decl.  */
1667
1668 struct lang_decl *
1669 build_lang_decl (Declaration *d)
1670 {
1671   /* For compiler generated run-time typeinfo, a lang_decl is allocated even if
1672      there's no associated frontend symbol to refer to (yet).  If the symbol
1673      appears later in the compilation, then the slot will be re-used.  */
1674   if (d == NULL)
1675     return ggc_cleared_alloc <struct lang_decl> ();
1676
1677   struct lang_decl *ld = (d->csym) ? DECL_LANG_SPECIFIC (d->csym) : NULL;
1678   if (ld == NULL)
1679     ld = ggc_cleared_alloc <struct lang_decl> ();
1680
1681   if (ld->decl == NULL)
1682     ld->decl = d;
1683
1684   return ld;
1685 }
1686
1687 /* Implements the lang_hooks.dup_lang_specific_decl routine for language D.
1688    Replace the DECL_LANG_SPECIFIC field of NODE with a copy.  */
1689
1690 static void
1691 d_dup_lang_specific_decl (tree node)
1692 {
1693   if (!DECL_LANG_SPECIFIC (node))
1694     return;
1695
1696   struct lang_decl *ld = ggc_alloc <struct lang_decl> ();
1697   memcpy (ld, DECL_LANG_SPECIFIC (node), sizeof (struct lang_decl));
1698   DECL_LANG_SPECIFIC (node) = ld;
1699 }
1700
1701 /* This preserves trees we create from the garbage collector.  */
1702
1703 static GTY(()) tree d_keep_list = NULL_TREE;
1704
1705 void
1706 d_keep (tree t)
1707 {
1708   d_keep_list = tree_cons (NULL_TREE, t, d_keep_list);
1709 }
1710
1711 /* Implements the lang_hooks.eh_personality routine for language D.
1712    Return the GDC personality function decl.  */
1713
1714 static GTY(()) tree d_eh_personality_decl;
1715
1716 static tree
1717 d_eh_personality (void)
1718 {
1719   if (!d_eh_personality_decl)
1720     d_eh_personality_decl = build_personality_function ("gdc");
1721
1722   return d_eh_personality_decl;
1723 }
1724
1725 /* Implements the lang_hooks.eh_runtime_type routine for language D.  */
1726
1727 static tree
1728 d_build_eh_runtime_type (tree type)
1729 {
1730   Type *t = TYPE_LANG_FRONTEND (type);
1731   gcc_assert (t != NULL);
1732   t = t->toBasetype ();
1733
1734   ClassDeclaration *cd = t->isTypeClass ()->sym;
1735   tree decl;
1736
1737   if (cd->isCPPclass ())
1738     decl = get_cpp_typeinfo_decl (cd);
1739   else
1740     decl = get_classinfo_decl (cd);
1741
1742   return convert (ptr_type_node, build_address (decl));
1743 }
1744
1745 /* Implements the lang_hooks.enum_underlying_base_type routine for language D.
1746    Returns the underlying type of the given enumeration TYPE.  */
1747
1748 static tree
1749 d_enum_underlying_base_type (const_tree type)
1750 {
1751   gcc_assert (TREE_CODE (type) == ENUMERAL_TYPE);
1752   return TREE_TYPE (type);
1753 }
1754
1755 /* Definitions for our language-specific hooks.  */
1756
1757 #undef LANG_HOOKS_NAME
1758 #undef LANG_HOOKS_INIT
1759 #undef LANG_HOOKS_INIT_TS
1760 #undef LANG_HOOKS_INIT_OPTIONS
1761 #undef LANG_HOOKS_INIT_OPTIONS_STRUCT
1762 #undef LANG_HOOKS_OPTION_LANG_MASK
1763 #undef LANG_HOOKS_HANDLE_OPTION
1764 #undef LANG_HOOKS_POST_OPTIONS
1765 #undef LANG_HOOKS_PARSE_FILE
1766 #undef LANG_HOOKS_COMMON_ATTRIBUTE_TABLE
1767 #undef LANG_HOOKS_ATTRIBUTE_TABLE
1768 #undef LANG_HOOKS_GET_ALIAS_SET
1769 #undef LANG_HOOKS_TYPES_COMPATIBLE_P
1770 #undef LANG_HOOKS_BUILTIN_FUNCTION
1771 #undef LANG_HOOKS_BUILTIN_FUNCTION_EXT_SCOPE
1772 #undef LANG_HOOKS_REGISTER_BUILTIN_TYPE
1773 #undef LANG_HOOKS_FINISH_INCOMPLETE_DECL
1774 #undef LANG_HOOKS_GIMPLIFY_EXPR
1775 #undef LANG_HOOKS_CLASSIFY_RECORD
1776 #undef LANG_HOOKS_TREE_SIZE
1777 #undef LANG_HOOKS_PRINT_XNODE
1778 #undef LANG_HOOKS_DUP_LANG_SPECIFIC_DECL
1779 #undef LANG_HOOKS_EH_PERSONALITY
1780 #undef LANG_HOOKS_EH_RUNTIME_TYPE
1781 #undef LANG_HOOKS_ENUM_UNDERLYING_BASE_TYPE
1782 #undef LANG_HOOKS_PUSHDECL
1783 #undef LANG_HOOKS_GETDECLS
1784 #undef LANG_HOOKS_GLOBAL_BINDINGS_P
1785 #undef LANG_HOOKS_TYPE_FOR_MODE
1786 #undef LANG_HOOKS_TYPE_FOR_SIZE
1787 #undef LANG_HOOKS_TYPE_PROMOTES_TO
1788
1789 #define LANG_HOOKS_NAME                     "GNU D"
1790 #define LANG_HOOKS_INIT                     d_init
1791 #define LANG_HOOKS_INIT_TS                  d_init_ts
1792 #define LANG_HOOKS_INIT_OPTIONS             d_init_options
1793 #define LANG_HOOKS_INIT_OPTIONS_STRUCT      d_init_options_struct
1794 #define LANG_HOOKS_OPTION_LANG_MASK         d_option_lang_mask
1795 #define LANG_HOOKS_HANDLE_OPTION            d_handle_option
1796 #define LANG_HOOKS_POST_OPTIONS             d_post_options
1797 #define LANG_HOOKS_PARSE_FILE               d_parse_file
1798 #define LANG_HOOKS_COMMON_ATTRIBUTE_TABLE   d_langhook_common_attribute_table
1799 #define LANG_HOOKS_ATTRIBUTE_TABLE          d_langhook_attribute_table
1800 #define LANG_HOOKS_GET_ALIAS_SET            d_get_alias_set
1801 #define LANG_HOOKS_TYPES_COMPATIBLE_P       d_types_compatible_p
1802 #define LANG_HOOKS_BUILTIN_FUNCTION         d_builtin_function
1803 #define LANG_HOOKS_BUILTIN_FUNCTION_EXT_SCOPE d_builtin_function_ext_scope
1804 #define LANG_HOOKS_REGISTER_BUILTIN_TYPE    d_register_builtin_type
1805 #define LANG_HOOKS_FINISH_INCOMPLETE_DECL   d_finish_incomplete_decl
1806 #define LANG_HOOKS_GIMPLIFY_EXPR            d_gimplify_expr
1807 #define LANG_HOOKS_CLASSIFY_RECORD          d_classify_record
1808 #define LANG_HOOKS_TREE_SIZE                d_tree_size
1809 #define LANG_HOOKS_PRINT_XNODE              d_print_xnode
1810 #define LANG_HOOKS_DUP_LANG_SPECIFIC_DECL   d_dup_lang_specific_decl
1811 #define LANG_HOOKS_EH_PERSONALITY           d_eh_personality
1812 #define LANG_HOOKS_EH_RUNTIME_TYPE          d_build_eh_runtime_type
1813 #define LANG_HOOKS_ENUM_UNDERLYING_BASE_TYPE d_enum_underlying_base_type
1814 #define LANG_HOOKS_PUSHDECL                 d_pushdecl
1815 #define LANG_HOOKS_GETDECLS                 d_getdecls
1816 #define LANG_HOOKS_GLOBAL_BINDINGS_P        d_global_bindings_p
1817 #define LANG_HOOKS_TYPE_FOR_MODE            d_type_for_mode
1818 #define LANG_HOOKS_TYPE_FOR_SIZE            d_type_for_size
1819 #define LANG_HOOKS_TYPE_PROMOTES_TO         d_type_promotes_to
1820
1821 struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
1822
1823 #include "gt-d-d-lang.h"
1824 #include "gtype-d.h"