Lines Matching refs:function
5 #include "src/objects/js-function.h"
84 // Returns false if no highest tier exists (i.e. the function is not compiled),
150 // Essentially, what we are asking here is, has this function been compiled
157 // Note that when the function has not yet been compiled we also return
222 Handle<JSFunctionOrBoundFunctionOrWrappedFunction> function,
251 LookupIterator it(isolate, function, isolate->factory()->length_string(),
252 function);
293 LookupIterator it(isolate, function, isolate->factory()->name_string());
306 Handle<JSBoundFunction> function) {
311 while (function->bound_target_function().IsJSBoundFunction()) {
315 function = handle(JSBoundFunction::cast(function->bound_target_function()),
318 if (function->bound_target_function().IsJSWrappedFunction()) {
320 JSWrappedFunction::cast(function->bound_target_function()), isolate);
326 if (function->bound_target_function().IsJSFunction()) {
328 JSFunction::cast(function->bound_target_function()), isolate);
338 Handle<JSBoundFunction> function) {
339 int nof_bound_arguments = function->bound_arguments().length();
340 while (function->bound_target_function().IsJSBoundFunction()) {
341 function = handle(JSBoundFunction::cast(function->bound_target_function()),
344 // arguments of a function is strictly limited by the max length of an
346 int length = function->bound_arguments().length();
353 if (function->bound_target_function().IsJSWrappedFunction()) {
355 JSWrappedFunction::cast(function->bound_target_function()), isolate);
365 Handle<JSFunction> target(JSFunction::cast(function->bound_target_function()),
374 Handle<String> JSBoundFunction::ToString(Handle<JSBoundFunction> function) {
375 Isolate* const isolate = function->GetIsolate();
381 Isolate* isolate, Handle<JSWrappedFunction> function) {
386 handle(function->wrapped_target_function(), isolate);
390 handle(JSBoundFunction::cast(function->wrapped_target_function()),
395 handle(JSFunction::cast(function->wrapped_target_function()), isolate));
403 Handle<JSWrappedFunction> function) {
406 handle(function->wrapped_target_function(), isolate);
410 handle(JSBoundFunction::cast(function->wrapped_target_function()),
419 Handle<String> JSWrappedFunction::ToString(Handle<JSWrappedFunction> function) {
420 Isolate* const isolate = function->GetIsolate();
431 // wrapped function won't cause a side effect in the creation realm.
481 Handle<JSFunction> function) {
482 if (function->shared().name_should_print_as_anonymous()) {
485 return handle(function->shared().Name(), isolate);
490 Handle<JSFunction> function, bool reset_budget_for_feedback_allocation) {
491 Isolate* const isolate = function->GetIsolate();
492 DCHECK(function->shared().is_compiled());
493 DCHECK(function->shared().HasFeedbackMetadata());
495 if (function->shared().HasAsmWasmData()) return;
498 Handle<SharedFunctionInfo> shared(function->shared(), isolate);
499 DCHECK(function->shared().HasBytecodeArray());
502 (function->has_closure_feedback_cell_array() ||
503 function->has_feedback_vector());
511 function->SetInterruptBudget(isolate);
521 // feedback cell for this function and a new feedback cell has to be
526 if (function->raw_feedback_cell() == isolate->heap()->many_closures_cell()) {
529 function->set_raw_feedback_cell(*feedback_cell, kReleaseStore);
530 function->SetInterruptBudget(isolate);
532 function->raw_feedback_cell().set_value(*feedback_cell_array,
539 Handle<JSFunction> function,
542 DCHECK(function->shared().HasFeedbackMetadata());
543 if (function->has_feedback_vector()) return;
545 if (function->shared().HasAsmWasmData()) return;
548 CreateAndAttachFeedbackVector(isolate, function, compiled_scope);
553 Isolate* isolate, Handle<JSFunction> function,
556 DCHECK(function->shared().HasFeedbackMetadata());
557 DCHECK(!function->has_feedback_vector());
559 DCHECK(!function->shared().HasAsmWasmData());
562 Handle<SharedFunctionInfo> shared(function->shared(), isolate);
563 DCHECK(function->shared().HasBytecodeArray());
565 EnsureClosureFeedbackCellArray(function, false);
567 handle(function->closure_feedback_cell_array(), isolate);
571 // to allocate a new feedback cell. Please look at comment in that function
573 DCHECK(function->raw_feedback_cell() !=
575 function->raw_feedback_cell().set_value(*feedback_vector, kReleaseStore);
576 function->SetInterruptBudget(isolate);
581 Handle<JSFunction> function, IsCompiledScope* is_compiled_scope,
583 Isolate* const isolate = function->GetIsolate();
590 if (function->shared().HasAsmWasmData()) return;
593 if (function->has_feedback_vector()) {
594 CHECK_EQ(function->feedback_vector().length(),
595 function->feedback_vector().metadata().slot_count());
599 if (function->has_closure_feedback_cell_array()) {
601 function->closure_feedback_cell_array().length(),
602 function->shared().feedback_metadata().create_closure_slot_count());
613 CreateAndAttachFeedbackVector(isolate, function, is_compiled_scope);
615 EnsureClosureFeedbackCellArray(function,
622 void SetInstancePrototype(Isolate* isolate, Handle<JSFunction> function,
625 // function as a constructor.
626 if (function->has_initial_map()) {
627 // If the function has allocated the initial map replace it with a
631 function->CompleteInobjectSlackTrackingIfActive();
633 Handle<Map> initial_map(function->initial_map(), isolate);
640 function->set_prototype_or_initial_map(*value, kReleaseStore);
644 JSFunction::SetInitialMap(isolate, function, new_map, value);
646 *function != function->native_context().array_function());
656 function->set_prototype_or_initial_map(*value, kReleaseStore);
666 void JSFunction::SetPrototype(Handle<JSFunction> function,
668 DCHECK(function->IsConstructor() ||
669 IsGeneratorFunction(function->shared().kind()));
670 Isolate* isolate = function->GetIsolate();
682 Map::Copy(isolate, handle(function->map(), isolate), "SetPrototype");
686 JSObject::MigrateToMap(isolate, function, new_map);
688 FunctionKind kind = function->shared().kind();
689 Handle<Context> native_context(function->native_context(), isolate);
700 function->map().set_has_non_instance_prototype(false);
703 SetInstancePrototype(isolate, function, construct_prototype);
706 void JSFunction::SetInitialMap(Isolate* isolate, Handle<JSFunction> function,
708 SetInitialMap(isolate, function, map, prototype, function);
711 void JSFunction::SetInitialMap(Isolate* isolate, Handle<JSFunction> function,
718 function->set_prototype_or_initial_map(*map, kReleaseStore);
722 handle(function->shared(), isolate))));
726 void JSFunction::EnsureHasInitialMap(Handle<JSFunction> function) {
727 DCHECK(function->has_prototype_slot());
728 DCHECK(function->IsConstructor() ||
729 IsResumableFunction(function->shared().kind()));
730 if (function->has_initial_map()) return;
731 Isolate* isolate = function->GetIsolate();
734 CalculateExpectedNofProperties(isolate, function);
739 if (function->has_initial_map()) return;
742 // by the function.
744 if (IsResumableFunction(function->shared().kind())) {
745 instance_type = IsAsyncGeneratorFunction(function->shared().kind())
763 if (function->has_instance_prototype()) {
764 prototype = handle(function->instance_prototype(), isolate);
766 prototype = isolate->factory()->NewFunctionPrototype(function);
770 // Finally link initial map and constructor function.
772 JSFunction::SetInitialMap(isolate, function, map, prototype);
915 // Check that |function|'s initial map still in sync with the |constructor|,
916 // otherwise we must create a new initial map for |function|.
925 // suggested by |function|.
927 // Link initial map and constructor function if the new.target is actually a
981 Handle<JSFunction> function = Handle<JSFunction>::cast(new_target);
982 if (FastInitializeDerivedMap(isolate, function, constructor,
984 return handle(function->initial_map(), isolate);
993 Handle<JSFunction> function = Handle<JSFunction>::cast(new_target);
994 if (function->has_prototype_slot()) {
996 EnsureHasInitialMap(function);
997 prototype = handle(function->prototype(), isolate);
1136 Handle<String> JSFunction::GetDebugName(Handle<JSFunction> function) {
1139 // lookup if the DescriptorArray for the |function| still has the
1143 Isolate* isolate = function->GetIsolate();
1144 if (!UseFastFunctionNameLookup(isolate, function->map())) {
1153 GetDataProperty(isolate, function, isolate->factory()->name_string());
1156 return SharedFunctionInfo::DebugName(handle(function->shared(), isolate));
1159 bool JSFunction::SetName(Handle<JSFunction> function, Handle<Name> name,
1161 Isolate* isolate = function->GetIsolate();
1176 function, isolate->factory()->name_string(), function_name,
1188 builder.AppendCStringLiteral("function ");
1197 Handle<String> JSFunction::ToString(Handle<JSFunction> function) {
1198 Isolate* const isolate = function->GetIsolate();
1199 Handle<SharedFunctionInfo> shared_info(function->shared(), isolate);
1201 // Check if {function} should hide its source code.
1206 // Check if we should print {function} as a class.
1208 isolate, function, isolate->factory()->class_positions_symbol());
1220 // Check if we have source code for the {function}.
1225 // If this function was compiled from asm.js, use the recorded offset
1245 // If the function token position isn't valid, return [native code] to
1258 Handle<JSFunction> function) {
1260 for (PrototypeIterator iter(isolate, function, kStartAtReceiver);
1283 // will be a builtin function in the prototype chain that requires