Lines Matching refs:Operand
157 __ Subu(sp, sp, Operand(slots * kPointerSize));
159 __ Addu(a0, sp, Operand(slots * kPointerSize));
160 __ li(a1, Operand(kSlotsZapValue));
163 __ Subu(a0, a0, Operand(kPointerSize));
165 __ Branch(&loop, ne, a0, Operand(sp));
168 __ Subu(sp, sp, Operand(slots * kPointerSize));
252 __ Subu(sp, sp, Operand(slots * kPointerSize));
289 __ li(scratch0(), Operand(Smi::FromInt(StackFrame::STUB)));
291 __ Addu(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
333 __ li(entry_offset, Operand(entry - base));
353 __ li(at, Operand(Smi::FromInt(StackFrame::STUB)));
355 __ Addu(fp, sp, Operand(StandardFrameConstants::kFixedFrameSizeFromFp));
368 Operand(ExternalReference::ForDeoptEntry(base)));
414 __ li(scratch, Operand(static_cast<int32_t>(literal->Number())));
417 __ li(scratch, Operand(Smi::FromInt(constant->Integer32Value())));
452 __ li(at, Operand(static_cast<int32_t>(literal->Number())));
516 Operand LCodeGen::ToOperand(LOperand* op) {
523 return Operand(Smi::FromInt(constant->Integer32Value()));
526 return Operand(constant->Integer32Value());
531 return Operand(constant->handle(isolate()));
533 return Operand(ToRegister(op));
536 return Operand(0);
540 return Operand(0);
769 Register src1, const Operand& src2) {
786 __ li(scratch, Operand(count));
788 __ Subu(a1, a1, Operand(1));
789 __ Branch(&no_deopt, ne, a1, Operand(zero_reg));
790 __ li(a1, Operand(FLAG_deopt_every_n_times));
836 Register src1, const Operand& src2) {
990 __ Branch(÷nd_is_not_negative, ge, dividend, Operand(zero_reg));
993 __ And(dividend, dividend, Operand(mask));
996 Operand(zero_reg));
1003 __ And(dividend, dividend, Operand(mask));
1020 __ Mul(result, result, Operand(Abs(divisor)));
1021 __ Subu(result, dividend, Operand(result));
1027 __ Branch(&remainder_not_zero, ne, result, Operand(zero_reg));
1029 Operand(zero_reg));
1049 Operand(zero_reg));
1056 __ Branch(&no_overflow_possible, ne, left_reg, Operand(kMinInt));
1058 DeoptimizeIf(eq, instr, Deoptimizer::kMinusZero, right_reg, Operand(-1));
1060 __ Branch(&no_overflow_possible, ne, right_reg, Operand(-1));
1068 __ Branch(&done, ge, left_reg, Operand(zero_reg));
1071 Operand(zero_reg));
1088 Operand(zero_reg));
1092 DeoptimizeIf(eq, instr, Deoptimizer::kOverflow, dividend, Operand(kMinInt));
1098 __ And(at, dividend, Operand(mask));
1099 DeoptimizeIf(ne, instr, Deoptimizer::kLostPrecision, at, Operand(zero_reg));
1111 __ Addu(result, dividend, Operand(result));
1115 __ Addu(result, dividend, Operand(result));
1137 Operand(zero_reg));
1144 __ Mul(scratch0(), result, Operand(divisor));
1147 Operand(zero_reg));
1167 Operand(zero_reg));
1173 __ Branch(&left_not_zero, ne, dividend, Operand(zero_reg));
1175 Operand(zero_reg));
1183 __ Branch(&left_not_min_int, ne, dividend, Operand(kMinInt));
1184 DeoptimizeIf(eq, instr, Deoptimizer::kOverflow, divisor, Operand(-1));
1190 Operand(zero_reg));
1236 DeoptimizeIf(eq, instr, Deoptimizer::kMinusZero, result, Operand(zero_reg));
1244 Operand(zero_reg));
1256 __ Branch(&no_overflow, lt, scratch, Operand(zero_reg));
1257 __ li(result, Operand(kMinInt / divisor));
1280 Operand(zero_reg));
1298 dividend, Operand(zero_reg));
1303 __ Addu(temp, dividend, Operand(divisor > 0 ? 1 : -1));
1306 __ Subu(result, result, Operand(1));
1325 Operand(zero_reg));
1331 __ Branch(&left_not_zero, ne, dividend, Operand(zero_reg));
1333 Operand(zero_reg));
1341 __ Branch(&left_not_min_int, ne, dividend, Operand(kMinInt));
1342 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 __ Subu(result, result, Operand(1));
1373 DeoptimizeIf(eq, instr, Deoptimizer::kMinusZero, left, Operand(zero_reg));
1380 __ SubBranchNoOvf(result, zero_reg, Operand(left), &no_overflow);
1392 Operand(zero_reg));
1444 DeoptimizeIf(ne, instr, Deoptimizer::kOverflow, scratch, Operand(at));
1457 __ Branch(&done, ge, at, Operand(zero_reg));
1460 Operand(zero_reg));
1473 Operand right(no_reg);
1476 right = Operand(EmitLoadRegister(right_op, at));
1512 // No need to mask the right operand on MIPS, it is built into the variable
1516 __ Ror(result, left, Operand(ToRegister(right_op)));
1525 Operand(zero_reg));
1536 // Mask the right_op operand.
1542 __ Ror(result, left, Operand(shift_count));
1559 __ And(at, left, Operand(0x80000000));
1561 Operand(zero_reg));
1577 Operand(zero_reg));
1602 __ Subu(ToRegister(result), ToRegister(left), Operand(right_reg));
1613 Operand(right_reg), &no_overflow_label);
1626 __ li(ToRegister(instr->result()), Operand(instr->value()));
1631 __ li(ToRegister(instr->result()), Operand(instr->value()));
1644 __ li(ToRegister(instr->result()), Operand(instr->value()));
1698 Operand(kStringRepresentationMask | kStringEncodingMask));
1701 __ Subu(at, scratch, Operand(encoding == String::ONE_BYTE_ENCODING
1703 __ Check(eq, kUnexpectedStringType, at, Operand(zero_reg));
1706 MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
1708 __ lbu(result, operand);
1710 __ lhu(result, operand);
1731 MemOperand operand = BuildSeqStringOperand(string, instr->index(), encoding);
1733 __ sb(value, operand);
1735 __ sh(value, operand);
1749 __ Addu(ToRegister(result), ToRegister(left), Operand(right_reg));
1760 Operand(right_reg), &no_overflow_label);
1783 __ Slt(scratch, left_reg, Operand(right_reg));
1893 const Operand& src2) {
1939 Register src1, const Operand& src2) {
1947 Register src1, const Operand& src2) {
1974 EmitBranch(instr, ne, reg, Operand(zero_reg));
1987 EmitBranch(instr, eq, reg, Operand(at));
1990 EmitBranch(instr, ne, reg, Operand(zero_reg));
1993 EmitBranch(instr, al, zero_reg, Operand(zero_reg));
2003 EmitBranch(instr, ne, at, Operand(zero_reg));
2012 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2017 __ Branch(instr->TrueLabel(chunk_), eq, reg, Operand(at));
2019 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2024 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(at));
2029 __ Branch(instr->FalseLabel(chunk_), eq, reg, Operand(zero_reg));
2034 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, at, Operand(zero_reg));
2043 __ And(at, at, Operand(1 << Map::kIsUndetectable));
2044 __ Branch(instr->FalseLabel(chunk_), ne, at, Operand(zero_reg));
2052 ge, at, Operand(FIRST_JS_RECEIVER_TYPE));
2059 __ Branch(¬_string, ge , at, Operand(FIRST_NONSTRING_TYPE));
2061 __ Branch(instr->TrueLabel(chunk_), ne, at, Operand(zero_reg));
2070 __ Branch(instr->TrueLabel(chunk_), eq, scratch, Operand(SYMBOL_TYPE));
2078 Operand(SIMD128_VALUE_TYPE));
2086 __ Branch(¬_heap_number, ne, map, Operand(at));
2099 Operand(zero_reg));
2180 Operand cmp_right = Operand(0);
2186 cmp_right = Operand(Smi::FromInt(value));
2189 cmp_right = Operand(value);
2195 cmp_right = Operand(Smi::FromInt(value));
2198 cmp_right = Operand(value);
2204 cmp_right = Operand(ToRegister(right));
2217 EmitBranch(instr, eq, left, Operand(right));
2224 __ li(at, Operand(factory()->the_hole_value()));
2225 EmitBranch(instr, eq, input_reg, Operand(at));
2234 EmitBranch(instr, eq, scratch, Operand(kHoleNanUpper32));
2256 EmitFalseBranch(instr, ne, scratch, Operand(0x80000000));
2260 EmitBranch(instr, eq, scratch, Operand(at));
2288 Operand(FIRST_NONSTRING_TYPE));
2295 EmitBranch(instr, eq, at, Operand(zero_reg));
2308 __ And(at, temp, Operand(1 << Map::kIsUndetectable));
2309 EmitBranch(instr, ne, at, Operand(zero_reg));
2342 Operand(zero_reg));
2378 Operand(TestType(instr->hydrogen())));
2400 __ And(at, scratch, Operand(String::kContainsCachedArrayIndexMask));
2401 EmitBranch(instr, eq, at, Operand(zero_reg));
2420 __ Branch(is_true, eq, temp2, Operand(JS_FUNCTION_TYPE));
2422 __ Branch(is_false, eq, temp2, Operand(JS_FUNCTION_TYPE));
2432 __ Branch(is_true, ne, instance_type, Operand(JS_FUNCTION_TYPE));
2434 __ Branch(is_false, ne, instance_type, Operand(JS_FUNCTION_TYPE));
2463 EmitBranch(instr, eq, temp, Operand(class_name));
2472 EmitBranch(instr, eq, temp, Operand(instr->map()));
2499 EmitFalseBranch(instr, eq, at, Operand(zero_reg));
2511 Operand(1 << Map::kIsAccessCheckNeeded));
2513 Operand(zero_reg));
2518 Operand(JS_PROXY_TYPE));
2521 EmitTrueBranch(instr, eq, object_prototype, Operand(prototype));
2523 EmitFalseBranch(instr, eq, object_prototype, Operand(at));
2543 __ Branch(USE_DELAY_SLOT, &done, condition, v0, Operand(zero_reg));
2573 __ Addu(sp, sp, Operand(sp_delta));
2601 __ li(slot_register, Operand(Smi::FromInt(index)));
2615 __ li(slot_register, Operand(Smi::FromInt(index)));
2625 __ li(LoadDescriptor::NameRegister(), Operand(instr->name()));
2643 DeoptimizeIf(eq, instr, Deoptimizer::kHole, result, Operand(at));
2646 __ Branch(&is_not_hole, ne, result, Operand(at));
2667 DeoptimizeIf(eq, instr, Deoptimizer::kHole, scratch, Operand(at));
2669 __ Branch(&skip_assignment, ne, scratch, Operand(at));
2699 MemOperand operand = MemOperand(object, offset);
2700 __ Load(result, operand, access.representation());
2715 MemOperand operand = FieldMemOperand(object, offset);
2716 __ Load(result, operand, access.representation());
2726 __ li(LoadDescriptor::NameRegister(), Operand(instr->name()));
2747 DeoptimizeIf(eq, instr, Deoptimizer::kHole, result, Operand(at));
2752 __ Branch(&done, ne, scratch, Operand(MAP_TYPE));
2781 __ li(at, Operand(const_length + 1));
2792 __ Subu(result, length, Operand(loc));
2872 result, Operand(0x80000000));
2910 __ Addu(scratch, elements, Operand(base_offset));
2925 Operand(kHoleNanUpper32));
2962 Operand(zero_reg));
2965 DeoptimizeIf(eq, instr, Deoptimizer::kHole, result, Operand(scratch));
2971 __ Branch(&done, ne, result, Operand(scratch));
2979 Operand(Smi::FromInt(Isolate::kArrayProtectorValid)));
3063 __ Xor(temp, result, Operand(Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR)));
3080 __ Addu(result, zero_reg, Operand(scope()->num_parameters()));
3081 __ Branch(&done, eq, fp, Operand(elem));
3117 __ And(scratch, scratch, Operand(strict_mode_function_mask | native_mask));
3118 __ Branch(&result_in_receiver, ne, scratch, Operand(zero_reg));
3123 __ Branch(&global_object, eq, receiver, Operand(scratch));
3125 __ Branch(&global_object, eq, receiver, Operand(scratch));
3129 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, scratch, Operand(zero_reg));
3133 Operand(FIRST_JS_RECEIVER_TYPE));
3167 Operand(kArgumentsLimit));
3174 __ Addu(elements, elements, Operand(1 * kPointerSize));
3180 __ Branch(USE_DELAY_SLOT, &invoke, eq, length, Operand(zero_reg));
3186 __ Subu(length, length, Operand(1));
3187 __ Branch(USE_DELAY_SLOT, &loop, ne, length, Operand(zero_reg));
3240 __ li(scratch1(), Operand(Smi::FromInt(instr->hydrogen()->flags())));
3263 __ li(a0, Operand(arity));
3290 DeoptimizeIf(ne, instr, Deoptimizer::kNotAHeapNumber, scratch, Operand(at));
3299 __ And(at, exponent, Operand(HeapNumber::kSignMask));
3300 __ Branch(&done, eq, at, Operand(zero_reg));
3336 __ And(exponent, exponent, Operand(~HeapNumber::kSignMask));
3353 __ Branch(USE_DELAY_SLOT, &done, ge, input, Operand(zero_reg));
3357 DeoptimizeIf(lt, instr, Deoptimizer::kOverflow, result, Operand(zero_reg));
3413 Operand(zero_reg));
3418 __ Branch(&done, ne, result, Operand(zero_reg));
3420 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
3422 Operand(zero_reg));
3444 __ Branch(&skip1, gt, scratch, Operand(HeapNumber::kExponentBias - 2));
3456 Operand(HeapNumber::kExponentBias + 32));
3459 __ And(scratch, result, Operand(HeapNumber::kSignMask));
3467 __ Xor(result, result, Operand(scratch));
3470 DeoptimizeIf(lt, instr, Deoptimizer::kMinusZero, result, Operand(zero_reg));
3475 __ Branch(&skip2, ge, result, Operand(zero_reg));
3490 Operand(zero_reg));
3494 __ Branch(&done, ne, result, Operand(zero_reg));
3497 __ And(scratch, scratch, Operand(HeapNumber::kSignMask));
3499 Operand(zero_reg));
3565 DeoptimizeIf(ne, instr, Deoptimizer::kNotAHeapNumber, t3, Operand(at));
3642 __ Addu(target, target, Operand(Code::kHeaderSize - kHeapObjectTag));
3658 __ Addu(target, target, Operand(Code::kHeaderSize - kHeapObjectTag));
3675 __ li(a0, Operand(instr->arity()));
3703 __ li(slot_register, Operand(Smi::FromInt(index)));
3709 __ li(a0, Operand(arity));
3720 __ li(a0, Operand(instr->arity()));
3745 __ Branch(&packed_case, eq, t1, Operand(zero_reg));
3775 Operand(Code::kHeaderSize - kHeapObjectTag));
3786 __ Addu(result, base, Operand(ToInteger32(offset)));
3804 MemOperand operand = MemOperand(object, offset);
3805 __ Store(value, operand, representation);
3826 __ li(scratch, Operand(transition));
3842 MemOperand operand = FieldMemOperand(object, offset);
3843 __ Store(value, operand, representation);
3858 MemOperand operand = FieldMemOperand(scratch, offset);
3859 __ Store(value, operand, representation);
3886 __ li(StoreDescriptor::NameRegister(), Operand(instr->name()));
3896 Operand operand(0);
3899 operand = ToOperand(instr->index());
3904 operand = ToOperand(instr->length());
3908 __ Branch(&done, NegateCondition(cc), reg, operand);
3912 DeoptimizeIf(cc, instr, Deoptimizer::kOutOfBounds, reg, operand);
3942 Operand(constant_key << element_size_shift));
4014 Operand((constant_key << element_size_shift) + base_offset));
4018 __ Addu(scratch, elements, Operand(base_offset));
4079 __ Addu(key, store_base, Operand(offset));
4156 Operand(constant_key));
4161 Operand(constant_capacity));
4164 Operand(ToRegister(current_capacity)));
4195 __ li(a3, Operand(ToSmi(LConstantOperand::cast(key))));
4212 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, at, Operand(zero_reg));
4227 __ Branch(¬_applicable, ne, scratch, Operand(from_map));
4231 __ li(new_map_reg, Operand(to_map));
4243 __ li(a1, Operand(to_map));
4315 __ Addu(scratch, zero_reg, Operand(Smi::FromInt(const_index)));
4354 char_code, Operand(String::kMaxOneByteCharCode));
4360 __ Branch(deferred->entry(), eq, result, Operand(scratch));
4459 __ Branch(deferred->entry(), hi, input, Operand(Smi::kMaxValue));
4484 __ Xor(src, src, Operand(0x80000000));
4593 __ And(at, input, Operand(0xc0000000));
4594 DeoptimizeIf(ne, instr, Deoptimizer::kOverflow, at, Operand(zero_reg));
4599 DeoptimizeIf(lt, instr, Deoptimizer::kOverflow, at, Operand(zero_reg));
4613 __ And(scratch, input, Operand(kHeapObjectTag));
4615 DeoptimizeIf(ne, instr, Deoptimizer::kNotASmi, scratch, Operand(zero_reg));
4638 __ Branch(&convert, ne, scratch, Operand(at));
4641 Operand(at));
4647 __ Branch(&done, ne, at, Operand(zero_reg));
4650 Operand(HeapNumber::kSignMask));
4658 Operand(at));
4700 __ Branch(USE_DELAY_SLOT, &no_heap_number, ne, scratch1, Operand(at));
4709 __ Branch(&check_bools, ne, input_reg, Operand(at));
4716 __ Branch(&check_false, ne, scratch2, Operand(at));
4718 __ li(input_reg, Operand(1)); // In delay slot.
4723 scratch2, Operand(at));
4728 Operand(at));
4744 Operand(zero_reg));
4747 __ Branch(&done, ne, input_reg, Operand(zero_reg));
4750 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4752 Operand(zero_reg));
4829 Operand(zero_reg));
4833 __ Branch(&done, ne, result_reg, Operand(zero_reg));
4835 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4837 Operand(zero_reg));
4864 Operand(zero_reg));
4868 __ Branch(&done, ne, result_reg, Operand(zero_reg));
4870 __ And(scratch1, scratch1, Operand(HeapNumber::kSignMask));
4872 Operand(zero_reg));
4877 DeoptimizeIf(lt, instr, Deoptimizer::kOverflow, scratch1, Operand(zero_reg));
4884 DeoptimizeIf(ne, instr, Deoptimizer::kNotASmi, at, Operand(zero_reg));
4892 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, at, Operand(zero_reg));
4905 DeoptimizeIf(ne, instr, Deoptimizer::kOutOfBounds, at, Operand(zero_reg));
4923 Operand(first));
4926 Operand(first));
4930 Operand(last));
4942 at, Operand(zero_reg));
4944 __ And(scratch, scratch, Operand(mask));
4946 Operand(tag));
4959 __ li(at, Operand(cell));
4961 DeoptimizeIf(ne, instr, Deoptimizer::kValueMismatch, reg, Operand(at));
4963 DeoptimizeIf(ne, instr, Deoptimizer::kValueMismatch, reg, Operand(object));
4980 Operand(zero_reg));
5032 __ Branch(deferred->entry(), ne, map_reg, Operand(map));
5034 DeoptimizeIf(ne, instr, Deoptimizer::kWrongMap, map_reg, Operand(map));
5068 __ Branch(&heap_number, eq, scratch, Operand(factory()->heap_number_map()));
5073 Operand(factory()->undefined_value()));
5153 __ li(scratch, Operand(size - kHeapObjectTag));
5155 __ Subu(scratch, ToRegister(instr->size()), Operand(kHeapObjectTag));
5157 __ li(scratch2, Operand(isolate()->factory()->one_pointer_filler_map()));
5160 __ Subu(scratch, scratch, Operand(kPointerSize));
5161 __ Addu(at, result, Operand(scratch));
5163 __ Branch(&loop, ge, scratch, Operand(zero_reg));
5223 __ li(v0, Operand(isolate()->factory()->number_string()));
5236 Operand cmp2 = Operand(no_reg);
5259 Operand* cmp2) {
5271 *cmp2 = Operand(at);
5278 *cmp2 = Operand(FIRST_NONSTRING_TYPE);
5285 *cmp2 = Operand(SYMBOL_TYPE);
5290 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5293 *cmp2 = Operand(input);
5298 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5307 *cmp2 = Operand(zero_reg);
5315 Operand((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
5317 *cmp2 = Operand(1 << Map::kIsCallable);
5323 __ Branch(USE_DELAY_SLOT, true_label, eq, at, Operand(input));
5326 __ Branch(false_label, lt, scratch1(), Operand(FIRST_JS_RECEIVER_TYPE));
5330 Operand((1 << Map::kIsCallable) | (1 << Map::kIsUndetectable)));
5332 *cmp2 = Operand(zero_reg);
5342 *cmp2 = Operand(at); \
5350 *cmp2 = Operand(zero_reg); // Set to valid regs, to avoid caller assertion.
5396 Operand(zero_reg));
5442 __ Branch(&done, hs, sp, Operand(at));
5455 __ Branch(deferred_stack_check->entry(), lo, sp, Operand(at));
5486 DeoptimizeIf(eq, instr, Deoptimizer::kSmi, at, Operand(zero_reg));
5491 Operand(JS_PROXY_TYPE));
5510 DeoptimizeIf(ne, instr, Deoptimizer::kWrongMap, a1, Operand(at));
5520 __ Branch(&load_cache, ne, result, Operand(Smi::FromInt(0)));
5521 __ li(result, Operand(isolate()->factory()->empty_fixed_array()));
5530 DeoptimizeIf(eq, instr, Deoptimizer::kNoCache, result, Operand(zero_reg));
5540 DeoptimizeIf(ne, instr, Deoptimizer::kWrongMap, map, Operand(scratch0()));
5595 __ And(scratch, index, Operand(Smi::FromInt(1)));
5596 __ Branch(deferred->entry(), ne, scratch, Operand(zero_reg));
5599 __ Branch(USE_DELAY_SLOT, &out_of_object, lt, index, Operand(zero_reg));
