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