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