/* *	HT Editor *	htdisasm.cc * *	Copyright (C) 1999-2002 Stefan Weyergraf * *	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 <cstring>#include "cmds.h"#include "htctrl.h"#include "htdisasm.h"#include "hthist.h"#include "htiobox.h"#include "htmenu.h"#include "httag.h"#include "snprintf.h"#include "x86asm.h"#include "x86dis.h"#include "ppcdis.h"extern "C" {#include "evalx.h"#include "regex.h"}ht_view *htdisasm_init(Bounds *b, File *file, ht_format_group *group){	int t1632;#if 1	Assembler *assembler=new x86asm(X86_OPSIZE32, X86_ADDRSIZE32);	x86dis *disassembler=new x86dis(X86_OPSIZE32, X86_ADDRSIZE32);#else	Assembler *assembler = NULL;	Disassembler *disassembler = new PPCDisassembler(PPC_MODE_32);#endif	t1632 = 0;	ht_disasm_viewer *v=new ht_disasm_viewer();	v->init(b, DESC_DISASM, VC_EDIT | VC_GOTO | VC_SEARCH, file, group, assembler, disassembler, t1632);	ht_disasm_sub *d=new ht_disasm_sub();	d->init(file, 0, file->getSize(),		disassembler, false, X86DIS_STYLE_OPTIMIZE_ADDR);	v->insertsub(d);	return v;}format_viewer_if htdisasm_if = {	htdisasm_init,	0};/* *	dialog_assemble */ static int opcode_compare(const char *a, const char *b){	int al = strlen(a);	int bl = strlen(b);	if (al > bl) return 1; else if (al < bl) return -1; else return strcmp(a, b);}void dialog_assemble(ht_format_viewer *f, viewer_pos vaddr, CPU_ADDR cpuaddr, Assembler *a, Disassembler *disasm, const char *default_str, int want_length){	char instr[257] = "";	if (default_str) strcpy(instr, default_str);	asm_insn *insn = a->alloc_insn();	asm_code *ac = NULL;	while (inputbox(a->get_name(), "~instruction:", instr, 255, HISTATOM_ASSEMBLER)) {		if ((a->translate_str(insn, instr)) && (ac = a->encode(insn, 0, cpuaddr))) {			break;		} else {			errorbox("%s: %s", a->get_name(), a->get_error_msg());		}	}	if (ac) {		bool ok=true;		asm_code *chosen_ac = ac;		if (ac->next) {			// choose from list if ambigous			Bounds b;			b.w = 60;			b.h = 15;			center_bounds(&b);			ht_dialog *dialog = new ht_dialog();			dialog->init(&b, "choose opcode", FS_KILLER | FS_TITLE | FS_MOVE);			b.assign(1, 0, 56, 1);			ht_listbox_title *text = new ht_listbox_title();			text->init(&b);			text->setText(2, "opcode", "disassembly");			dialog->insert(text);			b.assign(1, 1, 56, 12);			ht_text_listbox *list=new ht_text_listbox();			list->init(&b, 2, 0);			list->attachTitle(text);			asm_code *ac2 = ac;			uint aci = 0;			int best = 0;			while (ac2) {				char s[1024], *tmp = s;				for (int i=0; i < ac2->size; i++) {					tmp += sprintf(tmp, "%02x ", ac2->data[i]);				}				if (best == 0 && want_length == ac2->size) {					best = aci+1;				}				const char *tmp2;				if (disasm) {					dis_insn *o=disasm->decode((byte *)ac2->data, ac2->size, cpuaddr);					tmp2 = disasm->strf(o, DIS_STYLE_HEX_NOZEROPAD+DIS_STYLE_HEX_ASMSTYLE, DISASM_STRF_SMALL_FORMAT);				} else {					tmp2 = "<no disassembler>";				}				list->insert_str(aci, s, tmp2);				ac2 = ac2->next;				aci++;			}			ht_text_listbox_sort_order so;			so.col = 0;			so.compare_func = opcode_compare;			list->update();			if (best) {				list->gotoItemByPosition(best-1);			}			list->sort(1, &so);			if (!best) {				list->gotoItemByPosition(0);			}			dialog->insert(list);			int r = dialog->run(0);			ok = r;			if (r == button_ok) {				ht_listbox_data d;				ViewDataBuf vdb(list, &d, sizeof d);				ht_text_listbox_item *i = (ht_text_listbox_item *)d.data->cursor_ptr;				asm_code *ac3 = ac;				int ac3i = 0;				while (ac3) {					if (ac3i == i->id) {						chosen_ac = ac3;						break;					}					ac3 = ac3->next;					ac3i++;				}			}			dialog->done();			delete dialog;		}		if (ok) {			baseview->sendmsg(cmd_edit_mode_i, f->get_file(), NULL);			if (f->get_file() && (f->get_file()->getAccessMode() & IOAM_WRITE)) {				f->vwrite(vaddr, chosen_ac->data, chosen_ac->size);			}		}	}	free(insn);}/* *	CLASS ht_disasm_viewer */void ht_disasm_viewer::init(Bounds *b, const char *desc, int caps, File *file, ht_format_group *format_group, Assembler *a, Disassembler *d, int t){	ht_uformat_viewer::init(b, desc, caps, file, format_group);	assem = a;	disasm = d;	op1632 = t;}void ht_disasm_viewer::done(){	ht_uformat_viewer::done();	delete assem;	delete disasm;}int ht_disasm_viewer::get_pindicator_str(char *buf, int max_len){	FileOfs o;	if (get_current_offset(&o)) {		return ht_snprintf(buf, max_len, " %s 0x%08qx/%qu ", edit() ? "edit" : "view", o, o);	} else {		return ht_snprintf(buf, max_len, " ? ");	}}	bool ht_disasm_viewer::get_vscrollbar_pos(int *pstart, int *psize){	FileOfs s=file->getSize();	if (s) {		int z = MIN(size.h*16, s-(int)top.line_id.id1);		return scrollbar_pos(top.line_id.id1, z, s, pstart, psize);	}	return false;}void ht_disasm_viewer::handlemsg(htmsg *msg){	switch (msg->msg) {		case msg_contextmenuquery: {			ht_static_context_menu *m=new ht_static_context_menu();			m->init("~Local-Disasm");			m->insert_entry("~Assemble", "Ctrl+A", cmd_disasm_call_assembler, K_Control_A, 1);			// FIXME: wrong implementation			m->insert_entry("~Toggle 16/32", NULL, cmd_disasm_toggle1632, 0, 1);			msg->msg = msg_retval;			msg->data1.ptr = m;			return;		}		case msg_get_scrollinfo: {			switch (msg->data1.integer) {				case gsi_hscrollbar: {					gsi_scrollbar_t *p=(gsi_scrollbar_t*)msg->data2.ptr;					if (!get_hscrollbar_pos(&p->pstart, &p->psize)) {						p->pstart = 0;						p->psize = 100;					}					clearmsg(msg);					return;				}				case gsi_vscrollbar: {					gsi_scrollbar_t *p=(gsi_scrollbar_t*)msg->data2.ptr;					if (!get_vscrollbar_pos(&p->pstart, &p->psize)) {						p->pstart = 0;						p->psize = 100;					}					clearmsg(msg);					return;				}			}			break;		}		case msg_filesize_changed: {			htmsg m;			m.msg=msg_filesize_changed;			m.type=mt_broadcast;			sendsubmsg(&m);						// FIXME: hack			uf_initialized=false;			complete_init();						dirtyview();			return;		}		case cmd_disasm_call_assembler: {			viewer_pos current_pos;			get_current_pos(&current_pos);			CPU_ADDR cpuaddr;			cpuaddr.addr32.seg = 0;			cpuaddr.addr32.offset = current_pos.u.line_id.id1;			assem->set_imm_eval_proc(NULL, NULL);			byte data[32];			int datalen = vread(current_pos, data, sizeof data);			dis_insn *o = disasm->decode(data, datalen, cpuaddr);			const char *curinsn = disasm->strf(o, DIS_STYLE_HEX_NOZEROPAD+DIS_STYLE_HEX_ASMSTYLE, DISASM_STRF_SMALL_FORMAT);			int want_length = disasm->getSize(o);			dialog_assemble(this, current_pos, cpuaddr, assem, disasm, curinsn, want_length);			clearmsg(msg);			return;		}		case cmd_disasm_toggle1632: {			// FIXME: very beautiful...			op1632 ^= 1;			if (op1632) {				((x86asm *)assem)->opsize = X86_OPSIZE16;				((x86asm *)assem)->addrsize = X86_ADDRSIZE16;				((x86dis *)disasm)->opsize = X86_OPSIZE16;				((x86dis *)disasm)->addrsize = X86_ADDRSIZE16;			} else {				((x86asm *)assem)->opsize = X86_OPSIZE32;				((x86asm *)assem)->addrsize = X86_ADDRSIZE32;				((x86dis *)disasm)->opsize = X86_OPSIZE32;				((x86dis *)disasm)->addrsize = X86_ADDRSIZE32;			}			dirtyview();			clearmsg(msg);			return;		}	}	ht_uformat_viewer::handlemsg(msg);}ht_disasm_sub *ht_disasm_viewer::get_disasm_sub(){	return (ht_disasm_sub*)cursor.sub;}bool ht_disasm_viewer::offset_to_pos(FileOfs ofs, viewer_pos *p){	p->u.sub = get_disasm_sub();	p->u.line_id.id1 = ofs;	p->u.line_id.id2 = 0;	p->u.tag_idx = 0;	return true;}bool ht_disasm_viewer::pos_to_offset(viewer_pos p, FileOfs *ofs){	*ofs = p.u.line_id.id1;	return true;}bool ht_disasm_viewer::ref_sel(LINE_ID *id){	return goto_offset(id->id1, true);}bool ht_disasm_viewer::qword_to_pos(uint64 q, viewer_pos *p){	ht_linear_sub *s = get_disasm_sub();	FileOfs ofs = q;	clear_viewer_pos(p);	p->u.sub = s;	p->u.tag_idx = 0;	return s->convert_ofs_to_id(ofs, &p->u.line_id);}bool ht_disasm_viewer::symbol_handler(eval_scalar *result, char *name){	if (strcmp(name, "$") == 0) {		FileOfs ofs;		if (!pos_to_offset(*(viewer_pos*)&cursor, &ofs)) return 0;		scalar_create_int_q(result, ofs);		return true;	}	return ht_uformat_viewer::symbol_handler(result, name);}const char *ht_disasm_viewer::func(uint i, bool execute){	switch (i) {		// FIXME: wrong implementation		case 8:			if (execute) sendmsg(cmd_disasm_toggle1632);			return op1632 ? (char*)"use32" : (char*)"use16";	}	return ht_uformat_viewer::func(i, execute);}/* *	CLASS ht_disasm_sub */void ht_disasm_sub::init(File *f, FileOfs ofs, int size, Disassembler *u, bool own_u, int ds){	ht_linear_sub::init(f, ofs, size);	disasm = u;	own_disasm = own_u;	display_style = ds;}void ht_disasm_sub::done(){	if (own_disasm) {		delete disasm;	}	ht_linear_sub::done();}bool ht_disasm_sub::convert_ofs_to_id(const FileOfs offset, LINE_ID *line_id){	if ((offset >= fofs) && (offset < fofs+fsize)) {		line_id->id1=offset;		line_id->id2=0;		return true;	}	return false;}bool ht_disasm_sub::convert_id_to_ofs(const LINE_ID line_id, FileOfs *offset){	*offset = line_id.id1;	return true;}static char *diasm_addr_sym_func(CPU_ADDR Addr, int *symstrlen, void *context){	ht_disasm_sub *sub = (ht_disasm_sub *) context;	static char buf[120];	LINE_ID line_id;	sub->first_line_id(&line_id);	if (Addr.addr32.offset >= line_id.id1) {		sub->last_line_id(&line_id);		if (Addr.addr32.offset <= line_id.id1) {			char buf2[60];			ht_snprintf(buf2, sizeof buf2, "0x%x", Addr.addr32.offset);			char *b = tag_make_ref(buf, sizeof buf-1, Addr.addr32.offset, 0, 0, 0, buf2);			*b = 0;			if (symstrlen) *symstrlen = b-buf;			return buf;		}	}	return NULL;}bool ht_disasm_sub::getline(char *line, int maxlen, const LINE_ID line_id){	if (line_id.id2) return false;	uint64 ofs = line_id.id1;	byte buf[16];	int c = MIN(16, sint64(fofs+fsize-ofs));	if (c <= 0) return false;	file->seek(ofs);	c = file->read(buf, c);	CPU_ADDR caddr;	caddr.addr32.seg = 0;	caddr.addr32.offset = ofs;	const char *s;	char *l = line;	if (c) {		dis_insn *insn = disasm->decode(buf, c, caddr);		addr_sym_func_context = this;		addr_sym_func = &diasm_addr_sym_func;		s = disasm->str(insn, display_style);		addr_sym_func = NULL;		c = disasm->getSize(insn);	} else {		s = "db ?";		c = 0;	}	l += ht_snprintf(l, maxlen, "%08qx ", ofs);	for (int i=0; i<15; i++) {		if (i<c) {			l=tag_make_edit_byte(l, maxlen, ofs+i);		} else {			*l++=' ';			*l++=' ';		}	}	*l++=' ';	tag_strcpy(l, maxlen, s);	return true;}void ht_disasm_sub::first_line_id(LINE_ID *line_id){	clear_line_id(line_id);	line_id->id1 = fofs;}void ht_disasm_sub::last_line_id(LINE_ID *line_id){	clear_line_id(line_id);	line_id->id1 = fofs+fsize-1;}int ht_disasm_sub::prev_line_id(LINE_ID *line_id, int n){	if (line_id->id2) return 0;	uint32 *ofs=&line_id->id1;	int min_length;	int max_length;	int min_look_ahead;	int avg_look_ahead;	int addr_align;	disasm->getOpcodeMetrics(min_length, max_length, min_look_ahead, avg_look_ahead, addr_align);	unsigned char buf[avg_look_ahead*50], *bufp=buf;	int offsets[avg_look_ahead*50];	int *of=offsets;	int r=n<6 ? 6*avg_look_ahead : n*avg_look_ahead;	if (r > (int)sizeof buf) r = sizeof buf;	uint32 o=*ofs-r;	int c=r, d;	int s;	if (*ofs<fofs+r) {		c-=fofs-o;		o=fofs;	}	if (o+c>fofs+fsize) {		c=fofs+fsize-o;	}	file->seek(o);	d=file->read(buf, c);	CPU_ADDR caddr;	caddr.addr32.seg = 0;	caddr.addr32.offset = 0;	do {		if (d>0) {			dis_insn *insn=disasm->decode(bufp, d, caddr);			s=disasm->getSize(insn);/*			if (s!=4) {				insn=disasm->decode(bufp, d, caddr);			}			assert(s==4);*/			d-=s;		} else {			s=1;		}		*(of++)=o;		o+=s;		bufp+=s;	} while (o<=*ofs);	if (of-n-1<offsets) {		*ofs=*(offsets);		return of-offsets-1;	} else {		*ofs=*(of-n-1);		return n;	}}int ht_disasm_sub::next_line_id(LINE_ID *line_id, int n){	if (line_id->id2) return 0;	uint32 *ofs = &line_id->id1;	unsigned char buf[15];	int c=0, s;	uint z;	CPU_ADDR caddr;	caddr.addr32.seg = 0;	caddr.addr32.offset = 0;	while (n--) {		z=MIN(15, (uint)(fofs+fsize-*ofs));		file->seek(*ofs);		z=file->read(buf, z);		if (z) {			dis_insn *insn=disasm->decode(buf, z, caddr);			s=disasm->getSize(insn);		} else {			s=1;		}		if (*ofs+s>fofs+fsize-1) return c;		*ofs+=s;		c++;	}	return c;}