dwarves_emit.c - platform/external/dwarves - Git at Google

 /*
   SPDX-License-Identifier: GPL-2.0-only

   Copyright (C) 2006 Mandriva Conectiva S.A.
   Copyright (C) 2006 Arnaldo Carvalho de Melo <acme@mandriva.com>
   Copyright (C) 2007 Red Hat Inc.
   Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
 */

 #include <string.h>

 #include "list.h"
 #include "dwarves_emit.h"
 #include "dwarves.h"

 void type_emissions__init(struct type_emissions *emissions)
 {
 	INIT_LIST_HEAD(&emissions->definitions);
 	INIT_LIST_HEAD(&emissions->fwd_decls);
 }

 static void type_emissions__add_definition(struct type_emissions *emissions,
 					   struct type *type)
 {
 	type->definition_emitted = 1;
 	if (!list_empty(&type->node))
 		list_del(&type->node);
 	list_add_tail(&type->node, &emissions->definitions);
 }

 static void type_emissions__add_fwd_decl(struct type_emissions *emissions,
 					 struct type *type)
 {
 	type->fwd_decl_emitted = 1;
 	if (list_empty(&type->node))
 		list_add_tail(&type->node, &emissions->fwd_decls);
 }

 struct type *type_emissions__find_definition(const struct type_emissions *emissions,
 					     const struct cu *cu,
 					     const char *name)
 {
 	struct type *pos;

 	if (name == NULL)
 		return NULL;

 	list_for_each_entry(pos, &emissions->definitions, node)
 		if (type__name(pos, cu) != NULL &&
 		    strcmp(type__name(pos, cu), name) == 0)
 			return pos;

 	return NULL;
 }

 static struct type *type_emissions__find_fwd_decl(const struct type_emissions *emissions,
 						  const struct cu *cu,
 						  const char *name)
 {
 	struct type *pos;

 	if (name == NULL)
 		return NULL;

 	list_for_each_entry(pos, &emissions->fwd_decls, node) {
 		const char *curr_name = type__name(pos, cu);

 		if (curr_name && strcmp(curr_name, name) == 0)
 			return pos;
 	}

 	return NULL;
 }

 static int enumeration__emit_definitions(struct tag *tag, struct cu *cu,
 					 struct type_emissions *emissions,
 					 const struct conf_fprintf *conf,
 					 FILE *fp)
 {
 	struct type *etype = tag__type(tag);

 	/* Have we already emitted this in this CU? */
 	if (etype->definition_emitted)
 		return 0;

 	/* Ok, lets look at the previous CUs: */
 	if (type_emissions__find_definition(emissions, cu,
 					    type__name(etype, cu)) != NULL) {
 		/*
 		 * Yes, so lets mark it visited on this CU too,
 		 * to speed up the lookup.
 		 */
 		etype->definition_emitted = 1;
 		return 0;
 	}

 	enumeration__fprintf(tag, cu, conf, fp);
 	fputs(";\n", fp);
 	type_emissions__add_definition(emissions, etype);
 	return 1;
 }

 static int tag__emit_definitions(struct tag *tag, struct cu *cu,
 				 struct type_emissions *emissions, FILE *fp);

 static int typedef__emit_definitions(struct tag *tdef, struct cu *cu,
 				     struct type_emissions *emissions, FILE *fp)
 {
 	struct type *def = tag__type(tdef);
 	struct tag *type, *ptr_type;

 	/* Have we already emitted this in this CU? */
 	if (def->definition_emitted)
 		return 0;

 	/* Ok, lets look at the previous CUs: */
 	if (type_emissions__find_definition(emissions, cu,
 					    type__name(def, cu)) != NULL) {
 		/*
 		 * Yes, so lets mark it visited on this CU too,
 		 * to speed up the lookup.
 		 */
 		def->definition_emitted = 1;
 		return 0;
 	}

 	type = cu__type(cu, tdef->type);
 	tag__assert_search_result(type);

 	switch (type->tag) {
 	case DW_TAG_array_type:
 		tag__emit_definitions(type, cu, emissions, fp);
 		break;
 	case DW_TAG_typedef:
 		typedef__emit_definitions(type, cu, emissions, fp);
 		break;
 	case DW_TAG_pointer_type:
 		ptr_type = cu__type(cu, type->type);
 		/* void ** can make ptr_type be NULL */
 		if (ptr_type == NULL)
 			break;
 		if (ptr_type->tag == DW_TAG_typedef) {
 			typedef__emit_definitions(ptr_type, cu, emissions, fp);
 			break;
 		} else if (ptr_type->tag != DW_TAG_subroutine_type)
 			break;
 		type = ptr_type;
 		/* Fall thru */
 	case DW_TAG_subroutine_type:
 		ftype__emit_definitions(tag__ftype(type), cu, emissions, fp);
 		break;
 	case DW_TAG_enumeration_type: {
 		struct type *ctype = tag__type(type);
 		struct conf_fprintf conf = {
 			.suffix = NULL,
 		};

 		if (type__name(ctype, cu) == NULL) {
 			fputs("typedef ", fp);
 			conf.suffix = type__name(def, cu);
 			enumeration__emit_definitions(type, cu, emissions,
 						      &conf, fp);
 			goto out;
 		} else
 			enumeration__emit_definitions(type, cu, emissions,
 						      &conf, fp);
 	}
 		break;
 	case DW_TAG_structure_type:
 	case DW_TAG_union_type: {
 		struct type *ctype = tag__type(type);

 		if (type__name(ctype, cu) == NULL) {
 			if (type__emit_definitions(type, cu, emissions, fp))
 				type__emit(type, cu, "typedef",
 					   type__name(def, cu), fp);
 			goto out;
 		} else if (type__emit_definitions(type, cu, emissions, fp))
 			type__emit(type, cu, NULL, NULL, fp);
 	}
 	}

 	/*
 	 * Recheck if the typedef was emitted, as there are cases, like
 	 * wait_queue_t in the Linux kernel, that is against struct
 	 * __wait_queue, that has a wait_queue_func_t member, a function
 	 * typedef that has as one of its parameters a... wait_queue_t, that
 	 * will thus be emitted before the function typedef, making a no go to
 	 * redefine the typedef after struct __wait_queue.
 	 */
 	if (!def->definition_emitted) {
 		typedef__fprintf(tdef, cu, NULL, fp);
 		fputs(";\n", fp);
 	}
 out:
 	type_emissions__add_definition(emissions, def);
 	return 1;
 }

 int type__emit_fwd_decl(struct type *ctype, const struct cu *cu,
 			struct type_emissions *emissions, FILE *fp)
 {
 	/* Have we already emitted this in this CU? */
 	if (ctype->fwd_decl_emitted)
 		return 0;

 	const char *name = type__name(ctype, cu);
 	if (name == NULL)
 		return 0;

 	/* Ok, lets look at the previous CUs: */
 	if (type_emissions__find_fwd_decl(emissions, cu, name) != NULL) {
 		/*
 		 * Yes, so lets mark it visited on this CU too,
 		 * to speed up the lookup.
 		 */
 		ctype->fwd_decl_emitted = 1;
 		return 0;
 	}

 	fprintf(fp, "%s %s;\n",
 		tag__is_union(&ctype->namespace.tag) ? "union" : "struct",
 		type__name(ctype, cu));
 	type_emissions__add_fwd_decl(emissions, ctype);
 	return 1;
 }

 static int tag__emit_definitions(struct tag *tag, struct cu *cu,
 				 struct type_emissions *emissions, FILE *fp)
 {
 	struct tag *type = cu__type(cu, tag->type);
 	int pointer = 0;

 	if (type == NULL)
 		return 0;
 next_indirection:
 	switch (type->tag) {
 	case DW_TAG_pointer_type:
 	case DW_TAG_reference_type:
 		pointer = 1;
 		/* Fall thru */
 	case DW_TAG_array_type:
 	case DW_TAG_const_type:
 	case DW_TAG_volatile_type:
 		type = cu__type(cu, type->type);
 		if (type == NULL)
 			return 0;
 		goto next_indirection;
 	case DW_TAG_typedef:
 		return typedef__emit_definitions(type, cu, emissions, fp);
 	case DW_TAG_enumeration_type:
 		if (type__name(tag__type(type), cu) != NULL) {
 			struct conf_fprintf conf = {
 				.suffix = NULL,
 			};
 			return enumeration__emit_definitions(type, cu, emissions,
 							     &conf, fp);
 		}
 		break;
 	case DW_TAG_structure_type:
 	case DW_TAG_union_type:
 		if (pointer) {
 			/*
 			 * Struct defined inline, no name, need to have its
 			 * members types emitted.
 			 */
 			if (type__name(tag__type(type), cu) == NULL)
 				type__emit_definitions(type, cu, emissions, fp);

 			return type__emit_fwd_decl(tag__type(type), cu,
 						   emissions, fp);
 		}
 		if (type__emit_definitions(type, cu, emissions, fp))
 			type__emit(type, cu, NULL, NULL, fp);
 		return 1;
 	case DW_TAG_subroutine_type:
 		return ftype__emit_definitions(tag__ftype(type), cu,
 					       emissions, fp);
 	}

 	return 0;
 }

 int ftype__emit_definitions(struct ftype *ftype, struct cu *cu,
 			    struct type_emissions *emissions, FILE *fp)
 {
 	struct parameter *pos;
 	/* First check the function return type */
 	int printed = tag__emit_definitions(&ftype->tag, cu, emissions, fp);

 	/* Then its parameters */
 	list_for_each_entry(pos, &ftype->parms, tag.node)
 		if (tag__emit_definitions(&pos->tag, cu, emissions, fp))
 			printed = 1;

 	if (printed)
 		fputc('\n', fp);
 	return printed;
 }

 int type__emit_definitions(struct tag *tag, struct cu *cu,
 			   struct type_emissions *emissions, FILE *fp)
 {
 	struct type *ctype = tag__type(tag);
 	struct class_member *pos;

 	if (ctype->definition_emitted)
 		return 0;

 	/* Ok, lets look at the previous CUs: */
 	if (type_emissions__find_definition(emissions, cu,
 					    type__name(ctype, cu)) != NULL) {
 		ctype->definition_emitted = 1;
 		return 0;
 	}

 	if (tag__is_typedef(tag))
 		return typedef__emit_definitions(tag, cu, emissions, fp);

 	type_emissions__add_definition(emissions, ctype);

 	type__check_structs_at_unnatural_alignments(ctype, cu);

 	type__for_each_member(ctype, pos)
 		if (tag__emit_definitions(&pos->tag, cu, emissions, fp))
 			fputc('\n', fp);

 	return 1;
 }

 void type__emit(struct tag *tag, struct cu *cu,
 		const char *prefix, const char *suffix, FILE *fp)
 {
 	struct type *ctype = tag__type(tag);

 	if (type__name(ctype, cu) != NULL ||
 	    suffix != NULL || prefix != NULL) {
 		struct conf_fprintf conf = {
 			.prefix	    = prefix,
 			.suffix	    = suffix,
 			.emit_stats = 1,
 		};
 		tag__fprintf(tag, cu, &conf, fp);
 		fputc('\n', fp);
 	}
 }
	/*
	SPDX-License-Identifier: GPL-2.0-only

	Copyright (C) 2006 Mandriva Conectiva S.A.
	Copyright (C) 2006 Arnaldo Carvalho de Melo <acme@mandriva.com>
	Copyright (C) 2007 Red Hat Inc.
	Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
	*/

	#include <string.h>

	#include "list.h"
	#include "dwarves_emit.h"
	#include "dwarves.h"

	void type_emissions__init(struct type_emissions *emissions)
	{
	INIT_LIST_HEAD(&emissions->definitions);
	INIT_LIST_HEAD(&emissions->fwd_decls);
	}

	static void type_emissions__add_definition(struct type_emissions *emissions,
	struct type *type)
	{
	type->definition_emitted = 1;
	if (!list_empty(&type->node))
	list_del(&type->node);
	list_add_tail(&type->node, &emissions->definitions);
	}

	static void type_emissions__add_fwd_decl(struct type_emissions *emissions,
	struct type *type)
	{
	type->fwd_decl_emitted = 1;
	if (list_empty(&type->node))
	list_add_tail(&type->node, &emissions->fwd_decls);
	}

	struct type type_emissions__find_definition(const struct type_emissions emissions,
	const struct cu *cu,
	const char *name)
	{
	struct type *pos;

	if (name == NULL)
	return NULL;

	list_for_each_entry(pos, &emissions->definitions, node)
	if (type__name(pos, cu) != NULL &&
	strcmp(type__name(pos, cu), name) == 0)
	return pos;

	return NULL;
	}

	static struct type type_emissions__find_fwd_decl(const struct type_emissions emissions,
	const struct cu *cu,
	const char *name)
	{
	struct type *pos;

	if (name == NULL)
	return NULL;

	list_for_each_entry(pos, &emissions->fwd_decls, node) {
	const char *curr_name = type__name(pos, cu);

	if (curr_name && strcmp(curr_name, name) == 0)
	return pos;
	}

	return NULL;
	}

	static int enumeration__emit_definitions(struct tag tag, struct cu cu,
	struct type_emissions *emissions,
	const struct conf_fprintf *conf,
	FILE *fp)
	{
	struct type *etype = tag__type(tag);

	/* Have we already emitted this in this CU? */
	if (etype->definition_emitted)
	return 0;

	/* Ok, lets look at the previous CUs: */
	if (type_emissions__find_definition(emissions, cu,
	type__name(etype, cu)) != NULL) {
	/*
	* Yes, so lets mark it visited on this CU too,
	* to speed up the lookup.
	*/
	etype->definition_emitted = 1;
	return 0;
	}

	enumeration__fprintf(tag, cu, conf, fp);
	fputs(";\n", fp);
	type_emissions__add_definition(emissions, etype);
	return 1;
	}

	static int tag__emit_definitions(struct tag tag, struct cu cu,
	struct type_emissions emissions, FILE fp);

	static int typedef__emit_definitions(struct tag tdef, struct cu cu,
	struct type_emissions emissions, FILE fp)
	{
	struct type *def = tag__type(tdef);
	struct tag type, ptr_type;

	/* Have we already emitted this in this CU? */
	if (def->definition_emitted)
	return 0;

	/* Ok, lets look at the previous CUs: */
	if (type_emissions__find_definition(emissions, cu,
	type__name(def, cu)) != NULL) {
	/*
	* Yes, so lets mark it visited on this CU too,
	* to speed up the lookup.
	*/
	def->definition_emitted = 1;
	return 0;
	}

	type = cu__type(cu, tdef->type);
	tag__assert_search_result(type);

	switch (type->tag) {
	case DW_TAG_array_type:
	tag__emit_definitions(type, cu, emissions, fp);
	break;
	case DW_TAG_typedef:
	typedef__emit_definitions(type, cu, emissions, fp);
	break;
	case DW_TAG_pointer_type:
	ptr_type = cu__type(cu, type->type);
	/* void ** can make ptr_type be NULL */
	if (ptr_type == NULL)
	break;
	if (ptr_type->tag == DW_TAG_typedef) {
	typedef__emit_definitions(ptr_type, cu, emissions, fp);
	break;
	} else if (ptr_type->tag != DW_TAG_subroutine_type)
	break;
	type = ptr_type;
	/* Fall thru */
	case DW_TAG_subroutine_type:
	ftype__emit_definitions(tag__ftype(type), cu, emissions, fp);
	break;
	case DW_TAG_enumeration_type: {
	struct type *ctype = tag__type(type);
	struct conf_fprintf conf = {
	.suffix = NULL,
	};

	if (type__name(ctype, cu) == NULL) {
	fputs("typedef ", fp);
	conf.suffix = type__name(def, cu);
	enumeration__emit_definitions(type, cu, emissions,
	&conf, fp);
	goto out;
	} else
	enumeration__emit_definitions(type, cu, emissions,
	&conf, fp);
	}
	break;
	case DW_TAG_structure_type:
	case DW_TAG_union_type: {
	struct type *ctype = tag__type(type);

	if (type__name(ctype, cu) == NULL) {
	if (type__emit_definitions(type, cu, emissions, fp))
	type__emit(type, cu, "typedef",
	type__name(def, cu), fp);
	goto out;
	} else if (type__emit_definitions(type, cu, emissions, fp))
	type__emit(type, cu, NULL, NULL, fp);
	}
	}

	/*
	* Recheck if the typedef was emitted, as there are cases, like
	* wait_queue_t in the Linux kernel, that is against struct
	* __wait_queue, that has a wait_queue_func_t member, a function
	* typedef that has as one of its parameters a... wait_queue_t, that
	* will thus be emitted before the function typedef, making a no go to
	* redefine the typedef after struct __wait_queue.
	*/
	if (!def->definition_emitted) {
	typedef__fprintf(tdef, cu, NULL, fp);
	fputs(";\n", fp);
	}
	out:
	type_emissions__add_definition(emissions, def);
	return 1;
	}

	int type__emit_fwd_decl(struct type ctype, const struct cu cu,
	struct type_emissions emissions, FILE fp)
	{
	/* Have we already emitted this in this CU? */
	if (ctype->fwd_decl_emitted)
	return 0;

	const char *name = type__name(ctype, cu);
	if (name == NULL)
	return 0;

	/* Ok, lets look at the previous CUs: */
	if (type_emissions__find_fwd_decl(emissions, cu, name) != NULL) {
	/*
	* Yes, so lets mark it visited on this CU too,
	* to speed up the lookup.
	*/
	ctype->fwd_decl_emitted = 1;
	return 0;
	}

	fprintf(fp, "%s %s;\n",
	tag__is_union(&ctype->namespace.tag) ? "union" : "struct",
	type__name(ctype, cu));
	type_emissions__add_fwd_decl(emissions, ctype);
	return 1;
	}

	static int tag__emit_definitions(struct tag tag, struct cu cu,
	struct type_emissions emissions, FILE fp)
	{
	struct tag *type = cu__type(cu, tag->type);
	int pointer = 0;

	if (type == NULL)
	return 0;
	next_indirection:
	switch (type->tag) {
	case DW_TAG_pointer_type:
	case DW_TAG_reference_type:
	pointer = 1;
	/* Fall thru */
	case DW_TAG_array_type:
	case DW_TAG_const_type:
	case DW_TAG_volatile_type:
	type = cu__type(cu, type->type);
	if (type == NULL)
	return 0;
	goto next_indirection;
	case DW_TAG_typedef:
	return typedef__emit_definitions(type, cu, emissions, fp);
	case DW_TAG_enumeration_type:
	if (type__name(tag__type(type), cu) != NULL) {
	struct conf_fprintf conf = {
	.suffix = NULL,
	};
	return enumeration__emit_definitions(type, cu, emissions,
	&conf, fp);
	}
	break;
	case DW_TAG_structure_type:
	case DW_TAG_union_type:
	if (pointer) {
	/*
	* Struct defined inline, no name, need to have its
	* members types emitted.
	*/
	if (type__name(tag__type(type), cu) == NULL)
	type__emit_definitions(type, cu, emissions, fp);

	return type__emit_fwd_decl(tag__type(type), cu,
	emissions, fp);
	}
	if (type__emit_definitions(type, cu, emissions, fp))
	type__emit(type, cu, NULL, NULL, fp);
	return 1;
	case DW_TAG_subroutine_type:
	return ftype__emit_definitions(tag__ftype(type), cu,
	emissions, fp);
	}

	return 0;
	}

	int ftype__emit_definitions(struct ftype ftype, struct cu cu,
	struct type_emissions emissions, FILE fp)
	{
	struct parameter *pos;
	/* First check the function return type */
	int printed = tag__emit_definitions(&ftype->tag, cu, emissions, fp);

	/* Then its parameters */
	list_for_each_entry(pos, &ftype->parms, tag.node)
	if (tag__emit_definitions(&pos->tag, cu, emissions, fp))
	printed = 1;

	if (printed)
	fputc('\n', fp);
	return printed;
	}

	int type__emit_definitions(struct tag tag, struct cu cu,
	struct type_emissions emissions, FILE fp)
	{
	struct type *ctype = tag__type(tag);
	struct class_member *pos;

	if (ctype->definition_emitted)
	return 0;

	/* Ok, lets look at the previous CUs: */
	if (type_emissions__find_definition(emissions, cu,
	type__name(ctype, cu)) != NULL) {
	ctype->definition_emitted = 1;
	return 0;
	}

	if (tag__is_typedef(tag))
	return typedef__emit_definitions(tag, cu, emissions, fp);

	type_emissions__add_definition(emissions, ctype);

	type__check_structs_at_unnatural_alignments(ctype, cu);

	type__for_each_member(ctype, pos)
	if (tag__emit_definitions(&pos->tag, cu, emissions, fp))
	fputc('\n', fp);

	return 1;
	}

	void type__emit(struct tag tag, struct cu cu,
	const char prefix, const char suffix, FILE *fp)
	{
	struct type *ctype = tag__type(tag);

	if (type__name(ctype, cu) != NULL \|\|
	suffix != NULL \|\| prefix != NULL) {
	struct conf_fprintf conf = {
	.prefix = prefix,
	.suffix = suffix,
	.emit_stats = 1,
	};
	tag__fprintf(tag, cu, &conf, fp);
	fputc('\n', fp);
	}
	}