d-decls.cc

   1 /* GDC -- D front-end for GCC
   2    Copyright (C) 2004 David Friedman
   3
   4    This program 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 2 of the License, or
   7    (at your option) any later version.
   8
   9    This program 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 this program; if not, write to the Free Software
  16    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17 */
  18 /*
  19   This file is based on dmd/tocsym.c.  Original copyright:
  20
  21 // Copyright (c) 1999-2002 by Digital Mars
  22 // All Rights Reserved
  23 // written by Walter Bright
  24 // www.digitalmars.com
  25 // License for redistribution is by either the Artistic License
  26 // in artistic.txt, or the GNU General Public License in gnu.txt.
  27 // See the included readme.txt for details.
  28
  29 */
  30
  31 #include "d-gcc-includes.h"
  32 #include <assert.h>
  33
  34 #include "total.h"
  35 #include "mars.h"
  36 #include "statement.h"
  37 #include "aggregate.h"
  38 #include "init.h"
  39 #include "attrib.h"
  40
  41 #include "symbol.h"
  42 #include "d-lang.h"
  43 #include "d-codegen.h"
  44
  45 void slist_add(Symbol */*s*/)
  46 {
  47 }
  48 void slist_reset()
  49 {
  50 }
  51
  52 /********************************* SymbolDeclaration ****************************/
  53
  54 SymbolDeclaration::SymbolDeclaration(Loc loc, Symbol *s, StructDeclaration *dsym)
  55     : Declaration(new Identifier(s->Sident, TOKidentifier))
  56 {
  57     this->loc = loc;
  58     sym = s;
  59     this->dsym = dsym;
  60     storage_class |= STCconst;
  61 }
  62
  63 Symbol *SymbolDeclaration::toSymbol()
  64 {
  65     // Create the actual back-end value if not yet done
  66     if (! sym->Stree) {
  67         if (dsym)
  68             dsym->toInitializer();
  69         assert(sym->Stree);
  70     }
  71     return sym;
  72 }
  73
  74 /*************************************
  75  * Helper
  76  */
  77
  78 Symbol *Dsymbol::toSymbolX(const char *prefix, int sclass, type *t, const char *suffix)
  79 {
  80     Symbol *s;
  81     char *id;
  82     char *n;
  83
  84     n = mangle();
  85     id = (char *) alloca(2 + strlen(n) + sizeof(size_t) * 3 + strlen(prefix) + strlen(suffix) + 1);
  86     sprintf(id,"_D%s%"PRIuSIZE"%s%s", n, strlen(prefix), prefix, suffix);
  87     s = symbol_name(id, sclass, t);
  88     return s;
  89 }
  90
  91 /*************************************
  92  */
  93
  94 Symbol *Dsymbol::toSymbol()
  95 {
  96     fprintf(stderr, "Dsymbol::toSymbol() '%s', kind = '%s'\n", toChars(), kind());
  97     assert(0);          // BUG: implement
  98     return NULL;
  99 }
 100
 101 /*********************************
 102  * Generate import symbol from symbol.
 103  */
 104
 105 Symbol *Dsymbol::toImport()
 106 {
 107     if (!isym)
 108     {
 109         if (!csym)
 110             csym = toSymbol();
 111         isym = toImport(csym);
 112     }
 113     return isym;
 114 }
 115
 116 /*************************************
 117  */
 118
 119 Symbol *Dsymbol::toImport(Symbol * /*sym*/)
 120 {
 121     // not used in GCC (yet?)
 122     return 0;
 123 }
 124
 125
 126
 127 /* When using -combine, there may be name collisions on compiler-generated
 128    or extern(C) symbols. This only should only apply to private symbols.
 129    Otherwise, duplicate names are an error. */
 130
 131 static StringTable * uniqueNames = 0;
 132 static void uniqueName(Declaration * d, tree t, const char * asm_name) {
 133     Dsymbol * p = d->toParent2();
 134     const char * out_name = asm_name;
 135     char * alloc_name = 0;
 136
 137     FuncDeclaration * f = d->isFuncDeclaration();
 138     VarDeclaration * v = d->isVarDeclaration();
 139
 140     /* Check cases for which it is okay to have a duplicate symbol name.
 141        Otherwise, duplicate names are an error and the condition will
 142        be caught by the assembler. */
 143     if (!(f && ! f->fbody) &&
 144         !(v && (v->storage_class & STCextern)) &&
 145         (
 146          // Static declarations in different scope statements
 147          (p && p->isFuncDeclaration()) ||
 148
 149          // Top-level duplicate names are okay if private.
 150          ((!p || p->isModule()) && d->protection == PROTprivate) ))
 151     {
 152         StringValue * sv;
 153
 154         // Assumes one assembler output file per compiler run.  Otherwise, need
 155         // to reset this for each file.
 156         if (! uniqueNames)
 157             uniqueNames = new StringTable;
 158         sv = uniqueNames->update(asm_name, strlen(asm_name));
 159         if (sv->intvalue) {
 160             out_name = alloc_name = d_asm_format_private_name(asm_name, sv->intvalue );
 161         }
 162         sv->intvalue++;
 163     }
 164
 165     SET_DECL_ASSEMBLER_NAME(t, get_identifier(out_name));
 166
 167     if (alloc_name)
 168         free(alloc_name);
 169 }
 170
 171
 172 /*************************************
 173  */
 174
 175 Symbol *VarDeclaration::toSymbol()
 176 {
 177     if (! csym) {
 178         tree var_decl;
 179
 180         // For field declaration, it is possible for toSymbol to be called
 181         // before the parent's toCtype()
 182         if (storage_class & STCfield) {
 183             AggregateDeclaration * parent_decl = toParent()->isAggregateDeclaration();
 184             assert(parent_decl);
 185             parent_decl->type->toCtype();
 186             assert(csym);
 187             return csym;
 188         }
 189
 190         const char * ident_to_use;
 191         if (isDataseg())
 192             ident_to_use = mangle();
 193         else
 194             ident_to_use = ident->string;
 195
 196         enum tree_code decl_kind;
 197
 198 #if ! V2
 199         bool is_template_const = false;
 200         // Logic copied from toobj.c VarDeclaration::toObjFile
 201
 202         Dsymbol * parent = this->toParent();
 203 #if 1   /* private statics should still get a global symbol, in case
 204          * another module inlines a function that references it.
 205          */
 206         if (/*protection == PROTprivate ||*/
 207             !parent || parent->ident == NULL || parent->isFuncDeclaration())
 208         {
 209             // nothing
 210         }
 211         else
 212 #endif
 213         {
 214             do
 215             {
 216                 /* Global template data members need to be in comdat's
 217                  * in case multiple .obj files instantiate the same
 218                  * template with the same types.
 219                  */
 220                 if (parent->isTemplateInstance() && !parent->isTemplateMixin())
 221                 {
 222                     /* These symbol constants have already been copied,
 223                      * so no reason to output them.
 224                      * Note that currently there is no way to take
 225                      * the address of such a const.
 226                      */
 227                     if (isConst() && type->toBasetype()->ty != Tsarray &&
 228                         init && init->isExpInitializer())
 229                     {
 230                         is_template_const = true;
 231                         break;
 232                     }
 233
 234                     break;
 235                 }
 236                 parent = parent->parent;
 237             } while (parent);
 238         }
 239 #endif
 240
 241         if (storage_class & STCparameter)
 242             decl_kind = PARM_DECL;
 243         else if (
 244 #if V2
 245 # if 0
 246                  // from VarDeclaration::getConstInitializer
 247                  (isConst() || isInvariant()) && (storage_class & STCinit)
 248 # else
 249                  (storage_class & STCmanifest)
 250 # endif
 251 #else
 252                  is_template_const ||
 253                  (
 254                    isConst()
 255                    && ! gen.isDeclarationReferenceType( this ) &&
 256                    type->isscalar() && ! isDataseg()
 257                  )
 258 #endif
 259                  )
 260             decl_kind = CONST_DECL;
 261         else
 262             decl_kind = VAR_DECL;
 263
 264         var_decl = build_decl(decl_kind, get_identifier(ident_to_use),
 265             gen.trueDeclarationType( this ));
 266
 267         csym = new Symbol();
 268         csym->Stree = var_decl;
 269
 270         if (decl_kind != CONST_DECL) {
 271             if (isDataseg())
 272                 uniqueName(this, var_decl, ident_to_use);
 273             if (c_ident)
 274                 SET_DECL_ASSEMBLER_NAME(var_decl, get_identifier(c_ident->string));
 275         }
 276         dkeep(var_decl);
 277         g.ofile->setDeclLoc(var_decl, this);
 278         if ( decl_kind == VAR_DECL ) {
 279             g.ofile->setupSymbolStorage(this, var_decl);
 280             //DECL_CONTEXT( var_decl ) = gen.declContext(this);//EXPERkinda
 281         } else if (decl_kind == PARM_DECL)  {
 282             /* from gcc code: Some languages have different nominal and real types.  */
 283             // %% What about DECL_ORIGINAL_TYPE, DECL_ARG_TYPE_AS_WRITTEN, DECL_ARG_TYPE ?
 284             DECL_ARG_TYPE( var_decl ) = TREE_TYPE (var_decl);
 285
 286             DECL_CONTEXT( var_decl ) = gen.declContext(this);
 287             assert( TREE_CODE(DECL_CONTEXT( var_decl )) == FUNCTION_DECL );
 288         } else if (decl_kind == CONST_DECL) {
 289             /* Not sure how much of an optimization this is... It is needed
 290                for foreach loops on tuples which 'declare' the index variable
 291                as a constant for each iteration. */
 292             Expression * e = NULL;
 293
 294             if (init)
 295             {
 296                 if (! init->isVoidInitializer())
 297                 {
 298                     e = init->toExpression();
 299                     assert(e != NULL);
 300                 }
 301             }
 302             else
 303                 e = type->defaultInit();
 304
 305             if (e)
 306             {
 307                 DECL_INITIAL( var_decl ) = g.irs->assignValue(e, this);
 308                 if (! DECL_INITIAL(var_decl))
 309                     DECL_INITIAL( var_decl ) = e->toElem(g.irs);
 310             }
 311         }
 312
 313         // Can't set TREE_STATIC, etc. until we get to toObjFile as this could be
 314         // called from a varaible in an imported module
 315         // %% (out const X x) doesn't mean the reference is const...
 316         if (
 317 #if V2
 318             (isConst() || isInvariant()) && (storage_class & STCinit)
 319 #else
 320             isConst()
 321 #endif
 322             && ! gen.isDeclarationReferenceType( this )) {
 323             // %% CONST_DECLS don't have storage, so we can't use those,
 324             // but it would be nice to get the benefit of them (could handle in
 325             // VarExp -- makeAddressOf could switch back to the VAR_DECL
 326
 327             // if ( typs->isscalar() ) CONST_DECL...
 328
 329             TREE_READONLY( var_decl ) = 1;
 330             // can at least do this...
 331             //  const doesn't seem to matter for aggregates, so prevent problems..
 332             if ( type->isscalar() ) {
 333                 TREE_CONSTANT( var_decl ) = 1;
 334             }
 335         }
 336
 337 #if D_GCC_VER < 40
 338         // With cgraph, backend can figure it out (improves inline nested funcs?)
 339         if (
 340 #if V2
 341             nestedrefs.dim
 342 #else
 343             nestedref
 344 #endif
 345             && decl_kind != CONST_DECL) {
 346             DECL_NONLOCAL( var_decl ) = 1;
 347             TREE_ADDRESSABLE( var_decl ) = 1;
 348         }
 349
 350         TREE_USED( var_decl ) = 1;
 351 #endif
 352
 353
 354 #ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
 355         // Have to test for import first
 356         if (isImportedSymbol())
 357             gen.addDeclAttribute( var_decl, "dllimport" );
 358         else if (isExport())
 359             gen.addDeclAttribute( var_decl, "dllexport" );
 360 #endif
 361     }
 362     return csym;
 363 }
 364
 365 /*************************************
 366  */
 367
 368 Symbol *ClassInfoDeclaration::toSymbol()
 369 {
 370     return cd->toSymbol();
 371 }
 372
 373 /*************************************
 374  */
 375
 376 Symbol *ModuleInfoDeclaration::toSymbol()
 377 {
 378     return mod->toSymbol();
 379 }
 380
 381 /*************************************
 382  */
 383
 384 Symbol *TypeInfoDeclaration::toSymbol()
 385 {
 386     if ( ! csym ) {
 387         VarDeclaration::toSymbol();
 388
 389         // This variable is the static initialization for the
 390         // given TypeInfo.  It is the actual data, not a reference
 391         assert( TREE_CODE( TREE_TYPE( csym->Stree )) == REFERENCE_TYPE );
 392         TREE_TYPE( csym->Stree ) = TREE_TYPE( TREE_TYPE( csym->Stree ));
 393
 394         /* DMD makes typeinfo decls one-only by doing:
 395
 396             s->Sclass = SCcomdat;
 397
 398            in TypeInfoDeclaration::toObjFile.  The difference is
 399            that, in gdc, built-in typeinfo will be referenced as
 400            one-only.
 401         */
 402
 403
 404         D_DECL_ONE_ONLY( csym->Stree ) = 1;
 405         g.ofile->makeDeclOneOnly( csym->Stree );
 406     }
 407     return csym;
 408 }
 409
 410 /*************************************
 411  */
 412
 413 Symbol *FuncAliasDeclaration::toSymbol()
 414 {
 415     return funcalias->toSymbol();
 416 }
 417
 418 /*************************************
 419  */
 420
 421 // returns a FUNCTION_DECL tree
 422 Symbol *FuncDeclaration::toSymbol()
 423 {
 424     if (! csym) {
 425         csym  = new Symbol();
 426
 427         if (! isym) {
 428             tree id;
 429             //struct prod_token_parm_item* parm;
 430             //tree type_node;
 431             Type * func_type = tintro ? tintro : type;
 432             tree fn_decl;
 433             char * mangled_ident_str = 0;
 434             AggregateDeclaration * agg_decl;
 435
 436             if (ident) {
 437                 id = get_identifier(ident->string);
 438             } else {
 439                 // This happens for assoc array foreach bodies
 440
 441                 // Not sure if idents are strictly necc., but announce_function
 442                 //  dies without them.
 443
 444                 // %% better: use parent name
 445
 446                 static unsigned unamed_seq = 0;
 447                 char buf[64];
 448                 sprintf(buf, "___unamed_%u", ++unamed_seq);//%% sprintf
 449                 id = get_identifier(buf);
 450             }
 451
 452             tree fn_type = func_type->toCtype();
 453             dkeep(fn_type); /* TODO: fix this. we need to keep the type because
 454                                the creation of a method type below leaves this fn_type
 455                                unreferenced. maybe lang_specific.based_on */
 456
 457             tree vindex = NULL_TREE;
 458             if (isNested()) {
 459                 /* Even if DMD-style nested functions are not implemented, add an
 460                    extra argument to be compatible with delegates. */
 461
 462                 // irs->functionType(func_type, Type::tvoid);
 463                 fn_type = build_method_type(void_type_node, fn_type);
 464             } else if ( ( agg_decl = isMember() ) ) {
 465                 // Do this even if there is no debug info.  It is needed to make
 466                 // sure member functions are not called statically
 467                 if (isThis()) {
 468                     tree method_type = build_method_type(TREE_TYPE(agg_decl->handle->toCtype()), fn_type);
 469                     TYPE_ATTRIBUTES( method_type ) = TYPE_ATTRIBUTES( fn_type );
 470                     fn_type = method_type;
 471
 472                     if (isVirtual())
 473                         vindex = size_int(vtblIndex);
 474                 }
 475             } else if (isMain() && func_type->nextOf()->toBasetype()->ty == Tvoid) {
 476                 fn_type = build_function_type(integer_type_node, TYPE_ARG_TYPES(fn_type));
 477             }
 478
 479             // %%CHECK: is it okay for static nested functions to have a FUNC_DECL context?
 480             // seems okay so far...
 481
 482             fn_decl = build_decl( FUNCTION_DECL, id, fn_type );
 483             dkeep(fn_decl);
 484             if (ident) {
 485                 mangled_ident_str = mangle();
 486                 uniqueName(this, fn_decl, mangled_ident_str);
 487             }
 488             if (c_ident)
 489                 SET_DECL_ASSEMBLER_NAME(fn_decl, get_identifier(c_ident->string));
 490             // %% What about DECL_SECTION_NAME ?
 491             //DECL_ARGUMENTS(fn_decl) = NULL_TREE; // Probably don't need to do this until toObjFile
 492             DECL_CONTEXT (fn_decl) = gen.declContext(this); //context;
 493             if (vindex) {
 494                 DECL_VINDEX    (fn_decl) = vindex;
 495                 DECL_VIRTUAL_P (fn_decl) = 1;
 496             }
 497             if (! gen.functionNeedsChain(this)
 498     #if D_GCC_VER >= 40
 499                 // gcc 4.0: seems to be an error to set DECL_NO_STATIC_CHAIN on a toplevel function
 500                 // (tree-nest.c:1282:convert_all_function_calls)
 501                 && decl_function_context(fn_decl)
 502     #endif
 503                 ) {
 504                 // Prevent backend from thinking this is a nested function.
 505                 DECL_NO_STATIC_CHAIN( fn_decl ) = 1;
 506             }
 507             else
 508             {
 509                 /* If a template instance has a nested function (because
 510                    a template argument is a local variable), the nested
 511                    function may not have its toObjFile called before the
 512                    outer function is finished.  GCC requires that nested
 513                    functions be finished first so we need to arrange for
 514                    toObjFile to be called earlier.
 515
 516                    It may be possible to defer calling the outer
 517                    function's cgraph_finalize_function until all nested
 518                    functions are finished, but this will only work for
 519                    GCC >= 3.4. */
 520                 Dsymbol * p = this->parent;
 521                 FuncDeclaration * outer_func = NULL;
 522                 bool is_template_member = false;
 523                 while (p)
 524                 {
 525                     if (p->isTemplateInstance() && ! p->isTemplateMixin())
 526                     {
 527                         is_template_member = true;
 528                     }
 529                     else if ( (outer_func = p->isFuncDeclaration()) )
 530                         break;
 531                     p = p->parent;
 532                 }
 533                 if (is_template_member && outer_func)
 534                 {
 535                     Symbol * outer_sym = outer_func->toSymbol();
 536                     assert(outer_sym->outputStage != Finished);
 537                     if (! outer_sym->otherNestedFuncs)
 538                         outer_sym->otherNestedFuncs = new FuncDeclarations;
 539                     outer_sym->otherNestedFuncs->push(this);
 540                 }
 541             }
 542
 543             /* For now, inline asm means we can't inline (stack wouldn't be
 544                what was expected and LDASM labels aren't unique.)
 545                TODO: If the asm consists entirely
 546                of extended asm, we can allow inlining. */
 547             if (inlineAsm) {
 548                 DECL_UNINLINABLE(fn_decl) = 1;
 549             } else {
 550 #if D_GCC_VER >= 40
 551                 // see grokdeclarator in c-decl.c
 552                 if (flag_inline_trees == 2 && fbody /* && should_emit? */)
 553                     DECL_INLINE (fn_decl) = 1;
 554 #endif
 555             }
 556
 557             if (naked) {
 558                 D_DECL_NO_FRAME_POINTER( fn_decl ) = 1;
 559                 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT( fn_decl ) = 1;
 560
 561                 /* Need to do this or GCC will set up a frame pointer with -finline-functions.
 562                    Must have something to do with defered processing -- after we turn
 563                    flag_omit_frame_pointer back on. */
 564                 DECL_UNINLINABLE( fn_decl ) = 1;
 565             }
 566
 567 #ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
 568             // Have to test for import first
 569             if (isImportedSymbol())
 570                 gen.addDeclAttribute( fn_decl, "dllimport" );
 571             else if (isExport())
 572                 gen.addDeclAttribute( fn_decl, "dllexport" );
 573 #endif
 574
 575             g.ofile->setDeclLoc(fn_decl, this);
 576             g.ofile->setupSymbolStorage(this, fn_decl);
 577             if (! ident)
 578                 TREE_PUBLIC( fn_decl ) = 0;
 579
 580             TREE_USED (fn_decl) = 1; // %% Probably should be a little more intelligent about this
 581
 582             // if -mrtd is passed, how to handle this? handle in parsing or do
 583             // we go back and find out if linkage was specified
 584             switch (linkage)
 585             {
 586                 case LINKwindows:
 587                     gen.addDeclAttribute(fn_decl, "stdcall");
 588                     // The stdcall attribute also needs to be set on the function type.
 589                     assert( ((TypeFunction *) func_type)->linkage == LINKwindows );
 590                     break;
 591                 case LINKpascal:
 592                     // stdcall and reverse params?
 593                     break;
 594                 case LINKc:
 595                     // %% hack: on darwin (at least) using a DECL_EXTERNAL (IRState::getLibCallDecl)
 596                     // and TREE_STATIC FUNCTION_DECLs causes the stub label to be output twice.  This
 597                     // is a work around.  This doesn't handle the case in which the normal
 598                     // getLibCallDecl has already bee created and used.  Note that the problem only
 599                     // occurs with function inlining is used.
 600                     gen.replaceLibCallDecl(this);
 601                     break;
 602                 case LINKd:
 603                     // %% If x86, regparm(1)
 604                     // not sure if reg struct return
 605                     break;
 606                 case LINKcpp:
 607                     break;
 608                 default:
 609                     fprintf(stderr, "linkage = %d\n", linkage);
 610                     assert(0);
 611             }
 612
 613             csym->Sident = mangled_ident_str; // save for making thunks
 614             csym->Stree = fn_decl;
 615
 616             gen.maybeSetUpBuiltin(this);
 617         } else {
 618             csym->Stree = isym->Stree;
 619         }
 620     }
 621     return csym;
 622 }
 623
 624 #define D_PRIVATE_THUNKS 1
 625
 626 /*************************************
 627  */
 628 Symbol *FuncDeclaration::toThunkSymbol(target_ptrdiff_t offset)
 629 {
 630     Symbol *sthunk;
 631     Thunk * thunk;
 632
 633     toSymbol();
 634
 635     /* If the thunk is to be static (that is, it is being emitted in this
 636        module, there can only be one FUNCTION_DECL for it.   Thus, there
 637        is a list of all thunks for a given function. */
 638     if ( ! csym->thunks )
 639         csym->thunks = new Array;
 640     Array & thunks = * csym->thunks;
 641     bool found = false;
 642
 643     for (unsigned i = 0; i < thunks.dim; i++) {
 644         thunk = (Thunk *) thunks.data[i];
 645         if (thunk->offset == offset) {
 646             found = true;
 647             break;
 648         }
 649     }
 650
 651     if (! found) {
 652         thunk = new Thunk;
 653         thunk->offset = offset;
 654         thunks.push(thunk);
 655     }
 656
 657     if ( ! thunk->symbol ) {
 658         char *id;
 659         char *n;
 660         //type *t;
 661
 662         n = csym->Sident; // dmd uses 'sym' -- not sure what that is...
 663         id = (char *) alloca(8 + 5 + strlen(n) + 1);
 664         sprintf(id,"__t%"PRIdTSIZE"_%s", offset, n);
 665         sthunk = symbol_calloc(id);
 666         slist_add(sthunk);
 667         /* todo: could use anonymous names like DMD, with ASM_FORMAT_RRIVATE_NAME*/
 668         //sthunk = symbol_generate(SCstatic, csym->Stype);
 669         //sthunk->Sflags |= SFLimplem;
 670
 671         tree target_func_decl = csym->Stree;
 672         tree thunk_decl = build_decl(FUNCTION_DECL, get_identifier(id), TREE_TYPE( target_func_decl ));
 673         dkeep(thunk_decl);
 674         sthunk->Stree = thunk_decl;
 675
 676         //SET_DECL_ASSEMBLER_NAME(thunk_decl, DECL_NAME(thunk_decl));//old
 677         DECL_CONTEXT(thunk_decl) = DECL_CONTEXT(target_func_decl); // from c++...
 678         TREE_READONLY(thunk_decl) = TREE_READONLY(target_func_decl);
 679         TREE_THIS_VOLATILE(thunk_decl) = TREE_THIS_VOLATILE(target_func_decl);
 680
 681 #ifdef D_PRIVATE_THUNKS
 682         TREE_PRIVATE(thunk_decl) = 1;
 683 #else
 684         /* Due to changes in the assembler, it is not possible to emit
 685            a private thunk that refers to an external symbol.
 686            http://lists.gnu.org/archive/html/bug-binutils/2005-05/msg00002.html
 687         */
 688         DECL_EXTERNAL(thunk_decl) = DECL_EXTERNAL(target_func_decl);
 689         TREE_STATIC(thunk_decl) = TREE_STATIC(target_func_decl);
 690         TREE_PRIVATE(thunk_decl) = TREE_PRIVATE(target_func_decl);
 691         TREE_PUBLIC(thunk_decl) = TREE_PUBLIC(target_func_decl);
 692 #endif
 693
 694         DECL_ARTIFICIAL(thunk_decl) = 1;
 695         DECL_IGNORED_P(thunk_decl) = 1;
 696         DECL_NO_STATIC_CHAIN(thunk_decl) = 1;
 697         DECL_INLINE(thunk_decl) = 0;
 698         DECL_DECLARED_INLINE_P(thunk_decl) = 0;
 699         //needed on some targets to avoid "causes a section type conflict"
 700         D_DECL_ONE_ONLY(thunk_decl) = D_DECL_ONE_ONLY(target_func_decl);
 701         if ( D_DECL_ONE_ONLY(thunk_decl) )
 702             g.ofile->makeDeclOneOnly(thunk_decl);
 703
 704         TREE_ADDRESSABLE(thunk_decl) = 1;
 705         TREE_USED (thunk_decl) = 1;
 706
 707 #ifdef D_PRIVATE_THUNKS
 708         //g.ofile->prepareSymbolOutput(sthunk);
 709         g.ofile->doThunk(thunk_decl, target_func_decl, offset);
 710 #else
 711         if ( TREE_STATIC(thunk_decl) )
 712             g.ofile->doThunk(thunk_decl, target_func_decl, offset);
 713 #endif
 714
 715         thunk->symbol = sthunk;
 716     }
 717     return thunk->symbol;
 718 }
 719
 720
 721 /****************************************
 722  * Create a static symbol we can hang DT initializers onto.
 723  */
 724
 725 Symbol *static_sym()
 726 {
 727     Symbol * s = symbol_tree(NULL_TREE);
 728     //OLD//s->Sfl = FLstatic_sym;
 729     /* Before GCC 4.0, it was possible to take the address of a CONSTRUCTOR
 730        marked TREE_STATIC and the backend would output the data as an
 731        anonymous symbol.  This doesn't work in 4.0.  To keep things, simple,
 732        the same method is used for <4.0 and >= 4.0. */
 733     // Can't build the VAR_DECL because the type is unknown
 734     slist_add(s);
 735     return s;
 736 }
 737
 738 /**************************************
 739  * Fake a struct symbol.
 740  */
 741
 742 // Not used in GCC
 743 /*
 744 Classsym *fake_classsym(char * name)
 745 {
 746     return 0;
 747 }
 748 */
 749
 750 /*************************************
 751  * Create the "ClassInfo" symbol
 752  */
 753
 754 Symbol *ClassDeclaration::toSymbol()
 755 {
 756     if (! csym)
 757     {
 758         tree decl;
 759         csym = toSymbolX("__Class", SCextern, 0, "Z");
 760         slist_add(csym);
 761         decl = build_decl( VAR_DECL, get_identifier( csym->Sident ),
 762             TREE_TYPE( ClassDeclaration::classinfo->type->toCtype() )); // want the RECORD_TYPE, not the REFERENCE_TYPE
 763         csym->Stree = decl;
 764         dkeep(decl);
 765
 766         g.ofile->setupStaticStorage(this, decl);
 767
 768         TREE_CONSTANT( decl ) = 0; // DMD puts this into .data, not .rodata...
 769         TREE_READONLY( decl ) = 0;
 770     }
 771     return csym;
 772 }
 773
 774 /*************************************
 775  * Create the "InterfaceInfo" symbol
 776  */
 777
 778 Symbol *InterfaceDeclaration::toSymbol()
 779 {
 780     if (!csym)
 781     {
 782         csym = ClassDeclaration::toSymbol();
 783         tree decl = csym->Stree;
 784
 785         Symbol * temp_sym = toSymbolX("__Interface", SCextern, 0, "Z");
 786         DECL_NAME( decl ) = get_identifier( temp_sym->Sident );
 787         delete temp_sym;
 788
 789         TREE_CONSTANT( decl ) = 1; // Interface ClassInfo images are in .rodata, but classes arent..?
 790     }
 791     return csym;
 792 }
 793
 794 /*************************************
 795  * Create the "ModuleInfo" symbol
 796  */
 797
 798 Symbol *Module::toSymbol()
 799 {
 800     if (!csym)
 801     {
 802         Type * some_type;
 803
 804         /* This causes problems  .. workaround
 805            is to call moduleinfo->toCtype() before we start processing
 806            decls in genobjfile. ...
 807
 808             if (moduleinfo) {
 809                 some_type = moduleinfo->type;
 810             } else {
 811                 some_type = gen.getObjectType();
 812             }
 813         */
 814         some_type = gen.getObjectType();
 815
 816         csym = toSymbolX("__ModuleInfo", SCextern, 0, "Z");
 817         slist_add(csym);
 818
 819         tree decl = build_decl(VAR_DECL, get_identifier(csym->Sident),
 820             TREE_TYPE(some_type->toCtype())); // want the RECORD_TYPE, not the REFERENCE_TYPE
 821         csym->Stree = decl;
 822
 823         dkeep(decl);
 824
 825         g.ofile->setupStaticStorage(this, decl);
 826
 827         TREE_CONSTANT( decl ) = 0; // *not* readonly, moduleinit depends on this
 828         TREE_READONLY( decl ) = 0; // Not an lvalue, tho
 829     }
 830     return csym;
 831 }
 832
 833 /*************************************
 834  * This is accessible via the ClassData, but since it is frequently
 835  * needed directly (like for rtti comparisons), make it directly accessible.
 836  */
 837
 838 Symbol *ClassDeclaration::toVtblSymbol()
 839 {
 840     if (!vtblsym)
 841     {
 842         tree decl;
 843
 844         vtblsym = toSymbolX("__vtbl", SCextern, 0, "Z");
 845         slist_add(vtblsym);
 846
 847         /* The DECL_INITIAL value will have a different type object from the
 848            VAR_DECL.  The back end seems to accept this. */
 849         TypeSArray * vtbl_type = new TypeSArray(Type::tvoid->pointerTo(),
 850             new IntegerExp(loc, vtbl.dim, Type::tindex));
 851
 852         decl = build_decl( VAR_DECL, get_identifier( vtblsym->Sident ), vtbl_type->toCtype() );
 853         vtblsym->Stree = decl;
 854         dkeep(decl);
 855
 856         g.ofile->setupStaticStorage(this, decl);
 857
 858         TREE_READONLY( decl ) = 1;
 859         TREE_CONSTANT( decl ) = 1;
 860         TREE_ADDRESSABLE( decl ) = 1;
 861         // from cp/class.c
 862         DECL_CONTEXT (decl) =  TREE_TYPE( type->toCtype() );
 863         DECL_VIRTUAL_P (decl) = 1;
 864         DECL_ALIGN (decl) = TARGET_VTABLE_ENTRY_ALIGN;
 865     }
 866     return vtblsym;
 867 }
 868
 869 /**********************************
 870  * Create the static initializer for the struct/class.
 871  */
 872
 873 /* Because this is called from the front end (mtype.cc:TypeStruct::defaultInit()),
 874    we need to hold off using back-end stuff until the toobjfile phase.
 875
 876    Specifically, it is not safe create a VAR_DECL with a type from toCtype()
 877    because there may be unresolved recursive references.
 878    StructDeclaration::toObjFile calls toInitializer without ever calling
 879    SymbolDeclaration::toSymbol, so we just need to keep checking if we
 880    are in the toObjFile phase.
 881 */
 882
 883 Symbol *AggregateDeclaration::toInitializer()
 884 {
 885     Symbol *s;
 886
 887     if (!sinit)
 888     {
 889         s = toSymbolX("__init", SCextern, 0, "Z");
 890         slist_add(s);
 891         sinit = s;
 892     }
 893     if (! sinit->Stree && g.ofile != NULL)
 894     {
 895         tree struct_type = type->toCtype();
 896         if ( POINTER_TYPE_P( struct_type ) )
 897             struct_type = TREE_TYPE( struct_type ); // for TypeClass, want the RECORD_TYPE, not the REFERENCE_TYPE
 898         tree t = build_decl(VAR_DECL, get_identifier(sinit->Sident), struct_type);
 899         sinit->Stree = t;
 900         dkeep(t);
 901
 902         g.ofile->setupStaticStorage(this, t);
 903
 904         // %% what's the diff between setting this stuff on the DECL and the
 905         // CONSTRUCTOR itself?
 906
 907         TREE_ADDRESSABLE( t ) = 1;
 908         TREE_CONSTANT( t ) = 1;
 909         TREE_READONLY( t ) = 1;
 910         DECL_CONTEXT( t ) = 0; // These are always global
 911     }
 912     return sinit;
 913 }
 914
 915 Symbol *TypedefDeclaration::toInitializer()
 916 {
 917     Symbol *s;
 918
 919     if (!sinit)
 920     {
 921         s = toSymbolX("__init", SCextern, 0, "Z");
 922         s->Sfl = FLextern;
 923         s->Sflags |= SFLnodebug;
 924         slist_add(s);
 925         sinit = s;
 926         sinit->Sdt = ((TypeTypedef *)type)->sym->init->toDt();
 927     }
 928     return sinit;
 929 }
 930
 931 Symbol *EnumDeclaration::toInitializer()
 932 {
 933     Symbol *s;
 934
 935     if (!sinit)
 936     {
 937         Identifier *ident_save = ident;
 938         if (!ident)
 939         {   static int num;
 940             char name[6 + sizeof(num) * 3 + 1];
 941             snprintf(name, sizeof(name), "__enum%d", ++num);
 942             ident = Lexer::idPool(name);
 943         }
 944         s = toSymbolX("__init", SCextern, 0, "Z");
 945         ident = ident_save;
 946         s->Sfl = FLextern;
 947         s->Sflags |= SFLnodebug;
 948         slist_add(s);
 949         sinit = s;
 950     }
 951     if (! sinit->Stree && g.ofile != NULL)
 952     {
 953         tree t = build_decl(VAR_DECL, get_identifier(sinit->Sident), type->toCtype());
 954         sinit->Stree = t;
 955         dkeep(t);
 956
 957         g.ofile->setupStaticStorage(this, t);
 958         TREE_CONSTANT( t ) = 1;
 959         TREE_READONLY( t ) = 1;
 960         DECL_CONTEXT( t ) = 0;
 961     }
 962     return sinit;
 963 }
 964
 965
 966 /******************************************
 967  */
 968
 969 Symbol *Module::toModuleAssert()
 970 {
 971     // Not used in GCC
 972     return 0;
 973 }
 974
 975 /******************************************
 976  */
 977
 978 Symbol *Module::toModuleArray()
 979 {
 980     // Not used in GCC (all array bounds checks are inlined)
 981     return 0;
 982 }
 983
 984 /********************************************
 985  * Determine the right symbol to look up
 986  * an associative array element.
 987  * Input:
 988  *      flags   0       don't add value signature
 989  *              1       add value signature
 990  */
 991
 992 Symbol *TypeAArray::aaGetSymbol(char *func, int flags)
 993 {
 994     // This is not used in GCC (yet?)
 995     return 0;
 996 }
 997