Lines Matching refs:Smi
136 Immediate(Smi::FromInt(length)));
187 Immediate(Smi::FromInt(length)));
189 // If this block context is nested in the global context we get a smi
196 const char* message = "Expected 0 as a Smi sentinel";
441 if (types_.Contains(SMI)) {
452 // If we need a map later and have a Smi -> patch.
569 // same register as the result, because we never see Smi-zero here.
580 __ push(Immediate(Smi::FromInt(tos_.code())));
581 __ push(Immediate(Smi::FromInt(types_.ToByte())));
600 // be either a smi or a heap number object (fp value). Requirements:
606 // be either smi or heap number objects (fp values). Requirements:
617 // Test if operands are smi or number objects (fp). Requirements:
648 // Test if operands are numbers (smi or HeapNumber objects), and load
703 // represented by a Smi. A non-smi 32 bit integer is 1.xxx * 2^30 so the
709 // If we have a match of the int32-but-not-Smi exponent then skip some
757 // ecx already has a Smi zero.
821 case UnaryOpIC::SMI:
838 __ push(Immediate(Smi::FromInt(op_)));
839 __ push(Immediate(Smi::FromInt(mode_)));
840 __ push(Immediate(Smi::FromInt(operand_type_)));
893 // Check whether the value is a smi.
913 // Check whether the value is a smi.
916 // Flip bits and revert inverted smi-tag.
1014 // Do the bitwise operation and check if the result fits in a smi.
1020 // Tag the result as a smi and we're done.
1037 // be stored since it's untagged and not in the smi range (so we can't
1038 // smi-tag it). We'll recalculate the value after the GC instead.
1127 __ push(Immediate(Smi::FromInt(MinorKey())));
1128 __ push(Immediate(Smi::FromInt(op_)));
1129 __ push(Immediate(Smi::FromInt(operands_type_)));
1150 __ push(Immediate(Smi::FromInt(MinorKey())));
1151 __ push(Immediate(Smi::FromInt(op_)));
1152 __ push(Immediate(Smi::FromInt(operands_type_)));
1175 case BinaryOpIC::SMI:
1235 // 2. Prepare the smi check of both operands by oring them together.
1236 Comment smi_check_comment(masm, "-- Smi check arguments");
1242 // Perform the operation into eax and smi check the result. Preserve
1243 // eax in case the result is not a smi.
1265 // for the smi check register.
1276 // 3. Perform the smi check of the operands.
1282 Comment perform_smi(masm, "-- Perform smi operation");
1305 // Check that the *signed* result fits in a smi.
1330 // Check that the *unsigned* result fits in a smi.
1332 // - 0x80000000: high bit would be lost when smi tagging.
1334 // Smi tagging these two cases can only happen with shifts
1335 // by 0 or 1 when handed a valid smi.
1356 // If the smi tag is 0 we can just leave the tag on one operand.
1358 // We can't revert the multiplication if the result is not a smi
1371 // We can't revert the division if the result is not a smi so
1382 // Check for the corner case of dividing the most negative smi by
1440 // overflowed the smi range).
1566 // 7. Non-smi operands, fall out to the non-smi code with the operands in
1568 Comment done_comment(masm, "-- Enter non-smi code");
1575 // Right operand is saved in ecx and eax was destroyed by the smi
1616 result_type_ == BinaryOpIC::SMI) {
1748 // For MOD we go directly to runtime in the non-smi case.
1781 // Check if result is non-negative and fits in a smi.
1785 // Check if result fits in a smi.
1789 // Tag smi result and return.
1970 // For MOD we go directly to runtime in the non-smi case.
1995 // Check if result is non-negative and fits in a smi.
1999 // Check if result fits in a smi.
2003 // Tag smi result and return.
2171 // For MOD we go directly to runtime in the non-smi case.
2194 // Check if result is non-negative and fits in a smi.
2198 // Check if result fits in a smi.
2202 // Tag smi result and return.
2398 // Input is a smi. Untag and load it onto the FPU stack.
2538 __ push(Immediate(Smi::FromInt(2 * kDoubleSize)));
2689 // Test if arg1 is a Smi.
2712 // Here edx has the untagged integer, eax has a Smi or a heap number.
2715 // Test if arg2 is a Smi.
2779 __ SmiUntag(edx); // Untag smi before converting to float.
2781 __ SmiTag(edx); // Retag smi for heap number overwriting test.
2785 __ SmiUntag(eax); // Untag smi before converting to float.
2787 __ SmiTag(eax); // Retag smi for heap number overwriting test.
2809 __ SmiUntag(edx); // Untag smi before converting to float.
2811 __ SmiTag(edx); // Retag smi for heap number overwriting test.
2814 __ SmiUntag(eax); // Untag smi before converting to float.
2816 __ SmiTag(eax); // Retag smi for heap number overwriting test.
2916 // Test if both operands are floats or smi -> scratch=k_is_float;
3160 // exponent is a smi. We reset it with exponent value before bailing out.
3210 // Check that the key is a smi.
3218 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3251 // Slow-case: Handle non-smi or out-of-bounds access to arguments
3271 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3302 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3390 // Use the length (smi tagged) and set that as an in-object property too.
3419 __ lea(eax, Operand(ebx, reinterpret_cast<intptr_t>(Smi::FromInt(2))));
3436 __ mov(ebx, Immediate(Smi::FromInt(Context::MIN_CONTEXT_SLOTS)));
3455 __ sub(eax, Immediate(Smi::FromInt(1)));
3458 __ add(ebx, Immediate(Smi::FromInt(1)));
3488 __ add(ebx, Immediate(Smi::FromInt(1)));
3519 __ cmp(ecx, Immediate(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3560 // Get the length (smi tagged) and set that as an in-object property too.
3656 __ cmp(ebx, Immediate(Smi::FromInt(JSRegExp::IRREGEXP)));
3666 __ add(edx, Immediate(2)); // edx was a smi.
3681 // ebx: Length of subject string as a smi
3684 // Check that the third argument is a positive smi less than the subject
3759 // edi: offset of sliced string, smi-tagged.
3797 // a smi (code flushing support).
3806 __ SmiUntag(ebx); // Previous index from smi.
3876 STATIC_ASSERT(kSmiTagSize == 1); // esi is smi (powered by 2).
3941 __ add(edx, Immediate(2)); // edx was a smi.
3951 __ SmiTag(edx); // Number of capture registers to smi.
3953 __ SmiUntag(edx); // Number of capture registers back from smi.
3987 // Store the smi value in the last match info.
4034 __ cmp(ebx, Immediate(Smi::FromInt(kMaxInlineLength)));
4036 // Smi-tagging is equivalent to multiplying by 2.
4040 // JSArray: [Map][empty properties][Elements][Length-smi][index][input]
4044 ebx, // In: Number of elements (times 2, being a smi)
4077 // ecx: Number of elements in array, as smi.
4134 // number string cache for smis is just the smi value, and the hash for
4182 // Object is smi and hash is now in scratch. Calculate cache index.
4185 // Check if the entry is the smi we are looking for.
4249 __ Assert(not_zero, "Unexpected smi operands.");
4252 // NOTICE! This code is only reached after a smi-fast-case check, so
4253 // it is certain that at least one operand isn't a smi.
4268 __ Set(eax, Immediate(Smi::FromInt(NegativeComparisonResult(cc_))));
4277 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
4289 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
4317 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
4320 __ Set(eax, Immediate(Smi::FromInt(NegativeComparisonResult(cc_))));
4335 // and oddballs. Non-smi numbers and strings still go through the usual
4337 // If either is a Smi (we know that not both are), then they can only
4340 ASSERT_EQ(0, Smi::FromInt(0));
4345 // One operand is a smi.
4347 // Check whether the non-smi is a heap number.
4355 // if eax was smi, ebx is now edx, else eax.
4357 // Check if the non-smi operand is a heap number.
4415 __ mov(ecx, Immediate(Smi::FromInt(1)));
4417 __ mov(ecx, Immediate(Smi::FromInt(-1)));
4439 __ mov(eax, Immediate(Smi::FromInt(-1)));
4443 __ mov(eax, Immediate(Smi::FromInt(1)));
4452 __ mov(eax, Immediate(Smi::FromInt(1)));
4454 __ mov(eax, Immediate(Smi::FromInt(-1)));
4505 // At most one is a smi, so we can test for smi by adding the two.
4506 // A smi plus a heap object has the low bit set, a heap object plus
4547 __ push(Immediate(Smi::FromInt(NegativeComparisonResult(cc_))));
4717 // Check that function is not a smi.
4991 __ push(Immediate(Smi::FromInt(marker))); // context slot
4992 __ push(Immediate(Smi::FromInt(marker))); // function slot
5008 __ push(Immediate(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
5012 __ push(Immediate(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME)));
5063 __ cmp(ebx, Immediate(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
5229 __ Set(eax, Immediate(Smi::FromInt(1)));
5244 __ Set(eax, Immediate(Smi::FromInt(1)));
5251 // Before null, smi and string value checks, check that the rhs is a function
5260 __ Set(eax, Immediate(Smi::FromInt(1)));
5264 // Smi values is not instance of anything.
5266 __ Set(eax, Immediate(Smi::FromInt(1)));
5273 __ Set(eax, Immediate(Smi::FromInt(1)));
5357 // If the receiver is a smi trigger the non-string case.
5368 // If the index is non-smi trigger the non-smi case.
5393 // Index is not a smi.
5420 // If index is still not a smi, it must be out of range.
5463 // At this point code register contains smi tagged ASCII char code.
5568 // ebx: length of first string as a smi
5569 // ecx: length of second string as a smi
5575 STATIC_ASSERT(Smi::kMaxValue == String::kMaxLength);
5580 __ cmp(ebx, Immediate(Smi::FromInt(2)));
5620 __ cmp(ebx, Immediate(Smi::FromInt(ConsString::kMinLength)));
5672 // ebx: length of resulting flat string as a smi
5727 // ebx: length of resulting flat string as a smi
5761 // ebx: length of resulting flat string as a smi
6028 Immediate(Smi::FromInt(2)));
6157 // Calculate length of sub string using the smi values.
6173 // ecx: sub string length (smi)
6174 // edx: from index (smi)
6217 // edx: adjusted start index (smi)
6218 // ecx: length (smi)
6219 __ cmp(ecx, Immediate(Smi::FromInt(SlicedString::kMinLength)));
6250 // edx: adjusted start index (smi)
6251 // ecx: length (smi)
6318 // As from is a smi it is 2 times the value which matches the size of a two
6357 __ Set(eax, Immediate(Smi::FromInt(NOT_EQUAL)));
6366 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
6375 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
6422 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
6430 __ Set(eax, Immediate(Smi::FromInt(LESS)));
6435 __ Set(eax, Immediate(Smi::FromInt(GREATER)));
6486 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
6569 __ mov(ecx, Immediate(Smi::FromInt(1)));
6571 __ mov(ecx, Immediate(Smi::FromInt(-1)));
6637 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
6683 __ Set(eax, Immediate(Smi::FromInt(EQUAL)));
6787 __ push(Immediate(Smi::FromInt(op_)));
6821 // Capacity is smi 2^n.
6825 Immediate(Smi::FromInt(name->Hash() +
6889 __ shr(r1, kSmiTagSize); // convert smi to int
7309 // -- ecx : element index as smi
7361 // FAST_ELEMENTS, and value is Smi.
