Lines Matching full:operand
61 __ tst(r0, Operand(kSmiTagMask));
122 __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
155 __ mov(r2, Operand(Smi::FromInt(length)));
159 __ mov(r1, Operand(Smi::FromInt(0)));
202 __ add(r3, r3, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
249 __ add(r2, r0, Operand(JSArray::kSize));
257 __ add(sp, sp, Operand(3 * kPointerSize));
316 __ mov(source_, Operand(source_, ASR, kSmiTagSize));
321 __ and_(exponent, source_, Operand(HeapNumber::kSignMask), SetCC);
323 __ rsb(source_, source_, Operand(0, RelocInfo::NONE), LeaveCC, ne);
328 __ cmp(source_, Operand(1));
334 __ orr(exponent, exponent, Operand(exponent_word_for_1), LeaveCC, eq);
336 __ mov(mantissa, Operand(0, RelocInfo::NONE));
348 __ rsb(mantissa, zeros_, Operand(31 + HeapNumber::kExponentBias - fudge));
349 __ add(mantissa, mantissa, Operand(fudge));
352 Operand(mantissa, LSL, HeapNumber::kExponentShift));
354 __ add(zeros_, zeros_, Operand(1));
356 __ mov(source_, Operand(source_, LSL, zeros_));
358 __ mov(mantissa, Operand(source_, LSL, HeapNumber::kMantissaBitsInTopWord));
362 Operand(source_, LSR, 32 - HeapNumber::kMantissaBitsInTopWord));
503 __ mov(scratch1, Operand(r0, ASR, kSmiTagSize));
506 __ mov(scratch1, Operand(r1, ASR, kSmiTagSize));
516 __ mov(scratch1, Operand(r0));
521 __ mov(scratch1, Operand(r1));
537 // Load right operand (r0) to d6 or r2/r3.
541 // Load left operand (r1) to d7 or r0/r1.
573 __ sub(scratch1, object, Operand(kHeapObjectTag));
597 __ mov(scratch1, Operand(object));
689 __ cmp(scratch1, Operand(0));
695 __ and_(dst2, scratch1, Operand(HeapNumber::kSignMask), SetCC);
697 __ rsb(scratch1, scratch1, Operand(0), SetCC, mi);
703 __ rsb(dst1, dst1, Operand(31));
706 __ add(scratch2, dst1, Operand(HeapNumber::kExponentBias));
711 __ mov(scratch2, Operand(1));
712 __ bic(scratch1, scratch1, Operand(scratch2, LSL, dst1));
714 __ cmp(dst1, Operand(HeapNumber::kMantissaBitsInTopWord));
716 __ sub(scratch2, dst1, Operand(HeapNumber::kMantissaBitsInTopWord), SetCC);
719 __ orr(dst2, dst2, Operand(scratch1, LSR, scratch2));
720 __ rsb(scratch2, scratch2, Operand(32));
721 __ mov(dst1, Operand(scratch1, LSL, scratch2));
725 __ rsb(scratch2, dst1, Operand(HeapNumber::kMantissaBitsInTopWord));
726 __ mov(scratch2, Operand(scratch1, LSL, scratch2));
729 __ mov(dst1, Operand(0));
746 __ sub(scratch1, object, Operand(kHeapObjectTag));
769 __ bic(scratch1, dst1, Operand(HeapNumber::kSignMask));
770 __ orr(scratch1, scratch1, Operand(dst2));
771 __ cmp(scratch1, Operand(0));
821 __ sub(scratch1, object, Operand(kHeapObjectTag));
842 __ bic(dst, scratch1, Operand(HeapNumber::kSignMask));
843 __ orr(dst, scratch2, Operand(dst));
844 __ cmp(dst, Operand(0));
854 __ mov(dst, Operand(dst, LSR, scratch3));
856 __ rsb(scratch3, scratch3, Operand(32));
857 __ orr(dst, dst, Operand(scratch2, LSL, scratch3));
860 __ tst(scratch1, Operand(HeapNumber::kSignMask));
861 __ rsb(dst, dst, Operand(0), LeaveCC, mi);
881 __ sub(scratch, scratch, Operand(HeapNumber::kExponentBias), SetCC);
896 __ sub(tmp, scratch, Operand(src1, LSR, 31));
897 __ cmp(tmp, Operand(30));
900 __ tst(src2, Operand(0x3fffff));
916 Operand(src1, LSL, HeapNumber::kNonMantissaBitsInTopWord));
919 __ rsb(scratch, scratch, Operand(32));
920 __ mov(src2, Operand(1));
921 __ mov(src1, Operand(src2, LSL, scratch));
922 __ sub(src1, src1, Operand(1));
955 __ mov(r0, Operand(heap_number_result));
967 __ cmp(the_int_, Operand(0x80000000u));
973 __ mov(scratch_, Operand(non_smi_exponent));
975 __ orr(scratch_, scratch_, Operand(HeapNumber::kSignMask), LeaveCC, cs);
977 __ rsb(the_int_, the_int_, Operand(0, RelocInfo::NONE), LeaveCC, cs);
984 __ orr(scratch_, scratch_, Operand(the_int_, LSR, shift_distance));
987 __ mov(scratch_, Operand(the_int_, LSL, 32 - shift_distance));
998 __ mov(ip, Operand(HeapNumber::kSignMask | non_smi_exponent));
1000 __ mov(ip, Operand(0, RelocInfo::NONE));
1033 __ cmp(r4, Operand(FIRST_JS_OBJECT_TYPE));
1039 __ cmp(r4, Operand(ODDBALL_TYPE));
1046 __ mov(r0, Operand(GREATER));
1049 __ mov(r0, Operand(LESS));
1059 __ mov(r0, Operand(GREATER)); // Things aren't less than themselves.
1061 __ mov(r0, Operand(LESS)); // Things aren't greater than themselves.
1063 __ mov(r0, Operand(EQUAL)); // Things are <=, >=, ==, === themselves.
1083 __ cmp(r3, Operand(-1));
1087 __ mov(r2, Operand(r2, LSL, HeapNumber::kNonMantissaBitsInTopWord));
1090 __ orr(r0, r3, Operand(r2), SetCC);
1099 __ mov(r0, Operand(GREATER)); // NaN <= NaN should fail.
1101 __ mov(r0, Operand(LESS)); // NaN >= NaN should fail.
1124 __ tst(rhs, Operand(kSmiTagMask));
1134 __ mov(r0, Operand(NOT_EQUAL), LeaveCC, ne);
1149 __ sub(r7, rhs, Operand(kHeapObjectTag));
1154 __ mov(r7, Operand(lhs));
1174 __ mov(r0, Operand(NOT_EQUAL), LeaveCC, ne);
1187 __ sub(r7, lhs, Operand(kHeapObjectTag));
1196 __ mov(r7, Operand(rhs));
1218 __ cmp(r4, Operand(-1));
1221 Operand(lhs_exponent, LSL, HeapNumber::kNonMantissaBitsInTopWord),
1224 __ cmp(lhs_mantissa, Operand(0, RelocInfo::NONE));
1233 __ cmp(r4, Operand(-1));
1236 Operand(rhs_exponent, LSL, HeapNumber::kNonMantissaBitsInTopWord),
1239 __ cmp(rhs_mantissa, Operand(0, RelocInfo::NONE));
1246 __ mov(r0, Operand(GREATER));
1248 __ mov(r0, Operand(LESS));
1269 __ cmp(rhs_mantissa, Operand(lhs_mantissa));
1270 __ orr(r0, rhs_mantissa, Operand(lhs_mantissa), LeaveCC, ne);
1274 __ sub(r0, rhs_exponent, Operand(lhs_exponent), SetCC);
1284 __ orr(r4, lhs_mantissa, Operand(lhs_exponent, LSL, kSmiTagSize), SetCC);
1285 __ mov(r0, Operand(r4), LeaveCC, ne);
1289 __ mov(r0, Operand(rhs_exponent, LSL, kSmiTagSize));
1309 // If either operand is a JSObject or an oddball value, then they are
1314 // Get the type of the first operand into r2 and compare it with
1326 __ cmp(r2, Operand(ODDBALL_TYPE));
1333 __ cmp(r3, Operand(ODDBALL_TYPE));
1340 __ and_(r2, r2, Operand(r3));
1341 __ tst(r2, Operand(kIsSymbolMask));
1366 __ sub(r7, rhs, Operand(kHeapObjectTag));
1368 __ sub(r7, lhs, Operand(kHeapObjectTag));
1391 __ tst(r2, Operand(kIsNotStringMask));
1393 __ tst(r2, Operand(kIsSymbolMask));
1397 __ tst(r3, Operand(kIsSymbolMask));
1402 __ mov(r0, Operand(NOT_EQUAL));
1406 __ cmp(r2, Operand(FIRST_JS_OBJECT_TYPE));
1416 __ and_(r0, r2, Operand(r3));
1417 __ and_(r0, r0, Operand(1 << Map::kIsUndetectable));
1418 __ eor(r0, r0, Operand(1 << Map::kIsUndetectable));
1442 __ mov(mask, Operand(mask, ASR, kSmiTagSize + 1));
1443 __ sub(mask, mask, Operand(1)); // Make mask.
1465 Operand(HeapNumber::kValueOffset - kHeapObjectTag));
1467 __ eor(scratch1, scratch1, Operand(scratch2));
1468 __ and_(scratch1, scratch1, Operand(mask));
1474 Operand(scratch1, LSL, kPointerSizeLog2 + 1));
1480 __ sub(scratch2, object, Operand(kHeapObjectTag));
1482 __ sub(probe, probe, Operand(kHeapObjectTag));
1494 __ and_(scratch, mask, Operand(object, ASR, 1));
1499 Operand(scratch, LSL, kPointerSizeLog2 + 1));
1525 __ add(sp, sp, Operand(1 * kPointerSize));
1547 __ tst(r2, Operand(kSmiTagMask));
1549 __ mov(r1, Operand(r1, ASR, 1));
1550 __ sub(r0, r1, Operand(r0, ASR, 1));
1555 __ tst(r2, Operand(kSmiTagMask));
1560 // it is certain that at least one operand isn't a smi.
1570 __ and_(r2, lhs_, Operand(rhs_));
1571 __ tst(r2, Operand(kSmiTagMask));
1573 // One operand is a smi. EmitSmiNonsmiComparison generates code that can:
1596 __ mov(r0, Operand(EQUAL), LeaveCC, eq);
1597 __ mov(r0, Operand(LESS), LeaveCC, lt);
1598 __ mov(r0, Operand(GREATER), LeaveCC, gt);
1606 __ mov(r0, Operand(GREATER));
1608 __ mov(r0, Operand(LESS));
1684 __ mov(r0, Operand(Smi::FromInt(ncr)));
1714 __ sub(ip, tos_, Operand(kHeapObjectTag));
1720 __ mov(tos_, Operand(0, RelocInfo::NONE), LeaveCC, eq); // for FP_ZERO
1721 __ mov(tos_, Operand(0, RelocInfo::NONE), LeaveCC, vs); // for FP_NAN
1736 __ and_(scratch, scratch, Operand(1 << Map::kIsUndetectable));
1737 __ cmp(scratch, Operand(1 << Map::kIsUndetectable));
1743 __ cmp(scratch, Operand(FIRST_JS_OBJECT_TYPE));
1752 __ cmp(scratch, Operand(FIRST_NONSTRING_TYPE));
1766 __ mov(tos_, Operand(0, RelocInfo::NONE));
1784 __ mov(r2, Operand(Smi::FromInt(MinorKey())));
1785 __ mov(r1, Operand(Smi::FromInt(op_)));
1786 __ mov(r0, Operand(Smi::FromInt(operands_type_)));
1869 __ add(right, left, Operand(right), SetCC); // Add optimistically.
1871 __ sub(right, right, Operand(left)); // Revert optimistic add.
1874 __ sub(right, left, Operand(right), SetCC); // Subtract optimistically.
1876 __ sub(right, left, Operand(right)); // Revert optimistic subtract.
1888 __ mov(ip, Operand(scratch1, ASR, 31));
1889 __ cmp(ip, Operand(scratch2));
1892 __ tst(scratch1, Operand(scratch1));
1893 __ mov(right, Operand(scratch1), LeaveCC, ne);
1897 __ add(scratch2, right, Operand(left), SetCC);
1898 __ mov(right, Operand(Smi::FromInt(0)), LeaveCC, pl);
1907 __ orr(scratch2, scratch1, Operand(0x80000000u));
1913 __ rsb(scratch1, scratch1, Operand(31));
1914 __ mov(right, Operand(left, LSR, scratch1));
1919 __ orr(scratch1, left, Operand(right));
1920 __ tst(scratch1, Operand(0x80000000u | kSmiTagMask));
1927 __ and_(right, left, Operand(scratch1));
1931 __ orr(right, left, Operand(right));
1935 __ and_(right, left, Operand(right));
1939 __ eor(right, left, Operand(right));
1943 // Remove tags from right operand.
1945 __ mov(right, Operand(left, ASR, scratch1));
1947 __ bic(right, right, Operand(kSmiTagMask));
1955 __ mov(scratch1, Operand(scratch1, LSR, scratch2));
1958 __ tst(scratch1, Operand(0xc0000000));
1968 __ mov(scratch1, Operand(scratch1, LSL, scratch2));
1970 __ add(scratch2, scratch1, Operand(0x40000000), SetCC);
2055 __ sub(r0, result, Operand(kHeapObjectTag));
2057 __ add(r0, r0, Operand(kHeapObjectTag));
2105 __ orr(r2, r3, Operand(r2));
2108 __ eor(r2, r3, Operand(r2));
2111 __ and_(r2, r3, Operand(r2));
2116 __ mov(r2, Operand(r3, ASR, r2));
2121 __ mov(r2, Operand(r3, LSR, r2), SetCC);
2135 __ mov(r2, Operand(r3, LSL, r2));
2142 __ add(r3, r2, Operand(0x40000000), SetCC);
2163 __ mov(r0, Operand(r5));
2175 __ sub(r3, r0, Operand(kHeapObjectTag));
2208 __ orr(scratch1, left, Operand(right));
2210 __ tst(scratch1, Operand(kSmiTagMask));
2366 __ add(scratch2, scratch1, Operand(0x40000000), SetCC);
2371 __ cmp(scratch1, Operand(0));
2374 __ tst(scratch2, Operand(HeapNumber::kSignMask));
2396 __ sub(r0, heap_number_result, Operand(kHeapObjectTag));
2473 __ orr(r2, r3, Operand(r2));
2476 __ eor(r2, r3, Operand(r2));
2479 __ and_(r2, r3, Operand(r2));
2482 __ and_(r2, r2, Operand(0x1f));
2483 __ mov(r2, Operand(r3, ASR, r2));
2486 __ and_(r2, r2, Operand(0x1f));
2487 __ mov(r2, Operand(r3, LSR, r2), SetCC);
2504 __ and_(r2, r2, Operand(0x1f));
2505 __ mov(r2, Operand(r3, LSL, r2));
2512 __ add(scratch1, r2, Operand(0x40000000), SetCC);
2541 __ sub(r0, heap_number_result, Operand(kHeapObjectTag));
2584 __ mov(r1, Operand(Smi::FromInt(0)));
2593 __ mov(r0, Operand(Smi::FromInt(0)));
2645 // Left operand is not a string, test right.
2717 // If the overwritable operand is already an object, we skip the
2725 // Use object holding the overwritable operand for result.
2726 __ mov(result, Operand(overwritable_operand));
2788 __ eor(r1, r2, Operand(r3));
2789 __ eor(r1, r1, Operand(r1, ASR, 16));
2790 __ eor(r1, r1, Operand(r1, ASR, 8));
2792 __ And(r1, r1, Operand(TranscendentalCache::SubCache::kCacheSize - 1));
2800 __ mov(cache_entry, Operand(cache_array));
2807 __ cmp(cache_entry, Operand(0, RelocInfo::NONE));
2826 __ add(r1, r1, Operand(r1, LSL, 1));
2827 __ add(cache_entry, cache_entry, Operand(r1, LSL, 2));
2838 __ mov(r0, Operand(r6));
2903 __ mov(scratch0, Operand(4 * kPointerSize));
2965 __ tst(r0, Operand(kSmiTagMask));
2973 __ bic(ip, r0, Operand(0x80000000), SetCC);
2975 __ rsb(r0, r0, Operand(0, RelocInfo::NONE));
2980 __ rsb(r0, r0, Operand(0, RelocInfo::NONE), SetCC);
2989 __ tst(r0, Operand(kSmiTagMask));
2990 __ Assert(ne, "Unexpected smi operand.");
3000 __ eor(r2, r2, Operand(HeapNumber::kSignMask)); // Flip sign.
3007 __ eor(r2, r2, Operand(HeapNumber::kSignMask)); // Flip sign.
3009 __ mov(r0, Operand(r1));
3015 __ mvn(r0, Operand(r0));
3017 __ bic(r0, r0, Operand(kSmiTagMask));
3021 __ tst(r0, Operand(kSmiTagMask));
3022 __ Assert(ne, "Unexpected smi operand.");
3025 // Check if the operand is a heap number.
3037 __ mvn(r1, Operand(r1));
3038 __ add(r2, r1, Operand(0x40000000), SetCC);
3040 __ mov(r0, Operand(r1, LSL, kSmiTagSize));
3049 __ mov(r0, Operand(r2));
3057 __ sub(r2, r0, Operand(kHeapObjectTag));
3229 __ mov(r0, Operand(scope_depth));
3231 __ add(r1, r1, Operand(1));
3237 __ mov(r0, Operand(r4));
3238 __ mov(r1, Operand(r6));
3247 __ tst(sp, Operand(frame_alignment_mask));
3256 __ mov(r2, Operand(ExternalReference::isolate_address()));
3270 masm->add(lr, pc, Operand(4));
3277 __ mov(r2, Operand(scope_depth));
3279 __ sub(r3, r3, Operand(1));
3287 __ add(r2, r0, Operand(1));
3288 __ tst(r2, Operand(kFailureTagMask));
3303 __ tst(r0, Operand(((1 << kFailureTypeTagSize) - 1) << kFailureTagSize));
3308 __ cmp(r0, Operand(reinterpret_cast<int32_t>(out_of_memory)));
3312 __ mov(ip, Operand(ExternalReference::the_hole_value_location(isolate)));
3314 __ mov(ip, Operand(ExternalReference(Isolate::k_pending_exception_address,
3321 __ cmp(r0, Operand(isolate->factory()->termination_exception()));
3347 __ add(r6, sp, Operand(r0, LSL, kPointerSizeLog2));
3348 __ sub(r6, r6, Operand(kPointerSize));
3354 __ mov(r4, Operand(r0));
3355 __ mov(r5, Operand(r1));
3383 __ mov(r0, Operand(reinterpret_cast<int32_t>(failure)));
3442 __ mov(r8, Operand(-1)); // Push a bad frame pointer to fail if it is used.
3444 __ mov(r7, Operand(Smi::FromInt(marker)));
3445 __ mov(r6, Operand(Smi::FromInt(marker)));
3447 Operand(ExternalReference(Isolate::k_c_entry_fp_address, isolate)));
3452 __ add(fp, sp, Operand(-EntryFrameConstants::kCallerFPOffset));
3458 __ mov(r5, Operand(ExternalReference(js_entry_sp)));
3460 __ cmp(r6, Operand(0));
3463 __ mov(ip, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
3467 __ mov(ip, Operand(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME)));
3479 __ mov(ip, Operand(ExternalReference(Isolate::k_pending_exception_address,
3482 __ mov(r0, Operand(reinterpret_cast<int32_t>(Failure::Exception())));
3495 __ mov(ip, Operand(ExternalReference::the_hole_value_location(isolate)));
3497 __ mov(ip, Operand(ExternalReference(Isolate::k_pending_exception_address,
3514 __ mov(ip, Operand(construct_entry));
3517 __ mov(ip, Operand(entry));
3524 __ mov(lr, Operand(pc));
3525 masm->add(pc, ip, Operand(Code::kHeaderSize - kHeapObjectTag));
3535 __ cmp(r5, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
3537 __ mov(r6, Operand(0));
3538 __ mov(r5, Operand(ExternalReference(js_entry_sp)));
3546 Operand(ExternalReference(Isolate::k_c_entry_fp_address, isolate)));
3550 __ add(sp, sp, Operand(-EntryFrameConstants::kCallerFPOffset));
3555 __ mov(lr, Operand(pc));
3657 __ cmp(scratch, Operand(prototype));
3667 __ mov(r0, Operand(Smi::FromInt(0)));
3672 __ add(inline_site, inline_site, Operand(kDeltaToLoadBoolResult));
3678 __ mov(r0, Operand(Smi::FromInt(0)));
3685 __ mov(r0, Operand(Smi::FromInt(1)));
3690 __ add(inline_site, inline_site, Operand(kDeltaToLoadBoolResult));
3696 __ mov(r0, Operand(Smi::FromInt(1)));
3710 __ cmp(scratch, Operand(FACTORY->null_value()));
3712 __ mov(r0, Operand(Smi::FromInt(1)));
3718 __ mov(r0, Operand(Smi::FromInt(1)));
3724 __ mov(r0, Operand(Smi::FromInt(1)));
3739 __ cmp(r0, Operand(0));
3767 __ cmp(r3, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3778 __ add(r3, fp, Operand(r3, LSL, kPointerSizeLog2 - kSmiTagSize));
3792 __ add(r3, r2, Operand(r3, LSL, kPointerSizeLog2 - kSmiTagSize));
3813 __ cmp(r3, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3824 __ add(r3, r2, Operand(r1, LSL, kPointerSizeLog2 - kSmiTagSize));
3825 __ add(r3, r3, Operand(StandardFrameConstants::kCallerSPOffset));
3832 __ cmp(r1, Operand(0, RelocInfo::NONE));
3834 __ mov(r1, Operand(r1, LSR, kSmiTagSize));
3835 __ add(r1, r1, Operand(FixedArray::kHeaderSize / kPointerSize));
3837 __ add(r1, r1, Operand(GetArgumentsObjectSize() / kPointerSize));
3874 __ cmp(r1, Operand(0, RelocInfo::NONE));
3882 __ add(r4, r0, Operand(GetArgumentsObjectSize()));
3887 __ mov(r1, Operand(r1, LSR, kSmiTagSize)); // Untag the length for the loop.
3892 __ add(r4, r4, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
3899 __ sub(r1, r1, Operand(1));
3900 __ cmp(r1, Operand(0, RelocInfo::NONE));
3905 __ add(sp, sp, Operand(3 * kPointerSize));
3954 __ mov(r0, Operand(address_of_regexp_stack_memory_size));
3956 __ tst(r0, Operand(r0));
3962 __ tst(r0, Operand(kSmiTagMask));
3970 __ tst(regexp_data, Operand(kSmiTagMask));
3979 __ cmp(r0, Operand(Smi::FromInt(JSRegExp::IRREGEXP)));
3990 __ add(r2, r2, Operand(2)); // r2 was a smi.
3992 __ cmp(r2, Operand(OffsetsVector::kStaticOffsetsVectorSize));
3999 __ tst(subject, Operand(kSmiTagMask));
4013 __ tst(r0, Operand(kSmiTagMask));
4015 __ cmp(r3, Operand(r0));
4023 __ tst(r0, Operand(kSmiTagMask));
4038 __ add(r2, r2, Operand(RegExpImpl::kLastMatchOverhead));
4039 __ cmp(r2, Operand(r0, ASR, kSmiTagSize));
4049 __ tst(r0, Operand(kIsNotStringMask | kStringRepresentationMask));
4062 __ tst(r0, Operand(kIsNotStringMask | kExternalStringTag));
4073 __ tst(r0, Operand(kStringRepresentationMask));
4083 __ and_(r0, r0, Operand(kStringEncodingMask));
4084 __ mov(r3, Operand(r0, ASR, 2), SetCC);
4101 __ mov(r1, Operand(r1, ASR, kSmiTagSize));
4120 __ mov(r0, Operand(ExternalReference::isolate_address()));
4124 __ mov(r0, Operand(1));
4128 __ mov(r0, Operand(address_of_regexp_stack_memory_address));
4130 __ mov(r2, Operand(address_of_regexp_stack_memory_size));
4132 __ add(r0, r0, Operand(r2));
4137 Operand(ExternalReference::address_of_static_offsets_vector(isolate)));
4143 __ mov(r0, Operand(r0, ASR, kSmiTagSize));
4145 __ add(r9, subject, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag));
4146 __ eor(r3, r3, Operand(1));
4149 __ add(r2, r9, Operand(r1, LSL, r3));
4150 __ add(r3, r9, Operand(r0, LSL, r3));
4159 __ add(r7, r7, Operand(Code::kHeaderSize - kHeapObjectTag));
4173 __ cmp(r0, Operand(NativeRegExpMacroAssembler::SUCCESS));
4176 __ cmp(r0, Operand(NativeRegExpMacroAssembler::FAILURE));
4178 __ cmp(r0, Operand(NativeRegExpMacroAssembler::EXCEPTION));
4185 __ mov(r1, Operand(ExternalReference::the_hole_value_location(isolate)));
4187 __ mov(r2, Operand(ExternalReference(Isolate::k_pending_exception_address,
4208 __ mov(r0, Operand(FACTORY->null_value()));
4209 __ add(sp, sp, Operand(4 * kPointerSize));
4219 __ add(r1, r1, Operand(2)); // r1 was a smi.
4224 __ mov(r2, Operand(r1, LSL, kSmiTagSize + kSmiShiftSize)); // To smi.
4232 __ RecordWrite(r3, Operand(RegExpImpl::kLastSubjectOffset), r2, r7);
4237 __ RecordWrite(r3, Operand(RegExpImpl::kLastInputOffset), r2, r7);
4242 __ mov(r2, Operand(address_of_static_offsets_vector));
4251 Operand(RegExpImpl::kFirstCaptureOffset - kHeapObjectTag));
4253 __ sub(r1, r1, Operand(1), SetCC);
4258 __ mov(r3, Operand(r3, LSL, kSmiTagSize));
4265 __ add(sp, sp, Operand(4 * kPointerSize));
4282 __ tst(r1, Operand(kSmiTagMask));
4284 __ cmp(r1, Operand(Smi::FromInt(kMaxInlineLength)));
4294 __ mov(r5, Operand(r1, LSR, kSmiTagSize + kSmiShiftSize));
4295 __ add(r2, r5, Operand(objects_size));
4312 __ add(r3, r0, Operand(JSRegExpResult::kSize));
4313 __ mov(r4, Operand(FACTORY->empty_fixed_array()));
4334 __ mov(r2, Operand(FACTORY->fixed_array_map()));
4337 __ mov(r6, Operand(r5, LSL, kSmiTagSize));
4340 __ mov(r2, Operand(FACTORY->the_hole_value()));
4341 __ add(r3, r3, Operand(FixedArray::kHeaderSize - kHeapObjectTag));
4348 __ tst(r5, Operand(r5));
4351 __ sub(r5, r5, Operand(1), SetCC);
4356 __ add(sp, sp, Operand(3 * kPointerSize));
4414 __ mov(r0, Operand(argc_)); // Setup the number of arguments.
4415 __ mov(r2, Operand(0, RelocInfo::NONE));
4510 __ tst(result_, Operand(kIsNotStringMask));
4522 __ cmp(ip, Operand(scratch_));
4527 __ tst(result_, Operand(kStringRepresentationMask));
4531 __ tst(result_, Operand(kIsConsStringMask));
4541 __ cmp(result_, Operand(ip));
4549 __ tst(result_, Operand(kStringRepresentationMask));
4555 __ tst(result_, Operand(kStringEncodingMask));
4563 __ add(scratch_, object_, Operand(scratch_));
4570 __ add(scratch_, object_, Operand(scratch_, LSR, kSmiTagSize));
4574 __ mov(result_, Operand(result_, LSL, kSmiTagSize));
4639 Operand(kSmiTagMask |
4646 __ add(result_, result_, Operand(code_, LSL, kPointerSizeLog2 - kSmiTagSize));
4649 __ cmp(result_, Operand(ip));
4762 __ add(count, count, Operand(count), SetCC);
4764 __ cmp(count, Operand(0, RelocInfo::NONE));
4772 __ sub(count, count, Operand(1), SetCC);
4803 __ tst(dest, Operand(kPointerAlignmentMask));
4817 __ add(count, count, Operand(count), SetCC);
4819 __ cmp(count, Operand(0, RelocInfo::NONE));
4826 __ cmp(count, Operand(8));
4827 __ add(count, dest, Operand(count));
4833 __ and_(scratch4, dest, Operand(kReadAlignmentMask), SetCC);
4836 __ cmp(scratch4, Operand(2));
4848 __ sub(scratch4, dest, Operand(src));
4849 __ and_(scratch4, scratch4, Operand(0x03), SetCC);
4858 __ mov(scratch4, Operand(scratch4, LSL, 3));
4860 __ and_(src, src, Operand(~3)); // Round down to load previous word.
4864 __ rsb(scratch2, left_shift, Operand(32));
4866 __ mov(scratch1, Operand(scratch1, LSR, right_shift));
4870 __ sub(scratch5, limit, Operand(dest));
4871 __ orr(scratch1, scratch1, Operand(scratch3, LSL, left_shift));
4873 __ mov(scratch1, Operand(scratch3, LSR, right_shift));
4876 __ sub(scratch5, scratch5, Operand(8), SetCC);
4886 __ add(scratch5, scratch5, Operand(4), SetCC);
4888 __ cmp(scratch4, Operand(scratch5, LSL, 3), ne);
4890 __ mov(scratch5, Operand(scratch4, LSR, 3), LeaveCC, lt);
4893 __ cmp(scratch5, Operand(2));
4895 __ mov(scratch1, Operand(scratch1, LSR, 8), LeaveCC, ge);
4897 __ mov(scratch1, Operand(scratch1, LSR, 8), LeaveCC, gt);
4910 __ sub(scratch3, limit, Operand(dest));
4914 __ cmp(scratch3, Operand(8));
4920 __ cmp(dest, Operand(limit));
4945 __ sub(scratch, c1, Operand(static_cast<int>('0')));
4946 __ cmp(scratch, Operand(static_cast<int>('9' - '0')));
4948 __ sub(scratch, c2, Operand(static_cast<int>('0')));
4949 __ cmp(scratch, Operand(static_cast<int>('9' - '0')));
4954 __ orr(c1, c1, Operand(c2, LSL, kBitsPerByte), LeaveCC, ls);
4966 __ orr(chars, chars, Operand(c2, LSL, kBitsPerByte));
4982 __ mov(mask, Operand(mask, ASR, 1));
4983 __ sub(mask, mask, Operand(1));
4988 Operand(SymbolTable::kElementsStartOffset - kHeapObjectTag));
5008 __ add(candidate, hash, Operand(SymbolTable::GetProbeOffset(i)));
5013 __ and_(candidate, candidate, Operand(mask));
5047 __ cmp(scratch, Operand(Smi::FromInt(2)));
5072 __ add(hash, character, Operand(character, LSL, 10));
5074 __ eor(hash, hash, Operand(hash, ASR, 6));
5082 __ add(hash, hash, Operand(character));
5084 __ add(hash, hash, Operand(hash, LSL, 10));
5086 __ eor(hash, hash, Operand(hash, ASR, 6));
5093 __ add(hash, hash, Operand(hash, LSL, 3));
5095 __ eor(hash, hash, Operand(hash, ASR, 11));
5097 __ add(hash, hash, Operand(hash, LSL, 15), SetCC);
5100 __ mov(hash, Operand(27), LeaveCC, ne);
5132 __ mov(r2, Operand(to, ASR, 1), SetCC);
5133 __ mov(r3, Operand(from, ASR, 1), SetCC, cc);
5140 __ sub(r2, r2, Operand(r3), SetCC);
5145 __ cmp(r2, Operand(2));
5156 __ tst(r5, Operand(kSmiTagMask));
5168 __ and_(r4, r1, Operand(kStringRepresentationMask));
5171 __ cmp(r4, Operand(kConsStringTag));
5181 __ tst(r1, Operand(kStringRepresentationMask));
5195 __ cmp(r4, Operand(to));
5206 __ tst(r1, Operand(kStringEncodingMask));
5211 __ cmp(r2, Operand(2));
5216 __ add(r5, r5, Operand(r3));
5226 __ add(sp, sp, Operand(3 * kPointerSize));
5235 __ add(sp, sp, Operand(3 * kPointerSize));
5248 __ add(r1, r0, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag));
5250 __ add(r5, r5, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag));
5251 __ add(r5, r5, Operand(from, ASR, 1));
5261 __ add(sp, sp, Operand(3 * kPointerSize));
5277 __ add(r1, r0, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
5279 __ add(r5, r5, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
5282 __ add(r5, r5, Operand(from));
5293 __ add(sp, sp, Operand(3 * kPointerSize));
5313 __ sub(scratch3, scratch1, Operand(scratch2), SetCC);
5318 __ tst(min_length, Operand(min_length));
5322 __ mov(min_length, Operand(min_length, ASR, kSmiTagSize));
5327 Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag));
5328 __ add(left, left, Operand(scratch2));
5329 __ add(right, right, Operand(scratch2));
5331 __ rsb(min_length, min_length, Operand(-1));
5340 __ add(index, index, Operand(1), SetCC);
5353 __ mov(r0, Operand(length_delta), SetCC, eq);
5355 __ mov(r0, Operand(Smi::FromInt(GREATER)), LeaveCC, gt);
5356 __ mov(r0, Operand(Smi::FromInt(LESS)), LeaveCC, lt);
5376 __ mov(r0, Operand(Smi::FromInt(EQUAL)));
5378 __ add(sp, sp, Operand(2 * kPointerSize));
5388 __ add(sp, sp, Operand(2 * kPointerSize));
5422 __ tst(r4, Operand(kIsNotStringMask));
5423 __ tst(r5, Operand(kIsNotStringMask), eq);
5452 __ cmp(r2, Operand(Smi::FromInt(0))); // Test if first string is empty.
5453 __ mov(r0, Operand(r1), LeaveCC, eq); // If first is empty, return second.
5456 __ cmp(r3, Operand(Smi::FromInt(0)), ne);
5460 __ add(sp, sp, Operand(2 * kPointerSize));
5466 __ mov(r2, Operand(r2, ASR, kSmiTagSize));
5467 __ mov(r3, Operand(r3, ASR, kSmiTagSize));
5479 __ add(r6, r2, Operand(r3));
5482 __ cmp(r6, Operand(2));
5505 __ add(sp, sp, Operand(2 * kPointerSize));
5514 __ mov(r6, Operand(2));
5518 __ add(sp, sp, Operand(2 * kPointerSize));
5523 __ cmp(r6, Operand(String::kMinNonFlatLength));
5529 __ cmp(r6, Operand(String::kMaxLength + 1));
5542 __ tst(r4, Operand(kStringEncodingMask));
5543 __ tst(r5, Operand(kStringEncodingMask), ne);
5553 __ mov(r0, Operand(r7));
5555 __ add(sp, sp, Operand(2 * kPointerSize));
5563 __ tst(r4, Operand(kAsciiDataHintMask));
5564 __ tst(r5, Operand(kAsciiDataHintMask), ne);
5566 __ eor(r4, r4, Operand(r5));
5568 __ and_(r4, r4, Operand(kAsciiStringTag | kAsciiDataHintTag));
5569 __ cmp(r4, Operand(kAsciiStringTag | kAsciiDataHintTag));
5594 __ tst(r4, Operand(kStringRepresentationMask));
5595 __ tst(r5, Operand(kStringRepresentationMask), eq);
5605 __ eor(r7, r4, Operand(r5));
5606 __ tst(r7, Operand(kStringEncodingMask));
5609 __ tst(r4, Operand(kStringEncodingMask));
5617 __ add(r6, r7, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag));
5619 __ add(r0, r0, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag));
5629 __ add(r1, r1, Operand(SeqAsciiString::kHeaderSize - kHeapObjectTag));
5635 __ mov(r0, Operand(r7));
5637 __ add(sp, sp, Operand(2 * kPointerSize));
5655 __ add(r6, r7, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
5657 __ add(r0, r0, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
5668 __ add(r1, r1, Operand(SeqTwoByteString::kHeaderSize - kHeapObjectTag));
5676 __ mov(r0, Operand(r7));
5678 __ add(sp, sp, Operand(2 * kPointerSize));
5730 scratch2, Operand(1 << Map::kStringWrapperSafeForDefaultValueOf));
5732 Operand(1 << Map::kStringWrapperSafeForDefaultValueOf));
5745 __ tst(r2, Operand(kSmiTagMask));
5769 __ and_(r2, r1, Operand(r0));
5770 __ tst(r2, Operand(kSmiTagMask));
5783 // Load left and right operand
5784 __ sub(r2, r1, Operand(kHeapObjectTag));
5786 __ sub(r2, r0, Operand(kHeapObjectTag));
5796 __ mov(r0, Operand(EQUAL), LeaveCC, eq);
5797 __ mov(r0, Operand(LESS), LeaveCC, lt);
5798 __ mov(r0, Operand(GREATER), LeaveCC, gt);
5816 __ and_(r2, r1, Operand(r0));
5817 __ tst(r2, Operand(kSmiTagMask));
5826 __ sub(r0, r0, Operand(r1));
5843 __ mov(ip, Operand(Smi::FromInt(op_)));
5848 __ add(r2, r0, Operand(Code::kHeaderSize - kHeapObjectTag));
5864 __ mov(lr, Operand(reinterpret_cast<intptr_t>(GetCode().location()),
5866 __ mov(r2, Operand(function));
5875 __ mov(lr, Operand(reinterpret_cast<intptr_t>(GetCode().location()),
