1 /*
  2  * Copyright (c) 1997, 2025, 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 #include "asm/macroAssembler.inline.hpp"
 26 #include "cds/aotMetaspace.hpp"
 27 #include "compiler/disassembler.hpp"
 28 #include "interpreter/bytecodeHistogram.hpp"
 29 #include "interpreter/bytecodeStream.hpp"
 30 #include "interpreter/interp_masm.hpp"
 31 #include "interpreter/interpreter.hpp"
 32 #include "interpreter/interpreterRuntime.hpp"
 33 #include "interpreter/templateTable.hpp"
 34 #include "memory/allocation.inline.hpp"
 35 #include "memory/resourceArea.hpp"
 36 #include "oops/arrayOop.hpp"
 37 #include "oops/constantPool.inline.hpp"
 38 #include "oops/cpCache.inline.hpp"
 39 #include "oops/method.inline.hpp"
 40 #include "oops/methodData.hpp"
 41 #include "oops/oop.inline.hpp"
 42 #include "prims/jvmtiExport.hpp"
 43 #include "prims/methodHandles.hpp"
 44 #include "runtime/handles.inline.hpp"
 45 #include "runtime/sharedRuntime.hpp"
 46 #include "runtime/stubRoutines.hpp"
 47 #include "runtime/timer.hpp"
 48 
 49 # define __ _masm->
 50 
 51 //------------------------------------------------------------------------------------------------------------------------
 52 // Implementation of platform independent aspects of Interpreter
 53 
 54 void AbstractInterpreter::initialize() {
 55   // make sure 'imported' classes are initialized
 56   if (CountBytecodes || TraceBytecodes || StopInterpreterAt) BytecodeCounter::reset();
 57   if (PrintBytecodeHistogram)                                BytecodeHistogram::reset();
 58   if (PrintBytecodePairHistogram)                            BytecodePairHistogram::reset();
 59 }
 60 
 61 void AbstractInterpreter::print() {
 62   tty->cr();
 63   tty->print_cr("----------------------------------------------------------------------");
 64   tty->print_cr("Interpreter");
 65   tty->cr();
 66   tty->print_cr("code size        = %6dK bytes", (int)_code->used_space()/1024);
 67   tty->print_cr("total space      = %6dK bytes", (int)_code->total_space()/1024);
 68   tty->print_cr("wasted space     = %6dK bytes", (int)_code->available_space()/1024);
 69   tty->cr();
 70   tty->print_cr("# of codelets    = %6d"      , _code->number_of_stubs());
 71   if (_code->number_of_stubs() != 0) {
 72     tty->print_cr("avg codelet size = %6d bytes", _code->used_space() / _code->number_of_stubs());
 73     tty->cr();
 74   }
 75   _should_print_instructions = PrintInterpreter;
 76   _code->print();
 77   _should_print_instructions = false;
 78   tty->print_cr("----------------------------------------------------------------------");
 79   tty->cr();
 80 }
 81 
 82 
 83 //------------------------------------------------------------------------------------------------------------------------
 84 // Implementation of interpreter
 85 
 86 StubQueue* AbstractInterpreter::_code                                       = nullptr;
 87 bool       AbstractInterpreter::_notice_safepoints                          = false;
 88 address    AbstractInterpreter::_rethrow_exception_entry                    = nullptr;
 89 
 90 address    AbstractInterpreter::_slow_signature_handler;
 91 address    AbstractInterpreter::_entry_table            [AbstractInterpreter::number_of_method_entries];
 92 address    AbstractInterpreter::_native_abi_to_tosca    [AbstractInterpreter::number_of_result_handlers];
 93 
 94 bool       AbstractInterpreter::_should_print_instructions = false;
 95 
 96 //------------------------------------------------------------------------------------------------------------------------
 97 // Generation of complete interpreter
 98 
 99 AbstractInterpreterGenerator::AbstractInterpreterGenerator() {
100   _masm                      = nullptr;
101 }
102 
103 
104 //------------------------------------------------------------------------------------------------------------------------
105 // Entry points
106 
107 AbstractInterpreter::MethodKind AbstractInterpreter::method_kind(const methodHandle& m) {
108   // Abstract method?
109   if (m->is_abstract()) return abstract;
110 
111   // Method handle primitive?
112   vmIntrinsics::ID iid = m->intrinsic_id();
113   if (iid != vmIntrinsics::_none) {
114     if (m->is_method_handle_intrinsic()) {
115       assert(MethodHandles::is_signature_polymorphic(iid), "must match an intrinsic");
116       MethodKind kind = (MethodKind)(method_handle_invoke_FIRST +
117                                     vmIntrinsics::as_int(iid) -
118                                     static_cast<int>(vmIntrinsics::FIRST_MH_SIG_POLY));
119       assert(kind <= method_handle_invoke_LAST, "parallel enum ranges");
120       return kind;
121     }
122 
123     switch (iid) {
124 #ifndef ZERO
125       // Use optimized stub code for CRC32 native methods.
126       case vmIntrinsics::_updateCRC32:       return java_util_zip_CRC32_update;
127       case vmIntrinsics::_updateBytesCRC32:  return java_util_zip_CRC32_updateBytes;
128       case vmIntrinsics::_updateByteBufferCRC32: return java_util_zip_CRC32_updateByteBuffer;
129       // Use optimized stub code for CRC32C methods.
130       case vmIntrinsics::_updateBytesCRC32C: return java_util_zip_CRC32C_updateBytes;
131       case vmIntrinsics::_updateDirectByteBufferCRC32C: return java_util_zip_CRC32C_updateDirectByteBuffer;
132       case vmIntrinsics::_float16ToFloat:    return java_lang_Float_float16ToFloat;
133       case vmIntrinsics::_floatToFloat16:    return java_lang_Float_floatToFloat16;
134       case vmIntrinsics::_currentThread:     return java_lang_Thread_currentThread;
135 #endif // ZERO
136       case vmIntrinsics::_dsin:              return java_lang_math_sin;
137       case vmIntrinsics::_dcos:              return java_lang_math_cos;
138       case vmIntrinsics::_dtan:              return java_lang_math_tan;
139       case vmIntrinsics::_dsinh:             return java_lang_math_sinh;
140       case vmIntrinsics::_dtanh:             return java_lang_math_tanh;
141       case vmIntrinsics::_dcbrt:             return java_lang_math_cbrt;
142       case vmIntrinsics::_dabs:              return java_lang_math_abs;
143       case vmIntrinsics::_dlog:              return java_lang_math_log;
144       case vmIntrinsics::_dlog10:            return java_lang_math_log10;
145       case vmIntrinsics::_dpow:              return java_lang_math_pow;
146       case vmIntrinsics::_dexp:              return java_lang_math_exp;
147       case vmIntrinsics::_fmaD:              return java_lang_math_fmaD;
148       case vmIntrinsics::_fmaF:              return java_lang_math_fmaF;
149       case vmIntrinsics::_dsqrt:             return java_lang_math_sqrt;
150       case vmIntrinsics::_dsqrt_strict:      return java_lang_math_sqrt_strict;
151       case vmIntrinsics::_Reference_get0:    return java_lang_ref_reference_get0;
152       case vmIntrinsics::_Object_init:
153         if (m->code_size() == 1) {
154           // We need to execute the special return bytecode to check for
155           // finalizer registration so create a normal frame.
156           return zerolocals;
157         }
158         break;
159       default: break;
160     }
161   }
162 
163   // Native method?
164   if (m->is_native()) {
165     if (m->is_continuation_native_intrinsic()) {
166       // This entry will never be called.  The real entry gets generated later, like for MH intrinsics.
167       return abstract;
168     }
169     assert(!m->is_method_handle_intrinsic(), "overlapping bits here, watch out");
170     if (m->is_synchronized()) {
171       return m->has_upcall_on_method_entry() ? native_synchronized_upcalls : native_synchronized;
172     }
173     return m->has_upcall_on_method_entry() ? native_upcalls : native;
174   }
175 
176   // Synchronized?
177   if (m->is_synchronized()) {
178     return m->has_upcall_on_method_entry() ? zerolocals_synchronized_upcalls : zerolocals_synchronized;
179   }
180 
181   // Empty method?
182   if (m->is_empty_method()) {
183     return m->has_upcall_on_method_entry() ? empty_upcalls : empty;
184   }
185 
186   // Getter method?
187   if (m->is_getter()) {
188     return getter;
189   }
190 
191   // Setter method?
192   if (m->is_setter()) {
193     return setter;
194   }
195 
196   // Note: for now: zero locals for all non-empty methods
197   return m->has_upcall_on_method_entry() ? zerolocals_upcalls : zerolocals;
198 }
199 
200 vmIntrinsics::ID AbstractInterpreter::method_intrinsic(MethodKind kind) {
201   switch (kind) {
202   case java_lang_math_sin         : return vmIntrinsics::_dsin;
203   case java_lang_math_cos         : return vmIntrinsics::_dcos;
204   case java_lang_math_tan         : return vmIntrinsics::_dtan;
205   case java_lang_math_sinh        : return vmIntrinsics::_dsinh;
206   case java_lang_math_tanh        : return vmIntrinsics::_dtanh;
207   case java_lang_math_cbrt        : return vmIntrinsics::_dcbrt;
208   case java_lang_math_abs         : return vmIntrinsics::_dabs;
209   case java_lang_math_log         : return vmIntrinsics::_dlog;
210   case java_lang_math_log10       : return vmIntrinsics::_dlog10;
211   case java_lang_math_sqrt        : return vmIntrinsics::_dsqrt;
212   case java_lang_math_sqrt_strict : return vmIntrinsics::_dsqrt_strict;
213   case java_lang_math_pow         : return vmIntrinsics::_dpow;
214   case java_lang_math_exp         : return vmIntrinsics::_dexp;
215   case java_lang_math_fmaD        : return vmIntrinsics::_fmaD;
216   case java_lang_math_fmaF        : return vmIntrinsics::_fmaF;
217   case java_lang_ref_reference_get0: return vmIntrinsics::_Reference_get0;
218   case java_util_zip_CRC32_update : return vmIntrinsics::_updateCRC32;
219   case java_util_zip_CRC32_updateBytes
220                                   : return vmIntrinsics::_updateBytesCRC32;
221   case java_util_zip_CRC32_updateByteBuffer
222                                   : return vmIntrinsics::_updateByteBufferCRC32;
223   case java_util_zip_CRC32C_updateBytes
224                                   : return vmIntrinsics::_updateBytesCRC32C;
225   case java_util_zip_CRC32C_updateDirectByteBuffer
226                                   : return vmIntrinsics::_updateDirectByteBufferCRC32C;
227   case java_lang_Thread_currentThread
228                                   : return vmIntrinsics::_currentThread;
229   case java_lang_Float_float16ToFloat
230                                   : return vmIntrinsics::_float16ToFloat;
231   case java_lang_Float_floatToFloat16
232                                   : return vmIntrinsics::_floatToFloat16;
233 
234   default:
235     fatal("unexpected method intrinsic kind: %d", kind);
236     break;
237   }
238   return vmIntrinsics::_none;
239 }
240 
241 void AbstractInterpreter::set_entry_for_kind(MethodKind kind, address entry) {
242   assert(kind >= method_handle_invoke_FIRST &&
243          kind <= method_handle_invoke_LAST, "late initialization only for MH entry points");
244   assert(_entry_table[kind] == _entry_table[abstract], "previous value must be AME entry");
245   _entry_table[kind] = entry;
246 }
247 
248 // Return true if the interpreter can prove that the given bytecode has
249 // not yet been executed (in Java semantics, not in actual operation).
250 bool AbstractInterpreter::is_not_reached(const methodHandle& method, int bci) {
251   BytecodeStream s(method, bci);
252   Bytecodes::Code code = s.next();
253 
254   if (Bytecodes::is_invoke(code)) {
255     assert(!Bytecodes::must_rewrite(code), "invokes aren't rewritten");
256     ConstantPool* cpool = method()->constants();
257 
258     Bytecode invoke_bc(s.bytecode());
259 
260     switch (code) {
261       case Bytecodes::_invokedynamic: {
262         assert(invoke_bc.has_index_u4(code), "sanity");
263         int method_index = invoke_bc.get_index_u4(code);
264         return cpool->resolved_indy_entry_at(method_index)->is_resolved();
265       }
266       case Bytecodes::_invokevirtual:   // fall-through
267       case Bytecodes::_invokeinterface: // fall-through
268       case Bytecodes::_invokespecial:   // fall-through
269       case Bytecodes::_invokestatic: {
270         if (cpool->has_preresolution()) {
271           return false; // might have been reached
272         }
273         assert(!invoke_bc.has_index_u4(code), "sanity");
274         int method_index = invoke_bc.get_index_u2(code);
275         constantPoolHandle cp(Thread::current(), cpool);
276         Method* resolved_method = ConstantPool::method_at_if_loaded(cp, method_index);
277         return (resolved_method == nullptr);
278       }
279       default: ShouldNotReachHere();
280     }
281   } else if (!Bytecodes::must_rewrite(code)) {
282     // might have been reached
283     return false;
284   }
285 
286   // the bytecode might not be rewritten if the method is an accessor, etc.
287   address ientry = method->interpreter_entry();
288   if (ientry != entry_for_kind(AbstractInterpreter::zerolocals) &&
289       ientry != entry_for_kind(AbstractInterpreter::zerolocals_synchronized))
290     return false;  // interpreter does not run this method!
291 
292   // otherwise, we can be sure this bytecode has never been executed
293   return true;
294 }
295 
296 
297 #ifndef PRODUCT
298 void AbstractInterpreter::print_method_kind(MethodKind kind) {
299   switch (kind) {
300     case zerolocals             : tty->print("zerolocals"             ); break;
301     case zerolocals_synchronized: tty->print("zerolocals_synchronized"); break;
302     case native                 : tty->print("native"                 ); break;
303     case native_synchronized    : tty->print("native_synchronized"    ); break;
304     case empty                  : tty->print("empty"                  ); break;
305     case getter                 : tty->print("getter"                 ); break;
306     case setter                 : tty->print("setter"                 ); break;
307     case abstract               : tty->print("abstract"               ); break;
308     case java_lang_math_sin     : tty->print("java_lang_math_sin"     ); break;
309     case java_lang_math_cos     : tty->print("java_lang_math_cos"     ); break;
310     case java_lang_math_tan     : tty->print("java_lang_math_tan"     ); break;
311     case java_lang_math_sinh    : tty->print("java_lang_math_sinh"    ); break;
312     case java_lang_math_tanh    : tty->print("java_lang_math_tanh"    ); break;
313     case java_lang_math_cbrt    : tty->print("java_lang_math_cbrt"    ); break;
314     case java_lang_math_abs     : tty->print("java_lang_math_abs"     ); break;
315     case java_lang_math_log     : tty->print("java_lang_math_log"     ); break;
316     case java_lang_math_log10   : tty->print("java_lang_math_log10"   ); break;
317     case java_lang_math_pow     : tty->print("java_lang_math_pow"     ); break;
318     case java_lang_math_exp     : tty->print("java_lang_math_exp"     ); break;
319     case java_lang_math_fmaD    : tty->print("java_lang_math_fmaD"    ); break;
320     case java_lang_math_fmaF    : tty->print("java_lang_math_fmaF"    ); break;
321     case java_lang_math_sqrt    : tty->print("java_lang_math_sqrt"    ); break;
322     case java_lang_math_sqrt_strict           : tty->print("java_lang_math_sqrt_strict"); break;
323     case java_util_zip_CRC32_update           : tty->print("java_util_zip_CRC32_update"); break;
324     case java_util_zip_CRC32_updateBytes      : tty->print("java_util_zip_CRC32_updateBytes"); break;
325     case java_util_zip_CRC32_updateByteBuffer : tty->print("java_util_zip_CRC32_updateByteBuffer"); break;
326     case java_util_zip_CRC32C_updateBytes     : tty->print("java_util_zip_CRC32C_updateBytes"); break;
327     case java_util_zip_CRC32C_updateDirectByteBuffer: tty->print("java_util_zip_CRC32C_updateDirectByteByffer"); break;
328     case java_lang_ref_reference_get0         : tty->print("java_lang_ref_reference_get0"); break;
329     case java_lang_Thread_currentThread       : tty->print("java_lang_Thread_currentThread"); break;
330     case java_lang_Float_float16ToFloat       : tty->print("java_lang_Float_float16ToFloat"); break;
331     case java_lang_Float_floatToFloat16       : tty->print("java_lang_Float_floatToFloat16"); break;
332     default:
333       if (kind >= method_handle_invoke_FIRST &&
334           kind <= method_handle_invoke_LAST) {
335         const char* kind_name = vmIntrinsics::name_at(method_handle_intrinsic(kind));
336         if (kind_name[0] == '_')  kind_name = &kind_name[1];  // '_invokeExact' => 'invokeExact'
337         tty->print("method_handle_%s", kind_name);
338         break;
339       }
340       ShouldNotReachHere();
341       break;
342   }
343 }
344 #endif // PRODUCT
345 
346 
347 //------------------------------------------------------------------------------------------------------------------------
348 // Deoptimization support
349 
350 /**
351  * If a deoptimization happens, this function returns the point of next bytecode to continue execution.
352  */
353 address AbstractInterpreter::deopt_continue_after_entry(Method* method, address bcp, int callee_parameters, bool is_top_frame) {
354   assert(method->contains(bcp), "just checkin'");
355 
356   // Get the original and rewritten bytecode.
357   Bytecodes::Code code = Bytecodes::java_code_at(method, bcp);
358   assert(!Interpreter::bytecode_should_reexecute(code), "should not reexecute");
359 
360   const int bci = method->bci_from(bcp);
361 
362   // compute continuation length
363   const int length = Bytecodes::length_at(method, bcp);
364 
365   // compute result type
366   BasicType type = T_ILLEGAL;
367 
368   switch (code) {
369     case Bytecodes::_invokevirtual  :
370     case Bytecodes::_invokespecial  :
371     case Bytecodes::_invokestatic   :
372     case Bytecodes::_invokeinterface: {
373       Thread *thread = Thread::current();
374       ResourceMark rm(thread);
375       methodHandle mh(thread, method);
376       type = Bytecode_invoke(mh, bci).result_type();
377       // since the cache entry might not be initialized:
378       // (NOT needed for the old calling convention)
379       if (!is_top_frame) {
380         int index = Bytes::get_native_u2(bcp+1);
381         method->constants()->cache()->resolved_method_entry_at(index)->set_num_parameters(callee_parameters);
382       }
383       break;
384     }
385 
386    case Bytecodes::_invokedynamic: {
387       Thread *thread = Thread::current();
388       ResourceMark rm(thread);
389       methodHandle mh(thread, method);
390       type = Bytecode_invoke(mh, bci).result_type();
391       // since the cache entry might not be initialized:
392       // (NOT needed for the old calling convention)
393       if (!is_top_frame) {
394         int index = Bytes::get_native_u4(bcp+1);
395         method->constants()->resolved_indy_entry_at(index)->set_num_parameters(callee_parameters);
396       }
397       break;
398     }
399 
400     case Bytecodes::_ldc   :
401     case Bytecodes::_ldc_w : // fall through
402     case Bytecodes::_ldc2_w:
403       {
404         Thread *thread = Thread::current();
405         ResourceMark rm(thread);
406         methodHandle mh(thread, method);
407         type = Bytecode_loadconstant(mh, bci).result_type();
408         break;
409       }
410 
411     default:
412       type = Bytecodes::result_type(code);
413       break;
414   }
415 
416   // return entry point for computed continuation state & bytecode length
417   return
418     is_top_frame
419     ? Interpreter::deopt_entry (as_TosState(type), length)
420     : Interpreter::return_entry(as_TosState(type), length, code);
421 }
422 
423 // If deoptimization happens, this function returns the point where the interpreter reexecutes
424 // the bytecode.
425 // Note: Bytecodes::_athrow is a special case in that it does not return
426 //       Interpreter::deopt_entry(vtos, 0) like others
427 address AbstractInterpreter::deopt_reexecute_entry(Method* method, address bcp) {
428   assert(method->contains(bcp), "just checkin'");
429   Bytecodes::Code code   = Bytecodes::java_code_at(method, bcp);
430 #if defined(COMPILER1) || INCLUDE_JVMCI
431   if(code == Bytecodes::_athrow ) {
432     return Interpreter::rethrow_exception_entry();
433   }
434 #endif /* COMPILER1 || INCLUDE_JVMCI */
435   return Interpreter::deopt_entry(vtos, 0);
436 }
437 
438 // If deoptimization happens, the interpreter should reexecute these bytecodes.
439 // This function mainly helps the compilers to set up the reexecute bit.
440 bool AbstractInterpreter::bytecode_should_reexecute(Bytecodes::Code code) {
441   switch (code) {
442     case Bytecodes::_lookupswitch:
443     case Bytecodes::_tableswitch:
444     case Bytecodes::_fast_binaryswitch:
445     case Bytecodes::_fast_linearswitch:
446     // recompute conditional expression folded into _if<cond>
447     case Bytecodes::_lcmp      :
448     case Bytecodes::_fcmpl     :
449     case Bytecodes::_fcmpg     :
450     case Bytecodes::_dcmpl     :
451     case Bytecodes::_dcmpg     :
452     case Bytecodes::_ifnull    :
453     case Bytecodes::_ifnonnull :
454     case Bytecodes::_goto      :
455     case Bytecodes::_goto_w    :
456     case Bytecodes::_ifeq      :
457     case Bytecodes::_ifne      :
458     case Bytecodes::_iflt      :
459     case Bytecodes::_ifge      :
460     case Bytecodes::_ifgt      :
461     case Bytecodes::_ifle      :
462     case Bytecodes::_if_icmpeq :
463     case Bytecodes::_if_icmpne :
464     case Bytecodes::_if_icmplt :
465     case Bytecodes::_if_icmpge :
466     case Bytecodes::_if_icmpgt :
467     case Bytecodes::_if_icmple :
468     case Bytecodes::_if_acmpeq :
469     case Bytecodes::_if_acmpne :
470     // special cases
471     case Bytecodes::_getfield  :
472     case Bytecodes::_putfield  :
473     case Bytecodes::_getstatic :
474     case Bytecodes::_putstatic :
475     case Bytecodes::_aastore   :
476 #ifdef COMPILER1
477     //special case of reexecution
478     case Bytecodes::_athrow    :
479 #endif
480       return true;
481 
482     default:
483       return false;
484   }
485 }
486 
487 void AbstractInterpreter::initialize_method_handle_entries() {
488   // method handle entry kinds are generated later in MethodHandlesAdapterGenerator::generate:
489   for (int i = method_handle_invoke_FIRST; i <= method_handle_invoke_LAST; i++) {
490     MethodKind kind = (MethodKind) i;
491     _entry_table[kind] = _entry_table[Interpreter::abstract];
492   }
493 }