@@ -516,9 +516,9 @@ typedef struct {

} PyMemoEntry;

typedef struct {

Py_ssize_t mt_mask;

Py_ssize_t mt_used;

Py_ssize_t mt_allocated;

size_t mt_mask;

size_t mt_used;

size_t mt_allocated;

PyMemoEntry *mt_table;

} PyMemoTable;

@@ -562,8 +562,8 @@ typedef struct UnpicklerObject {

/* The unpickler memo is just an array of PyObject *s. Using a dict

is unnecessary, since the keys are contiguous ints. */

PyObject **memo;

Py_ssize_t memo_size; /* Capacity of the memo array */

Py_ssize_t memo_len; /* Number of objects in the memo */

size_t memo_size; /* Capacity of the memo array */

size_t memo_len; /* Number of objects in the memo */

PyObject *pers_func; /* persistent_load() method, can be NULL. */

@@ -647,7 +647,7 @@ PyMemoTable_New(void)

static PyMemoTable *

PyMemoTable_Copy(PyMemoTable *self)

{

Py_ssize_t i;

size_t i;

PyMemoTable *new = PyMemoTable_New();

if (new == NULL)

return NULL;

@@ -710,7 +710,7 @@ _PyMemoTable_Lookup(PyMemoTable *self, PyObject *key)

{

size_t i;

size_t perturb;

size_t mask = (size_t)self->mt_mask;

size_t mask = self->mt_mask;

PyMemoEntry *table = self->mt_table;

PyMemoEntry *entry;

Py_hash_t hash = (Py_hash_t)key >> 3;

@@ -732,22 +732,24 @@ _PyMemoTable_Lookup(PyMemoTable *self, PyObject *key)

/* Returns -1 on failure, 0 on success. */

static int

_PyMemoTable_ResizeTable(PyMemoTable *self, Py_ssize_t min_size)

_PyMemoTable_ResizeTable(PyMemoTable *self, size_t min_size)

{

PyMemoEntry *oldtable = NULL;

PyMemoEntry *oldentry, *newentry;

Py_ssize_t new_size = MT_MINSIZE;

Py_ssize_t to_process;

size_t new_size = MT_MINSIZE;

size_t to_process;

assert(min_size > 0);

/* Find the smallest valid table size >= min_size. */

while (new_size < min_size && new_size > 0)

new_size <<= 1;

if (new_size <= 0) {

if (min_size > PY_SSIZE_T_MAX) {

PyErr_NoMemory();

return -1;

}

/* Find the smallest valid table size >= min_size. */

while (new_size < min_size) {

new_size <<= 1;

}

/* new_size needs to be a power of two. */

assert((new_size & (new_size - 1)) == 0);

@@ -797,6 +799,7 @@ static int

PyMemoTable_Set(PyMemoTable *self, PyObject *key, Py_ssize_t value)

{

PyMemoEntry *entry;

size_t desired_size;

assert(key != NULL);

@@ -820,10 +823,12 @@ PyMemoTable_Set(PyMemoTable *self, PyObject *key, Py_ssize_t value)

* Very large memo tables (over 50K items) use doubling instead.

* This may help applications with severe memory constraints.

*/

if (!(self->mt_used * 3 >= (self->mt_mask + 1) * 2))

if (SIZE_MAX / 3 >= self->mt_used && self->mt_used * 3 < self->mt_allocated * 2) {

return 0;

return _PyMemoTable_ResizeTable(self,

(self->mt_used > 50000 ? 2 : 4) * self->mt_used);

}

// self->mt_used is always < PY_SSIZE_T_MAX, so this can't overflow.

desired_size = (self->mt_used > 50000 ? 2 : 4) * self->mt_used;

return _PyMemoTable_ResizeTable(self, desired_size);

}

#undef MT_MINSIZE

@@ -1263,9 +1268,9 @@ _Unpickler_Readline(UnpicklerObject *self, char **result)

/* Returns -1 (with an exception set) on failure, 0 on success. The memo array

will be modified in place. */

static int

_Unpickler_ResizeMemoList(UnpicklerObject *self, Py_ssize_t new_size)

_Unpickler_ResizeMemoList(UnpicklerObject *self, size_t new_size)

{

Py_ssize_t i;

size_t i;

assert(new_size > self->memo_size);

@@ -1282,9 +1287,9 @@ _Unpickler_ResizeMemoList(UnpicklerObject *self, Py_ssize_t new_size)

/* Returns NULL if idx is out of bounds. */

static PyObject *

_Unpickler_MemoGet(UnpicklerObject *self, Py_ssize_t idx)

_Unpickler_MemoGet(UnpicklerObject *self, size_t idx)

{

if (idx < 0 || idx >= self->memo_size)

if (idx >= self->memo_size)

return NULL;

return self->memo[idx];

@@ -1293,7 +1298,7 @@ _Unpickler_MemoGet(UnpicklerObject *self, Py_ssize_t idx)

/* Returns -1 (with an exception set) on failure, 0 on success.

This takes its own reference to `value`. */

static int

_Unpickler_MemoPut(UnpicklerObject *self, Py_ssize_t idx, PyObject *value)

_Unpickler_MemoPut(UnpicklerObject *self, size_t idx, PyObject *value)

{

PyObject *old_item;

@@ -4129,7 +4134,7 @@ static PyObject *

_pickle_PicklerMemoProxy_copy_impl(PicklerMemoProxyObject *self)

/*[clinic end generated code: output=bb83a919d29225ef input=b73043485ac30b36]*/

{

Py_ssize_t i;

size_t i;

PyMemoTable *memo;

PyObject *new_memo = PyDict_New();

if (new_memo == NULL)

@@ -6545,7 +6550,7 @@ static PyObject *

_pickle_UnpicklerMemoProxy_copy_impl(UnpicklerMemoProxyObject *self)

/*[clinic end generated code: output=e12af7e9bc1e4c77 input=97769247ce032c1d]*/

{

Py_ssize_t i;

size_t i;

PyObject *new_memo = PyDict_New();

if (new_memo == NULL)

return NULL;

@@ -6696,8 +6701,7 @@ static int

Unpickler_set_memo(UnpicklerObject *self, PyObject *obj)

{

PyObject **new_memo;

Py_ssize_t new_memo_size = 0;

Py_ssize_t i;

size_t new_memo_size = 0;

if (obj == NULL) {

PyErr_SetString(PyExc_TypeError,

@@ -6706,6 +6710,7 @@ Unpickler_set_memo(UnpicklerObject *self, PyObject *obj)

}

if (Py_TYPE(obj) == &UnpicklerMemoProxyType) {

size_t i;

UnpicklerObject *unpickler =

((UnpicklerMemoProxyObject *)obj)->unpickler;

@@ -6762,8 +6767,8 @@ Unpickler_set_memo(UnpicklerObject *self, PyObject *obj)

error:

if (new_memo_size) {

i = new_memo_size;

while (--i >= 0) {

size_t i;

for (i = new_memo_size - 1; i != SIZE_MAX; i--) {

Py_XDECREF(new_memo[i]);

}

PyMem_FREE(new_memo);