1212 break;
1213 }
1214 default: {
1215 ShouldNotReachHere();
1216 }
1217 }
1218 }
1219
1220 void LIRGenerator::do_update_CRC32C(Intrinsic* x) {
1221 assert(UseCRC32CIntrinsics, "or should not be here");
1222 LIR_Opr result = rlock_result(x);
1223
1224 switch (x->id()) {
1225 case vmIntrinsics::_updateBytesCRC32C:
1226 case vmIntrinsics::_updateDirectByteBufferCRC32C: {
1227 bool is_updateBytes = (x->id() == vmIntrinsics::_updateBytesCRC32C);
1228
1229 LIRItem crc(x->argument_at(0), this);
1230 LIRItem buf(x->argument_at(1), this);
1231 LIRItem off(x->argument_at(2), this);
1232 LIRItem len(x->argument_at(3), this);
1233 buf.load_item();
1234 off.load_nonconstant();
1235
1236 LIR_Opr index = off.result();
1237 int offset = is_updateBytes ? arrayOopDesc::base_offset_in_bytes(T_BYTE) : 0;
1238 if (off.result()->is_constant()) {
1239 index = LIR_OprFact::illegalOpr;
1240 offset += off.result()->as_jint();
1241 }
1242 LIR_Opr base_op = buf.result();
1243
1244 if (index->is_valid()) {
1245 LIR_Opr tmp = new_register(T_LONG);
1246 __ convert(Bytecodes::_i2l, index, tmp);
1247 index = tmp;
1248 }
1249
1250 LIR_Address* a = new LIR_Address(base_op, index, offset, T_BYTE);
1251
1252 BasicTypeList signature(3);
1253 signature.append(T_INT);
1254 signature.append(T_ADDRESS);
1255 signature.append(T_INT);
1256 CallingConvention* cc = frame_map()->c_calling_convention(&signature);
1257 const LIR_Opr result_reg = result_register_for (x->type());
1258
1259 LIR_Opr arg1 = cc->at(0);
1260 LIR_Opr arg2 = cc->at(1);
1261 LIR_Opr arg3 = cc->at(2);
1262
1263 crc.load_item_force(arg1); // We skip int->long conversion here, because CRC32C stub doesn't care about high bits.
1264 __ leal(LIR_OprFact::address(a), arg2);
1265 len.load_item_force(arg3); // We skip int->long conversion here, because CRC32C stub expects int.
1266
1267 __ call_runtime_leaf(StubRoutines::updateBytesCRC32C(), LIR_OprFact::illegalOpr, result_reg, cc->args());
1268 __ move(result_reg, result);
1269 break;
1270 }
1271 default: {
1272 ShouldNotReachHere();
1273 }
1274 }
1275 }
1276
1277 void LIRGenerator::do_FmaIntrinsic(Intrinsic* x) {
1278 assert(x->number_of_arguments() == 3, "wrong type");
1279 assert(UseFMA, "Needs FMA instructions support.");
1280 LIRItem value(x->argument_at(0), this);
1281 LIRItem value1(x->argument_at(1), this);
1282 LIRItem value2(x->argument_at(2), this);
1283
1284 value2.set_destroys_register();
1285
|
1212 break;
1213 }
1214 default: {
1215 ShouldNotReachHere();
1216 }
1217 }
1218 }
1219
1220 void LIRGenerator::do_update_CRC32C(Intrinsic* x) {
1221 assert(UseCRC32CIntrinsics, "or should not be here");
1222 LIR_Opr result = rlock_result(x);
1223
1224 switch (x->id()) {
1225 case vmIntrinsics::_updateBytesCRC32C:
1226 case vmIntrinsics::_updateDirectByteBufferCRC32C: {
1227 bool is_updateBytes = (x->id() == vmIntrinsics::_updateBytesCRC32C);
1228
1229 LIRItem crc(x->argument_at(0), this);
1230 LIRItem buf(x->argument_at(1), this);
1231 LIRItem off(x->argument_at(2), this);
1232 LIRItem end(x->argument_at(3), this);
1233 buf.load_item();
1234 off.load_nonconstant();
1235 end.load_nonconstant();
1236
1237 // len = end - off
1238 LIR_Opr len = end.result();
1239 LIR_Opr tmpA = new_register(T_INT);
1240 LIR_Opr tmpB = new_register(T_INT);
1241 __ move(end.result(), tmpA);
1242 __ move(off.result(), tmpB);
1243 __ sub(tmpA, tmpB, tmpA);
1244 len = tmpA;
1245
1246 LIR_Opr index = off.result();
1247 int offset = is_updateBytes ? arrayOopDesc::base_offset_in_bytes(T_BYTE) : 0;
1248 if (off.result()->is_constant()) {
1249 index = LIR_OprFact::illegalOpr;
1250 offset += off.result()->as_jint();
1251 }
1252 LIR_Opr base_op = buf.result();
1253
1254 if (index->is_valid()) {
1255 LIR_Opr tmp = new_register(T_LONG);
1256 __ convert(Bytecodes::_i2l, index, tmp);
1257 index = tmp;
1258 }
1259
1260 LIR_Address* a = new LIR_Address(base_op, index, offset, T_BYTE);
1261
1262 BasicTypeList signature(3);
1263 signature.append(T_INT);
1264 signature.append(T_ADDRESS);
1265 signature.append(T_INT);
1266 CallingConvention* cc = frame_map()->c_calling_convention(&signature);
1267 const LIR_Opr result_reg = result_register_for (x->type());
1268
1269 LIR_Opr arg1 = cc->at(0);
1270 LIR_Opr arg2 = cc->at(1);
1271 LIR_Opr arg3 = cc->at(2);
1272
1273 crc.load_item_force(arg1); // We skip int->long conversion here, because CRC32C stub doesn't care about high bits.
1274 __ leal(LIR_OprFact::address(a), arg2);
1275 __ move(len, cc->at(2)); // We skip int->long conversion here, because CRC32C stub expects int.
1276
1277 __ call_runtime_leaf(StubRoutines::updateBytesCRC32C(), LIR_OprFact::illegalOpr, result_reg, cc->args());
1278 __ move(result_reg, result);
1279 break;
1280 }
1281 default: {
1282 ShouldNotReachHere();
1283 }
1284 }
1285 }
1286
1287 void LIRGenerator::do_FmaIntrinsic(Intrinsic* x) {
1288 assert(x->number_of_arguments() == 3, "wrong type");
1289 assert(UseFMA, "Needs FMA instructions support.");
1290 LIRItem value(x->argument_at(0), this);
1291 LIRItem value1(x->argument_at(1), this);
1292 LIRItem value2(x->argument_at(2), this);
1293
1294 value2.set_destroys_register();
1295
|