8381276

Author: TobiHartmann

src/hotspot/share/opto/callnode.cpp

@@ -1991,7 +1991,6 @@ AllocateNode::AllocateNode(Compile* C, const TypeFunc *atype,
   _is_scalar_replaceable = false;
   _is_non_escaping = false;
   _is_allocation_MemBar_redundant = false;
-  _larval = false;
   Node *topnode = C->top();
 
   init_req( TypeFunc::Control  , ctrl );
@@ -2031,19 +2030,12 @@ Node* AllocateNode::make_ideal_mark(PhaseGVN* phase, Node* control, Node* mem) {
   if (UseCompactObjectHeaders || Arguments::is_valhalla_enabled()) {
     Node* klass_node = in(AllocateNode::KlassNode);
     Node* proto_adr = phase->transform(AddPNode::make_with_base(phase->C->top(), klass_node, phase->MakeConX(in_bytes(Klass::prototype_header_offset()))));
-
     mark_node = LoadNode::make(*phase, control, mem, proto_adr, phase->type(proto_adr)->is_ptr(), TypeX_X, TypeX_X->basic_type(), MemNode::unordered);
-    if (Arguments::is_valhalla_enabled()) {
-      mark_node = phase->transform(mark_node);
-      // Avoid returning a constant (old node) here because this method is used by LoadNode::Ideal
-      // TODO: Could this be removed now that we don't use larval bits
-      assert(!_larval, "Larval bits are not in use at the moment");
-      mark_node = new OrXNode(mark_node, phase->MakeConX(0));
-    }
-    return mark_node;
   } else {
-    return phase->MakeConX(markWord::prototype().value());
+    // For now only enable fast locking for non-array types
+    mark_node = phase->MakeConX(markWord::prototype().value());
   }
+  return mark_node;
 }
 
 // Retrieve the length from the AllocateArrayNode. Narrow the type with a

src/hotspot/share/opto/callnode.hpp

@@ -1073,7 +1073,6 @@ class AllocateNode : public CallNode {
   bool _is_non_escaping;
   // True when MemBar for new is redundant with MemBar at initialzer exit
   bool _is_allocation_MemBar_redundant;
-  bool _larval;
 
   virtual uint size_of() const; // Size is bigger
   AllocateNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio,

src/hotspot/share/opto/macro.cpp

@@ -1767,9 +1767,6 @@ void PhaseMacroExpand::expand_allocate_common(
     if (init_val != nullptr) {
       call->init_req(TypeFunc::Parms+2, init_val);
     }
-  } else {
-    // Let the runtime know if this is a larval allocation
-    call->init_req(TypeFunc::Parms+1, _igvn.intcon(alloc->_larval));
   }
 
   // Copy debug information and adjust JVMState information, then replace

src/hotspot/share/opto/memnode.cpp

@@ -2470,7 +2470,7 @@ const Type* LoadNode::Value(PhaseGVN* phase) const {
         assert(Opcode() == Op_LoadI, "must load an int from _layout_kind");
         return TypeInt::make(static_cast<jint>(klass->as_flat_array_klass()->layout_kind()));
       }
-      if (UseCompactObjectHeaders && tkls->offset() == in_bytes(Klass::prototype_header_offset())) {
+      if ((UseCompactObjectHeaders || Arguments::is_valhalla_enabled()) && tkls->offset() == in_bytes(Klass::prototype_header_offset())) {
         // The field is Klass::_prototype_header. Return its (constant) value.
         assert(this->Opcode() == Op_LoadX, "must load a proper type from _prototype_header");
         return TypeX::make(klass->prototype_header());

src/hotspot/share/opto/runtime.cpp

@@ -303,7 +303,7 @@ void OptoRuntime::complete_monitor_locking_C(oopDesc* obj, BasicLock* lock, Java
 // and try allocation again.
 
 // object allocation
-JRT_BLOCK_ENTRY(void, OptoRuntime::new_instance_C(Klass* klass, bool is_larval, JavaThread* current))
+JRT_BLOCK_ENTRY(void, OptoRuntime::new_instance_C(Klass* klass, JavaThread* current))
   JRT_BLOCK;
 #ifndef PRODUCT
   SharedRuntime::_new_instance_ctr++;         // new instance requires GC
@@ -323,7 +323,7 @@ JRT_BLOCK_ENTRY(void, OptoRuntime::new_instance_C(Klass* klass, bool is_larval,
   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);
+    oop result = InstanceKlass::cast(klass)->allocate_instance(THREAD);
     current->set_vm_result_oop(result);
 
     // Pass oops back through thread local storage.  Our apparent type to Java
@@ -587,10 +587,9 @@ JRT_END
 
 static const TypeFunc* make_new_instance_Type() {
   // create input type (domain)
-  const Type **fields = TypeTuple::fields(2);
+  const Type **fields = TypeTuple::fields(1);
   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);
+  const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
 
   // create result type (range)
   fields = TypeTuple::fields(1);

src/hotspot/share/opto/runtime.hpp

@@ -210,7 +210,7 @@ class OptoRuntime : public AllStatic {
   // =================================
 
   // Allocate storage for a Java instance.
-  static void new_instance_C(Klass* instance_klass, bool is_larval, JavaThread* current);
+  static void new_instance_C(Klass* instance_klass, JavaThread* current);
 
   // Allocate storage for a objArray or typeArray
   static void new_array_C(Klass* array_klass, int len, oopDesc* init_val, JavaThread* current);