1 /* Disassembler for the PA-RISC. Somewhat derived from sparc-pinsn.c. 2 Copyright 1989, 1990, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001, 2003, 3 2005 Free Software Foundation, Inc. 4 5 Contributed by the Center for Software Science at the 6 University of Utah (pa-gdb-bugs@cs.utah.edu). 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "qemu/osdep.h" 22 #include "disas/dis-asm.h" 23 24 /* HP PA-RISC SOM object file format: definitions internal to BFD. 25 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 26 2003 Free Software Foundation, Inc. 27 28 Contributed by the Center for Software Science at the 29 University of Utah (pa-gdb-bugs@cs.utah.edu). 30 31 This file is part of BFD, the Binary File Descriptor library. 32 33 This program is free software; you can redistribute it and/or modify 34 it under the terms of the GNU General Public License as published by 35 the Free Software Foundation; either version 2 of the License, or 36 (at your option) any later version. 37 38 This program is distributed in the hope that it will be useful, 39 but WITHOUT ANY WARRANTY; without even the implied warranty of 40 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 41 GNU General Public License for more details. 42 43 You should have received a copy of the GNU General Public License 44 along with this program; if not, see <http://www.gnu.org/licenses/>. */ 45 46 #ifndef _LIBHPPA_H 47 #define _LIBHPPA_H 48 49 #define BYTES_IN_WORD 4 50 #define PA_PAGESIZE 0x1000 51 52 /* The PA instruction set variants. */ 53 enum pa_arch {pa10 = 10, pa11 = 11, pa20 = 20, pa20w = 25}; 54 55 /* HP PA-RISC relocation types */ 56 57 enum hppa_reloc_field_selector_type 58 { 59 R_HPPA_FSEL = 0x0, 60 R_HPPA_LSSEL = 0x1, 61 R_HPPA_RSSEL = 0x2, 62 R_HPPA_LSEL = 0x3, 63 R_HPPA_RSEL = 0x4, 64 R_HPPA_LDSEL = 0x5, 65 R_HPPA_RDSEL = 0x6, 66 R_HPPA_LRSEL = 0x7, 67 R_HPPA_RRSEL = 0x8, 68 R_HPPA_NSEL = 0x9, 69 R_HPPA_NLSEL = 0xa, 70 R_HPPA_NLRSEL = 0xb, 71 R_HPPA_PSEL = 0xc, 72 R_HPPA_LPSEL = 0xd, 73 R_HPPA_RPSEL = 0xe, 74 R_HPPA_TSEL = 0xf, 75 R_HPPA_LTSEL = 0x10, 76 R_HPPA_RTSEL = 0x11, 77 R_HPPA_LTPSEL = 0x12, 78 R_HPPA_RTPSEL = 0x13 79 }; 80 81 /* /usr/include/reloc.h defines these to constants. We want to use 82 them in enums, so #undef them before we start using them. We might 83 be able to fix this another way by simply managing not to include 84 /usr/include/reloc.h, but currently GDB picks up these defines 85 somewhere. */ 86 #undef e_fsel 87 #undef e_lssel 88 #undef e_rssel 89 #undef e_lsel 90 #undef e_rsel 91 #undef e_ldsel 92 #undef e_rdsel 93 #undef e_lrsel 94 #undef e_rrsel 95 #undef e_nsel 96 #undef e_nlsel 97 #undef e_nlrsel 98 #undef e_psel 99 #undef e_lpsel 100 #undef e_rpsel 101 #undef e_tsel 102 #undef e_ltsel 103 #undef e_rtsel 104 #undef e_one 105 #undef e_two 106 #undef e_pcrel 107 #undef e_con 108 #undef e_plabel 109 #undef e_abs 110 111 /* for compatibility */ 112 enum hppa_reloc_field_selector_type_alt 113 { 114 e_fsel = R_HPPA_FSEL, 115 e_lssel = R_HPPA_LSSEL, 116 e_rssel = R_HPPA_RSSEL, 117 e_lsel = R_HPPA_LSEL, 118 e_rsel = R_HPPA_RSEL, 119 e_ldsel = R_HPPA_LDSEL, 120 e_rdsel = R_HPPA_RDSEL, 121 e_lrsel = R_HPPA_LRSEL, 122 e_rrsel = R_HPPA_RRSEL, 123 e_nsel = R_HPPA_NSEL, 124 e_nlsel = R_HPPA_NLSEL, 125 e_nlrsel = R_HPPA_NLRSEL, 126 e_psel = R_HPPA_PSEL, 127 e_lpsel = R_HPPA_LPSEL, 128 e_rpsel = R_HPPA_RPSEL, 129 e_tsel = R_HPPA_TSEL, 130 e_ltsel = R_HPPA_LTSEL, 131 e_rtsel = R_HPPA_RTSEL, 132 e_ltpsel = R_HPPA_LTPSEL, 133 e_rtpsel = R_HPPA_RTPSEL 134 }; 135 136 enum hppa_reloc_expr_type 137 { 138 R_HPPA_E_ONE = 0, 139 R_HPPA_E_TWO = 1, 140 R_HPPA_E_PCREL = 2, 141 R_HPPA_E_CON = 3, 142 R_HPPA_E_PLABEL = 7, 143 R_HPPA_E_ABS = 18 144 }; 145 146 /* for compatibility */ 147 enum hppa_reloc_expr_type_alt 148 { 149 e_one = R_HPPA_E_ONE, 150 e_two = R_HPPA_E_TWO, 151 e_pcrel = R_HPPA_E_PCREL, 152 e_con = R_HPPA_E_CON, 153 e_plabel = R_HPPA_E_PLABEL, 154 e_abs = R_HPPA_E_ABS 155 }; 156 157 158 /* Relocations for function calls must be accompanied by parameter 159 relocation bits. These bits describe exactly where the caller has 160 placed the function's arguments and where it expects to find a return 161 value. 162 163 Both ELF and SOM encode this information within the addend field 164 of the call relocation. (Note this could break very badly if one 165 was to make a call like bl foo + 0x12345678). 166 167 The high order 10 bits contain parameter relocation information, 168 the low order 22 bits contain the constant offset. */ 169 170 #define HPPA_R_ARG_RELOC(a) \ 171 (((a) >> 22) & 0x3ff) 172 #define HPPA_R_CONSTANT(a) \ 173 ((((bfd_signed_vma)(a)) << (BFD_ARCH_SIZE-22)) >> (BFD_ARCH_SIZE-22)) 174 #define HPPA_R_ADDEND(r, c) \ 175 (((r) << 22) + ((c) & 0x3fffff)) 176 177 178 /* Some functions to manipulate PA instructions. */ 179 180 /* Declare the functions with the unused attribute to avoid warnings. */ 181 static inline int sign_extend (int, int) ATTRIBUTE_UNUSED; 182 static inline int low_sign_extend (int, int) ATTRIBUTE_UNUSED; 183 static inline int sign_unext (int, int) ATTRIBUTE_UNUSED; 184 static inline int low_sign_unext (int, int) ATTRIBUTE_UNUSED; 185 static inline int re_assemble_3 (int) ATTRIBUTE_UNUSED; 186 static inline int re_assemble_12 (int) ATTRIBUTE_UNUSED; 187 static inline int re_assemble_14 (int) ATTRIBUTE_UNUSED; 188 static inline int re_assemble_16 (int) ATTRIBUTE_UNUSED; 189 static inline int re_assemble_17 (int) ATTRIBUTE_UNUSED; 190 static inline int re_assemble_21 (int) ATTRIBUTE_UNUSED; 191 static inline int re_assemble_22 (int) ATTRIBUTE_UNUSED; 192 static inline bfd_signed_vma hppa_field_adjust 193 (bfd_vma, bfd_signed_vma, enum hppa_reloc_field_selector_type_alt) 194 ATTRIBUTE_UNUSED; 195 static inline int hppa_rebuild_insn (int, int, int) ATTRIBUTE_UNUSED; 196 197 198 /* The *sign_extend functions are used to assemble various bitfields 199 taken from an instruction and return the resulting immediate 200 value. */ 201 202 static inline int 203 sign_extend (int x, int len) 204 { 205 int signbit = (1 << (len - 1)); 206 int mask = (signbit << 1) - 1; 207 return ((x & mask) ^ signbit) - signbit; 208 } 209 210 static inline int 211 low_sign_extend (int x, int len) 212 { 213 return (x >> 1) - ((x & 1) << (len - 1)); 214 } 215 216 217 /* The re_assemble_* functions prepare an immediate value for 218 insertion into an opcode. pa-risc uses all sorts of weird bitfields 219 in the instruction to hold the value. */ 220 221 static inline int 222 sign_unext (int x, int len) 223 { 224 int len_ones; 225 226 len_ones = (1 << len) - 1; 227 228 return x & len_ones; 229 } 230 231 static inline int 232 low_sign_unext (int x, int len) 233 { 234 int temp; 235 int sign; 236 237 sign = (x >> (len-1)) & 1; 238 239 temp = sign_unext (x, len-1); 240 241 return (temp << 1) | sign; 242 } 243 244 static inline int 245 re_assemble_3 (int as3) 246 { 247 return (( (as3 & 4) << (13-2)) 248 | ((as3 & 3) << (13+1))); 249 } 250 251 static inline int 252 re_assemble_12 (int as12) 253 { 254 return (( (as12 & 0x800) >> 11) 255 | ((as12 & 0x400) >> (10 - 2)) 256 | ((as12 & 0x3ff) << (1 + 2))); 257 } 258 259 static inline int 260 re_assemble_14 (int as14) 261 { 262 return (( (as14 & 0x1fff) << 1) 263 | ((as14 & 0x2000) >> 13)); 264 } 265 266 static inline int 267 re_assemble_16 (int as16) 268 { 269 int s, t; 270 271 /* Unusual 16-bit encoding, for wide mode only. */ 272 t = (as16 << 1) & 0xffff; 273 s = (as16 & 0x8000); 274 return (t ^ s ^ (s >> 1)) | (s >> 15); 275 } 276 277 static inline int 278 re_assemble_17 (int as17) 279 { 280 return (( (as17 & 0x10000) >> 16) 281 | ((as17 & 0x0f800) << (16 - 11)) 282 | ((as17 & 0x00400) >> (10 - 2)) 283 | ((as17 & 0x003ff) << (1 + 2))); 284 } 285 286 static inline int 287 re_assemble_21 (int as21) 288 { 289 return (( (as21 & 0x100000) >> 20) 290 | ((as21 & 0x0ffe00) >> 8) 291 | ((as21 & 0x000180) << 7) 292 | ((as21 & 0x00007c) << 14) 293 | ((as21 & 0x000003) << 12)); 294 } 295 296 static inline int 297 re_assemble_22 (int as22) 298 { 299 return (( (as22 & 0x200000) >> 21) 300 | ((as22 & 0x1f0000) << (21 - 16)) 301 | ((as22 & 0x00f800) << (16 - 11)) 302 | ((as22 & 0x000400) >> (10 - 2)) 303 | ((as22 & 0x0003ff) << (1 + 2))); 304 } 305 306 307 /* Handle field selectors for PA instructions. 308 The L and R (and LS, RS etc.) selectors are used in pairs to form a 309 full 32 bit address. eg. 310 311 LDIL L'start,%r1 ; put left part into r1 312 LDW R'start(%r1),%r2 ; add r1 and right part to form address 313 314 This function returns sign extended values in all cases. 315 */ 316 317 static inline bfd_signed_vma 318 hppa_field_adjust (bfd_vma sym_val, 319 bfd_signed_vma addend, 320 enum hppa_reloc_field_selector_type_alt r_field) 321 { 322 bfd_signed_vma value; 323 324 value = sym_val + addend; 325 switch (r_field) 326 { 327 case e_fsel: 328 /* F: No change. */ 329 break; 330 331 case e_nsel: 332 /* N: null selector. I don't really understand what this is all 333 about, but HP's documentation says "this indicates that zero 334 bits are to be used for the displacement on the instruction. 335 This fixup is used to identify three-instruction sequences to 336 access data (for importing shared library data)." */ 337 value = 0; 338 break; 339 340 case e_lsel: 341 case e_nlsel: 342 /* L: Select top 21 bits. */ 343 value = value >> 11; 344 break; 345 346 case e_rsel: 347 /* R: Select bottom 11 bits. */ 348 value = value & 0x7ff; 349 break; 350 351 case e_lssel: 352 /* LS: Round to nearest multiple of 2048 then select top 21 bits. */ 353 value = value + 0x400; 354 value = value >> 11; 355 break; 356 357 case e_rssel: 358 /* RS: Select bottom 11 bits for LS. 359 We need to return a value such that 2048 * LS'x + RS'x == x. 360 ie. RS'x = x - ((x + 0x400) & -0x800) 361 this is just a sign extension from bit 21. */ 362 value = ((value & 0x7ff) ^ 0x400) - 0x400; 363 break; 364 365 case e_ldsel: 366 /* LD: Round to next multiple of 2048 then select top 21 bits. 367 Yes, if we are already on a multiple of 2048, we go up to the 368 next one. RD in this case will be -2048. */ 369 value = value + 0x800; 370 value = value >> 11; 371 break; 372 373 case e_rdsel: 374 /* RD: Set bits 0-20 to one. */ 375 value = value | -0x800; 376 break; 377 378 case e_lrsel: 379 case e_nlrsel: 380 /* LR: L with rounding of the addend to nearest 8k. */ 381 value = sym_val + ((addend + 0x1000) & -0x2000); 382 value = value >> 11; 383 break; 384 385 case e_rrsel: 386 /* RR: R with rounding of the addend to nearest 8k. 387 We need to return a value such that 2048 * LR'x + RR'x == x 388 ie. RR'x = s+a - (s + (((a + 0x1000) & -0x2000) & -0x800)) 389 . = s+a - ((s & -0x800) + ((a + 0x1000) & -0x2000)) 390 . = (s & 0x7ff) + a - ((a + 0x1000) & -0x2000) */ 391 value = (sym_val & 0x7ff) + (((addend & 0x1fff) ^ 0x1000) - 0x1000); 392 break; 393 394 default: 395 abort (); 396 } 397 return value; 398 } 399 400 /* PA-RISC OPCODES */ 401 #define get_opcode(insn) (((insn) >> 26) & 0x3f) 402 403 enum hppa_opcode_type 404 { 405 /* None of the opcodes in the first group generate relocs, so we 406 aren't too concerned about them. */ 407 OP_SYSOP = 0x00, 408 OP_MEMMNG = 0x01, 409 OP_ALU = 0x02, 410 OP_NDXMEM = 0x03, 411 OP_SPOP = 0x04, 412 OP_DIAG = 0x05, 413 OP_FMPYADD = 0x06, 414 OP_UNDEF07 = 0x07, 415 OP_COPRW = 0x09, 416 OP_COPRDW = 0x0b, 417 OP_COPR = 0x0c, 418 OP_FLOAT = 0x0e, 419 OP_PRDSPEC = 0x0f, 420 OP_UNDEF15 = 0x15, 421 OP_UNDEF1d = 0x1d, 422 OP_FMPYSUB = 0x26, 423 OP_FPFUSED = 0x2e, 424 OP_SHEXDP0 = 0x34, 425 OP_SHEXDP1 = 0x35, 426 OP_SHEXDP2 = 0x36, 427 OP_UNDEF37 = 0x37, 428 OP_SHEXDP3 = 0x3c, 429 OP_SHEXDP4 = 0x3d, 430 OP_MULTMED = 0x3e, 431 OP_UNDEF3f = 0x3f, 432 433 OP_LDIL = 0x08, 434 OP_ADDIL = 0x0a, 435 436 OP_LDO = 0x0d, 437 OP_LDB = 0x10, 438 OP_LDH = 0x11, 439 OP_LDW = 0x12, 440 OP_LDWM = 0x13, 441 OP_STB = 0x18, 442 OP_STH = 0x19, 443 OP_STW = 0x1a, 444 OP_STWM = 0x1b, 445 446 OP_LDD = 0x14, 447 OP_STD = 0x1c, 448 449 OP_FLDW = 0x16, 450 OP_LDWL = 0x17, 451 OP_FSTW = 0x1e, 452 OP_STWL = 0x1f, 453 454 OP_COMBT = 0x20, 455 OP_COMIBT = 0x21, 456 OP_COMBF = 0x22, 457 OP_COMIBF = 0x23, 458 OP_CMPBDT = 0x27, 459 OP_ADDBT = 0x28, 460 OP_ADDIBT = 0x29, 461 OP_ADDBF = 0x2a, 462 OP_ADDIBF = 0x2b, 463 OP_CMPBDF = 0x2f, 464 OP_BVB = 0x30, 465 OP_BB = 0x31, 466 OP_MOVB = 0x32, 467 OP_MOVIB = 0x33, 468 OP_CMPIBD = 0x3b, 469 470 OP_COMICLR = 0x24, 471 OP_SUBI = 0x25, 472 OP_ADDIT = 0x2c, 473 OP_ADDI = 0x2d, 474 475 OP_BE = 0x38, 476 OP_BLE = 0x39, 477 OP_BL = 0x3a 478 }; 479 480 481 /* Insert VALUE into INSN using R_FORMAT to determine exactly what 482 bits to change. */ 483 484 static inline int 485 hppa_rebuild_insn (int insn, int value, int r_format) 486 { 487 switch (r_format) 488 { 489 case 11: 490 return (insn & ~ 0x7ff) | low_sign_unext (value, 11); 491 492 case 12: 493 return (insn & ~ 0x1ffd) | re_assemble_12 (value); 494 495 496 case 10: 497 return (insn & ~ 0x3ff1) | re_assemble_14 (value & -8); 498 499 case -11: 500 return (insn & ~ 0x3ff9) | re_assemble_14 (value & -4); 501 502 case 14: 503 return (insn & ~ 0x3fff) | re_assemble_14 (value); 504 505 506 case -10: 507 return (insn & ~ 0xfff1) | re_assemble_16 (value & -8); 508 509 case -16: 510 return (insn & ~ 0xfff9) | re_assemble_16 (value & -4); 511 512 case 16: 513 return (insn & ~ 0xffff) | re_assemble_16 (value); 514 515 516 case 17: 517 return (insn & ~ 0x1f1ffd) | re_assemble_17 (value); 518 519 case 21: 520 return (insn & ~ 0x1fffff) | re_assemble_21 (value); 521 522 case 22: 523 return (insn & ~ 0x3ff1ffd) | re_assemble_22 (value); 524 525 case 32: 526 return value; 527 528 default: 529 abort (); 530 } 531 return insn; 532 } 533 534 #endif /* _LIBHPPA_H */ 535 /* Table of opcodes for the PA-RISC. 536 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 537 2001, 2002, 2003, 2004, 2005 538 Free Software Foundation, Inc. 539 540 Contributed by the Center for Software Science at the 541 University of Utah (pa-gdb-bugs@cs.utah.edu). 542 543 This file is part of GAS, the GNU Assembler, and GDB, the GNU disassembler. 544 545 GAS/GDB is free software; you can redistribute it and/or modify 546 it under the terms of the GNU General Public License as published by 547 the Free Software Foundation; either version 1, or (at your option) 548 any later version. 549 550 GAS/GDB is distributed in the hope that it will be useful, 551 but WITHOUT ANY WARRANTY; without even the implied warranty of 552 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 553 GNU General Public License for more details. 554 555 You should have received a copy of the GNU General Public License 556 along with GAS or GDB; see the file COPYING. 557 If not, see <http://www.gnu.org/licenses/>. */ 558 559 #if !defined(__STDC__) && !defined(const) 560 #define const 561 #endif 562 563 /* 564 * Structure of an opcode table entry. 565 */ 566 567 /* There are two kinds of delay slot nullification: normal which is 568 * controlled by the nullification bit, and conditional, which depends 569 * on the direction of the branch and its success or failure. 570 * 571 * NONE is unfortunately #defined in the hiux system include files. 572 * #undef it away. 573 */ 574 #undef NONE 575 struct pa_opcode 576 { 577 const char *name; 578 unsigned long int match; /* Bits that must be set... */ 579 unsigned long int mask; /* ... in these bits. */ 580 const char *args; 581 enum pa_arch arch; 582 char flags; 583 }; 584 585 /* Enables strict matching. Opcodes with match errors are skipped 586 when this bit is set. */ 587 #define FLAG_STRICT 0x1 588 589 /* 590 All hppa opcodes are 32 bits. 591 592 The match component is a mask saying which bits must match a 593 particular opcode in order for an instruction to be an instance 594 of that opcode. 595 596 The args component is a string containing one character for each operand of 597 the instruction. Characters used as a prefix allow any second character to 598 be used without conflicting with the main operand characters. 599 600 Bit positions in this description follow HP usage of lsb = 31, 601 "at" is lsb of field. 602 603 In the args field, the following characters must match exactly: 604 605 '+,() ' 606 607 In the args field, the following characters are unused: 608 609 ' " - / 34 6789:; ' 610 '@ C M [\] ' 611 '` e g } ' 612 613 Here are all the characters: 614 615 ' !"#$%&'()*+-,./0123456789:;<=>?' 616 '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_' 617 '`abcdefghijklmnopqrstuvwxyz{|}~ ' 618 619 Kinds of operands: 620 x integer register field at 15. 621 b integer register field at 10. 622 t integer register field at 31. 623 a integer register field at 10 and 15 (for PERMH) 624 5 5 bit immediate at 15. 625 s 2 bit space specifier at 17. 626 S 3 bit space specifier at 18. 627 V 5 bit immediate value at 31 628 i 11 bit immediate value at 31 629 j 14 bit immediate value at 31 630 k 21 bit immediate value at 31 631 l 16 bit immediate value at 31 (wide mode only, unusual encoding). 632 n nullification for branch instructions 633 N nullification for spop and copr instructions 634 w 12 bit branch displacement 635 W 17 bit branch displacement (PC relative) 636 X 22 bit branch displacement (PC relative) 637 z 17 bit branch displacement (just a number, not an address) 638 639 Also these: 640 641 . 2 bit shift amount at 25 642 * 4 bit shift amount at 25 643 p 5 bit shift count at 26 (to support the SHD instruction) encoded as 644 31-p 645 ~ 6 bit shift count at 20,22:26 encoded as 63-~. 646 P 5 bit bit position at 26 647 q 6 bit bit position at 20,22:26 648 T 5 bit field length at 31 (encoded as 32-T) 649 % 6 bit field length at 23,27:31 (variable extract/deposit) 650 | 6 bit field length at 19,27:31 (fixed extract/deposit) 651 A 13 bit immediate at 18 (to support the BREAK instruction) 652 ^ like b, but describes a control register 653 ! sar (cr11) register 654 D 26 bit immediate at 31 (to support the DIAG instruction) 655 $ 9 bit immediate at 28 (to support POPBTS) 656 657 v 3 bit Special Function Unit identifier at 25 658 O 20 bit Special Function Unit operation split between 15 bits at 20 659 and 5 bits at 31 660 o 15 bit Special Function Unit operation at 20 661 2 22 bit Special Function Unit operation split between 17 bits at 20 662 and 5 bits at 31 663 1 15 bit Special Function Unit operation split between 10 bits at 20 664 and 5 bits at 31 665 0 10 bit Special Function Unit operation split between 5 bits at 20 666 and 5 bits at 31 667 u 3 bit coprocessor unit identifier at 25 668 F Source Floating Point Operand Format Completer encoded 2 bits at 20 669 I Source Floating Point Operand Format Completer encoded 1 bits at 20 670 (for 0xe format FP instructions) 671 G Destination Floating Point Operand Format Completer encoded 2 bits at 18 672 H Floating Point Operand Format at 26 for 'fmpyadd' and 'fmpysub' 673 (very similar to 'F') 674 675 r 5 bit immediate value at 31 (for the break instruction) 676 (very similar to V above, except the value is unsigned instead of 677 low_sign_ext) 678 R 5 bit immediate value at 15 (for the ssm, rsm, probei instructions) 679 (same as r above, except the value is in a different location) 680 U 10 bit immediate value at 15 (for SSM, RSM on pa2.0) 681 Q 5 bit immediate value at 10 (a bit position specified in 682 the bb instruction. It's the same as r above, except the 683 value is in a different location) 684 B 5 bit immediate value at 10 (a bit position specified in 685 the bb instruction. Similar to Q, but 64 bit handling is 686 different. 687 Z %r1 -- implicit target of addil instruction. 688 L ,%r2 completer for new syntax branch 689 { Source format completer for fcnv 690 _ Destination format completer for fcnv 691 h cbit for fcmp 692 = gfx tests for ftest 693 d 14 bit offset for single precision FP long load/store. 694 # 14 bit offset for double precision FP load long/store. 695 J Yet another 14 bit offset for load/store with ma,mb completers. 696 K Yet another 14 bit offset for load/store with ma,mb completers. 697 y 16 bit offset for word aligned load/store (PA2.0 wide). 698 & 16 bit offset for dword aligned load/store (PA2.0 wide). 699 < 16 bit offset for load/store with ma,mb completers (PA2.0 wide). 700 > 16 bit offset for load/store with ma,mb completers (PA2.0 wide). 701 Y %sr0,%r31 -- implicit target of be,l instruction. 702 @ implicit immediate value of 0 703 704 Completer operands all have 'c' as the prefix: 705 706 cx indexed load and store completer. 707 cX indexed load and store completer. Like cx, but emits a space 708 after in disassembler. 709 cm short load and store completer. 710 cM short load and store completer. Like cm, but emits a space 711 after in disassembler. 712 cq long load and store completer (like cm, but inserted into a 713 different location in the target instruction). 714 cs store bytes short completer. 715 cA store bytes short completer. Like cs, but emits a space 716 after in disassembler. 717 ce long load/store completer for LDW/STW with a different encoding 718 than the others 719 cc load cache control hint 720 cd load and clear cache control hint 721 cC store cache control hint 722 co ordered access 723 724 cp branch link and push completer 725 cP branch pop completer 726 cl branch link completer 727 cg branch gate completer 728 729 cw read/write completer for PROBE 730 cW wide completer for MFCTL 731 cL local processor completer for cache control 732 cZ System Control Completer (to support LPA, LHA, etc.) 733 734 ci correction completer for DCOR 735 ca add completer 736 cy 32 bit add carry completer 737 cY 64 bit add carry completer 738 cv signed overflow trap completer 739 ct trap on condition completer for ADDI, SUB 740 cT trap on condition completer for UADDCM 741 cb 32 bit borrow completer for SUB 742 cB 64 bit borrow completer for SUB 743 744 ch left/right half completer 745 cH signed/unsigned saturation completer 746 cS signed/unsigned completer at 21 747 cz zero/sign extension completer. 748 c* permutation completer 749 750 Condition operands all have '?' as the prefix: 751 752 ?f Floating point compare conditions (encoded as 5 bits at 31) 753 754 ?a add conditions 755 ?A 64 bit add conditions 756 ?@ add branch conditions followed by nullify 757 ?d non-negated add branch conditions 758 ?D negated add branch conditions 759 ?w wide mode non-negated add branch conditions 760 ?W wide mode negated add branch conditions 761 762 ?s compare/subtract conditions 763 ?S 64 bit compare/subtract conditions 764 ?t non-negated compare and branch conditions 765 ?n 32 bit compare and branch conditions followed by nullify 766 ?N 64 bit compare and branch conditions followed by nullify 767 ?Q 64 bit compare and branch conditions for CMPIB instruction 768 769 ?l logical conditions 770 ?L 64 bit logical conditions 771 772 ?b branch on bit conditions 773 ?B 64 bit branch on bit conditions 774 775 ?x shift/extract/deposit conditions 776 ?X 64 bit shift/extract/deposit conditions 777 ?y shift/extract/deposit conditions followed by nullify for conditional 778 branches 779 780 ?u unit conditions 781 ?U 64 bit unit conditions 782 783 Floating point registers all have 'f' as a prefix: 784 785 ft target register at 31 786 fT target register with L/R halves at 31 787 fa operand 1 register at 10 788 fA operand 1 register with L/R halves at 10 789 fX Same as fA, except prints a space before register during disasm 790 fb operand 2 register at 15 791 fB operand 2 register with L/R halves at 15 792 fC operand 3 register with L/R halves at 16:18,21:23 793 fe Like fT, but encoding is different. 794 fE Same as fe, except prints a space before register during disasm. 795 fx target register at 15 (only for PA 2.0 long format FLDD/FSTD). 796 797 Float registers for fmpyadd and fmpysub: 798 799 fi mult operand 1 register at 10 800 fj mult operand 2 register at 15 801 fk mult target register at 20 802 fl add/sub operand register at 25 803 fm add/sub target register at 31 804 805 */ 806 807 808 #if 0 809 /* List of characters not to put a space after. Note that 810 "," is included, as the "spopN" operations use literal 811 commas in their completer sections. */ 812 static const char *const completer_chars = ",CcY<>?!@+&U~FfGHINnOoZMadu|/=0123%e$m}"; 813 #endif 814 815 /* The order of the opcodes in this table is significant: 816 817 * The assembler requires that all instances of the same mnemonic be 818 consecutive. If they aren't, the assembler will bomb at runtime. 819 820 * Immediate fields use pa_get_absolute_expression to parse the 821 string. It will generate a "bad expression" error if passed 822 a register name. Thus, register index variants of an opcode 823 need to precede immediate variants. 824 825 * The disassembler does not care about the order of the opcodes 826 except in cases where implicit addressing is used. 827 828 Here are the rules for ordering the opcodes of a mnemonic: 829 830 1) Opcodes with FLAG_STRICT should precede opcodes without 831 FLAG_STRICT. 832 833 2) Opcodes with FLAG_STRICT should be ordered as follows: 834 register index opcodes, short immediate opcodes, and finally 835 long immediate opcodes. When both pa10 and pa11 variants 836 of the same opcode are available, the pa10 opcode should 837 come first for correct architectural promotion. 838 839 3) When implicit addressing is available for an opcode, the 840 implicit opcode should precede the explicit opcode. 841 842 4) Opcodes without FLAG_STRICT should be ordered as follows: 843 register index opcodes, long immediate opcodes, and finally 844 short immediate opcodes. */ 845 846 static const struct pa_opcode pa_opcodes[] = 847 { 848 849 /* Pseudo-instructions. */ 850 851 { "ldi", 0x34000000, 0xffe00000, "l,x", pa20w, 0},/* ldo val(r0),r */ 852 { "ldi", 0x34000000, 0xffe0c000, "j,x", pa10, 0},/* ldo val(r0),r */ 853 854 { "cmpib", 0xec000000, 0xfc000000, "?Qn5,b,w", pa20, FLAG_STRICT}, 855 { "cmpib", 0x84000000, 0xf4000000, "?nn5,b,w", pa10, FLAG_STRICT}, 856 { "comib", 0x84000000, 0xfc000000, "?nn5,b,w", pa10, 0}, /* comib{tf}*/ 857 /* This entry is for the disassembler only. It will never be used by 858 assembler. */ 859 { "comib", 0x8c000000, 0xfc000000, "?nn5,b,w", pa10, 0}, /* comib{tf}*/ 860 { "cmpb", 0x9c000000, 0xdc000000, "?Nnx,b,w", pa20, FLAG_STRICT}, 861 { "cmpb", 0x80000000, 0xf4000000, "?nnx,b,w", pa10, FLAG_STRICT}, 862 { "comb", 0x80000000, 0xfc000000, "?nnx,b,w", pa10, 0}, /* comb{tf} */ 863 /* This entry is for the disassembler only. It will never be used by 864 assembler. */ 865 { "comb", 0x88000000, 0xfc000000, "?nnx,b,w", pa10, 0}, /* comb{tf} */ 866 { "addb", 0xa0000000, 0xf4000000, "?Wnx,b,w", pa20w, FLAG_STRICT}, 867 { "addb", 0xa0000000, 0xfc000000, "?@nx,b,w", pa10, 0}, /* addb{tf} */ 868 /* This entry is for the disassembler only. It will never be used by 869 assembler. */ 870 { "addb", 0xa8000000, 0xfc000000, "?@nx,b,w", pa10, 0}, 871 { "addib", 0xa4000000, 0xf4000000, "?Wn5,b,w", pa20w, FLAG_STRICT}, 872 { "addib", 0xa4000000, 0xfc000000, "?@n5,b,w", pa10, 0}, /* addib{tf}*/ 873 /* This entry is for the disassembler only. It will never be used by 874 assembler. */ 875 { "addib", 0xac000000, 0xfc000000, "?@n5,b,w", pa10, 0}, /* addib{tf}*/ 876 { "nop", 0x08000240, 0xffffffff, "", pa10, 0}, /* or 0,0,0 */ 877 { "copy", 0x08000240, 0xffe0ffe0, "x,t", pa10, 0}, /* or r,0,t */ 878 { "mtsar", 0x01601840, 0xffe0ffff, "x", pa10, 0}, /* mtctl r,cr11 */ 879 880 /* Loads and Stores for integer registers. */ 881 882 { "ldd", 0x0c0000c0, 0xfc00d3c0, "cxccx(b),t", pa20, FLAG_STRICT}, 883 { "ldd", 0x0c0000c0, 0xfc0013c0, "cxccx(s,b),t", pa20, FLAG_STRICT}, 884 { "ldd", 0x0c0010e0, 0xfc1ff3e0, "cocc@(b),t", pa20, FLAG_STRICT}, 885 { "ldd", 0x0c0010e0, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT}, 886 { "ldd", 0x0c0010c0, 0xfc00d3c0, "cmcc5(b),t", pa20, FLAG_STRICT}, 887 { "ldd", 0x0c0010c0, 0xfc0013c0, "cmcc5(s,b),t", pa20, FLAG_STRICT}, 888 { "ldd", 0x50000000, 0xfc000002, "cq&(b),x", pa20w, FLAG_STRICT}, 889 { "ldd", 0x50000000, 0xfc00c002, "cq#(b),x", pa20, FLAG_STRICT}, 890 { "ldd", 0x50000000, 0xfc000002, "cq#(s,b),x", pa20, FLAG_STRICT}, 891 { "ldw", 0x0c000080, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 892 { "ldw", 0x0c000080, 0xfc001fc0, "cXx(s,b),t", pa10, FLAG_STRICT}, 893 { "ldw", 0x0c000080, 0xfc00d3c0, "cxccx(b),t", pa11, FLAG_STRICT}, 894 { "ldw", 0x0c000080, 0xfc0013c0, "cxccx(s,b),t", pa11, FLAG_STRICT}, 895 { "ldw", 0x0c0010a0, 0xfc1ff3e0, "cocc@(b),t", pa20, FLAG_STRICT}, 896 { "ldw", 0x0c0010a0, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT}, 897 { "ldw", 0x0c001080, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 898 { "ldw", 0x0c001080, 0xfc001fc0, "cM5(s,b),t", pa10, FLAG_STRICT}, 899 { "ldw", 0x0c001080, 0xfc00d3c0, "cmcc5(b),t", pa11, FLAG_STRICT}, 900 { "ldw", 0x0c001080, 0xfc0013c0, "cmcc5(s,b),t", pa11, FLAG_STRICT}, 901 { "ldw", 0x4c000000, 0xfc000000, "ce<(b),x", pa20w, FLAG_STRICT}, 902 { "ldw", 0x5c000004, 0xfc000006, "ce>(b),x", pa20w, FLAG_STRICT}, 903 { "ldw", 0x48000000, 0xfc000000, "l(b),x", pa20w, FLAG_STRICT}, 904 { "ldw", 0x5c000004, 0xfc00c006, "ceK(b),x", pa20, FLAG_STRICT}, 905 { "ldw", 0x5c000004, 0xfc000006, "ceK(s,b),x", pa20, FLAG_STRICT}, 906 { "ldw", 0x4c000000, 0xfc00c000, "ceJ(b),x", pa10, FLAG_STRICT}, 907 { "ldw", 0x4c000000, 0xfc000000, "ceJ(s,b),x", pa10, FLAG_STRICT}, 908 { "ldw", 0x48000000, 0xfc00c000, "j(b),x", pa10, 0}, 909 { "ldw", 0x48000000, 0xfc000000, "j(s,b),x", pa10, 0}, 910 { "ldh", 0x0c000040, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 911 { "ldh", 0x0c000040, 0xfc001fc0, "cXx(s,b),t", pa10, FLAG_STRICT}, 912 { "ldh", 0x0c000040, 0xfc00d3c0, "cxccx(b),t", pa11, FLAG_STRICT}, 913 { "ldh", 0x0c000040, 0xfc0013c0, "cxccx(s,b),t", pa11, FLAG_STRICT}, 914 { "ldh", 0x0c001060, 0xfc1ff3e0, "cocc@(b),t", pa20, FLAG_STRICT}, 915 { "ldh", 0x0c001060, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT}, 916 { "ldh", 0x0c001040, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 917 { "ldh", 0x0c001040, 0xfc001fc0, "cM5(s,b),t", pa10, FLAG_STRICT}, 918 { "ldh", 0x0c001040, 0xfc00d3c0, "cmcc5(b),t", pa11, FLAG_STRICT}, 919 { "ldh", 0x0c001040, 0xfc0013c0, "cmcc5(s,b),t", pa11, FLAG_STRICT}, 920 { "ldh", 0x44000000, 0xfc000000, "l(b),x", pa20w, FLAG_STRICT}, 921 { "ldh", 0x44000000, 0xfc00c000, "j(b),x", pa10, 0}, 922 { "ldh", 0x44000000, 0xfc000000, "j(s,b),x", pa10, 0}, 923 { "ldb", 0x0c000000, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 924 { "ldb", 0x0c000000, 0xfc001fc0, "cXx(s,b),t", pa10, FLAG_STRICT}, 925 { "ldb", 0x0c000000, 0xfc00d3c0, "cxccx(b),t", pa11, FLAG_STRICT}, 926 { "ldb", 0x0c000000, 0xfc0013c0, "cxccx(s,b),t", pa11, FLAG_STRICT}, 927 { "ldb", 0x0c001020, 0xfc1ff3e0, "cocc@(b),t", pa20, FLAG_STRICT}, 928 { "ldb", 0x0c001020, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT}, 929 { "ldb", 0x0c001000, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 930 { "ldb", 0x0c001000, 0xfc001fc0, "cM5(s,b),t", pa10, FLAG_STRICT}, 931 { "ldb", 0x0c001000, 0xfc00d3c0, "cmcc5(b),t", pa11, FLAG_STRICT}, 932 { "ldb", 0x0c001000, 0xfc0013c0, "cmcc5(s,b),t", pa11, FLAG_STRICT}, 933 { "ldb", 0x40000000, 0xfc000000, "l(b),x", pa20w, FLAG_STRICT}, 934 { "ldb", 0x40000000, 0xfc00c000, "j(b),x", pa10, 0}, 935 { "ldb", 0x40000000, 0xfc000000, "j(s,b),x", pa10, 0}, 936 { "std", 0x0c0012e0, 0xfc00f3ff, "cocCx,@(b)", pa20, FLAG_STRICT}, 937 { "std", 0x0c0012e0, 0xfc0033ff, "cocCx,@(s,b)", pa20, FLAG_STRICT}, 938 { "std", 0x0c0012c0, 0xfc00d3c0, "cmcCx,V(b)", pa20, FLAG_STRICT}, 939 { "std", 0x0c0012c0, 0xfc0013c0, "cmcCx,V(s,b)", pa20, FLAG_STRICT}, 940 { "std", 0x70000000, 0xfc000002, "cqx,&(b)", pa20w, FLAG_STRICT}, 941 { "std", 0x70000000, 0xfc00c002, "cqx,#(b)", pa20, FLAG_STRICT}, 942 { "std", 0x70000000, 0xfc000002, "cqx,#(s,b)", pa20, FLAG_STRICT}, 943 { "stw", 0x0c0012a0, 0xfc00f3ff, "cocCx,@(b)", pa20, FLAG_STRICT}, 944 { "stw", 0x0c0012a0, 0xfc0033ff, "cocCx,@(s,b)", pa20, FLAG_STRICT}, 945 { "stw", 0x0c001280, 0xfc00dfc0, "cMx,V(b)", pa10, FLAG_STRICT}, 946 { "stw", 0x0c001280, 0xfc001fc0, "cMx,V(s,b)", pa10, FLAG_STRICT}, 947 { "stw", 0x0c001280, 0xfc00d3c0, "cmcCx,V(b)", pa11, FLAG_STRICT}, 948 { "stw", 0x0c001280, 0xfc0013c0, "cmcCx,V(s,b)", pa11, FLAG_STRICT}, 949 { "stw", 0x6c000000, 0xfc000000, "cex,<(b)", pa20w, FLAG_STRICT}, 950 { "stw", 0x7c000004, 0xfc000006, "cex,>(b)", pa20w, FLAG_STRICT}, 951 { "stw", 0x68000000, 0xfc000000, "x,l(b)", pa20w, FLAG_STRICT}, 952 { "stw", 0x7c000004, 0xfc00c006, "cex,K(b)", pa20, FLAG_STRICT}, 953 { "stw", 0x7c000004, 0xfc000006, "cex,K(s,b)", pa20, FLAG_STRICT}, 954 { "stw", 0x6c000000, 0xfc00c000, "cex,J(b)", pa10, FLAG_STRICT}, 955 { "stw", 0x6c000000, 0xfc000000, "cex,J(s,b)", pa10, FLAG_STRICT}, 956 { "stw", 0x68000000, 0xfc00c000, "x,j(b)", pa10, 0}, 957 { "stw", 0x68000000, 0xfc000000, "x,j(s,b)", pa10, 0}, 958 { "sth", 0x0c001260, 0xfc00f3ff, "cocCx,@(b)", pa20, FLAG_STRICT}, 959 { "sth", 0x0c001260, 0xfc0033ff, "cocCx,@(s,b)", pa20, FLAG_STRICT}, 960 { "sth", 0x0c001240, 0xfc00dfc0, "cMx,V(b)", pa10, FLAG_STRICT}, 961 { "sth", 0x0c001240, 0xfc001fc0, "cMx,V(s,b)", pa10, FLAG_STRICT}, 962 { "sth", 0x0c001240, 0xfc00d3c0, "cmcCx,V(b)", pa11, FLAG_STRICT}, 963 { "sth", 0x0c001240, 0xfc0013c0, "cmcCx,V(s,b)", pa11, FLAG_STRICT}, 964 { "sth", 0x64000000, 0xfc000000, "x,l(b)", pa20w, FLAG_STRICT}, 965 { "sth", 0x64000000, 0xfc00c000, "x,j(b)", pa10, 0}, 966 { "sth", 0x64000000, 0xfc000000, "x,j(s,b)", pa10, 0}, 967 { "stb", 0x0c001220, 0xfc00f3ff, "cocCx,@(b)", pa20, FLAG_STRICT}, 968 { "stb", 0x0c001220, 0xfc0033ff, "cocCx,@(s,b)", pa20, FLAG_STRICT}, 969 { "stb", 0x0c001200, 0xfc00dfc0, "cMx,V(b)", pa10, FLAG_STRICT}, 970 { "stb", 0x0c001200, 0xfc001fc0, "cMx,V(s,b)", pa10, FLAG_STRICT}, 971 { "stb", 0x0c001200, 0xfc00d3c0, "cmcCx,V(b)", pa11, FLAG_STRICT}, 972 { "stb", 0x0c001200, 0xfc0013c0, "cmcCx,V(s,b)", pa11, FLAG_STRICT}, 973 { "stb", 0x60000000, 0xfc000000, "x,l(b)", pa20w, FLAG_STRICT}, 974 { "stb", 0x60000000, 0xfc00c000, "x,j(b)", pa10, 0}, 975 { "stb", 0x60000000, 0xfc000000, "x,j(s,b)", pa10, 0}, 976 { "ldwm", 0x4c000000, 0xfc00c000, "j(b),x", pa10, 0}, 977 { "ldwm", 0x4c000000, 0xfc000000, "j(s,b),x", pa10, 0}, 978 { "stwm", 0x6c000000, 0xfc00c000, "x,j(b)", pa10, 0}, 979 { "stwm", 0x6c000000, 0xfc000000, "x,j(s,b)", pa10, 0}, 980 { "ldwx", 0x0c000080, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 981 { "ldwx", 0x0c000080, 0xfc001fc0, "cXx(s,b),t", pa10, FLAG_STRICT}, 982 { "ldwx", 0x0c000080, 0xfc00d3c0, "cxccx(b),t", pa11, FLAG_STRICT}, 983 { "ldwx", 0x0c000080, 0xfc0013c0, "cxccx(s,b),t", pa11, FLAG_STRICT}, 984 { "ldwx", 0x0c000080, 0xfc00dfc0, "cXx(b),t", pa10, 0}, 985 { "ldwx", 0x0c000080, 0xfc001fc0, "cXx(s,b),t", pa10, 0}, 986 { "ldhx", 0x0c000040, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 987 { "ldhx", 0x0c000040, 0xfc001fc0, "cXx(s,b),t", pa10, FLAG_STRICT}, 988 { "ldhx", 0x0c000040, 0xfc00d3c0, "cxccx(b),t", pa11, FLAG_STRICT}, 989 { "ldhx", 0x0c000040, 0xfc0013c0, "cxccx(s,b),t", pa11, FLAG_STRICT}, 990 { "ldhx", 0x0c000040, 0xfc00dfc0, "cXx(b),t", pa10, 0}, 991 { "ldhx", 0x0c000040, 0xfc001fc0, "cXx(s,b),t", pa10, 0}, 992 { "ldbx", 0x0c000000, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 993 { "ldbx", 0x0c000000, 0xfc001fc0, "cXx(s,b),t", pa10, FLAG_STRICT}, 994 { "ldbx", 0x0c000000, 0xfc00d3c0, "cxccx(b),t", pa11, FLAG_STRICT}, 995 { "ldbx", 0x0c000000, 0xfc0013c0, "cxccx(s,b),t", pa11, FLAG_STRICT}, 996 { "ldbx", 0x0c000000, 0xfc00dfc0, "cXx(b),t", pa10, 0}, 997 { "ldbx", 0x0c000000, 0xfc001fc0, "cXx(s,b),t", pa10, 0}, 998 { "ldwa", 0x0c000180, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 999 { "ldwa", 0x0c000180, 0xfc00d3c0, "cxccx(b),t", pa11, FLAG_STRICT}, 1000 { "ldwa", 0x0c0011a0, 0xfc1ff3e0, "cocc@(b),t", pa20, FLAG_STRICT}, 1001 { "ldwa", 0x0c001180, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 1002 { "ldwa", 0x0c001180, 0xfc00d3c0, "cmcc5(b),t", pa11, FLAG_STRICT}, 1003 { "ldcw", 0x0c0001c0, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 1004 { "ldcw", 0x0c0001c0, 0xfc001fc0, "cXx(s,b),t", pa10, FLAG_STRICT}, 1005 { "ldcw", 0x0c0001c0, 0xfc00d3c0, "cxcdx(b),t", pa11, FLAG_STRICT}, 1006 { "ldcw", 0x0c0001c0, 0xfc0013c0, "cxcdx(s,b),t", pa11, FLAG_STRICT}, 1007 { "ldcw", 0x0c0011c0, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 1008 { "ldcw", 0x0c0011c0, 0xfc001fc0, "cM5(s,b),t", pa10, FLAG_STRICT}, 1009 { "ldcw", 0x0c0011c0, 0xfc00d3c0, "cmcd5(b),t", pa11, FLAG_STRICT}, 1010 { "ldcw", 0x0c0011c0, 0xfc0013c0, "cmcd5(s,b),t", pa11, FLAG_STRICT}, 1011 { "stwa", 0x0c0013a0, 0xfc00d3ff, "cocCx,@(b)", pa20, FLAG_STRICT}, 1012 { "stwa", 0x0c001380, 0xfc00dfc0, "cMx,V(b)", pa10, FLAG_STRICT}, 1013 { "stwa", 0x0c001380, 0xfc00d3c0, "cmcCx,V(b)", pa11, FLAG_STRICT}, 1014 { "stby", 0x0c001300, 0xfc00dfc0, "cAx,V(b)", pa10, FLAG_STRICT}, 1015 { "stby", 0x0c001300, 0xfc001fc0, "cAx,V(s,b)", pa10, FLAG_STRICT}, 1016 { "stby", 0x0c001300, 0xfc00d3c0, "cscCx,V(b)", pa11, FLAG_STRICT}, 1017 { "stby", 0x0c001300, 0xfc0013c0, "cscCx,V(s,b)", pa11, FLAG_STRICT}, 1018 { "ldda", 0x0c000100, 0xfc00d3c0, "cxccx(b),t", pa20, FLAG_STRICT}, 1019 { "ldda", 0x0c001120, 0xfc1ff3e0, "cocc@(b),t", pa20, FLAG_STRICT}, 1020 { "ldda", 0x0c001100, 0xfc00d3c0, "cmcc5(b),t", pa20, FLAG_STRICT}, 1021 { "ldcd", 0x0c000140, 0xfc00d3c0, "cxcdx(b),t", pa20, FLAG_STRICT}, 1022 { "ldcd", 0x0c000140, 0xfc0013c0, "cxcdx(s,b),t", pa20, FLAG_STRICT}, 1023 { "ldcd", 0x0c001140, 0xfc00d3c0, "cmcd5(b),t", pa20, FLAG_STRICT}, 1024 { "ldcd", 0x0c001140, 0xfc0013c0, "cmcd5(s,b),t", pa20, FLAG_STRICT}, 1025 { "stda", 0x0c0013e0, 0xfc00f3ff, "cocCx,@(b)", pa20, FLAG_STRICT}, 1026 { "stda", 0x0c0013c0, 0xfc00d3c0, "cmcCx,V(b)", pa20, FLAG_STRICT}, 1027 { "ldwax", 0x0c000180, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 1028 { "ldwax", 0x0c000180, 0xfc00d3c0, "cxccx(b),t", pa11, FLAG_STRICT}, 1029 { "ldwax", 0x0c000180, 0xfc00dfc0, "cXx(b),t", pa10, 0}, 1030 { "ldcwx", 0x0c0001c0, 0xfc00dfc0, "cXx(b),t", pa10, FLAG_STRICT}, 1031 { "ldcwx", 0x0c0001c0, 0xfc001fc0, "cXx(s,b),t", pa10, FLAG_STRICT}, 1032 { "ldcwx", 0x0c0001c0, 0xfc00d3c0, "cxcdx(b),t", pa11, FLAG_STRICT}, 1033 { "ldcwx", 0x0c0001c0, 0xfc0013c0, "cxcdx(s,b),t", pa11, FLAG_STRICT}, 1034 { "ldcwx", 0x0c0001c0, 0xfc00dfc0, "cXx(b),t", pa10, 0}, 1035 { "ldcwx", 0x0c0001c0, 0xfc001fc0, "cXx(s,b),t", pa10, 0}, 1036 { "ldws", 0x0c001080, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 1037 { "ldws", 0x0c001080, 0xfc001fc0, "cM5(s,b),t", pa10, FLAG_STRICT}, 1038 { "ldws", 0x0c001080, 0xfc00d3c0, "cmcc5(b),t", pa11, FLAG_STRICT}, 1039 { "ldws", 0x0c001080, 0xfc0013c0, "cmcc5(s,b),t", pa11, FLAG_STRICT}, 1040 { "ldws", 0x0c001080, 0xfc00dfc0, "cM5(b),t", pa10, 0}, 1041 { "ldws", 0x0c001080, 0xfc001fc0, "cM5(s,b),t", pa10, 0}, 1042 { "ldhs", 0x0c001040, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 1043 { "ldhs", 0x0c001040, 0xfc001fc0, "cM5(s,b),t", pa10, FLAG_STRICT}, 1044 { "ldhs", 0x0c001040, 0xfc00d3c0, "cmcc5(b),t", pa11, FLAG_STRICT}, 1045 { "ldhs", 0x0c001040, 0xfc0013c0, "cmcc5(s,b),t", pa11, FLAG_STRICT}, 1046 { "ldhs", 0x0c001040, 0xfc00dfc0, "cM5(b),t", pa10, 0}, 1047 { "ldhs", 0x0c001040, 0xfc001fc0, "cM5(s,b),t", pa10, 0}, 1048 { "ldbs", 0x0c001000, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 1049 { "ldbs", 0x0c001000, 0xfc001fc0, "cM5(s,b),t", pa10, FLAG_STRICT}, 1050 { "ldbs", 0x0c001000, 0xfc00d3c0, "cmcc5(b),t", pa11, FLAG_STRICT}, 1051 { "ldbs", 0x0c001000, 0xfc0013c0, "cmcc5(s,b),t", pa11, FLAG_STRICT}, 1052 { "ldbs", 0x0c001000, 0xfc00dfc0, "cM5(b),t", pa10, 0}, 1053 { "ldbs", 0x0c001000, 0xfc001fc0, "cM5(s,b),t", pa10, 0}, 1054 { "ldwas", 0x0c001180, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 1055 { "ldwas", 0x0c001180, 0xfc00d3c0, "cmcc5(b),t", pa11, FLAG_STRICT}, 1056 { "ldwas", 0x0c001180, 0xfc00dfc0, "cM5(b),t", pa10, 0}, 1057 { "ldcws", 0x0c0011c0, 0xfc00dfc0, "cM5(b),t", pa10, FLAG_STRICT}, 1058 { "ldcws", 0x0c0011c0, 0xfc001fc0, "cM5(s,b),t", pa10, FLAG_STRICT}, 1059 { "ldcws", 0x0c0011c0, 0xfc00d3c0, "cmcd5(b),t", pa11, FLAG_STRICT}, 1060 { "ldcws", 0x0c0011c0, 0xfc0013c0, "cmcd5(s,b),t", pa11, FLAG_STRICT}, 1061 { "ldcws", 0x0c0011c0, 0xfc00dfc0, "cM5(b),t", pa10, 0}, 1062 { "ldcws", 0x0c0011c0, 0xfc001fc0, "cM5(s,b),t", pa10, 0}, 1063 { "stws", 0x0c001280, 0xfc00dfc0, "cMx,V(b)", pa10, FLAG_STRICT}, 1064 { "stws", 0x0c001280, 0xfc001fc0, "cMx,V(s,b)", pa10, FLAG_STRICT}, 1065 { "stws", 0x0c001280, 0xfc00d3c0, "cmcCx,V(b)", pa11, FLAG_STRICT}, 1066 { "stws", 0x0c001280, 0xfc0013c0, "cmcCx,V(s,b)", pa11, FLAG_STRICT}, 1067 { "stws", 0x0c001280, 0xfc00dfc0, "cMx,V(b)", pa10, 0}, 1068 { "stws", 0x0c001280, 0xfc001fc0, "cMx,V(s,b)", pa10, 0}, 1069 { "sths", 0x0c001240, 0xfc00dfc0, "cMx,V(b)", pa10, FLAG_STRICT}, 1070 { "sths", 0x0c001240, 0xfc001fc0, "cMx,V(s,b)", pa10, FLAG_STRICT}, 1071 { "sths", 0x0c001240, 0xfc00d3c0, "cmcCx,V(b)", pa11, FLAG_STRICT}, 1072 { "sths", 0x0c001240, 0xfc0013c0, "cmcCx,V(s,b)", pa11, FLAG_STRICT}, 1073 { "sths", 0x0c001240, 0xfc00dfc0, "cMx,V(b)", pa10, 0}, 1074 { "sths", 0x0c001240, 0xfc001fc0, "cMx,V(s,b)", pa10, 0}, 1075 { "stbs", 0x0c001200, 0xfc00dfc0, "cMx,V(b)", pa10, FLAG_STRICT}, 1076 { "stbs", 0x0c001200, 0xfc001fc0, "cMx,V(s,b)", pa10, FLAG_STRICT}, 1077 { "stbs", 0x0c001200, 0xfc00d3c0, "cmcCx,V(b)", pa11, FLAG_STRICT}, 1078 { "stbs", 0x0c001200, 0xfc0013c0, "cmcCx,V(s,b)", pa11, FLAG_STRICT}, 1079 { "stbs", 0x0c001200, 0xfc00dfc0, "cMx,V(b)", pa10, 0}, 1080 { "stbs", 0x0c001200, 0xfc001fc0, "cMx,V(s,b)", pa10, 0}, 1081 { "stwas", 0x0c001380, 0xfc00dfc0, "cMx,V(b)", pa10, FLAG_STRICT}, 1082 { "stwas", 0x0c001380, 0xfc00d3c0, "cmcCx,V(b)", pa11, FLAG_STRICT}, 1083 { "stwas", 0x0c001380, 0xfc00dfc0, "cMx,V(b)", pa10, 0}, 1084 { "stdby", 0x0c001340, 0xfc00d3c0, "cscCx,V(b)", pa20, FLAG_STRICT}, 1085 { "stdby", 0x0c001340, 0xfc0013c0, "cscCx,V(s,b)", pa20, FLAG_STRICT}, 1086 { "stbys", 0x0c001300, 0xfc00dfc0, "cAx,V(b)", pa10, FLAG_STRICT}, 1087 { "stbys", 0x0c001300, 0xfc001fc0, "cAx,V(s,b)", pa10, FLAG_STRICT}, 1088 { "stbys", 0x0c001300, 0xfc00d3c0, "cscCx,V(b)", pa11, FLAG_STRICT}, 1089 { "stbys", 0x0c001300, 0xfc0013c0, "cscCx,V(s,b)", pa11, FLAG_STRICT}, 1090 { "stbys", 0x0c001300, 0xfc00dfc0, "cAx,V(b)", pa10, 0}, 1091 { "stbys", 0x0c001300, 0xfc001fc0, "cAx,V(s,b)", pa10, 0}, 1092 1093 /* Immediate instructions. */ 1094 { "ldo", 0x34000000, 0xfc000000, "l(b),x", pa20w, 0}, 1095 { "ldo", 0x34000000, 0xfc00c000, "j(b),x", pa10, 0}, 1096 { "ldil", 0x20000000, 0xfc000000, "k,b", pa10, 0}, 1097 { "addil", 0x28000000, 0xfc000000, "k,b,Z", pa10, 0}, 1098 { "addil", 0x28000000, 0xfc000000, "k,b", pa10, 0}, 1099 1100 /* Branching instructions. */ 1101 { "b", 0xe8008000, 0xfc00e000, "cpnXL", pa20, FLAG_STRICT}, 1102 { "b", 0xe800a000, 0xfc00e000, "clnXL", pa20, FLAG_STRICT}, 1103 { "b", 0xe8000000, 0xfc00e000, "clnW,b", pa10, FLAG_STRICT}, 1104 { "b", 0xe8002000, 0xfc00e000, "cgnW,b", pa10, FLAG_STRICT}, 1105 { "b", 0xe8000000, 0xffe0e000, "nW", pa10, 0}, /* b,l foo,r0 */ 1106 { "bl", 0xe8000000, 0xfc00e000, "nW,b", pa10, 0}, 1107 { "gate", 0xe8002000, 0xfc00e000, "nW,b", pa10, 0}, 1108 { "blr", 0xe8004000, 0xfc00e001, "nx,b", pa10, 0}, 1109 { "bv", 0xe800c000, 0xfc00fffd, "nx(b)", pa10, 0}, 1110 { "bv", 0xe800c000, 0xfc00fffd, "n(b)", pa10, 0}, 1111 { "bve", 0xe800f001, 0xfc1ffffd, "cpn(b)L", pa20, FLAG_STRICT}, 1112 { "bve", 0xe800f000, 0xfc1ffffd, "cln(b)L", pa20, FLAG_STRICT}, 1113 { "bve", 0xe800d001, 0xfc1ffffd, "cPn(b)", pa20, FLAG_STRICT}, 1114 { "bve", 0xe800d000, 0xfc1ffffd, "n(b)", pa20, FLAG_STRICT}, 1115 { "be", 0xe4000000, 0xfc000000, "clnz(S,b),Y", pa10, FLAG_STRICT}, 1116 { "be", 0xe4000000, 0xfc000000, "clnz(b),Y", pa10, FLAG_STRICT}, 1117 { "be", 0xe0000000, 0xfc000000, "nz(S,b)", pa10, 0}, 1118 { "be", 0xe0000000, 0xfc000000, "nz(b)", pa10, 0}, 1119 { "ble", 0xe4000000, 0xfc000000, "nz(S,b)", pa10, 0}, 1120 { "movb", 0xc8000000, 0xfc000000, "?ynx,b,w", pa10, 0}, 1121 { "movib", 0xcc000000, 0xfc000000, "?yn5,b,w", pa10, 0}, 1122 { "combt", 0x80000000, 0xfc000000, "?tnx,b,w", pa10, 0}, 1123 { "combf", 0x88000000, 0xfc000000, "?tnx,b,w", pa10, 0}, 1124 { "comibt", 0x84000000, 0xfc000000, "?tn5,b,w", pa10, 0}, 1125 { "comibf", 0x8c000000, 0xfc000000, "?tn5,b,w", pa10, 0}, 1126 { "addbt", 0xa0000000, 0xfc000000, "?dnx,b,w", pa10, 0}, 1127 { "addbf", 0xa8000000, 0xfc000000, "?dnx,b,w", pa10, 0}, 1128 { "addibt", 0xa4000000, 0xfc000000, "?dn5,b,w", pa10, 0}, 1129 { "addibf", 0xac000000, 0xfc000000, "?dn5,b,w", pa10, 0}, 1130 { "bb", 0xc0004000, 0xffe06000, "?bnx,!,w", pa10, FLAG_STRICT}, 1131 { "bb", 0xc0006000, 0xffe06000, "?Bnx,!,w", pa20, FLAG_STRICT}, 1132 { "bb", 0xc4004000, 0xfc006000, "?bnx,Q,w", pa10, FLAG_STRICT}, 1133 { "bb", 0xc4004000, 0xfc004000, "?Bnx,B,w", pa20, FLAG_STRICT}, 1134 { "bvb", 0xc0004000, 0xffe04000, "?bnx,w", pa10, 0}, 1135 { "clrbts", 0xe8004005, 0xffffffff, "", pa20, FLAG_STRICT}, 1136 { "popbts", 0xe8004005, 0xfffff007, "$", pa20, FLAG_STRICT}, 1137 { "pushnom", 0xe8004001, 0xffffffff, "", pa20, FLAG_STRICT}, 1138 { "pushbts", 0xe8004001, 0xffe0ffff, "x", pa20, FLAG_STRICT}, 1139 1140 /* Computation Instructions. */ 1141 1142 { "cmpclr", 0x080008a0, 0xfc000fe0, "?Sx,b,t", pa20, FLAG_STRICT}, 1143 { "cmpclr", 0x08000880, 0xfc000fe0, "?sx,b,t", pa10, FLAG_STRICT}, 1144 { "comclr", 0x08000880, 0xfc000fe0, "?sx,b,t", pa10, 0}, 1145 { "or", 0x08000260, 0xfc000fe0, "?Lx,b,t", pa20, FLAG_STRICT}, 1146 { "or", 0x08000240, 0xfc000fe0, "?lx,b,t", pa10, 0}, 1147 { "xor", 0x080002a0, 0xfc000fe0, "?Lx,b,t", pa20, FLAG_STRICT}, 1148 { "xor", 0x08000280, 0xfc000fe0, "?lx,b,t", pa10, 0}, 1149 { "and", 0x08000220, 0xfc000fe0, "?Lx,b,t", pa20, FLAG_STRICT}, 1150 { "and", 0x08000200, 0xfc000fe0, "?lx,b,t", pa10, 0}, 1151 { "andcm", 0x08000020, 0xfc000fe0, "?Lx,b,t", pa20, FLAG_STRICT}, 1152 { "andcm", 0x08000000, 0xfc000fe0, "?lx,b,t", pa10, 0}, 1153 { "uxor", 0x080003a0, 0xfc000fe0, "?Ux,b,t", pa20, FLAG_STRICT}, 1154 { "uxor", 0x08000380, 0xfc000fe0, "?ux,b,t", pa10, 0}, 1155 { "uaddcm", 0x080009a0, 0xfc000fa0, "cT?Ux,b,t", pa20, FLAG_STRICT}, 1156 { "uaddcm", 0x08000980, 0xfc000fa0, "cT?ux,b,t", pa10, FLAG_STRICT}, 1157 { "uaddcm", 0x08000980, 0xfc000fe0, "?ux,b,t", pa10, 0}, 1158 { "uaddcmt", 0x080009c0, 0xfc000fe0, "?ux,b,t", pa10, 0}, 1159 { "dcor", 0x08000ba0, 0xfc1f0fa0, "ci?Ub,t", pa20, FLAG_STRICT}, 1160 { "dcor", 0x08000b80, 0xfc1f0fa0, "ci?ub,t", pa10, FLAG_STRICT}, 1161 { "dcor", 0x08000b80, 0xfc1f0fe0, "?ub,t", pa10, 0}, 1162 { "idcor", 0x08000bc0, 0xfc1f0fe0, "?ub,t", pa10, 0}, 1163 { "addi", 0xb0000000, 0xfc000000, "ct?ai,b,x", pa10, FLAG_STRICT}, 1164 { "addi", 0xb4000000, 0xfc000000, "cv?ai,b,x", pa10, FLAG_STRICT}, 1165 { "addi", 0xb4000000, 0xfc000800, "?ai,b,x", pa10, 0}, 1166 { "addio", 0xb4000800, 0xfc000800, "?ai,b,x", pa10, 0}, 1167 { "addit", 0xb0000000, 0xfc000800, "?ai,b,x", pa10, 0}, 1168 { "addito", 0xb0000800, 0xfc000800, "?ai,b,x", pa10, 0}, 1169 { "add", 0x08000720, 0xfc0007e0, "cY?Ax,b,t", pa20, FLAG_STRICT}, 1170 { "add", 0x08000700, 0xfc0007e0, "cy?ax,b,t", pa10, FLAG_STRICT}, 1171 { "add", 0x08000220, 0xfc0003e0, "ca?Ax,b,t", pa20, FLAG_STRICT}, 1172 { "add", 0x08000200, 0xfc0003e0, "ca?ax,b,t", pa10, FLAG_STRICT}, 1173 { "add", 0x08000600, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1174 { "addl", 0x08000a00, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1175 { "addo", 0x08000e00, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1176 { "addc", 0x08000700, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1177 { "addco", 0x08000f00, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1178 { "sub", 0x080004e0, 0xfc0007e0, "ct?Sx,b,t", pa20, FLAG_STRICT}, 1179 { "sub", 0x080004c0, 0xfc0007e0, "ct?sx,b,t", pa10, FLAG_STRICT}, 1180 { "sub", 0x08000520, 0xfc0007e0, "cB?Sx,b,t", pa20, FLAG_STRICT}, 1181 { "sub", 0x08000500, 0xfc0007e0, "cb?sx,b,t", pa10, FLAG_STRICT}, 1182 { "sub", 0x08000420, 0xfc0007e0, "cv?Sx,b,t", pa20, FLAG_STRICT}, 1183 { "sub", 0x08000400, 0xfc0007e0, "cv?sx,b,t", pa10, FLAG_STRICT}, 1184 { "sub", 0x08000400, 0xfc000fe0, "?sx,b,t", pa10, 0}, 1185 { "subo", 0x08000c00, 0xfc000fe0, "?sx,b,t", pa10, 0}, 1186 { "subb", 0x08000500, 0xfc000fe0, "?sx,b,t", pa10, 0}, 1187 { "subbo", 0x08000d00, 0xfc000fe0, "?sx,b,t", pa10, 0}, 1188 { "subt", 0x080004c0, 0xfc000fe0, "?sx,b,t", pa10, 0}, 1189 { "subto", 0x08000cc0, 0xfc000fe0, "?sx,b,t", pa10, 0}, 1190 { "ds", 0x08000440, 0xfc000fe0, "?sx,b,t", pa10, 0}, 1191 { "subi", 0x94000000, 0xfc000000, "cv?si,b,x", pa10, FLAG_STRICT}, 1192 { "subi", 0x94000000, 0xfc000800, "?si,b,x", pa10, 0}, 1193 { "subio", 0x94000800, 0xfc000800, "?si,b,x", pa10, 0}, 1194 { "cmpiclr", 0x90000800, 0xfc000800, "?Si,b,x", pa20, FLAG_STRICT}, 1195 { "cmpiclr", 0x90000000, 0xfc000800, "?si,b,x", pa10, FLAG_STRICT}, 1196 { "comiclr", 0x90000000, 0xfc000800, "?si,b,x", pa10, 0}, 1197 { "shladd", 0x08000220, 0xfc000320, "ca?Ax,.,b,t", pa20, FLAG_STRICT}, 1198 { "shladd", 0x08000200, 0xfc000320, "ca?ax,.,b,t", pa10, FLAG_STRICT}, 1199 { "sh1add", 0x08000640, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1200 { "sh1addl", 0x08000a40, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1201 { "sh1addo", 0x08000e40, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1202 { "sh2add", 0x08000680, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1203 { "sh2addl", 0x08000a80, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1204 { "sh2addo", 0x08000e80, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1205 { "sh3add", 0x080006c0, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1206 { "sh3addl", 0x08000ac0, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1207 { "sh3addo", 0x08000ec0, 0xfc000fe0, "?ax,b,t", pa10, 0}, 1208 1209 /* Subword Operation Instructions. */ 1210 1211 { "hadd", 0x08000300, 0xfc00ff20, "cHx,b,t", pa20, FLAG_STRICT}, 1212 { "havg", 0x080002c0, 0xfc00ffe0, "x,b,t", pa20, FLAG_STRICT}, 1213 { "hshl", 0xf8008800, 0xffe0fc20, "x,*,t", pa20, FLAG_STRICT}, 1214 { "hshladd", 0x08000700, 0xfc00ff20, "x,.,b,t", pa20, FLAG_STRICT}, 1215 { "hshr", 0xf800c800, 0xfc1ff820, "cSb,*,t", pa20, FLAG_STRICT}, 1216 { "hshradd", 0x08000500, 0xfc00ff20, "x,.,b,t", pa20, FLAG_STRICT}, 1217 { "hsub", 0x08000100, 0xfc00ff20, "cHx,b,t", pa20, FLAG_STRICT}, 1218 { "mixh", 0xf8008400, 0xfc009fe0, "chx,b,t", pa20, FLAG_STRICT}, 1219 { "mixw", 0xf8008000, 0xfc009fe0, "chx,b,t", pa20, FLAG_STRICT}, 1220 { "permh", 0xf8000000, 0xfc009020, "c*a,t", pa20, FLAG_STRICT}, 1221 1222 1223 /* Extract and Deposit Instructions. */ 1224 1225 { "shrpd", 0xd0000200, 0xfc001fe0, "?Xx,b,!,t", pa20, FLAG_STRICT}, 1226 { "shrpd", 0xd0000400, 0xfc001400, "?Xx,b,~,t", pa20, FLAG_STRICT}, 1227 { "shrpw", 0xd0000000, 0xfc001fe0, "?xx,b,!,t", pa10, FLAG_STRICT}, 1228 { "shrpw", 0xd0000800, 0xfc001c00, "?xx,b,p,t", pa10, FLAG_STRICT}, 1229 { "vshd", 0xd0000000, 0xfc001fe0, "?xx,b,t", pa10, 0}, 1230 { "shd", 0xd0000800, 0xfc001c00, "?xx,b,p,t", pa10, 0}, 1231 { "extrd", 0xd0001200, 0xfc001ae0, "cS?Xb,!,%,x", pa20, FLAG_STRICT}, 1232 { "extrd", 0xd8000000, 0xfc000000, "cS?Xb,q,|,x", pa20, FLAG_STRICT}, 1233 { "extrw", 0xd0001000, 0xfc001be0, "cS?xb,!,T,x", pa10, FLAG_STRICT}, 1234 { "extrw", 0xd0001800, 0xfc001800, "cS?xb,P,T,x", pa10, FLAG_STRICT}, 1235 { "vextru", 0xd0001000, 0xfc001fe0, "?xb,T,x", pa10, 0}, 1236 { "vextrs", 0xd0001400, 0xfc001fe0, "?xb,T,x", pa10, 0}, 1237 { "extru", 0xd0001800, 0xfc001c00, "?xb,P,T,x", pa10, 0}, 1238 { "extrs", 0xd0001c00, 0xfc001c00, "?xb,P,T,x", pa10, 0}, 1239 { "depd", 0xd4000200, 0xfc001ae0, "cz?Xx,!,%,b", pa20, FLAG_STRICT}, 1240 { "depd", 0xf0000000, 0xfc000000, "cz?Xx,~,|,b", pa20, FLAG_STRICT}, 1241 { "depdi", 0xd4001200, 0xfc001ae0, "cz?X5,!,%,b", pa20, FLAG_STRICT}, 1242 { "depdi", 0xf4000000, 0xfc000000, "cz?X5,~,|,b", pa20, FLAG_STRICT}, 1243 { "depw", 0xd4000000, 0xfc001be0, "cz?xx,!,T,b", pa10, FLAG_STRICT}, 1244 { "depw", 0xd4000800, 0xfc001800, "cz?xx,p,T,b", pa10, FLAG_STRICT}, 1245 { "depwi", 0xd4001000, 0xfc001be0, "cz?x5,!,T,b", pa10, FLAG_STRICT}, 1246 { "depwi", 0xd4001800, 0xfc001800, "cz?x5,p,T,b", pa10, FLAG_STRICT}, 1247 { "zvdep", 0xd4000000, 0xfc001fe0, "?xx,T,b", pa10, 0}, 1248 { "vdep", 0xd4000400, 0xfc001fe0, "?xx,T,b", pa10, 0}, 1249 { "zdep", 0xd4000800, 0xfc001c00, "?xx,p,T,b", pa10, 0}, 1250 { "dep", 0xd4000c00, 0xfc001c00, "?xx,p,T,b", pa10, 0}, 1251 { "zvdepi", 0xd4001000, 0xfc001fe0, "?x5,T,b", pa10, 0}, 1252 { "vdepi", 0xd4001400, 0xfc001fe0, "?x5,T,b", pa10, 0}, 1253 { "zdepi", 0xd4001800, 0xfc001c00, "?x5,p,T,b", pa10, 0}, 1254 { "depi", 0xd4001c00, 0xfc001c00, "?x5,p,T,b", pa10, 0}, 1255 1256 /* System Control Instructions. */ 1257 1258 { "break", 0x00000000, 0xfc001fe0, "r,A", pa10, 0}, 1259 { "rfi", 0x00000c00, 0xffffff1f, "cr", pa10, FLAG_STRICT}, 1260 { "rfi", 0x00000c00, 0xffffffff, "", pa10, 0}, 1261 { "rfir", 0x00000ca0, 0xffffffff, "", pa11, 0}, 1262 { "ssm", 0x00000d60, 0xfc00ffe0, "U,t", pa20, FLAG_STRICT}, 1263 { "ssm", 0x00000d60, 0xffe0ffe0, "R,t", pa10, 0}, 1264 { "rsm", 0x00000e60, 0xfc00ffe0, "U,t", pa20, FLAG_STRICT}, 1265 { "rsm", 0x00000e60, 0xffe0ffe0, "R,t", pa10, 0}, 1266 { "mtsm", 0x00001860, 0xffe0ffff, "x", pa10, 0}, 1267 { "ldsid", 0x000010a0, 0xfc1fffe0, "(b),t", pa10, 0}, 1268 { "ldsid", 0x000010a0, 0xfc1f3fe0, "(s,b),t", pa10, 0}, 1269 { "mtsp", 0x00001820, 0xffe01fff, "x,S", pa10, 0}, 1270 { "mtctl", 0x00001840, 0xfc00ffff, "x,^", pa10, 0}, 1271 { "mtsarcm", 0x016018C0, 0xffe0ffff, "x", pa20, FLAG_STRICT}, 1272 { "mfia", 0x000014A0, 0xffffffe0, "t", pa20, FLAG_STRICT}, 1273 { "mfsp", 0x000004a0, 0xffff1fe0, "S,t", pa10, 0}, 1274 { "mfctl", 0x016048a0, 0xffffffe0, "cW!,t", pa20, FLAG_STRICT}, 1275 { "mfctl", 0x000008a0, 0xfc1fffe0, "^,t", pa10, 0}, 1276 { "sync", 0x00000400, 0xffffffff, "", pa10, 0}, 1277 { "syncdma", 0x00100400, 0xffffffff, "", pa10, 0}, 1278 { "probe", 0x04001180, 0xfc00ffa0, "cw(b),x,t", pa10, FLAG_STRICT}, 1279 { "probe", 0x04001180, 0xfc003fa0, "cw(s,b),x,t", pa10, FLAG_STRICT}, 1280 { "probei", 0x04003180, 0xfc00ffa0, "cw(b),R,t", pa10, FLAG_STRICT}, 1281 { "probei", 0x04003180, 0xfc003fa0, "cw(s,b),R,t", pa10, FLAG_STRICT}, 1282 { "prober", 0x04001180, 0xfc00ffe0, "(b),x,t", pa10, 0}, 1283 { "prober", 0x04001180, 0xfc003fe0, "(s,b),x,t", pa10, 0}, 1284 { "proberi", 0x04003180, 0xfc00ffe0, "(b),R,t", pa10, 0}, 1285 { "proberi", 0x04003180, 0xfc003fe0, "(s,b),R,t", pa10, 0}, 1286 { "probew", 0x040011c0, 0xfc00ffe0, "(b),x,t", pa10, 0}, 1287 { "probew", 0x040011c0, 0xfc003fe0, "(s,b),x,t", pa10, 0}, 1288 { "probewi", 0x040031c0, 0xfc00ffe0, "(b),R,t", pa10, 0}, 1289 { "probewi", 0x040031c0, 0xfc003fe0, "(s,b),R,t", pa10, 0}, 1290 { "lpa", 0x04001340, 0xfc00ffc0, "cZx(b),t", pa10, 0}, 1291 { "lpa", 0x04001340, 0xfc003fc0, "cZx(s,b),t", pa10, 0}, 1292 { "lci", 0x04001300, 0xfc00ffe0, "x(b),t", pa11, 0}, 1293 { "lci", 0x04001300, 0xfc003fe0, "x(s,b),t", pa11, 0}, 1294 { "pdtlb", 0x04001600, 0xfc00ffdf, "cLcZx(b)", pa20, FLAG_STRICT}, 1295 { "pdtlb", 0x04001600, 0xfc003fdf, "cLcZx(s,b)", pa20, FLAG_STRICT}, 1296 { "pdtlb", 0x04001600, 0xfc1fffdf, "cLcZ@(b)", pa20, FLAG_STRICT}, 1297 { "pdtlb", 0x04001600, 0xfc1f3fdf, "cLcZ@(s,b)", pa20, FLAG_STRICT}, 1298 { "pdtlb", 0x04001200, 0xfc00ffdf, "cZx(b)", pa10, 0}, 1299 { "pdtlb", 0x04001200, 0xfc003fdf, "cZx(s,b)", pa10, 0}, 1300 { "pitlb", 0x04000600, 0xfc001fdf, "cLcZx(S,b)", pa20, FLAG_STRICT}, 1301 { "pitlb", 0x04000600, 0xfc1f1fdf, "cLcZ@(S,b)", pa20, FLAG_STRICT}, 1302 { "pitlb", 0x04000200, 0xfc001fdf, "cZx(S,b)", pa10, 0}, 1303 { "pdtlbe", 0x04001240, 0xfc00ffdf, "cZx(b)", pa10, 0}, 1304 { "pdtlbe", 0x04001240, 0xfc003fdf, "cZx(s,b)", pa10, 0}, 1305 { "pitlbe", 0x04000240, 0xfc001fdf, "cZx(S,b)", pa10, 0}, 1306 { "idtlba", 0x04001040, 0xfc00ffff, "x,(b)", pa10, 0}, 1307 { "idtlba", 0x04001040, 0xfc003fff, "x,(s,b)", pa10, 0}, 1308 { "iitlba", 0x04000040, 0xfc001fff, "x,(S,b)", pa10, 0}, 1309 { "idtlbp", 0x04001000, 0xfc00ffff, "x,(b)", pa10, 0}, 1310 { "idtlbp", 0x04001000, 0xfc003fff, "x,(s,b)", pa10, 0}, 1311 { "iitlbp", 0x04000000, 0xfc001fff, "x,(S,b)", pa10, 0}, 1312 { "pdc", 0x04001380, 0xfc00ffdf, "cZx(b)", pa10, 0}, 1313 { "pdc", 0x04001380, 0xfc003fdf, "cZx(s,b)", pa10, 0}, 1314 { "fdc", 0x04001280, 0xfc00ffdf, "cZx(b)", pa10, FLAG_STRICT}, 1315 { "fdc", 0x04001280, 0xfc003fdf, "cZx(s,b)", pa10, FLAG_STRICT}, 1316 { "fdc", 0x04003280, 0xfc00ffff, "5(b)", pa20, FLAG_STRICT}, 1317 { "fdc", 0x04003280, 0xfc003fff, "5(s,b)", pa20, FLAG_STRICT}, 1318 { "fdc", 0x04001280, 0xfc00ffdf, "cZx(b)", pa10, 0}, 1319 { "fdc", 0x04001280, 0xfc003fdf, "cZx(s,b)", pa10, 0}, 1320 { "fic", 0x040013c0, 0xfc00dfdf, "cZx(b)", pa20, FLAG_STRICT}, 1321 { "fic", 0x04000280, 0xfc001fdf, "cZx(S,b)", pa10, 0}, 1322 { "fdce", 0x040012c0, 0xfc00ffdf, "cZx(b)", pa10, 0}, 1323 { "fdce", 0x040012c0, 0xfc003fdf, "cZx(s,b)", pa10, 0}, 1324 { "fice", 0x040002c0, 0xfc001fdf, "cZx(S,b)", pa10, 0}, 1325 { "diag", 0x14000000, 0xfc000000, "D", pa10, 0}, 1326 { "idtlbt", 0x04001800, 0xfc00ffff, "x,b", pa20, FLAG_STRICT}, 1327 { "iitlbt", 0x04000800, 0xfc00ffff, "x,b", pa20, FLAG_STRICT}, 1328 1329 /* These may be specific to certain versions of the PA. Joel claimed 1330 they were 72000 (7200?) specific. However, I'm almost certain the 1331 mtcpu/mfcpu were undocumented, but available in the older 700 machines. */ 1332 { "mtcpu", 0x14001600, 0xfc00ffff, "x,^", pa10, 0}, 1333 { "mfcpu", 0x14001A00, 0xfc00ffff, "^,x", pa10, 0}, 1334 { "tocen", 0x14403600, 0xffffffff, "", pa10, 0}, 1335 { "tocdis", 0x14401620, 0xffffffff, "", pa10, 0}, 1336 { "shdwgr", 0x14402600, 0xffffffff, "", pa10, 0}, 1337 { "grshdw", 0x14400620, 0xffffffff, "", pa10, 0}, 1338 1339 /* gfw and gfr are not in the HP PA 1.1 manual, but they are in either 1340 the Timex FPU or the Mustang ERS (not sure which) manual. */ 1341 { "gfw", 0x04001680, 0xfc00ffdf, "cZx(b)", pa11, 0}, 1342 { "gfw", 0x04001680, 0xfc003fdf, "cZx(s,b)", pa11, 0}, 1343 { "gfr", 0x04001a80, 0xfc00ffdf, "cZx(b)", pa11, 0}, 1344 { "gfr", 0x04001a80, 0xfc003fdf, "cZx(s,b)", pa11, 0}, 1345 1346 /* Floating Point Coprocessor Instructions. */ 1347 1348 { "fldw", 0x24000000, 0xfc00df80, "cXx(b),fT", pa10, FLAG_STRICT}, 1349 { "fldw", 0x24000000, 0xfc001f80, "cXx(s,b),fT", pa10, FLAG_STRICT}, 1350 { "fldw", 0x24000000, 0xfc00d380, "cxccx(b),fT", pa11, FLAG_STRICT}, 1351 { "fldw", 0x24000000, 0xfc001380, "cxccx(s,b),fT", pa11, FLAG_STRICT}, 1352 { "fldw", 0x24001020, 0xfc1ff3a0, "cocc@(b),fT", pa20, FLAG_STRICT}, 1353 { "fldw", 0x24001020, 0xfc1f33a0, "cocc@(s,b),fT", pa20, FLAG_STRICT}, 1354 { "fldw", 0x24001000, 0xfc00df80, "cM5(b),fT", pa10, FLAG_STRICT}, 1355 { "fldw", 0x24001000, 0xfc001f80, "cM5(s,b),fT", pa10, FLAG_STRICT}, 1356 { "fldw", 0x24001000, 0xfc00d380, "cmcc5(b),fT", pa11, FLAG_STRICT}, 1357 { "fldw", 0x24001000, 0xfc001380, "cmcc5(s,b),fT", pa11, FLAG_STRICT}, 1358 { "fldw", 0x5c000000, 0xfc000004, "y(b),fe", pa20w, FLAG_STRICT}, 1359 { "fldw", 0x58000000, 0xfc000000, "cJy(b),fe", pa20w, FLAG_STRICT}, 1360 { "fldw", 0x5c000000, 0xfc00c004, "d(b),fe", pa20, FLAG_STRICT}, 1361 { "fldw", 0x5c000000, 0xfc000004, "d(s,b),fe", pa20, FLAG_STRICT}, 1362 { "fldw", 0x58000000, 0xfc00c000, "cJd(b),fe", pa20, FLAG_STRICT}, 1363 { "fldw", 0x58000000, 0xfc000000, "cJd(s,b),fe", pa20, FLAG_STRICT}, 1364 { "fldd", 0x2c000000, 0xfc00dfc0, "cXx(b),ft", pa10, FLAG_STRICT}, 1365 { "fldd", 0x2c000000, 0xfc001fc0, "cXx(s,b),ft", pa10, FLAG_STRICT}, 1366 { "fldd", 0x2c000000, 0xfc00d3c0, "cxccx(b),ft", pa11, FLAG_STRICT}, 1367 { "fldd", 0x2c000000, 0xfc0013c0, "cxccx(s,b),ft", pa11, FLAG_STRICT}, 1368 { "fldd", 0x2c001020, 0xfc1ff3e0, "cocc@(b),ft", pa20, FLAG_STRICT}, 1369 { "fldd", 0x2c001020, 0xfc1f33e0, "cocc@(s,b),ft", pa20, FLAG_STRICT}, 1370 { "fldd", 0x2c001000, 0xfc00dfc0, "cM5(b),ft", pa10, FLAG_STRICT}, 1371 { "fldd", 0x2c001000, 0xfc001fc0, "cM5(s,b),ft", pa10, FLAG_STRICT}, 1372 { "fldd", 0x2c001000, 0xfc00d3c0, "cmcc5(b),ft", pa11, FLAG_STRICT}, 1373 { "fldd", 0x2c001000, 0xfc0013c0, "cmcc5(s,b),ft", pa11, FLAG_STRICT}, 1374 { "fldd", 0x50000002, 0xfc000002, "cq&(b),fx", pa20w, FLAG_STRICT}, 1375 { "fldd", 0x50000002, 0xfc00c002, "cq#(b),fx", pa20, FLAG_STRICT}, 1376 { "fldd", 0x50000002, 0xfc000002, "cq#(s,b),fx", pa20, FLAG_STRICT}, 1377 { "fstw", 0x24000200, 0xfc00df80, "cXfT,x(b)", pa10, FLAG_STRICT}, 1378 { "fstw", 0x24000200, 0xfc001f80, "cXfT,x(s,b)", pa10, FLAG_STRICT}, 1379 { "fstw", 0x24000200, 0xfc00d380, "cxcCfT,x(b)", pa11, FLAG_STRICT}, 1380 { "fstw", 0x24000200, 0xfc001380, "cxcCfT,x(s,b)", pa11, FLAG_STRICT}, 1381 { "fstw", 0x24001220, 0xfc1ff3a0, "cocCfT,@(b)", pa20, FLAG_STRICT}, 1382 { "fstw", 0x24001220, 0xfc1f33a0, "cocCfT,@(s,b)", pa20, FLAG_STRICT}, 1383 { "fstw", 0x24001200, 0xfc00df80, "cMfT,5(b)", pa10, FLAG_STRICT}, 1384 { "fstw", 0x24001200, 0xfc001f80, "cMfT,5(s,b)", pa10, FLAG_STRICT}, 1385 { "fstw", 0x24001200, 0xfc00df80, "cMfT,5(b)", pa10, FLAG_STRICT}, 1386 { "fstw", 0x24001200, 0xfc001f80, "cMfT,5(s,b)", pa10, FLAG_STRICT}, 1387 { "fstw", 0x7c000000, 0xfc000004, "fE,y(b)", pa20w, FLAG_STRICT}, 1388 { "fstw", 0x78000000, 0xfc000000, "cJfE,y(b)", pa20w, FLAG_STRICT}, 1389 { "fstw", 0x7c000000, 0xfc00c004, "fE,d(b)", pa20, FLAG_STRICT}, 1390 { "fstw", 0x7c000000, 0xfc000004, "fE,d(s,b)", pa20, FLAG_STRICT}, 1391 { "fstw", 0x78000000, 0xfc00c000, "cJfE,d(b)", pa20, FLAG_STRICT}, 1392 { "fstw", 0x78000000, 0xfc000000, "cJfE,d(s,b)", pa20, FLAG_STRICT}, 1393 { "fstd", 0x2c000200, 0xfc00dfc0, "cXft,x(b)", pa10, FLAG_STRICT}, 1394 { "fstd", 0x2c000200, 0xfc001fc0, "cXft,x(s,b)", pa10, FLAG_STRICT}, 1395 { "fstd", 0x2c000200, 0xfc00d3c0, "cxcCft,x(b)", pa11, FLAG_STRICT}, 1396 { "fstd", 0x2c000200, 0xfc0013c0, "cxcCft,x(s,b)", pa11, FLAG_STRICT}, 1397 { "fstd", 0x2c001220, 0xfc1ff3e0, "cocCft,@(b)", pa20, FLAG_STRICT}, 1398 { "fstd", 0x2c001220, 0xfc1f33e0, "cocCft,@(s,b)", pa20, FLAG_STRICT}, 1399 { "fstd", 0x2c001200, 0xfc00dfc0, "cMft,5(b)", pa10, FLAG_STRICT}, 1400 { "fstd", 0x2c001200, 0xfc001fc0, "cMft,5(s,b)", pa10, FLAG_STRICT}, 1401 { "fstd", 0x2c001200, 0xfc00d3c0, "cmcCft,5(b)", pa11, FLAG_STRICT}, 1402 { "fstd", 0x2c001200, 0xfc0013c0, "cmcCft,5(s,b)", pa11, FLAG_STRICT}, 1403 { "fstd", 0x70000002, 0xfc000002, "cqfx,&(b)", pa20w, FLAG_STRICT}, 1404 { "fstd", 0x70000002, 0xfc00c002, "cqfx,#(b)", pa20, FLAG_STRICT}, 1405 { "fstd", 0x70000002, 0xfc000002, "cqfx,#(s,b)", pa20, FLAG_STRICT}, 1406 { "fldwx", 0x24000000, 0xfc00df80, "cXx(b),fT", pa10, FLAG_STRICT}, 1407 { "fldwx", 0x24000000, 0xfc001f80, "cXx(s,b),fT", pa10, FLAG_STRICT}, 1408 { "fldwx", 0x24000000, 0xfc00d380, "cxccx(b),fT", pa11, FLAG_STRICT}, 1409 { "fldwx", 0x24000000, 0xfc001380, "cxccx(s,b),fT", pa11, FLAG_STRICT}, 1410 { "fldwx", 0x24000000, 0xfc00df80, "cXx(b),fT", pa10, 0}, 1411 { "fldwx", 0x24000000, 0xfc001f80, "cXx(s,b),fT", pa10, 0}, 1412 { "flddx", 0x2c000000, 0xfc00dfc0, "cXx(b),ft", pa10, FLAG_STRICT}, 1413 { "flddx", 0x2c000000, 0xfc001fc0, "cXx(s,b),ft", pa10, FLAG_STRICT}, 1414 { "flddx", 0x2c000000, 0xfc00d3c0, "cxccx(b),ft", pa11, FLAG_STRICT}, 1415 { "flddx", 0x2c000000, 0xfc0013c0, "cxccx(s,b),ft", pa11, FLAG_STRICT}, 1416 { "flddx", 0x2c000000, 0xfc00dfc0, "cXx(b),ft", pa10, 0}, 1417 { "flddx", 0x2c000000, 0xfc001fc0, "cXx(s,b),ft", pa10, 0}, 1418 { "fstwx", 0x24000200, 0xfc00df80, "cxfT,x(b)", pa10, FLAG_STRICT}, 1419 { "fstwx", 0x24000200, 0xfc001f80, "cxfT,x(s,b)", pa10, FLAG_STRICT}, 1420 { "fstwx", 0x24000200, 0xfc00d380, "cxcCfT,x(b)", pa11, FLAG_STRICT}, 1421 { "fstwx", 0x24000200, 0xfc001380, "cxcCfT,x(s,b)", pa11, FLAG_STRICT}, 1422 { "fstwx", 0x24000200, 0xfc00df80, "cxfT,x(b)", pa10, 0}, 1423 { "fstwx", 0x24000200, 0xfc001f80, "cxfT,x(s,b)", pa10, 0}, 1424 { "fstdx", 0x2c000200, 0xfc00dfc0, "cxft,x(b)", pa10, FLAG_STRICT}, 1425 { "fstdx", 0x2c000200, 0xfc001fc0, "cxft,x(s,b)", pa10, FLAG_STRICT}, 1426 { "fstdx", 0x2c000200, 0xfc00d3c0, "cxcCft,x(b)", pa11, FLAG_STRICT}, 1427 { "fstdx", 0x2c000200, 0xfc0013c0, "cxcCft,x(s,b)", pa11, FLAG_STRICT}, 1428 { "fstdx", 0x2c000200, 0xfc00dfc0, "cxft,x(b)", pa10, 0}, 1429 { "fstdx", 0x2c000200, 0xfc001fc0, "cxft,x(s,b)", pa10, 0}, 1430 { "fstqx", 0x3c000200, 0xfc00dfc0, "cxft,x(b)", pa10, 0}, 1431 { "fstqx", 0x3c000200, 0xfc001fc0, "cxft,x(s,b)", pa10, 0}, 1432 { "fldws", 0x24001000, 0xfc00df80, "cm5(b),fT", pa10, FLAG_STRICT}, 1433 { "fldws", 0x24001000, 0xfc001f80, "cm5(s,b),fT", pa10, FLAG_STRICT}, 1434 { "fldws", 0x24001000, 0xfc00d380, "cmcc5(b),fT", pa11, FLAG_STRICT}, 1435 { "fldws", 0x24001000, 0xfc001380, "cmcc5(s,b),fT", pa11, FLAG_STRICT}, 1436 { "fldws", 0x24001000, 0xfc00df80, "cm5(b),fT", pa10, 0}, 1437 { "fldws", 0x24001000, 0xfc001f80, "cm5(s,b),fT", pa10, 0}, 1438 { "fldds", 0x2c001000, 0xfc00dfc0, "cm5(b),ft", pa10, FLAG_STRICT}, 1439 { "fldds", 0x2c001000, 0xfc001fc0, "cm5(s,b),ft", pa10, FLAG_STRICT}, 1440 { "fldds", 0x2c001000, 0xfc00d3c0, "cmcc5(b),ft", pa11, FLAG_STRICT}, 1441 { "fldds", 0x2c001000, 0xfc0013c0, "cmcc5(s,b),ft", pa11, FLAG_STRICT}, 1442 { "fldds", 0x2c001000, 0xfc00dfc0, "cm5(b),ft", pa10, 0}, 1443 { "fldds", 0x2c001000, 0xfc001fc0, "cm5(s,b),ft", pa10, 0}, 1444 { "fstws", 0x24001200, 0xfc00df80, "cmfT,5(b)", pa10, FLAG_STRICT}, 1445 { "fstws", 0x24001200, 0xfc001f80, "cmfT,5(s,b)", pa10, FLAG_STRICT}, 1446 { "fstws", 0x24001200, 0xfc00d380, "cmcCfT,5(b)", pa11, FLAG_STRICT}, 1447 { "fstws", 0x24001200, 0xfc001380, "cmcCfT,5(s,b)", pa11, FLAG_STRICT}, 1448 { "fstws", 0x24001200, 0xfc00df80, "cmfT,5(b)", pa10, 0}, 1449 { "fstws", 0x24001200, 0xfc001f80, "cmfT,5(s,b)", pa10, 0}, 1450 { "fstds", 0x2c001200, 0xfc00dfc0, "cmft,5(b)", pa10, FLAG_STRICT}, 1451 { "fstds", 0x2c001200, 0xfc001fc0, "cmft,5(s,b)", pa10, FLAG_STRICT}, 1452 { "fstds", 0x2c001200, 0xfc00d3c0, "cmcCft,5(b)", pa11, FLAG_STRICT}, 1453 { "fstds", 0x2c001200, 0xfc0013c0, "cmcCft,5(s,b)", pa11, FLAG_STRICT}, 1454 { "fstds", 0x2c001200, 0xfc00dfc0, "cmft,5(b)", pa10, 0}, 1455 { "fstds", 0x2c001200, 0xfc001fc0, "cmft,5(s,b)", pa10, 0}, 1456 { "fstqs", 0x3c001200, 0xfc00dfc0, "cmft,5(b)", pa10, 0}, 1457 { "fstqs", 0x3c001200, 0xfc001fc0, "cmft,5(s,b)", pa10, 0}, 1458 { "fadd", 0x30000600, 0xfc00e7e0, "Ffa,fb,fT", pa10, 0}, 1459 { "fadd", 0x38000600, 0xfc00e720, "IfA,fB,fT", pa10, 0}, 1460 { "fsub", 0x30002600, 0xfc00e7e0, "Ffa,fb,fT", pa10, 0}, 1461 { "fsub", 0x38002600, 0xfc00e720, "IfA,fB,fT", pa10, 0}, 1462 { "fmpy", 0x30004600, 0xfc00e7e0, "Ffa,fb,fT", pa10, 0}, 1463 { "fmpy", 0x38004600, 0xfc00e720, "IfA,fB,fT", pa10, 0}, 1464 { "fdiv", 0x30006600, 0xfc00e7e0, "Ffa,fb,fT", pa10, 0}, 1465 { "fdiv", 0x38006600, 0xfc00e720, "IfA,fB,fT", pa10, 0}, 1466 { "fsqrt", 0x30008000, 0xfc1fe7e0, "Ffa,fT", pa10, 0}, 1467 { "fsqrt", 0x38008000, 0xfc1fe720, "FfA,fT", pa10, 0}, 1468 { "fabs", 0x30006000, 0xfc1fe7e0, "Ffa,fT", pa10, 0}, 1469 { "fabs", 0x38006000, 0xfc1fe720, "FfA,fT", pa10, 0}, 1470 { "frem", 0x30008600, 0xfc00e7e0, "Ffa,fb,fT", pa10, 0}, 1471 { "frem", 0x38008600, 0xfc00e720, "FfA,fB,fT", pa10, 0}, 1472 { "frnd", 0x3000a000, 0xfc1fe7e0, "Ffa,fT", pa10, 0}, 1473 { "frnd", 0x3800a000, 0xfc1fe720, "FfA,fT", pa10, 0}, 1474 { "fcpy", 0x30004000, 0xfc1fe7e0, "Ffa,fT", pa10, 0}, 1475 { "fcpy", 0x38004000, 0xfc1fe720, "FfA,fT", pa10, 0}, 1476 { "fcnvff", 0x30000200, 0xfc1f87e0, "FGfa,fT", pa10, 0}, 1477 { "fcnvff", 0x38000200, 0xfc1f8720, "FGfA,fT", pa10, 0}, 1478 { "fcnvxf", 0x30008200, 0xfc1f87e0, "FGfa,fT", pa10, 0}, 1479 { "fcnvxf", 0x38008200, 0xfc1f8720, "FGfA,fT", pa10, 0}, 1480 { "fcnvfx", 0x30010200, 0xfc1f87e0, "FGfa,fT", pa10, 0}, 1481 { "fcnvfx", 0x38010200, 0xfc1f8720, "FGfA,fT", pa10, 0}, 1482 { "fcnvfxt", 0x30018200, 0xfc1f87e0, "FGfa,fT", pa10, 0}, 1483 { "fcnvfxt", 0x38018200, 0xfc1f8720, "FGfA,fT", pa10, 0}, 1484 { "fmpyfadd", 0xb8000000, 0xfc000020, "IfA,fB,fC,fT", pa20, FLAG_STRICT}, 1485 { "fmpynfadd", 0xb8000020, 0xfc000020, "IfA,fB,fC,fT", pa20, FLAG_STRICT}, 1486 { "fneg", 0x3000c000, 0xfc1fe7e0, "Ffa,fT", pa20, FLAG_STRICT}, 1487 { "fneg", 0x3800c000, 0xfc1fe720, "IfA,fT", pa20, FLAG_STRICT}, 1488 { "fnegabs", 0x3000e000, 0xfc1fe7e0, "Ffa,fT", pa20, FLAG_STRICT}, 1489 { "fnegabs", 0x3800e000, 0xfc1fe720, "IfA,fT", pa20, FLAG_STRICT}, 1490 { "fcnv", 0x30000200, 0xfc1c0720, "{_fa,fT", pa20, FLAG_STRICT}, 1491 { "fcnv", 0x38000200, 0xfc1c0720, "FGfA,fT", pa20, FLAG_STRICT}, 1492 { "fcmp", 0x30000400, 0xfc00e7e0, "F?ffa,fb", pa10, FLAG_STRICT}, 1493 { "fcmp", 0x38000400, 0xfc00e720, "I?ffA,fB", pa10, FLAG_STRICT}, 1494 { "fcmp", 0x30000400, 0xfc0007e0, "F?ffa,fb,h", pa20, FLAG_STRICT}, 1495 { "fcmp", 0x38000400, 0xfc000720, "I?ffA,fB,h", pa20, FLAG_STRICT}, 1496 { "fcmp", 0x30000400, 0xfc00e7e0, "F?ffa,fb", pa10, 0}, 1497 { "fcmp", 0x38000400, 0xfc00e720, "I?ffA,fB", pa10, 0}, 1498 { "xmpyu", 0x38004700, 0xfc00e720, "fX,fB,fT", pa11, 0}, 1499 { "fmpyadd", 0x18000000, 0xfc000000, "Hfi,fj,fk,fl,fm", pa11, 0}, 1500 { "fmpysub", 0x98000000, 0xfc000000, "Hfi,fj,fk,fl,fm", pa11, 0}, 1501 { "ftest", 0x30002420, 0xffffffff, "", pa10, FLAG_STRICT}, 1502 { "ftest", 0x30002420, 0xffffffe0, ",=", pa20, FLAG_STRICT}, 1503 { "ftest", 0x30000420, 0xffff1fff, "m", pa20, FLAG_STRICT}, 1504 { "fid", 0x30000000, 0xffffffff, "", pa11, 0}, 1505 1506 /* Performance Monitor Instructions. */ 1507 1508 { "pmdis", 0x30000280, 0xffffffdf, "N", pa20, FLAG_STRICT}, 1509 { "pmenb", 0x30000680, 0xffffffff, "", pa20, FLAG_STRICT}, 1510 1511 /* Assist Instructions. */ 1512 1513 { "spop0", 0x10000000, 0xfc000600, "v,ON", pa10, 0}, 1514 { "spop1", 0x10000200, 0xfc000600, "v,oNt", pa10, 0}, 1515 { "spop2", 0x10000400, 0xfc000600, "v,1Nb", pa10, 0}, 1516 { "spop3", 0x10000600, 0xfc000600, "v,0Nx,b", pa10, 0}, 1517 { "copr", 0x30000000, 0xfc000000, "u,2N", pa10, 0}, 1518 { "cldw", 0x24000000, 0xfc00de00, "ucXx(b),t", pa10, FLAG_STRICT}, 1519 { "cldw", 0x24000000, 0xfc001e00, "ucXx(s,b),t", pa10, FLAG_STRICT}, 1520 { "cldw", 0x24000000, 0xfc00d200, "ucxccx(b),t", pa11, FLAG_STRICT}, 1521 { "cldw", 0x24000000, 0xfc001200, "ucxccx(s,b),t", pa11, FLAG_STRICT}, 1522 { "cldw", 0x24001000, 0xfc00d200, "ucocc@(b),t", pa20, FLAG_STRICT}, 1523 { "cldw", 0x24001000, 0xfc001200, "ucocc@(s,b),t", pa20, FLAG_STRICT}, 1524 { "cldw", 0x24001000, 0xfc00de00, "ucM5(b),t", pa10, FLAG_STRICT}, 1525 { "cldw", 0x24001000, 0xfc001e00, "ucM5(s,b),t", pa10, FLAG_STRICT}, 1526 { "cldw", 0x24001000, 0xfc00d200, "ucmcc5(b),t", pa11, FLAG_STRICT}, 1527 { "cldw", 0x24001000, 0xfc001200, "ucmcc5(s,b),t", pa11, FLAG_STRICT}, 1528 { "cldd", 0x2c000000, 0xfc00de00, "ucXx(b),t", pa10, FLAG_STRICT}, 1529 { "cldd", 0x2c000000, 0xfc001e00, "ucXx(s,b),t", pa10, FLAG_STRICT}, 1530 { "cldd", 0x2c000000, 0xfc00d200, "ucxccx(b),t", pa11, FLAG_STRICT}, 1531 { "cldd", 0x2c000000, 0xfc001200, "ucxccx(s,b),t", pa11, FLAG_STRICT}, 1532 { "cldd", 0x2c001000, 0xfc00d200, "ucocc@(b),t", pa20, FLAG_STRICT}, 1533 { "cldd", 0x2c001000, 0xfc001200, "ucocc@(s,b),t", pa20, FLAG_STRICT}, 1534 { "cldd", 0x2c001000, 0xfc00de00, "ucM5(b),t", pa10, FLAG_STRICT}, 1535 { "cldd", 0x2c001000, 0xfc001e00, "ucM5(s,b),t", pa10, FLAG_STRICT}, 1536 { "cldd", 0x2c001000, 0xfc00d200, "ucmcc5(b),t", pa11, FLAG_STRICT}, 1537 { "cldd", 0x2c001000, 0xfc001200, "ucmcc5(s,b),t", pa11, FLAG_STRICT}, 1538 { "cstw", 0x24000200, 0xfc00de00, "ucXt,x(b)", pa10, FLAG_STRICT}, 1539 { "cstw", 0x24000200, 0xfc001e00, "ucXt,x(s,b)", pa10, FLAG_STRICT}, 1540 { "cstw", 0x24000200, 0xfc00d200, "ucxcCt,x(b)", pa11, FLAG_STRICT}, 1541 { "cstw", 0x24000200, 0xfc001200, "ucxcCt,x(s,b)", pa11, FLAG_STRICT}, 1542 { "cstw", 0x24001200, 0xfc00d200, "ucocCt,@(b)", pa20, FLAG_STRICT}, 1543 { "cstw", 0x24001200, 0xfc001200, "ucocCt,@(s,b)", pa20, FLAG_STRICT}, 1544 { "cstw", 0x24001200, 0xfc00de00, "ucMt,5(b)", pa10, FLAG_STRICT}, 1545 { "cstw", 0x24001200, 0xfc001e00, "ucMt,5(s,b)", pa10, FLAG_STRICT}, 1546 { "cstw", 0x24001200, 0xfc00d200, "ucmcCt,5(b)", pa11, FLAG_STRICT}, 1547 { "cstw", 0x24001200, 0xfc001200, "ucmcCt,5(s,b)", pa11, FLAG_STRICT}, 1548 { "cstd", 0x2c000200, 0xfc00de00, "ucXt,x(b)", pa10, FLAG_STRICT}, 1549 { "cstd", 0x2c000200, 0xfc001e00, "ucXt,x(s,b)", pa10, FLAG_STRICT}, 1550 { "cstd", 0x2c000200, 0xfc00d200, "ucxcCt,x(b)", pa11, FLAG_STRICT}, 1551 { "cstd", 0x2c000200, 0xfc001200, "ucxcCt,x(s,b)", pa11, FLAG_STRICT}, 1552 { "cstd", 0x2c001200, 0xfc00d200, "ucocCt,@(b)", pa20, FLAG_STRICT}, 1553 { "cstd", 0x2c001200, 0xfc001200, "ucocCt,@(s,b)", pa20, FLAG_STRICT}, 1554 { "cstd", 0x2c001200, 0xfc00de00, "ucMt,5(b)", pa10, FLAG_STRICT}, 1555 { "cstd", 0x2c001200, 0xfc001e00, "ucMt,5(s,b)", pa10, FLAG_STRICT}, 1556 { "cstd", 0x2c001200, 0xfc00d200, "ucmcCt,5(b)", pa11, FLAG_STRICT}, 1557 { "cstd", 0x2c001200, 0xfc001200, "ucmcCt,5(s,b)", pa11, FLAG_STRICT}, 1558 { "cldwx", 0x24000000, 0xfc00de00, "ucXx(b),t", pa10, FLAG_STRICT}, 1559 { "cldwx", 0x24000000, 0xfc001e00, "ucXx(s,b),t", pa10, FLAG_STRICT}, 1560 { "cldwx", 0x24000000, 0xfc00d200, "ucxccx(b),t", pa11, FLAG_STRICT}, 1561 { "cldwx", 0x24000000, 0xfc001200, "ucxccx(s,b),t", pa11, FLAG_STRICT}, 1562 { "cldwx", 0x24000000, 0xfc00de00, "ucXx(b),t", pa10, 0}, 1563 { "cldwx", 0x24000000, 0xfc001e00, "ucXx(s,b),t", pa10, 0}, 1564 { "clddx", 0x2c000000, 0xfc00de00, "ucXx(b),t", pa10, FLAG_STRICT}, 1565 { "clddx", 0x2c000000, 0xfc001e00, "ucXx(s,b),t", pa10, FLAG_STRICT}, 1566 { "clddx", 0x2c000000, 0xfc00d200, "ucxccx(b),t", pa11, FLAG_STRICT}, 1567 { "clddx", 0x2c000000, 0xfc001200, "ucxccx(s,b),t", pa11, FLAG_STRICT}, 1568 { "clddx", 0x2c000000, 0xfc00de00, "ucXx(b),t", pa10, 0}, 1569 { "clddx", 0x2c000000, 0xfc001e00, "ucXx(s,b),t", pa10, 0}, 1570 { "cstwx", 0x24000200, 0xfc00de00, "ucXt,x(b)", pa10, FLAG_STRICT}, 1571 { "cstwx", 0x24000200, 0xfc001e00, "ucXt,x(s,b)", pa10, FLAG_STRICT}, 1572 { "cstwx", 0x24000200, 0xfc00d200, "ucxcCt,x(b)", pa11, FLAG_STRICT}, 1573 { "cstwx", 0x24000200, 0xfc001200, "ucxcCt,x(s,b)", pa11, FLAG_STRICT}, 1574 { "cstwx", 0x24000200, 0xfc00de00, "ucXt,x(b)", pa10, 0}, 1575 { "cstwx", 0x24000200, 0xfc001e00, "ucXt,x(s,b)", pa10, 0}, 1576 { "cstdx", 0x2c000200, 0xfc00de00, "ucXt,x(b)", pa10, FLAG_STRICT}, 1577 { "cstdx", 0x2c000200, 0xfc001e00, "ucXt,x(s,b)", pa10, FLAG_STRICT}, 1578 { "cstdx", 0x2c000200, 0xfc00d200, "ucxcCt,x(b)", pa11, FLAG_STRICT}, 1579 { "cstdx", 0x2c000200, 0xfc001200, "ucxcCt,x(s,b)", pa11, FLAG_STRICT}, 1580 { "cstdx", 0x2c000200, 0xfc00de00, "ucXt,x(b)", pa10, 0}, 1581 { "cstdx", 0x2c000200, 0xfc001e00, "ucXt,x(s,b)", pa10, 0}, 1582 { "cldws", 0x24001000, 0xfc00de00, "ucM5(b),t", pa10, FLAG_STRICT}, 1583 { "cldws", 0x24001000, 0xfc001e00, "ucM5(s,b),t", pa10, FLAG_STRICT}, 1584 { "cldws", 0x24001000, 0xfc00d200, "ucmcc5(b),t", pa11, FLAG_STRICT}, 1585 { "cldws", 0x24001000, 0xfc001200, "ucmcc5(s,b),t", pa11, FLAG_STRICT}, 1586 { "cldws", 0x24001000, 0xfc00de00, "ucM5(b),t", pa10, 0}, 1587 { "cldws", 0x24001000, 0xfc001e00, "ucM5(s,b),t", pa10, 0}, 1588 { "cldds", 0x2c001000, 0xfc00de00, "ucM5(b),t", pa10, FLAG_STRICT}, 1589 { "cldds", 0x2c001000, 0xfc001e00, "ucM5(s,b),t", pa10, FLAG_STRICT}, 1590 { "cldds", 0x2c001000, 0xfc00d200, "ucmcc5(b),t", pa11, FLAG_STRICT}, 1591 { "cldds", 0x2c001000, 0xfc001200, "ucmcc5(s,b),t", pa11, FLAG_STRICT}, 1592 { "cldds", 0x2c001000, 0xfc00de00, "ucM5(b),t", pa10, 0}, 1593 { "cldds", 0x2c001000, 0xfc001e00, "ucM5(s,b),t", pa10, 0}, 1594 { "cstws", 0x24001200, 0xfc00de00, "ucMt,5(b)", pa10, FLAG_STRICT}, 1595 { "cstws", 0x24001200, 0xfc001e00, "ucMt,5(s,b)", pa10, FLAG_STRICT}, 1596 { "cstws", 0x24001200, 0xfc00d200, "ucmcCt,5(b)", pa11, FLAG_STRICT}, 1597 { "cstws", 0x24001200, 0xfc001200, "ucmcCt,5(s,b)", pa11, FLAG_STRICT}, 1598 { "cstws", 0x24001200, 0xfc00de00, "ucMt,5(b)", pa10, 0}, 1599 { "cstws", 0x24001200, 0xfc001e00, "ucMt,5(s,b)", pa10, 0}, 1600 { "cstds", 0x2c001200, 0xfc00de00, "ucMt,5(b)", pa10, FLAG_STRICT}, 1601 { "cstds", 0x2c001200, 0xfc001e00, "ucMt,5(s,b)", pa10, FLAG_STRICT}, 1602 { "cstds", 0x2c001200, 0xfc00d200, "ucmcCt,5(b)", pa11, FLAG_STRICT}, 1603 { "cstds", 0x2c001200, 0xfc001200, "ucmcCt,5(s,b)", pa11, FLAG_STRICT}, 1604 { "cstds", 0x2c001200, 0xfc00de00, "ucMt,5(b)", pa10, 0}, 1605 { "cstds", 0x2c001200, 0xfc001e00, "ucMt,5(s,b)", pa10, 0}, 1606 1607 /* More pseudo instructions which must follow the main table. */ 1608 { "call", 0xe800f000, 0xfc1ffffd, "n(b)", pa20, FLAG_STRICT}, 1609 { "call", 0xe800a000, 0xffe0e000, "nW", pa10, FLAG_STRICT}, 1610 { "ret", 0xe840d000, 0xfffffffd, "n", pa20, FLAG_STRICT}, 1611 1612 }; 1613 1614 #define NUMOPCODES ((sizeof pa_opcodes)/(sizeof pa_opcodes[0])) 1615 1616 /* SKV 12/18/92. Added some denotations for various operands. */ 1617 1618 #define PA_IMM11_AT_31 'i' 1619 #define PA_IMM14_AT_31 'j' 1620 #define PA_IMM21_AT_31 'k' 1621 #define PA_DISP12 'w' 1622 #define PA_DISP17 'W' 1623 1624 #define N_HPPA_OPERAND_FORMATS 5 1625 1626 /* Integer register names, indexed by the numbers which appear in the 1627 opcodes. */ 1628 static const char *const reg_names[] = 1629 { 1630 "flags", "r1", "rp", "r3", "r4", "r5", "r6", "r7", "r8", "r9", 1631 "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18", "r19", 1632 "r20", "r21", "r22", "r23", "r24", "r25", "r26", "dp", "ret0", "ret1", 1633 "sp", "r31" 1634 }; 1635 1636 /* Floating point register names, indexed by the numbers which appear in the 1637 opcodes. */ 1638 static const char *const fp_reg_names[] = 1639 { 1640 "fpsr", "fpe2", "fpe4", "fpe6", 1641 "fr4", "fr5", "fr6", "fr7", "fr8", 1642 "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15", 1643 "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23", 1644 "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31" 1645 }; 1646 1647 typedef unsigned int CORE_ADDR; 1648 1649 /* Get at various relevant fields of an instruction word. */ 1650 1651 #define MASK_5 0x1f 1652 #define MASK_10 0x3ff 1653 #define MASK_11 0x7ff 1654 #define MASK_14 0x3fff 1655 #define MASK_16 0xffff 1656 #define MASK_21 0x1fffff 1657 1658 /* These macros get bit fields using HP's numbering (MSB = 0). */ 1659 1660 #define GET_FIELD(X, FROM, TO) \ 1661 ((X) >> (31 - (TO)) & ((1 << ((TO) - (FROM) + 1)) - 1)) 1662 1663 #define GET_BIT(X, WHICH) \ 1664 GET_FIELD (X, WHICH, WHICH) 1665 1666 /* Some of these have been converted to 2-d arrays because they 1667 consume less storage this way. If the maintenance becomes a 1668 problem, convert them back to const 1-d pointer arrays. */ 1669 static const char *const control_reg[] = 1670 { 1671 "rctr", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7", 1672 "pidr1", "pidr2", "ccr", "sar", "pidr3", "pidr4", 1673 "iva", "eiem", "itmr", "pcsq", "pcoq", "iir", "isr", 1674 "ior", "ipsw", "eirr", "tr0", "tr1", "tr2", "tr3", 1675 "tr4", "tr5", "tr6", "tr7" 1676 }; 1677 1678 static const char *const compare_cond_names[] = 1679 { 1680 "", ",=", ",<", ",<=", ",<<", ",<<=", ",sv", ",od", 1681 ",tr", ",<>", ",>=", ",>", ",>>=", ",>>", ",nsv", ",ev" 1682 }; 1683 static const char *const compare_cond_64_names[] = 1684 { 1685 "", ",*=", ",*<", ",*<=", ",*<<", ",*<<=", ",*sv", ",*od", 1686 ",*tr", ",*<>", ",*>=", ",*>", ",*>>=", ",*>>", ",*nsv", ",*ev" 1687 }; 1688 static const char *const cmpib_cond_64_names[] = 1689 { 1690 ",*<<", ",*=", ",*<", ",*<=", ",*>>=", ",*<>", ",*>=", ",*>" 1691 }; 1692 static const char *const add_cond_names[] = 1693 { 1694 "", ",=", ",<", ",<=", ",nuv", ",znv", ",sv", ",od", 1695 ",tr", ",<>", ",>=", ",>", ",uv", ",vnz", ",nsv", ",ev" 1696 }; 1697 static const char *const add_cond_64_names[] = 1698 { 1699 "", ",*=", ",*<", ",*<=", ",*nuv", ",*znv", ",*sv", ",*od", 1700 ",*tr", ",*<>", ",*>=", ",*>", ",*uv", ",*vnz", ",*nsv", ",*ev" 1701 }; 1702 static const char *const wide_add_cond_names[] = 1703 { 1704 "", ",=", ",<", ",<=", ",nuv", ",*=", ",*<", ",*<=", 1705 ",tr", ",<>", ",>=", ",>", ",uv", ",*<>", ",*>=", ",*>" 1706 }; 1707 static const char *const logical_cond_names[] = 1708 { 1709 "", ",=", ",<", ",<=", 0, 0, 0, ",od", 1710 ",tr", ",<>", ",>=", ",>", 0, 0, 0, ",ev"}; 1711 static const char *const logical_cond_64_names[] = 1712 { 1713 "", ",*=", ",*<", ",*<=", 0, 0, 0, ",*od", 1714 ",*tr", ",*<>", ",*>=", ",*>", 0, 0, 0, ",*ev"}; 1715 static const char *const unit_cond_names[] = 1716 { 1717 "", ",swz", ",sbz", ",shz", ",sdc", ",swc", ",sbc", ",shc", 1718 ",tr", ",nwz", ",nbz", ",nhz", ",ndc", ",nwc", ",nbc", ",nhc" 1719 }; 1720 static const char *const unit_cond_64_names[] = 1721 { 1722 "", ",*swz", ",*sbz", ",*shz", ",*sdc", ",*swc", ",*sbc", ",*shc", 1723 ",*tr", ",*nwz", ",*nbz", ",*nhz", ",*ndc", ",*nwc", ",*nbc", ",*nhc" 1724 }; 1725 static const char *const shift_cond_names[] = 1726 { 1727 "", ",=", ",<", ",od", ",tr", ",<>", ",>=", ",ev" 1728 }; 1729 static const char *const shift_cond_64_names[] = 1730 { 1731 "", ",*=", ",*<", ",*od", ",*tr", ",*<>", ",*>=", ",*ev" 1732 }; 1733 static const char *const bb_cond_64_names[] = 1734 { 1735 ",*<", ",*>=" 1736 }; 1737 static const char *const index_compl_names[] = {"", ",m", ",s", ",sm"}; 1738 static const char *const short_ldst_compl_names[] = {"", ",ma", "", ",mb"}; 1739 static const char *const short_bytes_compl_names[] = 1740 { 1741 "", ",b,m", ",e", ",e,m" 1742 }; 1743 static const char *const float_format_names[] = {",sgl", ",dbl", "", ",quad"}; 1744 static const char *const fcnv_fixed_names[] = {",w", ",dw", "", ",qw"}; 1745 static const char *const fcnv_ufixed_names[] = {",uw", ",udw", "", ",uqw"}; 1746 static const char *const float_comp_names[] = 1747 { 1748 ",false?", ",false", ",?", ",!<=>", ",=", ",=t", ",?=", ",!<>", 1749 ",!?>=", ",<", ",?<", ",!>=", ",!?>", ",<=", ",?<=", ",!>", 1750 ",!?<=", ",>", ",?>", ",!<=", ",!?<", ",>=", ",?>=", ",!<", 1751 ",!?=", ",<>", ",!=", ",!=t", ",!?", ",<=>", ",true?", ",true" 1752 }; 1753 static const char *const signed_unsigned_names[] = {",u", ",s"}; 1754 static const char *const mix_half_names[] = {",l", ",r"}; 1755 static const char *const saturation_names[] = {",us", ",ss", 0, ""}; 1756 static const char *const read_write_names[] = {",r", ",w"}; 1757 static const char *const add_compl_names[] = { 0, "", ",l", ",tsv" }; 1758 1759 /* For a bunch of different instructions form an index into a 1760 completer name table. */ 1761 #define GET_COMPL(insn) (GET_FIELD (insn, 26, 26) | \ 1762 GET_FIELD (insn, 18, 18) << 1) 1763 1764 #define GET_COND(insn) (GET_FIELD ((insn), 16, 18) + \ 1765 (GET_FIELD ((insn), 19, 19) ? 8 : 0)) 1766 1767 /* Utility function to print registers. Put these first, so gcc's function 1768 inlining can do its stuff. */ 1769 1770 #define fputs_filtered(STR,F) (*info->fprintf_func) (info->stream, "%s", STR) 1771 1772 static void 1773 fput_reg (unsigned reg, disassemble_info *info) 1774 { 1775 (*info->fprintf_func) (info->stream, "%s", reg ? reg_names[reg] : "r0"); 1776 } 1777 1778 static void 1779 fput_fp_reg (unsigned reg, disassemble_info *info) 1780 { 1781 (*info->fprintf_func) (info->stream, "%s", reg ? fp_reg_names[reg] : "fr0"); 1782 } 1783 1784 static void 1785 fput_fp_reg_r (unsigned reg, disassemble_info *info) 1786 { 1787 /* Special case floating point exception registers. */ 1788 if (reg < 4) 1789 (*info->fprintf_func) (info->stream, "fpe%d", reg * 2 + 1); 1790 else 1791 (*info->fprintf_func) (info->stream, "%sR", fp_reg_names[reg]); 1792 } 1793 1794 static void 1795 fput_creg (unsigned reg, disassemble_info *info) 1796 { 1797 (*info->fprintf_func) (info->stream, "%s", control_reg[reg]); 1798 } 1799 1800 /* Print constants with sign. */ 1801 1802 static void 1803 fput_const (unsigned num, disassemble_info *info) 1804 { 1805 if ((int) num < 0) 1806 (*info->fprintf_func) (info->stream, "-%x", - (int) num); 1807 else 1808 (*info->fprintf_func) (info->stream, "%x", num); 1809 } 1810 1811 /* Routines to extract various sized constants out of hppa 1812 instructions. */ 1813 1814 /* Extract a 3-bit space register number from a be, ble, mtsp or mfsp. */ 1815 static int 1816 extract_3 (unsigned word) 1817 { 1818 return GET_FIELD (word, 18, 18) << 2 | GET_FIELD (word, 16, 17); 1819 } 1820 1821 static int 1822 extract_5_load (unsigned word) 1823 { 1824 return low_sign_extend (word >> 16 & MASK_5, 5); 1825 } 1826 1827 /* Extract the immediate field from a st{bhw}s instruction. */ 1828 1829 static int 1830 extract_5_store (unsigned word) 1831 { 1832 return low_sign_extend (word & MASK_5, 5); 1833 } 1834 1835 /* Extract the immediate field from a break instruction. */ 1836 1837 static unsigned 1838 extract_5r_store (unsigned word) 1839 { 1840 return (word & MASK_5); 1841 } 1842 1843 /* Extract the immediate field from a {sr}sm instruction. */ 1844 1845 static unsigned 1846 extract_5R_store (unsigned word) 1847 { 1848 return (word >> 16 & MASK_5); 1849 } 1850 1851 /* Extract the 10 bit immediate field from a {sr}sm instruction. */ 1852 1853 static unsigned 1854 extract_10U_store (unsigned word) 1855 { 1856 return (word >> 16 & MASK_10); 1857 } 1858 1859 /* Extract the immediate field from a bb instruction. */ 1860 1861 static unsigned 1862 extract_5Q_store (unsigned word) 1863 { 1864 return (word >> 21 & MASK_5); 1865 } 1866 1867 /* Extract an 11 bit immediate field. */ 1868 1869 static int 1870 extract_11 (unsigned word) 1871 { 1872 return low_sign_extend (word & MASK_11, 11); 1873 } 1874 1875 /* Extract a 14 bit immediate field. */ 1876 1877 static int 1878 extract_14 (unsigned word) 1879 { 1880 return low_sign_extend (word & MASK_14, 14); 1881 } 1882 1883 /* Extract a 16 bit immediate field (PA2.0 wide only). */ 1884 1885 static int 1886 extract_16 (unsigned word) 1887 { 1888 int m15, m0, m1; 1889 1890 m0 = GET_BIT (word, 16); 1891 m1 = GET_BIT (word, 17); 1892 m15 = GET_BIT (word, 31); 1893 word = (word >> 1) & 0x1fff; 1894 word = word | (m15 << 15) | ((m15 ^ m0) << 14) | ((m15 ^ m1) << 13); 1895 return sign_extend (word, 16); 1896 } 1897 1898 /* Extract a 21 bit constant. */ 1899 1900 static int 1901 extract_21 (unsigned word) 1902 { 1903 int val; 1904 1905 word &= MASK_21; 1906 word <<= 11; 1907 val = GET_FIELD (word, 20, 20); 1908 val <<= 11; 1909 val |= GET_FIELD (word, 9, 19); 1910 val <<= 2; 1911 val |= GET_FIELD (word, 5, 6); 1912 val <<= 5; 1913 val |= GET_FIELD (word, 0, 4); 1914 val <<= 2; 1915 val |= GET_FIELD (word, 7, 8); 1916 return sign_extend (val, 21) << 11; 1917 } 1918 1919 /* Extract a 12 bit constant from branch instructions. */ 1920 1921 static int 1922 extract_12 (unsigned word) 1923 { 1924 return sign_extend (GET_FIELD (word, 19, 28) 1925 | GET_FIELD (word, 29, 29) << 10 1926 | (word & 0x1) << 11, 12) << 2; 1927 } 1928 1929 /* Extract a 17 bit constant from branch instructions, returning the 1930 19 bit signed value. */ 1931 1932 static int 1933 extract_17 (unsigned word) 1934 { 1935 return sign_extend (GET_FIELD (word, 19, 28) 1936 | GET_FIELD (word, 29, 29) << 10 1937 | GET_FIELD (word, 11, 15) << 11 1938 | (word & 0x1) << 16, 17) << 2; 1939 } 1940 1941 static int 1942 extract_22 (unsigned word) 1943 { 1944 return sign_extend (GET_FIELD (word, 19, 28) 1945 | GET_FIELD (word, 29, 29) << 10 1946 | GET_FIELD (word, 11, 15) << 11 1947 | GET_FIELD (word, 6, 10) << 16 1948 | (word & 0x1) << 21, 22) << 2; 1949 } 1950 1951 /* Print one instruction. */ 1952 1953 int 1954 print_insn_hppa (bfd_vma memaddr, disassemble_info *info) 1955 { 1956 bfd_byte buffer[4]; 1957 unsigned int insn, i; 1958 1959 { 1960 int status = 1961 (*info->read_memory_func) (memaddr, buffer, sizeof (buffer), info); 1962 if (status != 0) 1963 { 1964 (*info->memory_error_func) (status, memaddr, info); 1965 return -1; 1966 } 1967 } 1968 1969 insn = bfd_getb32 (buffer); 1970 1971 info->fprintf_func(info->stream, " %02x %02x %02x %02x ", 1972 (insn >> 24) & 0xff, (insn >> 16) & 0xff, 1973 (insn >> 8) & 0xff, insn & 0xff); 1974 1975 for (i = 0; i < NUMOPCODES; ++i) 1976 { 1977 const struct pa_opcode *opcode = &pa_opcodes[i]; 1978 1979 if ((insn & opcode->mask) == opcode->match) 1980 { 1981 const char *s; 1982 #ifndef BFD64 1983 if (opcode->arch == pa20w) 1984 continue; 1985 #endif 1986 (*info->fprintf_func) (info->stream, "%s", opcode->name); 1987 1988 if (!strchr ("cfCY?-+nHNZFIuv{", opcode->args[0])) 1989 (*info->fprintf_func) (info->stream, " "); 1990 for (s = opcode->args; *s != '\0'; ++s) 1991 { 1992 switch (*s) 1993 { 1994 case 'x': 1995 fput_reg (GET_FIELD (insn, 11, 15), info); 1996 break; 1997 case 'a': 1998 case 'b': 1999 fput_reg (GET_FIELD (insn, 6, 10), info); 2000 break; 2001 case '^': 2002 fput_creg (GET_FIELD (insn, 6, 10), info); 2003 break; 2004 case 't': 2005 fput_reg (GET_FIELD (insn, 27, 31), info); 2006 break; 2007 2008 /* Handle floating point registers. */ 2009 case 'f': 2010 switch (*++s) 2011 { 2012 case 't': 2013 fput_fp_reg (GET_FIELD (insn, 27, 31), info); 2014 break; 2015 case 'T': 2016 if (GET_FIELD (insn, 25, 25)) 2017 fput_fp_reg_r (GET_FIELD (insn, 27, 31), info); 2018 else 2019 fput_fp_reg (GET_FIELD (insn, 27, 31), info); 2020 break; 2021 case 'a': 2022 if (GET_FIELD (insn, 25, 25)) 2023 fput_fp_reg_r (GET_FIELD (insn, 6, 10), info); 2024 else 2025 fput_fp_reg (GET_FIELD (insn, 6, 10), info); 2026 break; 2027 2028 /* 'fA' will not generate a space before the register 2029 name. Normally that is fine. Except that it 2030 causes problems with xmpyu which has no FP format 2031 completer. */ 2032 case 'X': 2033 fputs_filtered (" ", info); 2034 /* FALLTHRU */ 2035 2036 case 'A': 2037 if (GET_FIELD (insn, 24, 24)) 2038 fput_fp_reg_r (GET_FIELD (insn, 6, 10), info); 2039 else 2040 fput_fp_reg (GET_FIELD (insn, 6, 10), info); 2041 break; 2042 case 'b': 2043 if (GET_FIELD (insn, 25, 25)) 2044 fput_fp_reg_r (GET_FIELD (insn, 11, 15), info); 2045 else 2046 fput_fp_reg (GET_FIELD (insn, 11, 15), info); 2047 break; 2048 case 'B': 2049 if (GET_FIELD (insn, 19, 19)) 2050 fput_fp_reg_r (GET_FIELD (insn, 11, 15), info); 2051 else 2052 fput_fp_reg (GET_FIELD (insn, 11, 15), info); 2053 break; 2054 case 'C': 2055 { 2056 int reg = GET_FIELD (insn, 21, 22); 2057 reg |= GET_FIELD (insn, 16, 18) << 2; 2058 if (GET_FIELD (insn, 23, 23) != 0) 2059 fput_fp_reg_r (reg, info); 2060 else 2061 fput_fp_reg (reg, info); 2062 break; 2063 } 2064 case 'i': 2065 { 2066 int reg = GET_FIELD (insn, 6, 10); 2067 2068 reg |= (GET_FIELD (insn, 26, 26) << 4); 2069 fput_fp_reg (reg, info); 2070 break; 2071 } 2072 case 'j': 2073 { 2074 int reg = GET_FIELD (insn, 11, 15); 2075 2076 reg |= (GET_FIELD (insn, 26, 26) << 4); 2077 fput_fp_reg (reg, info); 2078 break; 2079 } 2080 case 'k': 2081 { 2082 int reg = GET_FIELD (insn, 27, 31); 2083 2084 reg |= (GET_FIELD (insn, 26, 26) << 4); 2085 fput_fp_reg (reg, info); 2086 break; 2087 } 2088 case 'l': 2089 { 2090 int reg = GET_FIELD (insn, 21, 25); 2091 2092 reg |= (GET_FIELD (insn, 26, 26) << 4); 2093 fput_fp_reg (reg, info); 2094 break; 2095 } 2096 case 'm': 2097 { 2098 int reg = GET_FIELD (insn, 16, 20); 2099 2100 reg |= (GET_FIELD (insn, 26, 26) << 4); 2101 fput_fp_reg (reg, info); 2102 break; 2103 } 2104 2105 /* 'fe' will not generate a space before the register 2106 name. Normally that is fine. Except that it 2107 causes problems with fstw fe,y(b) which has no FP 2108 format completer. */ 2109 case 'E': 2110 fputs_filtered (" ", info); 2111 /* FALLTHRU */ 2112 2113 case 'e': 2114 if (GET_FIELD (insn, 30, 30)) 2115 fput_fp_reg_r (GET_FIELD (insn, 11, 15), info); 2116 else 2117 fput_fp_reg (GET_FIELD (insn, 11, 15), info); 2118 break; 2119 case 'x': 2120 fput_fp_reg (GET_FIELD (insn, 11, 15), info); 2121 break; 2122 } 2123 break; 2124 2125 case '5': 2126 fput_const (extract_5_load (insn), info); 2127 break; 2128 case 's': 2129 { 2130 int space = GET_FIELD (insn, 16, 17); 2131 /* Zero means implicit addressing, not use of sr0. */ 2132 if (space != 0) 2133 (*info->fprintf_func) (info->stream, "sr%d", space); 2134 } 2135 break; 2136 2137 case 'S': 2138 (*info->fprintf_func) (info->stream, "sr%d", 2139 extract_3 (insn)); 2140 break; 2141 2142 /* Handle completers. */ 2143 case 'c': 2144 switch (*++s) 2145 { 2146 case 'x': 2147 (*info->fprintf_func) 2148 (info->stream, "%s", 2149 index_compl_names[GET_COMPL (insn)]); 2150 break; 2151 case 'X': 2152 (*info->fprintf_func) 2153 (info->stream, "%s ", 2154 index_compl_names[GET_COMPL (insn)]); 2155 break; 2156 case 'm': 2157 (*info->fprintf_func) 2158 (info->stream, "%s", 2159 short_ldst_compl_names[GET_COMPL (insn)]); 2160 break; 2161 case 'M': 2162 (*info->fprintf_func) 2163 (info->stream, "%s ", 2164 short_ldst_compl_names[GET_COMPL (insn)]); 2165 break; 2166 case 'A': 2167 (*info->fprintf_func) 2168 (info->stream, "%s ", 2169 short_bytes_compl_names[GET_COMPL (insn)]); 2170 break; 2171 case 's': 2172 (*info->fprintf_func) 2173 (info->stream, "%s", 2174 short_bytes_compl_names[GET_COMPL (insn)]); 2175 break; 2176 case 'c': 2177 case 'C': 2178 switch (GET_FIELD (insn, 20, 21)) 2179 { 2180 case 1: 2181 (*info->fprintf_func) (info->stream, ",bc "); 2182 break; 2183 case 2: 2184 (*info->fprintf_func) (info->stream, ",sl "); 2185 break; 2186 default: 2187 (*info->fprintf_func) (info->stream, " "); 2188 } 2189 break; 2190 case 'd': 2191 switch (GET_FIELD (insn, 20, 21)) 2192 { 2193 case 1: 2194 (*info->fprintf_func) (info->stream, ",co "); 2195 break; 2196 default: 2197 (*info->fprintf_func) (info->stream, " "); 2198 } 2199 break; 2200 case 'o': 2201 (*info->fprintf_func) (info->stream, ",o"); 2202 break; 2203 case 'g': 2204 (*info->fprintf_func) (info->stream, ",gate"); 2205 break; 2206 case 'p': 2207 (*info->fprintf_func) (info->stream, ",l,push"); 2208 break; 2209 case 'P': 2210 (*info->fprintf_func) (info->stream, ",pop"); 2211 break; 2212 case 'l': 2213 case 'L': 2214 (*info->fprintf_func) (info->stream, ",l"); 2215 break; 2216 case 'w': 2217 (*info->fprintf_func) 2218 (info->stream, "%s ", 2219 read_write_names[GET_FIELD (insn, 25, 25)]); 2220 break; 2221 case 'W': 2222 (*info->fprintf_func) (info->stream, ",w "); 2223 break; 2224 case 'r': 2225 if (GET_FIELD (insn, 23, 26) == 5) 2226 (*info->fprintf_func) (info->stream, ",r"); 2227 break; 2228 case 'Z': 2229 if (GET_FIELD (insn, 26, 26)) 2230 (*info->fprintf_func) (info->stream, ",m "); 2231 else 2232 (*info->fprintf_func) (info->stream, " "); 2233 break; 2234 case 'i': 2235 if (GET_FIELD (insn, 25, 25)) 2236 (*info->fprintf_func) (info->stream, ",i"); 2237 break; 2238 case 'z': 2239 if (!GET_FIELD (insn, 21, 21)) 2240 (*info->fprintf_func) (info->stream, ",z"); 2241 break; 2242 case 'a': 2243 (*info->fprintf_func) 2244 (info->stream, "%s", 2245 add_compl_names[GET_FIELD (insn, 20, 21)]); 2246 break; 2247 case 'Y': 2248 (*info->fprintf_func) 2249 (info->stream, ",dc%s", 2250 add_compl_names[GET_FIELD (insn, 20, 21)]); 2251 break; 2252 case 'y': 2253 (*info->fprintf_func) 2254 (info->stream, ",c%s", 2255 add_compl_names[GET_FIELD (insn, 20, 21)]); 2256 break; 2257 case 'v': 2258 if (GET_FIELD (insn, 20, 20)) 2259 (*info->fprintf_func) (info->stream, ",tsv"); 2260 break; 2261 case 't': 2262 (*info->fprintf_func) (info->stream, ",tc"); 2263 if (GET_FIELD (insn, 20, 20)) 2264 (*info->fprintf_func) (info->stream, ",tsv"); 2265 break; 2266 case 'B': 2267 (*info->fprintf_func) (info->stream, ",db"); 2268 if (GET_FIELD (insn, 20, 20)) 2269 (*info->fprintf_func) (info->stream, ",tsv"); 2270 break; 2271 case 'b': 2272 (*info->fprintf_func) (info->stream, ",b"); 2273 if (GET_FIELD (insn, 20, 20)) 2274 (*info->fprintf_func) (info->stream, ",tsv"); 2275 break; 2276 case 'T': 2277 if (GET_FIELD (insn, 25, 25)) 2278 (*info->fprintf_func) (info->stream, ",tc"); 2279 break; 2280 case 'S': 2281 /* EXTRD/W has a following condition. */ 2282 if (*(s + 1) == '?') 2283 (*info->fprintf_func) 2284 (info->stream, "%s", 2285 signed_unsigned_names[GET_FIELD (insn, 21, 21)]); 2286 else 2287 (*info->fprintf_func) 2288 (info->stream, "%s ", 2289 signed_unsigned_names[GET_FIELD (insn, 21, 21)]); 2290 break; 2291 case 'h': 2292 (*info->fprintf_func) 2293 (info->stream, "%s", 2294 mix_half_names[GET_FIELD (insn, 17, 17)]); 2295 break; 2296 case 'H': 2297 (*info->fprintf_func) 2298 (info->stream, "%s ", 2299 saturation_names[GET_FIELD (insn, 24, 25)]); 2300 break; 2301 case '*': 2302 (*info->fprintf_func) 2303 (info->stream, ",%d%d%d%d ", 2304 GET_FIELD (insn, 17, 18), GET_FIELD (insn, 20, 21), 2305 GET_FIELD (insn, 22, 23), GET_FIELD (insn, 24, 25)); 2306 break; 2307 2308 case 'q': 2309 { 2310 int m, a; 2311 2312 m = GET_FIELD (insn, 28, 28); 2313 a = GET_FIELD (insn, 29, 29); 2314 2315 if (m && !a) 2316 fputs_filtered (",ma ", info); 2317 else if (m && a) 2318 fputs_filtered (",mb ", info); 2319 else 2320 fputs_filtered (" ", info); 2321 break; 2322 } 2323 2324 case 'J': 2325 { 2326 int opc = GET_FIELD (insn, 0, 5); 2327 2328 if (opc == 0x16 || opc == 0x1e) 2329 { 2330 if (GET_FIELD (insn, 29, 29) == 0) 2331 fputs_filtered (",ma ", info); 2332 else 2333 fputs_filtered (",mb ", info); 2334 } 2335 else 2336 fputs_filtered (" ", info); 2337 break; 2338 } 2339 2340 case 'e': 2341 { 2342 int opc = GET_FIELD (insn, 0, 5); 2343 2344 if (opc == 0x13 || opc == 0x1b) 2345 { 2346 if (GET_FIELD (insn, 18, 18) == 1) 2347 fputs_filtered (",mb ", info); 2348 else 2349 fputs_filtered (",ma ", info); 2350 } 2351 else if (opc == 0x17 || opc == 0x1f) 2352 { 2353 if (GET_FIELD (insn, 31, 31) == 1) 2354 fputs_filtered (",ma ", info); 2355 else 2356 fputs_filtered (",mb ", info); 2357 } 2358 else 2359 fputs_filtered (" ", info); 2360 2361 break; 2362 } 2363 } 2364 break; 2365 2366 /* Handle conditions. */ 2367 case '?': 2368 { 2369 s++; 2370 switch (*s) 2371 { 2372 case 'f': 2373 (*info->fprintf_func) 2374 (info->stream, "%s ", 2375 float_comp_names[GET_FIELD (insn, 27, 31)]); 2376 break; 2377 2378 /* These four conditions are for the set of instructions 2379 which distinguish true/false conditions by opcode 2380 rather than by the 'f' bit (sigh): comb, comib, 2381 addb, addib. */ 2382 case 't': 2383 fputs_filtered 2384 (compare_cond_names[GET_FIELD (insn, 16, 18)], info); 2385 break; 2386 case 'n': 2387 fputs_filtered 2388 (compare_cond_names[GET_FIELD (insn, 16, 18) 2389 + GET_FIELD (insn, 4, 4) * 8], 2390 info); 2391 break; 2392 case 'N': 2393 fputs_filtered 2394 (compare_cond_64_names[GET_FIELD (insn, 16, 18) 2395 + GET_FIELD (insn, 2, 2) * 8], 2396 info); 2397 break; 2398 case 'Q': 2399 fputs_filtered 2400 (cmpib_cond_64_names[GET_FIELD (insn, 16, 18)], 2401 info); 2402 break; 2403 case '@': 2404 fputs_filtered 2405 (add_cond_names[GET_FIELD (insn, 16, 18) 2406 + GET_FIELD (insn, 4, 4) * 8], 2407 info); 2408 break; 2409 case 's': 2410 (*info->fprintf_func) 2411 (info->stream, "%s ", 2412 compare_cond_names[GET_COND (insn)]); 2413 break; 2414 case 'S': 2415 (*info->fprintf_func) 2416 (info->stream, "%s ", 2417 compare_cond_64_names[GET_COND (insn)]); 2418 break; 2419 case 'a': 2420 (*info->fprintf_func) 2421 (info->stream, "%s ", 2422 add_cond_names[GET_COND (insn)]); 2423 break; 2424 case 'A': 2425 (*info->fprintf_func) 2426 (info->stream, "%s ", 2427 add_cond_64_names[GET_COND (insn)]); 2428 break; 2429 case 'd': 2430 (*info->fprintf_func) 2431 (info->stream, "%s", 2432 add_cond_names[GET_FIELD (insn, 16, 18)]); 2433 break; 2434 2435 case 'W': 2436 (*info->fprintf_func) 2437 (info->stream, "%s", 2438 wide_add_cond_names[GET_FIELD (insn, 16, 18) + 2439 GET_FIELD (insn, 4, 4) * 8]); 2440 break; 2441 2442 case 'l': 2443 (*info->fprintf_func) 2444 (info->stream, "%s ", 2445 logical_cond_names[GET_COND (insn)]); 2446 break; 2447 case 'L': 2448 (*info->fprintf_func) 2449 (info->stream, "%s ", 2450 logical_cond_64_names[GET_COND (insn)]); 2451 break; 2452 case 'u': 2453 (*info->fprintf_func) 2454 (info->stream, "%s ", 2455 unit_cond_names[GET_COND (insn)]); 2456 break; 2457 case 'U': 2458 (*info->fprintf_func) 2459 (info->stream, "%s ", 2460 unit_cond_64_names[GET_COND (insn)]); 2461 break; 2462 case 'y': 2463 case 'x': 2464 case 'b': 2465 (*info->fprintf_func) 2466 (info->stream, "%s", 2467 shift_cond_names[GET_FIELD (insn, 16, 18)]); 2468 2469 /* If the next character in args is 'n', it will handle 2470 putting out the space. */ 2471 if (s[1] != 'n') 2472 (*info->fprintf_func) (info->stream, " "); 2473 break; 2474 case 'X': 2475 (*info->fprintf_func) 2476 (info->stream, "%s ", 2477 shift_cond_64_names[GET_FIELD (insn, 16, 18)]); 2478 break; 2479 case 'B': 2480 (*info->fprintf_func) 2481 (info->stream, "%s", 2482 bb_cond_64_names[GET_FIELD (insn, 16, 16)]); 2483 2484 /* If the next character in args is 'n', it will handle 2485 putting out the space. */ 2486 if (s[1] != 'n') 2487 (*info->fprintf_func) (info->stream, " "); 2488 break; 2489 } 2490 break; 2491 } 2492 2493 case 'V': 2494 fput_const (extract_5_store (insn), info); 2495 break; 2496 case 'r': 2497 fput_const (extract_5r_store (insn), info); 2498 break; 2499 case 'R': 2500 fput_const (extract_5R_store (insn), info); 2501 break; 2502 case 'U': 2503 fput_const (extract_10U_store (insn), info); 2504 break; 2505 case 'B': 2506 case 'Q': 2507 fput_const (extract_5Q_store (insn), info); 2508 break; 2509 case 'i': 2510 fput_const (extract_11 (insn), info); 2511 break; 2512 case 'j': 2513 fput_const (extract_14 (insn), info); 2514 break; 2515 case 'k': 2516 fputs_filtered ("L%", info); 2517 fput_const (extract_21 (insn), info); 2518 break; 2519 case '<': 2520 case 'l': 2521 /* 16-bit long disp., PA2.0 wide only. */ 2522 fput_const (extract_16 (insn), info); 2523 break; 2524 case 'n': 2525 if (insn & 0x2) 2526 (*info->fprintf_func) (info->stream, ",n "); 2527 else 2528 (*info->fprintf_func) (info->stream, " "); 2529 break; 2530 case 'N': 2531 if ((insn & 0x20) && s[1]) 2532 (*info->fprintf_func) (info->stream, ",n "); 2533 else if (insn & 0x20) 2534 (*info->fprintf_func) (info->stream, ",n"); 2535 else if (s[1]) 2536 (*info->fprintf_func) (info->stream, " "); 2537 break; 2538 case 'w': 2539 (*info->print_address_func) 2540 (memaddr + 8 + extract_12 (insn), info); 2541 break; 2542 case 'W': 2543 /* 17 bit PC-relative branch. */ 2544 (*info->print_address_func) 2545 ((memaddr + 8 + extract_17 (insn)), info); 2546 break; 2547 case 'z': 2548 /* 17 bit displacement. This is an offset from a register 2549 so it gets disasssembled as just a number, not any sort 2550 of address. */ 2551 fput_const (extract_17 (insn), info); 2552 break; 2553 2554 case 'Z': 2555 /* addil %r1 implicit output. */ 2556 fputs_filtered ("r1", info); 2557 break; 2558 2559 case 'Y': 2560 /* be,l %sr0,%r31 implicit output. */ 2561 fputs_filtered ("sr0,r31", info); 2562 break; 2563 2564 case '@': 2565 (*info->fprintf_func) (info->stream, "0"); 2566 break; 2567 2568 case '.': 2569 (*info->fprintf_func) (info->stream, "%d", 2570 GET_FIELD (insn, 24, 25)); 2571 break; 2572 case '*': 2573 (*info->fprintf_func) (info->stream, "%d", 2574 GET_FIELD (insn, 22, 25)); 2575 break; 2576 case '!': 2577 fputs_filtered ("sar", info); 2578 break; 2579 case 'p': 2580 (*info->fprintf_func) (info->stream, "%d", 2581 31 - GET_FIELD (insn, 22, 26)); 2582 break; 2583 case '~': 2584 { 2585 int num; 2586 num = GET_FIELD (insn, 20, 20) << 5; 2587 num |= GET_FIELD (insn, 22, 26); 2588 (*info->fprintf_func) (info->stream, "%d", 63 - num); 2589 break; 2590 } 2591 case 'P': 2592 (*info->fprintf_func) (info->stream, "%d", 2593 GET_FIELD (insn, 22, 26)); 2594 break; 2595 case 'q': 2596 { 2597 int num; 2598 num = GET_FIELD (insn, 20, 20) << 5; 2599 num |= GET_FIELD (insn, 22, 26); 2600 (*info->fprintf_func) (info->stream, "%d", num); 2601 break; 2602 } 2603 case 'T': 2604 (*info->fprintf_func) (info->stream, "%d", 2605 32 - GET_FIELD (insn, 27, 31)); 2606 break; 2607 case '%': 2608 { 2609 int num; 2610 num = (GET_FIELD (insn, 23, 23) + 1) * 32; 2611 num -= GET_FIELD (insn, 27, 31); 2612 (*info->fprintf_func) (info->stream, "%d", num); 2613 break; 2614 } 2615 case '|': 2616 { 2617 int num; 2618 num = (GET_FIELD (insn, 19, 19) + 1) * 32; 2619 num -= GET_FIELD (insn, 27, 31); 2620 (*info->fprintf_func) (info->stream, "%d", num); 2621 break; 2622 } 2623 case '$': 2624 fput_const (GET_FIELD (insn, 20, 28), info); 2625 break; 2626 case 'A': 2627 fput_const (GET_FIELD (insn, 6, 18), info); 2628 break; 2629 case 'D': 2630 fput_const (GET_FIELD (insn, 6, 31), info); 2631 break; 2632 case 'v': 2633 (*info->fprintf_func) (info->stream, ",%d", 2634 GET_FIELD (insn, 23, 25)); 2635 break; 2636 case 'O': 2637 fput_const ((GET_FIELD (insn, 6,20) << 5 | 2638 GET_FIELD (insn, 27, 31)), info); 2639 break; 2640 case 'o': 2641 fput_const (GET_FIELD (insn, 6, 20), info); 2642 break; 2643 case '2': 2644 fput_const ((GET_FIELD (insn, 6, 22) << 5 | 2645 GET_FIELD (insn, 27, 31)), info); 2646 break; 2647 case '1': 2648 fput_const ((GET_FIELD (insn, 11, 20) << 5 | 2649 GET_FIELD (insn, 27, 31)), info); 2650 break; 2651 case '0': 2652 fput_const ((GET_FIELD (insn, 16, 20) << 5 | 2653 GET_FIELD (insn, 27, 31)), info); 2654 break; 2655 case 'u': 2656 (*info->fprintf_func) (info->stream, ",%d", 2657 GET_FIELD (insn, 23, 25)); 2658 break; 2659 case 'F': 2660 /* If no destination completer and not before a completer 2661 for fcmp, need a space here. */ 2662 if (s[1] == 'G' || s[1] == '?') 2663 fputs_filtered 2664 (float_format_names[GET_FIELD (insn, 19, 20)], info); 2665 else 2666 (*info->fprintf_func) 2667 (info->stream, "%s ", 2668 float_format_names[GET_FIELD (insn, 19, 20)]); 2669 break; 2670 case 'G': 2671 (*info->fprintf_func) 2672 (info->stream, "%s ", 2673 float_format_names[GET_FIELD (insn, 17, 18)]); 2674 break; 2675 case 'H': 2676 if (GET_FIELD (insn, 26, 26) == 1) 2677 (*info->fprintf_func) (info->stream, "%s ", 2678 float_format_names[0]); 2679 else 2680 (*info->fprintf_func) (info->stream, "%s ", 2681 float_format_names[1]); 2682 break; 2683 case 'I': 2684 /* If no destination completer and not before a completer 2685 for fcmp, need a space here. */ 2686 if (s[1] == '?') 2687 fputs_filtered 2688 (float_format_names[GET_FIELD (insn, 20, 20)], info); 2689 else 2690 (*info->fprintf_func) 2691 (info->stream, "%s ", 2692 float_format_names[GET_FIELD (insn, 20, 20)]); 2693 break; 2694 2695 case 'J': 2696 fput_const (extract_14 (insn), info); 2697 break; 2698 2699 case '#': 2700 { 2701 int sign = GET_FIELD (insn, 31, 31); 2702 int imm10 = GET_FIELD (insn, 18, 27); 2703 int disp; 2704 2705 if (sign) 2706 disp = (-1 << 10) | imm10; 2707 else 2708 disp = imm10; 2709 2710 disp <<= 3; 2711 fput_const (disp, info); 2712 break; 2713 } 2714 case 'K': 2715 case 'd': 2716 { 2717 int sign = GET_FIELD (insn, 31, 31); 2718 int imm11 = GET_FIELD (insn, 18, 28); 2719 int disp; 2720 2721 if (sign) 2722 disp = (-1 << 11) | imm11; 2723 else 2724 disp = imm11; 2725 2726 disp <<= 2; 2727 fput_const (disp, info); 2728 break; 2729 } 2730 2731 case '>': 2732 case 'y': 2733 { 2734 /* 16-bit long disp., PA2.0 wide only. */ 2735 int disp = extract_16 (insn); 2736 disp &= ~3; 2737 fput_const (disp, info); 2738 break; 2739 } 2740 2741 case '&': 2742 { 2743 /* 16-bit long disp., PA2.0 wide only. */ 2744 int disp = extract_16 (insn); 2745 disp &= ~7; 2746 fput_const (disp, info); 2747 break; 2748 } 2749 2750 case '_': 2751 break; /* Dealt with by '{' */ 2752 2753 case '{': 2754 { 2755 int sub = GET_FIELD (insn, 14, 16); 2756 int df = GET_FIELD (insn, 17, 18); 2757 int sf = GET_FIELD (insn, 19, 20); 2758 const char * const * source = float_format_names; 2759 const char * const * dest = float_format_names; 2760 const char *t = ""; 2761 2762 if (sub == 4) 2763 { 2764 fputs_filtered (",UND ", info); 2765 break; 2766 } 2767 if ((sub & 3) == 3) 2768 t = ",t"; 2769 if ((sub & 3) == 1) 2770 source = sub & 4 ? fcnv_ufixed_names : fcnv_fixed_names; 2771 if (sub & 2) 2772 dest = sub & 4 ? fcnv_ufixed_names : fcnv_fixed_names; 2773 2774 (*info->fprintf_func) (info->stream, "%s%s%s ", 2775 t, source[sf], dest[df]); 2776 break; 2777 } 2778 2779 case 'm': 2780 { 2781 int y = GET_FIELD (insn, 16, 18); 2782 2783 if (y != 1) 2784 fput_const ((y ^ 1) - 1, info); 2785 } 2786 break; 2787 2788 case 'h': 2789 { 2790 int cbit; 2791 2792 cbit = GET_FIELD (insn, 16, 18); 2793 2794 if (cbit > 0) 2795 (*info->fprintf_func) (info->stream, ",%d", cbit - 1); 2796 break; 2797 } 2798 2799 case '=': 2800 { 2801 int cond = GET_FIELD (insn, 27, 31); 2802 2803 switch (cond) 2804 { 2805 case 0: fputs_filtered (" ", info); break; 2806 case 1: fputs_filtered ("acc ", info); break; 2807 case 2: fputs_filtered ("rej ", info); break; 2808 case 5: fputs_filtered ("acc8 ", info); break; 2809 case 6: fputs_filtered ("rej8 ", info); break; 2810 case 9: fputs_filtered ("acc6 ", info); break; 2811 case 13: fputs_filtered ("acc4 ", info); break; 2812 case 17: fputs_filtered ("acc2 ", info); break; 2813 default: break; 2814 } 2815 break; 2816 } 2817 2818 case 'X': 2819 (*info->print_address_func) 2820 (memaddr + 8 + extract_22 (insn), info); 2821 break; 2822 case 'L': 2823 fputs_filtered (",rp", info); 2824 break; 2825 default: 2826 (*info->fprintf_func) (info->stream, "%c", *s); 2827 break; 2828 } 2829 } 2830 return sizeof (insn); 2831 } 2832 } 2833 info->fprintf_func(info->stream, "<unknown>"); 2834 return sizeof (insn); 2835 } 2836