Changing representation of .cv_def_range directives in Codeview debug info assembly format for better readability

[nilanjana_basu]

Summary

.cv_def_range information for symbol records in codeview debug info used to be represented as a serialized series of bytes in assembly format. This change will display the def_range info in human-readable format.

[rnk]

llvm/include/llvm/MC/MCStreamer.h

38

Please avoid using namespace in header files, since it will affect everyone who includes the header.

llvm/lib/MC/MCAsmStreamer.cpp

1398

I suppose this can be factored out as well.

1447–1453

Please factor this repeated code into a helper method.

1455

Ideally, registers should be printed textually as rbp, ebp, etc. Given time constraints, I think we can leave that as a future improvement, though.

llvm/lib/MC/MCParser/AsmParser.cpp

3882

I don't see a case for this enum... does it still work? I have to run to lunch, but I want to send these review comments now rather than later.

[nilanjana_basu]

llvm/lib/MC/MCAsmStreamer.cpp

1455

Will try to do this in the next patch before I leave.

llvm/lib/MC/MCParser/AsmParser.cpp

3882

This is a placeholder enum, like DK_NO_DIRECTIVE in DirectiveKind. If the defrange type is not found, it is set to this value, & its executed in the default case. I have only implemented the 4 types that are implemented in CodeViewDebug.cpp.

[nilanjana_basu]

1. Removed use of namespace from MCStreamer.h
2. Added helper function for factoring repeated code for printing def_range prefix

[rnk]

llvm/lib/MC/MCParser/AsmParser.cpp

3882

I saw that you left the asm printer method that prints the binary string version of .cv_defrange, so I thought maybe you wanted to keep support for that and handle it that way here. We can either completely remove support for the string variant of the directive, or add support for it here. Either way is fine.

3890

I realize you should write tests for the error handling paths. You can add a cv-defrange-errors.s test file that exercises each of these corner cases, and then FileCheck for the errors.

[nilanjana_basu]

1. Removed the functionality for the unimplemented (in CodeView) flag CVDR_DEFRANGE in the MCAsmStreamer.
2. Added new negative test cases for all errors reported for the current change
3. Fixed test cases involving CodeView def_range in MC/COFF

[rnk]

lgtm

[nilanjana_basu]

1. Changed two more test files for lld & lldb that used def_range directives
2. Fixed the endianness bug that arose because of changing the structure format of frame pointer relative def range structure.

lld/test/COFF/s_udt.s

 .Ltmp11:
   .short  .Ltmp13-.Ltmp12         # Record length
 .Ltmp12:
   .short  4414                    # Record kind: S_LOCAL
   .long 116                     # TypeIndex
   .short  1                       # Flags
   .asciz  "argc"
 .Ltmp13:
-  .cv_def_range  .Ltmp0 .Ltmp1, "B\021\f\000\000\000"
+  .cv_def_range   .Ltmp0 .Ltmp1, frame_ptr_rel, 12
   .short  .Ltmp15-.Ltmp14         # Record length
 .Ltmp14:
   .short  4414                    # Record kind: S_LOCAL
   .long 4096                    # TypeIndex
   .short  1                       # Flags
   .asciz  "argv"
 .Ltmp15:
-  .cv_def_range  .Ltmp0 .Ltmp1, "B\021\020\000\000\000"
+  .cv_def_range   .Ltmp0 .Ltmp1, frame_ptr_rel, 16
   .short  .Ltmp17-.Ltmp16         # Record length
 .Ltmp16:
   .short  4414                    # Record kind: S_LOCAL
   .long 4101                    # TypeIndex
   .short  0                       # Flags
   .asciz  "SPtr"
 .Ltmp17:
-  .cv_def_range  .Ltmp0 .Ltmp1, "B\021\000\000\000\000"
+  .cv_def_range   .Ltmp0 .Ltmp1, frame_ptr_rel, 0
   .short  .Ltmp19-.Ltmp18         # Record length
 .Ltmp18:
   .short  4360                    # Record kind: S_UDT
   .long 4101                    # Type
   .asciz  "main::LocalTypedef"
 .Ltmp19:
   .short  2                       # Record length
   .short  4431                    # Record kind: S_PROC_ID_END

lldb/lit/SymbolFile/NativePDB/Inputs/s_constant.s

 .Ltmp11:
   .short  .Ltmp13-.Ltmp12         # Record length
 .Ltmp12:
   .short  4414                    # Record kind: S_LOCAL
   .long 116                     # TypeIndex
   .short  1                       # Flags
   .asciz  "argc"
 .Ltmp13:
-  .cv_def_range  .Ltmp0 .Ltmp1, "B\021\004\000\000\000"
+  .cv_def_range   .Ltmp0 .Ltmp1, frame_ptr_rel, 4
   .short  .Ltmp15-.Ltmp14         # Record length
 .Ltmp14:
   .short  4414                    # Record kind: S_LOCAL
   .long 4096                    # TypeIndex
   .short  1                       # Flags
   .asciz  "argv"
 .Ltmp15:
-  .cv_def_range  .Ltmp0 .Ltmp1, "B\021\b\000\000\000"
+  .cv_def_range   .Ltmp0 .Ltmp1, frame_ptr_rel, 8
   .short  2                       # Record length
   .short  4431                    # Record kind: S_PROC_ID_END
 .Ltmp7:
   .p2align  2
   .cv_linetable 0, main, .Lfunc_end0
   .long 241                     # Symbol subsection for globals
   .long .Ltmp17-.Ltmp16         # Subsection size
 .Ltmp16:

lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.cpp

if (loc_specifier_cvs.kind() == S_DEFRANGE_FRAMEPOINTER_REL) {
           ((local.Flags & LocalSymFlags::IsParameter) != LocalSymFlags::None);
       RegisterId base_reg =
           GetBaseFrameRegister(index, frame_proc_id, is_parameter);
 
       if (base_reg == RegisterId::VFRAME) {
         llvm::StringRef program;
         if (GetFrameDataProgram(index, ranges, program)) {
           result.location =
-              MakeVFrameRelLocationExpression(program, loc.Offset, module);
+              MakeVFrameRelLocationExpression(program, loc.Hdr.Offset, module);
           result.ranges = std::move(ranges);
         } else {
           // invalid variable
         }
       } else {
         result.location =
-            MakeRegRelLocationExpression(base_reg, loc.Offset, module);
+            MakeRegRelLocationExpression(base_reg, loc.Hdr.Offset, module);
         result.ranges = std::move(ranges);
       }
     } else if (loc_specifier_cvs.kind() == S_DEFRANGE_REGISTER_REL) {
       DefRangeRegisterRelSym loc(SymbolRecordKind::DefRangeRegisterRelSym);
       cantFail(SymbolDeserializer::deserializeAs<DefRangeRegisterRelSym>(
           loc_specifier_cvs, loc));
 
       Variable::RangeList ranges = MakeRangeList(index, loc.Range, loc.Gaps);

llvm/include/llvm/DebugInfo/CodeView/SymbolRecord.h

public:
   uint32_t RecordOffset;
 };
 
 // S_DEFRANGE_FRAMEPOINTER_REL
 class DefRangeFramePointerRelSym : public SymbolRecord {
   static constexpr uint32_t RelocationOffset = 8;
 
 public:
+  struct Header {
+    little32_t Offset;
+  };
+
   explicit DefRangeFramePointerRelSym(SymbolRecordKind Kind)
       : SymbolRecord(Kind) {}
   DefRangeFramePointerRelSym(uint32_t RecordOffset)
       : SymbolRecord(SymbolRecordKind::DefRangeFramePointerRelSym),
         RecordOffset(RecordOffset) {}
 
   uint32_t getRelocationOffset() const {
     return RecordOffset + RelocationOffset;
   }
 
-  int32_t Offset;
+  Header Hdr;
   LocalVariableAddrRange Range;
   std::vector<LocalVariableAddrGap> Gaps;
 
   uint32_t RecordOffset;
 };
 
 // S_DEFRANGE_REGISTER_REL
 class DefRangeRegisterRelSym : public SymbolRecord {

llvm/include/llvm/MC/MCStreamer.h

 #ifndef LLVM_MC_MCSTREAMER_H
 #define LLVM_MC_MCSTREAMER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/SMLoc.h"
 #include "llvm/Support/TargetParser.h"
 #include "llvm/Support/VersionTuple.h"
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
 class AssemblerConstantPools;
 class formatted_raw_ostream;
 class MCAsmBackend;
 class MCCodeEmitter;
 struct MCCodePaddingContext;
 class MCContext;
 struct MCDwarfFrameInfo;
virtual void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
                                               const MCSymbol *FnEndSym);
 
   /// This implements the CodeView '.cv_def_range' assembler
   /// directive.
   virtual void EmitCVDefRangeDirective(
       ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
       StringRef FixedSizePortion);
 
+  virtual void EmitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeRegisterRelSym::Header DRHdr);
+
+  virtual void EmitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeSubfieldRegisterSym::Header DRHdr);
+
+  virtual void EmitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeRegisterSym::Header DRHdr);
+
+  virtual void EmitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeFramePointerRelSym::Header DRHdr);
+
   /// This implements the CodeView '.cv_stringtable' assembler directive.
   virtual void EmitCVStringTableDirective() {}
 
   /// This implements the CodeView '.cv_filechecksums' assembler directive.
   virtual void EmitCVFileChecksumsDirective() {}
 
   /// This implements the CodeView '.cv_filechecksumoffset' assembler
   /// directive.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

for (const LocalVariable *L : Params)
     emitLocalVariable(FI, *L);
 
   // Next emit all non-parameters in the order that we found them.
   for (const LocalVariable &L : Locals)
     if (!L.DIVar->isParameter())
       emitLocalVariable(FI, L);
 }
 
-/// Only call this on endian-specific types like ulittle16_t and little32_t, or
-/// structs composed of them.
-template <typename T>
-static void copyBytesForDefRange(SmallString<20> &BytePrefix,
-                                 SymbolKind SymKind, const T &DefRangeHeader) {
-  BytePrefix.resize(2 + sizeof(T));
-  ulittle16_t SymKindLE = ulittle16_t(SymKind);
-  memcpy(&BytePrefix[0], &SymKindLE, 2);
-  memcpy(&BytePrefix[2], &DefRangeHeader, sizeof(T));
-}
-
 void CodeViewDebug::emitLocalVariable(const FunctionInfo &FI,
                                       const LocalVariable &Var) {
   // LocalSym record, see SymbolRecord.h for more info.
   MCSymbol *LocalEnd = beginSymbolRecord(SymbolKind::S_LOCAL);
 
   LocalSymFlags Flags = LocalSymFlags::None;
   if (Var.DIVar->isParameter())
     Flags |= LocalSymFlags::IsParameter;
if (DefRange.InMemory) {
       // If we can use the chosen frame pointer for the frame and this isn't a
       // sliced aggregate, use the smaller S_DEFRANGE_FRAMEPOINTER_REL record.
       // Otherwise, use S_DEFRANGE_REGISTER_REL.
       EncodedFramePtrReg EncFP = encodeFramePtrReg(RegisterId(Reg), TheCPU);
       if (!DefRange.IsSubfield && EncFP != EncodedFramePtrReg::None &&
           (bool(Flags & LocalSymFlags::IsParameter)
                ? (EncFP == FI.EncodedParamFramePtrReg)
                : (EncFP == FI.EncodedLocalFramePtrReg))) {
-        little32_t FPOffset = little32_t(Offset);
-        copyBytesForDefRange(BytePrefix, S_DEFRANGE_FRAMEPOINTER_REL, FPOffset);
+        DefRangeFramePointerRelSym::Header DRHdr;
+        DRHdr.Offset = Offset;
+        OS.EmitCVDefRangeDirective(DefRange.Ranges, DRHdr);
       } else {
         uint16_t RegRelFlags = 0;
         if (DefRange.IsSubfield) {
           RegRelFlags = DefRangeRegisterRelSym::IsSubfieldFlag |
                         (DefRange.StructOffset
                          << DefRangeRegisterRelSym::OffsetInParentShift);
         }
         DefRangeRegisterRelSym::Header DRHdr;
         DRHdr.Register = Reg;
         DRHdr.Flags = RegRelFlags;
         DRHdr.BasePointerOffset = Offset;
-        copyBytesForDefRange(BytePrefix, S_DEFRANGE_REGISTER_REL, DRHdr);
+        OS.EmitCVDefRangeDirective(DefRange.Ranges, DRHdr);
       }
     } else {
       assert(DefRange.DataOffset == 0 && "unexpected offset into register");
       if (DefRange.IsSubfield) {
         DefRangeSubfieldRegisterSym::Header DRHdr;
         DRHdr.Register = DefRange.CVRegister;
         DRHdr.MayHaveNoName = 0;
         DRHdr.OffsetInParent = DefRange.StructOffset;
-        copyBytesForDefRange(BytePrefix, S_DEFRANGE_SUBFIELD_REGISTER, DRHdr);
+        OS.EmitCVDefRangeDirective(DefRange.Ranges, DRHdr);
       } else {
         DefRangeRegisterSym::Header DRHdr;
         DRHdr.Register = DefRange.CVRegister;
         DRHdr.MayHaveNoName = 0;
-        copyBytesForDefRange(BytePrefix, S_DEFRANGE_REGISTER, DRHdr);
+        OS.EmitCVDefRangeDirective(DefRange.Ranges, DRHdr);
       }
     }
-    OS.EmitCVDefRangeDirective(DefRange.Ranges, BytePrefix);
   }
 }
 
 void CodeViewDebug::emitLexicalBlockList(ArrayRef<LexicalBlock *> Blocks,
                                          const FunctionInfo& FI) {
   for (LexicalBlock *Block : Blocks)
     emitLexicalBlock(*Block, FI);
 }

llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp

Error CVSymbolDumperImpl::visitKnownRecord(
     CVSymbol &CVR,
     DefRangeFramePointerRelFullScopeSym &DefRangeFramePointerRelFullScope) {
   W.printNumber("Offset", DefRangeFramePointerRelFullScope.Offset);
   return Error::success();
 }
 
 Error CVSymbolDumperImpl::visitKnownRecord(
     CVSymbol &CVR, DefRangeFramePointerRelSym &DefRangeFramePointerRel) {
-  W.printNumber("Offset", DefRangeFramePointerRel.Offset);
+  W.printNumber("Offset", DefRangeFramePointerRel.Hdr.Offset);
   printLocalVariableAddrRange(DefRangeFramePointerRel.Range,
                               DefRangeFramePointerRel.getRelocationOffset());
   printLocalVariableAddrGap(DefRangeFramePointerRel.Gaps);
   return Error::success();
 }
 
 Error CVSymbolDumperImpl::visitKnownRecord(
     CVSymbol &CVR, DefRangeRegisterRelSym &DefRangeRegisterRel) {

llvm/lib/DebugInfo/CodeView/SymbolRecordMapping.cpp

Error SymbolRecordMapping::visitKnownRecord(CVSymbol &CVR, DataSym &Data) {
   error(IO.mapStringZ(Data.Name));
 
   return Error::success();
 }
 
 Error SymbolRecordMapping::visitKnownRecord(
     CVSymbol &CVR, DefRangeFramePointerRelSym &DefRangeFramePointerRel) {
 
-  error(IO.mapInteger(DefRangeFramePointerRel.Offset));
+  error(IO.mapObject(DefRangeFramePointerRel.Hdr.Offset));
   error(mapLocalVariableAddrRange(IO, DefRangeFramePointerRel.Range));
   error(IO.mapVectorTail(DefRangeFramePointerRel.Gaps, MapGap()));
 
   return Error::success();
 }
 
 Error SymbolRecordMapping::visitKnownRecord(
     CVSymbol &CVR,

llvm/lib/MC/MCAsmStreamer.cpp

void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
                           StringRef FileName, SMLoc Loc) override;
   void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *FnStart,
                                 const MCSymbol *FnEnd) override;
   void EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
                                       unsigned SourceFileId,
                                       unsigned SourceLineNum,
                                       const MCSymbol *FnStartSym,
                                       const MCSymbol *FnEndSym) override;
+
+  void PrintCVDefRangePrefix(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges);
+
+  void EmitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeRegisterRelSym::Header DRHdr) override;
+
   void EmitCVDefRangeDirective(
       ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
-      StringRef FixedSizePortion) override;
+      codeview::DefRangeSubfieldRegisterSym::Header DRHdr) override;
+
+  void EmitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeRegisterSym::Header DRHdr) override;
+
+  void EmitCVDefRangeDirective(
+      ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+      codeview::DefRangeFramePointerRelSym::Header DRHdr) override;
+
   void EmitCVStringTableDirective() override;
   void EmitCVFileChecksumsDirective() override;
   void EmitCVFileChecksumOffsetDirective(unsigned FileNo) override;
   void EmitCVFPOData(const MCSymbol *ProcSym, SMLoc L) override;
 
   void EmitIdent(StringRef IdentString) override;
   void EmitCFIBKeyFrame() override;
   void EmitCFISections(bool EH, bool Debug) override;
void MCAsmStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
   FnStartSym->print(OS, MAI);
   OS << ' ';
   FnEndSym->print(OS, MAI);
   EmitEOL();
   this->MCStreamer::EmitCVInlineLinetableDirective(
       PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym);
 }
 
-void MCAsmStreamer::EmitCVDefRangeDirective(
-    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
-    StringRef FixedSizePortion) {
+void MCAsmStreamer::PrintCVDefRangePrefix(
+    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges) {
   OS << "\t.cv_def_range\t";
   for (std::pair<const MCSymbol *, const MCSymbol *> Range : Ranges) {
     OS << ' ';
     Range.first->print(OS, MAI);
     OS << ' ';
     Range.second->print(OS, MAI);
   }
-  OS << ", ";
-  PrintQuotedString(FixedSizePortion, OS);
+}
+
+void MCAsmStreamer::EmitCVDefRangeDirective(
+    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+    codeview::DefRangeRegisterRelSym::Header DRHdr) {
+  PrintCVDefRangePrefix(Ranges);
+  OS << ", reg_rel, ";
+  OS << DRHdr.Register << ", " << DRHdr.Flags << ", "
+     << DRHdr.BasePointerOffset;
+  EmitEOL();
+}
+
+void MCAsmStreamer::EmitCVDefRangeDirective(
+    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+    codeview::DefRangeSubfieldRegisterSym::Header DRHdr) {
+  PrintCVDefRangePrefix(Ranges);
+  OS << ", subfield_reg, ";
+  OS << DRHdr.Register << ", " << DRHdr.OffsetInParent;
+  EmitEOL();
+}
+
+void MCAsmStreamer::EmitCVDefRangeDirective(
+    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+    codeview::DefRangeRegisterSym::Header DRHdr) {
+  PrintCVDefRangePrefix(Ranges);
+  OS << ", reg, ";
+  OS << DRHdr.Register;
+  EmitEOL();
+}
+
+void MCAsmStreamer::EmitCVDefRangeDirective(
+    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+    codeview::DefRangeFramePointerRelSym::Header DRHdr) {
+  PrintCVDefRangePrefix(Ranges);
+  OS << ", frame_ptr_rel, ";
+  OS << DRHdr.Offset;
   EmitEOL();
-  this->MCStreamer::EmitCVDefRangeDirective(Ranges, FixedSizePortion);
 }
 
 void MCAsmStreamer::EmitCVStringTableDirective() {
   OS << "\t.cv_stringtable";
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitCVFileChecksumsDirective() {
   OS << "\t.cv_filechecksums";
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitCVFileChecksumOffsetDirective(unsigned FileNo) {
   OS << "\t.cv_filechecksumoffset\t" << FileNo;
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitCVFPOData(const MCSymbol *ProcSym, SMLoc L) {
   OS << "\t.cv_fpo_data\t";
   ProcSym->print(OS, MAI);
   EmitEOL();
 }

llvm/lib/MC/MCParser/AsmParser.cpp

enum DirectiveKind {
     DK_ADDRSIG_SYM,
     DK_END
   };
 
   /// Maps directive name --> DirectiveKind enum, for
   /// directives parsed by this class.
   StringMap<DirectiveKind> DirectiveKindMap;
 
+  // Codeview def_range type parsing.
+  enum CVDefRangeType {
+    CVDR_DEFRANGE = 0, // Placeholder
+    CVDR_DEFRANGE_REGISTER,
+    CVDR_DEFRANGE_FRAMEPOINTER_REL,
+    CVDR_DEFRANGE_SUBFIELD_REGISTER,
+    CVDR_DEFRANGE_REGISTER_REL
+  };
+
+  /// Maps Codeview def_range types --> CVDefRangeType enum, for
+  /// Codeview def_range types parsed by this class.
+  StringMap<CVDefRangeType> CVDefRangeTypeMap;
+
   // ".ascii", ".asciz", ".string"
   bool parseDirectiveAscii(StringRef IDVal, bool ZeroTerminated);
   bool parseDirectiveReloc(SMLoc DirectiveLoc); // ".reloc"
   bool parseDirectiveValue(StringRef IDVal,
                            unsigned Size);       // ".byte", ".long", ...
   bool parseDirectiveOctaValue(StringRef IDVal); // ".octa", ...
   bool parseDirectiveRealValue(StringRef IDVal,
                                const fltSemantics &); // ".single", ...
private:
   // .print <double-quotes-string>
   bool parseDirectivePrint(SMLoc DirectiveLoc);
 
   // Directives to support address-significance tables.
   bool parseDirectiveAddrsig();
   bool parseDirectiveAddrsigSym();
 
   void initializeDirectiveKindMap();
+  void initializeCVDefRangeTypeMap();
 };
 
 } // end anonymous namespace
 
 namespace llvm {
 
 extern MCAsmParserExtension *createDarwinAsmParser();
 extern MCAsmParserExtension *createELFAsmParser();
case MCObjectFileInfo::IsWasm:
     break;
   case MCObjectFileInfo::IsXCOFF:
     // TODO: Need to implement createXCOFFAsmParser for XCOFF format.
     break;
   }
 
   PlatformParser->Initialize(*this);
   initializeDirectiveKindMap();
+  initializeCVDefRangeTypeMap();
 
   NumOfMacroInstantiations = 0;
 }
 
 AsmParser::~AsmParser() {
   assert((HadError || ActiveMacros.empty()) &&
          "Unexpected active macro instantiation!");
 
bool AsmParser::parseStatement(ParseStatementInfo &Info,
   }
 
   // Handle conditional assembly here before checking for skipping.  We
   // have to do this so that .endif isn't skipped in a ".if 0" block for
   // example.
   StringMap<DirectiveKind>::const_iterator DirKindIt =
       DirectiveKindMap.find(IDVal);
   DirectiveKind DirKind = (DirKindIt == DirectiveKindMap.end())
+
                               ? DK_NO_DIRECTIVE
                               : DirKindIt->getValue();
   switch (DirKind) {
   default:
     break;
   case DK_IF:
   case DK_IFEQ:
   case DK_IFGE:
bool AsmParser::parseDirectiveCVInlineLinetable() {
   MCSymbol *FnStartSym = getContext().getOrCreateSymbol(FnStartName);
   MCSymbol *FnEndSym = getContext().getOrCreateSymbol(FnEndName);
   getStreamer().EmitCVInlineLinetableDirective(PrimaryFunctionId, SourceFileId,
                                                SourceLineNum, FnStartSym,
                                                FnEndSym);
   return false;
 }
 
+void AsmParser::initializeCVDefRangeTypeMap() {
+  CVDefRangeTypeMap["reg"] = CVDR_DEFRANGE_REGISTER;
+  CVDefRangeTypeMap["frame_ptr_rel"] = CVDR_DEFRANGE_FRAMEPOINTER_REL;
+  CVDefRangeTypeMap["subfield_reg"] = CVDR_DEFRANGE_SUBFIELD_REGISTER;
+  CVDefRangeTypeMap["reg_rel"] = CVDR_DEFRANGE_REGISTER_REL;
+}
+
 /// parseDirectiveCVDefRange
 /// ::= .cv_def_range RangeStart RangeEnd (GapStart GapEnd)*, bytes*
 bool AsmParser::parseDirectiveCVDefRange() {
   SMLoc Loc;
   std::vector<std::pair<const MCSymbol *, const MCSymbol *>> Ranges;
   while (getLexer().is(AsmToken::Identifier)) {
     Loc = getLexer().getLoc();
     StringRef GapStartName;
     if (parseIdentifier(GapStartName))
       return Error(Loc, "expected identifier in directive");
     MCSymbol *GapStartSym = getContext().getOrCreateSymbol(GapStartName);
 
     Loc = getLexer().getLoc();
     StringRef GapEndName;
     if (parseIdentifier(GapEndName))
       return Error(Loc, "expected identifier in directive");
     MCSymbol *GapEndSym = getContext().getOrCreateSymbol(GapEndName);
 
     Ranges.push_back({GapStartSym, GapEndSym});
   }
 
-  std::string FixedSizePortion;
-  if (parseToken(AsmToken::Comma, "unexpected token in directive") ||
-      parseEscapedString(FixedSizePortion))
-    return true;
-
-  getStreamer().EmitCVDefRangeDirective(Ranges, FixedSizePortion);
-  return false;
+  StringRef CVDefRangeTypeStr;
+  if (parseToken(
+          AsmToken::Comma,
+          "expected comma before def_range type in .cv_def_range directive") ||
+      parseIdentifier(CVDefRangeTypeStr))
+    return Error(Loc, "expected def_range type in directive");
+
+  StringMap<CVDefRangeType>::const_iterator CVTypeIt =
+      CVDefRangeTypeMap.find(CVDefRangeTypeStr);
+  CVDefRangeType CVDRType = (CVTypeIt == CVDefRangeTypeMap.end())
+                                ? CVDR_DEFRANGE
+                                : CVTypeIt->getValue();
+  switch (CVDRType) {
+  case CVDR_DEFRANGE_REGISTER: {
+    int64_t DRRegister;
+    if (parseToken(AsmToken::Comma, "expected comma before register number in "
+                                    ".cv_def_range directive") ||
+        parseAbsoluteExpression(DRRegister))
+      return Error(Loc, "expected register number");
+
+    codeview::DefRangeRegisterSym::Header DRHdr;
+    DRHdr.Register = DRRegister;
+    getStreamer().EmitCVDefRangeDirective(Ranges, DRHdr);
+    break;
+  }
+  case CVDR_DEFRANGE_FRAMEPOINTER_REL: {
+    int64_t DROffset;
+    if (parseToken(AsmToken::Comma,
+                   "expected comma before offset in .cv_def_range directive") ||
+        parseAbsoluteExpression(DROffset))
+      return Error(Loc, "expected offset value");
+
+    codeview::DefRangeFramePointerRelSym::Header DRHdr;
+    DRHdr.Offset = DROffset;
+    getStreamer().EmitCVDefRangeDirective(Ranges, DRHdr);
+    break;
+  }
+  case CVDR_DEFRANGE_SUBFIELD_REGISTER: {
+    int64_t DRRegister;
+    int64_t DROffsetInParent;
+    if (parseToken(AsmToken::Comma, "expected comma before register number in "
+                                    ".cv_def_range directive") ||
+        parseAbsoluteExpression(DRRegister))
+      return Error(Loc, "expected register number");
+    if (parseToken(AsmToken::Comma,
+                   "expected comma before offset in .cv_def_range directive") ||
+        parseAbsoluteExpression(DROffsetInParent))
+      return Error(Loc, "expected offset value");
+
+    codeview::DefRangeSubfieldRegisterSym::Header DRHdr;
+    DRHdr.Register = DRRegister;
+    DRHdr.OffsetInParent = DROffsetInParent;
+    getStreamer().EmitCVDefRangeDirective(Ranges, DRHdr);
+    break;
+  }
+  case CVDR_DEFRANGE_REGISTER_REL: {
+    int64_t DRRegister;
+    int64_t DRFlags;
+    int64_t DRBasePointerOffset;
+    if (parseToken(AsmToken::Comma, "expected comma before register number in "
+                                    ".cv_def_range directive") ||
+        parseAbsoluteExpression(DRRegister))
+      return Error(Loc, "expected register value");
+    if (parseToken(
+            AsmToken::Comma,
+            "expected comma before flag value in .cv_def_range directive") ||
+        parseAbsoluteExpression(DRFlags))
+      return Error(Loc, "expected flag value");
+    if (parseToken(AsmToken::Comma, "expected comma before base pointer offset "
+                                    "in .cv_def_range directive") ||
+        parseAbsoluteExpression(DRBasePointerOffset))
+      return Error(Loc, "expected base pointer offset value");
+
+    codeview::DefRangeRegisterRelSym::Header DRHdr;
+    DRHdr.Register = DRRegister;
+    DRHdr.Flags = DRFlags;
+    DRHdr.BasePointerOffset = DRBasePointerOffset;
+    getStreamer().EmitCVDefRangeDirective(Ranges, DRHdr);
+    break;
+  }
+  default:
+    return Error(Loc, "unexpected def_range type in .cv_def_range directive");
+  }
 }
 
 /// parseDirectiveCVString
 /// ::= .cv_stringtable "string"
 bool AsmParser::parseDirectiveCVString() {
   std::string Data;
   if (checkForValidSection() || parseEscapedString(Data))
     return addErrorSuffix(" in '.cv_string' directive");

llvm/lib/MC/MCStreamer.cpp

void MCStreamer::EmitCVLinetableDirective(unsigned FunctionId,
                                           const MCSymbol *End) {}
 
 void MCStreamer::EmitCVInlineLinetableDirective(unsigned PrimaryFunctionId,
                                                 unsigned SourceFileId,
                                                 unsigned SourceLineNum,
                                                 const MCSymbol *FnStartSym,
                                                 const MCSymbol *FnEndSym) {}
 
+/// Only call this on endian-specific types like ulittle16_t and little32_t, or
+/// structs composed of them.
+template <typename T>
+static void copyBytesForDefRange(SmallString<20> &BytePrefix,
+                                 codeview::SymbolKind SymKind,
+                                 const T &DefRangeHeader) {
+  BytePrefix.resize(2 + sizeof(T));
+  codeview::ulittle16_t SymKindLE = codeview::ulittle16_t(SymKind);
+  memcpy(&BytePrefix[0], &SymKindLE, 2);
+  memcpy(&BytePrefix[2], &DefRangeHeader, sizeof(T));
+}
+
 void MCStreamer::EmitCVDefRangeDirective(
     ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
     StringRef FixedSizePortion) {}
 
+void MCStreamer::EmitCVDefRangeDirective(
+    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+    codeview::DefRangeRegisterRelSym::Header DRHdr) {
+  SmallString<20> BytePrefix;
+  copyBytesForDefRange(BytePrefix, codeview::S_DEFRANGE_REGISTER_REL, DRHdr);
+  EmitCVDefRangeDirective(Ranges, BytePrefix);
+}
+
+void MCStreamer::EmitCVDefRangeDirective(
+    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+    codeview::DefRangeSubfieldRegisterSym::Header DRHdr) {
+  SmallString<20> BytePrefix;
+  copyBytesForDefRange(BytePrefix, codeview::S_DEFRANGE_SUBFIELD_REGISTER,
+                       DRHdr);
+  EmitCVDefRangeDirective(Ranges, BytePrefix);
+}
+
+void MCStreamer::EmitCVDefRangeDirective(
+    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+    codeview::DefRangeRegisterSym::Header DRHdr) {
+  SmallString<20> BytePrefix;
+  copyBytesForDefRange(BytePrefix, codeview::S_DEFRANGE_REGISTER, DRHdr);
+  EmitCVDefRangeDirective(Ranges, BytePrefix);
+}
+
+void MCStreamer::EmitCVDefRangeDirective(
+    ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
+    codeview::DefRangeFramePointerRelSym::Header DRHdr) {
+  SmallString<20> BytePrefix;
+  copyBytesForDefRange(BytePrefix, codeview::S_DEFRANGE_FRAMEPOINTER_REL,
+                       DRHdr);
+  EmitCVDefRangeDirective(Ranges, BytePrefix);
+}
+
 void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
                                      MCSymbol *EHSymbol) {
 }
 
 void MCStreamer::InitSections(bool NoExecStack) {
   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
 }
 

llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp

 template <> void SymbolRecordImpl<DefRangeRegisterSym>::map(IO &IO) {
   IO.mapRequired("Register", Symbol.Hdr.Register);
   IO.mapRequired("MayHaveNoName", Symbol.Hdr.MayHaveNoName);
   IO.mapRequired("Range", Symbol.Range);
   IO.mapRequired("Gaps", Symbol.Gaps);
 }
 
 template <> void SymbolRecordImpl<DefRangeFramePointerRelSym>::map(IO &IO) {
-  IO.mapRequired("Offset", Symbol.Offset);
+  IO.mapRequired("Offset", Symbol.Hdr.Offset);
   IO.mapRequired("Range", Symbol.Range);
   IO.mapRequired("Gaps", Symbol.Gaps);
 }
 
 template <> void SymbolRecordImpl<DefRangeSubfieldRegisterSym>::map(IO &IO) {
   IO.mapRequired("Register", Symbol.Hdr.Register);
   IO.mapRequired("MayHaveNoName", Symbol.Hdr.MayHaveNoName);
   IO.mapRequired("OffsetInParent", Symbol.Hdr.OffsetInParent);

llvm/test/DebugInfo/COFF/fp-stack.ll

 ; RUN: llc -mtriple=i686-windows-msvc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -mtriple=i686-windows-msvc < %s -filetype=obj | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc18.0.0"
 
 define double @f(double %p1) !dbg !4 {
 entry:
   %sub = fsub double -0.000000e+00, %p1, !dbg !16
   tail call void @llvm.dbg.value(metadata double %sub, metadata !10, metadata !14), !dbg !15
   ret double %sub
 }
 
-; ASM:         .cv_def_range    Ltmp1 Lfunc_end0, "A\021\200\000\000\000"
+; ASM:         .cv_def_range    Ltmp1 Lfunc_end0, reg, 128
 ; OBJ:    DefRangeRegisterSym {
 ; OBJ:      Register: ST0 (0x80)
 ; OBJ:      MayHaveNoName: 0
 ; OBJ:      LocalVariableAddrRange {
 ; OBJ:        OffsetStart: .text+0x6
 ; OBJ:        ISectStart: 0x0
 ; OBJ:        Range: 0x1
 ; OBJ:      }

llvm/test/DebugInfo/COFF/local-variable-gap.ll

 ; ASM:         ud2
 ; ASM: .Lfunc_end0:
 
 ; ASM:         .short  {{.*}}         # Record length
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .long   116                     # TypeIndex
 ; ASM:         .short  0                       # Flags
 ; ASM:         .asciz  "p"
-; ASM:         .cv_def_range    [[p_b1]] [[p_e1]] [[p_b2]] .Lfunc_end0, "A\021\027\000\000\000"
+; ASM:         .cv_def_range    [[p_b1]] [[p_e1]] [[p_b2]] .Lfunc_end0, reg, 23
 ; ASM:         .short  2                       # Record length
 ; ASM:         .short  4431                    # Record kind: S_PROC_ID_END
 
 ; OBJ:         LocalSym {
 ; OBJ:           Type: int (0x74)
 ; OBJ:           VarName: p
 ; OBJ:         }
 ; OBJ-NOT:     LocalSym {

llvm/test/DebugInfo/COFF/local-variables.ll

 ; ASM:         addq    $56, %rsp
 ; ASM:         retq
 ; ASM: [[param_end:\.Ltmp.*]]:
 
 ; ASM: .short  4414                    # Record kind: S_LOCAL
 ; ASM: .long   116                     # TypeIndex
 ; ASM: .short  1                       # Flags
 ; ASM: .asciz  "param"
-; ASM: .cv_def_range    [[prologue_end]] [[param_end]], "B\0214\000\000\000"
+; ASM: .cv_def_range    [[prologue_end]] [[param_end]], frame_ptr_rel, 52
 ; ASM: .short  4414                    # Record kind: S_LOCAL
 ; ASM: .long   116                     # TypeIndex
 ; ASM: .short  0                       # Flags
 ; ASM: .asciz  "a"
-; ASM: .cv_def_range    [[if_start]] [[else_start]], "B\021(\000\000\000"
+; ASM: .cv_def_range    [[if_start]] [[else_start]], frame_ptr_rel, 40
 ; ASM: .short  4414                    # Record kind: S_LOCAL
 ; ASM: .long   116                     # TypeIndex
 ; ASM: .short  0                       # Flags
 ; ASM: .asciz  "b"
-; ASM: .cv_def_range    [[else_start]] [[else_end]], "B\021$\000\000\000"
+; ASM: .cv_def_range    [[else_start]] [[else_end]], frame_ptr_rel, 36
 ; ASM: .short  4429                    # Record kind: S_INLINESITE
 ; ASM: .short  4414                    # Record kind: S_LOCAL
 ; ASM: .long   116                     # TypeIndex
 ; ASM: .short  0                       # Flags
 ; ASM: .asciz  "v"
-; ASM: .cv_def_range    [[inline_site1]] [[else_start]], "B\021,\000\000\000"
+; ASM: .cv_def_range    [[inline_site1]] [[else_start]], frame_ptr_rel, 44
 ; ASM: .short  4430                    # Record kind: S_INLINESITE_END
 ; ASM: .short  4429                    # Record kind: S_INLINESITE
 ; ASM: .short  4414                    # Record kind: S_LOCAL
 ; ASM: .long   116                     # TypeIndex
 ; ASM: .short  0                       # Flags
 ; ASM: .asciz  "v"
-; ASM: .cv_def_range    [[inline_site2]] [[else_end]], "B\0210\000\000\000"
+; ASM: .cv_def_range    [[inline_site2]] [[else_end]], frame_ptr_rel, 48
 ; ASM: .short  4430                    # Record kind: S_INLINESITE_END
 
 ; OBJ:  Subsection [
 ; OBJ:    SubSectionType: Symbols (0xF1)
 ; OBJ:    {{.*}}Proc{{.*}}Sym {
 ; OBJ:      DisplayName: f
 ; OBJ:      LinkageName: f
 ; OBJ:    }

llvm/test/DebugInfo/COFF/nrvo.ll

 
 ; ASM-LABEL:  .long  241                      # Symbol subsection for GetFoo
 ; ASM:        .short 4414                     # Record kind: S_LOCAL
 ; ASM-NEXT:   .long 4113                      # TypeIndex
 ; ASM-NEXT:   .short 0                        # Flags
 ; ASM-NEXT:   .asciz "foo"
 ; ASM-NEXT:   .p2align 2
 ; ASM-NEXT: .Ltmp
-; ASM:        .cv_def_range  .Ltmp{{.*}} .Ltmp{{.*}}, "B\021(\000\000\000"
+; ASM:        .cv_def_range  .Ltmp{{.*}} .Ltmp{{.*}}, frame_ptr_rel, 40
 
 ; OBJ: Subsection [
 ; OBJ:   SubSectionType: Symbols (0xF1)
 ; OBJ:   LocalSym {
 ; OBJ:     Kind: S_LOCAL (0x113E)
 ; OBJ:     Type: Foo& (0x1011)
 ; OBJ:     Flags [ (0x0)
 ; OBJ:     ]

llvm/test/DebugInfo/COFF/pieces.ll

 ; ASM-NEXT: [[spill_o_x_end:\.Ltmp[0-9]+]]:
 ; ASM-NEXT: .Lfunc_end4:
 
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "loop_csr"              # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    [[oy_ox_start]] [[ox_start]], "C\021\030\000\000\000\000\000\000\000"
-; ASM:        .cv_def_range    [[oy_ox_start]] [[oy_start]], "C\021\027\000\000\000\004\000\000\000"
-; ASM:        .cv_def_range    [[ox_start]] [[loopskip_start]], "C\021\030\000\000\000\000\000\000\000"
-; ASM:        .cv_def_range    [[oy_start]] [[loopskip_start]], "C\021\027\000\000\000\004\000\000\000"
+; ASM:        .cv_def_range    [[oy_ox_start]] [[ox_start]], subfield_reg, 24, 0
+; ASM:        .cv_def_range    [[oy_ox_start]] [[oy_start]], subfield_reg, 23, 4
+; ASM:        .cv_def_range    [[ox_start]] [[loopskip_start]], subfield_reg, 24, 0
+; ASM:        .cv_def_range    [[oy_start]] [[loopskip_start]], subfield_reg, 23, 4
 
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: loop_csr
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o

 ; OBJ:       }
 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "pad_right"             # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    [[pad_right_tmp]] [[pad_right_tmp]], "C\021\021\000\000\000\004\000\000\000"
+; ASM:        .cv_def_range    [[pad_right_tmp]] [[pad_right_tmp]], subfield_reg, 17, 4
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: pad_right
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o
 ; OBJ:       }
 ; OBJ:       DefRangeSubfieldRegisterSym {
 ; OBJ:         Register: EAX (0x11)
 ; OBJ:         MayHaveNoName: 0
 ; OBJ:         OffsetInParent: 4
 ; OBJ:         LocalVariableAddrRange {
 ; OBJ:         }
 ; OBJ:       }
 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "pad_left"              # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    [[pad_left_tmp]] [[pad_left_tmp]], "C\021\021\000\000\000\000\000\000\000"
+; ASM:        .cv_def_range    [[pad_left_tmp]] [[pad_left_tmp]], subfield_reg, 17, 0
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: pad_left
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o
 ; OBJ:       }
 ; OBJ:       DefRangeSubfieldRegisterSym {
 ; OBJ:         Register: EAX (0x11)
 ; OBJ:         MayHaveNoName: 0
 ; OBJ:         OffsetInParent: 0
 ; OBJ:         LocalVariableAddrRange {
 ; OBJ:         }
 ; OBJ:       }
 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "nested"                # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    .Lfunc_begin3 .Lfunc_end3, "E\021J\001\000\000\000\000\000\000"
+; ASM:        .cv_def_range    .Lfunc_begin3 .Lfunc_end3, reg_rel, 330, 0, 0
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "p"
-; ASM:        .cv_def_range    [[p_start]] .Lfunc_end3, "C\021\021\000\000\000\004\000\000\000"
+; ASM:        .cv_def_range    [[p_start]] .Lfunc_end3, subfield_reg, 17, 4
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: nested
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         Type: Nested&
 ; OBJ:         VarName: o

 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "bitpiece_spill"        # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    [[spill_o_x_start]] .Lfunc_end4, "E\021O\001A\000$\000\000\000"
+; ASM:        .cv_def_range    [[spill_o_x_start]] .Lfunc_end4, reg_rel, 335, 65, 36
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: bitpiece_spill
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o
 ; OBJ:       }

llvm/test/DebugInfo/COFF/register-variables.ll

 ; ASM:         movl    %eax, %ecx
 ; ASM:         addq    $32, %rsp
 ; ASM:         popq    %rsi
 ; ASM: [[func_end:\.Ltmp.*]]:
 ; ASM:         jmp     putint                  # TAILCALL
 
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "p"
-; ASM:         .cv_def_range    .Lfunc_begin0 [[p_ecx_esi]], "A\021\022\000\000\000"
-; ASM:         .cv_def_range    [[p_ecx_esi]] [[func_end]], "A\021\027\000\000\000"
+; ASM:         .cv_def_range    .Lfunc_begin0 [[p_ecx_esi]], reg, 18
+; ASM:         .cv_def_range    [[p_ecx_esi]] [[func_end]], reg, 23
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "c"
-; ASM:         .cv_def_range    [[after_getint]] [[after_je]], "A\021\021\000\000\000"
+; ASM:         .cv_def_range    [[after_getint]] [[after_je]], reg, 17
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "a"
-; ASM:         .cv_def_range    [[after_getint]] [[after_inc_eax]], "A\021\021\000\000\000"
+; ASM:         .cv_def_range    [[after_getint]] [[after_inc_eax]], reg, 17
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "b"
-; ASM:         .cv_def_range    [[after_inc_eax]] [[after_if]], "A\021\021\000\000\000"
+; ASM:         .cv_def_range    [[after_inc_eax]] [[after_if]], reg, 17
 
 ; ASM:         .short  4429                    # Record kind: S_INLINESITE
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "a"
-; ASM:         .cv_def_range    [[after_getint]] [[after_inc_eax]], "A\021\021\000\000\000"
+; ASM:         .cv_def_range    [[after_getint]] [[after_inc_eax]], reg, 17
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "b"
-; ASM:         .cv_def_range    [[after_inc_eax]] [[after_if]], "A\021\021\000\000\000"
+; ASM:         .cv_def_range    [[after_inc_eax]] [[after_if]], reg, 17
 ; ASM:         .short  4430                    # Record kind: S_INLINESITE_END
 
 ; OBJ: Subsection [
 ; OBJ:   SubSectionType: Symbols (0xF1)
 ; OBJ:   {{.*}}Proc{{.*}}Sym {
 ; OBJ:     DisplayName: f
 ; OBJ:   }
 ; OBJ:   LocalSym {

llvm/test/MC/COFF/cv-def-range-align.s

 .Ltmp12:
   .short  4414                    # Record kind: S_LOCAL
   .long 18                      # TypeIndex
   .short  1                       # Flags
   .asciz  "a"
   # BUG
   .p2align 2
 .Ltmp13:
-  .cv_def_range  .Ltmp0 .Ltmp1, "B\021\000\000\000\000"
+  .cv_def_range   .Ltmp0 .Ltmp1, frame_ptr_rel, 8
   .short  .Ltmp15-.Ltmp14         # Record length
 .Ltmp14:
   .short  4414                    # Record kind: S_LOCAL
   .long 18                      # TypeIndex
   .short  1                       # Flags
   .asciz  "b"
   # BUG
   .p2align 2
 .Ltmp15:
-  .cv_def_range  .Ltmp0 .Ltmp1, "B\021\004\000\000\000"
+  .cv_def_range   .Ltmp0 .Ltmp1, frame_ptr_rel, 8
   .short  2                       # Record length
   .short  4431                    # Record kind: S_PROC_ID_END
 .Ltmp7:
   .p2align  2
   .cv_linetable 0, max, .Lfunc_end0
   .cv_filechecksums               # File index to string table offset subsection
   .cv_stringtable                 # String table
   .long 241

llvm/test/MC/COFF/cv-def-range-errors.s

+# RUN: not llvm-mc < %s -filetype=obj --triple=x86_64-windows -o /dev/null 2>&1 | FileCheck %s
+
+.cv_def_range  .Ltmp1 .Ltmp2
+# CHECK: error: expected comma before def_range type in .cv_def_range directive
+# CHECK: error: expected def_range type in directive
+
+.cv_def_range  .Ltmp1 .Ltmp2,
+# CHECK: error: expected def_range type in directive
+
+.cv_def_range  .Ltmp1 .Ltmp2, subfield_reg
+# CHECK: error: expected comma before register number in .cv_def_range directive
+# CHECK: error: expected register number
+
+.cv_def_range  .Ltmp1 .Ltmp2, subfield_reg,
+# CHECK: error: unknown token in expression
+# CHECK: error: expected register number
+
+.cv_def_range  .Ltmp1 .Ltmp2, subfield_reg, 25
+# CHECK: error: expected comma before offset in .cv_def_range directive
+# CHECK: error: expected offset value
+
+.cv_def_range  .Ltmp1 .Ltmp2, subfield_reg, 25,
+# CHECK: error: unknown token in expression
+# CHECK: error: expected offset value
+
+
+
+
+.cv_def_range    .Ltmp1 .Ltmp2
+# CHECK: error: expected comma before def_range type in .cv_def_range directive
+# CHECK: error: expected def_range type in directive
+
+.cv_def_range    .Ltmp1 .Ltmp2, 
+# CHECK: error: expected def_range type in directive
+
+.cv_def_range    .Ltmp1 .Ltmp2, reg
+# CHECK: error: expected comma before register number in .cv_def_range directive
+# CHECK: error: expected register number
+
+.cv_def_range    .Ltmp1 .Ltmp2, reg,
+# CHECK: error: unknown token in expression
+# CHECK: error: expected register number
+
+
+
+
+.cv_def_range    .Ltmp1 .Ltmp2
+# CHECK: error: expected comma before def_range type in .cv_def_range directive
+# CHECK: error: expected def_range type in directive
+
+.cv_def_range    .Ltmp1 .Ltmp2, 
+# CHECK: error: expected def_range type in directive
+
+.cv_def_range    .Ltmp1 .Ltmp2, frame_ptr_rel
+# CHECK: error: expected comma before offset in .cv_def_range directive
+# CHECK: error: expected offset value
+
+.cv_def_range    .Ltmp1 .Ltmp2, frame_ptr_rel,
+# CHECK: error: unknown token in expression
+# CHECK: error: expected offset value
+
+
+
+
+
+.cv_def_range    .Ltmp1 .Ltmp2
+# CHECK: error: expected comma before def_range type in .cv_def_range directive
+# CHECK: error: expected def_range type in directive
+
+.cv_def_range    .Ltmp1 .Ltmp2, 
+# CHECK: error: expected def_range type in directive
+
+.cv_def_range    .Ltmp1 .Ltmp2, reg_rel
+# CHECK: error: expected comma before register number in .cv_def_range directive
+# CHECK: error: expected register value
+
+.cv_def_range    .Ltmp1 .Ltmp2, reg_rel, 
+# CHECK: error: unknown token in expression
+# CHECK: error: expected register value
+
+.cv_def_range    .Ltmp1 .Ltmp2, reg_rel, 330
+# CHECK: error: expected comma before flag value in .cv_def_range directive
+# CHECK: error: expected flag value
+
+.cv_def_range    .Ltmp1 .Ltmp2, reg_rel, 330, 
+# CHECK: error: unknown token in expression
+# CHECK: error: expected flag value
+
+.cv_def_range    .Ltmp1 .Ltmp2, reg_rel, 330, 0
+# CHECK: error: expected comma before base pointer offset in .cv_def_range directive
+# CHECK: error: expected base pointer offset value
+
+.cv_def_range    .Ltmp1 .Ltmp2, reg_rel, 330, 0,
+# CHECK: error: unknown token in expression
+# CHECK: error: expected base pointer offset value

llvm/test/MC/COFF/cv-def-range-gap.s

 .Ltmp17:
   .short  .Ltmp19-.Ltmp18         # Record length
 .Ltmp18:
   .short  4414                    # Record kind: S_LOCAL
   .long 116                     # TypeIndex
   .short  0                       # Flags
   .asciz  "p"
 .Ltmp19:
-  .cv_def_range   .Lbegin0 .Lend0 .Lbegin1 .Lend1 .Lbegin2 .Lend2 .Lbegin3 .Lend3, "A\021\027\000\000\000"
-  .cv_def_range   .Lbegin4 .Lend4 .Lbegin5 .Lend5, "A\021\027\000\000\000"
+  .cv_def_range   .Lbegin0 .Lend0 .Lbegin1 .Lend1 .Lbegin2 .Lend2 .Lbegin3 .Lend3, reg, 23
+  .cv_def_range   .Lbegin4 .Lend4 .Lbegin5 .Lend5, reg, 23
   .short  2                       # Record length
   .short  4431                    # Record kind: S_PROC_ID_END
 .Ltmp15:
         .cv_filechecksums               # File index to string table offset subsection
         .cv_stringtable                 # String table

llvm/test/MC/COFF/cv-def-range.s

Ltmp2:
   .long 0                       # Function type index
   .secrel32 _g              # Function section relative address
   .secidx _g                      # Function section index
   .byte 0                       # Flags
   .asciz  "g"                     # Function name
 Ltmp3:
   .short  2                       # Record length
   .short  4431                    # Record kind: S_PROC_ID_END
-  .cv_def_range Lvar_begin0 Lvar_end0, "\102\021\374\377\377\377"
+  .cv_def_range  Lvar_begin0 Lvar_end0, frame_ptr_rel, -4
 
 # CHECK:    DefRangeFramePointerRelSym {
 # CHECK:      Offset: -4
 # CHECK:      LocalVariableAddrRange {
 # CHECK:        OffsetStart: .text+0x9
 # CHECK:        ISectStart: 0x0
 # CHECK:        Range: 0xF
 # CHECK:      }

llvm/tools/llvm-pdbutil/MinimalSymbolDumper.cpp

Error MinimalSymbolDumper::visitKnownRecord(
     CVSymbol &CVR, DefRangeFramePointerRelFullScopeSym &Def) {
   P.format(" offset = {0}", Def.Offset);
   return Error::success();
 }
 
 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
                                             DefRangeFramePointerRelSym &Def) {
   AutoIndent Indent(P, 7);
-  P.formatLine("offset = {0}, range = {1}", Def.Offset, formatRange(Def.Range));
-  P.formatLine("gaps = {2}", Def.Offset,
+  P.formatLine("offset = {0}, range = {1}", Def.Hdr.Offset,
+               formatRange(Def.Range));
+  P.formatLine("gaps = {2}", Def.Hdr.Offset,
                formatGaps(P.getIndentLevel() + 9, Def.Gaps));
   return Error::success();
 }
 
 Error MinimalSymbolDumper::visitKnownRecord(CVSymbol &CVR,
                                             DefRangeRegisterRelSym &Def) {
   AutoIndent Indent(P, 7);
   P.formatLine("register = {0}, offset = {1}, offset in parent = {2}, has "