clang  5.0.0
CGDebugInfo.cpp
Go to the documentation of this file.
1 //===--- CGDebugInfo.cpp - Emit Debug Information for a Module ------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This coordinates the debug information generation while generating code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CGDebugInfo.h"
15 #include "CGBlocks.h"
16 #include "CGCXXABI.h"
17 #include "CGObjCRuntime.h"
18 #include "CGRecordLayout.h"
19 #include "CodeGenFunction.h"
20 #include "CodeGenModule.h"
21 #include "clang/AST/ASTContext.h"
22 #include "clang/AST/DeclFriend.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/DeclTemplate.h"
25 #include "clang/AST/Expr.h"
26 #include "clang/AST/RecordLayout.h"
29 #include "clang/Basic/Version.h"
32 #include "clang/Lex/ModuleMap.h"
34 #include "llvm/ADT/DenseSet.h"
35 #include "llvm/ADT/SmallVector.h"
36 #include "llvm/ADT/StringExtras.h"
37 #include "llvm/IR/Constants.h"
38 #include "llvm/IR/DataLayout.h"
39 #include "llvm/IR/DerivedTypes.h"
40 #include "llvm/IR/Instructions.h"
41 #include "llvm/IR/Intrinsics.h"
42 #include "llvm/IR/Module.h"
43 #include "llvm/Support/FileSystem.h"
44 #include "llvm/Support/MD5.h"
45 #include "llvm/Support/Path.h"
46 using namespace clang;
47 using namespace clang::CodeGen;
48 
49 static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) {
50  auto TI = Ctx.getTypeInfo(Ty);
51  return TI.AlignIsRequired ? TI.Align : 0;
52 }
53 
54 static uint32_t getTypeAlignIfRequired(QualType Ty, const ASTContext &Ctx) {
55  return getTypeAlignIfRequired(Ty.getTypePtr(), Ctx);
56 }
57 
58 static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx) {
59  return D->hasAttr<AlignedAttr>() ? D->getMaxAlignment() : 0;
60 }
61 
63  : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
64  DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
65  DBuilder(CGM.getModule()) {
66  for (const auto &KV : CGM.getCodeGenOpts().DebugPrefixMap)
67  DebugPrefixMap[KV.first] = KV.second;
68  CreateCompileUnit();
69 }
70 
72  assert(LexicalBlockStack.empty() &&
73  "Region stack mismatch, stack not empty!");
74 }
75 
76 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
77  SourceLocation TemporaryLocation)
78  : CGF(&CGF) {
79  init(TemporaryLocation);
80 }
81 
82 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
83  bool DefaultToEmpty,
84  SourceLocation TemporaryLocation)
85  : CGF(&CGF) {
86  init(TemporaryLocation, DefaultToEmpty);
87 }
88 
89 void ApplyDebugLocation::init(SourceLocation TemporaryLocation,
90  bool DefaultToEmpty) {
91  auto *DI = CGF->getDebugInfo();
92  if (!DI) {
93  CGF = nullptr;
94  return;
95  }
96 
97  OriginalLocation = CGF->Builder.getCurrentDebugLocation();
98  if (TemporaryLocation.isValid()) {
99  DI->EmitLocation(CGF->Builder, TemporaryLocation);
100  return;
101  }
102 
103  if (DefaultToEmpty) {
104  CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc());
105  return;
106  }
107 
108  // Construct a location that has a valid scope, but no line info.
109  assert(!DI->LexicalBlockStack.empty());
110  CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
111  0, 0, DI->LexicalBlockStack.back(), DI->getInlinedAt()));
112 }
113 
114 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E)
115  : CGF(&CGF) {
116  init(E->getExprLoc());
117 }
118 
119 ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc)
120  : CGF(&CGF) {
121  if (!CGF.getDebugInfo()) {
122  this->CGF = nullptr;
123  return;
124  }
125  OriginalLocation = CGF.Builder.getCurrentDebugLocation();
126  if (Loc)
127  CGF.Builder.SetCurrentDebugLocation(std::move(Loc));
128 }
129 
131  // Query CGF so the location isn't overwritten when location updates are
132  // temporarily disabled (for C++ default function arguments)
133  if (CGF)
134  CGF->Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
135 }
136 
138  GlobalDecl InlinedFn)
139  : CGF(&CGF) {
140  if (!CGF.getDebugInfo()) {
141  this->CGF = nullptr;
142  return;
143  }
144  auto &DI = *CGF.getDebugInfo();
145  SavedLocation = DI.getLocation();
146  assert((DI.getInlinedAt() ==
147  CGF.Builder.getCurrentDebugLocation()->getInlinedAt()) &&
148  "CGDebugInfo and IRBuilder are out of sync");
149 
150  DI.EmitInlineFunctionStart(CGF.Builder, InlinedFn);
151 }
152 
154  if (!CGF)
155  return;
156  auto &DI = *CGF->getDebugInfo();
158  DI.EmitLocation(CGF->Builder, SavedLocation);
159 }
160 
162  // If the new location isn't valid return.
163  if (Loc.isInvalid())
164  return;
165 
166  CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc);
167 
168  // If we've changed files in the middle of a lexical scope go ahead
169  // and create a new lexical scope with file node if it's different
170  // from the one in the scope.
171  if (LexicalBlockStack.empty())
172  return;
173 
175  auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
176  PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
177 
178  if (PCLoc.isInvalid() || Scope->getFilename() == PCLoc.getFilename())
179  return;
180 
181  if (auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(Scope)) {
182  LexicalBlockStack.pop_back();
183  LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile(
184  LBF->getScope(), getOrCreateFile(CurLoc)));
185  } else if (isa<llvm::DILexicalBlock>(Scope) ||
186  isa<llvm::DISubprogram>(Scope)) {
187  LexicalBlockStack.pop_back();
188  LexicalBlockStack.emplace_back(
189  DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc)));
190  }
191 }
192 
193 llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(const Decl *D) {
194  llvm::DIScope *Mod = getParentModuleOrNull(D);
195  return getContextDescriptor(cast<Decl>(D->getDeclContext()),
196  Mod ? Mod : TheCU);
197 }
198 
199 llvm::DIScope *CGDebugInfo::getContextDescriptor(const Decl *Context,
200  llvm::DIScope *Default) {
201  if (!Context)
202  return Default;
203 
204  auto I = RegionMap.find(Context);
205  if (I != RegionMap.end()) {
206  llvm::Metadata *V = I->second;
207  return dyn_cast_or_null<llvm::DIScope>(V);
208  }
209 
210  // Check namespace.
211  if (const auto *NSDecl = dyn_cast<NamespaceDecl>(Context))
212  return getOrCreateNamespace(NSDecl);
213 
214  if (const auto *RDecl = dyn_cast<RecordDecl>(Context))
215  if (!RDecl->isDependentType())
216  return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
217  getOrCreateMainFile());
218  return Default;
219 }
220 
221 StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
222  assert(FD && "Invalid FunctionDecl!");
223  IdentifierInfo *FII = FD->getIdentifier();
226 
227  // Emit the unqualified name in normal operation. LLVM and the debugger can
228  // compute the fully qualified name from the scope chain. If we're only
229  // emitting line table info, there won't be any scope chains, so emit the
230  // fully qualified name here so that stack traces are more accurate.
231  // FIXME: Do this when emitting DWARF as well as when emitting CodeView after
232  // evaluating the size impact.
233  bool UseQualifiedName = DebugKind == codegenoptions::DebugLineTablesOnly &&
234  CGM.getCodeGenOpts().EmitCodeView;
235 
236  if (!Info && FII && !UseQualifiedName)
237  return FII->getName();
238 
239  SmallString<128> NS;
240  llvm::raw_svector_ostream OS(NS);
241  PrintingPolicy Policy(CGM.getLangOpts());
242  Policy.MSVCFormatting = CGM.getCodeGenOpts().EmitCodeView;
243  if (!UseQualifiedName)
244  FD->printName(OS);
245  else
246  FD->printQualifiedName(OS, Policy);
247 
248  // Add any template specialization args.
249  if (Info) {
250  const TemplateArgumentList *TArgs = Info->TemplateArguments;
252  Policy);
253  }
254 
255  // Copy this name on the side and use its reference.
256  return internString(OS.str());
257 }
258 
259 StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) {
260  SmallString<256> MethodName;
261  llvm::raw_svector_ostream OS(MethodName);
262  OS << (OMD->isInstanceMethod() ? '-' : '+') << '[';
263  const DeclContext *DC = OMD->getDeclContext();
264  if (const auto *OID = dyn_cast<ObjCImplementationDecl>(DC)) {
265  OS << OID->getName();
266  } else if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(DC)) {
267  OS << OID->getName();
268  } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(DC)) {
269  if (OC->IsClassExtension()) {
270  OS << OC->getClassInterface()->getName();
271  } else {
272  OS << OC->getIdentifier()->getNameStart() << '('
273  << OC->getIdentifier()->getNameStart() << ')';
274  }
275  } else if (const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {
276  OS << OCD->getClassInterface()->getName() << '('
277  << OCD->getName() << ')';
278  } else if (isa<ObjCProtocolDecl>(DC)) {
279  // We can extract the type of the class from the self pointer.
280  if (ImplicitParamDecl *SelfDecl = OMD->getSelfDecl()) {
281  QualType ClassTy =
282  cast<ObjCObjectPointerType>(SelfDecl->getType())->getPointeeType();
283  ClassTy.print(OS, PrintingPolicy(LangOptions()));
284  }
285  }
286  OS << ' ' << OMD->getSelector().getAsString() << ']';
287 
288  return internString(OS.str());
289 }
290 
291 StringRef CGDebugInfo::getSelectorName(Selector S) {
292  return internString(S.getAsString());
293 }
294 
295 StringRef CGDebugInfo::getClassName(const RecordDecl *RD) {
296  if (isa<ClassTemplateSpecializationDecl>(RD)) {
297  SmallString<128> Name;
298  llvm::raw_svector_ostream OS(Name);
300  /*Qualified*/ false);
301 
302  // Copy this name on the side and use its reference.
303  return internString(Name);
304  }
305 
306  // quick optimization to avoid having to intern strings that are already
307  // stored reliably elsewhere
308  if (const IdentifierInfo *II = RD->getIdentifier())
309  return II->getName();
310 
311  // The CodeView printer in LLVM wants to see the names of unnamed types: it is
312  // used to reconstruct the fully qualified type names.
313  if (CGM.getCodeGenOpts().EmitCodeView) {
314  if (const TypedefNameDecl *D = RD->getTypedefNameForAnonDecl()) {
315  assert(RD->getDeclContext() == D->getDeclContext() &&
316  "Typedef should not be in another decl context!");
317  assert(D->getDeclName().getAsIdentifierInfo() &&
318  "Typedef was not named!");
319  return D->getDeclName().getAsIdentifierInfo()->getName();
320  }
321 
322  if (CGM.getLangOpts().CPlusPlus) {
323  StringRef Name;
324 
325  ASTContext &Context = CGM.getContext();
326  if (const DeclaratorDecl *DD = Context.getDeclaratorForUnnamedTagDecl(RD))
327  // Anonymous types without a name for linkage purposes have their
328  // declarator mangled in if they have one.
329  Name = DD->getName();
330  else if (const TypedefNameDecl *TND =
332  // Anonymous types without a name for linkage purposes have their
333  // associate typedef mangled in if they have one.
334  Name = TND->getName();
335 
336  if (!Name.empty()) {
337  SmallString<256> UnnamedType("<unnamed-type-");
338  UnnamedType += Name;
339  UnnamedType += '>';
340  return internString(UnnamedType);
341  }
342  }
343  }
344 
345  return StringRef();
346 }
347 
348 llvm::DIFile::ChecksumKind
349 CGDebugInfo::computeChecksum(FileID FID, SmallString<32> &Checksum) const {
350  Checksum.clear();
351 
352  if (!CGM.getCodeGenOpts().EmitCodeView)
353  return llvm::DIFile::CSK_None;
354 
356  bool Invalid;
357  llvm::MemoryBuffer *MemBuffer = SM.getBuffer(FID, &Invalid);
358  if (Invalid)
359  return llvm::DIFile::CSK_None;
360 
361  llvm::MD5 Hash;
362  llvm::MD5::MD5Result Result;
363 
364  Hash.update(MemBuffer->getBuffer());
365  Hash.final(Result);
366 
367  Hash.stringifyResult(Result, Checksum);
368  return llvm::DIFile::CSK_MD5;
369 }
370 
371 llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
372  if (!Loc.isValid())
373  // If Location is not valid then use main input file.
374  return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
375  remapDIPath(TheCU->getDirectory()),
376  TheCU->getFile()->getChecksumKind(),
377  TheCU->getFile()->getChecksum());
378 
380  PresumedLoc PLoc = SM.getPresumedLoc(Loc);
381 
382  if (PLoc.isInvalid() || StringRef(PLoc.getFilename()).empty())
383  // If the location is not valid then use main input file.
384  return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
385  remapDIPath(TheCU->getDirectory()),
386  TheCU->getFile()->getChecksumKind(),
387  TheCU->getFile()->getChecksum());
388 
389  // Cache the results.
390  const char *fname = PLoc.getFilename();
391  auto it = DIFileCache.find(fname);
392 
393  if (it != DIFileCache.end()) {
394  // Verify that the information still exists.
395  if (llvm::Metadata *V = it->second)
396  return cast<llvm::DIFile>(V);
397  }
398 
399  SmallString<32> Checksum;
400  llvm::DIFile::ChecksumKind CSKind =
401  computeChecksum(SM.getFileID(Loc), Checksum);
402 
403  llvm::DIFile *F = DBuilder.createFile(remapDIPath(PLoc.getFilename()),
404  remapDIPath(getCurrentDirname()),
405  CSKind, Checksum);
406 
407  DIFileCache[fname].reset(F);
408  return F;
409 }
410 
411 llvm::DIFile *CGDebugInfo::getOrCreateMainFile() {
412  return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
413  remapDIPath(TheCU->getDirectory()),
414  TheCU->getFile()->getChecksumKind(),
415  TheCU->getFile()->getChecksum());
416 }
417 
418 std::string CGDebugInfo::remapDIPath(StringRef Path) const {
419  for (const auto &Entry : DebugPrefixMap)
420  if (Path.startswith(Entry.first))
421  return (Twine(Entry.second) + Path.substr(Entry.first.size())).str();
422  return Path.str();
423 }
424 
425 unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
426  if (Loc.isInvalid() && CurLoc.isInvalid())
427  return 0;
429  PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
430  return PLoc.isValid() ? PLoc.getLine() : 0;
431 }
432 
433 unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) {
434  // We may not want column information at all.
435  if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo)
436  return 0;
437 
438  // If the location is invalid then use the current column.
439  if (Loc.isInvalid() && CurLoc.isInvalid())
440  return 0;
442  PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
443  return PLoc.isValid() ? PLoc.getColumn() : 0;
444 }
445 
446 StringRef CGDebugInfo::getCurrentDirname() {
447  if (!CGM.getCodeGenOpts().DebugCompilationDir.empty())
448  return CGM.getCodeGenOpts().DebugCompilationDir;
449 
450  if (!CWDName.empty())
451  return CWDName;
452  SmallString<256> CWD;
453  llvm::sys::fs::current_path(CWD);
454  return CWDName = internString(CWD);
455 }
456 
457 void CGDebugInfo::CreateCompileUnit() {
458  SmallString<32> Checksum;
459  llvm::DIFile::ChecksumKind CSKind = llvm::DIFile::CSK_None;
460 
461  // Should we be asking the SourceManager for the main file name, instead of
462  // accepting it as an argument? This just causes the main file name to
463  // mismatch with source locations and create extra lexical scopes or
464  // mismatched debug info (a CU with a DW_AT_file of "-", because that's what
465  // the driver passed, but functions/other things have DW_AT_file of "<stdin>"
466  // because that's what the SourceManager says)
467 
468  // Get absolute path name.
470  std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
471  if (MainFileName.empty())
472  MainFileName = "<stdin>";
473 
474  // The main file name provided via the "-main-file-name" option contains just
475  // the file name itself with no path information. This file name may have had
476  // a relative path, so we look into the actual file entry for the main
477  // file to determine the real absolute path for the file.
478  std::string MainFileDir;
479  if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
480  MainFileDir = remapDIPath(MainFile->getDir()->getName());
481  if (MainFileDir != ".") {
482  llvm::SmallString<1024> MainFileDirSS(MainFileDir);
483  llvm::sys::path::append(MainFileDirSS, MainFileName);
484  MainFileName = MainFileDirSS.str();
485  }
486  CSKind = computeChecksum(SM.getMainFileID(), Checksum);
487  }
488 
489  llvm::dwarf::SourceLanguage LangTag;
490  const LangOptions &LO = CGM.getLangOpts();
491  if (LO.CPlusPlus) {
492  if (LO.ObjC1)
493  LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
494  else
495  LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
496  } else if (LO.ObjC1) {
497  LangTag = llvm::dwarf::DW_LANG_ObjC;
498  } else if (LO.RenderScript) {
499  LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript;
500  } else if (LO.C99) {
501  LangTag = llvm::dwarf::DW_LANG_C99;
502  } else {
503  LangTag = llvm::dwarf::DW_LANG_C89;
504  }
505 
506  std::string Producer = getClangFullVersion();
507 
508  // Figure out which version of the ObjC runtime we have.
509  unsigned RuntimeVers = 0;
510  if (LO.ObjC1)
511  RuntimeVers = LO.ObjCRuntime.isNonFragile() ? 2 : 1;
512 
513  llvm::DICompileUnit::DebugEmissionKind EmissionKind;
514  switch (DebugKind) {
517  EmissionKind = llvm::DICompileUnit::NoDebug;
518  break;
520  EmissionKind = llvm::DICompileUnit::LineTablesOnly;
521  break;
524  EmissionKind = llvm::DICompileUnit::FullDebug;
525  break;
526  }
527 
528  // Create new compile unit.
529  // FIXME - Eliminate TheCU.
530  TheCU = DBuilder.createCompileUnit(
531  LangTag,
532  DBuilder.createFile(remapDIPath(MainFileName),
533  remapDIPath(getCurrentDirname()), CSKind, Checksum),
534  Producer, LO.Optimize, CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers,
535  CGM.getCodeGenOpts().EnableSplitDwarf
536  ? ""
538  EmissionKind, 0 /* DWOid */, CGM.getCodeGenOpts().SplitDwarfInlining,
539  CGM.getCodeGenOpts().DebugInfoForProfiling);
540 }
541 
542 llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) {
543  llvm::dwarf::TypeKind Encoding;
544  StringRef BTName;
545  switch (BT->getKind()) {
546 #define BUILTIN_TYPE(Id, SingletonId)
547 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:
548 #include "clang/AST/BuiltinTypes.def"
549  case BuiltinType::Dependent:
550  llvm_unreachable("Unexpected builtin type");
551  case BuiltinType::NullPtr:
552  return DBuilder.createNullPtrType();
553  case BuiltinType::Void:
554  return nullptr;
555  case BuiltinType::ObjCClass:
556  if (!ClassTy)
557  ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
558  "objc_class", TheCU,
559  getOrCreateMainFile(), 0);
560  return ClassTy;
561  case BuiltinType::ObjCId: {
562  // typedef struct objc_class *Class;
563  // typedef struct objc_object {
564  // Class isa;
565  // } *id;
566 
567  if (ObjTy)
568  return ObjTy;
569 
570  if (!ClassTy)
571  ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
572  "objc_class", TheCU,
573  getOrCreateMainFile(), 0);
574 
575  unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
576 
577  auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
578 
579  ObjTy = DBuilder.createStructType(
580  TheCU, "objc_object", getOrCreateMainFile(), 0, 0, 0,
581  llvm::DINode::FlagZero, nullptr, llvm::DINodeArray());
582 
583  DBuilder.replaceArrays(
584  ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
585  ObjTy, "isa", getOrCreateMainFile(), 0, Size, 0, 0,
586  llvm::DINode::FlagZero, ISATy)));
587  return ObjTy;
588  }
589  case BuiltinType::ObjCSel: {
590  if (!SelTy)
591  SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
592  "objc_selector", TheCU,
593  getOrCreateMainFile(), 0);
594  return SelTy;
595  }
596 
597 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
598  case BuiltinType::Id: \
599  return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \
600  SingletonId);
601 #include "clang/Basic/OpenCLImageTypes.def"
602  case BuiltinType::OCLSampler:
603  return getOrCreateStructPtrType("opencl_sampler_t",
604  OCLSamplerDITy);
605  case BuiltinType::OCLEvent:
606  return getOrCreateStructPtrType("opencl_event_t", OCLEventDITy);
607  case BuiltinType::OCLClkEvent:
608  return getOrCreateStructPtrType("opencl_clk_event_t", OCLClkEventDITy);
609  case BuiltinType::OCLQueue:
610  return getOrCreateStructPtrType("opencl_queue_t", OCLQueueDITy);
611  case BuiltinType::OCLReserveID:
612  return getOrCreateStructPtrType("opencl_reserve_id_t", OCLReserveIDDITy);
613 
614  case BuiltinType::UChar:
615  case BuiltinType::Char_U:
616  Encoding = llvm::dwarf::DW_ATE_unsigned_char;
617  break;
618  case BuiltinType::Char_S:
619  case BuiltinType::SChar:
620  Encoding = llvm::dwarf::DW_ATE_signed_char;
621  break;
622  case BuiltinType::Char16:
623  case BuiltinType::Char32:
624  Encoding = llvm::dwarf::DW_ATE_UTF;
625  break;
626  case BuiltinType::UShort:
627  case BuiltinType::UInt:
628  case BuiltinType::UInt128:
629  case BuiltinType::ULong:
630  case BuiltinType::WChar_U:
631  case BuiltinType::ULongLong:
632  Encoding = llvm::dwarf::DW_ATE_unsigned;
633  break;
634  case BuiltinType::Short:
635  case BuiltinType::Int:
636  case BuiltinType::Int128:
637  case BuiltinType::Long:
638  case BuiltinType::WChar_S:
639  case BuiltinType::LongLong:
640  Encoding = llvm::dwarf::DW_ATE_signed;
641  break;
642  case BuiltinType::Bool:
643  Encoding = llvm::dwarf::DW_ATE_boolean;
644  break;
645  case BuiltinType::Half:
646  case BuiltinType::Float:
647  case BuiltinType::LongDouble:
648  case BuiltinType::Float128:
649  case BuiltinType::Double:
650  // FIXME: For targets where long double and __float128 have the same size,
651  // they are currently indistinguishable in the debugger without some
652  // special treatment. However, there is currently no consensus on encoding
653  // and this should be updated once a DWARF encoding exists for distinct
654  // floating point types of the same size.
655  Encoding = llvm::dwarf::DW_ATE_float;
656  break;
657  }
658 
659  switch (BT->getKind()) {
660  case BuiltinType::Long:
661  BTName = "long int";
662  break;
663  case BuiltinType::LongLong:
664  BTName = "long long int";
665  break;
666  case BuiltinType::ULong:
667  BTName = "long unsigned int";
668  break;
669  case BuiltinType::ULongLong:
670  BTName = "long long unsigned int";
671  break;
672  default:
673  BTName = BT->getName(CGM.getLangOpts());
674  break;
675  }
676  // Bit size and offset of the type.
677  uint64_t Size = CGM.getContext().getTypeSize(BT);
678  return DBuilder.createBasicType(BTName, Size, Encoding);
679 }
680 
681 llvm::DIType *CGDebugInfo::CreateType(const ComplexType *Ty) {
682  // Bit size and offset of the type.
683  llvm::dwarf::TypeKind Encoding = llvm::dwarf::DW_ATE_complex_float;
684  if (Ty->isComplexIntegerType())
685  Encoding = llvm::dwarf::DW_ATE_lo_user;
686 
687  uint64_t Size = CGM.getContext().getTypeSize(Ty);
688  return DBuilder.createBasicType("complex", Size, Encoding);
689 }
690 
691 llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty,
692  llvm::DIFile *Unit) {
694  const Type *T = Qc.strip(Ty);
695 
696  // Ignore these qualifiers for now.
697  Qc.removeObjCGCAttr();
698  Qc.removeAddressSpace();
699  Qc.removeObjCLifetime();
700 
701  // We will create one Derived type for one qualifier and recurse to handle any
702  // additional ones.
703  llvm::dwarf::Tag Tag;
704  if (Qc.hasConst()) {
705  Tag = llvm::dwarf::DW_TAG_const_type;
706  Qc.removeConst();
707  } else if (Qc.hasVolatile()) {
708  Tag = llvm::dwarf::DW_TAG_volatile_type;
709  Qc.removeVolatile();
710  } else if (Qc.hasRestrict()) {
711  Tag = llvm::dwarf::DW_TAG_restrict_type;
712  Qc.removeRestrict();
713  } else {
714  assert(Qc.empty() && "Unknown type qualifier for debug info");
715  return getOrCreateType(QualType(T, 0), Unit);
716  }
717 
718  auto *FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit);
719 
720  // No need to fill in the Name, Line, Size, Alignment, Offset in case of
721  // CVR derived types.
722  return DBuilder.createQualifiedType(Tag, FromTy);
723 }
724 
725 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
726  llvm::DIFile *Unit) {
727 
728  // The frontend treats 'id' as a typedef to an ObjCObjectType,
729  // whereas 'id<protocol>' is treated as an ObjCPointerType. For the
730  // debug info, we want to emit 'id' in both cases.
731  if (Ty->isObjCQualifiedIdType())
732  return getOrCreateType(CGM.getContext().getObjCIdType(), Unit);
733 
734  return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
735  Ty->getPointeeType(), Unit);
736 }
737 
738 llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty,
739  llvm::DIFile *Unit) {
740  return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
741  Ty->getPointeeType(), Unit);
742 }
743 
744 /// \return whether a C++ mangling exists for the type defined by TD.
745 static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU) {
746  switch (TheCU->getSourceLanguage()) {
747  case llvm::dwarf::DW_LANG_C_plus_plus:
748  return true;
749  case llvm::dwarf::DW_LANG_ObjC_plus_plus:
750  return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
751  default:
752  return false;
753  }
754 }
755 
756 /// In C++ mode, types have linkage, so we can rely on the ODR and
757 /// on their mangled names, if they're external.
758 static SmallString<256> getUniqueTagTypeName(const TagType *Ty,
759  CodeGenModule &CGM,
760  llvm::DICompileUnit *TheCU) {
761  SmallString<256> FullName;
762  const TagDecl *TD = Ty->getDecl();
763 
764  if (!hasCXXMangling(TD, TheCU) || !TD->isExternallyVisible())
765  return FullName;
766 
767  // TODO: This is using the RTTI name. Is there a better way to get
768  // a unique string for a type?
769  llvm::raw_svector_ostream Out(FullName);
771  return FullName;
772 }
773 
774 /// \return the approproate DWARF tag for a composite type.
775 static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) {
776  llvm::dwarf::Tag Tag;
777  if (RD->isStruct() || RD->isInterface())
778  Tag = llvm::dwarf::DW_TAG_structure_type;
779  else if (RD->isUnion())
780  Tag = llvm::dwarf::DW_TAG_union_type;
781  else {
782  // FIXME: This could be a struct type giving a default visibility different
783  // than C++ class type, but needs llvm metadata changes first.
784  assert(RD->isClass());
785  Tag = llvm::dwarf::DW_TAG_class_type;
786  }
787  return Tag;
788 }
789 
790 llvm::DICompositeType *
791 CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty,
792  llvm::DIScope *Ctx) {
793  const RecordDecl *RD = Ty->getDecl();
794  if (llvm::DIType *T = getTypeOrNull(CGM.getContext().getRecordType(RD)))
795  return cast<llvm::DICompositeType>(T);
796  llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
797  unsigned Line = getLineNumber(RD->getLocation());
798  StringRef RDName = getClassName(RD);
799 
800  uint64_t Size = 0;
801  uint32_t Align = 0;
802 
803  // Create the type.
804  SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
805  llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
806  getTagForRecord(RD), RDName, Ctx, DefUnit, Line, 0, Size, Align,
807  llvm::DINode::FlagFwdDecl, FullName);
808  ReplaceMap.emplace_back(
809  std::piecewise_construct, std::make_tuple(Ty),
810  std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
811  return RetTy;
812 }
813 
814 llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
815  const Type *Ty,
816  QualType PointeeTy,
817  llvm::DIFile *Unit) {
818  // Bit size, align and offset of the type.
819  // Size is always the size of a pointer. We can't use getTypeSize here
820  // because that does not return the correct value for references.
821  unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(PointeeTy);
822  uint64_t Size = CGM.getTarget().getPointerWidth(AddressSpace);
823  auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
824  Optional<unsigned> DWARFAddressSpace =
825  CGM.getTarget().getDWARFAddressSpace(AddressSpace);
826 
827  if (Tag == llvm::dwarf::DW_TAG_reference_type ||
828  Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
829  return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
830  Size, Align, DWARFAddressSpace);
831  else
832  return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
833  Align, DWARFAddressSpace);
834 }
835 
836 llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
837  llvm::DIType *&Cache) {
838  if (Cache)
839  return Cache;
840  Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
841  TheCU, getOrCreateMainFile(), 0);
842  unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
843  Cache = DBuilder.createPointerType(Cache, Size);
844  return Cache;
845 }
846 
847 llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty,
848  llvm::DIFile *Unit) {
850  QualType FType;
851  uint64_t FieldSize, FieldOffset;
852  uint32_t FieldAlign;
853  llvm::DINodeArray Elements;
854 
855  FieldOffset = 0;
856  FType = CGM.getContext().UnsignedLongTy;
857  EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
858  EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
859 
860  Elements = DBuilder.getOrCreateArray(EltTys);
861  EltTys.clear();
862 
863  llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
864  unsigned LineNo = 0;
865 
866  auto *EltTy =
867  DBuilder.createStructType(Unit, "__block_descriptor", nullptr, LineNo,
868  FieldOffset, 0, Flags, nullptr, Elements);
869 
870  // Bit size, align and offset of the type.
871  uint64_t Size = CGM.getContext().getTypeSize(Ty);
872 
873  auto *DescTy = DBuilder.createPointerType(EltTy, Size);
874 
875  FieldOffset = 0;
876  FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
877  EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
878  FType = CGM.getContext().IntTy;
879  EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
880  EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
881  FType = CGM.getContext().getPointerType(Ty->getPointeeType());
882  EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
883 
884  FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
885  FieldSize = CGM.getContext().getTypeSize(Ty);
886  FieldAlign = CGM.getContext().getTypeAlign(Ty);
887  EltTys.push_back(DBuilder.createMemberType(
888  Unit, "__descriptor", nullptr, LineNo, FieldSize, FieldAlign, FieldOffset,
889  llvm::DINode::FlagZero, DescTy));
890 
891  FieldOffset += FieldSize;
892  Elements = DBuilder.getOrCreateArray(EltTys);
893 
894  // The __block_literal_generic structs are marked with a special
895  // DW_AT_APPLE_BLOCK attribute and are an implementation detail only
896  // the debugger needs to know about. To allow type uniquing, emit
897  // them without a name or a location.
898  EltTy =
899  DBuilder.createStructType(Unit, "", nullptr, LineNo,
900  FieldOffset, 0, Flags, nullptr, Elements);
901 
902  return DBuilder.createPointerType(EltTy, Size);
903 }
904 
905 llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty,
906  llvm::DIFile *Unit) {
907  assert(Ty->isTypeAlias());
908  llvm::DIType *Src = getOrCreateType(Ty->getAliasedType(), Unit);
909 
910  SmallString<128> NS;
911  llvm::raw_svector_ostream OS(NS);
913  /*qualified*/ false);
914 
916  OS, Ty->template_arguments(),
917  CGM.getContext().getPrintingPolicy());
918 
919  auto *AliasDecl = cast<TypeAliasTemplateDecl>(
920  Ty->getTemplateName().getAsTemplateDecl())->getTemplatedDecl();
921 
922  SourceLocation Loc = AliasDecl->getLocation();
923  return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(Loc),
924  getLineNumber(Loc),
925  getDeclContextDescriptor(AliasDecl));
926 }
927 
928 llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty,
929  llvm::DIFile *Unit) {
930  // We don't set size information, but do specify where the typedef was
931  // declared.
932  SourceLocation Loc = Ty->getDecl()->getLocation();
933 
934  // Typedefs are derived from some other type.
935  return DBuilder.createTypedef(
936  getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit),
937  Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc),
938  getDeclContextDescriptor(Ty->getDecl()));
939 }
940 
941 static unsigned getDwarfCC(CallingConv CC) {
942  switch (CC) {
943  case CC_C:
944  // Avoid emitting DW_AT_calling_convention if the C convention was used.
945  return 0;
946 
947  case CC_X86StdCall:
948  return llvm::dwarf::DW_CC_BORLAND_stdcall;
949  case CC_X86FastCall:
950  return llvm::dwarf::DW_CC_BORLAND_msfastcall;
951  case CC_X86ThisCall:
952  return llvm::dwarf::DW_CC_BORLAND_thiscall;
953  case CC_X86VectorCall:
954  return llvm::dwarf::DW_CC_LLVM_vectorcall;
955  case CC_X86Pascal:
956  return llvm::dwarf::DW_CC_BORLAND_pascal;
957 
958  // FIXME: Create new DW_CC_ codes for these calling conventions.
959  case CC_Win64:
960  case CC_X86_64SysV:
961  case CC_AAPCS:
962  case CC_AAPCS_VFP:
963  case CC_IntelOclBicc:
964  case CC_SpirFunction:
965  case CC_OpenCLKernel:
966  case CC_Swift:
967  case CC_PreserveMost:
968  case CC_PreserveAll:
969  case CC_X86RegCall:
970  return 0;
971  }
972  return 0;
973 }
974 
975 llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty,
976  llvm::DIFile *Unit) {
978 
979  // Add the result type at least.
980  EltTys.push_back(getOrCreateType(Ty->getReturnType(), Unit));
981 
982  // Set up remainder of arguments if there is a prototype.
983  // otherwise emit it as a variadic function.
984  if (isa<FunctionNoProtoType>(Ty))
985  EltTys.push_back(DBuilder.createUnspecifiedParameter());
986  else if (const auto *FPT = dyn_cast<FunctionProtoType>(Ty)) {
987  for (const QualType &ParamType : FPT->param_types())
988  EltTys.push_back(getOrCreateType(ParamType, Unit));
989  if (FPT->isVariadic())
990  EltTys.push_back(DBuilder.createUnspecifiedParameter());
991  }
992 
993  llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
994  return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
995  getDwarfCC(Ty->getCallConv()));
996 }
997 
998 /// Convert an AccessSpecifier into the corresponding DINode flag.
999 /// As an optimization, return 0 if the access specifier equals the
1000 /// default for the containing type.
1001 static llvm::DINode::DIFlags getAccessFlag(AccessSpecifier Access,
1002  const RecordDecl *RD) {
1003  AccessSpecifier Default = clang::AS_none;
1004  if (RD && RD->isClass())
1005  Default = clang::AS_private;
1006  else if (RD && (RD->isStruct() || RD->isUnion()))
1007  Default = clang::AS_public;
1008 
1009  if (Access == Default)
1010  return llvm::DINode::FlagZero;
1011 
1012  switch (Access) {
1013  case clang::AS_private:
1014  return llvm::DINode::FlagPrivate;
1015  case clang::AS_protected:
1016  return llvm::DINode::FlagProtected;
1017  case clang::AS_public:
1018  return llvm::DINode::FlagPublic;
1019  case clang::AS_none:
1020  return llvm::DINode::FlagZero;
1021  }
1022  llvm_unreachable("unexpected access enumerator");
1023 }
1024 
1025 llvm::DIType *CGDebugInfo::createBitFieldType(const FieldDecl *BitFieldDecl,
1026  llvm::DIScope *RecordTy,
1027  const RecordDecl *RD) {
1028  StringRef Name = BitFieldDecl->getName();
1029  QualType Ty = BitFieldDecl->getType();
1030  SourceLocation Loc = BitFieldDecl->getLocation();
1031  llvm::DIFile *VUnit = getOrCreateFile(Loc);
1032  llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1033 
1034  // Get the location for the field.
1035  llvm::DIFile *File = getOrCreateFile(Loc);
1036  unsigned Line = getLineNumber(Loc);
1037 
1038  const CGBitFieldInfo &BitFieldInfo =
1039  CGM.getTypes().getCGRecordLayout(RD).getBitFieldInfo(BitFieldDecl);
1040  uint64_t SizeInBits = BitFieldInfo.Size;
1041  assert(SizeInBits > 0 && "found named 0-width bitfield");
1042  uint64_t StorageOffsetInBits =
1043  CGM.getContext().toBits(BitFieldInfo.StorageOffset);
1044  uint64_t Offset = BitFieldInfo.Offset;
1045  // The bit offsets for big endian machines are reversed for big
1046  // endian target, compensate for that as the DIDerivedType requires
1047  // un-reversed offsets.
1048  if (CGM.getDataLayout().isBigEndian())
1049  Offset = BitFieldInfo.StorageSize - BitFieldInfo.Size - Offset;
1050  uint64_t OffsetInBits = StorageOffsetInBits + Offset;
1051  llvm::DINode::DIFlags Flags = getAccessFlag(BitFieldDecl->getAccess(), RD);
1052  return DBuilder.createBitFieldMemberType(
1053  RecordTy, Name, File, Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
1054  Flags, DebugType);
1055 }
1056 
1057 llvm::DIType *
1058 CGDebugInfo::createFieldType(StringRef name, QualType type, SourceLocation loc,
1059  AccessSpecifier AS, uint64_t offsetInBits,
1060  uint32_t AlignInBits, llvm::DIFile *tunit,
1061  llvm::DIScope *scope, const RecordDecl *RD) {
1062  llvm::DIType *debugType = getOrCreateType(type, tunit);
1063 
1064  // Get the location for the field.
1065  llvm::DIFile *file = getOrCreateFile(loc);
1066  unsigned line = getLineNumber(loc);
1067 
1068  uint64_t SizeInBits = 0;
1069  auto Align = AlignInBits;
1070  if (!type->isIncompleteArrayType()) {
1071  TypeInfo TI = CGM.getContext().getTypeInfo(type);
1072  SizeInBits = TI.Width;
1073  if (!Align)
1074  Align = getTypeAlignIfRequired(type, CGM.getContext());
1075  }
1076 
1077  llvm::DINode::DIFlags flags = getAccessFlag(AS, RD);
1078  return DBuilder.createMemberType(scope, name, file, line, SizeInBits,
1079  Align, offsetInBits, flags, debugType);
1080 }
1081 
1082 void CGDebugInfo::CollectRecordLambdaFields(
1083  const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements,
1084  llvm::DIType *RecordTy) {
1085  // For C++11 Lambdas a Field will be the same as a Capture, but the Capture
1086  // has the name and the location of the variable so we should iterate over
1087  // both concurrently.
1088  const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl);
1090  unsigned fieldno = 0;
1092  E = CXXDecl->captures_end();
1093  I != E; ++I, ++Field, ++fieldno) {
1094  const LambdaCapture &C = *I;
1095  if (C.capturesVariable()) {
1096  SourceLocation Loc = C.getLocation();
1097  assert(!Field->isBitField() && "lambdas don't have bitfield members!");
1098  VarDecl *V = C.getCapturedVar();
1099  StringRef VName = V->getName();
1100  llvm::DIFile *VUnit = getOrCreateFile(Loc);
1101  auto Align = getDeclAlignIfRequired(V, CGM.getContext());
1102  llvm::DIType *FieldType = createFieldType(
1103  VName, Field->getType(), Loc, Field->getAccess(),
1104  layout.getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl);
1105  elements.push_back(FieldType);
1106  } else if (C.capturesThis()) {
1107  // TODO: Need to handle 'this' in some way by probably renaming the
1108  // this of the lambda class and having a field member of 'this' or
1109  // by using AT_object_pointer for the function and having that be
1110  // used as 'this' for semantic references.
1111  FieldDecl *f = *Field;
1112  llvm::DIFile *VUnit = getOrCreateFile(f->getLocation());
1113  QualType type = f->getType();
1114  llvm::DIType *fieldType = createFieldType(
1115  "this", type, f->getLocation(), f->getAccess(),
1116  layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl);
1117 
1118  elements.push_back(fieldType);
1119  }
1120  }
1121 }
1122 
1123 llvm::DIDerivedType *
1124 CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy,
1125  const RecordDecl *RD) {
1126  // Create the descriptor for the static variable, with or without
1127  // constant initializers.
1128  Var = Var->getCanonicalDecl();
1129  llvm::DIFile *VUnit = getOrCreateFile(Var->getLocation());
1130  llvm::DIType *VTy = getOrCreateType(Var->getType(), VUnit);
1131 
1132  unsigned LineNumber = getLineNumber(Var->getLocation());
1133  StringRef VName = Var->getName();
1134  llvm::Constant *C = nullptr;
1135  if (Var->getInit()) {
1136  const APValue *Value = Var->evaluateValue();
1137  if (Value) {
1138  if (Value->isInt())
1139  C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
1140  if (Value->isFloat())
1141  C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat());
1142  }
1143  }
1144 
1145  llvm::DINode::DIFlags Flags = getAccessFlag(Var->getAccess(), RD);
1146  auto Align = getDeclAlignIfRequired(Var, CGM.getContext());
1147  llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
1148  RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Align);
1149  StaticDataMemberCache[Var->getCanonicalDecl()].reset(GV);
1150  return GV;
1151 }
1152 
1153 void CGDebugInfo::CollectRecordNormalField(
1154  const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
1155  SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy,
1156  const RecordDecl *RD) {
1157  StringRef name = field->getName();
1158  QualType type = field->getType();
1159 
1160  // Ignore unnamed fields unless they're anonymous structs/unions.
1161  if (name.empty() && !type->isRecordType())
1162  return;
1163 
1164  llvm::DIType *FieldType;
1165  if (field->isBitField()) {
1166  FieldType = createBitFieldType(field, RecordTy, RD);
1167  } else {
1168  auto Align = getDeclAlignIfRequired(field, CGM.getContext());
1169  FieldType =
1170  createFieldType(name, type, field->getLocation(), field->getAccess(),
1171  OffsetInBits, Align, tunit, RecordTy, RD);
1172  }
1173 
1174  elements.push_back(FieldType);
1175 }
1176 
1177 void CGDebugInfo::CollectRecordNestedRecord(
1178  const RecordDecl *RD, SmallVectorImpl<llvm::Metadata *> &elements) {
1179  QualType Ty = CGM.getContext().getTypeDeclType(RD);
1180  // Injected class names are not considered nested records.
1181  if (isa<InjectedClassNameType>(Ty))
1182  return;
1183  SourceLocation Loc = RD->getLocation();
1184  llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc));
1185  elements.push_back(nestedType);
1186 }
1187 
1188 void CGDebugInfo::CollectRecordFields(
1189  const RecordDecl *record, llvm::DIFile *tunit,
1191  llvm::DICompositeType *RecordTy) {
1192  const auto *CXXDecl = dyn_cast<CXXRecordDecl>(record);
1193 
1194  if (CXXDecl && CXXDecl->isLambda())
1195  CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1196  else {
1197  const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record);
1198 
1199  // Debug info for nested records is included in the member list only for
1200  // CodeView.
1201  bool IncludeNestedRecords = CGM.getCodeGenOpts().EmitCodeView;
1202 
1203  // Field number for non-static fields.
1204  unsigned fieldNo = 0;
1205 
1206  // Static and non-static members should appear in the same order as
1207  // the corresponding declarations in the source program.
1208  for (const auto *I : record->decls())
1209  if (const auto *V = dyn_cast<VarDecl>(I)) {
1210  if (V->hasAttr<NoDebugAttr>())
1211  continue;
1212  // Reuse the existing static member declaration if one exists
1213  auto MI = StaticDataMemberCache.find(V->getCanonicalDecl());
1214  if (MI != StaticDataMemberCache.end()) {
1215  assert(MI->second &&
1216  "Static data member declaration should still exist");
1217  elements.push_back(MI->second);
1218  } else {
1219  auto Field = CreateRecordStaticField(V, RecordTy, record);
1220  elements.push_back(Field);
1221  }
1222  } else if (const auto *field = dyn_cast<FieldDecl>(I)) {
1223  CollectRecordNormalField(field, layout.getFieldOffset(fieldNo), tunit,
1224  elements, RecordTy, record);
1225 
1226  // Bump field number for next field.
1227  ++fieldNo;
1228  } else if (const auto *nestedRec = dyn_cast<CXXRecordDecl>(I))
1229  if (IncludeNestedRecords && !nestedRec->isImplicit() &&
1230  nestedRec->getDeclContext() == record)
1231  CollectRecordNestedRecord(nestedRec, elements);
1232  }
1233 }
1234 
1235 llvm::DISubroutineType *
1236 CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
1237  llvm::DIFile *Unit) {
1238  const FunctionProtoType *Func = Method->getType()->getAs<FunctionProtoType>();
1239  if (Method->isStatic())
1240  return cast_or_null<llvm::DISubroutineType>(
1241  getOrCreateType(QualType(Func, 0), Unit));
1242  return getOrCreateInstanceMethodType(Method->getThisType(CGM.getContext()),
1243  Func, Unit);
1244 }
1245 
1246 llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
1247  QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile *Unit) {
1248  // Add "this" pointer.
1249  llvm::DITypeRefArray Args(
1250  cast<llvm::DISubroutineType>(getOrCreateType(QualType(Func, 0), Unit))
1251  ->getTypeArray());
1252  assert(Args.size() && "Invalid number of arguments!");
1253 
1255 
1256  // First element is always return type. For 'void' functions it is NULL.
1257  Elts.push_back(Args[0]);
1258 
1259  // "this" pointer is always first argument.
1260  const CXXRecordDecl *RD = ThisPtr->getPointeeCXXRecordDecl();
1261  if (isa<ClassTemplateSpecializationDecl>(RD)) {
1262  // Create pointer type directly in this case.
1263  const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1264  QualType PointeeTy = ThisPtrTy->getPointeeType();
1265  unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy);
1266  uint64_t Size = CGM.getTarget().getPointerWidth(AS);
1267  auto Align = getTypeAlignIfRequired(ThisPtrTy, CGM.getContext());
1268  llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1269  llvm::DIType *ThisPtrType =
1270  DBuilder.createPointerType(PointeeType, Size, Align);
1271  TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1272  // TODO: This and the artificial type below are misleading, the
1273  // types aren't artificial the argument is, but the current
1274  // metadata doesn't represent that.
1275  ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1276  Elts.push_back(ThisPtrType);
1277  } else {
1278  llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1279  TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType);
1280  ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1281  Elts.push_back(ThisPtrType);
1282  }
1283 
1284  // Copy rest of the arguments.
1285  for (unsigned i = 1, e = Args.size(); i != e; ++i)
1286  Elts.push_back(Args[i]);
1287 
1288  llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1289 
1290  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1291  if (Func->getExtProtoInfo().RefQualifier == RQ_LValue)
1292  Flags |= llvm::DINode::FlagLValueReference;
1293  if (Func->getExtProtoInfo().RefQualifier == RQ_RValue)
1294  Flags |= llvm::DINode::FlagRValueReference;
1295 
1296  return DBuilder.createSubroutineType(EltTypeArray, Flags,
1297  getDwarfCC(Func->getCallConv()));
1298 }
1299 
1300 /// isFunctionLocalClass - Return true if CXXRecordDecl is defined
1301 /// inside a function.
1302 static bool isFunctionLocalClass(const CXXRecordDecl *RD) {
1303  if (const auto *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext()))
1304  return isFunctionLocalClass(NRD);
1305  if (isa<FunctionDecl>(RD->getDeclContext()))
1306  return true;
1307  return false;
1308 }
1309 
1310 llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1311  const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1312  bool IsCtorOrDtor =
1313  isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1314 
1315  StringRef MethodName = getFunctionName(Method);
1316  llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);
1317 
1318  // Since a single ctor/dtor corresponds to multiple functions, it doesn't
1319  // make sense to give a single ctor/dtor a linkage name.
1320  StringRef MethodLinkageName;
1321  // FIXME: 'isFunctionLocalClass' seems like an arbitrary/unintentional
1322  // property to use here. It may've been intended to model "is non-external
1323  // type" but misses cases of non-function-local but non-external classes such
1324  // as those in anonymous namespaces as well as the reverse - external types
1325  // that are function local, such as those in (non-local) inline functions.
1326  if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent()))
1327  MethodLinkageName = CGM.getMangledName(Method);
1328 
1329  // Get the location for the method.
1330  llvm::DIFile *MethodDefUnit = nullptr;
1331  unsigned MethodLine = 0;
1332  if (!Method->isImplicit()) {
1333  MethodDefUnit = getOrCreateFile(Method->getLocation());
1334  MethodLine = getLineNumber(Method->getLocation());
1335  }
1336 
1337  // Collect virtual method info.
1338  llvm::DIType *ContainingType = nullptr;
1339  unsigned Virtuality = 0;
1340  unsigned VIndex = 0;
1341  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1342  int ThisAdjustment = 0;
1343 
1344  if (Method->isVirtual()) {
1345  if (Method->isPure())
1346  Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual;
1347  else
1348  Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
1349 
1350  if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1351  // It doesn't make sense to give a virtual destructor a vtable index,
1352  // since a single destructor has two entries in the vtable.
1353  if (!isa<CXXDestructorDecl>(Method))
1354  VIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(Method);
1355  } else {
1356  // Emit MS ABI vftable information. There is only one entry for the
1357  // deleting dtor.
1358  const auto *DD = dyn_cast<CXXDestructorDecl>(Method);
1359  GlobalDecl GD = DD ? GlobalDecl(DD, Dtor_Deleting) : GlobalDecl(Method);
1362  VIndex = ML.Index;
1363 
1364  // CodeView only records the vftable offset in the class that introduces
1365  // the virtual method. This is possible because, unlike Itanium, the MS
1366  // C++ ABI does not include all virtual methods from non-primary bases in
1367  // the vtable for the most derived class. For example, if C inherits from
1368  // A and B, C's primary vftable will not include B's virtual methods.
1369  if (Method->begin_overridden_methods() == Method->end_overridden_methods())
1370  Flags |= llvm::DINode::FlagIntroducedVirtual;
1371 
1372  // The 'this' adjustment accounts for both the virtual and non-virtual
1373  // portions of the adjustment. Presumably the debugger only uses it when
1374  // it knows the dynamic type of an object.
1375  ThisAdjustment = CGM.getCXXABI()
1377  .getQuantity();
1378  }
1379  ContainingType = RecordTy;
1380  }
1381 
1382  if (Method->isImplicit())
1383  Flags |= llvm::DINode::FlagArtificial;
1384  Flags |= getAccessFlag(Method->getAccess(), Method->getParent());
1385  if (const auto *CXXC = dyn_cast<CXXConstructorDecl>(Method)) {
1386  if (CXXC->isExplicit())
1387  Flags |= llvm::DINode::FlagExplicit;
1388  } else if (const auto *CXXC = dyn_cast<CXXConversionDecl>(Method)) {
1389  if (CXXC->isExplicit())
1390  Flags |= llvm::DINode::FlagExplicit;
1391  }
1392  if (Method->hasPrototype())
1393  Flags |= llvm::DINode::FlagPrototyped;
1394  if (Method->getRefQualifier() == RQ_LValue)
1395  Flags |= llvm::DINode::FlagLValueReference;
1396  if (Method->getRefQualifier() == RQ_RValue)
1397  Flags |= llvm::DINode::FlagRValueReference;
1398 
1399  llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1400  llvm::DISubprogram *SP = DBuilder.createMethod(
1401  RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
1402  MethodTy, /*isLocalToUnit=*/false, /*isDefinition=*/false, Virtuality,
1403  VIndex, ThisAdjustment, ContainingType, Flags, CGM.getLangOpts().Optimize,
1404  TParamsArray.get());
1405 
1406  SPCache[Method->getCanonicalDecl()].reset(SP);
1407 
1408  return SP;
1409 }
1410 
1411 void CGDebugInfo::CollectCXXMemberFunctions(
1412  const CXXRecordDecl *RD, llvm::DIFile *Unit,
1413  SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) {
1414 
1415  // Since we want more than just the individual member decls if we
1416  // have templated functions iterate over every declaration to gather
1417  // the functions.
1418  for (const auto *I : RD->decls()) {
1419  const auto *Method = dyn_cast<CXXMethodDecl>(I);
1420  // If the member is implicit, don't add it to the member list. This avoids
1421  // the member being added to type units by LLVM, while still allowing it
1422  // to be emitted into the type declaration/reference inside the compile
1423  // unit.
1424  // Ditto 'nodebug' methods, for consistency with CodeGenFunction.cpp.
1425  // FIXME: Handle Using(Shadow?)Decls here to create
1426  // DW_TAG_imported_declarations inside the class for base decls brought into
1427  // derived classes. GDB doesn't seem to notice/leverage these when I tried
1428  // it, so I'm not rushing to fix this. (GCC seems to produce them, if
1429  // referenced)
1430  if (!Method || Method->isImplicit() || Method->hasAttr<NoDebugAttr>())
1431  continue;
1432 
1433  if (Method->getType()->getAs<FunctionProtoType>()->getContainedAutoType())
1434  continue;
1435 
1436  // Reuse the existing member function declaration if it exists.
1437  // It may be associated with the declaration of the type & should be
1438  // reused as we're building the definition.
1439  //
1440  // This situation can arise in the vtable-based debug info reduction where
1441  // implicit members are emitted in a non-vtable TU.
1442  auto MI = SPCache.find(Method->getCanonicalDecl());
1443  EltTys.push_back(MI == SPCache.end()
1444  ? CreateCXXMemberFunction(Method, Unit, RecordTy)
1445  : static_cast<llvm::Metadata *>(MI->second));
1446  }
1447 }
1448 
1449 void CGDebugInfo::CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile *Unit,
1451  llvm::DIType *RecordTy) {
1453  CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->bases(), SeenTypes,
1454  llvm::DINode::FlagZero);
1455 
1456  // If we are generating CodeView debug info, we also need to emit records for
1457  // indirect virtual base classes.
1458  if (CGM.getCodeGenOpts().EmitCodeView) {
1459  CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->vbases(), SeenTypes,
1460  llvm::DINode::FlagIndirectVirtualBase);
1461  }
1462 }
1463 
1464 void CGDebugInfo::CollectCXXBasesAux(
1465  const CXXRecordDecl *RD, llvm::DIFile *Unit,
1466  SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy,
1469  llvm::DINode::DIFlags StartingFlags) {
1470  const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1471  for (const auto &BI : Bases) {
1472  const auto *Base =
1473  cast<CXXRecordDecl>(BI.getType()->getAs<RecordType>()->getDecl());
1474  if (!SeenTypes.insert(Base).second)
1475  continue;
1476  auto *BaseTy = getOrCreateType(BI.getType(), Unit);
1477  llvm::DINode::DIFlags BFlags = StartingFlags;
1478  uint64_t BaseOffset;
1479 
1480  if (BI.isVirtual()) {
1481  if (CGM.getTarget().getCXXABI().isItaniumFamily()) {
1482  // virtual base offset offset is -ve. The code generator emits dwarf
1483  // expression where it expects +ve number.
1484  BaseOffset = 0 - CGM.getItaniumVTableContext()
1486  .getQuantity();
1487  } else {
1488  // In the MS ABI, store the vbtable offset, which is analogous to the
1489  // vbase offset offset in Itanium.
1490  BaseOffset =
1492  }
1493  BFlags |= llvm::DINode::FlagVirtual;
1494  } else
1495  BaseOffset = CGM.getContext().toBits(RL.getBaseClassOffset(Base));
1496  // FIXME: Inconsistent units for BaseOffset. It is in bytes when
1497  // BI->isVirtual() and bits when not.
1498 
1499  BFlags |= getAccessFlag(BI.getAccessSpecifier(), RD);
1500  llvm::DIType *DTy =
1501  DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset, BFlags);
1502  EltTys.push_back(DTy);
1503  }
1504 }
1505 
1506 llvm::DINodeArray
1507 CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList,
1509  llvm::DIFile *Unit) {
1510  SmallVector<llvm::Metadata *, 16> TemplateParams;
1511  for (unsigned i = 0, e = TAList.size(); i != e; ++i) {
1512  const TemplateArgument &TA = TAList[i];
1513  StringRef Name;
1514  if (TPList)
1515  Name = TPList->getParam(i)->getName();
1516  switch (TA.getKind()) {
1517  case TemplateArgument::Type: {
1518  llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit);
1519  TemplateParams.push_back(
1520  DBuilder.createTemplateTypeParameter(TheCU, Name, TTy));
1521  } break;
1523  llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit);
1524  TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1525  TheCU, Name, TTy,
1526  llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral())));
1527  } break;
1529  const ValueDecl *D = TA.getAsDecl();
1531  llvm::DIType *TTy = getOrCreateType(T, Unit);
1532  llvm::Constant *V = nullptr;
1533  const CXXMethodDecl *MD;
1534  // Variable pointer template parameters have a value that is the address
1535  // of the variable.
1536  if (const auto *VD = dyn_cast<VarDecl>(D))
1537  V = CGM.GetAddrOfGlobalVar(VD);
1538  // Member function pointers have special support for building them, though
1539  // this is currently unsupported in LLVM CodeGen.
1540  else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->isInstance())
1541  V = CGM.getCXXABI().EmitMemberFunctionPointer(MD);
1542  else if (const auto *FD = dyn_cast<FunctionDecl>(D))
1543  V = CGM.GetAddrOfFunction(FD);
1544  // Member data pointers have special handling too to compute the fixed
1545  // offset within the object.
1546  else if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr())) {
1547  // These five lines (& possibly the above member function pointer
1548  // handling) might be able to be refactored to use similar code in
1549  // CodeGenModule::getMemberPointerConstant
1550  uint64_t fieldOffset = CGM.getContext().getFieldOffset(D);
1551  CharUnits chars =
1552  CGM.getContext().toCharUnitsFromBits((int64_t)fieldOffset);
1553  V = CGM.getCXXABI().EmitMemberDataPointer(MPT, chars);
1554  }
1555  TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1556  TheCU, Name, TTy,
1557  cast_or_null<llvm::Constant>(V->stripPointerCasts())));
1558  } break;
1560  QualType T = TA.getNullPtrType();
1561  llvm::DIType *TTy = getOrCreateType(T, Unit);
1562  llvm::Constant *V = nullptr;
1563  // Special case member data pointer null values since they're actually -1
1564  // instead of zero.
1565  if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr()))
1566  // But treat member function pointers as simple zero integers because
1567  // it's easier than having a special case in LLVM's CodeGen. If LLVM
1568  // CodeGen grows handling for values of non-null member function
1569  // pointers then perhaps we could remove this special case and rely on
1570  // EmitNullMemberPointer for member function pointers.
1571  if (MPT->isMemberDataPointer())
1572  V = CGM.getCXXABI().EmitNullMemberPointer(MPT);
1573  if (!V)
1574  V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
1575  TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1576  TheCU, Name, TTy, V));
1577  } break;
1579  TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
1580  TheCU, Name, nullptr,
1582  break;
1584  TemplateParams.push_back(DBuilder.createTemplateParameterPack(
1585  TheCU, Name, nullptr,
1586  CollectTemplateParams(nullptr, TA.getPackAsArray(), Unit)));
1587  break;
1589  const Expr *E = TA.getAsExpr();
1590  QualType T = E->getType();
1591  if (E->isGLValue())
1592  T = CGM.getContext().getLValueReferenceType(T);
1593  llvm::Constant *V = CGM.EmitConstantExpr(E, T);
1594  assert(V && "Expression in template argument isn't constant");
1595  llvm::DIType *TTy = getOrCreateType(T, Unit);
1596  TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1597  TheCU, Name, TTy, V->stripPointerCasts()));
1598  } break;
1599  // And the following should never occur:
1602  llvm_unreachable(
1603  "These argument types shouldn't exist in concrete types");
1604  }
1605  }
1606  return DBuilder.getOrCreateArray(TemplateParams);
1607 }
1608 
1609 llvm::DINodeArray
1610 CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD,
1611  llvm::DIFile *Unit) {
1612  if (FD->getTemplatedKind() ==
1615  ->getTemplate()
1617  return CollectTemplateParams(
1618  TList, FD->getTemplateSpecializationArgs()->asArray(), Unit);
1619  }
1620  return llvm::DINodeArray();
1621 }
1622 
1623 llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
1624  const ClassTemplateSpecializationDecl *TSpecial, llvm::DIFile *Unit) {
1625  // Always get the full list of parameters, not just the ones from
1626  // the specialization.
1627  TemplateParameterList *TPList =
1629  const TemplateArgumentList &TAList = TSpecial->getTemplateArgs();
1630  return CollectTemplateParams(TPList, TAList.asArray(), Unit);
1631 }
1632 
1633 llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
1634  if (VTablePtrType)
1635  return VTablePtrType;
1636 
1637  ASTContext &Context = CGM.getContext();
1638 
1639  /* Function type */
1640  llvm::Metadata *STy = getOrCreateType(Context.IntTy, Unit);
1641  llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
1642  llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
1643  unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
1644  unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
1645  Optional<unsigned> DWARFAddressSpace =
1646  CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
1647 
1648  llvm::DIType *vtbl_ptr_type =
1649  DBuilder.createPointerType(SubTy, Size, 0, DWARFAddressSpace,
1650  "__vtbl_ptr_type");
1651  VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
1652  return VTablePtrType;
1653 }
1654 
1655 StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
1656  // Copy the gdb compatible name on the side and use its reference.
1657  return internString("_vptr$", RD->getNameAsString());
1658 }
1659 
1660 void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit,
1662  llvm::DICompositeType *RecordTy) {
1663  // If this class is not dynamic then there is not any vtable info to collect.
1664  if (!RD->isDynamicClass())
1665  return;
1666 
1667  // Don't emit any vtable shape or vptr info if this class doesn't have an
1668  // extendable vfptr. This can happen if the class doesn't have virtual
1669  // methods, or in the MS ABI if those virtual methods only come from virtually
1670  // inherited bases.
1671  const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
1672  if (!RL.hasExtendableVFPtr())
1673  return;
1674 
1675  // CodeView needs to know how large the vtable of every dynamic class is, so
1676  // emit a special named pointer type into the element list. The vptr type
1677  // points to this type as well.
1678  llvm::DIType *VPtrTy = nullptr;
1679  bool NeedVTableShape = CGM.getCodeGenOpts().EmitCodeView &&
1680  CGM.getTarget().getCXXABI().isMicrosoft();
1681  if (NeedVTableShape) {
1682  uint64_t PtrWidth =
1684  const VTableLayout &VFTLayout =
1686  unsigned VSlotCount =
1687  VFTLayout.vtable_components().size() - CGM.getLangOpts().RTTIData;
1688  unsigned VTableWidth = PtrWidth * VSlotCount;
1689  unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace();
1690  Optional<unsigned> DWARFAddressSpace =
1691  CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace);
1692 
1693  // Create a very wide void* type and insert it directly in the element list.
1694  llvm::DIType *VTableType =
1695  DBuilder.createPointerType(nullptr, VTableWidth, 0, DWARFAddressSpace,
1696  "__vtbl_ptr_type");
1697  EltTys.push_back(VTableType);
1698 
1699  // The vptr is a pointer to this special vtable type.
1700  VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);
1701  }
1702 
1703  // If there is a primary base then the artificial vptr member lives there.
1704  if (RL.getPrimaryBase())
1705  return;
1706 
1707  if (!VPtrTy)
1708  VPtrTy = getOrCreateVTablePtrType(Unit);
1709 
1710  unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
1711  llvm::DIType *VPtrMember = DBuilder.createMemberType(
1712  Unit, getVTableName(RD), Unit, 0, Size, 0, 0,
1713  llvm::DINode::FlagArtificial, VPtrTy);
1714  EltTys.push_back(VPtrMember);
1715 }
1716 
1718  SourceLocation Loc) {
1719  assert(DebugKind >= codegenoptions::LimitedDebugInfo);
1720  llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
1721  return T;
1722 }
1723 
1725  SourceLocation Loc) {
1726  return getOrCreateStandaloneType(D, Loc);
1727 }
1728 
1730  SourceLocation Loc) {
1731  assert(DebugKind >= codegenoptions::LimitedDebugInfo);
1732  assert(!D.isNull() && "null type");
1733  llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
1734  assert(T && "could not create debug info for type");
1735 
1736  RetainedTypes.push_back(D.getAsOpaquePtr());
1737  return T;
1738 }
1739 
1741  if (DebugKind <= codegenoptions::DebugLineTablesOnly)
1742  return;
1743  QualType Ty = CGM.getContext().getEnumType(ED);
1744  void *TyPtr = Ty.getAsOpaquePtr();
1745  auto I = TypeCache.find(TyPtr);
1746  if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl())
1747  return;
1748  llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<EnumType>());
1749  assert(!Res->isForwardDecl());
1750  TypeCache[TyPtr].reset(Res);
1751 }
1752 
1754  if (DebugKind > codegenoptions::LimitedDebugInfo ||
1755  !CGM.getLangOpts().CPlusPlus)
1757 }
1758 
1759 /// Return true if the class or any of its methods are marked dllimport.
1760 static bool isClassOrMethodDLLImport(const CXXRecordDecl *RD) {
1761  if (RD->hasAttr<DLLImportAttr>())
1762  return true;
1763  for (const CXXMethodDecl *MD : RD->methods())
1764  if (MD->hasAttr<DLLImportAttr>())
1765  return true;
1766  return false;
1767 }
1768 
1770  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1771  if (CXXRD->isDynamicClass() &&
1772  CGM.getVTableLinkage(CXXRD) ==
1773  llvm::GlobalValue::AvailableExternallyLinkage &&
1774  !isClassOrMethodDLLImport(CXXRD))
1775  return;
1776  completeClass(RD);
1777 }
1778 
1780  if (DebugKind <= codegenoptions::DebugLineTablesOnly)
1781  return;
1782  QualType Ty = CGM.getContext().getRecordType(RD);
1783  void *TyPtr = Ty.getAsOpaquePtr();
1784  auto I = TypeCache.find(TyPtr);
1785  if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl())
1786  return;
1787  llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<RecordType>());
1788  assert(!Res->isForwardDecl());
1789  TypeCache[TyPtr].reset(Res);
1790 }
1791 
1794  for (CXXMethodDecl *MD : llvm::make_range(I, End))
1796  if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
1798  return true;
1799  return false;
1800 }
1801 
1802 /// Does a type definition exist in an imported clang module?
1803 static bool isDefinedInClangModule(const RecordDecl *RD) {
1804  // Only definitions that where imported from an AST file come from a module.
1805  if (!RD || !RD->isFromASTFile())
1806  return false;
1807  // Anonymous entities cannot be addressed. Treat them as not from module.
1808  if (!RD->isExternallyVisible() && RD->getName().empty())
1809  return false;
1810  if (auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {
1811  if (!CXXDecl->isCompleteDefinition())
1812  return false;
1813  auto TemplateKind = CXXDecl->getTemplateSpecializationKind();
1814  if (TemplateKind != TSK_Undeclared) {
1815  // This is a template, check the origin of the first member.
1816  if (CXXDecl->field_begin() == CXXDecl->field_end())
1817  return TemplateKind == TSK_ExplicitInstantiationDeclaration;
1818  if (!CXXDecl->field_begin()->isFromASTFile())
1819  return false;
1820  }
1821  }
1822  return true;
1823 }
1824 
1826  bool DebugTypeExtRefs, const RecordDecl *RD,
1827  const LangOptions &LangOpts) {
1828  if (DebugTypeExtRefs && isDefinedInClangModule(RD->getDefinition()))
1829  return true;
1830 
1831  if (auto *ES = RD->getASTContext().getExternalSource())
1832  if (ES->hasExternalDefinitions(RD) == ExternalASTSource::EK_Always)
1833  return true;
1834 
1835  if (DebugKind > codegenoptions::LimitedDebugInfo)
1836  return false;
1837 
1838  if (!LangOpts.CPlusPlus)
1839  return false;
1840 
1841  if (!RD->isCompleteDefinitionRequired())
1842  return true;
1843 
1844  const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1845 
1846  if (!CXXDecl)
1847  return false;
1848 
1849  // Only emit complete debug info for a dynamic class when its vtable is
1850  // emitted. However, Microsoft debuggers don't resolve type information
1851  // across DLL boundaries, so skip this optimization if the class or any of its
1852  // methods are marked dllimport. This isn't a complete solution, since objects
1853  // without any dllimport methods can be used in one DLL and constructed in
1854  // another, but it is the current behavior of LimitedDebugInfo.
1855  if (CXXDecl->hasDefinition() && CXXDecl->isDynamicClass() &&
1856  !isClassOrMethodDLLImport(CXXDecl))
1857  return true;
1858 
1860  if (const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
1861  Spec = SD->getSpecializationKind();
1862 
1865  CXXDecl->method_end()))
1866  return true;
1867 
1868  return false;
1869 }
1870 
1872  if (shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD, CGM.getLangOpts()))
1873  return;
1874 
1875  QualType Ty = CGM.getContext().getRecordType(RD);
1876  llvm::DIType *T = getTypeOrNull(Ty);
1877  if (T && T->isForwardDecl())
1878  completeClassData(RD);
1879 }
1880 
1881 llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) {
1882  RecordDecl *RD = Ty->getDecl();
1883  llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0)));
1884  if (T || shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD,
1885  CGM.getLangOpts())) {
1886  if (!T)
1887  T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
1888  return T;
1889  }
1890 
1891  return CreateTypeDefinition(Ty);
1892 }
1893 
1894 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) {
1895  RecordDecl *RD = Ty->getDecl();
1896 
1897  // Get overall information about the record type for the debug info.
1898  llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
1899 
1900  // Records and classes and unions can all be recursive. To handle them, we
1901  // first generate a debug descriptor for the struct as a forward declaration.
1902  // Then (if it is a definition) we go through and get debug info for all of
1903  // its members. Finally, we create a descriptor for the complete type (which
1904  // may refer to the forward decl if the struct is recursive) and replace all
1905  // uses of the forward declaration with the final definition.
1906  llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty, DefUnit);
1907 
1908  const RecordDecl *D = RD->getDefinition();
1909  if (!D || !D->isCompleteDefinition())
1910  return FwdDecl;
1911 
1912  if (const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
1913  CollectContainingType(CXXDecl, FwdDecl);
1914 
1915  // Push the struct on region stack.
1916  LexicalBlockStack.emplace_back(&*FwdDecl);
1917  RegionMap[Ty->getDecl()].reset(FwdDecl);
1918 
1919  // Convert all the elements.
1921  // what about nested types?
1922 
1923  // Note: The split of CXXDecl information here is intentional, the
1924  // gdb tests will depend on a certain ordering at printout. The debug
1925  // information offsets are still correct if we merge them all together
1926  // though.
1927  const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
1928  if (CXXDecl) {
1929  CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
1930  CollectVTableInfo(CXXDecl, DefUnit, EltTys, FwdDecl);
1931  }
1932 
1933  // Collect data fields (including static variables and any initializers).
1934  CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
1935  if (CXXDecl)
1936  CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
1937 
1938  LexicalBlockStack.pop_back();
1939  RegionMap.erase(Ty->getDecl());
1940 
1941  llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
1942  DBuilder.replaceArrays(FwdDecl, Elements);
1943 
1944  if (FwdDecl->isTemporary())
1945  FwdDecl =
1946  llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
1947 
1948  RegionMap[Ty->getDecl()].reset(FwdDecl);
1949  return FwdDecl;
1950 }
1951 
1952 llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty,
1953  llvm::DIFile *Unit) {
1954  // Ignore protocols.
1955  return getOrCreateType(Ty->getBaseType(), Unit);
1956 }
1957 
1958 llvm::DIType *CGDebugInfo::CreateType(const ObjCTypeParamType *Ty,
1959  llvm::DIFile *Unit) {
1960  // Ignore protocols.
1961  SourceLocation Loc = Ty->getDecl()->getLocation();
1962 
1963  // Use Typedefs to represent ObjCTypeParamType.
1964  return DBuilder.createTypedef(
1965  getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit),
1966  Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc),
1967  getDeclContextDescriptor(Ty->getDecl()));
1968 }
1969 
1970 /// \return true if Getter has the default name for the property PD.
1972  const ObjCMethodDecl *Getter) {
1973  assert(PD);
1974  if (!Getter)
1975  return true;
1976 
1977  assert(Getter->getDeclName().isObjCZeroArgSelector());
1978  return PD->getName() ==
1980 }
1981 
1982 /// \return true if Setter has the default name for the property PD.
1984  const ObjCMethodDecl *Setter) {
1985  assert(PD);
1986  if (!Setter)
1987  return true;
1988 
1989  assert(Setter->getDeclName().isObjCOneArgSelector());
1992 }
1993 
1994 llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
1995  llvm::DIFile *Unit) {
1996  ObjCInterfaceDecl *ID = Ty->getDecl();
1997  if (!ID)
1998  return nullptr;
1999 
2000  // Return a forward declaration if this type was imported from a clang module,
2001  // and this is not the compile unit with the implementation of the type (which
2002  // may contain hidden ivars).
2003  if (DebugTypeExtRefs && ID->isFromASTFile() && ID->getDefinition() &&
2004  !ID->getImplementation())
2005  return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
2006  ID->getName(),
2007  getDeclContextDescriptor(ID), Unit, 0);
2008 
2009  // Get overall information about the record type for the debug info.
2010  llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
2011  unsigned Line = getLineNumber(ID->getLocation());
2012  auto RuntimeLang =
2013  static_cast<llvm::dwarf::SourceLanguage>(TheCU->getSourceLanguage());
2014 
2015  // If this is just a forward declaration return a special forward-declaration
2016  // debug type since we won't be able to lay out the entire type.
2017  ObjCInterfaceDecl *Def = ID->getDefinition();
2018  if (!Def || !Def->getImplementation()) {
2019  llvm::DIScope *Mod = getParentModuleOrNull(ID);
2020  llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType(
2021  llvm::dwarf::DW_TAG_structure_type, ID->getName(), Mod ? Mod : TheCU,
2022  DefUnit, Line, RuntimeLang);
2023  ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit));
2024  return FwdDecl;
2025  }
2026 
2027  return CreateTypeDefinition(Ty, Unit);
2028 }
2029 
2030 llvm::DIModule *
2031 CGDebugInfo::getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod,
2032  bool CreateSkeletonCU) {
2033  // Use the Module pointer as the key into the cache. This is a
2034  // nullptr if the "Module" is a PCH, which is safe because we don't
2035  // support chained PCH debug info, so there can only be a single PCH.
2036  const Module *M = Mod.getModuleOrNull();
2037  auto ModRef = ModuleCache.find(M);
2038  if (ModRef != ModuleCache.end())
2039  return cast<llvm::DIModule>(ModRef->second);
2040 
2041  // Macro definitions that were defined with "-D" on the command line.
2042  SmallString<128> ConfigMacros;
2043  {
2044  llvm::raw_svector_ostream OS(ConfigMacros);
2045  const auto &PPOpts = CGM.getPreprocessorOpts();
2046  unsigned I = 0;
2047  // Translate the macro definitions back into a commmand line.
2048  for (auto &M : PPOpts.Macros) {
2049  if (++I > 1)
2050  OS << " ";
2051  const std::string &Macro = M.first;
2052  bool Undef = M.second;
2053  OS << "\"-" << (Undef ? 'U' : 'D');
2054  for (char c : Macro)
2055  switch (c) {
2056  case '\\' : OS << "\\\\"; break;
2057  case '"' : OS << "\\\""; break;
2058  default: OS << c;
2059  }
2060  OS << '\"';
2061  }
2062  }
2063 
2064  bool IsRootModule = M ? !M->Parent : true;
2065  if (CreateSkeletonCU && IsRootModule) {
2066  // PCH files don't have a signature field in the control block,
2067  // but LLVM detects skeleton CUs by looking for a non-zero DWO id.
2068  // We use the lower 64 bits for debug info.
2069  uint64_t Signature =
2070  Mod.getSignature()
2071  ? (uint64_t)Mod.getSignature()[1] << 32 | Mod.getSignature()[0]
2072  : ~1ULL;
2073  llvm::DIBuilder DIB(CGM.getModule());
2074  DIB.createCompileUnit(TheCU->getSourceLanguage(),
2075  DIB.createFile(Mod.getModuleName(), Mod.getPath()),
2076  TheCU->getProducer(), true, StringRef(), 0,
2077  Mod.getASTFile(), llvm::DICompileUnit::FullDebug,
2078  Signature);
2079  DIB.finalize();
2080  }
2081  llvm::DIModule *Parent =
2082  IsRootModule ? nullptr
2083  : getOrCreateModuleRef(
2085  CreateSkeletonCU);
2086  llvm::DIModule *DIMod =
2087  DBuilder.createModule(Parent, Mod.getModuleName(), ConfigMacros,
2088  Mod.getPath(), CGM.getHeaderSearchOpts().Sysroot);
2089  ModuleCache[M].reset(DIMod);
2090  return DIMod;
2091 }
2092 
2093 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty,
2094  llvm::DIFile *Unit) {
2095  ObjCInterfaceDecl *ID = Ty->getDecl();
2096  llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation());
2097  unsigned Line = getLineNumber(ID->getLocation());
2098  unsigned RuntimeLang = TheCU->getSourceLanguage();
2099 
2100  // Bit size, align and offset of the type.
2101  uint64_t Size = CGM.getContext().getTypeSize(Ty);
2102  auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2103 
2104  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2105  if (ID->getImplementation())
2106  Flags |= llvm::DINode::FlagObjcClassComplete;
2107 
2108  llvm::DIScope *Mod = getParentModuleOrNull(ID);
2109  llvm::DICompositeType *RealDecl = DBuilder.createStructType(
2110  Mod ? Mod : Unit, ID->getName(), DefUnit, Line, Size, Align, Flags,
2111  nullptr, llvm::DINodeArray(), RuntimeLang);
2112 
2113  QualType QTy(Ty, 0);
2114  TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
2115 
2116  // Push the struct on region stack.
2117  LexicalBlockStack.emplace_back(RealDecl);
2118  RegionMap[Ty->getDecl()].reset(RealDecl);
2119 
2120  // Convert all the elements.
2122 
2123  ObjCInterfaceDecl *SClass = ID->getSuperClass();
2124  if (SClass) {
2125  llvm::DIType *SClassTy =
2126  getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
2127  if (!SClassTy)
2128  return nullptr;
2129 
2130  llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0,
2131  llvm::DINode::FlagZero);
2132  EltTys.push_back(InhTag);
2133  }
2134 
2135  // Create entries for all of the properties.
2136  auto AddProperty = [&](const ObjCPropertyDecl *PD) {
2137  SourceLocation Loc = PD->getLocation();
2138  llvm::DIFile *PUnit = getOrCreateFile(Loc);
2139  unsigned PLine = getLineNumber(Loc);
2140  ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
2141  ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
2142  llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
2143  PD->getName(), PUnit, PLine,
2144  hasDefaultGetterName(PD, Getter) ? ""
2145  : getSelectorName(PD->getGetterName()),
2146  hasDefaultSetterName(PD, Setter) ? ""
2147  : getSelectorName(PD->getSetterName()),
2148  PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
2149  EltTys.push_back(PropertyNode);
2150  };
2151  {
2152  llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
2153  for (const ObjCCategoryDecl *ClassExt : ID->known_extensions())
2154  for (auto *PD : ClassExt->properties()) {
2155  PropertySet.insert(PD->getIdentifier());
2156  AddProperty(PD);
2157  }
2158  for (const auto *PD : ID->properties()) {
2159  // Don't emit duplicate metadata for properties that were already in a
2160  // class extension.
2161  if (!PropertySet.insert(PD->getIdentifier()).second)
2162  continue;
2163  AddProperty(PD);
2164  }
2165  }
2166 
2168  unsigned FieldNo = 0;
2169  for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field;
2170  Field = Field->getNextIvar(), ++FieldNo) {
2171  llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
2172  if (!FieldTy)
2173  return nullptr;
2174 
2175  StringRef FieldName = Field->getName();
2176 
2177  // Ignore unnamed fields.
2178  if (FieldName.empty())
2179  continue;
2180 
2181  // Get the location for the field.
2182  llvm::DIFile *FieldDefUnit = getOrCreateFile(Field->getLocation());
2183  unsigned FieldLine = getLineNumber(Field->getLocation());
2184  QualType FType = Field->getType();
2185  uint64_t FieldSize = 0;
2186  uint32_t FieldAlign = 0;
2187 
2188  if (!FType->isIncompleteArrayType()) {
2189 
2190  // Bit size, align and offset of the type.
2191  FieldSize = Field->isBitField()
2192  ? Field->getBitWidthValue(CGM.getContext())
2193  : CGM.getContext().getTypeSize(FType);
2194  FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext());
2195  }
2196 
2197  uint64_t FieldOffset;
2198  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2199  // We don't know the runtime offset of an ivar if we're using the
2200  // non-fragile ABI. For bitfields, use the bit offset into the first
2201  // byte of storage of the bitfield. For other fields, use zero.
2202  if (Field->isBitField()) {
2203  FieldOffset =
2204  CGM.getObjCRuntime().ComputeBitfieldBitOffset(CGM, ID, Field);
2205  FieldOffset %= CGM.getContext().getCharWidth();
2206  } else {
2207  FieldOffset = 0;
2208  }
2209  } else {
2210  FieldOffset = RL.getFieldOffset(FieldNo);
2211  }
2212 
2213  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2214  if (Field->getAccessControl() == ObjCIvarDecl::Protected)
2215  Flags = llvm::DINode::FlagProtected;
2216  else if (Field->getAccessControl() == ObjCIvarDecl::Private)
2217  Flags = llvm::DINode::FlagPrivate;
2218  else if (Field->getAccessControl() == ObjCIvarDecl::Public)
2219  Flags = llvm::DINode::FlagPublic;
2220 
2221  llvm::MDNode *PropertyNode = nullptr;
2222  if (ObjCImplementationDecl *ImpD = ID->getImplementation()) {
2223  if (ObjCPropertyImplDecl *PImpD =
2224  ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
2225  if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) {
2226  SourceLocation Loc = PD->getLocation();
2227  llvm::DIFile *PUnit = getOrCreateFile(Loc);
2228  unsigned PLine = getLineNumber(Loc);
2229  ObjCMethodDecl *Getter = PD->getGetterMethodDecl();
2230  ObjCMethodDecl *Setter = PD->getSetterMethodDecl();
2231  PropertyNode = DBuilder.createObjCProperty(
2232  PD->getName(), PUnit, PLine,
2233  hasDefaultGetterName(PD, Getter) ? "" : getSelectorName(
2234  PD->getGetterName()),
2235  hasDefaultSetterName(PD, Setter) ? "" : getSelectorName(
2236  PD->getSetterName()),
2237  PD->getPropertyAttributes(),
2238  getOrCreateType(PD->getType(), PUnit));
2239  }
2240  }
2241  }
2242  FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
2243  FieldSize, FieldAlign, FieldOffset, Flags,
2244  FieldTy, PropertyNode);
2245  EltTys.push_back(FieldTy);
2246  }
2247 
2248  llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2249  DBuilder.replaceArrays(RealDecl, Elements);
2250 
2251  LexicalBlockStack.pop_back();
2252  return RealDecl;
2253 }
2254 
2255 llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty,
2256  llvm::DIFile *Unit) {
2257  llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit);
2258  int64_t Count = Ty->getNumElements();
2259  if (Count == 0)
2260  // If number of elements are not known then this is an unbounded array.
2261  // Use Count == -1 to express such arrays.
2262  Count = -1;
2263 
2264  llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(0, Count);
2265  llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
2266 
2267  uint64_t Size = CGM.getContext().getTypeSize(Ty);
2268  auto Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2269 
2270  return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
2271 }
2272 
2273 llvm::DIType *CGDebugInfo::CreateType(const ArrayType *Ty, llvm::DIFile *Unit) {
2274  uint64_t Size;
2275  uint32_t Align;
2276 
2277  // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
2278  if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
2279  Size = 0;
2281  CGM.getContext());
2282  } else if (Ty->isIncompleteArrayType()) {
2283  Size = 0;
2284  if (Ty->getElementType()->isIncompleteType())
2285  Align = 0;
2286  else
2287  Align = getTypeAlignIfRequired(Ty->getElementType(), CGM.getContext());
2288  } else if (Ty->isIncompleteType()) {
2289  Size = 0;
2290  Align = 0;
2291  } else {
2292  // Size and align of the whole array, not the element type.
2293  Size = CGM.getContext().getTypeSize(Ty);
2294  Align = getTypeAlignIfRequired(Ty, CGM.getContext());
2295  }
2296 
2297  // Add the dimensions of the array. FIXME: This loses CV qualifiers from
2298  // interior arrays, do we care? Why aren't nested arrays represented the
2299  // obvious/recursive way?
2301  QualType EltTy(Ty, 0);
2302  while ((Ty = dyn_cast<ArrayType>(EltTy))) {
2303  // If the number of elements is known, then count is that number. Otherwise,
2304  // it's -1. This allows us to represent a subrange with an array of 0
2305  // elements, like this:
2306  //
2307  // struct foo {
2308  // int x[0];
2309  // };
2310  int64_t Count = -1; // Count == -1 is an unbounded array.
2311  if (const auto *CAT = dyn_cast<ConstantArrayType>(Ty))
2312  Count = CAT->getSize().getZExtValue();
2313  else if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
2314  if (Expr *Size = VAT->getSizeExpr()) {
2315  llvm::APSInt V;
2316  if (Size->EvaluateAsInt(V, CGM.getContext()))
2317  Count = V.getExtValue();
2318  }
2319  }
2320 
2321  // FIXME: Verify this is right for VLAs.
2322  Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count));
2323  EltTy = Ty->getElementType();
2324  }
2325 
2326  llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
2327 
2328  return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
2329  SubscriptArray);
2330 }
2331 
2332 llvm::DIType *CGDebugInfo::CreateType(const LValueReferenceType *Ty,
2333  llvm::DIFile *Unit) {
2334  return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
2335  Ty->getPointeeType(), Unit);
2336 }
2337 
2338 llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty,
2339  llvm::DIFile *Unit) {
2340  return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, Ty,
2341  Ty->getPointeeType(), Unit);
2342 }
2343 
2344 llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty,
2345  llvm::DIFile *U) {
2346  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2347  uint64_t Size = 0;
2348 
2349  if (!Ty->isIncompleteType()) {
2350  Size = CGM.getContext().getTypeSize(Ty);
2351 
2352  // Set the MS inheritance model. There is no flag for the unspecified model.
2353  if (CGM.getTarget().getCXXABI().isMicrosoft()) {
2355  case MSInheritanceAttr::Keyword_single_inheritance:
2356  Flags |= llvm::DINode::FlagSingleInheritance;
2357  break;
2358  case MSInheritanceAttr::Keyword_multiple_inheritance:
2359  Flags |= llvm::DINode::FlagMultipleInheritance;
2360  break;
2361  case MSInheritanceAttr::Keyword_virtual_inheritance:
2362  Flags |= llvm::DINode::FlagVirtualInheritance;
2363  break;
2364  case MSInheritanceAttr::Keyword_unspecified_inheritance:
2365  break;
2366  }
2367  }
2368  }
2369 
2370  llvm::DIType *ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U);
2371  if (Ty->isMemberDataPointerType())
2372  return DBuilder.createMemberPointerType(
2373  getOrCreateType(Ty->getPointeeType(), U), ClassType, Size, /*Align=*/0,
2374  Flags);
2375 
2376  const FunctionProtoType *FPT =
2378  return DBuilder.createMemberPointerType(
2379  getOrCreateInstanceMethodType(CGM.getContext().getPointerType(QualType(
2380  Ty->getClass(), FPT->getTypeQuals())),
2381  FPT, U),
2382  ClassType, Size, /*Align=*/0, Flags);
2383 }
2384 
2385 llvm::DIType *CGDebugInfo::CreateType(const AtomicType *Ty, llvm::DIFile *U) {
2386  auto *FromTy = getOrCreateType(Ty->getValueType(), U);
2387  return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);
2388 }
2389 
2390 llvm::DIType* CGDebugInfo::CreateType(const PipeType *Ty,
2391  llvm::DIFile *U) {
2392  return getOrCreateType(Ty->getElementType(), U);
2393 }
2394 
2395 llvm::DIType *CGDebugInfo::CreateEnumType(const EnumType *Ty) {
2396  const EnumDecl *ED = Ty->getDecl();
2397 
2398  uint64_t Size = 0;
2399  uint32_t Align = 0;
2400  if (!ED->getTypeForDecl()->isIncompleteType()) {
2401  Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
2402  Align = getDeclAlignIfRequired(ED, CGM.getContext());
2403  }
2404 
2405  SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2406 
2407  bool isImportedFromModule =
2408  DebugTypeExtRefs && ED->isFromASTFile() && ED->getDefinition();
2409 
2410  // If this is just a forward declaration, construct an appropriately
2411  // marked node and just return it.
2412  if (isImportedFromModule || !ED->getDefinition()) {
2413  // Note that it is possible for enums to be created as part of
2414  // their own declcontext. In this case a FwdDecl will be created
2415  // twice. This doesn't cause a problem because both FwdDecls are
2416  // entered into the ReplaceMap: finalize() will replace the first
2417  // FwdDecl with the second and then replace the second with
2418  // complete type.
2419  llvm::DIScope *EDContext = getDeclContextDescriptor(ED);
2420  llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
2421  llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType(
2422  llvm::dwarf::DW_TAG_enumeration_type, "", TheCU, DefUnit, 0));
2423 
2424  unsigned Line = getLineNumber(ED->getLocation());
2425  StringRef EDName = ED->getName();
2426  llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType(
2427  llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line,
2428  0, Size, Align, llvm::DINode::FlagFwdDecl, FullName);
2429 
2430  ReplaceMap.emplace_back(
2431  std::piecewise_construct, std::make_tuple(Ty),
2432  std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
2433  return RetTy;
2434  }
2435 
2436  return CreateTypeDefinition(Ty);
2437 }
2438 
2439 llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) {
2440  const EnumDecl *ED = Ty->getDecl();
2441  uint64_t Size = 0;
2442  uint32_t Align = 0;
2443  if (!ED->getTypeForDecl()->isIncompleteType()) {
2444  Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
2445  Align = getDeclAlignIfRequired(ED, CGM.getContext());
2446  }
2447 
2448  SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2449 
2450  // Create elements for each enumerator.
2452  ED = ED->getDefinition();
2453  for (const auto *Enum : ED->enumerators()) {
2454  Enumerators.push_back(DBuilder.createEnumerator(
2455  Enum->getName(), Enum->getInitVal().getSExtValue()));
2456  }
2457 
2458  // Return a CompositeType for the enum itself.
2459  llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
2460 
2461  llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation());
2462  unsigned Line = getLineNumber(ED->getLocation());
2463  llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
2464  llvm::DIType *ClassTy =
2465  ED->isFixed() ? getOrCreateType(ED->getIntegerType(), DefUnit) : nullptr;
2466  return DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit,
2467  Line, Size, Align, EltArray, ClassTy,
2468  FullName);
2469 }
2470 
2471 llvm::DIMacro *CGDebugInfo::CreateMacro(llvm::DIMacroFile *Parent,
2472  unsigned MType, SourceLocation LineLoc,
2473  StringRef Name, StringRef Value) {
2474  unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc);
2475  return DBuilder.createMacro(Parent, Line, MType, Name, Value);
2476 }
2477 
2478 llvm::DIMacroFile *CGDebugInfo::CreateTempMacroFile(llvm::DIMacroFile *Parent,
2479  SourceLocation LineLoc,
2480  SourceLocation FileLoc) {
2481  llvm::DIFile *FName = getOrCreateFile(FileLoc);
2482  unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc);
2483  return DBuilder.createTempMacroFile(Parent, Line, FName);
2484 }
2485 
2487  Qualifiers Quals;
2488  do {
2489  Qualifiers InnerQuals = T.getLocalQualifiers();
2490  // Qualifiers::operator+() doesn't like it if you add a Qualifier
2491  // that is already there.
2492  Quals += Qualifiers::removeCommonQualifiers(Quals, InnerQuals);
2493  Quals += InnerQuals;
2494  QualType LastT = T;
2495  switch (T->getTypeClass()) {
2496  default:
2497  return C.getQualifiedType(T.getTypePtr(), Quals);
2498  case Type::TemplateSpecialization: {
2499  const auto *Spec = cast<TemplateSpecializationType>(T);
2500  if (Spec->isTypeAlias())
2501  return C.getQualifiedType(T.getTypePtr(), Quals);
2502  T = Spec->desugar();
2503  break;
2504  }
2505  case Type::TypeOfExpr:
2506  T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
2507  break;
2508  case Type::TypeOf:
2509  T = cast<TypeOfType>(T)->getUnderlyingType();
2510  break;
2511  case Type::Decltype:
2512  T = cast<DecltypeType>(T)->getUnderlyingType();
2513  break;
2514  case Type::UnaryTransform:
2515  T = cast<UnaryTransformType>(T)->getUnderlyingType();
2516  break;
2517  case Type::Attributed:
2518  T = cast<AttributedType>(T)->getEquivalentType();
2519  break;
2520  case Type::Elaborated:
2521  T = cast<ElaboratedType>(T)->getNamedType();
2522  break;
2523  case Type::Paren:
2524  T = cast<ParenType>(T)->getInnerType();
2525  break;
2526  case Type::SubstTemplateTypeParm:
2527  T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
2528  break;
2529  case Type::Auto:
2530  case Type::DeducedTemplateSpecialization: {
2531  QualType DT = cast<DeducedType>(T)->getDeducedType();
2532  assert(!DT.isNull() && "Undeduced types shouldn't reach here.");
2533  T = DT;
2534  break;
2535  }
2536  case Type::Adjusted:
2537  case Type::Decayed:
2538  // Decayed and adjusted types use the adjusted type in LLVM and DWARF.
2539  T = cast<AdjustedType>(T)->getAdjustedType();
2540  break;
2541  }
2542 
2543  assert(T != LastT && "Type unwrapping failed to unwrap!");
2544  (void)LastT;
2545  } while (true);
2546 }
2547 
2548 llvm::DIType *CGDebugInfo::getTypeOrNull(QualType Ty) {
2549 
2550  // Unwrap the type as needed for debug information.
2551  Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2552 
2553  auto it = TypeCache.find(Ty.getAsOpaquePtr());
2554  if (it != TypeCache.end()) {
2555  // Verify that the debug info still exists.
2556  if (llvm::Metadata *V = it->second)
2557  return cast<llvm::DIType>(V);
2558  }
2559 
2560  return nullptr;
2561 }
2562 
2564  const ClassTemplateSpecializationDecl &SD) {
2565  if (DebugKind <= codegenoptions::DebugLineTablesOnly)
2566  return;
2567  completeUnusedClass(SD);
2568 }
2569 
2571  if (DebugKind <= codegenoptions::DebugLineTablesOnly)
2572  return;
2573 
2574  completeClassData(&D);
2575  // In case this type has no member function definitions being emitted, ensure
2576  // it is retained
2577  RetainedTypes.push_back(CGM.getContext().getRecordType(&D).getAsOpaquePtr());
2578 }
2579 
2580 llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) {
2581  if (Ty.isNull())
2582  return nullptr;
2583 
2584  // Unwrap the type as needed for debug information.
2585  Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext());
2586 
2587  if (auto *T = getTypeOrNull(Ty))
2588  return T;
2589 
2590  llvm::DIType *Res = CreateTypeNode(Ty, Unit);
2591  void* TyPtr = Ty.getAsOpaquePtr();
2592 
2593  // And update the type cache.
2594  TypeCache[TyPtr].reset(Res);
2595 
2596  return Res;
2597 }
2598 
2599 llvm::DIModule *CGDebugInfo::getParentModuleOrNull(const Decl *D) {
2600  // A forward declaration inside a module header does not belong to the module.
2601  if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->getDefinition())
2602  return nullptr;
2603  if (DebugTypeExtRefs && D->isFromASTFile()) {
2604  // Record a reference to an imported clang module or precompiled header.
2605  auto *Reader = CGM.getContext().getExternalSource();
2606  auto Idx = D->getOwningModuleID();
2607  auto Info = Reader->getSourceDescriptor(Idx);
2608  if (Info)
2609  return getOrCreateModuleRef(*Info, /*SkeletonCU=*/true);
2610  } else if (ClangModuleMap) {
2611  // We are building a clang module or a precompiled header.
2612  //
2613  // TODO: When D is a CXXRecordDecl or a C++ Enum, the ODR applies
2614  // and it wouldn't be necessary to specify the parent scope
2615  // because the type is already unique by definition (it would look
2616  // like the output of -fno-standalone-debug). On the other hand,
2617  // the parent scope helps a consumer to quickly locate the object
2618  // file where the type's definition is located, so it might be
2619  // best to make this behavior a command line or debugger tuning
2620  // option.
2622  if (Module *M = D->getOwningModule()) {
2623  // This is a (sub-)module.
2625  return getOrCreateModuleRef(Info, /*SkeletonCU=*/false);
2626  } else {
2627  // This the precompiled header being built.
2628  return getOrCreateModuleRef(PCHDescriptor, /*SkeletonCU=*/false);
2629  }
2630  }
2631 
2632  return nullptr;
2633 }
2634 
2635 llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) {
2636  // Handle qualifiers, which recursively handles what they refer to.
2637  if (Ty.hasLocalQualifiers())
2638  return CreateQualifiedType(Ty, Unit);
2639 
2640  // Work out details of type.
2641  switch (Ty->getTypeClass()) {
2642 #define TYPE(Class, Base)
2643 #define ABSTRACT_TYPE(Class, Base)
2644 #define NON_CANONICAL_TYPE(Class, Base)
2645 #define DEPENDENT_TYPE(Class, Base) case Type::Class:
2646 #include "clang/AST/TypeNodes.def"
2647  llvm_unreachable("Dependent types cannot show up in debug information");
2648 
2649  case Type::ExtVector:
2650  case Type::Vector:
2651  return CreateType(cast<VectorType>(Ty), Unit);
2652  case Type::ObjCObjectPointer:
2653  return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
2654  case Type::ObjCObject:
2655  return CreateType(cast<ObjCObjectType>(Ty), Unit);
2656  case Type::ObjCTypeParam:
2657  return CreateType(cast<ObjCTypeParamType>(Ty), Unit);
2658  case Type::ObjCInterface:
2659  return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
2660  case Type::Builtin:
2661  return CreateType(cast<BuiltinType>(Ty));
2662  case Type::Complex:
2663  return CreateType(cast<ComplexType>(Ty));
2664  case Type::Pointer:
2665  return CreateType(cast<PointerType>(Ty), Unit);
2666  case Type::BlockPointer:
2667  return CreateType(cast<BlockPointerType>(Ty), Unit);
2668  case Type::Typedef:
2669  return CreateType(cast<TypedefType>(Ty), Unit);
2670  case Type::Record:
2671  return CreateType(cast<RecordType>(Ty));
2672  case Type::Enum:
2673  return CreateEnumType(cast<EnumType>(Ty));
2674  case Type::FunctionProto:
2675  case Type::FunctionNoProto:
2676  return CreateType(cast<FunctionType>(Ty), Unit);
2677  case Type::ConstantArray:
2678  case Type::VariableArray:
2679  case Type::IncompleteArray:
2680  return CreateType(cast<ArrayType>(Ty), Unit);
2681 
2682  case Type::LValueReference:
2683  return CreateType(cast<LValueReferenceType>(Ty), Unit);
2684  case Type::RValueReference:
2685  return CreateType(cast<RValueReferenceType>(Ty), Unit);
2686 
2687  case Type::MemberPointer:
2688  return CreateType(cast<MemberPointerType>(Ty), Unit);
2689 
2690  case Type::Atomic:
2691  return CreateType(cast<AtomicType>(Ty), Unit);
2692 
2693  case Type::Pipe:
2694  return CreateType(cast<PipeType>(Ty), Unit);
2695 
2696  case Type::TemplateSpecialization:
2697  return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
2698 
2699  case Type::Auto:
2700  case Type::Attributed:
2701  case Type::Adjusted:
2702  case Type::Decayed:
2703  case Type::DeducedTemplateSpecialization:
2704  case Type::Elaborated:
2705  case Type::Paren:
2706  case Type::SubstTemplateTypeParm:
2707  case Type::TypeOfExpr:
2708  case Type::TypeOf:
2709  case Type::Decltype:
2710  case Type::UnaryTransform:
2711  case Type::PackExpansion:
2712  break;
2713  }
2714 
2715  llvm_unreachable("type should have been unwrapped!");
2716 }
2717 
2718 llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty,
2719  llvm::DIFile *Unit) {
2720  QualType QTy(Ty, 0);
2721 
2722  auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
2723 
2724  // We may have cached a forward decl when we could have created
2725  // a non-forward decl. Go ahead and create a non-forward decl
2726  // now.
2727  if (T && !T->isForwardDecl())
2728  return T;
2729 
2730  // Otherwise create the type.
2731  llvm::DICompositeType *Res = CreateLimitedType(Ty);
2732 
2733  // Propagate members from the declaration to the definition
2734  // CreateType(const RecordType*) will overwrite this with the members in the
2735  // correct order if the full type is needed.
2736  DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
2737 
2738  // And update the type cache.
2739  TypeCache[QTy.getAsOpaquePtr()].reset(Res);
2740  return Res;
2741 }
2742 
2743 // TODO: Currently used for context chains when limiting debug info.
2744 llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) {
2745  RecordDecl *RD = Ty->getDecl();
2746 
2747  // Get overall information about the record type for the debug info.
2748  llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation());
2749  unsigned Line = getLineNumber(RD->getLocation());
2750  StringRef RDName = getClassName(RD);
2751 
2752  llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
2753 
2754  // If we ended up creating the type during the context chain construction,
2755  // just return that.
2756  auto *T = cast_or_null<llvm::DICompositeType>(
2757  getTypeOrNull(CGM.getContext().getRecordType(RD)));
2758  if (T && (!T->isForwardDecl() || !RD->getDefinition()))
2759  return T;
2760 
2761  // If this is just a forward or incomplete declaration, construct an
2762  // appropriately marked node and just return it.
2763  const RecordDecl *D = RD->getDefinition();
2764  if (!D || !D->isCompleteDefinition())
2765  return getOrCreateRecordFwdDecl(Ty, RDContext);
2766 
2767  uint64_t Size = CGM.getContext().getTypeSize(Ty);
2768  auto Align = getDeclAlignIfRequired(D, CGM.getContext());
2769 
2770  SmallString<256> FullName = getUniqueTagTypeName(Ty, CGM, TheCU);
2771 
2772  llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
2773  getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align,
2774  llvm::DINode::FlagZero, FullName);
2775 
2776  // Elements of composite types usually have back to the type, creating
2777  // uniquing cycles. Distinct nodes are more efficient.
2778  switch (RealDecl->getTag()) {
2779  default:
2780  llvm_unreachable("invalid composite type tag");
2781 
2782  case llvm::dwarf::DW_TAG_array_type:
2783  case llvm::dwarf::DW_TAG_enumeration_type:
2784  // Array elements and most enumeration elements don't have back references,
2785  // so they don't tend to be involved in uniquing cycles and there is some
2786  // chance of merging them when linking together two modules. Only make
2787  // them distinct if they are ODR-uniqued.
2788  if (FullName.empty())
2789  break;
2790  LLVM_FALLTHROUGH;
2791 
2792  case llvm::dwarf::DW_TAG_structure_type:
2793  case llvm::dwarf::DW_TAG_union_type:
2794  case llvm::dwarf::DW_TAG_class_type:
2795  // Immediatley resolve to a distinct node.
2796  RealDecl =
2797  llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
2798  break;
2799  }
2800 
2801  RegionMap[Ty->getDecl()].reset(RealDecl);
2802  TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl);
2803 
2804  if (const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
2805  DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
2806  CollectCXXTemplateParams(TSpecial, DefUnit));
2807  return RealDecl;
2808 }
2809 
2810 void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD,
2811  llvm::DICompositeType *RealDecl) {
2812  // A class's primary base or the class itself contains the vtable.
2813  llvm::DICompositeType *ContainingType = nullptr;
2814  const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
2815  if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) {
2816  // Seek non-virtual primary base root.
2817  while (1) {
2818  const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase);
2819  const CXXRecordDecl *PBT = BRL.getPrimaryBase();
2820  if (PBT && !BRL.isPrimaryBaseVirtual())
2821  PBase = PBT;
2822  else
2823  break;
2824  }
2825  ContainingType = cast<llvm::DICompositeType>(
2826  getOrCreateType(QualType(PBase->getTypeForDecl(), 0),
2827  getOrCreateFile(RD->getLocation())));
2828  } else if (RD->isDynamicClass())
2829  ContainingType = RealDecl;
2830 
2831  DBuilder.replaceVTableHolder(RealDecl, ContainingType);
2832 }
2833 
2834 llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType,
2835  StringRef Name, uint64_t *Offset) {
2836  llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
2837  uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
2838  auto FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext());
2839  llvm::DIType *Ty =
2840  DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,
2841  *Offset, llvm::DINode::FlagZero, FieldTy);
2842  *Offset += FieldSize;
2843  return Ty;
2844 }
2845 
2846 void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
2847  StringRef &Name,
2848  StringRef &LinkageName,
2849  llvm::DIScope *&FDContext,
2850  llvm::DINodeArray &TParamsArray,
2851  llvm::DINode::DIFlags &Flags) {
2852  const auto *FD = cast<FunctionDecl>(GD.getDecl());
2853  Name = getFunctionName(FD);
2854  // Use mangled name as linkage name for C/C++ functions.
2855  if (FD->hasPrototype()) {
2856  LinkageName = CGM.getMangledName(GD);
2857  Flags |= llvm::DINode::FlagPrototyped;
2858  }
2859  // No need to replicate the linkage name if it isn't different from the
2860  // subprogram name, no need to have it at all unless coverage is enabled or
2861  // debug is set to more than just line tables or extra debug info is needed.
2862  if (LinkageName == Name || (!CGM.getCodeGenOpts().EmitGcovArcs &&
2863  !CGM.getCodeGenOpts().EmitGcovNotes &&
2864  !CGM.getCodeGenOpts().DebugInfoForProfiling &&
2866  LinkageName = StringRef();
2867 
2868  if (DebugKind >= codegenoptions::LimitedDebugInfo) {
2869  if (const NamespaceDecl *NSDecl =
2870  dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext()))
2871  FDContext = getOrCreateNamespace(NSDecl);
2872  else if (const RecordDecl *RDecl =
2873  dyn_cast_or_null<RecordDecl>(FD->getDeclContext())) {
2874  llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
2875  FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
2876  }
2877  // Check if it is a noreturn-marked function
2878  if (FD->isNoReturn())
2879  Flags |= llvm::DINode::FlagNoReturn;
2880  // Collect template parameters.
2881  TParamsArray = CollectFunctionTemplateParams(FD, Unit);
2882  }
2883 }
2884 
2885 void CGDebugInfo::collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit,
2886  unsigned &LineNo, QualType &T,
2887  StringRef &Name, StringRef &LinkageName,
2888  llvm::DIScope *&VDContext) {
2889  Unit = getOrCreateFile(VD->getLocation());
2890  LineNo = getLineNumber(VD->getLocation());
2891 
2892  setLocation(VD->getLocation());
2893 
2894  T = VD->getType();
2895  if (T->isIncompleteArrayType()) {
2896  // CodeGen turns int[] into int[1] so we'll do the same here.
2897  llvm::APInt ConstVal(32, 1);
2899 
2900  T = CGM.getContext().getConstantArrayType(ET, ConstVal,
2901  ArrayType::Normal, 0);
2902  }
2903 
2904  Name = VD->getName();
2905  if (VD->getDeclContext() && !isa<FunctionDecl>(VD->getDeclContext()) &&
2906  !isa<ObjCMethodDecl>(VD->getDeclContext()))
2907  LinkageName = CGM.getMangledName(VD);
2908  if (LinkageName == Name)
2909  LinkageName = StringRef();
2910 
2911  // Since we emit declarations (DW_AT_members) for static members, place the
2912  // definition of those static members in the namespace they were declared in
2913  // in the source code (the lexical decl context).
2914  // FIXME: Generalize this for even non-member global variables where the
2915  // declaration and definition may have different lexical decl contexts, once
2916  // we have support for emitting declarations of (non-member) global variables.
2917  const DeclContext *DC = VD->isStaticDataMember() ? VD->getLexicalDeclContext()
2918  : VD->getDeclContext();
2919  // When a record type contains an in-line initialization of a static data
2920  // member, and the record type is marked as __declspec(dllexport), an implicit
2921  // definition of the member will be created in the record context. DWARF
2922  // doesn't seem to have a nice way to describe this in a form that consumers
2923  // are likely to understand, so fake the "normal" situation of a definition
2924  // outside the class by putting it in the global scope.
2925  if (DC->isRecord())
2926  DC = CGM.getContext().getTranslationUnitDecl();
2927 
2928  llvm::DIScope *Mod = getParentModuleOrNull(VD);
2929  VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
2930 }
2931 
2932 llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD,
2933  bool Stub) {
2934  llvm::DINodeArray TParamsArray;
2935  StringRef Name, LinkageName;
2936  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2937  SourceLocation Loc = GD.getDecl()->getLocation();
2938  llvm::DIFile *Unit = getOrCreateFile(Loc);
2939  llvm::DIScope *DContext = Unit;
2940  unsigned Line = getLineNumber(Loc);
2941  collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext,
2942  TParamsArray, Flags);
2943  auto *FD = dyn_cast<FunctionDecl>(GD.getDecl());
2944 
2945  // Build function type.
2946  SmallVector<QualType, 16> ArgTypes;
2947  if (FD)
2948  for (const ParmVarDecl *Parm : FD->parameters())
2949  ArgTypes.push_back(Parm->getType());
2950  CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv();
2951  QualType FnType = CGM.getContext().getFunctionType(
2952  FD->getReturnType(), ArgTypes, FunctionProtoType::ExtProtoInfo(CC));
2953  if (Stub) {
2954  return DBuilder.createFunction(
2955  DContext, Name, LinkageName, Unit, Line,
2956  getOrCreateFunctionType(GD.getDecl(), FnType, Unit),
2957  !FD->isExternallyVisible(),
2958  /* isDefinition = */ true, 0, Flags, CGM.getLangOpts().Optimize,
2959  TParamsArray.get(), getFunctionDeclaration(FD));
2960  }
2961 
2962  llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
2963  DContext, Name, LinkageName, Unit, Line,
2964  getOrCreateFunctionType(GD.getDecl(), FnType, Unit),
2965  !FD->isExternallyVisible(),
2966  /* isDefinition = */ false, 0, Flags, CGM.getLangOpts().Optimize,
2967  TParamsArray.get(), getFunctionDeclaration(FD));
2968  const auto *CanonDecl = cast<FunctionDecl>(FD->getCanonicalDecl());
2969  FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
2970  std::make_tuple(CanonDecl),
2971  std::make_tuple(SP));
2972  return SP;
2973 }
2974 
2975 llvm::DISubprogram *
2976 CGDebugInfo::getFunctionForwardDeclaration(GlobalDecl GD) {
2977  return getFunctionFwdDeclOrStub(GD, /* Stub = */ false);
2978 }
2979 
2980 llvm::DISubprogram *
2981 CGDebugInfo::getFunctionStub(GlobalDecl GD) {
2982  return getFunctionFwdDeclOrStub(GD, /* Stub = */ true);
2983 }
2984 
2985 llvm::DIGlobalVariable *
2986 CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) {
2987  QualType T;
2988  StringRef Name, LinkageName;
2989  SourceLocation Loc = VD->getLocation();
2990  llvm::DIFile *Unit = getOrCreateFile(Loc);
2991  llvm::DIScope *DContext = Unit;
2992  unsigned Line = getLineNumber(Loc);
2993 
2994  collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, DContext);
2995  auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
2996  auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
2997  DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
2998  !VD->isExternallyVisible(), nullptr, Align);
2999  FwdDeclReplaceMap.emplace_back(
3000  std::piecewise_construct,
3001  std::make_tuple(cast<VarDecl>(VD->getCanonicalDecl())),
3002  std::make_tuple(static_cast<llvm::Metadata *>(GV)));
3003  return GV;
3004 }
3005 
3006 llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(const Decl *D) {
3007  // We only need a declaration (not a definition) of the type - so use whatever
3008  // we would otherwise do to get a type for a pointee. (forward declarations in
3009  // limited debug info, full definitions (if the type definition is available)
3010  // in unlimited debug info)
3011  if (const auto *TD = dyn_cast<TypeDecl>(D))
3012  return getOrCreateType(CGM.getContext().getTypeDeclType(TD),
3013  getOrCreateFile(TD->getLocation()));
3014  auto I = DeclCache.find(D->getCanonicalDecl());
3015 
3016  if (I != DeclCache.end()) {
3017  auto N = I->second;
3018  if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))
3019  return GVE->getVariable();
3020  return dyn_cast_or_null<llvm::DINode>(N);
3021  }
3022 
3023  // No definition for now. Emit a forward definition that might be
3024  // merged with a potential upcoming definition.
3025  if (const auto *FD = dyn_cast<FunctionDecl>(D))
3026  return getFunctionForwardDeclaration(FD);
3027  else if (const auto *VD = dyn_cast<VarDecl>(D))
3028  return getGlobalVariableForwardDeclaration(VD);
3029 
3030  return nullptr;
3031 }
3032 
3033 llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) {
3034  if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
3035  return nullptr;
3036 
3037  const auto *FD = dyn_cast<FunctionDecl>(D);
3038  if (!FD)
3039  return nullptr;
3040 
3041  // Setup context.
3042  auto *S = getDeclContextDescriptor(D);
3043 
3044  auto MI = SPCache.find(FD->getCanonicalDecl());
3045  if (MI == SPCache.end()) {
3046  if (const auto *MD = dyn_cast<CXXMethodDecl>(FD->getCanonicalDecl())) {
3047  return CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()),
3048  cast<llvm::DICompositeType>(S));
3049  }
3050  }
3051  if (MI != SPCache.end()) {
3052  auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3053  if (SP && !SP->isDefinition())
3054  return SP;
3055  }
3056 
3057  for (auto NextFD : FD->redecls()) {
3058  auto MI = SPCache.find(NextFD->getCanonicalDecl());
3059  if (MI != SPCache.end()) {
3060  auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3061  if (SP && !SP->isDefinition())
3062  return SP;
3063  }
3064  }
3065  return nullptr;
3066 }
3067 
3068 // getOrCreateFunctionType - Construct type. If it is a c++ method, include
3069 // implicit parameter "this".
3070 llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(const Decl *D,
3071  QualType FnType,
3072  llvm::DIFile *F) {
3073  if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly)
3074  // Create fake but valid subroutine type. Otherwise -verify would fail, and
3075  // subprogram DIE will miss DW_AT_decl_file and DW_AT_decl_line fields.
3076  return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray(None));
3077 
3078  if (const auto *Method = dyn_cast<CXXMethodDecl>(D))
3079  return getOrCreateMethodType(Method, F);
3080 
3081  const auto *FTy = FnType->getAs<FunctionType>();
3082  CallingConv CC = FTy ? FTy->getCallConv() : CallingConv::CC_C;
3083 
3084  if (const auto *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
3085  // Add "self" and "_cmd"
3087 
3088  // First element is always return type. For 'void' functions it is NULL.
3089  QualType ResultTy = OMethod->getReturnType();
3090 
3091  // Replace the instancetype keyword with the actual type.
3092  if (ResultTy == CGM.getContext().getObjCInstanceType())
3093  ResultTy = CGM.getContext().getPointerType(
3094  QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
3095 
3096  Elts.push_back(getOrCreateType(ResultTy, F));
3097  // "self" pointer is always first argument.
3098  QualType SelfDeclTy;
3099  if (auto *SelfDecl = OMethod->getSelfDecl())
3100  SelfDeclTy = SelfDecl->getType();
3101  else if (auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3102  if (FPT->getNumParams() > 1)
3103  SelfDeclTy = FPT->getParamType(0);
3104  if (!SelfDeclTy.isNull())
3105  Elts.push_back(CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
3106  // "_cmd" pointer is always second argument.
3107  Elts.push_back(DBuilder.createArtificialType(
3108  getOrCreateType(CGM.getContext().getObjCSelType(), F)));
3109  // Get rest of the arguments.
3110  for (const auto *PI : OMethod->parameters())
3111  Elts.push_back(getOrCreateType(PI->getType(), F));
3112  // Variadic methods need a special marker at the end of the type list.
3113  if (OMethod->isVariadic())
3114  Elts.push_back(DBuilder.createUnspecifiedParameter());
3115 
3116  llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
3117  return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3118  getDwarfCC(CC));
3119  }
3120 
3121  // Handle variadic function types; they need an additional
3122  // unspecified parameter.
3123  if (const auto *FD = dyn_cast<FunctionDecl>(D))
3124  if (FD->isVariadic()) {
3126  EltTys.push_back(getOrCreateType(FD->getReturnType(), F));
3127  if (const auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3128  for (QualType ParamType : FPT->param_types())
3129  EltTys.push_back(getOrCreateType(ParamType, F));
3130  EltTys.push_back(DBuilder.createUnspecifiedParameter());
3131  llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
3132  return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3133  getDwarfCC(CC));
3134  }
3135 
3136  return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
3137 }
3138 
3140  SourceLocation ScopeLoc, QualType FnType,
3141  llvm::Function *Fn, CGBuilderTy &Builder) {
3142 
3143  StringRef Name;
3144  StringRef LinkageName;
3145 
3146  FnBeginRegionCount.push_back(LexicalBlockStack.size());
3147 
3148  const Decl *D = GD.getDecl();
3149  bool HasDecl = (D != nullptr);
3150 
3151  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3152  llvm::DIFile *Unit = getOrCreateFile(Loc);
3153  llvm::DIScope *FDContext = Unit;
3154  llvm::DINodeArray TParamsArray;
3155  if (!HasDecl) {
3156  // Use llvm function name.
3157  LinkageName = Fn->getName();
3158  } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
3159  // If there is a subprogram for this function available then use it.
3160  auto FI = SPCache.find(FD->getCanonicalDecl());
3161  if (FI != SPCache.end()) {
3162  auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
3163  if (SP && SP->isDefinition()) {
3164  LexicalBlockStack.emplace_back(SP);
3165  RegionMap[D].reset(SP);
3166  return;
3167  }
3168  }
3169  collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3170  TParamsArray, Flags);
3171  } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
3172  Name = getObjCMethodName(OMD);
3173  Flags |= llvm::DINode::FlagPrototyped;
3174  } else {
3175  // Use llvm function name.
3176  Name = Fn->getName();
3177  Flags |= llvm::DINode::FlagPrototyped;
3178  }
3179  if (Name.startswith("\01"))
3180  Name = Name.substr(1);
3181 
3182  if (!HasDecl || D->isImplicit()) {
3183  Flags |= llvm::DINode::FlagArtificial;
3184  // Artificial functions should not silently reuse CurLoc.
3185  CurLoc = SourceLocation();
3186  }
3187  unsigned LineNo = getLineNumber(Loc);
3188  unsigned ScopeLine = getLineNumber(ScopeLoc);
3189 
3190  // FIXME: The function declaration we're constructing here is mostly reusing
3191  // declarations from CXXMethodDecl and not constructing new ones for arbitrary
3192  // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for
3193  // all subprograms instead of the actual context since subprogram definitions
3194  // are emitted as CU level entities by the backend.
3195  llvm::DISubprogram *SP = DBuilder.createFunction(
3196  FDContext, Name, LinkageName, Unit, LineNo,
3197  getOrCreateFunctionType(D, FnType, Unit), Fn->hasLocalLinkage(),
3198  true /*definition*/, ScopeLine, Flags, CGM.getLangOpts().Optimize,
3199  TParamsArray.get(), getFunctionDeclaration(D));
3200  Fn->setSubprogram(SP);
3201  // We might get here with a VarDecl in the case we're generating
3202  // code for the initialization of globals. Do not record these decls
3203  // as they will overwrite the actual VarDecl Decl in the cache.
3204  if (HasDecl && isa<FunctionDecl>(D))
3205  DeclCache[D->getCanonicalDecl()].reset(SP);
3206 
3207  // Push the function onto the lexical block stack.
3208  LexicalBlockStack.emplace_back(SP);
3209 
3210  if (HasDecl)
3211  RegionMap[D].reset(SP);
3212 }
3213 
3215  QualType FnType) {
3216  StringRef Name;
3217  StringRef LinkageName;
3218 
3219  const Decl *D = GD.getDecl();
3220  if (!D)
3221  return;
3222 
3223  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3224  llvm::DIFile *Unit = getOrCreateFile(Loc);
3225  llvm::DIScope *FDContext = getDeclContextDescriptor(D);
3226  llvm::DINodeArray TParamsArray;
3227  if (isa<FunctionDecl>(D)) {
3228  // If there is a DISubprogram for this function available then use it.
3229  collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext,
3230  TParamsArray, Flags);
3231  } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) {
3232  Name = getObjCMethodName(OMD);
3233  Flags |= llvm::DINode::FlagPrototyped;
3234  } else {
3235  llvm_unreachable("not a function or ObjC method");
3236  }
3237  if (!Name.empty() && Name[0] == '\01')
3238  Name = Name.substr(1);
3239 
3240  if (D->isImplicit()) {
3241  Flags |= llvm::DINode::FlagArtificial;
3242  // Artificial functions without a location should not silently reuse CurLoc.
3243  if (Loc.isInvalid())
3244  CurLoc = SourceLocation();
3245  }
3246  unsigned LineNo = getLineNumber(Loc);
3247  unsigned ScopeLine = 0;
3248 
3249  DBuilder.retainType(DBuilder.createFunction(
3250  FDContext, Name, LinkageName, Unit, LineNo,
3251  getOrCreateFunctionType(D, FnType, Unit), false /*internalLinkage*/,
3252  false /*definition*/, ScopeLine, Flags, CGM.getLangOpts().Optimize,
3253  TParamsArray.get(), getFunctionDeclaration(D)));
3254 }
3255 
3257  const auto *FD = cast<FunctionDecl>(GD.getDecl());
3258  // If there is a subprogram for this function available then use it.
3259  auto FI = SPCache.find(FD->getCanonicalDecl());
3260  llvm::DISubprogram *SP = nullptr;
3261  if (FI != SPCache.end())
3262  SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second);
3263  if (!SP || !SP->isDefinition())
3264  SP = getFunctionStub(GD);
3265  FnBeginRegionCount.push_back(LexicalBlockStack.size());
3266  LexicalBlockStack.emplace_back(SP);
3267  setInlinedAt(Builder.getCurrentDebugLocation());
3268  EmitLocation(Builder, FD->getLocation());
3269 }
3270 
3272  assert(CurInlinedAt && "unbalanced inline scope stack");
3273  EmitFunctionEnd(Builder, nullptr);
3274  setInlinedAt(llvm::DebugLoc(CurInlinedAt).getInlinedAt());
3275 }
3276 
3278  // Update our current location
3279  setLocation(Loc);
3280 
3281  if (CurLoc.isInvalid() || CurLoc.isMacroID())
3282  return;
3283 
3284  llvm::MDNode *Scope = LexicalBlockStack.back();
3285  Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
3286  getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope, CurInlinedAt));
3287 }
3288 
3289 void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) {
3290  llvm::MDNode *Back = nullptr;
3291  if (!LexicalBlockStack.empty())
3292  Back = LexicalBlockStack.back().get();
3293  LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock(
3294  cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc),
3295  getColumnNumber(CurLoc)));
3296 }
3297 
3298 void CGDebugInfo::AppendAddressSpaceXDeref(
3299  unsigned AddressSpace,
3300  SmallVectorImpl<int64_t> &Expr) const {
3301  Optional<unsigned> DWARFAddressSpace =
3302  CGM.getTarget().getDWARFAddressSpace(AddressSpace);
3303  if (!DWARFAddressSpace)
3304  return;
3305 
3306  Expr.push_back(llvm::dwarf::DW_OP_constu);
3307  Expr.push_back(DWARFAddressSpace.getValue());
3308  Expr.push_back(llvm::dwarf::DW_OP_swap);
3309  Expr.push_back(llvm::dwarf::DW_OP_xderef);
3310 }
3311 
3313  SourceLocation Loc) {
3314  // Set our current location.
3315  setLocation(Loc);
3316 
3317  // Emit a line table change for the current location inside the new scope.
3318  Builder.SetCurrentDebugLocation(
3319  llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc),
3320  LexicalBlockStack.back(), CurInlinedAt));
3321 
3322  if (DebugKind <= codegenoptions::DebugLineTablesOnly)
3323  return;
3324 
3325  // Create a new lexical block and push it on the stack.
3326  CreateLexicalBlock(Loc);
3327 }
3328 
3330  SourceLocation Loc) {
3331  assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
3332 
3333  // Provide an entry in the line table for the end of the block.
3334  EmitLocation(Builder, Loc);
3335 
3336  if (DebugKind <= codegenoptions::DebugLineTablesOnly)
3337  return;
3338 
3339  LexicalBlockStack.pop_back();
3340 }
3341 
3343  assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
3344  unsigned RCount = FnBeginRegionCount.back();
3345  assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch");
3346 
3347  // Pop all regions for this function.
3348  while (LexicalBlockStack.size() != RCount) {
3349  // Provide an entry in the line table for the end of the block.
3350  EmitLocation(Builder, CurLoc);
3351  LexicalBlockStack.pop_back();
3352  }
3353  FnBeginRegionCount.pop_back();
3354 
3355  if (Fn && Fn->getSubprogram())
3356  DBuilder.finalizeSubprogram(Fn->getSubprogram());
3357 }
3358 
3359 llvm::DIType *CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD,
3360  uint64_t *XOffset) {
3361 
3363  QualType FType;
3364  uint64_t FieldSize, FieldOffset;
3365  uint32_t FieldAlign;
3366 
3367  llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
3368  QualType Type = VD->getType();
3369 
3370  FieldOffset = 0;
3371  FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3372  EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
3373  EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
3374  FType = CGM.getContext().IntTy;
3375  EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
3376  EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
3377 
3378  bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD);
3379  if (HasCopyAndDispose) {
3380  FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3381  EltTys.push_back(
3382  CreateMemberType(Unit, FType, "__copy_helper", &FieldOffset));
3383  EltTys.push_back(
3384  CreateMemberType(Unit, FType, "__destroy_helper", &FieldOffset));
3385  }
3386  bool HasByrefExtendedLayout;
3387  Qualifiers::ObjCLifetime Lifetime;
3388  if (CGM.getContext().getByrefLifetime(Type, Lifetime,
3389  HasByrefExtendedLayout) &&
3390  HasByrefExtendedLayout) {
3391  FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
3392  EltTys.push_back(
3393  CreateMemberType(Unit, FType, "__byref_variable_layout", &FieldOffset));
3394  }
3395 
3396  CharUnits Align = CGM.getContext().getDeclAlign(VD);
3397  if (Align > CGM.getContext().toCharUnitsFromBits(
3398  CGM.getTarget().getPointerAlign(0))) {
3399  CharUnits FieldOffsetInBytes =
3400  CGM.getContext().toCharUnitsFromBits(FieldOffset);
3401  CharUnits AlignedOffsetInBytes = FieldOffsetInBytes.alignTo(Align);
3402  CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
3403 
3404  if (NumPaddingBytes.isPositive()) {
3405  llvm::APInt pad(32, NumPaddingBytes.getQuantity());
3406  FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
3407  pad, ArrayType::Normal, 0);
3408  EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
3409  }
3410  }
3411 
3412  FType = Type;
3413  llvm::DIType *FieldTy = getOrCreateType(FType, Unit);
3414  FieldSize = CGM.getContext().getTypeSize(FType);
3415  FieldAlign = CGM.getContext().toBits(Align);
3416 
3417  *XOffset = FieldOffset;
3418  FieldTy = DBuilder.createMemberType(Unit, VD->getName(), Unit, 0, FieldSize,
3419  FieldAlign, FieldOffset,
3420  llvm::DINode::FlagZero, FieldTy);
3421  EltTys.push_back(FieldTy);
3422  FieldOffset += FieldSize;
3423 
3424  llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
3425 
3426  llvm::DINode::DIFlags Flags = llvm::DINode::FlagBlockByrefStruct;
3427 
3428  return DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0, Flags,
3429  nullptr, Elements);
3430 }
3431 
3432 void CGDebugInfo::EmitDeclare(const VarDecl *VD, llvm::Value *Storage,
3434  CGBuilderTy &Builder) {
3435  assert(DebugKind >= codegenoptions::LimitedDebugInfo);
3436  assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
3437  if (VD->hasAttr<NoDebugAttr>())
3438  return;
3439 
3440  bool Unwritten =
3441  VD->isImplicit() || (isa<Decl>(VD->getDeclContext()) &&
3442  cast<Decl>(VD->getDeclContext())->isImplicit());
3443  llvm::DIFile *Unit = nullptr;
3444  if (!Unwritten)
3445  Unit = getOrCreateFile(VD->getLocation());
3446  llvm::DIType *Ty;
3447  uint64_t XOffset = 0;
3448  if (VD->hasAttr<BlocksAttr>())
3449  Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
3450  else
3451  Ty = getOrCreateType(VD->getType(), Unit);
3452 
3453  // If there is no debug info for this type then do not emit debug info
3454  // for this variable.
3455  if (!Ty)
3456  return;
3457 
3458  // Get location information.
3459  unsigned Line = 0;
3460  unsigned Column = 0;
3461  if (!Unwritten) {
3462  Line = getLineNumber(VD->getLocation());
3463  Column = getColumnNumber(VD->getLocation());
3464  }
3466  llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3467  if (VD->isImplicit())
3468  Flags |= llvm::DINode::FlagArtificial;
3469 
3470  auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
3471 
3472  unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(VD->getType());
3473  AppendAddressSpaceXDeref(AddressSpace, Expr);
3474 
3475  // If this is implicit parameter of CXXThis or ObjCSelf kind, then give it an
3476  // object pointer flag.
3477  if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
3478  if (IPD->getParameterKind() == ImplicitParamDecl::CXXThis ||
3479  IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf)
3480  Flags |= llvm::DINode::FlagObjectPointer;
3481  }
3482 
3483  // Note: Older versions of clang used to emit byval references with an extra
3484  // DW_OP_deref, because they referenced the IR arg directly instead of
3485  // referencing an alloca. Newer versions of LLVM don't treat allocas
3486  // differently from other function arguments when used in a dbg.declare.
3487  auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
3488  StringRef Name = VD->getName();
3489  if (!Name.empty()) {
3490  if (VD->hasAttr<BlocksAttr>()) {
3491  // Here, we need an offset *into* the alloca.
3492  CharUnits offset = CharUnits::fromQuantity(32);
3493  Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3494  // offset of __forwarding field
3495  offset = CGM.getContext().toCharUnitsFromBits(
3496  CGM.getTarget().getPointerWidth(0));
3497  Expr.push_back(offset.getQuantity());
3498  Expr.push_back(llvm::dwarf::DW_OP_deref);
3499  Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3500  // offset of x field
3501  offset = CGM.getContext().toCharUnitsFromBits(XOffset);
3502  Expr.push_back(offset.getQuantity());
3503  }
3504  } else if (const auto *RT = dyn_cast<RecordType>(VD->getType())) {
3505  // If VD is an anonymous union then Storage represents value for
3506  // all union fields.
3507  const auto *RD = cast<RecordDecl>(RT->getDecl());
3508  if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
3509  // GDB has trouble finding local variables in anonymous unions, so we emit
3510  // artifical local variables for each of the members.
3511  //
3512  // FIXME: Remove this code as soon as GDB supports this.
3513  // The debug info verifier in LLVM operates based on the assumption that a
3514  // variable has the same size as its storage and we had to disable the check
3515  // for artificial variables.
3516  for (const auto *Field : RD->fields()) {
3517  llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3518  StringRef FieldName = Field->getName();
3519 
3520  // Ignore unnamed fields. Do not ignore unnamed records.
3521  if (FieldName.empty() && !isa<RecordType>(Field->getType()))
3522  continue;
3523 
3524  // Use VarDecl's Tag, Scope and Line number.
3525  auto FieldAlign = getDeclAlignIfRequired(Field, CGM.getContext());
3526  auto *D = DBuilder.createAutoVariable(
3527  Scope, FieldName, Unit, Line, FieldTy, CGM.getLangOpts().Optimize,
3528  Flags | llvm::DINode::FlagArtificial, FieldAlign);
3529 
3530  // Insert an llvm.dbg.declare into the current block.
3531  DBuilder.insertDeclare(
3532  Storage, D, DBuilder.createExpression(Expr),
3533  llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
3534  Builder.GetInsertBlock());
3535  }
3536  }
3537  }
3538 
3539  // Create the descriptor for the variable.
3540  auto *D = ArgNo
3541  ? DBuilder.createParameterVariable(
3542  Scope, Name, *ArgNo, Unit, Line, Ty,
3543  CGM.getLangOpts().Optimize, Flags)
3544  : DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty,
3545  CGM.getLangOpts().Optimize, Flags,
3546  Align);
3547 
3548  // Insert an llvm.dbg.declare into the current block.
3549  DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
3550  llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt),
3551  Builder.GetInsertBlock());
3552 }
3553 
3555  llvm::Value *Storage,
3556  CGBuilderTy &Builder) {
3557  assert(DebugKind >= codegenoptions::LimitedDebugInfo);
3558  EmitDeclare(VD, Storage, llvm::None, Builder);
3559 }
3560 
3561 llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy,
3562  llvm::DIType *Ty) {
3563  llvm::DIType *CachedTy = getTypeOrNull(QualTy);
3564  if (CachedTy)
3565  Ty = CachedTy;
3566  return DBuilder.createObjectPointerType(Ty);
3567 }
3568 
3570  const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder,
3571  const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
3572  assert(DebugKind >= codegenoptions::LimitedDebugInfo);
3573  assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!");
3574 
3575  if (Builder.GetInsertBlock() == nullptr)
3576  return;
3577  if (VD->hasAttr<NoDebugAttr>())
3578  return;
3579 
3580  bool isByRef = VD->hasAttr<BlocksAttr>();
3581 
3582  uint64_t XOffset = 0;
3583  llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
3584  llvm::DIType *Ty;
3585  if (isByRef)
3586  Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
3587  else
3588  Ty = getOrCreateType(VD->getType(), Unit);
3589 
3590  // Self is passed along as an implicit non-arg variable in a
3591  // block. Mark it as the object pointer.
3592  if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD))
3593  if (IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf)
3594  Ty = CreateSelfType(VD->getType(), Ty);
3595 
3596  // Get location information.
3597  unsigned Line = getLineNumber(VD->getLocation());
3598  unsigned Column = getColumnNumber(VD->getLocation());
3599 
3600  const llvm::DataLayout &target = CGM.getDataLayout();
3601 
3603  target.getStructLayout(blockInfo.StructureType)
3604  ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
3605 
3607  addr.push_back(llvm::dwarf::DW_OP_deref);
3608  addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3609  addr.push_back(offset.getQuantity());
3610  if (isByRef) {
3611  addr.push_back(llvm::dwarf::DW_OP_deref);
3612  addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3613  // offset of __forwarding field
3614  offset =
3615  CGM.getContext().toCharUnitsFromBits(target.getPointerSizeInBits(0));
3616  addr.push_back(offset.getQuantity());
3617  addr.push_back(llvm::dwarf::DW_OP_deref);
3618  addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3619  // offset of x field
3620  offset = CGM.getContext().toCharUnitsFromBits(XOffset);
3621  addr.push_back(offset.getQuantity());
3622  }
3623 
3624  // Create the descriptor for the variable.
3625  auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
3626  auto *D = DBuilder.createAutoVariable(
3627  cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->getName(), Unit,
3628  Line, Ty, false, llvm::DINode::FlagZero, Align);
3629 
3630  // Insert an llvm.dbg.declare into the current block.
3631  auto DL =
3632  llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back(), CurInlinedAt);
3633  auto *Expr = DBuilder.createExpression(addr);
3634  if (InsertPoint)
3635  DBuilder.insertDeclare(Storage, D, Expr, DL, InsertPoint);
3636  else
3637  DBuilder.insertDeclare(Storage, D, Expr, DL, Builder.GetInsertBlock());
3638 }
3639 
3641  unsigned ArgNo,
3642  CGBuilderTy &Builder) {
3643  assert(DebugKind >= codegenoptions::LimitedDebugInfo);
3644  EmitDeclare(VD, AI, ArgNo, Builder);
3645 }
3646 
3647 namespace {
3648 struct BlockLayoutChunk {
3649  uint64_t OffsetInBits;
3650  const BlockDecl::Capture *Capture;
3651 };
3652 bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) {
3653  return l.OffsetInBits < r.OffsetInBits;
3654 }
3655 }
3656 
3658  llvm::Value *Arg,
3659  unsigned ArgNo,
3660  llvm::Value *LocalAddr,
3661  CGBuilderTy &Builder) {
3662  assert(DebugKind >= codegenoptions::LimitedDebugInfo);
3663  ASTContext &C = CGM.getContext();
3664  const BlockDecl *blockDecl = block.getBlockDecl();
3665 
3666  // Collect some general information about the block's location.
3667  SourceLocation loc = blockDecl->getCaretLocation();
3668  llvm::DIFile *tunit = getOrCreateFile(loc);
3669  unsigned line = getLineNumber(loc);
3670  unsigned column = getColumnNumber(loc);
3671 
3672  // Build the debug-info type for the block literal.
3673  getDeclContextDescriptor(blockDecl);
3674 
3675  const llvm::StructLayout *blockLayout =
3676  CGM.getDataLayout().getStructLayout(block.StructureType);
3677 
3679  fields.push_back(createFieldType("__isa", C.VoidPtrTy, loc, AS_public,
3680  blockLayout->getElementOffsetInBits(0),
3681  tunit, tunit));
3682  fields.push_back(createFieldType("__flags", C.IntTy, loc, AS_public,
3683  blockLayout->getElementOffsetInBits(1),
3684  tunit, tunit));
3685  fields.push_back(createFieldType("__reserved", C.IntTy, loc, AS_public,
3686  blockLayout->getElementOffsetInBits(2),
3687  tunit, tunit));
3688  auto *FnTy = block.getBlockExpr()->getFunctionType();
3689  auto FnPtrType = CGM.getContext().getPointerType(FnTy->desugar());
3690  fields.push_back(createFieldType("__FuncPtr", FnPtrType, loc, AS_public,
3691  blockLayout->getElementOffsetInBits(3),
3692  tunit, tunit));
3693  fields.push_back(createFieldType(
3694  "__descriptor", C.getPointerType(block.NeedsCopyDispose
3696  : C.getBlockDescriptorType()),
3697  loc, AS_public, blockLayout->getElementOffsetInBits(4), tunit, tunit));
3698 
3699  // We want to sort the captures by offset, not because DWARF
3700  // requires this, but because we're paranoid about debuggers.
3702 
3703  // 'this' capture.
3704  if (blockDecl->capturesCXXThis()) {
3705  BlockLayoutChunk chunk;
3706  chunk.OffsetInBits =
3707  blockLayout->getElementOffsetInBits(block.CXXThisIndex);
3708  chunk.Capture = nullptr;
3709  chunks.push_back(chunk);
3710  }
3711 
3712  // Variable captures.
3713  for (const auto &capture : blockDecl->captures()) {
3714  const VarDecl *variable = capture.getVariable();
3715  const CGBlockInfo::Capture &captureInfo = block.getCapture(variable);
3716 
3717  // Ignore constant captures.
3718  if (captureInfo.isConstant())
3719  continue;
3720 
3721  BlockLayoutChunk chunk;
3722  chunk.OffsetInBits =
3723  blockLayout->getElementOffsetInBits(captureInfo.getIndex());
3724  chunk.Capture = &capture;
3725  chunks.push_back(chunk);
3726  }
3727 
3728  // Sort by offset.
3729  llvm::array_pod_sort(chunks.begin(), chunks.end());
3730 
3731  for (const BlockLayoutChunk &Chunk : chunks) {
3732  uint64_t offsetInBits = Chunk.OffsetInBits;
3733  const BlockDecl::Capture *capture = Chunk.Capture;
3734 
3735  // If we have a null capture, this must be the C++ 'this' capture.
3736  if (!capture) {
3737  QualType type;
3738  if (auto *Method =
3739  cast_or_null<CXXMethodDecl>(blockDecl->getNonClosureContext()))
3740  type = Method->getThisType(C);
3741  else if (auto *RDecl = dyn_cast<CXXRecordDecl>(blockDecl->getParent()))
3742  type = QualType(RDecl->getTypeForDecl(), 0);
3743  else
3744  llvm_unreachable("unexpected block declcontext");
3745 
3746  fields.push_back(createFieldType("this", type, loc, AS_public,
3747  offsetInBits, tunit, tunit));
3748  continue;
3749  }
3750 
3751  const VarDecl *variable = capture->getVariable();
3752  StringRef name = variable->getName();
3753 
3754  llvm::DIType *fieldType;
3755  if (capture->isByRef()) {
3756  TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy);
3757  auto Align = PtrInfo.AlignIsRequired ? PtrInfo.Align : 0;
3758 
3759  // FIXME: this creates a second copy of this type!
3760  uint64_t xoffset;
3761  fieldType = EmitTypeForVarWithBlocksAttr(variable, &xoffset);
3762  fieldType = DBuilder.createPointerType(fieldType, PtrInfo.Width);
3763  fieldType = DBuilder.createMemberType(tunit, name, tunit, line,
3764  PtrInfo.Width, Align, offsetInBits,
3765  llvm::DINode::FlagZero, fieldType);
3766  } else {
3767  auto Align = getDeclAlignIfRequired(variable, CGM.getContext());
3768  fieldType = createFieldType(name, variable->getType(), loc, AS_public,
3769  offsetInBits, Align, tunit, tunit);
3770  }
3771  fields.push_back(fieldType);
3772  }
3773 
3774  SmallString<36> typeName;
3775  llvm::raw_svector_ostream(typeName) << "__block_literal_"
3776  << CGM.getUniqueBlockCount();
3777 
3778  llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
3779 
3780  llvm::DIType *type =
3781  DBuilder.createStructType(tunit, typeName.str(), tunit, line,
3782  CGM.getContext().toBits(block.BlockSize), 0,
3783  llvm::DINode::FlagZero, nullptr, fieldsArray);
3784  type = DBuilder.createPointerType(type, CGM.PointerWidthInBits);
3785 
3786  // Get overall information about the block.
3787  llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
3788  auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
3789 
3790  // Create the descriptor for the parameter.
3791  auto *debugVar = DBuilder.createParameterVariable(
3792  scope, Arg->getName(), ArgNo, tunit, line, type,
3793  CGM.getLangOpts().Optimize, flags);
3794 
3795  if (LocalAddr) {
3796  // Insert an llvm.dbg.value into the current block.
3797  DBuilder.insertDbgValueIntrinsic(
3798  LocalAddr, 0, debugVar, DBuilder.createExpression(),
3799  llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
3800  Builder.GetInsertBlock());
3801  }
3802 
3803  // Insert an llvm.dbg.declare into the current block.
3804  DBuilder.insertDeclare(Arg, debugVar, DBuilder.createExpression(),
3805  llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
3806  Builder.GetInsertBlock());
3807 }
3808 
3809 llvm::DIDerivedType *
3810 CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) {
3811  if (!D->isStaticDataMember())
3812  return nullptr;
3813 
3814  auto MI = StaticDataMemberCache.find(D->getCanonicalDecl());
3815  if (MI != StaticDataMemberCache.end()) {
3816  assert(MI->second && "Static data member declaration should still exist");
3817  return MI->second;
3818  }
3819 
3820  // If the member wasn't found in the cache, lazily construct and add it to the
3821  // type (used when a limited form of the type is emitted).
3822  auto DC = D->getDeclContext();
3823  auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
3824  return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
3825 }
3826 
3827 llvm::DIGlobalVariableExpression *CGDebugInfo::CollectAnonRecordDecls(
3828  const RecordDecl *RD, llvm::DIFile *Unit, unsigned LineNo,
3829  StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) {
3830  llvm::DIGlobalVariableExpression *GVE = nullptr;
3831 
3832  for (const auto *Field : RD->fields()) {
3833  llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3834  StringRef FieldName = Field->getName();
3835 
3836  // Ignore unnamed fields, but recurse into anonymous records.
3837  if (FieldName.empty()) {
3838  if (const auto *RT = dyn_cast<RecordType>(Field->getType()))
3839  GVE = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
3840  Var, DContext);
3841  continue;
3842  }
3843  // Use VarDecl's Tag, Scope and Line number.
3844  GVE = DBuilder.createGlobalVariableExpression(
3845  DContext, FieldName, LinkageName, Unit, LineNo, FieldTy,
3846  Var->hasLocalLinkage());
3847  Var->addDebugInfo(GVE);
3848  }
3849  return GVE;
3850 }
3851 
3852 void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
3853  const VarDecl *D) {
3854  assert(DebugKind >= codegenoptions::LimitedDebugInfo);
3855  if (D->hasAttr<NoDebugAttr>())
3856  return;
3857 
3858  // If we already created a DIGlobalVariable for this declaration, just attach
3859  // it to the llvm::GlobalVariable.
3860  auto Cached = DeclCache.find(D->getCanonicalDecl());
3861  if (Cached != DeclCache.end())
3862  return Var->addDebugInfo(
3863  cast<llvm::DIGlobalVariableExpression>(Cached->second));
3864 
3865  // Create global variable debug descriptor.
3866  llvm::DIFile *Unit = nullptr;
3867  llvm::DIScope *DContext = nullptr;
3868  unsigned LineNo;
3869  StringRef DeclName, LinkageName;
3870  QualType T;
3871  collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName, DContext);
3872 
3873  // Attempt to store one global variable for the declaration - even if we
3874  // emit a lot of fields.
3875  llvm::DIGlobalVariableExpression *GVE = nullptr;
3876 
3877  // If this is an anonymous union then we'll want to emit a global
3878  // variable for each member of the anonymous union so that it's possible
3879  // to find the name of any field in the union.
3880  if (T->isUnionType() && DeclName.empty()) {
3881  const RecordDecl *RD = T->castAs<RecordType>()->getDecl();
3882  assert(RD->isAnonymousStructOrUnion() &&
3883  "unnamed non-anonymous struct or union?");
3884  GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
3885  } else {
3886  auto Align = getDeclAlignIfRequired(D, CGM.getContext());
3887 
3889  unsigned AddressSpace =
3891  AppendAddressSpaceXDeref(AddressSpace, Expr);
3892 
3893  GVE = DBuilder.createGlobalVariableExpression(
3894  DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit),
3895  Var->hasLocalLinkage(),
3896  Expr.empty() ? nullptr : DBuilder.createExpression(Expr),
3897  getOrCreateStaticDataMemberDeclarationOrNull(D), Align);
3898  Var->addDebugInfo(GVE);
3899  }
3900  DeclCache[D->getCanonicalDecl()].reset(GVE);
3901 }
3902 
3903 void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) {
3904  assert(DebugKind >= codegenoptions::LimitedDebugInfo);
3905  if (VD->hasAttr<NoDebugAttr>())
3906  return;
3907  auto Align = getDeclAlignIfRequired(VD, CGM.getContext());
3908  // Create the descriptor for the variable.
3909  llvm::DIFile *Unit = getOrCreateFile(VD->getLocation());
3910  StringRef Name = VD->getName();
3911  llvm::DIType *Ty = getOrCreateType(VD->getType(), Unit);
3912  if (const auto *ECD = dyn_cast<EnumConstantDecl>(VD)) {
3913  const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
3914  assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?");
3915  Ty = getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit);
3916  }
3917  // Do not use global variables for enums.
3918  //
3919  // FIXME: why not?
3920  if (Ty->getTag() == llvm::dwarf::DW_TAG_enumeration_type)
3921  return;
3922  // Do not emit separate definitions for function local const/statics.
3923  if (isa<FunctionDecl>(VD->getDeclContext()))
3924  return;
3925  VD = cast<ValueDecl>(VD->getCanonicalDecl());
3926  auto *VarD = cast<VarDecl>(VD);
3927  if (VarD->isStaticDataMember()) {
3928  auto *RD = cast<RecordDecl>(VarD->getDeclContext());
3929  getDeclContextDescriptor(VarD);
3930  // Ensure that the type is retained even though it's otherwise unreferenced.
3931  //
3932  // FIXME: This is probably unnecessary, since Ty should reference RD
3933  // through its scope.
3934  RetainedTypes.push_back(
3936  return;
3937  }
3938 
3939  llvm::DIScope *DContext = getDeclContextDescriptor(VD);
3940 
3941  auto &GV = DeclCache[VD];
3942  if (GV)
3943  return;
3944  llvm::DIExpression *InitExpr = nullptr;
3945  if (CGM.getContext().getTypeSize(VD->getType()) <= 64) {
3946  // FIXME: Add a representation for integer constants wider than 64 bits.
3947  if (Init.isInt())
3948  InitExpr =
3949  DBuilder.createConstantValueExpression(Init.getInt().getExtValue());
3950  else if (Init.isFloat())
3951  InitExpr = DBuilder.createConstantValueExpression(
3952  Init.getFloat().bitcastToAPInt().getZExtValue());
3953  }
3954  GV.reset(DBuilder.createGlobalVariableExpression(
3955  DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty,
3956  true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD),
3957  Align));
3958 }
3959 
3960 llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(const Decl *D) {
3961  if (!LexicalBlockStack.empty())
3962  return LexicalBlockStack.back();
3963  llvm::DIScope *Mod = getParentModuleOrNull(D);
3964  return getContextDescriptor(D, Mod ? Mod : TheCU);
3965 }
3966 
3968  if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
3969  return;
3970  const NamespaceDecl *NSDecl = UD.getNominatedNamespace();
3971  if (!NSDecl->isAnonymousNamespace() ||
3972  CGM.getCodeGenOpts().DebugExplicitImport) {
3973  auto Loc = UD.getLocation();
3974  DBuilder.createImportedModule(
3975  getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())),
3976  getOrCreateNamespace(NSDecl), getOrCreateFile(Loc), getLineNumber(Loc));
3977  }
3978 }
3979 
3981  if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
3982  return;
3983  assert(UD.shadow_size() &&
3984  "We shouldn't be codegening an invalid UsingDecl containing no decls");
3985  // Emitting one decl is sufficient - debuggers can detect that this is an
3986  // overloaded name & provide lookup for all the overloads.
3987  const UsingShadowDecl &USD = **UD.shadow_begin();
3988 
3989  // FIXME: Skip functions with undeduced auto return type for now since we
3990  // don't currently have the plumbing for separate declarations & definitions
3991  // of free functions and mismatched types (auto in the declaration, concrete
3992  // return type in the definition)
3993  if (const auto *FD = dyn_cast<FunctionDecl>(USD.getUnderlyingDecl()))
3994  if (const auto *AT =
3995  FD->getType()->getAs<FunctionProtoType>()->getContainedAutoType())
3996  if (AT->getDeducedType().isNull())
3997  return;
3998  if (llvm::DINode *Target =
3999  getDeclarationOrDefinition(USD.getUnderlyingDecl())) {
4000  auto Loc = USD.getLocation();
4001  DBuilder.createImportedDeclaration(
4002  getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target,
4003  getOrCreateFile(Loc), getLineNumber(Loc));
4004  }
4005 }
4006 
4008  if (CGM.getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
4009  return;
4010  if (Module *M = ID.getImportedModule()) {
4012  auto Loc = ID.getLocation();
4013  DBuilder.createImportedDeclaration(
4014  getCurrentContextDescriptor(cast<Decl>(ID.getDeclContext())),
4015  getOrCreateModuleRef(Info, DebugTypeExtRefs), getOrCreateFile(Loc),
4016  getLineNumber(Loc));
4017  }
4018 }
4019 
4020 llvm::DIImportedEntity *
4022  if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
4023  return nullptr;
4024  auto &VH = NamespaceAliasCache[&NA];
4025  if (VH)
4026  return cast<llvm::DIImportedEntity>(VH);
4027  llvm::DIImportedEntity *R;
4028  auto Loc = NA.getLocation();
4029  if (const auto *Underlying =
4030  dyn_cast<NamespaceAliasDecl>(NA.getAliasedNamespace()))
4031  // This could cache & dedup here rather than relying on metadata deduping.
4032  R = DBuilder.createImportedDeclaration(
4033  getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
4034  EmitNamespaceAlias(*Underlying), getOrCreateFile(Loc),
4035  getLineNumber(Loc), NA.getName());
4036  else
4037  R = DBuilder.createImportedDeclaration(
4038  getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())),
4039  getOrCreateNamespace(cast<NamespaceDecl>(NA.getAliasedNamespace())),
4040  getOrCreateFile(Loc), getLineNumber(Loc), NA.getName());
4041  VH.reset(R);
4042  return R;
4043 }
4044 
4045 llvm::DINamespace *
4046 CGDebugInfo::getOrCreateNamespace(const NamespaceDecl *NSDecl) {
4047  // Don't canonicalize the NamespaceDecl here: The DINamespace will be uniqued
4048  // if necessary, and this way multiple declarations of the same namespace in
4049  // different parent modules stay distinct.
4050  auto I = NamespaceCache.find(NSDecl);
4051  if (I != NamespaceCache.end())
4052  return cast<llvm::DINamespace>(I->second);
4053 
4054  llvm::DIScope *Context = getDeclContextDescriptor(NSDecl);
4055  // Don't trust the context if it is a DIModule (see comment above).
4056  llvm::DINamespace *NS =
4057  DBuilder.createNameSpace(Context, NSDecl->getName(), NSDecl->isInline());
4058  NamespaceCache[NSDecl].reset(NS);
4059  return NS;
4060 }
4061 
4062 void CGDebugInfo::setDwoId(uint64_t Signature) {
4063  assert(TheCU && "no main compile unit");
4064  TheCU->setDWOId(Signature);
4065 }
4066 
4067 
4069  // Creating types might create further types - invalidating the current
4070  // element and the size(), so don't cache/reference them.
4071  for (size_t i = 0; i != ObjCInterfaceCache.size(); ++i) {
4072  ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i];
4073  llvm::DIType *Ty = E.Type->getDecl()->getDefinition()
4074  ? CreateTypeDefinition(E.Type, E.Unit)
4075  : E.Decl;
4076  DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty);
4077  }
4078 
4079  for (auto p : ReplaceMap) {
4080  assert(p.second);
4081  auto *Ty = cast<llvm::DIType>(p.second);
4082  assert(Ty->isForwardDecl());
4083 
4084  auto it = TypeCache.find(p.first);
4085  assert(it != TypeCache.end());
4086  assert(it->second);
4087 
4088  DBuilder.replaceTemporary(llvm::TempDIType(Ty),
4089  cast<llvm::DIType>(it->second));
4090  }
4091 
4092  for (const auto &p : FwdDeclReplaceMap) {
4093  assert(p.second);
4094  llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(p.second));
4095  llvm::Metadata *Repl;
4096 
4097  auto it = DeclCache.find(p.first);
4098  // If there has been no definition for the declaration, call RAUW
4099  // with ourselves, that will destroy the temporary MDNode and
4100  // replace it with a standard one, avoiding leaking memory.
4101  if (it == DeclCache.end())
4102  Repl = p.second;
4103  else
4104  Repl = it->second;
4105 
4106  if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(Repl))
4107  Repl = GVE->getVariable();
4108  DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl));
4109  }
4110 
4111  // We keep our own list of retained types, because we need to look
4112  // up the final type in the type cache.
4113  for (auto &RT : RetainedTypes)
4114  if (auto MD = TypeCache[RT])
4115  DBuilder.retainType(cast<llvm::DIType>(MD));
4116 
4117  DBuilder.finalize();
4118 }
4119 
4121  if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo)
4122  return;
4123 
4124  if (auto *DieTy = getOrCreateType(Ty, getOrCreateMainFile()))
4125  // Don't ignore in case of explicit cast where it is referenced indirectly.
4126  DBuilder.retainType(DieTy);
4127 }
4128 
4130  if (LexicalBlockStack.empty())
4131  return llvm::DebugLoc();
4132 
4133  llvm::MDNode *Scope = LexicalBlockStack.back();
4134  return llvm::DebugLoc::get(
4135  getLineNumber(Loc), getColumnNumber(Loc), Scope);
4136 }
Kind getKind() const
Definition: Type.h:2105
unsigned getNumElements() const
Definition: Type.h:2822
Defines the clang::ASTContext interface.
bool isObjCOneArgSelector() const
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:5508
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5177
void print(raw_ostream &OS, const PrintingPolicy &Policy, bool SuppressNNS=false) const
Print the template name.
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1618
static bool hasDefaultSetterName(const ObjCPropertyDecl *PD, const ObjCMethodDecl *Setter)
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:237
void EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block, llvm::Value *Arg, unsigned ArgNo, llvm::Value *LocalAddr, CGBuilderTy &Builder)
Emit call to llvm.dbg.declare for the block-literal argument to a block invocation function...
Smart pointer class that efficiently represents Objective-C method names.
std::string DwarfDebugFlags
The string to embed in the debug information for the compile unit, if non-empty.
A class which contains all the information about a particular captured value.
Definition: Decl.h:3561
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2224
CanQualType VoidPtrTy
Definition: ASTContext.h:978
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2195
static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx)
Definition: CGDebugInfo.cpp:49
A (possibly-)qualified type.
Definition: Type.h:616
ArrayRef< Capture > captures() const
Definition: Decl.h:3682
base_class_range bases()
Definition: DeclCXX.h:737
unsigned getColumn() const
Return the presumed column number of this location.
bool isMacroID() const
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Definition: TemplateBase.h:279
bool isValid() const
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2434
bool isByRef() const
Whether this is a "by ref" capture, i.e.
Definition: Decl.h:3586
void EmitExplicitCastType(QualType Ty)
Emit the type explicitly casted to.
llvm::Module & getModule() const
Defines the clang::FileManager interface and associated types.
llvm::LLVMContext & getLLVMContext()
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:232
method_range methods() const
Definition: DeclCXX.h:779
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
Definition: Version.cpp:118
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1804
MSInheritanceAttr::Spelling getMSInheritanceModel() const
Returns the inheritance model used for this record.
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3288
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1537
llvm::DIType * getOrCreateRecordType(QualType Ty, SourceLocation L)
Emit record type's standalone debug info.
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2923
bool isInvalid() const
Return true if this object is invalid or uninitialized.
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
void EmitLexicalBlockEnd(CGBuilderTy &Builder, SourceLocation Loc)
Emit metadata to indicate the end of a new lexical block and pop the current block.
llvm::iterator_range< base_class_const_iterator > base_class_const_range
Definition: DeclCXX.h:735
Defines the SourceManager interface.
static bool shouldOmitDefinition(codegenoptions::DebugInfoKind DebugKind, bool DebugTypeExtRefs, const RecordDecl *RD, const LangOptions &LangOpts)
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
The template argument is an expression, and we've not resolved it to one of the other forms yet...
Definition: TemplateBase.h:69
bool isRecordType() const
Definition: Type.h:5769
QualType getUnderlyingType() const
Definition: Decl.h:2727
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization, retrieves the member specialization information.
Definition: Decl.cpp:3178
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
capture_const_iterator captures_begin() const
Definition: DeclCXX.h:1153
bool isNoReturn() const
Determines whether this function is known to be 'noreturn', through an attribute on its declaration o...
Definition: Decl.cpp:2786
Defines the C++ template declaration subclasses.
Parameter for Objective-C '_cmd' argument.
Definition: Decl.h:1392
llvm::MemoryBuffer * getBuffer(FileID FID, SourceLocation Loc, bool *Invalid=nullptr) const
Return the buffer for the specified FileID.
method_iterator method_begin() const
Method begin iterator.
Definition: DeclCXX.h:785
static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C)
TypePropertyCache< Private > Cache
Definition: Type.cpp:3326
bool hasDefinition() const
Definition: DeclCXX.h:702
const llvm::DataLayout & getDataLayout() const
static bool hasDefaultGetterName(const ObjCPropertyDecl *PD, const ObjCMethodDecl *Getter)
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
Definition: DeclCXX.h:2052
QualType getPointeeType() const
Definition: Type.h:2461
The base class of the type hierarchy.
Definition: Type.h:1303
QualType getRecordType(const RecordDecl *Decl) const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2497
const Expr * getInit() const
Definition: Decl.h:1146
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:51
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:461
static void PrintTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, bool SkipBrackets=false)
Print a template argument list, including the '<' and '>' enclosing the template arguments...
bool isPrimaryBaseVirtual() const
isPrimaryBaseVirtual - Get whether the primary base for this record is virtual or not...
Definition: RecordLayout.h:212
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:112
const PreprocessorOptions & getPreprocessorOpts() const
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:94
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:306
CharUnits alignTo(const CharUnits &Align) const
alignTo - Returns the next integer (mod 2**64) that is greater than or equal to this quantity and is ...
Definition: CharUnits.h:184
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:26
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
void * getAsOpaquePtr() const
Definition: Type.h:664
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:758
void removeObjCLifetime()
Definition: Type.h:315
bool capturesCXXThis() const
Definition: Decl.h:3687
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:46
Extra information about a function prototype.
Definition: Type.h:3234
AccessSpecifier getAccess() const
Definition: DeclBase.h:451
CallingConv getCallConv() const
Definition: Type.h:3073
field_iterator field_begin() const
Definition: Decl.cpp:3912
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
Definition: Expr.cpp:1940
A this pointer adjustment.
Definition: ABI.h:108
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:1924
void EmitDeclareOfAutoVariable(const VarDecl *Decl, llvm::Value *AI, CGBuilderTy &Builder)
Emit call to llvm.dbg.declare for an automatic variable declaration.
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:113
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
Definition: DeclCXX.cpp:1845
const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const
Return the BitFieldInfo that corresponds to the field FD.
std::string SplitDwarfFile
The name for the split debug info file that we'll break out.
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:50
bool isMemberDataPointerType() const
Definition: Type.h:5745
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
void completeTemplateDefinition(const ClassTemplateSpecializationDecl &SD)
static const NamedDecl * getDefinition(const Decl *D)
Definition: SemaDecl.cpp:2453
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1434
bool isUnionType() const
Definition: Type.cpp:390
static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD)
The collection of all-type qualifiers we support.
Definition: Type.h:118
PipeType - OpenCL20.
Definition: Type.h:5419
void setInlinedAt(llvm::MDNode *InlinedAt)
Update the current inline scope.
Definition: CGDebugInfo.h:340
void EmitInlineFunctionEnd(CGBuilderTy &Builder)
End an inlined function scope.
unsigned getNumParams() const
Definition: Type.h:3338
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3354
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl, 0 if there are none.
Definition: DeclBase.cpp:354
Represents a class template specialization, which refers to a class template with a given set of temp...
One of these records is kept for each identifier that is lexed.
method_iterator end_overridden_methods() const
Definition: DeclCXX.cpp:1828
std::map< std::string, std::string > DebugPrefixMap
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Definition: Type.cpp:3209
bool hasAttr() const
Definition: DeclBase.h:521
Represents a class type in Objective C.
Definition: Type.h:4969
void removeRestrict()
Definition: Type.h:255
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3314
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:57
static bool isFunctionLocalClass(const CXXRecordDecl *RD)
isFunctionLocalClass - Return true if CXXRecordDecl is defined inside a function. ...
void EmitImportDecl(const ImportDecl &ID)
Emit an declaration.
QualType getReturnType() const
Definition: Decl.h:2106
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2366
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2960
void removeConst()
Definition: Type.h:241
bool isClass() const
Definition: Decl.h:3027
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Definition: Decl.h:511
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:1898
QualType getBlockDescriptorType() const
Gets the struct used to keep track of the descriptor for pointer to blocks.
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:1984
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that that type refers to...
Definition: Type.cpp:1533
unsigned shadow_size() const
Return the number of shadowed declarations associated with this using declaration.
Definition: DeclCXX.h:3290
void completeClassData(const RecordDecl *RD)
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
llvm::DIMacro * CreateMacro(llvm::DIMacroFile *Parent, unsigned MType, SourceLocation LineLoc, StringRef Name, StringRef Value)
Create debug info for a macro defined by a #define directive or a macro undefined by a #undef directi...
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1295
const Decl * getDecl() const
Definition: GlobalDecl.h:62
Describes a module or submodule.
Definition: Module.h:57
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
getNameForDiagnostic - Appends a human-readable name for this declaration into the given stream...
Definition: Decl.cpp:1548
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:494
const Capture & getCapture(const VarDecl *var) const
Definition: CGBlocks.h:261
Represents a C++ using-declaration.
Definition: DeclCXX.h:3183
const TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
Definition: DeclTemplate.h:527
static SmallString< 64 > constructSetterName(StringRef Name)
Return the default setter name for the given identifier.
unsigned Size
The total size of the bit-field, in bits.
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2424
param_type_range param_types() const
Definition: Type.h:3465
An lvalue ref-qualifier was provided (&).
Definition: Type.h:1262
~ApplyInlineDebugLocation()
Restore everything back to the orginial state.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:537
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:516
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
uint32_t Offset
Definition: CacheTokens.cpp:43
QualType getBaseType() const
Gets the base type of this object type.
Definition: Type.h:5030
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:4382
NamedDecl * getAliasedNamespace() const
Retrieve the namespace that this alias refers to, which may either be a NamespaceDecl or a NamespaceA...
Definition: DeclCXX.h:2955
QualType getReturnType() const
Definition: Type.h:3065
virtual void printName(raw_ostream &os) const
Definition: Decl.cpp:1447
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2018
CharUnits StorageOffset
The offset of the bitfield storage from the start of the struct.
shadow_iterator shadow_begin() const
Definition: DeclCXX.h:3283
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
void EmitGlobalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl)
Emit information about a global variable.
field_range fields() const
Definition: Decl.h:3483
Deleting dtor.
Definition: ABI.h:35
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
bool getByrefLifetime(QualType Ty, Qualifiers::ObjCLifetime &Lifetime, bool &HasByrefExtendedLayout) const
Returns true, if given type has a known lifetime.
RecordDecl * getDecl() const
Definition: Type.h:3793
static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU)
Module * Parent
The parent of this module.
Definition: Module.h:79
std::string getNameAsString() const
getNameAsString - Get a human-readable name for the declaration, even if it is one of the special kin...
Definition: Decl.h:252
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2555
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
Definition: Type.h:952
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)
Returns the common set of qualifiers while removing them from the given sets.
Definition: Type.h:171
llvm::DIType * getOrCreateInterfaceType(QualType Ty, SourceLocation Loc)
Emit an Objective-C interface type standalone debug info.
unsigned Align
Definition: ASTContext.h:118
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
bool AlignIsRequired
Definition: ASTContext.h:119
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:177
TypeClass getTypeClass() const
Definition: Type.h:1555
VarDecl * getCapturedVar() const
Retrieve the declaration of the local variable being captured.
unsigned Offset
The offset within a contiguous run of bitfields that are represented as a single "field" within the L...
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types...
Definition: Type.cpp:1930
bool hasConst() const
Definition: Type.h:237
static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx)
Definition: CGDebugInfo.cpp:58
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:796
void EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn)
Constructs the debug code for exiting a function.
llvm::DIImportedEntity * EmitNamespaceAlias(const NamespaceAliasDecl &NA)
Emit C++ namespace alias.
unsigned getLine() const
Return the presumed line number of this location.
Represents an ObjC class declaration.
Definition: DeclObjC.h:1108
uint64_t getMethodVTableIndex(GlobalDecl GD)
Locate a virtual function in the vtable.
bool empty() const
Definition: Type.h:395
detail::InMemoryDirectory::const_iterator I
QualType getAliasedType() const
Get the aliased type, if this is a specialization of a type alias template.
Definition: Type.h:4371
void removeVolatile()
Definition: Type.h:248
CharUnits getVirtualBaseOffsetOffset(const CXXRecordDecl *RD, const CXXRecordDecl *VBase)
Return the offset in chars (relative to the vtable address point) where the offset of the virtual bas...
QualType getType() const
Definition: Decl.h:589
bool isInvalid() const
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:841
field_iterator field_end() const
Definition: Decl.h:3486
bool NeedsCopyDispose
True if the block needs a custom copy or dispose function.
Definition: CGBlocks.h:218
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
Definition: Decl.h:1932
bool isPositive() const
isPositive - Test whether the quantity is greater than zero.
Definition: CharUnits.h:122
EnumDecl * getDecl() const
Definition: Type.h:3816
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2645
bool isStatic() const
Definition: DeclCXX.cpp:1552
bool isUnion() const
Definition: Decl.h:3028
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5402
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3308
static unsigned getDwarfCC(CallingConv CC)
const HeaderSearchOptions & getHeaderSearchOpts() const
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
QualType getParamType(unsigned i) const
Definition: Type.h:3339
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3129
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
CGBlockInfo - Information to generate a block literal.
Definition: CGBlocks.h:149
const TargetInfo & getTarget() const
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:636
unsigned getOwningModuleID() const
Retrieve the global ID of the module that owns this particular declaration.
Definition: DeclBase.h:693
ASTContext * Context
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
void setDwoId(uint64_t Signature)
Module debugging: Support for building PCMs.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:247
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
bool hasLocalQualifiers() const
Determine whether this particular QualType instance has any qualifiers, without looking through any t...
Definition: Type.h:720
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:34
bool hasVolatile() const
Definition: Type.h:244
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
void EmitLocation(CGBuilderTy &Builder, SourceLocation Loc)
Emit metadata to indicate a change in line/column information in the source file. ...
ApplyInlineDebugLocation(CodeGenFunction &CGF, GlobalDecl InlinedFn)
Set up the CodeGenFunction's DebugInfo to produce inline locations for the function InlinedFn...
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
const Type * getTypeForDecl() const
Definition: Decl.h:2663
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3557
QualType getPointeeType() const
Definition: Type.h:2341
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:580
Expr - This represents one expression.
Definition: Expr.h:105
QualType getBlockDescriptorExtendedType() const
Gets the struct used to keep track of the extended descriptor for pointer to blocks.
StringRef getName() const
Return the actual identifier string.
Emit only debug info necessary for generating line number tables (-gline-tables-only).
bool isInstance() const
Definition: DeclCXX.h:1930
CGCXXABI & getCXXABI() const
void EmitInlineFunctionStart(CGBuilderTy &Builder, GlobalDecl GD)
Start a new scope for an inlined function.
VarDecl * getVariable() const
The variable being captured.
Definition: Decl.h:3582
bool isStruct() const
Definition: Decl.h:3025
llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)
Return the llvm::Constant for the address of the given global variable.
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:54
bool isVirtual() const
Definition: DeclCXX.h:1947
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2551
virtual CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD)
Get the ABI-specific "this" parameter adjustment to apply in the prologue of a virtual function...
Definition: CGCXXABI.h:357
bool isTypeAlias() const
Determine if this template specialization type is for a type alias template that has been substituted...
Definition: Type.h:4367
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:956
Defines version macros and version-related utility functions for Clang.
llvm::DIMacroFile * CreateTempMacroFile(llvm::DIMacroFile *Parent, SourceLocation LineLoc, SourceLocation FileLoc)
Create debug info for a file referenced by an #include directive.
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:213
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3347
DeclContext * getDeclContext()
Definition: DeclBase.h:416
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:219
ASTContext & getContext() const
SourceLocation getLocation() const
Retrieve the source location of the capture.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
MicrosoftVTableContext & getMicrosoftVTableContext()
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:408
void completeUnusedClass(const CXXRecordDecl &D)
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition: Type.h:910
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
bool isInstanceMethod() const
Definition: DeclObjC.h:416
clang::ObjCRuntime ObjCRuntime
Definition: LangOptions.h:116
virtual llvm::Constant * EmitMemberFunctionPointer(const CXXMethodDecl *MD)
Create a member pointer for the given method.
Definition: CGCXXABI.cpp:109
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1294
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
Definition: Type.h:5298
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:681
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1724
unsigned ComputeBitfieldBitOffset(CodeGen::CodeGenModule &CGM, const ObjCInterfaceDecl *ID, const ObjCIvarDecl *Ivar)
Represents an unpacked "presumed" location which can be presented to the user.
bool isExternallyVisible() const
Definition: Decl.h:338
Represents a GCC generic vector type.
Definition: Type.h:2797
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2407
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
QualType getElementType() const
Definition: Type.h:2821
bool isGLValue() const
Definition: Expr.h:251
bool isComplexIntegerType() const
Definition: Type.cpp:402
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3473
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Definition: DeclTemplate.h:537
const SourceManager & SM
Definition: Format.cpp:1293
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:232
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3050
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:1966
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:29
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:608
The l-value was considered opaque, so the alignment was determined from a type.
void EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI, unsigned ArgNo, CGBuilderTy &Builder)
Emit call to llvm.dbg.declare for an argument variable declaration.
uint64_t getFieldOffset(const ValueDecl *FD) const
Get the offset of a FieldDecl or IndirectFieldDecl, in bits.
unsigned getVBTableIndex(const CXXRecordDecl *Derived, const CXXRecordDecl *VBase)
Returns the index of VBase in the vbtable of Derived.
CXXRecordDecl * getMostRecentCXXRecordDecl() const
Definition: Type.cpp:3834
void EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc, QualType FnType)
Emit debug info for a function declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:289
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
Definition: ASTContext.h:1945
static llvm::DINode::DIFlags getAccessFlag(AccessSpecifier Access, const RecordDecl *RD)
Convert an AccessSpecifier into the corresponding DINode flag.
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition: ObjCRuntime.h:80
uint64_t getPointerAlign(unsigned AddrSpace) const
Definition: TargetInfo.h:310
virtual void mangleCXXRTTIName(QualType T, raw_ostream &)=0
const char * getFilename() const
Return the presumed filename of this location.
llvm::Constant * EmitConstantExpr(const Expr *E, QualType DestType, CodeGenFunction *CGF=nullptr)
Try to emit the given expression as a constant; returns 0 if the expression cannot be emitted as a co...
bool isInterface() const
Definition: Decl.h:3026
Encodes a location in the source.
enumerator_range enumerators() const
Definition: Decl.h:3198
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
Definition: ASTContext.h:1014
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3810
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5489
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:259
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:1823
AnnotatedLine & Line
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5165
const CXXRecordDecl * getPrimaryBase() const
getPrimaryBase - Get the primary base for this record.
Definition: RecordLayout.h:204
llvm::StructType * StructureType
Definition: CGBlocks.h:236
void completeRequiredType(const RecordDecl *RD)
Limit generated debug info to reduce size (-fno-standalone-debug).
bool isValid() const
Return true if this is a valid SourceLocation object.
const std::string ID
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2816
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:346
static QualType getUnderlyingType(const SubRegion *R)
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
APFloat & getFloat()
Definition: APValue.h:209
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1903
TypedefNameDecl * getTypedefNameForUnnamedTagDecl(const TagDecl *TD)
const VTableLayout & getVFTableLayout(const CXXRecordDecl *RD, CharUnits VFPtrOffset)
bool hasExtendableVFPtr() const
hasVFPtr - Does this class have a virtual function table pointer that can be extended by a derived cl...
Definition: RecordLayout.h:254
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2066
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2189
Module * getImportedModule() const
Retrieve the module that was imported by the import declaration.
Definition: Decl.h:3873
ArrayRef< VTableComponent > vtable_components() const
CanQualType VoidTy
Definition: ASTContext.h:963
Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
Definition: Decl.h:3576
const CodeGenOptions & getCodeGenOpts() const
const LangOptions & getLangOpts() const
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:704
std::string getAsString() const
Derive the full selector name (e.g.
TypedefNameDecl * getDecl() const
Definition: Type.h:3593
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6105
virtual Optional< unsigned > getDWARFAddressSpace(unsigned AddressSpace) const
Definition: TargetInfo.h:1070
MangleContext & getMangleContext()
Gets the mangle context.
Definition: CGCXXABI.h:96
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
Definition: Specifiers.h:145
FileID getMainFileID() const
Returns the FileID of the main source file.
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
method_iterator method_end() const
Method past-the-end iterator.
Definition: DeclCXX.h:789
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:4396
ItaniumVTableContext & getItaniumVTableContext()
unsigned CXXThisIndex
The field index of 'this' within the block, if there is one.
Definition: CGBlocks.h:155
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1264
void removeObjCGCAttr()
Definition: Type.h:292
virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)
Create a null member pointer of the given type.
Definition: CGCXXABI.cpp:105
static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I, CXXRecordDecl::method_iterator End)
llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Loc)
ObjCTypeParamDecl * getDecl() const
Definition: Type.h:4938
void printQualifiedName(raw_ostream &OS) const
printQualifiedName - Returns human-readable qualified name for declaration, like A::B::i, for i being member of namespace A::B.
Definition: Decl.cpp:1458
bool isDynamicClass() const
Definition: DeclCXX.h:715
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:242
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:3829
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;...
Definition: ASTContext.h:1605
QualType getPointeeType() const
Definition: Type.h:2238
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
Definition: ASTContext.h:1734
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1899
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2682
QualType getType() const
Definition: Expr.h:127
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3421
CanQualType CharTy
Definition: ASTContext.h:965
Represents a template argument.
Definition: TemplateBase.h:40
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1365
void completeClass(const RecordDecl *RD)
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:235
This class organizes the cross-function state that is used while generating LLVM code.
Selector getObjCSelector() const
getObjCSelector - Get the Objective-C selector stored in this declaration name.
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Definition: DeclCXX.cpp:2209
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
Definition: Decl.cpp:3155
A qualifier set is used to build a set of qualifiers.
Definition: Type.h:5455
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1215
int getUniqueBlockCount()
Fetches the global unique block count.
StringRef Name
Definition: USRFinder.cpp:123
prop_range properties() const
Definition: DeclObjC.h:939
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:2126
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:63
bool isExplicitSpecialization() const
Definition: DeclTemplate.h:621
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition: DeclObjC.h:1471
Emit location information but do not generate debug info in the output.
This template specialization was instantiated from a template due to an explicit instantiation declar...
Definition: Specifiers.h:156
QualType getEnumType(const EnumDecl *Decl) const
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Definition: Type.h:5462
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks, lambdas, etc.
Definition: DeclBase.cpp:940
CGDebugInfo(CodeGenModule &CGM)
Definition: CGDebugInfo.cpp:62
std::string DebugCompilationDir
The string to embed in debug information as the current working directory.
EnumDecl - Represents an enum.
Definition: Decl.h:3102
unsigned StorageSize
The storage size in bits which should be used when accessing this bitfield.
Selector getSelector() const
Definition: DeclObjC.h:328
detail::InMemoryDirectory::const_iterator E
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2442
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:142
bool isFloat() const
Definition: APValue.h:184
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1102
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1557
known_extensions_range known_extensions() const
Definition: DeclObjC.h:1680
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5235
bool isCompleteDefinitionRequired() const
Return true if this complete decl is required to be complete for some existing use.
Definition: Decl.h:2966
Represents a pointer to an Objective C object.
Definition: Type.h:5220
Pointer to a block type.
Definition: Type.h:2327
llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD)
Return the appropriate linkage for the vtable, VTT, and type information of the given class...
Definition: CGVTables.cpp:730
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2448
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3784
Complex values, per C99 6.2.5p11.
Definition: Type.h:2164
SourceLocation getCaretLocation() const
Definition: Decl.h:3631
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:6042
unsigned getTypeQuals() const
Definition: Type.h:3454
CanQualType UnsignedLongTy
Definition: ASTContext.h:972
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1281
llvm::DIType * getOrCreateStandaloneType(QualType Ty, SourceLocation Loc)
Emit standalone debug info for a type.
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:291
Module * getOwningModule() const
Get the module that owns this declaration.
Definition: DeclBase.h:737
void completeType(const EnumDecl *ED)
QualType getIntegerType() const
getIntegerType - Return the integer type this enum decl corresponds to.
Definition: Decl.h:3226
virtual llvm::Constant * EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset)
Create a member pointer for the given field.
Definition: CGCXXABI.cpp:114
DeclaratorDecl * getDeclaratorForUnnamedTagDecl(const TagDecl *TD)
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
StringRef getMangledName(GlobalDecl GD)
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:1928
The template argument is a type.
Definition: TemplateBase.h:48
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1503
The template argument is actually a parameter pack.
Definition: TemplateBase.h:72
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1065
bool isObjCZeroArgSelector() const
QualType getPointeeType() const
Definition: Type.h:2381
SourceManager & getSourceManager()
Definition: ASTContext.h:616
The type-property cache.
Definition: Type.cpp:3286
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:307
std::string getQualifiedNameAsString() const
Definition: Decl.cpp:1451
A template argument list.
Definition: DeclTemplate.h:195
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
const Type * getClass() const
Definition: Type.h:2475
void EmitUsingDecl(const UsingDecl &UD)
Emit C++ using declaration.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
Definition: TemplateBase.h:253
void EmitUsingDirective(const UsingDirectiveDecl &UD)
Emit C++ using directive.
void EmitLexicalBlockStart(CGBuilderTy &Builder, SourceLocation Loc)
Emit metadata to indicate the beginning of a new lexical block and push the block onto the stack...
ArrayRef< TemplateArgument > getPackAsArray() const
Return the array of arguments in this template argument pack.
Definition: TemplateBase.h:342
Represents a type parameter type in Objective C.
Definition: Type.h:4900
Represents a C++ struct/union/class.
Definition: DeclCXX.h:267
BoundNodesTreeBuilder *const Builder
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:861
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:60
std::string MainFileName
The user provided name for the "main file", if non-empty.
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1866
bool isItaniumFamily() const
Does this ABI generally fall into the Itanium family of ABIs?
Definition: TargetCXXABI.h:135
const BlockDecl * getBlockDecl() const
Definition: CGBlocks.h:271
void EmitDeclareOfBlockDeclRefVariable(const VarDecl *variable, llvm::Value *storage, CGBuilderTy &Builder, const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint=nullptr)
Emit call to llvm.dbg.declare for an imported variable declaration in a block.
void EmitFunctionStart(GlobalDecl GD, SourceLocation Loc, SourceLocation ScopeLoc, QualType FnType, llvm::Function *Fn, CGBuilderTy &Builder)
Emit a call to llvm.dbg.function.start to indicate start of a new function.
This class is used for builtin types like 'int'.
Definition: Type.h:2084
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:410
QualType getParamTypeForDecl() const
Definition: TemplateBase.h:247
capture_const_iterator captures_end() const
Definition: DeclCXX.h:1156
virtual unsigned getVtblPtrAddressSpace() const
Definition: TargetInfo.h:1060
A SourceLocation and its associated SourceManager.
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:314
uint64_t Index
Method's index in the vftable.
void setLocation(SourceLocation Loc)
Update the current source location.
uint64_t Width
Definition: ASTContext.h:117
TagDecl * getDecl() const
Definition: Type.cpp:2986
bool isIncompleteArrayType() const
Definition: Type.h:5757
bool isInt() const
Definition: APValue.h:183
CanQualType IntTy
Definition: ASTContext.h:971
Abstracts clang modules and precompiled header files and holds everything needed to generate debug in...
bool isRecord() const
Definition: DeclBase.h:1368
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2321
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4297
bool hasRestrict() const
Definition: Type.h:251
llvm::MDNode * getInlinedAt() const
Definition: CGDebugInfo.h:343
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
QualType getElementType() const
Definition: Type.h:5432
QualType getElementType() const
Definition: Type.h:2531
bool MSVCFormatting
Use whitespace and punctuation like MSVC does.
bool capturesThis() const
Determine whether this capture handles the C++ this pointer.
Definition: LambdaCapture.h:83
static bool isClassOrMethodDLLImport(const CXXRecordDecl *RD)
Return true if the class or any of its methods are marked dllimport.
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
const BlockExpr * getBlockExpr() const
Definition: CGBlocks.h:272
A wrapper class around a pointer that always points to its canonical declaration. ...
Definition: Redeclarable.h:345
SourceLocation getLocation() const
Definition: DeclBase.h:407
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:2812
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1543
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization, retrieves the function from which it was instantiated.
Definition: Decl.cpp:3171
static SmallString< 256 > getUniqueTagTypeName(const TagType *Ty, CodeGenModule &CGM, llvm::DICompileUnit *TheCU)
In C++ mode, types have linkage, so we can rely on the ODR and on their mangled names, if they're external.
StringRef getName(const PrintingPolicy &Policy) const
Definition: Type.cpp:2524
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
EnumDecl * getDefinition() const
Definition: Decl.h:3171
Represents a C++ namespace alias.
Definition: DeclCXX.h:2861
const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const
Get or compute information about the layout of the specified Objective-C interface.
APSInt & getInt()
Definition: APValue.h:201
static bool isDefinedInClangModule(const RecordDecl *RD)
Does a type definition exist in an imported clang module?
Represents C++ using-directive.
Definition: DeclCXX.h:2758
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:683
void removeAddressSpace()
Definition: Type.h:358
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
base_class_range vbases()
Definition: DeclCXX.h:754
This class handles loading and caching of source files into memory.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
const NamedDecl * Result
Definition: USRFinder.cpp:70
bool BlockRequiresCopying(QualType Ty, const VarDecl *D)
Returns true iff we need copy/dispose helpers for the given type.
const MethodVFTableLocation & getMethodVFTableLocation(GlobalDecl GD)
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:2978
Structure with information about how a bitfield should be accessed.
bool capturesVariable() const
Determine whether this capture handles a variable.
Definition: LambdaCapture.h:89
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.