gallium/hash_table: use the same callback signatures as util/hash_table

This is a port of commit 10d235a84319ed4137fe0c6d22d8bb9a52d3174a in Mesa.

Reviewed-by: Gert Wollny <gert.wollny@collabora.com>
Signed-off-by: Corentin Noël <corentin.noel@collabora.com>
Part-of: <https://gitlab.freedesktop.org/virgl/virglrenderer/-/merge_requests/976>

9 files changed, 34 insertions, 45 deletions

diff --git a/src/gallium/auxiliary/util/u_hash_table.c b/src/gallium/auxiliary/util/u_hash_table.c
index 095112a1..061b5321 100644
--- a/src/gallium/auxiliary/util/u_hash_table.c
+++ b/src/gallium/auxiliary/util/u_hash_table.c
@@ -53,10 +53,10 @@ struct util_hash_table
    struct cso_hash *cso;   
    
    /** Hash function */
-   unsigned (*hash)(void *key);
+   uint32_t (*hash)(const void *key);
    
    /** Compare two keys */
-   int (*compare)(void *key1, void *key2);
+   bool (*equal)(const void *key1, const void *key2);
    
    /** free value */
    void (*destroy)(void *value);
@@ -78,8 +78,8 @@ util_hash_table_item(struct cso_hash_iter iter)
 
 
 struct util_hash_table *
-util_hash_table_create(unsigned (*hash)(void *key),
-                       int (*compare)(void *key1, void *key2),
+util_hash_table_create(uint32_t (*hash)(const void *key),
+                       bool (*equal)(const void *key1, const void *key2),
                        void (*destroy)(void *value))
 {
    struct util_hash_table *ht;
@@ -95,7 +95,7 @@ util_hash_table_create(unsigned (*hash)(void *key),
    }
    
    ht->hash = hash;
-   ht->compare = compare;
+   ht->equal = equal;
    ht->destroy = destroy;
    
    return ht;
@@ -113,7 +113,7 @@ util_hash_table_find_iter(struct util_hash_table *ht,
    iter = cso_hash_find(ht->cso, key_hash);
    while (!cso_hash_iter_is_null(iter)) {
       item = (struct util_hash_table_item *)cso_hash_iter_data(iter);
-      if (!ht->compare(item->key, key))
+      if (ht->equal(item->key, key))
          break;
       iter = cso_hash_iter_next(iter);
    }
@@ -133,7 +133,7 @@ util_hash_table_find_item(struct util_hash_table *ht,
    iter = cso_hash_find(ht->cso, key_hash);
    while (!cso_hash_iter_is_null(iter)) {
       item = (struct util_hash_table_item *)cso_hash_iter_data(iter);
-      if (!ht->compare(item->key, key))
+      if (ht->equal(item->key, key))
          return item;
       iter = cso_hash_iter_next(iter);
    }
@@ -147,7 +147,7 @@ util_hash_table_set(struct util_hash_table *ht,
                     void *key,
                     void *value)
 {
-   unsigned key_hash;
+   uint32_t key_hash;
    struct util_hash_table_item *item;
    struct cso_hash_iter iter;
 
@@ -185,7 +185,7 @@ void *
 util_hash_table_get(struct util_hash_table *ht,
                     void *key)
 {
-   unsigned key_hash;
+   uint32_t key_hash;
    struct util_hash_table_item *item;
 
    assert(ht);
@@ -206,7 +206,7 @@ void
 util_hash_table_remove(struct util_hash_table *ht,
                        void *key)
 {
-   unsigned key_hash;
+   uint32_t key_hash;
    struct cso_hash_iter iter;
    struct util_hash_table_item *item;
 
diff --git a/src/gallium/auxiliary/util/u_hash_table.h b/src/gallium/auxiliary/util/u_hash_table.h
index b4a887bb..08481570 100644
--- a/src/gallium/auxiliary/util/u_hash_table.h
+++ b/src/gallium/auxiliary/util/u_hash_table.h
@@ -56,8 +56,8 @@ struct util_hash_table;
  * @param compare should return 0 for two equal keys.
  */
 struct util_hash_table *
-util_hash_table_create(unsigned (*hash)(void *key),
-                       int (*compare)(void *key1, void *key2),
+util_hash_table_create(uint32_t (*hash)(const void *key),
+                       bool (*equal)(const void *key1, const void *key2),
                        void (*destroy)(void *value));
 
 
diff --git a/src/virgl_context.c b/src/virgl_context.c
index f8c005a5..b74aad92 100644
--- a/src/virgl_context.c
+++ b/src/virgl_context.c
@@ -44,7 +44,7 @@ int
 virgl_context_table_init(void)
 {
    virgl_context_table = util_hash_table_create(hash_func_u32,
-                                                compare_func,
+                                                equal_func,
                                                 virgl_context_destroy_func);
    return virgl_context_table ? 0 : ENOMEM;
 }
diff --git a/src/virgl_resource.c b/src/virgl_resource.c
index 260e2916..7f2c3e6a 100644
--- a/src/virgl_resource.c
+++ b/src/virgl_resource.c
@@ -57,7 +57,7 @@ int
 virgl_resource_table_init(const struct virgl_resource_pipe_callbacks *callbacks)
 {
    virgl_resource_table = util_hash_table_create(hash_func_u32,
-                                                 compare_func,
+                                                 equal_func,
                                                  virgl_resource_destroy_func);
    if (!virgl_resource_table)
       return ENOMEM;
diff --git a/src/virgl_util.c b/src/virgl_util.c
index 4580da9e..6ef1802e 100644
--- a/src/virgl_util.c
+++ b/src/virgl_util.c
@@ -53,20 +53,15 @@
 #include <stdio.h>
 #endif
 
-unsigned hash_func_u32(void *key)
+uint32_t hash_func_u32(const void *key)
 {
    intptr_t ip = pointer_to_intptr(key);
-   return (unsigned)(ip & 0xffffffff);
+   return (uint32_t)(ip & 0xffffffff);
 }
 
-int compare_func(void *key1, void *key2)
+bool equal_func(const void *key1, const void *key2)
 {
-   if (key1 < key2)
-      return -1;
-   if (key1 > key2)
-      return 1;
-   else
-      return 0;
+   return key1 == key2;
 }
 
 bool has_eventfd(void)
diff --git a/src/virgl_util.h b/src/virgl_util.h
index 9e9f740c..d92ed29c 100644
--- a/src/virgl_util.h
+++ b/src/virgl_util.h
@@ -58,9 +58,9 @@ static inline bool is_only_bit(uint32_t mask, uint32_t bit)
     return (mask == bit);
 }
 
-unsigned hash_func_u32(void *key);
+uint32_t hash_func_u32(const void *key);
 
-int compare_func(void *key1, void *key2);
+bool equal_func(const void *key1, const void *key2);
 
 bool has_eventfd(void);
 int create_eventfd(unsigned int initval);
diff --git a/src/vrend_blitter.c b/src/vrend_blitter.c
index 25d3f66e..aa5e7a8c 100644
--- a/src/vrend_blitter.c
+++ b/src/vrend_blitter.c
@@ -428,14 +428,14 @@ static GLuint blit_get_frag_tex_col(struct vrend_blitter_ctx *blit_ctx,
    return prog_id;
 }
 
-static uint32_t program_hash_func(void *key)
+static uint32_t program_hash_func(const void *key)
 {
    return XXH32(key, sizeof(struct blit_prog_key), 0);
 }
 
-static int program_comp_func(void *key1, void *key2)
+static bool program_equal_func(const void *key1, const void *key2)
 {
-   return memcmp(key1, key2, sizeof(struct blit_prog_key));
+   return memcmp(key1, key2, sizeof(struct blit_prog_key)) == 0;
 }
 
 static void program_destroy_func(void *shader_id)
@@ -460,7 +460,7 @@ static void vrend_renderer_init_blit_ctx(struct vrend_blitter_ctx *blit_ctx)
    }
 
    vrend_blit_ctx.blit_programs = util_hash_table_create(program_hash_func,
-                                                         program_comp_func,
+                                                         program_equal_func,
                                                          program_destroy_func);
 
    blit_ctx->use_gles = epoxy_is_desktop_gl() == 0;
diff --git a/src/vrend_object.c b/src/vrend_object.c
index 7025cd9e..084e4ff5 100644
--- a/src/vrend_object.c
+++ b/src/vrend_object.c
@@ -61,7 +61,7 @@ static void free_object(void *value)
 struct util_hash_table *vrend_object_init_ctx_table(void)
 {
    struct util_hash_table *ctx_hash;
-   ctx_hash = util_hash_table_create(hash_func_u32, compare_func, free_object);
+   ctx_hash = util_hash_table_create(hash_func_u32, equal_func, free_object);
    return ctx_hash;
 }
 
@@ -82,7 +82,7 @@ struct util_hash_table *
 vrend_ctx_resource_init_table(void)
 {
    return util_hash_table_create(hash_func_u32,
-                                 compare_func,
+                                 equal_func,
                                  vrend_ctx_resource_destroy_func);
 }
 
diff --git a/vtest/vtest_renderer.c b/vtest/vtest_renderer.c
index 94e7966f..f852cdf9 100644
--- a/vtest/vtest_renderer.c
+++ b/vtest/vtest_renderer.c
@@ -299,23 +299,17 @@ static void vtest_free_sync_wait(struct vtest_sync_wait *wait)
    free(wait);
 }
 
-static unsigned
-u32_hash_func(void *key)
+static uint32_t
+u32_hash_func(const void *key)
 {
    intptr_t ip = pointer_to_intptr(key);
-   return (unsigned)(ip & 0xffffffff);
+   return (uint32_t)(ip & 0xffffffff);
 }
 
-static int
-u32_compare_func(void *key1, void *key2)
+static bool
+u32_equal_func(const void *key1, const void *key2)
 {
-   if (key1 < key2) {
-      return -1;
-   } else if (key1 > key2) {
-      return 1;
-   } else {
-      return 0;
-   }
+   return key1 == key2;
 }
 
 static void
@@ -523,7 +517,7 @@ static struct vtest_context *vtest_new_context(struct vtest_input *input,
       }
 
       ctx->resource_table = util_hash_table_create(u32_hash_func,
-                                                   u32_compare_func,
+                                                   u32_equal_func,
                                                    resource_destroy_func);
       if (!ctx->resource_table) {
          free(ctx);
@@ -531,7 +525,7 @@ static struct vtest_context *vtest_new_context(struct vtest_input *input,
       }
 
       ctx->sync_table = util_hash_table_create(u32_hash_func,
-                                               u32_compare_func,
+                                               u32_equal_func,
                                                sync_destroy_func);
       if (!ctx->sync_table) {
          util_hash_table_destroy(ctx->resource_table);