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
|
using System;
using Mono.Debugger.Languages;
namespace Mono.Debugger.Backend
{
internal abstract class BreakpointHandle : DebuggerMarshalByRefObject
{
public readonly Breakpoint Breakpoint;
protected BreakpointHandle (Breakpoint breakpoint)
{
this.Breakpoint = breakpoint;
}
public abstract void Insert (Inferior target);
public abstract void Insert (Thread target);
public abstract void Remove (Thread target);
}
internal class SimpleBreakpointHandle : BreakpointHandle
{
int index;
internal SimpleBreakpointHandle (Breakpoint breakpoint, int index)
: base (breakpoint)
{
this.index = index;
}
public override void Insert (Inferior target)
{
throw new InternalError ();
}
public override void Insert (Thread target)
{
throw new InternalError ();
}
public override void Remove (Thread target)
{
if (index > 0)
target.RemoveBreakpoint (this);
index = -1;
}
}
internal class AddressBreakpointHandle : BreakpointHandle
{
public readonly TargetAddress Address;
bool has_breakpoint;
public AddressBreakpointHandle (Breakpoint breakpoint, TargetAddress address)
: base (breakpoint)
{
this.Address = address;
}
public override void Insert (Thread target)
{
target.InsertBreakpoint (this, Address, -1);
has_breakpoint = true;
}
public override void Remove (Thread target)
{
if (has_breakpoint)
target.RemoveBreakpoint (this);
has_breakpoint = false;
}
public override void Insert (Inferior inferior)
{
inferior.InsertBreakpoint (this, Address, -1);
has_breakpoint = true;
}
internal void Remove (Inferior inferior)
{
if (has_breakpoint)
inferior.RemoveBreakpoint (this);
has_breakpoint = false;
}
}
internal class FunctionBreakpointHandle : BreakpointHandle
{
TargetFunctionType function;
bool has_load_handler;
int line = -1;
public FunctionBreakpointHandle (Breakpoint bpt, TargetFunctionType function,
int line)
: base (bpt)
{
this.function = function;
this.line = line;
}
internal TargetFunctionType Function {
get { return function; }
}
internal bool Insert (SingleSteppingEngine sse)
{
if (has_load_handler)
return false;
throw new InternalError ();
}
public override void Insert (Inferior target)
{
throw new InternalError ();
}
public override void Insert (Thread target)
{
if (has_load_handler)
return;
has_load_handler = function.InsertBreakpoint (target, this);
}
internal void MethodLoaded (TargetAccess target, Method method)
{
TargetAddress address;
if (line != -1) {
if (method.HasLineNumbers)
address = method.LineNumberTable.Lookup (line);
else
address = TargetAddress.Null;
} else if (method.HasMethodBounds)
address = method.MethodStartAddress;
else
address = method.StartAddress;
if (address.IsNull)
return;
try {
target.InsertBreakpoint (this, address, method.Domain);
} catch (TargetException ex) {
Report.Error ("Can't insert breakpoint {0} at {1}: {2}",
Breakpoint.Index, address, ex.Message);
}
}
public override void Remove (Thread target)
{
target.RemoveBreakpoint (this);
if (has_load_handler)
function.RemoveBreakpoint (target);
has_load_handler = false;
}
public override string ToString ()
{
return String.Format ("{0} ({1}:{2})", GetType (), function, line);
}
}
}
|
