--- old/src/hotspot/share/opto/library_call.cpp	2018-04-04 14:45:48.883206270 -0700
+++ new/src/hotspot/share/opto/library_call.cpp	2018-04-04 14:45:48.623206365 -0700
@@ -339,10 +339,11 @@
   bool inline_vector_blend();
   bool inline_vector_compare();
   bool inline_vector_broadcast_int();
-  bool inline_vector_rebracket();
+  bool inline_vector_reinterpret();
   Node* box_vector(Node* in, const TypeInstPtr* vbox_type, BasicType bt, int num_elem);
   Node* unbox_vector(Node* in, const TypeInstPtr* vbox_type, BasicType bt, int num_elem);
   Node* shift_count(Node* cnt, int shift_op, BasicType bt, int num_elem);
+  void set_vector_result(Node* result, bool set_res = true);
 
   void clear_upper_avx() {
 #ifdef X86
@@ -907,8 +908,8 @@
     return inline_vector_compare();
   case vmIntrinsics::_VectorBroadcastInt:
     return inline_vector_broadcast_int();
-  case vmIntrinsics::_VectorRebracket:
-    return inline_vector_rebracket();
+  case vmIntrinsics::_VectorReinterpret:
+    return inline_vector_reinterpret();
 
   default:
     // If you get here, it may be that someone has added a new intrinsic
@@ -7187,6 +7188,19 @@
   return unbox;
 }
 
+void LibraryCallKit::set_vector_result(Node* result, bool set_res) {
+  if (DebugVectorApi) {
+    tty->print("============ ");
+    callee()->print();
+    tty->print_cr(" ============");
+    result->dump(5);
+    tty->print_cr("----------------------------------------------------");
+  }
+  if (set_res) {
+    set_result(result);
+  }
+}
+
 bool LibraryCallKit::inline_vector_nary_operation(int n) {
   const TypeInt* opr              = gvn().type(argument(0))->is_int();
   const TypeInstPtr* vector_klass = gvn().type(argument(1))->is_instptr();
@@ -7253,7 +7267,7 @@
   }
   // Wrap it up in VectorBox to keep object type information.
   operation = box_vector(operation, vbox_type, elem_bt, num_elem);
-  set_result(operation);
+  set_vector_result(operation);
 
   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
   return true;
@@ -7318,7 +7332,7 @@
   Node* broadcast = VectorNode::scalar2vector(elem, num_elem, Type::get_const_basic_type(elem_bt));
   broadcast = gvn().transform(broadcast);
   Node* box = box_vector(broadcast, vbox_type, elem_bt, num_elem);
-  set_result(box);
+  set_vector_result(box);
 
   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
   return true;
@@ -7379,10 +7393,11 @@
     set_all_memory(reset_memory());
     Node* vstore = gvn().transform(StoreVectorNode::make(0, control(), memory(adr), adr, adr_type, val, num_elem));
     set_memory(vstore, adr_type);
+    set_vector_result(vstore, false);
   } else {
     Node* vload = gvn().transform(LoadVectorNode::make(0, control(), memory(adr), adr, adr_type, num_elem, elem_bt));
     Node* box = box_vector(vload, vbox_type, elem_bt, num_elem);
-    set_result(box);
+    set_vector_result(box);
   }
 
   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
@@ -7450,7 +7465,7 @@
     }
     default: fatal("%s", type2name(elem_bt));
   }
-  set_result(bits);
+  set_vector_result(bits);
   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
   return true;
 }
@@ -7489,7 +7504,7 @@
   }
   Node* test = new VectorTestNode(opd1, opd2, booltest);
   test = _gvn.transform(test);
-  set_result(test);
+  set_vector_result(test);
   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
   return true;
 }
@@ -7537,7 +7552,7 @@
 
   Node* blend = _gvn.transform(new VectorBlendNode(v1, v2, mask));
   Node* box = box_vector(blend, vbox_type, elem_bt, num_elem);
-  set_result(box);
+  set_vector_result(box);
 
   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
   return true;
@@ -7591,7 +7606,7 @@
   Node* operation = _gvn.transform(new VectorMaskCmpNode(pred, v1, v2, vt));
 
   Node* box = box_vector(operation, mbox_type, mask_bt, num_elem);
-  set_result(box);
+  set_vector_result(box);
 
   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
   return true;
@@ -7655,7 +7670,7 @@
   Node* operation = _gvn.transform(VectorNode::make(sopc, opd1, opd2, num_elem, elem_bt));
 
   Node* vbox = box_vector(operation, vbox_type, elem_bt, num_elem);
-  set_result(vbox);
+  set_vector_result(vbox);
   C->set_max_vector_size(MAX2(C->max_vector_size(), (uint)(num_elem * type2aelembytes(elem_bt))));
   return true;
 }
@@ -7677,15 +7692,16 @@
   return T_ILLEGAL;
 }
 
-bool LibraryCallKit::inline_vector_rebracket() {
+bool LibraryCallKit::inline_vector_reinterpret() {
   const TypeInstPtr* vector_klass_from = gvn().type(argument(0))->is_instptr();
   const TypeInstPtr* elem_klass_from   = gvn().type(argument(1))->is_instptr();
   const TypeInt*     vlen_from         = gvn().type(argument(2))->is_int();
 
   const TypeInstPtr* elem_klass_to     = gvn().type(argument(3))->is_instptr();
+  const TypeInt*     vlen_to           = gvn().type(argument(4))->is_int();
 
   if (vector_klass_from->const_oop() == NULL || elem_klass_from->const_oop() == NULL || !vlen_from->is_con() ||
-      elem_klass_to->const_oop() == NULL ) {
+      elem_klass_to->const_oop() == NULL || !vlen_to->is_con()) {
     return false; // not enough info for intrinsification
   }
 
@@ -7715,18 +7731,30 @@
     return false; // type mismatch
   }
   int num_elem_from = vlen_from->get_con();
+  int num_elem_to = vlen_to->get_con();
+  if (is_mask) {
+    elem_bt_to = getMaskBasicType(elem_bt_to);
+  }
 
-  int num_elem_to = (type2aelembytes(elem_bt_from) * num_elem_from) / type2aelembytes(elem_bt_to);
-  if (num_elem_to == 0) {
+  // Check whether we can unbox to appropriate size.
+  if (!arch_supports_vector(Op_VectorReinterpret,
+                            num_elem_from,
+                            elem_bt_from,
+                            is_mask ? VecMaskUseAll : VecMaskNotUsed)) {
     return false;
   }
-  if (is_mask) {
-    elem_bt_to = getMaskBasicType(elem_bt_to);
+
+  // Check whether we can support resizing/reinterpreting to the new size.
+  if (!arch_supports_vector(Op_VectorReinterpret,
+                            num_elem_to,
+                            elem_bt_to,
+                            is_mask ? VecMaskUseAll : VecMaskNotUsed)) {
+    return false;
   }
 
   const TypeInstPtr* vbox_type_from = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass_from);
 
-  Node* opd1 = unbox_vector(argument(4), vbox_type_from, elem_bt_from, num_elem_from);
+  Node* opd1 = unbox_vector(argument(5), vbox_type_from, elem_bt_from, num_elem_from);
   if (opd1 == NULL) {
     return false;
   }
@@ -7744,7 +7772,7 @@
                                                           num_elem_to, is_mask ? VECAPI_MASK : VECAPI_VECTOR);
   const TypeInstPtr* vbox_type_to = TypeInstPtr::make_exact(TypePtr::NotNull, vbox_klass_to);
   Node* vbox = box_vector(op, vbox_type_to, elem_bt_to, num_elem_to);
-  set_result(vbox);
+  set_vector_result(vbox);
   return true;
 }