Example #1
0
        static void ReadLocalVariables(MethodEntry entry, MethodBody body, Scope [] scopes)
        {
            var locals = entry.GetLocals();

            foreach (var local in locals)
            {
                if (local.Index < 0 || local.Index >= body.Variables.Count)                 // Mono 2.6 emits wrong local infos for iterators
                {
                    continue;
                }

                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);
            }
        }
Example #2
0
 static void ReadLocalVariables(MethodEntry entry, MethodSymbols symbols)
 {
     foreach (var local in entry.GetLocals())
     {
         var variable = symbols.Variables [local.Index];
         variable.Name = local.Name;
     }
 }
Example #3
0
 private static void ReadLocalVariables(MethodEntry entry, MethodSymbols symbols)
 {
     LocalVariableEntry[] locals = entry.GetLocals();
     for (int i = 0; i < locals.Length; i++)
     {
         LocalVariableEntry local    = locals[i];
         VariableDefinition variable = symbols.Variables[local.Index];
         variable.Name = local.Name;
     }
 }
Example #4
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;
            }
        }
Example #5
0
        private static void ReadLocals(MethodEntry entry, IMethodBody body)
        {
            foreach (var local in entry.GetLocals())
            {
                if (local.Index < 0 || local.Index >= body.LocalVariables.Count)                 // Mono 2.6 emits wrong local infos for iterators
                {
                    continue;
                }

                var variable = body.LocalVariables[local.Index];
                variable.Name = local.Name;
            }
        }
        public void PrintLocals(MethodEntry method)
        {
            CodeBlockEntry[] blocks = method.GetCodeBlocks() ?? new CodeBlockEntry [0];
            foreach (CodeBlockEntry block in blocks)
            {
                Message("  CodeBlock {0}", block);
            }

            LocalVariableEntry[] locals = method.GetLocals() ?? new LocalVariableEntry [0];
            foreach (LocalVariableEntry local in locals)
            {
                Message("  Local {0}", local);
            }
        }
Example #7
0
        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);
            }
        }
Example #8
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);
             }
         }
     }
 }
Example #9
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);
            }
        }
Example #10
0
        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);
                }
            }
        }
Example #11
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;
            }
        }
Example #12
0
        static void ReadLocalVariables(MethodEntry entry, MethodBody body, Scope [] scopes)
        {
            var locals = entry.GetLocals ();

            foreach (var local in locals) {
                if (local.Index < 0 || local.Index >= body.Variables.Count) // Mono 2.6 emits wrong local infos for iterators
                    continue;

                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);
            }
        }