src/debug/ppcdis.cc

/*
 *      HT Editor
 *      ppcdis.cc
 *
 *      Copyright (C) 1999-2002 Sebastian Biallas (sb@web-productions.de)
 *      Copyright 1994 Free Software Foundation, Inc.
 *      Written by Ian Lance Taylor, Cygnus Support
 *
 *      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 <cstdlib>
#include <cstring>

#include "tools/endianess.h"
#include "tools/snprintf.h"
#include "ppcdis.h"
#include "ppcopc.h"

PPCDisassembler::PPCDisassembler()
{
}

dis_insn *PPCDisassembler::decode(const byte *code, int maxlen, CPU_ADDR addr)
{
        const struct powerpc_opcode *opcode;
        const struct powerpc_opcode *opcode_end;
        uint32 op;
        int dialect = -1;

        insn.data = createHostInt(code, 4, little_endian);
        
        if (maxlen<4) {
                insn.valid = false;
                insn.size = maxlen;
                return &insn;
        }

        insn.size = 4;
        
        /* Get the major opcode of the instruction.  */
        op = PPC_OP(insn.data);

        /* Find the first match in the opcode table.  We could speed this up
           a bit by doing a binary search on the major opcode.  */
        opcode_end = powerpc_opcodes + powerpc_num_opcodes;
        
        for (opcode = powerpc_opcodes; opcode < opcode_end; opcode++) {
                uint32 table_op;
                const byte *opindex;
                const struct powerpc_operand *operand;
                bool invalid;
                bool need_comma;
                bool need_paren;

                table_op = PPC_OP (opcode->opcode);
                if (op < table_op) break;
                if (op > table_op) continue;

                if ((insn.data & opcode->mask) != opcode->opcode || (opcode->flags & dialect) == 0) {
                        continue;
                }

                /* Make two passes over the operands.  First see if any of them
                   have extraction functions, and, if they do, make sure the
                   instruction is valid.  */
                invalid = false;
                for (opindex = opcode->operands; *opindex != 0; opindex++) {
                        operand = powerpc_operands + *opindex;
                        if (operand->extract) (*operand->extract)(insn.data, &invalid);
                }
                if (invalid) continue;

                /* The instruction is valid.  */
//              fprintf(out, "%s", opcode->name);
                insn.name = opcode->name;
//              if (opcode->operands[0] != 0) fprintf(out, "\t");

                /* Now extract and print the operands.  */
                need_comma = false;
                need_paren = false;
                int opidx = 0;
                for (opindex = opcode->operands; *opindex != 0; opindex++) {
                        uint32 value;

                        operand = powerpc_operands + *opindex;

                        /* Operands that are marked FAKE are simply ignored.  We
                           already made sure that the extract function considered
                           the instruction to be valid.  */
                        if ((operand->flags & PPC_OPERAND_FAKE) != 0) continue;

                        insn.op[opidx].op = operand;
                        insn.op[opidx].flags = operand->flags;
                        /* Extract the value from the instruction.  */
                        if (operand->extract) {
                                value = (*operand->extract)(insn.data, NULL);
                        } else {
                                value = (insn.data >> operand->shift) & ((1 << operand->bits) - 1);
                                if ((operand->flags & PPC_OPERAND_SIGNED) != 0 && (value & (1 << (operand->bits - 1))) != 0) {
                                        value -= 1 << operand->bits;
                                }
                        }

                        /* If the operand is optional, and the value is zero, don't
                           print anything.  */
                        if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0 && (operand->flags & PPC_OPERAND_NEXT) == 0 && value == 0) {
                                insn.op[opidx++].imm = 0;
                                continue;
                        }

                        if (need_comma) {
//                              fprintf(out, ", ");
                                need_comma = false;
                        }

                        /* Print the operand as directed by the flags.  */
                        if ((operand->flags & PPC_OPERAND_GPR) != 0) {
                                insn.op[opidx++].reg = value;
                        } else if ((operand->flags & PPC_OPERAND_FPR) != 0) {
                                insn.op[opidx++].freg = value;
                        } else if ((operand->flags & PPC_OPERAND_VR) != 0) {
                                insn.op[opidx++].vreg = value;
                        } else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0) {
                                insn.op[opidx++].rel.mem = addr.addr32.offset + value;
                        } else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0) {
                                insn.op[opidx++].abs.mem = value;
                        } else if ((operand->flags & PPC_OPERAND_CR) == 0 || (dialect & PPC_OPCODE_PPC) == 0) {
                                insn.op[opidx++].imm = value;
                        } else {
                                insn.op[opidx++].creg = value;
                                if (operand->bits == 3) {
//                                      fprintf(out, "cr%d", value);
                                } else {

//                                      static const char *cbnames[4] = { "lt", "gt", "eq", "so" };
                                        int cr;
                                        int cc;
                                        cr = value >> 2;
//                                      if (cr != 0) fprintf(out, "4*cr%d", cr);
                                        cc = value & 3;
                                        if (cc != 0) {
//                                              if (cr != 0) fprintf(out, "+");
//                                              fprintf(out, "%s", cbnames[cc]);
                                        }
                                }
                        }

                        if (need_paren) {
//                              fprintf(out, ")");
                                need_paren = false;
                        }

                        if ((operand->flags & PPC_OPERAND_PARENS) == 0) {
                                need_comma = true;
                        } else {
//                              fprintf(out, "(");
                                need_paren = true;
                        }
                }
                insn.ops = opidx;

                /* We have found and printed an instruction; return.  */
                insn.valid = true;
                return &insn;
        }

        insn.valid = false;
        return &insn;
}

dis_insn *PPCDisassembler::duplicateInsn(dis_insn *disasm_insn)
{
        ppcdis_insn *insn = (ppcdis_insn *)malloc(sizeof (ppcdis_insn));
        *insn = *(ppcdis_insn *)disasm_insn;
        return insn;
}

void PPCDisassembler::getOpcodeMetrics(int &min_length, int &max_length, int &min_look_ahead, int &avg_look_ahead, int &addr_align)
{
        min_length = max_length = min_look_ahead = avg_look_ahead = addr_align = 4;
}

byte PPCDisassembler::getSize(dis_insn *disasm_insn)
{
        return ((ppcdis_insn*)disasm_insn)->size;
}

char *PPCDisassembler::getName()
{
        return "PPC/Disassembler";
}

char *PPCDisassembler::str(dis_insn *disasm_insn, int style)
{
        return strf(disasm_insn, style, "");
}

char *PPCDisassembler::strf(dis_insn *disasm_insn, int style, 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);

        ppcdis_insn *ppc_insn = (ppcdis_insn *) disasm_insn;
        if (!ppc_insn->valid) {
                switch (ppc_insn->size) {
                        case 1:
                                strcpy(insnstr, "db         ?");
                                break;
                        case 2:
                                strcpy(insnstr, "dw         ?");
                                break;
                        case 3:
                                strcpy(insnstr, "db         ? * 3");
                                break;
                        case 4:
                                ht_snprintf(insnstr, sizeof insnstr, "dd        %s0x%08x", cs_number, ppc_insn->data);
                                break;
                        default: { /* braces for empty assert */
                        }
                }
        } else {
                char *is = insnstr+sprintf(insnstr, "%-10s", ppc_insn->name);
                int dialect=-1;

                bool need_comma = false;
                bool need_paren = false;
                for (int opidx = 0; opidx < ppc_insn->ops; opidx++) {
                        int flags = ppc_insn->op[opidx].flags;
/*                      if ((flags & PPC_OPERAND_OPTIONAL) != 0 && (flags & PPC_OPERAND_NEXT) == 0 && ppc_insn->op[opidx].imm == 0) {
                                continue;
                        }*/
                        if (need_comma) {
                                is += sprintf(is, "%s, ", cs_symbol);
                                need_comma = false;
                        }
                        if ((flags & PPC_OPERAND_GPR) != 0) {
                                is += sprintf(is, "%sr%d", cs_default, ppc_insn->op[opidx].reg);
                        } else if ((flags & PPC_OPERAND_FPR) != 0) {
                                is += sprintf(is, "%sf%d", cs_default, ppc_insn->op[opidx].freg);
                        } else if ((flags & PPC_OPERAND_VR) != 0) {
                                is += sprintf(is, "%svr%d", cs_default, ppc_insn->op[opidx].vreg);
                        } else if ((flags & PPC_OPERAND_RELATIVE) != 0) {
                                CPU_ADDR caddr;
                                caddr.addr32.offset = (uint32)ppc_insn->op[opidx].mem.disp;
                                int slen;
                                char *s = (addr_sym_func) ? addr_sym_func(caddr, &slen, addr_sym_func_context) : 0;
                                if (s) {
                                        is += sprintf(is, "%s", cs_default);
                                        memmove(is, s, slen);
                                        is[slen] = 0;
                                        is += slen;
                                } else {
                                        is += sprintf(is, "%s0x%x", cs_number, ppc_insn->op[opidx].rel.mem);
                                }
                        } else if ((flags & PPC_OPERAND_ABSOLUTE) != 0) {
                                is += sprintf(is, "%s0x%x", cs_number, ppc_insn->op[opidx].abs.mem);
                        } else if ((flags & PPC_OPERAND_CR) == 0 || (dialect & PPC_OPCODE_PPC) == 0) {
                                is += sprintf(is, "%s%d", cs_number, ppc_insn->op[opidx].imm);
                        } else if (ppc_insn->op[opidx].op->bits == 3) {
                                is += sprintf(is, "%scr%d", cs_default, ppc_insn->op[opidx].creg);
                        } else {
                                static const char *cbnames[4] = { "lt", "gt", "eq", "so" };
                                int cr;
                                int cc;
                                cr = ppc_insn->op[opidx].creg >> 2;
                                if (cr != 0) is += sprintf(is, "%s4%s*%scr%d", cs_number, cs_symbol, cs_default, cr);
                                cc = ppc_insn->op[opidx].creg & 3;
                                if (cc != 0) {
                                        if (cr != 0) is += sprintf(is, "%s+", cs_symbol);
                                        is += sprintf(is, "%s%s", cs_default, cbnames[cc]);
                                }
                        }
                
                        if (need_paren) {
                                is += sprintf(is, "%s)", cs_symbol);
                                need_paren = false;
                        }

                        if ((flags & PPC_OPERAND_PARENS) == 0) {
                                need_comma = true;
                        } else {
                                is += sprintf(is, "%s(", cs_symbol);
                                need_paren = true;
                        }
                }
        }
        disable_highlighting();
        return insnstr;     
}

ObjectID PPCDisassembler::getObjectID() const
{
        return 0;
}

bool PPCDisassembler::validInsn(dis_insn *disasm_insn)
{
        return ((ppcdis_insn*)disasm_insn)->valid;
}


1	dpavlin	1	/*
2			* HT Editor
3			* ppcdis.cc
4			*
5			* Copyright (C) 1999-2002 Sebastian Biallas (sb@web-productions.de)
6			* Copyright 1994 Free Software Foundation, Inc.
7			* Written by Ian Lance Taylor, Cygnus Support
8			*
9			* This program is free software; you can redistribute it and/or modify
10			* it under the terms of the GNU General Public License version 2 as
11			* published by the Free Software Foundation.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program; if not, write to the Free Software
20			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21			*/
22
23			#include <cstdlib>
24			#include <cstring>
25
26			#include "tools/endianess.h"
27			#include "tools/snprintf.h"
28			#include "ppcdis.h"
29			#include "ppcopc.h"
30
31			PPCDisassembler::PPCDisassembler()
32			{
33			}
34
35			dis_insn PPCDisassembler::decode(const byte code, int maxlen, CPU_ADDR addr)
36			{
37			const struct powerpc_opcode *opcode;
38			const struct powerpc_opcode *opcode_end;
39			uint32 op;
40			int dialect = -1;
41
42			insn.data = createHostInt(code, 4, little_endian);
43
44			if (maxlen<4) {
45			insn.valid = false;
46			insn.size = maxlen;
47			return &insn;
48			}
49
50			insn.size = 4;
51
52			/* Get the major opcode of the instruction. */
53			op = PPC_OP(insn.data);
54
55			/* Find the first match in the opcode table. We could speed this up
56			a bit by doing a binary search on the major opcode. */
57			opcode_end = powerpc_opcodes + powerpc_num_opcodes;
58
59			for (opcode = powerpc_opcodes; opcode < opcode_end; opcode++) {
60			uint32 table_op;
61			const byte *opindex;
62			const struct powerpc_operand *operand;
63			bool invalid;
64			bool need_comma;
65			bool need_paren;
66
67			table_op = PPC_OP (opcode->opcode);
68			if (op < table_op) break;
69			if (op > table_op) continue;
70
71			if ((insn.data & opcode->mask) != opcode->opcode \|\| (opcode->flags & dialect) == 0) {
72			continue;
73			}
74
75			/* Make two passes over the operands. First see if any of them
76			have extraction functions, and, if they do, make sure the
77			instruction is valid. */
78			invalid = false;
79			for (opindex = opcode->operands; *opindex != 0; opindex++) {
80			operand = powerpc_operands + *opindex;
81			if (operand->extract) (*operand->extract)(insn.data, &invalid);
82			}
83			if (invalid) continue;
84
85			/* The instruction is valid. */
86			// fprintf(out, "%s", opcode->name);
87			insn.name = opcode->name;
88			// if (opcode->operands[0] != 0) fprintf(out, "\t");
89
90			/* Now extract and print the operands. */
91			need_comma = false;
92			need_paren = false;
93			int opidx = 0;
94			for (opindex = opcode->operands; *opindex != 0; opindex++) {
95			uint32 value;
96
97			operand = powerpc_operands + *opindex;
98
99			/* Operands that are marked FAKE are simply ignored. We
100			already made sure that the extract function considered
101			the instruction to be valid. */
102			if ((operand->flags & PPC_OPERAND_FAKE) != 0) continue;
103
104			insn.op[opidx].op = operand;
105			insn.op[opidx].flags = operand->flags;
106			/* Extract the value from the instruction. */
107			if (operand->extract) {
108			value = (*operand->extract)(insn.data, NULL);
109			} else {
110			value = (insn.data >> operand->shift) & ((1 << operand->bits) - 1);
111			if ((operand->flags & PPC_OPERAND_SIGNED) != 0 && (value & (1 << (operand->bits - 1))) != 0) {
112			value -= 1 << operand->bits;
113			}
114			}
115
116			/* If the operand is optional, and the value is zero, don't
117			print anything. */
118			if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0 && (operand->flags & PPC_OPERAND_NEXT) == 0 && value == 0) {
119			insn.op[opidx++].imm = 0;
120			continue;
121			}
122
123			if (need_comma) {
124			// fprintf(out, ", ");
125			need_comma = false;
126			}
127
128			/* Print the operand as directed by the flags. */
129			if ((operand->flags & PPC_OPERAND_GPR) != 0) {
130			insn.op[opidx++].reg = value;
131			} else if ((operand->flags & PPC_OPERAND_FPR) != 0) {
132			insn.op[opidx++].freg = value;
133			} else if ((operand->flags & PPC_OPERAND_VR) != 0) {
134			insn.op[opidx++].vreg = value;
135			} else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0) {
136			insn.op[opidx++].rel.mem = addr.addr32.offset + value;
137			} else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0) {
138			insn.op[opidx++].abs.mem = value;
139			} else if ((operand->flags & PPC_OPERAND_CR) == 0 \|\| (dialect & PPC_OPCODE_PPC) == 0) {
140			insn.op[opidx++].imm = value;
141			} else {
142			insn.op[opidx++].creg = value;
143			if (operand->bits == 3) {
144			// fprintf(out, "cr%d", value);
145			} else {
146
147			// static const char *cbnames[4] = { "lt", "gt", "eq", "so" };
148			int cr;
149			int cc;
150			cr = value >> 2;
151			// if (cr != 0) fprintf(out, "4*cr%d", cr);
152			cc = value & 3;
153			if (cc != 0) {
154			// if (cr != 0) fprintf(out, "+");
155			// fprintf(out, "%s", cbnames[cc]);
156			}
157			}
158			}
159
160			if (need_paren) {
161			// fprintf(out, ")");
162			need_paren = false;
163			}
164
165			if ((operand->flags & PPC_OPERAND_PARENS) == 0) {
166			need_comma = true;
167			} else {
168			// fprintf(out, "(");
169			need_paren = true;
170			}
171			}
172			insn.ops = opidx;
173
174			/* We have found and printed an instruction; return. */
175			insn.valid = true;
176			return &insn;
177			}
178
179			insn.valid = false;
180			return &insn;
181			}
182
183			dis_insn PPCDisassembler::duplicateInsn(dis_insn disasm_insn)
184			{
185			ppcdis_insn insn = (ppcdis_insn )malloc(sizeof (ppcdis_insn));
186			insn = (ppcdis_insn *)disasm_insn;
187			return insn;
188			}
189
190			void PPCDisassembler::getOpcodeMetrics(int &min_length, int &max_length, int &min_look_ahead, int &avg_look_ahead, int &addr_align)
191			{
192			min_length = max_length = min_look_ahead = avg_look_ahead = addr_align = 4;
193			}
194
195			byte PPCDisassembler::getSize(dis_insn *disasm_insn)
196			{
197			return ((ppcdis_insn*)disasm_insn)->size;
198			}
199
200			char *PPCDisassembler::getName()
201			{
202			return "PPC/Disassembler";
203			}
204
205			char PPCDisassembler::str(dis_insn disasm_insn, int style)
206			{
207			return strf(disasm_insn, style, "");
208			}
209
210			char PPCDisassembler::strf(dis_insn disasm_insn, int style, char *format)
211			{
212			if (style & DIS_STYLE_HIGHLIGHT) enable_highlighting();
213
214			const char *cs_default = get_cs(e_cs_default);
215			const char *cs_number = get_cs(e_cs_number);
216			const char *cs_symbol = get_cs(e_cs_symbol);
217
218			ppcdis_insn ppc_insn = (ppcdis_insn ) disasm_insn;
219			if (!ppc_insn->valid) {
220			switch (ppc_insn->size) {
221			case 1:
222			strcpy(insnstr, "db ?");
223			break;
224			case 2:
225			strcpy(insnstr, "dw ?");
226			break;
227			case 3:
228			strcpy(insnstr, "db ? * 3");
229			break;
230			case 4:
231			ht_snprintf(insnstr, sizeof insnstr, "dd %s0x%08x", cs_number, ppc_insn->data);
232			break;
233			default: { /* braces for empty assert */
234			}
235			}
236			} else {
237			char *is = insnstr+sprintf(insnstr, "%-10s", ppc_insn->name);
238			int dialect=-1;
239
240			bool need_comma = false;
241			bool need_paren = false;
242			for (int opidx = 0; opidx < ppc_insn->ops; opidx++) {
243			int flags = ppc_insn->op[opidx].flags;
244			/* if ((flags & PPC_OPERAND_OPTIONAL) != 0 && (flags & PPC_OPERAND_NEXT) == 0 && ppc_insn->op[opidx].imm == 0) {
245			continue;
246			}*/
247			if (need_comma) {
248			is += sprintf(is, "%s, ", cs_symbol);
249			need_comma = false;
250			}
251			if ((flags & PPC_OPERAND_GPR) != 0) {
252			is += sprintf(is, "%sr%d", cs_default, ppc_insn->op[opidx].reg);
253			} else if ((flags & PPC_OPERAND_FPR) != 0) {
254			is += sprintf(is, "%sf%d", cs_default, ppc_insn->op[opidx].freg);
255			} else if ((flags & PPC_OPERAND_VR) != 0) {
256			is += sprintf(is, "%svr%d", cs_default, ppc_insn->op[opidx].vreg);
257			} else if ((flags & PPC_OPERAND_RELATIVE) != 0) {
258			CPU_ADDR caddr;
259			caddr.addr32.offset = (uint32)ppc_insn->op[opidx].mem.disp;
260			int slen;
261			char *s = (addr_sym_func) ? addr_sym_func(caddr, &slen, addr_sym_func_context) : 0;
262			if (s) {
263			is += sprintf(is, "%s", cs_default);
264			memmove(is, s, slen);
265			is[slen] = 0;
266			is += slen;
267			} else {
268			is += sprintf(is, "%s0x%x", cs_number, ppc_insn->op[opidx].rel.mem);
269			}
270			} else if ((flags & PPC_OPERAND_ABSOLUTE) != 0) {
271			is += sprintf(is, "%s0x%x", cs_number, ppc_insn->op[opidx].abs.mem);
272			} else if ((flags & PPC_OPERAND_CR) == 0 \|\| (dialect & PPC_OPCODE_PPC) == 0) {
273			is += sprintf(is, "%s%d", cs_number, ppc_insn->op[opidx].imm);
274			} else if (ppc_insn->op[opidx].op->bits == 3) {
275			is += sprintf(is, "%scr%d", cs_default, ppc_insn->op[opidx].creg);
276			} else {
277			static const char *cbnames[4] = { "lt", "gt", "eq", "so" };
278			int cr;
279			int cc;
280			cr = ppc_insn->op[opidx].creg >> 2;
281			if (cr != 0) is += sprintf(is, "%s4%s*%scr%d", cs_number, cs_symbol, cs_default, cr);
282			cc = ppc_insn->op[opidx].creg & 3;
283			if (cc != 0) {
284			if (cr != 0) is += sprintf(is, "%s+", cs_symbol);
285			is += sprintf(is, "%s%s", cs_default, cbnames[cc]);
286			}
287			}
288
289			if (need_paren) {
290			is += sprintf(is, "%s)", cs_symbol);
291			need_paren = false;
292			}
293
294			if ((flags & PPC_OPERAND_PARENS) == 0) {
295			need_comma = true;
296			} else {
297			is += sprintf(is, "%s(", cs_symbol);
298			need_paren = true;
299			}
300			}
301			}
302			disable_highlighting();
303			return insnstr;
304			}
305
306			ObjectID PPCDisassembler::getObjectID() const
307			{
308			return 0;
309			}
310
311			bool PPCDisassembler::validInsn(dis_insn *disasm_insn)
312			{
313			return ((ppcdis_insn*)disasm_insn)->valid;
314			}
315
316