diff -r 9568343fde42 Objects/listobject.c
--- a/Objects/listobject.c	Mon Dec 19 18:39:28 2016 +0800
+++ b/Objects/listobject.c	Thu Dec 29 05:05:14 2016 +0900
@@ -38,6 +38,18 @@ list_resize(PyListObject *self, Py_ssize
         Py_SIZE(self) = newsize;
         return 0;
     }
+    
+    /* resize to zero: free up space used by the ob_item array, update
+    structure accordingly and return
+    */
+    if (newsize == 0) {
+        PyObject_FREE(self->ob_item);
+        self->ob_item = NULL;
+        self->allocated = 0;
+        Py_SIZE(self) = 0;
+        
+        return 0;   
+    }
 
     /* This over-allocates proportional to the list size, making room
      * for additional growth.  The over-allocation is mild, but is
@@ -48,21 +60,16 @@ list_resize(PyListObject *self, Py_ssize
      */
     new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);
 
-    /* check for integer overflow */
-    if (new_allocated > SIZE_MAX - newsize) {
+    /* check for integer overflow by keeping in mind that new_allocated will
+         be multiplied by sizeof(PyObject*) */
+    if (new_allocated > (PY_SIZE_MAX - newsize) / sizeof(PyObject*)) {
         PyErr_NoMemory();
         return -1;
-    } else {
-        new_allocated += newsize;
     }
 
-    if (newsize == 0)
-        new_allocated = 0;
-    items = self->ob_item;
-    if (new_allocated <= (SIZE_MAX / sizeof(PyObject *)))
-        PyMem_RESIZE(items, PyObject *, new_allocated);
-    else
-        items = NULL;
+    new_allocated += newsize;
+    items = self->ob_item;    
+    items = PyObject_REALLOC(items, new_allocated * sizeof(PyObject*));   
     if (items == NULL) {
         PyErr_NoMemory();
         return -1;
@@ -170,11 +177,13 @@ PyList_New(Py_ssize_t size)
     if (size <= 0)
         op->ob_item = NULL;
     else {
-        op->ob_item = (PyObject **) PyMem_Calloc(size, sizeof(PyObject *));
+        Py_ssize_t nbytes = size * sizeof(PyObject *);
+        op->ob_item = (PyObject **) PyObject_MALLOC(nbytes);
         if (op->ob_item == NULL) {
             Py_DECREF(op);
             return PyErr_NoMemory();
         }
+        memset(op->ob_item, 0, nbytes);
     }
     Py_SIZE(op) = size;
     op->allocated = size;
@@ -325,7 +334,7 @@ list_dealloc(PyListObject *op)
         while (--i >= 0) {
             Py_XDECREF(op->ob_item[i]);
         }
-        PyMem_FREE(op->ob_item);
+        PyObject_FREE(op->ob_item);
     }
     if (numfree < PyList_MAXFREELIST && PyList_CheckExact(op))
         free_list[numfree++] = op;
@@ -561,7 +570,7 @@ list_clear(PyListObject *a)
         while (--i >= 0) {
             Py_XDECREF(item[i]);
         }
-        PyMem_FREE(item);
+        PyObject_FREE(item);
     }
     /* Never fails; the return value can be ignored.
        Note that there is no guarantee that the list is actually empty
@@ -637,7 +646,7 @@ list_ass_slice(PyListObject *a, Py_ssize
     /* If norig == 0, item might be NULL, in which case we may not memcpy from it. */
     if (s) {
         if (s > sizeof(recycle_on_stack)) {
-            recycle = (PyObject **)PyMem_MALLOC(s);
+            recycle = (PyObject **)PyObject_MALLOC(s);
             if (recycle == NULL) {
                 PyErr_NoMemory();
                 goto Error;
@@ -675,7 +684,7 @@ list_ass_slice(PyListObject *a, Py_ssize
     result = 0;
  Error:
     if (recycle != recycle_on_stack)
-        PyMem_FREE(recycle);
+        PyObject_FREE(recycle);
     Py_XDECREF(v_as_SF);
     return result;
 #undef b
@@ -1445,7 +1454,7 @@ merge_freemem(MergeState *ms)
 {
     assert(ms != NULL);
     if (ms->a.keys != ms->temparray)
-        PyMem_Free(ms->a.keys);
+        PyObject_FREE(ms->a.keys);
 }
 
 /* Ensure enough temp memory for 'need' array slots is available.
@@ -1470,7 +1479,7 @@ merge_getmem(MergeState *ms, Py_ssize_t 
         PyErr_NoMemory();
         return -1;
     }
-    ms->a.keys = (PyObject**)PyMem_Malloc(multiplier * need
+    ms->a.keys = (PyObject**)PyObject_MALLOC(multiplier * need
                                           * sizeof(PyObject *));
     if (ms->a.keys != NULL) {
         ms->alloced = need;
@@ -1962,7 +1971,7 @@ listsort(PyListObject *self, PyObject *a
             /* Leverage stack space we allocated but won't otherwise use */
             keys = &ms.temparray[saved_ob_size+1];
         else {
-            keys = PyMem_MALLOC(sizeof(PyObject *) * saved_ob_size);
+            keys = PyObject_MALLOC(sizeof(PyObject *) * saved_ob_size);
             if (keys == NULL) {
                 PyErr_NoMemory();
                 goto keyfunc_fail;
@@ -1976,7 +1985,7 @@ listsort(PyListObject *self, PyObject *a
                 for (i=i-1 ; i>=0 ; i--)
                     Py_DECREF(keys[i]);
                 if (saved_ob_size >= MERGESTATE_TEMP_SIZE/2)
-                    PyMem_FREE(keys);
+                    PyObject_FREE(keys);
                 goto keyfunc_fail;
             }
         }
@@ -2049,7 +2058,7 @@ fail:
         for (i = 0; i < saved_ob_size; i++)
             Py_DECREF(keys[i]);
         if (saved_ob_size >= MERGESTATE_TEMP_SIZE/2)
-            PyMem_FREE(keys);
+            PyObject_FREE(keys);
     }
 
     if (self->allocated != -1 && result != NULL) {
@@ -2077,7 +2086,7 @@ keyfunc_fail:
         while (--i >= 0) {
             Py_XDECREF(final_ob_item[i]);
         }
-        PyMem_FREE(final_ob_item);
+        PyObject_FREE(final_ob_item);
     }
     Py_XINCREF(result);
     return result;
@@ -2500,7 +2509,7 @@ list_ass_subscript(PyListObject* self, P
             }
 
             garbage = (PyObject**)
-                PyMem_MALLOC(slicelength*sizeof(PyObject*));
+                PyObject_MALLOC(slicelength*sizeof(PyObject*));
             if (!garbage) {
                 PyErr_NoMemory();
                 return -1;
@@ -2541,7 +2550,7 @@ list_ass_subscript(PyListObject* self, P
             for (i = 0; i < slicelength; i++) {
                 Py_DECREF(garbage[i]);
             }
-            PyMem_FREE(garbage);
+            PyObject_FREE(garbage);
 
             return res;
         }
@@ -2581,7 +2590,7 @@ list_ass_subscript(PyListObject* self, P
             }
 
             garbage = (PyObject**)
-                PyMem_MALLOC(slicelength*sizeof(PyObject*));
+                PyObject_MALLOC(slicelength*sizeof(PyObject*));
             if (!garbage) {
                 Py_DECREF(seq);
                 PyErr_NoMemory();
@@ -2602,7 +2611,7 @@ list_ass_subscript(PyListObject* self, P
                 Py_DECREF(garbage[i]);
             }
 
-            PyMem_FREE(garbage);
+            PyObject_FREE(garbage);
             Py_DECREF(seq);
 
             return 0;