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/metaspaceShared.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           // No need to use the method kind with a memory barrier on entry
157           // because the method is empty and already has a memory barrier on return
158           return zerolocals;
159         } else if (EnableValhalla) {
160           // For non-empty Object constructors, we need a memory barrier
161           // when entering the method to ensure correctness of strict fields
162           return object_init;
163         }
164         break;
165       default: break;
166     }
167   }
168 
169   // Native method?
170   if (m->is_native()) {
171     if (m->is_continuation_native_intrinsic()) {
172       // This entry will never be called.  The real entry gets generated later, like for MH intrinsics.
173       return abstract;
174     }
175     assert(!m->is_method_handle_intrinsic(), "overlapping bits here, watch out");
176     return m->is_synchronized() ? native_synchronized : native;
177   }
178 
179   // Synchronized?
180   if (m->is_synchronized()) {
181     return zerolocals_synchronized;
182   }
183 
184   // Empty method?
185   if (m->is_empty_method()) {
186     return empty;
187   }
188 
189   // Getter method?
190   if (m->is_getter()) {
191     return getter;
192   }
193 
194   // Setter method?
195   if (m->is_setter()) {
196     return setter;
197   }
198 
199   // Note: for now: zero locals for all non-empty methods
200   return zerolocals;
201 }
202 
203 vmIntrinsics::ID AbstractInterpreter::method_intrinsic(MethodKind kind) {
204   switch (kind) {
205   case java_lang_math_sin         : return vmIntrinsics::_dsin;
206   case java_lang_math_cos         : return vmIntrinsics::_dcos;
207   case java_lang_math_tan         : return vmIntrinsics::_dtan;
208   case java_lang_math_sinh        : return vmIntrinsics::_dsinh;
209   case java_lang_math_tanh        : return vmIntrinsics::_dtanh;
210   case java_lang_math_cbrt        : return vmIntrinsics::_dcbrt;
211   case java_lang_math_abs         : return vmIntrinsics::_dabs;
212   case java_lang_math_log         : return vmIntrinsics::_dlog;
213   case java_lang_math_log10       : return vmIntrinsics::_dlog10;
214   case java_lang_math_sqrt        : return vmIntrinsics::_dsqrt;
215   case java_lang_math_sqrt_strict : return vmIntrinsics::_dsqrt_strict;
216   case java_lang_math_pow         : return vmIntrinsics::_dpow;
217   case java_lang_math_exp         : return vmIntrinsics::_dexp;
218   case java_lang_math_fmaD        : return vmIntrinsics::_fmaD;
219   case java_lang_math_fmaF        : return vmIntrinsics::_fmaF;
220   case java_lang_ref_reference_get0: return vmIntrinsics::_Reference_get0;
221   case java_util_zip_CRC32_update : return vmIntrinsics::_updateCRC32;
222   case java_util_zip_CRC32_updateBytes
223                                   : return vmIntrinsics::_updateBytesCRC32;
224   case java_util_zip_CRC32_updateByteBuffer
225                                   : return vmIntrinsics::_updateByteBufferCRC32;
226   case java_util_zip_CRC32C_updateBytes
227                                   : return vmIntrinsics::_updateBytesCRC32C;
228   case java_util_zip_CRC32C_updateDirectByteBuffer
229                                   : return vmIntrinsics::_updateDirectByteBufferCRC32C;
230   case java_lang_Thread_currentThread
231                                   : return vmIntrinsics::_currentThread;
232   case java_lang_Float_float16ToFloat
233                                   : return vmIntrinsics::_float16ToFloat;
234   case java_lang_Float_floatToFloat16
235                                   : return vmIntrinsics::_floatToFloat16;
236 
237   default:
238     fatal("unexpected method intrinsic kind: %d", kind);
239     break;
240   }
241   return vmIntrinsics::_none;
242 }
243 
244 void AbstractInterpreter::set_entry_for_kind(MethodKind kind, address entry) {
245   assert(kind >= method_handle_invoke_FIRST &&
246          kind <= method_handle_invoke_LAST, "late initialization only for MH entry points");
247   assert(_entry_table[kind] == _entry_table[abstract], "previous value must be AME entry");
248   _entry_table[kind] = entry;
249 }
250 
251 // Return true if the interpreter can prove that the given bytecode has
252 // not yet been executed (in Java semantics, not in actual operation).
253 bool AbstractInterpreter::is_not_reached(const methodHandle& method, int bci) {
254   BytecodeStream s(method, bci);
255   Bytecodes::Code code = s.next();
256 
257   if (Bytecodes::is_invoke(code)) {
258     assert(!Bytecodes::must_rewrite(code), "invokes aren't rewritten");
259     ConstantPool* cpool = method()->constants();
260 
261     Bytecode invoke_bc(s.bytecode());
262 
263     switch (code) {
264       case Bytecodes::_invokedynamic: {
265         assert(invoke_bc.has_index_u4(code), "sanity");
266         int method_index = invoke_bc.get_index_u4(code);
267         return cpool->resolved_indy_entry_at(method_index)->is_resolved();
268       }
269       case Bytecodes::_invokevirtual:   // fall-through
270       case Bytecodes::_invokeinterface: // fall-through
271       case Bytecodes::_invokespecial:   // fall-through
272       case Bytecodes::_invokestatic: {
273         if (cpool->has_preresolution()) {
274           return false; // might have been reached
275         }
276         assert(!invoke_bc.has_index_u4(code), "sanity");
277         int method_index = invoke_bc.get_index_u2(code);
278         constantPoolHandle cp(Thread::current(), cpool);
279         Method* resolved_method = ConstantPool::method_at_if_loaded(cp, method_index);
280         return (resolved_method == nullptr);
281       }
282       default: ShouldNotReachHere();
283     }
284   } else if (!Bytecodes::must_rewrite(code)) {
285     // might have been reached
286     return false;
287   }
288 
289   // the bytecode might not be rewritten if the method is an accessor, etc.
290   address ientry = method->interpreter_entry();
291   if (ientry != entry_for_kind(AbstractInterpreter::zerolocals) &&
292       ientry != entry_for_kind(AbstractInterpreter::zerolocals_synchronized))
293     return false;  // interpreter does not run this method!
294 
295   // otherwise, we can be sure this bytecode has never been executed
296   return true;
297 }
298 
299 
300 #ifndef PRODUCT
301 void AbstractInterpreter::print_method_kind(MethodKind kind) {
302   switch (kind) {
303     case zerolocals             : tty->print("zerolocals"             ); break;
304     case zerolocals_synchronized: tty->print("zerolocals_synchronized"); break;
305     case native                 : tty->print("native"                 ); break;
306     case native_synchronized    : tty->print("native_synchronized"    ); break;
307     case empty                  : tty->print("empty"                  ); break;
308     case getter                 : tty->print("getter"                 ); break;
309     case setter                 : tty->print("setter"                 ); break;
310     case abstract               : tty->print("abstract"               ); break;
311     case object_init            : tty->print("object_init"            ); break;
312     case java_lang_math_sin     : tty->print("java_lang_math_sin"     ); break;
313     case java_lang_math_cos     : tty->print("java_lang_math_cos"     ); break;
314     case java_lang_math_tan     : tty->print("java_lang_math_tan"     ); break;
315     case java_lang_math_sinh    : tty->print("java_lang_math_sinh"    ); break;
316     case java_lang_math_tanh    : tty->print("java_lang_math_tanh"    ); break;
317     case java_lang_math_cbrt    : tty->print("java_lang_math_cbrt"    ); break;
318     case java_lang_math_abs     : tty->print("java_lang_math_abs"     ); break;
319     case java_lang_math_log     : tty->print("java_lang_math_log"     ); break;
320     case java_lang_math_log10   : tty->print("java_lang_math_log10"   ); break;
321     case java_lang_math_pow     : tty->print("java_lang_math_pow"     ); break;
322     case java_lang_math_exp     : tty->print("java_lang_math_exp"     ); break;
323     case java_lang_math_fmaD    : tty->print("java_lang_math_fmaD"    ); break;
324     case java_lang_math_fmaF    : tty->print("java_lang_math_fmaF"    ); break;
325     case java_lang_math_sqrt    : tty->print("java_lang_math_sqrt"    ); break;
326     case java_lang_math_sqrt_strict           : tty->print("java_lang_math_sqrt_strict"); break;
327     case java_util_zip_CRC32_update           : tty->print("java_util_zip_CRC32_update"); break;
328     case java_util_zip_CRC32_updateBytes      : tty->print("java_util_zip_CRC32_updateBytes"); break;
329     case java_util_zip_CRC32_updateByteBuffer : tty->print("java_util_zip_CRC32_updateByteBuffer"); break;
330     case java_util_zip_CRC32C_updateBytes     : tty->print("java_util_zip_CRC32C_updateBytes"); break;
331     case java_util_zip_CRC32C_updateDirectByteBuffer: tty->print("java_util_zip_CRC32C_updateDirectByteByffer"); break;
332     case java_lang_ref_reference_get0         : tty->print("java_lang_ref_reference_get0"); break;
333     case java_lang_Thread_currentThread       : tty->print("java_lang_Thread_currentThread"); break;
334     case java_lang_Float_float16ToFloat       : tty->print("java_lang_Float_float16ToFloat"); break;
335     case java_lang_Float_floatToFloat16       : tty->print("java_lang_Float_floatToFloat16"); break;
336     default:
337       if (kind >= method_handle_invoke_FIRST &&
338           kind <= method_handle_invoke_LAST) {
339         const char* kind_name = vmIntrinsics::name_at(method_handle_intrinsic(kind));
340         if (kind_name[0] == '_')  kind_name = &kind_name[1];  // '_invokeExact' => 'invokeExact'
341         tty->print("method_handle_%s", kind_name);
342         break;
343       }
344       ShouldNotReachHere();
345       break;
346   }
347 }
348 #endif // PRODUCT
349 
350 
351 //------------------------------------------------------------------------------------------------------------------------
352 // Deoptimization support
353 
354 /**
355  * If a deoptimization happens, this function returns the point of next bytecode to continue execution.
356  */
357 address AbstractInterpreter::deopt_continue_after_entry(Method* method, address bcp, int callee_parameters, bool is_top_frame) {
358   assert(method->contains(bcp), "just checkin'");
359 
360   // Get the original and rewritten bytecode.
361   Bytecodes::Code code = Bytecodes::java_code_at(method, bcp);
362   assert(!Interpreter::bytecode_should_reexecute(code), "should not reexecute");
363 
364   const int bci = method->bci_from(bcp);
365 
366   // compute continuation length
367   const int length = Bytecodes::length_at(method, bcp);
368 
369   // compute result type
370   BasicType type = T_ILLEGAL;
371 
372   switch (code) {
373     case Bytecodes::_invokevirtual  :
374     case Bytecodes::_invokespecial  :
375     case Bytecodes::_invokestatic   :
376     case Bytecodes::_invokeinterface: {
377       Thread *thread = Thread::current();
378       ResourceMark rm(thread);
379       methodHandle mh(thread, method);
380       type = Bytecode_invoke(mh, bci).result_type();
381       // since the cache entry might not be initialized:
382       // (NOT needed for the old calling convention)
383       if (!is_top_frame) {
384         int index = Bytes::get_native_u2(bcp+1);
385         method->constants()->cache()->resolved_method_entry_at(index)->set_num_parameters(callee_parameters);
386       }
387       break;
388     }
389 
390    case Bytecodes::_invokedynamic: {
391       Thread *thread = Thread::current();
392       ResourceMark rm(thread);
393       methodHandle mh(thread, method);
394       type = Bytecode_invoke(mh, bci).result_type();
395       // since the cache entry might not be initialized:
396       // (NOT needed for the old calling convention)
397       if (!is_top_frame) {
398         int index = Bytes::get_native_u4(bcp+1);
399         method->constants()->resolved_indy_entry_at(index)->set_num_parameters(callee_parameters);
400       }
401       break;
402     }
403 
404     case Bytecodes::_ldc   :
405     case Bytecodes::_ldc_w : // fall through
406     case Bytecodes::_ldc2_w:
407       {
408         Thread *thread = Thread::current();
409         ResourceMark rm(thread);
410         methodHandle mh(thread, method);
411         type = Bytecode_loadconstant(mh, bci).result_type();
412         break;
413       }
414 
415     default:
416       type = Bytecodes::result_type(code);
417       break;
418   }
419 
420   // return entry point for computed continuation state & bytecode length
421   return
422     is_top_frame
423     ? Interpreter::deopt_entry (as_TosState(type), length)
424     : Interpreter::return_entry(as_TosState(type), length, code);
425 }
426 
427 // If deoptimization happens, this function returns the point where the interpreter reexecutes
428 // the bytecode.
429 // Note: Bytecodes::_athrow is a special case in that it does not return
430 //       Interpreter::deopt_entry(vtos, 0) like others
431 address AbstractInterpreter::deopt_reexecute_entry(Method* method, address bcp) {
432   assert(method->contains(bcp), "just checkin'");
433   Bytecodes::Code code   = Bytecodes::java_code_at(method, bcp);
434 #if defined(COMPILER1) || INCLUDE_JVMCI
435   if(code == Bytecodes::_athrow ) {
436     return Interpreter::rethrow_exception_entry();
437   }
438 #endif /* COMPILER1 || INCLUDE_JVMCI */
439   return Interpreter::deopt_entry(vtos, 0);
440 }
441 
442 // If deoptimization happens, the interpreter should reexecute these bytecodes.
443 // This function mainly helps the compilers to set up the reexecute bit.
444 bool AbstractInterpreter::bytecode_should_reexecute(Bytecodes::Code code) {
445   switch (code) {
446     case Bytecodes::_lookupswitch:
447     case Bytecodes::_tableswitch:
448     case Bytecodes::_fast_binaryswitch:
449     case Bytecodes::_fast_linearswitch:
450     // recompute conditional expression folded into _if<cond>
451     case Bytecodes::_lcmp      :
452     case Bytecodes::_fcmpl     :
453     case Bytecodes::_fcmpg     :
454     case Bytecodes::_dcmpl     :
455     case Bytecodes::_dcmpg     :
456     case Bytecodes::_ifnull    :
457     case Bytecodes::_ifnonnull :
458     case Bytecodes::_goto      :
459     case Bytecodes::_goto_w    :
460     case Bytecodes::_ifeq      :
461     case Bytecodes::_ifne      :
462     case Bytecodes::_iflt      :
463     case Bytecodes::_ifge      :
464     case Bytecodes::_ifgt      :
465     case Bytecodes::_ifle      :
466     case Bytecodes::_if_icmpeq :
467     case Bytecodes::_if_icmpne :
468     case Bytecodes::_if_icmplt :
469     case Bytecodes::_if_icmpge :
470     case Bytecodes::_if_icmpgt :
471     case Bytecodes::_if_icmple :
472     case Bytecodes::_if_acmpeq :
473     case Bytecodes::_if_acmpne :
474     // special cases
475     case Bytecodes::_getfield  :
476     case Bytecodes::_putfield  :
477     case Bytecodes::_getstatic :
478     case Bytecodes::_putstatic :
479     case Bytecodes::_aastore   :
480 #ifdef COMPILER1
481     //special case of reexecution
482     case Bytecodes::_athrow    :
483 #endif
484       return true;
485 
486     default:
487       return false;
488   }
489 }
490 
491 void AbstractInterpreter::initialize_method_handle_entries() {
492   // method handle entry kinds are generated later in MethodHandlesAdapterGenerator::generate:
493   for (int i = method_handle_invoke_FIRST; i <= method_handle_invoke_LAST; i++) {
494     MethodKind kind = (MethodKind) i;
495     _entry_table[kind] = _entry_table[Interpreter::abstract];
496   }
497 }