1 /** 2 * Generate debug info in the CV4 debug format. 3 * 4 * Copyright: Copyright (C) 1999-2020 by The D Language Foundation, All Rights Reserved 5 * Authors: $(LINK2 http://www.digitalmars.com, Walter Bright) 6 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) 7 * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/tocsym.d, _tocvdebug.d) 8 * Documentation: https://dlang.org/phobos/dmd_tocvdebug.html 9 * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/tocvdebug.d 10 */ 11 12 module dmd.tocvdebug; 13 14 version (Windows) 15 { 16 17 import core.stdc.stdio; 18 import core.stdc.string; 19 import core.stdc.stddef; 20 import core.stdc.stdlib; 21 import core.stdc.time; 22 23 import dmd.root.array; 24 import dmd.root.rmem; 25 26 import dmd.aggregate; 27 import dmd.apply; 28 import dmd.dclass; 29 import dmd.declaration; 30 import dmd.denum; 31 import dmd.dmodule; 32 import dmd.dsymbol; 33 import dmd.dstruct; 34 import dmd.dtemplate; 35 import dmd.func; 36 import dmd.globals; 37 import dmd.id; 38 import dmd.mtype; 39 import dmd.target; 40 import dmd.toctype; 41 import dmd.visitor; 42 43 import dmd.backend.cc; 44 import dmd.backend.cdef; 45 import dmd.backend.cgcv; 46 import dmd.backend.code; 47 import dmd.backend.cv4; 48 import dmd.backend.dlist; 49 import dmd.backend.dt; 50 import dmd.backend.global; 51 import dmd.backend.obj; 52 import dmd.backend.oper; 53 import dmd.backend.ty; 54 import dmd.backend.type; 55 56 extern (C++): 57 58 /* The CV4 debug format is defined in: 59 * "CV4 Symbolic Debug Information Specification" 60 * rev 3.1 March 5, 1993 61 * Languages Business Unit 62 * Microsoft 63 */ 64 65 /****************************** 66 * CV4 pg. 25 67 * Convert D protection attribute to cv attribute. 68 */ 69 70 uint PROTtoATTR(Prot.Kind prot) pure nothrow @safe @nogc 71 { 72 uint attribute; 73 74 final switch (prot) 75 { 76 case Prot.Kind.private_: attribute = 1; break; 77 case Prot.Kind.package_: attribute = 2; break; 78 case Prot.Kind.protected_: attribute = 2; break; 79 case Prot.Kind.public_: attribute = 3; break; 80 case Prot.Kind.export_: attribute = 3; break; 81 82 case Prot.Kind.undefined: 83 case Prot.Kind.none: 84 //printf("prot = %d\n", prot); 85 assert(0); 86 } 87 return attribute; 88 } 89 90 uint cv4_memfunctypidx(FuncDeclaration fd) 91 { 92 //printf("cv4_memfunctypidx(fd = '%s')\n", fd.toChars()); 93 94 type *t = Type_toCtype(fd.type); 95 if (AggregateDeclaration ad = fd.isMemberLocal()) 96 { 97 // It's a member function, which gets a special type record 98 99 const idx_t thisidx = fd.isStatic() 100 ? dttab4[TYvoid] 101 : (ad.handleType() ? cv4_typidx(Type_toCtype(ad.handleType())) : 0); 102 assert(thisidx); 103 104 uint nparam; 105 const idx_t paramidx = cv4_arglist(t,&nparam); 106 107 const ubyte call = cv4_callconv(t); 108 109 switch (config.fulltypes) 110 { 111 case CV4: 112 { 113 debtyp_t* d = debtyp_alloc(18); 114 ubyte *p = &d.data[0]; 115 TOWORD(p,LF_MFUNCTION); 116 TOWORD(p + 2,cv4_typidx(t.Tnext)); 117 TOWORD(p + 4,cv4_typidx(Type_toCtype(ad.type))); 118 TOWORD(p + 6,thisidx); 119 p[8] = call; 120 p[9] = 0; // reserved 121 TOWORD(p + 10,nparam); 122 TOWORD(p + 12,paramidx); 123 TOLONG(p + 14,0); // thisadjust 124 return cv_debtyp(d); 125 } 126 case CV8: 127 { 128 debtyp_t* d = debtyp_alloc(26); 129 ubyte *p = &d.data[0]; 130 TOWORD(p,0x1009); 131 TOLONG(p + 2,cv4_typidx(t.Tnext)); 132 TOLONG(p + 6,cv4_typidx(Type_toCtype(ad.type))); 133 TOLONG(p + 10,thisidx); 134 p[14] = call; 135 p[15] = 0; // reserved 136 TOWORD(p + 16,nparam); 137 TOLONG(p + 18,paramidx); 138 TOLONG(p + 22,0); // thisadjust 139 return cv_debtyp(d); 140 } 141 default: 142 assert(0); 143 } 144 } 145 return cv4_typidx(t); 146 } 147 148 enum CV4_NAMELENMAX = 0x3b9f; // found by trial and error 149 enum CV8_NAMELENMAX = 0xffff; // length record is 16-bit only 150 151 uint cv4_Denum(EnumDeclaration e) 152 { 153 //dbg_printf("cv4_Denum(%s)\n", e.toChars()); 154 const uint property = (!e.members || !e.memtype || !e.memtype.isintegral()) 155 ? 0x80 // enum is forward referenced or non-integer 156 : 0; 157 158 // Compute the number of fields, and the length of the fieldlist record 159 CvFieldList mc = CvFieldList(0, 0); 160 if (!property) 161 { 162 for (size_t i = 0; i < e.members.dim; i++) 163 { 164 if (EnumMember sf = (*e.members)[i].isEnumMember()) 165 { 166 const value = sf.value().toInteger(); 167 168 // store only member's simple name 169 uint len = 4 + cv4_numericbytes(cast(uint)value) + cv_stringbytes(sf.toChars()); 170 171 len = cv_align(null, len); 172 mc.count(len); 173 } 174 } 175 } 176 177 const id = e.toPrettyChars(); 178 uint len; 179 debtyp_t *d; 180 const uint memtype = e.memtype ? cv4_typidx(Type_toCtype(e.memtype)) : 0; 181 switch (config.fulltypes) 182 { 183 case CV8: 184 len = 14; 185 d = debtyp_alloc(len + cv_stringbytes(id)); 186 TOWORD(d.data.ptr,LF_ENUM_V3); 187 TOLONG(d.data.ptr + 6,memtype); 188 TOWORD(d.data.ptr + 4,property); 189 len += cv_namestring(d.data.ptr + len,id); 190 break; 191 192 case CV4: 193 len = 10; 194 d = debtyp_alloc(len + cv_stringbytes(id)); 195 TOWORD(d.data.ptr,LF_ENUM); 196 TOWORD(d.data.ptr + 4,memtype); 197 TOWORD(d.data.ptr + 8,property); 198 len += cv_namestring(d.data.ptr + len,id); 199 break; 200 201 default: 202 assert(0); 203 } 204 const length_save = d.length; 205 d.length = 0; // so cv_debtyp() will allocate new 206 const idx_t typidx = cv_debtyp(d); 207 d.length = length_save; // restore length 208 209 TOWORD(d.data.ptr + 2, mc.nfields); 210 211 uint fieldlist = 0; 212 if (!property) // if forward reference, then fieldlist is 0 213 { 214 // Generate fieldlist type record 215 mc.alloc(); 216 217 // And fill it in 218 for (size_t i = 0; i < e.members.dim; i++) 219 { 220 if (EnumMember sf = (*e.members)[i].isEnumMember()) 221 { 222 ubyte* p = mc.writePtr(); 223 dinteger_t value = sf.value().toInteger(); 224 TOWORD(p, (config.fulltypes == CV8) ? LF_ENUMERATE_V3 : LF_ENUMERATE); 225 uint attribute = 0; 226 TOWORD(p + 2, attribute); 227 cv4_storenumeric(p + 4,cast(uint)value); 228 uint j = 4 + cv4_numericbytes(cast(uint)value); 229 // store only member's simple name 230 j += cv_namestring(p + j, sf.toChars()); 231 j = cv_align(p + j, j); 232 mc.written(j); 233 // If enum is not a member of a class, output enum members as constants 234 // if (!isclassmember(s)) 235 // { 236 // cv4_outsym(sf); 237 // } 238 } 239 } 240 fieldlist = mc.debtyp(); 241 } 242 243 if (config.fulltypes == CV8) 244 TOLONG(d.data.ptr + 10,fieldlist); 245 else 246 TOWORD(d.data.ptr + 6,fieldlist); 247 248 // cv4_outsym(s); 249 return typidx; 250 } 251 252 /************************************* 253 * Align and pad. 254 * Returns: 255 * aligned count 256 */ 257 uint cv_align(ubyte *p, uint n) 258 { 259 if (config.fulltypes == CV8) 260 { 261 if (p) 262 { 263 uint npad = -n & 3; 264 while (npad) 265 { 266 *p = cast(ubyte)(0xF0 + npad); 267 ++p; 268 --npad; 269 } 270 } 271 n = (n + 3) & ~3; 272 } 273 return n; 274 } 275 276 /************************************* 277 * write a UDT record to the object file 278 * Params: 279 * id = name of user defined type 280 * typidx = type index 281 */ 282 void cv_udt(const char* id, uint typidx) 283 { 284 if (config.fulltypes == CV8) 285 cv8_udt(id, typidx); 286 else 287 { 288 const len = strlen(id); 289 ubyte *debsym = cast(ubyte *) alloca(39 + IDOHD + len); 290 291 // Output a 'user-defined type' for the tag name 292 TOWORD(debsym + 2,S_UDT); 293 TOIDX(debsym + 4,typidx); 294 uint length = 2 + 2 + cgcv.sz_idx; 295 length += cv_namestring(debsym + length,id); 296 TOWORD(debsym,length - 2); 297 298 assert(length <= 40 + len); 299 objmod.write_bytes(SegData[DEBSYM],length,debsym); 300 } 301 } 302 303 /* ==================================================================== */ 304 305 /**************************** 306 * Emit symbolic debug info in CV format. 307 */ 308 309 void toDebug(EnumDeclaration ed) 310 { 311 //printf("EnumDeclaration::toDebug('%s')\n", ed.toChars()); 312 313 assert(config.fulltypes >= CV4); 314 315 // If it is a member, it is handled by cvMember() 316 if (!ed.isMember()) 317 { 318 const id = ed.toPrettyChars(true); 319 const idx_t typidx = cv4_Denum(ed); 320 cv_udt(id, typidx); 321 } 322 } 323 324 /**************************** 325 * Helper struct for field list records LF_FIELDLIST/LF_FIELDLIST_V2 326 * 327 * if the size exceeds the maximum length of a record, the last entry 328 * is an LF_INDEX entry with the type index pointing to the next field list record 329 * 330 * Processing is done in two phases: 331 * 332 * Phase 1: computing the size of the field list and distributing it over multiple records 333 * - construct CvFieldList with some precalculated field count/length 334 * - for each field, call count(length of field) 335 * 336 * Phase 2: write the actual data 337 * - call alloc() to allocate debtyp's 338 * - for each field, 339 * - call writePtr() to get a pointer into the current debtyp 340 * - fill memory with field data 341 * - call written(length of field) 342 * - call debtyp() to create type records and return the index of the first one 343 */ 344 struct CvFieldList 345 { 346 // one LF_FIELDLIST record 347 static struct FLChunk 348 { 349 uint length; // accumulated during "count" phase 350 351 debtyp_t *dt; 352 uint writepos; // write position in dt 353 } 354 355 uint nfields; 356 uint writeIndex; 357 Array!FLChunk fieldLists; 358 359 const uint fieldLenMax; 360 const uint fieldIndexLen; 361 362 const bool canSplitList; 363 364 this(uint fields, uint len) 365 { 366 canSplitList = config.fulltypes == CV8; // optlink bails out with LF_INDEX 367 fieldIndexLen = canSplitList ? (config.fulltypes == CV8 ? 2 + 2 + 4 : 2 + 2) : 0; 368 fieldLenMax = (config.fulltypes == CV8 ? CV8_NAMELENMAX : CV4_NAMELENMAX) - fieldIndexLen; 369 370 assert(len < fieldLenMax); 371 nfields = fields; 372 fieldLists.push(FLChunk(2 + len)); 373 } 374 375 void count(uint n) 376 { 377 if (n) 378 { 379 nfields++; 380 assert(n < fieldLenMax); 381 if (fieldLists[$-1].length + n > fieldLenMax) 382 fieldLists.push(FLChunk(2 + n)); 383 else 384 fieldLists[$-1].length += n; 385 } 386 } 387 388 void alloc() 389 { 390 foreach (i, ref fld; fieldLists) 391 { 392 fld.dt = debtyp_alloc(fld.length + (i < fieldLists.length - 1 ? fieldIndexLen : 0)); 393 TOWORD(fld.dt.data.ptr, config.fulltypes == CV8 ? LF_FIELDLIST_V2 : LF_FIELDLIST); 394 fld.writepos = 2; 395 } 396 } 397 398 ubyte* writePtr() 399 { 400 assert(writeIndex < fieldLists.length); 401 auto fld = &fieldLists[writeIndex]; 402 if (fld.writepos >= fld.length) 403 { 404 assert(fld.writepos == fld.length); 405 if (writeIndex < fieldLists.length - 1) // if false, all further attempts must not actually write any data 406 { 407 writeIndex++; 408 fld++; 409 } 410 } 411 return fld.dt.data.ptr + fld.writepos; 412 } 413 414 void written(uint n) 415 { 416 assert(fieldLists[writeIndex].writepos + n <= fieldLists[writeIndex].length); 417 fieldLists[writeIndex].writepos += n; 418 } 419 420 idx_t debtyp() 421 { 422 idx_t typidx; 423 auto numCreate = canSplitList ? fieldLists.length : 1; 424 for(auto i = numCreate; i > 0; --i) 425 { 426 auto fld = &fieldLists[i - 1]; 427 if (typidx) 428 { 429 ubyte* p = fld.dt.data.ptr + fld.writepos; 430 if (config.fulltypes == CV8) 431 { 432 TOWORD (p, LF_INDEX_V2); 433 TOWORD (p + 2, 0); // padding 434 TOLONG (p + 4, typidx); 435 } 436 else 437 { 438 TOWORD (p, LF_INDEX); 439 TOWORD (p + 2, typidx); 440 } 441 } 442 typidx = cv_debtyp(fld.dt); 443 } 444 return typidx; 445 } 446 } 447 448 // Lambda function 449 int cv_mem_count(Dsymbol s, CvFieldList *pmc) 450 { 451 int nwritten = cvMember(s, null); 452 pmc.count(nwritten); 453 return 0; 454 } 455 456 // Lambda function 457 int cv_mem_p(Dsymbol s, CvFieldList *pmc) 458 { 459 ubyte *p = pmc.writePtr(); 460 uint len = cvMember(s, p); 461 pmc.written(len); 462 return 0; 463 } 464 465 466 void toDebug(StructDeclaration sd) 467 { 468 idx_t typidx1 = 0; 469 470 //printf("StructDeclaration::toDebug('%s')\n", sd.toChars()); 471 472 assert(config.fulltypes >= CV4); 473 if (sd.isAnonymous()) 474 return /*0*/; 475 476 if (typidx1) // if reference already generated 477 return /*typidx1*/; // use already existing reference 478 479 targ_size_t size; 480 uint property = 0; 481 if (!sd.members) 482 { 483 size = 0; 484 property |= 0x80; // forward reference 485 } 486 else 487 size = sd.structsize; 488 489 if (sd.parent.isAggregateDeclaration()) // if class is nested 490 property |= 8; 491 // if (st.Sctor || st.Sdtor) 492 // property |= 2; // class has ctors and/or dtors 493 // if (st.Sopoverload) 494 // property |= 4; // class has overloaded operators 495 // if (st.Scastoverload) 496 // property |= 0x40; // class has casting methods 497 // if (st.Sopeq && !(st.Sopeq.Sfunc.Fflags & Fnodebug)) 498 // property |= 0x20; // class has overloaded assignment 499 500 const char *id = sd.toPrettyChars(true); 501 502 uint leaf = sd.isUnionDeclaration() ? LF_UNION : LF_STRUCTURE; 503 if (config.fulltypes == CV8) 504 leaf = leaf == LF_UNION ? LF_UNION_V3 : LF_STRUCTURE_V3; 505 506 uint numidx; 507 final switch (leaf) 508 { 509 case LF_UNION: numidx = 8; break; 510 case LF_UNION_V3: numidx = 10; break; 511 case LF_STRUCTURE: numidx = 12; break; 512 case LF_STRUCTURE_V3: numidx = 18; break; 513 } 514 515 const len1 = numidx + cv4_numericbytes(cast(uint)size); 516 debtyp_t *d = debtyp_alloc(len1 + cv_stringbytes(id)); 517 cv4_storenumeric(d.data.ptr + numidx, cast(uint)size); 518 cv_namestring(d.data.ptr + len1, id); 519 520 if (leaf == LF_STRUCTURE) 521 { 522 TOWORD(d.data.ptr + 8,0); // dList 523 TOWORD(d.data.ptr + 10,0); // vshape is 0 (no virtual functions) 524 } 525 else if (leaf == LF_STRUCTURE_V3) 526 { 527 TOLONG(d.data.ptr + 10,0); // dList 528 TOLONG(d.data.ptr + 14,0); // vshape is 0 (no virtual functions) 529 } 530 TOWORD(d.data.ptr,leaf); 531 532 // Assign a number to prevent infinite recursion if a struct member 533 // references the same struct. 534 const length_save = d.length; 535 d.length = 0; // so cv_debtyp() will allocate new 536 const idx_t typidx = cv_debtyp(d); 537 d.length = length_save; // restore length 538 539 if (!sd.members) // if reference only 540 { 541 if (config.fulltypes == CV8) 542 { 543 TOWORD(d.data.ptr + 2,0); // count: number of fields is 0 544 TOLONG(d.data.ptr + 6,0); // field list is 0 545 TOWORD(d.data.ptr + 4,property); 546 } 547 else 548 { 549 TOWORD(d.data.ptr + 2,0); // count: number of fields is 0 550 TOWORD(d.data.ptr + 4,0); // field list is 0 551 TOWORD(d.data.ptr + 6,property); 552 } 553 return /*typidx*/; 554 } 555 556 // Compute the number of fields and the length of the fieldlist record 557 CvFieldList mc = CvFieldList(0, 0); 558 for (size_t i = 0; i < sd.members.dim; i++) 559 { 560 Dsymbol s = (*sd.members)[i]; 561 s.apply(&cv_mem_count, &mc); 562 } 563 const uint nfields = mc.nfields; 564 565 // Generate fieldlist type record 566 mc.alloc(); 567 if (nfields) 568 { 569 for (size_t i = 0; i < sd.members.dim; i++) 570 { 571 Dsymbol s = (*sd.members)[i]; 572 s.apply(&cv_mem_p, &mc); 573 } 574 } 575 576 //dbg_printf("fnamelen = %d, p-dt.data.ptr = %d\n",fnamelen,p-dt.data.ptr); 577 const idx_t fieldlist = mc.debtyp(); 578 579 TOWORD(d.data.ptr + 2, nfields); 580 if (config.fulltypes == CV8) 581 { 582 TOWORD(d.data.ptr + 4,property); 583 TOLONG(d.data.ptr + 6,fieldlist); 584 } 585 else 586 { 587 TOWORD(d.data.ptr + 4,fieldlist); 588 TOWORD(d.data.ptr + 6,property); 589 } 590 591 // cv4_outsym(s); 592 593 cv_udt(id, typidx); 594 595 // return typidx; 596 } 597 598 599 void toDebug(ClassDeclaration cd) 600 { 601 idx_t typidx1 = 0; 602 603 //printf("ClassDeclaration::toDebug('%s')\n", cd.toChars()); 604 605 assert(config.fulltypes >= CV4); 606 if (cd.isAnonymous()) 607 return /*0*/; 608 609 if (typidx1) // if reference already generated 610 return /*typidx1*/; // use already existing reference 611 612 targ_size_t size; 613 uint property = 0; 614 if (!cd.members) 615 { 616 size = 0; 617 property |= 0x80; // forward reference 618 } 619 else 620 size = cd.structsize; 621 622 if (cd.parent.isAggregateDeclaration()) // if class is nested 623 property |= 8; 624 if (cd.ctor || cd.dtors.dim) 625 property |= 2; // class has ctors and/or dtors 626 // if (st.Sopoverload) 627 // property |= 4; // class has overloaded operators 628 // if (st.Scastoverload) 629 // property |= 0x40; // class has casting methods 630 // if (st.Sopeq && !(st.Sopeq.Sfunc.Fflags & Fnodebug)) 631 // property |= 0x20; // class has overloaded assignment 632 633 const id = cd.isCPPinterface() ? cd.ident.toChars() : cd.toPrettyChars(true); 634 const uint leaf = config.fulltypes == CV8 ? LF_CLASS_V3 : LF_CLASS; 635 636 const uint numidx = (leaf == LF_CLASS_V3) ? 18 : 12; 637 const uint len1 = numidx + cv4_numericbytes(cast(uint)size); 638 debtyp_t *d = debtyp_alloc(len1 + cv_stringbytes(id)); 639 cv4_storenumeric(d.data.ptr + numidx, cast(uint)size); 640 cv_namestring(d.data.ptr + len1, id); 641 642 idx_t vshapeidx = 0; 643 if (1) 644 { 645 const size_t dim = cd.vtbl.dim; // number of virtual functions 646 if (dim) 647 { // 4 bits per descriptor 648 debtyp_t *vshape = debtyp_alloc(cast(uint)(4 + (dim + 1) / 2)); 649 TOWORD(vshape.data.ptr,LF_VTSHAPE); 650 TOWORD(vshape.data.ptr + 2, cast(uint)dim); 651 652 size_t n = 0; 653 ubyte descriptor = 0; 654 for (size_t i = 0; i < cd.vtbl.dim; i++) 655 { 656 //if (intsize == 4) 657 descriptor |= 5; 658 vshape.data.ptr[4 + n / 2] = descriptor; 659 descriptor <<= 4; 660 n++; 661 } 662 vshapeidx = cv_debtyp(vshape); 663 } 664 } 665 if (leaf == LF_CLASS) 666 { 667 TOWORD(d.data.ptr + 8,0); // dList 668 TOWORD(d.data.ptr + 10,vshapeidx); 669 } 670 else if (leaf == LF_CLASS_V3) 671 { 672 TOLONG(d.data.ptr + 10,0); // dList 673 TOLONG(d.data.ptr + 14,vshapeidx); 674 } 675 TOWORD(d.data.ptr,leaf); 676 677 // Assign a number to prevent infinite recursion if a struct member 678 // references the same struct. 679 const length_save = d.length; 680 d.length = 0; // so cv_debtyp() will allocate new 681 const idx_t typidx = cv_debtyp(d); 682 d.length = length_save; // restore length 683 684 if (!cd.members) // if reference only 685 { 686 if (leaf == LF_CLASS_V3) 687 { 688 TOWORD(d.data.ptr + 2,0); // count: number of fields is 0 689 TOLONG(d.data.ptr + 6,0); // field list is 0 690 TOWORD(d.data.ptr + 4,property); 691 } 692 else 693 { 694 TOWORD(d.data.ptr + 2,0); // count: number of fields is 0 695 TOWORD(d.data.ptr + 4,0); // field list is 0 696 TOWORD(d.data.ptr + 6,property); 697 } 698 return /*typidx*/; 699 } 700 701 // Compute the number of fields and the length of the fieldlist record 702 CvFieldList mc = CvFieldList(0, 0); 703 704 /* Adding in the base classes causes VS 2010 debugger to refuse to display any 705 * of the fields. I have not been able to determine why. 706 * (Could it be because the base class is "forward referenced"?) 707 * It does work with VS 2012. 708 */ 709 bool addInBaseClasses = true; 710 if (addInBaseClasses) 711 { 712 // Add in base classes 713 for (size_t i = 0; i < cd.baseclasses.dim; i++) 714 { 715 const bc = (*cd.baseclasses)[i]; 716 const uint elementlen = 4 + cgcv.sz_idx + cv4_numericbytes(bc.offset); 717 mc.count(cv_align(null, elementlen)); 718 } 719 } 720 721 for (size_t i = 0; i < cd.members.dim; i++) 722 { 723 Dsymbol s = (*cd.members)[i]; 724 s.apply(&cv_mem_count, &mc); 725 } 726 const uint nfields = mc.nfields; 727 728 TOWORD(d.data.ptr + 2, nfields); 729 730 // Generate fieldlist type record 731 mc.alloc(); 732 733 if (nfields) // if we didn't overflow 734 { 735 if (addInBaseClasses) 736 { 737 ubyte* base = mc.writePtr(); 738 ubyte* p = base; 739 740 // Add in base classes 741 for (size_t i = 0; i < cd.baseclasses.dim; i++) 742 { 743 BaseClass *bc = (*cd.baseclasses)[i]; 744 const idx_t typidx2 = cv4_typidx(Type_toCtype(bc.sym.type).Tnext); 745 const uint attribute = PROTtoATTR(Prot.Kind.public_); 746 747 uint elementlen; 748 final switch (config.fulltypes) 749 { 750 case CV8: 751 TOWORD(p, LF_BCLASS_V2); 752 TOWORD(p + 2,attribute); 753 TOLONG(p + 4,typidx2); 754 elementlen = 8; 755 break; 756 757 case CV4: 758 TOWORD(p, LF_BCLASS); 759 TOWORD(p + 2,typidx2); 760 TOWORD(p + 4,attribute); 761 elementlen = 6; 762 break; 763 } 764 765 cv4_storenumeric(p + elementlen, bc.offset); 766 elementlen += cv4_numericbytes(bc.offset); 767 p += cv_align(p + elementlen, elementlen); 768 } 769 mc.written(cast(uint)(p - base)); 770 } 771 772 for (size_t i = 0; i < cd.members.dim; i++) 773 { 774 Dsymbol s = (*cd.members)[i]; 775 s.apply(&cv_mem_p, &mc); 776 } 777 } 778 779 const idx_t fieldlist = mc.debtyp(); 780 781 if (config.fulltypes == CV8) 782 { 783 TOWORD(d.data.ptr + 4,property); 784 TOLONG(d.data.ptr + 6,fieldlist); 785 } 786 else 787 { 788 TOWORD(d.data.ptr + 4,fieldlist); 789 TOWORD(d.data.ptr + 6,property); 790 } 791 792 // cv4_outsym(s); 793 794 cv_udt(id, typidx); 795 796 // return typidx; 797 } 798 799 private uint writeField(ubyte* p, const char* id, uint attr, uint typidx, uint offset) 800 { 801 if (config.fulltypes == CV8) 802 { 803 TOWORD(p,LF_MEMBER_V3); 804 TOWORD(p + 2,attr); 805 TOLONG(p + 4,typidx); 806 cv4_storesignednumeric(p + 8, offset); 807 uint len = 8 + cv4_signednumericbytes(offset); 808 len += cv_namestring(p + len, id); 809 return cv_align(p + len, len); 810 } 811 else 812 { 813 TOWORD(p,LF_MEMBER); 814 TOWORD(p + 2,typidx); 815 TOWORD(p + 4,attr); 816 cv4_storesignednumeric(p + 6, offset); 817 uint len = 6 + cv4_signednumericbytes(offset); 818 return len + cv_namestring(p + len, id); 819 } 820 } 821 822 void toDebugClosure(Symbol* closstru) 823 { 824 //printf("toDebugClosure('%s')\n", fd.toChars()); 825 826 assert(config.fulltypes >= CV4); 827 828 uint leaf = config.fulltypes == CV8 ? LF_STRUCTURE_V3 : LF_STRUCTURE; 829 uint numidx = leaf == LF_STRUCTURE ? 12 : 18; 830 uint structsize = cast(uint)(closstru.Sstruct.Sstructsize); 831 const char* closname = closstru.Sident.ptr; 832 833 const len1 = numidx + cv4_numericbytes(structsize); 834 debtyp_t *d = debtyp_alloc(len1 + cv_stringbytes(closname)); 835 cv4_storenumeric(d.data.ptr + numidx, structsize); 836 cv_namestring(d.data.ptr + len1, closname); 837 838 if (leaf == LF_STRUCTURE) 839 { 840 TOWORD(d.data.ptr + 8,0); // dList 841 TOWORD(d.data.ptr + 10,0); // vshape is 0 (no virtual functions) 842 } 843 else // LF_STRUCTURE_V3 844 { 845 TOLONG(d.data.ptr + 10,0); // dList 846 TOLONG(d.data.ptr + 14,0); // vshape is 0 (no virtual functions) 847 } 848 TOWORD(d.data.ptr,leaf); 849 850 // Assign a number to prevent infinite recursion if a struct member 851 // references the same struct. 852 const length_save = d.length; 853 d.length = 0; // so cv_debtyp() will allocate new 854 const idx_t typidx = cv_debtyp(d); 855 d.length = length_save; // restore length 856 857 // Compute the number of fields (nfields), and the length of the fieldlist record (flistlen) 858 uint nfields = 0; 859 uint flistlen = 2; 860 for (auto sl = closstru.Sstruct.Sfldlst; sl; sl = list_next(sl)) 861 { 862 Symbol *sf = list_symbol(sl); 863 uint thislen = (config.fulltypes == CV8 ? 8 : 6); 864 thislen += cv4_signednumericbytes(cast(uint)sf.Smemoff); 865 thislen += cv_stringbytes(sf.Sident.ptr); 866 thislen = cv_align(null, thislen); 867 868 if (config.fulltypes != CV8 && flistlen + thislen > CV4_NAMELENMAX) 869 break; // Too long, fail gracefully 870 871 flistlen += thislen; 872 nfields++; 873 } 874 875 // Generate fieldlist type record 876 debtyp_t *dt = debtyp_alloc(flistlen); 877 ubyte *p = dt.data.ptr; 878 879 // And fill it in 880 TOWORD(p, config.fulltypes == CV8 ? LF_FIELDLIST_V2 : LF_FIELDLIST); 881 uint flistoff = 2; 882 for (auto sl = closstru.Sstruct.Sfldlst; sl && flistoff < flistlen; sl = list_next(sl)) 883 { 884 Symbol *sf = list_symbol(sl); 885 idx_t vtypidx = cv_typidx(sf.Stype); 886 flistoff += writeField(p + flistoff, sf.Sident.ptr, 3 /*public*/, vtypidx, cast(uint)sf.Smemoff); 887 } 888 889 //dbg_printf("fnamelen = %d, p-dt.data.ptr = %d\n",fnamelen,p-dt.data.ptr); 890 assert(flistoff == flistlen); 891 const idx_t fieldlist = cv_debtyp(dt); 892 893 uint property = 0; 894 TOWORD(d.data.ptr + 2, nfields); 895 if (config.fulltypes == CV8) 896 { 897 TOWORD(d.data.ptr + 4,property); 898 TOLONG(d.data.ptr + 6,fieldlist); 899 } 900 else 901 { 902 TOWORD(d.data.ptr + 4,fieldlist); 903 TOWORD(d.data.ptr + 6,property); 904 } 905 906 cv_udt(closname, typidx); 907 } 908 909 /* ===================================================================== */ 910 911 /***************************************** 912 * Insert CV info into *p. 913 * Returns: 914 * number of bytes written, or that would be written if p==null 915 */ 916 917 int cvMember(Dsymbol s, ubyte *p) 918 { 919 extern (C++) class CVMember : Visitor 920 { 921 ubyte *p; 922 int result; 923 924 this(ubyte *p) 925 { 926 this.p = p; 927 result = 0; 928 } 929 930 alias visit = Visitor.visit; 931 932 override void visit(Dsymbol s) 933 { 934 } 935 936 void cvMemberCommon(Dsymbol s, const(char)* id, idx_t typidx) 937 { 938 if (!p) 939 result = cv_stringbytes(id); 940 941 switch (config.fulltypes) 942 { 943 case CV8: 944 if (!p) 945 { 946 result += 8; 947 result = cv_align(null, result); 948 } 949 else 950 { 951 TOWORD(p,LF_NESTTYPE_V3); 952 TOWORD(p + 2,0); 953 TOLONG(p + 4,typidx); 954 result = 8 + cv_namestring(p + 8, id); 955 result = cv_align(p + result, result); 956 } 957 break; 958 959 case CV4: 960 if (!p) 961 { 962 result += 4; 963 } 964 else 965 { 966 TOWORD(p,LF_NESTTYPE); 967 TOWORD(p + 2,typidx); 968 result = 4 + cv_namestring(p + 4, id); 969 } 970 break; 971 972 default: 973 assert(0); 974 } 975 debug 976 { 977 if (p) 978 { 979 int save = result; 980 p = null; 981 cvMemberCommon(s, id, typidx); 982 assert(result == save); 983 } 984 } 985 } 986 987 override void visit(EnumDeclaration ed) 988 { 989 //printf("EnumDeclaration.cvMember() '%s'\n", d.toChars()); 990 991 cvMemberCommon(ed, ed.toChars(), cv4_Denum(ed)); 992 } 993 994 override void visit(FuncDeclaration fd) 995 { 996 //printf("FuncDeclaration.cvMember() '%s'\n", fd.toChars()); 997 998 if (!fd.type) // if not compiled in, 999 return; // skip it 1000 if (!fd.type.nextOf()) // if not fully analyzed (e.g. auto return type) 1001 return; // skip it 1002 1003 const id = fd.toChars(); 1004 1005 if (!p) 1006 { 1007 result = 2 + 2 + cgcv.sz_idx + cv_stringbytes(id); 1008 result = cv_align(null, result); 1009 return; 1010 } 1011 else 1012 { 1013 int count = 0; 1014 int mlen = 2; 1015 { 1016 if (fd.introducing) 1017 mlen += 4; 1018 mlen += cgcv.sz_idx * 2; 1019 count++; 1020 } 1021 1022 // Allocate and fill it in 1023 debtyp_t *d = debtyp_alloc(mlen); 1024 ubyte *q = d.data.ptr; 1025 TOWORD(q,config.fulltypes == CV8 ? LF_METHODLIST_V2 : LF_METHODLIST); 1026 q += 2; 1027 // for (s = sf; s; s = s.Sfunc.Foversym) 1028 { 1029 uint attribute = PROTtoATTR(fd.prot().kind); 1030 1031 /* 0*4 vanilla method 1032 * 1*4 virtual method 1033 * 2*4 static method 1034 * 3*4 friend method 1035 * 4*4 introducing virtual method 1036 * 5*4 pure virtual method 1037 * 6*4 pure introducing virtual method 1038 * 7*4 reserved 1039 */ 1040 1041 if (fd.isStatic()) 1042 attribute |= 2*4; 1043 else if (fd.isVirtual()) 1044 { 1045 if (fd.introducing) 1046 { 1047 if (fd.isAbstract()) 1048 attribute |= 6*4; 1049 else 1050 attribute |= 4*4; 1051 } 1052 else 1053 { 1054 if (fd.isAbstract()) 1055 attribute |= 5*4; 1056 else 1057 attribute |= 1*4; 1058 } 1059 } 1060 else 1061 attribute |= 0*4; 1062 1063 TOIDX(q,attribute); 1064 q += cgcv.sz_idx; 1065 TOIDX(q, cv4_memfunctypidx(fd)); 1066 q += cgcv.sz_idx; 1067 if (fd.introducing) 1068 { 1069 TOLONG(q, fd.vtblIndex * target.ptrsize); 1070 q += 4; 1071 } 1072 } 1073 assert(q - d.data.ptr == mlen); 1074 1075 idx_t typidx = cv_debtyp(d); 1076 if (typidx) 1077 { 1078 switch (config.fulltypes) 1079 { 1080 case CV8: 1081 TOWORD(p,LF_METHOD_V3); 1082 goto Lmethod; 1083 case CV4: 1084 TOWORD(p,LF_METHOD); 1085 Lmethod: 1086 TOWORD(p + 2,count); 1087 result = 4; 1088 TOIDX(p + result, typidx); 1089 result += cgcv.sz_idx; 1090 result += cv_namestring(p + result, id); 1091 break; 1092 1093 default: 1094 assert(0); 1095 } 1096 } 1097 result = cv_align(p + result, result); 1098 debug 1099 { 1100 int save = result; 1101 result = 0; 1102 p = null; 1103 visit(fd); 1104 assert(result == save); 1105 } 1106 } 1107 } 1108 1109 override void visit(VarDeclaration vd) 1110 { 1111 //printf("VarDeclaration.cvMember(p = %p) '%s'\n", p, vd.toChars()); 1112 1113 if (vd.type.toBasetype().ty == Ttuple) 1114 return; 1115 1116 const id = vd.toChars(); 1117 1118 if (!p) 1119 { 1120 if (vd.isField()) 1121 { 1122 if (config.fulltypes == CV8) 1123 result += 2; 1124 result += 6 + cv_stringbytes(id); 1125 result += cv4_numericbytes(vd.offset); 1126 } 1127 else if (vd.isStatic()) 1128 { 1129 if (config.fulltypes == CV8) 1130 result += 2; 1131 result += 6 + cv_stringbytes(id); 1132 } 1133 result = cv_align(null, result); 1134 } 1135 else 1136 { 1137 idx_t typidx = cv_typidx(Type_toCtype(vd.type)); 1138 uint attribute = PROTtoATTR(vd.prot().kind); 1139 assert((attribute & ~3) == 0); 1140 switch (config.fulltypes) 1141 { 1142 case CV8: 1143 if (vd.isField()) 1144 { 1145 TOWORD(p,LF_MEMBER_V3); 1146 TOWORD(p + 2,attribute); 1147 TOLONG(p + 4,typidx); 1148 cv4_storenumeric(p + 8, vd.offset); 1149 result = 8 + cv4_numericbytes(vd.offset); 1150 result += cv_namestring(p + result, id); 1151 } 1152 else if (vd.isStatic()) 1153 { 1154 TOWORD(p,LF_STMEMBER_V3); 1155 TOWORD(p + 2,attribute); 1156 TOLONG(p + 4,typidx); 1157 result = 8; 1158 result += cv_namestring(p + result, id); 1159 } 1160 break; 1161 1162 case CV4: 1163 if (vd.isField()) 1164 { 1165 TOWORD(p,LF_MEMBER); 1166 TOWORD(p + 2,typidx); 1167 TOWORD(p + 4,attribute); 1168 cv4_storenumeric(p + 6, vd.offset); 1169 result = 6 + cv4_numericbytes(vd.offset); 1170 result += cv_namestring(p + result, id); 1171 } 1172 else if (vd.isStatic()) 1173 { 1174 TOWORD(p,LF_STMEMBER); 1175 TOWORD(p + 2,typidx); 1176 TOWORD(p + 4,attribute); 1177 result = 6; 1178 result += cv_namestring(p + result, id); 1179 } 1180 break; 1181 1182 default: 1183 assert(0); 1184 } 1185 1186 result = cv_align(p + result, result); 1187 debug 1188 { 1189 int save = result; 1190 result = 0; 1191 p = null; 1192 visit(vd); 1193 assert(result == save); 1194 } 1195 } 1196 } 1197 } 1198 1199 scope v = new CVMember(p); 1200 s.accept(v); 1201 return v.result; 1202 } 1203 1204 } 1205 else 1206 { 1207 import dmd.denum; 1208 import dmd.dstruct; 1209 import dmd.dclass; 1210 import dmd.backend.cc; 1211 1212 /**************************** 1213 * Stub them out. 1214 */ 1215 1216 extern (C++) void toDebug(EnumDeclaration ed) 1217 { 1218 //printf("EnumDeclaration::toDebug('%s')\n", ed.toChars()); 1219 } 1220 1221 extern (C++) void toDebug(StructDeclaration sd) 1222 { 1223 } 1224 1225 extern (C++) void toDebug(ClassDeclaration cd) 1226 { 1227 } 1228 1229 extern (C++) void toDebugClosure(Symbol* closstru) 1230 { 1231 } 1232 }