core: Make destructors receive the 'struct cu' their object may have been allocated from

The default, most simple way of freeing memory associated with tags is
to just call free(), but the DWARF loader is a bit more involved in
which it needs extra info to keep its large data structures around for
further processing after loading.

This way we need to provide a way for the DWARF loader to find the real
pointer to release.

So far it was just freeing the tag, which ended up leaking the
tag->priv part, i.e. the associated 'struct dwarf_tag', which wasn't
that much of a problem as the bulk of freeing takes place at tool exit,
but since we want to avoid two allocations and get the 'struct
dwarf_tag' out of pointer arithmetic from the 'struct tag' pointer
associated with it in a single allocation, we have to catch all free()
calls with a 'struct cu' specific tag destructor so that we do that
pointer arithmetic and find the right pointer to feed free().

That or just do nothing when we use obstacks, as in the BTF encoder
case.

So this is all for consistency and correctness, it _shouldn't_ affect
the most critical use case which is BTF encoding, where no such use of
destructors take place.

In the process of getting the codebase more correct we are indeed
catching cases where we, in error paths, were calling free() on obstack
allocated memory, which, again, is a corner case, but lets plug all
these to avoid surprises, that, we know, appear from time to time.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

Author: acmel

btf_loader.c

@@ -77,7 +77,7 @@ static int cu__load_ftype(struct cu *cu, struct ftype *proto, uint32_t tag, cons
 
 	return 0;
 out_free_parameters:
-	ftype__delete(proto);
+	ftype__delete(proto, cu);
 	return -ENOMEM;
 }
 
@@ -255,7 +255,7 @@ static int create_new_class(struct cu *cu, const struct btf_type *tp, uint32_t i
 
 	return 0;
 out_free:
-	class__delete(class);
+	class__delete(class, cu);
 	return -ENOMEM;
 }
 
@@ -271,7 +271,7 @@ static int create_new_union(struct cu *cu, const struct btf_type *tp, uint32_t i
 
 	return 0;
 out_free:
-	type__delete(un);
+	type__delete(un, cu);
 	return -ENOMEM;
 }
 
@@ -320,7 +320,7 @@ static int create_new_enumeration(struct cu *cu, const struct btf_type *tp, uint
 
 	return 0;
 out_free:
-	enumeration__delete(enumeration);
+	enumeration__delete(enumeration, cu);
 	return -ENOMEM;
 }
 
@@ -366,7 +366,7 @@ static int create_new_enumeration64(struct cu *cu, const struct btf_type *tp, ui
 
 	return 0;
 out_free:
-	enumeration__delete(enumeration);
+	enumeration__delete(enumeration, cu);
 	return -ENOMEM;
 }
 #else

ctf_loader.c

@@ -34,7 +34,7 @@ static void *tag__alloc(const size_t size)
 	return tag;
 }
 
-static int ctf__load_ftype(struct ctf *ctf, struct ftype *proto, uint16_t tag,
+static int ctf__load_ftype(struct ctf *ctf, struct ftype *proto, struct cu *cu, uint16_t tag,
 			   uint16_t type, uint16_t vlen, uint16_t *args, long id)
 {
 	proto->tag.tag	= tag;
@@ -80,12 +80,12 @@ static int ctf__load_ftype(struct ctf *ctf, struct ftype *proto, uint16_t tag,
 
 	return vlen;
 out_free_parameters:
-	ftype__delete(proto);
+	ftype__delete(proto, cu);
 	return -ENOMEM;
 }
 
 static struct function *function__new(uint16_t **ptr, GElf_Sym *sym,
-				      struct ctf *ctf)
+				      struct ctf *ctf, struct cu *cu)
 {
 	struct function *func = tag__alloc(sizeof(*func));
 
@@ -116,7 +116,7 @@ static struct function *function__new(uint16_t **ptr, GElf_Sym *sym,
 
 		++*ptr;
 
-		if (ctf__load_ftype(ctf, &func->proto, DW_TAG_subprogram,
+		if (ctf__load_ftype(ctf, &func->proto, cu, DW_TAG_subprogram,
 				    type, vlen, *ptr, id) < 0)
 			return NULL;
 		/*
@@ -133,7 +133,7 @@ static struct function *function__new(uint16_t **ptr, GElf_Sym *sym,
 	return NULL;
 }
 
-static int ctf__load_funcs(struct ctf *ctf)
+static int ctf__load_funcs(struct ctf *ctf, struct cu *cu)
 {
 	struct ctf_header *hp = ctf__get_buffer(ctf);
 	uint16_t *func_ptr = (ctf__get_buffer(ctf) + sizeof(*hp) +
@@ -142,7 +142,7 @@ static int ctf__load_funcs(struct ctf *ctf)
 	GElf_Sym sym;
 	uint32_t idx;
 	ctf__for_each_symtab_function(ctf, idx, sym)
-		if (function__new(&func_ptr, &sym, ctf) == NULL)
+		if (function__new(&func_ptr, &sym, ctf, cu) == NULL)
 			return -ENOMEM;
 
 	return 0;
@@ -262,7 +262,7 @@ static int create_new_array(struct ctf *ctf, void *ptr, uint32_t id)
 
 static int create_new_subroutine_type(struct ctf *ctf, void *ptr,
 				      int vlen, struct ctf_full_type *tp,
-				      uint32_t id)
+				      uint32_t id, struct cu *cu)
 {
 	uint16_t *args = ptr;
 	unsigned int type = ctf__get16(ctf, &tp->base.ctf_type);
@@ -271,7 +271,7 @@ static int create_new_subroutine_type(struct ctf *ctf, void *ptr,
 	if (proto == NULL)
 		return -ENOMEM;
 
-	vlen = ctf__load_ftype(ctf, proto, DW_TAG_subroutine_type,
+	vlen = ctf__load_ftype(ctf, proto, cu, DW_TAG_subroutine_type,
 			       type, vlen, args, id);
 	return vlen < 0 ? -ENOMEM : vlen;
 }
@@ -326,7 +326,7 @@ static int create_short_members(struct ctf *ctf, void *ptr,
 
 static int create_new_class(struct ctf *ctf, void *ptr,
 			    int vlen, struct ctf_full_type *tp,
-			    uint64_t size, uint32_t id)
+			    uint64_t size, uint32_t id, struct cu *cu)
 {
 	int member_size;
 	const char *name = ctf__string(ctf, ctf__get32(ctf, &tp->base.ctf_name));
@@ -345,13 +345,13 @@ static int create_new_class(struct ctf *ctf, void *ptr,
 
 	return (vlen * member_size);
 out_free:
-	class__delete(class);
+	class__delete(class, cu);
 	return -ENOMEM;
 }
 
 static int create_new_union(struct ctf *ctf, void *ptr,
 			    int vlen, struct ctf_full_type *tp,
-			    uint64_t size, uint32_t id)
+			    uint64_t size, uint32_t id, struct cu *cu)
 {
 	int member_size;
 	const char *name = ctf__string(ctf, ctf__get32(ctf, &tp->base.ctf_name));
@@ -370,7 +370,7 @@ static int create_new_union(struct ctf *ctf, void *ptr,
 
 	return (vlen * member_size);
 out_free:
-	type__delete(un);
+	type__delete(un, cu);
 	return -ENOMEM;
 }
 
@@ -389,7 +389,7 @@ static struct enumerator *enumerator__new(const char *name, uint32_t value)
 
 static int create_new_enumeration(struct ctf *ctf, void *ptr,
 				  int vlen, struct ctf_full_type *tp,
-				  uint16_t size, uint32_t id)
+				  uint16_t size, uint32_t id, struct cu *cu)
 {
 	struct ctf_enum *ep = ptr;
 	uint16_t i;
@@ -414,7 +414,7 @@ static int create_new_enumeration(struct ctf *ctf, void *ptr,
 
 	return (vlen * sizeof(*ep));
 out_free:
-	enumeration__delete(enumeration);
+	enumeration__delete(enumeration, cu);
 	return -ENOMEM;
 }
 
@@ -473,7 +473,7 @@ static int create_new_tag(struct ctf *ctf, int type,
 	return 0;
 }
 
-static int ctf__load_types(struct ctf *ctf)
+static int ctf__load_types(struct ctf *ctf, struct cu *cu)
 {
 	void *ctf_buffer = ctf__get_buffer(ctf);
 	struct ctf_header *hp = ctf_buffer;
@@ -510,16 +510,16 @@ static int ctf__load_types(struct ctf *ctf)
 		} else if (type == CTF_TYPE_KIND_ARR) {
 			vlen = create_new_array(ctf, ptr, type_index);
 		} else if (type == CTF_TYPE_KIND_FUNC) {
-			vlen = create_new_subroutine_type(ctf, ptr, vlen, type_ptr, type_index);
+			vlen = create_new_subroutine_type(ctf, ptr, vlen, type_ptr, type_index, cu);
 		} else if (type == CTF_TYPE_KIND_STR) {
 			vlen = create_new_class(ctf, ptr,
-						vlen, type_ptr, size, type_index);
+						vlen, type_ptr, size, type_index, cu);
 		} else if (type == CTF_TYPE_KIND_UNION) {
 			vlen = create_new_union(ctf, ptr,
-					        vlen, type_ptr, size, type_index);
+					        vlen, type_ptr, size, type_index, cu);
 		} else if (type == CTF_TYPE_KIND_ENUM) {
 			vlen = create_new_enumeration(ctf, ptr, vlen, type_ptr,
-						      size, type_index);
+						      size, type_index, cu);
 		} else if (type == CTF_TYPE_KIND_FWD) {
 			vlen = create_new_forward_decl(ctf, type_ptr, size, type_index);
 		} else if (type == CTF_TYPE_KIND_TYPDEF) {
@@ -589,15 +589,15 @@ static int ctf__load_objects(struct ctf *ctf)
 	return 0;
 }
 
-static int ctf__load_sections(struct ctf *ctf)
+static int ctf__load_sections(struct ctf *ctf, struct cu *cu)
 {
 	int err = ctf__load_symtab(ctf);
 
 	if (err != 0)
 		goto out;
-	err = ctf__load_funcs(ctf);
+	err = ctf__load_funcs(ctf, cu);
 	if (err == 0)
-		err = ctf__load_types(ctf);
+		err = ctf__load_types(ctf, cu);
 	if (err == 0)
 		err = ctf__load_objects(ctf);
 out:
@@ -716,7 +716,7 @@ int ctf__load_file(struct cus *cus, struct conf_load *conf,
 	if (ctf__load(state) != 0)
 		return -1;
 
-	err = ctf__load_sections(state);
+	err = ctf__load_sections(state, cu);
 
 	if (err != 0) {
 		cu__delete(cu);

ctracer.c

@@ -349,7 +349,7 @@ static struct class *class__clone_base_types(const struct tag *tag,
 {
 	struct class *class = tag__class(tag);
 	struct class_member *pos, *next;
-	struct class *clone = class__clone(class, new_class_name);
+	struct class *clone = class__clone(class, new_class_name, cu);
 
 	if (clone == NULL)
 		return NULL;
@@ -360,7 +360,7 @@ static struct class *class__clone_base_types(const struct tag *tag,
 		tag__assert_search_result(member_type, pos->tag.tag, class_member__name(pos));
 		if (!tag__is_base_type(member_type, cu)) {
 			next = class__remove_member(clone, cu, pos);
-			class_member__delete(pos);
+			class_member__delete(pos, cu);
 		}
 	}
 	class__fixup_alignment(clone, cu);

dwarf_loader.c

@@ -1158,7 +1158,7 @@ static struct template_parameter_pack *template_parameter_pack__new(Dwarf_Die *d
 		INIT_LIST_HEAD(&pack->params);
 
 		if (template_parameter_pack__load_params(pack, die, cu, conf)) {
-			template_parameter_pack__delete(pack);
+			template_parameter_pack__delete(pack, cu);
 			pack = NULL;
 		}
 	}
@@ -1289,7 +1289,7 @@ static struct formal_parameter_pack *formal_parameter_pack__new(Dwarf_Die *die,
 		INIT_LIST_HEAD(&pack->params);
 
 		if (formal_parameter_pack__load_params(pack, die, cu, conf)) {
-			formal_parameter_pack__delete(pack);
+			formal_parameter_pack__delete(pack, cu);
 			pack = NULL;
 		}
 	}
@@ -1606,7 +1606,7 @@ static struct tag *die__create_new_class(Dwarf_Die *die, struct cu *cu, struct c
 	    dwarf_haschildren(die) != 0 &&
 	    dwarf_child(die, &child) == 0) {
 		if (die__process_class(&child, &class->type, cu, conf) != 0) {
-			class__delete(class);
+			class__delete(class, cu);
 			class = NULL;
 		}
 	}
@@ -1626,7 +1626,7 @@ static struct tag *die__create_new_namespace(Dwarf_Die *die, struct cu *cu, stru
 	    dwarf_haschildren(die) != 0 &&
 	    dwarf_child(die, &child) == 0) {
 		if (die__process_namespace(&child, namespace, cu, conf) != 0) {
-			namespace__delete(namespace);
+			namespace__delete(namespace, cu);
 			namespace = NULL;
 		}
 	}
@@ -1643,7 +1643,7 @@ static struct tag *die__create_new_union(Dwarf_Die *die, struct cu *cu, struct c
 	    dwarf_haschildren(die) != 0 &&
 	    dwarf_child(die, &child) == 0) {
 		if (die__process_class(&child, utype, cu, conf) != 0) {
-			type__delete(utype);
+			type__delete(utype, cu);
 			utype = NULL;
 		}
 	}
@@ -1854,9 +1854,9 @@ static struct tag *die__create_new_subroutine_type(Dwarf_Die *die,
 out:
 	return &ftype->tag;
 out_delete_tag:
-	tag__delete(tag);
+	tag__delete(tag, cu);
 out_delete:
-	ftype__delete(ftype);
+	ftype__delete(ftype, cu);
 	return NULL;
 }
 
@@ -1897,7 +1897,7 @@ static struct tag *die__create_new_enumeration(Dwarf_Die *die, struct cu *cu, st
 out:
 	return &enumeration->namespace.tag;
 out_delete:
-	enumeration__delete(enumeration);
+	enumeration__delete(enumeration, cu);
 	return NULL;
 }
 
@@ -1960,7 +1960,7 @@ static int die__process_class(Dwarf_Die *die, struct type *class,
 				uint32_t id;
 
 				if (cu__table_add_tag(cu, &member->tag, &id) < 0) {
-					class_member__delete(member);
+					class_member__delete(member, cu);
 					return -ENOMEM;
 				}
 
@@ -1993,7 +1993,7 @@ static int die__process_class(Dwarf_Die *die, struct type *class,
 			uint32_t id;
 
 			if (cu__table_add_tag(cu, tag, &id) < 0) {
-				tag__delete(tag);
+				tag__delete(tag, cu);
 				return -ENOMEM;
 			}
 
@@ -2043,7 +2043,7 @@ static int die__process_namespace(Dwarf_Die *die, struct namespace *namespace,
 
 	return 0;
 out_delete_tag:
-	tag__delete(tag);
+	tag__delete(tag, cu);
 out_enomem:
 	return -ENOMEM;
 }
@@ -2064,7 +2064,7 @@ static int die__create_new_lexblock(Dwarf_Die *die,
 		lexblock__add_lexblock(father, lexblock);
 	return 0;
 out_delete:
-	lexblock__delete(lexblock);
+	lexblock__delete(lexblock, cu);
 	return -ENOMEM;
 }
 
@@ -2152,7 +2152,7 @@ static int die__process_inline_expansion(Dwarf_Die *die, struct lexblock *lexblo
 
 	return 0;
 out_delete_tag:
-	tag__delete(tag);
+	tag__delete(tag, cu);
 out_enomem:
 	return -ENOMEM;
 }
@@ -2314,7 +2314,7 @@ static int die__process_function(Dwarf_Die *die, struct ftype *ftype,
 
 	return 0;
 out_delete_tag:
-	tag__delete(tag);
+	tag__delete(tag, cu);
 out_enomem:
 	return -ENOMEM;
 }
@@ -2325,7 +2325,7 @@ static struct tag *die__create_new_function(Dwarf_Die *die, struct cu *cu, struc
 
 	if (function != NULL &&
 	    die__process_function(die, &function->proto, &function->lexblock, cu, conf) != 0) {
-		function__delete(function);
+		function__delete(function, cu);
 		function = NULL;
 	}