aarch64/vm/c1_LIRGenerator_aarch64.cpp

288 bool LIRGenerator::strength_reduce_multiply(LIR_Opr left, int c, LIR_Opr result, LIR_Opr tmp) {
292     __ add(tmp, left, result);
296     __ sub(tmp, left, result);
354   LIR_Address* array_addr = emit_array_address(array.result(), index.result(), x->elt_type(), obj_store);
358       __ cmp(lir_cond_belowEqual, length.result(), index.result());
359       __ branch(lir_cond_belowEqual, T_INT, new RangeCheckStub(range_check_info, index.result()));
361       array_range_check(array.result(), index.result(), null_check_info, range_check_info);
373     __ store_check(value.result(), array.result(), tmp1, tmp2, tmp3, store_check_info, x->profiled_method(), x->profiled_bci());
380     __ move(value.result(), array_addr, null_check_info);
382     post_barrier(LIR_OprFact::address(array_addr), value.result());
384     LIR_Opr result = maybe_mask_boolean(x, array.result(), value.result(), null_check_info);
385     __ move(result, array_addr, null_check_info);
411   monitor_enter(obj.result(), lock, syncTempOpr(), scratch,
433   LIR_Opr result = rlock_result(x);
434   __ negate (from.result(), result);
461     __ move(right.result(), cc->at(0));
470     LIR_Opr result = rlock_result(x);
472     __ move(result_reg, result);
494   arithmetic_op_fpu(x->op(), reg, left.result(), right.result(), NULL);
517     __ cmp(lir_cond_equal, right.result(), LIR_OprFact::longConst(0));
523       __ rem (left.result(), right.result(), x->operand());
526       __ div (left.result(), right.result(), x->operand());
551     arithmetic_op_long(x->op(), x->operand(), left.result(), right.result(), NULL);
579     __ cmp(lir_cond_equal, right_arg->result(), LIR_OprFact::longConst(0));
584       __ irem(left_arg->result(), right_arg->result(), x->operand(), tmp, NULL);
586       __ idiv(left_arg->result(), right_arg->result(), x->operand(), tmp, NULL);
597     arithmetic_op_int(x->op(), x->operand(), left_arg->result(), right_arg->result(), LIR_OprFact::illegalOpr);
612     arithmetic_op_int(x->op(), x->operand(), left_arg->result(), right_arg->result(), new_register(T_INT));
649       __ shift_left(left.result(), c, x->operand());
654       __ shift_right(left.result(), c, x->operand());
659       __ unsigned_shift_right(left.result(), c, x->operand());
664       __ shift_left(left.result(), c, x->operand());
669       __ shift_right(left.result(), c, x->operand());
674       __ unsigned_shift_right(left.result(), c, x->operand());
685       __ logical_and(right.result(), LIR_OprFact::intConst(0x1f), tmp);
686       __ shift_left(left.result(), tmp, x->operand(), tmp);
690       __ logical_and(right.result(), LIR_OprFact::intConst(0x1f), tmp);
691       __ shift_right(left.result(), tmp, x->operand(), tmp);
695       __ logical_and(right.result(), LIR_OprFact::intConst(0x1f), tmp);
696       __ unsigned_shift_right(left.result(), tmp, x->operand(), tmp);
700       __ logical_and(right.result(), LIR_OprFact::intConst(0x3f), tmp);
701       __ shift_left(left.result(), tmp, x->operand(), tmp);
705       __ logical_and(right.result(), LIR_OprFact::intConst(0x3f), tmp);
706       __ shift_right(left.result(), tmp, x->operand(), tmp);
710       __ logical_and(right.result(), LIR_OprFact::intConst(0x3f), tmp);
711       __ unsigned_shift_right(left.result(), tmp, x->operand(), tmp);
741     __ logical_and(left.result(), right.result(), x->operand()); break;
744     __ logical_or (left.result(), right.result(), x->operand()); break;
747     __ logical_xor(left.result(), right.result(), x->operand()); break;
766     __ fcmp2int(left.result(), right.result(), reg, (code == Bytecodes::_fcmpl || code == Bytecodes::_dcmpl));
768     __ lcmp2int(left.result(), right.result(), reg);
796   if(offset.result()->is_constant()) {
797     jlong c = offset.result()->as_jlong();
799       a = new LIR_Address(obj.result(),
804       __ move(offset.result(), tmp);
805       a = new LIR_Address(obj.result(),
810     a = new LIR_Address(obj.result(),
811                         offset.result(),
824   LIR_Opr result = rlock_result(x);
828     __ cas_obj(addr, cmp.result(), val.result(), new_register(T_INT), new_register(T_INT),
829                result);
831     __ cas_int(addr, cmp.result(), val.result(), ill, ill);
833     __ cas_long(addr, cmp.result(), val.result(), ill, ill);
838   __ logical_xor(FrameMap::r8_opr, LIR_OprFact::intConst(1), result);
842     post_barrier(addr, val.result());
857         __ sqrt(value.result(), dst, LIR_OprFact::illegalOpr);
861         __ abs(value.result(), dst, LIR_OprFact::illegalOpr);
899       LIR_Opr result = call_runtime(x->argument_at(0), runtime_entry, x->type(), NULL);
900       set_result(x, result);
906       LIR_Opr result = call_runtime(x->argument_at(0), x->argument_at(1), runtime_entry, x->type(), NULL);
907       set_result(x, result);
952   __ arraycopy(src.result(), src_pos.result(), dst.result(), dst_pos.result(), length.result(), tmp, expected_type, flags, info); // does add_safepoint
958   LIR_Opr result = rlock_result(x);
968       __ update_crc32(crc.result(), val.result(), result);
982       LIR_Opr index = off.result();
984       if(off.result()->is_constant()) {
986        offset += off.result()->as_jint();
988       LIR_Opr base_op = buf.result();
1022       __ move(result_reg, result);
1047   LIR_Opr calc_input = value.result();
1048   LIR_Opr calc_input1 = value1.result();
1049   LIR_Opr calc_input2 = value2.result();
1068   LIR_Opr input = value.result();
1069   LIR_Opr result = rlock(x);
1073   LIR_Opr conv_result = result;
1078   assert(result->is_virtual(), "result must be virtual register");
1079   set_result(x, result);
1096   LIR_Opr result = rlock_result(x);
1097   __ move(reg, result);
1112   LIR_Opr len = length.result();
1120   LIR_Opr result = rlock_result(x);
1121   __ move(reg, result);
1143   LIR_Opr len = length.result();
1153   LIR_Opr result = rlock_result(x);
1154   __ move(reg, result);
1185     store_stack_parameter(size->result(), in_ByteSize(i*4));
1204   LIR_Opr result = rlock_result(x);
1205   __ move(reg, result);
1238     stub = new SimpleExceptionStub(Runtime1::throw_class_cast_exception_id, obj.result(), info_for_exception);
1245   __ checkcast(reg, obj.result(), x->klass(),
1254   // result and test object may not be in same register
1266   __ instanceof(reg, obj.result(), x->klass(),
1321   LIR_Opr left = xin->result();
1322   LIR_Opr right = yin->result();
1348 void LIRGenerator::volatile_field_load(LIR_Address* address, LIR_Opr result,
1360   __ volatile_load_mem_reg(address, result, info);
1404   LIR_Opr data = value.result();
1406   LIR_Opr offset = off.result();
1419     addr = new LIR_Address(src.result(), c, type);
1421     addr = new LIR_Address(src.result(), offset, type);
1433       __ add(src.result(), off.result(), ptr);