Fix the internals of our hash functions to used unsigned values during hash

computation as the overflow behavior of signed integers is undefined.

NOTE: This change is smaller compared to 3.2 as much of this cleanup had
already been done.  I added the comment that my change in 3.2 added so that the
code would match up.  Otherwise this just adds or synchronizes appropriate UL
designations on some constants to be pedantic.

In practice we require compiling everything with -fwrapv which forces overflow
to be defined as twos compliment but this keeps the code cleaner for checkers
or in the case where someone has compiled it without -fwrapv or their
compiler's equivalent.

Found by Clang trunk's Undefined Behavior Sanitizer (UBSan).

Cleanup only - no functionality or hash values change.

3 files changed, 11 insertions, 11 deletions

diff --git a/Objects/setobject.c b/Objects/setobject.c
index 723679a..c484dce 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -77,7 +77,7 @@ NULL if the rich comparison returns an error.
 static setentry *
 set_lookkey(PySetObject *so, PyObject *key, register Py_hash_t hash)
 {
-    register size_t i;
+    register size_t i;  /* Unsigned for defined overflow behavior. */
     register size_t perturb;
     register setentry *freeslot;
     register size_t mask = so->mask;
@@ -159,7 +159,7 @@ set_lookkey(PySetObject *so, PyObject *key, register Py_hash_t hash)
 static setentry *
 set_lookkey_unicode(PySetObject *so, PyObject *key, register Py_hash_t hash)
 {
-    register size_t i;
+    register size_t i;  /* Unsigned for defined overflow behavior. */
     register size_t perturb;
     register setentry *freeslot;
     register size_t mask = so->mask;
@@ -760,7 +760,7 @@ static Py_hash_t
 frozenset_hash(PyObject *self)
 {
     PySetObject *so = (PySetObject *)self;
-    Py_uhash_t h, hash = 1927868237U;
+    Py_uhash_t h, hash = 1927868237UL;
     setentry *entry;
     Py_ssize_t pos = 0;
 
@@ -775,11 +775,11 @@ frozenset_hash(PyObject *self)
            hashes so that many distinct combinations collapse to only
            a handful of distinct hash values. */
         h = entry->hash;
-        hash ^= (h ^ (h << 16) ^ 89869747U)  * 3644798167U;
+        hash ^= (h ^ (h << 16) ^ 89869747UL)  * 3644798167UL;
     }
-    hash = hash * 69069U + 907133923U;
+    hash = hash * 69069U + 907133923UL;
     if (hash == -1)
-        hash = 590923713U;
+        hash = 590923713UL;
     so->hash = hash;
     return hash;
 }
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index 9c843fa..ec3f91b 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -327,12 +327,12 @@ error:
 static Py_hash_t
 tuplehash(PyTupleObject *v)
 {
-    register Py_uhash_t x;
+    register Py_uhash_t x;  /* Unsigned for defined overflow behavior. */
     register Py_hash_t y;
     register Py_ssize_t len = Py_SIZE(v);
     register PyObject **p;
     Py_uhash_t mult = _PyHASH_MULTIPLIER;
-    x = 0x345678;
+    x = 0x345678UL;
     p = v->ob_item;
     while (--len >= 0) {
         y = PyObject_Hash(*p++);
@@ -340,9 +340,9 @@ tuplehash(PyTupleObject *v)
             return -1;
         x = (x ^ y) * mult;
         /* the cast might truncate len; that doesn't change hash stability */
-        mult += (Py_hash_t)(82520L + len + len);
+        mult += (Py_hash_t)(82520UL + len + len);
     }
-    x += 97531L;
+    x += 97531UL;
     if (x == (Py_uhash_t)-1)
         x = -2;
     return x;
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 60a74d6..0b9d652 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -11008,7 +11008,7 @@ static Py_hash_t
 unicode_hash(PyObject *self)
 {
     Py_ssize_t len;
-    Py_uhash_t x;
+    Py_uhash_t x;  /* Unsigned for defined overflow behavior. */
 
 #ifdef Py_DEBUG
     assert(_Py_HashSecret_Initialized);