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