MIPS16/opcodes: Fix PC-relative operation delay-slot adjustment
[external/binutils.git] / opcodes / mips-dis.c
1 /* Print mips instructions for GDB, the GNU debugger, or for objdump.
2    Copyright (C) 1989-2016 Free Software Foundation, Inc.
3    Contributed by Nobuyuki Hikichi(hikichi@sra.co.jp).
4
5    This file is part of the GNU opcodes library.
6
7    This library is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3, or (at your option)
10    any later version.
11
12    It is distributed in the hope that it will be useful, but WITHOUT
13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15    License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22 #include "sysdep.h"
23 #include "dis-asm.h"
24 #include "libiberty.h"
25 #include "opcode/mips.h"
26 #include "opintl.h"
27
28 /* FIXME: These are needed to figure out if the code is mips16 or
29    not. The low bit of the address is often a good indicator.  No
30    symbol table is available when this code runs out in an embedded
31    system as when it is used for disassembler support in a monitor.  */
32
33 #if !defined(EMBEDDED_ENV)
34 #define SYMTAB_AVAILABLE 1
35 #include "elf-bfd.h"
36 #include "elf/mips.h"
37 #endif
38
39 /* Mips instructions are at maximum this many bytes long.  */
40 #define INSNLEN 4
41
42 \f
43 /* FIXME: These should be shared with gdb somehow.  */
44
45 struct mips_cp0sel_name
46 {
47   unsigned int cp0reg;
48   unsigned int sel;
49   const char * const name;
50 };
51
52 static const char * const mips_gpr_names_numeric[32] =
53 {
54   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
55   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
56   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
57   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
58 };
59
60 static const char * const mips_gpr_names_oldabi[32] =
61 {
62   "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
63   "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
64   "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
65   "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra"
66 };
67
68 static const char * const mips_gpr_names_newabi[32] =
69 {
70   "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
71   "a4",   "a5",   "a6",   "a7",   "t0",   "t1",   "t2",   "t3",
72   "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
73   "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra"
74 };
75
76 static const char * const mips_fpr_names_numeric[32] =
77 {
78   "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
79   "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
80   "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
81   "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31"
82 };
83
84 static const char * const mips_fpr_names_32[32] =
85 {
86   "fv0",  "fv0f", "fv1",  "fv1f", "ft0",  "ft0f", "ft1",  "ft1f",
87   "ft2",  "ft2f", "ft3",  "ft3f", "fa0",  "fa0f", "fa1",  "fa1f",
88   "ft4",  "ft4f", "ft5",  "ft5f", "fs0",  "fs0f", "fs1",  "fs1f",
89   "fs2",  "fs2f", "fs3",  "fs3f", "fs4",  "fs4f", "fs5",  "fs5f"
90 };
91
92 static const char * const mips_fpr_names_n32[32] =
93 {
94   "fv0",  "ft14", "fv1",  "ft15", "ft0",  "ft1",  "ft2",  "ft3",
95   "ft4",  "ft5",  "ft6",  "ft7",  "fa0",  "fa1",  "fa2",  "fa3",
96   "fa4",  "fa5",  "fa6",  "fa7",  "fs0",  "ft8",  "fs1",  "ft9",
97   "fs2",  "ft10", "fs3",  "ft11", "fs4",  "ft12", "fs5",  "ft13"
98 };
99
100 static const char * const mips_fpr_names_64[32] =
101 {
102   "fv0",  "ft12", "fv1",  "ft13", "ft0",  "ft1",  "ft2",  "ft3",
103   "ft4",  "ft5",  "ft6",  "ft7",  "fa0",  "fa1",  "fa2",  "fa3",
104   "fa4",  "fa5",  "fa6",  "fa7",  "ft8",  "ft9",  "ft10", "ft11",
105   "fs0",  "fs1",  "fs2",  "fs3",  "fs4",  "fs5",  "fs6",  "fs7"
106 };
107
108 static const char * const mips_cp0_names_numeric[32] =
109 {
110   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
111   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
112   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
113   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
114 };
115
116 static const char * const mips_cp1_names_numeric[32] =
117 {
118   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
119   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
120   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
121   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
122 };
123
124 static const char * const mips_cp0_names_r3000[32] =
125 {
126   "c0_index",     "c0_random",    "c0_entrylo",   "$3",
127   "c0_context",   "$5",           "$6",           "$7",
128   "c0_badvaddr",  "$9",           "c0_entryhi",   "$11",
129   "c0_sr",        "c0_cause",     "c0_epc",       "c0_prid",
130   "$16",          "$17",          "$18",          "$19",
131   "$20",          "$21",          "$22",          "$23",
132   "$24",          "$25",          "$26",          "$27",
133   "$28",          "$29",          "$30",          "$31",
134 };
135
136 static const char * const mips_cp0_names_r4000[32] =
137 {
138   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
139   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
140   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
141   "c0_sr",        "c0_cause",     "c0_epc",       "c0_prid",
142   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
143   "c0_xcontext",  "$21",          "$22",          "$23",
144   "$24",          "$25",          "c0_ecc",       "c0_cacheerr",
145   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "$31",
146 };
147
148 static const char * const mips_cp0_names_r5900[32] =
149 {
150   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
151   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
152   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
153   "c0_sr",        "c0_cause",     "c0_epc",       "c0_prid",
154   "c0_config",    "$17",          "$18",          "$19",
155   "$20",          "$21",          "$22",          "c0_badpaddr",
156   "c0_depc",      "c0_perfcnt",   "$26",          "$27",
157   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "$31"
158 };
159
160 static const char * const mips_cp0_names_mips3264[32] =
161 {
162   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
163   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
164   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
165   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
166   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
167   "c0_xcontext",  "$21",          "$22",          "c0_debug",
168   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr",
169   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "c0_desave",
170 };
171
172 static const char * const mips_cp1_names_mips3264[32] =
173 {
174   "c1_fir",       "c1_ufr",       "$2",           "$3",
175   "c1_unfr",      "$5",           "$6",           "$7",
176   "$8",           "$9",           "$10",          "$11",
177   "$12",          "$13",          "$14",          "$15",
178   "$16",          "$17",          "$18",          "$19",
179   "$20",          "$21",          "$22",          "$23",
180   "$24",          "c1_fccr",      "c1_fexr",      "$27",
181   "c1_fenr",      "$29",          "$30",          "c1_fcsr"
182 };
183
184 static const struct mips_cp0sel_name mips_cp0sel_names_mips3264[] =
185 {
186   { 16, 1, "c0_config1"         },
187   { 16, 2, "c0_config2"         },
188   { 16, 3, "c0_config3"         },
189   { 18, 1, "c0_watchlo,1"       },
190   { 18, 2, "c0_watchlo,2"       },
191   { 18, 3, "c0_watchlo,3"       },
192   { 18, 4, "c0_watchlo,4"       },
193   { 18, 5, "c0_watchlo,5"       },
194   { 18, 6, "c0_watchlo,6"       },
195   { 18, 7, "c0_watchlo,7"       },
196   { 19, 1, "c0_watchhi,1"       },
197   { 19, 2, "c0_watchhi,2"       },
198   { 19, 3, "c0_watchhi,3"       },
199   { 19, 4, "c0_watchhi,4"       },
200   { 19, 5, "c0_watchhi,5"       },
201   { 19, 6, "c0_watchhi,6"       },
202   { 19, 7, "c0_watchhi,7"       },
203   { 25, 1, "c0_perfcnt,1"       },
204   { 25, 2, "c0_perfcnt,2"       },
205   { 25, 3, "c0_perfcnt,3"       },
206   { 25, 4, "c0_perfcnt,4"       },
207   { 25, 5, "c0_perfcnt,5"       },
208   { 25, 6, "c0_perfcnt,6"       },
209   { 25, 7, "c0_perfcnt,7"       },
210   { 27, 1, "c0_cacheerr,1"      },
211   { 27, 2, "c0_cacheerr,2"      },
212   { 27, 3, "c0_cacheerr,3"      },
213   { 28, 1, "c0_datalo"          },
214   { 29, 1, "c0_datahi"          }
215 };
216
217 static const char * const mips_cp0_names_mips3264r2[32] =
218 {
219   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
220   "c0_context",   "c0_pagemask",  "c0_wired",     "c0_hwrena",
221   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
222   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
223   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
224   "c0_xcontext",  "$21",          "$22",          "c0_debug",
225   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr",
226   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "c0_desave",
227 };
228
229 static const struct mips_cp0sel_name mips_cp0sel_names_mips3264r2[] =
230 {
231   {  4, 1, "c0_contextconfig"   },
232   {  0, 1, "c0_mvpcontrol"      },
233   {  0, 2, "c0_mvpconf0"        },
234   {  0, 3, "c0_mvpconf1"        },
235   {  1, 1, "c0_vpecontrol"      },
236   {  1, 2, "c0_vpeconf0"        },
237   {  1, 3, "c0_vpeconf1"        },
238   {  1, 4, "c0_yqmask"          },
239   {  1, 5, "c0_vpeschedule"     },
240   {  1, 6, "c0_vpeschefback"    },
241   {  2, 1, "c0_tcstatus"        },
242   {  2, 2, "c0_tcbind"          },
243   {  2, 3, "c0_tcrestart"       },
244   {  2, 4, "c0_tchalt"          },
245   {  2, 5, "c0_tccontext"       },
246   {  2, 6, "c0_tcschedule"      },
247   {  2, 7, "c0_tcschefback"     },
248   {  5, 1, "c0_pagegrain"       },
249   {  6, 1, "c0_srsconf0"        },
250   {  6, 2, "c0_srsconf1"        },
251   {  6, 3, "c0_srsconf2"        },
252   {  6, 4, "c0_srsconf3"        },
253   {  6, 5, "c0_srsconf4"        },
254   { 12, 1, "c0_intctl"          },
255   { 12, 2, "c0_srsctl"          },
256   { 12, 3, "c0_srsmap"          },
257   { 15, 1, "c0_ebase"           },
258   { 16, 1, "c0_config1"         },
259   { 16, 2, "c0_config2"         },
260   { 16, 3, "c0_config3"         },
261   { 18, 1, "c0_watchlo,1"       },
262   { 18, 2, "c0_watchlo,2"       },
263   { 18, 3, "c0_watchlo,3"       },
264   { 18, 4, "c0_watchlo,4"       },
265   { 18, 5, "c0_watchlo,5"       },
266   { 18, 6, "c0_watchlo,6"       },
267   { 18, 7, "c0_watchlo,7"       },
268   { 19, 1, "c0_watchhi,1"       },
269   { 19, 2, "c0_watchhi,2"       },
270   { 19, 3, "c0_watchhi,3"       },
271   { 19, 4, "c0_watchhi,4"       },
272   { 19, 5, "c0_watchhi,5"       },
273   { 19, 6, "c0_watchhi,6"       },
274   { 19, 7, "c0_watchhi,7"       },
275   { 23, 1, "c0_tracecontrol"    },
276   { 23, 2, "c0_tracecontrol2"   },
277   { 23, 3, "c0_usertracedata"   },
278   { 23, 4, "c0_tracebpc"        },
279   { 25, 1, "c0_perfcnt,1"       },
280   { 25, 2, "c0_perfcnt,2"       },
281   { 25, 3, "c0_perfcnt,3"       },
282   { 25, 4, "c0_perfcnt,4"       },
283   { 25, 5, "c0_perfcnt,5"       },
284   { 25, 6, "c0_perfcnt,6"       },
285   { 25, 7, "c0_perfcnt,7"       },
286   { 27, 1, "c0_cacheerr,1"      },
287   { 27, 2, "c0_cacheerr,2"      },
288   { 27, 3, "c0_cacheerr,3"      },
289   { 28, 1, "c0_datalo"          },
290   { 28, 2, "c0_taglo1"          },
291   { 28, 3, "c0_datalo1"         },
292   { 28, 4, "c0_taglo2"          },
293   { 28, 5, "c0_datalo2"         },
294   { 28, 6, "c0_taglo3"          },
295   { 28, 7, "c0_datalo3"         },
296   { 29, 1, "c0_datahi"          },
297   { 29, 2, "c0_taghi1"          },
298   { 29, 3, "c0_datahi1"         },
299   { 29, 4, "c0_taghi2"          },
300   { 29, 5, "c0_datahi2"         },
301   { 29, 6, "c0_taghi3"          },
302   { 29, 7, "c0_datahi3"         },
303 };
304
305 /* SB-1: MIPS64 (mips_cp0_names_mips3264) with minor mods.  */
306 static const char * const mips_cp0_names_sb1[32] =
307 {
308   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
309   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
310   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
311   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
312   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
313   "c0_xcontext",  "$21",          "$22",          "c0_debug",
314   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr_i",
315   "c0_taglo_i",   "c0_taghi_i",   "c0_errorepc",  "c0_desave",
316 };
317
318 static const struct mips_cp0sel_name mips_cp0sel_names_sb1[] =
319 {
320   { 16, 1, "c0_config1"         },
321   { 18, 1, "c0_watchlo,1"       },
322   { 19, 1, "c0_watchhi,1"       },
323   { 22, 0, "c0_perftrace"       },
324   { 23, 3, "c0_edebug"          },
325   { 25, 1, "c0_perfcnt,1"       },
326   { 25, 2, "c0_perfcnt,2"       },
327   { 25, 3, "c0_perfcnt,3"       },
328   { 25, 4, "c0_perfcnt,4"       },
329   { 25, 5, "c0_perfcnt,5"       },
330   { 25, 6, "c0_perfcnt,6"       },
331   { 25, 7, "c0_perfcnt,7"       },
332   { 26, 1, "c0_buserr_pa"       },
333   { 27, 1, "c0_cacheerr_d"      },
334   { 27, 3, "c0_cacheerr_d_pa"   },
335   { 28, 1, "c0_datalo_i"        },
336   { 28, 2, "c0_taglo_d"         },
337   { 28, 3, "c0_datalo_d"        },
338   { 29, 1, "c0_datahi_i"        },
339   { 29, 2, "c0_taghi_d"         },
340   { 29, 3, "c0_datahi_d"        },
341 };
342
343 /* Xlr cop0 register names.  */
344 static const char * const mips_cp0_names_xlr[32] = {
345   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
346   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
347   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
348   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
349   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
350   "c0_xcontext",  "$21",          "$22",          "c0_debug",
351   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr_i",
352   "c0_taglo_i",   "c0_taghi_i",   "c0_errorepc",  "c0_desave",
353 };
354
355 /* XLR's CP0 Select Registers.  */
356
357 static const struct mips_cp0sel_name mips_cp0sel_names_xlr[] = {
358   {  9, 6, "c0_extintreq"       },
359   {  9, 7, "c0_extintmask"      },
360   { 15, 1, "c0_ebase"           },
361   { 16, 1, "c0_config1"         },
362   { 16, 2, "c0_config2"         },
363   { 16, 3, "c0_config3"         },
364   { 16, 7, "c0_procid2"         },
365   { 18, 1, "c0_watchlo,1"       },
366   { 18, 2, "c0_watchlo,2"       },
367   { 18, 3, "c0_watchlo,3"       },
368   { 18, 4, "c0_watchlo,4"       },
369   { 18, 5, "c0_watchlo,5"       },
370   { 18, 6, "c0_watchlo,6"       },
371   { 18, 7, "c0_watchlo,7"       },
372   { 19, 1, "c0_watchhi,1"       },
373   { 19, 2, "c0_watchhi,2"       },
374   { 19, 3, "c0_watchhi,3"       },
375   { 19, 4, "c0_watchhi,4"       },
376   { 19, 5, "c0_watchhi,5"       },
377   { 19, 6, "c0_watchhi,6"       },
378   { 19, 7, "c0_watchhi,7"       },
379   { 25, 1, "c0_perfcnt,1"       },
380   { 25, 2, "c0_perfcnt,2"       },
381   { 25, 3, "c0_perfcnt,3"       },
382   { 25, 4, "c0_perfcnt,4"       },
383   { 25, 5, "c0_perfcnt,5"       },
384   { 25, 6, "c0_perfcnt,6"       },
385   { 25, 7, "c0_perfcnt,7"       },
386   { 27, 1, "c0_cacheerr,1"      },
387   { 27, 2, "c0_cacheerr,2"      },
388   { 27, 3, "c0_cacheerr,3"      },
389   { 28, 1, "c0_datalo"          },
390   { 29, 1, "c0_datahi"          }
391 };
392
393 static const char * const mips_hwr_names_numeric[32] =
394 {
395   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
396   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
397   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
398   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
399 };
400
401 static const char * const mips_hwr_names_mips3264r2[32] =
402 {
403   "hwr_cpunum",   "hwr_synci_step", "hwr_cc",     "hwr_ccres",
404   "$4",          "$5",            "$6",           "$7",
405   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
406   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
407   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
408 };
409
410 static const char * const msa_control_names[32] =
411 {
412   "msa_ir",     "msa_csr",      "msa_access",   "msa_save",
413   "msa_modify", "msa_request",  "msa_map",      "msa_unmap",
414   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
415   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
416   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
417 };
418
419 struct mips_abi_choice
420 {
421   const char * name;
422   const char * const *gpr_names;
423   const char * const *fpr_names;
424 };
425
426 struct mips_abi_choice mips_abi_choices[] =
427 {
428   { "numeric", mips_gpr_names_numeric, mips_fpr_names_numeric },
429   { "32", mips_gpr_names_oldabi, mips_fpr_names_32 },
430   { "n32", mips_gpr_names_newabi, mips_fpr_names_n32 },
431   { "64", mips_gpr_names_newabi, mips_fpr_names_64 },
432 };
433
434 struct mips_arch_choice
435 {
436   const char *name;
437   int bfd_mach_valid;
438   unsigned long bfd_mach;
439   int processor;
440   int isa;
441   int ase;
442   const char * const *cp0_names;
443   const struct mips_cp0sel_name *cp0sel_names;
444   unsigned int cp0sel_names_len;
445   const char * const *cp1_names;
446   const char * const *hwr_names;
447 };
448
449 const struct mips_arch_choice mips_arch_choices[] =
450 {
451   { "numeric",  0, 0, 0, 0, 0,
452     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
453     mips_hwr_names_numeric },
454
455   { "r3000",    1, bfd_mach_mips3000, CPU_R3000, ISA_MIPS1, 0,
456     mips_cp0_names_r3000, NULL, 0, mips_cp1_names_numeric,
457     mips_hwr_names_numeric },
458   { "r3900",    1, bfd_mach_mips3900, CPU_R3900, ISA_MIPS1, 0,
459     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
460     mips_hwr_names_numeric },
461   { "r4000",    1, bfd_mach_mips4000, CPU_R4000, ISA_MIPS3, 0,
462     mips_cp0_names_r4000, NULL, 0, mips_cp1_names_numeric,
463     mips_hwr_names_numeric },
464   { "r4010",    1, bfd_mach_mips4010, CPU_R4010, ISA_MIPS2, 0,
465     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
466     mips_hwr_names_numeric },
467   { "vr4100",   1, bfd_mach_mips4100, CPU_VR4100, ISA_MIPS3, 0,
468     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
469     mips_hwr_names_numeric },
470   { "vr4111",   1, bfd_mach_mips4111, CPU_R4111, ISA_MIPS3, 0,
471     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
472     mips_hwr_names_numeric },
473   { "vr4120",   1, bfd_mach_mips4120, CPU_VR4120, ISA_MIPS3, 0,
474     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
475     mips_hwr_names_numeric },
476   { "r4300",    1, bfd_mach_mips4300, CPU_R4300, ISA_MIPS3, 0,
477     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
478     mips_hwr_names_numeric },
479   { "r4400",    1, bfd_mach_mips4400, CPU_R4400, ISA_MIPS3, 0,
480     mips_cp0_names_r4000, NULL, 0, mips_cp1_names_numeric,
481     mips_hwr_names_numeric },
482   { "r4600",    1, bfd_mach_mips4600, CPU_R4600, ISA_MIPS3, 0,
483     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
484     mips_hwr_names_numeric },
485   { "r4650",    1, bfd_mach_mips4650, CPU_R4650, ISA_MIPS3, 0,
486     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
487     mips_hwr_names_numeric },
488   { "r5000",    1, bfd_mach_mips5000, CPU_R5000, ISA_MIPS4, 0,
489     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
490     mips_hwr_names_numeric },
491   { "vr5400",   1, bfd_mach_mips5400, CPU_VR5400, ISA_MIPS4, 0,
492     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
493     mips_hwr_names_numeric },
494   { "vr5500",   1, bfd_mach_mips5500, CPU_VR5500, ISA_MIPS4, 0,
495     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
496     mips_hwr_names_numeric },
497   { "r5900",    1, bfd_mach_mips5900, CPU_R5900, ISA_MIPS3, 0,
498     mips_cp0_names_r5900, NULL, 0, mips_cp1_names_numeric,
499     mips_hwr_names_numeric },
500   { "r6000",    1, bfd_mach_mips6000, CPU_R6000, ISA_MIPS2, 0,
501     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
502     mips_hwr_names_numeric },
503   { "rm7000",   1, bfd_mach_mips7000, CPU_RM7000, ISA_MIPS4, 0,
504     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
505     mips_hwr_names_numeric },
506   { "rm9000",   1, bfd_mach_mips7000, CPU_RM7000, ISA_MIPS4, 0,
507     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
508     mips_hwr_names_numeric },
509   { "r8000",    1, bfd_mach_mips8000, CPU_R8000, ISA_MIPS4, 0,
510     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
511     mips_hwr_names_numeric },
512   { "r10000",   1, bfd_mach_mips10000, CPU_R10000, ISA_MIPS4, 0,
513     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
514     mips_hwr_names_numeric },
515   { "r12000",   1, bfd_mach_mips12000, CPU_R12000, ISA_MIPS4, 0,
516     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
517     mips_hwr_names_numeric },
518   { "r14000",   1, bfd_mach_mips14000, CPU_R14000, ISA_MIPS4, 0,
519     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
520     mips_hwr_names_numeric },
521   { "r16000",   1, bfd_mach_mips16000, CPU_R16000, ISA_MIPS4, 0,
522     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
523     mips_hwr_names_numeric },
524   { "mips5",    1, bfd_mach_mips5, CPU_MIPS5, ISA_MIPS5, 0,
525     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
526     mips_hwr_names_numeric },
527
528   /* For stock MIPS32, disassemble all applicable MIPS-specified ASEs.
529      Note that MIPS-3D and MDMX are not applicable to MIPS32.  (See
530      _MIPS32 Architecture For Programmers Volume I: Introduction to the
531      MIPS32 Architecture_ (MIPS Document Number MD00082, Revision 0.95),
532      page 1.  */
533   { "mips32",   1, bfd_mach_mipsisa32, CPU_MIPS32,
534     ISA_MIPS32,  ASE_SMARTMIPS,
535     mips_cp0_names_mips3264,
536     mips_cp0sel_names_mips3264, ARRAY_SIZE (mips_cp0sel_names_mips3264),
537     mips_cp1_names_mips3264, mips_hwr_names_numeric },
538
539   { "mips32r2", 1, bfd_mach_mipsisa32r2, CPU_MIPS32R2,
540     ISA_MIPS32R2,
541     (ASE_SMARTMIPS | ASE_DSP | ASE_DSPR2 | ASE_EVA | ASE_MIPS3D
542      | ASE_MT | ASE_MCU | ASE_VIRT | ASE_MSA | ASE_XPA),
543     mips_cp0_names_mips3264r2,
544     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
545     mips_cp1_names_mips3264, mips_hwr_names_mips3264r2 },
546
547   { "mips32r3", 1, bfd_mach_mipsisa32r3, CPU_MIPS32R3,
548     ISA_MIPS32R3,
549     (ASE_SMARTMIPS | ASE_DSP | ASE_DSPR2 | ASE_EVA | ASE_MIPS3D
550      | ASE_MT | ASE_MCU | ASE_VIRT | ASE_MSA | ASE_XPA),
551     mips_cp0_names_mips3264r2,
552     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
553     mips_cp1_names_mips3264, mips_hwr_names_mips3264r2 },
554
555   { "mips32r5", 1, bfd_mach_mipsisa32r5, CPU_MIPS32R5,
556     ISA_MIPS32R5,
557     (ASE_SMARTMIPS | ASE_DSP | ASE_DSPR2 | ASE_EVA | ASE_MIPS3D
558      | ASE_MT | ASE_MCU | ASE_VIRT | ASE_MSA | ASE_XPA),
559     mips_cp0_names_mips3264r2,
560     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
561     mips_cp1_names_mips3264, mips_hwr_names_mips3264r2 },
562
563   { "mips32r6", 1, bfd_mach_mipsisa32r6, CPU_MIPS32R6,
564     ISA_MIPS32R6,
565     (ASE_EVA | ASE_MSA | ASE_VIRT | ASE_XPA | ASE_MCU | ASE_MT | ASE_DSP
566      | ASE_DSPR2 | ASE_DSPR3),
567     mips_cp0_names_mips3264r2,
568     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
569     mips_cp1_names_mips3264, mips_hwr_names_mips3264r2 },
570
571   /* For stock MIPS64, disassemble all applicable MIPS-specified ASEs.  */
572   { "mips64",   1, bfd_mach_mipsisa64, CPU_MIPS64,
573     ISA_MIPS64,  ASE_MIPS3D | ASE_MDMX,
574     mips_cp0_names_mips3264,
575     mips_cp0sel_names_mips3264, ARRAY_SIZE (mips_cp0sel_names_mips3264),
576     mips_cp1_names_mips3264, mips_hwr_names_numeric },
577
578   { "mips64r2", 1, bfd_mach_mipsisa64r2, CPU_MIPS64R2,
579     ISA_MIPS64R2,
580     (ASE_MIPS3D | ASE_DSP | ASE_DSPR2 | ASE_DSP64 | ASE_EVA | ASE_MT
581      | ASE_MCU | ASE_VIRT | ASE_VIRT64 | ASE_MSA | ASE_MSA64 | ASE_XPA),
582     mips_cp0_names_mips3264r2,
583     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
584     mips_cp1_names_mips3264, mips_hwr_names_mips3264r2 },
585
586   { "mips64r3", 1, bfd_mach_mipsisa64r3, CPU_MIPS64R3,
587     ISA_MIPS64R3,
588     (ASE_MIPS3D | ASE_DSP | ASE_DSPR2 | ASE_DSP64 | ASE_EVA | ASE_MT
589      | ASE_MCU | ASE_VIRT | ASE_VIRT64 | ASE_MSA | ASE_MSA64 | ASE_XPA),
590     mips_cp0_names_mips3264r2,
591     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
592     mips_cp1_names_mips3264, mips_hwr_names_mips3264r2 },
593
594   { "mips64r5", 1, bfd_mach_mipsisa64r5, CPU_MIPS64R5,
595     ISA_MIPS64R5,
596     (ASE_MIPS3D | ASE_DSP | ASE_DSPR2 | ASE_DSP64 | ASE_EVA | ASE_MT
597      | ASE_MCU | ASE_VIRT | ASE_VIRT64 | ASE_MSA | ASE_MSA64 | ASE_XPA),
598     mips_cp0_names_mips3264r2,
599     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
600     mips_cp1_names_mips3264, mips_hwr_names_mips3264r2 },
601
602   { "mips64r6", 1, bfd_mach_mipsisa64r6, CPU_MIPS64R6,
603     ISA_MIPS64R6,
604     (ASE_EVA | ASE_MSA | ASE_MSA64 | ASE_XPA | ASE_VIRT | ASE_VIRT64
605      | ASE_MCU | ASE_MT | ASE_DSP | ASE_DSPR2 | ASE_DSPR3),
606     mips_cp0_names_mips3264r2,
607     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
608     mips_cp1_names_mips3264, mips_hwr_names_mips3264r2 },
609
610   { "sb1",      1, bfd_mach_mips_sb1, CPU_SB1,
611     ISA_MIPS64 | INSN_SB1,  ASE_MIPS3D,
612     mips_cp0_names_sb1,
613     mips_cp0sel_names_sb1, ARRAY_SIZE (mips_cp0sel_names_sb1),
614     mips_cp1_names_mips3264, mips_hwr_names_numeric },
615
616   { "loongson2e",   1, bfd_mach_mips_loongson_2e, CPU_LOONGSON_2E,
617     ISA_MIPS3 | INSN_LOONGSON_2E, 0, mips_cp0_names_numeric,
618     NULL, 0, mips_cp1_names_numeric, mips_hwr_names_numeric },
619
620   { "loongson2f",   1, bfd_mach_mips_loongson_2f, CPU_LOONGSON_2F,
621     ISA_MIPS3 | INSN_LOONGSON_2F, 0, mips_cp0_names_numeric,
622     NULL, 0, mips_cp1_names_numeric, mips_hwr_names_numeric },
623
624   { "loongson3a",   1, bfd_mach_mips_loongson_3a, CPU_LOONGSON_3A,
625     ISA_MIPS64R2 | INSN_LOONGSON_3A, 0, mips_cp0_names_numeric,
626     NULL, 0, mips_cp1_names_mips3264, mips_hwr_names_numeric },
627
628   { "octeon",   1, bfd_mach_mips_octeon, CPU_OCTEON,
629     ISA_MIPS64R2 | INSN_OCTEON, 0, mips_cp0_names_numeric, NULL, 0,
630     mips_cp1_names_mips3264, mips_hwr_names_numeric },
631
632   { "octeon+",   1, bfd_mach_mips_octeonp, CPU_OCTEONP,
633     ISA_MIPS64R2 | INSN_OCTEONP, 0, mips_cp0_names_numeric,
634     NULL, 0, mips_cp1_names_mips3264, mips_hwr_names_numeric },
635
636   { "octeon2",   1, bfd_mach_mips_octeon2, CPU_OCTEON2,
637     ISA_MIPS64R2 | INSN_OCTEON2, 0, mips_cp0_names_numeric,
638     NULL, 0, mips_cp1_names_mips3264, mips_hwr_names_numeric },
639
640   { "octeon3",   1, bfd_mach_mips_octeon3, CPU_OCTEON3,
641     ISA_MIPS64R5 | INSN_OCTEON3, ASE_VIRT | ASE_VIRT64,
642     mips_cp0_names_numeric,
643     NULL, 0, mips_cp1_names_mips3264, mips_hwr_names_numeric },
644
645   { "xlr", 1, bfd_mach_mips_xlr, CPU_XLR,
646     ISA_MIPS64 | INSN_XLR, 0,
647     mips_cp0_names_xlr,
648     mips_cp0sel_names_xlr, ARRAY_SIZE (mips_cp0sel_names_xlr),
649     mips_cp1_names_mips3264, mips_hwr_names_numeric },
650
651   /* XLP is mostly like XLR, with the prominent exception it is being
652      MIPS64R2.  */
653   { "xlp", 1, bfd_mach_mips_xlr, CPU_XLR,
654     ISA_MIPS64R2 | INSN_XLR, 0,
655     mips_cp0_names_xlr,
656     mips_cp0sel_names_xlr, ARRAY_SIZE (mips_cp0sel_names_xlr),
657     mips_cp1_names_mips3264, mips_hwr_names_numeric },
658
659   /* This entry, mips16, is here only for ISA/processor selection; do
660      not print its name.  */
661   { "",         1, bfd_mach_mips16, CPU_MIPS16, ISA_MIPS3, 0,
662     mips_cp0_names_numeric, NULL, 0, mips_cp1_names_numeric,
663     mips_hwr_names_numeric },
664 };
665
666 /* ISA and processor type to disassemble for, and register names to use.
667    set_default_mips_dis_options and parse_mips_dis_options fill in these
668    values.  */
669 static int mips_processor;
670 static int mips_isa;
671 static int mips_ase;
672 static int micromips_ase;
673 static const char * const *mips_gpr_names;
674 static const char * const *mips_fpr_names;
675 static const char * const *mips_cp0_names;
676 static const struct mips_cp0sel_name *mips_cp0sel_names;
677 static int mips_cp0sel_names_len;
678 static const char * const *mips_cp1_names;
679 static const char * const *mips_hwr_names;
680
681 /* Other options */
682 static int no_aliases;  /* If set disassemble as most general inst.  */
683 \f
684 static const struct mips_abi_choice *
685 choose_abi_by_name (const char *name, unsigned int namelen)
686 {
687   const struct mips_abi_choice *c;
688   unsigned int i;
689
690   for (i = 0, c = NULL; i < ARRAY_SIZE (mips_abi_choices) && c == NULL; i++)
691     if (strncmp (mips_abi_choices[i].name, name, namelen) == 0
692         && strlen (mips_abi_choices[i].name) == namelen)
693       c = &mips_abi_choices[i];
694
695   return c;
696 }
697
698 static const struct mips_arch_choice *
699 choose_arch_by_name (const char *name, unsigned int namelen)
700 {
701   const struct mips_arch_choice *c = NULL;
702   unsigned int i;
703
704   for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
705     if (strncmp (mips_arch_choices[i].name, name, namelen) == 0
706         && strlen (mips_arch_choices[i].name) == namelen)
707       c = &mips_arch_choices[i];
708
709   return c;
710 }
711
712 static const struct mips_arch_choice *
713 choose_arch_by_number (unsigned long mach)
714 {
715   static unsigned long hint_bfd_mach;
716   static const struct mips_arch_choice *hint_arch_choice;
717   const struct mips_arch_choice *c;
718   unsigned int i;
719
720   /* We optimize this because even if the user specifies no
721      flags, this will be done for every instruction!  */
722   if (hint_bfd_mach == mach
723       && hint_arch_choice != NULL
724       && hint_arch_choice->bfd_mach == hint_bfd_mach)
725     return hint_arch_choice;
726
727   for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
728     {
729       if (mips_arch_choices[i].bfd_mach_valid
730           && mips_arch_choices[i].bfd_mach == mach)
731         {
732           c = &mips_arch_choices[i];
733           hint_bfd_mach = mach;
734           hint_arch_choice = c;
735         }
736     }
737   return c;
738 }
739
740 /* Check if the object uses NewABI conventions.  */
741
742 static int
743 is_newabi (Elf_Internal_Ehdr *header)
744 {
745   /* There are no old-style ABIs which use 64-bit ELF.  */
746   if (header->e_ident[EI_CLASS] == ELFCLASS64)
747     return 1;
748
749   /* If a 32-bit ELF file, n32 is a new-style ABI.  */
750   if ((header->e_flags & EF_MIPS_ABI2) != 0)
751     return 1;
752
753   return 0;
754 }
755
756 /* Check if the object has microMIPS ASE code.  */
757
758 static int
759 is_micromips (Elf_Internal_Ehdr *header)
760 {
761   if ((header->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0)
762     return 1;
763
764   return 0;
765 }
766
767 static void
768 set_default_mips_dis_options (struct disassemble_info *info)
769 {
770   const struct mips_arch_choice *chosen_arch;
771
772   /* Defaults: mipsIII/r3000 (?!), no microMIPS ASE (any compressed code
773      is MIPS16 ASE) (o)32-style ("oldabi") GPR names, and numeric FPR,
774      CP0 register, and HWR names.  */
775   mips_isa = ISA_MIPS3;
776   mips_processor = CPU_R3000;
777   micromips_ase = 0;
778   mips_ase = 0;
779   mips_gpr_names = mips_gpr_names_oldabi;
780   mips_fpr_names = mips_fpr_names_numeric;
781   mips_cp0_names = mips_cp0_names_numeric;
782   mips_cp0sel_names = NULL;
783   mips_cp0sel_names_len = 0;
784   mips_cp1_names = mips_cp1_names_numeric;
785   mips_hwr_names = mips_hwr_names_numeric;
786   no_aliases = 0;
787
788   /* Update settings according to the ELF file header flags.  */
789   if (info->flavour == bfd_target_elf_flavour && info->section != NULL)
790     {
791       Elf_Internal_Ehdr *header;
792
793       header = elf_elfheader (info->section->owner);
794       /* If an ELF "newabi" binary, use the n32/(n)64 GPR names.  */
795       if (is_newabi (header))
796         mips_gpr_names = mips_gpr_names_newabi;
797       /* If a microMIPS binary, then don't use MIPS16 bindings.  */
798       micromips_ase = is_micromips (header);
799     }
800
801   /* Set ISA, architecture, and cp0 register names as best we can.  */
802 #if ! SYMTAB_AVAILABLE
803   /* This is running out on a target machine, not in a host tool.
804      FIXME: Where does mips_target_info come from?  */
805   target_processor = mips_target_info.processor;
806   mips_isa = mips_target_info.isa;
807   mips_ase = mips_target_info.ase;
808 #else
809   chosen_arch = choose_arch_by_number (info->mach);
810   if (chosen_arch != NULL)
811     {
812       mips_processor = chosen_arch->processor;
813       mips_isa = chosen_arch->isa;
814       mips_ase = chosen_arch->ase;
815       mips_cp0_names = chosen_arch->cp0_names;
816       mips_cp0sel_names = chosen_arch->cp0sel_names;
817       mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
818       mips_cp1_names = chosen_arch->cp1_names;
819       mips_hwr_names = chosen_arch->hwr_names;
820     }
821 #endif
822 }
823
824 static void
825 parse_mips_dis_option (const char *option, unsigned int len)
826 {
827   unsigned int i, optionlen, vallen;
828   const char *val;
829   const struct mips_abi_choice *chosen_abi;
830   const struct mips_arch_choice *chosen_arch;
831
832   /* Try to match options that are simple flags */
833   if (CONST_STRNEQ (option, "no-aliases"))
834     {
835       no_aliases = 1;
836       return;
837     }
838
839   if (CONST_STRNEQ (option, "msa"))
840     {
841       mips_ase |= ASE_MSA;
842       if ((mips_isa & INSN_ISA_MASK) == ISA_MIPS64R2
843            || (mips_isa & INSN_ISA_MASK) == ISA_MIPS64R3
844            || (mips_isa & INSN_ISA_MASK) == ISA_MIPS64R5
845            || (mips_isa & INSN_ISA_MASK) == ISA_MIPS64R6)
846           mips_ase |= ASE_MSA64;
847       return;
848     }
849
850   if (CONST_STRNEQ (option, "virt"))
851     {
852       mips_ase |= ASE_VIRT;
853       if (mips_isa & ISA_MIPS64R2
854           || mips_isa & ISA_MIPS64R3
855           || mips_isa & ISA_MIPS64R5
856           || mips_isa & ISA_MIPS64R6)
857         mips_ase |= ASE_VIRT64;
858       return;
859     }
860
861   if (CONST_STRNEQ (option, "xpa"))
862     {
863       mips_ase |= ASE_XPA;
864       return;
865     }
866
867
868   /* Look for the = that delimits the end of the option name.  */
869   for (i = 0; i < len; i++)
870     if (option[i] == '=')
871       break;
872
873   if (i == 0)           /* Invalid option: no name before '='.  */
874     return;
875   if (i == len)         /* Invalid option: no '='.  */
876     return;
877   if (i == (len - 1))   /* Invalid option: no value after '='.  */
878     return;
879
880   optionlen = i;
881   val = option + (optionlen + 1);
882   vallen = len - (optionlen + 1);
883
884   if (strncmp ("gpr-names", option, optionlen) == 0
885       && strlen ("gpr-names") == optionlen)
886     {
887       chosen_abi = choose_abi_by_name (val, vallen);
888       if (chosen_abi != NULL)
889         mips_gpr_names = chosen_abi->gpr_names;
890       return;
891     }
892
893   if (strncmp ("fpr-names", option, optionlen) == 0
894       && strlen ("fpr-names") == optionlen)
895     {
896       chosen_abi = choose_abi_by_name (val, vallen);
897       if (chosen_abi != NULL)
898         mips_fpr_names = chosen_abi->fpr_names;
899       return;
900     }
901
902   if (strncmp ("cp0-names", option, optionlen) == 0
903       && strlen ("cp0-names") == optionlen)
904     {
905       chosen_arch = choose_arch_by_name (val, vallen);
906       if (chosen_arch != NULL)
907         {
908           mips_cp0_names = chosen_arch->cp0_names;
909           mips_cp0sel_names = chosen_arch->cp0sel_names;
910           mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
911         }
912       return;
913     }
914
915   if (strncmp ("cp1-names", option, optionlen) == 0
916       && strlen ("cp1-names") == optionlen)
917     {
918       chosen_arch = choose_arch_by_name (val, vallen);
919       if (chosen_arch != NULL)
920         mips_cp1_names = chosen_arch->cp1_names;
921       return;
922     }
923
924   if (strncmp ("hwr-names", option, optionlen) == 0
925       && strlen ("hwr-names") == optionlen)
926     {
927       chosen_arch = choose_arch_by_name (val, vallen);
928       if (chosen_arch != NULL)
929         mips_hwr_names = chosen_arch->hwr_names;
930       return;
931     }
932
933   if (strncmp ("reg-names", option, optionlen) == 0
934       && strlen ("reg-names") == optionlen)
935     {
936       /* We check both ABI and ARCH here unconditionally, so
937          that "numeric" will do the desirable thing: select
938          numeric register names for all registers.  Other than
939          that, a given name probably won't match both.  */
940       chosen_abi = choose_abi_by_name (val, vallen);
941       if (chosen_abi != NULL)
942         {
943           mips_gpr_names = chosen_abi->gpr_names;
944           mips_fpr_names = chosen_abi->fpr_names;
945         }
946       chosen_arch = choose_arch_by_name (val, vallen);
947       if (chosen_arch != NULL)
948         {
949           mips_cp0_names = chosen_arch->cp0_names;
950           mips_cp0sel_names = chosen_arch->cp0sel_names;
951           mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
952           mips_cp1_names = chosen_arch->cp1_names;
953           mips_hwr_names = chosen_arch->hwr_names;
954         }
955       return;
956     }
957
958   /* Invalid option.  */
959 }
960
961 static void
962 parse_mips_dis_options (const char *options)
963 {
964   const char *option_end;
965
966   if (options == NULL)
967     return;
968
969   while (*options != '\0')
970     {
971       /* Skip empty options.  */
972       if (*options == ',')
973         {
974           options++;
975           continue;
976         }
977
978       /* We know that *options is neither NUL or a comma.  */
979       option_end = options + 1;
980       while (*option_end != ',' && *option_end != '\0')
981         option_end++;
982
983       parse_mips_dis_option (options, option_end - options);
984
985       /* Go on to the next one.  If option_end points to a comma, it
986          will be skipped above.  */
987       options = option_end;
988     }
989 }
990
991 static const struct mips_cp0sel_name *
992 lookup_mips_cp0sel_name (const struct mips_cp0sel_name *names,
993                          unsigned int len,
994                          unsigned int cp0reg,
995                          unsigned int sel)
996 {
997   unsigned int i;
998
999   for (i = 0; i < len; i++)
1000     if (names[i].cp0reg == cp0reg && names[i].sel == sel)
1001       return &names[i];
1002   return NULL;
1003 }
1004
1005 /* Print register REGNO, of type TYPE, for instruction OPCODE.  */
1006
1007 static void
1008 print_reg (struct disassemble_info *info, const struct mips_opcode *opcode,
1009            enum mips_reg_operand_type type, int regno)
1010 {
1011   switch (type)
1012     {
1013     case OP_REG_GP:
1014       info->fprintf_func (info->stream, "%s", mips_gpr_names[regno]);
1015       break;
1016
1017     case OP_REG_FP:
1018       info->fprintf_func (info->stream, "%s", mips_fpr_names[regno]);
1019       break;
1020
1021     case OP_REG_CCC:
1022       if (opcode->pinfo & (FP_D | FP_S))
1023         info->fprintf_func (info->stream, "$fcc%d", regno);
1024       else
1025         info->fprintf_func (info->stream, "$cc%d", regno);
1026       break;
1027
1028     case OP_REG_VEC:
1029       if (opcode->membership & INSN_5400)
1030         info->fprintf_func (info->stream, "$f%d", regno);
1031       else
1032         info->fprintf_func (info->stream, "$v%d", regno);
1033       break;
1034
1035     case OP_REG_ACC:
1036       info->fprintf_func (info->stream, "$ac%d", regno);
1037       break;
1038
1039     case OP_REG_COPRO:
1040       if (opcode->name[strlen (opcode->name) - 1] == '0')
1041         info->fprintf_func (info->stream, "%s", mips_cp0_names[regno]);
1042       else if (opcode->name[strlen (opcode->name) - 1] == '1')
1043         info->fprintf_func (info->stream, "%s", mips_cp1_names[regno]);
1044       else
1045         info->fprintf_func (info->stream, "$%d", regno);
1046       break;
1047
1048     case OP_REG_HW:
1049       info->fprintf_func (info->stream, "%s", mips_hwr_names[regno]);
1050       break;
1051
1052     case OP_REG_VF:
1053       info->fprintf_func (info->stream, "$vf%d", regno);
1054       break;
1055
1056     case OP_REG_VI:
1057       info->fprintf_func (info->stream, "$vi%d", regno);
1058       break;
1059
1060     case OP_REG_R5900_I:
1061       info->fprintf_func (info->stream, "$I");
1062       break;
1063
1064     case OP_REG_R5900_Q:
1065       info->fprintf_func (info->stream, "$Q");
1066       break;
1067
1068     case OP_REG_R5900_R:
1069       info->fprintf_func (info->stream, "$R");
1070       break;
1071
1072     case OP_REG_R5900_ACC:
1073       info->fprintf_func (info->stream, "$ACC");
1074       break;
1075
1076     case OP_REG_MSA:
1077       info->fprintf_func (info->stream, "$w%d", regno);
1078       break;
1079
1080     case OP_REG_MSA_CTRL:
1081       info->fprintf_func (info->stream, "%s", msa_control_names[regno]);
1082       break;
1083
1084     }
1085 }
1086 \f
1087 /* Used to track the state carried over from previous operands in
1088    an instruction.  */
1089 struct mips_print_arg_state {
1090   /* The value of the last OP_INT seen.  We only use this for OP_MSB,
1091      where the value is known to be unsigned and small.  */
1092   unsigned int last_int;
1093
1094   /* The type and number of the last OP_REG seen.  We only use this for
1095      OP_REPEAT_DEST_REG and OP_REPEAT_PREV_REG.  */
1096   enum mips_reg_operand_type last_reg_type;
1097   unsigned int last_regno;
1098   unsigned int dest_regno;
1099   unsigned int seen_dest;
1100 };
1101
1102 /* Initialize STATE for the start of an instruction.  */
1103
1104 static inline void
1105 init_print_arg_state (struct mips_print_arg_state *state)
1106 {
1107   memset (state, 0, sizeof (*state));
1108 }
1109
1110 /* Print OP_VU0_SUFFIX or OP_VU0_MATCH_SUFFIX operand OPERAND,
1111    whose value is given by UVAL.  */
1112
1113 static void
1114 print_vu0_channel (struct disassemble_info *info,
1115                    const struct mips_operand *operand, unsigned int uval)
1116 {
1117   if (operand->size == 4)
1118     info->fprintf_func (info->stream, "%s%s%s%s",
1119                         uval & 8 ? "x" : "",
1120                         uval & 4 ? "y" : "",
1121                         uval & 2 ? "z" : "",
1122                         uval & 1 ? "w" : "");
1123   else if (operand->size == 2)
1124     info->fprintf_func (info->stream, "%c", "xyzw"[uval]);
1125   else
1126     abort ();
1127 }
1128
1129 /* Record information about a register operand.  */
1130
1131 static void
1132 mips_seen_register (struct mips_print_arg_state *state,
1133                     unsigned int regno,
1134                     enum mips_reg_operand_type reg_type)
1135 {
1136   state->last_reg_type = reg_type;
1137   state->last_regno = regno;
1138
1139   if (!state->seen_dest)
1140     {
1141       state->seen_dest = 1;
1142       state->dest_regno = regno;
1143     }
1144 }
1145
1146 /* Print operand OPERAND of OPCODE, using STATE to track inter-operand state.
1147    UVAL is the encoding of the operand (shifted into bit 0) and BASE_PC is
1148    the base address for OP_PCREL operands.  */
1149
1150 static void
1151 print_insn_arg (struct disassemble_info *info,
1152                 struct mips_print_arg_state *state,
1153                 const struct mips_opcode *opcode,
1154                 const struct mips_operand *operand,
1155                 bfd_vma base_pc,
1156                 unsigned int uval)
1157 {
1158   const fprintf_ftype infprintf = info->fprintf_func;
1159   void *is = info->stream;
1160
1161   switch (operand->type)
1162     {
1163     case OP_INT:
1164       {
1165         const struct mips_int_operand *int_op;
1166
1167         int_op = (const struct mips_int_operand *) operand;
1168         uval = mips_decode_int_operand (int_op, uval);
1169         state->last_int = uval;
1170         if (int_op->print_hex)
1171           infprintf (is, "0x%x", uval);
1172         else
1173           infprintf (is, "%d", uval);
1174       }
1175       break;
1176
1177     case OP_MAPPED_INT:
1178       {
1179         const struct mips_mapped_int_operand *mint_op;
1180
1181         mint_op = (const struct mips_mapped_int_operand *) operand;
1182         uval = mint_op->int_map[uval];
1183         state->last_int = uval;
1184         if (mint_op->print_hex)
1185           infprintf (is, "0x%x", uval);
1186         else
1187           infprintf (is, "%d", uval);
1188       }
1189       break;
1190
1191     case OP_MSB:
1192       {
1193         const struct mips_msb_operand *msb_op;
1194
1195         msb_op = (const struct mips_msb_operand *) operand;
1196         uval += msb_op->bias;
1197         if (msb_op->add_lsb)
1198           uval -= state->last_int;
1199         infprintf (is, "0x%x", uval);
1200       }
1201       break;
1202
1203     case OP_REG:
1204     case OP_OPTIONAL_REG:
1205       {
1206         const struct mips_reg_operand *reg_op;
1207
1208         reg_op = (const struct mips_reg_operand *) operand;
1209         uval = mips_decode_reg_operand (reg_op, uval);
1210         print_reg (info, opcode, reg_op->reg_type, uval);
1211
1212         mips_seen_register (state, uval, reg_op->reg_type);
1213       }
1214       break;
1215
1216     case OP_REG_PAIR:
1217       {
1218         const struct mips_reg_pair_operand *pair_op;
1219
1220         pair_op = (const struct mips_reg_pair_operand *) operand;
1221         print_reg (info, opcode, pair_op->reg_type,
1222                    pair_op->reg1_map[uval]);
1223         infprintf (is, ",");
1224         print_reg (info, opcode, pair_op->reg_type,
1225                    pair_op->reg2_map[uval]);
1226       }
1227       break;
1228
1229     case OP_PCREL:
1230       {
1231         const struct mips_pcrel_operand *pcrel_op;
1232
1233         pcrel_op = (const struct mips_pcrel_operand *) operand;
1234         info->target = mips_decode_pcrel_operand (pcrel_op, base_pc, uval);
1235
1236         /* Preserve the ISA bit for the GDB disassembler,
1237            otherwise clear it.  */
1238         if (info->flavour != bfd_target_unknown_flavour)
1239           info->target &= -2;
1240
1241         (*info->print_address_func) (info->target, info);
1242       }
1243       break;
1244
1245     case OP_PERF_REG:
1246       infprintf (is, "%d", uval);
1247       break;
1248
1249     case OP_ADDIUSP_INT:
1250       {
1251         int sval;
1252
1253         sval = mips_signed_operand (operand, uval) * 4;
1254         if (sval >= -8 && sval < 8)
1255           sval ^= 0x400;
1256         infprintf (is, "%d", sval);
1257         break;
1258       }
1259
1260     case OP_CLO_CLZ_DEST:
1261       {
1262         unsigned int reg1, reg2;
1263
1264         reg1 = uval & 31;
1265         reg2 = uval >> 5;
1266         /* If one is zero use the other.  */
1267         if (reg1 == reg2 || reg2 == 0)
1268           infprintf (is, "%s", mips_gpr_names[reg1]);
1269         else if (reg1 == 0)
1270           infprintf (is, "%s", mips_gpr_names[reg2]);
1271         else
1272           /* Bogus, result depends on processor.  */
1273           infprintf (is, "%s or %s", mips_gpr_names[reg1],
1274                      mips_gpr_names[reg2]);
1275       }
1276       break;
1277
1278     case OP_SAME_RS_RT:
1279     case OP_CHECK_PREV:
1280     case OP_NON_ZERO_REG:
1281       {
1282         print_reg (info, opcode, OP_REG_GP, uval & 31);
1283         mips_seen_register (state, uval, OP_REG_GP);
1284       }
1285       break;
1286
1287     case OP_LWM_SWM_LIST:
1288       if (operand->size == 2)
1289         {
1290           if (uval == 0)
1291             infprintf (is, "%s,%s",
1292                        mips_gpr_names[16],
1293                        mips_gpr_names[31]);
1294           else
1295             infprintf (is, "%s-%s,%s",
1296                        mips_gpr_names[16],
1297                        mips_gpr_names[16 + uval],
1298                        mips_gpr_names[31]);
1299         }
1300       else
1301         {
1302           int s_reg_encode;
1303
1304           s_reg_encode = uval & 0xf;
1305           if (s_reg_encode != 0)
1306             {
1307               if (s_reg_encode == 1)
1308                 infprintf (is, "%s", mips_gpr_names[16]);
1309               else if (s_reg_encode < 9)
1310                 infprintf (is, "%s-%s",
1311                            mips_gpr_names[16],
1312                            mips_gpr_names[15 + s_reg_encode]);
1313               else if (s_reg_encode == 9)
1314                 infprintf (is, "%s-%s,%s",
1315                            mips_gpr_names[16],
1316                            mips_gpr_names[23],
1317                            mips_gpr_names[30]);
1318               else
1319                 infprintf (is, "UNKNOWN");
1320             }
1321
1322           if (uval & 0x10) /* For ra.  */
1323             {
1324               if (s_reg_encode == 0)
1325                 infprintf (is, "%s", mips_gpr_names[31]);
1326               else
1327                 infprintf (is, ",%s", mips_gpr_names[31]);
1328             }
1329         }
1330       break;
1331
1332     case OP_ENTRY_EXIT_LIST:
1333       {
1334         const char *sep;
1335         unsigned int amask, smask;
1336
1337         sep = "";
1338         amask = (uval >> 3) & 7;
1339         if (amask > 0 && amask < 5)
1340           {
1341             infprintf (is, "%s", mips_gpr_names[4]);
1342             if (amask > 1)
1343               infprintf (is, "-%s", mips_gpr_names[amask + 3]);
1344             sep = ",";
1345           }
1346
1347         smask = (uval >> 1) & 3;
1348         if (smask == 3)
1349           {
1350             infprintf (is, "%s??", sep);
1351             sep = ",";
1352           }
1353         else if (smask > 0)
1354           {
1355             infprintf (is, "%s%s", sep, mips_gpr_names[16]);
1356             if (smask > 1)
1357               infprintf (is, "-%s", mips_gpr_names[smask + 15]);
1358             sep = ",";
1359           }
1360
1361         if (uval & 1)
1362           {
1363             infprintf (is, "%s%s", sep, mips_gpr_names[31]);
1364             sep = ",";
1365           }
1366
1367         if (amask == 5 || amask == 6)
1368           {
1369             infprintf (is, "%s%s", sep, mips_fpr_names[0]);
1370             if (amask == 6)
1371               infprintf (is, "-%s", mips_fpr_names[1]);
1372           }
1373       }
1374       break;
1375
1376     case OP_SAVE_RESTORE_LIST:
1377       /* Should be handled by the caller due to extend behavior.  */
1378       abort ();
1379
1380     case OP_MDMX_IMM_REG:
1381       {
1382         unsigned int vsel;
1383
1384         vsel = uval >> 5;
1385         uval &= 31;
1386         if ((vsel & 0x10) == 0)
1387           {
1388             int fmt;
1389
1390             vsel &= 0x0f;
1391             for (fmt = 0; fmt < 3; fmt++, vsel >>= 1)
1392               if ((vsel & 1) == 0)
1393                 break;
1394             print_reg (info, opcode, OP_REG_VEC, uval);
1395             infprintf (is, "[%d]", vsel >> 1);
1396           }
1397         else if ((vsel & 0x08) == 0)
1398           print_reg (info, opcode, OP_REG_VEC, uval);
1399         else
1400           infprintf (is, "0x%x", uval);
1401       }
1402       break;
1403
1404     case OP_REPEAT_PREV_REG:
1405       print_reg (info, opcode, state->last_reg_type, state->last_regno);
1406       break;
1407
1408     case OP_REPEAT_DEST_REG:
1409       print_reg (info, opcode, state->last_reg_type, state->dest_regno);
1410       break;
1411
1412     case OP_PC:
1413       infprintf (is, "$pc");
1414       break;
1415
1416     case OP_VU0_SUFFIX:
1417     case OP_VU0_MATCH_SUFFIX:
1418       print_vu0_channel (info, operand, uval);
1419       break;
1420
1421     case OP_IMM_INDEX:
1422       infprintf (is, "[%d]", uval);
1423       break;
1424
1425     case OP_REG_INDEX:
1426       infprintf (is, "[");
1427       print_reg (info, opcode, OP_REG_GP, uval);
1428       infprintf (is, "]");
1429       break;
1430     }
1431 }
1432
1433 /* Validate the arguments for INSN, which is described by OPCODE.
1434    Use DECODE_OPERAND to get the encoding of each operand.  */
1435
1436 static bfd_boolean
1437 validate_insn_args (const struct mips_opcode *opcode,
1438                     const struct mips_operand *(*decode_operand) (const char *),
1439                     unsigned int insn)
1440 {
1441   struct mips_print_arg_state state;
1442   const struct mips_operand *operand;
1443   const char *s;
1444   unsigned int uval;
1445
1446   init_print_arg_state (&state);
1447   for (s = opcode->args; *s; ++s)
1448     {
1449       switch (*s)
1450         {
1451         case ',':
1452         case '(':
1453         case ')':
1454           break;
1455
1456         case '#':
1457           ++s;
1458           break;
1459
1460         default:
1461           operand = decode_operand (s);
1462
1463           if (operand)
1464             {
1465               uval = mips_extract_operand (operand, insn);
1466               switch (operand->type)
1467                 {
1468                 case OP_REG:
1469                 case OP_OPTIONAL_REG:
1470                   {
1471                     const struct mips_reg_operand *reg_op;
1472
1473                     reg_op = (const struct mips_reg_operand *) operand;
1474                     uval = mips_decode_reg_operand (reg_op, uval);
1475                     mips_seen_register (&state, uval, reg_op->reg_type);
1476                   }
1477                 break;
1478
1479                 case OP_SAME_RS_RT:
1480                   {
1481                     unsigned int reg1, reg2;
1482
1483                     reg1 = uval & 31;
1484                     reg2 = uval >> 5;
1485
1486                     if (reg1 != reg2 || reg1 == 0)
1487                       return FALSE;
1488                   }
1489                 break;
1490
1491                 case OP_CHECK_PREV:
1492                   {
1493                     const struct mips_check_prev_operand *prev_op;
1494
1495                     prev_op = (const struct mips_check_prev_operand *) operand;
1496
1497                     if (!prev_op->zero_ok && uval == 0)
1498                       return FALSE;
1499
1500                     if (((prev_op->less_than_ok && uval < state.last_regno)
1501                         || (prev_op->greater_than_ok && uval > state.last_regno)
1502                         || (prev_op->equal_ok && uval == state.last_regno)))
1503                       break;
1504
1505                     return FALSE;
1506                   }
1507
1508                 case OP_NON_ZERO_REG:
1509                   {
1510                     if (uval == 0)
1511                       return FALSE;
1512                   }
1513                 break;
1514
1515                 case OP_INT:
1516                 case OP_MAPPED_INT:
1517                 case OP_MSB:
1518                 case OP_REG_PAIR:
1519                 case OP_PCREL:
1520                 case OP_PERF_REG:
1521                 case OP_ADDIUSP_INT:
1522                 case OP_CLO_CLZ_DEST:
1523                 case OP_LWM_SWM_LIST:
1524                 case OP_ENTRY_EXIT_LIST:
1525                 case OP_MDMX_IMM_REG:
1526                 case OP_REPEAT_PREV_REG:
1527                 case OP_REPEAT_DEST_REG:
1528                 case OP_PC:
1529                 case OP_VU0_SUFFIX:
1530                 case OP_VU0_MATCH_SUFFIX:
1531                 case OP_IMM_INDEX:
1532                 case OP_REG_INDEX:
1533                   break;
1534
1535                 case OP_SAVE_RESTORE_LIST:
1536                 /* Should be handled by the caller due to extend behavior.  */
1537                   abort ();
1538                 }
1539             }
1540           if (*s == 'm' || *s == '+' || *s == '-')
1541             ++s;
1542         }
1543     }
1544   return TRUE;
1545 }
1546
1547 /* Print the arguments for INSN, which is described by OPCODE.
1548    Use DECODE_OPERAND to get the encoding of each operand.  Use BASE_PC
1549    as the base of OP_PCREL operands, adjusting by LENGTH if the OP_PCREL
1550    operand is for a branch or jump.  */
1551
1552 static void
1553 print_insn_args (struct disassemble_info *info,
1554                  const struct mips_opcode *opcode,
1555                  const struct mips_operand *(*decode_operand) (const char *),
1556                  unsigned int insn, bfd_vma insn_pc, unsigned int length)
1557 {
1558   const fprintf_ftype infprintf = info->fprintf_func;
1559   void *is = info->stream;
1560   struct mips_print_arg_state state;
1561   const struct mips_operand *operand;
1562   const char *s;
1563
1564   init_print_arg_state (&state);
1565   for (s = opcode->args; *s; ++s)
1566     {
1567       switch (*s)
1568         {
1569         case ',':
1570         case '(':
1571         case ')':
1572           infprintf (is, "%c", *s);
1573           break;
1574
1575         case '#':
1576           ++s;
1577           infprintf (is, "%c%c", *s, *s);
1578           break;
1579
1580         default:
1581           operand = decode_operand (s);
1582           if (!operand)
1583             {
1584               /* xgettext:c-format */
1585               infprintf (is,
1586                          _("# internal error, undefined operand in `%s %s'"),
1587                          opcode->name, opcode->args);
1588               return;
1589             }
1590           if (operand->type == OP_REG
1591               && s[1] == ','
1592               && s[2] == 'H'
1593               && opcode->name[strlen (opcode->name) - 1] == '0')
1594             {
1595               /* Coprocessor register 0 with sel field (MT ASE).  */
1596               const struct mips_cp0sel_name *n;
1597               unsigned int reg, sel;
1598
1599               reg = mips_extract_operand (operand, insn);
1600               s += 2;
1601               operand = decode_operand (s);
1602               sel = mips_extract_operand (operand, insn);
1603
1604               /* CP0 register including 'sel' code for mftc0, to be
1605                  printed textually if known.  If not known, print both
1606                  CP0 register name and sel numerically since CP0 register
1607                  with sel 0 may have a name unrelated to register being
1608                  printed.  */
1609               n = lookup_mips_cp0sel_name (mips_cp0sel_names,
1610                                            mips_cp0sel_names_len,
1611                                            reg, sel);
1612               if (n != NULL)
1613                 infprintf (is, "%s", n->name);
1614               else
1615                 infprintf (is, "$%d,%d", reg, sel);
1616             }
1617           else
1618             {
1619               bfd_vma base_pc = insn_pc;
1620
1621               /* Adjust the PC relative base so that branch/jump insns use
1622                  the following PC as the base but genuinely PC relative
1623                  operands use the current PC.  */
1624               if (operand->type == OP_PCREL)
1625                 {
1626                   const struct mips_pcrel_operand *pcrel_op;
1627
1628                   pcrel_op = (const struct mips_pcrel_operand *) operand;
1629                   /* The include_isa_bit flag is sufficient to distinguish
1630                      branch/jump from other PC relative operands.  */
1631                   if (pcrel_op->include_isa_bit)
1632                     base_pc += length;
1633                 }
1634
1635               print_insn_arg (info, &state, opcode, operand, base_pc,
1636                               mips_extract_operand (operand, insn));
1637             }
1638           if (*s == 'm' || *s == '+' || *s == '-')
1639             ++s;
1640           break;
1641         }
1642     }
1643 }
1644 \f
1645 /* Print the mips instruction at address MEMADDR in debugged memory,
1646    on using INFO.  Returns length of the instruction, in bytes, which is
1647    always INSNLEN.  BIGENDIAN must be 1 if this is big-endian code, 0 if
1648    this is little-endian code.  */
1649
1650 static int
1651 print_insn_mips (bfd_vma memaddr,
1652                  int word,
1653                  struct disassemble_info *info)
1654 {
1655 #define GET_OP(insn, field)                     \
1656   (((insn) >> OP_SH_##field) & OP_MASK_##field)
1657   static const struct mips_opcode *mips_hash[OP_MASK_OP + 1];
1658   const fprintf_ftype infprintf = info->fprintf_func;
1659   const struct mips_opcode *op;
1660   static bfd_boolean init = 0;
1661   void *is = info->stream;
1662
1663   /* Build a hash table to shorten the search time.  */
1664   if (! init)
1665     {
1666       unsigned int i;
1667
1668       for (i = 0; i <= OP_MASK_OP; i++)
1669         {
1670           for (op = mips_opcodes; op < &mips_opcodes[NUMOPCODES]; op++)
1671             {
1672               if (op->pinfo == INSN_MACRO
1673                   || (no_aliases && (op->pinfo2 & INSN2_ALIAS)))
1674                 continue;
1675               if (i == GET_OP (op->match, OP))
1676                 {
1677                   mips_hash[i] = op;
1678                   break;
1679                 }
1680             }
1681         }
1682
1683       init = 1;
1684     }
1685
1686   info->bytes_per_chunk = INSNLEN;
1687   info->display_endian = info->endian;
1688   info->insn_info_valid = 1;
1689   info->branch_delay_insns = 0;
1690   info->data_size = 0;
1691   info->insn_type = dis_nonbranch;
1692   info->target = 0;
1693   info->target2 = 0;
1694
1695   op = mips_hash[GET_OP (word, OP)];
1696   if (op != NULL)
1697     {
1698       for (; op < &mips_opcodes[NUMOPCODES]; op++)
1699         {
1700           if (op->pinfo != INSN_MACRO
1701               && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
1702               && (word & op->mask) == op->match)
1703             {
1704               /* We always disassemble the jalx instruction, except for MIPS r6.  */
1705               if (!opcode_is_member (op, mips_isa, mips_ase, mips_processor)
1706                  && (strcmp (op->name, "jalx")
1707                      || (mips_isa & INSN_ISA_MASK) == ISA_MIPS32R6
1708                      || (mips_isa & INSN_ISA_MASK) == ISA_MIPS64R6))
1709                 continue;
1710
1711               /* Figure out instruction type and branch delay information.  */
1712               if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
1713                 {
1714                   if ((op->pinfo & (INSN_WRITE_GPR_31 | INSN_WRITE_1)) != 0)
1715                     info->insn_type = dis_jsr;
1716                   else
1717                     info->insn_type = dis_branch;
1718                   info->branch_delay_insns = 1;
1719                 }
1720               else if ((op->pinfo & (INSN_COND_BRANCH_DELAY
1721                                      | INSN_COND_BRANCH_LIKELY)) != 0)
1722                 {
1723                   if ((op->pinfo & INSN_WRITE_GPR_31) != 0)
1724                     info->insn_type = dis_condjsr;
1725                   else
1726                     info->insn_type = dis_condbranch;
1727                   info->branch_delay_insns = 1;
1728                 }
1729               else if ((op->pinfo & (INSN_STORE_MEMORY
1730                                      | INSN_LOAD_MEMORY)) != 0)
1731                 info->insn_type = dis_dref;
1732
1733               if (!validate_insn_args (op, decode_mips_operand, word))
1734                 continue;
1735
1736               infprintf (is, "%s", op->name);
1737               if (op->pinfo2 & INSN2_VU0_CHANNEL_SUFFIX)
1738                 {
1739                   unsigned int uval;
1740
1741                   infprintf (is, ".");
1742                   uval = mips_extract_operand (&mips_vu0_channel_mask, word);
1743                   print_vu0_channel (info, &mips_vu0_channel_mask, uval);
1744                 }
1745
1746               if (op->args[0])
1747                 {
1748                   infprintf (is, "\t");
1749                   print_insn_args (info, op, decode_mips_operand, word,
1750                                    memaddr, 4);
1751                 }
1752
1753               return INSNLEN;
1754             }
1755         }
1756     }
1757 #undef GET_OP
1758
1759   /* Handle undefined instructions.  */
1760   info->insn_type = dis_noninsn;
1761   infprintf (is, "0x%x", word);
1762   return INSNLEN;
1763 }
1764 \f
1765 /* Disassemble an operand for a mips16 instruction.  */
1766
1767 static void
1768 print_mips16_insn_arg (struct disassemble_info *info,
1769                        struct mips_print_arg_state *state,
1770                        const struct mips_opcode *opcode,
1771                        char type, bfd_vma memaddr,
1772                        unsigned insn, bfd_boolean use_extend,
1773                        unsigned extend, bfd_boolean is_offset)
1774 {
1775   const fprintf_ftype infprintf = info->fprintf_func;
1776   void *is = info->stream;
1777   const struct mips_operand *operand, *ext_operand;
1778   unsigned int uval;
1779   bfd_vma baseaddr;
1780
1781   if (!use_extend)
1782     extend = 0;
1783
1784   switch (type)
1785     {
1786     case ',':
1787     case '(':
1788     case ')':
1789       infprintf (is, "%c", type);
1790       break;
1791
1792     default:
1793       operand = decode_mips16_operand (type, FALSE);
1794       if (!operand)
1795         {
1796           /* xgettext:c-format */
1797           infprintf (is, _("# internal error, undefined operand in `%s %s'"),
1798                      opcode->name, opcode->args);
1799           return;
1800         }
1801
1802       if (operand->type == OP_SAVE_RESTORE_LIST)
1803         {
1804           /* Handle this case here because of the complex interaction
1805              with the EXTEND opcode.  */
1806           unsigned int amask, nargs, nstatics, nsreg, smask, frame_size, i, j;
1807           const char *sep;
1808
1809           amask = extend & 0xf;
1810           if (amask == MIPS16_ALL_ARGS)
1811             {
1812               nargs = 4;
1813               nstatics = 0;
1814             }
1815           else if (amask == MIPS16_ALL_STATICS)
1816             {
1817               nargs = 0;
1818               nstatics = 4;
1819             }
1820           else
1821             {
1822               nargs = amask >> 2;
1823               nstatics = amask & 3;
1824             }
1825
1826           sep = "";
1827           if (nargs > 0)
1828             {
1829               infprintf (is, "%s", mips_gpr_names[4]);
1830               if (nargs > 1)
1831                 infprintf (is, "-%s", mips_gpr_names[4 + nargs - 1]);
1832               sep = ",";
1833             }
1834
1835           frame_size = ((extend & 0xf0) | (insn & 0x0f)) * 8;
1836           if (frame_size == 0 && !use_extend)
1837             frame_size = 128;
1838           infprintf (is, "%s%d", sep, frame_size);
1839
1840           if (insn & 0x40)              /* $ra */
1841             infprintf (is, ",%s", mips_gpr_names[31]);
1842
1843           nsreg = (extend >> 8) & 0x7;
1844           smask = 0;
1845           if (insn & 0x20)              /* $s0 */
1846             smask |= 1 << 0;
1847           if (insn & 0x10)              /* $s1 */
1848             smask |= 1 << 1;
1849           if (nsreg > 0)                /* $s2-$s8 */
1850             smask |= ((1 << nsreg) - 1) << 2;
1851
1852           for (i = 0; i < 9; i++)
1853             if (smask & (1 << i))
1854               {
1855                 infprintf (is, ",%s", mips_gpr_names[i == 8 ? 30 : (16 + i)]);
1856                 /* Skip over string of set bits.  */
1857                 for (j = i; smask & (2 << j); j++)
1858                   continue;
1859                 if (j > i)
1860                   infprintf (is, "-%s", mips_gpr_names[j == 8 ? 30 : (16 + j)]);
1861                 i = j + 1;
1862               }
1863           /* Statics $ax - $a3.  */
1864           if (nstatics == 1)
1865             infprintf (is, ",%s", mips_gpr_names[7]);
1866           else if (nstatics > 0)
1867             infprintf (is, ",%s-%s",
1868                        mips_gpr_names[7 - nstatics + 1],
1869                        mips_gpr_names[7]);
1870           break;
1871         }
1872
1873       if (is_offset && operand->type == OP_INT)
1874         {
1875           const struct mips_int_operand *int_op;
1876
1877           int_op = (const struct mips_int_operand *) operand;
1878           info->insn_type = dis_dref;
1879           info->data_size = 1 << int_op->shift;
1880         }
1881
1882       if (operand->size == 26)
1883         /* In this case INSN is the first two bytes of the instruction
1884            and EXTEND is the second two bytes.  */
1885         uval = ((insn & 0x1f) << 21) | ((insn & 0x3e0) << 11) | extend;
1886       else
1887         {
1888           /* Calculate the full field value.  */
1889           uval = mips_extract_operand (operand, insn);
1890           if (use_extend)
1891             {
1892               ext_operand = decode_mips16_operand (type, TRUE);
1893               if (ext_operand != operand)
1894                 {
1895                   operand = ext_operand;
1896                   if (operand->size == 16)
1897                     uval = (((extend & 0x1f) << 11) | (extend & 0x7e0)
1898                             | (uval & 0x1f));
1899                   else if (operand->size == 15)
1900                     uval |= ((extend & 0xf) << 11) | (extend & 0x7f0);
1901                   else
1902                     uval = ((((extend >> 6) & 0x1f) | (extend & 0x20))
1903                             & ((1U << operand->size) - 1));
1904                 }
1905             }
1906         }
1907
1908       baseaddr = memaddr + 2;
1909       if (operand->type == OP_PCREL)
1910         {
1911           const struct mips_pcrel_operand *pcrel_op;
1912
1913           pcrel_op = (const struct mips_pcrel_operand *) operand;
1914           if (!pcrel_op->include_isa_bit && use_extend)
1915             baseaddr = memaddr - 2;
1916           else if (!pcrel_op->include_isa_bit)
1917              {
1918                bfd_byte buffer[2];
1919
1920                /* If this instruction is in the delay slot of a JAL/JALX
1921                   instruction, the base address is the address of the
1922                   JAL/JALX instruction.  If it is in the delay slot of
1923                   a JR/JALR instruction, the base address is the address
1924                   of the JR/JALR instruction.  This test is unreliable:
1925                   we have no way of knowing whether the previous word is
1926                   instruction or data.  */
1927                if (info->read_memory_func (memaddr - 4, buffer, 2, info) == 0
1928                    && (((info->endian == BFD_ENDIAN_BIG
1929                          ? bfd_getb16 (buffer)
1930                          : bfd_getl16 (buffer))
1931                         & 0xf800) == 0x1800))
1932                  baseaddr = memaddr - 4;
1933                else if (info->read_memory_func (memaddr - 2, buffer, 2,
1934                                                 info) == 0
1935                         && (((info->endian == BFD_ENDIAN_BIG
1936                               ? bfd_getb16 (buffer)
1937                               : bfd_getl16 (buffer))
1938                              & 0xf89f) == 0xe800)
1939                         && (((info->endian == BFD_ENDIAN_BIG
1940                               ? bfd_getb16 (buffer)
1941                               : bfd_getl16 (buffer))
1942                              & 0x0060) != 0x0060))
1943                  baseaddr = memaddr - 2;
1944                else
1945                  baseaddr = memaddr;
1946              }
1947         }
1948
1949       print_insn_arg (info, state, opcode, operand, baseaddr + 1, uval);
1950       break;
1951     }
1952 }
1953
1954
1955 /* Check if the given address is the last word of a MIPS16 PLT entry.
1956    This word is data and depending on the value it may interfere with
1957    disassembly of further PLT entries.  We make use of the fact PLT
1958    symbols are marked BSF_SYNTHETIC.  */
1959 static bfd_boolean
1960 is_mips16_plt_tail (struct disassemble_info *info, bfd_vma addr)
1961 {
1962   if (info->symbols
1963       && info->symbols[0]
1964       && (info->symbols[0]->flags & BSF_SYNTHETIC)
1965       && addr == bfd_asymbol_value (info->symbols[0]) + 12)
1966     return TRUE;
1967
1968   return FALSE;
1969 }
1970
1971 /* Disassemble mips16 instructions.  */
1972
1973 static int
1974 print_insn_mips16 (bfd_vma memaddr, struct disassemble_info *info)
1975 {
1976   const fprintf_ftype infprintf = info->fprintf_func;
1977   int status;
1978   bfd_byte buffer[4];
1979   int length;
1980   int insn;
1981   bfd_boolean use_extend;
1982   int extend = 0;
1983   const struct mips_opcode *op, *opend;
1984   struct mips_print_arg_state state;
1985   void *is = info->stream;
1986
1987   info->bytes_per_chunk = 2;
1988   info->display_endian = info->endian;
1989   info->insn_info_valid = 1;
1990   info->branch_delay_insns = 0;
1991   info->data_size = 0;
1992   info->target = 0;
1993   info->target2 = 0;
1994
1995 #define GET_OP(insn, field) \
1996   (((insn) >> MIPS16OP_SH_##field) & MIPS16OP_MASK_##field)
1997   /* Decode PLT entry's GOT slot address word.  */
1998   if (is_mips16_plt_tail (info, memaddr))
1999     {
2000       info->insn_type = dis_noninsn;
2001       status = (*info->read_memory_func) (memaddr, buffer, 4, info);
2002       if (status == 0)
2003         {
2004           unsigned int gotslot;
2005
2006           if (info->endian == BFD_ENDIAN_BIG)
2007             gotslot = bfd_getb32 (buffer);
2008           else
2009             gotslot = bfd_getl32 (buffer);
2010           infprintf (is, ".word\t0x%x", gotslot);
2011
2012           return 4;
2013         }
2014     }
2015   else
2016     {
2017       info->insn_type = dis_nonbranch;
2018       status = (*info->read_memory_func) (memaddr, buffer, 2, info);
2019     }
2020   if (status != 0)
2021     {
2022       (*info->memory_error_func) (status, memaddr, info);
2023       return -1;
2024     }
2025
2026   length = 2;
2027
2028   if (info->endian == BFD_ENDIAN_BIG)
2029     insn = bfd_getb16 (buffer);
2030   else
2031     insn = bfd_getl16 (buffer);
2032
2033   /* Handle the extend opcode specially.  */
2034   use_extend = FALSE;
2035   if ((insn & 0xf800) == 0xf000)
2036     {
2037       use_extend = TRUE;
2038       extend = insn & 0x7ff;
2039
2040       memaddr += 2;
2041
2042       status = (*info->read_memory_func) (memaddr, buffer, 2, info);
2043       if (status != 0)
2044         {
2045           infprintf (is, "extend 0x%x", (unsigned int) extend);
2046           (*info->memory_error_func) (status, memaddr, info);
2047           return -1;
2048         }
2049
2050       if (info->endian == BFD_ENDIAN_BIG)
2051         insn = bfd_getb16 (buffer);
2052       else
2053         insn = bfd_getl16 (buffer);
2054
2055       /* Check for an extend opcode followed by an extend opcode.  */
2056       if ((insn & 0xf800) == 0xf000)
2057         {
2058           infprintf (is, "extend 0x%x", (unsigned int) extend);
2059           info->insn_type = dis_noninsn;
2060           return length;
2061         }
2062
2063       length += 2;
2064     }
2065
2066   /* FIXME: Should probably use a hash table on the major opcode here.  */
2067
2068   opend = mips16_opcodes + bfd_mips16_num_opcodes;
2069   for (op = mips16_opcodes; op < opend; op++)
2070     {
2071       if (op->pinfo != INSN_MACRO
2072           && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
2073           && (insn & op->mask) == op->match)
2074         {
2075           const char *s;
2076
2077           if (op->args[0] == 'a' || op->args[0] == 'i')
2078             {
2079               if (use_extend)
2080                 {
2081                   infprintf (is, "extend 0x%x", (unsigned int) extend);
2082                   info->insn_type = dis_noninsn;
2083                   return length - 2;
2084                 }
2085
2086               use_extend = FALSE;
2087
2088               memaddr += 2;
2089
2090               status = (*info->read_memory_func) (memaddr, buffer, 2,
2091                                                   info);
2092               if (status == 0)
2093                 {
2094                   use_extend = TRUE;
2095                   if (info->endian == BFD_ENDIAN_BIG)
2096                     extend = bfd_getb16 (buffer);
2097                   else
2098                     extend = bfd_getl16 (buffer);
2099                   length += 2;
2100                 }
2101             }
2102
2103           infprintf (is, "%s", op->name);
2104           if (op->args[0] != '\0')
2105             infprintf (is, "\t");
2106
2107           init_print_arg_state (&state);
2108           for (s = op->args; *s != '\0'; s++)
2109             {
2110               if (*s == ','
2111                   && s[1] == 'w'
2112                   && GET_OP (insn, RX) == GET_OP (insn, RY))
2113                 {
2114                   /* Skip the register and the comma.  */
2115                   ++s;
2116                   continue;
2117                 }
2118               if (*s == ','
2119                   && s[1] == 'v'
2120                   && GET_OP (insn, RZ) == GET_OP (insn, RX))
2121                 {
2122                   /* Skip the register and the comma.  */
2123                   ++s;
2124                   continue;
2125                 }
2126               print_mips16_insn_arg (info, &state, op, *s, memaddr, insn,
2127                                      use_extend, extend, s[1] == '(');
2128             }
2129
2130           /* Figure out branch instruction type and delay slot information.  */
2131           if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
2132             info->branch_delay_insns = 1;
2133           if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0
2134               || (op->pinfo2 & INSN2_UNCOND_BRANCH) != 0)
2135             {
2136               if ((op->pinfo & INSN_WRITE_GPR_31) != 0)
2137                 info->insn_type = dis_jsr;
2138               else
2139                 info->insn_type = dis_branch;
2140             }
2141           else if ((op->pinfo2 & INSN2_COND_BRANCH) != 0)
2142             info->insn_type = dis_condbranch;
2143
2144           return length;
2145         }
2146     }
2147 #undef GET_OP
2148
2149   if (use_extend)
2150     infprintf (is, "0x%x", extend | 0xf000);
2151   infprintf (is, "0x%x", insn);
2152   info->insn_type = dis_noninsn;
2153
2154   return length;
2155 }
2156
2157 /* Disassemble microMIPS instructions.  */
2158
2159 static int
2160 print_insn_micromips (bfd_vma memaddr, struct disassemble_info *info)
2161 {
2162   const fprintf_ftype infprintf = info->fprintf_func;
2163   const struct mips_opcode *op, *opend;
2164   void *is = info->stream;
2165   bfd_byte buffer[2];
2166   unsigned int higher;
2167   unsigned int length;
2168   int status;
2169   unsigned int insn;
2170
2171   info->bytes_per_chunk = 2;
2172   info->display_endian = info->endian;
2173   info->insn_info_valid = 1;
2174   info->branch_delay_insns = 0;
2175   info->data_size = 0;
2176   info->insn_type = dis_nonbranch;
2177   info->target = 0;
2178   info->target2 = 0;
2179
2180   status = (*info->read_memory_func) (memaddr, buffer, 2, info);
2181   if (status != 0)
2182     {
2183       (*info->memory_error_func) (status, memaddr, info);
2184       return -1;
2185     }
2186
2187   length = 2;
2188
2189   if (info->endian == BFD_ENDIAN_BIG)
2190     insn = bfd_getb16 (buffer);
2191   else
2192     insn = bfd_getl16 (buffer);
2193
2194   if ((insn & 0x1c00) == 0x0000 || (insn & 0x1000) == 0x1000)
2195     {
2196       /* This is a 32-bit microMIPS instruction.  */
2197       higher = insn;
2198
2199       status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info);
2200       if (status != 0)
2201         {
2202           infprintf (is, "micromips 0x%x", higher);
2203           (*info->memory_error_func) (status, memaddr + 2, info);
2204           return -1;
2205         }
2206
2207       if (info->endian == BFD_ENDIAN_BIG)
2208         insn = bfd_getb16 (buffer);
2209       else
2210         insn = bfd_getl16 (buffer);
2211
2212       insn = insn | (higher << 16);
2213
2214       length += 2;
2215     }
2216
2217   /* FIXME: Should probably use a hash table on the major opcode here.  */
2218
2219   opend = micromips_opcodes + bfd_micromips_num_opcodes;
2220   for (op = micromips_opcodes; op < opend; op++)
2221     {
2222       if (op->pinfo != INSN_MACRO
2223           && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
2224           && (insn & op->mask) == op->match
2225           && ((length == 2 && (op->mask & 0xffff0000) == 0)
2226               || (length == 4 && (op->mask & 0xffff0000) != 0)))
2227         {
2228           if (!validate_insn_args (op, decode_micromips_operand, insn))
2229             continue;
2230
2231           infprintf (is, "%s", op->name);
2232
2233           if (op->args[0])
2234             {
2235               infprintf (is, "\t");
2236               print_insn_args (info, op, decode_micromips_operand, insn,
2237                                memaddr + 1, length);
2238             }
2239
2240           /* Figure out instruction type and branch delay information.  */
2241           if ((op->pinfo
2242                & (INSN_UNCOND_BRANCH_DELAY | INSN_COND_BRANCH_DELAY)) != 0)
2243             info->branch_delay_insns = 1;
2244           if (((op->pinfo & INSN_UNCOND_BRANCH_DELAY)
2245                | (op->pinfo2 & INSN2_UNCOND_BRANCH)) != 0)
2246             {
2247               if ((op->pinfo & (INSN_WRITE_GPR_31 | INSN_WRITE_1)) != 0)
2248                 info->insn_type = dis_jsr;
2249               else
2250                 info->insn_type = dis_branch;
2251             }
2252           else if (((op->pinfo & INSN_COND_BRANCH_DELAY)
2253                     | (op->pinfo2 & INSN2_COND_BRANCH)) != 0)
2254             {
2255               if ((op->pinfo & INSN_WRITE_GPR_31) != 0)
2256                 info->insn_type = dis_condjsr;
2257               else
2258                 info->insn_type = dis_condbranch;
2259             }
2260           else if ((op->pinfo
2261                     & (INSN_STORE_MEMORY | INSN_LOAD_MEMORY)) != 0)
2262             info->insn_type = dis_dref;
2263
2264           return length;
2265         }
2266     }
2267
2268   infprintf (is, "0x%x", insn);
2269   info->insn_type = dis_noninsn;
2270
2271   return length;
2272 }
2273
2274 /* Return 1 if a symbol associated with the location being disassembled
2275    indicates a compressed mode, either MIPS16 or microMIPS, according to
2276    MICROMIPS_P.  We iterate over all the symbols at the address being
2277    considered assuming if at least one of them indicates code compression,
2278    then such code has been genuinely produced here (other symbols could
2279    have been derived from function symbols defined elsewhere or could
2280    define data).  Otherwise, return 0.  */
2281
2282 static bfd_boolean
2283 is_compressed_mode_p (struct disassemble_info *info, bfd_boolean micromips_p)
2284 {
2285   int i;
2286   int l;
2287
2288   for (i = info->symtab_pos, l = i + info->num_symbols; i < l; i++)
2289     if (((info->symtab[i])->flags & BSF_SYNTHETIC) != 0
2290         && ((!micromips_p
2291              && ELF_ST_IS_MIPS16 ((*info->symbols)->udata.i))
2292             || (micromips_p
2293                 && ELF_ST_IS_MICROMIPS ((*info->symbols)->udata.i))))
2294       return 1;
2295     else if (bfd_asymbol_flavour (info->symtab[i]) == bfd_target_elf_flavour
2296               && info->symtab[i]->section == info->section)
2297       {
2298         elf_symbol_type *symbol = (elf_symbol_type *) info->symtab[i];
2299         if ((!micromips_p
2300              && ELF_ST_IS_MIPS16 (symbol->internal_elf_sym.st_other))
2301             || (micromips_p
2302                 && ELF_ST_IS_MICROMIPS (symbol->internal_elf_sym.st_other)))
2303           return 1;
2304       }
2305
2306   return 0;
2307 }
2308
2309 /* In an environment where we do not know the symbol type of the
2310    instruction we are forced to assume that the low order bit of the
2311    instructions' address may mark it as a mips16 instruction.  If we
2312    are single stepping, or the pc is within the disassembled function,
2313    this works.  Otherwise, we need a clue.  Sometimes.  */
2314
2315 static int
2316 _print_insn_mips (bfd_vma memaddr,
2317                   struct disassemble_info *info,
2318                   enum bfd_endian endianness)
2319 {
2320   bfd_byte buffer[INSNLEN];
2321   int status;
2322
2323   set_default_mips_dis_options (info);
2324   parse_mips_dis_options (info->disassembler_options);
2325
2326   if (info->mach == bfd_mach_mips16)
2327     return print_insn_mips16 (memaddr, info);
2328   if (info->mach == bfd_mach_mips_micromips)
2329     return print_insn_micromips (memaddr, info);
2330
2331 #if 1
2332   /* FIXME: If odd address, this is CLEARLY a compressed instruction.  */
2333   /* Only a few tools will work this way.  */
2334   if (memaddr & 0x01)
2335     {
2336       if (micromips_ase)
2337         return print_insn_micromips (memaddr, info);
2338       else
2339         return print_insn_mips16 (memaddr, info);
2340     }
2341 #endif
2342
2343 #if SYMTAB_AVAILABLE
2344   if (is_compressed_mode_p (info, TRUE))
2345     return print_insn_micromips (memaddr, info);
2346   if (is_compressed_mode_p (info, FALSE))
2347     return print_insn_mips16 (memaddr, info);
2348 #endif
2349
2350   status = (*info->read_memory_func) (memaddr, buffer, INSNLEN, info);
2351   if (status == 0)
2352     {
2353       int insn;
2354
2355       if (endianness == BFD_ENDIAN_BIG)
2356         insn = bfd_getb32 (buffer);
2357       else
2358         insn = bfd_getl32 (buffer);
2359
2360       return print_insn_mips (memaddr, insn, info);
2361     }
2362   else
2363     {
2364       (*info->memory_error_func) (status, memaddr, info);
2365       return -1;
2366     }
2367 }
2368
2369 int
2370 print_insn_big_mips (bfd_vma memaddr, struct disassemble_info *info)
2371 {
2372   return _print_insn_mips (memaddr, info, BFD_ENDIAN_BIG);
2373 }
2374
2375 int
2376 print_insn_little_mips (bfd_vma memaddr, struct disassemble_info *info)
2377 {
2378   return _print_insn_mips (memaddr, info, BFD_ENDIAN_LITTLE);
2379 }
2380 \f
2381 void
2382 print_mips_disassembler_options (FILE *stream)
2383 {
2384   unsigned int i;
2385
2386   fprintf (stream, _("\n\
2387 The following MIPS specific disassembler options are supported for use\n\
2388 with the -M switch (multiple options should be separated by commas):\n"));
2389
2390   fprintf (stream, _("\n\
2391   msa                      Recognize MSA instructions.\n"));
2392
2393   fprintf (stream, _("\n\
2394   virt                     Recognize the virtualization ASE instructions.\n"));
2395
2396   fprintf (stream, _("\n\
2397   xpa                      Recognize the eXtended Physical Address (XPA)\n\
2398                            ASE instructions.\n"));
2399
2400   fprintf (stream, _("\n\
2401   gpr-names=ABI            Print GPR names according to specified ABI.\n\
2402                            Default: based on binary being disassembled.\n"));
2403
2404   fprintf (stream, _("\n\
2405   fpr-names=ABI            Print FPR names according to specified ABI.\n\
2406                            Default: numeric.\n"));
2407
2408   fprintf (stream, _("\n\
2409   cp0-names=ARCH           Print CP0 register names according to\n\
2410                            specified architecture.\n\
2411                            Default: based on binary being disassembled.\n"));
2412
2413   fprintf (stream, _("\n\
2414   hwr-names=ARCH           Print HWR names according to specified \n\
2415                            architecture.\n\
2416                            Default: based on binary being disassembled.\n"));
2417
2418   fprintf (stream, _("\n\
2419   reg-names=ABI            Print GPR and FPR names according to\n\
2420                            specified ABI.\n"));
2421
2422   fprintf (stream, _("\n\
2423   reg-names=ARCH           Print CP0 register and HWR names according to\n\
2424                            specified architecture.\n"));
2425
2426   fprintf (stream, _("\n\
2427   For the options above, the following values are supported for \"ABI\":\n\
2428    "));
2429   for (i = 0; i < ARRAY_SIZE (mips_abi_choices); i++)
2430     fprintf (stream, " %s", mips_abi_choices[i].name);
2431   fprintf (stream, _("\n"));
2432
2433   fprintf (stream, _("\n\
2434   For the options above, The following values are supported for \"ARCH\":\n\
2435    "));
2436   for (i = 0; i < ARRAY_SIZE (mips_arch_choices); i++)
2437     if (*mips_arch_choices[i].name != '\0')
2438       fprintf (stream, " %s", mips_arch_choices[i].name);
2439   fprintf (stream, _("\n"));
2440
2441   fprintf (stream, _("\n"));
2442 }