Lines Matching refs:Function
191 // Set the positions to the end of the function.
348 // function twice might happen when stepping in a function with an exception
349 // handler as the handler and the function is the same.
424 // because caller of this function (Debug::PrepareStep) is expected to
425 // flood the top frame's function with one shot breakpoints.
427 // this function (Debug::PrepareStep) which should flood target function
437 // Check whether the break point is at a position which will exit the function.
470 // Patch the code to invoke the builtin debug break function matching the
577 // -- function (slot is called "context")
585 // Move function pointer into "context" slot.
698 // We need to clear all breakpoints associated with the function to restore
700 // the function will live in the heap until next gc, and can be found by
764 // Execute the shared function in the debugger context.
767 Handle<JSFunction> function =
771 Execution::TryCall(function, Handle<Object>(context->global()),
790 Handle<Script> script(Script::cast(function->shared()->script()));
923 Handle<SharedFunctionInfo>(JSFunction::cast(frame->function())->shared());
1050 // triggered. This function returns a JSArray with the break point objects
1095 // Get the function IsBreakPointTriggered (defined in debug-debugger.js).
1126 // Check whether the function has debug information.
1132 // Return the debug info for this function. EnsureDebugInfo must be called
1191 // function.
1221 // Make sure the function has set up the debug info.
1227 // Flood the function with break points.
1236 void Debug::FloodBoundFunctionWithOneShot(Handle<JSFunction> function) {
1237 Handle<FixedArray> new_bindings(function->function_bindings());
1260 JSFunction::cast(frame->function())->shared());
1261 // Flood the function with the catch block with break points
1320 // If the function on the top frame is unresolved perform step out. This will
1323 if (!frame->function()->IsJSFunction()) {
1327 // Fill the function to return to with one-shot break points.
1328 JSFunction* function = JSFunction::cast(frames_it.frame()->function());
1329 FloodWithOneShot(Handle<SharedFunctionInfo>(function->shared()));
1335 Handle<SharedFunctionInfo>(JSFunction::cast(frame->function())->shared());
1398 JSFunction::cast(frames_it.frame()->function())->IsBuiltin()) {
1404 // Fill the function to return to with one-shot break points.
1405 JSFunction* function = JSFunction::cast(frames_it.frame()->function());
1406 FloodWithOneShot(Handle<SharedFunctionInfo>(function->shared()));
1415 // Fill the current function with one-shot break points.
1424 // to function which is going to be restarted.
1432 // If it's CallFunction stub ensure target function is compiled and flood
1447 // expected arguments of the called function.
1454 // Find target function on the expression stack.
1460 // Function to call
1471 // It will also compile target function
1477 // Fill the current function with one-shot break points even for step in on
1478 // a call target as the function called might be a native function for
1504 // flooded with one-shot break points. This function helps to perform several
1519 // Never continue if returning from function.
1562 // Find the builtin debug break function matching the calling convention
1608 // Simple function for returning the source positions for active break points.
1646 // Handle stepping into a function.
1647 void Debug::HandleStepIn(Handle<JSFunction> function,
1663 // Flood the function with one-shot break points if it is called from where
1666 if (function->shared()->bound()) {
1667 // Handle Function.prototype.bind
1668 Debug::FloodBoundFunctionWithOneShot(function);
1669 } else if (!function->IsBuiltin()) {
1671 if (function->shared()->code() ==
1673 function->shared()->code() ==
1675 // Handle function.apply and function.call separately to flood the
1676 // function to be called and not the code for Builtins::FunctionApply or
1678 // function.
1686 Debug::FloodWithOneShot(Handle<SharedFunctionInfo>(function->shared()));
1705 // function is called each time a break point is hit as one shot break points
1709 // last break point for a function is removed that function is automatically
1753 // Helper function to compile full code for debugging. This code will
1756 // optimized version of this function is still activated on the
1804 JSFunction* function = functions[i];
1805 active_functions->Add(Handle<JSFunction>(function));
1806 function->shared()->code()->set_gc_metadata(active_code_marker);
1808 } else if (frame->function()->IsJSFunction()) {
1809 JSFunction* function = JSFunction::cast(frame->function());
1810 ASSERT(frame->LookupCode()->kind() == Code::FUNCTION);
1811 active_functions->Add(Handle<JSFunction>(function));
1812 function->shared()->code()->set_gc_metadata(active_code_marker);
1824 if (frame->is_optimized() || !frame->function()->IsJSFunction()) continue;
1826 JSFunction* function = JSFunction::cast(frame->function());
1828 ASSERT(frame->LookupCode()->kind() == Code::FUNCTION);
1833 Handle<Code> new_code(function->shared()->code());
1834 if (new_code->kind() != Code::FUNCTION ||
1961 // function and mark them for lazy compilation.
1966 JSFunction* function = JSFunction::cast(obj);
1967 SharedFunctionInfo* shared = function->shared();
1970 function->code()->kind() == Code::FUNCTION &&
1971 !function->code()->has_debug_break_slots() &&
1973 function->set_code(*lazy_compile);
1974 function->shared()->set_code(*lazy_compile);
1981 Handle<JSFunction> function = active_functions[i];
1982 function->shared()->code()->set_gc_metadata(Smi::FromInt(0));
1989 Handle<JSFunction> function = active_functions[i];
1991 if (function->code()->kind() == Code::FUNCTION &&
1992 function->code()->has_debug_break_slots()) {
1993 // Nothing to do. Function code already had debug break slots.
1997 Handle<SharedFunctionInfo> shared(function->shared());
2010 Handle<Code> current_code(function->shared()->code());
2016 ASSERT(current_code->kind() == Code::FUNCTION);
2026 // Keep function code in sync with shared function info.
2027 function->set_code(shared->code());
2104 // Get the executing function in which the debug break occurred.
2106 Handle<SharedFunctionInfo>(JSFunction::cast(frame->function())->shared());
2177 // care of the case where the last break point is removed from the function
2196 // Get the executing function in which the debug break occurred.
2198 Handle<SharedFunctionInfo>(JSFunction::cast(frame->function())->shared());
2433 Handle<Object> Debugger::MakeNewFunctionEvent(Handle<Object> function,
2435 // Create the new function event object.
2436 Handle<Object> argv[] = { function };
2603 // Get the function UpdateScriptBreakPoints (defined in debug-debugger.js).
2699 // a JavaScript function. Don't call event listener for v8::Break
2860 v8::Local<v8::Function> fun =
2861 v8::Function::Cast(*api_exec_state->Get(fun_name));
2903 v8::Local<v8::Function> fun;
2907 fun = v8::Function::Cast(*cmd_processor->Get(fun_name));
2933 fun = v8::Function::Cast(*cmd_processor->Get(fun_name));
