Remove copied opcodes now that we have better upstream support

Summary:
On yesterday imports we hit some issues with one of the opcodes we've duplicated. We duplicated it so that we could support optimized python -> python calls when we have our eval hook in place.

I landed python/cpython#143532 yesterday which makes it possible for us to just redefine the `IS_PEP523_HOOKED` macro. This macro conveniently already defined in our copy of `ceval_macros.h` so the upgrade to consume this is just deleting our overloaded opcodes and picking up the base ones.

Reviewed By: jbower-fb

Differential Revision: D90279669

fbshipit-source-id: ecc4d87981554aa5a5bf9f27519622cf17cfe2ed

Author: DinoV

cinderx/Interpreter/3.15/cinder-bytecodes.c

@@ -138,125 +138,6 @@ static PyObject* dummy_func(
 
   switch (opcode) {
     // BEGIN BYTECODES //
-
-    override inst(
-        LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN,
-        (unused / 1,
-         type_version / 2,
-         func_version / 2,
-         getattribute / 4,
-         owner-- unused)) {
-      PyObject* owner_o = PyStackRef_AsPyObjectBorrow(owner);
-
-      assert((oparg & 1) == 0);
-      DEOPT_IF(IS_PEP523_HOOKED(tstate));
-      PyTypeObject* cls = Py_TYPE(owner_o);
-      assert(type_version != 0);
-      DEOPT_IF(
-          FT_ATOMIC_LOAD_UINT_RELAXED(cls->tp_version_tag) != type_version);
-      assert(Py_IS_TYPE(getattribute, &PyFunction_Type));
-      PyFunctionObject* f = (PyFunctionObject*)getattribute;
-      assert(func_version != 0);
-      DEOPT_IF(f->func_version != func_version);
-      PyCodeObject* code = (PyCodeObject*)f->func_code;
-      assert(code->co_argcount == 2);
-      DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize));
-      STAT_INC(LOAD_ATTR, hit);
-
-      PyObject* name = GETITEM(FRAME_CO_NAMES, oparg >> 1);
-      _PyInterpreterFrame* new_frame = _PyFrame_PushUnchecked(
-          tstate, PyStackRef_FromPyObjectNew(f), 2, frame);
-      new_frame->localsplus[0] = owner;
-      DEAD(owner);
-      // Manipulate stack directly because we exit with DISPATCH_INLINED().
-      SYNC_SP();
-      new_frame->localsplus[1] = PyStackRef_FromPyObjectNew(name);
-      frame->return_offset = INSTRUCTION_SIZE;
-      DISPATCH_INLINED(new_frame);
-    }
-
-    override op(_DO_CALL, (callable, self_or_null, args[oparg]-- res)) {
-      PyObject* callable_o = PyStackRef_AsPyObjectBorrow(callable);
-
-      // oparg counts all of the args, but *not* self:
-      int total_args = oparg;
-      _PyStackRef* arguments = args;
-      if (!PyStackRef_IsNull(self_or_null)) {
-        arguments--;
-        total_args++;
-      }
-      // Check if the call can be inlined or not
-      if (Py_TYPE(callable_o) == &PyFunction_Type &&
-          !IS_PEP523_HOOKED(tstate) &&
-          ((PyFunctionObject*)callable_o)->vectorcall ==
-              _PyFunction_Vectorcall) {
-        int code_flags =
-            ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
-        PyObject* locals = code_flags & CO_OPTIMIZED
-            ? NULL
-            : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
-        _PyInterpreterFrame* new_frame = _PyEvalFramePushAndInit(
-            tstate, callable, locals, arguments, total_args, NULL, frame);
-        DEAD(args);
-        DEAD(self_or_null);
-        DEAD(callable);
-        // Manipulate stack directly since we leave using DISPATCH_INLINED().
-        SYNC_SP();
-        // The frame has stolen all the arguments from the stack,
-        // so there is no need to clean them up.
-        if (new_frame == NULL) {
-          ERROR_NO_POP();
-        }
-        frame->return_offset = INSTRUCTION_SIZE;
-        DISPATCH_INLINED(new_frame);
-      }
-      /* Callable is not a normal Python function */
-      STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
-      if (CONVERSION_FAILED(args_o)) {
-        DECREF_INPUTS();
-        ERROR_IF(true);
-      }
-      PyObject* res_o = PyObject_Vectorcall(
-          callable_o,
-          args_o,
-          total_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
-          NULL);
-      STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
-      if (opcode == INSTRUMENTED_CALL) {
-        PyObject* arg = total_args == 0
-            ? &_PyInstrumentation_MISSING
-            : PyStackRef_AsPyObjectBorrow(arguments[0]);
-        if (res_o == NULL) {
-          _Py_call_instrumentation_exc2(
-              tstate,
-              PY_MONITORING_EVENT_C_RAISE,
-              frame,
-              this_instr,
-              callable_o,
-              arg);
-        } else {
-          int err = _Py_call_instrumentation_2args(
-              tstate,
-              PY_MONITORING_EVENT_C_RETURN,
-              frame,
-              this_instr,
-              callable_o,
-              arg);
-          if (err < 0) {
-            Py_CLEAR(res_o);
-          }
-        }
-      }
-      assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
-      DECREF_INPUTS();
-      ERROR_IF(res_o == NULL);
-      res = PyStackRef_FromPyObjectSteal(res_o);
-    }
-
-    override op(_CHECK_PEP_523, (--)) {
-      DEOPT_IF(IS_PEP523_HOOKED(tstate));
-    }
-
     override op(_PUSH_FRAME, (new_frame--)) {
       // Write it out explicitly because it's subtly different.
       // Eventually this should be the only occurrence of this code.
@@ -277,231 +158,6 @@ static PyObject* dummy_func(
       LLTRACE_RESUME_FRAME();
     }
 
-    override op(
-        _DO_CALL_KW, (callable, self_or_null, args[oparg], kwnames-- res)) {
-      PyObject* callable_o = PyStackRef_AsPyObjectBorrow(callable);
-      PyObject* kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);
-
-      // oparg counts all of the args, but *not* self:
-      int total_args = oparg;
-      _PyStackRef* arguments = args;
-      if (!PyStackRef_IsNull(self_or_null)) {
-        arguments--;
-        total_args++;
-      }
-      int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);
-      // Check if the call can be inlined or not
-      if (Py_TYPE(callable_o) == &PyFunction_Type &&
-          !IS_PEP523_HOOKED(tstate) &&
-          ((PyFunctionObject*)callable_o)->vectorcall ==
-              _PyFunction_Vectorcall) {
-        int code_flags =
-            ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
-        PyObject* locals = code_flags & CO_OPTIMIZED
-            ? NULL
-            : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
-        _PyInterpreterFrame* new_frame = _PyEvalFramePushAndInit(
-            tstate,
-            callable,
-            locals,
-            arguments,
-            positional_args,
-            kwnames_o,
-            frame);
-        DEAD(args);
-        DEAD(self_or_null);
-        DEAD(callable);
-        PyStackRef_CLOSE(kwnames);
-        // Sync stack explicitly since we leave using DISPATCH_INLINED().
-        SYNC_SP();
-        // The frame has stolen all the arguments from the stack,
-        // so there is no need to clean them up.
-        if (new_frame == NULL) {
-          ERROR_NO_POP();
-        }
-        assert(INSTRUCTION_SIZE == 1 + INLINE_CACHE_ENTRIES_CALL_KW);
-        frame->return_offset = INSTRUCTION_SIZE;
-        DISPATCH_INLINED(new_frame);
-      }
-      /* Callable is not a normal Python function */
-      STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
-      if (CONVERSION_FAILED(args_o)) {
-        DECREF_INPUTS();
-        ERROR_IF(true);
-      }
-      PyObject* res_o = PyObject_Vectorcall(
-          callable_o,
-          args_o,
-          positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
-          kwnames_o);
-      STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
-      if (opcode == INSTRUMENTED_CALL_KW) {
-        PyObject* arg = total_args == 0
-            ? &_PyInstrumentation_MISSING
-            : PyStackRef_AsPyObjectBorrow(arguments[0]);
-        if (res_o == NULL) {
-          _Py_call_instrumentation_exc2(
-              tstate,
-              PY_MONITORING_EVENT_C_RAISE,
-              frame,
-              this_instr,
-              callable_o,
-              arg);
-        } else {
-          int err = _Py_call_instrumentation_2args(
-              tstate,
-              PY_MONITORING_EVENT_C_RETURN,
-              frame,
-              this_instr,
-              callable_o,
-              arg);
-          if (err < 0) {
-            Py_CLEAR(res_o);
-          }
-        }
-      }
-      DECREF_INPUTS();
-      ERROR_IF(res_o == NULL);
-      res = PyStackRef_FromPyObjectSteal(res_o);
-    }
-
-    override op(
-        _DO_CALL_FUNCTION_EX,
-        (func_st, null, callargs_st, kwargs_st-- result)) {
-      (void)null;
-      PyObject* func = PyStackRef_AsPyObjectBorrow(func_st);
-
-      // DICT_MERGE is called before this opcode if there are kwargs.
-      // It converts all dict subtypes in kwargs into regular dicts.
-      EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func);
-      PyObject* result_o;
-      assert(!_PyErr_Occurred(tstate));
-      if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) {
-        PyObject* callargs = PyStackRef_AsPyObjectBorrow(callargs_st);
-        PyObject* kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st);
-        assert(kwargs == NULL || PyDict_CheckExact(kwargs));
-        assert(PyTuple_CheckExact(callargs));
-        PyObject* arg = PyTuple_GET_SIZE(callargs) > 0
-            ? PyTuple_GET_ITEM(callargs, 0)
-            : &_PyInstrumentation_MISSING;
-        int err = _Py_call_instrumentation_2args(
-            tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, func, arg);
-        if (err) {
-          ERROR_NO_POP();
-        }
-        result_o = PyObject_Call(func, callargs, kwargs);
-
-        if (!PyFunction_Check(func) && !PyMethod_Check(func)) {
-          if (result_o == NULL) {
-            _Py_call_instrumentation_exc2(
-                tstate,
-                PY_MONITORING_EVENT_C_RAISE,
-                frame,
-                this_instr,
-                func,
-                arg);
-          } else {
-            int err = _Py_call_instrumentation_2args(
-                tstate,
-                PY_MONITORING_EVENT_C_RETURN,
-                frame,
-                this_instr,
-                func,
-                arg);
-            if (err < 0) {
-              Py_CLEAR(result_o);
-            }
-          }
-        }
-      } else {
-        if (Py_TYPE(func) == &PyFunction_Type && !IS_PEP523_HOOKED(tstate) &&
-            ((PyFunctionObject*)func)->vectorcall == _PyFunction_Vectorcall) {
-          PyObject* callargs = PyStackRef_AsPyObjectSteal(callargs_st);
-          assert(PyTuple_CheckExact(callargs));
-          PyObject* kwargs = PyStackRef_IsNull(kwargs_st)
-              ? NULL
-              : PyStackRef_AsPyObjectSteal(kwargs_st);
-          assert(kwargs == NULL || PyDict_CheckExact(kwargs));
-          Py_ssize_t nargs = PyTuple_GET_SIZE(callargs);
-          int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(func))->co_flags;
-          PyObject* locals = code_flags & CO_OPTIMIZED
-              ? NULL
-              : Py_NewRef(PyFunction_GET_GLOBALS(func));
-
-          _PyInterpreterFrame* new_frame = _PyEvalFramePushAndInit_Ex(
-              tstate, func_st, locals, nargs, callargs, kwargs, frame);
-          // Need to sync the stack since we exit with DISPATCH_INLINED.
-          INPUTS_DEAD();
-          SYNC_SP();
-          if (new_frame == NULL) {
-            ERROR_NO_POP();
-          }
-          assert(INSTRUCTION_SIZE == 1 + INLINE_CACHE_ENTRIES_CALL_FUNCTION_EX);
-          frame->return_offset = INSTRUCTION_SIZE;
-          DISPATCH_INLINED(new_frame);
-        }
-        PyObject* callargs = PyStackRef_AsPyObjectBorrow(callargs_st);
-        assert(PyTuple_CheckExact(callargs));
-        PyObject* kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st);
-        assert(kwargs == NULL || PyDict_CheckExact(kwargs));
-        result_o = PyObject_Call(func, callargs, kwargs);
-      }
-      PyStackRef_XCLOSE(kwargs_st);
-      PyStackRef_CLOSE(callargs_st);
-      DEAD(null);
-      PyStackRef_CLOSE(func_st);
-      ERROR_IF(result_o == NULL);
-      result = PyStackRef_FromPyObjectSteal(result_o);
-    }
-
-    override op(_SEND, (receiver, v-- receiver, retval)) {
-      PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver);
-      PyObject *retval_o;
-      assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
-      if (!IS_PEP523_HOOKED(tstate) &&
-          (Py_TYPE(receiver_o) == &PyGen_Type || Py_TYPE(receiver_o) == &PyCoro_Type) &&
-          gen_try_set_executing((PyGenObject *)receiver_o))
-      {
-          PyGenObject *gen = (PyGenObject *)receiver_o;
-          _PyInterpreterFrame *gen_frame = &gen->gi_iframe;
-          _PyFrame_StackPush(gen_frame, PyStackRef_MakeHeapSafe(v));
-          DEAD(v);
-          SYNC_SP();
-          gen->gi_exc_state.previous_item = tstate->exc_info;
-          tstate->exc_info = &gen->gi_exc_state;
-          assert(INSTRUCTION_SIZE + oparg <= UINT16_MAX);
-          frame->return_offset = (uint16_t)(INSTRUCTION_SIZE + oparg);
-          assert(gen_frame->previous == NULL);
-          gen_frame->previous = frame;
-          DISPATCH_INLINED(gen_frame);
-      }
-      if (PyStackRef_IsNone(v) && PyIter_Check(receiver_o)) {
-          retval_o = Py_TYPE(receiver_o)->tp_iternext(receiver_o);
-      }
-      else {
-          retval_o = PyObject_CallMethodOneArg(receiver_o,
-                                                &_Py_ID(send),
-                                                PyStackRef_AsPyObjectBorrow(v));
-      }
-      if (retval_o == NULL) {
-          int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration);
-          if (matches) {
-              _PyEval_MonitorRaise(tstate, frame, this_instr);
-          }
-          int err = _PyGen_FetchStopIterationValue(&retval_o);
-          if (err == 0) {
-              assert(retval_o != NULL);
-              JUMPBY(oparg);
-          }
-          else {
-              PyStackRef_CLOSE(v);
-              ERROR_IF(true);
-          }
-      }
-      PyStackRef_CLOSE(v);
-      retval = PyStackRef_FromPyObjectSteal(retval_o);
-    }
-
     override inst(GET_ANEXT, (aiter-- aiter, awaitable)) {
       // CX: Use modified version of _PyEval_GetANext to handle JIT generators
       PyObject* awaitable_o =