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