diff -r a0b38f4eb79e Objects/bytesobject.c
--- a/Objects/bytesobject.c	Fri Aug 15 23:17:38 2014 +0200
+++ b/Objects/bytesobject.c	Fri Aug 15 23:55:15 2014 +0200
@@ -89,7 +89,7 @@ static PyObject *
         return (PyObject *)op;
     }
 
-    if (size > PY_SSIZE_T_MAX - PyBytesObject_SIZE) {
+    if ((size_t)size > (size_t)PY_SSIZE_T_MAX - PyBytesObject_SIZE) {
         PyErr_SetString(PyExc_OverflowError,
                         "byte string is too large");
         return NULL;
diff -r a0b38f4eb79e Objects/tupleobject.c
--- a/Objects/tupleobject.c	Fri Aug 15 23:17:38 2014 +0200
+++ b/Objects/tupleobject.c	Fri Aug 15 23:55:15 2014 +0200
@@ -97,7 +97,7 @@ PyTuple_New(Py_ssize_t size)
 #endif
     {
         /* Check for overflow */
-        if (size > (PY_SSIZE_T_MAX - sizeof(PyTupleObject) -
+        if ((size_t)size > ((size_t)PY_SSIZE_T_MAX - sizeof(PyTupleObject) -
                     sizeof(PyObject *)) / sizeof(PyObject *)) {
             return PyErr_NoMemory();
         }
diff -r a0b38f4eb79e Objects/unicodeobject.c
--- a/Objects/unicodeobject.c	Fri Aug 15 23:17:38 2014 +0200
+++ b/Objects/unicodeobject.c	Fri Aug 15 23:55:15 2014 +0200
@@ -698,8 +698,8 @@ unicode_fill_invalid(PyObject *unicode, 
 static PyObject*
 resize_compact(PyObject *unicode, Py_ssize_t length)
 {
-    Py_ssize_t char_size;
-    Py_ssize_t struct_size;
+    size_t char_size;
+    size_t struct_size;
     Py_ssize_t new_size;
     int share_wstr;
     PyObject *new_unicode;
@@ -711,14 +711,15 @@ resize_compact(PyObject *unicode, Py_ssi
     assert(PyUnicode_IS_READY(unicode));
     assert(PyUnicode_IS_COMPACT(unicode));
 
-    char_size = PyUnicode_KIND(unicode);
+    char_size = (size_t)PyUnicode_KIND(unicode);
+    assert(char_size != 0);
     if (PyUnicode_IS_ASCII(unicode))
         struct_size = sizeof(PyASCIIObject);
     else
         struct_size = sizeof(PyCompactUnicodeObject);
     share_wstr = _PyUnicode_SHARE_WSTR(unicode);
 
-    if (length > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1)) {
+    if ((size_t)length > (((size_t)PY_SSIZE_T_MAX - struct_size) / char_size - 1)) {
         PyErr_NoMemory();
         return NULL;
     }
@@ -764,7 +765,7 @@ resize_inplace(PyObject *unicode, Py_ssi
     assert(Py_REFCNT(unicode) == 1);
 
     if (PyUnicode_IS_READY(unicode)) {
-        Py_ssize_t char_size;
+        size_t char_size;
         int share_wstr, share_utf8;
         void *data;
 #ifdef Py_DEBUG
@@ -776,7 +777,7 @@ resize_inplace(PyObject *unicode, Py_ssi
         share_wstr = _PyUnicode_SHARE_WSTR(unicode);
         share_utf8 = _PyUnicode_SHARE_UTF8(unicode);
 
-        if (length > (PY_SSIZE_T_MAX / char_size - 1)) {
+        if ((size_t)length > ((size_t)PY_SSIZE_T_MAX / char_size - 1)) {
             PyErr_NoMemory();
             return -1;
         }
@@ -816,7 +817,7 @@ resize_inplace(PyObject *unicode, Py_ssi
     assert(_PyUnicode_WSTR(unicode) != NULL);
 
     /* check for integer overflow */
-    if (length > PY_SSIZE_T_MAX / sizeof(wchar_t) - 1) {
+    if ((size_t)length > (size_t)PY_SSIZE_T_MAX / sizeof(wchar_t) - 1) {
         PyErr_NoMemory();
         return -1;
     }
@@ -888,14 +889,14 @@ static PyUnicodeObject *
     }
 
     /* Ensure we won't overflow the size. */
-    if (length > ((PY_SSIZE_T_MAX / sizeof(Py_UNICODE)) - 1)) {
-        return (PyUnicodeObject *)PyErr_NoMemory();
-    }
     if (length < 0) {
         PyErr_SetString(PyExc_SystemError,
                         "Negative size passed to _PyUnicode_New");
         return NULL;
     }
+    if ((size_t)length > (((size_t)PY_SSIZE_T_MAX / sizeof(Py_UNICODE)) - 1)) {
+        return (PyUnicodeObject *)PyErr_NoMemory();
+    }
 
     unicode = PyObject_New(PyUnicodeObject, &PyUnicode_Type);
     if (unicode == NULL)
@@ -1037,8 +1038,8 @@ PyUnicode_New(Py_ssize_t size, Py_UCS4 m
     void *data;
     enum PyUnicode_Kind kind;
     int is_sharing, is_ascii;
-    Py_ssize_t char_size;
-    Py_ssize_t struct_size;
+    size_t char_size;
+    size_t struct_size;
 
     /* Optimization for empty strings */
     if (size == 0 && unicode_empty != NULL) {
@@ -1083,7 +1084,7 @@ PyUnicode_New(Py_ssize_t size, Py_UCS4 m
                         "Negative size passed to PyUnicode_New");
         return NULL;
     }
-    if (size > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1))
+    if ((size_t)size > (((size_t)PY_SSIZE_T_MAX - struct_size) / char_size - 1))
         return PyErr_NoMemory();
 
     /* Duplicated allocation code from _PyObject_New() instead of a call to
@@ -2239,7 +2240,7 @@ as_ucs4(PyObject *string, Py_UCS4 *targe
     if (copy_null)
         targetlen++;
     if (!target) {
-        if (PY_SSIZE_T_MAX / sizeof(Py_UCS4) < targetlen) {
+        if ((size_t)PY_SSIZE_T_MAX / sizeof(Py_UCS4) < (size_t)targetlen) {
             PyErr_NoMemory();
             return NULL;
         }
@@ -2852,7 +2853,7 @@ PyUnicode_AsWideCharString(PyObject *uni
     buflen = unicode_aswidechar(unicode, NULL, 0);
     if (buflen == -1)
         return NULL;
-    if (PY_SSIZE_T_MAX / sizeof(wchar_t) < buflen) {
+    if ((size_t)PY_SSIZE_T_MAX / sizeof(wchar_t) < (size_t)buflen) {
         PyErr_NoMemory();
         return NULL;
     }
@@ -3551,7 +3552,7 @@ PyUnicode_DecodeLocaleAndSize(const char
             wstr = smallbuf;
         }
         else {
-            if (wlen > PY_SSIZE_T_MAX / sizeof(wchar_t) - 1)
+            if (wlen > (size_t)PY_SSIZE_T_MAX / sizeof(wchar_t) - 1)
                 return PyErr_NoMemory();
 
             wstr = PyMem_Malloc((wlen+1) * sizeof(wchar_t));
@@ -4514,7 +4515,7 @@ PyObject *
         return PyBytes_FromStringAndSize(NULL, 0);
 
     /* It might be possible to tighten this worst case */
-    if (len > PY_SSIZE_T_MAX / 8)
+    if ((size_t)len > (size_t)PY_SSIZE_T_MAX / 8)
         return PyErr_NoMemory();
     v = PyBytes_FromStringAndSize(NULL, len * 8);
     if (v == NULL)
@@ -5130,7 +5131,7 @@ PyObject *
     len = PyUnicode_GET_LENGTH(str);
 
     nsize = len + (byteorder == 0);
-    if (nsize > PY_SSIZE_T_MAX / 4)
+    if ((size_t)nsize > (size_t)PY_SSIZE_T_MAX / 4)
         return PyErr_NoMemory();
     v = PyBytes_FromStringAndSize(NULL, nsize * 4);
     if (v == NULL)
@@ -5212,7 +5213,7 @@ PyObject *
         if (moreunits > 1) {
             Py_ssize_t outpos = p - (unsigned char*) PyBytes_AS_STRING(v);
             Py_ssize_t morebytes = 4 * (moreunits - 1);
-            if (PyBytes_GET_SIZE(v) > PY_SSIZE_T_MAX - morebytes) {
+            if ((size_t)PyBytes_GET_SIZE(v) > (size_t)PY_SSIZE_T_MAX - (size_t)morebytes) {
                 /* integer overflow */
                 PyErr_NoMemory();
                 goto error;
@@ -5452,7 +5453,7 @@ PyObject *
     Py_ssize_t len;
     PyObject *v;
     unsigned short *out;
-    Py_ssize_t pairs;
+    size_t pairs;
 #if PY_BIG_ENDIAN
     int native_ordering = byteorder >= 0;
 #else
@@ -5482,7 +5483,7 @@ PyObject *
             if (*in++ >= 0x10000)
                 pairs++;
     }
-    if (len > PY_SSIZE_T_MAX / 2 - pairs - (byteorder == 0))
+    if ((size_t)len > (size_t)PY_SSIZE_T_MAX / 2 - pairs - (byteorder == 0))
         return PyErr_NoMemory();
     nsize = len + pairs + (byteorder == 0);
     v = PyBytes_FromStringAndSize(NULL, nsize * 2);
@@ -5559,7 +5560,7 @@ PyObject *
         if (moreunits > 1) {
             Py_ssize_t outpos = out - (unsigned short*) PyBytes_AS_STRING(v);
             Py_ssize_t morebytes = 2 * (moreunits - 1);
-            if (PyBytes_GET_SIZE(v) > PY_SSIZE_T_MAX - morebytes) {
+            if ((size_t)PyBytes_GET_SIZE(v) > (size_t)PY_SSIZE_T_MAX - (size_t)morebytes) {
                 /* integer overflow */
                 PyErr_NoMemory();
                 goto error;
@@ -5920,7 +5921,7 @@ PyUnicode_AsUnicodeEscapeString(PyObject
     char *p;
     int kind;
     void *data;
-    Py_ssize_t expandsize = 0;
+    size_t expandsize = 0;
 
     /* Initial allocation is based on the longest-possible character
        escape.
@@ -5948,7 +5949,7 @@ PyUnicode_AsUnicodeEscapeString(PyObject
     if (len == 0)
         return PyBytes_FromStringAndSize(NULL, 0);
 
-    if (len > (PY_SSIZE_T_MAX - 2 - 1) / expandsize)
+    if ((size_t)len > (size_t)(PY_SSIZE_T_MAX - 2 - 1) / expandsize)
         return PyErr_NoMemory();
 
     repr = PyBytes_FromStringAndSize(NULL,
@@ -6158,7 +6159,8 @@ PyUnicode_AsRawUnicodeEscapeString(PyObj
     PyObject *repr;
     char *p;
     char *q;
-    Py_ssize_t expandsize, pos;
+    size_t expandsize;
+    Py_ssize_t pos;
     int kind;
     void *data;
     Py_ssize_t len;
@@ -6174,9 +6176,9 @@ PyUnicode_AsRawUnicodeEscapeString(PyObj
     len = PyUnicode_GET_LENGTH(unicode);
     /* 4 byte characters can take up 10 bytes, 2 byte characters can take up 6
        bytes, and 1 byte characters 4. */
-    expandsize = kind * 2 + 2;
-
-    if (len > PY_SSIZE_T_MAX / expandsize)
+    expandsize = (size_t)kind * 2 + 2;
+
+    if ((size_t)len > (size_t)PY_SSIZE_T_MAX / expandsize)
         return PyErr_NoMemory();
 
     repr = PyBytes_FromStringAndSize(NULL, expandsize * len);
@@ -6260,7 +6262,7 @@ PyObject *
         _Py_RETURN_UNICODE_EMPTY();
 
     _PyUnicodeWriter_Init(&writer);
-    if (size / Py_UNICODE_SIZE > PY_SSIZE_T_MAX - 1) {
+    if ((size_t)size / Py_UNICODE_SIZE > (size_t)PY_SSIZE_T_MAX - 1) {
         PyErr_NoMemory();
         goto onError;
     }
@@ -6933,7 +6935,7 @@ decode_code_page_errors(UINT code_page,
 
     if (*v == NULL) {
         /* Create unicode object */
-        if (size > PY_SSIZE_T_MAX / (Py_ssize_t)Py_ARRAY_LENGTH(buffer)) {
+        if ((size_t)size > (size_t)PY_SSIZE_T_MAX / Py_ARRAY_LENGTH(buffer)) {
             PyErr_NoMemory();
             goto error;
         }
@@ -6945,8 +6947,8 @@ decode_code_page_errors(UINT code_page,
     }
     else {
         /* Extend unicode object */
-        Py_ssize_t n = PyUnicode_GET_SIZE(*v);
-        if (size > (PY_SSIZE_T_MAX - n) / (Py_ssize_t)Py_ARRAY_LENGTH(buffer)) {
+        size_t n = (size_t)PyUnicode_GET_SIZE(*v);
+        if ((size_t)size > ((size_t)PY_SSIZE_T_MAX - n) / Py_ARRAY_LENGTH(buffer)) {
             PyErr_NoMemory();
             goto error;
         }
@@ -7202,8 +7204,8 @@ encode_code_page_strict(UINT code_page, 
     }
     else {
         /* Extend string object */
-        const Py_ssize_t n = PyBytes_Size(*outbytes);
-        if (outsize > PY_SSIZE_T_MAX - n) {
+        const size_t n = (size_t)PyBytes_Size(*outbytes);
+        if ((size_t)outsize > (size_t)PY_SSIZE_T_MAX - n) {
             PyErr_NoMemory();
             Py_DECREF(substring);
             return -1;
@@ -7289,7 +7291,7 @@ encode_code_page_errors(UINT code_page, 
     else
         pusedDefaultChar = NULL;
 
-    if (Py_ARRAY_LENGTH(buffer) > PY_SSIZE_T_MAX / insize) {
+    if (Py_ARRAY_LENGTH(buffer) > (size_t)PY_SSIZE_T_MAX / (size_t)insize) {
         PyErr_NoMemory();
         goto error;
     }
@@ -7304,8 +7306,8 @@ encode_code_page_errors(UINT code_page, 
     }
     else {
         /* Extend string object */
-        Py_ssize_t n = PyBytes_Size(*outbytes);
-        if (n > PY_SSIZE_T_MAX - outsize) {
+        size_t n = PyBytes_Size(*outbytes);
+        if (n > (size_t)PY_SSIZE_T_MAX - (size_t)outsize) {
             PyErr_NoMemory();
             goto error;
         }
@@ -13287,7 +13289,7 @@ int
 
     assert(length > 0);
 
-    if (length > PY_SSIZE_T_MAX - writer->pos) {
+    if ((size_t)length > (size_t)PY_SSIZE_T_MAX - (size_t)writer->pos) {
         PyErr_NoMemory();
         return -1;
     }
@@ -14779,7 +14781,8 @@ static PyObject *
 unicode_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 {
     PyObject *unicode, *self;
-    Py_ssize_t length, char_size;
+    Py_ssize_t length;
+    size_t char_size;
     int share_wstr, share_utf8;
     unsigned int kind;
     void *data;
@@ -14840,7 +14843,7 @@ unicode_subtype_new(PyTypeObject *type, 
     }
 
     /* Ensure we won't overflow the length. */
-    if (length > (PY_SSIZE_T_MAX / char_size - 1)) {
+    if ((size_t)length > ((size_t)PY_SSIZE_T_MAX / char_size - 1)) {
         PyErr_NoMemory();
         goto onError;
     }
@@ -15394,7 +15397,7 @@ PyUnicode_AsUnicodeCopy(PyObject *unicod
     if (u == NULL)
         return NULL;
     /* Ensure we won't overflow the size. */
-    if (len > ((PY_SSIZE_T_MAX / sizeof(Py_UNICODE)) - 1)) {
+    if ((size_t)len > ((size_t)PY_SSIZE_T_MAX / sizeof(Py_UNICODE) - 1)) {
         PyErr_NoMemory();
         return NULL;
     }
diff -r a0b38f4eb79e Python/asdl.c
--- a/Python/asdl.c	Fri Aug 15 23:17:38 2014 +0200
+++ b/Python/asdl.c	Fri Aug 15 23:55:15 2014 +0200
@@ -9,7 +9,7 @@ asdl_seq *
 
     /* check size is sane */
     if (size < 0 || size == INT_MIN ||
-        (size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
+        (size && (((size_t)size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
         PyErr_NoMemory();
         return NULL;
     }
@@ -40,7 +40,7 @@ asdl_int_seq *
 
     /* check size is sane */
     if (size < 0 || size == INT_MIN ||
-        (size && ((size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
+        (size && (((size_t)size - 1) > (PY_SIZE_MAX / sizeof(void *))))) {
             PyErr_NoMemory();
             return NULL;
     }