Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

13434 lines (9031 sloc) 442.607 kb
2007-12-14 Wade Berrier <wberrier@novell.com>
* frontend/Makefile.am:
* test/src/Makefile.am:
* test/testsuite/Makefile.am:
* backend/arch/Makefile.am:
* classes/Makefile.am:
* interface/Makefile.am:
* languages/Makefile.am:
More .cs globbing for EXTRA_DIST
2007-12-10 Martin Baulig <martin@ximian.com>
* languages/TargetClass.cs
(TargetClass.GetField): Take a `TargetStructObject' instead of a
`TargetClassObject'.
(TargetClass.SetField): Likewise.
2007-12-10 Martin Baulig <martin@ximian.com>
* languages/TargetStructType.cs: New file.
(TargetStructType): New public abstract type.
* languages/TargetStructObject.cs: New file.
(TargetStructObject): New public abstract type.
* languages/TargetClassType.cs
(TargetClassType): Derive from `TargetStructType'; removed
`HasParent', `GetClass', `Module' and `ParentType' which are now
provided by `TargetStructType'.
* languages/TargetClassObject.cs
(TargetClassObject): Derive from `TargetClassObject'.
2007-12-10 Martin Baulig <martin@ximian.com>
* classes/DebuggerOptions.cs: Added new `-start' command line
argument to stop in Main(); made `-run' run the target without
stopping. This makes the command line arguments consistent with
the `start' and `run' commands.
2007-12-10 Martin Baulig <martin@ximian.com>
Applied a patch from Harald Krapfenbauer <krapfenbauer@ict.tuwien.ac.at>:
* backend/server/i386-arch.c
(x86_arch_get_registers): Store the return value each time to
`result' to check for errors.
* backend/server/x86_64-arch.c
(x86_arch_get_registers): Store the return value each time to
`result' to check for errors.
* backend/server/x86-linux-ptrace.c
(server_ptrace_get_application): Increase size of `buffer' by 1.
2007-12-08 Martin Baulig <martin@ximian.com>
* configure.in: Bumped version number to 0.60.
2007-12-08 Martin Baulig <martin@ximian.com>
Changed default behavior: don't follow fork() by default.
* classes/DebuggerConfiguration.cs
(DebuggerConfiguration.FollowFork): Changed default to false.
* test/testsuite/NUnit.cs
(NUnitInterpreter.ctor): Override configuration: enable `FollowFork'.
2007-12-08 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(ConfigCommand): New command.
2007-12-08 Martin Baulig <martin@ximian.com>
* backend/Inferior.cs
(Inferior): Replaced InitializeAfterFork() by DetachAfterFork().
* backend/SingleSteppingEngine.cs
(SSE.InitAfterFork): New method.
(OperationInitializeAfterFork): New operation. To avoid a race
condition, we need to wait until the target stopped the first time
before we can disable the local breakpoints.
* backend/server/server.h
(mono_debugger_server_init_after_fork): Renamed info
mono_debugger_server_detach_after_fork().
* backend/server/x86-arch.h
(x86_arch_enable_breakpoint): Add prototype.
(x86_arch_disable_breakpoint): Add prototype.
* backend/server/i386-arch.c
(do_enable): Renamed into x86_arch_enable_breakpoint().
(do_disable): Renamed into x86_arch_disable_breakpoint().
* backend/server/x86_64-arch.c
(do_enable): Renamed into x86_arch_enable_breakpoint().
(do_disable): Renamed into x86_arch_disable_breakpoint().
2007-12-08 Martin Baulig <martin@ximian.com>
* backend/ProcessServant.cs
(ProcessServant.ChildForked): Implement detach-after-fork, ie. not
following fork(). At the moment, this can only be enabled in the
configuration file
[FIXME: add user-interface option to enable/disable this].
* backend/Inferior.cs
(Inferior.InitializeAfterFork): Added `bool follow_fork' argument.
* backend/server/server.h
(mono_debugger_server_init_after_fork): Added
`gboolean follow_fork' argument; remove all breakpoints if false.
2007-12-08 Martin Baulig <martin@ximian.com>
* classes/DebuggerConfiguration.cs
(DebuggerConfiguration.FollowFork): New property. Not yet implemented.
2007-12-08 Martin Baulig <martin@ximian.com>
* backend/ThreadDB.cs
(ThreadDB.GetThreadInfo): Added `TargetMemoryAccess' argument;
operate on that target. This fixes the XSP issue.
2007-12-07 Martin Baulig <martin@ximian.com>
Unify registers on i386 and x86_64.
* backend/arch/X86_Architecture.cs: New file.
(X86_Architecture): New internal abstract class.
(X86_Register): New internal enum.
* backend/arch/Architecture_X86_64.cs
(X86_64_Register): Removed; use `X86_Register' instead.
* backend/arch/Architecture_I386.cs
(I386Register): Removed; use `X86_Register' instead.
* backend/server/x86-arch.h
(DebuggerX86Register): Use an unified register representation on
i386 and x86_64.
2007-12-05 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture_X86_64.cs
(X86_64_Register): Actually sync with backend/arch/x86_64-arch.h.
2007-11-30 Martin Baulig <martin@ximian.com>
* languages/TargetClassType.cs
(TargetClassType.StaticFields): Merged with `Fields'.
(TargetClassType.StaticProperties): Merged with `Properties'.
(TargetClassType.StaticEvents): Merged with `Events'.
(TargetClassType.StaticMethods): Merged with `Methods'.
(TargetClassType.StaticConstructors): Merged with `Constructors'.
(TargetClassType.FindMember): Provide a virtual implementation here.
2007-11-28 Martin Baulig <martin@ximian.com>
* languages/TargetClass.cs
(TargetClass.GetFields): New public method; this includes both
instance and static fields.
* languages/mono/MonoClassInfo.cs
(MonoClassInfo.GetFields): Get the field types from the runtime
and not from Cecil.
* frontend/ObjectFormatter.cs
(ObjectFormatter.FormatClassObject): Use the new `TargetClass' to
display fields.
2007-11-28 Martin Baulig <martin@ximian.com>
* languages/TargetClass.cs
(TargetClass): New public abstract class.
* languages/TargetClassType.cs
(TargetClassType.GetClass): New public method.
(TargetClassType): Removed GetStaticField() and SetStaticField(),
they're now in the `TargetClass'.
* languages/TargetClassObject.cs
(TargetClassObject): Removed GetField() and SetField(), they're
now in the `TargetClass'.
2007-11-28 Martin Baulig <martin@ximian.com>
* languages/TargetFunctionType.cs
(TargetFunctionType.GetMethodAddress): Removed.
* languages/mono/MonoClassType.cs
(MonoClassType.HardResolveClass): Removed.
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.OperationRuntimeInvoke): Call
GetMethodAddress() directly on the `MonoClassInfo'.
2007-11-28 Martin Baulig <martin@ximian.com>
* languages/TargetFundamentalObject.cs
(TargetFundamentalObject.GetObject): Added internal overloaded
version taking a `TargetMemoryAccess'.
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine): Kill some more `sse.Thread' madness.
* backend/Inferior.cs
(Inferior.RuntimeInvoke): Removed the `Thread' argument.
2007-11-28 Martin Baulig <martin@ximian.com>
Renamed `Mono.Debugger.Backends' => `Mono.Debugger.Backend'.
2007-11-28 Martin Baulig <martin@ximian.com>
* backend/arch/X86_Instruction.cs
(X86_Instruction.GetMonoTrampoline): New protected abstract method.
(X86_Instruction.CheckTrampoline): Implement this here.
2007-11-28 Martin Baulig <martin@ximian.com>
* backend/TargetMemoryAccess.cs
(TargetMemoryAccess): Moved `TargetIntegerSize',
`TargetLongIntegerSize', `TargetAddressSize', `IsBigEndian',
`CanWrite' and `Write*' here from `TargetAccess'.
(TargetAccess): Removed everything except `InsertBreakpoint' and
`RemoveBreakpoint'.
* classes/DebuggerSession.cs
(IExpressionParser): Operate on `Thread', not `TargetMemoryAccess'.
(DebuggerSession.ParseLocation): Likewise.
* classes/Thread.cs
(Thread): Don't derive from `TargetAccess'.
* classes/Breakpoint.cs
(Breakpoint.Resolve): Operate on `Thread', not `TargetMemoryAccess'.
* backend/ThreadServant.cs
(ThreadServant): Don't derive from `TargetAccess' or
`TargetMemoryAccess'.
* backend/arch/Architecture.cs
(Architecture): Operate on `TargetMemoryAccess', not `Thread'.
* backend/Inferior.cs
(Inferior): Derive from `TargetAccess', not `TargetMemoryAccess'.
* backend/MonoThreadManager.cs
(MonoMetadataInfo): Moved into ../languages/mono/MonoRuntime.cs.
* languages/Target*Object.cs
(Target*Object): Operate on `Thread', not `TargetMemoryAccess'.
* languages/Target*Type.cs
(Target*Type): Operate on `Thread', not `TargetMemoryAccess'.
2007-11-22 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs
(OperationDelegateInvoke): New operation; step through a delegate
invocation trampoline.
* backend/arch/Instruction.cs
(Instruction.TrampolineType): Added `DelegateInvoke'.
2007-11-20 Martin Baulig <martin@ximian.com>
* test/testsuite/TestDelegate.cs: Temporarily disable this.
* backend/SingleSteppingEngine.cs
(OperationExecuteInstruction): Make this a separate operation
since we need to resume the target after executing the instruction
if we're not single-stepping.
(OperationActivateBreakpoints): Use the new breakpoint code.
* languages/TargetFunctionType.cs
(TargetFunctionType.InsertBreakpoint): Take a
`FunctionBreakpointHandle' argument, not `MethodLoadedHandler'.
2007-11-19 Martin Baulig <martin@ximian.com>
* frontend/Main.cs
(Main.RunInferiorMainLoop): New public method. This can be used
to run a main loop inside the nunit test suite.
* test/testsuite/NUnit.cs
(TestSuite.MainLoop): New public method; run an inferior main loop
from within the testsuite.
2007-11-06 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture_I386.cs
(Architecture_I386.GetLMF): Make this work again.
2007-11-05 Martin Baulig <martin@ximian.com>
* backend/arch/Instruction.cs
(Instruction.Type): Added `Interpretable'.
* backend/arch/Instruction_I386.cs
(Instruction_I386.InterpretInstruction): Interpret `push %ebp'.
* backend/arch/Instruction_X86_64.cs
(Instruction_I386.InterpretInstruction): Interpret `push %rbp'.
2007-11-05 Martin Baulig <martin@ximian.com>
* backend/arch/Instruction.cs
(Instruction.CanInterpretInstruction): New public property.
* backend/arch/Bfd.cs
(Bfd.DynlinkBreakpoint): Interpret the instruction rather than
stepping over the breakpoint.
2007-11-05 Martin Baulig <martin@ximian.com>
* backend/server/x86-ptrace.c
(mono_debugger_server_finalize_mono_runtime): New public method.
* backend/ProcessServant.cs
(ProcessServant.CanExecuteCode): New internal property.
2007-11-05 Martin Baulig <martin@ximian.com>
* backend/MonoThreadManager.cs
(MonoDebuggerInfo.MinDynamicVersion): Bump to 64 to require SVN HEAD.
* backend/server/x86_64-arch.c: Reflect latest JIT changes.
* backend/server/i386-arch.c: Likewise.
2007-10-31 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture.cs
(Architecture.Opcodes.GenerateNopInstruction): New public property.
* backend/SingleSteppingEngine.cs
(SSE.step_over_breakpoint): Use Opcodes.GenerateNopInstruction()
instead of encoding it here.
* backend/server/server.h
(mono_debugger_server_execute_instruction): Removed the
`original_size' argument; replaced `push_retaddr' by `up
2007-10-31 Martin Baulig <martin@ximian.com>
* backend/arch/Opcodes.cs
(Opcodes.GenerateJumpInstruction): New abstract method.
* backend/arch/X86_Opcodes.cs
(X86_Opcodes): Make this abstract.
* backend/arch/Opcodes_I386.cs: New file.
(Opcodes_I386): i386-specific implementation.
* backend/arch/Opcodes_X86_64.cs: New file.
(Opcodes_X86_64): x86_64-specific implementation.
2007-10-31 Martin Baulig <martin@ximian.com>
Merged the Plophos branch.
* backend/SingleSteppingEngine.cs
(SSE.step_over_breakpoint): Take a `bool singlestep' and a
`TargetAddress until' argument; use the new ExecuteInstruction()
whenever possible.
(SSE): The old GetCallTarget() API is gone; we now use
Architecture.ReadInstruction() which returns an `Instruction'.
(OperationStepOverBreakpoint): We don't need to deal with
trampolines here anymore.
(OperationMonoTrampoline): This is used when stepping into a
trampoline: we enable the `NotificationType.Trampoline'
notification and resume execution.
(OperationCompileMethod): Removed.
(OperationRuntimeClassInit): Removed.
* backend/ProcessServant.cs: Reflect latest runtime changes.
* backend/MonoThreadManager.cs: Reflect latest runtime changes.
* backend/Inferior.cs
(Inferior.ChildEvent): Added public readonly `CallbackData' field.
(Inferior.CallMethod(long,long)): Take a `byte[]' and a `long'
argument instead of two `long' arguments.
(Inferior.ExecuteInstruction): New public method.
(Inferior.ProcessEvent): mono_debugger_server_dispatch_event() may
now pass us an additional byte[] argument.
* backend/server/breakpoints.h
(BreakpointInfo): Added `runtime_table_slot'.
* server.h
(MonoRuntimeInfo): New typedef.
(ServerHandle): Added `MonoRuntimeInfo *mono_runtime'
(InferiorVTable): Added `set_runtime_info' and
`execute_instruction'; removed `set_notification'; `call_method_2'
now takes additional `data_size' and 'data_buffer' arguments.
(mono_debugger_server_set_runtime_info): New function.
(mono_debugger_server_execute_instruction): New function.
(mono_debugger_server_set_notification): Removed.
(mono_debugger_server_initialize_mono_runtime): New function.
* x86-ptrace.c
(InferiorHandle): Removed `notification_address', this is now in
the new `MonoRuntimeInfo'.
* x86_64-arch.c
(runtime_info_enable/disable_breakpoint): New static methods.
* i386-arch.c
(runtime_info_enable/disable_breakpoint): New static methods.
* backend/arch/Architecture.cs
(CallTargetType): Removed.
(Architecture.ReadInstruction): New method.
(Architecture.IsTrampoline): Removed.
(Architecture.IsCall): Removed.
(Architecture.GetCallTarget): Removed.
(Architecture.DoGetMonoTrampoline): Removed.
* backend/arch/Opcodes.cs: New file.
(Opcodes): New abstract internal class.
* backend/arch/X86_Opcodes.cs: New file.
(X86_Opcodes): Implementation for i386 and x86_64.
* backend/arch/Instruction.cs: New file.
(Instruction): New abstract internal class.
* backend/arch/X86_Instruction.cs: New file.
(X86_Instruction): Abstract implementation for i386 and x86_64.
* backend/arch/Instruction_I386.cs: New file.
(Instruction_I386): i386-specific part.
* backend/arch/Instruction_X86_64.cs: New file.
(Instruction_X86_64): x86_64-specific part.
* languages/mono/MonoLanguageBackend.cs
(MonoLanguageBackend.IsTrampolineAddress): New public method.
(MonoLanguageBackend.GetTrampoline): FIXME: temporarily broken.
2007-10-30 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture.cs
(Architecture.Disassembler): New public property; only create one
single disassembler per process.
* backend/arch/Disassembler.cs
(Disassembler.GetInstructionSize): Added `TargetMemoryAccess' argument.
(Disassembler.DisassembleInstruction): Likewise.
(Disassembler.DisassembleMethod): Likewise.
2007-10-30 Martin Baulig <martin@ximian.com>
* backend/ProcessServant.cs
(ProcessServant.Architecture): New public property; only create
one single `Architecture' instance per process.
2007-10-29 Martin Baulig <martin@ximian.com>
* classes/TargetInfo.cs: New file.
(TargetInfo): Moved here from TargetBinaryAccess.cs.
(TargetMemoryInfo): New public class, derives from `TargetInfo'.
(TargetInfo.AddressDomain): Moved this into `TargetMemoryInfo'.
2007-10-24 Martin Baulig <martin@ximian.com>
* backend/arch/Instruction.cs: New file.
(Instruction): New internal abstract class.
* backend/arch/X86_Instruction.cs: New file.
(X86_Instruction): New internal class; implement `Instruction'
here, we use this for both i386 and x86_64.
* backend/arch/Architecture.cs
(Architecture.DoGetCallTarget): Don't make this abstract;
implement it here using the new `Instruction' class.
2007-10-16 Martin Baulig <martin@ximian.com>
* backend/ILanguageBackend.cs: Removed.
(ILanguageBackend): Removed.
2007-10-16 Martin Baulig <martin@ximian.com>
* backend/ILanguageBackend.cs
(NotificationType): Moved into MonoThreadManager.cs.
* backend/MonoThreadManager.cs
(NotificationType): Moved here from ILanguageBackend.cs.
2007-10-16 Martin Baulig <martin@ximian.com>
* backend/ILanguageBackend.cs
(ILanguageBackend.GetTrampoline): Removed.
2007-10-16 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture.cs
(Architecture.CallTargetType): Add `NativeTrampoline',
`NativeTrampolineStart' and `MonoTrampoline'.
(Architecture.GetCallTarget): Also check for trampolines here.
(Architecture.GetTrampoline): Removed.
* backend/ILanguageBackend.cs
(ILanguageBackend.GetTrampolineAddress): Removed.
2007-10-15 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture.cs
(Architecture.CallTargetType): New internal enum.
(Architecture.GetCallTarget): Merge GetJumpTarget() and
GetCallTarget() into a new GetCallTarget(); we now return a
`CallTargetType'.
2007-10-10 Martin Baulig <martin@ximian.com>
Fix the "field from parent class madness".
* languages/TargetClassObject.cs
(TargetClassObject.GetParentObject): Take a `TargetMemoryAccess'
instead of a `Target' argument.
* languages/mono/MonoClassObject.cs
(MonoClassObject.GetParentObject): Disallow any implicit boxings.
* frontend/Expression.cs
(StructAccessExpression.FindMember): When searching in the parent
class, also use the parent instance.
2007-10-09 Martin Baulig <martin@ximian.com>
* languages/mono/MonoClassInfo.cs
(MonoClassInfo): Moved the implementations of GetField(),
SetField(), GetStaticField() and SetStaticField() here from
`MonoClassType'.
* languages/mono/MonoClassType.cs
(MonoClassType): Moved all the code dealing with fields into
`MonoClassInfo'.
2007-10-09 Martin Baulig <martin@ximian.com>
* languages/TargetMember.cs
(TargetEnumInfo): New public abstract class.
* languages/TargetEnumType.cs
(TargetEnumType): Changed the type of `Value' and `Members' from
`TargetFieldInfo' info `TargetEnumInfo'.
* languages/mono/MonoClassType.cs
(MonoClassType): No longer include the fields and methods from our
parent class. We now create our parent class on-the-fly when it's
needed.
2007-10-09 Martin Baulig <martin@ximian.com>
* languages/mono/MonoClassInfo.cs
(MonoClassInfo.ClassType): New public property.
(MonoClassInfo.GetParent): New public method; compute the parent
on-the-fly when it's needed.
* languages/mono/MonoClassObject.cs
(MonoClassObject): The .ctor now takes a `MonoClassInfo' argument.
(MonoClassObject.GetParentObject): Implement this here.
2007-10-05 Martin Baulig <martin@ximian.com>
* languages/mono/MonoSymbolFile.cs
(MonoSymbolFile.LookupClassInfo): Reload the symbol tables if we
can't find the requested type and try again.
2007-10-05 Martin Baulig <martin@ximian.com>
* languages/TargetType.cs
(TargetType.SetObject): `Thread' -> `TargetAccess'.
* languages/TargetFundamentalObject.cs
(TargetFundamentalObject.SetObject): `Thread' -> `TargetAccess'.
* languages/TargetClassObject.cs
(TargetClassObject.SetField): `Thread' -> `TargetAccess'.
* languages/TargetArrayObject.cs
(TargetArrayObject.SetElement): `Thread' -> `TargetAccess'.
2007-10-05 Martin Baulig <martin@ximian.com>
* classes/StackFrame.cs
(Register.WriteRegister): `Thread' -> `TargetAccess'.
* languages/TargetLocation.cs
(TargetLocation.WriteBuffer): `Thread' -> `TargetAccess'.
(TargetLocation.WriteAddress): Likewise.
* backends/TargetAccess.cs
(TargetAccess): Move `Mono.Debugger.Backends' -> `Mono.Debugger'.
2007-10-05 Martin Baulig <martin@ximian.com>
* languages/TargetObject.cs
(TargetObject.GetAddress): `Thread' -> `TargetMemoryAccess'.
* languages/TargetFundamentalObject.cs
(TargetFundamentalObject.GetObject): `Thread' -> `TargetMemoryAccess'.
* languages/TargetClassObject.cs
(TargetClassObject.GetField): `Thread' -> `TargetMemoryAccess'.
(TargetClassObject.GetCurrentObject): Likewise.
2007-10-05 Martin Baulig <martin@ximian.com>
* languages/TargetPointerObject.cs
(TargetPointerObject.GetCurrentType): `Thread' -> `TargetMemoryAccess'.
(TargetPointerObject.GetDereferencedObject): Likewise.
(TargetPointerObject.GetArrayElement): Likewise.
* languages/TargetObjectObject.cs
(TargetObjectObject.GetClassObject): `Thread' -> `TargetMemoryAccess'.
2007-10-05 Martin Baulig <martin@ximian.com>
* languages/TargetObject.cs
(TargetObject.GetDynamicSize): `Thread' -> `TargetMemoryAccess'.
* languages/TargetLocation.cs
(TargetLocation.ReadMemory): `Thread' -> `TargetMemoryAccess'.
(TargetLocation.ReadBuffer): Likewise.
2007-10-05 Martin Baulig <martin@ximian.com>
* languages/TargetEnumType.cs
(TargetEnumType.Value): Replaced by a GetValue() method.
* languages/TargetType.cs
(TargetType.GetObject): Added `TargetMemoryAccess' argument.
(TargetType.DoGetObject): Likewise.
2007-10-02 Martin Baulig <martin@ximian.com>
* backend/server/x86-linux-ptrace.c
(_server_ptrace_check_errno): New static method; when `errno' is
`ESRCH', check whether the target still exists to distinguish
between `COMMAND_ERROR_NOT_STOPPED' and `COMMAND_ERROR_NO_TARGET'.
2007-10-02 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.ProcessEvent): Added new `dead' flag which
is set when we receive `CHILD_EXITED' or `CHILD_SIGNALED'.
(SingleSteppingEngine.IsAlive): Also check for `dead' and `killed'.
2007-10-02 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.Return): Create our own, local backtrace
instead of using `current_backtrace'; limit the maximum number of
frames to 2 since that's all we need here.
* classes/Backtrace.cs
(Backtrace.TryUnwind): Add sanity check to avoid 'loops'.
2007-09-28 Martin Baulig <martin@ximian.com>
* backend/MonoThreadManager.cs
(MonoDebuggerInfo.MinDynamicVersion): Require 61.
* languages/mono/MonoRuntime.cs
(MonoRuntime.ReadMonoMethod): New public static method.
2007-09-28 Martin Baulig <martin@ximian.com>
* languages/mono/MonoType.cs: Renamed into MonoRuntime.cs
(MonoType): Renamed into `MonoRuntime'.
2007-09-28 Martin Baulig <martin@ximian.com>
* backend/arch/DwarfReader.cs
(DwarfReader): Kill the `source_hash'; each source file may be
used multiple times in different compilation units.
2007-09-28 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture_I386.cs
(Architecture_I386.GetLMF): Make this work again.
2007-09-28 Martin Baulig <martin@ximian.com>
* backend/ProcessServant.cs
(ProcessServant.read_thread_table): Truncate the `TID' to 32-bits
on 32-bit machines.
2007-09-27 Martin Baulig <martin@ximian.com>
* languages/mono/MonoLanguageBackend.cs
(MonoLanguageBackend.ReadMonoClass): Use
MonoClassInfo.ReadMonoClass() to create the `MonoClassInfo', then
create a `MonoClassType'.
(MonoLanguageBackend.CreateClassInfo): Renamed into
CreateCoreType(); create the MonoClassType here and not inside
MonoClassInfo's .ctor.
* languages/mono/MonoClassType.cs
(MonoClassType.ReadClassType): Removed.
* languages/mono/MonoClassInfo.cs
(MonoClassInfo.ClassType): Removed.
2007-09-27 Martin Baulig <martin@ximian.com>
* languages/mono/MonoObjectType.cs
(MonoObjectType): Replace the public .ctor with a static
Create() method.
* languages/mono/MonoOpaqueType.cs: Renamed into MonoVoidType.cs
(MonoOpaqueType): Renamed into `MonoVoidType'.
2007-09-27 Martin Baulig <martin@ximian.com>
* languages/mono/MonoType.cs
(MonoType.Read): Renamed into ReadType().
(MonoType.ReadMonoClass): New public static method.
* languages/mono/MonoObjectObject.cs
(MonoObjectObject.GetCurrentType): Use MonoType.ReadMonoClass().
2007-09-27 Martin Baulig <martin@ximian.com>
* languages/mono/MonoFundamentalType.cs
(MonoFundamentalType): Replace the public .ctor with a static
Create() method.
* languages/mono/MonoStringType.cs
(MonoStringType): Replace the public .ctor with a static
Create() method.
2007-09-26 Wade Berrier <wberrier@novell.com>
* languages/native/Makefile.am:
* languages/mono/Makefile.am:
Glob .cs for EXTRA_DIST so these don't need updating anymore.
2007-09-26 Martin Baulig <martin@ximian.com>
* languages/mono/MonoFundamentalType.cs
(MonoFundamentalType): The .ctor now takes a `MonoClassInfo'.
* languages/mono/MonoClassType.cs
(MonoClassType): Add a .ctor taking a `MonoClassInfo'; remove the
one taking a `TargetAddress'.
2007-09-26 Martin Baulig <martin@ximian.com>
* languages/mono/MonoClassInfo.cs
(MonoClassInfo): Read field offsets and methods on-the-fly when
they're needed; this allows us to create a `MonoClassInfo' for
classes which aren't initialized yet.
(MonoClassInfo.FieldOffsets): Replaced by GetFieldOffsets().
(MonoClassInfo.GetMethodAddress): Added `TargetMemoryAccess' arg.
2007-09-26 Martin Baulig <martin@ximian.com>
* languages/TargetFundamentalType.cs
(TargetFundamentalType): Made this class abstract.
(TargetFundamentalType.HasClassType): Don't implement this here.
(TargetFundamentalType.ClassType): Likewise.
* languages/native/NativeFundamentalType.cs: New file.
(NativeFundamentalType): Derive from `TargetFundamentalType'.
* languages/mono/MonoFundamentalType.cs
(MonoFundamentalType): Implement `HasClassType' and `ClassType' here.
2007-09-25 Martin Baulig <martin@ximian.com>
* languages/mono/MonoSymbolFile.cs
(MonoTypeTable.ReadDataItem): Create a `token' -> `klass_address'
hash table; don't actually read the class.
(MonoSymbolFile.LookupClassInfo): New internal method; we now
create the `MonoClassInfo' on-the-fly when it's needed.
2007-09-25 Martin Baulig <martin@ximian.com>
* languages/mono/MonoClassType.cs
(MonoClassType.ResolveClass): Added `TargetMemoryAccess target'
and `bool fail' arguments.
2007-09-25 Martin Baulig <martin@ximian.com>
* languages/mono/MonoDebuggerSupport.cs
(MonoDebuggerSupport.GetLocalTypeFromSignature): Removed.
2007-09-25 Martin Baulig <martin@ximian.com>
* classes/Method.cs
(Method.DeclaringType): Repaced by GetDeclaringType().
2007-09-25 Martin Baulig <martin@ximian.com>
* languages/mono/MonoSymbolFile.cs
(MonoMethod): Use the new MonoType.Read() to construct the
variable's types from the `MonoType *'s provided by the runtime.
2007-09-25 Martin Baulig <martin@ximian.com>
* languages/mono/MonoType.cs: New file.
(MonoTypeEnum): New static enum.
(MonoType): New internal static class.
* languages/mono/MonoLanguageBackend.cs
(MonoLanguageBackend.GetClass): Renamed into ReadMonoClass().
2007-09-25 Martin Baulig <martin@ximian.com>
* classes/TargetException.cs
(TargetError): Add `MethodNotLoaded'.
2007-09-25 Martin Baulig <martin@ximian.com>
* classes/Method.cs
(Method): Replace the `This', `Locals' and `Parameters' by methods
which take a `TargetMemoryAccess' argument. This is neccessary
for generics.
(Method.This): Replaced by GetThis().
(Method.Parameters): Replaced by GetParameters().
(Method.Locals): Replaced by GetLocalVariables().
(Method.GetVariableByName): Removed.
* classes/StackFrame.cs
(StackFrame.Locals): Removed.
2007-09-24 Martin Baulig <martin@ximian.com>
* languages/mono/MonoLanguageBackend.cs
(MonoDataTable): Made this abstract; create `DomainDataTable' and
`MonoTypeTable' implementations.
2007-09-24 Martin Baulig <martin@ximian.com>
* languages/mono/MonoLanguageBackend.cs
(MonoDataTable): Formerly known as `MonoLanguageBackend.DataTable'.
(MonoLanguageBackend): Reflect latest runtime changes; we now have
one type table per symbol file.
* languages/mono/MonoSymbolFile.cs
(MonoSymbolFile.TypeTable): New public property.
2007-09-21 Martin Baulig <martin@ximian.com>
* languages/TargetType.cs
(TargetType.HasClassType): New public abstract property.
(TargetType.ClassType): Likewise.
2007-09-17 Martin Baulig <martin@ximian.com>
* languages/TargetType.cs
(TargetType): Renamed the abstract GetObject() into DoGetObject()
and made it protected; added a new non-abstract GetObject() which
just calls DoGetObject().
* languages/TargetLocation.cs
(TargetLocation): Made this class public; but removed all public
API entry points from it.
(TargetLocation.HasAddress): Made this internal.
(TargetLocation.GetAddress): Likewise.
2007-09-11 Martin Baulig <martin@ximian.com>
* backend/MonoThreadManager.cs
(MonoMetadataInfo): Add `MonoMethodFlagsOffset' and
`MonoMethodInflatedOffset'.
2007-09-04 Martin Baulig <martin@ximian.com>
* frontend/CSharpExpressionParser.jay
(member_name): New rule; support member names with generic arity.
(variable_or_type_name_0): Use `member_name' instead of
`IDENTIFIER' to allow names with generic arity.
* languages/mono/MonoMember.cs
(MonoMethodInfo): Include the generic arity in the method name.
* languages/mono/MonoFunctionType.cs
(MonoFunctionType): Include the generic arity in the method name.
2007-09-04 Martin Baulig <martin@ximian.com>
* backend/BreakpointManager.cs: Kill the `entry_hash'; only use
the `index_hash'.
2007-09-03 Martin Baulig <martin@ximian.com>
*** Milestone: Appdomains are now fully functional ***
2007-09-03 Martin Baulig <martin@ximian.com>
Fix a race condition in the thread-lock code.
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.ReleaseThreadLock): If we have a `stop_event',
don't process it here while we're called from the ProcessServant;
added a new overloaded version of this function which is now
called from the ThreadManager's event loop.
* backend/ThreadManager.cs
(ThreadManager.AddPendingEvent): New internal method; we're called
from SingleSteppingEngine.ReleaseThreadLock(); just queue the
event and process it next time we run the event loop.
(ThreadManager.engine_thread_main): Check for pending events.
2007-09-03 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.WaitAll): Don't stop if another than the current
thread exited.
2007-09-03 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(SteppingCommand.DoExecute): Only switch threads if the new thread
is alive.
2007-09-03 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(BreakCommand): Add new `lazy' argument to disable error checking.
* test/testsuite/TestAppDomain-Module.cs:
Insert a breakpoint on Hello.World(), which is dynamically loaded.
2007-09-03 Martin Baulig <martin@ximian.com>
User-visible change:
- `run' no longer stops in main
- there's a new `start' command which starts the target and stops
in main.
* frontend/Command.cs
(StartCommand): New command; start the target and stop in main.
(RunCommand): Don't stop in main anymore.
2007-09-03 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.OnModuleLoaded): New internal method; check
whether we need to activate any breakpoints and start an
`OperationActivateBreakpoints' if neccessary.
(OperationActivateBreakpoints): New operation.
(OperationStart): Don't activate any breakpoints here; just call
sse.OnModuleLoaded() and let the new `OperationActivateBreakpoints'
do the job.
* backend/ProcessStart.cs
(ProcessStart.StopInMain): New public property.
(ProcessStart.SetupApplication): We're called on exec() -> set
`StopInMain' to false.
* languages/mono/MonoLanguageBackend.cs
(MonoLanguageBackend.Notification): Added `SingleSteppingEngine'
argument; return a `bool' denoting whether or not to resume the
target.
2007-08-24 Wade Berrier <wberrier@novell.com>
* backend/Makefile.am: Glob .cs for EXTRA_DIST so these don't
need updating anymore.
2007-08-23 Martin Baulig <martin@ximian.com>
* test/src/IHelloInterface.cs: New file.
* test/src/TestAppDomain-Hello.cs: New file.
* test/src/TestAppDomain-Module.cs: New file.
* test/testsuite/TestAppDomain-Module.cs: New test.
2007-08-22 Martin Baulig <martin@ximian.com>
* backend/arch/Bfd.cs
(Bfd): Several bug fixes; mostly for core files.
(Bfd.LookupLocalSymbol): New public method.
(bfd.FindSection): New internal method.
* backend/arch/BfdContainer.cs
(BfdContainer.LookupLibrary): New public method.
(BfdContainer.FindLibrary): New public method.
* backend/arch/CoreFile.cs: Make this work again.
* backend/arch/bfdglue.c
(bfd_glue_get_errormsg): New public function.
(bfd_glue_get_section_size): Removed the `raw_section' argument.
2007-08-22 Martin Baulig <martin@ximian.com>
* languages/mono/MonoLanguageBackend.cs: Reflect latest runtime
changes; the method range entries are now stored on a per-domain
basis and are free'ed when the domain gets unloaded. Add support
for unloading symbol files.
2007-08-22 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs
(SSE.OnManagedThreadCreated): Remove the `tid' argument; this is
now computed by the ThreadDB.
(SSE.SetTID): New internal method; called by ThreadDB.
(SSE.SetLMFAddress): Likewise.
(SSE.OperationGetCurrentThread): Removed; we now use ThreadDB for this.
2007-08-22 Martin Baulig <martin@ximian.com>
* backend/ProcessServant.cs: Use the new `ThreadDB' interface if
possible. When attaching to a managed application, read the new
thread table from the runtime.
* backend/ThreadDB.cs: New file. We now use glibc's `thread_db'
library to get information about threads.
* backend/server/thread-db.[ch]: New files.
* backend/server/linux-proc-service.h: New file; copied from glibc.
2007-08-06 Wade Berrier <wberrier@novell.com>
* classes/Makefile.am:
* languages/mono/Makefile.am:
* languages/Makefile.am:
Update filelists for new source files to fix 'make dist'
Beautify listing
* test/src/Makefile.am:
Clean up list duplication, only build .cs files during 'make check'
2007-08-07 Martin Baulig <martin@ximian.com>
* backend/ILanguageBackend.cs (NotificationType): Add `DomainUnload'.
* backend/BreakpointManager.cs
(BreakpointManager.DomainUnload): New public method; remove all
breakpoints from an appdomain.
* backend/MonoThreadManager.cs
(MonoThreadManager.HandleChildEvent): Added a new `DomainUnload'
notification; we're called from the JIT before unloading an
appdomain, call BreakpointManager.DomainUnload() to remove all its
breakpoints.
2007-08-06 Martin Baulig <martin@ximian.com>
* backend/TargetMemoryAccess.cs
(TargetMemoryAccess.InsertBreakpoint): Return `void'.
(TargetMemoryAccess.RemoveBreakpoint): Take a `BreakpointHandle',
not an integer index.
* backend/BreakpointManager.cs
(BreakpointManager): Added a second hash table which maps
breakpoint handles and appdomains into indices.
(BreakpointManager.InsertBreakpoint): Added `int domain' argument.
(BreakpointManager.RemoveBreakpoint): Take a `BreakpointHandle'
instead of an integer index; remove all breakpoints in all
appdomains.
* classes/SourceLocation.cs
(SourceLocation.ResolveBreakpoint): Remove the `domain' argument.
* test/testsuite/TestAppDomain.cs: Remove the breakpoint instead
of disabling it; this must remove it from all appdomains.
2007-08-06 Martin Baulig <martin@ximian.com>
* classes/Method.cs
(Method.Domain): New public property.
2007-08-06 Martin Baulig <martin@ximian.com>
* backend/BreakpointManager.cs
(BreakpointManager): Operate on `BreakpointHandle', not `Breakpoint'.
2007-08-06 Martin Baulig <martin@ximian.com>
* backend/TargetMemoryAccess.cs
(TargetMemoryAccess.InsertBreakpoint): Make this internal.
(TargetMemoryAccess.RemoveBreakpoint): Likewise.
* classes/AddressBreakpoint.cs
(AddressBreakpoint): Use `AddressBreakpointHandle'.
2007-08-01 Martin Baulig <martin@ximian.com>
* configure.in: Make sure the runtime is recent enough.
2007-08-01 Martin Baulig <martin@ximian.com>
* configure.in: Bump version number to 0.55.
2007-08-01 Martin Baulig <martin@ximian.com>
Merged the `debugger-dublin' branch.
2007-06-21 Martin Baulig <martin@ximian.com>
* backend/server/x86-linux-ptrace.c
(server_ptrace_read_memory): Moved the actual reading into
_server_ptrace_read_memory(), just remove the breakpoints here.
(_server_ptrace_read_memory): Like server_ptrace_read_memory(),
but don't remove any breakpoints.
* backend/server/x86-ptrace.c
(server_ptrace_write_memory): Use _server_ptrace_read_memory().
2007-06-21 Martin Baulig <martin@ximian.com>
* backend/MonoThreadManager.cs
(MonoDebuggerInfo.MaxDynamicVersion): Allow 59 here; keep
`MinDynamicVersion' at 58. The new `debugger-dublin' branch uses
59, but it's backwards-compatible.
2007-07-31 Martin Baulig <martin@ximian.com>
* test/src/TestAppDomain.cs: New test.
* test/testsuite/TestAppDomain.cs: New test.
2007-07-31 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture_X86_64.cs
(Architecture_X86_64.GetJumpOrCallTarget): New private method; fix
and improve GetCallTarget() and also add support for jump
instructions.
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.OperationNativeTrampoline): New operation;
keep stepping while we're in the trampoline like `finish -native'.
2007-07-30 Martin Baulig <martin@ximian.com>
* languages/TargetLocation.cs
(TargetLocation.Address): Replaced by GetAddress().
(TargetLocation.GetAddress): New public function; replaces the
`Address' property.
(TargetLocation.GetDereferencedTargetLocation): Removed the
`Thread' argument; returns a `DereferencedTargetLocation'.
* languages/TargetObject.cs
(TargetObject.Address): Replaced by GetAddress().
(TargetObject.GetAddress): New public function; replaces the
`Address' property.
(TargetObject.IsNull): Removed.
2007-07-30 Martin Baulig <martin@ximian.com>
* test/testsuite/testnativetypes.cs: New test.
* test/src/testnativetypes.c: New test.
2007-07-30 Martin Baulig <martin@ximian.com>
* languages/DeferencedTargetLocation.cs: New file.
2007-07-28 Martin Baulig <martin@ximian.com>
* backend/arch/DwarfReader.cs: Almost completely redesign the line
number table; it's no longer based on methods and now also works
with newer versions of gcc and g++.
2007-07-28 Martin Baulig <martin@ximian.com>
* classes/SourceLocation.cs
(SourceLocation): Add a .ctor which takes a `SourceFile' in
addition to a `MethodSource'.
2007-07-27 Martin Baulig <martin@ximian.com>
* classes/LineNumberTable.cs
(LineNumberTable): Made Lookup() and DumpLineNumbers() abstract;
move the actual implementation into MonoSymbolFile.cs and
DwarfReader.cs.
2007-07-27 Martin Baulig <martin@ximian.com>
* classes/LineNumberTable.cs
(LineNumberTable.Name): Removed.
(LineNumberTable.Module): Removed.
2007-07-27 Martin Baulig <martin@ximian.com>
* classes/SourceAddress.cs
(SourceAddress.Null): Removed.
(SourceAddress.LineNumberTable): Removed.
(SourceAddress.SourceBuffer): New public property.
* classes/LineNumberTable.cs
(LineNumberTable.IsDynamic): Removed.
(LineNumberTable.SourceBuffer): Removed.
2007-07-27 Martin Baulig <martin@ximian.com>
* classes/MethodSource.cs
(MethodSource.IsDynamic): New public property.
(MethodSource.HasSourceCode): Renamed into `HasSourceFile'.
(MethodSource.HasSourceBuffer): New public property.
(MethodSource.SourceBuffer): New public property.
* classes/AssemblerMethod.cs
(AssemblerMethod): Derive from `MethodSource', not
`LineNumberTable'.
* classes/Method.cs
(Method.HasSourceFile): Removed.
(Method.SourceFile): Removed.
* languages/mono/MonoSymbolFile.cs
(WrapperMethod): Also create a MethodSource for wrappers.
2007-07-26 Martin Baulig <martin@ximian.com>
* classes/SourceAddress.cs
(SourceAddress.Location): Removed.
(SourceAddress.SourceFile): New public property.
* classes/LineNumberTable.cs
(LineNumberTable): Removed `MethodSource', `Addresses',
`StartRow', `EndRow' and `GetNamespaces()'.
* classes/Method.cs
(Method.HasSource): New public property.
(Method.MethodSource): New public property.
(Method.GetNamespaces): New public method.
(Method): Removed `StartRow' and `EndRow'; get them from the
`MethodSource' instead.
2007-07-20 Martin Baulig <martin@ximian.com>
* languages/mono/MonoFundamentalType.cs: New file.
(MonoFundamentalType): New type.
* languages/mono/MonoStringType.cs
(MonoStringType): Derive from `MonoFundamentalType'.
* languages/mono/MonoObjectType.cs
(MonoObjectType): Create the MonoClassType in the .ctor.
* languages/mono/MonoSymbolFile.cs
(MonoSymbolFile.LookupMonoClass): New public method; calls
LookupMonoType() and then returns a `MonoClassType', this also
works for fundamental types.
* languages/mono/MonoLanguageBackend.cs
(MonoBuiltinTypeInfo): Use the new `MonoFundamentalType'.
2007-06-28 Martin Baulig <martin@ximian.com>
* backend/MonoThreadManager.cs
(MonoDebuggerInfo): Reflect latest runtime changes; add the new
`DebuggerVersion' field.
2007-06-04 Martin Baulig <martin@ximian.com>
* classes/Thread.cs
(Thread.CallMethod (long,string)): Added second `long' argument
so we can now pass a long value in addition to the string to the
target.
* backends/Inferior.cs
(Inferior.CallMethod (long,string)): Added second `long' argument
so we can now pass a long value in addition to the string to the
target.
* backends/server/server.h
(mono_debugger_server_call_method_1): Added `guint64 data_arg'
argument.
2007-06-04 Martin Baulig <martin@ximian.com>
Replace `SourceMethod' with a new abstract `MethodSource'.
* classes/MethodSource.cs: New file.
(MethodSource): New public abstract class.
* classes/SourceInfo.cs
(SourceMethod): Removed; we now use the new `MethodSource'.
* classes/Module.cs
(Module.LookupMethod): Removed; use FindMethod() instead.
(Module.RegisterLoadHandler): Removed.
2007-05-29 Wade Berrier <wberrier@novell.com>
* classes/Makefile.am: fix make dist (remove MethodSource.cs)
2007-05-29 Martin Baulig <martin@ximian.com>
* classes/Method.cs
(Method.StartRow, Method.EndRow): New public properties. Only
valid when `HasSourceFile' is true.
2007-05-29 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.SourceFileFactory): New public property; moved the
`SourceFileFactory' from the backend to the frontend.
* frontend/Interpreter.cs
(Interpreter.ReadFile): New public method.
* classes/Method.cs
(Method.HasSourceFile): New public property.
(Method.SourceFile): New public property.
* classes/Process.cs
(Process.SourceFileFactory): Removed.
* backend/ProcessServant.cs
(ProcessServant.SourceFileFactory): Removed.
2007-05-29 Martin Baulig <martin@ximian.com>
* classes/MethodSource.cs: Renamed into LineNumberTable.cs
(MethodSource): Renamed into `LineNumberTable'.
* classes/Method.cs
(Method.HasSource): Renamed into `HasLineNumbers'.
(Method.Source): Renamed into `LineNumberTable'.
2007-05-23 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(SourceCommand.FindFile): Don't do a method lookup here.
(ListCommand.DoExecute): We can now list source locations outside
methods.
2007-05-16 Martin Baulig <martin@ximian.com>
* classes/SourceLocation.cs
(SourceLocation.FunctionBreakpointHandle): Moved into
BreakpointHandle.cs and made internal.
* backend/BreakpointHandle.cs
(FunctionBreakpointHandle): New internal class.
2007-05-16 Martin Baulig <martin@ximian.com>
* classes/Breakpoint.cs
(Breakpoint.Resolve): New abstract internal method.
* classes/SourceLocation.cs
(SourceLocation.InsertBreakpoint): Renamed into
ResolveBreakpoint(); don't take a `Thread' argument. You need to
call Insert() on the returned `BreakpointHandle' to actually
insert the breakpoint.
* backend/BreakpointHandle.cs
(BreakpointHandle.Insert): New public abstract method; we need to
call this to actually insert the breakpoint.
(AddressBreakpointHandle): New internal class.
2007-05-09 Martin Baulig <martin@ximian.com>
Released version 0.50 "Dublin" of the Mono Debugger :-)
* configure.in: Require Mono >= 1.2.4.
2007-05-14 Martin Baulig <martin@ximian.com>
* languages/mono/MonoLanguageBackend.cs
(MonoLanguageBackend.symbol_files): Make this a Hashtable instead
of an ArrayList; don't store any null's in the list.
2007-05-14 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture_I386.cs
(Architecture_I386.GetLMF): Correctly set ebp.
* backend/arch/Architecture_X86_64.cs
(Architecture_X86_64.GetLMF): Correctly set rbp.
2007-05-09 Martin Baulig <martin@ximian.com>
* frontend/ObjectFormatter.cs
(ObjectFormatter.FormatEnum): Sort the keys alphabetically.
2007-05-09 Martin Baulig <martin@ximian.com>
* test/testsuite/NUnit.cs (TestSuite.Compile): Don't take a
filename argument; use the `FileName' and `ExeFileName' and pass
the output filename to mcs to make things work with
srcdir != builddir.
2007-05-09 Martin Baulig <martin@ximian.com>
* languages/mono/MonoClassInfo.cs
(MonoClassInfo.GenericClass): New public field.
(MonoClassInfo.GenericContainer): Likewise.
* languages/mono/MonoLanguageBackend.cs
(MonoLanguageBackend.GetClassInfo): Don't add generic classes to
the type hash.
2007-05-09 Martin Baulig <martin@ximian.com>
* classes/DebuggerOptions.cs
(DebuggerOptions.ParseCommandLine): Warn about unknown arguments.
2007-05-08 Martin Baulig <martin@ximian.com>
The new ObjectFormatter :-)
This has two major user-visible changes:
- When printing a class, we now include fields from the parent type.
- When printing a variable, we use the actual type of the object
rather than just using the variable type.
* classes/Style.cs (StructFormatter): Removed; this has been
replaced by the new ObjectFormatter.
* frontend/Expression.cs
(Expression.DoEvaluateObject): Get the "real" type of a class
object instead of just using the variable type.
(BaseExpression.DoEvaluateObject): We need to override this and
use the variable type.
* frontend/ObjectFormatter.cs: New file.
(ObjectFormatter): New public class.
* frontend/Style.cs: Use the new ObjectFormatter.
2007-05-08 Martin Baulig <martin@ximian.com>
* languages/mono/MonoClassType.cs
(MonoClassType.GetCurrentObject): Unbox the object if necessary.
* languages/mono/MonoClassObject.cs
(MonoClassObject.GetParentObject): Ensure that `type.IsByRef'.
2007-05-02 Martin Baulig <martin@ximian.com>
* languages/mono/MonoClassInfo.cs
(MonoClassInfo): Completely redesigned this; we now construct the
`MonoClassInfo' when reading the symbol tables and it replaces the
`ClassEntry' in the symbol table. This means that we don't have
to do any target access when actually using the class.
* languages/mono/MonoLanguageBackend.cs
(MonoLanguageBackend.read_class_entry): Read all the data from the
target and construct the `MonoClassInfo' here, so we don't have to
make any target access when actually using the class.
* languages/mono/MonoClassObject.cs
(MonoClassObject): We now keep a reference to our `MonoClassType',
not our `MonoClassInfo'.
2007-04-18 Martin Baulig <martin@ximian.com>
Reimplement displays; integrate them with the session code and use
the new expression parser.
* classes/Display.cs: New file.
(Display): New public class.
* classes/DebuggerSession.cs
(DebuggerSession): Add displays to the session.
* frontend/Displays.cs: Removed.
* frontend/Command.cs
(DisplayCommand): Derive from `DebuggerCommand'.
(UndisplayCommand): Likewise.
* frontend/Expression.cs
(ExpressionParser.EvaluateExpression): New public method.
* frontend/Interpreter.cs
(Interpreter): Displays are now in the `DebuggerSession'.
2007-04-17 Martin Baulig <martin@ximian.com>
* classes/ExpressionBreakpoint.cs
(ILocationParser): Moved to DebuggerSession.cs and renamed into
`IExpressionParser'.
* classes/DebuggerSession.cs
(LocationType): Moved here from ExpressionBreakpoint.cs.
(IExpressionParser): Formerly known as `ILocationParser'.
* frontend/Expression.cs: Merge `ExpressionParser' and
`LocationParser'.
2007-04-17 Martin Baulig <martin@ximian.com>
* frontend/IExpressionParser.cs: Removed.
* frontend/CSharpExpressionParser.jay: We don't need a
`ScriptingContext' here; allow reusing the parser to parse
multiple expressions.
* frontend/Expression.cs
(ExpressionParser): New public class.
* frontend/Interpreter.cs
(Interpreter.ExpressionParser): New public property.
2007-04-17 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter): Remove support for multiple parser languages; this
was never used and we only supported "c#" anyways.
2007-04-04 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(BacktraceCommand.DoExecute): If we already have a backtrace and
no arguments were given, reuse it.
2007-03-28 Jb Evain <jb@nurv.fr>
* frontend/Command.cs: Rename PrintFrameCommand to SelectFrameCommand.
and make it able to select the current frame.
2007-03-14 Martin Baulig <martin@ximian.com>
* languages/mono/MonoSymbolFile.cs
(MonoSymbolFile.MonoMethod.GetTypeSignature): Add support for
byref types and arrays.
2007-03-13 Miguel de Icaza <miguel@novell.com>
* languages/mono/MonoLanguageBackend.cs: The main assembly might
not have symbols, we should not crash in that case.
2007-03-08 Wade Berrier <wberrier@novell.com>
* classes/Makefile.am: added new files to fix make dist,
beautified listing
2007-03-08 Martin Baulig <martin@ximian.com>
* api/: Removed unused directory.
2007-03-08 Massimiliano Mantione <massi@ximian.com>
* frontend/Command.cs: Added "[un]display" and enhanced "examine".
* frontend/Style.cs: In StyleCLI.TargetStopped, added code to
show displays to the user.
* frontend/Displays.cs: Implemented displays.
* frontend/Interpreter.cs: Added the collection of displays to
the interpreter instance.
* build/Makefile.am, frontend/Makefile.am: added Displays.cs
2007-03-06 Martin Baulig <martin@ximian.com>
* test/testsuite/TestSession.cs: Add a new testcase.
2007-03-06 Martin Baulig <martin@ximian.com>
* classes/Debugger.cs
(Debugger.MainProcessCreatedEvent): New public event.
* backend/ProcessServant.cs
(ProcessServant.Initialize): Fire a `MainProcessCreatedEvent' when
creating the main process.
* test/testsuite/NUnit.cs
(TestSuite.Start): New public method; use this instead of
`Interpreter.Start()'.
(TestSuite.LoadSession): Likewise.
(TestSuite.Attach): Likewise.
* test/testsuite/*.cs: Use our parent class'es Start(),
LoadSession() and Attach() methods instead directly calling them
on the `Interpreter'.
* test/testsuite/TestSession.cs: Add a new testcase.
2007-03-05 Martin Baulig <martin@ximian.com>
* classes/ExpressionBreakpoint.cs: New file.
(ExpressionBreakpoint.LocationType): Moved here from
frontend/Expression.cs.
* classes/DebuggerSession.cs
(DebuggerSession.ctor): Added `ILocationParser parser' argument.
(DebuggerSession.ParseLocation): New internal method.
(DebuggerSession.InsertBreakpoint): Added overloaded version
taking a `LocationType' and a `string'.
* frontend/Expression.cs
(LocationParser): New public class.
* frontend/Command.cs
(BreakCommand): Completely rewrote this; we can now insert
breakpoints before the target is started.
2007-02-28 Martin Baulig <martin@ximian.com>
* test/testsuite/TestBreakpoint.cs: Add a test for inserting
breakpoints by filename.
2007-02-28 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.cs
(DebuggerSession.InsertBreakpoint): Don't take a `Thread' argument
when inserting a breakpoint on a `SourceLocation' and don't
activate it. This allows us to insert such breakpoints before the
target is started.
* frontend/Interpreter.cs
(Interpreter.InsertBreakpoint): Removed; call
DebuggerSession.InsertBreakpoint() directly.
* frontend/Command.cs
(TestCommand): Temporary hack.
2007-02-28 Martin Baulig <martin@ximian.com>
* backend/ProcessStart.cs
(ProcessStart..ctor): Set `options.WorkingDirectory' if null.
* classes/Process.cs
(Process.FindFile): Correctly implement this.
(Process.FindLocation): Removed; use FileFile() instead.
2007-02-28 Martin Baulig <martin@ximian.com>
* classes/Process.cs
(Process.GetFullPath): Removed; use FindFile() instead.
2007-02-28 Martin Baulig <martin@ximian.com>
* classes/SourceInfo.cs
(SourceFile.FindMethod): New public method.
* classes/Process.cs
(Process.FindFile): New public method.
* classes/Module.cs
(Module.FindFile): New public method.
* classes/SourceLocation.cs
(SourceLocation): Allow file-line locations.
2007-02-27 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(BreakpointEnableCommand, BreakpointDisableCommand): Also activate
and deactivate the breakpoint if we have a target.
2007-02-27 Martin Baulig <martin@ximian.com>
* classes/Process.cs
(Process.GetFullPath): New public method; moved here from the
`ScriptingContext'.
* frontend/ScriptingContext.cs
(ScriptingContext.GetFullPath): Moved into `Process'.
(ScriptingContext.GetFullPathByFilename): Removed.
2007-02-27 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(ShowCommand): Make `show events' and alias for `show breakpoints'.
2007-02-27 Martin Baulig <martin@ximian.com>
* classes/Event.cs
(Event.Enable): Renamed to `Activate' and made public.
(Event.Disable): Renamed to `Deactivate' and made public.
(Event.IsEnabled): New public abstract property.
2007-02-23 Martin Baulig <martin@ximian.com>
* classes/ExceptionCatchPoint.cs
(ExceptionCatchPoint): Make this persistent.
2007-02-22 Martin Baulig <martin@ximian.com>
* classes/Event.cs
(Event.IsPersistent): New public property.
* classes/Breakpoint.cs
(Breakpoint): Make this class abstract and split the functionality
into `SourceBreakpoint' and `AddressBreakpoint'.
* classes/SourceBreakpoint.cs: New file.
(SourceBreakpoint): New public class.
* classes/AddressBreakpoint.cs: New file.
(AddressBreakpoint): New public class.
2007-02-22 Martin Baulig <martin@ximian.com>
* classes/Event.cs
(EventType): Added `Breakpoint', `WatchRead' and `WatchWrite'.
(Event.Type): New public property.
* classes/Breakpoint.cs
(HardwareWatchType): New public enum.
(BreakpointType): Removed; use `EventType' instead.
* classes/Thread.cs
(Thread.AddEventHandler): Removed the `EventType' argument.
* backends/ThreadServer.cs
(ThreadServant.AddEventHandler): Likewise.
2007-02-22 Martin Baulig <martin@ximian.com>
* languages/mono/MonoLanguageBackend.cs: Don't crash if we can't
find a symbol file.
2007-02-20 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.cs
(DebuggerSession): Store the main process internally and use it's
main thread when removing events.
(DebuggerSession.DeleteEvent): Removed the `Thread' argument.
* frontend/Command.cs
(EventHandleCommand): Derive from `DebuggerCommand', not
`ThreadCommand'; the "enable", "disable" and "delete" commands now
longer require a thread to operate on - it's now also possible to
enable/disable or delete events after the target exited.
2007-02-20 Martin Baulig <martin@ximian.com>
* classes/Event.cs
(Event.Breaks): Check `IsEnabled' as well.
(Event.Enable, Event.Disable): Make these methods internal; modify
the `IsEnabled' property instead.
* classes/DebuggerSession.cs
(DebuggerSession.InsertBreakpoint): Also enable the breakpoint by
calling the now internal `Event.Enable ()'.
(DebuggerSession.InsertHardwareWatchPoint): Likewise.
(DebuggerSession.InsertExceptionCatchPoint): Likewise.
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine): Check whether a breakpoint is actually enabled.
2007-02-16 Martin Baulig <martin@ximian.com>
Session changes: keep the `DebuggerSession' in memory between
different invocations of the same target; this allows us to modify
breakpoints before starting the target.
* classes/DebuggerSession.cs
(DebuggerSession.SessionData): Removed the nested class.
* classes/Event.cs
(Event.IsEnabled): Added a setter for this property.
* classes/SourceLocation.cs
(SourceLocation): Splitted into `SourceLocation' and
`DynamicSourceLocation'; the `SourceLocation' can now persist
across different invocations of the same target.
2007-02-13 Martin Baulig <martin@ximian.com>
* test/testsuite/NUnit.cs: Run the tests in the invariant culture;
fixes #80360.
2007-02-12 Martin Baulig <martin@ximian.com>
* configure.in: Require Mono >= 1.2.3.
2007-02-08 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs (Interpreter.WaitAll): Fix another bug.
2007-02-08 Martin Baulig <martin@ximian.com>
Distinguish between normal stopping and receiving a SIGSTOP in the
backend.
* backend/server/x86-arch.h
(ChildStoppedAction): Added `STOP_ACTION_INTERRUPTED'; renamed
`STOP_ACTION_SEND_STOPPED' to `STOP_ACTION_STOPPED'.
* backend/server/server.h
(ServerStatusMessageType): Added `MESSAGE_CHILD_INTERRUPTED'.
* backend/Inferior.cs
(Inferior.ChildEventType): Added `CHILD_INTERRUPTED'.
* backend/SingleSteppingEngine.cs: Handle `CHILD_INTERRUPTED'
separately; we now distinguish between stopped normally (hitting a
breakpoint, receiving a notification etc.) or being stopped by a
SIGSTOP.
* classes/TargetEvent.cs
(TargetEventType): Added `TargetInterrupted'.
2007-02-01 Miguel de Icaza <miguel@novell.com>
* frontend/Command.cs: Make it so "list -" works.
2007-02-01 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs: Fix a race condition: if we hit
a breakpoint and a stop has been requested at the same time, check
the breakpoint handler first and report `TargetStopped' instead of
`TargetHitBreakpoint' if the handler told us to resume.
2007-02-01 Martin Baulig <martin@ximian.com>
* interface/Report.cs
(ReportWriter.PrintToConsole): New public property.
(ReportWriter.Print): Also print to the console if we have a
logfile and `PrintToConsole' is true. We use this for the test
suite to suppress output to the console.
2007-01-30 Martin Baulig <martin@ximian.com>
* languages/Language.cs
(Language.ArrayType): New public property.
* languages/TargetArrayObject.cs
(TargetArrayObject.HasClassObject): New public abstract property.
(TargetArrayObject.GetClassObject): New public abstract method.
* frontend/Expression.cs
(Convert.ToClassObject): Handle `TargetArrayObject' -> `TargetClassObject'.
(Convert.ToClassType): Handle `TargetArrayType' -> `TargetClassType'.
* test/testsuite/TestManagedTypes.cs: Add tests for that.
2007-01-30 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs
(StructAccessExpression.GetField): Add support for consts.
* frontend/Style.cs
(StyleCLI.FormatMember): Add support for consts.
2007-01-29 Martin Baulig <martin@ximian.com>
* test/testsuite/NUnit.cs
(TestSuite.Compile): New public method to trigger a mcs compilation.
(TestSuite.OnTargetOutput): Don't call our base method; ie. we
don't want to print the text to the console.
* test/testsuite/TestSession.cs: New test.
* test/src/TestSession.cs: Source file for it.
2007-01-29 Martin Baulig <martin@ximian.com>
* build/AssemblyInfo.cs.in (BuildInfo.mcs): New public property.
2007-01-29 Martin Baulig <martin@ximian.com>
* interface/Report.cs (Report.Print): Only print to the `writer'.
(Report.Errort): Likewise.
2007-01-29 Martin Baulig <martin@ximian.com>
* backend/server/x86-ptrace.c
(server_ptrace_spawn): Use mono_domain_get() instead of
mono_get_root_domain() to execute the callback in the correct domain.
2007-01-29 Martin Baulig <martin@ximian.com>
* languages/mono/MonoSymbolFile.cs
(MonoSymbolFile.ctor): Do the GUID check here rather than passing
an assembly to C.MonoSymbolFile's .ctor.
2007-01-25 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.Stop): Check whether a stop has already been
requested.
2007-01-25 Martin Baulig <martin@ximian.com>
* build/Makefile.am
(check-local): Set LD_LIBRARY_PATH to build/server/.libs.
2007-01-24 Wade Berrier <wberrier@novell.com>
* backend/server/Makefile.am: remove deleted files to fix make dist
2007-01-24 Martin Baulig <martin@ximian.com>
* test/testsuite/TestMultiThread.cs: Improved the test.
2007-01-24 Martin Baulig <martin@ximian.com>
* backend/server/i386-win32.[ch]: Removed old code.
* backend/server/powerpc-arch.[ch]: Likewise.
* backend/server/powerpc-darwin.[ch]: Likewise.
* backend/server/x86-freebsd-ptrace.[ch]: Likewise.
2007-01-24 Martin Baulig <martin@ximian.com>
* test/testsuite/NUnit.cs (TestSuite..cctor): Call
Report.Initialize() in the .cctor rather than in the .ctor to
avoid a sharing violation on the logfile.
2007-01-23 Martin Baulig <martin@ximian.com>
* test/testsuite/TestMultiThread.cs: New test.
* test/src/TestMultiThread.cs: New test.
2007-01-23 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.WaitAll): Store the threads in a Hashtable instead of
an ArrayList and only start each thread once.
2007-01-23 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.ProcessOperation): Queue the operation and
start it later if we're currently thread-locked.
(SingleSteppingEngine.ReleaseThreadLockDone): New internal method.
* backend/ProcessServant.cs
(ProcessServant.ReleaseGlobalThreadLock): Call
ReleaseThreadLockDone() on each SSE after releasing the mutex to
start queued operations.
2007-01-19 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.IsStopped): Check whether the engine is
stopped rather than using the Inferior's TargetState.
* classes/Thread.cs
(Thread.IsStopped): Use `servant.IsStopped' rather than relying on
the `TargetState'.
2007-01-19 Martin Baulig <martin@ximian.com>
* classes/DebuggerConfiguration.cs
(DebuggerConfiguration.BrokenThreading): New public property;
enabled by default.
* frontend/Interpreter.cs
(Interpreter.RuntimeInvoke): New public method; use WaitAll() is
`DebuggerConfiguration.BrokenThreading' is set.
2007-01-19 Martin Baulig <martin@ximian.com>
* languages/mono/MonoLanguageBackend.cs: Don't crash if we don't
have a symbol table. This might happen if we for instance attach
to a mono process which is running without --debug.
2007-01-19 Martin Baulig <martin@ximian.com>
* classes/Backtrace.cs
(Backtrace.Mode): New public enum.
(Backtrace.GetBacktrace): Added `Mode mode' argument.
* classes/Thread.cs
(Thread.GetBacktrace): Added `Backtrace.Mode mode' argument.
* frontend/Command.cs
(BacktraceCommand): Added `-managed' and `-native' arguments.
2007-01-17 Martin Baulig <martin@ximian.com>
* classes/Backtrace.cs
(Backtrace.GetBacktrace): Make this internal and take a
`ThreadServant'.
(Backtrace.TryUnwind): Likewise.
(Backtrace.TryUnwind): If we're in unmanaged code and don't have
any source info, use the LMF to get back to managed land.
2007-01-17 Martin Baulig <martin@ximian.com>
* backend/arch/Architecture.cs
(Architecture.GetLMF): New internal method.
2007-01-17 Martin Baulig <martin@ximian.com>
* classes/Thread.cs
(Thread.LMFAddress): New internal property.
* backend/ThreadServant.cs
(ThreadServant.Process): New internal property.
* classes/TargetBinaryReader.cs
(TargetBinaryReader.ReadTargetAddress): New public method.
2007-01-17 Martin Baulig <martin@ximian.com>
* languages/Language.cs
(Language.IsManaged): New public property.
2007-01-17 Martin Baulig <martin@ximian.com>
* backend/ThreadServant.cs
(ThreadServant.LMFAddress): New public property.
* backend/SingleSteppingEngine.cs
(SingleSteppingEngine.OperationGetLMFAddress): New operation.
(SingleSteppingEngine.OperationStart): Push
OperationGetLMFAddress() to get the LMF on startup.
(SingleSteppingEngine.OperationInitialize): Likewise.
2007-01-16 Martin Baulig <martin@ximian.com>
* test/testsuite/: Updated the testsuite to reflect the latest
threading changes.
2007-01-16 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.CheckLastEvent): New method.
(Interpreter.WaitAll): Correctly implement this.
2007-01-16 Martin Baulig <martin@ximian.com>
* classes/Thread.cs (Thread.Flags): Added `AutoRun'.
(Thread.AutoStop): New public method.
* classes/DebuggerConfiguration.cs
(DebuggerConfiguration.StayInThread): New public property.
* backend/SingleSteppingEngine.cs: Correctly handle stop requests.
2007-01-03 Martin Baulig <martin@ximian.com>
* classes/Thread.cs (Thread.Flags): New public enum.
(Thread.ThreadFlags): New public property.
(Thread.IsAlive): New public property.
(Thread.IsDaemon): Removed.
(Thread.Continue): Removed the `is_background' argument.
(Thread.Background): New public method.
2006-12-29 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.IsSynchronous): Removed.
(Interpreter.WaitAll): New public method.
* frontend/Command.cs
(SteppingCommand): More work on the threading stuff.
2006-12-29 Martin Baulig <martin@ximian.com>
* classes/Thread.cs
(Thread): Make all the stepping operations return a
`ThreadCommandResult' instead of a `CommandResult'.
(Thread.GetLastTargetEvent): Renamed from `LastTargetEvent' and
made it a function.
(Thread.IsRunning): New public property.
2006-12-28 Martin Baulig <martin@ximian.com>
* backend/MonoThreadManager.cs
(MonoDebuggerInfo): Added `GetLMFAddress'.
2006-12-28 Martin Baulig <martin@ximian.com>
* classes/Process.cs
(Process): Replaced the `Threads' property with a GetThreads()
method.
2006-12-28 Martin Baulig <martin@ximian.com>
* classes/Thread.cs
(Thread.LastTargetEvent): New public property.
(CommandResult.Abort): New public method.
* backend/ThreadServant.cs
(ThreadServant.LastTargetEvent): New public property.
2006-12-28 Martin Baulig <martin@ximian.com>
* backend/SingleSteppingEngine.cs
(Operation): Store the `SingleSteppingEngine' inside the
`Operation', so we don't need to pass it around as a parameter.
2006-12-22 Martin Baulig <martin@ximian.com>
* backend/MonoThreadManager.cs: The `mono' binary now contains a
pointer to the `MONO_DEBUGGER__debugger_info' in a special
`.mdb_debug_info' section - this also works when the binary is
stripped.
2006-12-21 Martin Baulig <martin@ximian.com>
Change Ctrl-C semantics: abort the current operation on Ctrl-C.
* frontend/Main.cs
(CommandLineInterpreter.command_thread_main): Don't abort the main
thread on Ctrl-C; we still do it the second time the user hits
Ctrl-C as a fallback.
* frontend/Interpreter.cs
(Interpreter.Wait): Check whether the operation was interrupted by
Ctrl-C and stop the thread if neccessary.
* frontend/Command.cs: Use the new RuntimeInvoke API.
2006-12-21 Martin Baulig <martin@ximian.com>
* classes/Thread.cs
(Thread.StepCommandResult): Renamed to `ThreadCommandResult' and
made public.
(RuntimeInvokeResult): New public class; derives from `CommandResult'.
(Thread.RuntimeInvoke): Make this non-blocking and return a
`RuntimeCommandResult'; removed the other overloaded version.
2006-12-21 Martin Baulig <martin@ximian.com>
* configure.in: Bump version number to 0.35 for the SVN version;
the next release will be 0.40 "Bonn".
2006-11-15 Martin Baulig <martin@ximian.com>
Released version 0.31 "Ehrenbreitstein" of the Mono Debugger :-)
2006-11-14 Wade Berrier <wberrier@novell.com>
* ChangeLog: bump version for 0.31 tag
2006-11-10 Martin Baulig <martin@ximian.com>
* build/Makefile.am: Don't remove Mono.Debugger.Cecil.dll.
* build/Mono.Debugger.Cecil.dll: Upgrade to Cecil 0.4.3.
2006-11-10 Martin Baulig <martin@ximian.com>
* languages/mono/MonoLanguageBackend.cs: Don't crash if a symbol
file occurs twice in the list.
2006-11-10 Martin Baulig <martin@ximian.com>
* classes/Debugger.cs: Don't use another appdomain for the server.
2006-11-09 Wade Berrier <wberrier@novell.com>
* build/Makefile.am:
* classes/Makefile.am:
* frontend/libedit/Makefile.am:
* interface/Makefile.am:
Add/remove source files to filelistings to fix make dist
2006-10-25 Martin Baulig <martin@ximian.com>
* build/: Rename the current `Mono.Debugger.dll' into
`Mono.Debugger.Backend.dll' and create a new `Mono.Debugger.dll'.
* classes/TargetAddress.cs: Moved to ../interface.
* classes/AddressDomain.cs: Moved to ../interface.
* classes/Report.cs: Moved to ../interface.
2006-10-25 Martin Baulig <martin@ximian.com>
* classes/AddressDomain.cs
(AddressDomain): Don't make this byref; add [Serializable]
attribute and make the .ctor take the id as argument.
2006-10-25 Martin Baulig <martin@ximian.com>
* interfaces: Renamed to interface.
2006-10-25 Martin Baulig <martin@ximian.com>
* interfaces/ISymbolTable.cs: Moved to ../classes/.
* interfaces/ITargetNotification.cs: Moved to ../classes/.
2006-10-25 Martin Baulig <martin@ximian.com>
* jay/: Moved to frontend/jay/.
2006-10-25 Martin Baulig <martin@ximian.com>
* arch/: Moved to backend/arch.
2006-10-25 Martin Baulig <martin@ximian.com>
* backends/: Rename to backend.
2006-10-24 Wade Berrier <wberrier@novell.com>
* doc/Makefile.am: Update filelist for removed files to fix make dist
2006-10-09 Jb Evain <jbevain@gmail.com>
* languages/mono/MonoFunctionType.cs
languages/mono/MonoLanguageBackend.cs
languages/mono/MonoOpaqueType.cs
languages/mono/MonoSymbolFile.cs
languages/mono/MonoEnumType.cs
languages/mono/MonoMember.cs
languages/mono/MonoClassType.cs
languages/mono/MonoObjectType.cs
languages/mono/MonoDebuggerSupport.cs:
Don't use Cecil's interfaces which are deprecated
in the next version.
2006-07-18 Wade Berrier <wberrier@novell.com>
* backends/Makefile.am: Remove ModuleManager.cs from EXTRA_DIST
2006-07-18 Martin Baulig <martin@ximian.com>
Released version 0.30 "Koblenz" of the Mono Debugger :-)
2006-07-18 Martin Baulig <martin@ximian.com>
* configure.in: Require Mono >= 1.1.16.
2006-07-17 Martin Baulig <martin@ximian.com>
Kill the System.Data dependency.
* classes/DebuggerConfiguration.cs
(DebuggerConfiguration): Rewrite using System.Xml.
* classes/DebuggerSession.cs
(DebuggerSession): Rewrite using System.Xml; use an `XmlDocument'
instead of a `DataSet'.
* classes/DebuggerConfiguration.xsd: Update the schema to reflect
the new XML file format (we're still using the schema with an
`XmlValidatingReader').
2006-07-13 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(ModuleCommand): New command.
2006-07-13 Martin Baulig <martin@ximian.com>
* classes/DebuggerOptions.cs
(DebuggerOptions): Make this a DebuggerMarshalByRefObject.
(DebuggerOptions.Clone): New internal method.
* classes/DebuggerSession.cs
(DebuggerSession.Clone): Added `DebugggerOptions new_options' and
`string new_name' arguments.
* classes/Process.cs
(Process.Session): Get the session from the servant.
* backends/ProcessStart.cs
(ProcessStart.SetupApplication): Clone the options and update them
to the new values.
* frontend/Command.cs
(ShowCommand.ShowArgumentsCommand): Added `show args' command to
show the command line arguments.
2006-07-13 Martin Baulig <martin@ximian.com>
* classes/DebuggerConfiguration.cs
(DebuggerConfiguration): Rewrite to use System.Data with the
DebuggerConfiguration.xsd schema.
2006-07-12 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.xsd: Renamed into
DebuggerConfiguration.xsd.
2006-07-12 Martin Baulig <martin@ximian.com>
* classes/DebuggerOptions.cs: New file; split out
`DebuggerOptions' from DebuggerSession.cs.
2006-07-12 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.cs
(DebuggerOptions.ParseCommandLine): New public static method;
moved here from frontend/Main.cs.
2006-07-12 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.MethodHasSource): Don't check
`Module.StepInto' if the method we're stepping into is in the same
module.
2006-07-12 Martin Baulig <martin@ximian.com>
* classes/DebuggerOptions.cs
(DebuggerOptions.Prompt): Removed.
(DebuggerOptions.LoadNativeSymbolTable): Removed.
(DebuggerOptions.JitOptimizations): Default to null.
(DebuggerOptions.WorkingDirectory): Default to null.
(DebuggerSession): Also save/load the `DebuggerOptions'.
2006-07-08 Martin Baulig <martin@ximian.com>
* arch/DwarfReader.cs
(DwarfLocation): New protected class; moved the location reading here.
(DwarfLocation.GetLocation): Correctly handle `DW_OP_fbreg'.
(DieSubprogram): Support the `DW_AT_frame_base' attribute.
(DwarfTargetVariable): Moved the location code into `DwarfLocation'.
2006-07-06 Martin Baulig <martin@ximian.com>
* arch/Architecture_I386.cs
(Architecture_I386.IsSyscallInstruction): Correctly implement
this; also protect with try/catch.
* arch/Architecture_X86_64.cs
(Architecture_X86_64.IsSyscallInstruction): Protect with try/catch.
2006-07-06 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(OperationFinish.IsSourceOperation): Set to `!Native'.
2006-07-06 Martin Baulig <martin@ximian.com>
* backends/server/i386-arch.c (ArchInfo): Use `guint64' for
`dr_control' and `dr_status' since _server_ptrace_get_dr()
operates on guint64.
2006-07-06 Martin Baulig <martin@ximian.com>
* backends/server/x86_64-arch.c
(server_ptrace_insert_hw_breakpoint): Don't deadlock here.
* backends/server/i386-arch.c
(server_ptrace_insert_hw_breakpoint): Don't deadlock here.
2006-07-06 Martin Baulig <martin@ximian.com>
* classes/SourceInfo.cs
(SourceMethod.ClassName): New public property.
* classes/DebuggerSession.cs
(DebuggerSession.Clone): New internal method.
* backends/ProcessServant.cs
(ProcessServant.ChildExecd): Clone the session.
* classes/SourceLocation.cs
(SourceLocation): Make this actually work again.
2006-07-05 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.cs
(DebuggerSession.SessionData): New protected class; moved all the
session data here, we save this to XML when the target exists
while the `DebuggerSession' persists across multiple invocations.
2006-07-05 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.cs
(DebuggerSession.MainProcessReachedMain): Make this public again
and call it from the `Interpreter'; read the FIXME in the source
code.
* frontend/Interpreter.cs
(Interpreter.Start): Call `session.MainProcessReachedMain ()'.
(Interpreter.LoadSession): Likewise.
2006-07-03 Martin Baulig <martin@ximian.com>
* classes/Event.cs
(Event.OnTargetExited): New abstract internal method; an `Event'
may persist across multiple invocations of the target, so we use
this to disable the event when we exit.
* backends/ProcessServant.cs
(ProcessServant.OnProcessExitedEvent): New internal method; save
the session here.
* classes/DebuggerSession.cs
(DebuggerSession.OnProcessExited): Disable all events here.
2006-06-29 Martin Baulig <martin@ximian.com>
The big session-handling cleanup - we now load/save the session to
XML using a DataSet.
* classes/DebuggerConfiguration.cs
(DebuggerConfiguration.ModuleGroups): New internal property.
* classes/DebuggerSession.cs
(DebuggerSession): Moved thread groups and events here; load and
save the session from XML using a DataSet.
(DebuggerSession.CreateThreadGroup): Moved here.
(DebuggerSession.DeleteThreadGroup): Moved here.
(DebuggerSession.ThreadGroupExists): Moved here.
(DebuggerSession.ThreadGroups): Moved here.
(DebuggerSession.ThreadGroupByName): Moved here.
(DebuggerSession.MainThreadGroup): Moved here.
(DebuggerSession.Events): Moved here.
(DebuggerSession.GetEvent): Moved here.
(DebuggerSession.AddEvent): Moved here.
(DebuggerSession.DeleteEvent): Moved here.
(DebuggerSession.InsertBreakpoint): Moved here.
(DebuggerSession.SaveSession): New public method to save the
session as XML into a Stream.
(DebuggerSession.ctor): Added a ctor taking a `Stream' to load the
session from XML.
(DebuggerSession.SurrogateSelector): Removed.
* classes/DebuggerSession.xsd: New file.
* classes/Process.cs (Process.Session): New public property.
* classes/Event.cs
(Event.GetSessionData): New internal virtual method taking a
`DataRow' argument.
(Event.GetSessionData, SetSessionData): Removed the old
serialization-based implementation.
(Event.SessionSurrogate): Removed.
* classes/ThreadGroup.cs
(ThreadGroup.SessionSurrogate): Removed.
* classes/Module.cs
(SymbolFile.LookupMethod): New public abstract method.
(ModuleGroup.GetSessionData, SetSessionData): New internal
methods; operate on a `DataRow'.
(Module.LookupMethod): New public abstract method.
(Module.GetSessionData, SetSessionData): New internal methods;
operate on a `DataRow'.
(Module.SessionSurrogate): Removed.
* classes/SourceLocation.cs
(SourceLocation): Don't implement IDeserializationCallback.
(SourceLocation.method): New private field; when loading the
location from XML, we just have a method name and need to do a
method lookup.
* languages/TargetFunctionType.cs
(TargetFunctionType.Name): Don't include the class name here.
(TargetFunctionType.FullName): New public abstract property; this
is class name plus method name.
2006-06-26 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.cs
(DebuggerSession.ModulesChanged): Removed.
* classes/Module.cs
(SymbolFile): Implement IDisposable.
(SymbolFile.Module): New public abstract property.
(SymbolFile.DoDispose): New protected virtual method; call
`Module.UnLoadModule()'.
(Module.UnLoadModule): New internal method.
2006-06-26 Martin Baulig <martin@ximian.com>
* backends/SymbolTableManager.cs
(SymbolTableManager): Completely rewrite and simplify this;
instead of maintaining a `SymbolTableCollection' in a separate
thread, directly implement `ISymbolTable' and iterate over an
array of `SymbolFile's.
* classes/SourceInfo.cs
(SourceFile): Override GetHashCode() and Equals().
* classes/Module.cs
(Module.RegisterLoadHandler): Removed; call it on the `SymbolFile'
instead.
2006-06-26 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.cs
(DebuggerSession.ctor): Added `DebuggerConfiguration' argument.
(DebuggerSession.Config): New public readonly field.
(DebuggerSession): Moved the module management code here from
`ModuleManager'.
* backends/ModuleManager.cs: Removed.
(ModuleManager): Moved all the functionality into
`DebuggerSession'.
2006-06-26 Martin Baulig <martin@ximian.com>
* backends/SymbolTableManager.cs
(SymbolTableManager): Removed all the module code.
(SymbolTableManager.SetModules): Removed.
(SymbolTableManager.Modules): Removed.
2006-06-26 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.cs
(DebuggerSession): Make this a `DebuggerMarshalByRefObject'.
* classes/Debugger.cs
(Debugger.Run): Take a `DebuggerSession' argument instead of a
`DebuggerOptions' one.
(Debugger.Attach, Debugger.OpenCoreFile): Likewise.
* backends/DebuggerServant.cs
(DebuggerServabt.Run): Take a `DebuggerSession' argument instead
of a `DebuggerOptions' one.
(DebuggerServant.Attach, Debugger.OpenCoreFile): Likewise.
* backends/ProcessServant.cs
(ProcessServant.Session): New public property.
2006-06-26 Martin Baulig <martin@ximian.com>
* classes/Module.cs
(Module.BreakpointsChangedEvent): Removed.
* backends/ModuleManager.cs
(BreakpointChangedHandler): Removed.
(ModuleManager.BreakpointsChanged): Removed.
* backends/ProcessServant.cs
(ProcessServant.BreakpointsChangedEvent): Removed.
2006-06-26 Martin Baulig <martin@ximian.com>
* classes/DebuggerConfiguration.cs: New file.
(DebuggerConfiguration): New public class.
* classes/Debugger.cs
(Debugger.ctor): Added `DebuggerConfiguration' argument.
* classes/Module.cs
(SymbolFile.IsNative): New public property.
(ModuleBase): New public abstract base class.
(Module): Derive from `ModuleBase'.
(Module.ModuleGroup): New public property.
(Module.HideFromUser): New public property.
(ModuleGroup): New public class.
2006-06-12 Martin Baulig <martin@ximian.com>
* classes/TargetVariable.cs
(TargetVariable.IsInScope): New public abstract method.
* classes/Method.cs
(Method.GetVariableByName): Added `TargetAddress address' argument
and check whether the variable is actually in scope.
* classes/StackFrame.cs
(StackFrame.Locals): Use `local.IsInScope()' rather than
`local.IsAlive()'.
2006-06-12 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(OperationRuntimeInvoke.DoProcessEvent): Also push the rti frame
if we hit a breakpoint at the invoke method.
* test/testsuite/TestInvocation.cs: Added testcase for that.
2006-06-01 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine): Correctly handle the THROW_EXCEPTION /
HANDLE_EXCEPTION notification.
2006-06-01 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(BreakCommand): Added `-local' argument; change default behaviour
to `-global'.
2006-06-01 Martin Baulig <martin@ximian.com>
* backends/server/x86_64-arch.c
(server_ptrace_push_registers): Properly align the stack.
(server_ptrace_call_method_*): Likewise.
2006-06-01 Martin Baulig <martin@ximian.com>
* backends/server/server.h
(ServerCommandError): Add `COMMAND_ERROR_INTERNAL_ERROR'.
* classes/TargetException.cs
(TargetError): Added `InternalError'.
2006-05-31 Martin Baulig <martin@ximian.com>
* classes/Debugger.cs: Added error checking.
2006-05-31 Martin Baulig <martin@ximian.com>
* interfaces/ITargetNotification.cs
(TargetState): Don't use all-capital letters.
2006-05-31 Martin Baulig <martin@ximian.com>
* classes/Thread.cs
(Thread): Merge `Finish' and `FinishNative'.
* backends/ThreadServant.cs
(ThreadServant): Merge `Finish' and `FinishNative'.
2006-05-31 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(SteppingCommand.DoStep): Return a `CommandResult'.
* frontend/Interpreter.cs
(Interpreter.Wait): Added overloaded version which takes a
`CommandResult'; check for exceptions.
* backends/SingleSteppingEngine.cs
(CommandResult): Moved to classes/Thread.cs and made public.
* classes/Thread.cs (CommandResult): Moved here from
SingleSteppingEngine.cs and made public.
(Thread.StepInstruction): Return a `CommandResult'.
(Thread.StepNativeInstruction): Likewise.
(Thread.NextInstruction): Likewise.
(Thread.StepLine): Likewise.
(Thread.NextLine): Likewise.
(Thread.Finish): Likewise.
(Thread.FinishNative): Likewise.
(Thread.Continue): Likewise.
(Thread.FinishNative): Likewise.
2006-05-30 Martin Baulig <martin@ximian.com>
* backends/server/x86_64-arch.c
(server_ptrace_push_registers): Don't corrup the red zone.
(server_ptrace_call_method_*): Likewise.
2006-05-24 Martin Baulig <martin@ximian.com>
* doc/GC-issues.txt: Added document describing the interface
between the debugger and the GC.
2006-05-24 Martin Baulig <martin@ximian.com>
Released version 0.20 "Bruxelles" of the Mono Debugger :-)
2006-05-24 Martin Baulig <martin@ximian.com>
* backends/server/library.c
(mono_debugger_server_set_notification): This is no longer a
"static" method - different processes may have different
notification addresses, so we need to make this per-target.
* backends/server/x86-ptrace.c
(InferiorHandle): Added `guint64 nofification_address'; replaces
the static variable in x86_64-arch.c/i386-arch.c.
(server_ptrace_set_notification): Moved here from x86_64-arch.c.
* backends/Inferior.cs
(Inferior.SetNotificationAddress): New internal method; call
mono_debugger_server_set_notification().
* backends/MonoThreadManager.cs
(MonoThreadManager.ThreadCreated): Call SetNotificationAddress()
on each newly created inferior.
2006-05-24 Martin Baulig <martin@ximian.com>
* arch/bfdglue.c
(bfd_glue_get_section_size): Added `raw_size' argument.
(bfd_glue_get_section_contents): Take a pre-alloced buffer as
argument rather than allocating it here.
2006-05-24 Martin Baulig <martin@ximian.com>
* backends/ProcessServant.cs
(ProcessServant.Kill): Don't call Dispose().
* backends/server/x86-linux-ptrace.c
(server_ptrace_initialize_process): Don't use PTRACE_O_TRACEEXIT;
we don't need this.
2006-05-24 Martin Baulig <martin@ximian.com>
* backends/MonoThreadManager.cs
(MonoThreadManager.HandleChildEvent): Clear the `csharp_language' on
`NofitifactionType.FinalizeManagedCode'.
2006-05-24 Martin Baulig <martin@ximian.com>
* configure.in: Check whether the Mono we're using is recent enough.
2006-05-24 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(BreakCommand.DoResolve): If our base class'es DoResolve() failed,
try resolving the expression as an address.
* frontend/Interpreter.cs
(Interpreter.InsertBreakpoint): Added overloaded version which
takes a `TargetAddress'.
* classes/Process.cs
(Process.InsertBreakpoint): Added overloaded version which takes a
`TargetAddress'.
2006-05-24 Martin Baulig <martin@ximian.com>
* backends/server/server.h
(ServerStatusMessageType): Added `MESSAGE_CHILD_CALLED_EXIT'.
* backends/server/x86-ptrace.c
(server_ptrace_dispatch_event): Use `MESSAGE_CHILD_CALLED_EXIT'
for `PTRACE_EVENT_EXIT'.
2006-05-23 Martin Baulig <martin@ximian.com>
* backends/Inferior.cs
(Inferior.PushRegisters): New public method.
(Inferior.PopRegisters): New public method.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.AcquireThreadLock): Call
inferior.PushRegisters() to push all registers onto the stack so
the GC will see them.
(SingleSteppingEngine.ReleaseThreadLock): Call
inferior.PopRegisters() to remove them from the stack again.
* backends/server/x86-linux-ptrace.c
(server_ptrace_initialize_process): Add `PTRACE_O_TRACEEXIT'.
* backends/server/x86_64-arch.c
(server_ptrace_push_registers): New method.
(server_ptrace_pop_registers): New method.
* backends/server/i386-arch.c
(server_ptrace_push_registers): New method.
(server_ptrace_pop_registers): New method.
* backends/server/library.c
(mono_debugger_server_push_registers): New public method.
(mono_debugger_server_pop_registers): New public method.
2006-05-20 Martin Baulig <martin@ximian.com>
* arch/DwarfReader.cs
(DwarfReader.DwarfTargetVariable.GetLocation): Add support for
location lists.
2006-05-20 Martin Baulig <martin@ximian.com>
* arch/DwarfFrameReader.cs: More 64-bit updates.
2006-05-20 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(SourceCommand.DoResolve): Also lookup native methods.
(BreakCommand): Add `-global' argument as a shortcut for
`-group global'.
2006-05-17 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.InsertHardwareWatchPoint): New public method.
* frontend/Command.cs
(WatchCommand): New command.
* classes/Breakpoint.cs
(BreakpointType): New public enum.
(Breakpoint.Type): New public property.
* classes/Process.cs
(Process.InsertHardwareWatchPoint): New public method.
* backends/ProcessServant.cs
(ProcessServant.InsertHardwareWatchPoint): New public method.
2006-05-17 Martin Baulig <martin@ximian.com>
* backends/Inferior.cs
(Inferior.HardwareBreakpointType): New internal enum.
(Inferior.InsertHardwareWatchPoint): New public method.
* backends/server/x86-linux-ptrace.c
(_server_ptrace_set_dr): Use `guint64' for the `value' arg.
(_server_ptrace_get_dr): Likewise.
(server_ptrace_get_application): Fix compiler warnings.
* backends/server/x86-arch.h
(x86_arch_remove_hardware_breakpoints): New public function.
* backends/server/x86_64-arch.c
(ArchInfo): Use `guint64' for `dr_control' and `dr_status'.
* backends/server/x86-ptrace.cs
(server_ptrace_dispatch_event): Remove all hardware breakpoints if
we stopped the first time.
* backends/server/server.h
(mono_debugger_server_insert_hw_breakpoint): Added `guint32 type'
argument which is a `HardwareBreakpointType'.
* backends/server/breakpoints.h
(HardwareBreakpointType): New enum typedef.
(BreakpointInfo): Added `HardwareBreakpointType type' field to
support hardware watchpoints.
2006-05-15 Martin Baulig <martin@ximian.com>
* classes/SourceLocation.cs
(SourceLocation.HasLine): New public property.
* frontend/Command.cs
(ListCommand.DoExecute): Only display the whole method if we
didn't specify a line.
2006-05-15 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(SetCommand.SetEnvironmentCommand): Added "set env" command to set
environment variables.
* classes/DebuggerSession.cs
(DebuggerOptions.UserEnvironment): New public property.
(DebuggerOptions.SetEnvironment): New public method.
* backends/ProcessStart.cs
(ProcessStart.UserEnvironment): Removed; retrieve it from the
`DebuggerOptions'.
2006-05-12 Martin Baulig <martin@ximian.com>
* backends/server/x86-linux-ptrace.c
(server_ptrace_global_wait): Restart the waiting on `stop_requested'.
(server_ptrace_stop_and_wait): Fix a race condition;
server_ptrace_global_wait() is now automatically restarted; also
return the SIGSTOP which we expect.
* backends/ThreadManager.cs
(ThreadManager.RequestWait): Make this private and protect against
being called multiple times; use RequestWait() everywhere instead
of setting the `wait_event' directly to avoid race conditions.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.child_breakpoint): Call `bpt.CheckBreakpointHit()'
directly rather than using an async handler.
(SingleSteppingEngine.AcquireThreadLock): Don't call
`manager.RequestWait()'.
2006-05-12 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(OperationFinish.DoExecte): Use `do_next_native()', not
`do_step_native().
2006-05-12 Martin Baulig <martin@ximian.com>
* NEWS: Update: we need the latest Mono from SVN; just realized
that 1.1.15 is too old and does not work.
2006-05-12 Martin Baulig <martin@ximian.com>
* frontend/Command.cs (FileCommand): Added error checking.
(SetCommand.SetArgsCommand): Added `set args' command.
(SetCommand.DoResolve): Properly handle the subcommands.
* backends/ProcessStart.cs
(ProcessStart.cs): `Options.InferiorArgs' no longer contains the
target application; use `Options.File' for that.
2006-05-12 Martin Baulig <martin@ximian.com>
* configure.in: Bump version number to 0.20.
* NEWS: Updated NEWS.
2006-05-11 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs
(PointerDereferenceExpression): Allow dereferencing arbitrary
pointer expressions.
2006-05-11 Martin Baulig <martin@ximian.com>
* backends/ThreadManager.cs
(ThreadManager.WaitTimeout): Increase to 5 seconds.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.OnThreadExited): Use `TargetExited' and not
`TargetSignaled' if we were previously Kill()ed.
* backends/MonoThreadManager.cs
(MonoThreadManager.HandleChildEvent): Kill the target on
`NotificationType.MainExited'.
2006-05-11 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.Start): Properly handle errors.
(Interpreter.Attach): Likewise.
(Interpreter.OpenCoreFile): Likewise.
* frontend/Main.cs
(CommandLineInterpreter.RunMainLoop): Properly handle errors.
2006-05-11 Martin Baulig <martin@ximian.com>
* backends/server/remoting.[ch]: Removed.
2006-05-11 Martin Baulig <martin@ximian.com>
* arch/Architecture.cs
(Architecture.AdjustReturnAddress): New protected method; adjust
the return address, so we report the line of the call and not the
return address in stack traces.
(Architecture.CreateFrame): Call AdjustReturnAddress().
* test/testsuite/TestException.cs: Added test case for it.
2006-05-10 Martin Baulig <martin@ximian.com>
* classes/DebuggerMarshalByRefObject.cs
(DebuggerMarshalByRefObject): New public class; we now use this
everywhere instead of `MarshalByRefObject'.
(DebuggerMarshalByRefObject.InitializeLifeTimeService): Override
this and return null.
2006-05-10 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs (BinaryOperator): Make this work again.
* frontend/CSharpExpressionParser.jay: Add support for binary
operators.
2006-05-10 Martin Baulig <martin@ximian.com>
* classes/DebuggerSession.cs
(DebuggerOptions.JitArguments): New public field.
* frontend/Main.cs: Add `-jit-arg' command line argument to pass
additional arguments to the inferior `mono'.
2006-05-10 Martin Baulig <martin@ximian.com>
* backends/server/x86_64-arch.c: Use proper alignment when calling
methods.
2006-05-09 Martin Baulig <martin@ximian.com>
The big method lookup cleanup :-)
* frontend/Expression.cs (LocationType): Added `Constructor'.
(Expression.EvaluateSource): Removed.
(Expression.DoEvaluateSource): Removed.
(Expression.ResolveMethod): Added a `LocationType' argument and
return a `MethodExpression'.
(Expression.DoResolveMethod): Likewise; return null by default.
(SimpleNameExpression.DoResolveMethod): Handle all the different
kinds of method lookups here.
(MethodExpression): New public abstract class.
(MethodExpression.EvaluateSource): New public abstract method; use
this instead of `Expression.EvaluateSource()'.
(MethodGroupExpression): Derive from `MethodExpression'.
(MethodGroupExpression.DoResolveMethod): Add support for the
different LocationType's here.
(InvocationExpression): Derive from `MethodExpression'.
* frontend/Command.cs
(SourceCommand.Ctor): Added `-ctor' argument to lookup ctors.
(SourceCommand.DoResolve): We now use `Expression.ResolveMethod()'
to get a `MethodExpression' and then call EvaluateSource() on it.
* test/src/testsuite/TestMethodLookup.cs: New test. This test is
really huge and should cover all the cases.
2006-05-05 Martin Baulig <martin@ximian.com>
* languages/TargetFunctionType.cs
(TargetFunctionType.IsConstructor): New public property.
* frontend/Expression.cs
(InvocationExpression.DoInvoke): Make invoking ctors work.
2006-05-05 Martin Baulig <martin@ximian.com>
* languages/TargetFunctionType.cs
(TargetFunctionType.IsStatic): New public property.
* frontend/Expression.cs
(InvocationExpression.DoResolve): Use `method_expr.ResolveMethod()'
since we may be called from SourceLocation.DoResolve()'.
(InvocationExpression.DoInvoke): Don't allow invoking instance
methods with a type reference.
2006-05-05 Martin Baulig <martin@ximian.com>
* classes/SourceLocation.cs
(SourceLocation.HasMethod): New public property.
(SourceLocation.Function): New public property.
(SourceLocation.ctor): Add a ctor taking a `SourceFile' and a
line number.
* classes/SourceInfo.cs
(SourceInfo.FindLine): Allow line numbers outside methods; return
a `SourceLocation' without a method in this case.
* frontend/Command.cs
(SourceCommand.DoResolve): If the argument is now a valid number,
try parsing it as an expression and create a function location.
(SourceCommand.EvaluateMethod): Removed.
(BreakCommand.DoExecute): If we're a function breakpoint,
`Location.HasFunction' is true.
2006-05-05 Martin Baulig <martin@ximian.com>
* frontend/ScriptingContext.cs
(ScriptingContext.ListSourceCode): Removed; moved the
functionality into `ListCommand'.
* frontend/Command.cs
(SourceCommand.Location): New public property.
(SourceCommand.DoResolve): Make sure we have a valid `Location'.
(ListCommand.DoExecute): Moved the functionality here.
2006-05-03 Martin Baulig <martin@ximian.com>
* classes/Debugger.cs
(Debugger.Kill): Wait for the target to exit before returning.
2006-05-03 Martin Baulig <martin@ximian.com>
* backends/MonoThreadManager.cs
(MonoThreadManager.HandleChildEvent): Fix a race condition: call
`inferior.InitializeModules ()' before resuming the target.
2006-05-03 Martin Baulig <martin@ximian.com>
* frontend/Command.cs (DebuggerCommand.Execute): Always resolve
the command before executing it; also when repeating it.
2006-05-03 Martin Baulig <martin@ximian.com>
* backends/Inferior.cs (Inferior.Kill): Check errors.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.OnThreadExited): New internal method; we're
called from the ThreadManager when the target exited.
(SingleSteppingEngine.Kill): Correctly implement this.
(SingleSteppingEngine.Dispose): Correctly implement this.
(SingleSteppingEngine.DoDispose): Don't call `inferior.Kill ()'.
* backends/ProcessServant.cs
(ProcessServant.OnThreadExitedEvent): Call OnProcessExited() if
the last thread exited.
(ProcessServant.KillThread): Removed.
* backends/DebuggerServant.cs
(DebuggerServant.OnProcessExitedEvent): Call OnTargetExitedEvent()
if the last process exited.
* backends/server/x86-ptrace.c
(server_ptrace_kill): Don't send a SIGKILL to the target; just use
`ptrace (PTRACE_KILL)'.
2006-05-02 Martin Baulig <martin@ximian.com>
* test/testsuite/NUnit.cs
(DebuggerEvent): New public class.
(DebuggerEventType): New public enum.
(NUnitInterpreter): New public class; derive from `Interpreter'.
(TestSuite): Rewrite the testsuite: instead of parsing the
debugger output we're now listening directly for the events.
2006-05-02 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(Command.Execute): Changed return type from `void' to `object'.
(Command.DoExecute): Likewise.
* frontend/ScriptingContext.cs
(ScriptingContext.Error): Removed; throw a `ScriptingException'
instead.
2006-05-02 Martin Baulig <martin@ximian.com>
* backends/DebuggerServant.cs
(DebuggerServant.OnThreadCreatedEvent): Don't send the event for
daemon threads.
(DebuggerServant.OnThreadExitedEvent): Likewise.
(DebuggerServant.OnTargetEvent): Don't send a `TargetExited' or
`TargetSignaled' event for daemon threads.
2006-04-26 Martin Baulig <martin@ximian.com>
* classes/Report.cs (Report.ReportWriter): Make this field public
and don't initialize it.
* backends/DebuggerServant.cs
(DebuggerServant.ctor): Added `ReportWriter' argument and assign
it to `Report.ReportWriter'.
2006-04-26 Martin Baulig <martin@ximian.com>
* arch/bfdglue.h (BfdGlueSection): Removed.
* arch/bfdglue.c (bfd_glue_get_sections): Removed.
(bfd_glue_get_first_section): New function.
(bfd_glue_get_next_section): New function.
(bfd_glue_get_section_name): New function.
(bfd_glue_get_section_vma): New function.
(bfd_glue_get_section_size): New function.
(bfd_glue_get_section_flags): New function.
* arch/Bfd.cs (Bfd.InternalSection): Removed.
(Bfd.Section): Operate directly on the `asection *' pointer.
2006-04-25 Martin Baulig <martin@ximian.com>
* classes/Process.cs
(Process.SaveSession, Process.LoadSession): Moved the session
handling into the `ProcessServant'.
* classes/Debugger.cs
(Debugger.ctor): Create the `DebuggerServant' in another appdomain.
2006-04-25 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.StartThread): Added `do_attach' argument.
(SingleSteppingEngine.GetThreadID): Removed.
(SingleSteppingEngine.Attached): Removed.
(SingleSteppingEngine.Attach): Removed.
(SingleSteppingEngine.Detach): When detaching from a managed
application, start an `OperationDetach'.
(OperationDetach): New operation.
(OperationGetThreadId): Renamed into `OperationGetCurrentThread'.
* backends/ThreadServant.cs
(ThreadServant.DetachThread): New internal abstract method.
2006-04-25 Martin Baulig <martin@ximian.com>
* backends/BreakpointManager.cs
(BreakpointManager.RemoveAllBreakpoints): New public method.
2006-04-25 Martin Baulig <martin@ximian.com>
* backends/MonoThreadManager.cs
(MonoMetadataInfo): New internal struct; splitted out from
`MonoBuiltinTypeInfo' in MonoLanguageBackend.cs.
2006-04-25 Martin Baulig <martin@ximian.com>
* arch/Architecture.cs
(Architecture.IsSyscallInstruction): New public abstract method.
2006-04-20 Martin Baulig <martin@ximian.com>
* backends/Inferior.cs
(Inferior.Attach): Removed the `is_main' argument.
* backends/server/server.h
(mono_debugger_server_attach): Removed the `is_main' argument.
2006-04-20 Martin Baulig <martin@ximian.com>
* backends/ProcessServant.cs
(ProcessServant.MainThread): Changed type into `ThreadServant'.
(ProcessServant.Initialize): Major code cleanup in here; call
Inferior.InitializeProcess() if we're called the first time.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.ctor): A SingleSteppingEngine is now created
with an operation - it's either executing `OperationStart' or
`OperationRun'; moved the `reached main' magic into `OperationStart'.
(SingleSteppingEngine.OperationStart): New operation.
* backends/MonoThreadManager.cs
(MonoThreadManager.HandleChildEvent): No longer read the TID from
the notification on `ThreadCreated' and `ThreadExited'; always use
the SingleSteppingEngine which received the notification.
* backends/server/Inferior.cs
(Inferior.InitializeProcess): New method; this needs to be called
the first time the target is stopped.
(Inferior.Initialize): Renamed into InitializeThread().
(Inferior.GlobalStop): Removed.
(Inferior.TID): Removed.
2006-04-20 Martin Baulig <martin@ximian.com>
* backends/server/x86-linux-ptrace.c
(_server_ptrace_setup_inferior): Don't attempt to read the
registers and also don't call do_wait(). We may now be called
before the target is stopped.
(_server_ptrace_setup_thread_manager): Renamed into
server_ptrace_initialize_process(); we're now called from
ProcessServant.Initialize() after the managed `ThreadManager'
received the first event.
(server_ptrace_global_wait): `first_status' and `first_ret' is
gone; don't do anything special if we're called the first time.
* x86-ptrace.c (InferiorHandle): Removed `tid'; no longer attempt
to compute the TID here.
* x86-arch.h (x86_arch_get_tid): Removed.
* backends/server/server.h
(mono_debugger_server_initialize): Renamed into
mono_debugger_server_initialize_process() and removed the `tid'
argument.
(mono_debugger_server_initialize_process): New function.
(mono_debugger_server_attach): Removed the `tid' argument.
(mono_debugger_server_global_stop): Removed.
* backends/server/x86-ptrace.h: New file; replaces i386-ptrace.h
and x86_64-ptrace.h.
2006-04-19 Martin Baulig <martin@ximian.com>
* backends/ThreadServant.cs: New file.
(ThreadServant): New internal abstract class.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine): Derive from `ThreadServant'.
* arch/CoreFile.cs
(CoreFile.CoreFileThread): Derive from `ThreadServant'.
2006-04-19 Martin Baulig <martin@ximian.com>
Split `Process' into `Process' and `ProcessServant'.
* backends/ProcessServant.cs: New file.
(ProcessServant): New internal class.
2006-04-19 Martin Baulig <martin@ximian.com>
Split `Debugger' into `Debugger' and `DebuggerServant'.
* backends/DebuggerServant.cs: New file.
(DebuggerServant): New internal class.
2006-04-19 Martin Baulig <martin@ximian.com>
* test/testsuite/testnativeattach.cs: New test.
2006-04-19 Martin Baulig <martin@ximian.com>
* backends/ThreadManager.cs
(ThreadManager.start_wait_thread): Catch `ThreadAbortException'
and reset the abort. See the comment in the source code.
2006-04-18 Martin Baulig <martin@ximian.com>
* frontend/Command.cs (ProcessCommand): New public abstract class.
(DetachCommand): New command. Note that we can only detach from a
process if we previously attached to it.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.Kill): Send a SIGKILL to the target.
(SingleSteppingEngine.Dispose): Call `inferior.Kill()' if we still
have an inferior.
* classes/TargetException.cs
(TargetError.CannotDetach): New error.
* classes/Debugger.cs
(Debugger.Detach): New public method.
* classes/Process.cs
(Process.Detach): New public method.
* classes/Thread.cs
(Thread.Detach): New public method.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/server/x86-ptrace.cs
(x86_ptrace_kill): Send a SIGKILL to the process before using
`ptrace (PTRACE_KILL)' so we actually kill it.
* backends/ThreadManager.cs
(ThreadManager.Dispose): Call `wait_thread.Abort()' prior to
`wait_thread.Join()'.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/Debugger.cs: Moved to ../classes/
* backends/Process.cs: Moved to ../classes/
* backends/Thread.cs: Moved to ../classes/
2006-04-18 Martin Baulig <martin@ximian.com>
* classes/SymbolTableManager.cs: Moved to ../backends/
* classes/ModuleManager.cs: Moved to ../backends/
* backends/Process.cs
(Process.ModuleManager): Make this internal.
(Process.SymbolTableManager): Make this internal.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/classes/*TargetLocation.cs: Moved to languages/
* backends/classes/MonoVariableLocation: Moved to languages/mono/.
* backends/classes/: Removed.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/TargetReader.cs: Moved here from backends/classes/.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/Inferior.cs
(Inferior.GetFileContents): New public static method; obsoletes
the `Utils' class form backends/classes/Utils.cs.
* backends/classes/Utils.cs: Removed.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/EventQueue.cs: New file; merged classes/Threading.cs
and backends/classes/EventQueue.cs here.
* classes/ObjectContainer.cs: Removed.
2006-04-18 Martin Baulig <martin@ximian.com>
* classes/BreakpointHandle.cs: Moved into ../backends/.
* backends/BreakpointHandle.cs: Moved here from ../classes/.
2006-04-18 Martin Baulig <martin@ximian.com>
* arch/Architecture.cs (Architecture): Make this internal.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/TargetMemoryAccess.cs
(TargetMemoryAccess.Architecture): Make this internal.
* backends/Thread.cs
(Thread.PrintRegisters): New public method.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ISourceBuffer.cs: Removed.
(ISourceBuffer): Removed this interface; `SourceBuffer' is the
only class implementing it.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ITargetMemoryAccess.cs: Removed.
(ITargetMemoryAccess): Removed.
* backends/TargetMemoryAccess.cs: New file.
(TargetMemoryAccess): New public abstract class.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ITargetMemoryAccess.cs
(ITargetInfo): Removed.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ITargetMemoryAccess.cs
(ITargetMemoryAccess): Removed all the writing methods.
2006-04-18 Martin Baulig <martin@ximian.com>
* classes/TargetBinaryAccess.cs
(TargetInfo): Moved here from ../backends/classes/TargetReader.cs
and made it public.
* backends/TargetAccess.cs
(TargetAccess.TargetInfo): Return a `TargetInfo'.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ITargetMemoryAccess.cs
(ITargetMemoryInfo): Removed.
* backends/classes/TargetReader.cs
(TargetMemoryInfo): Removed.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/Thread.cs
(Thread.TargetMemoryAccess): Removed; just use `Thread' directly.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ITargetMemoryAccess.cs
(ITargetMemoryAccess): Only implement `ITargetInfo'.
(ITargetMemoryAccess.TargetMemoryInfo): Removed.
(ITargetMemoryAccess.Architecture): New property.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ITargetMemoryAccess.cs
(ITargetMemoryInfo.AddressDomain): Moved into `ITargetInfo'.
(ITargetInfo.AddressDomain): Moved here from `ITargetMemoryInfo'.
* backends/classes/TargetReader.cs
(TargetReader): Don't implement `ITargetMemoryInfo'.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/Inferior.cs
(Inferior.GetTargetInfo): New public static method.
* arch/CoreFile.cs: Don't create an Inferior here and make core
files work again.
2006-04-18 Martin Baulig <martin@ximian.com>
* backends/ThreadBase.cs: Renamed into TargetAccess.cs.
(ThreadBase): Renamed into `TargetAccess'.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ITargetMemoryAccess.cs
(ITargetMemoryInfo): Make this interface internal.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ITargetMemoryAccess.cs
(ITargetMemoryAccess): Make this interface internal.
2006-04-18 Martin Baulig <martin@ximian.com>
* classes/AddressDomain.cs
(AddressDomain): Make the .ctor internal.
2006-04-18 Martin Baulig <martin@ximian.com>
* interfaces/ITargetMemoryAccess.cs
(ITargetMemoryReader): Removed this interface; `TargetReader' is
the only class implementing it.
2006-04-18 Martin Baulig <martin@ximian.com>
* classes/ExceptionCatchPoint.cs
(ExceptionCatchPoint): Make this class sealed and rename
`CheckBreakpointHit' into `CheckException'.
* classes/Event.cs
(Event.CheckBreakpointHit): Moved into the `Breakpoint' class.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.child_breakpoint): Run
`breakpoint.CheckBreakpointHit()' asynchronously.
2006-04-17 Martin Baulig <martin@ximian.com>
Bump version number to 0.14 and require Mono >= 1.1.15.
2006-04-17 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs: Cosmetic cleanups in the
process-related messages.
2006-04-17 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.AcquireGlobalThreadLock): Check the
`stop_event' and don't do anything if we just died.
(SingleSteppingEngine.Start): Set `main_method_stackptr' to the
current stack pointer.
* backends/server/x86_64-arch.c
(server_ptrace_get_frame): Call x86_arch_get_registers() first.
* backends/server/i386-arch.c
(server_ptrace_get_frame): Call x86_arch_get_registers() first.
2006-04-13 Martin Baulig <martin@ximian.com>
* backends/ProcessStart.cs
(ProcessStart.SetupEnvironment): Add a `MONO_INSIDE_MDB'
environment variable; this is required if the target fork()s
another mono process.
2006-04-13 Martin Baulig <martin@ximian.com>
* languages/mono/MonoLanguageBackend.cs: Use the new
`MonoDefaults' offsets.
2006-04-13 Martin Baulig <martin@ximian.com>
* backends/Process.cs
(Process.ChildExecd): Don't create a new process here.
2006-04-12 Martin Baulig <martin@ximian.com>
* test/testsuite/testnativeexec.cs: New test.
2006-04-11 Martin Baulig <martin@ximian.com>
* test/testsuite/TestRestart.cs: New test.
2006-04-11 Martin Baulig <martin@ximian.com>
* backends/Debugger.cs
(Debugger.ProcessReachedMainEvent): Removed.
* classes/DebuggerSession.cs
(DebuggerSession): We're not a static class anymore.
* frontend/Interpreter.cs: Save the session on exit and load it
when we restart.
2006-04-11 Martin Baulig <martin@ximian.com>
* classes/SimpleBreakpoint.cs: Removed.
* classes/Breakpoint.cs (Breakpoint): Don't make this abstract.
* backends/Process.cs
(Process.InsertBreakpoint): Create and return a new `Breakpoint'.
(Process.InsertExceptionCheckPoint): Likewise.
2006-04-11 Martin Baulig <martin@ximian.com>
* classes/Event.cs (Event): New public abstract class. This
replaces the old `EventHandle' class.
* classes/Breakpoint.cs (Breakpoint): Derive from `Event'.
* classes/ExceptionCatchPoint.cs
(ExceptionCatchPoint): New public class; derives from `Event'.
* classes/EventHandle.cs: Removed.
* classes/CatchpointHandle.cs: Removed.
* classes/SourceLocation.cs
(SourceLocation): We can now also operate on a
`TargetFunctionType'.
(SourceLocation.HasFunction): New public property.
(SourceLocation.InsertBreakpoint): New internal method.
* classes/BreakpointHandle.cs
(BreakpointHandle): This is now private.
2006-04-11 Martin Baulig <martin@ximian.com>
* classes/BreakpointHandle.cs
(BreakpointHandle): Make this internal.
* backends/Process.cs
(Process.InsertBreakpoint): Don't take a `Thread' argument and
don't enable the breakpoint.
* frontend/Interpreter.cs
(Interpreter.InsertBreakpoint): Process.InsertBreakpoint() no
longer enables the breakpoint; do this here.
2006-04-11 Martin Baulig <martin@ximian.com>
* classes/Module.cs (ILoadHandler): New internal interface.
(SymbolFile.RegisterLoadHandler, Module.RegisterLoadHandler):
Return an `ILoadHandler', not an `IDisposable'.
2006-04-11 Martin Baulig <martin@ximian.com>
* classes/SourceLocation.cs
(SourceLocation.SourceBuffer): Removed.
2006-04-11 Martin Baulig <martin@ximian.com>
* backends/Process.cs
(Process.SaveSession, LoadSession): New public methods; moved the
session handling code here from `DebuggerSession'.
(Process.Session): Removed.
* classes/DebuggerSession.cs
(DebuggerSession): Make this a static class for the moment; all
the session handling code is now in `Process'.
2006-04-11 Martin Baulig <martin@ximian.com>
* classes/ThreadGroup.cs
(ThreadGroup.Global, ThreadGroup.System): New public static
properties; the "global" and "system" groups are now static and
immutable.
* backends/BreakpointManager.cs
(BreakpointManager.RemoveBreakpointsAfterFork): Renamed into
InitializeAfterFork().
2006-04-11 Martin Baulig <martin@ximian.com>
* classes/Breakpoint.cs (Breakpoint.Clone): Removed.
* backends/BreakpointManager.cs
(BreakpointManager.RemoveBreakpointsAfterFork): Create a new
`BreakpointHandle' for all global user-defined breakpoints.
2006-04-11 Martin Baulig <martin@ximian.com>
* backends/Process.cs (Process): Moved the breakpoint/event code
here from `DebuggerSession'.
* backends/DebuggerSession.cs (DebuggerSession): Moved the
breakpoint/event code into `Process'.
2006-04-10 Martin Baulig <martin@ximian.com>
* backends/BreakpointManager.cs
(BreakpointManager.RemoveBreakpointsAfterFork): Remove all
non-global breakpoints after a fork().
* backends/Inferior.cs
(Inferior.InitializeAfterFork): Call it here.
* frontend/Interpreter.cs
(Interpreter.GetThreadGroup): Default to `main', not `global'.
2006-04-10 Martin Baulig <martin@ximian.com>
* backends/ILanguageBackend.cs
(NotificationType): Added `ThreadExited'.
* backends/MonoThreadManager.cs
(MonoThreadManager.HandleChildEvent): If we receive a
`ThreadExited' notification, clear `engine.EndStackAddress'.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.ReleaseThreadLock): Resume the target if we
stopped it.
2006-04-10 Martin Baulig <martin@ximian.com>
* backends/server/x86-ptrace.c
(server_ptrace_dispatch_event): Clear `inferior->last_signal' if
we don't send a `MESSAGE_CHILD_STOPPED'.
2006-04-10 Martin Baulig <martin@ximian.com>
Released version 0.13 "Luxemburg" of the Mono Debugger :-)
2006-04-10 Martin Baulig <martin@ximian.com>
* backends/Debugger.cs
(Debugger.DebuggerSession): Moved into `Process'.
* backends/Process.cs
(Process.DebuggerSession): Moved here from `Debugger'.
* classes/DebuggerSession.cs
(DebuggerSession): Make this per-process, not per-debugger.
2006-04-09 Martin Baulig <martin@ximian.com>
* test/testsuite/testnativefork.cs: New test.
* test/src/testnativefork.c: Test case for the test.
2006-04-09 Martin Baulig <martin@ximian.com>
* backends/Threadmanager.cs
(ThreadManager.HandleChildEvent): Pass SIGCHLD to the target
without stopping it.
* backends/server/x86-ptrace.c
(server_ptrace_dispatch_event): Return a normal
MESSAGE_CHILD_STOPPED on SIGCHLD.
2006-04-07 Martin Baulig <martin@ximian.com>
* backends/server/x86-ptrace.c (server_ptrace_spawn): Set the
child's core-file limit to zero after forking.
2006-04-07 Martin Baulig <martin@ximian.com>
* backends/server/x86-ptrace.c
(io_thread): Fix a very old race condition: keep our data in a
separate `IOThreadData' structure since the inferior could have
been disposed.
2006-04-07 Martin Baulig <martin@ximian.com>
* test/: Clean up this directory a bit.
* test/mono-debugger.tests/: Removed.
* test/mdb.exp: Removed.
2006-04-06 Martin Baulig <martin@ximian.com>
* frontend/CL.cs (Engine.ctor): Take an `Interpreter' argument.
(Engine.Run): Moved the exception handling here.
* frontend/Command.cs
(Command.Execute): Changed return type to `void'; don't catch any
exceptions here.
(Command.Repeat): Changed return type to `void'.
(Command.Resolve): Don't catch any exceptions here.
2006-04-06 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter): Implement `IDisposable'.
2006-04-05 Martin Baulig <martin@ximian.com>
* wrapper/: Renamed to `build'.
2006-04-05 Martin Baulig <martin@ximian.com>
* frontend/Command.cs (DebuggerEngine.ctor): Register all the
commands here.
* frontend/Interpreter.cs (Interpreter): Make this a sealed class
and add a public .ctor.
* frontend/Main.cs (CommandLineInterpreter): Don't derive from
`Interpreter' anymore.
* frontend/ScriptingContext.cs
(ScriptingContext.PrintObject): Renamed into FormatObject().
(ScriptingContext.PrintType): Renamed into FormatType().
2006-04-05 Martin Baulig <martin@ximian.com>
* test/testsuite/: New directory. Started to migrate the
testsuite to NUnit.
* test/src/: New directory. The test sources will be moved here.
2006-04-04 Martin Baulig <martin@ximian.com>
* backends/server/x86-linux-ptrace.c
(_server_ptrace_setup_inferior): Check whether we're already
stopped before blocking on do_wait().
2006-04-04 Martin Baulig <martin@ximian.com>
* NEWS: Updated NEWS.
2006-04-04 Martin Baulig <martin@ximian.com>
* backends/Process.cs
(Process.AcquireGlobalThreadLock): Moved here from ThreadManager.
(Process.ReleaseGlobalThreadLock): Likewise.
2006-04-03 Martin Baulig <martin@ximian.com>
HEADS UP: The debugger no longer works with the stable Mono from
the 1.1.13 branch, sorry.
* configure.in: Require Mono >= 1.1.14.
2006-04-03 Martin Baulig <martin@ximian.com>
* backends/Debugger.cs
(Debugger.TargetOutputEvent): Moved here from `Thread'.
2006-04-03 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs: Inform the user about newly created and
exited processes.
2006-04-03 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.MainProcess): Removed.
(Interpreter.CurrentProcess): New public property.
* backends/Debugger.cs
(Debugger.TargetExitedEvent): New public event.
(Debugger.OnProcessExitedEvent): Kill all other processes if the
main process exited.
(Debugger.Kill): New public method.
2006-04-03 Martin Baulig <martin@ximian.com>
* backends/Process.cs
(Process.Initialize): Set `main_thread' and `main_engine' here.
* backends/Debugger.cs
(Debugger.Run): It's now safe to use `process.MainThread' on the
returned Process immediately.
2006-04-03 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.start_event): Removed.
2006-04-03 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs
(Interpreter.Threads): Removed; we don't keep a separate hash
table here anymore, but use `Process.Threads' instead.
(Interpreter.Processes): New public property.
* frontend/Command.cs
(Show.ShowProcessesCommand): Added `show processes' command.
2006-04-03 Martin Baulig <martin@ximian.com>
* backends/Process.cs
(Process.ID): New public property.
(Process.Threads): New public property.
(Process.TargetApplication): New public property.
(Process.CommandLineArguments): New public property.
2006-04-03 Martin Baulig <martin@ximian.com>
* classes/Breakpoint.cs (Breakpoint): Implement ICloneable.
(Breakpoint.Clone): New public method.
2006-04-03 Martin Baulig <martin@ximian.com>
* backends/server/breakpoints.c
(mono_debugger_breakpoint_manager_clone): New public function.
2006-04-02 Martin Baulig <martin@ximian.com>
* backends/server/breakpoints.h
(BreakpointInfo): Merge this with `X86BreakpointInfo'.
* backends/server/x86-arch.h
(X86BreakpointInfo): Merged into `BreakpointInfo'.
2006-04-02 Martin Baulig <martin@ximian.com>
* frontend/Interpreter.cs: Correctly dispose the `Debugger', so we
don't hang on exit.
2006-04-01 Martin Baulig <martin@ximian.com>
* backends/Process.cs: Implement follow-fork and follow-exec.
* backends/Debugger.cs
(Debugger.ProcessReachedMainEvent): New public event.
2006-04-01 Martin Baulig <martin@ximian.com>
* backends/server/x86-linux-ptrace.c
(_server_ptrace_setup_thread_manager): Add `PTRACE_O_TRACEFORK',
`PTRACE_O_TRACEVFORK' and `PTRACE_O_TRACEEXEC'.
* backends/server/server.h (ServerStatusMessageType): Added
`MESSAGE_CHILD_FORKED' and `MESSAGE_CHILD_EXECD'.
* backends/server/library.c
(mono_debugger_server_init_after_fork): New public function.
* backends/server/i386-arch.c
(do_disable, do_enable): Don't modify `breakpoint->info.enabled';
this is now done by our caller.
* backends/server/x86_64-arch.c
(do_disable, do_enable): Don't modify `breakpoint->info.enabled';
this is now done by our caller.
2006-04-01 Martin Baulig <martin@ximian.com>
* languages/native/NativeLanguage.cs
(NativeLanguage.StringType): Implemented.
* languages/native/NativePointerObject.cs
(NativePointerObject.Print): Check whether we're a string.
2006-04-01 Martin Baulig <martin@ximian.com>
* backends/ProcessStart.cs
(ProcessStart.SetupEnvironment): Set `MONO_SHARED_HOSTNAME=mdb'.
2006-03-29 Martin Baulig <martin@ximian.com>
* backends/Debugger.cs
(Debugger.InitializedEvent): Renamed to `ProcessCreatedEvent'.
(Debugger.TargetExitedEvent): Renamed to `ProcessExitedEvent'.
2006-03-29 Martin Baulig <martin@ximian.com>
* backends/remoting/: Removed.
2006-03-29 Martin Baulig <martin@ximian.com>
* backends/Debugger.cs (Debugger): Don't make this abstract and
added a public .ctor.
* backends/DebuggerSession.cs: Take a `Debugger' argument, not a
`DebuggerClient' one.
* backends/remoting/DebuggerClient.cs: Removed.
* backends/remoting/DebuggerServer.cs: Removed.
2006-03-29 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(DebuggerCommand.Execute): Don't create a new `ScriptingContext'
if we're repeating.
2006-03-28 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(DebuggerCommand.Execute): Create a new `ScriptingContext'.
(DebuggerCommand.Resolve): Call DoResolveBase() before
DoResolve().
(ThreadCommand.DoResolveBase): Set `context.CurrentThread' here.
(ThreadCommand.ResolveThread): Removed; use `CurrentThread' instead.
(ThreadCommand.CurrentThread): New public property.
(FrameCommand.DoResolveBase): Set `context.CurrentFrame' here.
(FrameCommand.ResolveFrame): Removed; use `CurrentFrame' instead.
(FrameCommand.CurrentFrame): New public property.
(UpCommand, DownCommand): We now use `backtrace.CurrentFrameIndex'.
2006-03-28 Martin Baulig <martin@ximian.com>
* classes/Backtrace.cs
(Backtrace.CurrentFrame): New public property.
(Backtrace.CurrentFrameIndex): Likewise.
* languages/Language.cs
(Language.Process): New public porperty.
2006-03-14 Martin Baulig <martin@ximian.com>
Released version 0.12 "Portland" of the Mono Debugger :-)
2006-03-14 Martin Baulig <martin@ximian.com>
* configure.in: Require Mono >= 1.1.13.
2006-03-13 Wade Berrier <wberrier@novell.com>
* arch/Makefile.am backends/remoting/Makefile.am backends/Makefile.am:
Update EXTRA_DIST to fix make dist and make distcheck
2006-03-04 Martin Baulig <martin@ximian.com>
* backends/MonoThreadManager.cs
(MonoThreadManager.Initialize): The notification function is not
dynamically allocated at runtime; we need to insert a breakpoint
on the `initialize' function in the `MONO_DEBUGGER_debugger_info'
vtable and read the notification address once we hit that bpt.
2006-02-28 Martin Baulig <martin@ximian.com>
* backends/TargetAccess.cs: Removed.
2006-02-28 Martin Baulig <martin@ximian.com>
* languages/*.cs: Use `Thread' everywhere instead of `TargetAccess'.
2006-02-28 Martin Baulig <martin@ximian.com>
* languages/Language.cs
(Language.CreateObject): Take a `Thread' argument, not a `TargetAccess'.
(Language.CreateInstance): Likewise.
(Language.CreateNullObject): Likewise.
* classes/Breakpoint.cs
(Breakpoint.CheckBreakpointHit): Take a `Thread' argument, not a
`TargetAccess'.
* classes/SimpleBreakpoint.cs
(BreakpointCheckHandler): Take a `Thread' argument, not a `TargetAccess'.
2006-02-28 Martin Baulig <martin@ximian.com>
* backends/TargetAccess.cs
(TargetAccess.DisassembleInstruction): Removed.
(TargetAccess.DisassembleMethod): Removed.
2006-02-28 Martin Baulig <martin@ximian.com>
* backends/TargetAccess.cs
(TargetAccess.InsertBreakpoint): Removed.
(TargetAccess.RemoveBreakpoint): Removed.
(TargetAccess.AddEventHandler): Removed.
(TargetAccess.RemoveEventHandler): Removed.
* backends/Debugger.cs
(Debugger.InsertBreakpoint): Removed.
(Debugger.InsertExceptionCatchpoint): Removed.
* backends/BreakpointHandle.cs
(BreakpointHandle): We now operate directly on the `Thread'
instead of the `TargetAccess'.
* classes/DebuggerSession.cs
(DebuggerSession.InsertBreakpoint): Take a `Thread' argument
instead of a `TargetAccess'.
(DebuggerSession.InsertExceptionCatchPoint): Likewise.
2006-02-28 Martin Baulig <martin@ximian.com>
* classes/Breakpoint.cs
(Breakpoint.GetNextBreakpointIndex): New internal static method.
* classes/EventHandle.cs (EventHandle..ctor): We now take an
`index' argument; we use `Breakpoint.Index' for breakpoints and
generate a new unique index for catchpoints.
2006-02-28 Martin Baulig <martin@ximian.com>
* backends/remoting/DebuggerContext.cs: Removed.
* backends/remoting/DebuggerManager.cs: Removed.
2006-02-28 Martin Baulig <martin@ximian.com>
* backends/TargetAccess.cs (ClientTargetAccess): Removed.
(TargetAccessHelper): Removed; we now share the same
`TargetAccess' between client and server.
* backends/remoting/DebuggerContext.cs
(DebuggerContext.GetTargetAccess): Removed.
2006-02-28 Martin Baulig <martin@ximian.com>
* backends/Process.cs
(Process): Manage thread groups here and not in `DebuggerManager'.
* backends/remoting/DebuggerManager.cs
(DebuggerManager): Moved all the thread groups related code into
the new `Process' class.
2006-02-28 Martin Baulig <martin@ximian.com>
* backends/Process.cs: New file.
(Process): New internal class. This class holds all the
information about one instance of a target application; ie. the
target application's threads, breakpoints, modules and symbol
tables.
* backends/ThreadManager.cs
(ThreadManager): The `ThreadManager' can now persist across
multiple invocations of a target application; all the state is in
the new `Process' class.
2006-02-24 Martin Baulig <martin@ximian.com>
The big `Process' -> `Thread' rename.
* backends/Process.cs: Renamed to Thread.cs
(Process): Renamed to Thread.
* frontend/Command.cs
(ProcessCommand): Renamed to `ThreadCommand'.
(ThreadCommand.ResolveProcess): Renamed to `ResolveThread'.
(FrameCommand.Process): Renamed the property to `Thread'.
(SelectProcessCommand): Renamed to `SelectThreadCommand'.
(BackgroundProcessCommand): Renamed to `SelectThreadCommand'.
(StopProcessCommand): Renamed to `StopThreadCommand'.
* frontend/Main.cs
(CommandLineInterpreter.SetupEngine): Renamed the "process"
command to "thread".
2006-02-24 Martin Baulig <martin@ximian.com>
* backends/Thread.cs: Renamed to ThreadBase.cs.
(Thread): Renamed to `ThreadBase'.
2006-02-23 Martin Baulig <martin@ximian.com>
* backends/Process.cs (Process): Derive from `Thread'.
2006-02-23 Martin Baulig <martin@ximian.com>
* backends/server/library.c
(mono_debugger_server_get_application): Return the currently
running application, its current working directory and command
line arguments; we use this after attaching to a process.
* backends/Inferior.cs (Inferior.GetApplication): New public
method to get the currently running application.
(Inferior.Attach): Call GetApplication() after attaching and setup
the `ProcessStart' accordingly.
* backends/ProcessStart.cs
(ProcessStart.SetupApplication): New public method; we use this
after attaching, so the user doesn't need to specify the application.
2006-02-23 Martin Baulig <martin@ximian.com>
Support multiple appdomains; this is only used when attaching to a
process which is running without `-O=shared'; the API to insert a
breakpoint in another appdomain is intentionally undocumented and
will change in near future.
* classes/SourceInfo.cs (SourceMethod.IsLoaded): Removed.
(SourceMethod.Method): Replaced the property with a new
GetMethod() method which takes a `domain' argument.
(SourceMethod.GetMethod): New public method.
(SourceMethod.Lookup): Removed.
* classes/DebuggerSession.cs
(DebuggerSession.InsertBreakpoint): Added `int domain' argument.
* classes/Module.cs
(SymbolFile.GetMethod): Added `int domain' argument.
* classes/SourceLocation.cs
(SourceLocation.GetAddress): Added `int domain' argument to
support multiple application domains.
* classes/BreakpointHandle.cs: Support multiple appdomains.
* languages/mono/MonoSymbolFile.cs: Support multiple appdomains.
2006-02-08 Martin Baulig <martin@ximian.com>
* backends/server/i386-arch.c: Use `guint32' instead of `long'
everywhere to correctly handle "negative" values.
2006-02-02 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(AttachCommand): New command.
(OpenCoreFileCommand): New command.
* frontend/Interpreter.cs
(Interpreter.Attach): New public method.
(Interpreter.OpenCoreFile): New public method.
2006-02-02 Martin Baulig <martin@ximian.com>
* backends/ProcessStart.cs
(ProcessStart.CoreFile): New public readonly field.
(ProcessStart.PID): New public readonly field
* backends/Debugger.cs
(Debugger.Attach): New public method.
(Debugger.OpenCoreFile): New public method.
2006-02-02 Martin Baulig <martin@ximian.com>
* backends/Thread.cs: New file.
(Mono.Debugger.Backends.Thread): New public abstract class.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine): Derive from `Thread'.
* arch/CoreFile.cs (CoreFile): Derive from `Thread'.
* backends/Process.cs (Process): Use a new `Thread thread' field
to perform non-stepping operations so we can talk both to a
`SingleSteppingEngine' and a `CoreFile'.
2006-02-02 Martin Baulig <martin@ximian.com>
* backends/MonoThreadManager.cs: The big API cleanup.
(MonoDebuggerInfo): Moved this here from MonoLanguageBackend.
* languages/mono/MonoLanguageBackend.cs
(MonoDebuggerInfo): Moved into MonoThreadManager.
2006-02-02 Martin Baulig <martin@ximian.com>
* arch/bfdglue.h (BfdGlueSection): Added `name'.
* arch/bfdglue.c (bfd_glue_core_file_failing_command): New
function.
* arch/Bfd.cs: Added core file support.
* arch/CoreFile.cs: New file.
(Mono.Debugger.Backends.CoreFile): New internal class.
* arch/Architecture.cs (Architecture.CreateFrame): Added
overloaded version taking a `Registers' argument.
2006-02-02 Martin Baulig <martin@ximian.com>
* backends/server/x86-linux-ptrace.c
(server_ptrace_get_threads): New function.
* backends/server/x86-ptrace.c
(server_ptrace_initialize): Renamed into `server_ptrace_create_inferior'.
(server_ptrace_attach): Renamed into `server_ptrace_initialize'
and created a new `server_ptrace_attach' to actually attach to a process.
Note that If we "attach" to a thread after receiving a PTRACE_EVENT_CLONE,
we are in fact already attached to that thread and don't need another
PT_ATTACH call.
* backends/server/library.c
(mono_debugger_server_initialize): Use this to "attach" to a new
thread of the application we're already debugging; this is used
after receiving a PTRACE_EVENT_CLONE.
(mono_debugger_server_attach): Use this to actually attach to a
new process.
(mono_debugger_server_get_threads): Get all threads of the process.
2006-01-25 Martin Baulig <martin@ximian.com>
* backends/MonoThreadManager.cs: Started to clean this up; removed
the `thread_hash'.
* backends/Inferior.cs (Inferior.TID): Make this a `long', not `int'.
* backends/Process.cs (Process.TID): Likewise.
* backends/server/library.c
(mono_debugger_server_attach): `tid' is now a `guint64 *'.
(mono_debugger_server_peek_word): `word' is now a `guint64 *'.
* backends/server/x86-arch.h (x86_arch_get_tid): Return a `guint64'.
2006-01-21 Martin Baulig <martin@ximian.com>
The debugger is now using the normal `mono' instead of its own
`mono-debugger-mini-wrapper' to execute managed code. You need to
use the latest SVN version of Mono from either HEAD or the
mono-1-1-13 branch for this.
* frontend/Main.cs: Added `-mono' command line argument to
specify the `mono' which should be used to execute managed code.
* wrapper/Makefile.am: The `mono-debugger-mini-wrapper' is gone.
* wrapper/wrapper.c: Removed.
* wrapper/mono-debugger-jit-wrapper.h: Removed.
2006-01-21 Martin Baulig <martin@ximian.com>
* wrapper/wrapper.c, thread-manager.c: Merge wrapper.c and
thread-manager.c into wrapper.c.
* wrapper/thread-manager.c: Removed.
* wrapper/icall.c: Removed.
2006-01-19 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.do_continue): Only insert the temporary
breakpoint if we're not stepping over a breakpoint; otherwise
OperationStepOverBreakpoint takes care of that.
* tests/mono-debugger.tests/TestBreakpoint.exp: Added some more
test cases; this also addresses the underlying problem of #77056.
2006-01-19 Martin Baulig <martin@ximian.com>
Fix #77056.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.ProcessChildEvent): Don't remove the
temporary breakpoint here unless we actually hit it.
(SingleSteppingEngine.step_over_breakpoint): The `trampoline'
argument is either null or the same than `until'; so change its
type into a `bool'.
(Operation.ResumeOperation): New protected virtual method; we're
called if the operation got interrupted by a non-breaking
breakpoint and we need to resume it.
* backends/server/x86_64-arch.cx
(86_arch_get_registers): Also read `DR_STATUS' here to make
hardware breakpoints actually work.
2006-01-05 Hans Kratz <kratz@omnicore.com>
* backends/ProcessStart.cs: Search for the for the wrapper in
the directory where mscorlib.dll is located instead. This is
used so other clients can work (X-Develop for example).
2005-12-21 Wade Berrier <wberrier@novell.com>
* wrapper/mdb.in: Modify wrapper to match more closly the wrappers in mono
2005-12-15 Martin Baulig <martin@ximian.com>
Released version 0.11 "Guam" of the Mono Debugger :-)
2005-12-14 Martin Baulig <martin@ximian.com>
* wrapper/Mono.Debugger.Cecil.dll: Added this to SVN.
* wrapper/Makefile.am: Don't build Mono.Debugger.Cecil.dll.
2005-12-14 Martin Baulig <martin@ximian.com>
* configure.in: Require Mono 1.1.11.
2005-12-14 Martin Baulig <martin@ximian.com>
* backends/remoting/DebuggerClient.cs
(DebuggerClient.IsRemote): Use another appdomain instead of
another process.
2005-12-11 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs
(TypeExpr): New public abstract base class for `TypeExpression'.
(PointerExpression): New public class.
(CastExpression.DoEvaluateObject): Allow casting from a pointer
expression of from a non-typesafe pointer to a native pointer.
* frontend/CSharpExpressionParser.jay
(variable_or_type_name): Add `NativeTypeName *' syntax for native
pointers.
2005-12-11 Martin Baulig <martin@ximian.com>
* backends/Debugger.cs
(Debugger.NativeLanguage): New public property.
2005-12-11 Martin Baulig <martin@ximian.com>
* languages/mono/MonoGenericInstanceType.cs: New file.
(MonoGenericInstanceType): New public class; derives from
`MonoClass'. We still don't have full generics support, we treat
the generic instance just like a normal class.
2005-12-11 Martin Baulig <martin@ximian.com>
* languages/TargetPointerType.cs
(TargetPointerType.GetObject): New public method to create a
pointer from an address.
2005-12-11 Martin Baulig <martin@ximian.com>
* languages/Language.cs
(Language.CreatePointerType): New public method.
2005-12-11 Martin Baulig <martin@ximian.com>
* arch/DwarfReader.cs: Improved the type support.
* arch/BfdContainer.cs
(BfdContainer.LookupType): We now use a type hashtable in the
`BfdContainer' and keep track of incomplete structs: if there's a
typedef entry for the same struct in more than one source file,
return the actual definition.
2005-12-11 Martin Baulig <martin@ximian.com>
* backends/remoting/DebuggerClient.cs
(DebuggerClient.ClientShutdown): New public event.
* frontend/Interpreter.cs
(Interpreter.Exit): Call Environment.Exit() in a `finally'
handler; print, but ignore all exceptions.
(Interpreter.InterpreterEventSink): Connect to the
`DebuggerClient.ClientShutdown' event.
2005-12-07 Martin Baulig <martin@ximian.com>
Reworked the breakpoint code and added session management.
* classes/DebuggerSession.cs
(DebuggerSession): The new session management code.
* classes/SourceFile.cs (SourceFile): Make this [Serializable].
(SourceMethod): Likewise.
* classes/SourceLocation.cs
(SourceLocation): Make this [Serializable].
* classes/EventHandle.cs
(EventHandle): Don't implement `IEventHandle'; killed that
interface.
* arch/Bfd.cs (Bfd): Inherit from `SymbolFile', not `Module'.
* languages/mono/MonoSymbolFile.cs
(MonoSymbolFile): Inherit from `SymbolFile', not `Module'.
* classes/CatchpointHandle.cs
(CatchPointHandle): Don't use an `ExceptionCatchPoint' anymore; do
everything in here instead.
* classes/ThreadGroup.cs (ThreadGroup): Moved all the static
methods into DebuggerManager.
* classes/Module.cs
(SymbolFile): New internal abstract class; replaces `ISymbolFile'.
(Module): Don't make this abstract; split out all the
functionality into `SymbolFile'.
* classes/ExceptionCatchPoint.cs: Removed.
* interfaces/IEventHandle.cs: Removed.
* interfaces/ISymbolFile.cs: Removed.
2005-12-03 Martin Baulig <martin@ximian.com>
* classes/ProcessStart.cs: Moved to ../backends/ProcessStart.cs;
moved the `ProcessStart' class into the `Mono.Debugger.Backends'
namespace; moved the `DebuggerOptions' class into the new
DebuggerSession.cs.
* classes/DebuggerSession.cs: New file.
(DebuggerOptions): Moved here from ProcessStart.cs.
2005-12-03 Martin Baulig <martin@ximian.com>
* classes/ProcessStart.cs
(ProcessStart): Make this class internal.
(DebuggerOptions): We're now [Serializable] and not a
MarshalByRefObject anymore.
2005-12-01 Martin Baulig <martin@ximian.com>
* frontend/ScriptingContext.cs (ProcessHandle): Removed.
2005-12-01 Martin Baulig <martin@ximian.com>
* frontend/ScriptingContext.cs
(ProcessHandle): Removed some more stuff here and get ready to
kill it.
2005-12-01 Martin Baulig <martin@ximian.com>
* frontend/Command.cs
(Command.SteppingCommand): New public abstract class; use this for
all stepping commands.
* frontend/ScriptingContext.cs (ProcessHandle.Step): Removed.
2005-12-01 Martin Baulig <martin@ximian.com>
* frontend/ScriptingContext.cs (FrameHandle): Removed.
(BacktraceHandle): Removed.
2005-12-01 Martin Baulig <martin@ximian.com>
* classes/StackFrame.cs
(StackFrame.ExceptionObject): New public property.
* frontend/Style.cs
(StyleBase.UnhandledException): Don't take a `TargetObject exc'
argument; it's now part of the `StackFrame'.
(StyleBase.TargetEvent): New public abstract method.
* frontend/ScriptingContext.cs
(FrameHandle.TargetEvent): Removed; we now use `Style.TargetEvent'.
2005-12-01 Martin Baulig <martin@ximian.com>
* frontend/ScriptingContext.cs
(FrameHandle): Removed all the register stuff.
2005-12-01 Martin Baulig <martin@ximian.com>
* frontend/ScriptingContext.cs
(FrameHandle.Disassemble): Removed.
(FrameHandle.DisassembleMethod): Removed.
(FrameHandle.Language): Removed.
(ScriptingContext.CurrentLanguage): New public property.
2005-11-30 Martin Baulig <martin@ximian.com>
* frontend/Style.cs (StyleMartin): Removed.
(StyleBase.PrintFrame): Take a `StackFrame' instead of a
`FrameHandle'.
(StyleBase.TargetStopped): Likewise.
(StyleBase.UnhandledException): Likewise.
2005-11-30 Martin Baulig <martin@ximian.com>
* backends/server/i386-arch.h: Move the hardware breakpoint stuff
to x86-ptrace.h and rename the `I386_DR_*' macros to `X86_DR_*'.
* backends/server/x86_64-arch.c: Implement hardware breakpoints.
2005-11-30 Martin Baulig <martin@ximian.com>
* frontend/Style.cs: Merge `StyleMono' and `StyleNative' into a
new `StyleCLI'.
2005-11-30 Martin Baulig <martin@ximian.com>
* backends/Process.cs (Process.DebuggerOutput): Removed.
* backends/Process.cs (Process.DebuggerError): Removed.
2005-11-30 Martin Baulig <martin@ximian.com>
* backends/server/i386-arch.c
(server_ptrace_call_method_invoke): Make this work again.
2005-11-29 Martin Baulig <martin@ximian.com>
* backends/server/i386-arch.c
(server_ptrace_insert_breakpoint): You cannot have a hardware
breakpoint and a normal breakpoint on the same address.
(server_ptrace_insert_hw_breakpoint): Check whether we already
have a breakpoint on the requested instruction.
2005-11-28 Martin Baulig <martin@ximian.com>
* classes/Report.cs (Report.Print): New public method.
(Report.Error): New public method.
* frontend/Interpreter.cs: Use Report.Print() and Report.Error()
to print things.
2005-11-28 Martin Baulig <martin@ximian.com>
* backends/server/i386-arch.c: Make i386 support work again.
2005-11-11 Martin Baulig <martin@ximian.com>
* languages/native/NativeEnumObject.cs: Removed.
* languages/mono/MonoEnumObject.cs: Removed.
* languages/TargetEnumObject.cs
(TargetEnumObject): Don't make this class abstract.
(TargetEnumObject.Value): Implement this here.
* languages/TargetEnumType.cs
(TargetEnumType.GetValue): New internal method.
2005-11-11 Martin Baulig <martin@ximian.com>
* arch/DwarfReader.cs
(DwarfTargetVariable.GetLocation): Implemented a few more opcodes.
* languages/TargetVariable.cs
(TargetVariable.PrintLocation): New public abstract method.
* frontend/Command.cs
(ShowLocationCommand): Added `show location' command.
2005-11-11 Martin Baulig <martin@ximian.com>
* backends/server/library.c
(mono_debugger_server_initialize): Print a warning that running
mdb as root may be a security risk; see
http://primates.ximian.com/~martin/blog/entry_150.html for details.
2005-11-11 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs
(Expression.EvaluateVariable): Renamed to `EvaluateObject'.
(Expression.DoEvaluateVariable): Renamed to `DoEvaluateObject'.
2005-11-11 Martin Baulig <martin@ximian.com>
* arch/Architecture.cs
(Architecture.CopyRegisters): New internal abstract method.
* arch/DwarfFrameReader.cs: Use `arch.CopyRegisters()' to copy the
registers; preserve callee saved registers.
* classes/StackFrame.cs (Register.Name): New public field.
2005-11-11 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs
(Expression.EvaluateLocation): Renamed to `EvaluateSource'.
(Expression.DoEvaluateLocation): Renamed to `DoEvaluateSource'.
2005-11-10 Martin Baulig <martin@ximian.com>
* arch/Architecture.cs
(Architecture.Hack_ReturnNull): You don't wanna use this function.
* arch/BfdContainer.cs: Some minor API cleanups; make sure to set
the newly created Bfd's `MainBfd'.
* classes/Breakpoint.cs
(Breakpoint.BreakpointHandler): New internal function.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.child_breakpoint): Call the new
`bpt.BreakpointHandler()' method before CheckBreakpointHit().
* arch/Bfd.cs
(Bfd.DynlinkBreakpoint): New private class; we use this for the
dynlink breakpoints.
(Bfd.module_loaded): Added big big hack for gnome-vfs: intercept
any calls to `__nptl_setxid()' via the new `SetXidBreakpoint' and
make it return 0.
2005-11-10 Martin Baulig <martin@ximian.com>
* backends/server/library.c
(mono_debugger_server_initialize): Refuse to run as root.
2005-11-09 Martin Baulig <martin@ximian.com>
* languages/TargetClassType.cs
(TargetClassType.Module): New public abstract property.
* languages/TargetFunctionType.cs
(TargetFunctionType.IsLoaded): New public abstract property.
* classes/BreakpointHandle.cs
(BreakpointHandle.EnableBreakpoint): When inserting a breakpoint
on a function, first check whether that function is loaded and use
a load handler if not.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.ExecuteOperation): New private method; use
this in ProcessOperation() and PushOperation() rather than calling
`operation.Execute (this)' directly; catch exceptions here.
2005-11-08 Martin Baulig <martin@ximian.com>
* languages/Language.cs
(Language.LookupType): Removed the `StackFrame' argument.
* languages/mono/MonoLanguageBackend.cs
(MonoLanguageBackend.LookupMonoType): Use `LookupType' to lookup a
`Cecil.ITypeReference'.
2005-11-08 Martin Baulig <martin@ximian.com>
* backends/Inferior.cs
(Inferior.CreateThread): Copy all the data to the new Inferior, so
we don't need to call SetupInferior() on it.
(Inferior.Attach): Don't call SetupInferior().
(Inferior.Dispose): Don't dispose the `Bfd' as it's owned by the
BfdContainer and will be disposed by the `Debugger' backend.
2005-11-02 Martin Baulig <martin@ximian.com>
* classes/Report.cs
(Report): Make this a static class and remove everything except
the `Debug' method.
(ReportWriter): New public `MarshalByRefObject' class.
* backends/remoting/DebuggerContext.cs
(DebuggerContext.ReportWriter): New public property; share one
`ReportWriter' instance between client and server so we can
redirect debugging output to a file.
* frontend/Main.cs (Main.ParseOption): The `-debug-flags' command
line argument now takes an optional filename.
2005-11-02 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(CommandAttribute): Removed.
(SingleSteppingEngine.SendCommand): New private method; call
`manager.SendCommand' unless we're in the engine thread.
(SingleSteppingEngine): Use `SendCommand' with an anonymous method
everywhere instead of the [Command] attribute.
2005-10-29 Martin Baulig <martin@ximian.com>
Avoid using the `Process' in the server; instead use the
`TargetAccess' to avoid unneccessary remoting round-trips.
* backends/Process.cs (Process.CallMethod): Removed.
* backends/TargetAccess.cs
(ServerTargetAccess.CallMethod): Implemented.
(TargetAccess.InsertBreakpoint): New internal method.
(TargetAccess.RemoveBreakpoint): New internal method.
(TargetAccess.AddEventHandler): New internal method.
(TargetAccess.RemoveEventHandler): New internal method.
* classes/BreakpointHandle.cs
(BreakpointHandle): Operate on `TargetAccess' and not on
`Process'.
2005-10-29 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(CommandResult): Make this abstract.
(SimpleCommandResult): New internal class.
(Operation.Result): New public readonly field.
(SingleSteppingEngine.operation_completed): Don't call
`process.SendTargetEvent()' anymore; our `current_operation' now
contains a `CommandResult' which has the completed event.
* backends/Process.cs (Process.State): Return the SSE's state.
(Process.SendTargetEvent): Removed.
(Process): When calling methods on the SSE, don't wait on the
`operation_completed_event' directly; use the `CommandResult'.
2005-10-26 Martin Baulig <martin@ximian.com>
* languages/TargetClassType.cs
(TargetClassType.ResolveClass): Removed.
* languages/TargetFunctionType.cs
(TargetFunctionType.GetVirtualMethod): Removed.
* backends/Process.cs
(Process.RuntimeInvoke): Take a `TargetFunctionType' instead of a
`TargetAddress' and added `bool is_virtual' argument.
* backends/SingleSteppingEngine.cs
(OperationRuntimeInvoke): Cleaned this up; box the instance and
compute the (virtual) method address here.
2005-10-20 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs
(Convert.ImplicitConversion(Exists)): Add support for implicit
reference conversions from a type to its parent.
* test/mono-debugger.tests/TestInheritance.exp: Added testcase.
2005-10-20 Martin Baulig <martin@ximian.com>
* frontend/Style.cs
(StyleNative.DoFormatObject): Added support for enums.
* languages/TargetEnumType.cs
(TargetEnumType.IsFlagsEnum): New public property.
* languages/TargetMember.cs
(TargetMemberInfo): Make this a MarshalByRefObject.
(TargetFieldInfo.ConstValue): New public property; replaces
GetConstValue().
(TargetFieldInfo.GetConstValue): Removed.
* test/mono-debugger.tests/TestEnum.exp: Added enum test.
2005-10-19 Martin Baulig <martin@ximian.com>
* languages/TargetFunctionType.cs
(TargetFunctionType.GetMethodAddress): New public method.
(TargetFunctionType.GetVirtualMethod): New public method.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.RuntimeInvoke): Take a `TargetAddress'
instead of a `TargetFunctionType'.
(OperationRuntimeInvoke): Don't compute the virtual method and
also don't box the instance here; our caller is now responsible
for doing that.
* backends/Process.cs (Process.RuntimeInvoke): Take a
`TargetAddress' instead of a `TargetFunctionType'.
* frontend/ScriptingContext.cs
(ScriptingContext.RuntimeInvoke): Compute the virtual method and
box/unbox the instance object here.
2005-10-18 Martin Baulig <martin@ximian.com>
* languages/TargetObjectType.cs
(TargetObjectType): New public abstract class.
* languages/TargetObjectObject.cs
(TargetObjectObject): New public abstract class.
* languages/TargetObjectKind.cs
(TargetObjectKind): Added `TargetObjectKind.Object'.
* languages/mono/MonoObjectType.cs
(MonoObjectType): Derive from `TargetObjectType'.
* languages/mono/MonoObjectObject.cs
(MonoObjectObject): Derive from `TargetObjectObject'.
* frontend/Expression.cs
(Convert.ToClassType): New public static method.
(Convert.ToClassObject): Likewise.
2005-10-18 Martin Baulig <martin@ximian.com>
* languages/TargetClassObject.cs
(TargetClassObject.GetCurrentObject): New public abstract method.
* frontend/Expression.cs
(Cast.TryCurrentCast): Make this actually work.
2005-10-18 Martin Baulig <martin@ximian.com>
* backends/server/x86_64-arch.c, i386-arch.c: Save and restore
`inferior->last_signal' across invocations.
2005-10-17 Martin Baulig <martin@ximian.com>
* backends/classes/MonoVariableLocation.cs
(MonoVariableLocation.WriteAddress): Correctly handle `is_byref'.
2005-10-17 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs (VariableAccessExpression.DoAssign): Call
`Convert.ImplicitConversionRequired' on the object to convert it
to the correct type.
2005-10-17 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs
(MethodGroupExpression.ctor): Take a `TargetFunctionType[]' array
instead of an `ArrayList'.
(PropertyGroupExpression): Removed.
(InvocationExpression.DoResolve): Do overload resolution here.
(InvocationExpression.DoResolveType): Override this.
(InvocationExpression.Invoke): Return `void'.
(ArrayAccessExpression.DoResolveVariable, DoAssign): Use an
`InvocationExpression' to invoke indexers.
2005-10-17 Martin Baulig <martin@ximian.com>
* frontend/Expression.cs (Convert): New public static class.
(Convert.ImplicitConversion): New public method.
(Convert.ImplicitConversionExists): Likewise.
(Convert.ImplicitConversionRequired): Likewise.
(MethodGroupExpression.IsApplicable): New method to check whether
a method is actually applicable.
(MethodGroupExpression.OverloadResolve): Also check whether the
method is applicable if there is just one single method; take a
`TargetType[]' array instead of an `Expression[]' array as
argument.
(MethodGroupExpression.OverloadResolve): Make the overloaded
version taking an `ArrayList candidates' private.
(InvocationExpression.Invoke): Implicitly convert the arguments to
the actual parameter types.
(NewExpression.Invoke): Create an InvocationExpression to avoid
some code duplication.
2005-10-16 Martin Baulig <martin@ximian.com>
* backends/classes/ClientSuppliedTargetLocation.cs
(ClientSuppliedTargetLocation): New internal class.
* languages/TargetFundamentalType.cs
(TargetFundamentalType.CreateInstance): Use the new
`ClientSuppliedTargetLocation' as the object's location rather
than using the heap.
* languages/Language.cs (Language.AllocateMemory): Removed.
* languages/mono/Heap.cs: Removed.
2005-10-16 Martin Baulig <martin@ximian.com>
* backends/SingleSteppingEngine.cs
(OperationAbortInvocation): New operation to abort a runtime
invoke; this unwinds the stack and calls all `finally' handlers.
(SingleSteppingEngine.AbortInvocation): New function.
2005-10-16 Martin Baulig <martin@ximian.com>
* classes/StackFrame.cs (StackFrame.ctor): Don't take a `level'
argument; we compute this automatically when adding the frame to
the Backtrace.
2005-10-16 Martin Baulig <martin@ximian.com>
* test/TestAbort.cs, test/mono-debugger.test/TestAbort.exp: New
test for the stack unwinding and `return'.
2005-10-16 Martin Baulig <martin@ximian.com>
* backends/server/server.c
(mono_debugger_server_abort_invoke): New public method.
* backends/SingleSteppingEngine.cs
(SingleSteppingEngine.Return): Check whether we're crossing a
runtime invoke boundary and abort the invocation if neccessary.
(SingleSteppingEngine.ProcessChildEvent): We now receive a
`CHILD_CALLBACK_COMPLETED' event when completing a debugging
runtime invoke.
* backends/Inferior.cs
(Inferior.ChildEventType): Added `CHILD_CALLBACK_COMPLETED'.
* backends/server/x86_64-arch.c
(x86_arch_child_stopped): Send `STOP_ACTION_CALLBACK_COMPLETED' if
we completed a debugging runtime invoke.
2005-10-16 Martin Baulig <martin@ximian.com>
* classes/StackFrame.cs (StackFrame): Don't implement IDisposable.
(StackFrame.FrameInvalidEvent): Removed.
(ObjectInvalidHandler): Removed.
* classes/Backtrace.cs (Backtrace): Don't implement IDisposable.
(Backtrace.BacktraceInvalidEvent): Removed.
2005-10-16 Martin Baulig <martin@ximian.com>
Added the `return' command to make the current stack frame return.
* wrapper/mono-debugger-jit-wrapper.h
(MonoDebuggerInfo): Added `run_finally'.
* backends/server/server.c
(mono_debugger_server_call_method_2): New public method; invoke a
function which takes a `MonoContext *' (private mini data structure)
argument; we use this to call mono_debugger_run_finally().
* backends/SingleSteppingEngine.cs
(OperationReturn): New operation; run the current frame's
`finally' handlers.
(SingleSteppingEngine.Return): New public method; make the current
stack frame return.
* frontend/Command.cs (ReturnCommand): Added a `return' command to
make the current stack frame return.
2005-10-14 Martin Baulig <martin@ximian.com>
Only use a single AddressDomain per process.
* interfaces/ITargetMemoryAccess.cs
(ITargetMemoryInfo.GlobalAddressDomain): Removed; use
`AddressDomain' instead.
(ITargetMemoryAccess.ReadGlobalAddress): Removed; use
`ReadAddress' instead.
2005-10-11 Martin Baulig <martin@ximian.com>
* classes/StackFrame.cs (SimpleStackFrame): Removed.
2005-10-11 Martin Baulig <martin@ximian.com>
* arch/Architecture.cs: The stack unwinding methods now operate on
`StackFrame's instead of `SimpleStackFrame's.
2005-10-11 Martin Baulig <martin@ximian.com>
* classes/StackFrame.cs
(StackFrame.SourceAddress): Create this lazily.
2005-10-11 Martin Baulig <martin@ximian.com>
* classes/SymbolTableManager.cs
(SymbolTableManager.SymbolTable): Removed.
(SymbolTableManager): Make some API entry points `internal'.
2005-10-11 Martin Baulig <martin@ximian.com>
* interfaces/ISymbolTable.cs (ISimpleSymbolTable): Removed.
* arch/Disassembler.cs (Disassembler.SymbolTable): Removed.
* classes/SimpleSymbolTableCollection.cs: R