You do have to do it the hard way, but it’s not really all that hard… Seriously, once you’ve written the template once, it’s a quick copy/paste/modify to match the function name in the Err.Raise statement to the actual function name. Private Function DoSomething(ByVal Arg as String) On Error GoTo Handler Dim ThisVar as String … Read more
How can we list all the functions being called in an application For any realistically sized application, this list will have thousands of entries, which will probably make it useless. You can find out all functions defined (but not necessarily called) in an application with the nm command, e.g. nm /path/to/a.out | egrep ‘ [TW] … Read more
You can use Devel::StackTrace. use Devel::StackTrace; my $trace = Devel::StackTrace->new; print $trace->as_string; # like carp It behaves like Carp’s trace, but you can get more control over the frames. The one problem is that references are stringified and if a referenced value changes, you won’t see it. However, you could whip up some stuff with … Read more
esp is the stack pointer, ebp is/was for a stack frame so that when you entered a function ebp could get a copy of esp at that point, everything on the stack before that happens, return address, passed in parameters, etc and things that are global for that function (local variables) will now be a … Read more
Windows pages in extra stack for your thread as it is used. At the end of the stack, there is one guard page mapped as inaccessible memory — if the program accesses it (because it is trying to use more stack than is currently mapped), there’s an access violation. The OS catches the fault, maps … Read more
When you write a = value, you are calling the property setter again. In order to use non-automatic properties, you need to create a separate private backing field, like this: ConstraintSet a; public ConstraintSet A { get { return a; } set { a = value; } }
First, it’s platform dependent. In some architectures, stack is allocated from the bottom of the address space and grows upwards. Assuming an architecture like x86 that stack grown downwards from the top of address space, the idea is pretty simple: =============== Highest Address (e.g. 0xFFFF) | | | STACK | | | |————-| <- Stack … Read more
Here is what the gcc manual has to say about it: -mpush-args -mno-push-args Use PUSH operations to store outgoing parameters. This method is shorter and usually equally fast as method using SUB/MOV operations and is enabled by default. In some cases disabling it may improve performance because of improved scheduling and reduced dependencies. -maccumulate-outgoing-args If … Read more
You’ve explained it yourself. The “return address” by definition tells you where you are going next. There is no requirement whatsoever that the return address that is put on the stack is an address inside the method that called the method you’re in now. It typically is, which sure makes it easier to debug. But … Read more
Update: There is now a better answer to this question: use GDB _is_caller convenience function. The need you describe comes up quite often, usually in the context of some_utility_fn being called a lot, but you only are interested in the call which comes from some_other_fn. You could probably script this entire interaction using the new … Read more