Eliminate final usage of spillInlinedFrames()

Summary: Now that `CallFuncEntry` operates on frame locals we can simple use it when side exiting from a func entry instead of doing an `InlineCall` and spilling all inlined frames.

Reviewed By: jano

Differential Revision: D72594276

fbshipit-source-id: 172193fb545d0b0a41962156f43cb27b350be80d

Author: paulbiss

hphp/doc/ir.specification

@@ -1629,19 +1629,6 @@ To string conversions:
 
   Marks the end of an inlined function. S0 is no longer a valid frame location.
 
-| InlineCall<retSPOff>, ND, S(FramePtr) S(FramePtr), NF
-
-  Sets the current vmfp for an inlined call to S0, and the m_sfp of S0 to the
-  previous vmfp, S1.
-
-  This instruction is primarily used to represent an inlined frame in the IR
-  when it cannot be eliminated during a side-exit. It performs callee-side
-  responsibilities for setting up an activation record (i.e. setting the return
-  ip, m_func and m_callOff, storing the frame pointer into D).
-
-  The caller frame pointer is passed as S1. This is used to keep track of the
-  call chain of inlined functions for simplification and dead code elimination.
-
 | InlineSideExitSyncStack<offset>, ND, S(StkPtr), NF
 
 This instruction does nothing, but has memory effects that force the stack
@@ -1898,10 +1885,6 @@ ReqBindJmp and CallFuncEntry.
 
   Store the func in m_funcId/m_func for S0.
 
-| StFrameMeta<callBCOff,flags>, ND, S(FramePtr), NF
-
-  Store the m_callOffAndFlags field of S0.
-
 10. Trace exits
 
 | StVMFP, ND, S(FramePtr), NF

hphp/runtime/vm/jit/alias-analysis.cpp

@@ -73,9 +73,7 @@ void visit_locations(const BlockList& blocks, Visit visit) {
         [&] (const PureStore& x)         { visit(x.dst); },
         [&] (const ExitEffects& x)       { visit(x.live);
                                            visit(x.kills);
-                                           visit(x.uninits); },
-        [&] (const PureInlineCall& x)    { visit(x.base);
-                                           visit(x.actrec); }
+                                           visit(x.uninits); }
       );
     }
   }

hphp/runtime/vm/jit/dce.cpp

@@ -455,7 +455,6 @@ bool canDCE(const IRInstruction& inst) {
   case NewStructDict:
   case NewBespokeStructDict:
   case Clone:
-  case InlineCall:
   case InlineSideExit:
   case InlineSideExitSyncStack:
   case Call:
@@ -740,7 +739,6 @@ bool canDCE(const IRInstruction& inst) {
   case ProfileIsTypeStruct:
   case StFrameCtx:
   case StFrameFunc:
-  case StFrameMeta:
   case LookupClsCns:
   case LookupClsCtxCns:
   case ArrayMarkLegacyShallow:
@@ -1078,12 +1076,7 @@ void processCatchBlock(IRUnit& unit, DceState& state, Block* block,
       },
       [&] (const PureLoad& x)           { return process_stack(x.src); },
       [&] (const PureStore& x)          { return do_store(x.dst, &*inst); },
-      [&] (const ExitEffects& x)        { return process_stack(x.live); },
-      [&] (const PureInlineCall& x) {
-        return
-          process_stack(x.base) ||
-          process_stack(x.actrec);
-      }
+      [&] (const ExitEffects& x)        { return process_stack(x.live); }
     );
   }
 

hphp/runtime/vm/jit/def-sink.cpp

@@ -457,7 +457,6 @@ bool conflicts(const IRInstruction& instr,
     [&] (const GeneralEffects&)      { return false; },
     [&] (const PureLoad&)            { return false; },
     [&] (const PureStore&)           { return false; },
-    [&] (const PureInlineCall&)      { return false; },
     [&] (const ExitEffects&)         { return true; },
     [&] (const UnknownEffects&)      { return true; }
   );
@@ -494,7 +493,6 @@ bool conflicts(const IRInstruction& instr,
     },
     [&] (const PureLoad&)            { return false; },
     [&] (const PureStore& store)     { return load.src.maybe(store.dst); },
-    [&] (const PureInlineCall& call) { return load.src.maybe(call.base); },
     [&] (const ExitEffects&)         { return true; },
     [&] (const UnknownEffects&)      { return true; }
   );
@@ -550,7 +548,6 @@ bool conflicts(const IRInstruction& instr,
     },
     [&] (const PureLoad&)            { return false; },
     [&] (const PureStore& store)     { return test_reads(store.dst); },
-    [&] (const PureInlineCall& call) { return test_reads(call.base); },
     [&] (const ExitEffects&)         { return true; },
     [&] (const UnknownEffects&)      { return true; }
   );
@@ -594,7 +591,6 @@ bool conflicts(const IRInstruction& sinkee, const IRInstruction& barrier) {
     [&] (const ReturnEffects&)       { always_assert(false); return true; },
     [&] (const CallEffects&)         { always_assert(false); return true; },
     [&] (const PureStore&)           { always_assert(false); return true; },
-    [&] (const PureInlineCall&)      { always_assert(false); return true; },
     [&] (const ExitEffects&)         { always_assert(false); return true; },
     [&] (const UnknownEffects&)      { always_assert(false); return true; }
   );
@@ -636,7 +632,6 @@ TriBool will_conflict(const IRInstruction& inst) {
     [&] (const ReturnEffects&)       { return TriBool::Yes; },
     [&] (const CallEffects&)         { return TriBool::Maybe; },
     [&] (const PureStore&)           { return TriBool::Maybe; },
-    [&] (const PureInlineCall&)      { return TriBool::Maybe; },
     [&] (const ExitEffects&)         { return TriBool::Yes; },
     [&] (const UnknownEffects&)      { return TriBool::Yes; }
   );
@@ -1118,7 +1113,6 @@ State make_state(IRUnit& unit,
       [&] (const ReturnEffects&)       { return false; },
       [&] (const CallEffects&)         { return false; },
       [&] (const PureStore&)           { return false; },
-      [&] (const PureInlineCall&)      { return false; },
       [&] (const ExitEffects&)         { return false; },
       [&] (const UnknownEffects&)      { return false; }
     );

hphp/runtime/vm/jit/extra-data.h

@@ -1168,31 +1168,6 @@ struct ReqBindJmpData : IRExtraData {
   bool popFrame;
 };
 
-struct StFrameMetaData : IRExtraData {
-  std::string show() const {
-    return folly::to<std::string>(
-      callBCOff, ',',
-      asyncEagerReturn
-    );
-  }
-
-  size_t stableHash() const {
-    return folly::hash::hash_combine(
-      std::hash<Offset>()(callBCOff),
-      std::hash<bool>()(asyncEagerReturn)
-    );
-  }
-
-  bool equals(const StFrameMetaData& o) const {
-    return callBCOff == o.callBCOff && asyncEagerReturn == o.asyncEagerReturn;
-  }
-
-
-  Offset callBCOff;
-  bool isInlined;
-  bool asyncEagerReturn;
-};
-
 struct CallBuiltinData : IRExtraData {
   explicit CallBuiltinData(IRSPRelOffset spOffset,
                            const Func* callee)
@@ -3141,7 +3116,6 @@ X(DefFrameRelSP,                DefStackData);
 X(DefRegSP,                     DefStackData);
 X(LdStk,                        IRSPRelOffsetData);
 X(LdStkAddr,                    IRSPRelOffsetData);
-X(StFrameMeta,                  StFrameMetaData);
 X(DefCalleeFP,                  DefCalleeFPData);
 X(ReqBindJmp,                   ReqBindJmpData);
 X(ReqInterpBBNoTranslate,       ReqBindJmpData);

hphp/runtime/vm/jit/frame-state.cpp

@@ -306,7 +306,6 @@ void FrameStateMgr::update(const IRInstruction* inst) {
   switch (inst->op()) {
   case EnterInlineFrame: trackEnterInlineFrame(inst); break;
   case LeaveInlineFrame: trackLeaveInlineFrame(); break;
-  case InlineCall:       trackInlineCall(inst); break;
   case InlineSideExit:   trackInlineSideExit(inst); break;
   case InlineSideExitSyncStack:
     assertx(cur().bcSPOff ==
@@ -764,7 +763,6 @@ void FrameStateMgr::handleConservatively(const IRInstruction* inst) {
       store(x.outputs);
     },
     [&] (const PureStore& x)       { store(x.dst); },
-    [&] (const PureInlineCall& x)  { store(x.base); },
     [&] (const UnknownEffects&)    { store(AUnknown); },
     [&] (const ReturnEffects&)     {},
     [&] (const ExitEffects&)       {},
@@ -1073,11 +1071,6 @@ void FrameStateMgr::trackLeaveInlineFrame() {
   assertx(cur().checkMInstrStateDead());
 }
 
-void FrameStateMgr::trackInlineCall(const IRInstruction* inst) {
-  assertx(cur().fixupFPValue == inst->src(1));
-  cur().fixupFPValue = inst->src(0);
-}
-
 void FrameStateMgr::trackInlineSideExit(const IRInstruction* inst) {
   auto const callee = inst->extra<InlineSideExit>()->callee;
   auto const arOffset = inst->src(1)->inst()->extra<DefCalleeFP>()->spOffset;

hphp/runtime/vm/jit/frame-state.h

@@ -515,7 +515,6 @@ struct FrameStateMgr final {
   void uninitStack();
   void trackEnterInlineFrame(const IRInstruction* inst);
   void trackLeaveInlineFrame();
-  void trackInlineCall(const IRInstruction* inst);
   void trackInlineSideExit(const IRInstruction* inst);
 
   void pointerLoad(SSATmp*, SSATmp*);

hphp/runtime/vm/jit/inline-state.h

@@ -67,6 +67,11 @@ struct InlineFrame {
    * Saved cost.
    */
   int savedCost;
+
+  /*
+   * Callee context (TCls, TObj, TNullptr)
+   */
+  SSATmp* ctx;
 };
 
 struct InlineState {

hphp/runtime/vm/jit/ir-opcode.cpp

@@ -681,7 +681,6 @@ bool opcodeMayRaise(Opcode opc) {
   case InitThrowableFileAndLine:
   case InitVecElem:
   case InitVecElemLoop:
-  case InlineCall:
   case InlineSideExitSyncStack:
   case InstanceOf:
   case InstanceOfBitmask:
@@ -918,7 +917,6 @@ bool opcodeMayRaise(Opcode opc) {
   case StContArValue:
   case StFrameCtx:
   case StFrameFunc:
-  case StFrameMeta:
   case StImplicitContext:
   case StIterEnd:
   case StIterPos:

hphp/runtime/vm/jit/irgen-call.cpp

@@ -280,34 +280,6 @@ SSATmp* callImpl(IRGS& env, SSATmp* callee, const FCallArgs& fca,
   );
 }
 
-SSATmp* callFuncEntry(IRGS& env, SrcKey entry, SSATmp* objOrClass,
-                      SSATmp* calleeFP, uint32_t numArgsInclUnpack,
-                      bool asyncEagerReturn) {
-  assertx(entry.funcEntry());
-  if (objOrClass == nullptr) objOrClass = cns(env, TNullptr);
-  assertx(objOrClass->isA(TNullptr) || objOrClass->isA(TObj|TCls));
-
-  auto const pubFP = env.irb->fs()[0].fp();
-  auto pubBcOff = bcOff(env);
-  if (env.irb->fs().inlineDepth()) {
-    auto const firstUnpubFP = env.irb->fs()[1].fp();
-    pubBcOff = firstUnpubFP->inst()->marker().sk().offset();
-  }
-
-  auto const arFlags = ActRec::encodeCallOffsetAndFlags(
-    pubBcOff,
-    asyncEagerReturn ? (1 << ActRec::AsyncEagerRet) : 0
-  );
-
-  auto const data = CallFuncEntryData {
-    entry,
-    numArgsInclUnpack,
-    arFlags,
-    env.formingRegion
-  };
-  return gen(env, CallFuncEntry, data, calleeFP, pubFP, objOrClass);
-}
-
 void handleCallReturn(IRGS& env, const Func* callee, SSATmp* retVal,
                       Offset asyncEagerOffset, bool unlikely) {
   // Insert a debugger interrupt check after returning from a call
@@ -1363,6 +1335,34 @@ void fcallFuncStr(IRGS& env, const FCallArgs& fca) {
 
 } // namespace
 
+SSATmp* callFuncEntry(IRGS& env, SrcKey entry, SSATmp* objOrClass,
+                      SSATmp* calleeFP, uint32_t numArgsInclUnpack,
+                      bool asyncEagerReturn) {
+  assertx(entry.funcEntry());
+  if (objOrClass == nullptr) objOrClass = cns(env, TNullptr);
+  assertx(objOrClass->isA(TNullptr) || objOrClass->isA(TObj|TCls));
+
+  auto const pubFP = env.irb->fs()[0].fp();
+  auto pubBcOff = bcOff(env);
+  if (env.irb->fs().inlineDepth()) {
+    auto const firstUnpubFP = env.irb->fs()[1].fp();
+    pubBcOff = firstUnpubFP->inst()->marker().sk().offset();
+  }
+
+  auto const arFlags = ActRec::encodeCallOffsetAndFlags(
+    pubBcOff,
+    asyncEagerReturn ? (1 << ActRec::AsyncEagerRet) : 0
+  );
+
+  auto const data = CallFuncEntryData {
+    entry,
+    numArgsInclUnpack,
+    arFlags,
+    env.formingRegion
+  };
+  return gen(env, CallFuncEntry, data, calleeFP, pubFP, objOrClass);
+}
+
 void emitDeploymentBoundaryCheck(IRGS& env, SSATmp* symbol) {
   if (!Cfg::Eval::EnforceDeployment) return;
   auto const caller = curFunc(env);