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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
using System;
namespace Mono.Debugger.Languages.Native
{
[Serializable]
internal class NativeFieldInfo : TargetFieldInfo
{
int bit_offset, bit_size;
bool is_bitfield;
int const_value;
public NativeFieldInfo (TargetType type, string name, int index, int offset)
: base (type, name, index, false, 0, offset, false)
{ }
public NativeFieldInfo (TargetType type, string name, int index, int offset,
int bit_offset, int bit_size)
: this (type, name, index, offset)
{
this.bit_offset = bit_offset;
this.bit_size = bit_size;
this.is_bitfield = true;
}
public NativeFieldInfo (TargetType type, string name, int index,
bool has_const_value, int const_value)
: base (type, name, index, false, 0, 0, has_const_value)
{
this.const_value = const_value;
}
public override object ConstValue {
get {
if (!HasConstValue)
throw new InvalidOperationException ();
return const_value;
}
}
public int BitOffset {
get {
return bit_offset;
}
}
public int BitSize {
get {
return bit_size;
}
}
public bool IsBitfield {
get {
return is_bitfield;
}
}
}
internal class NativeMethodInfo : TargetMethodInfo
{
public new readonly NativeFunctionType FunctionType;
public NativeMethodInfo (NativeFunctionType type, string name, int index)
: base (type, name, index, false, name)
{
this.FunctionType = type;
}
}
internal class NativeStructType : TargetClassType
{
string name;
int size;
NativeFieldInfo[] fields;
NativeClass class_info;
internal NativeStructType (Language language, string name, int size)
: base (language, TargetObjectKind.Struct)
{
this.name = name;
this.size = size;
}
internal NativeStructType (Language language, string name,
NativeFieldInfo[] fields, int size)
: this (language, name, size)
{
this.fields = fields;
}
public override bool HasClassType {
get { return true; }
}
public override TargetClassType ClassType {
get { return this; }
}
public override bool HasParent {
get { return false; }
}
internal override TargetStructType GetParentType (TargetMemoryAccess target)
{
throw new InvalidOperationException ();
}
public override Module Module {
get { throw new NotImplementedException (); }
}
internal void SetFields (NativeFieldInfo[] fields)
{
this.fields = fields;
}
public override string Name {
get { return name; }
}
public override int Size {
get { return size; }
}
public override bool HasFixedSize {
get { return true; }
}
public override bool IsByRef {
get { return false; }
}
public bool IsCompleteType {
get { return fields != null; }
}
public override TargetFieldInfo[] Fields {
get {
if (fields != null)
return fields;
return new TargetFieldInfo [0];
}
}
public override TargetPropertyInfo[] Properties {
get {
return new TargetPropertyInfo [0];
}
}
public override TargetEventInfo[] Events {
get {
return new TargetEventInfo [0];
}
}
public override TargetMethodInfo[] Methods {
get {
return new TargetMethodInfo [0];
}
}
public override TargetMethodInfo[] Constructors {
get {
return new TargetMethodInfo [0];
}
}
internal override TargetClass GetClass (TargetMemoryAccess target)
{
if (class_info == null)
class_info = new NativeClass (this, fields);
return class_info;
}
protected override TargetObject DoGetObject (TargetMemoryAccess target, TargetLocation location)
{
return new NativeStructObject (this, location);
}
internal TargetObject GetField (TargetMemoryAccess target, TargetLocation location,
NativeFieldInfo field)
{
TargetLocation field_loc = location.GetLocationAtOffset (field.Offset);
if (field.Type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
if (!field.Type.IsByRef && field.IsBitfield)
field_loc = new BitfieldTargetLocation (
field_loc, field.BitOffset, field.BitSize);
return field.Type.GetObject (target, field_loc);
}
internal void SetField (TargetMemoryAccess target, TargetLocation location,
NativeFieldInfo field, TargetObject obj)
{
TargetLocation field_loc = location.GetLocationAtOffset (field.Offset);
if (field.Type.IsByRef)
field_loc = field_loc.GetDereferencedLocation ();
if (!field.Type.IsByRef && field.IsBitfield)
field_loc = new BitfieldTargetLocation (
field_loc, field.BitOffset, field.BitSize);
// field.Type.SetObject (field_loc, obj);
throw new NotImplementedException ();
}
}
}
|
