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