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
107 // Compute the function map in the current global context and set that
180 // Remove the on-stack argument and return.
242 // Remove the on-stack argument and return.
270 // Allocate both the JS array and the elements array in one big
288 // Get hold of the elements array of the boilerplate and setup the
307 // Load boilerplate object into r3 and check if we need to create a
328 // Return and remove the on-stack parameters.
336 // Return and remove the on-stack parameters.
368 // Return and remove the on-stack parameters.
384 // Load boilerplate object into a3 and check if we need to create a
396 // Check that the boilerplate contains only fast properties and we can
403 // Allocate the JS object and copy header together with all in-object
411 // Return and remove the on-stack parameters.
419 // Takes a Smi and converts to an IEEE 64 bit floating point value in two
420 // registers. The format is 1 sign bit, 11 exponent bits (biased 1023) and
470 // in the exponent word of the double has the same position and polarity as
473 __ And(exponent, source_, Operand(HeapNumber::kSignMask));
479 // absolute value: it is either equal to 1 (special case of -1 and 1),
489 // 1, 0 and -1 all have 0 for the second word.
497 // Compute exponent and or it into the exponent register.
510 // And the top (top 20 bits).
536 // Write Smi from a0 to a3 and a2 in double format.
541 // Write Smi from a1 to a1 and a0 in double format.
603 // Load the double from heap number to dst1 and dst2 in double format.
618 // Load the converted smi to dst1 and dst2 in double format.
623 // Write smi to dst1 and dst2 double format.
709 __ And(dst2, int_scratch, Operand(HeapNumber::kSignMask));
733 __ And(int_scratch, int_scratch, scratch2);
818 // Check for 0 and -0.
819 __ And(scratch1, dst1, Operand(~HeapNumber::kSignMask));
827 // dst1 and dst2 were trashed. Reload the double value.
888 // Check for 0 and -0.
889 __ And(dst, scratch1, Operand(~HeapNumber::kSignMask));
908 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
951 __ And(tmp, src2, 0x3fffff);
968 // Create the mask and test the lower bits (of the higher bits).
974 __ And(src1, dst, src1);
999 // We are not using MIPS FPU instructions, and parameters for the runtime
1001 // calling is compiled with hard-float flag and expecting hard float ABI
1018 // Double returned in registers v0 and v1.
1022 // Place heap_number_result in v0 and return to the pushed return address.
1043 // Other register combinations are generated as and when they are needed,
1064 // Test sign, and save for later conditionals.
1065 __ And(sign_, the_int_, Operand(0x80000000u));
1081 // the most significant 1 to hit the last bit of the 12 bit sign and exponent.
1109 // Handle the case where the lhs and rhs are the same object.
1111 // for "identity and not NaN".
1129 // They are both equal and they are not both Smis so both of them are not
1172 // For less and greater we don't have to check for NaN since the result of
1177 // It is a heap number, so return non-equal if it's NaN and equal if it's
1181 // and not all mantissa bits (0..51) clear.
1185 __ And(t3, t2, Operand(exp_mask_reg));
1189 // Shift out flag and all exponent bits, retaining only mantissa.
1195 // if all bits in mantissa are zero (it's an Infinity) and non-zero if
1196 // not (it's a NaN). For <= and >= we need to load v0 with the failing
1231 // If lhs was not a number and rhs was a Smi then strict equality cannot
1254 // Write Smi from rhs to a1 and a0 in double format. t5 is scratch.
1270 // If lhs was not a number and rhs was a Smi then strict equality cannot
1312 // Lhs and rhs are already loaded to f12 and f14 register pairs.
1316 // Lhs and rhs are already loaded to GP registers.
1366 // f12 and f14 have the two doubles. Neither is a NaN.
1369 // We use a call_was and return manually because we need arguments slots to
1375 // Exception: 0 and -0.
1379 // Lhs and rhs are already loaded to f12 and f14 register pairs.
1383 // Lhs and rhs are already loaded to GP registers.
1419 // We are not using MIPS FPU instructions, and parameters for the runtime
1421 // calling is compiled with hard-float flag and expecting hard float ABI
1463 // Get the type of the first operand into a2 and compare it with
1488 __ And(t2, a2, Operand(a3));
1489 __ And(t0, t2, Operand(kIsSymbolMask));
1540 __ And(at, a2, Operand(kIsNotStringMask));
1542 __ And(at, a2, Operand(kIsSymbolMask));
1546 __ And(at, a3, Operand(kIsSymbolMask));
1560 // are not equal, since they are different objects and an object is not
1566 __ And(a0, a0, Operand(1 << Map::kIsUndetectable));
1588 // contains two elements (number and string) for each cache entry.
1595 // number string cache for smis is just the smi value, and the hash for
1596 // doubles is the xor of the upper and lower words. See
1618 __ And(scratch1, scratch1, Operand(mask));
1644 __ And(scratch, mask, Operand(scratch));
1683 // On entry lhs_ (lhs) and rhs_ (rhs) are the things to be compared.
1702 __ And(a2, a2, kSmiTagMask);
1719 __ And(t2, lhs_, Operand(rhs_));
1726 // In cases 3 and 4 we have found out we were dealing with a number-number
1727 // comparison and the numbers have been loaded into f12 and f14 as doubles,
1734 // and the right hand side if we have FPU. Otherwise a2, a3 represent
1735 // left hand side and
1784 // and neither of them is a Smi. The objects are in lhs_ and rhs_.
1794 // or load both doubles and jump to the code that handles
1812 // Check for both being sequential ASCII strings, and inline if that is the
1841 // Figure out which native to call and setup the arguments.
1864 // The stub expects its argument in the tos_ register and returns its result in
1865 // it, too: zero for false, and a non-zero value for true.
1885 __ And(at, tos_, kSmiTagMask);
1889 // If we need a map later and have a Smi -> patch.
1898 __ And(at, at, Operand(1 << Map::kIsUndetectable));
1930 // "tos_" is a register, and contains a non zero value by default.
1968 // Patch the caller to an appropriate specialized stub and return the
1979 // store the registers in any particular way, but we do have to store and
2040 // Argument is in a0 and v0 at this point, so we can overwrite a0.
2089 __ And(t0, a0, ~0x80000000);
2102 // Flip bits and revert inverted smi-tag.
2104 __ And(v0, v0, ~kSmiTagMask);
2189 // Do the bitwise operation and check if the result fits in a smi.
2195 // Tag the result as a smi and we're done.
2392 // No need to revert anything - right and left are intact.
2397 // No need to revert anything - right and left are intact.
2496 __ And(v0, scratch1, ~kSmiTagMask);
2506 // check the sign bit and the sign bit after Smi tagging.
2507 __ And(scratch1, v0, Operand(0xc0000000));
2556 // Load left and right operands into f12 and f14 or a0/a1 and a2/a3
2632 // Convert operands to 32-bit integers. Right in a2 and left in a3.
2661 __ And(a2, a3, Operand(a2));
2731 // a3 and a0 as scratch. v0 is preserved and returned.
2744 // generated. If the result is not a smi and heap number allocation is not
2783 // Allow heap number result and don't make a transition if a heap number
2816 // Registers containing left and right operands respectively.
2873 // Load both operands and check that they are 32-bit integer.
2874 // Jump to type transition if they are not. The registers a0 and a1 (right
2875 // and left) are preserved for the runtime call.
2951 __ And(scratch2, scratch2, HeapNumber::kSignMask);
2955 // Tag the result and return.
2984 // We preserved a0 and a1 to be able to call runtime.
3025 // Convert operands to 32-bit integers. Right in a2 and left in a3. The
3026 // registers a0 and a1 (right and left) are preserved for the runtime
3057 __ And(a2, a3, Operand(a2));
3060 __ And(a2, a2, Operand(0x1f));
3064 __ And(a2, a2, Operand(0x1f));
3089 __ And(a2, a2, Operand(0x1f));
3100 // Tag the result and return.
3132 // a3 and a0 as scratch. v0 is preserved and returned.
3334 // Tagged case: tagged input on top of stack and in a0,
3350 // Argument is a number and is on stack and in a0.
3351 // Load argument and check if it is a smi.
3354 // Input is a smi. Convert to double and load the low and high words
3370 // low and high words into a2, a3.
3388 __ And(a1, a1, Operand(TranscendentalCache::SubCache::kCacheSize - 1));
3411 CHECK_EQ(12, elem2_start - elem_start); // Two uint_32's and a pointer.
3430 // Cache hit. Load result, cleanup and return.
3435 // Pop input value from stack and load result into v0.
3462 // Call C function to calculate the result and update the cache.
3464 // it on the stack and pop it into register cache_entry after the
3499 // Call C function to calculate the result and answer directly
3601 // The exponent and base are supplied as arguments on the stack.
3649 // compile time and uses DoMathPowHalf instead. We then skip this check
3716 // Get two copies of exponent in the registers scratch and exponent.
3736 __ And(scratch2, scratch, 1);
3870 // We are calling compiled C/C++ code. a0 and a1 hold our two arguments. We
3879 // we can store the address on the stack to be able to find it again and
3882 // This branch-and-link sequence is needed to find the current PC on mips,
3892 // instruction past the real call into C code (the jalr(t9)), and push it.
3911 // It's okay to clobber a2 and a3 here. v0 & v1 contain result.
3928 // Exit C frame and return.
3951 // Retrieve the pending exception and clear the variable.
3982 // this by performing a garbage collection and retrying the
3988 // See MacroAssembler::PrepareCEntryArgs and PrepareCEntryFunction.
4013 // Do space-specific GC and retry runtime call.
4021 // Do full GC and retry runtime call one final time.
4040 // Set pending exception and v0 to out of memory exception.
4141 // field in the JSEnv and return a failure sentinel. Coming in here the
4157 // restores all kCalleeSaved registers (including cp and fp) to their
4244 // Call site inlining and patching implies arguments in registers.
4266 // Check that the left hand is a JS object and load map.
4271 // real lookup and update the call site cache.
4292 // map and function. The cached answer will be set when it is known below.
4304 // Get the map location in scratch and patch it.
4309 // Register mapping: a3 is object map and t0 is function prototype.
4335 // Get the boolean result location in scratch and patch it.
4353 // Get the boolean result location in scratch and patch it.
4365 // Before null, smi and string value checks, check that the rhs is a function
4443 // Read the argument from the stack and return it.
4457 // Read the argument from the adaptor frame and return it.
4485 // Patch the arguments.length and the parameters pointer in the current frame.
4543 // Compute the sizes of backing store, parameter map, and arguments object.
4544 // 1. Parameter map, has 2 extra words containing context and backing store.
4603 // Use the length (smi tagged) and set that as an in-object property too.
4640 // Copy the parameter slots and the holes in the arguments.
4683 // Copy arguments header and remaining slots (if there are any).
4706 // Return and remove the on-stack parameters.
4734 // Patch the arguments.length and the parameters pointer.
4745 // of the arguments object and the elements array in words.
4773 // Get the length (smi tagged) and set that as an in-object property too.
4785 // Set up the elements pointer in the allocated arguments object and
4810 // Return and remove the on-stack parameters.
4844 // registers and will be preserved by the call to the native RegExp code, as
4846 // directly from generated code the native RegExp code will not do a GC and
4873 __ And(t0, regexp_data, Operand(kSmiTagMask));
4908 __ And(a0, a0, Operand(kIsNotStringMask));
4939 // Check that the last match info has space for the capture registers and the
4951 // Check the representation and encoding of the subject string.
4957 __ And(a1,
4968 // a1: whether subject is a string and if yes, its string representation
4985 __ And(at, a1, Operand(kIsNotStringMask | kShortExternalStringMask));
5005 __ And(at, a0, Operand(kStringRepresentationMask));
5016 __ And(a0, a0, Operand(kStringEncodingMask)); // Non-zero for ASCII.
5085 // For arguments 4 and 3 get string length, calculate start of string data
5086 // and calculate the shift of the index (0 for ASCII and 1 for two byte).
5092 // the previous fp onto the stack and moves up sp by 2 * kPointerSize.)
5097 // Prepare start and end index of the input.
5113 // Locate the code entry and call it.
5156 // For failure and exception return null.
5175 // Store last subject and last input.
5204 // Capture register counter starts from number of capture registers and
5235 __ And(at, a0, Operand(kIsIndirectStringMask));
5270 // Size of JSArray with two in-object properties and the header of a
5300 // Set input, index and length fields from arguments.
5346 // are uninitialized, monomorphic (indicated by a JSFunction), and
5564 __ And(t0, result_, Operand(kIsNotStringMask));
5627 // Call runtime. We get here when the receiver is a string and the
5657 __ And(t0,
5759 __ And(scratch4, dest, Operand(kPointerAlignmentMask));
5772 // Assumes word reads and writes are little endian.
5789 // Align dest by byte copying. Copies between zero and three bytes.
5790 __ And(scratch4, dest, Operand(kReadAlignmentMask));
5806 __ And(scratch4, src, Operand(kReadAlignmentMask));
5810 // This loop uses lwl and lwr instructions. These instructions
5811 // depend on the endianness, and the implementation assumes little-endian.
5828 // Both src and dest are word aligned.
5900 // chars: two character string, char 1 in byte 0 and char 2 in byte 1.
5923 // chars: two character string, char 1 in byte 0 and char 2 in byte 1.
5944 __ And(candidate, candidate, Operand(mask));
5999 // Untag smi seed and add the character.
6056 // both "from" and "to" are smis, and
6074 // Both a2 and a3 are untagged integers.
6086 __ And(t0, a1, Operand(kIsNotStringMask));
6129 // and put the underlying string into t1.
6138 __ And(t0, a1, Operand(kIsIndirectStringMask));
6140 // t0 is used as a scratch register and can be overwritten in either case.
6141 __ And(t0, a1, Operand(kSlicedNotConsMask));
6154 // Sliced string. Fetch parent and correct start index by offset.
6186 __ And(t0, a1, Operand(kStringEncodingMask));
6208 __ And(t0, a1, Operand(kExternalStringTag));
6214 __ And(t0, a1, Operand(kShortExternalStringTag));
6228 __ And(t0, a1, Operand(kStringEncodingMask));
6231 // Allocate and copy the resulting ASCII string.
6249 // Allocate and copy the resulting two-byte string.
6325 // Find minimum length and length difference.
6455 __ And(t4, t4, Operand(kIsNotStringMask));
6543 // Resulting string has length 2 and first chars of two strings
6574 __ And(t4, t0, Operand(t1));
6575 __ And(t4, t4, Operand(kStringEncodingMask));
6594 __ And(at, t0, Operand(kAsciiDataHintMask));
6600 __ And(t0, t0, Operand(kAsciiStringTag | kAsciiDataHintTag));
6628 __ And(t3, t3, Operand(kStringEncodingMask));
6632 __ And(t4, t0, Operand(kStringRepresentationMask));
6640 // External string: rule out short external string and load string resource.
6642 __ And(t4, t0, Operand(kShortExternalStringMask));
6648 __ And(t4, t1, Operand(kStringRepresentationMask));
6655 // External string: rule out short external string and load string resource.
6657 __ And(t4, t1, Operand(kShortExternalStringMask));
6670 __ And(t4, t1, Operand(kStringEncodingMask));
6752 __ And(scratch2, scratch2, scratch4);
6789 __ And(a2, a1, Operand(a0));
6797 // Inlining the double comparison and falling back to the general compare
6802 // Load left and right operand.
6810 // Test if equal, and also handle the unordered/NaN case.
6816 // Otherwise it's greater, so just fall thru, and return.
6859 // Registers containing left and right operands respectively.
6874 __ And(tmp1, tmp1, Operand(tmp2));
6875 __ And(tmp1, tmp1, kIsSymbolMask);
6899 // Registers containing left and right operands respectively.
6912 // types loaded in tmp1 and tmp2.
6919 __ And(tmp5, tmp3, Operand(kIsNotStringMask));
6938 __ And(tmp3, tmp1, Operand(tmp2));
6939 __ And(tmp5, tmp3, Operand(kIsSymbolMask));
6981 __ And(a2, a1, Operand(a0));
7000 __ And(a2, a1, a0);
7045 // Dereference the address and check for this.
7102 // not equal to the name and kProbes-th slot is not used (its name is the
7113 __ And(index, index, Operand(
7147 __ And(scratch0, entity_name, Operand(kIsSymbolMask));
7208 // shifted in the following and instruction.
7215 __ And(scratch2, scratch1, scratch2);
7293 // shifted in the following and instruction.
7302 __ And(index, mask, index);
7328 __ And(result, entry_key, Operand(kIsSymbolMask));
7379 // and ElementsTransitionGenerator::GenerateSmiOnlyToDouble
7380 // and ElementsTransitionGenerator::GenerateDoubleToObject
7436 // Takes the input in 3 registers: address_ value_ and object_. A pointer to
7446 // back and forth between a "bne zero_reg, zero_reg, ..." (a nop in this
7447 // position) and the "beq zero_reg, zero_reg, ..." when we start and stop
7599 // We need extra registers for this, so we push the object and the address
7659 // Array literal has ElementsKind of FAST_ELEMENTS and value is an object.
7673 // FAST_ELEMENTS, and value is Smi.
