< prev index next >

src/hotspot/share/opto/runtime.cpp

Print this page
*** 44,10 ***
--- 44,12 ---
  #include "interpreter/linkResolver.hpp"
  #include "logging/log.hpp"
  #include "logging/logStream.hpp"
  #include "memory/oopFactory.hpp"
  #include "memory/resourceArea.hpp"
+ #include "oops/flatArrayKlass.hpp"
+ #include "oops/flatArrayOop.inline.hpp"
  #include "oops/objArrayKlass.hpp"
  #include "oops/klass.inline.hpp"
  #include "oops/oop.inline.hpp"
  #include "oops/typeArrayOop.inline.hpp"
  #include "opto/ad.hpp"

*** 106,10 ***
--- 108,11 ---
  address OptoRuntime::_monitor_notifyAll_Java                      = NULL;
  address OptoRuntime::_rethrow_Java                                = NULL;
  
  address OptoRuntime::_slow_arraycopy_Java                         = NULL;
  address OptoRuntime::_register_finalizer_Java                     = NULL;
+ address OptoRuntime::_load_unknown_inline                         = NULL;
  
  ExceptionBlob* OptoRuntime::_exception_blob;
  
  // This should be called in an assertion at the start of OptoRuntime routines
  // which are entered from compiled code (all of them)

*** 146,13 ***
    gen(env, _multianewarrayN_Java           , multianewarrayN_Type         , multianewarrayN_C               ,    0 , true, false);
    gen(env, _complete_monitor_locking_Java  , complete_monitor_enter_Type  , SharedRuntime::complete_monitor_locking_C, 0, false, false);
    gen(env, _monitor_notify_Java            , monitor_notify_Type          , monitor_notify_C                ,    0 , false, false);
    gen(env, _monitor_notifyAll_Java         , monitor_notify_Type          , monitor_notifyAll_C             ,    0 , false, false);
    gen(env, _rethrow_Java                   , rethrow_Type                 , rethrow_C                       ,    2 , true , true );
- 
    gen(env, _slow_arraycopy_Java            , slow_arraycopy_Type          , SharedRuntime::slow_arraycopy_C ,    0 , false, false);
    gen(env, _register_finalizer_Java        , register_finalizer_Type      , register_finalizer              ,    0 , false, false);
  
    return true;
  }
  
  #undef gen
--- 149,13 ---
    gen(env, _multianewarrayN_Java           , multianewarrayN_Type         , multianewarrayN_C               ,    0 , true, false);
    gen(env, _complete_monitor_locking_Java  , complete_monitor_enter_Type  , SharedRuntime::complete_monitor_locking_C, 0, false, false);
    gen(env, _monitor_notify_Java            , monitor_notify_Type          , monitor_notify_C                ,    0 , false, false);
    gen(env, _monitor_notifyAll_Java         , monitor_notify_Type          , monitor_notifyAll_C             ,    0 , false, false);
    gen(env, _rethrow_Java                   , rethrow_Type                 , rethrow_C                       ,    2 , true , true );
    gen(env, _slow_arraycopy_Java            , slow_arraycopy_Type          , SharedRuntime::slow_arraycopy_C ,    0 , false, false);
    gen(env, _register_finalizer_Java        , register_finalizer_Type      , register_finalizer              ,    0 , false, false);
+   gen(env, _load_unknown_inline            , load_unknown_inline_type     , load_unknown_inline             ,    0 , true,  false);
  
    return true;
  }
  
  #undef gen

*** 194,11 ***
  //=============================allocation======================================
  // We failed the fast-path allocation.  Now we need to do a scavenge or GC
  // and try allocation again.
  
  // object allocation
! JRT_BLOCK_ENTRY(void, OptoRuntime::new_instance_C(Klass* klass, JavaThread* current))
    JRT_BLOCK;
  #ifndef PRODUCT
    SharedRuntime::_new_instance_ctr++;         // new instance requires GC
  #endif
    assert(check_compiled_frame(current), "incorrect caller");
--- 197,11 ---
  //=============================allocation======================================
  // We failed the fast-path allocation.  Now we need to do a scavenge or GC
  // and try allocation again.
  
  // object allocation
! JRT_BLOCK_ENTRY(void, OptoRuntime::new_instance_C(Klass* klass, bool is_larval, JavaThread* current))
    JRT_BLOCK;
  #ifndef PRODUCT
    SharedRuntime::_new_instance_ctr++;         // new instance requires GC
  #endif
    assert(check_compiled_frame(current), "incorrect caller");

*** 214,11 ***
    }
  
    if (!HAS_PENDING_EXCEPTION) {
      // Scavenge and allocate an instance.
      Handle holder(current, klass->klass_holder()); // keep the klass alive
!     oop result = InstanceKlass::cast(klass)->allocate_instance(THREAD);
      current->set_vm_result(result);
  
      // Pass oops back through thread local storage.  Our apparent type to Java
      // is that we return an oop, but we can block on exit from this routine and
      // a GC can trash the oop in C's return register.  The generated stub will
--- 217,15 ---
    }
  
    if (!HAS_PENDING_EXCEPTION) {
      // Scavenge and allocate an instance.
      Handle holder(current, klass->klass_holder()); // keep the klass alive
!     instanceOop result = InstanceKlass::cast(klass)->allocate_instance(THREAD);
+     if (is_larval) {
+       // Check if this is a larval buffer allocation
+       result->set_mark(result->mark().enter_larval_state());
+     }
      current->set_vm_result(result);
  
      // Pass oops back through thread local storage.  Our apparent type to Java
      // is that we return an oop, but we can block on exit from this routine and
      // a GC can trash the oop in C's return register.  The generated stub will

*** 242,22 ***
    assert(check_compiled_frame(current), "incorrect caller");
  
    // Scavenge and allocate an instance.
    oop result;
  
!   if (array_type->is_typeArray_klass()) {
      // The oopFactory likes to work with the element type.
      // (We could bypass the oopFactory, since it doesn't add much value.)
      BasicType elem_type = TypeArrayKlass::cast(array_type)->element_type();
      result = oopFactory::new_typeArray(elem_type, len, THREAD);
    } else {
-     // Although the oopFactory likes to work with the elem_type,
-     // the compiler prefers the array_type, since it must already have
-     // that latter value in hand for the fast path.
      Handle holder(current, array_type->klass_holder()); // keep the array klass alive
!     Klass* elem_type = ObjArrayKlass::cast(array_type)->element_klass();
-     result = oopFactory::new_objArray(elem_type, len, THREAD);
    }
  
    // Pass oops back through thread local storage.  Our apparent type to Java
    // is that we return an oop, but we can block on exit from this routine and
    // a GC can trash the oop in C's return register.  The generated stub will
--- 249,21 ---
    assert(check_compiled_frame(current), "incorrect caller");
  
    // Scavenge and allocate an instance.
    oop result;
  
!   if (array_type->is_flatArray_klass()) {
+     Klass* elem_type = FlatArrayKlass::cast(array_type)->element_klass();
+     result = oopFactory::new_flatArray(elem_type, len, THREAD);
+   } else if (array_type->is_typeArray_klass()) {
      // The oopFactory likes to work with the element type.
      // (We could bypass the oopFactory, since it doesn't add much value.)
      BasicType elem_type = TypeArrayKlass::cast(array_type)->element_type();
      result = oopFactory::new_typeArray(elem_type, len, THREAD);
    } else {
      Handle holder(current, array_type->klass_holder()); // keep the array klass alive
!     result = ObjArrayKlass::cast(array_type)->allocate(len, THREAD);
    }
  
    // Pass oops back through thread local storage.  Our apparent type to Java
    // is that we return an oop, but we can block on exit from this routine and
    // a GC can trash the oop in C's return register.  The generated stub will

*** 447,13 ***
    JRT_BLOCK_END;
  JRT_END
  
  const TypeFunc *OptoRuntime::new_instance_Type() {
    // create input type (domain)
!   const Type **fields = TypeTuple::fields(1);
    fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
!   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
  
    // create result type (range)
    fields = TypeTuple::fields(1);
    fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
  
--- 453,14 ---
    JRT_BLOCK_END;
  JRT_END
  
  const TypeFunc *OptoRuntime::new_instance_Type() {
    // create input type (domain)
!   const Type **fields = TypeTuple::fields(2);
    fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Klass to be allocated
!   fields[TypeFunc::Parms+1] = TypeInt::BOOL;        // is_larval
+   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2, fields);
  
    // create result type (range)
    fields = TypeTuple::fields(1);
    fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
  

*** 567,11 ***
    // 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() {
--- 574,11 ---
    // 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() {

*** 1539,11 ***
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   return TypeFunc::make(domain,range);
  }
  
  #if INCLUDE_JFR
  const TypeFunc *OptoRuntime::get_class_id_intrinsic_Type() {
    // create input type (domain)
--- 1546,11 ---
    // create result type (range)
    fields = TypeTuple::fields(0);
  
    const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
  
!   return TypeFunc::make(domain, range);
  }
  
  #if INCLUDE_JFR
  const TypeFunc *OptoRuntime::get_class_id_intrinsic_Type() {
    // create input type (domain)

*** 1572,11 ***
    // 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);
--- 1579,11 ---
    // 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);

*** 1588,11 ***
    // 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* current))
    assert(oopDesc::is_oop(obj), "must be a valid oop");
--- 1595,11 ---
    // 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* current))
    assert(oopDesc::is_oop(obj), "must be a valid oop");

*** 1712,5 ***
--- 1719,109 ---
    tempst.print(" at " INTPTR_FORMAT,  p2i(exception_pc));
    tempst.print("]");
  
    st->print_raw_cr(tempst.as_string());
  }
+ 
+ const TypeFunc *OptoRuntime::store_inline_type_fields_Type() {
+   // create input type (domain)
+   uint total = SharedRuntime::java_return_convention_max_int + SharedRuntime::java_return_convention_max_float*2;
+   const Type **fields = TypeTuple::fields(total);
+   // We don't know the number of returned values and their
+   // types. Assume all registers available to the return convention
+   // are used.
+   fields[TypeFunc::Parms] = TypePtr::BOTTOM;
+   uint i = 1;
+   for (; i < SharedRuntime::java_return_convention_max_int; i++) {
+     fields[TypeFunc::Parms+i] = TypeInt::INT;
+   }
+   for (; i < total; i+=2) {
+     fields[TypeFunc::Parms+i] = Type::DOUBLE;
+     fields[TypeFunc::Parms+i+1] = Type::HALF;
+   }
+   const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + total, fields);
+ 
+   // create result type (range)
+   fields = TypeTuple::fields(1);
+   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;
+ 
+   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1,fields);
+ 
+   return TypeFunc::make(domain, range);
+ }
+ 
+ const TypeFunc *OptoRuntime::pack_inline_type_Type() {
+   // create input type (domain)
+   uint total = 1 + SharedRuntime::java_return_convention_max_int + SharedRuntime::java_return_convention_max_float*2;
+   const Type **fields = TypeTuple::fields(total);
+   // We don't know the number of returned values and their
+   // types. Assume all registers available to the return convention
+   // are used.
+   fields[TypeFunc::Parms] = TypeRawPtr::BOTTOM;
+   fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM;
+   uint i = 2;
+   for (; i < SharedRuntime::java_return_convention_max_int+1; i++) {
+     fields[TypeFunc::Parms+i] = TypeInt::INT;
+   }
+   for (; i < total; i+=2) {
+     fields[TypeFunc::Parms+i] = Type::DOUBLE;
+     fields[TypeFunc::Parms+i+1] = Type::HALF;
+   }
+   const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms + total, fields);
+ 
+   // create result type (range)
+   fields = TypeTuple::fields(1);
+   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL;
+ 
+   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1,fields);
+ 
+   return TypeFunc::make(domain, range);
+ }
+ 
+ JRT_BLOCK_ENTRY(void, OptoRuntime::load_unknown_inline(flatArrayOopDesc* array, int index, JavaThread* current))
+   JRT_BLOCK;
+   flatArrayHandle vah(current, array);
+   oop buffer = flatArrayOopDesc::value_alloc_copy_from_index(vah, index, THREAD);
+   deoptimize_caller_frame(current, HAS_PENDING_EXCEPTION);
+   current->set_vm_result(buffer);
+   JRT_BLOCK_END;
+ JRT_END
+ 
+ const TypeFunc* OptoRuntime::load_unknown_inline_type() {
+   // create input type (domain)
+   const Type** fields = TypeTuple::fields(2);
+   fields[TypeFunc::Parms] = TypeOopPtr::NOTNULL;
+   fields[TypeFunc::Parms+1] = TypeInt::POS;
+ 
+   const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+2, fields);
+ 
+   // create result type (range)
+   fields = TypeTuple::fields(1);
+   fields[TypeFunc::Parms] = TypeInstPtr::NOTNULL;
+ 
+   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields);
+ 
+   return TypeFunc::make(domain, range);
+ }
+ 
+ JRT_LEAF(void, OptoRuntime::store_unknown_inline(instanceOopDesc* buffer, flatArrayOopDesc* array, int index))
+ {
+   assert(buffer != NULL, "can't store null into flat array");
+   array->value_copy_to_index(buffer, index);
+ }
+ JRT_END
+ 
+ const TypeFunc* OptoRuntime::store_unknown_inline_type() {
+   // create input type (domain)
+   const Type** fields = TypeTuple::fields(3);
+   fields[TypeFunc::Parms] = TypeInstPtr::NOTNULL;
+   fields[TypeFunc::Parms+1] = TypeOopPtr::NOTNULL;
+   fields[TypeFunc::Parms+2] = TypeInt::POS;
+ 
+   const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+3, fields);
+ 
+   // create result type (range)
+   fields = TypeTuple::fields(0);
+   const TypeTuple* range = TypeTuple::make(TypeFunc::Parms, fields);
+ 
+   return TypeFunc::make(domain, range);
+ }
< prev index next >