Lines Matching refs:SMI
162 __ li(a2, Operand(Smi::FromInt(length)));
168 __ li(a1, Operand(Smi::FromInt(0)));
211 __ li(a2, Operand(Smi::FromInt(length)));
214 // If this block context is nested in the global context we get a smi
221 const char* message = "Expected 0 as a Smi sentinel";
419 // Takes a Smi and converts to an IEEE 64 bit floating point value in two
467 // Convert from Smi to integer.
471 // the 2's complement sign bit in a Smi.
536 // Write Smi from a0 to a3 and a2 in double format.
541 // Write Smi from a1 to a1 and a0 in double format.
586 // Smi-check
610 // Handle loading a double from a smi.
614 // Convert smi to double using FPU instructions.
618 // Load the converted smi to dst1 and dst2 in double format.
623 // Write smi to dst1 and dst2 double format.
1058 // See comment for class, this does NOT work for int32's that are in Smi range.
1061 // the_int_ has the answer which is a signed int32 but not a Smi.
1068 // Set up the correct exponent in scratch_. All non-Smi int32s have the same.
1069 // A non-Smi integer is 1.xxx * 2^30 so the exponent is 30 (biased).
1227 // Rhs is a Smi.
1228 // Check whether the non-smi is a heap number.
1231 // If lhs was not a number and rhs was a Smi then strict equality cannot
1236 // Smi compared non-strictly with a non-Smi non-heap-number. Call
1241 // Rhs is a smi, lhs is a number.
1242 // Convert smi rhs to double.
1254 // Write Smi from rhs to a1 and a0 in double format. t5 is scratch.
1267 // Lhs is a Smi. Check whether the non-smi is a heap number.
1270 // If lhs was not a number and rhs was a Smi then strict equality cannot
1275 // Smi compared non-strictly with a non-Smi non-heap-number. Call
1280 // Lhs is a smi, rhs is a number.
1281 // Convert smi lhs to double.
1590 // Divide length by two (length is a smi).
1595 // number string cache for smis is just the smi value, and the hash for
1651 // Check if the entry is the smi we are looking for.
1684 // On exit, v0 is 0, positive, or negative (smi) to indicate the result
1703 __ Assert(ne, "CompareStub: unexpected smi operands.",
1708 // NOTICE! This code is only reached after a smi-fast-case check, so
1709 // it is certain that at least one operand isn't a smi.
1715 // If either is a Smi (we know that not both are), then they can only
1718 ASSERT_EQ(0, Smi::FromInt(0));
1721 // One operand is a smi. EmitSmiNonsmiComparison generates code that can:
1784 // and neither of them is a Smi. The objects are in lhs_ and rhs_.
1854 __ li(a0, Operand(Smi::FromInt(ncr)));
1883 if (types_.Contains(SMI)) {
1889 // If we need a map later and have a Smi -> patch.
1965 __ li(a2, Operand(Smi::FromInt(tos_.code())));
1966 __ li(a1, Operand(Smi::FromInt(types_.ToByte())));
2026 case UnaryOpIC::SMI:
2041 __ li(a2, Operand(Smi::FromInt(op_)));
2042 __ li(a1, Operand(Smi::FromInt(mode_)));
2043 __ li(a0, Operand(Smi::FromInt(operand_type_)));
2088 // The result of negating zero or the smallest negative smi is not a smi.
2102 // Flip bits and revert inverted smi-tag.
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.
2306 __ li(a2, Operand(Smi::FromInt(MinorKey())));
2307 __ li(a1, Operand(Smi::FromInt(op_)));
2308 __ li(a0, Operand(Smi::FromInt(operands_type_)));
2333 case BinaryOpIC::SMI:
2401 // will be a smi if it fits the smi range.
2407 // Check for overflowing the smi range - no overflow if higher 33 bits of
2423 ASSERT(Smi::FromInt(0) == 0);
2425 __ mov(v0, zero_reg); // Return smi 0 if the non-zero one was positive.
2449 // Check that the signed result fits in a Smi.
2472 // Check that the signed result fits in a Smi.
2495 // Smi tag result.
2506 // check the sign bit and the sign bit after Smi tagging.
2509 // Smi tag result.
2518 // Check that the signed result fits in a Smi.
2690 // Check that the *signed* result fits in a smi.
2743 // Generate the smi code. If the operation on smis are successful this return is
2744 // generated. If the result is not a smi and heap number allocation is not
2758 // Perform combined smi check on both operands.
2763 // If the smi-smi operation results in a smi return is generated.
2779 result_type_ == BinaryOpIC::SMI) {
2780 // Only allow smi results.
2791 // Code falls through if the result is not returned as either a smi or heap
2859 // Smi-smi fast case.
2864 // Fall through if the result is not a smi.
2926 // Try to return a smi if we can.
2942 // Check if the result fits in a smi.
3096 // Check if the result fits in a smi.
3173 __ li(a1, Operand(Smi::FromInt(0)));
3182 __ li(a0, Operand(Smi::FromInt(0)));
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
3759 // smi. We set it with exponent value before bailing out.
4094 __ li(t2, Operand(Smi::FromInt(marker)));
4095 __ li(t1, Operand(Smi::FromInt(marker)));
4126 __ li(t0, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
4131 __ li(t0, Operand(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME)));
4208 Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
4327 ASSERT(Smi::FromInt(0) == 0);
4339 ASSERT_EQ(Smi::FromInt(0), 0);
4347 __ li(v0, Operand(Smi::FromInt(1)));
4357 __ li(v0, Operand(Smi::FromInt(1)));
4365 // Before null, smi and string value checks, check that the rhs is a function
4376 __ li(v0, Operand(Smi::FromInt(1)));
4380 // Smi values are not instances of anything.
4382 __ li(v0, Operand(Smi::FromInt(1)));
4388 __ li(v0, Operand(Smi::FromInt(1)));
4436 Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
4464 // Slow-case: Handle non-smi or out-of-bounds access to arguments
4483 Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
4518 Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
4549 ASSERT_EQ(0, Smi::FromInt(0));
4603 // Use the length (smi tagged) and set that as an in-object property too.
4622 __ Branch(&skip3, ne, a1, Operand(Smi::FromInt(0)));
4628 __ Branch(&skip_parameter_map, eq, a1, Operand(Smi::FromInt(0)));
4632 __ Addu(t2, a1, Operand(Smi::FromInt(2)));
4651 __ Addu(t5, t5, Operand(Smi::FromInt(Context::MIN_CONTEXT_SLOTS)));
4667 __ Subu(t2, t2, Operand(Smi::FromInt(1)));
4675 __ Addu(t5, t5, Operand(Smi::FromInt(1)));
4677 __ Branch(¶meters_loop, ne, t2, Operand(Smi::FromInt(0)));
4701 __ Addu(t5, t5, Operand(Smi::FromInt(1)));
4728 Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
4773 // Get the length (smi tagged) and set that as an in-object property too.
4888 __ Branch(&runtime, ne, a0, Operand(Smi::FromInt(JSRegExp::IRREGEXP)));
4898 __ Addu(a2, a2, Operand(2)); // a2 was a smi.
4916 // a3: Length of subject string as a smi
4919 // Check that the third argument is a positive smi less than the subject
4992 // t5: offset of sliced string, smi-tagged.
5024 // a smi (code flushing support).
5034 __ sra(a1, a1, kSmiTagSize); // Untag the Smi.
5167 __ Addu(a1, a1, Operand(2)); // a1 was a smi.
5172 __ sll(a2, a1, kSmiTagSize + kSmiShiftSize); // To smi.
5215 // Store the smi value in the last match info.
5216 __ sll(a3, a3, kSmiTagSize); // Convert to Smi.
5265 __ Branch(&slowcase, hi, a1, Operand(Smi::FromInt(kMaxInlineLength)));
5266 // Smi-tagging is equivalent to multiplying by 2.
5268 // JSArray: [Map][empty properties][Elements][Length-smi][index][input]
5284 // a1: Number of elements in array, as smi.
5471 // Check that the function is not a smi.
5557 // If the receiver is a smi trigger the non-string case.
5567 // If the index is non-smi trigger the non-smi case.
5594 // Index is not a smi.
5622 // If index is still not a smi, it must be out of range.
5664 // At this point code register contains smi tagged ASCII char code.
5975 __ Branch(&next_probe[i], ne, scratch, Operand(Smi::FromInt(2)));
5999 // Untag smi seed and add the character.
6293 __ li(v0, Operand(Smi::FromInt(NOT_EQUAL)));
6301 __ li(v0, Operand(Smi::FromInt(EQUAL)));
6312 __ li(v0, Operand(Smi::FromInt(EQUAL)));
6343 ASSERT(Smi::FromInt(EQUAL) == static_cast<Smi*>(0));
6354 __ li(v0, Operand(Smi::FromInt(GREATER)));
6356 __ li(v0, Operand(Smi::FromInt(LESS)));
6411 __ li(v0, Operand(Smi::FromInt(EQUAL)));
6481 // These tests use zero-length check on string-length whch is an Smi.
6482 // Assert that Smi::FromInt(0) is really 0.
6484 ASSERT(Smi::FromInt(0) == 0);
6885 __ li(v0, Operand(Smi::FromInt(EQUAL)));
7023 __ li(t0, Operand(Smi::FromInt(op_)));
7110 // Capacity is smi 2^n.
7114 Smi::FromInt(name->Hash() + StringDictionary::GetProbeOffset(i))));
7196 __ sra(scratch1, scratch1, kSmiTagSize); // convert smi to int
7289 // Capacity is smi 2^n.
7634 // -- a3 : element index as smi
7635 // -- t0 : array literal index in function as smi
7673 // FAST_ELEMENTS, and value is Smi.
