public static bool GoTo(IFileTabManager fileTabManager, IModuleLoader moduleLoader, CorFrame frame, bool newTab) {
			if (GoToIL(fileTabManager, moduleLoader, frame, newTab))
				return true;

			//TODO: eg. native frame or internal frame

			return false;
		}

		public static bool GoTo(IModuleIdProvider moduleIdProvider, IDocumentTabService documentTabService, IModuleLoader moduleLoader, CorFrame frame, bool newTab) {
			if (GoToIL(moduleIdProvider, documentTabService, moduleLoader, frame, newTab))
				return true;

			//TODO: eg. native frame or internal frame

			return false;
		}

		public static bool GoTo(CorFrame frame, bool newTab) {
			if (GoToIL(frame, newTab))
				return true;

			//TODO: eg. native frame or internal frame

			return false;
		}

		public static bool CanGoToDisasm(CorFrame frame) {
			if (frame == null)
				return false;
			if (!frame.IsNativeFrame)
				return false;

			return false;//TODO:
		}

		public static bool GoToIL(CorFrame frame, bool newTab) {
			if (!CanGoToIL(frame))
				return false;

			var func = frame.Function;
			if (func == null)
				return false;

			return DebugUtils.GoToIL(ModuleLoader.Instance.LoadModule(func.Module, true), frame.Token, frame.GetILOffset(), newTab);
		}

		public static bool GoToIL(IFileTabManager fileTabManager, IModuleLoader moduleLoader, CorFrame frame, bool newTab) {
			if (!CanGoToIL(frame))
				return false;

			var func = frame.Function;
			if (func == null)
				return false;

			return DebugUtils.GoToIL(fileTabManager, moduleLoader.LoadModule(func.Module, true), frame.Token, frame.GetILOffset(moduleLoader), newTab);
		}

		public ValueContext(ILocalsOwner localsOwner, CorFrame frame, DnThread thread) {
			this.LocalsOwner = localsOwner;
			this.Thread = thread;
			this.Process = thread.Process;

			// Read everything immediately since the frame will be neutered when Continue() is called
			this.FrameCouldBeNeutered = frame;
			frame.GetTypeAndMethodGenericParameters(out genericTypeArguments, out genericMethodArguments);
			this.Function = frame.Function;
		}

		public static bool GoToIL(IModuleIdProvider moduleIdProvider, IDocumentTabService documentTabService, IModuleLoader moduleLoader, CorFrame frame, bool newTab) {
			if (!CanGoToIL(frame))
				return false;

			var func = frame.Function;
			if (func == null)
				return false;

			return DebugUtils.GoToIL(moduleIdProvider, documentTabService, moduleLoader.LoadModule(func.Module, canLoadDynFile: true, isAutoLoaded: true), frame.Token, frame.GetILOffset(moduleLoader), newTab);
		}

		public ValueContext(ILocalsOwner localsOwner, CorFrame frame, DnThread thread, IList<CorType> genericTypeArguments) {
			this.LocalsOwner = localsOwner;
			this.Thread = thread;
			this.Process = thread.Process;

			// Read everything immediately since the frame will be neutered when Continue() is called
			this.FrameCouldBeNeutered = frame;
			this.genericTypeArguments = genericTypeArguments;
			this.genericMethodArguments = new CorType[0];
			this.Function = frame == null ? null : frame.Function;
		}

		public static bool CanGoToIL(CorFrame frame) {
			if (frame == null)
				return false;
			if (!frame.IsILFrame)
				return false;
			var ip = frame.ILFrameIP;
			if (!ip.IsExact && !ip.IsApproximate && !ip.IsProlog && !ip.IsEpilog)
				return false;
			if (frame.Token == 0)
				return false;

			return true;
		}

        CorFrame GetRunToCallee(CorFrame frame)
        {
            if (!CanStep(frame))
                return null;
            if (frame == null)
                return null;
            if (!frame.IsILFrame)
                return null;
            var callee = frame.Callee;
            if (callee == null)
                return null;
            if (!callee.IsILFrame)
                return null;

            return callee;
        }

        CorStepper CreateStepper(CorFrame frame)
        {
            if (frame == null)
                return null;

            var stepper = frame.CreateStepper();
            if (stepper == null)
                return null;
            if (!stepper.SetInterceptMask(debugOptions.StepperInterceptMask))
                return null;
            if (!stepper.SetUnmappedStopMask(debugOptions.StepperUnmappedStopMask))
                return null;
            if (!stepper.SetJMC(debugOptions.StepperJMC))
                return null;

            return stepper;
        }

        CodeLocation? GetCodeLocation(CorFrame frame)
        {
            if (ProcessState != DebuggerProcessState.Stopped)
                return null;
            if (frame == null)
                return null;
            var sma = frame.GetSerializedDnModuleWithAssembly();
            if (sma == null)
                return null;
            uint token = frame.Token;
            if (token == 0)
                return null;

            return new CodeLocation(sma.Value, token, frame.GetILOffset(), frame.ILFrameIP.Mapping);
        }

        static MethodKey? CreateMethodKey(DnDebugger debugger, CorFrame frame)
        {
            var sma = frame.GetSerializedDnModuleWithAssembly();
            if (sma == null)
                return null;

            return MethodKey.Create(frame.Token, sma.Value.Module);
        }

        internal void UpdateCurrentLocation(CorFrame frame)
        {
            var newLoc = GetCodeLocation(frame);

            if (currentLocation == null || newLoc == null) {
                currentLocation = newLoc;
                UpdateCurrentMethod();
                return;
            }
            if (!CodeLocation.SameMethod(currentLocation.Value, newLoc.Value)) {
                currentLocation = newLoc;
                UpdateCurrentMethod();
                return;
            }

            currentLocation = newLoc;
        }

        public void RunTo(CorFrame frame)
        {
            if (!CanRunTo(frame))
                return;

            Debugger.RunTo(frame);
        }

 /// <summary>
 /// Step out of current method in the selected frame
 /// </summary>
 /// <param name="frame">Frame</param>
 /// <param name="action">Delegate to call when completed or null</param>
 /// <returns></returns>
 public bool StepOut(CorFrame frame, Action<DnDebugger, StepCompleteDebugCallbackEventArgs> action = null)
 {
     DebugVerifyThread();
     return StepOutInternal(frame, action);
 }

        public bool RunTo(CorFrame frame)
        {
            DebugVerifyThread();
            var callee = GetRunToCallee(frame);
            if (callee == null)
                return false;

            return StepOutInternal(callee, null);
        }

 public bool CanRunTo(CorFrame frame)
 {
     DebugVerifyThread();
     return GetRunToCallee(frame) != null;
 }

        bool StepIntoOver(CorFrame frame, StepRange[] ranges, bool stepInto, Action<DnDebugger, StepCompleteDebugCallbackEventArgs> action = null)
        {
            if (ranges == null)
                return StepIntoOver(frame, stepInto, action);
            if (!CanStep(frame))
                return false;

            var stepper = CreateStepper(frame);
            if (stepper == null)
                return false;
            if (!stepper.StepRange(stepInto, ranges))
                return false;

            stepInfos.Add(stepper, new StepInfo(action));
            Continue();
            return true;
        }