]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - opcodes/mips-dis.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update year range in copyright notice of binutils files
[thirdparty/binutils-gdb.git] / opcodes / mips-dis.c
1 /* Print mips instructions for GDB, the GNU debugger, or for objdump.
2 Copyright (C) 1989-2018 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 "disassemble.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 { "interaptiv-mr2", 1, bfd_mach_mips_interaptiv_mr2, CPU_INTERAPTIV_MR2,
611 ISA_MIPS32R3,
612 ASE_MT | ASE_EVA | ASE_DSP | ASE_DSPR2 | ASE_MIPS16E2 | ASE_MIPS16E2_MT,
613 mips_cp0_names_mips3264r2,
614 mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
615 mips_cp1_names_mips3264, mips_hwr_names_mips3264r2 },
616
617 { "sb1", 1, bfd_mach_mips_sb1, CPU_SB1,
618 ISA_MIPS64 | INSN_SB1, ASE_MIPS3D,
619 mips_cp0_names_sb1,
620 mips_cp0sel_names_sb1, ARRAY_SIZE (mips_cp0sel_names_sb1),
621 mips_cp1_names_mips3264, mips_hwr_names_numeric },
622
623 { "loongson2e", 1, bfd_mach_mips_loongson_2e, CPU_LOONGSON_2E,
624 ISA_MIPS3 | INSN_LOONGSON_2E, 0, mips_cp0_names_numeric,
625 NULL, 0, mips_cp1_names_numeric, mips_hwr_names_numeric },
626
627 { "loongson2f", 1, bfd_mach_mips_loongson_2f, CPU_LOONGSON_2F,
628 ISA_MIPS3 | INSN_LOONGSON_2F, 0, mips_cp0_names_numeric,
629 NULL, 0, mips_cp1_names_numeric, mips_hwr_names_numeric },
630
631 { "loongson3a", 1, bfd_mach_mips_loongson_3a, CPU_LOONGSON_3A,
632 ISA_MIPS64R2 | INSN_LOONGSON_3A, 0, mips_cp0_names_numeric,
633 NULL, 0, mips_cp1_names_mips3264, mips_hwr_names_numeric },
634
635 { "octeon", 1, bfd_mach_mips_octeon, CPU_OCTEON,
636 ISA_MIPS64R2 | INSN_OCTEON, 0, mips_cp0_names_numeric, NULL, 0,
637 mips_cp1_names_mips3264, mips_hwr_names_numeric },
638
639 { "octeon+", 1, bfd_mach_mips_octeonp, CPU_OCTEONP,
640 ISA_MIPS64R2 | INSN_OCTEONP, 0, mips_cp0_names_numeric,
641 NULL, 0, mips_cp1_names_mips3264, mips_hwr_names_numeric },
642
643 { "octeon2", 1, bfd_mach_mips_octeon2, CPU_OCTEON2,
644 ISA_MIPS64R2 | INSN_OCTEON2, 0, mips_cp0_names_numeric,
645 NULL, 0, mips_cp1_names_mips3264, mips_hwr_names_numeric },
646
647 { "octeon3", 1, bfd_mach_mips_octeon3, CPU_OCTEON3,
648 ISA_MIPS64R5 | INSN_OCTEON3, ASE_VIRT | ASE_VIRT64,
649 mips_cp0_names_numeric,
650 NULL, 0, mips_cp1_names_mips3264, mips_hwr_names_numeric },
651
652 { "xlr", 1, bfd_mach_mips_xlr, CPU_XLR,
653 ISA_MIPS64 | INSN_XLR, 0,
654 mips_cp0_names_xlr,
655 mips_cp0sel_names_xlr, ARRAY_SIZE (mips_cp0sel_names_xlr),
656 mips_cp1_names_mips3264, mips_hwr_names_numeric },
657
658 /* XLP is mostly like XLR, with the prominent exception it is being
659 MIPS64R2. */
660 { "xlp", 1, bfd_mach_mips_xlr, CPU_XLR,
661 ISA_MIPS64R2 | INSN_XLR, 0,
662 mips_cp0_names_xlr,
663 mips_cp0sel_names_xlr, ARRAY_SIZE (mips_cp0sel_names_xlr),
664 mips_cp1_names_mips3264, mips_hwr_names_numeric },
665
666 /* This entry, mips16, is here only for ISA/processor selection; do
667 not print its name. */
668 { "", 1, bfd_mach_mips16, CPU_MIPS16, ISA_MIPS64,
669 ASE_MIPS16E2 | ASE_MIPS16E2_MT,
670 mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
671 mips_hwr_names_numeric },
672 };
673
674 /* ISA and processor type to disassemble for, and register names to use.
675 set_default_mips_dis_options and parse_mips_dis_options fill in these
676 values. */
677 static int mips_processor;
678 static int mips_isa;
679 static int mips_ase;
680 static int micromips_ase;
681 static const char * const *mips_gpr_names;
682 static const char * const *mips_fpr_names;
683 static const char * const *mips_cp0_names;
684 static const struct mips_cp0sel_name *mips_cp0sel_names;
685 static int mips_cp0sel_names_len;
686 static const char * const *mips_cp1_names;
687 static const char * const *mips_hwr_names;
688
689 /* Other options */
690 static int no_aliases; /* If set disassemble as most general inst. */
691 \f
692 static const struct mips_abi_choice *
693 choose_abi_by_name (const char *name, unsigned int namelen)
694 {
695 const struct mips_abi_choice *c;
696 unsigned int i;
697
698 for (i = 0, c = NULL; i < ARRAY_SIZE (mips_abi_choices) && c == NULL; i++)
699 if (strncmp (mips_abi_choices[i].name, name, namelen) == 0
700 && strlen (mips_abi_choices[i].name) == namelen)
701 c = &mips_abi_choices[i];
702
703 return c;
704 }
705
706 static const struct mips_arch_choice *
707 choose_arch_by_name (const char *name, unsigned int namelen)
708 {
709 const struct mips_arch_choice *c = NULL;
710 unsigned int i;
711
712 for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
713 if (strncmp (mips_arch_choices[i].name, name, namelen) == 0
714 && strlen (mips_arch_choices[i].name) == namelen)
715 c = &mips_arch_choices[i];
716
717 return c;
718 }
719
720 static const struct mips_arch_choice *
721 choose_arch_by_number (unsigned long mach)
722 {
723 static unsigned long hint_bfd_mach;
724 static const struct mips_arch_choice *hint_arch_choice;
725 const struct mips_arch_choice *c;
726 unsigned int i;
727
728 /* We optimize this because even if the user specifies no
729 flags, this will be done for every instruction! */
730 if (hint_bfd_mach == mach
731 && hint_arch_choice != NULL
732 && hint_arch_choice->bfd_mach == hint_bfd_mach)
733 return hint_arch_choice;
734
735 for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
736 {
737 if (mips_arch_choices[i].bfd_mach_valid
738 && mips_arch_choices[i].bfd_mach == mach)
739 {
740 c = &mips_arch_choices[i];
741 hint_bfd_mach = mach;
742 hint_arch_choice = c;
743 }
744 }
745 return c;
746 }
747
748 /* Check if the object uses NewABI conventions. */
749
750 static int
751 is_newabi (Elf_Internal_Ehdr *header)
752 {
753 /* There are no old-style ABIs which use 64-bit ELF. */
754 if (header->e_ident[EI_CLASS] == ELFCLASS64)
755 return 1;
756
757 /* If a 32-bit ELF file, n32 is a new-style ABI. */
758 if ((header->e_flags & EF_MIPS_ABI2) != 0)
759 return 1;
760
761 return 0;
762 }
763
764 /* Check if the object has microMIPS ASE code. */
765
766 static int
767 is_micromips (Elf_Internal_Ehdr *header)
768 {
769 if ((header->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0)
770 return 1;
771
772 return 0;
773 }
774
775 /* Convert ASE flags from .MIPS.abiflags to internal values. */
776
777 static unsigned long
778 mips_convert_abiflags_ases (unsigned long afl_ases)
779 {
780 unsigned long opcode_ases = 0;
781
782 if (afl_ases & AFL_ASE_DSP)
783 opcode_ases |= ASE_DSP;
784 if (afl_ases & AFL_ASE_DSPR2)
785 opcode_ases |= ASE_DSPR2;
786 if (afl_ases & AFL_ASE_EVA)
787 opcode_ases |= ASE_EVA;
788 if (afl_ases & AFL_ASE_MCU)
789 opcode_ases |= ASE_MCU;
790 if (afl_ases & AFL_ASE_MDMX)
791 opcode_ases |= ASE_MDMX;
792 if (afl_ases & AFL_ASE_MIPS3D)
793 opcode_ases |= ASE_MIPS3D;
794 if (afl_ases & AFL_ASE_MT)
795 opcode_ases |= ASE_MT;
796 if (afl_ases & AFL_ASE_SMARTMIPS)
797 opcode_ases |= ASE_SMARTMIPS;
798 if (afl_ases & AFL_ASE_VIRT)
799 opcode_ases |= ASE_VIRT;
800 if (afl_ases & AFL_ASE_MSA)
801 opcode_ases |= ASE_MSA;
802 if (afl_ases & AFL_ASE_XPA)
803 opcode_ases |= ASE_XPA;
804 if (afl_ases & AFL_ASE_DSPR3)
805 opcode_ases |= ASE_DSPR3;
806 if (afl_ases & AFL_ASE_MIPS16E2)
807 opcode_ases |= ASE_MIPS16E2;
808 return opcode_ases;
809 }
810
811 /* Calculate combination ASE flags from regular ASE flags. */
812
813 static unsigned long
814 mips_calculate_combination_ases (unsigned long opcode_ases)
815 {
816 unsigned long combination_ases = 0;
817
818 if ((opcode_ases & (ASE_XPA | ASE_VIRT)) == (ASE_XPA | ASE_VIRT))
819 combination_ases |= ASE_XPA_VIRT;
820 if ((opcode_ases & (ASE_MIPS16E2 | ASE_MT)) == (ASE_MIPS16E2 | ASE_MT))
821 combination_ases |= ASE_MIPS16E2_MT;
822 return combination_ases;
823 }
824
825 static void
826 set_default_mips_dis_options (struct disassemble_info *info)
827 {
828 const struct mips_arch_choice *chosen_arch;
829
830 /* Defaults: mipsIII/r3000 (?!), no microMIPS ASE (any compressed code
831 is MIPS16 ASE) (o)32-style ("oldabi") GPR names, and numeric FPR,
832 CP0 register, and HWR names. */
833 mips_isa = ISA_MIPS3;
834 mips_processor = CPU_R3000;
835 micromips_ase = 0;
836 mips_ase = 0;
837 mips_gpr_names = mips_gpr_names_oldabi;
838 mips_fpr_names = mips_fpr_names_numeric;
839 mips_cp0_names = mips_cp0_names_numeric;
840 mips_cp0sel_names = NULL;
841 mips_cp0sel_names_len = 0;
842 mips_cp1_names = mips_cp1_names_numeric;
843 mips_hwr_names = mips_hwr_names_numeric;
844 no_aliases = 0;
845
846 /* Set ISA, architecture, and cp0 register names as best we can. */
847 #if ! SYMTAB_AVAILABLE
848 /* This is running out on a target machine, not in a host tool.
849 FIXME: Where does mips_target_info come from? */
850 target_processor = mips_target_info.processor;
851 mips_isa = mips_target_info.isa;
852 mips_ase = mips_target_info.ase;
853 #else
854 chosen_arch = choose_arch_by_number (info->mach);
855 if (chosen_arch != NULL)
856 {
857 mips_processor = chosen_arch->processor;
858 mips_isa = chosen_arch->isa;
859 mips_ase = chosen_arch->ase;
860 mips_cp0_names = chosen_arch->cp0_names;
861 mips_cp0sel_names = chosen_arch->cp0sel_names;
862 mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
863 mips_cp1_names = chosen_arch->cp1_names;
864 mips_hwr_names = chosen_arch->hwr_names;
865 }
866
867 /* Update settings according to the ELF file header flags. */
868 if (info->flavour == bfd_target_elf_flavour && info->section != NULL)
869 {
870 struct bfd *abfd = info->section->owner;
871 Elf_Internal_Ehdr *header = elf_elfheader (abfd);
872 Elf_Internal_ABIFlags_v0 *abiflags = NULL;
873
874 /* We won't ever get here if !HAVE_BFD_MIPS_ELF_GET_ABIFLAGS,
875 because we won't then have a MIPS/ELF BFD, however we need
876 to guard against a link error in a `--enable-targets=...'
877 configuration with a 32-bit host where the MIPS target is
878 a secondary, or with MIPS/ECOFF configurations. */
879 #ifdef HAVE_BFD_MIPS_ELF_GET_ABIFLAGS
880 abiflags = bfd_mips_elf_get_abiflags (abfd);
881 #endif
882 /* If an ELF "newabi" binary, use the n32/(n)64 GPR names. */
883 if (is_newabi (header))
884 mips_gpr_names = mips_gpr_names_newabi;
885 /* If a microMIPS binary, then don't use MIPS16 bindings. */
886 micromips_ase = is_micromips (header);
887 /* OR in any extra ASE flags set in ELF file structures. */
888 if (abiflags)
889 mips_ase |= mips_convert_abiflags_ases (abiflags->ases);
890 else if (header->e_flags & EF_MIPS_ARCH_ASE_MDMX)
891 mips_ase |= ASE_MDMX;
892 }
893 #endif
894 mips_ase |= mips_calculate_combination_ases (mips_ase);
895 }
896
897 /* Parse an ASE disassembler option and set the corresponding global
898 ASE flag(s). Return TRUE if successful, FALSE otherwise. */
899
900 static bfd_boolean
901 parse_mips_ase_option (const char *option)
902 {
903 if (CONST_STRNEQ (option, "msa"))
904 {
905 mips_ase |= ASE_MSA;
906 if ((mips_isa & INSN_ISA_MASK) == ISA_MIPS64R2
907 || (mips_isa & INSN_ISA_MASK) == ISA_MIPS64R3
908 || (mips_isa & INSN_ISA_MASK) == ISA_MIPS64R5
909 || (mips_isa & INSN_ISA_MASK) == ISA_MIPS64R6)
910 mips_ase |= ASE_MSA64;
911 return TRUE;
912 }
913
914 if (CONST_STRNEQ (option, "virt"))
915 {
916 mips_ase |= ASE_VIRT;
917 if (mips_isa & ISA_MIPS64R2
918 || mips_isa & ISA_MIPS64R3
919 || mips_isa & ISA_MIPS64R5
920 || mips_isa & ISA_MIPS64R6)
921 mips_ase |= ASE_VIRT64;
922 return TRUE;
923 }
924
925 if (CONST_STRNEQ (option, "xpa"))
926 {
927 mips_ase |= ASE_XPA;
928 return TRUE;
929 }
930
931 return FALSE;
932 }
933
934 static void
935 parse_mips_dis_option (const char *option, unsigned int len)
936 {
937 unsigned int i, optionlen, vallen;
938 const char *val;
939 const struct mips_abi_choice *chosen_abi;
940 const struct mips_arch_choice *chosen_arch;
941
942 /* Try to match options that are simple flags */
943 if (CONST_STRNEQ (option, "no-aliases"))
944 {
945 no_aliases = 1;
946 return;
947 }
948
949 if (parse_mips_ase_option (option))
950 {
951 mips_ase |= mips_calculate_combination_ases (mips_ase);
952 return;
953 }
954
955 /* Look for the = that delimits the end of the option name. */
956 for (i = 0; i < len; i++)
957 if (option[i] == '=')
958 break;
959
960 if (i == 0) /* Invalid option: no name before '='. */
961 return;
962 if (i == len) /* Invalid option: no '='. */
963 return;
964 if (i == (len - 1)) /* Invalid option: no value after '='. */
965 return;
966
967 optionlen = i;
968 val = option + (optionlen + 1);
969 vallen = len - (optionlen + 1);
970
971 if (strncmp ("gpr-names", option, optionlen) == 0
972 && strlen ("gpr-names") == optionlen)
973 {
974 chosen_abi = choose_abi_by_name (val, vallen);
975 if (chosen_abi != NULL)
976 mips_gpr_names = chosen_abi->gpr_names;
977 return;
978 }
979
980 if (strncmp ("fpr-names", option, optionlen) == 0
981 && strlen ("fpr-names") == optionlen)
982 {
983 chosen_abi = choose_abi_by_name (val, vallen);
984 if (chosen_abi != NULL)
985 mips_fpr_names = chosen_abi->fpr_names;
986 return;
987 }
988
989 if (strncmp ("cp0-names", option, optionlen) == 0
990 && strlen ("cp0-names") == optionlen)
991 {
992 chosen_arch = choose_arch_by_name (val, vallen);
993 if (chosen_arch != NULL)
994 {
995 mips_cp0_names = chosen_arch->cp0_names;
996 mips_cp0sel_names = chosen_arch->cp0sel_names;
997 mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
998 }
999 return;
1000 }
1001
1002 if (strncmp ("cp1-names", option, optionlen) == 0
1003 && strlen ("cp1-names") == optionlen)
1004 {
1005 chosen_arch = choose_arch_by_name (val, vallen);
1006 if (chosen_arch != NULL)
1007 mips_cp1_names = chosen_arch->cp1_names;
1008 return;
1009 }
1010
1011 if (strncmp ("hwr-names", option, optionlen) == 0
1012 && strlen ("hwr-names") == optionlen)
1013 {
1014 chosen_arch = choose_arch_by_name (val, vallen);
1015 if (chosen_arch != NULL)
1016 mips_hwr_names = chosen_arch->hwr_names;
1017 return;
1018 }
1019
1020 if (strncmp ("reg-names", option, optionlen) == 0
1021 && strlen ("reg-names") == optionlen)
1022 {
1023 /* We check both ABI and ARCH here unconditionally, so
1024 that "numeric" will do the desirable thing: select
1025 numeric register names for all registers. Other than
1026 that, a given name probably won't match both. */
1027 chosen_abi = choose_abi_by_name (val, vallen);
1028 if (chosen_abi != NULL)
1029 {
1030 mips_gpr_names = chosen_abi->gpr_names;
1031 mips_fpr_names = chosen_abi->fpr_names;
1032 }
1033 chosen_arch = choose_arch_by_name (val, vallen);
1034 if (chosen_arch != NULL)
1035 {
1036 mips_cp0_names = chosen_arch->cp0_names;
1037 mips_cp0sel_names = chosen_arch->cp0sel_names;
1038 mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
1039 mips_cp1_names = chosen_arch->cp1_names;
1040 mips_hwr_names = chosen_arch->hwr_names;
1041 }
1042 return;
1043 }
1044
1045 /* Invalid option. */
1046 }
1047
1048 static void
1049 parse_mips_dis_options (const char *options)
1050 {
1051 const char *option_end;
1052
1053 if (options == NULL)
1054 return;
1055
1056 while (*options != '\0')
1057 {
1058 /* Skip empty options. */
1059 if (*options == ',')
1060 {
1061 options++;
1062 continue;
1063 }
1064
1065 /* We know that *options is neither NUL or a comma. */
1066 option_end = options + 1;
1067 while (*option_end != ',' && *option_end != '\0')
1068 option_end++;
1069
1070 parse_mips_dis_option (options, option_end - options);
1071
1072 /* Go on to the next one. If option_end points to a comma, it
1073 will be skipped above. */
1074 options = option_end;
1075 }
1076 }
1077
1078 static const struct mips_cp0sel_name *
1079 lookup_mips_cp0sel_name (const struct mips_cp0sel_name *names,
1080 unsigned int len,
1081 unsigned int cp0reg,
1082 unsigned int sel)
1083 {
1084 unsigned int i;
1085
1086 for (i = 0; i < len; i++)
1087 if (names[i].cp0reg == cp0reg && names[i].sel == sel)
1088 return &names[i];
1089 return NULL;
1090 }
1091
1092 /* Print register REGNO, of type TYPE, for instruction OPCODE. */
1093
1094 static void
1095 print_reg (struct disassemble_info *info, const struct mips_opcode *opcode,
1096 enum mips_reg_operand_type type, int regno)
1097 {
1098 switch (type)
1099 {
1100 case OP_REG_GP:
1101 info->fprintf_func (info->stream, "%s", mips_gpr_names[regno]);
1102 break;
1103
1104 case OP_REG_FP:
1105 info->fprintf_func (info->stream, "%s", mips_fpr_names[regno]);
1106 break;
1107
1108 case OP_REG_CCC:
1109 if (opcode->pinfo & (FP_D | FP_S))
1110 info->fprintf_func (info->stream, "$fcc%d", regno);
1111 else
1112 info->fprintf_func (info->stream, "$cc%d", regno);
1113 break;
1114
1115 case OP_REG_VEC:
1116 if (opcode->membership & INSN_5400)
1117 info->fprintf_func (info->stream, "$f%d", regno);
1118 else
1119 info->fprintf_func (info->stream, "$v%d", regno);
1120 break;
1121
1122 case OP_REG_ACC:
1123 info->fprintf_func (info->stream, "$ac%d", regno);
1124 break;
1125
1126 case OP_REG_COPRO:
1127 if (opcode->name[strlen (opcode->name) - 1] == '0')
1128 info->fprintf_func (info->stream, "%s", mips_cp0_names[regno]);
1129 else if (opcode->name[strlen (opcode->name) - 1] == '1')
1130 info->fprintf_func (info->stream, "%s", mips_cp1_names[regno]);
1131 else
1132 info->fprintf_func (info->stream, "$%d", regno);
1133 break;
1134
1135 case OP_REG_HW:
1136 info->fprintf_func (info->stream, "%s", mips_hwr_names[regno]);
1137 break;
1138
1139 case OP_REG_VF:
1140 info->fprintf_func (info->stream, "$vf%d", regno);
1141 break;
1142
1143 case OP_REG_VI:
1144 info->fprintf_func (info->stream, "$vi%d", regno);
1145 break;
1146
1147 case OP_REG_R5900_I:
1148 info->fprintf_func (info->stream, "$I");
1149 break;
1150
1151 case OP_REG_R5900_Q:
1152 info->fprintf_func (info->stream, "$Q");
1153 break;
1154
1155 case OP_REG_R5900_R:
1156 info->fprintf_func (info->stream, "$R");
1157 break;
1158
1159 case OP_REG_R5900_ACC:
1160 info->fprintf_func (info->stream, "$ACC");
1161 break;
1162
1163 case OP_REG_MSA:
1164 info->fprintf_func (info->stream, "$w%d", regno);
1165 break;
1166
1167 case OP_REG_MSA_CTRL:
1168 info->fprintf_func (info->stream, "%s", msa_control_names[regno]);
1169 break;
1170
1171 }
1172 }
1173 \f
1174 /* Used to track the state carried over from previous operands in
1175 an instruction. */
1176 struct mips_print_arg_state {
1177 /* The value of the last OP_INT seen. We only use this for OP_MSB,
1178 where the value is known to be unsigned and small. */
1179 unsigned int last_int;
1180
1181 /* The type and number of the last OP_REG seen. We only use this for
1182 OP_REPEAT_DEST_REG and OP_REPEAT_PREV_REG. */
1183 enum mips_reg_operand_type last_reg_type;
1184 unsigned int last_regno;
1185 unsigned int dest_regno;
1186 unsigned int seen_dest;
1187 };
1188
1189 /* Initialize STATE for the start of an instruction. */
1190
1191 static inline void
1192 init_print_arg_state (struct mips_print_arg_state *state)
1193 {
1194 memset (state, 0, sizeof (*state));
1195 }
1196
1197 /* Print OP_VU0_SUFFIX or OP_VU0_MATCH_SUFFIX operand OPERAND,
1198 whose value is given by UVAL. */
1199
1200 static void
1201 print_vu0_channel (struct disassemble_info *info,
1202 const struct mips_operand *operand, unsigned int uval)
1203 {
1204 if (operand->size == 4)
1205 info->fprintf_func (info->stream, "%s%s%s%s",
1206 uval & 8 ? "x" : "",
1207 uval & 4 ? "y" : "",
1208 uval & 2 ? "z" : "",
1209 uval & 1 ? "w" : "");
1210 else if (operand->size == 2)
1211 info->fprintf_func (info->stream, "%c", "xyzw"[uval]);
1212 else
1213 abort ();
1214 }
1215
1216 /* Record information about a register operand. */
1217
1218 static void
1219 mips_seen_register (struct mips_print_arg_state *state,
1220 unsigned int regno,
1221 enum mips_reg_operand_type reg_type)
1222 {
1223 state->last_reg_type = reg_type;
1224 state->last_regno = regno;
1225
1226 if (!state->seen_dest)
1227 {
1228 state->seen_dest = 1;
1229 state->dest_regno = regno;
1230 }
1231 }
1232
1233 /* Print SAVE/RESTORE instruction operands according to the argument
1234 register mask AMASK, the number of static registers saved NSREG,
1235 the $ra, $s0 and $s1 register specifiers RA, S0 and S1 respectively,
1236 and the frame size FRAME_SIZE. */
1237
1238 static void
1239 mips_print_save_restore (struct disassemble_info *info, unsigned int amask,
1240 unsigned int nsreg, unsigned int ra,
1241 unsigned int s0, unsigned int s1,
1242 unsigned int frame_size)
1243 {
1244 const fprintf_ftype infprintf = info->fprintf_func;
1245 unsigned int nargs, nstatics, smask, i, j;
1246 void *is = info->stream;
1247 const char *sep;
1248
1249 if (amask == MIPS_SVRS_ALL_ARGS)
1250 {
1251 nargs = 4;
1252 nstatics = 0;
1253 }
1254 else if (amask == MIPS_SVRS_ALL_STATICS)
1255 {
1256 nargs = 0;
1257 nstatics = 4;
1258 }
1259 else
1260 {
1261 nargs = amask >> 2;
1262 nstatics = amask & 3;
1263 }
1264
1265 sep = "";
1266 if (nargs > 0)
1267 {
1268 infprintf (is, "%s", mips_gpr_names[4]);
1269 if (nargs > 1)
1270 infprintf (is, "-%s", mips_gpr_names[4 + nargs - 1]);
1271 sep = ",";
1272 }
1273
1274 infprintf (is, "%s%d", sep, frame_size);
1275
1276 if (ra) /* $ra */
1277 infprintf (is, ",%s", mips_gpr_names[31]);
1278
1279 smask = 0;
1280 if (s0) /* $s0 */
1281 smask |= 1 << 0;
1282 if (s1) /* $s1 */
1283 smask |= 1 << 1;
1284 if (nsreg > 0) /* $s2-$s8 */
1285 smask |= ((1 << nsreg) - 1) << 2;
1286
1287 for (i = 0; i < 9; i++)
1288 if (smask & (1 << i))
1289 {
1290 infprintf (is, ",%s", mips_gpr_names[i == 8 ? 30 : (16 + i)]);
1291 /* Skip over string of set bits. */
1292 for (j = i; smask & (2 << j); j++)
1293 continue;
1294 if (j > i)
1295 infprintf (is, "-%s", mips_gpr_names[j == 8 ? 30 : (16 + j)]);
1296 i = j + 1;
1297 }
1298 /* Statics $ax - $a3. */
1299 if (nstatics == 1)
1300 infprintf (is, ",%s", mips_gpr_names[7]);
1301 else if (nstatics > 0)
1302 infprintf (is, ",%s-%s",
1303 mips_gpr_names[7 - nstatics + 1],
1304 mips_gpr_names[7]);
1305 }
1306
1307
1308 /* Print operand OPERAND of OPCODE, using STATE to track inter-operand state.
1309 UVAL is the encoding of the operand (shifted into bit 0) and BASE_PC is
1310 the base address for OP_PCREL operands. */
1311
1312 static void
1313 print_insn_arg (struct disassemble_info *info,
1314 struct mips_print_arg_state *state,
1315 const struct mips_opcode *opcode,
1316 const struct mips_operand *operand,
1317 bfd_vma base_pc,
1318 unsigned int uval)
1319 {
1320 const fprintf_ftype infprintf = info->fprintf_func;
1321 void *is = info->stream;
1322
1323 switch (operand->type)
1324 {
1325 case OP_INT:
1326 {
1327 const struct mips_int_operand *int_op;
1328
1329 int_op = (const struct mips_int_operand *) operand;
1330 uval = mips_decode_int_operand (int_op, uval);
1331 state->last_int = uval;
1332 if (int_op->print_hex)
1333 infprintf (is, "0x%x", uval);
1334 else
1335 infprintf (is, "%d", uval);
1336 }
1337 break;
1338
1339 case OP_MAPPED_INT:
1340 {
1341 const struct mips_mapped_int_operand *mint_op;
1342
1343 mint_op = (const struct mips_mapped_int_operand *) operand;
1344 uval = mint_op->int_map[uval];
1345 state->last_int = uval;
1346 if (mint_op->print_hex)
1347 infprintf (is, "0x%x", uval);
1348 else
1349 infprintf (is, "%d", uval);
1350 }
1351 break;
1352
1353 case OP_MSB:
1354 {
1355 const struct mips_msb_operand *msb_op;
1356
1357 msb_op = (const struct mips_msb_operand *) operand;
1358 uval += msb_op->bias;
1359 if (msb_op->add_lsb)
1360 uval -= state->last_int;
1361 infprintf (is, "0x%x", uval);
1362 }
1363 break;
1364
1365 case OP_REG:
1366 case OP_OPTIONAL_REG:
1367 {
1368 const struct mips_reg_operand *reg_op;
1369
1370 reg_op = (const struct mips_reg_operand *) operand;
1371 uval = mips_decode_reg_operand (reg_op, uval);
1372 print_reg (info, opcode, reg_op->reg_type, uval);
1373
1374 mips_seen_register (state, uval, reg_op->reg_type);
1375 }
1376 break;
1377
1378 case OP_REG_PAIR:
1379 {
1380 const struct mips_reg_pair_operand *pair_op;
1381
1382 pair_op = (const struct mips_reg_pair_operand *) operand;
1383 print_reg (info, opcode, pair_op->reg_type,
1384 pair_op->reg1_map[uval]);
1385 infprintf (is, ",");
1386 print_reg (info, opcode, pair_op->reg_type,
1387 pair_op->reg2_map[uval]);
1388 }
1389 break;
1390
1391 case OP_PCREL:
1392 {
1393 const struct mips_pcrel_operand *pcrel_op;
1394
1395 pcrel_op = (const struct mips_pcrel_operand *) operand;
1396 info->target = mips_decode_pcrel_operand (pcrel_op, base_pc, uval);
1397
1398 /* For jumps and branches clear the ISA bit except for
1399 the GDB disassembler. */
1400 if (pcrel_op->include_isa_bit
1401 && info->flavour != bfd_target_unknown_flavour)
1402 info->target &= -2;
1403
1404 (*info->print_address_func) (info->target, info);
1405 }
1406 break;
1407
1408 case OP_PERF_REG:
1409 infprintf (is, "%d", uval);
1410 break;
1411
1412 case OP_ADDIUSP_INT:
1413 {
1414 int sval;
1415
1416 sval = mips_signed_operand (operand, uval) * 4;
1417 if (sval >= -8 && sval < 8)
1418 sval ^= 0x400;
1419 infprintf (is, "%d", sval);
1420 break;
1421 }
1422
1423 case OP_CLO_CLZ_DEST:
1424 {
1425 unsigned int reg1, reg2;
1426
1427 reg1 = uval & 31;
1428 reg2 = uval >> 5;
1429 /* If one is zero use the other. */
1430 if (reg1 == reg2 || reg2 == 0)
1431 infprintf (is, "%s", mips_gpr_names[reg1]);
1432 else if (reg1 == 0)
1433 infprintf (is, "%s", mips_gpr_names[reg2]);
1434 else
1435 /* Bogus, result depends on processor. */
1436 infprintf (is, "%s or %s", mips_gpr_names[reg1],
1437 mips_gpr_names[reg2]);
1438 }
1439 break;
1440
1441 case OP_SAME_RS_RT:
1442 case OP_CHECK_PREV:
1443 case OP_NON_ZERO_REG:
1444 {
1445 print_reg (info, opcode, OP_REG_GP, uval & 31);
1446 mips_seen_register (state, uval, OP_REG_GP);
1447 }
1448 break;
1449
1450 case OP_LWM_SWM_LIST:
1451 if (operand->size == 2)
1452 {
1453 if (uval == 0)
1454 infprintf (is, "%s,%s",
1455 mips_gpr_names[16],
1456 mips_gpr_names[31]);
1457 else
1458 infprintf (is, "%s-%s,%s",
1459 mips_gpr_names[16],
1460 mips_gpr_names[16 + uval],
1461 mips_gpr_names[31]);
1462 }
1463 else
1464 {
1465 int s_reg_encode;
1466
1467 s_reg_encode = uval & 0xf;
1468 if (s_reg_encode != 0)
1469 {
1470 if (s_reg_encode == 1)
1471 infprintf (is, "%s", mips_gpr_names[16]);
1472 else if (s_reg_encode < 9)
1473 infprintf (is, "%s-%s",
1474 mips_gpr_names[16],
1475 mips_gpr_names[15 + s_reg_encode]);
1476 else if (s_reg_encode == 9)
1477 infprintf (is, "%s-%s,%s",
1478 mips_gpr_names[16],
1479 mips_gpr_names[23],
1480 mips_gpr_names[30]);
1481 else
1482 infprintf (is, "UNKNOWN");
1483 }
1484
1485 if (uval & 0x10) /* For ra. */
1486 {
1487 if (s_reg_encode == 0)
1488 infprintf (is, "%s", mips_gpr_names[31]);
1489 else
1490 infprintf (is, ",%s", mips_gpr_names[31]);
1491 }
1492 }
1493 break;
1494
1495 case OP_ENTRY_EXIT_LIST:
1496 {
1497 const char *sep;
1498 unsigned int amask, smask;
1499
1500 sep = "";
1501 amask = (uval >> 3) & 7;
1502 if (amask > 0 && amask < 5)
1503 {
1504 infprintf (is, "%s", mips_gpr_names[4]);
1505 if (amask > 1)
1506 infprintf (is, "-%s", mips_gpr_names[amask + 3]);
1507 sep = ",";
1508 }
1509
1510 smask = (uval >> 1) & 3;
1511 if (smask == 3)
1512 {
1513 infprintf (is, "%s??", sep);
1514 sep = ",";
1515 }
1516 else if (smask > 0)
1517 {
1518 infprintf (is, "%s%s", sep, mips_gpr_names[16]);
1519 if (smask > 1)
1520 infprintf (is, "-%s", mips_gpr_names[smask + 15]);
1521 sep = ",";
1522 }
1523
1524 if (uval & 1)
1525 {
1526 infprintf (is, "%s%s", sep, mips_gpr_names[31]);
1527 sep = ",";
1528 }
1529
1530 if (amask == 5 || amask == 6)
1531 {
1532 infprintf (is, "%s%s", sep, mips_fpr_names[0]);
1533 if (amask == 6)
1534 infprintf (is, "-%s", mips_fpr_names[1]);
1535 }
1536 }
1537 break;
1538
1539 case OP_SAVE_RESTORE_LIST:
1540 /* Should be handled by the caller due to complex behavior. */
1541 abort ();
1542
1543 case OP_MDMX_IMM_REG:
1544 {
1545 unsigned int vsel;
1546
1547 vsel = uval >> 5;
1548 uval &= 31;
1549 if ((vsel & 0x10) == 0)
1550 {
1551 int fmt;
1552
1553 vsel &= 0x0f;
1554 for (fmt = 0; fmt < 3; fmt++, vsel >>= 1)
1555 if ((vsel & 1) == 0)
1556 break;
1557 print_reg (info, opcode, OP_REG_VEC, uval);
1558 infprintf (is, "[%d]", vsel >> 1);
1559 }
1560 else if ((vsel & 0x08) == 0)
1561 print_reg (info, opcode, OP_REG_VEC, uval);
1562 else
1563 infprintf (is, "0x%x", uval);
1564 }
1565 break;
1566
1567 case OP_REPEAT_PREV_REG:
1568 print_reg (info, opcode, state->last_reg_type, state->last_regno);
1569 break;
1570
1571 case OP_REPEAT_DEST_REG:
1572 print_reg (info, opcode, state->last_reg_type, state->dest_regno);
1573 break;
1574
1575 case OP_PC:
1576 infprintf (is, "$pc");
1577 break;
1578
1579 case OP_REG28:
1580 print_reg (info, opcode, OP_REG_GP, 28);
1581 break;
1582
1583 case OP_VU0_SUFFIX:
1584 case OP_VU0_MATCH_SUFFIX:
1585 print_vu0_channel (info, operand, uval);
1586 break;
1587
1588 case OP_IMM_INDEX:
1589 infprintf (is, "[%d]", uval);
1590 break;
1591
1592 case OP_REG_INDEX:
1593 infprintf (is, "[");
1594 print_reg (info, opcode, OP_REG_GP, uval);
1595 infprintf (is, "]");
1596 break;
1597 }
1598 }
1599
1600 /* Validate the arguments for INSN, which is described by OPCODE.
1601 Use DECODE_OPERAND to get the encoding of each operand. */
1602
1603 static bfd_boolean
1604 validate_insn_args (const struct mips_opcode *opcode,
1605 const struct mips_operand *(*decode_operand) (const char *),
1606 unsigned int insn)
1607 {
1608 struct mips_print_arg_state state;
1609 const struct mips_operand *operand;
1610 const char *s;
1611 unsigned int uval;
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 break;
1622
1623 case '#':
1624 ++s;
1625 break;
1626
1627 default:
1628 operand = decode_operand (s);
1629
1630 if (operand)
1631 {
1632 uval = mips_extract_operand (operand, insn);
1633 switch (operand->type)
1634 {
1635 case OP_REG:
1636 case OP_OPTIONAL_REG:
1637 {
1638 const struct mips_reg_operand *reg_op;
1639
1640 reg_op = (const struct mips_reg_operand *) operand;
1641 uval = mips_decode_reg_operand (reg_op, uval);
1642 mips_seen_register (&state, uval, reg_op->reg_type);
1643 }
1644 break;
1645
1646 case OP_SAME_RS_RT:
1647 {
1648 unsigned int reg1, reg2;
1649
1650 reg1 = uval & 31;
1651 reg2 = uval >> 5;
1652
1653 if (reg1 != reg2 || reg1 == 0)
1654 return FALSE;
1655 }
1656 break;
1657
1658 case OP_CHECK_PREV:
1659 {
1660 const struct mips_check_prev_operand *prev_op;
1661
1662 prev_op = (const struct mips_check_prev_operand *) operand;
1663
1664 if (!prev_op->zero_ok && uval == 0)
1665 return FALSE;
1666
1667 if (((prev_op->less_than_ok && uval < state.last_regno)
1668 || (prev_op->greater_than_ok && uval > state.last_regno)
1669 || (prev_op->equal_ok && uval == state.last_regno)))
1670 break;
1671
1672 return FALSE;
1673 }
1674
1675 case OP_NON_ZERO_REG:
1676 {
1677 if (uval == 0)
1678 return FALSE;
1679 }
1680 break;
1681
1682 case OP_INT:
1683 case OP_MAPPED_INT:
1684 case OP_MSB:
1685 case OP_REG_PAIR:
1686 case OP_PCREL:
1687 case OP_PERF_REG:
1688 case OP_ADDIUSP_INT:
1689 case OP_CLO_CLZ_DEST:
1690 case OP_LWM_SWM_LIST:
1691 case OP_ENTRY_EXIT_LIST:
1692 case OP_MDMX_IMM_REG:
1693 case OP_REPEAT_PREV_REG:
1694 case OP_REPEAT_DEST_REG:
1695 case OP_PC:
1696 case OP_REG28:
1697 case OP_VU0_SUFFIX:
1698 case OP_VU0_MATCH_SUFFIX:
1699 case OP_IMM_INDEX:
1700 case OP_REG_INDEX:
1701 case OP_SAVE_RESTORE_LIST:
1702 break;
1703 }
1704 }
1705 if (*s == 'm' || *s == '+' || *s == '-')
1706 ++s;
1707 }
1708 }
1709 return TRUE;
1710 }
1711
1712 /* Print the arguments for INSN, which is described by OPCODE.
1713 Use DECODE_OPERAND to get the encoding of each operand. Use BASE_PC
1714 as the base of OP_PCREL operands, adjusting by LENGTH if the OP_PCREL
1715 operand is for a branch or jump. */
1716
1717 static void
1718 print_insn_args (struct disassemble_info *info,
1719 const struct mips_opcode *opcode,
1720 const struct mips_operand *(*decode_operand) (const char *),
1721 unsigned int insn, bfd_vma insn_pc, unsigned int length)
1722 {
1723 const fprintf_ftype infprintf = info->fprintf_func;
1724 void *is = info->stream;
1725 struct mips_print_arg_state state;
1726 const struct mips_operand *operand;
1727 const char *s;
1728
1729 init_print_arg_state (&state);
1730 for (s = opcode->args; *s; ++s)
1731 {
1732 switch (*s)
1733 {
1734 case ',':
1735 case '(':
1736 case ')':
1737 infprintf (is, "%c", *s);
1738 break;
1739
1740 case '#':
1741 ++s;
1742 infprintf (is, "%c%c", *s, *s);
1743 break;
1744
1745 default:
1746 operand = decode_operand (s);
1747 if (!operand)
1748 {
1749 /* xgettext:c-format */
1750 infprintf (is,
1751 _("# internal error, undefined operand in `%s %s'"),
1752 opcode->name, opcode->args);
1753 return;
1754 }
1755
1756 if (operand->type == OP_SAVE_RESTORE_LIST)
1757 {
1758 /* Handle this case here because of the complex behavior. */
1759 unsigned int amask = (insn >> 15) & 0xf;
1760 unsigned int nsreg = (insn >> 23) & 0x7;
1761 unsigned int ra = insn & 0x1000; /* $ra */
1762 unsigned int s0 = insn & 0x800; /* $s0 */
1763 unsigned int s1 = insn & 0x400; /* $s1 */
1764 unsigned int frame_size = (((insn >> 15) & 0xf0)
1765 | ((insn >> 6) & 0x0f)) * 8;
1766 mips_print_save_restore (info, amask, nsreg, ra, s0, s1,
1767 frame_size);
1768 }
1769 else if (operand->type == OP_REG
1770 && s[1] == ','
1771 && s[2] == 'H'
1772 && opcode->name[strlen (opcode->name) - 1] == '0')
1773 {
1774 /* Coprocessor register 0 with sel field. */
1775 const struct mips_cp0sel_name *n;
1776 unsigned int reg, sel;
1777
1778 reg = mips_extract_operand (operand, insn);
1779 s += 2;
1780 operand = decode_operand (s);
1781 sel = mips_extract_operand (operand, insn);
1782
1783 /* CP0 register including 'sel' code for mftc0, to be
1784 printed textually if known. If not known, print both
1785 CP0 register name and sel numerically since CP0 register
1786 with sel 0 may have a name unrelated to register being
1787 printed. */
1788 n = lookup_mips_cp0sel_name (mips_cp0sel_names,
1789 mips_cp0sel_names_len,
1790 reg, sel);
1791 if (n != NULL)
1792 infprintf (is, "%s", n->name);
1793 else
1794 infprintf (is, "$%d,%d", reg, sel);
1795 }
1796 else
1797 {
1798 bfd_vma base_pc = insn_pc;
1799
1800 /* Adjust the PC relative base so that branch/jump insns use
1801 the following PC as the base but genuinely PC relative
1802 operands use the current PC. */
1803 if (operand->type == OP_PCREL)
1804 {
1805 const struct mips_pcrel_operand *pcrel_op;
1806
1807 pcrel_op = (const struct mips_pcrel_operand *) operand;
1808 /* The include_isa_bit flag is sufficient to distinguish
1809 branch/jump from other PC relative operands. */
1810 if (pcrel_op->include_isa_bit)
1811 base_pc += length;
1812 }
1813
1814 print_insn_arg (info, &state, opcode, operand, base_pc,
1815 mips_extract_operand (operand, insn));
1816 }
1817 if (*s == 'm' || *s == '+' || *s == '-')
1818 ++s;
1819 break;
1820 }
1821 }
1822 }
1823 \f
1824 /* Print the mips instruction at address MEMADDR in debugged memory,
1825 on using INFO. Returns length of the instruction, in bytes, which is
1826 always INSNLEN. BIGENDIAN must be 1 if this is big-endian code, 0 if
1827 this is little-endian code. */
1828
1829 static int
1830 print_insn_mips (bfd_vma memaddr,
1831 int word,
1832 struct disassemble_info *info)
1833 {
1834 #define GET_OP(insn, field) \
1835 (((insn) >> OP_SH_##field) & OP_MASK_##field)
1836 static const struct mips_opcode *mips_hash[OP_MASK_OP + 1];
1837 const fprintf_ftype infprintf = info->fprintf_func;
1838 const struct mips_opcode *op;
1839 static bfd_boolean init = 0;
1840 void *is = info->stream;
1841
1842 /* Build a hash table to shorten the search time. */
1843 if (! init)
1844 {
1845 unsigned int i;
1846
1847 for (i = 0; i <= OP_MASK_OP; i++)
1848 {
1849 for (op = mips_opcodes; op < &mips_opcodes[NUMOPCODES]; op++)
1850 {
1851 if (op->pinfo == INSN_MACRO
1852 || (no_aliases && (op->pinfo2 & INSN2_ALIAS)))
1853 continue;
1854 if (i == GET_OP (op->match, OP))
1855 {
1856 mips_hash[i] = op;
1857 break;
1858 }
1859 }
1860 }
1861
1862 init = 1;
1863 }
1864
1865 info->bytes_per_chunk = INSNLEN;
1866 info->display_endian = info->endian;
1867 info->insn_info_valid = 1;
1868 info->branch_delay_insns = 0;
1869 info->data_size = 0;
1870 info->insn_type = dis_nonbranch;
1871 info->target = 0;
1872 info->target2 = 0;
1873
1874 op = mips_hash[GET_OP (word, OP)];
1875 if (op != NULL)
1876 {
1877 for (; op < &mips_opcodes[NUMOPCODES]; op++)
1878 {
1879 if (op->pinfo != INSN_MACRO
1880 && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
1881 && (word & op->mask) == op->match)
1882 {
1883 /* We always disassemble the jalx instruction, except for MIPS r6. */
1884 if (!opcode_is_member (op, mips_isa, mips_ase, mips_processor)
1885 && (strcmp (op->name, "jalx")
1886 || (mips_isa & INSN_ISA_MASK) == ISA_MIPS32R6
1887 || (mips_isa & INSN_ISA_MASK) == ISA_MIPS64R6))
1888 continue;
1889
1890 /* Figure out instruction type and branch delay information. */
1891 if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
1892 {
1893 if ((op->pinfo & (INSN_WRITE_GPR_31 | INSN_WRITE_1)) != 0)
1894 info->insn_type = dis_jsr;
1895 else
1896 info->insn_type = dis_branch;
1897 info->branch_delay_insns = 1;
1898 }
1899 else if ((op->pinfo & (INSN_COND_BRANCH_DELAY
1900 | INSN_COND_BRANCH_LIKELY)) != 0)
1901 {
1902 if ((op->pinfo & INSN_WRITE_GPR_31) != 0)
1903 info->insn_type = dis_condjsr;
1904 else
1905 info->insn_type = dis_condbranch;
1906 info->branch_delay_insns = 1;
1907 }
1908 else if ((op->pinfo & (INSN_STORE_MEMORY
1909 | INSN_LOAD_MEMORY)) != 0)
1910 info->insn_type = dis_dref;
1911
1912 if (!validate_insn_args (op, decode_mips_operand, word))
1913 continue;
1914
1915 infprintf (is, "%s", op->name);
1916 if (op->pinfo2 & INSN2_VU0_CHANNEL_SUFFIX)
1917 {
1918 unsigned int uval;
1919
1920 infprintf (is, ".");
1921 uval = mips_extract_operand (&mips_vu0_channel_mask, word);
1922 print_vu0_channel (info, &mips_vu0_channel_mask, uval);
1923 }
1924
1925 if (op->args[0])
1926 {
1927 infprintf (is, "\t");
1928 print_insn_args (info, op, decode_mips_operand, word,
1929 memaddr, 4);
1930 }
1931
1932 return INSNLEN;
1933 }
1934 }
1935 }
1936 #undef GET_OP
1937
1938 /* Handle undefined instructions. */
1939 info->insn_type = dis_noninsn;
1940 infprintf (is, "0x%x", word);
1941 return INSNLEN;
1942 }
1943 \f
1944 /* Disassemble an operand for a mips16 instruction. */
1945
1946 static void
1947 print_mips16_insn_arg (struct disassemble_info *info,
1948 struct mips_print_arg_state *state,
1949 const struct mips_opcode *opcode,
1950 char type, bfd_vma memaddr,
1951 unsigned insn, bfd_boolean use_extend,
1952 unsigned extend, bfd_boolean is_offset)
1953 {
1954 const fprintf_ftype infprintf = info->fprintf_func;
1955 void *is = info->stream;
1956 const struct mips_operand *operand, *ext_operand;
1957 unsigned short ext_size;
1958 unsigned int uval;
1959 bfd_vma baseaddr;
1960
1961 if (!use_extend)
1962 extend = 0;
1963
1964 switch (type)
1965 {
1966 case ',':
1967 case '(':
1968 case ')':
1969 infprintf (is, "%c", type);
1970 break;
1971
1972 default:
1973 operand = decode_mips16_operand (type, FALSE);
1974 if (!operand)
1975 {
1976 /* xgettext:c-format */
1977 infprintf (is, _("# internal error, undefined operand in `%s %s'"),
1978 opcode->name, opcode->args);
1979 return;
1980 }
1981
1982 if (operand->type == OP_SAVE_RESTORE_LIST)
1983 {
1984 /* Handle this case here because of the complex interaction
1985 with the EXTEND opcode. */
1986 unsigned int amask = extend & 0xf;
1987 unsigned int nsreg = (extend >> 8) & 0x7;
1988 unsigned int ra = insn & 0x40; /* $ra */
1989 unsigned int s0 = insn & 0x20; /* $s0 */
1990 unsigned int s1 = insn & 0x10; /* $s1 */
1991 unsigned int frame_size = ((extend & 0xf0) | (insn & 0x0f)) * 8;
1992 if (frame_size == 0 && !use_extend)
1993 frame_size = 128;
1994 mips_print_save_restore (info, amask, nsreg, ra, s0, s1, frame_size);
1995 break;
1996 }
1997
1998 if (is_offset && operand->type == OP_INT)
1999 {
2000 const struct mips_int_operand *int_op;
2001
2002 int_op = (const struct mips_int_operand *) operand;
2003 info->insn_type = dis_dref;
2004 info->data_size = 1 << int_op->shift;
2005 }
2006
2007 ext_size = 0;
2008 if (use_extend)
2009 {
2010 ext_operand = decode_mips16_operand (type, TRUE);
2011 if (ext_operand != operand
2012 || (operand->type == OP_INT && operand->lsb == 0
2013 && mips_opcode_32bit_p (opcode)))
2014 {
2015 ext_size = ext_operand->size;
2016 operand = ext_operand;
2017 }
2018 }
2019 if (operand->size == 26)
2020 uval = ((extend & 0x1f) << 21) | ((extend & 0x3e0) << 11) | insn;
2021 else if (ext_size == 16 || ext_size == 9)
2022 uval = ((extend & 0x1f) << 11) | (extend & 0x7e0) | (insn & 0x1f);
2023 else if (ext_size == 15)
2024 uval = ((extend & 0xf) << 11) | (extend & 0x7f0) | (insn & 0xf);
2025 else if (ext_size == 6)
2026 uval = ((extend >> 6) & 0x1f) | (extend & 0x20);
2027 else
2028 uval = mips_extract_operand (operand, (extend << 16) | insn);
2029 if (ext_size == 9)
2030 uval &= (1U << ext_size) - 1;
2031
2032 baseaddr = memaddr + 2;
2033 if (operand->type == OP_PCREL)
2034 {
2035 const struct mips_pcrel_operand *pcrel_op;
2036
2037 pcrel_op = (const struct mips_pcrel_operand *) operand;
2038 if (!pcrel_op->include_isa_bit && use_extend)
2039 baseaddr = memaddr - 2;
2040 else if (!pcrel_op->include_isa_bit)
2041 {
2042 bfd_byte buffer[2];
2043
2044 /* If this instruction is in the delay slot of a JAL/JALX
2045 instruction, the base address is the address of the
2046 JAL/JALX instruction. If it is in the delay slot of
2047 a JR/JALR instruction, the base address is the address
2048 of the JR/JALR instruction. This test is unreliable:
2049 we have no way of knowing whether the previous word is
2050 instruction or data. */
2051 if (info->read_memory_func (memaddr - 4, buffer, 2, info) == 0
2052 && (((info->endian == BFD_ENDIAN_BIG
2053 ? bfd_getb16 (buffer)
2054 : bfd_getl16 (buffer))
2055 & 0xf800) == 0x1800))
2056 baseaddr = memaddr - 4;
2057 else if (info->read_memory_func (memaddr - 2, buffer, 2,
2058 info) == 0
2059 && (((info->endian == BFD_ENDIAN_BIG
2060 ? bfd_getb16 (buffer)
2061 : bfd_getl16 (buffer))
2062 & 0xf89f) == 0xe800)
2063 && (((info->endian == BFD_ENDIAN_BIG
2064 ? bfd_getb16 (buffer)
2065 : bfd_getl16 (buffer))
2066 & 0x0060) != 0x0060))
2067 baseaddr = memaddr - 2;
2068 else
2069 baseaddr = memaddr;
2070 }
2071 }
2072
2073 print_insn_arg (info, state, opcode, operand, baseaddr + 1, uval);
2074 break;
2075 }
2076 }
2077
2078
2079 /* Check if the given address is the last word of a MIPS16 PLT entry.
2080 This word is data and depending on the value it may interfere with
2081 disassembly of further PLT entries. We make use of the fact PLT
2082 symbols are marked BSF_SYNTHETIC. */
2083 static bfd_boolean
2084 is_mips16_plt_tail (struct disassemble_info *info, bfd_vma addr)
2085 {
2086 if (info->symbols
2087 && info->symbols[0]
2088 && (info->symbols[0]->flags & BSF_SYNTHETIC)
2089 && addr == bfd_asymbol_value (info->symbols[0]) + 12)
2090 return TRUE;
2091
2092 return FALSE;
2093 }
2094
2095 /* Whether none, a 32-bit or a 16-bit instruction match has been done. */
2096
2097 enum match_kind
2098 {
2099 MATCH_NONE,
2100 MATCH_FULL,
2101 MATCH_SHORT
2102 };
2103
2104 /* Disassemble mips16 instructions. */
2105
2106 static int
2107 print_insn_mips16 (bfd_vma memaddr, struct disassemble_info *info)
2108 {
2109 const fprintf_ftype infprintf = info->fprintf_func;
2110 int status;
2111 bfd_byte buffer[4];
2112 const struct mips_opcode *op, *opend;
2113 struct mips_print_arg_state state;
2114 void *is = info->stream;
2115 bfd_boolean have_second;
2116 bfd_boolean extend_only;
2117 unsigned int second;
2118 unsigned int first;
2119 unsigned int full;
2120
2121 info->bytes_per_chunk = 2;
2122 info->display_endian = info->endian;
2123 info->insn_info_valid = 1;
2124 info->branch_delay_insns = 0;
2125 info->data_size = 0;
2126 info->target = 0;
2127 info->target2 = 0;
2128
2129 #define GET_OP(insn, field) \
2130 (((insn) >> MIPS16OP_SH_##field) & MIPS16OP_MASK_##field)
2131 /* Decode PLT entry's GOT slot address word. */
2132 if (is_mips16_plt_tail (info, memaddr))
2133 {
2134 info->insn_type = dis_noninsn;
2135 status = (*info->read_memory_func) (memaddr, buffer, 4, info);
2136 if (status == 0)
2137 {
2138 unsigned int gotslot;
2139
2140 if (info->endian == BFD_ENDIAN_BIG)
2141 gotslot = bfd_getb32 (buffer);
2142 else
2143 gotslot = bfd_getl32 (buffer);
2144 infprintf (is, ".word\t0x%x", gotslot);
2145
2146 return 4;
2147 }
2148 }
2149 else
2150 {
2151 info->insn_type = dis_nonbranch;
2152 status = (*info->read_memory_func) (memaddr, buffer, 2, info);
2153 }
2154 if (status != 0)
2155 {
2156 (*info->memory_error_func) (status, memaddr, info);
2157 return -1;
2158 }
2159
2160 extend_only = FALSE;
2161
2162 if (info->endian == BFD_ENDIAN_BIG)
2163 first = bfd_getb16 (buffer);
2164 else
2165 first = bfd_getl16 (buffer);
2166
2167 status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info);
2168 if (status == 0)
2169 {
2170 have_second = TRUE;
2171 if (info->endian == BFD_ENDIAN_BIG)
2172 second = bfd_getb16 (buffer);
2173 else
2174 second = bfd_getl16 (buffer);
2175 full = (first << 16) | second;
2176 }
2177 else
2178 {
2179 have_second = FALSE;
2180 second = 0;
2181 full = first;
2182 }
2183
2184 /* FIXME: Should probably use a hash table on the major opcode here. */
2185
2186 opend = mips16_opcodes + bfd_mips16_num_opcodes;
2187 for (op = mips16_opcodes; op < opend; op++)
2188 {
2189 enum match_kind match;
2190
2191 if (!opcode_is_member (op, mips_isa, mips_ase, mips_processor))
2192 continue;
2193
2194 if (op->pinfo == INSN_MACRO
2195 || (no_aliases && (op->pinfo2 & INSN2_ALIAS)))
2196 match = MATCH_NONE;
2197 else if (mips_opcode_32bit_p (op))
2198 {
2199 if (have_second
2200 && (full & op->mask) == op->match)
2201 match = MATCH_FULL;
2202 else
2203 match = MATCH_NONE;
2204 }
2205 else if ((first & op->mask) == op->match)
2206 {
2207 match = MATCH_SHORT;
2208 second = 0;
2209 full = first;
2210 }
2211 else if ((first & 0xf800) == 0xf000
2212 && have_second
2213 && !extend_only
2214 && (second & op->mask) == op->match)
2215 {
2216 if (op->pinfo2 & INSN2_SHORT_ONLY)
2217 {
2218 match = MATCH_NONE;
2219 extend_only = TRUE;
2220 }
2221 else
2222 match = MATCH_FULL;
2223 }
2224 else
2225 match = MATCH_NONE;
2226
2227 if (match != MATCH_NONE)
2228 {
2229 const char *s;
2230
2231 infprintf (is, "%s", op->name);
2232 if (op->args[0] != '\0')
2233 infprintf (is, "\t");
2234
2235 init_print_arg_state (&state);
2236 for (s = op->args; *s != '\0'; s++)
2237 {
2238 if (*s == ','
2239 && s[1] == 'w'
2240 && GET_OP (full, RX) == GET_OP (full, RY))
2241 {
2242 /* Skip the register and the comma. */
2243 ++s;
2244 continue;
2245 }
2246 if (*s == ','
2247 && s[1] == 'v'
2248 && GET_OP (full, RZ) == GET_OP (full, RX))
2249 {
2250 /* Skip the register and the comma. */
2251 ++s;
2252 continue;
2253 }
2254 if (s[0] == 'N'
2255 && s[1] == ','
2256 && s[2] == 'O'
2257 && op->name[strlen (op->name) - 1] == '0')
2258 {
2259 /* Coprocessor register 0 with sel field. */
2260 const struct mips_cp0sel_name *n;
2261 const struct mips_operand *operand;
2262 unsigned int reg, sel;
2263
2264 operand = decode_mips16_operand (*s, TRUE);
2265 reg = mips_extract_operand (operand, (first << 16) | second);
2266 s += 2;
2267 operand = decode_mips16_operand (*s, TRUE);
2268 sel = mips_extract_operand (operand, (first << 16) | second);
2269
2270 /* CP0 register including 'sel' code for mftc0, to be
2271 printed textually if known. If not known, print both
2272 CP0 register name and sel numerically since CP0 register
2273 with sel 0 may have a name unrelated to register being
2274 printed. */
2275 n = lookup_mips_cp0sel_name (mips_cp0sel_names,
2276 mips_cp0sel_names_len,
2277 reg, sel);
2278 if (n != NULL)
2279 infprintf (is, "%s", n->name);
2280 else
2281 infprintf (is, "$%d,%d", reg, sel);
2282 }
2283 else
2284 switch (match)
2285 {
2286 case MATCH_FULL:
2287 print_mips16_insn_arg (info, &state, op, *s, memaddr + 2,
2288 second, TRUE, first, s[1] == '(');
2289 break;
2290 case MATCH_SHORT:
2291 print_mips16_insn_arg (info, &state, op, *s, memaddr,
2292 first, FALSE, 0, s[1] == '(');
2293 break;
2294 case MATCH_NONE: /* Stop the compiler complaining. */
2295 break;
2296 }
2297 }
2298
2299 /* Figure out branch instruction type and delay slot information. */
2300 if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
2301 info->branch_delay_insns = 1;
2302 if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0
2303 || (op->pinfo2 & INSN2_UNCOND_BRANCH) != 0)
2304 {
2305 if ((op->pinfo & INSN_WRITE_GPR_31) != 0)
2306 info->insn_type = dis_jsr;
2307 else
2308 info->insn_type = dis_branch;
2309 }
2310 else if ((op->pinfo2 & INSN2_COND_BRANCH) != 0)
2311 info->insn_type = dis_condbranch;
2312
2313 return match == MATCH_FULL ? 4 : 2;
2314 }
2315 }
2316 #undef GET_OP
2317
2318 infprintf (is, "0x%x", first);
2319 info->insn_type = dis_noninsn;
2320
2321 return 2;
2322 }
2323
2324 /* Disassemble microMIPS instructions. */
2325
2326 static int
2327 print_insn_micromips (bfd_vma memaddr, struct disassemble_info *info)
2328 {
2329 const fprintf_ftype infprintf = info->fprintf_func;
2330 const struct mips_opcode *op, *opend;
2331 void *is = info->stream;
2332 bfd_byte buffer[2];
2333 unsigned int higher;
2334 unsigned int length;
2335 int status;
2336 unsigned int insn;
2337
2338 info->bytes_per_chunk = 2;
2339 info->display_endian = info->endian;
2340 info->insn_info_valid = 1;
2341 info->branch_delay_insns = 0;
2342 info->data_size = 0;
2343 info->insn_type = dis_nonbranch;
2344 info->target = 0;
2345 info->target2 = 0;
2346
2347 status = (*info->read_memory_func) (memaddr, buffer, 2, info);
2348 if (status != 0)
2349 {
2350 (*info->memory_error_func) (status, memaddr, info);
2351 return -1;
2352 }
2353
2354 length = 2;
2355
2356 if (info->endian == BFD_ENDIAN_BIG)
2357 insn = bfd_getb16 (buffer);
2358 else
2359 insn = bfd_getl16 (buffer);
2360
2361 if ((insn & 0x1c00) == 0x0000 || (insn & 0x1000) == 0x1000)
2362 {
2363 /* This is a 32-bit microMIPS instruction. */
2364 higher = insn;
2365
2366 status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info);
2367 if (status != 0)
2368 {
2369 infprintf (is, "micromips 0x%x", higher);
2370 (*info->memory_error_func) (status, memaddr + 2, info);
2371 return -1;
2372 }
2373
2374 if (info->endian == BFD_ENDIAN_BIG)
2375 insn = bfd_getb16 (buffer);
2376 else
2377 insn = bfd_getl16 (buffer);
2378
2379 insn = insn | (higher << 16);
2380
2381 length += 2;
2382 }
2383
2384 /* FIXME: Should probably use a hash table on the major opcode here. */
2385
2386 opend = micromips_opcodes + bfd_micromips_num_opcodes;
2387 for (op = micromips_opcodes; op < opend; op++)
2388 {
2389 if (op->pinfo != INSN_MACRO
2390 && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
2391 && (insn & op->mask) == op->match
2392 && ((length == 2 && (op->mask & 0xffff0000) == 0)
2393 || (length == 4 && (op->mask & 0xffff0000) != 0)))
2394 {
2395 if (!validate_insn_args (op, decode_micromips_operand, insn))
2396 continue;
2397
2398 infprintf (is, "%s", op->name);
2399
2400 if (op->args[0])
2401 {
2402 infprintf (is, "\t");
2403 print_insn_args (info, op, decode_micromips_operand, insn,
2404 memaddr + 1, length);
2405 }
2406
2407 /* Figure out instruction type and branch delay information. */
2408 if ((op->pinfo
2409 & (INSN_UNCOND_BRANCH_DELAY | INSN_COND_BRANCH_DELAY)) != 0)
2410 info->branch_delay_insns = 1;
2411 if (((op->pinfo & INSN_UNCOND_BRANCH_DELAY)
2412 | (op->pinfo2 & INSN2_UNCOND_BRANCH)) != 0)
2413 {
2414 if ((op->pinfo & (INSN_WRITE_GPR_31 | INSN_WRITE_1)) != 0)
2415 info->insn_type = dis_jsr;
2416 else
2417 info->insn_type = dis_branch;
2418 }
2419 else if (((op->pinfo & INSN_COND_BRANCH_DELAY)
2420 | (op->pinfo2 & INSN2_COND_BRANCH)) != 0)
2421 {
2422 if ((op->pinfo & INSN_WRITE_GPR_31) != 0)
2423 info->insn_type = dis_condjsr;
2424 else
2425 info->insn_type = dis_condbranch;
2426 }
2427 else if ((op->pinfo
2428 & (INSN_STORE_MEMORY | INSN_LOAD_MEMORY)) != 0)
2429 info->insn_type = dis_dref;
2430
2431 return length;
2432 }
2433 }
2434
2435 infprintf (is, "0x%x", insn);
2436 info->insn_type = dis_noninsn;
2437
2438 return length;
2439 }
2440
2441 /* Return 1 if a symbol associated with the location being disassembled
2442 indicates a compressed mode, either MIPS16 or microMIPS, according to
2443 MICROMIPS_P. We iterate over all the symbols at the address being
2444 considered assuming if at least one of them indicates code compression,
2445 then such code has been genuinely produced here (other symbols could
2446 have been derived from function symbols defined elsewhere or could
2447 define data). Otherwise, return 0. */
2448
2449 static bfd_boolean
2450 is_compressed_mode_p (struct disassemble_info *info, bfd_boolean micromips_p)
2451 {
2452 int i;
2453 int l;
2454
2455 for (i = info->symtab_pos, l = i + info->num_symbols; i < l; i++)
2456 if (((info->symtab[i])->flags & BSF_SYNTHETIC) != 0
2457 && ((!micromips_p
2458 && ELF_ST_IS_MIPS16 ((*info->symbols)->udata.i))
2459 || (micromips_p
2460 && ELF_ST_IS_MICROMIPS ((*info->symbols)->udata.i))))
2461 return 1;
2462 else if (bfd_asymbol_flavour (info->symtab[i]) == bfd_target_elf_flavour
2463 && info->symtab[i]->section == info->section)
2464 {
2465 elf_symbol_type *symbol = (elf_symbol_type *) info->symtab[i];
2466 if ((!micromips_p
2467 && ELF_ST_IS_MIPS16 (symbol->internal_elf_sym.st_other))
2468 || (micromips_p
2469 && ELF_ST_IS_MICROMIPS (symbol->internal_elf_sym.st_other)))
2470 return 1;
2471 }
2472
2473 return 0;
2474 }
2475
2476 /* In an environment where we do not know the symbol type of the
2477 instruction we are forced to assume that the low order bit of the
2478 instructions' address may mark it as a mips16 instruction. If we
2479 are single stepping, or the pc is within the disassembled function,
2480 this works. Otherwise, we need a clue. Sometimes. */
2481
2482 static int
2483 _print_insn_mips (bfd_vma memaddr,
2484 struct disassemble_info *info,
2485 enum bfd_endian endianness)
2486 {
2487 bfd_byte buffer[INSNLEN];
2488 int status;
2489
2490 set_default_mips_dis_options (info);
2491 parse_mips_dis_options (info->disassembler_options);
2492
2493 if (info->mach == bfd_mach_mips16)
2494 return print_insn_mips16 (memaddr, info);
2495 if (info->mach == bfd_mach_mips_micromips)
2496 return print_insn_micromips (memaddr, info);
2497
2498 #if 1
2499 /* FIXME: If odd address, this is CLEARLY a compressed instruction. */
2500 /* Only a few tools will work this way. */
2501 if (memaddr & 0x01)
2502 {
2503 if (micromips_ase)
2504 return print_insn_micromips (memaddr, info);
2505 else
2506 return print_insn_mips16 (memaddr, info);
2507 }
2508 #endif
2509
2510 #if SYMTAB_AVAILABLE
2511 if (is_compressed_mode_p (info, TRUE))
2512 return print_insn_micromips (memaddr, info);
2513 if (is_compressed_mode_p (info, FALSE))
2514 return print_insn_mips16 (memaddr, info);
2515 #endif
2516
2517 status = (*info->read_memory_func) (memaddr, buffer, INSNLEN, info);
2518 if (status == 0)
2519 {
2520 int insn;
2521
2522 if (endianness == BFD_ENDIAN_BIG)
2523 insn = bfd_getb32 (buffer);
2524 else
2525 insn = bfd_getl32 (buffer);
2526
2527 return print_insn_mips (memaddr, insn, info);
2528 }
2529 else
2530 {
2531 (*info->memory_error_func) (status, memaddr, info);
2532 return -1;
2533 }
2534 }
2535
2536 int
2537 print_insn_big_mips (bfd_vma memaddr, struct disassemble_info *info)
2538 {
2539 return _print_insn_mips (memaddr, info, BFD_ENDIAN_BIG);
2540 }
2541
2542 int
2543 print_insn_little_mips (bfd_vma memaddr, struct disassemble_info *info)
2544 {
2545 return _print_insn_mips (memaddr, info, BFD_ENDIAN_LITTLE);
2546 }
2547 \f
2548 void
2549 print_mips_disassembler_options (FILE *stream)
2550 {
2551 unsigned int i;
2552
2553 fprintf (stream, _("\n\
2554 The following MIPS specific disassembler options are supported for use\n\
2555 with the -M switch (multiple options should be separated by commas):\n"));
2556
2557 fprintf (stream, _("\n\
2558 no-aliases Use canonical instruction forms.\n"));
2559
2560 fprintf (stream, _("\n\
2561 msa Recognize MSA instructions.\n"));
2562
2563 fprintf (stream, _("\n\
2564 virt Recognize the virtualization ASE instructions.\n"));
2565
2566 fprintf (stream, _("\n\
2567 xpa Recognize the eXtended Physical Address (XPA)\n\
2568 ASE instructions.\n"));
2569
2570 fprintf (stream, _("\n\
2571 gpr-names=ABI Print GPR names according to specified ABI.\n\
2572 Default: based on binary being disassembled.\n"));
2573
2574 fprintf (stream, _("\n\
2575 fpr-names=ABI Print FPR names according to specified ABI.\n\
2576 Default: numeric.\n"));
2577
2578 fprintf (stream, _("\n\
2579 cp0-names=ARCH Print CP0 register names according to\n\
2580 specified architecture.\n\
2581 Default: based on binary being disassembled.\n"));
2582
2583 fprintf (stream, _("\n\
2584 hwr-names=ARCH Print HWR names according to specified \n\
2585 architecture.\n\
2586 Default: based on binary being disassembled.\n"));
2587
2588 fprintf (stream, _("\n\
2589 reg-names=ABI Print GPR and FPR names according to\n\
2590 specified ABI.\n"));
2591
2592 fprintf (stream, _("\n\
2593 reg-names=ARCH Print CP0 register and HWR names according to\n\
2594 specified architecture.\n"));
2595
2596 fprintf (stream, _("\n\
2597 For the options above, the following values are supported for \"ABI\":\n\
2598 "));
2599 for (i = 0; i < ARRAY_SIZE (mips_abi_choices); i++)
2600 fprintf (stream, " %s", mips_abi_choices[i].name);
2601 fprintf (stream, _("\n"));
2602
2603 fprintf (stream, _("\n\
2604 For the options above, The following values are supported for \"ARCH\":\n\
2605 "));
2606 for (i = 0; i < ARRAY_SIZE (mips_arch_choices); i++)
2607 if (*mips_arch_choices[i].name != '\0')
2608 fprintf (stream, " %s", mips_arch_choices[i].name);
2609 fprintf (stream, _("\n"));
2610
2611 fprintf (stream, _("\n"));
2612 }
A mirror of the official binutils-gdb repository