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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [opcodes/] [mips-dis.c] - Blame information for rev 853

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 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_MIPS16 | 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_MIPS16 | 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_MIPS16 | 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_MIPS16 | 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 | INSN_MIPS16,
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 ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1408
                    info->insn_type = dis_jsr;
1409
                  else
1410
                    info->insn_type = dis_branch;
1411
                  info->branch_delay_insns = 1;
1412
                }
1413
              else if ((op->pinfo & (INSN_COND_BRANCH_DELAY
1414
                                     | INSN_COND_BRANCH_LIKELY)) != 0)
1415
                {
1416
                  if ((info->insn_type & INSN_WRITE_GPR_31) != 0)
1417
                    info->insn_type = dis_condjsr;
1418
                  else
1419
                    info->insn_type = dis_condbranch;
1420
                  info->branch_delay_insns = 1;
1421
                }
1422
              else if ((op->pinfo & (INSN_STORE_MEMORY
1423
                                     | INSN_LOAD_MEMORY_DELAY)) != 0)
1424
                info->insn_type = dis_dref;
1425
 
1426
              (*info->fprintf_func) (info->stream, "%s", op->name);
1427
 
1428
              d = op->args;
1429
              if (d != NULL && *d != '\0')
1430
                {
1431
                  (*info->fprintf_func) (info->stream, "\t");
1432
                  print_insn_args (d, word, memaddr, info, op);
1433
                }
1434
 
1435
              return INSNLEN;
1436
            }
1437
        }
1438
    }
1439
 
1440
  /* Handle undefined instructions.  */
1441
  info->insn_type = dis_noninsn;
1442
  (*info->fprintf_func) (info->stream, "0x%lx", word);
1443
  return INSNLEN;
1444
}
1445
 
1446
/* Disassemble an operand for a mips16 instruction.  */
1447
 
1448
static void
1449
print_mips16_insn_arg (char type,
1450
                       const struct mips_opcode *op,
1451
                       int l,
1452
                       bfd_boolean use_extend,
1453
                       int extend,
1454
                       bfd_vma memaddr,
1455
                       struct disassemble_info *info)
1456
{
1457
  switch (type)
1458
    {
1459
    case ',':
1460
    case '(':
1461
    case ')':
1462
      (*info->fprintf_func) (info->stream, "%c", type);
1463
      break;
1464
 
1465
    case 'y':
1466
    case 'w':
1467
      (*info->fprintf_func) (info->stream, "%s",
1468
                             mips16_reg_names(((l >> MIPS16OP_SH_RY)
1469
                                               & MIPS16OP_MASK_RY)));
1470
      break;
1471
 
1472
    case 'x':
1473
    case 'v':
1474
      (*info->fprintf_func) (info->stream, "%s",
1475
                             mips16_reg_names(((l >> MIPS16OP_SH_RX)
1476
                                               & MIPS16OP_MASK_RX)));
1477
      break;
1478
 
1479
    case 'z':
1480
      (*info->fprintf_func) (info->stream, "%s",
1481
                             mips16_reg_names(((l >> MIPS16OP_SH_RZ)
1482
                                               & MIPS16OP_MASK_RZ)));
1483
      break;
1484
 
1485
    case 'Z':
1486
      (*info->fprintf_func) (info->stream, "%s",
1487
                             mips16_reg_names(((l >> MIPS16OP_SH_MOVE32Z)
1488
                                               & MIPS16OP_MASK_MOVE32Z)));
1489
      break;
1490
 
1491
    case '0':
1492
      (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1493
      break;
1494
 
1495
    case 'S':
1496
      (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[29]);
1497
      break;
1498
 
1499
    case 'P':
1500
      (*info->fprintf_func) (info->stream, "$pc");
1501
      break;
1502
 
1503
    case 'R':
1504
      (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[31]);
1505
      break;
1506
 
1507
    case 'X':
1508
      (*info->fprintf_func) (info->stream, "%s",
1509
                             mips_gpr_names[((l >> MIPS16OP_SH_REGR32)
1510
                                            & MIPS16OP_MASK_REGR32)]);
1511
      break;
1512
 
1513
    case 'Y':
1514
      (*info->fprintf_func) (info->stream, "%s",
1515
                             mips_gpr_names[MIPS16OP_EXTRACT_REG32R (l)]);
1516
      break;
1517
 
1518
    case '<':
1519
    case '>':
1520
    case '[':
1521
    case ']':
1522
    case '4':
1523
    case '5':
1524
    case 'H':
1525
    case 'W':
1526
    case 'D':
1527
    case 'j':
1528
    case '6':
1529
    case '8':
1530
    case 'V':
1531
    case 'C':
1532
    case 'U':
1533
    case 'k':
1534
    case 'K':
1535
    case 'p':
1536
    case 'q':
1537
    case 'A':
1538
    case 'B':
1539
    case 'E':
1540
      {
1541
        int immed, nbits, shift, signedp, extbits, pcrel, extu, branch;
1542
 
1543
        shift = 0;
1544
        signedp = 0;
1545
        extbits = 16;
1546
        pcrel = 0;
1547
        extu = 0;
1548
        branch = 0;
1549
        switch (type)
1550
          {
1551
          case '<':
1552
            nbits = 3;
1553
            immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1554
            extbits = 5;
1555
            extu = 1;
1556
            break;
1557
          case '>':
1558
            nbits = 3;
1559
            immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1560
            extbits = 5;
1561
            extu = 1;
1562
            break;
1563
          case '[':
1564
            nbits = 3;
1565
            immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1566
            extbits = 6;
1567
            extu = 1;
1568
            break;
1569
          case ']':
1570
            nbits = 3;
1571
            immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1572
            extbits = 6;
1573
            extu = 1;
1574
            break;
1575
          case '4':
1576
            nbits = 4;
1577
            immed = (l >> MIPS16OP_SH_IMM4) & MIPS16OP_MASK_IMM4;
1578
            signedp = 1;
1579
            extbits = 15;
1580
            break;
1581
          case '5':
1582
            nbits = 5;
1583
            immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1584
            info->insn_type = dis_dref;
1585
            info->data_size = 1;
1586
            break;
1587
          case 'H':
1588
            nbits = 5;
1589
            shift = 1;
1590
            immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1591
            info->insn_type = dis_dref;
1592
            info->data_size = 2;
1593
            break;
1594
          case 'W':
1595
            nbits = 5;
1596
            shift = 2;
1597
            immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1598
            if ((op->pinfo & MIPS16_INSN_READ_PC) == 0
1599
                && (op->pinfo & MIPS16_INSN_READ_SP) == 0)
1600
              {
1601
                info->insn_type = dis_dref;
1602
                info->data_size = 4;
1603
              }
1604
            break;
1605
          case 'D':
1606
            nbits = 5;
1607
            shift = 3;
1608
            immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1609
            info->insn_type = dis_dref;
1610
            info->data_size = 8;
1611
            break;
1612
          case 'j':
1613
            nbits = 5;
1614
            immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1615
            signedp = 1;
1616
            break;
1617
          case '6':
1618
            nbits = 6;
1619
            immed = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1620
            break;
1621
          case '8':
1622
            nbits = 8;
1623
            immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1624
            break;
1625
          case 'V':
1626
            nbits = 8;
1627
            shift = 2;
1628
            immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1629
            /* FIXME: This might be lw, or it might be addiu to $sp or
1630
               $pc.  We assume it's load.  */
1631
            info->insn_type = dis_dref;
1632
            info->data_size = 4;
1633
            break;
1634
          case 'C':
1635
            nbits = 8;
1636
            shift = 3;
1637
            immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1638
            info->insn_type = dis_dref;
1639
            info->data_size = 8;
1640
            break;
1641
          case 'U':
1642
            nbits = 8;
1643
            immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1644
            extu = 1;
1645
            break;
1646
          case 'k':
1647
            nbits = 8;
1648
            immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1649
            signedp = 1;
1650
            break;
1651
          case 'K':
1652
            nbits = 8;
1653
            shift = 3;
1654
            immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1655
            signedp = 1;
1656
            break;
1657
          case 'p':
1658
            nbits = 8;
1659
            immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1660
            signedp = 1;
1661
            pcrel = 1;
1662
            branch = 1;
1663
            info->insn_type = dis_condbranch;
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
            info->insn_type = dis_branch;
1672
            break;
1673
          case 'A':
1674
            nbits = 8;
1675
            shift = 2;
1676
            immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1677
            pcrel = 1;
1678
            /* FIXME: This can be lw or la.  We assume it is lw.  */
1679
            info->insn_type = dis_dref;
1680
            info->data_size = 4;
1681
            break;
1682
          case 'B':
1683
            nbits = 5;
1684
            shift = 3;
1685
            immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1686
            pcrel = 1;
1687
            info->insn_type = dis_dref;
1688
            info->data_size = 8;
1689
            break;
1690
          case 'E':
1691
            nbits = 5;
1692
            shift = 2;
1693
            immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1694
            pcrel = 1;
1695
            break;
1696
          default:
1697
            abort ();
1698
          }
1699
 
1700
        if (! use_extend)
1701
          {
1702
            if (signedp && immed >= (1 << (nbits - 1)))
1703
              immed -= 1 << nbits;
1704
            immed <<= shift;
1705
            if ((type == '<' || type == '>' || type == '[' || type == ']')
1706
                && immed == 0)
1707
              immed = 8;
1708
          }
1709
        else
1710
          {
1711
            if (extbits == 16)
1712
              immed |= ((extend & 0x1f) << 11) | (extend & 0x7e0);
1713
            else if (extbits == 15)
1714
              immed |= ((extend & 0xf) << 11) | (extend & 0x7f0);
1715
            else
1716
              immed = ((extend >> 6) & 0x1f) | (extend & 0x20);
1717
            immed &= (1 << extbits) - 1;
1718
            if (! extu && immed >= (1 << (extbits - 1)))
1719
              immed -= 1 << extbits;
1720
          }
1721
 
1722
        if (! pcrel)
1723
          (*info->fprintf_func) (info->stream, "%d", immed);
1724
        else
1725
          {
1726
            bfd_vma baseaddr;
1727
 
1728
            if (branch)
1729
              {
1730
                immed *= 2;
1731
                baseaddr = memaddr + 2;
1732
              }
1733
            else if (use_extend)
1734
              baseaddr = memaddr - 2;
1735
            else
1736
              {
1737
                int status;
1738
                bfd_byte buffer[2];
1739
 
1740
                baseaddr = memaddr;
1741
 
1742
                /* If this instruction is in the delay slot of a jr
1743
                   instruction, the base address is the address of the
1744
                   jr instruction.  If it is in the delay slot of jalr
1745
                   instruction, the base address is the address of the
1746
                   jalr instruction.  This test is unreliable: we have
1747
                   no way of knowing whether the previous word is
1748
                   instruction or data.  */
1749
                status = (*info->read_memory_func) (memaddr - 4, buffer, 2,
1750
                                                    info);
1751
                if (status == 0
1752
                    && (((info->endian == BFD_ENDIAN_BIG
1753
                          ? bfd_getb16 (buffer)
1754
                          : bfd_getl16 (buffer))
1755
                         & 0xf800) == 0x1800))
1756
                  baseaddr = memaddr - 4;
1757
                else
1758
                  {
1759
                    status = (*info->read_memory_func) (memaddr - 2, buffer,
1760
                                                        2, info);
1761
                    if (status == 0
1762
                        && (((info->endian == BFD_ENDIAN_BIG
1763
                              ? bfd_getb16 (buffer)
1764
                              : bfd_getl16 (buffer))
1765
                             & 0xf81f) == 0xe800))
1766
                      baseaddr = memaddr - 2;
1767
                  }
1768
              }
1769
            info->target = (baseaddr & ~((1 << shift) - 1)) + immed;
1770
            if (pcrel && branch
1771
                && info->flavour == bfd_target_unknown_flavour)
1772
              /* For gdb disassembler, maintain odd address.  */
1773
              info->target |= 1;
1774
            (*info->print_address_func) (info->target, info);
1775
          }
1776
      }
1777
      break;
1778
 
1779
    case 'a':
1780
      {
1781
        int jalx = l & 0x400;
1782
 
1783
        if (! use_extend)
1784
          extend = 0;
1785
        l = ((l & 0x1f) << 23) | ((l & 0x3e0) << 13) | (extend << 2);
1786
        if (!jalx && info->flavour == bfd_target_unknown_flavour)
1787
          /* For gdb disassembler, maintain odd address.  */
1788
          l |= 1;
1789
      }
1790
      info->target = ((memaddr + 4) & ~(bfd_vma) 0x0fffffff) | l;
1791
      (*info->print_address_func) (info->target, info);
1792
      info->insn_type = dis_jsr;
1793
      info->branch_delay_insns = 1;
1794
      break;
1795
 
1796
    case 'l':
1797
    case 'L':
1798
      {
1799
        int need_comma, amask, smask;
1800
 
1801
        need_comma = 0;
1802
 
1803
        l = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1804
 
1805
        amask = (l >> 3) & 7;
1806
 
1807
        if (amask > 0 && amask < 5)
1808
          {
1809
            (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1810
            if (amask > 1)
1811
              (*info->fprintf_func) (info->stream, "-%s",
1812
                                     mips_gpr_names[amask + 3]);
1813
            need_comma = 1;
1814
          }
1815
 
1816
        smask = (l >> 1) & 3;
1817
        if (smask == 3)
1818
          {
1819
            (*info->fprintf_func) (info->stream, "%s??",
1820
                                   need_comma ? "," : "");
1821
            need_comma = 1;
1822
          }
1823
        else if (smask > 0)
1824
          {
1825
            (*info->fprintf_func) (info->stream, "%s%s",
1826
                                   need_comma ? "," : "",
1827
                                   mips_gpr_names[16]);
1828
            if (smask > 1)
1829
              (*info->fprintf_func) (info->stream, "-%s",
1830
                                     mips_gpr_names[smask + 15]);
1831
            need_comma = 1;
1832
          }
1833
 
1834
        if (l & 1)
1835
          {
1836
            (*info->fprintf_func) (info->stream, "%s%s",
1837
                                   need_comma ? "," : "",
1838
                                   mips_gpr_names[31]);
1839
            need_comma = 1;
1840
          }
1841
 
1842
        if (amask == 5 || amask == 6)
1843
          {
1844
            (*info->fprintf_func) (info->stream, "%s$f0",
1845
                                   need_comma ? "," : "");
1846
            if (amask == 6)
1847
              (*info->fprintf_func) (info->stream, "-$f1");
1848
          }
1849
      }
1850
      break;
1851
 
1852
    case 'm':
1853
    case 'M':
1854
      /* MIPS16e save/restore.  */
1855
      {
1856
      int need_comma = 0;
1857
      int amask, args, statics;
1858
      int nsreg, smask;
1859
      int framesz;
1860
      int i, j;
1861
 
1862
      l = l & 0x7f;
1863
      if (use_extend)
1864
        l |= extend << 16;
1865
 
1866
      amask = (l >> 16) & 0xf;
1867
      if (amask == MIPS16_ALL_ARGS)
1868
        {
1869
          args = 4;
1870
          statics = 0;
1871
        }
1872
      else if (amask == MIPS16_ALL_STATICS)
1873
        {
1874
          args = 0;
1875
          statics = 4;
1876
        }
1877
      else
1878
        {
1879
          args = amask >> 2;
1880
          statics = amask & 3;
1881
        }
1882
 
1883
      if (args > 0) {
1884
          (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1885
          if (args > 1)
1886
            (*info->fprintf_func) (info->stream, "-%s",
1887
                                   mips_gpr_names[4 + args - 1]);
1888
          need_comma = 1;
1889
      }
1890
 
1891
      framesz = (((l >> 16) & 0xf0) | (l & 0x0f)) * 8;
1892
      if (framesz == 0 && !use_extend)
1893
        framesz = 128;
1894
 
1895
      (*info->fprintf_func) (info->stream, "%s%d",
1896
                             need_comma ? "," : "",
1897
                             framesz);
1898
 
1899
      if (l & 0x40)                   /* $ra */
1900
        (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[31]);
1901
 
1902
      nsreg = (l >> 24) & 0x7;
1903
      smask = 0;
1904
      if (l & 0x20)                   /* $s0 */
1905
        smask |= 1 << 0;
1906
      if (l & 0x10)                   /* $s1 */
1907
        smask |= 1 << 1;
1908
      if (nsreg > 0)                  /* $s2-$s8 */
1909
        smask |= ((1 << nsreg) - 1) << 2;
1910
 
1911
      /* Find first set static reg bit.  */
1912
      for (i = 0; i < 9; i++)
1913
        {
1914
          if (smask & (1 << i))
1915
            {
1916
              (*info->fprintf_func) (info->stream, ",%s",
1917
                                     mips_gpr_names[i == 8 ? 30 : (16 + i)]);
1918
              /* Skip over string of set bits.  */
1919
              for (j = i; smask & (2 << j); j++)
1920
                continue;
1921
              if (j > i)
1922
                (*info->fprintf_func) (info->stream, "-%s",
1923
                                       mips_gpr_names[j == 8 ? 30 : (16 + j)]);
1924
              i = j + 1;
1925
            }
1926
        }
1927
 
1928
      /* Statics $ax - $a3.  */
1929
      if (statics == 1)
1930
        (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[7]);
1931
      else if (statics > 0)
1932
        (*info->fprintf_func) (info->stream, ",%s-%s",
1933
                               mips_gpr_names[7 - statics + 1],
1934
                               mips_gpr_names[7]);
1935
      }
1936
      break;
1937
 
1938
    default:
1939
      /* xgettext:c-format */
1940
      (*info->fprintf_func)
1941
        (info->stream,
1942
         _("# internal disassembler error, unrecognised modifier (%c)"),
1943
         type);
1944
      abort ();
1945
    }
1946
}
1947
 
1948
/* Disassemble mips16 instructions.  */
1949
 
1950
static int
1951
print_insn_mips16 (bfd_vma memaddr, struct disassemble_info *info)
1952
{
1953
  int status;
1954
  bfd_byte buffer[2];
1955
  int length;
1956
  int insn;
1957
  bfd_boolean use_extend;
1958
  int extend = 0;
1959
  const struct mips_opcode *op, *opend;
1960
 
1961
  info->bytes_per_chunk = 2;
1962
  info->display_endian = info->endian;
1963
  info->insn_info_valid = 1;
1964
  info->branch_delay_insns = 0;
1965
  info->data_size = 0;
1966
  info->insn_type = dis_nonbranch;
1967
  info->target = 0;
1968
  info->target2 = 0;
1969
 
1970
  status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1971
  if (status != 0)
1972
    {
1973
      (*info->memory_error_func) (status, memaddr, info);
1974
      return -1;
1975
    }
1976
 
1977
  length = 2;
1978
 
1979
  if (info->endian == BFD_ENDIAN_BIG)
1980
    insn = bfd_getb16 (buffer);
1981
  else
1982
    insn = bfd_getl16 (buffer);
1983
 
1984
  /* Handle the extend opcode specially.  */
1985
  use_extend = FALSE;
1986
  if ((insn & 0xf800) == 0xf000)
1987
    {
1988
      use_extend = TRUE;
1989
      extend = insn & 0x7ff;
1990
 
1991
      memaddr += 2;
1992
 
1993
      status = (*info->read_memory_func) (memaddr, buffer, 2, info);
1994
      if (status != 0)
1995
        {
1996
          (*info->fprintf_func) (info->stream, "extend 0x%x",
1997
                                 (unsigned int) extend);
1998
          (*info->memory_error_func) (status, memaddr, info);
1999
          return -1;
2000
        }
2001
 
2002
      if (info->endian == BFD_ENDIAN_BIG)
2003
        insn = bfd_getb16 (buffer);
2004
      else
2005
        insn = bfd_getl16 (buffer);
2006
 
2007
      /* Check for an extend opcode followed by an extend opcode.  */
2008
      if ((insn & 0xf800) == 0xf000)
2009
        {
2010
          (*info->fprintf_func) (info->stream, "extend 0x%x",
2011
                                 (unsigned int) extend);
2012
          info->insn_type = dis_noninsn;
2013
          return length;
2014
        }
2015
 
2016
      length += 2;
2017
    }
2018
 
2019
  /* FIXME: Should probably use a hash table on the major opcode here.  */
2020
 
2021
  opend = mips16_opcodes + bfd_mips16_num_opcodes;
2022
  for (op = mips16_opcodes; op < opend; op++)
2023
    {
2024
      if (op->pinfo != INSN_MACRO
2025
          && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
2026
          && (insn & op->mask) == op->match)
2027
        {
2028
          const char *s;
2029
 
2030
          if (strchr (op->args, 'a') != NULL)
2031
            {
2032
              if (use_extend)
2033
                {
2034
                  (*info->fprintf_func) (info->stream, "extend 0x%x",
2035
                                         (unsigned int) extend);
2036
                  info->insn_type = dis_noninsn;
2037
                  return length - 2;
2038
                }
2039
 
2040
              use_extend = FALSE;
2041
 
2042
              memaddr += 2;
2043
 
2044
              status = (*info->read_memory_func) (memaddr, buffer, 2,
2045
                                                  info);
2046
              if (status == 0)
2047
                {
2048
                  use_extend = TRUE;
2049
                  if (info->endian == BFD_ENDIAN_BIG)
2050
                    extend = bfd_getb16 (buffer);
2051
                  else
2052
                    extend = bfd_getl16 (buffer);
2053
                  length += 2;
2054
                }
2055
            }
2056
 
2057
          (*info->fprintf_func) (info->stream, "%s", op->name);
2058
          if (op->args[0] != '\0')
2059
            (*info->fprintf_func) (info->stream, "\t");
2060
 
2061
          for (s = op->args; *s != '\0'; s++)
2062
            {
2063
              if (*s == ','
2064
                  && s[1] == 'w'
2065
                  && (((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)
2066
                      == ((insn >> MIPS16OP_SH_RY) & MIPS16OP_MASK_RY)))
2067
                {
2068
                  /* Skip the register and the comma.  */
2069
                  ++s;
2070
                  continue;
2071
                }
2072
              if (*s == ','
2073
                  && s[1] == 'v'
2074
                  && (((insn >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ)
2075
                      == ((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)))
2076
                {
2077
                  /* Skip the register and the comma.  */
2078
                  ++s;
2079
                  continue;
2080
                }
2081
              print_mips16_insn_arg (*s, op, insn, use_extend, extend, memaddr,
2082
                                     info);
2083
            }
2084
 
2085
          if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
2086
            {
2087
              info->branch_delay_insns = 1;
2088
              if (info->insn_type != dis_jsr)
2089
                info->insn_type = dis_branch;
2090
            }
2091
 
2092
          return length;
2093
        }
2094
    }
2095
 
2096
  if (use_extend)
2097
    (*info->fprintf_func) (info->stream, "0x%x", extend | 0xf000);
2098
  (*info->fprintf_func) (info->stream, "0x%x", insn);
2099
  info->insn_type = dis_noninsn;
2100
 
2101
  return length;
2102
}
2103
 
2104
/* In an environment where we do not know the symbol type of the
2105
   instruction we are forced to assume that the low order bit of the
2106
   instructions' address may mark it as a mips16 instruction.  If we
2107
   are single stepping, or the pc is within the disassembled function,
2108
   this works.  Otherwise, we need a clue.  Sometimes.  */
2109
 
2110
static int
2111
_print_insn_mips (bfd_vma memaddr,
2112
                  struct disassemble_info *info,
2113
                  enum bfd_endian endianness)
2114
{
2115
  bfd_byte buffer[INSNLEN];
2116
  int status;
2117
 
2118
  set_default_mips_dis_options (info);
2119
  parse_mips_dis_options (info->disassembler_options);
2120
 
2121
#if 1
2122
  /* FIXME: If odd address, this is CLEARLY a mips 16 instruction.  */
2123
  /* Only a few tools will work this way.  */
2124
  if (memaddr & 0x01)
2125
    return print_insn_mips16 (memaddr, info);
2126
#endif
2127
 
2128
#if SYMTAB_AVAILABLE
2129
  if (info->mach == bfd_mach_mips16
2130
      || (info->symbols != NULL
2131
          && bfd_asymbol_flavour (*info->symbols) == bfd_target_elf_flavour
2132
          && ELF_ST_IS_MIPS16 ((*(elf_symbol_type **) info->symbols)
2133
                               ->internal_elf_sym.st_other)))
2134
    return print_insn_mips16 (memaddr, info);
2135
#endif
2136
 
2137
  status = (*info->read_memory_func) (memaddr, buffer, INSNLEN, info);
2138
  if (status == 0)
2139
    {
2140
      unsigned long insn;
2141
 
2142
      if (endianness == BFD_ENDIAN_BIG)
2143
        insn = (unsigned long) bfd_getb32 (buffer);
2144
      else
2145
        insn = (unsigned long) bfd_getl32 (buffer);
2146
 
2147
      return print_insn_mips (memaddr, insn, info);
2148
    }
2149
  else
2150
    {
2151
      (*info->memory_error_func) (status, memaddr, info);
2152
      return -1;
2153
    }
2154
}
2155
 
2156
int
2157
print_insn_big_mips (bfd_vma memaddr, struct disassemble_info *info)
2158
{
2159
  return _print_insn_mips (memaddr, info, BFD_ENDIAN_BIG);
2160
}
2161
 
2162
int
2163
print_insn_little_mips (bfd_vma memaddr, struct disassemble_info *info)
2164
{
2165
  return _print_insn_mips (memaddr, info, BFD_ENDIAN_LITTLE);
2166
}
2167
 
2168
void
2169
print_mips_disassembler_options (FILE *stream)
2170
{
2171
  unsigned int i;
2172
 
2173
  fprintf (stream, _("\n\
2174
The following MIPS specific disassembler options are supported for use\n\
2175
with the -M switch (multiple options should be separated by commas):\n"));
2176
 
2177
  fprintf (stream, _("\n\
2178
  gpr-names=ABI            Print GPR names according to  specified ABI.\n\
2179
                           Default: based on binary being disassembled.\n"));
2180
 
2181
  fprintf (stream, _("\n\
2182
  fpr-names=ABI            Print FPR names according to specified ABI.\n\
2183
                           Default: numeric.\n"));
2184
 
2185
  fprintf (stream, _("\n\
2186
  cp0-names=ARCH           Print CP0 register names according to\n\
2187
                           specified architecture.\n\
2188
                           Default: based on binary being disassembled.\n"));
2189
 
2190
  fprintf (stream, _("\n\
2191
  hwr-names=ARCH           Print HWR names according to specified \n\
2192
                           architecture.\n\
2193
                           Default: based on binary being disassembled.\n"));
2194
 
2195
  fprintf (stream, _("\n\
2196
  reg-names=ABI            Print GPR and FPR names according to\n\
2197
                           specified ABI.\n"));
2198
 
2199
  fprintf (stream, _("\n\
2200
  reg-names=ARCH           Print CP0 register and HWR names according to\n\
2201
                           specified architecture.\n"));
2202
 
2203
  fprintf (stream, _("\n\
2204
  For the options above, the following values are supported for \"ABI\":\n\
2205
   "));
2206
  for (i = 0; i < ARRAY_SIZE (mips_abi_choices); i++)
2207
    fprintf (stream, " %s", mips_abi_choices[i].name);
2208
  fprintf (stream, _("\n"));
2209
 
2210
  fprintf (stream, _("\n\
2211
  For the options above, The following values are supported for \"ARCH\":\n\
2212
   "));
2213
  for (i = 0; i < ARRAY_SIZE (mips_arch_choices); i++)
2214
    if (*mips_arch_choices[i].name != '\0')
2215
      fprintf (stream, " %s", mips_arch_choices[i].name);
2216
  fprintf (stream, _("\n"));
2217
 
2218
  fprintf (stream, _("\n"));
2219
}

powered by: WebSVN 2.1.0

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