1361   // Insert extract (unpack) operations for scalar uses
1362   for (int i = 0; i < _packset.length(); i++) {
1363     insert_extracts(_packset.at(i));
1364   }
1365 
1366   Compile* C = _phase->C;
1367   uint max_vlen_in_bytes = 0;
1368   for (int i = 0; i < _block.length(); i++) {
1369     Node* n = _block.at(i);
1370     Node_List* p = my_pack(n);
1371     if (p && n == executed_last(p)) {
1372       uint vlen = p->size();
1373       uint vlen_in_bytes = 0;
1374       Node* vn = NULL;
1375       Node* low_adr = p->at(0);
1376       Node* first   = executed_first(p);
1377       int   opc = n->Opcode();
1378       if (n->is_Load()) {
1379         Node* ctl = n->in(MemNode::Control);
1380         Node* mem = first->in(MemNode::Memory);














1381         Node* adr = low_adr->in(MemNode::Address);
1382         const TypePtr* atyp = n->adr_type();
1383         vn = LoadVectorNode::make(C, opc, ctl, mem, adr, atyp, vlen, velt_basic_type(n));
1384         vlen_in_bytes = vn->as_LoadVector()->memory_size();
1385       } else if (n->is_Store()) {
1386         // Promote value to be stored to vector
1387         Node* val = vector_opd(p, MemNode::ValueIn);
1388         Node* ctl = n->in(MemNode::Control);
1389         Node* mem = first->in(MemNode::Memory);
1390         Node* adr = low_adr->in(MemNode::Address);
1391         const TypePtr* atyp = n->adr_type();
1392         vn = StoreVectorNode::make(C, opc, ctl, mem, adr, atyp, val, vlen);
1393         vlen_in_bytes = vn->as_StoreVector()->memory_size();
1394       } else if (n->req() == 3) {
1395         // Promote operands to vector
1396         Node* in1 = vector_opd(p, 1);
1397         Node* in2 = vector_opd(p, 2);
1398         if (VectorNode::is_invariant_vector(in1) && (n->is_Add() || n->is_Mul())) {
1399           // Move invariant vector input into second position to avoid register spilling.
1400           Node* tmp = in1;

1361   // Insert extract (unpack) operations for scalar uses
1362   for (int i = 0; i < _packset.length(); i++) {
1363     insert_extracts(_packset.at(i));
1364   }
1365 
1366   Compile* C = _phase->C;
1367   uint max_vlen_in_bytes = 0;
1368   for (int i = 0; i < _block.length(); i++) {
1369     Node* n = _block.at(i);
1370     Node_List* p = my_pack(n);
1371     if (p && n == executed_last(p)) {
1372       uint vlen = p->size();
1373       uint vlen_in_bytes = 0;
1374       Node* vn = NULL;
1375       Node* low_adr = p->at(0);
1376       Node* first   = executed_first(p);
1377       int   opc = n->Opcode();
1378       if (n->is_Load()) {
1379         Node* ctl = n->in(MemNode::Control);
1380         Node* mem = first->in(MemNode::Memory);
1381         SWPointer p1(n->as_Mem(), this);
1382         // Identify the memory dependency for the new loadVector node by 
1383         // walking up through memory chain.
1384         // This is done to give flexibility to the new loadVector node so that 
1385         // it can move above independent storeVector nodes.
1386         while (mem->is_StoreVector()) {
1387           SWPointer p2(mem->as_Mem(), this);
1388           int cmp = p1.cmp(p2);
1389           if (SWPointer::not_equal(cmp) || !SWPointer::comparable(cmp)) {
1390             mem = mem->in(MemNode::Memory);
1391           } else {
1392             break; // dependent memory
1393           }
1394         }
1395         Node* adr = low_adr->in(MemNode::Address);
1396         const TypePtr* atyp = n->adr_type();
1397         vn = LoadVectorNode::make(C, opc, ctl, mem, adr, atyp, vlen, velt_basic_type(n));
1398         vlen_in_bytes = vn->as_LoadVector()->memory_size();
1399       } else if (n->is_Store()) {
1400         // Promote value to be stored to vector
1401         Node* val = vector_opd(p, MemNode::ValueIn);
1402         Node* ctl = n->in(MemNode::Control);
1403         Node* mem = first->in(MemNode::Memory);
1404         Node* adr = low_adr->in(MemNode::Address);
1405         const TypePtr* atyp = n->adr_type();
1406         vn = StoreVectorNode::make(C, opc, ctl, mem, adr, atyp, val, vlen);
1407         vlen_in_bytes = vn->as_StoreVector()->memory_size();
1408       } else if (n->req() == 3) {
1409         // Promote operands to vector
1410         Node* in1 = vector_opd(p, 1);
1411         Node* in2 = vector_opd(p, 2);
1412         if (VectorNode::is_invariant_vector(in1) && (n->is_Add() || n->is_Mul())) {
1413           // Move invariant vector input into second position to avoid register spilling.
1414           Node* tmp = in1;