Lines Matching defs:function
1061 // Called from JavaScript; parameters are on stack as if calling JS function
1063 // a1: pointer to builtin function
1089 // s2: pointer to builtin function (C callee-saved)
1128 masm->mov(t9, s2); // Function pointer to t9 to conform to ABI for PIC.
1231 // a1: function
1271 // a1: function
1278 // function slot | entry frame
1331 // Invoke the function by calling through JS entry trampoline builtin.
1337 // a1: function
1428 Register const function = a0; // Function (rhs).
1430 Register const function_map = a3; // Map of {function}.
1431 Register const function_prototype = t0; // Prototype of {function}.
1435 DCHECK(function.is(InstanceOfDescriptor::RightRegister()));
1441 // Lookup the {function} and the {object} map in the global instanceof cache.
1447 __ Branch(&fast_case, ne, function, Operand(at));
1453 // If {object} is a smi we can safely return false if {function} is a JS
1454 // function, otherwise we have to miss to the runtime and throw an exception.
1456 __ JumpIfSmi(function, &slow_case);
1457 __ GetObjectType(function, function_map, scratch);
1462 // Fast-case: The {function} must be a valid JSFunction.
1464 __ JumpIfSmi(function, &slow_case);
1465 __ GetObjectType(function, function_map, scratch);
1468 // Ensure that {function} has an instance prototype.
1473 // Get the "prototype" (or initial map) of the {function}.
1475 FieldMemOperand(function, JSFunction::kPrototypeOrInitialMapOffset));
1478 // Resolve the prototype if the {function} has an initial map. Afterwards the
1480 // hole value, which means that no instances of the {function} were created so
1491 // {function}. The cached answer will be set when it is known below.
1492 __ StoreRoot(function, Heap::kInstanceofCacheFunctionRootIndex);
1495 // Loop through the prototype chain looking for the {function} prototype.
1536 // Slow-case: Call the %InstanceOf runtime function.
1538 __ Push(object, function);
1615 // a1 : function
1619 DCHECK(a1.is(ArgumentsAccessNewDescriptor::function()));
1643 // a1 : function
1646 // Registers used over whole function:
1650 DCHECK(a1.is(ArgumentsAccessNewDescriptor::function()));
1880 // a1 : function
1884 DCHECK(a1.is(ArgumentsAccessNewDescriptor::function()));
2014 // Allocation of registers for this function. These are in callee save
2427 // a0 : number of arguments to the construct function
2430 // a1 : the function to call
2449 // Cache the called function in a feedback vector slot. Cache states
2452 // a0 : number of arguments to the construct function
2453 // a1 : the function to call
2469 // function without changing the state.
2488 // If we came here, we need to see if we are the array function.
2489 // If we didn't have a matching function, and we didn't find the megamorph
2490 // sentinel, then we have in the slot either some other function or an
2495 // Make sure the function is the Array() function
2515 // An uninitialized cache is patched with the function.
2517 // Make sure the function is the Array() function.
2521 // The target function is the Array constructor,
2537 // a1 : the function to call
2542 // Check that the function is not a smi.
2544 // Check that the function is a JSFunction.
2563 // Pass function as new target.
2566 // Tail call to the function-specific construct stub (still in the caller
2580 // a1 - function
2589 // Increment the call count for monomorphic function calls.
2604 // a1 - function
2637 // Increment the call count for monomorphic function calls.
2695 // Goto miss case if we do not have a function.
2699 // Make sure the function is not the Array() function, which requires special
2704 // Make sure the function belongs to the same native context.
2716 // Store the function. Use a stub since we need a frame for allocation.
2719 // a1 - function
2742 // Push the receiver and the function and feedback info.
2806 // Consumed by runtime conversion function:
3820 __ Call(t9); // Call the C++ function.
4788 // Compute the function's address for the first argument.
4809 // trampoline function at a known address.
4818 // Call C function through t9 to conform ABI for PIC.
5014 // Initial map for the builtin Array function should be a map.
5028 // Enter the context of the Array function.
5109 // Initial map for the builtin Array function should be a map.
5297 // Calls an API function. Allocates HandleScope, extracts returned value
5402 // Check if the function scheduled an exception.
