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