/* 
 *	HT Editor
 *	pef_analy.cc
 *
 *	Copyright (C) 1999-2002 Sebastian Biallas (sb@biallas.net)
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License version 2 as
 *	published by the Free Software Foundation.
 *
 *	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 General Public License for more details.
 *
 *	You should have received a copy of the GNU General Public License
 *	along with this program; if not, write to the Free Software
 *	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "analy.h"
#include "analy_names.h"
#include "analy_ppc.h"
#include "analy_register.h"
#include "pef_analy.h"

#include "htctrl.h"
#include "htdebug.h"
#include "htiobox.h"
#include "htpef.h"
#include "strtools.h"
#include "pestruct.h"
#include "snprintf.h"
#include "x86asm.h"

extern "C" {
#include "demangle.h"
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
 *
 */

PEFAnalyser::PEFAnalyser()
{
}

void PEFAnalyser::init(ht_pef_shared_data *Pef_shared, File *File)
{
	pef_shared = Pef_shared;
	file = File;

	validarea = new Area();
	validarea->init();

	Analyser::init();
}

void PEFAnalyser::beginAnalysis()
{
//	Address *entry = NULL;

//	entry = createAddress32(pef_shared->header32.e_entry);

	setLocationTreeOptimizeThreshold(100);
	setSymbolTreeOptimizeThreshold(100);

	/*
	 *	entrypoint
	 */
//	pushAddress(entry, entry);
	
	/*
	 *	give all sections a descriptive comment:
	 */

	PEF_SECTION_HEADER *s32=pef_shared->sheaders.sheaders;
	char blub[100];
	for (uint i=0; i < pef_shared->sheaders.count; i++) {
		Address *secaddr;
		secaddr = createAddress32(s32->defaultAddress);
		if (validAddress(secaddr, scvalid)) {
			ht_snprintf(blub, sizeof blub, ";  section %d <%s>", i, getSegmentNameByAddress(secaddr));
			addComment(secaddr, 0, "");
			addComment(secaddr, 0, ";******************************************************************");
			addComment(secaddr, 0, blub);
			ht_snprintf(blub, sizeof blub, ";  virtual address  %08x  virtual size   %08x", s32->defaultAddress, s32->totalSize);
			addComment(secaddr, 0, blub);
			ht_snprintf(blub, sizeof blub, ";  file offset      %08x  file size      %08x", s32->containerOffset, s32->packedSize);
			addComment(secaddr, 0, blub);
			addComment(secaddr, 0, ";******************************************************************");

			// mark end of sections
			ht_snprintf(blub, sizeof blub, ";  end of section <%s>", getSegmentNameByAddress(secaddr));
			Address *secend_addr = secaddr->clone();
			secend_addr->add(s32->totalSize);
			newLocation(secend_addr)->flags |= AF_FUNCTION_END;
			addComment(secend_addr, 0, "");
			addComment(secend_addr, 0, ";******************************************************************");
			addComment(secend_addr, 0, blub);
			addComment(secend_addr, 0, ";******************************************************************");

			validarea->add(secaddr, secend_addr);

			delete secend_addr;
		}
		delete secaddr;
		s32++;
	}

/* symbols */
/*	for (uint i=1; i<pef_shared->sheaders.count; i++) {
		if ((pef_shared->sheaders.sheaders32[i].sh_type==PEF_SHT_SYMTAB) || (pef_shared->sheaders.sheaders32[i].sh_type==PEF_SHT_DYNSYM)) {
			initInsertSymbols(i);
		}
	}*/
/*	assignSymbol(entry, "entrypoint", label_func);
	addComment(entry, 0, "");
	addComment(entry, 0, ";****************************");
	addComment(entry, 0, ";  executable entry point");
	addComment(entry, 0, ";****************************");*/

	setLocationTreeOptimizeThreshold(1000);
	setSymbolTreeOptimizeThreshold(1000);
//	delete entry;
	
	Analyser::beginAnalysis();
}

/*
 *
 */
void PEFAnalyser::initInsertSymbols(int shidx)
{
/*	char pef_buffer[1024];
	if (pef_shared->ident.e_ident[PEF_EI_CLASS] == PEFCLASS32) {

		FileOfs h=pef_shared->sheaders.sheaders32[shidx].sh_offset;
		FileOfs sto=pef_shared->sheaders.sheaders32[pef_shared->sheaders.sheaders32[shidx].sh_link].sh_offset;
		uint symnum=pef_shared->sheaders.sheaders32[shidx].sh_size / sizeof (PEF_SYMBOL32);

		int *entropy = random_permutation(symnum);
		for (uint i=0; i<symnum; i++) {
			PEF_SYMBOL32 sym;
			if (entropy[i] == 0) continue;
			file->seek(h+entropy[i]*sizeof (PEF_SYMBOL32));
			file->read(&sym, sizeof sym);
			createHostStruct(&sym, PEF_SYMBOL32_struct, pef_shared->byte_order);

			file->seek(sto+sym.st_name);
			char *name = fgetstrz(*file);
			if (!name) continue;

			switch (sym.st_shndx) {
				case PEF_SHN_UNDEF:
					break;
				case PEF_SHN_ABS:
					break;
				case PEF_SHN_COMMON:
					break;
				default: {
					// sym.st_shndx
					break;
				}
			}

			char *bind;
			switch (PEF32_ST_BIND(sym.st_info)) {
				case PEF_STB_LOCAL:
					bind="local";
					break;
				case PEF_STB_GLOBAL:
					bind="global";
					break;
				case PEF_STB_WEAK:
					bind="weak";
					break;
				default:
					bind="?";
					break;
			}

			switch (PEF32_ST_TYPE(sym.st_info)) {
				case PEF_STT_NOTYPE:
				case PEF_STT_FUNC: {
				char *label = name;
					if (!getSymbolByName(label)) {
						Address *address = createAddress32(sym.st_value);
						if (validAddress(address, scvalid)) {
							char *demangled = cplus_demangle(label, DMGL_PARAMS | DMGL_ANSI);

							make_valid_name(label, label);

							ht_snprintf(pef_buffer, sizeof pef_buffer, "; function %s (%s)", (demangled) ? demangled : label, bind);

							if (demangled) free(demangled);

							addComment(address, 0, "");
							addComment(address, 0, ";********************************************************");
							addComment(address, 0, pef_buffer);
							addComment(address, 0, ";********************************************************");
							pushAddress(address, address);
							assignSymbol(address, label, label_func);
						}
						delete address;
					}
					break;
				}
				case PEF_STT_OBJECT: {
					char *label = name;
					if (!getSymbolByName(label)) {
						Address *address = createAddress32(sym.st_value);
						if (validAddress(address, scvalid)) {

							char *demangled = cplus_demangle(label, DMGL_PARAMS | DMGL_ANSI);
					
							make_valid_name(label, label);
					
							ht_snprintf(pef_buffer, sizeof pef_buffer, "; data object %s, size %d (%s)", (demangled) ? demangled : label, sym.st_size, bind);

							if (demangled) free(demangled);

							addComment(address, 0, "");
							addComment(address, 0, ";********************************************************");
							addComment(address, 0, pef_buffer);
							addComment(address, 0, ";********************************************************");
							assignSymbol(address, label, label_data);
						}
						delete address;
					}
					break;
				}
				case PEF_STT_SECTION:
				case PEF_STT_FILE:
					break;
			}
			free(name);
		}
		if (entropy) free(entropy);
	} else {
		// FIXME: 64 bit
		FileOfs h=pef_shared->sheaders.sheaders64[shidx].sh_offset.lo;
		FileOfs sto=pef_shared->sheaders.sheaders64[pef_shared->sheaders.sheaders64[shidx].sh_link].sh_offset.lo;
		uint symnum=pef_shared->sheaders.sheaders64[shidx].sh_size.lo / sizeof (PEF_SYMBOL64);

		int *entropy = random_permutation(symnum);
		for (uint i=0; i<symnum; i++) {
			PEF_SYMBOL64 sym;
			if (entropy[i] == 0) continue;
			file->seek(h+entropy[i]*sizeof (PEF_SYMBOL64));
			file->read(&sym, sizeof sym);
			createHostStruct(&sym, PEF_SYMBOL64_struct, pef_shared->byte_order);

			file->seek(sto+sym.st_name);
			char *name = fgetstrz(file);
			if (!name) continue;

			switch (sym.st_shndx) {
				case PEF_SHN_UNDEF:
					break;
				case PEF_SHN_ABS:
					break;
				case PEF_SHN_COMMON:
					break;
				default: {
					// sym.st_shndx
					break;
				}
			}

			char *bind;
			switch (PEF64_ST_BIND(sym.st_info)) {
				case PEF_STB_LOCAL:
					bind="local";
					break;
				case PEF_STB_GLOBAL:
					bind="global";
					break;
				case PEF_STB_WEAK:
					bind="weak";
					break;
				default:
					bind="?";
					break;
			}

			switch (PEF64_ST_TYPE(sym.st_info)) {
				case PEF_STT_NOTYPE:
				case PEF_STT_FUNC: {
					char *label = name;
					if (!getSymbolByName(label)) {
						Address *address = createAddress64(sym.st_value);

						char *demangled = cplus_demangle(label, DMGL_PARAMS | DMGL_ANSI);

						make_valid_name(label, label);

						ht_snprintf(pef_buffer, sizeof pef_buffer, "; function %s (%s)", (demangled) ? demangled : label, bind);

						if (demangled) free(demangled);

						addComment(address, 0, "");
						addComment(address, 0, ";********************************************************");
						addComment(address, 0, pef_buffer);
						addComment(address, 0, ";********************************************************");
						pushAddress(address, address);
						assignSymbol(address, label, label_func);
						
						delete address;
					}
					break;
				}
				case PEF_STT_OBJECT: {
					char *label = name;
					if (!getSymbolByName(label)) {
						Address *address = createAddress64(sym.st_value);

						char *demangled = cplus_demangle(label, DMGL_PARAMS | DMGL_ANSI);
					
						make_valid_name(label, label);
					
						ht_snprintf(pef_buffer, sizeof pef_buffer, "; data object %s, size %d (%s)", (demangled) ? demangled : label, sym.st_size.lo, bind);

						if (demangled) free(demangled);

						addComment(address, 0, "");
						addComment(address, 0, ";********************************************************");
						addComment(address, 0, pef_buffer);
						addComment(address, 0, ";********************************************************");
						assignSymbol(address, label, label_data);
						
						delete address;
					}
					break;
				}
				case PEF_STT_SECTION:
				case PEF_STT_FILE:
					break;
			}
			free(name);
		}
		if (entropy) free(entropy);
	}*/
}

/*
 *
 */
void PEFAnalyser::load(ObjectStream &f)
{
	GET_OBJECT(f, validarea);
	return Analyser::load(f);
}

/*
 *
 */
void PEFAnalyser::done()
{
	validarea->done();
	delete validarea;
	Analyser::done();
}

ObjectID PEFAnalyser::getObjectID() const
{
	return ATOM_PEF_ANALYSER;
}

/*
 *
 */
uint PEFAnalyser::bufPtr(Address *Addr, byte *buf, int size)
{
	FileOfs ofs = addressToFileofs(Addr);
/*     if (ofs == INVALID_FILE_OFS) {
		int as = 1;
	}*/
	assert(ofs != INVALID_FILE_OFS);
	file->seek(ofs);
	return file->read(buf, size);;
}

bool PEFAnalyser::convertAddressToPEFAddress(Address *addr, PEFAddress *r)
{
	if (addr->getObjectID()==ATOM_ADDRESS_FLAT_32) {
		r->a32 = ((AddressFlat32*)addr)->addr;
		return true;
	} else {
		return false;
	}
}

Address *PEFAnalyser::createAddress()
{
	return new AddressFlat32();
}

Address *PEFAnalyser::createAddress32(uint32 addr)
{
	return new AddressFlat32(addr);
}

Address *PEFAnalyser::createAddress64(uint64 addr)
{
	return new AddressFlat64(addr);
}

/*
 *
 */
Assembler *PEFAnalyser::createAssembler()
{
	return NULL;
}

/*
 *
 */
FileOfs PEFAnalyser::addressToFileofs(Address *Addr)
{
	if (validAddress(Addr, scinitialized)) {
		uint32 ofs;
		PEFAddress ea;
		if (!convertAddressToPEFAddress(Addr, &ea)) return INVALID_FILE_OFS;
		if (!pef_addr_to_ofs(&pef_shared->sheaders, ea, &ofs)) return INVALID_FILE_OFS;
		return ofs;
	} else {
		return INVALID_FILE_OFS;
	}
}

/*
 *
 */
const char *PEFAnalyser::getSegmentNameByAddress(Address *Addr)
{
	static char pef_sectionname[33];
	pef_section_headers *sections=&pef_shared->sheaders;
	int i;
	PEFAddress ea;
	if (!convertAddressToPEFAddress(Addr, &ea)) return NULL;
	if (!pef_addr_to_section(sections, ea, &i)) return NULL;
	if (pef_shared->sheaders.sheaders[i].nameOffset == 0xffffffff) {
		ht_snprintf(pef_sectionname, sizeof pef_sectionname, "unnamed%d", i);
	} else {
//		ht_strlcpy(pef_sectionname, pef_shared->shnames[i], 32);
		strcpy(pef_sectionname, "nyi");
	}
	return pef_sectionname;
}

/*
 *
 */
String &PEFAnalyser::getName(String &res)
{
	return file->getDesc(res);
}

/*
 *
 */
const char *PEFAnalyser::getType()
{
	return "PEF/Analyser";
}

/*
 *
 */
void PEFAnalyser::initCodeAnalyser()
{
	Analyser::initCodeAnalyser();
}

/*
 *
 */
void PEFAnalyser::initUnasm()
{
	DPRINTF("pef_analy: ");
	switch (pef_shared->arch) {
	case PEFARCH_PowerPC:
		DPRINTF("initing analy_ppc_disassembler\n");
		analy_disasm = new AnalyPPCDisassembler();
		((AnalyPPCDisassembler*)analy_disasm)->init(this, ANALY_PPC_32);
		break;
	case PEFARCH_M68K:
		DPRINTF("no disassembler for machine 'm68k'\n");
		warnbox("No disassembler for machine 'm68k'!");
		break;
	default:
		break;
	}
}

/*
 *
 */
void PEFAnalyser::log(const char *msg)
{
	/*
	 *	log() does to much traffic so dont log
	 *   perhaps we reactivate this later
	 *
	 */
/*	LOG(msg);*/
}

/*
 *
 */
Address *PEFAnalyser::nextValid(Address *Addr)
{
	return (Address *)validarea->findNext(Addr);
}

/*
 *
 */
void PEFAnalyser::store(ObjectStream &f) const
{
	PUT_OBJECT(f, validarea);
	Analyser::store(f);
}

/*
 *
 */
int PEFAnalyser::queryConfig(int mode)
{
	switch (mode) {
		case Q_DO_ANALYSIS:
		case Q_ENGAGE_CODE_ANALYSER:
		case Q_ENGAGE_DATA_ANALYSER:
			return true;
		default:
			return 0;
	}
}

/*
 *
 */
Address *PEFAnalyser::fileofsToAddress(FileOfs fileofs)
{
	PEFAddress ea;
	if (pef_ofs_to_addr(&pef_shared->sheaders, fileofs, &ea)) {
		return createAddress32(ea.a32);
	} else {
		return new InvalidAddress();
	}
}

/*
 *
 */
bool PEFAnalyser::validAddress(Address *Addr, tsectype action)
{
	pef_section_headers *sections=&pef_shared->sheaders;
	int sec;
	PEFAddress ea;
	if (!convertAddressToPEFAddress(Addr, &ea)) return false;
	if (!pef_addr_to_section(sections, ea, &sec)) return false;
	PEF_SECTION_HEADER *s = sections->sheaders + sec;
	switch (action) {
		case scvalid:
			return true;
		case scread:
			return true;
		case scwrite:
		case screadwrite:
			return (s->sectionKind == 1) ||
				(s->sectionKind == 2) ||
				(s->sectionKind == 6);
		case sccode:
			return (s->sectionKind == 0);
		case scinitialized:
			return (s->sectionKind == 0) ||
				(s->sectionKind == 1) ||
				(s->sectionKind == 3) ||
				(s->sectionKind == 6)	/* FIXME: is 6 really initialized ? */;
	}
	return false;
}