Lines Matching refs:And
173 // It's saved in the stack and kept live in cp.
189 // Update the write barrier. This clobbers a3 and a0.
291 // Second-level deopt table entries are contiguous and small, so instead
293 // address and add an immediate offset.
927 // (which gets simplified to an 'and') and subtraction) should be faster, and
928 // this is exactly what GCC and clang emit. Nevertheless, benchmarks seem to
939 __ And(dividend, dividend, Operand(mask));
949 __ And(dividend, dividend, Operand(mask));
1013 // If we care about -0, test if the dividend is <0 and the result is 0.
1045 __ And(at, dividend, Operand(mask));
1173 // If the divisor is positive, things are easy: There can be no deopts and we
1181 // If the divisor is negative, we have to negate and handle edge cases.
1234 // Easy case: We need no dynamic check for the dividend and the flooring
1243 // In the general case we may need to adjust before and after the truncating
1329 // If constant is negative and left is null, the result should be -0.
1346 // If left is strictly negative and the constant is null, the
1358 // Multiplying by powers of two and powers of two plus or minus
1431 // If constant is negative and left is null, the result should be -0.
1448 // If left is strictly negative and the constant is null, the
1460 // Multiplying by powers of two and powers of two plus or minus
1534 __ And(result, left, right);
1554 // Both 'left' and 'right' are "used at start" (see LCodeGen::DoShift), so
1611 __ And(at, left, Operand(0x80000000));
1744 __ And(scratch, scratch,
2027 // Test the double value. Zero and NaN are false.
2047 // Test the double value. Zero and NaN are false.
2082 // If we need a map later and have a Smi -> deopt.
2093 __ And(at, at, Operand(1 << Map::kIsUndetectable));
2218 // Compare left and right as doubles and load the
2319 __ And(at, input_reg, kSmiTagMask);
2333 __ And(at, temp, Operand(1 << Map::kIsUndetectable));
2424 __ And(at, scratch, Operand(String::kContainsCachedArrayIndexMask));
2472 // classes and it doesn't have to because you can't access it with natives
2512 // is not a smi, since all other non-spec objects have {null} prototypes and
2527 __ And(object_instance_type, object_instance_type,
2572 // managed by the register allocator and tearing down the frame, it's
2795 // There are two words between the frame pointer and the last argument.
3126 // Result is the frame pointer for the frame if not adapted and for the real
3165 // passed unchanged to builtins and strict-mode functions.
3180 __ And(at, at, Operand(strict_mode_function_mask));
3184 __ And(at, at, Operand(native_mask));
3236 // Push the receiver and use the register to keep the original
3265 // It is safe to use t0, t1 and t2 as scratch registers here given that
3337 // Always initialize new target and number of actual arguments.
3393 __ And(at, exponent, Operand(HeapNumber::kSignMask));
3430 __ And(exponent, exponent, Operand(~HeapNumber::kSignMask));
3530 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
3569 __ And(scratch, result, Operand(HeapNumber::kSignMask));
3575 // value was in ]0.5, 0[ and the result should be -0.
3610 __ And(scratch, scratch, Operand(HeapNumber::kSignMask));
3756 // Drop current frame and load arguments count from arguments adaptor frame.
3784 // It is safe to use t0, t1 and t2 as scratch registers here given that
4226 // Compute address of modified element and store it into key register.
4603 // There was overflow, so bits 30 and 31 of the original integer
4604 // disagree. Try to allocate a heap number in new space and store
4633 // NumberTagI and NumberTagD use the context from the frame, rather than
4691 // NumberTagI and NumberTagD use the context from the frame, rather than
4710 __ And(at, input, Operand(0x80000000));
4730 __ And(scratch, input, Operand(kHeapObjectTag));
4772 // Convert undefined (and hole) to NaN.
4809 // This 'at' value and scratch1 map value are used for tests in both clauses
4822 // Check for Oddballs. Undefined/False is converted to zero and True to one
4867 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4952 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4987 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
5020 __ And(at, scratch, 1 << JSArrayBuffer::WasNeutered::kShift);
5056 __ And(at, scratch, mask);
5060 __ And(scratch, scratch, Operand(mask));
5146 // Do the CompareMap() directly within the Branch() and DeoptimizeIf().
5179 // Both smi and heap number cases are handled.
5450 // The first instruction of JumpIfSmi is an And - it is safe in the delay
5456 __ And(at, at, 1 << Map::kIsUndetectable);
5465 __ And(scratch, scratch,
5480 __ And(at, scratch,
5540 // needed return address), even though the implementation of LAZY and EAGER is
5613 // This will be done explicitly when emitting call and the safepoint in
5621 // properly registered for deoptimization and records the assembler's PC
5733 __ And(scratch, index, Operand(Smi::FromInt(1)));
