Inheritance: IComparable
Exemple #1
0
 public static void DumpLineNumberTable(TextWriter writer, MonoSymbolFile file,
                                        Cecil.MethodDefinition mdef, C.MethodEntry entry)
 {
     try {
         DumpLineNumberTable_internal(writer, file, mdef, entry);
     } catch (Exception ex) {
         writer.WriteLine("DUMP LNT EX: {0}", ex);
     }
 }
		void ReadLocalVariables (MethodEntry entry, MethodBody body)
		{
			LocalVariableEntry[] locals = entry.GetLocals ();
			foreach (LocalVariableEntry loc in locals) {
				VariableDefinition var = body.Variables [loc.Index];
				var.Name = loc.Name;

				Scope scope = m_scopes [loc.BlockIndex] as Scope;
				if (scope == null)
					continue;
				scope.Variables.Add (var);
			}
		}
		void ReadLineNumbers (MethodEntry entry, IDictionary instructions)
		{
			LineNumberTable lnt = entry.GetLineNumberTable ();
			foreach (LineNumberEntry line in lnt.LineNumbers) {
				Instruction instr = instructions [line.Offset] as Instruction;
				if (instr == null)
					continue;

				Document doc = GetDocument (entry.CompileUnit.SourceFile);
				instr.SequencePoint = new SequencePoint (doc);
				instr.SequencePoint.StartLine = line.Row;
				instr.SequencePoint.EndLine = line.Row;
			}
		}
Exemple #4
0
		internal MethodEntry(MonoSymbolFile file, CompileUnitEntry comp_unit, int token, ScopeVariable[] scope_vars, LocalVariableEntry[] locals, LineNumberEntry[] lines, CodeBlockEntry[] code_blocks, string real_name, MethodEntry.Flags flags, int namespace_id)
		{
			this.SymbolFile = file;
			this.real_name = real_name;
			this.locals = locals;
			this.code_blocks = code_blocks;
			this.scope_vars = scope_vars;
			this.flags = flags;
			this.index = -1;
			this.Token = token;
			this.CompileUnitIndex = comp_unit.Index;
			this.CompileUnit = comp_unit;
			this.NamespaceID = namespace_id;
			this.CheckLineNumberTable(lines);
			this.lnt = new LineNumberTable(file, lines);
			file.NumLineNumbers += lines.Length;
			int num_locals = (locals != null) ? locals.Length : 0;
			if (num_locals <= 32)
			{
				for (int i = 0; i < num_locals; i++)
				{
					string nm = locals[i].Name;
					for (int j = i + 1; j < num_locals; j++)
					{
						if (locals[j].Name == nm)
						{
							flags |= MethodEntry.Flags.LocalNamesAmbiguous;
							goto IL_108;
						}
					}
				}
				IL_108:;
			}
			else
			{
				Dictionary<string, LocalVariableEntry> local_names = new Dictionary<string, LocalVariableEntry>();
				for (int k = 0; k < locals.Length; k++)
				{
					LocalVariableEntry local = locals[k];
					if (local_names.ContainsKey(local.Name))
					{
						flags |= MethodEntry.Flags.LocalNamesAmbiguous;
						break;
					}
					local_names.Add(local.Name, local);
				}
			}
		}
Exemple #5
0
		static void ReadLocalVariables (MethodEntry entry, MethodBody body, Scope [] scopes)
		{
			var locals = entry.GetLocals ();
			foreach (var local in locals) {
				var variable = body.Variables [local.Index];
				variable.Name = local.Name;

				var index = local.BlockIndex;
				if (index < 0 || index >= scopes.Length)
					continue;

				var scope = scopes [index];
				if (scope == null)
					continue;

				scope.Variables.Add (variable);
			}
		}
Exemple #6
0
		private static void ReadLocalVariables(MethodEntry entry, MethodBody body, Scope[] scopes)
		{
			LocalVariableEntry[] locals = entry.GetLocals();
			LocalVariableEntry[] array = locals;
			for (int i = 0; i < array.Length; i++)
			{
				LocalVariableEntry local = array[i];
				VariableDefinition variable = body.Variables[local.Index];
				variable.Name = local.Name;
				int index = local.BlockIndex;
				if (index >= 0 && index < scopes.Length)
				{
					Scope scope = scopes[index];
					if (scope != null)
					{
						scope.Variables.Add(variable);
					}
				}
			}
		}
Exemple #7
0
        static void DumpLineNumberTable_internal(TextWriter writer, MonoSymbolFile file,
                                                 Cecil.MethodDefinition mdef, C.MethodEntry entry)
        {
            string full_name = MonoSymbolFile.GetMethodName(mdef);

            if (mdef.MetadataToken.TokenType != Cecil.Metadata.TokenType.Method)
            {
                writer.WriteLine("UNKNOWN METHOD: {0}", full_name);
                return;
            }

            writer.WriteLine();
            writer.WriteLine("Symfile Line Numbers (file / row / offset):");
            writer.WriteLine("-------------------------------------------");

            C.LineNumberEntry[] lnt;
            lnt = entry.GetLineNumberTable().LineNumbers;
            for (int i = 0; i < lnt.Length; i++)
            {
                C.LineNumberEntry lne = lnt [i];

                writer.WriteLine("{0,4} {1,4} {2,4} {3,4:x}{4}", i,
                                 lne.File, lne.Row, lne.Offset,
                                 lne.IsHidden ? " (hidden)" : "");
            }

            writer.WriteLine("-------------------------------------------");
            writer.WriteLine();

            List <string>         lines;
            Dictionary <int, int> offsets;

            if (!DisassembleMethod_internal(file.ImageFile, (int)mdef.MetadataToken.RID, out lines, out offsets))
            {
                writer.WriteLine("Cannot disassemble method: {0}", full_name);
                return;
            }

            writer.WriteLine("Disassembling {0}:\n\n{1}\n", full_name, String.Join("\n", lines.ToArray()));
        }
Exemple #8
0
		private void ReadLineNumbers(MethodEntry entry, InstructionMapper mapper)
		{
			Document document = null;
			LineNumberTable table = entry.GetLineNumberTable();
			LineNumberEntry[] lineNumbers = table.LineNumbers;
			for (int i = 0; i < lineNumbers.Length; i++)
			{
				LineNumberEntry line = lineNumbers[i];
				Instruction instruction = mapper(line.Offset);
				if (instruction != null)
				{
					if (document == null)
					{
						document = this.GetDocument(entry.CompileUnit.SourceFile);
					}
					instruction.SequencePoint = new SequencePoint(document)
					{
						StartLine = line.Row,
						EndLine = line.Row
					};
				}
			}
		}
Exemple #9
0
		public void DefineMethod(MonoSymbolFile file)
		{
			LineNumberEntry[] lines = new LineNumberEntry[this.method_lines_pos];
			Array.Copy(this.method_lines, lines, this.method_lines_pos);
			MethodEntry entry = new MethodEntry(file, this._comp_unit.Entry, this._method.Token, this.ScopeVariables, this.Locals, lines, this.Blocks, this.RealMethodName, (MethodEntry.Flags)0, this._ns_id);
			file.AddMethod(entry);
		}
Exemple #10
0
		void ReadLineNumbers (MethodEntry entry, MethodSymbols symbols)
		{
			var table = entry.GetLineNumberTable ();
			var lines = table.LineNumbers;

			var instructions = symbols.instructions = new Collection<InstructionSymbol> (lines.Length);

			for (int i = 0; i < lines.Length; i++) {
				var line = lines [i];

				instructions.Add (new InstructionSymbol (line.Offset, new SequencePoint (GetDocument (entry.CompileUnit.SourceFile)) {
					StartLine = line.Row,
					EndLine = line.Row,
				}));
			}
		}
Exemple #11
0
		public void DefineMethod (MonoSymbolFile file, int token)
		{
			MethodEntry entry = new MethodEntry (
				file, _comp_unit.Entry, token, ScopeVariables,
				Locals, method_lines.ToArray (), Blocks, null, MethodEntry.Flags.ColumnsInfoIncluded, ns_id);

			file.AddMethod (entry);
		}
Exemple #12
0
	private void ProcessMethod (MethodBase monoMethod, MethodEntry entry, ClassCoverageItem klass, string methodName, string cov_info)
Exemple #13
0
		void read_methods ()
		{
			lock (this) {
				if (method_token_hash != null)
					return;

				method_token_hash = new Dictionary<int, MethodEntry> ();
				method_list = new List<MethodEntry> ();

				long old_pos = reader.BaseStream.Position;
				reader.BaseStream.Position = ot.MethodTableOffset;

				for (int i = 0; i < MethodCount; i++) {
					MethodEntry entry = new MethodEntry (this, reader, i + 1);
					method_token_hash.Add (entry.Token, entry);
					method_list.Add (entry);
				}

				reader.BaseStream.Position = old_pos;
			}
		}
Exemple #14
0
		internal void AddMethod (MethodEntry entry)
		{
			methods.Add (entry);
		}
Exemple #15
0
        static void ReadLocalVariables(MethodEntry entry, ScopeDebugInformation [] scopes)
        {
            var locals = entry.GetLocals ();

            foreach (var local in locals) {
                var variable = new VariableDebugInformation (local.Index, local.Name);

                var index = local.BlockIndex;
                if (index < 0 || index >= scopes.Length)
                    continue;

                var scope = scopes [index];
                if (scope == null)
                    continue;

                scope.Variables.Add (variable);
            }
        }
Exemple #16
0
        static ScopeDebugInformation[] ReadScopes(MethodEntry entry, MethodDebugInformation info)
        {
            var blocks = entry.GetCodeBlocks ();
            var scopes = new ScopeDebugInformation [blocks.Length + 1];

            info.scope = scopes [0] = new ScopeDebugInformation {
                Start = new InstructionOffset (0),
                End = new InstructionOffset (info.code_size),
            };

            foreach (var block in blocks) {
                if (block.BlockType != CodeBlockEntry.Type.Lexical && block.BlockType != CodeBlockEntry.Type.CompilerGenerated)
                    continue;

                var scope = new ScopeDebugInformation ();
                scope.Start = new InstructionOffset (block.StartOffset);
                scope.End = new InstructionOffset (block.EndOffset);

                scopes [block.Index + 1] = scope;

                if (!AddScope (info.scope.Scopes, scope))
                    info.scope.Scopes.Add (scope);
            }

            return scopes;
        }
Exemple #17
0
		public void DefineMethod (MonoSymbolFile file, int token)
		{
			var blocks = Blocks;

			//
			// When index is provided by user it can be inserted in
			// any order but mdb format does not store its value. It
			// uses store order instead as the index.
			//
			Array.Sort (blocks, (x, y) => x.Index.CompareTo (y.Index));

			var entry = new MethodEntry (
				file, _comp_unit.Entry, token, ScopeVariables,
				Locals, method_lines.ToArray (), blocks, null, MethodEntry.Flags.ColumnsInfoIncluded, ns_id);

			file.AddMethod (entry);
		}
		void ReadScopes (MethodEntry entry, MethodBody body, IDictionary instructions)
		{
			CodeBlockEntry[] blocks = entry.GetCodeBlocks ();
			foreach (CodeBlockEntry cbe in blocks) {
				if (cbe.BlockType != CodeBlockEntry.Type.Lexical)
					continue;

				Scope s = new Scope ();
				s.Start = GetInstruction (body, instructions, cbe.StartOffset);
				s.End = GetInstruction(body, instructions, cbe.EndOffset);
				m_scopes [entry.Index] = s;

				if (!AddScope (body, s))
					body.Scopes.Add (s);
			}
		}
        void Write(MyBinaryWriter bw, Guid guid)
        {
            // Magic number and file version.
            bw.Write(OffsetTable.Magic);
            bw.Write(MajorVersion);
            bw.Write(MinorVersion);

            bw.Write(guid.ToByteArray());

            //
            // Offsets of file sections; we must write this after we're done
            // writing the whole file, so we just reserve the space for it here.
            //
            long offset_table_offset = bw.BaseStream.Position;

            ot.Write(bw, MajorVersion, MinorVersion);

            //
            // Sort the methods according to their tokens and update their index.
            //
            methods.Sort();
            for (int i = 0; i < methods.Count; i++)
            {
                methods [i].Index = i + 1;
            }

            //
            // Write data sections.
            //
            ot.DataSectionOffset = (int)bw.BaseStream.Position;
            foreach (SourceFileEntry source in sources)
            {
                source.WriteData(bw);
            }
            foreach (CompileUnitEntry comp_unit in comp_units)
            {
                comp_unit.WriteData(bw);
            }
            foreach (MethodEntry method in methods)
            {
                method.WriteData(this, bw);
            }
            ot.DataSectionSize = (int)bw.BaseStream.Position - ot.DataSectionOffset;

            //
            // Write the method index table.
            //
            ot.MethodTableOffset = (int)bw.BaseStream.Position;
            for (int i = 0; i < methods.Count; i++)
            {
                MethodEntry entry = methods [i];
                entry.Write(bw);
            }
            ot.MethodTableSize = (int)bw.BaseStream.Position - ot.MethodTableOffset;

            //
            // Write source table.
            //
            ot.SourceTableOffset = (int)bw.BaseStream.Position;
            for (int i = 0; i < sources.Count; i++)
            {
                SourceFileEntry source = sources [i];
                source.Write(bw);
            }
            ot.SourceTableSize = (int)bw.BaseStream.Position - ot.SourceTableOffset;

            //
            // Write compilation unit table.
            //
            ot.CompileUnitTableOffset = (int)bw.BaseStream.Position;
            for (int i = 0; i < comp_units.Count; i++)
            {
                CompileUnitEntry unit = comp_units [i];
                unit.Write(bw);
            }
            ot.CompileUnitTableSize = (int)bw.BaseStream.Position - ot.CompileUnitTableOffset;

            //
            // Write anonymous scope table.
            //
            ot.AnonymousScopeCount       = anonymous_scopes != null ? anonymous_scopes.Count : 0;
            ot.AnonymousScopeTableOffset = (int)bw.BaseStream.Position;
            if (anonymous_scopes != null)
            {
                foreach (AnonymousScopeEntry scope in anonymous_scopes.Values)
                {
                    scope.Write(bw);
                }
            }
            ot.AnonymousScopeTableSize = (int)bw.BaseStream.Position - ot.AnonymousScopeTableOffset;

            //
            // Fixup offset table.
            //
            ot.TypeCount        = last_type_index;
            ot.MethodCount      = methods.Count;
            ot.SourceCount      = sources.Count;
            ot.CompileUnitCount = comp_units.Count;

            //
            // Write offset table.
            //
            ot.TotalFileSize = (int)bw.BaseStream.Position;
            bw.Seek((int)offset_table_offset, SeekOrigin.Begin);
            ot.Write(bw, MajorVersion, MinorVersion);
            bw.Seek(0, SeekOrigin.End);

#if false
            Console.WriteLine("TOTAL: {0} line numbes, {1} bytes, extended {2} bytes, " +
                              "{3} methods.", NumLineNumbers, LineNumberSize,
                              ExtendedLineNumberSize, methods.Count);
#endif
        }
            public MonoMethod(MonoSymbolFile file, MethodSource source, int domain,
					   C.MethodEntry method, Cecil.MethodDefinition mdef)
                : base(source.Name, file.ImageFile, file.Module)
            {
                this.file = file;
                this.source = source;
                this.domain = domain;
                this.method = method;
                this.mdef = mdef;

                foreach (Cecil.CustomAttribute cattr in mdef.CustomAttributes) {
                    string cname = cattr.Constructor.DeclaringType.FullName;
                    if ((cname == "System.Diagnostics.DebuggerHiddenAttribute") ||
                        (cname == "System.Runtime.CompilerServices.CompilerGeneratedAttribute"))
                        is_compiler_generated = true;
                }
            }
Exemple #21
0
        void ReadLineNumbers(MethodEntry entry, MethodDebugInformation info)
        {
            var table = entry.GetLineNumberTable ();

            info.sequence_points = new Collection<SequencePoint> (table.LineNumbers.Length);

            for (var i = 0; i < table.LineNumbers.Length; i++) {
                var line = table.LineNumbers [i];
                if (i > 0 && table.LineNumbers [i - 1].Offset == line.Offset)
                    continue;

                info.sequence_points.Add (LineToSequencePoint (line));
            }
        }
            public MonoMethodLineNumberTable(MonoSymbolFile file, MonoMethod method,
							  MethodSource source, C.MethodEntry entry,
							  JitLineNumberEntry[] jit_lnt)
                : base(file, method)
            {
                this.method = method;
                this.entry = entry;
                this.line_numbers = jit_lnt;
            }
		public void DefineMethod (MonoSymbolFile file)
		{
			LineNumberEntry[] lines = new LineNumberEntry [method_lines_pos];
			Array.Copy (method_lines, lines, method_lines_pos);

			MethodEntry entry = new MethodEntry (
				file, _comp_unit.Entry, _method.Token, ScopeVariables,
				Locals, lines, Blocks, RealMethodName, _method_flags,
				_ns_id);

			file.AddMethod (entry);
		}
            public MonoMethodSource(MonoSymbolFile file, SourceFile source_file,
						 C.MethodEntry method, Cecil.MethodDefinition mdef,
						 MonoClassType klass, MonoFunctionType function)
            {
                this.file = file;
                this.source_file = source_file;
                this.method = method;
                this.mdef = mdef;
                this.function = function;
                this.klass = klass;

                full_name = method.GetRealName ();
                if (full_name == null)
                    full_name = MonoSymbolFile.GetMethodName (mdef);

                C.LineNumberEntry start, end;
                C.LineNumberTable lnt = method.GetLineNumberTable ();
                if (lnt.GetMethodBounds (out start, out end))
                    start_row = start.Row; end_row = end.Row;
            }
Exemple #25
0
		public MethodEntry DefineMethod (CompileUnitEntry comp_unit, int token,
						 ScopeVariable[] scope_vars, LocalVariableEntry[] locals,
						 LineNumberEntry[] lines, CodeBlockEntry[] code_blocks,
						 string real_name, MethodEntry.Flags flags,
						 int namespace_id)
		{
			if (reader != null)
				throw new InvalidOperationException ();

			MethodEntry method = new MethodEntry (
				this, comp_unit, token, scope_vars, locals, lines, code_blocks,
				real_name, flags, namespace_id);
			AddMethod (method);
			return method;
		}
Exemple #26
0
 public void AddMethod(MethodEntry entry)
 {
     methods.Add(entry);
 }
Exemple #27
0
		static void ReadLocalVariables (MethodEntry entry, MethodSymbols symbols)
		{
			foreach (var local in entry.GetLocals ()) {
				if (local.Index < 0 || local.Index >= symbols.Variables.Count) // Mono 2.6 emits wrong local infos for iterators
					continue;

				var variable = symbols.Variables [local.Index];
				variable.Name = local.Name;
			}
		}
        public void DefineMethod(MonoSymbolFile file, int token)
        {
            var blocks = Blocks;

            if (blocks.Length > 0)
            {
                //
                // When index is provided by user it can be inserted in
                // any order but mdb format does not store its value. It
                // uses stored order as the index instead.
                //
                var sorted    = new List <CodeBlockEntry> (blocks.Length);
                int max_index = 0;
                for (int i = 0; i < blocks.Length; ++i)
                {
                    max_index = System.Math.Max(max_index, blocks [i].Index);
                }

                for (int i = 0; i < max_index; ++i)
                {
                    var scope_index = i + 1;

                    //
                    // Common fast path
                    //
                    if (i < blocks.Length && blocks [i].Index == scope_index)
                    {
                        sorted.Add(blocks [i]);
                        continue;
                    }

                    bool found = false;
                    for (int ii = 0; ii < blocks.Length; ++ii)
                    {
                        if (blocks [ii].Index == scope_index)
                        {
                            sorted.Add(blocks [ii]);
                            found = true;
                            break;
                        }
                    }

                    if (found)
                    {
                        continue;
                    }

                    //
                    // Ideally this should never happen but with current design we can
                    // generate scope index for unreachable code before reachable code
                    //
                    sorted.Add(new CodeBlockEntry(scope_index, -1, CodeBlockEntry.Type.CompilerGenerated, 0));
                }

                blocks = sorted.ToArray();
                //for (int i = 0; i < blocks.Length; ++i) {
                //	if (blocks [i].Index - 1 != i)
                //			throw new ArgumentException ("CodeBlocks cannot be converted to mdb format");
                //}
            }

            var entry = new MethodEntry(
                file, _comp_unit.Entry, token, ScopeVariables,
                Locals, method_lines.ToArray(), blocks, null, MethodEntry.Flags.ColumnsInfoIncluded, ns_id);

            file.AddMethod(entry);
        }
Exemple #29
0
	private void ProcessMethod (MethodDefinition monoMethod, MethodEntry entry, ClassCoverageItem klass, string methodName, string cov_info)
#endif
	{
		if (entry == null)
			// Compiler generated, abstract method etc.
			return;

		LineNumberEntry[] lines = entry.GetLineNumberTable ().LineNumbers;

		if (lines.Length == 0)
			return;

		int start_line = lines [0].Row;
		int end_line = lines [lines.Length - 1].Row;

		MethodCoverageItem method 
			= new MethodCoverageItem (klass, methodName);

		method.startLine = start_line;
		method.endLine = end_line;
#if USE_REFLECTION
		method.filtered = IsFiltered ("[" + monoMethod.DeclaringType.Assembly + "]" + monoMethod.DeclaringType + "::" + monoMethod.Name);
#else
		method.filtered = IsFiltered ("[" + monoMethod.DeclaringType.Module.Name + "]" + monoMethod.DeclaringType + "::" + monoMethod.Name);
#endif
		klass.methodsByMethod [monoMethod] = method;


		if (klass.sourceFile == null) {
			string sourceFile = entry.CompileUnit.SourceFile.FileName;

			SourceFileCoverageData source = (SourceFileCoverageData)sources [sourceFile];
			if (source == null) {
				source = new SourceFileCoverageData (sourceFile);
				sources [sourceFile] = source;
			}
			klass.sourceFile = source;
		}
			
		computeMethodCoverage (method, lines, cov_info);
	}
Exemple #30
0
 static SequencePoint LineToSequencePoint(LineNumberEntry line, MethodEntry entry, Document document)
 {
     return new SequencePoint (document) {
         StartLine = line.Row,
         EndLine = line.EndRow,
         StartColumn = line.Column,
         EndColumn = line.EndColumn,
     };
 }
Exemple #31
0
		static Scope [] ReadScopes (MethodEntry entry, MethodBody body, InstructionMapper mapper)
		{
			var blocks = entry.GetCodeBlocks ();
			var scopes = new Scope [blocks.Length];

			foreach (var block in blocks) {
				if (block.BlockType != CodeBlockEntry.Type.Lexical)
					continue;

				var scope = new Scope ();
				scope.Start = mapper (block.StartOffset);
				scope.End = mapper (block.EndOffset);

				scopes [block.Index] = scope;

				if (body.Scope == null)
					body.Scope = scope;

				if (!AddScope (body.Scope, scope))
					body.Scope = scope;
			}

			return scopes;
		}
Exemple #32
0
 private void read_methods()
 {
     if (this.method_token_hash == null)
     {
         this.method_token_hash = new Dictionary<int, MethodEntry>();
         this.method_list = new List<MethodEntry>();
         long old_pos = this.reader.BaseStream.Position;
         this.reader.BaseStream.Position = (long)this.ot.MethodTableOffset;
         for (int i = 0; i < this.MethodCount; i++)
         {
             MethodEntry entry = new MethodEntry(this, this.reader, i + 1);
             this.method_token_hash.Add(entry.Token, entry);
             this.method_list.Add(entry);
         }
         this.reader.BaseStream.Position = old_pos;
     }
 }
Exemple #33
0
		static void ReadLocalVariables (MethodEntry entry, MethodSymbols symbols)
		{
			foreach (var local in entry.GetLocals ()) {
				var variable = symbols.Variables [local.Index];
				variable.Name = local.Name;
			}
		}
 public void AddMethod(MethodEntry entry)
 {
     methods.Add (entry);
 }
Exemple #35
0
		void ReadLineNumbers (MethodEntry entry, InstructionMapper mapper)
		{
			Document document = null;
			var table = entry.GetLineNumberTable ();

			foreach (var line in table.LineNumbers) {
				var instruction = mapper (line.Offset);
				if (instruction == null)
					continue;

				if (document == null)
					document = GetDocument (entry.CompileUnit.SourceFile);

				instruction.SequencePoint = new SequencePoint (document) {
					StartLine = line.Row,
					EndLine = line.Row,
				};
			}
		}
 internal void AddMethod(MethodEntry entry)
 {
     methods.Add(entry);
 }