internal StackFrame(Thread thread, ICorDebugILFrame corILFrame, uint chainIndex, uint frameIndex) { this.process = thread.Process; this.thread = thread; this.appDomain = process.AppDomains[corILFrame.GetFunction().GetClass().GetModule().GetAssembly().GetAppDomain()]; this.corILFrame = corILFrame; this.corILFramePauseSession = process.PauseSession; this.corFunction = corILFrame.GetFunction(); this.chainIndex = chainIndex; this.frameIndex = frameIndex; MetaDataImport metaData = thread.Process.Modules[corFunction.GetClass().GetModule()].MetaData; int methodGenArgs = metaData.EnumGenericParams(corFunction.GetToken()).Length; // Class parameters are first, then the method ones List<ICorDebugType> corGenArgs = ((ICorDebugILFrame2)corILFrame).EnumerateTypeParameters().ToList(); // Remove method parametrs at the end corGenArgs.RemoveRange(corGenArgs.Count - methodGenArgs, methodGenArgs); List<DebugType> genArgs = new List<DebugType>(corGenArgs.Count); foreach(ICorDebugType corGenArg in corGenArgs) { genArgs.Add(DebugType.CreateFromCorType(this.AppDomain, corGenArg)); } DebugType debugType = DebugType.CreateFromCorClass( this.AppDomain, null, corFunction.GetClass(), genArgs.ToArray() ); this.methodInfo = (DebugMethodInfo)debugType.GetMember(corFunction.GetToken()); }
public static IMethod Import(this ICompilation compilation, ICorDebugFunction corFunction) { Module module = compilation.GetAppDomain().Process.GetModule(corFunction.GetModule()); if (module.IsDynamic || module.IsInMemory) { return(module.Assembly.GetTypeDefinition("", "UnknownDynamicType").Methods.First()); } var info = GetInfo(module.Assembly); uint functionToken = corFunction.GetToken(); var unresolvedMethod = info.GetMethodFromToken(functionToken); if (unresolvedMethod == null) { // The type containing this function wasn't loaded yet uint classToken = corFunction.GetClass().GetToken(); var definition = ToTypeDefinitionReference(module, classToken).Resolve(new SimpleTypeResolveContext(module.Assembly)).GetDefinition(); if (definition == null) { throw new InvalidOperationException("Could not find class for token " + classToken); } definition.Methods.ToList(); // enforce loading the methods so that they get added to the dictionary unresolvedMethod = info.GetMethodFromToken(functionToken); if (unresolvedMethod == null) { throw new InvalidOperationException("Could not find function with token " + functionToken); } } return(unresolvedMethod.Resolve(new SimpleTypeResolveContext(module.Assembly))); }
public static SourcecodeSegment ResolveForIL(Module module, ICorDebugFunction corFunction, int line, int offset, int[] ranges) { if (ranges == null) { return(null); // this would lead to a catched exception and the same result } try { SourcecodeSegment segment = new SourcecodeSegment(); segment.module = module; segment.typename = null; segment.checkSum = null; segment.startLine = line; segment.startColumn = 0; segment.endLine = line; segment.endColumn = 0; segment.corFunction = corFunction; segment.ilStart = offset; segment.ilEnd = ranges[1]; segment.stepRanges = ranges; return(segment); } catch { return(null); } }
public FunctionRemapCompleteDebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction) : base(pAppDomain) { AppDomain = pAppDomain; Thread = pThread; Function = pFunction; }
internal StackFrame(Thread thread, ICorDebugILFrame corILFrame, uint chainIndex, uint frameIndex) { this.process = thread.Process; this.thread = thread; this.appDomain = process.AppDomains[corILFrame.GetFunction().GetClass().GetModule().GetAssembly().GetAppDomain()]; this.corILFrame = corILFrame; this.corILFramePauseSession = process.PauseSession; this.corFunction = corILFrame.GetFunction(); this.chainIndex = chainIndex; this.frameIndex = frameIndex; MetaDataImport metaData = thread.Process.Modules[corFunction.GetClass().GetModule()].MetaData; int methodGenArgs = metaData.EnumGenericParams(corFunction.GetToken()).Length; // Class parameters are first, then the method ones List <ICorDebugType> corGenArgs = ((ICorDebugILFrame2)corILFrame).EnumerateTypeParameters().ToList(); // Remove method parametrs at the end corGenArgs.RemoveRange(corGenArgs.Count - methodGenArgs, methodGenArgs); List <DebugType> genArgs = new List <DebugType>(corGenArgs.Count); foreach (ICorDebugType corGenArg in corGenArgs) { genArgs.Add(DebugType.CreateFromCorType(this.AppDomain, corGenArg)); } DebugType debugType = DebugType.CreateFromCorClass( this.AppDomain, null, corFunction.GetClass(), genArgs.ToArray() ); this.methodInfo = (DebugMethodInfo)debugType.GetMember(corFunction.GetToken()); }
public EditAndContinueRemapDebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction, int fAccurate) : base(pAppDomain) { AppDomain = pAppDomain; Thread = pThread; Function = pFunction; Accurate = fAccurate != 0; }
int ICorDebugObjectValue.GetVirtualMethod(uint memberRef, out ICorDebugFunction ppFunction) { uint mdVirtual = Engine.GetVirtualMethod(nanoCLR_TypeSystem.ClassMemberIndexFromCLRToken(memberRef, m_class.Assembly), _rtv); ppFunction = nanoCLR_TypeSystem.CorDebugFunctionFromMethodIndex(mdVirtual, _appDomain); return(COM_HResults.S_OK); }
public virtual void EditAndContinueRemap( ICorDebugAppDomain appDomain, ICorDebugThread thread, ICorDebugFunction function, bool accurate) { this.DefaultHandler(appDomain); }
public FunctionRemapOpportunityDebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) : base(pAppDomain) { AppDomain = pAppDomain; Thread = pThread; OldFunction = pOldFunction; NewFunction = pNewFunction; OldILOffset = oldILOffset; }
public virtual void FunctionRemapOpportunity( ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) { pAppDomain.Continue(0); }
internal RuntimeFunction GetFunction(ICorDebugFunction comFunction) { RuntimeFunction function; if (!_cachedFunctions.TryGetValue(comFunction, out function)) { _cachedFunctions.Add(comFunction, function = new RuntimeFunction(this, comFunction)); } return(function); }
void ICorDebugManagedCallback2.FunctionRemapComplete( ICorDebugAppDomain appDomain, ICorDebugThread thread, ICorDebugFunction managedFunction) { if (DebugOutput) { Console.WriteLine("info: FunctionRemapComplete2"); } appDomain.Continue(0); }
public CorFunction(ICorDebugFunction funtion) { corFunction = funtion; ICorDebugModule imodule = null; corFunction.GetModule(out imodule); module = new CorModule(imodule); corFunction.GetToken(out token); //corFunction.GetLocalVarSigToken( //ICorDebugFunctionBreakpoint breakPoint = null; //corFunction. }
/// <summary> /// Finds appropriete SequncePointMap instances and builds SequencePointRemapper, gets new IL offset and call RemapFunction. /// </summary> public void FunctionRemapOpportunity(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) { ICorDebugILFrame2 frame = (ICorDebugILFrame2) pThread.GetActiveFrame(); uint nToken = pOldFunction.GetToken(); SequencePointRemapper remapper; if(!remappers.TryGetValue(nToken,out remapper)){ throw new KeyNotFoundException("Methods sequence points not found."); } frame.__RemapFunction(remapper.TranslateILOffset(oldILOffset)); }
void ICorDebugManagedCallback.EditAndContinueRemap( ICorDebugAppDomain appDomain, ICorDebugThread thread, ICorDebugFunction managedFunction, int isAccurate) { if (DebugOutput) { Console.WriteLine("info: EditAndContinueRemap"); } appDomain.Continue(0); }
int ICorDebugObjectValue.GetVirtualMethod(uint memberRef, out ICorDebugFunction ppFunction) { var getVirtualMethod = Engine.GetVirtualMethodAsync(nanoCLR_TypeSystem.ClassMemberIndexFromCLRToken(memberRef, this.m_class.Assembly), this.m_rtv); getVirtualMethod.Wait(); uint mdVirtual = getVirtualMethod.Result; ppFunction = nanoCLR_TypeSystem.CorDebugFunctionFromMethodIndex(mdVirtual, this.m_appDomain); return(COM_HResults.S_OK); }
void ICorDebugManagedCallback2.FunctionRemapOpportunity( ICorDebugAppDomain appDomain, ICorDebugThread thread, ICorDebugFunction oldFunction, ICorDebugFunction newFunction, uint oldILoffset) { if (DebugOutput) { Console.WriteLine("info: FunctionRemapOpportunity2"); } appDomain.Continue(0); }
public void SetBreakpoint(Module module) { foreach (var symbolSource in module.Process.Debugger.SymbolSources) { foreach (var seq in symbolSource.GetSequencePoints(module, this.FileName, this.Line, this.Column)) { ICorDebugFunction corFunction = module.CorModule.GetFunctionFromToken(seq.MethodDefToken); ICorDebugFunctionBreakpoint corBreakpoint = corFunction.GetILCode().CreateBreakpoint((uint)seq.ILOffset); corBreakpoint.Activate(enabled ? 1 : 0); corBreakpoints.Add(corBreakpoint); } } }
public CorType GetVirtualMethodAndType(int memberToken, out CorFunction managedFunction) { ICorDebugType dt = null; ICorDebugFunction pfunc = null; (m_objVal as ICorDebugObjectValue2).GetVirtualMethodAndType((uint)memberToken, out pfunc, out dt); if (pfunc == null) { managedFunction = null; } else { managedFunction = new CorFunction(pfunc); } return(dt == null ? null : new CorType(dt)); }
public static IMethod Import(this ICompilation compilation, ICorDebugFunction corFunction, List <ICorDebugType> typeArgs) { IMethod definition = Import(compilation, corFunction); if (typeArgs == null || typeArgs.Count == 0) { return(definition); } int classTPC = definition.DeclaringTypeDefinition.TypeParameterCount; IType[] classTPs = typeArgs.Take(classTPC).Select(t => compilation.Import(t)).ToArray(); IType[] methodTPs = null; if (definition.TypeParameters.Count > 0) { methodTPs = typeArgs.Skip(classTPC).Select(t => compilation.Import(t)).ToArray(); } return(new SpecializedMethod(definition, new TypeParameterSubstitution(classTPs, methodTPs))); }
internal Function(Thread thread, FrameID frameID, ICorDebugILFrame corILFrame) { this.process = thread.Process; this.thread = thread; this.frameID = frameID; this.CorILFrame = corILFrame; corFunction = corILFrame.Function; module = process.GetModule(corFunction.Module); methodProps = module.MetaData.GetMethodProps(corFunction.Token); // Force some callback when function steps out so that we can expire it stepOutStepper = new Stepper(this, "Function Tracker"); stepOutStepper.StepOut(); stepOutStepper.PauseWhenComplete = false; process.TraceMessage("Function " + this.ToString() + " created"); }
int ICorDebugEval.NewObject(ICorDebugFunction pConstructor, uint nArgs, ICorDebugValue[] ppArgs) { Debug.Assert(nArgs == ppArgs.Length); CorDebugFunction f = (CorDebugFunction)pConstructor; CorDebugClass c = f.Class; this.Process.SetCurrentAppDomain(this.AppDomain); Engine.AllocateObject(GetScratchPadLocation(), c.TypeDef_Index); ICorDebugValue[] args = new ICorDebugValue[nArgs + 1]; args[0] = GetResultValue(); ppArgs.CopyTo(args, 1); ((ICorDebugEval)this).CallFunction(pConstructor, (uint)args.Length, args); return(Utility.COM_HResults.S_OK); }
internal StackFrame(Thread thread, ICorDebugILFrame corILFrame, uint chainIndex, uint frameIndex) { this.process = thread.Process; this.thread = thread; this.corILFrame = corILFrame; this.corILFramePauseSession = process.PauseSession; this.corFunction = corILFrame.Function; this.chainIndex = chainIndex; this.frameIndex = frameIndex; DebugType debugType = DebugType.Create( this.Process, corFunction.Class, corILFrame.CastTo <ICorDebugILFrame2>().EnumerateTypeParameters().ToList().ToArray() ); this.methodInfo = debugType.GetMethod(corFunction.Token); }
/// <summary> /// Get a method from a managed type, method name and argument count /// </summary> public static MethodInfo GetFromName(Process process, System.Type type, string name, int paramCount) { if (type.IsNested) { throw new DebuggerException("Not implemented for nested types"); } if (type.IsGenericType) { throw new DebuggerException("Not implemented for generic types"); } if (type.IsGenericParameter) { throw new DebuggerException("Type can not be generic parameter"); } foreach (Module module in process.Modules) { TypeDefProps typeDefProps; try { typeDefProps = module.MetaData.FindTypeDefByName(type.FullName, 0 /* enclosing class for nested */); } catch { continue; } foreach (MethodProps methodProps in module.MetaData.EnumMethodsWithName(typeDefProps.Token, name)) { if (module.MetaData.GetParamCount(methodProps.Token) == paramCount) { ICorDebugFunction corFunction = module.CorModule.GetFunctionFromToken(methodProps.Token); ICorDebugClass2 corClass = corFunction.Class.As <ICorDebugClass2>(); ICorDebugType corType = corClass.GetParameterizedType(type.IsValueType ? (uint)CorElementType.VALUETYPE : (uint)CorElementType.CLASS, 0, new ICorDebugType[] {}); return(new MethodInfo(DebugType.Create(process, corType), methodProps)); } } } throw new DebuggerException("Not found"); }
public void RunTo(string fileName, int line, int column) { foreach (var symbolSource in this.Debugger.SymbolSources) { foreach (Module module in this.Modules) { // Note the we might get multiple matches foreach (SequencePoint seq in symbolSource.GetSequencePoints(module, fileName, line, column)) { ICorDebugFunction corFunction = module.CorModule.GetFunctionFromToken(seq.MethodDefToken); ICorDebugFunctionBreakpoint corBreakpoint = corFunction.GetILCode().CreateBreakpoint((uint)seq.ILOffset); corBreakpoint.Activate(1); this.tempBreakpoints.Add(corBreakpoint); if (this.IsPaused) { AsyncContinue(); } } } } }
public void EditAndContinueRemap(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction, int fAccurate) { try { _EnterCallback(); _CallbackNotImplemented(); _CallbackEvent("EditAndContinueRemap"); } catch (Exception e) { _CallbackException(e); } }
public void FunctionRemapComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction) { try { _EnterCallback(); _CallbackNotImplemented(); _CallbackEvent("FunctionRemapComplete"); } catch (Exception e) { _CallbackException(e); } }
public virtual void FunctionRemapOpportunity( ICorDebugAppDomain appDomain, ICorDebugThread thread, ICorDebugFunction oldFunction, ICorDebugFunction newFunction, int oldIlOffset) { this.DefaultHandler(appDomain); }
int ICorDebugEval.CallFunction(ICorDebugFunction pFunction, uint nArgs, ICorDebugValue[] ppArgs) { try { //CreateThread will cause a thread create event to occur. This is a virtual thread, so //we need to suspend processing of tinyclr commands until we have created the thread ourselves //and the processing of a new virtual thread will be ignored. Process.SuspendCommands(true); //need to flush the breakpoints in case new breakpoints were waiting until process was resumed. Process.UpdateBreakpoints(); Debug.Assert(nArgs == ppArgs.Length); Debug.Assert(Process.IsExecutionPaused); CorDebugFunction function = (CorDebugFunction)pFunction; uint md = function.MethodDef_Index; if (function.IsVirtual && function.IsInstance) { Debug.Assert(nArgs > 0); md = this.Engine.GetVirtualMethod(function.MethodDef_Index, ((CorDebugValue)ppArgs[0]).RuntimeValue); } this.Process.SetCurrentAppDomain(this.AppDomain); //Send the selected thread ID to the device so calls that use Thread.CurrentThread work as the user expects. uint pid = this.Engine.CreateThread(md, GetScratchPadLocation(), m_threadReal.ID); if (pid == uint.MaxValue) { throw new ArgumentException("TinyCLR cannot call this function. Possible reasons include: ByRef arguments not supported"); } //If anything below fails, we need to clean up by killing the thread if (nArgs > 0) { RuntimeValue[] args = this.Engine.GetStackFrameValueAll(pid, 0, function.NumArg, Engine.StackValueKind.Argument); for (int iArg = 0; iArg < nArgs; iArg++) { CorDebugValue valSrc = (CorDebugValue)ppArgs[iArg]; CorDebugValue valDst = CorDebugValue.CreateValue(args[iArg], m_appDomain); if (valDst.RuntimeValue.Assign(valSrc.RuntimeValue) == null) { throw new ArgumentException("TinyCLR cannot set argument " + iArg); } } } m_threadVirtual = new CorDebugThread(this.Process, pid, this); m_threadReal.AttachVirtualThread(m_threadVirtual); Debug.Assert(!m_fActive); m_fActive = true; //It is possible that a hard breakpoint is hit, the first line of the function //to evaluate. If that is the case, than breakpoints need to be drained so the //breakpoint event is fired, to avoid a race condition, where cpde resumes //execution to start the function eval before it gets the breakpoint event //This is primarily due to the difference in behavior of the TinyCLR and the desktop. //In the desktop, the hard breakpoint will not get hit until execution is resumed. //The TinyCLR can hit the breakpoint during the Thread_Create call. Process.DrainBreakpoints(); } finally { Process.SuspendCommands(false); } return(Utility.COM_HResults.S_OK); }
public void FunctionRemapOpportunity(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) { ManagedCallback managedCallback = GetProcessCallbackInterface("FunctionRemapOpportunity", pAppDomain); if (managedCallback != null) { managedCallback.FunctionRemapOpportunity(pAppDomain, pThread, pOldFunction, pNewFunction, oldILOffset); } }
public static void CallFunction(this ICorDebugEval instance, ICorDebugFunction pFunction, uint nArgs, ICorDebugValue[] ppArgs) { instance.__CallFunction(pFunction, nArgs, ppArgs); }
void ICorDebugManagedCallback.EditAndContinueRemap(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction, int fAccurate) { // TODO HandleEvent(ManagedCallbackType.On new CorEventArgs(new CorAppDomain(pAppDomain))); }
int ICorDebugEval2.NewParameterizedObject(ICorDebugFunction pConstructor, uint nTypeArgs, ICorDebugType[] ppTypeArgs, uint nArgs, ICorDebugValue[] ppArgs) { return(((ICorDebugEval)this).NewObject(pConstructor, nArgs, ppArgs)); }
public void EditAndContinueRemap(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction, int fAccurate) { ManagedCallback managedCallback = GetProcessCallbackInterface("EditAndContinueRemap", pAppDomain); if (managedCallback != null) { managedCallback.EditAndContinueRemap(pAppDomain, pThread, pFunction, fAccurate); } }
public static void CallParameterizedFunction(this ICorDebugEval2 instance, ICorDebugFunction pFunction, uint nTypeArgs, ICorDebugType[] ppTypeArgs, uint nArgs, ICorDebugValue[] ppArgs) { instance.__CallParameterizedFunction(pFunction, nTypeArgs, ppTypeArgs, nArgs, ppArgs); }
void ICorDebugManagedCallback2.FunctionRemapOpportunity(ICorDebugAppDomain appDomain, ICorDebugThread thread, ICorDebugFunction oldFunction, ICorDebugFunction newFunction, uint oldILoffset) { HandleEvent(ManagedCallbackType.OnFunctionRemapOpportunity, new CorFunctionRemapOpportunityEventArgs(appDomain == null ? null : new CorAppDomain(appDomain), thread == null ? null : new CorThread(thread), oldFunction == null ? null : new CorFunction(oldFunction), newFunction == null ? null : new CorFunction(newFunction), (int)oldILoffset, ManagedCallbackType.OnFunctionRemapOpportunity)); }
int ICorDebugFunctionBreakpoint.GetFunction(out ICorDebugFunction ppFunction) { ppFunction = m_function; return(COM_HResults.S_OK); }
public EditAndContinueRemapDebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction, int fAccurate) : base(pAppDomain) { this.AppDomain = pAppDomain; this.Thread = pThread; this.Function = pFunction; this.Accurate = fAccurate != 0; }
public void FunctionRemapOpportunity(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) { try { _EnterCallback(); _CallbackNotImplemented(); _CallbackEvent("FunctionRemapOpportunity"); } catch (Exception e) { _CallbackException(e); } }
void ICorDebugManagedCallback2.FunctionRemapComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction) { // TODO HandleEvent(<new CorEventArgs(new CorAppDomain(pAppDomain))); }
public void FunctionRemapOpportunity(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) { ManagedCallback managedCallback = GetProcessCallbackInterface(pAppDomain); if (managedCallback != null) { managedCallback.FunctionRemapOpportunity(pAppDomain, pThread, pOldFunction, pNewFunction, oldILOffset); } }
int ICorDebugEval2.CallParameterizedFunction(ICorDebugFunction pFunction, uint nTypeArgs, ICorDebugType[] ppTypeArgs, uint nArgs, ICorDebugValue[] ppArgs) { return(((ICorDebugEval)this).CallFunction(pFunction, nArgs, ppArgs)); }
internal CorFunction(ICorDebugFunction managedFunction) : base(managedFunction) { m_function = managedFunction; }
public void EditAndContinueRemap(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction, int fAccurate) { EnterCallback("EditAndContinueRemap", pThread); ExitCallback(); }
void ICorDebugManagedCallback2.FunctionRemapOpportunity(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) { var ev = new CorEventArgs(new CorAppDomain(pAppDomain, p_options)); GetOwner(ev.Controller).DispatchEvent(ev); FinishEvent(ev); }
public void FunctionRemapOpportunity(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) { EnterCallback("FunctionRemapOpportunity", pThread); ExitCallback(); }
internal RuntimeFunction(RuntimeModule module, ICorDebugFunction comFunction) { _module = module; _comFunction = comFunction; }
public void FunctionRemapComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction) { ManagedCallback managedCallback = GetProcessCallbackInterface("FunctionRemapComplete", pAppDomain); if (managedCallback != null) { managedCallback.FunctionRemapComplete(pAppDomain, pThread, pFunction); } }
public DebugFunction(ICorDebugFunction function) { _function = function; }
public void EditAndContinueRemap(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction, int fAccurate) { pAppDomain.Continue(0); }
public void FunctionRemapComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction) { EnterCallback("FunctionRemapComplete", pThread); ExitCallback(); }
public void FunctionRemapComplete(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction) { pAppDomain.Continue(0); }
public void FunctionRemapOpportunity(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) { pAppDomain.Continue(0); }
public FunctionRemapOpportunityDebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pOldFunction, ICorDebugFunction pNewFunction, uint oldILOffset) : base(pAppDomain) { this.AppDomain = pAppDomain; this.Thread = pThread; this.OldFunction = pOldFunction; this.NewFunction = pNewFunction; this.OldILOffset = oldILOffset; }
public virtual void FunctionRemapComplete( ICorDebugAppDomain appDomain, ICorDebugThread thread, ICorDebugFunction function) { this.DefaultHandler(appDomain); }
void ICorDebugManagedCallback.EditAndContinueRemap( ICorDebugAppDomain appDomain, ICorDebugThread thread, ICorDebugFunction managedFunction, int isAccurate) { Debug.Assert(false); //OBSOLETE callback }
public FunctionRemapCompleteDebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugThread pThread, ICorDebugFunction pFunction) : base(pAppDomain) { this.AppDomain = pAppDomain; this.Thread = pThread; this.Function = pFunction; }
void ICorDebugManagedCallback2.FunctionRemapComplete(ICorDebugAppDomain appDomain, ICorDebugThread thread, ICorDebugFunction managedFunction) { HandleEvent(ManagedCallbackType.OnFunctionRemapComplete, new CorFunctionRemapCompleteEventArgs(appDomain == null ? null : new CorAppDomain(appDomain), thread == null ? null : new CorThread(thread), managedFunction == null ? null : new CorFunction(managedFunction), ManagedCallbackType.OnFunctionRemapComplete)); }
// Returns true if found internal bool GetFunctionAndOffset(Module module, bool normailize, out ICorDebugFunction function, out int ilOffset) { function = null; ilOffset = 0; ISymUnmanagedReader symReader = module.SymReader; if (symReader == null) { return false; // No symbols } ISymUnmanagedDocument symDoc = null; symDoc = symReader.GetDocument(SourceFullFilename, Guid.Empty, Guid.Empty, Guid.Empty); if (symDoc == null) { return false; // Does not use source file } uint validLine; try { validLine = symDoc.FindClosestLine((uint)StartLine); } catch { return false; // Not on a vaild point } if (validLine != StartLine && normailize) { StartLine = (int)validLine; EndLine = (int)validLine; StartColumn = 0; EndColumn = 0; } ISymUnmanagedMethod symMethod; try { symMethod = symReader.GetMethodFromDocumentPosition(symDoc, validLine, 0); } catch { return false; //Not found } // Check that StartLine is within the method uint start = uint.MaxValue; uint end = uint.MinValue; foreach(SequencePoint sqPoint in symMethod.SequencePoints) { if (sqPoint.Line == 0xFEEFEE) continue; start = Math.Min(start, sqPoint.Line); end = Math.Max(end, sqPoint.EndLine); } if (StartLine < start || StartLine > end) return false; function = module.CorModule.GetFunctionFromToken(symMethod.Token); ilOffset = (int)symMethod.GetOffset(symDoc, validLine, 0); return true; }