Remove jit::hir::BasicBlock::cfg

Summary:
Remove the reverse-reference from BasicBlock to CFG.  It isn't needed, all
places where we need the CFG it is already accessible.

Reviewed By: yoney

Differential Revision: D88279074

fbshipit-source-id: e9a7adfbe3d1ba0416fd4ea8a6bb7d4c408d88b4

Author: alexmalyshev

cinderx/Jit/hir/builder.cpp

@@ -736,7 +736,7 @@ InlineResult HIRBuilder::inlineHIR(
 
   // The caller function has already been converted to SSA form and all HIR
   // passes require input to be in SSA form. SSAify the inlined function.
-  SSAify{}.Run(entry_block, &caller->env);
+  SSAify{}.Run(*caller, entry_block);
 
   // Re-link the CFG.
   for (auto& [fs, parent] : framestate_parent) {

cinderx/Jit/hir/hir.cpp

@@ -17,7 +17,7 @@ namespace jit::hir {
 #ifndef _LIBCPP_VERSION
 static_assert(sizeof(Function) == 48 * kPointerSize);
 static_assert(sizeof(CFG) == 6 * kPointerSize);
-static_assert(sizeof(BasicBlock) == 21 * kPointerSize);
+static_assert(sizeof(BasicBlock) == 20 * kPointerSize);
 static_assert(sizeof(Instr) == 6 * kPointerSize);
 #endif
 
@@ -1041,7 +1041,6 @@ void BasicBlock::removePhiPredecessor(BasicBlock* old_pred) {
 
 BasicBlock* CFG::AllocateBlock() {
   auto block = AllocateUnlinkedBlock();
-  block->cfg = this;
   blocks.PushBack(*block);
   return block;
 }
@@ -1054,14 +1053,11 @@ BasicBlock* CFG::AllocateUnlinkedBlock() {
 }
 
 void CFG::InsertBlock(BasicBlock* block) {
-  block->cfg = this;
   blocks.PushBack(*block);
 }
 
 void CFG::RemoveBlock(BasicBlock* block) {
-  JIT_DCHECK(block->cfg == this, "block doesn't belong to us");
   block->cfg_node.Unlink();
-  block->cfg = nullptr;
 }
 
 BasicBlock* CFG::splitAfter(Instr& target) {

cinderx/Jit/hir/hir.h

@@ -3765,7 +3765,7 @@ class CFG;
 class BasicBlock {
  public:
   BasicBlock() : BasicBlock(0) {}
-  explicit BasicBlock(int id_) : id(id_), cfg(nullptr) {}
+  explicit BasicBlock(int id_) : id(id_) {}
   ~BasicBlock();
 
   // Replace any references to old_pred in this block's Phis with new_pred.
@@ -3910,9 +3910,6 @@ class BasicBlock {
 
   int id;
 
-  // CFG that this block belongs to; may be NULL
-  CFG* cfg;
-
   // Basic blocks belong to a list of all blocks in their CFG
   IntrusiveListNode cfg_node;
 

cinderx/Jit/hir/pass.cpp

@@ -542,10 +542,14 @@ Type outputType(const Instr& instr) {
       instr, [&](std::size_t ind) { return instr.GetOperand(ind)->type(); });
 }
 
-void reflowTypes(Environment* env, BasicBlock* start) {
+void reflowTypes(Function& func) {
+  reflowTypes(func, func.cfg.entry_block);
+}
+
+void reflowTypes(Function& func, BasicBlock* start) {
   // First, reset all types to Bottom so Phi inputs from back edges don't
   // contribute to the output type of the Phi until they've been processed.
-  for (auto& pair : env->GetRegisters()) {
+  for (auto& pair : func.env.GetRegisters()) {
     pair.second->set_type(TBottom);
   }
 
@@ -564,7 +568,7 @@ void reflowTypes(Environment* env, BasicBlock* start) {
               type,
               instr,
               value->type(),
-              *start->cfg);
+              func.cfg);
         }
 
         auto dst = instr.output();
@@ -584,10 +588,6 @@ void reflowTypes(Environment* env, BasicBlock* start) {
   }
 }
 
-void reflowTypes(Function& func) {
-  reflowTypes(&func.env, func.cfg.entry_block);
-}
-
 bool removeTrampolineBlocks(CFG* cfg) {
   std::vector<BasicBlock*> trampolines;
   for (auto& block : cfg->blocks) {

cinderx/Jit/hir/pass.h

@@ -56,7 +56,7 @@ Type outputType(
 // SSAify and any optimizations that could refine the output type of an
 // instruction.
 void reflowTypes(Function& func);
-void reflowTypes(Environment* env, BasicBlock* start);
+void reflowTypes(Function& func, BasicBlock* start);
 
 // Remove any blocks that consist of a single jump to another block.
 bool removeTrampolineBlocks(CFG* cfg);

cinderx/Jit/hir/ssa.cpp

@@ -63,7 +63,7 @@ bool checkCFG(const Function& func, std::ostream& err) {
     auto block = queue.front();
     queue.pop();
 
-    if (block->cfg != &func.cfg) {
+    if (!block->cfg_node.isLinked()) {
       fmt::print(err, "ERROR: Reachable bb {} isn't part of CFG\n", block->id);
       return false;
     }
@@ -274,15 +274,15 @@ bool checkFunc(const Function& func, std::ostream& err) {
 }
 
 void SSAify::Run(Function& irfunc) {
-  Run(irfunc.cfg.entry_block, &irfunc.env);
+  Run(irfunc, irfunc.cfg.entry_block);
   PhiElimination{}.Run(irfunc);
 }
 
 // This implements the algorithm outlined in "Simple and Efficient Construction
 // of Static Single Assignment Form"
 // https://pp.info.uni-karlsruhe.de/uploads/publikationen/braun13cc.pdf
-void SSAify::Run(BasicBlock* start, Environment* env) {
-  env_ = env;
+void SSAify::Run(Function& irfunc, BasicBlock* start) {
+  env_ = &irfunc.env;
 
   auto blocks = CFG::GetRPOTraversal(start);
   auto ssa_basic_blocks = initSSABasicBlocks(blocks);
@@ -340,7 +340,7 @@ void SSAify::Run(BasicBlock* start, Environment* env) {
     delete ssablock;
   }
 
-  reflowTypes(env, start);
+  reflowTypes(irfunc, start);
 }
 
 Register* SSAify::getDefine(SSABasicBlock* ssablock, Register* reg) {

cinderx/Jit/hir/ssa.h

@@ -40,7 +40,7 @@ class SSAify : public Pass {
   SSAify() : Pass("SSAify"), env_(nullptr) {}
 
   void Run(Function& irfunc) override;
-  void Run(BasicBlock* block, Environment* env);
+  void Run(Function& irfunc, BasicBlock* block);
 
   static std::unique_ptr<SSAify> Factory() {
     return std::make_unique<SSAify>();

cinderx/RuntimeTests/hir_parser_test.cpp

@@ -63,7 +63,6 @@ TEST_F(HIRParserTest, ParsesHIR) {
   auto block = func->cfg.entry_block;
   ASSERT_NE(block, nullptr);
   ASSERT_EQ(block->id, 0);
-  ASSERT_EQ(block->cfg, &func->cfg);
 
   auto blocks_it = func->cfg.blocks.begin();
   auto blocks_end = func->cfg.blocks.end();