Home | History | Annotate | Download | only in mips

Lines Matching full:branch

546   __ Branch(&not_special, gt, source_, Operand(1));
625     __ Branch(&done, eq, scratch, Operand(zero_reg));
645   __ Branch(&done, eq, scratch, Operand(zero_reg));
654   __ Branch(&normal_exponent, le, result_reg, Operand(zero_reg));
656   __ Branch(&done);
671   __ Branch(&high_shift_needed, lt, scratch, Operand(32));
673   __ Branch(&high_shift_done);
691   __ Branch(&pos_shift, ge, scratch, Operand(zero_reg));
696   __ Branch(&shift_done);
734   __ Branch(&max_negative_int, eq, the_int_, Operand(0x80000000u));
787   __ Branch(&not_identical, ne, a0, Operand(a1));
797     __ Branch(slow, greater, t4, Operand(FIRST_SPEC_OBJECT_TYPE));
800     __ Branch(&heap_number, eq, t4, Operand(HEAP_NUMBER_TYPE));
803     __ Branch(slow, greater, t4, Operand(FIRST_SPEC_OBJECT_TYPE));
808         __ Branch(&return_equal, ne, t4, Operand(ODDBALL_TYPE));
810         __ Branch(&return_equal, ne, a0, Operand(t2));
850     __ Branch(&return_equal, ne, t3, Operand(exp_mask_reg));
901     __ Branch(slow, ne, t4, Operand(HEAP_NUMBER_TYPE));
925     __ Branch(slow, ne, t4, Operand(HEAP_NUMBER_TYPE));
949     __ Branch(&first_non_object, less, a2, Operand(FIRST_SPEC_OBJECT_TYPE));
959     __ Branch(&return_not_equal, eq, a2, Operand(ODDBALL_TYPE));
962     __ Branch(&return_not_equal, greater, a3, Operand(FIRST_SPEC_OBJECT_TYPE));
965     __ Branch(&return_not_equal, eq, a3, Operand(ODDBALL_TYPE));
972     __ Branch(&return_not_equal, eq, at, Operand(zero_reg));
983   __ Branch(not_heap_numbers, ne, a2, Operand(HEAP_NUMBER_TYPE));
986   __ Branch(slow, ne, a3, Operand(a2));
1010   __ Branch(&object_test, ne, at, Operand(zero_reg));
1012   __ Branch(possible_strings, ne, at, Operand(zero_reg));
1014   __ Branch(not_both_strings, ge, a3, Operand(FIRST_NONSTRING_TYPE));
1016   __ Branch(possible_strings, ne, at, Operand(zero_reg));
1024   __ Branch(not_both_strings, lt, a2, Operand(FIRST_SPEC_OBJECT_TYPE));
1026   __ Branch(not_both_strings, lt, a3, Operand(FIRST_SPEC_OBJECT_TYPE));
1302     __ Branch(&loaded);
1343   __ Branch(&invalid_cache, eq, cache_entry, Operand(zero_reg));
1370   __ Branch(&calculate, ne, a2, Operand(t0));
1371   __ Branch(&calculate, ne, a3, Operand(t1));
1537     __ Branch(&call_runtime, ne, scratch, Operand(heapnumbermap));
1550     __ Branch(&call_runtime, ne, scratch, Operand(heapnumbermap));
1572     __ Branch(&int_exponent_convert, eq, scratch2, Operand(zero_reg));
1655   __ Branch(&positive_exponent, ge, scratch, Operand(zero_reg));
1664   __ Branch(&no_carry, eq, scratch2, Operand(zero_reg));
1670   __ Branch(&loop_end, eq, scratch, Operand(zero_reg));
1673   __ Branch(&while_true);
1677   __ Branch(&done, ge, exponent, Operand(zero_reg));
1774   __ Branch(oom_label, eq, scratch, Operand(0xf));
1825     // This branch-and-link sequence is needed to find the current PC on mips,
1830     masm->bal(&find_ra);  // bal exposes branch delay slot.
1840     // Stack space reservation moved to the branch delay slot below.
1866   __ Branch(USE_DELAY_SLOT, &failure_returned, eq, t0, Operand(zero_reg));
1867   // Restore stack (remove arg slots) in branch delay slot.
1882   __ Branch(&retry, eq, t0, Operand(zero_reg));
1904   __ Branch(throw_termination_exception, eq, v0, Operand(t0));
2069   __ Branch(&non_outermost_js, ne, t2, Operand(zero_reg));
2074   __ nop();   // Branch delay slot nop.
2093   __ b(&exit);  // b exposes branch delay slot.
2094   __ nop();   // Branch delay slot nop.
2150   __ Branch(&non_outermost_js_2,
2217     __ Branch(&miss, ne, function, Operand(at));
2219     __ Branch(&miss, ne, map, Operand(at));
2262   __ Branch
2263   __ Branch(&is_not_instance, eq, scratch, Operand(scratch2));
2266   __ Branch(&loop);
2311   __ Branch(&slow, ne, scratch, Operand(JS_FUNCTION_TYPE));
2314   __ Branch(&object_not_null,
2364     __ Branch(&miss, ne, a0,
2394     __ Branch(&miss, ne, a0,
2432     __ Branch(&miss, ne, a1,
2454   __ Branch(&miss, ne, scratch, Operand(JS_ARRAY_TYPE));
2461   __ Branch(&miss, ne, scratch, Operand(FIXED_ARRAY_TYPE));
2468   __ Branch(&miss, eq, scratch, Operand(at));
2507   __ Branch(&adaptor,
2515   __ Branch(&slow, hs, a1, Operand(a0));
2529   __ Branch(&slow, Ugreater_equal, a1, Operand(a0));
2554   __ Branch(&runtime,
2589   __ Branch(&adaptor_frame,
2597   __ nop();   // Branch delay slot nop.
2611   __ Branch(&skip_min, lt, a1, Operand(a2));
2624   __ Branch(USE_DELAY_SLOT, &param_map_size, eq, a1, Operand(zero_reg));
2652   __ Branch(&skip2_ne, ne, a1, Operand(zero_reg));
2656   __ Branch(&skip2_eq, eq, a1, Operand(zero_reg));
2696   __ Branch(&skip3, ne, a1, Operand(Smi::FromInt(0)));
2702   __ Branch(&skip_parameter_map, eq, a1, Operand(Smi::FromInt(0)));
2751   __ Branch(&parameters_loop, ne, t2, Operand(Smi::FromInt(0)));
2778   __ Branch(&arguments_loop, lt, t5, Operand(a2));
2799   __ Branch(&adaptor_frame,
2806   __ Branch(&try_allocate);
2822   __ Branch(&add_arguments_object, eq, a1, Operand(zero_reg));
2849   __ Branch(&done, eq, a1, Operand(zero_reg));
2877   __ Branch(&loop, ne, a1, Operand(zero_reg));
2929   __ Branch(&runtime, eq, a0, Operand(zero_reg));
2936   __ Branch(&runtime, ne, a1, Operand(JS_REGEXP_TYPE));
2956   __ Branch(&runtime, ne, a0, Operand(Smi::FromInt(JSRegExp::IRREGEXP)));
2968   __ Branch(
3010   __ Branch(&seq_string, eq, a1, Operand(zero_reg));  // Go to (5).
3018   __ Branch(&not_seq_nor_cons, ge, a1, Operand(kExternalStringTag));
3024   __ Branch(&runtime, ne, a0, Operand(a1));
3036   __ Branch(&external_string, ne, at, Operand(zero_reg));  // Go to (7).
3048   __ Branch(&runtime, ls, a3, Operand(a1));
3163   __ Branch(&success, eq, v0, Operand(1));
3167   __ Branch(&failure, eq, v0, Operand(NativeRegExpMacroAssembler::FAILURE));
3169   __ Branch(&runtime, ne, v0, Operand(NativeRegExpMacroAssembler::EXCEPTION));
3178   __ Branch(&runtime, eq, v0, Operand(a1));
3185   __ Branch(&termination_exception, eq, v0, Operand(a0));
3210   __ Branch(&runtime, ne, a2, Operand(JS_ARRAY_TYPE));
3216   __ Branch(&runtime, ne, a0, Operand(at));
3223   __ Branch(&runtime, gt, a2, Operand(at));
3268   __ Branch(&done, lt, a1, Operand(zero_reg));
3275   __ Branch(&next_capture, USE_DELAY_SLOT);
3276   __ addiu(a0, a0, kPointerSize);  // In branch delay slot.
3292   __ Branch(&not_long_external, gt, a1, Operand(kExternalStringTag));
3320   __ Branch(&runtime, ne, at, Operand(zero_reg));
3340   __ Branch(&slowcase, hi, a1, Operand(Smi::FromInt(kMaxInlineLength)));
3406   __ Branch(&done, ge, a3, Operand(t1));  // Break when a3 past end of elem.
3408   __ Branch(&loop, USE_DELAY_SLOT);
3409   __ addiu(a3, a3, kPointerSize);  // In branch delay slot.
3438   __ Branch(&done, eq, a3, Operand(a1));
3446   __ Branch(&miss, ne, t1, Operand(at));
3450   __ Branch(&megamorphic, ne, a1, Operand(a3));
3458   __ Branch(&initialize, eq, a3, Operand(at));
3471   __ Branch(&not_array_function, ne, a1, Operand(a3));
3492   __ Branch(&done);
3517     __ Branch(&call, ne, t0, Operand(at));
3531   __ Branch(&slow, ne, a3, Operand(JS_FUNCTION_TYPE));
3544     __ Branch(&call_as_function, eq, t0, Operand(at));
3570   __ Branch(&non_function, ne, a3, Operand(JS_FUNCTION_PROXY_TYPE));
3605   __ Branch(&slow, ne, a3, Operand(JS_FUNCTION_TYPE));
3624   __ Branch(&non_function_call, ne, a3, Operand(JS_FUNCTION_PROXY_TYPE));
3658   __ Branch(receiver_not_string_, ne, t0, Operand(zero_reg));
3667   __ Branch(index_out_of_range_, ls, t0, Operand(index_));
3718   __ Branch(&got_smi_index_);
3754   __ Branch(&slow_case_, ne, t0, Operand(zero_reg));
3763   __ Branch(&slow_case_, eq, result_, Operand(t0));
3780   __ Branch(&exit_);
3799   __ Branch(&done, eq, count, Operand(zero_reg));
3807   __ Branch(&loop, lt, dest, Operand(count));
3855   __ Branch(&done, eq, count, Operand(zero_reg));
3862   __ Branch(&byte_loop, lt, scratch1, Operand(zero_reg));
3868     __ Branch(&dest_aligned, eq, scratch4, Operand(zero_reg));
3876     __ Branch(&aligned_loop, le, scratch4, Operand(kReadAlignmentMask));
3883   __ Branch(&simple_loop, eq, scratch4, Operand(zero_reg));
3897     __ Branch(&loop, ge, scratch2, Operand(kReadAlignment));
3900   __ Branch(&byte_loop);
3914     __ Branch(&loop, ge, scratch2, Operand(kReadAlignment));
3920   __ Branch(&done, ge, dest, Operand(limit));
3925   __ Branch(&byte_loop);
3947   __ Branch(&not_array_index,
3955   // not_found branch expects this combination in c1 register.
3958   __ Branch(&tmp, Ugreater, scratch, Operand(static_cast<int>('9' - '0')));
3961   __ Branch(
4031     __ Branch(&is_string, ne, scratch, Operand(ODDBALL_TYPE));
4033     __ Branch(not_found, eq, undefined, Operand(candidate));
4051     __ Branch(&next_probe[i], ne, scratch, Operand(Smi::FromInt(2)));
4056     __ Branch(&found_in_string_table, eq, chars, Operand(scratch));
4152   __ Branch(&runtime, lt, a3, Operand(zero_reg));  // From < 0.
4154   __ Branch(&runtime, gt, a3, Operand(a2));  // Fail if from > to.
4164   __ Branch(&runtime, ne, t0, Operand(zero_reg));
4167   __ Branch(&single_char, eq, a2, Operand(1));
4176   __ Branch(&return_v0, eq, a2, Operand(t0));
4178   __ Branch(&runtime, hi, a2, Operand(t0));
4192   __ Branch(USE_DELAY_SLOT, &seq_or_external_string, eq, t0, Operand(zero_reg));
4195   __ Branch(&sliced_string, ne, t0, Operand(zero_reg));
4199   __ Branch(&runtime, ne, t1, Operand(t0));
4230     __ Branch(&copy_routine, lt, a2, Operand(SlicedString::kMinLength));
4240     __ Branch(&two_byte_slice, eq, t0, Operand(zero_reg));
4262   __ Branch(&sequential_string, eq, t0, Operand(zero_reg));
4268   __ Branch(&runtime, ne, t0, Operand(zero_reg));
4282   __ Branch(&two_byte_sequential, eq, t0, Operand(zero_reg));
4356   __ Branch(&check_zero_length, eq, length, Operand(scratch2));
4366   __ Branch(&compare_chars, ne, length, Operand(zero_reg));
4401   __ Branch(&compare_lengths, eq, min_length, Operand(zero_reg));
4420   __ Branch(&ret, eq, scratch2, Operand(scratch4));
4422   __ Branch(&ret, gt, scratch2, Operand(scratch4));
4457   __ Branch(chars_not_equal, ne, scratch1, Operand(scratch2));
4459   __ Branch(&loop, ne, index, Operand(zero_reg));
4475   __ Branch(&not_same, ne, a0, Operand(a1));
4527     __ Branch(&call_runtime, ne, t4, Operand(zero_reg));
4558     __ and_(t4, t4, t5);        // Branch if both strings were non-empty.
4559     __ Branch(&strings_not_empty, ne, t4, Operand(zero_reg));
4585   __ Branch(&longer_than_two, ne, t2, Operand(2));
4623   __ Branch(&string_add_flat_result, lt, t2, Operand(ConsString::kMinLength));
4628   __ Branch(&call_runtime, hs, t2, Operand(String::kMaxLength + 1));
4640   // Branch to non_ascii if either string-encoding field is zero (non-ASCII).
4643   __ Branch(&non_ascii, eq, t4, Operand(zero_reg));
4655   __ Branch(&skip_write_barrier, eq, t0, Operand(zero_reg));
4688   // Branch to if _both_ instances have kOneByteDataHintMask set.
4691   __ Branch(&ascii_data, ne, at, Operand(zero_reg));
4695   __ Branch(&ascii_data, eq, t0,
4700   __ Branch(&allocated);
4724   __ Branch(&call_runtime, ne, t3, Operand(zero_reg));
4731   __ Branch(&skip_first_add, ne, t4, Operand(zero_reg));
4732   __ Branch(USE_DELAY_SLOT, &first_prepared);
4738   __ Branch(&call_runtime, ne, t4, Operand(zero_reg));
4746   __ Branch(&skip_second_add, ne, t4, Operand(zero_reg));
4747   __ Branch(USE_DELAY_SLOT, &second_prepared);
4753   __ Branch(&call_runtime, ne, t4, Operand(zero_reg));
4766   __ Branch(&non_ascii_string_add_flat_result, eq, t4, Operand(zero_reg));
4834   __ Branch(&done, lt, scratch1, Operand(FIRST_NONSTRING_TYPE));
4892   __ Branch(&left);
4905   __ Branch(&done);
4944     __ Branch(&miss, ne, a0, Operand(at));
4947     __ Branch(&maybe_undefined2, ne, a2, Operand(HEAP_NUMBER_TYPE));
4954     __ Branch(&unordered, eq, a1, Operand(at));
4983   __ Branch(&miss, ne, at, Operand(zero_reg));
5031   __ Branch(&done, ne, left, Operand(right));
5073   __ Branch(&miss, ne, tmp5, Operand(zero_reg));
5079   __ Branch(&left_ne_right, ne, left, Operand(right));
5095     __ Branch(&is_symbol, ne, tmp5, Operand(zero_reg));
5139   __ Branch(&miss, ne, a2, Operand(JS_OBJECT_TYPE));
5141   __ Branch(&miss, ne, a2, Operand(JS_OBJECT_TYPE));
5158   __ Branch(&miss, ne, a2, Operand(known_map_));
5159   __ Branch(&miss, ne, a3, Operand(known_map_));
5263     __ Branch(done, eq, entity_name, Operand(tmp));
5269     __ Branch(miss, eq, entity_name, Operand(Handle<Name>(name)));
5272     __ Branch(&good, eq, entity_name, Operand(tmp));
5298   __ Branch(done, eq, at, Operand(zero_reg));
5299   __ Branch(miss, ne, at, Operand(zero_reg));
5355     __ Branch(done, eq, name, Operand(at));
5378   __ Branch(done, ne, at, Operand(zero_reg));
5379   __ Branch(miss, eq, at, Operand(zero_reg));
5445     __ Branch(&not_in_dictionary, eq, entry_key, Operand(undefined));
5448     __ Branch(&in_dictionary, eq, entry_key, Operand(key));
5501   // The first two branch+nop instructions are generated with labels so as to
5621   __ Branch(&need_incremental, lt, regs_.scratch1(), Operand(zero_reg));
5876       __ Branch(&next, ne, a3, Operand(kind));
5908     __ Branch(&normal_sequence, ne, at, Operand(zero_reg));
5913   __ Branch(&normal_sequence, eq, t1, Operand(zero_reg));
5957       __ Branch(&next, ne, a3, Operand(kind));
6023     __ Branch(&not_zero_case, ne, at, Operand(zero_reg));
6027     __ Branch(&not_one_case, gt, a0, Operand(1));
6070     __ Branch(&okay_here, eq, a2, Operand(at));
6080   __ Branch(&no_info, eq, a2, Operand(at));
6087   __ Branch(&no_info, ne, t0, Operand(at));
6105   __ Branch(&not_zero_case, ne, a0, Operand(zero_reg));
6110   __ Branch(&not_one_case, gt, a0, Operand(1));
6116     __ Branch(&normal_sequence, eq, at, Operand(zero_reg));
6167     __ Branch(&done, eq, a3, Operand(FAST_ELEMENTS));
6175   __ Branch(&fast_elements_case, eq, a3, Operand(FAST_ELEMENTS));