Lines Matching refs:And
2 // Redistribution and use in source and binary forms, with or without
7 // notice, this list of conditions and the following disclaimer.
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
197 // It's saved in the stack and kept live in cp.
213 // Update the write barrier. This clobbers a3 and a0.
318 // Second-level deopt table entries are contiguous and small, so instead
938 // (which gets simplified to an 'and') and subtraction) should be faster, and
939 // this is exactly what GCC and clang emit. Nevertheless, benchmarks seem to
950 __ And(dividend, dividend, Operand(mask));
960 __ And(dividend, dividend, Operand(mask));
1024 // If we care about -0, test if the dividend is <0 and the result is 0.
1055 __ And(at, dividend, Operand(mask));
1177 // If the divisor is positive, things are easy: There can be no deopts and we
1185 // If the divisor is negative, we have to negate and handle edge cases.
1240 // Easy case: We need no dynamic check for the dividend and the flooring
1249 // 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
1440 __ And(result, left, right);
1460 // Both 'left' and 'right' are "used at start" (see LCodeGen::DoShift), so
1515 __ And(at, left, Operand(0x80000000));
1646 __ And(scratch, scratch,
1908 // Test the double value. Zero and NaN are false.
1928 // Test the double value. Zero and NaN are false.
1963 // If we need a map later and have a Smi -> deopt.
1974 __ And(at, at, Operand(1 << Map::kIsUndetectable));
2099 // Compare left and right as doubles and load the
2200 __ And(at, input_reg, kSmiTagMask);
2214 __ And(at, temp, Operand(1 << Map::kIsUndetectable));
2305 __ And(at, scratch, Operand(String::kContainsCachedArrayIndexMask));
2351 // classes and it doesn't have to because you can't access it with natives
2391 // is not a smi, since all other non-spec objects have {null} prototypes and
2406 __ And(object_instance_type, object_instance_type,
2451 // managed by the register allocator and tearing down the frame, it's
2659 // There are two words between the frame pointer and the last argument.
2946 // Result is the frame pointer for the frame if not adapted and for the real
2985 // passed unchanged to builtins and strict-mode functions.
3000 __ And(scratch, scratch, Operand(strict_mode_function_mask | native_mask));
3052 // Push the receiver and use the register to keep the original
3081 // It is safe to use t0, t1 and t2 as scratch registers here given that
3153 // Always initialize new target and number of actual arguments.
3209 __ And(at, exponent, Operand(HeapNumber::kSignMask));
3246 __ And(exponent, exponent, Operand(~HeapNumber::kSignMask));
3330 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
3369 __ And(scratch, result, Operand(HeapNumber::kSignMask));
3375 // value was in ]0.5, 0[ and the result should be -0.
3407 __ And(scratch, scratch, Operand(HeapNumber::kSignMask));
3553 // Drop current frame and load arguments count from arguments adaptor frame.
3584 // It is safe to use t0, t1 and t2 as scratch registers here given that
3995 // Compute address of modified element and store it into key register.
4399 // There was overflow, so bits 30 and 31 of the original integer
4400 // disagree. Try to allocate a heap number in new space and store
4429 // NumberTagI and NumberTagD use the context from the frame, rather than
4487 // NumberTagI and NumberTagD use the context from the frame, rather than
4506 __ And(at, input, Operand(0xc0000000));
4526 __ And(scratch, input, Operand(kHeapObjectTag));
4568 // Convert undefined (and hole) to NaN.
4605 // This 'at' value and scratch1 map value are used for tests in both clauses
4618 // Check for Oddballs. Undefined/False is converted to zero and True to one
4663 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4748 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4783 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4817 __ And(at, scratch, 1 << JSArrayBuffer::WasNeutered::kShift);
4853 __ And(at, scratch, mask);
4857 __ And(scratch, scratch, Operand(mask));
4943 // Do the CompareMap() directly within the Branch() and DeoptimizeIf().
4976 // Both smi and heap number cases are handled.
5245 // The first instruction of JumpIfSmi is an And - it is safe in the delay
5251 __ And(at, at, 1 << Map::kIsUndetectable);
5260 __ And(scratch, scratch,
5275 __ And(at, scratch,
5334 // needed return address), even though the implementation of LAZY and EAGER is
5407 // This will be done explicitly when emitting call and the safepoint in
5415 // properly registered for deoptimization and records the assembler's PC
5527 __ And(scratch, index, Operand(Smi::FromInt(1)));
