Replace macros with inline functions.

python · ericsnowcurrently · May 18, 2021 · May 18, 2021 · May 18, 2021 · May 18, 2021
commit d304aba2f6d6dd55363f8318118c8f8090e9b036
diff --git a/Include/internal/pycore_code.h b/Include/internal/pycore_code.h
@@ -3,7 +3,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
- 
+
 #include <stdbool.h>
 
 
@@ -87,31 +87,56 @@ PyAPI_FUNC(bool) _PyCode_HasFastlocals(PyCodeObject *, _PyFastLocalKind);
 PyAPI_FUNC(Py_ssize_t) _PyCode_CellForLocal(PyCodeObject *, Py_ssize_t);
 
 /* This does not fail.  A negative result means "no match". */
-PyAPI_FUNC(Py_ssize_t)  _PyCode_GetFastlocalOffsetId(PyCodeObject *,
-                                                     _Py_Identifier *,
-                                                     _PyFastLocalKind);
+PyAPI_FUNC(Py_ssize_t) _PyCode_GetFastlocalOffsetId(PyCodeObject *,
+                                                    _Py_Identifier *,
+                                                    _PyFastLocalKind);
 
 // This is a speed hack for use in ceval.c.
-#define _PyCode_LOCALVARS_ARRAY(co) \
-    (((PyTupleObject *)((co)->co_varnames))->ob_item)
-#define _PyCode_GET_LOCALVAR(co, offset) \
-    (PyTuple_GetItem((co)->co_varnames, offset))
-
-#define _PyCode_GET_CELLVAR(co, offset) \
-    (PyTuple_GetItem((co)->co_cellvars, offset))
-
-#define _PyCode_GET_FREEVAR(co, offset) \
-    (PyTuple_GetItem((co)->co_freevars, offset))
-
-#define _PyCode_CODE_IS_VALID(co)                                           \
-    (PyBytes_Check((co)->co_code) &&                                          \
-     PyBytes_GET_SIZE((co)->co_code) <= INT_MAX &&                            \
-     PyBytes_GET_SIZE((co)->co_code) % sizeof(_Py_CODEUNIT) == 0 &&           \
-     _Py_IS_ALIGNED(PyBytes_AS_STRING((co)->co_code), sizeof(_Py_CODEUNIT)))
-#define _PyCode_GET_INSTRUCTIONS(co) \
-    ((_Py_CODEUNIT *) PyBytes_AS_STRING((co)->co_code))
-#define _PyCode_NUM_INSTRUCTIONS(co) \
-    (PyBytes_Size((co)->co_code) / sizeof(_Py_CODEUNIT))
+static inline PyObject **
+_PyCode_LocalvarsArray(PyCodeObject *co)
+{
+    return ((PyTupleObject *)(co->co_varnames))->ob_item;
+}
+
+static inline PyObject *
+_PyCode_GetLocalvar(PyCodeObject *co, Py_ssize_t offset)
+{
+    return PyTuple_GetItem(co->co_varnames, offset);
+}
+
+static inline PyObject *
+_PyCode_GetCellvar(PyCodeObject *co, Py_ssize_t offset)
+{
+    return PyTuple_GetItem(co->co_cellvars, offset);
+}
+
+static inline PyObject *
+_PyCode_GetFreevar(PyCodeObject *co, Py_ssize_t offset)
+{
+    return PyTuple_GetItem(co->co_freevars, offset);
+}
+
+static inline bool
+_PyCode_CodeIsValid(PyCodeObject *co)
+{
+    return PyBytes_Check(co->co_code) &&
+           PyBytes_GET_SIZE(co->co_code) <= INT_MAX &&
+           PyBytes_GET_SIZE(co->co_code) % sizeof(_Py_CODEUNIT) == 0 &&
+           _Py_IS_ALIGNED(PyBytes_AS_STRING(co->co_code),
+                          sizeof(_Py_CODEUNIT));
+}
+
+static inline _Py_CODEUNIT *
+_PyCode_GetInstructions(PyCodeObject *co)
+{
+    return (_Py_CODEUNIT *)PyBytes_AS_STRING(co->co_code);
+}
+
+static inline Py_ssize_t
+_PyCode_NumInstructions(PyCodeObject *co)
+{
+    return PyBytes_Size(co->co_code) / sizeof(_Py_CODEUNIT);
+}
 
 
 #ifdef __cplusplus

@@ -167,7 +167,7 @@ top_of_stack(int64_t stack)
 static int64_t *
 mark_stacks(PyCodeObject *code_obj, int len)
 {
-    const _Py_CODEUNIT *code = _PyCode_GET_INSTRUCTIONS(code_obj);
+    const _Py_CODEUNIT *code = _PyCode_GetInstructions(code_obj);
     int64_t *stacks = PyMem_New(int64_t, len+1);
     int i, j, opcode;
 
@@ -480,7 +480,7 @@ frame_setlineno(PyFrameObject *f, PyObject* p_new_lineno, void *Py_UNUSED(ignore
 
     /* PyCode_NewWithPosOnlyArgs limits co_code to be under INT_MAX so this
      * should never overflow. */
-    int len = (int)_PyCode_NUM_INSTRUCTIONS(f->f_code);
+    int len = (int)_PyCode_NumInstructions(f->f_code);
     int *lines = marklines(f->f_code, len);
     if (lines == NULL) {
         return -1;

@@ -1648,8 +1648,8 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
     consts = co->co_consts;
     fastlocals = f->f_localsptr;
     freevars = f->f_localsptr + co->co_nlocals;
-    assert(_PyCode_CODE_IS_VALID(co));
-    first_instr = _PyCode_GET_INSTRUCTIONS(co);
+    assert(_PyCode_CodeIsValid(co));
+    first_instr = _PyCode_GetInstructions(co);
     /*
        f->f_lasti refers to the index of the last instruction,
        unless it's -1 in which case next_instr should be first_instr.
@@ -1685,7 +1685,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
             }
 #if OPCACHE_STATS
             opcache_code_objects_extra_mem +=
-                _PyCode_NUM_INSTRUCTIONS(co) +
+                _PyCode_NumInstructions(co) +
                 sizeof(_PyOpcache) * co->co_opcache_size;
             opcache_code_objects++;
 #endif
@@ -1822,7 +1822,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
             if (value == NULL) {
                 format_exc_check_arg(tstate, PyExc_UnboundLocalError,
                                      UNBOUNDLOCAL_ERROR_MSG,
-                                     _PyCode_GET_LOCALVAR(co, oparg));
+                                     _PyCode_GetLocalvar(co, oparg));
                 goto error;
             }
             Py_INCREF(value);
@@ -3050,7 +3050,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
             format_exc_check_arg(
                 tstate, PyExc_UnboundLocalError,
                 UNBOUNDLOCAL_ERROR_MSG,
-                _PyCode_GET_LOCALVAR(co, oparg)
+                _PyCode_GetLocalvar(co, oparg)
                 );
             goto error;
         }
@@ -3082,7 +3082,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
             assert(oparg >= co->co_ncellvars);
             idx = oparg - co->co_ncellvars;
             assert(idx >= 0 && idx < co->co_nfreevars);
-            name = _PyCode_GET_FREEVAR(co, idx);
+            name = _PyCode_GetFreevar(co, idx);
             if (PyDict_CheckExact(locals)) {
                 value = PyDict_GetItemWithError(locals, name);
                 if (value != NULL) {
@@ -4656,7 +4656,7 @@ missing_arguments(PyThreadState *tstate, PyCodeObject *co,
     }
     for (i = start; i < end; i++) {
         if (GETLOCAL(i) == NULL) {
-            PyObject *raw = _PyCode_GET_LOCALVAR(co, i);
+            PyObject *raw = _PyCode_GetLocalvar(co, i);
             PyObject *name = PyObject_Repr(raw);
             if (name == NULL) {
                 Py_DECREF(missing_names);
@@ -4737,7 +4737,7 @@ positional_only_passed_as_keyword(PyThreadState *tstate, PyCodeObject *co,
     PyObject* posonly_names = PyList_New(0);
 
     for(int k=0; k < co->co_posonlyargcount; k++){
-        PyObject* posonly_name = _PyCode_GET_LOCALVAR(co, k);
+        PyObject* posonly_name = _PyCode_GetLocalvar(co, k);
 
         for (int k2=0; k2<kwcount; k2++){
             /* Compare the pointers first and fallback to PyObject_RichCompareBool*/
@@ -4939,7 +4939,7 @@ initialize_locals(PyThreadState *tstate, PyFrameConstructor *con,
 
             /* Speed hack: do raw pointer compares. As names are
             normally interned this should almost always hit. */
-            co_varnames = _PyCode_LOCALVARS_ARRAY(co);
+            co_varnames = _PyCode_LocalvarsArray(co);
             for (j = co->co_posonlyargcount; j < total_args; j++) {
                 PyObject *varname = co_varnames[j];
                 if (varname == keyword) {
@@ -5037,7 +5037,7 @@ initialize_locals(PyThreadState *tstate, PyFrameConstructor *con,
         for (i = co->co_argcount; i < total_args; i++) {
             if (GETLOCAL(i) != NULL)
                 continue;
-            PyObject *varname = _PyCode_GET_LOCALVAR(co, i);
+            PyObject *varname = _PyCode_GetLocalvar(co, i);
             if (con->fc_kwdefaults != NULL) {
                 PyObject *def = PyDict_GetItemWithError(con->fc_kwdefaults, varname);
                 if (def) {
@@ -6416,13 +6416,13 @@ format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg)
     if (_PyErr_Occurred(tstate))
         return;
     if (oparg < co->co_ncellvars) {
-        name = _PyCode_GET_CELLVAR(co, oparg);
+        name = _PyCode_GetCellvar(co, oparg);
         format_exc_check_arg(tstate,
             PyExc_UnboundLocalError,
             UNBOUNDLOCAL_ERROR_MSG,
             name);
     } else {
-        name = _PyCode_GET_FREEVAR(co, oparg - co->co_ncellvars);
+        name = _PyCode_GetFreevar(co, oparg - co->co_ncellvars);
         format_exc_check_arg(tstate, PyExc_NameError,
                              UNBOUNDFREE_ERROR_MSG, name);
     }

@@ -2063,7 +2063,7 @@ compiler_make_closure(struct compiler *c, PyCodeObject *co, Py_ssize_t flags,
             /* Bypass com_addop_varname because it will generate
                LOAD_DEREF but LOAD_CLOSURE is needed.
             */
-            PyObject *name = _PyCode_GET_FREEVAR(co, i);
+            PyObject *name = _PyCode_GetFreevar(co, i);
 
             /* Special case: If a class contains a method with a
                free variable that has the same name as a method,