pythongh-114569: Use PyMem_* APIs for most non-PyObject uses (python#114574)

erlend-aasland · Glyphack · commit 16a89a3f60c8 · 2024-01-27T10:36:35.000+01:00
Fix usage in Modules, Objects, and Parser subdirectories.
diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
@@ -267,7 +267,7 @@ typedef struct {
 LOCAL(int)
 create_extra(ElementObject* self, PyObject* attrib)
 {
-    self->extra = PyObject_Malloc(sizeof(ElementObjectExtra));
+    self->extra = PyMem_Malloc(sizeof(ElementObjectExtra));
     if (!self->extra) {
         PyErr_NoMemory();
         return -1;
@@ -295,10 +295,11 @@ dealloc_extra(ElementObjectExtra *extra)
     for (i = 0; i < extra->length; i++)
         Py_DECREF(extra->children[i]);
 
-    if (extra->children != extra->_children)
-        PyObject_Free(extra->children);
+    if (extra->children != extra->_children) {
+        PyMem_Free(extra->children);
+    }
 
-    PyObject_Free(extra);
+    PyMem_Free(extra);
 }
 
 LOCAL(void)
@@ -495,14 +496,16 @@ element_resize(ElementObject* self, Py_ssize_t extra)
              * "children", which needs at least 4 bytes. Although it's a
              * false alarm always assume at least one child to be safe.
              */
-            children = PyObject_Realloc(self->extra->children,
-                                        size * sizeof(PyObject*));
-            if (!children)
+            children = PyMem_Realloc(self->extra->children,
+                                     size * sizeof(PyObject*));
+            if (!children) {
                 goto nomemory;
+            }
         } else {
-            children = PyObject_Malloc(size * sizeof(PyObject*));
-            if (!children)
+            children = PyMem_Malloc(size * sizeof(PyObject*));
+            if (!children) {
                 goto nomemory;
+            }
             /* copy existing children from static area to malloc buffer */
             memcpy(children, self->extra->children,
                    self->extra->length * sizeof(PyObject*));
@@ -3044,7 +3047,7 @@ _elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag,
 #define EXPAT(st, func) ((st)->expat_capi->func)
 
 static XML_Memory_Handling_Suite ExpatMemoryHandler = {
-    PyObject_Malloc, PyObject_Realloc, PyObject_Free};
+    PyMem_Malloc, PyMem_Realloc, PyMem_Free};
 
 typedef struct {
     PyObject_HEAD
diff --git a/Modules/_sre/sre_lib.h b/Modules/_sre/sre_lib.h
@@ -1122,7 +1122,7 @@ SRE(match)(SRE_STATE* state, const SRE_CODE* pattern, int toplevel)
             /* install new repeat context */
             /* TODO(https://github.com/python/cpython/issues/67877): Fix this
              * potential memory leak. */
-            ctx->u.rep = (SRE_REPEAT*) PyObject_Malloc(sizeof(*ctx->u.rep));
+            ctx->u.rep = (SRE_REPEAT*) PyMem_Malloc(sizeof(*ctx->u.rep));
             if (!ctx->u.rep) {
                 PyErr_NoMemory();
                 RETURN_FAILURE;
@@ -1136,7 +1136,7 @@ SRE(match)(SRE_STATE* state, const SRE_CODE* pattern, int toplevel)
             state->ptr = ptr;
             DO_JUMP(JUMP_REPEAT, jump_repeat, pattern+pattern[0]);
             state->repeat = ctx->u.rep->prev;
-            PyObject_Free(ctx->u.rep);
+            PyMem_Free(ctx->u.rep);
 
             if (ret) {
                 RETURN_ON_ERROR(ret);
diff --git a/Modules/mathmodule.c b/Modules/mathmodule.c
@@ -2570,7 +2570,7 @@ math_dist_impl(PyObject *module, PyObject *p, PyObject *q)
         goto error_exit;
     }
     if (n > NUM_STACK_ELEMS) {
-        diffs = (double *) PyObject_Malloc(n * sizeof(double));
+        diffs = (double *) PyMem_Malloc(n * sizeof(double));
         if (diffs == NULL) {
             PyErr_NoMemory();
             goto error_exit;
@@ -2590,7 +2590,7 @@ math_dist_impl(PyObject *module, PyObject *p, PyObject *q)
     }
     result = vector_norm(n, diffs, max, found_nan);
     if (diffs != diffs_on_stack) {
-        PyObject_Free(diffs);
+        PyMem_Free(diffs);
     }
     if (p_allocated) {
         Py_DECREF(p);
@@ -2602,7 +2602,7 @@ math_dist_impl(PyObject *module, PyObject *p, PyObject *q)
 
   error_exit:
     if (diffs != diffs_on_stack) {
-        PyObject_Free(diffs);
+        PyMem_Free(diffs);
     }
     if (p_allocated) {
         Py_DECREF(p);
@@ -2626,7 +2626,7 @@ math_hypot(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
     double *coordinates = coord_on_stack;
 
     if (nargs > NUM_STACK_ELEMS) {
-        coordinates = (double *) PyObject_Malloc(nargs * sizeof(double));
+        coordinates = (double *) PyMem_Malloc(nargs * sizeof(double));
         if (coordinates == NULL) {
             return PyErr_NoMemory();
         }
@@ -2643,13 +2643,13 @@ math_hypot(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
     }
     result = vector_norm(nargs, coordinates, max, found_nan);
     if (coordinates != coord_on_stack) {
-        PyObject_Free(coordinates);
+        PyMem_Free(coordinates);
     }
     return PyFloat_FromDouble(result);
 
   error_exit:
     if (coordinates != coord_on_stack) {
-        PyObject_Free(coordinates);
+        PyMem_Free(coordinates);
     }
     return NULL;
 }
diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c
@@ -21,7 +21,7 @@ module pyexpat
 #define XML_COMBINED_VERSION (10000*XML_MAJOR_VERSION+100*XML_MINOR_VERSION+XML_MICRO_VERSION)
 
 static XML_Memory_Handling_Suite ExpatMemoryHandler = {
-    PyObject_Malloc, PyObject_Realloc, PyObject_Free};
+    PyMem_Malloc, PyMem_Realloc, PyMem_Free};
 
 enum HandlerTypes {
     StartElement,
diff --git a/Objects/bytearrayobject.c b/Objects/bytearrayobject.c
@@ -132,7 +132,7 @@ PyByteArray_FromStringAndSize(const char *bytes, Py_ssize_t size)
     }
     else {
         alloc = size + 1;
-        new->ob_bytes = PyObject_Malloc(alloc);
+        new->ob_bytes = PyMem_Malloc(alloc);
         if (new->ob_bytes == NULL) {
             Py_DECREF(new);
             return PyErr_NoMemory();
@@ -221,17 +221,17 @@ PyByteArray_Resize(PyObject *self, Py_ssize_t requested_size)
     }
 
     if (logical_offset > 0) {
-        sval = PyObject_Malloc(alloc);
+        sval = PyMem_Malloc(alloc);
         if (sval == NULL) {
             PyErr_NoMemory();
             return -1;
         }
         memcpy(sval, PyByteArray_AS_STRING(self),
                Py_MIN((size_t)requested_size, (size_t)Py_SIZE(self)));
-        PyObject_Free(obj->ob_bytes);
+        PyMem_Free(obj->ob_bytes);
     }
     else {
-        sval = PyObject_Realloc(obj->ob_bytes, alloc);
+        sval = PyMem_Realloc(obj->ob_bytes, alloc);
         if (sval == NULL) {
             PyErr_NoMemory();
             return -1;
@@ -951,7 +951,7 @@ bytearray_repr(PyByteArrayObject *self)
     }
 
     newsize += 6 + length * 4;
-    buffer = PyObject_Malloc(newsize);
+    buffer = PyMem_Malloc(newsize);
     if (buffer == NULL) {
         PyErr_NoMemory();
         return NULL;
@@ -1008,7 +1008,7 @@ bytearray_repr(PyByteArrayObject *self)
     }
 
     v = PyUnicode_FromStringAndSize(buffer, p - buffer);
-    PyObject_Free(buffer);
+    PyMem_Free(buffer);
     return v;
 }
 
@@ -1088,7 +1088,7 @@ bytearray_dealloc(PyByteArrayObject *self)
         PyErr_Print();
     }
     if (self->ob_bytes != 0) {
-        PyObject_Free(self->ob_bytes);
+        PyMem_Free(self->ob_bytes);
     }
     Py_TYPE(self)->tp_free((PyObject *)self);
 }
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
@@ -3493,7 +3493,7 @@ type_new_set_doc(PyTypeObject *type)
 
     // Silently truncate the docstring if it contains a null byte
     Py_ssize_t size = strlen(doc_str) + 1;
-    char *tp_doc = (char *)PyObject_Malloc(size);
+    char *tp_doc = (char *)PyMem_Malloc(size);
     if (tp_doc == NULL) {
         PyErr_NoMemory();
         return -1;
@@ -4166,12 +4166,12 @@ _PyType_FromMetaclass_impl(
                 goto finally;
             }
             if (slot->pfunc == NULL) {
-                PyObject_Free(tp_doc);
+                PyMem_Free(tp_doc);
                 tp_doc = NULL;
             }
             else {
                 size_t len = strlen(slot->pfunc)+1;
-                tp_doc = PyObject_Malloc(len);
+                tp_doc = PyMem_Malloc(len);
                 if (tp_doc == NULL) {
                     PyErr_NoMemory();
                     goto finally;
@@ -4501,7 +4501,7 @@ _PyType_FromMetaclass_impl(
         Py_CLEAR(res);
     }
     Py_XDECREF(bases);
-    PyObject_Free(tp_doc);
+    PyMem_Free(tp_doc);
     Py_XDECREF(ht_name);
     PyMem_Free(_ht_tpname);
     return (PyObject*)res;
@@ -5099,7 +5099,7 @@ type_dealloc(PyObject *self)
     /* A type's tp_doc is heap allocated, unlike the tp_doc slots
      * of most other objects.  It's okay to cast it to char *.
      */
-    PyObject_Free((char *)type->tp_doc);
+    PyMem_Free((char *)type->tp_doc);
 
     PyHeapTypeObject *et = (PyHeapTypeObject *)type;
     Py_XDECREF(et->ht_name);
diff --git a/Parser/lexer/lexer.c b/Parser/lexer/lexer.c
@@ -129,7 +129,7 @@ set_fstring_expr(struct tok_state* tok, struct token *token, char c) {
 
     if (hash_detected) {
         Py_ssize_t input_length = tok_mode->last_expr_size - tok_mode->last_expr_end;
-        char *result = (char *)PyObject_Malloc((input_length + 1) * sizeof(char));
+        char *result = (char *)PyMem_Malloc((input_length + 1) * sizeof(char));
         if (!result) {
             return -1;
         }
@@ -154,7 +154,7 @@ set_fstring_expr(struct tok_state* tok, struct token *token, char c) {
 
         result[j] = '\0';  // Null-terminate the result string
         res = PyUnicode_DecodeUTF8(result, j, NULL);
-        PyObject_Free(result);
+        PyMem_Free(result);
     } else {
         res = PyUnicode_DecodeUTF8(
             tok_mode->last_expr_buffer,

Original file line number	Diff line number	Diff line change
`@@ -2570,7 +2570,7 @@ math_dist_impl(PyObject module, PyObject p, PyObject *q)`
`2570`	`2570`	`goto error_exit;`
`2571`	`2571`	`}`
`2572`	`2572`	`if (n > NUM_STACK_ELEMS) {`
`2573`		`- diffs = (double ) PyObject_Malloc(n sizeof(double));`
	`2573`	`+ diffs = (double ) PyMem_Malloc(n sizeof(double));`
`2574`	`2574`	`if (diffs == NULL) {`
`2575`	`2575`	`PyErr_NoMemory();`
`2576`	`2576`	`goto error_exit;`
`@@ -2590,7 +2590,7 @@ math_dist_impl(PyObject module, PyObject p, PyObject *q)`
`2590`	`2590`	`}`
`2591`	`2591`	`result = vector_norm(n, diffs, max, found_nan);`
`2592`	`2592`	`if (diffs != diffs_on_stack) {`
`2593`		`- PyObject_Free(diffs);`
	`2593`	`+ PyMem_Free(diffs);`
`2594`	`2594`	`}`
`2595`	`2595`	`if (p_allocated) {`
`2596`	`2596`	`Py_DECREF(p);`
`@@ -2602,7 +2602,7 @@ math_dist_impl(PyObject module, PyObject p, PyObject *q)`
`2602`	`2602`
`2603`	`2603`	`error_exit:`
`2604`	`2604`	`if (diffs != diffs_on_stack) {`
`2605`		`- PyObject_Free(diffs);`
	`2605`	`+ PyMem_Free(diffs);`
`2606`	`2606`	`}`
`2607`	`2607`	`if (p_allocated) {`
`2608`	`2608`	`Py_DECREF(p);`
`@@ -2626,7 +2626,7 @@ math_hypot(PyObject self, PyObject const *args, Py_ssize_t nargs)`
`2626`	`2626`	`double *coordinates = coord_on_stack;`
`2627`	`2627`
`2628`	`2628`	`if (nargs > NUM_STACK_ELEMS) {`
`2629`		`- coordinates = (double ) PyObject_Malloc(nargs sizeof(double));`
	`2629`	`+ coordinates = (double ) PyMem_Malloc(nargs sizeof(double));`
`2630`	`2630`	`if (coordinates == NULL) {`
`2631`	`2631`	`return PyErr_NoMemory();`
`2632`	`2632`	`}`
`@@ -2643,13 +2643,13 @@ math_hypot(PyObject self, PyObject const *args, Py_ssize_t nargs)`
`2643`	`2643`	`}`
`2644`	`2644`	`result = vector_norm(nargs, coordinates, max, found_nan);`
`2645`	`2645`	`if (coordinates != coord_on_stack) {`
`2646`		`- PyObject_Free(coordinates);`
	`2646`	`+ PyMem_Free(coordinates);`
`2647`	`2647`	`}`
`2648`	`2648`	`return PyFloat_FromDouble(result);`
`2649`	`2649`
`2650`	`2650`	`error_exit:`
`2651`	`2651`	`if (coordinates != coord_on_stack) {`
`2652`		`- PyObject_Free(coordinates);`
	`2652`	`+ PyMem_Free(coordinates);`
`2653`	`2653`	`}`
`2654`	`2654`	`return NULL;`
`2655`	`2655`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ PyByteArray_FromStringAndSize(const char *bytes, Py_ssize_t size)`
`132`	`132`	`}`
`133`	`133`	`else {`
`134`	`134`	`alloc = size + 1;`
`135`		`- new->ob_bytes = PyObject_Malloc(alloc);`
	`135`	`+ new->ob_bytes = PyMem_Malloc(alloc);`
`136`	`136`	`if (new->ob_bytes == NULL) {`
`137`	`137`	`Py_DECREF(new);`
`138`	`138`	`return PyErr_NoMemory();`
`@@ -221,17 +221,17 @@ PyByteArray_Resize(PyObject *self, Py_ssize_t requested_size)`
`221`	`221`	`}`
`222`	`222`
`223`	`223`	`if (logical_offset > 0) {`
`224`		`- sval = PyObject_Malloc(alloc);`
	`224`	`+ sval = PyMem_Malloc(alloc);`
`225`	`225`	`if (sval == NULL) {`
`226`	`226`	`PyErr_NoMemory();`
`227`	`227`	`return -1;`
`228`	`228`	`}`
`229`	`229`	`memcpy(sval, PyByteArray_AS_STRING(self),`
`230`	`230`	`Py_MIN((size_t)requested_size, (size_t)Py_SIZE(self)));`
`231`		`- PyObject_Free(obj->ob_bytes);`
	`231`	`+ PyMem_Free(obj->ob_bytes);`
`232`	`232`	`}`
`233`	`233`	`else {`
`234`		`- sval = PyObject_Realloc(obj->ob_bytes, alloc);`
	`234`	`+ sval = PyMem_Realloc(obj->ob_bytes, alloc);`
`235`	`235`	`if (sval == NULL) {`
`236`	`236`	`PyErr_NoMemory();`
`237`	`237`	`return -1;`
`@@ -951,7 +951,7 @@ bytearray_repr(PyByteArrayObject *self)`
`951`	`951`	`}`
`952`	`952`
`953`	`953`	`newsize += 6 + length * 4;`
`954`		`- buffer = PyObject_Malloc(newsize);`
	`954`	`+ buffer = PyMem_Malloc(newsize);`
`955`	`955`	`if (buffer == NULL) {`
`956`	`956`	`PyErr_NoMemory();`
`957`	`957`	`return NULL;`
`@@ -1008,7 +1008,7 @@ bytearray_repr(PyByteArrayObject *self)`
`1008`	`1008`	`}`
`1009`	`1009`
`1010`	`1010`	`v = PyUnicode_FromStringAndSize(buffer, p - buffer);`
`1011`		`- PyObject_Free(buffer);`
	`1011`	`+ PyMem_Free(buffer);`
`1012`	`1012`	`return v;`
`1013`	`1013`	`}`
`1014`	`1014`
`@@ -1088,7 +1088,7 @@ bytearray_dealloc(PyByteArrayObject *self)`
`1088`	`1088`	`PyErr_Print();`
`1089`	`1089`	`}`
`1090`	`1090`	`if (self->ob_bytes != 0) {`
`1091`		`- PyObject_Free(self->ob_bytes);`
	`1091`	`+ PyMem_Free(self->ob_bytes);`
`1092`	`1092`	`}`
`1093`	`1093`	`Py_TYPE(self)->tp_free((PyObject *)self);`
`1094`	`1094`	`}`