Exemple #1
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,
                };
            }
        }
Exemple #2
0
        private static IEnumerable <SequencePoint> ReadSequencePoints(MethodEntry entry)
        {
            var table = entry.GetLineNumberTable();

            return(table.LineNumbers.Select(line => new SequencePoint
            {
                File = entry.CompileUnit.SourceFile.FileName,
                Offset = line.Offset,
                StartRow = line.Row,
                EndRow = line.Row
            }));
        }
Exemple #3
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,
                                     LineToSequencePoint(line, entry, GetDocument(entry.CompileUnit.SourceFile))));
            }
        }
Exemple #4
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 #5
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));
            }
        }
Exemple #6
0
        private void ReadLineNumbers(MethodEntry entry, MethodSymbols symbols)
        {
            LineNumberTable table = entry.GetLineNumberTable();

            LineNumberEntry[] lines = table.LineNumbers;
            Collection <InstructionSymbol> instructions = symbols.instructions = new Collection <InstructionSymbol>(lines.Length);

            for (int i = 0; i < lines.Length; i++)
            {
                LineNumberEntry line = lines[i];
                instructions.Add(new InstructionSymbol(line.Offset, new SequencePoint(this.GetDocument(entry.CompileUnit.SourceFile))
                {
                    StartLine = line.Row,
                    EndLine   = line.Row
                }));
            }
        }
Exemple #7
0
        void ReadLineNumbers(MethodEntry entry, MethodSymbols symbols)
        {
            var table = entry.GetLineNumberTable();
            var lines = table.LineNumbers;

            var instructions = symbols.Instructions;

            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,
                }));
            }
        }
        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 #9
0
        /// <summary>
        /// Provides the method mapping for the specified MDB method.
        /// </summary>
        /// <param name="mdbMethod">The MDB MethodEntry to get the mapping for.</param>
        private MethodMapping GetMapping(MethodEntry mdbMethod)
        {
            var methodMapping = new MethodMapping()
            {
                MethodToken = (uint)mdbMethod.Token,
                SourceFile  = mdbMethod.CompileUnit.SourceFile.FileName
            };

            LineNumberTable lineNumberTable = mdbMethod.GetLineNumberTable();

            if (lineNumberTable != null)
            {
                LineNumberEntry[] lines = lineNumberTable.LineNumbers;

                if (lines != null && lines.Length > 0)
                {
                    methodMapping.StartLine = (uint)lines[0].Row;
                    methodMapping.EndLine   = (uint)lines[lines.Length - 1].Row;
                }
            }

            return(methodMapping);
        }
Exemple #10
0
        void ReadLineNumbers(MethodEntry entry, MethodDebugInformation info)
        {
            Document document = null;
            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 (document == null)
                {
                    document = GetDocument(entry.CompileUnit.SourceFile);
                }

                if (i > 0 && table.LineNumbers [i - 1].Offset == line.Offset)
                {
                    continue;
                }

                info.sequence_points.Add(LineToSequencePoint(line, entry, document));
            }
        }
Exemple #11
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
                    };
                }
            }
        }
        protected void CheckMethod(MethodEntry method)
        {
            Cecil.MethodDefinition mdef = (Cecil.MethodDefinition)Assembly.MainModule.LookupToken(
                new Cecil.MetadataToken(Cecil.TokenType.Method, method.Token & 0xffffff));
            if ((mdef == null) || (mdef.Body == null))
            {
                throw new MonoSymbolFileException("Method {0} (token {1:x}) not found in assembly.",
                                                  method.Index, method.Token);
            }

            string name = String.Format("{0} ({1})", method.Index, GetMethodName(mdef));

            Debug("[Method {0} - {1} - {2}]", method.Index, method.CompileUnit.SourceFile.FileName,
                  GetMethodName(mdef));

            LineNumberTable lnt = method.GetLineNumberTable();

            if (lnt == null)
            {
                throw new MonoSymbolFileException("Cannot get LNT from method {0}.", name);
            }

            if (lnt.LineNumbers == null)
            {
                throw new MonoSymbolFileException("Cannot get LNT from method {0}.", name);
            }
            LineNumberEntry start, end;

            if (lnt.GetMethodBounds(out start, out end))
            {
                Debug("  Bounds: {0} {1}", start, end);
            }
            foreach (LineNumberEntry line in lnt.LineNumbers)
            {
                Debug("    Line: {0}", line);
            }

            CodeBlockEntry[] blocks = method.GetCodeBlocks() ?? new CodeBlockEntry [0];
            foreach (CodeBlockEntry block in blocks)
            {
                if ((block.Parent >= 0) && (block.Parent >= blocks.Length))
                {
                    throw new MonoSymbolFileException(
                              "Code block {0} in method {1} has invalid parent index {2} (valid is 0..{3}).",
                              block, name, block.Parent, blocks.Length);
                }
            }

            LocalVariableEntry[] locals = method.GetLocals() ?? new LocalVariableEntry [0];
            foreach (LocalVariableEntry local in locals)
            {
                if ((local.BlockIndex < 0) || ((local.BlockIndex > 0) && (local.BlockIndex > blocks.Length)))
                {
                    throw new MonoSymbolFileException(
                              "Local variable {0} in method {1} has invalid block index {2} (valid is 0..{3}).",
                              local, name, local.BlockIndex, blocks.Length);
                }

                Debug("  Local: {0}", local);
            }

            int num_locals = mdef.Body.Variables.Count;

            ScopeVariable[] scope_vars = method.GetScopeVariables() ?? new ScopeVariable [0];
            foreach (ScopeVariable var in scope_vars)
            {
                Debug("  Scope var: {0}", var);
                if ((mdef.IsStatic) && (var.Index < 0))
                {
                    throw new MonoSymbolFileException(
                              "Method {0} has invalid scope variable {1} (referencing `this' in static method).",
                              name, var);
                }
                if ((var.Index >= 0) && (var.Index >= num_locals))
                {
                    throw new MonoSymbolFileException(
                              "Method {0} has invalid scope variable {1} (index out of bounds: {2} / {3}).",
                              name, var, var.Index, num_locals);
                }
                if ((var.Scope > 0) && (File.GetAnonymousScope(var.Scope) == null))
                {
                    throw new MonoSymbolFileException(
                              "Method {0} has invalid scope variable {1} (can't find scope {2}).",
                              name, var, var.Scope);
                }
            }
        }
        public void PrintLineNumberTables()
        {
            Message("Reading {0}, version {1}.{2}.", File.FileName, File.MajorVersion,
                    File.MinorVersion);

            for (int i = 0; i < File.MethodCount; i++)
            {
                if (LineNumberTables.Count > 0)
                {
                    if (!LineNumberTables.ContainsKey(i + 1))
                    {
                        continue;
                    }
                }

                MethodEntry method = File.GetMethod(i + 1);
                if (method == null)
                {
                    throw new MonoSymbolFileException("Cannot get method {0}.", i + 1);
                }

                Cecil.MethodDefinition mdef = (Cecil.MethodDefinition)Assembly.MainModule.LookupToken(
                    new Cecil.MetadataToken(Cecil.TokenType.Method, method.Token & 0xffffff));
                if ((mdef == null) || (mdef.Body == null))
                {
                    throw new MonoSymbolFileException("Method {0} (token {1:x}) not found in assembly.",
                                                      method.Index, method.Token);
                }

                string name = String.Format("{0} ({1})", method.Index, GetMethodName(mdef));
                Message("Method {0} - {1}", method.Index, GetMethodName(mdef));

                LineNumberTable lnt = method.GetLineNumberTable();
                if (lnt == null)
                {
                    throw new MonoSymbolFileException("Cannot get LNT from method {0}.", name);
                }

                if (lnt.LineNumbers == null)
                {
                    throw new MonoSymbolFileException("Cannot get LNT from method {0}.", name);
                }

                Dictionary <int, bool> seen_files = new Dictionary <int, bool> ();

                LineNumberEntry start, end;
                if (lnt.GetMethodBounds(out start, out end))
                {
                    Message("  Bounds: {0} {1}", start, end);
                }
                foreach (LineNumberEntry line in lnt.LineNumbers)
                {
                    if (!line.IsHidden && !seen_files.ContainsKey(line.File))
                    {
                        SourceFileEntry file = File.GetSourceFile(line.File);
                        Message("  File {0}{2}: {1}", file.Index, file.FileName,
                                file.AutoGenerated ? " (auto-generated)" : "");
                        seen_files.Add(line.File, true);
                    }

                    string range = "";
                    if (line.SourceRange != null)
                    {
                        SourceRangeEntry sre = (SourceRangeEntry)line.SourceRange;
                        range = String.Format(" - {0} {1} {2} {3}", sre.StartLine, sre.EndLine,
                                              sre.StartColumn, sre.EndColumn);
                    }

                    Message("    Line {0}:{1}:{2:x}{3}{4}", line.File, line.Row, line.Offset,
                            line.IsHidden ? " (hidden)" : "", range);
                }
            }
        }
Exemple #14
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,
                    LineToSequencePoint (line, entry, GetDocument (entry.CompileUnit.SourceFile))));
            }
        }
Exemple #15
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 = LineToSequencePoint (line, entry, document);
            }
        }