include/opcode/hppa.h

   1 /* Table of opcodes for the PA-RISC.
   2    Copyright (C) 1990, 1991, 1993, 1995, 1999 Free Software Foundation, Inc.
   3
   4    Contributed by the Center for Software Science at the
   5    University of Utah (pa-gdb-bugs@cs.utah.edu).
   6
   7 This file is part of GAS, the GNU Assembler, and GDB, the GNU disassembler.
   8
   9 GAS/GDB is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 1, or (at your option)
  12 any later version.
  13
  14 GAS/GDB is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GAS or GDB; see the file COPYING.  If not, write to
  21 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #if !defined(__STDC__) && !defined(const)
  24 #define const
  25 #endif
  26
  27 /*
  28  * Structure of an opcode table entry.
  29  */
  30
  31 /* There are two kinds of delay slot nullification: normal which is
  32  * controled by the nullification bit, and conditional, which depends
  33  * on the direction of the branch and its success or failure.
  34  *
  35  * NONE is unfortunately #defined in the hiux system include files.
  36  * #undef it away.
  37  */
  38 #undef NONE
  39 struct pa_opcode
  40 {
  41     const char *name;
  42     unsigned long int match;    /* Bits that must be set...  */
  43     unsigned long int mask;     /* ... in these bits. */
  44     char *args;
  45     enum pa_arch arch;
  46     char flags;
  47 };
  48
  49 /* Enable/disable strict syntax checking.  Not currently used, but will
  50    be necessary for PA2.0 support in the future.  */
  51 #define FLAG_STRICT 0x1
  52
  53 /*
  54    All hppa opcodes are 32 bits.
  55
  56    The match component is a mask saying which bits must match a
  57    particular opcode in order for an instruction to be an instance
  58    of that opcode.
  59
  60    The args component is a string containing one character
  61    for each operand of the instruction.
  62
  63    Bit positions in this description follow HP usage of lsb = 31,
  64    "at" is lsb of field.
  65
  66    In the args field, the following characters must match exactly:
  67
  68         '+,() '
  69
  70    In the args field, the following characters are unused:
  71
  72         '  "#$%    *+- ./          :;    '
  73         '                          [\]  '
  74         '                          { } '
  75
  76    Here are all the characters:
  77
  78         ' !"#$%&'()*+-,./0123456789:;<=>?@'
  79         'ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_'
  80         'abcdefghijklmnopqrstuvwxyz{|}~'
  81
  82 Kinds of operands:
  83    x    integer register field at 15.
  84    b    integer register field at 10.
  85    t    integer register field at 31.
  86    y    floating point register field at 31
  87    5    5 bit immediate at 15.
  88    s    2 bit space specifier at 17.
  89    S    3 bit space specifier at 18.
  90    c    indexed load completer.
  91    C    short load and store completer.
  92    Y    Store Bytes Short completer
  93    <    non-negated compare/subtract conditions.
  94    a    compare/subtract conditions
  95    d    non-negated add conditions
  96    &    logical instruction conditions
  97    U    unit instruction conditions
  98    >    shift/extract/deposit conditions.
  99    ~    bvb,bb conditions
 100    V    5 bit immediate value at 31
 101    i    11 bit immediate value at 31
 102    j    14 bit immediate value at 31
 103    k    21 bit immediate value at 31
 104    n    nullification for branch instructions
 105    N    nullification for spop and copr instructions
 106    w    12 bit branch displacement
 107    W    17 bit branch displacement (PC relative)
 108    z    17 bit branch displacement (just a number, not an address)
 109
 110 Also these:
 111
 112    p    5 bit shift count at 26 (to support the SHD instruction) encoded as
 113         31-p
 114    P    5 bit bit position at 26
 115    T    5 bit field length at 31 (encoded as 32-T)
 116    A    13 bit immediate at 18 (to support the BREAK instruction)
 117    ^    like b, but describes a control register
 118    Z    System Control Completer (to support LPA, LHA, etc.)
 119    D    26 bit immediate at 31 (to support the DIAG instruction)
 120
 121    f    3 bit Special Function Unit identifier at 25
 122    O    20 bit Special Function Unit operation split between 15 bits at 20
 123         and 5 bits at 31
 124    o    15 bit Special Function Unit operation at 20
 125    2    22 bit Special Function Unit operation split between 17 bits at 20
 126         and 5 bits at 31
 127    1    15 bit Special Function Unit operation split between 10 bits at 20
 128         and 5 bits at 31
 129    0    10 bit Special Function Unit operation split between 5 bits at 20
 130         and 5 bits at 31
 131    u    3 bit coprocessor unit identifier at 25
 132    F    Source Floating Point Operand Format Completer encoded 2 bits at 20
 133    I    Source Floating Point Operand Format Completer encoded 1 bits at 20
 134         (for 0xe format FP instructions)
 135    G    Destination Floating Point Operand Format Completer encoded 2 bits at 18
 136    M    Floating-Point Compare Conditions (encoded as 5 bits at 31)
 137    ?    non-negated/negated compare/subtract conditions.
 138    @    non-negated/negated add conditions.
 139    !    non-negated add conditions.
 140
 141    s    2 bit space specifier at 17.
 142    b    register field at 10.
 143    r    5 bit immediate value at 31 (for the break instruction)
 144         (very similar to V above, except the value is unsigned instead of
 145         low_sign_ext)
 146    R    5 bit immediate value at 15 (for the ssm, rsm, probei instructions)
 147         (same as r above, except the value is in a different location)
 148    Q    5 bit immediate value at 10 (a bit position specified in
 149         the bb instruction. It's the same as r above, except the
 150         value is in a different location)
 151    |    shift/extract/deposit conditions when used in a conditional branch
 152
 153 And these (PJH) for PA-89 F.P. registers and instructions:
 154
 155    v    a 't' operand type extended to handle L/R register halves.
 156    E    a 'b' operand type extended to handle L/R register halves.
 157    X    an 'x' operand type extended to handle L/R register halves.
 158    J    a 'b' operand type further extended to handle extra 1.1 registers
 159    K    a 'x' operand type further extended to handle extra 1.1 registers
 160    4    a variation of the 'b' operand type for 'fmpyadd' and 'fmpysub'
 161    6    a variation of the 'x' operand type for 'fmpyadd' and 'fmpysub'
 162    7    a variation of the 't' operand type for 'fmpyadd' and 'fmpysub'
 163    8    5 bit register field at 20 (used in 'fmpyadd' and 'fmpysub')
 164    9    5 bit register field at 25 (used in 'fmpyadd' and 'fmpysub')
 165    H    Floating Point Operand Format at 26 for 'fmpyadd' and 'fmpysub'
 166         (very similar to 'F')
 167 */
 168
 169
 170 /* List of characters not to put a space after.  Note that
 171    "," is included, as the "spopN" operations use literal
 172    commas in their completer sections. */
 173 static const char *const completer_chars = ",CcY<>?!@+&U~FfGHINnOoZMadu|/=0123%e$m}";
 174
 175 /* The order of the opcodes in this table is significant:
 176
 177    * The assembler requires that all instances of the same mnemonic must be
 178    consecutive.  If they aren't, the assembler will bomb at runtime.
 179
 180    * The disassembler should not care about the order of the opcodes.  */
 181
 182 static const struct pa_opcode pa_opcodes[] =
 183 {
 184
 185
 186 /* pseudo-instructions */
 187
 188 { "b",          0xe8000000, 0xffe0e000, "nW", pa10}, /* bl foo,r0 */
 189 { "ldi",        0x34000000, 0xffe0c000, "j,x", pa10},   /* ldo val(r0),r */
 190 { "comib",      0x84000000, 0xfc000000, "?n5,b,w", pa10}, /* comib{tf}*/
 191 /* This entry is for the disassembler only.  It will never be used by
 192    assembler.  */
 193 { "comib",      0x8c000000, 0xfc000000, "?n5,b,w", pa10}, /* comib{tf}*/
 194 { "comb",       0x80000000, 0xfc000000, "?nx,b,w", pa10}, /* comb{tf} */
 195 /* This entry is for the disassembler only.  It will never be used by
 196    assembler.  */
 197 { "comb",       0x88000000, 0xfc000000, "?nx,b,w", pa10}, /* comb{tf} */
 198 { "addb",       0xa0000000, 0xfc000000, "@nx,b,w", pa10}, /* addb{tf} */
 199 /* This entry is for the disassembler only.  It will never be used by
 200    assembler.  */
 201 { "addb",       0xa8000000, 0xfc000000, "@nx,b,w", pa10},
 202 { "addib",      0xa4000000, 0xfc000000, "@n5,b,w", pa10}, /* addib{tf}*/
 203 /* This entry is for the disassembler only.  It will never be used by
 204    assembler.  */
 205 { "addib",      0xac000000, 0xfc000000, "@n5,b,w", pa10}, /* addib{tf}*/
 206 { "nop",        0x08000240, 0xffffffff, "", pa10},      /* or 0,0,0 */
 207 { "copy",       0x08000240, 0xffe0ffe0, "x,t", pa10},   /* or r,0,t */
 208 { "mtsar",      0x01601840, 0xffe0ffff, "x", pa10}, /* mtctl r,cr11 */
 209
 210 /* Loads and Stores for integer registers.  */
 211 { "ldw",        0x48000000, 0xfc000000, "j(s,b),x", pa10},
 212 { "ldw",        0x48000000, 0xfc000000, "j(b),x", pa10},
 213 { "ldh",        0x44000000, 0xfc000000, "j(s,b),x", pa10},
 214 { "ldh",        0x44000000, 0xfc000000, "j(b),x", pa10},
 215 { "ldb",        0x40000000, 0xfc000000, "j(s,b),x", pa10},
 216 { "ldb",        0x40000000, 0xfc000000, "j(b),x", pa10},
 217 { "stw",        0x68000000, 0xfc000000, "x,j(s,b)", pa10},
 218 { "stw",        0x68000000, 0xfc000000, "x,j(b)", pa10},
 219 { "sth",        0x64000000, 0xfc000000, "x,j(s,b)", pa10},
 220 { "sth",        0x64000000, 0xfc000000, "x,j(b)", pa10},
 221 { "stb",        0x60000000, 0xfc000000, "x,j(s,b)", pa10},
 222 { "stb",        0x60000000, 0xfc000000, "x,j(b)", pa10},
 223 { "ldwm",       0x4c000000, 0xfc000000, "j(s,b),x", pa10},
 224 { "ldwm",       0x4c000000, 0xfc000000, "j(b),x", pa10},
 225 { "stwm",       0x6c000000, 0xfc000000, "x,j(s,b)", pa10},
 226 { "stwm",       0x6c000000, 0xfc000000, "x,j(b)", pa10},
 227 { "ldwx",       0x0c000080, 0xfc001fc0, "cx(s,b),t", pa10},
 228 { "ldwx",       0x0c000080, 0xfc001fc0, "cx(b),t", pa10},
 229 { "ldhx",       0x0c000040, 0xfc001fc0, "cx(s,b),t", pa10},
 230 { "ldhx",       0x0c000040, 0xfc001fc0, "cx(b),t", pa10},
 231 { "ldbx",       0x0c000000, 0xfc001fc0, "cx(s,b),t", pa10},
 232 { "ldbx",       0x0c000000, 0xfc001fc0, "cx(b),t", pa10},
 233 { "ldwax",      0x0c000180, 0xfc00dfc0, "cx(b),t", pa10},
 234 { "ldcwx",      0x0c0001c0, 0xfc001fc0, "cx(s,b),t", pa10},
 235 { "ldcwx",      0x0c0001c0, 0xfc001fc0, "cx(b),t", pa10},
 236 { "ldws",       0x0c001080, 0xfc001fc0, "C5(s,b),t", pa10},
 237 { "ldws",       0x0c001080, 0xfc001fc0, "C5(b),t", pa10},
 238 { "ldhs",       0x0c001040, 0xfc001fc0, "C5(s,b),t", pa10},
 239 { "ldhs",       0x0c001040, 0xfc001fc0, "C5(b),t", pa10},
 240 { "ldbs",       0x0c001000, 0xfc001fc0, "C5(s,b),t", pa10},
 241 { "ldbs",       0x0c001000, 0xfc001fc0, "C5(b),t", pa10},
 242 { "ldwas",      0x0c001180, 0xfc00dfc0, "C5(b),t", pa10},
 243 { "ldcws",      0x0c0011c0, 0xfc001fc0, "C5(s,b),t", pa10},
 244 { "ldcws",      0x0c0011c0, 0xfc001fc0, "C5(b),t", pa10},
 245 { "stws",       0x0c001280, 0xfc001fc0, "Cx,V(s,b)", pa10},
 246 { "stws",       0x0c001280, 0xfc001fc0, "Cx,V(b)", pa10},
 247 { "sths",       0x0c001240, 0xfc001fc0, "Cx,V(s,b)", pa10},
 248 { "sths",       0x0c001240, 0xfc001fc0, "Cx,V(b)", pa10},
 249 { "stbs",       0x0c001200, 0xfc001fc0, "Cx,V(s,b)", pa10},
 250 { "stbs",       0x0c001200, 0xfc001fc0, "Cx,V(b)", pa10},
 251 { "stwas",      0x0c001380, 0xfc00dfc0, "Cx,V(b)", pa10},
 252 { "stbys",      0x0c001300, 0xfc001fc0, "Yx,V(s,b)", pa10},
 253 { "stbys",      0x0c001300, 0xfc001fc0, "Yx,V(b)", pa10},
 254
 255 /* Immediate instructions.  */
 256 { "ldo",        0x34000000, 0xfc00c000, "j(b),x", pa10},
 257 { "ldil",       0x20000000, 0xfc000000, "k,b", pa10},
 258 { "addil",      0x28000000, 0xfc000000, "k,b", pa10},
 259
 260 /* Branching instructions. */
 261 { "bl",         0xe8000000, 0xfc00e000, "nW,b", pa10},
 262 { "gate",       0xe8002000, 0xfc00e000, "nW,b", pa10},
 263 { "blr",        0xe8004000, 0xfc00e001, "nx,b", pa10},
 264 { "bv",         0xe800c000, 0xfc00fffd, "nx(b)", pa10},
 265 { "bv",         0xe800c000, 0xfc00fffd, "n(b)", pa10},
 266 { "be",         0xe0000000, 0xfc000000, "nz(S,b)", pa10},
 267 { "ble",        0xe4000000, 0xfc000000, "nz(S,b)", pa10},
 268 { "movb",       0xc8000000, 0xfc000000, "|nx,b,w", pa10},
 269 { "movib",      0xcc000000, 0xfc000000, "|n5,b,w", pa10},
 270 { "combt",      0x80000000, 0xfc000000, "<nx,b,w", pa10},
 271 { "combf",      0x88000000, 0xfc000000, "<nx,b,w", pa10},
 272 { "comibt",     0x84000000, 0xfc000000, "<n5,b,w", pa10},
 273 { "comibf",     0x8c000000, 0xfc000000, "<n5,b,w", pa10},
 274 { "addbt",      0xa0000000, 0xfc000000, "!nx,b,w", pa10},
 275 { "addbf",      0xa8000000, 0xfc000000, "!nx,b,w", pa10},
 276 { "addibt",     0xa4000000, 0xfc000000, "!n5,b,w", pa10},
 277 { "addibf",     0xac000000, 0xfc000000, "!n5,b,w", pa10},
 278 { "bb",         0xc4004000, 0xfc004000, "~nx,Q,w", pa10},
 279 { "bvb",        0xc0004000, 0xffe04000, "~nx,w", pa10},
 280 { "clrbts",     0xe8004005, 0xffffffff, "", pa20},
 281
 282 /* Computation Instructions */
 283
 284 { "comclr",     0x08000880, 0xfc000fe0, "ax,b,t", pa10},
 285 { "or",         0x08000240, 0xfc000fe0, "&x,b,t", pa10},
 286 { "xor",        0x08000280, 0xfc000fe0, "&x,b,t", pa10},
 287 { "and",        0x08000200, 0xfc000fe0, "&x,b,t", pa10},
 288 { "andcm",      0x08000000, 0xfc000fe0, "&x,b,t", pa10},
 289 { "uxor",       0x08000380, 0xfc000fe0, "Ux,b,t", pa10},
 290 { "uaddcm",     0x08000980, 0xfc000fe0, "Ux,b,t", pa10},
 291 { "uaddcmt",    0x080009c0, 0xfc000fe0, "Ux,b,t", pa10},
 292 { "dcor",       0x08000b80, 0xfc1f0fe0, "Ub,t",   pa10},
 293 { "idcor",      0x08000bc0, 0xfc1f0fe0, "Ub,t",   pa10},
 294 { "addi",       0xb4000000, 0xfc000800, "di,b,x", pa10},
 295 { "addio",      0xb4000800, 0xfc000800, "di,b,x", pa10},
 296 { "addit",      0xb0000000, 0xfc000800, "di,b,x", pa10},
 297 { "addito",     0xb0000800, 0xfc000800, "di,b,x", pa10},
 298 { "add",        0x08000600, 0xfc000fe0, "dx,b,t", pa10},
 299 { "addl",       0x08000a00, 0xfc000fe0, "dx,b,t", pa10},
 300 { "addo",       0x08000e00, 0xfc000fe0, "dx,b,t", pa10},
 301 { "addc",       0x08000700, 0xfc000fe0, "dx,b,t", pa10},
 302 { "addco",      0x08000f00, 0xfc000fe0, "dx,b,t", pa10},
 303 { "sub",        0x08000400, 0xfc000fe0, "ax,b,t", pa10},
 304 { "subo",       0x08000c00, 0xfc000fe0, "ax,b,t", pa10},
 305 { "subb",       0x08000500, 0xfc000fe0, "ax,b,t", pa10},
 306 { "subbo",      0x08000d00, 0xfc000fe0, "ax,b,t", pa10},
 307 { "subt",       0x080004c0, 0xfc000fe0, "ax,b,t", pa10},
 308 { "subto",      0x08000cc0, 0xfc000fe0, "ax,b,t", pa10},
 309 { "ds",         0x08000440, 0xfc000fe0, "ax,b,t", pa10},
 310 { "subi",       0x94000000, 0xfc000800, "ai,b,x", pa10},
 311 { "subio",      0x94000800, 0xfc000800, "ai,b,x", pa10},
 312 { "comiclr",    0x90000000, 0xfc000800, "ai,b,x", pa10},
 313 { "sh1add",     0x08000640, 0xfc000fe0, "dx,b,t", pa10},
 314 { "sh1addl",    0x08000a40, 0xfc000fe0, "dx,b,t", pa10},
 315 { "sh1addo",    0x08000e40, 0xfc000fe0, "dx,b,t", pa10},
 316 { "sh2add",     0x08000680, 0xfc000fe0, "dx,b,t", pa10},
 317 { "sh2addl",    0x08000a80, 0xfc000fe0, "dx,b,t", pa10},
 318 { "sh2addo",    0x08000e80, 0xfc000fe0, "dx,b,t", pa10},
 319 { "sh3add",     0x080006c0, 0xfc000fe0, "dx,b,t", pa10},
 320 { "sh3addl",    0x08000ac0, 0xfc000fe0, "dx,b,t", pa10},
 321 { "sh3addo",    0x08000ec0, 0xfc000fe0, "dx,b,t", pa10},
 322
 323 /* Extract and Deposit Instructions */
 324
 325 { "vshd",       0xd0000000, 0xfc001fe0, ">x,b,t", pa10},
 326 { "shd",        0xd0000800, 0xfc001c00, ">x,b,p,t", pa10},
 327 { "vextru",     0xd0001000, 0xfc001fe0, ">b,T,x", pa10},
 328 { "vextrs",     0xd0001400, 0xfc001fe0, ">b,T,x", pa10},
 329 { "extru",      0xd0001800, 0xfc001c00, ">b,P,T,x", pa10},
 330 { "extrs",      0xd0001c00, 0xfc001c00, ">b,P,T,x", pa10},
 331 { "zvdep",      0xd4000000, 0xfc001fe0, ">x,T,b", pa10},
 332 { "vdep",       0xd4000400, 0xfc001fe0, ">x,T,b", pa10},
 333 { "zdep",       0xd4000800, 0xfc001c00, ">x,p,T,b", pa10},
 334 { "dep",        0xd4000c00, 0xfc001c00, ">x,p,T,b", pa10},
 335 { "zvdepi",     0xd4001000, 0xfc001fe0, ">5,T,b", pa10},
 336 { "vdepi",      0xd4001400, 0xfc001fe0, ">5,T,b", pa10},
 337 { "zdepi",      0xd4001800, 0xfc001c00, ">5,p,T,b", pa10},
 338 { "depi",       0xd4001c00, 0xfc001c00, ">5,p,T,b", pa10},
 339
 340 /* System Control Instructions */
 341
 342 { "break",      0x00000000, 0xfc001fe0, "r,A", pa10},
 343 { "rfi",        0x00000c00, 0xffffffff, "", pa10},
 344 { "rfir",       0x00000ca0, 0xffffffff, "", pa11},
 345 { "ssm",        0x00000d60, 0xffe0ffe0, "R,t", pa10},
 346 { "rsm",        0x00000e60, 0xffe0ffe0, "R,t", pa10},
 347 { "mtsm",       0x00001860, 0xffe0ffff, "x", pa10},
 348 { "ldsid",      0x000010a0, 0xfc1f3fe0, "(s,b),t", pa10},
 349 { "ldsid",      0x000010a0, 0xfc1f3fe0, "(b),t", pa10},
 350 { "mtsp",       0x00001820, 0xffe01fff, "x,S", pa10},
 351 { "mtctl",      0x00001840, 0xfc00ffff, "x,^", pa10},
 352 { "mtsarcm",    0x016018C0, 0xffe0ffff, "x", pa20},
 353 { "mfia",       0x000014A0, 0xffffffe0, "t", pa20},
 354 { "mfsp",       0x000004a0, 0xffff1fe0, "S,t", pa10},
 355 { "mfctl",      0x000008a0, 0xfc1fffe0, "^,t", pa10},
 356 { "sync",       0x00000400, 0xffffffff, "", pa10},
 357 { "syncdma",    0x00100400, 0xffffffff, "", pa10},
 358 { "prober",     0x04001180, 0xfc003fe0, "(s,b),x,t", pa10},
 359 { "prober",     0x04001180, 0xfc003fe0, "(b),x,t", pa10},
 360 { "proberi",    0x04003180, 0xfc003fe0, "(s,b),R,t", pa10},
 361 { "proberi",    0x04003180, 0xfc003fe0, "(b),R,t", pa10},
 362 { "probew",     0x040011c0, 0xfc003fe0, "(s,b),x,t", pa10},
 363 { "probew",     0x040011c0, 0xfc003fe0, "(b),x,t", pa10},
 364 { "probewi",    0x040031c0, 0xfc003fe0, "(s,b),R,t", pa10},
 365 { "probewi",    0x040031c0, 0xfc003fe0, "(b),R,t", pa10},
 366 { "lpa",        0x04001340, 0xfc003fc0, "Zx(s,b),t", pa10},
 367 { "lpa",        0x04001340, 0xfc003fc0, "Zx(b),t", pa10},
 368 { "lha",        0x04001300, 0xfc003fc0, "Zx(s,b),t", pa10},
 369 { "lha",        0x04001300, 0xfc003fc0, "Zx(b),t", pa10},
 370 { "lci",        0x04001300, 0xfc003fe0, "x(s,b),t", pa10},
 371 { "lci",        0x04001300, 0xfc003fe0, "x(b),t", pa10},
 372 { "pdtlb",      0x04001200, 0xfc003fdf, "Zx(s,b)", pa10},
 373 { "pdtlb",      0x04001200, 0xfc003fdf, "Zx(b)", pa10},
 374 { "pitlb",      0x04000200, 0xfc001fdf, "Zx(S,b)", pa10},
 375 { "pitlb",      0x04000200, 0xfc001fdf, "Zx(b)", pa10},
 376 { "pdtlbe",     0x04001240, 0xfc003fdf, "Zx(s,b)", pa10},
 377 { "pdtlbe",     0x04001240, 0xfc003fdf, "Zx(b)", pa10},
 378 { "pitlbe",     0x04000240, 0xfc001fdf, "Zx(S,b)", pa10},
 379 { "pitlbe",     0x04000240, 0xfc001fdf, "Zx(b)", pa10},
 380 { "idtlba",     0x04001040, 0xfc003fff, "x,(s,b)", pa10},
 381 { "idtlba",     0x04001040, 0xfc003fff, "x,(b)", pa10},
 382 { "iitlba",     0x04000040, 0xfc001fff, "x,(S,b)", pa10},
 383 { "iitlba",     0x04000040, 0xfc001fff, "x,(b)", pa10},
 384 { "idtlbp",     0x04001000, 0xfc003fff, "x,(s,b)", pa10},
 385 { "idtlbp",     0x04001000, 0xfc003fff, "x,(b)", pa10},
 386 { "iitlbp",     0x04000000, 0xfc001fff, "x,(S,b)", pa10},
 387 { "iitlbp",     0x04000000, 0xfc001fff, "x,(b)", pa10},
 388 { "pdc",        0x04001380, 0xfc003fdf, "Zx(s,b)", pa10},
 389 { "pdc",        0x04001380, 0xfc003fdf, "Zx(b)", pa10},
 390 { "fdc",        0x04001280, 0xfc003fdf, "Zx(s,b)", pa10},
 391 { "fdc",        0x04001280, 0xfc003fdf, "Zx(b)", pa10},
 392 { "fic",        0x04000280, 0xfc001fdf, "Zx(S,b)", pa10},
 393 { "fic",        0x04000280, 0xfc001fdf, "Zx(b)", pa10},
 394 { "fdce",       0x040012c0, 0xfc003fdf, "Zx(s,b)", pa10},
 395 { "fdce",       0x040012c0, 0xfc003fdf, "Zx(b)", pa10},
 396 { "fice",       0x040002c0, 0xfc001fdf, "Zx(S,b)", pa10},
 397 { "fice",       0x040002c0, 0xfc001fdf, "Zx(b)", pa10},
 398 { "diag",       0x14000000, 0xfc000000, "D", pa10},
 399
 400 /* These may be specific to certain versions of the PA.  Joel claimed
 401    they were 72000 (7200?) specific.  However, I'm almost certain the
 402    mtcpu/mfcpu were undocumented, but available in the older 700 machines.  */
 403 { "mtcpu",      0x14001600, 0xfc00ffff, "x,^"},
 404 { "mfcpu",      0x14001A00, 0xfc00ffff, "^,x"},
 405 { "tocen",      0x14403600, 0xffffffff, ""},
 406 { "tocdis",     0x14401620, 0xffffffff, ""},
 407 { "shdwgr",     0x14402600, 0xffffffff, ""},
 408 { "grshdw",     0x14400620, 0xffffffff, ""},
 409
 410 /* gfw and gfr are not in the HP PA 1.1 manual, but they are in either
 411    the Timex FPU or the Mustang ERS (not sure which) manual.  */
 412 { "gfw",        0x04001680, 0xfc003fdf, "Zx(s,b)", pa11},
 413 { "gfw",        0x04001680, 0xfc003fdf, "Zx(b)", pa11},
 414 { "gfr",        0x04001a80, 0xfc003fdf, "Zx(s,b)", pa11},
 415 { "gfr",        0x04001a80, 0xfc003fdf, "Zx(b)", pa11},
 416
 417 /* Floating Point Coprocessor Instructions */
 418
 419 { "fldwx",      0x24000000, 0xfc001f80, "cx(s,b),v", pa10},
 420 { "fldwx",      0x24000000, 0xfc001f80, "cx(b),v", pa10},
 421 { "flddx",      0x2c000000, 0xfc001fc0, "cx(s,b),y", pa10},
 422 { "flddx",      0x2c000000, 0xfc001fc0, "cx(b),y", pa10},
 423 { "fstwx",      0x24000200, 0xfc001f80, "cv,x(s,b)", pa10},
 424 { "fstwx",      0x24000200, 0xfc001f80, "cv,x(b)", pa10},
 425 { "fstdx",      0x2c000200, 0xfc001fc0, "cy,x(s,b)", pa10},
 426 { "fstdx",      0x2c000200, 0xfc001fc0, "cy,x(b)", pa10},
 427 { "fstqx",      0x3c000200, 0xfc001fc0, "cy,x(s,b)", pa10},
 428 { "fstqx",      0x3c000200, 0xfc001fc0, "cy,x(b)", pa10},
 429 { "fldws",      0x24001000, 0xfc001f80, "C5(s,b),v", pa10},
 430 { "fldws",      0x24001000, 0xfc001f80, "C5(b),v", pa10},
 431 { "fldds",      0x2c001000, 0xfc001fc0, "C5(s,b),y", pa10},
 432 { "fldds",      0x2c001000, 0xfc001fc0, "C5(b),y", pa10},
 433 { "fstws",      0x24001200, 0xfc001f80, "Cv,5(s,b)", pa10},
 434 { "fstws",      0x24001200, 0xfc001f80, "Cv,5(b)", pa10},
 435 { "fstds",      0x2c001200, 0xfc001fc0, "Cy,5(s,b)", pa10},
 436 { "fstds",      0x2c001200, 0xfc001fc0, "Cy,5(b)", pa10},
 437 { "fstqs",      0x3c001200, 0xfc001fc0, "Cy,5(s,b)", pa10},
 438 { "fstqs",      0x3c001200, 0xfc001fc0, "Cy,5(b)", pa10},
 439 { "fadd",       0x30000600, 0xfc00e7e0, "FE,X,v", pa10},
 440 { "fadd",       0x38000600, 0xfc00e720, "IJ,K,v", pa10},
 441 { "fsub",       0x30002600, 0xfc00e7e0, "FE,X,v", pa10},
 442 { "fsub",       0x38002600, 0xfc00e720, "IJ,K,v", pa10},
 443 { "fmpy",       0x30004600, 0xfc00e7e0, "FE,X,v", pa10},
 444 { "fmpy",       0x38004600, 0xfc00e720, "IJ,K,v", pa10},
 445 { "fdiv",       0x30006600, 0xfc00e7e0, "FE,X,v", pa10},
 446 { "fdiv",       0x38006600, 0xfc00e720, "IJ,K,v", pa10},
 447 { "fsqrt",      0x30008000, 0xfc1fe7e0, "FE,v", pa10},
 448 { "fsqrt",      0x38008000, 0xfc1fe720, "FJ,v", pa10},
 449 { "fabs",       0x30006000, 0xfc1fe7e0, "FE,v", pa10},
 450 { "fabs",       0x38006000, 0xfc1fe720, "FJ,v", pa10},
 451 { "frem",       0x30008600, 0xfc00e7e0, "FE,X,v", pa10},
 452 { "frem",       0x38008600, 0xfc00e720, "FJ,K,v", pa10},
 453 { "frnd",       0x3000a000, 0xfc1fe7e0, "FE,v", pa10},
 454 { "frnd",       0x3800a000, 0xfc1fe720, "FJ,v", pa10},
 455 { "fcpy",       0x30004000, 0xfc1fe7e0, "FE,v", pa10},
 456 { "fcpy",       0x38004000, 0xfc1fe720, "FJ,v", pa10},
 457 { "fcnvff",     0x30000200, 0xfc1f87e0, "FGE,v", pa10},
 458 { "fcnvff",     0x38000200, 0xfc1f8720, "FGJ,v", pa10},
 459 { "fcnvxf",     0x30008200, 0xfc1f87e0, "FGE,v", pa10},
 460 { "fcnvxf",     0x38008200, 0xfc1f8720, "FGJ,v", pa10},
 461 { "fcnvfx",     0x30010200, 0xfc1f87e0, "FGE,v", pa10},
 462 { "fcnvfx",     0x38010200, 0xfc1f8720, "FGJ,v", pa10},
 463 { "fcnvfxt",    0x30018200, 0xfc1f87e0, "FGE,v", pa10},
 464 { "fcnvfxt",    0x38018200, 0xfc1f8720, "FGJ,v", pa10},
 465 { "fmpyfadd",   0xb8000000, 0xfc000020, "FJ,K,3,v", pa20},
 466 { "fmpynfadd",  0xb8000020, 0xfc000020, "FJ,K,3,v", pa20},
 467 { "fneg",       0x3000c000, 0xfc1fe7e0, "FE,v", pa20},
 468 { "fneg",       0x3800c000, 0xfc1fe720, "FJ,v", pa20},
 469 { "fnegabs",    0x3000e000, 0xfc1fe7e0, "FE,v", pa20},
 470 { "fnegabs",    0x3800e000, 0xfc1fe720, "FJ,v", pa20},
 471 { "fcmp",       0x30000400, 0xfc00e7e0, "FME,X", pa10},
 472 { "fcmp",       0x38000400, 0xfc00e720, "IMJ,K", pa10},
 473 { "xmpyu",      0x38004700, 0xfc00e720, "J,K,v", pa11},
 474 { "fmpyadd",    0x18000000, 0xfc000000, "H4,6,7,9,8", pa11},
 475 { "fmpysub",    0x98000000, 0xfc000000, "H4,6,7,9,8", pa11},
 476 { "ftest",      0x30002420, 0xffffffff, "", pa10},
 477 { "fid",        0x30000000, 0xffffffff, "", pa11},
 478
 479
 480 /* Assist Instructions */
 481
 482 { "spop0",      0x10000000, 0xfc000600, "f,ON", pa10},
 483 { "spop1",      0x10000200, 0xfc000600, "f,oNt", pa10},
 484 { "spop2",      0x10000400, 0xfc000600, "f,1Nb", pa10},
 485 { "spop3",      0x10000600, 0xfc000600, "f,0Nx,b", pa10},
 486 { "copr",       0x30000000, 0xfc000000, "u,2N", pa10},
 487 { "cldwx",      0x24000000, 0xfc001e00, "ucx(s,b),t", pa10},
 488 { "cldwx",      0x24000000, 0xfc001e00, "ucx(b),t", pa10},
 489 { "clddx",      0x2c000000, 0xfc001e00, "ucx(s,b),t", pa10},
 490 { "clddx",      0x2c000000, 0xfc001e00, "ucx(b),t", pa10},
 491 { "cstwx",      0x24000200, 0xfc001e00, "uct,x(s,b)", pa10},
 492 { "cstwx",      0x24000200, 0xfc001e00, "uct,x(b)", pa10},
 493 { "cstdx",      0x2c000200, 0xfc001e00, "uct,x(s,b)", pa10},
 494 { "cstdx",      0x2c000200, 0xfc001e00, "uct,x(b)", pa10},
 495 { "cldws",      0x24001000, 0xfc001e00, "uC5(s,b),t", pa10},
 496 { "cldws",      0x24001000, 0xfc001e00, "uC5(b),t", pa10},
 497 { "cldds",      0x2c001000, 0xfc001e00, "uC5(s,b),t", pa10},
 498 { "cldds",      0x2c001000, 0xfc001e00, "uC5(b),t", pa10},
 499 { "cstws",      0x24001200, 0xfc001e00, "uCt,5(s,b)", pa10},
 500 { "cstws",      0x24001200, 0xfc001e00, "uCt,5(b)", pa10},
 501 { "cstds",      0x2c001200, 0xfc001e00, "uCt,5(s,b)", pa10},
 502 { "cstds",      0x2c001200, 0xfc001e00, "uCt,5(b)", pa10},
 503 };
 504
 505 #define NUMOPCODES ((sizeof pa_opcodes)/(sizeof pa_opcodes[0]))
 506
 507 /* SKV 12/18/92. Added some denotations for various operands. */
 508
 509 #define PA_IMM11_AT_31 'i'
 510 #define PA_IMM14_AT_31 'j'
 511 #define PA_IMM21_AT_31 'k'
 512 #define PA_DISP12 'w'
 513 #define PA_DISP17 'W'
 514
 515 #define N_HPPA_OPERAND_FORMATS 5