[LLDB] DynamicRegisterInfo calculate offsets in separate function

[omjavaid]

Summary

This patch pull offset calculation logic out of DynamicRegisterInfo::Finalize into a separate function. We are going to call this function whenever we update SVE register sizes.

[labath]

LG, modulo inline comment.

lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.h

45–46

Users should not be calling this, right? Could we make this protected?

lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.h

public:
 
   void AddRegister(lldb_private::RegisterInfo &reg_info,
                    lldb_private::ConstString &reg_name,
                    lldb_private::ConstString &reg_alt_name,
                    lldb_private::ConstString &set_name);
 
   void Finalize(const lldb_private::ArchSpec &arch);
 
   size_t GetNumRegisters() const;
 
   size_t GetNumRegisterSets() const;
 
   size_t GetRegisterDataByteSize() const;
 
   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(uint32_t i) const;
 
   lldb_private::RegisterInfo *GetRegisterInfoAtIndex(uint32_t i);
 
protected:
   typedef std::vector<uint8_t> dwarf_opcode;
   typedef std::map<uint32_t, dwarf_opcode> dynamic_reg_size_map;
 
   const lldb_private::RegisterInfo *
   GetRegisterInfo(llvm::StringRef reg_name) const;
 
   void MoveFrom(DynamicRegisterInfo &&info);
 
+  void ConfigureOffsets();
+
   reg_collection m_regs;
   set_collection m_sets;
   set_reg_num_collection m_set_reg_nums;
   name_collection m_set_names;
   reg_to_regs_map m_value_regs_map;
   reg_to_regs_map m_invalidate_regs_map;
   dynamic_reg_size_map m_dynamic_reg_size_map;
   size_t m_reg_data_byte_size = 0u; // The number of bytes required to store
                                     // all registers
   bool m_finalized = false;
   bool m_is_reconfigurable = false;
 };
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_UTILITY_DYNAMICREGISTERINFO_H

lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

void DynamicRegisterInfo::Finalize(const ArchSpec &arch) {
   m_finalized = true;
   const size_t num_sets = m_sets.size();
   for (size_t set = 0; set < num_sets; ++set) {
     assert(m_sets.size() == m_set_reg_nums.size());
     m_sets[set].num_registers = m_set_reg_nums[set].size();
     m_sets[set].registers = m_set_reg_nums[set].data();
   }
 
-  // We are going to create a map between remote (eRegisterKindProcessPlugin)
-  // and local (eRegisterKindLLDB) register numbers. This map will give us
-  // remote register numbers in increasing order for offset calculation.
-  std::map<uint32_t, uint32_t> remote_to_local_regnum_map;
-  for (const auto &reg : m_regs)
-    remote_to_local_regnum_map[reg.kinds[eRegisterKindProcessPlugin]] =
-        reg.kinds[eRegisterKindLLDB];
-
-  // At this stage we manually calculate g/G packet offsets of all primary
-  // registers, only if target XML or qRegisterInfo packet did not send
-  // an offset explicitly.
-  uint32_t reg_offset = 0;
-  for (auto const &regnum_pair : remote_to_local_regnum_map) {
-    if (m_regs[regnum_pair.second].byte_offset == LLDB_INVALID_INDEX32 &&
-        m_regs[regnum_pair.second].value_regs == nullptr) {
-      m_regs[regnum_pair.second].byte_offset = reg_offset;
-
-      reg_offset = m_regs[regnum_pair.second].byte_offset +
-                   m_regs[regnum_pair.second].byte_size;
-    }
-  }
-
   // sort and unique all value registers and make sure each is terminated with
   // LLDB_INVALID_REGNUM
 
   for (reg_to_regs_map::iterator pos = m_value_regs_map.begin(),
                                  end = m_value_regs_map.end();
        pos != end; ++pos) {
     if (pos->second.size() > 1) {
       llvm::sort(pos->second.begin(), pos->second.end());
       reg_num_collection::iterator unique_end =
           std::unique(pos->second.begin(), pos->second.end());
       if (unique_end != pos->second.end())
         pos->second.erase(unique_end, pos->second.end());
     }
     assert(!pos->second.empty());
     if (pos->second.back() != LLDB_INVALID_REGNUM)
       pos->second.push_back(LLDB_INVALID_REGNUM);
   }
 
   // Now update all value_regs with each register info as needed
   const size_t num_regs = m_regs.size();
   for (size_t i = 0; i < num_regs; ++i) {
-    if (m_value_regs_map.find(i) != m_value_regs_map.end()) {
+    if (m_value_regs_map.find(i) != m_value_regs_map.end())
       m_regs[i].value_regs = m_value_regs_map[i].data();
-      // Assign a valid offset to all pseudo registers if not assigned by stub.
-      // Pseudo registers with value_regs list populated will share same offset
-      // as that of their corresponding primary register in value_regs list.
-      if (m_regs[i].byte_offset == LLDB_INVALID_INDEX32) {
-        uint32_t value_regnum = m_regs[i].value_regs[0];
-        if (value_regnum != LLDB_INVALID_INDEX32)
-          m_regs[i].byte_offset =
-              GetRegisterInfoAtIndex(remote_to_local_regnum_map[value_regnum])
-                  ->byte_offset;
-      }
-    } else
+    else
       m_regs[i].value_regs = nullptr;
-
-    reg_offset = m_regs[i].byte_offset + m_regs[i].byte_size;
-    if (m_reg_data_byte_size < reg_offset)
-      m_reg_data_byte_size = reg_offset;
   }
 
   // Expand all invalidation dependencies
   for (reg_to_regs_map::iterator pos = m_invalidate_regs_map.begin(),
                                  end = m_invalidate_regs_map.end();
        pos != end; ++pos) {
     const uint32_t reg_num = pos->first;
 
case llvm::Triple::x86_64:
           reg.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS;
       }
       break;
 
     default:
       break;
     }
   }
+
+  // At this stage call ConfigureOffsets to calculate register offsets for
+  // targets supporting dynamic offset calculation. It also calculates
+  // total byte size of register data.
+  ConfigureOffsets();
+}
+
+void DynamicRegisterInfo::ConfigureOffsets() {
+  // We are going to create a map between remote (eRegisterKindProcessPlugin)
+  // and local (eRegisterKindLLDB) register numbers. This map will give us
+  // remote register numbers in increasing order for offset calculation.
+  std::map<uint32_t, uint32_t> remote_to_local_regnum_map;
+  for (const auto &reg : m_regs)
+    remote_to_local_regnum_map[reg.kinds[eRegisterKindProcessPlugin]] =
+        reg.kinds[eRegisterKindLLDB];
+
+  // At this stage we manually calculate g/G packet offsets of all primary
+  // registers, only if target XML or qRegisterInfo packet did not send
+  // an offset explicitly.
+  uint32_t reg_offset = 0;
+  for (auto const &regnum_pair : remote_to_local_regnum_map) {
+    if (m_regs[regnum_pair.second].byte_offset == LLDB_INVALID_INDEX32 &&
+        m_regs[regnum_pair.second].value_regs == nullptr) {
+      m_regs[regnum_pair.second].byte_offset = reg_offset;
+
+      reg_offset = m_regs[regnum_pair.second].byte_offset +
+                   m_regs[regnum_pair.second].byte_size;
+    }
+  }
+
+  // Now update all value_regs with each register info as needed
+  for (auto &reg : m_regs) {
+    if (reg.value_regs != nullptr) {
+      // Assign a valid offset to all pseudo registers if not assigned by stub.
+      // Pseudo registers with value_regs list populated will share same offset
+      // as that of their corresponding primary register in value_regs list.
+      if (reg.byte_offset == LLDB_INVALID_INDEX32) {
+        uint32_t value_regnum = reg.value_regs[0];
+        if (value_regnum != LLDB_INVALID_INDEX32)
+          reg.byte_offset =
+              GetRegisterInfoAtIndex(remote_to_local_regnum_map[value_regnum])
+                  ->byte_offset;
+      }
+    }
+
+    reg_offset = reg.byte_offset + reg.byte_size;
+    if (m_reg_data_byte_size < reg_offset)
+      m_reg_data_byte_size = reg_offset;
+  }
 }
 
 bool DynamicRegisterInfo::IsReconfigurable() { return m_is_reconfigurable; }
 
 size_t DynamicRegisterInfo::GetNumRegisters() const { return m_regs.size(); }
 
 size_t DynamicRegisterInfo::GetNumRegisterSets() const { return m_sets.size(); }