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