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