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