src/share/vm/opto/runtime.cpp

rev 10504 : value type calling convention

@@ -476,11 +476,11 @@
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
 
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 
 const TypeFunc *OptoRuntime::athrow_Type() {
   // create input type (domain)

@@ -491,11 +491,11 @@
   // create result type (range)
   fields = TypeTuple::fields(0);
 
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 
 const TypeFunc *OptoRuntime::new_array_Type() {
   // create input type (domain)

@@ -508,11 +508,11 @@
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
 
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc *OptoRuntime::multianewarray_Type(int ndim) {
   // create input type (domain)
   const int nargs = ndim + 1;

@@ -525,11 +525,11 @@
   // create result type (range)
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc *OptoRuntime::multianewarray2_Type() {
   return multianewarray_Type(2);
 }

@@ -556,11 +556,11 @@
   // create result type (range)
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc *OptoRuntime::g1_wb_pre_Type() {
   const Type **fields = TypeTuple::fields(2);
   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // original field value

@@ -569,11 +569,11 @@
 
   // create result type (range)
   fields = TypeTuple::fields(0);
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc *OptoRuntime::g1_wb_post_Type() {
 
   const Type **fields = TypeTuple::fields(2);

@@ -583,11 +583,11 @@
 
   // create result type (range)
   fields = TypeTuple::fields(0);
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc *OptoRuntime::uncommon_trap_Type() {
   // create input type (domain)
   const Type **fields = TypeTuple::fields(1);

@@ -596,11 +596,11 @@
 
   // create result type (range)
   fields = TypeTuple::fields(0);
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 //-----------------------------------------------------------------------------
 // Monitor Handling
 const TypeFunc *OptoRuntime::complete_monitor_enter_Type() {

@@ -613,11 +613,11 @@
   // create result type (range)
   fields = TypeTuple::fields(0);
 
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
 
-  return TypeFunc::make(domain,range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 
 //-----------------------------------------------------------------------------
 const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {

@@ -631,11 +631,11 @@
   // create result type (range)
   fields = TypeTuple::fields(0);
 
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc *OptoRuntime::monitor_notify_Type() {
   // create input type (domain)
   const Type **fields = TypeTuple::fields(1);

@@ -643,11 +643,11 @@
   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
 
   // create result type (range)
   fields = TypeTuple::fields(0);
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::flush_windows_Type() {
   // create input type (domain)
   const Type** fields = TypeTuple::fields(1);

@@ -657,11 +657,11 @@
   // create result type
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = NULL; // void
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::l2f_Type() {
   // create input type (domain)
   const Type **fields = TypeTuple::fields(2);

@@ -672,11 +672,11 @@
   // create result type (range)
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = Type::FLOAT;
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::modf_Type() {
   const Type **fields = TypeTuple::fields(2);
   fields[TypeFunc::Parms+0] = Type::FLOAT;

@@ -687,11 +687,11 @@
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = Type::FLOAT;
 
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc *OptoRuntime::Math_D_D_Type() {
   // create input type (domain)
   const Type **fields = TypeTuple::fields(2);

@@ -704,11 +704,11 @@
   fields = TypeTuple::fields(2);
   fields[TypeFunc::Parms+0] = Type::DOUBLE;
   fields[TypeFunc::Parms+1] = Type::HALF;
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::Math_DD_D_Type() {
   const Type **fields = TypeTuple::fields(4);
   fields[TypeFunc::Parms+0] = Type::DOUBLE;

@@ -721,11 +721,11 @@
   fields = TypeTuple::fields(2);
   fields[TypeFunc::Parms+0] = Type::DOUBLE;
   fields[TypeFunc::Parms+1] = Type::HALF;
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 //-------------- currentTimeMillis, currentTimeNanos, etc
 
 const TypeFunc* OptoRuntime::void_long_Type() {

@@ -737,11 +737,11 @@
   fields = TypeTuple::fields(2);
   fields[TypeFunc::Parms+0] = TypeLong::LONG;
   fields[TypeFunc::Parms+1] = Type::HALF;
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+2, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 // arraycopy stub variations:
 enum ArrayCopyType {
   ac_fast,                      // void(ptr, ptr, size_t)

@@ -783,11 +783,11 @@
   if (retcnt == 0)
     fields[TypeFunc::Parms+0] = NULL; // void
   else
     fields[TypeFunc::Parms+0] = TypeInt::INT; // status result, if needed
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+retcnt, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::fast_arraycopy_Type() {
   // This signature is simple:  Two base pointers and a size_t.
   return make_arraycopy_Type(ac_fast);

@@ -824,11 +824,11 @@
   // create result type
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = NULL; // void
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 // for aescrypt encrypt/decrypt operations, just three pointers returning void (length is constant)
 const TypeFunc* OptoRuntime::aescrypt_block_Type() {
   // create input type (domain)

@@ -850,11 +850,11 @@
 
   // no result type needed
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = NULL; // void
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 /**
  * int updateBytesCRC32(int crc, byte* b, int len)
  */

@@ -872,11 +872,11 @@
 
   // result type needed
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 /**
  * int updateBytesCRC32C(int crc, byte* buf, int len, int* table)
  */

@@ -895,11 +895,11 @@
 
   // result type needed
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 /**
 *  int updateBytesAdler32(int adler, bytes* b, int off, int len)
 */

@@ -917,11 +917,11 @@
 
   // result type needed
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 // for cipherBlockChaining calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
 const TypeFunc* OptoRuntime::cipherBlockChaining_aescrypt_Type() {
   // create input type (domain)

@@ -945,11 +945,11 @@
 
   // returning cipher len (int)
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeInt::INT;
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 //for counterMode calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
 const TypeFunc* OptoRuntime::counterMode_aescrypt_Type() {
   // create input type (domain)

@@ -974,11 +974,11 @@
   const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + argcnt, fields);
   // returning cipher len (int)
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms + 0] = TypeInt::INT;
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms + 1, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 /*
  * void implCompress(byte[] buf, int ofs)
  */

@@ -995,11 +995,11 @@
 
   // no result type needed
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = NULL; // void
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 /*
  * int implCompressMultiBlock(byte[] b, int ofs, int limit)
  */

@@ -1018,11 +1018,11 @@
 
   // returning ofs (int)
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeInt::INT; // ofs
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::multiplyToLen_Type() {
   // create input type (domain)
   int num_args      = 6;

@@ -1040,11 +1040,11 @@
 
   // no result type needed
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = NULL;
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::squareToLen_Type() {
   // create input type (domain)
   int num_args      = 4;

@@ -1060,11 +1060,11 @@
 
   // no result type needed
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = NULL;
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 // for mulAdd calls, 2 pointers and 3 ints, returning int
 const TypeFunc* OptoRuntime::mulAdd_Type() {
   // create input type (domain)

@@ -1082,11 +1082,11 @@
 
   // returning carry (int)
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeInt::INT;
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::montgomeryMultiply_Type() {
   // create input type (domain)
   int num_args      = 7;

@@ -1106,11 +1106,11 @@
   // result type needed
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypePtr::NOTNULL;
 
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::montgomerySquare_Type() {
   // create input type (domain)
   int num_args      = 6;

@@ -1129,11 +1129,11 @@
   // result type needed
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypePtr::NOTNULL;
 
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc* OptoRuntime::vectorizedMismatch_Type() {
   // create input type (domain)
   int num_args = 4;

@@ -1149,11 +1149,11 @@
 
   //return mismatch index (int)
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms + 0] = TypeInt::INT;
   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms + 1, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 // GHASH block processing
 const TypeFunc* OptoRuntime::ghash_processBlocks_Type() {
     int argcnt = 4;

@@ -1169,11 +1169,11 @@
 
     // result type needed
     fields = TypeTuple::fields(1);
     fields[TypeFunc::Parms+0] = NULL; // void
     const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
-    return TypeFunc::make(domain, range);
+    return TypeFunc::make(domain, domain, range);
 }
 
 //------------- Interpreter state access for on stack replacement
 const TypeFunc* OptoRuntime::osr_end_Type() {
   // create input type (domain)

@@ -1184,11 +1184,11 @@
   // create result type
   fields = TypeTuple::fields(1);
   // fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // locked oop
   fields[TypeFunc::Parms+0] = NULL; // void
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 //-------------- methodData update helpers
 
 const TypeFunc* OptoRuntime::profile_receiver_type_Type() {

@@ -1200,11 +1200,11 @@
 
   // create result type
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = NULL; // void
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
-  return TypeFunc::make(domain,range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 JRT_LEAF(void, OptoRuntime::profile_receiver_type_C(DataLayout* data, oopDesc* receiver))
   if (receiver == NULL) return;
   Klass* receiver_klass = receiver->klass();

@@ -1464,11 +1464,11 @@
   // create result type (range)
   fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Exception oop
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 
-  return TypeFunc::make(domain, range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 
 void OptoRuntime::deoptimize_caller_frame(JavaThread *thread, bool doit) {
   // Deoptimize the caller before continuing, as the compiled

@@ -1511,11 +1511,11 @@
   // create result type (range)
   fields = TypeTuple::fields(0);
 
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
 
-  return TypeFunc::make(domain,range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 
 //-----------------------------------------------------------------------------
 // Dtrace support.  entry and exit probes have the same signature

@@ -1529,11 +1529,11 @@
   // create result type (range)
   fields = TypeTuple::fields(0);
 
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
 
-  return TypeFunc::make(domain,range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 const TypeFunc *OptoRuntime::dtrace_object_alloc_Type() {
   // create input type (domain)
   const Type **fields = TypeTuple::fields(2);

@@ -1545,11 +1545,11 @@
   // create result type (range)
   fields = TypeTuple::fields(0);
 
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
 
-  return TypeFunc::make(domain,range);
+  return TypeFunc::make(domain, domain, range);
 }
 
 
 JRT_ENTRY_NO_ASYNC(void, OptoRuntime::register_finalizer(oopDesc* obj, JavaThread* thread))
   assert(obj->is_oop(), "must be a valid oop");