Load eval breaker directly from runtime

Summary: In 3.12 we can load the eval breaker directly from the single runtime. We need to be able to get to the interpreter we're compiling against including in multi-threaded eval so there's a little bit of plumbing. And then we just avoid one extra load.

Reviewed By: martindemello

Differential Revision: D78311891

fbshipit-source-id: bc1ccfafd7430da06a85701b7eec9204ef72ab19

Author: DinoV

Jit/lir/generator.cpp

@@ -2603,8 +2603,8 @@ LIRGenerator::TranslatedBlock LIRGenerator::TranslateOneBasicBlock(
         // std::memory_order_relaxed. It's correct on x86-64 but probably isn't
         // on other architectures.
         hir::Register* dest = i.output();
-        Instruction* tstate = env_->asm_tstate;
 #if PY_VERSION_HEX >= 0x030D0000
+        Instruction* tstate = env_->asm_tstate;
         // tstate->ceval.eval_breaker
         static_assert(
             sizeof(reinterpret_cast<PyThreadState*>(0)->eval_breaker) == 8,
@@ -2613,7 +2613,20 @@ LIRGenerator::TranslatedBlock LIRGenerator::TranslateOneBasicBlock(
             dest,
             Instruction::kMove,
             Ind{tstate, offsetof(PyThreadState, eval_breaker)});
+#elif PY_VERSION_HEX >= 0x030C0000
+        // eval_breaker is in the runtime, which the code is generated against,
+        // load it directly.
+        static_assert(
+            sizeof(reinterpret_cast<PyThreadState*>(0)
+                       ->interp->ceval.eval_breaker) == 4,
+            "Eval breaker is not a 4 byte value");
+        bbb.appendInstr(
+            dest,
+            Instruction::kMove,
+            MemImm{reinterpret_cast<int*>(
+                &ThreadedCompileContext::interpreter()->ceval.eval_breaker)});
 #else
+        Instruction* tstate = env_->asm_tstate;
         // tstate->interp->ceval.eval_breaker
         static_assert(
             sizeof(reinterpret_cast<PyThreadState*>(0)

Jit/threaded_compile.h

@@ -21,6 +21,10 @@ namespace jit {
     }                                                   \
   }
 
+class ThreadedCompileContext;
+// Get a reference to the global ThreadedCompileContext.
+ThreadedCompileContext& getThreadedCompileContext();
+
 // Threaded-compile state for the whole process.
 class ThreadedCompileContext {
  public:
@@ -76,8 +80,11 @@ class ThreadedCompileContext {
     return !compileRunning() || holder() == std::this_thread::get_id();
   }
 
-  PyInterpreterState* interpreter() const {
-    return interpreter_;
+  static PyInterpreterState* interpreter() {
+    if (getThreadedCompileContext().compileRunning()) {
+      return getThreadedCompileContext().interpreter_;
+    }
+    return PyInterpreterState_Get();
   }
 
  private:
@@ -161,9 +168,6 @@ class ThreadedCompileContext {
   PyInterpreterState* interpreter_;
 };
 
-// Get a reference to the global ThreadedCompileContext.
-ThreadedCompileContext& getThreadedCompileContext();
-
 // RAII device for acquiring the global threaded-compile lock.
 class ThreadedCompileSerialize {
  public:
@@ -286,7 +290,7 @@ class ThreadedRef : public RefBase<T> {
 
   static void incref(PyObject* obj) {
     if (obj != nullptr && !_Py_IsImmortal(obj)) {
-      incref_total(interpreter());
+      incref_total(ThreadedCompileContext::interpreter());
       obj->ob_refcnt++;
     }
   }
@@ -300,20 +304,13 @@ class ThreadedRef : public RefBase<T> {
 
   static void decref(PyObject* obj) {
     if (obj != nullptr && !_Py_IsImmortal(obj)) {
-      decref_total(interpreter());
+      decref_total(ThreadedCompileContext::interpreter());
       if (--obj->ob_refcnt == 0) {
         _Py_Dealloc((PyObject*)obj);
       }
     }
   }
 
-  static PyInterpreterState* interpreter() {
-    if (jit::getThreadedCompileContext().compileRunning()) {
-      return jit::getThreadedCompileContext().interpreter();
-    }
-    return PyInterpreterState_Get();
-  }
-
   using RefBase<T>::ptr_;
 };