--- old/src/share/vm/runtime/sharedRuntime.cpp	2017-07-04 18:39:48.084148172 +0200
+++ new/src/share/vm/runtime/sharedRuntime.cpp	2017-07-04 18:39:48.006148531 +0200
@@ -2710,8 +2710,8 @@
             // fields for the value type.
             sig_extended.push(SigEntry(T_OBJECT));
           } else {
-            const GrowableArray<SigEntry>& sig_vk = vk->collect_fields();
-            sig_extended.appendAll(&sig_vk);
+            const Array<SigEntry>* sig_vk = vk->extended_sig();
+            sig_extended.appendAll(sig_vk);
           }
         } else {
           sig_extended.push(SigEntry(T_OBJECT));
@@ -2729,8 +2729,8 @@
                    "should not use __Value for a value type argument");
             sig_extended.push(SigEntry(T_OBJECT));
           } else {
-            const GrowableArray<SigEntry>& sig_vk = vk->collect_fields();
-            sig_extended.appendAll(&sig_vk);
+            const Array<SigEntry>* sig_vk = vk->extended_sig();
+            sig_extended.appendAll(sig_vk);
           }
         } else {
           sig_extended.push(SigEntry(ss.type()));
@@ -3354,9 +3354,8 @@
 
   ValueKlass* vk = ValueKlass::cast(res->klass());
 
-  VMRegPair* regs;
-  int nb_fields;
-  const GrowableArray<SigEntry>& sig_vk = vk->return_convention(regs, nb_fields);
+  const Array<SigEntry>* sig_vk = vk->extended_sig() ;
+  const Array<VMRegPair>* regs = vk->return_regs();
 
   if (regs == NULL) {
     // The fields of the value klass don't fit in registers, bail out
@@ -3364,20 +3363,20 @@
   }
 
   int j = 1;
-  for (int i = 0; i < sig_vk.length(); i++) {
-    BasicType bt = sig_vk.at(i)._bt;
+  for (int i = 0; i < sig_vk->length(); i++) {
+    BasicType bt = sig_vk->at(i)._bt;
     if (bt == T_VALUETYPE) {
       continue;
     }
     if (bt == T_VOID) {
-      if (sig_vk.at(i-1)._bt == T_LONG ||
-          sig_vk.at(i-1)._bt == T_DOUBLE) {
+      if (sig_vk->at(i-1)._bt == T_LONG ||
+          sig_vk->at(i-1)._bt == T_DOUBLE) {
         j++;
       }
       continue;
     }
-    int off = sig_vk.at(i)._offset;
-    VMRegPair pair = regs[j];
+    int off = sig_vk->at(i)._offset;
+    VMRegPair pair = regs->at(j);
     address loc = reg_map.location(pair.first());
     switch(bt) {
     case T_BOOLEAN:
@@ -3428,10 +3427,10 @@
     }
     j++;
   }
-  assert(j == nb_fields, "missed a field?");
+  assert(j == regs->length(), "missed a field?");
 
 #ifdef ASSERT
-  VMRegPair pair = regs[0];
+  VMRegPair pair = regs->at(0);
   address loc = reg_map.location(pair.first());
   assert(*(oopDesc**)loc == res, "overwritten object");
 #endif
@@ -3452,45 +3451,26 @@
 
 #ifdef ASSERT
   ValueKlass* verif_vk = ValueKlass::returned_value_type(reg_map);
-  javaVFrame* vf = javaVFrame::cast(vframe::new_vframe(&callerFrame, &reg_map, thread));
-  Method* m = vf->method();
-  int bci = vf->bci();
-  Bytecode_invoke inv(m, bci);
-
-  {
-    NoSafepointVerifier nsv;
-    methodHandle callee = inv.static_target(thread);
-    assert(!thread->has_pending_exception(), "call resolution should work");
-    ValueKlass* verif_vk2 = callee->returned_value_type(thread);
-    assert(verif_vk == NULL || verif_vk == verif_vk2 ||
-           verif_vk2 == SystemDictionary::___Value_klass(), "Bad value klass");
-
-  }
 #endif
 
-    if (!Metaspace::contains((void*)res)) {
+  if ((res & 1) == 0) {
     // We're not returning with value type fields in registers (the
     // calling convention didn't allow it for this value klass)
+    assert(!Metaspace::contains((void*)res), "should be oop or pointer in buffer area");
     thread->set_vm_result((oopDesc*)res);
     assert(verif_vk == NULL, "broken calling convention");
     return;
   }
 
+  res = res & ~1L;
   ValueKlass* vk = (ValueKlass*)res;
   assert(verif_vk == vk, "broken calling convention");
-
-  VMRegPair* regs;
-  int nb_fields;
-  const GrowableArray<SigEntry>& sig_vk = vk->return_convention(regs, nb_fields);
-  assert(regs != NULL, "return convention should allow return as fields");
-
-  regs++;
-  nb_fields--;
+  assert(Metaspace::contains((void*)res), "should be klass");
 
   // Allocate handles for every oop fields so they are safe in case of
   // a safepoint when allocating
   GrowableArray<Handle> handles;
-  vk->save_oop_fields(sig_vk, reg_map, regs, handles, nb_fields);
+  vk->save_oop_fields(reg_map, handles);
 
   // It's unsafe to safepoint until we are here
 
@@ -3498,8 +3478,20 @@
   JRT_BLOCK;
   {
     Thread* THREAD = thread;
-    oop vt = vk->realloc_result(sig_vk, reg_map, regs, handles, nb_fields, CHECK);
+    oop vt = vk->realloc_result(reg_map, handles, CHECK);
     new_vt = Handle(thread, vt);
+
+#ifdef ASSERT
+    javaVFrame* vf = javaVFrame::cast(vframe::new_vframe(&callerFrame, &reg_map, thread));
+    Method* m = vf->method();
+    int bci = vf->bci();
+    Bytecode_invoke inv(m, bci);
+
+    methodHandle callee = inv.static_target(thread);
+    assert(!thread->has_pending_exception(), "call resolution should work");
+    ValueKlass* verif_vk2 = callee->returned_value_type(thread);
+    assert(verif_vk == verif_vk2 || verif_vk2 == SystemDictionary::___Value_klass(), "Bad value klass");
+#endif
   }
   JRT_BLOCK_END;