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