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;
63 : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()),
64 DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs),
65 DBuilder(CGM.getModule()) {
67 DebugPrefixMap[KV.first] = KV.second;
72 assert(LexicalBlockStack.empty() &&
73 "Region stack mismatch, stack not empty!");
79 init(TemporaryLocation);
86 init(TemporaryLocation, DefaultToEmpty);
90 bool DefaultToEmpty) {
97 OriginalLocation = CGF->
Builder.getCurrentDebugLocation();
98 if (TemporaryLocation.
isValid()) {
99 DI->EmitLocation(CGF->
Builder, TemporaryLocation);
103 if (DefaultToEmpty) {
104 CGF->
Builder.SetCurrentDebugLocation(llvm::DebugLoc());
109 assert(!DI->LexicalBlockStack.empty());
110 CGF->
Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
111 0, 0, DI->LexicalBlockStack.back(), DI->getInlinedAt()));
125 OriginalLocation = CGF.
Builder.getCurrentDebugLocation();
127 CGF.
Builder.SetCurrentDebugLocation(std::move(Loc));
134 CGF->
Builder.SetCurrentDebugLocation(std::move(OriginalLocation));
145 SavedLocation = DI.getLocation();
146 assert((DI.getInlinedAt() ==
147 CGF.
Builder.getCurrentDebugLocation()->getInlinedAt()) &&
148 "CGDebugInfo and IRBuilder are out of sync");
150 DI.EmitInlineFunctionStart(CGF.
Builder, InlinedFn);
158 DI.EmitLocation(CGF->
Builder, SavedLocation);
171 if (LexicalBlockStack.empty())
175 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
178 if (PCLoc.isInvalid() ||
Scope->getFilename() == PCLoc.getFilename())
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)));
193 llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(
const Decl *D) {
194 llvm::DIScope *Mod = getParentModuleOrNull(D);
199 llvm::DIScope *CGDebugInfo::getContextDescriptor(
const Decl *
Context,
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);
211 if (
const auto *NSDecl = dyn_cast<NamespaceDecl>(Context))
212 return getOrCreateNamespace(NSDecl);
214 if (
const auto *RDecl = dyn_cast<RecordDecl>(Context))
215 if (!RDecl->isDependentType())
217 getOrCreateMainFile());
221 StringRef CGDebugInfo::getFunctionName(
const FunctionDecl *FD) {
222 assert(FD &&
"Invalid FunctionDecl!");
236 if (!Info && FII && !UseQualifiedName)
240 llvm::raw_svector_ostream OS(NS);
243 if (!UseQualifiedName)
256 return internString(OS.str());
259 StringRef CGDebugInfo::getObjCMethodName(
const ObjCMethodDecl *OMD) {
260 SmallString<256> MethodName;
261 llvm::raw_svector_ostream OS(MethodName);
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();
272 OS << OC->getIdentifier()->getNameStart() <<
'('
273 << OC->getIdentifier()->getNameStart() <<
')';
275 }
else if (
const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) {
276 OS << OCD->getClassInterface()->getName() <<
'('
277 << OCD->getName() <<
')';
278 }
else if (isa<ObjCProtocolDecl>(DC)) {
282 cast<ObjCObjectPointerType>(SelfDecl->getType())->getPointeeType();
288 return internString(OS.str());
291 StringRef CGDebugInfo::getSelectorName(
Selector S) {
295 StringRef CGDebugInfo::getClassName(
const RecordDecl *RD) {
296 if (isa<ClassTemplateSpecializationDecl>(RD)) {
297 SmallString<128>
Name;
298 llvm::raw_svector_ostream OS(Name);
303 return internString(Name);
309 return II->getName();
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();
329 Name = DD->getName();
334 Name = TND->getName();
337 SmallString<256> UnnamedType(
"<unnamed-type-");
340 return internString(UnnamedType);
348 llvm::DIFile::ChecksumKind
349 CGDebugInfo::computeChecksum(
FileID FID, SmallString<32> &Checksum)
const {
353 return llvm::DIFile::CSK_None;
357 llvm::MemoryBuffer *MemBuffer = SM.
getBuffer(FID, &Invalid);
359 return llvm::DIFile::CSK_None;
362 llvm::MD5::MD5Result
Result;
364 Hash.update(MemBuffer->getBuffer());
367 Hash.stringifyResult(Result, Checksum);
368 return llvm::DIFile::CSK_MD5;
374 return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
375 remapDIPath(TheCU->getDirectory()),
376 TheCU->getFile()->getChecksumKind(),
377 TheCU->getFile()->getChecksum());
384 return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
385 remapDIPath(TheCU->getDirectory()),
386 TheCU->getFile()->getChecksumKind(),
387 TheCU->getFile()->getChecksum());
391 auto it = DIFileCache.find(fname);
393 if (it != DIFileCache.end()) {
395 if (llvm::Metadata *V = it->second)
396 return cast<llvm::DIFile>(V);
399 SmallString<32> Checksum;
400 llvm::DIFile::ChecksumKind CSKind =
401 computeChecksum(SM.
getFileID(Loc), Checksum);
403 llvm::DIFile *F = DBuilder.createFile(remapDIPath(PLoc.
getFilename()),
404 remapDIPath(getCurrentDirname()),
407 DIFileCache[fname].reset(F);
411 llvm::DIFile *CGDebugInfo::getOrCreateMainFile() {
412 return DBuilder.createFile(remapDIPath(TheCU->getFilename()),
413 remapDIPath(TheCU->getDirectory()),
414 TheCU->getFile()->getChecksumKind(),
415 TheCU->getFile()->getChecksum());
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();
433 unsigned CGDebugInfo::getColumnNumber(
SourceLocation Loc,
bool Force) {
446 StringRef CGDebugInfo::getCurrentDirname() {
450 if (!CWDName.empty())
452 SmallString<256> CWD;
453 llvm::sys::fs::current_path(CWD);
454 return CWDName = internString(CWD);
457 void CGDebugInfo::CreateCompileUnit() {
458 SmallString<32> Checksum;
459 llvm::DIFile::ChecksumKind CSKind = llvm::DIFile::CSK_None;
471 if (MainFileName.empty())
472 MainFileName =
"<stdin>";
478 std::string MainFileDir;
480 MainFileDir = remapDIPath(MainFile->getDir()->getName());
481 if (MainFileDir !=
".") {
483 llvm::sys::path::append(MainFileDirSS, MainFileName);
484 MainFileName = MainFileDirSS.str();
489 llvm::dwarf::SourceLanguage LangTag;
493 LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
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;
501 LangTag = llvm::dwarf::DW_LANG_C99;
503 LangTag = llvm::dwarf::DW_LANG_C89;
509 unsigned RuntimeVers = 0;
513 llvm::DICompileUnit::DebugEmissionKind EmissionKind;
517 EmissionKind = llvm::DICompileUnit::NoDebug;
520 EmissionKind = llvm::DICompileUnit::LineTablesOnly;
524 EmissionKind = llvm::DICompileUnit::FullDebug;
530 TheCU = DBuilder.createCompileUnit(
532 DBuilder.createFile(remapDIPath(MainFileName),
533 remapDIPath(getCurrentDirname()), CSKind, Checksum),
542 llvm::DIType *CGDebugInfo::CreateType(
const BuiltinType *BT) {
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:
555 case BuiltinType::ObjCClass:
557 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
559 getOrCreateMainFile(), 0);
561 case BuiltinType::ObjCId: {
571 ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
573 getOrCreateMainFile(), 0);
577 auto *ISATy = DBuilder.createPointerType(ClassTy, Size);
579 ObjTy = DBuilder.createStructType(
580 TheCU,
"objc_object", getOrCreateMainFile(), 0, 0, 0,
581 llvm::DINode::FlagZero,
nullptr, llvm::DINodeArray());
583 DBuilder.replaceArrays(
584 ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType(
585 ObjTy,
"isa", getOrCreateMainFile(), 0, Size, 0, 0,
586 llvm::DINode::FlagZero, ISATy)));
589 case BuiltinType::ObjCSel: {
591 SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
592 "objc_selector", TheCU,
593 getOrCreateMainFile(), 0);
597 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
598 case BuiltinType::Id: \
599 return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \
601 #include "clang/Basic/OpenCLImageTypes.def"
602 case BuiltinType::OCLSampler:
603 return getOrCreateStructPtrType(
"opencl_sampler_t",
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);
614 case BuiltinType::UChar:
615 case BuiltinType::Char_U:
616 Encoding = llvm::dwarf::DW_ATE_unsigned_char;
618 case BuiltinType::Char_S:
619 case BuiltinType::SChar:
620 Encoding = llvm::dwarf::DW_ATE_signed_char;
622 case BuiltinType::Char16:
623 case BuiltinType::Char32:
624 Encoding = llvm::dwarf::DW_ATE_UTF;
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;
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;
642 case BuiltinType::Bool:
643 Encoding = llvm::dwarf::DW_ATE_boolean;
645 case BuiltinType::Half:
646 case BuiltinType::Float:
647 case BuiltinType::LongDouble:
648 case BuiltinType::Float128:
649 case BuiltinType::Double:
655 Encoding = llvm::dwarf::DW_ATE_float;
660 case BuiltinType::Long:
663 case BuiltinType::LongLong:
664 BTName =
"long long int";
666 case BuiltinType::ULong:
667 BTName =
"long unsigned int";
669 case BuiltinType::ULongLong:
670 BTName =
"long long unsigned int";
678 return DBuilder.createBasicType(BTName, Size, Encoding);
681 llvm::DIType *CGDebugInfo::CreateType(
const ComplexType *Ty) {
683 llvm::dwarf::TypeKind Encoding = llvm::dwarf::DW_ATE_complex_float;
685 Encoding = llvm::dwarf::DW_ATE_lo_user;
688 return DBuilder.createBasicType(
"complex", Size, Encoding);
691 llvm::DIType *CGDebugInfo::CreateQualifiedType(
QualType Ty,
692 llvm::DIFile *Unit) {
703 llvm::dwarf::Tag Tag;
705 Tag = llvm::dwarf::DW_TAG_const_type;
708 Tag = llvm::dwarf::DW_TAG_volatile_type;
711 Tag = llvm::dwarf::DW_TAG_restrict_type;
714 assert(Qc.
empty() &&
"Unknown type qualifier for debug info");
715 return getOrCreateType(
QualType(T, 0), Unit);
722 return DBuilder.createQualifiedType(Tag, FromTy);
726 llvm::DIFile *Unit) {
734 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
738 llvm::DIType *CGDebugInfo::CreateType(
const PointerType *Ty,
739 llvm::DIFile *Unit) {
740 return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
746 switch (TheCU->getSourceLanguage()) {
747 case llvm::dwarf::DW_LANG_C_plus_plus:
749 case llvm::dwarf::DW_LANG_ObjC_plus_plus:
750 return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD);
760 llvm::DICompileUnit *TheCU) {
761 SmallString<256> FullName;
769 llvm::raw_svector_ostream Out(FullName);
776 llvm::dwarf::Tag Tag;
778 Tag = llvm::dwarf::DW_TAG_structure_type;
780 Tag = llvm::dwarf::DW_TAG_union_type;
785 Tag = llvm::dwarf::DW_TAG_class_type;
790 llvm::DICompositeType *
791 CGDebugInfo::getOrCreateRecordFwdDecl(
const RecordType *Ty,
792 llvm::DIScope *Ctx) {
795 return cast<llvm::DICompositeType>(T);
796 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
798 StringRef RDName = getClassName(RD);
805 llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType(
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)));
814 llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
817 llvm::DIFile *Unit) {
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);
832 return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
833 Align, DWARFAddressSpace);
836 llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
837 llvm::DIType *&
Cache) {
840 Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name,
841 TheCU, getOrCreateMainFile(), 0);
843 Cache = DBuilder.createPointerType(Cache, Size);
848 llvm::DIFile *Unit) {
851 uint64_t FieldSize, FieldOffset;
853 llvm::DINodeArray Elements;
857 EltTys.push_back(CreateMemberType(Unit, FType,
"reserved", &FieldOffset));
858 EltTys.push_back(CreateMemberType(Unit, FType,
"Size", &FieldOffset));
860 Elements = DBuilder.getOrCreateArray(EltTys);
863 llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock;
867 DBuilder.createStructType(Unit,
"__block_descriptor",
nullptr, LineNo,
868 FieldOffset, 0, Flags,
nullptr, Elements);
873 auto *DescTy = DBuilder.createPointerType(EltTy, Size);
877 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
879 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
880 EltTys.push_back(CreateMemberType(Unit, FType,
"__reserved", &FieldOffset));
882 EltTys.push_back(CreateMemberType(Unit, FType,
"__FuncPtr", &FieldOffset));
887 EltTys.push_back(DBuilder.createMemberType(
888 Unit,
"__descriptor",
nullptr, LineNo, FieldSize, FieldAlign, FieldOffset,
889 llvm::DINode::FlagZero, DescTy));
891 FieldOffset += FieldSize;
892 Elements = DBuilder.getOrCreateArray(EltTys);
899 DBuilder.createStructType(Unit,
"",
nullptr, LineNo,
900 FieldOffset, 0, Flags,
nullptr, Elements);
902 return DBuilder.createPointerType(EltTy, Size);
906 llvm::DIFile *Unit) {
911 llvm::raw_svector_ostream OS(NS);
919 auto *AliasDecl = cast<TypeAliasTemplateDecl>(
923 return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(Loc),
925 getDeclContextDescriptor(AliasDecl));
928 llvm::DIType *CGDebugInfo::CreateType(
const TypedefType *Ty,
929 llvm::DIFile *Unit) {
935 return DBuilder.createTypedef(
937 Ty->
getDecl()->
getName(), getOrCreateFile(Loc), getLineNumber(Loc),
938 getDeclContextDescriptor(Ty->
getDecl()));
948 return llvm::dwarf::DW_CC_BORLAND_stdcall;
950 return llvm::dwarf::DW_CC_BORLAND_msfastcall;
952 return llvm::dwarf::DW_CC_BORLAND_thiscall;
954 return llvm::dwarf::DW_CC_LLVM_vectorcall;
956 return llvm::dwarf::DW_CC_BORLAND_pascal;
975 llvm::DIType *CGDebugInfo::CreateType(
const FunctionType *Ty,
976 llvm::DIFile *Unit) {
980 EltTys.push_back(getOrCreateType(Ty->
getReturnType(), Unit));
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());
993 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys);
994 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
1009 if (Access == Default)
1010 return llvm::DINode::FlagZero;
1014 return llvm::DINode::FlagPrivate;
1016 return llvm::DINode::FlagProtected;
1018 return llvm::DINode::FlagPublic;
1020 return llvm::DINode::FlagZero;
1022 llvm_unreachable(
"unexpected access enumerator");
1025 llvm::DIType *CGDebugInfo::createBitFieldType(
const FieldDecl *BitFieldDecl,
1026 llvm::DIScope *RecordTy,
1028 StringRef Name = BitFieldDecl->
getName();
1031 llvm::DIFile *VUnit = getOrCreateFile(Loc);
1032 llvm::DIType *DebugType = getOrCreateType(Ty, VUnit);
1035 llvm::DIFile *File = getOrCreateFile(Loc);
1036 unsigned Line = getLineNumber(Loc);
1040 uint64_t SizeInBits = BitFieldInfo.
Size;
1041 assert(SizeInBits > 0 &&
"found named 0-width bitfield");
1042 uint64_t StorageOffsetInBits =
1050 uint64_t OffsetInBits = StorageOffsetInBits + Offset;
1052 return DBuilder.createBitFieldMemberType(
1053 RecordTy, Name, File, Line, SizeInBits, OffsetInBits, StorageOffsetInBits,
1060 uint32_t AlignInBits, llvm::DIFile *tunit,
1061 llvm::DIScope *scope,
const RecordDecl *RD) {
1062 llvm::DIType *debugType = getOrCreateType(type, tunit);
1065 llvm::DIFile *file = getOrCreateFile(loc);
1066 unsigned line = getLineNumber(loc);
1068 uint64_t SizeInBits = 0;
1069 auto Align = AlignInBits;
1072 SizeInBits = TI.
Width;
1078 return DBuilder.createMemberType(scope, name, file, line, SizeInBits,
1079 Align, offsetInBits, flags, debugType);
1082 void CGDebugInfo::CollectRecordLambdaFields(
1084 llvm::DIType *RecordTy) {
1090 unsigned fieldno = 0;
1093 I !=
E; ++
I, ++Field, ++fieldno) {
1097 assert(!Field->isBitField() &&
"lambdas don't have bitfield members!");
1099 StringRef VName = V->
getName();
1100 llvm::DIFile *VUnit = getOrCreateFile(Loc);
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);
1112 llvm::DIFile *VUnit = getOrCreateFile(f->
getLocation());
1114 llvm::DIType *fieldType = createFieldType(
1118 elements.push_back(fieldType);
1123 llvm::DIDerivedType *
1124 CGDebugInfo::CreateRecordStaticField(
const VarDecl *Var, llvm::DIType *RecordTy,
1129 llvm::DIFile *VUnit = getOrCreateFile(Var->
getLocation());
1130 llvm::DIType *VTy = getOrCreateType(Var->
getType(), VUnit);
1132 unsigned LineNumber = getLineNumber(Var->
getLocation());
1133 StringRef VName = Var->
getName();
1134 llvm::Constant *C =
nullptr;
1147 llvm::DIDerivedType *GV = DBuilder.createStaticMemberType(
1148 RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Align);
1153 void CGDebugInfo::CollectRecordNormalField(
1154 const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit,
1157 StringRef name = field->
getName();
1164 llvm::DIType *FieldType;
1166 FieldType = createBitFieldType(field, RecordTy, RD);
1171 OffsetInBits, Align, tunit, RecordTy, RD);
1174 elements.push_back(FieldType);
1177 void CGDebugInfo::CollectRecordNestedRecord(
1181 if (isa<InjectedClassNameType>(Ty))
1184 llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc));
1185 elements.push_back(nestedType);
1188 void CGDebugInfo::CollectRecordFields(
1189 const RecordDecl *record, llvm::DIFile *tunit,
1191 llvm::DICompositeType *RecordTy) {
1194 if (CXXDecl && CXXDecl->
isLambda())
1195 CollectRecordLambdaFields(CXXDecl, elements, RecordTy);
1204 unsigned fieldNo = 0;
1208 for (
const auto *
I : record->
decls())
1209 if (
const auto *V = dyn_cast<VarDecl>(
I)) {
1210 if (V->hasAttr<NoDebugAttr>())
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);
1219 auto Field = CreateRecordStaticField(V, RecordTy, record);
1220 elements.push_back(Field);
1222 }
else if (
const auto *field = dyn_cast<FieldDecl>(
I)) {
1223 CollectRecordNormalField(field, layout.
getFieldOffset(fieldNo), tunit,
1224 elements, RecordTy, record);
1228 }
else if (
const auto *nestedRec = dyn_cast<CXXRecordDecl>(
I))
1229 if (IncludeNestedRecords && !nestedRec->isImplicit() &&
1230 nestedRec->getDeclContext() == record)
1231 CollectRecordNestedRecord(nestedRec, elements);
1235 llvm::DISubroutineType *
1236 CGDebugInfo::getOrCreateMethodType(
const CXXMethodDecl *Method,
1237 llvm::DIFile *Unit) {
1240 return cast_or_null<llvm::DISubroutineType>(
1241 getOrCreateType(
QualType(Func, 0), Unit));
1246 llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType(
1249 llvm::DITypeRefArray Args(
1250 cast<llvm::DISubroutineType>(getOrCreateType(
QualType(Func, 0), Unit))
1252 assert(Args.size() &&
"Invalid number of arguments!");
1257 Elts.push_back(Args[0]);
1261 if (isa<ClassTemplateSpecializationDecl>(RD)) {
1263 const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr);
1268 llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit);
1269 llvm::DIType *ThisPtrType =
1270 DBuilder.createPointerType(PointeeType, Size, Align);
1275 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1276 Elts.push_back(ThisPtrType);
1278 llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit);
1280 ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType);
1281 Elts.push_back(ThisPtrType);
1285 for (
unsigned i = 1, e = Args.size(); i != e; ++i)
1286 Elts.push_back(Args[i]);
1288 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
1290 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1292 Flags |= llvm::DINode::FlagLValueReference;
1294 Flags |= llvm::DINode::FlagRValueReference;
1296 return DBuilder.createSubroutineType(EltTypeArray, Flags,
1303 if (
const auto *NRD = dyn_cast<CXXRecordDecl>(RD->
getDeclContext()))
1310 llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
1311 const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) {
1313 isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
1315 StringRef MethodName = getFunctionName(Method);
1316 llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit);
1320 StringRef MethodLinkageName;
1330 llvm::DIFile *MethodDefUnit =
nullptr;
1331 unsigned MethodLine = 0;
1333 MethodDefUnit = getOrCreateFile(Method->
getLocation());
1334 MethodLine = getLineNumber(Method->
getLocation());
1338 llvm::DIType *ContainingType =
nullptr;
1339 unsigned Virtuality = 0;
1340 unsigned VIndex = 0;
1341 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
1346 Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual;
1348 Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
1353 if (!isa<CXXDestructorDecl>(Method))
1370 Flags |= llvm::DINode::FlagIntroducedVirtual;
1379 ContainingType = RecordTy;
1383 Flags |= llvm::DINode::FlagArtificial;
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;
1393 Flags |= llvm::DINode::FlagPrototyped;
1395 Flags |= llvm::DINode::FlagLValueReference;
1397 Flags |= llvm::DINode::FlagRValueReference;
1399 llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit);
1400 llvm::DISubprogram *SP = DBuilder.createMethod(
1401 RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
1402 MethodTy,
false,
false, Virtuality,
1403 VIndex, ThisAdjustment, ContainingType, Flags, CGM.
getLangOpts().Optimize,
1404 TParamsArray.get());
1411 void CGDebugInfo::CollectCXXMemberFunctions(
1418 for (
const auto *
I : RD->
decls()) {
1443 EltTys.push_back(MI == SPCache.end()
1444 ? CreateCXXMemberFunction(Method, Unit, RecordTy)
1445 : static_cast<llvm::Metadata *>(MI->second));
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);
1459 CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->
vbases(), SeenTypes,
1460 llvm::DINode::FlagIndirectVirtualBase);
1464 void CGDebugInfo::CollectCXXBasesAux(
1469 llvm::DINode::DIFlags StartingFlags) {
1471 for (
const auto &BI : Bases) {
1473 cast<CXXRecordDecl>(BI.getType()->getAs<
RecordType>()->getDecl());
1474 if (!SeenTypes.insert(
Base).second)
1476 auto *BaseTy = getOrCreateType(BI.getType(), Unit);
1477 llvm::DINode::DIFlags BFlags = StartingFlags;
1478 uint64_t BaseOffset;
1480 if (BI.isVirtual()) {
1493 BFlags |= llvm::DINode::FlagVirtual;
1501 DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset, BFlags);
1502 EltTys.push_back(DTy);
1509 llvm::DIFile *Unit) {
1511 for (
unsigned i = 0, e = TAList.size(); i != e; ++i) {
1518 llvm::DIType *TTy = getOrCreateType(TA.
getAsType(), Unit);
1519 TemplateParams.push_back(
1520 DBuilder.createTemplateTypeParameter(TheCU, Name, TTy));
1524 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1531 llvm::DIType *TTy = getOrCreateType(T, Unit);
1532 llvm::Constant *V =
nullptr;
1536 if (
const auto *VD = dyn_cast<VarDecl>(D))
1540 else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->
isInstance())
1542 else if (
const auto *FD = dyn_cast<FunctionDecl>(D))
1546 else if (
const auto *MPT = dyn_cast<MemberPointerType>(T.
getTypePtr())) {
1555 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1557 cast_or_null<llvm::Constant>(V->stripPointerCasts())));
1561 llvm::DIType *TTy = getOrCreateType(T, Unit);
1562 llvm::Constant *V =
nullptr;
1565 if (
const auto *MPT = dyn_cast<MemberPointerType>(T.
getTypePtr()))
1571 if (MPT->isMemberDataPointer())
1574 V = llvm::ConstantInt::get(CGM.
Int8Ty, 0);
1575 TemplateParams.push_back(DBuilder.createTemplateValueParameter(
1576 TheCU, Name, TTy, V));
1579 TemplateParams.push_back(DBuilder.createTemplateTemplateParameter(
1580 TheCU, Name,
nullptr,
1584 TemplateParams.push_back(DBuilder.createTemplateParameterPack(
1585 TheCU, Name,
nullptr,
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()));
1603 "These argument types shouldn't exist in concrete types");
1606 return DBuilder.getOrCreateArray(TemplateParams);
1610 CGDebugInfo::CollectFunctionTemplateParams(
const FunctionDecl *FD,
1611 llvm::DIFile *Unit) {
1617 return CollectTemplateParams(
1620 return llvm::DINodeArray();
1623 llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams(
1630 return CollectTemplateParams(TPList, TAList.
asArray(), Unit);
1633 llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) {
1635 return VTablePtrType;
1640 llvm::Metadata *STy = getOrCreateType(Context.
IntTy, Unit);
1641 llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy);
1642 llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements);
1648 llvm::DIType *vtbl_ptr_type =
1649 DBuilder.createPointerType(SubTy, Size, 0, DWARFAddressSpace,
1651 VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size);
1652 return VTablePtrType;
1655 StringRef CGDebugInfo::getVTableName(
const CXXRecordDecl *RD) {
1660 void CGDebugInfo::CollectVTableInfo(
const CXXRecordDecl *RD, llvm::DIFile *Unit,
1662 llvm::DICompositeType *RecordTy) {
1678 llvm::DIType *VPtrTy =
nullptr;
1681 if (NeedVTableShape) {
1686 unsigned VSlotCount =
1688 unsigned VTableWidth = PtrWidth * VSlotCount;
1694 llvm::DIType *VTableType =
1695 DBuilder.createPointerType(
nullptr, VTableWidth, 0, DWARFAddressSpace,
1697 EltTys.push_back(VTableType);
1700 VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth);
1708 VPtrTy = getOrCreateVTablePtrType(Unit);
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);
1720 llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc));
1732 assert(!D.
isNull() &&
"null type");
1733 llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc));
1734 assert(T &&
"could not create debug info for type");
1745 auto I = TypeCache.find(TyPtr);
1746 if (
I == TypeCache.end() || !cast<llvm::DIType>(
I->second)->isForwardDecl())
1748 llvm::DIType *Res = CreateTypeDefinition(Ty->
castAs<
EnumType>());
1749 assert(!Res->isForwardDecl());
1750 TypeCache[TyPtr].reset(Res);
1761 if (RD->
hasAttr<DLLImportAttr>())
1764 if (MD->
hasAttr<DLLImportAttr>())
1770 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
1771 if (CXXRD->isDynamicClass() &&
1773 llvm::GlobalValue::AvailableExternallyLinkage &&
1784 auto I = TypeCache.find(TyPtr);
1785 if (
I != TypeCache.end() && !cast<llvm::DIType>(
I->second)->isForwardDecl())
1788 assert(!Res->isForwardDecl());
1789 TypeCache[TyPtr].reset(Res);
1796 if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() &&
1810 if (
auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) {
1838 if (!LangOpts.CPlusPlus)
1860 if (
const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD))
1861 Spec = SD->getSpecializationKind();
1876 llvm::DIType *T = getTypeOrNull(Ty);
1877 if (T && T->isForwardDecl())
1881 llvm::DIType *CGDebugInfo::CreateType(
const RecordType *Ty) {
1883 llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(
QualType(Ty, 0)));
1887 T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD));
1891 return CreateTypeDefinition(Ty);
1894 llvm::DIType *CGDebugInfo::CreateTypeDefinition(
const RecordType *Ty) {
1898 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
1906 llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty, DefUnit);
1912 if (
const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD))
1913 CollectContainingType(CXXDecl, FwdDecl);
1916 LexicalBlockStack.emplace_back(&*FwdDecl);
1917 RegionMap[Ty->
getDecl()].reset(FwdDecl);
1929 CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl);
1930 CollectVTableInfo(CXXDecl, DefUnit, EltTys, FwdDecl);
1934 CollectRecordFields(RD, DefUnit, EltTys, FwdDecl);
1936 CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl);
1938 LexicalBlockStack.pop_back();
1939 RegionMap.erase(Ty->
getDecl());
1941 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
1942 DBuilder.replaceArrays(FwdDecl, Elements);
1944 if (FwdDecl->isTemporary())
1946 llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl));
1948 RegionMap[Ty->
getDecl()].reset(FwdDecl);
1953 llvm::DIFile *Unit) {
1959 llvm::DIFile *Unit) {
1964 return DBuilder.createTypedef(
1966 Ty->
getDecl()->
getName(), getOrCreateFile(Loc), getLineNumber(Loc),
1967 getDeclContextDescriptor(Ty->
getDecl()));
1995 llvm::DIFile *Unit) {
2005 return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type,
2007 getDeclContextDescriptor(ID), Unit, 0);
2010 llvm::DIFile *DefUnit = getOrCreateFile(ID->
getLocation());
2013 static_cast<llvm::dwarf::SourceLanguage
>(TheCU->getSourceLanguage());
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));
2027 return CreateTypeDefinition(Ty, Unit);
2032 bool CreateSkeletonCU) {
2037 auto ModRef = ModuleCache.find(M);
2038 if (ModRef != ModuleCache.end())
2039 return cast<llvm::DIModule>(ModRef->second);
2042 SmallString<128> ConfigMacros;
2044 llvm::raw_svector_ostream OS(ConfigMacros);
2048 for (
auto &M : PPOpts.Macros) {
2051 const std::string &
Macro = M.first;
2052 bool Undef = M.second;
2053 OS <<
"\"-" << (Undef ?
'U' :
'D');
2054 for (
char c : Macro)
2056 case '\\' : OS <<
"\\\\";
break;
2057 case '"' : OS <<
"\\\"";
break;
2064 bool IsRootModule = M ? !M->
Parent :
true;
2065 if (CreateSkeletonCU && IsRootModule) {
2069 uint64_t Signature =
2074 DIB.createCompileUnit(TheCU->getSourceLanguage(),
2076 TheCU->getProducer(),
true, StringRef(), 0,
2077 Mod.
getASTFile(), llvm::DICompileUnit::FullDebug,
2081 llvm::DIModule *Parent =
2082 IsRootModule ?
nullptr
2083 : getOrCreateModuleRef(
2086 llvm::DIModule *DIMod =
2087 DBuilder.createModule(Parent, Mod.
getModuleName(), ConfigMacros,
2089 ModuleCache[M].reset(DIMod);
2094 llvm::DIFile *Unit) {
2096 llvm::DIFile *DefUnit = getOrCreateFile(ID->
getLocation());
2098 unsigned RuntimeLang = TheCU->getSourceLanguage();
2104 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2106 Flags |= llvm::DINode::FlagObjcClassComplete;
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);
2114 TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl);
2117 LexicalBlockStack.emplace_back(RealDecl);
2118 RegionMap[Ty->
getDecl()].reset(RealDecl);
2125 llvm::DIType *SClassTy =
2130 llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0,
2131 llvm::DINode::FlagZero);
2132 EltTys.push_back(InhTag);
2138 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2139 unsigned PLine = getLineNumber(Loc);
2142 llvm::MDNode *PropertyNode = DBuilder.createObjCProperty(
2143 PD->getName(), PUnit, PLine,
2145 : getSelectorName(PD->getGetterName()),
2147 : getSelectorName(PD->getSetterName()),
2148 PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit));
2149 EltTys.push_back(PropertyNode);
2152 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
2154 for (
auto *PD : ClassExt->properties()) {
2155 PropertySet.insert(PD->getIdentifier());
2161 if (!PropertySet.insert(PD->getIdentifier()).second)
2168 unsigned FieldNo = 0;
2171 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
2175 StringRef FieldName = Field->getName();
2178 if (FieldName.empty())
2182 llvm::DIFile *FieldDefUnit = getOrCreateFile(Field->getLocation());
2183 unsigned FieldLine = getLineNumber(Field->getLocation());
2185 uint64_t FieldSize = 0;
2186 uint32_t FieldAlign = 0;
2188 if (!FType->isIncompleteArrayType()) {
2191 FieldSize = Field->isBitField()
2197 uint64_t FieldOffset;
2202 if (Field->isBitField()) {
2213 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2215 Flags = llvm::DINode::FlagProtected;
2217 Flags = llvm::DINode::FlagPrivate;
2219 Flags = llvm::DINode::FlagPublic;
2221 llvm::MDNode *PropertyNode =
nullptr;
2224 ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) {
2227 llvm::DIFile *PUnit = getOrCreateFile(Loc);
2228 unsigned PLine = getLineNumber(Loc);
2231 PropertyNode = DBuilder.createObjCProperty(
2232 PD->getName(), PUnit, PLine,
2234 PD->getGetterName()),
2236 PD->getSetterName()),
2237 PD->getPropertyAttributes(),
2238 getOrCreateType(PD->getType(), PUnit));
2242 FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine,
2243 FieldSize, FieldAlign, FieldOffset, Flags,
2244 FieldTy, PropertyNode);
2245 EltTys.push_back(FieldTy);
2248 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
2249 DBuilder.replaceArrays(RealDecl, Elements);
2251 LexicalBlockStack.pop_back();
2255 llvm::DIType *CGDebugInfo::CreateType(
const VectorType *Ty,
2256 llvm::DIFile *Unit) {
2257 llvm::DIType *ElementTy = getOrCreateType(Ty->
getElementType(), Unit);
2264 llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(0, Count);
2265 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
2270 return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray);
2273 llvm::DIType *CGDebugInfo::CreateType(
const ArrayType *Ty, llvm::DIFile *Unit) {
2278 if (
const auto *VAT = dyn_cast<VariableArrayType>(Ty)) {
2302 while ((Ty = dyn_cast<ArrayType>(EltTy))) {
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()) {
2316 if (Size->EvaluateAsInt(V, CGM.
getContext()))
2317 Count = V.getExtValue();
2322 Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count));
2326 llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts);
2328 return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit),
2333 llvm::DIFile *Unit) {
2334 return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty,
2339 llvm::DIFile *Unit) {
2340 return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, Ty,
2346 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
2355 case MSInheritanceAttr::Keyword_single_inheritance:
2356 Flags |= llvm::DINode::FlagSingleInheritance;
2358 case MSInheritanceAttr::Keyword_multiple_inheritance:
2359 Flags |= llvm::DINode::FlagMultipleInheritance;
2361 case MSInheritanceAttr::Keyword_virtual_inheritance:
2362 Flags |= llvm::DINode::FlagVirtualInheritance;
2364 case MSInheritanceAttr::Keyword_unspecified_inheritance:
2372 return DBuilder.createMemberPointerType(
2378 return DBuilder.createMemberPointerType(
2382 ClassType, Size, 0, Flags);
2385 llvm::DIType *CGDebugInfo::CreateType(
const AtomicType *Ty, llvm::DIFile *U) {
2387 return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy);
2390 llvm::DIType* CGDebugInfo::CreateType(
const PipeType *Ty,
2395 llvm::DIType *CGDebugInfo::CreateEnumType(
const EnumType *Ty) {
2407 bool isImportedFromModule =
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));
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);
2430 ReplaceMap.emplace_back(
2431 std::piecewise_construct, std::make_tuple(Ty),
2432 std::make_tuple(static_cast<llvm::Metadata *>(RetTy)));
2436 return CreateTypeDefinition(Ty);
2439 llvm::DIType *CGDebugInfo::CreateTypeDefinition(
const EnumType *Ty) {
2454 Enumerators.push_back(DBuilder.createEnumerator(
2455 Enum->getName(),
Enum->getInitVal().getSExtValue()));
2459 llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators);
2461 llvm::DIFile *DefUnit = getOrCreateFile(ED->
getLocation());
2463 llvm::DIScope *EnumContext = getDeclContextDescriptor(ED);
2464 llvm::DIType *ClassTy =
2466 return DBuilder.createEnumerationType(EnumContext, ED->
getName(), DefUnit,
2467 Line, Size, Align, EltArray, ClassTy,
2473 StringRef Name, StringRef Value) {
2474 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
2475 return DBuilder.createMacro(Parent, Line, MType, Name, Value);
2481 llvm::DIFile *FName = getOrCreateFile(FileLoc);
2482 unsigned Line = LineLoc.
isInvalid() ? 0 : getLineNumber(LineLoc);
2483 return DBuilder.createTempMacroFile(Parent, Line, FName);
2493 Quals += InnerQuals;
2498 case Type::TemplateSpecialization: {
2499 const auto *Spec = cast<TemplateSpecializationType>(T);
2500 if (Spec->isTypeAlias())
2502 T = Spec->desugar();
2505 case Type::TypeOfExpr:
2506 T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
2511 case Type::Decltype:
2514 case Type::UnaryTransform:
2517 case Type::Attributed:
2518 T = cast<AttributedType>(T)->getEquivalentType();
2520 case Type::Elaborated:
2521 T = cast<ElaboratedType>(T)->getNamedType();
2524 T = cast<ParenType>(T)->getInnerType();
2526 case Type::SubstTemplateTypeParm:
2527 T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
2530 case Type::DeducedTemplateSpecialization: {
2531 QualType DT = cast<DeducedType>(T)->getDeducedType();
2532 assert(!DT.
isNull() &&
"Undeduced types shouldn't reach here.");
2536 case Type::Adjusted:
2539 T = cast<AdjustedType>(T)->getAdjustedType();
2543 assert(T != LastT &&
"Type unwrapping failed to unwrap!");
2548 llvm::DIType *CGDebugInfo::getTypeOrNull(
QualType Ty) {
2554 if (it != TypeCache.end()) {
2556 if (llvm::Metadata *V = it->second)
2557 return cast<llvm::DIType>(V);
2580 llvm::DIType *CGDebugInfo::getOrCreateType(
QualType Ty, llvm::DIFile *Unit) {
2587 if (
auto *T = getTypeOrNull(Ty))
2590 llvm::DIType *Res = CreateTypeNode(Ty, Unit);
2594 TypeCache[TyPtr].reset(Res);
2599 llvm::DIModule *CGDebugInfo::getParentModuleOrNull(
const Decl *D) {
2601 if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->
getDefinition())
2607 auto Info = Reader->getSourceDescriptor(Idx);
2609 return getOrCreateModuleRef(*Info,
true);
2610 }
else if (ClangModuleMap) {
2625 return getOrCreateModuleRef(Info,
false);
2628 return getOrCreateModuleRef(PCHDescriptor,
false);
2635 llvm::DIType *CGDebugInfo::CreateTypeNode(
QualType Ty, llvm::DIFile *Unit) {
2638 return CreateQualifiedType(Ty, Unit);
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");
2649 case Type::ExtVector:
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);
2661 return CreateType(cast<BuiltinType>(Ty));
2663 return CreateType(cast<ComplexType>(Ty));
2665 return CreateType(cast<PointerType>(Ty), Unit);
2666 case Type::BlockPointer:
2667 return CreateType(cast<BlockPointerType>(Ty), Unit);
2669 return CreateType(cast<TypedefType>(Ty), Unit);
2671 return CreateType(cast<RecordType>(Ty));
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);
2682 case Type::LValueReference:
2683 return CreateType(cast<LValueReferenceType>(Ty), Unit);
2684 case Type::RValueReference:
2685 return CreateType(cast<RValueReferenceType>(Ty), Unit);
2687 case Type::MemberPointer:
2688 return CreateType(cast<MemberPointerType>(Ty), Unit);
2691 return CreateType(cast<AtomicType>(Ty), Unit);
2694 return CreateType(cast<PipeType>(Ty), Unit);
2696 case Type::TemplateSpecialization:
2697 return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
2700 case Type::Attributed:
2701 case Type::Adjusted:
2703 case Type::DeducedTemplateSpecialization:
2704 case Type::Elaborated:
2706 case Type::SubstTemplateTypeParm:
2707 case Type::TypeOfExpr:
2709 case Type::Decltype:
2710 case Type::UnaryTransform:
2711 case Type::PackExpansion:
2715 llvm_unreachable(
"type should have been unwrapped!");
2718 llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(
const RecordType *Ty,
2719 llvm::DIFile *Unit) {
2722 auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy));
2727 if (T && !T->isForwardDecl())
2731 llvm::DICompositeType *Res = CreateLimitedType(Ty);
2736 DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray());
2739 TypeCache[QTy.getAsOpaquePtr()].reset(Res);
2744 llvm::DICompositeType *CGDebugInfo::CreateLimitedType(
const RecordType *Ty) {
2748 llvm::DIFile *DefUnit = getOrCreateFile(RD->
getLocation());
2750 StringRef RDName = getClassName(RD);
2752 llvm::DIScope *RDContext = getDeclContextDescriptor(RD);
2756 auto *T = cast_or_null<llvm::DICompositeType>(
2765 return getOrCreateRecordFwdDecl(Ty, RDContext);
2772 llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType(
2773 getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align,
2774 llvm::DINode::FlagZero, FullName);
2778 switch (RealDecl->getTag()) {
2780 llvm_unreachable(
"invalid composite type tag");
2782 case llvm::dwarf::DW_TAG_array_type:
2783 case llvm::dwarf::DW_TAG_enumeration_type:
2788 if (FullName.empty())
2792 case llvm::dwarf::DW_TAG_structure_type:
2793 case llvm::dwarf::DW_TAG_union_type:
2794 case llvm::dwarf::DW_TAG_class_type:
2797 llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
2801 RegionMap[Ty->
getDecl()].reset(RealDecl);
2804 if (
const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD))
2805 DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(),
2806 CollectCXXTemplateParams(TSpecial, DefUnit));
2810 void CGDebugInfo::CollectContainingType(
const CXXRecordDecl *RD,
2811 llvm::DICompositeType *RealDecl) {
2813 llvm::DICompositeType *ContainingType =
nullptr;
2825 ContainingType = cast<llvm::DICompositeType>(
2826 getOrCreateType(
QualType(PBase->getTypeForDecl(), 0),
2829 ContainingType = RealDecl;
2831 DBuilder.replaceVTableHolder(RealDecl, ContainingType);
2834 llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit,
QualType FType,
2835 StringRef Name, uint64_t *Offset) {
2836 llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
2840 DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign,
2841 *Offset, llvm::DINode::FlagZero, FieldTy);
2842 *Offset += FieldSize;
2846 void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit,
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);
2857 Flags |= llvm::DINode::FlagPrototyped;
2862 if (LinkageName == Name || (!CGM.
getCodeGenOpts().EmitGcovArcs &&
2866 LinkageName = StringRef();
2871 FDContext = getOrCreateNamespace(NSDecl);
2874 llvm::DIScope *Mod = getParentModuleOrNull(RDecl);
2875 FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU);
2879 Flags |= llvm::DINode::FlagNoReturn;
2881 TParamsArray = CollectFunctionTemplateParams(FD, Unit);
2885 void CGDebugInfo::collectVarDeclProps(
const VarDecl *VD, llvm::DIFile *&Unit,
2887 StringRef &Name, StringRef &LinkageName,
2888 llvm::DIScope *&VDContext) {
2895 if (T->isIncompleteArrayType()) {
2897 llvm::APInt ConstVal(32, 1);
2908 if (LinkageName == Name)
2909 LinkageName = StringRef();
2928 llvm::DIScope *Mod = getParentModuleOrNull(VD);
2929 VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU);
2932 llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD,
2934 llvm::DINodeArray TParamsArray;
2935 StringRef
Name, LinkageName;
2936 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
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);
2949 ArgTypes.push_back(Parm->getType());
2954 return DBuilder.createFunction(
2955 DContext, Name, LinkageName, Unit, Line,
2956 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit),
2959 TParamsArray.get(), getFunctionDeclaration(FD));
2962 llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
2963 DContext, Name, LinkageName, Unit, Line,
2964 getOrCreateFunctionType(GD.
getDecl(), FnType, Unit),
2967 TParamsArray.get(), getFunctionDeclaration(FD));
2969 FwdDeclReplaceMap.emplace_back(std::piecewise_construct,
2970 std::make_tuple(CanonDecl),
2971 std::make_tuple(SP));
2975 llvm::DISubprogram *
2976 CGDebugInfo::getFunctionForwardDeclaration(GlobalDecl GD) {
2977 return getFunctionFwdDeclOrStub(GD,
false);
2980 llvm::DISubprogram *
2981 CGDebugInfo::getFunctionStub(GlobalDecl GD) {
2982 return getFunctionFwdDeclOrStub(GD,
true);
2985 llvm::DIGlobalVariable *
2986 CGDebugInfo::getGlobalVariableForwardDeclaration(
const VarDecl *VD) {
2988 StringRef
Name, LinkageName;
2990 llvm::DIFile *Unit = getOrCreateFile(Loc);
2991 llvm::DIScope *DContext = Unit;
2992 unsigned Line = getLineNumber(Loc);
2994 collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, DContext);
2996 auto *GV = DBuilder.createTempGlobalVariableFwdDecl(
2997 DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit),
2999 FwdDeclReplaceMap.emplace_back(
3000 std::piecewise_construct,
3002 std::make_tuple(static_cast<llvm::Metadata *>(GV)));
3006 llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(
const Decl *D) {
3011 if (
const auto *TD = dyn_cast<TypeDecl>(D))
3013 getOrCreateFile(TD->getLocation()));
3016 if (I != DeclCache.end()) {
3018 if (
auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N))
3019 return GVE->getVariable();
3020 return dyn_cast_or_null<llvm::DINode>(N);
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);
3033 llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(
const Decl *D) {
3042 auto *S = getDeclContextDescriptor(D);
3045 if (MI == SPCache.end()) {
3047 return CreateCXXMemberFunction(MD, getOrCreateFile(MD->
getLocation()),
3048 cast<llvm::DICompositeType>(S));
3051 if (MI != SPCache.end()) {
3052 auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second);
3053 if (SP && !SP->isDefinition())
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())
3070 llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(
const Decl *D,
3076 return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray(None));
3078 if (
const auto *Method = dyn_cast<CXXMethodDecl>(D))
3079 return getOrCreateMethodType(Method, F);
3084 if (
const auto *OMethod = dyn_cast<ObjCMethodDecl>(D)) {
3089 QualType ResultTy = OMethod->getReturnType();
3094 QualType(OMethod->getClassInterface()->getTypeForDecl(), 0));
3096 Elts.push_back(getOrCreateType(ResultTy, F));
3099 if (
auto *SelfDecl = OMethod->getSelfDecl())
3100 SelfDeclTy = SelfDecl->getType();
3101 else if (
auto *FPT = dyn_cast<FunctionProtoType>(FnType))
3104 if (!SelfDeclTy.
isNull())
3105 Elts.push_back(CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F)));
3107 Elts.push_back(DBuilder.createArtificialType(
3110 for (
const auto *PI : OMethod->parameters())
3111 Elts.push_back(getOrCreateType(PI->getType(), F));
3113 if (OMethod->isVariadic())
3114 Elts.push_back(DBuilder.createUnspecifiedParameter());
3116 llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts);
3117 return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero,
3123 if (
const auto *FD = dyn_cast<FunctionDecl>(D))
3127 if (
const auto *FPT = dyn_cast<FunctionProtoType>(FnType))
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,
3136 return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F));
3144 StringRef LinkageName;
3146 FnBeginRegionCount.push_back(LexicalBlockStack.size());
3149 bool HasDecl = (D !=
nullptr);
3151 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3152 llvm::DIFile *Unit = getOrCreateFile(Loc);
3153 llvm::DIScope *FDContext = Unit;
3154 llvm::DINodeArray TParamsArray;
3157 LinkageName = Fn->getName();
3158 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
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);
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;
3176 Name = Fn->getName();
3177 Flags |= llvm::DINode::FlagPrototyped;
3179 if (Name.startswith(
"\01"))
3180 Name = Name.substr(1);
3183 Flags |= llvm::DINode::FlagArtificial;
3187 unsigned LineNo = getLineNumber(Loc);
3188 unsigned ScopeLine = getLineNumber(ScopeLoc);
3195 llvm::DISubprogram *SP = DBuilder.createFunction(
3196 FDContext, Name, LinkageName, Unit, LineNo,
3197 getOrCreateFunctionType(D, FnType, Unit), Fn->hasLocalLinkage(),
3198 true , ScopeLine, Flags, CGM.
getLangOpts().Optimize,
3199 TParamsArray.get(), getFunctionDeclaration(D));
3200 Fn->setSubprogram(SP);
3204 if (HasDecl && isa<FunctionDecl>(D))
3208 LexicalBlockStack.emplace_back(SP);
3211 RegionMap[D].reset(SP);
3217 StringRef LinkageName;
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)) {
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;
3235 llvm_unreachable(
"not a function or ObjC method");
3237 if (!Name.empty() && Name[0] ==
'\01')
3238 Name = Name.substr(1);
3241 Flags |= llvm::DINode::FlagArtificial;
3246 unsigned LineNo = getLineNumber(Loc);
3247 unsigned ScopeLine = 0;
3249 DBuilder.retainType(DBuilder.createFunction(
3250 FDContext, Name, LinkageName, Unit, LineNo,
3251 getOrCreateFunctionType(D, FnType, Unit),
false ,
3252 false , ScopeLine, Flags, CGM.
getLangOpts().Optimize,
3253 TParamsArray.get(), getFunctionDeclaration(D)));
3257 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
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);
3272 assert(CurInlinedAt &&
"unbalanced inline scope stack");
3284 llvm::MDNode *
Scope = LexicalBlockStack.back();
3285 Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(
3286 getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope, CurInlinedAt));
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)));
3298 void CGDebugInfo::AppendAddressSpaceXDeref(
3299 unsigned AddressSpace,
3303 if (!DWARFAddressSpace)
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);
3318 Builder.SetCurrentDebugLocation(
3319 llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc),
3320 LexicalBlockStack.back(), CurInlinedAt));
3326 CreateLexicalBlock(Loc);
3331 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
3339 LexicalBlockStack.pop_back();
3343 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
3344 unsigned RCount = FnBeginRegionCount.back();
3345 assert(RCount <= LexicalBlockStack.size() &&
"Region stack mismatch");
3348 while (LexicalBlockStack.size() != RCount) {
3351 LexicalBlockStack.pop_back();
3353 FnBeginRegionCount.pop_back();
3355 if (Fn && Fn->getSubprogram())
3356 DBuilder.finalizeSubprogram(Fn->getSubprogram());
3359 llvm::DIType *CGDebugInfo::EmitTypeForVarWithBlocksAttr(
const VarDecl *VD,
3360 uint64_t *XOffset) {
3364 uint64_t FieldSize, FieldOffset;
3365 uint32_t FieldAlign;
3367 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
3372 EltTys.push_back(CreateMemberType(Unit, FType,
"__isa", &FieldOffset));
3373 EltTys.push_back(CreateMemberType(Unit, FType,
"__forwarding", &FieldOffset));
3375 EltTys.push_back(CreateMemberType(Unit, FType,
"__flags", &FieldOffset));
3376 EltTys.push_back(CreateMemberType(Unit, FType,
"__size", &FieldOffset));
3379 if (HasCopyAndDispose) {
3382 CreateMemberType(Unit, FType,
"__copy_helper", &FieldOffset));
3384 CreateMemberType(Unit, FType,
"__destroy_helper", &FieldOffset));
3386 bool HasByrefExtendedLayout;
3389 HasByrefExtendedLayout) &&
3390 HasByrefExtendedLayout) {
3393 CreateMemberType(Unit, FType,
"__byref_variable_layout", &FieldOffset));
3402 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
3405 llvm::APInt pad(32, NumPaddingBytes.
getQuantity());
3408 EltTys.push_back(CreateMemberType(Unit, FType,
"", &FieldOffset));
3413 llvm::DIType *FieldTy = getOrCreateType(FType, Unit);
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;
3424 llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys);
3426 llvm::DINode::DIFlags Flags = llvm::DINode::FlagBlockByrefStruct;
3428 return DBuilder.createStructType(Unit,
"", Unit, 0, FieldOffset, 0, Flags,
3436 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
3437 if (VD->
hasAttr<NoDebugAttr>())
3443 llvm::DIFile *Unit =
nullptr;
3447 uint64_t XOffset = 0;
3448 if (VD->
hasAttr<BlocksAttr>())
3449 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
3451 Ty = getOrCreateType(VD->
getType(), Unit);
3466 llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero;
3468 Flags |= llvm::DINode::FlagArtificial;
3473 AppendAddressSpaceXDeref(AddressSpace, Expr);
3477 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) {
3480 Flags |= llvm::DINode::FlagObjectPointer;
3487 auto *
Scope = cast<llvm::DIScope>(LexicalBlockStack.back());
3488 StringRef Name = VD->
getName();
3489 if (!Name.empty()) {
3490 if (VD->
hasAttr<BlocksAttr>()) {
3493 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3498 Expr.push_back(llvm::dwarf::DW_OP_deref);
3499 Expr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3504 }
else if (
const auto *RT = dyn_cast<RecordType>(VD->
getType())) {
3507 const auto *RD = cast<RecordDecl>(RT->getDecl());
3516 for (
const auto *Field : RD->
fields()) {
3517 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3518 StringRef FieldName = Field->getName();
3521 if (FieldName.empty() && !isa<RecordType>(Field->getType()))
3526 auto *D = DBuilder.createAutoVariable(
3528 Flags | llvm::DINode::FlagArtificial, FieldAlign);
3531 DBuilder.insertDeclare(
3532 Storage, D, DBuilder.createExpression(Expr),
3533 llvm::DebugLoc::get(Line, Column,
Scope, CurInlinedAt),
3534 Builder.GetInsertBlock());
3541 ? DBuilder.createParameterVariable(
3542 Scope, Name, *ArgNo, Unit, Line, Ty,
3544 : DBuilder.createAutoVariable(
Scope, Name, Unit, Line, Ty,
3549 DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr),
3550 llvm::DebugLoc::get(Line, Column,
Scope, CurInlinedAt),
3551 Builder.GetInsertBlock());
3558 EmitDeclare(VD, Storage,
llvm::None, Builder);
3561 llvm::DIType *CGDebugInfo::CreateSelfType(
const QualType &QualTy,
3563 llvm::DIType *CachedTy = getTypeOrNull(QualTy);
3566 return DBuilder.createObjectPointerType(Ty);
3571 const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) {
3573 assert(!LexicalBlockStack.empty() &&
"Region stack mismatch, stack empty!");
3575 if (Builder.GetInsertBlock() ==
nullptr)
3577 if (VD->
hasAttr<NoDebugAttr>())
3580 bool isByRef = VD->
hasAttr<BlocksAttr>();
3582 uint64_t XOffset = 0;
3583 llvm::DIFile *Unit = getOrCreateFile(VD->
getLocation());
3586 Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
3588 Ty = getOrCreateType(VD->
getType(), Unit);
3592 if (
const auto *IPD = dyn_cast<ImplicitParamDecl>(VD))
3594 Ty = CreateSelfType(VD->
getType(), Ty);
3598 unsigned Column = getColumnNumber(VD->
getLocation());
3607 addr.push_back(llvm::dwarf::DW_OP_deref);
3608 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3611 addr.push_back(llvm::dwarf::DW_OP_deref);
3612 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3617 addr.push_back(llvm::dwarf::DW_OP_deref);
3618 addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
3626 auto *D = DBuilder.createAutoVariable(
3627 cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->
getName(), Unit,
3628 Line, Ty,
false, llvm::DINode::FlagZero, Align);
3632 llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back(), CurInlinedAt);
3633 auto *Expr = DBuilder.createExpression(addr);
3635 DBuilder.insertDeclare(Storage, D, Expr, DL, InsertPoint);
3637 DBuilder.insertDeclare(Storage, D, Expr, DL, Builder.GetInsertBlock());
3644 EmitDeclare(VD, AI, ArgNo, Builder);
3648 struct BlockLayoutChunk {
3649 uint64_t OffsetInBits;
3652 bool operator<(
const BlockLayoutChunk &l,
const BlockLayoutChunk &r) {
3653 return l.OffsetInBits < r.OffsetInBits;
3668 llvm::DIFile *tunit = getOrCreateFile(loc);
3669 unsigned line = getLineNumber(loc);
3670 unsigned column = getColumnNumber(loc);
3673 getDeclContextDescriptor(blockDecl);
3675 const llvm::StructLayout *blockLayout =
3680 blockLayout->getElementOffsetInBits(0),
3682 fields.push_back(createFieldType(
"__flags", C.
IntTy, loc,
AS_public,
3683 blockLayout->getElementOffsetInBits(1),
3685 fields.push_back(createFieldType(
"__reserved", C.
IntTy, loc,
AS_public,
3686 blockLayout->getElementOffsetInBits(2),
3690 fields.push_back(createFieldType(
"__FuncPtr", FnPtrType, loc,
AS_public,
3691 blockLayout->getElementOffsetInBits(3),
3693 fields.push_back(createFieldType(
3697 loc,
AS_public, blockLayout->getElementOffsetInBits(4), tunit, tunit));
3705 BlockLayoutChunk chunk;
3706 chunk.OffsetInBits =
3707 blockLayout->getElementOffsetInBits(block.
CXXThisIndex);
3708 chunk.Capture =
nullptr;
3709 chunks.push_back(chunk);
3713 for (
const auto &capture : blockDecl->
captures()) {
3714 const VarDecl *variable = capture.getVariable();
3721 BlockLayoutChunk chunk;
3722 chunk.OffsetInBits =
3723 blockLayout->getElementOffsetInBits(captureInfo.
getIndex());
3724 chunk.Capture = &capture;
3725 chunks.push_back(chunk);
3729 llvm::array_pod_sort(chunks.begin(), chunks.end());
3731 for (
const BlockLayoutChunk &Chunk : chunks) {
3732 uint64_t offsetInBits = Chunk.OffsetInBits;
3741 else if (
auto *RDecl = dyn_cast<CXXRecordDecl>(blockDecl->
getParent()))
3742 type =
QualType(RDecl->getTypeForDecl(), 0);
3744 llvm_unreachable(
"unexpected block declcontext");
3746 fields.push_back(createFieldType(
"this", type, loc,
AS_public,
3747 offsetInBits, tunit, tunit));
3752 StringRef name = variable->
getName();
3754 llvm::DIType *fieldType;
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);
3769 offsetInBits, Align, tunit, tunit);
3771 fields.push_back(fieldType);
3775 llvm::raw_svector_ostream(typeName) <<
"__block_literal_"
3778 llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields);
3780 llvm::DIType *type =
3781 DBuilder.createStructType(tunit, typeName.str(), tunit, line,
3783 llvm::DINode::FlagZero,
nullptr, fieldsArray);
3787 llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial;
3788 auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back());
3791 auto *debugVar = DBuilder.createParameterVariable(
3792 scope, Arg->getName(), ArgNo, tunit, line,
type,
3797 DBuilder.insertDbgValueIntrinsic(
3798 LocalAddr, 0, debugVar, DBuilder.createExpression(),
3799 llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
3800 Builder.GetInsertBlock());
3804 DBuilder.insertDeclare(Arg, debugVar, DBuilder.createExpression(),
3805 llvm::DebugLoc::get(line, column, scope, CurInlinedAt),
3806 Builder.GetInsertBlock());
3809 llvm::DIDerivedType *
3810 CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(
const VarDecl *D) {
3815 if (MI != StaticDataMemberCache.end()) {
3816 assert(MI->second &&
"Static data member declaration should still exist");
3823 auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D));
3824 return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC));
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;
3832 for (
const auto *Field : RD->
fields()) {
3833 llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit);
3834 StringRef FieldName = Field->getName();
3837 if (FieldName.empty()) {
3838 if (
const auto *RT = dyn_cast<RecordType>(Field->getType()))
3839 GVE = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName,
3844 GVE = DBuilder.createGlobalVariableExpression(
3845 DContext, FieldName, LinkageName, Unit, LineNo, FieldTy,
3846 Var->hasLocalLinkage());
3847 Var->addDebugInfo(GVE);
3855 if (D->
hasAttr<NoDebugAttr>())
3861 if (Cached != DeclCache.end())
3862 return Var->addDebugInfo(
3863 cast<llvm::DIGlobalVariableExpression>(Cached->second));
3866 llvm::DIFile *Unit =
nullptr;
3867 llvm::DIScope *DContext =
nullptr;
3869 StringRef DeclName, LinkageName;
3871 collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName, DContext);
3875 llvm::DIGlobalVariableExpression *GVE =
nullptr;
3883 "unnamed non-anonymous struct or union?");
3884 GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext);
3889 unsigned AddressSpace =
3891 AppendAddressSpaceXDeref(AddressSpace, Expr);
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);
3905 if (VD->
hasAttr<NoDebugAttr>())
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?");
3920 if (Ty->getTag() == llvm::dwarf::DW_TAG_enumeration_type)
3926 auto *VarD = cast<VarDecl>(VD);
3927 if (VarD->isStaticDataMember()) {
3928 auto *RD = cast<RecordDecl>(VarD->getDeclContext());
3929 getDeclContextDescriptor(VarD);
3934 RetainedTypes.push_back(
3939 llvm::DIScope *DContext = getDeclContextDescriptor(VD);
3941 auto &GV = DeclCache[VD];
3944 llvm::DIExpression *InitExpr =
nullptr;
3949 DBuilder.createConstantValueExpression(Init.
getInt().getExtValue());
3951 InitExpr = DBuilder.createConstantValueExpression(
3952 Init.
getFloat().bitcastToAPInt().getZExtValue());
3954 GV.reset(DBuilder.createGlobalVariableExpression(
3955 DContext, Name, StringRef(), Unit, getLineNumber(VD->
getLocation()), Ty,
3956 true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD),
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);
3974 DBuilder.createImportedModule(
3976 getOrCreateNamespace(NSDecl), getOrCreateFile(Loc), getLineNumber(Loc));
3984 "We shouldn't be codegening an invalid UsingDecl containing no decls");
3993 if (
const auto *FD = dyn_cast<FunctionDecl>(USD.getUnderlyingDecl()))
3994 if (
const auto *AT =
3996 if (AT->getDeducedType().isNull())
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));
4008 if (CGM.
getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB)
4013 DBuilder.createImportedDeclaration(
4015 getOrCreateModuleRef(Info, DebugTypeExtRefs), getOrCreateFile(Loc),
4016 getLineNumber(Loc));
4020 llvm::DIImportedEntity *
4024 auto &VH = NamespaceAliasCache[&NA];
4026 return cast<llvm::DIImportedEntity>(VH);
4027 llvm::DIImportedEntity *R;
4029 if (
const auto *Underlying =
4032 R = DBuilder.createImportedDeclaration(
4035 getLineNumber(Loc), NA.
getName());
4037 R = DBuilder.createImportedDeclaration(
4040 getOrCreateFile(Loc), getLineNumber(Loc), NA.
getName());
4046 CGDebugInfo::getOrCreateNamespace(
const NamespaceDecl *NSDecl) {
4050 auto I = NamespaceCache.find(NSDecl);
4051 if (I != NamespaceCache.end())
4052 return cast<llvm::DINamespace>(I->second);
4054 llvm::DIScope *Context = getDeclContextDescriptor(NSDecl);
4056 llvm::DINamespace *NS =
4057 DBuilder.createNameSpace(Context, NSDecl->
getName(), NSDecl->
isInline());
4058 NamespaceCache[NSDecl].reset(NS);
4063 assert(TheCU &&
"no main compile unit");
4064 TheCU->setDWOId(Signature);
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)
4076 DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty);
4079 for (
auto p : ReplaceMap) {
4081 auto *Ty = cast<llvm::DIType>(p.second);
4082 assert(Ty->isForwardDecl());
4084 auto it = TypeCache.find(p.first);
4085 assert(it != TypeCache.end());
4088 DBuilder.replaceTemporary(llvm::TempDIType(Ty),
4089 cast<llvm::DIType>(it->second));
4092 for (
const auto &p : FwdDeclReplaceMap) {
4094 llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(p.second));
4095 llvm::Metadata *Repl;
4097 auto it = DeclCache.find(p.first);
4101 if (it == DeclCache.end())
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));
4113 for (
auto &RT : RetainedTypes)
4114 if (
auto MD = TypeCache[RT])
4115 DBuilder.retainType(cast<llvm::DIType>(MD));
4117 DBuilder.finalize();
4124 if (
auto *DieTy = getOrCreateType(Ty, getOrCreateMainFile()))
4126 DBuilder.retainType(DieTy);
4130 if (LexicalBlockStack.empty())
4131 return llvm::DebugLoc();
4133 llvm::MDNode *
Scope = LexicalBlockStack.back();
4134 return llvm::DebugLoc::get(
4135 getLineNumber(Loc), getColumnNumber(Loc), Scope);
unsigned getNumElements() const
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...
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
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...
static bool hasDefaultSetterName(const ObjCPropertyDecl *PD, const ObjCMethodDecl *Setter)
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
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.
PointerType - C99 6.7.5.1 - Pointer Declarators.
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx)
A (possibly-)qualified type.
ArrayRef< Capture > captures() const
CodeGenTypes & getTypes()
unsigned getColumn() const
Return the presumed column number of this location.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
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.
bool isByRef() const
Whether this is a "by ref" capture, i.e.
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.
method_range methods() const
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number...
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
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...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
llvm::DIType * getOrCreateRecordType(QualType Ty, SourceLocation L)
Emit record type's standalone debug info.
FunctionType - C99 6.7.5.3 - Function Declarators.
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
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.
The template argument is an expression, and we've not resolved it to one of the other forms yet...
bool isRecordType() const
QualType getUnderlyingType() const
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization, retrieves the member specialization information.
Decl - This represents one declaration (or definition), e.g.
capture_const_iterator captures_begin() const
bool isNoReturn() const
Determines whether this function is known to be 'noreturn', through an attribute on its declaration o...
Defines the C++ template declaration subclasses.
Parameter for Objective-C '_cmd' argument.
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.
static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C)
TypePropertyCache< Private > Cache
bool hasDefinition() const
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.
QualType getPointeeType() const
The base class of the type hierarchy.
QualType getRecordType(const RecordDecl *Decl) const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
const Expr * getInit() const
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
NamespaceDecl - Represent a C++ namespace.
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...
NamedDecl * getParam(unsigned Idx)
const PreprocessorOptions & getPreprocessorOpts() const
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
RefQualifierKind RefQualifier
Expr * getAsExpr() const
Retrieve the template argument as an expression.
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 ...
Describes the capture of a variable or of this, or of a C++1y init-capture.
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
void * getAsOpaquePtr() const
VarDecl - An instance of this class is created to represent a variable declaration or definition...
void removeObjCLifetime()
bool capturesCXXThis() const
Represents an empty template argument, e.g., one that has not been deduced.
Extra information about a function prototype.
AccessSpecifier getAccess() const
CallingConv getCallConv() const
field_iterator field_begin() const
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
A this pointer adjustment.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
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.
QualType getThisType(ASTContext &C) const
Returns the type of the this pointer.
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.
bool isMemberDataPointerType() const
Describes how types, statements, expressions, and declarations should be printed. ...
void completeTemplateDefinition(const ClassTemplateSpecializationDecl &SD)
static const NamedDecl * getDefinition(const Decl *D)
ParmVarDecl - Represents a parameter to a function.
static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD)
The collection of all-type qualifiers we support.
void setInlinedAt(llvm::MDNode *InlinedAt)
Update the current inline scope.
void EmitInlineFunctionEnd(CGBuilderTy &Builder)
End an inlined function scope.
unsigned getNumParams() const
RecordDecl - Represents a struct/union/class.
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl, 0 if there are none.
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.
StringRef getPath() const
method_iterator end_overridden_methods() const
std::map< std::string, std::string > DebugPrefixMap
QualType apply(const ASTContext &Context, QualType QT) const
Apply the collected qualifiers to the given type.
Represents a class type in Objective C.
CGDebugInfo * getDebugInfo()
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...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
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
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
bool isPure() const
Whether this virtual function is pure, i.e.
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.
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that that type refers to...
unsigned shadow_size() const
Return the number of shadowed declarations associated with this using declaration.
void completeClassData(const RecordDecl *RD)
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
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...
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
const Decl * getDecl() const
Describes a module or submodule.
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...
Provides information about a function template specialization, which is a FunctionDecl that has been ...
const Capture & getCapture(const VarDecl *var) const
Represents a C++ using-declaration.
const TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
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].
param_type_range param_types() const
An lvalue ref-qualifier was provided (&).
~ApplyInlineDebugLocation()
Restore everything back to the orginial state.
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isInline() const
Returns true if this is an inline namespace declaration.
CharUnits - This is an opaque type for sizes expressed in character units.
QualType getBaseType() const
Gets the base type of this object type.
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
NamedDecl * getAliasedNamespace() const
Retrieve the namespace that this alias refers to, which may either be a NamespaceDecl or a NamespaceA...
QualType getReturnType() const
virtual void printName(raw_ostream &os) const
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
CharUnits StorageOffset
The offset of the bitfield storage from the start of the struct.
shadow_iterator shadow_begin() const
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
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
static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU)
Module * Parent
The parent of this module.
std::string getNameAsString() const
getNameAsString - Get a human-readable name for the declaration, even if it is one of the special kin...
bool isVariadic() const
Whether this function is variadic.
Scope - A scope is a transient data structure that is used while parsing the program.
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R)
Returns the common set of qualifiers while removing them from the given sets.
llvm::DIType * getOrCreateInterfaceType(QualType Ty, SourceLocation Loc)
Emit an Objective-C interface type standalone debug info.
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
TypeClass getTypeClass() const
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...
static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx)
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
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.
uint64_t getMethodVTableIndex(GlobalDecl GD)
Locate a virtual function in the vtable.
detail::InMemoryDirectory::const_iterator I
QualType getAliasedType() const
Get the aliased type, if this is a specialization of a type alias template.
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...
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
field_iterator field_end() const
bool NeedsCopyDispose
True if the block needs a custom copy or dispose function.
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
bool isPositive() const
isPositive - Test whether the quantity is greater than zero.
EnumDecl * getDecl() const
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
static unsigned getDwarfCC(CallingConv CC)
ASTFileSignature getSignature() const
const HeaderSearchOptions & getHeaderSearchOpts() const
const FileEntry * getFileEntryForID(FileID FID) const
Returns the FileEntry record for the provided FileID.
QualType getParamType(unsigned i) const
Represents a prototype with parameter type info, e.g.
FileID getFileID(SourceLocation SpellingLoc) const
Return the FileID for a SourceLocation.
CGBlockInfo - Information to generate a block literal.
const TargetInfo & getTarget() const
Represents a ValueDecl that came out of a declarator.
unsigned getOwningModuleID() const
Retrieve the global ID of the module that owns this particular declaration.
void setDwoId(uint64_t Signature)
Module debugging: Support for building PCMs.
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
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...
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
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?
const Type * getTypeForDecl() const
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
QualType getPointeeType() const
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
unsigned getIndex() const
Expr - This represents one expression.
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).
CGCXXABI & getCXXABI() const
void EmitInlineFunctionStart(CGBuilderTy &Builder, GlobalDecl GD)
Start a new scope for an inlined function.
VarDecl * getVariable() const
The variable being captured.
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...
Represents a C++ destructor within a class.
virtual CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD)
Get the ABI-specific "this" parameter adjustment to apply in the prologue of a virtual function...
bool isTypeAlias() const
Determine if this template specialization type is for a type alias template that has been substituted...
TranslationUnitDecl * getTranslationUnitDecl() const
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.
ExtProtoInfo getExtProtoInfo() const
DeclContext * getDeclContext()
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
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.
MicrosoftVTableContext & getMicrosoftVTableContext()
ImplicitParamDecl * getSelfDecl() const
void completeUnusedClass(const CXXRecordDecl &D)
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
bool isInstanceMethod() const
clang::ObjCRuntime ObjCRuntime
virtual llvm::Constant * EmitMemberFunctionPointer(const CXXMethodDecl *MD)
Create a member pointer for the given method.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isObjCQualifiedIdType() const
True if this is equivalent to 'id.
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
QualType getObjCIdType() const
Represents the Objective-CC id type.
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
Represents a GCC generic vector type.
An lvalue reference type, per C++11 [dcl.ref].
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
QualType getElementType() const
bool isComplexIntegerType() const
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
const Module * getModuleOrNull() const
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
TypedefNameDecl * getTypedefNameForAnonDecl() const
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
GlobalDecl - represents a global declaration.
const clang::PrintingPolicy & getPrintingPolicy() const
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
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.
unsigned getTypeAlign(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in bits.
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?
uint64_t getPointerAlign(unsigned AddrSpace) const
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...
Encodes a location in the source.
enumerator_range enumerators() const
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
method_iterator begin_overridden_methods() const
Interfaces are the core concept in Objective-C for object oriented design.
const CXXRecordDecl * getPrimaryBase() const
getPrimaryBase - Get the primary base for this record.
llvm::StructType * StructureType
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.
TagDecl - Represents the declaration of a struct/union/class/enum.
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
ASTContext & getASTContext() const LLVM_READONLY
static QualType getUnderlyingType(const SubRegion *R)
Cached information about one file (either on disk or in the virtual file system). ...
Represents a static or instance method of a struct/union/class.
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...
ArrayRef< ParmVarDecl * > parameters() const
ObjCCategoryDecl - Represents a category declaration.
Module * getImportedModule() const
Retrieve the module that was imported by the import declaration.
ArrayRef< VTableComponent > vtable_components() const
Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
const CodeGenOptions & getCodeGenOpts() const
const LangOptions & getLangOpts() const
Represents one property declaration in an Objective-C interface.
std::string getAsString() const
Derive the full selector name (e.g.
TypedefNameDecl * getDecl() const
const T * castAs() const
Member-template castAs<specific type>.
virtual Optional< unsigned > getDWARFAddressSpace(unsigned AddressSpace) const
MangleContext & getMangleContext()
Gets the mangle context.
This template specialization was formed from a template-id but has not yet been declared, defined, or instantiated.
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.
ArrayRef< TemplateArgument > template_arguments() const
ItaniumVTableContext & getItaniumVTableContext()
unsigned CXXThisIndex
The field index of 'this' within the block, if there is one.
An rvalue ref-qualifier was provided (&&).
virtual llvm::Constant * EmitNullMemberPointer(const MemberPointerType *MPT)
Create a null member pointer of the given type.
static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I, CXXRecordDecl::method_iterator End)
llvm::DebugLoc SourceLocToDebugLoc(SourceLocation Loc)
ObjCTypeParamDecl * getDecl() const
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.
bool isDynamicClass() const
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Describes a module import declaration, which makes the contents of the named module visible in the cu...
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;...
QualType getPointeeType() const
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
ObjCIvarDecl * getNextIvar()
Base class for declarations which introduce a typedef-name.
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.
Represents a template argument.
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
void completeClass(const RecordDecl *RD)
QualType getAsType() const
Retrieve the type for a type template argument.
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.
TemplatedKind getTemplatedKind() const
What kind of templated function this is.
A qualifier set is used to build a set of qualifiers.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
int getUniqueBlockCount()
Fetches the global unique block count.
StringRef getASTFile() const
prop_range properties() const
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
The template argument is a pack expansion of a template name that was provided for a template templat...
bool isExplicitSpecialization() const
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
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...
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.
std::string getModuleName() const
const Type * strip(QualType type)
Collect any qualifiers on the given type and return an unqualified type.
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks, lambdas, etc.
CGDebugInfo(CodeGenModule &CGM)
std::string DebugCompilationDir
The string to embed in debug information as the current working directory.
EnumDecl - Represents an enum.
unsigned StorageSize
The storage size in bits which should be used when accessing this bitfield.
Selector getSelector() const
detail::InMemoryDirectory::const_iterator E
A pointer to member type per C++ 8.3.3 - Pointers to members.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
bool isLambda() const
Determine whether this class describes a lambda function object.
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).
known_extensions_range known_extensions() const
QualType getPointeeType() const
Gets the type pointed to by this ObjC pointer.
bool isCompleteDefinitionRequired() const
Return true if this complete decl is required to be complete for some existing use.
Represents a pointer to an Objective C object.
llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD)
Return the appropriate linkage for the vtable, VTT, and type information of the given class...
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Complex values, per C99 6.2.5p11.
Don't generate debug info.
SourceLocation getCaretLocation() const
const T * getAs() const
Member-template getAs<specific type>'.
unsigned getTypeQuals() const
CanQualType UnsignedLongTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
llvm::DIType * getOrCreateStandaloneType(QualType Ty, SourceLocation Loc)
Emit standalone debug info for a type.
QualType getIntegralType() const
Retrieve the type of the integral value.
Module * getOwningModule() const
Get the module that owns this declaration.
void completeType(const EnumDecl *ED)
QualType getIntegerType() const
getIntegerType - Return the integer type this enum decl corresponds to.
virtual llvm::Constant * EmitMemberDataPointer(const MemberPointerType *MPT, CharUnits offset)
Create a member pointer for the given field.
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.
The template argument is a type.
ObjCImplementationDecl * getImplementation() const
The template argument is actually a parameter pack.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
bool isStaticDataMember() const
Determines whether this is a static data member.
bool isObjCZeroArgSelector() const
QualType getPointeeType() const
SourceManager & getSourceManager()
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
std::string getQualifiedNameAsString() const
A template argument list.
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
const Type * getClass() const
void EmitUsingDecl(const UsingDecl &UD)
Emit C++ using declaration.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
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.
Represents a type parameter type in Objective C.
Represents a C++ struct/union/class.
BoundNodesTreeBuilder *const Builder
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
The template argument is a template name that was provided for a template template parameter...
std::string MainFileName
The user provided name for the "main file", if non-empty.
ObjCIvarDecl - Represents an ObjC instance variable.
bool isItaniumFamily() const
Does this ABI generally fall into the Itanium family of ABIs?
const BlockDecl * getBlockDecl() const
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'.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
QualType getParamTypeForDecl() const
capture_const_iterator captures_end() const
virtual unsigned getVtblPtrAddressSpace() const
A SourceLocation and its associated SourceManager.
ObjCInterfaceDecl * getSuperClass() const
uint64_t Index
Method's index in the vftable.
void setLocation(SourceLocation Loc)
Update the current source location.
TagDecl * getDecl() const
bool isIncompleteArrayType() const
Abstracts clang modules and precompiled header files and holds everything needed to generate debug in...
unsigned getTargetAddressSpace(QualType T) const
Represents a type template specialization; the template must be a class template, a type alias templa...
llvm::MDNode * getInlinedAt() const
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
QualType getElementType() const
bool MSVCFormatting
Use whitespace and punctuation like MSVC does.
bool capturesThis() const
Determine whether this capture handles the C++ this pointer.
static bool isClassOrMethodDLLImport(const CXXRecordDecl *RD)
Return true if the class or any of its methods are marked dllimport.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
const BlockExpr * getBlockExpr() const
A wrapper class around a pointer that always points to its canonical declaration. ...
SourceLocation getLocation() const
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
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.
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
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
EnumDecl * getDefinition() const
Represents a C++ namespace alias.
const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const
Get or compute information about the layout of the specified Objective-C interface.
static bool isDefinedInClangModule(const RecordDecl *RD)
Does a type definition exist in an imported clang module?
Represents C++ using-directive.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
void removeAddressSpace()
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
base_class_range vbases()
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.
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.
Structure with information about how a bitfield should be accessed.
bool capturesVariable() const
Determine whether this capture handles a variable.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.