mon/src/mon_disass.cpp

/*
 *  mon_disass.cpp - Disassemblers
 *
 *  cxmon (C) 1997-2002 Christian Bauer, Marc Hellwig
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"

#include <stdarg.h>

#include "mon.h"
#include "mon_disass.h"

#include "mon_atraps.h"
#include "mon_lowmem.h"


// Flag: enable MacOS A-Trap and LM globals lookup in 68k disassembler
bool mon_macos_mode = false;


/*
 *  GNU disassembler callbacks
 */

extern "C" {
#include "disass/dis-asm.h"

int buffer_read_memory(bfd_vma from, bfd_byte *to, unsigned int length, struct disassemble_info *info)
{
        while (length--)
                *to++ = mon_read_byte(from++);
        return 0;
}

void perror_memory(int status, bfd_vma memaddr, struct disassemble_info *info)
{
        info->fprintf_func(info->stream, "Unknown error %d\n", status);
}

bool lookup_lowmem;

void generic_print_address(bfd_vma addr, struct disassemble_info *info)
{
        if (lookup_lowmem && addr >= 0x100 && addr < 0x3000) {
                if (((addr >= 0x400 && addr < 0x800) || (addr >= 0xe00 && addr < 0x1e00)) && ((addr & 3) == 0)) {
                        // Look for address in A-Trap table
                        uint16 opcode = (addr < 0xe00 ? 0xa000 + (addr - 0x400) / 4 : 0xa800 + (addr - 0xe00) / 4);
                        uint16 mask = (addr < 0xe00 ? 0xf8ff : 0xffff);
                        const atrap_info *p = atraps;
                        while (p->word) {
                                if ((p->word & mask) == opcode) {
                                        info->fprintf_func(info->stream, p->name);
                                        return;
                                }
                                p++;
                        }
                } else {
                        // Look for address in low memory globals table
                        const lowmem_info *p = lowmem;
                        while (p->name) {
                                if (addr >= p[0].addr && addr < p[1].addr) {
                                        if (addr == p[0].addr)
                                                info->fprintf_func(info->stream, "%s", p->name);
                                        else
                                                info->fprintf_func(info->stream, "%s+%d", p->name, addr - p->addr);
                                        return;
                                }
                                p++;
                        }
                }
        }
        info->fprintf_func(info->stream, "$%08x", addr);
}

int generic_symbol_at_address(bfd_vma addr, struct disassemble_info *info)
{
        return 0;
}

void print_68k_invalid_opcode(unsigned long opcode, struct disassemble_info *info)
{
        if (mon_macos_mode) {
                // Look for MacOS A-Trap
                const atrap_info *p = atraps;
                while (p->word) {
                        if (p->word == opcode) {
                                info->fprintf_func(info->stream, p->name);
                                return;
                        }
                        p++;
                }
        }
        info->fprintf_func(info->stream, "?");
}

};


/*
 *  sprintf into a "stream"
 */

struct SFILE {
        char *buffer;
        char *current;
};

static int mon_sprintf(SFILE *f, const char *format, ...)
{
        int n;
        va_list args;
        va_start(args, format);
        vsprintf(f->current, format, args);
        f->current += n = strlen(f->current);
        va_end(args);
        return n;
}


/*
 *  Disassemble one instruction, return number of bytes
 */

int disass_68k(FILE *f, uint32 adr)
{
        // Initialize info for GDB disassembler
        disassemble_info info;
        char buf[1024];
        SFILE sfile = {buf, buf};
        sfile.buffer = buf;
        sfile.current = buf;
        INIT_DISASSEMBLE_INFO(info, (FILE *)&sfile, (fprintf_ftype)mon_sprintf);

        // Disassemble instruction
        lookup_lowmem = mon_macos_mode;
        int num = print_insn_m68k(adr, &info);

        for (int i=0; i<6; i+=2) {
                if (num > i)
                        fprintf(f, "%04x ", mon_read_half(adr + i));
                else
                        fprintf(f, "     ");
        }
        if (num == 8)
                fprintf(f, "%04x\t%s\n", mon_read_half(adr + 6), buf);
        else if (num > 8)
                fprintf(f, "...\t%s\n", buf);
        else
                fprintf(f, "   \t%s\n", buf);

        return num;
}

int disass_x86(FILE *f, uint32 adr, uint32 bits)
{
        // Initialize info for GDB disassembler
        disassemble_info info;
        char buf[1024];
        SFILE sfile = {buf, buf};
        sfile.buffer = buf;
        sfile.current = buf;
        INIT_DISASSEMBLE_INFO(info, (FILE *)&sfile, (fprintf_ftype)mon_sprintf);
        if (bits == 16)
                info.mach = bfd_mach_i386_i8086;
        else if (bits == 64)
                info.mach = bfd_mach_x86_64;

        // Disassemble instruction
        lookup_lowmem = false;
        int num = print_insn_i386_att(adr, &info);

        for (int i=0; i<6; i++) {
                if (num > i)
                        fprintf(f, "%02x ", mon_read_byte(adr + i));
                else
                        fprintf(f, "   ");
        }
        if (num == 7)
                fprintf(f, "%02x\t%s\n", mon_read_byte(adr + 7), buf);
        else if (num > 7)
                fprintf(f, "..\t%s\n", buf);
        else
                fprintf(f, "  \t%s\n", buf);

        return num;
}
Revision:	1.7
Committed:	2003-02-03T21:40:46Z (21 years, 3 months ago) by gbeauche
Branch:	MAIN
Changes since 1.6:	+1 -1 lines
Log Message:	Force use of AT&T syntax for x86[-64] disassembly
#	User	Rev	Content
1	cebix	1.1	/*
2			* mon_disass.cpp - Disassemblers
3			*
4	cebix	1.5	* cxmon (C) 1997-2002 Christian Bauer, Marc Hellwig
5	cebix	1.1	*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include "sysdeps.h"
22
23			#include <stdarg.h>
24
25			#include "mon.h"
26			#include "mon_disass.h"
27	cebix	1.2
28			#include "mon_atraps.h"
29	cebix	1.1	#include "mon_lowmem.h"
30
31
32	cebix	1.2	// Flag: enable MacOS A-Trap and LM globals lookup in 68k disassembler
33			bool mon_macos_mode = false;
34
35
36	cebix	1.1	/*
37			* GNU disassembler callbacks
38			*/
39
40			extern "C" {
41			#include "disass/dis-asm.h"
42
43	gbeauche	1.6	int buffer_read_memory(bfd_vma from, bfd_byte to, unsigned int length, struct disassemble_info info)
44	cebix	1.1	{
45			while (length--)
46			*to++ = mon_read_byte(from++);
47			return 0;
48			}
49
50			void perror_memory(int status, bfd_vma memaddr, struct disassemble_info *info)
51			{
52			info->fprintf_func(info->stream, "Unknown error %d\n", status);
53			}
54
55			bool lookup_lowmem;
56
57			void generic_print_address(bfd_vma addr, struct disassemble_info *info)
58			{
59	cebix	1.2	if (lookup_lowmem && addr >= 0x100 && addr < 0x3000) {
60			if (((addr >= 0x400 && addr < 0x800) \|\| (addr >= 0xe00 && addr < 0x1e00)) && ((addr & 3) == 0)) {
61			// Look for address in A-Trap table
62			uint16 opcode = (addr < 0xe00 ? 0xa000 + (addr - 0x400) / 4 : 0xa800 + (addr - 0xe00) / 4);
63			uint16 mask = (addr < 0xe00 ? 0xf8ff : 0xffff);
64			const atrap_info *p = atraps;
65			while (p->word) {
66			if ((p->word & mask) == opcode) {
67			info->fprintf_func(info->stream, p->name);
68			return;
69			}
70			p++;
71			}
72			} else {
73			// Look for address in low memory globals table
74			const lowmem_info *p = lowmem;
75			while (p->name) {
76			if (addr >= p[0].addr && addr < p[1].addr) {
77			if (addr == p[0].addr)
78			info->fprintf_func(info->stream, "%s", p->name);
79			else
80			info->fprintf_func(info->stream, "%s+%d", p->name, addr - p->addr);
81			return;
82			}
83			p++;
84	cebix	1.1	}
85			}
86			}
87			info->fprintf_func(info->stream, "$%08x", addr);
88			}
89
90			int generic_symbol_at_address(bfd_vma addr, struct disassemble_info *info)
91			{
92			return 0;
93			}
94
95	cebix	1.2	void print_68k_invalid_opcode(unsigned long opcode, struct disassemble_info *info)
96			{
97			if (mon_macos_mode) {
98			// Look for MacOS A-Trap
99			const atrap_info *p = atraps;
100			while (p->word) {
101			if (p->word == opcode) {
102			info->fprintf_func(info->stream, p->name);
103			return;
104			}
105			p++;
106			}
107			}
108			info->fprintf_func(info->stream, "?");
109			}
110
111	cebix	1.1	};
112
113
114			/*
115			* sprintf into a "stream"
116			*/
117
118			struct SFILE {
119			char *buffer;
120			char *current;
121			};
122
123			static int mon_sprintf(SFILE f, const char format, ...)
124			{
125			int n;
126			va_list args;
127			va_start(args, format);
128			vsprintf(f->current, format, args);
129			f->current += n = strlen(f->current);
130			va_end(args);
131			return n;
132			}
133
134
135			/*
136			* Disassemble one instruction, return number of bytes
137			*/
138
139			int disass_68k(FILE *f, uint32 adr)
140			{
141			// Initialize info for GDB disassembler
142			disassemble_info info;
143			char buf[1024];
144			SFILE sfile = {buf, buf};
145			sfile.buffer = buf;
146			sfile.current = buf;
147			INIT_DISASSEMBLE_INFO(info, (FILE *)&sfile, (fprintf_ftype)mon_sprintf);
148
149			// Disassemble instruction
150	cebix	1.2	lookup_lowmem = mon_macos_mode;
151	cebix	1.1	int num = print_insn_m68k(adr, &info);
152	cebix	1.2
153			for (int i=0; i<6; i+=2) {
154			if (num > i)
155			fprintf(f, "%04x ", mon_read_half(adr + i));
156			else
157			fprintf(f, " ");
158			}
159	cebix	1.1	if (num == 8)
160			fprintf(f, "%04x\t%s\n", mon_read_half(adr + 6), buf);
161	cebix	1.2	else if (num > 8)
162	cebix	1.1	fprintf(f, "...\t%s\n", buf);
163			else
164			fprintf(f, " \t%s\n", buf);
165	cebix	1.2
166	cebix	1.1	return num;
167			}
168
169	gbeauche	1.6	int disass_x86(FILE *f, uint32 adr, uint32 bits)
170	cebix	1.1	{
171			// Initialize info for GDB disassembler
172			disassemble_info info;
173			char buf[1024];
174			SFILE sfile = {buf, buf};
175			sfile.buffer = buf;
176			sfile.current = buf;
177			INIT_DISASSEMBLE_INFO(info, (FILE *)&sfile, (fprintf_ftype)mon_sprintf);
178	gbeauche	1.6	if (bits == 16)
179	cebix	1.3	info.mach = bfd_mach_i386_i8086;
180	gbeauche	1.6	else if (bits == 64)
181			info.mach = bfd_mach_x86_64;
182	cebix	1.1
183			// Disassemble instruction
184			lookup_lowmem = false;
185	gbeauche	1.7	int num = print_insn_i386_att(adr, &info);
186	cebix	1.2
187			for (int i=0; i<6; i++) {
188			if (num > i)
189			fprintf(f, "%02x ", mon_read_byte(adr + i));
190			else
191			fprintf(f, " ");
192			}
193			if (num == 7)
194			fprintf(f, "%02x\t%s\n", mon_read_byte(adr + 7), buf);
195			else if (num > 7)
196			fprintf(f, "..\t%s\n", buf);
197			else
198			fprintf(f, " \t%s\n", buf);
199
200	cebix	1.1	return num;
201			}