Lines Matching defs:stack
98 #include "src/regexp/regexp-stack.h"
137 #include "src/heap/conservative-stack-visitor.h"
578 // Iterate over pointers on native execution stack.
586 // The active stack's jump buffer does not match the current state, use
632 "\n\nAttempt to print stack while printing stack (double fault)\n");
634 "If you are lucky you may find a partial stack dump on stdout.\n\n");
662 // to force stack allocation.
714 // framework and library code, and stack depth tends to be more than
822 // Poison stack frames below the first strict mode frame.
823 // The stack trace API should not expose receivers and function
834 // Determines whether the given stack frame should be displayed in a stack
840 // This mechanism excludes a number of uninteresting frames from the stack
871 // The --builtins-in-stack-traces command line flag allows including
872 // internal call sites in the stack trace for debugging purposes.
1171 // If --async-stack-traces are enabled and the "current microtask" is a
1172 // PromiseReactionJobTask, we try to enrich the stack trace with async
1191 // Capture the "simple stack trace" for the error.stack property,
1194 // is active, and requests more stack frames than the JavaScript
1204 // can ask the stack traces to also include cross-origin frames,
1216 // stack trace" above and whether that's usable (meaning the API
1218 // cap for the stack trace (either a positive limit indicating that
1221 // collect a "detailed stack trace" eagerly and stash that away.
1424 "\n\nAttempt to print stack while printing stack (double fault)\n");
1426 "If you are lucky you may find a partial stack dump on stdout.\n\n");
1447 "\n==== JS stack trace =========================================\n\n");
1540 // Whoever calls this method should not have overflown the stack limit by too
1541 // much. Otherwise we risk actually running out of stack space.
1545 // If this DCHECK fails, one of the frames on the stack should be augmented by
1546 // an additional stack check.
1556 FATAL("Aborting on stack overflow");
1730 // print a user-friendly stack trace (not an internal one).
1817 // It's not safe to try to make message objects or collect stack traces
1913 // Because the array join stack will not pop the elements when throwing the
1914 // uncatchable terminate exception, we need to clear the array join stack to
1915 // avoid leaving the stack in an invalid state.
1923 // Compute handler and stack unwinding information by performing a full walk
1924 // over the stack and dispatching according to the frame type.
1959 // Compute the stack pointer from the frame pointer. This ensures that
1960 // argument slots on the stack are dropped as returning would.
1983 // Compute the stack pointer from the frame pointer. This ensures that
1984 // argument slots on the stack are dropped as returning would.
2013 // Compute the stack pointer from the frame pointer. This ensures
2014 // that argument slots on the stack are dropped as returning would.
2052 // Compute the stack pointer from the frame pointer. This ensures
2053 // that argument slots on the stack are dropped as returning would.
2074 // Compute the stack pointer from the frame pointer. This ensures that
2075 // argument slots on the stack are dropped as returning would.
2108 // shadow stack will drop the underlying interpreter entry trampoline
2136 // Reconstruct the stack pointer from the frame pointer.
2221 // Search for an exception handler by performing a full walk over the stack.
2444 // We fetch the stack trace that corresponds to this error object.
2446 // object. In that case, we fall through and capture the stack trace
2452 // Not an error object, we capture stack and location at throw site.
2692 std::stack<Handle<JSPromise>> promises;
2693 // First descend into the outermost promise and collect the stack of
2770 // successive async/await stack frames until an asynchronous one with
2771 // dependents is found, or a non-async stack frame is encountered, in
2879 // NOTE: This code assumes that the stack grows downward.
3512 // The entry stack must be empty when we get here.
3853 // This global counter contains number of stack loads/stores per optimized/wasm
3947 // Ensure that the thread has a valid stack guard. The v8::Locker object
4207 std::unique_ptr<wasm::StackMemory> stack(
4209 this->wasm_stacks() = stack.get();
4211 PrintF("Set up native stack object (limit: %p, base: %p)\n",
4212 stack->jslimit(), reinterpret_cast<void*>(stack->base()));
4216 WasmContinuationObject::New(this, std::move(stack));
4272 // Pop the stack.
4296 os << "No stack accesses in optimized/wasm functions found.";
4299 os << "Number of optimized/wasm stack-access functions: "
4893 v8::Local<v8::Value> stack;
4895 this, stack,
4899 return Utils::OpenHandle(*stack);
5023 // so pop the outer promise from the isolate's promise stack.
5099 // (2) Empty the promise stack to avoid leaking memory.
5110 // Empty the promise stack.
5414 // The simulator uses a separate JS stack.