Lines Matching refs:Operand
153 __ Branch(&ok, ne, a2, Operand(at));
179 __ Subu(sp, sp, Operand(slots * kPointerSize));
181 __ Addu(a0, sp, Operand(slots * kPointerSize));
182 __ li(a1, Operand(kSlotsZapValue));
185 __ Subu(a0, a0, Operand(kPointerSize));
187 __ Branch(&loop, ne, a0, Operand(sp));
190 __ Subu(sp, sp, Operand(slots * kPointerSize));
266 __ Subu(sp, sp, Operand(slots * kPointerSize));
303 __ li(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));
305 __ Addu(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
347 __ li(entry_offset, Operand(entry - base));
361 __ li(at, Operand(Smi::FromInt(StackFrame::STUB)));
364 Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
369 Operand(ExternalReference::ForDeoptEntry(base)));
392 Operand(ExternalReference::ForDeoptEntry(base)));
438 __ li(scratch, Operand(static_cast<int32_t>(literal->Number())));
441 __ li(scratch, Operand(Smi::FromInt(constant->Integer32Value())));
476 __ li(at, Operand(static_cast<int32_t>(literal->Number())));
540 Operand LCodeGen::ToOperand(LOperand* op) {
547 return Operand(Smi::FromInt(constant->Integer32Value()));
550 return Operand(constant->Integer32Value());
555 return Operand(constant->handle(isolate()));
557 return Operand(ToRegister(op));
560 return Operand(0);
564 return Operand(0);
819 Register src1, const Operand& src2,
838 __ li(scratch, Operand(count));
840 __ Subu(a1, a1, Operand(1));
841 __ Branch(&no_deopt, ne, a1, Operand(zero_reg));
842 __ li(a1, Operand(FLAG_deopt_every_n_times));
885 Register src1, const Operand& src2,
1115 __ Branch(÷nd_is_not_negative, ge, dividend, Operand(zero_reg));
1118 __ And(dividend, dividend, Operand(mask));
1120 DeoptimizeIf(eq, instr, dividend, Operand(zero_reg));
1127 __ And(dividend, dividend, Operand(mask));
1144 __ Mul(result, result, Operand(Abs(divisor)));
1145 __ Subu(result, dividend, Operand(result));
1151 __ Branch(&remainder_not_zero, ne, result, Operand(zero_reg));
1152 DeoptimizeIf(lt, instr, dividend, Operand(zero_reg));
1171 DeoptimizeIf(eq, instr, right_reg, Operand(zero_reg));
1178 __ Branch(&no_overflow_possible, ne, left_reg, Operand(kMinInt));
1180 DeoptimizeIf(eq, instr, right_reg, Operand(-1));
1182 __ Branch(&no_overflow_possible, ne, right_reg, Operand(-1));
1190 __ Branch(&done, ge, left_reg, Operand(zero_reg));
1192 DeoptimizeIf(eq, instr, result_reg, Operand(zero_reg));
1208 DeoptimizeIf(eq, instr, dividend, Operand(zero_reg));
1212 DeoptimizeIf(eq, instr, dividend, Operand(kMinInt));
1218 __ And(at, dividend, Operand(mask));
1219 DeoptimizeIf(ne, instr, at, Operand(zero_reg));
1231 __ Addu(result, dividend, Operand(result));
1235 __ Addu(result, dividend, Operand(result));
1256 DeoptimizeIf(eq, instr, dividend, Operand(zero_reg));
1263 __ Mul(scratch0(), result, Operand(divisor));
1265 DeoptimizeIf(ne, instr, scratch0(), Operand(zero_reg));
1284 DeoptimizeIf(eq, instr, divisor, Operand(zero_reg));
1290 __ Branch(&left_not_zero, ne, dividend, Operand(zero_reg));
1291 DeoptimizeIf(lt, instr, divisor, Operand(zero_reg));
1299 __ Branch(&left_not_min_int, ne, dividend, Operand(kMinInt));
1300 DeoptimizeIf(eq, instr, divisor, Operand(-1));
1305 DeoptimizeIf(ne, instr, remainder, Operand(zero_reg));
1351 DeoptimizeIf(eq, instr, result, Operand(zero_reg));
1358 DeoptimizeIf(ge, instr, scratch, Operand(zero_reg));
1370 __ Branch(&no_overflow, lt, scratch, Operand(zero_reg));
1371 __ li(result, Operand(kMinInt / divisor));
1393 DeoptimizeIf(eq, instr, dividend, Operand(zero_reg));
1411 dividend, Operand(zero_reg));
1416 __ Addu(temp, dividend, Operand(divisor > 0 ? 1 : -1));
1419 __ Subu(result, result, Operand(1));
1437 DeoptimizeIf(eq, instr, divisor, Operand(zero_reg));
1443 __ Branch(&left_not_zero, ne, dividend, Operand(zero_reg));
1444 DeoptimizeIf(lt, instr, divisor, Operand(zero_reg));
1452 __ Branch(&left_not_min_int, ne, dividend, Operand(kMinInt));
1453 DeoptimizeIf(eq, instr, divisor, Operand
1459 __ Branch(&done, eq, remainder, Operand(zero_reg), USE_DELAY_SLOT);
1460 __ Xor(remainder, remainder, Operand(divisor));
1461 __ Branch(&done, ge, remainder, Operand(zero_reg));
1462 __ Subu(result, result, Operand(1));
1484 DeoptimizeIf(eq, instr, left, Operand(zero_reg));
1491 DeoptimizeIf(lt, instr, scratch, Operand(zero_reg));
1500 DeoptimizeIf(lt, instr, left, Operand(zero_reg));
1552 DeoptimizeIf(ne, instr, scratch, Operand(at));
1565 __ Branch(&done, ge, at, Operand(zero_reg));
1567 DeoptimizeIf(eq, instr, result, Operand(zero_reg));
1580 Operand right(no_reg);
1583 right = Operand(EmitLoadRegister(right_op, at));
1619 // No need to mask the right operand on MIPS, it is built into the variable
1623 __ Ror(result, left, Operand(ToRegister(right_op)));
1631 DeoptimizeIf(lt, instr, result, Operand(zero_reg));
1642 // Mask the right_op operand.
1648 __ Ror(result, left, Operand(shift_count));
1665 __ And(at, left, Operand(0x80000000));
1666 DeoptimizeIf(ne, instr, at, Operand(zero_reg));
1681 DeoptimizeIf(lt, instr, scratch, Operand(zero_reg));
1706 __ Subu(ToRegister(result), ToRegister(left), Operand(right_reg));
1729 DeoptimizeIf(lt, instr, overflow, Operand(zero_reg));
1735 __ li(ToRegister(instr->result()), Operand(instr->value()));
1740 __ li(ToRegister(instr->result()), Operand(instr->value()));
1753 __ li(ToRegister(instr->result()), Operand(instr->value()));
1783 DeoptimizeIf(eq, instr, at, Operand(zero_reg));
1785 DeoptimizeIf(ne, instr, scratch, Operand(JS_DATE_TYPE));
1792 __ li(scratch, Operand(stamp));
1795 __ Branch(&runtime, ne, scratch, Operand(scratch0()));
1802 __ li(a1, Operand(index));
1845 Operand(kStringRepresentationMask | kStringEncodingMask));
1848 __ Subu(at, scratch, Operand(encoding == String::ONE_BYTE_ENCODING
1850 __ Check(eq, kUnexpectedStringType, at, Operand(zero_reg));
1853 MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
1855 __ lbu(result, operand);
1857 __ lhu(result, operand);
1878 MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
1880 __ sb(value, operand);
1882 __ sh(value, operand);
1896 __ Addu(ToRegister(result), ToRegister(left), Operand(right_reg));
1920 DeoptimizeIf(lt, instr, overflow, Operand(zero_reg));
1936 __ Slt(scratch, left_reg, Operand(right_reg));
2046 const Operand& src2) {
2094 const Operand& src2) {
2121 EmitBranch(instr, ne, reg, Operand(zero_reg));
2134 EmitBranch(instr, eq, reg, Operand(at));
2137 EmitBranch(instr, ne, reg, Operand(zero_reg));
2140 EmitBranch(instr, al, zero_reg, Operand(zero_reg));
2150 EmitBranch(instr, ne, at, Operand(zero_reg));
2159 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2164 __ Branch(instr->TrueLabel(chunk_), eq, reg, Operand(at));
2166 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2171 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2176 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(zero_reg));
2181 DeoptimizeIf(eq, instr, at, Operand(zero_reg));
2190 __ And(at, at, Operand(1 << Map::kIsUndetectable));
2191 __ Branch(instr->FalseLabel(chunk_), ne, at, Operand(zero_reg));
2199 ge, at, Operand(FIRST_SPEC_OBJECT_TYPE));
2206 __ Branch(¬_string, ge , at, Operand(FIRST_NONSTRING_TYPE));
2208 __ Branch(instr->TrueLabel(chunk_), ne, at, Operand(zero_reg));
2217 __ Branch(instr->TrueLabel(chunk_), eq, scratch, Operand(SYMBOL_TYPE));
2225 __ Branch(¬_heap_number, ne, map, Operand(at));
2237 DeoptimizeIf(al, instr, zero_reg, Operand(zero_reg));
2318 Operand cmp_right = Operand(0);
2324 cmp_right = Operand(Smi::FromInt(value));
2327 cmp_right = Operand(value);
2333 cmp_right = Operand(Smi::FromInt(value));
2336 cmp_right = Operand(value);
2342 cmp_right = Operand(ToRegister(right));
2355 EmitBranch(instr, eq, left, Operand(right));
2362 __ li(at, Operand(factory()->the_hole_value()));
2363 EmitBranch(instr, eq, input_reg, Operand(at));
2372 EmitBranch(instr, eq, scratch, Operand(kHoleNanUpper32));
2394 EmitFalseBranch(instr, ne, scratch, Operand(0x80000000));
2398 EmitBranch(instr, eq, scratch, Operand(at));
2410 __ Branch(is_object, eq, input, Operand(temp2));
2416 __ And(temp2, temp2, Operand(1 << Map::kIsUndetectable));
2417 __ Branch(is_not_object, ne, temp2, Operand(zero_reg));
2422 lt, temp2, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
2438 Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
2466 Operand(FIRST_NONSTRING_TYPE));
2473 EmitBranch(instr, eq, at, Operand(zero_reg));
2486 __ And(at, temp, Operand(1 << Map::kIsUndetectable));
2487 EmitBranch(instr, ne, at, Operand(zero_reg));
2520 EmitBranch(instr, condition, v0, Operand(zero_reg));
2556 Operand(TestType(instr->hydrogen())));
2578 __ And(at, scratch, Operand(String::kContainsCachedArrayIndexMask));
2579 EmitBranch(instr, eq, at, Operand(zero_reg));
2608 __ Branch(is_false, lt, temp2, Operand(FIRST_SPEC_OBJECT_TYPE));
2609 __ Branch(is_true, eq, temp2, Operand(FIRST_SPEC_OBJECT_TYPE));
2610 __ Branch(is_true, eq, temp2, Operand(LAST_SPEC_OBJECT_TYPE));
2615 __ Subu(temp2, temp2, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
2616 __ Branch(is_false, gt, temp2, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE -
2627 __ Branch(is_true, ne, temp2, Operand(JS_FUNCTION_TYPE));
2629 __ Branch(is_false, ne, temp2, Operand(JS_FUNCTION_TYPE));
2658 EmitBranch(instr, eq, temp, Operand(class_name));
2667 EmitBranch(instr, eq, temp, Operand(instr->map()));
2682 __ Branch(&true_label, eq, result, Operand(zero_reg));
2683 __ li(result, Operand(factory()->false_value()));
2686 __ li(result, Operand(factory()->true_value()));
2735 __ li(at, Operand(Handle<Object>(cell)));
2737 __ BranchShort(&cache_miss, ne, map, Operand(at));
2741 __ li(result, Operand(factory()->the_hole_value()), CONSTANT_SIZE);
2749 __ Branch(&false_result, eq, object, Operand(temp));
2753 __ Branch(&false_result, cc, temp, Operand(zero_reg));
2797 __ li(temp, Operand(delta * kPointerSize), CONSTANT_SIZE);
2825 __ Branch(USE_DELAY_SLOT, &done, condition, v0, Operand(zero_reg));
2857 __ Addu(sp, sp, Operand(sp_delta));
2877 __ li(at, Operand(Handle<Object>(instr->hydrogen()->cell().handle())));
2881 DeoptimizeIf(eq, instr, result, Operand(at));
2895 Operand(Smi::FromInt(instr->hydrogen()->slot())));
2905 __ li(LoadDescriptor::NameRegister(), Operand(instr->name()));
2920 __ li(cell, Operand(instr->hydrogen()->cell().handle()));
2931 DeoptimizeIf(eq, instr, payload, Operand(at));
2950 DeoptimizeIf(eq, instr, result, Operand(at));
2953 __ Branch(&is_not_hole, ne, result, Operand(at));
2974 DeoptimizeIf(eq, instr, scratch, Operand(at));
2976 __ Branch(&skip_assignment, ne, scratch, Operand(at));
3006 MemOperand operand = MemOperand(object, offset);
3007 __ Load(result, operand, access.representation());
3022 MemOperand operand = FieldMemOperand(object, offset);
3023 __ Load(result, operand, access.representation());
3033 __ li(LoadDescriptor::NameRegister(), Operand(instr->name()));
3053 DeoptimizeIf(eq, instr, result, Operand(at));
3058 __ Branch(&done, ne, scratch, Operand(MAP_TYPE));
3087 __ li(at, Operand(const_length + 1));
3098 __ Subu(result, length, Operand(loc));
3189 DeoptimizeIf(Ugreater_equal, instr, result, Operand(0x80000000));
3228 __ Addu(scratch, elements, Operand(base_offset));
3242 DeoptimizeIf(eq, instr, scratch, Operand(kHoleNanUpper32));
3278 DeoptimizeIf(ne, instr, scratch, Operand(zero_reg));
3281 DeoptimizeIf(eq, instr, result, Operand(scratch));
3361 __ Xor(temp, result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3378 __ Addu(result, zero_reg, Operand(scope()->num_parameters()));
3379 __ Branch(&done, eq, fp, Operand(elem));
3415 __ And(scratch, scratch, Operand(strict_mode_function_mask | native_mask));
3416 __ Branch(&result_in_receiver, ne, scratch, Operand(zero_reg));
3421 __ Branch(&global_object, eq, receiver, Operand(scratch));
3423 __ Branch(&global_object, eq, receiver, Operand(scratch));
3427 DeoptimizeIf(eq, instr, scratch, Operand(zero_reg));
3430 DeoptimizeIf(lt, instr, scratch, Operand(FIRST_SPEC_OBJECT_TYPE));
3465 DeoptimizeIf(hi, instr, length, Operand(kArgumentsLimit));
3472 __ Addu(elements, elements, Operand(1 * kPointerSize));
3478 __ Branch(USE_DELAY_SLOT, &invoke, eq, length, Operand(zero_reg));
3484 __ Subu(length, length, Operand(1));
3485 __ Branch(USE_DELAY_SLOT, &loop, ne, length, Operand(zero_reg));
3537 __ li(scratch1(), Operand(Smi::FromInt(instr->hydrogen()->flags())));
3567 __ li(a0, Operand(arity));
3595 DeoptimizeIf(ne, instr, scratch, Operand(at));
3604 __ And(at, exponent, Operand(HeapNumber::kSignMask));
3605 __ Branch(&done, eq, at, Operand(zero_reg));
3641 __ And(exponent, exponent, Operand(~HeapNumber::kSignMask));
3658 __ Branch(USE_DELAY_SLOT, &done, ge, input, Operand(zero_reg));
3662 DeoptimizeIf(lt, instr, result, Operand(zero_reg));
3716 DeoptimizeIf(ne, instr, except_flag, Operand(zero_reg));
3721 __ Branch(&done, ne, result, Operand(zero_reg));
3723 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
3724 DeoptimizeIf(ne, instr, scratch1, Operand(zero_reg));
3746 __ Branch(&skip1, gt, scratch, Operand(HeapNumber::kExponentBias - 2));
3757 DeoptimizeIf(ge, instr, scratch, Operand(HeapNumber::kExponentBias + 32));
3760 __ And(scratch, result, Operand(HeapNumber::kSignMask));
3768 __ Xor(result, result, Operand(scratch));
3771 DeoptimizeIf(lt, instr, result, Operand(zero_reg));
3776 __ Branch(&skip2, ge, result, Operand(zero_reg));
3790 DeoptimizeIf(ne, instr, except_flag, Operand(zero_reg));
3794 __ Branch(&done, ne, result, Operand(zero_reg));
3797 __ And(scratch, scratch, Operand(HeapNumber::kSignMask));
3798 DeoptimizeIf(ne, instr, scratch, Operand(zero_reg));
3864 DeoptimizeIf(ne, instr, t3, Operand(at));
3973 __ Addu(target, target, Operand(Code::kHeaderSize - kHeapObjectTag));
3985 __ li(a0, Operand(instr->arity()));
4015 __ li(a0, Operand(instr->arity()));
4028 __ li(a0, Operand(instr->arity()));
4046 __ Branch(&packed_case, eq, t1, Operand(zero_reg));
4076 Operand(Code::kHeaderSize - kHeapObjectTag));
4087 __ Addu(result, base, Operand(ToInteger32(offset)));
4105 MemOperand operand = MemOperand(object, offset);
4106 __ Store(value, operand, representation);
4127 __ li(scratch, Operand(transition));
4143 MemOperand operand = FieldMemOperand(object, offset);
4144 __ Store(value, operand, representation);
4159 MemOperand operand = FieldMemOperand(scratch, offset);
4160 __ Store(value, operand, representation);
4183 __ li(StoreDescriptor::NameRegister(), Operand(instr->name()));
4191 Operand operand(0);
4194 operand = ToOperand(instr->index());
4199 operand = ToOperand(instr->length());
4203 __ Branch(&done, NegateCondition(cc), reg, operand);
4207 DeoptimizeIf(cc, instr, reg, operand);
4240 Operand(constant_key << element_size_shift));
4320 Operand((constant_key << element_size_shift) + base_offset));
4324 __ Addu(scratch, elements, Operand(base_offset));
4384 __ Addu(key, store_base, Operand(offset));
4432 __ Branch(¬_applicable, ne, scratch, Operand(from_map));
4436 __ li(new_map_reg, Operand(to_map));
4448 __ li(a1, Operand(to_map));
4521 __ Addu(scratch, zero_reg, Operand(Smi::FromInt(const_index)));
4559 char_code, Operand(String::kMaxOneByteCharCode));
4565 __ Branch(deferred->entry(), eq, result, Operand(scratch));
4663 __ Branch(deferred->entry(), hi, input, Operand(Smi::kMaxValue));
4688 __ Xor(src, src, Operand(0x80000000));
4799 __ And(at, input, Operand(0xc0000000));
4800 DeoptimizeIf(ne, instr, at, Operand(zero_reg));
4805 DeoptimizeIf(lt, instr, at, Operand(zero_reg));
4819 __ And(scratch, input, Operand(kHeapObjectTag));
4821 DeoptimizeIf(ne, instr, scratch, Operand(zero_reg));
4844 __ Branch(&convert, ne, scratch, Operand(at));
4846 DeoptimizeIf(ne, instr, scratch, Operand(at));
4852 __ Branch(&done, ne, at, Operand(zero_reg));
4854 DeoptimizeIf(eq, instr, scratch, Operand(HeapNumber::kSignMask));
4861 DeoptimizeIf(ne, instr, input_reg, Operand(at));
4903 __ Branch(USE_DELAY_SLOT, &no_heap_number, ne, scratch1, Operand(at));
4912 __ Branch(&check_bools, ne, input_reg, Operand(at));
4919 __ Branch(&check_false, ne, scratch2, Operand(at));
4921 __ li(input_reg, Operand(1)); // In delay slot.
4925 DeoptimizeIf(ne, instr, scratch2, Operand(at), "cannot truncate");
4929 DeoptimizeIf(ne, instr, scratch1, Operand(at), "not a heap number");
4944 DeoptimizeIf(ne, instr, except_flag, Operand(zero_reg),
4948 __ Branch(&done, ne, input_reg, Operand(zero_reg));
4951 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4952 DeoptimizeIf(ne, instr, scratch1, Operand(zero_reg), "minus zero");
5029 DeoptimizeIf(ne, instr, except_flag, Operand(zero_reg));
5033 __ Branch(&done, ne, result_reg, Operand(zero_reg));
5035 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
5036 DeoptimizeIf(ne, instr, scratch1, Operand(zero_reg));
5062 DeoptimizeIf(ne, instr, except_flag, Operand(zero_reg));
5066 __ Branch(&done, ne, result_reg, Operand(zero_reg));
5068 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
5069 DeoptimizeIf(ne, instr, scratch1, Operand(zero_reg));
5074 DeoptimizeIf(lt, instr, scratch1, Operand(zero_reg));
5081 DeoptimizeIf(ne, instr, at, Operand(zero_reg));
5089 DeoptimizeIf(eq, instr, at, Operand(zero_reg));
5107 DeoptimizeIf(ne, instr, scratch, Operand(first));
5109 DeoptimizeIf(lo, instr, scratch, Operand(first));
5112 DeoptimizeIf(hi, instr, scratch, Operand(last));
5123 DeoptimizeIf(tag == 0 ? ne : eq, instr, at, Operand(zero_reg));
5125 __ And(scratch, scratch, Operand(mask));
5126 DeoptimizeIf(ne, instr, scratch, Operand(tag));
5139 __ li(at, Operand(Handle<Object>(cell)));
5141 DeoptimizeIf(ne, instr, reg, Operand(at));
5143 DeoptimizeIf(ne, instr, reg, Operand(object));
5159 DeoptimizeIf(eq, instr, at, Operand(zero_reg));
5210 __ Branch(deferred->entry(), ne, map_reg, Operand(map));
5212 DeoptimizeIf(ne, instr, map_reg, Operand(map));
5246 __ Branch(&heap_number, eq, scratch, Operand(factory()->heap_number_map()));
5250 DeoptimizeIf(ne, instr, input_reg, Operand(factory()->undefined_value()));
5338 __ li(scratch, Operand(size - kHeapObjectTag));
5340 __ Subu(scratch, ToRegister(instr->size()), Operand(kHeapObjectTag));
5342 __ li(scratch2, Operand(isolate()->factory()->one_pointer_filler_map()));
5345 __ Subu(scratch, scratch, Operand(kPointerSize));
5346 __ Addu(at, result, Operand(scratch));
5348 __ Branch(&loop, ge, scratch, Operand(zero_reg));
5419 __ Branch(&materialized, ne, a1, Operand(at));
5423 __ li(t2, Operand(Smi::FromInt(instr->hydrogen()->literal_index())));
5424 __ li(t1, Operand(instr->hydrogen()->pattern()));
5425 __ li(t0, Operand(instr->hydrogen()->flags()));
5438 __ li(a0, Operand(Smi::FromInt(size)));
5467 __ li(a2, Operand(instr->hydrogen()->shared_info()));
5470 __ li(a2, Operand(instr->hydrogen()->shared_info()));
5471 __ li(a1, Operand(pretenure ? factory()->true_value()
5491 Operand cmp2 = Operand(no_reg);
5514 Operand* cmp2) {
5526 *cmp2 = Operand(at);
5533 ge, scratch, Operand(FIRST_NONSTRING_TYPE));
5539 *cmp2 = Operand(zero_reg);
5546 *cmp2 = Operand(SYMBOL_TYPE);
5551 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5554 *cmp2 = Operand(input);
5559 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5568 *cmp2 = Operand(zero_reg);
5575 __ Branch(true_label, eq, input, Operand(JS_FUNCTION_TYPE));
5577 *cmp2 = Operand(JS_FUNCTION_PROXY_TYPE);
5583 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5587 lt, scratch, Operand(FIRST_NONCALLABLE_SPEC_OBJECT_TYPE));
5589 gt, scratch, Operand(LAST_NONCALLABLE_SPEC_OBJECT_TYPE));
5595 *cmp2 = Operand(zero_reg);
5600 *cmp2 = Operand(zero_reg); // Set to valid regs, to avoid caller assertion.
5614 Operand(Smi::FromInt(StackFrame::CONSTRUCT)));
5627 Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
5673 DeoptimizeIf(al, instr, type, zero_reg, Operand(zero_reg),
5721 __ Branch(&done, hs, sp, Operand(at));
5734 __ Branch(deferred_stack_check->entry(), lo, sp, Operand(at));
5765 DeoptimizeIf(eq, instr, object, Operand(at));
5769 DeoptimizeIf(eq, instr, object, Operand(null_value));
5772 DeoptimizeIf(eq, instr, at, Operand(zero_reg));
5776 DeoptimizeIf(le, instr, a1, Operand(LAST_JS_PROXY_TYPE));
5793 DeoptimizeIf(ne, instr, a1, Operand(at));
5803 __ Branch(&load_cache, ne, result, Operand(Smi::FromInt(0)));
5804 __ li(result, Operand(isolate()->factory()->empty_fixed_array()));
5813 DeoptimizeIf(eq, instr, result, Operand(zero_reg));
5823 DeoptimizeIf(ne, instr, map, Operand(scratch0()));
5877 __ And(scratch, index, Operand(Smi::FromInt(1)));
5878 __ Branch(deferred->entry(), ne, scratch, Operand(zero_reg));
5881 __ Branch(USE_DELAY_SLOT, &out_of_object, lt, index, Operand(zero_reg));
