118   CallGenerator* cg_intrinsic = NULL;
 119   if (allow_inline && allow_intrinsics) {
 120     CallGenerator* cg = find_intrinsic(callee, call_does_dispatch);
 121     if (cg != NULL) {
 122       if (cg->is_predicated()) {
 123         // Code without intrinsic but, hopefully, inlined.
 124         CallGenerator* inline_cg = this->call_generator(callee,
 125               vtable_index, call_does_dispatch, jvms, allow_inline, prof_factor, speculative_receiver_type, false);
 126         if (inline_cg != NULL) {
 127           cg = CallGenerator::for_predicated_intrinsic(cg, inline_cg);
 128         }
 129       }
 130 
 131       // If intrinsic does the virtual dispatch, we try to use the type profile
 132       // first, and hopefully inline it as the regular virtual call below.
 133       // We will retry the intrinsic if nothing had claimed it afterwards.
 134       if (cg->does_virtual_dispatch()) {
 135         cg_intrinsic = cg;
 136         cg = NULL;
 137       } else if (should_delay_vector_inlining(callee, jvms)) {
 138         assert(!delayed_forbidden, "delay should be allowed");
 139         return CallGenerator::for_late_inline(callee, cg);
 140       } else {
 141         return cg;
 142       }
 143     }
 144   }
 145 
 146   // Do method handle calls.
 147   // NOTE: This must happen before normal inlining logic below since
 148   // MethodHandle.invoke* are native methods which obviously don't
 149   // have bytecodes and so normal inlining fails.
 150   if (callee->is_method_handle_intrinsic()) {
 151     CallGenerator* cg = CallGenerator::for_method_handle_call(jvms, caller, callee);
 152     return cg;
 153   }
 154 
 155   // If explicit rounding is required, do not inline strict into non-strict code (or the reverse).
 156   if (Matcher::strict_fp_requires_explicit_rounding &&
 157       caller->is_strict() != callee->is_strict()) {
 158     allow_inline = false;

 118   CallGenerator* cg_intrinsic = NULL;
 119   if (allow_inline && allow_intrinsics) {
 120     CallGenerator* cg = find_intrinsic(callee, call_does_dispatch);
 121     if (cg != NULL) {
 122       if (cg->is_predicated()) {
 123         // Code without intrinsic but, hopefully, inlined.
 124         CallGenerator* inline_cg = this->call_generator(callee,
 125               vtable_index, call_does_dispatch, jvms, allow_inline, prof_factor, speculative_receiver_type, false);
 126         if (inline_cg != NULL) {
 127           cg = CallGenerator::for_predicated_intrinsic(cg, inline_cg);
 128         }
 129       }
 130 
 131       // If intrinsic does the virtual dispatch, we try to use the type profile
 132       // first, and hopefully inline it as the regular virtual call below.
 133       // We will retry the intrinsic if nothing had claimed it afterwards.
 134       if (cg->does_virtual_dispatch()) {
 135         cg_intrinsic = cg;
 136         cg = NULL;
 137       } else if (should_delay_vector_inlining(callee, jvms)) {

 138         return CallGenerator::for_late_inline(callee, cg);
 139       } else {
 140         return cg;
 141       }
 142     }
 143   }
 144 
 145   // Do method handle calls.
 146   // NOTE: This must happen before normal inlining logic below since
 147   // MethodHandle.invoke* are native methods which obviously don't
 148   // have bytecodes and so normal inlining fails.
 149   if (callee->is_method_handle_intrinsic()) {
 150     CallGenerator* cg = CallGenerator::for_method_handle_call(jvms, caller, callee);
 151     return cg;
 152   }
 153 
 154   // If explicit rounding is required, do not inline strict into non-strict code (or the reverse).
 155   if (Matcher::strict_fp_requires_explicit_rounding &&
 156       caller->is_strict() != callee->is_strict()) {
 157     allow_inline = false;