Lines Matching refs:And
122 // These two are *different* from the architectural codes al and nv.
127 // cbz and cbnz
129 // tbz and tbnz
174 inline void And(const Register& rd,
204 // Add and sub macros.
265 // instruction. Returns true for success, and updates the contents of dst.
269 // Move an immediate into register dst, and return an Operand object for use
438 // Provide explicit double and float interfaces for FP immediate moves, rather
441 // signalling NaNs to quiet NaNs when converting between float and double.
587 // to be 'NoReg', and are thus not pushed or popped.
592 // It is valid to push the same register more than once, and there is no
599 // must be aligned to 16 bytes on entry and the total size of the specified
603 // Push (and derived methods) will still modify the system stack pointer in
607 // Other than the registers passed into Pop, the stack pointer and (possibly)
623 // Alternative forms of Push and Pop, taking a RegList or CPURegList that
626 // and pop instructions).
629 // parameter. Only kXRegSizeInBits, kWRegSizeInBits, kDRegSizeInBits and
677 // Aliases of Push and Pop, required for V8 compatibility.
690 // Unlike the other Push and Pop macros, PushPopQueue can handle mixed sets of
691 // register sizes and types.
724 // Peek at a value on the stack, and put it in 'dst'. The offset is in bytes.
730 // Poke 'src1' and 'src2' onto the stack. The values written will be adjacent
737 // Peek at two values on the stack, and put them in 'dst1' and 'dst2'. The
751 // must be aligned to 16 bytes and the size claimed or dropped must be a
763 // Variants of Claim and Drop, where the 'count' parameter is a SMI held in a
770 // Compare a register with an operand, and branch to label depending on the
777 // Test the bits of register defined by bit_pattern, and branch if ANY of
783 // Test the bits of register defined by bit_pattern, and branch if ALL of
825 // Higher-numbered registers are pushed before lower-numbered registers, and
827 // Floating-point registers are pushed before general-purpose registers, and
834 // SetStackPointer) is the system stack pointer (csp), and is aligned to
840 // Higher-numbered registers are popped after lower-numbered registers, and
842 // Floating-point registers are popped after general-purpose registers, and
846 // SetStackPointer) is the system stack pointer (csp), and is aligned to
861 // Align csp for a frame, as per ActivationFrameAlignment, and make it the
909 // Load both TrueValue and FalseValue roots.
952 // ---- SMI and Number Utilities ----
965 // Tag and push in one step.
1054 // are represented as 0 and handled as a success.
1069 // are represented as 0 and handled as a success.
1091 // clobbered. On exit src and dst will point to the place just after where the
1092 // last byte was read or written and length will be zero. Hint may be used to
1109 // Check if instance type is sequential one-byte string and jump to label if
1114 // Checks if both instance types are sequential one-byte strings and jumps to
1120 // Checks if both instance types are sequential one-byte strings and jumps to
1164 // garbage collection, since that might move the code and invalidate the
1205 // Removes current frame and its arguments from the stack preserving
1206 // the arguments and a return address pushed to the stack for the next call.
1207 // Both |callee_args_count| and |caller_args_count_reg| do not include
1257 // execution falls through, and the sign of the result can be used to
1274 // the JS bitwise operations. See ECMA-262 9.5: ToInt32. 'result' and 'input'
1280 // and brought into the range -2^31 .. +2^31 - 1. 'result' and 'input' must be
1324 // Push a new stack handler and link into stack handler chain.
1340 // In this case, the result and scratch registers may still be clobbered.
1387 // space is full and a scavenge is needed.
1399 // Allocate and initialize a JSValue wrapper with the specified {constructor}
1400 // and {value}.
1409 // |temp| holds |result|'s map when done, and |temp2| its instance type.
1418 // sets the flags and leaves the object type in the type_reg register.
1419 // It leaves the map in the map register (unless the type_reg and map register
1429 // Compare object type for heap object, and branch if equal (or not.)
1431 // the given type. This both sets the flags and leaves the object type in
1433 // type_reg and map register are the same register). It leaves the heap
1451 // sets the flags and leaves the object type in the type_reg register.
1469 // Check if the map of an object is equal to a specified map and branch to
1486 // As above, but the map of the object is already loaded into obj_map, and is
1493 // Check if the map of an object is equal to a specified weak map and branch
1500 // Compare the given value and the value of weak cell.
1509 // Test the bitfield of the heap object map with mask and set the condition
1513 // Load the elements kind field from a map, and return it in the result
1517 // Load the value from the root list and push it onto the stack.
1523 // Compare the object in a register to a value and jump if they are equal.
1528 // Compare the object in a register to a value and jump if they are not equal.
1533 // Load and check the instance type of an object for being a unique name.
1535 // The object and type arguments can be the same register; in that case it
1537 and jump on fail otherwise.
1540 // Load and check the instance type of an object for being a string.
1542 // The object and type arguments can be the same register; in that case it
1549 // Compare the contents of a register with an operand, and branch to true,
1558 // Test the bits of register defined by bit_pattern, and branch to
1571 // and HeapObject elements. Jump to the specified label if it does not.
1671 // The stack pointer has to switch between csp and jssp when setting up and
1677 // Generates function and stub prologue code.
1684 // The stack pointer must be jssp on entry, and will be set to csp by this
1686 // registers modified by this function are the provided scratch register, and
1693 // Set up a stack frame and registers as follows:
1736 // unchanged. Dividend and result must be different.
1766 // Push and pop the registers that can hold pointers, as defined by the
1798 // Check if object is in new space and jump accordingly.
1812 // stored. value and scratch registers are clobbered by the operation.
1864 // has been written. |value| is the object being stored. The value and
1935 // Print a message to stderr and abort execution.
1952 // Load the initial map from the global function. The registers function and
1967 // (such as %e, %f or %g) are FPRegisters, and that arguments for integer
1981 // a problem, preserve the important registers manually and then call
1982 // PrintfNoPreserve. Callee-saved registers are not used by Printf, and are
2006 // recently run) and continues. A young function is therefore one which has a
2007 // normal frame setup sequence, and an old function has a code age sequence
2012 // done by to Code::PatchPlatformCodeAge and EmitCodeAgeSequence.
2023 // EmitFrameSetupForCodeAgePatching, and represents an old function.
2052 // The actual Push and Pop implementations. These don't generate any code
2057 // Note that size is per register, and is specified in bytes.
2067 // arguments and stack (csp) must be prepared by the caller as for a normal
2071 // proper PCS registers (and in calling order). The argument registers can
2075 // Helper for implementing JumpIfNotInNewSpace and JumpIfInNewSpace.
2082 // It supports both 32-bit and 64-bit integers depending whether 'as_int'
2085 // This does not distinguish between +0 and -0, so if this distinction is
2155 // Use this scope when you need a one-to-one mapping bewteen methods and
2156 // instructions. This scope prevents the MacroAssembler from being called and
2203 // MacroAssembler's TmpList() (and FPTmpList()) is used as a pool of scratch
2204 // registers. These registers can be allocated on demand, and will be returned
2260 // Encode and decode information about patchable inline SMI checks.
2278 // SMI checks. The caller may specify 'reg' as NoReg and an unbound 'site' to
