Merge lworld

Author: Vicente Romero

src/hotspot/share/ci/ciReplay.cpp

@@ -866,7 +866,7 @@ class CompileReplay : public StackObj {
       if (had_error()) {
         return;
       }
-      if (Arguments::is_valhalla_enabled() && _version >= 3 && k != nullptr && k->is_objArray_klass()) {
+      if (_version >= 3 && k != nullptr && k->is_objArray_klass()) {
         k = create_concrete_object_array_klass(ObjArrayKlass::cast(k), THREAD);
       }
       rec->_classes_offsets[i] = offset;
@@ -892,11 +892,16 @@ class CompileReplay : public StackObj {
   ObjArrayKlass* create_concrete_object_array_klass(ObjArrayKlass* obj_array_klass, TRAPS) {
     ArrayKlass::ArrayProperties array_properties =
     static_cast<ArrayKlass::ArrayProperties>(parse_int("array_properties"));
+    if (!Arguments::is_valhalla_enabled()) {
+      // Ignore array properties.
+      return obj_array_klass;
+    }
+
     if (array_properties != ArrayKlass::DEFAULT &&
         array_properties != ArrayKlass::NULL_RESTRICTED &&
         array_properties != ArrayKlass::NON_ATOMIC &&
         array_properties != (ArrayKlass::NULL_RESTRICTED | ArrayKlass::NON_ATOMIC)) {
-      guarantee(false, "invalid array_properties: %d, fall back to DEFAULT", array_properties);
+      guarantee(false, "invalid array_properties: %d", array_properties);
     }
 
     return obj_array_klass->klass_with_properties(array_properties, THREAD);

src/hotspot/share/code/nmethod.cpp

@@ -1443,14 +1443,21 @@ nmethod::nmethod(const nmethod &nm) : CodeBlob(nm._name, nm._kind, nm._size, nm.
   _oops_do_mark_link            = nullptr;
   _compiled_ic_data             = nullptr;
 
-  if (nm._osr_entry_point != nullptr) {
-    _osr_entry_point            = (nm._osr_entry_point - (address) &nm) + (address) this;
-  } else {
-    _osr_entry_point            = nullptr;
-  }
-
+  auto relocate_address = [&nm, this](address old_addr) -> address {
+    if (old_addr == nullptr) return nullptr;
+    address new_addr = old_addr - (address) &nm + (address) this;
+    assert(new_addr >= code_begin() && new_addr < code_end(),
+           "relocated address must be within code bounds");
+    return new_addr;
+  };
+
+  _osr_entry_point              = relocate_address(nm._osr_entry_point);
   _entry_offset                 = nm._entry_offset;
   _verified_entry_offset        = nm._verified_entry_offset;
+  _inline_entry_point           = relocate_address(nm._inline_entry_point);
+  _verified_inline_entry_point  = relocate_address(nm._verified_inline_entry_point);
+  _verified_inline_ro_entry_point = relocate_address(nm._verified_inline_ro_entry_point);
+
   _entry_bci                    = nm._entry_bci;
   _immutable_data_size          = nm._immutable_data_size;
 

src/hotspot/share/opto/c2compiler.cpp

@@ -32,6 +32,7 @@
 #include "opto/optoreg.hpp"
 #include "opto/output.hpp"
 #include "opto/runtime.hpp"
+#include "runtime/arguments.hpp"
 #include "runtime/globals_extension.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/stubRoutines.hpp"
@@ -131,7 +132,7 @@ void C2Compiler::compile_method(ciEnv* env, ciMethod* target, int entry_bci, boo
   bool do_iterative_escape_analysis = DoEscapeAnalysis;
   bool do_reduce_allocation_merges = ReduceAllocationMerges && EliminateAllocations;
   // TODO 8328675 Re-enable
-  bool eliminate_boxing = false; // EliminateAutoBox;
+  bool eliminate_boxing = EliminateAutoBox && !Arguments::is_valhalla_enabled();
   bool do_locks_coarsening = EliminateLocks;
   bool do_superword = UseSuperWord;
 

src/hotspot/share/opto/callnode.cpp

@@ -40,7 +40,6 @@
 #include "opto/locknode.hpp"
 #include "opto/machnode.hpp"
 #include "opto/matcher.hpp"
-#include "opto/memnode.hpp"
 #include "opto/movenode.hpp"
 #include "opto/parse.hpp"
 #include "opto/regalloc.hpp"
@@ -1185,14 +1184,58 @@ Node* CallStaticJavaNode::Ideal(PhaseGVN* phase, bool can_reshape) {
     }
   }
 
-  // Try to replace the runtime call to the substitutability test emitted by acmp if we can reason
-  // about the operands
-  if (can_reshape && !control()->is_top() && method() != nullptr &&
-      method()->holder() == phase->C->env()->ValueObjectMethods_klass() &&
-      method()->name() == ciSymbols::isSubstitutable_name()) {
-    Node* res = replace_is_substitutable(phase->is_IterGVN());
-    if (res != nullptr) {
-      return res;
+  // Try to replace the runtime call to the substitutability test emitted by acmp if (at least) one operand is a known type
+  if (can_reshape && !control()->is_top() && method() != nullptr && method()->holder() == phase->C->env()->ValueObjectMethods_klass() &&
+      (method()->name() == ciSymbols::isSubstitutable_name())) {
+    Node* left = in(TypeFunc::Parms);
+    Node* right = in(TypeFunc::Parms + 1);
+    if (!left->is_top() && !right->is_top() && (left->is_InlineType() || right->is_InlineType())) {
+      if (!left->is_InlineType()) {
+        swap(left, right);
+      }
+      InlineTypeNode* vt = left->as_InlineType();
+
+      // Check if the field layout can be optimized
+      if (vt->can_emit_substitutability_check(right)) {
+        PhaseIterGVN* igvn = phase->is_IterGVN();
+
+        Node* ctrl = control();
+        RegionNode* region = new RegionNode(1);
+        Node* phi = new PhiNode(region, TypeInt::POS);
+
+        Node* base = right;
+        Node* ptr = right;
+        if (!base->is_InlineType()) {
+          // Parse time checks guarantee that both operands are non-null and have the same type
+          base = igvn->register_new_node_with_optimizer(new CheckCastPPNode(ctrl, base, vt->bottom_type()));
+          ptr = base;
+        }
+        // Emit IR for field-wise comparison
+        vt->check_substitutability(igvn, region, phi, &ctrl, in(MemNode::Memory), base, ptr);
+
+        // Equals
+        region->add_req(ctrl);
+        phi->add_req(igvn->intcon(1));
+
+        ctrl = igvn->register_new_node_with_optimizer(region);
+        Node* res = igvn->register_new_node_with_optimizer(phi);
+
+        // Kill exception projections and return a tuple that will replace the call
+        CallProjections* projs = extract_projections(false /*separate_io_proj*/);
+        if (projs->fallthrough_catchproj != nullptr) {
+          igvn->replace_node(projs->fallthrough_catchproj, ctrl);
+        }
+        if (projs->catchall_memproj != nullptr) {
+          igvn->replace_node(projs->catchall_memproj, igvn->C->top());
+        }
+        if (projs->catchall_ioproj != nullptr) {
+          igvn->replace_node(projs->catchall_ioproj, igvn->C->top());
+        }
+        if (projs->catchall_catchproj != nullptr) {
+          igvn->replace_node(projs->catchall_catchproj, igvn->C->top());
+        }
+        return TupleNode::make(tf()->range_cc(), ctrl, i_o(), memory(), frameptr(), returnadr(), res);
+      }
     }
   }
 
@@ -1382,52 +1425,6 @@ bool CallStaticJavaNode::remove_unknown_flat_array_load(PhaseIterGVN* igvn, Node
   return true;
 }
 
-// Try to replace a runtime call to the substitutability test by either a simple pointer comparison
-// if either operand is not a value object, or comparing their fields if either operand is an
-// object of a known value type
-Node* CallStaticJavaNode::replace_is_substitutable(PhaseIterGVN* igvn) {
-  // Delay IGVN during macro expansion
-  assert(!igvn->delay_transform(), "must not delay during Ideal");
-  igvn->set_delay_transform(true);
-
-  // Prepare to inline, clone the jvms
-  JVMState* jvms = this->jvms()->clone_shallow(igvn->C);
-  assert(jvms->map()->next_exception() == nullptr, "this call does not throw");
-  SafePointNode* map = new SafePointNode(req(), jvms);
-  igvn->register_new_node_with_optimizer(map);
-  for (uint i = 0; i < req(); i++) {
-    map->init_req(i, in(i));
-  }
-  MergeMemNode* mem = MergeMemNode::make(map->memory());
-  igvn->register_new_node_with_optimizer(mem);
-  map->set_memory(mem);
-  jvms->set_map(map);
-  GraphKit kit(jvms, igvn);
-
-  Node* left = in(TypeFunc::Parms);
-  Node* right = in(TypeFunc::Parms + 1);
-  Node* replace = InlineTypeNode::emit_substitutability_check(&kit, left, right);
-  igvn->set_delay_transform(false);
-  if (replace == nullptr) {
-    return nullptr;
-  }
-
-  // Kill exception projections and return a tuple that will replace the call
-  CallProjections* projs = extract_projections(false /*separate_io_proj*/);
-  if (projs->fallthrough_catchproj != nullptr) {
-    igvn->replace_node(projs->fallthrough_catchproj, kit.control());
-  }
-  if (projs->catchall_memproj != nullptr) {
-    igvn->replace_node(projs->catchall_memproj, igvn->C->top());
-  }
-  if (projs->catchall_ioproj != nullptr) {
-    igvn->replace_node(projs->catchall_ioproj, igvn->C->top());
-  }
-  if (projs->catchall_catchproj != nullptr) {
-    igvn->replace_node(projs->catchall_catchproj, igvn->C->top());
-  }
-  return TupleNode::make(tf()->range_cc(), igvn->C->top(), kit.i_o(), kit.reset_memory(), kit.frameptr(), kit.returnadr(), replace);
-}
 
 #ifndef PRODUCT
 void CallStaticJavaNode::dump_spec(outputStream *st) const {

src/hotspot/share/opto/callnode.hpp

@@ -841,7 +841,6 @@ class CallStaticJavaNode : public CallJavaNode {
   virtual uint size_of() const; // Size is bigger
 
   bool remove_unknown_flat_array_load(PhaseIterGVN* igvn, Node* ctl, Node* mem, Node* unc_arg);
-  Node* replace_is_substitutable(PhaseIterGVN* igvn);
 
 public:
   CallStaticJavaNode(Compile* C, const TypeFunc* tf, address addr, ciMethod* method)

src/hotspot/share/opto/graphKit.cpp

@@ -1497,22 +1497,19 @@ Node* GraphKit::null_check_common(Node* value, BasicType type,
 //------------------------------cast_not_null----------------------------------
 // Cast obj to not-null on this path
 Node* GraphKit::cast_not_null(Node* obj, bool do_replace_in_map) {
-  const Type* t = _gvn.type(obj);
-  const Type* t_not_null = t->join_speculative(TypePtr::NOTNULL);
-  if (t == t_not_null) {
-    return obj;
-  }
-
   if (obj->is_InlineType()) {
-    InlineTypeNode* vt = obj->isa_InlineType()->clone_if_required(&gvn(), map(), do_replace_in_map);
-    vt->set_null_marker(_gvn);
-    vt->set_type(t_not_null);
-    vt = _gvn.transform(vt)->as_InlineType();
+    Node* vt = obj->isa_InlineType()->clone_if_required(&gvn(), map(), do_replace_in_map);
+    vt->as_InlineType()->set_null_marker(_gvn);
+    vt = _gvn.transform(vt);
     if (do_replace_in_map) {
       replace_in_map(obj, vt);
     }
     return vt;
   }
+  const Type *t = _gvn.type(obj);
+  const Type *t_not_null = t->join_speculative(TypePtr::NOTNULL);
+  // Object is already not-null?
+  if( t == t_not_null ) return obj;
 
   Node* cast = new CastPPNode(control(), obj,t_not_null);
   cast = _gvn.transform( cast );