1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
//===-- DynamicRegisterInfo.cpp ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "DynamicRegisterInfo.h"
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
using namespace lldb;
using namespace lldb_private;
DynamicRegisterInfo::DynamicRegisterInfo () :
m_regs (),
m_sets (),
m_set_reg_nums (),
m_reg_names (),
m_reg_alt_names (),
m_set_names (),
m_reg_data_byte_size (0)
{
}
DynamicRegisterInfo::~DynamicRegisterInfo ()
{
}
void
DynamicRegisterInfo::AddRegister (RegisterInfo ®_info,
ConstString ®_name,
ConstString ®_alt_name,
ConstString &set_name)
{
const uint32_t reg_num = m_regs.size();
m_reg_names.push_back (reg_name);
m_reg_alt_names.push_back (reg_alt_name);
reg_info.name = reg_name.AsCString();
assert (reg_info.name);
reg_info.alt_name = reg_alt_name.AsCString(NULL);
m_regs.push_back (reg_info);
uint32_t set = GetRegisterSetIndexByName (set_name, true);
assert (set < m_sets.size());
assert (set < m_set_reg_nums.size());
assert (set < m_set_names.size());
m_set_reg_nums[set].push_back(reg_num);
size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
if (m_reg_data_byte_size < end_reg_offset)
m_reg_data_byte_size = end_reg_offset;
}
void
DynamicRegisterInfo::Finalize ()
{
for (uint32_t set = 0; set < m_sets.size(); ++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][0];
}
}
size_t
DynamicRegisterInfo::GetNumRegisters() const
{
return m_regs.size();
}
size_t
DynamicRegisterInfo::GetNumRegisterSets() const
{
return m_sets.size();
}
size_t
DynamicRegisterInfo::GetRegisterDataByteSize() const
{
return m_reg_data_byte_size;
}
const RegisterInfo *
DynamicRegisterInfo::GetRegisterInfoAtIndex (uint32_t i) const
{
if (i < m_regs.size())
return &m_regs[i];
return NULL;
}
const RegisterSet *
DynamicRegisterInfo::GetRegisterSet (uint32_t i) const
{
if (i < m_sets.size())
return &m_sets[i];
return NULL;
}
uint32_t
DynamicRegisterInfo::GetRegisterSetIndexByName (ConstString &set_name, bool can_create)
{
name_collection::iterator pos, end = m_set_names.end();
for (pos = m_set_names.begin(); pos != end; ++pos)
{
if (*pos == set_name)
return std::distance (m_set_names.begin(), pos);
}
m_set_names.push_back(set_name);
m_set_reg_nums.resize(m_set_reg_nums.size()+1);
RegisterSet new_set = { set_name.AsCString(), NULL, 0, NULL };
m_sets.push_back (new_set);
return m_sets.size() - 1;
}
uint32_t
DynamicRegisterInfo::ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num) const
{
reg_collection::const_iterator pos, end = m_regs.end();
for (pos = m_regs.begin(); pos != end; ++pos)
{
if (pos->kinds[kind] == num)
return std::distance (m_regs.begin(), pos);
}
return LLDB_INVALID_REGNUM;
}
void
DynamicRegisterInfo::Clear()
{
m_regs.clear();
m_sets.clear();
m_set_reg_nums.clear();
m_reg_names.clear();
m_reg_alt_names.clear();
m_set_names.clear();
}
|
