[LLDB][NativePDB] Add support for S_DEFRANGE_REGISTER and S_DEFRANGE_SUBFIELD_REGISTER

ZequanWu · ZequanWu · commit 5e9c9b324a1f · 2022-03-10T12:40:31.000-08:00
Differential Revision: https://reviews.llvm.org/D119508
diff --git a/lldb/include/lldb/Utility/RangeMap.h b/lldb/include/lldb/Utility/RangeMap.h
@@ -59,6 +59,17 @@ template <typename B, typename S> struct Range {
     return false;
   }
 
+  Range Intersect(const Range &rhs) const {
+    const BaseType lhs_base = this->GetRangeBase();
+    const BaseType rhs_base = rhs.GetRangeBase();
+    const BaseType lhs_end = this->GetRangeEnd();
+    const BaseType rhs_end = rhs.GetRangeEnd();
+    Range range;
+    range.SetRangeBase(std::max(lhs_base, rhs_base));
+    range.SetRangeEnd(std::min(lhs_end, rhs_end));
+    return range;
+  }
+
   BaseType GetRangeEnd() const { return base + size; }
 
   void SetRangeEnd(BaseType end) {
@@ -99,12 +110,7 @@ template <typename B, typename S> struct Range {
 
   // Returns true if the two ranges intersect
   bool DoesIntersect(const Range &rhs) const {
-    const BaseType lhs_base = this->GetRangeBase();
-    const BaseType rhs_base = rhs.GetRangeBase();
-    const BaseType lhs_end = this->GetRangeEnd();
-    const BaseType rhs_end = rhs.GetRangeEnd();
-    bool result = (lhs_base < rhs_end) && (lhs_end > rhs_base);
-    return result;
+    return Intersect(rhs).IsValid();
   }
 
   bool operator<(const Range &rhs) const {
@@ -133,6 +139,38 @@ template <typename B, typename S, unsigned N = 0> class RangeVector {
 
   ~RangeVector() = default;
 
+  static RangeVector GetOverlaps(const RangeVector &vec1,
+                                 const RangeVector &vec2) {
+#ifdef ASSERT_RANGEMAP_ARE_SORTED
+    assert(vec1.IsSorted() && vec2.IsSorted());
+#endif
+    RangeVector result;
+    auto pos1 = vec1.begin();
+    auto end1 = vec1.end();
+    auto pos2 = vec2.begin();
+    auto end2 = vec2.end();
+    while (pos1 != end1 && pos2 != end2) {
+      Entry entry = pos1->Intersect(*pos2);
+      if (entry.IsValid())
+        result.Append(entry);
+      if (pos1->GetRangeEnd() < pos2->GetRangeEnd())
+        ++pos1;
+      else
+        ++pos2;
+    }
+    return result;
+  }
+
+  bool operator==(const RangeVector &rhs) const {
+    if (GetSize() != rhs.GetSize())
+      return false;
+    for (size_t i = 0; i < GetSize(); ++i) {
+      if (GetEntryRef(i) != rhs.GetEntryRef(i))
+        return false;
+    }
+    return true;
+  }
+
   void Append(const Entry &entry) { m_entries.push_back(entry); }
 
   void Append(B base, S size) { m_entries.emplace_back(base, size); }
diff --git a/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp b/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp
@@ -250,3 +250,29 @@ DWARFExpression lldb_private::npdb::MakeConstantLocationExpression(
   DWARFExpression result(nullptr, extractor, nullptr);
   return result;
 }
+
+DWARFExpression lldb_private::npdb::MakeEnregisteredLocationExpressionForClass(
+    llvm::ArrayRef<std::pair<RegisterId, uint32_t>> &members_info,
+    lldb::ModuleSP module) {
+  return MakeLocationExpressionInternal(
+      module, [&](Stream &stream, RegisterKind &register_kind) -> bool {
+        for (auto member_info : members_info) {
+          if (member_info.first != llvm::codeview::RegisterId::NONE) {
+            uint32_t reg_num =
+                GetRegisterNumber(module->GetArchitecture().GetMachine(),
+                                  member_info.first, register_kind);
+            if (reg_num == LLDB_INVALID_REGNUM)
+              return false;
+            if (reg_num > 31) {
+              stream.PutHex8(llvm::dwarf::DW_OP_regx);
+              stream.PutULEB128(reg_num);
+            } else {
+              stream.PutHex8(llvm::dwarf::DW_OP_reg0 + reg_num);
+            }
+          }
+          stream.PutHex8(llvm::dwarf::DW_OP_piece);
+          stream.PutULEB128(member_info.second);
+        }
+        return true;
+      });
+}
diff --git a/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.h b/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.h
@@ -10,6 +10,7 @@
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_DWARFLOCATIONEXPRESSION_H
 
 #include "lldb/lldb-forward.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/DebugInfo/CodeView/CodeView.h"
 
 namespace llvm {
@@ -39,6 +40,10 @@ DWARFExpression MakeGlobalLocationExpression(uint16_t section, uint32_t offset,
 DWARFExpression MakeConstantLocationExpression(
     llvm::codeview::TypeIndex underlying_ti, llvm::pdb::TpiStream &tpi,
     const llvm::APSInt &constant, lldb::ModuleSP module);
+DWARFExpression MakeEnregisteredLocationExpressionForClass(
+    llvm::ArrayRef<std::pair<llvm::codeview::RegisterId, uint32_t>>
+        &members_info,
+    lldb::ModuleSP module);
 } // namespace npdb
 } // namespace lldb_private
 
diff --git a/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp b/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp
@@ -497,7 +497,8 @@ clang::Decl *PdbAstBuilder::GetOrCreateSymbolForId(PdbCompilandSymId id) {
   if (isLocalVariableType(cvs.kind())) {
     clang::DeclContext *scope = GetParentDeclContext(id);
     clang::Decl *scope_decl = clang::Decl::castFromDeclContext(scope);
-    PdbCompilandSymId scope_id(id.modi, m_decl_to_status[scope_decl].uid);
+    PdbCompilandSymId scope_id =
+        PdbSymUid(m_decl_to_status[scope_decl].uid).asCompilandSym();
     return GetOrCreateVariableDecl(scope_id, id);
   }
 
diff --git a/lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.cpp b/lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.cpp
@@ -12,6 +12,7 @@
 #include "PdbIndex.h"
 #include "PdbSymUid.h"
 
+#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
@@ -20,6 +21,7 @@
 #include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Utility/LLDBAssert.h"
+#include "lldb/Utility/LLDBLog.h"
 #include "lldb/lldb-enumerations.h"
 
 using namespace lldb_private;
@@ -48,6 +50,22 @@ MakeRangeList(const PdbIndex &index, const LocalVariableAddrRange &range,
   return result;
 }
 
+namespace {
+struct FindMembersSize : public TypeVisitorCallbacks {
+  FindMembersSize(std::vector<std::pair<RegisterId, uint32_t>> &members_info,
+                  TpiStream &tpi)
+      : members_info(members_info), tpi(tpi) {}
+  std::vector<std::pair<RegisterId, uint32_t>> &members_info;
+  TpiStream &tpi;
+  llvm::Error visitKnownMember(CVMemberRecord &cvr,
+                               DataMemberRecord &member) override {
+    members_info.emplace_back(llvm::codeview::RegisterId::NONE,
+                              GetSizeOfType(member.Type, tpi));
+    return llvm::Error::success();
+  }
+};
+} // namespace
+
 CVTagRecord CVTagRecord::create(CVType type) {
   assert(IsTagRecord(type) && "type is not a tag record!");
   switch (type.kind()) {
@@ -477,6 +495,8 @@ VariableInfo lldb_private::npdb::GetVariableNameInfo(CVSymbol sym) {
     cantFail(SymbolDeserializer::deserializeAs<LocalSym>(sym, local));
     result.type = local.Type;
     result.name = local.Name;
+    result.is_param =
+        ((local.Flags & LocalSymFlags::IsParameter) != LocalSymFlags::None);
     return result;
   }
 
@@ -609,7 +629,8 @@ VariableInfo lldb_private::npdb::GetVariableLocationInfo(
     PdbCompilandSymId loc_specifier_id(var_id.modi,
                                        var_id.offset + sym.RecordData.size());
     CVSymbol loc_specifier_cvs = index.ReadSymbolRecord(loc_specifier_id);
-    if (loc_specifier_cvs.kind() == S_DEFRANGE_FRAMEPOINTER_REL) {
+    switch(loc_specifier_cvs.kind()) {
+    case S_DEFRANGE_FRAMEPOINTER_REL: {
       DefRangeFramePointerRelSym loc(
           SymbolRecordKind::DefRangeFramePointerRelSym);
       cantFail(SymbolDeserializer::deserializeAs<DefRangeFramePointerRelSym>(
@@ -632,10 +653,8 @@ VariableInfo lldb_private::npdb::GetVariableLocationInfo(
       PdbCompilandSymId frame_proc_id(
           func_scope_id.modi, func_scope_id.offset + func_block_cvs.length());
 
-      bool is_parameter =
-          ((local.Flags & LocalSymFlags::IsParameter) != LocalSymFlags::None);
       RegisterId base_reg =
-          GetBaseFrameRegister(index, frame_proc_id, is_parameter);
+          GetBaseFrameRegister(index, frame_proc_id, result.is_param);
 
       if (base_reg == RegisterId::VFRAME) {
         llvm::StringRef program;
@@ -651,7 +670,9 @@ VariableInfo lldb_private::npdb::GetVariableLocationInfo(
             MakeRegRelLocationExpression(base_reg, loc.Hdr.Offset, module);
         result.ranges = std::move(ranges);
       }
-    } else if (loc_specifier_cvs.kind() == S_DEFRANGE_REGISTER_REL) {
+      break;
+    } 
+    case S_DEFRANGE_REGISTER_REL: {
       DefRangeRegisterRelSym loc(SymbolRecordKind::DefRangeRegisterRelSym);
       cantFail(SymbolDeserializer::deserializeAs<DefRangeRegisterRelSym>(
           loc_specifier_cvs, loc));
@@ -674,9 +695,76 @@ VariableInfo lldb_private::npdb::GetVariableLocationInfo(
             base_reg, loc.Hdr.BasePointerOffset, module);
         result.ranges = std::move(ranges);
       }
+      break;
     }
+    case S_DEFRANGE_REGISTER: {
+      DefRangeRegisterSym loc(SymbolRecordKind::DefRangeRegisterSym);
+      cantFail(SymbolDeserializer::deserializeAs<DefRangeRegisterSym>(
+          loc_specifier_cvs, loc));
 
-    // FIXME: Handle other kinds
+      RegisterId base_reg = (RegisterId)(uint16_t)loc.Hdr.Register;
+      result.ranges = MakeRangeList(index, loc.Range, loc.Gaps);
+      result.location = MakeEnregisteredLocationExpression(base_reg, module);
+      break;
+    }
+    case S_DEFRANGE_SUBFIELD_REGISTER: {
+      CVType class_cvt = index.tpi().getType(result.type);
+      ClassRecord class_record = CVTagRecord::create(class_cvt).asClass();
+      CVType field_list = index.tpi().getType(class_record.FieldList);
+      std::vector<std::pair<RegisterId, uint32_t>> members_info;
+      FindMembersSize find_members_size(members_info, index.tpi());
+      if (llvm::Error err =
+              visitMemberRecordStream(field_list.data(), find_members_size))
+        llvm::consumeError(std::move(err));
+
+      std::vector<Variable::RangeList> range_lists;
+      uint32_t cur_offset = 0;
+      size_t member_idx = 0;
+      // Assuming S_DEFRANGE_SUBFIELD_REGISTER is followed only by
+      // S_DEFRANGE_SUBFIELD_REGISTER, need to verify.
+      while (loc_specifier_cvs.kind() == S_DEFRANGE_SUBFIELD_REGISTER &&
+             member_idx < members_info.size()) {
+        DefRangeSubfieldRegisterSym loc(
+            SymbolRecordKind::DefRangeSubfieldRegisterSym);
+        cantFail(SymbolDeserializer::deserializeAs<DefRangeSubfieldRegisterSym>(
+            loc_specifier_cvs, loc));
+
+        if (result.ranges) {
+          result.ranges = Variable::RangeList::GetOverlaps(
+              *result.ranges, MakeRangeList(index, loc.Range, loc.Gaps));
+        } else {
+          result.ranges = MakeRangeList(index, loc.Range, loc.Gaps);
+          result.ranges->Sort();
+        }
+
+        // Some fields maybe optimized away and have no
+        // S_DEFRANGE_SUBFIELD_REGISTER to describe them. Skip them.
+        while (loc.Hdr.OffsetInParent != cur_offset) {
+          cur_offset += members_info[member_idx].second;
+          ++member_idx;
+        }
+        if (member_idx < members_info.size()) {
+          members_info[member_idx].first =
+              (RegisterId)(uint16_t)loc.Hdr.Register;
+          cur_offset += members_info[member_idx].second;
+          ++member_idx;
+        }
+        // Go to next S_DEFRANGE_SUBFIELD_REGISTER.
+        loc_specifier_id = PdbCompilandSymId(
+            loc_specifier_id.modi,
+            loc_specifier_id.offset + loc_specifier_cvs.RecordData.size());
+        loc_specifier_cvs = index.ReadSymbolRecord(loc_specifier_id);
+      }
+      auto member_info_ref = llvm::makeArrayRef(members_info);
+      result.location =
+          MakeEnregisteredLocationExpressionForClass(member_info_ref, module);
+      break;
+    }
+    default:
+      // FIXME: Handle other kinds. LLVM only generates the 4 types of records
+      // above.
+      break;
+    }
     return result;
   }
   llvm_unreachable("Symbol is not a local variable!");
diff --git a/lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.h b/lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.h
@@ -105,6 +105,7 @@ struct VariableInfo {
   llvm::codeview::TypeIndex type;
   llvm::Optional<DWARFExpression> location;
   llvm::Optional<Variable::RangeList> ranges;
+  bool is_param;
 };
 
 llvm::pdb::PDB_SymType CVSymToPDBSym(llvm::codeview::SymbolKind kind);
diff --git a/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp b/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
@@ -1665,6 +1665,7 @@ VariableSP SymbolFileNativePDB::CreateLocalVariable(PdbCompilandSymId scope_id,
   SymbolFileTypeSP sftype =
       std::make_shared<SymbolFileType>(*this, type_sp->GetID());
 
+  is_param |= var_info.is_param;
   ValueType var_scope =
       is_param ? eValueTypeVariableArgument : eValueTypeVariableLocal;
   bool external = false;
@@ -1673,7 +1674,7 @@ VariableSP SymbolFileNativePDB::CreateLocalVariable(PdbCompilandSymId scope_id,
   bool static_member = false;
   VariableSP var_sp = std::make_shared<Variable>(
       toOpaqueUid(var_id), name.c_str(), name.c_str(), sftype, var_scope,
-      comp_unit_sp.get(), *var_info.ranges, &decl, *var_info.location, external,
+      &block, *var_info.ranges, &decl, *var_info.location, external,
       artificial, location_is_constant_data, static_member);
 
   if (!is_param)
diff --git a/lldb/source/Symbol/Variable.cpp b/lldb/source/Symbol/Variable.cpp
@@ -243,6 +243,14 @@ bool Variable::LocationIsValidForAddress(const Address &address) {
   // Be sure to resolve the address to section offset prior to calling this
   // function.
   if (address.IsSectionOffset()) {
+    // We need to check if the address is valid for both scope range and value
+    // range. 
+    // Empty scope range means block range.
+    bool valid_in_scope_range =
+        GetScopeRange().IsEmpty() || GetScopeRange().FindEntryThatContains(
+                                         address.GetFileAddress()) != nullptr;
+    if (!valid_in_scope_range)
+      return false;
     SymbolContext sc;
     CalculateSymbolContext(&sc);
     if (sc.module_sp == address.GetModule()) {
diff --git a/lldb/test/Shell/SymbolFile/NativePDB/Inputs/local-variables-registers.lldbinit b/lldb/test/Shell/SymbolFile/NativePDB/Inputs/local-variables-registers.lldbinit
@@ -0,0 +1,11 @@
+image lookup -a 0x140001000 -v
+image lookup -a 0x140001003 -v
+image lookup -a 0x140001006 -v
+
+image lookup -a 0x140001011 -v
+image lookup -a 0x140001017 -v
+image lookup -a 0x140001019 -v
+image lookup -a 0x14000101e -v
+image lookup -a 0x14000102c -v
+
+exit
diff --git a/lldb/test/Shell/SymbolFile/NativePDB/local-variables-registers.s b/lldb/test/Shell/SymbolFile/NativePDB/local-variables-registers.s
diff --git a/lldb/test/Shell/SymbolFile/NativePDB/stack_unwinding01.cpp b/lldb/test/Shell/SymbolFile/NativePDB/stack_unwinding01.cpp
diff --git a/lldb/unittests/Utility/RangeMapTest.cpp b/lldb/unittests/Utility/RangeMapTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -497,7 +497,8 @@ clang::Decl *PdbAstBuilder::GetOrCreateSymbolForId(PdbCompilandSymId id) {`
`497`	`497`	`if (isLocalVariableType(cvs.kind())) {`
`498`	`498`	`clang::DeclContext *scope = GetParentDeclContext(id);`
`499`	`499`	`clang::Decl *scope_decl = clang::Decl::castFromDeclContext(scope);`
`500`		`- PdbCompilandSymId scope_id(id.modi, m_decl_to_status[scope_decl].uid);`
	`500`	`+ PdbCompilandSymId scope_id =`
	`501`	`+ PdbSymUid(m_decl_to_status[scope_decl].uid).asCompilandSym();`
`501`	`502`	`return GetOrCreateVariableDecl(scope_id, id);`
`502`	`503`	`}`
`503`	`504`