Add a DIExternalTypeRef debug metadata node to the IR.

[aprantl]

Summary

This adds a DIExternalTypeRef debug metadata node to the IR that is meant to be emitted by Clang when referring to a type that is defined in a .pcm file. DIExternalTypeRef is a child of DICompositeTypeBase because it shares common traits such as the unique identifier.

The idea how this is going to be used is that the frontend will discover that a type originates from an AST file and instead of and constructing a full DIType (and thus deserializing the type from the AST) it creates a DIExternalTypeRef with the tag type, mangled name and the .pcm file. The backend then can emit this as a split-DWARF-style forward declaration using DW_FORM_ref_sig8 (GDB) or as a string reference (LLDB) + and accelerator table entry.

[aprantl]

Abandoning this revision in favor of adding a FlagExternalTypeRef to be used by DICompositeType to the DebugInfoFlags.

include/llvm/Bitcode/LLVMBitCodes.h

enum MetadataCodes {
     METADATA_NAMESPACE     = 24,  // [distinct, scope, file, name, line]
     METADATA_TEMPLATE_TYPE = 25,  // [distinct, scope, name, type, ...]
     METADATA_TEMPLATE_VALUE= 26,  // [distinct, scope, name, type, value, ...]
     METADATA_GLOBAL_VAR    = 27,  // [distinct, ...]
     METADATA_LOCAL_VAR     = 28,  // [distinct, ...]
     METADATA_EXPRESSION    = 29,  // [distinct, n x element]
     METADATA_OBJC_PROPERTY = 30,  // [distinct, name, file, line, ...]
     METADATA_IMPORTED_ENTITY=31,  // [distinct, tag, scope, entity, line, name]
+    METADATA_EXTERNAL_TYPE_REF=32,// [distinct, tag, file, uid]
   };
 
   // The constants block (CONSTANTS_BLOCK_ID) describes emission for each
   // constant and maintains an implicit current type value.
   enum ConstantsCodes {
     CST_CODE_SETTYPE       =  1,  // SETTYPE:       [typeid]
     CST_CODE_NULL          =  2,  // NULL
     CST_CODE_UNDEF         =  3,  // UNDEF

include/llvm/IR/DIBuilder.h

public:
     /// @param ParameterTypes  An array of subroutine parameter types. This
     ///                        includes return type at 0th index.
     /// @param Flags           E.g.: LValueReference.
     ///                        These flags are used to emit dwarf attributes.
     DISubroutineType *createSubroutineType(DIFile *File,
                                            DITypeRefArray ParameterTypes,
                                            unsigned Flags = 0);
 
+    /// createExternalTypeRef - Create external type ref.
+    /// @param Tag              Dwarf TAG.
+    /// @param File             Module in which this type is defined.
+    /// @param UniqueIdentifire Mangled name or unique identifier for the type.
+    DIExternalTypeRef *createExternalTypeRef(unsigned Tag, DIFile *File,
+                                             StringRef UniqueIdentifier);
+
     /// createArtificialType - Create a new DIType* with "artificial" flag set.
     DIType *createArtificialType(DIType *Ty);
 
     /// createObjectPointerType - Create a new DIType* with the "object pointer"
     /// flag set.
     DIType *createObjectPointerType(DIType *Ty);
 
     /// \brief Create a permanent forward-declared type.

include/llvm/IR/DebugInfoMetadata.h

default:
       return false;
     case GenericDINodeKind:
     case DISubrangeKind:
     case DIEnumeratorKind:
     case DIBasicTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:
     case DISubroutineTypeKind:
+    case DIExternalTypeRefKind:
     case DIFileKind:
     case DICompileUnitKind:
     case DISubprogramKind:
     case DILexicalBlockKind:
     case DILexicalBlockFileKind:
     case DINamespaceKind:
     case DITemplateTypeParameterKind:
     case DITemplateValueParameterKind:
public:
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
     case DIBasicTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:
     case DISubroutineTypeKind:
+    case DIExternalTypeRefKind:
     case DIFileKind:
     case DICompileUnitKind:
     case DISubprogramKind:
     case DILexicalBlockKind:
     case DILexicalBlockFileKind:
     case DINamespaceKind:
       return true;
     }
public:
   static bool classof(const Metadata *MD) {
     switch (MD->getMetadataID()) {
     default:
       return false;
     case DIBasicTypeKind:
     case DIDerivedTypeKind:
     case DICompositeTypeKind:
     case DISubroutineTypeKind:
+    case DIExternalTypeRefKind:
       return true;
     }
   }
 };
 
 /// \brief Basic type, like 'int' or 'float'.
 ///
 /// TODO: Split out DW_TAG_unspecified_type.

 
 public:
   DITypeRef getBaseType() const { return DITypeRef(getRawBaseType()); }
   Metadata *getRawBaseType() const { return getOperand(3); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIDerivedTypeKind ||
            MD->getMetadataID() == DICompositeTypeKind ||
-           MD->getMetadataID() == DISubroutineTypeKind;
+           MD->getMetadataID() == DISubroutineTypeKind ||
+           MD->getMetadataID() == DIExternalTypeRefKind;
   }
 };
 
 /// \brief Derived types.
 ///
 /// This includes qualified types, pointers, references, friends, typedefs, and
 /// class members.
 ///
public:
   }
   /// @}
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIDerivedTypeKind;
   }
 };
 
-/// \brief Base class for DICompositeType and DISubroutineType.
+/// \brief Base class for DICompositeType, DISubroutineType
+///        and DIExternalTypeRef.
 ///
 /// TODO: Delete; they're not really related.
 class DICompositeTypeBase : public DIDerivedTypeBase {
   unsigned RuntimeLang;
 
 protected:
   DICompositeTypeBase(LLVMContext &C, unsigned ID, StorageType Storage,
                       unsigned Tag, unsigned Line, unsigned RuntimeLang,
#endif
   }
   void replaceTemplateParams(DITemplateParameterArray TemplateParams) {
     replaceOperandWith(6, TemplateParams.get());
   }
   /// @}
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DICompositeTypeKind ||
-           MD->getMetadataID() == DISubroutineTypeKind;
+           MD->getMetadataID() == DISubroutineTypeKind ||
+           MD->getMetadataID() == DIExternalTypeRefKind;
   }
 };
 
 /// \brief Composite types.
 ///
 /// TODO: Detach from DerivedTypeBase (split out MDEnumType?).
 /// TODO: Create a custom, unrelated node for DW_TAG_array_type.
 class DICompositeType : public DICompositeTypeBase {
public:
   }
   Metadata *getRawTypeArray() const { return getRawElements(); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DISubroutineTypeKind;
   }
 };
 
+/// \brief External (module) type references.
+///
+/// TODO: Detach from CompositeType.
+class DIExternalTypeRef : public DICompositeTypeBase {
+  friend class LLVMContextImpl;
+  friend class MDNode;
+
+  DIExternalTypeRef(LLVMContext &C, StorageType Storage, unsigned Tag,
+                    ArrayRef<Metadata *> Ops)
+      : DICompositeTypeBase(C, DIExternalTypeRefKind, Storage, Tag, 0, 0, 0, 0,
+                            0, 0, Ops) {}
+  ~DIExternalTypeRef() {}
+
+  static DIExternalTypeRef *
+  getImpl(LLVMContext &Context, unsigned Tag, Metadata *File, StringRef Identifier,
+          StorageType Storage, bool ShouldCreate = true) {
+    return getImpl(Context, Tag, File, getCanonicalMDString(Context, Identifier),
+                   Storage, ShouldCreate);
+  }
+  static DIExternalTypeRef *
+  getImpl(LLVMContext &Context, unsigned Tag, Metadata *File, MDString *Identifier,
+          StorageType Storage, bool ShouldCreate = true);
+
+  TempDIExternalTypeRef cloneImpl() const {
+    return getTemporary(getContext(), getTag(), getFile(), getIdentifier());
+  }
+
+public:
+  DEFINE_MDNODE_GET(DIExternalTypeRef, (unsigned Tag, Metadata *File,
+                    StringRef Identifier), (Tag, File, Identifier))
+  DEFINE_MDNODE_GET(DIExternalTypeRef, (unsigned Tag, Metadata *File,
+                    MDString *Identifier), (Tag, File, Identifier))
+
+  TempDIExternalTypeRef clone() const { return cloneImpl(); }
+
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == DIExternalTypeRefKind;
+  }
+};
+
 /// \brief Compile unit.
 class DICompileUnit : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned SourceLanguage;
   bool IsOptimized;
   unsigned RuntimeVersion;

include/llvm/IR/Metadata.h

enum MetadataKind {
     DILocationKind,
     GenericDINodeKind,
     DISubrangeKind,
     DIEnumeratorKind,
     DIBasicTypeKind,
     DIDerivedTypeKind,
     DICompositeTypeKind,
     DISubroutineTypeKind,
+    DIExternalTypeRefKind,
     DIFileKind,
     DICompileUnitKind,
     DISubprogramKind,
     DILexicalBlockKind,
     DILexicalBlockFileKind,
     DINamespaceKind,
     DITemplateTypeParameterKind,
     DITemplateValueParameterKind,

include/llvm/IR/Metadata.def

 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIScope)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIType)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DIBasicType)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIDerivedTypeBase)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DIDerivedType)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DICompositeTypeBase)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DICompositeType)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DISubroutineType)
+HANDLE_SPECIALIZED_MDNODE_LEAF(DIExternalTypeRef)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DIFile)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DICompileUnit)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DILocalScope)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DISubprogram)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DILexicalBlockBase)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DILexicalBlock)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DILexicalBlockFile)
 HANDLE_SPECIALIZED_MDNODE_LEAF(DINamespace)

lib/AsmParser/LLParser.cpp

#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(types, MDField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DISubroutineType, (Context, flags.Val, types.Val));
   return false;
 }
 
+/// ParseDIExternalTypeRef:
+///   ::= !DIExternalTypeRef(tag: DW_TAG_class_type, module: !1, identifier: "UUID")
+bool LLParser::ParseDIExternalTypeRef(MDNode *&Result, bool IsDistinct) {
+#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
+  REQUIRED(tag, DwarfTagField, );                                              \
+  REQUIRED(file, MDField, );                                                   \
+  REQUIRED(identifier, MDStringField, );
+  PARSE_MD_FIELDS();
+#undef VISIT_MD_FIELDS
+
+  Result = GET_OR_DISTINCT(DIExternalTypeRef,
+                           (Context, tag.Val, file.Val, identifier.Val));
+  return false;
+}
+
 /// ParseDIFileType:
 ///   ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir")
 bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(filename, MDStringField, );                                         \
   REQUIRED(directory, MDStringField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::METADATA_SUBROUTINE_TYPE: {
         return Error("Invalid record");
 
       MDValueList.AssignValue(
           GET_OR_DISTINCT(DISubroutineType, Record[0],
                           (Context, Record[1], getMDOrNull(Record[2]))),
           NextMDValueNo++);
       break;
     }
+    case bitc::METADATA_EXTERNAL_TYPE_REF: {
+      if (Record.size() != 4)
+        return Error("Invalid record");
+
+      MDValueList.AssignValue(
+          GET_OR_DISTINCT(DIExternalTypeRef, Record[0],
+                          (Context, Record[1], getMDOrNull(Record[2]),
+                                    getMDString(Record[3]))),
+          NextMDValueNo++);
+      break;
+    }
     case bitc::METADATA_FILE: {
       if (Record.size() != 3)
         return Error("Invalid record");
 
       MDValueList.AssignValue(
           GET_OR_DISTINCT(DIFile, Record[0], (Context, getMDString(Record[1]),
                                               getMDString(Record[2]))),
           NextMDValueNo++);

lib/Bitcode/Writer/BitcodeWriter.cpp

static void WriteDISubroutineType(const DISubroutineType *N,
   Record.push_back(N->isDistinct());
   Record.push_back(N->getFlags());
   Record.push_back(VE.getMetadataOrNullID(N->getTypeArray().get()));
 
   Stream.EmitRecord(bitc::METADATA_SUBROUTINE_TYPE, Record, Abbrev);
   Record.clear();
 }
 
+static void WriteDIExternalTypeRef(const DIExternalTypeRef *N,
+                                   const ValueEnumerator &VE,
+                                   BitstreamWriter &Stream,
+                                   SmallVectorImpl<uint64_t> &Record,
+                                   unsigned Abbrev) {
+  Record.push_back(N->isDistinct());
+  Record.push_back(N->getTag());
+  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
+  Record.push_back(VE.getMetadataOrNullID(N->getRawIdentifier()));
+
+  Stream.EmitRecord(bitc::METADATA_EXTERNAL_TYPE_REF, Record, Abbrev);
+  Record.clear();
+}
+
 static void WriteDIFile(const DIFile *N, const ValueEnumerator &VE,
                         BitstreamWriter &Stream,
                         SmallVectorImpl<uint64_t> &Record, unsigned Abbrev) {
   Record.push_back(N->isDistinct());
   Record.push_back(VE.getMetadataOrNullID(N->getRawFilename()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawDirectory()));
 
   Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev);

lib/IR/AsmWriter.cpp

static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
   Out << "!DISubroutineType(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
   Printer.printDIFlags("flags", N->getFlags());
   Printer.printMetadata("types", N->getRawTypeArray(),
                         /* ShouldSkipNull */ false);
   Out << ")";
 }
 
+static void writeDIExternalTypeRef(raw_ostream &Out,
+                                   const DIExternalTypeRef *N,
+                                   TypePrinting *TypePrinter,
+                                   SlotTracker *Machine, const Module *Context) {
+  Out << "!DIExternalTypeRef(";
+  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+  Printer.printTag(N);
+  Printer.printMetadata("file", N->getFile());
+  Printer.printString("identifier", N->getIdentifier());
+  Out << ")";
+}
+
 static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
                         SlotTracker *, const Module *) {
   Out << "!DIFile(";
   MDFieldPrinter Printer(Out);
   Printer.printString("filename", N->getFilename(),
                       /* ShouldSkipEmpty */ false);
   Printer.printString("directory", N->getDirectory(),
                       /* ShouldSkipEmpty */ false);

lib/IR/DIBuilder.cpp

 }
 
 DISubroutineType *DIBuilder::createSubroutineType(DIFile *File,
                                                   DITypeRefArray ParameterTypes,
                                                   unsigned Flags) {
   return DISubroutineType::get(VMContext, Flags, ParameterTypes);
 }
 
+DIExternalTypeRef *DIBuilder::createExternalTypeRef(unsigned Tag, DIFile *File,
+                                                    StringRef Identifier) {
+ return DIExternalTypeRef::get(VMContext, Tag, File, Identifier);
+}
+
 DICompositeType *DIBuilder::createEnumerationType(
     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
     uint64_t SizeInBits, uint64_t AlignInBits, DINodeArray Elements,
     DIType *UnderlyingType, StringRef UniqueIdentifier) {
   auto *CTy = DICompositeType::get(
       VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
       DIScopeRef::get(getNonCompileUnitScope(Scope)),
       DITypeRef::get(UnderlyingType), SizeInBits, AlignInBits, 0, 0, Elements,

lib/IR/DebugInfoMetadata.cpp

DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context,
                                             StorageType Storage,
                                             bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, TypeArray));
   Metadata *Ops[] = {nullptr,   nullptr, nullptr, nullptr,
                      TypeArray, nullptr, nullptr, nullptr};
   DEFINE_GETIMPL_STORE(DISubroutineType, (Flags), Ops);
 }
 
+DIExternalTypeRef *DIExternalTypeRef::getImpl(LLVMContext &Context,
+                                              unsigned Tag,
+                                              Metadata *File,
+                                              MDString *Identifier,
+                                              StorageType Storage,
+                                              bool ShouldCreate) {
+  DEFINE_GETIMPL_LOOKUP(DIExternalTypeRef, (Tag, File, getString(Identifier)));
+  Metadata *Ops[] = {File,    nullptr, nullptr, nullptr,
+                     nullptr, nullptr, nullptr, Identifier};
+  DEFINE_GETIMPL_STORE(DIExternalTypeRef, (Tag), Ops);
+}
+
 DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
                         MDString *Directory, StorageType Storage,
                         bool ShouldCreate) {
   assert(isCanonical(Filename) && "Expected canonical MDString");
   assert(isCanonical(Directory) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIFile, (getString(Filename), getString(Directory)));
   Metadata *Ops[] = {Filename, Directory};
   DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIFile, Ops);

lib/IR/LLVMContextImpl.h

MDNodeKeyImpl(const DISubroutineType *N)
       : Flags(N->getFlags()), TypeArray(N->getRawTypeArray()) {}
 
   bool isKeyOf(const DISubroutineType *RHS) const {
     return Flags == RHS->getFlags() && TypeArray == RHS->getRawTypeArray();
   }
   unsigned getHashValue() const { return hash_combine(Flags, TypeArray); }
 };
 
+template <> struct MDNodeKeyImpl<DIExternalTypeRef> {
+  unsigned Tag;
+  Metadata *File;
+  StringRef Identifier;
+
+  MDNodeKeyImpl(unsigned Tag, Metadata *File, StringRef Identifier)
+      : Tag(Tag), File(File), Identifier(Identifier) {}
+  MDNodeKeyImpl(const DIExternalTypeRef *N)
+      : Tag(N->getTag()), File(N->getRawFile()),
+        Identifier(N->getIdentifier()) {}
+
+  bool isKeyOf(const DIExternalTypeRef *RHS) const {
+    return Tag == RHS->getTag() && File == RHS->getRawFile() &&
+           Identifier == RHS->getIdentifier();
+  }
+  unsigned getHashValue() const { return hash_combine(Tag, File, Identifier); }
+};
+
 template <> struct MDNodeKeyImpl<DIFile> {
   StringRef Filename;
   StringRef Directory;
 
   MDNodeKeyImpl(StringRef Filename, StringRef Directory)
       : Filename(Filename), Directory(Directory) {}
   MDNodeKeyImpl(const DIFile *N)
       : Filename(N->getFilename()), Directory(N->getDirectory()) {}

lib/IR/Verifier.cpp

if (auto *Types = N.getRawTypeArray()) {
     for (Metadata *Ty : N.getTypeArray()->operands()) {
       Assert(isTypeRef(N, Ty), "invalid subroutine type ref", &N, Types, Ty);
     }
   }
   Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags",
          &N);
 }
 
+void Verifier::visitDIExternalTypeRef(const DIExternalTypeRef &N) {
+  Assert(!N.getIdentifier().empty(), "invalid identifier", &N);
+}
+
 void Verifier::visitDIFile(const DIFile &N) {
   Assert(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N);
 }
 
 void Verifier::visitDICompileUnit(const DICompileUnit &N) {
   Assert(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
 
   // Don't bother verifying the compilation directory or producer string

test/Assembler/DIExternalTypeRef.ll

+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
+; RUN: verify-uselistorder %s
+
+; CHECK: !named = !{!0, !1}
+!named = !{!0, !1}
+
+!0 = !DIFile(filename: "foo", directory: "/dir")
+
+; CHECK: !1 = !DIExternalTypeRef(tag: DW_TAG_structure_type, file: !0, identifier: "c:objc(cs)Foo")
+!1 = !DIExternalTypeRef(tag: DW_TAG_structure_type, file: !0, identifier: "c:objc(cs)Foo")
+