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