/* *	HT Editor *	ildis.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 <string.h>#include <stdlib.h>#include "data.h"#include "endianess.h"#include "ildis.h"#include "ilopc.h"#include "snprintf.h"ILDisassembler::ILDisassembler(char* (*sf)(uint32 string_ofs, void *context), char* (*tf)(uint32 token, void *context), void *ctx){	initialize(sf, tf, ctx);}void ILDisassembler::initialize(char* (*sf)(uint32 string_ofs, void *context), char* (*tf)(uint32 token, void *context), void *ctx){	string_func = sf;	token_func = tf;	context = ctx;}dis_insn *ILDisassembler::decode(byte *code, int maxlen, CPU_ADDR addr){	insn.valid = false;	insn.prefix = NULL;	insn.size = 0;	insn.data.ui = *code;	if (!maxlen) {		return (dis_insn *)&insn;	}restart:	insn.opcode = &il_opcode_table[*code];	insn.size = insn.opcode->size;	if (insn.size > maxlen) {		insn.size = 1;		insn.valid = false;		return (dis_insn *)&insn;	}	insn.op = insn.opcode->op;	switch (insn.op) {	case IL_OPCODE_ARGS_INVALID:		return (dis_insn *)&insn;	case IL_OPCODE_ARGS_NONE:		break;	case IL_OPCODE_ARGS_PREFIX:		insn.opcode = NULL;		code++;		if (*code < MAX_IL_OPCODE_PREFIX) {			insn.prefix = &il_prefix_opcode_table[*code];			code++;			goto restart;		} else {			insn.size = 1;			insn.valid = false;			return (dis_insn *)&insn;		}	case IL_OPCODE_ARGS_SHORT_JUMP: {		int c = ((char)code[1]);		insn.data.ui = addr.addr32.offset+2+c;		break;	}	case IL_OPCODE_ARGS_LONG_JUMP: {		int c = createHostInt(code+1, 4, little_endian);		insn.data.ui = addr.addr32.offset+5+c;		break;	}	case IL_OPCODE_ARGS_UINT16:	case IL_OPCODE_ARGS_LONG_ARG:	case IL_OPCODE_ARGS_LONG_VAR:	case IL_OPCODE_ARGS_ANN_ARG: 	case IL_OPCODE_ARGS_ANN_DEAD: 	case IL_OPCODE_ARGS_ANN_LIVE: {		uint16 w = createHostInt(code+1, 2, little_endian);		insn.data.ui = w;		break;	}	case IL_OPCODE_ARGS_INT16: {		uint16 w = createHostInt(code+1, 2, little_endian);		insn.data.i = (int)((short)w);		break;	}	case IL_OPCODE_ARGS_UINT8:		insn.data.ui = (byte)code[1];		break;	case IL_OPCODE_ARGS_INT8:	case IL_OPCODE_ARGS_SHORT_VAR:	case IL_OPCODE_ARGS_SHORT_ARG:	case IL_OPCODE_ARGS_ANN_REF_S: {		insn.data.i = (int)((char)code[1]);		break;	}	case IL_OPCODE_ARGS_INT64:		insn.data.q = createHostInt64(code+5, 8, little_endian);		break;	case IL_OPCODE_ARGS_TOKEN:	case IL_OPCODE_ARGS_NEW:	case IL_OPCODE_ARGS_CALL:	case IL_OPCODE_ARGS_CALLVIRT:	case IL_OPCODE_ARGS_INT32:	case IL_OPCODE_ARGS_STRING:		insn.data.ui = createHostInt(code+1, 4, little_endian);		break;	case IL_OPCODE_ARGS_FLOAT32:		// FIXME: hack		insn.data.ui = createHostInt(code+1, 4, little_endian);		break;	case IL_OPCODE_ARGS_FLOAT64:		// FIXME: hack		insn.data.q = createHostInt64(code+5, 8, little_endian);		break;			// variable length opcodes	case IL_OPCODE_ARGS_SWITCH: {		uint32 num = createHostInt(code+1, 4, little_endian);		if (num > 10000) {			insn.valid = false;			insn.size = 1;			return (dis_insn *)&insn;		}		insn.size += num * 4;		break;	}	case IL_OPCODE_ARGS_ANN_DATA_S: {		uint32 num = (byte)code[1];		insn.size += num;		break;	}	case IL_OPCODE_ARGS_ANN_DATA: {		uint32 num = createHostInt(code+1, 4, little_endian);		insn.size += num;		break;	}	case IL_OPCODE_ARGS_ANN_PHI: {		uint32 num = createHostInt(code+1, 2, little_endian);		insn.size += num * 2;		break;	}	}	insn.valid = true;	return (dis_insn *)&insn;}dis_insn *ILDisassembler::duplicateInsn(dis_insn *disasm_insn){	ILDisInsn *insn = ht_malloc(sizeof (ILDisInsn));	*insn = *(ILDisInsn *)disasm_insn;	return insn;}void ILDisassembler::getOpcodeMetrics(int &min_length, int &max_length, int &min_look_ahead, int &avg_look_ahead, int &addr_align){	// FIXME	min_length = 1;	max_length = 10;	min_look_ahead = 120;	avg_look_ahead = 24;	addr_align = 1;}byte ILDisassembler::getSize(dis_insn *disasm_insn){	return ((ILDisInsn*)disasm_insn)->size;}const char *ILDisassembler::getName(){	return "IL/Disassembler";}const char *ILDisassembler::str(dis_insn *disasm_insn, int style){	return strf(disasm_insn, style, "");}const char *ILDisassembler::strf(dis_insn *disasm_insn, int style, const char *format){	if (style & DIS_STYLE_HIGHLIGHT) enable_highlighting();//	const char *cs_default = get_cs(e_cs_default);	const char *cs_number = get_cs(e_cs_number);//	const char *cs_symbol = get_cs(e_cs_symbol);	const char *cs_string = get_cs(e_cs_string);	ILDisInsn *dis_insn = (ILDisInsn *) disasm_insn;		if (!dis_insn->valid) {//		is_invalid://          assert(dis_insn->size==1);		sprintf(insnstr, "db              %s0x%02x", cs_number, dis_insn->data.ui);	} else {		switch (dis_insn->op) {		case IL_OPCODE_ARGS_NONE:			sprintf(insnstr, "%-15s", dis_insn->opcode->name);			break;		case IL_OPCODE_ARGS_UINT8:		case IL_OPCODE_ARGS_UINT16:		case IL_OPCODE_ARGS_LONG_ARG:		case IL_OPCODE_ARGS_LONG_VAR:		case IL_OPCODE_ARGS_ANN_ARG: 		case IL_OPCODE_ARGS_ANN_DEAD: 		case IL_OPCODE_ARGS_ANN_LIVE:  {			sprintf(insnstr, "%-15s %s%u", dis_insn->opcode->name, cs_number, dis_insn->data.ui);			break;		}		case IL_OPCODE_ARGS_INT8:		case IL_OPCODE_ARGS_INT16:		case IL_OPCODE_ARGS_INT32:		case IL_OPCODE_ARGS_SHORT_VAR:		case IL_OPCODE_ARGS_SHORT_ARG:		case IL_OPCODE_ARGS_ANN_REF_S: {			sprintf(insnstr, "%-15s %s%d", dis_insn->opcode->name, cs_number, dis_insn->data.i);			break;		}		case IL_OPCODE_ARGS_INT64:			ht_snprintf(insnstr, 100, "%-15s %s%qd", dis_insn->opcode->name, cs_number, &dis_insn->data.q);			break;                    		case IL_OPCODE_ARGS_CALL:		case IL_OPCODE_ARGS_CALLI:		case IL_OPCODE_ARGS_CALLVIRT:		case IL_OPCODE_ARGS_NEW:		case IL_OPCODE_ARGS_TOKEN: {			uint32 token = dis_insn->data.ui;			char *tokenstr = NULL;			if (token_func) {				tokenstr = token_func(token, context);				if (tokenstr) {					sprintf(insnstr, "%-15s %s", dis_insn->opcode->name, tokenstr);					break;				}			}			sprintf(insnstr, "%-15s %s0x%08x", dis_insn->opcode->name, cs_number, token);			break;		}		case IL_OPCODE_ARGS_STRING: {			if ((dis_insn->data.ui & IL_META_TOKEN_MASK) == IL_META_TOKEN_STRING) {				uint32 strofs = dis_insn->data.ui & (~IL_META_TOKEN_MASK);				char *str = NULL;				if (string_func) {					str = string_func(strofs, context);				}				if (str) {					sprintf(insnstr, "%-15s %s\"%s\"", dis_insn->opcode->name, cs_string, str);					break;				}			}			sprintf(insnstr, "%-15s %s0x%08x", dis_insn->opcode->name, cs_number, dis_insn->data.ui);			break;		}		case IL_OPCODE_ARGS_LONG_JUMP:		case IL_OPCODE_ARGS_SHORT_JUMP: {			CPU_ADDR caddr;			caddr.addr32.offset = dis_insn->data.ui;			int slen;			char *s = (addr_sym_func) ? addr_sym_func(caddr, &slen, addr_sym_func_context) : NULL;			if (s) {				char *p = insnstr + sprintf(insnstr, "%-15s ", dis_insn->opcode->name);				memmove(p, s, slen);				p[slen] = 0;			} else {				sprintf(insnstr, "%-15s %s0x%08x", dis_insn->opcode->name, cs_number, dis_insn->data.ui);			}			break;		}		case IL_OPCODE_ARGS_FLOAT32: {			sprintf(insnstr, "%-15s %s%f", dis_insn->opcode->name, cs_number, dis_insn->data.f);			break;		}		case IL_OPCODE_ARGS_FLOAT64: {		sprintf(insnstr, "%-15s %s%f", dis_insn->opcode->name, cs_number, dis_insn->data.df);			break;		}		default:			sprintf(insnstr, "%-15s [unsupported paramtype]", dis_insn->opcode->name);		}	}		disable_highlighting();	return insnstr;     }ObjectID ILDisassembler::getObjectID() const{	return ATOM_DISASM_IL;}bool ILDisassembler::validInsn(dis_insn *disasm_insn){	return ((ILDisInsn *)disasm_insn)->valid;}