| File: | lib/IR/DebugInfoMetadata.cpp |
| Warning: | line 811, column 28 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | //===- DebugInfoMetadata.cpp - Implement debug info metadata --------------===// | |||
| 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 file implements the debug info Metadata classes. | |||
| 11 | // | |||
| 12 | //===----------------------------------------------------------------------===// | |||
| 13 | ||||
| 14 | #include "llvm/IR/DebugInfoMetadata.h" | |||
| 15 | #include "LLVMContextImpl.h" | |||
| 16 | #include "MetadataImpl.h" | |||
| 17 | #include "llvm/ADT/SmallPtrSet.h" | |||
| 18 | #include "llvm/ADT/StringSwitch.h" | |||
| 19 | #include "llvm/IR/DIBuilder.h" | |||
| 20 | #include "llvm/IR/Function.h" | |||
| 21 | #include "llvm/IR/Instructions.h" | |||
| 22 | ||||
| 23 | using namespace llvm; | |||
| 24 | ||||
| 25 | DILocation::DILocation(LLVMContext &C, StorageType Storage, unsigned Line, | |||
| 26 | unsigned Column, ArrayRef<Metadata *> MDs) | |||
| 27 | : MDNode(C, DILocationKind, Storage, MDs) { | |||
| 28 | assert((MDs.size() == 1 || MDs.size() == 2) &&(static_cast <bool> ((MDs.size() == 1 || MDs.size() == 2 ) && "Expected a scope and optional inlined-at") ? void (0) : __assert_fail ("(MDs.size() == 1 || MDs.size() == 2) && \"Expected a scope and optional inlined-at\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 29, __extension__ __PRETTY_FUNCTION__)) | |||
| 29 | "Expected a scope and optional inlined-at")(static_cast <bool> ((MDs.size() == 1 || MDs.size() == 2 ) && "Expected a scope and optional inlined-at") ? void (0) : __assert_fail ("(MDs.size() == 1 || MDs.size() == 2) && \"Expected a scope and optional inlined-at\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 29, __extension__ __PRETTY_FUNCTION__)); | |||
| 30 | ||||
| 31 | // Set line and column. | |||
| 32 | assert(Column < (1u << 16) && "Expected 16-bit column")(static_cast <bool> (Column < (1u << 16) && "Expected 16-bit column") ? void (0) : __assert_fail ("Column < (1u << 16) && \"Expected 16-bit column\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 32, __extension__ __PRETTY_FUNCTION__)); | |||
| 33 | ||||
| 34 | SubclassData32 = Line; | |||
| 35 | SubclassData16 = Column; | |||
| 36 | } | |||
| 37 | ||||
| 38 | static void adjustColumn(unsigned &Column) { | |||
| 39 | // Set to unknown on overflow. We only have 16 bits to play with here. | |||
| 40 | if (Column >= (1u << 16)) | |||
| 41 | Column = 0; | |||
| 42 | } | |||
| 43 | ||||
| 44 | DILocation *DILocation::getImpl(LLVMContext &Context, unsigned Line, | |||
| 45 | unsigned Column, Metadata *Scope, | |||
| 46 | Metadata *InlinedAt, StorageType Storage, | |||
| 47 | bool ShouldCreate) { | |||
| 48 | // Fixup column. | |||
| 49 | adjustColumn(Column); | |||
| 50 | ||||
| 51 | if (Storage == Uniqued) { | |||
| 52 | if (auto *N = | |||
| 53 | getUniqued(Context.pImpl->DILocations, | |||
| 54 | DILocationInfo::KeyTy(Line, Column, Scope, InlinedAt))) | |||
| 55 | return N; | |||
| 56 | if (!ShouldCreate) | |||
| 57 | return nullptr; | |||
| 58 | } else { | |||
| 59 | assert(ShouldCreate && "Expected non-uniqued nodes to always be created")(static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 59, __extension__ __PRETTY_FUNCTION__)); | |||
| 60 | } | |||
| 61 | ||||
| 62 | SmallVector<Metadata *, 2> Ops; | |||
| 63 | Ops.push_back(Scope); | |||
| 64 | if (InlinedAt) | |||
| 65 | Ops.push_back(InlinedAt); | |||
| 66 | return storeImpl(new (Ops.size()) | |||
| 67 | DILocation(Context, Storage, Line, Column, Ops), | |||
| 68 | Storage, Context.pImpl->DILocations); | |||
| 69 | } | |||
| 70 | ||||
| 71 | const DILocation * | |||
| 72 | DILocation::getMergedLocation(const DILocation *LocA, const DILocation *LocB, | |||
| 73 | const Instruction *ForInst) { | |||
| 74 | if (!LocA || !LocB) | |||
| 75 | return nullptr; | |||
| 76 | ||||
| 77 | if (LocA == LocB || !LocA->canDiscriminate(*LocB)) | |||
| 78 | return LocA; | |||
| 79 | ||||
| 80 | if (!dyn_cast_or_null<CallInst>(ForInst)) | |||
| 81 | return nullptr; | |||
| 82 | ||||
| 83 | SmallPtrSet<DILocation *, 5> InlinedLocationsA; | |||
| 84 | for (DILocation *L = LocA->getInlinedAt(); L; L = L->getInlinedAt()) | |||
| 85 | InlinedLocationsA.insert(L); | |||
| 86 | const DILocation *Result = LocB; | |||
| 87 | for (DILocation *L = LocB->getInlinedAt(); L; L = L->getInlinedAt()) { | |||
| 88 | Result = L; | |||
| 89 | if (InlinedLocationsA.count(L)) | |||
| 90 | break; | |||
| 91 | } | |||
| 92 | return DILocation::get(Result->getContext(), 0, 0, Result->getScope(), | |||
| 93 | Result->getInlinedAt()); | |||
| 94 | } | |||
| 95 | ||||
| 96 | DINode::DIFlags DINode::getFlag(StringRef Flag) { | |||
| 97 | return StringSwitch<DIFlags>(Flag) | |||
| 98 | #define HANDLE_DI_FLAG(ID, NAME) .Case("DIFlag" #NAME, Flag##NAME) | |||
| 99 | #include "llvm/IR/DebugInfoFlags.def" | |||
| 100 | .Default(DINode::FlagZero); | |||
| 101 | } | |||
| 102 | ||||
| 103 | StringRef DINode::getFlagString(DIFlags Flag) { | |||
| 104 | switch (Flag) { | |||
| 105 | #define HANDLE_DI_FLAG(ID, NAME) \ | |||
| 106 | case Flag##NAME: \ | |||
| 107 | return "DIFlag" #NAME; | |||
| 108 | #include "llvm/IR/DebugInfoFlags.def" | |||
| 109 | } | |||
| 110 | return ""; | |||
| 111 | } | |||
| 112 | ||||
| 113 | DINode::DIFlags DINode::splitFlags(DIFlags Flags, | |||
| 114 | SmallVectorImpl<DIFlags> &SplitFlags) { | |||
| 115 | // Flags that are packed together need to be specially handled, so | |||
| 116 | // that, for example, we emit "DIFlagPublic" and not | |||
| 117 | // "DIFlagPrivate | DIFlagProtected". | |||
| 118 | if (DIFlags A = Flags & FlagAccessibility) { | |||
| 119 | if (A == FlagPrivate) | |||
| 120 | SplitFlags.push_back(FlagPrivate); | |||
| 121 | else if (A == FlagProtected) | |||
| 122 | SplitFlags.push_back(FlagProtected); | |||
| 123 | else | |||
| 124 | SplitFlags.push_back(FlagPublic); | |||
| 125 | Flags &= ~A; | |||
| 126 | } | |||
| 127 | if (DIFlags R = Flags & FlagPtrToMemberRep) { | |||
| 128 | if (R == FlagSingleInheritance) | |||
| 129 | SplitFlags.push_back(FlagSingleInheritance); | |||
| 130 | else if (R == FlagMultipleInheritance) | |||
| 131 | SplitFlags.push_back(FlagMultipleInheritance); | |||
| 132 | else | |||
| 133 | SplitFlags.push_back(FlagVirtualInheritance); | |||
| 134 | Flags &= ~R; | |||
| 135 | } | |||
| 136 | if ((Flags & FlagIndirectVirtualBase) == FlagIndirectVirtualBase) { | |||
| 137 | Flags &= ~FlagIndirectVirtualBase; | |||
| 138 | SplitFlags.push_back(FlagIndirectVirtualBase); | |||
| 139 | } | |||
| 140 | ||||
| 141 | #define HANDLE_DI_FLAG(ID, NAME) \ | |||
| 142 | if (DIFlags Bit = Flags & Flag##NAME) { \ | |||
| 143 | SplitFlags.push_back(Bit); \ | |||
| 144 | Flags &= ~Bit; \ | |||
| 145 | } | |||
| 146 | #include "llvm/IR/DebugInfoFlags.def" | |||
| 147 | return Flags; | |||
| 148 | } | |||
| 149 | ||||
| 150 | DIScopeRef DIScope::getScope() const { | |||
| 151 | if (auto *T = dyn_cast<DIType>(this)) | |||
| 152 | return T->getScope(); | |||
| 153 | ||||
| 154 | if (auto *SP = dyn_cast<DISubprogram>(this)) | |||
| 155 | return SP->getScope(); | |||
| 156 | ||||
| 157 | if (auto *LB = dyn_cast<DILexicalBlockBase>(this)) | |||
| 158 | return LB->getScope(); | |||
| 159 | ||||
| 160 | if (auto *NS = dyn_cast<DINamespace>(this)) | |||
| 161 | return NS->getScope(); | |||
| 162 | ||||
| 163 | if (auto *M = dyn_cast<DIModule>(this)) | |||
| 164 | return M->getScope(); | |||
| 165 | ||||
| 166 | assert((isa<DIFile>(this) || isa<DICompileUnit>(this)) &&(static_cast <bool> ((isa<DIFile>(this) || isa< DICompileUnit>(this)) && "Unhandled type of scope." ) ? void (0) : __assert_fail ("(isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 167, __extension__ __PRETTY_FUNCTION__)) | |||
| 167 | "Unhandled type of scope.")(static_cast <bool> ((isa<DIFile>(this) || isa< DICompileUnit>(this)) && "Unhandled type of scope." ) ? void (0) : __assert_fail ("(isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 167, __extension__ __PRETTY_FUNCTION__)); | |||
| 168 | return nullptr; | |||
| 169 | } | |||
| 170 | ||||
| 171 | StringRef DIScope::getName() const { | |||
| 172 | if (auto *T = dyn_cast<DIType>(this)) | |||
| 173 | return T->getName(); | |||
| 174 | if (auto *SP = dyn_cast<DISubprogram>(this)) | |||
| 175 | return SP->getName(); | |||
| 176 | if (auto *NS = dyn_cast<DINamespace>(this)) | |||
| 177 | return NS->getName(); | |||
| 178 | if (auto *M = dyn_cast<DIModule>(this)) | |||
| 179 | return M->getName(); | |||
| 180 | assert((isa<DILexicalBlockBase>(this) || isa<DIFile>(this) ||(static_cast <bool> ((isa<DILexicalBlockBase>(this ) || isa<DIFile>(this) || isa<DICompileUnit>(this )) && "Unhandled type of scope.") ? void (0) : __assert_fail ("(isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 182, __extension__ __PRETTY_FUNCTION__)) | |||
| 181 | isa<DICompileUnit>(this)) &&(static_cast <bool> ((isa<DILexicalBlockBase>(this ) || isa<DIFile>(this) || isa<DICompileUnit>(this )) && "Unhandled type of scope.") ? void (0) : __assert_fail ("(isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 182, __extension__ __PRETTY_FUNCTION__)) | |||
| 182 | "Unhandled type of scope.")(static_cast <bool> ((isa<DILexicalBlockBase>(this ) || isa<DIFile>(this) || isa<DICompileUnit>(this )) && "Unhandled type of scope.") ? void (0) : __assert_fail ("(isa<DILexicalBlockBase>(this) || isa<DIFile>(this) || isa<DICompileUnit>(this)) && \"Unhandled type of scope.\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 182, __extension__ __PRETTY_FUNCTION__)); | |||
| 183 | return ""; | |||
| 184 | } | |||
| 185 | ||||
| 186 | #ifndef NDEBUG | |||
| 187 | static bool isCanonical(const MDString *S) { | |||
| 188 | return !S || !S->getString().empty(); | |||
| 189 | } | |||
| 190 | #endif | |||
| 191 | ||||
| 192 | GenericDINode *GenericDINode::getImpl(LLVMContext &Context, unsigned Tag, | |||
| 193 | MDString *Header, | |||
| 194 | ArrayRef<Metadata *> DwarfOps, | |||
| 195 | StorageType Storage, bool ShouldCreate) { | |||
| 196 | unsigned Hash = 0; | |||
| 197 | if (Storage == Uniqued) { | |||
| 198 | GenericDINodeInfo::KeyTy Key(Tag, Header, DwarfOps); | |||
| 199 | if (auto *N = getUniqued(Context.pImpl->GenericDINodes, Key)) | |||
| 200 | return N; | |||
| 201 | if (!ShouldCreate) | |||
| 202 | return nullptr; | |||
| 203 | Hash = Key.getHash(); | |||
| 204 | } else { | |||
| 205 | assert(ShouldCreate && "Expected non-uniqued nodes to always be created")(static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 205, __extension__ __PRETTY_FUNCTION__)); | |||
| 206 | } | |||
| 207 | ||||
| 208 | // Use a nullptr for empty headers. | |||
| 209 | assert(isCanonical(Header) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Header) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Header) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 209, __extension__ __PRETTY_FUNCTION__)); | |||
| 210 | Metadata *PreOps[] = {Header}; | |||
| 211 | return storeImpl(new (DwarfOps.size() + 1) GenericDINode( | |||
| 212 | Context, Storage, Hash, Tag, PreOps, DwarfOps), | |||
| 213 | Storage, Context.pImpl->GenericDINodes); | |||
| 214 | } | |||
| 215 | ||||
| 216 | void GenericDINode::recalculateHash() { | |||
| 217 | setHash(GenericDINodeInfo::KeyTy::calculateHash(this)); | |||
| 218 | } | |||
| 219 | ||||
| 220 | #define UNWRAP_ARGS_IMPL(...)... __VA_ARGS__ | |||
| 221 | #define UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS UNWRAP_ARGS_IMPL ARGS | |||
| 222 | #define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS)do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->CLASSs, CLASSInfo::KeyTy(UNWRAP_ARGS_IMPL ARGS))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast < bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 222, __extension__ __PRETTY_FUNCTION__)); } } while (false) \ | |||
| 223 | do { \ | |||
| 224 | if (Storage == Uniqued) { \ | |||
| 225 | if (auto *N = getUniqued(Context.pImpl->CLASS##s, \ | |||
| 226 | CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS))) \ | |||
| 227 | return N; \ | |||
| 228 | if (!ShouldCreate) \ | |||
| 229 | return nullptr; \ | |||
| 230 | } else { \ | |||
| 231 | assert(ShouldCreate && \(static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 232, __extension__ __PRETTY_FUNCTION__)) | |||
| 232 | "Expected non-uniqued nodes to always be created")(static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 232, __extension__ __PRETTY_FUNCTION__)); \ | |||
| 233 | } \ | |||
| 234 | } while (false) | |||
| 235 | #define DEFINE_GETIMPL_STORE(CLASS, ARGS, OPS)return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage , UNWRAP_ARGS_IMPL ARGS, OPS), Storage, Context.pImpl->CLASSs ) \ | |||
| 236 | return storeImpl(new (array_lengthof(OPS)) \ | |||
| 237 | CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS, OPS), \ | |||
| 238 | Storage, Context.pImpl->CLASS##s) | |||
| 239 | #define DEFINE_GETIMPL_STORE_NO_OPS(CLASS, ARGS)return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS_IMPL ARGS), Storage, Context.pImpl->CLASSs) \ | |||
| 240 | return storeImpl(new (0u) CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS), \ | |||
| 241 | Storage, Context.pImpl->CLASS##s) | |||
| 242 | #define DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(CLASS, OPS)return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage , OPS), Storage, Context.pImpl->CLASSs) \ | |||
| 243 | return storeImpl(new (array_lengthof(OPS)) CLASS(Context, Storage, OPS), \ | |||
| 244 | Storage, Context.pImpl->CLASS##s) | |||
| 245 | #define DEFINE_GETIMPL_STORE_N(CLASS, ARGS, OPS, NUM_OPS)return storeImpl(new (NUM_OPS) CLASS(Context, Storage, UNWRAP_ARGS_IMPL ARGS, OPS), Storage, Context.pImpl->CLASSs) \ | |||
| 246 | return storeImpl(new (NUM_OPS) \ | |||
| 247 | CLASS(Context, Storage, UNWRAP_ARGS(ARGS)UNWRAP_ARGS_IMPL ARGS, OPS), \ | |||
| 248 | Storage, Context.pImpl->CLASS##s) | |||
| 249 | ||||
| 250 | DISubrange *DISubrange::getImpl(LLVMContext &Context, int64_t Count, int64_t Lo, | |||
| 251 | StorageType Storage, bool ShouldCreate) { | |||
| 252 | auto *CountNode = ConstantAsMetadata::get( | |||
| 253 | ConstantInt::getSigned(Type::getInt64Ty(Context), Count)); | |||
| 254 | return getImpl(Context, CountNode, Lo, Storage, ShouldCreate); | |||
| 255 | } | |||
| 256 | ||||
| 257 | DISubrange *DISubrange::getImpl(LLVMContext &Context, Metadata *CountNode, | |||
| 258 | int64_t Lo, StorageType Storage, | |||
| 259 | bool ShouldCreate) { | |||
| 260 | DEFINE_GETIMPL_LOOKUP(DISubrange, (CountNode, Lo))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DISubranges, DISubrangeInfo::KeyTy(CountNode, Lo)) ) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 260, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 261 | Metadata *Ops[] = { CountNode }; | |||
| 262 | DEFINE_GETIMPL_STORE(DISubrange, (CountNode, Lo), Ops)return storeImpl(new (array_lengthof(Ops)) DISubrange(Context , Storage, CountNode, Lo, Ops), Storage, Context.pImpl->DISubranges ); | |||
| 263 | } | |||
| 264 | ||||
| 265 | DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, int64_t Value, | |||
| 266 | bool IsUnsigned, MDString *Name, | |||
| 267 | StorageType Storage, bool ShouldCreate) { | |||
| 268 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 268, __extension__ __PRETTY_FUNCTION__)); | |||
| 269 | DEFINE_GETIMPL_LOOKUP(DIEnumerator, (Value, IsUnsigned, Name))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIEnumerators, DIEnumeratorInfo::KeyTy(Value, IsUnsigned , Name))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 269, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 270 | Metadata *Ops[] = {Name}; | |||
| 271 | DEFINE_GETIMPL_STORE(DIEnumerator, (Value, IsUnsigned), Ops)return storeImpl(new (array_lengthof(Ops)) DIEnumerator(Context , Storage, Value, IsUnsigned, Ops), Storage, Context.pImpl-> DIEnumerators); | |||
| 272 | } | |||
| 273 | ||||
| 274 | DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag, | |||
| 275 | MDString *Name, uint64_t SizeInBits, | |||
| 276 | uint32_t AlignInBits, unsigned Encoding, | |||
| 277 | StorageType Storage, bool ShouldCreate) { | |||
| 278 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 278, __extension__ __PRETTY_FUNCTION__)); | |||
| 279 | DEFINE_GETIMPL_LOOKUP(DIBasicType,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIBasicTypes, DIBasicTypeInfo::KeyTy(Tag, Name, SizeInBits , AlignInBits, Encoding))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 280, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 280 | (Tag, Name, SizeInBits, AlignInBits, Encoding))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIBasicTypes, DIBasicTypeInfo::KeyTy(Tag, Name, SizeInBits , AlignInBits, Encoding))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 280, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 281 | Metadata *Ops[] = {nullptr, nullptr, Name}; | |||
| 282 | DEFINE_GETIMPL_STORE(DIBasicType, (Tag, SizeInBits, AlignInBits, Encoding),return storeImpl(new (array_lengthof(Ops)) DIBasicType(Context , Storage, Tag, SizeInBits, AlignInBits, Encoding, Ops), Storage , Context.pImpl->DIBasicTypes) | |||
| 283 | Ops)return storeImpl(new (array_lengthof(Ops)) DIBasicType(Context , Storage, Tag, SizeInBits, AlignInBits, Encoding, Ops), Storage , Context.pImpl->DIBasicTypes); | |||
| 284 | } | |||
| 285 | ||||
| 286 | DIDerivedType *DIDerivedType::getImpl( | |||
| 287 | LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, | |||
| 288 | unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, | |||
| 289 | uint32_t AlignInBits, uint64_t OffsetInBits, | |||
| 290 | Optional<unsigned> DWARFAddressSpace, DIFlags Flags, Metadata *ExtraData, | |||
| 291 | StorageType Storage, bool ShouldCreate) { | |||
| 292 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 292, __extension__ __PRETTY_FUNCTION__)); | |||
| 293 | DEFINE_GETIMPL_LOOKUP(DIDerivedType,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name , File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits , DWARFAddressSpace, Flags, ExtraData))) return N; if (!ShouldCreate ) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 296, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 294 | (Tag, Name, File, Line, Scope, BaseType, SizeInBits,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name , File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits , DWARFAddressSpace, Flags, ExtraData))) return N; if (!ShouldCreate ) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 296, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 295 | AlignInBits, OffsetInBits, DWARFAddressSpace, Flags,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name , File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits , DWARFAddressSpace, Flags, ExtraData))) return N; if (!ShouldCreate ) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 296, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 296 | ExtraData))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIDerivedTypes, DIDerivedTypeInfo::KeyTy(Tag, Name , File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits , DWARFAddressSpace, Flags, ExtraData))) return N; if (!ShouldCreate ) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 296, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 297 | Metadata *Ops[] = {File, Scope, Name, BaseType, ExtraData}; | |||
| 298 | DEFINE_GETIMPL_STORE(return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context , Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace , Flags, Ops), Storage, Context.pImpl->DIDerivedTypes) | |||
| 299 | DIDerivedType, (Tag, Line, SizeInBits, AlignInBits, OffsetInBits,return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context , Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace , Flags, Ops), Storage, Context.pImpl->DIDerivedTypes) | |||
| 300 | DWARFAddressSpace, Flags), Ops)return storeImpl(new (array_lengthof(Ops)) DIDerivedType(Context , Storage, Tag, Line, SizeInBits, AlignInBits, OffsetInBits, DWARFAddressSpace , Flags, Ops), Storage, Context.pImpl->DIDerivedTypes); | |||
| 301 | } | |||
| 302 | ||||
| 303 | DICompositeType *DICompositeType::getImpl( | |||
| 304 | LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *File, | |||
| 305 | unsigned Line, Metadata *Scope, Metadata *BaseType, uint64_t SizeInBits, | |||
| 306 | uint32_t AlignInBits, uint64_t OffsetInBits, DIFlags Flags, | |||
| 307 | Metadata *Elements, unsigned RuntimeLang, Metadata *VTableHolder, | |||
| 308 | Metadata *TemplateParams, MDString *Identifier, Metadata *Discriminator, | |||
| 309 | StorageType Storage, bool ShouldCreate) { | |||
| 310 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 310, __extension__ __PRETTY_FUNCTION__)); | |||
| 311 | ||||
| 312 | // Keep this in sync with buildODRType. | |||
| 313 | DEFINE_GETIMPL_LOOKUP(do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name , File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits , Flags, Elements, RuntimeLang, VTableHolder, TemplateParams, Identifier, Discriminator))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 316, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 314 | DICompositeType, (Tag, Name, File, Line, Scope, BaseType, SizeInBits,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name , File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits , Flags, Elements, RuntimeLang, VTableHolder, TemplateParams, Identifier, Discriminator))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 316, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 315 | AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name , File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits , Flags, Elements, RuntimeLang, VTableHolder, TemplateParams, Identifier, Discriminator))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 316, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 316 | VTableHolder, TemplateParams, Identifier, Discriminator))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DICompositeTypes, DICompositeTypeInfo::KeyTy(Tag, Name , File, Line, Scope, BaseType, SizeInBits, AlignInBits, OffsetInBits , Flags, Elements, RuntimeLang, VTableHolder, TemplateParams, Identifier, Discriminator))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 316, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 317 | Metadata *Ops[] = {File, Scope, Name, BaseType, | |||
| 318 | Elements, VTableHolder, TemplateParams, Identifier, | |||
| 319 | Discriminator}; | |||
| 320 | DEFINE_GETIMPL_STORE(DICompositeType, (Tag, Line, RuntimeLang, SizeInBits,return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context , Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits , Flags, Ops), Storage, Context.pImpl->DICompositeTypes) | |||
| 321 | AlignInBits, OffsetInBits, Flags),return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context , Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits , Flags, Ops), Storage, Context.pImpl->DICompositeTypes) | |||
| 322 | Ops)return storeImpl(new (array_lengthof(Ops)) DICompositeType(Context , Storage, Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits , Flags, Ops), Storage, Context.pImpl->DICompositeTypes); | |||
| 323 | } | |||
| 324 | ||||
| 325 | DICompositeType *DICompositeType::buildODRType( | |||
| 326 | LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, | |||
| 327 | Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, | |||
| 328 | uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, | |||
| 329 | DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, | |||
| 330 | Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator) { | |||
| 331 | assert(!Identifier.getString().empty() && "Expected valid identifier")(static_cast <bool> (!Identifier.getString().empty() && "Expected valid identifier") ? void (0) : __assert_fail ("!Identifier.getString().empty() && \"Expected valid identifier\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 331, __extension__ __PRETTY_FUNCTION__)); | |||
| 332 | if (!Context.isODRUniquingDebugTypes()) | |||
| 333 | return nullptr; | |||
| 334 | auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; | |||
| 335 | if (!CT) | |||
| 336 | return CT = DICompositeType::getDistinct( | |||
| 337 | Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, | |||
| 338 | AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, | |||
| 339 | VTableHolder, TemplateParams, &Identifier, Discriminator); | |||
| 340 | ||||
| 341 | // Only mutate CT if it's a forward declaration and the new operands aren't. | |||
| 342 | assert(CT->getRawIdentifier() == &Identifier && "Wrong ODR identifier?")(static_cast <bool> (CT->getRawIdentifier() == & Identifier && "Wrong ODR identifier?") ? void (0) : __assert_fail ("CT->getRawIdentifier() == &Identifier && \"Wrong ODR identifier?\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 342, __extension__ __PRETTY_FUNCTION__)); | |||
| 343 | if (!CT->isForwardDecl() || (Flags & DINode::FlagFwdDecl)) | |||
| 344 | return CT; | |||
| 345 | ||||
| 346 | // Mutate CT in place. Keep this in sync with getImpl. | |||
| 347 | CT->mutate(Tag, Line, RuntimeLang, SizeInBits, AlignInBits, OffsetInBits, | |||
| 348 | Flags); | |||
| 349 | Metadata *Ops[] = {File, Scope, Name, BaseType, | |||
| 350 | Elements, VTableHolder, TemplateParams, &Identifier, | |||
| 351 | Discriminator}; | |||
| 352 | assert((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() &&(static_cast <bool> ((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && "Mismatched number of operands" ) ? void (0) : __assert_fail ("(std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && \"Mismatched number of operands\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 353, __extension__ __PRETTY_FUNCTION__)) | |||
| 353 | "Mismatched number of operands")(static_cast <bool> ((std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && "Mismatched number of operands" ) ? void (0) : __assert_fail ("(std::end(Ops) - std::begin(Ops)) == (int)CT->getNumOperands() && \"Mismatched number of operands\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 353, __extension__ __PRETTY_FUNCTION__)); | |||
| 354 | for (unsigned I = 0, E = CT->getNumOperands(); I != E; ++I) | |||
| 355 | if (Ops[I] != CT->getOperand(I)) | |||
| 356 | CT->setOperand(I, Ops[I]); | |||
| 357 | return CT; | |||
| 358 | } | |||
| 359 | ||||
| 360 | DICompositeType *DICompositeType::getODRType( | |||
| 361 | LLVMContext &Context, MDString &Identifier, unsigned Tag, MDString *Name, | |||
| 362 | Metadata *File, unsigned Line, Metadata *Scope, Metadata *BaseType, | |||
| 363 | uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, | |||
| 364 | DIFlags Flags, Metadata *Elements, unsigned RuntimeLang, | |||
| 365 | Metadata *VTableHolder, Metadata *TemplateParams, Metadata *Discriminator) { | |||
| 366 | assert(!Identifier.getString().empty() && "Expected valid identifier")(static_cast <bool> (!Identifier.getString().empty() && "Expected valid identifier") ? void (0) : __assert_fail ("!Identifier.getString().empty() && \"Expected valid identifier\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 366, __extension__ __PRETTY_FUNCTION__)); | |||
| 367 | if (!Context.isODRUniquingDebugTypes()) | |||
| 368 | return nullptr; | |||
| 369 | auto *&CT = (*Context.pImpl->DITypeMap)[&Identifier]; | |||
| 370 | if (!CT) | |||
| 371 | CT = DICompositeType::getDistinct( | |||
| 372 | Context, Tag, Name, File, Line, Scope, BaseType, SizeInBits, | |||
| 373 | AlignInBits, OffsetInBits, Flags, Elements, RuntimeLang, VTableHolder, | |||
| 374 | TemplateParams, &Identifier, Discriminator); | |||
| 375 | return CT; | |||
| 376 | } | |||
| 377 | ||||
| 378 | DICompositeType *DICompositeType::getODRTypeIfExists(LLVMContext &Context, | |||
| 379 | MDString &Identifier) { | |||
| 380 | assert(!Identifier.getString().empty() && "Expected valid identifier")(static_cast <bool> (!Identifier.getString().empty() && "Expected valid identifier") ? void (0) : __assert_fail ("!Identifier.getString().empty() && \"Expected valid identifier\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 380, __extension__ __PRETTY_FUNCTION__)); | |||
| 381 | if (!Context.isODRUniquingDebugTypes()) | |||
| 382 | return nullptr; | |||
| 383 | return Context.pImpl->DITypeMap->lookup(&Identifier); | |||
| 384 | } | |||
| 385 | ||||
| 386 | DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags, | |||
| 387 | uint8_t CC, Metadata *TypeArray, | |||
| 388 | StorageType Storage, | |||
| 389 | bool ShouldCreate) { | |||
| 390 | DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DISubroutineTypes, DISubroutineTypeInfo::KeyTy(Flags , CC, TypeArray))) return N; if (!ShouldCreate) return nullptr ; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 390, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 391 | Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray}; | |||
| 392 | DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops)return storeImpl(new (array_lengthof(Ops)) DISubroutineType(Context , Storage, Flags, CC, Ops), Storage, Context.pImpl->DISubroutineTypes ); | |||
| 393 | } | |||
| 394 | ||||
| 395 | // FIXME: Implement this string-enum correspondence with a .def file and macros, | |||
| 396 | // so that the association is explicit rather than implied. | |||
| 397 | static const char *ChecksumKindName[DIFile::CSK_Last] = { | |||
| 398 | "CSK_MD5", | |||
| 399 | "CSK_SHA1" | |||
| 400 | }; | |||
| 401 | ||||
| 402 | StringRef DIFile::getChecksumKindAsString(ChecksumKind CSKind) { | |||
| 403 | assert(CSKind <= DIFile::CSK_Last && "Invalid checksum kind")(static_cast <bool> (CSKind <= DIFile::CSK_Last && "Invalid checksum kind") ? void (0) : __assert_fail ("CSKind <= DIFile::CSK_Last && \"Invalid checksum kind\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 403, __extension__ __PRETTY_FUNCTION__)); | |||
| 404 | // The first space was originally the CSK_None variant, which is now | |||
| 405 | // obsolete, but the space is still reserved in ChecksumKind, so we account | |||
| 406 | // for it here. | |||
| 407 | return ChecksumKindName[CSKind - 1]; | |||
| 408 | } | |||
| 409 | ||||
| 410 | Optional<DIFile::ChecksumKind> DIFile::getChecksumKind(StringRef CSKindStr) { | |||
| 411 | return StringSwitch<Optional<DIFile::ChecksumKind>>(CSKindStr) | |||
| 412 | .Case("CSK_MD5", DIFile::CSK_MD5) | |||
| 413 | .Case("CSK_SHA1", DIFile::CSK_SHA1) | |||
| 414 | .Default(None); | |||
| 415 | } | |||
| 416 | ||||
| 417 | DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename, | |||
| 418 | MDString *Directory, | |||
| 419 | Optional<DIFile::ChecksumInfo<MDString *>> CS, | |||
| 420 | Optional<MDString *> Source, StorageType Storage, | |||
| 421 | bool ShouldCreate) { | |||
| 422 | assert(isCanonical(Filename) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Filename) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Filename) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 422, __extension__ __PRETTY_FUNCTION__)); | |||
| 423 | assert(isCanonical(Directory) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Directory) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Directory) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 423, __extension__ __PRETTY_FUNCTION__)); | |||
| 424 | assert((!CS || isCanonical(CS->Value)) && "Expected canonical MDString")(static_cast <bool> ((!CS || isCanonical(CS->Value)) && "Expected canonical MDString") ? void (0) : __assert_fail ("(!CS || isCanonical(CS->Value)) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 424, __extension__ __PRETTY_FUNCTION__)); | |||
| 425 | assert((!Source || isCanonical(*Source)) && "Expected canonical MDString")(static_cast <bool> ((!Source || isCanonical(*Source)) && "Expected canonical MDString") ? void (0) : __assert_fail ("(!Source || isCanonical(*Source)) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 425, __extension__ __PRETTY_FUNCTION__)); | |||
| 426 | DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, CS, Source))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIFiles, DIFileInfo::KeyTy(Filename, Directory, CS , Source))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 426, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 427 | Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr, | |||
| 428 | Source.getValueOr(nullptr)}; | |||
| 429 | DEFINE_GETIMPL_STORE(DIFile, (CS, Source), Ops)return storeImpl(new (array_lengthof(Ops)) DIFile(Context, Storage , CS, Source, Ops), Storage, Context.pImpl->DIFiles); | |||
| 430 | } | |||
| 431 | ||||
| 432 | DICompileUnit *DICompileUnit::getImpl( | |||
| 433 | LLVMContext &Context, unsigned SourceLanguage, Metadata *File, | |||
| 434 | MDString *Producer, bool IsOptimized, MDString *Flags, | |||
| 435 | unsigned RuntimeVersion, MDString *SplitDebugFilename, | |||
| 436 | unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes, | |||
| 437 | Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros, | |||
| 438 | uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling, | |||
| 439 | bool GnuPubnames, StorageType Storage, bool ShouldCreate) { | |||
| 440 | assert(Storage != Uniqued && "Cannot unique DICompileUnit")(static_cast <bool> (Storage != Uniqued && "Cannot unique DICompileUnit" ) ? void (0) : __assert_fail ("Storage != Uniqued && \"Cannot unique DICompileUnit\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 440, __extension__ __PRETTY_FUNCTION__)); | |||
| 441 | assert(isCanonical(Producer) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Producer) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Producer) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 441, __extension__ __PRETTY_FUNCTION__)); | |||
| 442 | assert(isCanonical(Flags) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Flags) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Flags) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 442, __extension__ __PRETTY_FUNCTION__)); | |||
| 443 | assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString")(static_cast <bool> (isCanonical(SplitDebugFilename) && "Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(SplitDebugFilename) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 443, __extension__ __PRETTY_FUNCTION__)); | |||
| 444 | ||||
| 445 | Metadata *Ops[] = { | |||
| 446 | File, Producer, Flags, SplitDebugFilename, | |||
| 447 | EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities, | |||
| 448 | Macros}; | |||
| 449 | return storeImpl(new (array_lengthof(Ops)) DICompileUnit( | |||
| 450 | Context, Storage, SourceLanguage, IsOptimized, | |||
| 451 | RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining, | |||
| 452 | DebugInfoForProfiling, GnuPubnames, Ops), | |||
| 453 | Storage); | |||
| 454 | } | |||
| 455 | ||||
| 456 | Optional<DICompileUnit::DebugEmissionKind> | |||
| 457 | DICompileUnit::getEmissionKind(StringRef Str) { | |||
| 458 | return StringSwitch<Optional<DebugEmissionKind>>(Str) | |||
| 459 | .Case("NoDebug", NoDebug) | |||
| 460 | .Case("FullDebug", FullDebug) | |||
| 461 | .Case("LineTablesOnly", LineTablesOnly) | |||
| 462 | .Default(None); | |||
| 463 | } | |||
| 464 | ||||
| 465 | const char *DICompileUnit::EmissionKindString(DebugEmissionKind EK) { | |||
| 466 | switch (EK) { | |||
| 467 | case NoDebug: return "NoDebug"; | |||
| 468 | case FullDebug: return "FullDebug"; | |||
| 469 | case LineTablesOnly: return "LineTablesOnly"; | |||
| 470 | } | |||
| 471 | return nullptr; | |||
| 472 | } | |||
| 473 | ||||
| 474 | DISubprogram *DILocalScope::getSubprogram() const { | |||
| 475 | if (auto *Block = dyn_cast<DILexicalBlockBase>(this)) | |||
| 476 | return Block->getScope()->getSubprogram(); | |||
| 477 | return const_cast<DISubprogram *>(cast<DISubprogram>(this)); | |||
| 478 | } | |||
| 479 | ||||
| 480 | DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const { | |||
| 481 | if (auto *File = dyn_cast<DILexicalBlockFile>(this)) | |||
| 482 | return File->getScope()->getNonLexicalBlockFileScope(); | |||
| 483 | return const_cast<DILocalScope *>(this); | |||
| 484 | } | |||
| 485 | ||||
| 486 | DISubprogram *DISubprogram::getImpl( | |||
| 487 | LLVMContext &Context, Metadata *Scope, MDString *Name, | |||
| 488 | MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type, | |||
| 489 | bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine, | |||
| 490 | Metadata *ContainingType, unsigned Virtuality, unsigned VirtualIndex, | |||
| 491 | int ThisAdjustment, DIFlags Flags, bool IsOptimized, Metadata *Unit, | |||
| 492 | Metadata *TemplateParams, Metadata *Declaration, Metadata *Variables, | |||
| 493 | Metadata *ThrownTypes, StorageType Storage, bool ShouldCreate) { | |||
| 494 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 494, __extension__ __PRETTY_FUNCTION__)); | |||
| 495 | assert(isCanonical(LinkageName) && "Expected canonical MDString")(static_cast <bool> (isCanonical(LinkageName) && "Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(LinkageName) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 495, __extension__ __PRETTY_FUNCTION__)); | |||
| 496 | DEFINE_GETIMPL_LOOKUP(do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name , LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment , Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables , ThrownTypes))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 500, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 497 | DISubprogram, (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name , LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment , Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables , ThrownTypes))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 500, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 498 | IsDefinition, ScopeLine, ContainingType, Virtuality,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name , LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment , Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables , ThrownTypes))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 500, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 499 | VirtualIndex, ThisAdjustment, Flags, IsOptimized, Unit,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name , LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment , Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables , ThrownTypes))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 500, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 500 | TemplateParams, Declaration, Variables, ThrownTypes))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DISubprograms, DISubprogramInfo::KeyTy(Scope, Name , LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition, ScopeLine, ContainingType, Virtuality, VirtualIndex, ThisAdjustment , Flags, IsOptimized, Unit, TemplateParams, Declaration, Variables , ThrownTypes))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 500, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 501 | SmallVector<Metadata *, 11> Ops = { | |||
| 502 | File, Scope, Name, LinkageName, Type, Unit, | |||
| 503 | Declaration, Variables, ContainingType, TemplateParams, ThrownTypes}; | |||
| 504 | if (!ThrownTypes) { | |||
| 505 | Ops.pop_back(); | |||
| 506 | if (!TemplateParams) { | |||
| 507 | Ops.pop_back(); | |||
| 508 | if (!ContainingType) | |||
| 509 | Ops.pop_back(); | |||
| 510 | } | |||
| 511 | } | |||
| 512 | DEFINE_GETIMPL_STORE_N(DISubprogram,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage , Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags , IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context .pImpl->DISubprograms) | |||
| 513 | (Line, ScopeLine, Virtuality, VirtualIndex,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage , Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags , IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context .pImpl->DISubprograms) | |||
| 514 | ThisAdjustment, Flags, IsLocalToUnit, IsDefinition,return storeImpl(new (Ops.size()) DISubprogram(Context, Storage , Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags , IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context .pImpl->DISubprograms) | |||
| 515 | IsOptimized),return storeImpl(new (Ops.size()) DISubprogram(Context, Storage , Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags , IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context .pImpl->DISubprograms) | |||
| 516 | Ops, Ops.size())return storeImpl(new (Ops.size()) DISubprogram(Context, Storage , Line, ScopeLine, Virtuality, VirtualIndex, ThisAdjustment, Flags , IsLocalToUnit, IsDefinition, IsOptimized, Ops), Storage, Context .pImpl->DISubprograms); | |||
| 517 | } | |||
| 518 | ||||
| 519 | bool DISubprogram::describes(const Function *F) const { | |||
| 520 | assert(F && "Invalid function")(static_cast <bool> (F && "Invalid function") ? void (0) : __assert_fail ("F && \"Invalid function\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 520, __extension__ __PRETTY_FUNCTION__)); | |||
| 521 | if (F->getSubprogram() == this) | |||
| 522 | return true; | |||
| 523 | StringRef Name = getLinkageName(); | |||
| 524 | if (Name.empty()) | |||
| 525 | Name = getName(); | |||
| 526 | return F->getName() == Name; | |||
| 527 | } | |||
| 528 | ||||
| 529 | DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope, | |||
| 530 | Metadata *File, unsigned Line, | |||
| 531 | unsigned Column, StorageType Storage, | |||
| 532 | bool ShouldCreate) { | |||
| 533 | // Fixup column. | |||
| 534 | adjustColumn(Column); | |||
| 535 | ||||
| 536 | assert(Scope && "Expected scope")(static_cast <bool> (Scope && "Expected scope") ? void (0) : __assert_fail ("Scope && \"Expected scope\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 536, __extension__ __PRETTY_FUNCTION__)); | |||
| 537 | DEFINE_GETIMPL_LOOKUP(DILexicalBlock, (Scope, File, Line, Column))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DILexicalBlocks, DILexicalBlockInfo::KeyTy(Scope, File , Line, Column))) return N; if (!ShouldCreate) return nullptr ; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 537, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 538 | Metadata *Ops[] = {File, Scope}; | |||
| 539 | DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops)return storeImpl(new (array_lengthof(Ops)) DILexicalBlock(Context , Storage, Line, Column, Ops), Storage, Context.pImpl->DILexicalBlocks ); | |||
| 540 | } | |||
| 541 | ||||
| 542 | DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context, | |||
| 543 | Metadata *Scope, Metadata *File, | |||
| 544 | unsigned Discriminator, | |||
| 545 | StorageType Storage, | |||
| 546 | bool ShouldCreate) { | |||
| 547 | assert(Scope && "Expected scope")(static_cast <bool> (Scope && "Expected scope") ? void (0) : __assert_fail ("Scope && \"Expected scope\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 547, __extension__ __PRETTY_FUNCTION__)); | |||
| 548 | DEFINE_GETIMPL_LOOKUP(DILexicalBlockFile, (Scope, File, Discriminator))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DILexicalBlockFiles, DILexicalBlockFileInfo::KeyTy (Scope, File, Discriminator))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 548, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 549 | Metadata *Ops[] = {File, Scope}; | |||
| 550 | DEFINE_GETIMPL_STORE(DILexicalBlockFile, (Discriminator), Ops)return storeImpl(new (array_lengthof(Ops)) DILexicalBlockFile (Context, Storage, Discriminator, Ops), Storage, Context.pImpl ->DILexicalBlockFiles); | |||
| 551 | } | |||
| 552 | ||||
| 553 | DINamespace *DINamespace::getImpl(LLVMContext &Context, Metadata *Scope, | |||
| 554 | MDString *Name, bool ExportSymbols, | |||
| 555 | StorageType Storage, bool ShouldCreate) { | |||
| 556 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 556, __extension__ __PRETTY_FUNCTION__)); | |||
| 557 | DEFINE_GETIMPL_LOOKUP(DINamespace, (Scope, Name, ExportSymbols))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DINamespaces, DINamespaceInfo::KeyTy(Scope, Name, ExportSymbols ))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 557, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 558 | // The nullptr is for DIScope's File operand. This should be refactored. | |||
| 559 | Metadata *Ops[] = {nullptr, Scope, Name}; | |||
| 560 | DEFINE_GETIMPL_STORE(DINamespace, (ExportSymbols), Ops)return storeImpl(new (array_lengthof(Ops)) DINamespace(Context , Storage, ExportSymbols, Ops), Storage, Context.pImpl->DINamespaces ); | |||
| 561 | } | |||
| 562 | ||||
| 563 | DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *Scope, | |||
| 564 | MDString *Name, MDString *ConfigurationMacros, | |||
| 565 | MDString *IncludePath, MDString *ISysRoot, | |||
| 566 | StorageType Storage, bool ShouldCreate) { | |||
| 567 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 567, __extension__ __PRETTY_FUNCTION__)); | |||
| 568 | DEFINE_GETIMPL_LOOKUP(do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIModules, DIModuleInfo::KeyTy(Scope, Name, ConfigurationMacros , IncludePath, ISysRoot))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 569, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 569 | DIModule, (Scope, Name, ConfigurationMacros, IncludePath, ISysRoot))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIModules, DIModuleInfo::KeyTy(Scope, Name, ConfigurationMacros , IncludePath, ISysRoot))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 569, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 570 | Metadata *Ops[] = {Scope, Name, ConfigurationMacros, IncludePath, ISysRoot}; | |||
| 571 | DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIModule, Ops)return storeImpl(new (array_lengthof(Ops)) DIModule(Context, Storage , Ops), Storage, Context.pImpl->DIModules); | |||
| 572 | } | |||
| 573 | ||||
| 574 | DITemplateTypeParameter *DITemplateTypeParameter::getImpl(LLVMContext &Context, | |||
| 575 | MDString *Name, | |||
| 576 | Metadata *Type, | |||
| 577 | StorageType Storage, | |||
| 578 | bool ShouldCreate) { | |||
| 579 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 579, __extension__ __PRETTY_FUNCTION__)); | |||
| 580 | DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DITemplateTypeParameters, DITemplateTypeParameterInfo ::KeyTy(Name, Type))) return N; if (!ShouldCreate) return nullptr ; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 580, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 581 | Metadata *Ops[] = {Name, Type}; | |||
| 582 | DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DITemplateTypeParameter, Ops)return storeImpl(new (array_lengthof(Ops)) DITemplateTypeParameter (Context, Storage, Ops), Storage, Context.pImpl->DITemplateTypeParameters ); | |||
| 583 | } | |||
| 584 | ||||
| 585 | DITemplateValueParameter *DITemplateValueParameter::getImpl( | |||
| 586 | LLVMContext &Context, unsigned Tag, MDString *Name, Metadata *Type, | |||
| 587 | Metadata *Value, StorageType Storage, bool ShouldCreate) { | |||
| 588 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 588, __extension__ __PRETTY_FUNCTION__)); | |||
| 589 | DEFINE_GETIMPL_LOOKUP(DITemplateValueParameter, (Tag, Name, Type, Value))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DITemplateValueParameters, DITemplateValueParameterInfo ::KeyTy(Tag, Name, Type, Value))) return N; if (!ShouldCreate ) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 589, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 590 | Metadata *Ops[] = {Name, Type, Value}; | |||
| 591 | DEFINE_GETIMPL_STORE(DITemplateValueParameter, (Tag), Ops)return storeImpl(new (array_lengthof(Ops)) DITemplateValueParameter (Context, Storage, Tag, Ops), Storage, Context.pImpl->DITemplateValueParameters ); | |||
| 592 | } | |||
| 593 | ||||
| 594 | DIGlobalVariable * | |||
| 595 | DIGlobalVariable::getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name, | |||
| 596 | MDString *LinkageName, Metadata *File, unsigned Line, | |||
| 597 | Metadata *Type, bool IsLocalToUnit, bool IsDefinition, | |||
| 598 | Metadata *StaticDataMemberDeclaration, | |||
| 599 | uint32_t AlignInBits, StorageType Storage, | |||
| 600 | bool ShouldCreate) { | |||
| 601 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 601, __extension__ __PRETTY_FUNCTION__)); | |||
| 602 | assert(isCanonical(LinkageName) && "Expected canonical MDString")(static_cast <bool> (isCanonical(LinkageName) && "Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(LinkageName) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 602, __extension__ __PRETTY_FUNCTION__)); | |||
| 603 | DEFINE_GETIMPL_LOOKUP(DIGlobalVariable,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope , Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition , StaticDataMemberDeclaration, AlignInBits))) return N; if (! ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 606, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 604 | (Scope, Name, LinkageName, File, Line, Type,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope , Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition , StaticDataMemberDeclaration, AlignInBits))) return N; if (! ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 606, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 605 | IsLocalToUnit, IsDefinition,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope , Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition , StaticDataMemberDeclaration, AlignInBits))) return N; if (! ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 606, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 606 | StaticDataMemberDeclaration, AlignInBits))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIGlobalVariables, DIGlobalVariableInfo::KeyTy(Scope , Name, LinkageName, File, Line, Type, IsLocalToUnit, IsDefinition , StaticDataMemberDeclaration, AlignInBits))) return N; if (! ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 606, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 607 | Metadata *Ops[] = { | |||
| 608 | Scope, Name, File, Type, Name, LinkageName, StaticDataMemberDeclaration}; | |||
| 609 | DEFINE_GETIMPL_STORE(DIGlobalVariable,return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context , Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops ), Storage, Context.pImpl->DIGlobalVariables) | |||
| 610 | (Line, IsLocalToUnit, IsDefinition, AlignInBits),return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context , Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops ), Storage, Context.pImpl->DIGlobalVariables) | |||
| 611 | Ops)return storeImpl(new (array_lengthof(Ops)) DIGlobalVariable(Context , Storage, Line, IsLocalToUnit, IsDefinition, AlignInBits, Ops ), Storage, Context.pImpl->DIGlobalVariables); | |||
| 612 | } | |||
| 613 | ||||
| 614 | DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope, | |||
| 615 | MDString *Name, Metadata *File, | |||
| 616 | unsigned Line, Metadata *Type, | |||
| 617 | unsigned Arg, DIFlags Flags, | |||
| 618 | uint32_t AlignInBits, | |||
| 619 | StorageType Storage, | |||
| 620 | bool ShouldCreate) { | |||
| 621 | // 64K ought to be enough for any frontend. | |||
| 622 | assert(Arg <= UINT16_MAX && "Expected argument number to fit in 16-bits")(static_cast <bool> (Arg <= (65535) && "Expected argument number to fit in 16-bits" ) ? void (0) : __assert_fail ("Arg <= UINT16_MAX && \"Expected argument number to fit in 16-bits\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 622, __extension__ __PRETTY_FUNCTION__)); | |||
| 623 | ||||
| 624 | assert(Scope && "Expected scope")(static_cast <bool> (Scope && "Expected scope") ? void (0) : __assert_fail ("Scope && \"Expected scope\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 624, __extension__ __PRETTY_FUNCTION__)); | |||
| 625 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 625, __extension__ __PRETTY_FUNCTION__)); | |||
| 626 | DEFINE_GETIMPL_LOOKUP(DILocalVariable,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DILocalVariables, DILocalVariableInfo::KeyTy(Scope , Name, File, Line, Type, Arg, Flags, AlignInBits))) return N ; if (!ShouldCreate) return nullptr; } else { (static_cast < bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 628, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 627 | (Scope, Name, File, Line, Type, Arg, Flags,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DILocalVariables, DILocalVariableInfo::KeyTy(Scope , Name, File, Line, Type, Arg, Flags, AlignInBits))) return N ; if (!ShouldCreate) return nullptr; } else { (static_cast < bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 628, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 628 | AlignInBits))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DILocalVariables, DILocalVariableInfo::KeyTy(Scope , Name, File, Line, Type, Arg, Flags, AlignInBits))) return N ; if (!ShouldCreate) return nullptr; } else { (static_cast < bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 628, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 629 | Metadata *Ops[] = {Scope, Name, File, Type}; | |||
| 630 | DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops)return storeImpl(new (array_lengthof(Ops)) DILocalVariable(Context , Storage, Line, Arg, Flags, AlignInBits, Ops), Storage, Context .pImpl->DILocalVariables); | |||
| 631 | } | |||
| 632 | ||||
| 633 | Optional<uint64_t> DIVariable::getSizeInBits() const { | |||
| 634 | // This is used by the Verifier so be mindful of broken types. | |||
| 635 | const Metadata *RawType = getRawType(); | |||
| 636 | while (RawType) { | |||
| 637 | // Try to get the size directly. | |||
| 638 | if (auto *T = dyn_cast<DIType>(RawType)) | |||
| 639 | if (uint64_t Size = T->getSizeInBits()) | |||
| 640 | return Size; | |||
| 641 | ||||
| 642 | if (auto *DT = dyn_cast<DIDerivedType>(RawType)) { | |||
| 643 | // Look at the base type. | |||
| 644 | RawType = DT->getRawBaseType(); | |||
| 645 | continue; | |||
| 646 | } | |||
| 647 | ||||
| 648 | // Missing type or size. | |||
| 649 | break; | |||
| 650 | } | |||
| 651 | ||||
| 652 | // Fail gracefully. | |||
| 653 | return None; | |||
| 654 | } | |||
| 655 | ||||
| 656 | DIExpression *DIExpression::getImpl(LLVMContext &Context, | |||
| 657 | ArrayRef<uint64_t> Elements, | |||
| 658 | StorageType Storage, bool ShouldCreate) { | |||
| 659 | DEFINE_GETIMPL_LOOKUP(DIExpression, (Elements))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIExpressions, DIExpressionInfo::KeyTy(Elements))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 659, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 660 | DEFINE_GETIMPL_STORE_NO_OPS(DIExpression, (Elements))return storeImpl(new (0u) DIExpression(Context, Storage, Elements ), Storage, Context.pImpl->DIExpressions); | |||
| 661 | } | |||
| 662 | ||||
| 663 | unsigned DIExpression::ExprOperand::getSize() const { | |||
| 664 | switch (getOp()) { | |||
| 665 | case dwarf::DW_OP_LLVM_fragment: | |||
| 666 | return 3; | |||
| 667 | case dwarf::DW_OP_constu: | |||
| 668 | case dwarf::DW_OP_plus_uconst: | |||
| 669 | return 2; | |||
| 670 | default: | |||
| 671 | return 1; | |||
| 672 | } | |||
| 673 | } | |||
| 674 | ||||
| 675 | bool DIExpression::isValid() const { | |||
| 676 | for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) { | |||
| 677 | // Check that there's space for the operand. | |||
| 678 | if (I->get() + I->getSize() > E->get()) | |||
| 679 | return false; | |||
| 680 | ||||
| 681 | // Check that the operand is valid. | |||
| 682 | switch (I->getOp()) { | |||
| 683 | default: | |||
| 684 | return false; | |||
| 685 | case dwarf::DW_OP_LLVM_fragment: | |||
| 686 | // A fragment operator must appear at the end. | |||
| 687 | return I->get() + I->getSize() == E->get(); | |||
| 688 | case dwarf::DW_OP_stack_value: { | |||
| 689 | // Must be the last one or followed by a DW_OP_LLVM_fragment. | |||
| 690 | if (I->get() + I->getSize() == E->get()) | |||
| 691 | break; | |||
| 692 | auto J = I; | |||
| 693 | if ((++J)->getOp() != dwarf::DW_OP_LLVM_fragment) | |||
| 694 | return false; | |||
| 695 | break; | |||
| 696 | } | |||
| 697 | case dwarf::DW_OP_swap: { | |||
| 698 | // Must be more than one implicit element on the stack. | |||
| 699 | ||||
| 700 | // FIXME: A better way to implement this would be to add a local variable | |||
| 701 | // that keeps track of the stack depth and introduce something like a | |||
| 702 | // DW_LLVM_OP_implicit_location as a placeholder for the location this | |||
| 703 | // DIExpression is attached to, or else pass the number of implicit stack | |||
| 704 | // elements into isValid. | |||
| 705 | if (getNumElements() == 1) | |||
| 706 | return false; | |||
| 707 | break; | |||
| 708 | } | |||
| 709 | case dwarf::DW_OP_constu: | |||
| 710 | case dwarf::DW_OP_plus_uconst: | |||
| 711 | case dwarf::DW_OP_plus: | |||
| 712 | case dwarf::DW_OP_minus: | |||
| 713 | case dwarf::DW_OP_mul: | |||
| 714 | case dwarf::DW_OP_div: | |||
| 715 | case dwarf::DW_OP_mod: | |||
| 716 | case dwarf::DW_OP_or: | |||
| 717 | case dwarf::DW_OP_and: | |||
| 718 | case dwarf::DW_OP_xor: | |||
| 719 | case dwarf::DW_OP_shl: | |||
| 720 | case dwarf::DW_OP_shr: | |||
| 721 | case dwarf::DW_OP_shra: | |||
| 722 | case dwarf::DW_OP_deref: | |||
| 723 | case dwarf::DW_OP_xderef: | |||
| 724 | break; | |||
| 725 | } | |||
| 726 | } | |||
| 727 | return true; | |||
| 728 | } | |||
| 729 | ||||
| 730 | Optional<DIExpression::FragmentInfo> | |||
| 731 | DIExpression::getFragmentInfo(expr_op_iterator Start, expr_op_iterator End) { | |||
| 732 | for (auto I = Start; I != End; ++I) | |||
| 733 | if (I->getOp() == dwarf::DW_OP_LLVM_fragment) { | |||
| 734 | DIExpression::FragmentInfo Info = {I->getArg(1), I->getArg(0)}; | |||
| 735 | return Info; | |||
| 736 | } | |||
| 737 | return None; | |||
| 738 | } | |||
| 739 | ||||
| 740 | void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops, | |||
| 741 | int64_t Offset) { | |||
| 742 | if (Offset > 0) { | |||
| 743 | Ops.push_back(dwarf::DW_OP_plus_uconst); | |||
| 744 | Ops.push_back(Offset); | |||
| 745 | } else if (Offset < 0) { | |||
| 746 | Ops.push_back(dwarf::DW_OP_constu); | |||
| 747 | Ops.push_back(-Offset); | |||
| 748 | Ops.push_back(dwarf::DW_OP_minus); | |||
| 749 | } | |||
| 750 | } | |||
| 751 | ||||
| 752 | bool DIExpression::extractIfOffset(int64_t &Offset) const { | |||
| 753 | if (getNumElements() == 0) { | |||
| 754 | Offset = 0; | |||
| 755 | return true; | |||
| 756 | } | |||
| 757 | ||||
| 758 | if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) { | |||
| 759 | Offset = Elements[1]; | |||
| 760 | return true; | |||
| 761 | } | |||
| 762 | ||||
| 763 | if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) { | |||
| 764 | if (Elements[2] == dwarf::DW_OP_plus) { | |||
| 765 | Offset = Elements[1]; | |||
| 766 | return true; | |||
| 767 | } | |||
| 768 | if (Elements[2] == dwarf::DW_OP_minus) { | |||
| 769 | Offset = -Elements[1]; | |||
| 770 | return true; | |||
| 771 | } | |||
| 772 | } | |||
| 773 | ||||
| 774 | return false; | |||
| 775 | } | |||
| 776 | ||||
| 777 | DIExpression *DIExpression::prepend(const DIExpression *Expr, bool DerefBefore, | |||
| 778 | int64_t Offset, bool DerefAfter, | |||
| 779 | bool StackValue) { | |||
| 780 | SmallVector<uint64_t, 8> Ops; | |||
| 781 | if (DerefBefore) | |||
| ||||
| 782 | Ops.push_back(dwarf::DW_OP_deref); | |||
| 783 | ||||
| 784 | appendOffset(Ops, Offset); | |||
| 785 | if (DerefAfter) | |||
| 786 | Ops.push_back(dwarf::DW_OP_deref); | |||
| 787 | ||||
| 788 | return doPrepend(Expr, Ops, StackValue); | |||
| 789 | } | |||
| 790 | ||||
| 791 | DIExpression *DIExpression::doPrepend(const DIExpression *Expr, | |||
| 792 | SmallVectorImpl<uint64_t> &Ops, | |||
| 793 | bool StackValue) { | |||
| 794 | if (Expr) | |||
| 795 | for (auto Op : Expr->expr_ops()) { | |||
| 796 | // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment. | |||
| 797 | if (StackValue) { | |||
| 798 | if (Op.getOp() == dwarf::DW_OP_stack_value) | |||
| 799 | StackValue = false; | |||
| 800 | else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) { | |||
| 801 | Ops.push_back(dwarf::DW_OP_stack_value); | |||
| 802 | StackValue = false; | |||
| 803 | } | |||
| 804 | } | |||
| 805 | Ops.push_back(Op.getOp()); | |||
| 806 | for (unsigned I = 0; I < Op.getNumArgs(); ++I) | |||
| 807 | Ops.push_back(Op.getArg(I)); | |||
| 808 | } | |||
| 809 | if (StackValue) | |||
| 810 | Ops.push_back(dwarf::DW_OP_stack_value); | |||
| 811 | return DIExpression::get(Expr->getContext(), Ops); | |||
| ||||
| 812 | } | |||
| 813 | ||||
| 814 | Optional<DIExpression *> DIExpression::createFragmentExpression( | |||
| 815 | const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits) { | |||
| 816 | SmallVector<uint64_t, 8> Ops; | |||
| 817 | // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment. | |||
| 818 | if (Expr) { | |||
| 819 | for (auto Op : Expr->expr_ops()) { | |||
| 820 | switch (Op.getOp()) { | |||
| 821 | default: break; | |||
| 822 | case dwarf::DW_OP_plus: | |||
| 823 | case dwarf::DW_OP_minus: | |||
| 824 | // We can't safely split arithmetic into multiple fragments because we | |||
| 825 | // can't express carry-over between fragments. | |||
| 826 | // | |||
| 827 | // FIXME: We *could* preserve the lowest fragment of a constant offset | |||
| 828 | // operation if the offset fits into SizeInBits. | |||
| 829 | return None; | |||
| 830 | case dwarf::DW_OP_LLVM_fragment: { | |||
| 831 | // Make the new offset point into the existing fragment. | |||
| 832 | uint64_t FragmentOffsetInBits = Op.getArg(0); | |||
| 833 | // Op.getArg(0) is FragmentOffsetInBits. | |||
| 834 | // Op.getArg(1) is FragmentSizeInBits. | |||
| 835 | assert((OffsetInBits + SizeInBits <= Op.getArg(0) + Op.getArg(1)) &&(static_cast <bool> ((OffsetInBits + SizeInBits <= Op .getArg(0) + Op.getArg(1)) && "new fragment outside of original fragment" ) ? void (0) : __assert_fail ("(OffsetInBits + SizeInBits <= Op.getArg(0) + Op.getArg(1)) && \"new fragment outside of original fragment\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 836, __extension__ __PRETTY_FUNCTION__)) | |||
| 836 | "new fragment outside of original fragment")(static_cast <bool> ((OffsetInBits + SizeInBits <= Op .getArg(0) + Op.getArg(1)) && "new fragment outside of original fragment" ) ? void (0) : __assert_fail ("(OffsetInBits + SizeInBits <= Op.getArg(0) + Op.getArg(1)) && \"new fragment outside of original fragment\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 836, __extension__ __PRETTY_FUNCTION__)); | |||
| 837 | OffsetInBits += FragmentOffsetInBits; | |||
| 838 | continue; | |||
| 839 | } | |||
| 840 | } | |||
| 841 | Ops.push_back(Op.getOp()); | |||
| 842 | for (unsigned I = 0; I < Op.getNumArgs(); ++I) | |||
| 843 | Ops.push_back(Op.getArg(I)); | |||
| 844 | } | |||
| 845 | } | |||
| 846 | Ops.push_back(dwarf::DW_OP_LLVM_fragment); | |||
| 847 | Ops.push_back(OffsetInBits); | |||
| 848 | Ops.push_back(SizeInBits); | |||
| 849 | return DIExpression::get(Expr->getContext(), Ops); | |||
| 850 | } | |||
| 851 | ||||
| 852 | bool DIExpression::isConstant() const { | |||
| 853 | // Recognize DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment Len Ofs)?. | |||
| 854 | if (getNumElements() != 3 && getNumElements() != 6) | |||
| 855 | return false; | |||
| 856 | if (getElement(0) != dwarf::DW_OP_constu || | |||
| 857 | getElement(2) != dwarf::DW_OP_stack_value) | |||
| 858 | return false; | |||
| 859 | if (getNumElements() == 6 && getElement(3) != dwarf::DW_OP_LLVM_fragment) | |||
| 860 | return false; | |||
| 861 | return true; | |||
| 862 | } | |||
| 863 | ||||
| 864 | DIGlobalVariableExpression * | |||
| 865 | DIGlobalVariableExpression::getImpl(LLVMContext &Context, Metadata *Variable, | |||
| 866 | Metadata *Expression, StorageType Storage, | |||
| 867 | bool ShouldCreate) { | |||
| 868 | DEFINE_GETIMPL_LOOKUP(DIGlobalVariableExpression, (Variable, Expression))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIGlobalVariableExpressions, DIGlobalVariableExpressionInfo ::KeyTy(Variable, Expression))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 868, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 869 | Metadata *Ops[] = {Variable, Expression}; | |||
| 870 | DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIGlobalVariableExpression, Ops)return storeImpl(new (array_lengthof(Ops)) DIGlobalVariableExpression (Context, Storage, Ops), Storage, Context.pImpl->DIGlobalVariableExpressions ); | |||
| 871 | } | |||
| 872 | ||||
| 873 | DIObjCProperty *DIObjCProperty::getImpl( | |||
| 874 | LLVMContext &Context, MDString *Name, Metadata *File, unsigned Line, | |||
| 875 | MDString *GetterName, MDString *SetterName, unsigned Attributes, | |||
| 876 | Metadata *Type, StorageType Storage, bool ShouldCreate) { | |||
| 877 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 877, __extension__ __PRETTY_FUNCTION__)); | |||
| 878 | assert(isCanonical(GetterName) && "Expected canonical MDString")(static_cast <bool> (isCanonical(GetterName) && "Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(GetterName) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 878, __extension__ __PRETTY_FUNCTION__)); | |||
| 879 | assert(isCanonical(SetterName) && "Expected canonical MDString")(static_cast <bool> (isCanonical(SetterName) && "Expected canonical MDString") ? void (0) : __assert_fail ("isCanonical(SetterName) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 879, __extension__ __PRETTY_FUNCTION__)); | |||
| 880 | DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIObjCPropertys, DIObjCPropertyInfo::KeyTy(Name, File , Line, GetterName, SetterName, Attributes, Type))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast < bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 881, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 881 | SetterName, Attributes, Type))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIObjCPropertys, DIObjCPropertyInfo::KeyTy(Name, File , Line, GetterName, SetterName, Attributes, Type))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast < bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 881, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 882 | Metadata *Ops[] = {Name, File, GetterName, SetterName, Type}; | |||
| 883 | DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops)return storeImpl(new (array_lengthof(Ops)) DIObjCProperty(Context , Storage, Line, Attributes, Ops), Storage, Context.pImpl-> DIObjCPropertys); | |||
| 884 | } | |||
| 885 | ||||
| 886 | DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag, | |||
| 887 | Metadata *Scope, Metadata *Entity, | |||
| 888 | Metadata *File, unsigned Line, | |||
| 889 | MDString *Name, StorageType Storage, | |||
| 890 | bool ShouldCreate) { | |||
| 891 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 891, __extension__ __PRETTY_FUNCTION__)); | |||
| 892 | DEFINE_GETIMPL_LOOKUP(DIImportedEntity,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIImportedEntitys, DIImportedEntityInfo::KeyTy(Tag , Scope, Entity, File, Line, Name))) return N; if (!ShouldCreate ) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 893, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 893 | (Tag, Scope, Entity, File, Line, Name))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIImportedEntitys, DIImportedEntityInfo::KeyTy(Tag , Scope, Entity, File, Line, Name))) return N; if (!ShouldCreate ) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 893, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 894 | Metadata *Ops[] = {Scope, Entity, Name, File}; | |||
| 895 | DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIImportedEntity(Context , Storage, Tag, Line, Ops), Storage, Context.pImpl->DIImportedEntitys ); | |||
| 896 | } | |||
| 897 | ||||
| 898 | DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType, | |||
| 899 | unsigned Line, MDString *Name, MDString *Value, | |||
| 900 | StorageType Storage, bool ShouldCreate) { | |||
| 901 | assert(isCanonical(Name) && "Expected canonical MDString")(static_cast <bool> (isCanonical(Name) && "Expected canonical MDString" ) ? void (0) : __assert_fail ("isCanonical(Name) && \"Expected canonical MDString\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 901, __extension__ __PRETTY_FUNCTION__)); | |||
| 902 | DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIMacros, DIMacroInfo::KeyTy(MIType, Line, Name, Value ))) return N; if (!ShouldCreate) return nullptr; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created" ) ? void (0) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 902, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 903 | Metadata *Ops[] = { Name, Value }; | |||
| 904 | DEFINE_GETIMPL_STORE(DIMacro, (MIType, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIMacro(Context, Storage , MIType, Line, Ops), Storage, Context.pImpl->DIMacros); | |||
| 905 | } | |||
| 906 | ||||
| 907 | DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType, | |||
| 908 | unsigned Line, Metadata *File, | |||
| 909 | Metadata *Elements, StorageType Storage, | |||
| 910 | bool ShouldCreate) { | |||
| 911 | DEFINE_GETIMPL_LOOKUP(DIMacroFile,do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIMacroFiles, DIMacroFileInfo::KeyTy(MIType, Line, File, Elements))) return N; if (!ShouldCreate) return nullptr ; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 912, __extension__ __PRETTY_FUNCTION__)); } } while (false) | |||
| 912 | (MIType, Line, File, Elements))do { if (Storage == Uniqued) { if (auto *N = getUniqued(Context .pImpl->DIMacroFiles, DIMacroFileInfo::KeyTy(MIType, Line, File, Elements))) return N; if (!ShouldCreate) return nullptr ; } else { (static_cast <bool> (ShouldCreate && "Expected non-uniqued nodes to always be created") ? void (0 ) : __assert_fail ("ShouldCreate && \"Expected non-uniqued nodes to always be created\"" , "/build/llvm-toolchain-snapshot-7~svn329677/lib/IR/DebugInfoMetadata.cpp" , 912, __extension__ __PRETTY_FUNCTION__)); } } while (false); | |||
| 913 | Metadata *Ops[] = { File, Elements }; | |||
| 914 | DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops)return storeImpl(new (array_lengthof(Ops)) DIMacroFile(Context , Storage, MIType, Line, Ops), Storage, Context.pImpl->DIMacroFiles ); | |||
| 915 | } |