src/hotspot/share/runtime/sharedRuntime.cpp

@@ -2689,11 +2689,11 @@
 
       int i = 0;
       if (!method->is_static()) {  // Pass in receiver first
         if (holder->is_value()) {
           ValueKlass* vk = ValueKlass::cast(holder);
-          if (!ValueTypePassFieldsAsArgs || vk->is__Value()) {
+          if (!ValueTypePassFieldsAsArgs) {
             // If we don't pass value types as arguments or if the holder of
             // the method is __Value, we must pass a reference.
             sig_extended.push(SigEntry(T_VALUETYPEPTR));
           } else {
             const Array<SigEntry>* sig_vk = vk->extended_sig();

@@ -2704,11 +2704,11 @@
         }
       }
       for (SignatureStream ss(method->signature()); !ss.at_return_type(); ss.next()) {
         if (ss.type() == T_VALUETYPE) {
           Symbol* name = ss.as_symbol(CHECK_NULL);
-          if (!ValueTypePassFieldsAsArgs || (name == vmSymbols::java_lang____Value())) {
+          if (!ValueTypePassFieldsAsArgs) {
             sig_extended.push(SigEntry(T_VALUETYPEPTR));
           } else {
             // Method handle intrinsics with a __Value argument may be created during
             // compilation. Only do a full system dictionary lookup if the argument name
             // is not __Value, to avoid lookups from the compiler thread.

@@ -2949,11 +2949,10 @@
           if (THREAD->can_call_java()) {
             Handle class_loader(THREAD, method->method_holder()->class_loader());
             Handle protection_domain(THREAD, method->method_holder()->protection_domain());
             Klass* k = ss.as_klass(class_loader, protection_domain, SignatureStream::ReturnNull, THREAD);
             assert(k != NULL && !HAS_PENDING_EXCEPTION, "can't resolve klass");
-            assert(ValueKlass::cast(k)->is__Value(), "other values not supported");
           }
 #endif
           bt = T_VALUETYPEPTR;
         }
         sig_bt[i++] = bt;  // Collect remaining bits of signature

@@ -3049,21 +3048,20 @@
     case 'I': sig_bt[cnt++] = T_INT;     break;
     case 'J': sig_bt[cnt++] = T_LONG;    sig_bt[cnt++] = T_VOID; break;
     case 'S': sig_bt[cnt++] = T_SHORT;   break;
     case 'Z': sig_bt[cnt++] = T_BOOLEAN; break;
     case 'V': sig_bt[cnt++] = T_VOID;    break;
-    case 'Q':
     case 'L':                   // Oop
       while (*s++ != ';');   // Skip signature
       sig_bt[cnt++] = T_OBJECT;
       break;
     case '[': {                 // Array
       do {                      // Skip optional size
         while (*s >= '0' && *s <= '9') s++;
       } while (*s++ == '[');   // Nested arrays?
       // Skip element type
-      if (s[-1] == 'L' || s[-1] == 'Q')
+      if (s[-1] == 'L')
         while (*s++ != ';'); // Skip signature
       sig_bt[cnt++] = T_ARRAY;
       break;
     }
     default : ShouldNotReachHere();

@@ -3503,11 +3501,11 @@
     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->is__Value(), "Bad value klass");
+    assert(verif_vk == verif_vk2, "Bad value klass");
 #endif
   }
   JRT_BLOCK_END;
 
   thread->set_vm_result(new_vt());