class Instruction;
class Module;
class MDString;
-class DIType;
+class DICompositeType;
class SMDiagnostic;
class DiagnosticInfo;
template <typename T> class SmallVectorImpl;
void enableDebugTypeODRUniquing();
void disableDebugTypeODRUniquing();
- /// Get or insert the DIType mapped to the given string.
+ /// Get or insert the DICompositeType mapped to the given string.
///
- /// Returns the address of the current \a DIType pointer mapped to \c S,
- /// inserting a mapping to \c nullptr if \c S was not previously mapped.
- /// This method has no effect (and returns \c nullptr instead of a valid
- /// address) if \a isODRUniquingDebugTypes() is \c false.
+ /// Returns the address of the current \a DICompositeType pointer mapped to
+ /// \c S, inserting a mapping to \c nullptr if \c S was not previously
+ /// mapped. This method has no effect (and returns \c nullptr instead of a
+ /// valid address) if \a isODRUniquingDebugTypes() is \c false.
///
/// \post If \a isODRUniquingDebugTypes(), \c S will have a (possibly null)
/// mapping. \note The returned address is only valid until the next call.
- DIType **getOrInsertODRUniquedType(const MDString &S);
+ DICompositeType **getOrInsertODRUniquedType(const MDString &S);
typedef void (*InlineAsmDiagHandlerTy)(const SMDiagnostic&, void *Context,
unsigned LocCookie);
// If this isn't a forward declaration and it has a UUID, check for it in the
// type map in the context.
- DIType **MappedT = nullptr;
+ DICompositeType **MappedT = nullptr;
if (!(flags.Val & DINode::FlagFwdDecl) && identifier.Val &&
(MappedT = Context.getOrInsertODRUniquedType(*identifier.Val)) &&
*MappedT) {
size.Val, align.Val, offset.Val, flags.Val, elements.Val,
runtimeLang.Val, vtableHolder.Val, templateParams.Val, identifier.Val));
if (MappedT)
- *MappedT = cast<DIType>(Result);
+ *MappedT = cast<DICompositeType>(Result);
return false;
}
// mapping.
unsigned Flags = Record[10];
auto *Identifier = getMDString(Record[15]);
- DIType **MappedT = nullptr;
+ DICompositeType **MappedT = nullptr;
if (!(Flags & DINode::FlagFwdDecl) && Identifier)
MappedT = Context.getOrInsertODRUniquedType(*Identifier);
// Use the mapped type node, or create a new one if necessary.
- DIType *CT = MappedT ? *MappedT : nullptr;
+ DICompositeType *CT = MappedT ? *MappedT : nullptr;
if (!CT) {
CT = GET_OR_DISTINCT(
DICompositeType, Record[0],
if (pImpl->DITypeMap)
return;
- pImpl->DITypeMap = llvm::make_unique<DenseMap<const MDString *, DIType *>>();
+ pImpl->DITypeMap =
+ llvm::make_unique<DenseMap<const MDString *, DICompositeType *>>();
}
void LLVMContext::disableDebugTypeODRUniquing() { pImpl->DITypeMap.reset(); }
-DIType **LLVMContext::getOrInsertODRUniquedType(const MDString &S) {
+DICompositeType **LLVMContext::getOrInsertODRUniquedType(const MDString &S) {
if (!isODRUniquingDebugTypes())
return nullptr;
return &(*pImpl->DITypeMap)[&S];
#include "llvm/IR/Metadata.def"
// Optional map for looking up composite types by identifier.
- std::unique_ptr<DenseMap<const MDString *, DIType *>> DITypeMap;
+ std::unique_ptr<DenseMap<const MDString *, DICompositeType *>> DITypeMap;
// MDNodes may be uniqued or not uniqued. When they're not uniqued, they
// aren't in the MDNodeSet, but they're still shared between objects, so no
// Get the mapping.
Context.enableDebugTypeODRUniquing();
- DIType **Mapping = Context.getOrInsertODRUniquedType(S);
+ DICompositeType **Mapping = Context.getOrInsertODRUniquedType(S);
ASSERT_TRUE(Mapping);
// Create some type and add it to the mapping.
- auto &BT =
- *DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, S.getString());
- *Mapping = &BT;
+ auto &CT = *DICompositeType::get(Context, dwarf::DW_TAG_class_type, "name",
+ nullptr, 0, nullptr, nullptr, 0, 0, 0, 0,
+ nullptr, 0, nullptr, nullptr, S.getString());
+ ASSERT_EQ(S.getString(), CT.getIdentifier());
+ *Mapping = &CT;
// Check that we get it back.
Mapping = Context.getOrInsertODRUniquedType(S);
ASSERT_TRUE(Mapping);
- EXPECT_EQ(&BT, *Mapping);
+ EXPECT_EQ(&CT, *Mapping);
// Check that it's discarded with the type map.
Context.disableDebugTypeODRUniquing();