public Backtrace(StackFrame first_frame)
{
this.last_frame = first_frame;
frames = new ArrayList ();
frames.Add (first_frame);
}
public override void CopyFrom (Mono.Debugging.Evaluation.EvaluationContext gctx)
{
base.CopyFrom (gctx);
MdbEvaluationContext ctx = (MdbEvaluationContext) gctx;
thread = ctx.thread;
frame = ctx.frame;
}
public EnumVariable(string name, StackFrame stackFrame, TargetEnumObject obj)
{
this.name = name;
this.stackFrame = stackFrame;
this.obj = obj;
this.value = GetValue();
}
public MdbEvaluationContext (Thread thread, StackFrame frame, TargetObject exception, Mono.Debugging.Client.EvaluationOptions options): base (options)
{
Evaluator = Server.Instance.Evaluator;
Adapter = Server.Instance.MdbObjectValueAdaptor;
this.thread = thread;
this.frame = frame;
this.Exception = exception;
}
public ArrayVariable(string name, StackFrame stackFrame, TargetArrayObject obj)
{
this.name = name;
this.stackFrame = stackFrame;
this.obj = obj;
universalSubset = new ArraySubsetVariable(stackFrame, obj, new int[0]);
}
public StepFrame(Language language, StepMode mode, StackFrame stack,
TargetAddress start, TargetAddress end)
{
this.start = start;
this.end = end;
this.stack = stack;
this.language = language;
this.mode = mode;
}
public static AbstractVariable Create(TargetVariable variable, StackFrame stackFrame)
{
TargetObject obj;
try {
obj = variable.GetObject(stackFrame);
} catch {
return new ErrorVariable(variable.Name, "Can not get object");
}
return Create(variable.Name, obj, stackFrame);
}
internal override BreakpointHandle Resolve(Thread target, StackFrame frame)
{
if (handle != null)
return handle;
SourceLocation location = Session.ParseLocation (
target, frame, LocationType, Name);
if (location == null)
throw new TargetException (TargetError.LocationInvalid);
handle = location.ResolveBreakpoint (Session, this);
return handle;
}
public override DL.StackFrame[] GetStackFrames(int firstIndex, int lastIndex)
{
CheckDisposed();
//FIXME: validate indices
List <DL.StackFrame> list = new List <DL.StackFrame> ();
for (int i = firstIndex; i <= lastIndex && i < frames.Length; i++)
{
MD.StackFrame frame = frames [i];
string method = null;
string filename = null;
int line = -1;
if (frame.Method != null)
{
method = frame.Method.Name;
if (!method.StartsWith("<"))
{
int p = method.IndexOf('(');
if (p != -1)
{
method = method.Substring(0, p).Trim();
}
}
}
else if (frame.Name != null)
{
method = frame.Name.Name;
}
else
{
method = "?";
}
if (frame.SourceAddress != null)
{
if (frame.SourceAddress.SourceFile != null)
{
filename = frame.SourceAddress.SourceFile.FileName;
}
line = frame.SourceAddress.Row;
}
string lang = frame.Language != null ? frame.Language.Name : string.Empty;
list.Add(new DL.StackFrame(frame.TargetAddress.Address, new DL.SourceLocation(method, filename, line), lang));
}
return(list.ToArray());
}
public ArraySubsetVariable(StackFrame stackFrame, TargetArrayObject obj, int[] indicesPefix, int startIndex, int endIndex)
{
this.stackFrame = stackFrame;
this.obj = obj;
this.indicesPefix = indicesPefix;
this.startIndex = startIndex;
this.endIndex = endIndex;
dimension = indicesPefix.Length;
lowerBound = obj.GetLowerBound(stackFrame.Thread, dimension);
upperBound = obj.GetUpperBound(stackFrame.Thread, dimension) - 1;
// Uncoment to test that the whole int range can be handled
//lowerBound = int.MinValue;
//upperBound = int.MaxValue;
}
public override AssemblyLine[] Disassemble(int frameIndex, int firstLine, int count)
{
CheckDisposed();
if (disBuffers == null)
{
disBuffers = new MdbDissassemblyBuffer [frames.Length];
}
MD.StackFrame frame = frames [frameIndex];
DissassemblyBuffer buffer = disBuffers [frameIndex];
if (buffer == null)
{
buffer = new MdbDissassemblyBuffer(frame.Thread, frame.TargetAddress);
disBuffers [frameIndex] = buffer;
}
return(buffer.GetLines(firstLine, firstLine + count - 1));
}
public static AbstractVariable Create(string name, TargetObject obj, StackFrame stackFrame)
{
if (obj == null) {
return new ErrorVariable(name, "Object is null");
}
try {
switch (obj.Kind) {
case TargetObjectKind.Array:
return new ArrayVariable(name, stackFrame, (TargetArrayObject)obj);
case TargetObjectKind.Pointer:
TargetPointerObject pobj = (TargetPointerObject)obj;
if (!pobj.Type.IsTypesafe) {
return new ErrorVariable(name, "Pointer is not typesafe");
}
try {
TargetObject deref = pobj.GetDereferencedObject(stackFrame.Thread);
return VariableFactory.Create(name, deref, stackFrame);
} catch {
return new ErrorVariable(name, "Can not dereference object");
}
case TargetObjectKind.Object:
try {
TargetObject deref = ((TargetObjectObject)obj).GetDereferencedObject(stackFrame.Thread);
return VariableFactory.Create(name, deref, stackFrame);
} catch {
return new ErrorVariable(name, "Can not dereference object");
}
case TargetObjectKind.Struct:
case TargetObjectKind.Class:
return new ClassVariable(name, stackFrame, (TargetClassObject)obj);
case TargetObjectKind.Fundamental:
return new FundamentalVariable(name, stackFrame, (TargetFundamentalObject)obj);
case TargetObjectKind.Enum:
return new EnumVariable(name, stackFrame, (TargetEnumObject)obj);
default:
return new ErrorVariable(name, "Unknown kind of object");
}
} catch (Exception e) {
return new ErrorVariable(name, e.Message);
}
}
internal override BreakpointHandle Resolve(Thread target, StackFrame frame)
{
if (handle != null)
return handle;
if (frame.Thread.Process.IsManaged) {
MonoLanguageBackend mono = frame.Thread.Process.MonoLanguage;
MonoFunctionType main = mono.MainMethod;
if (main == null)
return null;
handle = main.GetBreakpointHandle (this, -1, -1);
} else {
OperatingSystemBackend os = frame.Thread.Process.OperatingSystem;
TargetAddress main = os.LookupSymbol ("main");
if (main.IsNull)
return null;
handle = new AddressBreakpointHandle (this, main);
}
return handle;
}
public override void TargetStopped(Interpreter interpreter, StackFrame frame,
AssemblerLine current_insn)
{
if (frame == null)
return;
if (frame != null && frame.SourceAddress != null)
Console.WriteLine ("\x1A\x1A{0}:{1}:beg:{2}",
frame.SourceAddress.Name, "55" /* XXX */,
"0x80594d8" /* XXX */);
}
protected void TargetEvent(Thread target, StackFrame frame,
TargetEventArgs args)
{
switch (args.Type) {
case TargetEventType.TargetStopped: {
if ((int) args.Data != 0)
interpreter.Print ("{0} received signal {1} at {2}.",
target.Name, (int) args.Data, frame);
else if (!interpreter.IsInteractive)
break;
else
interpreter.Print ("{0} stopped at {1}.", target.Name, frame);
if (interpreter.IsScript)
break;
AssemblerLine insn;
try {
insn = target.DisassembleInstruction (
frame.Method, frame.TargetAddress);
} catch {
insn = null;
}
interpreter.Style.TargetStopped (interpreter, frame, insn);
break;
}
case TargetEventType.TargetHitBreakpoint: {
if (!interpreter.IsInteractive)
break;
interpreter.Print ("{0} hit breakpoint {1} at {2}.",
target.Name, (int) args.Data, frame);
if (interpreter.IsScript)
break;
AssemblerLine insn;
try {
insn = target.DisassembleInstruction (
frame.Method, frame.TargetAddress);
} catch {
insn = null;
}
interpreter.Style.TargetStopped (interpreter, frame, insn);
break;
}
case TargetEventType.Exception:
case TargetEventType.UnhandledException: {
interpreter.Print ("{0} caught {2}exception at {1}.", target.Name, frame,
args.Type == TargetEventType.Exception ?
"" : "unhandled ");
if (interpreter.IsScript)
break;
AssemblerLine insn;
try {
insn = target.DisassembleInstruction (
frame.Method, frame.TargetAddress);
} catch {
insn = null;
}
interpreter.Style.UnhandledException (interpreter, frame, insn);
break;
}
}
}
protected bool PrintSource(Interpreter interpreter, StackFrame frame)
{
SourceAddress location = frame.SourceAddress;
if (location == null)
return false;
SourceBuffer buffer;
if (location.SourceFile != null) {
string filename = location.SourceFile.FileName;
buffer = interpreter.SourceFileFactory.FindFile (filename);
} else
buffer = location.SourceBuffer;
if ((buffer == null) || (buffer.Contents == null) || (location.Row == 0))
return false;
string line = buffer.Contents [location.Row - 1];
interpreter.Print (String.Format ("{0,4} {1}", location.Row, line));
return true;
}
public abstract void UnhandledException(Interpreter interpreter, StackFrame frame, AssemblerLine current_insn);
public abstract void TargetStopped(Interpreter interpreter, StackFrame frame, AssemblerLine current_insn);
public TargetEventArgs(TargetEventType type, StackFrame frame)
: this(type, (object)null)
{
this.Frame = frame;
}
public FundamentalVariable(string name, StackFrame stackFrame, TargetFundamentalObject obj)
{
this.name = name;
this.stackFrame = stackFrame;
this.obj = obj;
}
protected override EvaluationContext GetEvaluationContext(int frameIndex, EvaluationOptions options)
{
CheckDisposed();
MD.StackFrame frame = frames [frameIndex];
return(new MdbEvaluationContext(frame.Thread, frame, exception, options));
}
MemberExpression LookupMember(ScriptingContext context, StackFrame frame,
string full_name)
{
MemberExpression member;
TargetFunctionType function = frame.Function;
if (function != null) {
member = StructAccessExpression.FindMember (
frame.Thread, function.DeclaringType, null,
full_name, true, true);
if (member != null)
return member;
}
Method method = frame.Method;
if (method == null)
return null;
TargetClassType decl_type = method.GetDeclaringType (context.CurrentThread);
if (decl_type == null)
return null;
TargetClassObject instance = null;
if (method.HasThis) {
TargetVariable this_var = method.GetThis (context.CurrentThread);
TargetObject this_obj = this_var.GetObject (frame);
var pobj = this_obj as TargetPointerObject;
if (pobj != null)
this_obj = pobj.GetDereferencedObject (context.CurrentThread);
instance = (TargetClassObject) this_obj;
}
member = StructAccessExpression.FindMember (
context.CurrentThread, decl_type, instance, full_name, true, true);
if (member == null)
return null;
return member;
}
TargetVariable GetVariableByName(StackFrame frame, string name)
{
TargetVariable[] locals = frame.Method.GetLocalVariables (frame.Thread);
foreach (TargetVariable var in locals) {
if ((var.Name == name) && var.IsInScope (frame.TargetAddress))
return var;
}
TargetVariable[] param_vars = frame.Method.GetParameters (frame.Thread);
foreach (TargetVariable var in param_vars) {
if ((var.Name == name) && var.IsInScope (frame.TargetAddress))
return var;
}
return null;
}
protected void OnPausedEvent(object o, EventArgs args)
{
DebuggingService dbgr = (DebuggingService)Runtime.DebuggingService;
current_frame = dbgr.CurrentFrame;
UpdateDisplay ();
}
protected void OnStoppedEvent(object o, EventArgs args)
{
current_frame = null;
UpdateDisplay ();
}
bool BreakEventCheck(MD.TargetEventArgs args)
{
MD.StackFrame frame = args.Frame;
if (!(args.Data is int))
{
return(true);
}
int eventHandle = (int)args.Data;
DL.BreakEvent be;
if (!events.TryGetValue(eventHandle, out be))
{
return(true);
}
// Check hit count
if (be.HitCount > 0)
{
be.HitCount--;
DispatchEvent(delegate {
NotifyBreakEventUpdate(eventHandle, be.HitCount, null);
});
return(false);
}
MdbEvaluationContext ctx = new MdbEvaluationContext(frame.Thread, frame, null, SessionOptions.EvaluationOptions);
DL.Breakpoint bp = be as DL.Breakpoint;
if (bp != null && !string.IsNullOrEmpty(bp.ConditionExpression))
{
ML.TargetObject val = EvaluateExp(ctx, bp.ConditionExpression);
if (val == null)
{
return(false);
}
if (bp.BreakIfConditionChanges)
{
string current = evaluator.TargetObjectToExpression(ctx, val).Value;
string last;
bool found = lastConditionValue.TryGetValue(eventHandle, out last);
lastConditionValue [eventHandle] = current;
if (!found || last == current)
{
return(false);
}
}
else
{
ML.TargetFundamentalObject fob = val as ML.TargetFundamentalObject;
if (fob == null)
{
return(false);
}
object ob = fob.GetObject(frame.Thread);
if (!(ob is bool) || !(bool)ob)
{
return(false);
}
}
}
switch (be.HitAction)
{
case HitAction.Break:
return(true);
case HitAction.CustomAction:
return(controller.OnCustomBreakpointAction(be.CustomActionId, eventHandle));
case HitAction.PrintExpression:
if (string.IsNullOrEmpty(be.TraceExpression) || frame == null)
{
return(false);
}
ML.TargetObject val = EvaluateExp(ctx, be.TraceExpression);
if (val != null)
{
string str = evaluator.TargetObjectToString(ctx, val);
DispatchEvent(delegate {
NotifyBreakEventUpdate(eventHandle, -1, str);
});
}
return(false);
}
return(false);
}
MemberExpression Lookup(ScriptingContext context, StackFrame frame)
{
MemberExpression member = LookupMember (context, frame, name);
if (member != null)
return member;
string[] namespaces = context.GetNamespaces ();
if (namespaces == null)
return null;
foreach (string ns in namespaces) {
string full_name = MakeFQN (ns, name);
member = LookupMember (context, frame, full_name);
if (member != null)
return member;
}
return null;
}
public override void PrintFrame(ScriptingContext context, StackFrame frame)
{
context.Print (frame);
bool native = false;
if (!PrintSource (context.Interpreter, frame))
native = true;
if (native) {
AssemblerLine insn = frame.Thread.DisassembleInstruction (
frame.Method, frame.TargetAddress);
if (insn != null)
context.Interpreter.PrintInstruction (insn);
else
throw new ScriptingException (
"Cannot disassemble instruction at address {0}.",
frame.TargetAddress);
}
}
protected override Expression DoResolve(ScriptingContext context)
{
frame = context.CurrentFrame;
Method method = frame.Method;
if (method == null)
throw new ScriptingException (
"Keyword `this' not allowed: no current method.");
if (!method.HasThis)
throw new ScriptingException (
"Keyword `this' not allowed: current method is " +
"either static or unmanaged.");
var = method.GetThis (context.CurrentThread);
resolved = true;
return this;
}
public override string PrintVariable(TargetVariable variable, StackFrame frame)
{
ObjectFormatter formatter = new ObjectFormatter (DisplayFormat.Default);
formatter.FormatVariable (frame, variable);
return formatter.ToString ();
}
internal override BreakpointHandle Resolve(Thread target, StackFrame frame)
{
if (handle != null)
return handle;
switch (Type) {
case EventType.Breakpoint:
handle = new AddressBreakpointHandle (this, address);
break;
case EventType.WatchRead:
case EventType.WatchWrite:
handle = new AddressBreakpointHandle (this, address);
break;
default:
throw new InternalError ();
}
return handle;
}
public override void TargetStopped(Interpreter interpreter, StackFrame frame,
AssemblerLine current_insn)
{
if (frame != null) {
if (!PrintSource (interpreter, frame))
native = true;
interpreter.ShowDisplays (frame);
}
if (native && (current_insn != null))
interpreter.PrintInstruction (current_insn);
}
public override void UnhandledException(Interpreter interpreter, StackFrame frame,
AssemblerLine insn)
{
TargetStopped (interpreter, frame, insn);
}
public abstract void PrintFrame(ScriptingContext context, StackFrame frame);
public void ShowDisplays(StackFrame frame)
{
ScriptingContext context = new ScriptingContext (this);
context.CurrentFrame = frame;
foreach (Display d in Session.Displays)
context.ShowDisplay (d);
}
public TargetEventArgs(TargetEventType type, object data, StackFrame frame)
: this(type, data)
{
this.Frame = frame;
}
