1/* 2 * Copyright © 2009 Apple Inc. All rights reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright notice, 10 * this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright notice, 12 * this list of conditions and the following disclaimer in the documentation 13 * and/or other materials provided with the distribution. 14 * 3. Neither the name of Apple Inc. ("Apple") nor the names of its 15 * contributors may be used to endorse or promote products derived from this 16 * software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY 19 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 20 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 21 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY 22 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 23 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 * 29 * @APPLE_LICENSE_HEADER_END@ 30 */ 31#include <stdio.h> 32#include <string.h> 33#include <mach-o/loader.h> 34#include <mach-o/nlist.h> 35#include <mach-o/reloc.h> 36#include <mach-o/ppc/reloc.h> 37#include "stuff/bytesex.h" 38#include "stuff/symbol.h" 39#include "otool.h" 40#include "ofile_print.h" 41#include "ppc_disasm.h" 42 43#define RT(x) (((x) >> 21) & 0x1f) 44#define RA(x) (((x) >> 16) & 0x1f) 45#define RB(x) (((x) >> 11) & 0x1f) 46 47#define VT(x) (((x) >> 21) & 0x1f) 48#define VA(x) (((x) >> 16) & 0x1f) 49#define VB(x) (((x) >> 11) & 0x1f) 50#define VC(x) (((x) >> 6) & 0x1f) 51#define TAG(x) (((x) >> 21) & 0x3) 52#define VX_Rc(x) (rc[((x >> 10) & 0x1)]) 53 54#define RS(x) (((x) >> 21) & 0x1f) 55#define TO(x) (((x) >> 21) & 0x1f) 56#define L(x) (((x) >> 21) & 0x1) 57#define NB(x) (((x) >> 11) & 0x1f) 58#define SH(x) (((x) >> 11) & 0x1f) 59#define MB(x) (((x) >> 6) & 0x1f) 60#define ME(x) (((x) >> 1) & 0x1f) 61 62#define BF(x) (((x) >> 23) & 0x7) 63#define BFA(x) (((x) >> 18) & 0x7) 64#define U(x) (((x) >> 12) & 0xf) 65#define BT(x) (((x) >> 21) & 0x1f) 66 67#define SR(x) (((x) >> 16) & 0xf) 68 69#define FRT(x) (((x) >> 21) & 0x1f) 70#define FRA(x) (((x) >> 16) & 0x1f) 71#define FRB(x) (((x) >> 11) & 0x1f) 72#define FRC(x) (((x) >> 6) & 0x1f) 73#define FLM(x) (((x) >> 17) & 0xff) 74 75#define OE_Rc(x) (oe_rc[((x >> 9) & 0x2) | ((x) & 0x1)]) 76#define Rc(x) (rc[(x) & 0x1]) 77#define LK(x) (lk[(x) & 0x1]) 78#define AA(x) (aa[(x >> 1) & 0x1]) 79 80#define BH(x) (((x) >> 11) & 0x3) 81#define BC(x) (((x) >> 16) & 0x3) 82#define CR_FIELD(x) (((x) >> 18) & 0x7) 83#define Y_BIT(x) (((x) >> 21) & 0x1) 84#define BC_TRUE(x) (bc_true[BC(x)]) 85#define BC_FALSE(x) (bc_false[BC(x)]) 86 87#define TH(x) (((x) >> 21) & 0xf) 88 89static const char *oe_rc[] = { "", ".", "o", "o." }; 90static const char *rc[] = { "", "." }; 91static const char *lk[] = { "", "l" }; 92static const char *aa[] = { "", "a" }; 93static const char *bc_true[] = { "lt", "gt", "eq", "un" }; 94static const char *bc_false[] = { "ge", "le", "ne", "nu" }; 95 96static void xo_form( 97 const char *name, 98 uint32_t opcode, 99 uint32_t nregs); 100 101static void x_form( 102 const char *name, 103 uint32_t opcode, 104 uint32_t nregs); 105 106static void sx_form( 107 const char *name, 108 uint32_t opcode, 109 uint32_t nregs); 110 111static void fx_form( 112 const char *name, 113 uint32_t opcode, 114 uint32_t nregs); 115 116static void xl_form( 117 const char *name, 118 uint32_t opcode, 119 uint32_t nregs); 120 121static void a_form( 122 const char *name, 123 uint32_t opcode, 124 uint32_t nregs); 125 126static uint32_t bc( 127 const char *name, 128 uint32_t opcode, 129 uint32_t sect_offset, 130 struct relocation_info *relocs, 131 uint32_t nrelocs); 132 133static void trap( 134 const char *name, 135 uint32_t opcode); 136 137static void print_special_register_name( 138 unsigned opcode); 139 140static void print_immediate( 141 uint32_t value, 142 uint32_t sect_offset, 143 struct relocation_info *sorted_relocs, 144 uint32_t nsorted_relocs, 145 struct nlist *symbols, 146 struct nlist_64 *symbols64, 147 uint32_t nsymbols, 148 struct symbol *sorted_symbols, 149 uint32_t nsorted_symbols, 150 char *strings, 151 uint32_t strings_size, 152 enum bool verbose); 153 154static uint32_t get_reloc_r_type( 155 uint32_t pc, 156 struct relocation_info *relocs, 157 uint32_t nrelocs); 158 159static uint32_t get_reloc_r_length( 160 uint32_t sect_offset, 161 struct relocation_info *relocs, 162 uint32_t nrelocs); 163 164uint32_t 165ppc_disassemble( 166char *sect, 167uint32_t left, 168uint32_t addr, 169uint32_t sect_addr, 170enum byte_sex object_byte_sex, 171struct relocation_info *relocs, 172uint32_t nrelocs, 173struct nlist *symbols, 174struct nlist_64 *symbols64, 175uint32_t nsymbols, 176struct symbol *sorted_symbols, 177uint32_t nsorted_symbols, 178char *strings, 179uint32_t strings_size, 180uint32_t *indirect_symbols, 181uint32_t nindirect_symbols, 182struct load_command *load_commands, 183uint32_t ncmds, 184uint32_t sizeofcmds, 185enum bool verbose) 186{ 187 enum byte_sex host_byte_sex; 188 enum bool swapped, jbsr; 189 uint32_t opcode, base, disp; 190 int32_t simm; 191 uint32_t sect_offset; 192 const char *indirect_symbol_name; 193 194 host_byte_sex = get_host_byte_sex(); 195 swapped = host_byte_sex != object_byte_sex; 196 sect_offset = addr - sect_addr; 197 198 if(left < sizeof(uint32_t)){ 199 if(left != 0){ 200 memcpy(&opcode, sect, left); 201 if(swapped) 202 opcode = SWAP_INT(opcode); 203 printf(".long\t0x%08x\n", (unsigned int)opcode); 204 } 205 printf("(end of section)\n"); 206 return(left); 207 } 208 209 memcpy(&opcode, sect, sizeof(uint32_t)); 210 if(swapped) 211 opcode = SWAP_INT(opcode); 212 213 switch(opcode & 0xfc000000){ 214 case 0x00000000: 215 if((opcode & 0xfc0007ff) == 0x00000200){ 216 printf("attn\t0x%x\n", (unsigned int)((opcode >> 11) & 0x7fff)); 217 break; 218 } 219 printf(".long 0x%08x\n", (unsigned int)opcode); 220 break; 221 case 0x38000000: 222 if(RA(opcode) == 0) 223 printf("li\tr%u,", RT(opcode)); 224 else 225 printf("addi\tr%u,r%u,", RT(opcode), RA(opcode)); 226 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 227 symbols, symbols64, nsymbols, sorted_symbols, 228 nsorted_symbols, strings, strings_size, verbose); 229 printf("\n"); 230 break; 231 case 0x3c000000: 232 if(RA(opcode) == 0) 233 printf("lis\tr%u,", RT(opcode)); 234 else 235 printf("addis\tr%u,r%u,", RT(opcode), RA(opcode)); 236 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 237 symbols, symbols64, nsymbols, sorted_symbols, 238 nsorted_symbols, strings, strings_size, verbose); 239 printf("\n"); 240 break; 241 case 0x30000000: 242 printf("addic\tr%u,r%u,", RT(opcode), RA(opcode)); 243 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 244 symbols, symbols64, nsymbols, sorted_symbols, 245 nsorted_symbols, strings, strings_size, verbose); 246 printf("\n"); 247 break; 248 case 0x34000000: 249 printf("addic.\tr%u,r%u,", RT(opcode), RA(opcode)); 250 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 251 symbols, symbols64, nsymbols, sorted_symbols, 252 nsorted_symbols, strings, strings_size, verbose); 253 printf("\n"); 254 break; 255 case 0x20000000: 256 printf("subfic\tr%u,r%u,", RT(opcode), RA(opcode)); 257 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 258 symbols, symbols64, nsymbols, sorted_symbols, 259 nsorted_symbols, strings, strings_size, verbose); 260 printf("\n"); 261 break; 262 case 0x1c000000: 263 printf("mulli\tr%u,r%u,", RT(opcode), RA(opcode)); 264 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 265 symbols, symbols64, nsymbols, sorted_symbols, 266 nsorted_symbols, strings, strings_size, verbose); 267 printf("\n"); 268 break; 269 case 0x28000000: 270 if(Zflag == TRUE) 271 printf("cmpli\tcr%u,%d,r%u,", BF(opcode), L(opcode), 272 RA(opcode)); 273 else if(BF(opcode) == 0) 274 printf("cmpl%si\tr%u,", L(opcode) == 0 ? "w" : "d",RA(opcode)); 275 else 276 printf("cmpl%si\tcr%u,r%u,", L(opcode) == 0 ?"w":"d", 277 BF(opcode), RA(opcode)); 278 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 279 symbols, symbols64, nsymbols, sorted_symbols, 280 nsorted_symbols, strings, strings_size, verbose); 281 printf("\n"); 282 break; 283 case 0x2c000000: 284 if(Zflag == TRUE) 285 printf("cmpi\tcr%u,%d,r%u,", BF(opcode), L(opcode), 286 RA(opcode)); 287 else if(BF(opcode) == 0) 288 printf("cmp%si\tr%u,", L(opcode) == 0 ? "w" : "d",RA(opcode)); 289 else 290 printf("cmp%si\tcr%u,r%u,", L(opcode) == 0 ?"w":"d", 291 BF(opcode), RA(opcode)); 292 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 293 symbols, symbols64, nsymbols, sorted_symbols, 294 nsorted_symbols, strings, strings_size, verbose); 295 printf("\n"); 296 break; 297 case 0x48000000: 298 if((opcode & 0xfc000003) == 0x48000001 && 299 get_reloc_r_type(sect_offset,relocs, nrelocs) == PPC_RELOC_JBSR){ 300 printf("jbsr\t"); 301 jbsr = TRUE; 302 } 303 else if((opcode & 0xfc000003) == 0x48000000 && 304 get_reloc_r_type(sect_offset,relocs, nrelocs) == PPC_RELOC_JBSR){ 305 printf("jmp\t"); 306 jbsr = TRUE; 307 } 308 else{ 309 printf("b%s%s\t", LK(opcode), AA(opcode)); 310 jbsr = FALSE; 311 } 312 if((opcode & 0x00000002) != 0) 313 base = 0; 314 else 315 base = addr; 316 if((opcode & 0x02000000) == 0) 317 disp = opcode & 0x03fffffc; 318 else 319 disp = (opcode & 0x03fffffc) | 0xfc000000; 320 if(jbsr == TRUE){ 321 print_immediate(sect_addr, sect_offset, 322 relocs, nrelocs, symbols, symbols64, nsymbols, 323 sorted_symbols, nsorted_symbols, strings, strings_size, 324 verbose); 325 printf(",0x%x\n", (unsigned int)(base + disp)); 326 } 327 else{ 328 print_immediate(base + disp, sect_offset, 329 relocs, nrelocs, symbols, symbols64, nsymbols, 330 sorted_symbols, nsorted_symbols, strings, strings_size, 331 verbose); 332 if(verbose){ 333 indirect_symbol_name = guess_indirect_symbol(base + disp, 334 ncmds, sizeofcmds, load_commands, object_byte_sex, 335 indirect_symbols, nindirect_symbols, symbols, symbols64, 336 nsymbols, strings, strings_size); 337 if(indirect_symbol_name != NULL) 338 printf("\t; symbol stub for: %s", indirect_symbol_name); 339 } 340 printf("\n"); 341 } 342 break; 343 case 0x40000000: 344 if(bc("", opcode, sect_offset, relocs, nrelocs) == 0) 345 printf("\t"); 346 else 347 printf(","); 348 if((opcode & 0x00000002) != 0) 349 base = 0; 350 else 351 base = addr; 352 if((opcode & 0x00008000) == 0) 353 print_immediate(base + (opcode & 0x0000fffc), sect_offset, 354 relocs, nrelocs, symbols, symbols64, nsymbols, 355 sorted_symbols, nsorted_symbols, strings, strings_size, 356 verbose); 357 else 358 print_immediate(base + 359 ((opcode & 0x0000fffc) | 0xffff0000), sect_offset, 360 relocs, nrelocs, symbols, symbols64, nsymbols, 361 sorted_symbols, nsorted_symbols, strings, strings_size, 362 verbose); 363 printf("\n"); 364 break; 365 case 0x88000000: 366 printf("lbz\tr%u,", RT(opcode)); 367 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 368 symbols, symbols64, nsymbols, sorted_symbols, 369 nsorted_symbols, strings, strings_size, verbose); 370 if(RA(opcode) == 0) 371 printf("(0)\n"); 372 else 373 printf("(r%u)\n", RA(opcode)); 374 break; 375 case 0x8c000000: 376 printf("lbzu\tr%u,", RT(opcode)); 377 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 378 symbols, symbols64, nsymbols, sorted_symbols, 379 nsorted_symbols, strings, strings_size, verbose); 380 if(RA(opcode) == 0) 381 printf("(0)\n"); 382 else 383 printf("(r%u)\n", RA(opcode)); 384 break; 385 case 0xa0000000: 386 printf("lhz\tr%u,", RT(opcode)); 387 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 388 symbols, symbols64, nsymbols, sorted_symbols, 389 nsorted_symbols, strings, strings_size, verbose); 390 if(RA(opcode) == 0) 391 printf("(0)\n"); 392 else 393 printf("(r%u)\n", RA(opcode)); 394 break; 395 case 0xa4000000: 396 printf("lhzu\tr%u,", RT(opcode)); 397 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 398 symbols, symbols64, nsymbols, sorted_symbols, 399 nsorted_symbols, strings, strings_size, verbose); 400 if(RA(opcode) == 0) 401 printf("(0)\n"); 402 else 403 printf("(r%u)\n", RA(opcode)); 404 break; 405 case 0xa8000000: 406 printf("lha\tr%u,", RT(opcode)); 407 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 408 symbols, symbols64, nsymbols, sorted_symbols, 409 nsorted_symbols, strings, strings_size, verbose); 410 if(RA(opcode) == 0) 411 printf("(0)\n"); 412 else 413 printf("(r%u)\n", RA(opcode)); 414 break; 415 case 0xac000000: 416 printf("lhau\tr%u,", RT(opcode)); 417 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 418 symbols, symbols64, nsymbols, sorted_symbols, 419 nsorted_symbols, strings, strings_size, verbose); 420 printf("(r%u)\n", RA(opcode)); 421 break; 422 case 0x80000000: 423 printf("lwz\tr%u,", RT(opcode)); 424 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 425 symbols, symbols64, nsymbols, sorted_symbols, 426 nsorted_symbols, strings, strings_size, verbose); 427 if(RA(opcode) == 0) 428 printf("(0)\n"); 429 else 430 printf("(r%u)\n", RA(opcode)); 431 break; 432 case 0x84000000: 433 printf("lwzu\tr%u,", RT(opcode)); 434 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 435 symbols, symbols64, nsymbols, sorted_symbols, 436 nsorted_symbols, strings, strings_size, verbose); 437 printf("(r%u)\n", RA(opcode)); 438 break; 439 case 0x98000000: 440 printf("stb\tr%u,", RT(opcode)); 441 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 442 symbols, symbols64, nsymbols, sorted_symbols, 443 nsorted_symbols, strings, strings_size, verbose); 444 if(RA(opcode) == 0) 445 printf("(0)\n"); 446 else 447 printf("(r%u)\n", RA(opcode)); 448 break; 449 case 0x9c000000: 450 printf("stbu\tr%u,", RT(opcode)); 451 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 452 symbols, symbols64, nsymbols, sorted_symbols, 453 nsorted_symbols, strings, strings_size, verbose); 454 printf("(r%u)\n", RA(opcode)); 455 break; 456 case 0xb0000000: 457 printf("sth\tr%u,", RT(opcode)); 458 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 459 symbols, symbols64, nsymbols, sorted_symbols, 460 nsorted_symbols, strings, strings_size, verbose); 461 if(RA(opcode) == 0) 462 printf("(0)\n"); 463 else 464 printf("(r%u)\n", RA(opcode)); 465 break; 466 case 0xb4000000: 467 printf("sthu\tr%u,", RT(opcode)); 468 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 469 symbols, symbols64, nsymbols, sorted_symbols, 470 nsorted_symbols, strings, strings_size, verbose); 471 printf("(r%u)\n", RA(opcode)); 472 break; 473 case 0x90000000: 474 printf("stw\tr%u,", RT(opcode)); 475 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 476 symbols, symbols64, nsymbols, sorted_symbols, 477 nsorted_symbols, strings, strings_size, verbose); 478 if(RA(opcode) == 0) 479 printf("(0)\n"); 480 else 481 printf("(r%u)\n", RA(opcode)); 482 break; 483 case 0x94000000: 484 printf("stwu\tr%u,", RT(opcode)); 485 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 486 symbols, symbols64, nsymbols, sorted_symbols, 487 nsorted_symbols, strings, strings_size, verbose); 488 printf("(r%u)\n", RA(opcode)); 489 break; 490 case 0xb8000000: 491 printf("lmw\tr%u,", RT(opcode)); 492 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 493 symbols, symbols64, nsymbols, sorted_symbols, 494 nsorted_symbols, strings, strings_size, verbose); 495 if(RA(opcode) == 0) 496 printf("(0)\n"); 497 else 498 printf("(r%u)\n", RA(opcode)); 499 break; 500 case 0xbc000000: 501 printf("stmw\tr%u,", RT(opcode)); 502 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 503 symbols, symbols64, nsymbols, sorted_symbols, 504 nsorted_symbols, strings, strings_size, verbose); 505 if(RA(opcode) == 0) 506 printf("(0)\n"); 507 else 508 printf("(r%u)\n", RA(opcode)); 509 break; 510 case 0x08000000: 511 trap("d", opcode); 512 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 513 symbols, symbols64, nsymbols, sorted_symbols, 514 nsorted_symbols, strings, strings_size, verbose); 515 printf("\n"); 516 break; 517 case 0x0c000000: 518 trap("w", opcode); 519 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 520 symbols, symbols64, nsymbols, sorted_symbols, 521 nsorted_symbols, strings, strings_size, verbose); 522 printf("\n"); 523 break; 524 case 0x70000000: 525 printf("andi.\tr%u,r%u,", RA(opcode), RS(opcode)); 526 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 527 symbols, symbols64, nsymbols, sorted_symbols, 528 nsorted_symbols, strings, strings_size, verbose); 529 printf("\n"); 530 break; 531 case 0x74000000: 532 printf("andis.\tr%u,r%u,", RA(opcode), RS(opcode)); 533 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 534 symbols, symbols64, nsymbols, sorted_symbols, 535 nsorted_symbols, strings, strings_size, verbose); 536 printf("\n"); 537 break; 538 case 0x60000000: 539 if(opcode == 0x60000000) 540 printf("nop\n"); 541 else{ 542 printf("ori\tr%u,r%u,", RA(opcode), RS(opcode)); 543 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 544 symbols, symbols64, nsymbols, sorted_symbols, 545 nsorted_symbols, strings, strings_size,verbose); 546 printf("\n"); 547 } 548 break; 549 case 0x64000000: 550 printf("oris\tr%u,r%u,", RA(opcode), RS(opcode)); 551 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 552 symbols, symbols64, nsymbols, sorted_symbols, 553 nsorted_symbols, strings, strings_size, verbose); 554 printf("\n"); 555 break; 556 case 0x68000000: 557 printf("xori\tr%u,r%u,", RA(opcode), RS(opcode)); 558 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 559 symbols, symbols64, nsymbols, sorted_symbols, 560 nsorted_symbols, strings, strings_size, verbose); 561 printf("\n"); 562 break; 563 case 0x6c000000: 564 printf("xoris\tr%u,r%u,", RA(opcode), RS(opcode)); 565 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 566 symbols, symbols64, nsymbols, sorted_symbols, 567 nsorted_symbols, strings, strings_size, verbose); 568 printf("\n"); 569 break; 570 case 0xc0000000: 571 printf("lfs\tf%u,", FRT(opcode)); 572 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 573 symbols, symbols64, nsymbols, sorted_symbols, 574 nsorted_symbols, strings, strings_size, verbose); 575 if(RA(opcode) == 0) 576 printf("(0)\n"); 577 else 578 printf("(r%u)\n", RA(opcode)); 579 break; 580 case 0xc4000000: 581 printf("lfsu\tf%u,", FRT(opcode)); 582 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 583 symbols, symbols64, nsymbols, sorted_symbols, 584 nsorted_symbols, strings, strings_size, verbose); 585 printf("(r%u)\n", RA(opcode)); 586 break; 587 case 0xc8000000: 588 printf("lfd\tf%u,", FRT(opcode)); 589 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 590 symbols, symbols64, nsymbols, sorted_symbols, 591 nsorted_symbols, strings, strings_size, verbose); 592 if(RA(opcode) == 0) 593 printf("(0)\n"); 594 else 595 printf("(r%u)\n", RA(opcode)); 596 break; 597 case 0xcc000000: 598 printf("lfdu\tf%u,", FRT(opcode)); 599 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 600 symbols, symbols64, nsymbols, sorted_symbols, 601 nsorted_symbols, strings, strings_size, verbose); 602 printf("(r%u)\n", RA(opcode)); 603 break; 604 case 0xd0000000: 605 printf("stfs\tf%u,", FRT(opcode)); 606 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 607 symbols, symbols64, nsymbols, sorted_symbols, 608 nsorted_symbols, strings, strings_size, verbose); 609 if(RA(opcode) == 0) 610 printf("(0)\n"); 611 else 612 printf("(r%u)\n", RA(opcode)); 613 break; 614 case 0xd4000000: 615 printf("stfsu\tf%u,", FRT(opcode)); 616 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 617 symbols, symbols64, nsymbols, sorted_symbols, 618 nsorted_symbols, strings, strings_size, verbose); 619 printf("(r%u)\n", RA(opcode)); 620 break; 621 case 0xd8000000: 622 printf("stfd\tf%u,", FRT(opcode)); 623 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 624 symbols, symbols64, nsymbols, sorted_symbols, 625 nsorted_symbols, strings, strings_size, verbose); 626 if(RA(opcode) == 0) 627 printf("(0)\n"); 628 else 629 printf("(r%u)\n", RA(opcode)); 630 break; 631 case 0xdc000000: 632 printf("stfdu\tf%u,", FRT(opcode)); 633 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 634 symbols, symbols64, nsymbols, sorted_symbols, 635 nsorted_symbols, strings, strings_size, verbose); 636 printf("(r%u)\n", RA(opcode)); 637 break; 638 case 0x24000000: 639 printf("dozi\tr%u,r%u,", RT(opcode), RA(opcode)); 640 print_immediate(opcode & 0xffff, sect_offset, relocs, nrelocs, 641 symbols, symbols64, nsymbols, sorted_symbols, 642 nsorted_symbols, strings, strings_size, verbose); 643 break; 644 case 0xe8000000: 645 switch(opcode & 0x3){ 646 case 0: 647 printf("ld\tr%u,", RT(opcode)); 648 print_immediate(opcode & 0xfffc, sect_offset, relocs, nrelocs, 649 symbols, symbols64, nsymbols, sorted_symbols, 650 nsorted_symbols, strings, strings_size,verbose); 651 if(RA(opcode) == 0) 652 printf("(0)\n"); 653 else 654 printf("(r%u)\n", RA(opcode)); 655 break; 656 case 1: 657 printf("ldu\tr%u,", RT(opcode)); 658 print_immediate(opcode & 0xfffc, sect_offset, relocs, nrelocs, 659 symbols, symbols64, nsymbols, sorted_symbols, 660 nsorted_symbols, strings, strings_size,verbose); 661 printf("(r%u)\n", RA(opcode)); 662 break; 663 case 2: 664 printf("lwa\tr%u,", RT(opcode)); 665 print_immediate(opcode & 0xfffc, sect_offset, relocs, nrelocs, 666 symbols, symbols64, nsymbols, sorted_symbols, 667 nsorted_symbols, strings, strings_size,verbose); 668 if(RA(opcode) == 0) 669 printf("(0)\n"); 670 else 671 printf("(r%u)\n", RA(opcode)); 672 break; 673 default: 674 printf(".long 0x%08x\n", (unsigned int)opcode); 675 break; 676 } 677 break; 678 case 0xf8000000: 679 switch(opcode & 0x3){ 680 case 0: 681 printf("std\tr%u,", RT(opcode)); 682 print_immediate(opcode & 0xfffc, sect_offset, relocs, nrelocs, 683 symbols, symbols64, nsymbols, sorted_symbols, 684 nsorted_symbols, strings, strings_size,verbose); 685 if(RA(opcode) == 0) 686 printf("(0)\n"); 687 else 688 printf("(r%u)\n", RA(opcode)); 689 break; 690 case 1: 691 printf("stdu\tr%u,", RT(opcode)); 692 print_immediate(opcode & 0xfffc, sect_offset, relocs, nrelocs, 693 symbols, symbols64, nsymbols, sorted_symbols, 694 nsorted_symbols, strings, strings_size,verbose); 695 printf("(r%u)\n", RA(opcode)); 696 break; 697 default: 698 printf(".long 0x%08x\n", (unsigned int)opcode); 699 break; 700 } 701 break; 702 case 0x7c000000: 703 switch(opcode & 0x000007fe){ 704 case 0x00000214: 705 case 0x00000614: 706 xo_form("add", opcode, 3); 707 break; 708 case 0x00000050: 709 case 0x00000450: 710 xo_form("subf", opcode, 3); 711 break; 712 case 0x00000014: 713 case 0x00000414: 714 xo_form("addc", opcode, 3); 715 break; 716 case 0x00000114: 717 case 0x00000514: 718 xo_form("adde", opcode, 3); 719 break; 720 case 0x00000010: 721 case 0x00000410: 722 xo_form("subfc", opcode, 3); 723 break; 724 case 0x00000110: 725 case 0x00000510: 726 xo_form("subfe", opcode, 3); 727 break; 728 case 0x000001d4: 729 case 0x000005d4: 730 xo_form("addme", opcode, 2); 731 break; 732 case 0x00000194: 733 case 0x00000594: 734 xo_form("addze", opcode, 2); 735 break; 736 case 0x000001d0: 737 case 0x000005d0: 738 xo_form("subfme", opcode, 2); 739 break; 740 case 0x00000190: 741 case 0x00000590: 742 xo_form("subfze", opcode, 2); 743 break; 744 case 0x000000d0: 745 case 0x000004d0: 746 xo_form("neg", opcode, 2); 747 break; 748 case 0x000001d6: 749 case 0x000005d6: 750 xo_form("mullw", opcode, 3); 751 break; 752 case 0x000001d2: 753 case 0x000005d2: 754 xo_form("mulld", opcode, 3); 755 break; 756 case 0x00000092: 757 case 0x00000492: 758 xo_form("mulhd", opcode, 3); 759 break; 760 case 0x00000096: 761 case 0x00000496: 762 xo_form("mulhw", opcode, 3); 763 break; 764 case 0x00000012: 765 case 0x00000412: 766 xo_form("mulhdu", opcode, 3); 767 break; 768 case 0x00000016: 769 case 0x00000416: 770 xo_form("mulhwu", opcode, 3); 771 break; 772 case 0x000003d2: 773 case 0x000007d2: 774 xo_form("divd", opcode, 3); 775 break; 776 case 0x000003d6: 777 case 0x000007d6: 778 xo_form("divw", opcode, 3); 779 break; 780 case 0x00000392: 781 case 0x00000792: 782 xo_form("divdu", opcode, 3); 783 break; 784 case 0x00000396: 785 case 0x00000796: 786 xo_form("divwu", opcode, 3); 787 break; 788 789 case 0x000000ae: 790 if(RA(opcode) == 0) 791 printf("lbzx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 792 else 793 printf("lbzx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 794 RB(opcode)); 795 break; 796 case 0x000000ee: 797 x_form("lbzux", opcode, 3); 798 break; 799 case 0x0000022e: 800 if(RA(opcode) == 0) 801 printf("lhzx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 802 else 803 printf("lhzx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 804 RB(opcode)); 805 break; 806 case 0x0000026e: 807 x_form("lhzux", opcode, 3); 808 break; 809 case 0x000002ae: 810 if(RA(opcode) == 0) 811 printf("lhax\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 812 else 813 printf("lhax\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 814 RB(opcode)); 815 break; 816 case 0x000002ee: 817 x_form("lhaux", opcode, 3); 818 break; 819 case 0x0000002e: 820 if(RA(opcode) == 0) 821 printf("lwzx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 822 else 823 printf("lwzx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 824 RB(opcode)); 825 break; 826 case 0x0000006e: 827 x_form("lwzux", opcode, 3); 828 break; 829 case 0x000002aa: 830 if(RA(opcode) == 0) 831 printf("lwax\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 832 else 833 printf("lwax\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 834 RB(opcode)); 835 break; 836 case 0x000002ea: 837 x_form("lwaux", opcode, 3); 838 break; 839 case 0x0000002a: 840 if(RA(opcode) == 0) 841 printf("ldx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 842 else 843 printf("ldx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 844 RB(opcode)); 845 break; 846 case 0x0000006a: 847 x_form("ldux", opcode, 3); 848 break; 849 case 0x000001ae: 850 if(RA(opcode) == 0) 851 printf("stbx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 852 else 853 printf("stbx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 854 RB(opcode)); 855 break; 856 case 0x000001ee: 857 x_form("stbux", opcode, 3); 858 break; 859 case 0x0000032e: 860 if(RA(opcode) == 0) 861 printf("sthx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 862 else 863 printf("sthx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 864 RB(opcode)); 865 break; 866 case 0x0000036e: 867 x_form("sthux", opcode, 3); 868 break; 869 case 0x0000012e: 870 if(RA(opcode) == 0) 871 printf("stwx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 872 else 873 printf("stwx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 874 RB(opcode)); 875 break; 876 case 0x0000016e: 877 x_form("stwux", opcode, 3); 878 break; 879 case 0x0000012a: 880 if(RA(opcode) == 0) 881 printf("stdx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 882 else 883 printf("stdx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 884 RB(opcode)); 885 break; 886 case 0x0000016a: 887 x_form("stdux", opcode, 3); 888 break; 889 case 0x0000062c: 890 if(RA(opcode) == 0) 891 printf("lhbrx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 892 else 893 printf("lhbrx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 894 RB(opcode)); 895 break; 896 case 0x0000042c: 897 if(RA(opcode) == 0) 898 printf("lwbrx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 899 else 900 printf("lwbrx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 901 RB(opcode)); 902 break; 903 case 0x0000072c: 904 if(RA(opcode) == 0) 905 printf("sthbrx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 906 else 907 printf("sthbrx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 908 RB(opcode)); 909 break; 910 case 0x0000052c: 911 if(RA(opcode) == 0) 912 printf("stwbrx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 913 else 914 printf("stwbrx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 915 RB(opcode)); 916 break; 917 case 0x0000042a: 918 if(RA(opcode) == 0) 919 printf("lswx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 920 else 921 printf("lswx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 922 RB(opcode)); 923 break; 924 case 0x0000052a: 925 if(RA(opcode) == 0) 926 printf("stswx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 927 else 928 printf("stswx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 929 RB(opcode)); 930 break; 931 case 0x00000028: 932 if(RA(opcode) == 0) 933 printf("lwarx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 934 else 935 printf("lwarx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 936 RB(opcode)); 937 break; 938 case 0x000000a8: 939 if(RA(opcode) == 0) 940 printf("ldarx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 941 else 942 printf("ldarx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 943 RB(opcode)); 944 break; 945 case 0x0000022a: 946 if(RA(opcode) == 0) 947 printf("lscbx%s\tr%u,0,r%u\n", Rc(opcode), RT(opcode), 948 RB(opcode)); 949 else 950 printf("lscbx%s\tr%u,r%u,r%u\n", Rc(opcode), RT(opcode), 951 RA(opcode), RB(opcode)); 952 break; 953 case 0x0000012c: 954 if(RA(opcode) == 0) 955 printf("stwcx.\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 956 else 957 printf("stwcx.\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 958 RB(opcode)); 959 break; 960 case 0x000001ac: 961 if(RA(opcode) == 0) 962 printf("stdcx.\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 963 else 964 printf("stdcx.\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 965 RB(opcode)); 966 break; 967 case 0x00000038: 968 sx_form("and", opcode, 3); 969 break; 970 case 0x00000278: 971 sx_form("xor", opcode, 3); 972 break; 973 case 0x00000378: 974 sx_form("or", opcode, 3); 975 break; 976 case 0x000003b8: 977 sx_form("nand", opcode, 3); 978 break; 979 case 0x000000f8: 980 sx_form("nor", opcode, 3); 981 break; 982 case 0x00000078: 983 sx_form("andc", opcode, 3); 984 break; 985 case 0x00000238: 986 sx_form("eqv", opcode, 3); 987 break; 988 case 0x00000338: 989 sx_form("orc", opcode, 3); 990 break; 991 case 0x00000774: 992 sx_form("extsb", opcode, 2); 993 break; 994 case 0x000007b4: 995 sx_form("extsw", opcode, 2); 996 break; 997 case 0x00000734: 998 sx_form("extsh", opcode, 2); 999 break; 1000 case 0x00000074: 1001 sx_form("cntlzd", opcode, 2); 1002 break; 1003 case 0x00000034: 1004 sx_form("cntlzw", opcode, 2); 1005 break; 1006 case 0x00000036: 1007 sx_form("sld", opcode, 3); 1008 break; 1009 case 0x00000030: 1010 sx_form("slw", opcode, 3); 1011 break; 1012 case 0x00000436: 1013 sx_form("srd", opcode, 3); 1014 break; 1015 case 0x00000430: 1016 sx_form("srw", opcode, 3); 1017 break; 1018 case 0x00000634: 1019 sx_form("srad", opcode, 3); 1020 break; 1021 case 0x00000630: 1022 sx_form("sraw", opcode, 3); 1023 break; 1024 case 0x000004aa: 1025 if(RA(opcode) == 0) 1026 printf("lswi\tr%u,0,%u\n", RT(opcode), NB(opcode)); 1027 else 1028 printf("lswi\tr%u,r%u,%u\n", RT(opcode), RA(opcode), 1029 NB(opcode)); 1030 break; 1031 case 0x000005aa: 1032 if(RA(opcode) == 0) 1033 printf("stswi\tr%u,0,%u\n", RT(opcode), NB(opcode)); 1034 else 1035 printf("stswi\tr%u,r%u,%u\n", RT(opcode), RA(opcode), 1036 NB(opcode)); 1037 break; 1038 case 0x000004ac: 1039 switch((opcode >> 21) & 0x3){ 1040 case 0: 1041 printf("sync\n"); 1042 break; 1043 case 1: 1044 printf("lwsync\n"); 1045 break; 1046 case 2: 1047 printf("ptesync\n"); 1048 break; 1049 case 3: 1050 printf("sync\t3\n"); 1051 break; 1052 } 1053 break; 1054 case 0x00000000: 1055 if(Zflag == TRUE) 1056 printf("cmp\tcr%u,%d,r%u,r%u\n", 1057 BF(opcode), L(opcode), RA(opcode), RB(opcode)); 1058 else if(BF(opcode) == 0) 1059 printf("cmp%s\tr%u,r%u\n", L(opcode) == 0 ? "w" : "d", 1060 RA(opcode), RB(opcode)); 1061 else 1062 printf("cmp%s\tcr%u,r%u,r%u\n", L(opcode) == 0 ? "w":"d", 1063 BF(opcode), RA(opcode), RB(opcode)); 1064 break; 1065 case 0x00000040: 1066 if(Zflag == TRUE) 1067 printf("cmpl\tcr%u,%d,r%u,r%u\n", BF(opcode), L(opcode), 1068 RA(opcode), RB(opcode)); 1069 else if(BF(opcode) == 0) 1070 printf("cmpl%s\tr%u,r%u\n", L(opcode) == 0 ? "w" : "d", 1071 RA(opcode), RB(opcode)); 1072 else 1073 printf("cmpl%s\tcr%u,r%u,r%u\n", L(opcode) == 0 ?"w":"d", 1074 BF(opcode), RA(opcode), RB(opcode)); 1075 break; 1076 case 0x00000088: 1077 trap("d", opcode); 1078 printf("r%u\n", RB(opcode)); 1079 break; 1080 case 0x00000008: 1081 if(opcode == 0x7fe00008){ 1082 printf("trap\n"); 1083 } 1084 else{ 1085 trap("w", opcode); 1086 printf("r%u\n", RB(opcode)); 1087 } 1088 break; 1089 case 0x00000670: 1090 printf("srawi%s\tr%u,r%u,%u\n", Rc(opcode), RA(opcode), 1091 RS(opcode), SH(opcode)); 1092 break; 1093 case 0x00000674: 1094 case 0x00000676: 1095 printf("sradi%s\tr%u,r%u,%u\n", Rc(opcode), RA(opcode), 1096 RS(opcode), ((opcode & 0x2) << 4) | SH(opcode)); 1097 break; 1098 case 0x000003a6: 1099 if((opcode & 0xfc1fffff) == 0x7c1c43a6){ 1100 printf("mttbl\t"); 1101 printf("r%u\n", RS(opcode)); 1102 } 1103 else if((opcode & 0xfc1fffff) == 0x7c1d43a6){ 1104 printf("mttbu\t"); 1105 printf("r%u\n", RS(opcode)); 1106 } 1107 else{ 1108 printf("mtspr\t"); 1109 print_special_register_name(opcode); 1110 printf(",r%u\n", RS(opcode)); 1111 } 1112 break; 1113 case 0x000002a6: 1114 printf("mfspr\tr%u,", RT(opcode)); 1115 print_special_register_name(opcode); 1116 printf("\n"); 1117 break; 1118 case 0x00000120: 1119 if(opcode & 0x00100000) 1120 printf("mtocrf\t0x%02x,r%u\n", 1121 (unsigned int)((opcode >> 12) & 0xff), 1122 RS(opcode)); 1123 else 1124 printf("mtcrf\t%u,r%u\n", (opcode >> 12) & 0xff, 1125 RS(opcode)); 1126 break; 1127 case 0x00000400: 1128 printf("mcrxr\tcr%u\n", BF(opcode)); 1129 break; 1130 case 0x00000026: 1131 if(opcode & 0x00100000) 1132 printf("mfocrf\tr%u,0x%02x\n", RS(opcode), 1133 (unsigned int)((opcode >> 12) & 0xff)); 1134 else 1135 printf("mfcr\tr%u\n", RT(opcode)); 1136 break; 1137 case 0x0000042e: 1138 if(RA(opcode) == 0) 1139 printf("lfsx\tf%u,0,r%u\n", RT(opcode), RB(opcode)); 1140 else 1141 printf("lfsx\tf%u,r%u,r%u\n", RT(opcode), RA(opcode), 1142 RB(opcode)); 1143 break; 1144 case 0x0000046e: 1145 fx_form("lfsux", opcode, 3); 1146 break; 1147 case 0x000004ae: 1148 if(RA(opcode) == 0) 1149 printf("lfdx\tf%u,0,r%u\n", RT(opcode), RB(opcode)); 1150 else 1151 printf("lfdx\tf%u,r%u,r%u\n", RT(opcode), RA(opcode), 1152 RB(opcode)); 1153 break; 1154 case 0x000004ee: 1155 fx_form("lfdux", opcode, 3); 1156 break; 1157 case 0x0000052e: 1158 if(RA(opcode) == 0) 1159 printf("stfsx\tf%u,0,r%u\n", RT(opcode), RB(opcode)); 1160 else 1161 printf("stfsx\tf%u,r%u,r%u\n", RT(opcode), RA(opcode), 1162 RB(opcode)); 1163 break; 1164 case 0x0000056e: 1165 fx_form("stfsux", opcode, 3); 1166 break; 1167 case 0x000005ae: 1168 if(RA(opcode) == 0) 1169 printf("stfdx\tf%u,0,r%u\n", RT(opcode), RB(opcode)); 1170 else 1171 printf("stfdx\tf%u,r%u,r%u\n", RT(opcode), RA(opcode), 1172 RB(opcode)); 1173 break; 1174 case 0x000007ae: 1175 if(RA(opcode) == 0) 1176 printf("stfiwx\tf%u,0,r%u\n", RT(opcode), RB(opcode)); 1177 else 1178 printf("stfiwx\tf%u,r%u,r%u\n", RT(opcode), RA(opcode), 1179 RB(opcode)); 1180 break; 1181 case 0x000005ee: 1182 fx_form("stfdux", opcode, 3); 1183 break; 1184 case 0x000007ac: 1185 if(RA(opcode) == 0) 1186 printf("icbi\t0,r%u\n", RB(opcode)); 1187 else 1188 printf("icbi\tr%u,r%u\n", RA(opcode), RB(opcode)); 1189 break; 1190 case 0x0000022c: 1191 if(RT(opcode) != 0){ 1192 if(RA(opcode) == 0) 1193 printf("dcbt\t0,r%u,0x%x\n", RB(opcode), 1194 (unsigned int)TH(opcode)); 1195 else 1196 printf("dcbt\tr%u,r%u,0x%x\n", RA(opcode), 1197 RB(opcode), (unsigned int)TH(opcode)); 1198 } 1199 else{ 1200 if(RA(opcode) == 0) 1201 printf("dcbt\t0,r%u\n", RB(opcode)); 1202 else 1203 printf("dcbt\tr%u,r%u\n", RA(opcode), RB(opcode)); 1204 } 1205 break; 1206 case 0x000001ec: 1207 if(RA(opcode) == 0) 1208 printf("dcbtst\t0,r%u\n", RB(opcode)); 1209 else 1210 printf("dcbtst\tr%u,r%u\n", RA(opcode), RB(opcode)); 1211 break; 1212 case 0x000007ec: 1213 if((opcode & 0x00200000) == 0x00200000){ 1214 if(RA(opcode) == 0) 1215 printf("dcbzl\t0,r%u\n", RB(opcode)); 1216 else 1217 printf("dcbzl\tr%u,r%u\n", RA(opcode), RB(opcode)); 1218 } 1219 else{ 1220 if(RA(opcode) == 0) 1221 printf("dcbz\t0,r%u\n", RB(opcode)); 1222 else 1223 printf("dcbz\tr%u,r%u\n", RA(opcode), RB(opcode)); 1224 } 1225 break; 1226 case 0x0000006c: 1227 if(RA(opcode) == 0) 1228 printf("dcbst\t0,r%u\n", RB(opcode)); 1229 else 1230 printf("dcbst\tr%u,r%u\n", RA(opcode), RB(opcode)); 1231 break; 1232 case 0x000000ac: 1233 if(RA(opcode) == 0) 1234 printf("dcbf\t0,r%u\n", RB(opcode)); 1235 else 1236 printf("dcbf\tr%u,r%u\n", RA(opcode), RB(opcode)); 1237 break; 1238 case 0x0000026c: 1239 if(RA(opcode) == 0) 1240 printf("eciwx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 1241 else 1242 printf("eciwx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 1243 RB(opcode)); 1244 break; 1245 case 0x0000036c: 1246 if(RA(opcode) == 0) 1247 printf("ecowx\tr%u,0,r%u\n", RT(opcode), RB(opcode)); 1248 else 1249 printf("ecowx\tr%u,r%u,r%u\n", RT(opcode), RA(opcode), 1250 RB(opcode)); 1251 break; 1252 case 0x000006ac: 1253 printf("eieio\n"); 1254 break; 1255 case 0x00000124: 1256 printf("mtmsr\tr%u\n", RS(opcode)); 1257 break; 1258 case 0x00000164: 1259 if((opcode & 0x00010000) == 0) 1260 printf("mtmsrd\tr%u\n", RS(opcode)); 1261 else 1262 printf("mtmsrd\tr%u,1\n", RS(opcode)); 1263 break; 1264 case 0x000000a6: 1265 printf("mfmsr\tr%u\n", RS(opcode)); 1266 break; 1267 case 0x000003ac: 1268 if(RA(opcode) == 0) 1269 printf("dcbi\t0,r%u\n", RB(opcode)); 1270 else 1271 printf("dcbi\tr%u,r%u\n", RA(opcode), RB(opcode)); 1272 break; 1273 case 0x000005ec: 1274 if(RA(opcode) == 0) 1275 printf("dcba\t0,r%u\n", RB(opcode)); 1276 else 1277 printf("dcba\tr%u,r%u\n", RA(opcode), RB(opcode)); 1278 break; 1279 case 0x000001a4: 1280 printf("mtsr\tsr%u,r%u\n", SR(opcode), RS(opcode)); 1281 break; 1282 case 0x000004a6: 1283 printf("mfsr\tr%u,sr%u\n", RT(opcode), SR(opcode)); 1284 break; 1285 case 0x000001e4: 1286 printf("mtsrin\tr%u,r%u\n", RS(opcode), RB(opcode)); 1287 break; 1288 case 0x00000526: 1289 printf("mfsrin\tr%u,r%u\n", RT(opcode), RB(opcode)); 1290 break; 1291 case 0x00000264: 1292 if((opcode & 0x00200000) == 0) 1293 printf("tlbie\tr%u\n", RB(opcode)); 1294 else 1295 printf("tlbie\tr%u,1\n", RB(opcode)); 1296 break; 1297 case 0x00000224: 1298 printf("tlbiel\tr%u\n", RB(opcode)); 1299 break; 1300 case 0x0000046c: 1301 printf("tlbsync\n"); 1302 break; 1303 case 0x000002e4: 1304 printf("tlbia\n"); 1305 break; 1306 case 0x000002e6: 1307 switch(opcode & 0x001ff800){ 1308 case 0x000c4000: 1309 printf("mftb\tr%u\n", RT(opcode)); 1310 break; 1311 case 0x000d4000: 1312 printf("mftbu\tr%u\n", RT(opcode)); 1313 break; 1314 default: 1315 printf("mftb\tr%u,%u\n", RT(opcode), 1316 ((opcode >> 16) & 0x1f) | ((opcode >> 6) & 0x3e0)); 1317 } 1318 break; 1319 case 0x00000210: 1320 case 0x00000610: 1321 xo_form("doz", opcode, 3); 1322 break; 1323 case 0x000002d0: 1324 case 0x000006d0: 1325 xo_form("abs", opcode, 2); 1326 break; 1327 case 0x000003d0: 1328 case 0x000007d0: 1329 xo_form("nabs", opcode, 2); 1330 break; 1331 case 0x000000d6: 1332 case 0x000004d6: 1333 xo_form("mul", opcode, 3); 1334 break; 1335 case 0x00000296: 1336 case 0x00000696: 1337 xo_form("div", opcode, 3); 1338 break; 1339 case 0x000002d6: 1340 case 0x000006d6: 1341 xo_form("divs", opcode, 3); 1342 break; 1343 case 0x00000432: 1344 sx_form("rrib", opcode, 3); 1345 break; 1346 case 0x0000003a: 1347 sx_form("maskg", opcode, 3); 1348 break; 1349 case 0x0000043a: 1350 sx_form("maskir", opcode, 3); 1351 break; 1352 case 0x00000130: 1353 sx_form("slq", opcode, 3); 1354 break; 1355 case 0x00000530: 1356 sx_form("srq", opcode, 3); 1357 break; 1358 case 0x00000170: 1359 printf("sliq%s\tr%u,r%u,%u\n", Rc(opcode), RA(opcode), 1360 RS(opcode), SH(opcode)); 1361 break; 1362 case 0x00000570: 1363 printf("sriq%s\tr%u,r%u,%u\n", Rc(opcode), RA(opcode), 1364 RS(opcode), SH(opcode)); 1365 break; 1366 case 0x000001f0: 1367 printf("slliq%s\tr%u,r%u,%u\n", Rc(opcode), RA(opcode), 1368 RS(opcode), SH(opcode)); 1369 break; 1370 case 0x000005f0: 1371 printf("srliq%s\tr%u,r%u,%u\n", Rc(opcode), RA(opcode), 1372 RS(opcode), SH(opcode)); 1373 break; 1374 case 0x000001b0: 1375 sx_form("sllq", opcode, 3); 1376 break; 1377 case 0x000005b0: 1378 sx_form("srlq", opcode, 3); 1379 break; 1380 case 0x00000132: 1381 sx_form("sle", opcode, 3); 1382 break; 1383 case 0x00000532: 1384 sx_form("sre", opcode, 3); 1385 break; 1386 case 0x000001b2: 1387 sx_form("sleq", opcode, 3); 1388 break; 1389 case 0x000005b2: 1390 sx_form("sreq", opcode, 3); 1391 break; 1392 case 0x00000770: 1393 printf("sraiq%s\tr%u,r%u,%u\n", Rc(opcode), RA(opcode), 1394 RS(opcode), SH(opcode)); 1395 break; 1396 case 0x00000730: 1397 sx_form("sraq", opcode, 3); 1398 break; 1399 case 0x00000732: 1400 sx_form("srea", opcode, 3); 1401 break; 1402 case 0x00000426: 1403 printf("clcs\tr%u,r%u\n", RT(opcode), RA(opcode)); 1404 break; 1405 case 0x000007a4: 1406 printf("tlbld\tr%u\n", RB(opcode)); 1407 break; 1408 case 0x000007e4: 1409 printf("tlbli\tr%u\n", RB(opcode)); 1410 break; 1411 case 0x00000364: 1412 printf("slbie\tr%u\n", RB(opcode)); 1413 break; 1414 case 0x000003e4: 1415 printf("slbia\n"); 1416 break; 1417 case 0x00000324: 1418 printf("slbmte\tr%u,r%u\n", RS(opcode), RB(opcode)); 1419 break; 1420 case 0x000006a6: 1421 printf("slbmfev\tr%u,r%u\n", RS(opcode), RB(opcode)); 1422 break; 1423 case 0x00000726: 1424 printf("slbmfee\tr%u,r%u\n", RS(opcode), RB(opcode)); 1425 break; 1426 case 0x0000000e: 1427 if(RA(opcode) == 0) 1428 printf("lvebx\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1429 else 1430 printf("lvebx\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1431 RB(opcode)); 1432 break; 1433 case 0x0000004e: 1434 if(RA(opcode) == 0) 1435 printf("lvehx\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1436 else 1437 printf("lvehx\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1438 RB(opcode)); 1439 break; 1440 case 0x0000008e: 1441 if(RA(opcode) == 0) 1442 printf("lvewx\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1443 else 1444 printf("lvewx\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1445 RB(opcode)); 1446 break; 1447 case 0x000000ce: 1448 if(RA(opcode) == 0) 1449 printf("lvx\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1450 else 1451 printf("lvx\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1452 RB(opcode)); 1453 break; 1454 case 0x000002ce: 1455 if(RA(opcode) == 0) 1456 printf("lvxl\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1457 else 1458 printf("lvxl\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1459 RB(opcode)); 1460 break; 1461 case 0x0000010e: 1462 if(RA(opcode) == 0) 1463 printf("stvebx\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1464 else 1465 printf("stvebx\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1466 RB(opcode)); 1467 break; 1468 case 0x0000014e: 1469 if(RA(opcode) == 0) 1470 printf("stvehx\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1471 else 1472 printf("stvehx\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1473 RB(opcode)); 1474 break; 1475 case 0x0000018e: 1476 if(RA(opcode) == 0) 1477 printf("stvewx\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1478 else 1479 printf("stvewx\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1480 RB(opcode)); 1481 break; 1482 case 0x000001ce: 1483 if(RA(opcode) == 0) 1484 printf("stvx\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1485 else 1486 printf("stvx\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1487 RB(opcode)); 1488 break; 1489 case 0x000003ce: 1490 if(RA(opcode) == 0) 1491 printf("stvxl\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1492 else 1493 printf("stvxl\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1494 RB(opcode)); 1495 break; 1496 case 0x0000000c: 1497 if(RA(opcode) == 0) 1498 printf("lvsl\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1499 else 1500 printf("lvsl\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1501 RB(opcode)); 1502 break; 1503 case 0x0000004c: 1504 if(RA(opcode) == 0) 1505 printf("lvsr\tv%u,0,r%u\n", VT(opcode), RB(opcode)); 1506 else 1507 printf("lvsr\tv%u,r%u,r%u\n", VT(opcode), RA(opcode), 1508 RB(opcode)); 1509 break; 1510 case 0x000002ac: 1511 if((opcode & (1 << 25)) == 0){ 1512 printf("dst\tr%u,r%u,%u\n", RA(opcode), RB(opcode), 1513 TAG(opcode)); 1514 } else { 1515 printf("dstt\tr%u,r%u,%u\n", RA(opcode), RB(opcode), 1516 TAG(opcode)); 1517 } 1518 break; 1519 case 0x000002ec: 1520 if((opcode & (1 << 25)) == 0){ 1521 printf("dstst\tr%u,r%u,%u\n", RA(opcode), RB(opcode), 1522 TAG(opcode)); 1523 } else { 1524 printf("dststt\tr%u,r%u,%u\n", RA(opcode),RB(opcode), 1525 TAG(opcode)); 1526 } 1527 break; 1528 case 0x0000066c: 1529 if((opcode & (1 << 25)) == 0) 1530 printf("dss\t%u\n", TAG(opcode)); 1531 else 1532 printf("dssall\n"); 1533 break; 1534 default: 1535 printf(".long 0x%08x\n", (unsigned int)opcode); 1536 break; 1537 } 1538 break; 1539 case 0x4c000000: 1540 switch(opcode & 0x000007fe){ 1541 case 0x00000000: 1542 printf("mcrf\tcr%u,cr%u\n", BF(opcode), BFA(opcode)); 1543 break; 1544 case 0x00000020: 1545 (void)bc("lr", opcode, sect_offset, relocs, nrelocs); 1546 printf("\n"); 1547 break; 1548 case 0x00000024: 1549 printf("rfid\n"); 1550 break; 1551 case 0x00000420: 1552 (void)bc("ctr", opcode, sect_offset, relocs, nrelocs); 1553 printf("\n"); 1554 break; 1555 case 0x00000202: 1556 xl_form("crand", opcode, 3); 1557 break; 1558 case 0x00000182: 1559 xl_form("crxor", opcode, 3); 1560 break; 1561 case 0x00000382: 1562 xl_form("cror", opcode, 3); 1563 break; 1564 case 0x000001c2: 1565 xl_form("crnand", opcode, 3); 1566 break; 1567 case 0x00000042: 1568 xl_form("crnor", opcode, 3); 1569 break; 1570 case 0x00000102: 1571 xl_form("crandc", opcode, 3); 1572 break; 1573 case 0x00000242: 1574 xl_form("creqv", opcode, 3); 1575 break; 1576 case 0x00000342: 1577 xl_form("crorc", opcode, 3); 1578 break; 1579 case 0x0000012c: 1580 printf("isync\n"); 1581 break; 1582 case 0x00000064: 1583 printf("rfi\n"); 1584 break; 1585 default: 1586 printf(".long 0x%08x\n", (unsigned int)opcode); 1587 break; 1588 } 1589 break; 1590 case 0x78000000: 1591 switch(opcode & 0x0000001e){ 1592 case 0x00000000: 1593 case 0x00000002: 1594 printf("rldicl%s\tr%u,r%u,%u,%u\n", Rc(opcode), RA(opcode), 1595 RS(opcode), ((opcode & 0x2) << 4) | SH(opcode), 1596 ((opcode & 0x20) | ((opcode >> 6) & 0x1f)) ); 1597 break; 1598 case 0x00000004: 1599 case 0x00000006: 1600 printf("rldicr%s\tr%u,r%u,%u,%u\n", Rc(opcode), RA(opcode), 1601 RS(opcode), ((opcode & 0x2) << 4) | SH(opcode), 1602 ((opcode & 0x20) | ((opcode >> 6) & 0x1f)) ); 1603 break; 1604 case 0x00000008: 1605 case 0x0000000a: 1606 printf("rldic%s\tr%u,r%u,%u,%u\n", Rc(opcode), RA(opcode), 1607 RS(opcode), ((opcode & 0x2) << 4) | SH(opcode), 1608 ((opcode & 0x20) | ((opcode >> 6) & 0x1f)) ); 1609 break; 1610 case 0x0000000c: 1611 case 0x0000000e: 1612 printf("rldimi%s\tr%u,r%u,%u,%u\n", Rc(opcode), RA(opcode), 1613 RS(opcode), ((opcode & 0x2) << 4) | SH(opcode), 1614 ((opcode & 0x20) | ((opcode >> 6) & 0x1f)) ); 1615 break; 1616 case 0x00000010: 1617 printf("rldcl%s\tr%u,r%u,r%u,%u\n", Rc(opcode), RA(opcode), 1618 RS(opcode), RB(opcode), 1619 ((opcode & 0x20) | ((opcode >> 6) & 0x1f)) ); 1620 break; 1621 case 0x00000012: 1622 printf("rldcr%s\tr%u,r%u,r%u,%u\n", Rc(opcode), RA(opcode), 1623 RS(opcode), RB(opcode), 1624 ((opcode & 0x20) | ((opcode >> 6) & 0x1f)) ); 1625 break; 1626 default: 1627 printf(".long 0x%08x\n", (unsigned int)opcode); 1628 break; 1629 } 1630 break; 1631 case 0x44000000: 1632 switch(opcode & 0x000007fe){ 1633 case 0x00000002: 1634 printf("sc\n"); 1635 break; 1636 default: 1637 printf(".long 0x%08x\n", (unsigned int)opcode); 1638 break; 1639 } 1640 break; 1641 case 0x54000000: 1642 printf("rlwinm%s\tr%u,r%u,%u,%u,%u\n", Rc(opcode), RA(opcode), 1643 RS(opcode), SH(opcode), MB(opcode), ME(opcode)); 1644 break; 1645 case 0x58000000: 1646 printf("rlmi%s\tr%u,r%u,r%u,%u,%u\n", Rc(opcode), RA(opcode), 1647 RS(opcode), RB(opcode), MB(opcode), ME(opcode)); 1648 break; 1649 case 0x5c000000: 1650 printf("rlwnm%s\tr%u,r%u,r%u,%u,%u\n", Rc(opcode), RA(opcode), 1651 RS(opcode), RB(opcode), MB(opcode), ME(opcode)); 1652 break; 1653 case 0x50000000: 1654 printf("rlwimi%s\tr%u,r%u,%u,%u,%u\n", Rc(opcode), RA(opcode), 1655 RS(opcode), SH(opcode), MB(opcode), ME(opcode)); 1656 break; 1657 case 0xfc000000: 1658 switch(opcode & 0x000007fe){ 1659 case 0x00000090: 1660 fx_form("fmr", opcode, 2); 1661 break; 1662 case 0x00000210: 1663 fx_form("fabs", opcode, 2); 1664 break; 1665 case 0x00000050: 1666 fx_form("fneg", opcode, 2); 1667 break; 1668 case 0x00000110: 1669 fx_form("fnabs", opcode, 2); 1670 break; 1671 case 0x00000018: 1672 fx_form("frsp", opcode, 2); 1673 break; 1674 case 0x00000034: 1675 fx_form("frsqrte", opcode, 2); 1676 break; 1677 case 0x0000002c: 1678 fx_form("fsqrt", opcode, 2); 1679 break; 1680 case 0x0000065c: 1681 fx_form("fctid", opcode, 2); 1682 break; 1683 case 0x0000065e: 1684 fx_form("fctidz", opcode, 2); 1685 break; 1686 case 0x0000001c: 1687 fx_form("fctiw", opcode, 2); 1688 break; 1689 case 0x0000001e: 1690 fx_form("fctiwz", opcode, 2); 1691 break; 1692 case 0x0000069c: 1693 fx_form("fcfid", opcode, 2); 1694 break; 1695 case 0x00000000: 1696 printf("fcmpu\tcr%u,f%u,f%u\n", BF(opcode), FRA(opcode), 1697 FRB(opcode)); 1698 break; 1699 case 0x00000040: 1700 printf("fcmpo\tcr%u,f%u,f%u\n", BF(opcode), FRA(opcode), 1701 FRB(opcode)); 1702 break; 1703 case 0x0000048e: 1704 printf("mffs%s\tf%u\n", Rc(opcode), FRT(opcode)); 1705 break; 1706 case 0x00000080: 1707 printf("mcrfs\tcr%u,%u\n", BF(opcode), BFA(opcode)); 1708 break; 1709 case 0x0000010c: 1710 printf("mtfsfi%s\t%u,%u\n", Rc(opcode), BF(opcode), 1711 U(opcode)); 1712 break; 1713 case 0x0000058e: 1714 printf("mtfsf%s\t%u,f%u\n", Rc(opcode), FLM(opcode), 1715 FRB(opcode)); 1716 break; 1717 case 0x0000008c: 1718 printf("mtfsb0%s\t%u\n", Rc(opcode), BT(opcode)); 1719 break; 1720 case 0x0000004c: 1721 printf("mtfsb1%s\t%u\n", Rc(opcode), BT(opcode)); 1722 break; 1723 default: 1724 switch(opcode & 0x0000003e){ 1725 case 0x0000002a: 1726 a_form("fadd", opcode, 3); 1727 break; 1728 case 0x00000028: 1729 a_form("fsub", opcode, 3); 1730 break; 1731 case 0x00000032: 1732 printf("fmul%s\tf%u,f%u,f%u\n", Rc(opcode), FRT(opcode), 1733 FRA(opcode), FRC(opcode)); 1734 break; 1735 case 0x0000002e: 1736 printf("fsel%s\tf%u,f%u,f%u,f%u\n", Rc(opcode), 1737 FRT(opcode), FRA(opcode), FRC(opcode), FRB(opcode)); 1738 break; 1739 case 0x00000024: 1740 a_form("fdiv", opcode, 3); 1741 break; 1742 case 0x0000003a: 1743 a_form("fmadd", opcode, 4); 1744 break; 1745 case 0x00000038: 1746 a_form("fmsub", opcode, 4); 1747 break; 1748 case 0x0000003e: 1749 a_form("fnmadd", opcode, 4); 1750 break; 1751 case 0x0000003c: 1752 a_form("fnmsub", opcode, 4); 1753 break; 1754 default: 1755 printf(".long 0x%08x\n", (unsigned int)opcode); 1756 break; 1757 } 1758 } 1759 break; 1760 case 0xec000000: 1761 switch(opcode & 0x0000003e){ 1762 case 0x0000002a: 1763 a_form("fadds", opcode, 3); 1764 break; 1765 case 0x00000028: 1766 a_form("fsubs", opcode, 3); 1767 break; 1768 case 0x00000030: 1769 printf("fres%s\tf%u,f%u\n", Rc(opcode), FRT(opcode), 1770 FRB(opcode)); 1771 break; 1772 case 0x0000002c: 1773 printf("fsqrts%s\tf%u,f%u\n", Rc(opcode), FRT(opcode), 1774 FRB(opcode)); 1775 break; 1776 case 0x00000032: 1777 printf("fmuls%s\tf%u,f%u,f%u\n", Rc(opcode), FRT(opcode), 1778 FRA(opcode), FRC(opcode)); 1779 break; 1780 case 0x00000024: 1781 a_form("fdivs", opcode, 3); 1782 break; 1783 case 0x0000003a: 1784 a_form("fmadds", opcode, 4); 1785 break; 1786 case 0x00000038: 1787 a_form("fmsubs", opcode, 4); 1788 break; 1789 case 0x0000003e: 1790 a_form("fnmadds", opcode, 4); 1791 break; 1792 case 0x0000003c: 1793 a_form("fnmsubs", opcode, 4); 1794 break; 1795 default: 1796 printf(".long 0x%08x\n", (unsigned int)opcode); 1797 break; 1798 } 1799 break; 1800 case 0x10000000: 1801 if((opcode & (1 << 5)) == 0){ 1802 if((opcode & 0x31) != 0){ 1803 printf(".long 0x%08x\n", (unsigned int)opcode); 1804 break; 1805 } 1806 switch((opcode >> 1) & 0x7){ 1807 case 0: 1808 switch(opcode & 0x7c0){ 1809 case 0x00000000: 1810 printf("vaddubm\tv%u,v%u,v%u\n", VT(opcode), 1811 VA(opcode), VB(opcode)); 1812 break; 1813 case 0x00000040: 1814 printf("vadduhm\tv%u,v%u,v%u\n", VT(opcode), 1815 VA(opcode), VB(opcode)); 1816 break; 1817 case 0x00000080: 1818 printf("vadduwm\tv%u,v%u,v%u\n", VT(opcode), 1819 VA(opcode), VB(opcode)); 1820 break; 1821 case 0x00000180: 1822 printf("vaddcuw\tv%u,v%u,v%u\n", VT(opcode), 1823 VA(opcode), VB(opcode)); 1824 break; 1825 case 0x00000200: 1826 printf("vaddubs\tv%u,v%u,v%u\n", VT(opcode), 1827 VA(opcode), VB(opcode)); 1828 break; 1829 case 0x00000240: 1830 printf("vadduhs\tv%u,v%u,v%u\n", VT(opcode), 1831 VA(opcode), VB(opcode)); 1832 break; 1833 case 0x00000280: 1834 printf("vadduws\tv%u,v%u,v%u\n", VT(opcode), 1835 VA(opcode), VB(opcode)); 1836 break; 1837 case 0x00000300: 1838 printf("vaddsbs\tv%u,v%u,v%u\n", VT(opcode), 1839 VA(opcode), VB(opcode)); 1840 break; 1841 case 0x00000340: 1842 printf("vaddshs\tv%u,v%u,v%u\n", VT(opcode), 1843 VA(opcode), VB(opcode)); 1844 break; 1845 case 0x00000380: 1846 printf("vaddsws\tv%u,v%u,v%u\n", VT(opcode), 1847 VA(opcode), VB(opcode)); 1848 break; 1849 case 0x00000400: 1850 printf("vsububm\tv%u,v%u,v%u\n", VT(opcode), 1851 VA(opcode), VB(opcode)); 1852 break; 1853 case 0x00000440: 1854 printf("vsubuhm\tv%u,v%u,v%u\n", VT(opcode), 1855 VA(opcode), VB(opcode)); 1856 break; 1857 case 0x00000480: 1858 printf("vsubuwm\tv%u,v%u,v%u\n", VT(opcode), 1859 VA(opcode), VB(opcode)); 1860 break; 1861 case 0x00000580: 1862 printf("vsubcuw\tv%u,v%u,v%u\n", VT(opcode), 1863 VA(opcode), VB(opcode)); 1864 break; 1865 case 0x00000600: 1866 printf("vsububs\tv%u,v%u,v%u\n", VT(opcode), 1867 VA(opcode), VB(opcode)); 1868 break; 1869 case 0x00000640: 1870 printf("vsubuhs\tv%u,v%u,v%u\n", VT(opcode), 1871 VA(opcode), VB(opcode)); 1872 break; 1873 case 0x00000680: 1874 printf("vsubuws\tv%u,v%u,v%u\n", VT(opcode), 1875 VA(opcode), VB(opcode)); 1876 break; 1877 case 0x00000700: 1878 printf("vsubsbs\tv%u,v%u,v%u\n", VT(opcode), 1879 VA(opcode), VB(opcode)); 1880 break; 1881 case 0x00000740: 1882 printf("vsubshs\tv%u,v%u,v%u\n", VT(opcode), 1883 VA(opcode), VB(opcode)); 1884 break; 1885 case 0x00000780: 1886 printf("vsubsws\tv%u,v%u,v%u\n", VT(opcode), 1887 VA(opcode), VB(opcode)); 1888 break; 1889 default: 1890 printf(".long 0x%08x\n", (unsigned int)opcode); 1891 break; 1892 } 1893 break; 1894 case 1: 1895 switch(opcode & 0x7c0){ 1896 case 0x00000000: 1897 printf("vmaxub\tv%u,v%u,v%u\n", VT(opcode), 1898 VA(opcode), VB(opcode)); 1899 break; 1900 case 0x00000040: 1901 printf("vmaxuh\tv%u,v%u,v%u\n", VT(opcode), 1902 VA(opcode), VB(opcode)); 1903 break; 1904 case 0x00000080: 1905 printf("vmaxuw\tv%u,v%u,v%u\n", VT(opcode), 1906 VA(opcode), VB(opcode)); 1907 break; 1908 case 0x00000100: 1909 printf("vmaxsb\tv%u,v%u,v%u\n", VT(opcode), 1910 VA(opcode), VB(opcode)); 1911 break; 1912 case 0x00000140: 1913 printf("vmaxsh\tv%u,v%u,v%u\n", VT(opcode), 1914 VA(opcode), VB(opcode)); 1915 break; 1916 case 0x00000180: 1917 printf("vmaxsw\tv%u,v%u,v%u\n", VT(opcode), 1918 VA(opcode), VB(opcode)); 1919 break; 1920 case 0x00000200: 1921 printf("vminub\tv%u,v%u,v%u\n", VT(opcode), 1922 VA(opcode), VB(opcode)); 1923 break; 1924 case 0x00000240: 1925 printf("vminuh\tv%u,v%u,v%u\n", VT(opcode), 1926 VA(opcode), VB(opcode)); 1927 break; 1928 case 0x00000280: 1929 printf("vminuw\tv%u,v%u,v%u\n", VT(opcode), 1930 VA(opcode), VB(opcode)); 1931 break; 1932 case 0x00000300: 1933 printf("vminsb\tv%u,v%u,v%u\n", VT(opcode), 1934 VA(opcode), VB(opcode)); 1935 break; 1936 case 0x00000340: 1937 printf("vminsh\tv%u,v%u,v%u\n", VT(opcode), 1938 VA(opcode), VB(opcode)); 1939 break; 1940 case 0x00000380: 1941 printf("vminsw\tv%u,v%u,v%u\n", VT(opcode), 1942 VA(opcode), VB(opcode)); 1943 break; 1944 case 0x00000400: 1945 printf("vavgub\tv%u,v%u,v%u\n", VT(opcode), 1946 VA(opcode), VB(opcode)); 1947 break; 1948 case 0x00000440: 1949 printf("vavguh\tv%u,v%u,v%u\n", VT(opcode), 1950 VA(opcode), VB(opcode)); 1951 break; 1952 case 0x00000480: 1953 printf("vavguw\tv%u,v%u,v%u\n", VT(opcode), 1954 VA(opcode), VB(opcode)); 1955 break; 1956 case 0x00000500: 1957 printf("vavgsb\tv%u,v%u,v%u\n", VT(opcode), 1958 VA(opcode), VB(opcode)); 1959 break; 1960 case 0x00000540: 1961 printf("vavgsh\tv%u,v%u,v%u\n", VT(opcode), 1962 VA(opcode), VB(opcode)); 1963 break; 1964 case 0x00000580: 1965 printf("vavgsw\tv%u,v%u,v%u\n", VT(opcode), 1966 VA(opcode), VB(opcode)); 1967 break; 1968 default: 1969 printf(".long 0x%08x\n", (unsigned int)opcode); 1970 break; 1971 } 1972 break; 1973 case 2: 1974 switch(opcode & 0x7c0){ 1975 case 0x00000000: 1976 printf("vrlb\tv%u,v%u,v%u\n", VT(opcode), 1977 VA(opcode), VB(opcode)); 1978 break; 1979 case 0x00000040: 1980 printf("vrlh\tv%u,v%u,v%u\n", VT(opcode), 1981 VA(opcode), VB(opcode)); 1982 break; 1983 case 0x00000080: 1984 printf("vrlw\tv%u,v%u,v%u\n", VT(opcode), 1985 VA(opcode), VB(opcode)); 1986 break; 1987 case 0x00000100: 1988 printf("vslb\tv%u,v%u,v%u\n", VT(opcode), 1989 VA(opcode), VB(opcode)); 1990 break; 1991 case 0x00000140: 1992 printf("vslh\tv%u,v%u,v%u\n", VT(opcode), 1993 VA(opcode), VB(opcode)); 1994 break; 1995 case 0x00000180: 1996 printf("vslw\tv%u,v%u,v%u\n", VT(opcode), 1997 VA(opcode), VB(opcode)); 1998 break; 1999 case 0x000001c0: 2000 printf("vsl\tv%u,v%u,v%u\n", VT(opcode), 2001 VA(opcode), VB(opcode)); 2002 break; 2003 case 0x00000200: 2004 printf("vsrb\tv%u,v%u,v%u\n", VT(opcode), 2005 VA(opcode), VB(opcode)); 2006 break; 2007 case 0x00000240: 2008 printf("vsrh\tv%u,v%u,v%u\n", VT(opcode), 2009 VA(opcode), VB(opcode)); 2010 break; 2011 case 0x00000280: 2012 printf("vsrw\tv%u,v%u,v%u\n", VT(opcode), 2013 VA(opcode), VB(opcode)); 2014 break; 2015 case 0x000002c0: 2016 printf("vsr\tv%u,v%u,v%u\n", VT(opcode), 2017 VA(opcode), VB(opcode)); 2018 break; 2019 case 0x00000300: 2020 printf("vsrab\tv%u,v%u,v%u\n", VT(opcode), 2021 VA(opcode), VB(opcode)); 2022 break; 2023 case 0x00000340: 2024 printf("vsrah\tv%u,v%u,v%u\n", VT(opcode), 2025 VA(opcode), VB(opcode)); 2026 break; 2027 case 0x00000380: 2028 printf("vsraw\tv%u,v%u,v%u\n", VT(opcode), 2029 VA(opcode), VB(opcode)); 2030 break; 2031 case 0x00000400: 2032 printf("vand\tv%u,v%u,v%u\n", VT(opcode), 2033 VA(opcode), VB(opcode)); 2034 break; 2035 case 0x00000440: 2036 printf("vandc\tv%u,v%u,v%u\n", VT(opcode), 2037 VA(opcode), VB(opcode)); 2038 break; 2039 case 0x00000480: 2040 printf("vor\tv%u,v%u,v%u\n", VT(opcode), 2041 VA(opcode), VB(opcode)); 2042 break; 2043 case 0x000004c0: 2044 printf("vxor\tv%u,v%u,v%u\n", VT(opcode), 2045 VA(opcode), VB(opcode)); 2046 break; 2047 case 0x00000500: 2048 printf("vnor\tv%u,v%u,v%u\n", VT(opcode), 2049 VA(opcode), VB(opcode)); 2050 break; 2051 case 0x00000600: 2052 printf("mfvscr\tv%u\n", VT(opcode)); 2053 break; 2054 case 0x00000640: 2055 printf("mtvscr\tv%u\n", VB(opcode)); 2056 break; 2057 default: 2058 printf(".long 0x%08x\n", (unsigned int)opcode); 2059 break; 2060 } 2061 break; 2062 case 3: 2063 switch(opcode & 0x3c0){ 2064 case 0x00000000: 2065 printf("vcmpequb%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2066 VT(opcode), VA(opcode), VB(opcode)); 2067 break; 2068 case 0x00000040: 2069 printf("vcmpequh%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2070 VT(opcode), VA(opcode), VB(opcode)); 2071 break; 2072 case 0x00000080: 2073 printf("vcmpequw%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2074 VT(opcode), VA(opcode), VB(opcode)); 2075 break; 2076 case 0x000000c0: 2077 printf("vcmpeqfp%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2078 VT(opcode), VA(opcode), VB(opcode)); 2079 break; 2080 case 0x000001c0: 2081 printf("vcmpgefp%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2082 VT(opcode), VA(opcode), VB(opcode)); 2083 break; 2084 case 0x00000200: 2085 printf("vcmpgtub%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2086 VT(opcode), VA(opcode), VB(opcode)); 2087 break; 2088 case 0x00000240: 2089 printf("vcmpgtuh%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2090 VT(opcode), VA(opcode), VB(opcode)); 2091 break; 2092 case 0x00000280: 2093 printf("vcmpgtuw%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2094 VT(opcode), VA(opcode), VB(opcode)); 2095 break; 2096 case 0x000002c0: 2097 printf("vcmpgtfp%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2098 VT(opcode), VA(opcode), VB(opcode)); 2099 break; 2100 case 0x00000300: 2101 printf("vcmpgtsb%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2102 VT(opcode), VA(opcode), VB(opcode)); 2103 break; 2104 case 0x00000340: 2105 printf("vcmpgtsh%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2106 VT(opcode), VA(opcode), VB(opcode)); 2107 break; 2108 case 0x00000380: 2109 printf("vcmpgtsw%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2110 VT(opcode), VA(opcode), VB(opcode)); 2111 break; 2112 case 0x000003c0: 2113 printf("vcmpbfp%s\tv%u,v%u,v%u\n", VX_Rc(opcode), 2114 VT(opcode), VA(opcode), VB(opcode)); 2115 break; 2116 default: 2117 printf(".long 0x%08x\n", (unsigned int)opcode); 2118 break; 2119 } 2120 break; 2121 case 4: 2122 switch(opcode & 0x7c0){ 2123 case 0x00000000: 2124 printf("vmuloub\tv%u,v%u,v%u\n", VT(opcode), 2125 VA(opcode), VB(opcode)); 2126 break; 2127 case 0x00000040: 2128 printf("vmulouh\tv%u,v%u,v%u\n", VT(opcode), 2129 VA(opcode), VB(opcode)); 2130 break; 2131 case 0x00000100: 2132 printf("vmulosb\tv%u,v%u,v%u\n", VT(opcode), 2133 VA(opcode), VB(opcode)); 2134 break; 2135 case 0x00000140: 2136 printf("vmulosh\tv%u,v%u,v%u\n", VT(opcode), 2137 VA(opcode), VB(opcode)); 2138 break; 2139 case 0x00000200: 2140 printf("vmuleub\tv%u,v%u,v%u\n", VT(opcode), 2141 VA(opcode), VB(opcode)); 2142 break; 2143 case 0x00000240: 2144 printf("vmuleuh\tv%u,v%u,v%u\n", VT(opcode), 2145 VA(opcode), VB(opcode)); 2146 break; 2147 case 0x00000300: 2148 printf("vmulesb\tv%u,v%u,v%u\n", VT(opcode), 2149 VA(opcode), VB(opcode)); 2150 break; 2151 case 0x00000340: 2152 printf("vmulesh\tv%u,v%u,v%u\n", VT(opcode), 2153 VA(opcode), VB(opcode)); 2154 break; 2155 case 0x00000600: 2156 printf("vsum4ubs\tv%u,v%u,v%u\n", VT(opcode), 2157 VA(opcode), VB(opcode)); 2158 break; 2159 case 0x00000700: 2160 printf("vsum4sbs\tv%u,v%u,v%u\n", VT(opcode), 2161 VA(opcode), VB(opcode)); 2162 break; 2163 case 0x00000640: 2164 printf("vsum4shs\tv%u,v%u,v%u\n", VT(opcode), 2165 VA(opcode), VB(opcode)); 2166 break; 2167 case 0x00000680: 2168 printf("vsum2sws\tv%u,v%u,v%u\n", VT(opcode), 2169 VA(opcode), VB(opcode)); 2170 break; 2171 case 0x00000780: 2172 printf("vsumsws\tv%u,v%u,v%u\n", VT(opcode), 2173 VA(opcode), VB(opcode)); 2174 break; 2175 default: 2176 printf(".long 0x%08x\n", (unsigned int)opcode); 2177 break; 2178 } 2179 break; 2180 case 5: 2181 switch((opcode >> 6) & 0x1f){ 2182 case 0: 2183 printf("vaddfp\tv%u,v%u,v%u\n", VT(opcode), 2184 VA(opcode), VB(opcode)); 2185 break; 2186 case 1: 2187 printf("vsubfp\tv%u,v%u,v%u\n", VT(opcode), 2188 VA(opcode), VB(opcode)); 2189 break; 2190 case 4: 2191 printf("vrefp\tv%u,v%u\n", VT(opcode), VB(opcode)); 2192 break; 2193 case 5: 2194 printf("vrsqrtefp\tv%u,v%u\n",VT(opcode), VB(opcode)); 2195 break; 2196 case 6: 2197 printf("vexptefp\tv%u,v%u\n", VT(opcode), VB(opcode)); 2198 break; 2199 case 7: 2200 printf("vlogefp\tv%u,v%u\n", VT(opcode), VB(opcode)); 2201 break; 2202 case 8: 2203 printf("vrfin\tv%u,v%u\n", VT(opcode), VB(opcode)); 2204 break; 2205 case 9: 2206 printf("vrfiz\tv%u,v%u\n", VT(opcode), VB(opcode)); 2207 break; 2208 case 10: 2209 printf("vrfip\tv%u,v%u\n", VT(opcode), VB(opcode)); 2210 break; 2211 case 11: 2212 printf("vrfim\tv%u,v%u\n", VT(opcode), VB(opcode)); 2213 break; 2214 case 12: 2215 printf("vcfux\tv%u,v%u,%u\n", VT(opcode), 2216 VB(opcode), (opcode >> 16) & 0x1f); 2217 break; 2218 case 13: 2219 printf("vcfsx\tv%u,v%u,%u\n", VT(opcode), 2220 VB(opcode), (opcode >> 16) & 0x1f); 2221 break; 2222 case 14: 2223 printf("vctuxs\tv%u,v%u,%u\n", VT(opcode), 2224 VB(opcode), (opcode >> 16) & 0x1f); 2225 break; 2226 case 15: 2227 printf("vctsxs\tv%u,v%u,%u\n", VT(opcode), 2228 VB(opcode), (opcode >> 16) & 0x1f); 2229 break; 2230 case 16: 2231 printf("vmaxfp\tv%u,v%u,v%u\n", VT(opcode), 2232 VA(opcode), VB(opcode)); 2233 break; 2234 case 17: 2235 printf("vminfp\tv%u,v%u,v%u\n", VT(opcode), 2236 VA(opcode), VB(opcode)); 2237 break; 2238 default: 2239 printf(".long 0x%08x\n", (unsigned int)opcode); 2240 break; 2241 } 2242 break; 2243 case 6: 2244 switch(opcode & 0x7c0){ 2245 case 0x00000000: 2246 printf("vmrghb\tv%u,v%u,v%u\n", VT(opcode), 2247 VA(opcode), VB(opcode)); 2248 break; 2249 case 0x00000040: 2250 printf("vmrghh\tv%u,v%u,v%u\n", VT(opcode), 2251 VA(opcode), VB(opcode)); 2252 break; 2253 case 0x00000080: 2254 printf("vmrghw\tv%u,v%u,v%u\n", VT(opcode), 2255 VA(opcode), VB(opcode)); 2256 break; 2257 case 0x00000100: 2258 printf("vmrglb\tv%u,v%u,v%u\n", VT(opcode), 2259 VA(opcode), VB(opcode)); 2260 break; 2261 case 0x00000140: 2262 printf("vmrglh\tv%u,v%u,v%u\n", VT(opcode), 2263 VA(opcode), VB(opcode)); 2264 break; 2265 case 0x00000180: 2266 printf("vmrglw\tv%u,v%u,v%u\n", VT(opcode), 2267 VA(opcode), VB(opcode)); 2268 break; 2269 case 0x00000200: 2270 printf("vspltb\tv%u,v%u,%u\n", VT(opcode), 2271 VB(opcode), (opcode >> 16) & 0x1f); 2272 break; 2273 case 0x00000240: 2274 printf("vsplth\tv%u,v%u,%u\n", VT(opcode), 2275 VB(opcode), (opcode >> 16) & 0x1f); 2276 break; 2277 case 0x00000280: 2278 printf("vspltw\tv%u,v%u,%u\n", VT(opcode), 2279 VB(opcode), (opcode >> 16) & 0x1f); 2280 break; 2281 case 0x00000300: 2282 if((((opcode >> 16) & 0x1f) & 0x10) == 0x10) 2283 simm = 0xfffffff0 | ((opcode >> 16) & 0x1f); 2284 else 2285 simm = (opcode >> 16) & 0x1f; 2286 printf("vspltisb\tv%u,%d\n", VT(opcode), simm); 2287 break; 2288 case 0x00000340: 2289 if((((opcode >> 16) & 0x1f) & 0x10) == 0x10) 2290 simm = 0xfffffff0 | ((opcode >> 16) & 0x1f); 2291 else 2292 simm = (opcode >> 16) & 0x1f; 2293 printf("vspltish\tv%u,%d\n", VT(opcode), simm); 2294 break; 2295 case 0x00000380: 2296 if((((opcode >> 16) & 0x1f) & 0x10) == 0x10) 2297 simm = 0xfffffff0 | ((opcode >> 16) & 0x1f); 2298 else 2299 simm = (opcode >> 16) & 0x1f; 2300 printf("vspltisw\tv%u,%d\n", VT(opcode), simm); 2301 break; 2302 case 0x00000400: 2303 printf("vslo\tv%u,v%u,v%u\n", VT(opcode), 2304 VA(opcode), VB(opcode)); 2305 break; 2306 case 0x00000440: 2307 printf("vsro\tv%u,v%u,v%u\n", VT(opcode), 2308 VA(opcode), VB(opcode)); 2309 break; 2310 default: 2311 printf(".long 0x%08x\n", (unsigned int)opcode); 2312 break; 2313 } 2314 break; 2315 case 7: 2316 switch((opcode >> 6) & 0x1f){ 2317 case 0: 2318 printf("vpkuhum\tv%u,v%u,v%u\n", VT(opcode), 2319 VA(opcode), VB(opcode)); 2320 break; 2321 case 1: 2322 printf("vpkuwum\tv%u,v%u,v%u\n", VT(opcode), 2323 VA(opcode), VB(opcode)); 2324 break; 2325 case 2: 2326 printf("vpkuhus\tv%u,v%u,v%u\n", VT(opcode), 2327 VA(opcode), VB(opcode)); 2328 break; 2329 case 3: 2330 printf("vpkuwus\tv%u,v%u,v%u\n", VT(opcode), 2331 VA(opcode), VB(opcode)); 2332 break; 2333 case 4: 2334 printf("vpkshus\tv%u,v%u,v%u\n", VT(opcode), 2335 VA(opcode), VB(opcode)); 2336 break; 2337 case 5: 2338 printf("vpkswus\tv%u,v%u,v%u\n", VT(opcode), 2339 VA(opcode), VB(opcode)); 2340 break; 2341 case 6: 2342 printf("vpkshss\tv%u,v%u,v%u\n", VT(opcode), 2343 VA(opcode), VB(opcode)); 2344 break; 2345 case 7: 2346 printf("vpkswss\tv%u,v%u,v%u\n", VT(opcode), 2347 VA(opcode), VB(opcode)); 2348 break; 2349 case 8: 2350 printf("vupkhsb\tv%u,v%u\n", VT(opcode), 2351 VB(opcode)); 2352 break; 2353 case 9: 2354 printf("vupkhsh\tv%u,v%u\n", VT(opcode), 2355 VB(opcode)); 2356 break; 2357 case 10: 2358 printf("vupklsb\tv%u,v%u\n", VT(opcode), 2359 VB(opcode)); 2360 break; 2361 case 11: 2362 printf("vupklsh\tv%u,v%u\n", VT(opcode), 2363 VB(opcode)); 2364 break; 2365 case 12: 2366 printf("vpkpx\tv%u,v%u,v%u\n", VT(opcode), 2367 VA(opcode), VB(opcode)); 2368 break; 2369 case 13: 2370 printf("vupkhpx\tv%u,v%u\n", VT(opcode), 2371 VB(opcode)); 2372 break; 2373 case 15: 2374 printf("vupklpx\tv%u,v%u\n", VT(opcode), 2375 VB(opcode)); 2376 break; 2377 default: 2378 printf(".long 0x%08x\n", (unsigned int)opcode); 2379 break; 2380 } 2381 break; 2382 default: 2383 printf(".long 0x%08x\n", (unsigned int)opcode); 2384 break; 2385 } 2386 } 2387 else{ 2388 switch(opcode & 0xf){ 2389 case 0: 2390 printf("vmhaddshs\tv%u,v%u,v%u,v%u\n", VT(opcode), 2391 VA(opcode), VB(opcode), VC(opcode)); 2392 break; 2393 case 1: 2394 printf("vmhraddshs\tv%u,v%u,v%u,v%u\n", VT(opcode), 2395 VA(opcode), VB(opcode), VC(opcode)); 2396 break; 2397 case 2: 2398 printf("vmladduhm\tv%u,v%u,v%u,v%u\n", VT(opcode), 2399 VA(opcode), VB(opcode), VC(opcode)); 2400 break; 2401 case 4: 2402 printf("vmsumubm\tv%u,v%u,v%u,v%u\n", VT(opcode), 2403 VA(opcode), VB(opcode), VC(opcode)); 2404 break; 2405 case 5: 2406 printf("vmsummbm\tv%u,v%u,v%u,v%u\n", VT(opcode), 2407 VA(opcode), VB(opcode), VC(opcode)); 2408 break; 2409 case 6: 2410 printf("vmsumuhm\tv%u,v%u,v%u,v%u\n", VT(opcode), 2411 VA(opcode), VB(opcode), VC(opcode)); 2412 break; 2413 case 7: 2414 printf("vmsumuhs\tv%u,v%u,v%u,v%u\n", VT(opcode), 2415 VA(opcode), VB(opcode), VC(opcode)); 2416 break; 2417 case 8: 2418 printf("vmsumshm\tv%u,v%u,v%u,v%u\n", VT(opcode), 2419 VA(opcode), VB(opcode), VC(opcode)); 2420 break; 2421 case 9: 2422 printf("vmsumshs\tv%u,v%u,v%u,v%u\n", VT(opcode), 2423 VA(opcode), VB(opcode), VC(opcode)); 2424 break; 2425 case 10: 2426 printf("vsel\tv%u,v%u,v%u,v%u\n", VT(opcode), 2427 VA(opcode), VB(opcode), VC(opcode)); 2428 break; 2429 case 11: 2430 printf("vperm\tv%u,v%u,v%u,v%u\n", VT(opcode), 2431 VA(opcode), VB(opcode), VC(opcode)); 2432 break; 2433 case 12: 2434 printf("vsldoi\tv%u,v%u,v%u,%u\n", VT(opcode), 2435 VA(opcode), VB(opcode), (opcode >> 6) & 0xf); 2436 break; 2437 case 14: 2438 printf("vmaddfp\tv%u,v%u,v%u,v%u\n", VT(opcode), 2439 VA(opcode), VC(opcode), VB(opcode)); 2440 break; 2441 case 15: 2442 printf("vnmsubfp\tv%u,v%u,v%u,v%u\n", VT(opcode), 2443 VA(opcode), VC(opcode), VB(opcode)); 2444 break; 2445 default: 2446 printf(".long 0x%08x\n", (unsigned int)opcode); 2447 break; 2448 } 2449 } 2450 break; 2451 default: 2452 printf(".long 0x%08x\n", (unsigned int)opcode); 2453 break; 2454 } 2455 return(4); 2456} 2457 2458static 2459void 2460xo_form( 2461const char *name, 2462uint32_t opcode, 2463uint32_t nregs) 2464{ 2465 if(nregs == 3) 2466 printf("%s%s\tr%u,r%u,r%u\n", name, OE_Rc(opcode), RT(opcode), 2467 RA(opcode), RB(opcode)); 2468 else /* nregs == 2 */ 2469 printf("%s%s\tr%u,r%u\n", name, OE_Rc(opcode), RT(opcode), 2470 RA(opcode)); 2471} 2472 2473static 2474void 2475x_form( 2476const char *name, 2477uint32_t opcode, 2478uint32_t nregs) 2479{ 2480 if(nregs == 3) 2481 printf("%s%s\tr%u,r%u,r%u\n", name, Rc(opcode), RT(opcode), 2482 RA(opcode), RB(opcode)); 2483 else /* nregs == 2 */ 2484 printf("%s%s\tr%u,r%u\n", name, Rc(opcode), RT(opcode), 2485 RA(opcode)); 2486} 2487 2488static 2489void 2490sx_form( 2491const char *name, 2492uint32_t opcode, 2493uint32_t nregs) 2494{ 2495 if(nregs == 3) 2496 printf("%s%s\tr%u,r%u,r%u\n", name, Rc(opcode), RA(opcode), 2497 RS(opcode), RB(opcode)); 2498 else /* nregs == 2 */ 2499 printf("%s%s\tr%u,r%u\n", name, Rc(opcode), RA(opcode), 2500 RS(opcode)); 2501} 2502 2503static 2504void 2505fx_form( 2506const char *name, 2507uint32_t opcode, 2508uint32_t nregs) 2509{ 2510 if(nregs == 3) 2511 printf("%s\tf%u,r%u,r%u\n", name, FRT(opcode), 2512 RA(opcode), RB(opcode)); 2513 else /* nregs == 2 */ 2514 printf("%s%s\tf%u,f%u\n", name, Rc(opcode), FRT(opcode), 2515 FRB(opcode)); 2516} 2517 2518static 2519void 2520xl_form( 2521const char *name, 2522uint32_t opcode, 2523uint32_t nregs) 2524{ 2525 if(nregs == 3) 2526 printf("%s%s\t%u,%u,%u\n", name, LK(opcode), RT(opcode), 2527 RA(opcode), RB(opcode)); 2528 else /* nregs == 2 */ 2529 printf("%s%s\t%u,%u\n", name, LK(opcode), RT(opcode), 2530 RA(opcode)); 2531} 2532 2533static 2534void 2535a_form( 2536const char *name, 2537uint32_t opcode, 2538uint32_t nregs) 2539{ 2540 if(nregs == 3) 2541 printf("%s%s\tf%u,f%u,f%u\n", name, Rc(opcode), FRT(opcode), 2542 FRA(opcode), FRB(opcode)); 2543 else /* nregs == 4 */ 2544 printf("%s%s\tf%u,f%u,f%u,f%u\n", name, Rc(opcode), FRT(opcode), 2545 FRA(opcode), FRC(opcode), FRB(opcode)); 2546} 2547 2548static 2549uint32_t 2550bc( 2551const char *name, 2552uint32_t opcode, 2553uint32_t sect_offset, 2554struct relocation_info *relocs, 2555uint32_t nrelocs) 2556{ 2557 char *prediction; 2558 const char *a; 2559 uint32_t operands; 2560 enum bool branch_to_register, predicted; 2561 2562 operands = 0; 2563 prediction = ""; 2564 /* 2565 * For branch conditional instructions that use the Y-bit that were 2566 * predicted the r_length is set to 3 instead of 2. So to correctly 2567 * print the prediction, we have to search for a reloc of and look at 2568 * the r_length. If there is a reloc at this pc, and if the r_length 2569 * is 3 it then we know it was a predicted branch and we will always 2570 * print the prediction based on the Y-bit, the sign of the displacement 2571 * or the opcode (in the case of bclrX and bcctrX instructions). 2572 */ 2573 if(get_reloc_r_length(sect_offset, relocs, nrelocs) == 3) 2574 predicted = TRUE; 2575 else 2576 predicted = FALSE; 2577 /* branch conditional (to displacment) */ 2578 if((opcode & 0xfc000000) == 0x40000000){ 2579 branch_to_register = FALSE; 2580 a = aa[(opcode >> 1) & 0x1]; 2581 if(Y_BIT(opcode) == 0){ 2582 /* 2583 * the Y-bit is zero so don't print prediction unless there was 2584 * a reloc that said this was a predicted branch. 2585 */ 2586 if(predicted == TRUE){ 2587 if((opcode & 0x00008000) != 0) 2588 prediction = "+"; 2589 else 2590 prediction = "-"; 2591 } 2592 else{ 2593 prediction = ""; 2594 } 2595 } 2596 else{ 2597 if((opcode & 0x00008000) != 0) 2598 prediction = "-"; 2599 else 2600 prediction = "+"; 2601 } 2602 } 2603 else{ 2604 /* branch conditional (to link or count register) */ 2605 branch_to_register = TRUE; 2606 a = ""; 2607 if(Y_BIT(opcode) == 0){ 2608 /* the Y-bit is zero so don't print prediction */ 2609 prediction = ""; 2610 /* 2611 * the Y-bit is zero so don't print prediction unless there was 2612 * a reloc that said this was a predicted branch. 2613 */ 2614 if(predicted == TRUE){ 2615 prediction = "-"; 2616 } 2617 else{ 2618 prediction = ""; 2619 } 2620 } 2621 else{ 2622 prediction = "+"; 2623 } 2624 } 2625 if(Zflag == TRUE){ 2626 if(branch_to_register == TRUE){ 2627 printf("bc%s%s%s\t%u,%u,%u", name, LK(opcode), a, RT(opcode), 2628 RA(opcode), BH(opcode)); 2629 operands = 3; 2630 } 2631 else{ 2632 printf("bc%s%s%s\t%u,%u", name, LK(opcode), a, RT(opcode), 2633 RA(opcode)); 2634 operands = 2; 2635 } 2636 return(operands); 2637 } 2638 2639 switch(opcode & 0x03e00000){ 2640 case 0x01c00000: 2641 prediction = "--"; 2642 goto bt; 2643 case 0x01e00000: 2644 prediction = "++"; 2645 goto bt; 2646 case 0x01800000: 2647 case 0x01a00000: 2648bt: /* branch if condition true */ 2649 printf("b%s%s%s%s%s", BC_TRUE(opcode), name, LK(opcode), a, 2650 prediction); 2651 if(CR_FIELD(opcode) != 0 || 2652 (branch_to_register == TRUE && BH(opcode) != 0)){ 2653 printf("\tcr%u", CR_FIELD(opcode)); 2654 operands = 1; 2655 if(branch_to_register == TRUE && BH(opcode) != 0){ 2656 printf(",%u", BH(opcode)); 2657 operands = 2; 2658 } 2659 } 2660 break; 2661 case 0x00c00000: 2662 prediction = "--"; 2663 goto bf; 2664 case 0x00e00000: 2665 prediction = "++"; 2666 goto bf; 2667 case 0x00800000: 2668 case 0x00a00000: 2669bf: /* branch if condition false */ 2670 printf("b%s%s%s%s%s", BC_FALSE(opcode), name, LK(opcode), a, 2671 prediction); 2672 if(CR_FIELD(opcode) != 0 || 2673 (branch_to_register == TRUE && BH(opcode) != 0)){ 2674 printf("\tcr%u", CR_FIELD(opcode)); 2675 operands = 1; 2676 if(branch_to_register == TRUE && BH(opcode) != 0){ 2677 printf(",%u", BH(opcode)); 2678 operands = 2; 2679 } 2680 } 2681 break; 2682 case 0x03000000: 2683 prediction = "--"; 2684 goto bdnz; 2685 case 0x03200000: 2686 prediction = "++"; 2687 goto bdnz; 2688 case 0x02000000: 2689 case 0x02200000: 2690bdnz: /* decrement ctr branch if ctr non-zero */ 2691 if((opcode & 0xfc0007fe) == 0x4c000420 || 2692 (opcode & 0x001f0000) != 0x00000000) 2693 goto bc_general_default_form; 2694 printf("bdnz%s%s%s%s", name, LK(opcode), a, prediction); 2695 if(branch_to_register == TRUE && BH(opcode) != 0){ 2696 printf("\t%u", BH(opcode)); 2697 operands = 1; 2698 } 2699 break; 2700 case 0x01000000: 2701 case 0x01200000: 2702 /* decrement ctr branch if ctr non-zero and condition true */ 2703 if((opcode & 0xfc0007fe) == 0x4c000420) 2704 goto bc_general_default_form; 2705 printf("bdnzt%s%s%s%s\t", name, LK(opcode), a, prediction); 2706 if(CR_FIELD(opcode) != 0) 2707 printf("cr%u+", CR_FIELD(opcode)); 2708 printf("%s", BC_TRUE(opcode)); 2709 operands = 1; 2710 if(branch_to_register == TRUE && BH(opcode) != 0){ 2711 printf(",%u", BH(opcode)); 2712 operands = 2; 2713 } 2714 break; 2715 case 0x00000000: 2716 case 0x00200000: 2717 /* decrement ctr branch if ctr non-zero and condition false */ 2718 if((opcode & 0xfc0007fe) == 0x4c000420) 2719 goto bc_general_default_form; 2720 printf("bdnzf%s%s%s%s\t", name, LK(opcode), a, prediction); 2721 if(CR_FIELD(opcode) != 0) 2722 printf("cr%u+", CR_FIELD(opcode)); 2723 printf("%s", BC_TRUE(opcode)); 2724 operands = 1; 2725 if(branch_to_register == TRUE && BH(opcode) != 0){ 2726 printf(",%u", BH(opcode)); 2727 operands = 2; 2728 } 2729 break; 2730 case 0x03400000: 2731 prediction = "--"; 2732 goto bdz; 2733 case 0x03600000: 2734 prediction = "++"; 2735 goto bdz; 2736 case 0x02400000: 2737 case 0x02600000: 2738bdz: /* decrement ctr branch if ctr zero */ 2739 if((opcode & 0xfc0007fe) == 0x4c000420 || 2740 (opcode & 0x001f0000) != 0x00000000) 2741 goto bc_general_default_form; 2742 printf("bdz%s%s%s%s", name, LK(opcode), a, prediction); 2743 if(branch_to_register == TRUE && BH(opcode) != 0){ 2744 printf("\t%u", BH(opcode)); 2745 operands = 1; 2746 } 2747 break; 2748 case 0x01400000: 2749 case 0x01600000: 2750 /* decrement ctr branch if ctr zero and condition true */ 2751 if((opcode & 0xfc0007fe) == 0x4c000420) 2752 goto bc_general_default_form; 2753 printf("bdzt%s%s%s%s\t", name, LK(opcode), a, prediction); 2754 if(CR_FIELD(opcode) != 0) 2755 printf("cr%u+", CR_FIELD(opcode)); 2756 printf("%s", BC_TRUE(opcode)); 2757 operands = 1; 2758 if(branch_to_register == TRUE && BH(opcode) != 0){ 2759 printf(",%u", BH(opcode)); 2760 operands = 2; 2761 } 2762 break; 2763 case 0x00400000: 2764 case 0x00600000: 2765 /* decrement ctr branch if ctr zero and condition false */ 2766 if((opcode & 0xfc0007fe) == 0x4c000420) 2767 goto bc_general_default_form; 2768 printf("bdzf%s%s%s%s\t", name, LK(opcode), a, prediction); 2769 if(CR_FIELD(opcode) != 0) 2770 printf("cr%u+", CR_FIELD(opcode)); 2771 printf("%s", BC_TRUE(opcode)); 2772 operands = 1; 2773 if(branch_to_register == TRUE && BH(opcode) != 0){ 2774 printf(",%u", BH(opcode)); 2775 operands = 2; 2776 } 2777 break; 2778 case 0x02800000: 2779 /* branch unconditionally */ 2780 if(Y_BIT(opcode) != 0 || RA(opcode) != 0) 2781 goto bc_general_default_form; 2782 if(BH(opcode) != 0) 2783 printf("b%s%s%s\t%u", name, LK(opcode), a, BH(opcode)); 2784 else 2785 printf("b%s%s%s", name, LK(opcode), a); 2786 break; 2787 default: 2788bc_general_default_form: 2789 if(RT(opcode) == 20){ /* branch always */ 2790 if(branch_to_register == TRUE && BH(opcode) != 0){ 2791 printf("bc%s%s%s\t%u,%u,%u", name, LK(opcode), a, 2792 RT(opcode), RA(opcode), BH(opcode)); 2793 operands = 3; 2794 } 2795 else{ 2796 printf("bc%s%s%s\t%u,%u", name, LK(opcode), a, 2797 RT(opcode), RA(opcode)); 2798 operands = 2; 2799 } 2800 } 2801 else{ 2802 if(branch_to_register == TRUE && BH(opcode) != 0){ 2803 printf("bc%s%s%s%s\t%u,%u,%u", name, LK(opcode), a, 2804 prediction, RT(opcode), RA(opcode), BH(opcode)); 2805 operands = 3; 2806 } 2807 else{ 2808 printf("bc%s%s%s%s\t%u,%u", name, LK(opcode), a, 2809 prediction, RT(opcode), RA(opcode)); 2810 operands = 2; 2811 } 2812 } 2813 break; 2814 } 2815 return(operands); 2816} 2817 2818static 2819void 2820trap( 2821const char *name, 2822uint32_t opcode) 2823{ 2824 char *i; 2825 2826 if(((opcode & 0xfc000000) == 0x08000000) || 2827 ((opcode & 0xfc000000) == 0x0c000000)) 2828 i = "i"; 2829 else 2830 i = ""; 2831 2832 switch(opcode & 0x03e00000){ 2833 case 0x02000000: 2834 printf("t%slt%s\tr%u,", name, i, RA(opcode)); 2835 break; 2836 case 0x02800000: 2837 printf("t%sle%s\tr%u,", name, i, RA(opcode)); 2838 break; 2839 case 0x00800000: 2840 printf("t%seq%s\tr%u,", name, i, RA(opcode)); 2841 break; 2842 case 0x01800000: 2843 printf("t%sge%s\tr%u,", name, i, RA(opcode)); 2844 break; 2845 case 0x01000000: 2846 printf("t%sgt%s\tr%u,", name, i, RA(opcode)); 2847 break; 2848 case 0x03000000: 2849 printf("t%sne%s\tr%u,", name, i, RA(opcode)); 2850 break; 2851 case 0x00400000: 2852 printf("t%sllt%s\tr%u,", name, i, RA(opcode)); 2853 break; 2854 case 0x00c00000: 2855 printf("t%slle%s\tr%u,", name, i, RA(opcode)); 2856 break; 2857 case 0x00a00000: 2858 printf("t%slge%s\tr%u,", name, i, RA(opcode)); 2859 break; 2860 case 0x00200000: 2861 printf("t%slgt%s\tr%u,", name, i, RA(opcode)); 2862 break; 2863 default: 2864 printf("t%s%s\t%u,r%u,", name, i, TO(opcode), RA(opcode)); 2865 break; 2866 } 2867} 2868 2869static 2870void 2871print_special_register_name( 2872unsigned opcode) 2873{ 2874 uint32_t reg; 2875 2876 reg = ((((opcode >> 11) & 0x1f) << 5) | ((opcode >> 16) & 0x1f)); 2877 switch(reg){ 2878 case 0: 2879 printf("mq"); 2880 break; 2881 case 1: 2882 printf("xer"); 2883 break; 2884 case 4: 2885 printf("rtcu"); 2886 break; 2887 case 5: 2888 printf("rtcl"); 2889 break; 2890 case 8: 2891 printf("lr"); 2892 break; 2893 case 9: 2894 printf("ctr"); 2895 break; 2896 case 18: 2897 printf("dsisr"); 2898 break; 2899 case 19: 2900 printf("dar"); 2901 break; 2902 case 22: 2903 printf("dec"); 2904 break; 2905 case 25: 2906 printf("sdr1"); 2907 break; 2908 case 26: 2909 printf("srr0"); 2910 break; 2911 case 27: 2912 printf("srr1"); 2913 break; 2914 case 256: 2915 printf("VRsave"); 2916 break; 2917 case 272: 2918 printf("sprg0"); 2919 break; 2920 case 273: 2921 printf("sprg1"); 2922 break; 2923 case 274: 2924 printf("sprg2"); 2925 break; 2926 case 275: 2927 printf("sprg3"); 2928 break; 2929 case 280: 2930 printf("asr"); 2931 break; 2932 case 281: 2933 printf("rtcd"); 2934 break; 2935 case 282: 2936 printf("rtci"); 2937 break; 2938 case 284: 2939 printf("tbl"); 2940 break; 2941 case 285: 2942 printf("tbu"); 2943 break; 2944 case 287: 2945 printf("pvr"); 2946 break; 2947 case 528: 2948 printf("ibat0u"); 2949 break; 2950 case 529: 2951 printf("ibat0l"); 2952 break; 2953 case 530: 2954 printf("ibat1u"); 2955 break; 2956 case 531: 2957 printf("ibat1l"); 2958 break; 2959 case 532: 2960 printf("ibat2u"); 2961 break; 2962 case 533: 2963 printf("ibat2l"); 2964 break; 2965 case 534: 2966 printf("ibat3u"); 2967 break; 2968 case 535: 2969 printf("ibat3l"); 2970 break; 2971 case 536: 2972 printf("dbat0u"); 2973 break; 2974 case 537: 2975 printf("dbat0l"); 2976 break; 2977 case 538: 2978 printf("dbat1u"); 2979 break; 2980 case 539: 2981 printf("dbat1l"); 2982 break; 2983 case 540: 2984 printf("dbat2u"); 2985 break; 2986 case 541: 2987 printf("dbat2l"); 2988 break; 2989 case 542: 2990 printf("dbat3u"); 2991 break; 2992 case 543: 2993 printf("dbat3l"); 2994 break; 2995 case 936: 2996 printf("ummcr0"); 2997 break; 2998 case 937: 2999 printf("upmc1"); 3000 break; 3001 case 938: 3002 printf("upmc2"); 3003 break; 3004 case 939: 3005 printf("usia"); 3006 break; 3007 case 940: 3008 printf("ummcr1"); 3009 break; 3010 case 941: 3011 printf("upmc3"); 3012 break; 3013 case 942: 3014 printf("upmc4"); 3015 break; 3016 case 952: 3017 printf("mmcr0"); 3018 break; 3019 case 953: 3020 printf("pmc1"); 3021 break; 3022 case 954: 3023 printf("pmc2"); 3024 break; 3025 case 955: 3026 printf("sia"); 3027 break; 3028 case 956: 3029 printf("mmcr1"); 3030 break; 3031 case 957: 3032 printf("pmc3"); 3033 break; 3034 case 958: 3035 printf("pmc4"); 3036 break; 3037 case 959: 3038 printf("sda"); 3039 break; 3040 case 976: 3041 printf("dmiss"); 3042 break; 3043 case 977: 3044 printf("dcmp"); 3045 break; 3046 case 978: 3047 printf("hash1"); 3048 break; 3049 case 979: 3050 printf("hash2"); 3051 break; 3052 case 980: 3053 printf("imiss"); 3054 break; 3055 case 981: 3056 printf("icmp"); 3057 break; 3058 case 982: 3059 printf("rpa"); 3060 break; 3061 case 1008: 3062 printf("hid0"); 3063 break; 3064 case 1009: 3065 printf("hid1"); 3066 break; 3067 case 1010: 3068 printf("hid2"); 3069 break; 3070 case 1013: 3071 printf("dabr"); 3072 break; 3073 case 1017: 3074 printf("l2cr"); 3075 break; 3076 case 1019: 3077 printf("ictc"); 3078 break; 3079 case 1020: 3080 printf("thrm1"); 3081 break; 3082 case 1021: 3083 printf("thrm2"); 3084 break; 3085 case 1022: 3086 printf("thrm3"); 3087 break; 3088 case 1023: 3089 printf("pir"); 3090 break; 3091 default: 3092 printf("%u", reg); 3093 } 3094} 3095 3096static 3097void 3098print_immediate( 3099uint32_t value, 3100uint32_t sect_offset, 3101struct relocation_info *relocs, 3102uint32_t nrelocs, 3103struct nlist *symbols, 3104struct nlist_64 *symbols64, 3105uint32_t nsymbols, 3106struct symbol *sorted_symbols, 3107uint32_t nsorted_symbols, 3108char *strings, 3109uint32_t strings_size, 3110enum bool verbose) 3111{ 3112 int32_t low, high, mid, reloc_found, offset; 3113 uint32_t i, r_address, r_symbolnum, r_type, r_extern, 3114 r_value, r_scattered, pair_r_type, pair_r_value; 3115 uint32_t other_half; 3116 const char *name, *add, *sub; 3117 struct relocation_info *rp, *pairp; 3118 struct scattered_relocation_info *srp, *spairp; 3119 uint32_t n_strx; 3120 3121 r_symbolnum = 0; 3122 r_type = 0; 3123 r_extern = 0; 3124 r_value = 0; 3125 r_scattered = 0; 3126 other_half = 0; 3127 pair_r_value = 0; 3128 3129 if(verbose == FALSE){ 3130 printf("0x%x", (unsigned int)value); 3131 return; 3132 } 3133 reloc_found = 0; 3134 if(nrelocs != 0){ 3135 for(i = 0; i < nrelocs; i++){ 3136 rp = &relocs[i]; 3137 if(rp->r_address & R_SCATTERED){ 3138 srp = (struct scattered_relocation_info *)rp; 3139 r_scattered = 1; 3140 r_address = srp->r_address; 3141 r_extern = 0; 3142 r_type = srp->r_type; 3143 r_value = srp->r_value; 3144 } 3145 else{ 3146 r_scattered = 0; 3147 r_address = rp->r_address; 3148 r_symbolnum = rp->r_symbolnum; 3149 r_extern = rp->r_extern; 3150 r_type = rp->r_type; 3151 } 3152 if(r_type == PPC_RELOC_PAIR){ 3153 fprintf(stderr, "Stray PPC_RELOC_PAIR relocation entry " 3154 "%u\n", i); 3155 continue; 3156 } 3157 if(r_address == sect_offset){ 3158 if(r_type == PPC_RELOC_HI16 || 3159 r_type == PPC_RELOC_LO16 || 3160 r_type == PPC_RELOC_HA16 || 3161 r_type == PPC_RELOC_SECTDIFF || 3162 r_type == PPC_RELOC_LOCAL_SECTDIFF || 3163 r_type == PPC_RELOC_HI16_SECTDIFF || 3164 r_type == PPC_RELOC_LO16_SECTDIFF || 3165 r_type == PPC_RELOC_LO14_SECTDIFF || 3166 r_type == PPC_RELOC_HA16_SECTDIFF || 3167 r_type == PPC_RELOC_LO14 || 3168 r_type == PPC_RELOC_JBSR){ 3169 if(i+1 < nrelocs){ 3170 pairp = &rp[1]; 3171 if(pairp->r_address & R_SCATTERED){ 3172 spairp = (struct scattered_relocation_info *) 3173 pairp; 3174 if(r_type == PPC_RELOC_JBSR) 3175 other_half = spairp->r_address; 3176 else 3177 other_half = spairp->r_address & 0xffff; 3178 pair_r_type = spairp->r_type; 3179 pair_r_value = spairp->r_value; 3180 } 3181 else{ 3182 if(r_type == PPC_RELOC_JBSR) 3183 other_half = pairp->r_address; 3184 else 3185 other_half = pairp->r_address & 0xffff; 3186 pair_r_type = pairp->r_type; 3187 } 3188 if(pair_r_type != PPC_RELOC_PAIR){ 3189 fprintf(stderr, "No PPC_RELOC_PAIR relocation " 3190 "entry after entry %u\n", i); 3191 continue; 3192 } 3193 } 3194 } 3195 reloc_found = 1; 3196 break; 3197 } 3198 if(r_type == PPC_RELOC_HI16 || 3199 r_type == PPC_RELOC_LO16 || 3200 r_type == PPC_RELOC_HA16 || 3201 r_type == PPC_RELOC_SECTDIFF || 3202 r_type == PPC_RELOC_LOCAL_SECTDIFF || 3203 r_type == PPC_RELOC_HI16_SECTDIFF || 3204 r_type == PPC_RELOC_LO16_SECTDIFF || 3205 r_type == PPC_RELOC_LO14_SECTDIFF || 3206 r_type == PPC_RELOC_HA16_SECTDIFF || 3207 r_type == PPC_RELOC_LO14 || 3208 r_type == PPC_RELOC_JBSR){ 3209 if(i+1 < nrelocs){ 3210 pairp = &rp[1]; 3211 if(pairp->r_address & R_SCATTERED){ 3212 spairp = (struct scattered_relocation_info *)pairp; 3213 pair_r_type = spairp->r_type; 3214 } 3215 else{ 3216 pair_r_type = pairp->r_type; 3217 } 3218 if(pair_r_type == PPC_RELOC_PAIR) 3219 i++; 3220 else 3221 fprintf(stderr, "No PPC_RELOC_PAIR relocation " 3222 "entry after entry %u\n", i); 3223 } 3224 } 3225 } 3226 } 3227 3228 if(reloc_found && r_extern == 1){ 3229 if(symbols != NULL) 3230 n_strx = symbols[r_symbolnum].n_un.n_strx; 3231 else 3232 n_strx = symbols64[r_symbolnum].n_un.n_strx; 3233 if(n_strx >= strings_size) 3234 name = "bad string offset"; 3235 else 3236 name = strings + n_strx; 3237 if(value != 0){ 3238 switch(r_type){ 3239 case PPC_RELOC_HI16: 3240 value = value << 16 | other_half; 3241 printf("hi16(%s+0x%x)", name, (unsigned int)value); 3242 break; 3243 case PPC_RELOC_HA16: 3244 value = value << 16 | other_half; 3245 printf("ha16(%s+0x%x)", name, (unsigned int)value); 3246 break; 3247 case PPC_RELOC_LO16: 3248 case PPC_RELOC_LO14: 3249 value = other_half << 16 | value; 3250 printf("lo16(%s+0x%x)", name, (unsigned int)value); 3251 break; 3252 case PPC_RELOC_JBSR: 3253 printf("%s",name); 3254 if(other_half != 0) 3255 printf("+0x%x",(unsigned int)other_half); 3256 break; 3257 default: 3258 printf("%s+0x%x", name, (unsigned int)value); 3259 break; 3260 } 3261 } 3262 else{ 3263 switch(r_type){ 3264 case PPC_RELOC_HI16: 3265 value = value << 16 | other_half; 3266 if(value == 0) 3267 printf("hi16(%s)", name); 3268 else 3269 printf("hi16(%s+0x%x)", name, (unsigned int)value); 3270 break; 3271 case PPC_RELOC_HA16: 3272 value = value << 16 | other_half; 3273 if(value == 0) 3274 printf("ha16(%s)", name); 3275 else 3276 printf("ha16(%s+0x%x)", name, (unsigned int)value); 3277 break; 3278 case PPC_RELOC_LO16: 3279 case PPC_RELOC_LO14: 3280 value = other_half << 16 | value; 3281 if(value == 0) 3282 printf("lo16(%s)", name); 3283 else 3284 printf("lo16(%s+0x%x)", name, (unsigned int)value); 3285 break; 3286 case PPC_RELOC_JBSR: 3287 if(other_half != 0) 3288 printf("%s+0x%x", name, (unsigned int)other_half); 3289 else 3290 printf("%s", name); 3291 break; 3292 default: 3293 if(value == 0) 3294 printf("%s", name); 3295 else 3296 printf("%s+0x%x", name, (unsigned int)value); 3297 } 3298 } 3299 return; 3300 } 3301 3302 offset = 0; 3303 if(reloc_found){ 3304 if(r_type == PPC_RELOC_HI16 || 3305 r_type == PPC_RELOC_HI16_SECTDIFF) 3306 value = value << 16 | other_half; 3307 else if(r_type == PPC_RELOC_HA16 || 3308 r_type == PPC_RELOC_HA16_SECTDIFF){ 3309 if((other_half & 0x00008000) != 0) 3310 value = (value << 16) + (0xffff0000 | other_half); 3311 else 3312 value = (value << 16) + other_half; 3313 } 3314 else if(r_type == PPC_RELOC_LO16 || 3315 r_type == PPC_RELOC_LO16_SECTDIFF || 3316 r_type == PPC_RELOC_LO14_SECTDIFF || 3317 r_type == PPC_RELOC_LO14) 3318 value = other_half << 16 | value; 3319 else if(r_type == PPC_RELOC_JBSR) 3320 value = other_half; 3321 if(r_scattered && 3322 (r_type != PPC_RELOC_HI16_SECTDIFF && 3323 r_type != PPC_RELOC_HA16_SECTDIFF && 3324 r_type != PPC_RELOC_LO14_SECTDIFF && 3325 r_type != PPC_RELOC_LO16_SECTDIFF)){ 3326 offset = value - r_value; 3327 value = r_value; 3328 } 3329 } 3330 3331 if(reloc_found && 3332 (r_type == PPC_RELOC_HI16_SECTDIFF || 3333 r_type == PPC_RELOC_HA16_SECTDIFF || 3334 r_type == PPC_RELOC_LO14_SECTDIFF || 3335 r_type == PPC_RELOC_LO16_SECTDIFF)){ 3336 if(r_type == PPC_RELOC_HI16_SECTDIFF) 3337 printf("hi16("); 3338 else if(r_type == PPC_RELOC_HA16_SECTDIFF) 3339 printf("ha16("); 3340 else 3341 printf("lo16("); 3342 add = guess_symbol(r_value, sorted_symbols, 3343 nsorted_symbols, verbose); 3344 sub = guess_symbol(pair_r_value, sorted_symbols, 3345 nsorted_symbols, verbose); 3346 offset = value - (r_value - pair_r_value); 3347 if(add != NULL) 3348 printf("%s", add); 3349 else 3350 printf("0x%x", (unsigned int)r_value); 3351 if(sub != NULL) 3352 printf("-%s", sub); 3353 else 3354 printf("-0x%x", (unsigned int)pair_r_value); 3355 if(offset != 0) 3356 printf("+0x%x", (unsigned int)offset); 3357 printf(")"); 3358 return; 3359 } 3360 3361 low = 0; 3362 high = nsorted_symbols - 1; 3363 mid = (high - low) / 2; 3364 while(high >= low){ 3365 if(sorted_symbols[mid].n_value == value){ 3366 if(reloc_found){ 3367 switch(r_type){ 3368 case PPC_RELOC_HI16: 3369 if(offset == 0) 3370 printf("hi16(%s)", 3371 sorted_symbols[mid].name); 3372 else 3373 printf("hi16(%s+0x%x)", 3374 sorted_symbols[mid].name, 3375 (unsigned int)offset); 3376 break; 3377 case PPC_RELOC_HA16: 3378 if(offset == 0) 3379 printf("ha16(%s)", 3380 sorted_symbols[mid].name); 3381 else 3382 printf("ha16(%s+0x%x)", 3383 sorted_symbols[mid].name, 3384 (unsigned int)offset); 3385 break; 3386 case PPC_RELOC_LO16: 3387 case PPC_RELOC_LO14: 3388 if(offset == 0) 3389 printf("lo16(%s)", 3390 sorted_symbols[mid].name); 3391 else 3392 printf("lo16(%s+0x%x)", 3393 sorted_symbols[mid].name, 3394 (unsigned int)offset); 3395 break; 3396 default: 3397 if(offset == 0) 3398 printf("%s",sorted_symbols[mid].name); 3399 else 3400 printf("%s+0x%x", 3401 sorted_symbols[mid].name, 3402 (unsigned int)offset); 3403 break; 3404 } 3405 } 3406 else{ 3407 if(offset == 0) 3408 printf("%s",sorted_symbols[mid].name); 3409 else 3410 printf("%s+0x%x", 3411 sorted_symbols[mid].name, 3412 (unsigned int)offset); 3413 } 3414 return; 3415 } 3416 if(sorted_symbols[mid].n_value > value){ 3417 high = mid - 1; 3418 mid = (high + low) / 2; 3419 } 3420 else{ 3421 low = mid + 1; 3422 mid = (high + low) / 2; 3423 } 3424 } 3425 if(offset == 0){ 3426 if(reloc_found){ 3427 if(r_type == PPC_RELOC_HI16) 3428 printf("hi16(0x%x)", (unsigned int)value); 3429 else if(r_type == PPC_RELOC_HA16) 3430 printf("ha16(0x%x)", (unsigned int)value); 3431 else if(r_type == PPC_RELOC_LO16 || 3432 r_type == PPC_RELOC_LO14) 3433 printf("lo16(0x%x)", (unsigned int)value); 3434 else 3435 printf("0x%x", (unsigned int)value); 3436 } 3437 else 3438 printf("0x%x", (unsigned int)value); 3439 } 3440 else{ 3441 if(reloc_found){ 3442 if(r_type == PPC_RELOC_HI16) 3443 printf("hi16(0x%x+0x%x)", 3444 (unsigned int)value, (unsigned int)offset); 3445 else if(r_type == PPC_RELOC_HA16) 3446 printf("ha16(0x%x+0x%x)", 3447 (unsigned int)value, (unsigned int)offset); 3448 else if(r_type == PPC_RELOC_LO16 || 3449 r_type == PPC_RELOC_LO14) 3450 printf("lo16(0x%x+0x%x)", 3451 (unsigned int)value, (unsigned int)offset); 3452 else 3453 printf("0x%x+0x%x", 3454 (unsigned int)value, (unsigned int)offset); 3455 } 3456 else 3457 printf("0x%x+0x%x", 3458 (unsigned int)value, (unsigned int)offset); 3459 } 3460 return; 3461} 3462 3463/* 3464 * To handle the jsbr type instruction, we have to search for a reloc 3465 * of type PPC_RELOC_JBSR whenever a bl type instruction is encountered. 3466 * If such a reloc type exists at the correct pc, then we have to print out 3467 * jbsr instead of bl. This routine uses the logic from above to loop though 3468 * the relocs and give the r_type for the particular address. 3469 */ 3470static 3471uint32_t 3472get_reloc_r_type( 3473uint32_t pc, 3474struct relocation_info *relocs, 3475uint32_t nrelocs) 3476{ 3477 uint32_t i; 3478 struct relocation_info *rp; 3479 uint32_t r_type, r_address; 3480 3481 for(i = 0; i < nrelocs; i++){ 3482 rp = &relocs[i]; 3483 if(rp->r_address & R_SCATTERED){ 3484 r_type = ((struct scattered_relocation_info *)rp)->r_type; 3485 r_address = ((struct scattered_relocation_info *)rp)->r_address; 3486 } 3487 else{ 3488 r_type = rp->r_type; 3489 r_address = rp->r_address; 3490 } 3491 if(r_type == PPC_RELOC_PAIR) 3492 continue; 3493 if(r_address == pc) 3494 return(r_type); 3495 } 3496 return(0xffffffff); 3497} 3498 3499/* 3500 * For branch conditional instructions that use the Y-bit that were 3501 * predicted the r_length is set to 3 instead of 2. So to correctly 3502 * print the prediction, we have to search for a reloc of and look at 3503 * the r_length. If there is a reloc at the pc of the branch, and if the 3504 * r_length is 3 it then we know it was a predicted branch and we will always 3505 * print the prediction based on the Y-bit, the sign of the displacement 3506 * or the opcode (in the case of bclrX and bcctrX instructions). This routine 3507 * uses the logic from the above routine to loop though the relocs and give the 3508 * r_length for the particular address. 3509 */ 3510static 3511uint32_t 3512get_reloc_r_length( 3513uint32_t sect_offset, 3514struct relocation_info *relocs, 3515uint32_t nrelocs) 3516{ 3517 uint32_t i; 3518 struct relocation_info *rp; 3519 uint32_t r_length, r_address, r_type; 3520 3521 for(i = 0; i < nrelocs; i++){ 3522 rp = &relocs[i]; 3523 if(rp->r_address & R_SCATTERED){ 3524 r_type = ((struct scattered_relocation_info *)rp)->r_type; 3525 r_length = ((struct scattered_relocation_info *)rp)->r_length; 3526 r_address = ((struct scattered_relocation_info *)rp)->r_address; 3527 } 3528 else{ 3529 r_type = rp->r_type; 3530 r_length = rp->r_length; 3531 r_address = rp->r_address; 3532 } 3533 if(r_type == PPC_RELOC_PAIR) 3534 continue; 3535 if(r_address == sect_offset) 3536 return(r_length); 3537 } 3538 return(0xffffffff); 3539} 3540