LLVM  7.0.0svn
CodeViewDebug.cpp
Go to the documentation of this file.
1 //===- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp ----------------------===//
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 "DwarfExpression.h"
16 #include "llvm/ADT/APSInt.h"
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/ADT/DenseSet.h"
20 #include "llvm/ADT/MapVector.h"
21 #include "llvm/ADT/None.h"
22 #include "llvm/ADT/Optional.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/SmallString.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/ADT/StringRef.h"
27 #include "llvm/ADT/TinyPtrVector.h"
28 #include "llvm/ADT/Triple.h"
29 #include "llvm/ADT/Twine.h"
30 #include "llvm/BinaryFormat/COFF.h"
41 #include "llvm/Config/llvm-config.h"
52 #include "llvm/IR/Constants.h"
53 #include "llvm/IR/DataLayout.h"
55 #include "llvm/IR/DebugLoc.h"
56 #include "llvm/IR/Function.h"
57 #include "llvm/IR/GlobalValue.h"
58 #include "llvm/IR/GlobalVariable.h"
59 #include "llvm/IR/Metadata.h"
60 #include "llvm/IR/Module.h"
61 #include "llvm/MC/MCAsmInfo.h"
62 #include "llvm/MC/MCContext.h"
63 #include "llvm/MC/MCSectionCOFF.h"
64 #include "llvm/MC/MCStreamer.h"
65 #include "llvm/MC/MCSymbol.h"
68 #include "llvm/Support/Casting.h"
70 #include "llvm/Support/Compiler.h"
71 #include "llvm/Support/Endian.h"
72 #include "llvm/Support/Error.h"
75 #include "llvm/Support/SMLoc.h"
79 #include <algorithm>
80 #include <cassert>
81 #include <cctype>
82 #include <cstddef>
83 #include <cstdint>
84 #include <iterator>
85 #include <limits>
86 #include <string>
87 #include <utility>
88 #include <vector>
89 
90 using namespace llvm;
91 using namespace llvm::codeview;
92 
93 static cl::opt<bool> EmitDebugGlobalHashes("emit-codeview-ghash-section",
94  cl::ReallyHidden, cl::init(false));
95 
97  : DebugHandlerBase(AP), OS(*Asm->OutStreamer), TypeTable(Allocator) {
98  // If module doesn't have named metadata anchors or COFF debug section
99  // is not available, skip any debug info related stuff.
100  if (!MMI->getModule()->getNamedMetadata("llvm.dbg.cu") ||
102  Asm = nullptr;
103  return;
104  }
105 
106  // Tell MMI that we have debug info.
108 }
109 
110 StringRef CodeViewDebug::getFullFilepath(const DIFile *File) {
111  std::string &Filepath = FileToFilepathMap[File];
112  if (!Filepath.empty())
113  return Filepath;
114 
115  StringRef Dir = File->getDirectory(), Filename = File->getFilename();
116 
117  // If this is a Unix-style path, just use it as is. Don't try to canonicalize
118  // it textually because one of the path components could be a symlink.
119  if (!Dir.empty() && Dir[0] == '/') {
120  Filepath = Dir;
121  if (Dir.back() != '/')
122  Filepath += '/';
123  Filepath += Filename;
124  return Filepath;
125  }
126 
127  // Clang emits directory and relative filename info into the IR, but CodeView
128  // operates on full paths. We could change Clang to emit full paths too, but
129  // that would increase the IR size and probably not needed for other users.
130  // For now, just concatenate and canonicalize the path here.
131  if (Filename.find(':') == 1)
132  Filepath = Filename;
133  else
134  Filepath = (Dir + "\\" + Filename).str();
135 
136  // Canonicalize the path. We have to do it textually because we may no longer
137  // have access the file in the filesystem.
138  // First, replace all slashes with backslashes.
139  std::replace(Filepath.begin(), Filepath.end(), '/', '\\');
140 
141  // Remove all "\.\" with "\".
142  size_t Cursor = 0;
143  while ((Cursor = Filepath.find("\\.\\", Cursor)) != std::string::npos)
144  Filepath.erase(Cursor, 2);
145 
146  // Replace all "\XXX\..\" with "\". Don't try too hard though as the original
147  // path should be well-formatted, e.g. start with a drive letter, etc.
148  Cursor = 0;
149  while ((Cursor = Filepath.find("\\..\\", Cursor)) != std::string::npos) {
150  // Something's wrong if the path starts with "\..\", abort.
151  if (Cursor == 0)
152  break;
153 
154  size_t PrevSlash = Filepath.rfind('\\', Cursor - 1);
155  if (PrevSlash == std::string::npos)
156  // Something's wrong, abort.
157  break;
158 
159  Filepath.erase(PrevSlash, Cursor + 3 - PrevSlash);
160  // The next ".." might be following the one we've just erased.
161  Cursor = PrevSlash;
162  }
163 
164  // Remove all duplicate backslashes.
165  Cursor = 0;
166  while ((Cursor = Filepath.find("\\\\", Cursor)) != std::string::npos)
167  Filepath.erase(Cursor, 1);
168 
169  return Filepath;
170 }
171 
172 unsigned CodeViewDebug::maybeRecordFile(const DIFile *F) {
173  StringRef FullPath = getFullFilepath(F);
174  unsigned NextId = FileIdMap.size() + 1;
175  auto Insertion = FileIdMap.insert(std::make_pair(FullPath, NextId));
176  if (Insertion.second) {
177  // We have to compute the full filepath and emit a .cv_file directive.
178  ArrayRef<uint8_t> ChecksumAsBytes;
180  if (F->getChecksum()) {
181  std::string Checksum = fromHex(F->getChecksum()->Value);
182  void *CKMem = OS.getContext().allocate(Checksum.size(), 1);
183  memcpy(CKMem, Checksum.data(), Checksum.size());
184  ChecksumAsBytes = ArrayRef<uint8_t>(
185  reinterpret_cast<const uint8_t *>(CKMem), Checksum.size());
186  switch (F->getChecksum()->Kind) {
187  case DIFile::CSK_MD5: CSKind = FileChecksumKind::MD5; break;
188  case DIFile::CSK_SHA1: CSKind = FileChecksumKind::SHA1; break;
189  }
190  }
191  bool Success = OS.EmitCVFileDirective(NextId, FullPath, ChecksumAsBytes,
192  static_cast<unsigned>(CSKind));
193  (void)Success;
194  assert(Success && ".cv_file directive failed");
195  }
196  return Insertion.first->second;
197 }
198 
199 CodeViewDebug::InlineSite &
200 CodeViewDebug::getInlineSite(const DILocation *InlinedAt,
201  const DISubprogram *Inlinee) {
202  auto SiteInsertion = CurFn->InlineSites.insert({InlinedAt, InlineSite()});
203  InlineSite *Site = &SiteInsertion.first->second;
204  if (SiteInsertion.second) {
205  unsigned ParentFuncId = CurFn->FuncId;
206  if (const DILocation *OuterIA = InlinedAt->getInlinedAt())
207  ParentFuncId =
208  getInlineSite(OuterIA, InlinedAt->getScope()->getSubprogram())
209  .SiteFuncId;
210 
211  Site->SiteFuncId = NextFuncId++;
213  Site->SiteFuncId, ParentFuncId, maybeRecordFile(InlinedAt->getFile()),
214  InlinedAt->getLine(), InlinedAt->getColumn(), SMLoc());
215  Site->Inlinee = Inlinee;
216  InlinedSubprograms.insert(Inlinee);
217  getFuncIdForSubprogram(Inlinee);
218  }
219  return *Site;
220 }
221 
222 static StringRef getPrettyScopeName(const DIScope *Scope) {
223  StringRef ScopeName = Scope->getName();
224  if (!ScopeName.empty())
225  return ScopeName;
226 
227  switch (Scope->getTag()) {
228  case dwarf::DW_TAG_enumeration_type:
229  case dwarf::DW_TAG_class_type:
230  case dwarf::DW_TAG_structure_type:
231  case dwarf::DW_TAG_union_type:
232  return "<unnamed-tag>";
233  case dwarf::DW_TAG_namespace:
234  return "`anonymous namespace'";
235  }
236 
237  return StringRef();
238 }
239 
241  const DIScope *Scope, SmallVectorImpl<StringRef> &QualifiedNameComponents) {
242  const DISubprogram *ClosestSubprogram = nullptr;
243  while (Scope != nullptr) {
244  if (ClosestSubprogram == nullptr)
245  ClosestSubprogram = dyn_cast<DISubprogram>(Scope);
246  StringRef ScopeName = getPrettyScopeName(Scope);
247  if (!ScopeName.empty())
248  QualifiedNameComponents.push_back(ScopeName);
249  Scope = Scope->getScope().resolve();
250  }
251  return ClosestSubprogram;
252 }
253 
254 static std::string getQualifiedName(ArrayRef<StringRef> QualifiedNameComponents,
256  std::string FullyQualifiedName;
257  for (StringRef QualifiedNameComponent :
258  llvm::reverse(QualifiedNameComponents)) {
259  FullyQualifiedName.append(QualifiedNameComponent);
260  FullyQualifiedName.append("::");
261  }
262  FullyQualifiedName.append(TypeName);
263  return FullyQualifiedName;
264 }
265 
266 static std::string getFullyQualifiedName(const DIScope *Scope, StringRef Name) {
267  SmallVector<StringRef, 5> QualifiedNameComponents;
268  getQualifiedNameComponents(Scope, QualifiedNameComponents);
269  return getQualifiedName(QualifiedNameComponents, Name);
270 }
271 
273  TypeLoweringScope(CodeViewDebug &CVD) : CVD(CVD) { ++CVD.TypeEmissionLevel; }
275  // Don't decrement TypeEmissionLevel until after emitting deferred types, so
276  // inner TypeLoweringScopes don't attempt to emit deferred types.
277  if (CVD.TypeEmissionLevel == 1)
278  CVD.emitDeferredCompleteTypes();
279  --CVD.TypeEmissionLevel;
280  }
282 };
283 
284 static std::string getFullyQualifiedName(const DIScope *Ty) {
285  const DIScope *Scope = Ty->getScope().resolve();
286  return getFullyQualifiedName(Scope, getPrettyScopeName(Ty));
287 }
288 
289 TypeIndex CodeViewDebug::getScopeIndex(const DIScope *Scope) {
290  // No scope means global scope and that uses the zero index.
291  if (!Scope || isa<DIFile>(Scope))
292  return TypeIndex();
293 
294  assert(!isa<DIType>(Scope) && "shouldn't make a namespace scope for a type");
295 
296  // Check if we've already translated this scope.
297  auto I = TypeIndices.find({Scope, nullptr});
298  if (I != TypeIndices.end())
299  return I->second;
300 
301  // Build the fully qualified name of the scope.
302  std::string ScopeName = getFullyQualifiedName(Scope);
303  StringIdRecord SID(TypeIndex(), ScopeName);
304  auto TI = TypeTable.writeLeafType(SID);
305  return recordTypeIndexForDINode(Scope, TI);
306 }
307 
308 TypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) {
309  assert(SP);
310 
311  // Check if we've already translated this subprogram.
312  auto I = TypeIndices.find({SP, nullptr});
313  if (I != TypeIndices.end())
314  return I->second;
315 
316  // The display name includes function template arguments. Drop them to match
317  // MSVC.
318  StringRef DisplayName = SP->getName().split('<').first;
319 
320  const DIScope *Scope = SP->getScope().resolve();
321  TypeIndex TI;
322  if (const auto *Class = dyn_cast_or_null<DICompositeType>(Scope)) {
323  // If the scope is a DICompositeType, then this must be a method. Member
324  // function types take some special handling, and require access to the
325  // subprogram.
326  TypeIndex ClassType = getTypeIndex(Class);
327  MemberFuncIdRecord MFuncId(ClassType, getMemberFunctionType(SP, Class),
328  DisplayName);
329  TI = TypeTable.writeLeafType(MFuncId);
330  } else {
331  // Otherwise, this must be a free function.
332  TypeIndex ParentScope = getScopeIndex(Scope);
333  FuncIdRecord FuncId(ParentScope, getTypeIndex(SP->getType()), DisplayName);
334  TI = TypeTable.writeLeafType(FuncId);
335  }
336 
337  return recordTypeIndexForDINode(SP, TI);
338 }
339 
340 TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP,
341  const DICompositeType *Class) {
342  // Always use the method declaration as the key for the function type. The
343  // method declaration contains the this adjustment.
344  if (SP->getDeclaration())
345  SP = SP->getDeclaration();
346  assert(!SP->getDeclaration() && "should use declaration as key");
347 
348  // Key the MemberFunctionRecord into the map as {SP, Class}. It won't collide
349  // with the MemberFuncIdRecord, which is keyed in as {SP, nullptr}.
350  auto I = TypeIndices.find({SP, Class});
351  if (I != TypeIndices.end())
352  return I->second;
353 
354  // Make sure complete type info for the class is emitted *after* the member
355  // function type, as the complete class type is likely to reference this
356  // member function type.
357  TypeLoweringScope S(*this);
358  const bool IsStaticMethod = (SP->getFlags() & DINode::FlagStaticMember) != 0;
359  TypeIndex TI = lowerTypeMemberFunction(
360  SP->getType(), Class, SP->getThisAdjustment(), IsStaticMethod);
361  return recordTypeIndexForDINode(SP, TI, Class);
362 }
363 
364 TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node,
365  TypeIndex TI,
366  const DIType *ClassTy) {
367  auto InsertResult = TypeIndices.insert({{Node, ClassTy}, TI});
368  (void)InsertResult;
369  assert(InsertResult.second && "DINode was already assigned a type index");
370  return TI;
371 }
372 
373 unsigned CodeViewDebug::getPointerSizeInBytes() {
374  return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8;
375 }
376 
377 void CodeViewDebug::recordLocalVariable(LocalVariable &&Var,
378  const LexicalScope *LS) {
379  if (const DILocation *InlinedAt = LS->getInlinedAt()) {
380  // This variable was inlined. Associate it with the InlineSite.
381  const DISubprogram *Inlinee = Var.DIVar->getScope()->getSubprogram();
382  InlineSite &Site = getInlineSite(InlinedAt, Inlinee);
383  Site.InlinedLocals.emplace_back(Var);
384  } else {
385  // This variable goes into the corresponding lexical scope.
386  ScopeVariables[LS].emplace_back(Var);
387  }
388 }
389 
391  const DILocation *Loc) {
392  auto B = Locs.begin(), E = Locs.end();
393  if (std::find(B, E, Loc) == E)
394  Locs.push_back(Loc);
395 }
396 
397 void CodeViewDebug::maybeRecordLocation(const DebugLoc &DL,
398  const MachineFunction *MF) {
399  // Skip this instruction if it has the same location as the previous one.
400  if (!DL || DL == PrevInstLoc)
401  return;
402 
403  const DIScope *Scope = DL.get()->getScope();
404  if (!Scope)
405  return;
406 
407  // Skip this line if it is longer than the maximum we can record.
408  LineInfo LI(DL.getLine(), DL.getLine(), /*IsStatement=*/true);
409  if (LI.getStartLine() != DL.getLine() || LI.isAlwaysStepInto() ||
410  LI.isNeverStepInto())
411  return;
412 
413  ColumnInfo CI(DL.getCol(), /*EndColumn=*/0);
414  if (CI.getStartColumn() != DL.getCol())
415  return;
416 
417  if (!CurFn->HaveLineInfo)
418  CurFn->HaveLineInfo = true;
419  unsigned FileId = 0;
420  if (PrevInstLoc.get() && PrevInstLoc->getFile() == DL->getFile())
421  FileId = CurFn->LastFileId;
422  else
423  FileId = CurFn->LastFileId = maybeRecordFile(DL->getFile());
424  PrevInstLoc = DL;
425 
426  unsigned FuncId = CurFn->FuncId;
427  if (const DILocation *SiteLoc = DL->getInlinedAt()) {
428  const DILocation *Loc = DL.get();
429 
430  // If this location was actually inlined from somewhere else, give it the ID
431  // of the inline call site.
432  FuncId =
433  getInlineSite(SiteLoc, Loc->getScope()->getSubprogram()).SiteFuncId;
434 
435  // Ensure we have links in the tree of inline call sites.
436  bool FirstLoc = true;
437  while ((SiteLoc = Loc->getInlinedAt())) {
438  InlineSite &Site =
439  getInlineSite(SiteLoc, Loc->getScope()->getSubprogram());
440  if (!FirstLoc)
441  addLocIfNotPresent(Site.ChildSites, Loc);
442  FirstLoc = false;
443  Loc = SiteLoc;
444  }
445  addLocIfNotPresent(CurFn->ChildSites, Loc);
446  }
447 
448  OS.EmitCVLocDirective(FuncId, FileId, DL.getLine(), DL.getCol(),
449  /*PrologueEnd=*/false, /*IsStmt=*/false,
450  DL->getFilename(), SMLoc());
451 }
452 
453 void CodeViewDebug::emitCodeViewMagicVersion() {
454  OS.EmitValueToAlignment(4);
455  OS.AddComment("Debug section magic");
456  OS.EmitIntValue(COFF::DEBUG_SECTION_MAGIC, 4);
457 }
458 
460  if (!Asm || !MMI->hasDebugInfo())
461  return;
462 
463  assert(Asm != nullptr);
464 
465  // The COFF .debug$S section consists of several subsections, each starting
466  // with a 4-byte control code (e.g. 0xF1, 0xF2, etc) and then a 4-byte length
467  // of the payload followed by the payload itself. The subsections are 4-byte
468  // aligned.
469 
470  // Use the generic .debug$S section, and make a subsection for all the inlined
471  // subprograms.
472  switchToDebugSectionForSymbol(nullptr);
473 
474  MCSymbol *CompilerInfo = beginCVSubsection(DebugSubsectionKind::Symbols);
475  emitCompilerInformation();
476  endCVSubsection(CompilerInfo);
477 
478  emitInlineeLinesSubsection();
479 
480  // Emit per-function debug information.
481  for (auto &P : FnDebugInfo)
482  if (!P.first->isDeclarationForLinker())
483  emitDebugInfoForFunction(P.first, *P.second);
484 
485  // Emit global variable debug information.
486  setCurrentSubprogram(nullptr);
487  emitDebugInfoForGlobals();
488 
489  // Emit retained types.
490  emitDebugInfoForRetainedTypes();
491 
492  // Switch back to the generic .debug$S section after potentially processing
493  // comdat symbol sections.
494  switchToDebugSectionForSymbol(nullptr);
495 
496  // Emit UDT records for any types used by global variables.
497  if (!GlobalUDTs.empty()) {
498  MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
499  emitDebugInfoForUDTs(GlobalUDTs);
500  endCVSubsection(SymbolsEnd);
501  }
502 
503  // This subsection holds a file index to offset in string table table.
504  OS.AddComment("File index to string table offset subsection");
505  OS.EmitCVFileChecksumsDirective();
506 
507  // This subsection holds the string table.
508  OS.AddComment("String table");
509  OS.EmitCVStringTableDirective();
510 
511  // Emit type information and hashes last, so that any types we translate while
512  // emitting function info are included.
513  emitTypeInformation();
514 
516  emitTypeGlobalHashes();
517 
518  clear();
519 }
520 
522  unsigned MaxFixedRecordLength = 0xF00) {
523  // The maximum CV record length is 0xFF00. Most of the strings we emit appear
524  // after a fixed length portion of the record. The fixed length portion should
525  // always be less than 0xF00 (3840) bytes, so truncate the string so that the
526  // overall record size is less than the maximum allowed.
527  SmallString<32> NullTerminatedString(
528  S.take_front(MaxRecordLength - MaxFixedRecordLength - 1));
529  NullTerminatedString.push_back('\0');
530  OS.EmitBytes(NullTerminatedString);
531 }
532 
533 void CodeViewDebug::emitTypeInformation() {
534  if (TypeTable.empty())
535  return;
536 
537  // Start the .debug$T or .debug$P section with 0x4.
538  OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection());
539  emitCodeViewMagicVersion();
540 
541  SmallString<8> CommentPrefix;
542  if (OS.isVerboseAsm()) {
543  CommentPrefix += '\t';
544  CommentPrefix += Asm->MAI->getCommentString();
545  CommentPrefix += ' ';
546  }
547 
548  TypeTableCollection Table(TypeTable.records());
549  Optional<TypeIndex> B = Table.getFirst();
550  while (B) {
551  // This will fail if the record data is invalid.
552  CVType Record = Table.getType(*B);
553 
554  if (OS.isVerboseAsm()) {
555  // Emit a block comment describing the type record for readability.
556  SmallString<512> CommentBlock;
557  raw_svector_ostream CommentOS(CommentBlock);
558  ScopedPrinter SP(CommentOS);
559  SP.setPrefix(CommentPrefix);
560  TypeDumpVisitor TDV(Table, &SP, false);
561 
562  Error E = codeview::visitTypeRecord(Record, *B, TDV);
563  if (E) {
564  logAllUnhandledErrors(std::move(E), errs(), "error: ");
565  llvm_unreachable("produced malformed type record");
566  }
567  // emitRawComment will insert its own tab and comment string before
568  // the first line, so strip off our first one. It also prints its own
569  // newline.
570  OS.emitRawComment(
571  CommentOS.str().drop_front(CommentPrefix.size() - 1).rtrim());
572  }
573  OS.EmitBinaryData(Record.str_data());
574  B = Table.getNext(*B);
575  }
576 }
577 
578 void CodeViewDebug::emitTypeGlobalHashes() {
579  if (TypeTable.empty())
580  return;
581 
582  // Start the .debug$H section with the version and hash algorithm, currently
583  // hardcoded to version 0, SHA1.
585 
586  OS.EmitValueToAlignment(4);
587  OS.AddComment("Magic");
588  OS.EmitIntValue(COFF::DEBUG_HASHES_SECTION_MAGIC, 4);
589  OS.AddComment("Section Version");
590  OS.EmitIntValue(0, 2);
591  OS.AddComment("Hash Algorithm");
592  OS.EmitIntValue(uint16_t(GlobalTypeHashAlg::SHA1), 2);
593 
594  TypeIndex TI(TypeIndex::FirstNonSimpleIndex);
595  for (const auto &GHR : TypeTable.hashes()) {
596  if (OS.isVerboseAsm()) {
597  // Emit an EOL-comment describing which TypeIndex this hash corresponds
598  // to, as well as the stringified SHA1 hash.
599  SmallString<32> Comment;
600  raw_svector_ostream CommentOS(Comment);
601  CommentOS << formatv("{0:X+} [{1}]", TI.getIndex(), GHR);
602  OS.AddComment(Comment);
603  ++TI;
604  }
605  assert(GHR.Hash.size() % 20 == 0);
606  StringRef S(reinterpret_cast<const char *>(GHR.Hash.data()),
607  GHR.Hash.size());
608  OS.EmitBinaryData(S);
609  }
610 }
611 
612 static SourceLanguage MapDWLangToCVLang(unsigned DWLang) {
613  switch (DWLang) {
614  case dwarf::DW_LANG_C:
615  case dwarf::DW_LANG_C89:
616  case dwarf::DW_LANG_C99:
617  case dwarf::DW_LANG_C11:
618  case dwarf::DW_LANG_ObjC:
619  return SourceLanguage::C;
620  case dwarf::DW_LANG_C_plus_plus:
621  case dwarf::DW_LANG_C_plus_plus_03:
622  case dwarf::DW_LANG_C_plus_plus_11:
623  case dwarf::DW_LANG_C_plus_plus_14:
624  return SourceLanguage::Cpp;
625  case dwarf::DW_LANG_Fortran77:
626  case dwarf::DW_LANG_Fortran90:
627  case dwarf::DW_LANG_Fortran03:
628  case dwarf::DW_LANG_Fortran08:
630  case dwarf::DW_LANG_Pascal83:
631  return SourceLanguage::Pascal;
632  case dwarf::DW_LANG_Cobol74:
633  case dwarf::DW_LANG_Cobol85:
634  return SourceLanguage::Cobol;
635  case dwarf::DW_LANG_Java:
636  return SourceLanguage::Java;
637  case dwarf::DW_LANG_D:
638  return SourceLanguage::D;
639  default:
640  // There's no CodeView representation for this language, and CV doesn't
641  // have an "unknown" option for the language field, so we'll use MASM,
642  // as it's very low level.
643  return SourceLanguage::Masm;
644  }
645 }
646 
647 namespace {
648 struct Version {
649  int Part[4];
650 };
651 } // end anonymous namespace
652 
653 // Takes a StringRef like "clang 4.0.0.0 (other nonsense 123)" and parses out
654 // the version number.
656  Version V = {{0}};
657  int N = 0;
658  for (const char C : Name) {
659  if (isdigit(C)) {
660  V.Part[N] *= 10;
661  V.Part[N] += C - '0';
662  } else if (C == '.') {
663  ++N;
664  if (N >= 4)
665  return V;
666  } else if (N > 0)
667  return V;
668  }
669  return V;
670 }
671 
673  switch (Type) {
674  case Triple::ArchType::x86:
675  return CPUType::Pentium3;
676  case Triple::ArchType::x86_64:
677  return CPUType::X64;
678  case Triple::ArchType::thumb:
679  return CPUType::Thumb;
680  case Triple::ArchType::aarch64:
681  return CPUType::ARM64;
682  default:
683  report_fatal_error("target architecture doesn't map to a CodeView CPUType");
684  }
685 }
686 
687 void CodeViewDebug::emitCompilerInformation() {
689  MCSymbol *CompilerBegin = Context.createTempSymbol(),
690  *CompilerEnd = Context.createTempSymbol();
691  OS.AddComment("Record length");
692  OS.emitAbsoluteSymbolDiff(CompilerEnd, CompilerBegin, 2);
693  OS.EmitLabel(CompilerBegin);
694  OS.AddComment("Record kind: S_COMPILE3");
695  OS.EmitIntValue(SymbolKind::S_COMPILE3, 2);
696  uint32_t Flags = 0;
697 
698  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
699  const MDNode *Node = *CUs->operands().begin();
700  const auto *CU = cast<DICompileUnit>(Node);
701 
702  // The low byte of the flags indicates the source language.
703  Flags = MapDWLangToCVLang(CU->getSourceLanguage());
704  // TODO: Figure out which other flags need to be set.
705 
706  OS.AddComment("Flags and language");
707  OS.EmitIntValue(Flags, 4);
708 
709  OS.AddComment("CPUType");
710  CPUType CPU =
712  OS.EmitIntValue(static_cast<uint64_t>(CPU), 2);
713 
714  StringRef CompilerVersion = CU->getProducer();
715  Version FrontVer = parseVersion(CompilerVersion);
716  OS.AddComment("Frontend version");
717  for (int N = 0; N < 4; ++N)
718  OS.EmitIntValue(FrontVer.Part[N], 2);
719 
720  // Some Microsoft tools, like Binscope, expect a backend version number of at
721  // least 8.something, so we'll coerce the LLVM version into a form that
722  // guarantees it'll be big enough without really lying about the version.
723  int Major = 1000 * LLVM_VERSION_MAJOR +
724  10 * LLVM_VERSION_MINOR +
725  LLVM_VERSION_PATCH;
726  // Clamp it for builds that use unusually large version numbers.
727  Major = std::min<int>(Major, std::numeric_limits<uint16_t>::max());
728  Version BackVer = {{ Major, 0, 0, 0 }};
729  OS.AddComment("Backend version");
730  for (int N = 0; N < 4; ++N)
731  OS.EmitIntValue(BackVer.Part[N], 2);
732 
733  OS.AddComment("Null-terminated compiler version string");
734  emitNullTerminatedSymbolName(OS, CompilerVersion);
735 
736  OS.EmitLabel(CompilerEnd);
737 }
738 
739 void CodeViewDebug::emitInlineeLinesSubsection() {
740  if (InlinedSubprograms.empty())
741  return;
742 
743  OS.AddComment("Inlinee lines subsection");
744  MCSymbol *InlineEnd = beginCVSubsection(DebugSubsectionKind::InlineeLines);
745 
746  // We emit the checksum info for files. This is used by debuggers to
747  // determine if a pdb matches the source before loading it. Visual Studio,
748  // for instance, will display a warning that the breakpoints are not valid if
749  // the pdb does not match the source.
750  OS.AddComment("Inlinee lines signature");
751  OS.EmitIntValue(unsigned(InlineeLinesSignature::Normal), 4);
752 
753  for (const DISubprogram *SP : InlinedSubprograms) {
754  assert(TypeIndices.count({SP, nullptr}));
755  TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}];
756 
757  OS.AddBlankLine();
758  unsigned FileId = maybeRecordFile(SP->getFile());
759  OS.AddComment("Inlined function " + SP->getName() + " starts at " +
760  SP->getFilename() + Twine(':') + Twine(SP->getLine()));
761  OS.AddBlankLine();
762  OS.AddComment("Type index of inlined function");
763  OS.EmitIntValue(InlineeIdx.getIndex(), 4);
764  OS.AddComment("Offset into filechecksum table");
765  OS.EmitCVFileChecksumOffsetDirective(FileId);
766  OS.AddComment("Starting line number");
767  OS.EmitIntValue(SP->getLine(), 4);
768  }
769 
770  endCVSubsection(InlineEnd);
771 }
772 
773 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,
774  const DILocation *InlinedAt,
775  const InlineSite &Site) {
776  MCSymbol *InlineBegin = MMI->getContext().createTempSymbol(),
777  *InlineEnd = MMI->getContext().createTempSymbol();
778 
779  assert(TypeIndices.count({Site.Inlinee, nullptr}));
780  TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}];
781 
782  // SymbolRecord
783  OS.AddComment("Record length");
784  OS.emitAbsoluteSymbolDiff(InlineEnd, InlineBegin, 2); // RecordLength
785  OS.EmitLabel(InlineBegin);
786  OS.AddComment("Record kind: S_INLINESITE");
787  OS.EmitIntValue(SymbolKind::S_INLINESITE, 2); // RecordKind
788 
789  OS.AddComment("PtrParent");
790  OS.EmitIntValue(0, 4);
791  OS.AddComment("PtrEnd");
792  OS.EmitIntValue(0, 4);
793  OS.AddComment("Inlinee type index");
794  OS.EmitIntValue(InlineeIdx.getIndex(), 4);
795 
796  unsigned FileId = maybeRecordFile(Site.Inlinee->getFile());
797  unsigned StartLineNum = Site.Inlinee->getLine();
798 
799  OS.EmitCVInlineLinetableDirective(Site.SiteFuncId, FileId, StartLineNum,
800  FI.Begin, FI.End);
801 
802  OS.EmitLabel(InlineEnd);
803 
804  emitLocalVariableList(Site.InlinedLocals);
805 
806  // Recurse on child inlined call sites before closing the scope.
807  for (const DILocation *ChildSite : Site.ChildSites) {
808  auto I = FI.InlineSites.find(ChildSite);
809  assert(I != FI.InlineSites.end() &&
810  "child site not in function inline site map");
811  emitInlinedCallSite(FI, ChildSite, I->second);
812  }
813 
814  // Close the scope.
815  OS.AddComment("Record length");
816  OS.EmitIntValue(2, 2); // RecordLength
817  OS.AddComment("Record kind: S_INLINESITE_END");
818  OS.EmitIntValue(SymbolKind::S_INLINESITE_END, 2); // RecordKind
819 }
820 
821 void CodeViewDebug::switchToDebugSectionForSymbol(const MCSymbol *GVSym) {
822  // If we have a symbol, it may be in a section that is COMDAT. If so, find the
823  // comdat key. A section may be comdat because of -ffunction-sections or
824  // because it is comdat in the IR.
825  MCSectionCOFF *GVSec =
826  GVSym ? dyn_cast<MCSectionCOFF>(&GVSym->getSection()) : nullptr;
827  const MCSymbol *KeySym = GVSec ? GVSec->getCOMDATSymbol() : nullptr;
828 
829  MCSectionCOFF *DebugSec = cast<MCSectionCOFF>(
831  DebugSec = OS.getContext().getAssociativeCOFFSection(DebugSec, KeySym);
832 
833  OS.SwitchSection(DebugSec);
834 
835  // Emit the magic version number if this is the first time we've switched to
836  // this section.
837  if (ComdatDebugSections.insert(DebugSec).second)
838  emitCodeViewMagicVersion();
839 }
840 
841 // Emit an S_THUNK32/S_END symbol pair for a thunk routine.
842 // The only supported thunk ordinal is currently the standard type.
843 void CodeViewDebug::emitDebugInfoForThunk(const Function *GV,
844  FunctionInfo &FI,
845  const MCSymbol *Fn) {
846  std::string FuncName = GlobalValue::dropLLVMManglingEscape(GV->getName());
847  const ThunkOrdinal ordinal = ThunkOrdinal::Standard; // Only supported kind.
848 
849  OS.AddComment("Symbol subsection for " + Twine(FuncName));
850  MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
851 
852  // Emit S_THUNK32
853  MCSymbol *ThunkRecordBegin = MMI->getContext().createTempSymbol(),
854  *ThunkRecordEnd = MMI->getContext().createTempSymbol();
855  OS.AddComment("Record length");
856  OS.emitAbsoluteSymbolDiff(ThunkRecordEnd, ThunkRecordBegin, 2);
857  OS.EmitLabel(ThunkRecordBegin);
858  OS.AddComment("Record kind: S_THUNK32");
859  OS.EmitIntValue(unsigned(SymbolKind::S_THUNK32), 2);
860  OS.AddComment("PtrParent");
861  OS.EmitIntValue(0, 4);
862  OS.AddComment("PtrEnd");
863  OS.EmitIntValue(0, 4);
864  OS.AddComment("PtrNext");
865  OS.EmitIntValue(0, 4);
866  OS.AddComment("Thunk section relative address");
867  OS.EmitCOFFSecRel32(Fn, /*Offset=*/0);
868  OS.AddComment("Thunk section index");
869  OS.EmitCOFFSectionIndex(Fn);
870  OS.AddComment("Code size");
871  OS.emitAbsoluteSymbolDiff(FI.End, Fn, 2);
872  OS.AddComment("Ordinal");
873  OS.EmitIntValue(unsigned(ordinal), 1);
874  OS.AddComment("Function name");
875  emitNullTerminatedSymbolName(OS, FuncName);
876  // Additional fields specific to the thunk ordinal would go here.
877  OS.EmitLabel(ThunkRecordEnd);
878 
879  // Local variables/inlined routines are purposely omitted here. The point of
880  // marking this as a thunk is so Visual Studio will NOT stop in this routine.
881 
882  // Emit S_PROC_ID_END
883  const unsigned RecordLengthForSymbolEnd = 2;
884  OS.AddComment("Record length");
885  OS.EmitIntValue(RecordLengthForSymbolEnd, 2);
886  OS.AddComment("Record kind: S_PROC_ID_END");
887  OS.EmitIntValue(unsigned(SymbolKind::S_PROC_ID_END), 2);
888 
889  endCVSubsection(SymbolsEnd);
890 }
891 
892 void CodeViewDebug::emitDebugInfoForFunction(const Function *GV,
893  FunctionInfo &FI) {
894  // For each function there is a separate subsection which holds the PC to
895  // file:line table.
896  const MCSymbol *Fn = Asm->getSymbol(GV);
897  assert(Fn);
898 
899  // Switch to the to a comdat section, if appropriate.
900  switchToDebugSectionForSymbol(Fn);
901 
902  std::string FuncName;
903  auto *SP = GV->getSubprogram();
904  assert(SP);
905  setCurrentSubprogram(SP);
906 
907  if (SP->isThunk()) {
908  emitDebugInfoForThunk(GV, FI, Fn);
909  return;
910  }
911 
912  // If we have a display name, build the fully qualified name by walking the
913  // chain of scopes.
914  if (!SP->getName().empty())
915  FuncName =
917 
918  // If our DISubprogram name is empty, use the mangled name.
919  if (FuncName.empty())
921 
922  // Emit FPO data, but only on 32-bit x86. No other platforms use it.
923  if (Triple(MMI->getModule()->getTargetTriple()).getArch() == Triple::x86)
924  OS.EmitCVFPOData(Fn);
925 
926  // Emit a symbol subsection, required by VS2012+ to find function boundaries.
927  OS.AddComment("Symbol subsection for " + Twine(FuncName));
928  MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
929  {
930  MCSymbol *ProcRecordBegin = MMI->getContext().createTempSymbol(),
931  *ProcRecordEnd = MMI->getContext().createTempSymbol();
932  OS.AddComment("Record length");
933  OS.emitAbsoluteSymbolDiff(ProcRecordEnd, ProcRecordBegin, 2);
934  OS.EmitLabel(ProcRecordBegin);
935 
936  if (GV->hasLocalLinkage()) {
937  OS.AddComment("Record kind: S_LPROC32_ID");
938  OS.EmitIntValue(unsigned(SymbolKind::S_LPROC32_ID), 2);
939  } else {
940  OS.AddComment("Record kind: S_GPROC32_ID");
941  OS.EmitIntValue(unsigned(SymbolKind::S_GPROC32_ID), 2);
942  }
943 
944  // These fields are filled in by tools like CVPACK which run after the fact.
945  OS.AddComment("PtrParent");
946  OS.EmitIntValue(0, 4);
947  OS.AddComment("PtrEnd");
948  OS.EmitIntValue(0, 4);
949  OS.AddComment("PtrNext");
950  OS.EmitIntValue(0, 4);
951  // This is the important bit that tells the debugger where the function
952  // code is located and what's its size:
953  OS.AddComment("Code size");
954  OS.emitAbsoluteSymbolDiff(FI.End, Fn, 4);
955  OS.AddComment("Offset after prologue");
956  OS.EmitIntValue(0, 4);
957  OS.AddComment("Offset before epilogue");
958  OS.EmitIntValue(0, 4);
959  OS.AddComment("Function type index");
960  OS.EmitIntValue(getFuncIdForSubprogram(GV->getSubprogram()).getIndex(), 4);
961  OS.AddComment("Function section relative address");
962  OS.EmitCOFFSecRel32(Fn, /*Offset=*/0);
963  OS.AddComment("Function section index");
964  OS.EmitCOFFSectionIndex(Fn);
965  OS.AddComment("Flags");
966  OS.EmitIntValue(0, 1);
967  // Emit the function display name as a null-terminated string.
968  OS.AddComment("Function name");
969  // Truncate the name so we won't overflow the record length field.
970  emitNullTerminatedSymbolName(OS, FuncName);
971  OS.EmitLabel(ProcRecordEnd);
972 
973  emitLocalVariableList(FI.Locals);
974  emitLexicalBlockList(FI.ChildBlocks, FI);
975 
976  // Emit inlined call site information. Only emit functions inlined directly
977  // into the parent function. We'll emit the other sites recursively as part
978  // of their parent inline site.
979  for (const DILocation *InlinedAt : FI.ChildSites) {
980  auto I = FI.InlineSites.find(InlinedAt);
981  assert(I != FI.InlineSites.end() &&
982  "child site not in function inline site map");
983  emitInlinedCallSite(FI, InlinedAt, I->second);
984  }
985 
986  for (auto Annot : FI.Annotations) {
987  MCSymbol *Label = Annot.first;
988  MDTuple *Strs = cast<MDTuple>(Annot.second);
989  MCSymbol *AnnotBegin = MMI->getContext().createTempSymbol(),
990  *AnnotEnd = MMI->getContext().createTempSymbol();
991  OS.AddComment("Record length");
992  OS.emitAbsoluteSymbolDiff(AnnotEnd, AnnotBegin, 2);
993  OS.EmitLabel(AnnotBegin);
994  OS.AddComment("Record kind: S_ANNOTATION");
995  OS.EmitIntValue(SymbolKind::S_ANNOTATION, 2);
996  OS.EmitCOFFSecRel32(Label, /*Offset=*/0);
997  // FIXME: Make sure we don't overflow the max record size.
998  OS.EmitCOFFSectionIndex(Label);
999  OS.EmitIntValue(Strs->getNumOperands(), 2);
1000  for (Metadata *MD : Strs->operands()) {
1001  // MDStrings are null terminated, so we can do EmitBytes and get the
1002  // nice .asciz directive.
1003  StringRef Str = cast<MDString>(MD)->getString();
1004  assert(Str.data()[Str.size()] == '\0' && "non-nullterminated MDString");
1005  OS.EmitBytes(StringRef(Str.data(), Str.size() + 1));
1006  }
1007  OS.EmitLabel(AnnotEnd);
1008  }
1009 
1010  if (SP != nullptr)
1011  emitDebugInfoForUDTs(LocalUDTs);
1012 
1013  // We're done with this function.
1014  OS.AddComment("Record length");
1015  OS.EmitIntValue(0x0002, 2);
1016  OS.AddComment("Record kind: S_PROC_ID_END");
1017  OS.EmitIntValue(unsigned(SymbolKind::S_PROC_ID_END), 2);
1018  }
1019  endCVSubsection(SymbolsEnd);
1020 
1021  // We have an assembler directive that takes care of the whole line table.
1022  OS.EmitCVLinetableDirective(FI.FuncId, Fn, FI.End);
1023 }
1024 
1025 CodeViewDebug::LocalVarDefRange
1026 CodeViewDebug::createDefRangeMem(uint16_t CVRegister, int Offset) {
1027  LocalVarDefRange DR;
1028  DR.InMemory = -1;
1029  DR.DataOffset = Offset;
1030  assert(DR.DataOffset == Offset && "truncation");
1031  DR.IsSubfield = 0;
1032  DR.StructOffset = 0;
1033  DR.CVRegister = CVRegister;
1034  return DR;
1035 }
1036 
1037 CodeViewDebug::LocalVarDefRange
1038 CodeViewDebug::createDefRangeGeneral(uint16_t CVRegister, bool InMemory,
1039  int Offset, bool IsSubfield,
1040  uint16_t StructOffset) {
1041  LocalVarDefRange DR;
1042  DR.InMemory = InMemory;
1043  DR.DataOffset = Offset;
1044  DR.IsSubfield = IsSubfield;
1045  DR.StructOffset = StructOffset;
1046  DR.CVRegister = CVRegister;
1047  return DR;
1048 }
1049 
1050 void CodeViewDebug::collectVariableInfoFromMFTable(
1051  DenseSet<InlinedVariable> &Processed) {
1052  const MachineFunction &MF = *Asm->MF;
1053  const TargetSubtargetInfo &TSI = MF.getSubtarget();
1054  const TargetFrameLowering *TFI = TSI.getFrameLowering();
1055  const TargetRegisterInfo *TRI = TSI.getRegisterInfo();
1056 
1058  if (!VI.Var)
1059  continue;
1060  assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
1061  "Expected inlined-at fields to agree");
1062 
1063  Processed.insert(InlinedVariable(VI.Var, VI.Loc->getInlinedAt()));
1064  LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1065 
1066  // If variable scope is not found then skip this variable.
1067  if (!Scope)
1068  continue;
1069 
1070  // If the variable has an attached offset expression, extract it.
1071  // FIXME: Try to handle DW_OP_deref as well.
1072  int64_t ExprOffset = 0;
1073  if (VI.Expr)
1074  if (!VI.Expr->extractIfOffset(ExprOffset))
1075  continue;
1076 
1077  // Get the frame register used and the offset.
1078  unsigned FrameReg = 0;
1079  int FrameOffset = TFI->getFrameIndexReference(*Asm->MF, VI.Slot, FrameReg);
1080  uint16_t CVReg = TRI->getCodeViewRegNum(FrameReg);
1081 
1082  // Calculate the label ranges.
1083  LocalVarDefRange DefRange =
1084  createDefRangeMem(CVReg, FrameOffset + ExprOffset);
1085  for (const InsnRange &Range : Scope->getRanges()) {
1086  const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
1087  const MCSymbol *End = getLabelAfterInsn(Range.second);
1088  End = End ? End : Asm->getFunctionEnd();
1089  DefRange.Ranges.emplace_back(Begin, End);
1090  }
1091 
1092  LocalVariable Var;
1093  Var.DIVar = VI.Var;
1094  Var.DefRanges.emplace_back(std::move(DefRange));
1095  recordLocalVariable(std::move(Var), Scope);
1096  }
1097 }
1098 
1099 static bool canUseReferenceType(const DbgVariableLocation &Loc) {
1100  return !Loc.LoadChain.empty() && Loc.LoadChain.back() == 0;
1101 }
1102 
1103 static bool needsReferenceType(const DbgVariableLocation &Loc) {
1104  return Loc.LoadChain.size() == 2 && Loc.LoadChain.back() == 0;
1105 }
1106 
1107 void CodeViewDebug::calculateRanges(
1108  LocalVariable &Var, const DbgValueHistoryMap::InstrRanges &Ranges) {
1110 
1111  // Calculate the definition ranges.
1112  for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1113  const InsnRange &Range = *I;
1114  const MachineInstr *DVInst = Range.first;
1115  assert(DVInst->isDebugValue() && "Invalid History entry");
1116  // FIXME: Find a way to represent constant variables, since they are
1117  // relatively common.
1120  if (!Location)
1121  continue;
1122 
1123  // CodeView can only express variables in register and variables in memory
1124  // at a constant offset from a register. However, for variables passed
1125  // indirectly by pointer, it is common for that pointer to be spilled to a
1126  // stack location. For the special case of one offseted load followed by a
1127  // zero offset load (a pointer spilled to the stack), we change the type of
1128  // the local variable from a value type to a reference type. This tricks the
1129  // debugger into doing the load for us.
1130  if (Var.UseReferenceType) {
1131  // We're using a reference type. Drop the last zero offset load.
1132  if (canUseReferenceType(*Location))
1133  Location->LoadChain.pop_back();
1134  else
1135  continue;
1136  } else if (needsReferenceType(*Location)) {
1137  // This location can't be expressed without switching to a reference type.
1138  // Start over using that.
1139  Var.UseReferenceType = true;
1140  Var.DefRanges.clear();
1141  calculateRanges(Var, Ranges);
1142  return;
1143  }
1144 
1145  // We can only handle a register or an offseted load of a register.
1146  if (Location->Register == 0 || Location->LoadChain.size() > 1)
1147  continue;
1148  {
1149  LocalVarDefRange DR;
1150  DR.CVRegister = TRI->getCodeViewRegNum(Location->Register);
1151  DR.InMemory = !Location->LoadChain.empty();
1152  DR.DataOffset =
1153  !Location->LoadChain.empty() ? Location->LoadChain.back() : 0;
1154  if (Location->FragmentInfo) {
1155  DR.IsSubfield = true;
1156  DR.StructOffset = Location->FragmentInfo->OffsetInBits / 8;
1157  } else {
1158  DR.IsSubfield = false;
1159  DR.StructOffset = 0;
1160  }
1161 
1162  if (Var.DefRanges.empty() ||
1163  Var.DefRanges.back().isDifferentLocation(DR)) {
1164  Var.DefRanges.emplace_back(std::move(DR));
1165  }
1166  }
1167 
1168  // Compute the label range.
1169  const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
1170  const MCSymbol *End = getLabelAfterInsn(Range.second);
1171  if (!End) {
1172  // This range is valid until the next overlapping bitpiece. In the
1173  // common case, ranges will not be bitpieces, so they will overlap.
1174  auto J = std::next(I);
1175  const DIExpression *DIExpr = DVInst->getDebugExpression();
1176  while (J != E &&
1177  !DIExpr->fragmentsOverlap(J->first->getDebugExpression()))
1178  ++J;
1179  if (J != E)
1180  End = getLabelBeforeInsn(J->first);
1181  else
1182  End = Asm->getFunctionEnd();
1183  }
1184 
1185  // If the last range end is our begin, just extend the last range.
1186  // Otherwise make a new range.
1188  Var.DefRanges.back().Ranges;
1189  if (!R.empty() && R.back().second == Begin)
1190  R.back().second = End;
1191  else
1192  R.emplace_back(Begin, End);
1193 
1194  // FIXME: Do more range combining.
1195  }
1196 }
1197 
1198 void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) {
1199  DenseSet<InlinedVariable> Processed;
1200  // Grab the variable info that was squirreled away in the MMI side-table.
1201  collectVariableInfoFromMFTable(Processed);
1202 
1203  for (const auto &I : DbgValues) {
1204  InlinedVariable IV = I.first;
1205  if (Processed.count(IV))
1206  continue;
1207  const DILocalVariable *DIVar = IV.first;
1208  const DILocation *InlinedAt = IV.second;
1209 
1210  // Instruction ranges, specifying where IV is accessible.
1211  const auto &Ranges = I.second;
1212 
1213  LexicalScope *Scope = nullptr;
1214  if (InlinedAt)
1215  Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt);
1216  else
1217  Scope = LScopes.findLexicalScope(DIVar->getScope());
1218  // If variable scope is not found then skip this variable.
1219  if (!Scope)
1220  continue;
1221 
1222  LocalVariable Var;
1223  Var.DIVar = DIVar;
1224 
1225  calculateRanges(Var, Ranges);
1226  recordLocalVariable(std::move(Var), Scope);
1227  }
1228 }
1229 
1231  const Function &GV = MF->getFunction();
1232  auto Insertion = FnDebugInfo.insert({&GV, llvm::make_unique<FunctionInfo>()});
1233  assert(Insertion.second && "function already has info");
1234  CurFn = Insertion.first->second.get();
1235  CurFn->FuncId = NextFuncId++;
1236  CurFn->Begin = Asm->getFunctionBegin();
1237 
1238  OS.EmitCVFuncIdDirective(CurFn->FuncId);
1239 
1240  // Find the end of the function prolog. First known non-DBG_VALUE and
1241  // non-frame setup location marks the beginning of the function body.
1242  // FIXME: is there a simpler a way to do this? Can we just search
1243  // for the first instruction of the function, not the last of the prolog?
1245  bool EmptyPrologue = true;
1246  for (const auto &MBB : *MF) {
1247  for (const auto &MI : MBB) {
1248  if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
1249  MI.getDebugLoc()) {
1250  PrologEndLoc = MI.getDebugLoc();
1251  break;
1252  } else if (!MI.isMetaInstruction()) {
1253  EmptyPrologue = false;
1254  }
1255  }
1256  }
1257 
1258  // Record beginning of function if we have a non-empty prologue.
1259  if (PrologEndLoc && !EmptyPrologue) {
1260  DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc();
1261  maybeRecordLocation(FnStartDL, MF);
1262  }
1263 }
1264 
1265 static bool shouldEmitUdt(const DIType *T) {
1266  if (!T)
1267  return false;
1268 
1269  // MSVC does not emit UDTs for typedefs that are scoped to classes.
1270  if (T->getTag() == dwarf::DW_TAG_typedef) {
1271  if (DIScope *Scope = T->getScope().resolve()) {
1272  switch (Scope->getTag()) {
1273  case dwarf::DW_TAG_structure_type:
1274  case dwarf::DW_TAG_class_type:
1275  case dwarf::DW_TAG_union_type:
1276  return false;
1277  }
1278  }
1279  }
1280 
1281  while (true) {
1282  if (!T || T->isForwardDecl())
1283  return false;
1284 
1285  const DIDerivedType *DT = dyn_cast<DIDerivedType>(T);
1286  if (!DT)
1287  return true;
1288  T = DT->getBaseType().resolve();
1289  }
1290  return true;
1291 }
1292 
1293 void CodeViewDebug::addToUDTs(const DIType *Ty) {
1294  // Don't record empty UDTs.
1295  if (Ty->getName().empty())
1296  return;
1297  if (!shouldEmitUdt(Ty))
1298  return;
1299 
1300  SmallVector<StringRef, 5> QualifiedNameComponents;
1301  const DISubprogram *ClosestSubprogram = getQualifiedNameComponents(
1302  Ty->getScope().resolve(), QualifiedNameComponents);
1303 
1304  std::string FullyQualifiedName =
1305  getQualifiedName(QualifiedNameComponents, getPrettyScopeName(Ty));
1306 
1307  if (ClosestSubprogram == nullptr) {
1308  GlobalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
1309  } else if (ClosestSubprogram == CurrentSubprogram) {
1310  LocalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
1311  }
1312 
1313  // TODO: What if the ClosestSubprogram is neither null or the current
1314  // subprogram? Currently, the UDT just gets dropped on the floor.
1315  //
1316  // The current behavior is not desirable. To get maximal fidelity, we would
1317  // need to perform all type translation before beginning emission of .debug$S
1318  // and then make LocalUDTs a member of FunctionInfo
1319 }
1320 
1321 TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
1322  // Generic dispatch for lowering an unknown type.
1323  switch (Ty->getTag()) {
1324  case dwarf::DW_TAG_array_type:
1325  return lowerTypeArray(cast<DICompositeType>(Ty));
1326  case dwarf::DW_TAG_typedef:
1327  return lowerTypeAlias(cast<DIDerivedType>(Ty));
1328  case dwarf::DW_TAG_base_type:
1329  return lowerTypeBasic(cast<DIBasicType>(Ty));
1330  case dwarf::DW_TAG_pointer_type:
1331  if (cast<DIDerivedType>(Ty)->getName() == "__vtbl_ptr_type")
1332  return lowerTypeVFTableShape(cast<DIDerivedType>(Ty));
1334  case dwarf::DW_TAG_reference_type:
1335  case dwarf::DW_TAG_rvalue_reference_type:
1336  return lowerTypePointer(cast<DIDerivedType>(Ty));
1337  case dwarf::DW_TAG_ptr_to_member_type:
1338  return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
1339  case dwarf::DW_TAG_restrict_type:
1340  case dwarf::DW_TAG_const_type:
1341  case dwarf::DW_TAG_volatile_type:
1342  // TODO: add support for DW_TAG_atomic_type here
1343  return lowerTypeModifier(cast<DIDerivedType>(Ty));
1344  case dwarf::DW_TAG_subroutine_type:
1345  if (ClassTy) {
1346  // The member function type of a member function pointer has no
1347  // ThisAdjustment.
1348  return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy,
1349  /*ThisAdjustment=*/0,
1350  /*IsStaticMethod=*/false);
1351  }
1352  return lowerTypeFunction(cast<DISubroutineType>(Ty));
1353  case dwarf::DW_TAG_enumeration_type:
1354  return lowerTypeEnum(cast<DICompositeType>(Ty));
1355  case dwarf::DW_TAG_class_type:
1356  case dwarf::DW_TAG_structure_type:
1357  return lowerTypeClass(cast<DICompositeType>(Ty));
1358  case dwarf::DW_TAG_union_type:
1359  return lowerTypeUnion(cast<DICompositeType>(Ty));
1360  case dwarf::DW_TAG_unspecified_type:
1361  return TypeIndex::None();
1362  default:
1363  // Use the null type index.
1364  return TypeIndex();
1365  }
1366 }
1367 
1368 TypeIndex CodeViewDebug::lowerTypeAlias(const DIDerivedType *Ty) {
1369  DITypeRef UnderlyingTypeRef = Ty->getBaseType();
1370  TypeIndex UnderlyingTypeIndex = getTypeIndex(UnderlyingTypeRef);
1371  StringRef TypeName = Ty->getName();
1372 
1373  addToUDTs(Ty);
1374 
1375  if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::Int32Long) &&
1376  TypeName == "HRESULT")
1377  return TypeIndex(SimpleTypeKind::HResult);
1378  if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::UInt16Short) &&
1379  TypeName == "wchar_t")
1380  return TypeIndex(SimpleTypeKind::WideCharacter);
1381 
1382  return UnderlyingTypeIndex;
1383 }
1384 
1385 TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) {
1386  DITypeRef ElementTypeRef = Ty->getBaseType();
1387  TypeIndex ElementTypeIndex = getTypeIndex(ElementTypeRef);
1388  // IndexType is size_t, which depends on the bitness of the target.
1389  TypeIndex IndexType = getPointerSizeInBytes() == 8
1390  ? TypeIndex(SimpleTypeKind::UInt64Quad)
1391  : TypeIndex(SimpleTypeKind::UInt32Long);
1392 
1393  uint64_t ElementSize = getBaseTypeSize(ElementTypeRef) / 8;
1394 
1395  // Add subranges to array type.
1396  DINodeArray Elements = Ty->getElements();
1397  for (int i = Elements.size() - 1; i >= 0; --i) {
1398  const DINode *Element = Elements[i];
1399  assert(Element->getTag() == dwarf::DW_TAG_subrange_type);
1400 
1401  const DISubrange *Subrange = cast<DISubrange>(Element);
1402  assert(Subrange->getLowerBound() == 0 &&
1403  "codeview doesn't support subranges with lower bounds");
1404  int64_t Count = -1;
1405  if (auto *CI = Subrange->getCount().dyn_cast<ConstantInt*>())
1406  Count = CI->getSExtValue();
1407 
1408  // Forward declarations of arrays without a size and VLAs use a count of -1.
1409  // Emit a count of zero in these cases to match what MSVC does for arrays
1410  // without a size. MSVC doesn't support VLAs, so it's not clear what we
1411  // should do for them even if we could distinguish them.
1412  if (Count == -1)
1413  Count = 0;
1414 
1415  // Update the element size and element type index for subsequent subranges.
1416  ElementSize *= Count;
1417 
1418  // If this is the outermost array, use the size from the array. It will be
1419  // more accurate if we had a VLA or an incomplete element type size.
1420  uint64_t ArraySize =
1421  (i == 0 && ElementSize == 0) ? Ty->getSizeInBits() / 8 : ElementSize;
1422 
1423  StringRef Name = (i == 0) ? Ty->getName() : "";
1424  ArrayRecord AR(ElementTypeIndex, IndexType, ArraySize, Name);
1425  ElementTypeIndex = TypeTable.writeLeafType(AR);
1426  }
1427 
1428  return ElementTypeIndex;
1429 }
1430 
1431 TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) {
1432  TypeIndex Index;
1434  uint32_t ByteSize;
1435 
1436  Kind = static_cast<dwarf::TypeKind>(Ty->getEncoding());
1437  ByteSize = Ty->getSizeInBits() / 8;
1438 
1440  switch (Kind) {
1441  case dwarf::DW_ATE_address:
1442  // FIXME: Translate
1443  break;
1444  case dwarf::DW_ATE_boolean:
1445  switch (ByteSize) {
1446  case 1: STK = SimpleTypeKind::Boolean8; break;
1447  case 2: STK = SimpleTypeKind::Boolean16; break;
1448  case 4: STK = SimpleTypeKind::Boolean32; break;
1449  case 8: STK = SimpleTypeKind::Boolean64; break;
1450  case 16: STK = SimpleTypeKind::Boolean128; break;
1451  }
1452  break;
1453  case dwarf::DW_ATE_complex_float:
1454  switch (ByteSize) {
1455  case 2: STK = SimpleTypeKind::Complex16; break;
1456  case 4: STK = SimpleTypeKind::Complex32; break;
1457  case 8: STK = SimpleTypeKind::Complex64; break;
1458  case 10: STK = SimpleTypeKind::Complex80; break;
1459  case 16: STK = SimpleTypeKind::Complex128; break;
1460  }
1461  break;
1462  case dwarf::DW_ATE_float:
1463  switch (ByteSize) {
1464  case 2: STK = SimpleTypeKind::Float16; break;
1465  case 4: STK = SimpleTypeKind::Float32; break;
1466  case 6: STK = SimpleTypeKind::Float48; break;
1467  case 8: STK = SimpleTypeKind::Float64; break;
1468  case 10: STK = SimpleTypeKind::Float80; break;
1469  case 16: STK = SimpleTypeKind::Float128; break;
1470  }
1471  break;
1472  case dwarf::DW_ATE_signed:
1473  switch (ByteSize) {
1474  case 1: STK = SimpleTypeKind::SignedCharacter; break;
1475  case 2: STK = SimpleTypeKind::Int16Short; break;
1476  case 4: STK = SimpleTypeKind::Int32; break;
1477  case 8: STK = SimpleTypeKind::Int64Quad; break;
1478  case 16: STK = SimpleTypeKind::Int128Oct; break;
1479  }
1480  break;
1481  case dwarf::DW_ATE_unsigned:
1482  switch (ByteSize) {
1483  case 1: STK = SimpleTypeKind::UnsignedCharacter; break;
1484  case 2: STK = SimpleTypeKind::UInt16Short; break;
1485  case 4: STK = SimpleTypeKind::UInt32; break;
1486  case 8: STK = SimpleTypeKind::UInt64Quad; break;
1487  case 16: STK = SimpleTypeKind::UInt128Oct; break;
1488  }
1489  break;
1490  case dwarf::DW_ATE_UTF:
1491  switch (ByteSize) {
1492  case 2: STK = SimpleTypeKind::Character16; break;
1493  case 4: STK = SimpleTypeKind::Character32; break;
1494  }
1495  break;
1496  case dwarf::DW_ATE_signed_char:
1497  if (ByteSize == 1)
1498  STK = SimpleTypeKind::SignedCharacter;
1499  break;
1500  case dwarf::DW_ATE_unsigned_char:
1501  if (ByteSize == 1)
1502  STK = SimpleTypeKind::UnsignedCharacter;
1503  break;
1504  default:
1505  break;
1506  }
1507 
1508  // Apply some fixups based on the source-level type name.
1509  if (STK == SimpleTypeKind::Int32 && Ty->getName() == "long int")
1510  STK = SimpleTypeKind::Int32Long;
1511  if (STK == SimpleTypeKind::UInt32 && Ty->getName() == "long unsigned int")
1512  STK = SimpleTypeKind::UInt32Long;
1513  if (STK == SimpleTypeKind::UInt16Short &&
1514  (Ty->getName() == "wchar_t" || Ty->getName() == "__wchar_t"))
1515  STK = SimpleTypeKind::WideCharacter;
1516  if ((STK == SimpleTypeKind::SignedCharacter ||
1517  STK == SimpleTypeKind::UnsignedCharacter) &&
1518  Ty->getName() == "char")
1519  STK = SimpleTypeKind::NarrowCharacter;
1520 
1521  return TypeIndex(STK);
1522 }
1523 
1524 TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty,
1525  PointerOptions PO) {
1526  TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
1527 
1528  // Pointers to simple types without any options can use SimpleTypeMode, rather
1529  // than having a dedicated pointer type record.
1530  if (PointeeTI.isSimple() && PO == PointerOptions::None &&
1531  PointeeTI.getSimpleMode() == SimpleTypeMode::Direct &&
1532  Ty->getTag() == dwarf::DW_TAG_pointer_type) {
1533  SimpleTypeMode Mode = Ty->getSizeInBits() == 64
1534  ? SimpleTypeMode::NearPointer64
1535  : SimpleTypeMode::NearPointer32;
1536  return TypeIndex(PointeeTI.getSimpleKind(), Mode);
1537  }
1538 
1539  PointerKind PK =
1540  Ty->getSizeInBits() == 64 ? PointerKind::Near64 : PointerKind::Near32;
1541  PointerMode PM = PointerMode::Pointer;
1542  switch (Ty->getTag()) {
1543  default: llvm_unreachable("not a pointer tag type");
1544  case dwarf::DW_TAG_pointer_type:
1545  PM = PointerMode::Pointer;
1546  break;
1547  case dwarf::DW_TAG_reference_type:
1548  PM = PointerMode::LValueReference;
1549  break;
1550  case dwarf::DW_TAG_rvalue_reference_type:
1551  PM = PointerMode::RValueReference;
1552  break;
1553  }
1554 
1555  PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8);
1556  return TypeTable.writeLeafType(PR);
1557 }
1558 
1560 translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags) {
1561  // SizeInBytes being zero generally implies that the member pointer type was
1562  // incomplete, which can happen if it is part of a function prototype. In this
1563  // case, use the unknown model instead of the general model.
1564  if (IsPMF) {
1565  switch (Flags & DINode::FlagPtrToMemberRep) {
1566  case 0:
1567  return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1568  : PointerToMemberRepresentation::GeneralFunction;
1569  case DINode::FlagSingleInheritance:
1570  return PointerToMemberRepresentation::SingleInheritanceFunction;
1571  case DINode::FlagMultipleInheritance:
1572  return PointerToMemberRepresentation::MultipleInheritanceFunction;
1573  case DINode::FlagVirtualInheritance:
1574  return PointerToMemberRepresentation::VirtualInheritanceFunction;
1575  }
1576  } else {
1577  switch (Flags & DINode::FlagPtrToMemberRep) {
1578  case 0:
1579  return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1580  : PointerToMemberRepresentation::GeneralData;
1581  case DINode::FlagSingleInheritance:
1582  return PointerToMemberRepresentation::SingleInheritanceData;
1583  case DINode::FlagMultipleInheritance:
1584  return PointerToMemberRepresentation::MultipleInheritanceData;
1585  case DINode::FlagVirtualInheritance:
1586  return PointerToMemberRepresentation::VirtualInheritanceData;
1587  }
1588  }
1589  llvm_unreachable("invalid ptr to member representation");
1590 }
1591 
1592 TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty,
1593  PointerOptions PO) {
1594  assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type);
1595  TypeIndex ClassTI = getTypeIndex(Ty->getClassType());
1596  TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType(), Ty->getClassType());
1597  PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
1598  : PointerKind::Near32;
1599  bool IsPMF = isa<DISubroutineType>(Ty->getBaseType());
1600  PointerMode PM = IsPMF ? PointerMode::PointerToMemberFunction
1601  : PointerMode::PointerToDataMember;
1602 
1603  assert(Ty->getSizeInBits() / 8 <= 0xff && "pointer size too big");
1604  uint8_t SizeInBytes = Ty->getSizeInBits() / 8;
1605  MemberPointerInfo MPI(
1606  ClassTI, translatePtrToMemberRep(SizeInBytes, IsPMF, Ty->getFlags()));
1607  PointerRecord PR(PointeeTI, PK, PM, PO, SizeInBytes, MPI);
1608  return TypeTable.writeLeafType(PR);
1609 }
1610 
1611 /// Given a DWARF calling convention, get the CodeView equivalent. If we don't
1612 /// have a translation, use the NearC convention.
1614  switch (DwarfCC) {
1615  case dwarf::DW_CC_normal: return CallingConvention::NearC;
1616  case dwarf::DW_CC_BORLAND_msfastcall: return CallingConvention::NearFast;
1617  case dwarf::DW_CC_BORLAND_thiscall: return CallingConvention::ThisCall;
1618  case dwarf::DW_CC_BORLAND_stdcall: return CallingConvention::NearStdCall;
1619  case dwarf::DW_CC_BORLAND_pascal: return CallingConvention::NearPascal;
1620  case dwarf::DW_CC_LLVM_vectorcall: return CallingConvention::NearVector;
1621  }
1622  return CallingConvention::NearC;
1623 }
1624 
1625 TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) {
1628  bool IsModifier = true;
1629  const DIType *BaseTy = Ty;
1630  while (IsModifier && BaseTy) {
1631  // FIXME: Need to add DWARF tags for __unaligned and _Atomic
1632  switch (BaseTy->getTag()) {
1633  case dwarf::DW_TAG_const_type:
1634  Mods |= ModifierOptions::Const;
1635  PO |= PointerOptions::Const;
1636  break;
1637  case dwarf::DW_TAG_volatile_type:
1638  Mods |= ModifierOptions::Volatile;
1639  PO |= PointerOptions::Volatile;
1640  break;
1641  case dwarf::DW_TAG_restrict_type:
1642  // Only pointer types be marked with __restrict. There is no known flag
1643  // for __restrict in LF_MODIFIER records.
1644  PO |= PointerOptions::Restrict;
1645  break;
1646  default:
1647  IsModifier = false;
1648  break;
1649  }
1650  if (IsModifier)
1651  BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
1652  }
1653 
1654  // Check if the inner type will use an LF_POINTER record. If so, the
1655  // qualifiers will go in the LF_POINTER record. This comes up for types like
1656  // 'int *const' and 'int *__restrict', not the more common cases like 'const
1657  // char *'.
1658  if (BaseTy) {
1659  switch (BaseTy->getTag()) {
1660  case dwarf::DW_TAG_pointer_type:
1661  case dwarf::DW_TAG_reference_type:
1662  case dwarf::DW_TAG_rvalue_reference_type:
1663  return lowerTypePointer(cast<DIDerivedType>(BaseTy), PO);
1664  case dwarf::DW_TAG_ptr_to_member_type:
1665  return lowerTypeMemberPointer(cast<DIDerivedType>(BaseTy), PO);
1666  default:
1667  break;
1668  }
1669  }
1670 
1671  TypeIndex ModifiedTI = getTypeIndex(BaseTy);
1672 
1673  // Return the base type index if there aren't any modifiers. For example, the
1674  // metadata could contain restrict wrappers around non-pointer types.
1675  if (Mods == ModifierOptions::None)
1676  return ModifiedTI;
1677 
1678  ModifierRecord MR(ModifiedTI, Mods);
1679  return TypeTable.writeLeafType(MR);
1680 }
1681 
1682 TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) {
1683  SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
1684  for (DITypeRef ArgTypeRef : Ty->getTypeArray())
1685  ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
1686 
1687  // MSVC uses type none for variadic argument.
1688  if (ReturnAndArgTypeIndices.size() > 1 &&
1689  ReturnAndArgTypeIndices.back() == TypeIndex::Void()) {
1690  ReturnAndArgTypeIndices.back() = TypeIndex::None();
1691  }
1692  TypeIndex ReturnTypeIndex = TypeIndex::Void();
1693  ArrayRef<TypeIndex> ArgTypeIndices = None;
1694  if (!ReturnAndArgTypeIndices.empty()) {
1695  auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
1696  ReturnTypeIndex = ReturnAndArgTypesRef.front();
1697  ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
1698  }
1699 
1700  ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1701  TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec);
1702 
1704 
1705  ProcedureRecord Procedure(ReturnTypeIndex, CC, FunctionOptions::None,
1706  ArgTypeIndices.size(), ArgListIndex);
1707  return TypeTable.writeLeafType(Procedure);
1708 }
1709 
1710 TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty,
1711  const DIType *ClassTy,
1712  int ThisAdjustment,
1713  bool IsStaticMethod) {
1714  // Lower the containing class type.
1715  TypeIndex ClassType = getTypeIndex(ClassTy);
1716 
1717  SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
1718  for (DITypeRef ArgTypeRef : Ty->getTypeArray())
1719  ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
1720 
1721  // MSVC uses type none for variadic argument.
1722  if (ReturnAndArgTypeIndices.size() > 1 &&
1723  ReturnAndArgTypeIndices.back() == TypeIndex::Void()) {
1724  ReturnAndArgTypeIndices.back() = TypeIndex::None();
1725  }
1726  TypeIndex ReturnTypeIndex = TypeIndex::Void();
1727  ArrayRef<TypeIndex> ArgTypeIndices = None;
1728  if (!ReturnAndArgTypeIndices.empty()) {
1729  auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
1730  ReturnTypeIndex = ReturnAndArgTypesRef.front();
1731  ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
1732  }
1733  TypeIndex ThisTypeIndex;
1734  if (!IsStaticMethod && !ArgTypeIndices.empty()) {
1735  ThisTypeIndex = ArgTypeIndices.front();
1736  ArgTypeIndices = ArgTypeIndices.drop_front();
1737  }
1738 
1739  ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1740  TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec);
1741 
1743 
1744  // TODO: Need to use the correct values for FunctionOptions.
1745  MemberFunctionRecord MFR(ReturnTypeIndex, ClassType, ThisTypeIndex, CC,
1746  FunctionOptions::None, ArgTypeIndices.size(),
1747  ArgListIndex, ThisAdjustment);
1748  return TypeTable.writeLeafType(MFR);
1749 }
1750 
1751 TypeIndex CodeViewDebug::lowerTypeVFTableShape(const DIDerivedType *Ty) {
1752  unsigned VSlotCount =
1753  Ty->getSizeInBits() / (8 * Asm->MAI->getCodePointerSize());
1754  SmallVector<VFTableSlotKind, 4> Slots(VSlotCount, VFTableSlotKind::Near);
1755 
1756  VFTableShapeRecord VFTSR(Slots);
1757  return TypeTable.writeLeafType(VFTSR);
1758 }
1759 
1760 static MemberAccess translateAccessFlags(unsigned RecordTag, unsigned Flags) {
1761  switch (Flags & DINode::FlagAccessibility) {
1762  case DINode::FlagPrivate: return MemberAccess::Private;
1763  case DINode::FlagPublic: return MemberAccess::Public;
1764  case DINode::FlagProtected: return MemberAccess::Protected;
1765  case 0:
1766  // If there was no explicit access control, provide the default for the tag.
1767  return RecordTag == dwarf::DW_TAG_class_type ? MemberAccess::Private
1768  : MemberAccess::Public;
1769  }
1770  llvm_unreachable("access flags are exclusive");
1771 }
1772 
1774  if (SP->isArtificial())
1775  return MethodOptions::CompilerGenerated;
1776 
1777  // FIXME: Handle other MethodOptions.
1778 
1779  return MethodOptions::None;
1780 }
1781 
1783  bool Introduced) {
1784  if (SP->getFlags() & DINode::FlagStaticMember)
1785  return MethodKind::Static;
1786 
1787  switch (SP->getVirtuality()) {
1788  case dwarf::DW_VIRTUALITY_none:
1789  break;
1790  case dwarf::DW_VIRTUALITY_virtual:
1791  return Introduced ? MethodKind::IntroducingVirtual : MethodKind::Virtual;
1792  case dwarf::DW_VIRTUALITY_pure_virtual:
1793  return Introduced ? MethodKind::PureIntroducingVirtual
1794  : MethodKind::PureVirtual;
1795  default:
1796  llvm_unreachable("unhandled virtuality case");
1797  }
1798 
1799  return MethodKind::Vanilla;
1800 }
1801 
1803  switch (Ty->getTag()) {
1804  case dwarf::DW_TAG_class_type: return TypeRecordKind::Class;
1805  case dwarf::DW_TAG_structure_type: return TypeRecordKind::Struct;
1806  }
1807  llvm_unreachable("unexpected tag");
1808 }
1809 
1810 /// Return ClassOptions that should be present on both the forward declaration
1811 /// and the defintion of a tag type.
1814 
1815  // MSVC always sets this flag, even for local types. Clang doesn't always
1816  // appear to give every type a linkage name, which may be problematic for us.
1817  // FIXME: Investigate the consequences of not following them here.
1818  if (!Ty->getIdentifier().empty())
1819  CO |= ClassOptions::HasUniqueName;
1820 
1821  // Put the Nested flag on a type if it appears immediately inside a tag type.
1822  // Do not walk the scope chain. Do not attempt to compute ContainsNestedClass
1823  // here. That flag is only set on definitions, and not forward declarations.
1824  const DIScope *ImmediateScope = Ty->getScope().resolve();
1825  if (ImmediateScope && isa<DICompositeType>(ImmediateScope))
1826  CO |= ClassOptions::Nested;
1827 
1828  // Put the Scoped flag on function-local types.
1829  for (const DIScope *Scope = ImmediateScope; Scope != nullptr;
1830  Scope = Scope->getScope().resolve()) {
1831  if (isa<DISubprogram>(Scope)) {
1832  CO |= ClassOptions::Scoped;
1833  break;
1834  }
1835  }
1836 
1837  return CO;
1838 }
1839 
1840 void CodeViewDebug::addUDTSrcLine(const DIType *Ty, TypeIndex TI) {
1841  switch (Ty->getTag()) {
1842  case dwarf::DW_TAG_class_type:
1843  case dwarf::DW_TAG_structure_type:
1844  case dwarf::DW_TAG_union_type:
1845  case dwarf::DW_TAG_enumeration_type:
1846  break;
1847  default:
1848  return;
1849  }
1850 
1851  if (const auto *File = Ty->getFile()) {
1852  StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(File));
1853  TypeIndex SIDI = TypeTable.writeLeafType(SIDR);
1854 
1855  UdtSourceLineRecord USLR(TI, SIDI, Ty->getLine());
1856  TypeTable.writeLeafType(USLR);
1857  }
1858 }
1859 
1860 TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) {
1862  TypeIndex FTI;
1863  unsigned EnumeratorCount = 0;
1864 
1865  if (Ty->isForwardDecl()) {
1866  CO |= ClassOptions::ForwardReference;
1867  } else {
1868  ContinuationRecordBuilder ContinuationBuilder;
1869  ContinuationBuilder.begin(ContinuationRecordKind::FieldList);
1870  for (const DINode *Element : Ty->getElements()) {
1871  // We assume that the frontend provides all members in source declaration
1872  // order, which is what MSVC does.
1873  if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) {
1874  EnumeratorRecord ER(MemberAccess::Public,
1875  APSInt::getUnsigned(Enumerator->getValue()),
1876  Enumerator->getName());
1877  ContinuationBuilder.writeMemberType(ER);
1878  EnumeratorCount++;
1879  }
1880  }
1881  FTI = TypeTable.insertRecord(ContinuationBuilder);
1882  }
1883 
1884  std::string FullName = getFullyQualifiedName(Ty);
1885 
1886  EnumRecord ER(EnumeratorCount, CO, FTI, FullName, Ty->getIdentifier(),
1887  getTypeIndex(Ty->getBaseType()));
1888  TypeIndex EnumTI = TypeTable.writeLeafType(ER);
1889 
1890  addUDTSrcLine(Ty, EnumTI);
1891 
1892  return EnumTI;
1893 }
1894 
1895 //===----------------------------------------------------------------------===//
1896 // ClassInfo
1897 //===----------------------------------------------------------------------===//
1898 
1900  struct MemberInfo {
1902  uint64_t BaseOffset;
1903  };
1904  // [MemberInfo]
1905  using MemberList = std::vector<MemberInfo>;
1906 
1908  // MethodName -> MethodsList
1910 
1911  /// Base classes.
1912  std::vector<const DIDerivedType *> Inheritance;
1913 
1914  /// Direct members.
1916  // Direct overloaded methods gathered by name.
1918 
1920 
1921  std::vector<const DIType *> NestedTypes;
1922 };
1923 
1924 void CodeViewDebug::clear() {
1925  assert(CurFn == nullptr);
1926  FileIdMap.clear();
1927  FnDebugInfo.clear();
1928  FileToFilepathMap.clear();
1929  LocalUDTs.clear();
1930  GlobalUDTs.clear();
1931  TypeIndices.clear();
1932  CompleteTypeIndices.clear();
1933 }
1934 
1935 void CodeViewDebug::collectMemberInfo(ClassInfo &Info,
1936  const DIDerivedType *DDTy) {
1937  if (!DDTy->getName().empty()) {
1938  Info.Members.push_back({DDTy, 0});
1939  return;
1940  }
1941 
1942  // An unnamed member may represent a nested struct or union. Attempt to
1943  // interpret the unnamed member as a DICompositeType possibly wrapped in
1944  // qualifier types. Add all the indirect fields to the current record if that
1945  // succeeds, and drop the member if that fails.
1946  assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!");
1947  uint64_t Offset = DDTy->getOffsetInBits();
1948  const DIType *Ty = DDTy->getBaseType().resolve();
1949  bool FullyResolved = false;
1950  while (!FullyResolved) {
1951  switch (Ty->getTag()) {
1952  case dwarf::DW_TAG_const_type:
1953  case dwarf::DW_TAG_volatile_type:
1954  // FIXME: we should apply the qualifier types to the indirect fields
1955  // rather than dropping them.
1956  Ty = cast<DIDerivedType>(Ty)->getBaseType().resolve();
1957  break;
1958  default:
1959  FullyResolved = true;
1960  break;
1961  }
1962  }
1963 
1964  const DICompositeType *DCTy = dyn_cast<DICompositeType>(Ty);
1965  if (!DCTy)
1966  return;
1967 
1968  ClassInfo NestedInfo = collectClassInfo(DCTy);
1969  for (const ClassInfo::MemberInfo &IndirectField : NestedInfo.Members)
1970  Info.Members.push_back(
1971  {IndirectField.MemberTypeNode, IndirectField.BaseOffset + Offset});
1972 }
1973 
1974 ClassInfo CodeViewDebug::collectClassInfo(const DICompositeType *Ty) {
1975  ClassInfo Info;
1976  // Add elements to structure type.
1977  DINodeArray Elements = Ty->getElements();
1978  for (auto *Element : Elements) {
1979  // We assume that the frontend provides all members in source declaration
1980  // order, which is what MSVC does.
1981  if (!Element)
1982  continue;
1983  if (auto *SP = dyn_cast<DISubprogram>(Element)) {
1984  Info.Methods[SP->getRawName()].push_back(SP);
1985  } else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
1986  if (DDTy->getTag() == dwarf::DW_TAG_member) {
1987  collectMemberInfo(Info, DDTy);
1988  } else if (DDTy->getTag() == dwarf::DW_TAG_inheritance) {
1989  Info.Inheritance.push_back(DDTy);
1990  } else if (DDTy->getTag() == dwarf::DW_TAG_pointer_type &&
1991  DDTy->getName() == "__vtbl_ptr_type") {
1992  Info.VShapeTI = getTypeIndex(DDTy);
1993  } else if (DDTy->getTag() == dwarf::DW_TAG_typedef) {
1994  Info.NestedTypes.push_back(DDTy);
1995  } else if (DDTy->getTag() == dwarf::DW_TAG_friend) {
1996  // Ignore friend members. It appears that MSVC emitted info about
1997  // friends in the past, but modern versions do not.
1998  }
1999  } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
2000  Info.NestedTypes.push_back(Composite);
2001  }
2002  // Skip other unrecognized kinds of elements.
2003  }
2004  return Info;
2005 }
2006 
2007 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
2008  // First, construct the forward decl. Don't look into Ty to compute the
2009  // forward decl options, since it might not be available in all TUs.
2011  ClassOptions CO =
2012  ClassOptions::ForwardReference | getCommonClassOptions(Ty);
2013  std::string FullName = getFullyQualifiedName(Ty);
2014  ClassRecord CR(Kind, 0, CO, TypeIndex(), TypeIndex(), TypeIndex(), 0,
2015  FullName, Ty->getIdentifier());
2016  TypeIndex FwdDeclTI = TypeTable.writeLeafType(CR);
2017  if (!Ty->isForwardDecl())
2018  DeferredCompleteTypes.push_back(Ty);
2019  return FwdDeclTI;
2020 }
2021 
2022 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
2023  // Construct the field list and complete type record.
2026  TypeIndex FieldTI;
2027  TypeIndex VShapeTI;
2028  unsigned FieldCount;
2029  bool ContainsNestedClass;
2030  std::tie(FieldTI, VShapeTI, FieldCount, ContainsNestedClass) =
2031  lowerRecordFieldList(Ty);
2032 
2033  if (ContainsNestedClass)
2034  CO |= ClassOptions::ContainsNestedClass;
2035 
2036  std::string FullName = getFullyQualifiedName(Ty);
2037 
2038  uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
2039 
2040  ClassRecord CR(Kind, FieldCount, CO, FieldTI, TypeIndex(), VShapeTI,
2041  SizeInBytes, FullName, Ty->getIdentifier());
2042  TypeIndex ClassTI = TypeTable.writeLeafType(CR);
2043 
2044  addUDTSrcLine(Ty, ClassTI);
2045 
2046  addToUDTs(Ty);
2047 
2048  return ClassTI;
2049 }
2050 
2051 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
2052  ClassOptions CO =
2053  ClassOptions::ForwardReference | getCommonClassOptions(Ty);
2054  std::string FullName = getFullyQualifiedName(Ty);
2055  UnionRecord UR(0, CO, TypeIndex(), 0, FullName, Ty->getIdentifier());
2056  TypeIndex FwdDeclTI = TypeTable.writeLeafType(UR);
2057  if (!Ty->isForwardDecl())
2058  DeferredCompleteTypes.push_back(Ty);
2059  return FwdDeclTI;
2060 }
2061 
2062 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
2063  ClassOptions CO = ClassOptions::Sealed | getCommonClassOptions(Ty);
2064  TypeIndex FieldTI;
2065  unsigned FieldCount;
2066  bool ContainsNestedClass;
2067  std::tie(FieldTI, std::ignore, FieldCount, ContainsNestedClass) =
2068  lowerRecordFieldList(Ty);
2069 
2070  if (ContainsNestedClass)
2071  CO |= ClassOptions::ContainsNestedClass;
2072 
2073  uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
2074  std::string FullName = getFullyQualifiedName(Ty);
2075 
2076  UnionRecord UR(FieldCount, CO, FieldTI, SizeInBytes, FullName,
2077  Ty->getIdentifier());
2078  TypeIndex UnionTI = TypeTable.writeLeafType(UR);
2079 
2080  addUDTSrcLine(Ty, UnionTI);
2081 
2082  addToUDTs(Ty);
2083 
2084  return UnionTI;
2085 }
2086 
2087 std::tuple<TypeIndex, TypeIndex, unsigned, bool>
2088 CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) {
2089  // Manually count members. MSVC appears to count everything that generates a
2090  // field list record. Each individual overload in a method overload group
2091  // contributes to this count, even though the overload group is a single field
2092  // list record.
2093  unsigned MemberCount = 0;
2094  ClassInfo Info = collectClassInfo(Ty);
2095  ContinuationRecordBuilder ContinuationBuilder;
2096  ContinuationBuilder.begin(ContinuationRecordKind::FieldList);
2097 
2098  // Create base classes.
2099  for (const DIDerivedType *I : Info.Inheritance) {
2100  if (I->getFlags() & DINode::FlagVirtual) {
2101  // Virtual base.
2102  // FIXME: Emit VBPtrOffset when the frontend provides it.
2103  unsigned VBPtrOffset = 0;
2104  // FIXME: Despite the accessor name, the offset is really in bytes.
2105  unsigned VBTableIndex = I->getOffsetInBits() / 4;
2106  auto RecordKind = (I->getFlags() & DINode::FlagIndirectVirtualBase) == DINode::FlagIndirectVirtualBase
2107  ? TypeRecordKind::IndirectVirtualBaseClass
2108  : TypeRecordKind::VirtualBaseClass;
2110  RecordKind, translateAccessFlags(Ty->getTag(), I->getFlags()),
2111  getTypeIndex(I->getBaseType()), getVBPTypeIndex(), VBPtrOffset,
2112  VBTableIndex);
2113 
2114  ContinuationBuilder.writeMemberType(VBCR);
2115  MemberCount++;
2116  } else {
2117  assert(I->getOffsetInBits() % 8 == 0 &&
2118  "bases must be on byte boundaries");
2120  getTypeIndex(I->getBaseType()),
2121  I->getOffsetInBits() / 8);
2122  ContinuationBuilder.writeMemberType(BCR);
2123  MemberCount++;
2124  }
2125  }
2126 
2127  // Create members.
2128  for (ClassInfo::MemberInfo &MemberInfo : Info.Members) {
2129  const DIDerivedType *Member = MemberInfo.MemberTypeNode;
2130  TypeIndex MemberBaseType = getTypeIndex(Member->getBaseType());
2131  StringRef MemberName = Member->getName();
2132  MemberAccess Access =
2133  translateAccessFlags(Ty->getTag(), Member->getFlags());
2134 
2135  if (Member->isStaticMember()) {
2136  StaticDataMemberRecord SDMR(Access, MemberBaseType, MemberName);
2137  ContinuationBuilder.writeMemberType(SDMR);
2138  MemberCount++;
2139  continue;
2140  }
2141 
2142  // Virtual function pointer member.
2143  if ((Member->getFlags() & DINode::FlagArtificial) &&
2144  Member->getName().startswith("_vptr$")) {
2145  VFPtrRecord VFPR(getTypeIndex(Member->getBaseType()));
2146  ContinuationBuilder.writeMemberType(VFPR);
2147  MemberCount++;
2148  continue;
2149  }
2150 
2151  // Data member.
2152  uint64_t MemberOffsetInBits =
2153  Member->getOffsetInBits() + MemberInfo.BaseOffset;
2154  if (Member->isBitField()) {
2155  uint64_t StartBitOffset = MemberOffsetInBits;
2156  if (const auto *CI =
2157  dyn_cast_or_null<ConstantInt>(Member->getStorageOffsetInBits())) {
2158  MemberOffsetInBits = CI->getZExtValue() + MemberInfo.BaseOffset;
2159  }
2160  StartBitOffset -= MemberOffsetInBits;
2161  BitFieldRecord BFR(MemberBaseType, Member->getSizeInBits(),
2162  StartBitOffset);
2163  MemberBaseType = TypeTable.writeLeafType(BFR);
2164  }
2165  uint64_t MemberOffsetInBytes = MemberOffsetInBits / 8;
2166  DataMemberRecord DMR(Access, MemberBaseType, MemberOffsetInBytes,
2167  MemberName);
2168  ContinuationBuilder.writeMemberType(DMR);
2169  MemberCount++;
2170  }
2171 
2172  // Create methods
2173  for (auto &MethodItr : Info.Methods) {
2174  StringRef Name = MethodItr.first->getString();
2175 
2176  std::vector<OneMethodRecord> Methods;
2177  for (const DISubprogram *SP : MethodItr.second) {
2178  TypeIndex MethodType = getMemberFunctionType(SP, Ty);
2179  bool Introduced = SP->getFlags() & DINode::FlagIntroducedVirtual;
2180 
2181  unsigned VFTableOffset = -1;
2182  if (Introduced)
2183  VFTableOffset = SP->getVirtualIndex() * getPointerSizeInBytes();
2184 
2185  Methods.push_back(OneMethodRecord(
2186  MethodType, translateAccessFlags(Ty->getTag(), SP->getFlags()),
2187  translateMethodKindFlags(SP, Introduced),
2188  translateMethodOptionFlags(SP), VFTableOffset, Name));
2189  MemberCount++;
2190  }
2191  assert(!Methods.empty() && "Empty methods map entry");
2192  if (Methods.size() == 1)
2193  ContinuationBuilder.writeMemberType(Methods[0]);
2194  else {
2195  // FIXME: Make this use its own ContinuationBuilder so that
2196  // MethodOverloadList can be split correctly.
2197  MethodOverloadListRecord MOLR(Methods);
2198  TypeIndex MethodList = TypeTable.writeLeafType(MOLR);
2199 
2200  OverloadedMethodRecord OMR(Methods.size(), MethodList, Name);
2201  ContinuationBuilder.writeMemberType(OMR);
2202  }
2203  }
2204 
2205  // Create nested classes.
2206  for (const DIType *Nested : Info.NestedTypes) {
2207  NestedTypeRecord R(getTypeIndex(DITypeRef(Nested)), Nested->getName());
2208  ContinuationBuilder.writeMemberType(R);
2209  MemberCount++;
2210  }
2211 
2212  TypeIndex FieldTI = TypeTable.insertRecord(ContinuationBuilder);
2213  return std::make_tuple(FieldTI, Info.VShapeTI, MemberCount,
2214  !Info.NestedTypes.empty());
2215 }
2216 
2217 TypeIndex CodeViewDebug::getVBPTypeIndex() {
2218  if (!VBPType.getIndex()) {
2219  // Make a 'const int *' type.
2220  ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);
2221  TypeIndex ModifiedTI = TypeTable.writeLeafType(MR);
2222 
2223  PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
2224  : PointerKind::Near32;
2225  PointerMode PM = PointerMode::Pointer;
2227  PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes());
2228  VBPType = TypeTable.writeLeafType(PR);
2229  }
2230 
2231  return VBPType;
2232 }
2233 
2234 TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
2235  const DIType *Ty = TypeRef.resolve();
2236  const DIType *ClassTy = ClassTyRef.resolve();
2237 
2238  // The null DIType is the void type. Don't try to hash it.
2239  if (!Ty)
2240  return TypeIndex::Void();
2241 
2242  // Check if we've already translated this type. Don't try to do a
2243  // get-or-create style insertion that caches the hash lookup across the
2244  // lowerType call. It will update the TypeIndices map.
2245  auto I = TypeIndices.find({Ty, ClassTy});
2246  if (I != TypeIndices.end())
2247  return I->second;
2248 
2249  TypeLoweringScope S(*this);
2250  TypeIndex TI = lowerType(Ty, ClassTy);
2251  return recordTypeIndexForDINode(Ty, TI, ClassTy);
2252 }
2253 
2254 TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(DITypeRef TypeRef) {
2255  DIType *Ty = TypeRef.resolve();
2256  PointerRecord PR(getTypeIndex(Ty),
2257  getPointerSizeInBytes() == 8 ? PointerKind::Near64
2258  : PointerKind::Near32,
2259  PointerMode::LValueReference, PointerOptions::None,
2260  Ty->getSizeInBits() / 8);
2261  return TypeTable.writeLeafType(PR);
2262 }
2263 
2264 TypeIndex CodeViewDebug::getCompleteTypeIndex(DITypeRef TypeRef) {
2265  const DIType *Ty = TypeRef.resolve();
2266 
2267  // The null DIType is the void type. Don't try to hash it.
2268  if (!Ty)
2269  return TypeIndex::Void();
2270 
2271  // If this is a non-record type, the complete type index is the same as the
2272  // normal type index. Just call getTypeIndex.
2273  switch (Ty->getTag()) {
2274  case dwarf::DW_TAG_class_type:
2275  case dwarf::DW_TAG_structure_type:
2276  case dwarf::DW_TAG_union_type:
2277  break;
2278  default:
2279  return getTypeIndex(Ty);
2280  }
2281 
2282  // Check if we've already translated the complete record type. Lowering a
2283  // complete type should never trigger lowering another complete type, so we
2284  // can reuse the hash table lookup result.
2285  const auto *CTy = cast<DICompositeType>(Ty);
2286  auto InsertResult = CompleteTypeIndices.insert({CTy, TypeIndex()});
2287  if (!InsertResult.second)
2288  return InsertResult.first->second;
2289 
2290  TypeLoweringScope S(*this);
2291 
2292  // Make sure the forward declaration is emitted first. It's unclear if this
2293  // is necessary, but MSVC does it, and we should follow suit until we can show
2294  // otherwise.
2295  TypeIndex FwdDeclTI = getTypeIndex(CTy);
2296 
2297  // Just use the forward decl if we don't have complete type info. This might
2298  // happen if the frontend is using modules and expects the complete definition
2299  // to be emitted elsewhere.
2300  if (CTy->isForwardDecl())
2301  return FwdDeclTI;
2302 
2303  TypeIndex TI;
2304  switch (CTy->getTag()) {
2305  case dwarf::DW_TAG_class_type:
2306  case dwarf::DW_TAG_structure_type:
2307  TI = lowerCompleteTypeClass(CTy);
2308  break;
2309  case dwarf::DW_TAG_union_type:
2310  TI = lowerCompleteTypeUnion(CTy);
2311  break;
2312  default:
2313  llvm_unreachable("not a record");
2314  }
2315 
2316  InsertResult.first->second = TI;
2317  return TI;
2318 }
2319 
2320 /// Emit all the deferred complete record types. Try to do this in FIFO order,
2321 /// and do this until fixpoint, as each complete record type typically
2322 /// references
2323 /// many other record types.
2324 void CodeViewDebug::emitDeferredCompleteTypes() {
2326  while (!DeferredCompleteTypes.empty()) {
2327  std::swap(DeferredCompleteTypes, TypesToEmit);
2328  for (const DICompositeType *RecordTy : TypesToEmit)
2329  getCompleteTypeIndex(RecordTy);
2330  TypesToEmit.clear();
2331  }
2332 }
2333 
2334 void CodeViewDebug::emitLocalVariableList(ArrayRef<LocalVariable> Locals) {
2335  // Get the sorted list of parameters and emit them first.
2337  for (const LocalVariable &L : Locals)
2338  if (L.DIVar->isParameter())
2339  Params.push_back(&L);
2340  llvm::sort(Params.begin(), Params.end(),
2341  [](const LocalVariable *L, const LocalVariable *R) {
2342  return L->DIVar->getArg() < R->DIVar->getArg();
2343  });
2344  for (const LocalVariable *L : Params)
2345  emitLocalVariable(*L);
2346 
2347  // Next emit all non-parameters in the order that we found them.
2348  for (const LocalVariable &L : Locals)
2349  if (!L.DIVar->isParameter())
2350  emitLocalVariable(L);
2351 }
2352 
2353 void CodeViewDebug::emitLocalVariable(const LocalVariable &Var) {
2354  // LocalSym record, see SymbolRecord.h for more info.
2355  MCSymbol *LocalBegin = MMI->getContext().createTempSymbol(),
2356  *LocalEnd = MMI->getContext().createTempSymbol();
2357  OS.AddComment("Record length");
2358  OS.emitAbsoluteSymbolDiff(LocalEnd, LocalBegin, 2);
2359  OS.EmitLabel(LocalBegin);
2360 
2361  OS.AddComment("Record kind: S_LOCAL");
2362  OS.EmitIntValue(unsigned(SymbolKind::S_LOCAL), 2);
2363 
2365  if (Var.DIVar->isParameter())
2366  Flags |= LocalSymFlags::IsParameter;
2367  if (Var.DefRanges.empty())
2368  Flags |= LocalSymFlags::IsOptimizedOut;
2369 
2370  OS.AddComment("TypeIndex");
2371  TypeIndex TI = Var.UseReferenceType
2372  ? getTypeIndexForReferenceTo(Var.DIVar->getType())
2373  : getCompleteTypeIndex(Var.DIVar->getType());
2374  OS.EmitIntValue(TI.getIndex(), 4);
2375  OS.AddComment("Flags");
2376  OS.EmitIntValue(static_cast<uint16_t>(Flags), 2);
2377  // Truncate the name so we won't overflow the record length field.
2378  emitNullTerminatedSymbolName(OS, Var.DIVar->getName());
2379  OS.EmitLabel(LocalEnd);
2380 
2381  // Calculate the on disk prefix of the appropriate def range record. The
2382  // records and on disk formats are described in SymbolRecords.h. BytePrefix
2383  // should be big enough to hold all forms without memory allocation.
2384  SmallString<20> BytePrefix;
2385  for (const LocalVarDefRange &DefRange : Var.DefRanges) {
2386  BytePrefix.clear();
2387  if (DefRange.InMemory) {
2388  uint16_t RegRelFlags = 0;
2389  if (DefRange.IsSubfield) {
2390  RegRelFlags = DefRangeRegisterRelSym::IsSubfieldFlag |
2391  (DefRange.StructOffset
2392  << DefRangeRegisterRelSym::OffsetInParentShift);
2393  }
2394  DefRangeRegisterRelSym Sym(S_DEFRANGE_REGISTER_REL);
2395  Sym.Hdr.Register = DefRange.CVRegister;
2396  Sym.Hdr.Flags = RegRelFlags;
2397  Sym.Hdr.BasePointerOffset = DefRange.DataOffset;
2398  ulittle16_t SymKind = ulittle16_t(S_DEFRANGE_REGISTER_REL);
2399  BytePrefix +=
2400  StringRef(reinterpret_cast<const char *>(&SymKind), sizeof(SymKind));
2401  BytePrefix +=
2402  StringRef(reinterpret_cast<const char *>(&Sym.Hdr), sizeof(Sym.Hdr));
2403  } else {
2404  assert(DefRange.DataOffset == 0 && "unexpected offset into register");
2405  if (DefRange.IsSubfield) {
2406  // Unclear what matters here.
2407  DefRangeSubfieldRegisterSym Sym(S_DEFRANGE_SUBFIELD_REGISTER);
2408  Sym.Hdr.Register = DefRange.CVRegister;
2409  Sym.Hdr.MayHaveNoName = 0;
2410  Sym.Hdr.OffsetInParent = DefRange.StructOffset;
2411 
2412  ulittle16_t SymKind = ulittle16_t(S_DEFRANGE_SUBFIELD_REGISTER);
2413  BytePrefix += StringRef(reinterpret_cast<const char *>(&SymKind),
2414  sizeof(SymKind));
2415  BytePrefix += StringRef(reinterpret_cast<const char *>(&Sym.Hdr),
2416  sizeof(Sym.Hdr));
2417  } else {
2418  // Unclear what matters here.
2419  DefRangeRegisterSym Sym(S_DEFRANGE_REGISTER);
2420  Sym.Hdr.Register = DefRange.CVRegister;
2421  Sym.Hdr.MayHaveNoName = 0;
2422  ulittle16_t SymKind = ulittle16_t(S_DEFRANGE_REGISTER);
2423  BytePrefix += StringRef(reinterpret_cast<const char *>(&SymKind),
2424  sizeof(SymKind));
2425  BytePrefix += StringRef(reinterpret_cast<const char *>(&Sym.Hdr),
2426  sizeof(Sym.Hdr));
2427  }
2428  }
2429  OS.EmitCVDefRangeDirective(DefRange.Ranges, BytePrefix);
2430  }
2431 }
2432 
2433 void CodeViewDebug::emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks,
2434  const FunctionInfo& FI) {
2435  for (LexicalBlock *Block : Blocks)
2436  emitLexicalBlock(*Block, FI);
2437 }
2438 
2439 /// Emit an S_BLOCK32 and S_END record pair delimiting the contents of a
2440 /// lexical block scope.
2441 void CodeViewDebug::emitLexicalBlock(const LexicalBlock &Block,
2442  const FunctionInfo& FI) {
2443  MCSymbol *RecordBegin = MMI->getContext().createTempSymbol(),
2444  *RecordEnd = MMI->getContext().createTempSymbol();
2445 
2446  // Lexical block symbol record.
2447  OS.AddComment("Record length");
2448  OS.emitAbsoluteSymbolDiff(RecordEnd, RecordBegin, 2); // Record Length
2449  OS.EmitLabel(RecordBegin);
2450  OS.AddComment("Record kind: S_BLOCK32");
2451  OS.EmitIntValue(SymbolKind::S_BLOCK32, 2); // Record Kind
2452  OS.AddComment("PtrParent");
2453  OS.EmitIntValue(0, 4); // PtrParent
2454  OS.AddComment("PtrEnd");
2455  OS.EmitIntValue(0, 4); // PtrEnd
2456  OS.AddComment("Code size");
2457  OS.emitAbsoluteSymbolDiff(Block.End, Block.Begin, 4); // Code Size
2458  OS.AddComment("Function section relative address");
2459  OS.EmitCOFFSecRel32(Block.Begin, /*Offset=*/0); // Func Offset
2460  OS.AddComment("Function section index");
2461  OS.EmitCOFFSectionIndex(FI.Begin); // Func Symbol
2462  OS.AddComment("Lexical block name");
2463  emitNullTerminatedSymbolName(OS, Block.Name); // Name
2464  OS.EmitLabel(RecordEnd);
2465 
2466  // Emit variables local to this lexical block.
2467  emitLocalVariableList(Block.Locals);
2468 
2469  // Emit lexical blocks contained within this block.
2470  emitLexicalBlockList(Block.Children, FI);
2471 
2472  // Close the lexical block scope.
2473  OS.AddComment("Record length");
2474  OS.EmitIntValue(2, 2); // Record Length
2475  OS.AddComment("Record kind: S_END");
2476  OS.EmitIntValue(SymbolKind::S_END, 2); // Record Kind
2477 }
2478 
2479 /// Convenience routine for collecting lexical block information for a list
2480 /// of lexical scopes.
2481 void CodeViewDebug::collectLexicalBlockInfo(
2485  for (LexicalScope *Scope : Scopes)
2486  collectLexicalBlockInfo(*Scope, Blocks, Locals);
2487 }
2488 
2489 /// Populate the lexical blocks and local variable lists of the parent with
2490 /// information about the specified lexical scope.
2491 void CodeViewDebug::collectLexicalBlockInfo(
2492  LexicalScope &Scope,
2493  SmallVectorImpl<LexicalBlock *> &ParentBlocks,
2494  SmallVectorImpl<LocalVariable> &ParentLocals) {
2495  if (Scope.isAbstractScope())
2496  return;
2497 
2498  auto LocalsIter = ScopeVariables.find(&Scope);
2499  if (LocalsIter == ScopeVariables.end()) {
2500  // This scope does not contain variables and can be eliminated.
2501  collectLexicalBlockInfo(Scope.getChildren(), ParentBlocks, ParentLocals);
2502  return;
2503  }
2504  SmallVectorImpl<LocalVariable> &Locals = LocalsIter->second;
2505 
2506  const DILexicalBlock *DILB = dyn_cast<DILexicalBlock>(Scope.getScopeNode());
2507  if (!DILB) {
2508  // This scope is not a lexical block and can be eliminated, but keep any
2509  // local variables it contains.
2510  ParentLocals.append(Locals.begin(), Locals.end());
2511  collectLexicalBlockInfo(Scope.getChildren(), ParentBlocks, ParentLocals);
2512  return;
2513  }
2514 
2515  const SmallVectorImpl<InsnRange> &Ranges = Scope.getRanges();
2516  if (Ranges.size() != 1 || !getLabelAfterInsn(Ranges.front().second)) {
2517  // This lexical block scope has too many address ranges to represent in the
2518  // current CodeView format or does not have a valid address range.
2519  // Eliminate this lexical scope and promote any locals it contains to the
2520  // parent scope.
2521  //
2522  // For lexical scopes with multiple address ranges you may be tempted to
2523  // construct a single range covering every instruction where the block is
2524  // live and everything in between. Unfortunately, Visual Studio only
2525  // displays variables from the first matching lexical block scope. If the
2526  // first lexical block contains exception handling code or cold code which
2527  // is moved to the bottom of the routine creating a single range covering
2528  // nearly the entire routine, then it will hide all other lexical blocks
2529  // and the variables they contain.
2530  //
2531  ParentLocals.append(Locals.begin(), Locals.end());
2532  collectLexicalBlockInfo(Scope.getChildren(), ParentBlocks, ParentLocals);
2533  return;
2534  }
2535 
2536  // Create a new CodeView lexical block for this lexical scope. If we've
2537  // seen this DILexicalBlock before then the scope tree is malformed and
2538  // we can handle this gracefully by not processing it a second time.
2539  auto BlockInsertion = CurFn->LexicalBlocks.insert({DILB, LexicalBlock()});
2540  if (!BlockInsertion.second)
2541  return;
2542 
2543  // Create a lexical block containing the local variables and collect the
2544  // the lexical block information for the children.
2545  const InsnRange &Range = Ranges.front();
2546  assert(Range.first && Range.second);
2547  LexicalBlock &Block = BlockInsertion.first->second;
2548  Block.Begin = getLabelBeforeInsn(Range.first);
2549  Block.End = getLabelAfterInsn(Range.second);
2550  assert(Block.Begin && "missing label for scope begin");
2551  assert(Block.End && "missing label for scope end");
2552  Block.Name = DILB->getName();
2553  Block.Locals = std::move(Locals);
2554  ParentBlocks.push_back(&Block);
2555  collectLexicalBlockInfo(Scope.getChildren(), Block.Children, Block.Locals);
2556 }
2557 
2559  const Function &GV = MF->getFunction();
2560  assert(FnDebugInfo.count(&GV));
2561  assert(CurFn == FnDebugInfo[&GV].get());
2562 
2563  collectVariableInfo(GV.getSubprogram());
2564 
2565  // Build the lexical block structure to emit for this routine.
2567  collectLexicalBlockInfo(*CFS, CurFn->ChildBlocks, CurFn->Locals);
2568 
2569  // Clear the scope and variable information from the map which will not be
2570  // valid after we have finished processing this routine. This also prepares
2571  // the map for the subsequent routine.
2572  ScopeVariables.clear();
2573 
2574  // Don't emit anything if we don't have any line tables.
2575  // Thunks are compiler-generated and probably won't have source correlation.
2576  if (!CurFn->HaveLineInfo && !GV.getSubprogram()->isThunk()) {
2577  FnDebugInfo.erase(&GV);
2578  CurFn = nullptr;
2579  return;
2580  }
2581 
2582  CurFn->Annotations = MF->getCodeViewAnnotations();
2583 
2584  CurFn->End = Asm->getFunctionEnd();
2585 
2586  CurFn = nullptr;
2587 }
2588 
2591 
2592  // Ignore DBG_VALUE locations and function prologue.
2593  if (!Asm || !CurFn || MI->isDebugValue() ||
2595  return;
2596 
2597  // If the first instruction of a new MBB has no location, find the first
2598  // instruction with a location and use that.
2599  DebugLoc DL = MI->getDebugLoc();
2600  if (!DL && MI->getParent() != PrevInstBB) {
2601  for (const auto &NextMI : *MI->getParent()) {
2602  if (NextMI.isDebugValue())
2603  continue;
2604  DL = NextMI.getDebugLoc();
2605  if (DL)
2606  break;
2607  }
2608  }
2609  PrevInstBB = MI->getParent();
2610 
2611  // If we still don't have a debug location, don't record a location.
2612  if (!DL)
2613  return;
2614 
2615  maybeRecordLocation(DL, Asm->MF);
2616 }
2617 
2618 MCSymbol *CodeViewDebug::beginCVSubsection(DebugSubsectionKind Kind) {
2619  MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(),
2620  *EndLabel = MMI->getContext().createTempSymbol();
2621  OS.EmitIntValue(unsigned(Kind), 4);
2622  OS.AddComment("Subsection size");
2623  OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4);
2624  OS.EmitLabel(BeginLabel);
2625  return EndLabel;
2626 }
2627 
2628 void CodeViewDebug::endCVSubsection(MCSymbol *EndLabel) {
2629  OS.EmitLabel(EndLabel);
2630  // Every subsection must be aligned to a 4-byte boundary.
2631  OS.EmitValueToAlignment(4);
2632 }
2633 
2634 void CodeViewDebug::emitDebugInfoForUDTs(
2635  ArrayRef<std::pair<std::string, const DIType *>> UDTs) {
2636  for (const auto &UDT : UDTs) {
2637  const DIType *T = UDT.second;
2638  assert(shouldEmitUdt(T));
2639 
2640  MCSymbol *UDTRecordBegin = MMI->getContext().createTempSymbol(),
2641  *UDTRecordEnd = MMI->getContext().createTempSymbol();
2642  OS.AddComment("Record length");
2643  OS.emitAbsoluteSymbolDiff(UDTRecordEnd, UDTRecordBegin, 2);
2644  OS.EmitLabel(UDTRecordBegin);
2645 
2646  OS.AddComment("Record kind: S_UDT");
2647  OS.EmitIntValue(unsigned(SymbolKind::S_UDT), 2);
2648 
2649  OS.AddComment("Type");
2650  OS.EmitIntValue(getCompleteTypeIndex(T).getIndex(), 4);
2651 
2652  emitNullTerminatedSymbolName(OS, UDT.first);
2653  OS.EmitLabel(UDTRecordEnd);
2654  }
2655 }
2656 
2657 void CodeViewDebug::emitDebugInfoForGlobals() {
2659  GlobalMap;
2660  for (const GlobalVariable &GV : MMI->getModule()->globals()) {
2662  GV.getDebugInfo(GVEs);
2663  for (const auto *GVE : GVEs)
2664  GlobalMap[GVE] = &GV;
2665  }
2666 
2667  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2668  for (const MDNode *Node : CUs->operands()) {
2669  const auto *CU = cast<DICompileUnit>(Node);
2670 
2671  // First, emit all globals that are not in a comdat in a single symbol
2672  // substream. MSVC doesn't like it if the substream is empty, so only open
2673  // it if we have at least one global to emit.
2674  switchToDebugSectionForSymbol(nullptr);
2675  MCSymbol *EndLabel = nullptr;
2676  for (const auto *GVE : CU->getGlobalVariables()) {
2677  if (const auto *GV = GlobalMap.lookup(GVE))
2678  if (!GV->hasComdat() && !GV->isDeclarationForLinker()) {
2679  if (!EndLabel) {
2680  OS.AddComment("Symbol subsection for globals");
2681  EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
2682  }
2683  // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2684  emitDebugInfoForGlobal(GVE->getVariable(), GV, Asm->getSymbol(GV));
2685  }
2686  }
2687  if (EndLabel)
2688  endCVSubsection(EndLabel);
2689 
2690  // Second, emit each global that is in a comdat into its own .debug$S
2691  // section along with its own symbol substream.
2692  for (const auto *GVE : CU->getGlobalVariables()) {
2693  if (const auto *GV = GlobalMap.lookup(GVE)) {
2694  if (GV->hasComdat()) {
2695  MCSymbol *GVSym = Asm->getSymbol(GV);
2696  OS.AddComment("Symbol subsection for " +
2698  switchToDebugSectionForSymbol(GVSym);
2699  EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
2700  // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2701  emitDebugInfoForGlobal(GVE->getVariable(), GV, GVSym);
2702  endCVSubsection(EndLabel);
2703  }
2704  }
2705  }
2706  }
2707 }
2708 
2709 void CodeViewDebug::emitDebugInfoForRetainedTypes() {
2710  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2711  for (const MDNode *Node : CUs->operands()) {
2712  for (auto *Ty : cast<DICompileUnit>(Node)->getRetainedTypes()) {
2713  if (DIType *RT = dyn_cast<DIType>(Ty)) {
2714  getTypeIndex(RT);
2715  // FIXME: Add to global/local DTU list.
2716  }
2717  }
2718  }
2719 }
2720 
2721 void CodeViewDebug::emitDebugInfoForGlobal(const DIGlobalVariable *DIGV,
2722  const GlobalVariable *GV,
2723  MCSymbol *GVSym) {
2724  // DataSym record, see SymbolRecord.h for more info.
2725  // FIXME: Thread local data, etc
2726  MCSymbol *DataBegin = MMI->getContext().createTempSymbol(),
2727  *DataEnd = MMI->getContext().createTempSymbol();
2728  const unsigned FixedLengthOfThisRecord = 12;
2729  OS.AddComment("Record length");
2730  OS.emitAbsoluteSymbolDiff(DataEnd, DataBegin, 2);
2731  OS.EmitLabel(DataBegin);
2732  if (DIGV->isLocalToUnit()) {
2733  if (GV->isThreadLocal()) {
2734  OS.AddComment("Record kind: S_LTHREAD32");
2735  OS.EmitIntValue(unsigned(SymbolKind::S_LTHREAD32), 2);
2736  } else {
2737  OS.AddComment("Record kind: S_LDATA32");
2738  OS.EmitIntValue(unsigned(SymbolKind::S_LDATA32), 2);
2739  }
2740  } else {
2741  if (GV->isThreadLocal()) {
2742  OS.AddComment("Record kind: S_GTHREAD32");
2743  OS.EmitIntValue(unsigned(SymbolKind::S_GTHREAD32), 2);
2744  } else {
2745  OS.AddComment("Record kind: S_GDATA32");
2746  OS.EmitIntValue(unsigned(SymbolKind::S_GDATA32), 2);
2747  }
2748  }
2749  OS.AddComment("Type");
2750  OS.EmitIntValue(getCompleteTypeIndex(DIGV->getType()).getIndex(), 4);
2751  OS.AddComment("DataOffset");
2752  OS.EmitCOFFSecRel32(GVSym, /*Offset=*/0);
2753  OS.AddComment("Segment");
2754  OS.EmitCOFFSectionIndex(GVSym);
2755  OS.AddComment("Name");
2756  emitNullTerminatedSymbolName(OS, DIGV->getName(), FixedLengthOfThisRecord);
2757  OS.EmitLabel(DataEnd);
2758 }
DIFlags getFlags() const
const T & front() const
front - Get the first element.
Definition: ArrayRef.h:152
bool isDeclarationForLinker() const
Definition: GlobalValue.h:523
uint64_t CallInst * C
PointerKind
Equivalent to CV_ptrtype_e.
Definition: CodeView.h:326
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:208
ArrayRef< std::pair< MCSymbol *, MDNode * > > getCodeViewAnnotations() const
void push_back(const T &Elt)
Definition: SmallVector.h:212
const DILocalScope * getScopeNode() const
Definition: LexicalScopes.h:64
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:233
uint64_t getOffsetInBits() const
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
bool hasLocalLinkage() const
Definition: GlobalValue.h:435
DILocation * get() const
Get the underlying DILocation.
Definition: DebugLoc.cpp:21
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
LLVMContext & Context
bool hasDebugInfo() const
Returns true if valid debug info is present.
SI Whole Quad Mode
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:115
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
bool isAbstractScope() const
Definition: LexicalScopes.h:65
MCSection * getCOFFDebugTypesSection() const
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:235
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner)
Log all errors (if any) in E to OS.
Definition: Error.cpp:57
virtual int getFrameIndexReference(const MachineFunction &MF, int FI, unsigned &FrameReg) const
getFrameIndexReference - This method should return the base register and offset used to reference a f...
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
CodeViewDebug(AsmPrinter *Asm)
Implements a dense probed hash-table based set.
Definition: DenseSet.h:221
DIFile * getFile() const
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:271
SimpleTypeKind getSimpleKind() const
Definition: TypeIndex.h:127
DITypeRef getBaseType() const
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
virtual void EmitBytes(StringRef Data)
Emit the bytes in Data into the output.
Definition: MCStreamer.cpp:949
void endModule() override
Emit the COFF section that holds the line table information.
This file contains the declarations for metadata subclasses.
SmallVectorImpl< InsnRange > & getRanges()
Definition: LexicalScopes.h:67
static enum BaseType getBaseType(const Value *Val)
Return the baseType for Val which states whether Val is exclusively derived from constant/null, or not exclusively derived from constant.
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:494
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
unsigned getLine() const
Definition: DebugLoc.cpp:25
unsigned getPointerSizeInBits(unsigned AS=0) const
Layout pointer size, in bits FIXME: The defaults need to be removed once all of the backends/clients ...
Definition: DataLayout.h:360
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:862
F(f)
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:96
detail::packed_endian_specific_integral< uint16_t, little, unaligned > ulittle16_t
Definition: Endian.h:269
bool isForwardDecl() const
LexicalScope - This class is used to track scope information.
Definition: LexicalScopes.h:45
TinyPtrVector - This class is specialized for cases where there are normally 0 or 1 element in a vect...
Definition: TinyPtrVector.h:31
void endFunctionImpl(const MachineFunction *) override
Gather post-function debug information.
MCSection * getCOFFGlobalTypeHashesSection() const
StringRef getName() const
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
Tuple of metadata.
Definition: Metadata.h:1104
VariableDbgInfoMapTy & getVariableDbgInfo()
Tagged DWARF-like metadata node.
std::string fromHex(StringRef Input)
Convert hexadecimal string Input to its binary representation.
Definition: StringExtras.h:140
DINodeArray getElements() const
SimpleTypeMode getSimpleMode() const
Definition: TypeIndex.h:132
This represents a section on Windows.
Definition: MCSectionCOFF.h:27
MCContext & getContext() const
Definition: MCStreamer.h:248
static cl::opt< bool > EmitDebugGlobalHashes("emit-codeview-ghash-section", cl::ReallyHidden, cl::init(false))
DebugLoc PrevInstLoc
Previous instruction&#39;s location information.
A tuple of MDNodes.
Definition: Metadata.h:1323
StringRef getName() const
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:361
bool isStaticMember() const
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
SmallVectorImpl< LexicalScope * > & getChildren()
Definition: LexicalScopes.h:66
DbgValueHistoryMap DbgValues
History of DBG_VALUE and clobber instructions for each user variable.
unsigned getTag() const
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
Array subrange.
static StringRef getName(Value *V)
static std::string getFullyQualifiedName(const DIScope *Scope, StringRef Name)
uint64_t getSizeInBits() const
void * allocate(unsigned Size, unsigned Align=8)
Definition: MCContext.h:622
Holds a subclass of DINode.
StringRef getFilename() const
static StringRef getPrettyScopeName(const DIScope *Scope)
Context object for machine code objects.
Definition: MCContext.h:63
auto reverse(ContainerTy &&C, typename std::enable_if< has_rbegin< ContainerTy >::value >::type *=nullptr) -> decltype(make_range(C.rbegin(), C.rend()))
Definition: STLExtras.h:237
Subprogram description.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
virtual bool EmitCVFileDirective(unsigned FileNo, StringRef Filename, ArrayRef< uint8_t > Checksum, unsigned ChecksumKind)
Associate a filename with a specified logical file number, and also specify that file&#39;s checksum info...
Definition: MCStreamer.cpp:244
static bool canUseReferenceType(const DbgVariableLocation &Loc)
ModifierOptions
Equivalent to CV_modifier_t.
Definition: CodeView.h:297
MCSymbol * getFunctionBegin() const
Definition: AsmPrinter.h:204
op_range operands() const
Definition: Metadata.h:1065
static SourceLanguage MapDWLangToCVLang(unsigned DWLang)
static void addLocIfNotPresent(SmallVectorImpl< const DILocation *> &Locs, const DILocation *Loc)
#define T
const MCContext & getContext() const
MCSection * getCOFFDebugSymbolsSection() const
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
NamedMDNode * getNamedMetadata(const Twine &Name) const
Return the first NamedMDNode in the module with the specified name.
Definition: Module.cpp:242
A 32-bit type reference.
Definition: TypeIndex.h:96
LexicalScope * findLexicalScope(const DILocation *DL)
findLexicalScope - Find lexical scope, either regular or inlined, for the given DebugLoc.
Debug location.
MethodKind
Part of member attribute flags. (CV_methodprop_e)
Definition: CodeView.h:266
iterator_range< op_iterator > operands()
Definition: Metadata.h:1415
unsigned getLine() const
void resolve()
Resolve a unique, unresolved node.
Definition: Metadata.cpp:576
TypeRecordKind
Distinguishes individual records in .debug$T or .debug$P section or PDB type stream.
Definition: CodeView.h:27
#define P(N)
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:406
Streaming machine code generation interface.
Definition: MCStreamer.h:183
MCSymbol * createTempSymbol(bool CanBeUnnamed=true)
Create and return a new assembler temporary symbol with a unique but unspecified name.
Definition: MCContext.cpp:216
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static MemberAccess translateAccessFlags(unsigned RecordTag, unsigned Flags)
const MachineBasicBlock * PrevInstBB
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:84
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1505
const DILocation * getInlinedAt() const
Definition: LexicalScopes.h:63
StringRef str_data() const
Definition: CVRecord.h:39
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:149
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator begin()
Definition: SmallVector.h:116
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static CPUType mapArchToCVCPUType(Triple::ArchType Type)
std::vector< MemberInfo > MemberList
AsmPrinter * Asm
Target of debug info emission.
This class is intended to be used as a driving class for all asm writers.
Definition: AsmPrinter.h:78
For method overload sets. LF_METHOD.
Definition: TypeRecord.h:736
StringRef getCommentString() const
Definition: MCAsmInfo.h:475
static const unsigned End
constexpr char TypeName[]
Key for Kernel::Arg::Metadata::mTypeName.
void beginInstruction(const MachineInstr *MI) override
Process beginning of an instruction.
Error visitTypeRecord(CVType &Record, TypeIndex Index, TypeVisitorCallbacks &Callbacks, VisitorDataSource Source=VDS_BytesPresent)
void beginFunctionImpl(const MachineFunction *MF) override
Gather pre-function debug information.
StringRef getDirectory() const
MCSymbol * getLabelAfterInsn(const MachineInstr *MI)
Return Label immediately following the instruction.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
LLVM_NODISCARD char back() const
back - Get the last character in the string.
Definition: StringRef.h:149
auto find(R &&Range, const T &Val) -> decltype(adl_begin(Range))
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:867
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const DIExpression * getDebugExpression() const
Return the complex address expression referenced by this DBG_VALUE instruction.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Base class for scope-like contexts.
uint32_t getIndex() const
Definition: TypeIndex.h:111
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:797
PointerOptions
Equivalent to misc lfPointerAttr bitfields.
Definition: CodeView.h:352
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef drop_front(size_t N=1) const
Return a StringRef equal to &#39;this&#39; but with the first N elements dropped.
Definition: StringRef.h:645
LexicalScope * findInlinedScope(const DILocalScope *N, const DILocation *IA)
findInlinedScope - Find an inlined scope for the given scope/inlined-at.
Basic Register Allocator
Represents the location at which a variable is stored.
SourceLanguage
These values correspond to the CV_CFL_LANG enumeration, and are documented here: https://msdn.microsoft.com/en-us/library/bw3aekw6.aspx.
Definition: CodeView.h:144
static Optional< DbgVariableLocation > extractFromMachineInstruction(const MachineInstr &Instruction)
Extract a VariableLocation from a MachineInstr.
Base class for types.
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
void setDebugInfoAvailability(bool avail)
static TypeRecordKind getRecordKind(const DICompositeType *Ty)
StringRef getName() const
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:427
MCSymbol * getCOMDATSymbol() const
Definition: MCSectionCOFF.h:74
bool isDebugValue() const
Definition: MachineInstr.h:819
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:862
Module.h This file contains the declarations for the Module class.
LLVM_NODISCARD std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition: StringRef.h:727
CPUType
These values correspond to the CV_CPU_TYPE_e enumeration, and are documented here: https://msdn...
Definition: CodeView.h:79
Information about stack frame layout on the target.
StringRef str()
Return a StringRef for the vector contents.
Definition: raw_ostream.h:519
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
DebugLoc getFnDebugLoc() const
Find the debug info location for the start of the function.
Definition: DebugLoc.cpp:49
MCSymbol * getFunctionEnd() const
Definition: AsmPrinter.h:205
DWARF expression.
const Function & getFunction() const
Return the LLVM function that this machine code represents.
Collects and handles line tables information in a CodeView format.
Definition: CodeViewDebug.h:52
PointerMode
Equivalent to CV_ptrmode_e.
Definition: CodeView.h:343
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:924
This file contains constants used for implementing Dwarf debug support.
static StringRef dropLLVMManglingEscape(StringRef Name)
If the given string begins with the GlobalValue name mangling escape character &#39;\1&#39;, drop it.
Definition: GlobalValue.h:471
bool fragmentsOverlap(const DIExpression *Other) const
Check if fragments overlap between this DIExpression and Other.
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition: MCSymbol.h:267
RecordRecTy * getType()
Definition: Record.cpp:1861
DebugLoc PrologEndLoc
This location indicates end of function prologue and beginning of function body.
MethodOptions
Equivalent to CV_fldattr_t bitfield.
Definition: CodeView.h:277
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:396
bool hasComdat() const
Definition: GlobalObject.h:100
static const DISubprogram * getQualifiedNameComponents(const DIScope *Scope, SmallVectorImpl< StringRef > &QualifiedNameComponents)
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:142
Dumper for CodeView type streams found in COFF object files and PDB files.
TargetSubtargetInfo - Generic base class for all target subtargets.
#define Success
StringRef getIdentifier() const
static MethodKind translateMethodKindFlags(const DISubprogram *SP, bool Introduced)
Type array for a subprogram.
int getCodeViewRegNum(unsigned RegNum) const
Map a target register to an equivalent CodeView register number.
Representation of each machine instruction.
Definition: MachineInstr.h:60
const DIDerivedType * MemberTypeNode
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:120
void setPrefix(StringRef P)
Definition: ScopedPrinter.h:85
unsigned getEncoding() const
void emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:654
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:61
ArrayRef< T > drop_front(size_t N=1) const
Drop the first N elements of the array.
Definition: ArrayRef.h:188
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
static void emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S, unsigned MaxFixedRecordLength=0xF00)
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
virtual const TargetFrameLowering * getFrameLowering() const
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
Base class for debug information backends.
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:91
static std::string getQualifiedName(ArrayRef< StringRef > QualifiedNameComponents, StringRef TypeName)
const Module * getModule() const
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:181
PointerToMemberRepresentation
Equivalent to CV_pmtype_e.
Definition: CodeView.h:364
ThunkOrdinal
These values correspond to the THUNK_ORDINAL enumeration.
Definition: CodeView.h:514
unsigned getCol() const
Definition: DebugLoc.cpp:30
static Version parseVersion(StringRef Name)
unsigned getCodePointerSize() const
Get the code pointer size in bytes.
Definition: MCAsmInfo.h:387
const unsigned Kind
DITypeRef getType() const
MCSymbol * getLabelBeforeInsn(const MachineInstr *MI)
Return Label preceding the instruction.
MemberAccess
Source-level access specifier. (CV_access_e)
Definition: CodeView.h:258
SmallVector< int64_t, 1 > LoadChain
Chain of offsetted loads necessary to load the value if it lives in memory.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static APSInt getUnsigned(uint64_t X)
Definition: APSInt.h:315
static MethodOptions translateMethodOptionFlags(const DISubprogram *SP)
std::vector< const DIType * > NestedTypes
virtual bool EmitCVInlineSiteIdDirective(unsigned FunctionId, unsigned IAFunc, unsigned IAFile, unsigned IALine, unsigned IACol, SMLoc Loc)
Introduces an inline call site id for use with .cv_loc.
Definition: MCStreamer.cpp:255
DIScopeRef getScope() const
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
static bool shouldEmitUdt(const DIType *T)
CallingConvention
These values correspond to the CV_call_e enumeration, and are documented at the following locations: ...
Definition: CodeView.h:173
DITypeRefArray getTypeArray() const
bool isBitField() const
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef take_front(size_t N=1) const
Return a StringRef equal to &#39;this&#39; but with only the first N elements remaining.
Definition: StringRef.h:608
MachineModuleInfo * MMI
Collected machine module information.
bool isThreadLocal() const
If the value is "Thread Local", its value isn&#39;t shared by the threads.
Definition: GlobalValue.h:246
iterator_range< global_iterator > globals()
Definition: Module.h:561
static uint64_t getBaseTypeSize(const DITypeRef TyRef)
If this type is derived from a base type then return base type size.
IRTranslator LLVM IR MI
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
static Expected< std::string > replace(StringRef S, StringRef From, StringRef To)
static PointerToMemberRepresentation translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags)
static CallingConvention dwarfCCToCodeView(unsigned DwarfCC)
Given a DWARF calling convention, get the CodeView equivalent.
TypedDINodeRef< DIType > DITypeRef
Represents a location in source code.
Definition: SMLoc.h:24
DILocalScope * getScope() const
Get the local scope for this variable.
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1073
LocalSymFlags
Corresponds to CV_LVARFLAGS bitfield.
Definition: CodeView.h:394
Root of the metadata hierarchy.
Definition: Metadata.h:58
const uint64_t Version
Definition: InstrProf.h:895
static ClassOptions getCommonClassOptions(const DICompositeType *Ty)
Return ClassOptions that should be present on both the forward declaration and the defintion of a tag...
bool getFlag(MIFlag Flag) const
Return whether an MI flag is set.
Definition: MachineInstr.h:183
void begin(ContinuationRecordKind RecordKind)
MemberList Members
Direct members.
std::pair< const MachineInstr *, const MachineInstr * > InsnRange
InsnRange - This is used to track range of instructions with identical lexical scope.
Definition: LexicalScopes.h:40
std::vector< const DIDerivedType * > Inheritance
Base classes.
static bool needsReferenceType(const DbgVariableLocation &Loc)
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:144
LexicalScope * getCurrentFunctionScope() const
getCurrentFunctionScope - Return lexical scope for the current function.
Basic type, like &#39;int&#39; or &#39;float&#39;.
DIScopeRef getScope() const