Lines Matching defs:__
43 #define __ gen()->lir(__FILE__, __LINE__)->
45 #define __ gen()->lir()->
93 __ move(src, dest);
222 __ move(result(), reg);
254 __ move(r, reg);
324 __ branch_destination(block->label());
467 __ oop2reg_patch(NULL, r, info);
470 __ oop2reg(obj->constant_encoding(), r);
481 __ branch(lir_cond_belowEqual, T_INT, stub); // forward branch
485 __ branch(lir_cond_aboveEqual, T_INT, stub); // forward branch
494 __ branch(lir_cond_belowEqual, T_INT, stub); // forward branch
498 __ branch(lir_cond_aboveEqual, T_INT, stub); // forward branch
500 __ move(index, result);
512 __ move(left_op, result_op);
520 case Bytecodes::_iadd: __ add(left_op, right_op, result_op); break;
522 case Bytecodes::_lmul: __ mul(left_op, right_op, result_op); break;
527 __ mul_strictfp(left_op, right_op, result_op, tmp_op); break;
529 __ mul(left_op, right_op, result_op); break;
542 __ shift_left(left_op, exact_log2(c), result_op);
550 __ mul(left_op, right_op, result_op);
558 case Bytecodes::_isub: __ sub(left_op, right_op, result_op); break;
560 case Bytecodes::_fdiv: __ div (left_op, right_op, result_op); break;
566 __ div_strictfp (left_op, right_op, result_op, tmp_op); break;
568 __ div (left_op, right_op, result_op); break;
574 case Bytecodes::_frem: __ rem (left_op, right_op, result_op); break;
599 __ move(value, result_op);
606 case Bytecodes::_lshl: __ shift_left(value, count, result_op, tmp); break;
608 case Bytecodes::_lshr: __ shift_right(value, count, result_op, tmp); break;
610 case Bytecodes::_lushr: __ unsigned_shift_right(value, count, result_op, tmp); break;
619 __ move(left_op, result_op);
625 case Bytecodes::_land: __ logical_and(left_op, right_op, result_op); break;
628 case Bytecodes::_lor: __ logical_or(left_op, right_op, result_op); break;
631 case Bytecodes::_lxor: __ logical_xor(left_op, right_op, result_op); break;
642 __ load_stack_address_monitor(monitor_no, lock);
644 __ lock_object(hdr, object, lock, scratch, slow_path, info_for_exception);
654 __ load_stack_address_monitor(monitor_no, lock);
655 __ unlock_object(hdr, object, lock, scratch, slow_path);
673 __ allocate_object(dst, scratch1, scratch2, scratch3, scratch4,
677 __ branch(lir_cond_always, T_ILLEGAL, slow_path);
678 __ branch_destination(slow_path->continuation());
915 __ roundfp(opr, LIR_OprFact::illegalOpr, result);
928 __ move(value, r);
937 __ move(value, tmp);
959 __ oop2reg(md->constant_encoding(), md_reg);
962 __ cmove(lir_cond(cond),
970 __ move(data_addr, data_reg);
973 __ leal(LIR_OprFact::address(fake_incr_value), data_reg);
974 __ move(data_reg, data_addr);
1115 __ move_wide(new LIR_Address(thread_reg, in_bytes(JavaThread::exception_oop_offset()), T_OBJECT),
1117 __ move_wide(LIR_OprFact::oopConst(NULL),
1119 __ move_wide(LIR_OprFact::oopConst(NULL),
1123 __ move(exceptionOopOpr(), result);
1150 __ oop2reg_patch(NULL, reg, info);
1165 __ move(res, reg);
1196 __ oop2reg(method()->constant_encoding(), meth);
1202 __ return_op(LIR_OprFact::illegalOpr);
1208 __ return_op(result.result());
1236 __ load(referent_field_adr, result, info);
1266 __ null_check(clazz.result(), info);
1273 __ move(call_result, result);
1289 __ move(new LIR_Address(rcvr.result(), oopDesc::klass_offset_in_bytes(), T_OBJECT), result, info);
1290 __ move_wide(new LIR_Address(result, in_bytes(Klass::java_mirror_offset()), T_OBJECT), result);
1298 __ move_wide(new LIR_Address(getThreadPointer(), in_bytes(JavaThread::threadObj_offset()), T_OBJECT), reg);
1408 __ move((LIR_Opr)c, result);
1483 __ load(mark_active_flag_addr, flag_val);
1484 __ cmp(lir_cond_notEqual, flag_val, LIR_OprFact::intConst(0));
1513 __ branch(lir_cond_notEqual, T_INT, slow);
1514 __ branch_destination(slow->continuation());
1525 __ move(new_val, new_val_reg);
1527 __ leal(new_val, new_val_reg);
1537 __ move(address->base(), ptr);
1540 __ leal(addr, ptr);
1549 __ move(addr, xor_res);
1550 __ logical_xor(xor_res, new_val, xor_res);
1551 __ move(xor_res, xor_shift_res);
1552 __ unsigned_shift_right(xor_shift_res,
1557 __ logical_xor(addr, new_val, xor_res);
1558 __ unsigned_shift_right(xor_res,
1566 __ leal(new_val, new_val_reg);
1571 __ cmp(lir_cond_notEqual, xor_shift_res, LIR_OprFact::intptrConst(NULL_WORD));
1574 __ branch(lir_cond_notEqual, LP64_ONLY(T_LONG) NOT_LP64(T_INT), slow);
1575 __ branch_destination(slow->continuation());
1591 __ move(address->base(), ptr);
1594 __ leal(addr, ptr);
1604 __ move((LIR_Opr)card_table_base, tmp);
1606 __ move(new LIR_Address(FrameMap::Rthread_opr, in_bytes(JavaThread::card_table_base_offset()), T_ADDRESS), tmp);
1612 __ move(tmp, card_addr);
1615 __ move(LIR_OprFact::intConst(0), tmp_zero);
1616 __ move(tmp_zero, card_addr);
1621 __ move(addr, tmp);
1622 __ unsigned_shift_right(tmp, CardTableModRefBS::card_shift, tmp);
1624 __ unsigned_shift_right(addr, CardTableModRefBS::card_shift, tmp);
1627 __ move(LIR_OprFact::intConst(0),
1630 __ move(LIR_OprFact::intConst(0),
1720 __ null_check(object.result(), new CodeEmitInfo(info));
1735 __ membar_release();
1751 __ store(value.result(), address, info, patch_code);
1760 __ membar();
1798 __ null_check(object.result(), new CodeEmitInfo(info));
1817 __ load(address, reg, info, patch_code);
1821 __ membar_acquire();
1845 __ branch(lir_cond_belowEqual, T_INT, stub);
1849 __ branch(lir_cond_aboveEqual, T_INT, stub);
1851 __ move(index.result(), result);
1854 __ move(index.result(), result);
1876 __ load(new LIR_Address(array.result(), arrayOopDesc::length_offset_in_bytes(), T_INT), reg, info, lir_patch_none);
1921 __ cmp(lir_cond_belowEqual, length.result(), index.result());
1922 __ branch(lir_cond_belowEqual, T_INT, new RangeCheckStub(range_check_info, index.result()));
1930 __ move(array_addr, rlock_result(x, x->elt_type()), null_check_info);
1939 __ null_check(value.result(), info);
1991 __ null_check(exception_opr, new CodeEmitInfo(info, x->state()->copy(ValueStack::ExceptionState, x->state()->bci())));
2001 __ move(exception_opr, exceptionOopOpr());
2004 __ unwind_exception(exceptionOopOpr());
2006 __ throw_exception(exceptionPcOpr(), exceptionOopOpr(), info);
2022 __ roundfp(input_opr, LIR_OprFact::illegalOpr, result);
2051 __ convert(Bytecodes::_l2i, base.result(), base_op);
2069 __ convert(Bytecodes::_i2l, index_op, tmp);
2081 __ convert(Bytecodes::_i2l, index_op, tmp);
2088 __ shift_left(index_op, log2_scale, tmp);
2095 __ unaligned_move(addr, reg);
2098 __ move_wide(addr, reg);
2100 __ move(addr, reg);
2137 __ convert(Bytecodes::_l2i, base.result(), base_op);
2149 __ convert(Bytecodes::_i2l, idx.result(), index_op);
2153 __ move(idx.result(), index_op);
2157 __ shift_left(index_op, log2_scale, index_op);
2162 __ convert(Bytecodes::_i2l, index_op, tmp);
2168 __ move(value.result(), addr);
2280 __ move(LIR_OprFact::longConst(java_lang_ref_Reference::referent_offset), referent_off);
2282 __ cmp(lir_cond_notEqual, off.result(), referent_off);
2283 __ branch(lir_cond_notEqual, as_BasicType(off.type()), Lcont->label());
2288 __ cmp(lir_cond_equal, src.result(), LIR_OprFact::oopConst(NULL));
2289 __ branch(lir_cond_equal, T_OBJECT, Lcont->label());
2295 __ move(new LIR_Address(src.result(), oopDesc::klass_offset_in_bytes(), T_OBJECT), src_klass);
2298 __ move(reference_type_addr, reference_type);
2299 __ cmp(lir_cond_equal, reference_type, LIR_OprFact::intConst(REF_NONE));
2300 __ branch(lir_cond_equal, T_INT, Lcont->label());
2311 __ branch_destination(Lcont->label());
2316 if (x->is_volatile() && os::is_MP()) __ membar_acquire();
2336 if (x->is_volatile() && os::is_MP()) __ membar_release();
2338 if (x->is_volatile() && os::is_MP()) __ membar();
2357 __ prefetch(addr, is_store);
2380 __ cmp(lir_cond_equal, value, low_key);
2381 __ branch(lir_cond_equal, T_INT, dest);
2383 __ cmp(lir_cond_equal, value, low_key);
2384 __ branch(lir_cond_equal, T_INT, dest);
2385 __ cmp(lir_cond_equal, value, high_key);
2386 __ branch(lir_cond_equal, T_INT, dest);
2389 __ cmp(lir_cond_less, value, low_key);
2390 __ branch(lir_cond_less, T_INT, L->label());
2391 __ cmp(lir_cond_lessEqual, value, high_key);
2392 __ branch(lir_cond_lessEqual, T_INT, dest);
2393 __ branch_destination(L->label());
2396 __ jump(default_sux);
2465 __ safepoint(safepoint_poll_register(), state_for(x, x->state_before()));
2479 __ cmp(lir_cond_equal, value, i + lo_key);
2480 __ branch(lir_cond_equal, T_INT, x->sux_at(i));
2482 __ jump(x->default_sux());
2493 __ safepoint(safepoint_poll_register(), state_for(x, x->state_before()));
2505 __ cmp(lir_cond_equal, value, x->key_at(i));
2506 __ branch(lir_cond_equal, T_INT, x->sux_at(i));
2508 __ jump(x->default_sux());
2522 __ move(osrBuffer, cc->args()->at(0));
2523 __ call_runtime_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_end),
2534 __ safepoint(safepoint_poll_register(), safepoint_info);
2557 __ oop2reg(md->constant_encoding(), md_reg);
2567 __ jump(x->default_sux());
2572 __ std_entry(LIR_OprFact::illegalOpr);
2594 __ move(src, dest);
2615 __ oop2reg(method()->constant_encoding(), meth);
2624 __ oop2reg(method()->holder()->java_mirror()->constant_encoding(), obj);
2634 __ load_stack_address_monitor(0, lock);
2640 __ lock_object(syncTempOpr(), obj, lock, new_register(T_OBJECT), slow_path, NULL);
2652 __ jump(x->default_sux());
2659 __ osr_entry(LIR_Assembler::osrBufferPointer());
2661 __ move(LIR_Assembler::osrBufferPointer(), result);
2677 __ move_wide(param->result(), addr);
2680 __ unaligned_move(param->result(), addr);
2682 __ move(param->result(), addr);
2695 __ move_wide(receiver->result(), loc->as_address_ptr());
2774 __ move(FrameMap::stack_pointer(), FrameMap::method_handle_invoke_SP_save_opr());
2779 __ call_static(target, result_register,
2789 __ call_opt_virtual(target, receiver, result_register,
2793 __ call_icvirtual(target, receiver, result_register,
2799 __ call_virtual(target, receiver, result_register, vtable_offset, arg_list, info);
2803 __ call_dynamic(target, receiver, result_register,
2816 __ move(FrameMap::method_handle_invoke_SP_save_opr(), FrameMap::stack_pointer());
2832 __ move(result_register, result);
2843 __ move(tmp, reg);
2875 __ cmp(lir_cond(x->cond()), left.result(), right.result());
2876 __ cmove(lir_cond(x->cond()), t_val.result(), f_val.result(), reg, as_BasicType(x->x()->type()));
2882 __ call_runtime_leaf(routine, getThreadTemp(),
2885 __ move(reg, result);
2892 __ move(new LIR_Address(thread, in_bytes(JavaThread::osthread_offset()), osthread->type()), osthread);
2896 __ move(new LIR_Address(osthread, in_bytes(OSThread::thread_id_offset()), T_LONG), id);
2897 __ convert(Bytecodes::_l2i, id, rlock_result(x));
2899 __ move(new LIR_Address(osthread, in_bytes(OSThread::thread_id_offset()), T_INT), rlock_result(x));
2912 __ move(new LIR_Address(arg.result(), java_lang_Class::klass_offset_in_bytes(), T_OBJECT), klass, info);
2916 __ move(trace_id_addr, id);
2917 __ logical_or(id, LIR_OprFact::longConst(0x01l), id);
2918 __ store(id, trace_id_addr);
2919 __ logical_and(id, LIR_OprFact::longConst(~0x3l), id);
2920 __ move(id, rlock_result(x));
2997 __ move(value.result(), recv);
2999 __ profile_call(x->method(), x->bci_of_invoke(), x->callee(), mdo, recv, tmp, x->known_holder());
3039 __ oop2reg(method->constant_encoding(), counter_holder);
3046 __ oop2reg(md->constant_encoding(), counter_holder);
3048 __ oop2reg(method->constant_encoding(), meth);
3054 __ load(counter, result);
3055 __ add(result, LIR_OprFact::intConst(InvocationCounter::count_increment), result);
3056 __ store(result, counter);
3059 __ logical_and(result, mask, result);
3060 __ cmp(lir_cond_equal, result, LIR_OprFact::intConst(0));
3063 __ branch(lir_cond_equal, T_INT, overflow);
3064 __ branch_destination(overflow->continuation());
3089 __ move(result, rlock_result(x));
3135 __ move(arg, loc);
3140 // __ move(arg, tmp);
3144 __ unaligned_move(arg, addr);
3146 __ move(arg, addr);
3152 __ call_runtime(entry, getThreadTemp(), phys_reg, cc->args(), info);
3154 __ call_runtime_leaf(entry, getThreadTemp(), phys_reg, cc->args());
3157 __ move(phys_reg, result);
3186 __ unaligned_move(arg->result(), addr);
3188 __ move(arg->result(), addr);
3194 __ call_runtime(entry, getThreadTemp(), phys_reg, cc->args(), info);
3196 __ call_runtime_leaf(entry, getThreadTemp(), phys_reg, cc->args());
3199 __ move(phys_reg, result);
3208 case lir_membar_acquire : __ membar_acquire(); break;
3209 case lir_membar_release : __ membar_release(); break;
3210 case lir_membar : __ membar(); break;
3211 case lir_membar_loadload : __ membar_loadload(); break;
3212 case lir_membar_storestore: __ membar_storestore(); break;
3213 case lir_membar_loadstore : __ membar_loadstore(); break;
3214 case lir_membar_storeload : __ membar_storeload(); break;