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

1404

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

1404

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

2431

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

lib/AsmParser/LLParser.cpp

4286

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

lib/IR/DIBuilder.cpp

651

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 ↗

(On Diff #54111)

whitespace

lib/IR/Verifier.cpp

954

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

4347

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

2431

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

622

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

591–592

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

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

1209–1210

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

639–640

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

281–282

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

test/Linker/ditypeindex.ll

34–37

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

83

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

591–592

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

639–640

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

34–37

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

83

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

docs/LangRef.rst

 """""""""""
 
 ``DINamespace`` nodes represent namespaces in the source language.
 
 .. code-block:: llvm
 
     !0 = !DINamespace(name: "myawesomeproject", scope: !1, file: !2, line: 7)
 
+.. _DIGlobalVariable:
+
 DIGlobalVariable
 """"""""""""""""
 
 ``DIGlobalVariable`` nodes represent global variables in the source language.
 
 .. code-block:: llvm
 
     !0 = !DIGlobalVariable(name: "foo", linkageName: "foo", scope: !1,

 The ``nodes:`` field is a list of ``DIMacro`` and ``DIMacroFile`` nodes that
 appear in the included source file.
 
 .. code-block:: llvm
 
    !2 = !DIMacroFile(macinfo: DW_MACINFO_start_file, line: 7, file: !2,
                      nodes: !3)
 
+DITypeIndex
+"""""""""""
+
+``DITypeIndex`` nodes represent a single 32-bit number that stands in place of
+a type.  It can be used in the ``type:`` fields of :ref:`DISubprogram`,
+:ref:`DILocalVariable`, and :ref:`DIGlobalVariable`. The index is an opaque
+number referring to data in a separate, per-``DICompileUnit`` type information
+blob provided by the frontend. The contents of that blob and how it is stored
+in the metadata are format-specific. ``DITypeIndex`` is used primarily to
+implement CodeView type information, but in the future it could be used to
+represent a DWARF DIE offset.
+
+.. code-block:: llvm
+  !0 = !DISubprogram(name: !"foo", type: !DITypeIndex(u0x1000), ...)
+  !1 = !DILocalVariable(name: !"x", type: !DITypeIndex(u0x74), ...)
+  !2 = !DIGlobalVariable(name: !"y", type: !DITypeIndex(u0x74), ...)
+
 '``tbaa``' Metadata
 ^^^^^^^^^^^^^^^^^^^
 
 In LLVM IR, memory does not have types, so LLVM's own type system is not
 suitable for doing TBAA. Instead, metadata is added to the IR to
 describe a type system of a higher level language. This can be used to
 implement typical C/C++ TBAA, but it can also be used to implement
 custom alias analysis behavior for other languages.

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);
 
     /// Create a new descriptor for the specified C++ method.
     /// See comments in \a DISubprogram* for descriptions of these fields.
     /// \param Scope         Function scope.
     /// \param Name          Function name.
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) {}
   TypedDINodeRef(const T *MD) : MD(MD) {}
 
   explicit TypedDINodeRef(const Metadata *MD) : MD(MD) {
-    assert((!MD || isa<T>(MD)) && "Expected valid type ref");
+    assert((!MD || isa<T>(MD) || isa<DITypeIndex>(MD)) &&
+           "Expected valid type ref");
   }
 
   template <class U>
   TypedDINodeRef(
       const TypedDINodeRef<U> &X,
       typename std::enable_if<std::is_convertible<U *, T *>::value>::type * =
           nullptr)
       : MD(X) {}
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 type stream at the given index. The type stream is
+/// associated with the DICompileUnit containing the type index reference. This
+/// doesn't contain metadata operands, so it 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.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(...)
+///  ::= !DITypeIndex(...)
 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

private:
   void writeStringRecord(unsigned Code, StringRef Str, unsigned AbbrevToUse);
   void writeAttributeGroupTable();
   void writeAttributeTable();
   void writeTypeTable();
   void writeComdats();
   void writeModuleInfo();
   void writeValueAsMetadata(const ValueAsMetadata *MD,
                             SmallVectorImpl<uint64_t> &Record);
+  void writeDITypeIndex(const DITypeIndex *N,
+                        SmallVectorImpl<uint64_t> &Record);
   void writeMDTuple(const MDTuple *N, SmallVectorImpl<uint64_t> &Record,
                     unsigned Abbrev);
   unsigned createDILocationAbbrev();
   void writeDILocation(const DILocation *N, SmallVectorImpl<uint64_t> &Record,
                        unsigned &Abbrev);
   unsigned createGenericDINodeAbbrev();
   void writeGenericDINode(const GenericDINode *N,
                           SmallVectorImpl<uint64_t> &Record, unsigned &Abbrev);
void ModuleBitcodeWriter::writeValueAsMetadata(
   // 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();
 }
 
+void ModuleBitcodeWriter::writeDITypeIndex(const DITypeIndex *TI,
+                                           SmallVectorImpl<uint64_t> &Record) {
+  Record.push_back(TI->getIndex());
+  Stream.EmitRecord(bitc::METADATA_TYPE_INDEX, Record, 0);
+  Record.clear();
+}
+
 void ModuleBitcodeWriter::writeMDTuple(const MDTuple *N,
                                        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), Record, CLASS##Abbrev);                       \
     continue;
 #include "llvm/IR/Metadata.def"
       }
+    } else if (const DITypeIndex *TI = dyn_cast<DITypeIndex>(MD)) {
+      writeDITypeIndex(TI, Record);
+      continue;
     }
     writeValueAsMetadata(cast<ValueAsMetadata>(MD), Record);
   }
 }
 
 void ModuleBitcodeWriter::writeModuleMetadata() {
   if (!VE.hasMDs() && M.named_metadata_empty())
     return;

lib/Bitcode/Writer/ValueEnumerator.cpp

while (!Worklist.empty()) {
     }
   }
 }
 
 const MDNode *ValueEnumerator::enumerateMetadataImpl(unsigned F, const Metadata *MD) {
   if (!MD)
     return nullptr;
 
-  assert(
-      (isa<MDNode>(MD) || isa<MDString>(MD) || isa<ConstantAsMetadata>(MD)) &&
-      "Invalid metadata kind");
+  assert((isa<MDNode>(MD) || isa<MDString>(MD) || isa<DITypeIndex>(MD) ||
+          isa<ConstantAsMetadata>(MD)) ||
+         isa<DITypeIndex>(MD) && "Invalid metadata kind");
 
   auto Insertion = MetadataMap.insert(std::make_pair(MD, MDIndex(F)));
   MDIndex &Entry = Insertion.first->second;
   if (!Insertion.second) {
     // Already mapped.  If F doesn't match the function tag, drop it.
     if (Entry.hasDifferentFunction(F))
       dropFunctionFromMetadata(*Insertion.first);
     return nullptr;

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 auto *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

 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,
       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, 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());
-  processType(SP->getType());
+  processType(SP->getType().resolve());
   for (auto *Element : SP->getTemplateParams()) {
     if (auto *TType = dyn_cast<DITemplateTypeParameter>(Element)) {
       processType(TType->getType().resolve());
     } else if (auto *TVal = dyn_cast<DITemplateValueParameter>(Element)) {
       processType(TVal->getType().resolve());
     }
   }
 }

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.
#include "llvm/IR/Metadata.def"
 
   // Basic type instances.
   Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy;
   Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
   IntegerType Int1Ty, Int8Ty, Int16Ty, Int32Ty, Int64Ty, Int128Ty;
 
   
   /// TypeAllocator - All dynamically allocated types are allocated from this.
-  /// They live forever until the context is torn down.
+  /// They live forever until the context is torn down. Also used to store
+  /// DITypeIndex objects, which have the same lifetime.
   BumpPtrAllocator TypeAllocator;
   
   DenseMap<unsigned, IntegerType*> IntegerTypes;
 
   typedef DenseSet<FunctionType *, FunctionTypeKeyInfo> FunctionTypeSet;
   FunctionTypeSet FunctionTypes;
   typedef DenseSet<StructType *, AnonStructTypeKeyInfo> StructTypeSet;
   StructTypeSet AnonStructTypes;

lib/IR/Verifier.cpp

void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) {
   // avoids infinite recursion here, as well as being an optimization.
   if (!MDNodes.insert(MD).second)
     return;
 
   if (auto *V = dyn_cast<ValueAsMetadata>(MD))
     visitValueAsMetadata(*V, F);
 }
 
-static bool isType(const Metadata *MD) { return !MD || isa<DIType>(MD); }
+static bool isType(const Metadata *MD) {
+  return !MD || isa<DITypeIndex>(MD) || isa<DIType>(MD);
+}
 static bool isScope(const Metadata *MD) { return !MD || isa<DIScope>(MD); }
 static bool isDINode(const Metadata *MD) { return !MD || isa<DINode>(MD); }
 
 template <class Ty>
 bool isValidMetadataArrayImpl(const MDTuple &N, bool AllowNull) {
   for (Metadata *MD : N.operands()) {
     if (MD) {
       if (!isa<Ty>(MD))

 }
 
 void Verifier::visitDISubprogram(const DISubprogram &N) {
   Assert(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
   Assert(isScope(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(isType(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()) {

lib/Transforms/Utils/ValueMapper.cpp

Optional<Metadata *> MDNodeMapper::tryToMapOperand(const Metadata *Op) {
 
   if (Optional<Metadata *> MappedOp = M.mapSimpleMetadata(Op)) {
 #ifndef NDEBUG
     if (auto *CMD = dyn_cast<ConstantAsMetadata>(Op))
       assert((!*MappedOp || M.getVM().count(CMD->getValue()) ||
               M.getVM().getMappedMD(Op)) &&
              "Expected Value to be memoized");
     else
-      assert((isa<MDString>(Op) || M.getVM().getMappedMD(Op)) &&
+      assert((isa<MDString>(Op) || isa<DITypeIndex>(Op) ||
+              M.getVM().getMappedMD(Op)) &&
              "Expected result to be memoized");
 #endif
     return *MappedOp;
   }
 
   const MDNode &N = *cast<MDNode>(Op);
   if (N.isDistinct())
     return mapDistinctNode(N);

 
 Optional<Metadata *> MDNodeMapper::getMappedOp(const Metadata *Op) const {
   if (!Op)
     return nullptr;
 
   if (Optional<Metadata *> MappedOp = M.getVM().getMappedMD(Op))
     return *MappedOp;
 
-  if (isa<MDString>(Op))
+  if (isa<MDString>(Op) || isa<DITypeIndex>(Op))
     return const_cast<Metadata *>(Op);
 
   if (auto *CMD = dyn_cast<ConstantAsMetadata>(Op))
     return wrapConstantAsMetadata(*CMD, M.getVM().lookup(CMD->getValue()));
 
   return None;
 }
 

 
 } // end namespace
 
 Optional<Metadata *> Mapper::mapSimpleMetadata(const Metadata *MD) {
   // If the value already exists in the map, use it.
   if (Optional<Metadata *> NewMD = getVM().getMappedMD(MD))
     return *NewMD;
 
-  if (isa<MDString>(MD))
+  if (isa<MDString>(MD) || isa<DITypeIndex>(MD))
     return const_cast<Metadata *>(MD);
 
   // This is a module-level metadata.  If nothing at the module level is
   // changing, use an identity mapping.
   if ((Flags & RF_NoModuleLevelChanges))
     return const_cast<Metadata *>(MD);
 
   if (auto *CMD = dyn_cast<ConstantAsMetadata>(MD)) {

test/Assembler/ditypeindex.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
+@y = global i32 3, align 4
+
+; Function Attrs: nounwind
+define void @f() #0 !dbg !4 {
+entry:
+  %x = alloca i32, align 4
+  call void @llvm.dbg.declare(metadata i32* %x, metadata !13, metadata !14), !dbg !15
+  %0 = load i32, i32* @y, align 4, !dbg !15
+  store i32 %0, i32* %x, align 4, !dbg !15
+  ret void, !dbg !15
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-features"="+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!11}
+!llvm.ident = !{!12}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !8)
+!1 = !DIFile(filename: "<stdin>", directory: "D:\5Csrc\5Cllvm\5Cbuild")
+!2 = !{}
+!3 = !{!4}
+!4 = distinct !DISubprogram(name: "f", scope: !5, file: !5, line: 2, type: !DITypeIndex(u0x74), isLocal: false, isDefinition: true, scopeLine: 2, isOptimized: false, unit: !0, variables: !2)
+!5 = !DIFile(filename: "t.cpp", directory: "D:\5Csrc\5Cllvm\5Cbuild")
+!6 = !DISubroutineType(types: !7)
+!7 = !{null}
+!8 = !{!9}
+!9 = !DIGlobalVariable(name: "y", scope: !0, file: !5, line: 1, type: !DITypeIndex(u0x74), isLocal: false, isDefinition: true, variable: i32* @y)
+!11 = !{i32 2, !"Debug Info Version", i32 3}
+!12 = !{!"clang version 3.9.0 "}
+!13 = !DILocalVariable(name: "x", scope: !4, file: !5, line: 2, type: !DITypeIndex(u0x74))
+!14 = !DIExpression()
+!15 = !DILocation(line: 2, scope: !4)
+
+; CHECK-DAG: distinct !DISubprogram(name: "f", {{.*}}, type: !DITypeIndex(u0x74){{.*}})
+; CHECK-DAG: !DIGlobalVariable(name: "y", {{.*}}, type: !DITypeIndex(u0x74){{.*}})
+; CHECK-DAG: !DILocalVariable(name: "x", {{.*}}, type: !DITypeIndex(u0x74){{.*}})

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

 ; RUN: llc -mtriple=x86_64-windows-msvc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -mtriple=x86_64-windows-msvc < %s -filetype=obj | llvm-readobj -codeview - | FileCheck %s --check-prefix=OBJ
 
 ; This LL file was generated by running 'clang -g -gcodeview' on the
 ; following code:
 ;  1: extern "C" volatile int x;
 ;  2: extern "C" void capture(int *p);
 ;  3: static __forceinline inline void will_be_inlined() {
 ;  4:   int v = 3;
 ;  5:   capture(&v);
 ;  6: }
-;  7: extern "C" void f(int param) {
+;  7: extern "C" void f(unsigned param) {
 ;  8:   if (param) {
 ;  9:     int a = 42;
 ; 10:     will_be_inlined();
 ; 11:     capture(&a);
 ; 12:   } else {
-; 13:     int b = 42;
+; 13:     unsigned b = 42;
 ; 14:     will_be_inlined();
 ; 15:     capture(&b);
 ; 16:   }
 ; 17: }
 
 ; ASM: f:                                      # @f
 ; ASM:         .cv_file        1 "D:\\src\\llvm\\build\\t.cpp"
 ; ASM:         .cv_loc 0 1 7 0 is_stmt 0       # t.cpp:7:0

 ; ASM: [[else_end:\.Ltmp.*]]:
 ; ASM:         .cv_loc 0 1 17 1                # t.cpp:17:1
 ; ASM:         nop
 ; ASM:         addq    $56, %rsp
 ; ASM:         retq
 ; ASM: [[param_end:\.Ltmp.*]]:
 
 ; ASM: .short  4414                    # Record kind: S_LOCAL
-; ASM: .long   116                     # TypeIndex
+; ASM: .long   117                     # TypeIndex
 ; ASM: .short  1                       # Flags
 ; ASM: .asciz  "param"
 ; ASM: .cv_def_range    [[prologue_end]] [[param_end]], "E\021O\001\000\000,\000\000\000"
 ; ASM: .short  4414                    # Record kind: S_LOCAL
 ; ASM: .long   116                     # TypeIndex
 ; ASM: .short  0                       # Flags
 ; ASM: .asciz  "a"
 ; ASM: .cv_def_range    [[if_start]] [[else_start]], "E\021O\001\000\000(\000\000\000"
 ; ASM: .short  4414                    # Record kind: S_LOCAL
-; ASM: .long   116                     # TypeIndex
+; ASM: .long   117                     # TypeIndex
 ; ASM: .short  0                       # Flags
 ; ASM: .asciz  "b"
 ; ASM: .cv_def_range    [[else_start]] [[else_end]], "E\021O\001\000\000$\000\000\000"
 ; ASM: .short  4429                    # Record kind: S_INLINESITE
 ; ASM: .short  4414                    # Record kind: S_LOCAL
 ; ASM: .long   116                     # TypeIndex
 ; ASM: .short  0                       # Flags
 ; ASM: .asciz  "v"

 
 ; OBJ:  Subsection [
 ; OBJ:    SubSectionType: Symbols (0xF1)
 ; OBJ:    ProcStart {
 ; OBJ:      DisplayName: f
 ; OBJ:      LinkageName: f
 ; OBJ:    }
 ; OBJ:    Local {
-; OBJ:      Type: int (0x74)
+; OBJ:      Type: unsigned (0x75)
 ; OBJ:      Flags [ (0x1)
 ; OBJ:        IsParameter (0x1)
 ; OBJ:      ]
 ; OBJ:      VarName: param
 ; OBJ:    }
 ; OBJ:    DefRangeRegisterRel {
 ; OBJ:      BaseRegister: 335
 ; OBJ:      HasSpilledUDTMember: No

 ; OBJ:      BasePointerOffset: 40
 ; OBJ:      LocalVariableAddrRange {
 ; OBJ:        OffsetStart: .text+0xC
 ; OBJ:        ISectStart: 0x0
 ; OBJ:        Range: 0x21
 ; OBJ:      }
 ; OBJ:    }
 ; OBJ:    Local {
-; OBJ:      Type: int (0x74)
+; OBJ:      Type: unsigned (0x75)
 ; OBJ:      Flags [ (0x0)
 ; OBJ:      ]
 ; OBJ:      VarName: b
 ; OBJ:    }
 ; OBJ:    DefRangeRegisterRel {
 ; OBJ:      BaseRegister: 335
 ; OBJ:      HasSpilledUDTMember: No
 ; OBJ:      OffsetInParent: 0

 attributes #3 = { nounwind }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!11, !12, !13}
 !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}
+!4 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 7, type: !DITypeIndex(u0x1003), isLocal: false, isDefinition: true, scopeLine: 7, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!8 = distinct !DISubprogram(name: "will_be_inlined", linkageName: "\01?will_be_inlined@@YAXXZ", scope: !1, file: !1, line: 3, type: !DITypeIndex(u0x1003), isLocal: true, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
 !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(u0x75))
 !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(u0x75))
 !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

 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!25, !26, !27}
 !llvm.ident = !{!28}
 
 !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)
+!4 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 9, type: !DITypeIndex(u0x1003), isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !8)
 !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}
+!16 = distinct !DISubprogram(name: "inlineinc", scope: !1, file: !1, line: 4, type: !DITypeIndex(u0x1003), isLocal: true, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !19)
 !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)

test/Linker/Inputs/ditypeindex.ll

+@b = global i32 2
+@c = global i64 3
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!6, !7, !8}
+!llvm.ident = !{!9}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!1 = !DIFile(filename: "t.c", directory: "D:\5Csrc\5Cllvm\5Cbuild")
+!2 = !{}
+!3 = !{!4, !5}
+!4 = !DIGlobalVariable(name: "b", scope: !0, file: !1, line: 1, type: !DITypeIndex(u0x74), isLocal: false, isDefinition: true, variable: i32* @b)
+!5 = !DIGlobalVariable(name: "c", scope: !0, file: !1, line: 1, type: !DITypeIndex(u0x13), isLocal: false, isDefinition: true, variable: i64* @c)
+!6 = !{i32 2, !"CodeView", i32 1}
+!7 = !{i32 2, !"Debug Info Version", i32 3}
+!8 = !{i32 1, !"PIC Level", i32 2}
+!9 = !{!"clang version 3.9.0 "}

test/Linker/ditypeindex.ll

+; RUN: llvm-link %s %S/Inputs/ditypeindex.ll -S -o - | FileCheck %s
+
+@a = global i32 1
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!6, !7, !8}
+!llvm.ident = !{!9}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!1 = !DIFile(filename: "t.c", directory: "D:\5Csrc\5Cllvm\5Cbuild")
+!2 = !{}
+!3 = !{!4}
+!4 = !DIGlobalVariable(name: "a", scope: !0, file: !1, line: 1, type: !DITypeIndex(u0x74), isLocal: false, isDefinition: true, variable: i32* @a)
+!6 = !{i32 2, !"CodeView", i32 1}
+!7 = !{i32 2, !"Debug Info Version", i32 3}
+!8 = !{i32 1, !"PIC Level", i32 2}
+!9 = !{!"clang version 3.9.0 "}
+
+; CHECK: @a = global i32 1
+; CHECK: @b = global i32 2
+; CHECK: @c = global i64 3
+; CHECK: !DIGlobalVariable(name: "a", {{.*}}type: !DITypeIndex(u0x74){{.*}}variable: i32* @a)
+; CHECK: !DIGlobalVariable(name: "b", {{.*}}type: !DITypeIndex(u0x74){{.*}}variable: i32* @b)
+; CHECK: !DIGlobalVariable(name: "c", {{.*}}type: !DITypeIndex(u0x13){{.*}}variable: i64* @c)

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() { return MDNode::get(Context, None); }
   MDNode *getNode(Metadata *MD) { return MDNode::get(Context, MD); }
   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));
+  DITypeRef getSubroutineType() {
+    return DITypeRef(
+        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);
   }
   DIFile *getFile() {
     return DIFile::getDistinct(Context, "file.c", "/path/to/dir");

 typedef MetadataTest DISubprogramTest;
 
 TEST_F(DISubprogramTest, get) {
   DIScope *Scope = getCompositeType();
   StringRef Name = "name";
   StringRef LinkageName = "linkage";
   DIFile *File = getFile();
   unsigned Line = 2;
-  DISubroutineType *Type = getSubroutineType();
+  DITypeRef Type = getSubroutineType();
   bool IsLocalToUnit = false;
   bool IsDefinition = true;
   unsigned ScopeLine = 3;
   DIType *ContainingType = getCompositeType();
   unsigned Virtuality = 2;
   unsigned VirtualIndex = 5;
   unsigned Flags = 6;
   unsigned NotFlags = (~Flags) & ((1 << 27) - 1);

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);