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