1 /* Disassemble V850 instructions.
2 Copyright 1996, 1997, 1998, 2000, 2001, 2002, 2003
3 Free Software Foundation, Inc.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "opcode/v850.h"
27 static const char *const v850_reg_names
[] =
28 { "r0", "r1", "r2", "sp", "gp", "r5", "r6", "r7",
29 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
30 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
31 "r24", "r25", "r26", "r27", "r28", "r29", "ep", "lp" };
33 static const char *const v850_sreg_names
[] =
34 { "eipc", "eipsw", "fepc", "fepsw", "ecr", "psw", "sr6", "sr7",
35 "sr8", "sr9", "sr10", "sr11", "sr12", "sr13", "sr14", "sr15",
36 "ctpc", "ctpsw", "dbpc", "dbpsw", "ctbp", "sr21", "sr22", "sr23",
37 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31",
38 "sr16", "sr17", "sr18", "sr19", "sr20", "sr21", "sr22", "sr23",
39 "sr24", "sr25", "sr26", "sr27", "sr28", "sr29", "sr30", "sr31" };
41 static const char *const v850_cc_names
[] =
42 { "v", "c/l", "z", "nh", "s/n", "t", "lt", "le",
43 "nv", "nc/nl", "nz", "h", "ns/p", "sa", "ge", "gt" };
45 static int disassemble
46 PARAMS ((bfd_vma
, struct disassemble_info
*, unsigned long));
49 disassemble (memaddr
, info
, insn
)
51 struct disassemble_info
*info
;
54 struct v850_opcode
*op
= (struct v850_opcode
*)v850_opcodes
;
55 const struct v850_operand
*operand
;
57 int short_op
= ((insn
& 0x0600) != 0x0600);
61 /* Special case: 32 bit MOV */
62 if ((insn
& 0xffe0) == 0x0620)
65 bytes_read
= short_op
? 2 : 4;
67 /* If this is a two byte insn, then mask off the high bits. */
75 target_processor
= PROCESSOR_V850
;
79 target_processor
= PROCESSOR_V850E
;
83 target_processor
= PROCESSOR_V850E1
;
87 /* Find the opcode. */
90 if ((op
->mask
& insn
) == op
->opcode
91 && (op
->processors
& target_processor
))
93 const unsigned char *opindex_ptr
;
98 (*info
->fprintf_func
) (info
->stream
, "%s\t", op
->name
);
99 /*fprintf (stderr, "match: mask: %x insn: %x, opcode: %x, name: %s\n", op->mask, insn, op->opcode, op->name );*/
102 /* Now print the operands.
104 MEMOP is the operand number at which a memory
105 address specification starts, or zero if this
106 instruction has no memory addresses.
108 A memory address is always two arguments.
110 This information allows us to determine when to
111 insert commas into the output stream as well as
112 when to insert disp[reg] expressions onto the
115 for (opindex_ptr
= op
->operands
, opnum
= 1;
117 opindex_ptr
++, opnum
++)
124 operand
= &v850_operands
[*opindex_ptr
];
126 if (operand
->extract
)
127 value
= (operand
->extract
) (insn
, 0);
130 if (operand
->bits
== -1)
131 value
= (insn
& operand
->shift
);
133 value
= (insn
>> operand
->shift
) & ((1 << operand
->bits
) - 1);
135 if (operand
->flags
& V850_OPERAND_SIGNED
)
136 value
= ((long)(value
<< (32 - operand
->bits
))
137 >> (32 - operand
->bits
));
140 /* The first operand is always output without any
143 For the following arguments:
145 If memop && opnum == memop + 1, then we need '[' since
146 we're about to output the register used in a memory
149 If memop && opnum == memop + 2, then we need ']' since
150 we just finished the register in a memory reference. We
151 also need a ',' before this operand.
153 Else we just need a comma.
155 We may need to output a trailing ']' if the last operand
156 in an instruction is the register for a memory address.
158 The exception (and there's always an exception) is the
159 "jmp" insn which needs square brackets around it's only
160 register argument. */
162 if (memop
&& opnum
== memop
+ 1) info
->fprintf_func (info
->stream
, "[");
163 else if (memop
&& opnum
== memop
+ 2) info
->fprintf_func (info
->stream
, "],");
164 else if (memop
== 1 && opnum
== 1
165 && (operand
->flags
& V850_OPERAND_REG
))
166 info
->fprintf_func (info
->stream
, "[");
167 else if (opnum
> 1) info
->fprintf_func (info
->stream
, ", ");
169 /* extract the flags, ignorng ones which do not effect disassembly output. */
170 flag
= operand
->flags
;
171 flag
&= ~ V850_OPERAND_SIGNED
;
172 flag
&= ~ V850_OPERAND_RELAX
;
177 case V850_OPERAND_REG
: info
->fprintf_func (info
->stream
, "%s", v850_reg_names
[value
]); break;
178 case V850_OPERAND_SRG
: info
->fprintf_func (info
->stream
, "%s", v850_sreg_names
[value
]); break;
179 case V850_OPERAND_CC
: info
->fprintf_func (info
->stream
, "%s", v850_cc_names
[value
]); break;
180 case V850_OPERAND_EP
: info
->fprintf_func (info
->stream
, "ep"); break;
181 default: info
->fprintf_func (info
->stream
, "%d", value
); break;
182 case V850_OPERAND_DISP
:
184 bfd_vma addr
= value
+ memaddr
;
186 /* On the v850 the top 8 bits of an address are used by an overlay manager.
187 Thus it may happen that when we are looking for a symbol to match
188 against an address with some of its top bits set, the search fails to
189 turn up an exact match. In this case we try to find an exact match
190 against a symbol in the lower address space, and if we find one, we
191 use that address. We only do this for JARL instructions however, as
192 we do not want to misinterpret branch instructions. */
193 if (operand
->bits
== 22)
195 if ( ! info
->symbol_at_address_func (addr
, info
)
196 && ((addr
& 0xFF000000) != 0)
197 && info
->symbol_at_address_func (addr
& 0x00FFFFFF, info
))
202 info
->print_address_func (addr
, info
);
208 static int list12_regs
[32] = { 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24 };
209 static int list18_h_regs
[32] = { 19, 18, 17, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 30, 31, 29, 28, 23, 22, 21, 20, 27, 26, 25, 24 };
210 static int list18_l_regs
[32] = { 3, 2, 1, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 14, 15, 13, 12, 7, 6, 5, 4, 11, 10, 9, 8 };
213 unsigned long int mask
= 0;
218 switch (operand
->shift
)
220 case 0xffe00001: regs
= list12_regs
; break;
221 case 0xfff8000f: regs
= list18_h_regs
; break;
222 case 0xfff8001f: regs
= list18_l_regs
; value
&= ~0x10; break; /* Do not include magic bit */
224 /* xgettext:c-format */
225 fprintf (stderr
, _("unknown operand shift: %x\n"), operand
->shift
);
229 for (i
= 0; i
< 32; i
++)
231 if (value
& (1 << i
))
235 default: mask
|= (1 << regs
[ i
]); break;
236 /* xgettext:c-format */
237 case 0: fprintf (stderr
, _("unknown pop reg: %d\n"), i
); abort();
238 case -1: pc
= 1; break;
239 case -2: sr
= 1; break;
244 info
->fprintf_func (info
->stream
, "{");
246 if (mask
|| pc
|| sr
)
253 for (bit
= 0; bit
< 32; bit
++)
254 if (mask
& (1 << bit
))
256 unsigned long int first
= bit
;
257 unsigned long int last
;
260 info
->fprintf_func (info
->stream
, ", ");
264 info
->fprintf_func (info
->stream
, v850_reg_names
[first
]);
266 for (bit
++; bit
< 32; bit
++)
267 if ((mask
& (1 << bit
)) == 0)
272 if (last
> first
+ 1)
274 info
->fprintf_func (info
->stream
, " - %s", v850_reg_names
[ last
- 1 ]);
280 info
->fprintf_func (info
->stream
, "%sPC", mask
? ", " : "");
282 info
->fprintf_func (info
->stream
, "%sSR", (mask
|| pc
) ? ", " : "");
285 info
->fprintf_func (info
->stream
, "}");
289 case V850E_IMMEDIATE16
:
290 status
= info
->read_memory_func (memaddr
+ bytes_read
, buffer
, 2, info
);
294 value
= bfd_getl16 (buffer
);
296 /* If this is a DISPOSE instruction with ff set to 0x10, then shift value up by 16. */
297 if ((insn
& 0x001fffc0) == 0x00130780)
300 info
->fprintf_func (info
->stream
, "0x%x", value
);
304 info
->memory_error_func (status
, memaddr
+ bytes_read
, info
);
308 case V850E_IMMEDIATE32
:
309 status
= info
->read_memory_func (memaddr
+ bytes_read
, buffer
, 4, info
);
313 value
= bfd_getl32 (buffer
);
314 info
->fprintf_func (info
->stream
, "0x%lx", value
);
318 info
->memory_error_func (status
, memaddr
+ bytes_read
, info
);
323 /* Handle jmp correctly. */
324 if (memop
== 1 && opnum
== 1
325 && ((operand
->flags
& V850_OPERAND_REG
) != 0))
326 (*info
->fprintf_func
) (info
->stream
, "]");
329 /* Close any square bracket we left open. */
330 if (memop
&& opnum
== memop
+ 2)
331 (*info
->fprintf_func
) (info
->stream
, "]");
342 info
->fprintf_func (info
->stream
, ".short\t0x%04x", insn
);
344 info
->fprintf_func (info
->stream
, ".long\t0x%08x", insn
);
351 print_insn_v850 (memaddr
, info
)
353 struct disassemble_info
* info
;
357 unsigned long insn
= 0;
359 /* First figure out how big the opcode is. */
361 status
= info
->read_memory_func (memaddr
, buffer
, 2, info
);
364 insn
= bfd_getl16 (buffer
);
366 if ( (insn
& 0x0600) == 0x0600
367 && (insn
& 0xffe0) != 0x0620)
369 /* If this is a 4 byte insn, read 4 bytes of stuff. */
370 status
= info
->read_memory_func (memaddr
, buffer
, 4, info
);
373 insn
= bfd_getl32 (buffer
);
379 info
->memory_error_func (status
, memaddr
, info
);
383 /* Make sure we tell our caller how many bytes we consumed. */
384 return disassemble (memaddr
, info
, insn
);
This page took 0.037029 seconds and 4 git commands to generate.