Lines Matching refs:Operand
132 __ Dsubu(sp, sp, Operand(slots * kPointerSize));
134 __ Daddu(a0, sp, Operand(slots * kPointerSize));
135 __ li(a1, Operand(kSlotsZapValue));
138 __ Dsubu(a0, a0, Operand(kPointerSize));
140 __ Branch(&loop, ne, a0, Operand(sp));
143 __ Dsubu(sp, sp, Operand(slots * kPointerSize));
227 __ Dsubu(sp, sp, Operand(slots * kPointerSize));
264 __ li(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));
267 Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
312 __ li(t9, Operand(entry - base));
315 __ li(t9, Operand(entry - base));
319 __ li(t9, Operand(entry - base));
338 __ li(at, Operand(Smi::FromInt(StackFrame::STUB)));
340 __ Daddu(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
352 Operand(reinterpret_cast<int64_t>(base), RelocInfo::RUNTIME_ENTRY));
353 __ Daddu(t9, t9, Operand(at));
397 __ li(scratch, Operand(static_cast<int32_t>(literal->Number())));
400 __ li(scratch, Operand(Smi::FromInt(constant->Integer32Value())));
435 __ li(at, Operand(static_cast<int32_t>(literal->Number())));
501 Operand LCodeGen::ToOperand(LOperand* op) {
508 return Operand(Smi::FromInt(constant->Integer32Value()));
511 return Operand(constant->Integer32Value());
516 return Operand(constant->handle(isolate()));
518 return Operand(ToRegister(op));
521 return Operand((int64_t)0);
525 return Operand((int64_t)0);
757 Register src1, const Operand& src2) {
774 __ li(scratch, Operand(count));
776 __ Subu(a1, a1, Operand(1));
777 __ Branch(&no_deopt, ne, a1, Operand(zero_reg));
778 __ li(a1, Operand(FLAG_deopt_every_n_times));
825 Register src1, const Operand& src2) {
979 __ Branch(÷nd_is_not_negative, ge, dividend, Operand(zero_reg));
982 __ And(dividend, dividend, Operand(mask));
985 Operand(zero_reg));
992 __ And(dividend, dividend, Operand(mask));
1009 __ Dmul(result, result, Operand(Abs(divisor)));
1010 __ Dsubu(result, dividend, Operand(result));
1016 __ Branch(&remainder_not_zero, ne, result, Operand(zero_reg));
1018 Operand(zero_reg));
1038 Operand(zero_reg));
1045 __ Branch(&no_overflow_possible, ne, left_reg, Operand(kMinInt));
1047 DeoptimizeIf(eq, instr, Deoptimizer::kMinusZero, right_reg, Operand(-1));
1049 __ Branch(&no_overflow_possible, ne, right_reg, Operand(-1));
1057 __ Branch(&done, ge, left_reg, Operand(zero_reg));
1061 Operand(zero_reg));
1078 Operand(zero_reg));
1082 DeoptimizeIf(eq, instr, Deoptimizer::kOverflow, dividend, Operand(kMinInt));
1088 __ And(at, dividend, Operand(mask));
1089 DeoptimizeIf(ne, instr, Deoptimizer::kLostPrecision, at, Operand(zero_reg));
1101 __ Daddu(result, dividend, Operand(result));
1105 __ Daddu(result, dividend, Operand(result));
1127 Operand(zero_reg));
1134 __ Dmul(scratch0(), result, Operand(divisor));
1137 Operand(zero_reg));
1156 Operand(zero_reg));
1162 __ Branch(&left_not_zero, ne, dividend, Operand(zero_reg));
1164 Operand(zero_reg));
1172 __ Branch(&left_not_min_int, ne, dividend, Operand(kMinInt));
1173 DeoptimizeIf(eq, instr, Deoptimizer::kOverflow, divisor, Operand(-1));
1186 Operand(zero_reg));
1231 DeoptimizeIf(eq, instr, Deoptimizer::kMinusZero, result, Operand(zero_reg));
1238 DeoptimizeIf(gt, instr, Deoptimizer::kOverflow, result, Operand(kMaxInt));
1250 __ Branch(&no_overflow, lt, scratch, Operand(zero_reg));
1251 __ li(result, Operand(kMinInt / divisor), CONSTANT_SIZE);
1274 Operand(zero_reg));
1292 dividend, Operand(zero_reg));
1297 __ Daddu(temp, dividend, Operand(divisor > 0 ? 1 : -1));
1300 __ Dsubu(result, result, Operand(1));
1319 Operand(zero_reg));
1325 __ Branch(&left_not_zero, ne, dividend, Operand(zero_reg));
1327 Operand(zero_reg));
1335 __ Branch(&left_not_min_int, ne, dividend, Operand(kMinInt));
1336 DeoptimizeIf(eq, instr, Deoptimizer::kOverflow, divisor, Operand(-1));
1348 __ Branch(&done, eq, remainder, Operand(zero_reg), USE_DELAY_SLOT);
1349 __ Xor(remainder, remainder, Operand(divisor));
1350 __ Branch(&done, ge, remainder, Operand(zero_reg));
1351 __ Dsubu(result, result, Operand(1));
1373 DeoptimizeIf(eq, instr, Deoptimizer::kMinusZero, left, Operand(zero_reg));
1381 Operand(zero_reg));
1391 Operand(zero_reg));
1439 DeoptimizeIf(ne, instr, Deoptimizer::kOverflow, scratch, Operand(at));
1448 __ Branch(&done, ge, at, Operand(zero_reg));
1451 Operand(zero_reg));
1475 DeoptimizeIf(eq, instr, Deoptimizer::kMinusZero, left, Operand(zero_reg));
1483 Operand(zero_reg));
1493 Operand(zero_reg));
1542 DeoptimizeIf(ne, instr, Deoptimizer::kOverflow, scratch, Operand(at));
1550 __ Branch(&done, ge, at, Operand(zero_reg));
1553 Operand(zero_reg));
1566 Operand right(no_reg);
1569 right = Operand(EmitLoadRegister(right_op, at));
1604 // No need to mask the right operand on MIPS, it is built into the variable
1608 __ Ror(result, left, Operand(ToRegister(right_op)));
1618 Operand(zero_reg));
1620 Operand(kMaxInt));
1631 // Mask the right_op operand.
1637 __ Ror(result, left, Operand(shift_count));
1654 __ And(at, left, Operand(0x80000000));
1656 Operand(zero_reg));
1696 Operand(zero_reg));
1717 Operand(zero_reg));
1723 __ li(ToRegister(instr->result()), Operand(instr->value()));
1728 __ li(ToRegister(instr->result()), Operand(instr->value()));
1741 __ li(ToRegister(instr->result()), Operand(instr->value()));
1795 Operand(kStringRepresentationMask | kStringEncodingMask));
1798 __ Dsubu(at, scratch, Operand(encoding == String::ONE_BYTE_ENCODING
1800 __ Check(eq, kUnexpectedStringType, at, Operand(zero_reg));
1803 MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
1805 __ lbu(result, operand);
1807 __ lhu(result, operand);
1828 MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
1830 __ sb(value, operand);
1832 __ sh(value, operand);
1864 Operand(zero_reg));
1885 Operand(zero_reg));
1901 __ Slt(scratch, left_reg, Operand(right_reg));
2011 const Operand& src2) {
2057 Register src1, const Operand& src2) {
2065 Register src1, const Operand& src2) {
2092 EmitBranch(instr, ne, reg, Operand(zero_reg));
2105 EmitBranch(instr, eq, reg, Operand(at));
2108 EmitBranch(instr, ne, reg, Operand(zero_reg));
2111 EmitBranch(instr, al, zero_reg, Operand(zero_reg));
2121 EmitBranch(instr, ne, at, Operand(zero_reg));
2130 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2135 __ Branch(instr->TrueLabel(chunk_), eq, reg, Operand(at));
2137 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2142 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2147 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(zero_reg));
2152 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, at, Operand(zero_reg));
2161 __ And(at, at, Operand(1 << Map::kIsUndetectable));
2162 __ Branch(instr->FalseLabel(chunk_), ne, at, Operand(zero_reg));
2170 ge, at, Operand(FIRST_JS_RECEIVER_TYPE));
2177 __ Branch(¬_string, ge , at, Operand(FIRST_NONSTRING_TYPE));
2179 __ Branch(instr->TrueLabel(chunk_), ne, at, Operand(zero_reg));
2188 __ Branch(instr->TrueLabel(chunk_), eq, scratch, Operand(SYMBOL_TYPE));
2196 Operand(SIMD128_VALUE_TYPE));
2204 __ Branch(¬_heap_number, ne, map, Operand(at));
2217 Operand(zero_reg));
2298 Operand cmp_right = Operand((int64_t)0);
2303 cmp_right = Operand(Smi::FromInt(value));
2306 cmp_right = Operand(value);
2312 cmp_right = Operand(Smi::FromInt(value));
2315 cmp_right = Operand(value);
2321 cmp_right = Operand(ToRegister(right));
2334 EmitBranch(instr, eq, left, Operand(right));
2341 __ li(at, Operand(factory()->the_hole_value()));
2342 EmitBranch(instr, eq, input_reg, Operand(at));
2352 Operand(static_cast<int32_t>(kHoleNanUpper32)));
2377 EmitFalseBranch(instr, ne, scratch, Operand(0x80000000));
2381 EmitBranch(instr, eq, scratch, Operand(at));
2409 Operand(FIRST_NONSTRING_TYPE));
2416 EmitBranch(instr, eq, at, Operand(zero_reg));
2429 __ And(at, temp, Operand(1 << Map::kIsUndetectable));
2430 EmitBranch(instr, ne, at, Operand(zero_reg));
2463 Operand(zero_reg));
2499 Operand(TestType(instr->hydrogen())));
2521 __ And(at, scratch, Operand(String::kContainsCachedArrayIndexMask));
2522 EmitBranch(instr, eq, at, Operand(zero_reg));
2542 __ Branch(is_true, eq, temp2, Operand(JS_FUNCTION_TYPE));
2544 __ Branch(is_false, eq, temp2, Operand(JS_FUNCTION_TYPE));
2555 __ Branch(is_true, ne, instance_type, Operand(JS_FUNCTION_TYPE));
2557 __ Branch(is_false, ne, instance_type, Operand(JS_FUNCTION_TYPE));
2586 EmitBranch(instr, eq, temp, Operand(class_name));
2595 EmitBranch(instr, eq, temp, Operand(instr->map()));
2624 EmitFalseBranch(instr, eq, at, Operand(zero_reg));
2636 Operand(1 << Map::kIsAccessCheckNeeded));
2638 Operand(zero_reg));
2642 Operand(JS_PROXY_TYPE));
2645 EmitTrueBranch(instr, eq, object_prototype, Operand(prototype));
2647 EmitFalseBranch(instr, eq, object_prototype, Operand(at));
2668 __ Branch(USE_DELAY_SLOT, &done, condition, v0, Operand(zero_reg));
2698 __ Daddu(sp, sp, Operand(sp_delta));
2726 __ li(slot_register, Operand(Smi::FromInt(index)));
2740 __ li(slot_register, Operand(Smi::FromInt(index)));
2750 __ li(LoadDescriptor::NameRegister(), Operand(instr->name()));
2768 DeoptimizeIf(eq, instr, Deoptimizer::kHole, result, Operand(at));
2771 __ Branch(&is_not_hole, ne, result, Operand(at));
2792 DeoptimizeIf(eq, instr, Deoptimizer::kHole, scratch, Operand(at));
2794 __ Branch(&skip_assignment, ne, scratch, Operand(at));
2823 MemOperand operand = MemOperand(object, offset);
2824 __ Load(result, operand, access.representation());
2866 __ li(LoadDescriptor::NameRegister(), Operand(instr->name()));
2887 DeoptimizeIf(eq, instr, Deoptimizer::kHole, result, Operand(at));
2892 __ Branch(&done, ne, scratch, Operand(MAP_TYPE));
2921 __ li(at, Operand(const_length + 1));
2932 __ Dsubu(result, length, Operand(loc));
3022 result, Operand(0x80000000));
3060 __ Daddu(scratch, elements, Operand(base_offset));
3082 Operand(static_cast<int32_t>(kHoleNanUpper32)));
3137 Operand(zero_reg));
3140 DeoptimizeIf(eq, instr, Deoptimizer::kHole, result, Operand(scratch));
3146 __ Branch(&done, ne, result, Operand(scratch));
3155 Operand(Smi::FromInt(Isolate::kArrayProtectorValid)));
3245 __ Xor(temp, result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3262 __ Daddu(result, zero_reg, Operand(scope()->num_parameters()));
3263 __ Branch(&done, eq, fp, Operand(elem));
3299 __ And(at, at, Operand(strict_mode_function_mask));
3300 __ Branch(&result_in_receiver, ne, at, Operand(zero_reg));
3303 __ And(at, at, Operand(native_mask));
3304 __ Branch(&result_in_receiver, ne, at, Operand(zero_reg));
3309 __ Branch(&global_object, eq, receiver, Operand(scratch));
3311 __ Branch(&global_object, eq, receiver, Operand(scratch));
3315 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, scratch, Operand(zero_reg));
3319 Operand(FIRST_JS_RECEIVER_TYPE));
3353 Operand(kArgumentsLimit));
3360 __ Daddu(elements, elements, Operand(1 * kPointerSize));
3366 __ Branch(USE_DELAY_SLOT, &invoke, eq, length, Operand(zero_reg));
3372 __ Dsubu(length, length, Operand(1));
3373 __ Branch(USE_DELAY_SLOT, &loop, ne, length, Operand(zero_reg));
3426 __ li(scratch1(), Operand(Smi::FromInt(instr->hydrogen()->flags())));
3449 __ li(a0, Operand(arity));
3476 DeoptimizeIf(ne, instr, Deoptimizer::kNotAHeapNumber, scratch, Operand(at));
3485 __ And(at, exponent, Operand(HeapNumber::kSignMask));
3486 __ Branch(&done, eq, at, Operand(zero_reg));
3522 __ And(exponent, exponent, Operand(~HeapNumber::kSignMask));
3539 __ Branch(USE_DELAY_SLOT, &done, ge, input, Operand(zero_reg));
3543 DeoptimizeIf(lt, instr, Deoptimizer::kOverflow, result, Operand(zero_reg));
3553 __ Branch(USE_DELAY_SLOT, &done, ge, input, Operand(zero_reg));
3557 DeoptimizeIf(lt, instr, Deoptimizer::kOverflow, result, Operand(zero_reg));
3615 Operand(zero_reg));
3620 __ Branch(&done, ne, result, Operand(zero_reg));
3622 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
3624 Operand(zero_reg));
3646 __ Branch(&skip1, gt, scratch, Operand(HeapNumber::kExponentBias - 2));
3658 Operand(HeapNumber::kExponentBias + 32));
3661 __ And(scratch, result, Operand(HeapNumber::kSignMask));
3672 __ Xor(result, result, Operand(scratch));
3675 DeoptimizeIf(lt, instr, Deoptimizer::kMinusZero, result, Operand(zero_reg));
3680 __ Branch(&skip2, ge, result, Operand(zero_reg));
3695 Operand(zero_reg));
3699 __ Branch(&done, ne, result, Operand(zero_reg));
3702 __ And(scratch, scratch, Operand(HeapNumber::kSignMask));
3704 Operand(zero_reg));
3770 DeoptimizeIf(ne, instr, Deoptimizer::kNotAHeapNumber, a7, Operand(at));
3847 __ Daddu(target, target, Operand(Code::kHeaderSize - kHeapObjectTag));
3863 __ Daddu(target, target, Operand(Code::kHeaderSize - kHeapObjectTag));
3880 __ li(a0, Operand(instr->arity()));
3908 __ li(slot_register, Operand(Smi::FromInt(index)));
3914 __ li(a0, Operand(arity));
3925 __ li(a0, Operand(instr->arity()));
3950 __ Branch(&packed_case, eq, a5, Operand(zero_reg));
3980 Operand(Code::kHeaderSize - kHeapObjectTag));
3991 __ Daddu(result, base, Operand(ToInteger32(offset)));
4010 MemOperand operand = MemOperand(object, offset);
4011 __ Store(value, operand, representation);
4032 __ li(scratch1, Operand(transition));
4063 MemOperand operand = FieldMemOperand(destination, offset);
4068 __ sdc1(value, operand);
4072 __ Store(value, operand, representation);
4100 __ li(StoreDescriptor::NameRegister(), Operand(instr->name()));
4110 Operand operand((int64_t)0);
4113 operand = ToOperand(instr->index());
4118 operand = ToOperand(instr->length());
4122 __ Branch(&done, NegateCondition(cc), reg, operand);
4126 DeoptimizeIf(cc, instr, Deoptimizer::kOutOfBounds, reg, operand);
4157 Operand(constant_key << element_size_shift));
4236 Operand((constant_key << element_size_shift) + base_offset));
4241 __ Daddu(scratch, elements, Operand(base_offset));
4313 __ Daddu(key, store_base, Operand(offset));
4390 Operand(constant_key));
4395 Operand(constant_capacity));
4398 Operand(ToRegister(current_capacity)));
4429 __ li(a3, Operand(ToSmi(LConstantOperand::cast(key))));
4446 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, at, Operand(zero_reg));
4461 __ Branch(¬_applicable, ne, scratch, Operand(from_map));
4465 __ li(new_map_reg, Operand(to_map));
4477 __ li(a1, Operand(to_map));
4549 __ Daddu(scratch, zero_reg, Operand(Smi::FromInt(const_index)));
4588 char_code, Operand(String::kMaxOneByteCharCode));
4594 __ Branch(deferred->entry(), eq, result, Operand(scratch));
4666 __ Branch(deferred->entry(), hi, input, Operand(Smi::kMaxValue));
4691 __ Xor(src, src, Operand(0x80000000));
4797 __ And(at, input, Operand(0x80000000));
4798 DeoptimizeIf(ne, instr, Deoptimizer::kOverflow, at, Operand(zero_reg));
4803 DeoptimizeIf(lt, instr, Deoptimizer::kOverflow, at, Operand(zero_reg));
4817 __ And(scratch, input, Operand(kHeapObjectTag));
4819 DeoptimizeIf(ne, instr, Deoptimizer::kNotASmi, scratch, Operand(zero_reg));
4842 __ Branch(&convert, ne, scratch, Operand(at));
4845 Operand(at));
4851 __ Branch(&done, ne, at, Operand(zero_reg));
4854 Operand(HeapNumber::kSignMask));
4862 Operand(at));
4904 __ Branch(USE_DELAY_SLOT, &no_heap_number, ne, scratch1, Operand(at));
4913 __ Branch(&check_bools, ne, input_reg, Operand(at));
4920 __ Branch(&check_false, ne, scratch2, Operand(at));
4922 __ li(input_reg, Operand(1)); // In delay slot.
4927 scratch2, Operand(at));
4932 Operand(at));
4948 Operand(zero_reg));
4951 __ Branch(&done, ne, input_reg, Operand(zero_reg));
4954 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4956 Operand(zero_reg));
5033 Operand(zero_reg));
5037 __ Branch(&done, ne, result_reg, Operand(zero_reg));
5039 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
5041 Operand(zero_reg));
5068 Operand(zero_reg));
5072 __ Branch(&done, ne, result_reg, Operand(zero_reg));
5074 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
5076 Operand(zero_reg));
5087 DeoptimizeIf(ne, instr, Deoptimizer::kNotASmi, at, Operand(zero_reg));
5095 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, at, Operand(zero_reg));
5108 DeoptimizeIf(ne, instr, Deoptimizer::kOutOfBounds, at, Operand(zero_reg));
5126 Operand(first));
5129 Operand(first));
5133 Operand(last));
5145 at, Operand(zero_reg));
5147 __ And(scratch, scratch, Operand(mask));
5149 Operand(tag));
5162 __ li(at, Operand(cell));
5164 DeoptimizeIf(ne, instr, Deoptimizer::kValueMismatch, reg, Operand(at));
5166 DeoptimizeIf(ne, instr, Deoptimizer::kValueMismatch, reg, Operand(object));
5183 Operand(zero_reg));
5235 __ Branch(deferred->entry(), ne, map_reg, Operand(map));
5237 DeoptimizeIf(ne, instr, Deoptimizer::kWrongMap, map_reg, Operand(map));
5271 __ Branch(&heap_number, eq, scratch, Operand(factory()->heap_number_map()));
5276 Operand(factory()->undefined_value()));
5356 __ li(scratch, Operand(size - kHeapObjectTag));
5358 __ Dsubu(scratch, ToRegister(instr->size()), Operand(kHeapObjectTag));
5360 __ li(scratch2, Operand(isolate()->factory()->one_pointer_filler_map()));
5363 __ Dsubu(scratch, scratch, Operand(kPointerSize));
5364 __ Daddu(at, result, Operand(scratch));
5366 __ Branch(&loop, ge, scratch, Operand(zero_reg));
5388 __ li(v0, Operand(Smi::FromInt(size)));
5405 __ li(v0, Operand(Smi::FromInt(flags)));
5428 __ li(v0, Operand(isolate()->factory()->number_string()));
5441 Operand cmp2 = Operand(no_reg);
5464 Operand* cmp2) {
5476 *cmp2 = Operand(at);
5483 *cmp2 = Operand(FIRST_NONSTRING_TYPE);
5490 *cmp2 = Operand(SYMBOL_TYPE);
5495 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5498 *cmp2 = Operand(input);
5503 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5512 *cmp2 = Operand(zero_reg);
5520 Operand((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
5522 *cmp2 = Operand(1 << Map::kIsCallable);
5528 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5531 __ Branch(false_label, lt, scratch1(), Operand(FIRST_JS_RECEIVER_TYPE));
5535 Operand((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
5537 *cmp2 = Operand(zero_reg);
5547 *cmp2 = Operand(at); \
5556 *cmp2 = Operand(zero_reg); // Set to valid regs, to avoid caller assertion.
5602 Operand(zero_reg));
5648 __ Branch(&done, hs, sp, Operand(at));
5661 __ Branch(deferred_stack_check->entry(), lo, sp, Operand(at));
5693 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, at, Operand(zero_reg));
5698 Operand(JS_PROXY_TYPE));
5717 DeoptimizeIf(ne, instr, Deoptimizer::kWrongMap, a1, Operand(at));
5727 __ Branch(&load_cache, ne, result, Operand(Smi::FromInt(0)));
5728 __ li(result, Operand(isolate()->factory()->empty_fixed_array()));
5737 DeoptimizeIf(eq, instr, Deoptimizer::kNoCache, result, Operand(zero_reg));
5747 DeoptimizeIf(ne, instr, Deoptimizer::kWrongMap, map, Operand(scratch0()));
5802 __ And(scratch, index, Operand(Smi::FromInt(1)));
5803 __ Branch(deferred->entry(), ne, scratch, Operand(zero_reg));
5806 __ Branch(USE_DELAY_SLOT, &out_of_object, lt, index, Operand(zero_reg));
