Mercurial > jdk8-mips64-public > hotspot / file comparison
comparison: src/share/vm/opto/superword.cpp
src/share/vm/opto/superword.cpp
- changeset 4103
- 137868b7aa6f
- parent 4006
- 5af51c882207
- child 4105
- 8ae8f9dd7099
equal
deleted
inserted
replaced
| 4102:8d3cc6612bd1 | 4103:137868b7aa6f |
|---|---|
| 1348 // Insert extract (unpack) operations for scalar uses | 1348 // Insert extract (unpack) operations for scalar uses |
| 1349 for (int i = 0; i < _packset.length(); i++) { | 1349 for (int i = 0; i < _packset.length(); i++) { |
| 1350 insert_extracts(_packset.at(i)); | 1350 insert_extracts(_packset.at(i)); |
| 1351 } | 1351 } |
| 1352 | 1352 |
| 1353 Compile* C = _phase->C; | |
| 1354 uint max_vlen_in_bytes = 0; | |
| 1353 for (int i = 0; i < _block.length(); i++) { | 1355 for (int i = 0; i < _block.length(); i++) { |
| 1354 Node* n = _block.at(i); | 1356 Node* n = _block.at(i); |
| 1355 Node_List* p = my_pack(n); | 1357 Node_List* p = my_pack(n); |
| 1356 if (p && n == executed_last(p)) { | 1358 if (p && n == executed_last(p)) { |
| 1357 uint vlen = p->size(); | 1359 uint vlen = p->size(); |
| 1360 uint vlen_in_bytes = 0; | |
| 1358 Node* vn = NULL; | 1361 Node* vn = NULL; |
| 1359 Node* low_adr = p->at(0); | 1362 Node* low_adr = p->at(0); |
| 1360 Node* first = executed_first(p); | 1363 Node* first = executed_first(p); |
| 1361 int opc = n->Opcode(); | 1364 int opc = n->Opcode(); |
| 1362 if (n->is_Load()) { | 1365 if (n->is_Load()) { |
| 1363 Node* ctl = n->in(MemNode::Control); | 1366 Node* ctl = n->in(MemNode::Control); |
| 1364 Node* mem = first->in(MemNode::Memory); | 1367 Node* mem = first->in(MemNode::Memory); |
| 1365 Node* adr = low_adr->in(MemNode::Address); | 1368 Node* adr = low_adr->in(MemNode::Address); |
| 1366 const TypePtr* atyp = n->adr_type(); | 1369 const TypePtr* atyp = n->adr_type(); |
| 1367 vn = LoadVectorNode::make(_phase->C, opc, ctl, mem, adr, atyp, vlen, velt_basic_type(n)); | 1370 vn = LoadVectorNode::make(C, opc, ctl, mem, adr, atyp, vlen, velt_basic_type(n)); |
| 1371 vlen_in_bytes = vn->as_LoadVector()->memory_size(); | |
| 1368 } else if (n->is_Store()) { | 1372 } else if (n->is_Store()) { |
| 1369 // Promote value to be stored to vector | 1373 // Promote value to be stored to vector |
| 1370 Node* val = vector_opd(p, MemNode::ValueIn); | 1374 Node* val = vector_opd(p, MemNode::ValueIn); |
| 1371 Node* ctl = n->in(MemNode::Control); | 1375 Node* ctl = n->in(MemNode::Control); |
| 1372 Node* mem = first->in(MemNode::Memory); | 1376 Node* mem = first->in(MemNode::Memory); |
| 1373 Node* adr = low_adr->in(MemNode::Address); | 1377 Node* adr = low_adr->in(MemNode::Address); |
| 1374 const TypePtr* atyp = n->adr_type(); | 1378 const TypePtr* atyp = n->adr_type(); |
| 1375 vn = StoreVectorNode::make(_phase->C, opc, ctl, mem, adr, atyp, val, vlen); | 1379 vn = StoreVectorNode::make(C, opc, ctl, mem, adr, atyp, val, vlen); |
| 1380 vlen_in_bytes = vn->as_StoreVector()->memory_size(); | |
| 1376 } else if (n->req() == 3) { | 1381 } else if (n->req() == 3) { |
| 1377 // Promote operands to vector | 1382 // Promote operands to vector |
| 1378 Node* in1 = vector_opd(p, 1); | 1383 Node* in1 = vector_opd(p, 1); |
| 1379 Node* in2 = vector_opd(p, 2); | 1384 Node* in2 = vector_opd(p, 2); |
| 1380 if (VectorNode::is_invariant_vector(in1) && (n->is_Add() || n->is_Mul())) { | 1385 if (VectorNode::is_invariant_vector(in1) && (n->is_Add() || n->is_Mul())) { |
| 1381 // Move invariant vector input into second position to avoid register spilling. | 1386 // Move invariant vector input into second position to avoid register spilling. |
| 1382 Node* tmp = in1; | 1387 Node* tmp = in1; |
| 1383 in1 = in2; | 1388 in1 = in2; |
| 1384 in2 = tmp; | 1389 in2 = tmp; |
| 1385 } | 1390 } |
| 1386 vn = VectorNode::make(_phase->C, opc, in1, in2, vlen, velt_basic_type(n)); | 1391 vn = VectorNode::make(C, opc, in1, in2, vlen, velt_basic_type(n)); |
| 1392 vlen_in_bytes = vn->as_Vector()->length_in_bytes(); | |
| 1387 } else { | 1393 } else { |
| 1388 ShouldNotReachHere(); | 1394 ShouldNotReachHere(); |
| 1389 } | 1395 } |
| 1390 assert(vn != NULL, "sanity"); | 1396 assert(vn != NULL, "sanity"); |
| 1391 _phase->_igvn.register_new_node_with_optimizer(vn); | 1397 _phase->_igvn.register_new_node_with_optimizer(vn); |
| 1393 for (uint j = 0; j < p->size(); j++) { | 1399 for (uint j = 0; j < p->size(); j++) { |
| 1394 Node* pm = p->at(j); | 1400 Node* pm = p->at(j); |
| 1395 _igvn.replace_node(pm, vn); | 1401 _igvn.replace_node(pm, vn); |
| 1396 } | 1402 } |
| 1397 _igvn._worklist.push(vn); | 1403 _igvn._worklist.push(vn); |
| 1404 | |
| 1405 if (vlen_in_bytes > max_vlen_in_bytes) { | |
| 1406 max_vlen_in_bytes = vlen_in_bytes; | |
| 1407 } | |
| 1398 #ifdef ASSERT | 1408 #ifdef ASSERT |
| 1399 if (TraceNewVectors) { | 1409 if (TraceNewVectors) { |
| 1400 tty->print("new Vector node: "); | 1410 tty->print("new Vector node: "); |
| 1401 vn->dump(); | 1411 vn->dump(); |
| 1402 } | 1412 } |
| 1403 #endif | 1413 #endif |
| 1404 } | 1414 } |
| 1405 } | 1415 } |
| 1416 C->set_max_vector_size(max_vlen_in_bytes); | |
| 1406 } | 1417 } |
| 1407 | 1418 |
| 1408 //------------------------------vector_opd--------------------------- | 1419 //------------------------------vector_opd--------------------------- |
| 1409 // Create a vector operand for the nodes in pack p for operand: in(opd_idx) | 1420 // Create a vector operand for the nodes in pack p for operand: in(opd_idx) |
| 1410 Node* SuperWord::vector_opd(Node_List* p, int opd_idx) { | 1421 Node* SuperWord::vector_opd(Node_List* p, int opd_idx) { |
| 1437 _phase->_igvn.register_new_node_with_optimizer(cnt); | 1448 _phase->_igvn.register_new_node_with_optimizer(cnt); |
| 1438 _phase->set_ctrl(cnt, _phase->get_ctrl(opd)); | 1449 _phase->set_ctrl(cnt, _phase->get_ctrl(opd)); |
| 1439 } | 1450 } |
| 1440 assert(opd->bottom_type()->isa_int(), "int type only"); | 1451 assert(opd->bottom_type()->isa_int(), "int type only"); |
| 1441 // Move non constant shift count into XMM register. | 1452 // Move non constant shift count into XMM register. |
| 1442 cnt = new (_phase->C, 2) MoveI2FNode(cnt); | 1453 cnt = new (C, 2) MoveI2FNode(cnt); |
| 1443 } | 1454 } |
| 1444 if (cnt != opd) { | 1455 if (cnt != opd) { |
| 1445 _phase->_igvn.register_new_node_with_optimizer(cnt); | 1456 _phase->_igvn.register_new_node_with_optimizer(cnt); |
| 1446 _phase->set_ctrl(cnt, _phase->get_ctrl(opd)); | 1457 _phase->set_ctrl(cnt, _phase->get_ctrl(opd)); |
| 1447 } | 1458 } |
| 1478 pk->add_opd(in); | 1489 pk->add_opd(in); |
| 1479 } | 1490 } |
| 1480 _phase->_igvn.register_new_node_with_optimizer(pk); | 1491 _phase->_igvn.register_new_node_with_optimizer(pk); |
| 1481 _phase->set_ctrl(pk, _phase->get_ctrl(opd)); | 1492 _phase->set_ctrl(pk, _phase->get_ctrl(opd)); |
| 1482 #ifdef ASSERT | 1493 #ifdef ASSERT |
| 1483 if (TraceNewVectors) { | 1494 if (TraceNewVectors) { |
| 1484 tty->print("new Vector node: "); | 1495 tty->print("new Vector node: "); |
| 1485 pk->dump(); | 1496 pk->dump(); |
| 1486 } | 1497 } |
| 1487 #endif | 1498 #endif |
| 1488 return pk; | 1499 return pk; |
| 1489 } | 1500 } |
| 1490 | 1501 |
| 1491 //------------------------------insert_extracts--------------------------- | 1502 //------------------------------insert_extracts--------------------------- |
