Separate out jit::hir::Function into its own library

Summary:
Trying to modularize Jit/hir/hir.h and keep definitions separate.  Now that BasicBlock
has no knowledge of CFG, the cycle from Instr to Function is broken.

The new dependency chart looks like: Instr <-> BasicBlock <- CFG <-> Function.

Reviewed By: DinoV, yoney

Differential Revision: D88279071

fbshipit-source-id: 640199469949bbda934ea233fd55871eefd501c4

Author: alexmalyshev

cinderx/Jit/codegen/frame_asm.h

@@ -5,6 +5,7 @@
 #include "cinderx/Jit/codegen/arch.h"
 #include "cinderx/Jit/codegen/environ.h"
 #include "cinderx/Jit/codegen/register_preserver.h"
+#include "cinderx/Jit/hir/function.h"
 #include "cinderx/Jit/hir/hir.h"
 #include "cinderx/Jit/runtime.h"
 

cinderx/Jit/compiled_function.h

@@ -56,6 +56,7 @@ bool isJitCompiled(const PyFunctionObject* func);
 #include "cinderx/Common/util.h"
 #include "cinderx/Jit/code_patcher.h"
 #include "cinderx/Jit/code_runtime.h"
+#include "cinderx/Jit/hir/function.h"
 #include "cinderx/Jit/hir/hir.h"
 
 #include <chrono>

cinderx/Jit/debug_info.cpp

@@ -2,6 +2,7 @@
 
 #include "cinderx/Jit/debug_info.h"
 
+#include "cinderx/Jit/hir/function.h"
 #include "cinderx/Jit/hir/hir.h"
 
 #include <algorithm>

cinderx/Jit/hir/analysis.cpp

@@ -3,6 +3,7 @@
 #include "cinderx/Jit/hir/analysis.h"
 
 #include "cinderx/Jit/dataflow.h"
+#include "cinderx/Jit/hir/function.h"
 #include "cinderx/Jit/hir/hir.h"
 #include "cinderx/Jit/hir/printer.h"
 #include "cinderx/StaticPython/checked_dict.h"

cinderx/Jit/hir/analysis.h

@@ -4,6 +4,7 @@
 
 #include "cinderx/Jit/bitvector.h"
 #include "cinderx/Jit/dataflow.h"
+#include "cinderx/Jit/hir/function.h"
 #include "cinderx/Jit/hir/hir.h"
 
 #include <iosfwd>
@@ -13,7 +14,6 @@
 namespace jit::hir {
 
 class BasicBlock;
-class Function;
 class Register;
 
 using RegisterSet = std::unordered_set<Register*>;

cinderx/Jit/hir/function.cpp

@@ -0,0 +1,115 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+#include "cinderx/Jit/hir/function.h"
+
+namespace jit::hir {
+
+// Be intentional about HIR structure sizes.  There's no hard limit on what
+// these sizes have to be, but we should be aware when we change them.
+//
+// Ignore it for libc++ for now though, too tricky to track multiple
+// implementations.
+#ifndef _LIBCPP_VERSION
+static_assert(sizeof(Function) == 48 * kPointerSize);
+static_assert(sizeof(CFG) == 6 * kPointerSize);
+static_assert(sizeof(BasicBlock) == 20 * kPointerSize);
+static_assert(sizeof(Instr) == 6 * kPointerSize);
+#endif
+
+Function::Function() {
+  cfg.func = this;
+}
+
+Function::~Function() {
+  // Serialize as we alter ref-counts on potentially global objects.
+  ThreadedCompileSerialize guard;
+  code.reset();
+  builtins.reset();
+  globals.reset();
+  prim_args_info.reset();
+}
+
+void Function::setCode(BorrowedRef<PyCodeObject> code_2) {
+  this->code.reset(code_2);
+  uses_runtime_func = usesRuntimeFunc(code_2);
+  frameMode = getConfig().frame_mode;
+}
+
+std::size_t Function::CountInstrs(InstrPredicate pred) const {
+  std::size_t result = 0;
+  for (const auto& block : cfg.blocks) {
+    for (const auto& instr : block) {
+      if (pred(instr)) {
+        result++;
+      }
+    }
+  }
+  return result;
+}
+
+bool Function::returnsPrimitive() const {
+  return return_type <= TPrimitive;
+}
+
+bool Function::returnsPrimitiveDouble() const {
+  return return_type <= TCDouble;
+}
+
+void Function::setCompilationPhaseTimer(
+    std::unique_ptr<CompilationPhaseTimer> cpt) {
+  compilation_phase_timer = std::move(cpt);
+}
+
+int Function::numArgs() const {
+  if (code == nullptr) {
+    // code might be null if we parsed from textual ir
+    return 0;
+  }
+  return code->co_argcount + code->co_kwonlyargcount +
+      bool(code->co_flags & CO_VARARGS) + bool(code->co_flags & CO_VARKEYWORDS);
+}
+
+Py_ssize_t Function::numVars() const {
+  // Code might be null if we parsed from textual HIR.
+  return code != nullptr ? numLocalsplus(code) : 0;
+}
+
+bool Function::canDeopt() const {
+  for (const BasicBlock& block : cfg.blocks) {
+    for (const Instr& instr : block) {
+      if (instr.asDeoptBase()) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+BorrowedRef<PyCodeObject> Function::codeFor(const Instr& instr) const {
+  if (instr.IsBeginInlinedFunction()) {
+    auto bif = static_cast<const BeginInlinedFunction*>(&instr);
+    return bif->func()->func_code;
+  }
+  if (instr.IsLoadGlobalCached()) {
+    auto load_global = static_cast<const LoadGlobalCached*>(&instr);
+    return load_global->code();
+  }
+  if (auto deopt_base = instr.asDeoptBase()) {
+    auto fs = deopt_base->frameState();
+    return fs != nullptr ? fs->code : nullptr;
+  }
+  const FrameState* fs = instr.getDominatingFrameState();
+  return fs == nullptr ? code : fs->code;
+}
+
+OpcodeCounts count_opcodes(const Function& func) {
+  OpcodeCounts counts{};
+  for (const BasicBlock& block : func.cfg.blocks) {
+    for (const Instr& instr : block) {
+      counts[static_cast<size_t>(instr.opcode())]++;
+    }
+  }
+  return counts;
+}
+
+} // namespace jit::hir

cinderx/Jit/hir/function.h

@@ -0,0 +1,117 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+#pragma once
+
+#include "cinderx/Jit/hir/hir.h"
+
+namespace jit::hir {
+
+class Function {
+ public:
+  using InlineFailureStats =
+      UnorderedMap<InlineFailureType, UnorderedSet<std::string>>;
+  Function();
+  ~Function();
+
+  ThreadedRef<PyCodeObject> code;
+  ThreadedRef<PyDictObject> builtins;
+  ThreadedRef<PyDictObject> globals;
+
+  // for primitive args only, null if there are none
+  ThreadedRef<_PyTypedArgsInfo> prim_args_info;
+
+  // Fully-qualified name of the function
+  std::string fullname;
+
+  // Does this function need its PyFunctionObject* at runtime?
+  // (This is always the case in 3.12 as it is used to quickly access the
+  // _PyInterpreterFrame)
+  bool uses_runtime_func{
+#if PY_VERSION_HEX < 0x030C0000
+      false
+#else
+      true
+#endif
+  };
+
+  // Does this function have primitive args?
+  bool has_primitive_args{false};
+
+  // is the first argument a primitive?
+  bool has_primitive_first_arg{false};
+
+  struct InlineFunctionStats {
+    int num_inlined_functions{0};
+    // map of {inline_failure_type -> function_names}
+    InlineFailureStats failure_stats;
+  } inline_function_stats;
+
+  // vector of {locals_idx, type, optional}
+  // in argument order, may have gaps for unchecked args
+  std::vector<TypedArgument> typed_args;
+
+  // Return type
+  Type return_type{TObject};
+
+  FrameMode frameMode{FrameMode::kNormal};
+
+  CFG cfg;
+
+  Environment env;
+
+  // All the code patchers pointing to patch points in this function.
+  //
+  // These will be moved over to the CompiledFunction after compilation is
+  // complete.
+  std::vector<std::unique_ptr<CodePatcher>> code_patchers;
+
+  // Optional property used to track time taken for individual compilation
+  // phases
+  std::unique_ptr<CompilationPhaseTimer> compilation_phase_timer;
+
+  // Return the total number of arguments (positional + kwonly + varargs +
+  // varkeywords)
+  int numArgs() const;
+
+  // Return the number of locals + cellvars + freevars
+  Py_ssize_t numVars() const;
+
+  // Set code and a number of other members that are derived from it.
+  void setCode(BorrowedRef<PyCodeObject> code);
+
+  // Count the number of instructions that match the predicate
+  std::size_t CountInstrs(InstrPredicate pred) const;
+
+  // Does this function return a primitive type?
+  bool returnsPrimitive() const;
+
+  // Does this function return a primitive double?
+  bool returnsPrimitiveDouble() const;
+
+  void setCompilationPhaseTimer(std::unique_ptr<CompilationPhaseTimer> cpt);
+
+  bool canDeopt() const;
+
+  template <typename T, typename... Args>
+  T* allocateCodePatcher(Args&&... args) {
+    code_patchers.emplace_back(
+        std::make_unique<T>(std::forward<Args>(args)...));
+    return static_cast<T*>(code_patchers.back().get());
+  }
+
+  // Get the code object for the given instruction.  Handles inlined functions
+  // but assumes that inlined functions have a dominating FrameState from
+  // BeginInlinedFunction to use.  If we start optimizing that out for inlined
+  // functions that cannot deopt, we will have to do something different.
+  //
+  // The instruction must be part of this function.
+  BorrowedRef<PyCodeObject> codeFor(const Instr& instr) const;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Function);
+};
+
+using OpcodeCounts = std::array<int, kNumOpcodes>;
+OpcodeCounts count_opcodes(const Function& func);
+
+} // namespace jit::hir