home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gdb-4.9 / include / opcode / hppa.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-12  |  16.3 KB  |  359 lines
  1. /* Table of opcodes for the hppa.
  2.    Copyright (C) 1990 Free Software Foundation, Inc.
  3.  
  4. This file is part of GAS, the GNU Assembler, and GDB, the GNU disassembler.
  5.  
  6. GAS/GDB is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 1, or (at your option)
  9. any later version.
  10.  
  11. GAS/GDB is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GAS or GDB; see the file COPYING.  If not, write to
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. /*
  21.    HP PA-RISC support was contributed by the Center for Software Science
  22.    at the University of Utah.
  23.  */
  24.  
  25. #if !defined(__STDC__) && !defined(const)
  26. #define const
  27. #endif
  28.  
  29. /*
  30.  * Structure of an opcode table entry.
  31.  */
  32.  
  33. /* There are two kinds of delay slot nullification: normal which is
  34.  * controled by the nullification bit, and conditional, which depends 
  35.  * on the direction of the branch and its success or failure.
  36.  */
  37. enum delay_type {NONE, NORMAL, CONDITIONAL};
  38. struct pa_opcode
  39. {
  40.     const char *name;
  41.     unsigned long int match;    /* Bits that must be set...  */
  42.     unsigned long int mask;    /* ... in these bits. */
  43.     char *args;
  44.     /* Nonzero if this is a delayed branch instruction.  */
  45.     char delayed;
  46. };
  47.  
  48. /*
  49.    All hppa opcodes are 32 bits.
  50.  
  51.    The match component is a mask saying which bits must match a
  52.    particular opcode in order for an instruction to be an instance
  53.    of that opcode.
  54.  
  55.    The args component is a string containing one character
  56.    for each operand of the instruction.
  57.  
  58.    Bit positions in this description follow HP usage of lsb = 31,
  59.    "at" is lsb of field.
  60.    
  61. Kinds of operands:
  62.    x    register field at 15.
  63.    b    register field at 10.
  64.    t    register field at 31.
  65.    5    5 bit immediate at 15.
  66.    s    2 bit space specifier at 17.
  67.    S    3 bit space specifier at 18.
  68.    c    indexed load completer.
  69.    C    short load and store completer.
  70.    Y    Store Bytes Short completer
  71.    <    non-negated compare/subtract conditions.
  72.    -    compare/subtract conditions
  73.    +    non-negated add conditions
  74.    &    logical instruction conditions
  75.    U    unit instruction conditions
  76.    >    shift/extract/deposit conditions.
  77.    ~    bvb,bb conditions
  78.    V    5 bit immediate value at 31
  79.    i    11 bit immediate value at 31
  80.    j    14 bit immediate value at 31
  81.    k    21 bit immediate value at 31
  82.    n    nullification for branch instructions
  83.    w    12 bit branch displacement
  84.    W    17 bit branch displacement
  85.  
  86. Also these (PJH):
  87.  
  88.    B    either s,b or b where
  89.  
  90.            s    2 bit space specifier at 17.
  91.            b    register field at 10.
  92.  
  93.    p    5 bit shift count at 26 (to support the SHD instruction) encoded as
  94.         31-p
  95.    P    5 bit bit position at 26
  96.    T    5 bit field length at 31 (encoded as 32-T)
  97.    A    13 bit immediate at 18 (to support the BREAK instruction)
  98.    Z    System Control Completer (to support LDA, LHA, etc.)
  99.    D    26 bit immediate at 31 (to support the DIAG instruction)
  100.  
  101.    f    3 bit Special Function Unit identifier at 25
  102.    O    20 bit Special Function Unit operation split between 15 bits at 20
  103.         and 5 bits at 31
  104.    o    15 bit Special Function Unit operation at 20
  105.    2    22 bit Special Function Unit operation split between 17 bits at 20
  106.         and 5 bits at 31
  107.    1    15 bit Special Function Unit operation split between 10 bits at 20
  108.         and 5 bits at 31
  109.    0    10 bit Special Function Unit operation split between 5 bits at 20
  110.         and 5 bits at 31
  111.    u    3 bit coprocessor unit identifier at 25
  112.    F    Source Floating Point Operand Format Completer encoded 2 bits at 20
  113.    G    Destination Floating Point Operand Format Completer encoded 2 bits at 18
  114.    M    Floating-Point Compare Conditions (encoded as 5 bits at 31)
  115. #ifdef GAS
  116.    ?    negated or non-negated compare/subtract conditions
  117.         (used only by 'comb' and 'comib' pseudo-instructions)
  118.    !    negated or non-negated add conditions
  119.         (used only by 'addb' and 'addib' pseudo-instructions)
  120. #else GDB
  121.    ?    negated compare/subtract conditions.
  122.    !    non-negated add conditions.
  123.    @    negated add conditions.
  124. #endif
  125.    r    5 bit immediate value at 31 (for the break instruction)
  126.     (very similar to V above, except the value is unsigned instead of
  127.     low_sign_ext)
  128.    R    5 bit immediate value at 15 (for the ssm, rsm instruction)
  129.     (same as r above, except the value is in a different location)
  130.    Q    5 bit immediate value at 10 (a bit position specified in
  131.     the bb instruction. It's the same as r above, except the
  132.         value is in a different location)
  133.  
  134. And these (PJH) for PA-89 F.P. registers and instructions:
  135.  
  136.    v    a 't' operand type extended to handle L/R register halves.
  137.    E    a 'b' operand type extended to handle L/R register halves.
  138.    X    an 'x' operand type extended to handle L/R register halves.
  139.    4    a variation of the 'b' operand type for 'fmpyadd' and 'fmpysub'
  140.    6    a variation of the 'x' operand type for 'fmpyadd' and 'fmpysub'
  141.    7    a variation of the 't' operand type for 'fmpyadd' and 'fmpysub'
  142.    8    5 bit register field at 20 (used in 'fmpyadd' and 'fmpysub')
  143.    9    5 bit register field at 25 (used in 'fmpyadd' and 'fmpysub')
  144.    H    Floating Point Operand Format at 26 for 'fmpyadd' and 'fmpysub'
  145.         (very similar to 'F')
  146.  
  147. */
  148.  
  149. /* The order of the opcodes in this table is significant:
  150.    
  151.    * The assembler requires that all instances of the same mnemonic must be
  152.    consecutive.  If they aren't, the assembler will bomb at runtime.
  153.  
  154.    * The disassembler should not care about the order of the opcodes.  */
  155.  
  156. static struct pa_opcode pa_opcodes[] =
  157. {
  158.  
  159. /* pseudo-instructions */
  160.  
  161. { "b",        0xe8000000, 0xffe0e000, "nW", NORMAL}, /* bl foo,r0 */
  162. { "ldi",    0x34000000, 0xffe0c000, "j,x"},    /* ldo val(r0),r */
  163. { "comib",     0x84000000, 0xfc000000, "?n5,b,w", CONDITIONAL}, /* comib{tf}*/
  164. { "comb",    0x80000000, 0xfc000000, "?nx,b,w", CONDITIONAL}, /* comb{tf} */
  165. { "addb",    0xa0000000, 0xfc000000, "!nx,b,w", CONDITIONAL}, /* addb{tf} */
  166. { "addib",    0xa4000000, 0xfc000000, "!n5,b,w", CONDITIONAL}, /* addib{tf}*/
  167. { "nop",        0x08000240, 0xffffffff, ""},      /* or 0,0,0 */
  168. { "copy",       0x08000240, 0xffe0ffe0, "x,t"},   /* or r,0,t */
  169. { "mtsar",      0x01601840, 0xffe0ffff, "x"}, /* mtctl r,cr11 */
  170.  
  171. { "ldw",        0x48000000, 0xfc000000, "j(B),x"},
  172. { "ldh",        0x44000000, 0xfc000000, "j(B),x"},
  173. { "ldb",        0x40000000, 0xfc000000, "j(B),x"},
  174. { "stw",        0x68000000, 0xfc000000, "x,j(B)"},
  175. { "sth",        0x64000000, 0xfc000000, "x,j(B)"},
  176. { "stb",        0x60000000, 0xfc000000, "x,j(B)"},
  177. { "ldwm",       0x4c000000, 0xfc000000, "j(B),x"},
  178. { "stwm",       0x6c000000, 0xfc000000, "x,j(B)"},
  179. { "ldwx",       0x0c000080, 0xfc001fc0, "cx(B),t"},
  180. { "ldhx",       0x0c000040, 0xfc001fc0, "cx(B),t"},
  181. { "ldbx",       0x0c000000, 0xfc001fc0, "cx(B),t"},
  182. { "ldwax",      0x0c000180, 0xfc00dfc0, "cx(b),t"},
  183. { "ldcwx",      0x0c0001c0, 0xfc001fc0, "cx(B),t"},
  184. { "ldws",    0x0c001080, 0xfc001fc0, "C5(B),t"},
  185. { "ldhs",    0x0c001040, 0xfc001fc0, "C5(B),t"},
  186. { "ldbs",    0x0c001000, 0xfc001fc0, "C5(B),t"},
  187. { "ldwas",    0x0c001180, 0xfc00dfc0, "C5(b),t"},
  188. { "ldcws",    0x0c0011c0, 0xfc001fc0, "C5(B),t"},
  189. { "stws",    0x0c001280, 0xfc001fc0, "Cx,V(B)"},
  190. { "sths",    0x0c001240, 0xfc001fc0, "Cx,V(B)"},
  191. { "stbs",    0x0c001200, 0xfc001fc0, "Cx,V(B)"},
  192. { "stwas",    0x0c001380, 0xfc00dfc0, "Cx,V(b)"},
  193. { "stbys",    0x0c001300, 0xfc001fc0, "Yx,V(B)"},
  194. { "ldo",    0x34000000, 0xfc00c000, "j(b),x"},
  195. { "ldil",    0x20000000, 0xfc000000, "k,b"},
  196. { "addil",    0x28000000, 0xfc000000, "k,b"},
  197. { "bl",        0xe8000000, 0xfc00e000, "nW,b", NORMAL},
  198. { "gate",    0xe8002000, 0xfc00e000, "nW,b", NORMAL},
  199. { "blr",    0xe8004000, 0xfc00e001, "nx,b", NORMAL},
  200. { "bv",        0xe800c000, 0xfc00e001, "nx(b)", NORMAL},
  201. { "be",        0xe0000000, 0xfc000000, "nW(S,b)", NORMAL},
  202. { "ble",    0xe4000000, 0xfc000000, "nW(S,b)", NORMAL},
  203. { "movb",    0xc8000000, 0xfc000000, ">nx,b,w", CONDITIONAL},
  204. { "movib",    0xcc000000, 0xfc000000, ">n5,b,w", CONDITIONAL},
  205. { "combt",    0x80000000, 0xfc000000, "<nx,b,w", CONDITIONAL},
  206. { "combf",    0x88000000, 0xfc000000, "<nx,b,w", CONDITIONAL},
  207. { "comibt",    0x84000000, 0xfc000000, "<n5,b,w", CONDITIONAL},
  208. { "comibf",    0x8c000000, 0xfc000000, "<n5,b,w", CONDITIONAL},
  209. { "addbt",    0xa0000000, 0xfc000000, "+nx,b,w", CONDITIONAL},
  210. { "addbf",    0xa8000000, 0xfc000000, "+nx,b,w", CONDITIONAL},
  211. { "addibt",    0xa4000000, 0xfc000000, "+n5,b,w", CONDITIONAL},
  212. { "addibf",    0xac000000, 0xfc000000, "+n5,b,w", CONDITIONAL},
  213. { "bvb",    0xc0000000, 0xffe00000, "~nx,w", CONDITIONAL},
  214. { "bb",        0xc4000000, 0xfc000000, "~nx,Q,w", CONDITIONAL}, /* maybe */
  215.  
  216. /* Computation Instructions */
  217.   
  218. { "add",        0x08000600, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  219. { "addl",       0x08000a00, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  220. { "addo",       0x08000e00, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  221. { "addc",       0x08000700, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  222. { "addco",      0x08000f00, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  223. { "sh1add",     0x08000640, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  224. { "sh1addl",    0x08000a40, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  225. { "sh1addo",    0x08000e40, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  226. { "sh2add",     0x08000680, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  227. { "sh2addl",    0x08000a80, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  228. { "sh2addo",    0x08000e80, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  229. { "sh3add",     0x080006c0, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  230. { "sh3addl",    0x08000ac0, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  231. { "sh3addo",    0x08000ec0, 0xfc000fe0, "+x,b,t", CONDITIONAL},
  232. { "sub",        0x08000400, 0xfc000fe0, "-x,b,t", CONDITIONAL},
  233. { "subo",       0x08000c00, 0xfc000fe0, "-x,b,t", CONDITIONAL},
  234. { "subb",       0x08000500, 0xfc000fe0, "-x,b,t", CONDITIONAL},
  235. { "subbo",      0x08000d00, 0xfc000fe0, "-x,b,t", CONDITIONAL},
  236. { "subt",       0x080004c0, 0xfc000fe0, "-x,b,t", CONDITIONAL},
  237. { "subto",      0x08000cc0, 0xfc000fe0, "-x,b,t", CONDITIONAL},
  238. { "ds",         0x08000440, 0xfc000fe0, "-x,b,t", CONDITIONAL},
  239. { "comclr",     0x08000880, 0xfc000fe0, "-x,b,t", CONDITIONAL},
  240. { "or",         0x08000240, 0xfc000fe0, "&x,b,t", CONDITIONAL},
  241. { "xor",        0x08000280, 0xfc000fe0, "&x,b,t", CONDITIONAL},
  242. { "and",        0x08000200, 0xfc000fe0, "&x,b,t", CONDITIONAL},
  243. { "andcm",      0x08000000, 0xfc000fe0, "&x,b,t", CONDITIONAL},
  244. { "uxor",       0x08000380, 0xfc000fe0, "Ux,b,t", CONDITIONAL},
  245. { "uaddcm",     0x08000980, 0xfc000fe0, "Ux,b,t", CONDITIONAL},
  246. { "uaddcmt",    0x080009c0, 0xfc000fe0, "Ux,b,t", CONDITIONAL},
  247. { "dcor",       0x08000b80, 0xfc1f0fe0, "Ub,t",   CONDITIONAL},
  248. { "idcor",      0x08000bc0, 0xfc1f0fe0, "Ub,t",   CONDITIONAL},
  249. { "addi",       0xb4000000, 0xfc000800, "+i,b,x", CONDITIONAL},
  250. { "addio",      0xb4000800, 0xfc000800, "+i,b,x", CONDITIONAL},
  251. { "addit",      0xb0000000, 0xfc000800, "+i,b,x", CONDITIONAL},
  252. { "addito",     0xb0000800, 0xfc000800, "+i,b,x", CONDITIONAL},
  253. { "subi",       0x94000000, 0xfc000800, "-i,b,x", CONDITIONAL},
  254. { "subio",      0x94000800, 0xfc000800, "-i,b,x", CONDITIONAL},
  255. { "comiclr",    0x90000000, 0xfc000800, "-i,b,x", CONDITIONAL},
  256.  
  257. /* Extract and Deposit Instructions */
  258.  
  259. { "vshd",       0xd0000000, 0xfc001fe0, ">x,b,t", CONDITIONAL},
  260. { "shd",        0xd0000800, 0xfc001c00, ">x,b,p,t", CONDITIONAL},
  261. { "vextru",     0xd0001000, 0xfc001fe0, ">b,T,x", CONDITIONAL},
  262. { "vextrs",     0xd0001400, 0xfc001fe0, ">b,T,x", CONDITIONAL},
  263. { "extru",      0xd0001800, 0xfc001c00, ">b,P,T,x", CONDITIONAL},
  264. { "extrs",      0xd0001c00, 0xfc001c00, ">b,P,T,x", CONDITIONAL},
  265. { "zvdep",      0xd4000000, 0xfc001fe0, ">x,T,b", CONDITIONAL},
  266. { "vdep",       0xd4000400, 0xfc001fe0, ">x,T,b", CONDITIONAL},
  267. { "zdep",       0xd4000800, 0xfc001c00, ">x,p,T,b", CONDITIONAL},
  268. { "dep",        0xd4000c00, 0xfc001c00, ">x,p,T,b", CONDITIONAL},
  269. { "zvdepi",     0xd4001000, 0xfc001fe0, ">5,T,b", CONDITIONAL},
  270. { "vdepi",      0xd4001400, 0xfc001fe0, ">5,T,b", CONDITIONAL},
  271. { "zdepi",      0xd4001800, 0xfc001c00, ">5,p,T,b", CONDITIONAL},
  272. { "depi",       0xd4001c00, 0xfc001c00, ">5,p,T,b", CONDITIONAL},
  273.  
  274. /* System Control Instructions */
  275.  
  276. { "break",      0x00000000, 0xfc001fe0, "r,A"},
  277. { "rfi",        0x00000c00, 0xffffffff, ""},
  278. { "ssm",        0x00000d60, 0xffe0ffe0, "R,t"},
  279. { "rsm",        0x00000e60, 0xffe0ffe0, "R,t"},
  280. { "mtsm",       0x00001860, 0xffe0ffff, "x"},
  281. { "ldsid",      0x000010a0, 0xfc1f3fe0, "(B),t"},
  282. { "mtsp",       0x00001820, 0xffe01fff, "x,S"},
  283. { "mtctl",      0x00001840, 0xfc00ffff, "x,b"},
  284. { "mfsp",       0x000004a0, 0xffff1fe0, "S,t"},
  285. { "mfctl",      0x000008a0, 0xfc1fffe0, "b,t"},
  286. { "sync",       0x00000400, 0xffffffff, ""},
  287. { "prober",     0x04001180, 0xfc003fe0, "(B),x,t"},
  288. { "proberi",    0x04003180, 0xfc003fe0, "(B),5,t"},
  289. { "probew",     0x040011c0, 0xfc003fe0, "(B),x,t"},
  290. { "probewi",    0x040031c0, 0xfc003fe0, "(B),5,t"},
  291. { "lpa",        0x04001340, 0xfc003fc0, "Zx(B),t"},
  292. { "lha",        0x04001300, 0xfc003fc0, "Zx(B),t"},
  293. { "pdtlb",      0x04001200, 0xfc003fdf, "Zx(B)"},
  294. { "pitlb",      0x04000200, 0xfc003fdf, "Zx(B)"},
  295. { "pdtlbe",     0x04001240, 0xfc003fdf, "Zx(B)"},
  296. { "pitlbe",     0x04000240, 0xfc003fdf, "Zx(B)"},
  297. { "idtlba",     0x04001040, 0xfc003fff, "x,(B)"},
  298. { "iitlba",     0x04000040, 0xfc003fff, "x,(B)"},
  299. { "idtlbp",     0x04001000, 0xfc003fff, "x,(B)"},
  300. { "iitlbp",     0x04000000, 0xfc003fff, "x,(B)"},
  301. { "pdc",        0x04001380, 0xfc003fdf, "Zx(B)"},
  302. { "fdc",        0x04001280, 0xfc003fdf, "Zx(B)"},
  303. { "fic",        0x04000280, 0xfc003fdf, "Zx(B)"},
  304. { "fdce",       0x040012c0, 0xfc003fdf, "Zx(B)"},
  305. { "fice",       0x040002c0, 0xfc003fdf, "Zx(B)"},
  306. { "diag",       0x14000000, 0xfc000000, "D"},
  307.  
  308. /* Floating Point Coprocessor Instructions */
  309.  
  310. { "fldwx",      0x24000000, 0xfc001f80, "cx(B),v"}, /* PJH:  v used to be t */
  311.                                     /* and 0xfc001f80 used to be 0xfc001fc0 */
  312. { "flddx",      0x2c000000, 0xfc001fc0, "cx(B),t"},
  313. { "fstwx",      0x24000200, 0xfc001fc0, "cv,x(B)"}, /* PJH:  v used to be t */
  314. { "fstdx",      0x2c000200, 0xfc001fc0, "ct,x(B)"},
  315. { "fldws",      0x24001000, 0xfc001fc0, "C5(B),v"}, /* PJH:  v used to be t */
  316. { "fldds",      0x2c001000, 0xfc001fc0, "C5(B),t"},
  317. { "fstws",      0x24001200, 0xfc001fc0, "Cv,5(B)"}, /* PJH:  v used to be t */
  318. { "fstds",      0x2c001200, 0xfc001fc0, "Ct,5(B)"},
  319. { "fadd",       0x30000600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
  320. { "fsub",       0x30002600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
  321. { "fmpy",       0x30004600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
  322. { "fdiv",       0x30006600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
  323. { "fsqrt",      0x30008000, 0xfc1fe7e0, "FE,v"},   /* PJH: operands were "Fb,t" */
  324. { "fabs",       0x30006000, 0xfc1fe7e0, "FE,v"},   /* PJH: operands were "Fb,t" */
  325. { "frem",       0x30008600, 0xfc00e7e0, "FE,X,v"}, /* PJH: operands were "Fb,x,t" */
  326. { "frnd",       0x3000a000, 0xfc1fe7e0, "FE,v"},   /* PJH: operands were "Fb,t" */
  327. { "fcpy",       0x30004000, 0xfc1fe7e0, "FE,v"},   /* PJH: operands were "Fb,t" */
  328. { "fcnvff",     0x30000200, 0xfc1f87e0, "FGE,v"},  /* PJH: operands were "FGb,t" */
  329. { "fcnvxf",     0x30008200, 0xfc1f87e0, "FGE,v"},  /* PJH: operands were "FGb,t" */
  330. { "fcnvfx",     0x30010200, 0xfc1f87e0, "FGE,v"},  /* PJH: operands were "FGb,t" */
  331. { "fcnvfxt",    0x30018200, 0xfc1f87e0, "FGE,v"},  /* PJH: operands were "FGb,t" */
  332. { "fcmp",       0x30000400, 0xfc00e7e0, "FME,X"},  /* PJH: operands were "FMb,x" */
  333. { "ftest",      0x30002420, 0xffffffff, ""},
  334.  
  335. /* PA-89 only instructions */
  336.  
  337. { "xmpyu",    0x38004700, 0xfc00e720, "FE,X,v"},
  338. { "fmpyadd",    0x18000000, 0xfc000000, "H4,6,7,9,8"},
  339. { "fmpysub",    0x98000000, 0xfc000000, "H4,6,7,9,8"},
  340.  
  341. /* Assist Instructions */
  342.  
  343. { "spop0",      0x10000000, 0xfc000600, ",f,On", NORMAL},
  344. { "spop1",      0x10000200, 0xfc000600, ",f,ont", NORMAL},
  345. { "spop2",      0x10000400, 0xfc000600, ",f,1nb", NORMAL},
  346. { "spop3",      0x10000600, 0xfc000600, ",f,0nx,b", NORMAL},
  347. { "copr",       0x30000000, 0xfc000000, ",u,2n", NORMAL},
  348. { "cldwx",      0x24000000, 0xfc001e00, ",u,Zx(B),t"},
  349. { "clddx",      0x2c000000, 0xfc001e00, ",u,Zx(B),t"},
  350. { "cstwx",      0x24000200, 0xfc001e00, ",u,Zt,x(B)"},
  351. { "cstdx",      0x2c000200, 0xfc001e00, ",u,Zt,x(B)"},
  352. { "cldws",      0x24001000, 0xfc001e00, ",u,Z5(B),t"},
  353. { "cldds",      0x2c001000, 0xfc001e00, ",u,Z5(B),t"},
  354. { "cstws",      0x24001200, 0xfc001e00, ",u,Zt,5(B)"},
  355. { "cstds",      0x2c001200, 0xfc001e00, ",u,Zt,5(B)"},
  356. };
  357.  
  358. #define NUMOPCODES ((sizeof pa_opcodes)/(sizeof pa_opcodes[0]))
  359.