Attachment 352330 Details for Bug 587470

test program, run using gtest.exe <app to debug>

gtest.cs (text/x-csharp), 16.55 KB, created by Forgotten User vxPDddArjq on 2010-04-03 09:50:05 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Forgotten User vxPDddArjq

Created: 2010-04-03 09:50:05 UTC

Size: 16.55 KB

patch

obsolete

>using System;
>using System.Collections.Generic;
>using System.Runtime.Remoting;
>using System.Net;
>using System.Threading;
>using Mono.Cecil;
>using Mono.Cecil.Metadata;
>using Mono.Cecil.Cil;
>using Mono.Options;
>using Diag = System.Diagnostics;
>
>using Mono.Debugger.Soft;
>
>public class test
>{
>	static VirtualMachine vm;
>	static MethodMirror entry_point;
>	static bool valgrind, listen;
>	static string agent_args;
>
>	public static void stress_dispose (String[] args) {
>		for (int i = 0; i < 1000; ++i) {
>			vm = VirtualMachineManager.Launch (args, new LaunchOptions { AgentArgs = "loglevel=0" });
>
>			vm.EnableEvents (EventType.AssemblyLoad);
>
>			Event vmstart = vm.GetNextEvent ();
>			Console.WriteLine ("-- " + vmstart + " --");
>			
>			run_until_entry_assembly ();
>
>			run_until ("Main");
>
>			vm.Dispose ();
>		}
>	}
>
>	public static void stress_exit_suspended (String[] args) {
>		args = new string [] { "dtest-app.exe", "suspend-test" };
>
>		for (int i = 0; i < 1000; ++i) {
>			if (listen)
>				vm = VirtualMachineManager.Listen (new IPEndPoint (IPAddress.Loopback, 10000));
>			else
>				vm = VirtualMachineManager.Launch (args, new LaunchOptions { AgentArgs = "loglevel=0" });
>
>			vm.EnableEvents (EventType.AssemblyLoad);
>
>			Event vmstart = vm.GetNextEvent ();
>			Console.WriteLine ("-- " + vmstart + " --");
>
>			run_until_entry_assembly ();
>
>			run_until ("suspend");
>
>			vm.Resume ();
>
>			Thread.Sleep (100);
>
>			vm.Suspend ();
>
>			vm.Exit (0);
>		}
>	}
>
>	public static void stress_other (String[] args) {
>		for (int i = 0; i < 1000; ++i) {
>			if (listen)
>				vm = VirtualMachineManager.Listen (new IPEndPoint (IPAddress.Loopback, 10000));
>			else
>				vm = VirtualMachineManager.Launch (args, new LaunchOptions { AgentArgs = "loglevel=0" });
>
>			vm.EnableEvents (EventType.AssemblyLoad, EventType.ThreadStart);
>
>			Event vmstart = vm.GetNextEvent ();
>			Console.WriteLine ("-- " + vmstart + " --");
>
>			Event e;
>
>			run_until_entry_assembly ();
>
>			MethodMirror m = entry_point.DeclaringType.GetMethod ("bp6");
>
>			vm.SetBreakpoint (m, 0);
>
>			vm.Resume ();
>
>			//Thread.Sleep (100);
>
>			e = vm.GetNextEvent ();
>			if (e.EventType != EventType.Breakpoint) {
>				vm.Resume ();
>
>				Thread.Sleep (100);
>				Console.WriteLine ((e as ThreadStartEvent).Thread.Name);
>				return;
>			}
>
>			vm.Dispose ();
>		}
>	}
>
>	/*
>	 * Stress test the debugger by single stepping, querying all the available
>	 * state at every stop.
>	 */
>	public static void run_stress (String[] args) {
>		if (listen)
>			vm = VirtualMachineManager.Listen (new IPEndPoint (IPAddress.Loopback, 10000));
>		else {
>			var pi = new Diag.ProcessStartInfo ("./mono");
>			pi.Arguments = String.Join (" ", args);
>
>			vm = VirtualMachineManager.Launch (args, new LaunchOptions { Valgrind = valgrind, AgentArgs = agent_args });
>		}
>
>		vm.EnableEvents (EventType.AssemblyLoad, EventType.ThreadStart);
>
>		Event vmstart = vm.GetNextEvent ();
>
>		Event e;
>
>		// FIXME: Add options to run different kinds of single steps, query different
>		// state etc.
>		bool enable_ss = true;
>		bool enable_il = true;
>		bool enable_entry_exit = true;
>
>		if (enable_ss) {
>			var req3 = vm.CreateStepRequest (vmstart.Thread);
>			req3.Enable ();
>		}
>
>		if (enable_entry_exit) {
>			var req1 = vm.CreateMethodEntryRequest ();
>			var req2 = vm.CreateMethodExitRequest ();
>
>			req1.Enable ();
>			req2.Enable ();
>		}
>
>		int count = 0;
>
>		var il_ok = new Dictionary<MethodMirror, MethodMirror> ();
>
>		while (true) {
>			vm.Resume ();
>
>			e = vm.GetNextEvent ();
>			//Console.WriteLine ("-- " + e + " --");
>
>			if (e is VMDeathEvent)
>				break;
>
>			count ++;
>			if ((count % 100) == 0)
>				Console.Write (".");
>
>			if (e is ThreadStartEvent) {
>				string name = ((ThreadStartEvent)e).Thread.Name;
>			}
>
>			if (e.Thread != null) {
>				var frames = e.Thread.GetFrames ();
>
>				foreach (var f in frames) {
>					var m = f.Method;
>					var l = f.Location;
>					//Console.WriteLine (m.FullName);
>					var this_obj = f.GetThis ();
>
>					foreach (var par in m.GetParameters ()) {
>						var par_val = f.GetValue (par);
>					}
>
>					f.GetValues (m.GetLocals ());
>
>					if (!il_ok.ContainsKey (m)) {
>						var mb = m.GetMethodBody ();
>						foreach (var il in mb.Instructions) {
>							var operand = il.Operand;
>						}
>						il_ok [m] = m;
>					}
>				}
>					
>			}
>		}
>
>		Console.WriteLine ();
>	}
>
>	/*
>	 * Stress test async suspension
>	 */
>	public static void run_suspend_stress (String[] args) {
>		if (listen)
>			vm = VirtualMachineManager.Listen (new IPEndPoint (IPAddress.Loopback, 10000));
>		else {
>			var pi = new Diag.ProcessStartInfo ("./mono");
>			pi.Arguments = String.Join (" ", args);
>
>			vm = VirtualMachineManager.Launch (args, new LaunchOptions { Valgrind = valgrind, AgentArgs = agent_args });
>		}
>
>		Event vmstart = vm.GetNextEvent ();
>
>		Event e;
>
>		int count = 0;
>
>		while (true) {
>			Console.Write (".");
>
>			vm.Resume ();
>
>			Thread.Sleep (1);
>
>			try {
>				vm.Suspend ();
>
>				//Thread.Sleep (10);
>
>				foreach (ThreadMirror t in vm.GetThreads ()) {
>					var frames = t.GetFrames ();
>				}
>			} catch (VMDisconnectedException) {
>				break;
>			}
>		}
>
>		Console.WriteLine ();
>	}
>
>	public static int Main (String[] args) {
>		var p = new OptionSet () {
>				{"valgrind", "Run the debuggee under valgrind." , v => valgrind = true },
>				{"agent-args=", "Extra arguments to pass to the debugger agent in the debuggee.", v => agent_args = v },
>				{"listen", "Whenever to wait for a vm to connect.", v => listen = true }
>			};
>
>        try {
>            List<string> extra = p.Parse (args);
>			args = extra.ToArray ();
>		} catch (OptionException ex) {
>			Console.WriteLine (ex.Message);
>			return 1;
>		}
>
>		if (args.Length > 0 && args [0] == "stress") {
>			string[] new_args = new string [args.Length - 1];
>			for (int i = 1; i < args.Length; ++i)
>				new_args [i - 1] = args [i];
>			args = new_args;
>			run_stress (args);
>			return 0;
>		}
>
>		if (args.Length > 0 && args [0] == "suspend-stress") {
>			string[] new_args = new string [args.Length - 1];
>			for (int i = 1; i < args.Length; ++i)
>				new_args [i - 1] = args [i];
>			args = new_args;
>			run_suspend_stress (args);
>			return 0;
>		}
>
>		//stress_exit_suspended (args); return;
>		//stress_dispose (args); return;
>		//stress_other (args); return;
>
>		if (args.Length == 0)
>			args = new string[] { "hello.exe", "First" };
>
>		if (listen)
>			vm = VirtualMachineManager.Listen (new IPEndPoint (IPAddress.Any, 10000));
>		else
>			vm = VirtualMachineManager.Launch (args, new LaunchOptions { AgentArgs = agent_args });
>
>		vm.EnableEvents (EventType.AssemblyLoad, EventType.AssemblyUnload, EventType.ThreadStart, EventType.ThreadDeath, EventType.AppDomainCreate, EventType.AppDomainUnload);
>
>		/*
>		if (vm.Process != null) {
>			vm.Process.OutputDataReceived += delegate (object sender, Diag.DataReceivedEventArgs eargs) {
>				Console.WriteLine (eargs.Data);
>			};
>			vm.Process.BeginOutputReadLine ();
>		}
>		*/
>
>		/* Wait for the VMStart event */
>		Event vmstart = vm.GetNextEvent ();
>		Console.WriteLine ("-- " + vmstart + " --");
>
>		Console.WriteLine ("Root Domain: " + vm.RootDomain.FriendlyName);
>
>		AssemblyMirror[] assemblies = vm.RootDomain.GetAssemblies ();
>		Console.WriteLine ("Loaded assemblies: ");
>		foreach (AssemblyMirror ass in assemblies) {
>			Console.WriteLine ("\t" + ass.Location);
>
>			if (!String.IsNullOrEmpty (ass.Location)) {
>				//ass.Metadata = AssemblyFactory.GetAssembly (ass.Location);
>				//ass.Metadata = AssemblyFactory.GetAssembly ("hello.exe");
>			}
>		}
>
>		TypeMirror t = vmstart.Thread.Type;
>		Console.WriteLine (t);
>		foreach (MethodMirror m in t.GetMethods ()) {
>			if (m.Name == "set_Name") {
>				Value v = vmstart.Thread.InvokeMethod (vmstart.Thread, m, new Value [] { vm.RootDomain.CreateString ("ABC") });
>			}
>		}
>
>		vm.CreateExceptionRequest (null, true, false).Enable ();
>
>		Console.WriteLine ("Main thread name: " + vmstart.Thread.Name);
>
>		MethodEntryEventRequest req = vm.CreateMethodEntryRequest ();
>		req.Thread = vmstart.Thread;
>		//req.Enable ();
>
>		vm.Resume ();
>
>		//MethodExitEventRequest req2 = vm.CreateMethodExitRequest ();
>		//req2.Enable ();
>
>		//ThreadMirror main = null;
>
>		// FIXME: Add VMDisconnect event ?
>
>		AssemblyMirror am = null;
>
>		while (true) {
>			Event e = vm.GetNextEvent ();
>
>			Console.WriteLine ("-- " + e + " --");
>
>			string earg = "";
>
>			if (e is MethodEntryEvent) {
>				MethodMirror method = ((MethodEntryEvent)e).Method;
>
>				AssemblyMirror ass = method.DeclaringType.Assembly;
>				if (ass.Metadata == null)
>					ass.Metadata = AssemblyFactory.GetAssembly (ass.Location);
>
>				//Console.WriteLine ("BOO: " + method.DeclaringType.MetadataToken);
>
>				//Console.WriteLine ("BOO: " + method.DeclaringType.Module.ModuleVersionId);
>				//Console.WriteLine ("BOO: " + method.DeclaringType.Module.Assembly);
>
>				/*
>				foreach (var f in method.DeclaringType.GetFields ())
>					Console.WriteLine (f.Name);
>				*/
>
>				earg = method.FullName;
>				string filename = method.SourceFile;
>				if (filename != null)
>					earg = earg + " at " + filename;
>
>				Console.WriteLine ("\t " + earg);
>
>				ThreadMirror thread = ((MethodEntryEvent)e).Thread;
>
>				StackFrame[] frames = thread.GetFrames ();
>
>				PrintLocals (frames [0]);
>
>				//req.Disable ();
>
>				thread = ((MethodEntryEvent)e).Thread;
>
>				frames = thread.GetFrames ();
>
>				foreach (StackFrame f in frames) {
>					if (f.FileName != null)
>						Console.WriteLine ("\t\t " + f.Method.FullName + " at " + f.FileName + ":" + f.LineNumber + ".");
>					else
>						Console.WriteLine ("\t\t " + f.Method.FullName + " at <unknown>.");
>				}
>			}
>			if (e is MethodExitEvent) {
>				MethodExitEvent me = (MethodExitEvent)e;
>				Console.WriteLine ("\t " + me.Method.FullName);
>			}
>
>			if (e is TypeLoadEvent) {
>				Console.WriteLine ("\t " + (e as TypeLoadEvent).Type.FullName);
>				foreach (var s in (e as TypeLoadEvent).Type.GetSourceFiles ())
>					Console.WriteLine ("\t\t" + s);
>				(e as TypeLoadEvent).Type.GetCustomAttributes (true);
>			}
>
>			if (e is AssemblyLoadEvent) {
>				AssemblyLoadEvent ae = (AssemblyLoadEvent)e;
>				Console.WriteLine ("\tAssembly location: " + ae.Assembly.Location);
>				MethodMirror emethod = ae.Assembly.EntryPoint;
>				if (emethod != null) {
>					entry_point = emethod;
>					Console.WriteLine ("\tEntry point: " + entry_point.FullName + ".");
>					vm.SetBreakpoint (entry_point, 0);
>					//Tc2 (vm);
>					//break;
>				}
>
>				//Console.WriteLine (ae.Assembly.GetAssemblyObject ());
>				TypeMirror tm = ae.Assembly.GetType ("ProxyClass", false, true);
>				if (tm != null) {
>					am = ae.Assembly;
>					/*
>					foreach (MethodMirror m in tm.GetMethods ()) {
>						Console.WriteLine ("\t" + m.Name);
>						if (m.Name == ".ctor")
>							vm.SetBreakpoint (m, m.Locations [0].ILOffset);
>						//vm.SetBreakpoint (tm.GetMethod (".ctor"), 0);
>					}
>					*/
>				}
>			}
>
>			if (e is AppDomainCreateEvent) {
>				if (am != null) {
>					TypeMirror tm = am.GetType ("ProxyClass", false, true);
>					if (tm != null) {
>						foreach (MethodMirror m in tm.GetMethods ()) {
>							Console.WriteLine ("\t" + m.Name);
>							if (m.Name == ".ctor")
>								vm.SetBreakpoint (m, m.Locations [0].ILOffset);
>						}
>					}
>				}
>			}
>
>			if (e is AssemblyUnloadEvent) {
>				AssemblyUnloadEvent ae = (AssemblyUnloadEvent)e;
>				Console.WriteLine ("\tAssembly location: " + ae.Assembly.Location);
>			}
>
>			if (e is BreakpointEvent) {
>				Location l = e.Thread.GetFrames ()[0].Location;
>				Console.WriteLine (l);
>
>				/*
>				foreach (var v in e.Thread.GetFrames ()[0].GetVisibleVariables ()) {
>					Console.WriteLine ("X: " + v);
>				}
>				*/
>
>				/*
>				var req3 = vm.CreateStepRequest (e.Thread);
>				req3.Depth = StepDepth.Over;
>				req3.Size = StepSize.Line;
>				req3.Enable ();
>				*/
>			}
>
>			if (e is StepEvent) {
>				Location l = e.Thread.GetFrames ()[0].Location;
>				Console.WriteLine (l.SourceFile + ":" + l.LineNumber + " IL " + l.ILOffset);
>			}
>
>			if (e is ThreadStartEvent) {
>				Console.WriteLine ("Thread name: " + ((ThreadStartEvent)e).Thread.Name);
>			}
>
>#if FALSE
>			if (e is BreakpointEvent) {
>				var req = vm.CreateStepRequest (e.Thread);
>				req.Depth = StepDepth.Over;
>				req.Enable ();
>
>				StackFrame[] frames = e.Thread.GetFrames ();
>
>				StackFrame f = frames [0];
>				if (f.FileName != null)
>					Console.WriteLine ("\t\t " + f.Method.FullName + " at " + f.FileName + ":" + f.LineNumber + ".");
>				else
>					Console.WriteLine ("\t\t " + f.Method.FullName + " at <unknown>.");
>			}
>
>			/*
>			if (e is StepEvent) {
>				//Console.WriteLine (String.Format ("\t\t {0} at 0x{1:x}", (e as StepEvent).Method.FullName, (e as StepEvent).Location));
>
>				MethodMirror m = (e as StepEvent).Method;
>				long il_offset = (e as StepEvent).Location;
>
>				AssemblyMirror ass = m.DeclaringType.Assembly;
>				if (ass.Metadata == null)
>					ass.Metadata = AssemblyFactory.GetAssembly (ass.Location);
>
>				MethodDefinition def = m.Metadata;
>				MethodBody body = def.Body;
>
>				// FIXME: Speed this up
>				Instruction current_ins = null;
>				foreach (Instruction ins in body.Instructions)
>					if (ins.Offset == il_offset) {
>						current_ins = ins;
>						break;
>					}
>
>				if (current_ins != null) {
>					Instruction ins;
>					int prev = 2;
>					int next = 2;
>
>					Console.WriteLine ("\t\t{0}", def);
>
>					ins = current_ins;
>					for (int i = 0; i < prev; ++i)
>						if (ins.Previous != null)
>							ins = ins.Previous;
>					for (int i = 0; i < prev + next; ++i) {
>						string arg;
>
>						if (ins.Operand is Instruction)
>							arg = String.Format ("{0:x4}", (ins.Operand as Instruction).Offset);
>						else
>							arg = ins.Operand != null ? ins.Operand.ToString () : null;
>
>						if (ins == current_ins)
>							Console.WriteLine ("      -> {0:x4}: {1} {2}", ins.Offset, ins.OpCode, arg);
>						else
>							Console.WriteLine ("         {0:x4}: {1} {2}", ins.Offset, ins.OpCode, arg);
>						ins = ins.Next;
>						if (ins == null)
>							break;
>					}
>				}
>
>				char c = (char)Console.Read ();
>				if (c == 'n')
>					(e.Request as StepEventRequest).Depth = StepDepth.Over;
>				else if (c == 'o')
>					(e.Request as StepEventRequest).Depth = StepDepth.Out;
>				else
>					(e.Request as StepEventRequest).Depth = StepDepth.Into;
>				e.Request.Disable ();
>				e.Request.Enable ();
>			}
>#endif
>			
>			if (e is VMDeathEvent || e is VMDisconnectEvent)
>				break;
>
>			// This might fail if the debuggee disconnects
>			vm.Resume ();
>		}
>
>		/*
>		var p = vm.Process;
>		if (p != null) {
>			p.WaitForExit ();
>			Console.WriteLine (p.ExitCode);
>		}
>		*/
>
>		/*
>		if (args.Length > 0 && args [0] == "attach") {
>			ListeningConnector connector = mgr.ListeningConnectors [0];
>
>			vm = connector.Attach (connector.GetDefaultArguments ());
>		} else {
>			LaunchingConnector connector = mgr.DefaultConnector;
>			IDictionary<string, Argument> connectorArgs = connector.GetDefaultArguments ();
>
>			connectorArgs ["main"].StringValue = "hello.exe";
>		
>			vm = connector.Launch (connectorArgs);
>		}
>		*/
>
>			return 0;
>	}
>
>	public static void Tc2 (VirtualMachine vm) {
>		vm.Resume ();
>
>		Event e = vm.GetNextEvent ();
>		Console.WriteLine ("--" + e + "--");
>
>		vm.Resume ();
>
>		ThreadMirror main = e.Thread;
>
>		Thread.Sleep (1000);
>
>		vm.Suspend ();
>
>		//Thread.Sleep (1000);
>
>		Console.WriteLine (main.GetFrames ()[0].Method.Name);
>	}
>
>	static BreakpointEvent run_until (string name) {
>		MethodMirror m = entry_point.DeclaringType.GetMethod (name);
>		vm.SetBreakpoint (m, 0);
>
>		Event e = null;
>
>		while (true) {
>			vm.Resume ();
>			e = vm.GetNextEvent ();
>			Console.WriteLine (e);
>			if (e is BreakpointEvent)
>				break;
>		}
>
>		return (e as BreakpointEvent);
>	}
>
>	public static void print_il (StackFrame frame) {
>		List<ILInstruction> code = frame.Method.GetMethodBody ().Instructions;
>		foreach (var il in code) {
>			if (il.Offset == frame.Location.ILOffset)
>				Console.WriteLine (" -> " + il.OpCode);
>			else
>				Console.WriteLine ("    " + il.OpCode);
>		}
>	}
>
>	static void PrintLocals (StackFrame f) {
>		foreach (var l in f.Method.GetLocals ()) {
>			object val = f.GetValue (l);
>			Console.Write (l.Name + "(" + l.Type.Name + ") = ");
>			if (val is ArrayMirror) {
>				ArrayMirror arr = (val as ArrayMirror);
>				// FIXME: Add GetType () method.
>				Console.WriteLine (String.Format ("{0}[{1}] {{ ", arr.Type.Name.Replace ("[]", ""), arr.Length));
>				foreach (var o in arr) {
>					if (o is StringMirror)
>						Console.Write ("\"" + (o as StringMirror).Value + "\", ");
>					else
>						Console.Write ("{0}, ", o);
>				}
>				Console.WriteLine ("}");
>			} else if (val is ObjectMirror) {
>				ObjectMirror o = val as ObjectMirror;
>				Console.WriteLine ("X: " + o.Address);
>			} else {
>				Console.WriteLine (val);
>			}
>		}
>	}
>
>	static void run_until_entry_assembly () {
>		Event e;
>
>		/* Find out the entry point */
>		while (true) {
>			vm.Resume ();
>			e = vm.GetNextEvent ();
>			
>			if (e is AssemblyLoadEvent) {
>				AssemblyLoadEvent ae = (AssemblyLoadEvent)e;
>				entry_point = ae.Assembly.EntryPoint;
>				if (entry_point != null)
>					break;
>			}
>		}
>	}
>}

Actions: View

Attachments on bug 587470: 352330 | 352351 | 352378