Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
hotspot/src/share/vm/opto/superword.cpp
changeset 13883 6979b9850feb
parent 13490 d19348851d2e
child 13885 6b056026ecad
equal deleted inserted replaced
13882:80d5d0d21b75 13883:6979b9850feb 
  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---------------------------
jdk-sandbox