contrib/llvm/tools/lldb/source/Utility/RegisterNumber.cpp

   1 //===--------------------- RegisterNumber.cpp -------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Utility/RegisterNumber.h"
  11 #include "lldb/Target/Thread.h"
  12 #include "lldb/Target/RegisterContext.h"
  13
  14 using namespace lldb_private;
  15
  16
  17 RegisterNumber::RegisterNumber (lldb_private::Thread &thread, lldb::RegisterKind kind, uint32_t num) :
  18     m_reg_ctx_sp (thread.GetRegisterContext()),
  19     m_regnum (num),
  20     m_kind (kind),
  21     m_kind_regnum_map (),
  22     m_name ("")
  23 {
  24     if (m_reg_ctx_sp.get())
  25     {
  26         const lldb_private::RegisterInfo *reginfo = m_reg_ctx_sp->GetRegisterInfoAtIndex (GetAsKind (lldb::eRegisterKindLLDB));
  27         if (reginfo && reginfo->name)
  28         {
  29             m_name = reginfo->name;
  30         }
  31     }
  32 }
  33
  34 RegisterNumber::RegisterNumber () :
  35     m_reg_ctx_sp(),
  36     m_regnum (LLDB_INVALID_REGNUM),
  37     m_kind (lldb::kNumRegisterKinds),
  38     m_kind_regnum_map (),
  39     m_name (nullptr)
  40 {
  41 }
  42
  43 void
  44 RegisterNumber::init (lldb_private::Thread &thread, lldb::RegisterKind kind, uint32_t num)
  45 {
  46     m_reg_ctx_sp = thread.GetRegisterContext();
  47     m_regnum = num;
  48     m_kind = kind;
  49     if (m_reg_ctx_sp.get())
  50     {
  51         const lldb_private::RegisterInfo *reginfo = m_reg_ctx_sp->GetRegisterInfoAtIndex (GetAsKind (lldb::eRegisterKindLLDB));
  52         if (reginfo && reginfo->name)
  53         {
  54             m_name = reginfo->name;
  55         }
  56     }
  57 }
  58
  59 const RegisterNumber &
  60 RegisterNumber::operator = (const RegisterNumber &rhs)
  61 {
  62     m_reg_ctx_sp = rhs.m_reg_ctx_sp;
  63     m_regnum = rhs.m_regnum;
  64     m_kind = rhs.m_kind;
  65     for (auto it : rhs.m_kind_regnum_map)
  66         m_kind_regnum_map[it.first] = it.second;
  67     m_name = rhs.m_name;
  68     return *this;
  69 }
  70
  71 bool
  72 RegisterNumber::operator == (RegisterNumber &rhs)
  73 {
  74     if (IsValid() != rhs.IsValid())
  75         return false;
  76
  77     if (m_kind == rhs.m_kind)
  78     {
  79         if (m_regnum == rhs.m_regnum)
  80             return true;
  81         else
  82             return false;
  83     }
  84
  85     uint32_t rhs_regnum = rhs.GetAsKind (m_kind);
  86     if (rhs_regnum != LLDB_INVALID_REGNUM)
  87     {
  88         if (m_regnum == rhs_regnum)
  89             return true;
  90         else
  91             return false;
  92     }
  93     uint32_t lhs_regnum = GetAsKind (rhs.m_kind);
  94     {
  95         if (lhs_regnum == rhs.m_regnum)
  96             return true;
  97         else
  98             return false;
  99     }
 100     return false;
 101 }
 102
 103 bool
 104 RegisterNumber::operator != (RegisterNumber &rhs)
 105 {
 106     return !(*this == rhs);
 107 }
 108
 109 bool
 110 RegisterNumber::IsValid () const
 111 {
 112     return m_reg_ctx_sp.get()
 113         && m_kind != lldb::kNumRegisterKinds
 114         && m_regnum != LLDB_INVALID_REGNUM;
 115 }
 116
 117 uint32_t
 118 RegisterNumber::GetAsKind (lldb::RegisterKind kind)
 119 {
 120     if (m_regnum == LLDB_INVALID_REGNUM)
 121         return LLDB_INVALID_REGNUM;
 122
 123     if (kind == m_kind)
 124         return m_regnum;
 125
 126     Collection::iterator iter = m_kind_regnum_map.find (kind);
 127     if (iter != m_kind_regnum_map.end())
 128     {
 129         return iter->second;
 130     }
 131     uint32_t output_regnum = LLDB_INVALID_REGNUM;
 132     if (m_reg_ctx_sp
 133         && m_reg_ctx_sp->ConvertBetweenRegisterKinds (m_kind, m_regnum, kind, output_regnum)
 134         && output_regnum != LLDB_INVALID_REGNUM)
 135     {
 136         m_kind_regnum_map[kind] = output_regnum;
 137     }
 138     return output_regnum;
 139 }
 140
 141 uint32_t
 142 RegisterNumber::GetRegisterNumber () const
 143 {
 144     return m_regnum;
 145 }
 146
 147 lldb::RegisterKind
 148 RegisterNumber::GetRegisterKind () const
 149 {
 150     return m_kind;
 151 }
 152
 153 const char *
 154 RegisterNumber::GetName ()
 155 {
 156     return m_name;
 157 }