?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
daily update
[binutils.git] / opcodes / mips-dis.c
blob43fcb3ca79a2b5cd957b82a8db30e66399c9a0ec
1 /* Print mips instructions for GDB, the GNU debugger, or for objdump.
2 Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003
4 Free Software Foundation, Inc.
5 Contributed by Nobuyuki Hikichi(hikichi@sra.co.jp).
6
7 This file is part of GDB, GAS, and the GNU binutils.
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 as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22
23 #include "sysdep.h"
24 #include "dis-asm.h"
25 #include "libiberty.h"
26 #include "opcode/mips.h"
27 #include "opintl.h"
28
29 /* FIXME: These are needed to figure out if the code is mips16 or
30 not. The low bit of the address is often a good indicator. No
31 symbol table is available when this code runs out in an embedded
32 system as when it is used for disassembler support in a monitor. */
33
34 #if !defined(EMBEDDED_ENV)
35 #define SYMTAB_AVAILABLE 1
36 #include "elf-bfd.h"
37 #include "elf/mips.h"
38 #endif
39
40 /* Mips instructions are at maximum this many bytes long. */
41 #define INSNLEN 4
42
43 static void set_default_mips_dis_options
44 PARAMS ((struct disassemble_info *));
45 static void parse_mips_dis_option
46 PARAMS ((const char *, unsigned int));
47 static void parse_mips_dis_options
48 PARAMS ((const char *));
49 static int _print_insn_mips
50 PARAMS ((bfd_vma, struct disassemble_info *, enum bfd_endian));
51 static int print_insn_mips
52 PARAMS ((bfd_vma, unsigned long int, struct disassemble_info *));
53 static void print_insn_args
54 PARAMS ((const char *, unsigned long, bfd_vma, struct disassemble_info *));
55 static int print_insn_mips16
56 PARAMS ((bfd_vma, struct disassemble_info *));
57 static int is_newabi
58 PARAMS ((Elf_Internal_Ehdr *));
59 static void print_mips16_insn_arg
60 PARAMS ((int, const struct mips_opcode *, int, bfd_boolean, int, bfd_vma,
61 struct disassemble_info *));
62 \f
63 /* FIXME: These should be shared with gdb somehow. */
64
65 struct mips_cp0sel_name {
66 unsigned int cp0reg;
67 unsigned int sel;
68 const char * const name;
69 };
70
71 /* The mips16 register names. */
72 static const char * const mips16_reg_names[] = {
73 "s0", "s1", "v0", "v1", "a0", "a1", "a2", "a3"
74 };
75
76 static const char * const mips_gpr_names_numeric[32] = {
77 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
78 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
79 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
80 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31"
81 };
82
83 static const char * const mips_gpr_names_oldabi[32] = {
84 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
85 "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7",
86 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
87 "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra"
88 };
89
90 static const char * const mips_gpr_names_newabi[32] = {
91 "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3",
92 "a4", "a5", "a6", "a7", "t0", "t1", "t2", "t3",
93 "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7",
94 "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra"
95 };
96
97 static const char * const mips_fpr_names_numeric[32] = {
98 "$f0", "$f1", "$f2", "$f3", "$f4", "$f5", "$f6", "$f7",
99 "$f8", "$f9", "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
100 "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
101 "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31"
102 };
103
104 static const char * const mips_fpr_names_32[32] = {
105 "fv0", "fv0f", "fv1", "fv1f", "ft0", "ft0f", "ft1", "ft1f",
106 "ft2", "ft2f", "ft3", "ft3f", "fa0", "fa0f", "fa1", "fa1f",
107 "ft4", "ft4f", "ft5", "ft5f", "fs0", "fs0f", "fs1", "fs1f",
108 "fs2", "fs2f", "fs3", "fs3f", "fs4", "fs4f", "fs5", "fs5f"
109 };
110
111 static const char * const mips_fpr_names_n32[32] = {
112 "fv0", "ft14", "fv1", "ft15", "ft0", "ft1", "ft2", "ft3",
113 "ft4", "ft5", "ft6", "ft7", "fa0", "fa1", "fa2", "fa3",
114 "fa4", "fa5", "fa6", "fa7", "fs0", "ft8", "fs1", "ft9",
115 "fs2", "ft10", "fs3", "ft11", "fs4", "ft12", "fs5", "ft13"
116 };
117
118 static const char * const mips_fpr_names_64[32] = {
119 "fv0", "ft12", "fv1", "ft13", "ft0", "ft1", "ft2", "ft3",
120 "ft4", "ft5", "ft6", "ft7", "fa0", "fa1", "fa2", "fa3",
121 "fa4", "fa5", "fa6", "fa7", "ft8", "ft9", "ft10", "ft11",
122 "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7"
123 };
124
125 static const char * const mips_cp0_names_numeric[32] = {
126 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
127 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
128 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
129 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31"
130 };
131
132 static const char * const mips_cp0_names_mips3264[32] = {
133 "c0_index", "c0_random", "c0_entrylo0", "c0_entrylo1",
134 "c0_context", "c0_pagemask", "c0_wired", "$7",
135 "c0_badvaddr", "c0_count", "c0_entryhi", "c0_compare",
136 "c0_status", "c0_cause", "c0_epc", "c0_prid",
137 "c0_config", "c0_lladdr", "c0_watchlo", "c0_watchhi",
138 "c0_xcontext", "$21", "$22", "c0_debug",
139 "c0_depc", "c0_perfcnt", "c0_errctl", "c0_cacheerr",
140 "c0_taglo", "c0_taghi", "c0_errorepc", "c0_desave",
141 };
142
143 static const struct mips_cp0sel_name mips_cp0sel_names_mips3264[] = {
144 { 16, 1, "c0_config1" },
145 { 16, 2, "c0_config2" },
146 { 16, 3, "c0_config3" },
147 { 18, 1, "c0_watchlo,1" },
148 { 18, 2, "c0_watchlo,2" },
149 { 18, 3, "c0_watchlo,3" },
150 { 18, 4, "c0_watchlo,4" },
151 { 18, 5, "c0_watchlo,5" },
152 { 18, 6, "c0_watchlo,6" },
153 { 18, 7, "c0_watchlo,7" },
154 { 19, 1, "c0_watchhi,1" },
155 { 19, 2, "c0_watchhi,2" },
156 { 19, 3, "c0_watchhi,3" },
157 { 19, 4, "c0_watchhi,4" },
158 { 19, 5, "c0_watchhi,5" },
159 { 19, 6, "c0_watchhi,6" },
160 { 19, 7, "c0_watchhi,7" },
161 { 25, 1, "c0_perfcnt,1" },
162 { 25, 2, "c0_perfcnt,2" },
163 { 25, 3, "c0_perfcnt,3" },
164 { 25, 4, "c0_perfcnt,4" },
165 { 25, 5, "c0_perfcnt,5" },
166 { 25, 6, "c0_perfcnt,6" },
167 { 25, 7, "c0_perfcnt,7" },
168 { 27, 1, "c0_cacheerr,1" },
169 { 27, 2, "c0_cacheerr,2" },
170 { 27, 3, "c0_cacheerr,3" },
171 { 28, 1, "c0_datalo" },
172 { 29, 1, "c0_datahi" }
173 };
174
175 static const char * const mips_cp0_names_mips3264r2[32] = {
176 "c0_index", "c0_random", "c0_entrylo0", "c0_entrylo1",
177 "c0_context", "c0_pagemask", "c0_wired", "c0_hwrena",
178 "c0_badvaddr", "c0_count", "c0_entryhi", "c0_compare",
179 "c0_status", "c0_cause", "c0_epc", "c0_prid",
180 "c0_config", "c0_lladdr", "c0_watchlo", "c0_watchhi",
181 "c0_xcontext", "$21", "$22", "c0_debug",
182 "c0_depc", "c0_perfcnt", "c0_errctl", "c0_cacheerr",
183 "c0_taglo", "c0_taghi", "c0_errorepc", "c0_desave",
184 };
185
186 static const struct mips_cp0sel_name mips_cp0sel_names_mips3264r2[] = {
187 { 4, 1, "c0_contextconfig" },
188 { 5, 1, "c0_pagegrain" },
189 { 12, 1, "c0_intctl" },
190 { 12, 2, "c0_srsctl" },
191 { 12, 3, "c0_srsmap" },
192 { 15, 1, "c0_ebase" },
193 { 16, 1, "c0_config1" },
194 { 16, 2, "c0_config2" },
195 { 16, 3, "c0_config3" },
196 { 18, 1, "c0_watchlo,1" },
197 { 18, 2, "c0_watchlo,2" },
198 { 18, 3, "c0_watchlo,3" },
199 { 18, 4, "c0_watchlo,4" },
200 { 18, 5, "c0_watchlo,5" },
201 { 18, 6, "c0_watchlo,6" },
202 { 18, 7, "c0_watchlo,7" },
203 { 19, 1, "c0_watchhi,1" },
204 { 19, 2, "c0_watchhi,2" },
205 { 19, 3, "c0_watchhi,3" },
206 { 19, 4, "c0_watchhi,4" },
207 { 19, 5, "c0_watchhi,5" },
208 { 19, 6, "c0_watchhi,6" },
209 { 19, 7, "c0_watchhi,7" },
210 { 23, 1, "c0_tracecontrol" },
211 { 23, 2, "c0_tracecontrol2" },
212 { 23, 3, "c0_usertracedata" },
213 { 23, 4, "c0_tracebpc" },
214 { 25, 1, "c0_perfcnt,1" },
215 { 25, 2, "c0_perfcnt,2" },
216 { 25, 3, "c0_perfcnt,3" },
217 { 25, 4, "c0_perfcnt,4" },
218 { 25, 5, "c0_perfcnt,5" },
219 { 25, 6, "c0_perfcnt,6" },
220 { 25, 7, "c0_perfcnt,7" },
221 { 27, 1, "c0_cacheerr,1" },
222 { 27, 2, "c0_cacheerr,2" },
223 { 27, 3, "c0_cacheerr,3" },
224 { 28, 1, "c0_datalo" },
225 { 28, 2, "c0_taglo1" },
226 { 28, 3, "c0_datalo1" },
227 { 28, 4, "c0_taglo2" },
228 { 28, 5, "c0_datalo2" },
229 { 28, 6, "c0_taglo3" },
230 { 28, 7, "c0_datalo3" },
231 { 29, 1, "c0_datahi" },
232 { 29, 2, "c0_taghi1" },
233 { 29, 3, "c0_datahi1" },
234 { 29, 4, "c0_taghi2" },
235 { 29, 5, "c0_datahi2" },
236 { 29, 6, "c0_taghi3" },
237 { 29, 7, "c0_datahi3" },
238 };
239
240 /* SB-1: MIPS64 (mips_cp0_names_mips3264) with minor mods. */
241 static const char * const mips_cp0_names_sb1[32] = {
242 "c0_index", "c0_random", "c0_entrylo0", "c0_entrylo1",
243 "c0_context", "c0_pagemask", "c0_wired", "$7",
244 "c0_badvaddr", "c0_count", "c0_entryhi", "c0_compare",
245 "c0_status", "c0_cause", "c0_epc", "c0_prid",
246 "c0_config", "c0_lladdr", "c0_watchlo", "c0_watchhi",
247 "c0_xcontext", "$21", "$22", "c0_debug",
248 "c0_depc", "c0_perfcnt", "c0_errctl", "c0_cacheerr_i",
249 "c0_taglo_i", "c0_taghi_i", "c0_errorepc", "c0_desave",
250 };
251
252 static const struct mips_cp0sel_name mips_cp0sel_names_sb1[] = {
253 { 16, 1, "c0_config1" },
254 { 18, 1, "c0_watchlo,1" },
255 { 19, 1, "c0_watchhi,1" },
256 { 22, 0, "c0_perftrace" },
257 { 23, 3, "c0_edebug" },
258 { 25, 1, "c0_perfcnt,1" },
259 { 25, 2, "c0_perfcnt,2" },
260 { 25, 3, "c0_perfcnt,3" },
261 { 25, 4, "c0_perfcnt,4" },
262 { 25, 5, "c0_perfcnt,5" },
263 { 25, 6, "c0_perfcnt,6" },
264 { 25, 7, "c0_perfcnt,7" },
265 { 26, 1, "c0_buserr_pa" },
266 { 27, 1, "c0_cacheerr_d" },
267 { 27, 3, "c0_cacheerr_d_pa" },
268 { 28, 1, "c0_datalo_i" },
269 { 28, 2, "c0_taglo_d" },
270 { 28, 3, "c0_datalo_d" },
271 { 29, 1, "c0_datahi_i" },
272 { 29, 2, "c0_taghi_d" },
273 { 29, 3, "c0_datahi_d" },
274 };
275
276 static const char * const mips_hwr_names_numeric[32] = {
277 "$0", "$1", "$2", "$3", "$4", "$5", "$6", "$7",
278 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
279 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
280 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31"
281 };
282
283 static const char * const mips_hwr_names_mips3264r2[32] = {
284 "hwr_cpunum", "hwr_synci_step", "hwr_cc", "hwr_ccres",
285 "$4", "$5", "$6", "$7",
286 "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15",
287 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
288 "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31"
289 };
290
291 struct mips_abi_choice {
292 const char *name;
293 const char * const *gpr_names;
294 const char * const *fpr_names;
295 };
296
297 struct mips_abi_choice mips_abi_choices[] = {
298 { "numeric", mips_gpr_names_numeric, mips_fpr_names_numeric },
299 { "32", mips_gpr_names_oldabi, mips_fpr_names_32 },
300 { "n32", mips_gpr_names_newabi, mips_fpr_names_n32 },
301 { "64", mips_gpr_names_newabi, mips_fpr_names_64 },
302 };
303
304 struct mips_arch_choice {
305 const char *name;
306 int bfd_mach_valid;
307 unsigned long bfd_mach;
308 int processor;
309 int isa;
310 const char * const *cp0_names;
311 const struct mips_cp0sel_name *cp0sel_names;
312 unsigned int cp0sel_names_len;
313 const char * const *hwr_names;
314 };
315
316 const struct mips_arch_choice mips_arch_choices[] = {
317 { "numeric", 0, 0, 0, 0,
318 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
319
320 { "r3000", 1, bfd_mach_mips3000, CPU_R3000, ISA_MIPS1,
321 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
322 { "r3900", 1, bfd_mach_mips3900, CPU_R3900, ISA_MIPS1,
323 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
324 { "r4000", 1, bfd_mach_mips4000, CPU_R4000, ISA_MIPS3,
325 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
326 { "r4010", 1, bfd_mach_mips4010, CPU_R4010, ISA_MIPS2,
327 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
328 { "vr4100", 1, bfd_mach_mips4100, CPU_VR4100, ISA_MIPS3,
329 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
330 { "vr4111", 1, bfd_mach_mips4111, CPU_R4111, ISA_MIPS3,
331 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
332 { "vr4120", 1, bfd_mach_mips4120, CPU_VR4120, ISA_MIPS3,
333 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
334 { "r4300", 1, bfd_mach_mips4300, CPU_R4300, ISA_MIPS3,
335 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
336 { "r4400", 1, bfd_mach_mips4400, CPU_R4400, ISA_MIPS3,
337 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
338 { "r4600", 1, bfd_mach_mips4600, CPU_R4600, ISA_MIPS3,
339 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
340 { "r4650", 1, bfd_mach_mips4650, CPU_R4650, ISA_MIPS3,
341 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
342 { "r5000", 1, bfd_mach_mips5000, CPU_R5000, ISA_MIPS4,
343 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
344 { "vr5400", 1, bfd_mach_mips5400, CPU_VR5400, ISA_MIPS4,
345 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
346 { "vr5500", 1, bfd_mach_mips5500, CPU_VR5500, ISA_MIPS4,
347 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
348 { "r6000", 1, bfd_mach_mips6000, CPU_R6000, ISA_MIPS2,
349 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
350 { "rm7000", 1, bfd_mach_mips7000, CPU_RM7000, ISA_MIPS4,
351 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
352 { "rm9000", 1, bfd_mach_mips7000, CPU_RM7000, ISA_MIPS4,
353 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
354 { "r8000", 1, bfd_mach_mips8000, CPU_R8000, ISA_MIPS4,
355 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
356 { "r10000", 1, bfd_mach_mips10000, CPU_R10000, ISA_MIPS4,
357 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
358 { "r12000", 1, bfd_mach_mips12000, CPU_R12000, ISA_MIPS4,
359 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
360 { "mips5", 1, bfd_mach_mips5, CPU_MIPS5, ISA_MIPS5,
361 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
362
363 /* For stock MIPS32, disassemble all applicable MIPS-specified ASEs.
364 Note that MIPS-3D and MDMX are not applicable to MIPS32. (See
365 _MIPS32 Architecture For Programmers Volume I: Introduction to the
366 MIPS32 Architecture_ (MIPS Document Number MD00082, Revision 0.95),
367 page 1. */
368 { "mips32", 1, bfd_mach_mipsisa32, CPU_MIPS32,
369 ISA_MIPS32 | INSN_MIPS16,
370 mips_cp0_names_mips3264,
371 mips_cp0sel_names_mips3264, ARRAY_SIZE (mips_cp0sel_names_mips3264),
372 mips_hwr_names_numeric },
373
374 { "mips32r2", 1, bfd_mach_mipsisa32r2, CPU_MIPS32R2,
375 ISA_MIPS32R2 | INSN_MIPS16,
376 mips_cp0_names_mips3264r2,
377 mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
378 mips_hwr_names_mips3264r2 },
379
380 /* For stock MIPS64, disassemble all applicable MIPS-specified ASEs. */
381 { "mips64", 1, bfd_mach_mipsisa64, CPU_MIPS64,
382 ISA_MIPS64 | INSN_MIPS16 | INSN_MIPS3D | INSN_MDMX,
383 mips_cp0_names_mips3264,
384 mips_cp0sel_names_mips3264, ARRAY_SIZE (mips_cp0sel_names_mips3264),
385 mips_hwr_names_numeric },
386
387 { "mips64r2", 1, bfd_mach_mipsisa64r2, CPU_MIPS64R2,
388 ISA_MIPS64R2 | INSN_MIPS16 | INSN_MIPS3D | INSN_MDMX,
389 mips_cp0_names_mips3264r2,
390 mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
391 mips_hwr_names_mips3264r2 },
392
393 { "sb1", 1, bfd_mach_mips_sb1, CPU_SB1,
394 ISA_MIPS64 | INSN_MIPS3D | INSN_SB1,
395 mips_cp0_names_sb1,
396 mips_cp0sel_names_sb1, ARRAY_SIZE (mips_cp0sel_names_sb1),
397 mips_hwr_names_numeric },
398
399 /* This entry, mips16, is here only for ISA/processor selection; do
400 not print its name. */
401 { "", 1, bfd_mach_mips16, CPU_MIPS16, ISA_MIPS3 | INSN_MIPS16,
402 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
403 };
404
405 /* ISA and processor type to disassemble for, and register names to use.
406 set_default_mips_dis_options and parse_mips_dis_options fill in these
407 values. */
408 static int mips_processor;
409 static int mips_isa;
410 static const char * const *mips_gpr_names;
411 static const char * const *mips_fpr_names;
412 static const char * const *mips_cp0_names;
413 static const struct mips_cp0sel_name *mips_cp0sel_names;
414 static int mips_cp0sel_names_len;
415 static const char * const *mips_hwr_names;
416
417 static const struct mips_abi_choice *choose_abi_by_name
418 PARAMS ((const char *, unsigned int));
419 static const struct mips_arch_choice *choose_arch_by_name
420 PARAMS ((const char *, unsigned int));
421 static const struct mips_arch_choice *choose_arch_by_number
422 PARAMS ((unsigned long));
423 static const struct mips_cp0sel_name *lookup_mips_cp0sel_name
424 PARAMS ((const struct mips_cp0sel_name *, unsigned int, unsigned int,
425 unsigned int));
426 \f
427 static const struct mips_abi_choice *
428 choose_abi_by_name (name, namelen)
429 const char *name;
430 unsigned int namelen;
431 {
432 const struct mips_abi_choice *c;
433 unsigned int i;
434
435 for (i = 0, c = NULL; i < ARRAY_SIZE (mips_abi_choices) && c == NULL; i++)
436 {
437 if (strncmp (mips_abi_choices[i].name, name, namelen) == 0
438 && strlen (mips_abi_choices[i].name) == namelen)
439 c = &mips_abi_choices[i];
440 }
441 return c;
442 }
443
444 static const struct mips_arch_choice *
445 choose_arch_by_name (name, namelen)
446 const char *name;
447 unsigned int namelen;
448 {
449 const struct mips_arch_choice *c = NULL;
450 unsigned int i;
451
452 for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
453 {
454 if (strncmp (mips_arch_choices[i].name, name, namelen) == 0
455 && strlen (mips_arch_choices[i].name) == namelen)
456 c = &mips_arch_choices[i];
457 }
458 return c;
459 }
460
461 static const struct mips_arch_choice *
462 choose_arch_by_number (mach)
463 unsigned long mach;
464 {
465 static unsigned long hint_bfd_mach;
466 static const struct mips_arch_choice *hint_arch_choice;
467 const struct mips_arch_choice *c;
468 unsigned int i;
469
470 /* We optimize this because even if the user specifies no
471 flags, this will be done for every instruction! */
472 if (hint_bfd_mach == mach
473 && hint_arch_choice != NULL
474 && hint_arch_choice->bfd_mach == hint_bfd_mach)
475 return hint_arch_choice;
476
477 for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
478 {
479 if (mips_arch_choices[i].bfd_mach_valid
480 && mips_arch_choices[i].bfd_mach == mach)
481 {
482 c = &mips_arch_choices[i];
483 hint_bfd_mach = mach;
484 hint_arch_choice = c;
485 }
486 }
487 return c;
488 }
489
490 void
491 set_default_mips_dis_options (info)
492 struct disassemble_info *info;
493 {
494 const struct mips_arch_choice *chosen_arch;
495
496 /* Defaults: mipsIII/r3000 (?!), (o)32-style ("oldabi") GPR names,
497 and numeric FPR, CP0 register, and HWR names. */
498 mips_isa = ISA_MIPS3;
499 mips_processor = CPU_R3000;
500 mips_gpr_names = mips_gpr_names_oldabi;
501 mips_fpr_names = mips_fpr_names_numeric;
502 mips_cp0_names = mips_cp0_names_numeric;
503 mips_cp0sel_names = NULL;
504 mips_cp0sel_names_len = 0;
505 mips_hwr_names = mips_hwr_names_numeric;
506
507 /* If an ELF "newabi" binary, use the n32/(n)64 GPR names. */
508 if (info->flavour == bfd_target_elf_flavour && info->section != NULL)
509 {
510 Elf_Internal_Ehdr *header;
511
512 header = elf_elfheader (info->section->owner);
513 if (is_newabi (header))
514 mips_gpr_names = mips_gpr_names_newabi;
515 }
516
517 /* Set ISA, architecture, and cp0 register names as best we can. */
518 #if ! SYMTAB_AVAILABLE
519 /* This is running out on a target machine, not in a host tool.
520 FIXME: Where does mips_target_info come from? */
521 target_processor = mips_target_info.processor;
522 mips_isa = mips_target_info.isa;
523 #else
524 chosen_arch = choose_arch_by_number (info->mach);
525 if (chosen_arch != NULL)
526 {
527 mips_processor = chosen_arch->processor;
528 mips_isa = chosen_arch->isa;
529 mips_cp0_names = chosen_arch->cp0_names;
530 mips_cp0sel_names = chosen_arch->cp0sel_names;
531 mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
532 mips_hwr_names = chosen_arch->hwr_names;
533 }
534 #endif
535 }
536
537 void
538 parse_mips_dis_option (option, len)
539 const char *option;
540 unsigned int len;
541 {
542 unsigned int i, optionlen, vallen;
543 const char *val;
544 const struct mips_abi_choice *chosen_abi;
545 const struct mips_arch_choice *chosen_arch;
546
547 /* Look for the = that delimits the end of the option name. */
548 for (i = 0; i < len; i++)
549 {
550 if (option[i] == '=')
551 break;
552 }
553 if (i == 0) /* Invalid option: no name before '='. */
554 return;
555 if (i == len) /* Invalid option: no '='. */
556 return;
557 if (i == (len - 1)) /* Invalid option: no value after '='. */
558 return;
559
560 optionlen = i;
561 val = option + (optionlen + 1);
562 vallen = len - (optionlen + 1);
563
564 if (strncmp("gpr-names", option, optionlen) == 0
565 && strlen("gpr-names") == optionlen)
566 {
567 chosen_abi = choose_abi_by_name (val, vallen);
568 if (chosen_abi != NULL)
569 mips_gpr_names = chosen_abi->gpr_names;
570 return;
571 }
572
573 if (strncmp("fpr-names", option, optionlen) == 0
574 && strlen("fpr-names") == optionlen)
575 {
576 chosen_abi = choose_abi_by_name (val, vallen);
577 if (chosen_abi != NULL)
578 mips_fpr_names = chosen_abi->fpr_names;
579 return;
580 }
581
582 if (strncmp("cp0-names", option, optionlen) == 0
583 && strlen("cp0-names") == optionlen)
584 {
585 chosen_arch = choose_arch_by_name (val, vallen);
586 if (chosen_arch != NULL)
587 {
588 mips_cp0_names = chosen_arch->cp0_names;
589 mips_cp0sel_names = chosen_arch->cp0sel_names;
590 mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
591 }
592 return;
593 }
594
595 if (strncmp("hwr-names", option, optionlen) == 0
596 && strlen("hwr-names") == optionlen)
597 {
598 chosen_arch = choose_arch_by_name (val, vallen);
599 if (chosen_arch != NULL)
600 mips_hwr_names = chosen_arch->hwr_names;
601 return;
602 }
603
604 if (strncmp("reg-names", option, optionlen) == 0
605 && strlen("reg-names") == optionlen)
606 {
607 /* We check both ABI and ARCH here unconditionally, so
608 that "numeric" will do the desirable thing: select
609 numeric register names for all registers. Other than
610 that, a given name probably won't match both. */
611 chosen_abi = choose_abi_by_name (val, vallen);
612 if (chosen_abi != NULL)
613 {
614 mips_gpr_names = chosen_abi->gpr_names;
615 mips_fpr_names = chosen_abi->fpr_names;
616 }
617 chosen_arch = choose_arch_by_name (val, vallen);
618 if (chosen_arch != NULL)
619 {
620 mips_cp0_names = chosen_arch->cp0_names;
621 mips_cp0sel_names = chosen_arch->cp0sel_names;
622 mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
623 mips_hwr_names = chosen_arch->hwr_names;
624 }
625 return;
626 }
627
628 /* Invalid option. */
629 }
630
631 void
632 parse_mips_dis_options (options)
633 const char *options;
634 {
635 const char *option_end;
636
637 if (options == NULL)
638 return;
639
640 while (*options != '\0')
641 {
642 /* Skip empty options. */
643 if (*options == ',')
644 {
645 options++;
646 continue;
647 }
648
649 /* We know that *options is neither NUL or a comma. */
650 option_end = options + 1;
651 while (*option_end != ',' && *option_end != '\0')
652 option_end++;
653
654 parse_mips_dis_option (options, option_end - options);
655
656 /* Go on to the next one. If option_end points to a comma, it
657 will be skipped above. */
658 options = option_end;
659 }
660 }
661
662 static const struct mips_cp0sel_name *
663 lookup_mips_cp0sel_name(names, len, cp0reg, sel)
664 const struct mips_cp0sel_name *names;
665 unsigned int len, cp0reg, sel;
666 {
667 unsigned int i;
668
669 for (i = 0; i < len; i++)
670 if (names[i].cp0reg == cp0reg && names[i].sel == sel)
671 return &names[i];
672 return NULL;
673 }
674 \f
675 /* Print insn arguments for 32/64-bit code. */
676
677 static void
678 print_insn_args (d, l, pc, info)
679 const char *d;
680 register unsigned long int l;
681 bfd_vma pc;
682 struct disassemble_info *info;
683 {
684 int op, delta;
685 unsigned int lsb, msb, msbd;
686
687 lsb = 0;
688
689 for (; *d != '\0'; d++)
690 {
691 switch (*d)
692 {
693 case ',':
694 case '(':
695 case ')':
696 case '[':
697 case ']':
698 (*info->fprintf_func) (info->stream, "%c", *d);
699 break;
700
701 case '+':
702 /* Extension character; switch for second char. */
703 d++;
704 switch (*d)
705 {
706 case '\0':
707 /* xgettext:c-format */
708 (*info->fprintf_func) (info->stream,
709 _("# internal error, incomplete extension sequence (+)"));
710 return;
711
712 case 'A':
713 lsb = (l >> OP_SH_SHAMT) & OP_MASK_SHAMT;
714 (*info->fprintf_func) (info->stream, "0x%x", lsb);
715 break;
716
717 case 'B':
718 msb = (l >> OP_SH_INSMSB) & OP_MASK_INSMSB;
719 (*info->fprintf_func) (info->stream, "0x%x", msb - lsb + 1);
720 break;
721
722 case 'C':
723 case 'H':
724 msbd = (l >> OP_SH_EXTMSBD) & OP_MASK_EXTMSBD;
725 (*info->fprintf_func) (info->stream, "0x%x", msbd + 1);
726 break;
727
728 case 'D':
729 {
730 const struct mips_cp0sel_name *n;
731 unsigned int cp0reg, sel;
732
733 cp0reg = (l >> OP_SH_RD) & OP_MASK_RD;
734 sel = (l >> OP_SH_SEL) & OP_MASK_SEL;
735
736 /* CP0 register including 'sel' code for mtcN (et al.), to be
737 printed textually if known. If not known, print both
738 CP0 register name and sel numerically since CP0 register
739 with sel 0 may have a name unrelated to register being
740 printed. */
741 n = lookup_mips_cp0sel_name(mips_cp0sel_names,
742 mips_cp0sel_names_len, cp0reg, sel);
743 if (n != NULL)
744 (*info->fprintf_func) (info->stream, "%s", n->name);
745 else
746 (*info->fprintf_func) (info->stream, "$%d,%d", cp0reg, sel);
747 break;
748 }
749
750 case 'E':
751 lsb = ((l >> OP_SH_SHAMT) & OP_MASK_SHAMT) + 32;
752 (*info->fprintf_func) (info->stream, "0x%x", lsb);
753 break;
754
755 case 'F':
756 msb = ((l >> OP_SH_INSMSB) & OP_MASK_INSMSB) + 32;
757 (*info->fprintf_func) (info->stream, "0x%x", msb - lsb + 1);
758 break;
759
760 case 'G':
761 msbd = ((l >> OP_SH_EXTMSBD) & OP_MASK_EXTMSBD) + 32;
762 (*info->fprintf_func) (info->stream, "0x%x", msbd + 1);
763 break;
764
765 default:
766 /* xgettext:c-format */
767 (*info->fprintf_func) (info->stream,
768 _("# internal error, undefined extension sequence (+%c)"),
769 *d);
770 return;
771 }
772 break;
773
774 case 's':
775 case 'b':
776 case 'r':
777 case 'v':
778 (*info->fprintf_func) (info->stream, "%s",
779 mips_gpr_names[(l >> OP_SH_RS) & OP_MASK_RS]);
780 break;
781
782 case 't':
783 case 'w':
784 (*info->fprintf_func) (info->stream, "%s",
785 mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
786 break;
787
788 case 'i':
789 case 'u':
790 (*info->fprintf_func) (info->stream, "0x%x",
791 (l >> OP_SH_IMMEDIATE) & OP_MASK_IMMEDIATE);
792 break;
793
794 case 'j': /* Same as i, but sign-extended. */
795 case 'o':
796 delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
797 if (delta & 0x8000)
798 delta |= ~0xffff;
799 (*info->fprintf_func) (info->stream, "%d",
800 delta);
801 break;
802
803 case 'h':
804 (*info->fprintf_func) (info->stream, "0x%x",
805 (unsigned int) ((l >> OP_SH_PREFX)
806 & OP_MASK_PREFX));
807 break;
808
809 case 'k':
810 (*info->fprintf_func) (info->stream, "0x%x",
811 (unsigned int) ((l >> OP_SH_CACHE)
812 & OP_MASK_CACHE));
813 break;
814
815 case 'a':
816 info->target = (((pc + 4) & ~(bfd_vma) 0x0fffffff)
817 | (((l >> OP_SH_TARGET) & OP_MASK_TARGET) << 2));
818 (*info->print_address_func) (info->target, info);
819 break;
820
821 case 'p':
822 /* Sign extend the displacement. */
823 delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
824 if (delta & 0x8000)
825 delta |= ~0xffff;
826 info->target = (delta << 2) + pc + INSNLEN;
827 (*info->print_address_func) (info->target, info);
828 break;
829
830 case 'd':
831 (*info->fprintf_func) (info->stream, "%s",
832 mips_gpr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
833 break;
834
835 case 'U':
836 {
837 /* First check for both rd and rt being equal. */
838 unsigned int reg = (l >> OP_SH_RD) & OP_MASK_RD;
839 if (reg == ((l >> OP_SH_RT) & OP_MASK_RT))
840 (*info->fprintf_func) (info->stream, "%s",
841 mips_gpr_names[reg]);
842 else
843 {
844 /* If one is zero use the other. */
845 if (reg == 0)
846 (*info->fprintf_func) (info->stream, "%s",
847 mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
848 else if (((l >> OP_SH_RT) & OP_MASK_RT) == 0)
849 (*info->fprintf_func) (info->stream, "%s",
850 mips_gpr_names[reg]);
851 else /* Bogus, result depends on processor. */
852 (*info->fprintf_func) (info->stream, "%s or %s",
853 mips_gpr_names[reg],
854 mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
855 }
856 }
857 break;
858
859 case 'z':
860 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
861 break;
862
863 case '<':
864 (*info->fprintf_func) (info->stream, "0x%x",
865 (l >> OP_SH_SHAMT) & OP_MASK_SHAMT);
866 break;
867
868 case 'c':
869 (*info->fprintf_func) (info->stream, "0x%x",
870 (l >> OP_SH_CODE) & OP_MASK_CODE);
871 break;
872
873 case 'q':
874 (*info->fprintf_func) (info->stream, "0x%x",
875 (l >> OP_SH_CODE2) & OP_MASK_CODE2);
876 break;
877
878 case 'C':
879 (*info->fprintf_func) (info->stream, "0x%x",
880 (l >> OP_SH_COPZ) & OP_MASK_COPZ);
881 break;
882
883 case 'B':
884 (*info->fprintf_func) (info->stream, "0x%x",
885 (l >> OP_SH_CODE20) & OP_MASK_CODE20);
886 break;
887
888 case 'J':
889 (*info->fprintf_func) (info->stream, "0x%x",
890 (l >> OP_SH_CODE19) & OP_MASK_CODE19);
891 break;
892
893 case 'S':
894 case 'V':
895 (*info->fprintf_func) (info->stream, "%s",
896 mips_fpr_names[(l >> OP_SH_FS) & OP_MASK_FS]);
897 break;
898
899 case 'T':
900 case 'W':
901 (*info->fprintf_func) (info->stream, "%s",
902 mips_fpr_names[(l >> OP_SH_FT) & OP_MASK_FT]);
903 break;
904
905 case 'D':
906 (*info->fprintf_func) (info->stream, "%s",
907 mips_fpr_names[(l >> OP_SH_FD) & OP_MASK_FD]);
908 break;
909
910 case 'R':
911 (*info->fprintf_func) (info->stream, "%s",
912 mips_fpr_names[(l >> OP_SH_FR) & OP_MASK_FR]);
913 break;
914
915 case 'E':
916 /* Coprocessor register for lwcN instructions, et al.
917
918 Note that there is no load/store cp0 instructions, and
919 that FPU (cp1) instructions disassemble this field using
920 'T' format. Therefore, until we gain understanding of
921 cp2 register names, we can simply print the register
922 numbers. */
923 (*info->fprintf_func) (info->stream, "$%d",
924 (l >> OP_SH_RT) & OP_MASK_RT);
925 break;
926
927 case 'G':
928 /* Coprocessor register for mtcN instructions, et al. Note
929 that FPU (cp1) instructions disassemble this field using
930 'S' format. Therefore, we only need to worry about cp0,
931 cp2, and cp3. */
932 op = (l >> OP_SH_OP) & OP_MASK_OP;
933 if (op == OP_OP_COP0)
934 (*info->fprintf_func) (info->stream, "%s",
935 mips_cp0_names[(l >> OP_SH_RD) & OP_MASK_RD]);
936 else
937 (*info->fprintf_func) (info->stream, "$%d",
938 (l >> OP_SH_RD) & OP_MASK_RD);
939 break;
940
941 case 'K':
942 (*info->fprintf_func) (info->stream, "%s",
943 mips_hwr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
944 break;
945
946 case 'N':
947 (*info->fprintf_func) (info->stream, "$fcc%d",
948 (l >> OP_SH_BCC) & OP_MASK_BCC);
949 break;
950
951 case 'M':
952 (*info->fprintf_func) (info->stream, "$fcc%d",
953 (l >> OP_SH_CCC) & OP_MASK_CCC);
954 break;
955
956 case 'P':
957 (*info->fprintf_func) (info->stream, "%d",
958 (l >> OP_SH_PERFREG) & OP_MASK_PERFREG);
959 break;
960
961 case 'e':
962 (*info->fprintf_func) (info->stream, "%d",
963 (l >> OP_SH_VECBYTE) & OP_MASK_VECBYTE);
964 break;
965
966 case '%':
967 (*info->fprintf_func) (info->stream, "%d",
968 (l >> OP_SH_VECALIGN) & OP_MASK_VECALIGN);
969 break;
970
971 case 'H':
972 (*info->fprintf_func) (info->stream, "%d",
973 (l >> OP_SH_SEL) & OP_MASK_SEL);
974 break;
975
976 case 'O':
977 (*info->fprintf_func) (info->stream, "%d",
978 (l >> OP_SH_ALN) & OP_MASK_ALN);
979 break;
980
981 case 'Q':
982 {
983 unsigned int vsel = (l >> OP_SH_VSEL) & OP_MASK_VSEL;
984 if ((vsel & 0x10) == 0)
985 {
986 int fmt;
987 vsel &= 0x0f;
988 for (fmt = 0; fmt < 3; fmt++, vsel >>= 1)
989 if ((vsel & 1) == 0)
990 break;
991 (*info->fprintf_func) (info->stream, "$v%d[%d]",
992 (l >> OP_SH_FT) & OP_MASK_FT,
993 vsel >> 1);
994 }
995 else if ((vsel & 0x08) == 0)
996 {
997 (*info->fprintf_func) (info->stream, "$v%d",
998 (l >> OP_SH_FT) & OP_MASK_FT);
999 }
1000 else
1001 {
1002 (*info->fprintf_func) (info->stream, "0x%x",
1003 (l >> OP_SH_FT) & OP_MASK_FT);
1004 }
1005 }
1006 break;
1007
1008 case 'X':
1009 (*info->fprintf_func) (info->stream, "$v%d",
1010 (l >> OP_SH_FD) & OP_MASK_FD);
1011 break;
1012
1013 case 'Y':
1014 (*info->fprintf_func) (info->stream, "$v%d",
1015 (l >> OP_SH_FS) & OP_MASK_FS);
1016 break;
1017
1018 case 'Z':
1019 (*info->fprintf_func) (info->stream, "$v%d",
1020 (l >> OP_SH_FT) & OP_MASK_FT);
1021 break;
1022
1023 default:
1024 /* xgettext:c-format */
1025 (*info->fprintf_func) (info->stream,
1026 _("# internal error, undefined modifier(%c)"),
1027 *d);
1028 return;
1029 }
1030 }
1031 }
1032 \f
1033 /* Check if the object uses NewABI conventions. */
1034
1035 static int
1036 is_newabi (header)
1037 Elf_Internal_Ehdr *header;
1038 {
1039 /* There are no old-style ABIs which use 64-bit ELF. */
1040 if (header->e_ident[EI_CLASS] == ELFCLASS64)
1041 return 1;
1042
1043 /* If a 32-bit ELF file, n32 is a new-style ABI. */
1044 if ((header->e_flags & EF_MIPS_ABI2) != 0)
1045 return 1;
1046
1047 return 0;
1048 }
1049 \f
1050 /* Print the mips instruction at address MEMADDR in debugged memory,
1051 on using INFO. Returns length of the instruction, in bytes, which is
1052 always INSNLEN. BIGENDIAN must be 1 if this is big-endian code, 0 if
1053 this is little-endian code. */
1054
1055 static int
1056 print_insn_mips (memaddr, word, info)
1057 bfd_vma memaddr;
1058 unsigned long int word;
1059 struct disassemble_info *info;
1060 {
1061 register const struct mips_opcode *op;
1062 static bfd_boolean init = 0;
1063 static const struct mips_opcode *mips_hash[OP_MASK_OP + 1];
1064
1065 /* Build a hash table to shorten the search time. */
1066 if (! init)
1067 {
1068 unsigned int i;
1069
1070 for (i = 0; i <= OP_MASK_OP; i++)
1071 {
1072 for (op = mips_opcodes; op < &mips_opcodes[NUMOPCODES]; op++)
1073 {
1074 if (op->pinfo == INSN_MACRO)
1075 continue;
1076 if (i == ((op->match >> OP_SH_OP) & OP_MASK_OP))
1077 {
1078 mips_hash[i] = op;
1079 break;
1080 }
1081 }
1082 }
1083
1084 init = 1;
1085 }
1086
1087 info->bytes_per_chunk = INSNLEN;
1088 info->display_endian = info->endian;
1089 info->insn_info_valid = 1;
1090 info->branch_delay_insns = 0;
1091 info->data_size = 0;
1092 info->insn_type = dis_nonbranch;
1093 info->target = 0;
1094 info->target2 = 0;
1095
1096 op = mips_hash[(word >> OP_SH_OP) & OP_MASK_OP];
1097 if (op != NULL)
1098 {
1099 for (; op < &mips_opcodes[NUMOPCODES]; op++)
1100 {
1101 if (op->pinfo != INSN_MACRO && (word & op->mask) == op->match)
1102 {
1103 register const char *d;
1104
1105 /* We always allow to disassemble the jalx instruction. */
1106 if (! OPCODE_IS_MEMBER (op, mips_isa, mips_processor)
1107 && strcmp (op->name, "jalx"))
1108 continue;
1109
1110 /* Figure out instruction type and branch delay information. */
1111 if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
1112 {
1113 if ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1114 info->insn_type = dis_jsr;
1115 else
1116 info->insn_type = dis_branch;
1117 info->branch_delay_insns = 1;
1118 }
1119 else if ((op->pinfo & (INSN_COND_BRANCH_DELAY
1120 | INSN_COND_BRANCH_LIKELY)) != 0)
1121 {
1122 if ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1123 info->insn_type = dis_condjsr;
1124 else
1125 info->insn_type = dis_condbranch;
1126 info->branch_delay_insns = 1;
1127 }
1128 else if ((op->pinfo & (INSN_STORE_MEMORY
1129 | INSN_LOAD_MEMORY_DELAY)) != 0)
1130 info->insn_type = dis_dref;
1131
1132 (*info->fprintf_func) (info->stream, "%s", op->name);
1133
1134 d = op->args;
1135 if (d != NULL && *d != '\0')
1136 {
1137 (*info->fprintf_func) (info->stream, "\t");
1138 print_insn_args (d, word, memaddr, info);
1139 }
1140
1141 return INSNLEN;
1142 }
1143 }
1144 }
1145
1146 /* Handle undefined instructions. */
1147 info->insn_type = dis_noninsn;
1148 (*info->fprintf_func) (info->stream, "0x%x", word);
1149 return INSNLEN;
1150 }
1151 \f
1152 /* In an environment where we do not know the symbol type of the
1153 instruction we are forced to assume that the low order bit of the
1154 instructions' address may mark it as a mips16 instruction. If we
1155 are single stepping, or the pc is within the disassembled function,
1156 this works. Otherwise, we need a clue. Sometimes. */
1157
1158 static int
1159 _print_insn_mips (memaddr, info, endianness)
1160 bfd_vma memaddr;
1161 struct disassemble_info *info;
1162 enum bfd_endian endianness;
1163 {
1164 bfd_byte buffer[INSNLEN];
1165 int status;
1166
1167 set_default_mips_dis_options (info);
1168 parse_mips_dis_options (info->disassembler_options);
1169
1170 #if 1
1171 /* FIXME: If odd address, this is CLEARLY a mips 16 instruction. */
1172 /* Only a few tools will work this way. */
1173 if (memaddr & 0x01)
1174 return print_insn_mips16 (memaddr, info);
1175 #endif
1176
1177 #if SYMTAB_AVAILABLE
1178 if (info->mach == bfd_mach_mips16
1179 || (info->flavour == bfd_target_elf_flavour
1180 && info->symbols != NULL
1181 && ((*(elf_symbol_type **) info->symbols)->internal_elf_sym.st_other
1182 == STO_MIPS16)))
1183 return print_insn_mips16 (memaddr, info);
1184 #endif
1185
1186 status = (*info->read_memory_func) (memaddr, buffer, INSNLEN, info);
1187 if (status == 0)
1188 {
1189 unsigned long insn;
1190
1191 if (endianness == BFD_ENDIAN_BIG)
1192 insn = (unsigned long) bfd_getb32 (buffer);
1193 else
1194 insn = (unsigned long) bfd_getl32 (buffer);
1195
1196 return print_insn_mips (memaddr, insn, info);
1197 }
1198 else
1199 {
1200 (*info->memory_error_func) (status, memaddr, info);
1201 return -1;
1202 }
1203 }
1204
1205 int
1206 print_insn_big_mips (memaddr, info)
1207 bfd_vma memaddr;
1208 struct disassemble_info *info;
1209 {
1210 return _print_insn_mips (memaddr, info, BFD_ENDIAN_BIG);
1211 }
1212
1213 int
1214 print_insn_little_mips (memaddr, info)
1215 bfd_vma memaddr;
1216 struct disassemble_info *info;
1217 {
1218 return _print_insn_mips (memaddr, info, BFD_ENDIAN_LITTLE);
1219 }
1220 \f
1221 /* Disassemble mips16 instructions. */
1222
1223 static int
1224 print_insn_mips16 (memaddr, info)
1225 bfd_vma memaddr;
1226 struct disassemble_info *info;
1227 {
1228 int status;
1229 bfd_byte buffer[2];
1230 int length;
1231 int insn;
1232 bfd_boolean use_extend;
1233 int extend = 0;
1234 const struct mips_opcode *op, *opend;
1235
1236 info->bytes_per_chunk = 2;
1237 info->display_endian = info->endian;
1238 info->insn_info_valid = 1;
1239 info->branch_delay_insns = 0;
1240 info->data_size = 0;
1241 info->insn_type = dis_nonbranch;
1242 info->target = 0;
1243 info->target2 = 0;
1244
1245 status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1246 if (status != 0)
1247 {
1248 (*info->memory_error_func) (status, memaddr, info);
1249 return -1;
1250 }
1251
1252 length = 2;
1253
1254 if (info->endian == BFD_ENDIAN_BIG)
1255 insn = bfd_getb16 (buffer);
1256 else
1257 insn = bfd_getl16 (buffer);
1258
1259 /* Handle the extend opcode specially. */
1260 use_extend = FALSE;
1261 if ((insn & 0xf800) == 0xf000)
1262 {
1263 use_extend = TRUE;
1264 extend = insn & 0x7ff;
1265
1266 memaddr += 2;
1267
1268 status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1269 if (status != 0)
1270 {
1271 (*info->fprintf_func) (info->stream, "extend 0x%x",
1272 (unsigned int) extend);
1273 (*info->memory_error_func) (status, memaddr, info);
1274 return -1;
1275 }
1276
1277 if (info->endian == BFD_ENDIAN_BIG)
1278 insn = bfd_getb16 (buffer);
1279 else
1280 insn = bfd_getl16 (buffer);
1281
1282 /* Check for an extend opcode followed by an extend opcode. */
1283 if ((insn & 0xf800) == 0xf000)
1284 {
1285 (*info->fprintf_func) (info->stream, "extend 0x%x",
1286 (unsigned int) extend);
1287 info->insn_type = dis_noninsn;
1288 return length;
1289 }
1290
1291 length += 2;
1292 }
1293
1294 /* FIXME: Should probably use a hash table on the major opcode here. */
1295
1296 opend = mips16_opcodes + bfd_mips16_num_opcodes;
1297 for (op = mips16_opcodes; op < opend; op++)
1298 {
1299 if (op->pinfo != INSN_MACRO && (insn & op->mask) == op->match)
1300 {
1301 const char *s;
1302
1303 if (strchr (op->args, 'a') != NULL)
1304 {
1305 if (use_extend)
1306 {
1307 (*info->fprintf_func) (info->stream, "extend 0x%x",
1308 (unsigned int) extend);
1309 info->insn_type = dis_noninsn;
1310 return length - 2;
1311 }
1312
1313 use_extend = FALSE;
1314
1315 memaddr += 2;
1316
1317 status = (*info->read_memory_func) (memaddr, buffer, 2,
1318 info);
1319 if (status == 0)
1320 {
1321 use_extend = TRUE;
1322 if (info->endian == BFD_ENDIAN_BIG)
1323 extend = bfd_getb16 (buffer);
1324 else
1325 extend = bfd_getl16 (buffer);
1326 length += 2;
1327 }
1328 }
1329
1330 (*info->fprintf_func) (info->stream, "%s", op->name);
1331 if (op->args[0] != '\0')
1332 (*info->fprintf_func) (info->stream, "\t");
1333
1334 for (s = op->args; *s != '\0'; s++)
1335 {
1336 if (*s == ','
1337 && s[1] == 'w'
1338 && (((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)
1339 == ((insn >> MIPS16OP_SH_RY) & MIPS16OP_MASK_RY)))
1340 {
1341 /* Skip the register and the comma. */
1342 ++s;
1343 continue;
1344 }
1345 if (*s == ','
1346 && s[1] == 'v'
1347 && (((insn >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ)
1348 == ((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)))
1349 {
1350 /* Skip the register and the comma. */
1351 ++s;
1352 continue;
1353 }
1354 print_mips16_insn_arg (*s, op, insn, use_extend, extend, memaddr,
1355 info);
1356 }
1357
1358 if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
1359 {
1360 info->branch_delay_insns = 1;
1361 if (info->insn_type != dis_jsr)
1362 info->insn_type = dis_branch;
1363 }
1364
1365 return length;
1366 }
1367 }
1368
1369 if (use_extend)
1370 (*info->fprintf_func) (info->stream, "0x%x", extend | 0xf000);
1371 (*info->fprintf_func) (info->stream, "0x%x", insn);
1372 info->insn_type = dis_noninsn;
1373
1374 return length;
1375 }
1376
1377 /* Disassemble an operand for a mips16 instruction. */
1378
1379 static void
1380 print_mips16_insn_arg (type, op, l, use_extend, extend, memaddr, info)
1381 char type;
1382 const struct mips_opcode *op;
1383 int l;
1384 bfd_boolean use_extend;
1385 int extend;
1386 bfd_vma memaddr;
1387 struct disassemble_info *info;
1388 {
1389 switch (type)
1390 {
1391 case ',':
1392 case '(':
1393 case ')':
1394 (*info->fprintf_func) (info->stream, "%c", type);
1395 break;
1396
1397 case 'y':
1398 case 'w':
1399 (*info->fprintf_func) (info->stream, "%s",
1400 mips16_reg_names[((l >> MIPS16OP_SH_RY)
1401 & MIPS16OP_MASK_RY)]);
1402 break;
1403
1404 case 'x':
1405 case 'v':
1406 (*info->fprintf_func) (info->stream, "%s",
1407 mips16_reg_names[((l >> MIPS16OP_SH_RX)
1408 & MIPS16OP_MASK_RX)]);
1409 break;
1410
1411 case 'z':
1412 (*info->fprintf_func) (info->stream, "%s",
1413 mips16_reg_names[((l >> MIPS16OP_SH_RZ)
1414 & MIPS16OP_MASK_RZ)]);
1415 break;
1416
1417 case 'Z':
1418 (*info->fprintf_func) (info->stream, "%s",
1419 mips16_reg_names[((l >> MIPS16OP_SH_MOVE32Z)
1420 & MIPS16OP_MASK_MOVE32Z)]);
1421 break;
1422
1423 case '0':
1424 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1425 break;
1426
1427 case 'S':
1428 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[29]);
1429 break;
1430
1431 case 'P':
1432 (*info->fprintf_func) (info->stream, "$pc");
1433 break;
1434
1435 case 'R':
1436 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[31]);
1437 break;
1438
1439 case 'X':
1440 (*info->fprintf_func) (info->stream, "%s",
1441 mips_gpr_names[((l >> MIPS16OP_SH_REGR32)
1442 & MIPS16OP_MASK_REGR32)]);
1443 break;
1444
1445 case 'Y':
1446 (*info->fprintf_func) (info->stream, "%s",
1447 mips_gpr_names[MIPS16OP_EXTRACT_REG32R (l)]);
1448 break;
1449
1450 case '<':
1451 case '>':
1452 case '[':
1453 case ']':
1454 case '4':
1455 case '5':
1456 case 'H':
1457 case 'W':
1458 case 'D':
1459 case 'j':
1460 case '6':
1461 case '8':
1462 case 'V':
1463 case 'C':
1464 case 'U':
1465 case 'k':
1466 case 'K':
1467 case 'p':
1468 case 'q':
1469 case 'A':
1470 case 'B':
1471 case 'E':
1472 {
1473 int immed, nbits, shift, signedp, extbits, pcrel, extu, branch;
1474
1475 shift = 0;
1476 signedp = 0;
1477 extbits = 16;
1478 pcrel = 0;
1479 extu = 0;
1480 branch = 0;
1481 switch (type)
1482 {
1483 case '<':
1484 nbits = 3;
1485 immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1486 extbits = 5;
1487 extu = 1;
1488 break;
1489 case '>':
1490 nbits = 3;
1491 immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1492 extbits = 5;
1493 extu = 1;
1494 break;
1495 case '[':
1496 nbits = 3;
1497 immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1498 extbits = 6;
1499 extu = 1;
1500 break;
1501 case ']':
1502 nbits = 3;
1503 immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1504 extbits = 6;
1505 extu = 1;
1506 break;
1507 case '4':
1508 nbits = 4;
1509 immed = (l >> MIPS16OP_SH_IMM4) & MIPS16OP_MASK_IMM4;
1510 signedp = 1;
1511 extbits = 15;
1512 break;
1513 case '5':
1514 nbits = 5;
1515 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1516 info->insn_type = dis_dref;
1517 info->data_size = 1;
1518 break;
1519 case 'H':
1520 nbits = 5;
1521 shift = 1;
1522 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1523 info->insn_type = dis_dref;
1524 info->data_size = 2;
1525 break;
1526 case 'W':
1527 nbits = 5;
1528 shift = 2;
1529 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1530 if ((op->pinfo & MIPS16_INSN_READ_PC) == 0
1531 && (op->pinfo & MIPS16_INSN_READ_SP) == 0)
1532 {
1533 info->insn_type = dis_dref;
1534 info->data_size = 4;
1535 }
1536 break;
1537 case 'D':
1538 nbits = 5;
1539 shift = 3;
1540 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1541 info->insn_type = dis_dref;
1542 info->data_size = 8;
1543 break;
1544 case 'j':
1545 nbits = 5;
1546 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1547 signedp = 1;
1548 break;
1549 case '6':
1550 nbits = 6;
1551 immed = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1552 break;
1553 case '8':
1554 nbits = 8;
1555 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1556 break;
1557 case 'V':
1558 nbits = 8;
1559 shift = 2;
1560 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1561 /* FIXME: This might be lw, or it might be addiu to $sp or
1562 $pc. We assume it's load. */
1563 info->insn_type = dis_dref;
1564 info->data_size = 4;
1565 break;
1566 case 'C':
1567 nbits = 8;
1568 shift = 3;
1569 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1570 info->insn_type = dis_dref;
1571 info->data_size = 8;
1572 break;
1573 case 'U':
1574 nbits = 8;
1575 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1576 extu = 1;
1577 break;
1578 case 'k':
1579 nbits = 8;
1580 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1581 signedp = 1;
1582 break;
1583 case 'K':
1584 nbits = 8;
1585 shift = 3;
1586 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1587 signedp = 1;
1588 break;
1589 case 'p':
1590 nbits = 8;
1591 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1592 signedp = 1;
1593 pcrel = 1;
1594 branch = 1;
1595 info->insn_type = dis_condbranch;
1596 break;
1597 case 'q':
1598 nbits = 11;
1599 immed = (l >> MIPS16OP_SH_IMM11) & MIPS16OP_MASK_IMM11;
1600 signedp = 1;
1601 pcrel = 1;
1602 branch = 1;
1603 info->insn_type = dis_branch;
1604 break;
1605 case 'A':
1606 nbits = 8;
1607 shift = 2;
1608 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1609 pcrel = 1;
1610 /* FIXME: This can be lw or la. We assume it is lw. */
1611 info->insn_type = dis_dref;
1612 info->data_size = 4;
1613 break;
1614 case 'B':
1615 nbits = 5;
1616 shift = 3;
1617 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1618 pcrel = 1;
1619 info->insn_type = dis_dref;
1620 info->data_size = 8;
1621 break;
1622 case 'E':
1623 nbits = 5;
1624 shift = 2;
1625 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1626 pcrel = 1;
1627 break;
1628 default:
1629 abort ();
1630 }
1631
1632 if (! use_extend)
1633 {
1634 if (signedp && immed >= (1 << (nbits - 1)))
1635 immed -= 1 << nbits;
1636 immed <<= shift;
1637 if ((type == '<' || type == '>' || type == '[' || type == ']')
1638 && immed == 0)
1639 immed = 8;
1640 }
1641 else
1642 {
1643 if (extbits == 16)
1644 immed |= ((extend & 0x1f) << 11) | (extend & 0x7e0);
1645 else if (extbits == 15)
1646 immed |= ((extend & 0xf) << 11) | (extend & 0x7f0);
1647 else
1648 immed = ((extend >> 6) & 0x1f) | (extend & 0x20);
1649 immed &= (1 << extbits) - 1;
1650 if (! extu && immed >= (1 << (extbits - 1)))
1651 immed -= 1 << extbits;
1652 }
1653
1654 if (! pcrel)
1655 (*info->fprintf_func) (info->stream, "%d", immed);
1656 else
1657 {
1658 bfd_vma baseaddr;
1659
1660 if (branch)
1661 {
1662 immed *= 2;
1663 baseaddr = memaddr + 2;
1664 }
1665 else if (use_extend)
1666 baseaddr = memaddr - 2;
1667 else
1668 {
1669 int status;
1670 bfd_byte buffer[2];
1671
1672 baseaddr = memaddr;
1673
1674 /* If this instruction is in the delay slot of a jr
1675 instruction, the base address is the address of the
1676 jr instruction. If it is in the delay slot of jalr
1677 instruction, the base address is the address of the
1678 jalr instruction. This test is unreliable: we have
1679 no way of knowing whether the previous word is
1680 instruction or data. */
1681 status = (*info->read_memory_func) (memaddr - 4, buffer, 2,
1682 info);
1683 if (status == 0
1684 && (((info->endian == BFD_ENDIAN_BIG
1685 ? bfd_getb16 (buffer)
1686 : bfd_getl16 (buffer))
1687 & 0xf800) == 0x1800))
1688 baseaddr = memaddr - 4;
1689 else
1690 {
1691 status = (*info->read_memory_func) (memaddr - 2, buffer,
1692 2, info);
1693 if (status == 0
1694 && (((info->endian == BFD_ENDIAN_BIG
1695 ? bfd_getb16 (buffer)
1696 : bfd_getl16 (buffer))
1697 & 0xf81f) == 0xe800))
1698 baseaddr = memaddr - 2;
1699 }
1700 }
1701 info->target = (baseaddr & ~((1 << shift) - 1)) + immed;
1702 (*info->print_address_func) (info->target, info);
1703 }
1704 }
1705 break;
1706
1707 case 'a':
1708 if (! use_extend)
1709 extend = 0;
1710 l = ((l & 0x1f) << 23) | ((l & 0x3e0) << 13) | (extend << 2);
1711 info->target = ((memaddr + 4) & ~(bfd_vma) 0x0fffffff) | l;
1712 (*info->print_address_func) (info->target, info);
1713 info->insn_type = dis_jsr;
1714 info->branch_delay_insns = 1;
1715 break;
1716
1717 case 'l':
1718 case 'L':
1719 {
1720 int need_comma, amask, smask;
1721
1722 need_comma = 0;
1723
1724 l = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1725
1726 amask = (l >> 3) & 7;
1727
1728 if (amask > 0 && amask < 5)
1729 {
1730 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1731 if (amask > 1)
1732 (*info->fprintf_func) (info->stream, "-%s",
1733 mips_gpr_names[amask + 3]);
1734 need_comma = 1;
1735 }
1736
1737 smask = (l >> 1) & 3;
1738 if (smask == 3)
1739 {
1740 (*info->fprintf_func) (info->stream, "%s??",
1741 need_comma ? "," : "");
1742 need_comma = 1;
1743 }
1744 else if (smask > 0)
1745 {
1746 (*info->fprintf_func) (info->stream, "%s%s",
1747 need_comma ? "," : "",
1748 mips_gpr_names[16]);
1749 if (smask > 1)
1750 (*info->fprintf_func) (info->stream, "-%s",
1751 mips_gpr_names[smask + 15]);
1752 need_comma = 1;
1753 }
1754
1755 if (l & 1)
1756 {
1757 (*info->fprintf_func) (info->stream, "%s%s",
1758 need_comma ? "," : "",
1759 mips_gpr_names[31]);
1760 need_comma = 1;
1761 }
1762
1763 if (amask == 5 || amask == 6)
1764 {
1765 (*info->fprintf_func) (info->stream, "%s$f0",
1766 need_comma ? "," : "");
1767 if (amask == 6)
1768 (*info->fprintf_func) (info->stream, "-$f1");
1769 }
1770 }
1771 break;
1772
1773 default:
1774 /* xgettext:c-format */
1775 (*info->fprintf_func)
1776 (info->stream,
1777 _("# internal disassembler error, unrecognised modifier (%c)"),
1778 type);
1779 abort ();
1780 }
1781 }
1782
1783 void
1784 print_mips_disassembler_options (stream)
1785 FILE *stream;
1786 {
1787 unsigned int i;
1788
1789 fprintf (stream, _("\n\
1790 The following MIPS specific disassembler options are supported for use\n\
1791 with the -M switch (multiple options should be separated by commas):\n"));
1792
1793 fprintf (stream, _("\n\
1794 gpr-names=ABI Print GPR names according to specified ABI.\n\
1795 Default: based on binary being disassembled.\n"));
1796
1797 fprintf (stream, _("\n\
1798 fpr-names=ABI Print FPR names according to specified ABI.\n\
1799 Default: numeric.\n"));
1800
1801 fprintf (stream, _("\n\
1802 cp0-names=ARCH Print CP0 register names according to\n\
1803 specified architecture.\n\
1804 Default: based on binary being disassembled.\n"));
1805
1806 fprintf (stream, _("\n\
1807 hwr-names=ARCH Print HWR names according to specified \n\
1808 architecture.\n\
1809 Default: based on binary being disassembled.\n"));
1810
1811 fprintf (stream, _("\n\
1812 reg-names=ABI Print GPR and FPR names according to\n\
1813 specified ABI.\n"));
1814
1815 fprintf (stream, _("\n\
1816 reg-names=ARCH Print CP0 register and HWR names according to\n\
1817 specified architecture.\n"));
1818
1819 fprintf (stream, _("\n\
1820 For the options above, the following values are supported for \"ABI\":\n\
1821 "));
1822 for (i = 0; i < ARRAY_SIZE (mips_abi_choices); i++)
1823 fprintf (stream, " %s", mips_abi_choices[i].name);
1824 fprintf (stream, _("\n"));
1825
1826 fprintf (stream, _("\n\
1827 For the options above, The following values are supported for \"ARCH\":\n\
1828 "));
1829 for (i = 0; i < ARRAY_SIZE (mips_arch_choices); i++)
1830 if (*mips_arch_choices[i].name != '\0')
1831 fprintf (stream, " %s", mips_arch_choices[i].name);
1832 fprintf (stream, _("\n"));
1833
1834 fprintf (stream, _("\n"));
1835 }
git-cvsimport of binutils cvsroot