1 /*
  2  * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  *
 23  */
 24 
 25 #ifndef SHARE_INTERPRETER_LINKRESOLVER_HPP
 26 #define SHARE_INTERPRETER_LINKRESOLVER_HPP
 27 
 28 #include "interpreter/bootstrapInfo.hpp"
 29 #include "oops/method.hpp"
 30 
 31 // All the necessary definitions for run-time link resolution.
 32 
 33 // CallInfo provides all the information gathered for a particular
 34 // linked call site after resolving it. A link is any reference
 35 // made from within the bytecodes of a method to an object outside of
 36 // that method. If the info is invalid, the link has not been resolved
 37 // successfully.
 38 
 39 class CallInfo : public StackObj {
 40  public:
 41   // Ways that a method call might be selected (or not) based on receiver type.
 42   // Note that an invokevirtual instruction might be linked with no_dispatch,
 43   // and an invokeinterface instruction might be linked with any of the three options
 44   enum CallKind {
 45     direct_call,                        // jump into resolved_method (must be concrete)
 46     vtable_call,                        // select recv.klass.method_at_vtable(index)
 47     itable_call,                        // select recv.klass.method_at_itable(resolved_method.holder, index)
 48     unknown_kind = -1
 49   };
 50  private:
 51   Klass*       _resolved_klass;         // static receiver klass, resolved from a symbolic reference
 52   methodHandle _resolved_method;        // static target method
 53   methodHandle _selected_method;        // dynamic (actual) target method
 54   CallKind     _call_kind;              // kind of call (static(=bytecode static/special +
 55                                         //               others inferred), vtable, itable)
 56   int          _call_index;             // vtable or itable index of selected class method (if any)
 57   Handle       _resolved_appendix;      // extra argument in constant pool (if CPCE::has_appendix)
 58   Handle       _resolved_method_name;   // Object holding the ResolvedMethodName
 59 
 60   void set_static(Klass* resolved_klass, const methodHandle& resolved_method, TRAPS);
 61   void set_interface(Klass* resolved_klass,
 62                      const methodHandle& resolved_method,
 63                      const methodHandle& selected_method,
 64                      int itable_index, TRAPS);
 65   void set_virtual(Klass* resolved_klass,
 66                    const methodHandle& resolved_method,
 67                    const methodHandle& selected_method,
 68                    int vtable_index, TRAPS);
 69   void set_handle(Klass* resolved_klass,
 70                   const methodHandle& resolved_method,
 71                   Handle resolved_appendix, TRAPS);
 72   void set_common(Klass* resolved_klass,
 73                   const methodHandle& resolved_method,
 74                   const methodHandle& selected_method,
 75                   CallKind kind,
 76                   int index, TRAPS);
 77 
 78   friend class BootstrapInfo;
 79   friend class LinkResolver;
 80 
 81  public:
 82   CallInfo() {
 83 #ifndef PRODUCT
 84     _call_kind  = CallInfo::unknown_kind;
 85     _call_index = Method::garbage_vtable_index;
 86 #endif //PRODUCT
 87   }
 88 
 89   // utility to extract an effective CallInfo from a method and an optional receiver limit
 90   // does not queue the method for compilation.  This also creates a ResolvedMethodName
 91   // object for the resolved_method.
 92   CallInfo(Method* resolved_method, Klass* resolved_klass, TRAPS);
 93 
 94   Klass*  resolved_klass() const                 { return _resolved_klass; }
 95   Method* resolved_method() const                { return _resolved_method(); }
 96   Method* selected_method() const                { return _selected_method(); }
 97   Handle       resolved_appendix() const         { return _resolved_appendix; }
 98   Handle       resolved_method_name() const      { return _resolved_method_name; }
 99   // Materialize a java.lang.invoke.ResolvedMethodName for this resolved_method
100   void     set_resolved_method_name(TRAPS);
101 
102   BasicType    result_type() const               { return selected_method()->result_type(); }
103   CallKind     call_kind() const                 { return _call_kind; }
104   int          vtable_index() const {
105     // Even for interface calls the vtable index could be non-negative.
106     // See CallInfo::set_interface.
107     assert(has_vtable_index() || is_statically_bound(), "");
108     assert(call_kind() == vtable_call || call_kind() == direct_call, "");
109     // The returned value is < 0 if the call is statically bound.
110     // But, the returned value may be >= 0 even if the kind is direct_call.
111     // It is up to the caller to decide which way to go.
112     return _call_index;
113   }
114   int          itable_index() const {
115     assert(call_kind() == itable_call, "");
116     // The returned value is always >= 0, a valid itable index.
117     return _call_index;
118   }
119 
120   // debugging
121 #ifdef ASSERT
122   bool         has_vtable_index() const          { return _call_index >= 0 && _call_kind != CallInfo::itable_call; }
123   bool         is_statically_bound() const       { return _call_index == Method::nonvirtual_vtable_index; }
124 #endif //ASSERT
125   void         verify() PRODUCT_RETURN;
126   void         print()  PRODUCT_RETURN;
127 };
128 
129 
130 // Condensed information from constant pool to use to resolve the method or field.
131 //   resolved_klass = specified class (i.e., static receiver class)
132 //   current_klass  = sending method holder (i.e., class containing the method
133 //                    containing the call being resolved)
134 //   current_method = sending method (relevant for field resolution)
135 class LinkInfo : public StackObj {
136   Symbol*     _name;            // extracted from JVM_CONSTANT_NameAndType
137   Symbol*     _signature;
138   Klass*      _resolved_klass;  // class that the constant pool entry points to
139   Klass*      _current_klass;   // class that owns the constant pool
140   methodHandle _current_method;  // sending method
141   bool        _check_access;
142   bool        _check_loader_constraints;
143   constantTag _tag;
144 
145  public:
146   enum class AccessCheck { required, skip };
147   enum class LoaderConstraintCheck { required, skip };
148 
149   LinkInfo(const constantPoolHandle& pool, int index, const methodHandle& current_method, TRAPS);
150   LinkInfo(const constantPoolHandle& pool, int index, TRAPS);
151 
152   // Condensed information from other call sites within the vm.
153   LinkInfo(Klass* resolved_klass, Symbol* name, Symbol* signature, Klass* current_klass,
154            AccessCheck check_access = AccessCheck::required,
155            LoaderConstraintCheck check_loader_constraints = LoaderConstraintCheck::required,
156            constantTag tag = JVM_CONSTANT_Invalid) :
157       _name(name),
158       _signature(signature),
159       _resolved_klass(resolved_klass),
160       _current_klass(current_klass),
161       _current_method(methodHandle()),
162       _check_access(check_access == AccessCheck::required),
163       _check_loader_constraints(check_loader_constraints == LoaderConstraintCheck::required),
164       _tag(tag) {
165     assert(_resolved_klass != nullptr, "must always have a resolved_klass");
166   }
167 
168   LinkInfo(Klass* resolved_klass, Symbol* name, Symbol* signature, const methodHandle& current_method,
169            AccessCheck check_access = AccessCheck::required,
170            LoaderConstraintCheck check_loader_constraints = LoaderConstraintCheck::required,
171            constantTag tag = JVM_CONSTANT_Invalid) :
172     LinkInfo(resolved_klass, name, signature, current_method->method_holder(), check_access, check_loader_constraints, tag) {
173     _current_method = current_method;
174   }
175 
176   // Case where we just find the method and don't check access against the current class, used by JavaCalls
177   LinkInfo(Klass* resolved_klass, Symbol*name, Symbol* signature) :
178     LinkInfo(resolved_klass, name, signature, nullptr, AccessCheck::skip, LoaderConstraintCheck::skip,
179              JVM_CONSTANT_Invalid) {}
180 
181   // accessors
182   Symbol* name() const                  { return _name; }
183   Symbol* signature() const             { return _signature; }
184   Klass* resolved_klass() const         { return _resolved_klass; }
185   Klass* current_klass() const          { return _current_klass; }
186   Method* current_method() const        { return _current_method(); }
187   constantTag tag() const               { return _tag; }
188   bool check_access() const             { return _check_access; }
189   bool check_loader_constraints() const { return _check_loader_constraints; }
190   void         print()  PRODUCT_RETURN;
191 };
192 
193 // Link information for getfield/putfield & getstatic/putstatic bytecodes
194 // is represented using a fieldDescriptor.
195 
196 // The LinkResolver is used to resolve constant-pool references at run-time.
197 // It does all necessary link-time checks & throws exceptions if necessary.
198 
199 class LinkResolver: AllStatic {
200   friend class klassVtable;
201   friend class klassItable;
202 
203  private:
204 
205   static Method* lookup_method_in_klasses(const LinkInfo& link_info,
206                                           bool checkpolymorphism,
207                                           bool in_imethod_resolve);
208   static Method* lookup_method_in_interfaces(const LinkInfo& link_info);
209 
210   static Method* lookup_polymorphic_method(const LinkInfo& link_info,
211                                            Handle *appendix_result_or_null, TRAPS);
212  JVMCI_ONLY(public:) // Needed for CompilerToVM.resolveMethod()
213   // Not Linktime so doesn't take LinkInfo
214   static Method* lookup_instance_method_in_klasses (Klass* klass, Symbol* name, Symbol* signature,
215                                                     Klass::PrivateLookupMode private_mode);
216  JVMCI_ONLY(private:)
217 
218   // Similar loader constraint checking functions that throw
219   // LinkageError with descriptive message.
220   static void check_method_loader_constraints(const LinkInfo& link_info,
221                                               const methodHandle& resolved_method,
222                                               const char* method_type, TRAPS);
223   static void check_field_loader_constraints(Symbol* field, Symbol* sig,
224                                              Klass* current_klass,
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);
272   static void resolve_invokevirtual  (CallInfo& result, Handle recv,
273                                       const constantPoolHandle& pool, int index, TRAPS);
274   static void resolve_invokeinterface(CallInfo& result, Handle recv,
275                                       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
339   static void resolve_invoke(CallInfo& result, Handle recv,
340                              const constantPoolHandle& pool, int index,
341                              Bytecodes::Code byte, TRAPS);
342 
343   // runtime resolving from attached method
344   static void resolve_invoke(CallInfo& result, Handle& recv,
345                              const methodHandle& attached_method,
346                              Bytecodes::Code byte, bool check_null_and_abstract, TRAPS);
347 
348   // Only resolved method known.
349   static void throw_abstract_method_error(const methodHandle& resolved_method, TRAPS) {
350     throw_abstract_method_error(resolved_method, methodHandle(), NULL, CHECK);
351   }
352   // Resolved method and receiver klass know.
353   static void throw_abstract_method_error(const methodHandle& resolved_method, Klass *recv_klass, TRAPS) {
354     throw_abstract_method_error(resolved_method, methodHandle(), recv_klass, CHECK);
355   }
356   // Selected method is abstract.
357   static void throw_abstract_method_error(const methodHandle& resolved_method,
358                                           const methodHandle& selected_method,
359                                           Klass *recv_klass, TRAPS);
360 };
361 #endif // SHARE_INTERPRETER_LINKRESOLVER_HPP