move setting of object->type to alloc_* functions

The "struct object" type implements basic object
polymorphism.  Individual instances are allocated as
concrete types (or as a union type that can store any
object), and a "struct object *" can be cast into its real
type after examining its "type" enum.  This means it is
dangerous to have a type field that does not match the
allocation (e.g., setting the type field of a "struct blob"
to "OBJ_COMMIT" would mean that a reader might read past the
allocated memory).

In most of the current code this is not a problem; the first
thing we do after allocating an object is usually to set its
type field by passing it to create_object. However, the
virtual commits we create in merge-recursive.c do not ever
get their type set. This does not seem to have caused
problems in practice, though (presumably because we always
pass around a "struct commit" pointer and never even look at
the type).

We can fix this oversight and also make it harder for future
code to get it wrong by setting the type directly in the
object allocation functions.

This will also make it easier to fix problems with commit
index allocation, as we know that any object allocated by
alloc_commit_node will meet the invariant that an object
with an OBJ_COMMIT type field will have a unique index
number.

Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/alloc.c b/alloc.c
index 03e458bad02329927fffa12180122253c4671fc8..fd2e32df8c472d36043e0a389f5022b990600f77 100644 (file)
--- a/alloc.c
+++ b/alloc.c
@@ -52,6 +52,7 @@ static struct alloc_state blob_state;
 void *alloc_blob_node(void)
 {
        struct blob *b = alloc_node(&blob_state, sizeof(struct blob));
+       b->object.type = OBJ_BLOB;
        return b;
 }
 
@@ -59,6 +60,7 @@ static struct alloc_state tree_state;
 void *alloc_tree_node(void)
 {
        struct tree *t = alloc_node(&tree_state, sizeof(struct tree));
+       t->object.type = OBJ_TREE;
        return t;
 }
 
@@ -66,6 +68,7 @@ static struct alloc_state tag_state;
 void *alloc_tag_node(void)
 {
        struct tag *t = alloc_node(&tag_state, sizeof(struct tag));
+       t->object.type = OBJ_TAG;
        return t;
 }
 
@@ -73,6 +76,7 @@ static struct alloc_state object_state;
 void *alloc_object_node(void)
 {
        struct object *obj = alloc_node(&object_state, sizeof(union any_object));
+       obj->type = OBJ_NONE;
        return obj;
 }
 
@@ -82,6 +86,7 @@ void *alloc_commit_node(void)
 {
        static int commit_count;
        struct commit *c = alloc_node(&commit_state, sizeof(struct commit));
+       c->object.type = OBJ_COMMIT;
        c->index = commit_count++;
        return c;
 }

diff --git a/blob.c b/blob.c
index ae320bd8fa22aaaef8144bd6bc35c20d1e85e4f4..5720a38ca270b48f2dde81472cee3642f72d89f6 100644 (file)
--- a/blob.c
+++ b/blob.c
@@ -7,7 +7,7 @@ struct blob *lookup_blob(const unsigned char *sha1)
 {
        struct object *obj = lookup_object(sha1);
        if (!obj)
-               return create_object(sha1, OBJ_BLOB, alloc_blob_node());
+               return create_object(sha1, alloc_blob_node());
        if (!obj->type)
                obj->type = OBJ_BLOB;
        if (obj->type != OBJ_BLOB) {

diff --git a/builtin/blame.c b/builtin/blame.c
index 6a284ce46b4f3b46a47d033fca607cae710806bc..eefd6bc2e1576cf9a113fbeac11945458899c110 100644 (file)
--- a/builtin/blame.c
+++ b/builtin/blame.c
@@ -2041,7 +2041,6 @@ static struct commit *fake_working_tree_commit(struct diff_options *opt,
        commit = alloc_commit_node();
        commit->object.parsed = 1;
        commit->date = now;
-       commit->object.type = OBJ_COMMIT;
        parent_tail = &commit->parents;
 
        if (!resolve_ref_unsafe("HEAD", head_sha1, 1, NULL))

diff --git a/commit.c b/commit.c
index 4ff8077dbfbc6cdd6c14728a3d33a78d075c236f..eb24add86688705901ba0b71a7f025289df03c9d 100644 (file)
--- a/commit.c
+++ b/commit.c
@@ -61,10 +61,8 @@ struct commit *lookup_commit_or_die(const unsigned char *sha1, const char *ref_n
 struct commit *lookup_commit(const unsigned char *sha1)
 {
        struct object *obj = lookup_object(sha1);
-       if (!obj) {
-               struct commit *c = alloc_commit_node();
-               return create_object(sha1, OBJ_COMMIT, c);
-       }
+       if (!obj)
+               return create_object(sha1, alloc_commit_node());
        if (!obj->type)
                obj->type = OBJ_COMMIT;
        return check_commit(obj, sha1, 0);

diff --git a/object.c b/object.c
index 9c31e9a5e0e0d913044501089e09037e47894f03..a950b851469def4abd09dd58d360573c4fc6ee74 100644 (file)
--- a/object.c
+++ b/object.c
@@ -141,13 +141,12 @@ static void grow_object_hash(void)
        obj_hash_size = new_hash_size;
 }
 
-void *create_object(const unsigned char *sha1, int type, void *o)
+void *create_object(const unsigned char *sha1, void *o)
 {
        struct object *obj = o;
 
        obj->parsed = 0;
        obj->used = 0;
-       obj->type = type;
        obj->flags = 0;
        hashcpy(obj->sha1, sha1);
 
@@ -163,7 +162,7 @@ struct object *lookup_unknown_object(const unsigned char *sha1)
 {
        struct object *obj = lookup_object(sha1);
        if (!obj)
-               obj = create_object(sha1, OBJ_NONE, alloc_object_node());
+               obj = create_object(sha1, alloc_object_node());
        return obj;
 }
 

diff --git a/object.h b/object.h
index 6e12f2c7f4582b5121a4be18be5fedaecd30f38f..8020ace566c9c826a907490ac57c4d5aa425c2ae 100644 (file)
--- a/object.h
+++ b/object.h
@@ -79,7 +79,7 @@ extern struct object *get_indexed_object(unsigned int);
  */
 struct object *lookup_object(const unsigned char *sha1);
 
-extern void *create_object(const unsigned char *sha1, int type, void *obj);
+extern void *create_object(const unsigned char *sha1, void *obj);
 
 /*
  * Returns the object, having parsed it to find out what it is.

diff --git a/tag.c b/tag.c
index 7b07921b30641994ab3a877b6b377c5ce1f40149..79552c716cf63d454d6fdcd75845db91c609c92a 100644 (file)
--- a/tag.c
+++ b/tag.c
@@ -40,7 +40,7 @@ struct tag *lookup_tag(const unsigned char *sha1)
 {
        struct object *obj = lookup_object(sha1);
        if (!obj)
-               return create_object(sha1, OBJ_TAG, alloc_tag_node());
+               return create_object(sha1, alloc_tag_node());
        if (!obj->type)
                obj->type = OBJ_TAG;
        if (obj->type != OBJ_TAG) {

diff --git a/tree.c b/tree.c
index c8c49d7b78174199da94d802e1ca7037866b5f04..ed6657507937b26c702ff322b99182c688487d50 100644 (file)
--- a/tree.c
+++ b/tree.c
@@ -183,7 +183,7 @@ struct tree *lookup_tree(const unsigned char *sha1)
 {
        struct object *obj = lookup_object(sha1);
        if (!obj)
-               return create_object(sha1, OBJ_TREE, alloc_tree_node());
+               return create_object(sha1, alloc_tree_node());
        if (!obj->type)
                obj->type = OBJ_TREE;
        if (obj->type != OBJ_TREE) {