contrib/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

   1 //===-- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp --*- C++ -*--===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for writing Microsoft CodeView debug info.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CodeViewDebug.h"
  15 #include "llvm/ADT/TinyPtrVector.h"
  16 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
  17 #include "llvm/DebugInfo/CodeView/CodeView.h"
  18 #include "llvm/DebugInfo/CodeView/Line.h"
  19 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"
  20 #include "llvm/DebugInfo/CodeView/TypeDumper.h"
  21 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
  22 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
  23 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbacks.h"
  24 #include "llvm/DebugInfo/MSF/ByteStream.h"
  25 #include "llvm/DebugInfo/MSF/StreamReader.h"
  26 #include "llvm/IR/Constants.h"
  27 #include "llvm/MC/MCAsmInfo.h"
  28 #include "llvm/MC/MCExpr.h"
  29 #include "llvm/MC/MCSectionCOFF.h"
  30 #include "llvm/MC/MCSymbol.h"
  31 #include "llvm/Support/COFF.h"
  32 #include "llvm/Support/ScopedPrinter.h"
  33 #include "llvm/Target/TargetFrameLowering.h"
  34 #include "llvm/Target/TargetRegisterInfo.h"
  35 #include "llvm/Target/TargetSubtargetInfo.h"
  36
  37 using namespace llvm;
  38 using namespace llvm::codeview;
  39 using namespace llvm::msf;
  40
  41 CodeViewDebug::CodeViewDebug(AsmPrinter *AP)
  42     : DebugHandlerBase(AP), OS(*Asm->OutStreamer), Allocator(),
  43       TypeTable(Allocator), CurFn(nullptr) {
  44   // If module doesn't have named metadata anchors or COFF debug section
  45   // is not available, skip any debug info related stuff.
  46   if (!MMI->getModule()->getNamedMetadata("llvm.dbg.cu") ||
  47       !AP->getObjFileLowering().getCOFFDebugSymbolsSection()) {
  48     Asm = nullptr;
  49     return;
  50   }
  51
  52   // Tell MMI that we have debug info.
  53   MMI->setDebugInfoAvailability(true);
  54 }
  55
  56 StringRef CodeViewDebug::getFullFilepath(const DIFile *File) {
  57   std::string &Filepath = FileToFilepathMap[File];
  58   if (!Filepath.empty())
  59     return Filepath;
  60
  61   StringRef Dir = File->getDirectory(), Filename = File->getFilename();
  62
  63   // Clang emits directory and relative filename info into the IR, but CodeView
  64   // operates on full paths.  We could change Clang to emit full paths too, but
  65   // that would increase the IR size and probably not needed for other users.
  66   // For now, just concatenate and canonicalize the path here.
  67   if (Filename.find(':') == 1)
  68     Filepath = Filename;
  69   else
  70     Filepath = (Dir + "\\" + Filename).str();
  71
  72   // Canonicalize the path.  We have to do it textually because we may no longer
  73   // have access the file in the filesystem.
  74   // First, replace all slashes with backslashes.
  75   std::replace(Filepath.begin(), Filepath.end(), '/', '\\');
  76
  77   // Remove all "\.\" with "\".
  78   size_t Cursor = 0;
  79   while ((Cursor = Filepath.find("\\.\\", Cursor)) != std::string::npos)
  80     Filepath.erase(Cursor, 2);
  81
  82   // Replace all "\XXX\..\" with "\".  Don't try too hard though as the original
  83   // path should be well-formatted, e.g. start with a drive letter, etc.
  84   Cursor = 0;
  85   while ((Cursor = Filepath.find("\\..\\", Cursor)) != std::string::npos) {
  86     // Something's wrong if the path starts with "\..\", abort.
  87     if (Cursor == 0)
  88       break;
  89
  90     size_t PrevSlash = Filepath.rfind('\\', Cursor - 1);
  91     if (PrevSlash == std::string::npos)
  92       // Something's wrong, abort.
  93       break;
  94
  95     Filepath.erase(PrevSlash, Cursor + 3 - PrevSlash);
  96     // The next ".." might be following the one we've just erased.
  97     Cursor = PrevSlash;
  98   }
  99
 100   // Remove all duplicate backslashes.
 101   Cursor = 0;
 102   while ((Cursor = Filepath.find("\\\\", Cursor)) != std::string::npos)
 103     Filepath.erase(Cursor, 1);
 104
 105   return Filepath;
 106 }
 107
 108 unsigned CodeViewDebug::maybeRecordFile(const DIFile *F) {
 109   unsigned NextId = FileIdMap.size() + 1;
 110   auto Insertion = FileIdMap.insert(std::make_pair(F, NextId));
 111   if (Insertion.second) {
 112     // We have to compute the full filepath and emit a .cv_file directive.
 113     StringRef FullPath = getFullFilepath(F);
 114     bool Success = OS.EmitCVFileDirective(NextId, FullPath);
 115     (void)Success;
 116     assert(Success && ".cv_file directive failed");
 117   }
 118   return Insertion.first->second;
 119 }
 120
 121 CodeViewDebug::InlineSite &
 122 CodeViewDebug::getInlineSite(const DILocation *InlinedAt,
 123                              const DISubprogram *Inlinee) {
 124   auto SiteInsertion = CurFn->InlineSites.insert({InlinedAt, InlineSite()});
 125   InlineSite *Site = &SiteInsertion.first->second;
 126   if (SiteInsertion.second) {
 127     unsigned ParentFuncId = CurFn->FuncId;
 128     if (const DILocation *OuterIA = InlinedAt->getInlinedAt())
 129       ParentFuncId =
 130           getInlineSite(OuterIA, InlinedAt->getScope()->getSubprogram())
 131               .SiteFuncId;
 132
 133     Site->SiteFuncId = NextFuncId++;
 134     OS.EmitCVInlineSiteIdDirective(
 135         Site->SiteFuncId, ParentFuncId, maybeRecordFile(InlinedAt->getFile()),
 136         InlinedAt->getLine(), InlinedAt->getColumn(), SMLoc());
 137     Site->Inlinee = Inlinee;
 138     InlinedSubprograms.insert(Inlinee);
 139     getFuncIdForSubprogram(Inlinee);
 140   }
 141   return *Site;
 142 }
 143
 144 static StringRef getPrettyScopeName(const DIScope *Scope) {
 145   StringRef ScopeName = Scope->getName();
 146   if (!ScopeName.empty())
 147     return ScopeName;
 148
 149   switch (Scope->getTag()) {
 150   case dwarf::DW_TAG_enumeration_type:
 151   case dwarf::DW_TAG_class_type:
 152   case dwarf::DW_TAG_structure_type:
 153   case dwarf::DW_TAG_union_type:
 154     return "<unnamed-tag>";
 155   case dwarf::DW_TAG_namespace:
 156     return "`anonymous namespace'";
 157   }
 158
 159   return StringRef();
 160 }
 161
 162 static const DISubprogram *getQualifiedNameComponents(
 163     const DIScope *Scope, SmallVectorImpl<StringRef> &QualifiedNameComponents) {
 164   const DISubprogram *ClosestSubprogram = nullptr;
 165   while (Scope != nullptr) {
 166     if (ClosestSubprogram == nullptr)
 167       ClosestSubprogram = dyn_cast<DISubprogram>(Scope);
 168     StringRef ScopeName = getPrettyScopeName(Scope);
 169     if (!ScopeName.empty())
 170       QualifiedNameComponents.push_back(ScopeName);
 171     Scope = Scope->getScope().resolve();
 172   }
 173   return ClosestSubprogram;
 174 }
 175
 176 static std::string getQualifiedName(ArrayRef<StringRef> QualifiedNameComponents,
 177                                     StringRef TypeName) {
 178   std::string FullyQualifiedName;
 179   for (StringRef QualifiedNameComponent : reverse(QualifiedNameComponents)) {
 180     FullyQualifiedName.append(QualifiedNameComponent);
 181     FullyQualifiedName.append("::");
 182   }
 183   FullyQualifiedName.append(TypeName);
 184   return FullyQualifiedName;
 185 }
 186
 187 static std::string getFullyQualifiedName(const DIScope *Scope, StringRef Name) {
 188   SmallVector<StringRef, 5> QualifiedNameComponents;
 189   getQualifiedNameComponents(Scope, QualifiedNameComponents);
 190   return getQualifiedName(QualifiedNameComponents, Name);
 191 }
 192
 193 struct CodeViewDebug::TypeLoweringScope {
 194   TypeLoweringScope(CodeViewDebug &CVD) : CVD(CVD) { ++CVD.TypeEmissionLevel; }
 195   ~TypeLoweringScope() {
 196     // Don't decrement TypeEmissionLevel until after emitting deferred types, so
 197     // inner TypeLoweringScopes don't attempt to emit deferred types.
 198     if (CVD.TypeEmissionLevel == 1)
 199       CVD.emitDeferredCompleteTypes();
 200     --CVD.TypeEmissionLevel;
 201   }
 202   CodeViewDebug &CVD;
 203 };
 204
 205 static std::string getFullyQualifiedName(const DIScope *Ty) {
 206   const DIScope *Scope = Ty->getScope().resolve();
 207   return getFullyQualifiedName(Scope, getPrettyScopeName(Ty));
 208 }
 209
 210 TypeIndex CodeViewDebug::getScopeIndex(const DIScope *Scope) {
 211   // No scope means global scope and that uses the zero index.
 212   if (!Scope || isa<DIFile>(Scope))
 213     return TypeIndex();
 214
 215   assert(!isa<DIType>(Scope) && "shouldn't make a namespace scope for a type");
 216
 217   // Check if we've already translated this scope.
 218   auto I = TypeIndices.find({Scope, nullptr});
 219   if (I != TypeIndices.end())
 220     return I->second;
 221
 222   // Build the fully qualified name of the scope.
 223   std::string ScopeName = getFullyQualifiedName(Scope);
 224   StringIdRecord SID(TypeIndex(), ScopeName);
 225   auto TI = TypeTable.writeKnownType(SID);
 226   return recordTypeIndexForDINode(Scope, TI);
 227 }
 228
 229 TypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) {
 230   assert(SP);
 231
 232   // Check if we've already translated this subprogram.
 233   auto I = TypeIndices.find({SP, nullptr});
 234   if (I != TypeIndices.end())
 235     return I->second;
 236
 237   // The display name includes function template arguments. Drop them to match
 238   // MSVC.
 239   StringRef DisplayName = SP->getDisplayName().split('<').first;
 240
 241   const DIScope *Scope = SP->getScope().resolve();
 242   TypeIndex TI;
 243   if (const auto *Class = dyn_cast_or_null<DICompositeType>(Scope)) {
 244     // If the scope is a DICompositeType, then this must be a method. Member
 245     // function types take some special handling, and require access to the
 246     // subprogram.
 247     TypeIndex ClassType = getTypeIndex(Class);
 248     MemberFuncIdRecord MFuncId(ClassType, getMemberFunctionType(SP, Class),
 249                                DisplayName);
 250     TI = TypeTable.writeKnownType(MFuncId);
 251   } else {
 252     // Otherwise, this must be a free function.
 253     TypeIndex ParentScope = getScopeIndex(Scope);
 254     FuncIdRecord FuncId(ParentScope, getTypeIndex(SP->getType()), DisplayName);
 255     TI = TypeTable.writeKnownType(FuncId);
 256   }
 257
 258   return recordTypeIndexForDINode(SP, TI);
 259 }
 260
 261 TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP,
 262                                                const DICompositeType *Class) {
 263   // Always use the method declaration as the key for the function type. The
 264   // method declaration contains the this adjustment.
 265   if (SP->getDeclaration())
 266     SP = SP->getDeclaration();
 267   assert(!SP->getDeclaration() && "should use declaration as key");
 268
 269   // Key the MemberFunctionRecord into the map as {SP, Class}. It won't collide
 270   // with the MemberFuncIdRecord, which is keyed in as {SP, nullptr}.
 271   auto I = TypeIndices.find({SP, Class});
 272   if (I != TypeIndices.end())
 273     return I->second;
 274
 275   // Make sure complete type info for the class is emitted *after* the member
 276   // function type, as the complete class type is likely to reference this
 277   // member function type.
 278   TypeLoweringScope S(*this);
 279   TypeIndex TI =
 280       lowerTypeMemberFunction(SP->getType(), Class, SP->getThisAdjustment());
 281   return recordTypeIndexForDINode(SP, TI, Class);
 282 }
 283
 284 TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node,
 285                                                   TypeIndex TI,
 286                                                   const DIType *ClassTy) {
 287   auto InsertResult = TypeIndices.insert({{Node, ClassTy}, TI});
 288   (void)InsertResult;
 289   assert(InsertResult.second && "DINode was already assigned a type index");
 290   return TI;
 291 }
 292
 293 unsigned CodeViewDebug::getPointerSizeInBytes() {
 294   return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8;
 295 }
 296
 297 void CodeViewDebug::recordLocalVariable(LocalVariable &&Var,
 298                                         const DILocation *InlinedAt) {
 299   if (InlinedAt) {
 300     // This variable was inlined. Associate it with the InlineSite.
 301     const DISubprogram *Inlinee = Var.DIVar->getScope()->getSubprogram();
 302     InlineSite &Site = getInlineSite(InlinedAt, Inlinee);
 303     Site.InlinedLocals.emplace_back(Var);
 304   } else {
 305     // This variable goes in the main ProcSym.
 306     CurFn->Locals.emplace_back(Var);
 307   }
 308 }
 309
 310 static void addLocIfNotPresent(SmallVectorImpl<const DILocation *> &Locs,
 311                                const DILocation *Loc) {
 312   auto B = Locs.begin(), E = Locs.end();
 313   if (std::find(B, E, Loc) == E)
 314     Locs.push_back(Loc);
 315 }
 316
 317 void CodeViewDebug::maybeRecordLocation(const DebugLoc &DL,
 318                                         const MachineFunction *MF) {
 319   // Skip this instruction if it has the same location as the previous one.
 320   if (DL == CurFn->LastLoc)
 321     return;
 322
 323   const DIScope *Scope = DL.get()->getScope();
 324   if (!Scope)
 325     return;
 326
 327   // Skip this line if it is longer than the maximum we can record.
 328   LineInfo LI(DL.getLine(), DL.getLine(), /*IsStatement=*/true);
 329   if (LI.getStartLine() != DL.getLine() || LI.isAlwaysStepInto() ||
 330       LI.isNeverStepInto())
 331     return;
 332
 333   ColumnInfo CI(DL.getCol(), /*EndColumn=*/0);
 334   if (CI.getStartColumn() != DL.getCol())
 335     return;
 336
 337   if (!CurFn->HaveLineInfo)
 338     CurFn->HaveLineInfo = true;
 339   unsigned FileId = 0;
 340   if (CurFn->LastLoc.get() && CurFn->LastLoc->getFile() == DL->getFile())
 341     FileId = CurFn->LastFileId;
 342   else
 343     FileId = CurFn->LastFileId = maybeRecordFile(DL->getFile());
 344   CurFn->LastLoc = DL;
 345
 346   unsigned FuncId = CurFn->FuncId;
 347   if (const DILocation *SiteLoc = DL->getInlinedAt()) {
 348     const DILocation *Loc = DL.get();
 349
 350     // If this location was actually inlined from somewhere else, give it the ID
 351     // of the inline call site.
 352     FuncId =
 353         getInlineSite(SiteLoc, Loc->getScope()->getSubprogram()).SiteFuncId;
 354
 355     // Ensure we have links in the tree of inline call sites.
 356     bool FirstLoc = true;
 357     while ((SiteLoc = Loc->getInlinedAt())) {
 358       InlineSite &Site =
 359           getInlineSite(SiteLoc, Loc->getScope()->getSubprogram());
 360       if (!FirstLoc)
 361         addLocIfNotPresent(Site.ChildSites, Loc);
 362       FirstLoc = false;
 363       Loc = SiteLoc;
 364     }
 365     addLocIfNotPresent(CurFn->ChildSites, Loc);
 366   }
 367
 368   OS.EmitCVLocDirective(FuncId, FileId, DL.getLine(), DL.getCol(),
 369                         /*PrologueEnd=*/false, /*IsStmt=*/false,
 370                         DL->getFilename(), SMLoc());
 371 }
 372
 373 void CodeViewDebug::emitCodeViewMagicVersion() {
 374   OS.EmitValueToAlignment(4);
 375   OS.AddComment("Debug section magic");
 376   OS.EmitIntValue(COFF::DEBUG_SECTION_MAGIC, 4);
 377 }
 378
 379 void CodeViewDebug::endModule() {
 380   if (!Asm || !MMI->hasDebugInfo())
 381     return;
 382
 383   assert(Asm != nullptr);
 384
 385   // The COFF .debug$S section consists of several subsections, each starting
 386   // with a 4-byte control code (e.g. 0xF1, 0xF2, etc) and then a 4-byte length
 387   // of the payload followed by the payload itself.  The subsections are 4-byte
 388   // aligned.
 389
 390   // Use the generic .debug$S section, and make a subsection for all the inlined
 391   // subprograms.
 392   switchToDebugSectionForSymbol(nullptr);
 393
 394   MCSymbol *CompilerInfo = beginCVSubsection(ModuleSubstreamKind::Symbols);
 395   emitCompilerInformation();
 396   endCVSubsection(CompilerInfo);
 397
 398   emitInlineeLinesSubsection();
 399
 400   // Emit per-function debug information.
 401   for (auto &P : FnDebugInfo)
 402     if (!P.first->isDeclarationForLinker())
 403       emitDebugInfoForFunction(P.first, P.second);
 404
 405   // Emit global variable debug information.
 406   setCurrentSubprogram(nullptr);
 407   emitDebugInfoForGlobals();
 408
 409   // Emit retained types.
 410   emitDebugInfoForRetainedTypes();
 411
 412   // Switch back to the generic .debug$S section after potentially processing
 413   // comdat symbol sections.
 414   switchToDebugSectionForSymbol(nullptr);
 415
 416   // Emit UDT records for any types used by global variables.
 417   if (!GlobalUDTs.empty()) {
 418     MCSymbol *SymbolsEnd = beginCVSubsection(ModuleSubstreamKind::Symbols);
 419     emitDebugInfoForUDTs(GlobalUDTs);
 420     endCVSubsection(SymbolsEnd);
 421   }
 422
 423   // This subsection holds a file index to offset in string table table.
 424   OS.AddComment("File index to string table offset subsection");
 425   OS.EmitCVFileChecksumsDirective();
 426
 427   // This subsection holds the string table.
 428   OS.AddComment("String table");
 429   OS.EmitCVStringTableDirective();
 430
 431   // Emit type information last, so that any types we translate while emitting
 432   // function info are included.
 433   emitTypeInformation();
 434
 435   clear();
 436 }
 437
 438 static void emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S) {
 439   // The maximum CV record length is 0xFF00. Most of the strings we emit appear
 440   // after a fixed length portion of the record. The fixed length portion should
 441   // always be less than 0xF00 (3840) bytes, so truncate the string so that the
 442   // overall record size is less than the maximum allowed.
 443   unsigned MaxFixedRecordLength = 0xF00;
 444   SmallString<32> NullTerminatedString(
 445       S.take_front(MaxRecordLength - MaxFixedRecordLength - 1));
 446   NullTerminatedString.push_back('\0');
 447   OS.EmitBytes(NullTerminatedString);
 448 }
 449
 450 void CodeViewDebug::emitTypeInformation() {
 451   // Do nothing if we have no debug info or if no non-trivial types were emitted
 452   // to TypeTable during codegen.
 453   NamedMDNode *CU_Nodes = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
 454   if (!CU_Nodes)
 455     return;
 456   if (TypeTable.empty())
 457     return;
 458
 459   // Start the .debug$T section with 0x4.
 460   OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection());
 461   emitCodeViewMagicVersion();
 462
 463   SmallString<8> CommentPrefix;
 464   if (OS.isVerboseAsm()) {
 465     CommentPrefix += '\t';
 466     CommentPrefix += Asm->MAI->getCommentString();
 467     CommentPrefix += ' ';
 468   }
 469
 470   CVTypeDumper CVTD(nullptr, /*PrintRecordBytes=*/false);
 471   TypeTable.ForEachRecord([&](TypeIndex Index, ArrayRef<uint8_t> Record) {
 472     if (OS.isVerboseAsm()) {
 473       // Emit a block comment describing the type record for readability.
 474       SmallString<512> CommentBlock;
 475       raw_svector_ostream CommentOS(CommentBlock);
 476       ScopedPrinter SP(CommentOS);
 477       SP.setPrefix(CommentPrefix);
 478       CVTD.setPrinter(&SP);
 479       Error E = CVTD.dump(Record);
 480       if (E) {
 481         logAllUnhandledErrors(std::move(E), errs(), "error: ");
 482         llvm_unreachable("produced malformed type record");
 483       }
 484       // emitRawComment will insert its own tab and comment string before
 485       // the first line, so strip off our first one. It also prints its own
 486       // newline.
 487       OS.emitRawComment(
 488           CommentOS.str().drop_front(CommentPrefix.size() - 1).rtrim());
 489     } else {
 490 #ifndef NDEBUG
 491       // Assert that the type data is valid even if we aren't dumping
 492       // comments. The MSVC linker doesn't do much type record validation,
 493       // so the first link of an invalid type record can succeed while
 494       // subsequent links will fail with LNK1285.
 495       ByteStream Stream(Record);
 496       CVTypeArray Types;
 497       StreamReader Reader(Stream);
 498       Error E = Reader.readArray(Types, Reader.getLength());
 499       if (!E) {
 500         TypeVisitorCallbacks C;
 501         E = CVTypeVisitor(C).visitTypeStream(Types);
 502       }
 503       if (E) {
 504         logAllUnhandledErrors(std::move(E), errs(), "error: ");
 505         llvm_unreachable("produced malformed type record");
 506       }
 507 #endif
 508     }
 509     StringRef S(reinterpret_cast<const char *>(Record.data()), Record.size());
 510     OS.EmitBinaryData(S);
 511   });
 512 }
 513
 514 namespace {
 515
 516 static SourceLanguage MapDWLangToCVLang(unsigned DWLang) {
 517   switch (DWLang) {
 518   case dwarf::DW_LANG_C:
 519   case dwarf::DW_LANG_C89:
 520   case dwarf::DW_LANG_C99:
 521   case dwarf::DW_LANG_C11:
 522   case dwarf::DW_LANG_ObjC:
 523     return SourceLanguage::C;
 524   case dwarf::DW_LANG_C_plus_plus:
 525   case dwarf::DW_LANG_C_plus_plus_03:
 526   case dwarf::DW_LANG_C_plus_plus_11:
 527   case dwarf::DW_LANG_C_plus_plus_14:
 528     return SourceLanguage::Cpp;
 529   case dwarf::DW_LANG_Fortran77:
 530   case dwarf::DW_LANG_Fortran90:
 531   case dwarf::DW_LANG_Fortran03:
 532   case dwarf::DW_LANG_Fortran08:
 533     return SourceLanguage::Fortran;
 534   case dwarf::DW_LANG_Pascal83:
 535     return SourceLanguage::Pascal;
 536   case dwarf::DW_LANG_Cobol74:
 537   case dwarf::DW_LANG_Cobol85:
 538     return SourceLanguage::Cobol;
 539   case dwarf::DW_LANG_Java:
 540     return SourceLanguage::Java;
 541   default:
 542     // There's no CodeView representation for this language, and CV doesn't
 543     // have an "unknown" option for the language field, so we'll use MASM,
 544     // as it's very low level.
 545     return SourceLanguage::Masm;
 546   }
 547 }
 548
 549 struct Version {
 550   int Part[4];
 551 };
 552
 553 // Takes a StringRef like "clang 4.0.0.0 (other nonsense 123)" and parses out
 554 // the version number.
 555 static Version parseVersion(StringRef Name) {
 556   Version V = {{0}};
 557   int N = 0;
 558   for (const char C : Name) {
 559     if (isdigit(C)) {
 560       V.Part[N] *= 10;
 561       V.Part[N] += C - '0';
 562     } else if (C == '.') {
 563       ++N;
 564       if (N >= 4)
 565         return V;
 566     } else if (N > 0)
 567       return V;
 568   }
 569   return V;
 570 }
 571
 572 static CPUType mapArchToCVCPUType(Triple::ArchType Type) {
 573   switch (Type) {
 574     case Triple::ArchType::x86:
 575       return CPUType::Pentium3;
 576     case Triple::ArchType::x86_64:
 577       return CPUType::X64;
 578     case Triple::ArchType::thumb:
 579       return CPUType::Thumb;
 580     default:
 581       report_fatal_error("target architecture doesn't map to a CodeView "
 582                          "CPUType");
 583   }
 584 }
 585
 586 }  // anonymous namespace
 587
 588 void CodeViewDebug::emitCompilerInformation() {
 589   MCContext &Context = MMI->getContext();
 590   MCSymbol *CompilerBegin = Context.createTempSymbol(),
 591            *CompilerEnd = Context.createTempSymbol();
 592   OS.AddComment("Record length");
 593   OS.emitAbsoluteSymbolDiff(CompilerEnd, CompilerBegin, 2);
 594   OS.EmitLabel(CompilerBegin);
 595   OS.AddComment("Record kind: S_COMPILE3");
 596   OS.EmitIntValue(SymbolKind::S_COMPILE3, 2);
 597   uint32_t Flags = 0;
 598
 599   NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
 600   const MDNode *Node = *CUs->operands().begin();
 601   const auto *CU = cast<DICompileUnit>(Node);
 602
 603   // The low byte of the flags indicates the source language.
 604   Flags = MapDWLangToCVLang(CU->getSourceLanguage());
 605   // TODO:  Figure out which other flags need to be set.
 606
 607   OS.AddComment("Flags and language");
 608   OS.EmitIntValue(Flags, 4);
 609
 610   OS.AddComment("CPUType");
 611   CPUType CPU =
 612       mapArchToCVCPUType(Triple(MMI->getModule()->getTargetTriple()).getArch());
 613   OS.EmitIntValue(static_cast<uint64_t>(CPU), 2);
 614
 615   StringRef CompilerVersion = CU->getProducer();
 616   Version FrontVer = parseVersion(CompilerVersion);
 617   OS.AddComment("Frontend version");
 618   for (int N = 0; N < 4; ++N)
 619     OS.EmitIntValue(FrontVer.Part[N], 2);
 620
 621   // Some Microsoft tools, like Binscope, expect a backend version number of at
 622   // least 8.something, so we'll coerce the LLVM version into a form that
 623   // guarantees it'll be big enough without really lying about the version.
 624   int Major = 1000 * LLVM_VERSION_MAJOR +
 625               10 * LLVM_VERSION_MINOR +
 626               LLVM_VERSION_PATCH;
 627   // Clamp it for builds that use unusually large version numbers.
 628   Major = std::min<int>(Major, std::numeric_limits<uint16_t>::max());
 629   Version BackVer = {{ Major, 0, 0, 0 }};
 630   OS.AddComment("Backend version");
 631   for (int N = 0; N < 4; ++N)
 632     OS.EmitIntValue(BackVer.Part[N], 2);
 633
 634   OS.AddComment("Null-terminated compiler version string");
 635   emitNullTerminatedSymbolName(OS, CompilerVersion);
 636
 637   OS.EmitLabel(CompilerEnd);
 638 }
 639
 640 void CodeViewDebug::emitInlineeLinesSubsection() {
 641   if (InlinedSubprograms.empty())
 642     return;
 643
 644   OS.AddComment("Inlinee lines subsection");
 645   MCSymbol *InlineEnd = beginCVSubsection(ModuleSubstreamKind::InlineeLines);
 646
 647   // We don't provide any extra file info.
 648   // FIXME: Find out if debuggers use this info.
 649   OS.AddComment("Inlinee lines signature");
 650   OS.EmitIntValue(unsigned(InlineeLinesSignature::Normal), 4);
 651
 652   for (const DISubprogram *SP : InlinedSubprograms) {
 653     assert(TypeIndices.count({SP, nullptr}));
 654     TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}];
 655
 656     OS.AddBlankLine();
 657     unsigned FileId = maybeRecordFile(SP->getFile());
 658     OS.AddComment("Inlined function " + SP->getDisplayName() + " starts at " +
 659                   SP->getFilename() + Twine(':') + Twine(SP->getLine()));
 660     OS.AddBlankLine();
 661     // The filechecksum table uses 8 byte entries for now, and file ids start at
 662     // 1.
 663     unsigned FileOffset = (FileId - 1) * 8;
 664     OS.AddComment("Type index of inlined function");
 665     OS.EmitIntValue(InlineeIdx.getIndex(), 4);
 666     OS.AddComment("Offset into filechecksum table");
 667     OS.EmitIntValue(FileOffset, 4);
 668     OS.AddComment("Starting line number");
 669     OS.EmitIntValue(SP->getLine(), 4);
 670   }
 671
 672   endCVSubsection(InlineEnd);
 673 }
 674
 675 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,
 676                                         const DILocation *InlinedAt,
 677                                         const InlineSite &Site) {
 678   MCSymbol *InlineBegin = MMI->getContext().createTempSymbol(),
 679            *InlineEnd = MMI->getContext().createTempSymbol();
 680
 681   assert(TypeIndices.count({Site.Inlinee, nullptr}));
 682   TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}];
 683
 684   // SymbolRecord
 685   OS.AddComment("Record length");
 686   OS.emitAbsoluteSymbolDiff(InlineEnd, InlineBegin, 2);   // RecordLength
 687   OS.EmitLabel(InlineBegin);
 688   OS.AddComment("Record kind: S_INLINESITE");
 689   OS.EmitIntValue(SymbolKind::S_INLINESITE, 2); // RecordKind
 690
 691   OS.AddComment("PtrParent");
 692   OS.EmitIntValue(0, 4);
 693   OS.AddComment("PtrEnd");
 694   OS.EmitIntValue(0, 4);
 695   OS.AddComment("Inlinee type index");
 696   OS.EmitIntValue(InlineeIdx.getIndex(), 4);
 697
 698   unsigned FileId = maybeRecordFile(Site.Inlinee->getFile());
 699   unsigned StartLineNum = Site.Inlinee->getLine();
 700
 701   OS.EmitCVInlineLinetableDirective(Site.SiteFuncId, FileId, StartLineNum,
 702                                     FI.Begin, FI.End);
 703
 704   OS.EmitLabel(InlineEnd);
 705
 706   emitLocalVariableList(Site.InlinedLocals);
 707
 708   // Recurse on child inlined call sites before closing the scope.
 709   for (const DILocation *ChildSite : Site.ChildSites) {
 710     auto I = FI.InlineSites.find(ChildSite);
 711     assert(I != FI.InlineSites.end() &&
 712            "child site not in function inline site map");
 713     emitInlinedCallSite(FI, ChildSite, I->second);
 714   }
 715
 716   // Close the scope.
 717   OS.AddComment("Record length");
 718   OS.EmitIntValue(2, 2);                                  // RecordLength
 719   OS.AddComment("Record kind: S_INLINESITE_END");
 720   OS.EmitIntValue(SymbolKind::S_INLINESITE_END, 2); // RecordKind
 721 }
 722
 723 void CodeViewDebug::switchToDebugSectionForSymbol(const MCSymbol *GVSym) {
 724   // If we have a symbol, it may be in a section that is COMDAT. If so, find the
 725   // comdat key. A section may be comdat because of -ffunction-sections or
 726   // because it is comdat in the IR.
 727   MCSectionCOFF *GVSec =
 728       GVSym ? dyn_cast<MCSectionCOFF>(&GVSym->getSection()) : nullptr;
 729   const MCSymbol *KeySym = GVSec ? GVSec->getCOMDATSymbol() : nullptr;
 730
 731   MCSectionCOFF *DebugSec = cast<MCSectionCOFF>(
 732       Asm->getObjFileLowering().getCOFFDebugSymbolsSection());
 733   DebugSec = OS.getContext().getAssociativeCOFFSection(DebugSec, KeySym);
 734
 735   OS.SwitchSection(DebugSec);
 736
 737   // Emit the magic version number if this is the first time we've switched to
 738   // this section.
 739   if (ComdatDebugSections.insert(DebugSec).second)
 740     emitCodeViewMagicVersion();
 741 }
 742
 743 void CodeViewDebug::emitDebugInfoForFunction(const Function *GV,
 744                                              FunctionInfo &FI) {
 745   // For each function there is a separate subsection
 746   // which holds the PC to file:line table.
 747   const MCSymbol *Fn = Asm->getSymbol(GV);
 748   assert(Fn);
 749
 750   // Switch to the to a comdat section, if appropriate.
 751   switchToDebugSectionForSymbol(Fn);
 752
 753   std::string FuncName;
 754   auto *SP = GV->getSubprogram();
 755   assert(SP);
 756   setCurrentSubprogram(SP);
 757
 758   // If we have a display name, build the fully qualified name by walking the
 759   // chain of scopes.
 760   if (!SP->getDisplayName().empty())
 761     FuncName =
 762         getFullyQualifiedName(SP->getScope().resolve(), SP->getDisplayName());
 763
 764   // If our DISubprogram name is empty, use the mangled name.
 765   if (FuncName.empty())
 766     FuncName = GlobalValue::getRealLinkageName(GV->getName());
 767
 768   // Emit a symbol subsection, required by VS2012+ to find function boundaries.
 769   OS.AddComment("Symbol subsection for " + Twine(FuncName));
 770   MCSymbol *SymbolsEnd = beginCVSubsection(ModuleSubstreamKind::Symbols);
 771   {
 772     MCSymbol *ProcRecordBegin = MMI->getContext().createTempSymbol(),
 773              *ProcRecordEnd = MMI->getContext().createTempSymbol();
 774     OS.AddComment("Record length");
 775     OS.emitAbsoluteSymbolDiff(ProcRecordEnd, ProcRecordBegin, 2);
 776     OS.EmitLabel(ProcRecordBegin);
 777
 778     if (GV->hasLocalLinkage()) {
 779       OS.AddComment("Record kind: S_LPROC32_ID");
 780       OS.EmitIntValue(unsigned(SymbolKind::S_LPROC32_ID), 2);
 781     } else {
 782       OS.AddComment("Record kind: S_GPROC32_ID");
 783       OS.EmitIntValue(unsigned(SymbolKind::S_GPROC32_ID), 2);
 784     }
 785
 786     // These fields are filled in by tools like CVPACK which run after the fact.
 787     OS.AddComment("PtrParent");
 788     OS.EmitIntValue(0, 4);
 789     OS.AddComment("PtrEnd");
 790     OS.EmitIntValue(0, 4);
 791     OS.AddComment("PtrNext");
 792     OS.EmitIntValue(0, 4);
 793     // This is the important bit that tells the debugger where the function
 794     // code is located and what's its size:
 795     OS.AddComment("Code size");
 796     OS.emitAbsoluteSymbolDiff(FI.End, Fn, 4);
 797     OS.AddComment("Offset after prologue");
 798     OS.EmitIntValue(0, 4);
 799     OS.AddComment("Offset before epilogue");
 800     OS.EmitIntValue(0, 4);
 801     OS.AddComment("Function type index");
 802     OS.EmitIntValue(getFuncIdForSubprogram(GV->getSubprogram()).getIndex(), 4);
 803     OS.AddComment("Function section relative address");
 804     OS.EmitCOFFSecRel32(Fn, /*Offset=*/0);
 805     OS.AddComment("Function section index");
 806     OS.EmitCOFFSectionIndex(Fn);
 807     OS.AddComment("Flags");
 808     OS.EmitIntValue(0, 1);
 809     // Emit the function display name as a null-terminated string.
 810     OS.AddComment("Function name");
 811     // Truncate the name so we won't overflow the record length field.
 812     emitNullTerminatedSymbolName(OS, FuncName);
 813     OS.EmitLabel(ProcRecordEnd);
 814
 815     emitLocalVariableList(FI.Locals);
 816
 817     // Emit inlined call site information. Only emit functions inlined directly
 818     // into the parent function. We'll emit the other sites recursively as part
 819     // of their parent inline site.
 820     for (const DILocation *InlinedAt : FI.ChildSites) {
 821       auto I = FI.InlineSites.find(InlinedAt);
 822       assert(I != FI.InlineSites.end() &&
 823              "child site not in function inline site map");
 824       emitInlinedCallSite(FI, InlinedAt, I->second);
 825     }
 826
 827     if (SP != nullptr)
 828       emitDebugInfoForUDTs(LocalUDTs);
 829
 830     // We're done with this function.
 831     OS.AddComment("Record length");
 832     OS.EmitIntValue(0x0002, 2);
 833     OS.AddComment("Record kind: S_PROC_ID_END");
 834     OS.EmitIntValue(unsigned(SymbolKind::S_PROC_ID_END), 2);
 835   }
 836   endCVSubsection(SymbolsEnd);
 837
 838   // We have an assembler directive that takes care of the whole line table.
 839   OS.EmitCVLinetableDirective(FI.FuncId, Fn, FI.End);
 840 }
 841
 842 CodeViewDebug::LocalVarDefRange
 843 CodeViewDebug::createDefRangeMem(uint16_t CVRegister, int Offset) {
 844   LocalVarDefRange DR;
 845   DR.InMemory = -1;
 846   DR.DataOffset = Offset;
 847   assert(DR.DataOffset == Offset && "truncation");
 848   DR.IsSubfield = 0;
 849   DR.StructOffset = 0;
 850   DR.CVRegister = CVRegister;
 851   return DR;
 852 }
 853
 854 CodeViewDebug::LocalVarDefRange
 855 CodeViewDebug::createDefRangeGeneral(uint16_t CVRegister, bool InMemory,
 856                                      int Offset, bool IsSubfield,
 857                                      uint16_t StructOffset) {
 858   LocalVarDefRange DR;
 859   DR.InMemory = InMemory;
 860   DR.DataOffset = Offset;
 861   DR.IsSubfield = IsSubfield;
 862   DR.StructOffset = StructOffset;
 863   DR.CVRegister = CVRegister;
 864   return DR;
 865 }
 866
 867 void CodeViewDebug::collectVariableInfoFromMFTable(
 868     DenseSet<InlinedVariable> &Processed) {
 869   const MachineFunction &MF = *Asm->MF;
 870   const TargetSubtargetInfo &TSI = MF.getSubtarget();
 871   const TargetFrameLowering *TFI = TSI.getFrameLowering();
 872   const TargetRegisterInfo *TRI = TSI.getRegisterInfo();
 873
 874   for (const MachineFunction::VariableDbgInfo &VI : MF.getVariableDbgInfo()) {
 875     if (!VI.Var)
 876       continue;
 877     assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
 878            "Expected inlined-at fields to agree");
 879
 880     Processed.insert(InlinedVariable(VI.Var, VI.Loc->getInlinedAt()));
 881     LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
 882
 883     // If variable scope is not found then skip this variable.
 884     if (!Scope)
 885       continue;
 886
 887     // Get the frame register used and the offset.
 888     unsigned FrameReg = 0;
 889     int FrameOffset = TFI->getFrameIndexReference(*Asm->MF, VI.Slot, FrameReg);
 890     uint16_t CVReg = TRI->getCodeViewRegNum(FrameReg);
 891
 892     // Calculate the label ranges.
 893     LocalVarDefRange DefRange = createDefRangeMem(CVReg, FrameOffset);
 894     for (const InsnRange &Range : Scope->getRanges()) {
 895       const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
 896       const MCSymbol *End = getLabelAfterInsn(Range.second);
 897       End = End ? End : Asm->getFunctionEnd();
 898       DefRange.Ranges.emplace_back(Begin, End);
 899     }
 900
 901     LocalVariable Var;
 902     Var.DIVar = VI.Var;
 903     Var.DefRanges.emplace_back(std::move(DefRange));
 904     recordLocalVariable(std::move(Var), VI.Loc->getInlinedAt());
 905   }
 906 }
 907
 908 void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) {
 909   DenseSet<InlinedVariable> Processed;
 910   // Grab the variable info that was squirreled away in the MMI side-table.
 911   collectVariableInfoFromMFTable(Processed);
 912
 913   const TargetRegisterInfo *TRI = Asm->MF->getSubtarget().getRegisterInfo();
 914
 915   for (const auto &I : DbgValues) {
 916     InlinedVariable IV = I.first;
 917     if (Processed.count(IV))
 918       continue;
 919     const DILocalVariable *DIVar = IV.first;
 920     const DILocation *InlinedAt = IV.second;
 921
 922     // Instruction ranges, specifying where IV is accessible.
 923     const auto &Ranges = I.second;
 924
 925     LexicalScope *Scope = nullptr;
 926     if (InlinedAt)
 927       Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt);
 928     else
 929       Scope = LScopes.findLexicalScope(DIVar->getScope());
 930     // If variable scope is not found then skip this variable.
 931     if (!Scope)
 932       continue;
 933
 934     LocalVariable Var;
 935     Var.DIVar = DIVar;
 936
 937     // Calculate the definition ranges.
 938     for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
 939       const InsnRange &Range = *I;
 940       const MachineInstr *DVInst = Range.first;
 941       assert(DVInst->isDebugValue() && "Invalid History entry");
 942       const DIExpression *DIExpr = DVInst->getDebugExpression();
 943       bool IsSubfield = false;
 944       unsigned StructOffset = 0;
 945
 946       // Handle fragments.
 947       auto Fragment = DIExpr->getFragmentInfo();
 948       if (DIExpr && Fragment) {
 949         IsSubfield = true;
 950         StructOffset = Fragment->OffsetInBits / 8;
 951       } else if (DIExpr && DIExpr->getNumElements() > 0) {
 952         continue; // Ignore unrecognized exprs.
 953       }
 954
 955       // Bail if operand 0 is not a valid register. This means the variable is a
 956       // simple constant, or is described by a complex expression.
 957       // FIXME: Find a way to represent constant variables, since they are
 958       // relatively common.
 959       unsigned Reg =
 960           DVInst->getOperand(0).isReg() ? DVInst->getOperand(0).getReg() : 0;
 961       if (Reg == 0)
 962         continue;
 963
 964       // Handle the two cases we can handle: indirect in memory and in register.
 965       unsigned CVReg = TRI->getCodeViewRegNum(Reg);
 966       bool InMemory = DVInst->getOperand(1).isImm();
 967       int Offset = InMemory ? DVInst->getOperand(1).getImm() : 0;
 968       {
 969         LocalVarDefRange DR;
 970         DR.CVRegister = CVReg;
 971         DR.InMemory = InMemory;
 972         DR.DataOffset = Offset;
 973         DR.IsSubfield = IsSubfield;
 974         DR.StructOffset = StructOffset;
 975
 976         if (Var.DefRanges.empty() ||
 977             Var.DefRanges.back().isDifferentLocation(DR)) {
 978           Var.DefRanges.emplace_back(std::move(DR));
 979         }
 980       }
 981
 982       // Compute the label range.
 983       const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
 984       const MCSymbol *End = getLabelAfterInsn(Range.second);
 985       if (!End) {
 986         // This range is valid until the next overlapping bitpiece. In the
 987         // common case, ranges will not be bitpieces, so they will overlap.
 988         auto J = std::next(I);
 989         while (J != E &&
 990                !fragmentsOverlap(DIExpr, J->first->getDebugExpression()))
 991           ++J;
 992         if (J != E)
 993           End = getLabelBeforeInsn(J->first);
 994         else
 995           End = Asm->getFunctionEnd();
 996       }
 997
 998       // If the last range end is our begin, just extend the last range.
 999       // Otherwise make a new range.
1000       SmallVectorImpl<std::pair<const MCSymbol *, const MCSymbol *>> &Ranges =
1001           Var.DefRanges.back().Ranges;
1002       if (!Ranges.empty() && Ranges.back().second == Begin)
1003         Ranges.back().second = End;
1004       else
1005         Ranges.emplace_back(Begin, End);
1006
1007       // FIXME: Do more range combining.
1008     }
1009
1010     recordLocalVariable(std::move(Var), InlinedAt);
1011   }
1012 }
1013
1014 void CodeViewDebug::beginFunction(const MachineFunction *MF) {
1015   assert(!CurFn && "Can't process two functions at once!");
1016
1017   if (!Asm || !MMI->hasDebugInfo() || !MF->getFunction()->getSubprogram())
1018     return;
1019
1020   DebugHandlerBase::beginFunction(MF);
1021
1022   const Function *GV = MF->getFunction();
1023   assert(FnDebugInfo.count(GV) == false);
1024   CurFn = &FnDebugInfo[GV];
1025   CurFn->FuncId = NextFuncId++;
1026   CurFn->Begin = Asm->getFunctionBegin();
1027
1028   OS.EmitCVFuncIdDirective(CurFn->FuncId);
1029
1030   // Find the end of the function prolog.  First known non-DBG_VALUE and
1031   // non-frame setup location marks the beginning of the function body.
1032   // FIXME: is there a simpler a way to do this? Can we just search
1033   // for the first instruction of the function, not the last of the prolog?
1034   DebugLoc PrologEndLoc;
1035   bool EmptyPrologue = true;
1036   for (const auto &MBB : *MF) {
1037     for (const auto &MI : MBB) {
1038       if (!MI.isDebugValue() && !MI.getFlag(MachineInstr::FrameSetup) &&
1039           MI.getDebugLoc()) {
1040         PrologEndLoc = MI.getDebugLoc();
1041         break;
1042       } else if (!MI.isDebugValue()) {
1043         EmptyPrologue = false;
1044       }
1045     }
1046   }
1047
1048   // Record beginning of function if we have a non-empty prologue.
1049   if (PrologEndLoc && !EmptyPrologue) {
1050     DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc();
1051     maybeRecordLocation(FnStartDL, MF);
1052   }
1053 }
1054
1055 void CodeViewDebug::addToUDTs(const DIType *Ty, TypeIndex TI) {
1056   // Don't record empty UDTs.
1057   if (Ty->getName().empty())
1058     return;
1059
1060   SmallVector<StringRef, 5> QualifiedNameComponents;
1061   const DISubprogram *ClosestSubprogram = getQualifiedNameComponents(
1062       Ty->getScope().resolve(), QualifiedNameComponents);
1063
1064   std::string FullyQualifiedName =
1065       getQualifiedName(QualifiedNameComponents, getPrettyScopeName(Ty));
1066
1067   if (ClosestSubprogram == nullptr)
1068     GlobalUDTs.emplace_back(std::move(FullyQualifiedName), TI);
1069   else if (ClosestSubprogram == CurrentSubprogram)
1070     LocalUDTs.emplace_back(std::move(FullyQualifiedName), TI);
1071
1072   // TODO: What if the ClosestSubprogram is neither null or the current
1073   // subprogram?  Currently, the UDT just gets dropped on the floor.
1074   //
1075   // The current behavior is not desirable.  To get maximal fidelity, we would
1076   // need to perform all type translation before beginning emission of .debug$S
1077   // and then make LocalUDTs a member of FunctionInfo
1078 }
1079
1080 TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
1081   // Generic dispatch for lowering an unknown type.
1082   switch (Ty->getTag()) {
1083   case dwarf::DW_TAG_array_type:
1084     return lowerTypeArray(cast<DICompositeType>(Ty));
1085   case dwarf::DW_TAG_typedef:
1086     return lowerTypeAlias(cast<DIDerivedType>(Ty));
1087   case dwarf::DW_TAG_base_type:
1088     return lowerTypeBasic(cast<DIBasicType>(Ty));
1089   case dwarf::DW_TAG_pointer_type:
1090     if (cast<DIDerivedType>(Ty)->getName() == "__vtbl_ptr_type")
1091       return lowerTypeVFTableShape(cast<DIDerivedType>(Ty));
1092     LLVM_FALLTHROUGH;
1093   case dwarf::DW_TAG_reference_type:
1094   case dwarf::DW_TAG_rvalue_reference_type:
1095     return lowerTypePointer(cast<DIDerivedType>(Ty));
1096   case dwarf::DW_TAG_ptr_to_member_type:
1097     return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
1098   case dwarf::DW_TAG_const_type:
1099   case dwarf::DW_TAG_volatile_type:
1100   // TODO: add support for DW_TAG_atomic_type here
1101     return lowerTypeModifier(cast<DIDerivedType>(Ty));
1102   case dwarf::DW_TAG_subroutine_type:
1103     if (ClassTy) {
1104       // The member function type of a member function pointer has no
1105       // ThisAdjustment.
1106       return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy,
1107                                      /*ThisAdjustment=*/0);
1108     }
1109     return lowerTypeFunction(cast<DISubroutineType>(Ty));
1110   case dwarf::DW_TAG_enumeration_type:
1111     return lowerTypeEnum(cast<DICompositeType>(Ty));
1112   case dwarf::DW_TAG_class_type:
1113   case dwarf::DW_TAG_structure_type:
1114     return lowerTypeClass(cast<DICompositeType>(Ty));
1115   case dwarf::DW_TAG_union_type:
1116     return lowerTypeUnion(cast<DICompositeType>(Ty));
1117   default:
1118     // Use the null type index.
1119     return TypeIndex();
1120   }
1121 }
1122
1123 TypeIndex CodeViewDebug::lowerTypeAlias(const DIDerivedType *Ty) {
1124   DITypeRef UnderlyingTypeRef = Ty->getBaseType();
1125   TypeIndex UnderlyingTypeIndex = getTypeIndex(UnderlyingTypeRef);
1126   StringRef TypeName = Ty->getName();
1127
1128   addToUDTs(Ty, UnderlyingTypeIndex);
1129
1130   if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::Int32Long) &&
1131       TypeName == "HRESULT")
1132     return TypeIndex(SimpleTypeKind::HResult);
1133   if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::UInt16Short) &&
1134       TypeName == "wchar_t")
1135     return TypeIndex(SimpleTypeKind::WideCharacter);
1136
1137   return UnderlyingTypeIndex;
1138 }
1139
1140 TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) {
1141   DITypeRef ElementTypeRef = Ty->getBaseType();
1142   TypeIndex ElementTypeIndex = getTypeIndex(ElementTypeRef);
1143   // IndexType is size_t, which depends on the bitness of the target.
1144   TypeIndex IndexType = Asm->MAI->getPointerSize() == 8
1145                             ? TypeIndex(SimpleTypeKind::UInt64Quad)
1146                             : TypeIndex(SimpleTypeKind::UInt32Long);
1147
1148   uint64_t ElementSize = getBaseTypeSize(ElementTypeRef) / 8;
1149
1150
1151   // We want to assert that the element type multiplied by the array lengths
1152   // match the size of the overall array. However, if we don't have complete
1153   // type information for the base type, we can't make this assertion. This
1154   // happens if limited debug info is enabled in this case:
1155   //   struct VTableOptzn { VTableOptzn(); virtual ~VTableOptzn(); };
1156   //   VTableOptzn array[3];
1157   // The DICompositeType of VTableOptzn will have size zero, and the array will
1158   // have size 3 * sizeof(void*), and we should avoid asserting.
1159   //
1160   // There is a related bug in the front-end where an array of a structure,
1161   // which was declared as incomplete structure first, ends up not getting a
1162   // size assigned to it. (PR28303)
1163   // Example:
1164   //   struct A(*p)[3];
1165   //   struct A { int f; } a[3];
1166   bool PartiallyIncomplete = false;
1167   if (Ty->getSizeInBits() == 0 || ElementSize == 0) {
1168     PartiallyIncomplete = true;
1169   }
1170
1171   // Add subranges to array type.
1172   DINodeArray Elements = Ty->getElements();
1173   for (int i = Elements.size() - 1; i >= 0; --i) {
1174     const DINode *Element = Elements[i];
1175     assert(Element->getTag() == dwarf::DW_TAG_subrange_type);
1176
1177     const DISubrange *Subrange = cast<DISubrange>(Element);
1178     assert(Subrange->getLowerBound() == 0 &&
1179            "codeview doesn't support subranges with lower bounds");
1180     int64_t Count = Subrange->getCount();
1181
1182     // Variable Length Array (VLA) has Count equal to '-1'.
1183     // Replace with Count '1', assume it is the minimum VLA length.
1184     // FIXME: Make front-end support VLA subrange and emit LF_DIMVARLU.
1185     if (Count == -1) {
1186       Count = 1;
1187       PartiallyIncomplete = true;
1188     }
1189
1190     // Update the element size and element type index for subsequent subranges.
1191     ElementSize *= Count;
1192
1193     // If this is the outermost array, use the size from the array. It will be
1194     // more accurate if PartiallyIncomplete is true.
1195     uint64_t ArraySize =
1196         (i == 0 && ElementSize == 0) ? Ty->getSizeInBits() / 8 : ElementSize;
1197
1198     StringRef Name = (i == 0) ? Ty->getName() : "";
1199     ArrayRecord AR(ElementTypeIndex, IndexType, ArraySize, Name);
1200     ElementTypeIndex = TypeTable.writeKnownType(AR);
1201   }
1202
1203   (void)PartiallyIncomplete;
1204   assert(PartiallyIncomplete || ElementSize == (Ty->getSizeInBits() / 8));
1205
1206   return ElementTypeIndex;
1207 }
1208
1209 TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) {
1210   TypeIndex Index;
1211   dwarf::TypeKind Kind;
1212   uint32_t ByteSize;
1213
1214   Kind = static_cast<dwarf::TypeKind>(Ty->getEncoding());
1215   ByteSize = Ty->getSizeInBits() / 8;
1216
1217   SimpleTypeKind STK = SimpleTypeKind::None;
1218   switch (Kind) {
1219   case dwarf::DW_ATE_address:
1220     // FIXME: Translate
1221     break;
1222   case dwarf::DW_ATE_boolean:
1223     switch (ByteSize) {
1224     case 1:  STK = SimpleTypeKind::Boolean8;   break;
1225     case 2:  STK = SimpleTypeKind::Boolean16;  break;
1226     case 4:  STK = SimpleTypeKind::Boolean32;  break;
1227     case 8:  STK = SimpleTypeKind::Boolean64;  break;
1228     case 16: STK = SimpleTypeKind::Boolean128; break;
1229     }
1230     break;
1231   case dwarf::DW_ATE_complex_float:
1232     switch (ByteSize) {
1233     case 2:  STK = SimpleTypeKind::Complex16;  break;
1234     case 4:  STK = SimpleTypeKind::Complex32;  break;
1235     case 8:  STK = SimpleTypeKind::Complex64;  break;
1236     case 10: STK = SimpleTypeKind::Complex80;  break;
1237     case 16: STK = SimpleTypeKind::Complex128; break;
1238     }
1239     break;
1240   case dwarf::DW_ATE_float:
1241     switch (ByteSize) {
1242     case 2:  STK = SimpleTypeKind::Float16;  break;
1243     case 4:  STK = SimpleTypeKind::Float32;  break;
1244     case 6:  STK = SimpleTypeKind::Float48;  break;
1245     case 8:  STK = SimpleTypeKind::Float64;  break;
1246     case 10: STK = SimpleTypeKind::Float80;  break;
1247     case 16: STK = SimpleTypeKind::Float128; break;
1248     }
1249     break;
1250   case dwarf::DW_ATE_signed:
1251     switch (ByteSize) {
1252     case 1:  STK = SimpleTypeKind::SignedCharacter; break;
1253     case 2:  STK = SimpleTypeKind::Int16Short;      break;
1254     case 4:  STK = SimpleTypeKind::Int32;           break;
1255     case 8:  STK = SimpleTypeKind::Int64Quad;       break;
1256     case 16: STK = SimpleTypeKind::Int128Oct;       break;
1257     }
1258     break;
1259   case dwarf::DW_ATE_unsigned:
1260     switch (ByteSize) {
1261     case 1:  STK = SimpleTypeKind::UnsignedCharacter; break;
1262     case 2:  STK = SimpleTypeKind::UInt16Short;       break;
1263     case 4:  STK = SimpleTypeKind::UInt32;            break;
1264     case 8:  STK = SimpleTypeKind::UInt64Quad;        break;
1265     case 16: STK = SimpleTypeKind::UInt128Oct;        break;
1266     }
1267     break;
1268   case dwarf::DW_ATE_UTF:
1269     switch (ByteSize) {
1270     case 2: STK = SimpleTypeKind::Character16; break;
1271     case 4: STK = SimpleTypeKind::Character32; break;
1272     }
1273     break;
1274   case dwarf::DW_ATE_signed_char:
1275     if (ByteSize == 1)
1276       STK = SimpleTypeKind::SignedCharacter;
1277     break;
1278   case dwarf::DW_ATE_unsigned_char:
1279     if (ByteSize == 1)
1280       STK = SimpleTypeKind::UnsignedCharacter;
1281     break;
1282   default:
1283     break;
1284   }
1285
1286   // Apply some fixups based on the source-level type name.
1287   if (STK == SimpleTypeKind::Int32 && Ty->getName() == "long int")
1288     STK = SimpleTypeKind::Int32Long;
1289   if (STK == SimpleTypeKind::UInt32 && Ty->getName() == "long unsigned int")
1290     STK = SimpleTypeKind::UInt32Long;
1291   if (STK == SimpleTypeKind::UInt16Short &&
1292       (Ty->getName() == "wchar_t" || Ty->getName() == "__wchar_t"))
1293     STK = SimpleTypeKind::WideCharacter;
1294   if ((STK == SimpleTypeKind::SignedCharacter ||
1295        STK == SimpleTypeKind::UnsignedCharacter) &&
1296       Ty->getName() == "char")
1297     STK = SimpleTypeKind::NarrowCharacter;
1298
1299   return TypeIndex(STK);
1300 }
1301
1302 TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty) {
1303   TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
1304
1305   // Pointers to simple types can use SimpleTypeMode, rather than having a
1306   // dedicated pointer type record.
1307   if (PointeeTI.isSimple() &&
1308       PointeeTI.getSimpleMode() == SimpleTypeMode::Direct &&
1309       Ty->getTag() == dwarf::DW_TAG_pointer_type) {
1310     SimpleTypeMode Mode = Ty->getSizeInBits() == 64
1311                               ? SimpleTypeMode::NearPointer64
1312                               : SimpleTypeMode::NearPointer32;
1313     return TypeIndex(PointeeTI.getSimpleKind(), Mode);
1314   }
1315
1316   PointerKind PK =
1317       Ty->getSizeInBits() == 64 ? PointerKind::Near64 : PointerKind::Near32;
1318   PointerMode PM = PointerMode::Pointer;
1319   switch (Ty->getTag()) {
1320   default: llvm_unreachable("not a pointer tag type");
1321   case dwarf::DW_TAG_pointer_type:
1322     PM = PointerMode::Pointer;
1323     break;
1324   case dwarf::DW_TAG_reference_type:
1325     PM = PointerMode::LValueReference;
1326     break;
1327   case dwarf::DW_TAG_rvalue_reference_type:
1328     PM = PointerMode::RValueReference;
1329     break;
1330   }
1331   // FIXME: MSVC folds qualifiers into PointerOptions in the context of a method
1332   // 'this' pointer, but not normal contexts. Figure out what we're supposed to
1333   // do.
1334   PointerOptions PO = PointerOptions::None;
1335   PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8);
1336   return TypeTable.writeKnownType(PR);
1337 }
1338
1339 static PointerToMemberRepresentation
1340 translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags) {
1341   // SizeInBytes being zero generally implies that the member pointer type was
1342   // incomplete, which can happen if it is part of a function prototype. In this
1343   // case, use the unknown model instead of the general model.
1344   if (IsPMF) {
1345     switch (Flags & DINode::FlagPtrToMemberRep) {
1346     case 0:
1347       return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1348                               : PointerToMemberRepresentation::GeneralFunction;
1349     case DINode::FlagSingleInheritance:
1350       return PointerToMemberRepresentation::SingleInheritanceFunction;
1351     case DINode::FlagMultipleInheritance:
1352       return PointerToMemberRepresentation::MultipleInheritanceFunction;
1353     case DINode::FlagVirtualInheritance:
1354       return PointerToMemberRepresentation::VirtualInheritanceFunction;
1355     }
1356   } else {
1357     switch (Flags & DINode::FlagPtrToMemberRep) {
1358     case 0:
1359       return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1360                               : PointerToMemberRepresentation::GeneralData;
1361     case DINode::FlagSingleInheritance:
1362       return PointerToMemberRepresentation::SingleInheritanceData;
1363     case DINode::FlagMultipleInheritance:
1364       return PointerToMemberRepresentation::MultipleInheritanceData;
1365     case DINode::FlagVirtualInheritance:
1366       return PointerToMemberRepresentation::VirtualInheritanceData;
1367     }
1368   }
1369   llvm_unreachable("invalid ptr to member representation");
1370 }
1371
1372 TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty) {
1373   assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type);
1374   TypeIndex ClassTI = getTypeIndex(Ty->getClassType());
1375   TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType(), Ty->getClassType());
1376   PointerKind PK = Asm->MAI->getPointerSize() == 8 ? PointerKind::Near64
1377                                                    : PointerKind::Near32;
1378   bool IsPMF = isa<DISubroutineType>(Ty->getBaseType());
1379   PointerMode PM = IsPMF ? PointerMode::PointerToMemberFunction
1380                          : PointerMode::PointerToDataMember;
1381   PointerOptions PO = PointerOptions::None; // FIXME
1382   assert(Ty->getSizeInBits() / 8 <= 0xff && "pointer size too big");
1383   uint8_t SizeInBytes = Ty->getSizeInBits() / 8;
1384   MemberPointerInfo MPI(
1385       ClassTI, translatePtrToMemberRep(SizeInBytes, IsPMF, Ty->getFlags()));
1386   PointerRecord PR(PointeeTI, PK, PM, PO, SizeInBytes, MPI);
1387   return TypeTable.writeKnownType(PR);
1388 }
1389
1390 /// Given a DWARF calling convention, get the CodeView equivalent. If we don't
1391 /// have a translation, use the NearC convention.
1392 static CallingConvention dwarfCCToCodeView(unsigned DwarfCC) {
1393   switch (DwarfCC) {
1394   case dwarf::DW_CC_normal:             return CallingConvention::NearC;
1395   case dwarf::DW_CC_BORLAND_msfastcall: return CallingConvention::NearFast;
1396   case dwarf::DW_CC_BORLAND_thiscall:   return CallingConvention::ThisCall;
1397   case dwarf::DW_CC_BORLAND_stdcall:    return CallingConvention::NearStdCall;
1398   case dwarf::DW_CC_BORLAND_pascal:     return CallingConvention::NearPascal;
1399   case dwarf::DW_CC_LLVM_vectorcall:    return CallingConvention::NearVector;
1400   }
1401   return CallingConvention::NearC;
1402 }
1403
1404 TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) {
1405   ModifierOptions Mods = ModifierOptions::None;
1406   bool IsModifier = true;
1407   const DIType *BaseTy = Ty;
1408   while (IsModifier && BaseTy) {
1409     // FIXME: Need to add DWARF tags for __unaligned and _Atomic
1410     switch (BaseTy->getTag()) {
1411     case dwarf::DW_TAG_const_type:
1412       Mods |= ModifierOptions::Const;
1413       break;
1414     case dwarf::DW_TAG_volatile_type:
1415       Mods |= ModifierOptions::Volatile;
1416       break;
1417     default:
1418       IsModifier = false;
1419       break;
1420     }
1421     if (IsModifier)
1422       BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
1423   }
1424   TypeIndex ModifiedTI = getTypeIndex(BaseTy);
1425   ModifierRecord MR(ModifiedTI, Mods);
1426   return TypeTable.writeKnownType(MR);
1427 }
1428
1429 TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) {
1430   SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
1431   for (DITypeRef ArgTypeRef : Ty->getTypeArray())
1432     ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
1433
1434   TypeIndex ReturnTypeIndex = TypeIndex::Void();
1435   ArrayRef<TypeIndex> ArgTypeIndices = None;
1436   if (!ReturnAndArgTypeIndices.empty()) {
1437     auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
1438     ReturnTypeIndex = ReturnAndArgTypesRef.front();
1439     ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
1440   }
1441
1442   ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1443   TypeIndex ArgListIndex = TypeTable.writeKnownType(ArgListRec);
1444
1445   CallingConvention CC = dwarfCCToCodeView(Ty->getCC());
1446
1447   ProcedureRecord Procedure(ReturnTypeIndex, CC, FunctionOptions::None,
1448                             ArgTypeIndices.size(), ArgListIndex);
1449   return TypeTable.writeKnownType(Procedure);
1450 }
1451
1452 TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty,
1453                                                  const DIType *ClassTy,
1454                                                  int ThisAdjustment) {
1455   // Lower the containing class type.
1456   TypeIndex ClassType = getTypeIndex(ClassTy);
1457
1458   SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
1459   for (DITypeRef ArgTypeRef : Ty->getTypeArray())
1460     ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
1461
1462   TypeIndex ReturnTypeIndex = TypeIndex::Void();
1463   ArrayRef<TypeIndex> ArgTypeIndices = None;
1464   if (!ReturnAndArgTypeIndices.empty()) {
1465     auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
1466     ReturnTypeIndex = ReturnAndArgTypesRef.front();
1467     ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
1468   }
1469   TypeIndex ThisTypeIndex = TypeIndex::Void();
1470   if (!ArgTypeIndices.empty()) {
1471     ThisTypeIndex = ArgTypeIndices.front();
1472     ArgTypeIndices = ArgTypeIndices.drop_front();
1473   }
1474
1475   ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1476   TypeIndex ArgListIndex = TypeTable.writeKnownType(ArgListRec);
1477
1478   CallingConvention CC = dwarfCCToCodeView(Ty->getCC());
1479
1480   // TODO: Need to use the correct values for:
1481   //       FunctionOptions
1482   //       ThisPointerAdjustment.
1483   MemberFunctionRecord MFR(ReturnTypeIndex, ClassType, ThisTypeIndex, CC,
1484                            FunctionOptions::None, ArgTypeIndices.size(),
1485                            ArgListIndex, ThisAdjustment);
1486   TypeIndex TI = TypeTable.writeKnownType(MFR);
1487
1488   return TI;
1489 }
1490
1491 TypeIndex CodeViewDebug::lowerTypeVFTableShape(const DIDerivedType *Ty) {
1492   unsigned VSlotCount = Ty->getSizeInBits() / (8 * Asm->MAI->getPointerSize());
1493   SmallVector<VFTableSlotKind, 4> Slots(VSlotCount, VFTableSlotKind::Near);
1494
1495   VFTableShapeRecord VFTSR(Slots);
1496   return TypeTable.writeKnownType(VFTSR);
1497 }
1498
1499 static MemberAccess translateAccessFlags(unsigned RecordTag, unsigned Flags) {
1500   switch (Flags & DINode::FlagAccessibility) {
1501   case DINode::FlagPrivate:   return MemberAccess::Private;
1502   case DINode::FlagPublic:    return MemberAccess::Public;
1503   case DINode::FlagProtected: return MemberAccess::Protected;
1504   case 0:
1505     // If there was no explicit access control, provide the default for the tag.
1506     return RecordTag == dwarf::DW_TAG_class_type ? MemberAccess::Private
1507                                                  : MemberAccess::Public;
1508   }
1509   llvm_unreachable("access flags are exclusive");
1510 }
1511
1512 static MethodOptions translateMethodOptionFlags(const DISubprogram *SP) {
1513   if (SP->isArtificial())
1514     return MethodOptions::CompilerGenerated;
1515
1516   // FIXME: Handle other MethodOptions.
1517
1518   return MethodOptions::None;
1519 }
1520
1521 static MethodKind translateMethodKindFlags(const DISubprogram *SP,
1522                                            bool Introduced) {
1523   switch (SP->getVirtuality()) {
1524   case dwarf::DW_VIRTUALITY_none:
1525     break;
1526   case dwarf::DW_VIRTUALITY_virtual:
1527     return Introduced ? MethodKind::IntroducingVirtual : MethodKind::Virtual;
1528   case dwarf::DW_VIRTUALITY_pure_virtual:
1529     return Introduced ? MethodKind::PureIntroducingVirtual
1530                       : MethodKind::PureVirtual;
1531   default:
1532     llvm_unreachable("unhandled virtuality case");
1533   }
1534
1535   // FIXME: Get Clang to mark DISubprogram as static and do something with it.
1536
1537   return MethodKind::Vanilla;
1538 }
1539
1540 static TypeRecordKind getRecordKind(const DICompositeType *Ty) {
1541   switch (Ty->getTag()) {
1542   case dwarf::DW_TAG_class_type:     return TypeRecordKind::Class;
1543   case dwarf::DW_TAG_structure_type: return TypeRecordKind::Struct;
1544   }
1545   llvm_unreachable("unexpected tag");
1546 }
1547
1548 /// Return ClassOptions that should be present on both the forward declaration
1549 /// and the defintion of a tag type.
1550 static ClassOptions getCommonClassOptions(const DICompositeType *Ty) {
1551   ClassOptions CO = ClassOptions::None;
1552
1553   // MSVC always sets this flag, even for local types. Clang doesn't always
1554   // appear to give every type a linkage name, which may be problematic for us.
1555   // FIXME: Investigate the consequences of not following them here.
1556   if (!Ty->getIdentifier().empty())
1557     CO |= ClassOptions::HasUniqueName;
1558
1559   // Put the Nested flag on a type if it appears immediately inside a tag type.
1560   // Do not walk the scope chain. Do not attempt to compute ContainsNestedClass
1561   // here. That flag is only set on definitions, and not forward declarations.
1562   const DIScope *ImmediateScope = Ty->getScope().resolve();
1563   if (ImmediateScope && isa<DICompositeType>(ImmediateScope))
1564     CO |= ClassOptions::Nested;
1565
1566   // Put the Scoped flag on function-local types.
1567   for (const DIScope *Scope = ImmediateScope; Scope != nullptr;
1568        Scope = Scope->getScope().resolve()) {
1569     if (isa<DISubprogram>(Scope)) {
1570       CO |= ClassOptions::Scoped;
1571       break;
1572     }
1573   }
1574
1575   return CO;
1576 }
1577
1578 TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) {
1579   ClassOptions CO = getCommonClassOptions(Ty);
1580   TypeIndex FTI;
1581   unsigned EnumeratorCount = 0;
1582
1583   if (Ty->isForwardDecl()) {
1584     CO |= ClassOptions::ForwardReference;
1585   } else {
1586     FieldListRecordBuilder FLRB(TypeTable);
1587
1588     FLRB.begin();
1589     for (const DINode *Element : Ty->getElements()) {
1590       // We assume that the frontend provides all members in source declaration
1591       // order, which is what MSVC does.
1592       if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) {
1593         EnumeratorRecord ER(MemberAccess::Public,
1594                             APSInt::getUnsigned(Enumerator->getValue()),
1595                             Enumerator->getName());
1596         FLRB.writeMemberType(ER);
1597         EnumeratorCount++;
1598       }
1599     }
1600     FTI = FLRB.end();
1601   }
1602
1603   std::string FullName = getFullyQualifiedName(Ty);
1604
1605   EnumRecord ER(EnumeratorCount, CO, FTI, FullName, Ty->getIdentifier(),
1606                 getTypeIndex(Ty->getBaseType()));
1607   return TypeTable.writeKnownType(ER);
1608 }
1609
1610 //===----------------------------------------------------------------------===//
1611 // ClassInfo
1612 //===----------------------------------------------------------------------===//
1613
1614 struct llvm::ClassInfo {
1615   struct MemberInfo {
1616     const DIDerivedType *MemberTypeNode;
1617     uint64_t BaseOffset;
1618   };
1619   // [MemberInfo]
1620   typedef std::vector<MemberInfo> MemberList;
1621
1622   typedef TinyPtrVector<const DISubprogram *> MethodsList;
1623   // MethodName -> MethodsList
1624   typedef MapVector<MDString *, MethodsList> MethodsMap;
1625
1626   /// Base classes.
1627   std::vector<const DIDerivedType *> Inheritance;
1628
1629   /// Direct members.
1630   MemberList Members;
1631   // Direct overloaded methods gathered by name.
1632   MethodsMap Methods;
1633
1634   TypeIndex VShapeTI;
1635
1636   std::vector<const DICompositeType *> NestedClasses;
1637 };
1638
1639 void CodeViewDebug::clear() {
1640   assert(CurFn == nullptr);
1641   FileIdMap.clear();
1642   FnDebugInfo.clear();
1643   FileToFilepathMap.clear();
1644   LocalUDTs.clear();
1645   GlobalUDTs.clear();
1646   TypeIndices.clear();
1647   CompleteTypeIndices.clear();
1648 }
1649
1650 void CodeViewDebug::collectMemberInfo(ClassInfo &Info,
1651                                       const DIDerivedType *DDTy) {
1652   if (!DDTy->getName().empty()) {
1653     Info.Members.push_back({DDTy, 0});
1654     return;
1655   }
1656   // An unnamed member must represent a nested struct or union. Add all the
1657   // indirect fields to the current record.
1658   assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!");
1659   uint64_t Offset = DDTy->getOffsetInBits();
1660   const DIType *Ty = DDTy->getBaseType().resolve();
1661   const DICompositeType *DCTy = cast<DICompositeType>(Ty);
1662   ClassInfo NestedInfo = collectClassInfo(DCTy);
1663   for (const ClassInfo::MemberInfo &IndirectField : NestedInfo.Members)
1664     Info.Members.push_back(
1665         {IndirectField.MemberTypeNode, IndirectField.BaseOffset + Offset});
1666 }
1667
1668 ClassInfo CodeViewDebug::collectClassInfo(const DICompositeType *Ty) {
1669   ClassInfo Info;
1670   // Add elements to structure type.
1671   DINodeArray Elements = Ty->getElements();
1672   for (auto *Element : Elements) {
1673     // We assume that the frontend provides all members in source declaration
1674     // order, which is what MSVC does.
1675     if (!Element)
1676       continue;
1677     if (auto *SP = dyn_cast<DISubprogram>(Element)) {
1678       Info.Methods[SP->getRawName()].push_back(SP);
1679     } else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
1680       if (DDTy->getTag() == dwarf::DW_TAG_member) {
1681         collectMemberInfo(Info, DDTy);
1682       } else if (DDTy->getTag() == dwarf::DW_TAG_inheritance) {
1683         Info.Inheritance.push_back(DDTy);
1684       } else if (DDTy->getTag() == dwarf::DW_TAG_pointer_type &&
1685                  DDTy->getName() == "__vtbl_ptr_type") {
1686         Info.VShapeTI = getTypeIndex(DDTy);
1687       } else if (DDTy->getTag() == dwarf::DW_TAG_friend) {
1688         // Ignore friend members. It appears that MSVC emitted info about
1689         // friends in the past, but modern versions do not.
1690       }
1691     } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
1692       Info.NestedClasses.push_back(Composite);
1693     }
1694     // Skip other unrecognized kinds of elements.
1695   }
1696   return Info;
1697 }
1698
1699 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
1700   // First, construct the forward decl.  Don't look into Ty to compute the
1701   // forward decl options, since it might not be available in all TUs.
1702   TypeRecordKind Kind = getRecordKind(Ty);
1703   ClassOptions CO =
1704       ClassOptions::ForwardReference | getCommonClassOptions(Ty);
1705   std::string FullName = getFullyQualifiedName(Ty);
1706   ClassRecord CR(Kind, 0, CO, TypeIndex(), TypeIndex(), TypeIndex(), 0,
1707                  FullName, Ty->getIdentifier());
1708   TypeIndex FwdDeclTI = TypeTable.writeKnownType(CR);
1709   if (!Ty->isForwardDecl())
1710     DeferredCompleteTypes.push_back(Ty);
1711   return FwdDeclTI;
1712 }
1713
1714 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
1715   // Construct the field list and complete type record.
1716   TypeRecordKind Kind = getRecordKind(Ty);
1717   ClassOptions CO = getCommonClassOptions(Ty);
1718   TypeIndex FieldTI;
1719   TypeIndex VShapeTI;
1720   unsigned FieldCount;
1721   bool ContainsNestedClass;
1722   std::tie(FieldTI, VShapeTI, FieldCount, ContainsNestedClass) =
1723       lowerRecordFieldList(Ty);
1724
1725   if (ContainsNestedClass)
1726     CO |= ClassOptions::ContainsNestedClass;
1727
1728   std::string FullName = getFullyQualifiedName(Ty);
1729
1730   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
1731
1732   ClassRecord CR(Kind, FieldCount, CO, FieldTI, TypeIndex(), VShapeTI,
1733                  SizeInBytes, FullName, Ty->getIdentifier());
1734   TypeIndex ClassTI = TypeTable.writeKnownType(CR);
1735
1736   StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(Ty->getFile()));
1737   TypeIndex SIDI = TypeTable.writeKnownType(SIDR);
1738   UdtSourceLineRecord USLR(ClassTI, SIDI, Ty->getLine());
1739   TypeTable.writeKnownType(USLR);
1740
1741   addToUDTs(Ty, ClassTI);
1742
1743   return ClassTI;
1744 }
1745
1746 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
1747   ClassOptions CO =
1748       ClassOptions::ForwardReference | getCommonClassOptions(Ty);
1749   std::string FullName = getFullyQualifiedName(Ty);
1750   UnionRecord UR(0, CO, TypeIndex(), 0, FullName, Ty->getIdentifier());
1751   TypeIndex FwdDeclTI = TypeTable.writeKnownType(UR);
1752   if (!Ty->isForwardDecl())
1753     DeferredCompleteTypes.push_back(Ty);
1754   return FwdDeclTI;
1755 }
1756
1757 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
1758   ClassOptions CO = ClassOptions::Sealed | getCommonClassOptions(Ty);
1759   TypeIndex FieldTI;
1760   unsigned FieldCount;
1761   bool ContainsNestedClass;
1762   std::tie(FieldTI, std::ignore, FieldCount, ContainsNestedClass) =
1763       lowerRecordFieldList(Ty);
1764
1765   if (ContainsNestedClass)
1766     CO |= ClassOptions::ContainsNestedClass;
1767
1768   uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
1769   std::string FullName = getFullyQualifiedName(Ty);
1770
1771   UnionRecord UR(FieldCount, CO, FieldTI, SizeInBytes, FullName,
1772                  Ty->getIdentifier());
1773   TypeIndex UnionTI = TypeTable.writeKnownType(UR);
1774
1775   StringIdRecord SIR(TypeIndex(0x0), getFullFilepath(Ty->getFile()));
1776   TypeIndex SIRI = TypeTable.writeKnownType(SIR);
1777   UdtSourceLineRecord USLR(UnionTI, SIRI, Ty->getLine());
1778   TypeTable.writeKnownType(USLR);
1779
1780   addToUDTs(Ty, UnionTI);
1781
1782   return UnionTI;
1783 }
1784
1785 std::tuple<TypeIndex, TypeIndex, unsigned, bool>
1786 CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) {
1787   // Manually count members. MSVC appears to count everything that generates a
1788   // field list record. Each individual overload in a method overload group
1789   // contributes to this count, even though the overload group is a single field
1790   // list record.
1791   unsigned MemberCount = 0;
1792   ClassInfo Info = collectClassInfo(Ty);
1793   FieldListRecordBuilder FLBR(TypeTable);
1794   FLBR.begin();
1795
1796   // Create base classes.
1797   for (const DIDerivedType *I : Info.Inheritance) {
1798     if (I->getFlags() & DINode::FlagVirtual) {
1799       // Virtual base.
1800       // FIXME: Emit VBPtrOffset when the frontend provides it.
1801       unsigned VBPtrOffset = 0;
1802       // FIXME: Despite the accessor name, the offset is really in bytes.
1803       unsigned VBTableIndex = I->getOffsetInBits() / 4;
1804       auto RecordKind = (I->getFlags() & DINode::FlagIndirectVirtualBase) == DINode::FlagIndirectVirtualBase
1805                             ? TypeRecordKind::IndirectVirtualBaseClass
1806                             : TypeRecordKind::VirtualBaseClass;
1807       VirtualBaseClassRecord VBCR(
1808           RecordKind, translateAccessFlags(Ty->getTag(), I->getFlags()),
1809           getTypeIndex(I->getBaseType()), getVBPTypeIndex(), VBPtrOffset,
1810           VBTableIndex);
1811
1812       FLBR.writeMemberType(VBCR);
1813     } else {
1814       assert(I->getOffsetInBits() % 8 == 0 &&
1815              "bases must be on byte boundaries");
1816       BaseClassRecord BCR(translateAccessFlags(Ty->getTag(), I->getFlags()),
1817                           getTypeIndex(I->getBaseType()),
1818                           I->getOffsetInBits() / 8);
1819       FLBR.writeMemberType(BCR);
1820     }
1821   }
1822
1823   // Create members.
1824   for (ClassInfo::MemberInfo &MemberInfo : Info.Members) {
1825     const DIDerivedType *Member = MemberInfo.MemberTypeNode;
1826     TypeIndex MemberBaseType = getTypeIndex(Member->getBaseType());
1827     StringRef MemberName = Member->getName();
1828     MemberAccess Access =
1829         translateAccessFlags(Ty->getTag(), Member->getFlags());
1830
1831     if (Member->isStaticMember()) {
1832       StaticDataMemberRecord SDMR(Access, MemberBaseType, MemberName);
1833       FLBR.writeMemberType(SDMR);
1834       MemberCount++;
1835       continue;
1836     }
1837
1838     // Virtual function pointer member.
1839     if ((Member->getFlags() & DINode::FlagArtificial) &&
1840         Member->getName().startswith("_vptr$")) {
1841       VFPtrRecord VFPR(getTypeIndex(Member->getBaseType()));
1842       FLBR.writeMemberType(VFPR);
1843       MemberCount++;
1844       continue;
1845     }
1846
1847     // Data member.
1848     uint64_t MemberOffsetInBits =
1849         Member->getOffsetInBits() + MemberInfo.BaseOffset;
1850     if (Member->isBitField()) {
1851       uint64_t StartBitOffset = MemberOffsetInBits;
1852       if (const auto *CI =
1853               dyn_cast_or_null<ConstantInt>(Member->getStorageOffsetInBits())) {
1854         MemberOffsetInBits = CI->getZExtValue() + MemberInfo.BaseOffset;
1855       }
1856       StartBitOffset -= MemberOffsetInBits;
1857       BitFieldRecord BFR(MemberBaseType, Member->getSizeInBits(),
1858                          StartBitOffset);
1859       MemberBaseType = TypeTable.writeKnownType(BFR);
1860     }
1861     uint64_t MemberOffsetInBytes = MemberOffsetInBits / 8;
1862     DataMemberRecord DMR(Access, MemberBaseType, MemberOffsetInBytes,
1863                          MemberName);
1864     FLBR.writeMemberType(DMR);
1865     MemberCount++;
1866   }
1867
1868   // Create methods
1869   for (auto &MethodItr : Info.Methods) {
1870     StringRef Name = MethodItr.first->getString();
1871
1872     std::vector<OneMethodRecord> Methods;
1873     for (const DISubprogram *SP : MethodItr.second) {
1874       TypeIndex MethodType = getMemberFunctionType(SP, Ty);
1875       bool Introduced = SP->getFlags() & DINode::FlagIntroducedVirtual;
1876
1877       unsigned VFTableOffset = -1;
1878       if (Introduced)
1879         VFTableOffset = SP->getVirtualIndex() * getPointerSizeInBytes();
1880
1881       Methods.push_back(OneMethodRecord(
1882           MethodType, translateAccessFlags(Ty->getTag(), SP->getFlags()),
1883           translateMethodKindFlags(SP, Introduced),
1884           translateMethodOptionFlags(SP), VFTableOffset, Name));
1885       MemberCount++;
1886     }
1887     assert(Methods.size() > 0 && "Empty methods map entry");
1888     if (Methods.size() == 1)
1889       FLBR.writeMemberType(Methods[0]);
1890     else {
1891       MethodOverloadListRecord MOLR(Methods);
1892       TypeIndex MethodList = TypeTable.writeKnownType(MOLR);
1893       OverloadedMethodRecord OMR(Methods.size(), MethodList, Name);
1894       FLBR.writeMemberType(OMR);
1895     }
1896   }
1897
1898   // Create nested classes.
1899   for (const DICompositeType *Nested : Info.NestedClasses) {
1900     NestedTypeRecord R(getTypeIndex(DITypeRef(Nested)), Nested->getName());
1901     FLBR.writeMemberType(R);
1902     MemberCount++;
1903   }
1904
1905   TypeIndex FieldTI = FLBR.end();
1906   return std::make_tuple(FieldTI, Info.VShapeTI, MemberCount,
1907                          !Info.NestedClasses.empty());
1908 }
1909
1910 TypeIndex CodeViewDebug::getVBPTypeIndex() {
1911   if (!VBPType.getIndex()) {
1912     // Make a 'const int *' type.
1913     ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);
1914     TypeIndex ModifiedTI = TypeTable.writeKnownType(MR);
1915
1916     PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
1917                                                   : PointerKind::Near32;
1918     PointerMode PM = PointerMode::Pointer;
1919     PointerOptions PO = PointerOptions::None;
1920     PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes());
1921
1922     VBPType = TypeTable.writeKnownType(PR);
1923   }
1924
1925   return VBPType;
1926 }
1927
1928 TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
1929   const DIType *Ty = TypeRef.resolve();
1930   const DIType *ClassTy = ClassTyRef.resolve();
1931
1932   // The null DIType is the void type. Don't try to hash it.
1933   if (!Ty)
1934     return TypeIndex::Void();
1935
1936   // Check if we've already translated this type. Don't try to do a
1937   // get-or-create style insertion that caches the hash lookup across the
1938   // lowerType call. It will update the TypeIndices map.
1939   auto I = TypeIndices.find({Ty, ClassTy});
1940   if (I != TypeIndices.end())
1941     return I->second;
1942
1943   TypeLoweringScope S(*this);
1944   TypeIndex TI = lowerType(Ty, ClassTy);
1945   return recordTypeIndexForDINode(Ty, TI, ClassTy);
1946 }
1947
1948 TypeIndex CodeViewDebug::getCompleteTypeIndex(DITypeRef TypeRef) {
1949   const DIType *Ty = TypeRef.resolve();
1950
1951   // The null DIType is the void type. Don't try to hash it.
1952   if (!Ty)
1953     return TypeIndex::Void();
1954
1955   // If this is a non-record type, the complete type index is the same as the
1956   // normal type index. Just call getTypeIndex.
1957   switch (Ty->getTag()) {
1958   case dwarf::DW_TAG_class_type:
1959   case dwarf::DW_TAG_structure_type:
1960   case dwarf::DW_TAG_union_type:
1961     break;
1962   default:
1963     return getTypeIndex(Ty);
1964   }
1965
1966   // Check if we've already translated the complete record type.  Lowering a
1967   // complete type should never trigger lowering another complete type, so we
1968   // can reuse the hash table lookup result.
1969   const auto *CTy = cast<DICompositeType>(Ty);
1970   auto InsertResult = CompleteTypeIndices.insert({CTy, TypeIndex()});
1971   if (!InsertResult.second)
1972     return InsertResult.first->second;
1973
1974   TypeLoweringScope S(*this);
1975
1976   // Make sure the forward declaration is emitted first. It's unclear if this
1977   // is necessary, but MSVC does it, and we should follow suit until we can show
1978   // otherwise.
1979   TypeIndex FwdDeclTI = getTypeIndex(CTy);
1980
1981   // Just use the forward decl if we don't have complete type info. This might
1982   // happen if the frontend is using modules and expects the complete definition
1983   // to be emitted elsewhere.
1984   if (CTy->isForwardDecl())
1985     return FwdDeclTI;
1986
1987   TypeIndex TI;
1988   switch (CTy->getTag()) {
1989   case dwarf::DW_TAG_class_type:
1990   case dwarf::DW_TAG_structure_type:
1991     TI = lowerCompleteTypeClass(CTy);
1992     break;
1993   case dwarf::DW_TAG_union_type:
1994     TI = lowerCompleteTypeUnion(CTy);
1995     break;
1996   default:
1997     llvm_unreachable("not a record");
1998   }
1999
2000   InsertResult.first->second = TI;
2001   return TI;
2002 }
2003
2004 /// Emit all the deferred complete record types. Try to do this in FIFO order,
2005 /// and do this until fixpoint, as each complete record type typically
2006 /// references
2007 /// many other record types.
2008 void CodeViewDebug::emitDeferredCompleteTypes() {
2009   SmallVector<const DICompositeType *, 4> TypesToEmit;
2010   while (!DeferredCompleteTypes.empty()) {
2011     std::swap(DeferredCompleteTypes, TypesToEmit);
2012     for (const DICompositeType *RecordTy : TypesToEmit)
2013       getCompleteTypeIndex(RecordTy);
2014     TypesToEmit.clear();
2015   }
2016 }
2017
2018 void CodeViewDebug::emitLocalVariableList(ArrayRef<LocalVariable> Locals) {
2019   // Get the sorted list of parameters and emit them first.
2020   SmallVector<const LocalVariable *, 6> Params;
2021   for (const LocalVariable &L : Locals)
2022     if (L.DIVar->isParameter())
2023       Params.push_back(&L);
2024   std::sort(Params.begin(), Params.end(),
2025             [](const LocalVariable *L, const LocalVariable *R) {
2026               return L->DIVar->getArg() < R->DIVar->getArg();
2027             });
2028   for (const LocalVariable *L : Params)
2029     emitLocalVariable(*L);
2030
2031   // Next emit all non-parameters in the order that we found them.
2032   for (const LocalVariable &L : Locals)
2033     if (!L.DIVar->isParameter())
2034       emitLocalVariable(L);
2035 }
2036
2037 void CodeViewDebug::emitLocalVariable(const LocalVariable &Var) {
2038   // LocalSym record, see SymbolRecord.h for more info.
2039   MCSymbol *LocalBegin = MMI->getContext().createTempSymbol(),
2040            *LocalEnd = MMI->getContext().createTempSymbol();
2041   OS.AddComment("Record length");
2042   OS.emitAbsoluteSymbolDiff(LocalEnd, LocalBegin, 2);
2043   OS.EmitLabel(LocalBegin);
2044
2045   OS.AddComment("Record kind: S_LOCAL");
2046   OS.EmitIntValue(unsigned(SymbolKind::S_LOCAL), 2);
2047
2048   LocalSymFlags Flags = LocalSymFlags::None;
2049   if (Var.DIVar->isParameter())
2050     Flags |= LocalSymFlags::IsParameter;
2051   if (Var.DefRanges.empty())
2052     Flags |= LocalSymFlags::IsOptimizedOut;
2053
2054   OS.AddComment("TypeIndex");
2055   TypeIndex TI = getCompleteTypeIndex(Var.DIVar->getType());
2056   OS.EmitIntValue(TI.getIndex(), 4);
2057   OS.AddComment("Flags");
2058   OS.EmitIntValue(static_cast<uint16_t>(Flags), 2);
2059   // Truncate the name so we won't overflow the record length field.
2060   emitNullTerminatedSymbolName(OS, Var.DIVar->getName());
2061   OS.EmitLabel(LocalEnd);
2062
2063   // Calculate the on disk prefix of the appropriate def range record. The
2064   // records and on disk formats are described in SymbolRecords.h. BytePrefix
2065   // should be big enough to hold all forms without memory allocation.
2066   SmallString<20> BytePrefix;
2067   for (const LocalVarDefRange &DefRange : Var.DefRanges) {
2068     BytePrefix.clear();
2069     if (DefRange.InMemory) {
2070       uint16_t RegRelFlags = 0;
2071       if (DefRange.IsSubfield) {
2072         RegRelFlags = DefRangeRegisterRelSym::IsSubfieldFlag |
2073                       (DefRange.StructOffset
2074                        << DefRangeRegisterRelSym::OffsetInParentShift);
2075       }
2076       DefRangeRegisterRelSym Sym(S_DEFRANGE_REGISTER_REL);
2077       Sym.Hdr.Register = DefRange.CVRegister;
2078       Sym.Hdr.Flags = RegRelFlags;
2079       Sym.Hdr.BasePointerOffset = DefRange.DataOffset;
2080       ulittle16_t SymKind = ulittle16_t(S_DEFRANGE_REGISTER_REL);
2081       BytePrefix +=
2082           StringRef(reinterpret_cast<const char *>(&SymKind), sizeof(SymKind));
2083       BytePrefix +=
2084           StringRef(reinterpret_cast<const char *>(&Sym.Hdr), sizeof(Sym.Hdr));
2085     } else {
2086       assert(DefRange.DataOffset == 0 && "unexpected offset into register");
2087       if (DefRange.IsSubfield) {
2088         // Unclear what matters here.
2089         DefRangeSubfieldRegisterSym Sym(S_DEFRANGE_SUBFIELD_REGISTER);
2090         Sym.Hdr.Register = DefRange.CVRegister;
2091         Sym.Hdr.MayHaveNoName = 0;
2092         Sym.Hdr.OffsetInParent = DefRange.StructOffset;
2093
2094         ulittle16_t SymKind = ulittle16_t(S_DEFRANGE_SUBFIELD_REGISTER);
2095         BytePrefix += StringRef(reinterpret_cast<const char *>(&SymKind),
2096                                 sizeof(SymKind));
2097         BytePrefix += StringRef(reinterpret_cast<const char *>(&Sym.Hdr),
2098                                 sizeof(Sym.Hdr));
2099       } else {
2100         // Unclear what matters here.
2101         DefRangeRegisterSym Sym(S_DEFRANGE_REGISTER);
2102         Sym.Hdr.Register = DefRange.CVRegister;
2103         Sym.Hdr.MayHaveNoName = 0;
2104         ulittle16_t SymKind = ulittle16_t(S_DEFRANGE_REGISTER);
2105         BytePrefix += StringRef(reinterpret_cast<const char *>(&SymKind),
2106                                 sizeof(SymKind));
2107         BytePrefix += StringRef(reinterpret_cast<const char *>(&Sym.Hdr),
2108                                 sizeof(Sym.Hdr));
2109       }
2110     }
2111     OS.EmitCVDefRangeDirective(DefRange.Ranges, BytePrefix);
2112   }
2113 }
2114
2115 void CodeViewDebug::endFunction(const MachineFunction *MF) {
2116   if (!Asm || !CurFn)  // We haven't created any debug info for this function.
2117     return;
2118
2119   const Function *GV = MF->getFunction();
2120   assert(FnDebugInfo.count(GV));
2121   assert(CurFn == &FnDebugInfo[GV]);
2122
2123   collectVariableInfo(GV->getSubprogram());
2124
2125   DebugHandlerBase::endFunction(MF);
2126
2127   // Don't emit anything if we don't have any line tables.
2128   if (!CurFn->HaveLineInfo) {
2129     FnDebugInfo.erase(GV);
2130     CurFn = nullptr;
2131     return;
2132   }
2133
2134   CurFn->End = Asm->getFunctionEnd();
2135
2136   CurFn = nullptr;
2137 }
2138
2139 void CodeViewDebug::beginInstruction(const MachineInstr *MI) {
2140   DebugHandlerBase::beginInstruction(MI);
2141
2142   // Ignore DBG_VALUE locations and function prologue.
2143   if (!Asm || !CurFn || MI->isDebugValue() ||
2144       MI->getFlag(MachineInstr::FrameSetup))
2145     return;
2146   DebugLoc DL = MI->getDebugLoc();
2147   if (DL == PrevInstLoc || !DL)
2148     return;
2149   maybeRecordLocation(DL, Asm->MF);
2150 }
2151
2152 MCSymbol *CodeViewDebug::beginCVSubsection(ModuleSubstreamKind Kind) {
2153   MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(),
2154            *EndLabel = MMI->getContext().createTempSymbol();
2155   OS.EmitIntValue(unsigned(Kind), 4);
2156   OS.AddComment("Subsection size");
2157   OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4);
2158   OS.EmitLabel(BeginLabel);
2159   return EndLabel;
2160 }
2161
2162 void CodeViewDebug::endCVSubsection(MCSymbol *EndLabel) {
2163   OS.EmitLabel(EndLabel);
2164   // Every subsection must be aligned to a 4-byte boundary.
2165   OS.EmitValueToAlignment(4);
2166 }
2167
2168 void CodeViewDebug::emitDebugInfoForUDTs(
2169     ArrayRef<std::pair<std::string, TypeIndex>> UDTs) {
2170   for (const std::pair<std::string, codeview::TypeIndex> &UDT : UDTs) {
2171     MCSymbol *UDTRecordBegin = MMI->getContext().createTempSymbol(),
2172              *UDTRecordEnd = MMI->getContext().createTempSymbol();
2173     OS.AddComment("Record length");
2174     OS.emitAbsoluteSymbolDiff(UDTRecordEnd, UDTRecordBegin, 2);
2175     OS.EmitLabel(UDTRecordBegin);
2176
2177     OS.AddComment("Record kind: S_UDT");
2178     OS.EmitIntValue(unsigned(SymbolKind::S_UDT), 2);
2179
2180     OS.AddComment("Type");
2181     OS.EmitIntValue(UDT.second.getIndex(), 4);
2182
2183     emitNullTerminatedSymbolName(OS, UDT.first);
2184     OS.EmitLabel(UDTRecordEnd);
2185   }
2186 }
2187
2188 void CodeViewDebug::emitDebugInfoForGlobals() {
2189   DenseMap<const DIGlobalVariableExpression *, const GlobalVariable *>
2190       GlobalMap;
2191   for (const GlobalVariable &GV : MMI->getModule()->globals()) {
2192     SmallVector<DIGlobalVariableExpression *, 1> GVEs;
2193     GV.getDebugInfo(GVEs);
2194     for (const auto *GVE : GVEs)
2195       GlobalMap[GVE] = &GV;
2196   }
2197
2198   NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2199   for (const MDNode *Node : CUs->operands()) {
2200     const auto *CU = cast<DICompileUnit>(Node);
2201
2202     // First, emit all globals that are not in a comdat in a single symbol
2203     // substream. MSVC doesn't like it if the substream is empty, so only open
2204     // it if we have at least one global to emit.
2205     switchToDebugSectionForSymbol(nullptr);
2206     MCSymbol *EndLabel = nullptr;
2207     for (const auto *GVE : CU->getGlobalVariables()) {
2208       if (const auto *GV = GlobalMap.lookup(GVE))
2209         if (!GV->hasComdat() && !GV->isDeclarationForLinker()) {
2210           if (!EndLabel) {
2211             OS.AddComment("Symbol subsection for globals");
2212             EndLabel = beginCVSubsection(ModuleSubstreamKind::Symbols);
2213           }
2214           // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2215           emitDebugInfoForGlobal(GVE->getVariable(), GV, Asm->getSymbol(GV));
2216         }
2217     }
2218     if (EndLabel)
2219       endCVSubsection(EndLabel);
2220
2221     // Second, emit each global that is in a comdat into its own .debug$S
2222     // section along with its own symbol substream.
2223     for (const auto *GVE : CU->getGlobalVariables()) {
2224       if (const auto *GV = GlobalMap.lookup(GVE)) {
2225         if (GV->hasComdat()) {
2226           MCSymbol *GVSym = Asm->getSymbol(GV);
2227           OS.AddComment("Symbol subsection for " +
2228                         Twine(GlobalValue::getRealLinkageName(GV->getName())));
2229           switchToDebugSectionForSymbol(GVSym);
2230           EndLabel = beginCVSubsection(ModuleSubstreamKind::Symbols);
2231           // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2232           emitDebugInfoForGlobal(GVE->getVariable(), GV, GVSym);
2233           endCVSubsection(EndLabel);
2234         }
2235       }
2236     }
2237   }
2238 }
2239
2240 void CodeViewDebug::emitDebugInfoForRetainedTypes() {
2241   NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2242   for (const MDNode *Node : CUs->operands()) {
2243     for (auto *Ty : cast<DICompileUnit>(Node)->getRetainedTypes()) {
2244       if (DIType *RT = dyn_cast<DIType>(Ty)) {
2245         getTypeIndex(RT);
2246         // FIXME: Add to global/local DTU list.
2247       }
2248     }
2249   }
2250 }
2251
2252 void CodeViewDebug::emitDebugInfoForGlobal(const DIGlobalVariable *DIGV,
2253                                            const GlobalVariable *GV,
2254                                            MCSymbol *GVSym) {
2255   // DataSym record, see SymbolRecord.h for more info.
2256   // FIXME: Thread local data, etc
2257   MCSymbol *DataBegin = MMI->getContext().createTempSymbol(),
2258            *DataEnd = MMI->getContext().createTempSymbol();
2259   OS.AddComment("Record length");
2260   OS.emitAbsoluteSymbolDiff(DataEnd, DataBegin, 2);
2261   OS.EmitLabel(DataBegin);
2262   if (DIGV->isLocalToUnit()) {
2263     if (GV->isThreadLocal()) {
2264       OS.AddComment("Record kind: S_LTHREAD32");
2265       OS.EmitIntValue(unsigned(SymbolKind::S_LTHREAD32), 2);
2266     } else {
2267       OS.AddComment("Record kind: S_LDATA32");
2268       OS.EmitIntValue(unsigned(SymbolKind::S_LDATA32), 2);
2269     }
2270   } else {
2271     if (GV->isThreadLocal()) {
2272       OS.AddComment("Record kind: S_GTHREAD32");
2273       OS.EmitIntValue(unsigned(SymbolKind::S_GTHREAD32), 2);
2274     } else {
2275       OS.AddComment("Record kind: S_GDATA32");
2276       OS.EmitIntValue(unsigned(SymbolKind::S_GDATA32), 2);
2277     }
2278   }
2279   OS.AddComment("Type");
2280   OS.EmitIntValue(getCompleteTypeIndex(DIGV->getType()).getIndex(), 4);
2281   OS.AddComment("DataOffset");
2282   OS.EmitCOFFSecRel32(GVSym, /*Offset=*/0);
2283   OS.AddComment("Segment");
2284   OS.EmitCOFFSectionIndex(GVSym);
2285   OS.AddComment("Name");
2286   emitNullTerminatedSymbolName(OS, DIGV->getName());
2287   OS.EmitLabel(DataEnd);
2288 }