2003-01-07 Chris Demetriou <cgd@broadcom.com>
[deliverable/binutils-gdb.git] / include / opcode / hppa.h
index 9ce59c364f59bae267eedffc7469e475855d5bee..471161788ad73b463997d226e974b0fa3b8f460b 100644 (file)
@@ -1,5 +1,7 @@
 /* Table of opcodes for the PA-RISC.
-   Copyright (C) 1990, 1991, 1993, 1995, 1999 Free Software Foundation, Inc.
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000,
+   2001, 2002
+   Free Software Foundation, Inc.
 
    Contributed by the Center for Software Science at the
    University of Utah (pa-gdb-bugs@cs.utah.edu).
@@ -70,15 +72,15 @@ struct pa_opcode
 
    In the args field, the following characters are unused:
 
-       '  "         -  /   34 6789:;< > @'
-       '  C         M             [\]  '
-       '    e g                     } '
+       '  "         -  /   34 6789:;    '
+       '@  C         M             [\]  '
+       '`    e g                     }  '
 
    Here are all the characters:
 
-       ' !"#$%&'()*+-,./0123456789:;<=>?@'
-       'ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_'
-       'abcdefghijklmnopqrstuvwxyz{|}~'
+       ' !"#$%&'()*+-,./0123456789:;<=>?'
+       '@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_'
+       '`abcdefghijklmnopqrstuvwxyz{|}~ '
 
 Kinds of operands:
    x    integer register field at 15.
@@ -146,7 +148,7 @@ Also these:
        the bb instruction. It's the same as r above, except the
         value is in a different location)
    B   5 bit immediate value at 10 (a bit position specified in
-       the bb instruction. Similar to Q, but 64bit handling is
+       the bb instruction. Similar to Q, but 64 bit handling is
        different.
    Z    %r1 -- implicit target of addil instruction.
    L    ,%r2 completer for new syntax branch
@@ -154,22 +156,30 @@ Also these:
    _    Destination format completer for fcnv
    h    cbit for fcmp
    =    gfx tests for ftest
-   d    14bit offset for single precision FP long load/store.
-   #    14bit offset for double precision FP load long/store.
-   J    Yet another 14bit offset with an unusual encoding.
-   K    Yet another 14bit offset with an unusual encoding.
-   y    16bit offset for single precision FP long load/store (PA2.0 wide).
-   &    16bit offset for double precision FP long load/store (PA2.0 wide).
+   d    14 bit offset for single precision FP long load/store.
+   #    14 bit offset for double precision FP load long/store.
+   J    Yet another 14 bit offset for load/store with ma,mb completers.
+   K    Yet another 14 bit offset for load/store with ma,mb completers.
+   y    16 bit offset for word aligned load/store (PA2.0 wide).
+   &    16 bit offset for dword aligned load/store (PA2.0 wide).
+   <    16 bit offset for load/store with ma,mb completers (PA2.0 wide).
+   >    16 bit offset for load/store with ma,mb completers (PA2.0 wide).
    Y    %sr0,%r31 -- implicit target of be,l instruction.
    @   implicit immediate value of 0
 
 Completer operands all have 'c' as the prefix:
 
    cx   indexed load completer.
+   cX   indexed load completer.  Like cx, but emits a space after
+        in disassembler.
    cm   short load and store completer.
+   cM   short load and store completer.  Like cm, but emits a space
+        after in disassembler.
    cq   long load and store completer (like cm, but inserted into a
        different location in the target instruction).
    cs   store bytes short completer.
+   cA   store bytes short completer.  Like cs, but emits a space
+        after in disassembler.
    ce   long load/store completer for LDW/STW with a different encoding than the
        others
    cc   load cache control hint
@@ -200,6 +210,7 @@ Completer operands all have 'c' as the prefix:
    ch  left/right half completer
    cH  signed/unsigned saturation completer
    cS  signed/unsigned completer at 21
+   cz  zero/sign extension completer.
    c*  permutation completer
 
 Condition operands all have '?' as the prefix:
@@ -260,10 +271,12 @@ Float registers for fmpyadd and fmpysub:
 */
 
 
+#if 0
 /* List of characters not to put a space after.  Note that
    "," is included, as the "spopN" operations use literal
    commas in their completer sections.  */
 static const char *const completer_chars = ",CcY<>?!@+&U~FfGHINnOoZMadu|/=0123%e$m}";
+#endif
 
 /* The order of the opcodes in this table is significant:
 
@@ -277,12 +290,9 @@ static const struct pa_opcode pa_opcodes[] =
 
 /* Pseudo-instructions.  */
 
+{ "ldi",       0x34000000, 0xffe00000, "l,x", pa20w, 0},/* ldo val(r0),r */
 { "ldi",       0x34000000, 0xffe0c000, "j,x", pa10, 0},/* ldo val(r0),r */
 
-{ "call",      0xe800f000, 0xfc1ffffd, "n(b)", pa20, FLAG_STRICT},
-{ "call",      0xe800a000, 0xffe0e000, "nW", pa10, FLAG_STRICT},
-{ "ret",       0xe840d000, 0xfffffffd, "n", pa20, FLAG_STRICT},
-
 { "cmpib",     0xec000000, 0xfc000000, "?Qn5,b,w", pa20, FLAG_STRICT},
 { "cmpib",     0x84000000, 0xf4000000, "?nn5,b,w", pa10, FLAG_STRICT},
 { "comib",     0x84000000, 0xfc000000, "?nn5,b,w", pa10, 0}, /* comib{tf}*/
@@ -295,12 +305,12 @@ static const struct pa_opcode pa_opcodes[] =
 /* This entry is for the disassembler only.  It will never be used by
    assembler.  */
 { "comb",      0x88000000, 0xfc000000, "?nnx,b,w", pa10, 0}, /* comb{tf} */
-{ "addb",      0xa0000000, 0xf4000000, "?Wnx,b,w", pa20, FLAG_STRICT},
+{ "addb",      0xa0000000, 0xf4000000, "?Wnx,b,w", pa20w, FLAG_STRICT},
 { "addb",      0xa0000000, 0xfc000000, "?@nx,b,w", pa10, 0}, /* addb{tf} */
 /* This entry is for the disassembler only.  It will never be used by
    assembler.  */
 { "addb",      0xa8000000, 0xfc000000, "?@nx,b,w", pa10, 0},
-{ "addib",     0xa4000000, 0xf4000000, "?Wn5,b,w", pa20, FLAG_STRICT},
+{ "addib",     0xa4000000, 0xf4000000, "?Wn5,b,w", pa20w, FLAG_STRICT},
 { "addib",     0xa4000000, 0xfc000000, "?@n5,b,w", pa10, 0}, /* addib{tf}*/
 /* This entry is for the disassembler only.  It will never be used by
    assembler.  */
@@ -319,36 +329,37 @@ static const struct pa_opcode pa_opcodes[] =
 { "ldd",       0x0c0010c0, 0xfc0013c0, "cmcc5(b),t", pa20, FLAG_STRICT},
 { "ldd",        0x50000000, 0xfc000002, "cq&(b),x", pa20w, FLAG_STRICT},
 { "ldd",        0x50000000, 0xfc000002, "cq#(b),x", pa20, FLAG_STRICT},
-{ "ldw",        0x48000000, 0xfc000000, "l(b),x", pa20w, FLAG_STRICT},
 { "ldw",        0x0c000080, 0xfc0013c0, "cxccx(s,b),t", pa10, FLAG_STRICT},
 { "ldw",        0x0c000080, 0xfc0013c0, "cxccx(b),t", pa10, FLAG_STRICT},
-{ "ldw",       0x0c0010a0, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT},
-{ "ldw",       0x0c0010a0, 0xfc1f33e0, "cocc@(b),t", pa20, FLAG_STRICT},
 { "ldw",       0x0c001080, 0xfc0013c0, "cmcc5(s,b),t", pa10, FLAG_STRICT},
 { "ldw",       0x0c001080, 0xfc0013c0, "cmcc5(b),t", pa10, FLAG_STRICT},
+{ "ldw",       0x0c0010a0, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT},
+{ "ldw",       0x0c0010a0, 0xfc1f33e0, "cocc@(b),t", pa20, FLAG_STRICT},
+{ "ldw",        0x4c000000, 0xfc000000, "ce<(b),x", pa20w, FLAG_STRICT},
 { "ldw",        0x4c000000, 0xfc000000, "ceJ(s,b),x", pa10, FLAG_STRICT},
 { "ldw",        0x4c000000, 0xfc000000, "ceJ(b),x", pa10, FLAG_STRICT},
+{ "ldw",        0x5c000004, 0xfc000006, "ce>(b),x", pa20w, FLAG_STRICT},
 { "ldw",        0x5c000004, 0xfc000006, "ceK(s,b),x", pa20, FLAG_STRICT},
 { "ldw",        0x5c000004, 0xfc000006, "ceK(b),x", pa20, FLAG_STRICT},
-{ "ldw",        0x48000000, 0xfc000000, "j(s,b),x", pa10, 0},
+{ "ldw",        0x48000000, 0xfc000000, "l(b),x", pa20w, FLAG_STRICT},
 { "ldw",        0x48000000, 0xfc000000, "j(s,b),x", pa10, 0},
 { "ldw",        0x48000000, 0xfc000000, "j(b),x", pa10, 0},
-{ "ldh",        0x44000000, 0xfc000000, "l(b),x", pa20w, FLAG_STRICT},
 { "ldh",        0x0c000040, 0xfc0013c0, "cxccx(s,b),t", pa10, FLAG_STRICT},
 { "ldh",        0x0c000040, 0xfc0013c0, "cxccx(b),t", pa10, FLAG_STRICT},
-{ "ldh",       0x0c001060, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT},
-{ "ldh",       0x0c001060, 0xfc1f33e0, "cocc@(b),t", pa20, FLAG_STRICT},
 { "ldh",       0x0c001040, 0xfc0013c0, "cmcc5(s,b),t", pa10, FLAG_STRICT},
 { "ldh",       0x0c001040, 0xfc0013c0, "cmcc5(b),t", pa10, FLAG_STRICT},
+{ "ldh",       0x0c001060, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT},
+{ "ldh",       0x0c001060, 0xfc1f33e0, "cocc@(b),t", pa20, FLAG_STRICT},
+{ "ldh",        0x44000000, 0xfc000000, "l(b),x", pa20w, FLAG_STRICT},
 { "ldh",        0x44000000, 0xfc000000, "j(s,b),x", pa10, 0},
 { "ldh",        0x44000000, 0xfc000000, "j(b),x", pa10, 0},
-{ "ldb",        0x40000000, 0xfc000000, "l(b),x", pa20w, FLAG_STRICT},
 { "ldb",        0x0c000000, 0xfc0013c0, "cxccx(s,b),t", pa10, FLAG_STRICT},
 { "ldb",        0x0c000000, 0xfc0013c0, "cxccx(b),t", pa10, FLAG_STRICT},
-{ "ldb",       0x0c001020, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT},
-{ "ldb",       0x0c001020, 0xfc1f33e0, "cocc@(b),t", pa20, FLAG_STRICT},
 { "ldb",       0x0c001000, 0xfc0013c0, "cmcc5(s,b),t", pa10, FLAG_STRICT},
 { "ldb",       0x0c001000, 0xfc0013c0, "cmcc5(b),t", pa10, FLAG_STRICT},
+{ "ldb",       0x0c001020, 0xfc1f33e0, "cocc@(s,b),t", pa20, FLAG_STRICT},
+{ "ldb",       0x0c001020, 0xfc1f33e0, "cocc@(b),t", pa20, FLAG_STRICT},
+{ "ldb",        0x40000000, 0xfc000000, "l(b),x", pa20w, FLAG_STRICT},
 { "ldb",        0x40000000, 0xfc000000, "j(s,b),x", pa10, 0},
 { "ldb",        0x40000000, 0xfc000000, "j(b),x", pa10, 0},
 { "std",       0x0c0012e0, 0xfc0033ff, "cocCx,@(s,b)", pa20, FLAG_STRICT},
@@ -357,49 +368,51 @@ static const struct pa_opcode pa_opcodes[] =
 { "std",       0x0c0012c0, 0xfc0013c0, "cmcCx,V(b)", pa20, FLAG_STRICT},
 { "std",        0x70000000, 0xfc000002, "cqx,&(b)", pa20w, FLAG_STRICT},
 { "std",        0x70000000, 0xfc000002, "cqx,#(b)", pa20, FLAG_STRICT},
-{ "stw",        0x68000000, 0xfc000000, "x,l(b)", pa20w, FLAG_STRICT},
-{ "stw",       0x0c0012a0, 0xfc0013ff, "cocCx,@(s,b)", pa20, FLAG_STRICT},
-{ "stw",       0x0c0012a0, 0xfc0013ff, "cocCx,@(b)", pa20, FLAG_STRICT},
 { "stw",       0x0c001280, 0xfc0013c0, "cmcCx,V(s,b)", pa10, FLAG_STRICT},
 { "stw",       0x0c001280, 0xfc0013c0, "cmcCx,V(b)", pa10, FLAG_STRICT},
+{ "stw",       0x0c0012a0, 0xfc0013ff, "cocCx,@(s,b)", pa20, FLAG_STRICT},
+{ "stw",       0x0c0012a0, 0xfc0013ff, "cocCx,@(b)", pa20, FLAG_STRICT},
+{ "stw",        0x6c000000, 0xfc000000, "cex,<(b)", pa20w, FLAG_STRICT},
 { "stw",        0x6c000000, 0xfc000000, "cex,J(s,b)", pa10, FLAG_STRICT},
 { "stw",        0x6c000000, 0xfc000000, "cex,J(b)", pa10, FLAG_STRICT},
+{ "stw",        0x7c000004, 0xfc000006, "cex,>(b)", pa20w, FLAG_STRICT},
 { "stw",        0x7c000004, 0xfc000006, "cex,K(s,b)", pa20, FLAG_STRICT},
 { "stw",        0x7c000004, 0xfc000006, "cex,K(b)", pa20, FLAG_STRICT},
+{ "stw",        0x68000000, 0xfc000000, "x,l(b)", pa20w, FLAG_STRICT},
 { "stw",        0x68000000, 0xfc000000, "x,j(s,b)", pa10, 0},
 { "stw",        0x68000000, 0xfc000000, "x,j(b)", pa10, 0},
-{ "sth",        0x64000000, 0xfc000000, "x,l(b)", pa20w, FLAG_STRICT},
-{ "sth",       0x0c001260, 0xfc0033ff, "cocCx,@(s,b)", pa20, FLAG_STRICT},
-{ "sth",       0x0c001260, 0xfc0033ff, "cocCx,@(b)", pa20, FLAG_STRICT},
 { "sth",       0x0c001240, 0xfc0013c0, "cmcCx,V(s,b)", pa10, FLAG_STRICT},
 { "sth",       0x0c001240, 0xfc0013c0, "cmcCx,V(b)", pa10, FLAG_STRICT},
+{ "sth",       0x0c001260, 0xfc0033ff, "cocCx,@(s,b)", pa20, FLAG_STRICT},
+{ "sth",       0x0c001260, 0xfc0033ff, "cocCx,@(b)", pa20, FLAG_STRICT},
+{ "sth",        0x64000000, 0xfc000000, "x,l(b)", pa20w, FLAG_STRICT},
 { "sth",        0x64000000, 0xfc000000, "x,j(s,b)", pa10, 0},
 { "sth",        0x64000000, 0xfc000000, "x,j(b)", pa10, 0},
-{ "stb",        0x60000000, 0xfc000000, "x,l(b)", pa20w, FLAG_STRICT},
-{ "stb",       0x0c001220, 0xfc0033ff, "cocCx,@(s,b)", pa20, FLAG_STRICT},
-{ "stb",       0x0c001220, 0xfc0033ff, "cocCx,@(b)", pa20, FLAG_STRICT},
 { "stb",       0x0c001200, 0xfc0013c0, "cmcCx,V(s,b)", pa10, FLAG_STRICT},
 { "stb",       0x0c001200, 0xfc0013c0, "cmcCx,V(b)", pa10, FLAG_STRICT},
+{ "stb",       0x0c001220, 0xfc0033ff, "cocCx,@(s,b)", pa20, FLAG_STRICT},
+{ "stb",       0x0c001220, 0xfc0033ff, "cocCx,@(b)", pa20, FLAG_STRICT},
+{ "stb",        0x60000000, 0xfc000000, "x,l(b)", pa20w, FLAG_STRICT},
 { "stb",        0x60000000, 0xfc000000, "x,j(s,b)", pa10, 0},
 { "stb",        0x60000000, 0xfc000000, "x,j(b)", pa10, 0},
 { "ldwm",       0x4c000000, 0xfc000000, "j(s,b),x", pa10, 0},
 { "ldwm",       0x4c000000, 0xfc000000, "j(b),x", pa10, 0},
 { "stwm",       0x6c000000, 0xfc000000, "x,j(s,b)", pa10, 0},
 { "stwm",       0x6c000000, 0xfc000000, "x,j(b)", pa10, 0},
-{ "ldwx",       0x0c000080, 0xfc001fc0, "cxx(s,b),t", pa10, 0},
-{ "ldwx",       0x0c000080, 0xfc001fc0, "cxx(b),t", pa10, 0},
-{ "ldhx",       0x0c000040, 0xfc001fc0, "cxx(s,b),t", pa10, 0},
-{ "ldhx",       0x0c000040, 0xfc001fc0, "cxx(b),t", pa10, 0},
-{ "ldbx",       0x0c000000, 0xfc001fc0, "cxx(s,b),t", pa10, 0},
-{ "ldbx",       0x0c000000, 0xfc001fc0, "cxx(b),t", pa10, 0},
+{ "ldwx",       0x0c000080, 0xfc001fc0, "cXx(s,b),t", pa10, 0},
+{ "ldwx",       0x0c000080, 0xfc001fc0, "cXx(b),t", pa10, 0},
+{ "ldhx",       0x0c000040, 0xfc001fc0, "cXx(s,b),t", pa10, 0},
+{ "ldhx",       0x0c000040, 0xfc001fc0, "cXx(b),t", pa10, 0},
+{ "ldbx",       0x0c000000, 0xfc001fc0, "cXx(s,b),t", pa10, 0},
+{ "ldbx",       0x0c000000, 0xfc001fc0, "cXx(b),t", pa10, 0},
 { "ldwa",       0x0c000180, 0xfc00d3c0, "cxccx(b),t", pa10, FLAG_STRICT},
 { "ldwa",      0x0c001180, 0xfc00d3c0, "cmcc5(b),t", pa10, FLAG_STRICT},
 { "ldcw",       0x0c0001c0, 0xfc0013c0, "cxcdx(s,b),t", pa10, FLAG_STRICT},
 { "ldcw",       0x0c0001c0, 0xfc0013c0, "cxcdx(b),t", pa10, FLAG_STRICT},
 { "ldcw",      0x0c0011c0, 0xfc0013c0, "cmcd5(s,b),t", pa10, FLAG_STRICT},
 { "ldcw",      0x0c0011c0, 0xfc0013c0, "cmcd5(b),t", pa10, FLAG_STRICT},
-{ "stwa",      0x0c0013a0, 0xfc00d3ff, "cocCx,@(b)", pa20, FLAG_STRICT},
 { "stwa",      0x0c001380, 0xfc00d3c0, "cmcCx,V(b)", pa10, FLAG_STRICT},
+{ "stwa",      0x0c0013a0, 0xfc00d3ff, "cocCx,@(b)", pa20, FLAG_STRICT},
 { "stby",      0x0c001300, 0xfc0013c0, "cscCx,V(s,b)", pa10, FLAG_STRICT},
 { "stby",      0x0c001300, 0xfc0013c0, "cscCx,V(b)", pa10, FLAG_STRICT},
 { "ldda",       0x0c000100, 0xfc00d3c0, "cxccx(b),t", pa20, FLAG_STRICT},
@@ -412,31 +425,32 @@ static const struct pa_opcode pa_opcodes[] =
 { "stda",      0x0c0013e0, 0xfc0033ff, "cocCx,@(b)", pa20, FLAG_STRICT},
 { "stda",      0x0c0013c0, 0xfc0013c0, "cmcCx,V(s,b)", pa20, FLAG_STRICT},
 { "stda",      0x0c0013c0, 0xfc0013c0, "cmcCx,V(b)", pa20, FLAG_STRICT},
-{ "ldwax",      0x0c000180, 0xfc00dfc0, "cxx(b),t", pa10, 0},
-{ "ldcwx",      0x0c0001c0, 0xfc001fc0, "cxx(s,b),t", pa10, 0},
-{ "ldcwx",      0x0c0001c0, 0xfc001fc0, "cxx(b),t", pa10, 0},
-{ "ldws",      0x0c001080, 0xfc001fc0, "cm5(s,b),t", pa10, 0},
-{ "ldws",      0x0c001080, 0xfc001fc0, "cm5(b),t", pa10, 0},
-{ "ldhs",      0x0c001040, 0xfc001fc0, "cm5(s,b),t", pa10, 0},
-{ "ldhs",      0x0c001040, 0xfc001fc0, "cm5(b),t", pa10, 0},
-{ "ldbs",      0x0c001000, 0xfc001fc0, "cm5(s,b),t", pa10, 0},
-{ "ldbs",      0x0c001000, 0xfc001fc0, "cm5(b),t", pa10, 0},
-{ "ldwas",     0x0c001180, 0xfc00dfc0, "cm5(b),t", pa10, 0},
-{ "ldcws",     0x0c0011c0, 0xfc001fc0, "cm5(s,b),t", pa10, 0},
-{ "ldcws",     0x0c0011c0, 0xfc001fc0, "cm5(b),t", pa10, 0},
-{ "stws",      0x0c001280, 0xfc001fc0, "cmx,V(s,b)", pa10, 0},
-{ "stws",      0x0c001280, 0xfc001fc0, "cmx,V(b)", pa10, 0},
-{ "sths",      0x0c001240, 0xfc001fc0, "cmx,V(s,b)", pa10, 0},
-{ "sths",      0x0c001240, 0xfc001fc0, "cmx,V(b)", pa10, 0},
-{ "stbs",      0x0c001200, 0xfc001fc0, "cmx,V(s,b)", pa10, 0},
-{ "stbs",      0x0c001200, 0xfc001fc0, "cmx,V(b)", pa10, 0},
-{ "stwas",     0x0c001380, 0xfc00dfc0, "cmx,V(b)", pa10, 0},
+{ "ldwax",      0x0c000180, 0xfc00dfc0, "cXx(b),t", pa10, 0},
+{ "ldcwx",      0x0c0001c0, 0xfc001fc0, "cXx(s,b),t", pa10, 0},
+{ "ldcwx",      0x0c0001c0, 0xfc001fc0, "cXx(b),t", pa10, 0},
+{ "ldws",      0x0c001080, 0xfc001fc0, "cM5(s,b),t", pa10, 0},
+{ "ldws",      0x0c001080, 0xfc001fc0, "cM5(b),t", pa10, 0},
+{ "ldhs",      0x0c001040, 0xfc001fc0, "cM5(s,b),t", pa10, 0},
+{ "ldhs",      0x0c001040, 0xfc001fc0, "cM5(b),t", pa10, 0},
+{ "ldbs",      0x0c001000, 0xfc001fc0, "cM5(s,b),t", pa10, 0},
+{ "ldbs",      0x0c001000, 0xfc001fc0, "cM5(b),t", pa10, 0},
+{ "ldwas",     0x0c001180, 0xfc00dfc0, "cM5(b),t", pa10, 0},
+{ "ldcws",     0x0c0011c0, 0xfc001fc0, "cM5(s,b),t", pa10, 0},
+{ "ldcws",     0x0c0011c0, 0xfc001fc0, "cM5(b),t", pa10, 0},
+{ "stws",      0x0c001280, 0xfc001fc0, "cMx,V(s,b)", pa10, 0},
+{ "stws",      0x0c001280, 0xfc001fc0, "cMx,V(b)", pa10, 0},
+{ "sths",      0x0c001240, 0xfc001fc0, "cMx,V(s,b)", pa10, 0},
+{ "sths",      0x0c001240, 0xfc001fc0, "cMx,V(b)", pa10, 0},
+{ "stbs",      0x0c001200, 0xfc001fc0, "cMx,V(s,b)", pa10, 0},
+{ "stbs",      0x0c001200, 0xfc001fc0, "cMx,V(b)", pa10, 0},
+{ "stwas",     0x0c001380, 0xfc00dfc0, "cMx,V(b)", pa10, 0},
 { "stdby",     0x0c001340, 0xfc0013c0, "cscCx,V(s,b)", pa20, FLAG_STRICT},
 { "stdby",     0x0c001340, 0xfc0013c0, "cscCx,V(b)", pa20, FLAG_STRICT},
-{ "stbys",     0x0c001300, 0xfc001fc0, "csx,V(s,b)", pa10, 0},
-{ "stbys",     0x0c001300, 0xfc001fc0, "csx,V(b)", pa10, 0},
+{ "stbys",     0x0c001300, 0xfc001fc0, "cAx,V(s,b)", pa10, 0},
+{ "stbys",     0x0c001300, 0xfc001fc0, "cAx,V(b)", pa10, 0},
 
 /* Immediate instructions.  */
+{ "ldo",       0x34000000, 0xfc000000, "l(b),x", pa20w, 0},
 { "ldo",       0x34000000, 0xfc00c000, "j(b),x", pa10, 0},
 { "ldil",      0x20000000, 0xfc000000, "k,b", pa10, 0},
 { "addil",     0x28000000, 0xfc000000, "k,b,Z", pa10, 0},
@@ -472,10 +486,10 @@ static const struct pa_opcode pa_opcodes[] =
 { "addbf",     0xa8000000, 0xfc000000, "?dnx,b,w", pa10, 0},
 { "addibt",    0xa4000000, 0xfc000000, "?dn5,b,w", pa10, 0},
 { "addibf",    0xac000000, 0xfc000000, "?dn5,b,w", pa10, 0},
-{ "bb",                0xc0006000, 0xffe06000, "?Bnx,!,w", pa20, FLAG_STRICT}, 
-{ "bb",                0xc4004000, 0xfc004000, "?Bnx,B,w", pa20, FLAG_STRICT}, 
 { "bb",                0xc0004000, 0xffe06000, "?bnx,!,w", pa10, FLAG_STRICT}, 
 { "bb",                0xc4004000, 0xfc004000, "?bnx,Q,w", pa10, 0}, 
+{ "bb",                0xc0006000, 0xffe06000, "?Bnx,!,w", pa20, FLAG_STRICT}, 
+{ "bb",                0xc4004000, 0xfc004000, "?Bnx,B,w", pa20, FLAG_STRICT}, 
 { "bvb",       0xc0004000, 0xffe04000, "?bnx,w", pa10, 0},
 { "clrbts",    0xe8004005, 0xffffffff, "", pa20, FLAG_STRICT},
 { "popbts",    0xe8004005, 0xfffff007, "$", pa20, FLAG_STRICT},
@@ -691,46 +705,46 @@ static const struct pa_opcode pa_opcodes[] =
 
 /* Floating Point Coprocessor Instructions.  */
  
-{ "fldw",       0x24001020, 0xfc1f33a0, "cocc@(s,b),fT", pa20, FLAG_STRICT},
-{ "fldw",       0x24001020, 0xfc1f33a0, "cocc@(b),fT", pa20, FLAG_STRICT},
 { "fldw",       0x24000000, 0xfc001380, "cxccx(s,b),fT", pa10, FLAG_STRICT},
 { "fldw",       0x24000000, 0xfc001380, "cxccx(b),fT", pa10, FLAG_STRICT},
 { "fldw",       0x24001000, 0xfc001380, "cmcc5(s,b),fT", pa10, FLAG_STRICT},
 { "fldw",       0x24001000, 0xfc001380, "cmcc5(b),fT", pa10, FLAG_STRICT},
+{ "fldw",       0x24001020, 0xfc1f33a0, "cocc@(s,b),fT", pa20, FLAG_STRICT},
+{ "fldw",       0x24001020, 0xfc1f33a0, "cocc@(b),fT", pa20, FLAG_STRICT},
 { "fldw",       0x5c000000, 0xfc000004, "y(b),fe", pa20w, FLAG_STRICT},
 { "fldw",       0x58000000, 0xfc000000, "cJy(b),fe", pa20w, FLAG_STRICT},
 { "fldw",       0x5c000000, 0xfc000004, "d(b),fe", pa20, FLAG_STRICT},
 { "fldw",       0x58000000, 0xfc000000, "cJd(b),fe", pa20, FLAG_STRICT},
-{ "fldd",       0x2c001020, 0xfc1f33e0, "cocc@(s,b),ft", pa20, FLAG_STRICT},
-{ "fldd",       0x2c001020, 0xfc1f33e0, "cocc@(b),ft", pa20, FLAG_STRICT},
 { "fldd",       0x2c000000, 0xfc0013c0, "cxccx(s,b),ft", pa10, FLAG_STRICT},
 { "fldd",       0x2c000000, 0xfc0013c0, "cxccx(b),ft", pa10, FLAG_STRICT},
 { "fldd",       0x2c001000, 0xfc0013c0, "cmcc5(s,b),ft", pa10, FLAG_STRICT},
 { "fldd",       0x2c001000, 0xfc0013c0, "cmcc5(b),ft", pa10, FLAG_STRICT},
+{ "fldd",       0x2c001020, 0xfc1f33e0, "cocc@(s,b),ft", pa20, FLAG_STRICT},
+{ "fldd",       0x2c001020, 0xfc1f33e0, "cocc@(b),ft", pa20, FLAG_STRICT},
 { "fldd",       0x50000002, 0xfc000002, "cq&(b),fx", pa20w, FLAG_STRICT},
 { "fldd",       0x50000002, 0xfc000002, "cq#(b),fx", pa20, FLAG_STRICT},
-{ "fstw",       0x24001220, 0xfc1f33a0, "cocCfT,@(s,b)", pa10, FLAG_STRICT},
-{ "fstw",       0x24001220, 0xfc1f33a0, "cocCfT,@(b)", pa10, FLAG_STRICT},
 { "fstw",       0x24000200, 0xfc001380, "cxcCfT,x(s,b)", pa10, FLAG_STRICT},
 { "fstw",       0x24000200, 0xfc001380, "cxcCfT,x(b)", pa10, FLAG_STRICT},
 { "fstw",       0x24001200, 0xfc001380, "cmcCfT,5(s,b)", pa10, FLAG_STRICT},
 { "fstw",       0x24001200, 0xfc001380, "cmcCfT,5(b)", pa10, FLAG_STRICT},
+{ "fstw",       0x24001220, 0xfc1f33a0, "cocCfT,@(s,b)", pa10, FLAG_STRICT},
+{ "fstw",       0x24001220, 0xfc1f33a0, "cocCfT,@(b)", pa10, FLAG_STRICT},
 { "fstw",       0x7c000000, 0xfc000004, "fE,y(b)", pa20w, FLAG_STRICT},
 { "fstw",       0x78000000, 0xfc000000, "cJfe,y(b)", pa20w, FLAG_STRICT},
 { "fstw",       0x7c000000, 0xfc000004, "fe,d(b)", pa20, FLAG_STRICT},
 { "fstw",       0x78000000, 0xfc000000, "cJfe,d(b)", pa20, FLAG_STRICT},
-{ "fstd",       0x2c001220, 0xfc1f33e0, "cocCft,@(s,b)", pa10, FLAG_STRICT},
-{ "fstd",       0x2c001220, 0xfc1f33e0, "cocCft,@(b)", pa10, FLAG_STRICT},
 { "fstd",       0x2c000200, 0xfc0013c0, "cxcCft,x(s,b)", pa10, FLAG_STRICT},
 { "fstd",       0x2c000200, 0xfc0013c0, "cxcCft,x(b)", pa10, FLAG_STRICT},
 { "fstd",       0x2c001200, 0xfc0013c0, "cmcCft,5(s,b)", pa10, FLAG_STRICT},
 { "fstd",       0x2c001200, 0xfc0013c0, "cmcCft,5(b)", pa10, FLAG_STRICT},
+{ "fstd",       0x2c001220, 0xfc1f33e0, "cocCft,@(s,b)", pa10, FLAG_STRICT},
+{ "fstd",       0x2c001220, 0xfc1f33e0, "cocCft,@(b)", pa10, FLAG_STRICT},
 { "fstd",       0x70000002, 0xfc000002, "cqfx,&(b)", pa20w, FLAG_STRICT},
 { "fstd",       0x70000002, 0xfc000002, "cqfx,#(b)", pa20, FLAG_STRICT},
-{ "fldwx",      0x24000000, 0xfc001f80, "cxx(s,b),fT", pa10, 0},
-{ "fldwx",      0x24000000, 0xfc001f80, "cxx(b),fT", pa10, 0},
-{ "flddx",      0x2c000000, 0xfc001fc0, "cxx(s,b),ft", pa10, 0},
-{ "flddx",      0x2c000000, 0xfc001fc0, "cxx(b),ft", pa10, 0},
+{ "fldwx",      0x24000000, 0xfc001f80, "cXx(s,b),fT", pa10, 0},
+{ "fldwx",      0x24000000, 0xfc001f80, "cXx(b),fT", pa10, 0},
+{ "flddx",      0x2c000000, 0xfc001fc0, "cXx(s,b),ft", pa10, 0},
+{ "flddx",      0x2c000000, 0xfc001fc0, "cXx(b),ft", pa10, 0},
 { "fstwx",      0x24000200, 0xfc001f80, "cxfT,x(s,b)", pa10, 0},
 { "fstwx",      0x24000200, 0xfc001f80, "cxfT,x(b)", pa10, 0},
 { "fstdx",      0x2c000200, 0xfc001fc0, "cxft,x(s,b)", pa10, 0},
@@ -805,38 +819,44 @@ static const struct pa_opcode pa_opcodes[] =
 { "spop2",      0x10000400, 0xfc000600, "v,1Nb", pa10, 0},
 { "spop3",      0x10000600, 0xfc000600, "v,0Nx,b", pa10, 0},
 { "copr",       0x30000000, 0xfc000000, "u,2N", pa10, 0},
-{ "cldwx",      0x24000000, 0xfc001e00, "ucxx(s,b),t", pa10, 0},
-{ "cldwx",      0x24000000, 0xfc001e00, "ucxx(b),t", pa10, 0},
-{ "clddx",      0x2c000000, 0xfc001e00, "ucxx(s,b),t", pa10, 0},
-{ "clddx",      0x2c000000, 0xfc001e00, "ucxx(b),t", pa10, 0},
-{ "cstwx",      0x24000200, 0xfc001e00, "ucxt,x(s,b)", pa10, 0},
-{ "cstwx",      0x24000200, 0xfc001e00, "ucxt,x(b)", pa10, 0},
-{ "cstdx",      0x2c000200, 0xfc001e00, "ucxt,x(s,b)", pa10, 0},
-{ "cstdx",      0x2c000200, 0xfc001e00, "ucxt,x(b)", pa10, 0},
-{ "cldws",      0x24001000, 0xfc001e00, "ucm5(s,b),t", pa10, 0},
-{ "cldws",      0x24001000, 0xfc001e00, "ucm5(b),t", pa10, 0},
-{ "cldds",      0x2c001000, 0xfc001e00, "ucm5(s,b),t", pa10, 0},
-{ "cldds",      0x2c001000, 0xfc001e00, "ucm5(b),t", pa10, 0},
-{ "cstws",      0x24001200, 0xfc001e00, "ucmt,5(s,b)", pa10, 0},
-{ "cstws",      0x24001200, 0xfc001e00, "ucmt,5(b)", pa10, 0},
-{ "cstds",      0x2c001200, 0xfc001e00, "ucmt,5(s,b)", pa10, 0},
-{ "cstds",      0x2c001200, 0xfc001e00, "ucmt,5(b)", pa10, 0},
-{ "cldw",       0x24000000, 0xfc001e00, "ucxx(s,b),t", pa10, FLAG_STRICT},
-{ "cldw",       0x24000000, 0xfc001e00, "ucxx(b),t", pa10, FLAG_STRICT},
-{ "cldw",       0x24001000, 0xfc001e00, "ucm5(s,b),t", pa10, FLAG_STRICT},
-{ "cldw",       0x24001000, 0xfc001e00, "ucm5(b),t", pa10, FLAG_STRICT},
-{ "cldd",       0x2c000000, 0xfc001e00, "ucxx(s,b),t", pa10, FLAG_STRICT},
-{ "cldd",       0x2c000000, 0xfc001e00, "ucxx(b),t", pa10, FLAG_STRICT},
-{ "cldd",       0x2c001000, 0xfc001e00, "ucm5(s,b),t", pa10, FLAG_STRICT},
-{ "cldd",       0x2c001000, 0xfc001e00, "ucm5(b),t", pa20, FLAG_STRICT},
-{ "cstw",       0x24000200, 0xfc001e00, "ucxt,x(s,b)", pa10, FLAG_STRICT},
-{ "cstw",       0x24000200, 0xfc001e00, "ucxt,x(b)", pa10, FLAG_STRICT},
-{ "cstw",       0x24001200, 0xfc001e00, "ucmt,5(s,b)", pa10, FLAG_STRICT},
-{ "cstw",       0x24001200, 0xfc001e00, "ucmt,5(b)", pa10, FLAG_STRICT},
-{ "cstd",       0x2c000200, 0xfc001e00, "ucxt,x(s,b)", pa10, FLAG_STRICT},
-{ "cstd",       0x2c000200, 0xfc001e00, "ucxt,x(b)", pa10, FLAG_STRICT},
-{ "cstd",       0x2c001200, 0xfc001e00, "ucmt,5(s,b)", pa10, FLAG_STRICT},
-{ "cstd",       0x2c001200, 0xfc001e00, "ucmt,5(b)", pa10, FLAG_STRICT},
+{ "cldwx",      0x24000000, 0xfc001e00, "ucXx(s,b),t", pa10, 0},
+{ "cldwx",      0x24000000, 0xfc001e00, "ucXx(b),t", pa10, 0},
+{ "clddx",      0x2c000000, 0xfc001e00, "ucXx(s,b),t", pa10, 0},
+{ "clddx",      0x2c000000, 0xfc001e00, "ucXx(b),t", pa10, 0},
+{ "cstwx",      0x24000200, 0xfc001e00, "ucXt,x(s,b)", pa10, 0},
+{ "cstwx",      0x24000200, 0xfc001e00, "ucXt,x(b)", pa10, 0},
+{ "cstdx",      0x2c000200, 0xfc001e00, "ucXt,x(s,b)", pa10, 0},
+{ "cstdx",      0x2c000200, 0xfc001e00, "ucXt,x(b)", pa10, 0},
+{ "cldws",      0x24001000, 0xfc001e00, "ucM5(s,b),t", pa10, 0},
+{ "cldws",      0x24001000, 0xfc001e00, "ucM5(b),t", pa10, 0},
+{ "cldds",      0x2c001000, 0xfc001e00, "ucM5(s,b),t", pa10, 0},
+{ "cldds",      0x2c001000, 0xfc001e00, "ucM5(b),t", pa10, 0},
+{ "cstws",      0x24001200, 0xfc001e00, "ucMt,5(s,b)", pa10, 0},
+{ "cstws",      0x24001200, 0xfc001e00, "ucMt,5(b)", pa10, 0},
+{ "cstds",      0x2c001200, 0xfc001e00, "ucMt,5(s,b)", pa10, 0},
+{ "cstds",      0x2c001200, 0xfc001e00, "ucMt,5(b)", pa10, 0},
+{ "cldw",       0x24000000, 0xfc001e00, "ucXx(s,b),t", pa10, FLAG_STRICT},
+{ "cldw",       0x24000000, 0xfc001e00, "ucXx(b),t", pa10, FLAG_STRICT},
+{ "cldw",       0x24001000, 0xfc001e00, "ucM5(s,b),t", pa10, FLAG_STRICT},
+{ "cldw",       0x24001000, 0xfc001e00, "ucM5(b),t", pa10, FLAG_STRICT},
+{ "cldd",       0x2c000000, 0xfc001e00, "ucXx(s,b),t", pa10, FLAG_STRICT},
+{ "cldd",       0x2c000000, 0xfc001e00, "ucXx(b),t", pa10, FLAG_STRICT},
+{ "cldd",       0x2c001000, 0xfc001e00, "ucM5(s,b),t", pa10, FLAG_STRICT},
+{ "cldd",       0x2c001000, 0xfc001e00, "ucM5(b),t", pa20, FLAG_STRICT},
+{ "cstw",       0x24000200, 0xfc001e00, "ucXt,x(s,b)", pa10, FLAG_STRICT},
+{ "cstw",       0x24000200, 0xfc001e00, "ucXt,x(b)", pa10, FLAG_STRICT},
+{ "cstw",       0x24001200, 0xfc001e00, "ucMt,5(s,b)", pa10, FLAG_STRICT},
+{ "cstw",       0x24001200, 0xfc001e00, "ucMt,5(b)", pa10, FLAG_STRICT},
+{ "cstd",       0x2c000200, 0xfc001e00, "ucXt,x(s,b)", pa10, FLAG_STRICT},
+{ "cstd",       0x2c000200, 0xfc001e00, "ucXt,x(b)", pa10, FLAG_STRICT},
+{ "cstd",       0x2c001200, 0xfc001e00, "ucMt,5(s,b)", pa10, FLAG_STRICT},
+{ "cstd",       0x2c001200, 0xfc001e00, "ucMt,5(b)", pa10, FLAG_STRICT},
+
+/* More pseudo instructions which must follow the main table.  */
+{ "call",      0xe800f000, 0xfc1ffffd, "n(b)", pa20, FLAG_STRICT},
+{ "call",      0xe800a000, 0xffe0e000, "nW", pa10, FLAG_STRICT},
+{ "ret",       0xe840d000, 0xfffffffd, "n", pa20, FLAG_STRICT},
+
 };
 
 #define NUMOPCODES ((sizeof pa_opcodes)/(sizeof pa_opcodes[0]))
This page took 0.029723 seconds and 4 git commands to generate.