Lines Matching refs:And
145 // Push and pop all registers that can hold pointers.
209 // Clobbers object, dst, value, and ra, if (ra_status == kRAHasBeenSaved)
239 And(t8, dst, Operand((1 << kPointerSizeLog2) - 1));
265 // Clobbers object, dst, map, and ra, if (ra_status == kRAHasBeenSaved)
295 // only set during incremental collection, and then it's also guaranteed that
307 And(at, dst, Operand((1 << kPointerSizeLog2) - 1));
339 // Clobbers object, address, value, and ra, if (ra_status == kRAHasBeenSaved)
366 // catch stores of smis and stores into the young generation.
436 // catch stores of Smis and stores into young gen.
447 // Save caller-saved registers. js_function and code_entry are in the
492 // Store pointer to buffer and increment buffer top.
499 And(t8, scratch, Operand(StoreBuffer::kStoreBufferMask));
557 // Read the first word and compare to the native_context_map.
602 // ComputeIntegerHash in utils.h and KeyedLoadGenericStub in
639 And(reg0, reg0, Operand(0x3fffffff));
666 // reg0 - holds the untagged key on entry and holds the hash once computed.
683 // Use reg2 for index calculations and keep the hash intact in reg0.
713 And(at, reg1, Operand(Smi::FromInt(PropertyDetails::TypeField::kMask)));
716 // Get the value at the masked, scaled index and return.
1174 void MacroAssembler::And(Register rd, Register rs, const Operand& rt) {
1554 // Load consequent 32-bit word pair in 64-bit reg. and put first word in low
2153 // and add 2^31 to rs.
2183 // and add 2^31 to rs.
2221 // and add 2^63 to rs.
2269 // and add 2^63 to rs.
2627 // Left and right hand side are equal, check for -0 vs. +0.
2657 // Left and right hand side are equal, check for -0 vs. +0.
2851 And(except_flag, except_flag, Operand(except_mask));
2864 // Clear cumulative exception flags and save the FCSR.
2870 // Retrieve and restore the FCSR.
2873 // Check for overflow and NaNs.
2874 And(scratch,
2948 And(dst, dst, Operand((1 << num_least_bits) - 1));
2956 And(dst, src, Operand((1 << num_least_bits) - 1));
3820 // overflow cases, so we keep slt and add an intermediate third instruction.
4147 // Buffer growth (and relocation) must be blocked for internal references
4148 // until associated instructions are emitted and available to be patched.
4167 // Buffer growth (and relocation) must be blocked for internal references
4168 // until associated instructions are emitted and available to be patched.
4188 // Both Drop and Ret need to be conditional.
4338 // Check relative positions of allocation top and limit addresses.
4350 // Set up allocation top address and allocation limit registers.
4358 // Load allocation top into result and allocation limit into alloc_limit.
4371 // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
4376 And(at, result, Operand(kDoubleAlignmentMask));
4380 // Calculate new top and bail out if new space is exhausted. Use result
4409 // |object_size| and |result_end| may overlap, other registers must not.
4413 // Check relative positions of allocation top and limit addresses.
4424 // Set up allocation top address and object size registers.
4431 // Load allocation top into result and allocation limit into alloc_limit.
4444 // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
4449 And(at, result, Operand(kDoubleAlignmentMask));
4453 // Calculate new top and bail out if new space is exhausted. Use result
4466 And(at, result_end, Operand(kObjectAlignmentMask));
4499 // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
4504 And(at, result, Operand(kDoubleAlignmentMask));
4508 // Calculate new top and write it back.
4518 // |object_size| and |result_end| may overlap, other registers must not.
4525 // Set up allocation top address and object size registers.
4530 // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
4535 And(at, result, Operand(kDoubleAlignmentMask));
4539 // Calculate new top and write it back
4548 And(at, result_end, Operand(kObjectAlignmentMask));
4567 And(scratch1, scratch1, Operand(~kObjectAlignmentMask));
4573 // Set the map, length and hash field.
4592 And(scratch1, scratch1, Operand(~kObjectAlignmentMask));
4598 // Set the map, length and hash field.
4664 And(at, reg, Operand(kIsNotStringMask | kIsNotInternalizedMask));
4672 // Allocates a heap number or jumps to the label if the young space is full and
4680 // Allocate an object in the heap for the heap number and tag it as a heap
4738 And(scratch, src, kPointerSize - 1);
4750 And(scratch, src, kPointerSize - 1);
4893 // Untag and transfer.
4931 And(scratch1, scratch1,
4934 And(scratch2, scratch2, Operand(kSingleNaNMask));
4966 And(scratch1, scratch1, at);
4968 And(scratch2, scratch2, Operand(kDoubleNaNMask));
5168 // Restore caller's frame pointer and return address now as they will be
5174 // callee arguments corruption (source and destination areas could overlap).
5176 // Both src_reg and dst_reg are pointing to the word after the one to copy,
5203 // Check whether the expected and actual arguments count match. If not,
5210 // up actual and expected registers according to the contract if values are
5225 // like we have a match between expected and actual number of
5381 // Get the function and setup the context.
5405 And(scratch, scratch, Operand(kIsNotStringMask));
5443 // If the prototype or initial map is the hole, don't return it and
5502 // cached in the hash field and the number of bits reserved for it does not
5521 // Remove smi tag and convert to double.
5529 // Check for heap number and load double value from it.
5540 And(exponent, exponent, mask_reg);
5901 // should remove this need and make the runtime routine entry code
6127 // The following three instructions must remain together and unmodified
6133 // Load the stub address to t9 and call it,
6215 // Save registers and reserve room for saved entry sp and code object.
6232 // Save the frame pointer and the context in top.
6251 // Reserve place for the return address, stack space and an optional slot
6253 // returned) and align the frame preparing for calling the runtime function.
6258 And(sp, sp, Operand(-frame_alignment)); // Align stack.
6287 // Restore current context from top and clear it in debug mode.
6297 // Pop the arguments, restore registers, and return.
6427 // Returns 2 values: the Smi and a scaled version of the int within the Smi.
6443 // Returns 2 values: the untagged Smi (int32) and scaled version of that int.
6453 // Need both the int and the scaled in, so use two instructions.
6656 // Test that both first and second are sequential one-byte strings.
6675 And(scratch1, first, Operand(second));
6704 And(scratch, type, Operand(kFlatOneByteStringMask));
6766 // Make stack end at alignment and make room for num_arguments - 4 words
6767 // and the original value of sp.
6771 And(sp, sp, Operand(-frame_alignment));
6829 And(at, sp, Operand(frame_alignment_mask));
6870 And(scratch, object, Operand(~Page::kPageAlignmentMask));
6872 And(scratch, scratch, Operand(mask));
6900 And(t8, t9, Operand(mask_scratch));
6904 And(t8, t9, Operand(mask_scratch));
6919 And(bitmap_reg, addr_reg, Operand(~Page::kPageAlignmentMask));
6941 // Since both black and grey have a 1 in the first position and white does
6950 And(t8, mask_scratch, load_scratch);
6970 And(dst, dst, Operand(Map::EnumLengthBits::kMask));
7066 // In 0-255 range, round and truncate.
7091 And(scratch_reg, scratch_reg, Operand(~Page::kPageAlignmentMask));
7094 // object sits on the page boundary as no memento can follow and we cannot
7098 And(scratch_reg, scratch_reg, Operand(~Page::kPageAlignmentMask));
