[binutils.git] / gdb / arm-pinsn.c

/* Print ARM instructions for GDB, the GNU debugger.
   Copyright (C) 1986, 1989 Free Software Foundation, Inc.

This file is part of GDB.

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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <stdio.h>
#include <ctype.h>
#include <assert.h>

#include "defs.h"
#include "param.h"
#include "symtab.h"
#include "arm-opcode.h"

extern char *reg_names[];

static char *shift_names[] = {
    "lsl", "lsr", "asr", "ror",
};

static char *cond_names[] = {
	"eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
	"hi", "ls", "ge", "lt", "gt", "le", "", "nv"
};

static char float_precision[] = "sdep";
static char float_rounding[] = " pmz";
static float float_immed[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 0.5, 10.0 };

static void print_ldr_str_offset();
static void print_ldc_stc_offset();
static long immediate_value();
\f
/* Print the ARM instruction at address MEMADDR in debugged memory,
   on STREAM.  Returns length of the instruction, in bytes.  */

int
print_insn (memaddr, stream)
     CORE_ADDR memaddr;
     FILE *stream;
{
    unsigned long ins;
    register struct opcode *op;
    register char *p;
    register int i, c;
    int s, e, val;

    ins = read_memory_integer(memaddr, 4);
    for (i = 0, op = opcodes; i < N_OPCODES; i++, op++)
	if ((ins & op->mask) == op->value) break;
    assert(i != N_OPCODES);
    
    for (p = op->assembler; *p;) {
	c = *p++;
	if (c == '%') {
	    s = e = 0;
	    while (isdigit(*p))
		s = s*10 + (*p++ - '0');
	    if (*p == '-') {
		p++;
		while (isdigit(*p))
		    e = e*10 + (*p++ - '0');
	    } else
		e = s;
	    assert(s >= 0 && s <= 31 && e >= 0 && e <= 31);
	    val = (ins >> s) & ((1 << (e + 1 - s)) - 1);
	    switch (*p++) {
	    case '%' :
		putc('%', stream);
		break;
	    case 'd' :
		fprintf(stream, "%d", val);
		break;
	    case 'x' :
		fprintf(stream, "%x", val);
		break;
	    case 'r' :
		assert(val >= 0 && val <= 15);
		fprintf(stream, "%s", reg_names[val]);
		break;
	    case 'c' :
		fprintf(stream, "%s", cond_names[ins >> 28]);
		break;
	    case '\'' :
		assert(*p);
		c = *p++;
		if (val)
		    putc(c, stream);
		break;
	    case '`' :
		assert(*p);
		c = *p++;
		if (!val)
		    putc(c, stream);
		break;
	    case '?' :
		assert(*p);
		c = *p++;
		assert(*p);
		if (val)
		    p++;
		else
		    c = *p++;
		putc(c, stream);
		break;
	    case 'p' :
		if (((ins >> 12) & 0xf) == 0xf)
		    putc('p', stream);
		break;
	    case 'o' :
		if (ins & (1<<25)) {
		    int immed = immediate_value(ins & 0xfff);
		    fprintf (stream, "#%d (0x%x)", immed, immed);
		} else {
		    int operand2 = ins & 0xfff;
		    /* in operand2 :
		       bits 0-3 are the base register
		       bits 5-6 are the shift (0=lsl, 1=lsr, 2=asr, 3=ror)
		       if bit 4 is zero then bits 7-11 are an immediate shift count
		       else bit 7 must be zero and bits 8-11 are the register
		       to be used as a shift count.
		       Note: no shift at all is encoded as "reg lsl #0" */
		    fprintf (stream, "%s", reg_names[operand2 & 0xf]);
		    if (operand2 & 0xff0) {
			/* ror #0 is really rrx (rotate right extend) */
			if ((operand2 & 0xff0) == 0x060)
			    fprintf (stream, ", rrx");
			else {
			    fprintf (stream, ", %s ",
				     shift_names[(operand2 >> 5) & 3]);
			    if (operand2 & (1<<4)) /* register shift */
				fprintf (stream, "%s",
					 reg_names[operand2 >> 8]);
			    else	/* immediate shift */
				fprintf (stream, "#%d",
					 operand2 >> 7);
			}
		    }
		}
		break;
	    case 'a' :
		fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]);
		if (ins & (1<<24)) {
		    fprintf (stream, ", ");
		    print_ldr_str_offset (ins, stream);
		    putc (']', stream);
		    if (ins & (1<<21)) putc('!', stream);
		    /* If it is a pc relative load, then it is probably
		       a constant so print it */
		    if (((ins >> 16) & 0xf) == 15 &&
			(ins & (1<<25)) == 0 &&
			(ins & (1<<20))) {
			int addr = memaddr + 8 +
			    (ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1);
			fprintf (stream, " (contents=");
			print_address (read_memory_integer(addr, 4), stream);
			fprintf (stream, ")");
		    }
		} else {
		    fprintf (stream, "]," );
		    print_ldr_str_offset (ins, stream);
		}
		break;
	    case 'b' :
		print_address (memaddr + 8 + (((int)ins << 8) >> 6), stream);
		break;
	    case 'A' :
		fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]);
		if (ins & (1<<24)) {
		    fprintf (stream, ", ");
		    print_ldc_stc_offset (ins, stream);
		    putc(']', stream);
		    if (ins & (1<<21))
			putc('!', stream);
		} else {
		    fprintf (stream, "], ");
		    print_ldc_stc_offset (ins, stream);
		}
		break;
	    case 'm' :
		{
		    int regnum, first = 1;
		    putc('{', stream);
		    for (regnum = 0; regnum < 16; regnum++)
			if (ins & (1<<regnum)) {
			    if (!first)
				putc (',', stream);
			    first = 0;
			    fprintf (stream, "%s", reg_names[regnum]);
			}
		    putc('}', stream);
		}
		break;
	    case 'P' :
		val = ((ins >> 18) & 2) | ((ins >> 7) & 1);
		putc(float_precision[val], stream);
		break;
	    case 'Q' :
		val = ((ins >> 21) & 2) | ((ins >> 15) & 1);
		putc(float_precision[val], stream);
		break;
	    case 'R' :
		val = ((ins >> 5) & 3);
		if (val) putc(float_rounding[val], stream);
		break;
	    case 'f' :
		assert(val >= 0 && val <= 15);
		if (val > 7)
		    fprintf (stream, "#%3.1f", float_immed[val - 8]);
		else
		    fprintf (stream, "f%d", val);
		break;
	    default:
		abort();
	    }
	} else
	    putc(c, stream);
    }
    return 4;
}

static long
immediate_value(operand)
int operand;
{
    int val = operand & 0xff;
    int shift = 2*(operand >> 8);
    /* immediate value is (val ror shift) */
    return (val >> shift) | (val << (32 - shift));
}

static void
print_ldr_str_offset(ins, stream)
unsigned long ins;
FILE *stream;
{
    if ((ins & (1<<25)) == 0)
	fprintf (stream, "#%d",
		 (ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1));
    else {
	fprintf (stream, "%s%s", reg_names[ins & 0xf],
		 (ins & (1<<23)) ? "" : "-");
	if (ins & 0xff0)
	    fprintf (stream, ", %s #%d",
		     shift_names[(ins >> 5) & 3],
		     (ins >> 7) & 0x1f);
    }
}

static void
print_ldc_stc_offset(ins, stream)
unsigned long ins;
FILE *stream;
{
    fprintf (stream, "#%d",
	     4 * (ins & 0xff) * ((ins & (1<<23)) ? 1 : -1));
}
Commit	Line	Data
dd3b648e RP	1	/* Print ARM instructions for GDB, the GNU debugger.
	2	Copyright (C) 1986, 1989 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
99a7de40	6	This program is free software; you can redistribute it and/or modify
dd3b648e	7	it under the terms of the GNU General Public License as published by
99a7de40 JG	8	the Free Software Foundation; either version 2 of the License, or
99a7de40 JG	9	(at your option) any later version.
dd3b648e	10
99a7de40	11	This program is distributed in the hope that it will be useful,
dd3b648e RP	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
99a7de40 JG	17	along with this program; if not, write to the Free Software
99a7de40 JG	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
dd3b648e RP	19
	20	#include <stdio.h>
	21	#include <ctype.h>
	22	#include <assert.h>
	23
	24	#include "defs.h"
	25	#include "param.h"
	26	#include "symtab.h"
	27	#include "arm-opcode.h"
	28
	29	extern char *reg_names[];
	30
	31	static char *shift_names[] = {
	32	"lsl", "lsr", "asr", "ror",
	33	};
	34
	35	static char *cond_names[] = {
	36	"eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
	37	"hi", "ls", "ge", "lt", "gt", "le", "", "nv"
	38	};
	39
	40	static char float_precision[] = "sdep";
	41	static char float_rounding[] = " pmz";
	42	static float float_immed[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 0.5, 10.0 };
	43
	44	static void print_ldr_str_offset();
	45	static void print_ldc_stc_offset();
	46	static long immediate_value();
	47	\f
	48	/* Print the ARM instruction at address MEMADDR in debugged memory,
	49	on STREAM. Returns length of the instruction, in bytes. */
	50
	51	int
	52	print_insn (memaddr, stream)
	53	CORE_ADDR memaddr;
	54	FILE *stream;
	55	{
	56	unsigned long ins;
	57	register struct opcode *op;
	58	register char *p;
	59	register int i, c;
	60	int s, e, val;
	61
	62	ins = read_memory_integer(memaddr, 4);
	63	for (i = 0, op = opcodes; i < N_OPCODES; i++, op++)
	64	if ((ins & op->mask) == op->value) break;
	65	assert(i != N_OPCODES);
	66
	67	for (p = op->assembler; *p;) {
	68	c = *p++;
	69	if (c == '%') {
	70	s = e = 0;
	71	while (isdigit(*p))
	72	s = s10 + (p++ - '0');
	73	if (*p == '-') {
	74	p++;
	75	while (isdigit(*p))
	76	e = e10 + (p++ - '0');
	77	} else
	78	e = s;
	79	assert(s >= 0 && s <= 31 && e >= 0 && e <= 31);
	80	val = (ins >> s) & ((1 << (e + 1 - s)) - 1);
	81	switch (*p++) {
	82	case '%' :
83	putc('%', stream);
84	break;
85	case 'd' :
86	fprintf(stream, "%d", val);
87	break;
88	case 'x' :
89	fprintf(stream, "%x", val);
90	break;
91	case 'r' :
92	assert(val >= 0 && val <= 15);
93	fprintf(stream, "%s", reg_names[val]);
94	break;
95	case 'c' :
96	fprintf(stream, "%s", cond_names[ins >> 28]);
97	break;
98	case '\'' :
99	assert(*p);
100	c = *p++;
101	if (val)
102	putc(c, stream);
103	break;
104	case '`' :
105	assert(*p);
106	c = *p++;
107	if (!val)
108	putc(c, stream);
109	break;
110	case '?' :
111	assert(*p);
112	c = *p++;
113	assert(*p);
114	if (val)
115	p++;
116	else
117	c = *p++;
118	putc(c, stream);
119	break;
120	case 'p' :
121	if (((ins >> 12) & 0xf) == 0xf)
122	putc('p', stream);
123	break;
124	case 'o' :
125	if (ins & (1<<25)) {
126	int immed = immediate_value(ins & 0xfff);
127	fprintf (stream, "#%d (0x%x)", immed, immed);
128	} else {
129	int operand2 = ins & 0xfff;
130	/* in operand2 :
131	bits 0-3 are the base register
132	bits 5-6 are the shift (0=lsl, 1=lsr, 2=asr, 3=ror)
133	if bit 4 is zero then bits 7-11 are an immediate shift count
134	else bit 7 must be zero and bits 8-11 are the register
135	to be used as a shift count.
136	Note: no shift at all is encoded as "reg lsl #0" */
137	fprintf (stream, "%s", reg_names[operand2 & 0xf]);
138	if (operand2 & 0xff0) {
139	/* ror #0 is really rrx (rotate right extend) */
140	if ((operand2 & 0xff0) == 0x060)
141	fprintf (stream, ", rrx");
142	else {
143	fprintf (stream, ", %s ",
144	shift_names[(operand2 >> 5) & 3]);
145	if (operand2 & (1<<4)) /* register shift */
146	fprintf (stream, "%s",
147	reg_names[operand2 >> 8]);
148	else /* immediate shift */
149	fprintf (stream, "#%d",
150	operand2 >> 7);
151	}
152	}
153	}
154	break;
155	case 'a' :
156	fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]);
157	if (ins & (1<<24)) {
158	fprintf (stream, ", ");
159	print_ldr_str_offset (ins, stream);
160	putc (']', stream);
161	if (ins & (1<<21)) putc('!', stream);
162	/* If it is a pc relative load, then it is probably
163	a constant so print it */
164	if (((ins >> 16) & 0xf) == 15 &&
165	(ins & (1<<25)) == 0 &&
166	(ins & (1<<20))) {
167	int addr = memaddr + 8 +
168	(ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1);
169	fprintf (stream, " (contents=");
170	print_address (read_memory_integer(addr, 4), stream);
171	fprintf (stream, ")");
172	}
173	} else {
174	fprintf (stream, "]," );
175	print_ldr_str_offset (ins, stream);
176	}
177	break;
178	case 'b' :
179	print_address (memaddr + 8 + (((int)ins << 8) >> 6), stream);
180	break;
181	case 'A' :
182	fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]);
183	if (ins & (1<<24)) {
184	fprintf (stream, ", ");
185	print_ldc_stc_offset (ins, stream);
186	putc(']', stream);
187	if (ins & (1<<21))
188	putc('!', stream);
189	} else {
190	fprintf (stream, "], ");
191	print_ldc_stc_offset (ins, stream);
192	}
193	break;
194	case 'm' :
195	{
196	int regnum, first = 1;
197	putc('{', stream);
198	for (regnum = 0; regnum < 16; regnum++)
199	if (ins & (1<<regnum)) {
200	if (!first)
201	putc (',', stream);
202	first = 0;
203	fprintf (stream, "%s", reg_names[regnum]);
204	}
205	putc('}', stream);
206	}
207	break;
208	case 'P' :
209	val = ((ins >> 18) & 2) \| ((ins >> 7) & 1);
210	putc(float_precision[val], stream);
211	break;
212	case 'Q' :
213	val = ((ins >> 21) & 2) \| ((ins >> 15) & 1);
214	putc(float_precision[val], stream);
215	break;
216	case 'R' :
217	val = ((ins >> 5) & 3);
218	if (val) putc(float_rounding[val], stream);
219	break;
220	case 'f' :
221	assert(val >= 0 && val <= 15);
222	if (val > 7)
223	fprintf (stream, "#%3.1f", float_immed[val - 8]);
224	else
225	fprintf (stream, "f%d", val);
226	break;
227	default:
228	abort();
229	}
230	} else
231	putc(c, stream);
232	}
233	return 4;
234	}
235
236	static long
237	immediate_value(operand)
238	int operand;
239	{
240	int val = operand & 0xff;
241	int shift = 2*(operand >> 8);
242	/* immediate value is (val ror shift) */
243	return (val >> shift) \| (val << (32 - shift));
244	}
245
246	static void
247	print_ldr_str_offset(ins, stream)
248	unsigned long ins;
249	FILE *stream;
250	{
251	if ((ins & (1<<25)) == 0)
252	fprintf (stream, "#%d",
253	(ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1));
254	else {
255	fprintf (stream, "%s%s", reg_names[ins & 0xf],
256	(ins & (1<<23)) ? "" : "-");
257	if (ins & 0xff0)
258	fprintf (stream, ", %s #%d",
259	shift_names[(ins >> 5) & 3],
260	(ins >> 7) & 0x1f);
261	}
262	}
263
264	static void
265	print_ldc_stc_offset(ins, stream)
266	unsigned long ins;
267	FILE *stream;
268	{
269	fprintf (stream, "#%d",
270	4 * (ins & 0xff) * ((ins & (1<<23)) ? 1 : -1));
271	}