OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [opcodes/] [mips-dis.c] - Blame information for rev 841

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.