< prev index next >

src/hotspot/share/interpreter/linkResolver.hpp

Print this page

225                                              Klass* sel_klass, TRAPS);
226 
227   static Method* resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
228   static Method* resolve_method          (const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
229 
230   static Method* linktime_resolve_static_method    (const LinkInfo& link_info, TRAPS);
231   static Method* linktime_resolve_special_method   (const LinkInfo& link_info, TRAPS);
232   static Method* linktime_resolve_virtual_method   (const LinkInfo& link_info, TRAPS);
233   static Method* linktime_resolve_interface_method (const LinkInfo& link_info, TRAPS);
234 
235   static void runtime_resolve_special_method    (CallInfo& result,
236                                                  const LinkInfo& link_info,
237                                                  const methodHandle& resolved_method,
238                                                  Handle recv, TRAPS);
239 
240   static void runtime_resolve_virtual_method    (CallInfo& result,
241                                                  const methodHandle& resolved_method,
242                                                  Klass* resolved_klass,
243                                                  Handle recv,
244                                                  Klass* recv_klass,
245                                                  bool check_null_and_abstract, TRAPS);

246   static void runtime_resolve_interface_method  (CallInfo& result,
247                                                  const methodHandle& resolved_method,
248                                                  Klass* resolved_klass,
249                                                  Handle recv,
250                                                  Klass* recv_klass,
251                                                  bool check_null_and_abstract, TRAPS);

252 
253   static bool resolve_previously_linked_invokehandle(CallInfo& result,
254                                                      const LinkInfo& link_info,
255                                                      const constantPoolHandle& pool,
256                                                      int index, TRAPS);
257 
258   static void check_field_accessability(Klass* ref_klass,
259                                         Klass* resolved_klass,
260                                         Klass* sel_klass,
261                                         const fieldDescriptor& fd, TRAPS);
262   static void check_method_accessability(Klass* ref_klass,
263                                          Klass* resolved_klass,
264                                          Klass* sel_klass,
265                                          const methodHandle& sel_method, TRAPS);
266 
267   // runtime resolving from constant pool
268   static void resolve_invokestatic   (CallInfo& result,
269                                       const constantPoolHandle& pool, int index, TRAPS);
270   static void resolve_invokespecial  (CallInfo& result, Handle recv,
271                                       const constantPoolHandle& pool, int index, TRAPS);

276   static void resolve_invokedynamic  (CallInfo& result,
277                                       const constantPoolHandle& pool, int index, TRAPS);
278   static void resolve_invokehandle   (CallInfo& result,
279                                       const constantPoolHandle& pool, int index, TRAPS);
280  public:
281   // constant pool resolving
282   static void check_klass_accessibility(Klass* ref_klass, Klass* sel_klass, TRAPS);
283 
284   // static resolving calls (will not run any Java code);
285   // used only from Bytecode_invoke::static_target
286   static Method* resolve_method_statically(Bytecodes::Code code,
287                                            const constantPoolHandle& pool,
288                                            int index, TRAPS);
289 
290   static void resolve_continuation_enter(CallInfo& callinfo, TRAPS);
291 
292   static void resolve_field_access(fieldDescriptor& result,
293                                    const constantPoolHandle& pool,
294                                    int index,
295                                    const methodHandle& method,
296                                    Bytecodes::Code byte, TRAPS);

297   static void resolve_field(fieldDescriptor& result, const LinkInfo& link_info,
298                             Bytecodes::Code access_kind,
299                             bool initialize_class, TRAPS);
300 
301   static void resolve_static_call   (CallInfo& result,
302                                      const LinkInfo& link_info,
303                                      bool initialize_klass, TRAPS);
304   static void resolve_special_call  (CallInfo& result,
305                                      Handle recv,
306                                      const LinkInfo& link_info,
307                                      TRAPS);
308   static void resolve_virtual_call  (CallInfo& result, Handle recv, Klass* recv_klass,
309                                      const LinkInfo& link_info,
310                                      bool check_null_and_abstract, TRAPS);
311   static void resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
312                                      const LinkInfo& link_info,
313                                      bool check_null_and_abstract, TRAPS);
314   static void resolve_handle_call   (CallInfo& result,
315                                      const LinkInfo& link_info, TRAPS);
316   static void resolve_dynamic_call  (CallInfo& result,
317                                      BootstrapInfo& bootstrap_specifier, TRAPS);
318 





319   // same as above for compile-time resolution; but returns null handle instead of throwing
320   // an exception on error also, does not initialize klass (i.e., no side effects)
321   static Method* resolve_virtual_call_or_null(Klass* receiver_klass,
322                                               const LinkInfo& link_info);
323   static Method* resolve_interface_call_or_null(Klass* receiver_klass,
324                                                 const LinkInfo& link_info);
325   static Method* resolve_static_call_or_null(const LinkInfo& link_info);
326   static Method* resolve_special_call_or_null(const LinkInfo& link_info);
327 
328   static int vtable_index_of_interface_method(Klass* klass, const methodHandle& resolved_method);
329 
330   // same as above for compile-time resolution; returns vtable_index if current_klass if linked
331   static int resolve_virtual_vtable_index  (Klass* receiver_klass,
332                                             const LinkInfo& link_info);
333 
334   // static resolving for compiler (does not throw exceptions, returns null handle if unsuccessful)
335   static Method* linktime_resolve_virtual_method_or_null  (const LinkInfo& link_info);
336   static Method* linktime_resolve_interface_method_or_null(const LinkInfo& link_info);
337 
338   // runtime resolving from constant pool

225                                              Klass* sel_klass, TRAPS);
226 
227   static Method* resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
228   static Method* resolve_method          (const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
229 
230   static Method* linktime_resolve_static_method    (const LinkInfo& link_info, TRAPS);
231   static Method* linktime_resolve_special_method   (const LinkInfo& link_info, TRAPS);
232   static Method* linktime_resolve_virtual_method   (const LinkInfo& link_info, TRAPS);
233   static Method* linktime_resolve_interface_method (const LinkInfo& link_info, TRAPS);
234 
235   static void runtime_resolve_special_method    (CallInfo& result,
236                                                  const LinkInfo& link_info,
237                                                  const methodHandle& resolved_method,
238                                                  Handle recv, TRAPS);
239 
240   static void runtime_resolve_virtual_method    (CallInfo& result,
241                                                  const methodHandle& resolved_method,
242                                                  Klass* resolved_klass,
243                                                  Handle recv,
244                                                  Klass* recv_klass,
245                                                  bool check_null_and_abstract,
246                                                  bool need_selected_method, TRAPS);
247   static void runtime_resolve_interface_method  (CallInfo& result,
248                                                  const methodHandle& resolved_method,
249                                                  Klass* resolved_klass,
250                                                  Handle recv,
251                                                  Klass* recv_klass,
252                                                  bool check_null_and_abstract,
253                                                  bool needs_selected_methods, TRAPS);
254 
255   static bool resolve_previously_linked_invokehandle(CallInfo& result,
256                                                      const LinkInfo& link_info,
257                                                      const constantPoolHandle& pool,
258                                                      int index, TRAPS);
259 
260   static void check_field_accessability(Klass* ref_klass,
261                                         Klass* resolved_klass,
262                                         Klass* sel_klass,
263                                         const fieldDescriptor& fd, TRAPS);
264   static void check_method_accessability(Klass* ref_klass,
265                                          Klass* resolved_klass,
266                                          Klass* sel_klass,
267                                          const methodHandle& sel_method, TRAPS);
268 
269   // runtime resolving from constant pool
270   static void resolve_invokestatic   (CallInfo& result,
271                                       const constantPoolHandle& pool, int index, TRAPS);
272   static void resolve_invokespecial  (CallInfo& result, Handle recv,
273                                       const constantPoolHandle& pool, int index, TRAPS);

278   static void resolve_invokedynamic  (CallInfo& result,
279                                       const constantPoolHandle& pool, int index, TRAPS);
280   static void resolve_invokehandle   (CallInfo& result,
281                                       const constantPoolHandle& pool, int index, TRAPS);
282  public:
283   // constant pool resolving
284   static void check_klass_accessibility(Klass* ref_klass, Klass* sel_klass, TRAPS);
285 
286   // static resolving calls (will not run any Java code);
287   // used only from Bytecode_invoke::static_target
288   static Method* resolve_method_statically(Bytecodes::Code code,
289                                            const constantPoolHandle& pool,
290                                            int index, TRAPS);
291 
292   static void resolve_continuation_enter(CallInfo& callinfo, TRAPS);
293 
294   static void resolve_field_access(fieldDescriptor& result,
295                                    const constantPoolHandle& pool,
296                                    int index,
297                                    const methodHandle& method,
298                                    Bytecodes::Code byte,
299                                    bool initialize_class, TRAPS);
300   static void resolve_field(fieldDescriptor& result, const LinkInfo& link_info,
301                             Bytecodes::Code access_kind,
302                             bool initialize_class, TRAPS);
303 
304   static void resolve_static_call   (CallInfo& result,
305                                      const LinkInfo& link_info,
306                                      bool initialize_klass, TRAPS);
307   static void resolve_special_call  (CallInfo& result,
308                                      Handle recv,
309                                      const LinkInfo& link_info,
310                                      TRAPS);
311   static void resolve_virtual_call  (CallInfo& result, Handle recv, Klass* recv_klass,
312                                      const LinkInfo& link_info,
313                                      bool check_null_and_abstract, TRAPS);
314   static void resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
315                                      const LinkInfo& link_info,
316                                      bool check_null_and_abstract, TRAPS);
317   static void resolve_handle_call   (CallInfo& result,
318                                      const LinkInfo& link_info, TRAPS);
319   static void resolve_dynamic_call  (CallInfo& result,
320                                      BootstrapInfo& bootstrap_specifier, TRAPS);
321 
322   static void cds_resolve_virtual_call  (CallInfo& result, const LinkInfo& link_info, TRAPS);
323   static void cds_resolve_interface_call(CallInfo& result, const LinkInfo& link_info, TRAPS);
324   static void cds_resolve_static_call   (CallInfo& result, const LinkInfo& link_info, TRAPS);
325   static void cds_resolve_special_call  (CallInfo& result, const LinkInfo& link_info, TRAPS);
326 
327   // same as above for compile-time resolution; but returns null handle instead of throwing
328   // an exception on error also, does not initialize klass (i.e., no side effects)
329   static Method* resolve_virtual_call_or_null(Klass* receiver_klass,
330                                               const LinkInfo& link_info);
331   static Method* resolve_interface_call_or_null(Klass* receiver_klass,
332                                                 const LinkInfo& link_info);
333   static Method* resolve_static_call_or_null(const LinkInfo& link_info);
334   static Method* resolve_special_call_or_null(const LinkInfo& link_info);
335 
336   static int vtable_index_of_interface_method(Klass* klass, const methodHandle& resolved_method);
337 
338   // same as above for compile-time resolution; returns vtable_index if current_klass if linked
339   static int resolve_virtual_vtable_index  (Klass* receiver_klass,
340                                             const LinkInfo& link_info);
341 
342   // static resolving for compiler (does not throw exceptions, returns null handle if unsuccessful)
343   static Method* linktime_resolve_virtual_method_or_null  (const LinkInfo& link_info);
344   static Method* linktime_resolve_interface_method_or_null(const LinkInfo& link_info);
345 
346   // runtime resolving from constant pool
< prev index next >