move setting of object->type to alloc_* functions

peff · gitster · commit fe24d396e1b8 · 2014-07-28T10:14:33.000-07:00
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 &lt;peff@peff.net&gt;
Signed-off-by: Junio C Hamano &lt;gitster@pobox.com&gt;
diff --git a/alloc.c b/alloc.c
@@ -52,27 +52,31 @@ 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;
 }
 
 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;
 }
 
 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;
 }
 
 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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) {

Original file line number	Diff line number	Diff line change
`@@ -52,27 +52,31 @@ static struct alloc_state blob_state;`
`52`	`52`	`void *alloc_blob_node(void)`
`53`	`53`	`{`
`54`	`54`	`struct blob *b = alloc_node(&blob_state, sizeof(struct blob));`
	`55`	`+ b->object.type = OBJ_BLOB;`
`55`	`56`	`return b;`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`static struct alloc_state tree_state;`
`59`	`60`	`void *alloc_tree_node(void)`
`60`	`61`	`{`
`61`	`62`	`struct tree *t = alloc_node(&tree_state, sizeof(struct tree));`
	`63`	`+ t->object.type = OBJ_TREE;`
`62`	`64`	`return t;`
`63`	`65`	`}`
`64`	`66`
`65`	`67`	`static struct alloc_state tag_state;`
`66`	`68`	`void *alloc_tag_node(void)`
`67`	`69`	`{`
`68`	`70`	`struct tag *t = alloc_node(&tag_state, sizeof(struct tag));`
	`71`	`+ t->object.type = OBJ_TAG;`
`69`	`72`	`return t;`
`70`	`73`	`}`
`71`	`74`
`72`	`75`	`static struct alloc_state object_state;`
`73`	`76`	`void *alloc_object_node(void)`
`74`	`77`	`{`
`75`	`78`	`struct object *obj = alloc_node(&object_state, sizeof(union any_object));`
	`79`	`+ obj->type = OBJ_NONE;`
`76`	`80`	`return obj;`
`77`	`81`	`}`
`78`	`82`
`@@ -82,6 +86,7 @@ void *alloc_commit_node(void)`
`82`	`86`	`{`
`83`	`87`	`static int commit_count;`
`84`	`88`	`struct commit *c = alloc_node(&commit_state, sizeof(struct commit));`
	`89`	`+ c->object.type = OBJ_COMMIT;`
`85`	`90`	`c->index = commit_count++;`
`86`	`91`	`return c;`
`87`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ struct blob lookup_blob(const unsigned char sha1)`
`7`	`7`	`{`
`8`	`8`	`struct object *obj = lookup_object(sha1);`
`9`	`9`	`if (!obj)`
`10`		`- return create_object(sha1, OBJ_BLOB, alloc_blob_node());`
	`10`	`+ return create_object(sha1, alloc_blob_node());`
`11`	`11`	`if (!obj->type)`
`12`	`12`	`obj->type = OBJ_BLOB;`
`13`	`13`	`if (obj->type != OBJ_BLOB) {`
Original file line number	Diff line number	Diff line change
`@@ -141,13 +141,12 @@ static void grow_object_hash(void)`
`141`	`141`	`obj_hash_size = new_hash_size;`
`142`	`142`	`}`
`143`	`143`
`144`		`-void create_object(const unsigned char sha1, int type, void *o)`
	`144`	`+void create_object(const unsigned char sha1, void *o)`
`145`	`145`	`{`
`146`	`146`	`struct object *obj = o;`
`147`	`147`
`148`	`148`	`obj->parsed = 0;`
`149`	`149`	`obj->used = 0;`
`150`		`- obj->type = type;`
`151`	`150`	`obj->flags = 0;`
`152`	`151`	`hashcpy(obj->sha1, sha1);`
`153`	`152`
`@@ -163,7 +162,7 @@ struct object lookup_unknown_object(const unsigned char sha1)`
`163`	`162`	`{`
`164`	`163`	`struct object *obj = lookup_object(sha1);`
`165`	`164`	`if (!obj)`
`166`		`- obj = create_object(sha1, OBJ_NONE, alloc_object_node());`
	`165`	`+ obj = create_object(sha1, alloc_object_node());`
`167`	`166`	`return obj;`
`168`	`167`	`}`
`169`	`168`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ struct tag lookup_tag(const unsigned char sha1)`
`40`	`40`	`{`
`41`	`41`	`struct object *obj = lookup_object(sha1);`
`42`	`42`	`if (!obj)`
`43`		`- return create_object(sha1, OBJ_TAG, alloc_tag_node());`
	`43`	`+ return create_object(sha1, alloc_tag_node());`
`44`	`44`	`if (!obj->type)`
`45`	`45`	`obj->type = OBJ_TAG;`
`46`	`46`	`if (obj->type != OBJ_TAG) {`
Original file line number	Diff line number	Diff line change
`@@ -183,7 +183,7 @@ struct tree lookup_tree(const unsigned char sha1)`
`183`	`183`	`{`
`184`	`184`	`struct object *obj = lookup_object(sha1);`
`185`	`185`	`if (!obj)`
`186`		`- return create_object(sha1, OBJ_TREE, alloc_tree_node());`
	`186`	`+ return create_object(sha1, alloc_tree_node());`
`187`	`187`	`if (!obj->type)`
`188`	`188`	`obj->type = OBJ_TREE;`
`189`	`189`	`if (obj->type != OBJ_TREE) {`