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