/* $Id$ */
/* Copyright (c) 2011-2017 Pierre Pronchery <khorben@defora.org> */
/* This file is part of DeforaOS Devel Asm */
/* This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, version 3 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>. */
/* FIXME:
 * - ensure the first section output is of type SHN_UNDEF
 * - use set_string() to store and remember strings? */



#include <System.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "elf/common.h"
#include "elf/elf.h"


/* ELF */
/* private */
/* prototypes */
/* plug-in */
static AsmFormatPlugin * _elf_init(AsmFormatPluginHelper * helper,
		char const * arch);
static int _elf_destroy(AsmFormatPlugin * format);
static int _elf_section(AsmFormatPlugin * format, char const * name);
static char const * _elf_guess(AsmFormatPlugin * format, char const * hint);
static char const * _elf_detect(AsmFormatPlugin * format);
static int _elf_decode(AsmFormatPlugin * format, int raw);
static int _elf_decode_section(AsmFormatPlugin * format, AsmSection * section,
		AsmArchInstructionCall ** calls, size_t * calls_cnt);


/* public */
/* variables */
/* format_plugin */
AsmFormatPluginDefinition format_plugin =
{
	"elf",
	"ELF",
	LICENSE_GNU_LGPL3_FLAGS,
	ELFMAG,
	SELFMAG,
	_elf_init,
	_elf_destroy,
	_elf_guess,
	NULL,
	NULL,
	_elf_section,
	_elf_detect,
	_elf_decode,
	_elf_decode_section
};


/* private */
/* functions */
/* plug-in */
/* elf_init */
static const ElfArch * _init_arch(char const * arch);

static AsmFormatPlugin * _elf_init(AsmFormatPluginHelper * helper,
		char const * arch)
{
	Elf * elf;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(\"%s\")\n", __func__, arch);
#endif
	if((elf = object_new(sizeof(*elf))) == NULL)
		return NULL;
	elf->helper = helper;
	elf->destroy = NULL;
	elf->decode = NULL;
	elf->shstrtab.buf = NULL;
	elf->shstrtab.cnt = 0;
	elf->es32 = NULL;
	elf->es32_cnt = 0;
	elf->es64 = NULL;
	elf->es64_cnt = 0;
	if(arch == NULL)
	{
		elf->arch = NULL;
		return elf;
	}
	if((elf->arch = _init_arch(arch)) == NULL)
	{
		object_delete(elf);
		return NULL;
	}
	if(elf->arch->capacity == ELFCLASS32)
	{
		if(elf32_init(elf) != 0)
			return NULL;
		elf->destroy = elf32_destroy;
		elf->section = elf32_section;
		elf->decode = elf32_decode;
	}
	else if(elf->arch->capacity == ELFCLASS64)
	{
		if(elf64_init(elf) != 0)
			return NULL;
		elf->destroy = elf64_destroy;
		elf->section = elf64_section;
		elf->decode = elf64_decode;
	}
	else
		return NULL;
	return elf;
}

static const ElfArch * _init_arch(char const * arch)
{
	const ElfArch * ea;

	for(ea = elf_arch; ea->arch != NULL; ea++)
		if(strcmp(ea->arch, arch) == 0)
			return ea;
	error_set_code(1, "%s: %s", arch, "Unsupported ELF architecture");
	return NULL;
}


/* elf_destroy */
static int _elf_destroy(AsmFormatPlugin * format)
{
	Elf * elf = format;
	int ret = 0;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	if(format->destroy != NULL)
		ret = format->destroy(elf);
	free(elf->es32);
	free(elf->es64);
	object_delete(elf);
	return ret;
}


/* elf_section */
static int _elf_section(AsmFormatPlugin * format, char const * name)
{
	if(format->section == NULL)
		return -1;
	return format->section(format, name);
}


/* elf_guess */
static char const * _elf_guess(AsmFormatPlugin * format, char const * hint)
{
	/* XXX share these tables with _elf_detect() */
	struct
	{
		char const * quirk;
		char const * arch;
	} quirks[] =
	{
		{ "arm", "armel" },
		{ "mips", "mipsel" },
		{ "x86", "i686" },
		{ "x86-64", "amd64" },
		{ "x86_64", "amd64" }
	};
	char const * arch[] =
	{
		"alpha",
		"amd64",
		"armeb", "armel",
		"i386", "i486", "i586", "i686",
		"mips", "mips64",
		"sparc", "sparc64",
	};
	size_t i;
	(void) format;

	if(hint == NULL)
		return NULL;
	for(i = 0; i < sizeof(quirks) / sizeof(*quirks); i++)
		if(string_compare(hint, quirks[i].quirk) == 0)
			return quirks[i].arch;
	for(i = 0; i < sizeof(arch) / sizeof(*arch); i++)
		if(string_compare(hint, arch[i]) == 0)
			return hint;
	return NULL;
}


/* elf_detect */
static char const * _elf_detect(AsmFormatPlugin * format)
{
	AsmFormatPluginHelper * helper = format->helper;
	char const * ret;
	union
	{
		Elf32_Ehdr ehdr32;
		Elf64_Ehdr ehdr64;
	} ehdr;

	if(helper->seek(helper->format, 0, SEEK_SET) != 0)
		return NULL;
	if(helper->read(helper->format, &ehdr, sizeof(ehdr)) != sizeof(ehdr))
		return NULL;
	switch(ehdr.ehdr32.e_ident[EI_CLASS])
	{
		case ELFCLASS32:
			if((ret = elf32_detect(format, &ehdr.ehdr32)) != NULL)
				format->decode = elf32_decode;
			break;
		case ELFCLASS64:
			if((ret = elf64_detect(format, &ehdr.ehdr64)) != NULL)
				format->decode = elf64_decode;
			break;
		default:
			ret = NULL;
			error_set_code(1, "%s: %s 0x%x\n",
					helper->get_filename(helper->format),
					"Unsupported ELF class",
					ehdr.ehdr32.e_ident[EI_CLASS]);
			break;
	}
	return ret;
}


/* elf_decode */
static int _elf_decode(AsmFormatPlugin * format, int raw)
{
#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s(%d)\n", __func__, raw);
#endif
	if(_elf_detect(format) == NULL)
		return -1;
	return format->decode(format, raw);
}


/* elf_decode_section */
static int _elf_decode_section(AsmFormatPlugin * format, AsmSection * section,
		AsmArchInstructionCall ** calls, size_t * calls_cnt)
{
	AsmFormatPluginHelper * helper = format->helper;

#ifdef DEBUG
	fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
	return helper->decode(helper->format, section->offset, section->size,
			section->base, calls, calls_cnt);
}