标签: stack-frame

在dotNet中,一行引发异常并被捕获,如何确定哪个文件在哪个行引发了异常？看起来相对简单,但我无法弄明白......

Smalltalk对象thisContext看起来奇怪而奇妙.我无法理解它是什么以及它是如何工作的.甚至它如何实现延续.

对于C的调用栈,我可以很容易地想象它是如何实现和工作的.但为此......我做不到.请帮我理解一下.

我正在使用VS2010来开发我的项目.在我的代码库中,我使用了stackframe的GetFileLineNumber()函数.但是,在运行时,它总是返回0.即使我正在运行调试版本,也会发生这种情况.我还确认生成的pdb文件与生成的可执行文件一起存在.

有任何想法吗？

使用时打印堆栈跟踪并不困难System.Diagnostics.我想知道是否有可能打印传递给堆栈跟踪上的每个方法的参数的值,如果不是,为什么不.

这是我的初步代码:

public static class CallStackTracker
{
    public static void Print()
    {
        var st = new StackTrace();
        for (int i = 0; i < st.FrameCount; i++)
        {
            var frame = st.GetFrame(i);
            var mb = frame.GetMethod();
            var parameters = mb.GetParameters();
            foreach (var p in parameters)
            {
                // Stuff probably goes here, but is there another way?
            }
        }
    }
}

提前致谢.

我正在学习OllyDbg中的汇编程序和调试技巧,以学习如何使用未记录的函数.现在我遇到以下问题:

我有以下代码部分(来自OllyDbg):

MOV EDI,EDI
PUSH EBP
MOV EBP,ESP
MOV EAX, DWORD PTR SS:[EBP+8]
XOR EDX,EDX
LEA ECX, DWORD PTR DS:[EAX+4]
MOV DWORD PTR DS:[EAX], EDX
MOV DWORD PTR DS:[ECX+4],ECX
MOV DWORD PTR DS:[ECX],ECX
MOV DWORD PTR DS:[EAX+C],ECX
MOV ECX, DWORD PTR SS:[EBP+C]

这是函数的开始,目标是查找数据结构.所以我发现它首先将EBP推入堆栈,然后将ESP(当前堆栈指针)移动到EBP,我认为它现在定义了该函数的堆栈帧.现在教程说在流行的布局中,第一个参数位于[EBP + 8],第二个参数位于[EBP + C]

这是我不明白的.我怎么知道第一个参数放在EBP + 8？

希望有人可以帮助我!谢谢!

以下是代码，我将其作为参考，以了解{}函数中存在的子作用域（或）虚拟作用域（仅）如何影响堆栈帧的结构。

#include <stdio.h>
int main()
{
   int main_scope=0; /*Scope and life time of the variable is throughout main*/

   {
     //From below two statements I assume that there
     //is no seperate "stack frame" created for just
     //braces {}.So we are free access (scope exists) and
     //modify (lifetime exists) the variable "main_scope"
     //anywhere within main

     main_scope++;
     printf("main_scope++:(%d)\n",main_scope);

    //I expected this statement to throw an error saying
    //"Multiple definition for "main_scope".But it isn't????

    int main_scope=2;
    printf("Value of redefined main_scope:(%d)\n",main_scope);

  }

  printf("Finally …

我在下面的代码中有一些关于ebp,esp和stack frame的问题.

1. 为什么我们从esp中减去28？我们在main中有两个局部变量x和y.那么为什么我们不减8？

2. 我们不是把值从右到左叠加？那么为什么我们在[eax + 8]而不是[eax + 4]中添加1？

3. 我对这个结构有点困惑.你能帮我吗？谢谢.

   func(int a, int b, int c)
   {
     return a+b+c;
   }
   main()
   {
    int x, y=3;
    x=func(y,2,1);
   }
   

   Run Code Online (Sandbox Code Playgroud)

Java 堆栈为每个方法调用创建新框架，但是此框架是否占用堆栈上的内存？

澄清我的问题：

public void oneWay()
{
  System.out.println("start");
  get1();
}

private void get1()
{
  System.out.println("get1");
  get2();
}

private void get2()
{
  System.out.println("get2");
}

此输出与以下内容相同：

public void anotherWay()
{
  System.out.println("start");
  System.out.println("get1");
  System.out.println("get2");
}

但是第二个片段在堆栈上占用更多内存还是相等？简而言之，堆栈帧是否占用内存？

编辑：堆栈帧需要多少内存？Sun（现在是 Oracle）是否有任何规范？

我无法理解堆栈帧和执行帧之间的差异,主要是关于traceback和inspect模块(在Python 3中).

我以为他们是相同的,但文档意味着他们不作为的方法inspect模块返回帧的对象,而方法的traceback模块不(即inspect.stack()VS traceback.print_stack().

从谷歌搜索,我知道堆栈帧是一个包含子程序状态信息(函数调用和参数数据)的数据结构.但是,根据文档,执行框架是类似的:

执行框架包含一些管理信息(用于调试),确定在代码块执行完成后执行继续的位置和方式,并且(可能最重要的)定义影响代码执行的两个名称空间,即本地名称空间和全局名称空间块.

那么堆栈帧和执行帧之间究竟有什么区别呢？

我试图找出是否有可能解决堆栈帧中的变量(如返回inspect.currentframe()).

换句话说,我正在寻找一个功能

def resolve_variable(variable_name, frame_object):
    return value_of_that_variable_in_that_stackframe

例如,请考虑以下代码:

global_var = 'global'

def foo():
    closure_var = 'closure'

    def bar(param):
        local_var = 'local'

        frame = inspect.currentframe()
        assert resolve_variable('local_var', frame) == local_var
        assert resolve_variable('param', frame) == param
        assert resolve_variable('closure_var', frame) == closure_var
        assert resolve_variable('global_var', frame) == global_var

    bar('parameter')

foo()

局部和全局变量平凡通过抬头f_locals和f_globals框架对象的属性:

def resolve_variable(variable_name, frame_object):
    try:
        return frame_object.f_locals[variable_name]
    except KeyError:
        try:
            return frame_object.f_globals[variable_name]
        except KeyError:
            raise NameError(varname) from None

但问题是关闭变量.据我所知,它们不存储在像本地和全局变量这样的字典中.更糟糕的是,如果函数实际访问它们,变量只会成为闭包变量(例如通过读取它的值_ = closure_var或者用它来写入它nonlocal closure_var; closure_var = _ …