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