Lines Matching defs:to
31 // x0: number of arguments to the constructor function
151 // Try to convert with a FPU convert instruction. This handles all
159 // If we reach here we need to manually convert the input to an int32.
191 // Shift the mantissa bits in the correct place. We know that we have to shift
219 // Test for NaN. Sadly, we can't just compare to factory::nan_value(),
228 // Call runtime on identical symbols since we need to throw a TypeError.
236 // we need to throw a TypeError. Smis have already been ruled out.
250 // Call runtime on identical symbols since we need to throw a TypeError.
258 // since we need to throw a TypeError. Smis and heap numbers have
263 // Normally here we fall through to return_equal, but undefined is
297 // Left and right are identical pointers to a heap number object. Return
299 // the number to itself will set the overflow flag iff the number is NaN.
439 // Fall through to both_loaded_as_doubles.
444 // Fast negative check for internalized-to-internalized equality.
483 // equal, since they are different objects and an object is not equal to
509 // hydrogen doesn't care, the stub doesn't have to care either.
538 // or goes to slow. Only falls through if the objects were not identical.
549 // 2) Branch to the slow case.
550 // 3) Fall through to both_loaded_as_doubles.
559 // The arguments have been converted to doubles and stored in rhs_d and
603 // Check for heap number comparison. Branch to earlier double comparison code
604 // if they are heap numbers, otherwise, branch to internalized string check.
609 // If maps aren't equal, lhs_ and rhs_ are not heap numbers. Branch to flat
613 // Both lhs_ and rhs_ are heap numbers. Load them and branch to the double
624 // Otherwise branches to the string case or not both strings case.
646 // Never fall through to here.
654 // Figure out which native to call and setup the arguments.
683 // We don't allow a GC during a store buffer overflow so there is no need to
684 // store the registers in any particular way, but we do have to store and
724 // Restore lr with the value it had before the call to this stub (the value
768 // Bail out to runtime.
786 // base_tagged is a SMI, so untag it and convert it to a double.
830 // Given that exponent is known to be either 0.5 or -0.5, the following
831 // special cases could apply (according to ECMA-262 15.8.2.13):
845 // Add +0 to base. This has no effect other than turning -0 into +0.
918 // Repeatedly multiply to calculate the power.
953 // ECMA-262 only requires Math.pow to return an 'implementation-dependent
955 // to calculate the subnormal value 2^-1074. This method of calculating
956 // negative powers doesn't work because 2^1074 overflows to infinity. To
963 // Bail out to runtime code.
1028 // nothing to do here.
1036 // when the C++ code returns to the stub because LR holds the return address
1038 // returning to dead code.
1040 // find any comment to confirm this, and I don't hit any crashes whatever
1056 // CEntryStub, so until this stub has been generated, we have to use a
1069 // x11: argv (pointer to first argument)
1081 // first argument to the target function and arg[0] is the last.
1087 // callee-saved registers so we can retry the call without having to reload
1097 // Derive argv from the stack pointer so that it points to the first argument
1107 // Enter the exit frame. Reserve three slots to preserve x21-x23 callee-saved
1158 // untouched, and the stub either throws an exception by jumping to one of
1163 // Prepare AAPCS64 arguments to pass to the builtin.
1173 // Verify that the slot below fp[kSPOffset]-8 points to the return location
1234 // Ask the runtime for help to determine the handler. This will set x0 to
1248 // (except for the return address slot). However, we don't need to initialize
1261 // If the handler is a JS frame, restore the context to the frame. Note that
1262 // the context will be set to (cp == 0) for non-JS frames.
1268 // Compute the handler entry address and jump to it.
1302 // We must not write to jssp until after the PushCalleeSavedRegisters()
1310 // according to AAPCS64. However, we only set default-NaN mode and this will
1321 int64_t bad_frame_pointer = -1L; // Bad frame pointer to fail if it is used.
1356 // Jump to a faked try block that does the invoke, with a faked catch
1363 // checking for constant pool emission, but we do not want to depend on
1371 // fp will be invalid because the PushTryHandler below sets it to 0 to
1384 // returns control to the code after the B(&invoke) above, which
1385 // restores all callee-saved registers (including cp and fp) to their
1386 // saved values before returning a failure to C.
1395 // Notice that we cannot store a reference to the trampoline code directly in
1421 // The stack pointer points to the top of the entry frame pushed on entry from
1443 // Reset the stack to the callee saved registers.
1533 // function, otherwise we have to miss to the runtime and throw an exception.
1574 // Assume true, and change to false if not found.
1585 // Check if the object needs to be access checked.
1626 // to the frame pointer.
1652 // to get negative check for free: branch if key < 0 or key >= arg_count.
1662 // Slow case: handle non-smi or out-of-bounds access to arguments by calling
1706 // Returns pointer to result object in x0.
1736 // x3 recv_arg pointer to receiver arguments
1763 // x0 alloc_obj pointer to allocated objects: param map, backing
1767 // x3 recv_arg pointer to receiver arguments
1770 // x10 size size of objects to allocate (uninit)
1784 // If there are no mapped parameters, set the running size total to zero.
1794 // Do the allocation of all three objects in one go. Assign this to x0, as it
1795 // will be returned to the caller.
1801 // x0 alloc_obj pointer to allocated objects (param map, backing
1805 // x3 recv_arg pointer to receiver arguments
1808 // x11 sloppy_args_map offset to args (or aliased args) map (uninit)
1845 // it will point to the backing store.
1847 // x0 alloc_obj pointer to allocated objects (param map, backing
1851 // x3 recv_arg pointer to receiver arguments
1853 // x5 elements pointer to parameter map or backing store (uninit)
1854 // x6 backing_store pointer to backing store (uninit)
1884 // We need to fill in mapped_parameter_count slots. Then index the context,
1889 // The mapped parameter thus needs to get indices:
1894 // We loop from right to left.
1896 // x0 alloc_obj pointer to allocated objects (param map, backing
1900 // x3 recv_arg pointer to receiver arguments
1902 // x5 elements pointer to parameter map or backing store (uninit)
1903 // x6 backing_store pointer to backing store (uninit)
1942 // x0 alloc_obj pointer to allocated objects (param map, backing
1946 // x3 recv_arg pointer to receiver arguments
1948 // x6 backing_store pointer to backing store (uninit)
1969 // Do the runtime call to allocate the arguments object.
2001 // Returns pointer to result object in x0.
2025 // x2 param_count_smi number of parameters passed to function (smi)
2026 // x3 params pointer to parameters
2028 // x13 param_count number of parameters passed to function
2047 // Do the allocation of both objects in one go. Assign this to x0, as it will
2048 // be returned to the caller.
2058 // x0 alloc_obj pointer to allocated objects: parameter array and
2061 // x2 param_count_smi number of parameters passed to function (smi)
2062 // x3 params pointer to parameters
2063 // x4 strict_args_map offset to arguments map
2064 // x13 param_count number of parameters passed to function
2089 // x0 alloc_obj pointer to allocated objects: parameter array and
2092 // x2 param_count_smi number of parameters passed to function (smi)
2093 // x3 params pointer to parameters
2094 // x4 array pointer to array slot (uninit)
2095 // x5 elements pointer to elements array of alloc_obj
2096 // x13 param_count number of parameters passed to function
2101 // Set up pointer to first array slot.
2106 // Pre-decrement in order to skip receiver.
2117 // Do the runtime call to allocate the arguments object.
2129 // Returns pointer to result object in x0.
2154 // x2 param_count_smi number of parameters passed to function (smi)
2155 // x3 params pointer to parameters
2157 // x13 param_count number of parameters passed to function
2193 // offset to the underlying string
2206 // to the native RegExp code, as this code is called using the normal
2209 // these registers are safe to use after the call.
2213 // x21 last_match_info_elements info relative to the last match
2264 // ones due to capturing parentheses. A capture takes 2 registers.
2288 // Handle subject string according to its encoding and representation:
2289 // (1) Sequential string? If yes, go to (5).
2290 // (2) Anything but sequential or cons? If yes, go to (6).
2293 // (4) Is subject external? If yes, go to (7).
2294 // (5) Sequential string. Load regexp code according to encoding.
2299 // (6) Not a long external string? If yes, go to (8).
2301 // Go to (5).
2302 // (8) Short external string or not a string? If yes, bail out to runtime.
2303 // (9) Sliced string. Replace subject with parent. Go to (4).
2311 // (1) Sequential string? If yes, go to (5).
2328 __ Cbz(string_representation, &seq_string); // Go to (5).
2330 // (2) Anything but sequential or cons? If yes, go to (6).
2336 __ B(ge, ¬_seq_nor_cons); // Go to (6).
2344 // (4) Is subject external? If yes, go to (7).
2355 &external_string); // Go to (7).
2357 // (5) Sequential string. Load regexp code according to encoding.
2368 // Argument 2 (x1): We need to load argument 2 (the previous index) into x1
2379 // of kPointerSize to reach the latter.
2406 // We have 9 arguments to pass to the regexp code, therefore we have to pass
2424 // frame. Therefore we have to use fp, which points exactly to two pointer
2439 // Convert string positions from characters to bytes.
2465 // Argument 6 (x5): Set the number of capture registers to zero to force
2466 // global regexps to behave as non-global. This stub is not used for global
2541 // Use x10 as the subject string in order to only need
2573 // iterates down to zero (inclusive).
2627 // (6) Not a long external string? If yes, go to (8).
2630 __ B(ne, ¬_long_external); // Go to (8).
2650 __ B(&seq_string); // Go to (5).
2652 // (8) If this is a short external string or not a string, bail out to
2664 __ B(&check_underlying); // Go to (4).
2675 // Number-of-arguments register must be smi-tagged to call out.
2697 // argc : number of arguments to the construct function
2698 // function : the function to call
2719 // harmless to read at this position in a symbol (see static asserts in
2731 // If the weak cell is cleared, we have a new chance to become monomorphic.
2736 // If we came here, we need to see if we are the array function.
2762 // An uninitialized cache is patched with the function or sentinel to
2790 // x1 : the function to call
2819 // Tail call to the function-specific construct stub (still in the caller
2888 // or an AllocationSite, but the memory is safe to examine.
2889 // AllocationSite::kTransitionInfoOffset - contains a Smi or pointer to
2893 // computed, meaning that it can't appear to be a pointer. If the low bit is
2895 // to be a pointer.
2935 // The following cases attempt to handle MISS cases without going to the
2944 // to handle it here. More complex cases are dealt with in the runtime.
2971 // Make sure the function belongs to the same native context.
3018 // Move result to edi and exit the internal frame.
3063 // If index is a heap number, try converting it to an integer.
3081 // have a chance to overwrite it.
3096 // Otherwise, return to the fast path.
3101 // is too complex (e.g., when the string needs to be flattened).
3177 // Bail out (to 'miss') unless both x0 and x1 are smis.
3184 // Untag before subtracting to avoid handling overflow.
3322 // To avoid a miss, each instance type should be either SYMBOL_TYPE or it
3516 // Tail-call to the new stub.
3527 // jssp[0]: substring "to" offset
3529 // jssp[16]: pointer to string object
3534 // both "from" and "to" are smis, and
3535 // 0 <= from <= to <= string.length (in debug mode.)
3542 Register to = x0;
3551 __ Peek(to, kToOffset);
3554 // Check that both from and to are smis. If not, jump to runtime.
3555 __ JumpIfEitherNotSmi(from, to, &runtime);
3557 __ SmiUntag(to);
3559 // Calculate difference between from and to. If to < from, branch to runtime.
3560 __ Subs(result_length, to, from);
3590 // x0 to substring end character offset
3592 // x10 input_string pointer to input string object
3593 // x10 unpacked_string pointer to unpacked string object
3606 // Test for string types, and branch/fall through to appropriate unpacking
3633 // Now control must go to &underlying_unpacked. Since the no code is generated
3638 // alias, so there's nothing to do here.
3641 // x0 result_string pointer to result string object (uninit)
3643 // x10 unpacked_string pointer to unpacked string object
3657 // string's encoding is wrong because we always have to recheck encoding of
3658 // the newly created string's parent anyway due to externalized strings.
3681 // x0 result_string pointer to result string object (uninit)
3683 // x10 unpacked_string pointer to unpacked string object
3686 // x13 unpacked_char0 pointer to first char of unpacked string (uninit)
3687 // x13 substring_char0 pointer to first char of substring (uninit)
3688 // x14 result_char0 pointer to first char of result (uninit)
3704 // unpacked_char0 points to the first character of the underlying string.
3721 // Locate first character of substring to copy.
3736 // Locate first character of substring to copy.
3871 // smis, and don't need to be untagged.
3921 // Compare lengths - strings up to min-length are equal.
3946 // Change index to run from -length to -1 by adding length to string
4035 // but we need to save them before using them.
4109 // If the object is not black we don't have to inform the incremental marker.
4165 // Fall through when we need to inform the incremental marker.
4175 // Initially the stub is expected to be in STORE_BUFFER_ONLY mode, so 2 nops
4210 // Return to IC Miss stub, continuation still on stack.
4286 // use cached_map (scratch1) to look in the weak map values.
4347 // Try to quickly handle the monomorphic case without knowing for sure
4348 // if we have a weak cell in feedback. We do know it's safe to look
4400 // Try to quickly handle the monomorphic case without knowing for sure
4401 // if we have a weak cell in feedback. We do know it's safe to look
4483 // Try to quickly handle the monomorphic case without knowing for sure
4484 // if we have a weak cell in feedback. We do know it's safe to look
4547 // use cached_map (scratch1) to look in the weak map values.
4602 // Try to quickly handle the monomorphic case without knowing for sure
4603 // if we have a weak cell in feedback. We do know it's safe to look
4688 // Under the simulator we need to indirect the entry hook through a trampoline
4699 // Grab its location for the second argument to the hook.
4722 // Put return address on the stack (accessible to GC through exit frame pc).
4726 // Return to calling code.
4744 // Branch to the stub.
4750 // Jump to the 'done' label if a property with the given name is found.
4751 // Jump to the 'miss' label otherwise.
4753 // If lookup was successful 'scratch2' will be equal to elements + 4 * index.
4777 // Add the probe offset (i + i * i) left shifted to avoid right shifting
4791 // Check if the key is identical to the name.
4801 // Call the complete stub to scan the whole dictionary.
4842 // If names of slots in range from 1 to kProbes - 1 for the hash value are
4843 // not equal to the name and kProbes-th slot is not used (its name is the
4848 // scratch0 points to properties hash.
4885 spill_list.Remove(scratch0); // Scratch registers don't need to be preserved.
4893 // Move stub return value to scratch0. Note that scratch0 is not included in
4904 // This stub overrides SometimesSetsUpAFrame() to return false. That means
4935 // Add the probe offset (i + i * i) left shifted to avoid right shifting
5004 // TODO(jbramley): Is this the best way to handle this? Can we make the
5021 // TODO(jbramley): If this needs to be a special case, make it a proper template
5068 // We are going to create a holey array, but our kind is non-holey.
5081 // restricted to a portion of the field; upper bits need to be left alone.
5271 // We might need to create a holey array; look at the first argument.
5352 // Go up the context chain to the script context.
5367 // Fallback to runtime.
5392 // Go up the context chain to the script context.
5485 // Fall back to the runtime.
5495 // The number of register that CallApiFunctionAndReturn will need to save on
5496 // the stack. The space for these registers need to be allocated in the
5508 // 'stack_space' is the space to be unwound on exit (includes the call JS
5541 // Save the callee-save registers we are going to use.
5550 // We will need to restore the HandleScope after the call to the API function,
5573 // Native call returns to the DirectCEntry stub which redirects to the
