8347396: Efficient TypeFunc creations

Reviewed-by: dlong, vlivanov, adinn

Author: Harshit470250

src/hotspot/share/gc/shared/c2/barrierSetC2.cpp

@@ -813,7 +813,10 @@ Node* BarrierSetC2::obj_allocate(PhaseMacroExpand* macro, Node* mem, Node* toobi
   return old_tlab_top;
 }
 
-static const TypeFunc* clone_type() {
+const TypeFunc* BarrierSetC2::_clone_type_Type = nullptr;
+
+void BarrierSetC2::make_clone_type() {
+  assert(BarrierSetC2::_clone_type_Type == nullptr, "should be");
   // Create input type (domain)
   int argcnt = NOT_LP64(3) LP64_ONLY(4);
   const Type** const domain_fields = TypeTuple::fields(argcnt);
@@ -829,7 +832,12 @@ static const TypeFunc* clone_type() {
   const Type** const range_fields = TypeTuple::fields(0);
   const TypeTuple* const range = TypeTuple::make(TypeFunc::Parms + 0, range_fields);
 
-  return TypeFunc::make(domain, range);
+  BarrierSetC2::_clone_type_Type = TypeFunc::make(domain, range);
+}
+
+inline const TypeFunc* BarrierSetC2::clone_type() {
+  assert(BarrierSetC2::_clone_type_Type != nullptr, "should be initialized");
+  return BarrierSetC2::_clone_type_Type;
 }
 
 #define XTOP LP64_ONLY(COMMA phase->top())

src/hotspot/share/gc/shared/c2/barrierSetC2.hpp

@@ -270,6 +270,9 @@ class BarrierStubC2 : public ArenaObj {
 // various GC barrier sets inherit from the BarrierSetC2 class to sprinkle
 // barriers into the accesses.
 class BarrierSetC2: public CHeapObj<mtGC> {
+private:
+  static const TypeFunc* _clone_type_Type;
+
 protected:
   virtual void resolve_address(C2Access& access) const;
   virtual Node* store_at_resolved(C2Access& access, C2AccessValue& val) const;
@@ -379,6 +382,9 @@ class BarrierSetC2: public CHeapObj<mtGC> {
 
   static int arraycopy_payload_base_offset(bool is_array);
 
+  static void make_clone_type();
+  static const TypeFunc* clone_type();
+
 #ifndef PRODUCT
   virtual void dump_barrier_data(const MachNode* mach, outputStream* st) const {
     st->print("%x", mach->barrier_data());

src/hotspot/share/gc/shenandoah/c2/shenandoahBarrierSetC2.cpp

@@ -519,7 +519,33 @@ void ShenandoahBarrierSetC2::post_barrier(GraphKit* kit,
 
 #undef __
 
-const TypeFunc* ShenandoahBarrierSetC2::write_barrier_pre_Type() {
+const TypeFunc* ShenandoahBarrierSetC2::_write_barrier_pre_Type              = nullptr;
+const TypeFunc* ShenandoahBarrierSetC2::_clone_barrier_Type                  = nullptr;
+const TypeFunc* ShenandoahBarrierSetC2::_load_reference_barrier_Type         = nullptr;
+
+inline const TypeFunc* ShenandoahBarrierSetC2::write_barrier_pre_Type() {
+  assert(ShenandoahBarrierSetC2::_write_barrier_pre_Type != nullptr, "should be initialized");
+  return ShenandoahBarrierSetC2::_write_barrier_pre_Type;
+}
+
+inline const TypeFunc* ShenandoahBarrierSetC2::clone_barrier_Type() {
+  assert(ShenandoahBarrierSetC2::_clone_barrier_Type != nullptr, "should be initialized");
+  return ShenandoahBarrierSetC2::_clone_barrier_Type;
+}
+
+const TypeFunc* ShenandoahBarrierSetC2::load_reference_barrier_Type() {
+  assert(ShenandoahBarrierSetC2::_load_reference_barrier_Type != nullptr, "should be initialized");
+  return ShenandoahBarrierSetC2::_load_reference_barrier_Type;
+}
+
+void ShenandoahBarrierSetC2::init() {
+  ShenandoahBarrierSetC2::make_write_barrier_pre_Type();
+  ShenandoahBarrierSetC2::make_clone_barrier_Type();
+  ShenandoahBarrierSetC2::make_load_reference_barrier_Type();
+}
+
+void ShenandoahBarrierSetC2::make_write_barrier_pre_Type() {
+  assert(ShenandoahBarrierSetC2::_write_barrier_pre_Type == nullptr, "should be");
   const Type **fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // original field value
   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
@@ -528,10 +554,11 @@ const TypeFunc* ShenandoahBarrierSetC2::write_barrier_pre_Type() {
   fields = TypeTuple::fields(0);
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
 
-  return TypeFunc::make(domain, range);
+  ShenandoahBarrierSetC2::_write_barrier_pre_Type = TypeFunc::make(domain, range);
 }
 
-const TypeFunc* ShenandoahBarrierSetC2::clone_barrier_Type() {
+void ShenandoahBarrierSetC2::make_clone_barrier_Type() {
+  assert(ShenandoahBarrierSetC2::_clone_barrier_Type == nullptr, "should be");
   const Type **fields = TypeTuple::fields(1);
   fields[TypeFunc::Parms+0] = TypeOopPtr::NOTNULL; // src oop
   const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+1, fields);
@@ -540,10 +567,11 @@ const TypeFunc* ShenandoahBarrierSetC2::clone_barrier_Type() {
   fields = TypeTuple::fields(0);
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0, fields);
 
-  return TypeFunc::make(domain, range);
+  ShenandoahBarrierSetC2::_clone_barrier_Type = TypeFunc::make(domain, range);
 }
 
-const TypeFunc* ShenandoahBarrierSetC2::load_reference_barrier_Type() {
+void ShenandoahBarrierSetC2::make_load_reference_barrier_Type() {
+  assert(ShenandoahBarrierSetC2::_load_reference_barrier_Type == nullptr, "should be");
   const Type **fields = TypeTuple::fields(2);
   fields[TypeFunc::Parms+0] = TypeOopPtr::BOTTOM; // original field value
   fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // original load address
@@ -555,7 +583,7 @@ const TypeFunc* ShenandoahBarrierSetC2::load_reference_barrier_Type() {
   fields[TypeFunc::Parms+0] = TypeOopPtr::BOTTOM;
   const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
 
-  return TypeFunc::make(domain, range);
+  ShenandoahBarrierSetC2::_load_reference_barrier_Type = TypeFunc::make(domain, range);
 }
 
 Node* ShenandoahBarrierSetC2::store_at_resolved(C2Access& access, C2AccessValue& val) const {

src/hotspot/share/gc/shenandoah/c2/shenandoahBarrierSetC2.hpp

@@ -82,6 +82,13 @@ class ShenandoahBarrierSetC2 : public BarrierSetC2 {
 
   static bool clone_needs_barrier(Node* src, PhaseGVN& gvn);
 
+  static const TypeFunc* _write_barrier_pre_Type;
+  static const TypeFunc* _clone_barrier_Type;
+  static const TypeFunc* _load_reference_barrier_Type;
+  static void make_write_barrier_pre_Type();
+  static void make_clone_barrier_Type();
+  static void make_load_reference_barrier_Type();
+
 protected:
   virtual Node* load_at_resolved(C2Access& access, const Type* val_type) const;
   virtual Node* store_at_resolved(C2Access& access, C2AccessValue& val) const;
@@ -106,6 +113,8 @@ class ShenandoahBarrierSetC2 : public BarrierSetC2 {
   static const TypeFunc* write_barrier_pre_Type();
   static const TypeFunc* clone_barrier_Type();
   static const TypeFunc* load_reference_barrier_Type();
+  static void init();
+
   virtual bool has_load_barrier_nodes() const { return true; }
 
   // This is the entry-point for the backend to perform accesses through the Access API.

src/hotspot/share/opto/type.cpp

@@ -49,6 +49,9 @@
 #include "utilities/ostream.hpp"
 #include "utilities/powerOfTwo.hpp"
 #include "utilities/stringUtils.hpp"
+#if INCLUDE_SHENANDOAHGC
+#include "gc/shenandoah/c2/shenandoahBarrierSetC2.hpp"
+#endif // INCLUDE_SHENANDOAHGC
 
 // Portions of code courtesy of Clifford Click
 
@@ -732,6 +735,11 @@ void Type::Initialize_shared(Compile* current) {
   mreg2type[Op_VecY] = TypeVect::VECTY;
   mreg2type[Op_VecZ] = TypeVect::VECTZ;
 
+#if INCLUDE_SHENANDOAHGC
+  ShenandoahBarrierSetC2::init();
+#endif //INCLUDE_SHENANDOAHGC
+
+  BarrierSetC2::make_clone_type();
   LockNode::initialize_lock_Type();
   ArrayCopyNode::initialize_arraycopy_Type();
   OptoRuntime::initialize_types();