[codeview] use S_BPREL32, S_REGREL32, and S_REGISTER records when appropriate

[inglorion]

Summary

We used to emit an S_LOCAL record and zero or more S_DEFRANGE* records
for every local variable. This change makes us emit a single S_BPREL32, S_REGREL32,
or S_REGISTER record for variables that can be described that way. This reduces
the size of the generated debug information.

[inglorion]

Thanks!

[inglorion]

I still need to update/add tests.

This shaves about 11 megabytes off the PDB size for opt:
Before: 307,671,040 bytes
After: 295,956,480 bytes

[zturner]

Unfortunately this seems to have virtually no effect on /DEBUG:FASTLINK PDB size :(. Still good to have anyway since /DEBUG:FULL PDB size is also important, and simpler debug info = better.

[inglorion]

I made the change a little more conservative. We now only use the single-record representation
when:

1. The variable has only a single defrange.
2. There are no gaps in the defrange.
3. There S_LOCAL record we would emit would have the default flags.
4. The defrange does not have a struct offset.

I also updated all the affected tests to expect the new records.

With that, all tests pass and this change is ready for review.

[inglorion]

rebased

[inglorion]

Size numbers with this version:

Without this change: 320,352,256 opt.pdb
With this change: 310,153,216 opt.pdb

[inglorion]

Can we ship this?

[zturner]

llvm/test/CodeGen/MIR/X86/diexpr-win32.mir

4

Can you inject 5 spaces here so that these line up vertically with the CHECK-NEXT statements?

33–38

Why are we still getting some DefRangeRegisterRel even in 32-bit mode with O0? Ranges should be entire blocks or entire functions, which should make them eligible for BPRelativesym

llvm/test/DebugInfo/COFF/types-array-advanced.ll

53

Any idea where this is coming from? It wasn't here before.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h

static LocalVarDefRange createDefRangeGeneral(uint16_t CVRegister,
                                                 bool InMemory, int Offset,
                                                 bool IsSubfield,
                                                 uint16_t StructOffset);
 
   /// Similar to DbgVariable in DwarfDebug, but not dwarf-specific.
   struct LocalVariable {
     const DILocalVariable *DIVar = nullptr;
     SmallVector<LocalVarDefRange, 1> DefRanges;
+    bool Deref = false;
   };
 
   struct InlineSite {
     SmallVector<LocalVariable, 1> InlinedLocals;
     SmallVector<const DILocation *, 1> ChildSites;
     const DISubprogram *Inlinee = nullptr;
 
     /// The ID of the inline site or function used with .cv_loc. Not a type
class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   /// to be confused with type indices for LF_FUNC_ID records.
   unsigned NextFuncId = 0;
 
   InlineSite &getInlineSite(const DILocation *InlinedAt,
                             const DISubprogram *Inlinee);
 
   codeview::TypeIndex getFuncIdForSubprogram(const DISubprogram *SP);
 
+  void calculateRanges(LocalVariable &Var,
+                       const DbgValueHistoryMap::InstrRanges &Ranges);
+
   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;
 
class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   /// Emits an S_LOCAL record and its associated defined ranges.
   void emitLocalVariable(const LocalVariable &Var);
 
   /// Translates the DIType to codeview if necessary and returns a type index
   /// for it.
   codeview::TypeIndex getTypeIndex(DITypeRef TypeRef,
                                    DITypeRef ClassTyRef = DITypeRef());
 
+  codeview::TypeIndex getTypeIndexForReferenceTo(DITypeRef TypeRef);
+
   codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP,
                                             const DICompositeType *Class);
 
   codeview::TypeIndex getScopeIndex(const DIScope *Scope);
 
   codeview::TypeIndex getVBPTypeIndex();
 
   void addToUDTs(const DIType *Ty);

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

for (const MachineFunction::VariableDbgInfo &VI : MF.getVariableDbgInfo()) {
 
     LocalVariable Var;
     Var.DIVar = VI.Var;
     Var.DefRanges.emplace_back(std::move(DefRange));
     recordLocalVariable(std::move(Var), VI.Loc->getInlinedAt());
   }
 }
 
-void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) {
-  DenseSet<InlinedVariable> Processed;
-  // Grab the variable info that was squirreled away in the MMI side-table.
-  collectVariableInfoFromMFTable(Processed);
-
+void CodeViewDebug::calculateRanges(
+    LocalVariable &Var, const DbgValueHistoryMap::InstrRanges &Ranges) {
   const TargetRegisterInfo *TRI = Asm->MF->getSubtarget().getRegisterInfo();
 
-  for (const auto &I : DbgValues) {
-    InlinedVariable IV = I.first;
-    if (Processed.count(IV))
-      continue;
-    const DILocalVariable *DIVar = IV.first;
-    const DILocation *InlinedAt = IV.second;
-
-    // Instruction ranges, specifying where IV is accessible.
-    const auto &Ranges = I.second;
-
-    LexicalScope *Scope = nullptr;
-    if (InlinedAt)
-      Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt);
-    else
-      Scope = LScopes.findLexicalScope(DIVar->getScope());
-    // If variable scope is not found then skip this variable.
-    if (!Scope)
-      continue;
-
-    LocalVariable Var;
-    Var.DIVar = DIVar;
-
-    // Calculate the definition ranges.
-    for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
-      const InsnRange &Range = *I;
-      const MachineInstr *DVInst = Range.first;
-      assert(DVInst->isDebugValue() && "Invalid History entry");
-      const DIExpression *DIExpr = DVInst->getDebugExpression();
-      bool InMemory = DVInst->getOperand(1).isImm();
-      bool IsSubfield = false;
-      unsigned StructOffset = 0;
-      // Recognize a +Offset expression.
-      int Offset = 0;
-      DIExpressionCursor Ops(DIExpr);
-      auto Op = Ops.peek();
-      if (Op && Op->getOp() == dwarf::DW_OP_plus_uconst) {
-        Offset = Op->getArg(0);
-        Ops.take();
-      }
-
-      // Handle fragments.
-      auto Fragment = Ops.getFragmentInfo();
-      if (Fragment) {
-        IsSubfield = true;
-        StructOffset = Fragment->OffsetInBits / 8;
-      }
-      // Ignore unrecognized exprs.
-      if (Ops.peek() && Ops.peek()->getOp() != dwarf::DW_OP_LLVM_fragment)
-        continue;
-      if (!InMemory && Offset)
-        continue;
-
-      // Bail if operand 0 is not a valid register. This means the variable is a
-      // simple constant, or is described by a complex expression.
-      // FIXME: Find a way to represent constant variables, since they are
-      // relatively common.
-      unsigned Reg =
-          DVInst->getOperand(0).isReg() ? DVInst->getOperand(0).getReg() : 0;
-      if (Reg == 0)
-        continue;
+  // calculate the definition ranges.
+    DbgVariableLocation Location;
+    bool Supported =
+        DbgVariableLocation::extractFromMachineInstruction(Location, *DVInst);
+
+    // Because we cannot express DW_OP_deref in CodeView directly,
+    // we use a trick: we encode the type as a reference to the
+    // real type.
+    if (Var.Deref) {
+      // When we're encoding the type as a reference to the original type,
+      // we need to remove a level of indirection from incoming locations.
+      // E.g. [RSP+8] with DW_OP_deref becomes [RSP+8],
+      // and [RCX+0] without DW_OP_deref becomes RCX.
+      if (!Location.Deref) {
+        if (Location.InMemory)
+          Location.InMemory = false;
+        else
+          Supported = false;
+      }
+    } else if (Location.Deref) {
+      // We've encountered a Deref range when we had not applied the
+      // reference encoding. Start over using reference encoding.
+      Var.Deref = true;
+      Var.DefRanges.clear();
+      calculateRanges(Var, Ranges);
+      return;
+    }
+
+    // If we don't know how to handle this range, skip past it.
+    if (!Supported || (Location.Offset && !Location.InMemory))
 
-      // Handle the two cases we can handle: indirect in memory and in register.
-      unsigned CVReg = TRI->getCodeViewRegNum(Reg);
-      {
-        LocalVarDefRange DR;
-        DR.CVRegister = CVReg;
-        DR.InMemory = InMemory;
-        DR.DataOffset = Offset;
-        DR.IsSubfield = IsSubfield;
-        DR.StructOffset = StructOffset;
+      DR.CVRegister = TRI->getCodeViewRegNum(Location.Register);
+      DR.InMemory = Location.InMemory;
+      DR.DataOffset = Location.Offset;
+      if (Location.FragmentInfo) {
+        DR.IsSubfield = true;
+        DR.StructOffset = Location.FragmentInfo->OffsetInBits / 8;
+      } else {
+        DR.IsSubfield = false;
+        DR.StructOffset = 0;
+      }
 
-        if (Var.DefRanges.empty() ||
-            Var.DefRanges.back().isDifferentLocation(DR)) {
-          Var.DefRanges.emplace_back(std::move(DR));
-        }
-      }
 
-      // Compute the label range.
-      const MCSymbol *Begin = getLabelBeforeInsn(Range.first);
-      const MCSymbol *End = getLabelAfterInsn(Range.second);
-      if (!End) {
-        // This range is valid until the next overlapping bitpiece. In the
-        // common case, ranges will not be bitpieces, so they will overlap.
-        auto J = std::next(I);
-        while (J != E &&
-               !fragmentsOverlap(DIExpr, J->first->getDebugExpression()))
-          ++J;
-        if (J != E)
-          End = getLabelBeforeInsn(J->first);
-        else
-          End = Asm->getFunctionEnd();
-      }
+      const DIExpression *DIExpr = DVInst->getDebugExpression();
 
-      // If the last range end is our begin, just extend the last range.
-      // Otherwise make a new range.
-      SmallVectorImpl<std::pair<const MCSymbol *, const MCSymbol *>> &Ranges =
-          Var.DefRanges.back().Ranges;
-      if (!Ranges.empty() && Ranges.back().second == Begin)
-        Ranges.back().second = End;
-      else
-        Ranges.emplace_back(Begin, End);
+    SmallVectorImpl<std::pair<const MCSymbol *, const MCSymbol *>> &R =
+    if (!R.empty() && R.back().second == Begin)
+      R.back().second = End;
+      R.emplace_back(Begin, End);
 
-      // FIXME: Do more range combining.
-    }
+}
 
+void CodeViewDebug::collectVariableInfo(const DISubprogram *SP) {
+  DenseSet<InlinedVariable> Processed;
+  // Grab the variable info that was squirreled away in the MMI side-table.
+  collectVariableInfoFromMFTable(Processed);
+
+  for (const auto &I : DbgValues) {
+    InlinedVariable IV = I.first;
+    if (Processed.count(IV))
+      continue;
+    const DILocalVariable *DIVar = IV.first;
+    const DILocation *InlinedAt = IV.second;
+
+    // Instruction ranges, specifying where IV is accessible.
+    const auto &Ranges = I.second;
+
+    LexicalScope *Scope = nullptr;
+    if (InlinedAt)
+      Scope = LScopes.findInlinedScope(DIVar->getScope(), InlinedAt);
+    else
+      Scope = LScopes.findLexicalScope(DIVar->getScope());
+    // If variable scope is not found then skip this variable.
+    if (!Scope)
+      continue;
+
+    LocalVariable Var;
+    Var.DIVar = DIVar;
+
+    calculateRanges(Var, Ranges);
     recordLocalVariable(std::move(Var), InlinedAt);
   }
 }
 
 void CodeViewDebug::beginFunctionImpl(const MachineFunction *MF) {
   const Function *GV = MF->getFunction();
   assert(FnDebugInfo.count(GV) == false);
   CurFn = &FnDebugInfo[GV];
TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
   if (I != TypeIndices.end())
     return I->second;
 
   TypeLoweringScope S(*this);
   TypeIndex TI = lowerType(Ty, ClassTy);
   return recordTypeIndexForDINode(Ty, TI, ClassTy);
 }
 
+TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(DITypeRef TypeRef) {
+  DIType *Ty = TypeRef.resolve();
+  PointerRecord PR(getTypeIndex(Ty),
+                   getPointerSizeInBytes() == 8 ? PointerKind::Near64
+                                                : PointerKind::Near32,
+                   PointerMode::LValueReference, PointerOptions::None,
+                   Ty->getSizeInBits() / 8);
+  return TypeTable.writeKnownType(PR);
+}
+
 TypeIndex CodeViewDebug::getCompleteTypeIndex(DITypeRef TypeRef) {
   const DIType *Ty = TypeRef.resolve();
 
   // The null DIType is the void type. Don't try to hash it.
   if (!Ty)
     return TypeIndex::Void();
 
   // If this is a non-record type, the complete type index is the same as the
for (const LocalVariable &L : Locals)
     if (!L.DIVar->isParameter())
       emitLocalVariable(L);
 }
 
 void CodeViewDebug::emitLocalVariable(const LocalVariable &Var) {
   // LocalSym record, see SymbolRecord.h for more info.
   MCSymbol *LocalBegin = MMI->getContext().createTempSymbol(),
            *LocalEnd = MMI->getContext().createTempSymbol();
-  OS.AddComment("Record length");
-  OS.emitAbsoluteSymbolDiff(LocalEnd, LocalBegin, 2);
-  OS.EmitLabel(LocalBegin);
-
-  OS.AddComment("Record kind: S_LOCAL");
-  OS.EmitIntValue(unsigned(SymbolKind::S_LOCAL), 2);
-
+  bool NeedToEmitRanges = !Var.DefRanges.empty();
+  TypeIndex TI = Var.Deref ? getTypeIndexForReferenceTo(Var.DIVar->getType())
+                           : getCompleteTypeIndex(Var.DIVar->getType());
   LocalSymFlags Flags = LocalSymFlags::None;
   if (Var.DIVar->isParameter())
     Flags |= LocalSymFlags::IsParameter;
   if (Var.DefRanges.empty())
     Flags |= LocalSymFlags::IsOptimizedOut;
-
+  OS.AddComment("Record length");
+  OS.emitAbsoluteSymbolDiff(LocalEnd, LocalBegin, 2);
+  OS.EmitLabel(LocalBegin);
+  if (Var.DefRanges.size() == 1 && Var.DefRanges[0].Ranges.size() == 1 &&
+      Flags == LocalSymFlags::None && Var.DefRanges[0].StructOffset == 0) {
+    auto &DefRange = Var.DefRanges[0];
+    if (DefRange.InMemory) {
+      NeedToEmitRanges = false;
+      if (DefRange.CVRegister == uint16_t(codeview::RegisterId::EBP)) {
+        OS.AddComment("Record kind: S_BPREL32");
+        OS.EmitIntValue(unsigned(SymbolKind::S_BPREL32), 2);
+      } else {
+        OS.AddComment("Record kind: S_REGREL32");
+        OS.EmitIntValue(unsigned(SymbolKind::S_REGREL32), 2);
+      }
+      OS.EmitIntValue(DefRange.DataOffset, 4);
+      OS.AddComment("TypeIndex");
+      OS.EmitIntValue(TI.getIndex(), 4);
+      if (DefRange.CVRegister != uint16_t(codeview::RegisterId::EBP))
+        OS.EmitIntValue(DefRange.CVRegister, 2);
+    } else {
+      NeedToEmitRanges = false;
+      OS.AddComment("Record kind: S_REGISTER");
+      OS.EmitIntValue(unsigned(SymbolKind::S_REGISTER), 2);
+      OS.AddComment("TypeIndex");
+      OS.EmitIntValue(TI.getIndex(), 4);
+      OS.EmitIntValue(DefRange.CVRegister, 2);
+    }
+  } else {
+    OS.AddComment("Record kind: S_LOCAL");
+    OS.EmitIntValue(unsigned(SymbolKind::S_LOCAL), 2);
     OS.AddComment("TypeIndex");
-  TypeIndex TI = getCompleteTypeIndex(Var.DIVar->getType());
     OS.EmitIntValue(TI.getIndex(), 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());
   OS.EmitLabel(LocalEnd);
 
+  if (!NeedToEmitRanges)
+    return;
+
   // 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();
     if (DefRange.InMemory) {
       uint16_t RegRelFlags = 0;

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGHANDLERBASE_H
 #define LLVM_LIB_CODEGEN_ASMPRINTER_DEBUGHANDLERBASE_H
 
 #include "AsmPrinterHandler.h"
 #include "DbgValueHistoryCalculator.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/CodeGen/LexicalScopes.h"
 #include "llvm/CodeGen/MachineInstr.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 
 namespace llvm {
 
 class AsmPrinter;
+class MachineInstr;
 class MachineModuleInfo;
 
+/// Represents the location at which a variable is stored.
+struct DbgVariableLocation {
+  /// Offset relative to base register.
+  int64_t Offset;
+
+  /// Base register.
+  unsigned Register;
+
+  /// If false, Register is the location. If true,
+  /// Register+Offset point at the location.
+  unsigned InMemory : 1;
+
+  /// If false, the location holds the variable's value.
+  /// If true, the location holds the variable's address.
+  unsigned Deref : 1;
+
+  /// Present if the location is part of a larger variable.
+  llvm::Optional<llvm::DIExpression::FragmentInfo> FragmentInfo;
+
+  /// Extract a VariableLocation from a MachineInstr.  The struct passed in as
+  /// Location is populated.  The MachineInstr must be a debug value
+  /// instruction.
+  /// @return true if successful and false if not.
+  static bool extractFromMachineInstruction(DbgVariableLocation &Location,
+                                            const MachineInstr &Instruction);
+};
+
 /// Base class for debug information backends. Common functionality related to
 /// tracking which variables and scopes are alive at a given PC live here.
 class DebugHandlerBase : public AsmPrinterHandler {
 protected:
   DebugHandlerBase(AsmPrinter *A);
 
   /// Target of debug info emission.
   AsmPrinter *Asm;

llvm/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/Target/TargetSubtargetInfo.h"
 
 using namespace llvm;
 
+bool DbgVariableLocation::extractFromMachineInstruction(
+    DbgVariableLocation &Location, const MachineInstr &Instruction) {
+  if (!Instruction.isDebugValue())
+    return false;
+  if (!Instruction.getOperand(0).isReg())
+    return false;
+  Location.Register = Instruction.getOperand(0).getReg();
+  Location.InMemory = Instruction.getOperand(1).isImm();
+  Location.Deref = false;
+  Location.FragmentInfo.reset();
+  // We only handle expressions generated by DIExpression::appendOffset,
+  // which doesn't require a full stack machine.
+  int64_t Offset = 0;
+  const DIExpression *DIExpr = Instruction.getDebugExpression();
+  auto Op = DIExpr->expr_op_begin();
+  while (Op != DIExpr->expr_op_end()) {
+    switch (Op->getOp()) {
+    case dwarf::DW_OP_constu: {
+      int Value = Op->getArg(0);
+      ++Op;
+      if (Op != DIExpr->expr_op_end()) {
+        switch (Op->getOp()) {
+        case dwarf::DW_OP_minus:
+          Offset -= Value;
+          break;
+        case dwarf::DW_OP_plus:
+          Offset += Value;
+        default:
+          continue;
+        }
+      }
+    } break;
+    case dwarf::DW_OP_plus_uconst:
+      Offset += Op->getArg(0);
+      break;
+    case dwarf::DW_OP_LLVM_fragment:
+      Location.FragmentInfo = {Op->getArg(1), Op->getArg(0)};
+      break;
+    case dwarf::DW_OP_deref:
+      Location.Deref = true;
+      break;
+    default:
+      return false;
+    }
+    ++Op;
+  }
+
+  Location.Offset = Offset;
+  return true;
+}
+
 DebugHandlerBase::DebugHandlerBase(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {}
 
 // Each LexicalScope has first instruction and last instruction to mark
 // beginning and end of a scope respectively. Create an inverse map that list
 // scopes starts (and ends) with an instruction. One instruction may start (or
 // end) multiple scopes. Ignore scopes that are not reachable.
 void DebugHandlerBase::identifyScopeMarkers() {
   SmallVector<LexicalScope *, 4> WorkList;

llvm/lib/DebugInfo/CodeView/SymbolDumper.cpp

for (auto &Annotation : InlineSite.annotations()) {
     }
   }
   return Error::success();
 }
 
 Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR,
                                            RegisterSym &Register) {
   printTypeIndex("Type", Register.Index);
-  W.printEnum("Seg", uint16_t(Register.Register), getRegisterNames());
+  W.printEnum("Register", uint16_t(Register.Register), getRegisterNames());
   W.printString("Name", Register.Name);
   return Error::success();
 }
 
 Error CVSymbolDumperImpl::visitKnownRecord(CVSymbol &CVR, PublicSym32 &Public) {
   W.printFlags("Flags", uint32_t(Public.Flags), getPublicSymFlagNames());
   W.printNumber("Seg", Public.Segment);
   W.printNumber("Off", Public.Offset);

llvm/lib/ObjectYAML/CodeViewYAMLSymbols.cpp

template <> void SymbolRecordImpl<ProcSym>::map(IO &IO) {
   IO.mapOptional("Offset", Symbol.CodeOffset, 0U);
   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
   IO.mapRequired("Flags", Symbol.Flags);
   IO.mapRequired("DisplayName", Symbol.Name);
 }
 
 template <> void SymbolRecordImpl<RegisterSym>::map(IO &IO) {
   IO.mapRequired("Type", Symbol.Index);
-  IO.mapRequired("Seg", Symbol.Register);
+  IO.mapRequired("Register", Symbol.Register);
   IO.mapRequired("Name", Symbol.Name);
 }
 
 template <> void SymbolRecordImpl<PublicSym32>::map(IO &IO) {
   IO.mapRequired("Flags", Symbol.Flags);
   IO.mapOptional("Offset", Symbol.Offset, 0U);
   IO.mapOptional("Segment", Symbol.Segment, uint16_t(0));
   IO.mapRequired("Name", Symbol.Name);

llvm/test/CodeGen/MIR/X86/diexpr-win32.mir

+# RUN: llc -filetype=obj -O0 %s -o - | llvm-readobj -codeview | FileCheck %s
+#
+# (DW_OP_plus_uconst 12)
+# CHECK: RegRelativeSym {
+# CHECK-NEXT:   Kind: S_REGREL32 (0x1111)
+# CHECK-NEXT:   Offset:
+# CHECK-NEXT:   Type: string* (0x
+# CHECK-NEXT:   Register:
+# CHECK-NEXT:   VarName: Str
+# CHECK-NEXT: }
+# (DW_OP_plus_uconst, 8, DW_OP_deref)
+# CHECK: LocalSym {
+# CHECK-NEXT:   Kind: S_LOCAL (0x113E)
+# CHECK-NEXT:   Type: string& (0x
+# CHECK-NEXT:   Flags [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   VarName: Result
+# CHECK-NEXT: }
+# CHECK-NEXT: DefRangeRegisterRelSym {
+# CHECK-NEXT:   Kind: S_DEFRANGE_REGISTER_REL (0x1145)
+# CHECK-NEXT:   BaseRegister:
+# CHECK-NEXT:   HasSpilledUDTMember: No
+# CHECK-NEXT:   OffsetInParent: 0
+# CHECK-NEXT:   BasePointerOffset: 8
+# CHECK-NEXT:   LocalVariableAddrRange {
+# CHECK-NEXT:     OffsetStart:
+# CHECK-NEXT:     ISectStart:
+# CHECK-NEXT:     Range:
+# CHECK-NEXT:   }
+# CHECK-NEXT: }
+# (DW_OP_constu, 4, DW_OP_minus)
+# CHECK: LocalSym {
+# CHECK-NEXT:   Kind: S_LOCAL (0x113E)
+# CHECK-NEXT:   Type: long (0x12)
+# CHECK-NEXT:   Flags [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   VarName: Bytes
+# CHECK-NEXT: }
+# CHECK-NEXT: DefRangeRegisterRelSym {
+# CHECK-NEXT:   Kind: S_DEFRANGE_REGISTER_REL (0x1145)
+# CHECK-NEXT:   BaseRegister:
+# CHECK-NEXT:   HasSpilledUDTMember: No
+# CHECK-NEXT:   OffsetInParent: 0
+# CHECK-NEXT:   BasePointerOffset: -4
+# CHECK-NEXT:   LocalVariableAddrRange {
+# CHECK-NEXT:     OffsetStart:
+# CHECK-NEXT:     ISectStart:
+# CHECK-NEXT:     Range:
+# CHECK-NEXT:   }
+# CHECK-NEXT: }
+--- |
+  ; ModuleID = '<stdin>'
+  source_filename = "<stdin>"
+  target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
+  target triple = "i386-pc-windows-msvc19.0.24215"
+
+  %struct.string = type { i32, i32, i8* }
+
+  define void @fun(%struct.string* noalias sret %agg.result, %struct.string* noalias %str) !dbg !12 {
+  entry:
+    call void @llvm.dbg.value(metadata %struct.string* %agg.result, metadata !23, metadata !24), !dbg !25
+    call void @llvm.dbg.value(metadata %struct.string* %str, metadata !26, metadata !28), !dbg !25
+    %call = call dereferenceable(12) %struct.string* @getString(), !dbg !29
+    %0 = bitcast %struct.string* %agg.result to i8*, !dbg !29
+    %1 = bitcast %struct.string* %call to i8*, !dbg !29
+    call void @llvm.memcpy.p0i8.p0i8.i32(i8* %0, i8* %1, i32 12, i32 4, i1 false), !dbg !29
+    ret void, !dbg !30
+  }
+
+  define i32 @len(%struct.string* %s, i32 %acc) !dbg !31 {
+  entry:
+    %0 = bitcast %struct.string* %s to i32*
+    %bytes = load i32, i32* %0, !dbg !34
+    call void @llvm.dbg.declare(metadata i32 %bytes, metadata !35, metadata !28), !dbg !34
+    %1 = add i32 %bytes, %acc, !dbg !36
+    ret i32 %1, !dbg !36
+  }
+
+  ; Function Attrs: nounwind readnone speculatable
+  declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
+
+  ; Function Attrs: nounwind readnone speculatable
+  declare void @llvm.dbg.value(metadata, metadata, metadata) #0
+
+  declare dereferenceable(12) %struct.string* @getString()
+
+  ; Function Attrs: argmemonly nounwind
+  declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture writeonly, i8* nocapture readonly, i32, i32, i1) #1
+
+  ; Function Attrs: nounwind
+  declare void @llvm.stackprotector(i8*, i8**) #2
+
+  attributes #0 = { nounwind readnone speculatable }
+  attributes #1 = { argmemonly nounwind }
+  attributes #2 = { nounwind }
+
+  !llvm.dbg.cu = !{!0}
+  !llvm.linker.options = !{!3, !4}
+  !llvm.module.flags = !{!5, !6, !7, !8}
+  !llvm.ident = !{!9}
+
+  !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 6.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+  !1 = !DIFile(filename: "diexpr.ll", directory: "C:\5Csrc", checksumkind: CSK_MD5, checksum: "c547c362c610fa79e7abaddc76e1efe7")
+  !2 = !{}
+  !3 = !{!"/DEFAULTLIB:libcmt.lib"}
+  !4 = !{!"/DEFAULTLIB:oldnames.lib"}
+  !5 = !{i32 1, !"NumRegisterParameters", i32 0}
+  !6 = !{i32 2, !"CodeView", i32 1}
+  !7 = !{i32 2, !"Debug Info Version", i32 3}
+  !8 = !{i32 1, !"wchar_size", i32 2}
+  !9 = !{!"clang version 6.0.0 "}
+  !10 = !DIExpression(DW_OP_plus_uconst, 12)
+  !11 = !DIExpression(DW_OP_plus_uconst, 8, DW_OP_deref)
+  !12 = distinct !DISubprogram(name: "fun", linkageName: "fun", scope: !1, file: !1, line: 9, type: !13, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+  !13 = !DISubroutineType(types: !14)
+  !14 = !{!15}
+  !15 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "string", file: !1, line: 1, size: 96, elements: !16, identifier: ".?AUstring@@")
+  !16 = !{!17, !19, !20}
+  !17 = !DIDerivedType(tag: DW_TAG_member, name: "length", scope: !15, file: !1, line: 2, baseType: !18, size: 32)
+  !18 = !DIBasicType(name: "long int", size: 32, encoding: DW_ATE_signed)
+  !19 = !DIDerivedType(tag: DW_TAG_member, name: "size", scope: !15, file: !1, line: 3, baseType: !18, size: 32, offset: 32)
+  !20 = !DIDerivedType(tag: DW_TAG_member, name: "data", scope: !15, file: !1, line: 4, baseType: !21, size: 32, offset: 64)
+  !21 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !22, size: 32)
+  !22 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+  !23 = !DILocalVariable(name: "Result", scope: !12, file: !1, line: 10, type: !15)
+  !24 = !DIExpression(DW_OP_deref)
+  !25 = !DILocation(line: 10, scope: !12)
+  !26 = !DILocalVariable(name: "Str", scope: !12, file: !1, line: 10, type: !27)
+  !27 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !15, size: 32)
+  !28 = !DIExpression(DW_OP_constu, 4, DW_OP_minus)
+  !29 = !DILocation(line: 11, scope: !12)
+  !30 = !DILocation(line: 12, scope: !12)
+  !31 = distinct !DISubprogram(name: "len", linkageName: "len", scope: !1, file: !1, line: 14, type: !32, isLocal: false, isDefinition: true, scopeLine: 14, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+  !32 = !DISubroutineType(types: !33)
+  !33 = !{!18}
+  !34 = !DILocation(line: 15, scope: !31)
+  !35 = !DILocalVariable(name: "Bytes", scope: !31, file: !1, line: 15, type: !18)
+  !36 = !DILocation(line: 16, scope: !31)
+
+...
+---
+name:            fun
+alignment:       4
+exposesReturnsTwice: false
+legalized:       false
+regBankSelected: false
+selected:        false
+tracksRegLiveness: true
+registers:
+liveins:
+frameInfo:
+  isFrameAddressTaken: false
+  isReturnAddressTaken: false
+  hasStackMap:     false
+  hasPatchPoint:   false
+  stackSize:       4
+  offsetAdjustment: 0
+  maxAlignment:    4
+  adjustsStack:    true
+  hasCalls:        true
+  stackProtector:  ''
+  maxCallFrameSize: 0
+  hasOpaqueSPAdjustment: false
+  hasVAStart:      false
+  hasMustTailInVarArgFunc: false
+  savePoint:       ''
+  restorePoint:    ''
+fixedStack:
+  - { id: 0, type: spill-slot, offset: -8, size: 4, alignment: 4, stack-id: 0,
+      callee-saved-register: '%esi' }
+  - { id: 1, type: default, offset: 4, size: 4, alignment: 4, stack-id: 0,
+      isImmutable: true, isAliased: false, callee-saved-register: '' }
+  - { id: 2, type: default, offset: 0, size: 4, alignment: 4, stack-id: 0,
+      isImmutable: true, isAliased: false, callee-saved-register: '' }
+stack:
+constants:
+body:             |
+  bb.0.entry:
+    liveins: %esi
+
+    frame-setup PUSH32r killed %esi, implicit-def %esp, implicit %esp
+    CFI_INSTRUCTION def_cfa_offset 8
+    CFI_INSTRUCTION offset %esi, -8
+    %esi = MOV32rm %esp, 1, _, 8, _ :: (load 4 from %fixed-stack.2)
+    DBG_VALUE %esp, 0, !26, !10, debug-location !25
+    DBG_VALUE %esp, 0, !23, !11, debug-location !25
+    CALLpcrel32 @getString, csr_32, implicit %esp, implicit-def %esp, implicit-def %eax, debug-location !29
+    %ecx = MOV32rm %eax, 1, _, 0, _, debug-location !29 :: (dereferenceable load 4 from %ir.1)
+    %edx = MOV32rm %eax, 1, _, 4, _, debug-location !29 :: (dereferenceable load 4 from %ir.1 + 4)
+    MOV32mr %esi, 1, _, 0, _, killed %ecx, debug-location !29 :: (store 4 into %ir.0)
+    MOV32mr %esi, 1, _, 4, _, killed %edx, debug-location !29 :: (store 4 into %ir.0 + 4)
+    %eax = MOV32rm killed %eax, 1, _, 8, _, debug-location !29 :: (dereferenceable load 4 from %ir.1 + 8)
+    MOV32mr %esi, 1, _, 8, _, killed %eax, debug-location !29 :: (store 4 into %ir.0 + 8)
+    %eax = COPY killed %esi, debug-location !30
+    %esi = POP32r implicit-def %esp, implicit %esp, debug-location !30
+    RET 0, %eax, debug-location !30
+
+...
+---
+name:            len
+alignment:       4
+exposesReturnsTwice: false
+legalized:       false
+regBankSelected: false
+selected:        false
+tracksRegLiveness: true
+registers:
+liveins:
+frameInfo:
+  isFrameAddressTaken: false
+  isReturnAddressTaken: false
+  hasStackMap:     false
+  hasPatchPoint:   false
+  stackSize:       0
+  offsetAdjustment: 0
+  maxAlignment:    4
+  adjustsStack:    false
+  hasCalls:        false
+  stackProtector:  ''
+  maxCallFrameSize: 0
+  hasOpaqueSPAdjustment: false
+  hasVAStart:      false
+  hasMustTailInVarArgFunc: false
+  savePoint:       ''
+  restorePoint:    ''
+fixedStack:
+  - { id: 0, type: default, offset: 4, size: 4, alignment: 4, stack-id: 0,
+      isImmutable: true, isAliased: false, callee-saved-register: '' }
+  - { id: 1, type: default, offset: 0, size: 4, alignment: 4, stack-id: 0,
+      isImmutable: true, isAliased: false, callee-saved-register: '' }
+stack:
+constants:
+body:             |
+  bb.0.entry:
+    %eax = MOV32rm %esp, 1, _, 4, _ :: (load 4 from %fixed-stack.1)
+    %eax = MOV32rm killed %eax, 1, _, 0, _, debug-location !34 :: (load 4 from %ir.0)
+    DBG_VALUE debug-use %eax, 0, !35, !28, debug-location !34
+    %eax = ADD32rm killed %eax, %esp, 1, _, 8, _, implicit-def dead %eflags, debug-location !36 :: (load 4 from %fixed-stack.0)
+    RET 0, %eax, debug-location !36
+
+...

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

 ; 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]], "E\021O\001\000\0004\000\000\000"
-; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .short  4369                    # Record kind: S_REGREL32
 ; ASM: .long   116                     # TypeIndex
-; ASM: .short  0                       # Flags
 ; ASM: .asciz  "a"
-; ASM: .cv_def_range    [[if_start]] [[else_start]], "E\021O\001\000\000(\000\000\000"
-; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .short  4369                    # Record kind: S_REGREL32
 ; ASM: .long   116                     # TypeIndex
-; ASM: .short  0                       # Flags
 ; ASM: .asciz  "b"
-; ASM: .cv_def_range    [[else_start]] [[else_end]], "E\021O\001\000\000$\000\000\000"
 ; ASM: .short  4429                    # Record kind: S_INLINESITE
-; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .short  4369                    # Record kind: S_REGREL32
 ; ASM: .long   116                     # TypeIndex
-; ASM: .short  0                       # Flags
 ; ASM: .asciz  "v"
-; ASM: .cv_def_range    [[inline_site1]] [[else_start]], "E\021O\001\000\000,\000\000\000"
 ; ASM: .short  4430                    # Record kind: S_INLINESITE_END
 ; ASM: .short  4429                    # Record kind: S_INLINESITE
-; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .short  4369                    # Record kind: S_REGREL32
 ; ASM: .long   116                     # TypeIndex
-; ASM: .short  0                       # Flags
 ; ASM: .asciz  "v"
-; ASM: .cv_def_range    [[inline_site2]] [[else_end]], "E\021O\001\000\0000\000\000\000"
 ; ASM: .short  4430                    # Record kind: S_INLINESITE_END
 
 ; OBJ:  Subsection [
 ; OBJ:    SubSectionType: Symbols (0xF1)
 ; OBJ:    {{.*}}Proc{{.*}}Sym {
 ; OBJ:      DisplayName: f
 ; OBJ:      LinkageName: f
 ; OBJ:    }

 ; OBJ:      OffsetInParent: 0
 ; OBJ:      BasePointerOffset: 52
 ; OBJ:      LocalVariableAddrRange {
 ; OBJ:        OffsetStart: .text+0x8
 ; OBJ:        ISectStart: 0x0
 ; OBJ:        Range: 0x4F
 ; OBJ:      }
 ; OBJ:    }
-; OBJ:    LocalSym {
+; OBJ:    RegRelativeSym {
+; OBJ:      Offset: 0x28
 ; OBJ:      Type: int (0x74)
-; OBJ:      Flags [ (0x0)
-; OBJ:      ]
+; OBJ:      Register: RSP (0x14F)
 ; OBJ:      VarName: a
 ; OBJ:    }
-; OBJ:    DefRangeRegisterRelSym {
-; OBJ:      BaseRegister: 335
-; OBJ:      HasSpilledUDTMember: No
-; OBJ:      OffsetInParent: 0
-; OBJ:      BasePointerOffset: 40
-; OBJ:      LocalVariableAddrRange {
-; OBJ:        OffsetStart: .text+0xC
-; OBJ:        ISectStart: 0x0
-; OBJ:        Range: 0x21
-; OBJ:      }
-; OBJ:    }
-; OBJ:    LocalSym {
+; OBJ:    RegRelativeSym {
+; OBJ:      Offset: 0x24
 ; OBJ:      Type: int (0x74)
-; OBJ:      Flags [ (0x0)
-; OBJ:      ]
+; OBJ:      Register: RSP (0x14F)
 ; OBJ:      VarName: b
 ; OBJ:    }
-; OBJ:    DefRangeRegisterRelSym {
-; OBJ:      BaseRegister: 335
-; OBJ:      HasSpilledUDTMember: No
-; OBJ:      OffsetInParent: 0
-; OBJ:      BasePointerOffset: 36
-; OBJ:      LocalVariableAddrRange {
-; OBJ:        OffsetStart: .text+0x2D
-; OBJ:        ISectStart: 0x0
-; OBJ:        Range: 0x1F
-; OBJ:      }
-; OBJ:    }
 ; OBJ:    InlineSiteSym {
 ; OBJ:      PtrParent: 0x0
 ; OBJ:      PtrEnd: 0x0
 ; OBJ:      Inlinee: will_be_inlined (0x1002)
 ; OBJ:      BinaryAnnotations [
 ; OBJ:        ChangeLineOffset: 1
 ; OBJ:        ChangeCodeOffset: 0x14
 ; OBJ:        ChangeCodeOffsetAndLineOffset: {CodeOffset: 0xD, LineOffset: 1}
 ; OBJ:        ChangeCodeLength: 0xC
 ; OBJ:      ]
 ; OBJ:    }
-; OBJ:    LocalSym {
+; OBJ:    RegRelativeSym {
+; OBJ:      Offset: 0x2C
 ; OBJ:      Type: int (0x74)
-; OBJ:      Flags [ (0x0)
-; OBJ:      ]
+; OBJ:      Register: RSP (0x14F)
 ; OBJ:      VarName: v
 ; OBJ:    }
-; OBJ:    DefRangeRegisterRelSym {
-; OBJ:      BaseRegister: 335
-; OBJ:      HasSpilledUDTMember: No
-; OBJ:      OffsetInParent: 0
-; OBJ:      BasePointerOffset: 44
-; OBJ:      LocalVariableAddrRange {
-; OBJ:        OffsetStart: .text+0x14
-; OBJ:        ISectStart: 0x0
-; OBJ:        Range: 0x19
-; OBJ:      }
-; OBJ:    }
 ; OBJ:    InlineSiteEnd {
 ; OBJ:    }
 ; OBJ:    InlineSiteSym {
 ; OBJ:      PtrParent: 0x0
 ; OBJ:      PtrEnd: 0x0
 ; OBJ:      Inlinee: will_be_inlined (0x1002)
 ; OBJ:      BinaryAnnotations [
 ; OBJ:        ChangeLineOffset: 1
 ; OBJ:        ChangeCodeOffset: 0x35
 ; OBJ:        ChangeCodeOffsetAndLineOffset: {CodeOffset: 0xD, LineOffset: 1}
 ; OBJ:        ChangeCodeLength: 0xA
 ; OBJ:      ]
 ; OBJ:    }
-; OBJ:    LocalSym {
+; OBJ:    RegRelativeSym {
+; OBJ:      Offset: 0x30
 ; OBJ:      Type: int (0x74)
-; OBJ:      Flags [ (0x0)
-; OBJ:      ]
+; OBJ:      Register: RSP (0x14F)
 ; OBJ:      VarName: v
 ; OBJ:    }
-; OBJ:    DefRangeRegisterRelSym {
-; OBJ:      BaseRegister: 335
-; OBJ:      HasSpilledUDTMember: No
-; OBJ:      OffsetInParent: 0
-; OBJ:      BasePointerOffset: 48
-; OBJ:      LocalVariableAddrRange {
-; OBJ:        OffsetStart: .text+0x35
-; OBJ:        ISectStart: 0x0
-; OBJ:        Range: 0x17
-; OBJ:      }
-; OBJ:    }
 ; OBJ:    InlineSiteEnd {
 ; OBJ:    }
 ; OBJ:    ProcEnd
 ; OBJ:  ]
 
 ; ModuleID = 't.cpp'
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc18.0.0"

llvm/test/DebugInfo/COFF/parameter-order.ll

 ; ASM: .cv_def_range
 
 ; ASM: .short  4414                    # Record kind: S_LOCAL
 ; ASM: .long   116                     # TypeIndex
 ; ASM: .short  1                       # Flags
 ; ASM: .asciz  "c"
 ; ASM: .cv_def_range
 
-; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .short  4369                    # Record kind: S_REGREL32
 ; ASM: .long   116                     # TypeIndex
-; ASM: .short  0                       # Flags
 ; ASM: .asciz  "d"
-; ASM: .cv_def_range
 
-; ASM: .short  4414                    # Record kind: S_LOCAL
+; ASM: .short  4369                    # Record kind: S_REGREL32
 ; ASM: .long   116                     # TypeIndex
-; ASM: .short  0                       # Flags
 ; ASM: .asciz  "e"
-; ASM: .cv_def_range
 
 
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.23918"
 
 ; Function Attrs: nounwind uwtable

llvm/test/DebugInfo/COFF/pieces.ll

 ; 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"
-; FIXME: We should have a .cv_def_range for 'o', but we don't yet.
-; ASM-NOT:    .cv_def_range
+; ASM:        .cv_def_range    .Lfunc_begin3 .Lfunc_end3, "E\021J\001\000\000\000\000\000\000"
 ; 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"
 
 ; OBJ-LABEL: {{.*}}Proc{{.*}}Sym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: nested
 ; OBJ:       }
 ; OBJ:       LocalSym {
+; OBJ:         Type: Nested&
 ; OBJ:         VarName: o
 ; OBJ:       }
+; OBJ:       DefRangeRegisterRelSym {
+; OBJ:         BaseRegister: 330
+; OBJ:         HasSpilledUDTMember: No
+; OBJ:         OffsetInParent: 0
+; OBJ:         BasePointerOffset: 0
+; OBJ:         LocalVariableAddrRange {
+; OBJ:         }
+; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: p
 ; OBJ:       }
 ; OBJ:       DefRangeSubfieldRegisterSym {
 ; OBJ:         Register: 17
 ; OBJ:         MayHaveNoName: 0
 ; OBJ:         OffsetInParent: 4
 ; OBJ:         LocalVariableAddrRange {

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

 ; 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:         .short  4414                    # Record kind: S_LOCAL
+; ASM:         .short  4358                    # Record kind: S_REGISTER
+; ASM:         .short  17
 ; ASM:         .asciz  "a"
-; ASM:         .cv_def_range    [[after_getint]] [[after_inc_eax]], "A\021\021\000\000\000"
-; ASM:         .short  4414                    # Record kind: S_LOCAL
+; ASM:         .short  4358                    # Record kind: S_REGISTER
+; ASM:         .short  17
 ; ASM:         .asciz  "c"
-; ASM:         .cv_def_range    [[after_getint]] [[after_je]], "A\021\021\000\000\000"
-; ASM:         .short  4414                    # Record kind: S_LOCAL
+; ASM:         .short  4358                    # Record kind: S_REGISTER
+; ASM:         .short  17
 ; ASM:         .asciz  "b"
-; ASM:         .cv_def_range    [[after_inc_eax]] [[after_if]], "A\021\021\000\000\000"
-
 ; 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:         .short  4414                    # Record kind: S_LOCAL
+; ASM:         .short  4358                    # Record kind: S_REGISTER
+; ASM:         .short  17
 ; ASM:         .asciz  "b"
-; ASM:         .cv_def_range    [[after_inc_eax]] [[after_if]], "A\021\021\000\000\000"
 ; ASM:         .short  4430                    # Record kind: S_INLINESITE_END
 
 ; OBJ: Subsection [
 ; OBJ:   SubSectionType: Symbols (0xF1)
 ; OBJ:   {{.*}}Proc{{.*}}Sym {
 ; OBJ:     DisplayName: f
 ; OBJ:   }
 ; OBJ:   LocalSym {

 ; OBJ:   DefRangeRegisterSym {
 ; OBJ:     Register: 23
 ; OBJ:     LocalVariableAddrRange {
 ; OBJ:       OffsetStart: .text+0x7
 ; OBJ:       ISectStart: 0x0
 ; OBJ:       Range: 0x1A
 ; OBJ:     }
 ; OBJ:   }
-; OBJ:   LocalSym {
+; OBJ:   RegisterSym {
 ; OBJ:     Type: int (0x74)
-; OBJ:     Flags [ (0x0)
-; OBJ:     ]
-; OBJ:     VarName: a
-; OBJ:   }
-; OBJ:   DefRangeRegisterSym {
-; OBJ:     Register: 17
-; OBJ:     LocalVariableAddrRange {
-; OBJ:       OffsetStart: .text+0xC
-; OBJ:       ISectStart: 0x0
-; OBJ:       Range: 0x7
-; OBJ:     }
+; OBJ:     Register: EAX (0x11)
+; OBJ:     Name: a
 ; OBJ:   }
-; OBJ:   LocalSym {
+; OBJ:   RegisterSym {
 ; OBJ:     Type: int (0x74)
-; OBJ:     Flags [ (0x0)
-; OBJ:     ]
-; OBJ:     VarName: c
+; OBJ:     Register: EAX (0x11)
+; OBJ:     Name: c
 ; OBJ:   }
-; OBJ:   DefRangeRegisterSym {
-; OBJ:     Register: 17
-; OBJ:     LocalVariableAddrRange {
-; OBJ:       OffsetStart: .text+0xC
-; OBJ:       ISectStart: 0x0
-; OBJ:       Range: 0x4
-; OBJ:     }
-; OBJ:   }
-; OBJ:   LocalSym {
+; OBJ:   RegisterSym {
 ; OBJ:     Type: int (0x74)
-; OBJ:     Flags [ (0x0)
-; OBJ:     ]
-; OBJ:     VarName: b
-; OBJ:   }
-; OBJ:   DefRangeRegisterSym {
-; OBJ:     Register: 17
-; OBJ:     MayHaveNoName: 0
-; OBJ:       OffsetStart: .text+0x13
-; OBJ:       ISectStart: 0x0
-; OBJ:       Range: 0x7
-; OBJ:     }
+; OBJ:     Register: EAX (0x11)
+; OBJ:     Name: b
 ; OBJ:   }
 ; OBJ:   InlineSiteSym {
 ; OBJ:     PtrParent: 0x0
 ; OBJ:     PtrEnd: 0x0
 ; OBJ:     Inlinee: inlineinc (0x1002)
 ; OBJ:   }
 ; OBJ:   LocalSym {
 ; OBJ:     Type: int (0x74)
 ; OBJ:     Flags [ (0x1)
 ; OBJ:       IsParameter (0x1)
 ; OBJ:     ]
 ; OBJ:     VarName: a
 ; OBJ:   }
 ; OBJ:   DefRangeRegisterSym {
 ; OBJ:     Register: 17
 ; OBJ:     LocalVariableAddrRange {
 ; OBJ:       OffsetStart: .text+0xC
 ; OBJ:       ISectStart: 0x0
 ; OBJ:       Range: 0x7
 ; OBJ:     }
 ; OBJ:   }
-; OBJ:   LocalSym {
+; OBJ:   RegisterSym {
 ; OBJ:     Type: int (0x74)
-; OBJ:     Flags [ (0x0)
-; OBJ:     ]
-; OBJ:     VarName: b
-; OBJ:   }
-; OBJ:   DefRangeRegisterSym {
-; OBJ:     Register: 17
-; OBJ:     LocalVariableAddrRange {
-; OBJ:       OffsetStart: .text+0x13
-; OBJ:       ISectStart: 0x0
-; OBJ:       Range: 0x7
-; OBJ:     }
+; OBJ:     Register: EAX (0x11)
+; OBJ:     Name: b
 ; OBJ:   }
 ; OBJ:   InlineSiteEnd {
 ; OBJ:   }
 ; OBJ:   ProcEnd
 ; OBJ: ]
 
 ; ModuleID = 't.cpp'
 source_filename = "test/DebugInfo/COFF/register-variables.ll"

llvm/test/DebugInfo/COFF/typedef.ll

 ; RUN: llc < %s -filetype=obj | llvm-readobj - -codeview | FileCheck %s
 
 ; CHECK: CodeViewDebugInfo [
 ; CHECK:   Subsection [
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: wchar_t (0x71)
-; CHECK:       Flags [ (0x0)
-; CHECK:       ]
-; CHECK:       VarName: foo
+; CHECK:       Name: foo
 ; CHECK:     }
 ; CHECK:   Subsection [
 ; CHECK:     SubSectionType: Symbols (0xF1)
 ; CHECK:     UDTSym {
 ; CHECK:       Type: wchar_t (0x71)
 ; CHECK:       UDTName: XYZ
 ; CHECK:     }
 ; CHECK:   ]

llvm/test/DebugInfo/COFF/types-array-advanced.ll

 ; CHECK:   }
 ; CHECK:   Array (0x1003) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
 ; CHECK:     ElementType: int (0x74)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 4
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Array (0x1004) {
+; CHECK:   Pointer (0x1004) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: 0x1003
+; CHECK:     PointerAttributes: 0x2A
+; CHECK:     PtrType: Near32 (0xA)
+; CHECK:     PtrMode: LValueReference (0x1)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     SizeOf: 0
+; CHECK:   }
+; CHECK:   Array (0x1005) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
 ; CHECK:     ElementType: char (0x70)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 7
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Array (0x1005) {
+; CHECK:   Array (0x1006) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK:     ElementType: 0x1004
+; CHECK:     ElementType: 0x1005
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 35
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Array (0x1006) {
+; CHECK:   Array (0x1007) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK:     ElementType: 0x1005
+; CHECK:     ElementType: 0x1006
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 70
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Struct (0x1007) {
+; CHECK:   Struct (0x1008) {
 ; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
 ; CHECK:     MemberCount: 0
 ; CHECK:     Properties [ (0x280)
 ; CHECK:       ForwardReference (0x80)
 ; CHECK:       HasUniqueName (0x200)
 ; CHECK:     ]
 ; CHECK:     FieldList: 0x0
 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: incomplete_struct
 ; CHECK:     LinkageName: .?AUincomplete_struct@@
 ; CHECK:   }
-; CHECK:   Array (0x1008) {
+; CHECK:   Array (0x1009) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK:     ElementType: incomplete_struct (0x1007)
+; CHECK:     ElementType: incomplete_struct (0x1008)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 12
 ; CHECK:     Name: 
 ; CHECK:   }
-; CHECK:   Pointer (0x1009) {
+; CHECK:   Pointer (0x100A) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
-; CHECK:     PointeeType: 0x1008
+; CHECK:     PointeeType: 0x1009
 ; CHECK:     PointerAttributes: 0x800A
 ; CHECK:     PtrType: Near32 (0xA)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 4
 ; CHECK:   }
-;
-; CHECK:   Modifier (0x100E) {
+; CHECK:   FieldList (0x100B) {
+; CHECK:     TypeLeafKind: LF_FIELDLIST (0x1203)
+; CHECK:     DataMember {
+; CHECK:       TypeLeafKind: LF_MEMBER (0x150D)
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       Type: int (0x74)
+; CHECK:       FieldOffset: 0x0
+; CHECK:       Name: s1
+; CHECK:     }
+; CHECK:   }
+; CHECK:   Struct (0x100C) {
+; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
+; CHECK:     MemberCount: 1
+; CHECK:     Properties [ (0x200)
+; CHECK:       HasUniqueName (0x200)
+; CHECK:     ]
+; CHECK:     FieldList: <field list> (0x100B)
+; CHECK:     DerivedFrom: 0x0
+; CHECK:     VShape: 0x0
+; CHECK:     SizeOf: 4
+; CHECK:     Name: incomplete_struct
+; CHECK:     LinkageName: .?AUincomplete_struct@@
+; CHECK:   }
+; CHECK:   StringId (0x100D) {
+; CHECK:     TypeLeafKind: LF_STRING_ID (0x1605)
+; CHECK:     Id: 0x0
+; CHECK:     StringData: \t.cpp
+; CHECK:   }
+; CHECK:   UdtSourceLine (0x100E) {
+; CHECK:     TypeLeafKind: LF_UDT_SRC_LINE (0x1606)
+; CHECK:     UDT: incomplete_struct (0x100C)
+; CHECK:     SourceFile: \t.cpp (0x100D)
+; CHECK:     LineNumber: 4
+; CHECK:   }
+; CHECK:   Modifier (0x100F) {
 ; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
 ; CHECK:     ModifiedType: int (0x74)
 ; CHECK:     Modifiers [ (0x3)
 ; CHECK:       Const (0x1)
 ; CHECK:       Volatile (0x2)
 ; CHECK:     ]
 ; CHECK:   }
-; CHECK:   Array (0x100F) {
+; CHECK:   Array (0x1010) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK:     ElementType: const volatile int (0x100E)
+; CHECK:     ElementType: const volatile int (0x100F)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 16
-; CHECK:     Name:
+; CHECK:     Name: 
 ; CHECK:   }
 ; CHECK: ]
 
 source_filename = "test/DebugInfo/COFF/types-array-advanced.ll"
 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.31101"
 
 %struct.incomplete_struct = type { i32 }

llvm/test/DebugInfo/COFF/types-array.ll

 ; CHECK:       FunctionType: f (0x1002)
 ; CHECK:       CodeOffset: ?f@@YAXXZ+0x0
 ; CHECK:       Segment: 0x0
 ; CHECK:       Flags [ (0x0)
 ; CHECK:       ]
 ; CHECK:       DisplayName: f
 ; CHECK:       LinkageName: ?f@@YAXXZ
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     BPRelativeSym {
+; CHECK:       Offset: -20
 ; CHECK:       Type: 0x1003
-; CHECK:       Flags [ (0x0)
-; CHECK:       ]
 ; CHECK:       VarName: a
 ; CHECK:     }
-; CHECK:     DefRangeRegisterRelSym {
-; CHECK:       BaseRegister: 22
-; CHECK:       HasSpilledUDTMember: No
-; CHECK:       OffsetInParent: 0
-; CHECK:       BasePointerOffset: -20
-; CHECK:       LocalVariableAddrRange {
-; CHECK:         OffsetStart: .text+0x3
-; CHECK:         ISectStart: 0x0
-; CHECK:         Range: 0x36
-; CHECK:       }
-; CHECK:     }
 ; CHECK:     ProcEnd {
 ; CHECK:     }
 ; CHECK:   ]
 
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc19.0.23918"

llvm/test/DebugInfo/COFF/types-basic.ll

 ; CHECK:     }
 ; CHECK:     LocalSym {
 ; CHECK:       Type: __int64 (0x13)
 ; CHECK:       Flags [ (0x1)
 ; CHECK:         IsParameter (0x1)
 ; CHECK:       ]
 ; CHECK:       VarName: p3
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: int (0x74)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: v1
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: int* (0x674)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: v2
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: const int* (0x1004)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: v21
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: void* (0x603)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: v3
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: int A::* (0x1006)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: v4
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: void A::() A::* (0x100E)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: v5
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: long (0x12)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: l1
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: long (0x12)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: l2
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: unsigned long (0x22)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: l3
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: unsigned long (0x22)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: l4
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: const void* (0x1010)
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: v6
 ; CHECK:     }
 ; CHECK:     ProcEnd {
 ; CHECK:     }
 ; CHECK:   ]
 ; CHECK:   Subsection [
 ; CHECK:     {{.*}}Proc{{.*}}Sym {
 ; CHECK:       Type: CharTypes (0x1012)
 ; CHECK:       DisplayName: CharTypes
 ; CHECK:       LinkageName: ?CharTypes@@YAXXZ
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: wchar_t (0x71)
-; CHECK:       Flags [ (0x0)
-; CHECK:       ]
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: w
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: unsigned short (0x21)
-; CHECK:       Flags [ (0x0)
-; CHECK:       ]
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: us
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: char (0x70)
-; CHECK:       Flags [ (0x0)
-; CHECK:       ]
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: c
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: unsigned char (0x20)
-; CHECK:       Flags [ (0x0)
-; CHECK:       ]
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: uc
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: signed char (0x10)
-; CHECK:       Flags [ (0x0)
-; CHECK:       ]
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: sc
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: char16_t (0x7A)
-; CHECK:       Flags [ (0x0)
-; CHECK:       ]
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: c16
 ; CHECK:     }
-; CHECK:     LocalSym {
+; CHECK:     RegRelativeSym {
 ; CHECK:       Type: char32_t (0x7B)
-; CHECK:       Flags [ (0x0)
-; CHECK:       ]
+; CHECK:       Register: RSP (0x14F)
 ; CHECK:       VarName: c32
 ; CHECK:     }
 ; CHECK:     ProcEnd {
 ; CHECK:     }
 ; CHECK:   ]
 ; CHECK: ]
 
 ; ModuleID = 't.cpp'