dmd2/tocsym.c

   1
   2 // Compiler implementation of the D programming language
   3 // Copyright (c) 1999-2007 by Digital Mars
   4 // All Rights Reserved
   5 // written by Walter Bright
   6 // http://www.digitalmars.com
   7 // License for redistribution is by either the Artistic License
   8 // in artistic.txt, or the GNU General Public License in gnu.txt.
   9 // See the included readme.txt for details.
  10
  11 #include <stdio.h>
  12 #include <stddef.h>
  13 #include <time.h>
  14 #include <assert.h>
  15 #include "gdc_alloca.h"
  16
  17 #include "mars.h"
  18 #include "module.h"
  19 #include "mtype.h"
  20 #include "declaration.h"
  21 #include "statement.h"
  22 #include "enum.h"
  23 #include "aggregate.h"
  24 #include "init.h"
  25 #include "attrib.h"
  26 #include "lexer.h"
  27 #include "dsymbol.h"
  28 #include "id.h"
  29
  30 #include <mem.h>
  31
  32 // Back end
  33 #include "cc.h"
  34 #include "global.h"
  35 #include "oper.h"
  36 #include "code.h"
  37 #include "type.h"
  38 #include "dt.h"
  39 #include "cgcv.h"
  40 #include "outbuf.h"
  41 #include "irstate.h"
  42
  43 void slist_add(Symbol *s);
  44 void slist_reset();
  45
  46 Classsym *fake_classsym(Identifier *id);
  47
  48 /********************************* SymbolDeclaration ****************************/
  49
  50 SymbolDeclaration::SymbolDeclaration(Loc loc, Symbol *s, StructDeclaration *dsym)
  51     : Declaration(new Identifier(s->Sident, TOKidentifier))
  52 {
  53     this->loc = loc;
  54     sym = s;
  55     this->dsym = dsym;
  56     storage_class |= STCconst;
  57 }
  58
  59 Symbol *SymbolDeclaration::toSymbol()
  60 {
  61     return sym;
  62 }
  63
  64 /*************************************
  65  * Helper
  66  */
  67
  68 Symbol *Dsymbol::toSymbolX(const char *prefix, int sclass, type *t, const char *suffix)
  69 {
  70     Symbol *s;
  71     char *id;
  72     char *n;
  73     size_t nlen;
  74
  75     //printf("Dsymbol::toSymbolX('%s')\n", prefix);
  76     n = mangle();
  77     assert(n);
  78     nlen = strlen(n);
  79 #if 0
  80     if (nlen > 2 && n[0] == '_' && n[1] == 'D')
  81     {
  82         nlen -= 2;
  83         n += 2;
  84     }
  85 #endif
  86     id = (char *) alloca(2 + nlen + sizeof(size_t) * 3 + strlen(prefix) + strlen(suffix) + 1);
  87     sprintf(id,"_D%s%d%s%s", n, strlen(prefix), prefix, suffix);
  88 #if 0
  89     if (global.params.isWindows &&
  90         (type_mangle(t) == mTYman_c || type_mangle(t) == mTYman_std))
  91         id++;                   // Windows C mangling will put the '_' back in
  92 #endif
  93     s = symbol_name(id, sclass, t);
  94     //printf("-Dsymbol::toSymbolX() %s\n", id);
  95     return s;
  96 }
  97
  98 /*************************************
  99  */
 100
 101 Symbol *Dsymbol::toSymbol()
 102 {
 103     fprintf(stderr, "Dsymbol::toSymbol() '%s', kind = '%s'\n", toChars(), kind());
 104 #ifdef DEBUG
 105     halt();
 106 #endif
 107     assert(0);          // BUG: implement
 108     return NULL;
 109 }
 110
 111 /*********************************
 112  * Generate import symbol from symbol.
 113  */
 114
 115 Symbol *Dsymbol::toImport()
 116 {
 117     if (!isym)
 118     {
 119         if (!csym)
 120             csym = toSymbol();
 121         isym = toImport(csym);
 122     }
 123     return isym;
 124 }
 125
 126 /*************************************
 127  */
 128
 129 Symbol *Dsymbol::toImport(Symbol *sym)
 130 {
 131     char *id;
 132     char *n;
 133     Symbol *s;
 134     type *t;
 135
 136     //printf("Dsymbol::toImport('%s')\n", sym->Sident);
 137     n = sym->Sident;
 138     id = (char *) alloca(6 + strlen(n) + 1 + sizeof(type_paramsize(sym->Stype))*3 + 1);
 139     if (sym->Stype->Tmangle == mTYman_std && tyfunc(sym->Stype->Tty))
 140     {
 141         sprintf(id,"_imp__%s@%d",n,type_paramsize(sym->Stype));
 142     }
 143     else if (sym->Stype->Tmangle == mTYman_d)
 144         sprintf(id,"_imp_%s",n);
 145     else
 146         sprintf(id,"_imp__%s",n);
 147     t = type_alloc(TYnptr | mTYconst);
 148     t->Tnext = sym->Stype;
 149     t->Tnext->Tcount++;
 150     t->Tmangle = mTYman_c;
 151     t->Tcount++;
 152     s = symbol_calloc(id);
 153     s->Stype = t;
 154     s->Sclass = SCextern;
 155     s->Sfl = FLextern;
 156     slist_add(s);
 157     return s;
 158 }
 159
 160 /*************************************
 161  */
 162
 163 Symbol *VarDeclaration::toSymbol()
 164 {
 165     //printf("VarDeclaration::toSymbol(%s)\n", toChars());
 166     //if (needThis()) *(char*)0=0;
 167     assert(!needThis());
 168     if (!csym)
 169     {   Symbol *s;
 170         TYPE *t;
 171         const char *id;
 172         mangle_t m = 0;
 173
 174         if (isDataseg())
 175             id = mangle();
 176         else
 177             id = ident->toChars();
 178         s = symbol_calloc(id);
 179
 180         if (storage_class & (STCout | STCref))
 181         {
 182             if (global.params.symdebug && storage_class & STCparameter)
 183             {
 184                 t = type_alloc(TYnptr);         // should be TYref, but problems in back end
 185                 t->Tnext = type->toCtype();
 186                 t->Tnext->Tcount++;
 187             }
 188             else
 189                 t = type_fake(TYnptr);
 190         }
 191         else if (storage_class & STClazy)
 192             t = type_fake(TYullong);            // Tdelegate as C type
 193         else if (isParameter())
 194             t = type->toCParamtype();
 195         else
 196             t = type->toCtype();
 197         t->Tcount++;
 198
 199         if (isDataseg())
 200         {
 201             if (storage_class & STCtls)
 202             {   /* Thread local storage
 203                  */
 204                 type_setty(&t, t->Tty | mTYthread);
 205             }
 206             s->Sclass = SCextern;
 207             s->Sfl = FLextern;
 208             slist_add(s);
 209         }
 210         else
 211         {
 212             s->Sclass = SCauto;
 213             s->Sfl = FLauto;
 214
 215             if (nestedrefs.dim)
 216             {
 217                 /* Symbol is accessed by a nested function. Make sure
 218                  * it is not put in a register, and that the optimizer
 219                  * assumes it is modified across function calls and pointer
 220                  * dereferences.
 221                  */
 222                 //printf("\tnested ref, not register\n");
 223                 type_setcv(&t, t->Tty | mTYvolatile);
 224             }
 225         }
 226         if (isConst() || isInvariant())
 227         {
 228             // Insert const modifiers
 229             type_setcv(&t, t->Tty | mTYconst);
 230         }
 231         switch (linkage)
 232         {
 233             case LINKwindows:
 234                 m = mTYman_std;
 235                 break;
 236
 237             case LINKpascal:
 238                 m = mTYman_pas;
 239                 break;
 240
 241             case LINKc:
 242                 m = mTYman_c;
 243                 break;
 244
 245             case LINKd:
 246                 m = mTYman_d;
 247                 break;
 248
 249             case LINKcpp:
 250                 m = mTYman_cpp;
 251                 break;
 252
 253             default:
 254                 fprintf(stderr, "linkage = %d\n", linkage);
 255                 assert(0);
 256         }
 257         type_setmangle(&t, m);
 258         s->Stype = t;
 259
 260         csym = s;
 261     }
 262     return csym;
 263 }
 264
 265 /*************************************
 266  */
 267
 268 Symbol *ClassInfoDeclaration::toSymbol()
 269 {
 270     return cd->toSymbol();
 271 }
 272
 273 /*************************************
 274  */
 275
 276 Symbol *ModuleInfoDeclaration::toSymbol()
 277 {
 278     return mod->toSymbol();
 279 }
 280
 281 /*************************************
 282  */
 283
 284 Symbol *TypeInfoDeclaration::toSymbol()
 285 {
 286     //printf("TypeInfoDeclaration::toSymbol(%s), linkage = %d\n", toChars(), linkage);
 287     return VarDeclaration::toSymbol();
 288 }
 289
 290 /*************************************
 291  */
 292
 293 Symbol *FuncAliasDeclaration::toSymbol()
 294 {
 295     return funcalias->toSymbol();
 296 }
 297
 298 /*************************************
 299  */
 300
 301 Symbol *FuncDeclaration::toSymbol()
 302 {
 303     if (!csym)
 304     {   Symbol *s;
 305         TYPE *t;
 306         const char *id;
 307
 308 #if 0
 309         id = ident->toChars();
 310 #else
 311         id = mangle();
 312 #endif
 313         //printf("FuncDeclaration::toSymbol(%s %s)\n", kind(), toChars());
 314         //printf("\tid = '%s'\n", id);
 315         //printf("\ttype = %s\n", type->toChars());
 316         s = symbol_calloc(id);
 317         slist_add(s);
 318
 319         {
 320             s->Sclass = SCglobal;
 321             symbol_func(s);
 322             func_t *f = s->Sfunc;
 323             if (isVirtual())
 324                 f->Fflags |= Fvirtual;
 325             else if (isMember2())
 326                 f->Fflags |= Fstatic;
 327             f->Fstartline.Slinnum = loc.linnum;
 328             f->Fstartline.Sfilename = loc.filename;
 329             if (endloc.linnum)
 330             {   f->Fendline.Slinnum = endloc.linnum;
 331                 f->Fendline.Sfilename = endloc.filename;
 332             }
 333             else
 334             {   f->Fendline.Slinnum = loc.linnum;
 335                 f->Fendline.Sfilename = loc.filename;
 336             }
 337             t = type->toCtype();
 338         }
 339
 340         mangle_t msave = t->Tmangle;
 341         if (isMain())
 342         {
 343             t->Tty = TYnfunc;
 344             t->Tmangle = mTYman_c;
 345         }
 346         else
 347         {
 348             switch (linkage)
 349             {
 350                 case LINKwindows:
 351                     t->Tmangle = mTYman_std;
 352                     break;
 353
 354                 case LINKpascal:
 355                     t->Tty = TYnpfunc;
 356                     t->Tmangle = mTYman_pas;
 357                     break;
 358
 359                 case LINKc:
 360                     t->Tmangle = mTYman_c;
 361                     break;
 362
 363                 case LINKd:
 364                     t->Tmangle = mTYman_d;
 365                     break;
 366
 367                 case LINKcpp:
 368                 {   t->Tmangle = mTYman_cpp;
 369 #if !TARGET_LINUX
 370                     if (isThis())
 371                         t->Tty = TYmfunc;
 372 #endif
 373                     s->Sflags |= SFLpublic;
 374                     Dsymbol *parent = toParent();
 375                     ClassDeclaration *cd = parent->isClassDeclaration();
 376                     if (cd)
 377                     {
 378                         ::type *t = cd->type->toCtype();
 379                         s->Sscope = t->Tnext->Ttag;
 380                     }
 381                     break;
 382                 }
 383                 default:
 384                     fprintf(stderr, "linkage = %d\n", linkage);
 385                     assert(0);
 386             }
 387         }
 388         if (msave)
 389             assert(msave == t->Tmangle);
 390         //printf("Tty = %x, mangle = x%x\n", t->Tty, t->Tmangle);
 391         t->Tcount++;
 392         s->Stype = t;
 393         //s->Sfielddef = this;
 394
 395         csym = s;
 396     }
 397     return csym;
 398 }
 399
 400 /*************************************
 401  */
 402
 403 Symbol *FuncDeclaration::toThunkSymbol(int offset)
 404 {
 405     Symbol *sthunk;
 406
 407     toSymbol();
 408
 409 #if 0
 410     char *id;
 411     char *n;
 412     type *t;
 413
 414     n = sym->Sident;
 415     id = (char *) alloca(8 + 5 + strlen(n) + 1);
 416     sprintf(id,"_thunk%d__%s", offset, n);
 417     s = symbol_calloc(id);
 418     slist_add(s);
 419     s->Stype = csym->Stype;
 420     s->Stype->Tcount++;
 421 #endif
 422     sthunk = symbol_generate(SCstatic, csym->Stype);
 423     sthunk->Sflags |= SFLimplem;
 424     cod3_thunk(sthunk, csym, 0, TYnptr, -offset, -1, 0);
 425     return sthunk;
 426 }
 427
 428
 429 /****************************************
 430  * Create a static symbol we can hang DT initializers onto.
 431  */
 432
 433 Symbol *static_sym()
 434 {
 435     Symbol *s;
 436     type *t;
 437
 438     t = type_alloc(TYint);
 439     t->Tcount++;
 440     s = symbol_calloc("internal");
 441     s->Sclass = SCstatic;
 442     s->Sfl = FLextern;
 443     s->Sflags |= SFLnodebug;
 444     s->Stype = t;
 445 #if ELFOBJ // Burton
 446     s->Sseg = DATA;
 447 #endif /* ELFOBJ */
 448     slist_add(s);
 449     return s;
 450 }
 451
 452 /**************************************
 453  * Fake a struct symbol.
 454  */
 455
 456 Classsym *fake_classsym(Identifier *id)
 457 {   TYPE *t;
 458     Classsym *scc;
 459
 460     scc = (Classsym *)symbol_calloc(id->toChars());
 461     scc->Sclass = SCstruct;
 462     scc->Sstruct = struct_calloc();
 463     scc->Sstruct->Sstructalign = 8;
 464     //scc->Sstruct->ptrtype = TYnptr;
 465     scc->Sstruct->Sflags = STRglobal;
 466
 467     t = type_alloc(TYstruct);
 468     t->Tflags |= TFsizeunknown | TFforward;
 469     t->Ttag = scc;              // structure tag name
 470     assert(t->Tmangle == 0);
 471     t->Tmangle = mTYman_d;
 472     t->Tcount++;
 473     scc->Stype = t;
 474     slist_add(scc);
 475     return scc;
 476 }
 477
 478 /*************************************
 479  * Create the "ClassInfo" symbol
 480  */
 481
 482 static Classsym *scc;
 483
 484 Symbol *ClassDeclaration::toSymbol()
 485 {
 486     if (!csym)
 487     {
 488         Symbol *s;
 489
 490         if (!scc)
 491             scc = fake_classsym(Id::ClassInfo);
 492
 493         s = toSymbolX("__Class", SCextern, scc->Stype, "Z");
 494         s->Sfl = FLextern;
 495         s->Sflags |= SFLnodebug;
 496         csym = s;
 497         slist_add(s);
 498     }
 499     return csym;
 500 }
 501
 502 /*************************************
 503  * Create the "InterfaceInfo" symbol
 504  */
 505
 506 Symbol *InterfaceDeclaration::toSymbol()
 507 {
 508     if (!csym)
 509     {
 510         Symbol *s;
 511
 512         if (!scc)
 513             scc = fake_classsym(Id::ClassInfo);
 514
 515         s = toSymbolX("__Interface", SCextern, scc->Stype, "Z");
 516         s->Sfl = FLextern;
 517         s->Sflags |= SFLnodebug;
 518         csym = s;
 519         slist_add(s);
 520     }
 521     return csym;
 522 }
 523
 524 /*************************************
 525  * Create the "ModuleInfo" symbol
 526  */
 527
 528 Symbol *Module::toSymbol()
 529 {
 530     if (!csym)
 531     {
 532         Symbol *s;
 533         static Classsym *scc;
 534
 535         if (!scc)
 536             scc = fake_classsym(Id::ClassInfo);
 537
 538         s = toSymbolX("__ModuleInfo", SCextern, scc->Stype, "Z");
 539         s->Sfl = FLextern;
 540         s->Sflags |= SFLnodebug;
 541         csym = s;
 542         slist_add(s);
 543     }
 544     return csym;
 545 }
 546
 547 /*************************************
 548  * This is accessible via the ClassData, but since it is frequently
 549  * needed directly (like for rtti comparisons), make it directly accessible.
 550  */
 551
 552 Symbol *ClassDeclaration::toVtblSymbol()
 553 {
 554     if (!vtblsym)
 555     {
 556         Symbol *s;
 557         TYPE *t;
 558
 559         if (!csym)
 560             toSymbol();
 561
 562         t = type_alloc(TYnptr | mTYconst);
 563         t->Tnext = tsvoid;
 564         t->Tnext->Tcount++;
 565         t->Tmangle = mTYman_d;
 566         s = toSymbolX("__vtbl", SCextern, t, "Z");
 567         s->Sflags |= SFLnodebug;
 568         s->Sfl = FLextern;
 569         vtblsym = s;
 570         slist_add(s);
 571     }
 572     return vtblsym;
 573 }
 574
 575 /**********************************
 576  * Create the static initializer for the struct/class.
 577  */
 578
 579 Symbol *AggregateDeclaration::toInitializer()
 580 {
 581     Symbol *s;
 582     Classsym *stag;
 583
 584     if (!sinit)
 585     {
 586         stag = fake_classsym(Id::ClassInfo);
 587         s = toSymbolX("__init", SCextern, stag->Stype, "Z");
 588         s->Sfl = FLextern;
 589         s->Sflags |= SFLnodebug;
 590         slist_add(s);
 591         sinit = s;
 592     }
 593     return sinit;
 594 }
 595
 596 Symbol *TypedefDeclaration::toInitializer()
 597 {
 598     Symbol *s;
 599     Classsym *stag;
 600
 601     if (!sinit)
 602     {
 603         stag = fake_classsym(Id::ClassInfo);
 604         s = toSymbolX("__init", SCextern, stag->Stype, "Z");
 605         s->Sfl = FLextern;
 606         s->Sflags |= SFLnodebug;
 607         slist_add(s);
 608         sinit = s;
 609     }
 610     return sinit;
 611 }
 612
 613 Symbol *EnumDeclaration::toInitializer()
 614 {
 615     Symbol *s;
 616     Classsym *stag;
 617
 618     if (!sinit)
 619     {
 620         stag = fake_classsym(Id::ClassInfo);
 621         Identifier *ident_save = ident;
 622         if (!ident)
 623             ident = Lexer::uniqueId("__enum");
 624         s = toSymbolX("__init", SCextern, stag->Stype, "Z");
 625         ident = ident_save;
 626         s->Sfl = FLextern;
 627         s->Sflags |= SFLnodebug;
 628         slist_add(s);
 629         sinit = s;
 630     }
 631     return sinit;
 632 }
 633
 634
 635 /******************************************
 636  */
 637
 638 Symbol *Module::toModuleAssert()
 639 {
 640     if (!massert)
 641     {
 642         type *t;
 643
 644         t = type_alloc(TYjfunc);
 645         t->Tflags |= TFprototype | TFfixed;
 646         t->Tmangle = mTYman_d;
 647         t->Tnext = tsvoid;
 648         tsvoid->Tcount++;
 649
 650         massert = toSymbolX("__assert", SCextern, t, "FiZv");
 651         massert->Sfl = FLextern;
 652         massert->Sflags |= SFLnodebug;
 653         slist_add(massert);
 654     }
 655     return massert;
 656 }
 657
 658 /******************************************
 659  */
 660
 661 Symbol *Module::toModuleArray()
 662 {
 663     if (!marray)
 664     {
 665         type *t;
 666
 667         t = type_alloc(TYjfunc);
 668         t->Tflags |= TFprototype | TFfixed;
 669         t->Tmangle = mTYman_d;
 670         t->Tnext = tsvoid;
 671         tsvoid->Tcount++;
 672
 673         marray = toSymbolX("__array", SCextern, t, "Z");
 674         marray->Sfl = FLextern;
 675         marray->Sflags |= SFLnodebug;
 676         slist_add(marray);
 677     }
 678     return marray;
 679 }
 680
 681 /********************************************
 682  * Determine the right symbol to look up
 683  * an associative array element.
 684  * Input:
 685  *      flags   0       don't add value signature
 686  *              1       add value signature
 687  */
 688
 689 Symbol *TypeAArray::aaGetSymbol(char *func, int flags)
 690 #if __DMC__
 691     __in
 692     {
 693         assert(func);
 694         assert((flags & ~1) == 0);
 695     }
 696     __out (result)
 697     {
 698         assert(result);
 699     }
 700     __body
 701 #endif
 702     {
 703         int sz;
 704         char *id;
 705         type *t;
 706         Symbol *s;
 707         int i;
 708
 709         // Dumb linear symbol table - should use associative array!
 710         static Array *sarray = NULL;
 711
 712         //printf("aaGetSymbol(func = '%s', flags = %d, key = %p)\n", func, flags, key);
 713 #if 0
 714         OutBuffer buf;
 715         key->toKeyBuffer(&buf);
 716
 717         sz = next->size();              // it's just data, so we only care about the size
 718         sz = (sz + 3) & ~3;             // reduce proliferation of library routines
 719         id = (char *)alloca(3 + strlen(func) + buf.offset + sizeof(sz) * 3 + 1);
 720         buf.writeByte(0);
 721         if (flags & 1)
 722             sprintf(id, "_aa%s%s%d", func, buf.data, sz);
 723         else
 724             sprintf(id, "_aa%s%s", func, buf.data);
 725 #else
 726         id = (char *)alloca(3 + strlen(func) + 1);
 727         sprintf(id, "_aa%s", func);
 728 #endif
 729         if (!sarray)
 730             sarray = new Array();
 731
 732         // See if symbol is already in sarray
 733         for (i = 0; i < sarray->dim; i++)
 734         {   s = (Symbol *)sarray->data[i];
 735             if (strcmp(id, s->Sident) == 0)
 736                 return s;                       // use existing Symbol
 737         }
 738
 739         // Create new Symbol
 740
 741         s = symbol_calloc(id);
 742         slist_add(s);
 743         s->Sclass = SCextern;
 744         s->Ssymnum = -1;
 745         symbol_func(s);
 746
 747         t = type_alloc(TYnfunc);
 748         t->Tflags = TFprototype | TFfixed;
 749         t->Tmangle = mTYman_c;
 750         t->Tparamtypes = NULL;
 751         t->Tnext = next->toCtype();
 752         t->Tnext->Tcount++;
 753         t->Tcount++;
 754         s->Stype = t;
 755
 756         sarray->push(s);                        // remember it
 757         return s;
 758     }
 759