src/hotspot/share/interpreter/linkResolver.hpp
changeset 48826 c4d9d1b08e2e
parent 47401 98e960939ef2
child 49368 2ed1c37df3a5
equal deleted inserted replaced
48825:ef8a98bc71f8 48826:c4d9d1b08e2e
   272                                       const constantPoolHandle& pool, int index, TRAPS);
   272                                       const constantPoolHandle& pool, int index, TRAPS);
   273   static void resolve_invokehandle   (CallInfo& result,
   273   static void resolve_invokehandle   (CallInfo& result,
   274                                       const constantPoolHandle& pool, int index, TRAPS);
   274                                       const constantPoolHandle& pool, int index, TRAPS);
   275  public:
   275  public:
   276   // constant pool resolving
   276   // constant pool resolving
   277   static void check_klass_accessability(Klass* ref_klass, Klass* sel_klass, TRAPS);
   277   static void check_klass_accessability(Klass* ref_klass, Klass* sel_klass,
       
   278                                         bool fold_type_to_class, TRAPS);
       
   279   // The optional 'fold_type_to_class' means that a derived type (array)
       
   280   // is first converted to the class it is derived from (element type).
       
   281   // If this element type is not a class, then the check passes quietly.
       
   282   // This is usually what is needed, but a few existing uses might break
       
   283   // if this flag were always turned on.  FIXME: See if it can be, always.
       
   284   static void check_klass_accessability(Klass* ref_klass, Klass* sel_klass, TRAPS) {
       
   285     return check_klass_accessability(ref_klass, sel_klass, false, THREAD);
       
   286   }
   278 
   287 
   279   // static resolving calls (will not run any Java code);
   288   // static resolving calls (will not run any Java code);
   280   // used only from Bytecode_invoke::static_target
   289   // used only from Bytecode_invoke::static_target
   281   static methodHandle resolve_method_statically(Bytecodes::Code code,
   290   static methodHandle resolve_method_statically(Bytecodes::Code code,
   282                                                 const constantPoolHandle& pool,
   291                                                 const constantPoolHandle& pool,
   304   static void resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
   313   static void resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
   305                                      const LinkInfo& link_info,
   314                                      const LinkInfo& link_info,
   306                                      bool check_null_and_abstract, TRAPS);
   315                                      bool check_null_and_abstract, TRAPS);
   307   static void resolve_handle_call   (CallInfo& result,
   316   static void resolve_handle_call   (CallInfo& result,
   308                                      const LinkInfo& link_info, TRAPS);
   317                                      const LinkInfo& link_info, TRAPS);
   309   static void resolve_dynamic_call  (CallInfo& result, Handle bootstrap_specifier,
   318   static void resolve_dynamic_call  (CallInfo& result, int pool_index, Handle bootstrap_specifier,
   310                                      Symbol* method_name, Symbol* method_signature,
   319                                      Symbol* method_name, Symbol* method_signature,
   311                                      Klass* current_klass, TRAPS);
   320                                      Klass* current_klass, TRAPS);
   312 
   321 
   313   // same as above for compile-time resolution; but returns null handle instead of throwing
   322   // same as above for compile-time resolution; but returns null handle instead of throwing
   314   // an exception on error also, does not initialize klass (i.e., no side effects)
   323   // an exception on error also, does not initialize klass (i.e., no side effects)