src/hotspot/share/code/dependencies.hpp
changeset 54721 3661ad97da8f
parent 53244 9807daeb47c4
child 54734 e8f1b9fc82cc
equal deleted inserted replaced
54720:c48f141e7c5b 54721:3661ad97da8f
    25 #ifndef SHARE_CODE_DEPENDENCIES_HPP
    25 #ifndef SHARE_CODE_DEPENDENCIES_HPP
    26 #define SHARE_CODE_DEPENDENCIES_HPP
    26 #define SHARE_CODE_DEPENDENCIES_HPP
    27 
    27 
    28 #include "ci/ciCallSite.hpp"
    28 #include "ci/ciCallSite.hpp"
    29 #include "ci/ciKlass.hpp"
    29 #include "ci/ciKlass.hpp"
       
    30 #include "ci/ciMethod.hpp"
    30 #include "ci/ciMethodHandle.hpp"
    31 #include "ci/ciMethodHandle.hpp"
    31 #include "classfile/systemDictionary.hpp"
    32 #include "classfile/systemDictionary.hpp"
    32 #include "code/compressedStream.hpp"
    33 #include "code/compressedStream.hpp"
    33 #include "code/nmethod.hpp"
    34 #include "code/nmethod.hpp"
    34 #include "memory/resourceArea.hpp"
    35 #include "memory/resourceArea.hpp"
   339   }
   340   }
   340   static void check_ctxk_abstract(ciKlass* ctxk) {
   341   static void check_ctxk_abstract(ciKlass* ctxk) {
   341     check_ctxk(ctxk);
   342     check_ctxk(ctxk);
   342     assert(!is_concrete_klass(ctxk->as_instance_klass()), "must be abstract");
   343     assert(!is_concrete_klass(ctxk->as_instance_klass()), "must be abstract");
   343   }
   344   }
       
   345   static void check_unique_method(ciKlass* ctxk, ciMethod* m) {
       
   346     assert(!m->can_be_statically_bound(ctxk->as_instance_klass()), "redundant");
       
   347   }
   344 
   348 
   345   void assert_common_1(DepType dept, ciBaseObject* x);
   349   void assert_common_1(DepType dept, ciBaseObject* x);
   346   void assert_common_2(DepType dept, ciBaseObject* x0, ciBaseObject* x1);
   350   void assert_common_2(DepType dept, ciBaseObject* x0, ciBaseObject* x1);
   347   void assert_common_3(DepType dept, ciKlass* ctxk, ciBaseObject* x1, ciBaseObject* x2);
   351   void assert_common_3(DepType dept, ciKlass* ctxk, ciBaseObject* x1, ciBaseObject* x2);
   348 
   352 
   366   }
   370   }
   367   static void check_ctxk_abstract(Klass* ctxk) {
   371   static void check_ctxk_abstract(Klass* ctxk) {
   368     check_ctxk(ctxk);
   372     check_ctxk(ctxk);
   369     assert(ctxk->is_abstract(), "must be abstract");
   373     assert(ctxk->is_abstract(), "must be abstract");
   370   }
   374   }
       
   375   static void check_unique_method(Klass* ctxk, Method* m) {
       
   376     assert(!m->can_be_statically_bound(InstanceKlass::cast(ctxk)), "redundant");
       
   377   }
       
   378 
   371   void assert_common_1(DepType dept, DepValue x);
   379   void assert_common_1(DepType dept, DepValue x);
   372   void assert_common_2(DepType dept, DepValue x0, DepValue x1);
   380   void assert_common_2(DepType dept, DepValue x0, DepValue x1);
   373 
   381 
   374  public:
   382  public:
   375   void assert_evol_method(Method* m);
   383   void assert_evol_method(Method* m);