980 int offset = is_updateBytes ? arrayOopDesc::base_offset_in_bytes(T_BYTE) : 0;
981 if(off.result()->is_constant()) {
982 index = LIR_OprFact::illegalOpr;
983 offset += off.result()->as_jint();
984 }
985 LIR_Opr base_op = buf.result();
986
987 #ifndef _LP64
988 if (!is_updateBytes) { // long b raw address
989 base_op = new_register(T_INT);
990 __ convert(Bytecodes::_l2i, buf.result(), base_op);
991 }
992 #else
993 if (index->is_valid()) {
994 LIR_Opr tmp = new_register(T_LONG);
995 __ convert(Bytecodes::_i2l, index, tmp);
996 index = tmp;
997 }
998 #endif
999
1000 LIR_Address* a = new LIR_Address(base_op,
1001 index,
1002 offset,
1003 T_BYTE);
1004 BasicTypeList signature(3);
1005 signature.append(T_INT);
1006 signature.append(T_ADDRESS);
1007 signature.append(T_INT);
1008 CallingConvention* cc = frame_map()->c_calling_convention(&signature);
1009 const LIR_Opr result_reg = result_register_for(x->type());
1010
1011 LIR_Opr addr = new_pointer_register();
1012 __ leal(LIR_OprFact::address(a), addr);
1013
1014 crc.load_item_force(cc->at(0));
1015 __ move(addr, cc->at(1));
1016 len.load_item_force(cc->at(2));
1017
1018 __ call_runtime_leaf(StubRoutines::updateBytesCRC32(), getThreadTemp(), result_reg, cc->args());
1019 __ move(result_reg, result);
1037 LIR_Opr result = rlock_result(x);
1038
1039 LIRItem a(x->argument_at(0), this); // Object
1040 LIRItem aOffset(x->argument_at(1), this); // long
1041 LIRItem b(x->argument_at(2), this); // Object
1042 LIRItem bOffset(x->argument_at(3), this); // long
1043 LIRItem length(x->argument_at(4), this); // int
1044 LIRItem log2ArrayIndexScale(x->argument_at(5), this); // int
1045
1046 a.load_item();
1047 aOffset.load_nonconstant();
1048 b.load_item();
1049 bOffset.load_nonconstant();
1050
1051 long constant_aOffset = 0;
1052 LIR_Opr result_aOffset = aOffset.result();
1053 if (result_aOffset->is_constant()) {
1054 constant_aOffset = result_aOffset->as_jlong();
1055 result_aOffset = LIR_OprFact::illegalOpr;
1056 }
1057 LIR_Opr result_a = a.result();
1058
1059 long constant_bOffset = 0;
1060 LIR_Opr result_bOffset = bOffset.result();
1061 if (result_bOffset->is_constant()) {
1062 constant_bOffset = result_bOffset->as_jlong();
1063 result_bOffset = LIR_OprFact::illegalOpr;
1064 }
1065 LIR_Opr result_b = b.result();
1066
1067 #ifndef _LP64
1068 result_a = new_register(T_INT);
1069 __ convert(Bytecodes::_l2i, a.result(), result_a);
1070 result_b = new_register(T_INT);
1071 __ convert(Bytecodes::_l2i, b.result(), result_b);
1072 #endif
1073
1074
1075 LIR_Address* addr_a = new LIR_Address(result_a,
1076 result_aOffset,
1077 constant_aOffset,
1078 T_BYTE);
1079
1080 LIR_Address* addr_b = new LIR_Address(result_b,
1081 result_bOffset,
1082 constant_bOffset,
1083 T_BYTE);
1084
1085 BasicTypeList signature(4);
|
980 int offset = is_updateBytes ? arrayOopDesc::base_offset_in_bytes(T_BYTE) : 0;
981 if(off.result()->is_constant()) {
982 index = LIR_OprFact::illegalOpr;
983 offset += off.result()->as_jint();
984 }
985 LIR_Opr base_op = buf.result();
986
987 #ifndef _LP64
988 if (!is_updateBytes) { // long b raw address
989 base_op = new_register(T_INT);
990 __ convert(Bytecodes::_l2i, buf.result(), base_op);
991 }
992 #else
993 if (index->is_valid()) {
994 LIR_Opr tmp = new_register(T_LONG);
995 __ convert(Bytecodes::_i2l, index, tmp);
996 index = tmp;
997 }
998 #endif
999
1000 if (is_updateBytes) {
1001 base_op = access_resolve(IN_HEAP | IS_NOT_NULL | ACCESS_READ, base_op, NULL);
1002 }
1003
1004 LIR_Address* a = new LIR_Address(base_op,
1005 index,
1006 offset,
1007 T_BYTE);
1008 BasicTypeList signature(3);
1009 signature.append(T_INT);
1010 signature.append(T_ADDRESS);
1011 signature.append(T_INT);
1012 CallingConvention* cc = frame_map()->c_calling_convention(&signature);
1013 const LIR_Opr result_reg = result_register_for(x->type());
1014
1015 LIR_Opr addr = new_pointer_register();
1016 __ leal(LIR_OprFact::address(a), addr);
1017
1018 crc.load_item_force(cc->at(0));
1019 __ move(addr, cc->at(1));
1020 len.load_item_force(cc->at(2));
1021
1022 __ call_runtime_leaf(StubRoutines::updateBytesCRC32(), getThreadTemp(), result_reg, cc->args());
1023 __ move(result_reg, result);
1041 LIR_Opr result = rlock_result(x);
1042
1043 LIRItem a(x->argument_at(0), this); // Object
1044 LIRItem aOffset(x->argument_at(1), this); // long
1045 LIRItem b(x->argument_at(2), this); // Object
1046 LIRItem bOffset(x->argument_at(3), this); // long
1047 LIRItem length(x->argument_at(4), this); // int
1048 LIRItem log2ArrayIndexScale(x->argument_at(5), this); // int
1049
1050 a.load_item();
1051 aOffset.load_nonconstant();
1052 b.load_item();
1053 bOffset.load_nonconstant();
1054
1055 long constant_aOffset = 0;
1056 LIR_Opr result_aOffset = aOffset.result();
1057 if (result_aOffset->is_constant()) {
1058 constant_aOffset = result_aOffset->as_jlong();
1059 result_aOffset = LIR_OprFact::illegalOpr;
1060 }
1061 LIR_Opr result_a = access_resolve(IN_HEAP | ACCESS_READ, a.result(), NULL);
1062
1063 long constant_bOffset = 0;
1064 LIR_Opr result_bOffset = bOffset.result();
1065 if (result_bOffset->is_constant()) {
1066 constant_bOffset = result_bOffset->as_jlong();
1067 result_bOffset = LIR_OprFact::illegalOpr;
1068 }
1069 LIR_Opr result_b = access_resolve(IN_HEAP | ACCESS_READ, b.result(), NULL);
1070
1071 #ifndef _LP64
1072 result_a = new_register(T_INT);
1073 __ convert(Bytecodes::_l2i, a.result(), result_a);
1074 result_b = new_register(T_INT);
1075 __ convert(Bytecodes::_l2i, b.result(), result_b);
1076 #endif
1077
1078
1079 LIR_Address* addr_a = new LIR_Address(result_a,
1080 result_aOffset,
1081 constant_aOffset,
1082 T_BYTE);
1083
1084 LIR_Address* addr_b = new LIR_Address(result_b,
1085 result_bOffset,
1086 constant_bOffset,
1087 T_BYTE);
1088
1089 BasicTypeList signature(4);
|