diff a/src/hotspot/share/opto/callGenerator.cpp b/src/hotspot/share/opto/callGenerator.cpp
--- a/src/hotspot/share/opto/callGenerator.cpp
+++ b/src/hotspot/share/opto/callGenerator.cpp
@@ -642,10 +642,14 @@
     kit.replace_call(call, C->top(), true);
   } else {
     // Make a clone of the JVMState that appropriate to use for driving a parse
     JVMState* old_jvms = call->jvms();
     JVMState* jvms = old_jvms->clone_shallow(C);
+
+    // Clear the allocation state. We assume all inputs are materialized.
+    jvms->alloc_state().clear();
+
     uint size = call->req();
     SafePointNode* map = new SafePointNode(size, jvms);
     for (uint i1 = 0; i1 < size; i1++) {
       map->init_req(i1, call->in(i1));
     }
@@ -809,11 +813,11 @@
   return new LateInlineVectorReboxingCallGenerator(method, inline_cg);
 }
 
 //------------------------PredictedCallGenerator------------------------------
 // Internal class which handles all out-of-line calls checking receiver type.
-class PredictedCallGenerator : public CallGenerator {
+class PredictedCallGenerator : public InlineCallGenerator {
   ciKlass*       _predicted_receiver;
   CallGenerator* _if_missed;
   CallGenerator* _if_hit;
   float          _hit_prob;
   bool           _exact_check;
@@ -821,11 +825,11 @@
 public:
   PredictedCallGenerator(ciKlass* predicted_receiver,
                          CallGenerator* if_missed,
                          CallGenerator* if_hit, bool exact_check,
                          float hit_prob)
-    : CallGenerator(if_missed->method())
+    : InlineCallGenerator(if_missed->method())
   {
     // The call profile data may predict the hit_prob as extreme as 0 or 1.
     // Remove the extremes values from the range.
     if (hit_prob > PROB_MAX)   hit_prob = PROB_MAX;
     if (hit_prob < PROB_MIN)   hit_prob = PROB_MIN;
@@ -914,11 +918,10 @@
     return kit.transfer_exceptions_into_jvms();
   }
 
   // Fall through if the instance matches the desired type.
   kit.replace_in_map(receiver, casted_receiver);
-
   // Make the hot call:
   JVMState* new_jvms = _if_hit->generate(kit.sync_jvms());
   if (new_jvms == nullptr) {
     // Inline failed, so make a direct call.
     assert(_if_hit->is_inline(), "must have been a failed inline");
@@ -943,10 +946,13 @@
   // There are 2 branches and the replaced nodes are only valid on
   // one: restore the replaced nodes to what they were before the
   // branch.
   kit.map()->set_replaced_nodes(replaced_nodes);
 
+  PEAState& slow_as = slow_jvms->alloc_state();
+  PEAState& as = new_jvms->alloc_state();
+  AllocationStateMerger as_merger(as);
   // Finish the diamond.
   kit.C->set_has_split_ifs(true); // Has chance for split-if optimization
   RegionNode* region = new RegionNode(3);
   region->init_req(1, kit.control());
   region->init_req(2, slow_map->control());
@@ -976,12 +982,19 @@
     if (m != n) {
       const Type* t = gvn.type(m)->meet_speculative(gvn.type(n));
       Node* phi = PhiNode::make(region, m, t);
       phi->set_req(2, n);
       kit.map()->set_req(i, gvn.transform(phi));
+      if (DoPartialEscapeAnalysis) {
+        as_merger.merge_at_phi_creation(kit.PEA(), slow_as, phi->as_Phi(), m, n);
+      }
     }
   }
+
+  if (DoPartialEscapeAnalysis) {
+    as_merger.merge(slow_as, &kit, region, 2);
+  }
   return kit.transfer_exceptions_into_jvms();
 }
 
 
 CallGenerator* CallGenerator::for_method_handle_call(JVMState* jvms, ciMethod* caller, ciMethod* callee, bool allow_inline) {
@@ -1154,25 +1167,24 @@
   return nullptr;
 }
 
 //------------------------PredicatedIntrinsicGenerator------------------------------
 // Internal class which handles all predicated Intrinsic calls.
-class PredicatedIntrinsicGenerator : public CallGenerator {
+class PredicatedIntrinsicGenerator : public InlineCallGenerator {
   CallGenerator* _intrinsic;
   CallGenerator* _cg;
 
 public:
   PredicatedIntrinsicGenerator(CallGenerator* intrinsic,
                                CallGenerator* cg)
-    : CallGenerator(cg->method())
+    : InlineCallGenerator(cg->method())
   {
     _intrinsic = intrinsic;
     _cg        = cg;
   }
 
   virtual bool      is_virtual()   const    { return true; }
-  virtual bool      is_inline()    const    { return true; }
   virtual bool      is_intrinsic() const    { return true; }
 
   virtual JVMState* generate(JVMState* jvms);
 };
 
@@ -1241,10 +1253,11 @@
     assert(old_exc == new_map->next_exception(), "generate_predicate should not add exceptions");
 #endif
     if (!kit.stopped()) {
       PreserveJVMState pjvms(&kit);
       // Generate intrinsic code:
+      assert(_intrinsic->is_inline(), "LibraryIntrinsic");
       JVMState* new_jvms = _intrinsic->generate(kit.sync_jvms());
       if (new_jvms == nullptr) {
         // Intrinsic failed, use normal compilation path for this predicate.
         slow_region->add_req(kit.control());
       } else {
