public AssemblerLine(string label, TargetAddress address, byte size, string text)
 {
     this.Label = label;
     this.Address = address;
     this.InstructionSize = size;
     this.Text = text;
 }

        public TargetMemoryArea(TargetAddress start, TargetAddress end,
					 TargetMemoryFlags flags, string name)
        {
            this.start = start;
            this.end = end;
            this.flags = flags;
            this.name = name;
        }

        public StepFrame(Language language, StepMode mode, StackFrame stack,
				  TargetAddress start, TargetAddress end)
        {
            this.start = start;
            this.end = end;
            this.stack = stack;
            this.language = language;
            this.mode = mode;
        }

        public LineEntry(TargetAddress address, int file, int line, bool is_hidden,
				  SourceRange? source_range)
        {
            this.Address = address;;
            this.File = file;
            this.Line = line;
            this.IsHidden = is_hidden;
            this.SourceRange = source_range;
        }

        public Register(Registers registers, string name, int index, int size,
				 bool valid, long value)
        {
            this.registers = registers;
            this.Name = name;
            this.Index = index;
            this.Size = size;
            this.valid = valid;
            this.value = value;
            this.addr_on_stack = TargetAddress.Null;
        }

        public override bool GetTrampoline(TargetMemoryAccess memory, TargetAddress address,
						    out TargetAddress trampoline, out bool is_start)
        {
            foreach (Bfd bfd in bfd_hash.Values) {
                if (bfd.GetTrampoline (memory, address, out trampoline, out is_start))
                    return true;
            }

            is_start = false;
            trampoline = TargetAddress.Null;
            return false;
        }

        internal bool CheckException(MonoLanguageBackend mono, TargetMemoryAccess target,
					      TargetAddress address)
        {
            TargetClassObject exc = mono.CreateObject (target, address) as TargetClassObject;
            if (exc == null)
                return false; // OOOPS

            if (exception == null)
                exception = mono.LookupType (Name);
            if (exception == null)
                return false;

            return IsSubclassOf (target, exc.Type, exception);
        }

        public override NativeExecutableReader AddExecutableFile(Inferior inferior, string filename,
									  TargetAddress base_address, bool step_into,
									  bool is_loaded)
        {
            check_disposed ();
            Bfd bfd = (Bfd) bfd_hash [filename];
            if (bfd != null)
                return bfd;

            bfd = new Bfd (this, inferior.TargetMemoryInfo, filename, base_address, is_loaded);
            bfd_hash.Add (filename, bfd);
            check_loaded_library (inferior, bfd);
            return bfd;
        }

        public override AssemblerLine DisassembleInstruction(TargetMemoryAccess memory,
								      Method method,
								      TargetAddress address)
        {
            lock (this) {
                memory_exception = null;
                sb = new StringBuilder ();

                address = new TargetAddress (memory.AddressDomain, address.Address);

                string insn;
                int insn_size;
                try {
                    this.memory = memory;
                    current_method = method;
                    insn_size = bfd_glue_disassemble_insn (handle, address.Address);
                    if (memory_exception != null)
                        return null;
                    insn = sb.ToString ();
                } finally {
                    sb = null;
                    this.memory = null;
                    memory_exception = null;
                    current_method = null;
                }

                Symbol label = null;
                if (process != null)
                    label = process.SymbolTableManager.SimpleLookup (address, true);

                string label_name = null;
                if (label != null)
                    label_name = label.ToString ();

                return new AssemblerLine (
                    label_name, address, (byte) insn_size, insn);
            }
        }

        // <summary>
        //   Disassemble one instruction.
        //   If @imethod is non-null, it specifies the current method which will
        //   be used to lookup function names from trampoline calls.
        // </summary>
        public abstract AssemblerLine DisassembleInstruction(TargetMemoryAccess memory,
								      Method method,
								      TargetAddress address);

 internal AddressBreakpoint(string name, ThreadGroup group, TargetAddress address)
     : base(EventType.Breakpoint, name, group)
 {
     this.address = address;
 }

        internal void InitializeMono(Inferior inferior, TargetAddress mdb_debug_info)
        {
            MonoRuntimeFound = true;
            mono_manager = MonoThreadManager.Initialize (this, inferior, mdb_debug_info, is_attached);

            InitializeThreads (inferior, !is_attached);

            if (mono_manager == null)
                return;

            mono_manager.InitializeThreads (inferior);

            if (is_attached)
                mono_manager.InitializeAfterAttach (inferior);
        }

 public Symbol(string name, TargetAddress address, int offset)
 {
     this.Name = name;
     this.Address = address;
     this.Offset = offset;
 }

 internal void InitCodeBuffer(Inferior inferior, TargetAddress code_buffer)
 {
     HasCodeBuffer = true;
     mono_debugger_server_initialize_code_buffer (
         mono_runtime_info, code_buffer.Address,
         debugger_info.ExecutableCodeBufferSize);
 }

        protected override TargetObject DoEvaluateObject(ScriptingContext context)
        {
            StackFrame frame = context.CurrentFrame;
            Register register = frame.Registers [name];
            if (register == null)
                throw new ScriptingException ("No such register `{0}'.", name);

            try {
                long value = register.Value;
                TargetAddress address = new TargetAddress (
                    context.AddressDomain, value);
                return context.CurrentLanguage.CreatePointer (frame, address);
            } catch {
                throw new ScriptingException (
                    "Can't access register `{0}' selected stack frame.", name);
            }
        }

 public InitializeBreakpoint(MonoThreadManager manager, TargetAddress address)
     : base("initialize", ThreadGroup.System, address)
 {
     this.manager = manager;
 }

 public override bool CheckBreakpointHit(Thread target, TargetAddress address)
 {
     return true;
 }

 public abstract NativeExecutableReader LookupLibrary(TargetAddress address);

 public void WriteAddress(TargetAddress address)
 {
     if (AddressSize == 8)
         WriteInt64 (address.Address);
     else
         WriteInt32 ((int) address.Address);
 }

        // <summary>
        //   Get the size of the current instruction.
        // </summary>
        public abstract int GetInstructionSize(TargetMemoryAccess memory,
							TargetAddress address);