ESP is the current stack pointer. EBP is the base pointer for the current stack frame. When you call a function, typically space is reserved on the stack for local variables. This space is usually referenced via EBP (all local variables and function parameters are a known constant offset from this register for the duration … Read more
Yes, alloca is functionally equivalent to a local variable length array, i.e. this: int arr[n]; and this: int *arr = alloca(n * sizeof(int)); both allocate space for n elements of type int on the stack. The only differences between arr in each case is that 1) one is an actual array and the other is … Read more
Maybe you’re wondering about this: push ebp mov ebp, esp sub esp, 12 These lines are known as the assembly function prologue. The first 2 instructions save the previous base pointer (ebp) and set EBP to point at that position on the stack (right below the return address). This sets up EBP as a frame … Read more
enter is avoided in practice as it performs quite poorly – see the answers at “enter” vs “push ebp; mov ebp, esp; sub esp, imm” and “leave” vs “mov esp, ebp; pop ebp”. There are a bunch of x86 instructions that are obsolete but are still supported for backwards compatibility reasons – enter is one … Read more
This seems to be a reliable, simple way to get the “entry” or main assembly for a web app. If you put controllers in a separate project, you may find that the base class of ApplicationInstance is not in the same assembly as your MVC project that contains the Views – but, this setup seems … Read more
There is a performance difference, especially for enter. On modern processors this decodes to some 10 to 20 µops, while the three instruction sequence is about 4 to 6, depending on the architecture. For details consult Agner Fog’s instruction tables. Additionally the enter instruction usually has a quite high latency, for example 8 clocks on … 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
Java requires all classes that are loaded to be verified, in order to maintain the security of the sandbox and ensure that the code is safe to optimize. Note that this is done on the bytecode level, so the verification does not verify invariants of the Java language, it merely verifies that the bytecode makes … Read more
parent.env is the environment in which a closure (e.g., function) is defined. parent.frame is the environment from which the closure was invoked. f = function() c(f=environment(), defined_in=parent.env(environment()), called_from=parent.frame()) g = function() c(g=environment(), f()) and then > g() $g <environment: 0x14060e8> $f <environment: 0x1405f28> $defined_in <environment: R_GlobalEnv> $called_from <environment: 0x14060e8> I’m not sure when a mere … Read more
Most smaller functions don’t need a frame pointer – larger functions MAY need one. It’s really about how well the compiler manages to track how the stack is used, and where things are on the stack (local variables, arguments passed to the current function and arguments being prepared for a function about to be called). … Read more