Don't store static entry, calculcate it

Summary: Storing this isn't really necessary, we can easily re-calculate it.

Reviewed By: SonicField

Differential Revision: D91923886

fbshipit-source-id: 98ed9b8f54d1016e8e3e41ca30beab61048e44bd

Author: DinoV

cinderx/Jit/compiled_function.cpp

@@ -2,6 +2,7 @@
 
 #include "cinderx/Jit/compiled_function.h"
 
+#include "cinderx/Common/extra-py-flags.h"
 #include "cinderx/Common/log.h"
 #include "cinderx/Jit/disassembler.h"
 #include "cinderx/Jit/hir/printer.h"
@@ -67,4 +68,13 @@ void CompiledFunction::setHirFunc(std::unique_ptr<hir::Function>&& irfunc) {
   irfunc_ = std::move(irfunc);
 }
 
+void* CompiledFunction::staticEntry() const {
+  if (runtime_ == nullptr ||
+      !(runtime_->frameState()->code()->co_flags & CI_CO_STATICALLY_COMPILED)) {
+    return nullptr;
+  }
+
+  return reinterpret_cast<void*>(JITRT_GET_STATIC_ENTRY(vectorcall_entry_));
+}
+
 } // namespace jit

cinderx/Jit/compiled_function.h

@@ -86,15 +86,13 @@ class CompiledFunction {
   CompiledFunction(
       std::span<const std::byte> code,
       vectorcallfunc vectorcall_entry,
-      void* static_entry,
       int stack_size,
       int spill_stack_size,
       hir::Function::InlineFunctionStats inline_function_stats,
       const hir::OpcodeCounts& hir_opcode_counts,
       CodeRuntime* runtime)
       : code_(code),
         vectorcall_entry_(vectorcall_entry),
-        static_entry_(static_entry),
         stack_size_(stack_size),
         spill_stack_size_(spill_stack_size),
         inline_function_stats_(std::move(inline_function_stats)),
@@ -113,9 +111,7 @@ class CompiledFunction {
     return vectorcall_entry_;
   }
 
-  void* staticEntry() const {
-    return static_entry_;
-  }
+  void* staticEntry() const;
 
   CodeRuntime* runtime() const {
     return runtime_;
@@ -161,7 +157,6 @@ class CompiledFunction {
 
   const std::span<const std::byte> code_;
   vectorcallfunc const vectorcall_entry_;
-  void* const static_entry_;
   const int stack_size_;
   const int spill_stack_size_;
   std::chrono::nanoseconds compile_time_;

cinderx/Jit/compiler.cpp

@@ -249,13 +249,11 @@ std::unique_ptr<CompiledFunction> Compiler::Compile(
   hir::Function::InlineFunctionStats inline_stats =
       std::move(irfunc->inline_function_stats);
   std::span<const std::byte> code = ngen->getCodeBuffer();
-  void* static_entry = ngen->getStaticEntry();
   auto code_runtime = ngen->codeRuntime();
 
   auto compiled_func = std::make_unique<CompiledFunction>(
       code,
       entry,
-      static_entry,
       stack_size,
       spill_stack_size,
       std::move(inline_stats),

cinderx/RuntimeTests/deopt_patcher_test.cpp

@@ -23,7 +23,6 @@ class CodePatcherTest : public RuntimeTest {
     return std::make_unique<jit::CompiledFunction>(
         code,
         reinterpret_cast<vectorcallfunc>(entry),
-        ngen.getStaticEntry(),
         stack_size,
         spill_stack_size,
         jit::hir::Function::InlineFunctionStats{},