Add DITypeIndex for CodeView and emit it for locals

[rnk]

Summary

This is subclass of Metadata that essentially contains one 32-bit
integer. It can stand in as a DITypeRef or a DIScopeRef in certain
cases. If you attempt to resolve such a DITypeRef, you will get an
assertion failure.

Currently the indexes can only represent the simple types below 0x1000.
In the next patch I'll add support for type streams, and these indexes
will be able to represent compound types such as record and function
types.

[mehdi_amini]

Missing update to LangRef?

[dblaikie]

unittests/IR/MetadataTest.cpp

1407

X y = X(z); -> X y(z); perhaps?

and/or should DITypeRef be implicitly convertible from a DIType?

[llvm-commits]

I like this. I think you're missing updates to ValueMapper.cpp, so
llvm-link will crash if you leave this as is. For the code there,
it would be best to treat DITypeIndex exactly like MDString.

It might be nice to have a single isa target for types that (1)
don't have operands and (2) never change address. Basically, things
like MDString and DITypeRef (and DIExpression should be moved
over, too...).

That'll keep down code duplication in ValueMapper; it'll probably be
useful in other places that don't really care about specific
semantics.

Maybe "ImmutableMetadata"?

[rnk]

In D19236#404416, @llvm-commits wrote:

Maybe "ImmutableMetadata"?

I think the main property they share is that they have no metadata operands: they are leaves of the metadata graph. So, maybe LeafMetadata? MDLeaf? DILeaf?

unittests/IR/MetadataTest.cpp

1407

The primary TypedDINodeRef constructor is marked explicit, so I shied away from adding an implicit constructor. However, it is constructing from a generic Metadata*, and an implicit constructor from T* would be pretty safe.

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

2391

Does CU here mean DICompileUnit or llvm::Module? It's probably better to spell it out.

lib/AsmParser/LLParser.cpp

4287

Comment update?
Mehdi already mentioned that this should also be in LangRef.rst.

lib/IR/DIBuilder.cpp

689

Are we loosing type safety through this change? Can you double-check that there is a Verifier check that ensures that Function->getType() resolves to a DISubroutineType?

lib/IR/Metadata.cpp

422

whitespace

lib/IR/Verifier.cpp

990

Ah there it is :-)

[aprantl]

Could you please also (doesn't have to be part of this patch) update SourceLevelDebugging.rst with information about LLVM's CodeView implementation?

[rnk]

• Add LangRef and a linker test case for DITypeIndex

[aprantl]

docs/LangRef.rst

4298 ↗

(On Diff #54121)

Could you please spell out CU?
Should we mention that this is used to implement CodeView types?

[aaboud]

I am a little confused.

1. Are you trying to replace DIBasicType?
2. Will Clang be generating DITypeIndex for Windows target (COFF debug info) and DIBasicType/DICompositeType/DIDerivedType/DISubroutineType for Linux target (DWARF debug info)?
3. You did not explain how you will represent the compound types using this DITypeIndex! 3.a. Who will set the index field in DITypeIndex for compound types? can clang FE do that? 3.b. Will CodeView emitter emit that index directly? what will happen if we do not want to emit some of the types, do not we need to rearrange the indices? 3.c. Will this work also for emitting a pdb file? can the compiler set these indices also when emitting types to pdb file instead of COFF object file?

I would appreciate if you can answer these questions.
Thanks,
Amjad

[rnk]

In D19236#405489, @aaboud wrote:

I am a little confused.

1. Are you trying to replace DIBasicType?

Yes

2. Will Clang be generating DITypeIndex for Windows target (COFF debug info) and DIBasicType/DICompositeType/DIDerivedType/DISubroutineType for Linux target (DWARF debug info)?

Yes

3. You did not explain how you will represent the compound types using this DITypeIndex!

My plan is that we will have named metadata, like llvm.dbg.cvtypes, which will be a list of pairs of CUs and type streams. The type stream will be a simple MDString. This avoids having DICompileUnit reference the type streams directly, while still allowing us to associate the type stream with the CU. This is similar to how we associated subprograms with CUs currently.

Later we can add a specialized DI node to represent type streams (DITypeStream/Blob?) if we think it's worth it. It's not very efficient for the entire type stream to participate in MDString uniquing, for example, and printing a bunch of binary hex escapes is very ugly.

3.a. Who will set the index field in DITypeIndex for compound types? can clang FE do that?

Yes, the frontend will drive llvm::codeview::MemoryTypeTableBuilder to do this.

3.b. Will CodeView emitter emit that index directly? what will happen if we do not want to emit some of the types, do not we need to rearrange the indices?

Yes, if you want to change or drop some type information, your tool will need to be format-aware. LTO doesn't need to do this, it can simply concatenate the llvm.dbg.cvtypes lists. The backend can do the merging and renumbering when it emits .debug$T.

3.c. Will this work also for emitting a pdb file? can the compiler set these indices also when emitting types to pdb file instead of COFF object file?

I have no plans to implement MSVC /Zi-style PDB emission, where the compiler communicates with a PDB server process that brokers type indices. If you did this, I could easily imagine replacing the type stream with a sentinel that says "this type index refers to that PDB".

I *do* want clang to avoid duplicating type information when the type was defined in another module, similar to what we do for DWARF. For now if we detect that case, we can emit a forward declaration for the type in the type stream to give it a type index. In the future, we may want a way to represent a type index from some stream other than that of the current CU.

include/llvm/IR/DebugInfoMetadata.h

2391

The DICompileUnit. I want LTO to be functionally correct, if inefficient, in the presence of this data. For now, this means having two CUs and two type streams in one module, and fixing up the type indices in the backend. We can teach LTO to merge the type streams later.

[aaboud]

Hi Reid,
Thanks for the answers, now as I understand more your plan, I have more questions:

1. You want to use indices into list of MDString per CU to improve LTO linkage and reduce type footprint by improving merging types from different compile unites. right? 1.a. I claim that we can achieve that by doing a deep compare on current debug info metadata (based DWARF), do you agree?
2. Regarding the MDString, it should be generated canonically, otherwise the compare will fail, right? 2.a. Can you give example on what it will contain for class types? 2.b. I claim that we can generate that MDString today by traveling on "DI*Type" entries (based dwarf), do you agree or you think that we already lost some information? 2.c. I assume you will still need to generate "DI*Type" entries for compound types (maybe with the index into the MDString list), as you cannot get all information from the MDString, can you? 2.d. Do you have estimation on how much size the "llvm.dbg.cvtypes" will consume? Can you assure we will end up reducing the IR size and not increasing it?
3. If the idea is to reduce the size of the LTO IR, why we are not doing this also for DWARF, why just for CV types?

Thanks,
Amjad

[rnk]

• Rebase

[dblaikie]

Generally looks good - should there be more test coverage, though? At least testing one case of a type other than int being generated into the code view? (to demonstrate the new codepath, etc - it looks like the only things testing the CodeView type reference emission are testing the old "everything is int" implementation?)

lib/Bitcode/Writer/ValueEnumerator.cpp

605

That's probably going to trigger the parens precedence warning - I think you need to put the || x inside the original outer ()

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

712–713

Is this a supported case? Sounds like if that happens it's corrupt debug info, no? (catch this in the verifier & then just assert that it'll always be present here?)

714

static_cast rather than C style cast?

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

590–591

Under what conditions would this fail? Is there a test case for it?

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

1209–1211

Can use 'auto*' on the LHS when the type is explicit in the cast on the RHS (similarly elswhere in this change) - style guide suggests this as acceptable, but not sure it explicitly favors it, up to you.

lib/IR/DebugInfoMetadata.cpp

573–574

Is this the first use of TypeAllocator for something other than types? Should it be renamed, or at least a comment added? (or a different allocator used?)

test/DebugInfo/COFF/local-variables.ll

285

Presumably this type should be pruned from all the codeview test cases now, as unreferenced metadata?

test/Linker/ditypeindex.ll

33–36 ↗

(On Diff #55255)

Presumably you don't need to check that all this other stuff roundtrips - just the indexes, right? Your change didn't have anything to do with those other bits.

Oh, I see, these aren't CHECK lines, they're for mutating this file. - not sure if that's ideal/necessary. (& won't that mean this test "REQUIRES: shell"? Which is probably best avoided (I assume we generally try to avoid that, but don't know for sure), but should be added if you're going to keep the grep/sed/cat/etc)

I'd just write it as a second file - at least that's what we've usually done, I think.

unittests/IR/MetadataTest.cpp

84

Is this conversion implicit? (I think it is, but didn't entirely follow all the layers of macro goo, inheritance, etc)

unittests/Transforms/Utils/Cloning.cpp

422

Prefer copy init over direct init where both are valid:

DITypeRef DFuncType = DBuilder.createSubroutineType(ParamTypes);

(this avoids any accidental explicit conversions from being performed)
(same comment on the previous instance of the same construct in this file)

[rnk]

In D19236#414087, @dblaikie wrote:

Generally looks good - should there be more test coverage, though? At least testing one case of a type other than int being generated into the code view? (to demonstrate the new codepath, etc - it looks like the only things testing the CodeView type reference emission are testing the old "everything is int" implementation?)

I changed local-variable.ll to have some 'unsigned' variables.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

712–713

IMO it is useful to allow users to emit codeview for IR that was generated with DWARF in mind. You'll still get line tables etc. Rejecting it in the verifier and asserting here would make that pretty hard.

714

You don't like C++ conversion-style casts? :)

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

590–591

The verifier checks that this is a DISubroutineType, DITypeIndex, or null. 'resolve' internally casts to DIType, so if you attempt to generate DWARF from IR with type indices, you will crash here. You will also crash at every other 'resolve' call site, though.

Do you think we should apply the same logic that we have on the CV side and have 'resolve' return nullptr for a DITypeIndex?

lib/IR/DebugInfoMetadata.cpp

573–574

Oops, I assumed it was used for DI types, not LLVM IR types... Well, they have the same lifetimes. I'm going to update the doc comment to indicate that they also live here.

test/Linker/ditypeindex.ll

33–36 ↗

(On Diff #55255)

Fine. Personally, I find it convenient to be able to see the whole test case all at once, but it is not a common style and pretty confusing.

unittests/IR/MetadataTest.cpp

84

No, it is not. I drafted a change to make it implicit, but I think Duncan said he'd rather not do that.

unittests/Transforms/Utils/Cloning.cpp

422

Both instances need explicit conversion, though.

[rnk]

In D19236#414087, @dblaikie wrote:

Generally looks good - should there be more test coverage, though? At least testing one case of a type other than int being generated into the code view? (to demonstrate the new codepath, etc - it looks like the only things testing the CodeView type reference emission are testing the old "everything is int" implementation?)

Yeah, the linker test case has some non-int variables, so I felt covered, but it doesn't actually emit indices to an object file. I changed local-variable.ll to have some 'unsigned' variables so now that's covered.

[rnk]

• Address review comments

include/llvm/Bitcode/LLVMBitCodes.h

enum MetadataCodes {
   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_MODULE = 32,          // [distinct, scope, name, ...]
   METADATA_MACRO = 33,           // [distinct, macinfo, line, name, value]
   METADATA_MACRO_FILE = 34,      // [distinct, macinfo, line, file, ...]
   METADATA_STRINGS = 35,         // [count, offset] blob([lengths][chars])
+  METADATA_TYPE_INDEX = 36,      // [index]
 };
 
 // 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 isDefinition  True if this is a function definition.
     /// \param ScopeLine     Set to the beginning of the scope this starts
     /// \param Flags         e.g. is this function prototyped or not.
     ///                      These flags are used to emit dwarf attributes.
     /// \param isOptimized   True if optimization is ON.
     /// \param TParams       Function template parameters.
     DISubprogram *createFunction(DIScope *Scope, StringRef Name,
                                  StringRef LinkageName, DIFile *File,
-                                 unsigned LineNo, DISubroutineType *Ty,
+                                 unsigned LineNo, DITypeRef Ty,
                                  bool isLocalToUnit, bool isDefinition,
                                  unsigned ScopeLine, unsigned Flags = 0,
                                  bool isOptimized = false,
                                  DITemplateParameterArray TParams = nullptr,
                                  DISubprogram *Decl = nullptr);
 
     /// Identical to createFunction,
     /// except that the resulting DbgNode is meant to be RAUWed.
     DISubprogram *createTempFunctionFwdDecl(
         DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File,
-        unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
+        unsigned LineNo, DITypeRef Ty, bool isLocalToUnit,
         bool isDefinition, unsigned ScopeLine, unsigned Flags = 0,
         bool isOptimized = false, DITemplateParameterArray TParams = nullptr,
         DISubprogram *Decl = nullptr);
 
     /// FIXME: this is added for dragonegg. Once we update dragonegg
     /// to call resolve function, this will be removed.
     DISubprogram *createFunction(DIScopeRef Scope, StringRef Name,
                                  StringRef LinkageName, DIFile *File,
public:
     ///                      unrepresentable.
     /// \param VTableHolder  Type that holds vtable.
     /// \param Flags         e.g. is this function prototyped or not.
     ///                      This flags are used to emit dwarf attributes.
     /// \param isOptimized   True if optimization is ON.
     /// \param TParams       Function template parameters.
     DISubprogram *
     createMethod(DIScope *Scope, StringRef Name, StringRef LinkageName,
-                 DIFile *File, unsigned LineNo, DISubroutineType *Ty,
+                 DIFile *File, unsigned LineNo, DITypeRef Ty,
                  bool isLocalToUnit, bool isDefinition, unsigned Virtuality = 0,
                  unsigned VTableIndex = 0, DIType *VTableHolder = nullptr,
                  unsigned Flags = 0, bool isOptimized = false,
                  DITemplateParameterArray TParams = nullptr);
 
     /// This creates new descriptor for a namespace with the specified
     /// parent scope.
     /// \param Scope       Namespace scope

include/llvm/IR/DebugInfoMetadata.h

template <class T> class TypedDINodeRef {
   const Metadata *MD = nullptr;
 
 public:
   TypedDINodeRef() = default;
   TypedDINodeRef(std::nullptr_t) {}
 
   /// \brief Construct from a raw pointer.
   explicit TypedDINodeRef(const Metadata *MD) : MD(MD) {
-    assert((!MD || isa<MDString>(MD) || isa<T>(MD)) && "Expected valid ref");
+    assert((!MD || isa<MDString>(MD) || isa<DITypeIndex>(MD) || isa<T>(MD)) &&
+           "Expected valid ref");
   }
 
   template <class U>
   TypedDINodeRef(
       const TypedDINodeRef<U> &X,
       typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
           nullptr)
       : MD(X) {}
public:
 
   template <class MapTy> T *resolve(const MapTy &Map) const {
     if (!MD)
       return nullptr;
 
     if (auto *Typed = dyn_cast<T>(MD))
       return const_cast<T *>(Typed);
 
+    assert(!isa<DITypeIndex>(MD) && "attempted to resolve a type index");
+
     auto *S = cast<MDString>(MD);
     auto I = Map.find(S);
     assert(I != Map.end() && "Missing identifier in type map");
     return cast<T>(I->second);
   }
 };
 
 typedef TypedDINodeRef<DINode> DINodeRef;
DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
     assert(Virtuality < 4 && "Virtuality out of range");
     assert((Flags < (1 << 27)) && "Flags out of range");
   }
   ~DISubprogram() = default;
 
   static DISubprogram *
   getImpl(LLVMContext &Context, DIScopeRef Scope, StringRef Name,
           StringRef LinkageName, DIFile *File, unsigned Line,
-          DISubroutineType *Type, bool IsLocalToUnit, bool IsDefinition,
+          DITypeRef Type, bool IsLocalToUnit, bool IsDefinition,
           unsigned ScopeLine, DITypeRef ContainingType, unsigned Virtuality,
           unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
           DICompileUnit *Unit, DITemplateParameterArray TemplateParams,
           DISubprogram *Declaration, DILocalVariableArray Variables,
           StorageType Storage, bool ShouldCreate = true) {
     return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
                    getCanonicalMDString(Context, LinkageName), File, Line, Type,
                    IsLocalToUnit, IsDefinition, ScopeLine, ContainingType,
return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
                         getVirtuality(), getVirtualIndex(), getFlags(),
                         isOptimized(), getUnit(), getTemplateParams(),
                         getDeclaration(), getVariables());
   }
 
 public:
   DEFINE_MDNODE_GET(DISubprogram,
                     (DIScopeRef Scope, StringRef Name, StringRef LinkageName,
-                     DIFile *File, unsigned Line, DISubroutineType *Type,
+                     DIFile *File, unsigned Line, DITypeRef Type,
                      bool IsLocalToUnit, bool IsDefinition, unsigned ScopeLine,
                      DITypeRef ContainingType, unsigned Virtuality,
                      unsigned VirtualIndex, unsigned Flags, bool IsOptimized,
                      DICompileUnit *Unit,
                      DITemplateParameterArray TemplateParams = nullptr,
                      DISubprogram *Declaration = nullptr,
                      DILocalVariableArray Variables = nullptr),
                     (Scope, Name, LinkageName, File, Line, Type, IsLocalToUnit,
public:
 
   StringRef getName() const { return getStringOperand(2); }
   StringRef getDisplayName() const { return getStringOperand(3); }
   StringRef getLinkageName() const { return getStringOperand(4); }
 
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
   MDString *getRawLinkageName() const { return getOperandAs<MDString>(4); }
 
-  DISubroutineType *getType() const {
-    return cast_or_null<DISubroutineType>(getRawType());
-  }
+  DITypeRef getType() const { return DITypeRef(getRawType()); }
   DITypeRef getContainingType() const {
     return DITypeRef(getRawContainingType());
   }
 
   DICompileUnit *getUnit() const {
     return cast_or_null<DICompileUnit>(getRawUnit());
   }
   void replaceUnit(DICompileUnit *CU) {
#endif
   Metadata *getRawFile() const { return getOperand(0); }
   Metadata *getRawElements() const { return getOperand(1); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIMacroFileKind;
   }
 };
 
+/// Represents a type in a DITypeStream at the given index. Uses the
+/// DITypeStream in the current CU. Doesn't contain metadata operands, so this
+/// inherits directly from Metadata.
+class DITypeIndex : public Metadata {
+  DITypeIndex(unsigned Index) : Metadata(DITypeIndexKind, Uniqued) {
+    SubclassData32 = Index;
+  }
+  ~DITypeIndex() = default;
+
+public:
+  unsigned getIndex() const { return SubclassData32; }
+
+  static DITypeIndex *get(LLVMContext &Context, unsigned Index);
+
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == DITypeIndexKind;
+  }
+};
+
 } // end namespace llvm
 
 #undef DEFINE_MDNODE_GET_UNPACK_IMPL
 #undef DEFINE_MDNODE_GET_UNPACK
 #undef DEFINE_MDNODE_GET
 
 #endif

include/llvm/IR/Metadata.h

enum MetadataKind {
     DILocalVariableKind,
     DIExpressionKind,
     DIObjCPropertyKind,
     DIImportedEntityKind,
     ConstantAsMetadataKind,
     LocalAsMetadataKind,
     MDStringKind,
     DIMacroKind,
-    DIMacroFileKind
+    DIMacroFileKind,
+    DITypeIndexKind,
   };
 
 protected:
   Metadata(unsigned ID, StorageType Storage)
       : SubclassID(ID), Storage(Storage), SubclassData16(0), SubclassData32(0) {
     static_assert(sizeof(*this) == 8, "Metdata fields poorly packed");
   }
   ~Metadata() = default;

include/llvm/IR/Metadata.def

 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocalVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIObjCProperty)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIImportedEntity)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIMacroNode)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacro)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacroFile)
+HANDLE_METADATA_LEAF(DITypeIndex)
 
 #undef HANDLE_METADATA
 #undef HANDLE_METADATA_LEAF
 #undef HANDLE_METADATA_BRANCH
 #undef HANDLE_MDNODE_LEAF
 #undef HANDLE_MDNODE_LEAF_UNIQUABLE
 #undef HANDLE_MDNODE_BRANCH
 #undef HANDLE_SPECIALIZED_MDNODE_LEAF
 #undef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE
 #undef HANDLE_SPECIALIZED_MDNODE_BRANCH

lib/AsmParser/LLParser.h

bool parseIndirectSymbol(const std::string &Name, LocTy Loc,
                              unsigned Linkage, unsigned Visibility,
                              unsigned DLLStorageClass,
                              GlobalVariable::ThreadLocalMode TLM,
                              bool UnnamedAddr);
     bool parseComdat();
     bool ParseStandaloneMetadata();
     bool ParseNamedMetadata();
     bool ParseMDString(MDString *&Result);
+    bool ParseDITypeIndex(DITypeIndex *&Result);
     bool ParseMDNodeID(MDNode *&Result);
     bool ParseUnnamedAttrGrp();
     bool ParseFnAttributeValuePairs(AttrBuilder &B,
                                     std::vector<unsigned> &FwdRefAttrGrps,
                                     bool inAttrGrp, LocTy &BuiltinLoc);
 
     // Type Parsing.
     bool ParseType(Type *&Result, const Twine &Msg, bool AllowVoid = false);

lib/AsmParser/LLParser.cpp

 //   ::= '!' STRINGCONSTANT
 bool LLParser::ParseMDString(MDString *&Result) {
   std::string Str;
   if (ParseStringConstant(Str)) return true;
   Result = MDString::get(Context, Str);
   return false;
 }
 
+// DITypeIndex:
+//   ::= '!DITypeIndex' '(' uint32 ')'
+bool LLParser::ParseDITypeIndex(DITypeIndex *&Result) {
+  assert(Lex.getKind() == lltok::MetadataVar);
+  Lex.Lex();
+  unsigned Index;
+  if (ParseToken(lltok::lparen, "Expected '(' here") || ParseUInt32(Index) ||
+      ParseToken(lltok::rparen, "Expected ')' here"))
+    return true;
+  Result = DITypeIndex::get(Context, Index);
+  return false;
+}
+
 // MDNode:
 //   ::= '!' MDNodeNumber
 bool LLParser::ParseMDNodeID(MDNode *&Result) {
   // !{ ..., !42, ... }
   LocTy IDLoc = Lex.getLoc();
   unsigned MID = 0;
   if (ParseUInt32(MID))
     return true;

 }
 
 /// ParseMetadata
 ///  ::= i32 %local
 ///  ::= i32 @global
 ///  ::= i32 7
 ///  ::= !42
 ///  ::= !{...}
 ///  ::= !"string"
 ///  ::= !DILocation(...)
 bool LLParser::ParseMetadata(Metadata *&MD, PerFunctionState *PFS) {
   if (Lex.getKind() == lltok::MetadataVar) {
+    // Handle type indices similar to MDString. They appear as literals, and are
+    // not referred to by number as is done for MDNodes.
+    if (Lex.getStrVal() == "DITypeIndex") {
+      DITypeIndex *TI;
+      if (ParseDITypeIndex(TI))
+        return true;
+      MD = TI;
+      return false;
+    }
+
     MDNode *N;
     if (ParseSpecializedMDNode(N))
       return true;
     MD = N;
     return false;
   }
 
   // ValueAsMetadata:

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::METADATA_STRING_OLD: {
 
       // Test for upgrading !llvm.loop.
       HasSeenOldLoopTags |= mayBeOldLoopAttachmentTag(String);
 
       Metadata *MD = MDString::get(Context, String);
       MetadataList.assignValue(MD, NextMetadataNo++);
       break;
     }
+    case bitc::METADATA_TYPE_INDEX: {
+      if (Record.size() != 1 || Record[0] > UINT_MAX)
+        return error("Invalid record");
+      uint32_t Index = Record[0];
+      Metadata *MD = DITypeIndex::get(Context, Index);
+      MetadataList.assignValue(MD, NextMetadataNo++);
+      break;
+    }
     case bitc::METADATA_STRINGS:
       if (std::error_code EC =
               parseMetadataStrings(Record, Blob, NextMetadataNo))
         return EC;
       break;
     case bitc::METADATA_KIND: {
       // Support older bitcode files that had METADATA_KIND records in a
       // block with METADATA_BLOCK_ID.

lib/Bitcode/Writer/BitcodeWriter.cpp

static void writeValueAsMetadata(const ValueAsMetadata *MD,
   // Mimic an MDNode with a value as one operand.
   Value *V = MD->getValue();
   Record.push_back(VE.getTypeID(V->getType()));
   Record.push_back(VE.getValueID(V));
   Stream.EmitRecord(bitc::METADATA_VALUE, Record, 0);
   Record.clear();
 }
 
+static void writeDITypeIndex(const DITypeIndex *TI, BitstreamWriter &Stream,
+                             SmallVectorImpl<uint64_t> &Record) {
+  // Mimic an MDNode with a value as one operand.
+  Record.push_back(TI->getIndex());
+  Stream.EmitRecord(bitc::METADATA_TYPE_INDEX, Record, 0);
+  Record.clear();
+}
+
 static void writeMDTuple(const MDTuple *N, const ValueEnumerator &VE,
                          BitstreamWriter &Stream,
                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev) {
   for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
     Metadata *MD = N->getOperand(i);
     assert(!(MD && isa<LocalAsMetadata>(MD)) &&
            "Unexpected function-local metadata");
     Record.push_back(VE.getMetadataOrNullID(MD));
if (const MDNode *N = dyn_cast<MDNode>(MD)) {
       default:
         llvm_unreachable("Invalid MDNode subclass");
 #define HANDLE_MDNODE_LEAF(CLASS)                                              \
   case Metadata::CLASS##Kind:                                                  \
     write##CLASS(cast<CLASS>(N), VE, Stream, Record, CLASS##Abbrev);           \
     continue;
 #include "llvm/IR/Metadata.def"
       }
+    } else if (const DITypeIndex *TI = dyn_cast<DITypeIndex>(MD)) {
+      writeDITypeIndex(TI, Stream, Record);
+      continue;
     }
     writeValueAsMetadata(cast<ValueAsMetadata>(MD), VE, Stream, Record);
   }
 }
 
 static void writeModuleMetadata(const Module &M,
                                 const ValueEnumerator &VE,
                                 BitstreamWriter &Stream) {

lib/Bitcode/Writer/ValueEnumerator.cpp

for (const Metadata *Op : Worklist.pop_back_val()->operands()) {
       if (auto *OpN = dyn_cast<MDNode>(Op))
         Worklist.push_back(OpN);
     }
   }
 }
 
 void ValueEnumerator::EnumerateMetadata(unsigned F, const Metadata *MD) {
   assert(
-      (isa<MDNode>(MD) || isa<MDString>(MD) || isa<ConstantAsMetadata>(MD)) &&
-      "Invalid metadata kind");
+      (isa<MDNode>(MD) || isa<MDString>(MD) || isa<ConstantAsMetadata>(MD)) ||
+      isa<DITypeIndex>(MD) && "Invalid metadata kind");
 
   // Insert a dummy ID to block the co-recursive call to
   // EnumerateMDNodeOperands() from re-visiting MD in a cyclic graph.
   //
   // Return early if there's already an ID.
   if (!insertMetadata(F, MD))
     return;
 

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

MCSymbol *LocalBegin = MMI->getContext().createTempSymbol(),
            *LocalEnd = MMI->getContext().createTempSymbol();
   OS.AddComment("Record length");
   OS.emitAbsoluteSymbolDiff(LocalEnd, LocalBegin, 2);
   OS.EmitLabel(LocalBegin);
 
   OS.AddComment("Record kind: S_LOCAL");
   OS.EmitIntValue(unsigned(SymbolRecordKind::S_LOCAL), 2);
 
+  // Pull the type index out of the type field. If the frontend did not provide
+  // a DITypeIndex, emit zero for "no type".
+  unsigned TI = unsigned(SimpleTypeKind::None);
+  if (auto *DTI = dyn_cast_or_null<DITypeIndex>(Var.DIVar->getType()))
+    TI = DTI->getIndex();
+
   uint16_t Flags = 0;
   if (Var.DIVar->isParameter())
     Flags |= LocalSym::IsParameter;
   if (Var.DefRanges.empty())
     Flags |= LocalSym::IsOptimizedOut;
 
   OS.AddComment("TypeIndex");
-  OS.EmitIntValue(TypeIndex::Int32().getIndex(), 4);
+  OS.EmitIntValue(TI, 4);
   OS.AddComment("Flags");
   OS.EmitIntValue(Flags, 2);
   // Truncate the name so we won't overflow the record length field.
   emitNullTerminatedSymbolName(OS, Var.DIVar->getName());
   OS.EmitLabel(LocalEnd);
 
   // Calculate the on disk prefix of the appropriate def range record. The
   // records and on disk formats are described in SymbolRecords.h. BytePrefix

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

void DwarfCompileUnit::constructSubprogramScopeDIE(LexicalScope *Scope) {
   assert(!Scope->isAbstractScope());
   auto *Sub = cast<DISubprogram>(Scope->getScopeNode());
 
   DD->getProcessedSPNodes().insert(Sub);
 
   DIE &ScopeDIE = updateSubprogramScopeDIE(Sub);
 
   // If this is a variadic function, add an unspecified parameter.
-  DITypeRefArray FnArgs = Sub->getType()->getTypeArray();
+  DITypeRefArray FnArgs;
+  if (DISubroutineType *FnTy =
+          cast_or_null<DISubroutineType>(resolve(Sub->getType())))
+    FnArgs = FnTy->getTypeArray();
 
   // Collect lexical scope children first.
   // ObjectPointer might be a local (non-argument) local variable if it's a
   // block's synthetic this pointer.
   if (DIE *ObjectPointer = createAndAddScopeChildren(Scope, ScopeDIE))
     addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer, *ObjectPointer);
 
   // If we have a single element of null, it is a function that returns void.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
   // language.
   uint16_t Language = getLanguage();
   if (SP->isPrototyped() &&
       (Language == dwarf::DW_LANG_C89 || Language == dwarf::DW_LANG_C99 ||
        Language == dwarf::DW_LANG_ObjC))
     addFlag(SPDie, dwarf::DW_AT_prototyped);
 
   DITypeRefArray Args;
-  if (const DISubroutineType *SPTy = SP->getType())
+  if (const DISubroutineType *SPTy =
+          cast_or_null<DISubroutineType>(resolve(SP->getType())))
     Args = SPTy->getTypeArray();
 
   // Add a return type. If this is a type like a C/C++ void type we don't add a
   // return type.
   if (Args.size())
     if (auto Ty = resolve(Args[0]))
       addType(SPDie, Ty);
 
   unsigned VK = SP->getVirtuality();

lib/IR/AsmWriter.cpp

static void WriteAsOperandInternal(raw_ostream &Out, const Metadata *MD,
 
   if (const MDString *MDS = dyn_cast<MDString>(MD)) {
     Out << "!\"";
     PrintEscapedString(MDS->getString(), Out);
     Out << '"';
     return;
   }
 
+  if (const auto *TI = dyn_cast<DITypeIndex>(MD)) {
+    Out << "!DITypeIndex(";
+    if (TI->getIndex() == 0)
+      Out << '0';
+    else
+      Out << 'u' << format_hex(TI->getIndex(), 0, /*Upper=*/true);
+    Out << ')';
+    return;
+  }
+
   auto *V = cast<ValueAsMetadata>(MD);
   assert(TypePrinter && "TypePrinter required for metadata values");
   assert((FromValue || !isa<LocalAsMetadata>(V)) &&
          "Unexpected function-local metadata outside of value argument");
 
   TypePrinter->print(V->getValue()->getType(), Out);
   Out << ' ';
   WriteAsOperandInternal(Out, V->getValue(), TypePrinter, Machine, Context);

lib/IR/DIBuilder.cpp

DISubprogram *DIBuilder::createFunction(
     DIScopeRef Context, StringRef Name, StringRef LinkageName, DIFile *File,
     unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
     bool isDefinition, unsigned ScopeLine, unsigned Flags, bool isOptimized,
     DITemplateParameterArray TParams, DISubprogram *Decl) {
   // dragonegg does not generate identifier for types, so using an empty map
   // to resolve the context should be fine.
   DITypeIdentifierMap EmptyMap;
   return createFunction(Context.resolve(EmptyMap), Name, LinkageName, File,
-                        LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine,
-                        Flags, isOptimized, TParams, Decl);
+                        LineNo, DITypeRef(Ty), isLocalToUnit, isDefinition,
+                        ScopeLine, Flags, isOptimized, TParams, Decl);
 }
 
 template <class... Ts>
 static DISubprogram *getSubprogram(bool IsDistinct, Ts &&... Args) {
   if (IsDistinct)
     return DISubprogram::getDistinct(std::forward<Ts>(Args)...);
   return DISubprogram::get(std::forward<Ts>(Args)...);
 }
 
 DISubprogram *DIBuilder::createFunction(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
-    unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
+    unsigned LineNo, DITypeRef Ty, bool isLocalToUnit,
     bool isDefinition, unsigned ScopeLine, unsigned Flags, bool isOptimized,
     DITemplateParameterArray TParams, DISubprogram *Decl) {
   auto *Node = getSubprogram(
       /* IsDistinct = */ isDefinition, VMContext,
       DIScopeRef::get(getNonCompileUnitScope(Context)), Name, LinkageName, File,
       LineNo, Ty, isLocalToUnit, isDefinition, ScopeLine, nullptr, 0, 0, Flags,
       isOptimized, isDefinition ? CUNode : nullptr, TParams, Decl,
       MDTuple::getTemporary(VMContext, None).release());
 
   if (isDefinition)
     AllSubprograms.push_back(Node);
   trackIfUnresolved(Node);
   return Node;
 }
 
 DISubprogram *DIBuilder::createTempFunctionFwdDecl(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
-    unsigned LineNo, DISubroutineType *Ty, bool isLocalToUnit,
+    unsigned LineNo, DITypeRef Ty, bool isLocalToUnit,
     bool isDefinition, unsigned ScopeLine, unsigned Flags, bool isOptimized,
     DITemplateParameterArray TParams, DISubprogram *Decl) {
   return DISubprogram::getTemporary(
              VMContext, DIScopeRef::get(getNonCompileUnitScope(Context)), Name,
              LinkageName, File, LineNo, Ty, isLocalToUnit, isDefinition,
              ScopeLine, nullptr, 0, 0, Flags, isOptimized,
              isDefinition ? CUNode : nullptr, TParams, Decl, nullptr)
       .release();
 }
 
 DISubprogram *
 DIBuilder::createMethod(DIScope *Context, StringRef Name, StringRef LinkageName,
-                        DIFile *F, unsigned LineNo, DISubroutineType *Ty,
+                        DIFile *F, unsigned LineNo, DITypeRef Ty,
                         bool isLocalToUnit, bool isDefinition, unsigned VK,
                         unsigned VIndex, DIType *VTableHolder, unsigned Flags,
                         bool isOptimized, DITemplateParameterArray TParams) {
   assert(getNonCompileUnitScope(Context) &&
          "Methods should have both a Context and a context that isn't "
          "the compile unit.");
   // FIXME: Do we want to use different scope/lines?
   auto *SP = getSubprogram(

lib/IR/DebugInfo.cpp

if (auto *LB = dyn_cast<DILexicalBlockBase>(Scope)) {
     processScope(M->getScope());
   }
 }
 
 void DebugInfoFinder::processSubprogram(DISubprogram *SP) {
   if (!addSubprogram(SP))
     return;
   processScope(SP->getScope().resolve(TypeIdentifierMap));
-  processType(SP->getType());
+  processType(SP->getType().resolve(TypeIdentifierMap));
   for (auto *Element : SP->getTemplateParams()) {
     if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
       processType(TType->getType().resolve(TypeIdentifierMap));
     } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
       processType(TVal->getType().resolve(TypeIdentifierMap));
     }
   }
 }

lib/IR/DebugInfoMetadata.cpp

DIMacroFile *DIMacroFile::getImpl(LLVMContext &Context, unsigned MIType,
                                   Metadata *Elements, StorageType Storage,
                                   bool ShouldCreate) {
   DEFINE_GETIMPL_LOOKUP(DIMacroFile,
                         (MIType, Line, File, Elements));
   Metadata *Ops[] = { File, Elements };
   DEFINE_GETIMPL_STORE(DIMacroFile, (MIType, Line), Ops);
 }
 
+DITypeIndex *DITypeIndex::get(LLVMContext &Context, unsigned Index) {
+  DITypeIndex *&Slot = Context.pImpl->TypeIndexCache[Index];
+  if (!Slot) {
+    void *Mem = Context.pImpl->TypeAllocator.Allocate(sizeof(DITypeIndex),
+                                                      alignof(DITypeIndex));
+    Slot = new (Mem) DITypeIndex(Index);
+  }
+  return Slot;
+}

lib/IR/LLVMContextImpl.h

public:
 
   FoldingSet<AttributeImpl> AttrsSet;
   FoldingSet<AttributeSetImpl> AttrsLists;
   FoldingSet<AttributeSetNode> AttrsSetNodes;
 
   StringMap<MDString, BumpPtrAllocator> MDStringCache;
   DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
   DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
+  DenseMap<unsigned, DITypeIndex *> TypeIndexCache;
 
   DenseMap<const Value*, ValueName*> ValueNames;
 
 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
   DenseSet<CLASS *, CLASS##Info> CLASS##s;
 #include "llvm/IR/Metadata.def"
 
   // Optional map for looking up composite types by identifier.

lib/IR/Metadata.cpp

MDString *MDString::get(LLVMContext &Context, StringRef Str) {
   return &MapEntry;
 }
 
 StringRef MDString::getString() const {
   assert(Entry && "Expected to find string map entry");
   return Entry->first();
 }
 
+
 //===----------------------------------------------------------------------===//
 // MDNode implementation.
 //
 
 // Assert that the MDNode types will not be unaligned by the objects
 // prepended to them.
 #define HANDLE_MDNODE_LEAF(CLASS)                                              \
   static_assert(                                                               \

lib/IR/Verifier.cpp

bool Verifier::isValidUUID(const MDNode &N, const Metadata *MD) {
   // Keep track of names of types referenced via UUID so we can check that they
   // actually exist.
   UnresolvedTypeRefs.insert(std::make_pair(S, &N));
   return true;
 }
 
 /// \brief Check if a value can be a reference to a type.
 bool Verifier::isTypeRef(const MDNode &N, const Metadata *MD) {
-  return !MD || isValidUUID(N, MD) || isa<DIType>(MD);
+  return !MD || isValidUUID(N, MD) || isa<DIType>(MD) || isa<DITypeIndex>(MD);
 }
 
 /// \brief Check if a value can be a ScopeRef.
 bool Verifier::isScopeRef(const MDNode &N, const Metadata *MD) {
   return !MD || isValidUUID(N, MD) || isa<DIScope>(MD);
 }
 
 /// \brief Check if a value can be a debug info ref.

 }
 
 void Verifier::visitDISubprogram(const DISubprogram &N) {
   Assert(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
   Assert(isScopeRef(N, N.getRawScope()), "invalid scope", &N, N.getRawScope());
   if (auto *F = N.getRawFile())
     Assert(isa<DIFile>(F), "invalid file", &N, F);
   if (auto *T = N.getRawType())
-    Assert(isa<DISubroutineType>(T), "invalid subroutine type", &N, T);
+    Assert(isa<DISubroutineType>(T) || isa<DITypeIndex>(T),
+           "invalid subroutine type", &N, T);
   Assert(isTypeRef(N, N.getRawContainingType()), "invalid containing type", &N,
          N.getRawContainingType());
   if (auto *Params = N.getRawTemplateParams())
     visitTemplateParams(N, *Params);
   if (auto *S = N.getRawDeclaration())
     Assert(isa<DISubprogram>(S) && !cast<DISubprogram>(S)->isDefinition(),
            "invalid subprogram declaration", &N, S);
   if (auto *RawVars = N.getRawVariables()) {

test/DebugInfo/COFF/local-constant.ll

 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 (trunk 260957)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 !1 = !DIFile(filename: "t.cpp", directory: "D:\5Csrc\5Cllvm\5Cbuild")
 !2 = !{}
 !4 = distinct !DISubprogram(name: "constant_var", linkageName: "\01?constant_var@@YAXXZ", scope: !1, file: !1, line: 2, type: !5, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !7)
 !5 = !DISubroutineType(types: !6)
 !6 = !{null}
 !7 = !{!8}
-!8 = !DILocalVariable(name: "x", scope: !4, file: !1, line: 3, type: !9)
+!8 = !DILocalVariable(name: "x", scope: !4, file: !1, line: 3, type: !DITypeIndex(u0x74))
 !9 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !10 = !{i32 2, !"CodeView", i32 1}
 !11 = !{i32 2, !"Debug Info Version", i32 3}
 !12 = !{i32 1, !"PIC Level", i32 2}
 !13 = !{!"clang version 3.9.0 (trunk 260957)"}
 !14 = !DIExpression()
 !15 = !DILocation(line: 3, column: 7, scope: !4)
 !16 = !DILocation(line: 4, column: 3, scope: !4)
 !17 = !DILocation(line: 5, column: 3, scope: !4)
 !18 = !DILocation(line: 6, column: 1, scope: !4)

test/DebugInfo/COFF/local-variables.ll

 !llvm.ident = !{!14}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
 !1 = !DIFile(filename: "t.cpp", directory: "D:\5Csrc\5Cllvm\5Cbuild")
 !2 = !{}
 !4 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 7, type: !5, isLocal: false, isDefinition: true, scopeLine: 7, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
 !5 = !DISubroutineType(types: !6)
 !6 = !{null, !7}
 !7 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !8 = distinct !DISubprogram(name: "will_be_inlined", linkageName: "\01?will_be_inlined@@YAXXZ", scope: !1, file: !1, line: 3, type: !9, isLocal: true, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
 !9 = !DISubroutineType(types: !10)
 !10 = !{null}
 !11 = !{i32 2, !"CodeView", i32 1}
 !12 = !{i32 2, !"Debug Info Version", i32 3}
 !13 = !{i32 1, !"PIC Level", i32 2}
 !14 = !{!"clang version 3.9.0 "}
-!15 = !DILocalVariable(name: "v", scope: !8, file: !1, line: 4, type: !7)
+!15 = !DILocalVariable(name: "v", scope: !8, file: !1, line: 4, type: !DITypeIndex(u0x74))
 !16 = !DIExpression()
 !17 = !DILocation(line: 4, column: 7, scope: !8, inlinedAt: !18)
 !18 = distinct !DILocation(line: 14, column: 5, scope: !19)
 !19 = distinct !DILexicalBlock(scope: !20, file: !1, line: 12, column: 10)
 !20 = distinct !DILexicalBlock(scope: !4, file: !1, line: 8, column: 7)
 !21 = !DILocation(line: 4, column: 7, scope: !8, inlinedAt: !22)
 !22 = distinct !DILocation(line: 10, column: 5, scope: !23)
 !23 = distinct !DILexicalBlock(scope: !20, file: !1, line: 8, column: 14)
-!24 = !DILocalVariable(name: "param", arg: 1, scope: !4, file: !1, line: 7, type: !7)
+!24 = !DILocalVariable(name: "param", arg: 1, scope: !4, file: !1, line: 7, type: !DITypeIndex(u0x74))
 !25 = !DILocation(line: 7, column: 23, scope: !4)
 !26 = !DILocation(line: 8, column: 7, scope: !20)
 !27 = !DILocation(line: 8, column: 7, scope: !4)
-!28 = !DILocalVariable(name: "a", scope: !23, file: !1, line: 9, type: !7)
+!28 = !DILocalVariable(name: "a", scope: !23, file: !1, line: 9, type: !DITypeIndex(u0x74))
 !29 = !DILocation(line: 9, column: 9, scope: !23)
 !30 = !DILocation(line: 5, column: 3, scope: !8, inlinedAt: !22)
 !31 = !DILocation(line: 11, column: 5, scope: !23)
 !32 = !DILocation(line: 12, column: 3, scope: !23)
-!33 = !DILocalVariable(name: "b", scope: !19, file: !1, line: 13, type: !7)
+!33 = !DILocalVariable(name: "b", scope: !19, file: !1, line: 13, type: !DITypeIndex(u0x74))
 !34 = !DILocation(line: 13, column: 9, scope: !19)
 !35 = !DILocation(line: 5, column: 3, scope: !8, inlinedAt: !18)
 !36 = !DILocation(line: 15, column: 5, scope: !19)
 !37 = !DILocation(line: 17, column: 1, scope: !4)

test/DebugInfo/COFF/register-variables.ll

 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (trunk 260617) (llvm/trunk 260619)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !22)
 !1 = !DIFile(filename: "t.cpp", directory: "D:\5Csrc\5Cllvm\5Cbuild")
 !2 = !{}
 !4 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 9, type: !5, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !8)
 !5 = !DISubroutineType(types: !6)
 !6 = !{null, !7}
 !7 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !8 = !{!9, !10, !13, !14}
-!9 = !DILocalVariable(name: "p", arg: 1, scope: !4, file: !1, line: 9, type: !7)
-!10 = !DILocalVariable(name: "a", scope: !11, file: !1, line: 11, type: !7)
+!9 = !DILocalVariable(name: "p", arg: 1, scope: !4, file: !1, line: 9, type: !DITypeIndex(u0x74))
+!10 = !DILocalVariable(name: "a", scope: !11, file: !1, line: 11, type: !DITypeIndex(u0x74))
 !11 = distinct !DILexicalBlock(scope: !12, file: !1, line: 10, column: 10)
 !12 = distinct !DILexicalBlock(scope: !4, file: !1, line: 10, column: 7)
-!13 = !DILocalVariable(name: "b", scope: !11, file: !1, line: 12, type: !7)
-!14 = !DILocalVariable(name: "c", scope: !15, file: !1, line: 15, type: !7)
+!13 = !DILocalVariable(name: "b", scope: !11, file: !1, line: 12, type: !DITypeIndex(u0x74))
+!14 = !DILocalVariable(name: "c", scope: !15, file: !1, line: 15, type: !DITypeIndex(u0x74))
 !15 = distinct !DILexicalBlock(scope: !12, file: !1, line: 14, column: 10)
 !16 = distinct !DISubprogram(name: "inlineinc", scope: !1, file: !1, line: 4, type: !17, isLocal: true, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !19)
 !17 = !DISubroutineType(types: !18)
 !18 = !{!7, !7}
 !19 = !{!20, !21}
-!20 = !DILocalVariable(name: "a", arg: 1, scope: !16, file: !1, line: 4, type: !7)
-!21 = !DILocalVariable(name: "b", scope: !16, file: !1, line: 5, type: !7)
+!20 = !DILocalVariable(name: "a", arg: 1, scope: !16, file: !1, line: 4, type: !DITypeIndex(u0x74))
+!21 = !DILocalVariable(name: "b", scope: !16, file: !1, line: 5, type: !DITypeIndex(u0x74))
 !22 = !{!23}
-!23 = !DIGlobalVariable(name: "x", scope: !0, file: !1, line: 1, type: !24, isLocal: false, isDefinition: true, variable: i32* @x)
-!24 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!23 = !DIGlobalVariable(name: "x", scope: !0, file: !1, line: 1, type: !DITypeIndex(u0x74), isLocal: false, isDefinition: true, variable: i32* @x)
 !25 = !{i32 2, !"CodeView", i32 1}
 !26 = !{i32 2, !"Debug Info Version", i32 3}
 !27 = !{i32 1, !"PIC Level", i32 2}
 !28 = !{!"clang version 3.9.0 (trunk 260617) (llvm/trunk 260619)"}
 !29 = !DIExpression()
 !30 = !DILocation(line: 9, column: 12, scope: !4)
 !31 = !DILocation(line: 10, column: 7, scope: !12)
 !32 = !DILocation(line: 15, column: 13, scope: !15)

unittests/IR/IRBuilderTest.cpp

 
 TEST_F(IRBuilderTest, DIBuilder) {
   IRBuilder<> Builder(BB);
   DIBuilder DIB(*M);
   auto File = DIB.createFile("F.CBL", "/");
   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74, "F.CBL", "/",
                                   "llvm-cobol74", true, "", 0);
   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
-  auto SP =
-      DIB.createFunction(CU, "foo", "", File, 1, Type, false, true, 1, 0, true);
+  auto SP = DIB.createFunction(CU, "foo", "", File, 1, DITypeRef(Type), false,
+                               true, 1, 0, true);
   F->setSubprogram(SP);
   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
-  auto BarSP =
-      DIB.createFunction(CU, "bar", "", File, 1, Type, false, true, 1, 0, true);
+  auto BarSP = DIB.createFunction(CU, "bar", "", File, 1, DITypeRef(Type),
+                                  false, true, 1, 0, true);
   auto BadScope = DIB.createLexicalBlockFile(BarSP, File, 0);
   I->setDebugLoc(DebugLoc::get(2, 0, BadScope));
   DIB.finalize();
   EXPECT_TRUE(verifyModule(*M));
 }
 
 TEST_F(IRBuilderTest, InsertExtractElement) {
   IRBuilder<> Builder(BB);
TEST_F(IRBuilderTest, DebugLoc) {
   auto Callee =
       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
 
   DIBuilder DIB(*M);
   auto File = DIB.createFile("tmp.cpp", "/");
   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11, "tmp.cpp", "/",
                                   "", true, "", 0);
   auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
-  auto SP =
-      DIB.createFunction(CU, "foo", "foo", File, 1, SPType, false, true, 1);
+  auto SP = DIB.createFunction(CU, "foo", "foo", File, 1, DITypeRef(SPType),
+                               false, true, 1);
   DebugLoc DL1 = DILocation::get(Ctx, 2, 0, SP);
   DebugLoc DL2 = DILocation::get(Ctx, 3, 0, SP);
 
   auto BB2 = BasicBlock::Create(Ctx, "bb2", F);
   auto Br = BranchInst::Create(BB2, BB);
   Br->setDebugLoc(DL1);
 
   IRBuilder<> Builder(Ctx);

unittests/IR/MetadataTest.cpp

protected:
   MDNode *getNode(Metadata *MD1, Metadata *MD2) {
     Metadata *MDs[] = {MD1, MD2};
     return MDNode::get(Context, MDs);
   }
 
   MDTuple *getTuple() { return MDTuple::getDistinct(Context, None); }
   DISubroutineType *getSubroutineType() {
     return DISubroutineType::getDistinct(Context, 0, getNode(nullptr));
   }
   DISubprogram *getSubprogram() {
     return DISubprogram::getDistinct(Context, nullptr, "", "", nullptr, 0,
                                      nullptr, false, false, 0, nullptr,
                                      0, 0, 0, false, nullptr);
   }
   DIScopeRef getSubprogramRef() { return getSubprogram()->getRef(); }
   DIFile *getFile() {
     return DIFile::getDistinct(Context, "file.c", "/path/to/dir");

 typedef MetadataTest DISubprogramTest;
 
 TEST_F(DISubprogramTest, get) {
   DIScopeRef Scope = getCompositeType();
   StringRef Name = "name";
   StringRef LinkageName = "linkage";
   DIFile *File = getFile();
   unsigned Line = 2;
-  DISubroutineType *Type = getSubroutineType();
+  DITypeRef Type = DITypeRef(getSubroutineType());
   bool IsLocalToUnit = false;
   bool IsDefinition = true;
   unsigned ScopeLine = 3;
   DITypeRef ContainingType = getCompositeType();
   unsigned Virtuality = 2;
   unsigned VirtualIndex = 5;
   unsigned Flags = 6;
   unsigned NotFlags = (~Flags) & ((1 << 27) - 1);
EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, getFile(),
                                  VirtualIndex, Flags, IsOptimized, Unit,
                                  TemplateParams, Declaration, Variables));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File,
                                  Line + 1, Type, IsLocalToUnit, IsDefinition,
                                  ScopeLine, ContainingType, Virtuality,
                                  VirtualIndex, Flags, IsOptimized, Unit,
                                  TemplateParams, Declaration, Variables));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
-                                 getSubroutineType(), IsLocalToUnit,
+                                 DITypeRef(getSubroutineType()), IsLocalToUnit,
                                  IsDefinition, ScopeLine, ContainingType,
                                  Virtuality, VirtualIndex, Flags, IsOptimized,
                                  Unit, TemplateParams, Declaration, Variables));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, !IsLocalToUnit, IsDefinition, ScopeLine,
                                  ContainingType, Virtuality, VirtualIndex,
                                  Flags, IsOptimized, Unit, TemplateParams,
                                  Declaration, Variables));

unittests/Transforms/Utils/Cloning.cpp

protected:
 
   void CreateOldFunctionBodyAndDI() {
     DIBuilder DBuilder(*M);
     IRBuilder<> IBuilder(C);
 
     // Function DI
     auto *File = DBuilder.createFile("filename.c", "/file/dir/");
     DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
-    DISubroutineType *FuncType =
-        DBuilder.createSubroutineType(ParamTypes);
+    DITypeRef FuncType(DBuilder.createSubroutineType(ParamTypes));
     auto *CU =
         DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
                                    "/file/dir", "CloneFunc", false, "", 0);
 
     auto *Subprogram = DBuilder.createFunction(
         CU, "f", "f", File, 4, FuncType, true, true, 3, 0, false);
     OldFunc->setSubprogram(Subprogram);
 
auto *PersFn = Function::Create(FuncType, GlobalValue::ExternalLinkage,
                                     "persfn", OldM);
     auto *F =
         Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", OldM);
     F->setPersonalityFn(PersFn);
 
     // Create debug info
     auto *File = DBuilder.createFile("filename.c", "/file/dir/");
     DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
-    DISubroutineType *DFuncType = DBuilder.createSubroutineType(ParamTypes);
+    DITypeRef DFuncType(DBuilder.createSubroutineType(ParamTypes));
     auto *CU =
         DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
                                    "/file/dir", "CloneModule", false, "", 0);
     // Function DI
     auto *Subprogram = DBuilder.createFunction(CU, "f", "f", File, 4, DFuncType,
                                                true, true, 3, 0, false);
     F->setSubprogram(Subprogram);