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