Lines Matching refs:stack
55 // This value is based on a stack frame size histogram built for a set of
97 // The x86 is a 32-bit CPU, the limits of the supplied stack are invalid.
146 // Save the stack walking info we found, in case we need it later to
150 // This function only covers the full STACK WIN case. If
158 // callee argument pushed onto the stack, which may not be where %esp points
162 // stack after the callee returns. This is usually accomplished by adding
165 // parameters stored on the stack before returning. This is usually
167 // the stack after popping the return address.
169 // Because each frame's %esp will point to a location on the stack after
170 // callee arguments have been PUSHed, when locating things in a stack frame
181 // set the callee parameter size to 0: the stack pointer can't point to
227 // the stack was aligned to a quadword boundary.
237 // the results will be different depending on what is left on the stack
248 // On the top of the stack we have a pointer to the current instruction.
250 // on the top of the stack which is very atypical situaltion.
251 // Skip one slot from the stack and do another scan in order to get the
263 // function. Because of bugs described below, the stack may need to be
275 // .raSearchStart, the stack may need to be scanned afterward.
282 // value of %ebp can be recovered from a location in its stack frame,
287 // %ebp before returning. These functions create their stack frame
288 // after a CALL by decrementing the stack pointer in an amount
290 // registers onto the stack. Arguments to a callee function, if any,
292 // can be done solely with calculations relative to the stack pointer
295 // and locals. The caller's stack pointer (the value of %esp when
299 // the stack frame.
306 // about the use of .raSearchStart, the stack may need to be scanned
320 // The called procedure's instruction pointer and stack pointer are
323 // in the callee's stack frame and does not need to be recovered.
328 // Because of the use of .raSearchStart, the stack will possibly be
330 // evaluation. The stack will not be examined to locate a saved
371 // with stack frame info, and %ebp is pointing to non-stack memory, so
372 // our evaluation couldn't succeed. We'll scan the stack for a return
373 // address. This can happen if the stack is in a module for which
381 // if we can't find an instruction pointer even with stack scanning,
394 // Since this stack frame did not use %ebp in a traditional way,
396 // case, the stack can be scanned to locate the return address.
399 // %ebp values of 0, trust that the end of the stack has been
440 // stack. The scan is performed from the highest possible address to
448 // the location of the return address on the stack
466 // (the stack). Prefer it as a recovered %ebp result.
475 // Create a new stack frame (ownership will be transferred to the caller)
544 // address onto the stack and sets the instruction pointer (%eip) to
546 // PUSHes the calling routine's frame pointer (%ebp) onto the stack
547 // before copying the stack pointer (%esp) to the frame pointer (%ebp).
552 // calling procedure's stack pointer (%esp) is 8 higher than the value
570 // is pointing to non-stack memory. We'll scan the stack for a
577 // if we can't find an instruction pointer even with stack scanning,
602 // Create a new stack frame (ownership will be transferred to the caller)
618 StackFrame* StackwalkerX86::GetCallerFrame(const CallStack* stack,
620 if (!memory_ || !stack) {
621 BPLOG(ERROR) << "Can't get caller frame without memory or stack";
625 const vector<StackFrame*> &frames = *stack->frames();
629 // If the resolver has Windows stack walking information, use that.
652 // Treat an instruction address of 0 as end-of-stack.
656 // If the new stack pointer is at a lower address than the old, then
657 // that's clearly incorrect. Treat this as end-of-stack to enforce
