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