ctf_encoder.c

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

  Copyright (C) 2009 Red Hat Inc.
  Copyright (C) 2009 Arnaldo Carvalho de Melo <acme@redhat.com>
*/

#include "dwarves.h"
#include "libctf.h"
#include "ctf.h"
#include "hash.h"
#include "elf_symtab.h"
#include <inttypes.h>

static int tag__check_id_drift(const struct tag *tag,
			       uint32_t core_id, uint32_t ctf_id)
{
	if (ctf_id != core_id) {
		fprintf(stderr, "%s: %s id drift, core: %u, libctf: %d\n",
			__func__, dwarf_tag_name(tag->tag), core_id, ctf_id);
		return -1;
	}
	return 0;
}

static int dwarf_to_ctf_type(uint16_t tag)
{
	switch (tag) {
	case DW_TAG_const_type:		return CTF_TYPE_KIND_CONST;
	case DW_TAG_pointer_type:	return CTF_TYPE_KIND_PTR;
	case DW_TAG_restrict_type:	return CTF_TYPE_KIND_RESTRICT;
	case DW_TAG_volatile_type:	return CTF_TYPE_KIND_VOLATILE;
	case DW_TAG_class_type:
	case DW_TAG_structure_type:	return CTF_TYPE_KIND_STR;
	case DW_TAG_union_type:		return CTF_TYPE_KIND_UNION;
	}
	return 0xffff;
}

static int base_type__encode(struct tag *tag, uint32_t core_id, struct ctf *ctf)
{
	struct base_type *bt = tag__base_type(tag);
	uint32_t ctf_id = ctf__add_base_type(ctf, bt->name, bt->bit_size);

	if (tag__check_id_drift(tag, core_id, ctf_id))
		return -1;

	return 0;
}

static int pointer_type__encode(struct tag *tag, uint32_t core_id, struct ctf *ctf)
{
	uint32_t ctf_id = ctf__add_short_type(ctf, dwarf_to_ctf_type(tag->tag), tag->type, 0);

	if (tag__check_id_drift(tag, core_id, ctf_id))
		return -1;

	return 0;
}

static int typedef__encode(struct tag *tag, uint32_t core_id, struct ctf *ctf)
{
	uint32_t ctf_id = ctf__add_short_type(ctf, CTF_TYPE_KIND_TYPDEF, tag->type, tag__namespace(tag)->name);

	if (tag__check_id_drift(tag, core_id, ctf_id))
		return -1;

	return 0;
}

static int fwd_decl__encode(struct tag *tag, uint32_t core_id, struct ctf *ctf)
{
	uint32_t ctf_id = ctf__add_fwd_decl(ctf, tag__namespace(tag)->name);

	if (tag__check_id_drift(tag, core_id, ctf_id))
		return -1;

	return 0;
}

static int structure_type__encode(struct tag *tag, uint32_t core_id, struct ctf *ctf)
{
	struct type *type = tag__type(tag);
	int64_t position;
	uint32_t ctf_id = ctf__add_struct(ctf, dwarf_to_ctf_type(tag->tag),
				     type->namespace.name, type->size,
				     type->nr_members, &position);

	if (tag__check_id_drift(tag, core_id, ctf_id))
		return -1;

	const bool is_short = type->size < CTF_SHORT_MEMBER_LIMIT;
	struct class_member *pos;
	type__for_each_data_member(type, pos) {
		if (is_short)
			ctf__add_short_member(ctf, pos->name, pos->tag.type,
					      pos->bit_offset, &position);
		else
			ctf__add_full_member(ctf, pos->name, pos->tag.type,
					     pos->bit_offset, &position);
	}

	return 0;
}

static uint32_t array_type__nelems(struct tag *tag)
{
	int i;
	uint32_t nelem = 1;
	struct array_type *array = tag__array_type(tag);

	for (i = array->dimensions - 1; i >= 0; --i)
		nelem *= array->nr_entries[i];

	return nelem;
}

static int array_type__encode(struct tag *tag, uint32_t core_id, struct ctf *ctf)
{
	const uint32_t nelems = array_type__nelems(tag);
	uint32_t ctf_id = ctf__add_array(ctf, tag->type, 0, nelems);

	if (tag__check_id_drift(tag, core_id, ctf_id))
		return -1;

	return 0;
}

static int subroutine_type__encode(struct tag *tag, uint32_t core_id, struct ctf *ctf)
{
	struct parameter *pos;
	int64_t position;
	struct ftype *ftype = tag__ftype(tag);
	uint32_t ctf_id = ctf__add_function_type(ctf, tag->type, ftype->nr_parms, ftype->unspec_parms, &position);

	if (tag__check_id_drift(tag, core_id, ctf_id))
		return -1;

	ftype__for_each_parameter(ftype, pos)
		ctf__add_parameter(ctf, pos->tag.type, &position);

	return 0;
}

static int enumeration_type__encode(struct tag *tag, uint32_t core_id, struct ctf *ctf)
{
	struct type *etype = tag__type(tag);
	int64_t position;
	uint32_t ctf_id = ctf__add_enumeration_type(ctf, etype->namespace.name,
					       etype->size, etype->nr_members,
					       &position);

	if (tag__check_id_drift(tag, core_id, ctf_id))
		return -1;

	struct enumerator *pos;
	type__for_each_enumerator(etype, pos)
		ctf__add_enumerator(ctf, pos->name, pos->value, &position);

	return 0;
}

static void tag__encode_ctf(struct tag *tag, uint32_t core_id, struct ctf *ctf)
{
	switch (tag->tag) {
	case DW_TAG_base_type:
		base_type__encode(tag, core_id, ctf);
		break;
	case DW_TAG_const_type:
	case DW_TAG_pointer_type:
	case DW_TAG_restrict_type:
	case DW_TAG_volatile_type:
		pointer_type__encode(tag, core_id, ctf);
		break;
	case DW_TAG_typedef:
		typedef__encode(tag, core_id, ctf);
		break;
	case DW_TAG_structure_type:
	case DW_TAG_union_type:
	case DW_TAG_class_type:
		if (tag__type(tag)->declaration)
			fwd_decl__encode(tag, core_id, ctf);
		else
			structure_type__encode(tag, core_id, ctf);
		break;
	case DW_TAG_array_type:
		array_type__encode(tag, core_id, ctf);
		break;
	case DW_TAG_subroutine_type:
		subroutine_type__encode(tag, core_id, ctf);
		break;
	case DW_TAG_enumeration_type:
		enumeration_type__encode(tag, core_id, ctf);
		break;
	}
}

#define HASHADDR__BITS 8
#define HASHADDR__SIZE (1UL << HASHADDR__BITS)
#define hashaddr__fn(key) hash_64(key, HASHADDR__BITS)

static struct function *hashaddr__find_function(const struct hlist_head hashtable[],
						const uint64_t addr)
{
	struct function *function;
	struct hlist_node *pos;
	uint16_t bucket = hashaddr__fn(addr);
	const struct hlist_head *head = &hashtable[bucket];

	hlist_for_each_entry(function, pos, head, tool_hnode) {
		if (function->lexblock.ip.addr == addr)
			return function;
	}

	return NULL;
}

static struct variable *hashaddr__find_variable(const struct hlist_head hashtable[],
						const uint64_t addr)
{
	struct variable *variable;
	struct hlist_node *pos;
	uint16_t bucket = hashaddr__fn(addr);
	const struct hlist_head *head = &hashtable[bucket];

	hlist_for_each_entry(variable, pos, head, tool_hnode) {
		if (variable->ip.addr == addr)
			return variable;
	}

	return NULL;
}

/*
 * FIXME: Its in the DWARF loader, we have to find a better handoff
 * mechanizm...
 */
extern struct strings *strings;

int cu__encode_ctf(struct cu *cu, int verbose)
{
	int err = -1;
	struct ctf *ctf = ctf__new(cu->filename, cu->elf);

	if (ctf == NULL)
		goto out;

	if (cu__cache_symtab(cu) < 0)
		goto out_delete;

	ctf__set_strings(ctf, strings);

	uint32_t id;
	struct tag *pos;
	cu__for_each_type(cu, id, pos)
		tag__encode_ctf(pos, id, ctf);

	struct hlist_head hash_addr[HASHADDR__SIZE];

	for (id = 0; id < HASHADDR__SIZE; ++id)
		INIT_HLIST_HEAD(&hash_addr[id]);

	struct function *function;
	cu__for_each_function(cu, id, function) {
		uint64_t addr = function->lexblock.ip.addr;
		struct hlist_head *head = &hash_addr[hashaddr__fn(addr)];
		hlist_add_head(&function->tool_hnode, head);
	}

	uint64_t addr;
	GElf_Sym sym;
	const char *sym_name;
	cu__for_each_cached_symtab_entry(cu, id, sym, sym_name) {
		if (ctf__ignore_symtab_function(&sym, sym_name))
			continue;

		addr = elf_sym__value(&sym);
		int64_t position;
		function = hashaddr__find_function(hash_addr, addr);
		if (function == NULL) {
			if (verbose)
				fprintf(stderr,
					"function %4d: %-20s %#" PRIx64 " %5u NOT FOUND!\n",
					id, sym_name, addr,
					elf_sym__size(&sym));
			err = ctf__add_function(ctf, 0, 0, 0, &position);
			if (err != 0)
				goto out_err_ctf;
			continue;
		}

		const struct ftype *ftype = &function->proto;
		err = ctf__add_function(ctf, function->proto.tag.type,
					ftype->nr_parms,
					ftype->unspec_parms, &position);

		if (err != 0)
			goto out_err_ctf;

		struct parameter *pos;
		ftype__for_each_parameter(ftype, pos)
			ctf__add_function_parameter(ctf, pos->tag.type, &position);
	}

	for (id = 0; id < HASHADDR__SIZE; ++id)
		INIT_HLIST_HEAD(&hash_addr[id]);

	struct variable *var;
	cu__for_each_variable(cu, id, pos) {
		var = tag__variable(pos);
		if (variable__scope(var) != VSCOPE_GLOBAL)
			continue;
		struct hlist_head *head = &hash_addr[hashaddr__fn(var->ip.addr)];
		hlist_add_head(&var->tool_hnode, head);
	}

	cu__for_each_cached_symtab_entry(cu, id, sym, sym_name) {
		if (ctf__ignore_symtab_object(&sym, sym_name))
			continue;
		addr = elf_sym__value(&sym);

		var = hashaddr__find_variable(hash_addr, addr);
		if (var == NULL) {
			if (verbose)
				fprintf(stderr,
					"variable %4d: %-20s %#" PRIx64 " %5u NOT FOUND!\n",
					id, sym_name, addr,
					elf_sym__size(&sym));
			err = ctf__add_object(ctf, 0);
			if (err != 0)
				goto out_err_ctf;
			continue;
		}

		err = ctf__add_object(ctf, var->ip.tag.type);
		if (err != 0)
			goto out_err_ctf;
	}

	ctf__encode(ctf, CTF_FLAGS_COMPR);

	err = 0;
out_delete:
	ctf__delete(ctf);
out:
	return err;
out_err_ctf:
	fprintf(stderr,
		"%4d: %-20s %#llx %5u failed encoding, "
		"ABORTING!\n", id, sym_name,
		(unsigned long long)addr, elf_sym__size(&sym));
	goto out_delete;
}