opcodes/mips-dis.c

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