< prev index next >

src/hotspot/share/interpreter/templateInterpreterGenerator.cpp

Print this page

173     Interpreter::_throw_NullPointerException_entry           = generate_exception_handler("java/lang/NullPointerException", nullptr);
174     Interpreter::_throw_StackOverflowError_entry             = generate_StackOverflowError_handler();
175   }
176 
177   { CodeletMark cm(_masm, "preemption resume adapter");
178     Interpreter::_cont_resume_interpreter_adapter = generate_cont_resume_interpreter_adapter();
179   }
180 
181 #define method_entry(kind)                                                                          \
182   { CodeletMark cm(_masm, "method entry point (kind = " #kind ")");                                 \
183     Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind, false); \
184   }
185 
186   // all non-native method kinds
187   method_entry(zerolocals)
188   method_entry(zerolocals_synchronized)
189   method_entry(empty)
190   method_entry(getter)
191   method_entry(setter)
192   method_entry(abstract)

193   method_entry(java_lang_math_sin  )
194   method_entry(java_lang_math_cos  )
195   method_entry(java_lang_math_tan  )
196   method_entry(java_lang_math_sinh )
197   method_entry(java_lang_math_tanh )
198   method_entry(java_lang_math_cbrt )
199   method_entry(java_lang_math_abs  )
200   method_entry(java_lang_math_sqrt )
201   method_entry(java_lang_math_sqrt_strict)
202   method_entry(java_lang_math_log  )
203   method_entry(java_lang_math_log10)
204   method_entry(java_lang_math_exp  )
205   method_entry(java_lang_math_pow  )
206   method_entry(java_lang_math_fmaF )
207   method_entry(java_lang_math_fmaD )
208   method_entry(java_lang_ref_reference_get0)
209   AbstractInterpreter::initialize_method_handle_entries();
210 
211   method_entry(java_util_zip_CRC32C_updateBytes)
212   method_entry(java_util_zip_CRC32C_updateDirectByteBuffer)

400     // dispatch to next bytecode
401     __ dispatch_epilog(tos_out, step);
402   }
403 }
404 
405 // Generate method entries
406 address TemplateInterpreterGenerator::generate_method_entry(
407                                         AbstractInterpreter::MethodKind kind, bool native) {
408   // determine code generation flags
409   bool synchronized = false;
410   address entry_point = nullptr;
411 
412   switch (kind) {
413   case Interpreter::zerolocals             :                           break;
414   case Interpreter::zerolocals_synchronized: synchronized = true;      break;
415   case Interpreter::native                 :                           break;
416   case Interpreter::native_synchronized    : synchronized = true;      break;
417   case Interpreter::empty                  : break;
418   case Interpreter::getter                 : break;
419   case Interpreter::setter                 : break;

420   case Interpreter::abstract               : entry_point = generate_abstract_entry(); break;
421   default:
422     entry_point = generate_intrinsic_entry(kind); // process the rest
423     break;
424   }
425 
426   if (entry_point) {
427     return entry_point;
428   }
429 
430   // We expect the normal and native entry points to be generated first so we can reuse them.
431   if (native) {

432     entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native);
433     if (entry_point == nullptr) {
434       entry_point = generate_native_entry(synchronized);
435     }
436   } else {
437     entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals);


438     if (entry_point == nullptr) {
439       entry_point = generate_normal_entry(synchronized);
440     }
441   }
442 
443   return entry_point;
444 }
445 
446 // Generate intrinsic method entries
447 address TemplateInterpreterGenerator::generate_intrinsic_entry(AbstractInterpreter::MethodKind kind) {
448   if (!InlineIntrinsics || !vmIntrinsics::is_intrinsic_available(AbstractInterpreter::method_intrinsic(kind))) {
449     return nullptr;
450   }
451 
452   address entry_point = nullptr;
453 
454   switch (kind) {
455   case Interpreter::java_lang_math_sin     : // fall thru
456   case Interpreter::java_lang_math_cos     : // fall thru
457   case Interpreter::java_lang_math_tan     : // fall thru
458   case Interpreter::java_lang_math_sinh    : // fall thru
459   case Interpreter::java_lang_math_tanh    : // fall thru

173     Interpreter::_throw_NullPointerException_entry           = generate_exception_handler("java/lang/NullPointerException", nullptr);
174     Interpreter::_throw_StackOverflowError_entry             = generate_StackOverflowError_handler();
175   }
176 
177   { CodeletMark cm(_masm, "preemption resume adapter");
178     Interpreter::_cont_resume_interpreter_adapter = generate_cont_resume_interpreter_adapter();
179   }
180 
181 #define method_entry(kind)                                                                          \
182   { CodeletMark cm(_masm, "method entry point (kind = " #kind ")");                                 \
183     Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind, false); \
184   }
185 
186   // all non-native method kinds
187   method_entry(zerolocals)
188   method_entry(zerolocals_synchronized)
189   method_entry(empty)
190   method_entry(getter)
191   method_entry(setter)
192   method_entry(abstract)
193   method_entry(object_init)
194   method_entry(java_lang_math_sin  )
195   method_entry(java_lang_math_cos  )
196   method_entry(java_lang_math_tan  )
197   method_entry(java_lang_math_sinh )
198   method_entry(java_lang_math_tanh )
199   method_entry(java_lang_math_cbrt )
200   method_entry(java_lang_math_abs  )
201   method_entry(java_lang_math_sqrt )
202   method_entry(java_lang_math_sqrt_strict)
203   method_entry(java_lang_math_log  )
204   method_entry(java_lang_math_log10)
205   method_entry(java_lang_math_exp  )
206   method_entry(java_lang_math_pow  )
207   method_entry(java_lang_math_fmaF )
208   method_entry(java_lang_math_fmaD )
209   method_entry(java_lang_ref_reference_get0)
210   AbstractInterpreter::initialize_method_handle_entries();
211 
212   method_entry(java_util_zip_CRC32C_updateBytes)
213   method_entry(java_util_zip_CRC32C_updateDirectByteBuffer)

401     // dispatch to next bytecode
402     __ dispatch_epilog(tos_out, step);
403   }
404 }
405 
406 // Generate method entries
407 address TemplateInterpreterGenerator::generate_method_entry(
408                                         AbstractInterpreter::MethodKind kind, bool native) {
409   // determine code generation flags
410   bool synchronized = false;
411   address entry_point = nullptr;
412 
413   switch (kind) {
414   case Interpreter::zerolocals             :                           break;
415   case Interpreter::zerolocals_synchronized: synchronized = true;      break;
416   case Interpreter::native                 :                           break;
417   case Interpreter::native_synchronized    : synchronized = true;      break;
418   case Interpreter::empty                  : break;
419   case Interpreter::getter                 : break;
420   case Interpreter::setter                 : break;
421   case Interpreter::object_init            : break;
422   case Interpreter::abstract               : entry_point = generate_abstract_entry(); break;
423   default:
424     entry_point = generate_intrinsic_entry(kind); // process the rest
425     break;
426   }
427 
428   if (entry_point) {
429     return entry_point;
430   }
431 
432   // We expect the normal and native entry points to be generated first so we can reuse them.
433   if (native) {
434     assert(kind != Interpreter::object_init, "Not supported");
435     entry_point = Interpreter::entry_for_kind(synchronized ? Interpreter::native_synchronized : Interpreter::native);
436     if (entry_point == nullptr) {
437       entry_point = generate_native_entry(synchronized);
438     }
439   } else {
440     entry_point = kind == Interpreter::object_init ?
441                   Interpreter::entry_for_kind(Interpreter::object_init) :
442                   Interpreter::entry_for_kind(synchronized ? Interpreter::zerolocals_synchronized : Interpreter::zerolocals);
443     if (entry_point == nullptr) {
444       entry_point = generate_normal_entry(synchronized, kind == Interpreter::object_init);
445     }
446   }
447 
448   return entry_point;
449 }
450 
451 // Generate intrinsic method entries
452 address TemplateInterpreterGenerator::generate_intrinsic_entry(AbstractInterpreter::MethodKind kind) {
453   if (!InlineIntrinsics || !vmIntrinsics::is_intrinsic_available(AbstractInterpreter::method_intrinsic(kind))) {
454     return nullptr;
455   }
456 
457   address entry_point = nullptr;
458 
459   switch (kind) {
460   case Interpreter::java_lang_math_sin     : // fall thru
461   case Interpreter::java_lang_math_cos     : // fall thru
462   case Interpreter::java_lang_math_tan     : // fall thru
463   case Interpreter::java_lang_math_sinh    : // fall thru
464   case Interpreter::java_lang_math_tanh    : // fall thru
< prev index next >