Lines Matching defs:function

530   // Debug break at function entry, do not worry about stepping.
550     // We have to ignore recursive calls to function.
672   Handle<JSFunction> function = summary.AsJavaScript().function();
673   if (!function->shared().HasBreakInfo()) {
677   Handle<DebugInfo> debug_info(function->shared().GetDebugInfo(), isolate_);
729   // Make sure the function is compiled and has set up the debug info.
766   // Obtain shared function info for the innermost function containing this
776   // Find the nested shared function info that is closest to the position within
777   // the containing function.
781   // Set the breakpoint in the function.
861 int Debug::GetFunctionDebuggingId(Handle<JSFunction> function) {
863   Handle<SharedFunctionInfo> shared = handle(function->shared(), isolate_);
886   // Handle wasm function.
988   // Make sure the function is compiled and has set up the debug info.
993   // Flood the function with break points.
1056   // This method forces V8 to break on next function call regardless current
1060   // function is called, then we will clear this flag and let stepping continue
1071 void Debug::PrepareStepIn(Handle<JSFunction> function) {
1077   Handle<SharedFunctionInfo> shared(function->shared(), isolate_);
1079   if (*function == thread_local_.ignore_step_into_function_) return;
1081   FloodWithOneShot(Handle<SharedFunctionInfo>(function->shared(), isolate_));
1092   Handle<JSFunction> function(
1093       JSGeneratorObject::cast(thread_local_.suspended_generator_).function(),
1095   FloodWithOneShot(Handle<SharedFunctionInfo>(function->shared(), isolate_));
1131       Deoptimizer::DeoptimizeFunction(frame->function());
1140         // If it only contains one function, we already found the handler.
1162             summary.AsJavaScript().function()->shared(), isolate_);
1198     DCHECK(js_frame->function().IsJSFunction());
1202     Handle<JSFunction> function(summary.function());
1203     shared = Handle<SharedFunctionInfo>(function->shared(), isolate_);
1219       // On StepOut we'll ignore our further calls to current function in
1222         thread_local_.ignore_step_into_function_ = *function;
1231     // A step-next in blackboxed function is a step-out.
1273           // Stepping out of an async function whose implicit promise is awaited
1274           // by some other async function, should resume the latter. The return
1310           Deoptimizer::DeoptimizeFunction(js_frame->function());
1340 // Simple function for returning the source positions for active break points.
1386 // function is called each time a break point is hit as one shot break points
1391   // last break point for a function is removed that function is automatically
1412       if (!deopt_all && it.frame()->function().shared() != shared_) continue;
1425         // This is the case if a baseline function was inlined into a function
1498   // Deoptimize all code compiled from this shared function info including
1539     // Deopt everything in case the function is inlined anywhere.
1572   // If there is a breakpoint at function entry, we need to install trampoline.
1612   // By overwriting the function code with DebugBreakTrampoline, which tailcalls
1672     // Make sure the function has set up the debug info.
1715       // (toplevel function) there's an end position that is technically outside
1728         // If a top-level function contains only one function
1729         // declaration the source for the top-level and the function
1730         // is the same. In that case prefer the non top-level function.
1785   // Find all shared function infos of functions that are intersecting from
1786   // the requested position until the end of the enclosing function.
1884     // Go through all shared function infos associated with this script to
1885     // find the innermost function containing this position.
1886     // If there is no shared function info for this script at all, there is
1895         // It might be that the shared function info is not available as the
1907         // function in order to create this shared function info. So there can
2076   // Get the executing function in which the debug break occurred.
2077   Handle<SharedFunctionInfo> shared(frame->function().shared(), isolate_);
2293   // expression and compile it as anonymous function like (function() ..
2295   // expression V8 compile this function with negative offset. Instead of stmt
2296   // position blackboxing use function start position which is negative in
2490     Object fun = it.frame()->function();
2492       Handle<JSFunction> function(JSFunction::cast(fun), isolate_);
2494       Handle<SharedFunctionInfo> shared(function->shared(), isolate_);
2499       if (function->shared().HasBreakInfo()) {
2500         Handle<DebugInfo> debug_info(function->shared().GetDebugInfo(),
2554   PrintF("[debug] break in function '");
2734 bool Debug::PerformSideEffectCheck(Handle<JSFunction> function,
2740       function->shared().is_compiled_scope(isolate_));
2741   if (!function->is_compiled() &&
2742       !Compiler::Compile(isolate_, function, Compiler::KEEP_EXCEPTION,
2747   Handle<SharedFunctionInfo> shared(function->shared(), isolate_);
2755                function->shared().DebugNameCStr().get());
2765       // If function has bytecode array then prepare function for debug
2847   SharedFunctionInfo shared = frame->function().shared();