Beispiel #1
0
 private Parameter[] getParameters()
 {
     var parameters = new List<Parameter>();
     var metadata_import = new CorMetadataImport(_thread.ActiveFrame.Function.Module);
     var method_info = metadata_import.GetMethodInfo(_thread.ActiveFrame.FunctionToken);
     foreach (var parameter in method_info.GetParameters())
     {
         var argument = _thread.ActiveFrame.GetArgument(parameter.Position - 1);
         parameters.Add(new Parameter(parameter.Name, getValue(argument)));
     }
     return parameters.ToArray();
 }
Beispiel #2
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="frame">The CorFrame frame object</param>
        /// <param name="importer">The meta data importer for the module this frame is contained within</param>
        internal FrameInfo(CorFrame frame, CorMetadataImport importer)
        {
            if (frame == null)
            {
                throw new ArgumentNullException("frame");
            }

            if (importer == null)
            {
                throw new ArgumentNullException("importer");
            }

            thisFrame = frame;
            metaImporter = importer;
            functionShortName = "";
            functionFullName = "";
            moduleShortName = "";
            moduleFullName = "";
            functionFileName = "";
            functionLineNumber = -1;//-1 is set by deafult which means no line number

            SourcePosition functionPos = null; //position in this function where we are

            //make binder and reader for the metadata

            if (thisFrame.FrameType == CorFrameType.InternalFrame)
            {
                functionFullName = functionShortName = InternalFrameToString();
            }
            else
            {
                functionPos = GetMetaDataInfo(importer);
            }

            if (functionPos != null)
            {
                functionLineNumber = functionPos.Line;
                functionFileName = Path.GetFileName(functionPos.Path);
            }
            else
            {
                ResourceManager stackStrings = new ResourceManager(typeof(Resources));
                functionLineNumber = -1;//no line number available
                functionFileName = stackStrings.GetString("sourceUnavailable");
            }
        }
Beispiel #3
0
 private ISymbolReader getSymbolReader(CorModule module)
 {
     ISymbolReader reader = null;
     string sympath = Path.GetDirectoryName(module.Name);
     string moduleName = module.Name;
     try
     {
         SymbolBinder binder = new SymbolBinder();
         var importer = new CorMetadataImport(module);
         reader = binder.GetReaderForFile(importer.RawCOMObject, moduleName, sympath);
     }
     catch (COMException ex)
     {
         if (ex.ErrorCode == unchecked((int)0x806D0014))  // E_PDB_CORRUPT
         {
             // Ignore it.
             // This may happen for mismatched pdbs
         }
         else
             throw;
     }
     return reader;
 }
		void OnModuleLoad (object sender, CorModuleEventArgs e)
		{
			CorMetadataImport mi = new CorMetadataImport (e.Module);

			try {
				// Required to avoid the jit to get rid of variables too early
				e.Module.JITCompilerFlags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DISABLE_OPTIMIZATION;
			}
			catch {
				// Some kind of modules don't allow JIT flags to be changed.
			}

			string file = e.Module.Assembly.Name;
			lock (documents) {
				ISymbolReader reader = null;
				if (file.IndexOfAny (System.IO.Path.InvalidPathChars) == -1 && System.IO.File.Exists (System.IO.Path.ChangeExtension (file, ".pdb"))) {
					try {
						reader = symbolBinder.GetReaderForFile (mi.RawCOMObject, file, ".");
						foreach (ISymbolDocument doc in reader.GetDocuments ()) {
							if (string.IsNullOrEmpty (doc.URL))
								continue;
							string docFile = System.IO.Path.GetFullPath (doc.URL);
							DocInfo di = new DocInfo ();
							di.Document = doc;
							di.Reader = reader;
							di.Module = e.Module;
							documents[docFile] = di;
							NotifySourceFileLoaded (docFile);
						}
					}
					catch (Exception ex) {
						OnDebuggerOutput (true, string.Format ("Debugger Error: {0}\n", ex.Message));
					}
					e.Module.SetJmcStatus (true, null);
				}
				else {
					// Flag modules without debug info as not JMC. In this way
					// the debugger won't try to step into them
					e.Module.SetJmcStatus (false, null);
				}

				ModuleInfo moi;

				if (modules.TryGetValue (e.Module.Name, out moi)) {
					moi.References++;
				}
				else {
					moi = new ModuleInfo ();
					moi.Module = e.Module;
					moi.Reader = reader;
					moi.Importer = mi;
					moi.References = 1;
					modules[e.Module.Name] = moi;
				}
			}
			e.Continue = true;
		}
		void OnUpdateModuleSymbols (object sender, CorUpdateModuleSymbolsEventArgs e)
		{
			SymbolBinder binder = new SymbolBinder ();
			CorMetadataImport mi = new CorMetadataImport (e.Module);
			ISymbolReader reader = binder.GetReaderFromStream (mi.RawCOMObject, e.Stream);
			foreach (ISymbolDocument doc in reader.GetDocuments ()) {
				Console.WriteLine (doc.URL);
			}
			e.Continue = true;
		}
		internal static StackFrame CreateFrame (CorDebuggerSession session, CorFrame frame)
		{
			uint address = 0;
			string file = "";
			int line = 0;
			string method = "";
			string lang = "";
			string module = "";
			string type = "";

			if (frame.FrameType == CorFrameType.ILFrame) {
				if (frame.Function != null) {
					module = frame.Function.Module.Name;
					CorMetadataImport importer = new CorMetadataImport (frame.Function.Module);
					MethodInfo mi = importer.GetMethodInfo (frame.Function.Token);
					method = mi.DeclaringType.FullName + "." + mi.Name;
					type = mi.DeclaringType.FullName;
					ISymbolReader reader = session.GetReaderForModule (frame.Function.Module.Name);
					if (reader != null) {
						ISymbolMethod met = reader.GetMethod (new SymbolToken (frame.Function.Token));
						if (met != null) {
							uint offset;
							CorDebugMappingResult mappingResult;
							frame.GetIP (out offset, out mappingResult);
							SequencePoint prevSp = null;
							foreach (SequencePoint sp in met.GetSequencePoints ()) {
								if (sp.Offset > offset)
									break;
								prevSp = sp;
							}
							if (prevSp != null) {
								line = prevSp.Line;
								file = prevSp.Document.URL;
							}
						}
					}
				}
				lang = "Managed";
			}
			else if (frame.FrameType == CorFrameType.NativeFrame) {
				frame.GetNativeIP (out address);
				method = "<Unknown>";
				lang = "Native";
			}
			else if (frame.FrameType == CorFrameType.InternalFrame) {
				switch (frame.InternalFrameType) {
					case CorDebugInternalFrameType.STUBFRAME_M2U: method = "[Managed to Native Transition]"; break;
					case CorDebugInternalFrameType.STUBFRAME_U2M: method = "[Native to Managed Transition]"; break;
					case CorDebugInternalFrameType.STUBFRAME_LIGHTWEIGHT_FUNCTION: method = "[Lightweight Method Call]"; break;
					case CorDebugInternalFrameType.STUBFRAME_APPDOMAIN_TRANSITION: method = "[Application Domain Transition]"; break;
					case CorDebugInternalFrameType.STUBFRAME_FUNC_EVAL: method = "[Function Evaluation]"; break;
				}
			}
			if (method == null)
				method = "<Unknown>";
			var loc = new SourceLocation (method, file, line);
			return new StackFrame ((long) address, loc, lang);
		}
Beispiel #7
0
 public TypeDefEnum(CorMetadataImport corMeta)
 {
     m_corMeta = corMeta;
 }
		internal static StackFrame CreateFrame (CorDebuggerSession session, CorFrame frame)
		{
			// TODO: Fix remaining.
			uint address = 0;
			//string typeFQN;
			//string typeFullName;
			string addressSpace = "";
			string file = "";
			int line = 0;
			int column = 0;
			string method = "";
			string lang = "";
			string module = "";
			string type = "";
			bool hasDebugInfo = false;
			bool hidden = false;
			bool external = true;

			if (frame.FrameType == CorFrameType.ILFrame) {
				if (frame.Function != null) {
					module = frame.Function.Module.Name;
					CorMetadataImport importer = new CorMetadataImport (frame.Function.Module);
					MethodInfo mi = importer.GetMethodInfo (frame.Function.Token);
					method = mi.DeclaringType.FullName + "." + mi.Name;
					type = mi.DeclaringType.FullName;
					addressSpace = mi.Name;
					ISymbolReader reader = session.GetReaderForModule (frame.Function.Module.Name);
					if (reader != null) {
						ISymbolMethod met = reader.GetMethod (new SymbolToken (frame.Function.Token));
						if (met != null) {
							CorDebugMappingResult mappingResult;
							frame.GetIP (out address, out mappingResult);
							SequencePoint prevSp = null;
							foreach (SequencePoint sp in met.GetSequencePoints ()) {
								if (sp.Offset > address)
									break;
								prevSp = sp;
							}
							if (prevSp != null) {
								line = prevSp.Line;
								column = prevSp.Offset;
								file = prevSp.Document.URL;
								address = (uint)prevSp.Offset;
							}
						}
					}
					// FIXME: Still steps into.
					//hidden = mi.GetCustomAttributes (true).Any (v => v is System.Diagnostics.DebuggerHiddenAttribute);
				}
				lang = "Managed";
				hasDebugInfo = true;
			}
			else if (frame.FrameType == CorFrameType.NativeFrame) {
				frame.GetNativeIP (out address);
				method = "<Unknown>";
				lang = "Native";
			}
			else if (frame.FrameType == CorFrameType.InternalFrame) {
				switch (frame.InternalFrameType) {
					case CorDebugInternalFrameType.STUBFRAME_M2U: method = "[Managed to Native Transition]"; break;
					case CorDebugInternalFrameType.STUBFRAME_U2M: method = "[Native to Managed Transition]"; break;
					case CorDebugInternalFrameType.STUBFRAME_LIGHTWEIGHT_FUNCTION: method = "[Lightweight Method Call]"; break;
					case CorDebugInternalFrameType.STUBFRAME_APPDOMAIN_TRANSITION: method = "[Application Domain Transition]"; break;
					case CorDebugInternalFrameType.STUBFRAME_FUNC_EVAL: method = "[Function Evaluation]"; break;
				}
			}

			if (method == null)
				method = "<Unknown>";

			var loc = new SourceLocation (method, file, line, column);
			return new StackFrame ((long) address, addressSpace, loc, lang, external, hasDebugInfo, hidden, null, null);
		}
Beispiel #9
0
        //methods
        /// <summary>
        /// Loop through all frames in thread getting info on them then building
        /// a arrayList representation of the stack trace with them
        /// If called when already attached it will skip attaching and detaching and let the function that called it worry about that
        /// otherwise this function will deal with attaching and deataching
        /// </summary>
        /// <param name="depth">How many frames deep to display, 0 means show all</param>
        public void UpdateStackTrace(int depth)
        {
            frameStack.Clear();  //not needed right now cause this class is remade each update
            bool enteredAttached = processInfo.Attached;
            if (!enteredAttached)
            {
                processInfo.AttachAndStop();
            }
            try
            {
                int frameNum = 0;

                foreach (CorChain chain in thread.Chains)
                {

                    foreach (CorFrame frame in chain.Frames)
                    {
                        if ((frameNum >= depth) && (depth != 0))
                        {
                            break;
                        }
                        if (frame.Function == null)
                        {
                            continue;
                        }
                        CorModule module = frame.Function.Module;
                        string moduleName = module.Name;
                        CorMetadataImport importer = null;
                        if (metaImportHash.ContainsKey(moduleName))
                        {
                            importer = metaImportHash[moduleName] as CorMetadataImport;
                        }
                        else
                        {//make a new importer then add it to the hash
                            importer = new CorMetadataImport(module);
                            metaImportHash[moduleName] = importer;
                        }

                        //add the next frame to the frame stack
                        frameStack.Add(new FrameInfo(frame, importer));
                        frameNum++;

                    }
                    if ((frameNum > depth) && (depth != 0))
                    {
                        break;
                    }
                }
            }
            catch (COMException ex)
            {
                Debug.WriteLine(ex.ToString());
            }
            finally
            {
                if (!enteredAttached)
                {
                    processInfo.DetachAndResume();
                }
            }
        }
Beispiel #10
0
 /// <summary>
 /// Dispose managed and unmanaged objects
 /// </summary>
 /// <param name="disposing">Dispose managed objects</param>
 protected virtual void Dispose(bool disposing)
 {
     if (disposing)
     {
         // Free other state (managed objects).
         metaImporter = null;
         symDocs = null;
         offsets = null;
         startLines = null;
         endLines = null;
         startColumns = null;
         endColumns = null;
     }
     // Free your own state (unmanaged objects).
 }
Beispiel #11
0
        /// <summary>
        /// Read the pdb file for this module and frame
        /// Retrieve infomation about the function
        /// </summary>
        /// <remarks>
        /// When an unmanaged app like reflector loads CLR, "Function.Module.Name"
        /// doesn't return a valid value and so this function returns null.
        /// </remarks>
        /// <returns>SourcePosition of the function</returns>
        private SourcePosition GetMetaDataInfo(CorMetadataImport importer)
        {
            SourcePosition functionPos = null; //position in this function where we are
            try
            {
                moduleFullName = thisFrame.Function.Module.Name;
                moduleShortName = System.IO.Path.GetFileName(moduleFullName);
            }
            catch (ArgumentException)
            {
                moduleFullName = "";
                moduleShortName = "";
                return null;
            }

            //TODO: Implement a better method to determine the symbol path than just assuming it's in the same
            //      directory
            string sympath = ".";

            //dealing with readinf the source in the module
            ISymbolReader metaReader = null;
            ISymbolBinder1 symbolBinder = new SymbolBinder();

            try
            {
                if (moduleFullName.Length > 0)
                {
                    metaReader = (symbolBinder as ISymbolBinder2).
                        GetReaderForFile(importer.RawCOMObject, moduleFullName, sympath);
                }
            }
            catch (COMException)
            {
                //Debug.WriteLine(ed.ToString(CultureInfo.CurrentCulture.NumberFormat));
                //will get here for any function which we cant read the .pdb file for
                //its not a big deal we just wont have source and line info
            }

            if (metaReader != null)
            {
                ISymbolMethod symMethod = null;
                try
                {
                    symMethod = metaReader.GetMethod(new SymbolToken((int)thisFrame.Function.Token), thisFrame.Function.Version);
                    int sequenceCount = symMethod.SequencePointCount;
                    symDocs = new ISymbolDocument[sequenceCount];
                    offsets = new int[sequenceCount];
                    startLines = new int[sequenceCount];
                    startColumns = new int[sequenceCount];
                    endLines = new int[sequenceCount];
                    endColumns = new int[sequenceCount];

                    //Get the sequence points and store them in the apporpriate arrays. Seqeunce points
                    //represent the different points in the files which correlate to il instruction and lines
                    symMethod.GetSequencePoints(offsets, symDocs, startLines, startColumns, endLines, endColumns);

                    functionPos = GetSourcePositionFromFrame();
                }
                catch (COMException)
                {
                    functionPos = null;
                }
                finally
                {
                    symDocs = null;
                    symMethod = null;
                }
            }

            CorType ctype = GetClassType();
            if (ctype != null)
            {
                StringBuilder sb = new StringBuilder();
                GetFunctionClassPath(sb, ctype);
                functionFullName = sb.ToString();
            }
            else
            {
                functionFullName = "";
            }

            MethodInfo methIn = importer.GetMethodInfo(thisFrame.Function.Token);
            functionFullName += "." + methIn.Name;
            functionShortName = methIn.Name;
            return functionPos;
        }
Beispiel #12
0
 public void ShowStackTrace(CorThread thread)
 {
     var builder = new StringBuilder();
     foreach (CorFrame frame in thread.ActiveChain.Frames)
     {
         if (frame.FrameType == CorFrameType.ILFrame) builder.AppendLine("[IL]");
         var import = new CorMetadataImport(frame.Function.Module);
         MethodInfo methodInfo = import.GetMethodInfo(frame.FunctionToken);
         builder.AppendLine(string.Format("{0}:{1}", methodInfo.DeclaringType, methodInfo.Name));
     }
     subscriber.PublishedSource(builder.ToString());
     subscriber.Stopped(this, thread);
 }
Beispiel #13
0
        public static void Disassemble(byte[] ilCode, CorMetadataImport importer, out string[] lines, out int[] ip2line)
        {
            ArrayList ils = new ArrayList();
            ip2line = new int[ilCode.Length];
            int pc = 0;
            while (pc < ilCode.Length)
            {
                string instruction = "";
                int instruction_start = pc;

                int opCodeSize;
                ILOpCode opCode = DecodeOpcode(ilCode, pc, out opCodeSize);
                pc += opCodeSize;
                switch ((OpcodeFormat)GenTables.opCodeTypeInfo[(int)opCode].Type)
                {
                    default:
                        Debug.Assert(false);
                        break;

                    case OpcodeFormat.InlineNone:
                        instruction = GenTables.opCodeTypeInfo[(int)opCode].Name;
                        break;

                    case OpcodeFormat.ShortInlineI:
                    case OpcodeFormat.ShortInlineVar:
                        {
                            byte arg = ilCode[pc];
                            pc++;
                            instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[]{GenTables.opCodeTypeInfo[(int)opCode].Name,
                                                                            arg});
                            break;
                        }
                    case OpcodeFormat.InlineVar:
                        {
                            Int16 arg = BitConverter.ToInt16(ilCode, pc);
                            pc += 2;
                            instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[]{GenTables.opCodeTypeInfo[(int)opCode].Name,
                                                                            arg});
                            break;
                        }
                    case OpcodeFormat.InlineI:
                    case OpcodeFormat.InlineRVA:
                        {
                            Int32 arg = BitConverter.ToInt32(ilCode, pc);
                            pc += 4;
                            instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[]{GenTables.opCodeTypeInfo[(int)opCode].Name,
                                                                            arg});
                            break;
                        }
                    case OpcodeFormat.InlineI8:
                        {
                            Int64 arg = BitConverter.ToInt64(ilCode, pc);
                            pc += 8;
                            instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[]{GenTables.opCodeTypeInfo[(int)opCode].Name,
                                                                            arg});
                            break;
                        }
                    case OpcodeFormat.ShortInlineR:
                        {
                            float arg = BitConverter.ToSingle(ilCode, pc);
                            pc += 4;
                            instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[]{GenTables.opCodeTypeInfo[(int)opCode].Name,
                                                                            arg});
                            break;
                        }
                    case OpcodeFormat.InlineR:
                        {
                            double arg = BitConverter.ToDouble(ilCode, pc);
                            pc += 8;
                            instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[]{GenTables.opCodeTypeInfo[(int)opCode].Name,
                                                                            arg});
                            break;
                        }
                    case OpcodeFormat.ShortInlineBrTarget:
                        {
                            sbyte offset = (sbyte)ilCode[pc];
                            pc++;
                            int dest = pc + offset;
                            instruction = String.Format(CultureInfo.InvariantCulture, "{0} IL_{1,-4:X}", new Object[]{GenTables.opCodeTypeInfo[(int)opCode].Name,
                                                                                    dest});
                            break;
                        }
                    case OpcodeFormat.InlineBrTarget:
                        {
                            Int32 offset = BitConverter.ToInt32(ilCode, pc);
                            pc += 4;
                            int dest = pc + offset;
                            instruction = String.Format(CultureInfo.InvariantCulture, "{0} IL_{1,-4:X}", new Object[]{GenTables.opCodeTypeInfo[(int)opCode].Name,
                                                                                    dest});
                            break;
                        }
                    case OpcodeFormat.InlineSwitch:
                    case OpcodeFormat.InlinePhi:
                        instruction = "MESSED UP!";
                        // variable size
                        Debug.Assert(false);
                        break;
                    case OpcodeFormat.InlineString:
                    case OpcodeFormat.InlineField:
                    case OpcodeFormat.InlineType:
                    case OpcodeFormat.InlineToken:
                    case OpcodeFormat.InlineMethod:
                        {
                            int token = BitConverter.ToInt32(ilCode, pc);
                            pc += 4;

                            CorTokenType tokenType = TokenUtils.TypeFromToken(token);
                            // if it is reference token we need to dereference it.
                            string arg = null;
                            switch (tokenType)
                            {
                                default:
                                    Debug.Assert(false);
                                    break;
                                case CorTokenType.mdtTypeDef:
                                    int extendsToken;
                                    arg = importer.GetTypeNameFromDef(token, out extendsToken);
                                    break;
                                case CorTokenType.mdtTypeRef:
                                    arg = importer.GetTypeNameFromRef(token);
                                    break;
                                case CorTokenType.mdtTypeSpec:
                                    arg = "NYI";
                                    break;
                                case CorTokenType.mdtMethodDef:
                                    MethodInfo mi = importer.GetMethodInfo(token);
                                    Type dt = mi.DeclaringType;
                                    arg = (dt == null ? "" : dt.Name) + "." + mi.Name;
                                    break;
                                case CorTokenType.mdtFieldDef:
                                    arg = "NYI";
                                    break;
                                case CorTokenType.mdtMemberRef:
                                    arg = importer.GetMemberRefName(token);
                                    break;
                                case CorTokenType.mdtString:
                                    arg = "\"" + importer.GetUserString(token) + "\"";
                                    break;
                            } // switch(tokenType)
                            instruction = String.Format(CultureInfo.InvariantCulture, "{0} {1}", new Object[]{GenTables.opCodeTypeInfo[(int)opCode].Name,
                                                                            arg});
                            break;
                        }
                    case OpcodeFormat.InlineSig:
                        instruction = GenTables.opCodeTypeInfo[(int)opCode].Name;
                        pc += 4;
                        break;
                } // switch((OpcodeFormat)GenTables.opCodeTypeInfo[(int)opCode].Type)
                ils.Add(String.Format(CultureInfo.InvariantCulture, "IL_{0,-4:X}:  {1}", new Object[] { instruction_start, instruction }));

                // add ip2line mapping
                for (int i = instruction_start; i < pc; i++)
                    ip2line[i] = ils.Count - 1; // last line
            } // while(pc<ilCode.Length)
            lines = (string[])ils.ToArray(typeof(string));
            return;

        }
Beispiel #14
0
        /// <summary>
        /// Releases all resources used by the MDbgModule.
        /// </summary>
        public void Dispose()
        {
            // Our funtion list may hold onto unmanaged SymbolMethod objects, so dispose that too.
            m_functions.Dispose();
            m_functions = null;

            // Release unmanaged resources
            if (m_symReader != null)
            {
                // Disposing the symbol reader will release the file lock on the PDB (even when other
                // reader COM objects have yet to be released by the garbage collector).
                ((IDisposable)m_symReader).Dispose();
                m_symReader = null;
            }
            m_module = null;
            m_importer = null;
        }
		internal static StackFrame CreateFrame (CorDebuggerSession session, CorFrame frame)
		{
			// TODO: Fix remaining.
			uint address = 0;
			//string typeFQN;
			//string typeFullName;
			string addressSpace = "";
			string file = "";
			int line = 0;
			int endLine = 0;
			int column = 0;
			int endColumn = 0;
			string method = "";
			string lang = "";
			string module = "";
			string type = "";
			bool hasDebugInfo = false;
			bool hidden = false;
			bool external = true;

			if (frame.FrameType == CorFrameType.ILFrame) {
				if (frame.Function != null) {
					module = frame.Function.Module.Name;
					CorMetadataImport importer = new CorMetadataImport (frame.Function.Module);
					MethodInfo mi = importer.GetMethodInfo (frame.Function.Token);
					method = mi.DeclaringType.FullName + "." + mi.Name;
					type = mi.DeclaringType.FullName;
					addressSpace = mi.Name;
					
					var sp = GetSequencePoint (session, frame);
					if (sp != null) {
						line = sp.StartLine;
						column = sp.StartColumn;
						endLine = sp.EndLine;
						endColumn = sp.EndColumn;
						file = sp.Document.URL;
						address = (uint)sp.Offset;
					}

					if (session.IsExternalCode (file)) {
						external = true;
					} else {
						if (session.Options.ProjectAssembliesOnly) {
							external = mi.GetCustomAttributes (true).Any (v => 
								v is System.Diagnostics.DebuggerHiddenAttribute ||
							v is System.Diagnostics.DebuggerNonUserCodeAttribute);
						} else {
							external = mi.GetCustomAttributes (true).Any (v => 
								v is System.Diagnostics.DebuggerHiddenAttribute);
						}
					}
					hidden = mi.GetCustomAttributes (true).Any (v => v is System.Diagnostics.DebuggerHiddenAttribute);
				}
				lang = "Managed";
				hasDebugInfo = true;
			} else if (frame.FrameType == CorFrameType.NativeFrame) {
				frame.GetNativeIP (out address);
				method = "<Unknown>";
				lang = "Native";
			} else if (frame.FrameType == CorFrameType.InternalFrame) {
				switch (frame.InternalFrameType) {
				case CorDebugInternalFrameType.STUBFRAME_M2U:
					method = "[Managed to Native Transition]";
					break;
				case CorDebugInternalFrameType.STUBFRAME_U2M:
					method = "[Native to Managed Transition]";
					break;
				case CorDebugInternalFrameType.STUBFRAME_LIGHTWEIGHT_FUNCTION:
					method = "[Lightweight Method Call]";
					break;
				case CorDebugInternalFrameType.STUBFRAME_APPDOMAIN_TRANSITION:
					method = "[Application Domain Transition]";
					break;
				case CorDebugInternalFrameType.STUBFRAME_FUNC_EVAL:
					method = "[Function Evaluation]";
					break;
				}
			}

			if (method == null)
				method = "<Unknown>";

			var loc = new SourceLocation (method, file, line, column, endLine, endColumn);
			return new StackFrame ((long)address, addressSpace, loc, lang, external, hasDebugInfo, hidden, null, null);
		}
Beispiel #16
0
        /// <summary>
        /// Releases all resources used by the MDbgModule.
        /// </summary>
        public void Dispose()
        {
            // Our funtion list may hold onto unmanaged SymbolMethod objects, so dispose that too.
            m_functions.Dispose();
            m_functions = null;

            // Release unmanaged resources.
            m_symReader = null;
            m_module = null;
            m_importer = null;
        }