lldb/Target/DynamicRegisterInfo.h

0001 //===-- DynamicRegisterInfo.h -----------------------------------*- C++ -*-===//
0002 //
0003 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0004 // See https://llvm.org/LICENSE.txt for license information.
0005 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0006 //
0007 //===----------------------------------------------------------------------===//
0008
0009 #ifndef LLDB_TARGET_DYNAMICREGISTERINFO_H
0010 #define LLDB_TARGET_DYNAMICREGISTERINFO_H
0011
0012 #include <map>
0013 #include <vector>
0014
0015 #include "lldb/Target/RegisterFlags.h"
0016 #include "lldb/Utility/ConstString.h"
0017 #include "lldb/Utility/StructuredData.h"
0018 #include "lldb/lldb-private.h"
0019
0020 namespace lldb_private {
0021
0022 class DynamicRegisterInfo {
0023 protected:
0024   DynamicRegisterInfo(DynamicRegisterInfo &) = default;
0025   DynamicRegisterInfo &operator=(DynamicRegisterInfo &) = default;
0026
0027 public:
0028   struct Register {
0029     ConstString name;
0030     ConstString alt_name;
0031     ConstString set_name;
0032     uint32_t byte_size = LLDB_INVALID_INDEX32;
0033     uint32_t byte_offset = LLDB_INVALID_INDEX32;
0034     lldb::Encoding encoding = lldb::eEncodingUint;
0035     lldb::Format format = lldb::eFormatHex;
0036     uint32_t regnum_dwarf = LLDB_INVALID_REGNUM;
0037     uint32_t regnum_ehframe = LLDB_INVALID_REGNUM;
0038     uint32_t regnum_generic = LLDB_INVALID_REGNUM;
0039     uint32_t regnum_remote = LLDB_INVALID_REGNUM;
0040     std::vector<uint32_t> value_regs;
0041     std::vector<uint32_t> invalidate_regs;
0042     uint32_t value_reg_offset = 0;
0043     // Non-null if there is an XML provided type.
0044     const RegisterFlags *flags_type = nullptr;
0045   };
0046
0047   DynamicRegisterInfo() = default;
0048
0049   static std::unique_ptr<DynamicRegisterInfo>
0050   Create(const StructuredData::Dictionary &dict, const ArchSpec &arch);
0051
0052   virtual ~DynamicRegisterInfo() = default;
0053
0054   DynamicRegisterInfo(DynamicRegisterInfo &&info);
0055   DynamicRegisterInfo &operator=(DynamicRegisterInfo &&info);
0056
0057   size_t SetRegisterInfo(const lldb_private::StructuredData::Dictionary &dict,
0058                          const lldb_private::ArchSpec &arch);
0059
0060   size_t SetRegisterInfo(std::vector<Register> &&regs,
0061                          const lldb_private::ArchSpec &arch);
0062
0063   size_t GetNumRegisters() const;
0064
0065   size_t GetNumRegisterSets() const;
0066
0067   size_t GetRegisterDataByteSize() const;
0068
0069   const lldb_private::RegisterInfo *GetRegisterInfoAtIndex(uint32_t i) const;
0070
0071   const lldb_private::RegisterSet *GetRegisterSet(uint32_t i) const;
0072
0073   uint32_t GetRegisterSetIndexByName(const lldb_private::ConstString &set_name,
0074                                      bool can_create);
0075
0076   uint32_t ConvertRegisterKindToRegisterNumber(uint32_t kind,
0077                                                uint32_t num) const;
0078
0079   const lldb_private::RegisterInfo *GetRegisterInfo(uint32_t kind,
0080                                                     uint32_t num) const;
0081
0082   void Dump() const;
0083
0084   void Clear();
0085
0086   bool IsReconfigurable();
0087
0088   const lldb_private::RegisterInfo *
0089   GetRegisterInfo(llvm::StringRef reg_name) const;
0090
0091   typedef std::vector<lldb_private::RegisterInfo> reg_collection;
0092   typedef llvm::iterator_range<reg_collection::const_iterator>
0093       reg_collection_const_range;
0094   typedef llvm::iterator_range<reg_collection::iterator> reg_collection_range;
0095
0096   template <typename T> T registers() = delete;
0097
0098   void ConfigureOffsets();
0099
0100 protected:
0101   // Classes that inherit from DynamicRegisterInfo can see and modify these
0102   typedef std::vector<lldb_private::RegisterSet> set_collection;
0103   typedef std::vector<uint32_t> reg_num_collection;
0104   typedef std::vector<reg_num_collection> set_reg_num_collection;
0105   typedef std::vector<lldb_private::ConstString> name_collection;
0106   typedef std::map<uint32_t, reg_num_collection> reg_to_regs_map;
0107   typedef std::map<uint32_t, uint32_t> reg_offset_map;
0108
0109   llvm::Expected<uint32_t> ByteOffsetFromSlice(uint32_t index,
0110                                                llvm::StringRef slice_str,
0111                                                lldb::ByteOrder byte_order);
0112   llvm::Expected<uint32_t> ByteOffsetFromComposite(
0113       uint32_t index, lldb_private::StructuredData::Array &composite_reg_list,
0114       lldb::ByteOrder byte_order);
0115   llvm::Expected<uint32_t> ByteOffsetFromRegInfoDict(
0116       uint32_t index, lldb_private::StructuredData::Dictionary &reg_info_dict,
0117       lldb::ByteOrder byte_order);
0118
0119   void MoveFrom(DynamicRegisterInfo &&info);
0120
0121   void Finalize(const lldb_private::ArchSpec &arch);
0122
0123   reg_collection m_regs;
0124   set_collection m_sets;
0125   set_reg_num_collection m_set_reg_nums;
0126   name_collection m_set_names;
0127   reg_to_regs_map m_value_regs_map;
0128   reg_to_regs_map m_invalidate_regs_map;
0129   reg_offset_map m_value_reg_offset_map;
0130   size_t m_reg_data_byte_size = 0u; // The number of bytes required to store
0131                                     // all registers
0132   bool m_finalized = false;
0133   bool m_is_reconfigurable = false;
0134 };
0135
0136 template <>
0137 inline DynamicRegisterInfo::reg_collection_const_range
0138 DynamicRegisterInfo::registers() {
0139   return reg_collection_const_range(m_regs);
0140 }
0141
0142 template <>
0143 inline DynamicRegisterInfo::reg_collection_range
0144 DynamicRegisterInfo::registers() {
0145   return reg_collection_range(m_regs);
0146 }
0147
0148 void addSupplementaryRegister(std::vector<DynamicRegisterInfo::Register> &regs,
0149                               DynamicRegisterInfo::Register new_reg_info);
0150
0151 } // namespace lldb_private
0152
0153 #endif // LLDB_TARGET_DYNAMICREGISTERINFO_H