Is this approach to hashing any generic object correct?

Question

Using the OpenJDK's hashCode, I tried to implement a generic hashing routine in C:

U32 hashObject(void *object_generic, U32 object_length) {
    if (object_generic == NULL) return 0;

    U8 *object = (U8*)object_generic;
    U32 hash = 1;

    for (U32 i = 0; i < object_length; ++i) {
//      hash = 31 * hash + object[i]; // Original prime used in OpenJDK
        hash = 92821 * hash + object[i]; // Better constant found here: https://stackoverflow.com/questions/1835976/what-is-a-sensible-prime-for-hashcode-calculation
    }

    return hash;
}

The idea is that I can pass a pointer to any C object (primitive type, struct, array, etc.) and the object will be uniquely hashed. However, since this is the first time I am doing something like this, I'd like to ask- Is this the right approach? Are there any pitfalls that I need to be aware of?

Answer 1

There are decidedly pitfalls. The below program using your function, for example, prints a different value for each equivalent object (and a different value every time it’s compiled) under gcc -O0:

#include <stddef.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

struct foo {
    char c;
    int i;
};

static uint32_t hashObject(void const* object_generic, uint32_t object_length) {
    if (object_generic == NULL) return 0;

    uint8_t const* object = (uint8_t const*)object_generic;
    uint32_t hash = 1;

    for (uint32_t i = 0; i < object_length; ++i) {
        hash = 92821 * hash + object[i];
    }

    return hash;
}

int main() {
    struct foo a[2];

    a[0].c = 'A';
    a[0].i = 1;

    a[1].c = 'A';
    a[1].i = 1;

    _Static_assert(
        sizeof(struct foo) == offsetof(struct foo, i) + sizeof(int),
        "struct has no end padding"
    );

    printf("%d\n", hashObject(&a[0], sizeof *a));
    printf("%d\n", hashObject(&a[1], sizeof *a));

    return EXIT_SUCCESS;
}

This happens because padding can contain anything.

Answer 2

In the comments you ask what would happen if you zero out the struct object before using them.

It would not help. The hashes could still be different because padding bytes take unspecified values when a value is stored into a struct object or a member of a struct object¹. The unspecified values may change on every store.

There is an additional problem, with other types. Any scalar type (pointer, integers, and floating types) may have different representations of the same value. This is a similar problem as struct types have with padding bytes, mentioned above. The bit representations of scalar objects may change, even though the value did not, and the resulting hash will be different.

---

(Quoted from: ISO/IEC 9899:201x 6.2.6 Representation of types 6.2.6.1 General 6)
When a value is stored in an object of structure or union type, including in a member object, the bytes of the object representation that correspond to any padding bytes take unspecified values.

Answer 3

No.

std::vector<int> v1 = {1, 2, 3, 4};
std::vector<int> v2 = {1, 2, 3, 4};

std::cout << "hash1=" << hashobject(&v1, sizeof(v1)) 
    << "hash2=" << hashobject(&v1, sizeof(v1)) << std::endl;

would report two different hash values, which is probably not the intended behaviour.

PS: the question is about C rather than the C++, but the similar class can be in C.