Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1 | //===--- CGDebugInfo.cpp - Emit Debug Information for a Module ------------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This coordinates the debug information generation while generating code. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "CGDebugInfo.h" |
| 15 | #include "CGBlocks.h" |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 16 | #include "CGCXXABI.h" |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 17 | #include "CGObjCRuntime.h" |
Bob Haarman | dff3673 | 2016-10-25 22:19:32 +0000 | [diff] [blame] | 18 | #include "CGRecordLayout.h" |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 19 | #include "CodeGenFunction.h" |
| 20 | #include "CodeGenModule.h" |
John McCall | de0fe07 | 2017-08-15 21:42:52 +0000 | [diff] [blame] | 21 | #include "ConstantEmitter.h" |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 22 | #include "clang/AST/ASTContext.h" |
| 23 | #include "clang/AST/DeclFriend.h" |
| 24 | #include "clang/AST/DeclObjC.h" |
| 25 | #include "clang/AST/DeclTemplate.h" |
| 26 | #include "clang/AST/Expr.h" |
| 27 | #include "clang/AST/RecordLayout.h" |
| 28 | #include "clang/Basic/FileManager.h" |
| 29 | #include "clang/Basic/SourceManager.h" |
| 30 | #include "clang/Basic/Version.h" |
Saleem Abdulrasool | 10a4972 | 2016-04-08 16:52:00 +0000 | [diff] [blame] | 31 | #include "clang/Frontend/CodeGenOptions.h" |
Taewook Oh | 0fb5b78 | 2017-08-16 19:36:24 +0000 | [diff] [blame] | 32 | #include "clang/Frontend/FrontendOptions.h" |
Adrian Prantl | c4bb47e | 2015-06-30 17:39:51 +0000 | [diff] [blame] | 33 | #include "clang/Lex/HeaderSearchOptions.h" |
Adrian Prantl | 9402cef | 2015-09-20 16:51:35 +0000 | [diff] [blame] | 34 | #include "clang/Lex/ModuleMap.h" |
Adrian Prantl | c4bb47e | 2015-06-30 17:39:51 +0000 | [diff] [blame] | 35 | #include "clang/Lex/PreprocessorOptions.h" |
Bob Haarman | dff3673 | 2016-10-25 22:19:32 +0000 | [diff] [blame] | 36 | #include "llvm/ADT/DenseSet.h" |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 37 | #include "llvm/ADT/SmallVector.h" |
| 38 | #include "llvm/ADT/StringExtras.h" |
Chandler Carruth | ffd5551 | 2013-01-02 11:45:17 +0000 | [diff] [blame] | 39 | #include "llvm/IR/Constants.h" |
| 40 | #include "llvm/IR/DataLayout.h" |
| 41 | #include "llvm/IR/DerivedTypes.h" |
| 42 | #include "llvm/IR/Instructions.h" |
| 43 | #include "llvm/IR/Intrinsics.h" |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 44 | #include "llvm/IR/Metadata.h" |
Chandler Carruth | ffd5551 | 2013-01-02 11:45:17 +0000 | [diff] [blame] | 45 | #include "llvm/IR/Module.h" |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 46 | #include "llvm/Support/FileSystem.h" |
Amjad Aboud | e2aab8c | 2016-12-25 10:12:27 +0000 | [diff] [blame] | 47 | #include "llvm/Support/MD5.h" |
Adrian Prantl | 0630eb7 | 2013-12-18 21:48:18 +0000 | [diff] [blame] | 48 | #include "llvm/Support/Path.h" |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 49 | using namespace clang; |
| 50 | using namespace clang::CodeGen; |
| 51 | |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 52 | static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) { |
| 53 | auto TI = Ctx.getTypeInfo(Ty); |
| 54 | return TI.AlignIsRequired ? TI.Align : 0; |
| 55 | } |
| 56 | |
| 57 | static uint32_t getTypeAlignIfRequired(QualType Ty, const ASTContext &Ctx) { |
| 58 | return getTypeAlignIfRequired(Ty.getTypePtr(), Ctx); |
| 59 | } |
| 60 | |
| 61 | static uint32_t getDeclAlignIfRequired(const Decl *D, const ASTContext &Ctx) { |
| 62 | return D->hasAttr<AlignedAttr>() ? D->getMaxAlignment() : 0; |
| 63 | } |
| 64 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 65 | CGDebugInfo::CGDebugInfo(CodeGenModule &CGM) |
Eric Christopher | 324bbbd | 2013-07-14 21:12:44 +0000 | [diff] [blame] | 66 | : CGM(CGM), DebugKind(CGM.getCodeGenOpts().getDebugInfo()), |
Adrian Prantl | 6b21ab2 | 2015-08-27 19:46:20 +0000 | [diff] [blame] | 67 | DebugTypeExtRefs(CGM.getCodeGenOpts().DebugTypeExtRefs), |
Eric Christopher | 324bbbd | 2013-07-14 21:12:44 +0000 | [diff] [blame] | 68 | DBuilder(CGM.getModule()) { |
Saleem Abdulrasool | 436256a | 2015-10-12 20:21:08 +0000 | [diff] [blame] | 69 | for (const auto &KV : CGM.getCodeGenOpts().DebugPrefixMap) |
| 70 | DebugPrefixMap[KV.first] = KV.second; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 71 | CreateCompileUnit(); |
| 72 | } |
| 73 | |
| 74 | CGDebugInfo::~CGDebugInfo() { |
| 75 | assert(LexicalBlockStack.empty() && |
| 76 | "Region stack mismatch, stack not empty!"); |
| 77 | } |
| 78 | |
David Blaikie | 66e4197 | 2015-01-14 07:38:27 +0000 | [diff] [blame] | 79 | ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 80 | SourceLocation TemporaryLocation) |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 81 | : CGF(&CGF) { |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 82 | init(TemporaryLocation); |
David Blaikie | 9b47966 | 2015-01-25 01:19:10 +0000 | [diff] [blame] | 83 | } |
| 84 | |
Adrian Prantl | 39428e7 | 2015-02-03 18:40:42 +0000 | [diff] [blame] | 85 | ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, |
Adrian Prantl | 95b24e9 | 2015-02-03 20:00:54 +0000 | [diff] [blame] | 86 | bool DefaultToEmpty, |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 87 | SourceLocation TemporaryLocation) |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 88 | : CGF(&CGF) { |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 89 | init(TemporaryLocation, DefaultToEmpty); |
Adrian Prantl | 39428e7 | 2015-02-03 18:40:42 +0000 | [diff] [blame] | 90 | } |
| 91 | |
| 92 | void ApplyDebugLocation::init(SourceLocation TemporaryLocation, |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 93 | bool DefaultToEmpty) { |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 94 | auto *DI = CGF->getDebugInfo(); |
| 95 | if (!DI) { |
| 96 | CGF = nullptr; |
| 97 | return; |
David Blaikie | 66e4197 | 2015-01-14 07:38:27 +0000 | [diff] [blame] | 98 | } |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 99 | |
| 100 | OriginalLocation = CGF->Builder.getCurrentDebugLocation(); |
Bob Haarman | c6c9b8f | 2017-09-11 22:11:57 +0000 | [diff] [blame] | 101 | |
| 102 | if (OriginalLocation && !DI->CGM.getExpressionLocationsEnabled()) |
| 103 | return; |
| 104 | |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 105 | if (TemporaryLocation.isValid()) { |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 106 | DI->EmitLocation(CGF->Builder, TemporaryLocation); |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 107 | return; |
| 108 | } |
| 109 | |
| 110 | if (DefaultToEmpty) { |
| 111 | CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc()); |
| 112 | return; |
| 113 | } |
| 114 | |
| 115 | // Construct a location that has a valid scope, but no line info. |
| 116 | assert(!DI->LexicalBlockStack.empty()); |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 117 | CGF->Builder.SetCurrentDebugLocation(llvm::DebugLoc::get( |
| 118 | 0, 0, DI->LexicalBlockStack.back(), DI->getInlinedAt())); |
Adrian Prantl | 2e0637f | 2013-07-18 00:28:02 +0000 | [diff] [blame] | 119 | } |
| 120 | |
David Blaikie | 9b47966 | 2015-01-25 01:19:10 +0000 | [diff] [blame] | 121 | ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, const Expr *E) |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 122 | : CGF(&CGF) { |
David Blaikie | 9b47966 | 2015-01-25 01:19:10 +0000 | [diff] [blame] | 123 | init(E->getExprLoc()); |
| 124 | } |
| 125 | |
David Blaikie | 66e4197 | 2015-01-14 07:38:27 +0000 | [diff] [blame] | 126 | ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF, llvm::DebugLoc Loc) |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 127 | : CGF(&CGF) { |
| 128 | if (!CGF.getDebugInfo()) { |
| 129 | this->CGF = nullptr; |
| 130 | return; |
David Blaikie | 66e4197 | 2015-01-14 07:38:27 +0000 | [diff] [blame] | 131 | } |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 132 | OriginalLocation = CGF.Builder.getCurrentDebugLocation(); |
| 133 | if (Loc) |
| 134 | CGF.Builder.SetCurrentDebugLocation(std::move(Loc)); |
David Blaikie | 66e4197 | 2015-01-14 07:38:27 +0000 | [diff] [blame] | 135 | } |
| 136 | |
| 137 | ApplyDebugLocation::~ApplyDebugLocation() { |
| 138 | // Query CGF so the location isn't overwritten when location updates are |
| 139 | // temporarily disabled (for C++ default function arguments) |
David Blaikie | d7057d9 | 2015-08-12 23:49:57 +0000 | [diff] [blame] | 140 | if (CGF) |
| 141 | CGF->Builder.SetCurrentDebugLocation(std::move(OriginalLocation)); |
David Blaikie | 66e4197 | 2015-01-14 07:38:27 +0000 | [diff] [blame] | 142 | } |
| 143 | |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 144 | ApplyInlineDebugLocation::ApplyInlineDebugLocation(CodeGenFunction &CGF, |
| 145 | GlobalDecl InlinedFn) |
| 146 | : CGF(&CGF) { |
| 147 | if (!CGF.getDebugInfo()) { |
| 148 | this->CGF = nullptr; |
| 149 | return; |
| 150 | } |
| 151 | auto &DI = *CGF.getDebugInfo(); |
| 152 | SavedLocation = DI.getLocation(); |
| 153 | assert((DI.getInlinedAt() == |
| 154 | CGF.Builder.getCurrentDebugLocation()->getInlinedAt()) && |
| 155 | "CGDebugInfo and IRBuilder are out of sync"); |
| 156 | |
| 157 | DI.EmitInlineFunctionStart(CGF.Builder, InlinedFn); |
| 158 | } |
| 159 | |
| 160 | ApplyInlineDebugLocation::~ApplyInlineDebugLocation() { |
| 161 | if (!CGF) |
| 162 | return; |
| 163 | auto &DI = *CGF->getDebugInfo(); |
| 164 | DI.EmitInlineFunctionEnd(CGF->Builder); |
| 165 | DI.EmitLocation(CGF->Builder, SavedLocation); |
| 166 | } |
| 167 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 168 | void CGDebugInfo::setLocation(SourceLocation Loc) { |
| 169 | // If the new location isn't valid return. |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 170 | if (Loc.isInvalid()) |
| 171 | return; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 172 | |
| 173 | CurLoc = CGM.getContext().getSourceManager().getExpansionLoc(Loc); |
| 174 | |
| 175 | // If we've changed files in the middle of a lexical scope go ahead |
| 176 | // and create a new lexical scope with file node if it's different |
| 177 | // from the one in the scope. |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 178 | if (LexicalBlockStack.empty()) |
| 179 | return; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 180 | |
| 181 | SourceManager &SM = CGM.getContext().getSourceManager(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 182 | auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 183 | PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 184 | |
Duncan P. N. Exon Smith | 373ee85 | 2015-04-16 01:36:36 +0000 | [diff] [blame] | 185 | if (PCLoc.isInvalid() || Scope->getFilename() == PCLoc.getFilename()) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 186 | return; |
| 187 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 188 | if (auto *LBF = dyn_cast<llvm::DILexicalBlockFile>(Scope)) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 189 | LexicalBlockStack.pop_back(); |
Duncan P. N. Exon Smith | d899f6e | 2015-04-18 00:07:30 +0000 | [diff] [blame] | 190 | LexicalBlockStack.emplace_back(DBuilder.createLexicalBlockFile( |
| 191 | LBF->getScope(), getOrCreateFile(CurLoc))); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 192 | } else if (isa<llvm::DILexicalBlock>(Scope) || |
| 193 | isa<llvm::DISubprogram>(Scope)) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 194 | LexicalBlockStack.pop_back(); |
Duncan P. N. Exon Smith | d899f6e | 2015-04-18 00:07:30 +0000 | [diff] [blame] | 195 | LexicalBlockStack.emplace_back( |
| 196 | DBuilder.createLexicalBlockFile(Scope, getOrCreateFile(CurLoc))); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 197 | } |
| 198 | } |
| 199 | |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 200 | llvm::DIScope *CGDebugInfo::getDeclContextDescriptor(const Decl *D) { |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 201 | llvm::DIScope *Mod = getParentModuleOrNull(D); |
| 202 | return getContextDescriptor(cast<Decl>(D->getDeclContext()), |
| 203 | Mod ? Mod : TheCU); |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 204 | } |
| 205 | |
| 206 | llvm::DIScope *CGDebugInfo::getContextDescriptor(const Decl *Context, |
| 207 | llvm::DIScope *Default) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 208 | if (!Context) |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 209 | return Default; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 210 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 211 | auto I = RegionMap.find(Context); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 212 | if (I != RegionMap.end()) { |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 213 | llvm::Metadata *V = I->second; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 214 | return dyn_cast_or_null<llvm::DIScope>(V); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 215 | } |
| 216 | |
| 217 | // Check namespace. |
Adrian Prantl | ddb8e06 | 2017-05-12 16:23:53 +0000 | [diff] [blame] | 218 | if (const auto *NSDecl = dyn_cast<NamespaceDecl>(Context)) |
| 219 | return getOrCreateNamespace(NSDecl); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 220 | |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 221 | if (const auto *RDecl = dyn_cast<RecordDecl>(Context)) |
David Blaikie | bfa5274 | 2013-04-19 06:56:38 +0000 | [diff] [blame] | 222 | if (!RDecl->isDependentType()) |
| 223 | return getOrCreateType(CGM.getContext().getTypeDeclType(RDecl), |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 224 | getOrCreateMainFile()); |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 225 | return Default; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 226 | } |
| 227 | |
Reid Kleckner | 59d1220 | 2017-08-08 01:33:53 +0000 | [diff] [blame] | 228 | PrintingPolicy CGDebugInfo::getPrintingPolicy() const { |
| 229 | PrintingPolicy PP = CGM.getContext().getPrintingPolicy(); |
| 230 | |
| 231 | // If we're emitting codeview, it's important to try to match MSVC's naming so |
| 232 | // that visualizers written for MSVC will trigger for our class names. In |
| 233 | // particular, we can't have spaces between arguments of standard templates |
| 234 | // like basic_string and vector. |
| 235 | if (CGM.getCodeGenOpts().EmitCodeView) |
| 236 | PP.MSVCFormatting = true; |
| 237 | |
| 238 | return PP; |
| 239 | } |
| 240 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 241 | StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 242 | assert(FD && "Invalid FunctionDecl!"); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 243 | IdentifierInfo *FII = FD->getIdentifier(); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 244 | FunctionTemplateSpecializationInfo *Info = |
| 245 | FD->getTemplateSpecializationInfo(); |
Reid Kleckner | 6010338 | 2015-12-16 02:04:40 +0000 | [diff] [blame] | 246 | |
Reid Kleckner | 31abd80 | 2016-06-30 17:41:31 +0000 | [diff] [blame] | 247 | // Emit the unqualified name in normal operation. LLVM and the debugger can |
| 248 | // compute the fully qualified name from the scope chain. If we're only |
| 249 | // emitting line table info, there won't be any scope chains, so emit the |
| 250 | // fully qualified name here so that stack traces are more accurate. |
| 251 | // FIXME: Do this when emitting DWARF as well as when emitting CodeView after |
| 252 | // evaluating the size impact. |
| 253 | bool UseQualifiedName = DebugKind == codegenoptions::DebugLineTablesOnly && |
| 254 | CGM.getCodeGenOpts().EmitCodeView; |
| 255 | |
| 256 | if (!Info && FII && !UseQualifiedName) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 257 | return FII->getName(); |
| 258 | |
Benjamin Kramer | 9170e91 | 2013-02-22 15:46:01 +0000 | [diff] [blame] | 259 | SmallString<128> NS; |
| 260 | llvm::raw_svector_ostream OS(NS); |
Reid Kleckner | 31abd80 | 2016-06-30 17:41:31 +0000 | [diff] [blame] | 261 | if (!UseQualifiedName) |
| 262 | FD->printName(OS); |
| 263 | else |
Reid Kleckner | 59d1220 | 2017-08-08 01:33:53 +0000 | [diff] [blame] | 264 | FD->printQualifiedName(OS, getPrintingPolicy()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 265 | |
Reid Kleckner | 829398e | 2016-06-17 16:11:20 +0000 | [diff] [blame] | 266 | // Add any template specialization args. |
| 267 | if (Info) { |
| 268 | const TemplateArgumentList *TArgs = Info->TemplateArguments; |
Serge Pavlov | 03e672c | 2017-11-28 16:14:14 +0000 | [diff] [blame] | 269 | printTemplateArgumentList(OS, TArgs->asArray(), getPrintingPolicy()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 270 | } |
| 271 | |
| 272 | // Copy this name on the side and use its reference. |
Benjamin Kramer | 1b18a5e | 2013-09-09 16:39:06 +0000 | [diff] [blame] | 273 | return internString(OS.str()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 274 | } |
| 275 | |
| 276 | StringRef CGDebugInfo::getObjCMethodName(const ObjCMethodDecl *OMD) { |
| 277 | SmallString<256> MethodName; |
| 278 | llvm::raw_svector_ostream OS(MethodName); |
| 279 | OS << (OMD->isInstanceMethod() ? '-' : '+') << '['; |
| 280 | const DeclContext *DC = OMD->getDeclContext(); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 281 | if (const auto *OID = dyn_cast<ObjCImplementationDecl>(DC)) { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 282 | OS << OID->getName(); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 283 | } else if (const auto *OID = dyn_cast<ObjCInterfaceDecl>(DC)) { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 284 | OS << OID->getName(); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 285 | } else if (const auto *OC = dyn_cast<ObjCCategoryDecl>(DC)) { |
Douglas Gregor | acf4fd3 | 2015-11-03 01:15:46 +0000 | [diff] [blame] | 286 | if (OC->IsClassExtension()) { |
| 287 | OS << OC->getClassInterface()->getName(); |
| 288 | } else { |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 289 | OS << OC->getIdentifier()->getNameStart() << '(' |
Douglas Gregor | acf4fd3 | 2015-11-03 01:15:46 +0000 | [diff] [blame] | 290 | << OC->getIdentifier()->getNameStart() << ')'; |
| 291 | } |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 292 | } else if (const auto *OCD = dyn_cast<ObjCCategoryImplDecl>(DC)) { |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 293 | OS << OCD->getClassInterface()->getName() << '(' << OCD->getName() << ')'; |
Adrian Prantl | b39fc14 | 2013-05-17 23:58:45 +0000 | [diff] [blame] | 294 | } else if (isa<ObjCProtocolDecl>(DC)) { |
Adrian Prantl | 6e785ec | 2013-05-17 23:49:10 +0000 | [diff] [blame] | 295 | // We can extract the type of the class from the self pointer. |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 296 | if (ImplicitParamDecl *SelfDecl = OMD->getSelfDecl()) { |
Adrian Prantl | 6e785ec | 2013-05-17 23:49:10 +0000 | [diff] [blame] | 297 | QualType ClassTy = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 298 | cast<ObjCObjectPointerType>(SelfDecl->getType())->getPointeeType(); |
Adrian Prantl | 6e785ec | 2013-05-17 23:49:10 +0000 | [diff] [blame] | 299 | ClassTy.print(OS, PrintingPolicy(LangOptions())); |
| 300 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 301 | } |
| 302 | OS << ' ' << OMD->getSelector().getAsString() << ']'; |
| 303 | |
Benjamin Kramer | 1b18a5e | 2013-09-09 16:39:06 +0000 | [diff] [blame] | 304 | return internString(OS.str()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 305 | } |
| 306 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 307 | StringRef CGDebugInfo::getSelectorName(Selector S) { |
Benjamin Kramer | 1b18a5e | 2013-09-09 16:39:06 +0000 | [diff] [blame] | 308 | return internString(S.getAsString()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 309 | } |
| 310 | |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 311 | StringRef CGDebugInfo::getClassName(const RecordDecl *RD) { |
David Majnemer | bc5976a | 2016-07-01 23:12:54 +0000 | [diff] [blame] | 312 | if (isa<ClassTemplateSpecializationDecl>(RD)) { |
| 313 | SmallString<128> Name; |
David Blaikie | 65813a3 | 2014-04-02 18:21:09 +0000 | [diff] [blame] | 314 | llvm::raw_svector_ostream OS(Name); |
Reid Kleckner | 59d1220 | 2017-08-08 01:33:53 +0000 | [diff] [blame] | 315 | RD->getNameForDiagnostic(OS, getPrintingPolicy(), |
David Blaikie | 65813a3 | 2014-04-02 18:21:09 +0000 | [diff] [blame] | 316 | /*Qualified*/ false); |
David Majnemer | bc5976a | 2016-07-01 23:12:54 +0000 | [diff] [blame] | 317 | |
| 318 | // Copy this name on the side and use its reference. |
| 319 | return internString(Name); |
Benjamin Kramer | 9170e91 | 2013-02-22 15:46:01 +0000 | [diff] [blame] | 320 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 321 | |
David Majnemer | bc5976a | 2016-07-01 23:12:54 +0000 | [diff] [blame] | 322 | // quick optimization to avoid having to intern strings that are already |
| 323 | // stored reliably elsewhere |
| 324 | if (const IdentifierInfo *II = RD->getIdentifier()) |
| 325 | return II->getName(); |
| 326 | |
| 327 | // The CodeView printer in LLVM wants to see the names of unnamed types: it is |
| 328 | // used to reconstruct the fully qualified type names. |
| 329 | if (CGM.getCodeGenOpts().EmitCodeView) { |
| 330 | if (const TypedefNameDecl *D = RD->getTypedefNameForAnonDecl()) { |
| 331 | assert(RD->getDeclContext() == D->getDeclContext() && |
| 332 | "Typedef should not be in another decl context!"); |
| 333 | assert(D->getDeclName().getAsIdentifierInfo() && |
| 334 | "Typedef was not named!"); |
| 335 | return D->getDeclName().getAsIdentifierInfo()->getName(); |
| 336 | } |
| 337 | |
| 338 | if (CGM.getLangOpts().CPlusPlus) { |
| 339 | StringRef Name; |
| 340 | |
| 341 | ASTContext &Context = CGM.getContext(); |
| 342 | if (const DeclaratorDecl *DD = Context.getDeclaratorForUnnamedTagDecl(RD)) |
| 343 | // Anonymous types without a name for linkage purposes have their |
| 344 | // declarator mangled in if they have one. |
| 345 | Name = DD->getName(); |
| 346 | else if (const TypedefNameDecl *TND = |
| 347 | Context.getTypedefNameForUnnamedTagDecl(RD)) |
| 348 | // Anonymous types without a name for linkage purposes have their |
| 349 | // associate typedef mangled in if they have one. |
| 350 | Name = TND->getName(); |
| 351 | |
| 352 | if (!Name.empty()) { |
| 353 | SmallString<256> UnnamedType("<unnamed-type-"); |
| 354 | UnnamedType += Name; |
| 355 | UnnamedType += '>'; |
| 356 | return internString(UnnamedType); |
| 357 | } |
| 358 | } |
| 359 | } |
| 360 | |
| 361 | return StringRef(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 362 | } |
| 363 | |
Scott Linder | 94834f1 | 2018-02-12 19:47:05 +0000 | [diff] [blame] | 364 | Optional<llvm::DIFile::ChecksumKind> |
Amjad Aboud | e2aab8c | 2016-12-25 10:12:27 +0000 | [diff] [blame] | 365 | CGDebugInfo::computeChecksum(FileID FID, SmallString<32> &Checksum) const { |
| 366 | Checksum.clear(); |
| 367 | |
Paul Robinson | 7617863 | 2018-05-25 22:35:59 +0000 | [diff] [blame] | 368 | if (!CGM.getCodeGenOpts().EmitCodeView && |
| 369 | CGM.getCodeGenOpts().DwarfVersion < 5) |
Scott Linder | 94834f1 | 2018-02-12 19:47:05 +0000 | [diff] [blame] | 370 | return None; |
Amjad Aboud | e2aab8c | 2016-12-25 10:12:27 +0000 | [diff] [blame] | 371 | |
| 372 | SourceManager &SM = CGM.getContext().getSourceManager(); |
| 373 | bool Invalid; |
Paul Robinson | 7617863 | 2018-05-25 22:35:59 +0000 | [diff] [blame] | 374 | llvm::MemoryBuffer *MemBuffer = SM.getBuffer(FID, &Invalid); |
| 375 | if (Invalid) |
Scott Linder | 94834f1 | 2018-02-12 19:47:05 +0000 | [diff] [blame] | 376 | return None; |
Amjad Aboud | e2aab8c | 2016-12-25 10:12:27 +0000 | [diff] [blame] | 377 | |
| 378 | llvm::MD5 Hash; |
| 379 | llvm::MD5::MD5Result Result; |
| 380 | |
| 381 | Hash.update(MemBuffer->getBuffer()); |
| 382 | Hash.final(Result); |
| 383 | |
| 384 | Hash.stringifyResult(Result, Checksum); |
| 385 | return llvm::DIFile::CSK_MD5; |
| 386 | } |
| 387 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 388 | Optional<StringRef> CGDebugInfo::getSource(const SourceManager &SM, |
| 389 | FileID FID) { |
Scott Linder | a2fbcef | 2018-02-26 17:32:31 +0000 | [diff] [blame] | 390 | if (!CGM.getCodeGenOpts().EmbedSource) |
| 391 | return None; |
| 392 | |
| 393 | bool SourceInvalid = false; |
| 394 | StringRef Source = SM.getBufferData(FID, &SourceInvalid); |
| 395 | |
| 396 | if (SourceInvalid) |
| 397 | return None; |
| 398 | |
| 399 | return Source; |
| 400 | } |
| 401 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 402 | llvm::DIFile *CGDebugInfo::getOrCreateFile(SourceLocation Loc) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 403 | if (!Loc.isValid()) |
| 404 | // If Location is not valid then use main input file. |
Scott Linder | 39ceac1 | 2018-02-26 16:31:08 +0000 | [diff] [blame] | 405 | return getOrCreateMainFile(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 406 | |
| 407 | SourceManager &SM = CGM.getContext().getSourceManager(); |
| 408 | PresumedLoc PLoc = SM.getPresumedLoc(Loc); |
| 409 | |
| 410 | if (PLoc.isInvalid() || StringRef(PLoc.getFilename()).empty()) |
| 411 | // If the location is not valid then use main input file. |
Scott Linder | 39ceac1 | 2018-02-26 16:31:08 +0000 | [diff] [blame] | 412 | return getOrCreateMainFile(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 413 | |
| 414 | // Cache the results. |
| 415 | const char *fname = PLoc.getFilename(); |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 416 | auto It = DIFileCache.find(fname); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 417 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 418 | if (It != DIFileCache.end()) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 419 | // Verify that the information still exists. |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 420 | if (llvm::Metadata *V = It->second) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 421 | return cast<llvm::DIFile>(V); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 422 | } |
| 423 | |
Amjad Aboud | e2aab8c | 2016-12-25 10:12:27 +0000 | [diff] [blame] | 424 | SmallString<32> Checksum; |
Scott Linder | 94834f1 | 2018-02-12 19:47:05 +0000 | [diff] [blame] | 425 | Optional<llvm::DIFile::ChecksumKind> CSKind = |
Amjad Aboud | e2aab8c | 2016-12-25 10:12:27 +0000 | [diff] [blame] | 426 | computeChecksum(SM.getFileID(Loc), Checksum); |
Scott Linder | 94834f1 | 2018-02-12 19:47:05 +0000 | [diff] [blame] | 427 | Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo; |
| 428 | if (CSKind) |
| 429 | CSInfo.emplace(*CSKind, Checksum); |
Amjad Aboud | e2aab8c | 2016-12-25 10:12:27 +0000 | [diff] [blame] | 430 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 431 | llvm::DIFile *F = DBuilder.createFile( |
| 432 | remapDIPath(PLoc.getFilename()), remapDIPath(getCurrentDirname()), CSInfo, |
| 433 | getSource(SM, SM.getFileID(Loc))); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 434 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 435 | DIFileCache[fname].reset(F); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 436 | return F; |
| 437 | } |
| 438 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 439 | llvm::DIFile *CGDebugInfo::getOrCreateMainFile() { |
Scott Linder | a2fbcef | 2018-02-26 17:32:31 +0000 | [diff] [blame] | 440 | return DBuilder.createFile( |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 441 | remapDIPath(TheCU->getFilename()), remapDIPath(TheCU->getDirectory()), |
Scott Linder | a2fbcef | 2018-02-26 17:32:31 +0000 | [diff] [blame] | 442 | TheCU->getFile()->getChecksum(), |
| 443 | CGM.getCodeGenOpts().EmbedSource ? TheCU->getSource() : None); |
Saleem Abdulrasool | 436256a | 2015-10-12 20:21:08 +0000 | [diff] [blame] | 444 | } |
| 445 | |
| 446 | std::string CGDebugInfo::remapDIPath(StringRef Path) const { |
| 447 | for (const auto &Entry : DebugPrefixMap) |
| 448 | if (Path.startswith(Entry.first)) |
| 449 | return (Twine(Entry.second) + Path.substr(Entry.first.size())).str(); |
| 450 | return Path.str(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 451 | } |
| 452 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 453 | unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) { |
| 454 | if (Loc.isInvalid() && CurLoc.isInvalid()) |
| 455 | return 0; |
| 456 | SourceManager &SM = CGM.getContext().getSourceManager(); |
| 457 | PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 458 | return PLoc.isValid() ? PLoc.getLine() : 0; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 459 | } |
| 460 | |
Adrian Prantl | c782242 | 2013-03-12 20:43:25 +0000 | [diff] [blame] | 461 | unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc, bool Force) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 462 | // We may not want column information at all. |
Adrian Prantl | c782242 | 2013-03-12 20:43:25 +0000 | [diff] [blame] | 463 | if (!Force && !CGM.getCodeGenOpts().DebugColumnInfo) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 464 | return 0; |
| 465 | |
| 466 | // If the location is invalid then use the current column. |
| 467 | if (Loc.isInvalid() && CurLoc.isInvalid()) |
| 468 | return 0; |
| 469 | SourceManager &SM = CGM.getContext().getSourceManager(); |
| 470 | PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 471 | return PLoc.isValid() ? PLoc.getColumn() : 0; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 472 | } |
| 473 | |
| 474 | StringRef CGDebugInfo::getCurrentDirname() { |
| 475 | if (!CGM.getCodeGenOpts().DebugCompilationDir.empty()) |
| 476 | return CGM.getCodeGenOpts().DebugCompilationDir; |
| 477 | |
| 478 | if (!CWDName.empty()) |
| 479 | return CWDName; |
| 480 | SmallString<256> CWD; |
| 481 | llvm::sys::fs::current_path(CWD); |
Benjamin Kramer | 1b18a5e | 2013-09-09 16:39:06 +0000 | [diff] [blame] | 482 | return CWDName = internString(CWD); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 483 | } |
| 484 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 485 | void CGDebugInfo::CreateCompileUnit() { |
Amjad Aboud | e2aab8c | 2016-12-25 10:12:27 +0000 | [diff] [blame] | 486 | SmallString<32> Checksum; |
Scott Linder | 94834f1 | 2018-02-12 19:47:05 +0000 | [diff] [blame] | 487 | Optional<llvm::DIFile::ChecksumKind> CSKind; |
| 488 | Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 489 | |
David Blaikie | aabde05 | 2014-05-14 00:29:00 +0000 | [diff] [blame] | 490 | // Should we be asking the SourceManager for the main file name, instead of |
| 491 | // accepting it as an argument? This just causes the main file name to |
| 492 | // mismatch with source locations and create extra lexical scopes or |
| 493 | // mismatched debug info (a CU with a DW_AT_file of "-", because that's what |
| 494 | // the driver passed, but functions/other things have DW_AT_file of "<stdin>" |
| 495 | // because that's what the SourceManager says) |
| 496 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 497 | // Get absolute path name. |
| 498 | SourceManager &SM = CGM.getContext().getSourceManager(); |
| 499 | std::string MainFileName = CGM.getCodeGenOpts().MainFileName; |
| 500 | if (MainFileName.empty()) |
David Blaikie | aabde05 | 2014-05-14 00:29:00 +0000 | [diff] [blame] | 501 | MainFileName = "<stdin>"; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 502 | |
| 503 | // The main file name provided via the "-main-file-name" option contains just |
| 504 | // the file name itself with no path information. This file name may have had |
| 505 | // a relative path, so we look into the actual file entry for the main |
| 506 | // file to determine the real absolute path for the file. |
| 507 | std::string MainFileDir; |
| 508 | if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { |
Saleem Abdulrasool | 436256a | 2015-10-12 20:21:08 +0000 | [diff] [blame] | 509 | MainFileDir = remapDIPath(MainFile->getDir()->getName()); |
Yaron Keren | 9fb7e90 | 2013-10-21 20:07:37 +0000 | [diff] [blame] | 510 | if (MainFileDir != ".") { |
Eric Christopher | 0a1301f | 2014-02-26 02:49:36 +0000 | [diff] [blame] | 511 | llvm::SmallString<1024> MainFileDirSS(MainFileDir); |
| 512 | llvm::sys::path::append(MainFileDirSS, MainFileName); |
| 513 | MainFileName = MainFileDirSS.str(); |
Yaron Keren | 9fb7e90 | 2013-10-21 20:07:37 +0000 | [diff] [blame] | 514 | } |
Taewook Oh | 0fb5b78 | 2017-08-16 19:36:24 +0000 | [diff] [blame] | 515 | // If the main file name provided is identical to the input file name, and |
| 516 | // if the input file is a preprocessed source, use the module name for |
| 517 | // debug info. The module name comes from the name specified in the first |
| 518 | // linemarker if the input is a preprocessed source. |
| 519 | if (MainFile->getName() == MainFileName && |
| 520 | FrontendOptions::getInputKindForExtension( |
| 521 | MainFile->getName().rsplit('.').second) |
| 522 | .isPreprocessed()) |
| 523 | MainFileName = CGM.getModule().getName().str(); |
| 524 | |
Amjad Aboud | e2aab8c | 2016-12-25 10:12:27 +0000 | [diff] [blame] | 525 | CSKind = computeChecksum(SM.getMainFileID(), Checksum); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 526 | } |
| 527 | |
Ed Maste | da70602 | 2014-05-07 12:49:30 +0000 | [diff] [blame] | 528 | llvm::dwarf::SourceLanguage LangTag; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 529 | const LangOptions &LO = CGM.getLangOpts(); |
| 530 | if (LO.CPlusPlus) { |
Erik Pilkington | fa98390 | 2018-10-30 20:31:30 +0000 | [diff] [blame] | 531 | if (LO.ObjC) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 532 | LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus; |
| 533 | else |
| 534 | LangTag = llvm::dwarf::DW_LANG_C_plus_plus; |
Erik Pilkington | fa98390 | 2018-10-30 20:31:30 +0000 | [diff] [blame] | 535 | } else if (LO.ObjC) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 536 | LangTag = llvm::dwarf::DW_LANG_ObjC; |
Pirama Arumuga Nainar | a7484c9 | 2016-06-21 21:35:11 +0000 | [diff] [blame] | 537 | } else if (LO.RenderScript) { |
| 538 | LangTag = llvm::dwarf::DW_LANG_GOOGLE_RenderScript; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 539 | } else if (LO.C99) { |
| 540 | LangTag = llvm::dwarf::DW_LANG_C99; |
| 541 | } else { |
| 542 | LangTag = llvm::dwarf::DW_LANG_C89; |
| 543 | } |
| 544 | |
| 545 | std::string Producer = getClangFullVersion(); |
| 546 | |
| 547 | // Figure out which version of the ObjC runtime we have. |
| 548 | unsigned RuntimeVers = 0; |
Erik Pilkington | fa98390 | 2018-10-30 20:31:30 +0000 | [diff] [blame] | 549 | if (LO.ObjC) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 550 | RuntimeVers = LO.ObjCRuntime.isNonFragile() ? 2 : 1; |
| 551 | |
Adrian Prantl | 826824e | 2016-04-08 22:43:06 +0000 | [diff] [blame] | 552 | llvm::DICompileUnit::DebugEmissionKind EmissionKind; |
| 553 | switch (DebugKind) { |
| 554 | case codegenoptions::NoDebugInfo: |
| 555 | case codegenoptions::LocTrackingOnly: |
| 556 | EmissionKind = llvm::DICompileUnit::NoDebug; |
| 557 | break; |
| 558 | case codegenoptions::DebugLineTablesOnly: |
| 559 | EmissionKind = llvm::DICompileUnit::LineTablesOnly; |
| 560 | break; |
Alexey Bataev | 80e1b5e | 2018-08-31 13:56:14 +0000 | [diff] [blame] | 561 | case codegenoptions::DebugDirectivesOnly: |
| 562 | EmissionKind = llvm::DICompileUnit::DebugDirectivesOnly; |
| 563 | break; |
Adrian Prantl | 826824e | 2016-04-08 22:43:06 +0000 | [diff] [blame] | 564 | case codegenoptions::LimitedDebugInfo: |
| 565 | case codegenoptions::FullDebugInfo: |
| 566 | EmissionKind = llvm::DICompileUnit::FullDebug; |
| 567 | break; |
| 568 | } |
| 569 | |
Scott Linder | 94834f1 | 2018-02-12 19:47:05 +0000 | [diff] [blame] | 570 | if (CSKind) |
| 571 | CSInfo.emplace(*CSKind, Checksum); |
| 572 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 573 | // Create new compile unit. |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 574 | // FIXME - Eliminate TheCU. |
Adrian Prantl | b442302 | 2017-08-04 23:08:57 +0000 | [diff] [blame] | 575 | auto &CGOpts = CGM.getCodeGenOpts(); |
Eric Christopher | e4200a2 | 2014-02-27 01:25:08 +0000 | [diff] [blame] | 576 | TheCU = DBuilder.createCompileUnit( |
David Blaikie | 8150355 | 2017-04-21 23:35:36 +0000 | [diff] [blame] | 577 | LangTag, |
| 578 | DBuilder.createFile(remapDIPath(MainFileName), |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 579 | remapDIPath(getCurrentDirname()), CSInfo, |
Scott Linder | a2fbcef | 2018-02-26 17:32:31 +0000 | [diff] [blame] | 580 | getSource(SM, SM.getMainFileID())), |
Mikhail Maltsev | 4a4e7a3 | 2018-04-23 10:08:46 +0000 | [diff] [blame] | 581 | CGOpts.EmitVersionIdentMetadata ? Producer : "", |
Tobias Edler von Koch | 7609cb8 | 2018-06-22 20:23:21 +0000 | [diff] [blame] | 582 | LO.Optimize || CGOpts.PrepareForLTO || CGOpts.PrepareForThinLTO, |
Adrian Prantl | b442302 | 2017-08-04 23:08:57 +0000 | [diff] [blame] | 583 | CGOpts.DwarfDebugFlags, RuntimeVers, |
George Rimar | 91829ee | 2018-11-14 09:22:16 +0000 | [diff] [blame] | 584 | (CGOpts.getSplitDwarfMode() != CodeGenOptions::NoFission) |
| 585 | ? "" |
| 586 | : CGOpts.SplitDwarfFile, |
| 587 | EmissionKind, 0 /* DWOid */, CGOpts.SplitDwarfInlining, |
| 588 | CGOpts.DebugInfoForProfiling, |
David Blaikie | 9982bb8 | 2018-08-16 23:56:32 +0000 | [diff] [blame] | 589 | CGM.getTarget().getTriple().isNVPTX() |
| 590 | ? llvm::DICompileUnit::DebugNameTableKind::None |
David Blaikie | 6586452 | 2018-08-20 20:14:08 +0000 | [diff] [blame] | 591 | : static_cast<llvm::DICompileUnit::DebugNameTableKind>( |
David Blaikie | 27692de | 2018-11-13 20:08:13 +0000 | [diff] [blame] | 592 | CGOpts.DebugNameTable), |
| 593 | CGOpts.DebugRangesBaseAddress); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 594 | } |
| 595 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 596 | llvm::DIType *CGDebugInfo::CreateType(const BuiltinType *BT) { |
Ed Maste | da70602 | 2014-05-07 12:49:30 +0000 | [diff] [blame] | 597 | llvm::dwarf::TypeKind Encoding; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 598 | StringRef BTName; |
| 599 | switch (BT->getKind()) { |
| 600 | #define BUILTIN_TYPE(Id, SingletonId) |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 601 | #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id: |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 602 | #include "clang/AST/BuiltinTypes.def" |
| 603 | case BuiltinType::Dependent: |
| 604 | llvm_unreachable("Unexpected builtin type"); |
| 605 | case BuiltinType::NullPtr: |
Peter Collingbourne | 5c5e617 | 2013-06-27 22:51:01 +0000 | [diff] [blame] | 606 | return DBuilder.createNullPtrType(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 607 | case BuiltinType::Void: |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 608 | return nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 609 | case BuiltinType::ObjCClass: |
David Blaikie | f427b00 | 2014-05-06 03:42:01 +0000 | [diff] [blame] | 610 | if (!ClassTy) |
| 611 | ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, |
| 612 | "objc_class", TheCU, |
| 613 | getOrCreateMainFile(), 0); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 614 | return ClassTy; |
| 615 | case BuiltinType::ObjCId: { |
| 616 | // typedef struct objc_class *Class; |
| 617 | // typedef struct objc_object { |
| 618 | // Class isa; |
| 619 | // } *id; |
| 620 | |
Eric Christopher | f8bc4d8 | 2013-07-18 00:52:50 +0000 | [diff] [blame] | 621 | if (ObjTy) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 622 | return ObjTy; |
| 623 | |
Eric Christopher | f8bc4d8 | 2013-07-18 00:52:50 +0000 | [diff] [blame] | 624 | if (!ClassTy) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 625 | ClassTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, |
| 626 | "objc_class", TheCU, |
| 627 | getOrCreateMainFile(), 0); |
| 628 | |
| 629 | unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 630 | |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 631 | auto *ISATy = DBuilder.createPointerType(ClassTy, Size); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 632 | |
Leny Kholodov | df050fd | 2016-09-06 17:06:14 +0000 | [diff] [blame] | 633 | ObjTy = DBuilder.createStructType( |
| 634 | TheCU, "objc_object", getOrCreateMainFile(), 0, 0, 0, |
| 635 | llvm::DINode::FlagZero, nullptr, llvm::DINodeArray()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 636 | |
Duncan P. N. Exon Smith | c8ee63e | 2014-12-18 00:48:56 +0000 | [diff] [blame] | 637 | DBuilder.replaceArrays( |
Leny Kholodov | df050fd | 2016-09-06 17:06:14 +0000 | [diff] [blame] | 638 | ObjTy, DBuilder.getOrCreateArray(&*DBuilder.createMemberType( |
| 639 | ObjTy, "isa", getOrCreateMainFile(), 0, Size, 0, 0, |
| 640 | llvm::DINode::FlagZero, ISATy))); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 641 | return ObjTy; |
| 642 | } |
| 643 | case BuiltinType::ObjCSel: { |
David Blaikie | f427b00 | 2014-05-06 03:42:01 +0000 | [diff] [blame] | 644 | if (!SelTy) |
| 645 | SelTy = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, |
| 646 | "objc_selector", TheCU, |
| 647 | getOrCreateMainFile(), 0); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 648 | return SelTy; |
| 649 | } |
Guy Benyei | d8a08ea | 2012-12-18 14:38:23 +0000 | [diff] [blame] | 650 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 651 | #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ |
| 652 | case BuiltinType::Id: \ |
| 653 | return getOrCreateStructPtrType("opencl_" #ImgType "_" #Suffix "_t", \ |
Alexey Bader | 954ba21 | 2016-04-08 13:40:33 +0000 | [diff] [blame] | 654 | SingletonId); |
Alexey Bader | b62f144 | 2016-04-13 08:33:41 +0000 | [diff] [blame] | 655 | #include "clang/Basic/OpenCLImageTypes.def" |
Guy Benyei | 6105419 | 2013-02-07 10:55:47 +0000 | [diff] [blame] | 656 | case BuiltinType::OCLSampler: |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 657 | return getOrCreateStructPtrType("opencl_sampler_t", OCLSamplerDITy); |
Guy Benyei | 1b4fb3e | 2013-01-20 12:31:11 +0000 | [diff] [blame] | 658 | case BuiltinType::OCLEvent: |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 659 | return getOrCreateStructPtrType("opencl_event_t", OCLEventDITy); |
Alexey Bader | 9c8453f | 2015-09-15 11:18:52 +0000 | [diff] [blame] | 660 | case BuiltinType::OCLClkEvent: |
| 661 | return getOrCreateStructPtrType("opencl_clk_event_t", OCLClkEventDITy); |
| 662 | case BuiltinType::OCLQueue: |
| 663 | return getOrCreateStructPtrType("opencl_queue_t", OCLQueueDITy); |
Alexey Bader | 9c8453f | 2015-09-15 11:18:52 +0000 | [diff] [blame] | 664 | case BuiltinType::OCLReserveID: |
| 665 | return getOrCreateStructPtrType("opencl_reserve_id_t", OCLReserveIDDITy); |
Andrew Savonichev | 3fee351 | 2018-11-08 11:25:41 +0000 | [diff] [blame] | 666 | #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ |
| 667 | case BuiltinType::Id: \ |
| 668 | return getOrCreateStructPtrType("opencl_" #ExtType, Id##Ty); |
| 669 | #include "clang/Basic/OpenCLExtensionTypes.def" |
Guy Benyei | d8a08ea | 2012-12-18 14:38:23 +0000 | [diff] [blame] | 670 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 671 | case BuiltinType::UChar: |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 672 | case BuiltinType::Char_U: |
| 673 | Encoding = llvm::dwarf::DW_ATE_unsigned_char; |
| 674 | break; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 675 | case BuiltinType::Char_S: |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 676 | case BuiltinType::SChar: |
| 677 | Encoding = llvm::dwarf::DW_ATE_signed_char; |
| 678 | break; |
Richard Smith | 3a8244d | 2018-05-01 05:02:45 +0000 | [diff] [blame] | 679 | case BuiltinType::Char8: |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 680 | case BuiltinType::Char16: |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 681 | case BuiltinType::Char32: |
| 682 | Encoding = llvm::dwarf::DW_ATE_UTF; |
| 683 | break; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 684 | case BuiltinType::UShort: |
| 685 | case BuiltinType::UInt: |
| 686 | case BuiltinType::UInt128: |
| 687 | case BuiltinType::ULong: |
| 688 | case BuiltinType::WChar_U: |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 689 | case BuiltinType::ULongLong: |
| 690 | Encoding = llvm::dwarf::DW_ATE_unsigned; |
| 691 | break; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 692 | case BuiltinType::Short: |
| 693 | case BuiltinType::Int: |
| 694 | case BuiltinType::Int128: |
| 695 | case BuiltinType::Long: |
| 696 | case BuiltinType::WChar_S: |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 697 | case BuiltinType::LongLong: |
| 698 | Encoding = llvm::dwarf::DW_ATE_signed; |
| 699 | break; |
| 700 | case BuiltinType::Bool: |
| 701 | Encoding = llvm::dwarf::DW_ATE_boolean; |
| 702 | break; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 703 | case BuiltinType::Half: |
| 704 | case BuiltinType::Float: |
| 705 | case BuiltinType::LongDouble: |
Sjoerd Meijer | cc623ad | 2017-09-08 15:15:00 +0000 | [diff] [blame] | 706 | case BuiltinType::Float16: |
Nemanja Ivanovic | bb1ea2d | 2016-05-09 08:52:33 +0000 | [diff] [blame] | 707 | case BuiltinType::Float128: |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 708 | case BuiltinType::Double: |
Nemanja Ivanovic | bb1ea2d | 2016-05-09 08:52:33 +0000 | [diff] [blame] | 709 | // FIXME: For targets where long double and __float128 have the same size, |
| 710 | // they are currently indistinguishable in the debugger without some |
| 711 | // special treatment. However, there is currently no consensus on encoding |
| 712 | // and this should be updated once a DWARF encoding exists for distinct |
| 713 | // floating point types of the same size. |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 714 | Encoding = llvm::dwarf::DW_ATE_float; |
| 715 | break; |
Leonard Chan | f921d85 | 2018-06-04 16:07:52 +0000 | [diff] [blame] | 716 | case BuiltinType::ShortAccum: |
| 717 | case BuiltinType::Accum: |
| 718 | case BuiltinType::LongAccum: |
Leonard Chan | ab80f3c | 2018-06-14 14:53:51 +0000 | [diff] [blame] | 719 | case BuiltinType::ShortFract: |
| 720 | case BuiltinType::Fract: |
| 721 | case BuiltinType::LongFract: |
| 722 | case BuiltinType::SatShortFract: |
| 723 | case BuiltinType::SatFract: |
| 724 | case BuiltinType::SatLongFract: |
| 725 | case BuiltinType::SatShortAccum: |
| 726 | case BuiltinType::SatAccum: |
| 727 | case BuiltinType::SatLongAccum: |
Leonard Chan | f921d85 | 2018-06-04 16:07:52 +0000 | [diff] [blame] | 728 | Encoding = llvm::dwarf::DW_ATE_signed_fixed; |
| 729 | break; |
| 730 | case BuiltinType::UShortAccum: |
| 731 | case BuiltinType::UAccum: |
| 732 | case BuiltinType::ULongAccum: |
Leonard Chan | ab80f3c | 2018-06-14 14:53:51 +0000 | [diff] [blame] | 733 | case BuiltinType::UShortFract: |
| 734 | case BuiltinType::UFract: |
| 735 | case BuiltinType::ULongFract: |
| 736 | case BuiltinType::SatUShortAccum: |
| 737 | case BuiltinType::SatUAccum: |
| 738 | case BuiltinType::SatULongAccum: |
| 739 | case BuiltinType::SatUShortFract: |
| 740 | case BuiltinType::SatUFract: |
| 741 | case BuiltinType::SatULongFract: |
Leonard Chan | f921d85 | 2018-06-04 16:07:52 +0000 | [diff] [blame] | 742 | Encoding = llvm::dwarf::DW_ATE_unsigned_fixed; |
| 743 | break; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 744 | } |
| 745 | |
| 746 | switch (BT->getKind()) { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 747 | case BuiltinType::Long: |
| 748 | BTName = "long int"; |
| 749 | break; |
| 750 | case BuiltinType::LongLong: |
| 751 | BTName = "long long int"; |
| 752 | break; |
| 753 | case BuiltinType::ULong: |
| 754 | BTName = "long unsigned int"; |
| 755 | break; |
| 756 | case BuiltinType::ULongLong: |
| 757 | BTName = "long long unsigned int"; |
| 758 | break; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 759 | default: |
| 760 | BTName = BT->getName(CGM.getLangOpts()); |
| 761 | break; |
| 762 | } |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 763 | // Bit size and offset of the type. |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 764 | uint64_t Size = CGM.getContext().getTypeSize(BT); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 765 | return DBuilder.createBasicType(BTName, Size, Encoding); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 766 | } |
| 767 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 768 | llvm::DIType *CGDebugInfo::CreateType(const ComplexType *Ty) { |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 769 | // Bit size and offset of the type. |
Ed Maste | da70602 | 2014-05-07 12:49:30 +0000 | [diff] [blame] | 770 | llvm::dwarf::TypeKind Encoding = llvm::dwarf::DW_ATE_complex_float; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 771 | if (Ty->isComplexIntegerType()) |
| 772 | Encoding = llvm::dwarf::DW_ATE_lo_user; |
| 773 | |
| 774 | uint64_t Size = CGM.getContext().getTypeSize(Ty); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 775 | return DBuilder.createBasicType("complex", Size, Encoding); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 776 | } |
| 777 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 778 | llvm::DIType *CGDebugInfo::CreateQualifiedType(QualType Ty, |
| 779 | llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 780 | QualifierCollector Qc; |
| 781 | const Type *T = Qc.strip(Ty); |
| 782 | |
| 783 | // Ignore these qualifiers for now. |
| 784 | Qc.removeObjCGCAttr(); |
| 785 | Qc.removeAddressSpace(); |
| 786 | Qc.removeObjCLifetime(); |
| 787 | |
| 788 | // We will create one Derived type for one qualifier and recurse to handle any |
| 789 | // additional ones. |
Ed Maste | da70602 | 2014-05-07 12:49:30 +0000 | [diff] [blame] | 790 | llvm::dwarf::Tag Tag; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 791 | if (Qc.hasConst()) { |
| 792 | Tag = llvm::dwarf::DW_TAG_const_type; |
| 793 | Qc.removeConst(); |
| 794 | } else if (Qc.hasVolatile()) { |
| 795 | Tag = llvm::dwarf::DW_TAG_volatile_type; |
| 796 | Qc.removeVolatile(); |
| 797 | } else if (Qc.hasRestrict()) { |
| 798 | Tag = llvm::dwarf::DW_TAG_restrict_type; |
| 799 | Qc.removeRestrict(); |
| 800 | } else { |
| 801 | assert(Qc.empty() && "Unknown type qualifier for debug info"); |
| 802 | return getOrCreateType(QualType(T, 0), Unit); |
| 803 | } |
| 804 | |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 805 | auto *FromTy = getOrCreateType(Qc.apply(CGM.getContext(), T), Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 806 | |
| 807 | // No need to fill in the Name, Line, Size, Alignment, Offset in case of |
| 808 | // CVR derived types. |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 809 | return DBuilder.createQualifiedType(Tag, FromTy); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 810 | } |
| 811 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 812 | llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty, |
| 813 | llvm::DIFile *Unit) { |
Fariborz Jahanian | 65f1fa1 | 2013-02-21 20:42:11 +0000 | [diff] [blame] | 814 | |
| 815 | // The frontend treats 'id' as a typedef to an ObjCObjectType, |
| 816 | // whereas 'id<protocol>' is treated as an ObjCPointerType. For the |
| 817 | // debug info, we want to emit 'id' in both cases. |
| 818 | if (Ty->isObjCQualifiedIdType()) |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 819 | return getOrCreateType(CGM.getContext().getObjCIdType(), Unit); |
Fariborz Jahanian | 65f1fa1 | 2013-02-21 20:42:11 +0000 | [diff] [blame] | 820 | |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 821 | return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty, |
| 822 | Ty->getPointeeType(), Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 823 | } |
| 824 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 825 | llvm::DIType *CGDebugInfo::CreateType(const PointerType *Ty, |
| 826 | llvm::DIFile *Unit) { |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 827 | return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty, |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 828 | Ty->getPointeeType(), Unit); |
| 829 | } |
| 830 | |
Adrian Prantl | c6f91a2 | 2015-06-15 23:18:16 +0000 | [diff] [blame] | 831 | /// \return whether a C++ mangling exists for the type defined by TD. |
| 832 | static bool hasCXXMangling(const TagDecl *TD, llvm::DICompileUnit *TheCU) { |
| 833 | switch (TheCU->getSourceLanguage()) { |
| 834 | case llvm::dwarf::DW_LANG_C_plus_plus: |
| 835 | return true; |
| 836 | case llvm::dwarf::DW_LANG_ObjC_plus_plus: |
| 837 | return isa<CXXRecordDecl>(TD) || isa<EnumDecl>(TD); |
| 838 | default: |
| 839 | return false; |
| 840 | } |
| 841 | } |
| 842 | |
Reid Kleckner | 59320fc | 2018-08-17 20:59:52 +0000 | [diff] [blame] | 843 | // Determines if the debug info for this tag declaration needs a type |
| 844 | // identifier. The purpose of the unique identifier is to deduplicate type |
| 845 | // information for identical types across TUs. Because of the C++ one definition |
| 846 | // rule (ODR), it is valid to assume that the type is defined the same way in |
| 847 | // every TU and its debug info is equivalent. |
| 848 | // |
| 849 | // C does not have the ODR, and it is common for codebases to contain multiple |
| 850 | // different definitions of a struct with the same name in different TUs. |
| 851 | // Therefore, if the type doesn't have a C++ mangling, don't give it an |
| 852 | // identifer. Type information in C is smaller and simpler than C++ type |
| 853 | // information, so the increase in debug info size is negligible. |
| 854 | // |
| 855 | // If the type is not externally visible, it should be unique to the current TU, |
| 856 | // and should not need an identifier to participate in type deduplication. |
| 857 | // However, when emitting CodeView, the format internally uses these |
| 858 | // unique type name identifers for references between debug info. For example, |
| 859 | // the method of a class in an anonymous namespace uses the identifer to refer |
| 860 | // to its parent class. The Microsoft C++ ABI attempts to provide unique names |
| 861 | // for such types, so when emitting CodeView, always use identifiers for C++ |
| 862 | // types. This may create problems when attempting to emit CodeView when the MS |
| 863 | // C++ ABI is not in use. |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 864 | static bool needsTypeIdentifier(const TagDecl *TD, CodeGenModule &CGM, |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 865 | llvm::DICompileUnit *TheCU) { |
| 866 | // We only add a type identifier for types with C++ name mangling. |
| 867 | if (!hasCXXMangling(TD, TheCU)) |
| 868 | return false; |
| 869 | |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 870 | // Externally visible types with C++ mangling need a type identifier. |
| 871 | if (TD->isExternallyVisible()) |
| 872 | return true; |
| 873 | |
Reid Kleckner | 59320fc | 2018-08-17 20:59:52 +0000 | [diff] [blame] | 874 | // CodeView types with C++ mangling need a type identifier. |
| 875 | if (CGM.getCodeGenOpts().EmitCodeView) |
| 876 | return true; |
| 877 | |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 878 | return false; |
| 879 | } |
| 880 | |
Reid Kleckner | 59320fc | 2018-08-17 20:59:52 +0000 | [diff] [blame] | 881 | // Returns a unique type identifier string if one exists, or an empty string. |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 882 | static SmallString<256> getTypeIdentifier(const TagType *Ty, CodeGenModule &CGM, |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 883 | llvm::DICompileUnit *TheCU) { |
| 884 | SmallString<256> Identifier; |
Manman Ren | e0064d8 | 2013-08-29 23:19:58 +0000 | [diff] [blame] | 885 | const TagDecl *TD = Ty->getDecl(); |
Adrian Prantl | c6f91a2 | 2015-06-15 23:18:16 +0000 | [diff] [blame] | 886 | |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 887 | if (!needsTypeIdentifier(TD, CGM, TheCU)) |
| 888 | return Identifier; |
Adrian Prantl | c6f91a2 | 2015-06-15 23:18:16 +0000 | [diff] [blame] | 889 | |
Manman Ren | e0064d8 | 2013-08-29 23:19:58 +0000 | [diff] [blame] | 890 | // TODO: This is using the RTTI name. Is there a better way to get |
| 891 | // a unique string for a type? |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 892 | llvm::raw_svector_ostream Out(Identifier); |
Manman Ren | e0064d8 | 2013-08-29 23:19:58 +0000 | [diff] [blame] | 893 | CGM.getCXXABI().getMangleContext().mangleCXXRTTIName(QualType(Ty, 0), Out); |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 894 | return Identifier; |
Manman Ren | e0064d8 | 2013-08-29 23:19:58 +0000 | [diff] [blame] | 895 | } |
| 896 | |
Alexander Kornienko | 2a8c18d | 2018-04-06 15:14:32 +0000 | [diff] [blame] | 897 | /// \return the appropriate DWARF tag for a composite type. |
Adrian Prantl | 5f66bae | 2015-02-11 17:45:15 +0000 | [diff] [blame] | 898 | static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) { |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 899 | llvm::dwarf::Tag Tag; |
Adrian Prantl | 5f66bae | 2015-02-11 17:45:15 +0000 | [diff] [blame] | 900 | if (RD->isStruct() || RD->isInterface()) |
| 901 | Tag = llvm::dwarf::DW_TAG_structure_type; |
| 902 | else if (RD->isUnion()) |
| 903 | Tag = llvm::dwarf::DW_TAG_union_type; |
| 904 | else { |
| 905 | // FIXME: This could be a struct type giving a default visibility different |
| 906 | // than C++ class type, but needs llvm metadata changes first. |
| 907 | assert(RD->isClass()); |
| 908 | Tag = llvm::dwarf::DW_TAG_class_type; |
| 909 | } |
| 910 | return Tag; |
| 911 | } |
| 912 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 913 | llvm::DICompositeType * |
Manman Ren | 1b45702 | 2013-08-28 21:20:28 +0000 | [diff] [blame] | 914 | CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType *Ty, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 915 | llvm::DIScope *Ctx) { |
Manman Ren | 1b45702 | 2013-08-28 21:20:28 +0000 | [diff] [blame] | 916 | const RecordDecl *RD = Ty->getDecl(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 917 | if (llvm::DIType *T = getTypeOrNull(CGM.getContext().getRecordType(RD))) |
| 918 | return cast<llvm::DICompositeType>(T); |
| 919 | llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 920 | unsigned Line = getLineNumber(RD->getLocation()); |
| 921 | StringRef RDName = getClassName(RD); |
| 922 | |
Peter Collingbourne | d251b0a | 2015-03-01 22:07:04 +0000 | [diff] [blame] | 923 | uint64_t Size = 0; |
Victor Leschuk | 802e4a5 | 2016-10-19 22:11:07 +0000 | [diff] [blame] | 924 | uint32_t Align = 0; |
Peter Collingbourne | d251b0a | 2015-03-01 22:07:04 +0000 | [diff] [blame] | 925 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 926 | // Create the type. |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 927 | SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 928 | llvm::DICompositeType *RetTy = DBuilder.createReplaceableCompositeType( |
Peter Collingbourne | d251b0a | 2015-03-01 22:07:04 +0000 | [diff] [blame] | 929 | getTagForRecord(RD), RDName, Ctx, DefUnit, Line, 0, Size, Align, |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 930 | llvm::DINode::FlagFwdDecl, Identifier); |
Paul Robinson | 1787f81 | 2017-09-28 18:37:02 +0000 | [diff] [blame] | 931 | if (CGM.getCodeGenOpts().DebugFwdTemplateParams) |
| 932 | if (auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD)) |
| 933 | DBuilder.replaceArrays(RetTy, llvm::DINodeArray(), |
| 934 | CollectCXXTemplateParams(TSpecial, DefUnit)); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 935 | ReplaceMap.emplace_back( |
| 936 | std::piecewise_construct, std::make_tuple(Ty), |
| 937 | std::make_tuple(static_cast<llvm::Metadata *>(RetTy))); |
David Blaikie | f427b00 | 2014-05-06 03:42:01 +0000 | [diff] [blame] | 938 | return RetTy; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 939 | } |
| 940 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 941 | llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag, |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 942 | const Type *Ty, |
| 943 | QualType PointeeTy, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 944 | llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 945 | // Bit size, align and offset of the type. |
| 946 | // Size is always the size of a pointer. We can't use getTypeSize here |
| 947 | // because that does not return the correct value for references. |
Konstantin Zhuravlyov | d1ba16e | 2017-03-08 23:56:48 +0000 | [diff] [blame] | 948 | unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(PointeeTy); |
| 949 | uint64_t Size = CGM.getTarget().getPointerWidth(AddressSpace); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 950 | auto Align = getTypeAlignIfRequired(Ty, CGM.getContext()); |
Konstantin Zhuravlyov | d1ba16e | 2017-03-08 23:56:48 +0000 | [diff] [blame] | 951 | Optional<unsigned> DWARFAddressSpace = |
| 952 | CGM.getTarget().getDWARFAddressSpace(AddressSpace); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 953 | |
Keno Fischer | 87842f3 | 2015-11-16 09:04:13 +0000 | [diff] [blame] | 954 | if (Tag == llvm::dwarf::DW_TAG_reference_type || |
| 955 | Tag == llvm::dwarf::DW_TAG_rvalue_reference_type) |
| 956 | return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit), |
Konstantin Zhuravlyov | d1ba16e | 2017-03-08 23:56:48 +0000 | [diff] [blame] | 957 | Size, Align, DWARFAddressSpace); |
Keno Fischer | 87842f3 | 2015-11-16 09:04:13 +0000 | [diff] [blame] | 958 | else |
| 959 | return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size, |
Konstantin Zhuravlyov | d1ba16e | 2017-03-08 23:56:48 +0000 | [diff] [blame] | 960 | Align, DWARFAddressSpace); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 961 | } |
| 962 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 963 | llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name, |
| 964 | llvm::DIType *&Cache) { |
Eric Christopher | f8bc4d8 | 2013-07-18 00:52:50 +0000 | [diff] [blame] | 965 | if (Cache) |
Guy Benyei | d8a08ea | 2012-12-18 14:38:23 +0000 | [diff] [blame] | 966 | return Cache; |
David Blaikie | fefc7f7 | 2013-05-21 17:58:54 +0000 | [diff] [blame] | 967 | Cache = DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, Name, |
| 968 | TheCU, getOrCreateMainFile(), 0); |
| 969 | unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy); |
| 970 | Cache = DBuilder.createPointerType(Cache, Size); |
| 971 | return Cache; |
Guy Benyei | d8a08ea | 2012-12-18 14:38:23 +0000 | [diff] [blame] | 972 | } |
| 973 | |
Scott Linder | 58df0e4 | 2018-08-08 15:56:12 +0000 | [diff] [blame] | 974 | uint64_t CGDebugInfo::collectDefaultElementTypesForBlockPointer( |
| 975 | const BlockPointerType *Ty, llvm::DIFile *Unit, llvm::DIDerivedType *DescTy, |
| 976 | unsigned LineNo, SmallVectorImpl<llvm::Metadata *> &EltTys) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 977 | QualType FType; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 978 | |
Scott Linder | 58df0e4 | 2018-08-08 15:56:12 +0000 | [diff] [blame] | 979 | // Advanced by calls to CreateMemberType in increments of FType, then |
| 980 | // returned as the overall size of the default elements. |
| 981 | uint64_t FieldOffset = 0; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 982 | |
Scott Linder | 58df0e4 | 2018-08-08 15:56:12 +0000 | [diff] [blame] | 983 | // Blocks in OpenCL have unique constraints which make the standard fields |
| 984 | // redundant while requiring size and align fields for enqueue_kernel. See |
| 985 | // initializeForBlockHeader in CGBlocks.cpp |
Scott Linder | 2b5cf04 | 2018-07-30 20:31:11 +0000 | [diff] [blame] | 986 | if (CGM.getLangOpts().OpenCL) { |
| 987 | FType = CGM.getContext().IntTy; |
| 988 | EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset)); |
| 989 | EltTys.push_back(CreateMemberType(Unit, FType, "__align", &FieldOffset)); |
| 990 | } else { |
| 991 | FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); |
| 992 | EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset)); |
| 993 | FType = CGM.getContext().IntTy; |
| 994 | EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset)); |
| 995 | EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset)); |
| 996 | FType = CGM.getContext().getPointerType(Ty->getPointeeType()); |
| 997 | EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset)); |
| 998 | FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); |
Scott Linder | 58df0e4 | 2018-08-08 15:56:12 +0000 | [diff] [blame] | 999 | uint64_t FieldSize = CGM.getContext().getTypeSize(Ty); |
| 1000 | uint32_t FieldAlign = CGM.getContext().getTypeAlign(Ty); |
Scott Linder | 2b5cf04 | 2018-07-30 20:31:11 +0000 | [diff] [blame] | 1001 | EltTys.push_back(DBuilder.createMemberType( |
Scott Linder | 58df0e4 | 2018-08-08 15:56:12 +0000 | [diff] [blame] | 1002 | Unit, "__descriptor", nullptr, LineNo, FieldSize, FieldAlign, |
| 1003 | FieldOffset, llvm::DINode::FlagZero, DescTy)); |
Scott Linder | a7c4568 | 2018-07-30 22:52:07 +0000 | [diff] [blame] | 1004 | FieldOffset += FieldSize; |
Scott Linder | 2b5cf04 | 2018-07-30 20:31:11 +0000 | [diff] [blame] | 1005 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1006 | |
Scott Linder | 58df0e4 | 2018-08-08 15:56:12 +0000 | [diff] [blame] | 1007 | return FieldOffset; |
| 1008 | } |
| 1009 | |
| 1010 | llvm::DIType *CGDebugInfo::CreateType(const BlockPointerType *Ty, |
| 1011 | llvm::DIFile *Unit) { |
| 1012 | SmallVector<llvm::Metadata *, 8> EltTys; |
| 1013 | QualType FType; |
| 1014 | uint64_t FieldOffset; |
| 1015 | llvm::DINodeArray Elements; |
| 1016 | |
| 1017 | FieldOffset = 0; |
| 1018 | FType = CGM.getContext().UnsignedLongTy; |
| 1019 | EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset)); |
| 1020 | EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset)); |
| 1021 | |
| 1022 | Elements = DBuilder.getOrCreateArray(EltTys); |
| 1023 | EltTys.clear(); |
| 1024 | |
| 1025 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagAppleBlock; |
| 1026 | |
| 1027 | auto *EltTy = |
| 1028 | DBuilder.createStructType(Unit, "__block_descriptor", nullptr, 0, |
| 1029 | FieldOffset, 0, Flags, nullptr, Elements); |
| 1030 | |
| 1031 | // Bit size, align and offset of the type. |
| 1032 | uint64_t Size = CGM.getContext().getTypeSize(Ty); |
| 1033 | |
| 1034 | auto *DescTy = DBuilder.createPointerType(EltTy, Size); |
| 1035 | |
| 1036 | FieldOffset = collectDefaultElementTypesForBlockPointer(Ty, Unit, DescTy, |
| 1037 | 0, EltTys); |
| 1038 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1039 | Elements = DBuilder.getOrCreateArray(EltTys); |
| 1040 | |
Adrian Prantl | 3d2c051 | 2015-07-07 00:49:35 +0000 | [diff] [blame] | 1041 | // The __block_literal_generic structs are marked with a special |
| 1042 | // DW_AT_APPLE_BLOCK attribute and are an implementation detail only |
| 1043 | // the debugger needs to know about. To allow type uniquing, emit |
| 1044 | // them without a name or a location. |
Scott Linder | 58df0e4 | 2018-08-08 15:56:12 +0000 | [diff] [blame] | 1045 | EltTy = DBuilder.createStructType(Unit, "", nullptr, 0, FieldOffset, 0, |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 1046 | Flags, nullptr, Elements); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1047 | |
Adrian Prantl | 3d2c051 | 2015-07-07 00:49:35 +0000 | [diff] [blame] | 1048 | return DBuilder.createPointerType(EltTy, Size); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1049 | } |
| 1050 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1051 | llvm::DIType *CGDebugInfo::CreateType(const TemplateSpecializationType *Ty, |
| 1052 | llvm::DIFile *Unit) { |
David Blaikie | f1b382e | 2014-04-06 17:14:06 +0000 | [diff] [blame] | 1053 | assert(Ty->isTypeAlias()); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1054 | llvm::DIType *Src = getOrCreateType(Ty->getAliasedType(), Unit); |
David Blaikie | f1b382e | 2014-04-06 17:14:06 +0000 | [diff] [blame] | 1055 | |
| 1056 | SmallString<128> NS; |
| 1057 | llvm::raw_svector_ostream OS(NS); |
Serge Pavlov | 03e672c | 2017-11-28 16:14:14 +0000 | [diff] [blame] | 1058 | Ty->getTemplateName().print(OS, getPrintingPolicy(), /*qualified*/ false); |
| 1059 | printTemplateArgumentList(OS, Ty->template_arguments(), getPrintingPolicy()); |
David Blaikie | f1b382e | 2014-04-06 17:14:06 +0000 | [diff] [blame] | 1060 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 1061 | auto *AliasDecl = |
| 1062 | cast<TypeAliasTemplateDecl>(Ty->getTemplateName().getAsTemplateDecl()) |
| 1063 | ->getTemplatedDecl(); |
David Blaikie | f1b382e | 2014-04-06 17:14:06 +0000 | [diff] [blame] | 1064 | |
| 1065 | SourceLocation Loc = AliasDecl->getLocation(); |
Adrian Prantl | b67dbce | 2015-09-11 18:45:02 +0000 | [diff] [blame] | 1066 | return DBuilder.createTypedef(Src, OS.str(), getOrCreateFile(Loc), |
| 1067 | getLineNumber(Loc), |
| 1068 | getDeclContextDescriptor(AliasDecl)); |
David Blaikie | f1b382e | 2014-04-06 17:14:06 +0000 | [diff] [blame] | 1069 | } |
| 1070 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1071 | llvm::DIType *CGDebugInfo::CreateType(const TypedefType *Ty, |
| 1072 | llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1073 | // We don't set size information, but do specify where the typedef was |
| 1074 | // declared. |
Amjad Aboud | dc4531e | 2016-04-30 01:44:38 +0000 | [diff] [blame] | 1075 | SourceLocation Loc = Ty->getDecl()->getLocation(); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1076 | |
Duncan P. N. Exon Smith | 4078ad4 | 2015-04-16 16:36:45 +0000 | [diff] [blame] | 1077 | // Typedefs are derived from some other type. |
| 1078 | return DBuilder.createTypedef( |
| 1079 | getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit), |
| 1080 | Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc), |
Amjad Aboud | dc4531e | 2016-04-30 01:44:38 +0000 | [diff] [blame] | 1081 | getDeclContextDescriptor(Ty->getDecl())); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1082 | } |
| 1083 | |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1084 | static unsigned getDwarfCC(CallingConv CC) { |
| 1085 | switch (CC) { |
| 1086 | case CC_C: |
| 1087 | // Avoid emitting DW_AT_calling_convention if the C convention was used. |
| 1088 | return 0; |
| 1089 | |
| 1090 | case CC_X86StdCall: |
| 1091 | return llvm::dwarf::DW_CC_BORLAND_stdcall; |
| 1092 | case CC_X86FastCall: |
| 1093 | return llvm::dwarf::DW_CC_BORLAND_msfastcall; |
| 1094 | case CC_X86ThisCall: |
| 1095 | return llvm::dwarf::DW_CC_BORLAND_thiscall; |
| 1096 | case CC_X86VectorCall: |
| 1097 | return llvm::dwarf::DW_CC_LLVM_vectorcall; |
| 1098 | case CC_X86Pascal: |
| 1099 | return llvm::dwarf::DW_CC_BORLAND_pascal; |
Martin Storsjo | 022e782 | 2017-07-17 20:49:45 +0000 | [diff] [blame] | 1100 | case CC_Win64: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1101 | return llvm::dwarf::DW_CC_LLVM_Win64; |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1102 | case CC_X86_64SysV: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1103 | return llvm::dwarf::DW_CC_LLVM_X86_64SysV; |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1104 | case CC_AAPCS: |
Sander de Smalen | 44a2253 | 2018-11-26 16:38:37 +0000 | [diff] [blame] | 1105 | case CC_AArch64VectorCall: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1106 | return llvm::dwarf::DW_CC_LLVM_AAPCS; |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1107 | case CC_AAPCS_VFP: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1108 | return llvm::dwarf::DW_CC_LLVM_AAPCS_VFP; |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1109 | case CC_IntelOclBicc: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1110 | return llvm::dwarf::DW_CC_LLVM_IntelOclBicc; |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1111 | case CC_SpirFunction: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1112 | return llvm::dwarf::DW_CC_LLVM_SpirFunction; |
Nikolay Haustov | 8c6538b | 2016-06-30 09:06:33 +0000 | [diff] [blame] | 1113 | case CC_OpenCLKernel: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1114 | return llvm::dwarf::DW_CC_LLVM_OpenCLKernel; |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1115 | case CC_Swift: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1116 | return llvm::dwarf::DW_CC_LLVM_Swift; |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1117 | case CC_PreserveMost: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1118 | return llvm::dwarf::DW_CC_LLVM_PreserveMost; |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1119 | case CC_PreserveAll: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1120 | return llvm::dwarf::DW_CC_LLVM_PreserveAll; |
Erich Keane | 757d317 | 2016-11-02 18:29:35 +0000 | [diff] [blame] | 1121 | case CC_X86RegCall: |
Jonas Devlieghere | f070268 | 2018-03-22 13:53:30 +0000 | [diff] [blame] | 1122 | return llvm::dwarf::DW_CC_LLVM_X86RegCall; |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1123 | } |
| 1124 | return 0; |
| 1125 | } |
| 1126 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1127 | llvm::DIType *CGDebugInfo::CreateType(const FunctionType *Ty, |
| 1128 | llvm::DIFile *Unit) { |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1129 | SmallVector<llvm::Metadata *, 16> EltTys; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1130 | |
| 1131 | // Add the result type at least. |
Alp Toker | 314cc81 | 2014-01-25 16:55:45 +0000 | [diff] [blame] | 1132 | EltTys.push_back(getOrCreateType(Ty->getReturnType(), Unit)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1133 | |
| 1134 | // Set up remainder of arguments if there is a prototype. |
Adrian Prantl | 800faef | 2014-02-25 23:42:18 +0000 | [diff] [blame] | 1135 | // otherwise emit it as a variadic function. |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1136 | if (isa<FunctionNoProtoType>(Ty)) |
| 1137 | EltTys.push_back(DBuilder.createUnspecifiedParameter()); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 1138 | else if (const auto *FPT = dyn_cast<FunctionProtoType>(Ty)) { |
| 1139 | for (const QualType &ParamType : FPT->param_types()) |
| 1140 | EltTys.push_back(getOrCreateType(ParamType, Unit)); |
Adrian Prantl | d45ba25 | 2014-02-25 19:38:11 +0000 | [diff] [blame] | 1141 | if (FPT->isVariadic()) |
| 1142 | EltTys.push_back(DBuilder.createUnspecifiedParameter()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1143 | } |
| 1144 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1145 | llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys); |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 1146 | return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero, |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1147 | getDwarfCC(Ty->getCallConv())); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1148 | } |
| 1149 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1150 | /// Convert an AccessSpecifier into the corresponding DINode flag. |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 1151 | /// As an optimization, return 0 if the access specifier equals the |
| 1152 | /// default for the containing type. |
Leny Kholodov | df050fd | 2016-09-06 17:06:14 +0000 | [diff] [blame] | 1153 | static llvm::DINode::DIFlags getAccessFlag(AccessSpecifier Access, |
| 1154 | const RecordDecl *RD) { |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 1155 | AccessSpecifier Default = clang::AS_none; |
| 1156 | if (RD && RD->isClass()) |
| 1157 | Default = clang::AS_private; |
| 1158 | else if (RD && (RD->isStruct() || RD->isUnion())) |
| 1159 | Default = clang::AS_public; |
| 1160 | |
| 1161 | if (Access == Default) |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 1162 | return llvm::DINode::FlagZero; |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 1163 | |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1164 | switch (Access) { |
| 1165 | case clang::AS_private: |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1166 | return llvm::DINode::FlagPrivate; |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1167 | case clang::AS_protected: |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1168 | return llvm::DINode::FlagProtected; |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1169 | case clang::AS_public: |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1170 | return llvm::DINode::FlagPublic; |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1171 | case clang::AS_none: |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 1172 | return llvm::DINode::FlagZero; |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 1173 | } |
| 1174 | llvm_unreachable("unexpected access enumerator"); |
| 1175 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1176 | |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1177 | llvm::DIType *CGDebugInfo::createBitFieldType(const FieldDecl *BitFieldDecl, |
| 1178 | llvm::DIScope *RecordTy, |
| 1179 | const RecordDecl *RD) { |
| 1180 | StringRef Name = BitFieldDecl->getName(); |
| 1181 | QualType Ty = BitFieldDecl->getType(); |
| 1182 | SourceLocation Loc = BitFieldDecl->getLocation(); |
| 1183 | llvm::DIFile *VUnit = getOrCreateFile(Loc); |
| 1184 | llvm::DIType *DebugType = getOrCreateType(Ty, VUnit); |
| 1185 | |
| 1186 | // Get the location for the field. |
| 1187 | llvm::DIFile *File = getOrCreateFile(Loc); |
| 1188 | unsigned Line = getLineNumber(Loc); |
| 1189 | |
| 1190 | const CGBitFieldInfo &BitFieldInfo = |
| 1191 | CGM.getTypes().getCGRecordLayout(RD).getBitFieldInfo(BitFieldDecl); |
| 1192 | uint64_t SizeInBits = BitFieldInfo.Size; |
| 1193 | assert(SizeInBits > 0 && "found named 0-width bitfield"); |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1194 | uint64_t StorageOffsetInBits = |
| 1195 | CGM.getContext().toBits(BitFieldInfo.StorageOffset); |
Reid Kleckner | 06a4b2a | 2017-06-12 19:57:56 +0000 | [diff] [blame] | 1196 | uint64_t Offset = BitFieldInfo.Offset; |
| 1197 | // The bit offsets for big endian machines are reversed for big |
| 1198 | // endian target, compensate for that as the DIDerivedType requires |
| 1199 | // un-reversed offsets. |
| 1200 | if (CGM.getDataLayout().isBigEndian()) |
| 1201 | Offset = BitFieldInfo.StorageSize - BitFieldInfo.Size - Offset; |
| 1202 | uint64_t OffsetInBits = StorageOffsetInBits + Offset; |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 1203 | llvm::DINode::DIFlags Flags = getAccessFlag(BitFieldDecl->getAccess(), RD); |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1204 | return DBuilder.createBitFieldMemberType( |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1205 | RecordTy, Name, File, Line, SizeInBits, OffsetInBits, StorageOffsetInBits, |
| 1206 | Flags, DebugType); |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1207 | } |
| 1208 | |
| 1209 | llvm::DIType * |
| 1210 | CGDebugInfo::createFieldType(StringRef name, QualType type, SourceLocation loc, |
| 1211 | AccessSpecifier AS, uint64_t offsetInBits, |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1212 | uint32_t AlignInBits, llvm::DIFile *tunit, |
| 1213 | llvm::DIScope *scope, const RecordDecl *RD) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1214 | llvm::DIType *debugType = getOrCreateType(type, tunit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1215 | |
| 1216 | // Get the location for the field. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1217 | llvm::DIFile *file = getOrCreateFile(loc); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1218 | unsigned line = getLineNumber(loc); |
| 1219 | |
David Majnemer | 34b5749 | 2014-07-30 01:30:47 +0000 | [diff] [blame] | 1220 | uint64_t SizeInBits = 0; |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1221 | auto Align = AlignInBits; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1222 | if (!type->isIncompleteArrayType()) { |
David Majnemer | 34b5749 | 2014-07-30 01:30:47 +0000 | [diff] [blame] | 1223 | TypeInfo TI = CGM.getContext().getTypeInfo(type); |
| 1224 | SizeInBits = TI.Width; |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1225 | if (!Align) |
| 1226 | Align = getTypeAlignIfRequired(type, CGM.getContext()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1227 | } |
| 1228 | |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 1229 | llvm::DINode::DIFlags flags = getAccessFlag(AS, RD); |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 1230 | return DBuilder.createMemberType(scope, name, file, line, SizeInBits, Align, |
| 1231 | offsetInBits, flags, debugType); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1232 | } |
| 1233 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1234 | void CGDebugInfo::CollectRecordLambdaFields( |
| 1235 | const CXXRecordDecl *CXXDecl, SmallVectorImpl<llvm::Metadata *> &elements, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1236 | llvm::DIType *RecordTy) { |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1237 | // For C++11 Lambdas a Field will be the same as a Capture, but the Capture |
| 1238 | // has the name and the location of the variable so we should iterate over |
| 1239 | // both concurrently. |
| 1240 | const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(CXXDecl); |
| 1241 | RecordDecl::field_iterator Field = CXXDecl->field_begin(); |
| 1242 | unsigned fieldno = 0; |
| 1243 | for (CXXRecordDecl::capture_const_iterator I = CXXDecl->captures_begin(), |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1244 | E = CXXDecl->captures_end(); |
| 1245 | I != E; ++I, ++Field, ++fieldno) { |
Benjamin Kramer | f3ca2698 | 2014-05-10 16:31:55 +0000 | [diff] [blame] | 1246 | const LambdaCapture &C = *I; |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1247 | if (C.capturesVariable()) { |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1248 | SourceLocation Loc = C.getLocation(); |
| 1249 | assert(!Field->isBitField() && "lambdas don't have bitfield members!"); |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1250 | VarDecl *V = C.getCapturedVar(); |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1251 | StringRef VName = V->getName(); |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1252 | llvm::DIFile *VUnit = getOrCreateFile(Loc); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1253 | auto Align = getDeclAlignIfRequired(V, CGM.getContext()); |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1254 | llvm::DIType *FieldType = createFieldType( |
| 1255 | VName, Field->getType(), Loc, Field->getAccess(), |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1256 | layout.getFieldOffset(fieldno), Align, VUnit, RecordTy, CXXDecl); |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1257 | elements.push_back(FieldType); |
Alexey Bataev | 39c81e2 | 2014-08-28 04:28:19 +0000 | [diff] [blame] | 1258 | } else if (C.capturesThis()) { |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1259 | // TODO: Need to handle 'this' in some way by probably renaming the |
| 1260 | // this of the lambda class and having a field member of 'this' or |
| 1261 | // by using AT_object_pointer for the function and having that be |
| 1262 | // used as 'this' for semantic references. |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1263 | FieldDecl *f = *Field; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1264 | llvm::DIFile *VUnit = getOrCreateFile(f->getLocation()); |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1265 | QualType type = f->getType(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1266 | llvm::DIType *fieldType = createFieldType( |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1267 | "this", type, f->getLocation(), f->getAccess(), |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1268 | layout.getFieldOffset(fieldno), VUnit, RecordTy, CXXDecl); |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1269 | |
| 1270 | elements.push_back(fieldType); |
| 1271 | } |
| 1272 | } |
| 1273 | } |
| 1274 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1275 | llvm::DIDerivedType * |
| 1276 | CGDebugInfo::CreateRecordStaticField(const VarDecl *Var, llvm::DIType *RecordTy, |
Duncan P. N. Exon Smith | c09c548 | 2015-04-20 21:17:26 +0000 | [diff] [blame] | 1277 | const RecordDecl *RD) { |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1278 | // Create the descriptor for the static variable, with or without |
| 1279 | // constant initializers. |
David Blaikie | 8e707bb | 2014-10-14 22:22:17 +0000 | [diff] [blame] | 1280 | Var = Var->getCanonicalDecl(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1281 | llvm::DIFile *VUnit = getOrCreateFile(Var->getLocation()); |
| 1282 | llvm::DIType *VTy = getOrCreateType(Var->getType(), VUnit); |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1283 | |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1284 | unsigned LineNumber = getLineNumber(Var->getLocation()); |
| 1285 | StringRef VName = Var->getName(); |
Craig Topper | 8a13c41 | 2014-05-21 05:09:00 +0000 | [diff] [blame] | 1286 | llvm::Constant *C = nullptr; |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1287 | if (Var->getInit()) { |
| 1288 | const APValue *Value = Var->evaluateValue(); |
David Blaikie | d42917f | 2013-01-20 01:19:17 +0000 | [diff] [blame] | 1289 | if (Value) { |
| 1290 | if (Value->isInt()) |
| 1291 | C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt()); |
| 1292 | if (Value->isFloat()) |
| 1293 | C = llvm::ConstantFP::get(CGM.getLLVMContext(), Value->getFloat()); |
| 1294 | } |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1295 | } |
| 1296 | |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 1297 | llvm::DINode::DIFlags Flags = getAccessFlag(Var->getAccess(), RD); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1298 | auto Align = getDeclAlignIfRequired(Var, CGM.getContext()); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1299 | llvm::DIDerivedType *GV = DBuilder.createStaticMemberType( |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1300 | RecordTy, VName, VUnit, LineNumber, VTy, Flags, C, Align); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1301 | StaticDataMemberCache[Var->getCanonicalDecl()].reset(GV); |
David Blaikie | ae01946 | 2013-08-15 22:50:29 +0000 | [diff] [blame] | 1302 | return GV; |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1303 | } |
| 1304 | |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1305 | void CGDebugInfo::CollectRecordNormalField( |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1306 | const FieldDecl *field, uint64_t OffsetInBits, llvm::DIFile *tunit, |
| 1307 | SmallVectorImpl<llvm::Metadata *> &elements, llvm::DIType *RecordTy, |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1308 | const RecordDecl *RD) { |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1309 | StringRef name = field->getName(); |
| 1310 | QualType type = field->getType(); |
| 1311 | |
| 1312 | // Ignore unnamed fields unless they're anonymous structs/unions. |
| 1313 | if (name.empty() && !type->isRecordType()) |
| 1314 | return; |
| 1315 | |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1316 | llvm::DIType *FieldType; |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1317 | if (field->isBitField()) { |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1318 | FieldType = createBitFieldType(field, RecordTy, RD); |
| 1319 | } else { |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1320 | auto Align = getDeclAlignIfRequired(field, CGM.getContext()); |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1321 | FieldType = |
| 1322 | createFieldType(name, type, field->getLocation(), field->getAccess(), |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1323 | OffsetInBits, Align, tunit, RecordTy, RD); |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1324 | } |
| 1325 | |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 1326 | elements.push_back(FieldType); |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1327 | } |
| 1328 | |
Reid Kleckner | e2e8206 | 2017-08-08 20:30:14 +0000 | [diff] [blame] | 1329 | void CGDebugInfo::CollectRecordNestedType( |
| 1330 | const TypeDecl *TD, SmallVectorImpl<llvm::Metadata *> &elements) { |
| 1331 | QualType Ty = CGM.getContext().getTypeDeclType(TD); |
Reid Kleckner | 755220b | 2016-08-01 18:56:13 +0000 | [diff] [blame] | 1332 | // Injected class names are not considered nested records. |
| 1333 | if (isa<InjectedClassNameType>(Ty)) |
| 1334 | return; |
Reid Kleckner | e2e8206 | 2017-08-08 20:30:14 +0000 | [diff] [blame] | 1335 | SourceLocation Loc = TD->getLocation(); |
Adrian McCarthy | ab1e786 | 2016-07-21 18:43:20 +0000 | [diff] [blame] | 1336 | llvm::DIType *nestedType = getOrCreateType(Ty, getOrCreateFile(Loc)); |
| 1337 | elements.push_back(nestedType); |
| 1338 | } |
| 1339 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1340 | void CGDebugInfo::CollectRecordFields( |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1341 | const RecordDecl *record, llvm::DIFile *tunit, |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1342 | SmallVectorImpl<llvm::Metadata *> &elements, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1343 | llvm::DICompositeType *RecordTy) { |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 1344 | const auto *CXXDecl = dyn_cast<CXXRecordDecl>(record); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1345 | |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1346 | if (CXXDecl && CXXDecl->isLambda()) |
| 1347 | CollectRecordLambdaFields(CXXDecl, elements, RecordTy); |
| 1348 | else { |
| 1349 | const ASTRecordLayout &layout = CGM.getContext().getASTRecordLayout(record); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1350 | |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1351 | // Field number for non-static fields. |
Eric Christopher | 0f759437 | 2013-01-04 17:59:07 +0000 | [diff] [blame] | 1352 | unsigned fieldNo = 0; |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1353 | |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1354 | // Static and non-static members should appear in the same order as |
| 1355 | // the corresponding declarations in the source program. |
Aaron Ballman | 629afae | 2014-03-07 19:56:05 +0000 | [diff] [blame] | 1356 | for (const auto *I : record->decls()) |
| 1357 | if (const auto *V = dyn_cast<VarDecl>(I)) { |
Paul Robinson | b17327d | 2016-04-27 17:37:12 +0000 | [diff] [blame] | 1358 | if (V->hasAttr<NoDebugAttr>()) |
| 1359 | continue; |
Reid Kleckner | 891b271 | 2018-07-20 20:55:00 +0000 | [diff] [blame] | 1360 | |
| 1361 | // Skip variable template specializations when emitting CodeView. MSVC |
| 1362 | // doesn't emit them. |
| 1363 | if (CGM.getCodeGenOpts().EmitCodeView && |
| 1364 | isa<VarTemplateSpecializationDecl>(V)) |
| 1365 | continue; |
| 1366 | |
David Blaikie | ce76304 | 2013-08-20 21:49:21 +0000 | [diff] [blame] | 1367 | // Reuse the existing static member declaration if one exists |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1368 | auto MI = StaticDataMemberCache.find(V->getCanonicalDecl()); |
David Blaikie | ce76304 | 2013-08-20 21:49:21 +0000 | [diff] [blame] | 1369 | if (MI != StaticDataMemberCache.end()) { |
| 1370 | assert(MI->second && |
| 1371 | "Static data member declaration should still exist"); |
Duncan P. N. Exon Smith | ac346ba | 2015-07-24 18:05:58 +0000 | [diff] [blame] | 1372 | elements.push_back(MI->second); |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 1373 | } else { |
| 1374 | auto Field = CreateRecordStaticField(V, RecordTy, record); |
| 1375 | elements.push_back(Field); |
| 1376 | } |
Aaron Ballman | 629afae | 2014-03-07 19:56:05 +0000 | [diff] [blame] | 1377 | } else if (const auto *field = dyn_cast<FieldDecl>(I)) { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1378 | CollectRecordNormalField(field, layout.getFieldOffset(fieldNo), tunit, |
| 1379 | elements, RecordTy, record); |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 1380 | |
| 1381 | // Bump field number for next field. |
| 1382 | ++fieldNo; |
Reid Kleckner | 891b271 | 2018-07-20 20:55:00 +0000 | [diff] [blame] | 1383 | } else if (CGM.getCodeGenOpts().EmitCodeView) { |
| 1384 | // Debug info for nested types is included in the member list only for |
| 1385 | // CodeView. |
Reid Kleckner | e2e8206 | 2017-08-08 20:30:14 +0000 | [diff] [blame] | 1386 | if (const auto *nestedType = dyn_cast<TypeDecl>(I)) |
| 1387 | if (!nestedType->isImplicit() && |
| 1388 | nestedType->getDeclContext() == record) |
| 1389 | CollectRecordNestedType(nestedType, elements); |
| 1390 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1391 | } |
| 1392 | } |
| 1393 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1394 | llvm::DISubroutineType * |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1395 | CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1396 | llvm::DIFile *Unit) { |
David Blaikie | 7eb0685 | 2013-01-07 23:06:35 +0000 | [diff] [blame] | 1397 | const FunctionProtoType *Func = Method->getType()->getAs<FunctionProtoType>(); |
David Blaikie | 2aaf065 | 2013-01-07 22:24:59 +0000 | [diff] [blame] | 1398 | if (Method->isStatic()) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1399 | return cast_or_null<llvm::DISubroutineType>( |
Duncan P. N. Exon Smith | c755128 | 2015-04-06 23:21:33 +0000 | [diff] [blame] | 1400 | getOrCreateType(QualType(Func, 0), Unit)); |
David Blaikie | 7eb0685 | 2013-01-07 23:06:35 +0000 | [diff] [blame] | 1401 | return getOrCreateInstanceMethodType(Method->getThisType(CGM.getContext()), |
| 1402 | Func, Unit); |
| 1403 | } |
David Blaikie | 2aaf065 | 2013-01-07 22:24:59 +0000 | [diff] [blame] | 1404 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1405 | llvm::DISubroutineType *CGDebugInfo::getOrCreateInstanceMethodType( |
| 1406 | QualType ThisPtr, const FunctionProtoType *Func, llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1407 | // Add "this" pointer. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1408 | llvm::DITypeRefArray Args( |
| 1409 | cast<llvm::DISubroutineType>(getOrCreateType(QualType(Func, 0), Unit)) |
Duncan P. N. Exon Smith | c755128 | 2015-04-06 23:21:33 +0000 | [diff] [blame] | 1410 | ->getTypeArray()); |
Duncan P. N. Exon Smith | a98fac6 | 2015-04-07 04:14:45 +0000 | [diff] [blame] | 1411 | assert(Args.size() && "Invalid number of arguments!"); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1412 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1413 | SmallVector<llvm::Metadata *, 16> Elts; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1414 | |
| 1415 | // First element is always return type. For 'void' functions it is NULL. |
Duncan P. N. Exon Smith | 3732858 | 2015-04-07 18:41:26 +0000 | [diff] [blame] | 1416 | Elts.push_back(Args[0]); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1417 | |
David Blaikie | 2aaf065 | 2013-01-07 22:24:59 +0000 | [diff] [blame] | 1418 | // "this" pointer is always first argument. |
David Blaikie | 7eb0685 | 2013-01-07 23:06:35 +0000 | [diff] [blame] | 1419 | const CXXRecordDecl *RD = ThisPtr->getPointeeCXXRecordDecl(); |
David Blaikie | 2aaf065 | 2013-01-07 22:24:59 +0000 | [diff] [blame] | 1420 | if (isa<ClassTemplateSpecializationDecl>(RD)) { |
| 1421 | // Create pointer type directly in this case. |
| 1422 | const PointerType *ThisPtrTy = cast<PointerType>(ThisPtr); |
| 1423 | QualType PointeeTy = ThisPtrTy->getPointeeType(); |
| 1424 | unsigned AS = CGM.getContext().getTargetAddressSpace(PointeeTy); |
John McCall | c8e0170 | 2013-04-16 22:48:15 +0000 | [diff] [blame] | 1425 | uint64_t Size = CGM.getTarget().getPointerWidth(AS); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 1426 | auto Align = getTypeAlignIfRequired(ThisPtrTy, CGM.getContext()); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1427 | llvm::DIType *PointeeType = getOrCreateType(PointeeTy, Unit); |
| 1428 | llvm::DIType *ThisPtrType = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1429 | DBuilder.createPointerType(PointeeType, Size, Align); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1430 | TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType); |
David Blaikie | 2aaf065 | 2013-01-07 22:24:59 +0000 | [diff] [blame] | 1431 | // TODO: This and the artificial type below are misleading, the |
| 1432 | // types aren't artificial the argument is, but the current |
| 1433 | // metadata doesn't represent that. |
| 1434 | ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType); |
| 1435 | Elts.push_back(ThisPtrType); |
| 1436 | } else { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1437 | llvm::DIType *ThisPtrType = getOrCreateType(ThisPtr, Unit); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1438 | TypeCache[ThisPtr.getAsOpaquePtr()].reset(ThisPtrType); |
David Blaikie | 2aaf065 | 2013-01-07 22:24:59 +0000 | [diff] [blame] | 1439 | ThisPtrType = DBuilder.createObjectPointerType(ThisPtrType); |
| 1440 | Elts.push_back(ThisPtrType); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1441 | } |
| 1442 | |
| 1443 | // Copy rest of the arguments. |
Duncan P. N. Exon Smith | a98fac6 | 2015-04-07 04:14:45 +0000 | [diff] [blame] | 1444 | for (unsigned i = 1, e = Args.size(); i != e; ++i) |
| 1445 | Elts.push_back(Args[i]); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1446 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1447 | llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1448 | |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 1449 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero; |
Adrian Prantl | 0630eb7 | 2013-12-18 21:48:18 +0000 | [diff] [blame] | 1450 | if (Func->getExtProtoInfo().RefQualifier == RQ_LValue) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1451 | Flags |= llvm::DINode::FlagLValueReference; |
Adrian Prantl | 0630eb7 | 2013-12-18 21:48:18 +0000 | [diff] [blame] | 1452 | if (Func->getExtProtoInfo().RefQualifier == RQ_RValue) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1453 | Flags |= llvm::DINode::FlagRValueReference; |
Adrian Prantl | 0630eb7 | 2013-12-18 21:48:18 +0000 | [diff] [blame] | 1454 | |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 1455 | return DBuilder.createSubroutineType(EltTypeArray, Flags, |
| 1456 | getDwarfCC(Func->getCallConv())); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1457 | } |
| 1458 | |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1459 | /// isFunctionLocalClass - Return true if CXXRecordDecl is defined |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1460 | /// inside a function. |
| 1461 | static bool isFunctionLocalClass(const CXXRecordDecl *RD) { |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 1462 | if (const auto *NRD = dyn_cast<CXXRecordDecl>(RD->getDeclContext())) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1463 | return isFunctionLocalClass(NRD); |
| 1464 | if (isa<FunctionDecl>(RD->getDeclContext())) |
| 1465 | return true; |
| 1466 | return false; |
| 1467 | } |
| 1468 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1469 | llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction( |
| 1470 | const CXXMethodDecl *Method, llvm::DIFile *Unit, llvm::DIType *RecordTy) { |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1471 | bool IsCtorOrDtor = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1472 | isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1473 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1474 | StringRef MethodName = getFunctionName(Method); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1475 | llvm::DISubroutineType *MethodTy = getOrCreateMethodType(Method, Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1476 | |
| 1477 | // Since a single ctor/dtor corresponds to multiple functions, it doesn't |
| 1478 | // make sense to give a single ctor/dtor a linkage name. |
| 1479 | StringRef MethodLinkageName; |
David Blaikie | 7164767 | 2016-04-12 21:22:48 +0000 | [diff] [blame] | 1480 | // FIXME: 'isFunctionLocalClass' seems like an arbitrary/unintentional |
| 1481 | // property to use here. It may've been intended to model "is non-external |
| 1482 | // type" but misses cases of non-function-local but non-external classes such |
| 1483 | // as those in anonymous namespaces as well as the reverse - external types |
| 1484 | // that are function local, such as those in (non-local) inline functions. |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1485 | if (!IsCtorOrDtor && !isFunctionLocalClass(Method->getParent())) |
| 1486 | MethodLinkageName = CGM.getMangledName(Method); |
| 1487 | |
| 1488 | // Get the location for the method. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1489 | llvm::DIFile *MethodDefUnit = nullptr; |
David Blaikie | 7fceebf | 2013-08-19 03:37:48 +0000 | [diff] [blame] | 1490 | unsigned MethodLine = 0; |
| 1491 | if (!Method->isImplicit()) { |
| 1492 | MethodDefUnit = getOrCreateFile(Method->getLocation()); |
| 1493 | MethodLine = getLineNumber(Method->getLocation()); |
| 1494 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1495 | |
| 1496 | // Collect virtual method info. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1497 | llvm::DIType *ContainingType = nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1498 | unsigned VIndex = 0; |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 1499 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero; |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 1500 | llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero; |
Reid Kleckner | 0358cbf | 2016-07-01 02:41:25 +0000 | [diff] [blame] | 1501 | int ThisAdjustment = 0; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1502 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1503 | if (Method->isVirtual()) { |
| 1504 | if (Method->isPure()) |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 1505 | SPFlags |= llvm::DISubprogram::SPFlagPureVirtual; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1506 | else |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 1507 | SPFlags |= llvm::DISubprogram::SPFlagVirtual; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1508 | |
Reid Kleckner | 216d0a1 | 2016-06-16 20:08:51 +0000 | [diff] [blame] | 1509 | if (CGM.getTarget().getCXXABI().isItaniumFamily()) { |
| 1510 | // It doesn't make sense to give a virtual destructor a vtable index, |
| 1511 | // since a single destructor has two entries in the vtable. |
| 1512 | if (!isa<CXXDestructorDecl>(Method)) |
| 1513 | VIndex = CGM.getItaniumVTableContext().getMethodVTableIndex(Method); |
| 1514 | } else { |
| 1515 | // Emit MS ABI vftable information. There is only one entry for the |
| 1516 | // deleting dtor. |
| 1517 | const auto *DD = dyn_cast<CXXDestructorDecl>(Method); |
| 1518 | GlobalDecl GD = DD ? GlobalDecl(DD, Dtor_Deleting) : GlobalDecl(Method); |
Reid Kleckner | cbec026 | 2018-04-02 20:00:39 +0000 | [diff] [blame] | 1519 | MethodVFTableLocation ML = |
Reid Kleckner | 216d0a1 | 2016-06-16 20:08:51 +0000 | [diff] [blame] | 1520 | CGM.getMicrosoftVTableContext().getMethodVFTableLocation(GD); |
| 1521 | VIndex = ML.Index; |
Reid Kleckner | c4871ed | 2016-06-22 18:34:45 +0000 | [diff] [blame] | 1522 | |
| 1523 | // CodeView only records the vftable offset in the class that introduces |
| 1524 | // the virtual method. This is possible because, unlike Itanium, the MS |
| 1525 | // C++ ABI does not include all virtual methods from non-primary bases in |
| 1526 | // the vtable for the most derived class. For example, if C inherits from |
| 1527 | // A and B, C's primary vftable will not include B's virtual methods. |
Benjamin Kramer | acfa339 | 2017-12-17 23:52:45 +0000 | [diff] [blame] | 1528 | if (Method->size_overridden_methods() == 0) |
Reid Kleckner | c4871ed | 2016-06-22 18:34:45 +0000 | [diff] [blame] | 1529 | Flags |= llvm::DINode::FlagIntroducedVirtual; |
| 1530 | |
Reid Kleckner | 0358cbf | 2016-07-01 02:41:25 +0000 | [diff] [blame] | 1531 | // The 'this' adjustment accounts for both the virtual and non-virtual |
| 1532 | // portions of the adjustment. Presumably the debugger only uses it when |
| 1533 | // it knows the dynamic type of an object. |
| 1534 | ThisAdjustment = CGM.getCXXABI() |
| 1535 | .getVirtualFunctionPrologueThisAdjustment(GD) |
| 1536 | .getQuantity(); |
Reid Kleckner | 216d0a1 | 2016-06-16 20:08:51 +0000 | [diff] [blame] | 1537 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1538 | ContainingType = RecordTy; |
| 1539 | } |
| 1540 | |
Adrian McCarthy | d91bf39 | 2017-09-13 20:53:55 +0000 | [diff] [blame] | 1541 | if (Method->isStatic()) |
| 1542 | Flags |= llvm::DINode::FlagStaticMember; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1543 | if (Method->isImplicit()) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1544 | Flags |= llvm::DINode::FlagArtificial; |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 1545 | Flags |= getAccessFlag(Method->getAccess(), Method->getParent()); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 1546 | if (const auto *CXXC = dyn_cast<CXXConstructorDecl>(Method)) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1547 | if (CXXC->isExplicit()) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1548 | Flags |= llvm::DINode::FlagExplicit; |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 1549 | } else if (const auto *CXXC = dyn_cast<CXXConversionDecl>(Method)) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1550 | if (CXXC->isExplicit()) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1551 | Flags |= llvm::DINode::FlagExplicit; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1552 | } |
| 1553 | if (Method->hasPrototype()) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1554 | Flags |= llvm::DINode::FlagPrototyped; |
Adrian Prantl | 0630eb7 | 2013-12-18 21:48:18 +0000 | [diff] [blame] | 1555 | if (Method->getRefQualifier() == RQ_LValue) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1556 | Flags |= llvm::DINode::FlagLValueReference; |
Adrian Prantl | 0630eb7 | 2013-12-18 21:48:18 +0000 | [diff] [blame] | 1557 | if (Method->getRefQualifier() == RQ_RValue) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1558 | Flags |= llvm::DINode::FlagRValueReference; |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 1559 | if (CGM.getLangOpts().Optimize) |
| 1560 | SPFlags |= llvm::DISubprogram::SPFlagOptimized; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1561 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1562 | llvm::DINodeArray TParamsArray = CollectFunctionTemplateParams(Method, Unit); |
| 1563 | llvm::DISubprogram *SP = DBuilder.createMethod( |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1564 | RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine, |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 1565 | MethodTy, VIndex, ThisAdjustment, ContainingType, Flags, SPFlags, |
Reid Kleckner | 0358cbf | 2016-07-01 02:41:25 +0000 | [diff] [blame] | 1566 | TParamsArray.get()); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1567 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1568 | SPCache[Method->getCanonicalDecl()].reset(SP); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1569 | |
| 1570 | return SP; |
| 1571 | } |
| 1572 | |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1573 | void CGDebugInfo::CollectCXXMemberFunctions( |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1574 | const CXXRecordDecl *RD, llvm::DIFile *Unit, |
| 1575 | SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1576 | |
| 1577 | // Since we want more than just the individual member decls if we |
| 1578 | // have templated functions iterate over every declaration to gather |
| 1579 | // the functions. |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1580 | for (const auto *I : RD->decls()) { |
David Blaikie | fd58072 | 2014-10-06 05:18:55 +0000 | [diff] [blame] | 1581 | const auto *Method = dyn_cast<CXXMethodDecl>(I); |
| 1582 | // If the member is implicit, don't add it to the member list. This avoids |
| 1583 | // the member being added to type units by LLVM, while still allowing it |
| 1584 | // to be emitted into the type declaration/reference inside the compile |
| 1585 | // unit. |
Paul Robinson | 6a7511b | 2015-06-25 17:50:43 +0000 | [diff] [blame] | 1586 | // Ditto 'nodebug' methods, for consistency with CodeGenFunction.cpp. |
David Blaikie | 6dddfe3 | 2014-10-06 05:52:27 +0000 | [diff] [blame] | 1587 | // FIXME: Handle Using(Shadow?)Decls here to create |
| 1588 | // DW_TAG_imported_declarations inside the class for base decls brought into |
| 1589 | // derived classes. GDB doesn't seem to notice/leverage these when I tried |
| 1590 | // it, so I'm not rushing to fix this. (GCC seems to produce them, if |
| 1591 | // referenced) |
Paul Robinson | 6a7511b | 2015-06-25 17:50:43 +0000 | [diff] [blame] | 1592 | if (!Method || Method->isImplicit() || Method->hasAttr<NoDebugAttr>()) |
David Blaikie | fd58072 | 2014-10-06 05:18:55 +0000 | [diff] [blame] | 1593 | continue; |
David Blaikie | 42edade | 2014-11-11 20:44:45 +0000 | [diff] [blame] | 1594 | |
| 1595 | if (Method->getType()->getAs<FunctionProtoType>()->getContainedAutoType()) |
| 1596 | continue; |
| 1597 | |
David Blaikie | fd58072 | 2014-10-06 05:18:55 +0000 | [diff] [blame] | 1598 | // Reuse the existing member function declaration if it exists. |
| 1599 | // It may be associated with the declaration of the type & should be |
| 1600 | // reused as we're building the definition. |
| 1601 | // |
| 1602 | // This situation can arise in the vtable-based debug info reduction where |
| 1603 | // implicit members are emitted in a non-vtable TU. |
| 1604 | auto MI = SPCache.find(Method->getCanonicalDecl()); |
| 1605 | EltTys.push_back(MI == SPCache.end() |
| 1606 | ? CreateCXXMemberFunction(Method, Unit, RecordTy) |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1607 | : static_cast<llvm::Metadata *>(MI->second)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1608 | } |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1609 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1610 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1611 | void CGDebugInfo::CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile *Unit, |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1612 | SmallVectorImpl<llvm::Metadata *> &EltTys, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1613 | llvm::DIType *RecordTy) { |
Bob Haarman | dff3673 | 2016-10-25 22:19:32 +0000 | [diff] [blame] | 1614 | llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> SeenTypes; |
| 1615 | CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->bases(), SeenTypes, |
| 1616 | llvm::DINode::FlagZero); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1617 | |
Bob Haarman | dff3673 | 2016-10-25 22:19:32 +0000 | [diff] [blame] | 1618 | // If we are generating CodeView debug info, we also need to emit records for |
| 1619 | // indirect virtual base classes. |
| 1620 | if (CGM.getCodeGenOpts().EmitCodeView) { |
| 1621 | CollectCXXBasesAux(RD, Unit, EltTys, RecordTy, RD->vbases(), SeenTypes, |
| 1622 | llvm::DINode::FlagIndirectVirtualBase); |
| 1623 | } |
| 1624 | } |
| 1625 | |
| 1626 | void CGDebugInfo::CollectCXXBasesAux( |
| 1627 | const CXXRecordDecl *RD, llvm::DIFile *Unit, |
| 1628 | SmallVectorImpl<llvm::Metadata *> &EltTys, llvm::DIType *RecordTy, |
| 1629 | const CXXRecordDecl::base_class_const_range &Bases, |
| 1630 | llvm::DenseSet<CanonicalDeclPtr<const CXXRecordDecl>> &SeenTypes, |
| 1631 | llvm::DINode::DIFlags StartingFlags) { |
| 1632 | const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD); |
| 1633 | for (const auto &BI : Bases) { |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 1634 | const auto *Base = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1635 | cast<CXXRecordDecl>(BI.getType()->getAs<RecordType>()->getDecl()); |
Bob Haarman | dff3673 | 2016-10-25 22:19:32 +0000 | [diff] [blame] | 1636 | if (!SeenTypes.insert(Base).second) |
| 1637 | continue; |
| 1638 | auto *BaseTy = getOrCreateType(BI.getType(), Unit); |
| 1639 | llvm::DINode::DIFlags BFlags = StartingFlags; |
| 1640 | uint64_t BaseOffset; |
Brock Wyma | 3db2b10 | 2018-05-14 21:21:22 +0000 | [diff] [blame] | 1641 | uint32_t VBPtrOffset = 0; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1642 | |
Aaron Ballman | 574705e | 2014-03-13 15:41:46 +0000 | [diff] [blame] | 1643 | if (BI.isVirtual()) { |
Reid Kleckner | d3b23d6 | 2014-08-07 21:29:25 +0000 | [diff] [blame] | 1644 | if (CGM.getTarget().getCXXABI().isItaniumFamily()) { |
| 1645 | // virtual base offset offset is -ve. The code generator emits dwarf |
| 1646 | // expression where it expects +ve number. |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1647 | BaseOffset = 0 - CGM.getItaniumVTableContext() |
| 1648 | .getVirtualBaseOffsetOffset(RD, Base) |
| 1649 | .getQuantity(); |
Reid Kleckner | d3b23d6 | 2014-08-07 21:29:25 +0000 | [diff] [blame] | 1650 | } else { |
| 1651 | // In the MS ABI, store the vbtable offset, which is analogous to the |
| 1652 | // vbase offset offset in Itanium. |
| 1653 | BaseOffset = |
| 1654 | 4 * CGM.getMicrosoftVTableContext().getVBTableIndex(RD, Base); |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 1655 | VBPtrOffset = CGM.getContext() |
| 1656 | .getASTRecordLayout(RD) |
| 1657 | .getVBPtrOffset() |
| 1658 | .getQuantity(); |
Reid Kleckner | d3b23d6 | 2014-08-07 21:29:25 +0000 | [diff] [blame] | 1659 | } |
Bob Haarman | dff3673 | 2016-10-25 22:19:32 +0000 | [diff] [blame] | 1660 | BFlags |= llvm::DINode::FlagVirtual; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1661 | } else |
| 1662 | BaseOffset = CGM.getContext().toBits(RL.getBaseClassOffset(Base)); |
| 1663 | // FIXME: Inconsistent units for BaseOffset. It is in bytes when |
| 1664 | // BI->isVirtual() and bits when not. |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 1665 | |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 1666 | BFlags |= getAccessFlag(BI.getAccessSpecifier(), RD); |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 1667 | llvm::DIType *DTy = DBuilder.createInheritance(RecordTy, BaseTy, BaseOffset, |
| 1668 | VBPtrOffset, BFlags); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1669 | EltTys.push_back(DTy); |
| 1670 | } |
| 1671 | } |
| 1672 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1673 | llvm::DINodeArray |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1674 | CGDebugInfo::CollectTemplateParams(const TemplateParameterList *TPList, |
| 1675 | ArrayRef<TemplateArgument> TAList, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1676 | llvm::DIFile *Unit) { |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1677 | SmallVector<llvm::Metadata *, 16> TemplateParams; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1678 | for (unsigned i = 0, e = TAList.size(); i != e; ++i) { |
| 1679 | const TemplateArgument &TA = TAList[i]; |
David Blaikie | 47c1150 | 2013-06-22 18:59:18 +0000 | [diff] [blame] | 1680 | StringRef Name; |
| 1681 | if (TPList) |
| 1682 | Name = TPList->getParam(i)->getName(); |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1683 | switch (TA.getKind()) { |
| 1684 | case TemplateArgument::Type: { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1685 | llvm::DIType *TTy = getOrCreateType(TA.getAsType(), Unit); |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 1686 | TemplateParams.push_back( |
| 1687 | DBuilder.createTemplateTypeParameter(TheCU, Name, TTy)); |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1688 | } break; |
| 1689 | case TemplateArgument::Integral: { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1690 | llvm::DIType *TTy = getOrCreateType(TA.getIntegralType(), Unit); |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 1691 | TemplateParams.push_back(DBuilder.createTemplateValueParameter( |
| 1692 | TheCU, Name, TTy, |
| 1693 | llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral()))); |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1694 | } break; |
| 1695 | case TemplateArgument::Declaration: { |
| 1696 | const ValueDecl *D = TA.getAsDecl(); |
David Blaikie | b5c7e6a | 2014-10-18 02:21:26 +0000 | [diff] [blame] | 1697 | QualType T = TA.getParamTypeForDecl().getDesugaredType(CGM.getContext()); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1698 | llvm::DIType *TTy = getOrCreateType(T, Unit); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1699 | llvm::Constant *V = nullptr; |
David Blaikie | 1a83db4 | 2014-10-20 18:56:54 +0000 | [diff] [blame] | 1700 | const CXXMethodDecl *MD; |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1701 | // Variable pointer template parameters have a value that is the address |
| 1702 | // of the variable. |
David Blaikie | 952a9b1 | 2014-10-17 18:00:12 +0000 | [diff] [blame] | 1703 | if (const auto *VD = dyn_cast<VarDecl>(D)) |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1704 | V = CGM.GetAddrOfGlobalVar(VD); |
| 1705 | // Member function pointers have special support for building them, though |
| 1706 | // this is currently unsupported in LLVM CodeGen. |
David Blaikie | 1a83db4 | 2014-10-20 18:56:54 +0000 | [diff] [blame] | 1707 | else if ((MD = dyn_cast<CXXMethodDecl>(D)) && MD->isInstance()) |
David Majnemer | e2be95b | 2015-06-23 07:31:01 +0000 | [diff] [blame] | 1708 | V = CGM.getCXXABI().EmitMemberFunctionPointer(MD); |
David Blaikie | 952a9b1 | 2014-10-17 18:00:12 +0000 | [diff] [blame] | 1709 | else if (const auto *FD = dyn_cast<FunctionDecl>(D)) |
David Blaikie | d900f98 | 2013-05-13 06:57:50 +0000 | [diff] [blame] | 1710 | V = CGM.GetAddrOfFunction(FD); |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1711 | // Member data pointers have special handling too to compute the fixed |
| 1712 | // offset within the object. |
David Blaikie | 952a9b1 | 2014-10-17 18:00:12 +0000 | [diff] [blame] | 1713 | else if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr())) { |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1714 | // These five lines (& possibly the above member function pointer |
| 1715 | // handling) might be able to be refactored to use similar code in |
| 1716 | // CodeGenModule::getMemberPointerConstant |
| 1717 | uint64_t fieldOffset = CGM.getContext().getFieldOffset(D); |
| 1718 | CharUnits chars = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1719 | CGM.getContext().toCharUnitsFromBits((int64_t)fieldOffset); |
David Blaikie | 952a9b1 | 2014-10-17 18:00:12 +0000 | [diff] [blame] | 1720 | V = CGM.getCXXABI().EmitMemberDataPointer(MPT, chars); |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1721 | } |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 1722 | TemplateParams.push_back(DBuilder.createTemplateValueParameter( |
| 1723 | TheCU, Name, TTy, |
| 1724 | cast_or_null<llvm::Constant>(V->stripPointerCasts()))); |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1725 | } break; |
| 1726 | case TemplateArgument::NullPtr: { |
| 1727 | QualType T = TA.getNullPtrType(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1728 | llvm::DIType *TTy = getOrCreateType(T, Unit); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1729 | llvm::Constant *V = nullptr; |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1730 | // Special case member data pointer null values since they're actually -1 |
| 1731 | // instead of zero. |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 1732 | if (const auto *MPT = dyn_cast<MemberPointerType>(T.getTypePtr())) |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1733 | // But treat member function pointers as simple zero integers because |
| 1734 | // it's easier than having a special case in LLVM's CodeGen. If LLVM |
| 1735 | // CodeGen grows handling for values of non-null member function |
| 1736 | // pointers then perhaps we could remove this special case and rely on |
| 1737 | // EmitNullMemberPointer for member function pointers. |
| 1738 | if (MPT->isMemberDataPointer()) |
| 1739 | V = CGM.getCXXABI().EmitNullMemberPointer(MPT); |
| 1740 | if (!V) |
| 1741 | V = llvm::ConstantInt::get(CGM.Int8Ty, 0); |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 1742 | TemplateParams.push_back( |
| 1743 | DBuilder.createTemplateValueParameter(TheCU, Name, TTy, V)); |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1744 | } break; |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 1745 | case TemplateArgument::Template: |
| 1746 | TemplateParams.push_back(DBuilder.createTemplateTemplateParameter( |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 1747 | TheCU, Name, nullptr, |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 1748 | TA.getAsTemplate().getAsTemplateDecl()->getQualifiedNameAsString())); |
| 1749 | break; |
| 1750 | case TemplateArgument::Pack: |
| 1751 | TemplateParams.push_back(DBuilder.createTemplateParameterPack( |
| 1752 | TheCU, Name, nullptr, |
| 1753 | CollectTemplateParams(nullptr, TA.getPackAsArray(), Unit))); |
| 1754 | break; |
David Majnemer | 5559d47 | 2013-08-24 08:21:10 +0000 | [diff] [blame] | 1755 | case TemplateArgument::Expression: { |
| 1756 | const Expr *E = TA.getAsExpr(); |
| 1757 | QualType T = E->getType(); |
David Majnemer | 922ad9f | 2014-10-24 19:49:04 +0000 | [diff] [blame] | 1758 | if (E->isGLValue()) |
| 1759 | T = CGM.getContext().getLValueReferenceType(T); |
John McCall | de0fe07 | 2017-08-15 21:42:52 +0000 | [diff] [blame] | 1760 | llvm::Constant *V = ConstantEmitter(CGM).emitAbstract(E, T); |
David Majnemer | 5559d47 | 2013-08-24 08:21:10 +0000 | [diff] [blame] | 1761 | assert(V && "Expression in template argument isn't constant"); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1762 | llvm::DIType *TTy = getOrCreateType(T, Unit); |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 1763 | TemplateParams.push_back(DBuilder.createTemplateValueParameter( |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 1764 | TheCU, Name, TTy, V->stripPointerCasts())); |
David Majnemer | 5559d47 | 2013-08-24 08:21:10 +0000 | [diff] [blame] | 1765 | } break; |
David Blaikie | 2b93c54 | 2013-05-10 23:36:06 +0000 | [diff] [blame] | 1766 | // And the following should never occur: |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1767 | case TemplateArgument::TemplateExpansion: |
David Blaikie | 38079fd | 2013-05-10 21:53:14 +0000 | [diff] [blame] | 1768 | case TemplateArgument::Null: |
| 1769 | llvm_unreachable( |
| 1770 | "These argument types shouldn't exist in concrete types"); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1771 | } |
| 1772 | } |
| 1773 | return DBuilder.getOrCreateArray(TemplateParams); |
| 1774 | } |
| 1775 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1776 | llvm::DINodeArray |
Duncan P. N. Exon Smith | 8e47da4 | 2015-04-21 20:07:29 +0000 | [diff] [blame] | 1777 | CGDebugInfo::CollectFunctionTemplateParams(const FunctionDecl *FD, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1778 | llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1779 | if (FD->getTemplatedKind() == |
| 1780 | FunctionDecl::TK_FunctionTemplateSpecialization) { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1781 | const TemplateParameterList *TList = FD->getTemplateSpecializationInfo() |
| 1782 | ->getTemplate() |
| 1783 | ->getTemplateParameters(); |
David Blaikie | 47c1150 | 2013-06-22 18:59:18 +0000 | [diff] [blame] | 1784 | return CollectTemplateParams( |
| 1785 | TList, FD->getTemplateSpecializationArgs()->asArray(), Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1786 | } |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1787 | return llvm::DINodeArray(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1788 | } |
| 1789 | |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 1790 | llvm::DINodeArray CGDebugInfo::CollectVarTemplateParams(const VarDecl *VL, |
| 1791 | llvm::DIFile *Unit) { |
| 1792 | if (auto *TS = dyn_cast<VarTemplateSpecializationDecl>(VL)) { |
| 1793 | auto T = TS->getSpecializedTemplateOrPartial(); |
| 1794 | auto TA = TS->getTemplateArgs().asArray(); |
| 1795 | // Collect parameters for a partial specialization |
| 1796 | if (T.is<VarTemplatePartialSpecializationDecl *>()) { |
| 1797 | const TemplateParameterList *TList = |
| 1798 | T.get<VarTemplatePartialSpecializationDecl *>() |
| 1799 | ->getTemplateParameters(); |
| 1800 | return CollectTemplateParams(TList, TA, Unit); |
| 1801 | } |
| 1802 | |
| 1803 | // Collect parameters for an explicit specialization |
| 1804 | if (T.is<VarTemplateDecl *>()) { |
| 1805 | const TemplateParameterList *TList = T.get<VarTemplateDecl *>() |
| 1806 | ->getTemplateParameters(); |
| 1807 | return CollectTemplateParams(TList, TA, Unit); |
| 1808 | } |
| 1809 | } |
| 1810 | return llvm::DINodeArray(); |
| 1811 | } |
| 1812 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1813 | llvm::DINodeArray CGDebugInfo::CollectCXXTemplateParams( |
| 1814 | const ClassTemplateSpecializationDecl *TSpecial, llvm::DIFile *Unit) { |
Adrian Prantl | 649f030 | 2014-04-17 01:04:01 +0000 | [diff] [blame] | 1815 | // Always get the full list of parameters, not just the ones from |
| 1816 | // the specialization. |
| 1817 | TemplateParameterList *TPList = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1818 | TSpecial->getSpecializedTemplate()->getTemplateParameters(); |
Adrian Prantl | 2c92e9c | 2014-04-17 00:30:48 +0000 | [diff] [blame] | 1819 | const TemplateArgumentList &TAList = TSpecial->getTemplateArgs(); |
David Blaikie | 47c1150 | 2013-06-22 18:59:18 +0000 | [diff] [blame] | 1820 | return CollectTemplateParams(TPList, TAList.asArray(), Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1821 | } |
| 1822 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1823 | llvm::DIType *CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile *Unit) { |
Duncan P. N. Exon Smith | b747023 | 2015-04-15 23:48:50 +0000 | [diff] [blame] | 1824 | if (VTablePtrType) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1825 | return VTablePtrType; |
| 1826 | |
| 1827 | ASTContext &Context = CGM.getContext(); |
| 1828 | |
| 1829 | /* Function type */ |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1830 | llvm::Metadata *STy = getOrCreateType(Context.IntTy, Unit); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1831 | llvm::DITypeRefArray SElements = DBuilder.getOrCreateTypeArray(STy); |
Eric Christopher | 28a6db5 | 2015-10-15 06:56:08 +0000 | [diff] [blame] | 1832 | llvm::DIType *SubTy = DBuilder.createSubroutineType(SElements); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1833 | unsigned Size = Context.getTypeSize(Context.VoidPtrTy); |
Konstantin Zhuravlyov | d1ba16e | 2017-03-08 23:56:48 +0000 | [diff] [blame] | 1834 | unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace(); |
| 1835 | Optional<unsigned> DWARFAddressSpace = |
| 1836 | CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace); |
| 1837 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 1838 | llvm::DIType *vtbl_ptr_type = DBuilder.createPointerType( |
| 1839 | SubTy, Size, 0, DWARFAddressSpace, "__vtbl_ptr_type"); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1840 | VTablePtrType = DBuilder.createPointerType(vtbl_ptr_type, Size); |
| 1841 | return VTablePtrType; |
| 1842 | } |
| 1843 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1844 | StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) { |
Benjamin Kramer | 1b18a5e | 2013-09-09 16:39:06 +0000 | [diff] [blame] | 1845 | // Copy the gdb compatible name on the side and use its reference. |
| 1846 | return internString("_vptr$", RD->getNameAsString()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1847 | } |
| 1848 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1849 | void CGDebugInfo::CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile *Unit, |
Reid Kleckner | dc12499 | 2016-08-31 16:11:43 +0000 | [diff] [blame] | 1850 | SmallVectorImpl<llvm::Metadata *> &EltTys, |
| 1851 | llvm::DICompositeType *RecordTy) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1852 | // If this class is not dynamic then there is not any vtable info to collect. |
| 1853 | if (!RD->isDynamicClass()) |
| 1854 | return; |
| 1855 | |
Reid Kleckner | 5981242 | 2016-08-31 20:35:01 +0000 | [diff] [blame] | 1856 | // Don't emit any vtable shape or vptr info if this class doesn't have an |
| 1857 | // extendable vfptr. This can happen if the class doesn't have virtual |
| 1858 | // methods, or in the MS ABI if those virtual methods only come from virtually |
| 1859 | // inherited bases. |
| 1860 | const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD); |
| 1861 | if (!RL.hasExtendableVFPtr()) |
| 1862 | return; |
| 1863 | |
Reid Kleckner | dc12499 | 2016-08-31 16:11:43 +0000 | [diff] [blame] | 1864 | // CodeView needs to know how large the vtable of every dynamic class is, so |
| 1865 | // emit a special named pointer type into the element list. The vptr type |
| 1866 | // points to this type as well. |
| 1867 | llvm::DIType *VPtrTy = nullptr; |
| 1868 | bool NeedVTableShape = CGM.getCodeGenOpts().EmitCodeView && |
| 1869 | CGM.getTarget().getCXXABI().isMicrosoft(); |
| 1870 | if (NeedVTableShape) { |
| 1871 | uint64_t PtrWidth = |
| 1872 | CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy); |
| 1873 | const VTableLayout &VFTLayout = |
| 1874 | CGM.getMicrosoftVTableContext().getVFTableLayout(RD, CharUnits::Zero()); |
| 1875 | unsigned VSlotCount = |
Peter Collingbourne | e53683f | 2016-09-08 01:14:39 +0000 | [diff] [blame] | 1876 | VFTLayout.vtable_components().size() - CGM.getLangOpts().RTTIData; |
Reid Kleckner | dc12499 | 2016-08-31 16:11:43 +0000 | [diff] [blame] | 1877 | unsigned VTableWidth = PtrWidth * VSlotCount; |
Konstantin Zhuravlyov | d1ba16e | 2017-03-08 23:56:48 +0000 | [diff] [blame] | 1878 | unsigned VtblPtrAddressSpace = CGM.getTarget().getVtblPtrAddressSpace(); |
| 1879 | Optional<unsigned> DWARFAddressSpace = |
| 1880 | CGM.getTarget().getDWARFAddressSpace(VtblPtrAddressSpace); |
Reid Kleckner | dc12499 | 2016-08-31 16:11:43 +0000 | [diff] [blame] | 1881 | |
| 1882 | // Create a very wide void* type and insert it directly in the element list. |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 1883 | llvm::DIType *VTableType = DBuilder.createPointerType( |
| 1884 | nullptr, VTableWidth, 0, DWARFAddressSpace, "__vtbl_ptr_type"); |
Reid Kleckner | dc12499 | 2016-08-31 16:11:43 +0000 | [diff] [blame] | 1885 | EltTys.push_back(VTableType); |
| 1886 | |
| 1887 | // The vptr is a pointer to this special vtable type. |
| 1888 | VPtrTy = DBuilder.createPointerType(VTableType, PtrWidth); |
| 1889 | } |
| 1890 | |
| 1891 | // If there is a primary base then the artificial vptr member lives there. |
Reid Kleckner | dc12499 | 2016-08-31 16:11:43 +0000 | [diff] [blame] | 1892 | if (RL.getPrimaryBase()) |
| 1893 | return; |
| 1894 | |
| 1895 | if (!VPtrTy) |
| 1896 | VPtrTy = getOrCreateVTablePtrType(Unit); |
| 1897 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1898 | unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy); |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 1899 | llvm::DIType *VPtrMember = |
| 1900 | DBuilder.createMemberType(Unit, getVTableName(RD), Unit, 0, Size, 0, 0, |
| 1901 | llvm::DINode::FlagArtificial, VPtrTy); |
Reid Kleckner | dc12499 | 2016-08-31 16:11:43 +0000 | [diff] [blame] | 1902 | EltTys.push_back(VPtrMember); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1903 | } |
| 1904 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1905 | llvm::DIType *CGDebugInfo::getOrCreateRecordType(QualType RTy, |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 1906 | SourceLocation Loc) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 1907 | assert(DebugKind >= codegenoptions::LimitedDebugInfo); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1908 | llvm::DIType *T = getOrCreateType(RTy, getOrCreateFile(Loc)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1909 | return T; |
| 1910 | } |
| 1911 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1912 | llvm::DIType *CGDebugInfo::getOrCreateInterfaceType(QualType D, |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 1913 | SourceLocation Loc) { |
Adrian Prantl | ad9a195e | 2015-08-27 21:21:19 +0000 | [diff] [blame] | 1914 | return getOrCreateStandaloneType(D, Loc); |
| 1915 | } |
| 1916 | |
| 1917 | llvm::DIType *CGDebugInfo::getOrCreateStandaloneType(QualType D, |
| 1918 | SourceLocation Loc) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 1919 | assert(DebugKind >= codegenoptions::LimitedDebugInfo); |
Adrian Prantl | ad9a195e | 2015-08-27 21:21:19 +0000 | [diff] [blame] | 1920 | assert(!D.isNull() && "null type"); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1921 | llvm::DIType *T = getOrCreateType(D, getOrCreateFile(Loc)); |
Adrian Prantl | ad9a195e | 2015-08-27 21:21:19 +0000 | [diff] [blame] | 1922 | assert(T && "could not create debug info for type"); |
Adrian Prantl | 3a884fa | 2015-08-27 22:56:46 +0000 | [diff] [blame] | 1923 | |
Adrian Prantl | 73409ce | 2013-03-11 18:33:46 +0000 | [diff] [blame] | 1924 | RetainedTypes.push_back(D.getAsOpaquePtr()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 1925 | return T; |
| 1926 | } |
| 1927 | |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 1928 | void CGDebugInfo::completeType(const EnumDecl *ED) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 1929 | if (DebugKind <= codegenoptions::DebugLineTablesOnly) |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 1930 | return; |
| 1931 | QualType Ty = CGM.getContext().getEnumType(ED); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 1932 | void *TyPtr = Ty.getAsOpaquePtr(); |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 1933 | auto I = TypeCache.find(TyPtr); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1934 | if (I == TypeCache.end() || !cast<llvm::DIType>(I->second)->isForwardDecl()) |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 1935 | return; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 1936 | llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<EnumType>()); |
Duncan P. N. Exon Smith | 4caa7f2 | 2015-04-16 01:00:56 +0000 | [diff] [blame] | 1937 | assert(!Res->isForwardDecl()); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 1938 | TypeCache[TyPtr].reset(Res); |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 1939 | } |
| 1940 | |
David Blaikie | b2e86eb | 2013-08-15 20:49:17 +0000 | [diff] [blame] | 1941 | void CGDebugInfo::completeType(const RecordDecl *RD) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 1942 | if (DebugKind > codegenoptions::LimitedDebugInfo || |
David Blaikie | b2e86eb | 2013-08-15 20:49:17 +0000 | [diff] [blame] | 1943 | !CGM.getLangOpts().CPlusPlus) |
| 1944 | completeRequiredType(RD); |
| 1945 | } |
| 1946 | |
David Blaikie | b11c873 | 2017-01-30 06:36:08 +0000 | [diff] [blame] | 1947 | /// Return true if the class or any of its methods are marked dllimport. |
| 1948 | static bool isClassOrMethodDLLImport(const CXXRecordDecl *RD) { |
| 1949 | if (RD->hasAttr<DLLImportAttr>()) |
| 1950 | return true; |
| 1951 | for (const CXXMethodDecl *MD : RD->methods()) |
| 1952 | if (MD->hasAttr<DLLImportAttr>()) |
| 1953 | return true; |
| 1954 | return false; |
| 1955 | } |
| 1956 | |
Adrian Prantl | a43acdc | 2017-07-24 23:48:51 +0000 | [diff] [blame] | 1957 | /// Does a type definition exist in an imported clang module? |
| 1958 | static bool isDefinedInClangModule(const RecordDecl *RD) { |
| 1959 | // Only definitions that where imported from an AST file come from a module. |
| 1960 | if (!RD || !RD->isFromASTFile()) |
| 1961 | return false; |
| 1962 | // Anonymous entities cannot be addressed. Treat them as not from module. |
| 1963 | if (!RD->isExternallyVisible() && RD->getName().empty()) |
| 1964 | return false; |
| 1965 | if (auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) { |
| 1966 | if (!CXXDecl->isCompleteDefinition()) |
| 1967 | return false; |
Adrian Prantl | ba6fdc5 | 2018-10-24 00:06:02 +0000 | [diff] [blame] | 1968 | // Check wether RD is a template. |
Adrian Prantl | a43acdc | 2017-07-24 23:48:51 +0000 | [diff] [blame] | 1969 | auto TemplateKind = CXXDecl->getTemplateSpecializationKind(); |
| 1970 | if (TemplateKind != TSK_Undeclared) { |
Adrian Prantl | ba6fdc5 | 2018-10-24 00:06:02 +0000 | [diff] [blame] | 1971 | // Unfortunately getOwningModule() isn't accurate enough to find the |
| 1972 | // owning module of a ClassTemplateSpecializationDecl that is inside a |
| 1973 | // namespace spanning multiple modules. |
| 1974 | bool Explicit = false; |
| 1975 | if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(CXXDecl)) |
| 1976 | Explicit = TD->isExplicitInstantiationOrSpecialization(); |
| 1977 | if (!Explicit && CXXDecl->getEnclosingNamespaceContext()) |
| 1978 | return false; |
Adrian Prantl | a43acdc | 2017-07-24 23:48:51 +0000 | [diff] [blame] | 1979 | // This is a template, check the origin of the first member. |
| 1980 | if (CXXDecl->field_begin() == CXXDecl->field_end()) |
| 1981 | return TemplateKind == TSK_ExplicitInstantiationDeclaration; |
| 1982 | if (!CXXDecl->field_begin()->isFromASTFile()) |
| 1983 | return false; |
| 1984 | } |
| 1985 | } |
| 1986 | return true; |
| 1987 | } |
| 1988 | |
David Blaikie | 6943dea | 2013-08-20 01:28:15 +0000 | [diff] [blame] | 1989 | void CGDebugInfo::completeClassData(const RecordDecl *RD) { |
David Blaikie | b11c873 | 2017-01-30 06:36:08 +0000 | [diff] [blame] | 1990 | if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) |
| 1991 | if (CXXRD->isDynamicClass() && |
| 1992 | CGM.getVTableLinkage(CXXRD) == |
| 1993 | llvm::GlobalValue::AvailableExternallyLinkage && |
| 1994 | !isClassOrMethodDLLImport(CXXRD)) |
| 1995 | return; |
Adrian Prantl | a43acdc | 2017-07-24 23:48:51 +0000 | [diff] [blame] | 1996 | |
| 1997 | if (DebugTypeExtRefs && isDefinedInClangModule(RD->getDefinition())) |
| 1998 | return; |
| 1999 | |
David Blaikie | b11c873 | 2017-01-30 06:36:08 +0000 | [diff] [blame] | 2000 | completeClass(RD); |
| 2001 | } |
| 2002 | |
| 2003 | void CGDebugInfo::completeClass(const RecordDecl *RD) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 2004 | if (DebugKind <= codegenoptions::DebugLineTablesOnly) |
Michael Gottesman | 349542b | 2013-08-19 18:46:16 +0000 | [diff] [blame] | 2005 | return; |
David Blaikie | 6943dea | 2013-08-20 01:28:15 +0000 | [diff] [blame] | 2006 | QualType Ty = CGM.getContext().getRecordType(RD); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2007 | void *TyPtr = Ty.getAsOpaquePtr(); |
David Blaikie | ef8a951 | 2014-05-05 23:23:53 +0000 | [diff] [blame] | 2008 | auto I = TypeCache.find(TyPtr); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2009 | if (I != TypeCache.end() && !cast<llvm::DIType>(I->second)->isForwardDecl()) |
David Blaikie | b2e86eb | 2013-08-15 20:49:17 +0000 | [diff] [blame] | 2010 | return; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2011 | llvm::DIType *Res = CreateTypeDefinition(Ty->castAs<RecordType>()); |
Duncan P. N. Exon Smith | 4caa7f2 | 2015-04-16 01:00:56 +0000 | [diff] [blame] | 2012 | assert(!Res->isForwardDecl()); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2013 | TypeCache[TyPtr].reset(Res); |
David Blaikie | b2e86eb | 2013-08-15 20:49:17 +0000 | [diff] [blame] | 2014 | } |
| 2015 | |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2016 | static bool hasExplicitMemberDefinition(CXXRecordDecl::method_iterator I, |
| 2017 | CXXRecordDecl::method_iterator End) { |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 2018 | for (CXXMethodDecl *MD : llvm::make_range(I, End)) |
| 2019 | if (FunctionDecl *Tmpl = MD->getInstantiatedFromMemberFunction()) |
David Blaikie | f7f2185 | 2014-03-04 03:08:14 +0000 | [diff] [blame] | 2020 | if (!Tmpl->isImplicit() && Tmpl->isThisDeclarationADefinition() && |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 2021 | !MD->getMemberSpecializationInfo()->isExplicitSpecialization()) |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2022 | return true; |
| 2023 | return false; |
| 2024 | } |
| 2025 | |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 2026 | static bool shouldOmitDefinition(codegenoptions::DebugInfoKind DebugKind, |
| 2027 | bool DebugTypeExtRefs, const RecordDecl *RD, |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2028 | const LangOptions &LangOpts) { |
Adrian Prantl | 88d7917 | 2016-04-26 21:58:18 +0000 | [diff] [blame] | 2029 | if (DebugTypeExtRefs && isDefinedInClangModule(RD->getDefinition())) |
Adrian Prantl | 43e0081 | 2016-01-19 23:42:53 +0000 | [diff] [blame] | 2030 | return true; |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 2031 | |
David Blaikie | 1ac9c98 | 2017-04-11 21:13:37 +0000 | [diff] [blame] | 2032 | if (auto *ES = RD->getASTContext().getExternalSource()) |
| 2033 | if (ES->hasExternalDefinitions(RD) == ExternalASTSource::EK_Always) |
| 2034 | return true; |
| 2035 | |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 2036 | if (DebugKind > codegenoptions::LimitedDebugInfo) |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2037 | return false; |
| 2038 | |
| 2039 | if (!LangOpts.CPlusPlus) |
| 2040 | return false; |
| 2041 | |
| 2042 | if (!RD->isCompleteDefinitionRequired()) |
| 2043 | return true; |
| 2044 | |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 2045 | const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD); |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2046 | |
| 2047 | if (!CXXDecl) |
| 2048 | return false; |
| 2049 | |
Adrian McCarthy | 9924298 | 2016-08-16 22:11:18 +0000 | [diff] [blame] | 2050 | // Only emit complete debug info for a dynamic class when its vtable is |
| 2051 | // emitted. However, Microsoft debuggers don't resolve type information |
Reid Kleckner | c9404e1 | 2016-09-09 16:27:04 +0000 | [diff] [blame] | 2052 | // across DLL boundaries, so skip this optimization if the class or any of its |
| 2053 | // methods are marked dllimport. This isn't a complete solution, since objects |
| 2054 | // without any dllimport methods can be used in one DLL and constructed in |
| 2055 | // another, but it is the current behavior of LimitedDebugInfo. |
Adrian McCarthy | 9924298 | 2016-08-16 22:11:18 +0000 | [diff] [blame] | 2056 | if (CXXDecl->hasDefinition() && CXXDecl->isDynamicClass() && |
Reid Kleckner | c9404e1 | 2016-09-09 16:27:04 +0000 | [diff] [blame] | 2057 | !isClassOrMethodDLLImport(CXXDecl)) |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2058 | return true; |
| 2059 | |
| 2060 | TemplateSpecializationKind Spec = TSK_Undeclared; |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 2061 | if (const auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD)) |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2062 | Spec = SD->getSpecializationKind(); |
| 2063 | |
| 2064 | if (Spec == TSK_ExplicitInstantiationDeclaration && |
| 2065 | hasExplicitMemberDefinition(CXXDecl->method_begin(), |
| 2066 | CXXDecl->method_end())) |
| 2067 | return true; |
| 2068 | |
| 2069 | return false; |
| 2070 | } |
| 2071 | |
Reid Kleckner | 6c7b1c6 | 2016-09-13 00:01:23 +0000 | [diff] [blame] | 2072 | void CGDebugInfo::completeRequiredType(const RecordDecl *RD) { |
| 2073 | if (shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD, CGM.getLangOpts())) |
| 2074 | return; |
| 2075 | |
| 2076 | QualType Ty = CGM.getContext().getRecordType(RD); |
| 2077 | llvm::DIType *T = getTypeOrNull(Ty); |
| 2078 | if (T && T->isForwardDecl()) |
| 2079 | completeClassData(RD); |
| 2080 | } |
| 2081 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2082 | llvm::DIType *CGDebugInfo::CreateType(const RecordType *Ty) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2083 | RecordDecl *RD = Ty->getDecl(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2084 | llvm::DIType *T = cast_or_null<llvm::DIType>(getTypeOrNull(QualType(Ty, 0))); |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 2085 | if (T || shouldOmitDefinition(DebugKind, DebugTypeExtRefs, RD, |
| 2086 | CGM.getLangOpts())) { |
David Blaikie | 3b1cc9b | 2013-09-06 06:45:04 +0000 | [diff] [blame] | 2087 | if (!T) |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 2088 | T = getOrCreateRecordFwdDecl(Ty, getDeclContextDescriptor(RD)); |
David Blaikie | 3b1cc9b | 2013-09-06 06:45:04 +0000 | [diff] [blame] | 2089 | return T; |
David Blaikie | e36464c | 2013-06-05 05:32:23 +0000 | [diff] [blame] | 2090 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2091 | |
David Blaikie | b2e86eb | 2013-08-15 20:49:17 +0000 | [diff] [blame] | 2092 | return CreateTypeDefinition(Ty); |
| 2093 | } |
| 2094 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2095 | llvm::DIType *CGDebugInfo::CreateTypeDefinition(const RecordType *Ty) { |
David Blaikie | b2e86eb | 2013-08-15 20:49:17 +0000 | [diff] [blame] | 2096 | RecordDecl *RD = Ty->getDecl(); |
| 2097 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2098 | // Get overall information about the record type for the debug info. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2099 | llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2100 | |
| 2101 | // Records and classes and unions can all be recursive. To handle them, we |
| 2102 | // first generate a debug descriptor for the struct as a forward declaration. |
| 2103 | // Then (if it is a definition) we go through and get debug info for all of |
| 2104 | // its members. Finally, we create a descriptor for the complete type (which |
| 2105 | // may refer to the forward decl if the struct is recursive) and replace all |
| 2106 | // uses of the forward declaration with the final definition. |
Duncan P. N. Exon Smith | bd210e6 | 2015-07-24 20:34:41 +0000 | [diff] [blame] | 2107 | llvm::DICompositeType *FwdDecl = getOrCreateLimitedType(Ty, DefUnit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2108 | |
Adrian Prantl | 5f66bae | 2015-02-11 17:45:15 +0000 | [diff] [blame] | 2109 | const RecordDecl *D = RD->getDefinition(); |
| 2110 | if (!D || !D->isCompleteDefinition()) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2111 | return FwdDecl; |
| 2112 | |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 2113 | if (const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD)) |
David Blaikie | adfbf99 | 2013-08-18 16:55:33 +0000 | [diff] [blame] | 2114 | CollectContainingType(CXXDecl, FwdDecl); |
| 2115 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2116 | // Push the struct on region stack. |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2117 | LexicalBlockStack.emplace_back(&*FwdDecl); |
| 2118 | RegionMap[Ty->getDecl()].reset(FwdDecl); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2119 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2120 | // Convert all the elements. |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2121 | SmallVector<llvm::Metadata *, 16> EltTys; |
David Blaikie | 6943dea | 2013-08-20 01:28:15 +0000 | [diff] [blame] | 2122 | // what about nested types? |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2123 | |
| 2124 | // Note: The split of CXXDecl information here is intentional, the |
| 2125 | // gdb tests will depend on a certain ordering at printout. The debug |
| 2126 | // information offsets are still correct if we merge them all together |
| 2127 | // though. |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 2128 | const auto *CXXDecl = dyn_cast<CXXRecordDecl>(RD); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2129 | if (CXXDecl) { |
| 2130 | CollectCXXBases(CXXDecl, DefUnit, EltTys, FwdDecl); |
Reid Kleckner | dc12499 | 2016-08-31 16:11:43 +0000 | [diff] [blame] | 2131 | CollectVTableInfo(CXXDecl, DefUnit, EltTys, FwdDecl); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2132 | } |
| 2133 | |
Eric Christopher | 91a3190 | 2013-01-16 01:22:32 +0000 | [diff] [blame] | 2134 | // Collect data fields (including static variables and any initializers). |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2135 | CollectRecordFields(RD, DefUnit, EltTys, FwdDecl); |
Eric Christopher | 2df080e | 2013-10-11 18:16:51 +0000 | [diff] [blame] | 2136 | if (CXXDecl) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2137 | CollectCXXMemberFunctions(CXXDecl, DefUnit, EltTys, FwdDecl); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2138 | |
| 2139 | LexicalBlockStack.pop_back(); |
| 2140 | RegionMap.erase(Ty->getDecl()); |
| 2141 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2142 | llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys); |
Duncan P. N. Exon Smith | c8ee63e | 2014-12-18 00:48:56 +0000 | [diff] [blame] | 2143 | DBuilder.replaceArrays(FwdDecl, Elements); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2144 | |
Adrian Prantl | 5f66bae | 2015-02-11 17:45:15 +0000 | [diff] [blame] | 2145 | if (FwdDecl->isTemporary()) |
Duncan P. N. Exon Smith | 4078ad4 | 2015-04-16 16:36:45 +0000 | [diff] [blame] | 2146 | FwdDecl = |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2147 | llvm::MDNode::replaceWithPermanent(llvm::TempDICompositeType(FwdDecl)); |
Adrian Prantl | 5f66bae | 2015-02-11 17:45:15 +0000 | [diff] [blame] | 2148 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2149 | RegionMap[Ty->getDecl()].reset(FwdDecl); |
Eric Christopher | 5c7ee8b | 2013-04-02 22:59:11 +0000 | [diff] [blame] | 2150 | return FwdDecl; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2151 | } |
| 2152 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2153 | llvm::DIType *CGDebugInfo::CreateType(const ObjCObjectType *Ty, |
| 2154 | llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2155 | // Ignore protocols. |
| 2156 | return getOrCreateType(Ty->getBaseType(), Unit); |
| 2157 | } |
| 2158 | |
Manman Ren | e6be26c | 2016-09-13 17:25:08 +0000 | [diff] [blame] | 2159 | llvm::DIType *CGDebugInfo::CreateType(const ObjCTypeParamType *Ty, |
| 2160 | llvm::DIFile *Unit) { |
| 2161 | // Ignore protocols. |
| 2162 | SourceLocation Loc = Ty->getDecl()->getLocation(); |
| 2163 | |
| 2164 | // Use Typedefs to represent ObjCTypeParamType. |
| 2165 | return DBuilder.createTypedef( |
| 2166 | getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit), |
| 2167 | Ty->getDecl()->getName(), getOrCreateFile(Loc), getLineNumber(Loc), |
| 2168 | getDeclContextDescriptor(Ty->getDecl())); |
| 2169 | } |
| 2170 | |
Adrian Prantl | b8fad1a | 2013-06-07 01:10:45 +0000 | [diff] [blame] | 2171 | /// \return true if Getter has the default name for the property PD. |
| 2172 | static bool hasDefaultGetterName(const ObjCPropertyDecl *PD, |
| 2173 | const ObjCMethodDecl *Getter) { |
| 2174 | assert(PD); |
| 2175 | if (!Getter) |
| 2176 | return true; |
| 2177 | |
| 2178 | assert(Getter->getDeclName().isObjCZeroArgSelector()); |
| 2179 | return PD->getName() == |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2180 | Getter->getDeclName().getObjCSelector().getNameForSlot(0); |
Adrian Prantl | b8fad1a | 2013-06-07 01:10:45 +0000 | [diff] [blame] | 2181 | } |
| 2182 | |
| 2183 | /// \return true if Setter has the default name for the property PD. |
| 2184 | static bool hasDefaultSetterName(const ObjCPropertyDecl *PD, |
| 2185 | const ObjCMethodDecl *Setter) { |
| 2186 | assert(PD); |
| 2187 | if (!Setter) |
| 2188 | return true; |
| 2189 | |
| 2190 | assert(Setter->getDeclName().isObjCOneArgSelector()); |
Adrian Prantl | a4ce906 | 2013-06-07 22:29:12 +0000 | [diff] [blame] | 2191 | return SelectorTable::constructSetterName(PD->getName()) == |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2192 | Setter->getDeclName().getObjCSelector().getNameForSlot(0); |
Adrian Prantl | b8fad1a | 2013-06-07 01:10:45 +0000 | [diff] [blame] | 2193 | } |
| 2194 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2195 | llvm::DIType *CGDebugInfo::CreateType(const ObjCInterfaceType *Ty, |
| 2196 | llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2197 | ObjCInterfaceDecl *ID = Ty->getDecl(); |
| 2198 | if (!ID) |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 2199 | return nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2200 | |
Adrian Prantl | 50fd1a8 | 2016-04-20 23:59:32 +0000 | [diff] [blame] | 2201 | // Return a forward declaration if this type was imported from a clang module, |
| 2202 | // and this is not the compile unit with the implementation of the type (which |
| 2203 | // may contain hidden ivars). |
| 2204 | if (DebugTypeExtRefs && ID->isFromASTFile() && ID->getDefinition() && |
| 2205 | !ID->getImplementation()) |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 2206 | return DBuilder.createForwardDecl(llvm::dwarf::DW_TAG_structure_type, |
| 2207 | ID->getName(), |
| 2208 | getDeclContextDescriptor(ID), Unit, 0); |
| 2209 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2210 | // Get overall information about the record type for the debug info. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2211 | llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2212 | unsigned Line = getLineNumber(ID->getLocation()); |
Duncan P. N. Exon Smith | 798d565 | 2015-04-15 23:19:15 +0000 | [diff] [blame] | 2213 | auto RuntimeLang = |
| 2214 | static_cast<llvm::dwarf::SourceLanguage>(TheCU->getSourceLanguage()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2215 | |
| 2216 | // If this is just a forward declaration return a special forward-declaration |
| 2217 | // debug type since we won't be able to lay out the entire type. |
| 2218 | ObjCInterfaceDecl *Def = ID->getDefinition(); |
David Blaikie | ef8a951 | 2014-05-05 23:23:53 +0000 | [diff] [blame] | 2219 | if (!Def || !Def->getImplementation()) { |
Adrian Prantl | 42ce2d3 | 2015-10-01 16:57:02 +0000 | [diff] [blame] | 2220 | llvm::DIScope *Mod = getParentModuleOrNull(ID); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2221 | llvm::DIType *FwdDecl = DBuilder.createReplaceableCompositeType( |
Adrian Prantl | 42ce2d3 | 2015-10-01 16:57:02 +0000 | [diff] [blame] | 2222 | llvm::dwarf::DW_TAG_structure_type, ID->getName(), Mod ? Mod : TheCU, |
| 2223 | DefUnit, Line, RuntimeLang); |
David Blaikie | ef8a951 | 2014-05-05 23:23:53 +0000 | [diff] [blame] | 2224 | ObjCInterfaceCache.push_back(ObjCInterfaceCacheEntry(Ty, FwdDecl, Unit)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2225 | return FwdDecl; |
| 2226 | } |
| 2227 | |
David Blaikie | ef8a951 | 2014-05-05 23:23:53 +0000 | [diff] [blame] | 2228 | return CreateTypeDefinition(Ty, Unit); |
| 2229 | } |
| 2230 | |
Adrian Prantl | c4bb47e | 2015-06-30 17:39:51 +0000 | [diff] [blame] | 2231 | llvm::DIModule * |
Adrian Prantl | 6668920 | 2015-09-18 23:01:45 +0000 | [diff] [blame] | 2232 | CGDebugInfo::getOrCreateModuleRef(ExternalASTSource::ASTSourceDescriptor Mod, |
| 2233 | bool CreateSkeletonCU) { |
Adrian Prantl | eb66a26 | 2015-09-24 16:10:04 +0000 | [diff] [blame] | 2234 | // Use the Module pointer as the key into the cache. This is a |
| 2235 | // nullptr if the "Module" is a PCH, which is safe because we don't |
| 2236 | // support chained PCH debug info, so there can only be a single PCH. |
| 2237 | const Module *M = Mod.getModuleOrNull(); |
Adrian Prantl | 9e8ea35 | 2015-09-29 20:44:46 +0000 | [diff] [blame] | 2238 | auto ModRef = ModuleCache.find(M); |
| 2239 | if (ModRef != ModuleCache.end()) |
| 2240 | return cast<llvm::DIModule>(ModRef->second); |
Adrian Prantl | 2388ead | 2015-06-30 18:01:05 +0000 | [diff] [blame] | 2241 | |
| 2242 | // Macro definitions that were defined with "-D" on the command line. |
| 2243 | SmallString<128> ConfigMacros; |
| 2244 | { |
| 2245 | llvm::raw_svector_ostream OS(ConfigMacros); |
| 2246 | const auto &PPOpts = CGM.getPreprocessorOpts(); |
| 2247 | unsigned I = 0; |
Alexander Kornienko | 2a8c18d | 2018-04-06 15:14:32 +0000 | [diff] [blame] | 2248 | // Translate the macro definitions back into a command line. |
Adrian Prantl | 2388ead | 2015-06-30 18:01:05 +0000 | [diff] [blame] | 2249 | for (auto &M : PPOpts.Macros) { |
| 2250 | if (++I > 1) |
| 2251 | OS << " "; |
| 2252 | const std::string &Macro = M.first; |
| 2253 | bool Undef = M.second; |
| 2254 | OS << "\"-" << (Undef ? 'U' : 'D'); |
| 2255 | for (char c : Macro) |
| 2256 | switch (c) { |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 2257 | case '\\': |
| 2258 | OS << "\\\\"; |
| 2259 | break; |
| 2260 | case '"': |
| 2261 | OS << "\\\""; |
| 2262 | break; |
| 2263 | default: |
| 2264 | OS << c; |
Adrian Prantl | 2388ead | 2015-06-30 18:01:05 +0000 | [diff] [blame] | 2265 | } |
| 2266 | OS << '\"'; |
Adrian Prantl | c4bb47e | 2015-06-30 17:39:51 +0000 | [diff] [blame] | 2267 | } |
Adrian Prantl | c4bb47e | 2015-06-30 17:39:51 +0000 | [diff] [blame] | 2268 | } |
Adrian Prantl | 6668920 | 2015-09-18 23:01:45 +0000 | [diff] [blame] | 2269 | |
Adrian Prantl | 835e663 | 2015-09-24 16:10:10 +0000 | [diff] [blame] | 2270 | bool IsRootModule = M ? !M->Parent : true; |
| 2271 | if (CreateSkeletonCU && IsRootModule) { |
Adrian Prantl | c96da8f | 2016-01-22 17:43:43 +0000 | [diff] [blame] | 2272 | // PCH files don't have a signature field in the control block, |
| 2273 | // but LLVM detects skeleton CUs by looking for a non-zero DWO id. |
Duncan P. N. Exon Smith | 60fa288 | 2017-03-13 18:45:08 +0000 | [diff] [blame] | 2274 | // We use the lower 64 bits for debug info. |
| 2275 | uint64_t Signature = |
| 2276 | Mod.getSignature() |
| 2277 | ? (uint64_t)Mod.getSignature()[1] << 32 | Mod.getSignature()[0] |
| 2278 | : ~1ULL; |
Adrian Prantl | 6668920 | 2015-09-18 23:01:45 +0000 | [diff] [blame] | 2279 | llvm::DIBuilder DIB(CGM.getModule()); |
Amjad Aboud | fa9a17e | 2016-12-14 20:24:40 +0000 | [diff] [blame] | 2280 | DIB.createCompileUnit(TheCU->getSourceLanguage(), |
Scott Linder | a2fbcef | 2018-02-26 17:32:31 +0000 | [diff] [blame] | 2281 | // TODO: Support "Source" from external AST providers? |
Amjad Aboud | fa9a17e | 2016-12-14 20:24:40 +0000 | [diff] [blame] | 2282 | DIB.createFile(Mod.getModuleName(), Mod.getPath()), |
| 2283 | TheCU->getProducer(), true, StringRef(), 0, |
| 2284 | Mod.getASTFile(), llvm::DICompileUnit::FullDebug, |
| 2285 | Signature); |
Adrian Prantl | 6668920 | 2015-09-18 23:01:45 +0000 | [diff] [blame] | 2286 | DIB.finalize(); |
Adrian Prantl | 2f957ac | 2015-09-19 00:59:22 +0000 | [diff] [blame] | 2287 | } |
Adrian Prantl | 835e663 | 2015-09-24 16:10:10 +0000 | [diff] [blame] | 2288 | llvm::DIModule *Parent = |
| 2289 | IsRootModule ? nullptr |
| 2290 | : getOrCreateModuleRef( |
| 2291 | ExternalASTSource::ASTSourceDescriptor(*M->Parent), |
| 2292 | CreateSkeletonCU); |
Adrian Prantl | eb66a26 | 2015-09-24 16:10:04 +0000 | [diff] [blame] | 2293 | llvm::DIModule *DIMod = |
Adrian Prantl | 835e663 | 2015-09-24 16:10:10 +0000 | [diff] [blame] | 2294 | DBuilder.createModule(Parent, Mod.getModuleName(), ConfigMacros, |
| 2295 | Mod.getPath(), CGM.getHeaderSearchOpts().Sysroot); |
Adrian Prantl | 9e8ea35 | 2015-09-29 20:44:46 +0000 | [diff] [blame] | 2296 | ModuleCache[M].reset(DIMod); |
Adrian Prantl | eb66a26 | 2015-09-24 16:10:04 +0000 | [diff] [blame] | 2297 | return DIMod; |
Adrian Prantl | c4bb47e | 2015-06-30 17:39:51 +0000 | [diff] [blame] | 2298 | } |
| 2299 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2300 | llvm::DIType *CGDebugInfo::CreateTypeDefinition(const ObjCInterfaceType *Ty, |
| 2301 | llvm::DIFile *Unit) { |
David Blaikie | ef8a951 | 2014-05-05 23:23:53 +0000 | [diff] [blame] | 2302 | ObjCInterfaceDecl *ID = Ty->getDecl(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2303 | llvm::DIFile *DefUnit = getOrCreateFile(ID->getLocation()); |
David Blaikie | ef8a951 | 2014-05-05 23:23:53 +0000 | [diff] [blame] | 2304 | unsigned Line = getLineNumber(ID->getLocation()); |
Duncan P. N. Exon Smith | 798d565 | 2015-04-15 23:19:15 +0000 | [diff] [blame] | 2305 | unsigned RuntimeLang = TheCU->getSourceLanguage(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2306 | |
| 2307 | // Bit size, align and offset of the type. |
| 2308 | uint64_t Size = CGM.getContext().getTypeSize(Ty); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 2309 | auto Align = getTypeAlignIfRequired(Ty, CGM.getContext()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2310 | |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 2311 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2312 | if (ID->getImplementation()) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2313 | Flags |= llvm::DINode::FlagObjcClassComplete; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2314 | |
Adrian Prantl | fd69611 | 2015-10-01 00:48:51 +0000 | [diff] [blame] | 2315 | llvm::DIScope *Mod = getParentModuleOrNull(ID); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2316 | llvm::DICompositeType *RealDecl = DBuilder.createStructType( |
Adrian Prantl | fd69611 | 2015-10-01 00:48:51 +0000 | [diff] [blame] | 2317 | Mod ? Mod : Unit, ID->getName(), DefUnit, Line, Size, Align, Flags, |
| 2318 | nullptr, llvm::DINodeArray(), RuntimeLang); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2319 | |
David Blaikie | ef8a951 | 2014-05-05 23:23:53 +0000 | [diff] [blame] | 2320 | QualType QTy(Ty, 0); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2321 | TypeCache[QTy.getAsOpaquePtr()].reset(RealDecl); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2322 | |
Eric Christopher | 35f1f9f | 2013-07-14 21:00:07 +0000 | [diff] [blame] | 2323 | // Push the struct on region stack. |
Duncan P. N. Exon Smith | 4078ad4 | 2015-04-16 16:36:45 +0000 | [diff] [blame] | 2324 | LexicalBlockStack.emplace_back(RealDecl); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2325 | RegionMap[Ty->getDecl()].reset(RealDecl); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2326 | |
| 2327 | // Convert all the elements. |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2328 | SmallVector<llvm::Metadata *, 16> EltTys; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2329 | |
| 2330 | ObjCInterfaceDecl *SClass = ID->getSuperClass(); |
| 2331 | if (SClass) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2332 | llvm::DIType *SClassTy = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2333 | getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit); |
Duncan P. N. Exon Smith | b747023 | 2015-04-15 23:48:50 +0000 | [diff] [blame] | 2334 | if (!SClassTy) |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 2335 | return nullptr; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 2336 | |
Brock Wyma | 3db2b10 | 2018-05-14 21:21:22 +0000 | [diff] [blame] | 2337 | llvm::DIType *InhTag = DBuilder.createInheritance(RealDecl, SClassTy, 0, 0, |
Leny Kholodov | df050fd | 2016-09-06 17:06:14 +0000 | [diff] [blame] | 2338 | llvm::DINode::FlagZero); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2339 | EltTys.push_back(InhTag); |
| 2340 | } |
| 2341 | |
Eric Christopher | 35f1f9f | 2013-07-14 21:00:07 +0000 | [diff] [blame] | 2342 | // Create entries for all of the properties. |
Nico Weber | 7123bca | 2015-12-04 19:14:14 +0000 | [diff] [blame] | 2343 | auto AddProperty = [&](const ObjCPropertyDecl *PD) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2344 | SourceLocation Loc = PD->getLocation(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2345 | llvm::DIFile *PUnit = getOrCreateFile(Loc); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2346 | unsigned PLine = getLineNumber(Loc); |
| 2347 | ObjCMethodDecl *Getter = PD->getGetterMethodDecl(); |
| 2348 | ObjCMethodDecl *Setter = PD->getSetterMethodDecl(); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2349 | llvm::MDNode *PropertyNode = DBuilder.createObjCProperty( |
| 2350 | PD->getName(), PUnit, PLine, |
| 2351 | hasDefaultGetterName(PD, Getter) ? "" |
| 2352 | : getSelectorName(PD->getGetterName()), |
| 2353 | hasDefaultSetterName(PD, Setter) ? "" |
| 2354 | : getSelectorName(PD->getSetterName()), |
| 2355 | PD->getPropertyAttributes(), getOrCreateType(PD->getType(), PUnit)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2356 | EltTys.push_back(PropertyNode); |
Nico Weber | 7123bca | 2015-12-04 19:14:14 +0000 | [diff] [blame] | 2357 | }; |
| 2358 | { |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 2359 | llvm::SmallPtrSet<const IdentifierInfo *, 16> PropertySet; |
Nico Weber | de059e1 | 2015-12-04 19:35:45 +0000 | [diff] [blame] | 2360 | for (const ObjCCategoryDecl *ClassExt : ID->known_extensions()) |
Manman Ren | efe1bac | 2016-01-27 20:00:32 +0000 | [diff] [blame] | 2361 | for (auto *PD : ClassExt->properties()) { |
Nico Weber | de059e1 | 2015-12-04 19:35:45 +0000 | [diff] [blame] | 2362 | PropertySet.insert(PD->getIdentifier()); |
| 2363 | AddProperty(PD); |
| 2364 | } |
Manman Ren | efe1bac | 2016-01-27 20:00:32 +0000 | [diff] [blame] | 2365 | for (const auto *PD : ID->properties()) { |
Nico Weber | 7123bca | 2015-12-04 19:14:14 +0000 | [diff] [blame] | 2366 | // Don't emit duplicate metadata for properties that were already in a |
| 2367 | // class extension. |
| 2368 | if (!PropertySet.insert(PD->getIdentifier()).second) |
| 2369 | continue; |
| 2370 | AddProperty(PD); |
| 2371 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2372 | } |
| 2373 | |
| 2374 | const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID); |
| 2375 | unsigned FieldNo = 0; |
| 2376 | for (ObjCIvarDecl *Field = ID->all_declared_ivar_begin(); Field; |
| 2377 | Field = Field->getNextIvar(), ++FieldNo) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2378 | llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit); |
Duncan P. N. Exon Smith | b747023 | 2015-04-15 23:48:50 +0000 | [diff] [blame] | 2379 | if (!FieldTy) |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 2380 | return nullptr; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 2381 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2382 | StringRef FieldName = Field->getName(); |
| 2383 | |
| 2384 | // Ignore unnamed fields. |
| 2385 | if (FieldName.empty()) |
| 2386 | continue; |
| 2387 | |
| 2388 | // Get the location for the field. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2389 | llvm::DIFile *FieldDefUnit = getOrCreateFile(Field->getLocation()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2390 | unsigned FieldLine = getLineNumber(Field->getLocation()); |
| 2391 | QualType FType = Field->getType(); |
| 2392 | uint64_t FieldSize = 0; |
Victor Leschuk | 802e4a5 | 2016-10-19 22:11:07 +0000 | [diff] [blame] | 2393 | uint32_t FieldAlign = 0; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2394 | |
| 2395 | if (!FType->isIncompleteArrayType()) { |
| 2396 | |
| 2397 | // Bit size, align and offset of the type. |
| 2398 | FieldSize = Field->isBitField() |
Eric Christopher | 35f1f9f | 2013-07-14 21:00:07 +0000 | [diff] [blame] | 2399 | ? Field->getBitWidthValue(CGM.getContext()) |
| 2400 | : CGM.getContext().getTypeSize(FType); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 2401 | FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2402 | } |
| 2403 | |
| 2404 | uint64_t FieldOffset; |
| 2405 | if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) { |
| 2406 | // We don't know the runtime offset of an ivar if we're using the |
| 2407 | // non-fragile ABI. For bitfields, use the bit offset into the first |
| 2408 | // byte of storage of the bitfield. For other fields, use zero. |
| 2409 | if (Field->isBitField()) { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2410 | FieldOffset = |
| 2411 | CGM.getObjCRuntime().ComputeBitfieldBitOffset(CGM, ID, Field); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2412 | FieldOffset %= CGM.getContext().getCharWidth(); |
| 2413 | } else { |
| 2414 | FieldOffset = 0; |
| 2415 | } |
| 2416 | } else { |
| 2417 | FieldOffset = RL.getFieldOffset(FieldNo); |
| 2418 | } |
| 2419 | |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 2420 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2421 | if (Field->getAccessControl() == ObjCIvarDecl::Protected) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2422 | Flags = llvm::DINode::FlagProtected; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2423 | else if (Field->getAccessControl() == ObjCIvarDecl::Private) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2424 | Flags = llvm::DINode::FlagPrivate; |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 2425 | else if (Field->getAccessControl() == ObjCIvarDecl::Public) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2426 | Flags = llvm::DINode::FlagPublic; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2427 | |
Craig Topper | 8a13c41 | 2014-05-21 05:09:00 +0000 | [diff] [blame] | 2428 | llvm::MDNode *PropertyNode = nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2429 | if (ObjCImplementationDecl *ImpD = ID->getImplementation()) { |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 2430 | if (ObjCPropertyImplDecl *PImpD = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2431 | ImpD->FindPropertyImplIvarDecl(Field->getIdentifier())) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2432 | if (ObjCPropertyDecl *PD = PImpD->getPropertyDecl()) { |
Eric Christopher | c0c5d46 | 2013-02-21 22:35:08 +0000 | [diff] [blame] | 2433 | SourceLocation Loc = PD->getLocation(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2434 | llvm::DIFile *PUnit = getOrCreateFile(Loc); |
Eric Christopher | c0c5d46 | 2013-02-21 22:35:08 +0000 | [diff] [blame] | 2435 | unsigned PLine = getLineNumber(Loc); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2436 | ObjCMethodDecl *Getter = PD->getGetterMethodDecl(); |
| 2437 | ObjCMethodDecl *Setter = PD->getSetterMethodDecl(); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2438 | PropertyNode = DBuilder.createObjCProperty( |
| 2439 | PD->getName(), PUnit, PLine, |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 2440 | hasDefaultGetterName(PD, Getter) |
| 2441 | ? "" |
| 2442 | : getSelectorName(PD->getGetterName()), |
| 2443 | hasDefaultSetterName(PD, Setter) |
| 2444 | ? "" |
| 2445 | : getSelectorName(PD->getSetterName()), |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2446 | PD->getPropertyAttributes(), |
| 2447 | getOrCreateType(PD->getType(), PUnit)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2448 | } |
| 2449 | } |
| 2450 | } |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2451 | FieldTy = DBuilder.createObjCIVar(FieldName, FieldDefUnit, FieldLine, |
| 2452 | FieldSize, FieldAlign, FieldOffset, Flags, |
| 2453 | FieldTy, PropertyNode); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2454 | EltTys.push_back(FieldTy); |
| 2455 | } |
| 2456 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2457 | llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys); |
Duncan P. N. Exon Smith | c8ee63e | 2014-12-18 00:48:56 +0000 | [diff] [blame] | 2458 | DBuilder.replaceArrays(RealDecl, Elements); |
Adrian Prantl | a03a85a | 2013-03-06 22:03:30 +0000 | [diff] [blame] | 2459 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2460 | LexicalBlockStack.pop_back(); |
Eric Christopher | 5c7ee8b | 2013-04-02 22:59:11 +0000 | [diff] [blame] | 2461 | return RealDecl; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2462 | } |
| 2463 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2464 | llvm::DIType *CGDebugInfo::CreateType(const VectorType *Ty, |
| 2465 | llvm::DIFile *Unit) { |
| 2466 | llvm::DIType *ElementTy = getOrCreateType(Ty->getElementType(), Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2467 | int64_t Count = Ty->getNumElements(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2468 | |
Sander de Smalen | 891af03a | 2018-02-03 13:55:59 +0000 | [diff] [blame] | 2469 | llvm::Metadata *Subscript; |
| 2470 | QualType QTy(Ty, 0); |
| 2471 | auto SizeExpr = SizeExprCache.find(QTy); |
| 2472 | if (SizeExpr != SizeExprCache.end()) |
| 2473 | Subscript = DBuilder.getOrCreateSubrange(0, SizeExpr->getSecond()); |
| 2474 | else |
| 2475 | Subscript = DBuilder.getOrCreateSubrange(0, Count ? Count : -1); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2476 | llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2477 | |
| 2478 | uint64_t Size = CGM.getContext().getTypeSize(Ty); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 2479 | auto Align = getTypeAlignIfRequired(Ty, CGM.getContext()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2480 | |
| 2481 | return DBuilder.createVectorType(Size, Align, ElementTy, SubscriptArray); |
| 2482 | } |
| 2483 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2484 | llvm::DIType *CGDebugInfo::CreateType(const ArrayType *Ty, llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2485 | uint64_t Size; |
Victor Leschuk | 802e4a5 | 2016-10-19 22:11:07 +0000 | [diff] [blame] | 2486 | uint32_t Align; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2487 | |
| 2488 | // FIXME: make getTypeAlign() aware of VLAs and incomplete array types |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 2489 | if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2490 | Size = 0; |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 2491 | Align = getTypeAlignIfRequired(CGM.getContext().getBaseElementType(VAT), |
| 2492 | CGM.getContext()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2493 | } else if (Ty->isIncompleteArrayType()) { |
| 2494 | Size = 0; |
| 2495 | if (Ty->getElementType()->isIncompleteType()) |
| 2496 | Align = 0; |
| 2497 | else |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 2498 | Align = getTypeAlignIfRequired(Ty->getElementType(), CGM.getContext()); |
David Blaikie | f03b2e8 | 2013-05-09 20:48:12 +0000 | [diff] [blame] | 2499 | } else if (Ty->isIncompleteType()) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2500 | Size = 0; |
| 2501 | Align = 0; |
| 2502 | } else { |
| 2503 | // Size and align of the whole array, not the element type. |
| 2504 | Size = CGM.getContext().getTypeSize(Ty); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 2505 | Align = getTypeAlignIfRequired(Ty, CGM.getContext()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2506 | } |
| 2507 | |
| 2508 | // Add the dimensions of the array. FIXME: This loses CV qualifiers from |
| 2509 | // interior arrays, do we care? Why aren't nested arrays represented the |
| 2510 | // obvious/recursive way? |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2511 | SmallVector<llvm::Metadata *, 8> Subscripts; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2512 | QualType EltTy(Ty, 0); |
| 2513 | while ((Ty = dyn_cast<ArrayType>(EltTy))) { |
| 2514 | // If the number of elements is known, then count is that number. Otherwise, |
| 2515 | // it's -1. This allows us to represent a subrange with an array of 0 |
| 2516 | // elements, like this: |
| 2517 | // |
| 2518 | // struct foo { |
| 2519 | // int x[0]; |
| 2520 | // }; |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2521 | int64_t Count = -1; // Count == -1 is an unbounded array. |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 2522 | if (const auto *CAT = dyn_cast<ConstantArrayType>(Ty)) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2523 | Count = CAT->getSize().getZExtValue(); |
David Blaikie | 87173f1 | 2016-08-22 17:49:56 +0000 | [diff] [blame] | 2524 | else if (const auto *VAT = dyn_cast<VariableArrayType>(Ty)) { |
Eli Friedman | 01d6b96 | 2016-10-19 22:16:32 +0000 | [diff] [blame] | 2525 | if (Expr *Size = VAT->getSizeExpr()) { |
Fangrui Song | 407659a | 2018-11-30 23:41:18 +0000 | [diff] [blame^] | 2526 | Expr::EvalResult Result; |
| 2527 | if (Size->EvaluateAsInt(Result, CGM.getContext())) |
| 2528 | Count = Result.Val.getInt().getExtValue(); |
Eli Friedman | 01d6b96 | 2016-10-19 22:16:32 +0000 | [diff] [blame] | 2529 | } |
David Blaikie | 87173f1 | 2016-08-22 17:49:56 +0000 | [diff] [blame] | 2530 | } |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 2531 | |
Sander de Smalen | 891af03a | 2018-02-03 13:55:59 +0000 | [diff] [blame] | 2532 | auto SizeNode = SizeExprCache.find(EltTy); |
| 2533 | if (SizeNode != SizeExprCache.end()) |
| 2534 | Subscripts.push_back( |
| 2535 | DBuilder.getOrCreateSubrange(0, SizeNode->getSecond())); |
| 2536 | else |
| 2537 | Subscripts.push_back(DBuilder.getOrCreateSubrange(0, Count)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2538 | EltTy = Ty->getElementType(); |
| 2539 | } |
| 2540 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2541 | llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscripts); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2542 | |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 2543 | return DBuilder.createArrayType(Size, Align, getOrCreateType(EltTy, Unit), |
| 2544 | SubscriptArray); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2545 | } |
| 2546 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2547 | llvm::DIType *CGDebugInfo::CreateType(const LValueReferenceType *Ty, |
| 2548 | llvm::DIFile *Unit) { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2549 | return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type, Ty, |
| 2550 | Ty->getPointeeType(), Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2551 | } |
| 2552 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2553 | llvm::DIType *CGDebugInfo::CreateType(const RValueReferenceType *Ty, |
| 2554 | llvm::DIFile *Unit) { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2555 | return CreatePointerLikeType(llvm::dwarf::DW_TAG_rvalue_reference_type, Ty, |
| 2556 | Ty->getPointeeType(), Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2557 | } |
| 2558 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2559 | llvm::DIType *CGDebugInfo::CreateType(const MemberPointerType *Ty, |
| 2560 | llvm::DIFile *U) { |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 2561 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero; |
Reid Kleckner | fb72718 | 2016-06-17 22:27:59 +0000 | [diff] [blame] | 2562 | uint64_t Size = 0; |
| 2563 | |
| 2564 | if (!Ty->isIncompleteType()) { |
| 2565 | Size = CGM.getContext().getTypeSize(Ty); |
| 2566 | |
| 2567 | // Set the MS inheritance model. There is no flag for the unspecified model. |
| 2568 | if (CGM.getTarget().getCXXABI().isMicrosoft()) { |
| 2569 | switch (Ty->getMostRecentCXXRecordDecl()->getMSInheritanceModel()) { |
| 2570 | case MSInheritanceAttr::Keyword_single_inheritance: |
| 2571 | Flags |= llvm::DINode::FlagSingleInheritance; |
| 2572 | break; |
| 2573 | case MSInheritanceAttr::Keyword_multiple_inheritance: |
| 2574 | Flags |= llvm::DINode::FlagMultipleInheritance; |
| 2575 | break; |
| 2576 | case MSInheritanceAttr::Keyword_virtual_inheritance: |
| 2577 | Flags |= llvm::DINode::FlagVirtualInheritance; |
| 2578 | break; |
| 2579 | case MSInheritanceAttr::Keyword_unspecified_inheritance: |
| 2580 | break; |
| 2581 | } |
| 2582 | } |
| 2583 | } |
| 2584 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2585 | llvm::DIType *ClassType = getOrCreateType(QualType(Ty->getClass(), 0), U); |
David Majnemer | 5fd33e0 | 2015-04-24 01:25:08 +0000 | [diff] [blame] | 2586 | if (Ty->isMemberDataPointerType()) |
David Blaikie | 2c705ca | 2013-01-19 19:20:56 +0000 | [diff] [blame] | 2587 | return DBuilder.createMemberPointerType( |
Reid Kleckner | fb72718 | 2016-06-17 22:27:59 +0000 | [diff] [blame] | 2588 | getOrCreateType(Ty->getPointeeType(), U), ClassType, Size, /*Align=*/0, |
| 2589 | Flags); |
Adrian Prantl | 0866acd | 2013-12-19 01:38:47 +0000 | [diff] [blame] | 2590 | |
| 2591 | const FunctionProtoType *FPT = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2592 | Ty->getPointeeType()->getAs<FunctionProtoType>(); |
| 2593 | return DBuilder.createMemberPointerType( |
| 2594 | getOrCreateInstanceMethodType(CGM.getContext().getPointerType(QualType( |
| 2595 | Ty->getClass(), FPT->getTypeQuals())), |
| 2596 | FPT, U), |
Reid Kleckner | fb72718 | 2016-06-17 22:27:59 +0000 | [diff] [blame] | 2597 | ClassType, Size, /*Align=*/0, Flags); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2598 | } |
| 2599 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2600 | llvm::DIType *CGDebugInfo::CreateType(const AtomicType *Ty, llvm::DIFile *U) { |
Victor Leschuk | 0df19037 | 2016-10-31 19:09:47 +0000 | [diff] [blame] | 2601 | auto *FromTy = getOrCreateType(Ty->getValueType(), U); |
| 2602 | return DBuilder.createQualifiedType(llvm::dwarf::DW_TAG_atomic_type, FromTy); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2603 | } |
| 2604 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 2605 | llvm::DIType *CGDebugInfo::CreateType(const PipeType *Ty, llvm::DIFile *U) { |
Xiuli Pan | 9c14e28 | 2016-01-09 12:53:17 +0000 | [diff] [blame] | 2606 | return getOrCreateType(Ty->getElementType(), U); |
| 2607 | } |
| 2608 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2609 | llvm::DIType *CGDebugInfo::CreateEnumType(const EnumType *Ty) { |
Manman Ren | 1b45702 | 2013-08-28 21:20:28 +0000 | [diff] [blame] | 2610 | const EnumDecl *ED = Ty->getDecl(); |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 2611 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2612 | uint64_t Size = 0; |
Victor Leschuk | 802e4a5 | 2016-10-19 22:11:07 +0000 | [diff] [blame] | 2613 | uint32_t Align = 0; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2614 | if (!ED->getTypeForDecl()->isIncompleteType()) { |
| 2615 | Size = CGM.getContext().getTypeSize(ED->getTypeForDecl()); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 2616 | Align = getDeclAlignIfRequired(ED, CGM.getContext()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2617 | } |
| 2618 | |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 2619 | SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU); |
Manman Ren | e0064d8 | 2013-08-29 23:19:58 +0000 | [diff] [blame] | 2620 | |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 2621 | bool isImportedFromModule = |
| 2622 | DebugTypeExtRefs && ED->isFromASTFile() && ED->getDefinition(); |
| 2623 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2624 | // If this is just a forward declaration, construct an appropriately |
| 2625 | // marked node and just return it. |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 2626 | if (isImportedFromModule || !ED->getDefinition()) { |
Adrian Prantl | 4594606 | 2016-02-23 19:30:08 +0000 | [diff] [blame] | 2627 | // Note that it is possible for enums to be created as part of |
| 2628 | // their own declcontext. In this case a FwdDecl will be created |
| 2629 | // twice. This doesn't cause a problem because both FwdDecls are |
| 2630 | // entered into the ReplaceMap: finalize() will replace the first |
| 2631 | // FwdDecl with the second and then replace the second with |
| 2632 | // complete type. |
Amjad Aboud | dc4531e | 2016-04-30 01:44:38 +0000 | [diff] [blame] | 2633 | llvm::DIScope *EDContext = getDeclContextDescriptor(ED); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2634 | llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation()); |
Adrian Prantl | ff9d83c | 2016-02-08 17:03:28 +0000 | [diff] [blame] | 2635 | llvm::TempDIScope TmpContext(DBuilder.createReplaceableCompositeType( |
| 2636 | llvm::dwarf::DW_TAG_enumeration_type, "", TheCU, DefUnit, 0)); |
Adrian Prantl | a40030f | 2016-02-06 01:59:09 +0000 | [diff] [blame] | 2637 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2638 | unsigned Line = getLineNumber(ED->getLocation()); |
| 2639 | StringRef EDName = ED->getName(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2640 | llvm::DIType *RetTy = DBuilder.createReplaceableCompositeType( |
Adrian Prantl | 4594606 | 2016-02-23 19:30:08 +0000 | [diff] [blame] | 2641 | llvm::dwarf::DW_TAG_enumeration_type, EDName, EDContext, DefUnit, Line, |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 2642 | 0, Size, Align, llvm::DINode::FlagFwdDecl, Identifier); |
Adrian Prantl | a40030f | 2016-02-06 01:59:09 +0000 | [diff] [blame] | 2643 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2644 | ReplaceMap.emplace_back( |
| 2645 | std::piecewise_construct, std::make_tuple(Ty), |
| 2646 | std::make_tuple(static_cast<llvm::Metadata *>(RetTy))); |
David Blaikie | f427b00 | 2014-05-06 03:42:01 +0000 | [diff] [blame] | 2647 | return RetTy; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2648 | } |
| 2649 | |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 2650 | return CreateTypeDefinition(Ty); |
| 2651 | } |
| 2652 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2653 | llvm::DIType *CGDebugInfo::CreateTypeDefinition(const EnumType *Ty) { |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 2654 | const EnumDecl *ED = Ty->getDecl(); |
| 2655 | uint64_t Size = 0; |
Victor Leschuk | 802e4a5 | 2016-10-19 22:11:07 +0000 | [diff] [blame] | 2656 | uint32_t Align = 0; |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 2657 | if (!ED->getTypeForDecl()->isIncompleteType()) { |
| 2658 | Size = CGM.getContext().getTypeSize(ED->getTypeForDecl()); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 2659 | Align = getDeclAlignIfRequired(ED, CGM.getContext()); |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 2660 | } |
| 2661 | |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 2662 | SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU); |
David Blaikie | 483a9da | 2014-05-06 18:35:21 +0000 | [diff] [blame] | 2663 | |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 2664 | // Create elements for each enumerator. |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2665 | SmallVector<llvm::Metadata *, 16> Enumerators; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2666 | ED = ED->getDefinition(); |
Momchil Velikov | 25f6be5 | 2018-02-12 16:12:52 +0000 | [diff] [blame] | 2667 | bool IsSigned = ED->getIntegerType()->isSignedIntegerType(); |
Aaron Ballman | 23a6dcb | 2014-03-08 18:45:14 +0000 | [diff] [blame] | 2668 | for (const auto *Enum : ED->enumerators()) { |
Momchil Velikov | 25f6be5 | 2018-02-12 16:12:52 +0000 | [diff] [blame] | 2669 | const auto &InitVal = Enum->getInitVal(); |
| 2670 | auto Value = IsSigned ? InitVal.getSExtValue() : InitVal.getZExtValue(); |
| 2671 | Enumerators.push_back( |
| 2672 | DBuilder.createEnumerator(Enum->getName(), Value, !IsSigned)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2673 | } |
| 2674 | |
| 2675 | // Return a CompositeType for the enum itself. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2676 | llvm::DINodeArray EltArray = DBuilder.getOrCreateArray(Enumerators); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2677 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2678 | llvm::DIFile *DefUnit = getOrCreateFile(ED->getLocation()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2679 | unsigned Line = getLineNumber(ED->getLocation()); |
Amjad Aboud | dc4531e | 2016-04-30 01:44:38 +0000 | [diff] [blame] | 2680 | llvm::DIScope *EnumContext = getDeclContextDescriptor(ED); |
Momchil Velikov | 25f6be5 | 2018-02-12 16:12:52 +0000 | [diff] [blame] | 2681 | llvm::DIType *ClassTy = getOrCreateType(ED->getIntegerType(), DefUnit); |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 2682 | return DBuilder.createEnumerationType(EnumContext, ED->getName(), DefUnit, |
| 2683 | Line, Size, Align, EltArray, ClassTy, |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 2684 | Identifier, ED->isFixed()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2685 | } |
| 2686 | |
Amjad Aboud | 546bc11 | 2017-02-09 22:07:24 +0000 | [diff] [blame] | 2687 | llvm::DIMacro *CGDebugInfo::CreateMacro(llvm::DIMacroFile *Parent, |
| 2688 | unsigned MType, SourceLocation LineLoc, |
| 2689 | StringRef Name, StringRef Value) { |
| 2690 | unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc); |
| 2691 | return DBuilder.createMacro(Parent, Line, MType, Name, Value); |
| 2692 | } |
| 2693 | |
| 2694 | llvm::DIMacroFile *CGDebugInfo::CreateTempMacroFile(llvm::DIMacroFile *Parent, |
| 2695 | SourceLocation LineLoc, |
| 2696 | SourceLocation FileLoc) { |
| 2697 | llvm::DIFile *FName = getOrCreateFile(FileLoc); |
| 2698 | unsigned Line = LineLoc.isInvalid() ? 0 : getLineNumber(LineLoc); |
| 2699 | return DBuilder.createTempMacroFile(Parent, Line, FName); |
| 2700 | } |
| 2701 | |
David Blaikie | 0549106 | 2013-01-21 04:37:12 +0000 | [diff] [blame] | 2702 | static QualType UnwrapTypeForDebugInfo(QualType T, const ASTContext &C) { |
| 2703 | Qualifiers Quals; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2704 | do { |
Adrian Prantl | 179af90 | 2013-09-26 21:35:50 +0000 | [diff] [blame] | 2705 | Qualifiers InnerQuals = T.getLocalQualifiers(); |
| 2706 | // Qualifiers::operator+() doesn't like it if you add a Qualifier |
| 2707 | // that is already there. |
| 2708 | Quals += Qualifiers::removeCommonQualifiers(Quals, InnerQuals); |
| 2709 | Quals += InnerQuals; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2710 | QualType LastT = T; |
| 2711 | switch (T->getTypeClass()) { |
| 2712 | default: |
David Blaikie | 0549106 | 2013-01-21 04:37:12 +0000 | [diff] [blame] | 2713 | return C.getQualifiedType(T.getTypePtr(), Quals); |
David Blaikie | f1b382e | 2014-04-06 17:14:06 +0000 | [diff] [blame] | 2714 | case Type::TemplateSpecialization: { |
| 2715 | const auto *Spec = cast<TemplateSpecializationType>(T); |
| 2716 | if (Spec->isTypeAlias()) |
| 2717 | return C.getQualifiedType(T.getTypePtr(), Quals); |
| 2718 | T = Spec->desugar(); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2719 | break; |
| 2720 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2721 | case Type::TypeOfExpr: |
| 2722 | T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType(); |
| 2723 | break; |
| 2724 | case Type::TypeOf: |
| 2725 | T = cast<TypeOfType>(T)->getUnderlyingType(); |
| 2726 | break; |
| 2727 | case Type::Decltype: |
| 2728 | T = cast<DecltypeType>(T)->getUnderlyingType(); |
| 2729 | break; |
| 2730 | case Type::UnaryTransform: |
| 2731 | T = cast<UnaryTransformType>(T)->getUnderlyingType(); |
| 2732 | break; |
| 2733 | case Type::Attributed: |
| 2734 | T = cast<AttributedType>(T)->getEquivalentType(); |
| 2735 | break; |
| 2736 | case Type::Elaborated: |
| 2737 | T = cast<ElaboratedType>(T)->getNamedType(); |
| 2738 | break; |
| 2739 | case Type::Paren: |
| 2740 | T = cast<ParenType>(T)->getInnerType(); |
| 2741 | break; |
David Blaikie | 0549106 | 2013-01-21 04:37:12 +0000 | [diff] [blame] | 2742 | case Type::SubstTemplateTypeParm: |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2743 | T = cast<SubstTemplateTypeParmType>(T)->getReplacementType(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2744 | break; |
Richard Smith | a0abc42 | 2017-02-22 00:13:14 +0000 | [diff] [blame] | 2745 | case Type::Auto: |
| 2746 | case Type::DeducedTemplateSpecialization: { |
| 2747 | QualType DT = cast<DeducedType>(T)->getDeducedType(); |
David Blaikie | 42edade | 2014-11-11 20:44:45 +0000 | [diff] [blame] | 2748 | assert(!DT.isNull() && "Undeduced types shouldn't reach here."); |
David Blaikie | 22c460a0 | 2013-05-24 21:24:35 +0000 | [diff] [blame] | 2749 | T = DT; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2750 | break; |
| 2751 | } |
Jordan Rose | 303e2f1 | 2016-11-10 23:28:17 +0000 | [diff] [blame] | 2752 | case Type::Adjusted: |
| 2753 | case Type::Decayed: |
| 2754 | // Decayed and adjusted types use the adjusted type in LLVM and DWARF. |
| 2755 | T = cast<AdjustedType>(T)->getAdjustedType(); |
| 2756 | break; |
| 2757 | } |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 2758 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2759 | assert(T != LastT && "Type unwrapping failed to unwrap!"); |
NAKAMURA Takumi | 3e0a363 | 2013-01-21 10:51:28 +0000 | [diff] [blame] | 2760 | (void)LastT; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2761 | } while (true); |
| 2762 | } |
| 2763 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2764 | llvm::DIType *CGDebugInfo::getTypeOrNull(QualType Ty) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2765 | |
| 2766 | // Unwrap the type as needed for debug information. |
David Blaikie | 0549106 | 2013-01-21 04:37:12 +0000 | [diff] [blame] | 2767 | Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext()); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 2768 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 2769 | auto It = TypeCache.find(Ty.getAsOpaquePtr()); |
| 2770 | if (It != TypeCache.end()) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2771 | // Verify that the debug info still exists. |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 2772 | if (llvm::Metadata *V = It->second) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2773 | return cast<llvm::DIType>(V); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2774 | } |
| 2775 | |
Duncan P. N. Exon Smith | c755128 | 2015-04-06 23:21:33 +0000 | [diff] [blame] | 2776 | return nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2777 | } |
| 2778 | |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2779 | void CGDebugInfo::completeTemplateDefinition( |
| 2780 | const ClassTemplateSpecializationDecl &SD) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 2781 | if (DebugKind <= codegenoptions::DebugLineTablesOnly) |
David Blaikie | 0856f66 | 2014-03-04 22:01:08 +0000 | [diff] [blame] | 2782 | return; |
David Blaikie | 1ac9c98 | 2017-04-11 21:13:37 +0000 | [diff] [blame] | 2783 | completeUnusedClass(SD); |
| 2784 | } |
David Blaikie | 0856f66 | 2014-03-04 22:01:08 +0000 | [diff] [blame] | 2785 | |
David Blaikie | 1ac9c98 | 2017-04-11 21:13:37 +0000 | [diff] [blame] | 2786 | void CGDebugInfo::completeUnusedClass(const CXXRecordDecl &D) { |
| 2787 | if (DebugKind <= codegenoptions::DebugLineTablesOnly) |
| 2788 | return; |
| 2789 | |
| 2790 | completeClassData(&D); |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2791 | // In case this type has no member function definitions being emitted, ensure |
| 2792 | // it is retained |
David Blaikie | 1ac9c98 | 2017-04-11 21:13:37 +0000 | [diff] [blame] | 2793 | RetainedTypes.push_back(CGM.getContext().getRecordType(&D).getAsOpaquePtr()); |
David Blaikie | 0e716b4 | 2014-03-03 23:48:23 +0000 | [diff] [blame] | 2794 | } |
| 2795 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2796 | llvm::DIType *CGDebugInfo::getOrCreateType(QualType Ty, llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2797 | if (Ty.isNull()) |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 2798 | return nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2799 | |
| 2800 | // Unwrap the type as needed for debug information. |
David Blaikie | 0549106 | 2013-01-21 04:37:12 +0000 | [diff] [blame] | 2801 | Ty = UnwrapTypeForDebugInfo(Ty, CGM.getContext()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2802 | |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 2803 | if (auto *T = getTypeOrNull(Ty)) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2804 | return T; |
| 2805 | |
Adrian Prantl | ca84418 | 2015-09-11 17:23:03 +0000 | [diff] [blame] | 2806 | llvm::DIType *Res = CreateTypeNode(Ty, Unit); |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 2807 | void *TyPtr = Ty.getAsOpaquePtr(); |
Adrian Prantl | 73409ce | 2013-03-11 18:33:46 +0000 | [diff] [blame] | 2808 | |
| 2809 | // And update the type cache. |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2810 | TypeCache[TyPtr].reset(Res); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2811 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2812 | return Res; |
| 2813 | } |
| 2814 | |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 2815 | llvm::DIModule *CGDebugInfo::getParentModuleOrNull(const Decl *D) { |
Adrian Prantl | 335f5c7 | 2015-10-02 17:36:14 +0000 | [diff] [blame] | 2816 | // A forward declaration inside a module header does not belong to the module. |
| 2817 | if (isa<RecordDecl>(D) && !cast<RecordDecl>(D)->getDefinition()) |
| 2818 | return nullptr; |
Adrian Prantl | 85d938a | 2015-09-21 17:48:37 +0000 | [diff] [blame] | 2819 | if (DebugTypeExtRefs && D->isFromASTFile()) { |
| 2820 | // Record a reference to an imported clang module or precompiled header. |
| 2821 | auto *Reader = CGM.getContext().getExternalSource(); |
| 2822 | auto Idx = D->getOwningModuleID(); |
| 2823 | auto Info = Reader->getSourceDescriptor(Idx); |
| 2824 | if (Info) |
| 2825 | return getOrCreateModuleRef(*Info, /*SkeletonCU=*/true); |
| 2826 | } else if (ClangModuleMap) { |
Adrian Prantl | 9402cef | 2015-09-20 16:51:35 +0000 | [diff] [blame] | 2827 | // We are building a clang module or a precompiled header. |
| 2828 | // |
| 2829 | // TODO: When D is a CXXRecordDecl or a C++ Enum, the ODR applies |
| 2830 | // and it wouldn't be necessary to specify the parent scope |
| 2831 | // because the type is already unique by definition (it would look |
| 2832 | // like the output of -fno-standalone-debug). On the other hand, |
| 2833 | // the parent scope helps a consumer to quickly locate the object |
| 2834 | // file where the type's definition is located, so it might be |
| 2835 | // best to make this behavior a command line or debugger tuning |
| 2836 | // option. |
Richard Smith | 54f0440 | 2017-05-18 02:29:20 +0000 | [diff] [blame] | 2837 | if (Module *M = D->getOwningModule()) { |
Adrian Prantl | aa5d08d | 2016-01-22 21:14:41 +0000 | [diff] [blame] | 2838 | // This is a (sub-)module. |
Adrian Prantl | 9402cef | 2015-09-20 16:51:35 +0000 | [diff] [blame] | 2839 | auto Info = ExternalASTSource::ASTSourceDescriptor(*M); |
| 2840 | return getOrCreateModuleRef(Info, /*SkeletonCU=*/false); |
Adrian Prantl | aa5d08d | 2016-01-22 21:14:41 +0000 | [diff] [blame] | 2841 | } else { |
| 2842 | // This the precompiled header being built. |
| 2843 | return getOrCreateModuleRef(PCHDescriptor, /*SkeletonCU=*/false); |
Adrian Prantl | 9402cef | 2015-09-20 16:51:35 +0000 | [diff] [blame] | 2844 | } |
| 2845 | } |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 2846 | |
Adrian Prantl | 9402cef | 2015-09-20 16:51:35 +0000 | [diff] [blame] | 2847 | return nullptr; |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 2848 | } |
| 2849 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2850 | llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty, llvm::DIFile *Unit) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2851 | // Handle qualifiers, which recursively handles what they refer to. |
| 2852 | if (Ty.hasLocalQualifiers()) |
David Blaikie | 99dab3b | 2013-09-04 22:03:57 +0000 | [diff] [blame] | 2853 | return CreateQualifiedType(Ty, Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2854 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2855 | // Work out details of type. |
| 2856 | switch (Ty->getTypeClass()) { |
| 2857 | #define TYPE(Class, Base) |
| 2858 | #define ABSTRACT_TYPE(Class, Base) |
| 2859 | #define NON_CANONICAL_TYPE(Class, Base) |
| 2860 | #define DEPENDENT_TYPE(Class, Base) case Type::Class: |
| 2861 | #include "clang/AST/TypeNodes.def" |
| 2862 | llvm_unreachable("Dependent types cannot show up in debug information"); |
| 2863 | |
| 2864 | case Type::ExtVector: |
| 2865 | case Type::Vector: |
| 2866 | return CreateType(cast<VectorType>(Ty), Unit); |
| 2867 | case Type::ObjCObjectPointer: |
| 2868 | return CreateType(cast<ObjCObjectPointerType>(Ty), Unit); |
| 2869 | case Type::ObjCObject: |
| 2870 | return CreateType(cast<ObjCObjectType>(Ty), Unit); |
Manman Ren | e6be26c | 2016-09-13 17:25:08 +0000 | [diff] [blame] | 2871 | case Type::ObjCTypeParam: |
| 2872 | return CreateType(cast<ObjCTypeParamType>(Ty), Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2873 | case Type::ObjCInterface: |
| 2874 | return CreateType(cast<ObjCInterfaceType>(Ty), Unit); |
| 2875 | case Type::Builtin: |
| 2876 | return CreateType(cast<BuiltinType>(Ty)); |
| 2877 | case Type::Complex: |
| 2878 | return CreateType(cast<ComplexType>(Ty)); |
| 2879 | case Type::Pointer: |
| 2880 | return CreateType(cast<PointerType>(Ty), Unit); |
| 2881 | case Type::BlockPointer: |
| 2882 | return CreateType(cast<BlockPointerType>(Ty), Unit); |
| 2883 | case Type::Typedef: |
David Blaikie | 99dab3b | 2013-09-04 22:03:57 +0000 | [diff] [blame] | 2884 | return CreateType(cast<TypedefType>(Ty), Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2885 | case Type::Record: |
David Blaikie | 99dab3b | 2013-09-04 22:03:57 +0000 | [diff] [blame] | 2886 | return CreateType(cast<RecordType>(Ty)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2887 | case Type::Enum: |
Manman Ren | 1b45702 | 2013-08-28 21:20:28 +0000 | [diff] [blame] | 2888 | return CreateEnumType(cast<EnumType>(Ty)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2889 | case Type::FunctionProto: |
| 2890 | case Type::FunctionNoProto: |
| 2891 | return CreateType(cast<FunctionType>(Ty), Unit); |
| 2892 | case Type::ConstantArray: |
| 2893 | case Type::VariableArray: |
| 2894 | case Type::IncompleteArray: |
| 2895 | return CreateType(cast<ArrayType>(Ty), Unit); |
| 2896 | |
| 2897 | case Type::LValueReference: |
| 2898 | return CreateType(cast<LValueReferenceType>(Ty), Unit); |
| 2899 | case Type::RValueReference: |
| 2900 | return CreateType(cast<RValueReferenceType>(Ty), Unit); |
| 2901 | |
| 2902 | case Type::MemberPointer: |
| 2903 | return CreateType(cast<MemberPointerType>(Ty), Unit); |
| 2904 | |
| 2905 | case Type::Atomic: |
| 2906 | return CreateType(cast<AtomicType>(Ty), Unit); |
| 2907 | |
Xiuli Pan | 9c14e28 | 2016-01-09 12:53:17 +0000 | [diff] [blame] | 2908 | case Type::Pipe: |
| 2909 | return CreateType(cast<PipeType>(Ty), Unit); |
| 2910 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2911 | case Type::TemplateSpecialization: |
David Blaikie | f1b382e | 2014-04-06 17:14:06 +0000 | [diff] [blame] | 2912 | return CreateType(cast<TemplateSpecializationType>(Ty), Unit); |
| 2913 | |
David Blaikie | 42edade | 2014-11-11 20:44:45 +0000 | [diff] [blame] | 2914 | case Type::Auto: |
David Blaikie | f1b382e | 2014-04-06 17:14:06 +0000 | [diff] [blame] | 2915 | case Type::Attributed: |
Jordan Rose | 303e2f1 | 2016-11-10 23:28:17 +0000 | [diff] [blame] | 2916 | case Type::Adjusted: |
| 2917 | case Type::Decayed: |
Richard Smith | 600b526 | 2017-01-26 20:40:47 +0000 | [diff] [blame] | 2918 | case Type::DeducedTemplateSpecialization: |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2919 | case Type::Elaborated: |
| 2920 | case Type::Paren: |
| 2921 | case Type::SubstTemplateTypeParm: |
| 2922 | case Type::TypeOfExpr: |
| 2923 | case Type::TypeOf: |
| 2924 | case Type::Decltype: |
| 2925 | case Type::UnaryTransform: |
David Blaikie | 66ed89d | 2013-07-13 21:08:08 +0000 | [diff] [blame] | 2926 | case Type::PackExpansion: |
David Blaikie | 22c460a0 | 2013-05-24 21:24:35 +0000 | [diff] [blame] | 2927 | break; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2928 | } |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 2929 | |
David Blaikie | 42edade | 2014-11-11 20:44:45 +0000 | [diff] [blame] | 2930 | llvm_unreachable("type should have been unwrapped!"); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2931 | } |
| 2932 | |
Duncan P. N. Exon Smith | bd210e6 | 2015-07-24 20:34:41 +0000 | [diff] [blame] | 2933 | llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty, |
| 2934 | llvm::DIFile *Unit) { |
David Blaikie | 4a2b5ef | 2013-08-12 22:24:20 +0000 | [diff] [blame] | 2935 | QualType QTy(Ty, 0); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2936 | |
Duncan P. N. Exon Smith | bd210e6 | 2015-07-24 20:34:41 +0000 | [diff] [blame] | 2937 | auto *T = cast_or_null<llvm::DICompositeType>(getTypeOrNull(QTy)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2938 | |
| 2939 | // We may have cached a forward decl when we could have created |
| 2940 | // a non-forward decl. Go ahead and create a non-forward decl |
| 2941 | // now. |
Duncan P. N. Exon Smith | 4caa7f2 | 2015-04-16 01:00:56 +0000 | [diff] [blame] | 2942 | if (T && !T->isForwardDecl()) |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2943 | return T; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2944 | |
| 2945 | // Otherwise create the type. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2946 | llvm::DICompositeType *Res = CreateLimitedType(Ty); |
David Blaikie | 8d5e128 | 2013-08-20 21:03:29 +0000 | [diff] [blame] | 2947 | |
| 2948 | // Propagate members from the declaration to the definition |
| 2949 | // CreateType(const RecordType*) will overwrite this with the members in the |
| 2950 | // correct order if the full type is needed. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2951 | DBuilder.replaceArrays(Res, T ? T->getElements() : llvm::DINodeArray()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2952 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2953 | // And update the type cache. |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 2954 | TypeCache[QTy.getAsOpaquePtr()].reset(Res); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2955 | return Res; |
| 2956 | } |
| 2957 | |
| 2958 | // TODO: Currently used for context chains when limiting debug info. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2959 | llvm::DICompositeType *CGDebugInfo::CreateLimitedType(const RecordType *Ty) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2960 | RecordDecl *RD = Ty->getDecl(); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 2961 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2962 | // Get overall information about the record type for the debug info. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2963 | llvm::DIFile *DefUnit = getOrCreateFile(RD->getLocation()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2964 | unsigned Line = getLineNumber(RD->getLocation()); |
| 2965 | StringRef RDName = getClassName(RD); |
| 2966 | |
Amjad Aboud | dc4531e | 2016-04-30 01:44:38 +0000 | [diff] [blame] | 2967 | llvm::DIScope *RDContext = getDeclContextDescriptor(RD); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2968 | |
David Blaikie | d278589 | 2013-08-18 17:36:19 +0000 | [diff] [blame] | 2969 | // If we ended up creating the type during the context chain construction, |
| 2970 | // just return that. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 2971 | auto *T = cast_or_null<llvm::DICompositeType>( |
Duncan P. N. Exon Smith | c755128 | 2015-04-06 23:21:33 +0000 | [diff] [blame] | 2972 | getTypeOrNull(CGM.getContext().getRecordType(RD))); |
Duncan P. N. Exon Smith | 4caa7f2 | 2015-04-16 01:00:56 +0000 | [diff] [blame] | 2973 | if (T && (!T->isForwardDecl() || !RD->getDefinition())) |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 2974 | return T; |
David Blaikie | d278589 | 2013-08-18 17:36:19 +0000 | [diff] [blame] | 2975 | |
Adrian Prantl | 381e755 | 2014-02-04 21:29:50 +0000 | [diff] [blame] | 2976 | // If this is just a forward or incomplete declaration, construct an |
| 2977 | // appropriately marked node and just return it. |
| 2978 | const RecordDecl *D = RD->getDefinition(); |
| 2979 | if (!D || !D->isCompleteDefinition()) |
Manman Ren | 1b45702 | 2013-08-28 21:20:28 +0000 | [diff] [blame] | 2980 | return getOrCreateRecordFwdDecl(Ty, RDContext); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 2981 | |
| 2982 | uint64_t Size = CGM.getContext().getTypeSize(Ty); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 2983 | auto Align = getDeclAlignIfRequired(D, CGM.getContext()); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 2984 | |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 2985 | SmallString<256> Identifier = getTypeIdentifier(Ty, CGM, TheCU); |
Manman Ren | e0064d8 | 2013-08-29 23:19:58 +0000 | [diff] [blame] | 2986 | |
Adrian Prantl | 6c5f03a | 2018-01-05 01:13:52 +0000 | [diff] [blame] | 2987 | // Explicitly record the calling convention for C++ records. |
| 2988 | auto Flags = llvm::DINode::FlagZero; |
| 2989 | if (auto CXXRD = dyn_cast<CXXRecordDecl>(RD)) { |
| 2990 | if (CGM.getCXXABI().getRecordArgABI(CXXRD) == CGCXXABI::RAA_Indirect) |
| 2991 | Flags |= llvm::DINode::FlagTypePassByReference; |
| 2992 | else |
| 2993 | Flags |= llvm::DINode::FlagTypePassByValue; |
Aaron Smith | 044326c | 2018-07-23 20:49:07 +0000 | [diff] [blame] | 2994 | |
| 2995 | // Record if a C++ record is trivial type. |
| 2996 | if (CXXRD->isTrivial()) |
| 2997 | Flags |= llvm::DINode::FlagTrivial; |
Adrian Prantl | 6c5f03a | 2018-01-05 01:13:52 +0000 | [diff] [blame] | 2998 | } |
| 2999 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3000 | llvm::DICompositeType *RealDecl = DBuilder.createReplaceableCompositeType( |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 3001 | getTagForRecord(RD), RDName, RDContext, DefUnit, Line, 0, Size, Align, |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 3002 | Flags, Identifier); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3003 | |
Duncan P. N. Exon Smith | f9521b0 | 2016-04-17 07:45:08 +0000 | [diff] [blame] | 3004 | // Elements of composite types usually have back to the type, creating |
| 3005 | // uniquing cycles. Distinct nodes are more efficient. |
| 3006 | switch (RealDecl->getTag()) { |
| 3007 | default: |
| 3008 | llvm_unreachable("invalid composite type tag"); |
| 3009 | |
| 3010 | case llvm::dwarf::DW_TAG_array_type: |
| 3011 | case llvm::dwarf::DW_TAG_enumeration_type: |
| 3012 | // Array elements and most enumeration elements don't have back references, |
| 3013 | // so they don't tend to be involved in uniquing cycles and there is some |
| 3014 | // chance of merging them when linking together two modules. Only make |
| 3015 | // them distinct if they are ODR-uniqued. |
Brock Wyma | 8557ec5 | 2018-05-22 12:41:19 +0000 | [diff] [blame] | 3016 | if (Identifier.empty()) |
Duncan P. N. Exon Smith | f9521b0 | 2016-04-17 07:45:08 +0000 | [diff] [blame] | 3017 | break; |
Galina Kistanova | 0872d6c | 2017-06-03 06:30:46 +0000 | [diff] [blame] | 3018 | LLVM_FALLTHROUGH; |
Duncan P. N. Exon Smith | f9521b0 | 2016-04-17 07:45:08 +0000 | [diff] [blame] | 3019 | |
| 3020 | case llvm::dwarf::DW_TAG_structure_type: |
| 3021 | case llvm::dwarf::DW_TAG_union_type: |
| 3022 | case llvm::dwarf::DW_TAG_class_type: |
Alexander Kornienko | 2a8c18d | 2018-04-06 15:14:32 +0000 | [diff] [blame] | 3023 | // Immediately resolve to a distinct node. |
Duncan P. N. Exon Smith | f9521b0 | 2016-04-17 07:45:08 +0000 | [diff] [blame] | 3024 | RealDecl = |
| 3025 | llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl)); |
| 3026 | break; |
| 3027 | } |
| 3028 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3029 | RegionMap[Ty->getDecl()].reset(RealDecl); |
| 3030 | TypeCache[QualType(Ty, 0).getAsOpaquePtr()].reset(RealDecl); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3031 | |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3032 | if (const auto *TSpecial = dyn_cast<ClassTemplateSpecializationDecl>(RD)) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3033 | DBuilder.replaceArrays(RealDecl, llvm::DINodeArray(), |
Duncan P. N. Exon Smith | c8ee63e | 2014-12-18 00:48:56 +0000 | [diff] [blame] | 3034 | CollectCXXTemplateParams(TSpecial, DefUnit)); |
David Blaikie | 952dac3 | 2013-08-15 22:42:12 +0000 | [diff] [blame] | 3035 | return RealDecl; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3036 | } |
| 3037 | |
David Blaikie | adfbf99 | 2013-08-18 16:55:33 +0000 | [diff] [blame] | 3038 | void CGDebugInfo::CollectContainingType(const CXXRecordDecl *RD, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3039 | llvm::DICompositeType *RealDecl) { |
David Blaikie | adfbf99 | 2013-08-18 16:55:33 +0000 | [diff] [blame] | 3040 | // A class's primary base or the class itself contains the vtable. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3041 | llvm::DICompositeType *ContainingType = nullptr; |
David Blaikie | adfbf99 | 2013-08-18 16:55:33 +0000 | [diff] [blame] | 3042 | const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD); |
| 3043 | if (const CXXRecordDecl *PBase = RL.getPrimaryBase()) { |
Alp Toker | d473363 | 2013-12-05 04:47:09 +0000 | [diff] [blame] | 3044 | // Seek non-virtual primary base root. |
David Blaikie | adfbf99 | 2013-08-18 16:55:33 +0000 | [diff] [blame] | 3045 | while (1) { |
| 3046 | const ASTRecordLayout &BRL = CGM.getContext().getASTRecordLayout(PBase); |
| 3047 | const CXXRecordDecl *PBT = BRL.getPrimaryBase(); |
| 3048 | if (PBT && !BRL.isPrimaryBaseVirtual()) |
| 3049 | PBase = PBT; |
| 3050 | else |
| 3051 | break; |
| 3052 | } |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3053 | ContainingType = cast<llvm::DICompositeType>( |
David Blaikie | adfbf99 | 2013-08-18 16:55:33 +0000 | [diff] [blame] | 3054 | getOrCreateType(QualType(PBase->getTypeForDecl(), 0), |
| 3055 | getOrCreateFile(RD->getLocation()))); |
| 3056 | } else if (RD->isDynamicClass()) |
| 3057 | ContainingType = RealDecl; |
| 3058 | |
Duncan P. N. Exon Smith | c8ee63e | 2014-12-18 00:48:56 +0000 | [diff] [blame] | 3059 | DBuilder.replaceVTableHolder(RealDecl, ContainingType); |
David Blaikie | adfbf99 | 2013-08-18 16:55:33 +0000 | [diff] [blame] | 3060 | } |
| 3061 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3062 | llvm::DIType *CGDebugInfo::CreateMemberType(llvm::DIFile *Unit, QualType FType, |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 3063 | StringRef Name, uint64_t *Offset) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3064 | llvm::DIType *FieldTy = CGDebugInfo::getOrCreateType(FType, Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3065 | uint64_t FieldSize = CGM.getContext().getTypeSize(FType); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 3066 | auto FieldAlign = getTypeAlignIfRequired(FType, CGM.getContext()); |
Leny Kholodov | df050fd | 2016-09-06 17:06:14 +0000 | [diff] [blame] | 3067 | llvm::DIType *Ty = |
| 3068 | DBuilder.createMemberType(Unit, Name, Unit, 0, FieldSize, FieldAlign, |
| 3069 | *Offset, llvm::DINode::FlagZero, FieldTy); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3070 | *Offset += FieldSize; |
| 3071 | return Ty; |
| 3072 | } |
| 3073 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3074 | void CGDebugInfo::collectFunctionDeclProps(GlobalDecl GD, llvm::DIFile *Unit, |
Duncan P. N. Exon Smith | 8e47da4 | 2015-04-21 20:07:29 +0000 | [diff] [blame] | 3075 | StringRef &Name, |
| 3076 | StringRef &LinkageName, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3077 | llvm::DIScope *&FDContext, |
| 3078 | llvm::DINodeArray &TParamsArray, |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 3079 | llvm::DINode::DIFlags &Flags) { |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3080 | const auto *FD = cast<FunctionDecl>(GD.getDecl()); |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3081 | Name = getFunctionName(FD); |
| 3082 | // Use mangled name as linkage name for C/C++ functions. |
| 3083 | if (FD->hasPrototype()) { |
| 3084 | LinkageName = CGM.getMangledName(GD); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3085 | Flags |= llvm::DINode::FlagPrototyped; |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3086 | } |
| 3087 | // No need to replicate the linkage name if it isn't different from the |
| 3088 | // subprogram name, no need to have it at all unless coverage is enabled or |
Dehao Chen | b3a70de | 2017-01-19 00:44:21 +0000 | [diff] [blame] | 3089 | // debug is set to more than just line tables or extra debug info is needed. |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3090 | if (LinkageName == Name || (!CGM.getCodeGenOpts().EmitGcovArcs && |
| 3091 | !CGM.getCodeGenOpts().EmitGcovNotes && |
Dehao Chen | b3a70de | 2017-01-19 00:44:21 +0000 | [diff] [blame] | 3092 | !CGM.getCodeGenOpts().DebugInfoForProfiling && |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3093 | DebugKind <= codegenoptions::DebugLineTablesOnly)) |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3094 | LinkageName = StringRef(); |
| 3095 | |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3096 | if (DebugKind >= codegenoptions::LimitedDebugInfo) { |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3097 | if (const NamespaceDecl *NSDecl = |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3098 | dyn_cast_or_null<NamespaceDecl>(FD->getDeclContext())) |
Adrian Prantl | ddb8e06 | 2017-05-12 16:23:53 +0000 | [diff] [blame] | 3099 | FDContext = getOrCreateNamespace(NSDecl); |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3100 | else if (const RecordDecl *RDecl = |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3101 | dyn_cast_or_null<RecordDecl>(FD->getDeclContext())) { |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 3102 | llvm::DIScope *Mod = getParentModuleOrNull(RDecl); |
| 3103 | FDContext = getContextDescriptor(RDecl, Mod ? Mod : TheCU); |
| 3104 | } |
Adrian Prantl | fd5ac8a | 2016-08-17 16:20:32 +0000 | [diff] [blame] | 3105 | // Check if it is a noreturn-marked function |
| 3106 | if (FD->isNoReturn()) |
| 3107 | Flags |= llvm::DINode::FlagNoReturn; |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3108 | // Collect template parameters. |
| 3109 | TParamsArray = CollectFunctionTemplateParams(FD, Unit); |
| 3110 | } |
| 3111 | } |
| 3112 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3113 | void CGDebugInfo::collectVarDeclProps(const VarDecl *VD, llvm::DIFile *&Unit, |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3114 | unsigned &LineNo, QualType &T, |
| 3115 | StringRef &Name, StringRef &LinkageName, |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 3116 | llvm::MDTuple *&TemplateParameters, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3117 | llvm::DIScope *&VDContext) { |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3118 | Unit = getOrCreateFile(VD->getLocation()); |
| 3119 | LineNo = getLineNumber(VD->getLocation()); |
| 3120 | |
| 3121 | setLocation(VD->getLocation()); |
| 3122 | |
| 3123 | T = VD->getType(); |
| 3124 | if (T->isIncompleteArrayType()) { |
| 3125 | // CodeGen turns int[] into int[1] so we'll do the same here. |
| 3126 | llvm::APInt ConstVal(32, 1); |
| 3127 | QualType ET = CGM.getContext().getAsArrayType(T)->getElementType(); |
| 3128 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3129 | T = CGM.getContext().getConstantArrayType(ET, ConstVal, ArrayType::Normal, |
| 3130 | 0); |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3131 | } |
| 3132 | |
| 3133 | Name = VD->getName(); |
| 3134 | if (VD->getDeclContext() && !isa<FunctionDecl>(VD->getDeclContext()) && |
| 3135 | !isa<ObjCMethodDecl>(VD->getDeclContext())) |
| 3136 | LinkageName = CGM.getMangledName(VD); |
| 3137 | if (LinkageName == Name) |
| 3138 | LinkageName = StringRef(); |
| 3139 | |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 3140 | if (isa<VarTemplateSpecializationDecl>(VD)) { |
| 3141 | llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VD, &*Unit); |
| 3142 | TemplateParameters = parameterNodes.get(); |
| 3143 | } else { |
| 3144 | TemplateParameters = nullptr; |
| 3145 | } |
| 3146 | |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3147 | // Since we emit declarations (DW_AT_members) for static members, place the |
| 3148 | // definition of those static members in the namespace they were declared in |
| 3149 | // in the source code (the lexical decl context). |
| 3150 | // FIXME: Generalize this for even non-member global variables where the |
| 3151 | // declaration and definition may have different lexical decl contexts, once |
| 3152 | // we have support for emitting declarations of (non-member) global variables. |
Saleem Abdulrasool | cd187f0 | 2015-02-28 00:13:13 +0000 | [diff] [blame] | 3153 | const DeclContext *DC = VD->isStaticDataMember() ? VD->getLexicalDeclContext() |
| 3154 | : VD->getDeclContext(); |
| 3155 | // When a record type contains an in-line initialization of a static data |
| 3156 | // member, and the record type is marked as __declspec(dllexport), an implicit |
| 3157 | // definition of the member will be created in the record context. DWARF |
| 3158 | // doesn't seem to have a nice way to describe this in a form that consumers |
| 3159 | // are likely to understand, so fake the "normal" situation of a definition |
| 3160 | // outside the class by putting it in the global scope. |
| 3161 | if (DC->isRecord()) |
| 3162 | DC = CGM.getContext().getTranslationUnitDecl(); |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 3163 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3164 | llvm::DIScope *Mod = getParentModuleOrNull(VD); |
| 3165 | VDContext = getContextDescriptor(cast<Decl>(DC), Mod ? Mod : TheCU); |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3166 | } |
| 3167 | |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3168 | llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD, |
| 3169 | bool Stub) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3170 | llvm::DINodeArray TParamsArray; |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3171 | StringRef Name, LinkageName; |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 3172 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero; |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3173 | llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero; |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3174 | SourceLocation Loc = GD.getDecl()->getLocation(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3175 | llvm::DIFile *Unit = getOrCreateFile(Loc); |
| 3176 | llvm::DIScope *DContext = Unit; |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3177 | unsigned Line = getLineNumber(Loc); |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3178 | collectFunctionDeclProps(GD, Unit, Name, LinkageName, DContext, TParamsArray, |
| 3179 | Flags); |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3180 | auto *FD = dyn_cast<FunctionDecl>(GD.getDecl()); |
| 3181 | |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3182 | // Build function type. |
| 3183 | SmallVector<QualType, 16> ArgTypes; |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3184 | if (FD) |
| 3185 | for (const ParmVarDecl *Parm : FD->parameters()) |
| 3186 | ArgTypes.push_back(Parm->getType()); |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 3187 | CallingConv CC = FD->getType()->castAs<FunctionType>()->getCallConv(); |
| 3188 | QualType FnType = CGM.getContext().getFunctionType( |
| 3189 | FD->getReturnType(), ArgTypes, FunctionProtoType::ExtProtoInfo(CC)); |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3190 | if (!FD->isExternallyVisible()) |
| 3191 | SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit; |
| 3192 | if (CGM.getLangOpts().Optimize) |
| 3193 | SPFlags |= llvm::DISubprogram::SPFlagOptimized; |
| 3194 | |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3195 | if (Stub) { |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 3196 | Flags |= getCallSiteRelatedAttrs(); |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3197 | SPFlags |= llvm::DISubprogram::SPFlagDefinition; |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3198 | return DBuilder.createFunction( |
| 3199 | DContext, Name, LinkageName, Unit, Line, |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3200 | getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags, |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3201 | TParamsArray.get(), getFunctionDeclaration(FD)); |
| 3202 | } |
| 3203 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3204 | llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl( |
Duncan P. N. Exon Smith | ebad0aa | 2015-04-07 16:50:49 +0000 | [diff] [blame] | 3205 | DContext, Name, LinkageName, Unit, Line, |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3206 | getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags, |
Duncan P. N. Exon Smith | ebad0aa | 2015-04-07 16:50:49 +0000 | [diff] [blame] | 3207 | TParamsArray.get(), getFunctionDeclaration(FD)); |
George Burgess IV | 00f70bd | 2018-03-01 05:43:23 +0000 | [diff] [blame] | 3208 | const FunctionDecl *CanonDecl = FD->getCanonicalDecl(); |
Duncan P. N. Exon Smith | 4078ad4 | 2015-04-16 16:36:45 +0000 | [diff] [blame] | 3209 | FwdDeclReplaceMap.emplace_back(std::piecewise_construct, |
| 3210 | std::make_tuple(CanonDecl), |
| 3211 | std::make_tuple(SP)); |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3212 | return SP; |
| 3213 | } |
| 3214 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3215 | llvm::DISubprogram *CGDebugInfo::getFunctionForwardDeclaration(GlobalDecl GD) { |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3216 | return getFunctionFwdDeclOrStub(GD, /* Stub = */ false); |
| 3217 | } |
| 3218 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3219 | llvm::DISubprogram *CGDebugInfo::getFunctionStub(GlobalDecl GD) { |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3220 | return getFunctionFwdDeclOrStub(GD, /* Stub = */ true); |
| 3221 | } |
| 3222 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3223 | llvm::DIGlobalVariable * |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3224 | CGDebugInfo::getGlobalVariableForwardDeclaration(const VarDecl *VD) { |
| 3225 | QualType T; |
| 3226 | StringRef Name, LinkageName; |
| 3227 | SourceLocation Loc = VD->getLocation(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3228 | llvm::DIFile *Unit = getOrCreateFile(Loc); |
| 3229 | llvm::DIScope *DContext = Unit; |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3230 | unsigned Line = getLineNumber(Loc); |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 3231 | llvm::MDTuple *TemplateParameters = nullptr; |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3232 | |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 3233 | collectVarDeclProps(VD, Unit, Line, T, Name, LinkageName, TemplateParameters, |
| 3234 | DContext); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 3235 | auto Align = getDeclAlignIfRequired(VD, CGM.getContext()); |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 3236 | auto *GV = DBuilder.createTempGlobalVariableFwdDecl( |
| 3237 | DContext, Name, LinkageName, Unit, Line, getOrCreateType(T, Unit), |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 3238 | !VD->isExternallyVisible(), nullptr, TemplateParameters, Align); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3239 | FwdDeclReplaceMap.emplace_back( |
| 3240 | std::piecewise_construct, |
| 3241 | std::make_tuple(cast<VarDecl>(VD->getCanonicalDecl())), |
| 3242 | std::make_tuple(static_cast<llvm::Metadata *>(GV))); |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3243 | return GV; |
| 3244 | } |
| 3245 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3246 | llvm::DINode *CGDebugInfo::getDeclarationOrDefinition(const Decl *D) { |
David Blaikie | bd48376 | 2013-05-20 04:58:53 +0000 | [diff] [blame] | 3247 | // We only need a declaration (not a definition) of the type - so use whatever |
| 3248 | // we would otherwise do to get a type for a pointee. (forward declarations in |
| 3249 | // limited debug info, full definitions (if the type definition is available) |
| 3250 | // in unlimited debug info) |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3251 | if (const auto *TD = dyn_cast<TypeDecl>(D)) |
David Blaikie | 6b7d060c | 2013-08-12 23:14:36 +0000 | [diff] [blame] | 3252 | return getOrCreateType(CGM.getContext().getTypeDeclType(TD), |
David Blaikie | 99dab3b | 2013-09-04 22:03:57 +0000 | [diff] [blame] | 3253 | getOrCreateFile(TD->getLocation())); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3254 | auto I = DeclCache.find(D->getCanonicalDecl()); |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3255 | |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 3256 | if (I != DeclCache.end()) { |
| 3257 | auto N = I->second; |
| 3258 | if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(N)) |
| 3259 | return GVE->getVariable(); |
| 3260 | return dyn_cast_or_null<llvm::DINode>(N); |
| 3261 | } |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3262 | |
| 3263 | // No definition for now. Emit a forward definition that might be |
| 3264 | // merged with a potential upcoming definition. |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3265 | if (const auto *FD = dyn_cast<FunctionDecl>(D)) |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 3266 | return getFunctionForwardDeclaration(FD); |
| 3267 | else if (const auto *VD = dyn_cast<VarDecl>(D)) |
| 3268 | return getGlobalVariableForwardDeclaration(VD); |
| 3269 | |
Duncan P. N. Exon Smith | 4078ad4 | 2015-04-16 16:36:45 +0000 | [diff] [blame] | 3270 | return nullptr; |
David Blaikie | bd48376 | 2013-05-20 04:58:53 +0000 | [diff] [blame] | 3271 | } |
| 3272 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3273 | llvm::DISubprogram *CGDebugInfo::getFunctionDeclaration(const Decl *D) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3274 | if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly) |
Duncan P. N. Exon Smith | a7fbcbf | 2015-04-20 22:09:57 +0000 | [diff] [blame] | 3275 | return nullptr; |
David Blaikie | 18cfbc5 | 2013-06-22 00:09:36 +0000 | [diff] [blame] | 3276 | |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3277 | const auto *FD = dyn_cast<FunctionDecl>(D); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3278 | if (!FD) |
Duncan P. N. Exon Smith | a7fbcbf | 2015-04-20 22:09:57 +0000 | [diff] [blame] | 3279 | return nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3280 | |
| 3281 | // Setup context. |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 3282 | auto *S = getDeclContextDescriptor(D); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3283 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3284 | auto MI = SPCache.find(FD->getCanonicalDecl()); |
David Blaikie | fd07c60 | 2013-08-09 17:20:05 +0000 | [diff] [blame] | 3285 | if (MI == SPCache.end()) { |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3286 | if (const auto *MD = dyn_cast<CXXMethodDecl>(FD->getCanonicalDecl())) { |
Duncan P. N. Exon Smith | c09c548 | 2015-04-20 21:17:26 +0000 | [diff] [blame] | 3287 | return CreateCXXMemberFunction(MD, getOrCreateFile(MD->getLocation()), |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3288 | cast<llvm::DICompositeType>(S)); |
David Blaikie | fd07c60 | 2013-08-09 17:20:05 +0000 | [diff] [blame] | 3289 | } |
| 3290 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3291 | if (MI != SPCache.end()) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3292 | auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second); |
Duncan P. N. Exon Smith | 87afdeb | 2015-04-14 03:24:14 +0000 | [diff] [blame] | 3293 | if (SP && !SP->isDefinition()) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3294 | return SP; |
| 3295 | } |
| 3296 | |
Aaron Ballman | 86c9390 | 2014-03-06 23:45:36 +0000 | [diff] [blame] | 3297 | for (auto NextFD : FD->redecls()) { |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3298 | auto MI = SPCache.find(NextFD->getCanonicalDecl()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3299 | if (MI != SPCache.end()) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3300 | auto *SP = dyn_cast_or_null<llvm::DISubprogram>(MI->second); |
Duncan P. N. Exon Smith | 87afdeb | 2015-04-14 03:24:14 +0000 | [diff] [blame] | 3301 | if (SP && !SP->isDefinition()) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3302 | return SP; |
| 3303 | } |
| 3304 | } |
Duncan P. N. Exon Smith | a7fbcbf | 2015-04-20 22:09:57 +0000 | [diff] [blame] | 3305 | return nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3306 | } |
| 3307 | |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 3308 | // getOrCreateFunctionType - Construct type. If it is a c++ method, include |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3309 | // implicit parameter "this". |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3310 | llvm::DISubroutineType *CGDebugInfo::getOrCreateFunctionType(const Decl *D, |
Duncan P. N. Exon Smith | 4078ad4 | 2015-04-16 16:36:45 +0000 | [diff] [blame] | 3311 | QualType FnType, |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3312 | llvm::DIFile *F) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3313 | if (!D || DebugKind <= codegenoptions::DebugLineTablesOnly) |
Duncan P. N. Exon Smith | a7fbcbf | 2015-04-20 22:09:57 +0000 | [diff] [blame] | 3314 | // Create fake but valid subroutine type. Otherwise -verify would fail, and |
| 3315 | // subprogram DIE will miss DW_AT_decl_file and DW_AT_decl_line fields. |
Eric Christopher | 28a6db5 | 2015-10-15 06:56:08 +0000 | [diff] [blame] | 3316 | return DBuilder.createSubroutineType(DBuilder.getOrCreateTypeArray(None)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3317 | |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3318 | if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3319 | return getOrCreateMethodType(Method, F); |
Reid Kleckner | f00f803 | 2016-06-08 20:41:54 +0000 | [diff] [blame] | 3320 | |
| 3321 | const auto *FTy = FnType->getAs<FunctionType>(); |
| 3322 | CallingConv CC = FTy ? FTy->getCallConv() : CallingConv::CC_C; |
| 3323 | |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3324 | if (const auto *OMethod = dyn_cast<ObjCMethodDecl>(D)) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3325 | // Add "self" and "_cmd" |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3326 | SmallVector<llvm::Metadata *, 16> Elts; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3327 | |
| 3328 | // First element is always return type. For 'void' functions it is NULL. |
Alp Toker | 314cc81 | 2014-01-25 16:55:45 +0000 | [diff] [blame] | 3329 | QualType ResultTy = OMethod->getReturnType(); |
Adrian Prantl | 5f36010 | 2013-05-22 21:37:49 +0000 | [diff] [blame] | 3330 | |
| 3331 | // Replace the instancetype keyword with the actual type. |
| 3332 | if (ResultTy == CGM.getContext().getObjCInstanceType()) |
| 3333 | ResultTy = CGM.getContext().getPointerType( |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3334 | QualType(OMethod->getClassInterface()->getTypeForDecl(), 0)); |
Adrian Prantl | 5f36010 | 2013-05-22 21:37:49 +0000 | [diff] [blame] | 3335 | |
Adrian Prantl | 7bec903 | 2013-05-10 21:08:31 +0000 | [diff] [blame] | 3336 | Elts.push_back(getOrCreateType(ResultTy, F)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3337 | // "self" pointer is always first argument. |
Adrian Prantl | 748a6cd | 2015-09-08 20:41:52 +0000 | [diff] [blame] | 3338 | QualType SelfDeclTy; |
| 3339 | if (auto *SelfDecl = OMethod->getSelfDecl()) |
| 3340 | SelfDeclTy = SelfDecl->getType(); |
| 3341 | else if (auto *FPT = dyn_cast<FunctionProtoType>(FnType)) |
| 3342 | if (FPT->getNumParams() > 1) |
| 3343 | SelfDeclTy = FPT->getParamType(0); |
| 3344 | if (!SelfDeclTy.isNull()) |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3345 | Elts.push_back( |
| 3346 | CreateSelfType(SelfDeclTy, getOrCreateType(SelfDeclTy, F))); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3347 | // "_cmd" pointer is always second argument. |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 3348 | Elts.push_back(DBuilder.createArtificialType( |
Adrian Prantl | 748a6cd | 2015-09-08 20:41:52 +0000 | [diff] [blame] | 3349 | getOrCreateType(CGM.getContext().getObjCSelType(), F))); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3350 | // Get rest of the arguments. |
David Majnemer | 59f7792 | 2016-06-24 04:05:48 +0000 | [diff] [blame] | 3351 | for (const auto *PI : OMethod->parameters()) |
Aaron Ballman | 43b68be | 2014-03-07 17:50:17 +0000 | [diff] [blame] | 3352 | Elts.push_back(getOrCreateType(PI->getType(), F)); |
Frederic Riss | 787d9d6 | 2014-08-12 04:42:23 +0000 | [diff] [blame] | 3353 | // Variadic methods need a special marker at the end of the type list. |
| 3354 | if (OMethod->isVariadic()) |
| 3355 | Elts.push_back(DBuilder.createUnspecifiedParameter()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3356 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3357 | llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(Elts); |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 3358 | return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero, |
| 3359 | getDwarfCC(CC)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3360 | } |
Adrian Prantl | d45ba25 | 2014-02-25 19:38:11 +0000 | [diff] [blame] | 3361 | |
Adrian Prantl | 800faef | 2014-02-25 23:42:18 +0000 | [diff] [blame] | 3362 | // Handle variadic function types; they need an additional |
| 3363 | // unspecified parameter. |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3364 | if (const auto *FD = dyn_cast<FunctionDecl>(D)) |
Adrian Prantl | d45ba25 | 2014-02-25 19:38:11 +0000 | [diff] [blame] | 3365 | if (FD->isVariadic()) { |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3366 | SmallVector<llvm::Metadata *, 16> EltTys; |
Adrian Prantl | d45ba25 | 2014-02-25 19:38:11 +0000 | [diff] [blame] | 3367 | EltTys.push_back(getOrCreateType(FD->getReturnType(), F)); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3368 | if (const auto *FPT = dyn_cast<FunctionProtoType>(FnType)) |
| 3369 | for (QualType ParamType : FPT->param_types()) |
| 3370 | EltTys.push_back(getOrCreateType(ParamType, F)); |
Adrian Prantl | d45ba25 | 2014-02-25 19:38:11 +0000 | [diff] [blame] | 3371 | EltTys.push_back(DBuilder.createUnspecifiedParameter()); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3372 | llvm::DITypeRefArray EltTypeArray = DBuilder.getOrCreateTypeArray(EltTys); |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 3373 | return DBuilder.createSubroutineType(EltTypeArray, llvm::DINode::FlagZero, |
| 3374 | getDwarfCC(CC)); |
Adrian Prantl | d45ba25 | 2014-02-25 19:38:11 +0000 | [diff] [blame] | 3375 | } |
| 3376 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3377 | return cast<llvm::DISubroutineType>(getOrCreateType(FnType, F)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3378 | } |
| 3379 | |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3380 | void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, SourceLocation Loc, |
| 3381 | SourceLocation ScopeLoc, QualType FnType, |
Brock Wyma | 94ece8f | 2018-04-16 16:53:57 +0000 | [diff] [blame] | 3382 | llvm::Function *Fn, bool CurFuncIsThunk, |
| 3383 | CGBuilderTy &Builder) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3384 | |
| 3385 | StringRef Name; |
| 3386 | StringRef LinkageName; |
| 3387 | |
| 3388 | FnBeginRegionCount.push_back(LexicalBlockStack.size()); |
| 3389 | |
| 3390 | const Decl *D = GD.getDecl(); |
Craig Topper | 8a13c41 | 2014-05-21 05:09:00 +0000 | [diff] [blame] | 3391 | bool HasDecl = (D != nullptr); |
Eric Christopher | 885c41b | 2014-04-01 22:25:28 +0000 | [diff] [blame] | 3392 | |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 3393 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero; |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3394 | llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3395 | llvm::DIFile *Unit = getOrCreateFile(Loc); |
| 3396 | llvm::DIScope *FDContext = Unit; |
| 3397 | llvm::DINodeArray TParamsArray; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3398 | if (!HasDecl) { |
| 3399 | // Use llvm function name. |
David Blaikie | ebe87e1 | 2013-08-27 23:57:18 +0000 | [diff] [blame] | 3400 | LinkageName = Fn->getName(); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3401 | } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) { |
Duncan P. N. Exon Smith | a7fbcbf | 2015-04-20 22:09:57 +0000 | [diff] [blame] | 3402 | // If there is a subprogram for this function available then use it. |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3403 | auto FI = SPCache.find(FD->getCanonicalDecl()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3404 | if (FI != SPCache.end()) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3405 | auto *SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second); |
Duncan P. N. Exon Smith | 87afdeb | 2015-04-14 03:24:14 +0000 | [diff] [blame] | 3406 | if (SP && SP->isDefinition()) { |
Duncan P. N. Exon Smith | d899f6e | 2015-04-18 00:07:30 +0000 | [diff] [blame] | 3407 | LexicalBlockStack.emplace_back(SP); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3408 | RegionMap[D].reset(SP); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3409 | return; |
| 3410 | } |
| 3411 | } |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 3412 | collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext, |
| 3413 | TParamsArray, Flags); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3414 | } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3415 | Name = getObjCMethodName(OMD); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3416 | Flags |= llvm::DINode::FlagPrototyped; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3417 | } else { |
| 3418 | // Use llvm function name. |
| 3419 | Name = Fn->getName(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3420 | Flags |= llvm::DINode::FlagPrototyped; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3421 | } |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3422 | if (Name.startswith("\01")) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3423 | Name = Name.substr(1); |
| 3424 | |
Erich Keane | 293a055 | 2018-02-14 00:14:07 +0000 | [diff] [blame] | 3425 | if (!HasDecl || D->isImplicit() || D->hasAttr<ArtificialAttr>()) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3426 | Flags |= llvm::DINode::FlagArtificial; |
Adrian Prantl | db76357 | 2016-11-09 21:43:51 +0000 | [diff] [blame] | 3427 | // Artificial functions should not silently reuse CurLoc. |
| 3428 | CurLoc = SourceLocation(); |
Adrian Prantl | 42d71b9 | 2014-04-10 23:21:53 +0000 | [diff] [blame] | 3429 | } |
Brock Wyma | 94ece8f | 2018-04-16 16:53:57 +0000 | [diff] [blame] | 3430 | |
| 3431 | if (CurFuncIsThunk) |
| 3432 | Flags |= llvm::DINode::FlagThunk; |
| 3433 | |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3434 | if (Fn->hasLocalLinkage()) |
| 3435 | SPFlags |= llvm::DISubprogram::SPFlagLocalToUnit; |
| 3436 | if (CGM.getLangOpts().Optimize) |
| 3437 | SPFlags |= llvm::DISubprogram::SPFlagOptimized; |
| 3438 | |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 3439 | llvm::DINode::DIFlags FlagsForDef = Flags | getCallSiteRelatedAttrs(); |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3440 | llvm::DISubprogram::DISPFlags SPFlagsForDef = |
| 3441 | SPFlags | llvm::DISubprogram::SPFlagDefinition; |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 3442 | |
Adrian Prantl | 42d71b9 | 2014-04-10 23:21:53 +0000 | [diff] [blame] | 3443 | unsigned LineNo = getLineNumber(Loc); |
| 3444 | unsigned ScopeLine = getLineNumber(ScopeLoc); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3445 | |
Eric Christopher | 8018e41 | 2014-03-27 18:50:35 +0000 | [diff] [blame] | 3446 | // FIXME: The function declaration we're constructing here is mostly reusing |
| 3447 | // declarations from CXXMethodDecl and not constructing new ones for arbitrary |
| 3448 | // FunctionDecls. When/if we fix this we can have FDContext be TheCU/null for |
| 3449 | // all subprograms instead of the actual context since subprogram definitions |
| 3450 | // are emitted as CU level entities by the backend. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3451 | llvm::DISubprogram *SP = DBuilder.createFunction( |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3452 | FDContext, Name, LinkageName, Unit, LineNo, |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3453 | getOrCreateFunctionType(D, FnType, Unit), ScopeLine, FlagsForDef, |
| 3454 | SPFlagsForDef, TParamsArray.get(), getFunctionDeclaration(D)); |
Peter Collingbourne | 0900fe0 | 2015-11-05 22:04:14 +0000 | [diff] [blame] | 3455 | Fn->setSubprogram(SP); |
Frederic Riss | b1ab28c | 2014-11-05 19:19:04 +0000 | [diff] [blame] | 3456 | // We might get here with a VarDecl in the case we're generating |
| 3457 | // code for the initialization of globals. Do not record these decls |
| 3458 | // as they will overwrite the actual VarDecl Decl in the cache. |
| 3459 | if (HasDecl && isa<FunctionDecl>(D)) |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3460 | DeclCache[D->getCanonicalDecl()].reset(SP); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3461 | |
Jonas Devlieghere | d8ba8ae | 2018-06-27 17:31:59 +0000 | [diff] [blame] | 3462 | if (CGM.getCodeGenOpts().DwarfVersion >= 5) { |
| 3463 | // Starting with DWARF V5 method declarations are emitted as children of |
| 3464 | // the interface type. |
| 3465 | if (const auto *OMD = dyn_cast_or_null<ObjCMethodDecl>(D)) { |
| 3466 | const ObjCInterfaceDecl *ID = OMD->getClassInterface(); |
| 3467 | QualType QTy(ID->getTypeForDecl(), 0); |
| 3468 | auto It = TypeCache.find(QTy.getAsOpaquePtr()); |
| 3469 | if (It != TypeCache.end()) { |
| 3470 | llvm::DICompositeType *InterfaceDecl = |
| 3471 | cast<llvm::DICompositeType>(It->second); |
| 3472 | llvm::DISubprogram *FD = DBuilder.createFunction( |
| 3473 | InterfaceDecl, Name, LinkageName, Unit, LineNo, |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3474 | getOrCreateFunctionType(D, FnType, Unit), ScopeLine, Flags, SPFlags, |
Jonas Devlieghere | d8ba8ae | 2018-06-27 17:31:59 +0000 | [diff] [blame] | 3475 | TParamsArray.get()); |
| 3476 | DBuilder.finalizeSubprogram(FD); |
| 3477 | ObjCMethodCache[ID].push_back(FD); |
| 3478 | } |
| 3479 | } |
| 3480 | } |
| 3481 | |
Adrian Prantl | bebb893 | 2014-03-21 21:01:58 +0000 | [diff] [blame] | 3482 | // Push the function onto the lexical block stack. |
Duncan P. N. Exon Smith | d899f6e | 2015-04-18 00:07:30 +0000 | [diff] [blame] | 3483 | LexicalBlockStack.emplace_back(SP); |
Adrian Prantl | bebb893 | 2014-03-21 21:01:58 +0000 | [diff] [blame] | 3484 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3485 | if (HasDecl) |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3486 | RegionMap[D].reset(SP); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3487 | } |
| 3488 | |
Adrian Prantl | 748a6cd | 2015-09-08 20:41:52 +0000 | [diff] [blame] | 3489 | void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc, |
| 3490 | QualType FnType) { |
| 3491 | StringRef Name; |
| 3492 | StringRef LinkageName; |
| 3493 | |
| 3494 | const Decl *D = GD.getDecl(); |
| 3495 | if (!D) |
| 3496 | return; |
| 3497 | |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 3498 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero; |
Adrian Prantl | 748a6cd | 2015-09-08 20:41:52 +0000 | [diff] [blame] | 3499 | llvm::DIFile *Unit = getOrCreateFile(Loc); |
Adrian Prantl | f0cd677 | 2015-10-04 23:23:04 +0000 | [diff] [blame] | 3500 | llvm::DIScope *FDContext = getDeclContextDescriptor(D); |
Adrian Prantl | 748a6cd | 2015-09-08 20:41:52 +0000 | [diff] [blame] | 3501 | llvm::DINodeArray TParamsArray; |
| 3502 | if (isa<FunctionDecl>(D)) { |
| 3503 | // If there is a DISubprogram for this function available then use it. |
| 3504 | collectFunctionDeclProps(GD, Unit, Name, LinkageName, FDContext, |
| 3505 | TParamsArray, Flags); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3506 | } else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(D)) { |
Adrian Prantl | 748a6cd | 2015-09-08 20:41:52 +0000 | [diff] [blame] | 3507 | Name = getObjCMethodName(OMD); |
| 3508 | Flags |= llvm::DINode::FlagPrototyped; |
| 3509 | } else { |
| 3510 | llvm_unreachable("not a function or ObjC method"); |
| 3511 | } |
| 3512 | if (!Name.empty() && Name[0] == '\01') |
| 3513 | Name = Name.substr(1); |
| 3514 | |
| 3515 | if (D->isImplicit()) { |
| 3516 | Flags |= llvm::DINode::FlagArtificial; |
| 3517 | // Artificial functions without a location should not silently reuse CurLoc. |
| 3518 | if (Loc.isInvalid()) |
| 3519 | CurLoc = SourceLocation(); |
| 3520 | } |
| 3521 | unsigned LineNo = getLineNumber(Loc); |
| 3522 | unsigned ScopeLine = 0; |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3523 | llvm::DISubprogram::DISPFlags SPFlags = llvm::DISubprogram::SPFlagZero; |
| 3524 | if (CGM.getLangOpts().Optimize) |
| 3525 | SPFlags |= llvm::DISubprogram::SPFlagOptimized; |
Adrian Prantl | 748a6cd | 2015-09-08 20:41:52 +0000 | [diff] [blame] | 3526 | |
Adrian Prantl | e76bda5 | 2016-04-15 15:55:45 +0000 | [diff] [blame] | 3527 | DBuilder.retainType(DBuilder.createFunction( |
| 3528 | FDContext, Name, LinkageName, Unit, LineNo, |
Paul Robinson | cda5421 | 2018-11-19 18:29:28 +0000 | [diff] [blame] | 3529 | getOrCreateFunctionType(D, FnType, Unit), ScopeLine, Flags, SPFlags, |
Adrian Prantl | e76bda5 | 2016-04-15 15:55:45 +0000 | [diff] [blame] | 3530 | TParamsArray.get(), getFunctionDeclaration(D))); |
Adrian Prantl | 748a6cd | 2015-09-08 20:41:52 +0000 | [diff] [blame] | 3531 | } |
| 3532 | |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3533 | void CGDebugInfo::EmitInlineFunctionStart(CGBuilderTy &Builder, GlobalDecl GD) { |
| 3534 | const auto *FD = cast<FunctionDecl>(GD.getDecl()); |
| 3535 | // If there is a subprogram for this function available then use it. |
| 3536 | auto FI = SPCache.find(FD->getCanonicalDecl()); |
| 3537 | llvm::DISubprogram *SP = nullptr; |
| 3538 | if (FI != SPCache.end()) |
| 3539 | SP = dyn_cast_or_null<llvm::DISubprogram>(FI->second); |
Adrian Prantl | 8040a21 | 2017-08-23 21:24:12 +0000 | [diff] [blame] | 3540 | if (!SP || !SP->isDefinition()) |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3541 | SP = getFunctionStub(GD); |
| 3542 | FnBeginRegionCount.push_back(LexicalBlockStack.size()); |
| 3543 | LexicalBlockStack.emplace_back(SP); |
| 3544 | setInlinedAt(Builder.getCurrentDebugLocation()); |
| 3545 | EmitLocation(Builder, FD->getLocation()); |
| 3546 | } |
| 3547 | |
| 3548 | void CGDebugInfo::EmitInlineFunctionEnd(CGBuilderTy &Builder) { |
| 3549 | assert(CurInlinedAt && "unbalanced inline scope stack"); |
Keno Fischer | 41d4b4e | 2017-06-01 21:14:03 +0000 | [diff] [blame] | 3550 | EmitFunctionEnd(Builder, nullptr); |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3551 | setInlinedAt(llvm::DebugLoc(CurInlinedAt).getInlinedAt()); |
| 3552 | } |
| 3553 | |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 3554 | void CGDebugInfo::EmitLocation(CGBuilderTy &Builder, SourceLocation Loc) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3555 | // Update our current location |
| 3556 | setLocation(Loc); |
| 3557 | |
Adrian Prantl | 42ab39f | 2018-11-09 21:17:38 +0000 | [diff] [blame] | 3558 | if (CurLoc.isInvalid() || CurLoc.isMacroID() || LexicalBlockStack.empty()) |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3559 | return; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3560 | |
Adrian Prantl | e83b130 | 2014-01-07 22:05:52 +0000 | [diff] [blame] | 3561 | llvm::MDNode *Scope = LexicalBlockStack.back(); |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 3562 | Builder.SetCurrentDebugLocation(llvm::DebugLoc::get( |
| 3563 | getLineNumber(CurLoc), getColumnNumber(CurLoc), Scope, CurInlinedAt)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3564 | } |
| 3565 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3566 | void CGDebugInfo::CreateLexicalBlock(SourceLocation Loc) { |
Duncan P. N. Exon Smith | a66e305 | 2014-12-09 19:22:40 +0000 | [diff] [blame] | 3567 | llvm::MDNode *Back = nullptr; |
| 3568 | if (!LexicalBlockStack.empty()) |
| 3569 | Back = LexicalBlockStack.back().get(); |
Duncan P. N. Exon Smith | d899f6e | 2015-04-18 00:07:30 +0000 | [diff] [blame] | 3570 | LexicalBlockStack.emplace_back(DBuilder.createLexicalBlock( |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3571 | cast<llvm::DIScope>(Back), getOrCreateFile(CurLoc), getLineNumber(CurLoc), |
Duncan P. N. Exon Smith | d899f6e | 2015-04-18 00:07:30 +0000 | [diff] [blame] | 3572 | getColumnNumber(CurLoc))); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3573 | } |
| 3574 | |
Konstantin Zhuravlyov | 2b4917f | 2017-03-09 18:06:23 +0000 | [diff] [blame] | 3575 | void CGDebugInfo::AppendAddressSpaceXDeref( |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3576 | unsigned AddressSpace, SmallVectorImpl<int64_t> &Expr) const { |
Konstantin Zhuravlyov | 2b4917f | 2017-03-09 18:06:23 +0000 | [diff] [blame] | 3577 | Optional<unsigned> DWARFAddressSpace = |
| 3578 | CGM.getTarget().getDWARFAddressSpace(AddressSpace); |
| 3579 | if (!DWARFAddressSpace) |
| 3580 | return; |
| 3581 | |
| 3582 | Expr.push_back(llvm::dwarf::DW_OP_constu); |
| 3583 | Expr.push_back(DWARFAddressSpace.getValue()); |
| 3584 | Expr.push_back(llvm::dwarf::DW_OP_swap); |
| 3585 | Expr.push_back(llvm::dwarf::DW_OP_xderef); |
| 3586 | } |
| 3587 | |
Eric Christopher | 0fdcb31 | 2013-05-16 00:52:20 +0000 | [diff] [blame] | 3588 | void CGDebugInfo::EmitLexicalBlockStart(CGBuilderTy &Builder, |
| 3589 | SourceLocation Loc) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3590 | // Set our current location. |
| 3591 | setLocation(Loc); |
| 3592 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3593 | // Emit a line table change for the current location inside the new scope. |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3594 | Builder.SetCurrentDebugLocation( |
| 3595 | llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc), |
| 3596 | LexicalBlockStack.back(), CurInlinedAt)); |
David Blaikie | 60a877b | 2014-10-22 19:34:33 +0000 | [diff] [blame] | 3597 | |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3598 | if (DebugKind <= codegenoptions::DebugLineTablesOnly) |
David Blaikie | 60a877b | 2014-10-22 19:34:33 +0000 | [diff] [blame] | 3599 | return; |
| 3600 | |
| 3601 | // Create a new lexical block and push it on the stack. |
| 3602 | CreateLexicalBlock(Loc); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3603 | } |
| 3604 | |
Eric Christopher | 0fdcb31 | 2013-05-16 00:52:20 +0000 | [diff] [blame] | 3605 | void CGDebugInfo::EmitLexicalBlockEnd(CGBuilderTy &Builder, |
| 3606 | SourceLocation Loc) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3607 | assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"); |
| 3608 | |
| 3609 | // Provide an entry in the line table for the end of the block. |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 3610 | EmitLocation(Builder, Loc); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3611 | |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3612 | if (DebugKind <= codegenoptions::DebugLineTablesOnly) |
David Blaikie | 60a877b | 2014-10-22 19:34:33 +0000 | [diff] [blame] | 3613 | return; |
| 3614 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3615 | LexicalBlockStack.pop_back(); |
| 3616 | } |
| 3617 | |
Keno Fischer | 41d4b4e | 2017-06-01 21:14:03 +0000 | [diff] [blame] | 3618 | void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3619 | assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"); |
| 3620 | unsigned RCount = FnBeginRegionCount.back(); |
| 3621 | assert(RCount <= LexicalBlockStack.size() && "Region stack mismatch"); |
| 3622 | |
| 3623 | // Pop all regions for this function. |
David Blaikie | 60a877b | 2014-10-22 19:34:33 +0000 | [diff] [blame] | 3624 | while (LexicalBlockStack.size() != RCount) { |
| 3625 | // Provide an entry in the line table for the end of the block. |
Calixte Denizet | fcd661d | 2018-09-24 18:24:18 +0000 | [diff] [blame] | 3626 | EmitLocation(Builder, CurLoc); |
David Blaikie | 60a877b | 2014-10-22 19:34:33 +0000 | [diff] [blame] | 3627 | LexicalBlockStack.pop_back(); |
| 3628 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3629 | FnBeginRegionCount.pop_back(); |
Keno Fischer | 41d4b4e | 2017-06-01 21:14:03 +0000 | [diff] [blame] | 3630 | |
| 3631 | if (Fn && Fn->getSubprogram()) |
| 3632 | DBuilder.finalizeSubprogram(Fn->getSubprogram()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3633 | } |
| 3634 | |
Adrian Prantl | 05a623e | 2018-09-10 16:14:28 +0000 | [diff] [blame] | 3635 | CGDebugInfo::BlockByRefType |
| 3636 | CGDebugInfo::EmitTypeForVarWithBlocksAttr(const VarDecl *VD, |
| 3637 | uint64_t *XOffset) { |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3638 | SmallVector<llvm::Metadata *, 5> EltTys; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3639 | QualType FType; |
| 3640 | uint64_t FieldSize, FieldOffset; |
Victor Leschuk | 802e4a5 | 2016-10-19 22:11:07 +0000 | [diff] [blame] | 3641 | uint32_t FieldAlign; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3642 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3643 | llvm::DIFile *Unit = getOrCreateFile(VD->getLocation()); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3644 | QualType Type = VD->getType(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3645 | |
| 3646 | FieldOffset = 0; |
| 3647 | FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); |
| 3648 | EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset)); |
| 3649 | EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset)); |
| 3650 | FType = CGM.getContext().IntTy; |
| 3651 | EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset)); |
| 3652 | EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset)); |
| 3653 | |
| 3654 | bool HasCopyAndDispose = CGM.getContext().BlockRequiresCopying(Type, VD); |
| 3655 | if (HasCopyAndDispose) { |
| 3656 | FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3657 | EltTys.push_back( |
| 3658 | CreateMemberType(Unit, FType, "__copy_helper", &FieldOffset)); |
| 3659 | EltTys.push_back( |
| 3660 | CreateMemberType(Unit, FType, "__destroy_helper", &FieldOffset)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3661 | } |
| 3662 | bool HasByrefExtendedLayout; |
| 3663 | Qualifiers::ObjCLifetime Lifetime; |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3664 | if (CGM.getContext().getByrefLifetime(Type, Lifetime, |
| 3665 | HasByrefExtendedLayout) && |
| 3666 | HasByrefExtendedLayout) { |
Adrian Prantl | ead2ba4 | 2013-07-23 00:12:14 +0000 | [diff] [blame] | 3667 | FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3668 | EltTys.push_back( |
| 3669 | CreateMemberType(Unit, FType, "__byref_variable_layout", &FieldOffset)); |
Adrian Prantl | ead2ba4 | 2013-07-23 00:12:14 +0000 | [diff] [blame] | 3670 | } |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3671 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3672 | CharUnits Align = CGM.getContext().getDeclAlign(VD); |
| 3673 | if (Align > CGM.getContext().toCharUnitsFromBits( |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3674 | CGM.getTarget().getPointerAlign(0))) { |
| 3675 | CharUnits FieldOffsetInBytes = |
| 3676 | CGM.getContext().toCharUnitsFromBits(FieldOffset); |
Rui Ueyama | 83aa979 | 2016-01-14 21:00:27 +0000 | [diff] [blame] | 3677 | CharUnits AlignedOffsetInBytes = FieldOffsetInBytes.alignTo(Align); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3678 | CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3679 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3680 | if (NumPaddingBytes.isPositive()) { |
| 3681 | llvm::APInt pad(32, NumPaddingBytes.getQuantity()); |
| 3682 | FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy, |
| 3683 | pad, ArrayType::Normal, 0); |
| 3684 | EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset)); |
| 3685 | } |
| 3686 | } |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3687 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3688 | FType = Type; |
Adrian Prantl | 05a623e | 2018-09-10 16:14:28 +0000 | [diff] [blame] | 3689 | llvm::DIType *WrappedTy = getOrCreateType(FType, Unit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3690 | FieldSize = CGM.getContext().getTypeSize(FType); |
| 3691 | FieldAlign = CGM.getContext().toBits(Align); |
| 3692 | |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3693 | *XOffset = FieldOffset; |
Adrian Prantl | 05a623e | 2018-09-10 16:14:28 +0000 | [diff] [blame] | 3694 | llvm::DIType *FieldTy = DBuilder.createMemberType( |
| 3695 | Unit, VD->getName(), Unit, 0, FieldSize, FieldAlign, FieldOffset, |
| 3696 | llvm::DINode::FlagZero, WrappedTy); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3697 | EltTys.push_back(FieldTy); |
| 3698 | FieldOffset += FieldSize; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3699 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3700 | llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys); |
Adrian Prantl | 05a623e | 2018-09-10 16:14:28 +0000 | [diff] [blame] | 3701 | return {DBuilder.createStructType(Unit, "", Unit, 0, FieldOffset, 0, |
| 3702 | llvm::DINode::FlagZero, nullptr, Elements), |
| 3703 | WrappedTy}; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3704 | } |
| 3705 | |
Sander de Smalen | 891af03a | 2018-02-03 13:55:59 +0000 | [diff] [blame] | 3706 | llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const VarDecl *VD, |
| 3707 | llvm::Value *Storage, |
| 3708 | llvm::Optional<unsigned> ArgNo, |
| 3709 | CGBuilderTy &Builder) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3710 | assert(DebugKind >= codegenoptions::LimitedDebugInfo); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3711 | assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"); |
Paul Robinson | afd2dde | 2016-06-16 00:42:36 +0000 | [diff] [blame] | 3712 | if (VD->hasAttr<NoDebugAttr>()) |
Sander de Smalen | 891af03a | 2018-02-03 13:55:59 +0000 | [diff] [blame] | 3713 | return nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3714 | |
David Blaikie | 7fceebf | 2013-08-19 03:37:48 +0000 | [diff] [blame] | 3715 | bool Unwritten = |
| 3716 | VD->isImplicit() || (isa<Decl>(VD->getDeclContext()) && |
| 3717 | cast<Decl>(VD->getDeclContext())->isImplicit()); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3718 | llvm::DIFile *Unit = nullptr; |
David Blaikie | 7fceebf | 2013-08-19 03:37:48 +0000 | [diff] [blame] | 3719 | if (!Unwritten) |
| 3720 | Unit = getOrCreateFile(VD->getLocation()); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3721 | llvm::DIType *Ty; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3722 | uint64_t XOffset = 0; |
| 3723 | if (VD->hasAttr<BlocksAttr>()) |
Adrian Prantl | 05a623e | 2018-09-10 16:14:28 +0000 | [diff] [blame] | 3724 | Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3725 | else |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3726 | Ty = getOrCreateType(VD->getType(), Unit); |
| 3727 | |
| 3728 | // If there is no debug info for this type then do not emit debug info |
| 3729 | // for this variable. |
| 3730 | if (!Ty) |
Sander de Smalen | 891af03a | 2018-02-03 13:55:59 +0000 | [diff] [blame] | 3731 | return nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3732 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3733 | // Get location information. |
David Blaikie | 7fceebf | 2013-08-19 03:37:48 +0000 | [diff] [blame] | 3734 | unsigned Line = 0; |
| 3735 | unsigned Column = 0; |
| 3736 | if (!Unwritten) { |
| 3737 | Line = getLineNumber(VD->getLocation()); |
| 3738 | Column = getColumnNumber(VD->getLocation()); |
| 3739 | } |
Konstantin Zhuravlyov | 2b4917f | 2017-03-09 18:06:23 +0000 | [diff] [blame] | 3740 | SmallVector<int64_t, 13> Expr; |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 3741 | llvm::DINode::DIFlags Flags = llvm::DINode::FlagZero; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3742 | if (VD->isImplicit()) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3743 | Flags |= llvm::DINode::FlagArtificial; |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 3744 | |
| 3745 | auto Align = getDeclAlignIfRequired(VD, CGM.getContext()); |
| 3746 | |
Konstantin Zhuravlyov | 2b4917f | 2017-03-09 18:06:23 +0000 | [diff] [blame] | 3747 | unsigned AddressSpace = CGM.getContext().getTargetAddressSpace(VD->getType()); |
| 3748 | AppendAddressSpaceXDeref(AddressSpace, Expr); |
| 3749 | |
Alexey Bataev | 24f71018 | 2017-06-09 13:55:08 +0000 | [diff] [blame] | 3750 | // If this is implicit parameter of CXXThis or ObjCSelf kind, then give it an |
| 3751 | // object pointer flag. |
Alexey Bataev | 5622323 | 2017-06-09 13:40:18 +0000 | [diff] [blame] | 3752 | if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) { |
| 3753 | if (IPD->getParameterKind() == ImplicitParamDecl::CXXThis || |
| 3754 | IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf) |
| 3755 | Flags |= llvm::DINode::FlagObjectPointer; |
| 3756 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3757 | |
Adrian Prantl | c3782a1 | 2017-04-18 01:22:01 +0000 | [diff] [blame] | 3758 | // Note: Older versions of clang used to emit byval references with an extra |
| 3759 | // DW_OP_deref, because they referenced the IR arg directly instead of |
| 3760 | // referencing an alloca. Newer versions of LLVM don't treat allocas |
| 3761 | // differently from other function arguments when used in a dbg.declare. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3762 | auto *Scope = cast<llvm::DIScope>(LexicalBlockStack.back()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3763 | StringRef Name = VD->getName(); |
| 3764 | if (!Name.empty()) { |
| 3765 | if (VD->hasAttr<BlocksAttr>()) { |
Adrian Prantl | c3782a1 | 2017-04-18 01:22:01 +0000 | [diff] [blame] | 3766 | // Here, we need an offset *into* the alloca. |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3767 | CharUnits offset = CharUnits::fromQuantity(32); |
Florian Hahn | 3dbcced | 2017-06-13 18:06:15 +0000 | [diff] [blame] | 3768 | Expr.push_back(llvm::dwarf::DW_OP_plus_uconst); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3769 | // offset of __forwarding field |
| 3770 | offset = CGM.getContext().toCharUnitsFromBits( |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3771 | CGM.getTarget().getPointerWidth(0)); |
Adrian Prantl | 7c6f944 | 2015-01-19 17:51:58 +0000 | [diff] [blame] | 3772 | Expr.push_back(offset.getQuantity()); |
| 3773 | Expr.push_back(llvm::dwarf::DW_OP_deref); |
Florian Hahn | 3dbcced | 2017-06-13 18:06:15 +0000 | [diff] [blame] | 3774 | Expr.push_back(llvm::dwarf::DW_OP_plus_uconst); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3775 | // offset of x field |
| 3776 | offset = CGM.getContext().toCharUnitsFromBits(XOffset); |
Adrian Prantl | 7c6f944 | 2015-01-19 17:51:58 +0000 | [diff] [blame] | 3777 | Expr.push_back(offset.getQuantity()); |
Adrian Prantl | c3782a1 | 2017-04-18 01:22:01 +0000 | [diff] [blame] | 3778 | } |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 3779 | } else if (const auto *RT = dyn_cast<RecordType>(VD->getType())) { |
Adrian Prantl | 0d82089 | 2015-04-29 15:05:50 +0000 | [diff] [blame] | 3780 | // If VD is an anonymous union then Storage represents value for |
| 3781 | // all union fields. |
George Burgess IV | 00f70bd | 2018-03-01 05:43:23 +0000 | [diff] [blame] | 3782 | const RecordDecl *RD = RT->getDecl(); |
Adrian Prantl | 0d82089 | 2015-04-29 15:05:50 +0000 | [diff] [blame] | 3783 | if (RD->isUnion() && RD->isAnonymousStructOrUnion()) { |
Adrian Prantl | 00820ab | 2015-04-29 16:52:31 +0000 | [diff] [blame] | 3784 | // GDB has trouble finding local variables in anonymous unions, so we emit |
Alexander Kornienko | 2a8c18d | 2018-04-06 15:14:32 +0000 | [diff] [blame] | 3785 | // artificial local variables for each of the members. |
Adrian Prantl | 00820ab | 2015-04-29 16:52:31 +0000 | [diff] [blame] | 3786 | // |
| 3787 | // FIXME: Remove this code as soon as GDB supports this. |
| 3788 | // The debug info verifier in LLVM operates based on the assumption that a |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3789 | // variable has the same size as its storage and we had to disable the |
| 3790 | // check for artificial variables. |
Adrian Prantl | 0d82089 | 2015-04-29 15:05:50 +0000 | [diff] [blame] | 3791 | for (const auto *Field : RD->fields()) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3792 | llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit); |
Adrian Prantl | 0d82089 | 2015-04-29 15:05:50 +0000 | [diff] [blame] | 3793 | StringRef FieldName = Field->getName(); |
| 3794 | |
| 3795 | // Ignore unnamed fields. Do not ignore unnamed records. |
| 3796 | if (FieldName.empty() && !isa<RecordType>(Field->getType())) |
| 3797 | continue; |
| 3798 | |
| 3799 | // Use VarDecl's Tag, Scope and Line number. |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 3800 | auto FieldAlign = getDeclAlignIfRequired(Field, CGM.getContext()); |
Duncan P. N. Exon Smith | e430654 | 2015-07-31 17:56:14 +0000 | [diff] [blame] | 3801 | auto *D = DBuilder.createAutoVariable( |
| 3802 | Scope, FieldName, Unit, Line, FieldTy, CGM.getLangOpts().Optimize, |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 3803 | Flags | llvm::DINode::FlagArtificial, FieldAlign); |
Adrian Prantl | 0d82089 | 2015-04-29 15:05:50 +0000 | [diff] [blame] | 3804 | |
| 3805 | // Insert an llvm.dbg.declare into the current block. |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3806 | DBuilder.insertDeclare( |
| 3807 | Storage, D, DBuilder.createExpression(Expr), |
| 3808 | llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt), |
| 3809 | Builder.GetInsertBlock()); |
Adrian Prantl | 0d82089 | 2015-04-29 15:05:50 +0000 | [diff] [blame] | 3810 | } |
Adrian Prantl | 0d82089 | 2015-04-29 15:05:50 +0000 | [diff] [blame] | 3811 | } |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3812 | } |
David Blaikie | a76a7c9 | 2013-01-05 05:58:35 +0000 | [diff] [blame] | 3813 | |
| 3814 | // Create the descriptor for the variable. |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3815 | auto *D = ArgNo ? DBuilder.createParameterVariable( |
| 3816 | Scope, Name, *ArgNo, Unit, Line, Ty, |
| 3817 | CGM.getLangOpts().Optimize, Flags) |
| 3818 | : DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty, |
| 3819 | CGM.getLangOpts().Optimize, |
| 3820 | Flags, Align); |
David Blaikie | a76a7c9 | 2013-01-05 05:58:35 +0000 | [diff] [blame] | 3821 | |
| 3822 | // Insert an llvm.dbg.declare into the current block. |
Duncan P. N. Exon Smith | fe88b48 | 2015-04-15 21:18:30 +0000 | [diff] [blame] | 3823 | DBuilder.insertDeclare(Storage, D, DBuilder.createExpression(Expr), |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3824 | llvm::DebugLoc::get(Line, Column, Scope, CurInlinedAt), |
Duncan P. N. Exon Smith | fe88b48 | 2015-04-15 21:18:30 +0000 | [diff] [blame] | 3825 | Builder.GetInsertBlock()); |
Sander de Smalen | 891af03a | 2018-02-03 13:55:59 +0000 | [diff] [blame] | 3826 | |
| 3827 | return D; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3828 | } |
| 3829 | |
Sander de Smalen | 891af03a | 2018-02-03 13:55:59 +0000 | [diff] [blame] | 3830 | llvm::DILocalVariable * |
| 3831 | CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD, llvm::Value *Storage, |
| 3832 | CGBuilderTy &Builder) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3833 | assert(DebugKind >= codegenoptions::LimitedDebugInfo); |
Sander de Smalen | 891af03a | 2018-02-03 13:55:59 +0000 | [diff] [blame] | 3834 | return EmitDeclare(VD, Storage, llvm::None, Builder); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3835 | } |
| 3836 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3837 | llvm::DIType *CGDebugInfo::CreateSelfType(const QualType &QualTy, |
| 3838 | llvm::DIType *Ty) { |
| 3839 | llvm::DIType *CachedTy = getTypeOrNull(QualTy); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3840 | if (CachedTy) |
| 3841 | Ty = CachedTy; |
Adrian Prantl | de17db3 | 2013-03-29 19:20:29 +0000 | [diff] [blame] | 3842 | return DBuilder.createObjectPointerType(Ty); |
| 3843 | } |
| 3844 | |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3845 | void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable( |
| 3846 | const VarDecl *VD, llvm::Value *Storage, CGBuilderTy &Builder, |
Adrian Prantl | 88eec39 | 2014-11-21 00:35:25 +0000 | [diff] [blame] | 3847 | const CGBlockInfo &blockInfo, llvm::Instruction *InsertPoint) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3848 | assert(DebugKind >= codegenoptions::LimitedDebugInfo); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3849 | assert(!LexicalBlockStack.empty() && "Region stack mismatch, stack empty!"); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3850 | |
Craig Topper | 8a13c41 | 2014-05-21 05:09:00 +0000 | [diff] [blame] | 3851 | if (Builder.GetInsertBlock() == nullptr) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3852 | return; |
Paul Robinson | afd2dde | 2016-06-16 00:42:36 +0000 | [diff] [blame] | 3853 | if (VD->hasAttr<NoDebugAttr>()) |
| 3854 | return; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3855 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3856 | bool isByRef = VD->hasAttr<BlocksAttr>(); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3857 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3858 | uint64_t XOffset = 0; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3859 | llvm::DIFile *Unit = getOrCreateFile(VD->getLocation()); |
| 3860 | llvm::DIType *Ty; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3861 | if (isByRef) |
Adrian Prantl | 05a623e | 2018-09-10 16:14:28 +0000 | [diff] [blame] | 3862 | Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset).WrappedType; |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3863 | else |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3864 | Ty = getOrCreateType(VD->getType(), Unit); |
| 3865 | |
| 3866 | // Self is passed along as an implicit non-arg variable in a |
| 3867 | // block. Mark it as the object pointer. |
Alexey Bataev | 5622323 | 2017-06-09 13:40:18 +0000 | [diff] [blame] | 3868 | if (const auto *IPD = dyn_cast<ImplicitParamDecl>(VD)) |
| 3869 | if (IPD->getParameterKind() == ImplicitParamDecl::ObjCSelf) |
| 3870 | Ty = CreateSelfType(VD->getType(), Ty); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3871 | |
| 3872 | // Get location information. |
| 3873 | unsigned Line = getLineNumber(VD->getLocation()); |
| 3874 | unsigned Column = getColumnNumber(VD->getLocation()); |
| 3875 | |
| 3876 | const llvm::DataLayout &target = CGM.getDataLayout(); |
| 3877 | |
| 3878 | CharUnits offset = CharUnits::fromQuantity( |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3879 | target.getStructLayout(blockInfo.StructureType) |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3880 | ->getElementOffset(blockInfo.getCapture(VD).getIndex())); |
| 3881 | |
Duncan P. N. Exon Smith | f3dc429 | 2014-10-01 20:26:18 +0000 | [diff] [blame] | 3882 | SmallVector<int64_t, 9> addr; |
Adrian Prantl | c3782a1 | 2017-04-18 01:22:01 +0000 | [diff] [blame] | 3883 | addr.push_back(llvm::dwarf::DW_OP_deref); |
Florian Hahn | 3dbcced | 2017-06-13 18:06:15 +0000 | [diff] [blame] | 3884 | addr.push_back(llvm::dwarf::DW_OP_plus_uconst); |
Duncan P. N. Exon Smith | f3dc429 | 2014-10-01 20:26:18 +0000 | [diff] [blame] | 3885 | addr.push_back(offset.getQuantity()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3886 | if (isByRef) { |
Duncan P. N. Exon Smith | f3dc429 | 2014-10-01 20:26:18 +0000 | [diff] [blame] | 3887 | addr.push_back(llvm::dwarf::DW_OP_deref); |
Florian Hahn | 3dbcced | 2017-06-13 18:06:15 +0000 | [diff] [blame] | 3888 | addr.push_back(llvm::dwarf::DW_OP_plus_uconst); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3889 | // offset of __forwarding field |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3890 | offset = |
| 3891 | CGM.getContext().toCharUnitsFromBits(target.getPointerSizeInBits(0)); |
Duncan P. N. Exon Smith | f3dc429 | 2014-10-01 20:26:18 +0000 | [diff] [blame] | 3892 | addr.push_back(offset.getQuantity()); |
| 3893 | addr.push_back(llvm::dwarf::DW_OP_deref); |
Florian Hahn | 3dbcced | 2017-06-13 18:06:15 +0000 | [diff] [blame] | 3894 | addr.push_back(llvm::dwarf::DW_OP_plus_uconst); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3895 | // offset of x field |
| 3896 | offset = CGM.getContext().toCharUnitsFromBits(XOffset); |
Duncan P. N. Exon Smith | f3dc429 | 2014-10-01 20:26:18 +0000 | [diff] [blame] | 3897 | addr.push_back(offset.getQuantity()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3898 | } |
| 3899 | |
| 3900 | // Create the descriptor for the variable. |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 3901 | auto Align = getDeclAlignIfRequired(VD, CGM.getContext()); |
Duncan P. N. Exon Smith | e430654 | 2015-07-31 17:56:14 +0000 | [diff] [blame] | 3902 | auto *D = DBuilder.createAutoVariable( |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3903 | cast<llvm::DILocalScope>(LexicalBlockStack.back()), VD->getName(), Unit, |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 3904 | Line, Ty, false, llvm::DINode::FlagZero, Align); |
Adrian Prantl | 0f6df00 | 2013-03-29 19:20:35 +0000 | [diff] [blame] | 3905 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3906 | // Insert an llvm.dbg.declare into the current block. |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 3907 | auto DL = |
| 3908 | llvm::DebugLoc::get(Line, Column, LexicalBlockStack.back(), CurInlinedAt); |
Adrian Prantl | c3782a1 | 2017-04-18 01:22:01 +0000 | [diff] [blame] | 3909 | auto *Expr = DBuilder.createExpression(addr); |
Duncan P. N. Exon Smith | fe88b48 | 2015-04-15 21:18:30 +0000 | [diff] [blame] | 3910 | if (InsertPoint) |
Adrian Prantl | c3782a1 | 2017-04-18 01:22:01 +0000 | [diff] [blame] | 3911 | DBuilder.insertDeclare(Storage, D, Expr, DL, InsertPoint); |
Duncan P. N. Exon Smith | fe88b48 | 2015-04-15 21:18:30 +0000 | [diff] [blame] | 3912 | else |
Adrian Prantl | c3782a1 | 2017-04-18 01:22:01 +0000 | [diff] [blame] | 3913 | DBuilder.insertDeclare(Storage, D, Expr, DL, Builder.GetInsertBlock()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3914 | } |
| 3915 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3916 | void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI, |
| 3917 | unsigned ArgNo, |
| 3918 | CGBuilderTy &Builder) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3919 | assert(DebugKind >= codegenoptions::LimitedDebugInfo); |
Duncan P. N. Exon Smith | e430654 | 2015-07-31 17:56:14 +0000 | [diff] [blame] | 3920 | EmitDeclare(VD, AI, ArgNo, Builder); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3921 | } |
| 3922 | |
| 3923 | namespace { |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3924 | struct BlockLayoutChunk { |
| 3925 | uint64_t OffsetInBits; |
| 3926 | const BlockDecl::Capture *Capture; |
| 3927 | }; |
| 3928 | bool operator<(const BlockLayoutChunk &l, const BlockLayoutChunk &r) { |
| 3929 | return l.OffsetInBits < r.OffsetInBits; |
| 3930 | } |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 3931 | } // namespace |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3932 | |
Scott Linder | 58df0e4 | 2018-08-08 15:56:12 +0000 | [diff] [blame] | 3933 | void CGDebugInfo::collectDefaultFieldsForBlockLiteralDeclare( |
| 3934 | const CGBlockInfo &Block, const ASTContext &Context, SourceLocation Loc, |
| 3935 | const llvm::StructLayout &BlockLayout, llvm::DIFile *Unit, |
| 3936 | SmallVectorImpl<llvm::Metadata *> &Fields) { |
| 3937 | // Blocks in OpenCL have unique constraints which make the standard fields |
| 3938 | // redundant while requiring size and align fields for enqueue_kernel. See |
| 3939 | // initializeForBlockHeader in CGBlocks.cpp |
| 3940 | if (CGM.getLangOpts().OpenCL) { |
| 3941 | Fields.push_back(createFieldType("__size", Context.IntTy, Loc, AS_public, |
| 3942 | BlockLayout.getElementOffsetInBits(0), |
| 3943 | Unit, Unit)); |
| 3944 | Fields.push_back(createFieldType("__align", Context.IntTy, Loc, AS_public, |
| 3945 | BlockLayout.getElementOffsetInBits(1), |
| 3946 | Unit, Unit)); |
| 3947 | } else { |
| 3948 | Fields.push_back(createFieldType("__isa", Context.VoidPtrTy, Loc, AS_public, |
| 3949 | BlockLayout.getElementOffsetInBits(0), |
| 3950 | Unit, Unit)); |
| 3951 | Fields.push_back(createFieldType("__flags", Context.IntTy, Loc, AS_public, |
| 3952 | BlockLayout.getElementOffsetInBits(1), |
| 3953 | Unit, Unit)); |
| 3954 | Fields.push_back( |
| 3955 | createFieldType("__reserved", Context.IntTy, Loc, AS_public, |
| 3956 | BlockLayout.getElementOffsetInBits(2), Unit, Unit)); |
| 3957 | auto *FnTy = Block.getBlockExpr()->getFunctionType(); |
| 3958 | auto FnPtrType = CGM.getContext().getPointerType(FnTy->desugar()); |
| 3959 | Fields.push_back(createFieldType("__FuncPtr", FnPtrType, Loc, AS_public, |
| 3960 | BlockLayout.getElementOffsetInBits(3), |
| 3961 | Unit, Unit)); |
| 3962 | Fields.push_back(createFieldType( |
| 3963 | "__descriptor", |
| 3964 | Context.getPointerType(Block.NeedsCopyDispose |
| 3965 | ? Context.getBlockDescriptorExtendedType() |
| 3966 | : Context.getBlockDescriptorType()), |
| 3967 | Loc, AS_public, BlockLayout.getElementOffsetInBits(4), Unit, Unit)); |
| 3968 | } |
| 3969 | } |
| 3970 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3971 | void CGDebugInfo::EmitDeclareOfBlockLiteralArgVariable(const CGBlockInfo &block, |
Adrian Prantl | 356347b | 2017-10-26 20:08:52 +0000 | [diff] [blame] | 3972 | StringRef Name, |
David Blaikie | 77bbb5f | 2014-08-08 17:10:14 +0000 | [diff] [blame] | 3973 | unsigned ArgNo, |
Adrian Prantl | 356347b | 2017-10-26 20:08:52 +0000 | [diff] [blame] | 3974 | llvm::AllocaInst *Alloca, |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3975 | CGBuilderTy &Builder) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 3976 | assert(DebugKind >= codegenoptions::LimitedDebugInfo); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3977 | ASTContext &C = CGM.getContext(); |
| 3978 | const BlockDecl *blockDecl = block.getBlockDecl(); |
| 3979 | |
| 3980 | // Collect some general information about the block's location. |
| 3981 | SourceLocation loc = blockDecl->getCaretLocation(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 3982 | llvm::DIFile *tunit = getOrCreateFile(loc); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3983 | unsigned line = getLineNumber(loc); |
| 3984 | unsigned column = getColumnNumber(loc); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 3985 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3986 | // Build the debug-info type for the block literal. |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 3987 | getDeclContextDescriptor(blockDecl); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3988 | |
| 3989 | const llvm::StructLayout *blockLayout = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 3990 | CGM.getDataLayout().getStructLayout(block.StructureType); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3991 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 3992 | SmallVector<llvm::Metadata *, 16> fields; |
Scott Linder | 58df0e4 | 2018-08-08 15:56:12 +0000 | [diff] [blame] | 3993 | collectDefaultFieldsForBlockLiteralDeclare(block, C, loc, *blockLayout, tunit, |
| 3994 | fields); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 3995 | |
| 3996 | // We want to sort the captures by offset, not because DWARF |
| 3997 | // requires this, but because we're paranoid about debuggers. |
| 3998 | SmallVector<BlockLayoutChunk, 8> chunks; |
| 3999 | |
| 4000 | // 'this' capture. |
| 4001 | if (blockDecl->capturesCXXThis()) { |
| 4002 | BlockLayoutChunk chunk; |
| 4003 | chunk.OffsetInBits = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 4004 | blockLayout->getElementOffsetInBits(block.CXXThisIndex); |
Craig Topper | 8a13c41 | 2014-05-21 05:09:00 +0000 | [diff] [blame] | 4005 | chunk.Capture = nullptr; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4006 | chunks.push_back(chunk); |
| 4007 | } |
| 4008 | |
| 4009 | // Variable captures. |
Aaron Ballman | 9371dd2 | 2014-03-14 18:34:04 +0000 | [diff] [blame] | 4010 | for (const auto &capture : blockDecl->captures()) { |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4011 | const VarDecl *variable = capture.getVariable(); |
| 4012 | const CGBlockInfo::Capture &captureInfo = block.getCapture(variable); |
| 4013 | |
| 4014 | // Ignore constant captures. |
| 4015 | if (captureInfo.isConstant()) |
| 4016 | continue; |
| 4017 | |
| 4018 | BlockLayoutChunk chunk; |
| 4019 | chunk.OffsetInBits = |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 4020 | blockLayout->getElementOffsetInBits(captureInfo.getIndex()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4021 | chunk.Capture = &capture; |
| 4022 | chunks.push_back(chunk); |
| 4023 | } |
| 4024 | |
| 4025 | // Sort by offset. |
| 4026 | llvm::array_pod_sort(chunks.begin(), chunks.end()); |
| 4027 | |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 4028 | for (const BlockLayoutChunk &Chunk : chunks) { |
| 4029 | uint64_t offsetInBits = Chunk.OffsetInBits; |
| 4030 | const BlockDecl::Capture *capture = Chunk.Capture; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4031 | |
| 4032 | // If we have a null capture, this must be the C++ 'this' capture. |
| 4033 | if (!capture) { |
Adrian Prantl | 2526fca | 2016-04-18 23:48:16 +0000 | [diff] [blame] | 4034 | QualType type; |
| 4035 | if (auto *Method = |
| 4036 | cast_or_null<CXXMethodDecl>(blockDecl->getNonClosureContext())) |
| 4037 | type = Method->getThisType(C); |
| 4038 | else if (auto *RDecl = dyn_cast<CXXRecordDecl>(blockDecl->getParent())) |
| 4039 | type = QualType(RDecl->getTypeForDecl(), 0); |
| 4040 | else |
| 4041 | llvm_unreachable("unexpected block declcontext"); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4042 | |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 4043 | fields.push_back(createFieldType("this", type, loc, AS_public, |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4044 | offsetInBits, tunit, tunit)); |
| 4045 | continue; |
| 4046 | } |
| 4047 | |
| 4048 | const VarDecl *variable = capture->getVariable(); |
| 4049 | StringRef name = variable->getName(); |
| 4050 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4051 | llvm::DIType *fieldType; |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4052 | if (capture->isByRef()) { |
David Majnemer | 34b5749 | 2014-07-30 01:30:47 +0000 | [diff] [blame] | 4053 | TypeInfo PtrInfo = C.getTypeInfo(C.VoidPtrTy); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 4054 | auto Align = PtrInfo.AlignIsRequired ? PtrInfo.Align : 0; |
Adrian Prantl | 05a623e | 2018-09-10 16:14:28 +0000 | [diff] [blame] | 4055 | // FIXME: This recomputes the layout of the BlockByRefWrapper. |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4056 | uint64_t xoffset; |
Adrian Prantl | 05a623e | 2018-09-10 16:14:28 +0000 | [diff] [blame] | 4057 | fieldType = |
| 4058 | EmitTypeForVarWithBlocksAttr(variable, &xoffset).BlockByRefWrapper; |
David Majnemer | 34b5749 | 2014-07-30 01:30:47 +0000 | [diff] [blame] | 4059 | fieldType = DBuilder.createPointerType(fieldType, PtrInfo.Width); |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 4060 | fieldType = DBuilder.createMemberType(tunit, name, tunit, line, |
| 4061 | PtrInfo.Width, Align, offsetInBits, |
| 4062 | llvm::DINode::FlagZero, fieldType); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4063 | } else { |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 4064 | auto Align = getDeclAlignIfRequired(variable, CGM.getContext()); |
David Majnemer | b4b671e | 2016-06-30 03:01:59 +0000 | [diff] [blame] | 4065 | fieldType = createFieldType(name, variable->getType(), loc, AS_public, |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 4066 | offsetInBits, Align, tunit, tunit); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4067 | } |
| 4068 | fields.push_back(fieldType); |
| 4069 | } |
| 4070 | |
| 4071 | SmallString<36> typeName; |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4072 | llvm::raw_svector_ostream(typeName) |
| 4073 | << "__block_literal_" << CGM.getUniqueBlockCount(); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4074 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4075 | llvm::DINodeArray fieldsArray = DBuilder.getOrCreateArray(fields); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4076 | |
Leny Kholodov | df050fd | 2016-09-06 17:06:14 +0000 | [diff] [blame] | 4077 | llvm::DIType *type = |
| 4078 | DBuilder.createStructType(tunit, typeName.str(), tunit, line, |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 4079 | CGM.getContext().toBits(block.BlockSize), 0, |
Leny Kholodov | df050fd | 2016-09-06 17:06:14 +0000 | [diff] [blame] | 4080 | llvm::DINode::FlagZero, nullptr, fieldsArray); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4081 | type = DBuilder.createPointerType(type, CGM.PointerWidthInBits); |
| 4082 | |
| 4083 | // Get overall information about the block. |
Leny Kholodov | 80c047d | 2016-09-06 10:48:04 +0000 | [diff] [blame] | 4084 | llvm::DINode::DIFlags flags = llvm::DINode::FlagArtificial; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4085 | auto *scope = cast<llvm::DILocalScope>(LexicalBlockStack.back()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4086 | |
| 4087 | // Create the descriptor for the parameter. |
Duncan P. N. Exon Smith | e430654 | 2015-07-31 17:56:14 +0000 | [diff] [blame] | 4088 | auto *debugVar = DBuilder.createParameterVariable( |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4089 | scope, Name, ArgNo, tunit, line, type, CGM.getLangOpts().Optimize, flags); |
Adrian Prantl | 51936dd | 2013-03-14 17:53:33 +0000 | [diff] [blame] | 4090 | |
Adrian Prantl | 616bef4 | 2013-03-14 21:52:59 +0000 | [diff] [blame] | 4091 | // Insert an llvm.dbg.declare into the current block. |
Adrian Prantl | 356347b | 2017-10-26 20:08:52 +0000 | [diff] [blame] | 4092 | DBuilder.insertDeclare(Alloca, debugVar, DBuilder.createExpression(), |
Adrian Prantl | b7acfc0 | 2017-02-27 21:30:05 +0000 | [diff] [blame] | 4093 | llvm::DebugLoc::get(line, column, scope, CurInlinedAt), |
Duncan P. N. Exon Smith | fe88b48 | 2015-04-15 21:18:30 +0000 | [diff] [blame] | 4094 | Builder.GetInsertBlock()); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4095 | } |
| 4096 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4097 | llvm::DIDerivedType * |
David Blaikie | 6943dea | 2013-08-20 01:28:15 +0000 | [diff] [blame] | 4098 | CGDebugInfo::getOrCreateStaticDataMemberDeclarationOrNull(const VarDecl *D) { |
| 4099 | if (!D->isStaticDataMember()) |
Duncan P. N. Exon Smith | c09c548 | 2015-04-20 21:17:26 +0000 | [diff] [blame] | 4100 | return nullptr; |
Saleem Abdulrasool | cd187f0 | 2015-02-28 00:13:13 +0000 | [diff] [blame] | 4101 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 4102 | auto MI = StaticDataMemberCache.find(D->getCanonicalDecl()); |
David Blaikie | 6943dea | 2013-08-20 01:28:15 +0000 | [diff] [blame] | 4103 | if (MI != StaticDataMemberCache.end()) { |
| 4104 | assert(MI->second && "Static data member declaration should still exist"); |
Duncan P. N. Exon Smith | ac346ba | 2015-07-24 18:05:58 +0000 | [diff] [blame] | 4105 | return MI->second; |
Evgeniy Stepanov | 37b3f73 | 2013-08-16 10:35:31 +0000 | [diff] [blame] | 4106 | } |
David Blaikie | ce76304 | 2013-08-20 21:49:21 +0000 | [diff] [blame] | 4107 | |
| 4108 | // If the member wasn't found in the cache, lazily construct and add it to the |
| 4109 | // type (used when a limited form of the type is emitted). |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 4110 | auto DC = D->getDeclContext(); |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 4111 | auto *Ctxt = cast<llvm::DICompositeType>(getDeclContextDescriptor(D)); |
Adrian Prantl | 21361fb | 2014-08-29 22:44:27 +0000 | [diff] [blame] | 4112 | return CreateRecordStaticField(D, Ctxt, cast<RecordDecl>(DC)); |
David Blaikie | 6943dea | 2013-08-20 01:28:15 +0000 | [diff] [blame] | 4113 | } |
| 4114 | |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4115 | llvm::DIGlobalVariableExpression *CGDebugInfo::CollectAnonRecordDecls( |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4116 | const RecordDecl *RD, llvm::DIFile *Unit, unsigned LineNo, |
| 4117 | StringRef LinkageName, llvm::GlobalVariable *Var, llvm::DIScope *DContext) { |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4118 | llvm::DIGlobalVariableExpression *GVE = nullptr; |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4119 | |
| 4120 | for (const auto *Field : RD->fields()) { |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4121 | llvm::DIType *FieldTy = getOrCreateType(Field->getType(), Unit); |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4122 | StringRef FieldName = Field->getName(); |
| 4123 | |
| 4124 | // Ignore unnamed fields, but recurse into anonymous records. |
| 4125 | if (FieldName.empty()) { |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 4126 | if (const auto *RT = dyn_cast<RecordType>(Field->getType())) |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4127 | GVE = CollectAnonRecordDecls(RT->getDecl(), Unit, LineNo, LinkageName, |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4128 | Var, DContext); |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4129 | continue; |
| 4130 | } |
| 4131 | // Use VarDecl's Tag, Scope and Line number. |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4132 | GVE = DBuilder.createGlobalVariableExpression( |
| 4133 | DContext, FieldName, LinkageName, Unit, LineNo, FieldTy, |
| 4134 | Var->hasLocalLinkage()); |
| 4135 | Var->addDebugInfo(GVE); |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4136 | } |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4137 | return GVE; |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4138 | } |
| 4139 | |
Yunzhong Gao | 0ebf1bb | 2013-08-30 08:53:09 +0000 | [diff] [blame] | 4140 | void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var, |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4141 | const VarDecl *D) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 4142 | assert(DebugKind >= codegenoptions::LimitedDebugInfo); |
Paul Robinson | b17327d | 2016-04-27 17:37:12 +0000 | [diff] [blame] | 4143 | if (D->hasAttr<NoDebugAttr>()) |
| 4144 | return; |
Adrian Prantl | 338ef7a | 2016-11-09 00:42:03 +0000 | [diff] [blame] | 4145 | |
| 4146 | // If we already created a DIGlobalVariable for this declaration, just attach |
| 4147 | // it to the llvm::GlobalVariable. |
| 4148 | auto Cached = DeclCache.find(D->getCanonicalDecl()); |
| 4149 | if (Cached != DeclCache.end()) |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4150 | return Var->addDebugInfo( |
| 4151 | cast<llvm::DIGlobalVariableExpression>(Cached->second)); |
Adrian Prantl | 338ef7a | 2016-11-09 00:42:03 +0000 | [diff] [blame] | 4152 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4153 | // Create global variable debug descriptor. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4154 | llvm::DIFile *Unit = nullptr; |
| 4155 | llvm::DIScope *DContext = nullptr; |
Frederic Riss | 9db79f1 | 2014-11-18 03:40:46 +0000 | [diff] [blame] | 4156 | unsigned LineNo; |
| 4157 | StringRef DeclName, LinkageName; |
| 4158 | QualType T; |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 4159 | llvm::MDTuple *TemplateParameters = nullptr; |
| 4160 | collectVarDeclProps(D, Unit, LineNo, T, DeclName, LinkageName, |
| 4161 | TemplateParameters, DContext); |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4162 | |
| 4163 | // Attempt to store one global variable for the declaration - even if we |
| 4164 | // emit a lot of fields. |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4165 | llvm::DIGlobalVariableExpression *GVE = nullptr; |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4166 | |
| 4167 | // If this is an anonymous union then we'll want to emit a global |
| 4168 | // variable for each member of the anonymous union so that it's possible |
| 4169 | // to find the name of any field in the union. |
| 4170 | if (T->isUnionType() && DeclName.empty()) { |
Reid Kleckner | 43ecd7c | 2015-11-20 17:41:12 +0000 | [diff] [blame] | 4171 | const RecordDecl *RD = T->castAs<RecordType>()->getDecl(); |
Eric Christopher | e7b87e5 | 2014-10-26 23:40:33 +0000 | [diff] [blame] | 4172 | assert(RD->isAnonymousStructOrUnion() && |
| 4173 | "unnamed non-anonymous struct or union?"); |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4174 | GVE = CollectAnonRecordDecls(RD, Unit, LineNo, LinkageName, Var, DContext); |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4175 | } else { |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 4176 | auto Align = getDeclAlignIfRequired(D, CGM.getContext()); |
Konstantin Zhuravlyov | 2b4917f | 2017-03-09 18:06:23 +0000 | [diff] [blame] | 4177 | |
| 4178 | SmallVector<int64_t, 4> Expr; |
| 4179 | unsigned AddressSpace = |
| 4180 | CGM.getContext().getTargetAddressSpace(D->getType()); |
| 4181 | AppendAddressSpaceXDeref(AddressSpace, Expr); |
| 4182 | |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4183 | GVE = DBuilder.createGlobalVariableExpression( |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4184 | DContext, DeclName, LinkageName, Unit, LineNo, getOrCreateType(T, Unit), |
Konstantin Zhuravlyov | 2b4917f | 2017-03-09 18:06:23 +0000 | [diff] [blame] | 4185 | Var->hasLocalLinkage(), |
| 4186 | Expr.empty() ? nullptr : DBuilder.createExpression(Expr), |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 4187 | getOrCreateStaticDataMemberDeclarationOrNull(D), TemplateParameters, |
| 4188 | Align); |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4189 | Var->addDebugInfo(GVE); |
Eric Christopher | cab9fae | 2014-04-10 05:20:00 +0000 | [diff] [blame] | 4190 | } |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4191 | DeclCache[D->getCanonicalDecl()].reset(GVE); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4192 | } |
| 4193 | |
Peter Collingbourne | eeb56ab | 2016-09-13 01:13:19 +0000 | [diff] [blame] | 4194 | void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD, const APValue &Init) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 4195 | assert(DebugKind >= codegenoptions::LimitedDebugInfo); |
Paul Robinson | b17327d | 2016-04-27 17:37:12 +0000 | [diff] [blame] | 4196 | if (VD->hasAttr<NoDebugAttr>()) |
| 4197 | return; |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 4198 | auto Align = getDeclAlignIfRequired(VD, CGM.getContext()); |
Yunzhong Gao | 0ebf1bb | 2013-08-30 08:53:09 +0000 | [diff] [blame] | 4199 | // Create the descriptor for the variable. |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4200 | llvm::DIFile *Unit = getOrCreateFile(VD->getLocation()); |
Yunzhong Gao | 0ebf1bb | 2013-08-30 08:53:09 +0000 | [diff] [blame] | 4201 | StringRef Name = VD->getName(); |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4202 | llvm::DIType *Ty = getOrCreateType(VD->getType(), Unit); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 4203 | if (const auto *ECD = dyn_cast<EnumConstantDecl>(VD)) { |
| 4204 | const auto *ED = cast<EnumDecl>(ECD->getDeclContext()); |
Yunzhong Gao | 0ebf1bb | 2013-08-30 08:53:09 +0000 | [diff] [blame] | 4205 | assert(isa<EnumType>(ED->getTypeForDecl()) && "Enum without EnumType?"); |
| 4206 | Ty = getOrCreateType(QualType(ED->getTypeForDecl(), 0), Unit); |
| 4207 | } |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 4208 | // Do not use global variables for enums. |
| 4209 | // |
| 4210 | // FIXME: why not? |
Duncan P. N. Exon Smith | 4caa7f2 | 2015-04-16 01:00:56 +0000 | [diff] [blame] | 4211 | if (Ty->getTag() == llvm::dwarf::DW_TAG_enumeration_type) |
Yunzhong Gao | 0ebf1bb | 2013-08-30 08:53:09 +0000 | [diff] [blame] | 4212 | return; |
David Blaikie | a1556556 | 2014-04-04 20:56:17 +0000 | [diff] [blame] | 4213 | // Do not emit separate definitions for function local const/statics. |
| 4214 | if (isa<FunctionDecl>(VD->getDeclContext())) |
| 4215 | return; |
David Blaikie | bb11391 | 2014-04-05 07:23:17 +0000 | [diff] [blame] | 4216 | VD = cast<ValueDecl>(VD->getCanonicalDecl()); |
David Blaikie | 423eb5a | 2014-11-19 19:42:40 +0000 | [diff] [blame] | 4217 | auto *VarD = cast<VarDecl>(VD); |
David Blaikie | af08085 | 2014-11-21 00:20:58 +0000 | [diff] [blame] | 4218 | if (VarD->isStaticDataMember()) { |
| 4219 | auto *RD = cast<RecordDecl>(VarD->getDeclContext()); |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 4220 | getDeclContextDescriptor(VarD); |
David Blaikie | 423eb5a | 2014-11-19 19:42:40 +0000 | [diff] [blame] | 4221 | // Ensure that the type is retained even though it's otherwise unreferenced. |
Duncan P. N. Exon Smith | 383f841 | 2016-04-23 21:08:27 +0000 | [diff] [blame] | 4222 | // |
| 4223 | // FIXME: This is probably unnecessary, since Ty should reference RD |
| 4224 | // through its scope. |
David Blaikie | 423eb5a | 2014-11-19 19:42:40 +0000 | [diff] [blame] | 4225 | RetainedTypes.push_back( |
David Blaikie | af08085 | 2014-11-21 00:20:58 +0000 | [diff] [blame] | 4226 | CGM.getContext().getRecordType(RD).getAsOpaquePtr()); |
David Blaikie | 423eb5a | 2014-11-19 19:42:40 +0000 | [diff] [blame] | 4227 | return; |
| 4228 | } |
| 4229 | |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 4230 | llvm::DIScope *DContext = getDeclContextDescriptor(VD); |
David Blaikie | af08085 | 2014-11-21 00:20:58 +0000 | [diff] [blame] | 4231 | |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 4232 | auto &GV = DeclCache[VD]; |
| 4233 | if (GV) |
David Blaikie | bb11391 | 2014-04-05 07:23:17 +0000 | [diff] [blame] | 4234 | return; |
Peter Collingbourne | eeb56ab | 2016-09-13 01:13:19 +0000 | [diff] [blame] | 4235 | llvm::DIExpression *InitExpr = nullptr; |
Peter Collingbourne | b701363 | 2016-12-16 22:10:52 +0000 | [diff] [blame] | 4236 | if (CGM.getContext().getTypeSize(VD->getType()) <= 64) { |
| 4237 | // FIXME: Add a representation for integer constants wider than 64 bits. |
| 4238 | if (Init.isInt()) |
| 4239 | InitExpr = |
| 4240 | DBuilder.createConstantValueExpression(Init.getInt().getExtValue()); |
| 4241 | else if (Init.isFloat()) |
| 4242 | InitExpr = DBuilder.createConstantValueExpression( |
| 4243 | Init.getFloat().bitcastToAPInt().getZExtValue()); |
| 4244 | } |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 4245 | |
| 4246 | llvm::MDTuple *TemplateParameters = nullptr; |
| 4247 | |
| 4248 | if (isa<VarTemplateSpecializationDecl>(VD)) |
| 4249 | if (VarD) { |
| 4250 | llvm::DINodeArray parameterNodes = CollectVarTemplateParams(VarD, &*Unit); |
| 4251 | TemplateParameters = parameterNodes.get(); |
| 4252 | } |
| 4253 | |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4254 | GV.reset(DBuilder.createGlobalVariableExpression( |
David Blaikie | 506a745 | 2014-04-05 07:46:57 +0000 | [diff] [blame] | 4255 | DContext, Name, StringRef(), Unit, getLineNumber(VD->getLocation()), Ty, |
Victor Leschuk | a7ece03 | 2016-10-20 00:13:19 +0000 | [diff] [blame] | 4256 | true, InitExpr, getOrCreateStaticDataMemberDeclarationOrNull(VarD), |
Matthew Voss | 2016536 | 2018-10-03 18:45:04 +0000 | [diff] [blame] | 4257 | TemplateParameters, Align)); |
David Blaikie | bd48376 | 2013-05-20 04:58:53 +0000 | [diff] [blame] | 4258 | } |
| 4259 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4260 | llvm::DIScope *CGDebugInfo::getCurrentContextDescriptor(const Decl *D) { |
David Blaikie | bd48376 | 2013-05-20 04:58:53 +0000 | [diff] [blame] | 4261 | if (!LexicalBlockStack.empty()) |
Duncan P. N. Exon Smith | fc8d9d9 | 2015-04-20 18:32:15 +0000 | [diff] [blame] | 4262 | return LexicalBlockStack.back(); |
Adrian Prantl | 5c8bd88 | 2015-09-11 17:23:08 +0000 | [diff] [blame] | 4263 | llvm::DIScope *Mod = getParentModuleOrNull(D); |
| 4264 | return getContextDescriptor(D, Mod ? Mod : TheCU); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4265 | } |
| 4266 | |
David Blaikie | 9f88fe8 | 2013-04-22 06:13:21 +0000 | [diff] [blame] | 4267 | void CGDebugInfo::EmitUsingDirective(const UsingDirectiveDecl &UD) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 4268 | if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo) |
David Blaikie | bd48376 | 2013-05-20 04:58:53 +0000 | [diff] [blame] | 4269 | return; |
Ekaterina Romanova | 9218a3b | 2015-12-10 18:52:50 +0000 | [diff] [blame] | 4270 | const NamespaceDecl *NSDecl = UD.getNominatedNamespace(); |
Adrian McCarthy | ab1e786 | 2016-07-21 18:43:20 +0000 | [diff] [blame] | 4271 | if (!NSDecl->isAnonymousNamespace() || |
| 4272 | CGM.getCodeGenOpts().DebugExplicitImport) { |
Adrian Prantl | 5649b0e | 2017-07-19 00:09:58 +0000 | [diff] [blame] | 4273 | auto Loc = UD.getLocation(); |
Ekaterina Romanova | 9218a3b | 2015-12-10 18:52:50 +0000 | [diff] [blame] | 4274 | DBuilder.createImportedModule( |
| 4275 | getCurrentContextDescriptor(cast<Decl>(UD.getDeclContext())), |
Adrian Prantl | 5649b0e | 2017-07-19 00:09:58 +0000 | [diff] [blame] | 4276 | getOrCreateNamespace(NSDecl), getOrCreateFile(Loc), getLineNumber(Loc)); |
Ekaterina Romanova | 9218a3b | 2015-12-10 18:52:50 +0000 | [diff] [blame] | 4277 | } |
David Blaikie | 9f88fe8 | 2013-04-22 06:13:21 +0000 | [diff] [blame] | 4278 | } |
| 4279 | |
David Blaikie | bd48376 | 2013-05-20 04:58:53 +0000 | [diff] [blame] | 4280 | void CGDebugInfo::EmitUsingDecl(const UsingDecl &UD) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 4281 | if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo) |
David Blaikie | bd48376 | 2013-05-20 04:58:53 +0000 | [diff] [blame] | 4282 | return; |
| 4283 | assert(UD.shadow_size() && |
| 4284 | "We shouldn't be codegening an invalid UsingDecl containing no decls"); |
| 4285 | // Emitting one decl is sufficient - debuggers can detect that this is an |
| 4286 | // overloaded name & provide lookup for all the overloads. |
| 4287 | const UsingShadowDecl &USD = **UD.shadow_begin(); |
David Blaikie | 2a58a18 | 2016-08-05 19:03:01 +0000 | [diff] [blame] | 4288 | |
| 4289 | // FIXME: Skip functions with undeduced auto return type for now since we |
| 4290 | // don't currently have the plumbing for separate declarations & definitions |
| 4291 | // of free functions and mismatched types (auto in the declaration, concrete |
| 4292 | // return type in the definition) |
| 4293 | if (const auto *FD = dyn_cast<FunctionDecl>(USD.getUnderlyingDecl())) |
| 4294 | if (const auto *AT = |
| 4295 | FD->getType()->getAs<FunctionProtoType>()->getContainedAutoType()) |
| 4296 | if (AT->getDeducedType().isNull()) |
| 4297 | return; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4298 | if (llvm::DINode *Target = |
Adrian Prantl | 5649b0e | 2017-07-19 00:09:58 +0000 | [diff] [blame] | 4299 | getDeclarationOrDefinition(USD.getUnderlyingDecl())) { |
| 4300 | auto Loc = USD.getLocation(); |
David Blaikie | bd48376 | 2013-05-20 04:58:53 +0000 | [diff] [blame] | 4301 | DBuilder.createImportedDeclaration( |
| 4302 | getCurrentContextDescriptor(cast<Decl>(USD.getDeclContext())), Target, |
Adrian Prantl | 5649b0e | 2017-07-19 00:09:58 +0000 | [diff] [blame] | 4303 | getOrCreateFile(Loc), getLineNumber(Loc)); |
| 4304 | } |
David Blaikie | bd48376 | 2013-05-20 04:58:53 +0000 | [diff] [blame] | 4305 | } |
| 4306 | |
Adrian Prantl | c4bb47e | 2015-06-30 17:39:51 +0000 | [diff] [blame] | 4307 | void CGDebugInfo::EmitImportDecl(const ImportDecl &ID) { |
David Blaikie | af09f4a | 2016-05-03 23:06:40 +0000 | [diff] [blame] | 4308 | if (CGM.getCodeGenOpts().getDebuggerTuning() != llvm::DebuggerKind::LLDB) |
| 4309 | return; |
Adrian Prantl | 8a634c1 | 2015-12-18 19:44:31 +0000 | [diff] [blame] | 4310 | if (Module *M = ID.getImportedModule()) { |
Chad Rosier | e5dafd1 | 2015-12-18 20:08:40 +0000 | [diff] [blame] | 4311 | auto Info = ExternalASTSource::ASTSourceDescriptor(*M); |
Adrian Prantl | 5649b0e | 2017-07-19 00:09:58 +0000 | [diff] [blame] | 4312 | auto Loc = ID.getLocation(); |
Adrian Prantl | 8a634c1 | 2015-12-18 19:44:31 +0000 | [diff] [blame] | 4313 | DBuilder.createImportedDeclaration( |
| 4314 | getCurrentContextDescriptor(cast<Decl>(ID.getDeclContext())), |
Adrian Prantl | 5649b0e | 2017-07-19 00:09:58 +0000 | [diff] [blame] | 4315 | getOrCreateModuleRef(Info, DebugTypeExtRefs), getOrCreateFile(Loc), |
| 4316 | getLineNumber(Loc)); |
Adrian Prantl | 8a634c1 | 2015-12-18 19:44:31 +0000 | [diff] [blame] | 4317 | } |
Adrian Prantl | c4bb47e | 2015-06-30 17:39:51 +0000 | [diff] [blame] | 4318 | } |
| 4319 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4320 | llvm::DIImportedEntity * |
David Blaikie | f121b93 | 2013-05-20 22:50:41 +0000 | [diff] [blame] | 4321 | CGDebugInfo::EmitNamespaceAlias(const NamespaceAliasDecl &NA) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 4322 | if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo) |
Duncan P. N. Exon Smith | dadc2b6 | 2015-04-21 18:43:54 +0000 | [diff] [blame] | 4323 | return nullptr; |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 4324 | auto &VH = NamespaceAliasCache[&NA]; |
David Blaikie | f121b93 | 2013-05-20 22:50:41 +0000 | [diff] [blame] | 4325 | if (VH) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4326 | return cast<llvm::DIImportedEntity>(VH); |
| 4327 | llvm::DIImportedEntity *R; |
Adrian Prantl | 5649b0e | 2017-07-19 00:09:58 +0000 | [diff] [blame] | 4328 | auto Loc = NA.getLocation(); |
David Majnemer | 58ed0f3 | 2016-07-17 00:39:12 +0000 | [diff] [blame] | 4329 | if (const auto *Underlying = |
David Blaikie | f121b93 | 2013-05-20 22:50:41 +0000 | [diff] [blame] | 4330 | dyn_cast<NamespaceAliasDecl>(NA.getAliasedNamespace())) |
| 4331 | // This could cache & dedup here rather than relying on metadata deduping. |
David Blaikie | 551fb0a | 2014-04-06 06:30:03 +0000 | [diff] [blame] | 4332 | R = DBuilder.createImportedDeclaration( |
David Blaikie | f121b93 | 2013-05-20 22:50:41 +0000 | [diff] [blame] | 4333 | getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())), |
Adrian Prantl | 5649b0e | 2017-07-19 00:09:58 +0000 | [diff] [blame] | 4334 | EmitNamespaceAlias(*Underlying), getOrCreateFile(Loc), |
| 4335 | getLineNumber(Loc), NA.getName()); |
David Blaikie | f121b93 | 2013-05-20 22:50:41 +0000 | [diff] [blame] | 4336 | else |
David Blaikie | 551fb0a | 2014-04-06 06:30:03 +0000 | [diff] [blame] | 4337 | R = DBuilder.createImportedDeclaration( |
David Blaikie | f121b93 | 2013-05-20 22:50:41 +0000 | [diff] [blame] | 4338 | getCurrentContextDescriptor(cast<Decl>(NA.getDeclContext())), |
Adrian Prantl | ddb8e06 | 2017-05-12 16:23:53 +0000 | [diff] [blame] | 4339 | getOrCreateNamespace(cast<NamespaceDecl>(NA.getAliasedNamespace())), |
Adrian Prantl | 5649b0e | 2017-07-19 00:09:58 +0000 | [diff] [blame] | 4340 | getOrCreateFile(Loc), getLineNumber(Loc), NA.getName()); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 4341 | VH.reset(R); |
David Blaikie | f121b93 | 2013-05-20 22:50:41 +0000 | [diff] [blame] | 4342 | return R; |
| 4343 | } |
| 4344 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4345 | llvm::DINamespace * |
Adrian Prantl | ddb8e06 | 2017-05-12 16:23:53 +0000 | [diff] [blame] | 4346 | CGDebugInfo::getOrCreateNamespace(const NamespaceDecl *NSDecl) { |
| 4347 | // Don't canonicalize the NamespaceDecl here: The DINamespace will be uniqued |
| 4348 | // if necessary, and this way multiple declarations of the same namespace in |
| 4349 | // different parent modules stay distinct. |
| 4350 | auto I = NamespaceCache.find(NSDecl); |
Adrian Prantl | d887055 | 2017-05-11 22:59:19 +0000 | [diff] [blame] | 4351 | if (I != NamespaceCache.end()) |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4352 | return cast<llvm::DINamespace>(I->second); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 4353 | |
Adrian Prantl | 6ec370a | 2015-09-10 18:39:45 +0000 | [diff] [blame] | 4354 | llvm::DIScope *Context = getDeclContextDescriptor(NSDecl); |
Adrian Prantl | d887055 | 2017-05-11 22:59:19 +0000 | [diff] [blame] | 4355 | // Don't trust the context if it is a DIModule (see comment above). |
Adrian Prantl | ddb8e06 | 2017-05-12 16:23:53 +0000 | [diff] [blame] | 4356 | llvm::DINamespace *NS = |
| 4357 | DBuilder.createNameSpace(Context, NSDecl->getName(), NSDecl->isInline()); |
| 4358 | NamespaceCache[NSDecl].reset(NS); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4359 | return NS; |
| 4360 | } |
| 4361 | |
Adrian Prantl | a5206ce | 2015-09-22 23:26:43 +0000 | [diff] [blame] | 4362 | void CGDebugInfo::setDwoId(uint64_t Signature) { |
| 4363 | assert(TheCU && "no main compile unit"); |
| 4364 | TheCU->setDWOId(Signature); |
| 4365 | } |
| 4366 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4367 | void CGDebugInfo::finalize() { |
David Blaikie | 87dab87 | 2014-05-07 16:56:58 +0000 | [diff] [blame] | 4368 | // Creating types might create further types - invalidating the current |
| 4369 | // element and the size(), so don't cache/reference them. |
| 4370 | for (size_t i = 0; i != ObjCInterfaceCache.size(); ++i) { |
| 4371 | ObjCInterfaceCacheEntry E = ObjCInterfaceCache[i]; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4372 | llvm::DIType *Ty = E.Type->getDecl()->getDefinition() |
Duncan P. N. Exon Smith | 497d4d46 | 2015-04-11 19:05:04 +0000 | [diff] [blame] | 4373 | ? CreateTypeDefinition(E.Type, E.Unit) |
| 4374 | : E.Decl; |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4375 | DBuilder.replaceTemporary(llvm::TempDIType(E.Decl), Ty); |
David Blaikie | 87dab87 | 2014-05-07 16:56:58 +0000 | [diff] [blame] | 4376 | } |
| 4377 | |
Jonas Devlieghere | d8ba8ae | 2018-06-27 17:31:59 +0000 | [diff] [blame] | 4378 | if (CGM.getCodeGenOpts().DwarfVersion >= 5) { |
| 4379 | // Add methods to interface. |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4380 | for (const auto &P : ObjCMethodCache) { |
Jonas Devlieghere | d8ba8ae | 2018-06-27 17:31:59 +0000 | [diff] [blame] | 4381 | if (P.second.empty()) |
| 4382 | continue; |
| 4383 | |
| 4384 | QualType QTy(P.first->getTypeForDecl(), 0); |
| 4385 | auto It = TypeCache.find(QTy.getAsOpaquePtr()); |
| 4386 | assert(It != TypeCache.end()); |
| 4387 | |
| 4388 | llvm::DICompositeType *InterfaceDecl = |
| 4389 | cast<llvm::DICompositeType>(It->second); |
| 4390 | |
| 4391 | SmallVector<llvm::Metadata *, 16> EltTys; |
| 4392 | auto CurrenetElts = InterfaceDecl->getElements(); |
| 4393 | EltTys.append(CurrenetElts.begin(), CurrenetElts.end()); |
| 4394 | for (auto &MD : P.second) |
| 4395 | EltTys.push_back(MD); |
| 4396 | llvm::DINodeArray Elements = DBuilder.getOrCreateArray(EltTys); |
| 4397 | DBuilder.replaceArrays(InterfaceDecl, Elements); |
| 4398 | } |
| 4399 | } |
| 4400 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4401 | for (const auto &P : ReplaceMap) { |
| 4402 | assert(P.second); |
| 4403 | auto *Ty = cast<llvm::DIType>(P.second); |
Duncan P. N. Exon Smith | 4caa7f2 | 2015-04-16 01:00:56 +0000 | [diff] [blame] | 4404 | assert(Ty->isForwardDecl()); |
Eric Christopher | b2a008c | 2013-05-16 00:45:12 +0000 | [diff] [blame] | 4405 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4406 | auto It = TypeCache.find(P.first); |
| 4407 | assert(It != TypeCache.end()); |
| 4408 | assert(It->second); |
Adrian Prantl | 73409ce | 2013-03-11 18:33:46 +0000 | [diff] [blame] | 4409 | |
Duncan P. N. Exon Smith | 9dd4e4e | 2015-04-29 16:40:08 +0000 | [diff] [blame] | 4410 | DBuilder.replaceTemporary(llvm::TempDIType(Ty), |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4411 | cast<llvm::DIType>(It->second)); |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4412 | } |
Adrian Prantl | 73409ce | 2013-03-11 18:33:46 +0000 | [diff] [blame] | 4413 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4414 | for (const auto &P : FwdDeclReplaceMap) { |
| 4415 | assert(P.second); |
| 4416 | llvm::TempMDNode FwdDecl(cast<llvm::MDNode>(P.second)); |
Duncan P. N. Exon Smith | fb49491 | 2014-12-09 18:39:32 +0000 | [diff] [blame] | 4417 | llvm::Metadata *Repl; |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 4418 | |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4419 | auto It = DeclCache.find(P.first); |
Adrian Prantl | 97f7685 | 2014-12-19 01:02:11 +0000 | [diff] [blame] | 4420 | // If there has been no definition for the declaration, call RAUW |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 4421 | // with ourselves, that will destroy the temporary MDNode and |
| 4422 | // replace it with a standard one, avoiding leaking memory. |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4423 | if (It == DeclCache.end()) |
| 4424 | Repl = P.second; |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 4425 | else |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4426 | Repl = It->second; |
Frederic Riss | dce60a7 | 2014-11-19 18:53:46 +0000 | [diff] [blame] | 4427 | |
Adrian Prantl | 5f4740d | 2016-12-20 02:10:02 +0000 | [diff] [blame] | 4428 | if (auto *GVE = dyn_cast_or_null<llvm::DIGlobalVariableExpression>(Repl)) |
| 4429 | Repl = GVE->getVariable(); |
Duncan P. N. Exon Smith | d899f6e | 2015-04-18 00:07:30 +0000 | [diff] [blame] | 4430 | DBuilder.replaceTemporary(std::move(FwdDecl), cast<llvm::MDNode>(Repl)); |
Frederic Riss | d253ed6 | 2014-11-18 03:40:51 +0000 | [diff] [blame] | 4431 | } |
| 4432 | |
Adrian Prantl | 73409ce | 2013-03-11 18:33:46 +0000 | [diff] [blame] | 4433 | // We keep our own list of retained types, because we need to look |
| 4434 | // up the final type in the type cache. |
Adrian Prantl | 3a884fa | 2015-08-27 22:56:46 +0000 | [diff] [blame] | 4435 | for (auto &RT : RetainedTypes) |
Adrian Prantl | ad9a195e | 2015-08-27 21:21:19 +0000 | [diff] [blame] | 4436 | if (auto MD = TypeCache[RT]) |
| 4437 | DBuilder.retainType(cast<llvm::DIType>(MD)); |
Adrian Prantl | 73409ce | 2013-03-11 18:33:46 +0000 | [diff] [blame] | 4438 | |
Guy Benyei | 11169dd | 2012-12-18 14:30:41 +0000 | [diff] [blame] | 4439 | DBuilder.finalize(); |
| 4440 | } |
David Blaikie | 66088d5 | 2014-09-24 17:01:27 +0000 | [diff] [blame] | 4441 | |
| 4442 | void CGDebugInfo::EmitExplicitCastType(QualType Ty) { |
Benjamin Kramer | 8c30592 | 2016-02-02 11:06:51 +0000 | [diff] [blame] | 4443 | if (CGM.getCodeGenOpts().getDebugInfo() < codegenoptions::LimitedDebugInfo) |
David Blaikie | 66088d5 | 2014-09-24 17:01:27 +0000 | [diff] [blame] | 4444 | return; |
Duncan P. N. Exon Smith | 5043f91 | 2015-03-27 22:58:05 +0000 | [diff] [blame] | 4445 | |
Duncan P. N. Exon Smith | 0b6c369 | 2015-04-20 18:51:48 +0000 | [diff] [blame] | 4446 | if (auto *DieTy = getOrCreateType(Ty, getOrCreateMainFile())) |
Duncan P. N. Exon Smith | 5043f91 | 2015-03-27 22:58:05 +0000 | [diff] [blame] | 4447 | // Don't ignore in case of explicit cast where it is referenced indirectly. |
| 4448 | DBuilder.retainType(DieTy); |
David Blaikie | 66088d5 | 2014-09-24 17:01:27 +0000 | [diff] [blame] | 4449 | } |
Amara Emerson | 652795d | 2016-11-10 14:44:30 +0000 | [diff] [blame] | 4450 | |
| 4451 | llvm::DebugLoc CGDebugInfo::SourceLocToDebugLoc(SourceLocation Loc) { |
| 4452 | if (LexicalBlockStack.empty()) |
| 4453 | return llvm::DebugLoc(); |
| 4454 | |
| 4455 | llvm::MDNode *Scope = LexicalBlockStack.back(); |
Jonas Devlieghere | 9ef4965 | 2018-06-28 10:56:40 +0000 | [diff] [blame] | 4456 | return llvm::DebugLoc::get(getLineNumber(Loc), getColumnNumber(Loc), Scope); |
Amara Emerson | 652795d | 2016-11-10 14:44:30 +0000 | [diff] [blame] | 4457 | } |
Vedant Kumar | 5931b4e | 2018-10-05 20:37:17 +0000 | [diff] [blame] | 4458 | |
| 4459 | llvm::DINode::DIFlags CGDebugInfo::getCallSiteRelatedAttrs() const { |
| 4460 | // Call site-related attributes are only useful in optimized programs, and |
| 4461 | // when there's a possibility of debugging backtraces. |
| 4462 | if (!CGM.getLangOpts().Optimize || DebugKind == codegenoptions::NoDebugInfo || |
| 4463 | DebugKind == codegenoptions::LocTrackingOnly) |
| 4464 | return llvm::DINode::FlagZero; |
| 4465 | |
| 4466 | // Call site-related attributes are available in DWARF v5. Some debuggers, |
| 4467 | // while not fully DWARF v5-compliant, may accept these attributes as if they |
| 4468 | // were part of DWARF v4. |
| 4469 | bool SupportsDWARFv4Ext = |
| 4470 | CGM.getCodeGenOpts().DwarfVersion == 4 && |
| 4471 | CGM.getCodeGenOpts().getDebuggerTuning() == llvm::DebuggerKind::LLDB; |
| 4472 | if (!SupportsDWARFv4Ext && CGM.getCodeGenOpts().DwarfVersion < 5) |
| 4473 | return llvm::DINode::FlagZero; |
| 4474 | |
| 4475 | return llvm::DINode::FlagAllCallsDescribed; |
| 4476 | } |