hash: convert hashing context to a structure

The `git_hash_context` is a union containing the different hash-specific
states for SHA1, its unsafe variant as well as SHA256. We know that only
one of these states will ever be in use at the same time because hash
contexts cannot be used for multiple different hashes at the same point
in time.

We're about to extend the structure though to keep track of the hash
algorithm used to initialize the context, which is impossible to do
while the context is a union. Refactor it to instead be a structure that
contains the union of context states.

Signed-off-by: Patrick Steinhardt <ps@pks.im>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/hash.h b/hash.h
index ad2c919991c884f0e563aa4416c5c004349582fe..5b88d9b714d8ad875dfa64b11ca5e1158a3336d5 100644 (file)
--- a/hash.h
+++ b/hash.h
@@ -234,13 +234,14 @@ enum get_oid_result {
 #endif
 
 /* A suitably aligned type for stack allocations of hash contexts. */
-union git_hash_ctx {
-       git_SHA_CTX sha1;
-       git_SHA_CTX_unsafe sha1_unsafe;
-
-       git_SHA256_CTX sha256;
+struct git_hash_ctx {
+       union {
+               git_SHA_CTX sha1;
+               git_SHA_CTX_unsafe sha1_unsafe;
+               git_SHA256_CTX sha256;
+       } state;
 };
-typedef union git_hash_ctx git_hash_ctx;
+typedef struct git_hash_ctx git_hash_ctx;
 
 typedef void (*git_hash_init_fn)(git_hash_ctx *ctx);
 typedef void (*git_hash_clone_fn)(git_hash_ctx *dst, const git_hash_ctx *src);

diff --git a/object-file.c b/object-file.c
index 6ce1caacae7f0b03f11159f0e742a5f07ddd7b08..7505aa6b6073ae3297fa74eb0d15d07afdd2d561 100644 (file)
--- a/object-file.c
+++ b/object-file.c
@@ -88,82 +88,82 @@ static const struct object_id null_oid_sha256 = {
 
 static void git_hash_sha1_init(git_hash_ctx *ctx)
 {
-       git_SHA1_Init(&ctx->sha1);
+       git_SHA1_Init(&ctx->state.sha1);
 }
 
 static void git_hash_sha1_clone(git_hash_ctx *dst, const git_hash_ctx *src)
 {
-       git_SHA1_Clone(&dst->sha1, &src->sha1);
+       git_SHA1_Clone(&dst->state.sha1, &src->state.sha1);
 }
 
 static void git_hash_sha1_update(git_hash_ctx *ctx, const void *data, size_t len)
 {
-       git_SHA1_Update(&ctx->sha1, data, len);
+       git_SHA1_Update(&ctx->state.sha1, data, len);
 }
 
 static void git_hash_sha1_final(unsigned char *hash, git_hash_ctx *ctx)
 {
-       git_SHA1_Final(hash, &ctx->sha1);
+       git_SHA1_Final(hash, &ctx->state.sha1);
 }
 
 static void git_hash_sha1_final_oid(struct object_id *oid, git_hash_ctx *ctx)
 {
-       git_SHA1_Final(oid->hash, &ctx->sha1);
+       git_SHA1_Final(oid->hash, &ctx->state.sha1);
        memset(oid->hash + GIT_SHA1_RAWSZ, 0, GIT_MAX_RAWSZ - GIT_SHA1_RAWSZ);
        oid->algo = GIT_HASH_SHA1;
 }
 
 static void git_hash_sha1_init_unsafe(git_hash_ctx *ctx)
 {
-       git_SHA1_Init_unsafe(&ctx->sha1_unsafe);
+       git_SHA1_Init_unsafe(&ctx->state.sha1_unsafe);
 }
 
 static void git_hash_sha1_clone_unsafe(git_hash_ctx *dst, const git_hash_ctx *src)
 {
-       git_SHA1_Clone_unsafe(&dst->sha1_unsafe, &src->sha1_unsafe);
+       git_SHA1_Clone_unsafe(&dst->state.sha1_unsafe, &src->state.sha1_unsafe);
 }
 
 static void git_hash_sha1_update_unsafe(git_hash_ctx *ctx, const void *data,
                                      size_t len)
 {
-       git_SHA1_Update_unsafe(&ctx->sha1_unsafe, data, len);
+       git_SHA1_Update_unsafe(&ctx->state.sha1_unsafe, data, len);
 }
 
 static void git_hash_sha1_final_unsafe(unsigned char *hash, git_hash_ctx *ctx)
 {
-       git_SHA1_Final_unsafe(hash, &ctx->sha1_unsafe);
+       git_SHA1_Final_unsafe(hash, &ctx->state.sha1_unsafe);
 }
 
 static void git_hash_sha1_final_oid_unsafe(struct object_id *oid, git_hash_ctx *ctx)
 {
-       git_SHA1_Final_unsafe(oid->hash, &ctx->sha1_unsafe);
+       git_SHA1_Final_unsafe(oid->hash, &ctx->state.sha1_unsafe);
        memset(oid->hash + GIT_SHA1_RAWSZ, 0, GIT_MAX_RAWSZ - GIT_SHA1_RAWSZ);
        oid->algo = GIT_HASH_SHA1;
 }
 
 static void git_hash_sha256_init(git_hash_ctx *ctx)
 {
-       git_SHA256_Init(&ctx->sha256);
+       git_SHA256_Init(&ctx->state.sha256);
 }
 
 static void git_hash_sha256_clone(git_hash_ctx *dst, const git_hash_ctx *src)
 {
-       git_SHA256_Clone(&dst->sha256, &src->sha256);
+       git_SHA256_Clone(&dst->state.sha256, &src->state.sha256);
 }
 
 static void git_hash_sha256_update(git_hash_ctx *ctx, const void *data, size_t len)
 {
-       git_SHA256_Update(&ctx->sha256, data, len);
+       git_SHA256_Update(&ctx->state.sha256, data, len);
 }
 
 static void git_hash_sha256_final(unsigned char *hash, git_hash_ctx *ctx)
 {
-       git_SHA256_Final(hash, &ctx->sha256);
+       git_SHA256_Final(hash, &ctx->state.sha256);
 }
 
 static void git_hash_sha256_final_oid(struct object_id *oid, git_hash_ctx *ctx)
 {
-       git_SHA256_Final(oid->hash, &ctx->sha256);
+       git_SHA256_Final(oid->hash, &ctx->state.sha256);
        /*
         * This currently does nothing, so the compiler should optimize it out,
         * but keep it in case we extend the hash size again.