Minor refactors to lir::Function

Summary:
Mostly just consolidating code in the implementation file, keeping method order
the same across the .h and the .cpp, and adding comments.

Reviewed By: yoney

Differential Revision: D81698609

fbshipit-source-id: 0456fe67a22499f9f83a894168395f62cfd58628

Author: alexmalyshev

cinderx/Jit/lir/function.cpp

@@ -7,8 +7,10 @@
 
 namespace jit::lir {
 
+namespace {
+
 // Helper for copyOperand.
-static void copyIndirect(
+void copyIndirect(
     UnorderedMap<LinkedOperand*, int>& instr_refs,
     Operand* dest_op,
     MemoryIndirect* source_op) {
@@ -58,7 +60,7 @@ static void copyIndirect(
 
 // Helper for copyOperandBase.
 // Assume that type and data type are already be set.
-static void copyOperand(
+void copyOperand(
     UnorderedMap<int, BasicBlock*>& block_index_map,
     UnorderedMap<LinkedOperand*, int>& instr_refs,
     Operand* operand,
@@ -97,7 +99,7 @@ static void copyOperand(
 }
 
 // Helper for deepCopyBasicBlocks.
-static void copyInput(
+void copyInput(
     UnorderedMap<int, BasicBlock*>& block_index_map,
     UnorderedMap<LinkedOperand*, int>& instr_refs,
     OperandBase* input,
@@ -117,7 +119,7 @@ static void copyInput(
 }
 
 // Helper for deepCopyBasicBlocks.
-static void connectLinkedOperands(
+void connectLinkedOperands(
     UnorderedMap<int, Instruction*>& output_index_map_,
     UnorderedMap<LinkedOperand*, int>& instr_refs_) {
   for (auto& [operand, instr_index] : instr_refs_) {
@@ -129,7 +131,7 @@ static void connectLinkedOperands(
 // Helper used in copyFrom.
 // Expects blocks to be initialized into block_index_map_.
 // Copies the instructions and successors from src_blocks.
-static void deepCopyBasicBlocks(
+void deepCopyBasicBlocks(
     const std::vector<BasicBlock*>& src_blocks,
     UnorderedMap<int, BasicBlock*>& block_index_map_,
     const hir::Instr* origin) {
@@ -163,6 +165,16 @@ static void deepCopyBasicBlocks(
   connectLinkedOperands(output_index_map, instr_refs);
 }
 
+} // namespace
+
+int Function::allocateId() {
+  return next_id_++;
+}
+
+void Function::setNextId(int id) {
+  next_id_ = id;
+}
+
 Function::CopyResult Function::copyFrom(
     const Function* src_func,
     BasicBlock* prev_bb,
@@ -216,13 +228,25 @@ BasicBlock* Function::allocateBasicBlockAfter(BasicBlock* block) {
   return new_block;
 }
 
+const std::vector<BasicBlock*>& Function::basicblocks() const {
+  return basic_blocks_;
+}
+
+std::vector<BasicBlock*>& Function::basicblocks() {
+  return basic_blocks_;
+}
+
 BasicBlock* Function::entryBlock() const {
   if (basic_blocks_.empty()) {
     return nullptr;
   }
   return basic_blocks_.front();
 }
 
+size_t Function::getNumBasicBlocks() const {
+  return basic_blocks_.size();
+}
+
 void Function::sortBasicBlocks() {
   BasicBlockSorter sorter(basic_blocks_);
   basic_blocks_ = sorter.getSortedBlocks();

cinderx/Jit/lir/function.h

@@ -5,22 +5,24 @@
 #include "cinderx/Jit/lir/block.h"
 
 #include <deque>
-#include <memory>
 #include <vector>
 
 namespace jit::lir {
 
 class Function {
  public:
-  int allocateId() {
-    return next_id_++;
-  }
-
   struct CopyResult {
     int begin_bb;
     int end_bb;
   };
 
+  // Allocate a new ID for a basic block or an instruction.
+  int allocateId();
+
+  // Set the next ID to return from allocateId().  Only meant to be used by the
+  // LIR parser.
+  void setNextId(int id);
+
   // Deep copy function into dest_func.
   // Insert the blocks between prev_bb and next_bb.
   // Assumes that prev_bb and next_bb appear consecutively
@@ -34,25 +36,21 @@ class Function {
       BasicBlock* next_bb,
       const hir::Instr* origin);
 
+  // Create a new block and insert it as the last block in the CFG.
   BasicBlock* allocateBasicBlock();
 
+  // Create a new block and insert it in a given spot in the CFG.
   BasicBlock* allocateBasicBlockAfter(BasicBlock* block);
 
   // Returns the list of all the basic blocks.
   // The basic blocks will be in RPO as long as the CFG has not been
   // modified since the last call to SortRPO().
-  const std::vector<BasicBlock*>& basicblocks() const {
-    return basic_blocks_;
-  }
-  std::vector<BasicBlock*>& basicblocks() {
-    return basic_blocks_;
-  }
+  const std::vector<BasicBlock*>& basicblocks() const;
+  std::vector<BasicBlock*>& basicblocks();
 
   BasicBlock* entryBlock() const;
 
-  size_t getNumBasicBlocks() const {
-    return basic_blocks_.size();
-  }
+  size_t getNumBasicBlocks() const;
 
   void sortBasicBlocks();
 
@@ -80,13 +78,6 @@ class Function {
 
   // The next id to assign to a BasicBlock or Instruction.
   int next_id_{0};
-
-  // used in parser
-  void setNextId(int id) {
-    next_id_ = id;
-  }
-
-  friend class Parser;
 };
 
 } // namespace jit::lir