hotspot Cdiff src/share/vm/opto/runtime.cpp

src/share/vm/opto/runtime.cpp

rev 10504 : value type calling convention


*** 476,486 ****
    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);
  }
  
  
  const TypeFunc *OptoRuntime::athrow_Type() {
    // create input type (domain)
--- 476,486 ----
    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, domain, range);
  }
  
  
  const TypeFunc *OptoRuntime::athrow_Type() {
    // create input type (domain)
*** 491,501 ****
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
  
!   return TypeFunc::make(domain, range);
  }
  
  
  const TypeFunc *OptoRuntime::new_array_Type() {
    // create input type (domain)
--- 491,501 ----
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
  
!   return TypeFunc::make(domain, domain, range);
  }
  
  
  const TypeFunc *OptoRuntime::new_array_Type() {
    // create input type (domain)
*** 508,518 ****
    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);
  }
  
  const TypeFunc *OptoRuntime::multianewarray_Type(int ndim) {
    // create input type (domain)
    const int nargs = ndim + 1;
--- 508,518 ----
    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, domain, range);
  }
  
  const TypeFunc *OptoRuntime::multianewarray_Type(int ndim) {
    // create input type (domain)
    const int nargs = ndim + 1;
*** 525,535 ****
    // 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);
  }
  
  const TypeFunc *OptoRuntime::multianewarray2_Type() {
    return multianewarray_Type(2);
  }
--- 525,535 ----
    // 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, domain, range);
  }
  
  const TypeFunc *OptoRuntime::multianewarray2_Type() {
    return multianewarray_Type(2);
  }
*** 556,566 ****
    // 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);
  }
  
  const TypeFunc *OptoRuntime::g1_wb_pre_Type() {
    const Type **fields = TypeTuple::fields(2);
    fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // original field value
--- 556,566 ----
    // 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, 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,579 ****
  
    // create result type (range)
    fields = TypeTuple::fields(0);
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
  
!   return TypeFunc::make(domain, range);
  }
  
  const TypeFunc *OptoRuntime::g1_wb_post_Type() {
  
    const Type **fields = TypeTuple::fields(2);
--- 569,579 ----
  
    // create result type (range)
    fields = TypeTuple::fields(0);
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
  
!   return TypeFunc::make(domain, domain, range);
  }
  
  const TypeFunc *OptoRuntime::g1_wb_post_Type() {
  
    const Type **fields = TypeTuple::fields(2);
*** 583,593 ****
  
    // create result type (range)
    fields = TypeTuple::fields(0);
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
  
!   return TypeFunc::make(domain, range);
  }
  
  const TypeFunc *OptoRuntime::uncommon_trap_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(1);
--- 583,593 ----
  
    // create result type (range)
    fields = TypeTuple::fields(0);
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms, fields);
  
!   return TypeFunc::make(domain, domain, range);
  }
  
  const TypeFunc *OptoRuntime::uncommon_trap_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(1);
*** 596,606 ****
  
    // create result type (range)
    fields = TypeTuple::fields(0);
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
  
!   return TypeFunc::make(domain, range);
  }
  
  //-----------------------------------------------------------------------------
  // Monitor Handling
  const TypeFunc *OptoRuntime::complete_monitor_enter_Type() {
--- 596,606 ----
  
    // create result type (range)
    fields = TypeTuple::fields(0);
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
  
!   return TypeFunc::make(domain, domain, range);
  }
  
  //-----------------------------------------------------------------------------
  // Monitor Handling
  const TypeFunc *OptoRuntime::complete_monitor_enter_Type() {
*** 613,623 ****
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   return TypeFunc::make(domain,range);
  }
  
  
  //-----------------------------------------------------------------------------
  const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {
--- 613,623 ----
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   return TypeFunc::make(domain, domain, range);
  }
  
  
  //-----------------------------------------------------------------------------
  const TypeFunc *OptoRuntime::complete_monitor_exit_Type() {
*** 631,641 ****
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
  
!   return TypeFunc::make(domain, range);
  }
  
  const TypeFunc *OptoRuntime::monitor_notify_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(1);
--- 631,641 ----
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
  
!   return TypeFunc::make(domain, domain, range);
  }
  
  const TypeFunc *OptoRuntime::monitor_notify_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(1);
*** 643,653 ****
    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);
  }
  
  const TypeFunc* OptoRuntime::flush_windows_Type() {
    // create input type (domain)
    const Type** fields = TypeTuple::fields(1);
--- 643,653 ----
    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, domain, range);
  }
  
  const TypeFunc* OptoRuntime::flush_windows_Type() {
    // create input type (domain)
    const Type** fields = TypeTuple::fields(1);
*** 657,667 ****
    // 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);
  }
  
  const TypeFunc* OptoRuntime::l2f_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(2);
--- 657,667 ----
    // 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, domain, range);
  }
  
  const TypeFunc* OptoRuntime::l2f_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(2);
*** 672,682 ****
    // 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);
  }
  
  const TypeFunc* OptoRuntime::modf_Type() {
    const Type **fields = TypeTuple::fields(2);
    fields[TypeFunc::Parms+0] = Type::FLOAT;
--- 672,682 ----
    // 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, domain, range);
  }
  
  const TypeFunc* OptoRuntime::modf_Type() {
    const Type **fields = TypeTuple::fields(2);
    fields[TypeFunc::Parms+0] = Type::FLOAT;
*** 687,697 ****
    fields = TypeTuple::fields(1);
    fields[TypeFunc::Parms+0] = Type::FLOAT;
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
  
!   return TypeFunc::make(domain, range);
  }
  
  const TypeFunc *OptoRuntime::Math_D_D_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(2);
--- 687,697 ----
    fields = TypeTuple::fields(1);
    fields[TypeFunc::Parms+0] = Type::FLOAT;
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
  
!   return TypeFunc::make(domain, domain, range);
  }
  
  const TypeFunc *OptoRuntime::Math_D_D_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(2);
*** 704,714 ****
    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);
  }
  
  const TypeFunc* OptoRuntime::Math_DD_D_Type() {
    const Type **fields = TypeTuple::fields(4);
    fields[TypeFunc::Parms+0] = Type::DOUBLE;
--- 704,714 ----
    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, domain, range);
  }
  
  const TypeFunc* OptoRuntime::Math_DD_D_Type() {
    const Type **fields = TypeTuple::fields(4);
    fields[TypeFunc::Parms+0] = Type::DOUBLE;
*** 721,731 ****
    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);
  }
  
  //-------------- currentTimeMillis, currentTimeNanos, etc
  
  const TypeFunc* OptoRuntime::void_long_Type() {
--- 721,731 ----
    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, domain, range);
  }
  
  //-------------- currentTimeMillis, currentTimeNanos, etc
  
  const TypeFunc* OptoRuntime::void_long_Type() {
*** 737,747 ****
    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);
  }
  
  // arraycopy stub variations:
  enum ArrayCopyType {
    ac_fast,                      // void(ptr, ptr, size_t)
--- 737,747 ----
    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, domain, range);
  }
  
  // arraycopy stub variations:
  enum ArrayCopyType {
    ac_fast,                      // void(ptr, ptr, size_t)
*** 783,793 ****
    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);
  }
  
  const TypeFunc* OptoRuntime::fast_arraycopy_Type() {
    // This signature is simple:  Two base pointers and a size_t.
    return make_arraycopy_Type(ac_fast);
--- 783,793 ----
    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, 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,834 ****
    // 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);
  }
  
  // for aescrypt encrypt/decrypt operations, just three pointers returning void (length is constant)
  const TypeFunc* OptoRuntime::aescrypt_block_Type() {
    // create input type (domain)
--- 824,834 ----
    // 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, 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,860 ****
  
    // 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);
  }
  
  /**
   * int updateBytesCRC32(int crc, byte* b, int len)
   */
--- 850,860 ----
  
    // 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, domain, range);
  }
  
  /**
   * int updateBytesCRC32(int crc, byte* b, int len)
   */
*** 872,882 ****
  
    // 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);
  }
  
  /**
   * int updateBytesCRC32C(int crc, byte* buf, int len, int* table)
   */
--- 872,882 ----
  
    // 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, domain, range);
  }
  
  /**
   * int updateBytesCRC32C(int crc, byte* buf, int len, int* table)
   */
*** 895,905 ****
  
    // 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);
  }
  
  /**
  *  int updateBytesAdler32(int adler, bytes* b, int off, int len)
  */
--- 895,905 ----
  
    // 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, domain, range);
  }
  
  /**
  *  int updateBytesAdler32(int adler, bytes* b, int off, int len)
  */
*** 917,927 ****
  
    // 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);
  }
  
  // for cipherBlockChaining calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
  const TypeFunc* OptoRuntime::cipherBlockChaining_aescrypt_Type() {
    // create input type (domain)
--- 917,927 ----
  
    // 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, 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,955 ****
  
    // 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);
  }
  
  //for counterMode calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
  const TypeFunc* OptoRuntime::counterMode_aescrypt_Type() {
    // create input type (domain)
--- 945,955 ----
  
    // 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, 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,984 ****
    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);
  }
  
  /*
   * void implCompress(byte[] buf, int ofs)
   */
--- 974,984 ----
    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, domain, range);
  }
  
  /*
   * void implCompress(byte[] buf, int ofs)
   */
*** 995,1005 ****
  
    // 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);
  }
  
  /*
   * int implCompressMultiBlock(byte[] b, int ofs, int limit)
   */
--- 995,1005 ----
  
    // 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, domain, range);
  }
  
  /*
   * int implCompressMultiBlock(byte[] b, int ofs, int limit)
   */
*** 1018,1028 ****
  
    // 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);
  }
  
  const TypeFunc* OptoRuntime::multiplyToLen_Type() {
    // create input type (domain)
    int num_args      = 6;
--- 1018,1028 ----
  
    // 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, domain, range);
  }
  
  const TypeFunc* OptoRuntime::multiplyToLen_Type() {
    // create input type (domain)
    int num_args      = 6;
*** 1040,1050 ****
  
    // 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);
  }
  
  const TypeFunc* OptoRuntime::squareToLen_Type() {
    // create input type (domain)
    int num_args      = 4;
--- 1040,1050 ----
  
    // 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, domain, range);
  }
  
  const TypeFunc* OptoRuntime::squareToLen_Type() {
    // create input type (domain)
    int num_args      = 4;
*** 1060,1070 ****
  
    // 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);
  }
  
  // for mulAdd calls, 2 pointers and 3 ints, returning int
  const TypeFunc* OptoRuntime::mulAdd_Type() {
    // create input type (domain)
--- 1060,1070 ----
  
    // 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, domain, range);
  }
  
  // for mulAdd calls, 2 pointers and 3 ints, returning int
  const TypeFunc* OptoRuntime::mulAdd_Type() {
    // create input type (domain)
*** 1082,1092 ****
  
    // 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);
  }
  
  const TypeFunc* OptoRuntime::montgomeryMultiply_Type() {
    // create input type (domain)
    int num_args      = 7;
--- 1082,1092 ----
  
    // 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, domain, range);
  }
  
  const TypeFunc* OptoRuntime::montgomeryMultiply_Type() {
    // create input type (domain)
    int num_args      = 7;
*** 1106,1116 ****
    // 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);
  }
  
  const TypeFunc* OptoRuntime::montgomerySquare_Type() {
    // create input type (domain)
    int num_args      = 6;
--- 1106,1116 ----
    // 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, domain, range);
  }
  
  const TypeFunc* OptoRuntime::montgomerySquare_Type() {
    // create input type (domain)
    int num_args      = 6;
*** 1129,1139 ****
    // 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);
  }
  
  const TypeFunc* OptoRuntime::vectorizedMismatch_Type() {
    // create input type (domain)
    int num_args = 4;
--- 1129,1139 ----
    // 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, domain, range);
  }
  
  const TypeFunc* OptoRuntime::vectorizedMismatch_Type() {
    // create input type (domain)
    int num_args = 4;
*** 1149,1159 ****
  
    //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);
  }
  
  // GHASH block processing
  const TypeFunc* OptoRuntime::ghash_processBlocks_Type() {
      int argcnt = 4;
--- 1149,1159 ----
  
    //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, domain, range);
  }
  
  // GHASH block processing
  const TypeFunc* OptoRuntime::ghash_processBlocks_Type() {
      int argcnt = 4;
*** 1169,1179 ****
  
      // 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);
  }
  
  //------------- Interpreter state access for on stack replacement
  const TypeFunc* OptoRuntime::osr_end_Type() {
    // create input type (domain)
--- 1169,1179 ----
  
      // 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, domain, range);
  }
  
  //------------- Interpreter state access for on stack replacement
  const TypeFunc* OptoRuntime::osr_end_Type() {
    // create input type (domain)
*** 1184,1194 ****
    // 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);
  }
  
  //-------------- methodData update helpers
  
  const TypeFunc* OptoRuntime::profile_receiver_type_Type() {
--- 1184,1194 ----
    // 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, domain, range);
  }
  
  //-------------- methodData update helpers
  
  const TypeFunc* OptoRuntime::profile_receiver_type_Type() {
*** 1200,1210 ****
  
    // 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);
  }
  
  JRT_LEAF(void, OptoRuntime::profile_receiver_type_C(DataLayout* data, oopDesc* receiver))
    if (receiver == NULL) return;
    Klass* receiver_klass = receiver->klass();
--- 1200,1210 ----
  
    // 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, domain, range);
  }
  
  JRT_LEAF(void, OptoRuntime::profile_receiver_type_C(DataLayout* data, oopDesc* receiver))
    if (receiver == NULL) return;
    Klass* receiver_klass = receiver->klass();
*** 1464,1474 ****
    // 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);
  }
  
  
  void OptoRuntime::deoptimize_caller_frame(JavaThread *thread, bool doit) {
    // Deoptimize the caller before continuing, as the compiled
--- 1464,1474 ----
    // 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, domain, range);
  }
  
  
  void OptoRuntime::deoptimize_caller_frame(JavaThread *thread, bool doit) {
    // Deoptimize the caller before continuing, as the compiled
*** 1511,1521 ****
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   return TypeFunc::make(domain,range);
  }
  
  
  //-----------------------------------------------------------------------------
  // Dtrace support.  entry and exit probes have the same signature
--- 1511,1521 ----
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   return TypeFunc::make(domain, domain, range);
  }
  
  
  //-----------------------------------------------------------------------------
  // Dtrace support.  entry and exit probes have the same signature
*** 1529,1539 ****
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   return TypeFunc::make(domain,range);
  }
  
  const TypeFunc *OptoRuntime::dtrace_object_alloc_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(2);
--- 1529,1539 ----
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   return TypeFunc::make(domain, domain, range);
  }
  
  const TypeFunc *OptoRuntime::dtrace_object_alloc_Type() {
    // create input type (domain)
    const Type **fields = TypeTuple::fields(2);
*** 1545,1555 ****
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   return TypeFunc::make(domain,range);
  }
  
  
  JRT_ENTRY_NO_ASYNC(void, OptoRuntime::register_finalizer(oopDesc* obj, JavaThread* thread))
    assert(obj->is_oop(), "must be a valid oop");
--- 1545,1555 ----
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   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");

< prev index next >