include/opcode/hppa.h

   1 /* Table of opcodes for the PA-RISC.
   2    Copyright (C) 1990, 1991, 1993 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, 675 Mass Ave, Cambridge, MA 02139, 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 enum delay_type {NONE, NORMAL, CONDITIONAL};
  36 struct pa_opcode
  37 {
  38     const char *name;
  39     unsigned long int match;    /* Bits that must be set...  */
  40     unsigned long int mask;     /* ... in these bits. */
  41     char *args;
  42     /* Nonzero if this is a delayed branch instruction.  */
  43     /* What uses this field?  Nothing in opcodes or gas that I saw.
  44        If nothing needs it, we could reduce this table by 20% (for
  45        most machines).  KR */
  46     char delayed;
  47 };
  48
  49 /*
  50    All hppa opcodes are 32 bits.
  51
  52    The match component is a mask saying which bits must match a
  53    particular opcode in order for an instruction to be an instance
  54    of that opcode.
  55
  56    The args component is a string containing one character
  57    for each operand of the instruction.
  58
  59    Bit positions in this description follow HP usage of lsb = 31,
  60    "at" is lsb of field.
  61
  62 #ifndef OLD_TABLE
  63    In the args field, the following characters must match exactly:
  64
  65         '+,() '
  66
  67    In the args field, the following characters are unused:
  68
  69         '  "#$% '  *-  ./   34 6789:; =  @'
  70         ' B  E  HIJKL N  QR     X  [\] _'
  71         '    e gh   lm   qr   v  yz{|} '
  72
  73    Here are all the characters:
  74
  75         ' !"#$%&'()*+-,./0123456789:;<=>?@'
  76         'ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_'
  77         'abcdefghijklmnopqrstuvwxyz{|}~'
  78 #endif /* OLD_TABLE */
  79
  80 Kinds of operands:
  81    x    register field at 15.
  82    b    register field at 10.
  83    t    register field at 31.
  84    5    5 bit immediate at 15.
  85    s    2 bit space specifier at 17.
  86    S    3 bit space specifier at 18.
  87    c    indexed load completer.
  88    C    short load and store completer.
  89    Y    Store Bytes Short completer
  90    <    non-negated compare/subtract conditions.
  91 #ifndef OLD_TABLE
  92    a    compare/subtract conditions
  93    d    non-negated add conditions
  94 #else
  95    -    compare/subtract conditions
  96    +    non-negated add conditions
  97 #endif /* OLD_TABLE */
  98    &    logical instruction conditions
  99    U    unit instruction conditions
 100    >    shift/extract/deposit conditions.
 101    ~    bvb,bb conditions
 102    V    5 bit immediate value at 31
 103    i    11 bit immediate value at 31
 104    j    14 bit immediate value at 31
 105    k    21 bit immediate value at 31
 106    n    nullification for branch instructions
 107    w    12 bit branch displacement
 108    W    17 bit branch displacement
 109
 110 Also these:
 111
 112 #ifdef OLD_TABLE
 113    B    either s,b or b where
 114
 115            s    2 bit space specifier at 17.
 116            b    register field at 10.
 117 #endif /* OLD_TABLE */
 118
 119    p    5 bit shift count at 26 (to support the SHD instruction) encoded as
 120         31-p
 121    P    5 bit bit position at 26
 122    T    5 bit field length at 31 (encoded as 32-T)
 123    A    13 bit immediate at 18 (to support the BREAK instruction)
 124 #ifndef OLD_TABLE
 125    ^    like b, but describes a control register
 126    Z    System Control Completer (to support LPA, LHA, etc.)
 127 #else
 128    Z    System Control Completer (to support LDA, LHA, etc.)
 129 #endif /* OLD_TABLE */
 130    D    26 bit immediate at 31 (to support the DIAG instruction)
 131
 132    f    3 bit Special Function Unit identifier at 25
 133    O    20 bit Special Function Unit operation split between 15 bits at 20
 134         and 5 bits at 31
 135    o    15 bit Special Function Unit operation at 20
 136    2    22 bit Special Function Unit operation split between 17 bits at 20
 137         and 5 bits at 31
 138    1    15 bit Special Function Unit operation split between 10 bits at 20
 139         and 5 bits at 31
 140    0    10 bit Special Function Unit operation split between 5 bits at 20
 141         and 5 bits at 31
 142    u    3 bit coprocessor unit identifier at 25
 143    F    Source Floating Point Operand Format Completer encoded 2 bits at 20
 144    G    Destination Floating Point Operand Format Completer encoded 2 bits at 18
 145    M    Floating-Point Compare Conditions (encoded as 5 bits at 31)
 146 #ifdef GAS
 147    ?    negated or non-negated compare/subtract conditions
 148         (used only by 'comb' and 'comib' pseudo-instructions)
 149    !    negated or non-negated add conditions
 150         (used only by 'addb' and 'addib' pseudo-instructions)
 151 #else GDB
 152    ?    negated compare/subtract conditions.
 153    !    non-negated add conditions.
 154    @    negated add conditions.
 155 #endif
 156
 157 #ifndef OLD_TABLE
 158 No longer used:
 159    B    either s,b or b where
 160
 161            s    2 bit space specifier at 17.
 162            b    register field at 10.
 163 #else
 164    r    5 bit immediate value at 31 (for the break instruction)
 165         (very similar to V above, except the value is unsigned instead of
 166         low_sign_ext)
 167    R    5 bit immediate value at 15 (for the ssm, rsm instruction)
 168         (same as r above, except the value is in a different location)
 169    Q    5 bit immediate value at 10 (a bit position specified in
 170         the bb instruction. It's the same as r above, except the
 171         value is in a different location)
 172
 173 And these (PJH) for PA-89 F.P. registers and instructions:
 174
 175    v    a 't' operand type extended to handle L/R register halves.
 176    E    a 'b' operand type extended to handle L/R register halves.
 177    X    an 'x' operand type extended to handle L/R register halves.
 178    4    a variation of the 'b' operand type for 'fmpyadd' and 'fmpysub'
 179    6    a variation of the 'x' operand type for 'fmpyadd' and 'fmpysub'
 180    7    a variation of the 't' operand type for 'fmpyadd' and 'fmpysub'
 181    8    5 bit register field at 20 (used in 'fmpyadd' and 'fmpysub')
 182    9    5 bit register field at 25 (used in 'fmpyadd' and 'fmpysub')
 183    H    Floating Point Operand Format at 26 for 'fmpyadd' and 'fmpysub'
 184         (very similar to 'F')
 185 #endif /* OLD_TABLE */
 186
 187 */
 188
 189 /* The order of the opcodes in this table is significant:
 190
 191    * The assembler requires that all instances of the same mnemonic must be
 192    consecutive.  If they aren't, the assembler will bomb at runtime.
 193
 194    * The disassembler should not care about the order of the opcodes.  */
 195
 196 static const struct pa_opcode pa_opcodes[] =
 197 {
 198
 199 /* pseudo-instructions */
 200
 201 { "b",          0xe8000000, 0xffe0e000, "nW", NORMAL}, /* bl foo,r0 */
 202 { "ldi",        0x34000000, 0xffe0c000, "j,x"}, /* ldo val(r0),r */
 203 { "comib",      0x84000000, 0xfc000000, "?n5,b,w", CONDITIONAL}, /* comib{tf}*/
 204 { "comb",       0x80000000, 0xfc000000, "?nx,b,w", CONDITIONAL}, /* comb{tf} */
 205 { "addb",       0xa0000000, 0xfc000000, "!nx,b,w", CONDITIONAL}, /* addb{tf} */
 206 { "addib",      0xa4000000, 0xfc000000, "!n5,b,w", CONDITIONAL}, /* addib{tf}*/
 207 { "nop",        0x08000240, 0xffffffff, ""},      /* or 0,0,0 */
 208 { "copy",       0x08000240, 0xffe0ffe0, "x,t"},   /* or r,0,t */
 209 { "mtsar",      0x01601840, 0xffe0ffff, "x"}, /* mtctl r,cr11 */
 210
 211 #ifndef OLD_TABLE
 212 { "ldw",        0x48000000, 0xfc000000, "j(s,b),x"},
 213 { "ldw",        0x48000000, 0xfc000000, "j(b),x"},
 214 { "ldh",        0x44000000, 0xfc000000, "j(s,b),x"},
 215 { "ldh",        0x44000000, 0xfc000000, "j(b),x"},
 216 { "ldb",        0x40000000, 0xfc000000, "j(s,b),x"},
 217 { "ldb",        0x40000000, 0xfc000000, "j(b),x"},
 218 { "stw",        0x68000000, 0xfc000000, "x,j(s,b)"},
 219 { "stw",        0x68000000, 0xfc000000, "x,j(b)"},
 220 { "sth",        0x64000000, 0xfc000000, "x,j(s,b)"},
 221 { "sth",        0x64000000, 0xfc000000, "x,j(b)"},
 222 { "stb",        0x60000000, 0xfc000000, "x,j(s,b)"},
 223 { "stb",        0x60000000, 0xfc000000, "x,j(b)"},
 224 { "ldwm",       0x4c000000, 0xfc000000, "j(s,b),x"},
 225 { "ldwm",       0x4c000000, 0xfc000000, "j(b),x"},
 226 { "stwm",       0x6c000000, 0xfc000000, "x,j(s,b)"},
 227 { "stwm",       0x6c000000, 0xfc000000, "x,j(b)"},
 228 { "ldwx",       0x0c000080, 0xfc001fc0, "cx(s,b),t"},
 229 { "ldwx",       0x0c000080, 0xfc001fc0, "cx(b),t"},
 230 { "ldhx",       0x0c000040, 0xfc001fc0, "cx(s,b),t"},
 231 { "ldhx",       0x0c000040, 0xfc001fc0, "cx(b),t"},
 232 { "ldbx",       0x0c000000, 0xfc001fc0, "cx(s,b),t"},
 233 { "ldbx",       0x0c000000, 0xfc001fc0, "cx(b),t"},
 234 #else
 235 { "ldw",        0x48000000, 0xfc000000, "j(B),x"},
 236 { "ldh",        0x44000000, 0xfc000000, "j(B),x"},
 237 { "ldb",        0x40000000, 0xfc000000, "j(B),x"},
 238 { "stw",        0x68000000, 0xfc000000, "x,j(B)"},
 239 { "sth",        0x64000000, 0xfc000000, "x,j(B)"},
 240 { "stb",        0x60000000, 0xfc000000, "x,j(B)"},
 241 { "ldwm",       0x4c000000, 0xfc000000, "j(B),x"},
 242 { "stwm",       0x6c000000, 0xfc000000, "x,j(B)"},
 243 { "ldwx",       0x0c000080, 0xfc001fc0, "cx(B),t"},
 244 { "ldhx",       0x0c000040, 0xfc001fc0, "cx(B),t"},
 245 { "ldbx",       0x0c000000, 0xfc001fc0, "cx(B),t"},
 246 #endif /* OLD_TABLE */
 247 { "ldwax",      0x0c000180, 0xfc00dfc0, "cx(b),t"},
 248 #ifndef OLD_TABLE
 249 { "ldcwx",      0x0c0001c0, 0xfc001fc0, "cx(s,b),t"},
 250 { "ldcwx",      0x0c0001c0, 0xfc001fc0, "cx(b),t"},
 251 { "ldws",       0x0c001080, 0xfc001fc0, "C5(s,b),t"},
 252 { "ldws",       0x0c001080, 0xfc001fc0, "C5(b),t"},
 253 { "ldhs",       0x0c001040, 0xfc001fc0, "C5(s,b),t"},
 254 { "ldhs",       0x0c001040, 0xfc001fc0, "C5(b),t"},
 255 { "ldbs",       0x0c001000, 0xfc001fc0, "C5(s,b),t"},
 256 { "ldbs",       0x0c001000, 0xfc001fc0, "C5(b),t"},
 257 #else
 258 { "ldcwx",      0x0c0001c0, 0xfc001fc0, "cx(B),t"},
 259 { "ldws",       0x0c001080, 0xfc001fc0, "C5(B),t"},
 260 { "ldhs",       0x0c001040, 0xfc001fc0, "C5(B),t"},
 261 { "ldbs",       0x0c001000, 0xfc001fc0, "C5(B),t"},
 262 #endif /* OLD_TABLE */
 263 { "ldwas",      0x0c001180, 0xfc00dfc0, "C5(b),t"},
 264 #ifndef OLD_TABLE
 265 { "ldcws",      0x0c0011c0, 0xfc001fc0, "C5(s,b),t"},
 266 { "ldcws",      0x0c0011c0, 0xfc001fc0, "C5(b),t"},
 267 { "stws",       0x0c001280, 0xfc001fc0, "Cx,V(s,b)"},
 268 { "stws",       0x0c001280, 0xfc001fc0, "Cx,V(b)"},
 269 { "sths",       0x0c001240, 0xfc001fc0, "Cx,V(s,b)"},
 270 { "sths",       0x0c001240, 0xfc001fc0, "Cx,V(b)"},
 271 { "stbs",       0x0c001200, 0xfc001fc0, "Cx,V(s,b)"},
 272 { "stbs",       0x0c001200, 0xfc001fc0, "Cx,V(b)"},
 273 #else
 274 { "ldcws",      0x0c0011c0, 0xfc001fc0, "C5(B),t"},
 275 { "stws",       0x0c001280, 0xfc001fc0, "Cx,V(B)"},
 276 { "sths",       0x0c001240, 0xfc001fc0, "Cx,V(B)"},
 277 { "stbs",       0x0c001200, 0xfc001fc0, "Cx,V(B)"},
 278 #endif /* OLD_TABLE */
 279 { "stwas",      0x0c001380, 0xfc00dfc0, "Cx,V(b)"},
 280 #ifndef OLD_TABLE
 281 { "stbys",      0x0c001300, 0xfc001fc0, "Yx,V(s,b)"},
 282 { "stbys",      0x0c001300, 0xfc001fc0, "Yx,V(b)"},
 283 #else
 284 { "stbys",      0x0c001300, 0xfc001fc0, "Yx,V(B)"},
 285 #endif /* OLD_TABLE */
 286 { "ldo",        0x34000000, 0xfc00c000, "j(b),x"},
 287 { "ldil",       0x20000000, 0xfc000000, "k,b"},
 288 { "addil",      0x28000000, 0xfc000000, "k,b"},
 289 { "bl",         0xe8000000, 0xfc00e000, "nW,b", NORMAL},
 290 { "gate",       0xe8002000, 0xfc00e000, "nW,b", NORMAL},
 291 { "blr",        0xe8004000, 0xfc00e001, "nx,b", NORMAL},
 292 #ifndef OLD_TABLE
 293 { "bv",         0xe800c000, 0xfc00e001, "n(b)", NORMAL},
 294 #endif /* OLD_TABLE */
 295 { "bv",         0xe800c000, 0xfc00e001, "nx(b)", NORMAL},
 296 { "be",         0xe0000000, 0xfc000000, "nW(S,b)", NORMAL},
 297 { "ble",        0xe4000000, 0xfc000000, "nW(S,b)", NORMAL},
 298 { "movb",       0xc8000000, 0xfc000000, ">nx,b,w", CONDITIONAL},
 299 { "movib",      0xcc000000, 0xfc000000, ">n5,b,w", CONDITIONAL},
 300 { "combt",      0x80000000, 0xfc000000, "<nx,b,w", CONDITIONAL},
 301 { "combf",      0x88000000, 0xfc000000, "<nx,b,w", CONDITIONAL},
 302 { "comibt",     0x84000000, 0xfc000000, "<n5,b,w", CONDITIONAL},
 303 { "comibf",     0x8c000000, 0xfc000000, "<n5,b,w", CONDITIONAL},
 304 #ifndef OLD_TABLE
 305 { "addbt",      0xa0000000, 0xfc000000, "!nx,b,w", CONDITIONAL},
 306 { "addbf",      0xa8000000, 0xfc000000, "!nx,b,w", CONDITIONAL},
 307 { "addibt",     0xa4000000, 0xfc000000, "!n5,b,w", CONDITIONAL},
 308 { "addibf",     0xac000000, 0xfc000000, "!n5,b,w", CONDITIONAL},
 309 #else
 310 { "addbt",      0xa0000000, 0xfc000000, "+nx,b,w", CONDITIONAL},
 311 { "addbf",      0xa8000000, 0xfc000000, "+nx,b,w", CONDITIONAL},
 312 { "addibt",     0xa4000000, 0xfc000000, "+n5,b,w", CONDITIONAL},
 313 { "addibf",     0xac000000, 0xfc000000, "+n5,b,w", CONDITIONAL},
 314 #endif /* OLD_TABLE */
 315 { "bvb",        0xc0000000, 0xffe00000, "~nx,w", CONDITIONAL},
 316 #ifndef OLD_TABLE
 317 { "bb",         0xc4000000, 0xfc000000, "~nx,b,w", CONDITIONAL}, /* maybe */
 318 #else
 319 { "bb",         0xc4000000, 0xfc000000, "~nx,Q,w", CONDITIONAL}, /* maybe */
 320 #endif /* OLD_TABLE */
 321
 322 /* Computation Instructions */
 323
 324 #ifndef OLD_TABLE
 325 { "add",        0x08000600, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 326 { "addl",       0x08000a00, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 327 { "addo",       0x08000e00, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 328 { "addc",       0x08000700, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 329 { "addco",      0x08000f00, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 330 { "sh1add",     0x08000640, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 331 { "sh1addl",    0x08000a40, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 332 { "sh1addo",    0x08000e40, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 333 { "sh2add",     0x08000680, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 334 { "sh2addl",    0x08000a80, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 335 { "sh2addo",    0x08000e80, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 336 { "sh3add",     0x080006c0, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 337 { "sh3addl",    0x08000ac0, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 338 { "sh3addo",    0x08000ec0, 0xfc000fe0, "dx,b,t", CONDITIONAL},
 339 { "sub",        0x08000400, 0xfc000fe0, "ax,b,t", CONDITIONAL},
 340 { "subo",       0x08000c00, 0xfc000fe0, "ax,b,t", CONDITIONAL},
 341 { "subb",       0x08000500, 0xfc000fe0, "ax,b,t", CONDITIONAL},
 342 { "subbo",      0x08000d00, 0xfc000fe0, "ax,b,t", CONDITIONAL},
 343 { "subt",       0x080004c0, 0xfc000fe0, "ax,b,t", CONDITIONAL},
 344 { "subto",      0x08000cc0, 0xfc000fe0, "ax,b,t", CONDITIONAL},
 345 { "ds",         0x08000440, 0xfc000fe0, "ax,b,t", CONDITIONAL},
 346 { "comclr",     0x08000880, 0xfc000fe0, "ax,b,t", CONDITIONAL},
 347 #else
 348 { "add",        0x08000600, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 349 { "addl",       0x08000a00, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 350 { "addo",       0x08000e00, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 351 { "addc",       0x08000700, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 352 { "addco",      0x08000f00, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 353 { "sh1add",     0x08000640, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 354 { "sh1addl",    0x08000a40, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 355 { "sh1addo",    0x08000e40, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 356 { "sh2add",     0x08000680, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 357 { "sh2addl",    0x08000a80, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 358 { "sh2addo",    0x08000e80, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 359 { "sh3add",     0x080006c0, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 360 { "sh3addl",    0x08000ac0, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 361 { "sh3addo",    0x08000ec0, 0xfc000fe0, "+x,b,t", CONDITIONAL},
 362 { "sub",        0x08000400, 0xfc000fe0, "-x,b,t", CONDITIONAL},
 363 { "subo",       0x08000c00, 0xfc000fe0, "-x,b,t", CONDITIONAL},
 364 { "subb",       0x08000500, 0xfc000fe0, "-x,b,t", CONDITIONAL},
 365 { "subbo",      0x08000d00, 0xfc000fe0, "-x,b,t", CONDITIONAL},
 366 { "subt",       0x080004c0, 0xfc000fe0, "-x,b,t", CONDITIONAL},
 367 { "subto",      0x08000cc0, 0xfc000fe0, "-x,b,t", CONDITIONAL},
 368 { "ds",         0x08000440, 0xfc000fe0, "-x,b,t", CONDITIONAL},
 369 { "comclr",     0x08000880, 0xfc000fe0, "-x,b,t", CONDITIONAL},
 370 #endif /* OLD_TABLE */
 371 { "or",         0x08000240, 0xfc000fe0, "&x,b,t", CONDITIONAL},
 372 { "xor",        0x08000280, 0xfc000fe0, "&x,b,t", CONDITIONAL},
 373 { "and",        0x08000200, 0xfc000fe0, "&x,b,t", CONDITIONAL},
 374 { "andcm",      0x08000000, 0xfc000fe0, "&x,b,t", CONDITIONAL},
 375 { "uxor",       0x08000380, 0xfc000fe0, "Ux,b,t", CONDITIONAL},
 376 { "uaddcm",     0x08000980, 0xfc000fe0, "Ux,b,t", CONDITIONAL},
 377 { "uaddcmt",    0x080009c0, 0xfc000fe0, "Ux,b,t", CONDITIONAL},
 378 { "dcor",       0x08000b80, 0xfc1f0fe0, "Ub,t",   CONDITIONAL},
 379 { "idcor",      0x08000bc0, 0xfc1f0fe0, "Ub,t",   CONDITIONAL},
 380 #ifndef OLD_TABLE
 381 { "addi",       0xb4000000, 0xfc000800, "di,b,x", CONDITIONAL},
 382 { "addio",      0xb4000800, 0xfc000800, "di,b,x", CONDITIONAL},
 383 { "addit",      0xb0000000, 0xfc000800, "di,b,x", CONDITIONAL},
 384 { "addito",     0xb0000800, 0xfc000800, "di,b,x", CONDITIONAL},
 385 { "subi",       0x94000000, 0xfc000800, "ai,b,x", CONDITIONAL},
 386 { "subio",      0x94000800, 0xfc000800, "ai,b,x", CONDITIONAL},
 387 { "comiclr",    0x90000000, 0xfc000800, "ai,b,x", CONDITIONAL},
 388 #else
 389 { "addi",       0xb4000000, 0xfc000800, "+i,b,x", CONDITIONAL},
 390 { "addio",      0xb4000800, 0xfc000800, "+i,b,x", CONDITIONAL},
 391 { "addit",      0xb0000000, 0xfc000800, "+i,b,x", CONDITIONAL},
 392 { "addito",     0xb0000800, 0xfc000800, "+i,b,x", CONDITIONAL},
 393 { "subi",       0x94000000, 0xfc000800, "-i,b,x", CONDITIONAL},
 394 { "subio",      0x94000800, 0xfc000800, "-i,b,x", CONDITIONAL},
 395 { "comiclr",    0x90000000, 0xfc000800, "-i,b,x", CONDITIONAL},
 396 #endif /* OLD_TABLE */
 397
 398 /* Extract and Deposit Instructions */
 399
 400 { "vshd",       0xd0000000, 0xfc001fe0, ">x,b,t", CONDITIONAL},
 401 { "shd",        0xd0000800, 0xfc001c00, ">x,b,p,t", CONDITIONAL},
 402 { "vextru",     0xd0001000, 0xfc001fe0, ">b,T,x", CONDITIONAL},
 403 { "vextrs",     0xd0001400, 0xfc001fe0, ">b,T,x", CONDITIONAL},
 404 { "extru",      0xd0001800, 0xfc001c00, ">b,P,T,x", CONDITIONAL},
 405 { "extrs",      0xd0001c00, 0xfc001c00, ">b,P,T,x", CONDITIONAL},
 406 { "zvdep",      0xd4000000, 0xfc001fe0, ">x,T,b", CONDITIONAL},
 407 { "vdep",       0xd4000400, 0xfc001fe0, ">x,T,b", CONDITIONAL},
 408 { "zdep",       0xd4000800, 0xfc001c00, ">x,p,T,b", CONDITIONAL},
 409 { "dep",        0xd4000c00, 0xfc001c00, ">x,p,T,b", CONDITIONAL},
 410 { "zvdepi",     0xd4001000, 0xfc001fe0, ">5,T,b", CONDITIONAL},
 411 { "vdepi",      0xd4001400, 0xfc001fe0, ">5,T,b", CONDITIONAL},
 412 { "zdepi",      0xd4001800, 0xfc001c00, ">5,p,T,b", CONDITIONAL},
 413 { "depi",       0xd4001c00, 0xfc001c00, ">5,p,T,b", CONDITIONAL},
 414
 415 /* System Control Instructions */
 416
 417 #ifndef OLD_TABLE
 418 { "break",      0x00000000, 0xfc001fe0, "V,A"},
 419 #else
 420 { "break",      0x00000000, 0xfc001fe0, "r,A"},
 421 #endif /* OLD_TABLE */
 422 { "rfi",        0x00000c00, 0xffffffff, ""},
 423 #ifndef OLD_TABLE
 424 { "ssm",        0x00000d60, 0xffe0ffe0, "5,t"},
 425 { "rsm",        0x00000e60, 0xffe0ffe0, "5,t"},
 426 #else
 427 { "ssm",        0x00000d60, 0xffe0ffe0, "R,t"},
 428 { "rsm",        0x00000e60, 0xffe0ffe0, "R,t"},
 429 #endif /* OLD_TABLE */
 430 { "mtsm",       0x00001860, 0xffe0ffff, "x"},
 431 #ifndef OLD_TABLE
 432 { "ldsid",      0x000010a0, 0xfc1f3fe0, "(s,b),t"},
 433 { "ldsid",      0x000010a0, 0xfc1f3fe0, "(b),t"},
 434 #else
 435 { "ldsid",      0x000010a0, 0xfc1f3fe0, "(B),t"},
 436 #endif /* OLD_TABLE */
 437 { "mtsp",       0x00001820, 0xffe01fff, "x,S"},
 438 #ifndef OLD_TABLE
 439 { "mtctl",      0x00001840, 0xfc00ffff, "x,^"},
 440 #else
 441 { "mtctl",      0x00001840, 0xfc00ffff, "x,b"},
 442 #endif /* OLD_TABLE */
 443 { "mfsp",       0x000004a0, 0xffff1fe0, "S,t"},
 444 #ifndef OLD_TABLE
 445 { "mfctl",      0x000008a0, 0xfc1fffe0, "^,t"},
 446 #else
 447 { "mfctl",      0x000008a0, 0xfc1fffe0, "b,t"},
 448 #endif /* OLD_TABLE */
 449 { "sync",       0x00000400, 0xffffffff, ""},
 450 #ifndef OLD_TABLE
 451 { "prober",     0x04001180, 0xfc003fe0, "(s,b),x,t"},
 452 { "prober",     0x04001180, 0xfc003fe0, "(b),x,t"},
 453 { "proberi",    0x04003180, 0xfc003fe0, "(s,b),5,t"},
 454 { "proberi",    0x04003180, 0xfc003fe0, "(b),5,t"},
 455 { "probew",     0x040011c0, 0xfc003fe0, "(s,b),x,t"},
 456 { "probew",     0x040011c0, 0xfc003fe0, "(b),x,t"},
 457 { "probewi",    0x040031c0, 0xfc003fe0, "(s,b),5,t"},
 458 { "probewi",    0x040031c0, 0xfc003fe0, "(b),5,t"},
 459 { "lpa",        0x04001340, 0xfc003fc0, "Zx(s,b),t"},
 460 { "lpa",        0x04001340, 0xfc003fc0, "Zx(b),t"},
 461
 462 { "lha",        0x04001300, 0xfc003fc0, "Zx(s,b),t"},
 463 { "lha",        0x04001300, 0xfc003fc0, "Zx(b),t"},
 464
 465 { "pdtlb",      0x04001200, 0xfc003fdf, "Zx(s,b)"},
 466 { "pdtlb",      0x04001200, 0xfc003fdf, "Zx(b)"},
 467
 468 { "pitlb",      0x04000200, 0xfc003fdf, "Zx(s,b)"},
 469 { "pitlb",      0x04000200, 0xfc003fdf, "Zx(b)"},
 470
 471 { "pdtlbe",     0x04001240, 0xfc003fdf, "Zx(s,b)"},
 472 { "pdtlbe",     0x04001240, 0xfc003fdf, "Zx(b)"},
 473
 474 { "pitlbe",     0x04000240, 0xfc003fdf, "Zx(s,b)"},
 475 { "pitlbe",     0x04000240, 0xfc003fdf, "Zx(b)"},
 476
 477 { "idtlba",     0x04001040, 0xfc003fff, "x,(s,b)"},
 478 { "idtlba",     0x04001040, 0xfc003fff, "x,(b)"},
 479
 480 { "iitlba",     0x04000040, 0xfc003fff, "x,(s,b)"},
 481 { "iitlba",     0x04000040, 0xfc003fff, "x,(b)"},
 482
 483 { "idtlbp",     0x04001000, 0xfc003fff, "x,(s,b)"},
 484 { "idtlbp",     0x04001000, 0xfc003fff, "x,(b)"},
 485
 486 { "iitlbp",     0x04000000, 0xfc003fff, "x,(s,b)"},
 487 { "iitlbp",     0x04000000, 0xfc003fff, "x,(b)"},
 488
 489 { "pdc",        0x04001380, 0xfc003fdf, "Zx(s,b)"},
 490 { "pdc",        0x04001380, 0xfc003fdf, "Zx(b)"},
 491
 492 { "fdc",        0x04001280, 0xfc003fdf, "Zx(s,b)"},
 493 { "fdc",        0x04001280, 0xfc003fdf, "Zx(b)"},
 494
 495 { "fic",        0x04000280, 0xfc003fdf, "Zx(s,b)"},
 496 { "fic",        0x04000280, 0xfc003fdf, "Zx(b)"},
 497
 498 { "fdce",       0x040012c0, 0xfc003fdf, "Zx(s,b)"},
 499 { "fdce",       0x040012c0, 0xfc003fdf, "Zx(b)"},
 500
 501 { "fice",       0x040002c0, 0xfc003fdf, "Zx(s,b)"},
 502 { "fice",       0x040002c0, 0xfc003fdf, "Zx(b)"},
 503
 504 #else
 505 { "prober",     0x04001180, 0xfc003fe0, "(B),x,t"},
 506 { "proberi",    0x04003180, 0xfc003fe0, "(B),5,t"},
 507 { "probew",     0x040011c0, 0xfc003fe0, "(B),x,t"},
 508 { "probewi",    0x040031c0, 0xfc003fe0, "(B),5,t"},
 509 { "lpa",        0x04001340, 0xfc003fc0, "Zx(B),t"},
 510 { "lha",        0x04001300, 0xfc003fc0, "Zx(B),t"},
 511 { "pdtlb",      0x04001200, 0xfc003fdf, "Zx(B)"},
 512 { "pitlb",      0x04000200, 0xfc003fdf, "Zx(B)"},
 513 { "pdtlbe",     0x04001240, 0xfc003fdf, "Zx(B)"},
 514 { "pitlbe",     0x04000240, 0xfc003fdf, "Zx(B)"},
 515 { "idtlba",     0x04001040, 0xfc003fff, "x,(B)"},
 516 { "iitlba",     0x04000040, 0xfc003fff, "x,(B)"},
 517 { "idtlbp",     0x04001000, 0xfc003fff, "x,(B)"},
 518 { "iitlbp",     0x04000000, 0xfc003fff, "x,(B)"},
 519 { "pdc",        0x04001380, 0xfc003fdf, "Zx(B)"},
 520 { "fdc",        0x04001280, 0xfc003fdf, "Zx(B)"},
 521 { "fic",        0x04000280, 0xfc003fdf, "Zx(B)"},
 522 { "fdce",       0x040012c0, 0xfc003fdf, "Zx(B)"},
 523 { "fice",       0x040002c0, 0xfc003fdf, "Zx(B)"},
 524 #endif /* OLD_TABLE */
 525 { "diag",       0x14000000, 0xfc000000, "D"},
 526
 527 /* Floating Point Coprocessor Instructions */
 528
 529 #ifndef OLD_TABLE
 530 { "fldwx",      0x24000000, 0xfc001fc0, "cx(s,b),t"},
 531 { "fldwx",      0x24000000, 0xfc001fc0, "cx(b),t"},
 532 #else
 533 { "fldwx",      0x24000000, 0xfc001f80, "cx(B),v"}, /* PJH:  v used to be t */
 534                                     /* and 0xfc001f80 used to be 0xfc001fc0 */
 535 { "flddx",      0x2c000000, 0xfc001fc0, "cx(B),t"},
 536 { "fstwx",      0x24000200, 0xfc001fc0, "cv,x(B)"}, /* PJH:  v used to be t */
 537 { "fstdx",      0x2c000200, 0xfc001fc0, "ct,x(B)"},
 538 { "fldws",      0x24001000, 0xfc001fc0, "C5(B),v"}, /* PJH:  v used to be t */
 539 { "fldds",      0x2c001000, 0xfc001fc0, "C5(B),t"},
 540 { "fstws",      0x24001200, 0xfc001fc0, "Cv,5(B)"}, /* PJH:  v used to be t */
 541 { "fstds",      0x2c001200, 0xfc001fc0, "Ct,5(B)"},
 542 { "fadd",       0x30000600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
 543 { "fsub",       0x30002600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
 544 { "fmpy",       0x30004600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
 545 { "fdiv",       0x30006600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
 546 { "fsqrt",      0x30008000, 0xfc1fe7e0, "FE,v"},   /* PJH: operands were "Fb,t" */
 547 { "fabs",       0x30006000, 0xfc1fe7e0, "FE,v"},   /* PJH: operands were "Fb,t" */
 548 { "frem",       0x30008600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
 549 { "frnd",       0x3000a000, 0xfc1fe7e0, "FE,v"},   /* PJH: operands were "Fb,t" */
 550 { "fcpy",       0x30004000, 0xfc1fe7e0, "FE,v"},   /* PJH: operands were "Fb,t" */
 551 { "fcnvff",     0x30000200, 0xfc1f87e0, "FGE,v"},  /* PJH: operands were "FGb,t" */
 552 { "fcnvxf",     0x30008200, 0xfc1f87e0, "FGE,v"},  /* PJH: operands were "FGb,t" */
 553 { "fcnvfx",     0x30010200, 0xfc1f87e0, "FGE,v"},  /* PJH: operands were "FGb,t" */
 554 { "fcnvfxt",    0x30018200, 0xfc1f87e0, "FGE,v"},  /* PJH: operands were "FGb,t" */
 555 { "fcmp",       0x30000400, 0xfc00e7e0, "FME,X"},  /* PJH: operands were "FMb,x" */
 556 { "ftest",      0x30002420, 0xffffffff, ""},
 557 #endif /* OLD_TABLE */
 558
 559 #ifndef OLD_TABLE
 560 { "flddx",      0x2c000000, 0xfc001fc0, "cx(s,b),t"},
 561 { "flddx",      0x2c000000, 0xfc001fc0, "cx(b),t"},
 562 #else
 563 /* PA-89 only instructions */
 564 #endif /* OLD_TABLE */
 565
 566 #ifndef OLD_TABLE
 567 { "fstwx",      0x24000200, 0xfc001fc0, "ct,x(s,b)"},
 568 { "fstwx",      0x24000200, 0xfc001fc0, "ct,x(b)"},
 569 #else
 570 { "xmpyu",      0x38004700, 0xfc00e720, "FE,X,v"},
 571 { "fmpyadd",    0x18000000, 0xfc000000, "H4,6,7,9,8"},
 572 { "fmpysub",    0x98000000, 0xfc000000, "H4,6,7,9,8"},
 573 #endif /* OLD_TABLE */
 574
 575 #ifndef OLD_TABLE
 576 { "fstdx",      0x2c000200, 0xfc001fc0, "ct,x(s,b)"},
 577 { "fstdx",      0x2c000200, 0xfc001fc0, "ct,x(b)"},
 578
 579 { "fldws",      0x24001000, 0xfc001fc0, "C5(s,b),t"},
 580 { "fldws",      0x24001000, 0xfc001fc0, "C5(b),t"},
 581
 582 { "fldds",      0x2c001000, 0xfc001fc0, "C5(s,b),t"},
 583 { "fldds",      0x2c001000, 0xfc001fc0, "C5(b),t"},
 584
 585 { "fstws",      0x24001200, 0xfc001fc0, "Ct,5(s,b)"},
 586 { "fstws",      0x24001200, 0xfc001fc0, "Ct,5(b)"},
 587
 588 { "fstds",      0x2c001200, 0xfc001fc0, "Ct,5(s,b)"},
 589 { "fstds",      0x2c001200, 0xfc001fc0, "Ct,5(b)"},
 590
 591 { "fadd",       0x30000600, 0xfc00e7e0, "Fb,x,t"},
 592 { "fsub",       0x30002600, 0xfc00e7e0, "Fb,x,t"},
 593 { "fmpy",       0x30004600, 0xfc00e7e0, "Fb,x,t"},
 594 { "fdiv",       0x30006600, 0xfc00e7e0, "Fb,x,t"},
 595 { "fsqrt",      0x30008000, 0xfc1fe7e0, "Fb,t"},
 596 { "fabs",       0x30006000, 0xfc1fe7e0, "Fb,t"},
 597 { "frem",       0x30008600, 0xfc00e7e0, "Fb,x,t"},
 598 { "frnd",       0x3000a000, 0xfc1fe7e0, "Fb,t"},
 599 { "fcpy",       0x30004000, 0xfc1fe7e0, "Fb,t"},
 600 { "fcnvff",     0x30000200, 0xfc1f87e0, "FGb,t"},
 601 { "fcnvxf",     0x30008200, 0xfc1f87e0, "FGb,t"},
 602 { "fcnvfx",     0x30010200, 0xfc1f87e0, "FGb,t"},
 603 { "fcnvfxt",    0x30018200, 0xfc1f87e0, "FGb,t"},
 604 { "fcmp",       0x30000400, 0xfc00e7e0, "FMb,x"},
 605 { "ftest",      0x30002420, 0xffffffff, ""},
 606
 607 #endif /* OLD_TABLE */
 608 /* Assist Instructions */
 609
 610 { "spop0",      0x10000000, 0xfc000600, ",f,On", NORMAL},
 611 { "spop1",      0x10000200, 0xfc000600, ",f,ont", NORMAL},
 612 { "spop2",      0x10000400, 0xfc000600, ",f,1nb", NORMAL},
 613 { "spop3",      0x10000600, 0xfc000600, ",f,0nx,b", NORMAL},
 614 { "copr",       0x30000000, 0xfc000000, ",u,2n", NORMAL},
 615 #ifndef OLD_TABLE
 616 { "cldwx",      0x24000000, 0xfc001e00, ",u,Zx(s,b),t"},
 617 { "cldwx",      0x24000000, 0xfc001e00, ",u,Zx(b),t"},
 618 { "clddx",      0x2c000000, 0xfc001e00, ",u,Zx(s,b),t"},
 619 { "clddx",      0x2c000000, 0xfc001e00, ",u,Zx(b),t"},
 620 { "cstwx",      0x24000200, 0xfc001e00, ",u,Zt,x(s,b)"},
 621 { "cstwx",      0x24000200, 0xfc001e00, ",u,Zt,x(b)"},
 622 { "cstdx",      0x2c000200, 0xfc001e00, ",u,Zt,x(s,b)"},
 623 { "cstdx",      0x2c000200, 0xfc001e00, ",u,Zt,x(b)"},
 624 { "cldws",      0x24001000, 0xfc001e00, ",u,Z5(s,b),t"},
 625 { "cldws",      0x24001000, 0xfc001e00, ",u,Z5(b),t"},
 626 { "cldds",      0x2c001000, 0xfc001e00, ",u,Z5(s,b),t"},
 627 { "cldds",      0x2c001000, 0xfc001e00, ",u,Z5(b),t"},
 628 { "cstws",      0x24001200, 0xfc001e00, ",u,Zt,5(s,b)"},
 629 { "cstws",      0x24001200, 0xfc001e00, ",u,Zt,5(b)"},
 630 { "cstds",      0x2c001200, 0xfc001e00, ",u,Zt,5(s,b)"},
 631 { "cstds",      0x2c001200, 0xfc001e00, ",u,Zt,5(b)"},
 632 #else
 633 { "cldwx",      0x24000000, 0xfc001e00, ",u,Zx(B),t"},
 634 { "clddx",      0x2c000000, 0xfc001e00, ",u,Zx(B),t"},
 635 { "cstwx",      0x24000200, 0xfc001e00, ",u,Zt,x(B)"},
 636 { "cstdx",      0x2c000200, 0xfc001e00, ",u,Zt,x(B)"},
 637 { "cldws",      0x24001000, 0xfc001e00, ",u,Z5(B),t"},
 638 { "cldds",      0x2c001000, 0xfc001e00, ",u,Z5(B),t"},
 639 { "cstws",      0x24001200, 0xfc001e00, ",u,Zt,5(B)"},
 640 { "cstds",      0x2c001200, 0xfc001e00, ",u,Zt,5(B)"},
 641 #endif /* OLD_TABLE */
 642 };
 643
 644 #define NUMOPCODES ((sizeof pa_opcodes)/(sizeof pa_opcodes[0]))
 645 #ifndef OLD_TABLE
 646
 647 /* SKV 12/18/92. Added some denotations for various operands. */
 648
 649 #define PA_IMM11_AT_31 'i'
 650 #define PA_IMM14_AT_31 'j'
 651 #define PA_IMM21_AT_31 'k'
 652 #define PA_DISP12 'w'
 653 #define PA_DISP17 'W'
 654
 655 #define N_HPPA_OPERAND_FORMATS 5
 656 #endif /* OLD_TABLE */