?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2008-09-08 Tristan Gingold <gingold@adacore.com>
[binutils.git] / opcodes / mips-dis.c
blob744d5a92bcbb6cd5b17ab17ba960428f4d4e9c3c
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 case 'x': /* bbit bit index */
886 (*info->fprintf_func) (info->stream, "0x%lx",
887 (l >> OP_SH_BBITIND) & OP_MASK_BBITIND);
888 break;
889
890 case 'p': /* cins, cins32, exts and exts32 position */
891 (*info->fprintf_func) (info->stream, "0x%lx",
892 (l >> OP_SH_CINSPOS) & OP_MASK_CINSPOS);
893 break;
894
895 case 's': /* cins and exts length-minus-one */
896 (*info->fprintf_func) (info->stream, "0x%lx",
897 (l >> OP_SH_CINSLM1) & OP_MASK_CINSLM1);
898 break;
899
900 case 'S': /* cins32 and exts32 length-minus-one field */
901 (*info->fprintf_func) (info->stream, "0x%lx",
902 (l >> OP_SH_CINSLM1) & OP_MASK_CINSLM1);
903 break;
904
905 case 'Q': /* seqi/snei immediate field */
906 op = (l >> OP_SH_SEQI) & OP_MASK_SEQI;
907 /* Sign-extend it. */
908 op = (op ^ 512) - 512;
909 (*info->fprintf_func) (info->stream, "%d", op);
910 break;
911
912 default:
913 /* xgettext:c-format */
914 (*info->fprintf_func) (info->stream,
915 _("# internal error, undefined extension sequence (+%c)"),
916 *d);
917 return;
918 }
919 break;
920
921 case '2':
922 (*info->fprintf_func) (info->stream, "0x%lx",
923 (l >> OP_SH_BP) & OP_MASK_BP);
924 break;
925
926 case '3':
927 (*info->fprintf_func) (info->stream, "0x%lx",
928 (l >> OP_SH_SA3) & OP_MASK_SA3);
929 break;
930
931 case '4':
932 (*info->fprintf_func) (info->stream, "0x%lx",
933 (l >> OP_SH_SA4) & OP_MASK_SA4);
934 break;
935
936 case '5':
937 (*info->fprintf_func) (info->stream, "0x%lx",
938 (l >> OP_SH_IMM8) & OP_MASK_IMM8);
939 break;
940
941 case '6':
942 (*info->fprintf_func) (info->stream, "0x%lx",
943 (l >> OP_SH_RS) & OP_MASK_RS);
944 break;
945
946 case '7':
947 (*info->fprintf_func) (info->stream, "$ac%ld",
948 (l >> OP_SH_DSPACC) & OP_MASK_DSPACC);
949 break;
950
951 case '8':
952 (*info->fprintf_func) (info->stream, "0x%lx",
953 (l >> OP_SH_WRDSP) & OP_MASK_WRDSP);
954 break;
955
956 case '9':
957 (*info->fprintf_func) (info->stream, "$ac%ld",
958 (l >> OP_SH_DSPACC_S) & OP_MASK_DSPACC_S);
959 break;
960
961 case '0': /* dsp 6-bit signed immediate in bit 20 */
962 delta = ((l >> OP_SH_DSPSFT) & OP_MASK_DSPSFT);
963 if (delta & 0x20) /* test sign bit */
964 delta |= ~OP_MASK_DSPSFT;
965 (*info->fprintf_func) (info->stream, "%d", delta);
966 break;
967
968 case ':': /* dsp 7-bit signed immediate in bit 19 */
969 delta = ((l >> OP_SH_DSPSFT_7) & OP_MASK_DSPSFT_7);
970 if (delta & 0x40) /* test sign bit */
971 delta |= ~OP_MASK_DSPSFT_7;
972 (*info->fprintf_func) (info->stream, "%d", delta);
973 break;
974
975 case '\'':
976 (*info->fprintf_func) (info->stream, "0x%lx",
977 (l >> OP_SH_RDDSP) & OP_MASK_RDDSP);
978 break;
979
980 case '@': /* dsp 10-bit signed immediate in bit 16 */
981 delta = ((l >> OP_SH_IMM10) & OP_MASK_IMM10);
982 if (delta & 0x200) /* test sign bit */
983 delta |= ~OP_MASK_IMM10;
984 (*info->fprintf_func) (info->stream, "%d", delta);
985 break;
986
987 case '!':
988 (*info->fprintf_func) (info->stream, "%ld",
989 (l >> OP_SH_MT_U) & OP_MASK_MT_U);
990 break;
991
992 case '$':
993 (*info->fprintf_func) (info->stream, "%ld",
994 (l >> OP_SH_MT_H) & OP_MASK_MT_H);
995 break;
996
997 case '*':
998 (*info->fprintf_func) (info->stream, "$ac%ld",
999 (l >> OP_SH_MTACC_T) & OP_MASK_MTACC_T);
1000 break;
1001
1002 case '&':
1003 (*info->fprintf_func) (info->stream, "$ac%ld",
1004 (l >> OP_SH_MTACC_D) & OP_MASK_MTACC_D);
1005 break;
1006
1007 case 'g':
1008 /* Coprocessor register for CTTC1, MTTC2, MTHC2, CTTC2. */
1009 (*info->fprintf_func) (info->stream, "$%ld",
1010 (l >> OP_SH_RD) & OP_MASK_RD);
1011 break;
1012
1013 case 's':
1014 case 'b':
1015 case 'r':
1016 case 'v':
1017 (*info->fprintf_func) (info->stream, "%s",
1018 mips_gpr_names[(l >> OP_SH_RS) & OP_MASK_RS]);
1019 break;
1020
1021 case 't':
1022 case 'w':
1023 (*info->fprintf_func) (info->stream, "%s",
1024 mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1025 break;
1026
1027 case 'i':
1028 case 'u':
1029 (*info->fprintf_func) (info->stream, "0x%lx",
1030 (l >> OP_SH_IMMEDIATE) & OP_MASK_IMMEDIATE);
1031 break;
1032
1033 case 'j': /* Same as i, but sign-extended. */
1034 case 'o':
1035 delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
1036 if (delta & 0x8000)
1037 delta |= ~0xffff;
1038 (*info->fprintf_func) (info->stream, "%d",
1039 delta);
1040 break;
1041
1042 case 'h':
1043 (*info->fprintf_func) (info->stream, "0x%x",
1044 (unsigned int) ((l >> OP_SH_PREFX)
1045 & OP_MASK_PREFX));
1046 break;
1047
1048 case 'k':
1049 (*info->fprintf_func) (info->stream, "0x%x",
1050 (unsigned int) ((l >> OP_SH_CACHE)
1051 & OP_MASK_CACHE));
1052 break;
1053
1054 case 'a':
1055 info->target = (((pc + 4) & ~(bfd_vma) 0x0fffffff)
1056 | (((l >> OP_SH_TARGET) & OP_MASK_TARGET) << 2));
1057 /* For gdb disassembler, force odd address on jalx. */
1058 if (info->flavour == bfd_target_unknown_flavour
1059 && strcmp (opp->name, "jalx") == 0)
1060 info->target |= 1;
1061 (*info->print_address_func) (info->target, info);
1062 break;
1063
1064 case 'p':
1065 /* Sign extend the displacement. */
1066 delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
1067 if (delta & 0x8000)
1068 delta |= ~0xffff;
1069 info->target = (delta << 2) + pc + INSNLEN;
1070 (*info->print_address_func) (info->target, info);
1071 break;
1072
1073 case 'd':
1074 (*info->fprintf_func) (info->stream, "%s",
1075 mips_gpr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1076 break;
1077
1078 case 'U':
1079 {
1080 /* First check for both rd and rt being equal. */
1081 unsigned int reg = (l >> OP_SH_RD) & OP_MASK_RD;
1082 if (reg == ((l >> OP_SH_RT) & OP_MASK_RT))
1083 (*info->fprintf_func) (info->stream, "%s",
1084 mips_gpr_names[reg]);
1085 else
1086 {
1087 /* If one is zero use the other. */
1088 if (reg == 0)
1089 (*info->fprintf_func) (info->stream, "%s",
1090 mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1091 else if (((l >> OP_SH_RT) & OP_MASK_RT) == 0)
1092 (*info->fprintf_func) (info->stream, "%s",
1093 mips_gpr_names[reg]);
1094 else /* Bogus, result depends on processor. */
1095 (*info->fprintf_func) (info->stream, "%s or %s",
1096 mips_gpr_names[reg],
1097 mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1098 }
1099 }
1100 break;
1101
1102 case 'z':
1103 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1104 break;
1105
1106 case '<':
1107 (*info->fprintf_func) (info->stream, "0x%lx",
1108 (l >> OP_SH_SHAMT) & OP_MASK_SHAMT);
1109 break;
1110
1111 case 'c':
1112 (*info->fprintf_func) (info->stream, "0x%lx",
1113 (l >> OP_SH_CODE) & OP_MASK_CODE);
1114 break;
1115
1116 case 'q':
1117 (*info->fprintf_func) (info->stream, "0x%lx",
1118 (l >> OP_SH_CODE2) & OP_MASK_CODE2);
1119 break;
1120
1121 case 'C':
1122 (*info->fprintf_func) (info->stream, "0x%lx",
1123 (l >> OP_SH_COPZ) & OP_MASK_COPZ);
1124 break;
1125
1126 case 'B':
1127 (*info->fprintf_func) (info->stream, "0x%lx",
1128
1129 (l >> OP_SH_CODE20) & OP_MASK_CODE20);
1130 break;
1131
1132 case 'J':
1133 (*info->fprintf_func) (info->stream, "0x%lx",
1134 (l >> OP_SH_CODE19) & OP_MASK_CODE19);
1135 break;
1136
1137 case 'S':
1138 case 'V':
1139 (*info->fprintf_func) (info->stream, "%s",
1140 mips_fpr_names[(l >> OP_SH_FS) & OP_MASK_FS]);
1141 break;
1142
1143 case 'T':
1144 case 'W':
1145 (*info->fprintf_func) (info->stream, "%s",
1146 mips_fpr_names[(l >> OP_SH_FT) & OP_MASK_FT]);
1147 break;
1148
1149 case 'D':
1150 (*info->fprintf_func) (info->stream, "%s",
1151 mips_fpr_names[(l >> OP_SH_FD) & OP_MASK_FD]);
1152 break;
1153
1154 case 'R':
1155 (*info->fprintf_func) (info->stream, "%s",
1156 mips_fpr_names[(l >> OP_SH_FR) & OP_MASK_FR]);
1157 break;
1158
1159 case 'E':
1160 /* Coprocessor register for lwcN instructions, et al.
1161
1162 Note that there is no load/store cp0 instructions, and
1163 that FPU (cp1) instructions disassemble this field using
1164 'T' format. Therefore, until we gain understanding of
1165 cp2 register names, we can simply print the register
1166 numbers. */
1167 (*info->fprintf_func) (info->stream, "$%ld",
1168 (l >> OP_SH_RT) & OP_MASK_RT);
1169 break;
1170
1171 case 'G':
1172 /* Coprocessor register for mtcN instructions, et al. Note
1173 that FPU (cp1) instructions disassemble this field using
1174 'S' format. Therefore, we only need to worry about cp0,
1175 cp2, and cp3. */
1176 op = (l >> OP_SH_OP) & OP_MASK_OP;
1177 if (op == OP_OP_COP0)
1178 (*info->fprintf_func) (info->stream, "%s",
1179 mips_cp0_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1180 else
1181 (*info->fprintf_func) (info->stream, "$%ld",
1182 (l >> OP_SH_RD) & OP_MASK_RD);
1183 break;
1184
1185 case 'K':
1186 (*info->fprintf_func) (info->stream, "%s",
1187 mips_hwr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1188 break;
1189
1190 case 'N':
1191 (*info->fprintf_func) (info->stream,
1192 ((opp->pinfo & (FP_D | FP_S)) != 0
1193 ? "$fcc%ld" : "$cc%ld"),
1194 (l >> OP_SH_BCC) & OP_MASK_BCC);
1195 break;
1196
1197 case 'M':
1198 (*info->fprintf_func) (info->stream, "$fcc%ld",
1199 (l >> OP_SH_CCC) & OP_MASK_CCC);
1200 break;
1201
1202 case 'P':
1203 (*info->fprintf_func) (info->stream, "%ld",
1204 (l >> OP_SH_PERFREG) & OP_MASK_PERFREG);
1205 break;
1206
1207 case 'e':
1208 (*info->fprintf_func) (info->stream, "%ld",
1209 (l >> OP_SH_VECBYTE) & OP_MASK_VECBYTE);
1210 break;
1211
1212 case '%':
1213 (*info->fprintf_func) (info->stream, "%ld",
1214 (l >> OP_SH_VECALIGN) & OP_MASK_VECALIGN);
1215 break;
1216
1217 case 'H':
1218 (*info->fprintf_func) (info->stream, "%ld",
1219 (l >> OP_SH_SEL) & OP_MASK_SEL);
1220 break;
1221
1222 case 'O':
1223 (*info->fprintf_func) (info->stream, "%ld",
1224 (l >> OP_SH_ALN) & OP_MASK_ALN);
1225 break;
1226
1227 case 'Q':
1228 {
1229 unsigned int vsel = (l >> OP_SH_VSEL) & OP_MASK_VSEL;
1230
1231 if ((vsel & 0x10) == 0)
1232 {
1233 int fmt;
1234
1235 vsel &= 0x0f;
1236 for (fmt = 0; fmt < 3; fmt++, vsel >>= 1)
1237 if ((vsel & 1) == 0)
1238 break;
1239 (*info->fprintf_func) (info->stream, "$v%ld[%d]",
1240 (l >> OP_SH_FT) & OP_MASK_FT,
1241 vsel >> 1);
1242 }
1243 else if ((vsel & 0x08) == 0)
1244 {
1245 (*info->fprintf_func) (info->stream, "$v%ld",
1246 (l >> OP_SH_FT) & OP_MASK_FT);
1247 }
1248 else
1249 {
1250 (*info->fprintf_func) (info->stream, "0x%lx",
1251 (l >> OP_SH_FT) & OP_MASK_FT);
1252 }
1253 }
1254 break;
1255
1256 case 'X':
1257 (*info->fprintf_func) (info->stream, "$v%ld",
1258 (l >> OP_SH_FD) & OP_MASK_FD);
1259 break;
1260
1261 case 'Y':
1262 (*info->fprintf_func) (info->stream, "$v%ld",
1263 (l >> OP_SH_FS) & OP_MASK_FS);
1264 break;
1265
1266 case 'Z':
1267 (*info->fprintf_func) (info->stream, "$v%ld",
1268 (l >> OP_SH_FT) & OP_MASK_FT);
1269 break;
1270
1271 default:
1272 /* xgettext:c-format */
1273 (*info->fprintf_func) (info->stream,
1274 _("# internal error, undefined modifier (%c)"),
1275 *d);
1276 return;
1277 }
1278 }
1279 }
1280 \f
1281 /* Print the mips instruction at address MEMADDR in debugged memory,
1282 on using INFO. Returns length of the instruction, in bytes, which is
1283 always INSNLEN. BIGENDIAN must be 1 if this is big-endian code, 0 if
1284 this is little-endian code. */
1285
1286 static int
1287 print_insn_mips (bfd_vma memaddr,
1288 unsigned long int word,
1289 struct disassemble_info *info)
1290 {
1291 const struct mips_opcode *op;
1292 static bfd_boolean init = 0;
1293 static const struct mips_opcode *mips_hash[OP_MASK_OP + 1];
1294
1295 /* Build a hash table to shorten the search time. */
1296 if (! init)
1297 {
1298 unsigned int i;
1299
1300 for (i = 0; i <= OP_MASK_OP; i++)
1301 {
1302 for (op = mips_opcodes; op < &mips_opcodes[NUMOPCODES]; op++)
1303 {
1304 if (op->pinfo == INSN_MACRO
1305 || (no_aliases && (op->pinfo2 & INSN2_ALIAS)))
1306 continue;
1307 if (i == ((op->match >> OP_SH_OP) & OP_MASK_OP))
1308 {
1309 mips_hash[i] = op;
1310 break;
1311 }
1312 }
1313 }
1314
1315 init = 1;
1316 }
1317
1318 info->bytes_per_chunk = INSNLEN;
1319 info->display_endian = info->endian;
1320 info->insn_info_valid = 1;
1321 info->branch_delay_insns = 0;
1322 info->data_size = 0;
1323 info->insn_type = dis_nonbranch;
1324 info->target = 0;
1325 info->target2 = 0;
1326
1327 op = mips_hash[(word >> OP_SH_OP) & OP_MASK_OP];
1328 if (op != NULL)
1329 {
1330 for (; op < &mips_opcodes[NUMOPCODES]; op++)
1331 {
1332 if (op->pinfo != INSN_MACRO
1333 && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
1334 && (word & op->mask) == op->match)
1335 {
1336 const char *d;
1337
1338 /* We always allow to disassemble the jalx instruction. */
1339 if (! OPCODE_IS_MEMBER (op, mips_isa, mips_processor)
1340 && strcmp (op->name, "jalx"))
1341 continue;
1342
1343 /* Figure out instruction type and branch delay information. */
1344 if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
1345 {
1346 if ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1347 info->insn_type = dis_jsr;
1348 else
1349 info->insn_type = dis_branch;
1350 info->branch_delay_insns = 1;
1351 }
1352 else if ((op->pinfo & (INSN_COND_BRANCH_DELAY
1353 | INSN_COND_BRANCH_LIKELY)) != 0)
1354 {
1355 if ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1356 info->insn_type = dis_condjsr;
1357 else
1358 info->insn_type = dis_condbranch;
1359 info->branch_delay_insns = 1;
1360 }
1361 else if ((op->pinfo & (INSN_STORE_MEMORY
1362 | INSN_LOAD_MEMORY_DELAY)) != 0)
1363 info->insn_type = dis_dref;
1364
1365 (*info->fprintf_func) (info->stream, "%s", op->name);
1366
1367 d = op->args;
1368 if (d != NULL && *d != '\0')
1369 {
1370 (*info->fprintf_func) (info->stream, "\t");
1371 print_insn_args (d, word, memaddr, info, op);
1372 }
1373
1374 return INSNLEN;
1375 }
1376 }
1377 }
1378
1379 /* Handle undefined instructions. */
1380 info->insn_type = dis_noninsn;
1381 (*info->fprintf_func) (info->stream, "0x%lx", word);
1382 return INSNLEN;
1383 }
1384 \f
1385 /* Disassemble an operand for a mips16 instruction. */
1386
1387 static void
1388 print_mips16_insn_arg (char type,
1389 const struct mips_opcode *op,
1390 int l,
1391 bfd_boolean use_extend,
1392 int extend,
1393 bfd_vma memaddr,
1394 struct disassemble_info *info)
1395 {
1396 switch (type)
1397 {
1398 case ',':
1399 case '(':
1400 case ')':
1401 (*info->fprintf_func) (info->stream, "%c", type);
1402 break;
1403
1404 case 'y':
1405 case 'w':
1406 (*info->fprintf_func) (info->stream, "%s",
1407 mips16_reg_names(((l >> MIPS16OP_SH_RY)
1408 & MIPS16OP_MASK_RY)));
1409 break;
1410
1411 case 'x':
1412 case 'v':
1413 (*info->fprintf_func) (info->stream, "%s",
1414 mips16_reg_names(((l >> MIPS16OP_SH_RX)
1415 & MIPS16OP_MASK_RX)));
1416 break;
1417
1418 case 'z':
1419 (*info->fprintf_func) (info->stream, "%s",
1420 mips16_reg_names(((l >> MIPS16OP_SH_RZ)
1421 & MIPS16OP_MASK_RZ)));
1422 break;
1423
1424 case 'Z':
1425 (*info->fprintf_func) (info->stream, "%s",
1426 mips16_reg_names(((l >> MIPS16OP_SH_MOVE32Z)
1427 & MIPS16OP_MASK_MOVE32Z)));
1428 break;
1429
1430 case '0':
1431 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1432 break;
1433
1434 case 'S':
1435 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[29]);
1436 break;
1437
1438 case 'P':
1439 (*info->fprintf_func) (info->stream, "$pc");
1440 break;
1441
1442 case 'R':
1443 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[31]);
1444 break;
1445
1446 case 'X':
1447 (*info->fprintf_func) (info->stream, "%s",
1448 mips_gpr_names[((l >> MIPS16OP_SH_REGR32)
1449 & MIPS16OP_MASK_REGR32)]);
1450 break;
1451
1452 case 'Y':
1453 (*info->fprintf_func) (info->stream, "%s",
1454 mips_gpr_names[MIPS16OP_EXTRACT_REG32R (l)]);
1455 break;
1456
1457 case '<':
1458 case '>':
1459 case '[':
1460 case ']':
1461 case '4':
1462 case '5':
1463 case 'H':
1464 case 'W':
1465 case 'D':
1466 case 'j':
1467 case '6':
1468 case '8':
1469 case 'V':
1470 case 'C':
1471 case 'U':
1472 case 'k':
1473 case 'K':
1474 case 'p':
1475 case 'q':
1476 case 'A':
1477 case 'B':
1478 case 'E':
1479 {
1480 int immed, nbits, shift, signedp, extbits, pcrel, extu, branch;
1481
1482 shift = 0;
1483 signedp = 0;
1484 extbits = 16;
1485 pcrel = 0;
1486 extu = 0;
1487 branch = 0;
1488 switch (type)
1489 {
1490 case '<':
1491 nbits = 3;
1492 immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1493 extbits = 5;
1494 extu = 1;
1495 break;
1496 case '>':
1497 nbits = 3;
1498 immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1499 extbits = 5;
1500 extu = 1;
1501 break;
1502 case '[':
1503 nbits = 3;
1504 immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1505 extbits = 6;
1506 extu = 1;
1507 break;
1508 case ']':
1509 nbits = 3;
1510 immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1511 extbits = 6;
1512 extu = 1;
1513 break;
1514 case '4':
1515 nbits = 4;
1516 immed = (l >> MIPS16OP_SH_IMM4) & MIPS16OP_MASK_IMM4;
1517 signedp = 1;
1518 extbits = 15;
1519 break;
1520 case '5':
1521 nbits = 5;
1522 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1523 info->insn_type = dis_dref;
1524 info->data_size = 1;
1525 break;
1526 case 'H':
1527 nbits = 5;
1528 shift = 1;
1529 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1530 info->insn_type = dis_dref;
1531 info->data_size = 2;
1532 break;
1533 case 'W':
1534 nbits = 5;
1535 shift = 2;
1536 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1537 if ((op->pinfo & MIPS16_INSN_READ_PC) == 0
1538 && (op->pinfo & MIPS16_INSN_READ_SP) == 0)
1539 {
1540 info->insn_type = dis_dref;
1541 info->data_size = 4;
1542 }
1543 break;
1544 case 'D':
1545 nbits = 5;
1546 shift = 3;
1547 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1548 info->insn_type = dis_dref;
1549 info->data_size = 8;
1550 break;
1551 case 'j':
1552 nbits = 5;
1553 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1554 signedp = 1;
1555 break;
1556 case '6':
1557 nbits = 6;
1558 immed = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1559 break;
1560 case '8':
1561 nbits = 8;
1562 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1563 break;
1564 case 'V':
1565 nbits = 8;
1566 shift = 2;
1567 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1568 /* FIXME: This might be lw, or it might be addiu to $sp or
1569 $pc. We assume it's load. */
1570 info->insn_type = dis_dref;
1571 info->data_size = 4;
1572 break;
1573 case 'C':
1574 nbits = 8;
1575 shift = 3;
1576 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1577 info->insn_type = dis_dref;
1578 info->data_size = 8;
1579 break;
1580 case 'U':
1581 nbits = 8;
1582 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1583 extu = 1;
1584 break;
1585 case 'k':
1586 nbits = 8;
1587 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1588 signedp = 1;
1589 break;
1590 case 'K':
1591 nbits = 8;
1592 shift = 3;
1593 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1594 signedp = 1;
1595 break;
1596 case 'p':
1597 nbits = 8;
1598 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1599 signedp = 1;
1600 pcrel = 1;
1601 branch = 1;
1602 info->insn_type = dis_condbranch;
1603 break;
1604 case 'q':
1605 nbits = 11;
1606 immed = (l >> MIPS16OP_SH_IMM11) & MIPS16OP_MASK_IMM11;
1607 signedp = 1;
1608 pcrel = 1;
1609 branch = 1;
1610 info->insn_type = dis_branch;
1611 break;
1612 case 'A':
1613 nbits = 8;
1614 shift = 2;
1615 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1616 pcrel = 1;
1617 /* FIXME: This can be lw or la. We assume it is lw. */
1618 info->insn_type = dis_dref;
1619 info->data_size = 4;
1620 break;
1621 case 'B':
1622 nbits = 5;
1623 shift = 3;
1624 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1625 pcrel = 1;
1626 info->insn_type = dis_dref;
1627 info->data_size = 8;
1628 break;
1629 case 'E':
1630 nbits = 5;
1631 shift = 2;
1632 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1633 pcrel = 1;
1634 break;
1635 default:
1636 abort ();
1637 }
1638
1639 if (! use_extend)
1640 {
1641 if (signedp && immed >= (1 << (nbits - 1)))
1642 immed -= 1 << nbits;
1643 immed <<= shift;
1644 if ((type == '<' || type == '>' || type == '[' || type == ']')
1645 && immed == 0)
1646 immed = 8;
1647 }
1648 else
1649 {
1650 if (extbits == 16)
1651 immed |= ((extend & 0x1f) << 11) | (extend & 0x7e0);
1652 else if (extbits == 15)
1653 immed |= ((extend & 0xf) << 11) | (extend & 0x7f0);
1654 else
1655 immed = ((extend >> 6) & 0x1f) | (extend & 0x20);
1656 immed &= (1 << extbits) - 1;
1657 if (! extu && immed >= (1 << (extbits - 1)))
1658 immed -= 1 << extbits;
1659 }
1660
1661 if (! pcrel)
1662 (*info->fprintf_func) (info->stream, "%d", immed);
1663 else
1664 {
1665 bfd_vma baseaddr;
1666
1667 if (branch)
1668 {
1669 immed *= 2;
1670 baseaddr = memaddr + 2;
1671 }
1672 else if (use_extend)
1673 baseaddr = memaddr - 2;
1674 else
1675 {
1676 int status;
1677 bfd_byte buffer[2];
1678
1679 baseaddr = memaddr;
1680
1681 /* If this instruction is in the delay slot of a jr
1682 instruction, the base address is the address of the
1683 jr instruction. If it is in the delay slot of jalr
1684 instruction, the base address is the address of the
1685 jalr instruction. This test is unreliable: we have
1686 no way of knowing whether the previous word is
1687 instruction or data. */
1688 status = (*info->read_memory_func) (memaddr - 4, buffer, 2,
1689 info);
1690 if (status == 0
1691 && (((info->endian == BFD_ENDIAN_BIG
1692 ? bfd_getb16 (buffer)
1693 : bfd_getl16 (buffer))
1694 & 0xf800) == 0x1800))
1695 baseaddr = memaddr - 4;
1696 else
1697 {
1698 status = (*info->read_memory_func) (memaddr - 2, buffer,
1699 2, info);
1700 if (status == 0
1701 && (((info->endian == BFD_ENDIAN_BIG
1702 ? bfd_getb16 (buffer)
1703 : bfd_getl16 (buffer))
1704 & 0xf81f) == 0xe800))
1705 baseaddr = memaddr - 2;
1706 }
1707 }
1708 info->target = (baseaddr & ~((1 << shift) - 1)) + immed;
1709 if (pcrel && branch
1710 && info->flavour == bfd_target_unknown_flavour)
1711 /* For gdb disassembler, maintain odd address. */
1712 info->target |= 1;
1713 (*info->print_address_func) (info->target, info);
1714 }
1715 }
1716 break;
1717
1718 case 'a':
1719 {
1720 int jalx = l & 0x400;
1721
1722 if (! use_extend)
1723 extend = 0;
1724 l = ((l & 0x1f) << 23) | ((l & 0x3e0) << 13) | (extend << 2);
1725 if (!jalx && info->flavour == bfd_target_unknown_flavour)
1726 /* For gdb disassembler, maintain odd address. */
1727 l |= 1;
1728 }
1729 info->target = ((memaddr + 4) & ~(bfd_vma) 0x0fffffff) | l;
1730 (*info->print_address_func) (info->target, info);
1731 info->insn_type = dis_jsr;
1732 info->branch_delay_insns = 1;
1733 break;
1734
1735 case 'l':
1736 case 'L':
1737 {
1738 int need_comma, amask, smask;
1739
1740 need_comma = 0;
1741
1742 l = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1743
1744 amask = (l >> 3) & 7;
1745
1746 if (amask > 0 && amask < 5)
1747 {
1748 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1749 if (amask > 1)
1750 (*info->fprintf_func) (info->stream, "-%s",
1751 mips_gpr_names[amask + 3]);
1752 need_comma = 1;
1753 }
1754
1755 smask = (l >> 1) & 3;
1756 if (smask == 3)
1757 {
1758 (*info->fprintf_func) (info->stream, "%s??",
1759 need_comma ? "," : "");
1760 need_comma = 1;
1761 }
1762 else if (smask > 0)
1763 {
1764 (*info->fprintf_func) (info->stream, "%s%s",
1765 need_comma ? "," : "",
1766 mips_gpr_names[16]);
1767 if (smask > 1)
1768 (*info->fprintf_func) (info->stream, "-%s",
1769 mips_gpr_names[smask + 15]);
1770 need_comma = 1;
1771 }
1772
1773 if (l & 1)
1774 {
1775 (*info->fprintf_func) (info->stream, "%s%s",
1776 need_comma ? "," : "",
1777 mips_gpr_names[31]);
1778 need_comma = 1;
1779 }
1780
1781 if (amask == 5 || amask == 6)
1782 {
1783 (*info->fprintf_func) (info->stream, "%s$f0",
1784 need_comma ? "," : "");
1785 if (amask == 6)
1786 (*info->fprintf_func) (info->stream, "-$f1");
1787 }
1788 }
1789 break;
1790
1791 case 'm':
1792 case 'M':
1793 /* MIPS16e save/restore. */
1794 {
1795 int need_comma = 0;
1796 int amask, args, statics;
1797 int nsreg, smask;
1798 int framesz;
1799 int i, j;
1800
1801 l = l & 0x7f;
1802 if (use_extend)
1803 l |= extend << 16;
1804
1805 amask = (l >> 16) & 0xf;
1806 if (amask == MIPS16_ALL_ARGS)
1807 {
1808 args = 4;
1809 statics = 0;
1810 }
1811 else if (amask == MIPS16_ALL_STATICS)
1812 {
1813 args = 0;
1814 statics = 4;
1815 }
1816 else
1817 {
1818 args = amask >> 2;
1819 statics = amask & 3;
1820 }
1821
1822 if (args > 0) {
1823 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1824 if (args > 1)
1825 (*info->fprintf_func) (info->stream, "-%s",
1826 mips_gpr_names[4 + args - 1]);
1827 need_comma = 1;
1828 }
1829
1830 framesz = (((l >> 16) & 0xf0) | (l & 0x0f)) * 8;
1831 if (framesz == 0 && !use_extend)
1832 framesz = 128;
1833
1834 (*info->fprintf_func) (info->stream, "%s%d",
1835 need_comma ? "," : "",
1836 framesz);
1837
1838 if (l & 0x40) /* $ra */
1839 (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[31]);
1840
1841 nsreg = (l >> 24) & 0x7;
1842 smask = 0;
1843 if (l & 0x20) /* $s0 */
1844 smask |= 1 << 0;
1845 if (l & 0x10) /* $s1 */
1846 smask |= 1 << 1;
1847 if (nsreg > 0) /* $s2-$s8 */
1848 smask |= ((1 << nsreg) - 1) << 2;
1849
1850 /* Find first set static reg bit. */
1851 for (i = 0; i < 9; i++)
1852 {
1853 if (smask & (1 << i))
1854 {
1855 (*info->fprintf_func) (info->stream, ",%s",
1856 mips_gpr_names[i == 8 ? 30 : (16 + i)]);
1857 /* Skip over string of set bits. */
1858 for (j = i; smask & (2 << j); j++)
1859 continue;
1860 if (j > i)
1861 (*info->fprintf_func) (info->stream, "-%s",
1862 mips_gpr_names[j == 8 ? 30 : (16 + j)]);
1863 i = j + 1;
1864 }
1865 }
1866
1867 /* Statics $ax - $a3. */
1868 if (statics == 1)
1869 (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[7]);
1870 else if (statics > 0)
1871 (*info->fprintf_func) (info->stream, ",%s-%s",
1872 mips_gpr_names[7 - statics + 1],
1873 mips_gpr_names[7]);
1874 }
1875 break;
1876
1877 default:
1878 /* xgettext:c-format */
1879 (*info->fprintf_func)
1880 (info->stream,
1881 _("# internal disassembler error, unrecognised modifier (%c)"),
1882 type);
1883 abort ();
1884 }
1885 }
1886
1887 /* Disassemble mips16 instructions. */
1888
1889 static int
1890 print_insn_mips16 (bfd_vma memaddr, struct disassemble_info *info)
1891 {
1892 int status;
1893 bfd_byte buffer[2];
1894 int length;
1895 int insn;
1896 bfd_boolean use_extend;
1897 int extend = 0;
1898 const struct mips_opcode *op, *opend;
1899
1900 info->bytes_per_chunk = 2;
1901 info->display_endian = info->endian;
1902 info->insn_info_valid = 1;
1903 info->branch_delay_insns = 0;
1904 info->data_size = 0;
1905 info->insn_type = dis_nonbranch;
1906 info->target = 0;
1907 info->target2 = 0;
1908
1909 status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1910 if (status != 0)
1911 {
1912 (*info->memory_error_func) (status, memaddr, info);
1913 return -1;
1914 }
1915
1916 length = 2;
1917
1918 if (info->endian == BFD_ENDIAN_BIG)
1919 insn = bfd_getb16 (buffer);
1920 else
1921 insn = bfd_getl16 (buffer);
1922
1923 /* Handle the extend opcode specially. */
1924 use_extend = FALSE;
1925 if ((insn & 0xf800) == 0xf000)
1926 {
1927 use_extend = TRUE;
1928 extend = insn & 0x7ff;
1929
1930 memaddr += 2;
1931
1932 status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1933 if (status != 0)
1934 {
1935 (*info->fprintf_func) (info->stream, "extend 0x%x",
1936 (unsigned int) extend);
1937 (*info->memory_error_func) (status, memaddr, info);
1938 return -1;
1939 }
1940
1941 if (info->endian == BFD_ENDIAN_BIG)
1942 insn = bfd_getb16 (buffer);
1943 else
1944 insn = bfd_getl16 (buffer);
1945
1946 /* Check for an extend opcode followed by an extend opcode. */
1947 if ((insn & 0xf800) == 0xf000)
1948 {
1949 (*info->fprintf_func) (info->stream, "extend 0x%x",
1950 (unsigned int) extend);
1951 info->insn_type = dis_noninsn;
1952 return length;
1953 }
1954
1955 length += 2;
1956 }
1957
1958 /* FIXME: Should probably use a hash table on the major opcode here. */
1959
1960 opend = mips16_opcodes + bfd_mips16_num_opcodes;
1961 for (op = mips16_opcodes; op < opend; op++)
1962 {
1963 if (op->pinfo != INSN_MACRO
1964 && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
1965 && (insn & op->mask) == op->match)
1966 {
1967 const char *s;
1968
1969 if (strchr (op->args, 'a') != NULL)
1970 {
1971 if (use_extend)
1972 {
1973 (*info->fprintf_func) (info->stream, "extend 0x%x",
1974 (unsigned int) extend);
1975 info->insn_type = dis_noninsn;
1976 return length - 2;
1977 }
1978
1979 use_extend = FALSE;
1980
1981 memaddr += 2;
1982
1983 status = (*info->read_memory_func) (memaddr, buffer, 2,
1984 info);
1985 if (status == 0)
1986 {
1987 use_extend = TRUE;
1988 if (info->endian == BFD_ENDIAN_BIG)
1989 extend = bfd_getb16 (buffer);
1990 else
1991 extend = bfd_getl16 (buffer);
1992 length += 2;
1993 }
1994 }
1995
1996 (*info->fprintf_func) (info->stream, "%s", op->name);
1997 if (op->args[0] != '\0')
1998 (*info->fprintf_func) (info->stream, "\t");
1999
2000 for (s = op->args; *s != '\0'; s++)
2001 {
2002 if (*s == ','
2003 && s[1] == 'w'
2004 && (((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)
2005 == ((insn >> MIPS16OP_SH_RY) & MIPS16OP_MASK_RY)))
2006 {
2007 /* Skip the register and the comma. */
2008 ++s;
2009 continue;
2010 }
2011 if (*s == ','
2012 && s[1] == 'v'
2013 && (((insn >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ)
2014 == ((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)))
2015 {
2016 /* Skip the register and the comma. */
2017 ++s;
2018 continue;
2019 }
2020 print_mips16_insn_arg (*s, op, insn, use_extend, extend, memaddr,
2021 info);
2022 }
2023
2024 if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
2025 {
2026 info->branch_delay_insns = 1;
2027 if (info->insn_type != dis_jsr)
2028 info->insn_type = dis_branch;
2029 }
2030
2031 return length;
2032 }
2033 }
2034
2035 if (use_extend)
2036 (*info->fprintf_func) (info->stream, "0x%x", extend | 0xf000);
2037 (*info->fprintf_func) (info->stream, "0x%x", insn);
2038 info->insn_type = dis_noninsn;
2039
2040 return length;
2041 }
2042
2043 /* In an environment where we do not know the symbol type of the
2044 instruction we are forced to assume that the low order bit of the
2045 instructions' address may mark it as a mips16 instruction. If we
2046 are single stepping, or the pc is within the disassembled function,
2047 this works. Otherwise, we need a clue. Sometimes. */
2048
2049 static int
2050 _print_insn_mips (bfd_vma memaddr,
2051 struct disassemble_info *info,
2052 enum bfd_endian endianness)
2053 {
2054 bfd_byte buffer[INSNLEN];
2055 int status;
2056
2057 set_default_mips_dis_options (info);
2058 parse_mips_dis_options (info->disassembler_options);
2059
2060 #if 1
2061 /* FIXME: If odd address, this is CLEARLY a mips 16 instruction. */
2062 /* Only a few tools will work this way. */
2063 if (memaddr & 0x01)
2064 return print_insn_mips16 (memaddr, info);
2065 #endif
2066
2067 #if SYMTAB_AVAILABLE
2068 if (info->mach == bfd_mach_mips16
2069 || (info->symbols != NULL
2070 && bfd_asymbol_flavour (*info->symbols) == bfd_target_elf_flavour
2071 && ELF_ST_IS_MIPS16 ((*(elf_symbol_type **) info->symbols)
2072 ->internal_elf_sym.st_other)))
2073 return print_insn_mips16 (memaddr, info);
2074 #endif
2075
2076 status = (*info->read_memory_func) (memaddr, buffer, INSNLEN, info);
2077 if (status == 0)
2078 {
2079 unsigned long insn;
2080
2081 if (endianness == BFD_ENDIAN_BIG)
2082 insn = (unsigned long) bfd_getb32 (buffer);
2083 else
2084 insn = (unsigned long) bfd_getl32 (buffer);
2085
2086 return print_insn_mips (memaddr, insn, info);
2087 }
2088 else
2089 {
2090 (*info->memory_error_func) (status, memaddr, info);
2091 return -1;
2092 }
2093 }
2094
2095 int
2096 print_insn_big_mips (bfd_vma memaddr, struct disassemble_info *info)
2097 {
2098 return _print_insn_mips (memaddr, info, BFD_ENDIAN_BIG);
2099 }
2100
2101 int
2102 print_insn_little_mips (bfd_vma memaddr, struct disassemble_info *info)
2103 {
2104 return _print_insn_mips (memaddr, info, BFD_ENDIAN_LITTLE);
2105 }
2106 \f
2107 void
2108 print_mips_disassembler_options (FILE *stream)
2109 {
2110 unsigned int i;
2111
2112 fprintf (stream, _("\n\
2113 The following MIPS specific disassembler options are supported for use\n\
2114 with the -M switch (multiple options should be separated by commas):\n"));
2115
2116 fprintf (stream, _("\n\
2117 gpr-names=ABI Print GPR names according to specified ABI.\n\
2118 Default: based on binary being disassembled.\n"));
2119
2120 fprintf (stream, _("\n\
2121 fpr-names=ABI Print FPR names according to specified ABI.\n\
2122 Default: numeric.\n"));
2123
2124 fprintf (stream, _("\n\
2125 cp0-names=ARCH Print CP0 register names according to\n\
2126 specified architecture.\n\
2127 Default: based on binary being disassembled.\n"));
2128
2129 fprintf (stream, _("\n\
2130 hwr-names=ARCH Print HWR names according to specified \n\
2131 architecture.\n\
2132 Default: based on binary being disassembled.\n"));
2133
2134 fprintf (stream, _("\n\
2135 reg-names=ABI Print GPR and FPR names according to\n\
2136 specified ABI.\n"));
2137
2138 fprintf (stream, _("\n\
2139 reg-names=ARCH Print CP0 register and HWR names according to\n\
2140 specified architecture.\n"));
2141
2142 fprintf (stream, _("\n\
2143 For the options above, the following values are supported for \"ABI\":\n\
2144 "));
2145 for (i = 0; i < ARRAY_SIZE (mips_abi_choices); i++)
2146 fprintf (stream, " %s", mips_abi_choices[i].name);
2147 fprintf (stream, _("\n"));
2148
2149 fprintf (stream, _("\n\
2150 For the options above, The following values are supported for \"ARCH\":\n\
2151 "));
2152 for (i = 0; i < ARRAY_SIZE (mips_arch_choices); i++)
2153 if (*mips_arch_choices[i].name != '\0')
2154 fprintf (stream, " %s", mips_arch_choices[i].name);
2155 fprintf (stream, _("\n"));
2156
2157 fprintf (stream, _("\n"));
2158 }
git-cvsimport of binutils cvsroot