projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
PR gas/5172
[deliverable/binutils-gdb.git] / opcodes / mips-dis.c
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
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 /* This entry, mips16, is here only for ISA/processor selection; do
454 not print its name. */
455 { "", 1, bfd_mach_mips16, CPU_MIPS16, ISA_MIPS3 | INSN_MIPS16,
456 mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
457 };
458
459 /* ISA and processor type to disassemble for, and register names to use.
460 set_default_mips_dis_options and parse_mips_dis_options fill in these
461 values. */
462 static int mips_processor;
463 static int mips_isa;
464 static const char * const *mips_gpr_names;
465 static const char * const *mips_fpr_names;
466 static const char * const *mips_cp0_names;
467 static const struct mips_cp0sel_name *mips_cp0sel_names;
468 static int mips_cp0sel_names_len;
469 static const char * const *mips_hwr_names;
470
471 /* Other options */
472 static int no_aliases; /* If set disassemble as most general inst. */
473 \f
474 static const struct mips_abi_choice *
475 choose_abi_by_name (const char *name, unsigned int namelen)
476 {
477 const struct mips_abi_choice *c;
478 unsigned int i;
479
480 for (i = 0, c = NULL; i < ARRAY_SIZE (mips_abi_choices) && c == NULL; i++)
481 if (strncmp (mips_abi_choices[i].name, name, namelen) == 0
482 && strlen (mips_abi_choices[i].name) == namelen)
483 c = &mips_abi_choices[i];
484
485 return c;
486 }
487
488 static const struct mips_arch_choice *
489 choose_arch_by_name (const char *name, unsigned int namelen)
490 {
491 const struct mips_arch_choice *c = NULL;
492 unsigned int i;
493
494 for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
495 if (strncmp (mips_arch_choices[i].name, name, namelen) == 0
496 && strlen (mips_arch_choices[i].name) == namelen)
497 c = &mips_arch_choices[i];
498
499 return c;
500 }
501
502 static const struct mips_arch_choice *
503 choose_arch_by_number (unsigned long mach)
504 {
505 static unsigned long hint_bfd_mach;
506 static const struct mips_arch_choice *hint_arch_choice;
507 const struct mips_arch_choice *c;
508 unsigned int i;
509
510 /* We optimize this because even if the user specifies no
511 flags, this will be done for every instruction! */
512 if (hint_bfd_mach == mach
513 && hint_arch_choice != NULL
514 && hint_arch_choice->bfd_mach == hint_bfd_mach)
515 return hint_arch_choice;
516
517 for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
518 {
519 if (mips_arch_choices[i].bfd_mach_valid
520 && mips_arch_choices[i].bfd_mach == mach)
521 {
522 c = &mips_arch_choices[i];
523 hint_bfd_mach = mach;
524 hint_arch_choice = c;
525 }
526 }
527 return c;
528 }
529
530 /* Check if the object uses NewABI conventions. */
531
532 static int
533 is_newabi (Elf_Internal_Ehdr *header)
534 {
535 /* There are no old-style ABIs which use 64-bit ELF. */
536 if (header->e_ident[EI_CLASS] == ELFCLASS64)
537 return 1;
538
539 /* If a 32-bit ELF file, n32 is a new-style ABI. */
540 if ((header->e_flags & EF_MIPS_ABI2) != 0)
541 return 1;
542
543 return 0;
544 }
545
546 static void
547 set_default_mips_dis_options (struct disassemble_info *info)
548 {
549 const struct mips_arch_choice *chosen_arch;
550
551 /* Defaults: mipsIII/r3000 (?!), (o)32-style ("oldabi") GPR names,
552 and numeric FPR, CP0 register, and HWR names. */
553 mips_isa = ISA_MIPS3;
554 mips_processor = CPU_R3000;
555 mips_gpr_names = mips_gpr_names_oldabi;
556 mips_fpr_names = mips_fpr_names_numeric;
557 mips_cp0_names = mips_cp0_names_numeric;
558 mips_cp0sel_names = NULL;
559 mips_cp0sel_names_len = 0;
560 mips_hwr_names = mips_hwr_names_numeric;
561 no_aliases = 0;
562
563 /* If an ELF "newabi" binary, use the n32/(n)64 GPR names. */
564 if (info->flavour == bfd_target_elf_flavour && info->section != NULL)
565 {
566 Elf_Internal_Ehdr *header;
567
568 header = elf_elfheader (info->section->owner);
569 if (is_newabi (header))
570 mips_gpr_names = mips_gpr_names_newabi;
571 }
572
573 /* Set ISA, architecture, and cp0 register names as best we can. */
574 #if ! SYMTAB_AVAILABLE
575 /* This is running out on a target machine, not in a host tool.
576 FIXME: Where does mips_target_info come from? */
577 target_processor = mips_target_info.processor;
578 mips_isa = mips_target_info.isa;
579 #else
580 chosen_arch = choose_arch_by_number (info->mach);
581 if (chosen_arch != NULL)
582 {
583 mips_processor = chosen_arch->processor;
584 mips_isa = chosen_arch->isa;
585 mips_cp0_names = chosen_arch->cp0_names;
586 mips_cp0sel_names = chosen_arch->cp0sel_names;
587 mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
588 mips_hwr_names = chosen_arch->hwr_names;
589 }
590 #endif
591 }
592
593 static void
594 parse_mips_dis_option (const char *option, unsigned int len)
595 {
596 unsigned int i, optionlen, vallen;
597 const char *val;
598 const struct mips_abi_choice *chosen_abi;
599 const struct mips_arch_choice *chosen_arch;
600
601 /* Try to match options that are simple flags */
602 if (CONST_STRNEQ (option, "no-aliases"))
603 {
604 no_aliases = 1;
605 return;
606 }
607
608 /* Look for the = that delimits the end of the option name. */
609 for (i = 0; i < len; i++)
610 if (option[i] == '=')
611 break;
612
613 if (i == 0) /* Invalid option: no name before '='. */
614 return;
615 if (i == len) /* Invalid option: no '='. */
616 return;
617 if (i == (len - 1)) /* Invalid option: no value after '='. */
618 return;
619
620 optionlen = i;
621 val = option + (optionlen + 1);
622 vallen = len - (optionlen + 1);
623
624 if (strncmp ("gpr-names", option, optionlen) == 0
625 && strlen ("gpr-names") == optionlen)
626 {
627 chosen_abi = choose_abi_by_name (val, vallen);
628 if (chosen_abi != NULL)
629 mips_gpr_names = chosen_abi->gpr_names;
630 return;
631 }
632
633 if (strncmp ("fpr-names", option, optionlen) == 0
634 && strlen ("fpr-names") == optionlen)
635 {
636 chosen_abi = choose_abi_by_name (val, vallen);
637 if (chosen_abi != NULL)
638 mips_fpr_names = chosen_abi->fpr_names;
639 return;
640 }
641
642 if (strncmp ("cp0-names", option, optionlen) == 0
643 && strlen ("cp0-names") == optionlen)
644 {
645 chosen_arch = choose_arch_by_name (val, vallen);
646 if (chosen_arch != NULL)
647 {
648 mips_cp0_names = chosen_arch->cp0_names;
649 mips_cp0sel_names = chosen_arch->cp0sel_names;
650 mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
651 }
652 return;
653 }
654
655 if (strncmp ("hwr-names", option, optionlen) == 0
656 && strlen ("hwr-names") == optionlen)
657 {
658 chosen_arch = choose_arch_by_name (val, vallen);
659 if (chosen_arch != NULL)
660 mips_hwr_names = chosen_arch->hwr_names;
661 return;
662 }
663
664 if (strncmp ("reg-names", option, optionlen) == 0
665 && strlen ("reg-names") == optionlen)
666 {
667 /* We check both ABI and ARCH here unconditionally, so
668 that "numeric" will do the desirable thing: select
669 numeric register names for all registers. Other than
670 that, a given name probably won't match both. */
671 chosen_abi = choose_abi_by_name (val, vallen);
672 if (chosen_abi != NULL)
673 {
674 mips_gpr_names = chosen_abi->gpr_names;
675 mips_fpr_names = chosen_abi->fpr_names;
676 }
677 chosen_arch = choose_arch_by_name (val, vallen);
678 if (chosen_arch != NULL)
679 {
680 mips_cp0_names = chosen_arch->cp0_names;
681 mips_cp0sel_names = chosen_arch->cp0sel_names;
682 mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
683 mips_hwr_names = chosen_arch->hwr_names;
684 }
685 return;
686 }
687
688 /* Invalid option. */
689 }
690
691 static void
692 parse_mips_dis_options (const char *options)
693 {
694 const char *option_end;
695
696 if (options == NULL)
697 return;
698
699 while (*options != '\0')
700 {
701 /* Skip empty options. */
702 if (*options == ',')
703 {
704 options++;
705 continue;
706 }
707
708 /* We know that *options is neither NUL or a comma. */
709 option_end = options + 1;
710 while (*option_end != ',' && *option_end != '\0')
711 option_end++;
712
713 parse_mips_dis_option (options, option_end - options);
714
715 /* Go on to the next one. If option_end points to a comma, it
716 will be skipped above. */
717 options = option_end;
718 }
719 }
720
721 static const struct mips_cp0sel_name *
722 lookup_mips_cp0sel_name (const struct mips_cp0sel_name *names,
723 unsigned int len,
724 unsigned int cp0reg,
725 unsigned int sel)
726 {
727 unsigned int i;
728
729 for (i = 0; i < len; i++)
730 if (names[i].cp0reg == cp0reg && names[i].sel == sel)
731 return &names[i];
732 return NULL;
733 }
734 \f
735 /* Print insn arguments for 32/64-bit code. */
736
737 static void
738 print_insn_args (const char *d,
739 register unsigned long int l,
740 bfd_vma pc,
741 struct disassemble_info *info,
742 const struct mips_opcode *opp)
743 {
744 int op, delta;
745 unsigned int lsb, msb, msbd;
746
747 lsb = 0;
748
749 for (; *d != '\0'; d++)
750 {
751 switch (*d)
752 {
753 case ',':
754 case '(':
755 case ')':
756 case '[':
757 case ']':
758 (*info->fprintf_func) (info->stream, "%c", *d);
759 break;
760
761 case '+':
762 /* Extension character; switch for second char. */
763 d++;
764 switch (*d)
765 {
766 case '\0':
767 /* xgettext:c-format */
768 (*info->fprintf_func) (info->stream,
769 _("# internal error, incomplete extension sequence (+)"));
770 return;
771
772 case 'A':
773 lsb = (l >> OP_SH_SHAMT) & OP_MASK_SHAMT;
774 (*info->fprintf_func) (info->stream, "0x%x", lsb);
775 break;
776
777 case 'B':
778 msb = (l >> OP_SH_INSMSB) & OP_MASK_INSMSB;
779 (*info->fprintf_func) (info->stream, "0x%x", msb - lsb + 1);
780 break;
781
782 case '1':
783 (*info->fprintf_func) (info->stream, "0x%lx",
784 (l >> OP_SH_UDI1) & OP_MASK_UDI1);
785 break;
786
787 case '2':
788 (*info->fprintf_func) (info->stream, "0x%lx",
789 (l >> OP_SH_UDI2) & OP_MASK_UDI2);
790 break;
791
792 case '3':
793 (*info->fprintf_func) (info->stream, "0x%lx",
794 (l >> OP_SH_UDI3) & OP_MASK_UDI3);
795 break;
796
797 case '4':
798 (*info->fprintf_func) (info->stream, "0x%lx",
799 (l >> OP_SH_UDI4) & OP_MASK_UDI4);
800 break;
801
802 case 'C':
803 case 'H':
804 msbd = (l >> OP_SH_EXTMSBD) & OP_MASK_EXTMSBD;
805 (*info->fprintf_func) (info->stream, "0x%x", msbd + 1);
806 break;
807
808 case 'D':
809 {
810 const struct mips_cp0sel_name *n;
811 unsigned int cp0reg, sel;
812
813 cp0reg = (l >> OP_SH_RD) & OP_MASK_RD;
814 sel = (l >> OP_SH_SEL) & OP_MASK_SEL;
815
816 /* CP0 register including 'sel' code for mtcN (et al.), to be
817 printed textually if known. If not known, print both
818 CP0 register name and sel numerically since CP0 register
819 with sel 0 may have a name unrelated to register being
820 printed. */
821 n = lookup_mips_cp0sel_name(mips_cp0sel_names,
822 mips_cp0sel_names_len, cp0reg, sel);
823 if (n != NULL)
824 (*info->fprintf_func) (info->stream, "%s", n->name);
825 else
826 (*info->fprintf_func) (info->stream, "$%d,%d", cp0reg, sel);
827 break;
828 }
829
830 case 'E':
831 lsb = ((l >> OP_SH_SHAMT) & OP_MASK_SHAMT) + 32;
832 (*info->fprintf_func) (info->stream, "0x%x", lsb);
833 break;
834
835 case 'F':
836 msb = ((l >> OP_SH_INSMSB) & OP_MASK_INSMSB) + 32;
837 (*info->fprintf_func) (info->stream, "0x%x", msb - lsb + 1);
838 break;
839
840 case 'G':
841 msbd = ((l >> OP_SH_EXTMSBD) & OP_MASK_EXTMSBD) + 32;
842 (*info->fprintf_func) (info->stream, "0x%x", msbd + 1);
843 break;
844
845 case 't': /* Coprocessor 0 reg name */
846 (*info->fprintf_func) (info->stream, "%s",
847 mips_cp0_names[(l >> OP_SH_RT) &
848 OP_MASK_RT]);
849 break;
850
851 case 'T': /* Coprocessor 0 reg name */
852 {
853 const struct mips_cp0sel_name *n;
854 unsigned int cp0reg, sel;
855
856 cp0reg = (l >> OP_SH_RT) & OP_MASK_RT;
857 sel = (l >> OP_SH_SEL) & OP_MASK_SEL;
858
859 /* CP0 register including 'sel' code for mftc0, to be
860 printed textually if known. If not known, print both
861 CP0 register name and sel numerically since CP0 register
862 with sel 0 may have a name unrelated to register being
863 printed. */
864 n = lookup_mips_cp0sel_name(mips_cp0sel_names,
865 mips_cp0sel_names_len, cp0reg, sel);
866 if (n != NULL)
867 (*info->fprintf_func) (info->stream, "%s", n->name);
868 else
869 (*info->fprintf_func) (info->stream, "$%d,%d", cp0reg, sel);
870 break;
871 }
872
873 default:
874 /* xgettext:c-format */
875 (*info->fprintf_func) (info->stream,
876 _("# internal error, undefined extension sequence (+%c)"),
877 *d);
878 return;
879 }
880 break;
881
882 case '2':
883 (*info->fprintf_func) (info->stream, "0x%lx",
884 (l >> OP_SH_BP) & OP_MASK_BP);
885 break;
886
887 case '3':
888 (*info->fprintf_func) (info->stream, "0x%lx",
889 (l >> OP_SH_SA3) & OP_MASK_SA3);
890 break;
891
892 case '4':
893 (*info->fprintf_func) (info->stream, "0x%lx",
894 (l >> OP_SH_SA4) & OP_MASK_SA4);
895 break;
896
897 case '5':
898 (*info->fprintf_func) (info->stream, "0x%lx",
899 (l >> OP_SH_IMM8) & OP_MASK_IMM8);
900 break;
901
902 case '6':
903 (*info->fprintf_func) (info->stream, "0x%lx",
904 (l >> OP_SH_RS) & OP_MASK_RS);
905 break;
906
907 case '7':
908 (*info->fprintf_func) (info->stream, "$ac%ld",
909 (l >> OP_SH_DSPACC) & OP_MASK_DSPACC);
910 break;
911
912 case '8':
913 (*info->fprintf_func) (info->stream, "0x%lx",
914 (l >> OP_SH_WRDSP) & OP_MASK_WRDSP);
915 break;
916
917 case '9':
918 (*info->fprintf_func) (info->stream, "$ac%ld",
919 (l >> OP_SH_DSPACC_S) & OP_MASK_DSPACC_S);
920 break;
921
922 case '0': /* dsp 6-bit signed immediate in bit 20 */
923 delta = ((l >> OP_SH_DSPSFT) & OP_MASK_DSPSFT);
924 if (delta & 0x20) /* test sign bit */
925 delta |= ~OP_MASK_DSPSFT;
926 (*info->fprintf_func) (info->stream, "%d", delta);
927 break;
928
929 case ':': /* dsp 7-bit signed immediate in bit 19 */
930 delta = ((l >> OP_SH_DSPSFT_7) & OP_MASK_DSPSFT_7);
931 if (delta & 0x40) /* test sign bit */
932 delta |= ~OP_MASK_DSPSFT_7;
933 (*info->fprintf_func) (info->stream, "%d", delta);
934 break;
935
936 case '\'':
937 (*info->fprintf_func) (info->stream, "0x%lx",
938 (l >> OP_SH_RDDSP) & OP_MASK_RDDSP);
939 break;
940
941 case '@': /* dsp 10-bit signed immediate in bit 16 */
942 delta = ((l >> OP_SH_IMM10) & OP_MASK_IMM10);
943 if (delta & 0x200) /* test sign bit */
944 delta |= ~OP_MASK_IMM10;
945 (*info->fprintf_func) (info->stream, "%d", delta);
946 break;
947
948 case '!':
949 (*info->fprintf_func) (info->stream, "%ld",
950 (l >> OP_SH_MT_U) & OP_MASK_MT_U);
951 break;
952
953 case '$':
954 (*info->fprintf_func) (info->stream, "%ld",
955 (l >> OP_SH_MT_H) & OP_MASK_MT_H);
956 break;
957
958 case '*':
959 (*info->fprintf_func) (info->stream, "$ac%ld",
960 (l >> OP_SH_MTACC_T) & OP_MASK_MTACC_T);
961 break;
962
963 case '&':
964 (*info->fprintf_func) (info->stream, "$ac%ld",
965 (l >> OP_SH_MTACC_D) & OP_MASK_MTACC_D);
966 break;
967
968 case 'g':
969 /* Coprocessor register for CTTC1, MTTC2, MTHC2, CTTC2. */
970 (*info->fprintf_func) (info->stream, "$%ld",
971 (l >> OP_SH_RD) & OP_MASK_RD);
972 break;
973
974 case 's':
975 case 'b':
976 case 'r':
977 case 'v':
978 (*info->fprintf_func) (info->stream, "%s",
979 mips_gpr_names[(l >> OP_SH_RS) & OP_MASK_RS]);
980 break;
981
982 case 't':
983 case 'w':
984 (*info->fprintf_func) (info->stream, "%s",
985 mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
986 break;
987
988 case 'i':
989 case 'u':
990 (*info->fprintf_func) (info->stream, "0x%lx",
991 (l >> OP_SH_IMMEDIATE) & OP_MASK_IMMEDIATE);
992 break;
993
994 case 'j': /* Same as i, but sign-extended. */
995 case 'o':
996 delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
997 if (delta & 0x8000)
998 delta |= ~0xffff;
999 (*info->fprintf_func) (info->stream, "%d",
1000 delta);
1001 break;
1002
1003 case 'h':
1004 (*info->fprintf_func) (info->stream, "0x%x",
1005 (unsigned int) ((l >> OP_SH_PREFX)
1006 & OP_MASK_PREFX));
1007 break;
1008
1009 case 'k':
1010 (*info->fprintf_func) (info->stream, "0x%x",
1011 (unsigned int) ((l >> OP_SH_CACHE)
1012 & OP_MASK_CACHE));
1013 break;
1014
1015 case 'a':
1016 info->target = (((pc + 4) & ~(bfd_vma) 0x0fffffff)
1017 | (((l >> OP_SH_TARGET) & OP_MASK_TARGET) << 2));
1018 /* For gdb disassembler, force odd address on jalx. */
1019 if (info->flavour == bfd_target_unknown_flavour
1020 && strcmp (opp->name, "jalx") == 0)
1021 info->target |= 1;
1022 (*info->print_address_func) (info->target, info);
1023 break;
1024
1025 case 'p':
1026 /* Sign extend the displacement. */
1027 delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
1028 if (delta & 0x8000)
1029 delta |= ~0xffff;
1030 info->target = (delta << 2) + pc + INSNLEN;
1031 (*info->print_address_func) (info->target, info);
1032 break;
1033
1034 case 'd':
1035 (*info->fprintf_func) (info->stream, "%s",
1036 mips_gpr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1037 break;
1038
1039 case 'U':
1040 {
1041 /* First check for both rd and rt being equal. */
1042 unsigned int reg = (l >> OP_SH_RD) & OP_MASK_RD;
1043 if (reg == ((l >> OP_SH_RT) & OP_MASK_RT))
1044 (*info->fprintf_func) (info->stream, "%s",
1045 mips_gpr_names[reg]);
1046 else
1047 {
1048 /* If one is zero use the other. */
1049 if (reg == 0)
1050 (*info->fprintf_func) (info->stream, "%s",
1051 mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1052 else if (((l >> OP_SH_RT) & OP_MASK_RT) == 0)
1053 (*info->fprintf_func) (info->stream, "%s",
1054 mips_gpr_names[reg]);
1055 else /* Bogus, result depends on processor. */
1056 (*info->fprintf_func) (info->stream, "%s or %s",
1057 mips_gpr_names[reg],
1058 mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1059 }
1060 }
1061 break;
1062
1063 case 'z':
1064 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1065 break;
1066
1067 case '<':
1068 (*info->fprintf_func) (info->stream, "0x%lx",
1069 (l >> OP_SH_SHAMT) & OP_MASK_SHAMT);
1070 break;
1071
1072 case 'c':
1073 (*info->fprintf_func) (info->stream, "0x%lx",
1074 (l >> OP_SH_CODE) & OP_MASK_CODE);
1075 break;
1076
1077 case 'q':
1078 (*info->fprintf_func) (info->stream, "0x%lx",
1079 (l >> OP_SH_CODE2) & OP_MASK_CODE2);
1080 break;
1081
1082 case 'C':
1083 (*info->fprintf_func) (info->stream, "0x%lx",
1084 (l >> OP_SH_COPZ) & OP_MASK_COPZ);
1085 break;
1086
1087 case 'B':
1088 (*info->fprintf_func) (info->stream, "0x%lx",
1089
1090 (l >> OP_SH_CODE20) & OP_MASK_CODE20);
1091 break;
1092
1093 case 'J':
1094 (*info->fprintf_func) (info->stream, "0x%lx",
1095 (l >> OP_SH_CODE19) & OP_MASK_CODE19);
1096 break;
1097
1098 case 'S':
1099 case 'V':
1100 (*info->fprintf_func) (info->stream, "%s",
1101 mips_fpr_names[(l >> OP_SH_FS) & OP_MASK_FS]);
1102 break;
1103
1104 case 'T':
1105 case 'W':
1106 (*info->fprintf_func) (info->stream, "%s",
1107 mips_fpr_names[(l >> OP_SH_FT) & OP_MASK_FT]);
1108 break;
1109
1110 case 'D':
1111 (*info->fprintf_func) (info->stream, "%s",
1112 mips_fpr_names[(l >> OP_SH_FD) & OP_MASK_FD]);
1113 break;
1114
1115 case 'R':
1116 (*info->fprintf_func) (info->stream, "%s",
1117 mips_fpr_names[(l >> OP_SH_FR) & OP_MASK_FR]);
1118 break;
1119
1120 case 'E':
1121 /* Coprocessor register for lwcN instructions, et al.
1122
1123 Note that there is no load/store cp0 instructions, and
1124 that FPU (cp1) instructions disassemble this field using
1125 'T' format. Therefore, until we gain understanding of
1126 cp2 register names, we can simply print the register
1127 numbers. */
1128 (*info->fprintf_func) (info->stream, "$%ld",
1129 (l >> OP_SH_RT) & OP_MASK_RT);
1130 break;
1131
1132 case 'G':
1133 /* Coprocessor register for mtcN instructions, et al. Note
1134 that FPU (cp1) instructions disassemble this field using
1135 'S' format. Therefore, we only need to worry about cp0,
1136 cp2, and cp3. */
1137 op = (l >> OP_SH_OP) & OP_MASK_OP;
1138 if (op == OP_OP_COP0)
1139 (*info->fprintf_func) (info->stream, "%s",
1140 mips_cp0_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1141 else
1142 (*info->fprintf_func) (info->stream, "$%ld",
1143 (l >> OP_SH_RD) & OP_MASK_RD);
1144 break;
1145
1146 case 'K':
1147 (*info->fprintf_func) (info->stream, "%s",
1148 mips_hwr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1149 break;
1150
1151 case 'N':
1152 (*info->fprintf_func) (info->stream,
1153 ((opp->pinfo & (FP_D | FP_S)) != 0
1154 ? "$fcc%ld" : "$cc%ld"),
1155 (l >> OP_SH_BCC) & OP_MASK_BCC);
1156 break;
1157
1158 case 'M':
1159 (*info->fprintf_func) (info->stream, "$fcc%ld",
1160 (l >> OP_SH_CCC) & OP_MASK_CCC);
1161 break;
1162
1163 case 'P':
1164 (*info->fprintf_func) (info->stream, "%ld",
1165 (l >> OP_SH_PERFREG) & OP_MASK_PERFREG);
1166 break;
1167
1168 case 'e':
1169 (*info->fprintf_func) (info->stream, "%ld",
1170 (l >> OP_SH_VECBYTE) & OP_MASK_VECBYTE);
1171 break;
1172
1173 case '%':
1174 (*info->fprintf_func) (info->stream, "%ld",
1175 (l >> OP_SH_VECALIGN) & OP_MASK_VECALIGN);
1176 break;
1177
1178 case 'H':
1179 (*info->fprintf_func) (info->stream, "%ld",
1180 (l >> OP_SH_SEL) & OP_MASK_SEL);
1181 break;
1182
1183 case 'O':
1184 (*info->fprintf_func) (info->stream, "%ld",
1185 (l >> OP_SH_ALN) & OP_MASK_ALN);
1186 break;
1187
1188 case 'Q':
1189 {
1190 unsigned int vsel = (l >> OP_SH_VSEL) & OP_MASK_VSEL;
1191
1192 if ((vsel & 0x10) == 0)
1193 {
1194 int fmt;
1195
1196 vsel &= 0x0f;
1197 for (fmt = 0; fmt < 3; fmt++, vsel >>= 1)
1198 if ((vsel & 1) == 0)
1199 break;
1200 (*info->fprintf_func) (info->stream, "$v%ld[%d]",
1201 (l >> OP_SH_FT) & OP_MASK_FT,
1202 vsel >> 1);
1203 }
1204 else if ((vsel & 0x08) == 0)
1205 {
1206 (*info->fprintf_func) (info->stream, "$v%ld",
1207 (l >> OP_SH_FT) & OP_MASK_FT);
1208 }
1209 else
1210 {
1211 (*info->fprintf_func) (info->stream, "0x%lx",
1212 (l >> OP_SH_FT) & OP_MASK_FT);
1213 }
1214 }
1215 break;
1216
1217 case 'X':
1218 (*info->fprintf_func) (info->stream, "$v%ld",
1219 (l >> OP_SH_FD) & OP_MASK_FD);
1220 break;
1221
1222 case 'Y':
1223 (*info->fprintf_func) (info->stream, "$v%ld",
1224 (l >> OP_SH_FS) & OP_MASK_FS);
1225 break;
1226
1227 case 'Z':
1228 (*info->fprintf_func) (info->stream, "$v%ld",
1229 (l >> OP_SH_FT) & OP_MASK_FT);
1230 break;
1231
1232 default:
1233 /* xgettext:c-format */
1234 (*info->fprintf_func) (info->stream,
1235 _("# internal error, undefined modifier (%c)"),
1236 *d);
1237 return;
1238 }
1239 }
1240 }
1241 \f
1242 /* Print the mips instruction at address MEMADDR in debugged memory,
1243 on using INFO. Returns length of the instruction, in bytes, which is
1244 always INSNLEN. BIGENDIAN must be 1 if this is big-endian code, 0 if
1245 this is little-endian code. */
1246
1247 static int
1248 print_insn_mips (bfd_vma memaddr,
1249 unsigned long int word,
1250 struct disassemble_info *info)
1251 {
1252 const struct mips_opcode *op;
1253 static bfd_boolean init = 0;
1254 static const struct mips_opcode *mips_hash[OP_MASK_OP + 1];
1255
1256 /* Build a hash table to shorten the search time. */
1257 if (! init)
1258 {
1259 unsigned int i;
1260
1261 for (i = 0; i <= OP_MASK_OP; i++)
1262 {
1263 for (op = mips_opcodes; op < &mips_opcodes[NUMOPCODES]; op++)
1264 {
1265 if (op->pinfo == INSN_MACRO
1266 || (no_aliases && (op->pinfo2 & INSN2_ALIAS)))
1267 continue;
1268 if (i == ((op->match >> OP_SH_OP) & OP_MASK_OP))
1269 {
1270 mips_hash[i] = op;
1271 break;
1272 }
1273 }
1274 }
1275
1276 init = 1;
1277 }
1278
1279 info->bytes_per_chunk = INSNLEN;
1280 info->display_endian = info->endian;
1281 info->insn_info_valid = 1;
1282 info->branch_delay_insns = 0;
1283 info->data_size = 0;
1284 info->insn_type = dis_nonbranch;
1285 info->target = 0;
1286 info->target2 = 0;
1287
1288 op = mips_hash[(word >> OP_SH_OP) & OP_MASK_OP];
1289 if (op != NULL)
1290 {
1291 for (; op < &mips_opcodes[NUMOPCODES]; op++)
1292 {
1293 if (op->pinfo != INSN_MACRO
1294 && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
1295 && (word & op->mask) == op->match)
1296 {
1297 const char *d;
1298
1299 /* We always allow to disassemble the jalx instruction. */
1300 if (! OPCODE_IS_MEMBER (op, mips_isa, mips_processor)
1301 && strcmp (op->name, "jalx"))
1302 continue;
1303
1304 /* Figure out instruction type and branch delay information. */
1305 if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
1306 {
1307 if ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1308 info->insn_type = dis_jsr;
1309 else
1310 info->insn_type = dis_branch;
1311 info->branch_delay_insns = 1;
1312 }
1313 else if ((op->pinfo & (INSN_COND_BRANCH_DELAY
1314 | INSN_COND_BRANCH_LIKELY)) != 0)
1315 {
1316 if ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1317 info->insn_type = dis_condjsr;
1318 else
1319 info->insn_type = dis_condbranch;
1320 info->branch_delay_insns = 1;
1321 }
1322 else if ((op->pinfo & (INSN_STORE_MEMORY
1323 | INSN_LOAD_MEMORY_DELAY)) != 0)
1324 info->insn_type = dis_dref;
1325
1326 (*info->fprintf_func) (info->stream, "%s", op->name);
1327
1328 d = op->args;
1329 if (d != NULL && *d != '\0')
1330 {
1331 (*info->fprintf_func) (info->stream, "\t");
1332 print_insn_args (d, word, memaddr, info, op);
1333 }
1334
1335 return INSNLEN;
1336 }
1337 }
1338 }
1339
1340 /* Handle undefined instructions. */
1341 info->insn_type = dis_noninsn;
1342 (*info->fprintf_func) (info->stream, "0x%lx", word);
1343 return INSNLEN;
1344 }
1345 \f
1346 /* Disassemble an operand for a mips16 instruction. */
1347
1348 static void
1349 print_mips16_insn_arg (char type,
1350 const struct mips_opcode *op,
1351 int l,
1352 bfd_boolean use_extend,
1353 int extend,
1354 bfd_vma memaddr,
1355 struct disassemble_info *info)
1356 {
1357 switch (type)
1358 {
1359 case ',':
1360 case '(':
1361 case ')':
1362 (*info->fprintf_func) (info->stream, "%c", type);
1363 break;
1364
1365 case 'y':
1366 case 'w':
1367 (*info->fprintf_func) (info->stream, "%s",
1368 mips16_reg_names(((l >> MIPS16OP_SH_RY)
1369 & MIPS16OP_MASK_RY)));
1370 break;
1371
1372 case 'x':
1373 case 'v':
1374 (*info->fprintf_func) (info->stream, "%s",
1375 mips16_reg_names(((l >> MIPS16OP_SH_RX)
1376 & MIPS16OP_MASK_RX)));
1377 break;
1378
1379 case 'z':
1380 (*info->fprintf_func) (info->stream, "%s",
1381 mips16_reg_names(((l >> MIPS16OP_SH_RZ)
1382 & MIPS16OP_MASK_RZ)));
1383 break;
1384
1385 case 'Z':
1386 (*info->fprintf_func) (info->stream, "%s",
1387 mips16_reg_names(((l >> MIPS16OP_SH_MOVE32Z)
1388 & MIPS16OP_MASK_MOVE32Z)));
1389 break;
1390
1391 case '0':
1392 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1393 break;
1394
1395 case 'S':
1396 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[29]);
1397 break;
1398
1399 case 'P':
1400 (*info->fprintf_func) (info->stream, "$pc");
1401 break;
1402
1403 case 'R':
1404 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[31]);
1405 break;
1406
1407 case 'X':
1408 (*info->fprintf_func) (info->stream, "%s",
1409 mips_gpr_names[((l >> MIPS16OP_SH_REGR32)
1410 & MIPS16OP_MASK_REGR32)]);
1411 break;
1412
1413 case 'Y':
1414 (*info->fprintf_func) (info->stream, "%s",
1415 mips_gpr_names[MIPS16OP_EXTRACT_REG32R (l)]);
1416 break;
1417
1418 case '<':
1419 case '>':
1420 case '[':
1421 case ']':
1422 case '4':
1423 case '5':
1424 case 'H':
1425 case 'W':
1426 case 'D':
1427 case 'j':
1428 case '6':
1429 case '8':
1430 case 'V':
1431 case 'C':
1432 case 'U':
1433 case 'k':
1434 case 'K':
1435 case 'p':
1436 case 'q':
1437 case 'A':
1438 case 'B':
1439 case 'E':
1440 {
1441 int immed, nbits, shift, signedp, extbits, pcrel, extu, branch;
1442
1443 shift = 0;
1444 signedp = 0;
1445 extbits = 16;
1446 pcrel = 0;
1447 extu = 0;
1448 branch = 0;
1449 switch (type)
1450 {
1451 case '<':
1452 nbits = 3;
1453 immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1454 extbits = 5;
1455 extu = 1;
1456 break;
1457 case '>':
1458 nbits = 3;
1459 immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1460 extbits = 5;
1461 extu = 1;
1462 break;
1463 case '[':
1464 nbits = 3;
1465 immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1466 extbits = 6;
1467 extu = 1;
1468 break;
1469 case ']':
1470 nbits = 3;
1471 immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1472 extbits = 6;
1473 extu = 1;
1474 break;
1475 case '4':
1476 nbits = 4;
1477 immed = (l >> MIPS16OP_SH_IMM4) & MIPS16OP_MASK_IMM4;
1478 signedp = 1;
1479 extbits = 15;
1480 break;
1481 case '5':
1482 nbits = 5;
1483 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1484 info->insn_type = dis_dref;
1485 info->data_size = 1;
1486 break;
1487 case 'H':
1488 nbits = 5;
1489 shift = 1;
1490 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1491 info->insn_type = dis_dref;
1492 info->data_size = 2;
1493 break;
1494 case 'W':
1495 nbits = 5;
1496 shift = 2;
1497 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1498 if ((op->pinfo & MIPS16_INSN_READ_PC) == 0
1499 && (op->pinfo & MIPS16_INSN_READ_SP) == 0)
1500 {
1501 info->insn_type = dis_dref;
1502 info->data_size = 4;
1503 }
1504 break;
1505 case 'D':
1506 nbits = 5;
1507 shift = 3;
1508 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1509 info->insn_type = dis_dref;
1510 info->data_size = 8;
1511 break;
1512 case 'j':
1513 nbits = 5;
1514 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1515 signedp = 1;
1516 break;
1517 case '6':
1518 nbits = 6;
1519 immed = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1520 break;
1521 case '8':
1522 nbits = 8;
1523 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1524 break;
1525 case 'V':
1526 nbits = 8;
1527 shift = 2;
1528 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1529 /* FIXME: This might be lw, or it might be addiu to $sp or
1530 $pc. We assume it's load. */
1531 info->insn_type = dis_dref;
1532 info->data_size = 4;
1533 break;
1534 case 'C':
1535 nbits = 8;
1536 shift = 3;
1537 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1538 info->insn_type = dis_dref;
1539 info->data_size = 8;
1540 break;
1541 case 'U':
1542 nbits = 8;
1543 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1544 extu = 1;
1545 break;
1546 case 'k':
1547 nbits = 8;
1548 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1549 signedp = 1;
1550 break;
1551 case 'K':
1552 nbits = 8;
1553 shift = 3;
1554 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1555 signedp = 1;
1556 break;
1557 case 'p':
1558 nbits = 8;
1559 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1560 signedp = 1;
1561 pcrel = 1;
1562 branch = 1;
1563 info->insn_type = dis_condbranch;
1564 break;
1565 case 'q':
1566 nbits = 11;
1567 immed = (l >> MIPS16OP_SH_IMM11) & MIPS16OP_MASK_IMM11;
1568 signedp = 1;
1569 pcrel = 1;
1570 branch = 1;
1571 info->insn_type = dis_branch;
1572 break;
1573 case 'A':
1574 nbits = 8;
1575 shift = 2;
1576 immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1577 pcrel = 1;
1578 /* FIXME: This can be lw or la. We assume it is lw. */
1579 info->insn_type = dis_dref;
1580 info->data_size = 4;
1581 break;
1582 case 'B':
1583 nbits = 5;
1584 shift = 3;
1585 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1586 pcrel = 1;
1587 info->insn_type = dis_dref;
1588 info->data_size = 8;
1589 break;
1590 case 'E':
1591 nbits = 5;
1592 shift = 2;
1593 immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1594 pcrel = 1;
1595 break;
1596 default:
1597 abort ();
1598 }
1599
1600 if (! use_extend)
1601 {
1602 if (signedp && immed >= (1 << (nbits - 1)))
1603 immed -= 1 << nbits;
1604 immed <<= shift;
1605 if ((type == '<' || type == '>' || type == '[' || type == ']')
1606 && immed == 0)
1607 immed = 8;
1608 }
1609 else
1610 {
1611 if (extbits == 16)
1612 immed |= ((extend & 0x1f) << 11) | (extend & 0x7e0);
1613 else if (extbits == 15)
1614 immed |= ((extend & 0xf) << 11) | (extend & 0x7f0);
1615 else
1616 immed = ((extend >> 6) & 0x1f) | (extend & 0x20);
1617 immed &= (1 << extbits) - 1;
1618 if (! extu && immed >= (1 << (extbits - 1)))
1619 immed -= 1 << extbits;
1620 }
1621
1622 if (! pcrel)
1623 (*info->fprintf_func) (info->stream, "%d", immed);
1624 else
1625 {
1626 bfd_vma baseaddr;
1627
1628 if (branch)
1629 {
1630 immed *= 2;
1631 baseaddr = memaddr + 2;
1632 }
1633 else if (use_extend)
1634 baseaddr = memaddr - 2;
1635 else
1636 {
1637 int status;
1638 bfd_byte buffer[2];
1639
1640 baseaddr = memaddr;
1641
1642 /* If this instruction is in the delay slot of a jr
1643 instruction, the base address is the address of the
1644 jr instruction. If it is in the delay slot of jalr
1645 instruction, the base address is the address of the
1646 jalr instruction. This test is unreliable: we have
1647 no way of knowing whether the previous word is
1648 instruction or data. */
1649 status = (*info->read_memory_func) (memaddr - 4, buffer, 2,
1650 info);
1651 if (status == 0
1652 && (((info->endian == BFD_ENDIAN_BIG
1653 ? bfd_getb16 (buffer)
1654 : bfd_getl16 (buffer))
1655 & 0xf800) == 0x1800))
1656 baseaddr = memaddr - 4;
1657 else
1658 {
1659 status = (*info->read_memory_func) (memaddr - 2, buffer,
1660 2, info);
1661 if (status == 0
1662 && (((info->endian == BFD_ENDIAN_BIG
1663 ? bfd_getb16 (buffer)
1664 : bfd_getl16 (buffer))
1665 & 0xf81f) == 0xe800))
1666 baseaddr = memaddr - 2;
1667 }
1668 }
1669 info->target = (baseaddr & ~((1 << shift) - 1)) + immed;
1670 if (pcrel && branch
1671 && info->flavour == bfd_target_unknown_flavour)
1672 /* For gdb disassembler, maintain odd address. */
1673 info->target |= 1;
1674 (*info->print_address_func) (info->target, info);
1675 }
1676 }
1677 break;
1678
1679 case 'a':
1680 {
1681 int jalx = l & 0x400;
1682
1683 if (! use_extend)
1684 extend = 0;
1685 l = ((l & 0x1f) << 23) | ((l & 0x3e0) << 13) | (extend << 2);
1686 if (!jalx && info->flavour == bfd_target_unknown_flavour)
1687 /* For gdb disassembler, maintain odd address. */
1688 l |= 1;
1689 }
1690 info->target = ((memaddr + 4) & ~(bfd_vma) 0x0fffffff) | l;
1691 (*info->print_address_func) (info->target, info);
1692 info->insn_type = dis_jsr;
1693 info->branch_delay_insns = 1;
1694 break;
1695
1696 case 'l':
1697 case 'L':
1698 {
1699 int need_comma, amask, smask;
1700
1701 need_comma = 0;
1702
1703 l = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1704
1705 amask = (l >> 3) & 7;
1706
1707 if (amask > 0 && amask < 5)
1708 {
1709 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1710 if (amask > 1)
1711 (*info->fprintf_func) (info->stream, "-%s",
1712 mips_gpr_names[amask + 3]);
1713 need_comma = 1;
1714 }
1715
1716 smask = (l >> 1) & 3;
1717 if (smask == 3)
1718 {
1719 (*info->fprintf_func) (info->stream, "%s??",
1720 need_comma ? "," : "");
1721 need_comma = 1;
1722 }
1723 else if (smask > 0)
1724 {
1725 (*info->fprintf_func) (info->stream, "%s%s",
1726 need_comma ? "," : "",
1727 mips_gpr_names[16]);
1728 if (smask > 1)
1729 (*info->fprintf_func) (info->stream, "-%s",
1730 mips_gpr_names[smask + 15]);
1731 need_comma = 1;
1732 }
1733
1734 if (l & 1)
1735 {
1736 (*info->fprintf_func) (info->stream, "%s%s",
1737 need_comma ? "," : "",
1738 mips_gpr_names[31]);
1739 need_comma = 1;
1740 }
1741
1742 if (amask == 5 || amask == 6)
1743 {
1744 (*info->fprintf_func) (info->stream, "%s$f0",
1745 need_comma ? "," : "");
1746 if (amask == 6)
1747 (*info->fprintf_func) (info->stream, "-$f1");
1748 }
1749 }
1750 break;
1751
1752 case 'm':
1753 case 'M':
1754 /* MIPS16e save/restore. */
1755 {
1756 int need_comma = 0;
1757 int amask, args, statics;
1758 int nsreg, smask;
1759 int framesz;
1760 int i, j;
1761
1762 l = l & 0x7f;
1763 if (use_extend)
1764 l |= extend << 16;
1765
1766 amask = (l >> 16) & 0xf;
1767 if (amask == MIPS16_ALL_ARGS)
1768 {
1769 args = 4;
1770 statics = 0;
1771 }
1772 else if (amask == MIPS16_ALL_STATICS)
1773 {
1774 args = 0;
1775 statics = 4;
1776 }
1777 else
1778 {
1779 args = amask >> 2;
1780 statics = amask & 3;
1781 }
1782
1783 if (args > 0) {
1784 (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1785 if (args > 1)
1786 (*info->fprintf_func) (info->stream, "-%s",
1787 mips_gpr_names[4 + args - 1]);
1788 need_comma = 1;
1789 }
1790
1791 framesz = (((l >> 16) & 0xf0) | (l & 0x0f)) * 8;
1792 if (framesz == 0 && !use_extend)
1793 framesz = 128;
1794
1795 (*info->fprintf_func) (info->stream, "%s%d",
1796 need_comma ? "," : "",
1797 framesz);
1798
1799 if (l & 0x40) /* $ra */
1800 (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[31]);
1801
1802 nsreg = (l >> 24) & 0x7;
1803 smask = 0;
1804 if (l & 0x20) /* $s0 */
1805 smask |= 1 << 0;
1806 if (l & 0x10) /* $s1 */
1807 smask |= 1 << 1;
1808 if (nsreg > 0) /* $s2-$s8 */
1809 smask |= ((1 << nsreg) - 1) << 2;
1810
1811 /* Find first set static reg bit. */
1812 for (i = 0; i < 9; i++)
1813 {
1814 if (smask & (1 << i))
1815 {
1816 (*info->fprintf_func) (info->stream, ",%s",
1817 mips_gpr_names[i == 8 ? 30 : (16 + i)]);
1818 /* Skip over string of set bits. */
1819 for (j = i; smask & (2 << j); j++)
1820 continue;
1821 if (j > i)
1822 (*info->fprintf_func) (info->stream, "-%s",
1823 mips_gpr_names[j == 8 ? 30 : (16 + j)]);
1824 i = j + 1;
1825 }
1826 }
1827
1828 /* Statics $ax - $a3. */
1829 if (statics == 1)
1830 (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[7]);
1831 else if (statics > 0)
1832 (*info->fprintf_func) (info->stream, ",%s-%s",
1833 mips_gpr_names[7 - statics + 1],
1834 mips_gpr_names[7]);
1835 }
1836 break;
1837
1838 default:
1839 /* xgettext:c-format */
1840 (*info->fprintf_func)
1841 (info->stream,
1842 _("# internal disassembler error, unrecognised modifier (%c)"),
1843 type);
1844 abort ();
1845 }
1846 }
1847
1848 /* Disassemble mips16 instructions. */
1849
1850 static int
1851 print_insn_mips16 (bfd_vma memaddr, struct disassemble_info *info)
1852 {
1853 int status;
1854 bfd_byte buffer[2];
1855 int length;
1856 int insn;
1857 bfd_boolean use_extend;
1858 int extend = 0;
1859 const struct mips_opcode *op, *opend;
1860
1861 info->bytes_per_chunk = 2;
1862 info->display_endian = info->endian;
1863 info->insn_info_valid = 1;
1864 info->branch_delay_insns = 0;
1865 info->data_size = 0;
1866 info->insn_type = dis_nonbranch;
1867 info->target = 0;
1868 info->target2 = 0;
1869
1870 status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1871 if (status != 0)
1872 {
1873 (*info->memory_error_func) (status, memaddr, info);
1874 return -1;
1875 }
1876
1877 length = 2;
1878
1879 if (info->endian == BFD_ENDIAN_BIG)
1880 insn = bfd_getb16 (buffer);
1881 else
1882 insn = bfd_getl16 (buffer);
1883
1884 /* Handle the extend opcode specially. */
1885 use_extend = FALSE;
1886 if ((insn & 0xf800) == 0xf000)
1887 {
1888 use_extend = TRUE;
1889 extend = insn & 0x7ff;
1890
1891 memaddr += 2;
1892
1893 status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1894 if (status != 0)
1895 {
1896 (*info->fprintf_func) (info->stream, "extend 0x%x",
1897 (unsigned int) extend);
1898 (*info->memory_error_func) (status, memaddr, info);
1899 return -1;
1900 }
1901
1902 if (info->endian == BFD_ENDIAN_BIG)
1903 insn = bfd_getb16 (buffer);
1904 else
1905 insn = bfd_getl16 (buffer);
1906
1907 /* Check for an extend opcode followed by an extend opcode. */
1908 if ((insn & 0xf800) == 0xf000)
1909 {
1910 (*info->fprintf_func) (info->stream, "extend 0x%x",
1911 (unsigned int) extend);
1912 info->insn_type = dis_noninsn;
1913 return length;
1914 }
1915
1916 length += 2;
1917 }
1918
1919 /* FIXME: Should probably use a hash table on the major opcode here. */
1920
1921 opend = mips16_opcodes + bfd_mips16_num_opcodes;
1922 for (op = mips16_opcodes; op < opend; op++)
1923 {
1924 if (op->pinfo != INSN_MACRO
1925 && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
1926 && (insn & op->mask) == op->match)
1927 {
1928 const char *s;
1929
1930 if (strchr (op->args, 'a') != NULL)
1931 {
1932 if (use_extend)
1933 {
1934 (*info->fprintf_func) (info->stream, "extend 0x%x",
1935 (unsigned int) extend);
1936 info->insn_type = dis_noninsn;
1937 return length - 2;
1938 }
1939
1940 use_extend = FALSE;
1941
1942 memaddr += 2;
1943
1944 status = (*info->read_memory_func) (memaddr, buffer, 2,
1945 info);
1946 if (status == 0)
1947 {
1948 use_extend = TRUE;
1949 if (info->endian == BFD_ENDIAN_BIG)
1950 extend = bfd_getb16 (buffer);
1951 else
1952 extend = bfd_getl16 (buffer);
1953 length += 2;
1954 }
1955 }
1956
1957 (*info->fprintf_func) (info->stream, "%s", op->name);
1958 if (op->args[0] != '\0')
1959 (*info->fprintf_func) (info->stream, "\t");
1960
1961 for (s = op->args; *s != '\0'; s++)
1962 {
1963 if (*s == ','
1964 && s[1] == 'w'
1965 && (((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)
1966 == ((insn >> MIPS16OP_SH_RY) & MIPS16OP_MASK_RY)))
1967 {
1968 /* Skip the register and the comma. */
1969 ++s;
1970 continue;
1971 }
1972 if (*s == ','
1973 && s[1] == 'v'
1974 && (((insn >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ)
1975 == ((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)))
1976 {
1977 /* Skip the register and the comma. */
1978 ++s;
1979 continue;
1980 }
1981 print_mips16_insn_arg (*s, op, insn, use_extend, extend, memaddr,
1982 info);
1983 }
1984
1985 if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
1986 {
1987 info->branch_delay_insns = 1;
1988 if (info->insn_type != dis_jsr)
1989 info->insn_type = dis_branch;
1990 }
1991
1992 return length;
1993 }
1994 }
1995
1996 if (use_extend)
1997 (*info->fprintf_func) (info->stream, "0x%x", extend | 0xf000);
1998 (*info->fprintf_func) (info->stream, "0x%x", insn);
1999 info->insn_type = dis_noninsn;
2000
2001 return length;
2002 }
2003
2004 /* In an environment where we do not know the symbol type of the
2005 instruction we are forced to assume that the low order bit of the
2006 instructions' address may mark it as a mips16 instruction. If we
2007 are single stepping, or the pc is within the disassembled function,
2008 this works. Otherwise, we need a clue. Sometimes. */
2009
2010 static int
2011 _print_insn_mips (bfd_vma memaddr,
2012 struct disassemble_info *info,
2013 enum bfd_endian endianness)
2014 {
2015 bfd_byte buffer[INSNLEN];
2016 int status;
2017
2018 set_default_mips_dis_options (info);
2019 parse_mips_dis_options (info->disassembler_options);
2020
2021 #if 1
2022 /* FIXME: If odd address, this is CLEARLY a mips 16 instruction. */
2023 /* Only a few tools will work this way. */
2024 if (memaddr & 0x01)
2025 return print_insn_mips16 (memaddr, info);
2026 #endif
2027
2028 #if SYMTAB_AVAILABLE
2029 if (info->mach == bfd_mach_mips16
2030 || (info->flavour == bfd_target_elf_flavour
2031 && info->symbols != NULL
2032 && ((*(elf_symbol_type **) info->symbols)->internal_elf_sym.st_other
2033 == STO_MIPS16)))
2034 return print_insn_mips16 (memaddr, info);
2035 #endif
2036
2037 status = (*info->read_memory_func) (memaddr, buffer, INSNLEN, info);
2038 if (status == 0)
2039 {
2040 unsigned long insn;
2041
2042 if (endianness == BFD_ENDIAN_BIG)
2043 insn = (unsigned long) bfd_getb32 (buffer);
2044 else
2045 insn = (unsigned long) bfd_getl32 (buffer);
2046
2047 return print_insn_mips (memaddr, insn, info);
2048 }
2049 else
2050 {
2051 (*info->memory_error_func) (status, memaddr, info);
2052 return -1;
2053 }
2054 }
2055
2056 int
2057 print_insn_big_mips (bfd_vma memaddr, struct disassemble_info *info)
2058 {
2059 return _print_insn_mips (memaddr, info, BFD_ENDIAN_BIG);
2060 }
2061
2062 int
2063 print_insn_little_mips (bfd_vma memaddr, struct disassemble_info *info)
2064 {
2065 return _print_insn_mips (memaddr, info, BFD_ENDIAN_LITTLE);
2066 }
2067 \f
2068 void
2069 print_mips_disassembler_options (FILE *stream)
2070 {
2071 unsigned int i;
2072
2073 fprintf (stream, _("\n\
2074 The following MIPS specific disassembler options are supported for use\n\
2075 with the -M switch (multiple options should be separated by commas):\n"));
2076
2077 fprintf (stream, _("\n\
2078 gpr-names=ABI Print GPR names according to specified ABI.\n\
2079 Default: based on binary being disassembled.\n"));
2080
2081 fprintf (stream, _("\n\
2082 fpr-names=ABI Print FPR names according to specified ABI.\n\
2083 Default: numeric.\n"));
2084
2085 fprintf (stream, _("\n\
2086 cp0-names=ARCH Print CP0 register names according to\n\
2087 specified architecture.\n\
2088 Default: based on binary being disassembled.\n"));
2089
2090 fprintf (stream, _("\n\
2091 hwr-names=ARCH Print HWR names according to specified \n\
2092 architecture.\n\
2093 Default: based on binary being disassembled.\n"));
2094
2095 fprintf (stream, _("\n\
2096 reg-names=ABI Print GPR and FPR names according to\n\
2097 specified ABI.\n"));
2098
2099 fprintf (stream, _("\n\
2100 reg-names=ARCH Print CP0 register and HWR names according to\n\
2101 specified architecture.\n"));
2102
2103 fprintf (stream, _("\n\
2104 For the options above, the following values are supported for \"ABI\":\n\
2105 "));
2106 for (i = 0; i < ARRAY_SIZE (mips_abi_choices); i++)
2107 fprintf (stream, " %s", mips_abi_choices[i].name);
2108 fprintf (stream, _("\n"));
2109
2110 fprintf (stream, _("\n\
2111 For the options above, The following values are supported for \"ARCH\":\n\
2112 "));
2113 for (i = 0; i < ARRAY_SIZE (mips_arch_choices); i++)
2114 if (*mips_arch_choices[i].name != '\0')
2115 fprintf (stream, " %s", mips_arch_choices[i].name);
2116 fprintf (stream, _("\n"));
2117
2118 fprintf (stream, _("\n"));
2119 }
GDB Binutils - Deliverables
This page took 0.074846 seconds and 4 git commands to generate.