dmd2/typinf.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 /* NOTE: This file has been patched from the original DMD distribution to
  12    work with the GDC compiler.
  13
  14    Modified by David Friedman, September 2004
  15 */
  16
  17 #include <stdio.h>
  18 #include <assert.h>
  19
  20 //#include "mem.h"
  21
  22 #include "mars.h"
  23 #include "module.h"
  24 #include "mtype.h"
  25 #include "scope.h"
  26 #include "init.h"
  27 #include "expression.h"
  28 #include "attrib.h"
  29 #include "declaration.h"
  30 #include "template.h"
  31 #include "id.h"
  32 #include "enum.h"
  33 #include "import.h"
  34 #include "aggregate.h"
  35
  36 #include <mem.h>
  37 #ifndef IN_GCC
  38 #include "cc.h"
  39 #include "global.h"
  40 #include "oper.h"
  41 #include "code.h"
  42 #include "type.h"
  43 #include "dt.h"
  44 #include "cgcv.h"
  45 #include "outbuf.h"
  46 #include "irstate.h"
  47 #else
  48 #include "symbol.h"
  49 #include "dt.h"
  50 #include "d-dmd-gcc.h"
  51 #endif
  52
  53 extern Symbol *static_sym();
  54
  55 /*******************************************
  56  * Get a canonicalized form of the TypeInfo for use with the internal
  57  * runtime library routines. Canonicalized in that static arrays are
  58  * represented as dynamic arrays, enums are represented by their
  59  * underlying type, etc. This reduces the number of TypeInfo's needed,
  60  * so we can use the custom internal ones more.
  61  */
  62
  63 Expression *Type::getInternalTypeInfo(Scope *sc)
  64 {   TypeInfoDeclaration *tid;
  65     Expression *e;
  66     Type *t;
  67     static TypeInfoDeclaration *internalTI[TMAX];
  68
  69     //printf("Type::getInternalTypeInfo() %s\n", toChars());
  70     t = toBasetype();
  71     switch (t->ty)
  72     {
  73         case Tsarray:
  74 #if 0
  75             // convert to corresponding dynamic array type
  76             t = t->nextOf()->mutableOf()->arrayOf();
  77 #endif
  78             break;
  79
  80         case Tclass:
  81             if (((TypeClass *)t)->sym->isInterfaceDeclaration())
  82                 break;
  83             goto Linternal;
  84
  85         case Tarray:
  86             // convert to corresponding dynamic array type
  87             t = t->nextOf()->mutableOf()->arrayOf();
  88             if (t->nextOf()->ty != Tclass)
  89                 break;
  90             goto Linternal;
  91
  92         case Tfunction:
  93         case Tdelegate:
  94         case Tpointer:
  95         Linternal:
  96             tid = internalTI[t->ty];
  97             if (!tid)
  98             {   tid = new TypeInfoDeclaration(t, 1);
  99                 internalTI[t->ty] = tid;
 100             }
 101             e = new VarExp(0, tid);
 102             e = e->addressOf(sc);
 103             e->type = tid->type;        // do this so we don't get redundant dereference
 104             return e;
 105
 106         default:
 107             break;
 108     }
 109     //printf("\tcalling getTypeInfo() %s\n", t->toChars());
 110     return t->getTypeInfo(sc);
 111 }
 112
 113
 114 /****************************************************
 115  * Get the exact TypeInfo.
 116  */
 117
 118 Expression *Type::getTypeInfo(Scope *sc)
 119 {
 120     Expression *e;
 121     Type *t;
 122
 123     //printf("Type::getTypeInfo() %p, %s\n", this, toChars());
 124     t = merge();        // do this since not all Type's are merge'd
 125     if (!t->vtinfo)
 126     {
 127         if (t->isConst())
 128             t->vtinfo = new TypeInfoConstDeclaration(t);
 129         else if (t->isInvariant())
 130             t->vtinfo = new TypeInfoInvariantDeclaration(t);
 131         else
 132             t->vtinfo = t->getTypeInfoDeclaration();
 133         assert(t->vtinfo);
 134
 135         /* If this has a custom implementation in std/typeinfo, then
 136          * do not generate a COMDAT for it.
 137          */
 138         if (!t->builtinTypeInfo())
 139         {   // Generate COMDAT
 140             if (sc)                     // if in semantic() pass
 141             {   // Find module that will go all the way to an object file
 142                 Module *m = sc->module->importedFrom;
 143                 m->members->push(t->vtinfo);
 144             }
 145             else                        // if in obj generation pass
 146             {
 147                 t->vtinfo->toObjFile(global.params.multiobj);
 148             }
 149         }
 150     }
 151     e = new VarExp(0, t->vtinfo);
 152     e = e->addressOf(sc);
 153     e->type = t->vtinfo->type;          // do this so we don't get redundant dereference
 154     return e;
 155 }
 156
 157 TypeInfoDeclaration *Type::getTypeInfoDeclaration()
 158 {
 159     //printf("Type::getTypeInfoDeclaration() %s\n", toChars());
 160     return new TypeInfoDeclaration(this, 0);
 161 }
 162
 163 TypeInfoDeclaration *TypeTypedef::getTypeInfoDeclaration()
 164 {
 165     return new TypeInfoTypedefDeclaration(this);
 166 }
 167
 168 TypeInfoDeclaration *TypePointer::getTypeInfoDeclaration()
 169 {
 170     return new TypeInfoPointerDeclaration(this);
 171 }
 172
 173 TypeInfoDeclaration *TypeMaybe::getTypeInfoDeclaration()
 174 {
 175     return new TypeInfoMaybeDeclaration(this);
 176 }
 177
 178 TypeInfoDeclaration *TypeDArray::getTypeInfoDeclaration()
 179 {
 180     return new TypeInfoArrayDeclaration(this);
 181 }
 182
 183 TypeInfoDeclaration *TypeSArray::getTypeInfoDeclaration()
 184 {
 185     return new TypeInfoStaticArrayDeclaration(this);
 186 }
 187
 188 TypeInfoDeclaration *TypeAArray::getTypeInfoDeclaration()
 189 {
 190     return new TypeInfoAssociativeArrayDeclaration(this);
 191 }
 192
 193 TypeInfoDeclaration *TypeStruct::getTypeInfoDeclaration()
 194 {
 195     return new TypeInfoStructDeclaration(this);
 196 }
 197
 198 TypeInfoDeclaration *TypeClass::getTypeInfoDeclaration()
 199 {
 200     if (sym->isInterfaceDeclaration())
 201         return new TypeInfoInterfaceDeclaration(this);
 202     else
 203         return new TypeInfoClassDeclaration(this);
 204 }
 205
 206 TypeInfoDeclaration *TypeEnum::getTypeInfoDeclaration()
 207 {
 208     return new TypeInfoEnumDeclaration(this);
 209 }
 210
 211 TypeInfoDeclaration *TypeFunction::getTypeInfoDeclaration()
 212 {
 213     return new TypeInfoFunctionDeclaration(this);
 214 }
 215
 216 TypeInfoDeclaration *TypeDelegate::getTypeInfoDeclaration()
 217 {
 218     return new TypeInfoDelegateDeclaration(this);
 219 }
 220
 221 TypeInfoDeclaration *TypeTuple::getTypeInfoDeclaration()
 222 {
 223     return new TypeInfoTupleDeclaration(this);
 224 }
 225
 226
 227 /****************************************************
 228  */
 229
 230 #if 1
 231
 232 void TypeInfoDeclaration::toDt(dt_t **pdt)
 233 {
 234     //printf("TypeInfoDeclaration::toDt() %s\n", toChars());
 235     dtxoff(pdt, Type::typeinfo->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo
 236     dtdword(pdt, 0);                        // monitor
 237 }
 238
 239 void TypeInfoConstDeclaration::toDt(dt_t **pdt)
 240 {
 241     //printf("TypeInfoConstDeclaration::toDt() %s\n", toChars());
 242     dtxoff(pdt, Type::typeinfoconst->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Const
 243     dtdword(pdt, 0);                        // monitor
 244     Type *tm = tinfo->mutableOf();
 245     tm = tm->merge();
 246     tm->getTypeInfo(NULL);
 247     dtxoff(pdt, tm->vtinfo->toSymbol(), 0, TYnptr);
 248 }
 249
 250 void TypeInfoInvariantDeclaration::toDt(dt_t **pdt)
 251 {
 252     //printf("TypeInfoInvariantDeclaration::toDt() %s\n", toChars());
 253     dtxoff(pdt, Type::typeinfoinvariant->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Invariant
 254     dtdword(pdt, 0);                        // monitor
 255     Type *tm = tinfo->mutableOf();
 256     tm = tm->merge();
 257     tm->getTypeInfo(NULL);
 258     dtxoff(pdt, tm->vtinfo->toSymbol(), 0, TYnptr);
 259 }
 260
 261 void TypeInfoTypedefDeclaration::toDt(dt_t **pdt)
 262 {
 263     //printf("TypeInfoTypedefDeclaration::toDt() %s\n", toChars());
 264
 265     dtxoff(pdt, Type::typeinfotypedef->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Typedef
 266     dtdword(pdt, 0);                        // monitor
 267
 268     assert(tinfo->ty == Ttypedef);
 269
 270     TypeTypedef *tc = (TypeTypedef *)tinfo;
 271     TypedefDeclaration *sd = tc->sym;
 272     //printf("basetype = %s\n", sd->basetype->toChars());
 273
 274     /* Put out:
 275      *  TypeInfo base;
 276      *  char[] name;
 277      *  void[] m_init;
 278      */
 279
 280     sd->basetype = sd->basetype->merge();
 281     sd->basetype->getTypeInfo(NULL);            // generate vtinfo
 282     assert(sd->basetype->vtinfo);
 283     dtxoff(pdt, sd->basetype->vtinfo->toSymbol(), 0, TYnptr);   // TypeInfo for basetype
 284
 285     char *name = sd->toPrettyChars();
 286     size_t namelen = strlen(name);
 287     dtdword(pdt, namelen);
 288     dtabytes(pdt, TYnptr, 0, namelen + 1, name);
 289
 290     // void[] init;
 291     if (tinfo->isZeroInit() || !sd->init)
 292     {   // 0 initializer, or the same as the base type
 293         dtdword(pdt, 0);        // init.length
 294         dtdword(pdt, 0);        // init.ptr
 295     }
 296     else
 297     {
 298         dtdword(pdt, sd->type->size()); // init.length
 299         dtxoff(pdt, sd->toInitializer(), 0, TYnptr);    // init.ptr
 300     }
 301 }
 302
 303 void TypeInfoEnumDeclaration::toDt(dt_t **pdt)
 304 {
 305     //printf("TypeInfoEnumDeclaration::toDt()\n");
 306     dtxoff(pdt, Type::typeinfoenum->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Enum
 307     dtdword(pdt, 0);                        // monitor
 308
 309     assert(tinfo->ty == Tenum);
 310
 311     TypeEnum *tc = (TypeEnum *)tinfo;
 312     EnumDeclaration *sd = tc->sym;
 313
 314     /* Put out:
 315      *  TypeInfo base;
 316      *  char[] name;
 317      *  void[] m_init;
 318      */
 319
 320     if (sd->memtype)
 321     {   sd->memtype->getTypeInfo(NULL);
 322         dtxoff(pdt, sd->memtype->vtinfo->toSymbol(), 0, TYnptr);        // TypeInfo for enum members
 323     }
 324     else
 325         dtdword(pdt, 0);
 326
 327     char *name = sd->toPrettyChars();
 328     size_t namelen = strlen(name);
 329     dtdword(pdt, namelen);
 330     dtabytes(pdt, TYnptr, 0, namelen + 1, name);
 331
 332     // void[] init;
 333     if (!sd->defaultval || tinfo->isZeroInit())
 334     {   // 0 initializer, or the same as the base type
 335         dtdword(pdt, 0);        // init.length
 336         dtdword(pdt, 0);        // init.ptr
 337     }
 338     else
 339     {
 340         dtdword(pdt, sd->type->size()); // init.length
 341         dtxoff(pdt, sd->toInitializer(), 0, TYnptr);    // init.ptr
 342     }
 343 }
 344
 345 void TypeInfoPointerDeclaration::toDt(dt_t **pdt)
 346 {
 347     //printf("TypeInfoPointerDeclaration::toDt()\n");
 348     dtxoff(pdt, Type::typeinfopointer->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Pointer
 349     dtdword(pdt, 0);                        // monitor
 350
 351     assert(tinfo->ty == Tpointer);
 352
 353     TypePointer *tc = (TypePointer *)tinfo;
 354
 355     tc->next->getTypeInfo(NULL);
 356     dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for type being pointed to
 357 }
 358
 359 void TypeInfoMaybeDeclaration::toDt(dt_t **pdt)
 360 {
 361     //printf("TypeInfoMaybeDeclaration::toDt()\n");
 362     dtxoff(pdt, Type::typeinfomaybe->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Maybe
 363     dtdword(pdt, 0);                        // monitor
 364
 365     assert(tinfo->ty == Tmaybe);
 366
 367     TypeMaybe *tc = (TypeMaybe *)tinfo;
 368
 369     tc->next->getTypeInfo(NULL);
 370     dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for pointer type
 371 }
 372
 373 void TypeInfoArrayDeclaration::toDt(dt_t **pdt)
 374 {
 375     //printf("TypeInfoArrayDeclaration::toDt()\n");
 376     dtxoff(pdt, Type::typeinfoarray->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Array
 377     dtdword(pdt, 0);                        // monitor
 378
 379     assert(tinfo->ty == Tarray);
 380
 381     TypeDArray *tc = (TypeDArray *)tinfo;
 382
 383     tc->next->getTypeInfo(NULL);
 384     dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type
 385 }
 386
 387 void TypeInfoStaticArrayDeclaration::toDt(dt_t **pdt)
 388 {
 389     //printf("TypeInfoStaticArrayDeclaration::toDt()\n");
 390     dtxoff(pdt, Type::typeinfostaticarray->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_StaticArray
 391     dtdword(pdt, 0);                        // monitor
 392
 393     assert(tinfo->ty == Tsarray);
 394
 395     TypeSArray *tc = (TypeSArray *)tinfo;
 396
 397     tc->next->getTypeInfo(NULL);
 398     dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type
 399
 400     dtdword(pdt, tc->dim->toInteger());         // length
 401 }
 402
 403 void TypeInfoAssociativeArrayDeclaration::toDt(dt_t **pdt)
 404 {
 405     //printf("TypeInfoAssociativeArrayDeclaration::toDt()\n");
 406     dtxoff(pdt, Type::typeinfoassociativearray->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_AssociativeArray
 407     dtdword(pdt, 0);                        // monitor
 408
 409     assert(tinfo->ty == Taarray);
 410
 411     TypeAArray *tc = (TypeAArray *)tinfo;
 412
 413     tc->next->getTypeInfo(NULL);
 414     dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type
 415
 416     tc->index->getTypeInfo(NULL);
 417     dtxoff(pdt, tc->index->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for array of type
 418 }
 419
 420 void TypeInfoFunctionDeclaration::toDt(dt_t **pdt)
 421 {
 422     //printf("TypeInfoFunctionDeclaration::toDt()\n");
 423     dtxoff(pdt, Type::typeinfofunction->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Function
 424     dtdword(pdt, 0);                        // monitor
 425
 426     assert(tinfo->ty == Tfunction);
 427
 428     TypeFunction *tc = (TypeFunction *)tinfo;
 429
 430     tc->next->getTypeInfo(NULL);
 431     dtxoff(pdt, tc->next->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for function return value
 432 }
 433
 434 void TypeInfoDelegateDeclaration::toDt(dt_t **pdt)
 435 {
 436     //printf("TypeInfoDelegateDeclaration::toDt()\n");
 437     dtxoff(pdt, Type::typeinfodelegate->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Delegate
 438     dtdword(pdt, 0);                        // monitor
 439
 440     assert(tinfo->ty == Tdelegate);
 441
 442     TypeDelegate *tc = (TypeDelegate *)tinfo;
 443
 444     tc->next->nextOf()->getTypeInfo(NULL);
 445     dtxoff(pdt, tc->next->nextOf()->vtinfo->toSymbol(), 0, TYnptr); // TypeInfo for delegate return value
 446 }
 447
 448 void TypeInfoStructDeclaration::toDt(dt_t **pdt)
 449 {
 450     //printf("TypeInfoStructDeclaration::toDt() '%s'\n", toChars());
 451
 452     unsigned offset = Type::typeinfostruct->structsize;
 453
 454     dtxoff(pdt, Type::typeinfostruct->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfo_Struct
 455     dtdword(pdt, 0);                        // monitor
 456
 457     assert(tinfo->ty == Tstruct);
 458
 459     TypeStruct *tc = (TypeStruct *)tinfo;
 460     StructDeclaration *sd = tc->sym;
 461
 462     /* Put out:
 463      *  char[] name;
 464      *  void[] init;
 465      *  hash_t function(in void*) xtoHash;
 466      *  int function(in void*, in void*) xopEquals;
 467      *  int function(in void*, in void*) xopCmp;
 468      *  string function(const(void)*) xtoString;
 469      *  uint m_flags;
 470      *  xgetMembers;
 471      *  xdtor;
 472      *  xpostblit;
 473      *
 474      *  name[]
 475      */
 476
 477     char *name = sd->toPrettyChars();
 478     size_t namelen = strlen(name);
 479     dtdword(pdt, namelen);
 480     //dtabytes(pdt, TYnptr, 0, namelen + 1, name);
 481     dtxoff(pdt, toSymbol(), offset, TYnptr);
 482     offset += namelen + 1;
 483
 484     // void[] init;
 485     dtdword(pdt, sd->structsize);       // init.length
 486     if (sd->zeroInit)
 487         dtdword(pdt, 0);                // NULL for 0 initialization
 488     else
 489         dtxoff(pdt, sd->toInitializer(), 0, TYnptr);    // init.ptr
 490
 491     FuncDeclaration *fd;
 492     FuncDeclaration *fdx;
 493     TypeFunction *tf;
 494     Type *ta;
 495     Dsymbol *s;
 496
 497     static TypeFunction *tftohash;
 498     static TypeFunction *tftostring;
 499
 500     if (!tftohash)
 501     {
 502         Scope sc;
 503
 504         tftohash = new TypeFunction(NULL, Type::thash_t, 0, LINKd);
 505         tftohash->mod = MODconst;
 506         tftohash = (TypeFunction *)tftohash->semantic(0, &sc);
 507
 508         tftostring = new TypeFunction(NULL, Type::tchar->invariantOf()->arrayOf(), 0, LINKd);
 509         tftostring = (TypeFunction *)tftostring->semantic(0, &sc);
 510     }
 511
 512     TypeFunction *tfeqptr;
 513     {
 514         Scope sc;
 515         Arguments *arguments = new Arguments;
 516         Argument *arg = new Argument(STCin, tc->pointerTo(), NULL, NULL);
 517
 518         arguments->push(arg);
 519         tfeqptr = new TypeFunction(arguments, Type::tint32, 0, LINKd);
 520         tfeqptr->mod = MODconst;
 521         tfeqptr = (TypeFunction *)tfeqptr->semantic(0, &sc);
 522     }
 523
 524 #if 0
 525     TypeFunction *tfeq;
 526     {
 527         Scope sc;
 528         Array *arguments = new Array;
 529         Argument *arg = new Argument(In, tc, NULL, NULL);
 530
 531         arguments->push(arg);
 532         tfeq = new TypeFunction(arguments, Type::tint32, 0, LINKd);
 533         tfeq = (TypeFunction *)tfeq->semantic(0, &sc);
 534     }
 535 #endif
 536
 537     s = search_function(sd, Id::tohash);
 538     fdx = s ? s->isFuncDeclaration() : NULL;
 539     if (fdx)
 540     {   fd = fdx->overloadExactMatch(tftohash);
 541         if (fd)
 542             dtxoff(pdt, fd->toSymbol(), 0, TYnptr);
 543         else
 544             //fdx->error("must be declared as extern (D) uint toHash()");
 545             dtdword(pdt, 0);
 546     }
 547     else
 548         dtdword(pdt, 0);
 549
 550     s = search_function(sd, Id::eq);
 551     fdx = s ? s->isFuncDeclaration() : NULL;
 552     for (int i = 0; i < 2; i++)
 553     {
 554         if (fdx)
 555         {   fd = fdx->overloadExactMatch(tfeqptr);
 556             if (fd)
 557                 dtxoff(pdt, fd->toSymbol(), 0, TYnptr);
 558             else
 559                 //fdx->error("must be declared as extern (D) int %s(%s*)", fdx->toChars(), sd->toChars());
 560                 dtdword(pdt, 0);
 561         }
 562         else
 563             dtdword(pdt, 0);
 564
 565         s = search_function(sd, Id::cmp);
 566         fdx = s ? s->isFuncDeclaration() : NULL;
 567     }
 568
 569     s = search_function(sd, Id::tostring);
 570     fdx = s ? s->isFuncDeclaration() : NULL;
 571     if (fdx)
 572     {   fd = fdx->overloadExactMatch(tftostring);
 573         if (fd)
 574             dtxoff(pdt, fd->toSymbol(), 0, TYnptr);
 575         else
 576             //fdx->error("must be declared as extern (D) char[] toString()");
 577             dtdword(pdt, 0);
 578     }
 579     else
 580         dtdword(pdt, 0);
 581
 582     // uint m_flags;
 583     dti32(pdt, tc->hasPointers(), false);
 584
 585     // xgetMembers
 586     FuncDeclaration *sgetmembers = sd->findGetMembers();
 587     if (sgetmembers)
 588         dtxoff(pdt, sgetmembers->toSymbol(), 0, TYnptr);
 589     else
 590         dtdword(pdt, 0);                        // xgetMembers
 591
 592     // xdtor
 593     FuncDeclaration *sdtor = sd->dtor;
 594     if (sdtor)
 595         dtxoff(pdt, sdtor->toSymbol(), 0, TYnptr);
 596     else
 597         dtdword(pdt, 0);                        // xdtor
 598
 599     // xpostblit
 600     FuncDeclaration *spostblit = sd->postblit;
 601     if (spostblit)
 602         dtxoff(pdt, spostblit->toSymbol(), 0, TYnptr);
 603     else
 604         dtdword(pdt, 0);                        // xpostblit
 605
 606     // name[]
 607     dtnbytes(pdt, namelen + 1, name);
 608 }
 609
 610 void TypeInfoClassDeclaration::toDt(dt_t **pdt)
 611 {
 612     //printf("TypeInfoClassDeclaration::toDt() %s\n", tinfo->toChars());
 613     dtxoff(pdt, Type::typeinfoclass->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfoClass
 614     dtdword(pdt, 0);                        // monitor
 615
 616     assert(tinfo->ty == Tclass);
 617
 618     TypeClass *tc = (TypeClass *)tinfo;
 619     Symbol *s;
 620
 621     if (!tc->sym->vclassinfo)
 622         tc->sym->vclassinfo = new ClassInfoDeclaration(tc->sym);
 623     s = tc->sym->vclassinfo->toSymbol();
 624     dtxoff(pdt, s, 0, TYnptr);          // ClassInfo for tinfo
 625 }
 626
 627 void TypeInfoInterfaceDeclaration::toDt(dt_t **pdt)
 628 {
 629     //printf("TypeInfoInterfaceDeclaration::toDt() %s\n", tinfo->toChars());
 630     dtxoff(pdt, Type::typeinfointerface->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfoInterface
 631     dtdword(pdt, 0);                        // monitor
 632
 633     assert(tinfo->ty == Tclass);
 634
 635     TypeClass *tc = (TypeClass *)tinfo;
 636     Symbol *s;
 637
 638     if (!tc->sym->vclassinfo)
 639         tc->sym->vclassinfo = new ClassInfoDeclaration(tc->sym);
 640     s = tc->sym->vclassinfo->toSymbol();
 641     dtxoff(pdt, s, 0, TYnptr);          // ClassInfo for tinfo
 642 }
 643
 644 void TypeInfoTupleDeclaration::toDt(dt_t **pdt)
 645 {
 646     //printf("TypeInfoTupleDeclaration::toDt() %s\n", tinfo->toChars());
 647     dtxoff(pdt, Type::typeinfotypelist->toVtblSymbol(), 0, TYnptr); // vtbl for TypeInfoInterface
 648     dtdword(pdt, 0);                        // monitor
 649
 650     assert(tinfo->ty == Ttuple);
 651
 652     TypeTuple *tu = (TypeTuple *)tinfo;
 653
 654     size_t dim = tu->arguments->dim;
 655     dtdword(pdt, dim);                      // elements.length
 656
 657     dt_t *d = NULL;
 658     for (size_t i = 0; i < dim; i++)
 659     {   Argument *arg = (Argument *)tu->arguments->data[i];
 660         Expression *e = arg->type->getTypeInfo(NULL);
 661         e = e->optimize(WANTvalue);
 662         e->toDt(&d);
 663     }
 664
 665     Symbol *s;
 666     s = static_sym();
 667     s->Sdt = d;
 668     outdata(s);
 669
 670     dtxoff(pdt, s, 0, TYnptr);              // elements.ptr
 671 }
 672
 673 void TypeInfoDeclaration::toObjFile(int multiobj)
 674 {
 675     Symbol *s;
 676     unsigned sz;
 677     Dsymbol *parent;
 678
 679     //printf("TypeInfoDeclaration::toObjFile(%p '%s') protection %d\n", this, toChars(), protection);
 680
 681     if (multiobj)
 682     {
 683         obj_append(this);
 684         return;
 685     }
 686
 687     s = toSymbol();
 688     sz = type->size();
 689
 690     parent = this->toParent();
 691     s->Sclass = SCcomdat;
 692     s->Sfl = FLdata;
 693
 694     toDt(&s->Sdt);
 695
 696     dt_optimize(s->Sdt);
 697
 698     // See if we can convert a comdat to a comdef,
 699     // which saves on exe file space.
 700     if (s->Sclass == SCcomdat &&
 701         s->Sdt->dt == DT_azeros &&
 702         s->Sdt->DTnext == NULL)
 703     {
 704         s->Sclass = SCglobal;
 705         s->Sdt->dt = DT_common;
 706     }
 707
 708 #if ELFOBJ // Burton
 709     if (s->Sdt && s->Sdt->dt == DT_azeros && s->Sdt->DTnext == NULL)
 710         s->Sseg = UDATA;
 711     else
 712         s->Sseg = DATA;
 713 #endif /* ELFOBJ */
 714     outdata(s);
 715     if (isExport())
 716         obj_export(s,0);
 717 }
 718
 719 #endif
 720
 721 /* ========================================================================= */
 722
 723 /* These decide if there's an instance for them already in std.typeinfo,
 724  * because then the compiler doesn't need to build one.
 725  */
 726
 727 int Type::builtinTypeInfo()
 728 {
 729     return 0;
 730 }
 731
 732 int TypeBasic::builtinTypeInfo()
 733 {
 734     return mod ? 0 : 1;
 735 }
 736
 737 int TypeDArray::builtinTypeInfo()
 738 {
 739     return !mod && next->isTypeBasic() != NULL && !next->mod;
 740 }
 741
 742 /* ========================================================================= */
 743
 744 /***************************************
 745  * Create a static array of TypeInfo references
 746  * corresponding to an array of Expression's.
 747  * Used to supply hidden _arguments[] value for variadic D functions.
 748  */
 749
 750 Expression *createTypeInfoArray(Scope *sc, Expression *exps[], int dim)
 751 {
 752 #if 1
 753     /* Get the corresponding TypeInfo_Tuple and
 754      * point at its elements[].
 755      */
 756
 757     /* Create the TypeTuple corresponding to the types of args[]
 758      */
 759     Arguments *args = new Arguments;
 760     args->setDim(dim);
 761     for (size_t i = 0; i < dim; i++)
 762     {   Argument *arg = new Argument(STCin, exps[i]->type, NULL, NULL);
 763         args->data[i] = (void *)arg;
 764     }
 765     TypeTuple *tup = new TypeTuple(args);
 766     Expression *e = tup->getTypeInfo(sc);
 767     e = e->optimize(WANTvalue);
 768     assert(e->op == TOKsymoff);         // should be SymOffExp
 769
 770 #if BREAKABI
 771     /*
 772      * Should just pass a reference to TypeInfo_Tuple instead,
 773      * but that would require existing code to be recompiled.
 774      * Source compatibility can be maintained by computing _arguments[]
 775      * at the start of the called function by offseting into the
 776      * TypeInfo_Tuple reference.
 777      */
 778
 779 #else
 780     // Advance to elements[] member of TypeInfo_Tuple
 781     SymOffExp *se = (SymOffExp *)e;
 782     se->offset += PTRSIZE + PTRSIZE;
 783
 784     // Set type to TypeInfo[]*
 785     se->type = Type::typeinfo->type->arrayOf()->pointerTo();
 786
 787     // Indirect to get the _arguments[] value
 788     e = new PtrExp(0, se);
 789     e->type = se->type->next;
 790 #endif
 791     return e;
 792 #else
 793     /* Improvements:
 794      * 1) create an array literal instead,
 795      * as it would eliminate the extra dereference of loading the
 796      * static variable.
 797      */
 798
 799     ArrayInitializer *ai = new ArrayInitializer(0);
 800     VarDeclaration *v;
 801     Type *t;
 802     Expression *e;
 803     OutBuffer buf;
 804     Identifier *id;
 805     char *name;
 806
 807     // Generate identifier for _arguments[]
 808     buf.writestring("_arguments_");
 809     for (int i = 0; i < dim; i++)
 810     {   t = exps[i]->type;
 811         t->toDecoBuffer(&buf);
 812     }
 813     buf.writeByte(0);
 814     id = Lexer::idPool((char *)buf.data);
 815
 816 #ifdef IN_GCC
 817     Module *m = d_gcc_get_output_module();
 818 #else
 819     Module *m = sc->module;
 820 #endif
 821     Dsymbol *s = m->symtab->lookup(id);
 822
 823     if (s && s->parent == m)
 824     {   // Use existing one
 825         v = s->isVarDeclaration();
 826         assert(v);
 827     }
 828     else
 829     {   // Generate new one
 830
 831         for (int i = 0; i < dim; i++)
 832         {   t = exps[i]->type;
 833             e = t->getTypeInfo(sc);
 834             ai->addInit(new IntegerExp(i), new ExpInitializer(0, e));
 835         }
 836
 837         t = Type::typeinfo->type->arrayOf();
 838         ai->type = t;
 839         v = new VarDeclaration(0, t, id, ai);
 840         m->members->push(v);
 841         m->symtab->insert(v);
 842         sc = sc->push();
 843         sc->linkage = LINKc;
 844         sc->stc = STCstatic | STCcomdat;
 845         ai->semantic(sc, t);
 846         v->semantic(sc);
 847         v->parent = m;
 848         sc = sc->pop();
 849     }
 850     e = new VarExp(0, v);
 851     e = e->semantic(sc);
 852     return e;
 853 #endif
 854 }
 855
 856
 857