Inheritance: DebuggerMarshalByRefObject
Exemplo n.º 1
0
        internal StackFrame UnwindStack(StackFrame frame, TargetMemoryAccess memory)
        {
            if (!IsLoaded)
            {
                return(null);
            }

            try {
                StackFrame new_frame = Module.UnwindStack(frame, memory);
                if (new_frame != null)
                {
                    return(new_frame);
                }
            } catch {
            }

            int prologue_size;

            if (HasMethodBounds)
            {
                prologue_size = (int)(MethodStartAddress - StartAddress);
            }
            else
            {
                prologue_size = (int)(EndAddress - StartAddress);
            }
            int offset = (int)(frame.TargetAddress - StartAddress);

            byte[] prologue = memory.ReadBuffer(StartAddress, prologue_size);
            return(frame.Thread.Architecture.UnwindStack(frame, memory, prologue, offset));
        }
Exemplo n.º 2
0
        private StackFrame TryLMF(ThreadServant thread, TargetMemoryAccess memory)
        {
            try {
                if (lmf_address.IsNull)
                {
                    return(null);
                }

                StackFrame new_frame = thread.Architecture.GetLMF(thread, memory, ref lmf_address);
                if (new_frame == null)
                {
                    return(null);
                }

                // Sanity check; don't loop.
                if (new_frame.StackPointer <= last_frame.StackPointer)
                {
                    return(null);
                }

                return(new_frame);
            } catch (TargetException) {
                return(null);
            }
        }
Exemplo n.º 3
0
 internal void UpdateSymbolTable(TargetMemoryAccess target)
 {
     if (mono_language != null)
     {
         mono_language.Update(target);
     }
 }
Exemplo n.º 4
0
        internal bool TryUnwind(ThreadServant thread, TargetMemoryAccess memory,
                                Mode mode, TargetAddress until)
        {
            StackFrame new_frame = null;

            try {
                new_frame = last_frame.UnwindStack(memory);
            } catch (TargetException) {
            }

            if (!TryCallback(thread, memory, ref new_frame, true))
            {
                if ((new_frame == null) || !IsFrameOkForMode(new_frame, mode))
                {
                    if (!tried_lmf)
                    {
                        tried_lmf = true;
                        if (thread.LMFAddress.IsNull)
                        {
                            return(false);
                        }
                        lmf_address = memory.ReadAddress(thread.LMFAddress);
                    }

                    if (!lmf_address.IsNull)
                    {
                        new_frame = TryLMF(thread, memory);
                    }
                    else
                    {
                        return(false);
                    }
                }
            }

            if (new_frame == null)
            {
                return(false);
            }

            // Sanity check; don't loop.
            if (new_frame.StackPointer <= last_frame.StackPointer)
            {
                return(false);
            }

            if (!until.IsNull && (new_frame.StackPointer >= until))
            {
                return(false);
            }

            AddFrame(new_frame);
            return(true);
        }
Exemplo n.º 5
0
        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;
        }
Exemplo n.º 6
0
        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);
        }
Exemplo n.º 7
0
        internal void WriteRegister(TargetMemoryAccess target, long value)
        {
            this.value = value;

            if (addr_on_stack.IsNull)
            {
                target.SetRegisters(registers);
            }
            else if (Size == target.TargetMemoryInfo.TargetIntegerSize)
            {
                target.WriteInteger(addr_on_stack, (int)value);
            }
            else
            {
                target.WriteLongInteger(addr_on_stack, value);
            }
        }
Exemplo n.º 8
0
        private bool TryCallback(ThreadServant thread, TargetMemoryAccess memory,
                                 ref StackFrame frame, bool exact_match)
        {
            try {
                if (frame == null)
                {
                    return(false);
                }

                Inferior.CallbackFrame callback = thread.GetCallbackFrame(
                    frame.StackPointer, exact_match);
                if (callback == null)
                {
                    return(false);
                }

                frame = thread.Architecture.CreateFrame(
                    thread.Client, FrameType.Normal, memory, callback.Registers);

                FrameType callback_type;
                string    frame_name = "<method called from mdb>";

                if (callback.IsRuntimeInvokeFrame)
                {
                    callback_type = FrameType.RuntimeInvoke;
                    TargetFunctionType func = thread.GetRuntimeInvokedFunction(callback.ID);
                    if (func != null)
                    {
                        frame_name = String.Format("<Invocation of: {0}>", func.FullName);
                    }
                }
                else
                {
                    callback_type = FrameType.Callback;
                }

                AddFrame(new StackFrame(
                             thread.Client, callback_type, callback.CallAddress, callback.StackPointer,
                             TargetAddress.Null, callback.Registers, thread.NativeLanguage,
                             new Symbol(frame_name, callback.CallAddress, 0)));
                return(true);
            } catch (TargetException) {
                return(false);
            }
        }
Exemplo n.º 9
0
        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));
        }
Exemplo n.º 10
0
        bool IsSubclassOf(TargetMemoryAccess target, TargetClassType type,
                          TargetType parent)
        {
            while (type != null)
            {
                if (type == parent)
                {
                    return(true);
                }

                if (!type.HasParent)
                {
                    return(false);
                }

                type = type.GetParentType(target);
            }

            return(false);
        }
Exemplo n.º 11
0
        internal void GetBacktrace(ThreadServant thread, TargetMemoryAccess memory,
                                   Mode mode, TargetAddress until, int max_frames)
        {
            while (TryUnwind(thread, memory, mode, until))
            {
                if ((max_frames != -1) && (frames.Count > max_frames))
                {
                    break;
                }
            }

            // Ugly hack: in Mode == Mode.Default, we accept wrappers but not as the
            //            last frame.
            if ((mode == Mode.Default) && (frames.Count > 1))
            {
                StackFrame last = this [frames.Count - 1];
                if (!IsFrameOkForMode(last, Mode.Managed))
                {
                    frames.Remove(last);
                }
            }
        }
Exemplo n.º 12
0
        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);
            }
        }
Exemplo n.º 13
0
        internal StackFrame UnwindStack(TargetMemoryAccess memory)
        {
            if (parent_frame != null)
            {
                return(parent_frame);
            }

            StackFrame new_frame = null;

            if (method != null)
            {
                try {
                    new_frame = method.UnwindStack(this, memory);
                } catch (TargetException) {
                }

                if (new_frame != null)
                {
                    return(new_frame);
                }
            }

            foreach (Module module in thread.Process.Modules)
            {
                try {
                    new_frame = module.UnwindStack(this, memory);
                } catch {
                    continue;
                }
                if (new_frame != null)
                {
                    return(new_frame);
                }
            }

            return(thread.Architecture.UnwindStack(this, memory, null, 0));
        }
Exemplo n.º 14
0
 // <summary>
 //   Get the size of the current instruction.
 // </summary>
 public abstract int GetInstructionSize(TargetMemoryAccess memory,
                                        TargetAddress address);
Exemplo n.º 15
0
        public override AssemblerMethod DisassembleMethod(TargetMemoryAccess memory, Method method)
        {
            lock (this) {
                ArrayList list = new ArrayList ();
                TargetAddress current = method.StartAddress;
                while (current < method.EndAddress) {
                    AssemblerLine line = DisassembleInstruction (
                        memory, method, current);
                    if (line == null)
                        break;

                    current += line.InstructionSize;
                    list.Add (line);
                }

                AssemblerLine[] lines = new AssemblerLine [list.Count];
                list.CopyTo (lines, 0);

                return new AssemblerMethod (method, lines);
            }
        }
Exemplo n.º 16
0
        internal Method ReadRangeEntry(TargetMemoryAccess memory, TargetReader reader,
						byte[] contents)
        {
            RangeEntry range = RangeEntry.Create (this, memory, reader, contents);
            if (!range_hash.Contains (range.Hash)) {
                range_hash.Add (range.Hash, range);
                ranges.Add (range);
            }
            return range.GetMethod ();
        }
Exemplo n.º 17
0
        bool IsSubclassOf(TargetMemoryAccess target, TargetClassType type,
				   TargetType parent)
        {
            while (type != null) {
                if (type == parent)
                    return true;

                if (!type.HasParent)
                    return false;

                type = type.GetParentType (target);
            }

            return false;
        }
Exemplo n.º 18
0
        internal StackFrame UnwindStack(StackFrame last_frame,
						 TargetMemoryAccess memory)
        {
            return SymbolFile.UnwindStack (last_frame, memory);
        }
Exemplo n.º 19
0
        private StackFrame TryLMF(ThreadServant thread, TargetMemoryAccess memory)
        {
            try {
                if (lmf_address.IsNull)
                    return null;

                StackFrame new_frame = thread.Architecture.GetLMF (thread, memory, ref lmf_address);
                if (new_frame == null)
                    return null;

                // Sanity check; don't loop.
                if (new_frame.StackPointer <= last_frame.StackPointer)
                    return null;

                return new_frame;
            } catch (TargetException) {
                return null;
            }
        }
Exemplo n.º 20
0
        private bool TryCallback(ThreadServant thread, TargetMemoryAccess memory,
					  ref StackFrame frame, bool exact_match)
        {
            try {
                if (frame == null)
                    return false;

                Inferior.CallbackFrame callback = thread.GetCallbackFrame (
                    frame.StackPointer, exact_match);
                if (callback == null)
                    return false;

                frame = thread.Architecture.CreateFrame (
                    thread.Client, FrameType.Normal, memory, callback.Registers);

                FrameType callback_type;
                string frame_name = "<method called from mdb>";

                if (callback.IsRuntimeInvokeFrame) {
                    callback_type = FrameType.RuntimeInvoke;
                    TargetFunctionType func = thread.GetRuntimeInvokedFunction (callback.ID);
                    if (func != null)
                        frame_name = String.Format ("<Invocation of: {0}>", func.FullName);
                } else {
                    callback_type = FrameType.Callback;
                }

                AddFrame (new StackFrame (
                    thread.Client, callback_type, callback.CallAddress, callback.StackPointer,
                    TargetAddress.Null, callback.Registers, thread.NativeLanguage,
                    new Symbol (frame_name, callback.CallAddress, 0)));
                return true;
            } catch (TargetException) {
                return false;
            }
        }
Exemplo n.º 21
0
        internal bool TryUnwind(ThreadServant thread, TargetMemoryAccess memory,
					 Mode mode, TargetAddress until)
        {
            StackFrame new_frame = null;
            try {
                new_frame = last_frame.UnwindStack (memory);
            } catch (TargetException) {
            }

            if (!TryCallback (thread, memory, ref new_frame, true)) {
                if ((new_frame == null) || !IsFrameOkForMode (new_frame, mode)) {
                    if (!tried_lmf) {
                        tried_lmf = true;
                        if (thread.LMFAddress.IsNull)
                            return false;
                        lmf_address = memory.ReadAddress (thread.LMFAddress);
                    }

                    if (!lmf_address.IsNull)
                        new_frame = TryLMF (thread, memory);
                    else
                        return false;
                }
            }

            if (new_frame == null)
                return false;

            // Sanity check; don't loop.
            if (new_frame.StackPointer <= last_frame.StackPointer)
                return false;

            if (!until.IsNull && (new_frame.StackPointer >= until))
                return false;

            AddFrame (new_frame);
            return true;
        }
Exemplo n.º 22
0
        internal void GetBacktrace(ThreadServant thread, TargetMemoryAccess memory,
					    Mode mode, TargetAddress until, int max_frames)
        {
            while (TryUnwind (thread, memory, mode, until)) {
                if ((max_frames != -1) && (frames.Count > max_frames))
                    break;
            }

            // Ugly hack: in Mode == Mode.Default, we accept wrappers but not as the
            //            last frame.
            if ((mode == Mode.Default) && (frames.Count > 1)) {
                StackFrame last = this [frames.Count - 1];
                if (!IsFrameOkForMode (last, Mode.Managed))
                    frames.Remove (last);
            }
        }
Exemplo n.º 23
0
            internal MonoClassInfo ReadClassInfo(MonoLanguageBackend mono,
							      TargetMemoryAccess target)
            {
                if (info == null)
                    info = mono.ReadClassInfo (target, KlassAddress);

                return info;
            }
Exemplo n.º 24
0
        internal override StackFrame UnwindStack(StackFrame last_frame,
							  TargetMemoryAccess memory)
        {
            return null;
        }
Exemplo n.º 25
0
            internal override MethodSource GetTrampoline(TargetMemoryAccess memory,
								      TargetAddress address)
            {
                return File.MonoLanguage.GetTrampoline (memory, address);
            }
Exemplo n.º 26
0
 internal virtual Block LookupBlock(TargetMemoryAccess memory,
                                    TargetAddress address)
 {
     return(null);
 }
Exemplo n.º 27
0
            public static RangeEntry Create(MonoSymbolFile file, TargetMemoryAccess memory,
							 TargetReader reader, byte[] contents)
            {
                int domain = reader.BinaryReader.ReadInt32 ();
                int index = reader.BinaryReader.ReadInt32 ();

                TargetAddress wrapper_data = reader.ReadAddress ();
                TargetAddress method = reader.ReadAddress ();
                reader.ReadAddress (); /* address_list */
                TargetAddress code_start = reader.ReadAddress ();
                TargetAddress wrapper_addr = reader.ReadAddress ();
                int code_size = reader.BinaryReader.ReadInt32 ();

                WrapperEntry wrapper = null;

                if (!wrapper_data.IsNull) {
                    int wrapper_size = 4 + 3 * memory.TargetMemoryInfo.TargetAddressSize;

                    TargetReader wrapper_reader = new TargetReader (
                        memory.ReadMemory (wrapper_data, wrapper_size));

                    TargetAddress name_address = wrapper_reader.ReadAddress ();
                    TargetAddress cil_address = wrapper_reader.ReadAddress ();
                    int wrapper_type = wrapper_reader.BinaryReader.ReadInt32 ();

                    string name = "<" + memory.ReadString (name_address) + ">";
                    string cil_code = memory.ReadString (cil_address);

                    wrapper = new WrapperEntry (
                        wrapper_addr, (WrapperType) wrapper_type, name, cil_code);
                }

                return new RangeEntry (
                    file, domain, index, wrapper, method,
                    code_start, code_start + code_size, contents);
            }
Exemplo n.º 28
0
 internal abstract MethodSource GetTrampoline(TargetMemoryAccess memory,
                                              TargetAddress address);
Exemplo n.º 29
0
 internal StackFrame UnwindStack(StackFrame last_frame,
                                 TargetMemoryAccess memory)
 {
     return(SymbolFile.UnwindStack(last_frame, memory));
 }
Exemplo n.º 30
0
        internal abstract StackFrame UnwindStack(StackFrame last_frame,
							  TargetMemoryAccess memory);
Exemplo n.º 31
0
        protected MonoDebuggerInfo(TargetMemoryAccess memory, TargetReader reader)
        {
            reader.Offset = 8;
            MajorVersion              = reader.ReadInteger ();
            MinorVersion              = reader.ReadInteger ();

            RuntimeFlags              = reader.ReadInteger ();

            reader.Offset = 24;

            SymbolTableSize           = reader.ReadInteger ();
            MonoTrampolineNum         = reader.ReadInteger ();
            MonoTrampolineCode        = reader.ReadAddress ();
            NotificationAddress       = reader.ReadAddress ();
            SymbolTable               = reader.ReadAddress ();
            MonoMetadataInfo          = reader.ReadAddress ();
            DebuggerVersion           = reader.ReadAddress ();

            CompileMethod             = reader.ReadAddress ();
            GetVirtualMethod          = reader.ReadAddress ();
            GetBoxedObjectMethod      = reader.ReadAddress ();
            RuntimeInvoke             = reader.ReadAddress ();
            ClassGetStaticFieldData   = reader.ReadAddress ();
            RunFinally                = reader.ReadAddress ();
            Initialize                = reader.ReadAddress ();

            CreateString              = reader.ReadAddress ();
            LookupClass               = reader.ReadAddress ();

            InsertMethodBreakpoint    = reader.ReadAddress ();
            InsertSourceBreakpoint    = reader.ReadAddress ();
            RemoveBreakpoint          = reader.ReadAddress ();

            RegisterClassInitCallback = reader.ReadAddress ();
            RemoveClassInitCallback   = reader.ReadAddress ();

            ThreadTable               = reader.ReadAddress ();

            ExecutableCodeBuffer      = reader.ReadAddress ();
            BreakpointInfo            = reader.ReadAddress ();
            BreakpointInfoIndex       = reader.ReadAddress ();

            ExecutableCodeBufferSize  = reader.ReadInteger ();
            BreakpointArraySize       = reader.ReadInteger ();

            GetMethodSignature        = reader.ReadAddress ();
            InitCodeBuffer            = reader.ReadAddress ();

            ThreadVTablePtr           = reader.ReadAddress ();
            ThreadVTable              = reader.ReadAddress ();
            EventHandlerPtr           = reader.ReadAddress ();
            EventHandler              = reader.ReadAddress ();

            UsingMonoDebugger         = reader.ReadAddress ();
            InterruptionRequest       = reader.ReadAddress ();

            if (HasAbortRuntimeInvoke)
                AbortRuntimeInvoke = reader.ReadAddress ();

            if (HasThreadAbortSignal)
                ThreadAbortSignal = reader.ReadAddress ();

            Report.Debug (DebugFlags.JitSymtab, this);
        }
Exemplo n.º 32
0
        internal void WriteRegister(TargetMemoryAccess target, long value)
        {
            this.value = value;

            if (addr_on_stack.IsNull)
                target.SetRegisters (registers);
            else if (Size == target.TargetMemoryInfo.TargetIntegerSize)
                target.WriteInteger (addr_on_stack, (int) value);
            else
                target.WriteLongInteger (addr_on_stack, value);
        }
Exemplo n.º 33
0
        internal MonoClassInfo LookupClassInfo(TargetMemoryAccess target, int token)
        {
            ClassEntry entry = (ClassEntry) class_entry_by_token [token];
            if (entry == null) {
                MonoLanguage.Update (target);
                entry = (ClassEntry) class_entry_by_token [token];
                if (entry == null)
                    return null;
            }

            return entry.ReadClassInfo (MonoLanguage, target);
        }
Exemplo n.º 34
0
 internal abstract StackFrame UnwindStack(StackFrame last_frame,
                                          TargetMemoryAccess memory);
Exemplo n.º 35
0
        internal StackFrame UnwindStack(TargetMemoryAccess memory)
        {
            if (parent_frame != null)
                return parent_frame;

            StackFrame new_frame = null;
            if (method != null) {
                try {
                    new_frame = method.UnwindStack (this, memory);
                } catch (TargetException) {
                }

                if (new_frame != null)
                    return new_frame;
            }

            foreach (Module module in thread.Process.Modules) {
                try {
                    new_frame = module.UnwindStack (this, memory);
                } catch {
                    continue;
                }
                if (new_frame != null)
                    return new_frame;
            }

            return thread.Architecture.UnwindStack (this, memory, null, 0);
        }
Exemplo n.º 36
0
        public static MonoDebuggerInfo Create(TargetMemoryAccess memory, TargetAddress info)
        {
            TargetBinaryReader header = memory.ReadMemory (info, 24).GetReader ();
            long magic = header.ReadInt64 ();
            if (magic != DynamicMagic) {
                Report.Error ("`MONO_DEBUGGER__debugger_info' at {0} has unknown magic {1:x}.", info, magic);
                return null;
            }

            int version = header.ReadInt32 ();
            if (version < MinDynamicVersion) {
                Report.Error ("`MONO_DEBUGGER__debugger_info' has version {0}, " +
                          "but expected at least {1}.", version,
                          MonoDebuggerInfo.MinDynamicVersion);
                return null;
            }
            if (version > MaxDynamicVersion) {
                Report.Error ("`MONO_DEBUGGER__debugger_info' has version {0}, " +
                          "but expected at most {1}.", version,
                          MonoDebuggerInfo.MaxDynamicVersion);
                return null;
            }

            header.ReadInt32 (); // minor version
            header.ReadInt32 ();

            int size = header.ReadInt32 ();

            TargetReader reader = new TargetReader (memory.ReadMemory (info, size));
            return new MonoDebuggerInfo (memory, reader);
        }
Exemplo n.º 37
0
 internal void UpdateSymbolTable(TargetMemoryAccess target)
 {
     if (mono_language != null)
         mono_language.Update (target);
 }
Exemplo n.º 38
0
        // <summary>
        //   Disassemble one method.
        // </summary>
        public abstract AssemblerMethod DisassembleMethod(TargetMemoryAccess memory,
								   Method method);
Exemplo n.º 39
0
 // <summary>
 //   Disassemble one method.
 // </summary>
 public abstract AssemblerMethod DisassembleMethod(TargetMemoryAccess memory,
                                                   Method method);
Exemplo n.º 40
0
        public override int GetInstructionSize(TargetMemoryAccess memory, TargetAddress address)
        {
            memory_exception = null;

            try {
                this.memory = memory;
                int count = bfd_glue_disassemble_insn (handle, address.Address);
                if (memory_exception != null)
                    throw memory_exception;
                return count;
            } finally {
                this.memory = null;
                memory_exception = null;
            }
        }
Exemplo n.º 41
0
        internal StackFrame UnwindStack(StackFrame frame, TargetMemoryAccess memory)
        {
            if (!IsLoaded)
                return null;

            try {
                StackFrame new_frame = Module.UnwindStack (frame, memory);
                if (new_frame != null)
                    return new_frame;
            } catch {
            }

            int prologue_size;
            if (HasMethodBounds)
                prologue_size = (int) (MethodStartAddress - StartAddress);
            else
                prologue_size = (int) (EndAddress - StartAddress);
            int offset = (int) (frame.TargetAddress - StartAddress);

            byte[] prologue = memory.ReadBuffer (StartAddress, prologue_size);
            return frame.Thread.Architecture.UnwindStack (frame, memory, prologue, offset);
        }
Exemplo n.º 42
0
        public abstract bool GetTrampoline(TargetMemoryAccess memory, TargetAddress address,
						    out TargetAddress trampoline, out bool is_start);
Exemplo n.º 43
0
 // <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);
Exemplo n.º 44
0
        // <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);
Exemplo n.º 45
0
        internal abstract MethodSource GetTrampoline(TargetMemoryAccess memory,
							      TargetAddress address);
Exemplo n.º 46
0
        // <summary>
        //   Get the size of the current instruction.
        // </summary>
        public abstract int GetInstructionSize(TargetMemoryAccess memory,
							TargetAddress address);
Exemplo n.º 47
0
        internal virtual Block LookupBlock(TargetMemoryAccess memory,
						    TargetAddress address)
        {
            return null;
        }