pascalabcnet/VisualPascalABCNETLinux/MonoDebugging/Soft/SoftDebuggerSession.cs

// 
// SoftDebuggerSession.cs
//  
// Authors: Lluis Sanchez Gual <lluis@novell.com>
//          Jeffrey Stedfast <jeff@xamarin.com>
// 
// Copyright (c) 2009 Novell, Inc (http://www.novell.com)
// Copyright (c) 2012 Xamarin Inc. (http://www.xamarin.com)
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

//#define DEBUG_EVENT_QUEUEING

using System;
using System.IO;
using System.Net;
using System.Linq;
using System.Text;
using System.Threading;
using System.Reflection;
using System.Net.Sockets;
using System.Globalization;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Text.RegularExpressions;

using Mono.Debugger.Soft;

using Mono.Debugging.Client;
using Mono.Debugging.Evaluation;

using StackFrame = Mono.Debugger.Soft.StackFrame;
using Assembly = Mono.Debugging.Client.Assembly;

namespace Mono.Debugging.Soft
{
	public class SoftDebuggerSession : DebuggerSession
	{
		readonly Dictionary<AppDomainMirror, HashSet<AssemblyMirror>> domainAssembliesToUnload = new Dictionary<AppDomainMirror, HashSet<AssemblyMirror>> ();
		readonly Dictionary<Tuple<TypeMirror, string>, MethodMirror[]> overloadResolveCache = new Dictionary<Tuple<TypeMirror, string>, MethodMirror[]> ();
		readonly Dictionary<string, List<TypeMirror>> source_to_type = new Dictionary<string, List<TypeMirror>> (PathComparer);
		readonly Dictionary<long,ObjectMirror> activeExceptionsByThread = new Dictionary<long, ObjectMirror> ();
		readonly Dictionary<EventRequest, BreakInfo> breakpoints = new Dictionary<EventRequest, BreakInfo> ();
		readonly Dictionary<TypeMirror, string[]> type_to_source = new Dictionary<TypeMirror, string[]> ();
		readonly Dictionary<string, List<TypeMirror>> aliases = new Dictionary<string, List<TypeMirror>> ();
		readonly Dictionary<string, List<TypeMirror>> types = new Dictionary<string, List<TypeMirror>> ();
		readonly LinkedList<List<Event>> queuedEventSets = new LinkedList<List<Event>> ();
		readonly Dictionary<long,long> localThreadIds = new Dictionary<long, long> ();
		readonly List<BreakInfo> pending_bes = new List<BreakInfo> ();
		TypeLoadEventRequest typeLoadReq, typeLoadTypeNameReq;
		ExceptionEventRequest unhandledExceptionRequest;
		Dictionary<string, string> assemblyPathMap;
		Dictionary<string, string> symbolPathMap;
		ThreadMirror current_thread, recent_thread;
		List<AssemblyMirror> assemblyFilters;
		StepEventRequest currentStepRequest;
		IConnectionDialog connectionDialog;
		Thread outputReader, errorReader;
		bool loggedSymlinkedRuntimesBug;
		SoftDebuggerStartArgs startArgs;
		List<string> userAssemblyNames;
		List<SourceUpdate> sourceUpdates;
		Mono.Debugging.Client.ThreadInfo[] current_threads;
		string remoteProcessName;
		long currentAddress = -1;
		IAsyncResult connection;
		int currentStackDepth;
		ProcessInfo[] procs;
		Thread eventHandler;
		VirtualMachine vm;
		bool autoStepInto;
		bool disposed;
		bool started;

		internal int StackVersion;

		public SoftDebuggerAdaptor Adaptor {
			get; private set;
		}

		public SoftDebuggerSession ()
		{
			Adaptor = CreateSoftDebuggerAdaptor ();
			Adaptor.BusyStateChanged += (sender, e) => SetBusyState (e);
			Adaptor.DebuggerSession = this;
			sourceUpdates = new List<SourceUpdate> ();
		}

		protected virtual SoftDebuggerAdaptor CreateSoftDebuggerAdaptor ()
		{
			return new SoftDebuggerAdaptor ();
		}

		public Version ProtocolVersion {
			get { return new Version (vm.Version.MajorVersion, vm.Version.MinorVersion); }
		}

		protected override void OnRun (DebuggerStartInfo startInfo)
		{
			if (HasExited)
				throw new InvalidOperationException ("Already exited");

			SetupProcessStartHooks ();
			
			var dsi = (SoftDebuggerStartInfo) startInfo;
			if (dsi.StartArgs is SoftDebuggerLaunchArgs) {
				remoteProcessName = Path.GetFileNameWithoutExtension (dsi.Command);
				StartLaunching (dsi);
			} else if (dsi.StartArgs is SoftDebuggerConnectArgs) {
				StartConnecting (dsi);
			} else if (dsi.StartArgs is SoftDebuggerListenArgs) {
				StartListening (dsi);
			} else if (dsi.StartArgs.ConnectionProvider != null) {
				StartConnection (dsi);
			} else {
				throw new ArgumentException ("StartArgs has no ConnectionProvider");
			}
		}
		
		void StartConnection (SoftDebuggerStartInfo dsi)
		{
			startArgs = dsi.StartArgs;
			
			RegisterUserAssemblies (dsi);
			
			if (!String.IsNullOrEmpty (dsi.LogMessage))
				OnDebuggerOutput (false, dsi.LogMessage + Environment.NewLine);
			
			AsyncCallback callback = null;
			int attemptNumber = 0;
			int maxAttempts = startArgs.MaxConnectionAttempts;
			int timeBetweenAttempts = startArgs.TimeBetweenConnectionAttempts;
			callback = delegate (IAsyncResult ar) {
				try {
					string appName;
					VirtualMachine machine;
					startArgs.ConnectionProvider.EndConnect (ar, out machine, out appName);
					remoteProcessName = appName;
					ConnectionStarted (machine);
					return;
				} catch (Exception ex) {
					attemptNumber++;
					if (!ShouldRetryConnection (ex, attemptNumber)
						|| startArgs?.ConnectionProvider?.ShouldRetryConnection (ex) == false
						|| attemptNumber == maxAttempts
						|| HasExited) {
						OnConnectionError (ex);
						return;
					}
				}
				try {
					if (timeBetweenAttempts > 0)
						Thread.Sleep (timeBetweenAttempts);
					ConnectionStarting (startArgs.ConnectionProvider.BeginConnect (dsi, callback), dsi, false, attemptNumber);
				} catch (Exception ex2) {
					OnConnectionError (ex2);
				}
			};
			//the "listening" value is never used, pass a dummy value
			ConnectionStarting (startArgs.ConnectionProvider.BeginConnect (dsi, callback), dsi, false, 0);
		}
		
		void StartLaunching (SoftDebuggerStartInfo dsi)
		{
			var args = (SoftDebuggerLaunchArgs) dsi.StartArgs;
			var executable = string.IsNullOrEmpty (args.MonoExecutableFileName) ? "mono" : args.MonoExecutableFileName;
			var runtime = string.IsNullOrEmpty (args.MonoRuntimePrefix) ? executable : Path.Combine (Path.Combine (args.MonoRuntimePrefix, "bin"), executable);
			RegisterUserAssemblies (dsi);
			
			var psi = new System.Diagnostics.ProcessStartInfo (runtime) {
				Arguments = string.Format ("{2} \"{0}\" {1}", dsi.Command, dsi.Arguments, dsi.RuntimeArguments),
				WorkingDirectory = dsi.WorkingDirectory,
				RedirectStandardOutput = true,
				RedirectStandardInput = true,
				RedirectStandardError = true,
				UseShellExecute = false,
				CreateNoWindow = true,
			};
#if (DEBUG)
			Console.WriteLine(psi.Arguments);
#endif
			LaunchOptions options = null;
			
			if (dsi.UseExternalConsole && args.ExternalConsoleLauncher != null) {
				options = new LaunchOptions ();
				options.CustomTargetProcessLauncher = args.ExternalConsoleLauncher;
				psi.RedirectStandardOutput = false;
				psi.RedirectStandardError = false;
			}
			if (args.CustomProcessLauncher != null) {
				options = options ?? new LaunchOptions ();
				options.CustomProcessLauncher = args.CustomProcessLauncher;
			}

			var sdbLog = Environment.GetEnvironmentVariable ("MONODEVELOP_SDB_LOG");
			if (!string.IsNullOrEmpty (sdbLog)) {
				options = options ?? new LaunchOptions ();
				options.AgentArgs = string.Format ("loglevel=10,logfile='{0}',setpgid=y", sdbLog);
			}
			
			foreach (var env in args.MonoRuntimeEnvironmentVariables)
				psi.EnvironmentVariables[env.Key] = env.Value;
			
			foreach (var env in dsi.EnvironmentVariables)
				psi.EnvironmentVariables[env.Key] = env.Value;
			
			if (!string.IsNullOrEmpty (dsi.LogMessage))
				OnDebuggerOutput (false, dsi.LogMessage + Environment.NewLine);

			var callback = HandleConnectionCallbackErrors (ar => ConnectionStarted (VirtualMachineManager.EndLaunch (ar)));
			ConnectionStarting (VirtualMachineManager.BeginLaunch (psi, callback, options), dsi, true, 0);
		}
		
		/// <summary>Starts the debugger listening for a connection over TCP/IP</summary>
		protected void StartListening (SoftDebuggerStartInfo dsi)
		{
			int dp, cp;
			StartListening (dsi, out dp, out cp);
		}
		
		/// <summary>Starts the debugger listening for a connection over TCP/IP</summary>
		protected void StartListening (SoftDebuggerStartInfo dsi, out int assignedDebugPort)
		{
			int cp;
			StartListening (dsi, out assignedDebugPort, out cp);
		}
		
		/// <summary>Starts the debugger listening for a connection over TCP/IP</summary>
		protected void StartListening (SoftDebuggerStartInfo dsi, out int assignedDebugPort, out int assignedConsolePort)
		{
			IPEndPoint dbgEP, conEP;
			InitForRemoteSession (dsi, out dbgEP, out conEP);

			var callback = HandleConnectionCallbackErrors (ar => ConnectionStarted (VirtualMachineManager.EndListen (ar)));
			var a = VirtualMachineManager.BeginListen (dbgEP, conEP, callback, out assignedDebugPort, out assignedConsolePort);
			ConnectionStarting (a, dsi, true, 0);
		}

		protected virtual bool ShouldRetryConnection (Exception ex, int attemptNumber)
		{
			var sx = ex as SocketException;
			if (sx != null) {
				if (sx.ErrorCode == 10061) //connection refused
					return true;
			}
			//retry if it receives 0 byte and threw an exception in the handshake
			return true;
		}
		
		protected void StartConnecting (SoftDebuggerStartInfo dsi)
		{
			StartConnecting (dsi, dsi.StartArgs.MaxConnectionAttempts, dsi.StartArgs.TimeBetweenConnectionAttempts);
		}
		
		/// <summary>Starts the debugger connecting to a remote IP</summary>
		protected void StartConnecting (SoftDebuggerStartInfo dsi, int maxAttempts, int timeBetweenAttempts)
		{	
			if (timeBetweenAttempts < 0 || timeBetweenAttempts > 10000)
				throw new ArgumentException ("timeBetweenAttempts");
			
			IPEndPoint dbgEP, conEP;
			InitForRemoteSession (dsi, out dbgEP, out conEP);

			AsyncCallback callback = null;
			int attemptNumber = 0;
			callback = delegate (IAsyncResult ar) {
				try {
					ConnectionStarted (VirtualMachineManager.EndConnect (ar));
					return;
				} catch (Exception ex) {
					attemptNumber++;
					if (!ShouldRetryConnection (ex, attemptNumber) || attemptNumber == maxAttempts || HasExited) {
						OnConnectionError (ex);
						return;
					}
				}
				try {
					if (timeBetweenAttempts > 0)
						Thread.Sleep (timeBetweenAttempts);
					
					ConnectionStarting (VirtualMachineManager.BeginConnect (dbgEP, conEP, callback), dsi, false, attemptNumber);
					
				} catch (Exception ex2) {
					OnConnectionError (ex2);
				}
			};
			
			ConnectionStarting (VirtualMachineManager.BeginConnect (dbgEP, conEP, callback), dsi, false, 0);
		}
		
		void InitForRemoteSession (SoftDebuggerStartInfo dsi, out IPEndPoint dbgEP, out IPEndPoint conEP)
		{
			if (remoteProcessName != null)
				throw new InvalidOperationException ("Cannot initialize connection more than once");
			
			var args = (SoftDebuggerRemoteArgs) dsi.StartArgs;
			
			remoteProcessName = args.AppName;
			
			RegisterUserAssemblies (dsi);
			
			dbgEP = new IPEndPoint (args.Address, args.DebugPort);
			conEP = args.RedirectOutput? new IPEndPoint (args.Address, args.OutputPort) : null;
			
			if (!String.IsNullOrEmpty (dsi.LogMessage))
				OnDebuggerOutput (false, dsi.LogMessage + Environment.NewLine);
		}
		
		///<summary>Catches errors in async callbacks and hands off to OnConnectionError</summary>
		AsyncCallback HandleConnectionCallbackErrors (AsyncCallback callback)
		{
			return delegate (IAsyncResult ar) {
				connection = null;
				try {
					callback (ar);
				} catch (Exception ex) {
					OnConnectionError (ex);
				}
			};
		}
		
		/// <summary>
		/// Called if an error happens while making the connection. Default terminates the session.
		/// </summary>
		protected virtual void OnConnectionError (Exception ex)
		{
			//if the exception was caused by cancelling the session
			if (HasExited)
				return;
			
			if (!HandleException (new ConnectionException (ex))) {
				DebuggerLoggingService.LogAndShowException ("Unhandled error launching soft debugger", ex);
			}
			
			// The session is dead
			// HandleException doesn't actually handle exceptions, it just displays them.
			try {
				EndSession ();
			} catch (Exception e) {
				DebuggerLoggingService.LogError ("Unhandled error ending the debugger session", e);
			}
		}
		
		void ConnectionStarting (IAsyncResult connectionHandle, DebuggerStartInfo dsi, bool listening, int attemptNumber) 
		{
			if (connection != null && (attemptNumber == 0 || !connection.IsCompleted))
				throw new InvalidOperationException ("Already connecting");
			
			connection = connectionHandle;

			if (attemptNumber == 0) {
				if (ConnectionDialogCreatorExtended != null)
					connectionDialog = ConnectionDialogCreatorExtended (dsi);
				else if (ConnectionDialogCreator != null)
					connectionDialog = ConnectionDialogCreator ();

				if (connectionDialog != null) {
					connectionDialog.UserCancelled += delegate {
						EndSession ();
					};
				}
			}

			if (connectionDialog != null)
				connectionDialog.SetMessage (dsi, GetConnectingMessage (dsi), listening, attemptNumber);
		}
		
		protected virtual string GetConnectingMessage (DebuggerStartInfo dsi)
		{
			return null;
		}
		
		void EndLaunch ()
		{
			HideConnectionDialog ();
			if (connection != null) {
				try {
					if (startArgs != null && startArgs.ConnectionProvider != null) {
						startArgs.ConnectionProvider.CancelConnect(connection);
						startArgs = null;
					} else {
						VirtualMachineManager.CancelConnection(connection);
					}
				} catch(Exception e) {
					DebuggerLoggingService.LogError("Unhandled error canceling the debugger connection", e);
				}
				connection = null;
			}
		}
		
		protected virtual void EndSession ()
		{
			if (!HasExited) {
				EndLaunch ();
				OnTargetEvent (new TargetEventArgs (TargetEventType.TargetExited));
			}
		}

		public void ForceEndSession()
        {
			EndSession();
		}

		const string StartWithShellExecuteExMarker = "___Process_StartWithShellExecuteEx_Marker___";
		const string StartWithCreateProcessMarker = "___Process_StartWithCreateProcess_Marker__";
		const string SetProcessIdMarker = "___Process_SetProcessId_Marker__";

		void SetupProcessStartHooks ()
		{
			if (!Options.DebugSubprocesses)
				return;

			// Subprocess lauch is intercepted using 3 function breakpoints.
			// The first breakpoint is used to intercept calls to start a process with shell execute.
			var bp = Breakpoints.OfType< FunctionBreakpoint> ().FirstOrDefault (b => b.CustomActionId == StartWithShellExecuteExMarker);
			if (bp == null) {
				bp = new FunctionBreakpoint ("System.Diagnostics.Process.StartWithShellExecuteEx", "C#");
				bp.HitAction = HitAction.CustomAction;
				bp.CustomActionId = StartWithShellExecuteExMarker;
				bp.NonUserBreakpoint = true;
				Breakpoints.Add (bp);
			}

			// The second breakpoint is used to intercept calls to start a process with CreateProcess
			bp = Breakpoints.OfType<FunctionBreakpoint> ().FirstOrDefault (b => b.CustomActionId == StartWithCreateProcessMarker);
			if (bp == null) {
				bp = new FunctionBreakpoint ("System.Diagnostics.Process.StartWithCreateProcess", "C#");
				bp.HitAction = HitAction.CustomAction;
				bp.CustomActionId = StartWithCreateProcessMarker;
				bp.NonUserBreakpoint = true;
				Breakpoints.Add (bp);
			}

			// The third breakpoint is used to intercept the method that assigns an ID to the process. This is used to
			// retrieve the process id, and also as a signal that the process has started running
			bp = Breakpoints.OfType<FunctionBreakpoint> ().FirstOrDefault (b => b.CustomActionId == SetProcessIdMarker);
			if (bp == null) {
				bp = new FunctionBreakpoint ("System.Diagnostics.Process.SetProcessId", "C#");
				bp.HitAction = HitAction.CustomAction;
				bp.CustomActionId = SetProcessIdMarker;
				bp.NonUserBreakpoint = true;
				Breakpoints.Add (bp);
			}
		}

		bool HandleProcessStartHook (ThreadMirror thread, BreakEvent b)
		{
			if (!Options.DebugSubprocesses)
				return false;

			// Subprocess debugging is achieved by intercepting calls to start a process using function breakpoints.
			// This is achieved in 3 stages:
			// 1) Process start interception: this is done by adding a function breakpoint to Process.StartWithShellExecuteEx
			//    and Process.StartWithCreateProcess. If the process being launched is a mono process a new debug session
			//    is creaated, and the process start info object is patched to add the debugger agent configuration options.
			// 2) Process launch. This is actually done by the current executing process. The new process is bound to
			//    the new debug session. However, to complete the debug session initialization we need an actual reference
			//    to the process, so that the session can get the process id and subscribe process events, and that's
			//    done in step 3.
			// 3) Process launched interception: this is done by adding a function breakpoint to Process.SetProcessId.
			//    This method is called after starting the process, so at this point it is possible to get a reference
			//    to the running process object and assign it to the debug session to complete the initialization.

			// A potential process start call has been intercepted.

			var evalOptions = EvaluationOptions.DefaultOptions.Clone ();
			evalOptions.AllowTargetInvoke = evalOptions.AllowMethodEvaluation = evalOptions.FlattenHierarchy = true;
			evalOptions.GroupPrivateMembers = evalOptions.GroupStaticMembers = evalOptions.AllowToStringCalls = evalOptions.EllipsizeStrings = false;

			if (b.CustomActionId == StartWithShellExecuteExMarker || b.CustomActionId == StartWithCreateProcessMarker) {

				// A project start call has been intercepted. We need to check if a mono process is being started.

				var fr = thread.GetFrames ()[0];
				var ctx = new SoftEvaluationContext (this, fr, evalOptions);
				var eval = ctx.Evaluator;

				var parameters = eval.GetParameters (ctx);
				var startInfo = parameters.First();
				var exe = (string) startInfo.GetChild ("file_name", evalOptions).GetRawValue (evalOptions);

				// The process being launched is a mono process if the target file is a .exe or .dll, or if the launcher is mono.

				var ext = Path.GetExtension (exe).ToLower ();
				if (ext == ".exe" || ext == ".dll" || Subprocess.IsMonoLauncher (exe)) {

					// If the runtime arguments are already setting up a debugger agent, don't override it
					var arguments = (string)startInfo.GetChild ("Arguments", evalOptions).GetRawValue (evalOptions);
					if (arguments.Contains ("--debugger-agent"))
						return false;

					// Create the new debug session
					Subprocess sp;
					lock (subprocessesStarting) {
						sp = new Subprocess (GetId (thread), this);
						subprocessesStarting.Add (sp);
					}

					if (sp.CreateSession (startInfo, evalOptions)) {
						// Notify that the new session has started
						OnSubprocessStarted (sp.SubprocessSession);
					}
				}
				return true;
			} else if (b.CustomActionId == SetProcessIdMarker) {

				// A call to SetProcessId has been intercepted
				// Check if there is a subprocess waiting for the start signal

				var tid = GetId (thread);
				Subprocess subprocess;

				lock (subprocessesStarting)
					subprocess  = subprocessesStarting.FirstOrDefault (s => s.ThreadId == tid);

				if (subprocess != null) {
					lock (subprocessesStarting)
						subprocessesStarting.Remove (subprocess);

					var fr = thread.GetFrames ()[0];
					var ctx = new SoftEvaluationContext (this, fr, evalOptions);
					var eval = ctx.Evaluator;

					try {
						// The first parameter is the process ID
						var parameters = eval.GetParameters (ctx);
						var id = (int)parameters.First ().GetRawValue (evalOptions);

						// Get the start info object from the process
						var ts = eval.GetThisReference (ctx);
						var si = ts.GetChild ("startInfo", evalOptions);

						// Tell the subprocess that the process has started. This will finish the initialization
						// of the debug session.
						subprocess.SetStarted (si, id, ctx);
					} catch {
						subprocess.Shutdown ();
						throw;
					}
				}
				return true;
			}
			return false;
		}

		List<Subprocess> subprocessesStarting = new List<Subprocess> ();

		public Dictionary<Tuple<TypeMirror, string>, MethodMirror[]> OverloadResolveCache {
			get {
				return overloadResolveCache;
			}
		}
		
		void HideConnectionDialog ()
		{
			if (connectionDialog != null) {
				connectionDialog.Dispose ();
				connectionDialog = null;
			}
		}
		
		/// <summary>
		/// If subclasses do an async connect in OnRun, they should pass the resulting VM to this method.
		/// If the vm is null, the session will be closed.
		/// </summary>
		void ConnectionStarted (VirtualMachine machine)
		{
			if (vm != null)
				throw new InvalidOperationException ("The VM has already connected");
			
			if (machine == null) {
				EndSession ();
				return;
			}
			
			connection = null;
			
			vm = machine;

			// Allocate the process list now, so it is cached and can be queried while the session is running
			OnGetProcesses ();

			ConnectOutput (machine.StandardOutput, false);
			ConnectOutput (machine.StandardError, true);
			
			HideConnectionDialog ();
			
			machine.EnableEvents (EventType.AssemblyLoad, EventType.ThreadStart, EventType.ThreadDeath,
				EventType.AppDomainUnload, EventType.UserBreak, EventType.UserLog);
			try {
				unhandledExceptionRequest = machine.CreateExceptionRequest (null, false, true);
				unhandledExceptionRequest.Enable ();
			} catch (NotSupportedException) {
				//Mono < 2.6.3 doesn't support catching unhandled exceptions
			}

			if (machine.Version.AtLeast (2, 9)) {
				/* Created later */
			} else {
				machine.EnableEvents (EventType.TypeLoad);
			}
			

			machine.EnableEvents (EventType.MethodUpdate);

			started = true;
			
			/* Wait for the VMStart event */
			HandleEventSet (machine.GetNextEventSet ());
			
			eventHandler = new Thread (EventHandler);
			eventHandler.Name = "SDB Event Handler";
			eventHandler.IsBackground = true;
			eventHandler.Start ();
		}
		
		void RegisterUserAssemblies (SoftDebuggerStartInfo dsi)
		{
			if (Options.ProjectAssembliesOnly && dsi.UserAssemblyNames != null) {
				assemblyFilters = new List<AssemblyMirror> ();
				userAssemblyNames = dsi.UserAssemblyNames.Select (x => x.ToString ()).ToList ();
			}
			
			assemblyPathMap = dsi.AssemblyPathMap;
			if (assemblyPathMap == null)
				assemblyPathMap = new Dictionary<string, string> ();

			if (dsi.SymbolPathMap == null)
				symbolPathMap = new Dictionary<string, string>();
			else
				symbolPathMap = dsi.SymbolPathMap;
		}

		public void AddOrReplaceAssemblyPathMap(string assembly, string path)
		{
			assemblyPathMap[assembly] = path;
		}

		public void AddOrReplaceSymbolPathMap (string assembly, string path)
		{
			symbolPathMap[assembly] = path;
		}

		protected bool SetSocketTimeouts (int sendTimeout, int receiveTimeout, int keepaliveInterval)
		{
			try {
				if (vm.Version.AtLeast (2, 4)) {
					vm.EnableEvents (EventType.KeepAlive);
					vm.SetSocketTimeouts (sendTimeout, receiveTimeout, keepaliveInterval);
					return true;
				}

				return false;
			} catch {
				return false;
			}
		}

		protected void ConnectOutput (StreamReader reader, bool error)
		{
			Thread t = (error ? errorReader : outputReader);
			if (t != null || reader == null)
				return;

			t = new Thread (() => ReadOutput (reader, error));
			t.Name = error ? "SDB error reader" : "SDB output reader";
			t.IsBackground = true;
			t.Start ();

			if (error)
				errorReader = t;	
			else
				outputReader = t;
		}

		void ReadOutput (TextReader reader, bool isError)
		{
			try {
				var buffer = new char [1024];
				while (!HasExited) {
					int c = reader.Read (buffer, 0, buffer.Length);
					if (c > 0) {
						OnTargetOutput (isError, new string (buffer, 0, c));
					} else {
						//FIXME: workaround for buggy console stream that never blocks
						Thread.Sleep (250);
					}
				}
			} catch (IOException) {
				// Ignore
			}
		}

		protected virtual void OnResumed ()
		{
			current_threads = null;
			current_thread = null;
			activeExceptionsByThread.Clear ();
		}
		
		public VirtualMachine VirtualMachine {
			get { return vm; }
		}
		
		public TypeMirror GetType (string fullName)
		{
			List<TypeMirror> typesList;

			if (!types.TryGetValue (fullName, out typesList))
				aliases.TryGetValue (fullName, out typesList);
			if (typesList == null)
            {
				var vm_types = vm.GetTypes(fullName, true);
				foreach (var vm_type in vm_types)
					ProcessType(vm_type);
				if (!types.TryGetValue(fullName, out typesList))
					aliases.TryGetValue(fullName, out typesList);
				if (typesList == null)
					return null;
			}
			if (typesList.Count == 1)
				return typesList [0];
			//Idea here is... If we have multiple types with same name... they must be in different .dlls
			//so find 1st matching assembly with stackframes and then return type that belongs to that assembly
			var assembly = current_thread.GetFrames ().Select (f => f.Method.DeclaringType.Assembly).FirstOrDefault (asm => typesList.Select (t => t.Assembly).Contains (asm));
			return typesList.FirstOrDefault (t => t.Assembly == assembly) ?? typesList.FirstOrDefault ();
		}

		public IEnumerable<TypeMirror> GetAllTypes ()
		{
			return types.Values.SelectMany (l => l);
		}

		protected override bool AllowBreakEventChanges {
			get { return true; }
		}

		public override void Dispose ()
		{
			base.Dispose ();

			if (disposed)
				return;

			disposed = true;

			lock (subprocessesStarting) {
				foreach (var s in subprocessesStarting)
					s.Shutdown ();
			}

			if (!HasExited)
				EndLaunch ();

			exceptionRequests.Clear();

			if (!HasExited) {
				if (vm != null) {
					ThreadPool.QueueUserWorkItem (delegate {
						try {
							vm.Exit (0);
						} catch (VMDisconnectedException) {
						} catch (Exception ex) {
							DebuggerLoggingService.LogError ("Error exiting SDB VM:", ex);
						}
					});
				}
			}

			Adaptor.Dispose ();
		}

		protected override void OnAttachToProcess (long processId)
		{
			throw new NotSupportedException ();
		}

		protected override void OnContinue ()
		{
			ThreadPool.QueueUserWorkItem (delegate {
				try {
					Adaptor.CancelAsyncOperations (); // This call can block, so it has to run in background thread to avoid keeping the main session lock
					OnResumed ();
					vm.Resume ();
					DequeueEventsForFirstThread ();
				} catch (Exception ex) {
					if (!HandleException (ex) && outputOptions.ExceptionMessage)
						OnDebuggerOutput (true, ex.ToString ());
				}
			});
		}

		protected override void OnDetach ()
		{
			vm.Detach ();
		}

		protected override void OnExit ()
		{
			HasExited = true;
			EndLaunch ();
			if (vm != null) {
				try {
					vm.Exit (0);
				} catch (VMDisconnectedException) {
					// The VM was already disconnected, ignore.
				} catch (SocketException se) {
					// This will often happen during normal operation
					DebuggerLoggingService.LogError ("Error closing debugger session", se);
				} catch (IOException ex) {
					// This will often happen during normal operation
					DebuggerLoggingService.LogError ("Error closing debugger session", ex);
				}
			}
			QueueEnsureExited ();
		}
		
		void QueueEnsureExited ()
		{
			if (vm != null) {
				//FIXME: this might never get reached if the IDE is Exited first
				try {
					if (vm.Process != null) {
						ThreadPool.QueueUserWorkItem (delegate {
							// This is a workaround for a mono bug
							// Without this call, the process may become zombie in mono < 2.10.2
							vm.Process.WaitForExit ();
						});
					}
				} catch (InvalidOperationException) {
					// ignore - this is thrown by the vm.Process getter when the process has already exited
				} catch (Exception ex) {
					DebuggerLoggingService.LogError ("Failed to launch a thread to wait for the process to exit", ex);
				}

				var t = new System.Timers.Timer ();
				t.Interval = 3000;
				t.Elapsed += delegate {
					try {
						t.Enabled = false;
						t.Dispose ();
						EnsureExited ();
					} catch (Exception ex) {
						DebuggerLoggingService.LogError ("Failed to force-terminate process", ex);
					}

					try {
						if (vm != null) {
							//this is a no-op if it already closed
							vm.ForceDisconnect ();
						}
					} catch (Exception ex) {
						DebuggerLoggingService.LogError ("Failed to force-close debugger connection", ex);
					}
				};

				t.Enabled = true;
			}	
		}
		
		/// <summary>This is a fallback in case the debugger agent doesn't respond to an exit call</summary>
		protected virtual void EnsureExited ()
		{
			try {
				if (vm != null && vm.TargetProcess != null && !vm.TargetProcess.HasExited)
					vm.TargetProcess.Kill ();
			} catch (Exception ex) {
				DebuggerLoggingService.LogError ("Error force-terminating soft debugger process", ex);
			}
		}

		protected override void OnFinish ()
		{
			Step (StepDepth.Out, StepSize.Line);
		}

		protected override ProcessInfo[] OnGetProcesses ()
		{
			if (procs == null) {
				if (vm == null)//process didn't start yet
					return new ProcessInfo [0];
				if (vm.TargetProcess == null) {
					procs = new [] { new ProcessInfo (0, remoteProcessName ?? "mono") };
				} else {
					try {
						procs = new [] { new ProcessInfo (vm.TargetProcess.Id, remoteProcessName ?? vm.TargetProcess.ProcessName) };
					} catch (Exception ex) {
						if (!loggedSymlinkedRuntimesBug) {
							loggedSymlinkedRuntimesBug = true;
							DebuggerLoggingService.LogError ("Error getting debugger process info. Known Mono bug with symlinked runtimes.", ex);
						}
						procs = new [] { new ProcessInfo (0, "mono") };
					}
				}
			}
			return new [] { new ProcessInfo (procs[0].Id, procs[0].Name) };
		}

		internal PortablePdbData GetPdbData (AssemblyMirror asm)
		{
			string pdbFileName;
			if (!symbolPathMap.TryGetValue(asm.GetName().FullName, out pdbFileName) || Path.GetExtension(pdbFileName) != ".pdb")
			{
				string assemblyFileName;
				if (!assemblyPathMap.TryGetValue (asm.GetName ().FullName, out assemblyFileName))
					assemblyFileName = asm.Location;
				pdbFileName = Path.ChangeExtension (assemblyFileName, ".pdb");
			}
			if (PortablePdbData.IsPortablePdb (pdbFileName))
				return new PortablePdbData (pdbFileName);
			// Attempt to fetch pdb from the debuggee over the wire
			var pdbBlob = asm.GetPdbBlob ();
			return pdbBlob != null ? new PortablePdbData (pdbBlob) : null;
		}

		internal PortablePdbData GetPdbData (MethodMirror method)
		{
			return GetPdbData (method.DeclaringType.Assembly);
		}

		readonly Dictionary<AssemblyMirror, SourceLinkMap []> SourceLinkCache = new Dictionary<AssemblyMirror, SourceLinkMap []> ();
		SourceLinkMap [] GetSourceLinkMaps (MethodMirror method)
		{
			var asm = method.DeclaringType.Assembly;
			SourceLinkMap[] maps;

			lock (SourceLinkCache) {
				if (SourceLinkCache.TryGetValue (asm, out maps))
					return maps;
			}

			string jsonString = null;

			if (asm.VirtualMachine.Version.AtLeast (2, 48)) {
				jsonString = asm.ManifestModule.SourceLink;
			} else {
				// Read the pdb ourselves
				jsonString = GetPdbData (asm)?.GetSourceLinkBlob ();
			}

			/*if (!string.IsNullOrWhiteSpace(jsonString)) {
				try {
					var jsonSourceLink = JsonConvert.DeserializeObject<JsonSourceLink> (jsonString);

					if (jsonSourceLink != null && jsonSourceLink.Maps != null && jsonSourceLink.Maps.Any ())
						maps = jsonSourceLink.Maps.Select (kv => new SourceLinkMap (kv.Key, kv.Value)).ToArray ();
				} catch (JsonException ex) {
					DebuggerLoggingService.LogError ("Error reading source link", ex);
				}
			}*/

			lock (SourceLinkCache) {
				SourceLinkCache[asm] = maps ?? Array.Empty<SourceLinkMap> ();
			}

			return maps;
		}

		internal SourceLink GetSourceLink (MethodMirror method, string originalFileName)
		{
			if (originalFileName == null)
				return null;

			var maps = GetSourceLinkMaps (method);
			if (maps == null || maps.Length == 0)
				return null;

			originalFileName = originalFileName.Replace ('\\', '/');
			foreach (var map in maps) {
				var pattern = map.RelativePathWildcard.Replace ("*", "").Replace ('\\', '/');

				if (originalFileName.StartsWith (pattern, StringComparison.Ordinal)) {
					var localPath = originalFileName.Replace (pattern.Replace (".*", ""), "");
					var httpBasePath = map.UriWildcard.Replace ("*", "");
					// org/project-name/git-sha (usually)
					var pathAndQuery = new Uri (httpBasePath).GetComponents (UriComponents.Path, UriFormat.SafeUnescaped);
					// org/projectname/git-sha/path/to/file.cs
					var relativePath = Path.Combine (pathAndQuery, localPath);
					// Replace something like "f:/build/*" with "https://raw.githubusercontent.com/org/projectname/git-sha/*"
					var httpPath = Regex.Replace (originalFileName, pattern, httpBasePath);
					return new SourceLink (httpPath, relativePath);
				}
			}
			return null;
		}

		protected override Backtrace OnGetThreadBacktrace (long processId, long threadId)
		{
			return GetThreadBacktrace (GetThread (threadId));
		}

		protected override long OnGetElapsedTime (long processId, long threadId)
		{
			return GetElapsedTime (GetThread (threadId));
		}

		Backtrace GetThreadBacktrace (ThreadMirror thread)
		{
			return new Backtrace (new SoftDebuggerBacktrace (this, thread));
		}

		long GetElapsedTime (ThreadMirror thread)
		{
			return thread.ElapsedTime ();
		}

		string GetThreadName (ThreadMirror t)
		{
			string name = t.Name;
			if (string.IsNullOrEmpty (name)) {
				try {
					if (t.IsThreadPoolThread)
						return "<Thread Pool>";
				} catch {
					if (vm.Version.AtLeast (2, 2)) {
						throw;
					}
					return "<Thread>";
				}
			}
			return name;
		}

		protected override void OnFetchFrames (Mono.Debugging.Client.ThreadInfo [] threads)
		{
			var mirrorThreads = new List<ThreadMirror> (threads.Length);
			for (int i = 0; i < threads.Length; i++) {
				var thread = GetThread (threads [i].Id);
				if (thread != null) {
					mirrorThreads.Add (thread);
				}
			}
			ThreadMirror.FetchFrames (mirrorThreads);
		}

		protected override Mono.Debugging.Client.ThreadInfo[] OnGetThreads (long processId)
		{
			if (current_threads == null) {
				var mirrors = vm.GetThreads ();
				var threads = new Mono.Debugging.Client.ThreadInfo[mirrors.Count];

				for (int i = 0; i < mirrors.Count; i++) {
					var thread = mirrors[i];

					threads[i] = new Mono.Debugging.Client.ThreadInfo (processId, GetId (thread), GetThreadName (thread), null);
				}

				current_threads = threads;
			}

			return current_threads;
		}
		
		ThreadMirror GetThread (long threadId)
		{
			foreach (var thread in vm.GetThreads ()) {
				if (GetId (thread) == threadId)
					return thread;
			}

			return null;
		}

		Mono.Debugging.Client.ThreadInfo GetThread (ProcessInfo process, ThreadMirror thread)
		{
			long id = GetId (thread);

			foreach (var threadInfo in OnGetThreads (process.Id)) {
				if (threadInfo.Id == id)
					return threadInfo;
			}

			return null;
		}

		public override bool CanSetNextStatement {
			get { return vm.Version.AtLeast (2, 29); }
		}

		protected override void OnSetNextStatement (long threadId, string fileName, int line, int column)
		{
			if (!CanSetNextStatement)
				throw new NotSupportedException ();

			var thread = GetThread (threadId);
			if (thread == null)
				throw new ArgumentException ("Unknown thread.");

			var frames = thread.GetFrames ();
			if (frames.Length == 0)
				throw new NotSupportedException ();

			bool dummy = false;
			var location = FindLocationByMethod (frames[0].Method, fileName, line, column, ref dummy);
			if (location == null)
				throw new NotSupportedException ("Unable to set the next statement. The next statement cannot be set to another function.");
			try {
				thread.SetIP (location);
				currentAddress = location.ILOffset;
				currentStackDepth = frames.Length;
			} catch (ArgumentException) {
				throw new NotSupportedException ();
			}
		}

		protected override void OnSetNextStatement (long threadId, int ilOffset)
		{
			if (!CanSetNextStatement)
				throw new NotSupportedException ();

			var thread = GetThread (threadId);
			if (thread == null)
				throw new ArgumentException ("Unknown thread.");

			var frames = thread.GetFrames ();
			if (frames.Length == 0)
				throw new NotSupportedException ();

			var location = frames[0].Method.LocationAtILOffset (ilOffset);
			if (location == null)
				throw new NotSupportedException ();

			try {
				thread.SetIP (location);
				StackVersion++;
				RaiseStopEvent ();
			} catch (ArgumentException) {
				throw new NotSupportedException ();
			}
		}
		
		protected override BreakEventInfo OnInsertBreakEvent (BreakEvent breakEvent)
		{
			var breakInfo = new BreakInfo ();

			if (HasExited) {
				breakInfo.SetStatus (BreakEventStatus.Disconnected, null);
				return breakInfo;
			}

		
			if (breakEvent is FunctionBreakpoint) {
				var function = breakEvent as FunctionBreakpoint;
				foreach (var method in FindMethodsByName (function.TypeName, function.MethodName, function.ParamTypes)) {
					if (!ResolveFunctionBreakpoint (breakInfo, function, method)) {
						breakInfo.SetStatus (BreakEventStatus.NotBound, null);
					}
				}

				breakInfo.TypeName = function.TypeName;

				lock (pending_bes) {
					pending_bes.Add (breakInfo);
				}
			} else if (breakEvent is InstructionBreakpoint) {
				var instruction = breakEvent as InstructionBreakpoint;
				Location location;

				breakInfo.FileName = instruction.FileName;

				if ((location = FindLocationByILOffset (instruction, instruction.FileName, out _, out var insideTypeRange)) != null) {
					breakInfo.Location = location;
					InsertBreakpoint (instruction, breakInfo);
					breakInfo.SetStatus (BreakEventStatus.Bound, null);
				} else if (insideTypeRange)
					breakInfo.SetStatus (BreakEventStatus.Invalid, null);
				else
					breakInfo.SetStatus (BreakEventStatus.NotBound, null);

				lock (pending_bes) {
					pending_bes.Add (breakInfo);
				}
			} else if (breakEvent is Breakpoint) {
				var breakpoint = breakEvent as Breakpoint;
				bool insideLoadedRange;
				bool found = false;

				breakInfo.FileName = breakpoint.FileName;

				foreach (var location in FindLocationsByFile (breakpoint.FileName, breakpoint.Line, breakpoint.Column, out _, out insideLoadedRange)) {
					OnDebuggerOutput (false, string.Format ("Resolved pending breakpoint at '{0}:{1},{2}' to {3} [0x{4:x5}].\n",
					                                        breakpoint.FileName, breakpoint.Line, breakpoint.Column,
															GetPrettyMethodName (location.Method), location.ILOffset));

					breakInfo.Location = location;
					InsertBreakpoint (breakpoint, breakInfo);
					found = true;
					breakInfo.SetStatus (BreakEventStatus.Bound, null);
				}
				lock (pending_bes) {
					pending_bes.Add (breakInfo);
				}

				if (!found) {
					breakInfo.Breakpoint = breakpoint;
					if (insideLoadedRange)
						breakInfo.SetStatus (BreakEventStatus.Invalid, null);
					else
						breakInfo.SetStatus (BreakEventStatus.NotBound, null);
				}
			} else if (breakEvent is Catchpoint) {
				var catchpoint = breakEvent as Catchpoint;
				if (!types.ContainsKey (catchpoint.ExceptionName)) {
					//
					// Same as in FindLocationByFile (), fetch types matching the type name
					if (vm.Version.AtLeast (2, 9)) {
						foreach (TypeMirror t in vm.GetTypes (catchpoint.ExceptionName, false))
							ProcessType (t);
					}
				}

				List<TypeMirror> typesList;
				if (types.TryGetValue (catchpoint.ExceptionName, out typesList)) {
					foreach (var type in typesList)
						InsertCatchpoint (catchpoint, breakInfo, type);
					breakInfo.SetStatus (BreakEventStatus.Bound, null);
				} else {
					breakInfo.SetStatus (BreakEventStatus.NotBound, null);
				}

				breakInfo.TypeName = catchpoint.ExceptionName;
				lock (pending_bes) {
					pending_bes.Add (breakInfo);
				}
			}
			UpdateTypeLoadFilters ();
			return breakInfo;
		}

		void UpdateTypeLoadFilters()
		{
			/*
			 * TypeLoad events lead to too much wire traffic + suspend/resume work, so
			 * filter them using the file names used by pending breakpoints.
			 */
			if (vm.Version.AtLeast (2, 9)) {
				string [] sourceFileList;
				lock (pending_bes) {
					sourceFileList = pending_bes.Where (b => b.FileName != null).SelectMany ((b, i) => new [] {
					Path.GetFileName (b.FileName),
					b.FileName
					}).Distinct ().ToArray ();
				}
				if (sourceFileList.Length > 0) {
					//HACK: with older versions of sdb that don't support case-insenitive compares,
					//explicitly try lowercased drivename on windows, since csc (when not hosted in VS) lowercases
					//the drivename in the pdb files that get converted to mdbs as-is
					if (IsWindows && !vm.Version.AtLeast (2, 12)) {
						int originalCount = sourceFileList.Length;
						Array.Resize (ref sourceFileList, originalCount * 2);
						for (int i = 0; i < originalCount; i++) {
							string n = sourceFileList[i];
							sourceFileList[originalCount + i] = char.ToLower (n[0]) + n.Substring (1);
						}
					}

					if (typeLoadReq == null) {
						typeLoadReq = vm.CreateTypeLoadRequest ();
					}
					typeLoadReq.Enabled = false;
					typeLoadReq.SourceFileFilter = sourceFileList;
					typeLoadReq.Enabled = true;
				}

				string [] typeNameList;
				lock (pending_bes) {
					typeNameList = pending_bes.Where (b => b.TypeName != null).Select (b => b.TypeName).ToArray ();
				}
				if (typeNameList.Length > 0) {
					// Use a separate request since the filters are ANDed together
					if (typeLoadTypeNameReq == null) {
						typeLoadTypeNameReq = vm.CreateTypeLoadRequest ();
					}
					typeLoadTypeNameReq.Enabled = false;
					typeLoadTypeNameReq.TypeNameFilter = typeNameList;
					typeLoadTypeNameReq.Enabled = true;
				}
			}
		}

		private Location FindLocationByILOffset (InstructionBreakpoint bp, string filename, out bool isGeneric, out bool insideTypeRange)
		{
			var typesInFile = new List<TypeMirror> ();

			AddFileToSourceMapping (filename);

			insideTypeRange = true;
			isGeneric = false;

			lock (source_to_type) {
				if (source_to_type.TryGetValue (filename, out typesInFile)) {
					foreach (var type in typesInFile) {
						var method = type.GetMethod (bp.MethodName);
						if (method != null) {
							foreach (var location in method.Locations) {
								if (location.ILOffset == bp.ILOffset) {
									isGeneric = type.IsGenericType;
									return location;
								}
							}
						}
					}
				}
			}

			return null;
		}

		protected override void OnRemoveBreakEvent (BreakEventInfo eventInfo)
		{
			if (HasExited)
				return;

			var bi = (BreakInfo) eventInfo;
			if (bi.Requests.Count != 0) {
				foreach (var request in bi.Requests.Keys) {
					request.Enabled = false;
					breakpoints.Remove (request);
				}

				RemoveQueuedBreakEvents (bi.Requests);
			}

			lock (pending_bes) {
				pending_bes.Remove (bi);
			}
		}

		protected override void OnEnableBreakEvent (BreakEventInfo eventInfo, bool enable)
		{
			if (HasExited)
				return;
			
			var bi = (BreakInfo) eventInfo;
			if (bi.Requests.Count != 0) {
				foreach (var request in bi.Requests.Keys)
					request.Enabled = enable;

				if (!enable)
					RemoveQueuedBreakEvents (bi.Requests);
			}
		}

		protected override void OnUpdateBreakEvent (BreakEventInfo eventInfo)
		{
		}

		void InsertBreakpoint (Breakpoint bp, BreakInfo bi)
		{
			InsertBreakpoint (bp, bi, bi.Location.Method, bi.Location.ILOffset);
		}

		void UpdateBreakpoint (Breakpoint bp, BreakInfo bi)
		{
			foreach (var req in bi.Requests)
			{
				req.Key.Disable ();
				var request = vm.SetBreakpoint (bi.Location.Method, bi.Location.ILOffset);
				req.Key.UpdateReqId (request.GetId());
				req.Key.Enabled = bp.Enabled;
			}
		}

		void InsertBreakpoint (Breakpoint bp, BreakInfo bi, MethodMirror method, int ilOffset)
		{
			EventRequest request;

			request = vm.SetBreakpoint (method, ilOffset);
			request.Enabled = bp.Enabled;
			bi.Requests.Add (request, method.DeclaringType.Assembly);

			breakpoints [request] = bi;

			if (bi.Location != null && (bi.Location.LineNumber != bp.Line || bi.Location.ColumnNumber != bp.Column))
				bi.AdjustBreakpointLocation (bi.Location.LineNumber, bi.Location.ColumnNumber);
		}
		
		void InsertCatchpoint (Catchpoint cp, BreakInfo bi, TypeMirror excType)
		{
			ExceptionEventRequest request;

			request = vm.CreateExceptionRequest (excType, true, true);
			//Commenting Count so we have better control of counting
			//because VM only allows count equal to some number but we need also
			//lower, greater, equal or greater...
			//Plus some day we might want to put filtering before counting...
			//request.Count = cp.HitCount; // Note: need to set HitCount *before* enabling
			if (vm.Version.AtLeast (2, 25))
				request.IncludeSubclasses = cp.IncludeSubclasses; // Note: need to set IncludeSubclasses *before* enabling
			request.Enabled = cp.Enabled;
			bi.Requests.Add (request, excType.Assembly);

			breakpoints[request] = bi;
		}

#region ExceptionRequest
		//VS in Windows doesn't have the concept of a Catchpoint. In the past we did use it anyway, but that leads to all sort of issues and bugs.
		//The most important difference is that subclasses are never caught, and that Others is a concept that the Catchpoint doesn't support properly.
		//This region is for Windows, to be able to properly handle exceptions with an exception list. The concept of Other is supported starting with vm version 2.54.

		readonly Dictionary<string, ExceptionEventRequest> exceptionRequests = new Dictionary<string, ExceptionEventRequest>();
		ExceptionEventRequest otherExceptions;

		public void EnableException(string exceptionType, bool caught = true)
		{
			lock (exceptionRequests) {
				if (!types.ContainsKey (exceptionType)) {
					if (vm.Version.AtLeast (2, 9)) {
						try {
							foreach (TypeMirror t in vm.GetTypes (exceptionType, false))
								ProcessType (t);
						}
						catch (CommandException exc) {
							if (outputOptions.ExceptionMessage)
								OnDebuggerOutput (false, string.Format ("Error while parsing type ‘{0}’.\n", exceptionType));
						}
					}
				}

				if (types.TryGetValue(exceptionType, out var typemirrors)) { 
					var exception = typemirrors.First();
					var request = vm.CreateExceptionRequest (exception, caught, true, false);
					request.Enable();
					exceptionRequests[exceptionType] = request;
				}
			}
		}

		public void EnableOtherExceptions()
		{
			if (!vm.Version.AtLeast(2, 54))
				return;

			if (otherExceptions == null)
				otherExceptions = vm.CreateExceptionRequest (null, true, true, true);
			otherExceptions.Enable ();
		}

		public void DisableException(string exceptionType, bool setuncaught = true)
		{
			lock (exceptionRequests) {
				if (exceptionRequests.TryGetValue (exceptionType, out var request)) {
					request.Disable();
					exceptionRequests.Remove(exceptionType);
				}
				if (setuncaught)
					EnableException (exceptionType, false);
			}
		}

		public void DisableOtherExceptions()
		{
			if (otherExceptions != null) {
				otherExceptions.Disable();
			}
		}

		public void RemoveException(string exceptionType)
		{
			DisableException(exceptionType, false);
		}

#endregion

		static bool CheckTypeName (string typeName, string name)
		{
			// if the name provided is empty, it matches anything.
			if (string.IsNullOrEmpty (name))
				return true;

			if (name.StartsWith ("global::", StringComparison.Ordinal)) {
				if (typeName != name.Substring ("global::".Length))
					return false;
			} else if (name.StartsWith ("::", StringComparison.Ordinal)) {
				if (typeName != name.Substring ("::".Length))
					return false;
			} else {
				// be a little more flexible with what we match... i.e. "Console" should match "System.Console"
				if (typeName != null && typeName.Length > name.Length) {
					if (!typeName.EndsWith (name, StringComparison.Ordinal))
						return false;

					char delim = typeName[typeName.Length - name.Length];
					if (delim != '.' && delim != '+')
						return false;
				} else if (typeName != name) {
					return false;
				}
			}

			return true;
		}

		static bool CheckTypeName (TypeMirror type, string name)
		{
			if (string.IsNullOrEmpty (name)) {
				// empty name matches anything
				return true;
			}

			if (name[name.Length - 1] == '?') {
				// canonicalize the user-specified nullable type
				return CheckTypeName (type, string.Format ("System.Nullable<{0}>", name.Substring (0, name.Length - 1)));
			}

			if (type.IsArray) {
				int startIndex = name.LastIndexOf ('[');
				int endIndex = name.Length - 1;

				if (startIndex == -1 || name[endIndex] != ']') {
					// the user-specified type is not an array
					return false;
				}

				var rank = name.Substring (startIndex + 1, endIndex - (startIndex + 1)).Split (new [] { ',' });
				if (rank.Length != type.GetArrayRank ())
					return false;

				return CheckTypeName (type.GetElementType (), name.Substring (0, startIndex).TrimEnd ());
			}

			if (type.IsPointer) {
				if (name.Length < 2 || name[name.Length - 1] != '*')
					return false;

				return CheckTypeName (type.GetElementType (), name.Substring (0, name.Length - 1).TrimEnd ());
			}

			if (type.IsGenericType) {
				int startIndex = name.IndexOf ('<');
				int endIndex = name.Length - 1;

				if (startIndex == -1 || name[endIndex] != '>') {
					// the user-specified type is not a generic type
					return false;
				}

				// make sure that the type name matches (minus generics)
				string subName = name.Substring (0, startIndex);
				string typeName = type.FullName;
				int tick;

				if ((tick = typeName.IndexOf ('`')) != -1)
					typeName = typeName.Substring (0, tick);

				if (!CheckTypeName (typeName, subName))
					return false;

				string[] paramTypes;
				if (!FunctionBreakpoint.TryParseParameters (name, startIndex + 1, endIndex, out paramTypes))
					return false;

				TypeMirror[] argTypes = type.GetGenericArguments ();
				if (paramTypes.Length != argTypes.Length)
					return false;

				for (int i = 0; i < paramTypes.Length; i++) {
					if (!CheckTypeName (argTypes[i], paramTypes[i]))
						return false;
				}
			} else if (!CheckTypeName (type.CSharpName, name)) {
				if (!CheckTypeName (type.FullName, name))
					return false;
			}

			return true;
		}

		static bool CheckMethodParams (MethodMirror method, string[] paramTypes)
		{
			if (paramTypes == null) {
				// User supplied no params to match against, match anything we find.
				return true;
			}

			var parameters = method.GetParameters ();
			if (parameters.Length != paramTypes.Length)
				return false;

			for (int i = 0; i < paramTypes.Length; i++) {
				if (!CheckTypeName (parameters[i].ParameterType, paramTypes[i]))
					return false;
			}

			return true;
		}
		
		bool IsGenericMethod (MethodMirror method)
		{
			return vm.Version.AtLeast (2, 12) && method.IsGenericMethod;
		}

		//If paramType == null all overloads are returned
		IEnumerable<MethodMirror> FindMethodsByName (string typeName, string methodName, string[] paramTypes)
		{
			if (!started)
				yield break;
			
			if (vm.Version.AtLeast (2, 9)) {
				// FIXME: need a way of querying all types so we can substring match typeName (e.g. user may have typed "Console" instead of "System.Console")
				foreach (var type in vm.GetTypes (typeName, false)) {
					ProcessType (type);
					
					foreach (var method in type.GetMethodsByNameFlags (methodName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static, true)) {
						if (!CheckMethodParams (method, paramTypes))
							continue;
						
						yield return method;
					}
				}
			}
			
			yield break;
		}
		
		IList<Location> FindLocationsByFile (string file, int line, int column, out bool genericTypeOrMethod, out bool insideLoadedRange)
		{
			var locations = new List<Location> ();

			genericTypeOrMethod = false;
			insideLoadedRange = false;
			
			if (!started)
				return locations;

			var filename = Path.GetFileName (file);

			AddFileToSourceMapping (filename);

			lock (source_to_type) {
				// Try already loaded types in the current source file
				if (source_to_type.TryGetValue (filename, out var mirrors)) {
					foreach (var type in mirrors) {
						var location = FindLocationByType (type, file, line, column, out var genericMethod, out var insideRange);
						if (insideRange)
							insideLoadedRange = true;

						if (location != null) {
							if (genericMethod || type.IsGenericType)
								genericTypeOrMethod = true;

							locations.Add (location);
						}
					}
				}
			}

			return locations;
		}

		private void AddFileToSourceMapping (string filename)
		{
			//
			// Fetch types matching the source file from the debuggee, and add them
			// to the source file->type mapping tables.
			// This is needed because we don't receive type load events for all types,
			// just the ones which match a source file with an existing breakpoint.
			//
			if (vm.Version.AtLeast (2, 9)) {
				IList<TypeMirror> typesInFile;
				if (vm.Version.AtLeast (2, 12)) {
					typesInFile = vm.GetTypesForSourceFile (filename, IgnoreFilenameCase);
				} else {
					typesInFile = vm.GetTypesForSourceFile (filename, false);
					//HACK: with older versions of sdb that don't support case-insenitive compares,
					//explicitly try lowercased drivename on windows, since csc (when not hosted in VS) lowercases
					//the drivename in the pdb files that get converted to mdbs as-is
					if (typesInFile.Count == 0 && IsWindows) {
						string alternateCaseFilename = char.ToLower (filename [0]) + filename.Substring (1);
						typesInFile = vm.GetTypesForSourceFile (alternateCaseFilename, false);
					}
				}
				
				foreach (TypeMirror t in typesInFile)
					ProcessType (t);
			}
		}

		public override bool CanCancelAsyncEvaluations
		{
			get
			{
				return Adaptor.IsEvaluating;
			}
		}
		
		protected override void OnCancelAsyncEvaluations ()
		{
			Adaptor.CancelAsyncOperations ();
		}
		
		protected override void OnNextInstruction ()
		{
			Step (StepDepth.Over, StepSize.Min);
		}

		protected override void OnNextLine ()
		{
			Step (StepDepth.Over, StepSize.Line);
		}

		public void StepOut()
        {
			Step(StepDepth.Out, StepSize.Line);
        }

		void Step (StepDepth depth, StepSize size)
		{
			try {
				//Console.WriteLine("Adaptor.CancelAsyncOperations");
				Adaptor.CancelAsyncOperations (); // This call can block, so it has to run in background thread to avoid keeping the main session lock
				var req = vm.CreateStepRequest (current_thread);
				req.Depth = depth;
				req.Size = size;
				req.Filter = ShouldFilterStaticCtor () | StepFilter.DebuggerHidden | StepFilter.DebuggerStepThrough;
				if (Options.ProjectAssembliesOnly)
					req.Filter |= StepFilter.DebuggerNonUserCode;
				if (assemblyFilters != null && assemblyFilters.Count > 0)
					req.AssemblyFilter = assemblyFilters;
				try {
					req.Enabled = true;
				} catch (NotSupportedException e) {
					if (vm.Version.AtLeast (2, 19)) //catch NotSupportedException thrown by old version of protocol
						throw e;
				}
				currentStepRequest = req;
				//Console.WriteLine("OnResumed");
				OnResumed ();
				//Console.WriteLine("vm.Resume");
				vm.Resume ();
				//Console.WriteLine("DequeueEventsForFirstThread");
				DequeueEventsForFirstThread ();
			} catch (CommandException ex) {
				string reason;

				switch (ex.ErrorCode) {
				case ErrorCode.INVALID_FRAMEID: reason = "invalid frame id"; break;
				case ErrorCode.NOT_SUSPENDED: reason = "VM not suspended"; break;
				case ErrorCode.ERR_UNLOADED: reason = "AppDomain has been unloaded"; break;
				case ErrorCode.NO_SEQ_POINT_AT_IL_OFFSET: reason = "no sequence point at the specified IL offset"; break;
				default: reason = ex.ErrorCode.ToString (); break;
				}

				if (outputOptions.ExceptionMessage)
					OnDebuggerOutput (true, string.Format ("Step request failed: {0}.", reason));
				DebuggerLoggingService.LogError ("Step request failed", ex);
			} catch (Exception ex) {
				if (outputOptions.ExceptionMessage)
					OnDebuggerOutput(true, string.Format ("Step request failed: {0}", ex.Message));
				DebuggerLoggingService.LogError ("Step request failed", ex);
			}
		}

		private StepFilter ShouldFilterStaticCtor()
		{
			var frames = current_thread.GetFrames();
			return (frames.Any(f => f.Method.Name == ".cctor" && f.Method.IsSpecialName && f.Method.IsStatic))
				? StepFilter.None : StepFilter.StaticCtor;
		}

		void EventHandler ()
		{
			int? exit_code = null;

			while (true) {
				try {
					EventSet e = vm.GetNextEventSet ();
					var type = e[0].EventType;
					if (type == EventType.VMDeath || type == EventType.VMDisconnect) {
						if (type == EventType.VMDeath && vm.Version.AtLeast (2, 27)) {
							exit_code = ((VMDeathEvent) e[0]).ExitCode;
						}
						break;
					}
					HandleEventSet (e);
				} catch (Exception ex) {
					if (HasExited)
						break;

					if (!HandleException (ex) && outputOptions.ExceptionMessage)
						OnDebuggerOutput (true, ex.ToString ());

					if (ex is VMDisconnectedException || ex is IOException || ex is SocketException)
						break;
				}
			}
			
			try {
				// This is a workaround for a mono bug
				// Without this call, the process may become zombie in mono < 2.10.2
				if (vm.Process != null)
					vm.Process.WaitForExit (1);
			} catch (SystemException) {
			}

			OnTargetEvent (new TargetEventArgs (TargetEventType.TargetExited) {
				ExitCode = exit_code
			});
		}
		
		protected override bool HandleException (Exception ex)
		{
			HideConnectionDialog ();

			if (HasExited)
				return true;
			
			if (ex is VMDisconnectedException || ex is IOException) {
				ex = new DisconnectedException (ex);
				HasExited = true;
			} else if (ex is SocketException) {
				ex = new DebugSocketException (ex);
				HasExited = true;
			}
			
			return base.HandleException (ex);
		}

		void HandleEventSet (EventSet es)
		{
			var type = es[0].EventType;

#if DEBUG_EVENT_QUEUEING
			if (type != TypeLoadEvent)
				Console.WriteLine ("pp eventset({0}): {1}", es.Events.Length, es[0]);
#endif

			// If we are currently stopped on a thread, and the break events are on a different thread, we must queue
			// that event set and dequeue it next time we resume. This eliminates race conditions when multiple threads
			// hit breakpoints or catchpoints simultaneously.
			//
			bool isBreakEvent = type == EventType.Step || type == EventType.Breakpoint || type == EventType.Exception || type == EventType.UserBreak;
			if (isBreakEvent) {
				if (current_thread != null && es[0].Thread.Id != current_thread.Id) {
					QueueBreakEventSet (es.Events);
				} else {
					HandleBreakEventSet (es.Events, false);
				}
				return;
			}

			switch (type) {
			case EventType.AssemblyLoad:
				HandleAssemblyLoadEvents (Array.ConvertAll (es.Events, item => (AssemblyLoadEvent)item));
				break;
			case EventType.AppDomainUnload:
				HandleDomainUnloadEvents (Array.ConvertAll (es.Events, item => (AppDomainUnloadEvent)item));
				break;
			case EventType.VMStart:
				HandleVMStartEvents (Array.ConvertAll (es.Events, item => (VMStartEvent)item));
				break;
			case EventType.TypeLoad:
				HandleTypeLoadEvents (Array.ConvertAll (es.Events, item => (TypeLoadEvent)item));
				break;
			case EventType.ThreadStart:
				HandleThreadStartEvents (Array.ConvertAll (es.Events, item => (ThreadStartEvent)item));
				break;
			case EventType.ThreadDeath:
				HandleThreadDeathEvents (Array.ConvertAll (es.Events, item => (ThreadDeathEvent)item));
				break;
			case EventType.UserLog:
				HandleUserLogEvents (Array.ConvertAll (es.Events, item => (UserLogEvent)item));
				break;
			case EventType.MethodUpdate:
				HandleMethodUpdateEvents (Array.ConvertAll (es.Events, item => (MethodUpdateEvent)item));
				break;
			default:
				DebuggerLoggingService.LogMessage ("Ignoring unknown debugger event type {0}", type);
				break;
			}

			try {
				if (!vm.Version.AtLeast (2, 55) || es.SuspendPolicy != SuspendPolicy.None)
					vm.Resume ();
			} catch (VMNotSuspendedException) {
				if (type != EventType.VMStart && vm.Version.AtLeast (2, 2))
					throw;
			}
		}
		
		static bool IsStepIntoRequest (StepEventRequest stepRequest)
		{
			return stepRequest.Depth == StepDepth.Into;
		}
		
		static bool IsStepOutRequest (StepEventRequest stepRequest)
		{
			return stepRequest.Depth == StepDepth.Out;
		}
		
		static bool IsPropertyOrOperatorMethod (MethodMirror method)
		{
			string name = method.Name;
			
			return method.IsSpecialName &&
				(name.StartsWith ("get_", StringComparison.Ordinal) ||
				 name.StartsWith ("set_", StringComparison.Ordinal) ||
				 name.StartsWith ("op_", StringComparison.Ordinal));
		}

		static bool IsCompilerGenerated (MethodMirror method)
		{
			foreach (var attr in method.GetCustomAttributes(false)) {
				if (attr.Constructor.DeclaringType.FullName == "System.Runtime.CompilerServices.CompilerGeneratedAttribute")
					return true;
			}
			return false;
		}

		bool IsUserAssembly (AssemblyMirror assembly)
		{
			if (userAssemblyNames == null)
				return true;

			var name = assembly.GetName ().FullName;

			foreach (var n in userAssemblyNames) {
				if (n == name)
					return true;
			}

			return false;
		}

		bool IsAutoGeneratedFrameworkEnumerator (TypeMirror type)
		{
			if (IsUserAssembly (type.Assembly))
				return false;

			if (!SoftDebuggerAdaptor.IsGeneratedType (type))
				return false;

			foreach (var iface in type.GetInterfaces ()) {
				if (iface.Namespace == "System.Collections" && iface.Name == "IEnumerator")
					return true;
			}

			return false;
		}

		bool StepThrough (MethodMirror method)
		{
			if (Options.ProjectAssembliesOnly && !IsUserAssembly (method.DeclaringType.Assembly))
				return true;

			//With Sdb 2.30 this logic was moved to Runtime no need to spend time on checking this
			if (!vm.Version.AtLeast (2, 30)) {
				if (vm.Version.AtLeast (2, 21)) {
					foreach (var attr in method.GetCustomAttributes (false)) {
						var attrName = attr.Constructor.DeclaringType.FullName;

						switch (attrName) {
						case "System.Diagnostics.DebuggerHiddenAttribute":
							return true;
						case "System.Diagnostics.DebuggerStepThroughAttribute":
							return true;
						case "System.Diagnostics.DebuggerNonUserCodeAttribute":
							return Options.ProjectAssembliesOnly;
						}
					}
				}

				if (Options.ProjectAssembliesOnly) {
					foreach (var attr in method.DeclaringType.GetCustomAttributes (false)) {
						var attrName = attr.Constructor.DeclaringType.FullName;

						if (attrName == "System.Diagnostics.DebuggerNonUserCodeAttribute")
							return Options.ProjectAssembliesOnly;
					}
				}
			}

			return false;
		}

		bool ContinueOnStepInto (MethodMirror method)
		{
			if (vm.Version.AtLeast (2, 21)) {
				foreach (var attr in method.GetCustomAttributes (false)) {
					var attrName = attr.Constructor.DeclaringType.FullName;

					if (attrName == "System.Diagnostics.DebuggerStepperBoundaryAttribute")
						return true;
				}
			}

			return false;
		}

		bool IgnoreBreakpoint (MethodMirror method)
		{
			if (vm.Version.AtLeast (2, 21)) {
				foreach (var attr in method.GetCustomAttributes (false)) {
					var attrName = attr.Constructor.DeclaringType.FullName;

					switch (attrName) {
					case "System.Diagnostics.DebuggerHiddenAttribute":      return true;
					case "System.Diagnostics.DebuggerStepThroughAttribute": return true;
					case "System.Diagnostics.DebuggerNonUserCodeAttribute": return Options.ProjectAssembliesOnly;
					case "System.Diagnostics.DebuggerStepperBoundaryAttribute": return true;
					}
				}
			}

			if (Options.ProjectAssembliesOnly) {
				foreach (var attr in method.DeclaringType.GetCustomAttributes (false)) {
					var attrName = attr.Constructor.DeclaringType.FullName;

					if (attrName == "System.Diagnostics.DebuggerNonUserCodeAttribute")
						return Options.ProjectAssembliesOnly;
				}
			}

			return false;
		}

		/// <summary>
		/// Checks all frames in thread where exception occured and if any frame has user code it returns true.
		/// Also notice that this method already check if Options.ProjectAssembliesOnly==false 
		/// </summary>
		bool ExceptionInUserCode (ExceptionEvent ev)
		{
			// this is just optimization to prevent need to fetch Frames
			if (Options.ProjectAssembliesOnly == false)
				return true;
			foreach (var frame in ev.Thread.GetFrames ()) {
				if (!IsExternalCode (frame))
					return true;
			}
			return false;
		}

		bool ShouldIgnore (ExceptionEvent ev)
		{
			BreakInfo binfo;
			if (!breakpoints.TryGetValue (ev.Request, out binfo))
				return false;

			var cp = binfo.BreakEvent as Catchpoint;
			if (cp == null)
				return false;

			var backtrace = GetThreadBacktrace (ev.Thread);
			if (backtrace.FrameCount == 0) {
				return cp.ShouldIgnore (ev.Exception.Type.FullName, null);
			} else {
				var frame = backtrace.GetFrame (0);
				return cp.ShouldIgnore (ev.Exception.Type.FullName, frame.GetLocationSignature ());
			}
		}

		void HandleBreakEventSet (Event[] es, bool dequeuing)
		{
			if (dequeuing && HasExited)
				return;

			TargetEventType etype = TargetEventType.TargetStopped;
			ObjectMirror exception = null;
			BreakEvent breakEvent = null;
			bool redoCurrentStep = false;
			bool steppedInto = false;
			bool steppedOut = false;
			bool resume = true;
			BreakInfo binfo;
			
			if (es [0].EventType == EventType.Exception) {
				var bad = es.FirstOrDefault (ee => ee.EventType != EventType.Exception);
				if (bad != null)
					throw new Exception ("Catchpoint eventset had unexpected event type " + bad.GetType ());
				var ev = (ExceptionEvent)es [0];
				exception = ev.Exception;
				if (ev.Request == unhandledExceptionRequest) {
					etype = TargetEventType.UnhandledException;
					if (exception.Type.FullName != "System.Threading.ThreadAbortException")
						resume = false;
				} else {
					// Set the exception for this thread so that CatchPoint Print message(tracing) of {$exception} works
					activeExceptionsByThread [es[0].Thread.ThreadId] = exception;
					if (ExceptionInUserCode(ev) && !ShouldIgnore(ev) && !HandleBreakpoint (es [0].Thread, ev.Request)) {
						etype = TargetEventType.ExceptionThrown;
						resume = false;
					}

					// Remove exception from the thread so that when the program stops due to stepFinished/programPause/breakPoint...
					// we don't have on out-dated exception(setting and unsetting few lines later is needed because it's used inside HandleBreakpoint)
					activeExceptionsByThread.Remove (es[0].Thread.ThreadId);

					// Get the breakEvent so that we can check if we should ignore it later
					if (breakpoints.TryGetValue (ev.Request, out binfo))
						breakEvent = binfo.BreakEvent;
				}
			} else {
				//always need to evaluate all breakpoints, some might be tracepoints or conditional bps with counters
				foreach (Event e in es) {
					if (e.EventType == EventType.Breakpoint) {
						var be = (BreakpointEvent) e;
						var hasBreakInfo = breakpoints.TryGetValue (be.Request, out binfo);

						if (!HandleBreakpoint (e.Thread, be.Request)) {
							etype = TargetEventType.TargetHitBreakpoint;
							autoStepInto = false;
							resume = false;
							if (hasBreakInfo)
								breakEvent = binfo.BreakEvent;
						}
						
						if (hasBreakInfo) {
							if (currentStepRequest != null &&
							    currentStepRequest.Depth != StepDepth.Out &&
							    binfo.Location.ILOffset == currentAddress && 
							    e.Thread.Id == currentStepRequest.Thread.Id &&
								currentStackDepth == e.Thread.GetFrames ().Length)
								redoCurrentStep = true;
						}
					} else if (e.EventType == EventType.Step) {
						var stepRequest = e.Request as StepEventRequest;
						steppedInto = IsStepIntoRequest (stepRequest);
						steppedOut = IsStepOutRequest (stepRequest);
						etype = TargetEventType.TargetStopped;
						resume = false;
					} else if (e.EventType == EventType.UserBreak) {
						etype = TargetEventType.TargetStopped;
						autoStepInto = false;
						resume = false;
					} else {
						throw new Exception ("Break eventset had unexpected event type " + e.GetType ());
					}
				}
			}
			
			if (redoCurrentStep) {
				StepDepth depth = currentStepRequest.Depth;
				StepSize size = currentStepRequest.Size;
				
				current_thread = recent_thread = es[0].Thread;
				currentStepRequest.Enabled = false;
				currentStepRequest = null;
				
				Step (depth, size);
			} else if (resume) {
				// all breakpoints were conditional and evaluated as false
				current_thread = null;
				vm.Resume ();
				DequeueEventsForFirstThread ();
			} else {
				if (currentStepRequest != null) {
					currentStepRequest.Enabled = false;
					currentStepRequest = null;
				}
				
				current_thread = recent_thread = es[0].Thread;
				
				if (exception != null)
					activeExceptionsByThread [current_thread.ThreadId] = exception;
				
				var backtrace = GetThreadBacktrace (current_thread);
				bool stepInto = false;
				bool stepOut = false;
				
				if (backtrace.FrameCount > 0) {
					var frame = backtrace.GetFrame (0) as SoftDebuggerStackFrame;
					currentAddress = frame != null ? frame.Address : -1;
					currentStackDepth = backtrace.FrameCount;

					if (frame != null && steppedInto) {
						if (ContinueOnStepInto (frame.StackFrame.Method)) {
							current_thread = null;
							vm.Resume ();
							DequeueEventsForFirstThread ();
							return;
						}

						if (StepThrough (frame.StackFrame.Method)) {
							// The method has a Debugger[Hidden,StepThrough,NonUserCode]Attribute on it
							// Keep calling StepInto until we land somewhere without one of these attributes
							stepInto = true;
						} else if (frame.StackFrame.ILOffset == 0 && IsPropertyOrOperatorMethod (frame.StackFrame.Method) &&
						           (Options.StepOverPropertiesAndOperators || IsCompilerGenerated (frame.StackFrame.Method))) {
							//We want to skip property only when we just stepped into property(ILOffset==0)
							//so if user puts breakpoint inside property we don't want to StepOut for him when he steps after breakpoint is hit

							//mcs.exe and Roslyn are also emmiting Sequence point inside auto-properties so breakpoint can be placed
							//we want to always skip auto-properties also when StepOverProperties is disabled hence "|| IsCompilerGenerated"

							// We will want to call StepInto once StepOut returns...
							autoStepInto = true;
							stepOut = true;
						} else if (IsAutoGeneratedFrameworkEnumerator (frame.StackFrame.Method.DeclaringType)) {
							// User asked to step in, but we landed in an autogenerated type (probably an iterator)
							autoStepInto = true;
							stepOut = true;
						}
					} else if (etype == TargetEventType.TargetHitBreakpoint && breakEvent != null && !breakEvent.NonUserBreakpoint && IgnoreBreakpoint (frame.StackFrame.Method)) {
						current_thread = null;
						vm.Resume ();
						DequeueEventsForFirstThread ();
						return;
					}
				}

				if (stepOut) {
					Step (StepDepth.Out, StepSize.Min);
				} else if (stepInto) {
					Step (StepDepth.Into, StepSize.Min);
				} else if (steppedOut && autoStepInto) {
					autoStepInto = false;
					Step (StepDepth.Into, StepSize.Min);
				} else {
					var args = new TargetEventArgs (etype);
					args.Process = OnGetProcesses () [0];
					args.Thread = GetThread (args.Process, current_thread);
					args.Backtrace = backtrace;
					args.BreakEvent = breakEvent;
					
					OnTargetEvent (args);
				}
			}
		}

		public void AddUserAssembly(string userAssembly)
		{
			if (userAssemblyNames != null && !userAssemblyNames.Contains(userAssembly))
				userAssemblyNames.Add(userAssembly);
		}

		void HandleAssemblyLoadEvents (AssemblyLoadEvent[] events)
		{
			var asm = events [0].Assembly;
			if (events.Length > 1 && events.Any (a => a.Assembly != asm))
				throw new InvalidOperationException ("Simultaneous AssemblyLoadEvent for multiple assemblies");

			HandleAssemblyLoaded (asm);
			RegisterAssembly (asm);
			bool isExternal;
			isExternal = !UpdateAssemblyFilters (asm) && userAssemblyNames != null;

			if (outputOptions.ModuleLoaded) { 
				string flagExt = isExternal ? " [External]" : "";
				OnDebuggerOutput (false, string.Format ("Loaded assembly: {0}{1}\n", asm.Location, flagExt));
			}
		}

		private void HandleAssemblyLoaded (AssemblyMirror asm)
		{
			var name = asm.GetName ();
			var assemblyObject = asm.GetAssemblyObject ();
			bool isDynamic = asm.IsDynamic;
			string assemblyName;
			bool hasSymbol;
			if (!isDynamic) {
				assemblyName = name.Name;
				hasSymbol = asm.HasDebugInfo;
			} else {
				assemblyName = string.Empty;
				hasSymbol = false;
			}
			var assembly = new Assembly (
					assemblyName,
					asm?.Location ?? string.Empty,
					true,
					hasSymbol,
					string.Empty,
					string.Empty,
					-1,
					name?.Version?.Major.ToString () ?? string.Empty,
					// TODO: module time stamp
					string.Empty,
					assemblyObject?.Address.ToString () ?? string.Empty,
					string.Format ("[{0}]{1}", asm?.VirtualMachine?.TargetProcess?.Id ?? -1, asm?.VirtualMachine?.TargetProcess?.ProcessName ?? string.Empty),
					asm?.Domain?.FriendlyName ?? string.Empty,
					asm?.VirtualMachine?.TargetProcess?.Id ?? -1,
					hasSymbol,
					isDynamic
			);

			OnAssemblyLoaded (assembly);
		}

		void RegisterAssembly (AssemblyMirror asm)
		{
			var domain = vm.Version.AtLeast (2, 45) ? asm.Domain : asm.GetAssemblyObject ().Domain;
			if (domainAssembliesToUnload.TryGetValue (domain, out var asmList)) {
				asmList.Add (asm);
			} else {
				domainAssembliesToUnload.Add (domain, new HashSet<AssemblyMirror> (new [] { asm }));
			}
		}

		void HandleDomainUnloadEvents (AppDomainUnloadEvent [] events)
		{
			var domain = events [0].Domain;
			if (events.Length > 1 && events.Any (a => a.Domain != domain))
				throw new InvalidOperationException ("Simultaneous DomainUnloadEvents for multiple domains");
			if (domainAssembliesToUnload.TryGetValue (domain, out var asmList)) {
				foreach (var asm in asmList) {
					HandleAssemblyUnloadEvents (asm);
				}
			}
		}

		void HandleAssemblyUnloadEvents (AssemblyMirror asm)
		{
			assemblyFilters?.Remove (asm);

			// Mark affected breakpoints as pending again
			var affectedBreakpoints = new List<KeyValuePair<EventRequest, BreakInfo>> (breakpoints.Where (x => x.Value.Requests.TryGetValue (x.Key, out var a) && a == asm));
			foreach (var breakpoint in affectedBreakpoints) {
				var affectedRequests = breakpoint.Value.Requests.Where (r => r.Value == asm).ToArray ();
				foreach (var item in affectedRequests) {
					breakpoint.Value.Requests.Remove (item.Key);
					breakpoints.Remove (breakpoint.Key);
				}
				if (!breakpoint.Value.Requests.Any ()) {
					string file = breakpoint.Value.Location.SourceFile;
					int line = breakpoint.Value.Location.LineNumber;
					OnDebuggerOutput (false, string.Format ("Re-pending breakpoint at {0}:{1}\n", file, line));
					breakpoint.Value.SetStatus (BreakEventStatus.NotBound, "Assembly unloaded");
				}
			}

			// Remove affected types from the loaded types list
			var affectedTypes = types.SelectMany (l => l.Value).Where (t => t.Assembly == asm).ToArray ();

			foreach (var tm in affectedTypes) {
				List<TypeMirror> typesList;
				if (tm.IsNested) {
					if (aliases.TryGetValue (NestedTypeNameToAlias (tm.FullName), out typesList)) {
						typesList.Remove (tm);
						if (typesList.Count == 0)
							aliases.Remove (NestedTypeNameToAlias (tm.FullName));
					}
				}
				if (types.TryGetValue (tm.FullName, out typesList)) {
					typesList.Remove (tm);
					if (typesList.Count == 0)
						types.Remove (tm.FullName);
				}
			}

			lock (source_to_type) {
				foreach (var pair in source_to_type)
					pair.Value.RemoveAll (m => m.Assembly == asm);
			}

			if (outputOptions.ModuleUnoaded)
				OnDebuggerOutput (false, string.Format ("Unloaded assembly: {0}\n", GetAssemblyLocation (asm) ?? "<unknown>"));
		}

		static string GetAssemblyLocation (AssemblyMirror asm)
		{
			if (asm == null)
				return null;
			try {
				return asm.Location;
			} catch (CommandException ex) {
				if (ex.ErrorCode != ErrorCode.ERR_UNLOADED)
					throw ex;
				return null;
			}
		}

		void HandleVMStartEvents (VMStartEvent[] events)
		{
			var thread = events [0].Thread;
			if (events.Length > 1)
				throw new InvalidOperationException ("Simultaneous VMStartEvents");

			OnStarted (new Mono.Debugging.Client.ThreadInfo (0, GetId (thread), GetThreadName (thread), null));
			//HACK: 2.6.1 VM doesn't emit type load event, so work around it
			var t = vm.RootDomain.Corlib.GetType ("System.Exception", false, false);
			if (t != null) {
				ResolveBreakpoints (t);
			}
		}

		void HandleTypeLoadEvents (TypeLoadEvent[] events)
		{
			var type = events [0].Type;
			if (events.Length > 1 && events.Any (a => a.Type != type))
				throw new InvalidOperationException ("Simultaneous TypeLoadEvents for multiple types");

			List<TypeMirror> typesList;
			if (!(types.TryGetValue (type.FullName, out typesList) && typesList.Contains (type)))
				ResolveBreakpoints (type);
		}

		void HandleThreadStartEvents (ThreadStartEvent[] events)
		{
			current_threads = null;
			var thread = events [0].Thread;
			if (events.Length > 1 && events.Any (a => a.Thread != thread))
				throw new InvalidOperationException ("Simultaneous ThreadStartEvents for multiple threads");

			var name = GetThreadName (thread);
			var id = GetId (thread);
			OnDebuggerOutput (false, string.Format ("Thread started: {0} #{1}\n", name, id));
			OnTargetEvent (new TargetEventArgs (TargetEventType.ThreadStarted) {
				Thread = new Mono.Debugging.Client.ThreadInfo (0, id, name, null),
			});
		}

		void HandleThreadDeathEvents (ThreadDeathEvent[] events)
		{
			current_threads = null;
			ThreadMirror thread;
			try {
				thread = events [0].Thread;
			} catch (ObjectCollectedException) {
				// A 2.1 debugger-agent can send a ThreadDeath event for a ThreadMirror
				// already collected, in that case just allow the session to continue
				if (!vm.Version.AtLeast (2, 2))
					return;

				// Otherwise just report the error
				throw;
			}
			if (events.Length > 1 && events.Any (a => a.Thread != thread))
				throw new InvalidOperationException ("Simultaneous ThreadDeathEvents for multiple threads");

			var name = GetThreadName (thread);
			var id = GetId (thread);
			if (outputOptions.ThreadExited)
				OnDebuggerOutput (false, string.Format ("Thread finished: {0} #{1}\n", name, id));
			OnTargetEvent (new TargetEventArgs (TargetEventType.ThreadStopped) {
				Thread = new Mono.Debugging.Client.ThreadInfo (0, id, name, null),
			});
		}

		void HandleUserLogEvents (UserLogEvent[] events)
		{
			foreach (var ul in events)
				OnTargetDebug (ul.Level, ul.Category, ul.Message);
		}

		void HandleMethodUpdateEvents(MethodUpdateEvent[] methods)
		{
			foreach (var method in methods) //add new methods to type
			{
				method.GetMethod ().ClearCachedLocalsDebugInfo ();
				method.GetMethod ().DeclaringType.AddMethodIfNotExist (method.GetMethod ());
			}
			foreach (var breakpoint in breakpoints) {
				Breakpoint bp = ((Breakpoint)breakpoint.Value.BreakEvent);
				if (bp.UpdatedByEnC) {
					bool dummy = false;
					var l = FindLocationByMethod (breakpoint.Value.Location.Method, bp.FileName, bp.Line, bp.Column, ref dummy);
					if (l != null) {
						breakpoint.Value.Location = l;
						UpdateBreakpoint (bp, breakpoint.Value);
						bp.UpdatedByEnC = false;
					}
				}
			}
			foreach (var bp in pending_bes) {
				if (bp.Status != BreakEventStatus.Bound) {
					foreach (var location in FindLocationsByFile (bp.Breakpoint.FileName, bp.Breakpoint.Line, bp.Breakpoint.Column, out _, out bool insideLoadedRange)) {
						OnDebuggerOutput (false, string.Format ("Resolved pending breakpoint at '{0}:{1},{2}' to {3} [0x{4:x5}].\n",
																bp.Breakpoint.FileName, bp.Breakpoint.Line, bp.Breakpoint.Column,
																GetPrettyMethodName (location.Method), location.ILOffset));

						bp.Location = location;
						InsertBreakpoint (bp.Breakpoint, bp);
						bp.SetStatus (BreakEventStatus.Bound, null);
					}
				}
			}
		}

		public ObjectMirror GetExceptionObject (ThreadMirror thread)
		{
			ObjectMirror obj;

			return activeExceptionsByThread.TryGetValue (thread.ThreadId, out obj) ? obj : null;
		}
		
		void QueueBreakEventSet (Event[] eventSet)
		{
#if DEBUG_EVENT_QUEUEING
			Console.WriteLine ("qq eventset({0}): {1}", eventSet.Length, eventSet[0]);
#endif
			var events = new List<Event> (eventSet);
			lock (queuedEventSets) {
				queuedEventSets.AddLast (events);
			}
		}
		
		void RemoveQueuedBreakEvents (Dictionary<EventRequest, AssemblyMirror> requests)
		{
			int resume = 0;
			
			lock (queuedEventSets) {
				var node = queuedEventSets.First;
				
				while (node != null) {
					List<Event> q = node.Value;
					
					for (int i = 0; i < q.Count; i++) {
						foreach (var request in requests.Keys) {
							if (q[i].Request == request) {
								q.RemoveAt (i--);
								break;
							}
						}
					}
					
					if (q.Count == 0) {
						var d = node;
						node = node.Next;
						queuedEventSets.Remove (d);
						resume++;
					} else {
						node = node.Next;
					}
				}
			}
			
			for (int i = 0; i < resume; i++)
				vm.Resume ();
		}
		
		void DequeueEventsForFirstThread ()
		{
			List<List<Event>> dequeuing;
			lock (queuedEventSets) {
				if (queuedEventSets.Count < 1)
					return;
				
				dequeuing = new List<List<Event>> ();
				var node = queuedEventSets.First;
				
				//making this the current thread means that all events from other threads will get queued
				current_thread = node.Value[0].Thread;
				while (node != null) {
					if (node.Value[0].Thread.Id == current_thread.Id) {
						var d = node;
						node = node.Next;
						dequeuing.Add (d.Value);
						queuedEventSets.Remove (d);
					} else {
						node = node.Next;
					}
				}
			}

#if DEBUG_EVENT_QUEUEING
			foreach (var e in dequeuing)
				Console.WriteLine ("dq eventset({0}): {1}", e.Count, e[0]);
#endif

			//firing this off in a thread prevents possible infinite recursion
			ThreadPool.QueueUserWorkItem (delegate {
				if (!HasExited) {
					foreach (var es in dequeuing) {
						try {
							 HandleBreakEventSet (es.ToArray (), true);
						} catch (Exception ex) {
							if (!HandleException (ex) && outputOptions.ExceptionMessage)
								OnDebuggerOutput (true, ex.ToString ());

							if (ex is VMDisconnectedException || ex is IOException || ex is SocketException) {
								OnTargetEvent (new TargetEventArgs (TargetEventType.TargetExited));
								break;
							}
						}
					}
				}
			});
		}
		
		bool HandleBreakpoint (ThreadMirror thread, EventRequest er)
		{
			BreakInfo binfo;
			if (!breakpoints.TryGetValue (er, out binfo))
				return false;
			
			var bp = binfo.BreakEvent;
			if (bp == null)
				return false;

			binfo.IncrementHitCount ();
			if (!binfo.HitCountReached)
				return true;
			
			if (!string.IsNullOrEmpty (bp.ConditionExpression)) {
				string res = EvaluateExpression (thread, bp.ConditionExpression, bp);
				if (bp.BreakIfConditionChanges) {
					if (res == binfo.LastConditionValue)
						return true;
					binfo.LastConditionValue = res;
				} else {
					if (res == null || res.ToLowerInvariant () != "true")
						return true;
				}
			}
			if ((bp.HitAction & HitAction.CustomAction) != HitAction.None) {
				if (HandleProcessStartHook (thread, bp))
					return true;
				// If custom action returns true, execution must continue
				return binfo.RunCustomBreakpointAction (bp.CustomActionId);
			}

			if ((bp.HitAction & HitAction.PrintTrace) != HitAction.None) {
				OnTargetDebug (0, "", "Breakpoint reached: " + binfo.FileName + ":" + binfo.Location.LineNumber + Environment.NewLine);
			}

			if ((bp.HitAction & HitAction.PrintExpression) != HitAction.None) {
				string exp = EvaluateTrace (thread, bp.TraceExpression);
				binfo.UpdateLastTraceValue (exp);
			}

			// Continue execution if we don't have break action.
			return (bp.HitAction & HitAction.Break) == HitAction.None;
		}
		
		string EvaluateTrace (ThreadMirror thread, string exp)
		{
			var sb = new StringBuilder ();
			int last = 0;
			int i = exp.IndexOf ('{');
			while (i != -1) {
				if (i < exp.Length - 1 && exp [i+1] == '{') {
					sb.Append (exp, last, i - last + 1);
					last = i + 2;
					i = exp.IndexOf ('{', i + 2);
					continue;
				}
				int j = exp.IndexOf ('}', i + 1);
				if (j == -1)
					break;
				string se = exp.Substring (i + 1, j - i - 1);
				se = EvaluateExpression (thread, se, null);
				sb.Append (exp, last, i - last);
				sb.Append (se);
				last = j + 1;
				i = exp.IndexOf ('{', last);
			}
			sb.Append (exp, last, exp.Length - last);
			return sb.ToString ();
		}

		static SourceLocation GetSourceLocation (StackFrame frame)
		{
			return new SourceLocation (frame.Method.Name, frame.FileName, frame.LineNumber, frame.ColumnNumber, frame.EndLineNumber, frame.EndColumnNumber);
		}

		static string FormatSourceLocation (BreakEvent breakEvent)
		{
			var bp = breakEvent as Breakpoint;
			if (bp == null || string.IsNullOrEmpty (bp.FileName))
				return null;

			var location = Path.GetFileName (bp.FileName);
			if (bp.OriginalLine > 0) {
				location += ":" + bp.OriginalLine;
				if (bp.OriginalColumn > 0)
					location += "," + bp.OriginalColumn;
			}

			return location;
		}

		static bool IsBoolean (ValueReference vr)
		{
			if (vr.Type is Type && ((Type) vr.Type) == typeof (bool))
				return true;

			if (vr.Type is TypeMirror && ((TypeMirror) vr.Type).FullName == "System.Boolean")
				return true;

			return false;
		}
		
		string EvaluateExpression (ThreadMirror thread, string expression, BreakEvent bp)
		{
			try {
				var frames = thread.GetFrames ();
				if (frames.Length == 0)
					return string.Empty;

				EvaluationOptions ops = Options.EvaluationOptions.Clone ();
				ops.AllowTargetInvoke = true;
				ops.EllipsizedLength = 1000;

				var ctx = new SoftEvaluationContext (this, frames[0], ops);

				if (bp != null) {
					// validate conditional breakpoint expressions so that we can provide error reporting to the user
					var vr = ctx.Evaluator.ValidateExpression (ctx, expression);
					if (!vr.IsValid) {
						string message = string.Format ("Invalid expression in conditional breakpoint. {0}", vr.Message);
						string location = FormatSourceLocation (bp);

						if (!string.IsNullOrEmpty (location))
							message = location + ": " + message;

						OnDebuggerOutput (true, message);
						return string.Empty;
					}

					// resolve types...
					if (ctx.SourceCodeAvailable)
						expression = ctx.Evaluator.Resolve (this, GetSourceLocation (frames[0]), expression);
				}

				ValueReference val = ctx.Evaluator.Evaluate (ctx, expression);
				if (bp != null && !bp.BreakIfConditionChanges && !IsBoolean (val)) {
					string message = string.Format ("Expression in conditional breakpoint did not evaluate to a boolean value: {0}", bp.ConditionExpression);
					string location = FormatSourceLocation (bp);

					if (!string.IsNullOrEmpty (location))
						message = location + ": " + message;

					OnDebuggerOutput (true, message);
					return string.Empty;
				}

				return val.CreateObjectValue (false).Value;
			} catch (EvaluatorException ex) {
				string message;

				if (bp != null) {
					message = string.Format ("Failed to evaluate expression in conditional breakpoint. {0}", ex.Message);
					string location = FormatSourceLocation (bp);

					if (!string.IsNullOrEmpty (location))
						message = location + ": " + message;
				} else {
					message = ex.ToString ();
				}

				OnDebuggerOutput (true, message);
				return string.Empty;
			} catch (Exception ex) {
				OnDebuggerOutput (true, ex.ToString ());
				return string.Empty;
			}
		}

		static string NestedTypeNameToAlias (string typeName)
		{
			int index = typeName.IndexOfAny (new [] { '[', ',' });

			if (index == -1)
				return typeName.Replace ('+', '.');

			var prefix = typeName.Substring (0, index).Replace ('+', '.');
			var suffix = typeName.Substring (index);

			return prefix + suffix;
		}
		
		void ProcessType (TypeMirror t)
		{
			string typeName = t.FullName;

			List<TypeMirror> typesList;
			if (types.TryGetValue (typeName, out typesList) && typesList.Contains (t))
				return;

			RegisterAssembly (t.Assembly);

			if (t.IsNested) {
				var alias = NestedTypeNameToAlias (typeName);
				List<TypeMirror> aliasesList;
				if (aliases.TryGetValue (alias, out aliasesList)) {
					aliasesList.Add (t);
				} else {
					aliases [alias] = new List<TypeMirror> (new [] { t });
				}
			}
			types [typeName] = typesList ?? new List<TypeMirror> ();
			types [typeName].Add (t);

			//get the source file paths
			//full paths, from GetSourceFiles (true), are only supported by sdb protocol 2.2 and later
			string[] sourceFiles;
			if (vm.Version.AtLeast (2, 2)) {
				sourceFiles = t.GetSourceFiles ().Select ((fullPath) => Path.GetFileName (fullPath)).ToArray ();
			} else {
				sourceFiles = t.GetSourceFiles ();
				
				//HACK: if mdb paths are windows paths but the sdb agent is on unix, it won't map paths to filenames correctly
				if (IsWindows) {
					for (int i = 0; i < sourceFiles.Length; i++) {
						string s = sourceFiles[i];
						if (s != null && !s.StartsWith ("/", StringComparison.Ordinal))
							sourceFiles[i] = Path.GetFileName (s);
					}
				}
			}
			
			for (int n = 0; n < sourceFiles.Length; n++)
				sourceFiles[n] = NormalizePath (sourceFiles[n]);

			foreach (string s in sourceFiles) {
				lock (source_to_type) {
					if (source_to_type.TryGetValue (s, out typesList)) {
						typesList.Add (t);
					} else {
						typesList = new List<TypeMirror> ();
						typesList.Add (t);
						source_to_type[s] = typesList;
					}
				}
			}

			type_to_source [t] = sourceFiles;
		}
		
		static string[] GetParamTypes (MethodMirror method)
		{
			var paramTypes = new List<string> ();
			
			foreach (var param in method.GetParameters ())
				paramTypes.Add (param.ParameterType.CSharpName);
			
			return paramTypes.ToArray ();
		}

		string GetPrettyMethodName (MethodMirror method)
		{
			var name = new StringBuilder ();

			name.Append (Adaptor.GetDisplayTypeName (method.ReturnType.FullName));
			name.Append (" ");
			name.Append (Adaptor.GetDisplayTypeName (method.DeclaringType.FullName));
			name.Append (".");
			name.Append (method.Name);

			if (method.VirtualMachine.Version.AtLeast (2, 12)) {
				if (method.IsGenericMethodDefinition || method.IsGenericMethod) {
					name.Append ("<");
					if (method.VirtualMachine.Version.AtLeast (2, 15)) {
						var argTypes = method.GetGenericArguments ();
						for (int i = 0; i < argTypes.Length; i++) {
							if (i != 0)
								name.Append (", ");
							name.Append (Adaptor.GetDisplayTypeName (argTypes[i].FullName));
						}
					}
					name.Append (">");
				}
			}

			name.Append (" (");
			var @params = method.GetParameters ();
			for (int i = 0; i < @params.Length; i++) {
				if (i != 0)
					name.Append (", ");
				if (@params[i].Attributes.HasFlag (ParameterAttributes.Out)) {
					if (@params[i].Attributes.HasFlag (ParameterAttributes.In))
						name.Append ("ref ");
					else
						name.Append ("out ");
				}
				name.Append (Adaptor.GetDisplayTypeName (@params[i].ParameterType.FullName));
				name.Append (" ");
				name.Append (@params[i].Name);
			}
			name.Append (")");

			return name.ToString ();
		}

		void ResolveBreakpoints (TypeMirror type)
		{
			Location loc;
			
			ProcessType (type);

			// First, resolve FunctionBreakpoints
			BreakInfo [] tempPendingBes;
			lock (pending_bes) {
				tempPendingBes = pending_bes.Where (b => b.BreakEvent is FunctionBreakpoint).ToArray ();
			}
			foreach (var bi in tempPendingBes) {
				if (CheckTypeName (type, bi.TypeName)) {
					var bp = (FunctionBreakpoint)bi.BreakEvent;
					foreach (var method in FindMethodsByName (bp.TypeName, bp.MethodName, bp.ParamTypes)) {
						ResolveFunctionBreakpoint (bi, bp, method);
					}
				}
			}

			// Now resolve normal Breakpoints
			foreach (string s in type_to_source [type]) {
				lock (pending_bes) {
					tempPendingBes = pending_bes.Where (b => (b.BreakEvent is Breakpoint) && !(b.BreakEvent is FunctionBreakpoint)).ToArray ();
				}
				foreach (var bi in tempPendingBes) {
					var bp = (Breakpoint) bi.BreakEvent;
					if (PathComparer.Compare (Path.GetFileName (bp.FileName), s) == 0) {
						bool insideLoadedRange;
						bool genericMethod;

						if (bi.BreakEvent is InstructionBreakpoint) {
							loc = FindLocationByILOffset ((InstructionBreakpoint)bi.BreakEvent, bp.FileName, out genericMethod, out insideLoadedRange);
						} else {
							loc = FindLocationByType (type, bp.FileName, bp.Line, bp.Column, out genericMethod, out insideLoadedRange);
						}
						if (loc != null) {
							OnDebuggerOutput (false, string.Format ("Resolved pending breakpoint at '{0}:{1},{2}' to {3} [0x{4:x5}].\n",
							                                        s, bp.Line, bp.Column, GetPrettyMethodName (loc.Method), loc.ILOffset));
							ResolvePendingBreakpoint (bi, loc);
						} else {
							if (insideLoadedRange) {
								bi.SetStatus (BreakEventStatus.Invalid, null);
							}
						}
					}
				}
			}

			// Thirdly, resolve pending catchpoints
			lock (pending_bes) {
				tempPendingBes = pending_bes.Where (b => b.BreakEvent is Catchpoint).ToArray ();
			}
			foreach (var bi in tempPendingBes) {
				var cp = (Catchpoint) bi.BreakEvent;
				if (cp.ExceptionName == type.FullName) {
					ResolvePendingCatchpoint (bi, type);
				}
			}
		}

		bool ResolveFunctionBreakpoint (BreakInfo bi, FunctionBreakpoint bp, MethodMirror method)
		{
			var loc = method.Locations.FirstOrDefault ();
			string paramList = "(" + string.Join (", ", bp.ParamTypes ?? GetParamTypes (method)) + ")";
			if (loc != null) {
				bi.Location = loc;
				InsertBreakpoint (bp, bi);
				OnDebuggerOutput (false, string.Format ("Resolved pending breakpoint for '{0}{1}' to {2}:{3} [0x{4:x5}].\n",
														bp.FunctionName, paramList, loc.SourceFile, loc.LineNumber, loc.ILOffset));
			} else {
				InsertBreakpoint (bp, bi, method, 0);
				OnDebuggerOutput (false, string.Format ("Resolved pending breakpoint for '{0}{1}' to [0x0](no debug symbols).\n",
														bp.FunctionName, paramList));
			}
			bi.SetStatus (BreakEventStatus.Bound, null);
			// Note: if the type or method is generic, there may be more instances so don't assume we are done resolving the breakpoint
			return bp.ParamTypes != null && !method.DeclaringType.IsGenericType && !IsGenericMethod (method);
		}

		internal static string NormalizePath (string path)
		{
			if (!IsWindows && (path.StartsWith ("\\", StringComparison.Ordinal) || (path.Length > 3 && path [1] == ':' && path [2] == '\\')))
				return path.Replace ('\\', '/');

			return path;
		}

		[DllImport ("libc")]
		static extern IntPtr realpath (string path, IntPtr buffer);
		
		static string ResolveFullPath (string path)
		{
			if (IsWindows)
				return Path.GetFullPath (path);

			const int PATHMAX = 4096 + 1;
			IntPtr buffer = IntPtr.Zero;

			try {
				buffer = Marshal.AllocHGlobal (PATHMAX);
				var result = realpath (path, buffer);
				var realPath = result == IntPtr.Zero ? "" : Marshal.PtrToStringAuto (buffer);

				if (string.IsNullOrEmpty(realPath) && !File.Exists(path)) {
					// if the file does not exist then `realpath` will return empty string
					// default to what we would do if calling this on windows
					realPath = Path.GetFullPath (path);
				}

				return realPath;
			} finally {
				if (buffer != IntPtr.Zero)
					Marshal.FreeHGlobal (buffer);
			}
		}

		static string ResolveSymbolicLink (string path)
		{
			if (path.Length == 0)
				return path;

			if (IsWindows)
				return ResolveWindowsSymbolicLink (path);

            return ResolveUnixSymbolicLink (path);
		}

        static string ResolveWindowsSymbolicLink (string path)
        {
            return Path.GetFullPath (path);
        }

        static string ResolveUnixSymbolicLink (string path)
        {
			/*try {
				var alreadyVisted = new HashSet<string> ();

				while (true) {
					if (alreadyVisted.Contains (path))
						return string.Empty;

					alreadyVisted.Add (path);

					var linkInfo = new Mono.Unix.UnixSymbolicLinkInfo (path);
					if (linkInfo.IsSymbolicLink && linkInfo.HasContents) {
						string contentsPath = linkInfo.ContentsPath;

						if (!Path.IsPathRooted (contentsPath))
							path = Path.Combine (Path.GetDirectoryName (path), contentsPath);
						else
							path = contentsPath;

						path = ResolveFullPath (path);
						continue;
					}

					path = Path.Combine (ResolveSymbolicLink (Path.GetDirectoryName (path)), Path.GetFileName (path));

					return ResolveFullPath (path);
				}
			} catch {
				return path;
			}*/
			return path;
        }
		
		static bool PathsAreEqual (string p1, string p2)
		{
			if (string.IsNullOrWhiteSpace (p1) || string.IsNullOrWhiteSpace (p2))
				return false;

			if (PathComparer.Compare (p1, p2) == 0)
				return true;

			var rp1 = ResolveSymbolicLink (p1);
			var rp2 = ResolveSymbolicLink (p2);

			return PathComparer.Compare (rp1, rp2) == 0;
		}

		Location FindLocationByMethod (MethodMirror method, string file, int line, int column, ref bool insideTypeRange)
		{
			int rangeFirstLine = int.MaxValue;
			int rangeLastLine = -1;
			Location target = null;

			//Console.WriteLine ("FindLocationByMethod: method = {0}, file = {1}, line = {2}, column = {3}", method.Name, Path.GetFileName (file), line, column);

			foreach (var location in method.Locations) {
				var srcFile = location.SourceFile;

				//Console.WriteLine ("\tChecking location {0}:{1},{2}...", Path.GetFileName(srcFile), location.LineNumber, location.ColumnNumber);

				//Check if file names match
				if (srcFile != null && PathComparer.Compare (Path.GetFileName (NormalizePath (srcFile)), Path.GetFileName (file)) == 0) {
					//Check if full path match(we don't care about md5 if full path match):
					//1. For backward compatibility
					//2. If full path matches user himself probably modified code and is aware of modifications
					//OR if md5 match, useful for alternative location files with breakpoints
					if (!PathsAreEqual (NormalizePath (srcFile), file) && !SourceLocation.CheckFileHash (file, location.SourceFileHash))
						continue;

					if (location.LineNumber < rangeFirstLine)
						rangeFirstLine = location.LineNumber;

					if (location.LineNumber > rangeLastLine)
						rangeLastLine = location.LineNumber;

					if (line >= rangeFirstLine && line <= rangeLastLine)
						insideTypeRange = true;

					if (line == location.LineNumber && (column <= 1 || column == location.ColumnNumber)) {
						if (target != null) {
							if (location.ILOffset < target.ILOffset)
								target = location;
						} else {
							target = location;
						}
					}
				} else {
					rangeFirstLine = int.MaxValue;
					rangeLastLine = -1;
				}
			}

			return target;
		}

		Location FindLocationByType (TypeMirror type, string file, int line, int column, out bool genericMethod, out bool insideTypeRange)
		{
			var methodInsideTypeRange = false;
			Location target = null;

			insideTypeRange = false;
			genericMethod = false;

			foreach (var method in type.GetMethods ()) {
				Location location = null;

				if ((location = FindLocationByMethod (method, file, line, column, ref methodInsideTypeRange)) != null) {
					insideTypeRange |= methodInsideTypeRange;//If any method returns true return true

					if (target != null) {
						// Use the location with the lowest ILOffset
						if (location.ILOffset < target.ILOffset) {
							genericMethod = IsGenericMethod (method);
							target = location;
						}
					} else {
						genericMethod = IsGenericMethod (method);
						target = location;
					}
				}
			}
			
			return target;
		}

		void ResolvePendingBreakpoint (BreakInfo bi, Location l)
		{
			bi.Location = l;
			InsertBreakpoint ((Breakpoint) bi.BreakEvent, bi);
			bi.SetStatus (BreakEventStatus.Bound, null);
		}
				
		void ResolvePendingCatchpoint (BreakInfo bi, TypeMirror type)
		{
			InsertCatchpoint ((Catchpoint) bi.BreakEvent, bi, type);
			bi.SetStatus (BreakEventStatus.Bound, null);
		}
		
		bool UpdateAssemblyFilters (AssemblyMirror asm)
		{
			var name = asm.GetName ().FullName;
			bool found = false;
			if (userAssemblyNames != null) {
				//HACK: not sure how else to handle xsp-compiled pages
				if (name.StartsWith ("App_", StringComparison.Ordinal)) {
					found = true;
				} else {
					foreach (var n in userAssemblyNames) {
						if (n == name) {
							found = true;
							break;
						}
					}
				}
			}

			if (found) {
				assemblyFilters.Add (asm);
				return true;
			}

			return false;
		}
		
		internal void WriteDebuggerOutput (bool isError, string msg)
		{
			OnDebuggerOutput (isError, msg);
		}
		
		protected override void OnSetActiveThread (long processId, long threadId)
		{
		}

		protected override void OnStepInstruction ()
		{
			Step (StepDepth.Into, StepSize.Min);
		}

		protected override void OnStepLine ()
		{
			Step (StepDepth.Into, StepSize.Line);
		}

		protected override void OnStop ()
		{
			vm.Suspend ();
			
			//emit a stop event at the current position of the most recent thread
			//we use "getprocesses" instead of "ongetprocesses" because it attaches the process to the session
			//using private Mono.Debugging API, so our thread/backtrace calls will cache stuff that will get used later
			var process = GetProcesses () [0];				
			EnsureRecentThreadIsValid (process);
			current_thread = recent_thread;
			OnTargetEvent (new TargetEventArgs (TargetEventType.TargetStopped) {
				Process = process,
				Thread = GetThread (process, recent_thread),
				Backtrace = GetThreadBacktrace (recent_thread)});
		}
		
		void EnsureRecentThreadIsValid (ProcessInfo process)
		{
			var infos = process.GetThreads ();
			
			if (ThreadIsAlive (recent_thread) && HasUserFrame (GetId (recent_thread), infos))
				return;

			var threads = vm.GetThreads ();
			foreach (var thread in threads) {
				if (ThreadIsAlive (thread) && HasUserFrame (GetId (thread), infos)) {
					recent_thread = thread;
					return;
				}
			}
			recent_thread = threads[0];	
		}
		
		long GetId (ThreadMirror thread)
		{
			long id;
			if (!localThreadIds.TryGetValue (thread.ThreadId, out id)) {
				id = localThreadIds.Count + 1;
				localThreadIds [thread.ThreadId] = id;
			}
			return id;
		}
		
		static bool ThreadIsAlive (ThreadMirror thread)
		{
			if (thread == null)
				return false;
			ThreadState state;
			try {
				state = thread.ThreadState;
			} catch (ObjectCollectedException) {
				return false;//Thread was already collected by garbage collector, hence it's not alive
			}
			return state != ThreadState.Stopped && state != ThreadState.Aborted;
		}
		
		//we use the Mono.Debugging classes because they are cached
		static bool HasUserFrame (long tid, Mono.Debugging.Client.ThreadInfo[] threads)
		{
			foreach (var thread in threads) {
				if (thread.Id != tid)
					continue;

				var bt = thread.Backtrace;
				for (int i = 0; i < bt.FrameCount; i++) {
					var frame = bt.GetFrame (i);
					if (frame != null && !frame.IsExternalCode)
						return true;
				}

				return false;
			}

			return false;
		}
		
		public bool IsExternalCode (StackFrame frame)
		{
			return frame.Method == null || string.IsNullOrEmpty (frame.FileName)
				|| (assemblyFilters != null && !assemblyFilters.Contains (frame.Method.DeclaringType.Assembly));
		}
		
		public bool IsExternalCode (TypeMirror type)
		{
			return assemblyFilters != null && !assemblyFilters.Contains (type.Assembly);
		}
		
		protected override AssemblyLine[] OnDisassembleFile (string file)
		{
			List<TypeMirror> mirrors;

			if (!source_to_type.TryGetValue (file, out mirrors))
				return new AssemblyLine [0];
			
			var lines = new List<AssemblyLine> ();
			foreach (var type in mirrors) {
				foreach (var method in type.GetMethods ()) {
					string srcFile = method.SourceFile != null ? NormalizePath (method.SourceFile) : null;
					
					if (srcFile == null || !PathsAreEqual (srcFile, file))
						continue;
					
					var body = method.GetMethodBody ();
					int lastLine = -1;
					int firstPos = lines.Count;
					string addrSpace = method.FullName;
					
					foreach (var ins in body.Instructions) {
						var loc = method.LocationAtILOffset (ins.Offset);

						if (loc != null && lastLine == -1) {
							lastLine = loc.LineNumber;
							for (int n = firstPos; n < lines.Count; n++) {
								AssemblyLine old = lines [n];
								lines [n] = new AssemblyLine (old.Address, old.AddressSpace, old.Code, loc.LineNumber);
							}
						}

						lines.Add (new AssemblyLine (ins.Offset, addrSpace, Disassemble (ins), loc != null ? loc.LineNumber : lastLine));
					}
				}
			}

			lines.Sort (delegate (AssemblyLine a1, AssemblyLine a2) {
				int res = a1.SourceLine.CompareTo (a2.SourceLine);

				return res != 0 ? res : a1.Address.CompareTo (a2.Address);
			});

			return lines.ToArray ();
		}

		public AssemblyLine[] Disassemble (StackFrame frame)
		{
			var body = frame.Method.GetMethodBody ();
			var instructions = body.Instructions;
			var lines = new List<AssemblyLine> ();

			foreach (var instruction in instructions) {
				var location = frame.Method.LocationAtILOffset (instruction.Offset);
				int lineNumber = location != null ? location.LineNumber : -1;
				var code = Disassemble (instruction);

				lines.Add (new AssemblyLine (instruction.Offset, frame.Method.FullName, code, lineNumber));
			}

			return lines.ToArray ();
		}
		
		public AssemblyLine[] Disassemble (StackFrame frame, int firstLine, int count)
		{
			var body = frame.Method.GetMethodBody ();
			var instructions = body.Instructions;
			ILInstruction current = null;

			foreach (var instruction in instructions) {
				if (instruction.Offset >= frame.ILOffset) {
					current = instruction;
					break;
				}
			}

			if (current == null)
				return new AssemblyLine [0];
			
			var lines = new List<AssemblyLine> ();
			
			while (firstLine < 0 && count > 0) {
				if (current.Previous == null) {
					lines.Add (AssemblyLine.OutOfRange);
					firstLine = 0;
					break;
				}

				current = current.Previous;
				firstLine++;
			}
			
			while (current != null && firstLine > 0) {
				current = current.Next;
				firstLine--;
			}
			
			while (count > 0) {
				if (current != null) {
					var location = frame.Method.LocationAtILOffset (current.Offset);
					int lineNumber = location != null ? location.LineNumber : -1;
					var code = Disassemble (current);

					lines.Add (new AssemblyLine (current.Offset, frame.Method.FullName, code, lineNumber));
					current = current.Next;
				} else {
					lines.Add (AssemblyLine.OutOfRange);
				}

				count--;
			}

			return lines.ToArray ();
		}

		public void AddSourceUpdate (string fileName)
		{
			sourceUpdates.Add (new SourceUpdate(fileName));
		}
		public void AddLineUpdate (int oldLine, int newLine)
		{
			sourceUpdates.Last().LineUpdates.Add (new Tuple<int, int>(oldLine, newLine));
		}
		public void ApplyChanges (ModuleMirror module, byte[] metadataDelta, byte[] ilDelta, byte[] pdbDelta = null)
		{
			var rootDomain = VirtualMachine.RootDomain;
			var metadataArray = rootDomain.CreateByteArray (metadataDelta);
			var ilArray = rootDomain.CreateByteArray (ilDelta);
			Value pdbArray;
			if (pdbDelta == null)
				pdbArray = VirtualMachine.CreateValue (null);
			else
				pdbArray = rootDomain.CreateByteArray (pdbDelta);

			module.Assembly.ApplyChanges_DebugInformation (metadataDelta, pdbDelta);
			module.ApplyChanges (metadataArray, ilArray, pdbArray);
			foreach (var sourceUpdate in sourceUpdates)
			{
				var types = VirtualMachine.GetTypesForSourceFile (sourceUpdate.FileName, false);
				foreach (var type in types)
				{
					type.ApplySourceChanges (sourceUpdate);
				}
			}
			sourceUpdates.Clear ();
		}

		public string GetEnCCapabilities()
		{
			return vm.GetEnCCapabilities ();
		}
		static string EscapeString (string text)
		{
			var escaped = new StringBuilder ();
			
			escaped.Append ('"');
			for (int i = 0; i < text.Length; i++) {
				char c = text[i];
				string txt;
				switch (c) {
				case '"': txt = "\\\""; break;
				case '\0': txt = @"\0"; break;
				case '\\': txt = @"\\"; break;
				case '\a': txt = @"\a"; break;
				case '\b': txt = @"\b"; break;
				case '\f': txt = @"\f"; break;
				case '\v': txt = @"\v"; break;
				case '\n': txt = @"\n"; break;
				case '\r': txt = @"\r"; break;
				case '\t': txt = @"\t"; break;
				default:
					if (char.GetUnicodeCategory (c) == UnicodeCategory.OtherNotAssigned) {
						escaped.AppendFormat ("\\u{0:X4}", c);
					} else {
						escaped.Append (c);
					}
					continue;
				}
				escaped.Append (txt);
			}
			escaped.Append ('"');
			
			return escaped.ToString ();
		}
		
		static string Disassemble (ILInstruction ins)
		{
			string oper;
			if (ins.Operand is MethodMirror)
				oper = ((MethodMirror)ins.Operand).FullName;
			else if (ins.Operand is FieldInfoMirror)
				oper = ((FieldInfoMirror)ins.Operand).FullName;
			else if (ins.Operand is TypeMirror)
				oper = ((TypeMirror)ins.Operand).FullName;
			else if (ins.Operand is ILInstruction)
				oper = ((ILInstruction)ins.Operand).Offset.ToString ("x8");
			else if (ins.Operand is string)
				oper = EscapeString ((string) ins.Operand);
			else if (ins.Operand == null)
				oper = string.Empty;
			else
				oper = ins.Operand.ToString ();
			
			return ins.OpCode + " " + oper;
		}
		
		readonly static bool IsWindows;
		readonly static bool IsMac;
		readonly static StringComparer PathComparer;
		
		static bool IgnoreFilenameCase {
			get { return IsMac || IsWindows; }
		}
		
		static SoftDebuggerSession ()
		{
			IsWindows = Path.DirectorySeparatorChar == '\\';
			IsMac = !IsWindows && IsRunningOnMac ();
			PathComparer = IgnoreFilenameCase ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
			ThreadMirror.NativeTransitions = true;
		}
		
		//From Managed.Windows.Forms/XplatUI
		static bool IsRunningOnMac ()
		{
			IntPtr buf = IntPtr.Zero;
			try {
				buf = Marshal.AllocHGlobal (8192);
				// This is a hacktastic way of getting sysname from uname ()
				if (uname (buf) == 0) {
					string os = Marshal.PtrToStringAnsi (buf);
					if (os == "Darwin")
						return true;
				}
			} catch {
				return false;
			} finally {
				if (buf != IntPtr.Zero)
					Marshal.FreeHGlobal (buf);
			}
			return false;
		}
		
		[System.Runtime.InteropServices.DllImport ("libc")]
		static extern int uname (IntPtr buf);
	}

	class LocationComparer : IComparer<Location>
	{
		public int Compare (Location loc0, Location loc1)
		{
			if (loc0.LineNumber < loc1.LineNumber)
				return -1;
			if (loc0.LineNumber > loc1.LineNumber)
				return 1;

			if (loc0.ColumnNumber < loc1.ColumnNumber)
				return -1;
			if (loc0.ColumnNumber > loc1.ColumnNumber)
				return 1;

			return loc0.ILOffset - loc1.ILOffset;
		}
	}
	
	class BreakInfo: BreakEventInfo
	{
		public Location Location;
		public Dictionary<EventRequest, AssemblyMirror> Requests = new Dictionary<EventRequest, AssemblyMirror> ();
		public string LastConditionValue;
		public string FileName;
		public string TypeName;
	}
	
	class DisconnectedException: DebuggerException
	{
		public DisconnectedException (Exception ex):
			base ("The connection with the debugger has been lost. The target application may have exited.", ex)
		{
		}
	}
	
	class DebugSocketException: DebuggerException
	{
		public DebugSocketException (Exception ex):
			base ("Could not open port for debugger. Another process may be using the port.", ex)
		{
		}
	}
	
	class ConnectionException : DebuggerException
	{
		public ConnectionException (Exception ex):
			base ("Could not connect to the debugger.", ex)
		{
		}
	}
}