opcodes/mips-dis.c

   1 /* Print mips instructions for GDB, the GNU debugger, or for objdump.
   2    Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2012
   4    Free Software Foundation, Inc.
   5    Contributed by Nobuyuki Hikichi(hikichi@sra.co.jp).
   6
   7    This file is part of the GNU opcodes library.
   8
   9    This library is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    It is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17    License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 #include "sysdep.h"
  25 #include "dis-asm.h"
  26 #include "libiberty.h"
  27 #include "opcode/mips.h"
  28 #include "opintl.h"
  29
  30 /* FIXME: These are needed to figure out if the code is mips16 or
  31    not. The low bit of the address is often a good indicator.  No
  32    symbol table is available when this code runs out in an embedded
  33    system as when it is used for disassembler support in a monitor.  */
  34
  35 #if !defined(EMBEDDED_ENV)
  36 #define SYMTAB_AVAILABLE 1
  37 #include "elf-bfd.h"
  38 #include "elf/mips.h"
  39 #endif
  40
  41 /* Mips instructions are at maximum this many bytes long.  */
  42 #define INSNLEN 4
  43
  44 \f
  45 /* FIXME: These should be shared with gdb somehow.  */
  46
  47 struct mips_cp0sel_name
  48 {
  49   unsigned int cp0reg;
  50   unsigned int sel;
  51   const char * const name;
  52 };
  53
  54 /* The mips16 registers.  */
  55 static const unsigned int mips16_to_32_reg_map[] =
  56 {
  57   16, 17, 2, 3, 4, 5, 6, 7
  58 };
  59
  60 /* The microMIPS registers with type b.  */
  61 #define micromips_to_32_reg_b_map       mips16_to_32_reg_map
  62
  63 /* The microMIPS registers with type c.  */
  64 #define micromips_to_32_reg_c_map       mips16_to_32_reg_map
  65
  66 /* The microMIPS registers with type d.  */
  67 #define micromips_to_32_reg_d_map       mips16_to_32_reg_map
  68
  69 /* The microMIPS registers with type e.  */
  70 #define micromips_to_32_reg_e_map       mips16_to_32_reg_map
  71
  72 /* The microMIPS registers with type f.  */
  73 #define micromips_to_32_reg_f_map       mips16_to_32_reg_map
  74
  75 /* The microMIPS registers with type g.  */
  76 #define micromips_to_32_reg_g_map       mips16_to_32_reg_map
  77
  78 /* The microMIPS registers with type h.  */
  79 static const unsigned int micromips_to_32_reg_h_map[] =
  80 {
  81   5, 5, 6, 4, 4, 4, 4, 4
  82 };
  83
  84 /* The microMIPS registers with type i.  */
  85 static const unsigned int micromips_to_32_reg_i_map[] =
  86 {
  87   6, 7, 7, 21, 22, 5, 6, 7
  88 };
  89
  90 /* The microMIPS registers with type j: 32 registers.  */
  91
  92 /* The microMIPS registers with type l.  */
  93 #define micromips_to_32_reg_l_map       mips16_to_32_reg_map
  94
  95 /* The microMIPS registers with type m.  */
  96 static const unsigned int micromips_to_32_reg_m_map[] =
  97 {
  98   0, 17, 2, 3, 16, 18, 19, 20
  99 };
 100
 101 /* The microMIPS registers with type n.  */
 102 #define micromips_to_32_reg_n_map      micromips_to_32_reg_m_map
 103
 104 /* The microMIPS registers with type p: 32 registers.  */
 105
 106 /* The microMIPS registers with type q.  */
 107 static const unsigned int micromips_to_32_reg_q_map[] =
 108 {
 109   0, 17, 2, 3, 4, 5, 6, 7
 110 };
 111
 112 /* reg type s is $29.  */
 113
 114 /* reg type t is the same as the last register.  */
 115
 116 /* reg type y is $31.  */
 117
 118 /* reg type z is $0.  */
 119
 120 /* micromips imm B type.  */
 121 static const int micromips_imm_b_map[8] =
 122 {
 123   1, 4, 8, 12, 16, 20, 24, -1
 124 };
 125
 126 /* micromips imm C type.  */
 127 static const int micromips_imm_c_map[16] =
 128 {
 129   128, 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 255, 32768, 65535
 130 };
 131
 132 /* micromips imm D type: (-512..511)<<1.  */
 133 /* micromips imm E type: (-64..63)<<1.  */
 134 /* micromips imm F type: (0..63).  */
 135 /* micromips imm G type: (-1..14).  */
 136 /* micromips imm H type: (0..15)<<1.  */
 137 /* micromips imm I type: (-1..126).  */
 138 /* micromips imm J type: (0..15)<<2.  */
 139 /* micromips imm L type: (0..15).  */
 140 /* micromips imm M type: (1..8).  */
 141 /* micromips imm W type: (0..63)<<2.  */
 142 /* micromips imm X type: (-8..7).  */
 143 /* micromips imm Y type: (-258..-3, 2..257)<<2.  */
 144
 145 #define mips16_reg_names(rn)    mips_gpr_names[mips16_to_32_reg_map[rn]]
 146
 147
 148 static const char * const mips_gpr_names_numeric[32] =
 149 {
 150   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
 151   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
 152   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
 153   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
 154 };
 155
 156 static const char * const mips_gpr_names_oldabi[32] =
 157 {
 158   "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 159   "t0",   "t1",   "t2",   "t3",   "t4",   "t5",   "t6",   "t7",
 160   "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 161   "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra"
 162 };
 163
 164 static const char * const mips_gpr_names_newabi[32] =
 165 {
 166   "zero", "at",   "v0",   "v1",   "a0",   "a1",   "a2",   "a3",
 167   "a4",   "a5",   "a6",   "a7",   "t0",   "t1",   "t2",   "t3",
 168   "s0",   "s1",   "s2",   "s3",   "s4",   "s5",   "s6",   "s7",
 169   "t8",   "t9",   "k0",   "k1",   "gp",   "sp",   "s8",   "ra"
 170 };
 171
 172 static const char * const mips_fpr_names_numeric[32] =
 173 {
 174   "$f0",  "$f1",  "$f2",  "$f3",  "$f4",  "$f5",  "$f6",  "$f7",
 175   "$f8",  "$f9",  "$f10", "$f11", "$f12", "$f13", "$f14", "$f15",
 176   "$f16", "$f17", "$f18", "$f19", "$f20", "$f21", "$f22", "$f23",
 177   "$f24", "$f25", "$f26", "$f27", "$f28", "$f29", "$f30", "$f31"
 178 };
 179
 180 static const char * const mips_fpr_names_32[32] =
 181 {
 182   "fv0",  "fv0f", "fv1",  "fv1f", "ft0",  "ft0f", "ft1",  "ft1f",
 183   "ft2",  "ft2f", "ft3",  "ft3f", "fa0",  "fa0f", "fa1",  "fa1f",
 184   "ft4",  "ft4f", "ft5",  "ft5f", "fs0",  "fs0f", "fs1",  "fs1f",
 185   "fs2",  "fs2f", "fs3",  "fs3f", "fs4",  "fs4f", "fs5",  "fs5f"
 186 };
 187
 188 static const char * const mips_fpr_names_n32[32] =
 189 {
 190   "fv0",  "ft14", "fv1",  "ft15", "ft0",  "ft1",  "ft2",  "ft3",
 191   "ft4",  "ft5",  "ft6",  "ft7",  "fa0",  "fa1",  "fa2",  "fa3",
 192   "fa4",  "fa5",  "fa6",  "fa7",  "fs0",  "ft8",  "fs1",  "ft9",
 193   "fs2",  "ft10", "fs3",  "ft11", "fs4",  "ft12", "fs5",  "ft13"
 194 };
 195
 196 static const char * const mips_fpr_names_64[32] =
 197 {
 198   "fv0",  "ft12", "fv1",  "ft13", "ft0",  "ft1",  "ft2",  "ft3",
 199   "ft4",  "ft5",  "ft6",  "ft7",  "fa0",  "fa1",  "fa2",  "fa3",
 200   "fa4",  "fa5",  "fa6",  "fa7",  "ft8",  "ft9",  "ft10", "ft11",
 201   "fs0",  "fs1",  "fs2",  "fs3",  "fs4",  "fs5",  "fs6",  "fs7"
 202 };
 203
 204 static const char * const mips_cp0_names_numeric[32] =
 205 {
 206   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
 207   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
 208   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
 209   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
 210 };
 211
 212 static const char * const mips_cp0_names_r3000[32] =
 213 {
 214   "c0_index",     "c0_random",    "c0_entrylo",   "$3",
 215   "c0_context",   "$5",           "$6",           "$7",
 216   "c0_badvaddr",  "$9",           "c0_entryhi",   "$11",
 217   "c0_sr",        "c0_cause",     "c0_epc",       "c0_prid",
 218   "$16",          "$17",          "$18",          "$19",
 219   "$20",          "$21",          "$22",          "$23",
 220   "$24",          "$25",          "$26",          "$27",
 221   "$28",          "$29",          "$30",          "$31",
 222 };
 223
 224 static const char * const mips_cp0_names_r4000[32] =
 225 {
 226   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
 227   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
 228   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
 229   "c0_sr",        "c0_cause",     "c0_epc",       "c0_prid",
 230   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
 231   "c0_xcontext",  "$21",          "$22",          "$23",
 232   "$24",          "$25",          "c0_ecc",       "c0_cacheerr",
 233   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "$31",
 234 };
 235
 236 static const char * const mips_cp0_names_mips3264[32] =
 237 {
 238   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
 239   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
 240   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
 241   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
 242   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
 243   "c0_xcontext",  "$21",          "$22",          "c0_debug",
 244   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr",
 245   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "c0_desave",
 246 };
 247
 248 static const struct mips_cp0sel_name mips_cp0sel_names_mips3264[] =
 249 {
 250   { 16, 1, "c0_config1"         },
 251   { 16, 2, "c0_config2"         },
 252   { 16, 3, "c0_config3"         },
 253   { 18, 1, "c0_watchlo,1"       },
 254   { 18, 2, "c0_watchlo,2"       },
 255   { 18, 3, "c0_watchlo,3"       },
 256   { 18, 4, "c0_watchlo,4"       },
 257   { 18, 5, "c0_watchlo,5"       },
 258   { 18, 6, "c0_watchlo,6"       },
 259   { 18, 7, "c0_watchlo,7"       },
 260   { 19, 1, "c0_watchhi,1"       },
 261   { 19, 2, "c0_watchhi,2"       },
 262   { 19, 3, "c0_watchhi,3"       },
 263   { 19, 4, "c0_watchhi,4"       },
 264   { 19, 5, "c0_watchhi,5"       },
 265   { 19, 6, "c0_watchhi,6"       },
 266   { 19, 7, "c0_watchhi,7"       },
 267   { 25, 1, "c0_perfcnt,1"       },
 268   { 25, 2, "c0_perfcnt,2"       },
 269   { 25, 3, "c0_perfcnt,3"       },
 270   { 25, 4, "c0_perfcnt,4"       },
 271   { 25, 5, "c0_perfcnt,5"       },
 272   { 25, 6, "c0_perfcnt,6"       },
 273   { 25, 7, "c0_perfcnt,7"       },
 274   { 27, 1, "c0_cacheerr,1"      },
 275   { 27, 2, "c0_cacheerr,2"      },
 276   { 27, 3, "c0_cacheerr,3"      },
 277   { 28, 1, "c0_datalo"          },
 278   { 29, 1, "c0_datahi"          }
 279 };
 280
 281 static const char * const mips_cp0_names_mips3264r2[32] =
 282 {
 283   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
 284   "c0_context",   "c0_pagemask",  "c0_wired",     "c0_hwrena",
 285   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
 286   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
 287   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
 288   "c0_xcontext",  "$21",          "$22",          "c0_debug",
 289   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr",
 290   "c0_taglo",     "c0_taghi",     "c0_errorepc",  "c0_desave",
 291 };
 292
 293 static const struct mips_cp0sel_name mips_cp0sel_names_mips3264r2[] =
 294 {
 295   {  4, 1, "c0_contextconfig"   },
 296   {  0, 1, "c0_mvpcontrol"      },
 297   {  0, 2, "c0_mvpconf0"        },
 298   {  0, 3, "c0_mvpconf1"        },
 299   {  1, 1, "c0_vpecontrol"      },
 300   {  1, 2, "c0_vpeconf0"        },
 301   {  1, 3, "c0_vpeconf1"        },
 302   {  1, 4, "c0_yqmask"          },
 303   {  1, 5, "c0_vpeschedule"     },
 304   {  1, 6, "c0_vpeschefback"    },
 305   {  2, 1, "c0_tcstatus"        },
 306   {  2, 2, "c0_tcbind"          },
 307   {  2, 3, "c0_tcrestart"       },
 308   {  2, 4, "c0_tchalt"          },
 309   {  2, 5, "c0_tccontext"       },
 310   {  2, 6, "c0_tcschedule"      },
 311   {  2, 7, "c0_tcschefback"     },
 312   {  5, 1, "c0_pagegrain"       },
 313   {  6, 1, "c0_srsconf0"        },
 314   {  6, 2, "c0_srsconf1"        },
 315   {  6, 3, "c0_srsconf2"        },
 316   {  6, 4, "c0_srsconf3"        },
 317   {  6, 5, "c0_srsconf4"        },
 318   { 12, 1, "c0_intctl"          },
 319   { 12, 2, "c0_srsctl"          },
 320   { 12, 3, "c0_srsmap"          },
 321   { 15, 1, "c0_ebase"           },
 322   { 16, 1, "c0_config1"         },
 323   { 16, 2, "c0_config2"         },
 324   { 16, 3, "c0_config3"         },
 325   { 18, 1, "c0_watchlo,1"       },
 326   { 18, 2, "c0_watchlo,2"       },
 327   { 18, 3, "c0_watchlo,3"       },
 328   { 18, 4, "c0_watchlo,4"       },
 329   { 18, 5, "c0_watchlo,5"       },
 330   { 18, 6, "c0_watchlo,6"       },
 331   { 18, 7, "c0_watchlo,7"       },
 332   { 19, 1, "c0_watchhi,1"       },
 333   { 19, 2, "c0_watchhi,2"       },
 334   { 19, 3, "c0_watchhi,3"       },
 335   { 19, 4, "c0_watchhi,4"       },
 336   { 19, 5, "c0_watchhi,5"       },
 337   { 19, 6, "c0_watchhi,6"       },
 338   { 19, 7, "c0_watchhi,7"       },
 339   { 23, 1, "c0_tracecontrol"    },
 340   { 23, 2, "c0_tracecontrol2"   },
 341   { 23, 3, "c0_usertracedata"   },
 342   { 23, 4, "c0_tracebpc"        },
 343   { 25, 1, "c0_perfcnt,1"       },
 344   { 25, 2, "c0_perfcnt,2"       },
 345   { 25, 3, "c0_perfcnt,3"       },
 346   { 25, 4, "c0_perfcnt,4"       },
 347   { 25, 5, "c0_perfcnt,5"       },
 348   { 25, 6, "c0_perfcnt,6"       },
 349   { 25, 7, "c0_perfcnt,7"       },
 350   { 27, 1, "c0_cacheerr,1"      },
 351   { 27, 2, "c0_cacheerr,2"      },
 352   { 27, 3, "c0_cacheerr,3"      },
 353   { 28, 1, "c0_datalo"          },
 354   { 28, 2, "c0_taglo1"          },
 355   { 28, 3, "c0_datalo1"         },
 356   { 28, 4, "c0_taglo2"          },
 357   { 28, 5, "c0_datalo2"         },
 358   { 28, 6, "c0_taglo3"          },
 359   { 28, 7, "c0_datalo3"         },
 360   { 29, 1, "c0_datahi"          },
 361   { 29, 2, "c0_taghi1"          },
 362   { 29, 3, "c0_datahi1"         },
 363   { 29, 4, "c0_taghi2"          },
 364   { 29, 5, "c0_datahi2"         },
 365   { 29, 6, "c0_taghi3"          },
 366   { 29, 7, "c0_datahi3"         },
 367 };
 368
 369 /* SB-1: MIPS64 (mips_cp0_names_mips3264) with minor mods.  */
 370 static const char * const mips_cp0_names_sb1[32] =
 371 {
 372   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
 373   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
 374   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
 375   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
 376   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
 377   "c0_xcontext",  "$21",          "$22",          "c0_debug",
 378   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr_i",
 379   "c0_taglo_i",   "c0_taghi_i",   "c0_errorepc",  "c0_desave",
 380 };
 381
 382 static const struct mips_cp0sel_name mips_cp0sel_names_sb1[] =
 383 {
 384   { 16, 1, "c0_config1"         },
 385   { 18, 1, "c0_watchlo,1"       },
 386   { 19, 1, "c0_watchhi,1"       },
 387   { 22, 0, "c0_perftrace"       },
 388   { 23, 3, "c0_edebug"          },
 389   { 25, 1, "c0_perfcnt,1"       },
 390   { 25, 2, "c0_perfcnt,2"       },
 391   { 25, 3, "c0_perfcnt,3"       },
 392   { 25, 4, "c0_perfcnt,4"       },
 393   { 25, 5, "c0_perfcnt,5"       },
 394   { 25, 6, "c0_perfcnt,6"       },
 395   { 25, 7, "c0_perfcnt,7"       },
 396   { 26, 1, "c0_buserr_pa"       },
 397   { 27, 1, "c0_cacheerr_d"      },
 398   { 27, 3, "c0_cacheerr_d_pa"   },
 399   { 28, 1, "c0_datalo_i"        },
 400   { 28, 2, "c0_taglo_d"         },
 401   { 28, 3, "c0_datalo_d"        },
 402   { 29, 1, "c0_datahi_i"        },
 403   { 29, 2, "c0_taghi_d"         },
 404   { 29, 3, "c0_datahi_d"        },
 405 };
 406
 407 /* Xlr cop0 register names.  */
 408 static const char * const mips_cp0_names_xlr[32] = {
 409   "c0_index",     "c0_random",    "c0_entrylo0",  "c0_entrylo1",
 410   "c0_context",   "c0_pagemask",  "c0_wired",     "$7",
 411   "c0_badvaddr",  "c0_count",     "c0_entryhi",   "c0_compare",
 412   "c0_status",    "c0_cause",     "c0_epc",       "c0_prid",
 413   "c0_config",    "c0_lladdr",    "c0_watchlo",   "c0_watchhi",
 414   "c0_xcontext",  "$21",          "$22",          "c0_debug",
 415   "c0_depc",      "c0_perfcnt",   "c0_errctl",    "c0_cacheerr_i",
 416   "c0_taglo_i",   "c0_taghi_i",   "c0_errorepc",  "c0_desave",
 417 };
 418
 419 /* XLR's CP0 Select Registers.  */
 420
 421 static const struct mips_cp0sel_name mips_cp0sel_names_xlr[] = {
 422   {  9, 6, "c0_extintreq"       },
 423   {  9, 7, "c0_extintmask"      },
 424   { 15, 1, "c0_ebase"           },
 425   { 16, 1, "c0_config1"         },
 426   { 16, 2, "c0_config2"         },
 427   { 16, 3, "c0_config3"         },
 428   { 16, 7, "c0_procid2"         },
 429   { 18, 1, "c0_watchlo,1"       },
 430   { 18, 2, "c0_watchlo,2"       },
 431   { 18, 3, "c0_watchlo,3"       },
 432   { 18, 4, "c0_watchlo,4"       },
 433   { 18, 5, "c0_watchlo,5"       },
 434   { 18, 6, "c0_watchlo,6"       },
 435   { 18, 7, "c0_watchlo,7"       },
 436   { 19, 1, "c0_watchhi,1"       },
 437   { 19, 2, "c0_watchhi,2"       },
 438   { 19, 3, "c0_watchhi,3"       },
 439   { 19, 4, "c0_watchhi,4"       },
 440   { 19, 5, "c0_watchhi,5"       },
 441   { 19, 6, "c0_watchhi,6"       },
 442   { 19, 7, "c0_watchhi,7"       },
 443   { 25, 1, "c0_perfcnt,1"       },
 444   { 25, 2, "c0_perfcnt,2"       },
 445   { 25, 3, "c0_perfcnt,3"       },
 446   { 25, 4, "c0_perfcnt,4"       },
 447   { 25, 5, "c0_perfcnt,5"       },
 448   { 25, 6, "c0_perfcnt,6"       },
 449   { 25, 7, "c0_perfcnt,7"       },
 450   { 27, 1, "c0_cacheerr,1"      },
 451   { 27, 2, "c0_cacheerr,2"      },
 452   { 27, 3, "c0_cacheerr,3"      },
 453   { 28, 1, "c0_datalo"          },
 454   { 29, 1, "c0_datahi"          }
 455 };
 456
 457 static const char * const mips_hwr_names_numeric[32] =
 458 {
 459   "$0",   "$1",   "$2",   "$3",   "$4",   "$5",   "$6",   "$7",
 460   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
 461   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
 462   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
 463 };
 464
 465 static const char * const mips_hwr_names_mips3264r2[32] =
 466 {
 467   "hwr_cpunum",   "hwr_synci_step", "hwr_cc",     "hwr_ccres",
 468   "$4",          "$5",            "$6",           "$7",
 469   "$8",   "$9",   "$10",  "$11",  "$12",  "$13",  "$14",  "$15",
 470   "$16",  "$17",  "$18",  "$19",  "$20",  "$21",  "$22",  "$23",
 471   "$24",  "$25",  "$26",  "$27",  "$28",  "$29",  "$30",  "$31"
 472 };
 473
 474 struct mips_abi_choice
 475 {
 476   const char * name;
 477   const char * const *gpr_names;
 478   const char * const *fpr_names;
 479 };
 480
 481 struct mips_abi_choice mips_abi_choices[] =
 482 {
 483   { "numeric", mips_gpr_names_numeric, mips_fpr_names_numeric },
 484   { "32", mips_gpr_names_oldabi, mips_fpr_names_32 },
 485   { "n32", mips_gpr_names_newabi, mips_fpr_names_n32 },
 486   { "64", mips_gpr_names_newabi, mips_fpr_names_64 },
 487 };
 488
 489 struct mips_arch_choice
 490 {
 491   const char *name;
 492   int bfd_mach_valid;
 493   unsigned long bfd_mach;
 494   int processor;
 495   int isa;
 496   const char * const *cp0_names;
 497   const struct mips_cp0sel_name *cp0sel_names;
 498   unsigned int cp0sel_names_len;
 499   const char * const *hwr_names;
 500 };
 501
 502 const struct mips_arch_choice mips_arch_choices[] =
 503 {
 504   { "numeric",  0, 0, 0, 0,
 505     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 506
 507   { "r3000",    1, bfd_mach_mips3000, CPU_R3000, ISA_MIPS1,
 508     mips_cp0_names_r3000, NULL, 0, mips_hwr_names_numeric },
 509   { "r3900",    1, bfd_mach_mips3900, CPU_R3900, ISA_MIPS1,
 510     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 511   { "r4000",    1, bfd_mach_mips4000, CPU_R4000, ISA_MIPS3,
 512     mips_cp0_names_r4000, NULL, 0, mips_hwr_names_numeric },
 513   { "r4010",    1, bfd_mach_mips4010, CPU_R4010, ISA_MIPS2,
 514     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 515   { "vr4100",   1, bfd_mach_mips4100, CPU_VR4100, ISA_MIPS3,
 516     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 517   { "vr4111",   1, bfd_mach_mips4111, CPU_R4111, ISA_MIPS3,
 518     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 519   { "vr4120",   1, bfd_mach_mips4120, CPU_VR4120, ISA_MIPS3,
 520     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 521   { "r4300",    1, bfd_mach_mips4300, CPU_R4300, ISA_MIPS3,
 522     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 523   { "r4400",    1, bfd_mach_mips4400, CPU_R4400, ISA_MIPS3,
 524     mips_cp0_names_r4000, NULL, 0, mips_hwr_names_numeric },
 525   { "r4600",    1, bfd_mach_mips4600, CPU_R4600, ISA_MIPS3,
 526     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 527   { "r4650",    1, bfd_mach_mips4650, CPU_R4650, ISA_MIPS3,
 528     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 529   { "r5000",    1, bfd_mach_mips5000, CPU_R5000, ISA_MIPS4,
 530     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 531   { "vr5400",   1, bfd_mach_mips5400, CPU_VR5400, ISA_MIPS4,
 532     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 533   { "vr5500",   1, bfd_mach_mips5500, CPU_VR5500, ISA_MIPS4,
 534     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 535   { "r6000",    1, bfd_mach_mips6000, CPU_R6000, ISA_MIPS2,
 536     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 537   { "rm7000",   1, bfd_mach_mips7000, CPU_RM7000, ISA_MIPS4,
 538     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 539   { "rm9000",   1, bfd_mach_mips7000, CPU_RM7000, ISA_MIPS4,
 540     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 541   { "r8000",    1, bfd_mach_mips8000, CPU_R8000, ISA_MIPS4,
 542     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 543   { "r10000",   1, bfd_mach_mips10000, CPU_R10000, ISA_MIPS4,
 544     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 545   { "r12000",   1, bfd_mach_mips12000, CPU_R12000, ISA_MIPS4,
 546     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 547   { "r14000",   1, bfd_mach_mips14000, CPU_R14000, ISA_MIPS4,
 548     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 549   { "r16000",   1, bfd_mach_mips16000, CPU_R16000, ISA_MIPS4,
 550     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 551   { "mips5",    1, bfd_mach_mips5, CPU_MIPS5, ISA_MIPS5,
 552     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 553
 554   /* For stock MIPS32, disassemble all applicable MIPS-specified ASEs.
 555      Note that MIPS-3D and MDMX are not applicable to MIPS32.  (See
 556      _MIPS32 Architecture For Programmers Volume I: Introduction to the
 557      MIPS32 Architecture_ (MIPS Document Number MD00082, Revision 0.95),
 558      page 1.  */
 559   { "mips32",   1, bfd_mach_mipsisa32, CPU_MIPS32,
 560     ISA_MIPS32 | INSN_SMARTMIPS,
 561     mips_cp0_names_mips3264,
 562     mips_cp0sel_names_mips3264, ARRAY_SIZE (mips_cp0sel_names_mips3264),
 563     mips_hwr_names_numeric },
 564
 565   { "mips32r2", 1, bfd_mach_mipsisa32r2, CPU_MIPS32R2,
 566     (ISA_MIPS32R2 | INSN_SMARTMIPS | INSN_DSP | INSN_DSPR2
 567      | INSN_MIPS3D | INSN_MT | INSN_MCU),
 568     mips_cp0_names_mips3264r2,
 569     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
 570     mips_hwr_names_mips3264r2 },
 571
 572   /* For stock MIPS64, disassemble all applicable MIPS-specified ASEs.  */
 573   { "mips64",   1, bfd_mach_mipsisa64, CPU_MIPS64,
 574     ISA_MIPS64 | INSN_MIPS3D | INSN_MDMX,
 575     mips_cp0_names_mips3264,
 576     mips_cp0sel_names_mips3264, ARRAY_SIZE (mips_cp0sel_names_mips3264),
 577     mips_hwr_names_numeric },
 578
 579   { "mips64r2", 1, bfd_mach_mipsisa64r2, CPU_MIPS64R2,
 580     (ISA_MIPS64R2 | INSN_MIPS3D | INSN_DSP | INSN_DSPR2
 581      | INSN_DSP64 | INSN_MT | INSN_MDMX | INSN_MCU),
 582     mips_cp0_names_mips3264r2,
 583     mips_cp0sel_names_mips3264r2, ARRAY_SIZE (mips_cp0sel_names_mips3264r2),
 584     mips_hwr_names_mips3264r2 },
 585
 586   { "sb1",      1, bfd_mach_mips_sb1, CPU_SB1,
 587     ISA_MIPS64 | INSN_MIPS3D | INSN_SB1,
 588     mips_cp0_names_sb1,
 589     mips_cp0sel_names_sb1, ARRAY_SIZE (mips_cp0sel_names_sb1),
 590     mips_hwr_names_numeric },
 591
 592   { "loongson2e",   1, bfd_mach_mips_loongson_2e, CPU_LOONGSON_2E,
 593     ISA_MIPS3 | INSN_LOONGSON_2E, mips_cp0_names_numeric,
 594     NULL, 0, mips_hwr_names_numeric },
 595
 596   { "loongson2f",   1, bfd_mach_mips_loongson_2f, CPU_LOONGSON_2F,
 597     ISA_MIPS3 | INSN_LOONGSON_2F, mips_cp0_names_numeric,
 598     NULL, 0, mips_hwr_names_numeric },
 599
 600   { "loongson3a",   1, bfd_mach_mips_loongson_3a, CPU_LOONGSON_3A,
 601     ISA_MIPS64 | INSN_LOONGSON_3A, mips_cp0_names_numeric,
 602     NULL, 0, mips_hwr_names_numeric },
 603
 604   { "octeon",   1, bfd_mach_mips_octeon, CPU_OCTEON,
 605     ISA_MIPS64R2 | INSN_OCTEON, mips_cp0_names_numeric, NULL, 0,
 606     mips_hwr_names_numeric },
 607
 608   { "octeon+",   1, bfd_mach_mips_octeonp, CPU_OCTEONP,
 609     ISA_MIPS64R2 | INSN_OCTEONP, mips_cp0_names_numeric,
 610     NULL, 0, mips_hwr_names_numeric },
 611
 612   { "octeon2",   1, bfd_mach_mips_octeon2, CPU_OCTEON2,
 613     ISA_MIPS64R2 | INSN_OCTEON2, mips_cp0_names_numeric,
 614     NULL, 0, mips_hwr_names_numeric },
 615
 616   { "xlr", 1, bfd_mach_mips_xlr, CPU_XLR,
 617     ISA_MIPS64 | INSN_XLR,
 618     mips_cp0_names_xlr,
 619     mips_cp0sel_names_xlr, ARRAY_SIZE (mips_cp0sel_names_xlr),
 620     mips_hwr_names_numeric },
 621
 622   /* XLP is mostly like XLR, with the prominent exception it is being
 623      MIPS64R2.  */
 624   { "xlp", 1, bfd_mach_mips_xlr, CPU_XLR,
 625     ISA_MIPS64R2 | INSN_XLR,
 626     mips_cp0_names_xlr,
 627     mips_cp0sel_names_xlr, ARRAY_SIZE (mips_cp0sel_names_xlr),
 628     mips_hwr_names_numeric },
 629
 630   /* This entry, mips16, is here only for ISA/processor selection; do
 631      not print its name.  */
 632   { "",         1, bfd_mach_mips16, CPU_MIPS16, ISA_MIPS3,
 633     mips_cp0_names_numeric, NULL, 0, mips_hwr_names_numeric },
 634 };
 635
 636 /* ISA and processor type to disassemble for, and register names to use.
 637    set_default_mips_dis_options and parse_mips_dis_options fill in these
 638    values.  */
 639 static int mips_processor;
 640 static int mips_isa;
 641 static int micromips_ase;
 642 static const char * const *mips_gpr_names;
 643 static const char * const *mips_fpr_names;
 644 static const char * const *mips_cp0_names;
 645 static const struct mips_cp0sel_name *mips_cp0sel_names;
 646 static int mips_cp0sel_names_len;
 647 static const char * const *mips_hwr_names;
 648
 649 /* Other options */
 650 static int no_aliases;  /* If set disassemble as most general inst.  */
 651 \f
 652 static const struct mips_abi_choice *
 653 choose_abi_by_name (const char *name, unsigned int namelen)
 654 {
 655   const struct mips_abi_choice *c;
 656   unsigned int i;
 657
 658   for (i = 0, c = NULL; i < ARRAY_SIZE (mips_abi_choices) && c == NULL; i++)
 659     if (strncmp (mips_abi_choices[i].name, name, namelen) == 0
 660         && strlen (mips_abi_choices[i].name) == namelen)
 661       c = &mips_abi_choices[i];
 662
 663   return c;
 664 }
 665
 666 static const struct mips_arch_choice *
 667 choose_arch_by_name (const char *name, unsigned int namelen)
 668 {
 669   const struct mips_arch_choice *c = NULL;
 670   unsigned int i;
 671
 672   for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
 673     if (strncmp (mips_arch_choices[i].name, name, namelen) == 0
 674         && strlen (mips_arch_choices[i].name) == namelen)
 675       c = &mips_arch_choices[i];
 676
 677   return c;
 678 }
 679
 680 static const struct mips_arch_choice *
 681 choose_arch_by_number (unsigned long mach)
 682 {
 683   static unsigned long hint_bfd_mach;
 684   static const struct mips_arch_choice *hint_arch_choice;
 685   const struct mips_arch_choice *c;
 686   unsigned int i;
 687
 688   /* We optimize this because even if the user specifies no
 689      flags, this will be done for every instruction!  */
 690   if (hint_bfd_mach == mach
 691       && hint_arch_choice != NULL
 692       && hint_arch_choice->bfd_mach == hint_bfd_mach)
 693     return hint_arch_choice;
 694
 695   for (i = 0, c = NULL; i < ARRAY_SIZE (mips_arch_choices) && c == NULL; i++)
 696     {
 697       if (mips_arch_choices[i].bfd_mach_valid
 698           && mips_arch_choices[i].bfd_mach == mach)
 699         {
 700           c = &mips_arch_choices[i];
 701           hint_bfd_mach = mach;
 702           hint_arch_choice = c;
 703         }
 704     }
 705   return c;
 706 }
 707
 708 /* Check if the object uses NewABI conventions.  */
 709
 710 static int
 711 is_newabi (Elf_Internal_Ehdr *header)
 712 {
 713   /* There are no old-style ABIs which use 64-bit ELF.  */
 714   if (header->e_ident[EI_CLASS] == ELFCLASS64)
 715     return 1;
 716
 717   /* If a 32-bit ELF file, n32 is a new-style ABI.  */
 718   if ((header->e_flags & EF_MIPS_ABI2) != 0)
 719     return 1;
 720
 721   return 0;
 722 }
 723
 724 /* Check if the object has microMIPS ASE code.  */
 725
 726 static int
 727 is_micromips (Elf_Internal_Ehdr *header)
 728 {
 729   if ((header->e_flags & EF_MIPS_ARCH_ASE_MICROMIPS) != 0)
 730     return 1;
 731
 732   return 0;
 733 }
 734
 735 static void
 736 set_default_mips_dis_options (struct disassemble_info *info)
 737 {
 738   const struct mips_arch_choice *chosen_arch;
 739
 740   /* Defaults: mipsIII/r3000 (?!), no microMIPS ASE (any compressed code
 741      is MIPS16 ASE) (o)32-style ("oldabi") GPR names, and numeric FPR,
 742      CP0 register, and HWR names.  */
 743   mips_isa = ISA_MIPS3;
 744   mips_processor = CPU_R3000;
 745   micromips_ase = 0;
 746   mips_gpr_names = mips_gpr_names_oldabi;
 747   mips_fpr_names = mips_fpr_names_numeric;
 748   mips_cp0_names = mips_cp0_names_numeric;
 749   mips_cp0sel_names = NULL;
 750   mips_cp0sel_names_len = 0;
 751   mips_hwr_names = mips_hwr_names_numeric;
 752   no_aliases = 0;
 753
 754   /* Update settings according to the ELF file header flags.  */
 755   if (info->flavour == bfd_target_elf_flavour && info->section != NULL)
 756     {
 757       Elf_Internal_Ehdr *header;
 758
 759       header = elf_elfheader (info->section->owner);
 760       /* If an ELF "newabi" binary, use the n32/(n)64 GPR names.  */
 761       if (is_newabi (header))
 762         mips_gpr_names = mips_gpr_names_newabi;
 763       /* If a microMIPS binary, then don't use MIPS16 bindings.  */
 764       micromips_ase = is_micromips (header);
 765     }
 766
 767   /* Set ISA, architecture, and cp0 register names as best we can.  */
 768 #if ! SYMTAB_AVAILABLE
 769   /* This is running out on a target machine, not in a host tool.
 770      FIXME: Where does mips_target_info come from?  */
 771   target_processor = mips_target_info.processor;
 772   mips_isa = mips_target_info.isa;
 773 #else
 774   chosen_arch = choose_arch_by_number (info->mach);
 775   if (chosen_arch != NULL)
 776     {
 777       mips_processor = chosen_arch->processor;
 778       mips_isa = chosen_arch->isa;
 779       mips_cp0_names = chosen_arch->cp0_names;
 780       mips_cp0sel_names = chosen_arch->cp0sel_names;
 781       mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
 782       mips_hwr_names = chosen_arch->hwr_names;
 783     }
 784 #endif
 785 }
 786
 787 static void
 788 parse_mips_dis_option (const char *option, unsigned int len)
 789 {
 790   unsigned int i, optionlen, vallen;
 791   const char *val;
 792   const struct mips_abi_choice *chosen_abi;
 793   const struct mips_arch_choice *chosen_arch;
 794
 795   /* Try to match options that are simple flags */
 796   if (CONST_STRNEQ (option, "no-aliases"))
 797     {
 798       no_aliases = 1;
 799       return;
 800     }
 801
 802   /* Look for the = that delimits the end of the option name.  */
 803   for (i = 0; i < len; i++)
 804     if (option[i] == '=')
 805       break;
 806
 807   if (i == 0)           /* Invalid option: no name before '='.  */
 808     return;
 809   if (i == len)         /* Invalid option: no '='.  */
 810     return;
 811   if (i == (len - 1))   /* Invalid option: no value after '='.  */
 812     return;
 813
 814   optionlen = i;
 815   val = option + (optionlen + 1);
 816   vallen = len - (optionlen + 1);
 817
 818   if (strncmp ("gpr-names", option, optionlen) == 0
 819       && strlen ("gpr-names") == optionlen)
 820     {
 821       chosen_abi = choose_abi_by_name (val, vallen);
 822       if (chosen_abi != NULL)
 823         mips_gpr_names = chosen_abi->gpr_names;
 824       return;
 825     }
 826
 827   if (strncmp ("fpr-names", option, optionlen) == 0
 828       && strlen ("fpr-names") == optionlen)
 829     {
 830       chosen_abi = choose_abi_by_name (val, vallen);
 831       if (chosen_abi != NULL)
 832         mips_fpr_names = chosen_abi->fpr_names;
 833       return;
 834     }
 835
 836   if (strncmp ("cp0-names", option, optionlen) == 0
 837       && strlen ("cp0-names") == optionlen)
 838     {
 839       chosen_arch = choose_arch_by_name (val, vallen);
 840       if (chosen_arch != NULL)
 841         {
 842           mips_cp0_names = chosen_arch->cp0_names;
 843           mips_cp0sel_names = chosen_arch->cp0sel_names;
 844           mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
 845         }
 846       return;
 847     }
 848
 849   if (strncmp ("hwr-names", option, optionlen) == 0
 850       && strlen ("hwr-names") == optionlen)
 851     {
 852       chosen_arch = choose_arch_by_name (val, vallen);
 853       if (chosen_arch != NULL)
 854         mips_hwr_names = chosen_arch->hwr_names;
 855       return;
 856     }
 857
 858   if (strncmp ("reg-names", option, optionlen) == 0
 859       && strlen ("reg-names") == optionlen)
 860     {
 861       /* We check both ABI and ARCH here unconditionally, so
 862          that "numeric" will do the desirable thing: select
 863          numeric register names for all registers.  Other than
 864          that, a given name probably won't match both.  */
 865       chosen_abi = choose_abi_by_name (val, vallen);
 866       if (chosen_abi != NULL)
 867         {
 868           mips_gpr_names = chosen_abi->gpr_names;
 869           mips_fpr_names = chosen_abi->fpr_names;
 870         }
 871       chosen_arch = choose_arch_by_name (val, vallen);
 872       if (chosen_arch != NULL)
 873         {
 874           mips_cp0_names = chosen_arch->cp0_names;
 875           mips_cp0sel_names = chosen_arch->cp0sel_names;
 876           mips_cp0sel_names_len = chosen_arch->cp0sel_names_len;
 877           mips_hwr_names = chosen_arch->hwr_names;
 878         }
 879       return;
 880     }
 881
 882   /* Invalid option.  */
 883 }
 884
 885 static void
 886 parse_mips_dis_options (const char *options)
 887 {
 888   const char *option_end;
 889
 890   if (options == NULL)
 891     return;
 892
 893   while (*options != '\0')
 894     {
 895       /* Skip empty options.  */
 896       if (*options == ',')
 897         {
 898           options++;
 899           continue;
 900         }
 901
 902       /* We know that *options is neither NUL or a comma.  */
 903       option_end = options + 1;
 904       while (*option_end != ',' && *option_end != '\0')
 905         option_end++;
 906
 907       parse_mips_dis_option (options, option_end - options);
 908
 909       /* Go on to the next one.  If option_end points to a comma, it
 910          will be skipped above.  */
 911       options = option_end;
 912     }
 913 }
 914
 915 static const struct mips_cp0sel_name *
 916 lookup_mips_cp0sel_name (const struct mips_cp0sel_name *names,
 917                          unsigned int len,
 918                          unsigned int cp0reg,
 919                          unsigned int sel)
 920 {
 921   unsigned int i;
 922
 923   for (i = 0; i < len; i++)
 924     if (names[i].cp0reg == cp0reg && names[i].sel == sel)
 925       return &names[i];
 926   return NULL;
 927 }
 928 \f
 929 /* Print insn arguments for 32/64-bit code.  */
 930
 931 static void
 932 print_insn_args (const char *d,
 933                  register unsigned long int l,
 934                  bfd_vma pc,
 935                  struct disassemble_info *info,
 936                  const struct mips_opcode *opp)
 937 {
 938   int op, delta;
 939   unsigned int lsb, msb, msbd;
 940
 941   lsb = 0;
 942
 943   for (; *d != '\0'; d++)
 944     {
 945       switch (*d)
 946         {
 947         case ',':
 948         case '(':
 949         case ')':
 950         case '[':
 951         case ']':
 952           (*info->fprintf_func) (info->stream, "%c", *d);
 953           break;
 954
 955         case '+':
 956           /* Extension character; switch for second char.  */
 957           d++;
 958           switch (*d)
 959             {
 960             case '\0':
 961               /* xgettext:c-format */
 962               (*info->fprintf_func) (info->stream,
 963                                      _("# internal error, incomplete extension sequence (+)"));
 964               return;
 965
 966             case 'A':
 967               lsb = (l >> OP_SH_SHAMT) & OP_MASK_SHAMT;
 968               (*info->fprintf_func) (info->stream, "0x%x", lsb);
 969               break;
 970
 971             case 'B':
 972               msb = (l >> OP_SH_INSMSB) & OP_MASK_INSMSB;
 973               (*info->fprintf_func) (info->stream, "0x%x", msb - lsb + 1);
 974               break;
 975
 976             case '1':
 977               (*info->fprintf_func) (info->stream, "0x%lx",
 978                                      (l >> OP_SH_UDI1) & OP_MASK_UDI1);
 979               break;
 980
 981             case '2':
 982               (*info->fprintf_func) (info->stream, "0x%lx",
 983                                      (l >> OP_SH_UDI2) & OP_MASK_UDI2);
 984               break;
 985
 986             case '3':
 987               (*info->fprintf_func) (info->stream, "0x%lx",
 988                                      (l >> OP_SH_UDI3) & OP_MASK_UDI3);
 989               break;
 990
 991             case '4':
 992               (*info->fprintf_func) (info->stream, "0x%lx",
 993                                      (l >> OP_SH_UDI4) & OP_MASK_UDI4);
 994               break;
 995
 996             case 'C':
 997             case 'H':
 998               msbd = (l >> OP_SH_EXTMSBD) & OP_MASK_EXTMSBD;
 999               (*info->fprintf_func) (info->stream, "0x%x", msbd + 1);
1000               break;
1001
1002             case 'D':
1003               {
1004                 const struct mips_cp0sel_name *n;
1005                 unsigned int cp0reg, sel;
1006
1007                 cp0reg = (l >> OP_SH_RD) & OP_MASK_RD;
1008                 sel = (l >> OP_SH_SEL) & OP_MASK_SEL;
1009
1010                 /* CP0 register including 'sel' code for mtcN (et al.), to be
1011                    printed textually if known.  If not known, print both
1012                    CP0 register name and sel numerically since CP0 register
1013                    with sel 0 may have a name unrelated to register being
1014                    printed.  */
1015                 n = lookup_mips_cp0sel_name(mips_cp0sel_names,
1016                                             mips_cp0sel_names_len, cp0reg, sel);
1017                 if (n != NULL)
1018                   (*info->fprintf_func) (info->stream, "%s", n->name);
1019                 else
1020                   (*info->fprintf_func) (info->stream, "$%d,%d", cp0reg, sel);
1021                 break;
1022               }
1023
1024             case 'E':
1025               lsb = ((l >> OP_SH_SHAMT) & OP_MASK_SHAMT) + 32;
1026               (*info->fprintf_func) (info->stream, "0x%x", lsb);
1027               break;
1028
1029             case 'F':
1030               msb = ((l >> OP_SH_INSMSB) & OP_MASK_INSMSB) + 32;
1031               (*info->fprintf_func) (info->stream, "0x%x", msb - lsb + 1);
1032               break;
1033
1034             case 'G':
1035               msbd = ((l >> OP_SH_EXTMSBD) & OP_MASK_EXTMSBD) + 32;
1036               (*info->fprintf_func) (info->stream, "0x%x", msbd + 1);
1037               break;
1038
1039             case 't': /* Coprocessor 0 reg name */
1040               (*info->fprintf_func) (info->stream, "%s",
1041                                      mips_cp0_names[(l >> OP_SH_RT) &
1042                                                      OP_MASK_RT]);
1043               break;
1044
1045             case 'T': /* Coprocessor 0 reg name */
1046               {
1047                 const struct mips_cp0sel_name *n;
1048                 unsigned int cp0reg, sel;
1049
1050                 cp0reg = (l >> OP_SH_RT) & OP_MASK_RT;
1051                 sel = (l >> OP_SH_SEL) & OP_MASK_SEL;
1052
1053                 /* CP0 register including 'sel' code for mftc0, to be
1054                    printed textually if known.  If not known, print both
1055                    CP0 register name and sel numerically since CP0 register
1056                    with sel 0 may have a name unrelated to register being
1057                    printed.  */
1058                 n = lookup_mips_cp0sel_name(mips_cp0sel_names,
1059                                             mips_cp0sel_names_len, cp0reg, sel);
1060                 if (n != NULL)
1061                   (*info->fprintf_func) (info->stream, "%s", n->name);
1062                 else
1063                   (*info->fprintf_func) (info->stream, "$%d,%d", cp0reg, sel);
1064                 break;
1065               }
1066
1067             case 'x':           /* bbit bit index */
1068               (*info->fprintf_func) (info->stream, "0x%lx",
1069                                      (l >> OP_SH_BBITIND) & OP_MASK_BBITIND);
1070               break;
1071
1072             case 'p':           /* cins, cins32, exts and exts32 position */
1073               (*info->fprintf_func) (info->stream, "0x%lx",
1074                                      (l >> OP_SH_CINSPOS) & OP_MASK_CINSPOS);
1075               break;
1076
1077             case 's':           /* cins and exts length-minus-one */
1078               (*info->fprintf_func) (info->stream, "0x%lx",
1079                                      (l >> OP_SH_CINSLM1) & OP_MASK_CINSLM1);
1080               break;
1081
1082             case 'S':           /* cins32 and exts32 length-minus-one field */
1083               (*info->fprintf_func) (info->stream, "0x%lx",
1084                                      (l >> OP_SH_CINSLM1) & OP_MASK_CINSLM1);
1085               break;
1086
1087             case 'Q':           /* seqi/snei immediate field */
1088               op = (l >> OP_SH_SEQI) & OP_MASK_SEQI;
1089               /* Sign-extend it.  */
1090               op = (op ^ 512) - 512;
1091               (*info->fprintf_func) (info->stream, "%d", op);
1092               break;
1093
1094             case 'a':           /* 8-bit signed offset in bit 6 */
1095               delta = (l >> OP_SH_OFFSET_A) & OP_MASK_OFFSET_A;
1096               if (delta & 0x80)
1097                 delta |= ~OP_MASK_OFFSET_A;
1098               (*info->fprintf_func) (info->stream, "%d", delta);
1099               break;
1100
1101             case 'b':           /* 8-bit signed offset in bit 3 */
1102               delta = (l >> OP_SH_OFFSET_B) & OP_MASK_OFFSET_B;
1103               if (delta & 0x80)
1104                 delta |= ~OP_MASK_OFFSET_B;
1105               (*info->fprintf_func) (info->stream, "%d", delta);
1106               break;
1107
1108             case 'c':           /* 9-bit signed offset in bit 6 */
1109               delta = (l >> OP_SH_OFFSET_C) & OP_MASK_OFFSET_C;
1110               if (delta & 0x100)
1111                 delta |= ~OP_MASK_OFFSET_C;
1112               /* Left shift 4 bits to print the real offset.  */
1113               (*info->fprintf_func) (info->stream, "%d", delta << 4);
1114               break;
1115
1116             case 'z':
1117               (*info->fprintf_func) (info->stream, "%s",
1118                                      mips_gpr_names[(l >> OP_SH_RZ) & OP_MASK_RZ]);
1119               break;
1120
1121             case 'Z':
1122               (*info->fprintf_func) (info->stream, "%s",
1123                                      mips_fpr_names[(l >> OP_SH_FZ) & OP_MASK_FZ]);
1124               break;
1125
1126             default:
1127               /* xgettext:c-format */
1128               (*info->fprintf_func) (info->stream,
1129                                      _("# internal error, undefined extension sequence (+%c)"),
1130                                      *d);
1131               return;
1132             }
1133           break;
1134
1135         case '2':
1136           (*info->fprintf_func) (info->stream, "0x%lx",
1137                                  (l >> OP_SH_BP) & OP_MASK_BP);
1138           break;
1139
1140         case '3':
1141           (*info->fprintf_func) (info->stream, "0x%lx",
1142                                  (l >> OP_SH_SA3) & OP_MASK_SA3);
1143           break;
1144
1145         case '4':
1146           (*info->fprintf_func) (info->stream, "0x%lx",
1147                                  (l >> OP_SH_SA4) & OP_MASK_SA4);
1148           break;
1149
1150         case '5':
1151           (*info->fprintf_func) (info->stream, "0x%lx",
1152                                  (l >> OP_SH_IMM8) & OP_MASK_IMM8);
1153           break;
1154
1155         case '6':
1156           (*info->fprintf_func) (info->stream, "0x%lx",
1157                                  (l >> OP_SH_RS) & OP_MASK_RS);
1158           break;
1159
1160         case '7':
1161           (*info->fprintf_func) (info->stream, "$ac%ld",
1162                                  (l >> OP_SH_DSPACC) & OP_MASK_DSPACC);
1163           break;
1164
1165         case '8':
1166           (*info->fprintf_func) (info->stream, "0x%lx",
1167                                  (l >> OP_SH_WRDSP) & OP_MASK_WRDSP);
1168           break;
1169
1170         case '9':
1171           (*info->fprintf_func) (info->stream, "$ac%ld",
1172                                  (l >> OP_SH_DSPACC_S) & OP_MASK_DSPACC_S);
1173           break;
1174
1175         case '0': /* dsp 6-bit signed immediate in bit 20 */
1176           delta = ((l >> OP_SH_DSPSFT) & OP_MASK_DSPSFT);
1177           if (delta & 0x20) /* test sign bit */
1178             delta |= ~OP_MASK_DSPSFT;
1179           (*info->fprintf_func) (info->stream, "%d", delta);
1180           break;
1181
1182         case ':': /* dsp 7-bit signed immediate in bit 19 */
1183           delta = ((l >> OP_SH_DSPSFT_7) & OP_MASK_DSPSFT_7);
1184           if (delta & 0x40) /* test sign bit */
1185             delta |= ~OP_MASK_DSPSFT_7;
1186           (*info->fprintf_func) (info->stream, "%d", delta);
1187           break;
1188
1189         case '~':
1190           delta = (l >> OP_SH_OFFSET12) & OP_MASK_OFFSET12;
1191           if (delta & 0x800)
1192             delta |= ~0x7ff;
1193           (*info->fprintf_func) (info->stream, "%d", delta);
1194           break;
1195
1196         case '\\':
1197           (*info->fprintf_func) (info->stream, "0x%lx",
1198                                  (l >> OP_SH_3BITPOS) & OP_MASK_3BITPOS);
1199           break;
1200
1201         case '\'':
1202           (*info->fprintf_func) (info->stream, "0x%lx",
1203                                  (l >> OP_SH_RDDSP) & OP_MASK_RDDSP);
1204           break;
1205
1206         case '@': /* dsp 10-bit signed immediate in bit 16 */
1207           delta = ((l >> OP_SH_IMM10) & OP_MASK_IMM10);
1208           if (delta & 0x200) /* test sign bit */
1209             delta |= ~OP_MASK_IMM10;
1210           (*info->fprintf_func) (info->stream, "%d", delta);
1211           break;
1212
1213         case '!':
1214           (*info->fprintf_func) (info->stream, "%ld",
1215                                  (l >> OP_SH_MT_U) & OP_MASK_MT_U);
1216           break;
1217
1218         case '$':
1219           (*info->fprintf_func) (info->stream, "%ld",
1220                                  (l >> OP_SH_MT_H) & OP_MASK_MT_H);
1221           break;
1222
1223         case '*':
1224           (*info->fprintf_func) (info->stream, "$ac%ld",
1225                                  (l >> OP_SH_MTACC_T) & OP_MASK_MTACC_T);
1226           break;
1227
1228         case '&':
1229           (*info->fprintf_func) (info->stream, "$ac%ld",
1230                                  (l >> OP_SH_MTACC_D) & OP_MASK_MTACC_D);
1231           break;
1232
1233         case 'g':
1234           /* Coprocessor register for CTTC1, MTTC2, MTHC2, CTTC2.  */
1235           (*info->fprintf_func) (info->stream, "$%ld",
1236                                  (l >> OP_SH_RD) & OP_MASK_RD);
1237           break;
1238
1239         case 's':
1240         case 'b':
1241         case 'r':
1242         case 'v':
1243           (*info->fprintf_func) (info->stream, "%s",
1244                                  mips_gpr_names[(l >> OP_SH_RS) & OP_MASK_RS]);
1245           break;
1246
1247         case 't':
1248         case 'w':
1249           (*info->fprintf_func) (info->stream, "%s",
1250                                  mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1251           break;
1252
1253         case 'i':
1254         case 'u':
1255           (*info->fprintf_func) (info->stream, "0x%lx",
1256                                  (l >> OP_SH_IMMEDIATE) & OP_MASK_IMMEDIATE);
1257           break;
1258
1259         case 'j': /* Same as i, but sign-extended.  */
1260         case 'o':
1261           delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
1262           if (delta & 0x8000)
1263             delta |= ~0xffff;
1264           (*info->fprintf_func) (info->stream, "%d",
1265                                  delta);
1266           break;
1267
1268         case 'h':
1269           (*info->fprintf_func) (info->stream, "0x%x",
1270                                  (unsigned int) ((l >> OP_SH_PREFX)
1271                                                  & OP_MASK_PREFX));
1272           break;
1273
1274         case 'k':
1275           (*info->fprintf_func) (info->stream, "0x%x",
1276                                  (unsigned int) ((l >> OP_SH_CACHE)
1277                                                  & OP_MASK_CACHE));
1278           break;
1279
1280         case 'a':
1281           info->target = (((pc + 4) & ~(bfd_vma) 0x0fffffff)
1282                           | (((l >> OP_SH_TARGET) & OP_MASK_TARGET) << 2));
1283           /* For gdb disassembler, force odd address on jalx.  */
1284           if (info->flavour == bfd_target_unknown_flavour
1285               && strcmp (opp->name, "jalx") == 0)
1286             info->target |= 1;
1287           (*info->print_address_func) (info->target, info);
1288           break;
1289
1290         case 'p':
1291           /* Sign extend the displacement.  */
1292           delta = (l >> OP_SH_DELTA) & OP_MASK_DELTA;
1293           if (delta & 0x8000)
1294             delta |= ~0xffff;
1295           info->target = (delta << 2) + pc + INSNLEN;
1296           (*info->print_address_func) (info->target, info);
1297           break;
1298
1299         case 'd':
1300           (*info->fprintf_func) (info->stream, "%s",
1301                                  mips_gpr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1302           break;
1303
1304         case 'U':
1305           {
1306             /* First check for both rd and rt being equal.  */
1307             unsigned int reg = (l >> OP_SH_RD) & OP_MASK_RD;
1308             if (reg == ((l >> OP_SH_RT) & OP_MASK_RT))
1309               (*info->fprintf_func) (info->stream, "%s",
1310                                      mips_gpr_names[reg]);
1311             else
1312               {
1313                 /* If one is zero use the other.  */
1314                 if (reg == 0)
1315                   (*info->fprintf_func) (info->stream, "%s",
1316                                          mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1317                 else if (((l >> OP_SH_RT) & OP_MASK_RT) == 0)
1318                   (*info->fprintf_func) (info->stream, "%s",
1319                                          mips_gpr_names[reg]);
1320                 else /* Bogus, result depends on processor.  */
1321                   (*info->fprintf_func) (info->stream, "%s or %s",
1322                                          mips_gpr_names[reg],
1323                                          mips_gpr_names[(l >> OP_SH_RT) & OP_MASK_RT]);
1324               }
1325           }
1326           break;
1327
1328         case 'z':
1329           (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1330           break;
1331
1332         case '<':
1333         case '1':
1334           (*info->fprintf_func) (info->stream, "0x%lx",
1335                                  (l >> OP_SH_SHAMT) & OP_MASK_SHAMT);
1336           break;
1337
1338         case 'c':
1339           (*info->fprintf_func) (info->stream, "0x%lx",
1340                                  (l >> OP_SH_CODE) & OP_MASK_CODE);
1341           break;
1342
1343         case 'q':
1344           (*info->fprintf_func) (info->stream, "0x%lx",
1345                                  (l >> OP_SH_CODE2) & OP_MASK_CODE2);
1346           break;
1347
1348         case 'C':
1349           (*info->fprintf_func) (info->stream, "0x%lx",
1350                                  (l >> OP_SH_COPZ) & OP_MASK_COPZ);
1351           break;
1352
1353         case 'B':
1354           (*info->fprintf_func) (info->stream, "0x%lx",
1355                                  (l >> OP_SH_CODE20) & OP_MASK_CODE20);
1356           break;
1357
1358         case 'J':
1359           (*info->fprintf_func) (info->stream, "0x%lx",
1360                                  (l >> OP_SH_CODE19) & OP_MASK_CODE19);
1361           break;
1362
1363         case 'S':
1364         case 'V':
1365           (*info->fprintf_func) (info->stream, "%s",
1366                                  mips_fpr_names[(l >> OP_SH_FS) & OP_MASK_FS]);
1367           break;
1368
1369         case 'T':
1370         case 'W':
1371           (*info->fprintf_func) (info->stream, "%s",
1372                                  mips_fpr_names[(l >> OP_SH_FT) & OP_MASK_FT]);
1373           break;
1374
1375         case 'D':
1376           (*info->fprintf_func) (info->stream, "%s",
1377                                  mips_fpr_names[(l >> OP_SH_FD) & OP_MASK_FD]);
1378           break;
1379
1380         case 'R':
1381           (*info->fprintf_func) (info->stream, "%s",
1382                                  mips_fpr_names[(l >> OP_SH_FR) & OP_MASK_FR]);
1383           break;
1384
1385         case 'E':
1386           /* Coprocessor register for lwcN instructions, et al.
1387
1388              Note that there is no load/store cp0 instructions, and
1389              that FPU (cp1) instructions disassemble this field using
1390              'T' format.  Therefore, until we gain understanding of
1391              cp2 register names, we can simply print the register
1392              numbers.  */
1393           (*info->fprintf_func) (info->stream, "$%ld",
1394                                  (l >> OP_SH_RT) & OP_MASK_RT);
1395           break;
1396
1397         case 'G':
1398           /* Coprocessor register for mtcN instructions, et al.  Note
1399              that FPU (cp1) instructions disassemble this field using
1400              'S' format.  Therefore, we only need to worry about cp0,
1401              cp2, and cp3.  */
1402           op = (l >> OP_SH_OP) & OP_MASK_OP;
1403           if (op == OP_OP_COP0)
1404             (*info->fprintf_func) (info->stream, "%s",
1405                                    mips_cp0_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1406           else
1407             (*info->fprintf_func) (info->stream, "$%ld",
1408                                    (l >> OP_SH_RD) & OP_MASK_RD);
1409           break;
1410
1411         case 'K':
1412           (*info->fprintf_func) (info->stream, "%s",
1413                                  mips_hwr_names[(l >> OP_SH_RD) & OP_MASK_RD]);
1414           break;
1415
1416         case 'N':
1417           (*info->fprintf_func) (info->stream,
1418                                  ((opp->pinfo & (FP_D | FP_S)) != 0
1419                                   ? "$fcc%ld" : "$cc%ld"),
1420                                  (l >> OP_SH_BCC) & OP_MASK_BCC);
1421           break;
1422
1423         case 'M':
1424           (*info->fprintf_func) (info->stream, "$fcc%ld",
1425                                  (l >> OP_SH_CCC) & OP_MASK_CCC);
1426           break;
1427
1428         case 'P':
1429           (*info->fprintf_func) (info->stream, "%ld",
1430                                  (l >> OP_SH_PERFREG) & OP_MASK_PERFREG);
1431           break;
1432
1433         case 'e':
1434           (*info->fprintf_func) (info->stream, "%ld",
1435                                  (l >> OP_SH_VECBYTE) & OP_MASK_VECBYTE);
1436           break;
1437
1438         case '%':
1439           (*info->fprintf_func) (info->stream, "%ld",
1440                                  (l >> OP_SH_VECALIGN) & OP_MASK_VECALIGN);
1441           break;
1442
1443         case 'H':
1444           (*info->fprintf_func) (info->stream, "%ld",
1445                                  (l >> OP_SH_SEL) & OP_MASK_SEL);
1446           break;
1447
1448         case 'O':
1449           (*info->fprintf_func) (info->stream, "%ld",
1450                                  (l >> OP_SH_ALN) & OP_MASK_ALN);
1451           break;
1452
1453         case 'Q':
1454           {
1455             unsigned int vsel = (l >> OP_SH_VSEL) & OP_MASK_VSEL;
1456
1457             if ((vsel & 0x10) == 0)
1458               {
1459                 int fmt;
1460
1461                 vsel &= 0x0f;
1462                 for (fmt = 0; fmt < 3; fmt++, vsel >>= 1)
1463                   if ((vsel & 1) == 0)
1464                     break;
1465                 (*info->fprintf_func) (info->stream, "$v%ld[%d]",
1466                                        (l >> OP_SH_FT) & OP_MASK_FT,
1467                                        vsel >> 1);
1468               }
1469             else if ((vsel & 0x08) == 0)
1470               {
1471                 (*info->fprintf_func) (info->stream, "$v%ld",
1472                                        (l >> OP_SH_FT) & OP_MASK_FT);
1473               }
1474             else
1475               {
1476                 (*info->fprintf_func) (info->stream, "0x%lx",
1477                                        (l >> OP_SH_FT) & OP_MASK_FT);
1478               }
1479           }
1480           break;
1481
1482         case 'X':
1483           (*info->fprintf_func) (info->stream, "$v%ld",
1484                                  (l >> OP_SH_FD) & OP_MASK_FD);
1485           break;
1486
1487         case 'Y':
1488           (*info->fprintf_func) (info->stream, "$v%ld",
1489                                  (l >> OP_SH_FS) & OP_MASK_FS);
1490           break;
1491
1492         case 'Z':
1493           (*info->fprintf_func) (info->stream, "$v%ld",
1494                                  (l >> OP_SH_FT) & OP_MASK_FT);
1495           break;
1496
1497         default:
1498           /* xgettext:c-format */
1499           (*info->fprintf_func) (info->stream,
1500                                  _("# internal error, undefined modifier (%c)"),
1501                                  *d);
1502           return;
1503         }
1504     }
1505 }
1506 \f
1507 /* Print the mips instruction at address MEMADDR in debugged memory,
1508    on using INFO.  Returns length of the instruction, in bytes, which is
1509    always INSNLEN.  BIGENDIAN must be 1 if this is big-endian code, 0 if
1510    this is little-endian code.  */
1511
1512 static int
1513 print_insn_mips (bfd_vma memaddr,
1514                  unsigned long int word,
1515                  struct disassemble_info *info)
1516 {
1517   const struct mips_opcode *op;
1518   static bfd_boolean init = 0;
1519   static const struct mips_opcode *mips_hash[OP_MASK_OP + 1];
1520
1521   /* Build a hash table to shorten the search time.  */
1522   if (! init)
1523     {
1524       unsigned int i;
1525
1526       for (i = 0; i <= OP_MASK_OP; i++)
1527         {
1528           for (op = mips_opcodes; op < &mips_opcodes[NUMOPCODES]; op++)
1529             {
1530               if (op->pinfo == INSN_MACRO
1531                   || (no_aliases && (op->pinfo2 & INSN2_ALIAS)))
1532                 continue;
1533               if (i == ((op->match >> OP_SH_OP) & OP_MASK_OP))
1534                 {
1535                   mips_hash[i] = op;
1536                   break;
1537                 }
1538             }
1539         }
1540
1541       init = 1;
1542     }
1543
1544   info->bytes_per_chunk = INSNLEN;
1545   info->display_endian = info->endian;
1546   info->insn_info_valid = 1;
1547   info->branch_delay_insns = 0;
1548   info->data_size = 0;
1549   info->insn_type = dis_nonbranch;
1550   info->target = 0;
1551   info->target2 = 0;
1552
1553   op = mips_hash[(word >> OP_SH_OP) & OP_MASK_OP];
1554   if (op != NULL)
1555     {
1556       for (; op < &mips_opcodes[NUMOPCODES]; op++)
1557         {
1558           if (op->pinfo != INSN_MACRO
1559               && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
1560               && (word & op->mask) == op->match)
1561             {
1562               const char *d;
1563
1564               /* We always allow to disassemble the jalx instruction.  */
1565               if (! OPCODE_IS_MEMBER (op, mips_isa, mips_processor)
1566                   && strcmp (op->name, "jalx"))
1567                 continue;
1568
1569               /* Figure out instruction type and branch delay information.  */
1570               if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
1571                 {
1572                   if ((op->pinfo & (INSN_WRITE_GPR_31
1573                                     | INSN_WRITE_GPR_D)) != 0)
1574                     info->insn_type = dis_jsr;
1575                   else
1576                     info->insn_type = dis_branch;
1577                   info->branch_delay_insns = 1;
1578                 }
1579               else if ((op->pinfo & (INSN_COND_BRANCH_DELAY
1580                                      | INSN_COND_BRANCH_LIKELY)) != 0)
1581                 {
1582                   if ((op->pinfo & INSN_WRITE_GPR_31) != 0)
1583                     info->insn_type = dis_condjsr;
1584                   else
1585                     info->insn_type = dis_condbranch;
1586                   info->branch_delay_insns = 1;
1587                 }
1588               else if ((op->pinfo & (INSN_STORE_MEMORY
1589                                      | INSN_LOAD_MEMORY_DELAY)) != 0)
1590                 info->insn_type = dis_dref;
1591
1592               (*info->fprintf_func) (info->stream, "%s", op->name);
1593
1594               d = op->args;
1595               if (d != NULL && *d != '\0')
1596                 {
1597                   (*info->fprintf_func) (info->stream, "\t");
1598                   print_insn_args (d, word, memaddr, info, op);
1599                 }
1600
1601               return INSNLEN;
1602             }
1603         }
1604     }
1605
1606   /* Handle undefined instructions.  */
1607   info->insn_type = dis_noninsn;
1608   (*info->fprintf_func) (info->stream, "0x%lx", word);
1609   return INSNLEN;
1610 }
1611 \f
1612 /* Disassemble an operand for a mips16 instruction.  */
1613
1614 static void
1615 print_mips16_insn_arg (char type,
1616                        const struct mips_opcode *op,
1617                        int l,
1618                        bfd_boolean use_extend,
1619                        int extend,
1620                        bfd_vma memaddr,
1621                        struct disassemble_info *info)
1622 {
1623   switch (type)
1624     {
1625     case ',':
1626     case '(':
1627     case ')':
1628       (*info->fprintf_func) (info->stream, "%c", type);
1629       break;
1630
1631     case 'y':
1632     case 'w':
1633       (*info->fprintf_func) (info->stream, "%s",
1634                              mips16_reg_names(((l >> MIPS16OP_SH_RY)
1635                                                & MIPS16OP_MASK_RY)));
1636       break;
1637
1638     case 'x':
1639     case 'v':
1640       (*info->fprintf_func) (info->stream, "%s",
1641                              mips16_reg_names(((l >> MIPS16OP_SH_RX)
1642                                                & MIPS16OP_MASK_RX)));
1643       break;
1644
1645     case 'z':
1646       (*info->fprintf_func) (info->stream, "%s",
1647                              mips16_reg_names(((l >> MIPS16OP_SH_RZ)
1648                                                & MIPS16OP_MASK_RZ)));
1649       break;
1650
1651     case 'Z':
1652       (*info->fprintf_func) (info->stream, "%s",
1653                              mips16_reg_names(((l >> MIPS16OP_SH_MOVE32Z)
1654                                                & MIPS16OP_MASK_MOVE32Z)));
1655       break;
1656
1657     case '0':
1658       (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[0]);
1659       break;
1660
1661     case 'S':
1662       (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[29]);
1663       break;
1664
1665     case 'P':
1666       (*info->fprintf_func) (info->stream, "$pc");
1667       break;
1668
1669     case 'R':
1670       (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[31]);
1671       break;
1672
1673     case 'X':
1674       (*info->fprintf_func) (info->stream, "%s",
1675                              mips_gpr_names[((l >> MIPS16OP_SH_REGR32)
1676                                             & MIPS16OP_MASK_REGR32)]);
1677       break;
1678
1679     case 'Y':
1680       (*info->fprintf_func) (info->stream, "%s",
1681                              mips_gpr_names[MIPS16OP_EXTRACT_REG32R (l)]);
1682       break;
1683
1684     case '<':
1685     case '>':
1686     case '[':
1687     case ']':
1688     case '4':
1689     case '5':
1690     case 'H':
1691     case 'W':
1692     case 'D':
1693     case 'j':
1694     case '6':
1695     case '8':
1696     case 'V':
1697     case 'C':
1698     case 'U':
1699     case 'k':
1700     case 'K':
1701     case 'p':
1702     case 'q':
1703     case 'A':
1704     case 'B':
1705     case 'E':
1706       {
1707         int immed, nbits, shift, signedp, extbits, pcrel, extu, branch;
1708
1709         shift = 0;
1710         signedp = 0;
1711         extbits = 16;
1712         pcrel = 0;
1713         extu = 0;
1714         branch = 0;
1715         switch (type)
1716           {
1717           case '<':
1718             nbits = 3;
1719             immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1720             extbits = 5;
1721             extu = 1;
1722             break;
1723           case '>':
1724             nbits = 3;
1725             immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1726             extbits = 5;
1727             extu = 1;
1728             break;
1729           case '[':
1730             nbits = 3;
1731             immed = (l >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ;
1732             extbits = 6;
1733             extu = 1;
1734             break;
1735           case ']':
1736             nbits = 3;
1737             immed = (l >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX;
1738             extbits = 6;
1739             extu = 1;
1740             break;
1741           case '4':
1742             nbits = 4;
1743             immed = (l >> MIPS16OP_SH_IMM4) & MIPS16OP_MASK_IMM4;
1744             signedp = 1;
1745             extbits = 15;
1746             break;
1747           case '5':
1748             nbits = 5;
1749             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1750             info->insn_type = dis_dref;
1751             info->data_size = 1;
1752             break;
1753           case 'H':
1754             nbits = 5;
1755             shift = 1;
1756             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1757             info->insn_type = dis_dref;
1758             info->data_size = 2;
1759             break;
1760           case 'W':
1761             nbits = 5;
1762             shift = 2;
1763             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1764             if ((op->pinfo & MIPS16_INSN_READ_PC) == 0
1765                 && (op->pinfo & MIPS16_INSN_READ_SP) == 0)
1766               {
1767                 info->insn_type = dis_dref;
1768                 info->data_size = 4;
1769               }
1770             break;
1771           case 'D':
1772             nbits = 5;
1773             shift = 3;
1774             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1775             info->insn_type = dis_dref;
1776             info->data_size = 8;
1777             break;
1778           case 'j':
1779             nbits = 5;
1780             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1781             signedp = 1;
1782             break;
1783           case '6':
1784             nbits = 6;
1785             immed = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1786             break;
1787           case '8':
1788             nbits = 8;
1789             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1790             break;
1791           case 'V':
1792             nbits = 8;
1793             shift = 2;
1794             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1795             /* FIXME: This might be lw, or it might be addiu to $sp or
1796                $pc.  We assume it's load.  */
1797             info->insn_type = dis_dref;
1798             info->data_size = 4;
1799             break;
1800           case 'C':
1801             nbits = 8;
1802             shift = 3;
1803             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1804             info->insn_type = dis_dref;
1805             info->data_size = 8;
1806             break;
1807           case 'U':
1808             nbits = 8;
1809             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1810             extu = 1;
1811             break;
1812           case 'k':
1813             nbits = 8;
1814             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1815             signedp = 1;
1816             break;
1817           case 'K':
1818             nbits = 8;
1819             shift = 3;
1820             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1821             signedp = 1;
1822             break;
1823           case 'p':
1824             nbits = 8;
1825             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1826             signedp = 1;
1827             pcrel = 1;
1828             branch = 1;
1829             break;
1830           case 'q':
1831             nbits = 11;
1832             immed = (l >> MIPS16OP_SH_IMM11) & MIPS16OP_MASK_IMM11;
1833             signedp = 1;
1834             pcrel = 1;
1835             branch = 1;
1836             break;
1837           case 'A':
1838             nbits = 8;
1839             shift = 2;
1840             immed = (l >> MIPS16OP_SH_IMM8) & MIPS16OP_MASK_IMM8;
1841             pcrel = 1;
1842             /* FIXME: This can be lw or la.  We assume it is lw.  */
1843             info->insn_type = dis_dref;
1844             info->data_size = 4;
1845             break;
1846           case 'B':
1847             nbits = 5;
1848             shift = 3;
1849             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1850             pcrel = 1;
1851             info->insn_type = dis_dref;
1852             info->data_size = 8;
1853             break;
1854           case 'E':
1855             nbits = 5;
1856             shift = 2;
1857             immed = (l >> MIPS16OP_SH_IMM5) & MIPS16OP_MASK_IMM5;
1858             pcrel = 1;
1859             break;
1860           default:
1861             abort ();
1862           }
1863
1864         if (! use_extend)
1865           {
1866             if (signedp && immed >= (1 << (nbits - 1)))
1867               immed -= 1 << nbits;
1868             immed <<= shift;
1869             if ((type == '<' || type == '>' || type == '[' || type == ']')
1870                 && immed == 0)
1871               immed = 8;
1872           }
1873         else
1874           {
1875             if (extbits == 16)
1876               immed |= ((extend & 0x1f) << 11) | (extend & 0x7e0);
1877             else if (extbits == 15)
1878               immed |= ((extend & 0xf) << 11) | (extend & 0x7f0);
1879             else
1880               immed = ((extend >> 6) & 0x1f) | (extend & 0x20);
1881             immed &= (1 << extbits) - 1;
1882             if (! extu && immed >= (1 << (extbits - 1)))
1883               immed -= 1 << extbits;
1884           }
1885
1886         if (! pcrel)
1887           (*info->fprintf_func) (info->stream, "%d", immed);
1888         else
1889           {
1890             bfd_vma baseaddr;
1891
1892             if (branch)
1893               {
1894                 immed *= 2;
1895                 baseaddr = memaddr + 2;
1896               }
1897             else if (use_extend)
1898               baseaddr = memaddr - 2;
1899             else
1900               {
1901                 int status;
1902                 bfd_byte buffer[2];
1903
1904                 baseaddr = memaddr;
1905
1906                 /* If this instruction is in the delay slot of a jr
1907                    instruction, the base address is the address of the
1908                    jr instruction.  If it is in the delay slot of jalr
1909                    instruction, the base address is the address of the
1910                    jalr instruction.  This test is unreliable: we have
1911                    no way of knowing whether the previous word is
1912                    instruction or data.  */
1913                 status = (*info->read_memory_func) (memaddr - 4, buffer, 2,
1914                                                     info);
1915                 if (status == 0
1916                     && (((info->endian == BFD_ENDIAN_BIG
1917                           ? bfd_getb16 (buffer)
1918                           : bfd_getl16 (buffer))
1919                          & 0xf800) == 0x1800))
1920                   baseaddr = memaddr - 4;
1921                 else
1922                   {
1923                     status = (*info->read_memory_func) (memaddr - 2, buffer,
1924                                                         2, info);
1925                     if (status == 0
1926                         && (((info->endian == BFD_ENDIAN_BIG
1927                               ? bfd_getb16 (buffer)
1928                               : bfd_getl16 (buffer))
1929                              & 0xf81f) == 0xe800))
1930                       baseaddr = memaddr - 2;
1931                   }
1932               }
1933             info->target = (baseaddr & ~((1 << shift) - 1)) + immed;
1934             if (pcrel && branch
1935                 && info->flavour == bfd_target_unknown_flavour)
1936               /* For gdb disassembler, maintain odd address.  */
1937               info->target |= 1;
1938             (*info->print_address_func) (info->target, info);
1939           }
1940       }
1941       break;
1942
1943     case 'a':
1944       {
1945         int jalx = l & 0x400;
1946
1947         if (! use_extend)
1948           extend = 0;
1949         l = ((l & 0x1f) << 23) | ((l & 0x3e0) << 13) | (extend << 2);
1950         if (!jalx && info->flavour == bfd_target_unknown_flavour)
1951           /* For gdb disassembler, maintain odd address.  */
1952           l |= 1;
1953       }
1954       info->target = ((memaddr + 4) & ~(bfd_vma) 0x0fffffff) | l;
1955       (*info->print_address_func) (info->target, info);
1956       break;
1957
1958     case 'l':
1959     case 'L':
1960       {
1961         int need_comma, amask, smask;
1962
1963         need_comma = 0;
1964
1965         l = (l >> MIPS16OP_SH_IMM6) & MIPS16OP_MASK_IMM6;
1966
1967         amask = (l >> 3) & 7;
1968
1969         if (amask > 0 && amask < 5)
1970           {
1971             (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
1972             if (amask > 1)
1973               (*info->fprintf_func) (info->stream, "-%s",
1974                                      mips_gpr_names[amask + 3]);
1975             need_comma = 1;
1976           }
1977
1978         smask = (l >> 1) & 3;
1979         if (smask == 3)
1980           {
1981             (*info->fprintf_func) (info->stream, "%s??",
1982                                    need_comma ? "," : "");
1983             need_comma = 1;
1984           }
1985         else if (smask > 0)
1986           {
1987             (*info->fprintf_func) (info->stream, "%s%s",
1988                                    need_comma ? "," : "",
1989                                    mips_gpr_names[16]);
1990             if (smask > 1)
1991               (*info->fprintf_func) (info->stream, "-%s",
1992                                      mips_gpr_names[smask + 15]);
1993             need_comma = 1;
1994           }
1995
1996         if (l & 1)
1997           {
1998             (*info->fprintf_func) (info->stream, "%s%s",
1999                                    need_comma ? "," : "",
2000                                    mips_gpr_names[31]);
2001             need_comma = 1;
2002           }
2003
2004         if (amask == 5 || amask == 6)
2005           {
2006             (*info->fprintf_func) (info->stream, "%s$f0",
2007                                    need_comma ? "," : "");
2008             if (amask == 6)
2009               (*info->fprintf_func) (info->stream, "-$f1");
2010           }
2011       }
2012       break;
2013
2014     case 'm':
2015     case 'M':
2016       /* MIPS16e save/restore.  */
2017       {
2018       int need_comma = 0;
2019       int amask, args, statics;
2020       int nsreg, smask;
2021       int framesz;
2022       int i, j;
2023
2024       l = l & 0x7f;
2025       if (use_extend)
2026         l |= extend << 16;
2027
2028       amask = (l >> 16) & 0xf;
2029       if (amask == MIPS16_ALL_ARGS)
2030         {
2031           args = 4;
2032           statics = 0;
2033         }
2034       else if (amask == MIPS16_ALL_STATICS)
2035         {
2036           args = 0;
2037           statics = 4;
2038         }
2039       else
2040         {
2041           args = amask >> 2;
2042           statics = amask & 3;
2043         }
2044
2045       if (args > 0) {
2046           (*info->fprintf_func) (info->stream, "%s", mips_gpr_names[4]);
2047           if (args > 1)
2048             (*info->fprintf_func) (info->stream, "-%s",
2049                                    mips_gpr_names[4 + args - 1]);
2050           need_comma = 1;
2051       }
2052
2053       framesz = (((l >> 16) & 0xf0) | (l & 0x0f)) * 8;
2054       if (framesz == 0 && !use_extend)
2055         framesz = 128;
2056
2057       (*info->fprintf_func) (info->stream, "%s%d",
2058                              need_comma ? "," : "",
2059                              framesz);
2060
2061       if (l & 0x40)                   /* $ra */
2062         (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[31]);
2063
2064       nsreg = (l >> 24) & 0x7;
2065       smask = 0;
2066       if (l & 0x20)                   /* $s0 */
2067         smask |= 1 << 0;
2068       if (l & 0x10)                   /* $s1 */
2069         smask |= 1 << 1;
2070       if (nsreg > 0)                  /* $s2-$s8 */
2071         smask |= ((1 << nsreg) - 1) << 2;
2072
2073       /* Find first set static reg bit.  */
2074       for (i = 0; i < 9; i++)
2075         {
2076           if (smask & (1 << i))
2077             {
2078               (*info->fprintf_func) (info->stream, ",%s",
2079                                      mips_gpr_names[i == 8 ? 30 : (16 + i)]);
2080               /* Skip over string of set bits.  */
2081               for (j = i; smask & (2 << j); j++)
2082                 continue;
2083               if (j > i)
2084                 (*info->fprintf_func) (info->stream, "-%s",
2085                                        mips_gpr_names[j == 8 ? 30 : (16 + j)]);
2086               i = j + 1;
2087             }
2088         }
2089
2090       /* Statics $ax - $a3.  */
2091       if (statics == 1)
2092         (*info->fprintf_func) (info->stream, ",%s", mips_gpr_names[7]);
2093       else if (statics > 0)
2094         (*info->fprintf_func) (info->stream, ",%s-%s",
2095                                mips_gpr_names[7 - statics + 1],
2096                                mips_gpr_names[7]);
2097       }
2098       break;
2099
2100     default:
2101       /* xgettext:c-format */
2102       (*info->fprintf_func)
2103         (info->stream,
2104          _("# internal disassembler error, unrecognised modifier (%c)"),
2105          type);
2106       abort ();
2107     }
2108 }
2109
2110 /* Disassemble mips16 instructions.  */
2111
2112 static int
2113 print_insn_mips16 (bfd_vma memaddr, struct disassemble_info *info)
2114 {
2115   int status;
2116   bfd_byte buffer[2];
2117   int length;
2118   int insn;
2119   bfd_boolean use_extend;
2120   int extend = 0;
2121   const struct mips_opcode *op, *opend;
2122
2123   info->bytes_per_chunk = 2;
2124   info->display_endian = info->endian;
2125   info->insn_info_valid = 1;
2126   info->branch_delay_insns = 0;
2127   info->data_size = 0;
2128   info->insn_type = dis_nonbranch;
2129   info->target = 0;
2130   info->target2 = 0;
2131
2132   status = (*info->read_memory_func) (memaddr, buffer, 2, info);
2133   if (status != 0)
2134     {
2135       (*info->memory_error_func) (status, memaddr, info);
2136       return -1;
2137     }
2138
2139   length = 2;
2140
2141   if (info->endian == BFD_ENDIAN_BIG)
2142     insn = bfd_getb16 (buffer);
2143   else
2144     insn = bfd_getl16 (buffer);
2145
2146   /* Handle the extend opcode specially.  */
2147   use_extend = FALSE;
2148   if ((insn & 0xf800) == 0xf000)
2149     {
2150       use_extend = TRUE;
2151       extend = insn & 0x7ff;
2152
2153       memaddr += 2;
2154
2155       status = (*info->read_memory_func) (memaddr, buffer, 2, info);
2156       if (status != 0)
2157         {
2158           (*info->fprintf_func) (info->stream, "extend 0x%x",
2159                                  (unsigned int) extend);
2160           (*info->memory_error_func) (status, memaddr, info);
2161           return -1;
2162         }
2163
2164       if (info->endian == BFD_ENDIAN_BIG)
2165         insn = bfd_getb16 (buffer);
2166       else
2167         insn = bfd_getl16 (buffer);
2168
2169       /* Check for an extend opcode followed by an extend opcode.  */
2170       if ((insn & 0xf800) == 0xf000)
2171         {
2172           (*info->fprintf_func) (info->stream, "extend 0x%x",
2173                                  (unsigned int) extend);
2174           info->insn_type = dis_noninsn;
2175           return length;
2176         }
2177
2178       length += 2;
2179     }
2180
2181   /* FIXME: Should probably use a hash table on the major opcode here.  */
2182
2183   opend = mips16_opcodes + bfd_mips16_num_opcodes;
2184   for (op = mips16_opcodes; op < opend; op++)
2185     {
2186       if (op->pinfo != INSN_MACRO
2187           && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
2188           && (insn & op->mask) == op->match)
2189         {
2190           const char *s;
2191
2192           if (strchr (op->args, 'a') != NULL)
2193             {
2194               if (use_extend)
2195                 {
2196                   (*info->fprintf_func) (info->stream, "extend 0x%x",
2197                                          (unsigned int) extend);
2198                   info->insn_type = dis_noninsn;
2199                   return length - 2;
2200                 }
2201
2202               use_extend = FALSE;
2203
2204               memaddr += 2;
2205
2206               status = (*info->read_memory_func) (memaddr, buffer, 2,
2207                                                   info);
2208               if (status == 0)
2209                 {
2210                   use_extend = TRUE;
2211                   if (info->endian == BFD_ENDIAN_BIG)
2212                     extend = bfd_getb16 (buffer);
2213                   else
2214                     extend = bfd_getl16 (buffer);
2215                   length += 2;
2216                 }
2217             }
2218
2219           (*info->fprintf_func) (info->stream, "%s", op->name);
2220           if (op->args[0] != '\0')
2221             (*info->fprintf_func) (info->stream, "\t");
2222
2223           for (s = op->args; *s != '\0'; s++)
2224             {
2225               if (*s == ','
2226                   && s[1] == 'w'
2227                   && (((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)
2228                       == ((insn >> MIPS16OP_SH_RY) & MIPS16OP_MASK_RY)))
2229                 {
2230                   /* Skip the register and the comma.  */
2231                   ++s;
2232                   continue;
2233                 }
2234               if (*s == ','
2235                   && s[1] == 'v'
2236                   && (((insn >> MIPS16OP_SH_RZ) & MIPS16OP_MASK_RZ)
2237                       == ((insn >> MIPS16OP_SH_RX) & MIPS16OP_MASK_RX)))
2238                 {
2239                   /* Skip the register and the comma.  */
2240                   ++s;
2241                   continue;
2242                 }
2243               print_mips16_insn_arg (*s, op, insn, use_extend, extend, memaddr,
2244                                      info);
2245             }
2246
2247           /* Figure out branch instruction type and delay slot information.  */
2248           if ((op->pinfo & INSN_UNCOND_BRANCH_DELAY) != 0)
2249             info->branch_delay_insns = 1;
2250           if ((op->pinfo & (INSN_UNCOND_BRANCH_DELAY
2251                             | MIPS16_INSN_UNCOND_BRANCH)) != 0)
2252             {
2253               if ((op->pinfo & INSN_WRITE_GPR_31) != 0)
2254                 info->insn_type = dis_jsr;
2255               else
2256                 info->insn_type = dis_branch;
2257             }
2258           else if ((op->pinfo & MIPS16_INSN_COND_BRANCH) != 0)
2259             info->insn_type = dis_condbranch;
2260
2261           return length;
2262         }
2263     }
2264
2265   if (use_extend)
2266     (*info->fprintf_func) (info->stream, "0x%x", extend | 0xf000);
2267   (*info->fprintf_func) (info->stream, "0x%x", insn);
2268   info->insn_type = dis_noninsn;
2269
2270   return length;
2271 }
2272
2273 /* Disassemble microMIPS instructions.  */
2274
2275 static int
2276 print_insn_micromips (bfd_vma memaddr, struct disassemble_info *info)
2277 {
2278   const fprintf_ftype infprintf = info->fprintf_func;
2279   const struct mips_opcode *op, *opend;
2280   unsigned int lsb, msbd, msb;
2281   void *is = info->stream;
2282   unsigned int regno;
2283   bfd_byte buffer[2];
2284   int lastregno = 0;
2285   int higher;
2286   int length;
2287   int status;
2288   int delta;
2289   int immed;
2290   int insn;
2291
2292   lsb = 0;
2293
2294   info->bytes_per_chunk = 2;
2295   info->display_endian = info->endian;
2296   info->insn_info_valid = 1;
2297   info->branch_delay_insns = 0;
2298   info->data_size = 0;
2299   info->insn_type = dis_nonbranch;
2300   info->target = 0;
2301   info->target2 = 0;
2302
2303   status = (*info->read_memory_func) (memaddr, buffer, 2, info);
2304   if (status != 0)
2305     {
2306       (*info->memory_error_func) (status, memaddr, info);
2307       return -1;
2308     }
2309
2310   length = 2;
2311
2312   if (info->endian == BFD_ENDIAN_BIG)
2313     insn = bfd_getb16 (buffer);
2314   else
2315     insn = bfd_getl16 (buffer);
2316
2317   if ((insn & 0xfc00) == 0x7c00)
2318     {
2319       /* This is a 48-bit microMIPS instruction.  */
2320       higher = insn;
2321
2322       status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info);
2323       if (status != 0)
2324         {
2325           infprintf (is, "micromips 0x%x", higher);
2326           (*info->memory_error_func) (status, memaddr + 2, info);
2327           return -1;
2328         }
2329       if (info->endian == BFD_ENDIAN_BIG)
2330         insn = bfd_getb16 (buffer);
2331       else
2332         insn = bfd_getl16 (buffer);
2333       higher = (higher << 16) | insn;
2334
2335       status = (*info->read_memory_func) (memaddr + 4, buffer, 2, info);
2336       if (status != 0)
2337         {
2338           infprintf (is, "micromips 0x%x", higher);
2339           (*info->memory_error_func) (status, memaddr + 4, info);
2340           return -1;
2341         }
2342       if (info->endian == BFD_ENDIAN_BIG)
2343         insn = bfd_getb16 (buffer);
2344       else
2345         insn = bfd_getl16 (buffer);
2346       infprintf (is, "0x%x%04x (48-bit insn)", higher, insn);
2347
2348       info->insn_type = dis_noninsn;
2349       return 6;
2350     }
2351   else if ((insn & 0x1c00) == 0x0000 || (insn & 0x1000) == 0x1000)
2352     {
2353       /* This is a 32-bit microMIPS instruction.  */
2354       higher = insn;
2355
2356       status = (*info->read_memory_func) (memaddr + 2, buffer, 2, info);
2357       if (status != 0)
2358         {
2359           infprintf (is, "micromips 0x%x", higher);
2360           (*info->memory_error_func) (status, memaddr + 2, info);
2361           return -1;
2362         }
2363
2364       if (info->endian == BFD_ENDIAN_BIG)
2365         insn = bfd_getb16 (buffer);
2366       else
2367         insn = bfd_getl16 (buffer);
2368
2369       insn = insn | (higher << 16);
2370
2371       length += 2;
2372     }
2373
2374   /* FIXME: Should probably use a hash table on the major opcode here.  */
2375
2376 #define GET_OP(insn, field) \
2377   (((insn) >> MICROMIPSOP_SH_##field) & MICROMIPSOP_MASK_##field)
2378   opend = micromips_opcodes + bfd_micromips_num_opcodes;
2379   for (op = micromips_opcodes; op < opend; op++)
2380     {
2381       if (op->pinfo != INSN_MACRO
2382           && !(no_aliases && (op->pinfo2 & INSN2_ALIAS))
2383           && (insn & op->mask) == op->match
2384           && ((length == 2 && (op->mask & 0xffff0000) == 0)
2385               || (length == 4 && (op->mask & 0xffff0000) != 0)))
2386         {
2387           const char *s;
2388
2389           infprintf (is, "%s", op->name);
2390           if (op->args[0] != '\0')
2391             infprintf (is, "\t");
2392
2393           for (s = op->args; *s != '\0'; s++)
2394             {
2395               switch (*s)
2396                 {
2397                 case ',':
2398                 case '(':
2399                 case ')':
2400                   infprintf (is, "%c", *s);
2401                   break;
2402
2403                 case '.':
2404                   delta = GET_OP (insn, OFFSET10);
2405                   if (delta & 0x200)
2406                     delta |= ~0x3ff;
2407                   infprintf (is, "%d", delta);
2408                   break;
2409
2410                 case '1':
2411                   infprintf (is, "0x%lx", GET_OP (insn, STYPE));
2412                   break;
2413
2414                 case '<':
2415                   infprintf (is, "0x%lx", GET_OP (insn, SHAMT));
2416                   break;
2417
2418                 case '\\':
2419                   infprintf (is, "0x%lx", GET_OP (insn, 3BITPOS));
2420                   break;
2421
2422                 case '|':
2423                   infprintf (is, "0x%lx", GET_OP (insn, TRAP));
2424                   break;
2425
2426                 case '~':
2427                   delta = GET_OP (insn, OFFSET12);
2428                   if (delta & 0x800)
2429                     delta |= ~0x7ff;
2430                   infprintf (is, "%d", delta);
2431                   break;
2432
2433                 case 'a':
2434                   if (strcmp (op->name, "jalx") == 0)
2435                     info->target = (((memaddr + 4) & ~(bfd_vma) 0x0fffffff)
2436                                     | (GET_OP (insn, TARGET) << 2));
2437                   else
2438                     info->target = (((memaddr + 4) & ~(bfd_vma) 0x07ffffff)
2439                                     | ((GET_OP (insn, TARGET)) << 1));
2440                   /* For gdb disassembler, force odd address on jalx.  */
2441                   if (info->flavour == bfd_target_unknown_flavour
2442                       && strcmp (op->name, "jalx") == 0)
2443                     info->target |= 1;
2444                   (*info->print_address_func) (info->target, info);
2445                   break;
2446
2447                 case 'b':
2448                 case 'r':
2449                 case 's':
2450                 case 'v':
2451                   infprintf (is, "%s", mips_gpr_names[GET_OP (insn, RS)]);
2452                   break;
2453
2454                 case 'c':
2455                   infprintf (is, "0x%lx", GET_OP (insn, CODE));
2456                   break;
2457
2458                 case 'd':
2459                   infprintf (is, "%s", mips_gpr_names[GET_OP (insn, RD)]);
2460                   break;
2461
2462                 case 'h':
2463                   infprintf (is, "0x%lx", GET_OP (insn, PREFX));
2464                   break;
2465
2466                 case 'i':
2467                 case 'u':
2468                   infprintf (is, "0x%lx", GET_OP (insn, IMMEDIATE));
2469                   break;
2470
2471                 case 'j': /* Same as i, but sign-extended.  */
2472                 case 'o':
2473                   delta = (GET_OP (insn, DELTA) ^ 0x8000) - 0x8000;
2474                   infprintf (is, "%d", delta);
2475                   break;
2476
2477                 case 'k':
2478                   infprintf (is, "0x%x", GET_OP (insn, CACHE));
2479                   break;
2480
2481                 case 'n':
2482                   {
2483                     int s_reg_encode;
2484
2485                     immed = GET_OP (insn, RT);
2486                     s_reg_encode = immed & 0xf;
2487                     if (s_reg_encode != 0)
2488                       {
2489                         if (s_reg_encode == 1)
2490                           infprintf (is, "%s", mips_gpr_names[16]);
2491                         else if (s_reg_encode < 9)
2492                           infprintf (is, "%s-%s",
2493                                    mips_gpr_names[16],
2494                                    mips_gpr_names[15 + s_reg_encode]);
2495                         else if (s_reg_encode == 9)
2496                           infprintf (is, "%s-%s,%s",
2497                                    mips_gpr_names[16],
2498                                    mips_gpr_names[23],
2499                                    mips_gpr_names[30]);
2500                         else
2501                           infprintf (is, "UNKNOWN");
2502                       }
2503
2504                     if (immed & 0x10) /* For ra.  */
2505                       {
2506                         if (s_reg_encode == 0)
2507                           infprintf (is, "%s", mips_gpr_names[31]);
2508                         else
2509                           infprintf (is, ",%s", mips_gpr_names[31]);
2510                       }
2511                     break;
2512                   }
2513
2514                 case 'p':
2515                   /* Sign-extend the displacement.  */
2516                   delta = (GET_OP (insn, DELTA) ^ 0x8000) - 0x8000;
2517                   info->target = (delta << 1) + memaddr + length;
2518                   (*info->print_address_func) (info->target, info);
2519                   break;
2520
2521                 case 'q':
2522                   infprintf (is, "0x%lx", GET_OP (insn, CODE2));
2523                   break;
2524
2525                 case 't':
2526                 case 'w':
2527                   infprintf (is, "%s", mips_gpr_names[GET_OP (insn, RT)]);
2528                   break;
2529
2530                 case 'y':
2531                   infprintf (is, "%s", mips_gpr_names[GET_OP (insn, RS3)]);
2532                   break;
2533
2534                 case 'z':
2535                   infprintf (is, "%s", mips_gpr_names[0]);
2536                   break;
2537
2538                 case 'B':
2539                   infprintf (is, "0x%lx", GET_OP (insn, CODE10));
2540                   break;
2541
2542                 case 'C':
2543                   infprintf (is, "0x%lx", GET_OP (insn, COPZ));
2544                   break;
2545
2546                 case 'D':
2547                   infprintf (is, "%s", mips_fpr_names[GET_OP (insn, FD)]);
2548                   break;
2549
2550                 case 'E':
2551                   /* Coprocessor register for lwcN instructions, et al.
2552
2553                     Note that there is no load/store cp0 instructions, and
2554                     that FPU (cp1) instructions disassemble this field using
2555                     'T' format.  Therefore, until we gain understanding of
2556                     cp2 register names, we can simply print the register
2557                     numbers.  */
2558                   infprintf (is, "$%ld", GET_OP (insn, RT));
2559                   break;
2560
2561                 case 'G':
2562                   /* Coprocessor register for mtcN instructions, et al.  Note
2563                      that FPU (cp1) instructions disassemble this field using
2564                      'S' format.  Therefore, we only need to worry about cp0,
2565                      cp2, and cp3.
2566                      The microMIPS encoding does not have a coprocessor
2567                      identifier field as such, so we must work out the
2568                      coprocessor number by looking at the opcode.  */
2569                   switch (insn
2570                           & ~((MICROMIPSOP_MASK_RT << MICROMIPSOP_SH_RT)
2571                               | (MICROMIPSOP_MASK_RS << MICROMIPSOP_SH_RS)))
2572                     {
2573                     case 0x000000fc:                            /* mfc0  */
2574                     case 0x000002fc:                            /* mtc0  */
2575                     case 0x580000fc:                            /* dmfc0 */
2576                     case 0x580002fc:                            /* dmtc0 */
2577                       infprintf (is, "%s", mips_cp0_names[GET_OP (insn, RS)]);
2578                       break;
2579                     default:
2580                       infprintf (is, "$%ld", GET_OP (insn, RS));
2581                       break;
2582                     }
2583                   break;
2584
2585                 case 'H':
2586                   infprintf (is, "%ld", GET_OP (insn, SEL));
2587                   break;
2588
2589                 case 'K':
2590                   infprintf (is, "%s", mips_hwr_names[GET_OP (insn, RS)]);
2591                   break;
2592
2593                 case 'M':
2594                   infprintf (is, "$fcc%ld", GET_OP (insn, CCC));
2595                   break;
2596
2597                 case 'N':
2598                   infprintf (is,
2599                            (op->pinfo & (FP_D | FP_S)) != 0
2600                            ? "$fcc%ld" : "$cc%ld",
2601                            GET_OP (insn, BCC));
2602                   break;
2603
2604                 case 'R':
2605                   infprintf (is, "%s", mips_fpr_names[GET_OP (insn, FR)]);
2606                   break;
2607
2608                 case 'S':
2609                 case 'V':
2610                   infprintf (is, "%s", mips_fpr_names[GET_OP (insn, FS)]);
2611                   break;
2612
2613                 case 'T':
2614                   infprintf (is, "%s", mips_fpr_names[GET_OP (insn, FT)]);
2615                   break;
2616
2617                 case '+':
2618                   /* Extension character; switch for second char.  */
2619                   s++;
2620                   switch (*s)
2621                     {
2622                     case 'A':
2623                       lsb = GET_OP (insn, EXTLSB);
2624                       infprintf (is, "0x%x", lsb);
2625                       break;
2626
2627                     case 'B':
2628                       msb = GET_OP (insn, INSMSB);
2629                       infprintf (is, "0x%x", msb - lsb + 1);
2630                       break;
2631
2632                     case 'C':
2633                     case 'H':
2634                       msbd = GET_OP (insn, EXTMSBD);
2635                       infprintf (is, "0x%x", msbd + 1);
2636                       break;
2637
2638                     case 'D':
2639                       {
2640                         const struct mips_cp0sel_name *n;
2641                         unsigned int cp0reg, sel;
2642
2643                         cp0reg = GET_OP (insn, RS);
2644                         sel = GET_OP (insn, SEL);
2645
2646                         /* CP0 register including 'sel' code for mtcN
2647                            (et al.), to be printed textually if known.
2648                            If not known, print both CP0 register name and
2649                            sel numerically since CP0 register with sel 0 may
2650                            have a name unrelated to register being printed.  */
2651                         n = lookup_mips_cp0sel_name (mips_cp0sel_names,
2652                                                      mips_cp0sel_names_len,
2653                                                      cp0reg, sel);
2654                         if (n != NULL)
2655                           infprintf (is, "%s", n->name);
2656                         else
2657                           infprintf (is, "$%d,%d", cp0reg, sel);
2658                         break;
2659                       }
2660
2661                     case 'E':
2662                       lsb = GET_OP (insn, EXTLSB) + 32;
2663                       infprintf (is, "0x%x", lsb);
2664                       break;
2665
2666                     case 'F':
2667                       msb = GET_OP (insn, INSMSB) + 32;
2668                       infprintf (is, "0x%x", msb - lsb + 1);
2669                       break;
2670
2671                     case 'G':
2672                       msbd = GET_OP (insn, EXTMSBD) + 32;
2673                       infprintf (is, "0x%x", msbd + 1);
2674                       break;
2675
2676                     default:
2677                       /* xgettext:c-format */
2678                       infprintf (is,
2679                                _("# internal disassembler error, "
2680                                  "unrecognized modifier (+%c)"),
2681                                *s);
2682                       abort ();
2683                     }
2684                   break;
2685
2686                 case 'm':
2687                   /* Extension character; switch for second char.  */
2688                   s++;
2689                   switch (*s)
2690                     {
2691                     case 'a':   /* global pointer.  */
2692                       infprintf (is, "%s", mips_gpr_names[28]);
2693                       break;
2694
2695                     case 'b':
2696                       regno = micromips_to_32_reg_b_map[GET_OP (insn, MB)];
2697                       infprintf (is, "%s", mips_gpr_names[regno]);
2698                       break;
2699
2700                     case 'c':
2701                       regno = micromips_to_32_reg_c_map[GET_OP (insn, MC)];
2702                       infprintf (is, "%s", mips_gpr_names[regno]);
2703                       break;
2704
2705                     case 'd':
2706                       regno = micromips_to_32_reg_d_map[GET_OP (insn, MD)];
2707                       infprintf (is, "%s", mips_gpr_names[regno]);
2708                       break;
2709
2710                     case 'e':
2711                       regno = micromips_to_32_reg_e_map[GET_OP (insn, ME)];
2712                       infprintf (is, "%s", mips_gpr_names[regno]);
2713                       break;
2714
2715                     case 'f':
2716                       /* Save lastregno for "mt" to print out later.  */
2717                       lastregno = micromips_to_32_reg_f_map[GET_OP (insn, MF)];
2718                       infprintf (is, "%s", mips_gpr_names[lastregno]);
2719                       break;
2720
2721                     case 'g':
2722                       regno = micromips_to_32_reg_g_map[GET_OP (insn, MG)];
2723                       infprintf (is, "%s", mips_gpr_names[regno]);
2724                       break;
2725
2726                     case 'h':
2727                       regno = micromips_to_32_reg_h_map[GET_OP (insn, MH)];
2728                       infprintf (is, "%s", mips_gpr_names[regno]);
2729                       break;
2730
2731                     case 'i':
2732                       regno = micromips_to_32_reg_i_map[GET_OP (insn, MI)];
2733                       infprintf (is, "%s", mips_gpr_names[regno]);
2734                       break;
2735
2736                     case 'j':
2737                       infprintf (is, "%s", mips_gpr_names[GET_OP (insn, MJ)]);
2738                       break;
2739
2740                     case 'l':
2741                       regno = micromips_to_32_reg_l_map[GET_OP (insn, ML)];
2742                       infprintf (is, "%s", mips_gpr_names[regno]);
2743                       break;
2744
2745                     case 'm':
2746                       regno = micromips_to_32_reg_m_map[GET_OP (insn, MM)];
2747                       infprintf (is, "%s", mips_gpr_names[regno]);
2748                       break;
2749
2750                     case 'n':
2751                       regno = micromips_to_32_reg_n_map[GET_OP (insn, MN)];
2752                       infprintf (is, "%s", mips_gpr_names[regno]);
2753                       break;
2754
2755                     case 'p':
2756                       /* Save lastregno for "mt" to print out later.  */
2757                       lastregno = GET_OP (insn, MP);
2758                       infprintf (is, "%s", mips_gpr_names[lastregno]);
2759                       break;
2760
2761                     case 'q':
2762                       regno = micromips_to_32_reg_q_map[GET_OP (insn, MQ)];
2763                       infprintf (is, "%s", mips_gpr_names[regno]);
2764                       break;
2765
2766                     case 'r':   /* program counter.  */
2767                       infprintf (is, "$pc");
2768                       break;
2769
2770                     case 's':   /* stack pointer.  */
2771                       lastregno = 29;
2772                       infprintf (is, "%s", mips_gpr_names[29]);
2773                       break;
2774
2775                     case 't':
2776                       infprintf (is, "%s", mips_gpr_names[lastregno]);
2777                       break;
2778
2779                     case 'z':   /* $0.  */
2780                       infprintf (is, "%s", mips_gpr_names[0]);
2781                       break;
2782
2783                     case 'A':
2784                       /* Sign-extend the immediate.  */
2785                       immed = ((GET_OP (insn, IMMA) ^ 0x40) - 0x40) << 2;
2786                       infprintf (is, "%d", immed);
2787                       break;
2788
2789                     case 'B':
2790                       immed = micromips_imm_b_map[GET_OP (insn, IMMB)];
2791                       infprintf (is, "%d", immed);
2792                       break;
2793
2794                     case 'C':
2795                       immed = micromips_imm_c_map[GET_OP (insn, IMMC)];
2796                       infprintf (is, "0x%lx", immed);
2797                       break;
2798
2799                     case 'D':
2800                       /* Sign-extend the displacement.  */
2801                       delta = (GET_OP (insn, IMMD) ^ 0x200) - 0x200;
2802                       info->target = (delta << 1) + memaddr + length;
2803                       (*info->print_address_func) (info->target, info);
2804                       break;
2805
2806                     case 'E':
2807                       /* Sign-extend the displacement.  */
2808                       delta = (GET_OP (insn, IMME) ^ 0x40) - 0x40;
2809                       info->target = (delta << 1) + memaddr + length;
2810                       (*info->print_address_func) (info->target, info);
2811                       break;
2812
2813                     case 'F':
2814                       immed = GET_OP (insn, IMMF);
2815                       infprintf (is, "0x%x", immed);
2816                       break;
2817
2818                     case 'G':
2819                       immed = (insn >> MICROMIPSOP_SH_IMMG) + 1;
2820                       immed = (immed & MICROMIPSOP_MASK_IMMG) - 1;
2821                       infprintf (is, "%d", immed);
2822                       break;
2823
2824                     case 'H':
2825                       immed = GET_OP (insn, IMMH) << 1;
2826                       infprintf (is, "%d", immed);
2827                       break;
2828
2829                     case 'I':
2830                       immed = (insn >> MICROMIPSOP_SH_IMMI) + 1;
2831                       immed = (immed & MICROMIPSOP_MASK_IMMI) - 1;
2832                       infprintf (is, "%d", immed);
2833                       break;
2834
2835                     case 'J':
2836                       immed = GET_OP (insn, IMMJ) << 2;
2837                       infprintf (is, "%d", immed);
2838                       break;
2839
2840                     case 'L':
2841                       immed = GET_OP (insn, IMML);
2842                       infprintf (is, "%d", immed);
2843                       break;
2844
2845                     case 'M':
2846                       immed = (insn >> MICROMIPSOP_SH_IMMM) - 1;
2847                       immed = (immed & MICROMIPSOP_MASK_IMMM) + 1;
2848                       infprintf (is, "%d", immed);
2849                       break;
2850
2851                     case 'N':
2852                       immed = GET_OP (insn, IMMN);
2853                       if (immed == 0)
2854                         infprintf (is, "%s,%s",
2855                                  mips_gpr_names[16],
2856                                  mips_gpr_names[31]);
2857                       else
2858                         infprintf (is, "%s-%s,%s",
2859                                  mips_gpr_names[16],
2860                                  mips_gpr_names[16 + immed],
2861                                  mips_gpr_names[31]);
2862                       break;
2863
2864                     case 'O':
2865                       immed = GET_OP (insn, IMMO);
2866                       infprintf (is, "0x%x", immed);
2867                       break;
2868
2869                     case 'P':
2870                       immed = GET_OP (insn, IMMP) << 2;
2871                       infprintf (is, "%d", immed);
2872                       break;
2873
2874                     case 'Q':
2875                       /* Sign-extend the immediate.  */
2876                       immed = (GET_OP (insn, IMMQ) ^ 0x400000) - 0x400000;
2877                       immed <<= 2;
2878                       infprintf (is, "%d", immed);
2879                       break;
2880
2881                     case 'U':
2882                       immed = GET_OP (insn, IMMU) << 2;
2883                       infprintf (is, "%d", immed);
2884                       break;
2885
2886                     case 'W':
2887                       immed = GET_OP (insn, IMMW) << 2;
2888                       infprintf (is, "%d", immed);
2889                       break;
2890
2891                     case 'X':
2892                       /* Sign-extend the immediate.  */
2893                       immed = (GET_OP (insn, IMMX) ^ 0x8) - 0x8;
2894                       infprintf (is, "%d", immed);
2895                       break;
2896
2897                     case 'Y':
2898                       /* Sign-extend the immediate.  */
2899                       immed = (GET_OP (insn, IMMY) ^ 0x100) - 0x100;
2900                       if (immed >= -2 && immed <= 1)
2901                         immed ^= 0x100;
2902                       immed = immed << 2;
2903                       infprintf (is, "%d", immed);
2904                       break;
2905
2906                     default:
2907                       /* xgettext:c-format */
2908                       infprintf (is,
2909                                _("# internal disassembler error, "
2910                                  "unrecognized modifier (m%c)"),
2911                                *s);
2912                       abort ();
2913                     }
2914                   break;
2915
2916                 default:
2917                   /* xgettext:c-format */
2918                   infprintf (is,
2919                            _("# internal disassembler error, "
2920                              "unrecognized modifier (%c)"),
2921                            *s);
2922                   abort ();
2923                 }
2924             }
2925
2926           /* Figure out instruction type and branch delay information.  */
2927           if ((op->pinfo
2928                & (INSN_UNCOND_BRANCH_DELAY | INSN_COND_BRANCH_DELAY)) != 0)
2929             info->branch_delay_insns = 1;
2930           if (((op->pinfo & INSN_UNCOND_BRANCH_DELAY)
2931                | (op->pinfo2 & INSN2_UNCOND_BRANCH)) != 0)
2932             {
2933               if ((op->pinfo & (INSN_WRITE_GPR_31 | INSN_WRITE_GPR_T)) != 0)
2934                 info->insn_type = dis_jsr;
2935               else
2936                 info->insn_type = dis_branch;
2937             }
2938           else if (((op->pinfo & INSN_COND_BRANCH_DELAY)
2939                     | (op->pinfo2 & INSN2_COND_BRANCH)) != 0)
2940             {
2941               if ((op->pinfo & INSN_WRITE_GPR_31) != 0)
2942                 info->insn_type = dis_condjsr;
2943               else
2944                 info->insn_type = dis_condbranch;
2945             }
2946           else if ((op->pinfo
2947                     & (INSN_STORE_MEMORY | INSN_LOAD_MEMORY_DELAY)) != 0)
2948             info->insn_type = dis_dref;
2949
2950           return length;
2951         }
2952     }
2953 #undef GET_OP
2954
2955   infprintf (is, "0x%x", insn);
2956   info->insn_type = dis_noninsn;
2957
2958   return length;
2959 }
2960
2961 /* Return 1 if a symbol associated with the location being disassembled
2962    indicates a compressed (MIPS16 or microMIPS) mode.  We iterate over
2963    all the symbols at the address being considered assuming if at least
2964    one of them indicates code compression, then such code has been
2965    genuinely produced here (other symbols could have been derived from
2966    function symbols defined elsewhere or could define data).  Otherwise,
2967    return 0.  */
2968
2969 static bfd_boolean
2970 is_compressed_mode_p (struct disassemble_info *info)
2971 {
2972   elf_symbol_type *symbol;
2973   int pos;
2974   int i;
2975
2976   for (i = 0; i < info->num_symbols; i++)
2977     {
2978       pos = info->symtab_pos + i;
2979
2980       if (bfd_asymbol_flavour (info->symtab[pos]) != bfd_target_elf_flavour)
2981         continue;
2982
2983       symbol = (elf_symbol_type *) info->symtab[pos];
2984       if ((!micromips_ase
2985            && ELF_ST_IS_MIPS16 (symbol->internal_elf_sym.st_other))
2986           || (micromips_ase
2987               && ELF_ST_IS_MICROMIPS (symbol->internal_elf_sym.st_other)))
2988             return 1;
2989     }
2990
2991   return 0;
2992 }
2993
2994 /* In an environment where we do not know the symbol type of the
2995    instruction we are forced to assume that the low order bit of the
2996    instructions' address may mark it as a mips16 instruction.  If we
2997    are single stepping, or the pc is within the disassembled function,
2998    this works.  Otherwise, we need a clue.  Sometimes.  */
2999
3000 static int
3001 _print_insn_mips (bfd_vma memaddr,
3002                   struct disassemble_info *info,
3003                   enum bfd_endian endianness)
3004 {
3005   int (*print_insn_compr) (bfd_vma, struct disassemble_info *);
3006   bfd_byte buffer[INSNLEN];
3007   int status;
3008
3009   set_default_mips_dis_options (info);
3010   parse_mips_dis_options (info->disassembler_options);
3011
3012   if (info->mach == bfd_mach_mips16)
3013     return print_insn_mips16 (memaddr, info);
3014   if (info->mach == bfd_mach_mips_micromips)
3015     return print_insn_micromips (memaddr, info);
3016
3017   print_insn_compr = !micromips_ase ? print_insn_mips16 : print_insn_micromips;
3018
3019 #if 1
3020   /* FIXME: If odd address, this is CLEARLY a compressed instruction.  */
3021   /* Only a few tools will work this way.  */
3022   if (memaddr & 0x01)
3023     return print_insn_compr (memaddr, info);
3024 #endif
3025
3026 #if SYMTAB_AVAILABLE
3027   if (is_compressed_mode_p (info))
3028     return print_insn_compr (memaddr, info);
3029 #endif
3030
3031   status = (*info->read_memory_func) (memaddr, buffer, INSNLEN, info);
3032   if (status == 0)
3033     {
3034       unsigned long insn;
3035
3036       if (endianness == BFD_ENDIAN_BIG)
3037         insn = (unsigned long) bfd_getb32 (buffer);
3038       else
3039         insn = (unsigned long) bfd_getl32 (buffer);
3040
3041       return print_insn_mips (memaddr, insn, info);
3042     }
3043   else
3044     {
3045       (*info->memory_error_func) (status, memaddr, info);
3046       return -1;
3047     }
3048 }
3049
3050 int
3051 print_insn_big_mips (bfd_vma memaddr, struct disassemble_info *info)
3052 {
3053   return _print_insn_mips (memaddr, info, BFD_ENDIAN_BIG);
3054 }
3055
3056 int
3057 print_insn_little_mips (bfd_vma memaddr, struct disassemble_info *info)
3058 {
3059   return _print_insn_mips (memaddr, info, BFD_ENDIAN_LITTLE);
3060 }
3061 \f
3062 void
3063 print_mips_disassembler_options (FILE *stream)
3064 {
3065   unsigned int i;
3066
3067   fprintf (stream, _("\n\
3068 The following MIPS specific disassembler options are supported for use\n\
3069 with the -M switch (multiple options should be separated by commas):\n"));
3070
3071   fprintf (stream, _("\n\
3072   gpr-names=ABI            Print GPR names according to  specified ABI.\n\
3073                            Default: based on binary being disassembled.\n"));
3074
3075   fprintf (stream, _("\n\
3076   fpr-names=ABI            Print FPR names according to specified ABI.\n\
3077                            Default: numeric.\n"));
3078
3079   fprintf (stream, _("\n\
3080   cp0-names=ARCH           Print CP0 register names according to\n\
3081                            specified architecture.\n\
3082                            Default: based on binary being disassembled.\n"));
3083
3084   fprintf (stream, _("\n\
3085   hwr-names=ARCH           Print HWR names according to specified \n\
3086                            architecture.\n\
3087                            Default: based on binary being disassembled.\n"));
3088
3089   fprintf (stream, _("\n\
3090   reg-names=ABI            Print GPR and FPR names according to\n\
3091                            specified ABI.\n"));
3092
3093   fprintf (stream, _("\n\
3094   reg-names=ARCH           Print CP0 register and HWR names according to\n\
3095                            specified architecture.\n"));
3096
3097   fprintf (stream, _("\n\
3098   For the options above, the following values are supported for \"ABI\":\n\
3099    "));
3100   for (i = 0; i < ARRAY_SIZE (mips_abi_choices); i++)
3101     fprintf (stream, " %s", mips_abi_choices[i].name);
3102   fprintf (stream, _("\n"));
3103
3104   fprintf (stream, _("\n\
3105   For the options above, The following values are supported for \"ARCH\":\n\
3106    "));
3107   for (i = 0; i < ARRAY_SIZE (mips_arch_choices); i++)
3108     if (*mips_arch_choices[i].name != '\0')
3109       fprintf (stream, " %s", mips_arch_choices[i].name);
3110   fprintf (stream, _("\n"));
3111
3112   fprintf (stream, _("\n"));
3113 }