src/cpu/x86/vm/sharedRuntime_x86_64.cpp

*** 4156,4160 ****
--- 4156,4257 ----
  
    // Set exception blob
    _exception_blob =  ExceptionBlob::create(&buffer, oop_maps, SimpleRuntimeFrame::framesize >> 1);
  }
  #endif // COMPILER2
+ 
+ BufferedValueTypeBlob* SharedRuntime::generate_buffered_value_type_adapter(const ValueKlass* vk) {
+   BufferBlob* buf = BufferBlob::create("value types", 16 * K);
+   CodeBuffer buffer(buf);
+   short buffer_locs[20];
+   buffer.insts()->initialize_shared_locs((relocInfo*)buffer_locs,
+                                          sizeof(buffer_locs)/sizeof(relocInfo));
+ 
+   MacroAssembler _masm(&buffer);
+   MacroAssembler* masm = &_masm;
+ 
+   const Array<SigEntry>* sig_vk = vk->extended_sig();
+   const Array<VMRegPair>* regs = vk->return_regs();
+ 
+   int pack_fields_off = __ offset();
+ 
+   int j = 1;
+   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) {
+         j++;
+       }
+       continue;
+     }
+     int off = sig_vk->at(i)._offset;
+     VMRegPair pair = regs->at(j);
+     VMReg r_1 = pair.first();
+     VMReg r_2 = pair.second();
+     Address to(rax, off);
+     if (bt == T_FLOAT) {
+       __ movflt(to, r_1->as_XMMRegister());
+     } else if (bt == T_DOUBLE) {
+       __ movdbl(to, r_1->as_XMMRegister());
+     } else if (bt == T_OBJECT || bt == T_ARRAY) {
+       __ store_heap_oop(to, r_1->as_Register());
+     } else {
+       assert(is_java_primitive(bt), "unexpected basic type");
+       size_t size_in_bytes = type2aelembytes(bt);
+       __ store_sized_value(to, r_1->as_Register(), size_in_bytes);
+     }
+     j++;
+   }
+   assert(j == regs->length(), "missed a field?");
+ 
+   __ ret(0);
+ 
+   int unpack_fields_off = __ offset();
+ 
+   j = 1;
+   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) {
+         j++;
+       }
+       continue;
+     }
+     int off = sig_vk->at(i)._offset;
+     VMRegPair pair = regs->at(j);
+     VMReg r_1 = pair.first();
+     VMReg r_2 = pair.second();
+     Address from(rax, off);
+     if (bt == T_FLOAT) {
+       __ movflt(r_1->as_XMMRegister(), from);
+     } else if (bt == T_DOUBLE) {
+       __ movdbl(r_1->as_XMMRegister(), from);
+     } else if (bt == T_OBJECT || bt == T_ARRAY) {
+       __ load_heap_oop(r_1->as_Register(), from);
+     } else {
+       assert(is_java_primitive(bt), "unexpected basic type");
+       size_t size_in_bytes = type2aelembytes(bt);
+       __ load_sized_value(r_1->as_Register(), from, size_in_bytes, bt != T_CHAR && bt != T_BOOLEAN);
+     }
+     j++;
+   }
+   assert(j == regs->length(), "missed a field?");
+ 
+   if (StressValueTypeReturnedAsFields) {
+     __ load_klass(rax, rax);
+     __ orptr(rax, 1);
+   }
+ 
+   __ ret(0);
+ 
+   __ flush();
+ 
+   return BufferedValueTypeBlob::create(&buffer, pack_fields_off, unpack_fields_off);
+ }