1 /*
  2  * Copyright (c) 1997, 2022, 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), _resolved_klass(resolved_klass), _current_klass(current_klass), _current_method(methodHandle()),
159     _check_access(check_access == AccessCheck::required),
160     _check_loader_constraints(check_loader_constraints == LoaderConstraintCheck::required), _tag(tag) {}
161 
162   LinkInfo(Klass* resolved_klass, Symbol* name, Symbol* signature, const methodHandle& current_method,
163            AccessCheck check_access = AccessCheck::required,
164            LoaderConstraintCheck check_loader_constraints = LoaderConstraintCheck::required,
165            constantTag tag = JVM_CONSTANT_Invalid) :
166     _name(name),
167     _signature(signature), _resolved_klass(resolved_klass), _current_klass(current_method->method_holder()), _current_method(current_method),
168     _check_access(check_access == AccessCheck::required),
169     _check_loader_constraints(check_loader_constraints == LoaderConstraintCheck::required), _tag(tag) {}
170 
171 
172   // Case where we just find the method and don't check access against the current class
173   LinkInfo(Klass* resolved_klass, Symbol*name, Symbol* signature) :
174     _name(name),
175     _signature(signature), _resolved_klass(resolved_klass), _current_klass(NULL), _current_method(methodHandle()),
176     _check_access(false), _check_loader_constraints(false), _tag(JVM_CONSTANT_Invalid) {}
177 
178   // accessors
179   Symbol* name() const                  { return _name; }
180   Symbol* signature() const             { return _signature; }
181   Klass* resolved_klass() const         { return _resolved_klass; }
182   Klass* current_klass() const          { return _current_klass; }
183   Method* current_method() const        { return _current_method(); }
184   constantTag tag() const               { return _tag; }
185   bool check_access() const             { return _check_access; }
186   bool check_loader_constraints() const { return _check_loader_constraints; }
187   void         print()  PRODUCT_RETURN;
188 };
189 
190 // Link information for getfield/putfield & getstatic/putstatic bytecodes
191 // is represented using a fieldDescriptor.
192 
193 // The LinkResolver is used to resolve constant-pool references at run-time.
194 // It does all necessary link-time checks & throws exceptions if necessary.
195 
196 class LinkResolver: AllStatic {
197   friend class klassVtable;
198   friend class klassItable;
199 
200  private:
201 
202   static Method* lookup_method_in_klasses(const LinkInfo& link_info,
203                                           bool checkpolymorphism,
204                                           bool in_imethod_resolve);
205   static Method* lookup_method_in_interfaces(const LinkInfo& link_info);
206 
207   static Method* lookup_polymorphic_method(const LinkInfo& link_info,
208                                            Handle *appendix_result_or_null, TRAPS);
209  JVMCI_ONLY(public:) // Needed for CompilerToVM.resolveMethod()
210   // Not Linktime so doesn't take LinkInfo
211   static Method* lookup_instance_method_in_klasses (Klass* klass, Symbol* name, Symbol* signature,
212                                                     Klass::PrivateLookupMode private_mode);
213  JVMCI_ONLY(private:)
214 
215   // Similar loader constraint checking functions that throw
216   // LinkageError with descriptive message.
217   static void check_method_loader_constraints(const LinkInfo& link_info,
218                                               const methodHandle& resolved_method,
219                                               const char* method_type, TRAPS);
220   static void check_field_loader_constraints(Symbol* field, Symbol* sig,
221                                              Klass* current_klass,
222                                              Klass* sel_klass, TRAPS);
223 
224   static Method* resolve_interface_method(const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
225   static Method* resolve_method          (const LinkInfo& link_info, Bytecodes::Code code, TRAPS);
226 
227   static Method* linktime_resolve_static_method    (const LinkInfo& link_info, TRAPS);
228   static Method* linktime_resolve_special_method   (const LinkInfo& link_info, TRAPS);
229   static Method* linktime_resolve_virtual_method   (const LinkInfo& link_info, TRAPS);
230   static Method* linktime_resolve_interface_method (const LinkInfo& link_info, TRAPS);
231 
232   static void runtime_resolve_special_method    (CallInfo& result,
233                                                  const LinkInfo& link_info,
234                                                  const methodHandle& resolved_method,
235                                                  Handle recv, TRAPS);
236 
237   static void runtime_resolve_virtual_method    (CallInfo& result,
238                                                  const methodHandle& resolved_method,
239                                                  Klass* resolved_klass,
240                                                  Handle recv,
241                                                  Klass* recv_klass,
242                                                  bool check_null_and_abstract, TRAPS);
243   static void runtime_resolve_interface_method  (CallInfo& result,
244                                                  const methodHandle& resolved_method,
245                                                  Klass* resolved_klass,
246                                                  Handle recv,
247                                                  Klass* recv_klass,
248                                                  bool check_null_and_abstract, TRAPS);
249 
250   static bool resolve_previously_linked_invokehandle(CallInfo& result,
251                                                      const LinkInfo& link_info,
252                                                      const constantPoolHandle& pool,
253                                                      int index, TRAPS);
254 
255   static void check_field_accessability(Klass* ref_klass,
256                                         Klass* resolved_klass,
257                                         Klass* sel_klass,
258                                         const fieldDescriptor& fd, TRAPS);
259   static void check_method_accessability(Klass* ref_klass,
260                                          Klass* resolved_klass,
261                                          Klass* sel_klass,
262                                          const methodHandle& sel_method, TRAPS);
263 
264   // runtime resolving from constant pool
265   static void resolve_invokestatic   (CallInfo& result,
266                                       const constantPoolHandle& pool, int index, TRAPS);
267   static void resolve_invokespecial  (CallInfo& result, Handle recv,
268                                       const constantPoolHandle& pool, int index, TRAPS);
269   static void resolve_invokevirtual  (CallInfo& result, Handle recv,
270                                       const constantPoolHandle& pool, int index, TRAPS);
271   static void resolve_invokeinterface(CallInfo& result, Handle recv,
272                                       const constantPoolHandle& pool, int index, TRAPS);
273   static void resolve_invokedynamic  (CallInfo& result,
274                                       const constantPoolHandle& pool, int index, TRAPS);
275   static void resolve_invokehandle   (CallInfo& result,
276                                       const constantPoolHandle& pool, int index, TRAPS);
277  public:
278   // constant pool resolving
279   static void check_klass_accessibility(Klass* ref_klass, Klass* sel_klass, TRAPS);
280 
281   // static resolving calls (will not run any Java code);
282   // used only from Bytecode_invoke::static_target
283   static Method* resolve_method_statically(Bytecodes::Code code,
284                                            const constantPoolHandle& pool,
285                                            int index, TRAPS);
286 
287   static void resolve_continuation_enter(CallInfo& callinfo, TRAPS);
288 
289   static void resolve_field_access(fieldDescriptor& result,
290                                    const constantPoolHandle& pool,
291                                    int index,
292                                    const methodHandle& method,
293                                    Bytecodes::Code byte, TRAPS);
294   static void resolve_field(fieldDescriptor& result, const LinkInfo& link_info,
295                             Bytecodes::Code access_kind,
296                             bool initialize_class, TRAPS);
297 
298   static void resolve_static_call   (CallInfo& result,
299                                      const LinkInfo& link_info,
300                                      bool initialize_klass, TRAPS);
301   static void resolve_special_call  (CallInfo& result,
302                                      Handle recv,
303                                      const LinkInfo& link_info,
304                                      TRAPS);
305   static void resolve_virtual_call  (CallInfo& result, Handle recv, Klass* recv_klass,
306                                      const LinkInfo& link_info,
307                                      bool check_null_and_abstract, TRAPS);
308   static void resolve_interface_call(CallInfo& result, Handle recv, Klass* recv_klass,
309                                      const LinkInfo& link_info,
310                                      bool check_null_and_abstract, TRAPS);
311   static void resolve_handle_call   (CallInfo& result,
312                                      const LinkInfo& link_info, TRAPS);
313   static void resolve_dynamic_call  (CallInfo& result,
314                                      BootstrapInfo& bootstrap_specifier, TRAPS);
315 
316   // same as above for compile-time resolution; but returns null handle instead of throwing
317   // an exception on error also, does not initialize klass (i.e., no side effects)
318   static Method* resolve_virtual_call_or_null(Klass* receiver_klass,
319                                               const LinkInfo& link_info);
320   static Method* resolve_interface_call_or_null(Klass* receiver_klass,
321                                                 const LinkInfo& link_info);
322   static Method* resolve_static_call_or_null(const LinkInfo& link_info);
323   static Method* resolve_special_call_or_null(const LinkInfo& link_info);
324 
325   static int vtable_index_of_interface_method(Klass* klass, const methodHandle& resolved_method);
326 
327   // same as above for compile-time resolution; returns vtable_index if current_klass if linked
328   static int resolve_virtual_vtable_index  (Klass* receiver_klass,
329                                             const LinkInfo& link_info);
330 
331   // static resolving for compiler (does not throw exceptions, returns null handle if unsuccessful)
332   static Method* linktime_resolve_virtual_method_or_null  (const LinkInfo& link_info);
333   static Method* linktime_resolve_interface_method_or_null(const LinkInfo& link_info);
334 
335   // runtime resolving from constant pool
336   static void resolve_invoke(CallInfo& result, Handle recv,
337                              const constantPoolHandle& pool, int index,
338                              Bytecodes::Code byte, TRAPS);
339 
340   // runtime resolving from attached method
341   static void resolve_invoke(CallInfo& result, Handle& recv,
342                              const methodHandle& attached_method,
343                              Bytecodes::Code byte, bool check_null_and_abstract, TRAPS);
344 
345   // Only resolved method known.
346   static void throw_abstract_method_error(const methodHandle& resolved_method, TRAPS) {
347     throw_abstract_method_error(resolved_method, methodHandle(), NULL, CHECK);
348   }
349   // Resolved method and receiver klass know.
350   static void throw_abstract_method_error(const methodHandle& resolved_method, Klass *recv_klass, TRAPS) {
351     throw_abstract_method_error(resolved_method, methodHandle(), recv_klass, CHECK);
352   }
353   // Selected method is abstract.
354   static void throw_abstract_method_error(const methodHandle& resolved_method,
355                                           const methodHandle& selected_method,
356                                           Klass *recv_klass, TRAPS);
357 };
358 #endif // SHARE_INTERPRETER_LINKRESOLVER_HPP