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 isTrivial(const DICompositeType *DCTy) {
367  return ((DCTy->getFlags() & DINode::FlagTrivial) == DINode::FlagTrivial);
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 (!isTrivial(ReturnDCTy))
383  FO |= FunctionOptions::CxxReturnUdt;
384  }
385 
386  // DISubroutineType is unnamed. Use DISubprogram's i.e. SPName in comparison.
387  if (ClassTy && !isTrivial(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  default:
703  // There's no CodeView representation for this language, and CV doesn't
704  // have an "unknown" option for the language field, so we'll use MASM,
705  // as it's very low level.
706  return SourceLanguage::Masm;
707  }
708 }
709 
710 namespace {
711 struct Version {
712  int Part[4];
713 };
714 } // end anonymous namespace
715 
716 // Takes a StringRef like "clang 4.0.0.0 (other nonsense 123)" and parses out
717 // the version number.
719  Version V = {{0}};
720  int N = 0;
721  for (const char C : Name) {
722  if (isdigit(C)) {
723  V.Part[N] *= 10;
724  V.Part[N] += C - '0';
725  } else if (C == '.') {
726  ++N;
727  if (N >= 4)
728  return V;
729  } else if (N > 0)
730  return V;
731  }
732  return V;
733 }
734 
735 void CodeViewDebug::emitCompilerInformation() {
736  MCSymbol *CompilerEnd = beginSymbolRecord(SymbolKind::S_COMPILE3);
737  uint32_t Flags = 0;
738 
739  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
740  const MDNode *Node = *CUs->operands().begin();
741  const auto *CU = cast<DICompileUnit>(Node);
742 
743  // The low byte of the flags indicates the source language.
744  Flags = MapDWLangToCVLang(CU->getSourceLanguage());
745  // TODO: Figure out which other flags need to be set.
746 
747  OS.AddComment("Flags and language");
748  OS.EmitIntValue(Flags, 4);
749 
750  OS.AddComment("CPUType");
751  OS.EmitIntValue(static_cast<uint64_t>(TheCPU), 2);
752 
753  StringRef CompilerVersion = CU->getProducer();
754  Version FrontVer = parseVersion(CompilerVersion);
755  OS.AddComment("Frontend version");
756  for (int N = 0; N < 4; ++N)
757  OS.EmitIntValue(FrontVer.Part[N], 2);
758 
759  // Some Microsoft tools, like Binscope, expect a backend version number of at
760  // least 8.something, so we'll coerce the LLVM version into a form that
761  // guarantees it'll be big enough without really lying about the version.
762  int Major = 1000 * LLVM_VERSION_MAJOR +
763  10 * LLVM_VERSION_MINOR +
764  LLVM_VERSION_PATCH;
765  // Clamp it for builds that use unusually large version numbers.
766  Major = std::min<int>(Major, std::numeric_limits<uint16_t>::max());
767  Version BackVer = {{ Major, 0, 0, 0 }};
768  OS.AddComment("Backend version");
769  for (int N = 0; N < 4; ++N)
770  OS.EmitIntValue(BackVer.Part[N], 2);
771 
772  OS.AddComment("Null-terminated compiler version string");
773  emitNullTerminatedSymbolName(OS, CompilerVersion);
774 
775  endSymbolRecord(CompilerEnd);
776 }
777 
779  StringRef S) {
780  StringIdRecord SIR(TypeIndex(0x0), S);
781  return TypeTable.writeLeafType(SIR);
782 }
783 
784 void CodeViewDebug::emitBuildInfo() {
785  // First, make LF_BUILDINFO. It's a sequence of strings with various bits of
786  // build info. The known prefix is:
787  // - Absolute path of current directory
788  // - Compiler path
789  // - Main source file path, relative to CWD or absolute
790  // - Type server PDB file
791  // - Canonical compiler command line
792  // If frontend and backend compilation are separated (think llc or LTO), it's
793  // not clear if the compiler path should refer to the executable for the
794  // frontend or the backend. Leave it blank for now.
795  TypeIndex BuildInfoArgs[BuildInfoRecord::MaxArgs] = {};
796  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
797  const MDNode *Node = *CUs->operands().begin(); // FIXME: Multiple CUs.
798  const auto *CU = cast<DICompileUnit>(Node);
799  const DIFile *MainSourceFile = CU->getFile();
800  BuildInfoArgs[BuildInfoRecord::CurrentDirectory] =
801  getStringIdTypeIdx(TypeTable, MainSourceFile->getDirectory());
802  BuildInfoArgs[BuildInfoRecord::SourceFile] =
803  getStringIdTypeIdx(TypeTable, MainSourceFile->getFilename());
804  // FIXME: Path to compiler and command line. PDB is intentionally blank unless
805  // we implement /Zi type servers.
806  BuildInfoRecord BIR(BuildInfoArgs);
807  TypeIndex BuildInfoIndex = TypeTable.writeLeafType(BIR);
808 
809  // Make a new .debug$S subsection for the S_BUILDINFO record, which points
810  // from the module symbols into the type stream.
811  MCSymbol *BISubsecEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
812  MCSymbol *BIEnd = beginSymbolRecord(SymbolKind::S_BUILDINFO);
813  OS.AddComment("LF_BUILDINFO index");
814  OS.EmitIntValue(BuildInfoIndex.getIndex(), 4);
815  endSymbolRecord(BIEnd);
816  endCVSubsection(BISubsecEnd);
817 }
818 
819 void CodeViewDebug::emitInlineeLinesSubsection() {
820  if (InlinedSubprograms.empty())
821  return;
822 
823  OS.AddComment("Inlinee lines subsection");
824  MCSymbol *InlineEnd = beginCVSubsection(DebugSubsectionKind::InlineeLines);
825 
826  // We emit the checksum info for files. This is used by debuggers to
827  // determine if a pdb matches the source before loading it. Visual Studio,
828  // for instance, will display a warning that the breakpoints are not valid if
829  // the pdb does not match the source.
830  OS.AddComment("Inlinee lines signature");
831  OS.EmitIntValue(unsigned(InlineeLinesSignature::Normal), 4);
832 
833  for (const DISubprogram *SP : InlinedSubprograms) {
834  assert(TypeIndices.count({SP, nullptr}));
835  TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}];
836 
837  OS.AddBlankLine();
838  unsigned FileId = maybeRecordFile(SP->getFile());
839  OS.AddComment("Inlined function " + SP->getName() + " starts at " +
840  SP->getFilename() + Twine(':') + Twine(SP->getLine()));
841  OS.AddBlankLine();
842  OS.AddComment("Type index of inlined function");
843  OS.EmitIntValue(InlineeIdx.getIndex(), 4);
844  OS.AddComment("Offset into filechecksum table");
845  OS.EmitCVFileChecksumOffsetDirective(FileId);
846  OS.AddComment("Starting line number");
847  OS.EmitIntValue(SP->getLine(), 4);
848  }
849 
850  endCVSubsection(InlineEnd);
851 }
852 
853 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,
854  const DILocation *InlinedAt,
855  const InlineSite &Site) {
856  assert(TypeIndices.count({Site.Inlinee, nullptr}));
857  TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}];
858 
859  // SymbolRecord
860  MCSymbol *InlineEnd = beginSymbolRecord(SymbolKind::S_INLINESITE);
861 
862  OS.AddComment("PtrParent");
863  OS.EmitIntValue(0, 4);
864  OS.AddComment("PtrEnd");
865  OS.EmitIntValue(0, 4);
866  OS.AddComment("Inlinee type index");
867  OS.EmitIntValue(InlineeIdx.getIndex(), 4);
868 
869  unsigned FileId = maybeRecordFile(Site.Inlinee->getFile());
870  unsigned StartLineNum = Site.Inlinee->getLine();
871 
872  OS.EmitCVInlineLinetableDirective(Site.SiteFuncId, FileId, StartLineNum,
873  FI.Begin, FI.End);
874 
875  endSymbolRecord(InlineEnd);
876 
877  emitLocalVariableList(FI, Site.InlinedLocals);
878 
879  // Recurse on child inlined call sites before closing the scope.
880  for (const DILocation *ChildSite : Site.ChildSites) {
881  auto I = FI.InlineSites.find(ChildSite);
882  assert(I != FI.InlineSites.end() &&
883  "child site not in function inline site map");
884  emitInlinedCallSite(FI, ChildSite, I->second);
885  }
886 
887  // Close the scope.
888  emitEndSymbolRecord(SymbolKind::S_INLINESITE_END);
889 }
890 
891 void CodeViewDebug::switchToDebugSectionForSymbol(const MCSymbol *GVSym) {
892  // If we have a symbol, it may be in a section that is COMDAT. If so, find the
893  // comdat key. A section may be comdat because of -ffunction-sections or
894  // because it is comdat in the IR.
895  MCSectionCOFF *GVSec =
896  GVSym ? dyn_cast<MCSectionCOFF>(&GVSym->getSection()) : nullptr;
897  const MCSymbol *KeySym = GVSec ? GVSec->getCOMDATSymbol() : nullptr;
898 
899  MCSectionCOFF *DebugSec = cast<MCSectionCOFF>(
901  DebugSec = OS.getContext().getAssociativeCOFFSection(DebugSec, KeySym);
902 
903  OS.SwitchSection(DebugSec);
904 
905  // Emit the magic version number if this is the first time we've switched to
906  // this section.
907  if (ComdatDebugSections.insert(DebugSec).second)
908  emitCodeViewMagicVersion();
909 }
910 
911 // Emit an S_THUNK32/S_END symbol pair for a thunk routine.
912 // The only supported thunk ordinal is currently the standard type.
913 void CodeViewDebug::emitDebugInfoForThunk(const Function *GV,
914  FunctionInfo &FI,
915  const MCSymbol *Fn) {
916  std::string FuncName = GlobalValue::dropLLVMManglingEscape(GV->getName());
917  const ThunkOrdinal ordinal = ThunkOrdinal::Standard; // Only supported kind.
918 
919  OS.AddComment("Symbol subsection for " + Twine(FuncName));
920  MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
921 
922  // Emit S_THUNK32
923  MCSymbol *ThunkRecordEnd = beginSymbolRecord(SymbolKind::S_THUNK32);
924  OS.AddComment("PtrParent");
925  OS.EmitIntValue(0, 4);
926  OS.AddComment("PtrEnd");
927  OS.EmitIntValue(0, 4);
928  OS.AddComment("PtrNext");
929  OS.EmitIntValue(0, 4);
930  OS.AddComment("Thunk section relative address");
931  OS.EmitCOFFSecRel32(Fn, /*Offset=*/0);
932  OS.AddComment("Thunk section index");
933  OS.EmitCOFFSectionIndex(Fn);
934  OS.AddComment("Code size");
935  OS.emitAbsoluteSymbolDiff(FI.End, Fn, 2);
936  OS.AddComment("Ordinal");
937  OS.EmitIntValue(unsigned(ordinal), 1);
938  OS.AddComment("Function name");
939  emitNullTerminatedSymbolName(OS, FuncName);
940  // Additional fields specific to the thunk ordinal would go here.
941  endSymbolRecord(ThunkRecordEnd);
942 
943  // Local variables/inlined routines are purposely omitted here. The point of
944  // marking this as a thunk is so Visual Studio will NOT stop in this routine.
945 
946  // Emit S_PROC_ID_END
947  emitEndSymbolRecord(SymbolKind::S_PROC_ID_END);
948 
949  endCVSubsection(SymbolsEnd);
950 }
951 
952 void CodeViewDebug::emitDebugInfoForFunction(const Function *GV,
953  FunctionInfo &FI) {
954  // For each function there is a separate subsection which holds the PC to
955  // file:line table.
956  const MCSymbol *Fn = Asm->getSymbol(GV);
957  assert(Fn);
958 
959  // Switch to the to a comdat section, if appropriate.
960  switchToDebugSectionForSymbol(Fn);
961 
962  std::string FuncName;
963  auto *SP = GV->getSubprogram();
964  assert(SP);
965  setCurrentSubprogram(SP);
966 
967  if (SP->isThunk()) {
968  emitDebugInfoForThunk(GV, FI, Fn);
969  return;
970  }
971 
972  // If we have a display name, build the fully qualified name by walking the
973  // chain of scopes.
974  if (!SP->getName().empty())
975  FuncName =
977 
978  // If our DISubprogram name is empty, use the mangled name.
979  if (FuncName.empty())
981 
982  // Emit FPO data, but only on 32-bit x86. No other platforms use it.
983  if (Triple(MMI->getModule()->getTargetTriple()).getArch() == Triple::x86)
984  OS.EmitCVFPOData(Fn);
985 
986  // Emit a symbol subsection, required by VS2012+ to find function boundaries.
987  OS.AddComment("Symbol subsection for " + Twine(FuncName));
988  MCSymbol *SymbolsEnd = beginCVSubsection(DebugSubsectionKind::Symbols);
989  {
990  SymbolKind ProcKind = GV->hasLocalLinkage() ? SymbolKind::S_LPROC32_ID
991  : SymbolKind::S_GPROC32_ID;
992  MCSymbol *ProcRecordEnd = beginSymbolRecord(ProcKind);
993 
994  // These fields are filled in by tools like CVPACK which run after the fact.
995  OS.AddComment("PtrParent");
996  OS.EmitIntValue(0, 4);
997  OS.AddComment("PtrEnd");
998  OS.EmitIntValue(0, 4);
999  OS.AddComment("PtrNext");
1000  OS.EmitIntValue(0, 4);
1001  // This is the important bit that tells the debugger where the function
1002  // code is located and what's its size:
1003  OS.AddComment("Code size");
1004  OS.emitAbsoluteSymbolDiff(FI.End, Fn, 4);
1005  OS.AddComment("Offset after prologue");
1006  OS.EmitIntValue(0, 4);
1007  OS.AddComment("Offset before epilogue");
1008  OS.EmitIntValue(0, 4);
1009  OS.AddComment("Function type index");
1010  OS.EmitIntValue(getFuncIdForSubprogram(GV->getSubprogram()).getIndex(), 4);
1011  OS.AddComment("Function section relative address");
1012  OS.EmitCOFFSecRel32(Fn, /*Offset=*/0);
1013  OS.AddComment("Function section index");
1014  OS.EmitCOFFSectionIndex(Fn);
1015  OS.AddComment("Flags");
1016  OS.EmitIntValue(0, 1);
1017  // Emit the function display name as a null-terminated string.
1018  OS.AddComment("Function name");
1019  // Truncate the name so we won't overflow the record length field.
1020  emitNullTerminatedSymbolName(OS, FuncName);
1021  endSymbolRecord(ProcRecordEnd);
1022 
1023  MCSymbol *FrameProcEnd = beginSymbolRecord(SymbolKind::S_FRAMEPROC);
1024  // Subtract out the CSR size since MSVC excludes that and we include it.
1025  OS.AddComment("FrameSize");
1026  OS.EmitIntValue(FI.FrameSize - FI.CSRSize, 4);
1027  OS.AddComment("Padding");
1028  OS.EmitIntValue(0, 4);
1029  OS.AddComment("Offset of padding");
1030  OS.EmitIntValue(0, 4);
1031  OS.AddComment("Bytes of callee saved registers");
1032  OS.EmitIntValue(FI.CSRSize, 4);
1033  OS.AddComment("Exception handler offset");
1034  OS.EmitIntValue(0, 4);
1035  OS.AddComment("Exception handler section");
1036  OS.EmitIntValue(0, 2);
1037  OS.AddComment("Flags (defines frame register)");
1038  OS.EmitIntValue(uint32_t(FI.FrameProcOpts), 4);
1039  endSymbolRecord(FrameProcEnd);
1040 
1041  emitLocalVariableList(FI, FI.Locals);
1042  emitGlobalVariableList(FI.Globals);
1043  emitLexicalBlockList(FI.ChildBlocks, FI);
1044 
1045  // Emit inlined call site information. Only emit functions inlined directly
1046  // into the parent function. We'll emit the other sites recursively as part
1047  // of their parent inline site.
1048  for (const DILocation *InlinedAt : FI.ChildSites) {
1049  auto I = FI.InlineSites.find(InlinedAt);
1050  assert(I != FI.InlineSites.end() &&
1051  "child site not in function inline site map");
1052  emitInlinedCallSite(FI, InlinedAt, I->second);
1053  }
1054 
1055  for (auto Annot : FI.Annotations) {
1056  MCSymbol *Label = Annot.first;
1057  MDTuple *Strs = cast<MDTuple>(Annot.second);
1058  MCSymbol *AnnotEnd = beginSymbolRecord(SymbolKind::S_ANNOTATION);
1059  OS.EmitCOFFSecRel32(Label, /*Offset=*/0);
1060  // FIXME: Make sure we don't overflow the max record size.
1061  OS.EmitCOFFSectionIndex(Label);
1062  OS.EmitIntValue(Strs->getNumOperands(), 2);
1063  for (Metadata *MD : Strs->operands()) {
1064  // MDStrings are null terminated, so we can do EmitBytes and get the
1065  // nice .asciz directive.
1066  StringRef Str = cast<MDString>(MD)->getString();
1067  assert(Str.data()[Str.size()] == '\0' && "non-nullterminated MDString");
1068  OS.EmitBytes(StringRef(Str.data(), Str.size() + 1));
1069  }
1070  endSymbolRecord(AnnotEnd);
1071  }
1072 
1073  if (SP != nullptr)
1074  emitDebugInfoForUDTs(LocalUDTs);
1075 
1076  // We're done with this function.
1077  emitEndSymbolRecord(SymbolKind::S_PROC_ID_END);
1078  }
1079  endCVSubsection(SymbolsEnd);
1080 
1081  // We have an assembler directive that takes care of the whole line table.
1082  OS.EmitCVLinetableDirective(FI.FuncId, Fn, FI.End);
1083 }
1084 
1085 CodeViewDebug::LocalVarDefRange
1086 CodeViewDebug::createDefRangeMem(uint16_t CVRegister, int Offset) {
1087  LocalVarDefRange DR;
1088  DR.InMemory = -1;
1089  DR.DataOffset = Offset;
1090  assert(DR.DataOffset == Offset && "truncation");
1091  DR.IsSubfield = 0;
1092  DR.StructOffset = 0;
1093  DR.CVRegister = CVRegister;
1094  return DR;
1095 }
1096 
1097 void CodeViewDebug::collectVariableInfoFromMFTable(
1098  DenseSet<InlinedEntity> &Processed) {
1099  const MachineFunction &MF = *Asm->MF;
1100  const TargetSubtargetInfo &TSI = MF.getSubtarget();
1101  const TargetFrameLowering *TFI = TSI.getFrameLowering();
1102  const TargetRegisterInfo *TRI = TSI.getRegisterInfo();
1103 
1105  if (!VI.Var)
1106  continue;
1107  assert(VI.Var->isValidLocationForIntrinsic(VI.Loc) &&
1108  "Expected inlined-at fields to agree");
1109 
1110  Processed.insert(InlinedEntity(VI.Var, VI.Loc->getInlinedAt()));
1111  LexicalScope *Scope = LScopes.findLexicalScope(VI.Loc);
1112 
1113  // If variable scope is not found then skip this variable.
1114  if (!Scope)
1115  continue;
1116 
1117  // If the variable has an attached offset expression, extract it.
1118  // FIXME: Try to handle DW_OP_deref as well.
1119  int64_t ExprOffset = 0;
1120  if (VI.Expr)
1121  if (!VI.Expr->extractIfOffset(ExprOffset))
1122  continue;
1123 
1124  // Get the frame register used and the offset.
1125  unsigned FrameReg = 0;
1126  int FrameOffset = TFI->getFrameIndexReference(*Asm->MF, VI.Slot, FrameReg);
1127  uint16_t CVReg = TRI->getCodeViewRegNum(FrameReg);
1128 
1129  // Calculate the label ranges.
1130  LocalVarDefRange DefRange =
1131  createDefRangeMem(CVReg, FrameOffset + ExprOffset);
1132  for (const InsnRange &Range : Scope->getRanges()) {
1133  const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
1134  const MCSymbol *End = getLabelAfterInsn(Range.second);
1135  End = End ? End : Asm->getFunctionEnd();
1136  DefRange.Ranges.emplace_back(Begin, End);
1137  }
1138 
1139  LocalVariable Var;
1140  Var.DIVar = VI.Var;
1141  Var.DefRanges.emplace_back(std::move(DefRange));
1142  recordLocalVariable(std::move(Var), Scope);
1143  }
1144 }
1145 
1146 static bool canUseReferenceType(const DbgVariableLocation &Loc) {
1147  return !Loc.LoadChain.empty() && Loc.LoadChain.back() == 0;
1148 }
1149 
1150 static bool needsReferenceType(const DbgVariableLocation &Loc) {
1151  return Loc.LoadChain.size() == 2 && Loc.LoadChain.back() == 0;
1152 }
1153 
1154 void CodeViewDebug::calculateRanges(
1155  LocalVariable &Var, const DbgValueHistoryMap::InstrRanges &Ranges) {
1157 
1158  // Calculate the definition ranges.
1159  for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
1160  const InsnRange &Range = *I;
1161  const MachineInstr *DVInst = Range.first;
1162  assert(DVInst->isDebugValue() && "Invalid History entry");
1163  // FIXME: Find a way to represent constant variables, since they are
1164  // relatively common.
1167  if (!Location)
1168  continue;
1169 
1170  // CodeView can only express variables in register and variables in memory
1171  // at a constant offset from a register. However, for variables passed
1172  // indirectly by pointer, it is common for that pointer to be spilled to a
1173  // stack location. For the special case of one offseted load followed by a
1174  // zero offset load (a pointer spilled to the stack), we change the type of
1175  // the local variable from a value type to a reference type. This tricks the
1176  // debugger into doing the load for us.
1177  if (Var.UseReferenceType) {
1178  // We're using a reference type. Drop the last zero offset load.
1179  if (canUseReferenceType(*Location))
1180  Location->LoadChain.pop_back();
1181  else
1182  continue;
1183  } else if (needsReferenceType(*Location)) {
1184  // This location can't be expressed without switching to a reference type.
1185  // Start over using that.
1186  Var.UseReferenceType = true;
1187  Var.DefRanges.clear();
1188  calculateRanges(Var, Ranges);
1189  return;
1190  }
1191 
1192  // We can only handle a register or an offseted load of a register.
1193  if (Location->Register == 0 || Location->LoadChain.size() > 1)
1194  continue;
1195  {
1196  LocalVarDefRange DR;
1197  DR.CVRegister = TRI->getCodeViewRegNum(Location->Register);
1198  DR.InMemory = !Location->LoadChain.empty();
1199  DR.DataOffset =
1200  !Location->LoadChain.empty() ? Location->LoadChain.back() : 0;
1201  if (Location->FragmentInfo) {
1202  DR.IsSubfield = true;
1203  DR.StructOffset = Location->FragmentInfo->OffsetInBits / 8;
1204  } else {
1205  DR.IsSubfield = false;
1206  DR.StructOffset = 0;
1207  }
1208 
1209  if (Var.DefRanges.empty() ||
1210  Var.DefRanges.back().isDifferentLocation(DR)) {
1211  Var.DefRanges.emplace_back(std::move(DR));
1212  }
1213  }
1214 
1215  // Compute the label range.
1216  const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
1217  const MCSymbol *End = getLabelAfterInsn(Range.second);
1218  if (!End) {
1219  // This range is valid until the next overlapping bitpiece. In the
1220  // common case, ranges will not be bitpieces, so they will overlap.
1221  auto J = std::next(I);
1222  const DIExpression *DIExpr = DVInst->getDebugExpression();
1223  while (J != E &&
1224  !DIExpr->fragmentsOverlap(J->first->getDebugExpression()))
1225  ++J;
1226  if (J != E)
1227  End = getLabelBeforeInsn(J->first);
1228  else
1229  End = Asm->getFunctionEnd();
1230  }
1231 
1232  // If the last range end is our begin, just extend the last range.
1233  // Otherwise make a new range.
1235  Var.DefRanges.back().Ranges;
1236  if (!R.empty() && R.back().second == Begin)
1237  R.back().second = End;
1238  else
1239  R.emplace_back(Begin, End);
1240 
1241  // FIXME: Do more range combining.
1242  }
1243 }
1244 
1245 void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) {
1246  DenseSet<InlinedEntity> Processed;
1247  // Grab the variable info that was squirreled away in the MMI side-table.
1248  collectVariableInfoFromMFTable(Processed);
1249 
1250  for (const auto &I : DbgValues) {
1251  InlinedEntity IV = I.first;
1252  if (Processed.count(IV))
1253  continue;
1254  const DILocalVariable *DIVar = cast<DILocalVariable>(IV.first);
1255  const DILocation *InlinedAt = IV.second;
1256 
1257  // Instruction ranges, specifying where IV is accessible.
1258  const auto &Ranges = I.second;
1259 
1260  LexicalScope *Scope = nullptr;
1261  if (InlinedAt)
1262  Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt);
1263  else
1264  Scope = LScopes.findLexicalScope(DIVar->getScope());
1265  // If variable scope is not found then skip this variable.
1266  if (!Scope)
1267  continue;
1268 
1269  LocalVariable Var;
1270  Var.DIVar = DIVar;
1271 
1272  calculateRanges(Var, Ranges);
1273  recordLocalVariable(std::move(Var), Scope);
1274  }
1275 }
1276 
1278  const TargetSubtargetInfo &TSI = MF->getSubtarget();
1279  const TargetRegisterInfo *TRI = TSI.getRegisterInfo();
1280  const MachineFrameInfo &MFI = MF->getFrameInfo();
1281  const Function &GV = MF->getFunction();
1282  auto Insertion = FnDebugInfo.insert({&GV, llvm::make_unique<FunctionInfo>()});
1283  assert(Insertion.second && "function already has info");
1284  CurFn = Insertion.first->second.get();
1285  CurFn->FuncId = NextFuncId++;
1286  CurFn->Begin = Asm->getFunctionBegin();
1287 
1288  // The S_FRAMEPROC record reports the stack size, and how many bytes of
1289  // callee-saved registers were used. For targets that don't use a PUSH
1290  // instruction (AArch64), this will be zero.
1291  CurFn->CSRSize = MFI.getCVBytesOfCalleeSavedRegisters();
1292  CurFn->FrameSize = MFI.getStackSize();
1293  CurFn->OffsetAdjustment = MFI.getOffsetAdjustment();
1294  CurFn->HasStackRealignment = TRI->needsStackRealignment(*MF);
1295 
1296  // For this function S_FRAMEPROC record, figure out which codeview register
1297  // will be the frame pointer.
1298  CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::None; // None.
1299  CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::None; // None.
1300  if (CurFn->FrameSize > 0) {
1301  if (!TSI.getFrameLowering()->hasFP(*MF)) {
1302  CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::StackPtr;
1303  CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::StackPtr;
1304  } else {
1305  // If there is an FP, parameters are always relative to it.
1306  CurFn->EncodedParamFramePtrReg = EncodedFramePtrReg::FramePtr;
1307  if (CurFn->HasStackRealignment) {
1308  // If the stack needs realignment, locals are relative to SP or VFRAME.
1309  CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::StackPtr;
1310  } else {
1311  // Otherwise, locals are relative to EBP, and we probably have VLAs or
1312  // other stack adjustments.
1313  CurFn->EncodedLocalFramePtrReg = EncodedFramePtrReg::FramePtr;
1314  }
1315  }
1316  }
1317 
1318  // Compute other frame procedure options.
1320  if (MFI.hasVarSizedObjects())
1321  FPO |= FrameProcedureOptions::HasAlloca;
1322  if (MF->exposesReturnsTwice())
1323  FPO |= FrameProcedureOptions::HasSetJmp;
1324  // FIXME: Set HasLongJmp if we ever track that info.
1325  if (MF->hasInlineAsm())
1326  FPO |= FrameProcedureOptions::HasInlineAssembly;
1327  if (GV.hasPersonalityFn()) {
1330  FPO |= FrameProcedureOptions::HasStructuredExceptionHandling;
1331  else
1332  FPO |= FrameProcedureOptions::HasExceptionHandling;
1333  }
1334  if (GV.hasFnAttribute(Attribute::InlineHint))
1335  FPO |= FrameProcedureOptions::MarkedInline;
1336  if (GV.hasFnAttribute(Attribute::Naked))
1337  FPO |= FrameProcedureOptions::Naked;
1338  if (MFI.hasStackProtectorIndex())
1339  FPO |= FrameProcedureOptions::SecurityChecks;
1340  FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedLocalFramePtrReg) << 14U);
1341  FPO |= FrameProcedureOptions(uint32_t(CurFn->EncodedParamFramePtrReg) << 16U);
1342  if (Asm->TM.getOptLevel() != CodeGenOpt::None && !GV.optForSize() &&
1343  !GV.hasFnAttribute(Attribute::OptimizeNone))
1344  FPO |= FrameProcedureOptions::OptimizedForSpeed;
1345  // FIXME: Set GuardCfg when it is implemented.
1346  CurFn->FrameProcOpts = FPO;
1347 
1348  OS.EmitCVFuncIdDirective(CurFn->FuncId);
1349 
1350  // Find the end of the function prolog. First known non-DBG_VALUE and
1351  // non-frame setup location marks the beginning of the function body.
1352  // FIXME: is there a simpler a way to do this? Can we just search
1353  // for the first instruction of the function, not the last of the prolog?
1355  bool EmptyPrologue = true;
1356  for (const auto &MBB : *MF) {
1357  for (const auto &MI : MBB) {
1358  if (!MI.isMetaInstruction() && !MI.getFlag(MachineInstr::FrameSetup) &&
1359  MI.getDebugLoc()) {
1360  PrologEndLoc = MI.getDebugLoc();
1361  break;
1362  } else if (!MI.isMetaInstruction()) {
1363  EmptyPrologue = false;
1364  }
1365  }
1366  }
1367 
1368  // Record beginning of function if we have a non-empty prologue.
1369  if (PrologEndLoc && !EmptyPrologue) {
1370  DebugLoc FnStartDL = PrologEndLoc.getFnDebugLoc();
1371  maybeRecordLocation(FnStartDL, MF);
1372  }
1373 }
1374 
1375 static bool shouldEmitUdt(const DIType *T) {
1376  if (!T)
1377  return false;
1378 
1379  // MSVC does not emit UDTs for typedefs that are scoped to classes.
1380  if (T->getTag() == dwarf::DW_TAG_typedef) {
1381  if (DIScope *Scope = T->getScope().resolve()) {
1382  switch (Scope->getTag()) {
1383  case dwarf::DW_TAG_structure_type:
1384  case dwarf::DW_TAG_class_type:
1385  case dwarf::DW_TAG_union_type:
1386  return false;
1387  }
1388  }
1389  }
1390 
1391  while (true) {
1392  if (!T || T->isForwardDecl())
1393  return false;
1394 
1395  const DIDerivedType *DT = dyn_cast<DIDerivedType>(T);
1396  if (!DT)
1397  return true;
1398  T = DT->getBaseType().resolve();
1399  }
1400  return true;
1401 }
1402 
1403 void CodeViewDebug::addToUDTs(const DIType *Ty) {
1404  // Don't record empty UDTs.
1405  if (Ty->getName().empty())
1406  return;
1407  if (!shouldEmitUdt(Ty))
1408  return;
1409 
1410  SmallVector<StringRef, 5> QualifiedNameComponents;
1411  const DISubprogram *ClosestSubprogram = getQualifiedNameComponents(
1412  Ty->getScope().resolve(), QualifiedNameComponents);
1413 
1414  std::string FullyQualifiedName =
1415  getQualifiedName(QualifiedNameComponents, getPrettyScopeName(Ty));
1416 
1417  if (ClosestSubprogram == nullptr) {
1418  GlobalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
1419  } else if (ClosestSubprogram == CurrentSubprogram) {
1420  LocalUDTs.emplace_back(std::move(FullyQualifiedName), Ty);
1421  }
1422 
1423  // TODO: What if the ClosestSubprogram is neither null or the current
1424  // subprogram? Currently, the UDT just gets dropped on the floor.
1425  //
1426  // The current behavior is not desirable. To get maximal fidelity, we would
1427  // need to perform all type translation before beginning emission of .debug$S
1428  // and then make LocalUDTs a member of FunctionInfo
1429 }
1430 
1431 TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
1432  // Generic dispatch for lowering an unknown type.
1433  switch (Ty->getTag()) {
1434  case dwarf::DW_TAG_array_type:
1435  return lowerTypeArray(cast<DICompositeType>(Ty));
1436  case dwarf::DW_TAG_typedef:
1437  return lowerTypeAlias(cast<DIDerivedType>(Ty));
1438  case dwarf::DW_TAG_base_type:
1439  return lowerTypeBasic(cast<DIBasicType>(Ty));
1440  case dwarf::DW_TAG_pointer_type:
1441  if (cast<DIDerivedType>(Ty)->getName() == "__vtbl_ptr_type")
1442  return lowerTypeVFTableShape(cast<DIDerivedType>(Ty));
1444  case dwarf::DW_TAG_reference_type:
1445  case dwarf::DW_TAG_rvalue_reference_type:
1446  return lowerTypePointer(cast<DIDerivedType>(Ty));
1447  case dwarf::DW_TAG_ptr_to_member_type:
1448  return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
1449  case dwarf::DW_TAG_restrict_type:
1450  case dwarf::DW_TAG_const_type:
1451  case dwarf::DW_TAG_volatile_type:
1452  // TODO: add support for DW_TAG_atomic_type here
1453  return lowerTypeModifier(cast<DIDerivedType>(Ty));
1454  case dwarf::DW_TAG_subroutine_type:
1455  if (ClassTy) {
1456  // The member function type of a member function pointer has no
1457  // ThisAdjustment.
1458  return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy,
1459  /*ThisAdjustment=*/0,
1460  /*IsStaticMethod=*/false);
1461  }
1462  return lowerTypeFunction(cast<DISubroutineType>(Ty));
1463  case dwarf::DW_TAG_enumeration_type:
1464  return lowerTypeEnum(cast<DICompositeType>(Ty));
1465  case dwarf::DW_TAG_class_type:
1466  case dwarf::DW_TAG_structure_type:
1467  return lowerTypeClass(cast<DICompositeType>(Ty));
1468  case dwarf::DW_TAG_union_type:
1469  return lowerTypeUnion(cast<DICompositeType>(Ty));
1470  case dwarf::DW_TAG_unspecified_type:
1471  if (Ty->getName() == "decltype(nullptr)")
1472  return TypeIndex::NullptrT();
1473  return TypeIndex::None();
1474  default:
1475  // Use the null type index.
1476  return TypeIndex();
1477  }
1478 }
1479 
1480 TypeIndex CodeViewDebug::lowerTypeAlias(const DIDerivedType *Ty) {
1481  DITypeRef UnderlyingTypeRef = Ty->getBaseType();
1482  TypeIndex UnderlyingTypeIndex = getTypeIndex(UnderlyingTypeRef);
1483  StringRef TypeName = Ty->getName();
1484 
1485  addToUDTs(Ty);
1486 
1487  if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::Int32Long) &&
1488  TypeName == "HRESULT")
1489  return TypeIndex(SimpleTypeKind::HResult);
1490  if (UnderlyingTypeIndex == TypeIndex(SimpleTypeKind::UInt16Short) &&
1491  TypeName == "wchar_t")
1492  return TypeIndex(SimpleTypeKind::WideCharacter);
1493 
1494  return UnderlyingTypeIndex;
1495 }
1496 
1497 TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) {
1498  DITypeRef ElementTypeRef = Ty->getBaseType();
1499  TypeIndex ElementTypeIndex = getTypeIndex(ElementTypeRef);
1500  // IndexType is size_t, which depends on the bitness of the target.
1501  TypeIndex IndexType = getPointerSizeInBytes() == 8
1502  ? TypeIndex(SimpleTypeKind::UInt64Quad)
1503  : TypeIndex(SimpleTypeKind::UInt32Long);
1504 
1505  uint64_t ElementSize = getBaseTypeSize(ElementTypeRef) / 8;
1506 
1507  // Add subranges to array type.
1508  DINodeArray Elements = Ty->getElements();
1509  for (int i = Elements.size() - 1; i >= 0; --i) {
1510  const DINode *Element = Elements[i];
1511  assert(Element->getTag() == dwarf::DW_TAG_subrange_type);
1512 
1513  const DISubrange *Subrange = cast<DISubrange>(Element);
1514  assert(Subrange->getLowerBound() == 0 &&
1515  "codeview doesn't support subranges with lower bounds");
1516  int64_t Count = -1;
1517  if (auto *CI = Subrange->getCount().dyn_cast<ConstantInt*>())
1518  Count = CI->getSExtValue();
1519 
1520  // Forward declarations of arrays without a size and VLAs use a count of -1.
1521  // Emit a count of zero in these cases to match what MSVC does for arrays
1522  // without a size. MSVC doesn't support VLAs, so it's not clear what we
1523  // should do for them even if we could distinguish them.
1524  if (Count == -1)
1525  Count = 0;
1526 
1527  // Update the element size and element type index for subsequent subranges.
1528  ElementSize *= Count;
1529 
1530  // If this is the outermost array, use the size from the array. It will be
1531  // more accurate if we had a VLA or an incomplete element type size.
1532  uint64_t ArraySize =
1533  (i == 0 && ElementSize == 0) ? Ty->getSizeInBits() / 8 : ElementSize;
1534 
1535  StringRef Name = (i == 0) ? Ty->getName() : "";
1536  ArrayRecord AR(ElementTypeIndex, IndexType, ArraySize, Name);
1537  ElementTypeIndex = TypeTable.writeLeafType(AR);
1538  }
1539 
1540  return ElementTypeIndex;
1541 }
1542 
1543 TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) {
1544  TypeIndex Index;
1546  uint32_t ByteSize;
1547 
1548  Kind = static_cast<dwarf::TypeKind>(Ty->getEncoding());
1549  ByteSize = Ty->getSizeInBits() / 8;
1550 
1552  switch (Kind) {
1553  case dwarf::DW_ATE_address:
1554  // FIXME: Translate
1555  break;
1556  case dwarf::DW_ATE_boolean:
1557  switch (ByteSize) {
1558  case 1: STK = SimpleTypeKind::Boolean8; break;
1559  case 2: STK = SimpleTypeKind::Boolean16; break;
1560  case 4: STK = SimpleTypeKind::Boolean32; break;
1561  case 8: STK = SimpleTypeKind::Boolean64; break;
1562  case 16: STK = SimpleTypeKind::Boolean128; break;
1563  }
1564  break;
1565  case dwarf::DW_ATE_complex_float:
1566  switch (ByteSize) {
1567  case 2: STK = SimpleTypeKind::Complex16; break;
1568  case 4: STK = SimpleTypeKind::Complex32; break;
1569  case 8: STK = SimpleTypeKind::Complex64; break;
1570  case 10: STK = SimpleTypeKind::Complex80; break;
1571  case 16: STK = SimpleTypeKind::Complex128; break;
1572  }
1573  break;
1574  case dwarf::DW_ATE_float:
1575  switch (ByteSize) {
1576  case 2: STK = SimpleTypeKind::Float16; break;
1577  case 4: STK = SimpleTypeKind::Float32; break;
1578  case 6: STK = SimpleTypeKind::Float48; break;
1579  case 8: STK = SimpleTypeKind::Float64; break;
1580  case 10: STK = SimpleTypeKind::Float80; break;
1581  case 16: STK = SimpleTypeKind::Float128; break;
1582  }
1583  break;
1584  case dwarf::DW_ATE_signed:
1585  switch (ByteSize) {
1586  case 1: STK = SimpleTypeKind::SignedCharacter; break;
1587  case 2: STK = SimpleTypeKind::Int16Short; break;
1588  case 4: STK = SimpleTypeKind::Int32; break;
1589  case 8: STK = SimpleTypeKind::Int64Quad; break;
1590  case 16: STK = SimpleTypeKind::Int128Oct; break;
1591  }
1592  break;
1593  case dwarf::DW_ATE_unsigned:
1594  switch (ByteSize) {
1595  case 1: STK = SimpleTypeKind::UnsignedCharacter; break;
1596  case 2: STK = SimpleTypeKind::UInt16Short; break;
1597  case 4: STK = SimpleTypeKind::UInt32; break;
1598  case 8: STK = SimpleTypeKind::UInt64Quad; break;
1599  case 16: STK = SimpleTypeKind::UInt128Oct; break;
1600  }
1601  break;
1602  case dwarf::DW_ATE_UTF:
1603  switch (ByteSize) {
1604  case 2: STK = SimpleTypeKind::Character16; break;
1605  case 4: STK = SimpleTypeKind::Character32; break;
1606  }
1607  break;
1608  case dwarf::DW_ATE_signed_char:
1609  if (ByteSize == 1)
1610  STK = SimpleTypeKind::SignedCharacter;
1611  break;
1612  case dwarf::DW_ATE_unsigned_char:
1613  if (ByteSize == 1)
1614  STK = SimpleTypeKind::UnsignedCharacter;
1615  break;
1616  default:
1617  break;
1618  }
1619 
1620  // Apply some fixups based on the source-level type name.
1621  if (STK == SimpleTypeKind::Int32 && Ty->getName() == "long int")
1622  STK = SimpleTypeKind::Int32Long;
1623  if (STK == SimpleTypeKind::UInt32 && Ty->getName() == "long unsigned int")
1624  STK = SimpleTypeKind::UInt32Long;
1625  if (STK == SimpleTypeKind::UInt16Short &&
1626  (Ty->getName() == "wchar_t" || Ty->getName() == "__wchar_t"))
1627  STK = SimpleTypeKind::WideCharacter;
1628  if ((STK == SimpleTypeKind::SignedCharacter ||
1629  STK == SimpleTypeKind::UnsignedCharacter) &&
1630  Ty->getName() == "char")
1631  STK = SimpleTypeKind::NarrowCharacter;
1632 
1633  return TypeIndex(STK);
1634 }
1635 
1636 TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty,
1637  PointerOptions PO) {
1638  TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
1639 
1640  // Pointers to simple types without any options can use SimpleTypeMode, rather
1641  // than having a dedicated pointer type record.
1642  if (PointeeTI.isSimple() && PO == PointerOptions::None &&
1643  PointeeTI.getSimpleMode() == SimpleTypeMode::Direct &&
1644  Ty->getTag() == dwarf::DW_TAG_pointer_type) {
1645  SimpleTypeMode Mode = Ty->getSizeInBits() == 64
1646  ? SimpleTypeMode::NearPointer64
1647  : SimpleTypeMode::NearPointer32;
1648  return TypeIndex(PointeeTI.getSimpleKind(), Mode);
1649  }
1650 
1651  PointerKind PK =
1652  Ty->getSizeInBits() == 64 ? PointerKind::Near64 : PointerKind::Near32;
1653  PointerMode PM = PointerMode::Pointer;
1654  switch (Ty->getTag()) {
1655  default: llvm_unreachable("not a pointer tag type");
1656  case dwarf::DW_TAG_pointer_type:
1657  PM = PointerMode::Pointer;
1658  break;
1659  case dwarf::DW_TAG_reference_type:
1660  PM = PointerMode::LValueReference;
1661  break;
1662  case dwarf::DW_TAG_rvalue_reference_type:
1663  PM = PointerMode::RValueReference;
1664  break;
1665  }
1666 
1667  if (Ty->isObjectPointer())
1668  PO |= PointerOptions::Const;
1669 
1670  PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8);
1671  return TypeTable.writeLeafType(PR);
1672 }
1673 
1675 translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags) {
1676  // SizeInBytes being zero generally implies that the member pointer type was
1677  // incomplete, which can happen if it is part of a function prototype. In this
1678  // case, use the unknown model instead of the general model.
1679  if (IsPMF) {
1680  switch (Flags & DINode::FlagPtrToMemberRep) {
1681  case 0:
1682  return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1683  : PointerToMemberRepresentation::GeneralFunction;
1684  case DINode::FlagSingleInheritance:
1685  return PointerToMemberRepresentation::SingleInheritanceFunction;
1686  case DINode::FlagMultipleInheritance:
1687  return PointerToMemberRepresentation::MultipleInheritanceFunction;
1688  case DINode::FlagVirtualInheritance:
1689  return PointerToMemberRepresentation::VirtualInheritanceFunction;
1690  }
1691  } else {
1692  switch (Flags & DINode::FlagPtrToMemberRep) {
1693  case 0:
1694  return SizeInBytes == 0 ? PointerToMemberRepresentation::Unknown
1695  : PointerToMemberRepresentation::GeneralData;
1696  case DINode::FlagSingleInheritance:
1697  return PointerToMemberRepresentation::SingleInheritanceData;
1698  case DINode::FlagMultipleInheritance:
1699  return PointerToMemberRepresentation::MultipleInheritanceData;
1700  case DINode::FlagVirtualInheritance:
1701  return PointerToMemberRepresentation::VirtualInheritanceData;
1702  }
1703  }
1704  llvm_unreachable("invalid ptr to member representation");
1705 }
1706 
1707 TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty,
1708  PointerOptions PO) {
1709  assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type);
1710  TypeIndex ClassTI = getTypeIndex(Ty->getClassType());
1711  TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType(), Ty->getClassType());
1712  PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
1713  : PointerKind::Near32;
1714  bool IsPMF = isa<DISubroutineType>(Ty->getBaseType());
1715  PointerMode PM = IsPMF ? PointerMode::PointerToMemberFunction
1716  : PointerMode::PointerToDataMember;
1717 
1718  assert(Ty->getSizeInBits() / 8 <= 0xff && "pointer size too big");
1719  uint8_t SizeInBytes = Ty->getSizeInBits() / 8;
1720  MemberPointerInfo MPI(
1721  ClassTI, translatePtrToMemberRep(SizeInBytes, IsPMF, Ty->getFlags()));
1722  PointerRecord PR(PointeeTI, PK, PM, PO, SizeInBytes, MPI);
1723  return TypeTable.writeLeafType(PR);
1724 }
1725 
1726 /// Given a DWARF calling convention, get the CodeView equivalent. If we don't
1727 /// have a translation, use the NearC convention.
1729  switch (DwarfCC) {
1730  case dwarf::DW_CC_normal: return CallingConvention::NearC;
1731  case dwarf::DW_CC_BORLAND_msfastcall: return CallingConvention::NearFast;
1732  case dwarf::DW_CC_BORLAND_thiscall: return CallingConvention::ThisCall;
1733  case dwarf::DW_CC_BORLAND_stdcall: return CallingConvention::NearStdCall;
1734  case dwarf::DW_CC_BORLAND_pascal: return CallingConvention::NearPascal;
1735  case dwarf::DW_CC_LLVM_vectorcall: return CallingConvention::NearVector;
1736  }
1737  return CallingConvention::NearC;
1738 }
1739 
1740 TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) {
1743  bool IsModifier = true;
1744  const DIType *BaseTy = Ty;
1745  while (IsModifier && BaseTy) {
1746  // FIXME: Need to add DWARF tags for __unaligned and _Atomic
1747  switch (BaseTy->getTag()) {
1748  case dwarf::DW_TAG_const_type:
1749  Mods |= ModifierOptions::Const;
1750  PO |= PointerOptions::Const;
1751  break;
1752  case dwarf::DW_TAG_volatile_type:
1753  Mods |= ModifierOptions::Volatile;
1754  PO |= PointerOptions::Volatile;
1755  break;
1756  case dwarf::DW_TAG_restrict_type:
1757  // Only pointer types be marked with __restrict. There is no known flag
1758  // for __restrict in LF_MODIFIER records.
1759  PO |= PointerOptions::Restrict;
1760  break;
1761  default:
1762  IsModifier = false;
1763  break;
1764  }
1765  if (IsModifier)
1766  BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
1767  }
1768 
1769  // Check if the inner type will use an LF_POINTER record. If so, the
1770  // qualifiers will go in the LF_POINTER record. This comes up for types like
1771  // 'int *const' and 'int *__restrict', not the more common cases like 'const
1772  // char *'.
1773  if (BaseTy) {
1774  switch (BaseTy->getTag()) {
1775  case dwarf::DW_TAG_pointer_type:
1776  case dwarf::DW_TAG_reference_type:
1777  case dwarf::DW_TAG_rvalue_reference_type:
1778  return lowerTypePointer(cast<DIDerivedType>(BaseTy), PO);
1779  case dwarf::DW_TAG_ptr_to_member_type:
1780  return lowerTypeMemberPointer(cast<DIDerivedType>(BaseTy), PO);
1781  default:
1782  break;
1783  }
1784  }
1785 
1786  TypeIndex ModifiedTI = getTypeIndex(BaseTy);
1787 
1788  // Return the base type index if there aren't any modifiers. For example, the
1789  // metadata could contain restrict wrappers around non-pointer types.
1790  if (Mods == ModifierOptions::None)
1791  return ModifiedTI;
1792 
1793  ModifierRecord MR(ModifiedTI, Mods);
1794  return TypeTable.writeLeafType(MR);
1795 }
1796 
1797 TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) {
1798  SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
1799  for (DITypeRef ArgTypeRef : Ty->getTypeArray())
1800  ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
1801 
1802  // MSVC uses type none for variadic argument.
1803  if (ReturnAndArgTypeIndices.size() > 1 &&
1804  ReturnAndArgTypeIndices.back() == TypeIndex::Void()) {
1805  ReturnAndArgTypeIndices.back() = TypeIndex::None();
1806  }
1807  TypeIndex ReturnTypeIndex = TypeIndex::Void();
1808  ArrayRef<TypeIndex> ArgTypeIndices = None;
1809  if (!ReturnAndArgTypeIndices.empty()) {
1810  auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
1811  ReturnTypeIndex = ReturnAndArgTypesRef.front();
1812  ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
1813  }
1814 
1815  ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1816  TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec);
1817 
1819 
1821  ProcedureRecord Procedure(ReturnTypeIndex, CC, FO, ArgTypeIndices.size(),
1822  ArgListIndex);
1823  return TypeTable.writeLeafType(Procedure);
1824 }
1825 
1826 TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty,
1827  const DIType *ClassTy,
1828  int ThisAdjustment,
1829  bool IsStaticMethod,
1830  FunctionOptions FO) {
1831  // Lower the containing class type.
1832  TypeIndex ClassType = getTypeIndex(ClassTy);
1833 
1834  DITypeRefArray ReturnAndArgs = Ty->getTypeArray();
1835 
1836  unsigned Index = 0;
1837  SmallVector<TypeIndex, 8> ArgTypeIndices;
1838  TypeIndex ReturnTypeIndex = TypeIndex::Void();
1839  if (ReturnAndArgs.size() > Index) {
1840  ReturnTypeIndex = getTypeIndex(ReturnAndArgs[Index++]);
1841  }
1842 
1843  // If the first argument is a pointer type and this isn't a static method,
1844  // treat it as the special 'this' parameter, which is encoded separately from
1845  // the arguments.
1846  TypeIndex ThisTypeIndex;
1847  if (!IsStaticMethod && ReturnAndArgs.size() > Index) {
1848  if (const DIDerivedType *PtrTy =
1849  dyn_cast_or_null<DIDerivedType>(ReturnAndArgs[Index].resolve())) {
1850  if (PtrTy->getTag() == dwarf::DW_TAG_pointer_type) {
1851  ThisTypeIndex = getTypeIndexForThisPtr(PtrTy, Ty);
1852  Index++;
1853  }
1854  }
1855  }
1856 
1857  while (Index < ReturnAndArgs.size())
1858  ArgTypeIndices.push_back(getTypeIndex(ReturnAndArgs[Index++]));
1859 
1860  // MSVC uses type none for variadic argument.
1861  if (!ArgTypeIndices.empty() && ArgTypeIndices.back() == TypeIndex::Void())
1862  ArgTypeIndices.back() = TypeIndex::None();
1863 
1864  ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
1865  TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec);
1866 
1868 
1869  MemberFunctionRecord MFR(ReturnTypeIndex, ClassType, ThisTypeIndex, CC, FO,
1870  ArgTypeIndices.size(), ArgListIndex, ThisAdjustment);
1871  return TypeTable.writeLeafType(MFR);
1872 }
1873 
1874 TypeIndex CodeViewDebug::lowerTypeVFTableShape(const DIDerivedType *Ty) {
1875  unsigned VSlotCount =
1876  Ty->getSizeInBits() / (8 * Asm->MAI->getCodePointerSize());
1877  SmallVector<VFTableSlotKind, 4> Slots(VSlotCount, VFTableSlotKind::Near);
1878 
1879  VFTableShapeRecord VFTSR(Slots);
1880  return TypeTable.writeLeafType(VFTSR);
1881 }
1882 
1883 static MemberAccess translateAccessFlags(unsigned RecordTag, unsigned Flags) {
1884  switch (Flags & DINode::FlagAccessibility) {
1885  case DINode::FlagPrivate: return MemberAccess::Private;
1886  case DINode::FlagPublic: return MemberAccess::Public;
1887  case DINode::FlagProtected: return MemberAccess::Protected;
1888  case 0:
1889  // If there was no explicit access control, provide the default for the tag.
1890  return RecordTag == dwarf::DW_TAG_class_type ? MemberAccess::Private
1891  : MemberAccess::Public;
1892  }
1893  llvm_unreachable("access flags are exclusive");
1894 }
1895 
1897  if (SP->isArtificial())
1898  return MethodOptions::CompilerGenerated;
1899 
1900  // FIXME: Handle other MethodOptions.
1901 
1902  return MethodOptions::None;
1903 }
1904 
1906  bool Introduced) {
1907  if (SP->getFlags() & DINode::FlagStaticMember)
1908  return MethodKind::Static;
1909 
1910  switch (SP->getVirtuality()) {
1911  case dwarf::DW_VIRTUALITY_none:
1912  break;
1913  case dwarf::DW_VIRTUALITY_virtual:
1914  return Introduced ? MethodKind::IntroducingVirtual : MethodKind::Virtual;
1915  case dwarf::DW_VIRTUALITY_pure_virtual:
1916  return Introduced ? MethodKind::PureIntroducingVirtual
1917  : MethodKind::PureVirtual;
1918  default:
1919  llvm_unreachable("unhandled virtuality case");
1920  }
1921 
1922  return MethodKind::Vanilla;
1923 }
1924 
1926  switch (Ty->getTag()) {
1927  case dwarf::DW_TAG_class_type: return TypeRecordKind::Class;
1928  case dwarf::DW_TAG_structure_type: return TypeRecordKind::Struct;
1929  }
1930  llvm_unreachable("unexpected tag");
1931 }
1932 
1933 /// Return ClassOptions that should be present on both the forward declaration
1934 /// and the defintion of a tag type.
1937 
1938  // MSVC always sets this flag, even for local types. Clang doesn't always
1939  // appear to give every type a linkage name, which may be problematic for us.
1940  // FIXME: Investigate the consequences of not following them here.
1941  if (!Ty->getIdentifier().empty())
1942  CO |= ClassOptions::HasUniqueName;
1943 
1944  // Put the Nested flag on a type if it appears immediately inside a tag type.
1945  // Do not walk the scope chain. Do not attempt to compute ContainsNestedClass
1946  // here. That flag is only set on definitions, and not forward declarations.
1947  const DIScope *ImmediateScope = Ty->getScope().resolve();
1948  if (ImmediateScope && isa<DICompositeType>(ImmediateScope))
1949  CO |= ClassOptions::Nested;
1950 
1951  // Put the Scoped flag on function-local types. MSVC puts this flag for enum
1952  // type only when it has an immediate function scope. Clang never puts enums
1953  // inside DILexicalBlock scopes. Enum types, as generated by clang, are
1954  // always in function, class, or file scopes.
1955  if (Ty->getTag() == dwarf::DW_TAG_enumeration_type) {
1956  if (ImmediateScope && isa<DISubprogram>(ImmediateScope))
1957  CO |= ClassOptions::Scoped;
1958  } else {
1959  for (const DIScope *Scope = ImmediateScope; Scope != nullptr;
1960  Scope = Scope->getScope().resolve()) {
1961  if (isa<DISubprogram>(Scope)) {
1962  CO |= ClassOptions::Scoped;
1963  break;
1964  }
1965  }
1966  }
1967 
1968  return CO;
1969 }
1970 
1971 void CodeViewDebug::addUDTSrcLine(const DIType *Ty, TypeIndex TI) {
1972  switch (Ty->getTag()) {
1973  case dwarf::DW_TAG_class_type:
1974  case dwarf::DW_TAG_structure_type:
1975  case dwarf::DW_TAG_union_type:
1976  case dwarf::DW_TAG_enumeration_type:
1977  break;
1978  default:
1979  return;
1980  }
1981 
1982  if (const auto *File = Ty->getFile()) {
1983  StringIdRecord SIDR(TypeIndex(0x0), getFullFilepath(File));
1984  TypeIndex SIDI = TypeTable.writeLeafType(SIDR);
1985 
1986  UdtSourceLineRecord USLR(TI, SIDI, Ty->getLine());
1987  TypeTable.writeLeafType(USLR);
1988  }
1989 }
1990 
1991 TypeIndex CodeViewDebug::lowerTypeEnum(const DICompositeType *Ty) {
1993  TypeIndex FTI;
1994  unsigned EnumeratorCount = 0;
1995 
1996  if (Ty->isForwardDecl()) {
1997  CO |= ClassOptions::ForwardReference;
1998  } else {
1999  ContinuationRecordBuilder ContinuationBuilder;
2000  ContinuationBuilder.begin(ContinuationRecordKind::FieldList);
2001  for (const DINode *Element : Ty->getElements()) {
2002  // We assume that the frontend provides all members in source declaration
2003  // order, which is what MSVC does.
2004  if (auto *Enumerator = dyn_cast_or_null<DIEnumerator>(Element)) {
2005  EnumeratorRecord ER(MemberAccess::Public,
2006  APSInt::getUnsigned(Enumerator->getValue()),
2007  Enumerator->getName());
2008  ContinuationBuilder.writeMemberType(ER);
2009  EnumeratorCount++;
2010  }
2011  }
2012  FTI = TypeTable.insertRecord(ContinuationBuilder);
2013  }
2014 
2015  std::string FullName = getFullyQualifiedName(Ty);
2016 
2017  EnumRecord ER(EnumeratorCount, CO, FTI, FullName, Ty->getIdentifier(),
2018  getTypeIndex(Ty->getBaseType()));
2019  TypeIndex EnumTI = TypeTable.writeLeafType(ER);
2020 
2021  addUDTSrcLine(Ty, EnumTI);
2022 
2023  return EnumTI;
2024 }
2025 
2026 //===----------------------------------------------------------------------===//
2027 // ClassInfo
2028 //===----------------------------------------------------------------------===//
2029 
2031  struct MemberInfo {
2033  uint64_t BaseOffset;
2034  };
2035  // [MemberInfo]
2036  using MemberList = std::vector<MemberInfo>;
2037 
2039  // MethodName -> MethodsList
2041 
2042  /// Base classes.
2043  std::vector<const DIDerivedType *> Inheritance;
2044 
2045  /// Direct members.
2047  // Direct overloaded methods gathered by name.
2049 
2051 
2052  std::vector<const DIType *> NestedTypes;
2053 };
2054 
2055 void CodeViewDebug::clear() {
2056  assert(CurFn == nullptr);
2057  FileIdMap.clear();
2058  FnDebugInfo.clear();
2059  FileToFilepathMap.clear();
2060  LocalUDTs.clear();
2061  GlobalUDTs.clear();
2062  TypeIndices.clear();
2063  CompleteTypeIndices.clear();
2064  ScopeGlobals.clear();
2065 }
2066 
2067 void CodeViewDebug::collectMemberInfo(ClassInfo &Info,
2068  const DIDerivedType *DDTy) {
2069  if (!DDTy->getName().empty()) {
2070  Info.Members.push_back({DDTy, 0});
2071  return;
2072  }
2073 
2074  // An unnamed member may represent a nested struct or union. Attempt to
2075  // interpret the unnamed member as a DICompositeType possibly wrapped in
2076  // qualifier types. Add all the indirect fields to the current record if that
2077  // succeeds, and drop the member if that fails.
2078  assert((DDTy->getOffsetInBits() % 8) == 0 && "Unnamed bitfield member!");
2079  uint64_t Offset = DDTy->getOffsetInBits();
2080  const DIType *Ty = DDTy->getBaseType().resolve();
2081  bool FullyResolved = false;
2082  while (!FullyResolved) {
2083  switch (Ty->getTag()) {
2084  case dwarf::DW_TAG_const_type:
2085  case dwarf::DW_TAG_volatile_type:
2086  // FIXME: we should apply the qualifier types to the indirect fields
2087  // rather than dropping them.
2088  Ty = cast<DIDerivedType>(Ty)->getBaseType().resolve();
2089  break;
2090  default:
2091  FullyResolved = true;
2092  break;
2093  }
2094  }
2095 
2096  const DICompositeType *DCTy = dyn_cast<DICompositeType>(Ty);
2097  if (!DCTy)
2098  return;
2099 
2100  ClassInfo NestedInfo = collectClassInfo(DCTy);
2101  for (const ClassInfo::MemberInfo &IndirectField : NestedInfo.Members)
2102  Info.Members.push_back(
2103  {IndirectField.MemberTypeNode, IndirectField.BaseOffset + Offset});
2104 }
2105 
2106 ClassInfo CodeViewDebug::collectClassInfo(const DICompositeType *Ty) {
2107  ClassInfo Info;
2108  // Add elements to structure type.
2109  DINodeArray Elements = Ty->getElements();
2110  for (auto *Element : Elements) {
2111  // We assume that the frontend provides all members in source declaration
2112  // order, which is what MSVC does.
2113  if (!Element)
2114  continue;
2115  if (auto *SP = dyn_cast<DISubprogram>(Element)) {
2116  Info.Methods[SP->getRawName()].push_back(SP);
2117  } else if (auto *DDTy = dyn_cast<DIDerivedType>(Element)) {
2118  if (DDTy->getTag() == dwarf::DW_TAG_member) {
2119  collectMemberInfo(Info, DDTy);
2120  } else if (DDTy->getTag() == dwarf::DW_TAG_inheritance) {
2121  Info.Inheritance.push_back(DDTy);
2122  } else if (DDTy->getTag() == dwarf::DW_TAG_pointer_type &&
2123  DDTy->getName() == "__vtbl_ptr_type") {
2124  Info.VShapeTI = getTypeIndex(DDTy);
2125  } else if (DDTy->getTag() == dwarf::DW_TAG_typedef) {
2126  Info.NestedTypes.push_back(DDTy);
2127  } else if (DDTy->getTag() == dwarf::DW_TAG_friend) {
2128  // Ignore friend members. It appears that MSVC emitted info about
2129  // friends in the past, but modern versions do not.
2130  }
2131  } else if (auto *Composite = dyn_cast<DICompositeType>(Element)) {
2132  Info.NestedTypes.push_back(Composite);
2133  }
2134  // Skip other unrecognized kinds of elements.
2135  }
2136  return Info;
2137 }
2138 
2140  // This routine is used by lowerTypeClass and lowerTypeUnion to determine
2141  // if a complete type should be emitted instead of a forward reference.
2142  return Ty->getName().empty() && Ty->getIdentifier().empty() &&
2143  !Ty->isForwardDecl();
2144 }
2145 
2146 TypeIndex CodeViewDebug::lowerTypeClass(const DICompositeType *Ty) {
2147  // Emit the complete type for unnamed structs. C++ classes with methods
2148  // which have a circular reference back to the class type are expected to
2149  // be named by the front-end and should not be "unnamed". C unnamed
2150  // structs should not have circular references.
2152  // If this unnamed complete type is already in the process of being defined
2153  // then the description of the type is malformed and cannot be emitted
2154  // into CodeView correctly so report a fatal error.
2155  auto I = CompleteTypeIndices.find(Ty);
2156  if (I != CompleteTypeIndices.end() && I->second == TypeIndex())
2157  report_fatal_error("cannot debug circular reference to unnamed type");
2158  return getCompleteTypeIndex(Ty);
2159  }
2160 
2161  // First, construct the forward decl. Don't look into Ty to compute the
2162  // forward decl options, since it might not be available in all TUs.
2164  ClassOptions CO =
2165  ClassOptions::ForwardReference | getCommonClassOptions(Ty);
2166  std::string FullName = getFullyQualifiedName(Ty);
2167  ClassRecord CR(Kind, 0, CO, TypeIndex(), TypeIndex(), TypeIndex(), 0,
2168  FullName, Ty->getIdentifier());
2169  TypeIndex FwdDeclTI = TypeTable.writeLeafType(CR);
2170  if (!Ty->isForwardDecl())
2171  DeferredCompleteTypes.push_back(Ty);
2172  return FwdDeclTI;
2173 }
2174 
2175 TypeIndex CodeViewDebug::lowerCompleteTypeClass(const DICompositeType *Ty) {
2176  // Construct the field list and complete type record.
2179  TypeIndex FieldTI;
2180  TypeIndex VShapeTI;
2181  unsigned FieldCount;
2182  bool ContainsNestedClass;
2183  std::tie(FieldTI, VShapeTI, FieldCount, ContainsNestedClass) =
2184  lowerRecordFieldList(Ty);
2185 
2186  if (ContainsNestedClass)
2187  CO |= ClassOptions::ContainsNestedClass;
2188 
2189  std::string FullName = getFullyQualifiedName(Ty);
2190 
2191  uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
2192 
2193  ClassRecord CR(Kind, FieldCount, CO, FieldTI, TypeIndex(), VShapeTI,
2194  SizeInBytes, FullName, Ty->getIdentifier());
2195  TypeIndex ClassTI = TypeTable.writeLeafType(CR);
2196 
2197  addUDTSrcLine(Ty, ClassTI);
2198 
2199  addToUDTs(Ty);
2200 
2201  return ClassTI;
2202 }
2203 
2204 TypeIndex CodeViewDebug::lowerTypeUnion(const DICompositeType *Ty) {
2205  // Emit the complete type for unnamed unions.
2207  return getCompleteTypeIndex(Ty);
2208 
2209  ClassOptions CO =
2210  ClassOptions::ForwardReference | getCommonClassOptions(Ty);
2211  std::string FullName = getFullyQualifiedName(Ty);
2212  UnionRecord UR(0, CO, TypeIndex(), 0, FullName, Ty->getIdentifier());
2213  TypeIndex FwdDeclTI = TypeTable.writeLeafType(UR);
2214  if (!Ty->isForwardDecl())
2215  DeferredCompleteTypes.push_back(Ty);
2216  return FwdDeclTI;
2217 }
2218 
2219 TypeIndex CodeViewDebug::lowerCompleteTypeUnion(const DICompositeType *Ty) {
2220  ClassOptions CO = ClassOptions::Sealed | getCommonClassOptions(Ty);
2221  TypeIndex FieldTI;
2222  unsigned FieldCount;
2223  bool ContainsNestedClass;
2224  std::tie(FieldTI, std::ignore, FieldCount, ContainsNestedClass) =
2225  lowerRecordFieldList(Ty);
2226 
2227  if (ContainsNestedClass)
2228  CO |= ClassOptions::ContainsNestedClass;
2229 
2230  uint64_t SizeInBytes = Ty->getSizeInBits() / 8;
2231  std::string FullName = getFullyQualifiedName(Ty);
2232 
2233  UnionRecord UR(FieldCount, CO, FieldTI, SizeInBytes, FullName,
2234  Ty->getIdentifier());
2235  TypeIndex UnionTI = TypeTable.writeLeafType(UR);
2236 
2237  addUDTSrcLine(Ty, UnionTI);
2238 
2239  addToUDTs(Ty);
2240 
2241  return UnionTI;
2242 }
2243 
2244 std::tuple<TypeIndex, TypeIndex, unsigned, bool>
2245 CodeViewDebug::lowerRecordFieldList(const DICompositeType *Ty) {
2246  // Manually count members. MSVC appears to count everything that generates a
2247  // field list record. Each individual overload in a method overload group
2248  // contributes to this count, even though the overload group is a single field
2249  // list record.
2250  unsigned MemberCount = 0;
2251  ClassInfo Info = collectClassInfo(Ty);
2252  ContinuationRecordBuilder ContinuationBuilder;
2253  ContinuationBuilder.begin(ContinuationRecordKind::FieldList);
2254 
2255  // Create base classes.
2256  for (const DIDerivedType *I : Info.Inheritance) {
2257  if (I->getFlags() & DINode::FlagVirtual) {
2258  // Virtual base.
2259  unsigned VBPtrOffset = I->getVBPtrOffset();
2260  // FIXME: Despite the accessor name, the offset is really in bytes.
2261  unsigned VBTableIndex = I->getOffsetInBits() / 4;
2262  auto RecordKind = (I->getFlags() & DINode::FlagIndirectVirtualBase) == DINode::FlagIndirectVirtualBase
2263  ? TypeRecordKind::IndirectVirtualBaseClass
2264  : TypeRecordKind::VirtualBaseClass;
2266  RecordKind, translateAccessFlags(Ty->getTag(), I->getFlags()),
2267  getTypeIndex(I->getBaseType()), getVBPTypeIndex(), VBPtrOffset,
2268  VBTableIndex);
2269 
2270  ContinuationBuilder.writeMemberType(VBCR);
2271  MemberCount++;
2272  } else {
2273  assert(I->getOffsetInBits() % 8 == 0 &&
2274  "bases must be on byte boundaries");
2276  getTypeIndex(I->getBaseType()),
2277  I->getOffsetInBits() / 8);
2278  ContinuationBuilder.writeMemberType(BCR);
2279  MemberCount++;
2280  }
2281  }
2282 
2283  // Create members.
2284  for (ClassInfo::MemberInfo &MemberInfo : Info.Members) {
2285  const DIDerivedType *Member = MemberInfo.MemberTypeNode;
2286  TypeIndex MemberBaseType = getTypeIndex(Member->getBaseType());
2287  StringRef MemberName = Member->getName();
2288  MemberAccess Access =
2289  translateAccessFlags(Ty->getTag(), Member->getFlags());
2290 
2291  if (Member->isStaticMember()) {
2292  StaticDataMemberRecord SDMR(Access, MemberBaseType, MemberName);
2293  ContinuationBuilder.writeMemberType(SDMR);
2294  MemberCount++;
2295  continue;
2296  }
2297 
2298  // Virtual function pointer member.
2299  if ((Member->getFlags() & DINode::FlagArtificial) &&
2300  Member->getName().startswith("_vptr$")) {
2301  VFPtrRecord VFPR(getTypeIndex(Member->getBaseType()));
2302  ContinuationBuilder.writeMemberType(VFPR);
2303  MemberCount++;
2304  continue;
2305  }
2306 
2307  // Data member.
2308  uint64_t MemberOffsetInBits =
2309  Member->getOffsetInBits() + MemberInfo.BaseOffset;
2310  if (Member->isBitField()) {
2311  uint64_t StartBitOffset = MemberOffsetInBits;
2312  if (const auto *CI =
2313  dyn_cast_or_null<ConstantInt>(Member->getStorageOffsetInBits())) {
2314  MemberOffsetInBits = CI->getZExtValue() + MemberInfo.BaseOffset;
2315  }
2316  StartBitOffset -= MemberOffsetInBits;
2317  BitFieldRecord BFR(MemberBaseType, Member->getSizeInBits(),
2318  StartBitOffset);
2319  MemberBaseType = TypeTable.writeLeafType(BFR);
2320  }
2321  uint64_t MemberOffsetInBytes = MemberOffsetInBits / 8;
2322  DataMemberRecord DMR(Access, MemberBaseType, MemberOffsetInBytes,
2323  MemberName);
2324  ContinuationBuilder.writeMemberType(DMR);
2325  MemberCount++;
2326  }
2327 
2328  // Create methods
2329  for (auto &MethodItr : Info.Methods) {
2330  StringRef Name = MethodItr.first->getString();
2331 
2332  std::vector<OneMethodRecord> Methods;
2333  for (const DISubprogram *SP : MethodItr.second) {
2334  TypeIndex MethodType = getMemberFunctionType(SP, Ty);
2335  bool Introduced = SP->getFlags() & DINode::FlagIntroducedVirtual;
2336 
2337  unsigned VFTableOffset = -1;
2338  if (Introduced)
2339  VFTableOffset = SP->getVirtualIndex() * getPointerSizeInBytes();
2340 
2341  Methods.push_back(OneMethodRecord(
2342  MethodType, translateAccessFlags(Ty->getTag(), SP->getFlags()),
2343  translateMethodKindFlags(SP, Introduced),
2344  translateMethodOptionFlags(SP), VFTableOffset, Name));
2345  MemberCount++;
2346  }
2347  assert(!Methods.empty() && "Empty methods map entry");
2348  if (Methods.size() == 1)
2349  ContinuationBuilder.writeMemberType(Methods[0]);
2350  else {
2351  // FIXME: Make this use its own ContinuationBuilder so that
2352  // MethodOverloadList can be split correctly.
2353  MethodOverloadListRecord MOLR(Methods);
2354  TypeIndex MethodList = TypeTable.writeLeafType(MOLR);
2355 
2356  OverloadedMethodRecord OMR(Methods.size(), MethodList, Name);
2357  ContinuationBuilder.writeMemberType(OMR);
2358  }
2359  }
2360 
2361  // Create nested classes.
2362  for (const DIType *Nested : Info.NestedTypes) {
2363  NestedTypeRecord R(getTypeIndex(DITypeRef(Nested)), Nested->getName());
2364  ContinuationBuilder.writeMemberType(R);
2365  MemberCount++;
2366  }
2367 
2368  TypeIndex FieldTI = TypeTable.insertRecord(ContinuationBuilder);
2369  return std::make_tuple(FieldTI, Info.VShapeTI, MemberCount,
2370  !Info.NestedTypes.empty());
2371 }
2372 
2373 TypeIndex CodeViewDebug::getVBPTypeIndex() {
2374  if (!VBPType.getIndex()) {
2375  // Make a 'const int *' type.
2376  ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);
2377  TypeIndex ModifiedTI = TypeTable.writeLeafType(MR);
2378 
2379  PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
2380  : PointerKind::Near32;
2381  PointerMode PM = PointerMode::Pointer;
2383  PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes());
2384  VBPType = TypeTable.writeLeafType(PR);
2385  }
2386 
2387  return VBPType;
2388 }
2389 
2390 TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
2391  const DIType *Ty = TypeRef.resolve();
2392  const DIType *ClassTy = ClassTyRef.resolve();
2393 
2394  // The null DIType is the void type. Don't try to hash it.
2395  if (!Ty)
2396  return TypeIndex::Void();
2397 
2398  // Check if we've already translated this type. Don't try to do a
2399  // get-or-create style insertion that caches the hash lookup across the
2400  // lowerType call. It will update the TypeIndices map.
2401  auto I = TypeIndices.find({Ty, ClassTy});
2402  if (I != TypeIndices.end())
2403  return I->second;
2404 
2405  TypeLoweringScope S(*this);
2406  TypeIndex TI = lowerType(Ty, ClassTy);
2407  return recordTypeIndexForDINode(Ty, TI, ClassTy);
2408 }
2409 
2411 CodeViewDebug::getTypeIndexForThisPtr(const DIDerivedType *PtrTy,
2412  const DISubroutineType *SubroutineTy) {
2413  assert(PtrTy->getTag() == dwarf::DW_TAG_pointer_type &&
2414  "this type must be a pointer type");
2415 
2417  if (SubroutineTy->getFlags() & DINode::DIFlags::FlagLValueReference)
2418  Options = PointerOptions::LValueRefThisPointer;
2419  else if (SubroutineTy->getFlags() & DINode::DIFlags::FlagRValueReference)
2420  Options = PointerOptions::RValueRefThisPointer;
2421 
2422  // Check if we've already translated this type. If there is no ref qualifier
2423  // on the function then we look up this pointer type with no associated class
2424  // so that the TypeIndex for the this pointer can be shared with the type
2425  // index for other pointers to this class type. If there is a ref qualifier
2426  // then we lookup the pointer using the subroutine as the parent type.
2427  auto I = TypeIndices.find({PtrTy, SubroutineTy});
2428  if (I != TypeIndices.end())
2429  return I->second;
2430 
2431  TypeLoweringScope S(*this);
2432  TypeIndex TI = lowerTypePointer(PtrTy, Options);
2433  return recordTypeIndexForDINode(PtrTy, TI, SubroutineTy);
2434 }
2435 
2436 TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(DITypeRef TypeRef) {
2437  DIType *Ty = TypeRef.resolve();
2438  PointerRecord PR(getTypeIndex(Ty),
2439  getPointerSizeInBytes() == 8 ? PointerKind::Near64
2440  : PointerKind::Near32,
2441  PointerMode::LValueReference, PointerOptions::None,
2442  Ty->getSizeInBits() / 8);
2443  return TypeTable.writeLeafType(PR);
2444 }
2445 
2446 TypeIndex CodeViewDebug::getCompleteTypeIndex(DITypeRef TypeRef) {
2447  const DIType *Ty = TypeRef.resolve();
2448 
2449  // The null DIType is the void type. Don't try to hash it.
2450  if (!Ty)
2451  return TypeIndex::Void();
2452 
2453  // Look through typedefs when getting the complete type index. Call
2454  // getTypeIndex on the typdef to ensure that any UDTs are accumulated and are
2455  // emitted only once.
2456  if (Ty->getTag() == dwarf::DW_TAG_typedef)
2457  (void)getTypeIndex(Ty);
2458  while (Ty->getTag() == dwarf::DW_TAG_typedef)
2459  Ty = cast<DIDerivedType>(Ty)->getBaseType().resolve();
2460 
2461  // If this is a non-record type, the complete type index is the same as the
2462  // normal type index. Just call getTypeIndex.
2463  switch (Ty->getTag()) {
2464  case dwarf::DW_TAG_class_type:
2465  case dwarf::DW_TAG_structure_type:
2466  case dwarf::DW_TAG_union_type:
2467  break;
2468  default:
2469  return getTypeIndex(Ty);
2470  }
2471 
2472  // Check if we've already translated the complete record type.
2473  const auto *CTy = cast<DICompositeType>(Ty);
2474  auto InsertResult = CompleteTypeIndices.insert({CTy, TypeIndex()});
2475  if (!InsertResult.second)
2476  return InsertResult.first->second;
2477 
2478  TypeLoweringScope S(*this);
2479 
2480  // Make sure the forward declaration is emitted first. It's unclear if this
2481  // is necessary, but MSVC does it, and we should follow suit until we can show
2482  // otherwise.
2483  // We only emit a forward declaration for named types.
2484  if (!CTy->getName().empty() || !CTy->getIdentifier().empty()) {
2485  TypeIndex FwdDeclTI = getTypeIndex(CTy);
2486 
2487  // Just use the forward decl if we don't have complete type info. This
2488  // might happen if the frontend is using modules and expects the complete
2489  // definition to be emitted elsewhere.
2490  if (CTy->isForwardDecl())
2491  return FwdDeclTI;
2492  }
2493 
2494  TypeIndex TI;
2495  switch (CTy->getTag()) {
2496  case dwarf::DW_TAG_class_type:
2497  case dwarf::DW_TAG_structure_type:
2498  TI = lowerCompleteTypeClass(CTy);
2499  break;
2500  case dwarf::DW_TAG_union_type:
2501  TI = lowerCompleteTypeUnion(CTy);
2502  break;
2503  default:
2504  llvm_unreachable("not a record");
2505  }
2506 
2507  // Update the type index associated with this CompositeType. This cannot
2508  // use the 'InsertResult' iterator above because it is potentially
2509  // invalidated by map insertions which can occur while lowering the class
2510  // type above.
2511  CompleteTypeIndices[CTy] = TI;
2512  return TI;
2513 }
2514 
2515 /// Emit all the deferred complete record types. Try to do this in FIFO order,
2516 /// and do this until fixpoint, as each complete record type typically
2517 /// references
2518 /// many other record types.
2519 void CodeViewDebug::emitDeferredCompleteTypes() {
2521  while (!DeferredCompleteTypes.empty()) {
2522  std::swap(DeferredCompleteTypes, TypesToEmit);
2523  for (const DICompositeType *RecordTy : TypesToEmit)
2524  getCompleteTypeIndex(RecordTy);
2525  TypesToEmit.clear();
2526  }
2527 }
2528 
2529 void CodeViewDebug::emitLocalVariableList(const FunctionInfo &FI,
2530  ArrayRef<LocalVariable> Locals) {
2531  // Get the sorted list of parameters and emit them first.
2533  for (const LocalVariable &L : Locals)
2534  if (L.DIVar->isParameter())
2535  Params.push_back(&L);
2536  llvm::sort(Params, [](const LocalVariable *L, const LocalVariable *R) {
2537  return L->DIVar->getArg() < R->DIVar->getArg();
2538  });
2539  for (const LocalVariable *L : Params)
2540  emitLocalVariable(FI, *L);
2541 
2542  // Next emit all non-parameters in the order that we found them.
2543  for (const LocalVariable &L : Locals)
2544  if (!L.DIVar->isParameter())
2545  emitLocalVariable(FI, L);
2546 }
2547 
2548 /// Only call this on endian-specific types like ulittle16_t and little32_t, or
2549 /// structs composed of them.
2550 template <typename T>
2551 static void copyBytesForDefRange(SmallString<20> &BytePrefix,
2552  SymbolKind SymKind, const T &DefRangeHeader) {
2553  BytePrefix.resize(2 + sizeof(T));
2554  ulittle16_t SymKindLE = ulittle16_t(SymKind);
2555  memcpy(&BytePrefix[0], &SymKindLE, 2);
2556  memcpy(&BytePrefix[2], &DefRangeHeader, sizeof(T));
2557 }
2558 
2559 void CodeViewDebug::emitLocalVariable(const FunctionInfo &FI,
2560  const LocalVariable &Var) {
2561  // LocalSym record, see SymbolRecord.h for more info.
2562  MCSymbol *LocalEnd = beginSymbolRecord(SymbolKind::S_LOCAL);
2563 
2565  if (Var.DIVar->isParameter())
2566  Flags |= LocalSymFlags::IsParameter;
2567  if (Var.DefRanges.empty())
2568  Flags |= LocalSymFlags::IsOptimizedOut;
2569 
2570  OS.AddComment("TypeIndex");
2571  TypeIndex TI = Var.UseReferenceType
2572  ? getTypeIndexForReferenceTo(Var.DIVar->getType())
2573  : getCompleteTypeIndex(Var.DIVar->getType());
2574  OS.EmitIntValue(TI.getIndex(), 4);
2575  OS.AddComment("Flags");
2576  OS.EmitIntValue(static_cast<uint16_t>(Flags), 2);
2577  // Truncate the name so we won't overflow the record length field.
2578  emitNullTerminatedSymbolName(OS, Var.DIVar->getName());
2579  endSymbolRecord(LocalEnd);
2580 
2581  // Calculate the on disk prefix of the appropriate def range record. The
2582  // records and on disk formats are described in SymbolRecords.h. BytePrefix
2583  // should be big enough to hold all forms without memory allocation.
2584  SmallString<20> BytePrefix;
2585  for (const LocalVarDefRange &DefRange : Var.DefRanges) {
2586  BytePrefix.clear();
2587  if (DefRange.InMemory) {
2588  int Offset = DefRange.DataOffset;
2589  unsigned Reg = DefRange.CVRegister;
2590 
2591  // 32-bit x86 call sequences often use PUSH instructions, which disrupt
2592  // ESP-relative offsets. Use the virtual frame pointer, VFRAME or $T0,
2593  // instead. In frames without stack realignment, $T0 will be the CFA.
2594  if (RegisterId(Reg) == RegisterId::ESP) {
2595  Reg = unsigned(RegisterId::VFRAME);
2596  Offset += FI.OffsetAdjustment;
2597  }
2598 
2599  // If we can use the chosen frame pointer for the frame and this isn't a
2600  // sliced aggregate, use the smaller S_DEFRANGE_FRAMEPOINTER_REL record.
2601  // Otherwise, use S_DEFRANGE_REGISTER_REL.
2602  EncodedFramePtrReg EncFP = encodeFramePtrReg(RegisterId(Reg), TheCPU);
2603  if (!DefRange.IsSubfield && EncFP != EncodedFramePtrReg::None &&
2604  (bool(Flags & LocalSymFlags::IsParameter)
2605  ? (EncFP == FI.EncodedParamFramePtrReg)
2606  : (EncFP == FI.EncodedLocalFramePtrReg))) {
2607  little32_t FPOffset = little32_t(Offset);
2608  copyBytesForDefRange(BytePrefix, S_DEFRANGE_FRAMEPOINTER_REL, FPOffset);
2609  } else {
2610  uint16_t RegRelFlags = 0;
2611  if (DefRange.IsSubfield) {
2612  RegRelFlags = DefRangeRegisterRelSym::IsSubfieldFlag |
2613  (DefRange.StructOffset
2614  << DefRangeRegisterRelSym::OffsetInParentShift);
2615  }
2617  DRHdr.Register = Reg;
2618  DRHdr.Flags = RegRelFlags;
2619  DRHdr.BasePointerOffset = Offset;
2620  copyBytesForDefRange(BytePrefix, S_DEFRANGE_REGISTER_REL, DRHdr);
2621  }
2622  } else {
2623  assert(DefRange.DataOffset == 0 && "unexpected offset into register");
2624  if (DefRange.IsSubfield) {
2626  DRHdr.Register = DefRange.CVRegister;
2627  DRHdr.MayHaveNoName = 0;
2628  DRHdr.OffsetInParent = DefRange.StructOffset;
2629  copyBytesForDefRange(BytePrefix, S_DEFRANGE_SUBFIELD_REGISTER, DRHdr);
2630  } else {
2632  DRHdr.Register = DefRange.CVRegister;
2633  DRHdr.MayHaveNoName = 0;
2634  copyBytesForDefRange(BytePrefix, S_DEFRANGE_REGISTER, DRHdr);
2635  }
2636  }
2637  OS.EmitCVDefRangeDirective(DefRange.Ranges, BytePrefix);
2638  }
2639 }
2640 
2641 void CodeViewDebug::emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks,
2642  const FunctionInfo& FI) {
2643  for (LexicalBlock *Block : Blocks)
2644  emitLexicalBlock(*Block, FI);
2645 }
2646 
2647 /// Emit an S_BLOCK32 and S_END record pair delimiting the contents of a
2648 /// lexical block scope.
2649 void CodeViewDebug::emitLexicalBlock(const LexicalBlock &Block,
2650  const FunctionInfo& FI) {
2651  MCSymbol *RecordEnd = beginSymbolRecord(SymbolKind::S_BLOCK32);
2652  OS.AddComment("PtrParent");
2653  OS.EmitIntValue(0, 4); // PtrParent
2654  OS.AddComment("PtrEnd");
2655  OS.EmitIntValue(0, 4); // PtrEnd
2656  OS.AddComment("Code size");
2657  OS.emitAbsoluteSymbolDiff(Block.End, Block.Begin, 4); // Code Size
2658  OS.AddComment("Function section relative address");
2659  OS.EmitCOFFSecRel32(Block.Begin, /*Offset=*/0); // Func Offset
2660  OS.AddComment("Function section index");
2661  OS.EmitCOFFSectionIndex(FI.Begin); // Func Symbol
2662  OS.AddComment("Lexical block name");
2663  emitNullTerminatedSymbolName(OS, Block.Name); // Name
2664  endSymbolRecord(RecordEnd);
2665 
2666  // Emit variables local to this lexical block.
2667  emitLocalVariableList(FI, Block.Locals);
2668  emitGlobalVariableList(Block.Globals);
2669 
2670  // Emit lexical blocks contained within this block.
2671  emitLexicalBlockList(Block.Children, FI);
2672 
2673  // Close the lexical block scope.
2674  emitEndSymbolRecord(SymbolKind::S_END);
2675 }
2676 
2677 /// Convenience routine for collecting lexical block information for a list
2678 /// of lexical scopes.
2679 void CodeViewDebug::collectLexicalBlockInfo(
2684  for (LexicalScope *Scope : Scopes)
2685  collectLexicalBlockInfo(*Scope, Blocks, Locals, Globals);
2686 }
2687 
2688 /// Populate the lexical blocks and local variable lists of the parent with
2689 /// information about the specified lexical scope.
2690 void CodeViewDebug::collectLexicalBlockInfo(
2691  LexicalScope &Scope,
2692  SmallVectorImpl<LexicalBlock *> &ParentBlocks,
2693  SmallVectorImpl<LocalVariable> &ParentLocals,
2694  SmallVectorImpl<CVGlobalVariable> &ParentGlobals) {
2695  if (Scope.isAbstractScope())
2696  return;
2697 
2698  // Gather information about the lexical scope including local variables,
2699  // global variables, and address ranges.
2700  bool IgnoreScope = false;
2701  auto LI = ScopeVariables.find(&Scope);
2703  LI != ScopeVariables.end() ? &LI->second : nullptr;
2704  auto GI = ScopeGlobals.find(Scope.getScopeNode());
2706  GI != ScopeGlobals.end() ? GI->second.get() : nullptr;
2707  const DILexicalBlock *DILB = dyn_cast<DILexicalBlock>(Scope.getScopeNode());
2708  const SmallVectorImpl<InsnRange> &Ranges = Scope.getRanges();
2709 
2710  // Ignore lexical scopes which do not contain variables.
2711  if (!Locals && !Globals)
2712  IgnoreScope = true;
2713 
2714  // Ignore lexical scopes which are not lexical blocks.
2715  if (!DILB)
2716  IgnoreScope = true;
2717 
2718  // Ignore scopes which have too many address ranges to represent in the
2719  // current CodeView format or do not have a valid address range.
2720  //
2721  // For lexical scopes with multiple address ranges you may be tempted to
2722  // construct a single range covering every instruction where the block is
2723  // live and everything in between. Unfortunately, Visual Studio only
2724  // displays variables from the first matching lexical block scope. If the
2725  // first lexical block contains exception handling code or cold code which
2726  // is moved to the bottom of the routine creating a single range covering
2727  // nearly the entire routine, then it will hide all other lexical blocks
2728  // and the variables they contain.
2729  if (Ranges.size() != 1 || !getLabelAfterInsn(Ranges.front().second))
2730  IgnoreScope = true;
2731 
2732  if (IgnoreScope) {
2733  // This scope can be safely ignored and eliminating it will reduce the
2734  // size of the debug information. Be sure to collect any variable and scope
2735  // information from the this scope or any of its children and collapse them
2736  // into the parent scope.
2737  if (Locals)
2738  ParentLocals.append(Locals->begin(), Locals->end());
2739  if (Globals)
2740  ParentGlobals.append(Globals->begin(), Globals->end());
2741  collectLexicalBlockInfo(Scope.getChildren(),
2742  ParentBlocks,
2743  ParentLocals,
2744  ParentGlobals);
2745  return;
2746  }
2747 
2748  // Create a new CodeView lexical block for this lexical scope. If we've
2749  // seen this DILexicalBlock before then the scope tree is malformed and
2750  // we can handle this gracefully by not processing it a second time.
2751  auto BlockInsertion = CurFn->LexicalBlocks.insert({DILB, LexicalBlock()});
2752  if (!BlockInsertion.second)
2753  return;
2754 
2755  // Create a lexical block containing the variables and collect the the
2756  // lexical block information for the children.
2757  const InsnRange &Range = Ranges.front();
2758  assert(Range.first && Range.second);
2759  LexicalBlock &Block = BlockInsertion.first->second;
2760  Block.Begin = getLabelBeforeInsn(Range.first);
2761  Block.End = getLabelAfterInsn(Range.second);
2762  assert(Block.Begin && "missing label for scope begin");
2763  assert(Block.End && "missing label for scope end");
2764  Block.Name = DILB->getName();
2765  if (Locals)
2766  Block.Locals = std::move(*Locals);
2767  if (Globals)
2768  Block.Globals = std::move(*Globals);
2769  ParentBlocks.push_back(&Block);
2770  collectLexicalBlockInfo(Scope.getChildren(),
2771  Block.Children,
2772  Block.Locals,
2773  Block.Globals);
2774 }
2775 
2777  const Function &GV = MF->getFunction();
2778  assert(FnDebugInfo.count(&GV));
2779  assert(CurFn == FnDebugInfo[&GV].get());
2780 
2781  collectVariableInfo(GV.getSubprogram());
2782 
2783  // Build the lexical block structure to emit for this routine.
2785  collectLexicalBlockInfo(*CFS,
2786  CurFn->ChildBlocks,
2787  CurFn->Locals,
2788  CurFn->Globals);
2789 
2790  // Clear the scope and variable information from the map which will not be
2791  // valid after we have finished processing this routine. This also prepares
2792  // the map for the subsequent routine.
2793  ScopeVariables.clear();
2794 
2795  // Don't emit anything if we don't have any line tables.
2796  // Thunks are compiler-generated and probably won't have source correlation.
2797  if (!CurFn->HaveLineInfo && !GV.getSubprogram()->isThunk()) {
2798  FnDebugInfo.erase(&GV);
2799  CurFn = nullptr;
2800  return;
2801  }
2802 
2803  CurFn->Annotations = MF->getCodeViewAnnotations();
2804 
2805  CurFn->End = Asm->getFunctionEnd();
2806 
2807  CurFn = nullptr;
2808 }
2809 
2812 
2813  // Ignore DBG_VALUE and DBG_LABEL locations and function prologue.
2814  if (!Asm || !CurFn || MI->isDebugInstr() ||
2816  return;
2817 
2818  // If the first instruction of a new MBB has no location, find the first
2819  // instruction with a location and use that.
2820  DebugLoc DL = MI->getDebugLoc();
2821  if (!DL && MI->getParent() != PrevInstBB) {
2822  for (const auto &NextMI : *MI->getParent()) {
2823  if (NextMI.isDebugInstr())
2824  continue;
2825  DL = NextMI.getDebugLoc();
2826  if (DL)
2827  break;
2828  }
2829  }
2830  PrevInstBB = MI->getParent();
2831 
2832  // If we still don't have a debug location, don't record a location.
2833  if (!DL)
2834  return;
2835 
2836  maybeRecordLocation(DL, Asm->MF);
2837 }
2838 
2839 MCSymbol *CodeViewDebug::beginCVSubsection(DebugSubsectionKind Kind) {
2840  MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(),
2841  *EndLabel = MMI->getContext().createTempSymbol();
2842  OS.EmitIntValue(unsigned(Kind), 4);
2843  OS.AddComment("Subsection size");
2844  OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 4);
2845  OS.EmitLabel(BeginLabel);
2846  return EndLabel;
2847 }
2848 
2849 void CodeViewDebug::endCVSubsection(MCSymbol *EndLabel) {
2850  OS.EmitLabel(EndLabel);
2851  // Every subsection must be aligned to a 4-byte boundary.
2852  OS.EmitValueToAlignment(4);
2853 }
2854 
2856  for (const EnumEntry<SymbolKind> &EE : getSymbolTypeNames())
2857  if (EE.Value == SymKind)
2858  return EE.Name;
2859  return "";
2860 }
2861 
2862 MCSymbol *CodeViewDebug::beginSymbolRecord(SymbolKind SymKind) {
2863  MCSymbol *BeginLabel = MMI->getContext().createTempSymbol(),
2864  *EndLabel = MMI->getContext().createTempSymbol();
2865  OS.AddComment("Record length");
2866  OS.emitAbsoluteSymbolDiff(EndLabel, BeginLabel, 2);
2867  OS.EmitLabel(BeginLabel);
2868  if (OS.isVerboseAsm())
2869  OS.AddComment("Record kind: " + getSymbolName(SymKind));
2870  OS.EmitIntValue(unsigned(SymKind), 2);
2871  return EndLabel;
2872 }
2873 
2874 void CodeViewDebug::endSymbolRecord(MCSymbol *SymEnd) {
2875  // MSVC does not pad out symbol records to four bytes, but LLVM does to avoid
2876  // an extra copy of every symbol record in LLD. This increases object file
2877  // size by less than 1% in the clang build, and is compatible with the Visual
2878  // C++ linker.
2879  OS.EmitValueToAlignment(4);
2880  OS.EmitLabel(SymEnd);
2881 }
2882 
2883 void CodeViewDebug::emitEndSymbolRecord(SymbolKind EndKind) {
2884  OS.AddComment("Record length");
2885  OS.EmitIntValue(2, 2);
2886  if (OS.isVerboseAsm())
2887  OS.AddComment("Record kind: " + getSymbolName(EndKind));
2888  OS.EmitIntValue(unsigned(EndKind), 2); // Record Kind
2889 }
2890 
2891 void CodeViewDebug::emitDebugInfoForUDTs(
2892  ArrayRef<std::pair<std::string, const DIType *>> UDTs) {
2893  for (const auto &UDT : UDTs) {
2894  const DIType *T = UDT.second;
2895  assert(shouldEmitUdt(T));
2896 
2897  MCSymbol *UDTRecordEnd = beginSymbolRecord(SymbolKind::S_UDT);
2898  OS.AddComment("Type");
2899  OS.EmitIntValue(getCompleteTypeIndex(T).getIndex(), 4);
2900  emitNullTerminatedSymbolName(OS, UDT.first);
2901  endSymbolRecord(UDTRecordEnd);
2902  }
2903 }
2904 
2905 void CodeViewDebug::collectGlobalVariableInfo() {
2907  GlobalMap;
2908  for (const GlobalVariable &GV : MMI->getModule()->globals()) {
2910  GV.getDebugInfo(GVEs);
2911  for (const auto *GVE : GVEs)
2912  GlobalMap[GVE] = &GV;
2913  }
2914 
2915  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2916  for (const MDNode *Node : CUs->operands()) {
2917  const auto *CU = cast<DICompileUnit>(Node);
2918  for (const auto *GVE : CU->getGlobalVariables()) {
2919  const auto *GV = GlobalMap.lookup(GVE);
2920  if (!GV || GV->isDeclarationForLinker())
2921  continue;
2922  const DIGlobalVariable *DIGV = GVE->getVariable();
2923  DIScope *Scope = DIGV->getScope();
2924  SmallVector<CVGlobalVariable, 1> *VariableList;
2925  if (Scope && isa<DILocalScope>(Scope)) {
2926  // Locate a global variable list for this scope, creating one if
2927  // necessary.
2928  auto Insertion = ScopeGlobals.insert(
2929  {Scope, std::unique_ptr<GlobalVariableList>()});
2930  if (Insertion.second)
2931  Insertion.first->second = llvm::make_unique<GlobalVariableList>();
2932  VariableList = Insertion.first->second.get();
2933  } else if (GV->hasComdat())
2934  // Emit this global variable into a COMDAT section.
2935  VariableList = &ComdatVariables;
2936  else
2937  // Emit this globla variable in a single global symbol section.
2938  VariableList = &GlobalVariables;
2939  CVGlobalVariable CVGV = {DIGV, GV};
2940  VariableList->emplace_back(std::move(CVGV));
2941  }
2942  }
2943 }
2944 
2945 void CodeViewDebug::emitDebugInfoForGlobals() {
2946  // First, emit all globals that are not in a comdat in a single symbol
2947  // substream. MSVC doesn't like it if the substream is empty, so only open
2948  // it if we have at least one global to emit.
2949  switchToDebugSectionForSymbol(nullptr);
2950  if (!GlobalVariables.empty()) {
2951  OS.AddComment("Symbol subsection for globals");
2952  MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
2953  emitGlobalVariableList(GlobalVariables);
2954  endCVSubsection(EndLabel);
2955  }
2956 
2957  // Second, emit each global that is in a comdat into its own .debug$S
2958  // section along with its own symbol substream.
2959  for (const CVGlobalVariable &CVGV : ComdatVariables) {
2960  MCSymbol *GVSym = Asm->getSymbol(CVGV.GV);
2961  OS.AddComment("Symbol subsection for " +
2962  Twine(GlobalValue::dropLLVMManglingEscape(CVGV.GV->getName())));
2963  switchToDebugSectionForSymbol(GVSym);
2964  MCSymbol *EndLabel = beginCVSubsection(DebugSubsectionKind::Symbols);
2965  // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2966  emitDebugInfoForGlobal(CVGV.DIGV, CVGV.GV, GVSym);
2967  endCVSubsection(EndLabel);
2968  }
2969 }
2970 
2971 void CodeViewDebug::emitDebugInfoForRetainedTypes() {
2972  NamedMDNode *CUs = MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
2973  for (const MDNode *Node : CUs->operands()) {
2974  for (auto *Ty : cast<DICompileUnit>(Node)->getRetainedTypes()) {
2975  if (DIType *RT = dyn_cast<DIType>(Ty)) {
2976  getTypeIndex(RT);
2977  // FIXME: Add to global/local DTU list.
2978  }
2979  }
2980  }
2981 }
2982 
2983 // Emit each global variable in the specified array.
2984 void CodeViewDebug::emitGlobalVariableList(ArrayRef<CVGlobalVariable> Globals) {
2985  for (const CVGlobalVariable &CVGV : Globals) {
2986  MCSymbol *GVSym = Asm->getSymbol(CVGV.GV);
2987  // FIXME: emitDebugInfoForGlobal() doesn't handle DIExpressions.
2988  emitDebugInfoForGlobal(CVGV.DIGV, CVGV.GV, GVSym);
2989  }
2990 }
2991 
2992 void CodeViewDebug::emitDebugInfoForGlobal(const DIGlobalVariable *DIGV,
2993  const GlobalVariable *GV,
2994  MCSymbol *GVSym) {
2995  // DataSym record, see SymbolRecord.h for more info. Thread local data
2996  // happens to have the same format as global data.
2998  ? (DIGV->isLocalToUnit() ? SymbolKind::S_LTHREAD32
2999  : SymbolKind::S_GTHREAD32)
3000  : (DIGV->isLocalToUnit() ? SymbolKind::S_LDATA32
3001  : SymbolKind::S_GDATA32);
3002  MCSymbol *DataEnd = beginSymbolRecord(DataSym);
3003  OS.AddComment("Type");
3004  OS.EmitIntValue(getCompleteTypeIndex(DIGV->getType()).getIndex(), 4);
3005  OS.AddComment("DataOffset");
3006  OS.EmitCOFFSecRel32(GVSym, /*Offset=*/0);
3007  OS.AddComment("Segment");
3008  OS.EmitCOFFSectionIndex(GVSym);
3009  OS.AddComment("Name");
3010  const unsigned LengthOfDataRecord = 12;
3011  emitNullTerminatedSymbolName(OS, DIGV->getName(), LengthOfDataRecord);
3012  endSymbolRecord(DataEnd);
3013 }
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:327
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
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:239
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:365
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:268
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:641
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:298
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:267
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:518
MCSymbol * createTempSymbol(bool CanBeUnnamed=true)
Create and return a new assembler temporary symbol with a unique but unspecified name.
Definition: MCContext.cpp:216
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
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
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:353
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:294
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:839
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:344
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:1985
DebugLoc PrologEndLoc
This location indicates end of function prologue and beginning of function body.
iterator insert(iterator I, T &&Elt)
Definition: SmallVector.h:470
MethodOptions
Equivalent to CV_fldattr_t bitfield.
Definition: CodeView.h:278
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:386
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
static bool isTrivial(const DICompositeType *DCTy)
unsigned getEncoding() const
void emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:644
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:277
#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:367
ThunkOrdinal
These values correspond to the THUNK_ORDINAL enumeration.
Definition: CodeView.h:530
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
const unsigned Kind
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:259
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:172
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:586
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:397
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:894
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
void resize(size_type N)
Definition: SmallVector.h:343