/*
 *	HT Editor
 *	xex_analy.cc
 *
 *	Copyright (C) 2006 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 <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "analy.h"
#include "analy_names.h"
#include "analy_register.h"
#include "analy_ppc.h"
#include "htctrl.h"
#include "htdebug.h"
#include "htiobox.h"
#include "htxex.h"
#include "strtools.h"
#include "xex_analy.h"
#include "xexstruct.h"
#include "snprintf.h"

void	XEXAnalyser::init(ht_xex_shared_data *XEX_shared, File *File)
{
	xex_shared = XEX_shared;
	file = File;

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

	Analyser::init();
}

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

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

/*
 *
 */
void XEXAnalyser::beginAnalysis()
{
	char	buffer[1024];
	
	Address *entry = createAddress32(xex_shared->entrypoint);
	pushAddress(entry, entry);

	int lib_count=xex_shared->imports.lib_count;
	for (int i=0; i < lib_count; i++) {
		XexImportLib *lib = xex_shared->imports.libs + i;
		for (int j = 0; j < lib->func_count; j++) {
			XexImportFunc *func = lib->funcs + j;
			uint32 ord = func->ord;
			if (ord & 0xff000000) {
				int libidx = (ord & 0x00ff0000) >> 16;
				ord &= 0x7fff;
				if (libidx != i) {
					continue;
				}
				char s[200];
				ht_snprintf(s, sizeof s, "wrapper_import_%s_%d", lib->name, ord);
				Address *faddr = createAddress32(func->patch);
				addComment(faddr, 0, "");
				assignSymbol(faddr, s, label_func);
				delete faddr;
				faddr = createAddress32(func->patch+12);				
				Address *faddr2 = createAddress32(func->ia);
				addXRef(faddr2, faddr, xrefijump);
				delete faddr;
				delete faddr2;				
//				printf("xref 0x%08x -> 0x%08x\n", ia, imports[i].func[j].patch + 12);
				
			} else {
				char s[200];
				ord &= 0x7fff;
				ht_snprintf(s, sizeof s, "import_%s_%d", lib->name, ord);
				Address *faddr = createAddress32(func->patch);
				addComment(faddr, 0, "");
				assignSymbol(faddr, s, label_func);
				data->setIntAddressType(faddr, dst_idword, 4);
				delete faddr;				
//				printf("function_ptr 0x%08x name '%s'\n", imports[i].func[j].patch, s);
			}
			
		}
	}

#if 0
	int dimport_count=xex_shared->dimports.funcs->count();
	entropy = random_permutation(dimport_count);
	for (int i=0; i<dimport_count; i++) {
		// FIXME: delay imports need work (push addr)
		ht_pe_import_function *f=(ht_pe_import_function *)(*xex_shared->dimports.funcs)[entropy[i]];
		ht_pe_import_library *d=(ht_pe_import_library *)(*xex_shared->dimports.libs)[f->libidx];
		if (f->byname) {
			ht_snprintf(buffer, sizeof buffer, "; delay import function loader for %s, ordinal %04x", f->name.name, f->ordinal);
		} else {
			ht_snprintf(buffer, sizeof buffer, "; delay import function loader for ordinal %04x", f->ordinal);
		}
		char *label;
		label = import_func_name(d->name, f->byname ? f->name.name : NULL, f->ordinal);
		Address *faddr;
		if (pe32) {
			faddr = createAddress32(f->address);
		} else {
			faddr = createAddress64(f->address);
		}
		addComment(faddr, 0, "");
		addComment(faddr, 0, ";********************************************************");
		addComment(faddr, 0, buffer);
		addComment(faddr, 0, ";********************************************************");
		assignSymbol(faddr, label, label_func);
		free(label);
		delete faddr;
	}
	if (entropy) free(entropy);
#endif

	addComment(entry, 0, "");
	addComment(entry, 0, ";****************************");
	addComment(entry, 0, ";  program entry point");
	addComment(entry, 0, ";****************************");
	assignSymbol(entry, "entrypoint", label_func);

	setLocationTreeOptimizeThreshold(1000);
	setSymbolTreeOptimizeThreshold(1000);
	delete entry;

	Analyser::beginAnalysis();
}

/*
 *
 */
ObjectID	XEXAnalyser::getObjectID() const
{
	return ATOM_XEX_ANALYSER;
}

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

bool XEXAnalyser::convertAddressToRVA(Address *addr, RVA *r)
{
	ObjectID oid = addr->getObjectID();
	if (oid == ATOM_ADDRESS_FLAT_32) {
		*r = ((AddressFlat32*)addr)->addr - xex_shared->image_base;
		return true;
	}
	return false;
}

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


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

/*
 *
 */
FileOfs XEXAnalyser::addressToFileofs(Address *Addr)
{
	if (validAddress(Addr, scinitialized)) {
		FileOfs ofs;
		RVA r;
		if (!convertAddressToRVA(Addr, &r)) return INVALID_FILE_OFS;
		if (!xex_rva_to_ofs(xex_shared, r, ofs)) return INVALID_FILE_OFS;
		return ofs;
	} else {
		return INVALID_FILE_OFS;
	}
}

/*
 *
 */
const char *XEXAnalyser::getSegmentNameByAddress(Address *Addr)
{
	return "";
}

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

/*
 *
 */
const char *XEXAnalyser::getType()
{
	return "XEX/Analyser";
}

/*
 *
 */
void XEXAnalyser::initUnasm()
{
	analy_disasm = new AnalyPPCDisassembler();
	((AnalyPPCDisassembler*)analy_disasm)->init(this, ANALY_PPC_32);
}

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

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


/*
 *
 */
Address *XEXAnalyser::fileofsToAddress(FileOfs fileofs)
{
	RVA r;
	if (xex_ofs_to_rva(xex_shared, fileofs, r)) {
		return createAddress32(r + xex_shared->image_base);
	} else {
		return new InvalidAddress();
	}
}

/*
 *
 */
bool XEXAnalyser::validAddress(Address *Addr, tsectype action)
{
//	e_section_headers *sections=&xex_shared->sections;
	int sec;
	RVA r;
	FileOfs ofs;
	if (!convertAddressToRVA(Addr, &r)) return false;
//	if (!pe_rva_to_section(sections, r, &sec)) return false;
	if (!xex_rva_to_ofs(xex_shared, r, ofs)) return false;
	uint32 flags = xex_get_rva_flags(xex_shared, r);
	switch (action) {
	case scvalid:
	case scinitialized:
	case scread:
		return true;
		return true;
	case scwrite:
	case screadwrite:
		return !(flags & 1);
	case sccode:
		return !(flags & 2);
	}
	return true;
}