[codeview] Adding support for CodeView types

[aaboud]

Summary

Added support for CodeView Types.
Now type indices are auto generated.
The idea is:

1. to lower types from LLVM DIType to CodeViewType during assembly processing (codeview symbol processing).
2. assigned indices to all codeview types according to order they are going to be emitted in.
3. emit the codeview types into .Debug$T section.

Note: This patch only adds support for Basic types and function type (and id).

Once this patch is committed, it will be relatively easy to support all other kind of types.

Few LIT tests were modified to be aligned with the changes and two LIT tests that covers basic types and function type were added.

[zturner]

I'll let someone else comment on the record emission.

include/llvm/DebugInfo/CodeView/TypeRecord.h

880

This looks wrong to me. It does not include the length of the name. Also, I would prefer if the 2 + were raised somehow, because it is common to every single type of CodeView record, and this logic of knowing that a type record has 2 header bytes should be common somewhere.

Also, each type record knows how to deserialize itself (see the deserialize method above), should we centralize the serialization logic here as well using a similar pattern?

[majnemer]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

812

This can't be right. You want to transform the index if the name has "long" somewhere in it?
I'd suggest matching against "long INT" explicitly.

838

Please use // for comments.

849

Pointers lean right.

861–862

Please use clang-format here, you have an abnormal amount of space between the pointee type and the star.

896

The LLVM style is just to use unsigned instead of unsigned int.

898–900

These extra braces are a little jarring.

902–917

I'd just do:

if (CodeViewType *CVType = getMappedCodeViewType(Type))
  return CVType;

switch (Tag) {
case dwarf::DW_TAG_base_type:
  return lowerTypeBasic(cast<DIBasicType>(Type));
case dwarf::DW_TAG_subroutine_type:
  return lowerTypeSubroutine(cast<DISubroutineType>(Type));
default:
  // TODO: Enable this assert once all types are implemented
  //assert(Tag != Tag && "Unhandled type Tag!");
  return nullptr;
}

914

Er, Tag != Tag? Perhaps you want llvm_unreachable ?

956–961

If there is a single path between a variable and it's initialization, we typically sink the definition to the initializer.

990–995

Ditto.

1134

unsigned

1143

unsigned

1154–1156

Please make this one line.

1172

llvm_unreachable?

lib/CodeGen/AsmPrinter/CodeViewDebug.h

152–154

Could this be DeleteContainerPointers(TypeTable) ?

[rnk]

Thanks Amjad! Adrian Mccarthy, who I added to the review, was also just getting started on this approach. At a high level, I'd like to keep as much CV serialization logic in lib/DebugInfo/CodeView as possible.

My thinking was that for every CV type record, we'd serialize the record in memory using MemoryTypeTableBuilder as we encounter DITypes. After translation, for each record we would call some new virtual MCStreamer method like EmitCVType. In MCObjectStreamer, this would delegate directly to EmitBytes. In MCAsmStreamer, this would do more work to try to make the output pretty. My initial idea is that it would emit each record as a sequence of 32-bit hex integers preceded by a big block comment generated by the same type dumper that llvm-readobj and llvm-pdbdump use.

Thoughts?

include/llvm/DebugInfo/CodeView/TypeRecord.h

880

We won't need to know the layout size if we use MemoryTypeTableBuilder or something like it.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1095

Why not assign type indices as we lower types, and then maintain a mapping from DIType* to TypeIndex? That seems like it would be considerably more efficient for C++ programs with lots of types.

1181

I actually wanted to move away from serializing type records using the MCStreamer interface, because it completely duplicates the CV type record layout. Instead I was suggesting to Adrian Mccarthy that we use MemoryTypeTableBuilder.

We can preserve the pretty assembly printing functionality by calling the dumper on our serialized CV types and printing that as a comment before every binary record. If we do that, we should emit CV records as a series of 32-hex bit words instead of using "EmitBytes", which uses the .ascii directive, which is useless when trying to read the assembly.

lib/CodeGen/AsmPrinter/CodeViewType.h

1

Is there a reason you can't modify TypeRecord.h to make its types suitable for this?

[dblaikie]

Here are some basic thoughts - I'd probably wait for Reid to chime in before getting too deep into all this feedback. He might have some higher level feedback, outstanding patches, etc, to worry about.

include/llvm/DebugInfo/CodeView/TypeRecord.h

880

Where's the 2 come from? Could use a comment.

& if this size is being used as part of the output format, you'd probably need to make sure the Layout struct is packed, etc. But might be better not to rely on that at all, if you can help it.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

257

We usually skip {} on single line blocks (general code review feedback, not just this instance)

874–881

Looks like you could skip the CVType variable and just use VoidType directly. (& I might consider inverting the condition/returning early to reduce indentation)

902

Sink the variable to its declaration (& that'll also avoid a -Wparentheses warning here)

906–907

Sink the variable declaration into the switch condition. Oh, then the variable would be unused - remove the variable and just "switch (Type->getTag())"

931–932

Probably just sink these two variables into their only use - their initialization expressions are pretty self explanatory.

956–957

I don't /think/ we usually do this sort of alignment, but I could be wrong.

970–971

Formatting ("} else {"). Probably just run the whole thing through clang-format.

1004

Prefer !empty over size in this context

1040–1042

Move declarations to their first use or otherwise as close as possible (just above the if/else for CVType, for example). Reduces the scope/makes it easier to understand their use, etc. (general feedback, not just this instance)

Actually you could probably skip CVType entirely and just return:

if (...)
  return nullptr;
return lowerType(Type);

1048–1050

Then roll this declaration into the if:

if (const auto *ClassType = dyn_cast<DIType>(...))

Oh, the variable's unused - use isa<DIType> instead.

1079–1082

Maybe use the conditional operator here

1122

Probably more efficient to emit the original bytes, then emit a null byte - rather than copying the whole string, adding a null terminator, then emitting that.

1126–1127

I think we have some utility functions for computing teh nearest alignment, which might make this easier to read.

1182–1189

Not sure if this is idiomatic of other parts of the file - but mostly I'd just sink all these variables into their only use (especially since there's the "addComment" line above each emission to indicate what's being emitted in case the expression's not self documenting enough. (so adding a variable name doesn't necessarily add lots of value)

Goes for the other emit functions below.

lib/CodeGen/AsmPrinter/CodeViewDebug.h

108

Could you use a MapVector to keep the vector and map together. Or, alternatively, to save space, you could create a temporary vector at the point of emission, and sort based on the type id.

152–154

Should TypeTable contain unique_ptrs instead of raw pointers - then this manual memory management wouldn't be needed?

If it is needed, you can use DeleteContainerPointers to do this work.

lib/CodeGen/AsmPrinter/CodeViewType.cpp

1

Pretty much all the functions in this file are trivial enough to be defined inline in the header.

Though the virtual dtors do need to be out of line for the weak vtable style guide requirement/recommendation.

lib/CodeGen/AsmPrinter/CodeViewType.h

47

Any reason for this to be a virtual hierarchy if it has no other virtual functions? Should it have some?

65

Seems weird for this to be protected. Nothing else is derived from this type so maybe make it private? (same point for other CodeViewType derived classes)

Also, the naming scheme might be beter as "CodeView<X>Type" rather than "CodeViewType<X>" (eg: CodeViewBasicType here)

153

Please use 'override' where applicable.

157–158

Should return by reference, not pointer, I think?

160

Probably skip this if it just returns getArgumentList().size() ?

test/DebugInfo/COFF/basic-types.ll

20–21

Pretty sure you don't need uses of variables to cause them to be emitted at -O0, right?

test/DebugInfo/COFF/function-type.ll

6–8

There's a function type you could test in the basic-types test case, perhaps? (not a hard requirement - it's a tricky tradeoff between multiple mini tests in a single test case, versus pulling things out into entirely separate test cases to make it simpler/more obvious)

[aaboud]

Hi all,
Thanks a lot for all your valuable comments.

Reid, I agree with you that we can reuse TypeRecord instead of introducing a new CodeViewType.
I also understand your design and approach. And I am willing to refactor my patch to suit them.

However, I must mention two concerns:

1. Can we be sure that we can generate the correct index for each type record during creation of that record?
   • In some cases you want to revisit the type record you generated to fix some of its attributes (like the attribute "ClassOptions::ContainsNestedClass").
2. PDB support
   • I know that you do not want to support PDB, but we must keep it into consideration.
   • When emitting types to PDB we do not know the index of each type record before we actually emit the record.
   • In the current design we create the type record index when we write the record (before we emit it to the object/pdb file).

Once again, the approach you have in mind can work if we solve the above two issues.
One way to solve them is to allow fixing data in the written record, although it would be better if we can delay the creation of the record buffer till we know the final value of the data.

Any thoughts?

lib/CodeGen/AsmPrinter/CodeViewDebug.h

108

It will not work once I add support of class types.
Because the map will have two dimensions, [Class-Type][DIType] -> CodeViewType.
And the order we want to save in the vector will get lost in this two dimentson map.

test/DebugInfo/COFF/function-type.ll

6–8

You are right, but I wanted to have a better test for LF_ARGLIST, the function in the basic-types test is very simple.
Also, having a test for each type rather than having one test for all types will help understanding the reason for the failure faster.
Finally, we do not have a lot of types, something around 10, is that too much for tests?

Notice that I am not trying to have a test for each CodeView type entry, and will merge some entries in same test where it make sense.

[rnk]

In D20435#436415, @aaboud wrote:

Hi all,
Thanks a lot for all your valuable comments.

Reid, I agree with you that we can reuse TypeRecord instead of introducing a new CodeViewType.
I also understand your design and approach. And I am willing to refactor my patch to suit them.

Great!

However, I must mention two concerns:

1. Can we be sure that we can generate the correct index for each type record during creation of that record?
   • In some cases you want to revisit the type record you generated to fix some of its attributes (like the attribute "ClassOptions::ContainsNestedClass").

I guess the issue is that classes don't contain their nested classes, instead the nested class points back at the parent record through its scope field. I think here we've found the first point where we'll need to extend the existing metadata. Consider the IR metadata generated for this example:

struct A {
  int a;
  struct B { int b; };
};
A a;
//A::B b;

Today the metadata we generate does not mention B at all, and that is a problem we're going to have to fix if we want our type records to be bitwise identical across TUs. I think we should change clang to mention a forward declaration of B in the elements list of A, and then we don't need to go back and patch up existing type records.

2. PDB support
   • I know that you do not want to support PDB, but we must keep it into consideration.
   • When emitting types to PDB we do not know the index of each type record before we actually emit the record.
   • In the current design we create the type record index when we write the record (before we emit it to the object/pdb file).

I assume the way we support types in PDBs is by doing synchronous IPCs or file IO at the point of the call to TypeTableBuilder::writeRecord. Is that not similar to what MSVC does?

Once again, the approach you have in mind can work if we solve the above two issues.
One way to solve them is to allow fixing data in the written record, although it would be better if we can delay the creation of the record buffer till we know the final value of the data.

Any thoughts?

[aaboud]

Hi Reid,

Today the metadata we generate does not mention B at all, and that is a problem we're going to have to fix if we want our type records to be bitwise identical across TUs. I think we should change clang to mention a forward declaration of B in the elements list of A, and then we don't need to go back and patch up existing type records.

I wanted to show you that the current debug info metadata contain (almost) everything we need to generate codeview types and symbols.
The reason you keep thinking that we need to change the metadata is that you decided on this implementation direction.

I assume the way we support types in PDBs is by doing synchronous IPCs or file IO at the point of the call to TypeTableBuilder::writeRecord. Is that not similar to what MSVC does?

If we will end up emitting the type record to the pdb file at "TypeTableBuilder::writeRecord", then I assume we will get the correct index after all, but can we do that when supporting pdb files? and if so, why not do that for COFF files two?

---

Finally, one minor issue regarding debuggablity and testing, are we fine to get ".debug$T" section printed in assembly mode like this, instead of have each "Type record data" string split and explained by field?

.section        .debug$T,"dr"
.long   4                       # Debug section magic
.short  6                       # Type record length
.asciz  "\001\022\000\000\000"  # Type record data
.short  14                      # Type record length
.asciz  "\b\020\003\000\000\000\000\000\000\000\000\020\000" # Type record data
.short  12                      # Type record length
.asciz  "\001\026\000\000\000\000\001\020\000\000f" # Type record data

[rnk]

In D20435#437656, @aaboud wrote:

I wanted to show you that the current debug info metadata contain (almost) everything we need to generate codeview types and symbols.
The reason you keep thinking that we need to change the metadata is that you decided on this implementation direction.

Well, I think my example shows that we *must* change our type emission to at least mention A::B. I also think it would be convenient to make A reference A::B, so that we don't have to do a complete module pass over all DIType nodes.

I assume the way we support types in PDBs is by doing synchronous IPCs or file IO at the point of the call to TypeTableBuilder::writeRecord. Is that not similar to what MSVC does?

If we will end up emitting the type record to the pdb file at "TypeTableBuilder::writeRecord", then I assume we will get the correct index after all, but can we do that when supporting pdb files? and if so, why not do that for COFF files two?

I'm not sure I understand the question, but yes, I claim we can get correct type indices at the point of the writeRecord call. We can do it today when building type info streams in memory, and we can do it in the future by looking the type up in the PDB on-disk type hash table.

Finally, one minor issue regarding debuggablity and testing, are we fine to get ".debug$T" section printed in assembly mode like this, instead of have each "Type record data" string split and explained by field?

I'd like to improve on this by doing the following, as mentioned previously: "... emit each record as a sequence of 32-bit hex integers preceded by a big block comment generated by the same type dumper that llvm-readobj and llvm-pdbdump use."

[aaboud]

Most of the feature in this revision was already committed in a way or another into LLVM.

include/llvm/DebugInfo/CodeView/TypeIndex.h

static TypeIndex WideCharacter() {
     return TypeIndex(SimpleTypeKind::WideCharacter);
   }
   static TypeIndex Int16Short() {
     return TypeIndex(SimpleTypeKind::Int16Short);
   }
   static TypeIndex UInt16Short() {
     return TypeIndex(SimpleTypeKind::UInt16Short);
   }
+  static TypeIndex Int16() { return TypeIndex(SimpleTypeKind::Int16); }
+  static TypeIndex UInt16() { return TypeIndex(SimpleTypeKind::UInt16); }
   static TypeIndex Int32() { return TypeIndex(SimpleTypeKind::Int32); }
   static TypeIndex UInt32() { return TypeIndex(SimpleTypeKind::UInt32); }
   static TypeIndex Int32Long() { return TypeIndex(SimpleTypeKind::Int32Long); }
   static TypeIndex UInt32Long() {
     return TypeIndex(SimpleTypeKind::UInt32Long);
   }
   static TypeIndex Int64() { return TypeIndex(SimpleTypeKind::Int64); }
   static TypeIndex UInt64() { return TypeIndex(SimpleTypeKind::UInt64); }
   static TypeIndex Int64Quad() { return TypeIndex(SimpleTypeKind::Int64Quad); }
   static TypeIndex UInt64Quad() {
     return TypeIndex(SimpleTypeKind::UInt64Quad);
   }
 
   static TypeIndex Float32() { return TypeIndex(SimpleTypeKind::Float32); }
+  static TypeIndex Float48() { return TypeIndex(SimpleTypeKind::Float48); }
   static TypeIndex Float64() { return TypeIndex(SimpleTypeKind::Float64); }
+  static TypeIndex Float80() { return TypeIndex(SimpleTypeKind::Float80); }
+  static TypeIndex Float128() { return TypeIndex(SimpleTypeKind::Float128); }
+
+  static TypeIndex Complex32() { return TypeIndex(SimpleTypeKind::Complex32); }
+  static TypeIndex Complex64() { return TypeIndex(SimpleTypeKind::Complex64); }
+  static TypeIndex Complex80() { return TypeIndex(SimpleTypeKind::Complex80); }
+  static TypeIndex Complex128() { return TypeIndex(SimpleTypeKind::Complex128); }
+
+  static TypeIndex Boolean8() { return TypeIndex(SimpleTypeKind::Boolean8); }
+  static TypeIndex Boolean16() { return TypeIndex(SimpleTypeKind::Boolean16); }
+  static TypeIndex Boolean32() { return TypeIndex(SimpleTypeKind::Boolean32); }
+  static TypeIndex Boolean64() { return TypeIndex(SimpleTypeKind::Boolean64); }
 
 private:
   support::ulittle32_t Index;
 };
 
 inline bool operator==(const TypeIndex &A, const TypeIndex &B) {
   return A.getIndex() == B.getIndex();
 }

include/llvm/DebugInfo/CodeView/TypeRecord.h

public:
   }
 
   TypeIndex getParentScope() const { return ParentScope; }
 
   TypeIndex getFunctionType() const { return FunctionType; }
 
   StringRef getName() const { return Name; }
 
+  static uint32_t getLayoutSize() { return 2 + sizeof(Layout); }
+
 private:
   struct Layout {
     TypeIndex ParentScope;
     TypeIndex FunctionType;
     // Name: The null-terminated name follows.
   };
 
   TypeIndex ParentScope;

lib/CodeGen/AsmPrinter/CMakeLists.txt

add_llvm_library(LLVMAsmPrinter
   DwarfFile.cpp
   DwarfStringPool.cpp
   DwarfUnit.cpp
   EHStreamer.cpp
   ErlangGCPrinter.cpp
   OcamlGCPrinter.cpp
   WinException.cpp
   CodeViewDebug.cpp
+  CodeViewType.cpp
   )
 
 add_dependencies(LLVMAsmPrinter intrinsics_gen)

lib/CodeGen/AsmPrinter/CodeViewDebug.h

 //===-- llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h ----*- C++ -*--===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains support for writing Microsoft CodeView debug info.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H
 #define LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWDEBUG_H
 
+#include "CodeViewType.h"
 #include "DebugHandlerBase.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/DebugInfo/CodeView/TypeIndex.h"
 #include "llvm/IR/DebugInfo.h"
class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
 
   static LocalVarDefRange createDefRangeMem(uint16_t CVRegister, int Offset);
   static LocalVarDefRange createDefRangeReg(uint16_t CVRegister);
 
   /// Similar to DbgVariable in DwarfDebug, but not dwarf-specific.
   struct LocalVariable {
     const DILocalVariable *DIVar = nullptr;
     SmallVector<LocalVarDefRange, 1> DefRanges;
+    const CodeViewType *CVType = nullptr;
   };
 
   struct InlineSite {
     SmallVector<LocalVariable, 1> InlinedLocals;
     SmallVector<const DILocation *, 1> ChildSites;
     const DISubprogram *Inlinee = nullptr;
     unsigned SiteFuncId = 0;
   };
 
   // For each function, store a vector of labels to its instructions, as well as
   // to the end of the function.
   struct FunctionInfo {
     /// Map from inlined call site to inlined instructions and child inlined
     /// call sites. Listed in program order.
     std::unordered_map<const DILocation *, InlineSite> InlineSites;
 
     /// Ordered list of top-level inlined call sites.
     SmallVector<const DILocation *, 1> ChildSites;
 
     SmallVector<LocalVariable, 1> Locals;
 
+    // Function type.
+    CodeViewType *FnType = nullptr;
+
     DebugLoc LastLoc;
     const MCSymbol *Begin = nullptr;
     const MCSymbol *End = nullptr;
     unsigned FuncId = 0;
     unsigned LastFileId = 0;
     bool HaveLineInfo = false;
   };
   FunctionInfo *CurFn;
 
+  // All types in the order they should be emitted.
+  typedef std::vector<CodeViewType *> CodeViewTypeTable;
+  CodeViewTypeTable TypeTable;
+  DenseMap<const DIType*, CodeViewType *> TypeMap;
+
+  // CodeView void type created lazily, once per module.
+  CodeViewType *VoidType = nullptr;
+
   /// The next available function index for use with our .cv_* directives. Not
   /// to be confused with type indices for LF_FUNC_ID records.
   unsigned NextFuncId = 0;
 
-  /// The next available type index.
-  unsigned NextTypeIndex = llvm::codeview::TypeIndex::FirstNonSimpleIndex;
-
-  /// Get the next type index and reserve it. Can be used to reserve more than
-  /// one type index.
-  unsigned getNextTypeIndex(unsigned NumRecords = 1) {
-    unsigned Result = NextTypeIndex;
-    NextTypeIndex += NumRecords;
-    return Result;
-  }
-
   InlineSite &getInlineSite(const DILocation *InlinedAt,
                             const DISubprogram *Inlinee);
 
   static void collectInlineSiteChildren(SmallVectorImpl<unsigned> &Children,
                                         const FunctionInfo &FI,
                                         const InlineSite &Site);
 
   /// Remember some debug info about each function. Keep it in a stable order to
   /// emit at the end of the TU.
   MapVector<const Function *, FunctionInfo> FnDebugInfo;
 
   /// Map from DIFile to .cv_file id.
   DenseMap<const DIFile *, unsigned> FileIdMap;
 
   /// Map from subprogram to index in InlinedSubprograms.
   DenseMap<const DISubprogram *, size_t> SubprogramIndices;
 
   /// All inlined subprograms in the order they should be emitted.
-  SmallVector<const DISubprogram *, 4> InlinedSubprograms;
-
-  /// The first type index that refers to an LF_FUNC_ID record. We have one
-  /// record per inlined subprogram.
-  /// FIXME: Keep in sync with emitTypeInformation until we buffer type records
-  /// on the side as we go. Once we buffer type records, we can allocate type
-  /// indices on demand without interleaving our assembly output.
-  unsigned FuncIdTypeIndexStart = NextTypeIndex + 2;
+  MapVector<const DISubprogram *, const CodeViewType *> InlinedSubprograms;
 
   typedef std::map<const DIFile *, std::string> FileToFilepathMapTy;
   FileToFilepathMapTy FileToFilepathMap;
   StringRef getFullFilepath(const DIFile *S);
 
   unsigned maybeRecordFile(const DIFile *F);
 
   void maybeRecordLocation(DebugLoc DL, const MachineFunction *MF);
 
   void clear() {
     assert(CurFn == nullptr);
     FileIdMap.clear();
     FnDebugInfo.clear();
     FileToFilepathMap.clear();
+    for (auto T : TypeTable) {
+      delete T;
+    }
+    TypeTable.clear();
+    TypeMap.clear();
+    VoidType = nullptr;
+  }
+
+  // Helper lowering functions.
+  void appendType(CodeViewType* CVType);
+  void mapLLVMTypeToCodeViewType(const DIType *Type, CodeViewType *CVType);
+  CodeViewType *getMappedCodeViewType(const DIType *Type);
+  CodeViewType *getVoidType();
+  // Lower LLVM type to CodeViewType functions.
+  CodeViewType *lowerType(const DIType *Type);
+  CodeViewTypeArgumentList *lowerTypeSubroutineArgumentList(
+      DITypeRefArray Elements, uint16_t FirstArgIndex);
+  CodeViewType *lowerTypeBasic(const DIBasicType *Type);
+  CodeViewType *lowerTypeSubroutine(const DISubroutineType *Type);
+  CodeViewType *lowerSubprogramType(const DISubprogram *SP);
+  CodeViewType *lowerSubprogramId(const DISubprogram *SP,
+                                  const Function *GV = nullptr);
+
+  void layout();
+
+  // Helper emit functions.
+  void emitInt8(int Value) {
+    OS.EmitIntValue(Value, 1);
+  }
+
+  void emitInt16(int Value) {
+    OS.EmitIntValue(Value, 2);
+  }
+
+  void emitInt32(int Value) {
+    OS.EmitIntValue(Value, 4);
   }
 
+  void emitString(StringRef S);
+
+  void emitBytes(const char *data, size_t size) {
+    OS.EmitBytes(StringRef(data, size));
+  }
+
+  void emitFill(size_t size, const uint8_t byte) {
+    OS.EmitFill(size, byte);
+  }
+
+  void addComment(StringRef comment) {
+    OS.AddComment(comment);
+  }
+
+  void emitLabel(MCSymbol *symbol) {
+    OS.EmitLabel(symbol);
+  }
+
+  void emitValue(const MCExpr *value, unsigned int sizeInBytes) {
+    OS.EmitValue(value, sizeInBytes);
+  }
+
+  void emitPadding(unsigned int Count);
+
+  // Routines for emiting the .debug$T section.
   void emitTypeInformation();
+  void emitType(const CodeViewType *CVType);
+  void emitTypeFunctionID(const CodeViewTypeFunctionID *CVType);
+  void emitTypeProcedure(const CodeViewTypeProcedure *CVType);
+  void emitTypeArgumentList(const CodeViewTypeArgumentList *CVType);
 
+  // Routines for emiting the .debug$S section.
   void emitInlineeFuncIdsAndLines();
 
   void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI);
 
   void emitInlinedCallSite(const FunctionInfo &FI, const DILocation *InlinedAt,
                            const InlineSite &Site);
 
   typedef DbgValueHistoryMap::InlinedVariable InlinedVariable;
 
   void collectVariableInfo(const DISubprogram *SP);
 
   void collectVariableInfoFromMMITable(DenseSet<InlinedVariable> &Processed);
 
   /// Records information about a local variable in the appropriate scope. In
   /// particular, locals from inlined code live inside the inlining site.
   void recordLocalVariable(LocalVariable &&Var, const DILocation *Loc);
 
   void emitLocalVariable(const LocalVariable &Var);
 
+  /// Find the MDNode for the given reference.
+  template <typename T> static  T *resolve(TypedDINodeRef<T> Ref) {
+    return Ref.resolve();
+  }
 public:
   CodeViewDebug(AsmPrinter *Asm);
 
   void setSymbolSize(const llvm::MCSymbol *, uint64_t) override {}
 
   /// \brief Emit the COFF section that holds the line table information.
   void endModule() override;
 

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

CodeViewDebug::getInlineSite(const DILocation *InlinedAt,
   auto SiteInsertion = CurFn->InlineSites.insert({InlinedAt, InlineSite()});
   InlineSite *Site = &SiteInsertion.first->second;
   if (SiteInsertion.second) {
     Site->SiteFuncId = NextFuncId++;
     Site->Inlinee = Inlinee;
     auto InlineeInsertion =
         SubprogramIndices.insert({Inlinee, InlinedSubprograms.size()});
     if (InlineeInsertion.second)
-      InlinedSubprograms.push_back(Inlinee);
+      InlinedSubprograms.insert(
+          std::make_pair(Inlinee, lowerSubprogramId(Inlinee)));
   }
   return *Site;
 }
 
 void CodeViewDebug::recordLocalVariable(LocalVariable &&Var,
                                         const DILocation *InlinedAt) {
+  Var.CVType = lowerType(resolve(Var.DIVar->getType()));
   if (InlinedAt) {
     // This variable was inlined. Associate it with the InlineSite.
     const DISubprogram *Inlinee = Var.DIVar->getScope()->getSubprogram();
     InlineSite &Site = getInlineSite(InlinedAt, Inlinee);
     Site.InlinedLocals.emplace_back(Var);
   } else {
     // This variable goes in the main ProcSym.
     CurFn->Locals.emplace_back(Var);
OS.EmitCVLocDirective(FuncId, FileId, DL.getLine(), DL.getCol(),
                         /*PrologueEnd=*/false,
                         /*IsStmt=*/false, DL->getFilename());
 }
 
 void CodeViewDebug::endModule() {
   if (FnDebugInfo.empty())
     return;
 
+  layout();
   emitTypeInformation();
 
   // FIXME: For functions that are comdat, we should emit separate .debug$S
   // sections that are comdat associative with the main function instead of
   // having one big .debug$S section.
   assert(Asm != nullptr);
   OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugSymbolsSection());
   OS.AddComment("Debug section magic");
void CodeViewDebug::endModule() {
 
   // This subsection holds the string table.
   OS.AddComment("String table");
   OS.EmitCVStringTableDirective();
 
   clear();
 }
 
-static void emitNullTerminatedSymbolName(MCStreamer &OS, StringRef S) {
-  // Microsoft's linker seems to have trouble with symbol names longer than
-  // 0xffd8 bytes.
-  S = S.substr(0, 0xffd8);
-  SmallString<32> NullTerminatedString(S);
-  NullTerminatedString.push_back('\0');
-  OS.EmitBytes(NullTerminatedString);
-}
-
 void CodeViewDebug::emitTypeInformation() {
   // Do nothing if we have no debug info or no inlined subprograms.  The types
   // we currently emit exist only to support inlined call site info.
   NamedMDNode *CU_Nodes =
       MMI->getModule()->getNamedMetadata("llvm.dbg.cu");
   if (!CU_Nodes)
     return;
-  if (InlinedSubprograms.empty())
+
+  if (TypeTable.empty())
     return;
 
   // Start the .debug$T section with 0x4.
   OS.SwitchSection(Asm->getObjFileLowering().getCOFFDebugTypesSection());
   OS.AddComment("Debug section magic");
   OS.EmitIntValue(COFF::DEBUG_SECTION_MAGIC, 4);
 
-  // This type info currently only holds function ids for use with inline call
-  // frame info. All functions are assigned a simple 'void ()' type. Emit that
-  // type here.
-  unsigned ArgListIndex = getNextTypeIndex();
-  OS.AddComment("Type record length");
-  OS.EmitIntValue(ArgListRecord::getLayoutSize(), 2);
-  OS.AddComment("Leaf type: LF_ARGLIST");
-  OS.EmitIntValue(LF_ARGLIST, 2);
-  OS.AddComment("Number of arguments");
-  OS.EmitIntValue(0, 4);
 
-  unsigned VoidFnTyIdx = getNextTypeIndex();
-  OS.AddComment("Type record length");
-  OS.EmitIntValue(ProcedureRecord::getLayoutSize(), 2);
-  OS.AddComment("Leaf type: LF_PROCEDURE");
-  OS.EmitIntValue(LF_PROCEDURE, 2);
-  OS.AddComment("Return type index");
-  OS.EmitIntValue(TypeIndex::Void().getIndex(), 4);
-  OS.AddComment("Calling convention");
-  OS.EmitIntValue(char(CallingConvention::NearC), 1);
-  OS.AddComment("Function options");
-  OS.EmitIntValue(char(FunctionOptions::None), 1);
-  OS.AddComment("# of parameters");
-  OS.EmitIntValue(0, 2);
-  OS.AddComment("Argument list type index");
-  OS.EmitIntValue(ArgListIndex, 4);
-
-  // Emit LF_FUNC_ID records for all inlined subprograms to the type stream.
-  // Allocate one type index for each func id.
-  unsigned NextIdx = getNextTypeIndex(InlinedSubprograms.size());
-  (void)NextIdx;
-  assert(NextIdx == FuncIdTypeIndexStart && "func id type indices broken");
-  for (auto *SP : InlinedSubprograms) {
-    StringRef DisplayName = SP->getDisplayName();
-    OS.AddComment("Type record length");
-    MCSymbol *FuncBegin = MMI->getContext().createTempSymbol(),
-             *FuncEnd = MMI->getContext().createTempSymbol();
-    OS.emitAbsoluteSymbolDiff(FuncEnd, FuncBegin, 2);
-    OS.EmitLabel(FuncBegin);
-    OS.AddComment("Leaf type: LF_FUNC_ID");
-    OS.EmitIntValue(LF_FUNC_ID, 2);
-
-    OS.AddComment("Scope type index");
-    OS.EmitIntValue(0, 4);
-    OS.AddComment("Function type");
-    OS.EmitIntValue(VoidFnTyIdx, 4);
-    {
-      OS.AddComment("Function name");
-      emitNullTerminatedSymbolName(OS, DisplayName);
-    }
-    OS.EmitLabel(FuncEnd);
+  for (const auto *CVType : TypeTable) {
+    emitType(CVType);
   }
 }
 
 void CodeViewDebug::emitInlineeFuncIdsAndLines() {
   if (InlinedSubprograms.empty())
     return;
 
   MCSymbol *InlineBegin = MMI->getContext().createTempSymbol(),
            *InlineEnd = MMI->getContext().createTempSymbol();
 
   OS.AddComment("Inlinee lines subsection");
   OS.EmitIntValue(unsigned(ModuleSubstreamKind::InlineeLines), 4);
   OS.AddComment("Subsection size");
   OS.emitAbsoluteSymbolDiff(InlineEnd, InlineBegin, 4);
   OS.EmitLabel(InlineBegin);
 
   // We don't provide any extra file info.
   // FIXME: Find out if debuggers use this info.
   OS.AddComment("Inlinee lines signature");
   OS.EmitIntValue(unsigned(InlineeLinesSignature::Normal), 4);
 
-  unsigned InlineeIndex = FuncIdTypeIndexStart;
-  for (const DISubprogram *SP : InlinedSubprograms) {
+  for (const auto Itr : InlinedSubprograms) {
+    const DISubprogram *SP = Itr.first;
+    unsigned InlineeIndex = CodeViewType::getIndexOrNone(Itr.second);
     OS.AddBlankLine();
     unsigned FileId = maybeRecordFile(SP->getFile());
     OS.AddComment("Inlined function " + SP->getDisplayName() + " starts at " +
                   SP->getFilename() + Twine(':') + Twine(SP->getLine()));
     OS.AddBlankLine();
     // The filechecksum table uses 8 byte entries for now, and file ids start at
     // 1.
     unsigned FileOffset = (FileId - 1) * 8;
     OS.AddComment("Type index of inlined function");
     OS.EmitIntValue(InlineeIndex, 4);
     OS.AddComment("Offset into filechecksum table");
     OS.EmitIntValue(FileOffset, 4);
     OS.AddComment("Starting line number");
     OS.EmitIntValue(SP->getLine(), 4);
-
-    // The next inlined subprogram has the next function id.
-    InlineeIndex++;
   }
 
   OS.EmitLabel(InlineEnd);
 }
 
 void CodeViewDebug::collectInlineSiteChildren(
     SmallVectorImpl<unsigned> &Children, const FunctionInfo &FI,
     const InlineSite &Site) {
   for (const DILocation *ChildSiteLoc : Site.ChildSites) {
     auto I = FI.InlineSites.find(ChildSiteLoc);
     const InlineSite &ChildSite = I->second;
     Children.push_back(ChildSite.SiteFuncId);
     collectInlineSiteChildren(Children, FI, ChildSite);
   }
 }
 
 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,
                                         const DILocation *InlinedAt,
                                         const InlineSite &Site) {
   MCSymbol *InlineBegin = MMI->getContext().createTempSymbol(),
            *InlineEnd = MMI->getContext().createTempSymbol();
 
-  assert(SubprogramIndices.count(Site.Inlinee));
-  unsigned InlineeIdx = FuncIdTypeIndexStart + SubprogramIndices[Site.Inlinee];
+  unsigned InlineeIndex =
+      CodeViewType::getIndexOrNone(InlinedSubprograms[Site.Inlinee]);
 
   // SymbolRecord
   OS.AddComment("Record length");
   OS.emitAbsoluteSymbolDiff(InlineEnd, InlineBegin, 2);   // RecordLength
   OS.EmitLabel(InlineBegin);
   OS.AddComment("Record kind: S_INLINESITE");
   OS.EmitIntValue(SymbolKind::S_INLINESITE, 2); // RecordKind
 
   OS.AddComment("PtrParent");
   OS.EmitIntValue(0, 4);
   OS.AddComment("PtrEnd");
   OS.EmitIntValue(0, 4);
   OS.AddComment("Inlinee type index");
-  OS.EmitIntValue(InlineeIdx, 4);
+  OS.EmitIntValue(InlineeIndex, 4);
 
   unsigned FileId = maybeRecordFile(Site.Inlinee->getFile());
   unsigned StartLineNum = Site.Inlinee->getLine();
   SmallVector<unsigned, 3> SecondaryFuncIds;
   collectInlineSiteChildren(SecondaryFuncIds, FI, Site);
 
   OS.EmitCVInlineLinetableDirective(Site.SiteFuncId, FileId, StartLineNum,
                                     FI.Begin, FI.End, SecondaryFuncIds);
OS.EmitLabel(SymbolsBegin);
     // code is located and what's its size:
     OS.AddComment("Code size");
     OS.emitAbsoluteSymbolDiff(FI.End, Fn, 4);
     OS.AddComment("Offset after prologue");
     OS.EmitIntValue(0, 4);
     OS.AddComment("Offset before epilogue");
     OS.EmitIntValue(0, 4);
     OS.AddComment("Function type index");
-    OS.EmitIntValue(0, 4);
+    OS.EmitIntValue(CodeViewType::getIndexOrNone(FI.FnType), 4);
     OS.AddComment("Function section relative address");
     OS.EmitCOFFSecRel32(Fn);
     OS.AddComment("Function section index");
     OS.EmitCOFFSectionIndex(Fn);
     OS.AddComment("Flags");
     OS.EmitIntValue(0, 1);
     // Emit the function display name as a null-terminated string.
     OS.AddComment("Function name");
     // Truncate the name so we won't overflow the record length field.
-    emitNullTerminatedSymbolName(OS, FuncName);
+    emitString(FuncName);
     OS.EmitLabel(ProcRecordEnd);
 
     for (const LocalVariable &Var : FI.Locals)
       emitLocalVariable(Var);
 
     // Emit inlined call site information. Only emit functions inlined directly
     // into the parent function. We'll emit the other sites recursively as part
     // of their parent inline site.
void CodeViewDebug::emitLocalVariable(const LocalVariable &Var) {
 
   LocalSymFlags Flags = LocalSymFlags::None;
   if (Var.DIVar->isParameter())
     Flags |= LocalSymFlags::IsParameter;
   if (Var.DefRanges.empty())
     Flags |= LocalSymFlags::IsOptimizedOut;
 
   OS.AddComment("TypeIndex");
-  OS.EmitIntValue(TypeIndex::Int32().getIndex(), 4);
+  OS.EmitIntValue(CodeViewType::getIndexOrNone(Var.CVType), 4);
   OS.AddComment("Flags");
   OS.EmitIntValue(static_cast<uint16_t>(Flags), 2);
   // Truncate the name so we won't overflow the record length field.
-  emitNullTerminatedSymbolName(OS, Var.DIVar->getName());
+  emitString(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
   // should be big enough to hold all forms without memory allocation.
   SmallString<20> BytePrefix;
   for (const LocalVarDefRange &DefRange : Var.DefRanges) {
     BytePrefix.clear();
void CodeViewDebug::endFunction(const MachineFunction *MF) {
 
   // Don't emit anything if we don't have any line tables.
   if (!CurFn->HaveLineInfo) {
     FnDebugInfo.erase(GV);
     CurFn = nullptr;
     return;
   }
 
+  CurFn->FnType = lowerSubprogramId(GV->getSubprogram(), GV);
+
   CurFn->End = Asm->getFunctionEnd();
 
   CurFn = nullptr;
 }
 
 void CodeViewDebug::beginInstruction(const MachineInstr *MI) {
   DebugHandlerBase::beginInstruction(MI);
 
   // Ignore DBG_VALUE locations and function prologue.
   if (!Asm || MI->isDebugValue() || MI->getFlag(MachineInstr::FrameSetup))
     return;
   DebugLoc DL = MI->getDebugLoc();
   if (DL == PrevInstLoc || !DL)
     return;
   maybeRecordLocation(DL, Asm->MF);
 }
+
+
+//===----------------------------------------------------------------------===//
+// CodeViewDebug type function implementation
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+// INDEX_BASIC_TYPE_MAPPINGS
+//
+// Maps LLVM basic types to TypeIndex encodings.
+//
+//===----------------------------------------------------------------------===//
+
+#define INDEX_BASIC_TYPE_MAPPINGS                               \
+  X(dwarf::DW_ATE_address,          4,      Void)               \
+  X(dwarf::DW_ATE_boolean,          1,      Boolean8)           \
+  X(dwarf::DW_ATE_boolean,          2,      Boolean16)          \
+  X(dwarf::DW_ATE_boolean,          4,      Boolean32)          \
+  X(dwarf::DW_ATE_boolean,          8,      Boolean64)          \
+  X(dwarf::DW_ATE_complex_float,    4,      Complex32)          \
+  X(dwarf::DW_ATE_complex_float,    8,      Complex64)          \
+  X(dwarf::DW_ATE_complex_float,   10,      Complex80)          \
+  X(dwarf::DW_ATE_complex_float,   16,      Complex128)         \
+  X(dwarf::DW_ATE_float,            4,      Float32)            \
+  X(dwarf::DW_ATE_float,            6,      Float48)            \
+  X(dwarf::DW_ATE_float,            8,      Float64)            \
+  X(dwarf::DW_ATE_float,           10,      Float80)            \
+  X(dwarf::DW_ATE_float,           16,      Float128)           \
+  X(dwarf::DW_ATE_decimal_float,    4,      Float32)            \
+  X(dwarf::DW_ATE_decimal_float,    6,      Float48)            \
+  X(dwarf::DW_ATE_decimal_float,    8,      Float64)            \
+  X(dwarf::DW_ATE_decimal_float,   10,      Float80)            \
+  X(dwarf::DW_ATE_decimal_float,   16,      Float128)           \
+  X(dwarf::DW_ATE_signed,           1,      SignedCharacter)    \
+  X(dwarf::DW_ATE_signed,           2,      Int16Short)         \
+  X(dwarf::DW_ATE_signed,           4,      Int32)              \
+  X(dwarf::DW_ATE_signed,           8,      Int64)              \
+  X(dwarf::DW_ATE_signed_char,      1,      SignedCharacter)    \
+  X(dwarf::DW_ATE_unsigned,         1,      UnsignedCharacter)  \
+  X(dwarf::DW_ATE_unsigned,         2,      UInt16)             \
+  X(dwarf::DW_ATE_unsigned,         4,      UInt32)             \
+  X(dwarf::DW_ATE_unsigned,         8,      UInt64)             \
+  X(dwarf::DW_ATE_unsigned_char,    1,      UnsignedCharacter)
+
+//===----------------------------------------------------------------------===//
+// toBasicTypeIndex(Type)
+//
+// Returns an CodeView TypeIndex encoding for the specified LLVM basic type.
+//
+//===----------------------------------------------------------------------===//
+
+static TypeIndex toBasicTypeIndex(const DIBasicType *Type) {
+  TypeIndex Index;
+  dwarf::TypeKind Kind;
+  uint32_t ByteSize;
+
+  Kind = static_cast<dwarf::TypeKind>(Type->getEncoding());
+  ByteSize = Type->getSizeInBits() >> 3;
+
+#define X(KIND, BYTESIZE, INDEX_FN)                                            \
+  if (Kind == KIND && ByteSize == BYTESIZE) {                                  \
+    Index = TypeIndex::INDEX_FN();                                             \
+    } else
+  INDEX_BASIC_TYPE_MAPPINGS
+#undef X
+  { Index = TypeIndex(); }
+
+  // Map "long INT" types to "LONG" types.
+  //
+  if (Type->getName().count("long")) {
+    switch (Index.getSimpleKind()) {
+    case (SimpleTypeKind::Int32) : Index = TypeIndex::Int32Long(); break;
+    case (SimpleTypeKind::UInt32) : Index = TypeIndex::UInt32Long(); break;
+    default:
+      // For everything else leave the index unchanged.
+      break;
+    }
+  }
+
+  return Index;
+}
+
+//===----------------------------------------------------------------------===//
+// getMappedCodeViewType(Type)
+//
+// If the specified LLVM type has already been mapped to an existing CodeView
+// type then the CodeView type is returned.  Otherwise nullptr is returned.
+//
+//===----------------------------------------------------------------------===//
+CodeViewType *CodeViewDebug::getMappedCodeViewType(const DIType *Type) {
+  auto itr = TypeMap.find(Type);
+  if (itr == TypeMap.end()) {
+    return nullptr;
+  }
+
+  return itr->second;  /* second is the CodeView type */
+}
+
+//===----------------------------------------------------------------------===//
+// appendType(type)
+//
+// Appends the specified type to the end of the type table which will be
+// emitted to the .debug$T section.
+//
+//===----------------------------------------------------------------------===//
+
+void CodeViewDebug::appendType(CodeViewType* CVType) {
+  TypeTable.push_back(CVType);
+}
+
+//===----------------------------------------------------------------------===//
+// mapLLVMTypeToCodeViewType(Type, CVType)
+//
+// Map an LLVM type to an CodeView type.  Future references to the LLVM type
+// will reuse the existing CodeView type from the map.
+//
+//===----------------------------------------------------------------------===//
+
+void CodeViewDebug::mapLLVMTypeToCodeViewType(const DIType  *Type,
+                                              CodeViewType  *CVType) {
+  TypeMap.insert(std::make_pair(Type, CVType));
+}
+
+//===----------------------------------------------------------------------===//
+// getVoidType()
+//
+// Return CodeView void type, create one if it was not created yet.
+//
+//===----------------------------------------------------------------------===//
+CodeViewType *CodeViewDebug::getVoidType() {
+  if (VoidType == nullptr) {
+    CodeViewTypeBasic *CVType;
+
+    CVType = CodeViewTypeBasic::create();
+    CVType->setTypeIndex(TypeIndex::Void());
+    CVType->setSizeInBits(0);
+
+    appendType(CVType);
+    VoidType = CVType;
+  }
+
+  return VoidType;
+}
+
+//===----------------------------------------------------------------------===//
+// lowerType(Type)
+//
+// Lowers the specified LLVM type into one or more CodeView type entries.
+//
+//===----------------------------------------------------------------------===//
+
+CodeViewType *CodeViewDebug::lowerType(const DIType *Type) {
+  CodeViewType *CVType;
+  unsigned int Tag;
+
+  if (Type == nullptr) {
+    return getVoidType();
+  }
+
+  if (CVType = getMappedCodeViewType(Type)) {
+    return CVType;
+  }
+
+  Tag = Type->getTag();
+  switch (Tag) {
+  case dwarf::DW_TAG_base_type:
+    CVType = lowerTypeBasic(cast<DIBasicType>(Type)); break;
+  case dwarf::DW_TAG_subroutine_type:
+    CVType = lowerTypeSubroutine(cast<DISubroutineType>(Type)); break;
+  default:
+    // TODO: Enable this assert once all types are implemented
+    //assert(Tag != Tag && "Unhandled type Tag!");
+    CVType = nullptr;
+    break;
+  }
+
+  return CVType;
+}
+
+//===----------------------------------------------------------------------===//
+// lowerTypeBasic(Type)
+//
+// Lowers the specified LLVM type, which must be a basic type, to a CodeView
+// intermediate representation.
+//
+//===----------------------------------------------------------------------===//
+
+CodeViewType *CodeViewDebug::lowerTypeBasic(const DIBasicType *Type) {
+  const uint32_t SizeInBits = Type->getSizeInBits();
+  const TypeIndex Index = toBasicTypeIndex(Type);
+  CodeViewTypeBasic *CVType;
+
+  CVType = CodeViewTypeBasic::create();
+  CVType->setTypeIndex(Index);
+  CVType->setSizeInBits(SizeInBits);
+
+  appendType(CVType);
+  mapLLVMTypeToCodeViewType(Type, CVType);
+
+  return CVType;
+}
+
+//===----------------------------------------------------------------------===//
+// lowerTypeSubroutineArgumentList(Elements, FirstArgIndex)
+//
+// Lowers all of the argument types in the specified elements array and
+// creates a new argument list type entry containing each of the lowered
+// argument types.
+//
+//===----------------------------------------------------------------------===//
+
+CodeViewTypeArgumentList *CodeViewDebug::lowerTypeSubroutineArgumentList(
+    DITypeRefArray Elements, uint16_t FirstArgIndex) {
+  CodeViewTypeArgumentList *ArgList;
+  DIType                   *ArgType;
+
+  // Create the argument list type entry.
+  //
+  ArgList = CodeViewTypeArgumentList::create();
+
+  // Walk each of the elements, starting with the first argument index, lower
+  // the argument type and append it's index to the argument list.
+  //
+  for (unsigned i = FirstArgIndex, size = Elements.size(); i < size; ++i) {
+    ArgType = resolve(Elements[i]);
+    if (ArgType) {
+      ArgList->append(lowerType(ArgType));
+    }
+    else {
+      assert(i == size - 1); // A variadic argument must be the last argument.
+      ArgList->append(nullptr); // FIXME: handle variadic argument
+    }
+  }
+
+  appendType(ArgList);
+
+  return ArgList;
+}
+
+//===----------------------------------------------------------------------===//
+// lowerTypeSubroutine(Type)
+//
+// Lower the specified LLVM subroutine type to CodeView type entries.
+//
+//===----------------------------------------------------------------------===//
+
+CodeViewType *CodeViewDebug::lowerTypeSubroutine(const DISubroutineType *Type) {
+  CodeViewTypeProcedure    *CVType;
+  CodeViewTypeArgumentList *ArgListType;
+  CodeViewType             *ReturnType;
+  int                      CallingConvention;
+  uint16_t                 ParamCount;
+  DITypeRefArray           Arguments;
+
+  // Lower the return type.
+  //
+  // The return type is recorded in the argument list at index "0".  If the
+  // argument list is empty then the return type is void and there are no
+  // parameters.
+  //
+  Arguments = Type->getTypeArray();
+  ReturnType = lowerType(Arguments.size() ? resolve(Arguments[0]) : nullptr);
+
+  // Lower the argument list.
+  //
+  // The return type will be index "0", so the first argument is index "1".
+  //
+  ArgListType = lowerTypeSubroutineArgumentList(Arguments, 1);
+  ParamCount = ArgListType->getArgumentCount();
+
+  // Determine the calling convention this routine uses.
+  //
+  // FIXME: Current implementation uses only NearC calling convention.
+  CallingConvention = (int)CallingConvention::NearC;
+
+  // Create an TypeRecordKind::Procedure type entry.
+  //
+  CVType = CodeViewTypeProcedure::create();
+  CVType->setReturnType(ReturnType);
+  CVType->setArgumentList(ArgListType);
+  CVType->setParamCount(ParamCount);
+  CVType->setCallingConvention(CallingConvention);
+
+  appendType(CVType);
+  mapLLVMTypeToCodeViewType(Type, CVType);
+
+  return CVType;
+}
+
+//===----------------------------------------------------------------------===//
+// lowerSubprogramType(SP)
+//
+// Lowers the subroutine type of the specified subprogram.
+//
+//===----------------------------------------------------------------------===//
+
+CodeViewType *CodeViewDebug::lowerSubprogramType(const DISubprogram *SP) {
+  CodeViewType           *CVType;
+  const DISubroutineType *Type;
+  const DIType           *ClassType;
+
+  if (!SP)
+    return nullptr;
+
+  Type = SP->getType();
+  ClassType = dyn_cast<DIType>(resolve(SP->getScope()));
+
+  if (ClassType) {
+    // TODO: implement this case.
+    CVType = nullptr;
+  }
+  else {
+    CVType = lowerType(Type); // Indirectly calls lowerTypeSubroutine().
+  }
+
+  return CVType;
+}
+
+//===----------------------------------------------------------------------===//
+// lowerSubprogramId(SP, GV)
+//
+// Lowers the LLVM subprogram to CodeView ID entry.
+//
+//===----------------------------------------------------------------------===//
+
+CodeViewType *CodeViewDebug::lowerSubprogramId(const DISubprogram *SP,
+                                               const Function *GV) {
+
+  if (!SP)
+    return nullptr;
+
+  CodeViewType *CVType = lowerSubprogramType(SP);
+
+  StringRef FuncName = SP->getDisplayName();
+  // If our DISubprogram name is empty, use the mangled name.
+  if (FuncName.empty())
+    if (GV)
+      FuncName = GlobalValue::getRealLinkageName(GV->getName());
+    else
+      FuncName = SP->getName();
+
+  CodeViewTypeFunctionID *FuncIDType = CodeViewTypeFunctionID::create();
+  FuncIDType->setType(CVType);
+  FuncIDType->setParentScope(nullptr); // FIXME
+  FuncIDType->setParentClassType(nullptr); // FIXME
+  FuncIDType->setName(FuncName);
+  appendType(FuncIDType);
+
+  return FuncIDType;
+}
+
+void CodeViewDebug::layout() {
+  // Assign unique indexes to each type in the type table.
+  //
+  // When emitting the type table to an object file, we need to assign the type
+  // index to every type here.
+  //
+  uint16_t NextTypeIndex = llvm::codeview::TypeIndex::FirstNonSimpleIndex;
+  for (CodeViewType *CVType : TypeTable) {
+    switch (CVType->getTypeKind()) {
+    case CodeViewTypeKind::TypeBasic:
+      // Basic types are indexed when created and will not be emitted.
+      break;
+    default:
+      CVType->setTypeIndex(TypeIndex(NextTypeIndex++));
+      break;
+    }
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// emitString(Count)
+//===----------------------------------------------------------------------===//
+void CodeViewDebug::emitString(StringRef S) {
+  // Microsoft's linker seems to have trouble with symbol names longer than
+  // 0xffd8 bytes.
+  S = S.substr(0, 0xffd8);
+  SmallString<32> NullTerminatedString(S);
+  NullTerminatedString.push_back('\0');
+  OS.EmitBytes(NullTerminatedString);
+}
+
+static size_t paddingBytes(const size_t Size) {
+  const uint32_t Alignment = 4;
+  return (Alignment - (Size % Alignment)) % Alignment;
+}
+
+//===----------------------------------------------------------------------===//
+// emitPadding(Count)
+//===----------------------------------------------------------------------===//
+
+void CodeViewDebug::emitPadding(unsigned int Count) {
+  static const int PaddingArray[16] = {
+    LF_PAD0, LF_PAD1, LF_PAD2, LF_PAD3,
+    LF_PAD4, LF_PAD5, LF_PAD6, LF_PAD7,
+    LF_PAD8, LF_PAD9, LF_PAD10, LF_PAD11,
+    LF_PAD12, LF_PAD13, LF_PAD14, LF_PAD15 };
+
+  assert(Count < 16);
+
+  for (unsigned int I = Count; I > 0; --I) {
+    addComment("Padding");
+    emitInt8(PaddingArray[I]);
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// emitType(CVType)
+//===----------------------------------------------------------------------===//
+
+void CodeViewDebug::emitType(const CodeViewType *CVType) {
+  CodeViewTypeKind Kind;
+
+  Kind = CVType->getTypeKind();
+  switch (Kind) {
+  case CodeViewTypeKind::TypeBasic:
+    // Primitive Types Are Predefined And Not Emitted.
+    break;
+  case CodeViewTypeKind::TypeFunctionId:
+    emitTypeFunctionID(static_cast<const CodeViewTypeFunctionID *>(CVType));
+    break;
+  case CodeViewTypeKind::TypeProcedure:
+    emitTypeProcedure(static_cast<const CodeViewTypeProcedure *>(CVType));
+    break;
+  case CodeViewTypeKind::TypeArgumentList:
+    emitTypeArgumentList(static_cast<const CodeViewTypeArgumentList *>(CVType));
+    break;
+  default:
+    // TODO: Enable this assert once all types are implemented
+    //assert(Kind != Kind && invalid type kind);
+    break;
+  }
+}
+
+//===----------------------------------------------------------------------===//
+// emitTypeFunctionID(CVType)
+//===----------------------------------------------------------------------===//
+
+void CodeViewDebug::emitTypeFunctionID(const CodeViewTypeFunctionID *CVType) {
+  StringRef Name = CVType->getName();
+  const CodeViewType *FuncType = CVType->getType();
+  const CodeViewType *ClassType = CVType->getParentClassType();
+  const CodeViewType *ScopeType =
+    ClassType ? ClassType : CVType->getParentScope();
+  unsigned SymbolID = LF_FUNC_ID;
+  const size_t Length = 2 + FuncIdRecord::getLayoutSize() + Name.size() + 1;
+  const size_t Padding = paddingBytes(Length);
+
+  addComment("Type record length");
+  emitInt16(Length + Padding - 2);
+  addComment("Leaf type: LF_FUNC_ID");
+  emitInt16(SymbolID);
+  addComment("Parent scope type");
+  emitInt32(CodeViewType::getIndexOrNone(ScopeType));
+  addComment("Function type");
+  emitInt32(CodeViewType::getIndexOrNone(FuncType));
+  addComment("Function name");
+  emitString(Name);
+  emitPadding(Padding);
+}
+
+//===----------------------------------------------------------------------===//
+// emitTypeProcedure(CVType)
+//===----------------------------------------------------------------------===//
+
+void CodeViewDebug::emitTypeProcedure(const CodeViewTypeProcedure *CVType) {
+  const CodeViewType *ReturnType = CVType->getReturnType();
+  int CallingConvention = CVType->getCallingConvention();
+  uint16_t ParamCount = CVType->getParamCount();
+  const CodeViewType *ArgList = CVType->getArgumentList();
+  const size_t Length = 2 + ProcedureRecord::getLayoutSize();
+  const size_t Padding = paddingBytes(Length);
+
+  addComment("Type record length");
+  emitInt16(Length + Padding - 2);
+  addComment("Leaf type: LF_PROCEDURE");
+  emitInt16(LF_PROCEDURE);
+  addComment("Return Type");
+  emitInt32(CodeViewType::getIndexOrNone(ReturnType));
+  addComment("Calling Convention");
+  emitInt8(CallingConvention);
+  addComment("Reserved");
+  emitInt8(0);
+  addComment("Number of arguments");
+  emitInt16(ParamCount);
+  addComment("Argument List Type");
+  emitInt32(CodeViewType::getIndexOrNone(ArgList));
+  emitPadding(Padding);
+}
+
+//===----------------------------------------------------------------------===//
+// emitTypeArgumentList(CVType)
+//===----------------------------------------------------------------------===//
+
+void CodeViewDebug::emitTypeArgumentList(
+    const CodeViewTypeArgumentList *CVType) {
+  uint32_t ArgCount = CVType->getArgumentCount();
+  const auto *ArgList = CVType->getArgumentList();
+  const size_t Length = 2 + ArgListRecord::getLayoutSize() + (4 * ArgCount);
+  const size_t Padding = paddingBytes(Length);
+
+  addComment("Type record length");
+  emitInt16(Length + Padding - 2);
+  addComment("Leaf type: LF_ARGLIST");
+  emitInt16(LF_ARGLIST);
+  addComment("Number of arguments");
+  emitInt32(ArgCount);
+  for (const CodeViewType *ArgType : *ArgList) {
+    addComment("Argument Type");
+    emitInt32(CodeViewType::getIndexOrNone(ArgType));
+  }
+  emitPadding(Padding);
+}

lib/CodeGen/AsmPrinter/CodeViewType.h

+//===-- llvm/lib/CodeGen/AsmPrinter/CodeViewType.h ----*- C++ -*--===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains support for writing Microsoft CodeView debug type info.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWTYPE_H
+#define LLVM_LIB_CODEGEN_ASMPRINTER_CODEVIEWTYPE_H
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/DebugInfo/CodeView/TypeIndex.h"
+
+namespace llvm {
+
+//===----------------------------------------------------------------------===//
+// CodeViewTypeKind
+//===----------------------------------------------------------------------===//
+enum class CodeViewTypeKind : uint32_t {
+  TypeNone = 0,
+  TypeBasic = 1,
+  TypeFunctionId = 2,
+  TypeProcedure = 3,
+  TypeArgumentList = 4
+};
+
+//===----------------------------------------------------------------------===//
+// CodeViewType
+//===----------------------------------------------------------------------===//
+
+class CodeViewType {
+private:
+  CodeViewTypeKind Kind;
+  codeview::TypeIndex Index;
+  uint32_t SizeInBits;
+
+protected:
+  CodeViewType(CodeViewTypeKind Kind);
+
+public:
+  virtual ~CodeViewType();
+
+  CodeViewTypeKind getTypeKind() const;
+
+  codeview::TypeIndex getTypeIndex() const;
+  void setTypeIndex(const codeview::TypeIndex Index);
+
+  uint32_t getSizeInBits() const;
+  void setSizeInBits(uint32_t SizeInBits);
+
+  static unsigned getIndexOrNone(const CodeViewType * CVType);
+};
+
+//===----------------------------------------------------------------------===//
+// CodeViewTypeBasic
+//===----------------------------------------------------------------------===//
+
+class CodeViewTypeBasic : public CodeViewType {
+protected:
+  CodeViewTypeBasic();
+
+public:
+  ~CodeViewTypeBasic();
+
+  static CodeViewTypeBasic *create();
+};
+
+//===----------------------------------------------------------------------===//
+// CodeViewTypeFunctionID
+//===----------------------------------------------------------------------===//
+
+class CodeViewTypeFunctionID : public CodeViewType {
+private:
+  CodeViewType *CVType;
+  CodeViewType *ParentScope;
+  CodeViewType *ParentClassType;
+  std::string Name;
+
+protected:
+  CodeViewTypeFunctionID();
+
+public:
+  ~CodeViewTypeFunctionID();
+
+  static CodeViewTypeFunctionID *create();
+
+  CodeViewType *getType() const;
+  void setType(CodeViewType *Type);
+
+  CodeViewType *getParentScope() const;
+  void setParentScope(CodeViewType *Scope);
+
+  CodeViewType *getParentClassType() const;
+  void setParentClassType(CodeViewType *ClassType);
+
+  StringRef getName() const;
+  void setName(StringRef Name);
+};
+
+//===----------------------------------------------------------------------===//
+// CodeViewTypeProcedure
+//===----------------------------------------------------------------------===//
+
+class CodeViewTypeProcedure : public CodeViewType {
+private:
+  CodeViewType *ReturnType;
+  CodeViewType *ArgumentList;
+  int CallingConvention;
+  uint16_t ParamCount;
+
+protected:
+  CodeViewTypeProcedure();
+
+public:
+  ~CodeViewTypeProcedure();
+
+  static CodeViewTypeProcedure *create();
+
+  CodeViewType *getReturnType() const;
+  void setReturnType(CodeViewType *CVType);
+
+  int getCallingConvention() const;
+  void setCallingConvention(int CC);
+
+  uint16_t getParamCount() const;
+  void setParamCount(uint16_t Count);
+
+  CodeViewType *getArgumentList() const;
+  void setArgumentList(CodeViewType *ArgList);
+};
+
+//===----------------------------------------------------------------------===//
+// CodeViewTypeArgumentList
+//===----------------------------------------------------------------------===//
+
+class CodeViewTypeArgumentList : public CodeViewType {
+public:
+  typedef SmallVector<CodeViewType *, 4> ArgTypeList;
+
+private:
+  ArgTypeList ArgumentList;
+
+protected:
+  CodeViewTypeArgumentList();
+
+public:
+  ~CodeViewTypeArgumentList();
+
+  static CodeViewTypeArgumentList *create();
+
+  const ArgTypeList *getArgumentList() const;
+  ArgTypeList *getArgumentList();
+
+  uint32_t getArgumentCount() const;
+  void append(CodeViewType *Argument);
+};
+
+} // End of namespace llvm
+
+#endif

lib/CodeGen/AsmPrinter/CodeViewType.cpp

+//===-- llvm/lib/CodeGen/AsmPrinter/CodeViewType.cpp --*- C++ -*--===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains support for writing Microsoft CodeView debug type info.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CodeViewType.h"
+
+using namespace llvm;
+using namespace llvm::codeview;
+
+//===----------------------------------------------------------------------===//
+// CodeViewType
+//===----------------------------------------------------------------------===//
+
+CodeViewType::CodeViewType(CodeViewTypeKind K) : Kind(K) {}
+
+CodeViewType::~CodeViewType() {}
+
+CodeViewTypeKind CodeViewType::getTypeKind() const { return Kind; }
+
+TypeIndex CodeViewType::getTypeIndex() const { return Index; }
+
+void CodeViewType::setTypeIndex(const TypeIndex I) { Index = I; }
+
+uint32_t CodeViewType::getSizeInBits() const { return SizeInBits; }
+
+void CodeViewType::setSizeInBits(uint32_t Size) { SizeInBits = Size; }
+
+unsigned CodeViewType::getIndexOrNone(const CodeViewType * CVType) {
+  if (!CVType)
+    return (unsigned)SimpleTypeKind::None;
+  return CVType->getTypeIndex().getIndex();
+}
+
+//===----------------------------------------------------------------------===//
+// CodeViewTypeBasic
+//===----------------------------------------------------------------------===//
+
+CodeViewTypeBasic::CodeViewTypeBasic()
+    : CodeViewType(CodeViewTypeKind::TypeBasic) {}
+
+CodeViewTypeBasic::~CodeViewTypeBasic() {}
+
+CodeViewTypeBasic *CodeViewTypeBasic::create() {
+  return new CodeViewTypeBasic();
+}
+
+//===----------------------------------------------------------------------===//
+// CodeViewTypeFunctionID
+//===----------------------------------------------------------------------===//
+
+CodeViewTypeFunctionID::CodeViewTypeFunctionID()
+    : CodeViewType(CodeViewTypeKind::TypeFunctionId), CVType(nullptr),
+      ParentScope(nullptr) {}
+
+CodeViewTypeFunctionID::~CodeViewTypeFunctionID() {}
+
+CodeViewTypeFunctionID *CodeViewTypeFunctionID::create() {
+  return new CodeViewTypeFunctionID();
+}
+
+CodeViewType *CodeViewTypeFunctionID::getType() const { return CVType; }
+
+void CodeViewTypeFunctionID::setType(CodeViewType *Type) { CVType = Type; }
+
+CodeViewType *CodeViewTypeFunctionID::getParentScope() const { return ParentScope; }
+
+void CodeViewTypeFunctionID::setParentScope(CodeViewType *ScopeType) {
+  ParentScope = ScopeType;
+}
+
+CodeViewType *CodeViewTypeFunctionID::getParentClassType() const {
+  return ParentClassType;
+}
+
+void CodeViewTypeFunctionID::setParentClassType(CodeViewType *ClassType) {
+  ParentClassType = ClassType;
+}
+
+StringRef CodeViewTypeFunctionID::getName() const { return Name; }
+
+void CodeViewTypeFunctionID::setName(StringRef N) { Name = N; }
+
+//===----------------------------------------------------------------------===//
+// CodeViewTypeProcedure
+//===----------------------------------------------------------------------===//
+
+CodeViewTypeProcedure::CodeViewTypeProcedure()
+    : CodeViewType(CodeViewTypeKind::TypeProcedure),
+      ReturnType(nullptr),
+      ArgumentList(nullptr),
+      CallingConvention(0),
+      ParamCount(0) {}
+
+CodeViewTypeProcedure::~CodeViewTypeProcedure() {}
+
+CodeViewTypeProcedure *CodeViewTypeProcedure::create() {
+  return new CodeViewTypeProcedure();
+}
+
+CodeViewType *CodeViewTypeProcedure::getReturnType() const {
+  return ReturnType;
+}
+
+void CodeViewTypeProcedure::setReturnType(CodeViewType *CVType) {
+  ReturnType = CVType;
+}
+
+int CodeViewTypeProcedure::getCallingConvention() const {
+  return CallingConvention;
+}
+
+void CodeViewTypeProcedure::setCallingConvention(int CC) {
+  CallingConvention = CC;
+}
+
+uint16_t CodeViewTypeProcedure::getParamCount() const { return ParamCount; }
+
+void CodeViewTypeProcedure::setParamCount(uint16_t Count) {
+  ParamCount = Count;
+}
+
+CodeViewType *CodeViewTypeProcedure::getArgumentList() const { return ArgumentList; }
+
+void CodeViewTypeProcedure::setArgumentList(CodeViewType *ArgList) {
+  ArgumentList = ArgList;
+}
+
+//===----------------------------------------------------------------------===//
+// CodeViewTypeArgumentList
+//===----------------------------------------------------------------------===//
+
+CodeViewTypeArgumentList::CodeViewTypeArgumentList()
+  : CodeViewType(CodeViewTypeKind::TypeArgumentList),
+  ArgumentList() {}
+
+CodeViewTypeArgumentList::~CodeViewTypeArgumentList() {}
+
+CodeViewTypeArgumentList *CodeViewTypeArgumentList::create() {
+  return new CodeViewTypeArgumentList();
+}
+
+const CodeViewTypeArgumentList::ArgTypeList *
+CodeViewTypeArgumentList::getArgumentList() const { return &ArgumentList; }
+
+CodeViewTypeArgumentList::ArgTypeList *
+CodeViewTypeArgumentList::getArgumentList() { return &ArgumentList; }
+
+uint32_t CodeViewTypeArgumentList::getArgumentCount() const {
+  return ArgumentList.size();
+}
+
+void CodeViewTypeArgumentList::append(CodeViewType *Argument) {
+  ArgumentList.push_back(Argument);
+}
+

test/DebugInfo/COFF/asm.ll

 ; X86:      .cv_file 1 "D:\\asm.c"
 ; X86:      .cv_loc 0 1 4 0 is_stmt 0
 ; X86:      .cv_loc 0 1 5 0
 ; X86:      calll   _g
 ; X86:      .cv_loc 0 1 6 0
 ; X86:      ret
 ; X86:      [[END_OF_F:.?Lfunc_end.*]]:
 ;
+; X86-LABEL: .section        .debug$T,"dr"
+; X86-NEXT: .long   4
+; X86-NEXT: .short  6
+; X86-NEXT: .short  4609
+; X86-NEXT: .long   0
+; X86-NEXT: .short  14
+; X86-NEXT: .short  4104
+; X86-NEXT: .long   3
+; X86-NEXT: .byte   0
+; X86-NEXT: .byte   0
+; X86-NEXT: .short  0
+; X86-NEXT: .long   4096
+; X86-NEXT: .short  14
+; X86-NEXT: .short  5633
+; X86-NEXT: .long   0
+; X86-NEXT: .long   4097
+; X86-NEXT: .asciz  "f"
+; X86-NEXT:.byte   242
+; X86-NEXT:.byte   241
+;
 ; X86-LABEL: .section        .debug$S,"dr"
 ; X86-NEXT: .long   4
 ; Symbol subsection
 ; X86-NEXT: .long   241
 ; X86-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X86-NEXT: [[F1_START]]:
 ; X86-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X86-NEXT: [[PROC_SEGMENT_START]]:
 ; X86-NEXT: .short  4423
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long [[END_OF_F]]-_f
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
-; X86-NEXT: .long   0
+; X86-NEXT: .long   4098
 ; X86-NEXT: .secrel32 _f
 ; X86-NEXT: .secidx _f
 ; X86-NEXT: .byte   0
 ; X86-NEXT: .asciz "f"
 ; X86-NEXT: [[PROC_SEGMENT_END]]:
 ; X86-NEXT: .short  2
 ; X86-NEXT: .short  4431
 ; X86-NEXT: [[F1_END]]:

 ; X64:      .cv_loc 0 1 4 0
 ; X64:      .cv_loc 0 1 5 0
 ; X64:      callq   g
 ; X64:      .cv_loc 0 1 6 0
 ; X64:      addq    $40, %rsp
 ; X64-NEXT: ret
 ; X64:      [[END_OF_F:.?Lfunc_end.*]]:
 ;
+; X64-LABEL: .section        .debug$T,"dr"
+; X64-NEXT: .long   4
+; X64-NEXT: .short  6
+; X64-NEXT: .short  4609
+; X64-NEXT: .long   0
+; X64-NEXT: .short  14
+; X64-NEXT: .short  4104
+; X64-NEXT: .long   3
+; X64-NEXT: .byte   0
+; X64-NEXT: .byte   0
+; X64-NEXT: .short  0
+; X64-NEXT: .long   4096
+; X64-NEXT: .short  14
+; X64-NEXT: .short  5633
+; X64-NEXT: .long   0
+; X64-NEXT: .long   4097
+; X64-NEXT: .asciz  "f"
+; X64-NEXT:.byte   242
+; X64-NEXT:.byte   241
+;
 ; X64-LABEL: .section        .debug$S,"dr"
 ; X64-NEXT: .long   4
 ; Symbol subsection
 ; X64-NEXT: .long   241
 ; X64-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X64-NEXT: [[F1_START]]:
 ; X64-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X64-NEXT: [[PROC_SEGMENT_START]]:
 ; X64-NEXT: .short  4423
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long [[END_OF_F]]-f
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
-; X64-NEXT: .long   0
+; X64-NEXT: .long   4098
 ; X64-NEXT: .secrel32 f
 ; X64-NEXT: .secidx f
 ; X64-NEXT: .byte   0
 ; X64-NEXT: .asciz "f"
 ; X64-NEXT: [[PROC_SEGMENT_END]]:
 ; X64-NEXT: .short  2
 ; X64-NEXT: .short  4431
 ; X64-NEXT: [[F1_END]]:

test/DebugInfo/COFF/basic-types.ll

+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s | FileCheck %s --check-prefix=ASM
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s -filetype=obj | llvm-readobj -codeview | FileCheck %s --check-prefix=OBJ
+
+; This LL file was generated by running
+; 'clang -O0 -c -g -gcodeview -S -emit-llvm' on the following code:
+;  1: extern volatile int x;
+;  2: void foo() {
+;  3:   bool b;
+;  4:   char c;
+;  5:   short s;
+;  6:   int i;
+;  7:   long l;  
+;  8:   float f;
+;  9:   double d;
+; 10:   long double ld;
+; 11:   unsigned char uc;
+; 12:   insigned short us;
+; 13:   unsigned int ui;
+; 14:   unsigned long ul;
+; 15:   x += (int)&b + (int)&c + (int)&s + (int)&i + (int)&l + (int)&f + (int)&d
+; 16:      + (int)&ld + (int)&uc + (int)&us + (int)&ui + (int)&ul;
+; 17: }
+
+; ASM: .section        .debug$T,"dr"
+; ASM: .long   4
+; ASM: .short  6
+; ASM: .short  4609
+; ASM: .long   0
+; ASM: .short  14
+; ASM: .short  4104
+; ASM: .long   3
+; ASM: .byte   0
+; ASM: .byte   0
+; ASM: .short  0
+; ASM: .long   4096
+; ASM: .short  14
+; ASM: .short  5633
+; ASM: .long   0
+; ASM: .long   4097
+; ASM: .asciz  "foo"
+;
+; ASM: .section        .debug$S,"dr"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   48                      # TypeIndex
+; ASM: .asciz  "b"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   16                      # TypeIndex
+; ASM: .asciz  "c"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   17                      # TypeIndex
+; ASM: .asciz  "s"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   116                     # TypeIndex
+; ASM: .asciz  "i"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   18                      # TypeIndex
+; ASM: .asciz  "l"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   64                      # TypeIndex
+; ASM: .asciz  "f"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   65                      # TypeIndex
+; ASM: .asciz  "d"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   65                      # TypeIndex
+; ASM: .asciz  "ld"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   32                      # TypeIndex
+; ASM: .asciz  "uc"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   115                     # TypeIndex
+; ASM: .asciz  "us"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   117                     # TypeIndex
+; ASM: .asciz  "ui"
+; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .long   34                      # TypeIndex
+; ASM: .asciz  "ul"
+
+; OBJ: Local {
+; OBJ:   Type: bool (0x30)
+; OBJ:   VarName: b
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: signed char (0x10)
+; OBJ:   VarName: c
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: short (0x11)
+; OBJ:   VarName: s
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: int (0x74)
+; OBJ:   VarName: i
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: long (0x12)
+; OBJ:   VarName: l
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: float (0x40)
+; OBJ:   VarName: f
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: double (0x41)
+; OBJ:   VarName: d
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: double (0x41)
+; OBJ:   VarName: ld
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: unsigned char (0x20)
+; OBJ:   VarName: uc
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: unsigned __int16 (0x73)
+; OBJ:   VarName: us
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: unsigned (0x75)
+; OBJ:   VarName: ui
+; OBJ: }
+; OBJ: Local {
+; OBJ:   Type: unsigned long (0x22)
+; OBJ:   VarName: ul
+; OBJ: }
+
+; ModuleID = 'basic-types.cpp'
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc18.0.0"
+
+@"\01?x@@3HC" = external global i32, align 4
+
+; Function Attrs: nounwind
+define void @"\01?foo@@YAXXZ"() #0 !dbg !8 {
+entry:
+  %b = alloca i8, align 1
+  %c = alloca i8, align 1
+  %s = alloca i16, align 2
+  %i = alloca i32, align 4
+  %l = alloca i32, align 4
+  %f = alloca float, align 4
+  %d = alloca double, align 8
+  %ld = alloca double, align 8
+  %uc = alloca i8, align 1
+  %us = alloca i16, align 2
+  %ui = alloca i32, align 4
+  %ul = alloca i32, align 4
+  call void @llvm.dbg.declare(metadata i8* %b, metadata !11, metadata !13), !dbg !14
+  call void @llvm.dbg.declare(metadata i8* %c, metadata !15, metadata !13), !dbg !17
+  call void @llvm.dbg.declare(metadata i16* %s, metadata !18, metadata !13), !dbg !20
+  call void @llvm.dbg.declare(metadata i32* %i, metadata !21, metadata !13), !dbg !22
+  call void @llvm.dbg.declare(metadata i32* %l, metadata !23, metadata !13), !dbg !25
+  call void @llvm.dbg.declare(metadata float* %f, metadata !26, metadata !13), !dbg !28
+  call void @llvm.dbg.declare(metadata double* %d, metadata !29, metadata !13), !dbg !31
+  call void @llvm.dbg.declare(metadata double* %ld, metadata !32, metadata !13), !dbg !34
+  call void @llvm.dbg.declare(metadata i8* %uc, metadata !35, metadata !13), !dbg !37
+  call void @llvm.dbg.declare(metadata i16* %us, metadata !38, metadata !13), !dbg !40
+  call void @llvm.dbg.declare(metadata i32* %ui, metadata !41, metadata !13), !dbg !43
+  call void @llvm.dbg.declare(metadata i32* %ul, metadata !44, metadata !13), !dbg !46
+  %0 = ptrtoint i8* %b to i32, !dbg !47
+  %1 = ptrtoint i8* %c to i32, !dbg !48
+  %add = add nsw i32 %0, %1, !dbg !49
+  %2 = ptrtoint i16* %s to i32, !dbg !50
+  %add1 = add nsw i32 %add, %2, !dbg !51
+  %3 = ptrtoint i32* %i to i32, !dbg !52
+  %add2 = add nsw i32 %add1, %3, !dbg !53
+  %4 = ptrtoint i32* %l to i32, !dbg !54
+  %add3 = add nsw i32 %add2, %4, !dbg !55
+  %5 = ptrtoint float* %f to i32, !dbg !56
+  %add4 = add nsw i32 %add3, %5, !dbg !57
+  %6 = ptrtoint double* %d to i32, !dbg !58
+  %add5 = add nsw i32 %add4, %6, !dbg !59
+  %7 = ptrtoint double* %ld to i32, !dbg !60
+  %add6 = add nsw i32 %add5, %7, !dbg !61
+  %8 = ptrtoint i8* %uc to i32, !dbg !62
+  %add7 = add nsw i32 %add6, %8, !dbg !63
+  %9 = ptrtoint i16* %us to i32, !dbg !64
+  %add8 = add nsw i32 %add7, %9, !dbg !65
+  %10 = ptrtoint i32* %ui to i32, !dbg !66
+  %add9 = add nsw i32 %add8, %10, !dbg !67
+  %11 = ptrtoint i32* %ul to i32, !dbg !68
+  %add10 = add nsw i32 %add9, %11, !dbg !69
+  %12 = load volatile i32, i32* @"\01?x@@3HC", align 4, !dbg !70
+  %add11 = add nsw i32 %12, %add10, !dbg !70
+  store volatile i32 %add11, i32* @"\01?x@@3HC", align 4, !dbg !70
+  ret void, !dbg !71
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!5, !6}
+!llvm.ident = !{!7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 (trunk 269756)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3)
+!1 = !DIFile(filename: "basic-types.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4}
+!4 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!5 = !{i32 2, !"CodeView", i32 1}
+!6 = !{i32 2, !"Debug Info Version", i32 3}
+!7 = !{!"clang version 3.9.0 (trunk 269756)"}
+!8 = distinct !DISubprogram(name: "foo", linkageName: "\01?foo@@YAXXZ", scope: !1, file: !1, line: 2, type: !9, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!9 = !DISubroutineType(types: !10)
+!10 = !{null}
+!11 = !DILocalVariable(name: "b", scope: !8, file: !1, line: 3, type: !12)
+!12 = !DIBasicType(name: "bool", size: 8, align: 8, encoding: DW_ATE_boolean)
+!13 = !DIExpression()
+!14 = !DILocation(line: 3, column: 8, scope: !8)
+!15 = !DILocalVariable(name: "c", scope: !8, file: !1, line: 4, type: !16)
+!16 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
+!17 = !DILocation(line: 4, column: 8, scope: !8)
+!18 = !DILocalVariable(name: "s", scope: !8, file: !1, line: 5, type: !19)
+!19 = !DIBasicType(name: "short", size: 16, align: 16, encoding: DW_ATE_signed)
+!20 = !DILocation(line: 5, column: 9, scope: !8)
+!21 = !DILocalVariable(name: "i", scope: !8, file: !1, line: 6, type: !4)
+!22 = !DILocation(line: 6, column: 7, scope: !8)
+!23 = !DILocalVariable(name: "l", scope: !8, file: !1, line: 7, type: !24)
+!24 = !DIBasicType(name: "long int", size: 32, align: 32, encoding: DW_ATE_signed)
+!25 = !DILocation(line: 7, column: 8, scope: !8)
+!26 = !DILocalVariable(name: "f", scope: !8, file: !1, line: 8, type: !27)
+!27 = !DIBasicType(name: "float", size: 32, align: 32, encoding: DW_ATE_float)
+!28 = !DILocation(line: 8, column: 9, scope: !8)
+!29 = !DILocalVariable(name: "d", scope: !8, file: !1, line: 9, type: !30)
+!30 = !DIBasicType(name: "double", size: 64, align: 64, encoding: DW_ATE_float)
+!31 = !DILocation(line: 9, column: 10, scope: !8)
+!32 = !DILocalVariable(name: "ld", scope: !8, file: !1, line: 10, type: !33)
+!33 = !DIBasicType(name: "long double", size: 64, align: 64, encoding: DW_ATE_float)
+!34 = !DILocation(line: 10, column: 15, scope: !8)
+!35 = !DILocalVariable(name: "uc", scope: !8, file: !1, line: 11, type: !36)
+!36 = !DIBasicType(name: "unsigned char", size: 8, align: 8, encoding: DW_ATE_unsigned_char)
+!37 = !DILocation(line: 11, column: 17, scope: !8)
+!38 = !DILocalVariable(name: "us", scope: !8, file: !1, line: 12, type: !39)
+!39 = !DIBasicType(name: "unsigned short", size: 16, align: 16, encoding: DW_ATE_unsigned)
+!40 = !DILocation(line: 12, column: 18, scope: !8)
+!41 = !DILocalVariable(name: "ui", scope: !8, file: !1, line: 13, type: !42)
+!42 = !DIBasicType(name: "unsigned int", size: 32, align: 32, encoding: DW_ATE_unsigned)
+!43 = !DILocation(line: 13, column: 16, scope: !8)
+!44 = !DILocalVariable(name: "ul", scope: !8, file: !1, line: 14, type: !45)
+!45 = !DIBasicType(name: "long unsigned int", size: 32, align: 32, encoding: DW_ATE_unsigned)
+!46 = !DILocation(line: 14, column: 17, scope: !8)
+!47 = !DILocation(line: 15, column: 8, scope: !8)
+!48 = !DILocation(line: 15, column: 18, scope: !8)
+!49 = !DILocation(line: 15, column: 16, scope: !8)
+!50 = !DILocation(line: 15, column: 28, scope: !8)
+!51 = !DILocation(line: 15, column: 26, scope: !8)
+!52 = !DILocation(line: 15, column: 38, scope: !8)
+!53 = !DILocation(line: 15, column: 36, scope: !8)
+!54 = !DILocation(line: 15, column: 48, scope: !8)
+!55 = !DILocation(line: 15, column: 46, scope: !8)
+!56 = !DILocation(line: 15, column: 58, scope: !8)
+!57 = !DILocation(line: 15, column: 56, scope: !8)
+!58 = !DILocation(line: 15, column: 68, scope: !8)
+!59 = !DILocation(line: 15, column: 66, scope: !8)
+!60 = !DILocation(line: 16, column: 6, scope: !8)
+!61 = !DILocation(line: 16, column: 5, scope: !8)
+!62 = !DILocation(line: 16, column: 17, scope: !8)
+!63 = !DILocation(line: 16, column: 15, scope: !8)
+!64 = !DILocation(line: 16, column: 28, scope: !8)
+!65 = !DILocation(line: 16, column: 26, scope: !8)
+!66 = !DILocation(line: 16, column: 39, scope: !8)
+!67 = !DILocation(line: 16, column: 37, scope: !8)
+!68 = !DILocation(line: 16, column: 50, scope: !8)
+!69 = !DILocation(line: 16, column: 48, scope: !8)
+!70 = !DILocation(line: 15, column: 5, scope: !8)
+!71 = !DILocation(line: 17, column: 1, scope: !8)

test/DebugInfo/COFF/function-type.ll

+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s | FileCheck %s --check-prefix=ASM
+; RUN: llc -mcpu=core2 -mtriple=i686-pc-win32 < %s -filetype=obj | llvm-readobj -codeview | FileCheck %s --check-prefix=OBJ
+
+; This LL file was generated by running
+; 'clang -O0 -c -g -gcodeview -S -emit-llvm' on the following code:
+;  1: int foo(char c, short s, long l, float f) {
+;  2: return 0;
+;  3: }
+
+; ASM: .section        .debug$T,"dr"
+; ASM: long   4                       # Debug section magic
+; ASM: short  22                      # Type record length
+; ASM: short  4609                    # Leaf type: LF_ARGLIST
+; ASM: long   4                       # Number of arguments
+; ASM: long   16                      # Argument Type
+; ASM: long   17                      # Argument Type
+; ASM: long   18                      # Argument Type
+; ASM: long   64                      # Argument Type
+; ASM: short  14                      # Type record length
+; ASM: short  4104                    # Leaf type: LF_PROCEDURE
+; ASM: long   116                     # Return Type
+; ASM: byte   0                       # Calling Convention
+; ASM: byte   0                       # Reserved
+; ASM: short  4                       # Number of arguments
+; ASM: long   4096                    # Argument List Type
+; ASM: short  14                      # Type record length
+; ASM: short  5633                    # Leaf type: LF_FUNC_ID
+; ASM: long   0                       # Parent scope type
+; ASM: long   4097                    # Function type
+; ASM: asciz  "foo"                   # Function name
+
+; OBJ: CodeViewTypes [
+; OBJ:   Section: .debug$T (4)
+; OBJ:   Magic: 0x4
+; OBJ:   ArgList (0x1000) {
+; OBJ:     TypeLeafKind: LF_ARGLIST (0x1201)
+; OBJ:     NumArgs: 4
+; OBJ:     Arguments [
+; OBJ:       ArgType: signed char (0x10)
+; OBJ:       ArgType: short (0x11)
+; OBJ:       ArgType: long (0x12)
+; OBJ:       ArgType: float (0x40)
+; OBJ:     ]
+; OBJ:   }
+; OBJ:   Procedure (0x1001) {
+; OBJ:     TypeLeafKind: LF_PROCEDURE (0x1008)
+; OBJ:     ReturnType: int (0x74)
+; OBJ:     CallingConvention: NearC (0x0)
+; OBJ:     FunctionOptions [ (0x0)
+; OBJ:     ]
+; OBJ:     NumParameters: 4
+; OBJ:     ArgListType: (signed char, short, long, float) (0x1000)
+; OBJ:   }
+; OBJ:   FuncId (0x1002) {
+; OBJ:     TypeLeafKind: LF_FUNC_ID (0x1601)
+; OBJ:     ParentScope: 0x0
+; OBJ:     FunctionType: int (signed char, short, long, float) (0x1001)
+; OBJ:     Name: foo
+; OBJ:   }
+; OBJ: ]
+
+; ModuleID = 'function-type.c'
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc18.0.0"
+
+; Function Attrs: nounwind
+define i32 @foo(i8 signext %c, i16 signext %s, i32 %l, float %f) #0 !dbg !6 {
+entry:
+  %f.addr = alloca float, align 4
+  %l.addr = alloca i32, align 4
+  %s.addr = alloca i16, align 2
+  %c.addr = alloca i8, align 1
+  store float %f, float* %f.addr, align 4
+  call void @llvm.dbg.declare(metadata float* %f.addr, metadata !14, metadata !15), !dbg !16
+  store i32 %l, i32* %l.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %l.addr, metadata !17, metadata !15), !dbg !18
+  store i16 %s, i16* %s.addr, align 2
+  call void @llvm.dbg.declare(metadata i16* %s.addr, metadata !19, metadata !15), !dbg !20
+  store i8 %c, i8* %c.addr, align 1
+  call void @llvm.dbg.declare(metadata i8* %c.addr, metadata !21, metadata !15), !dbg !22
+  ret i32 0, !dbg !23
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4}
+!llvm.ident = !{!5}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 3.9.0 (trunk 269756)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "function-type.c", directory: "/")
+!2 = !{}
+!3 = !{i32 2, !"CodeView", i32 1}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{!"clang version 3.9.0 (trunk 269756)"}
+!6 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 1, type: !7, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!7 = !DISubroutineType(types: !8)
+!8 = !{!9, !10, !11, !12, !13}
+!9 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!10 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
+!11 = !DIBasicType(name: "short", size: 16, align: 16, encoding: DW_ATE_signed)
+!12 = !DIBasicType(name: "long int", size: 32, align: 32, encoding: DW_ATE_signed)
+!13 = !DIBasicType(name: "float", size: 32, align: 32, encoding: DW_ATE_float)
+!14 = !DILocalVariable(name: "f", arg: 4, scope: !6, file: !1, line: 1, type: !13)
+!15 = !DIExpression()
+!16 = !DILocation(line: 1, column: 40, scope: !6)
+!17 = !DILocalVariable(name: "l", arg: 3, scope: !6, file: !1, line: 1, type: !12)
+!18 = !DILocation(line: 1, column: 31, scope: !6)
+!19 = !DILocalVariable(name: "s", arg: 2, scope: !6, file: !1, line: 1, type: !11)
+!20 = !DILocation(line: 1, column: 23, scope: !6)
+!21 = !DILocalVariable(name: "c", arg: 1, scope: !6, file: !1, line: 1, type: !10)
+!22 = !DILocation(line: 1, column: 14, scope: !6)
+!23 = !DILocation(line: 2, column: 3, scope: !6)

test/DebugInfo/COFF/inlining.ll

 ; OBJ:     Name: bar
 ; OBJ:   }
 ; OBJ:   FuncId (0x1003) {
 ; OBJ:     TypeLeafKind: LF_FUNC_ID (0x1601)
 ; OBJ:     ParentScope: 0x0
 ; OBJ:     FunctionType: void () (0x1001)
 ; OBJ:     Name: foo
 ; OBJ:   }
+; OBJ:   FuncId (0x1004) {
+; OBJ:     TypeLeafKind: LF_FUNC_ID (0x1601)
+; OBJ:     ParentScope: 0x0
+; OBJ:     FunctionType: void () (0x1001)
+; OBJ:     Name: baz
+; OBJ:   }
 ; OBJ-NOT: TypeLeafKind: LF_FUNC_ID
 ; OBJ: ]
 
 ; OBJ: Subsection [
 ; OBJ:   SubSectionType: InlineeLines (0xF6)
 ; OBJ:   SubSectionSize: 0x1C
 ; OBJ:   InlineeSourceLine {
 ; OBJ:     Inlinee: bar (0x1002)

 ; OBJ:   SubSectionType: Symbols (0xF1)
 ; OBJ:   ProcStart {
 ; OBJ:     PtrParent: 0x0
 ; OBJ:     PtrEnd: 0x0
 ; OBJ:     PtrNext: 0x0
 ; OBJ:     CodeSize: 0x3D
 ; OBJ:     DbgStart: 0x0
 ; OBJ:     DbgEnd: 0x0
-; OBJ:     FunctionType: 0x0
+; OBJ:     FunctionType: baz (0x1004)
 ; OBJ:     CodeOffset: ?baz@@YAXXZ+0x0
 ; OBJ:     Segment: 0x0
 ; OBJ:     Flags [ (0x0)
 ; OBJ:     ]
 ; OBJ:     DisplayName: baz
 ; OBJ:     LinkageName: ?baz@@YAXXZ
 ; OBJ:   }
 ; OBJ:   InlineSite {

test/DebugInfo/COFF/multifile.ll

 ; X86:      .cv_loc 0 2 2 0 # two.c:2:0
 ; X86:      calll   _g
 ; X86:      .cv_loc 0 1 7 0 # one.c:7:0
 ; X86:      calll   _g
 ; X86:      .cv_loc 0 1 8 0 # one.c:8:0
 ; X86:      ret
 ; X86:      [[END_OF_F:.?Lfunc_end.*]]:
 ;
+; X86-LABEL: .section        .debug$T,"dr"
+; X86-NEXT: .long   4
+; X86-NEXT: .short  6
+; X86-NEXT: .short  4609
+; X86-NEXT: .long   0
+; X86-NEXT: .short  14
+; X86-NEXT: .short  4104
+; X86-NEXT: .long   3
+; X86-NEXT: .byte   0
+; X86-NEXT: .byte   0
+; X86-NEXT: .short  0
+; X86-NEXT: .long   4096
+; X86-NEXT: .short  14
+; X86-NEXT: .short  5633
+; X86-NEXT: .long   0
+; X86-NEXT: .long   4097
+; X86-NEXT: .asciz  "f"
+; X86-NEXT: .byte   242
+; X86-NEXT: .byte   241
+;
 ; X86-LABEL: .section        .debug$S,"dr"
 ; X86-NEXT: .long   4
 ; Symbol subsection
 ; X86-NEXT: .long   241
 ; X86-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X86-NEXT: [[F1_START]]:
 ; X86-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X86-NEXT: [[PROC_SEGMENT_START]]:
 ; X86-NEXT: .short  4423
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long [[END_OF_F]]-_f
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
-; X86-NEXT: .long   0
+; X86-NEXT: .long   4098
 ; X86-NEXT: .secrel32 _f
 ; X86-NEXT: .secidx _f
 ; X86-NEXT: .byte   0
 ; X86-NEXT: .asciz "f"
 ; X86-NEXT: [[PROC_SEGMENT_END]]:
 ; X86-NEXT: .short  2
 ; X86-NEXT: .short  4431
 ; X86-NEXT: [[F1_END]]:

 ; X64:      callq   g
 ; X64:      .cv_loc 0 2 7 0 # one.c:7:0
 ; X64:      callq   g
 ; X64:      .cv_loc 0 2 8 0 # one.c:8:0
 ; X64:      addq    $40, %rsp
 ; X64-NEXT: ret
 ; X64:      [[END_OF_F:.?Lfunc_end.*]]:
 ;
+; X64-LABEL: .section        .debug$T,"dr"
+; X64-NEXT: .long   4
+; X64-NEXT: .short  6
+; X64-NEXT: .short  4609
+; X64-NEXT: .long   0
+; X64-NEXT: .short  14
+; X64-NEXT: .short  4104
+; X64-NEXT: .long   3
+; X64-NEXT: .byte   0
+; X64-NEXT: .byte   0
+; X64-NEXT: .short  0
+; X64-NEXT: .long   4096
+; X64-NEXT: .short  14
+; X64-NEXT: .short  5633
+; X64-NEXT: .long   0
+; X64-NEXT: .long   4097
+; X64-NEXT: .asciz  "f"
+; X64-NEXT: .byte   242
+; X64-NEXT: .byte   241
+;
 ; X64-LABEL: .section        .debug$S,"dr"
 ; X64-NEXT: .long   4
 ; Symbol subsection
 ; X64-NEXT: .long   241
 ; X64-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X64-NEXT: [[F1_START]]:
 ; X64-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X64-NEXT: [[PROC_SEGMENT_START]]:
 ; X64-NEXT: .short  4423
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long [[END_OF_F]]-f
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
-; X64-NEXT: .long   0
+; X64-NEXT: .long   4098
 ; X64-NEXT: .secrel32 f
 ; X64-NEXT: .secidx f
 ; X64-NEXT: .byte   0
 ; X64-NEXT: .asciz "f"
 ; X64-NEXT: [[PROC_SEGMENT_END]]:
 ; X64-NEXT: .short  2
 ; X64-NEXT: .short  4431
 ; X64-NEXT: [[F1_END]]:

test/DebugInfo/COFF/multifunction.ll

 ; X86:      .cv_loc 2 1 13 63 # source.c:13:63
 ; X86:      calll   _y
 ; X86:      .cv_loc 2 1 14 72 # source.c:14:72
 ; X86:      calll   _z
 ; X86:      .cv_loc 2 1 15 73 # source.c:15:73
 ; X86:      ret
 ; X86:      [[END_OF_F:.?Lfunc_end.*]]:
 ;
+; X86-LABEL: .section        .debug$T,"dr"
+; X86-NEXT: .long   4
+; X86-NEXT: .short  6
+; X86-NEXT: .short  4609
+; X86-NEXT: .long   0
+; X86-NEXT: .short  14
+; X86-NEXT: .short  4104
+; X86-NEXT: .long   3
+; X86-NEXT: .byte   0
+; X86-NEXT: .byte   0
+; X86-NEXT: .short  0
+; X86-NEXT: .long   4096
+; X86-NEXT: .short  14
+; X86-NEXT: .short  5633
+; X86-NEXT: .long   0
+; X86-NEXT: .long   4097
+; X86-NEXT: .asciz  "x"
+; X86-NEXT: .byte   242
+; X86-NEXT: .byte   241
+; X86-NEXT: .short  14
+; X86-NEXT: .short  5633
+; X86-NEXT: .long   0
+; X86-NEXT: .long   4097
+; X86-NEXT: .asciz  "y"
+; X86-NEXT: .byte   242
+; X86-NEXT: .byte   241
+; X86-NEXT: .short  14
+; X86-NEXT: .short  5633
+; X86-NEXT: .long   0
+; X86-NEXT: .long   4097
+; X86-NEXT: .asciz  "f"
+; X86-NEXT: .byte   242
+; X86-NEXT: .byte   241
+;
 ; X86-LABEL: .section        .debug$S,"dr"
 ; X86-NEXT: .long   4
 ; Symbol subsection for x
 ; X86-NEXT: .long   241
 ; X86-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X86-NEXT: [[F1_START]]:
 ; X86-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X86-NEXT: [[PROC_SEGMENT_START]]:
 ; X86-NEXT: .short  4423
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long [[END_OF_X]]-_x
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
-; X86-NEXT: .long   0
+; X86-NEXT: .long   4098
 ; X86-NEXT: .secrel32 _x
 ; X86-NEXT: .secidx _x
 ; X86-NEXT: .byte   0
 ; X86-NEXT: .asciz "x"
 ; X86-NEXT: [[PROC_SEGMENT_END]]:
 ; X86-NEXT: .short  2
 ; X86-NEXT: .short  4431
 ; X86-NEXT: [[F1_END]]:
 ; X86-NEXT: .p2align 2
 ; Line table subsection for x
 ; X86: .cv_linetable 0, _x, [[END_OF_X]]
 ; Symbol subsection for y
 ; X86-NEXT: .long   241
 ; X86-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X86-NEXT: [[F1_START]]:
 ; X86-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X86-NEXT: [[PROC_SEGMENT_START]]:
 ; X86-NEXT: .short  4423
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long [[END_OF_Y]]-_y
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
-; X86-NEXT: .long   0
+; X86-NEXT: .long   4099
 ; X86-NEXT: .secrel32 _y
 ; X86-NEXT: .secidx _y
 ; X86-NEXT: .byte   0
 ; X86-NEXT: .asciz "y"
 ; X86-NEXT: [[PROC_SEGMENT_END]]:
 ; X86-NEXT: .short  2
 ; X86-NEXT: .short  4431
 ; X86-NEXT: [[F1_END]]:
 ; X86-NEXT: .p2align 2
 ; Line table subsection for y
 ; X86: .cv_linetable 1, _y, [[END_OF_Y]]
 ; Symbol subsection for f
 ; X86-NEXT: .long   241
 ; X86-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X86-NEXT: [[F1_START]]:
 ; X86-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X86-NEXT: [[PROC_SEGMENT_START]]:
 ; X86-NEXT: .short  4423
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long [[END_OF_F]]-_f
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
-; X86-NEXT: .long   0
+; X86-NEXT: .long   4100
 ; X86-NEXT: .secrel32 _f
 ; X86-NEXT: .secidx _f
 ; X86-NEXT: .byte   0
 ; X86-NEXT: .asciz "f"
 ; X86-NEXT: [[PROC_SEGMENT_END]]:
 ; X86-NEXT: .short  2
 ; X86-NEXT: .short  4431
 ; X86-NEXT: [[F1_END]]:

 ; X64:      callq   y
 ; X64:      .cv_loc 2 1 14 72 # source.c:14:72
 ; X64:      callq   z
 ; X64:      .cv_loc 2 1 15 73 # source.c:15:73
 ; X64:      addq    $40, %rsp
 ; X64-NEXT: ret
 ; X64:      [[END_OF_F:.?Lfunc_end.*]]:
 ;
+; X64-LABEL: .section        .debug$T,"dr"
+; X64-NEXT: .long   4
+; X64-NEXT: .short  6
+; X64-NEXT: .short  4609
+; X64-NEXT: .long   0
+; X64-NEXT: .short  14
+; X64-NEXT: .short  4104
+; X64-NEXT: .long   3
+; X64-NEXT: .byte   0
+; X64-NEXT: .byte   0
+; X64-NEXT: .short  0
+; X64-NEXT: .long   4096
+; X64-NEXT: .short  14
+; X64-NEXT: .short  5633
+; X64-NEXT: .long   0
+; X64-NEXT: .long   4097
+; X64-NEXT: .asciz  "x"
+; X64-NEXT: .byte   242
+; X64-NEXT: .byte   241
+; X64-NEXT: .short  14
+; X64-NEXT: .short  5633
+; X64-NEXT: .long   0
+; X64-NEXT: .long   4097
+; X64-NEXT: .asciz  "y"
+; X64-NEXT: .byte   242
+; X64-NEXT: .byte   241
+; X64-NEXT: .short  14
+; X64-NEXT: .short  5633
+; X64-NEXT: .long   0
+; X64-NEXT: .long   4097
+; X64-NEXT: .asciz  "f"
+; X64-NEXT: .byte   242
+; X64-NEXT: .byte   241
+;
 ; X64-LABEL: .section        .debug$S,"dr"
 ; X64-NEXT: .long   4
 ; Symbol subsection for x
 ; X64-NEXT: .long   241
 ; X64-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X64-NEXT: [[F1_START]]:
 ; X64-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X64-NEXT: [[PROC_SEGMENT_START]]:
 ; X64-NEXT: .short  4423
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long [[END_OF_X]]-x
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
-; X64-NEXT: .long   0
+; X64-NEXT: .long   4098
 ; X64-NEXT: .secrel32 x
 ; X64-NEXT: .secidx x
 ; X64-NEXT: .byte   0
 ; X64-NEXT: .asciz "x"
 ; X64-NEXT: [[PROC_SEGMENT_END]]:
 ; X64-NEXT: .short  2
 ; X64-NEXT: .short  4431
 ; X64-NEXT: [[F1_END]]:
 ; X64-NEXT: .p2align 2
 ; Line table subsection for x
 ; X64: .cv_linetable 0, x, [[END_OF_X]]
 ; Symbol subsection for y
 ; X64-NEXT: .long   241
 ; X64-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X64-NEXT: [[F1_START]]:
 ; X64-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X64-NEXT: [[PROC_SEGMENT_START]]:
 ; X64-NEXT: .short  4423
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long [[END_OF_Y]]-y
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
-; X64-NEXT: .long   0
+; X64-NEXT: .long   4099
 ; X64-NEXT: .secrel32 y
 ; X64-NEXT: .secidx y
 ; X64-NEXT: .byte   0
 ; X64-NEXT: .asciz "y"
 ; X64-NEXT: [[PROC_SEGMENT_END]]:
 ; X64-NEXT: .short  2
 ; X64-NEXT: .short  4431
 ; X64-NEXT: [[F1_END]]:
 ; X64-NEXT: .p2align 2
 ; Line table subsection for y
 ; X64: .cv_linetable 1, y, [[END_OF_Y]]
 ; Symbol subsection for f
 ; X64-NEXT: .long   241
 ; X64-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X64-NEXT: [[F1_START]]:
 ; X64-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X64-NEXT: [[PROC_SEGMENT_START]]:
 ; X64-NEXT: .short  4423
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long [[END_OF_F]]-f
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
-; X64-NEXT: .long   0
+; X64-NEXT: .long   4100
 ; X64-NEXT: .secrel32 f
 ; X64-NEXT: .secidx f
 ; X64-NEXT: .byte   0
 ; X64-NEXT: .asciz "f"
 ; X64-NEXT: [[PROC_SEGMENT_END]]:
 ; X64-NEXT: .short  2
 ; X64-NEXT: .short  4431
 ; X64-NEXT: [[F1_END]]:

test/DebugInfo/COFF/simple.ll

 ; X86:      # BB
 ; X86:      .cv_file 1 "D:\\test.c"
 ; X86:      .cv_loc 0 1 4 2 is_stmt 0 # test.c:4:2
 ; X86:      calll   _g
 ; X86:      .cv_loc 0 1 5 0 # test.c:5:0
 ; X86:      ret
 ; X86:      [[END_OF_F:Lfunc_end.*]]:
 ;
+; X86-LABEL: .section        .debug$T,"dr"
+; X86-NEXT:.long   4
+; X86-NEXT:.short  6
+; X86-NEXT:.short  4609
+; X86-NEXT:.long   0
+; X86-NEXT:.short  14
+; X86-NEXT:.short  4104
+; X86-NEXT:.long   3
+; X86-NEXT:.byte   0
+; X86-NEXT:.byte   0
+; X86-NEXT:.short  0
+; X86-NEXT:.long   4096
+; X86-NEXT:.short  14
+; X86-NEXT:.short  5633
+; X86-NEXT:.long   0
+; X86-NEXT:.long   4097
+; X86-NEXT:.asciz  "f"
+; X86-NEXT:.byte   242
+; X86-NEXT:.byte   241
+;
 ; X86-LABEL: .section        .debug$S,"dr"
 ; X86-NEXT: .long   4
 ; Symbol subsection
 ; X86-NEXT: .long   241
 ; X86-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X86-NEXT: [[F1_START]]:
 ; X86-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X86-NEXT: [[PROC_SEGMENT_START]]:
 ; X86-NEXT: .short  4423
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long [[END_OF_F]]-_f
 ; X86-NEXT: .long   0
 ; X86-NEXT: .long   0
-; X86-NEXT: .long   0
+; X86-NEXT: .long   4098
 ; X86-NEXT: .secrel32 _f
 ; X86-NEXT: .secidx _f
 ; X86-NEXT: .byte   0
 ; X86-NEXT: .asciz "f"
 ; X86-NEXT: [[PROC_SEGMENT_END]]:
 ; X86-NEXT: .short  2
 ; X86-NEXT: .short  4431
 ; X86-NEXT: [[F1_END]]:

 ; X64:      subq    $40, %rsp
 ; X64:      .cv_loc 0 1 4 2 # test.c:4:2
 ; X64-NEXT: callq   g
 ; X64:      .cv_loc 0 1 5 0 # test.c:5:0
 ; X64:      addq    $40, %rsp
 ; X64-NEXT: ret
 ; X64:      [[END_OF_F:.?Lfunc_end.*]]:
 ;
+; X64-LABEL: .section        .debug$T,"dr"
+; X64-NEXT:.long   4
+; X64-NEXT:.short  6
+; X64-NEXT:.short  4609
+; X64-NEXT:.long   0
+; X64-NEXT:.short  14
+; X64-NEXT:.short  4104
+; X64-NEXT:.long   3
+; X64-NEXT:.byte   0
+; X64-NEXT:.byte   0
+; X64-NEXT:.short  0
+; X64-NEXT:.long   4096
+; X64-NEXT:.short  14
+; X64-NEXT:.short  5633
+; X64-NEXT:.long   0
+; X64-NEXT:.long   4097
+; X64-NEXT:.asciz  "f"
+; X64-NEXT:.byte   242
+; X64-NEXT:.byte   241
+;
 ; X64-LABEL: .section        .debug$S,"dr"
 ; X64-NEXT: .long   4
 ; Symbol subsection
 ; X64-NEXT: .long   241
 ; X64-NEXT: .long [[F1_END:.*]]-[[F1_START:.*]] #
 ; X64-NEXT: [[F1_START]]:
 ; X64-NEXT: .short [[PROC_SEGMENT_END:.*]]-[[PROC_SEGMENT_START:.*]] #
 ; X64-NEXT: [[PROC_SEGMENT_START]]:
 ; X64-NEXT: .short  4423
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long [[END_OF_F]]-f
 ; X64-NEXT: .long   0
 ; X64-NEXT: .long   0
-; X64-NEXT: .long   0
+; X64-NEXT: .long   4098
 ; X64-NEXT: .secrel32 f
 ; X64-NEXT: .secidx f
 ; X64-NEXT: .byte   0
 ; X64-NEXT: .asciz "f"
 ; X64-NEXT: [[PROC_SEGMENT_END]]:
 ; X64-NEXT: .short  2
 ; X64-NEXT: .short  4431
 ; X64-NEXT: [[F1_END]]: