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