home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / superopt-2.5-src.tgz / tar.out / fsf / superopt / superopt.h < prev    next >
C/C++ Source or Header  |  1996-09-28  |  52KB  |  1,482 lines
  1. /* Superoptimizer definitions.
  2.  
  3.    Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
  4.  
  5.    This program is free software; you can redistribute it and/or modify it
  6.    under the terms of the GNU General Public License as published by the
  7.    Free Software Foundation; either version 2, or (at your option) any
  8.    later version.
  9.  
  10.    This program is distributed in the hope that it will be useful, but
  11.    WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.    General Public License for more details.
  14.  
  15.    You should have received a copy of the GNU General Public License along
  16.    with this program; see the file COPYING.  If not, write to the Free
  17.    Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18.  
  19. #if !(defined(SPARC) || defined(POWER) || defined(POWERPC) || defined(M88000) \
  20.       || defined(AM29K) || defined(MC68000) || defined(MC68020) \
  21.       || defined(I386) || defined(PYR) || defined(ALPHA) || defined(HPPA) \
  22.       || defined(SH) || defined (I960) || defined (I960B))
  23. /* If no target instruction set is defined, use host instruction set.  */
  24. #define SPARC (defined(sparc) || defined(__sparc__))
  25. #define POWER ((defined(rs6000) || defined(_IBMR2)) && !defined (_ARCH_PPC))
  26. #define POWEPC (defined(_ARCH_PPC))
  27. /* #define POWER ???? */
  28. #define M88000 (defined(m88000) || defined(__m88000__))
  29. #define AM29K (defined(_AM29K) || defined(_AM29000))
  30. #define MC68020 (defined(m68020) || defined(mc68020))
  31. #define MC68000 (defined(m68000) || defined(mc68000))
  32. #define I386 (defined(i386) || defined(i80386) || defined(__i386__))
  33. #define PYR (defined(pyr) || defined(__pyr__))
  34. #define ALPHA defined(__alpha)
  35. #define HPPA defined(__hppa)
  36. #define SH defined(__sh__)
  37. #define I960 defined (__i960)
  38. #endif
  39.  
  40. #define M68000 (MC68000 || MC68020)
  41.  
  42. #if POWERPC
  43. #define POWER 1
  44. #endif
  45.  
  46. #if I960B
  47. #define I960 1
  48. #endif
  49.  
  50. #if SPARC
  51. #define TARGET_STRING "SPARC v7/v8"
  52. #elif POWERPC
  53. #define TARGET_STRING "PowerPC"
  54. #elif POWER
  55. #define TARGET_STRING "IBM POWER"
  56. #elif M88000
  57. #define TARGET_STRING "Motorola MC88000"
  58. #elif AM29K
  59. #define TARGET_STRING "Amd 29000"
  60. #elif MC68020
  61. #define TARGET_STRING "Motorola MC68020"
  62. #elif MC68000
  63. #define TARGET_STRING "Motorola MC68000 (no 68020 instructions)"
  64. #elif I386
  65. #define TARGET_STRING "Intel 386/486/Pentium/Sexium"
  66. #elif PYR
  67. #define TARGET_STRING "Pyramid (with the secret instructions)"
  68. #elif ALPHA
  69. #define TARGET_STRING "DEC Alpha"
  70. #elif HPPA
  71. #define TARGET_STRING "Hewlett-Packard Precision Architecture (PA-RISC)"
  72. #elif  SH
  73. #define TARGET_STRING "Hitachi Super-H (SH)"
  74. /* Reject sequences that require two different registers to be allocated to
  75.    register r0.  */
  76. #define EXTRA_SEQUENCE_TESTS(seq, n) \
  77. {                                    \
  78.   int reg0 = -1;    /* -1 means r0 is not yet allocated */        \
  79.   int i;                                \
  80.   for (i = 0; i < n; i++)                        \
  81.     {                                    \
  82.       if ((seq[i].opcode == AND || seq[i].opcode == XOR            \
  83.        || seq[i].opcode == IOR || seq[i].opcode == CYEQ)        \
  84.       && IMMEDIATE_P (seq[i].s2) && IMMEDIATE_VAL (seq[i].s2) != 0)    \
  85.     {                                \
  86.       if (reg0 >= 0 && reg0 != seq[i].d)                \
  87.         return;                            \
  88.       reg0 = seq[i].d;                        \
  89.     }                                \
  90.     }                                    \
  91. }
  92. #elif  I960
  93. #define TARGET_STRING "Intel 960 v1.0"
  94. #elif  I960B
  95. #define TARGET_STRING "Intel 960 v1.1"
  96. #endif
  97.  
  98. #if !(SPARC || POWER || M88000 || AM29K || M68000 || I386 || PYR \
  99.       || ALPHA || HPPA || SH || I960)
  100. #error You have to choose target CPU type (e.g. -DSPARC).
  101. #endif
  102.  
  103. #if MC68000
  104. #define SHIFT_COST(CNT) ((8+2*(CNT)) / 5) /* internal cost */
  105. #else
  106. #define SHIFT_COST(CNT) 1
  107. #endif
  108.  
  109. #if ALPHA
  110. #define BITS_PER_WORD 64
  111. #else
  112. #define BITS_PER_WORD 32
  113. #endif
  114.  
  115. /* Get longlong.h for double-word arithmetic.
  116.    First define the types for it to operate on.  */
  117. #define UWtype word
  118. #define UHWtype word
  119. #define UDWtype unsigned long    /* Bogus, but we'll not depend on it */
  120. #define W_TYPE_SIZE BITS_PER_WORD
  121. #define SItype int
  122. #define USItype unsigned int
  123. #define DItype long long int
  124. #define UDItype unsigned long long int
  125. #define LONGLONG_STANDALONE
  126. #include "longlong.h"
  127.  
  128. #if HPPA
  129. #define HAS_NULLIFICATION 1
  130. enum { NOT_NULLIFY = 0, NULLIFY = 1 };
  131. #endif
  132.  
  133. #if BITS_PER_WORD == 64
  134. #if defined (__GNUC__) || defined (_LONGLONG)
  135. typedef unsigned long long int unsigned_word;
  136. typedef signed long long int signed_word;
  137. typedef unsigned_word word;
  138. #undef PSTR            /* no portable way to print */
  139. #elif __alpha /* Native compiler on alpha has 64 bit longs.  */
  140. typedef unsigned long int unsigned_word;
  141. typedef signed long int signed_word;
  142. typedef unsigned_word word;
  143. #define PSTR "0x%lx"
  144. #else /* Not on alpha, not GCC.  Don't have 64 bit type.  */
  145. #error Do not know how to perform 64 bit arithmetic with this compiler.
  146. #endif
  147. #else
  148. typedef unsigned int unsigned_word;
  149. typedef signed int signed_word;
  150. typedef unsigned_word word;
  151. #define PSTR "0x%x"
  152. #endif
  153.  
  154.  
  155. #define TRUNC_CNT(cnt) ((unsigned) (cnt) % BITS_PER_WORD)
  156.  
  157. #if defined(sparc) || defined(__GNUC__)
  158. #define alloca __builtin_alloca
  159. #endif
  160.  
  161. #if !defined(__GNUC__) || !defined(__OPTIMIZE__) || defined(DEBUG)
  162. #define inline /* Empty */
  163. #endif
  164.  
  165. /* Handle immediates by putting all handled values in the VALUE array at
  166.    appropriate indices, and then insert these indices in the code.
  167.    We currently do this just for some hardwired constants.  */
  168.  
  169. #define CNST_0x80000000 (0x20 - 2)
  170. #define CNST_0x7FFFFFFF (0x20 - 3)
  171. #define CNST_0xFFFF (0x20 - 4)
  172. #define CNST_0xFF (0x20 - 5)
  173.  
  174. #define VALUE_MIN_SIGNED ((word) 1 << (BITS_PER_WORD - 1))
  175. #define VALUE_MAX_SIGNED (((word) 1 << (BITS_PER_WORD - 1)) - 1)
  176.  
  177. #define CNST(n) (0x20 + n)
  178. #define VALUE(n) n
  179.  
  180. /* The IMMEDIATE_* macros are for printing assembly.  NOT for sequence
  181.    generating or analyze.  */
  182. #define IMMEDIATE_P(op) (op >= 0x20 - 5)
  183. static const word __immediate_val[] =
  184. {
  185.   VALUE_MIN_SIGNED,
  186.   VALUE_MAX_SIGNED,
  187.   0xffff,
  188.   0xff
  189. };
  190. #define IMMEDIATE_VAL(op) \
  191.   ((op) >= 0x20 - 1 ? op - 0x20 : __immediate_val[0x20 - 2 - (op)])
  192.  
  193. typedef enum
  194. {
  195. #undef DEF_INSN
  196. #define DEF_INSN(SYM,CLASS,NAME) SYM,
  197. #include "insn.def"
  198. } opcode_t;
  199.  
  200. #define GET_INSN_CLASS(OP) (insn_class[OP])
  201. #define GET_INSN_NAME(OP) (insn_name[OP])
  202.  
  203. #define UNARY_OPERATION(insn) (GET_INSN_CLASS (insn.opcode) == '1')
  204.  
  205. typedef struct
  206. {
  207.   opcode_t opcode:11;
  208.   unsigned int s1:7;
  209.   unsigned int s2:7;
  210.   unsigned int d:7;
  211. } insn_t;
  212.  
  213. #if __GNUC__ < 2
  214. #define __CLOBBER_CC
  215. #define __AND_CLOBBER_CC
  216. #else /* __GNUC__ >= 2 */
  217. #define __CLOBBER_CC : "cc"
  218. #define __AND_CLOBBER_CC , "cc"
  219. #endif /* __GNUC__ < 2 */
  220.  
  221. /* PERFORM_* for all instructions the search uses.  These macros are
  222.    used both in the search phase and in the test phase.  */
  223.  
  224. #if defined(__GNUC__) && defined(USE_ASM)
  225. /*** Define machine-dependent PERFORM_* here to improve synthesis speed ***/
  226.  
  227. #if sparc
  228. #define PERFORM_ADD_CIO(d, co, r1, r2, ci) \
  229.   asm ("subcc %%g0,%4,%%g0    ! set cy if CI != 0
  230.     addxcc %2,%3,%0        ! add R1 and R2
  231.     addx %%g0,%%g0,%1    ! set CO to cy"                \
  232.        : "=r" (d), "=r" (co)                        \
  233.        : "%r" (r1), "rI" (r2), "rI" (ci)                \
  234.        __CLOBBER_CC)
  235. #define PERFORM_ADD_CO(d, co, r1, r2, ci) \
  236.   asm ("addcc %2,%3,%0        ! add R1 and R2
  237.     addx %%g0,%%g0,%1    ! set CO to cy"                \
  238.        : "=r" (d), "=r" (co)                        \
  239.        : "%r" (r1), "rI" (r2)                        \
  240.        __CLOBBER_CC)
  241. #define PERFORM_SUB_CIO(d, co, r1, r2, ci) \
  242.   asm ("subcc %%g0,%4,%%g0    ! set cy if CI != 0
  243.     subxcc %2,%3,%0        ! subtract R2 from R1
  244.     addx %%g0,%%g0,%1    ! set CO to cy"                \
  245.        : "=r" (d), "=r" (co)                        \
  246.        : "r" (r1), "rI" (r2), "rI" (ci)                    \
  247.        __CLOBBER_CC)
  248. #define PERFORM_SUB_CO(d, co, r1, r2, ci) \
  249.   asm ("subcc %2,%3,%0        ! subtract R2 from R1
  250.     addx %%g0,%%g0,%1    ! set CO to cy"                \
  251.        : "=r" (d), "=r" (co)                        \
  252.        : "r" (r1), "rI" (r2)                        \
  253.        __CLOBBER_CC)
  254. #define PERFORM_ADC_CIO(d, co, r1, r2, ci) \
  255.   asm ("subcc %4,1,%%g0        ! cy = (CI == 0)
  256.     subxcc %2,%3,%0        ! subtract R2 from R1
  257.     subx %%g0,-1,%1        ! set CO to !cy"            \
  258.        : "=&r" (d), "=r" (co)                        \
  259.        : "r" (r1), "rI" (r2), "rI" (ci)                    \
  260.        __CLOBBER_CC)
  261. #define PERFORM_ADC_CO(d, co, r1, r2, ci) \
  262.   asm ("subcc %2,%3,%0        ! subtract R2 from R1
  263.     subx %%g0,-1,%1        ! set CO to !cy"            \
  264.        : "=&r" (d), "=r" (co)                        \
  265.        : "r" (r1), "rI" (r2)                        \
  266.        __CLOBBER_CC)
  267. #endif /* sparc */
  268.  
  269. #if m88k
  270. #define PERFORM_ADD_CIO(d, co, r1, r2, ci) \
  271.   asm ("or %0,r0,1
  272.     subu.co r0,%4,%0    ; set cy if CI != 0
  273.     addu.cio %0,%2,%r3    ; add R1 and R2
  274.     addu.ci %1,r0,r0    ; set CO to cy"                \
  275.        : "=&r" (d), "=r" (co)                        \
  276.        : "%r" (r1), "Or" (r2), "r" (ci))
  277. #define PERFORM_ADD_CO(d, co, r1, r2, ci) \
  278.   asm ("addu.co %0,%2,%r3    ; add R1 and R2
  279.     addu.ci %1,r0,r0    ; set CO to cy"                \
  280.        : "=r" (d), "=r" (co)                        \
  281.        : "%r" (r1), "Or" (r2))
  282. #define PERFORM_SUB_CIO(d, co, r1, r2, ci) \
  283.   asm ("subu.co r0,r0,%r4    ; reset cy if CI != 0
  284.     subu.cio %0,%2,%r3    ; subtract R2 from R1
  285.     subu.ci %1,r0,r0    ; set CO to -1+cy
  286.     subu %1,r0,%1        ; set CO to !cy"            \
  287.        : "=r" (d), "=r" (co)                        \
  288.        : "r" (r1), "Or" (r2), "Or" (ci))
  289. #define PERFORM_SUB_CO(d, co, r1, r2, ci) \
  290.   asm ("subu.co %0,%2,%r3    ; subtract R2 from R1
  291.     subu.ci %1,r0,r0    ; set CO to -1+cy
  292.     subu %1,r0,%1        ; set CO to !cy"            \
  293.        : "=r" (d), "=r" (co)                        \
  294.        : "r" (r1), "Or" (r2))
  295. #define PERFORM_ADC_CIO(d, co, r1, r2, ci) \
  296.   asm ("or %0,r0,1
  297.     subu.co r0,%r4,%0    ; set cy if CI != 0
  298.     subu.cio %0,%2,%r3    ; subtract R2 from R1
  299.     addu.ci %1,r0,r0    ; set CO to cy"                \
  300.        : "=&r" (d), "=r" (co)                        \
  301.        : "r" (r1), "Or" (r2), "Or" (ci))
  302. #define PERFORM_ADC_CO(d, co, r1, r2, ci) \
  303.   asm ("subu.co %0,%2,%r3    ; subtract R2 from R1
  304.     addu.ci %1,r0,r0    ; set CO to cy"                \
  305.        : "=r" (d), "=r" (co)                        \
  306.        : "r" (r1), "Or" (r2))
  307. #endif /* m88k */
  308.  
  309. #endif /* __GNUC__ && USE_ASM */
  310.  
  311. /************************* Default PERFORM_* in C *************************/
  312.  
  313. #define PERFORM_COPY(d, co, r1, ci) \
  314.   ((d) = (r1), (co) = (ci))
  315. #define PERFORM_EXCHANGE(co, r1, r2, ci) \
  316.   do {word __temp = (r1), (r1) = (r2), (r2) = __temp, (co) = (ci);} while (0)
  317.  
  318. #define PERFORM_ADD(d, co, r1, r2, ci) \
  319.   ((d) = (r1) + (r2), (co) = (ci))
  320. #ifndef PERFORM_ADD_CIO
  321. #define PERFORM_ADD_CIO(d, co, r1, r2, ci) \
  322.   do { word __d = (r1) + (ci);                        \
  323.        word __cy = __d < (ci);                        \
  324.        (d) = __d + (r2);                        \
  325.        (co) = ((d) < __d) + __cy; } while (0)
  326. #endif
  327. #ifndef PERFORM_ADD_CI
  328. #define PERFORM_ADD_CI(d, co, r1, r2, ci) \
  329.   do { word __d = (r1) + (r2) + (ci);                    \
  330.        (co) = (ci);                            \
  331.        (d) = __d; } while (0)
  332. #endif
  333. #ifndef PERFORM_ADD_CO
  334. #define PERFORM_ADD_CO(d, co, r1, r2, ci) \
  335.   do { word __d = (r1) + (r2);                        \
  336.        (co) = __d < (r1);                        \
  337.        (d) = __d; } while (0)
  338. #endif
  339.  
  340. #define PERFORM_SUB(d, co, r1, r2, ci) \
  341.   ((d) = (r1) - (r2), (co) = (ci))
  342. #ifndef PERFORM_SUB_CIO
  343. #define PERFORM_SUB_CIO(d, co, r1, r2, ci) \
  344.   do { word __d = (r1) - (r2) - (ci);                    \
  345.        (co) = (ci) ? __d >= (r1) : __d > (r1);                \
  346.        (d) = __d; } while (0)
  347. #endif
  348. #ifndef PERFORM_SUB_CI
  349. #define PERFORM_SUB_CI(d, co, r1, r2, ci) \
  350.   do { word __d = (r1) - (r2) - (ci);                    \
  351.        (co) = (ci);                            \
  352.        (d) = __d; } while (0)
  353. #endif
  354. #ifndef PERFORM_SUB_CO
  355. #define PERFORM_SUB_CO(d, co, r1, r2, ci) \
  356.   do { word __d = (r1) - (r2);                        \
  357.        (co) = __d > (r1);                        \
  358.        (d) = __d; } while (0)
  359. #endif
  360.  
  361. #ifndef PERFORM_ADC_CIO
  362. #define PERFORM_ADC_CIO(d, co, r1, r2, ci) \
  363.   do { word __d = (r1) + ~(r2) + (ci);                    \
  364.        (co) = (ci) ? __d <= (r1) : __d < (r1);                \
  365.        (d) = __d; } while (0)
  366. #endif
  367. #ifndef PERFORM_ADC_CI
  368. #define PERFORM_ADC_CI(d, co, r1, r2, ci) \
  369.   do { word __d = (r1) + ~(r2) + (ci);                    \
  370.        (co) = (ci);                            \
  371.        (d) = __d; } while (0)
  372. #endif
  373. #ifndef PERFORM_ADC_CO
  374. #define PERFORM_ADC_CO(d, co, r1, r2, ci) \
  375.   do { word __d = (r1) - (r2);                        \
  376.        (co) = __d <= (r1);                        \
  377.        (d) = __d; } while (0)
  378. #endif
  379.  
  380. #ifndef PERFORM_ADDCMPL
  381. #define PERFORM_ADDCMPL(d, co, r1, r2, ci) \
  382.   ((d) = (r1) + ~(r2), (co) = (ci))
  383. #endif
  384.  
  385. #ifndef PERFORM_CMP
  386. #define PERFORM_CMP(d, co, r1, r2, ci) \
  387.   ((co) = (r1) < (r2))
  388. #endif
  389. #ifndef PERFORM_CMPPAR
  390. #define PERFORM_CMPPAR(d, co, r1, r2, ci) \
  391.   do {                                    \
  392.     word __x;                                \
  393.     union { long w; short h[2]; char b[4]; } __r1, __r2;        \
  394.     __r1.w = (r1); __r2.w = (r2);                    \
  395.     __x = ((__r1.h[0] != __r2.h[0]) && (__r1.h[1] != __r2.h[1])) << 14;    \
  396.     __x |= ((__r1.b[0] != __r2.b[0]) && (__r1.b[1] != __r2.b[1])    \
  397.        && (__r1.b[2] != __r2.b[2]) && (__r1.b[3] != __r2.b[3])) << 12; \
  398.     __x |= ((unsigned_word) (r1) >= (unsigned_word) (r2)) << 10;    \
  399.     __x |= ((unsigned_word) (r1) <= (unsigned_word) (r2)) << 8;        \
  400.     __x |= ((signed_word) (r1) >= (signed_word) (r2)) << 6;        \
  401.     __x |= ((signed_word) (r1) <= (signed_word) (r2)) << 4;        \
  402.     __x |= ((r1) != (r2)) << 2;                        \
  403.     (d) = __x + 0x5554;        /* binary 0101010101010100 */        \
  404.     (co) = (ci);                            \
  405.   } while (0)
  406. #endif
  407.  
  408. /* Logic operations that don't affect carry.  */
  409. #ifndef PERFORM_AND
  410. #define PERFORM_AND(d, co, r1, r2, ci) \
  411.   ((d) = (r1) & (r2), (co) = (ci))
  412. #endif
  413. #ifndef PERFORM_IOR
  414. #define PERFORM_IOR(d, co, r1, r2, ci) \
  415.   ((d) = (r1) | (r2), (co) = (ci))
  416. #endif
  417. #ifndef PERFORM_XOR
  418. #define PERFORM_XOR(d, co, r1, r2, ci) \
  419.   ((d) = (r1) ^ (r2), (co) = (ci))
  420. #endif
  421. #ifndef PERFORM_ANDC
  422. #define PERFORM_ANDC(d, co, r1, r2, ci) \
  423.   ((d) = (r1) & ~(r2), (co) = (ci))
  424. #endif
  425. #ifndef PERFORM_IORC
  426. #define PERFORM_IORC(d, co, r1, r2, ci) \
  427.   ((d) = (r1) | ~(r2), (co) = (ci))
  428. #endif
  429. #ifndef PERFORM_EQV
  430. #define PERFORM_EQV(d, co, r1, r2, ci) \
  431.   ((d) = (r1) ^ ~(r2), (co) = (ci))
  432. #endif
  433. #ifndef PERFORM_NAND
  434. #define PERFORM_NAND(d, co, r1, r2, ci) \
  435.   ((d) = ~((r1) & (r2)), (co) = (ci))
  436. #endif
  437. #ifndef PERFORM_NOR
  438. #define PERFORM_NOR(d, co, r1, r2, ci) \
  439.   ((d) = ~((r1) | (r2)), (co) = (ci))
  440. #endif
  441.  
  442. /* Logic operations that reset carry.  */
  443. #ifndef PERFORM_AND_RC
  444. #define PERFORM_AND_RC(d, co, r1, r2, ci) \
  445.   ((d) = (r1) & (r2), (co) = 0)
  446. #endif
  447. #ifndef PERFORM_IOR_RC
  448. #define PERFORM_IOR_RC(d, co, r1, r2, ci) \
  449.   ((d) = (r1) | (r2), (co) = 0)
  450. #endif
  451. #ifndef PERFORM_XOR_RC
  452. #define PERFORM_XOR_RC(d, co, r1, r2, ci) \
  453.   ((d) = (r1) ^ (r2), (co) = 0)
  454. #endif
  455. #ifndef PERFORM_ANDC_RC
  456. #define PERFORM_ANDC_RC(d, co, r1, r2, ci) \
  457.   ((d) = (r1) & ~(r2), (co) = 0)
  458. #endif
  459. #ifndef PERFORM_IORC_RC
  460. #define PERFORM_IORC_RC(d, co, r1, r2, ci) \
  461.   ((d) = (r1) | ~(r2), (co) = 0)
  462. #endif
  463. #ifndef PERFORM_EQV_RC
  464. #define PERFORM_EQV_RC(d, co, r1, r2, ci) \
  465.   ((d) = (r1) ^ ~(r2), (co) = 0)
  466. #endif
  467. #ifndef PERFORM_NAND_RC
  468. #define PERFORM_NAND_RC(d, co, r1, r2, ci) \
  469.   ((d) = ~((r1) & (r2)), (co) = 0)
  470. #endif
  471. #ifndef PERFORM_NOR_RC
  472. #define PERFORM_NOR_RC(d, co, r1, r2, ci) \
  473.   ((d) = ~((r1) | (r2)), (co) = 0)
  474. #endif
  475.  
  476. /* Logic operations that clobber carry.  */
  477. #ifndef PERFORM_AND_CC
  478. #define PERFORM_AND_CC(d, co, r1, r2, ci) \
  479.   ((d) = (r1) & (r2), (co) = -1)
  480. #endif
  481. #ifndef PERFORM_IOR_CC
  482. #define PERFORM_IOR_CC(d, co, r1, r2, ci) \
  483.   ((d) = (r1) | (r2), (co) = -1)
  484. #endif
  485. #ifndef PERFORM_XOR_CC
  486. #define PERFORM_XOR_CC(d, co, r1, r2, ci) \
  487.   ((d) = (r1) ^ (r2), (co) = -1)
  488. #endif
  489. #ifndef PERFORM_ANDC_CC
  490. #define PERFORM_ANDC_CC(d, co, r1, r2, ci) \
  491.   ((d) = (r1) & ~(r2), (co) = -1)
  492. #endif
  493. #ifndef PERFORM_IORC_CC
  494. #define PERFORM_IORC_CC(d, co, r1, r2, ci) \
  495.   ((d) = (r1) | ~(r2), (co) = -1)
  496. #endif
  497. #ifndef PERFORM_EQV_CC
  498. #define PERFORM_EQV_CC(d, co, r1, r2, ci) \
  499.   ((d) = (r1) ^ ~(r2), (co) = -1)
  500. #endif
  501. #ifndef PERFORM_NAND_CC
  502. #define PERFORM_NAND_CC(d, co, r1, r2, ci) \
  503.   ((d) = ~((r1) & (r2)), (co) = -1)
  504. #endif
  505. #ifndef PERFORM_NOR_CC
  506. #define PERFORM_NOR_CC(d, co, r1, r2, ci) \
  507.   ((d) = ~((r1) | (r2)), (co) = -1)
  508. #endif
  509.  
  510. #ifndef PERFORM_LSHIFTR
  511. #define PERFORM_LSHIFTR(d, co, r1, r2, ci) \
  512.   ((d) = ((unsigned_word) (r1) >> TRUNC_CNT(r2)),            \
  513.    (co) = (ci))
  514. #endif
  515. #ifndef PERFORM_ASHIFTR
  516. #define PERFORM_ASHIFTR(d, co, r1, r2, ci) \
  517.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)),                \
  518.    (co) = (ci))
  519. #endif
  520. #ifndef PERFORM_SHIFTL
  521. #define PERFORM_SHIFTL(d, co, r1, r2, ci) \
  522.   ((d) = ((unsigned_word) (r1) << TRUNC_CNT(r2)), (co) = (ci))
  523. #endif
  524. #ifndef PERFORM_ROTATEL
  525. #define PERFORM_ROTATEL(d, co, r1, r2, ci) \
  526.  ((d) = TRUNC_CNT(r2) == 0 ? (r1)                    \
  527.   : ((r1) << TRUNC_CNT(r2)) | ((r1) >> TRUNC_CNT(BITS_PER_WORD - (r2))),\
  528.   (co) = (ci))
  529. #endif
  530. #ifndef PERFORM_LSHIFTR_CO
  531. #define PERFORM_LSHIFTR_CO(d, co, r1, r2, ci) \
  532.   do { word __d = ((unsigned_word) (r1) >> TRUNC_CNT(r2));        \
  533.        (co) = ((unsigned_word) (r1) >> (TRUNC_CNT(r2) - 1)) & 1;    \
  534.        (d) = __d; } while (0)
  535. #endif
  536. #ifndef PERFORM_ASHIFTR_CO
  537. #define PERFORM_ASHIFTR_CO(d, co, r1, r2, ci) \
  538.   do { word __d = ((signed_word) (r1) >> TRUNC_CNT(r2));        \
  539.        (co) = ((signed_word) (r1) >> (TRUNC_CNT(r2) - 1)) & 1;        \
  540.        (d) = __d; } while (0)
  541. #endif
  542. #ifndef PERFORM_ASHIFTR_CON
  543. #define PERFORM_ASHIFTR_CON(d, co, r1, r2, ci) \
  544.   do { word __d = ((signed_word) (r1) >> TRUNC_CNT(r2));        \
  545.      (co) = (signed_word) (r1) < 0                    \
  546.        && ((r1) << TRUNC_CNT(BITS_PER_WORD - (r2))) != 0;        \
  547.        (d) = __d; } while (0)
  548. #endif
  549. #ifndef PERFORM_SHIFTL_CO
  550. #define PERFORM_SHIFTL_CO(d, co, r1, r2, ci) \
  551.   do { word __d = ((unsigned_word) (r1) << TRUNC_CNT(r2));        \
  552.        (co) = ((r1) >> TRUNC_CNT(BITS_PER_WORD - (r2))) & 1;        \
  553.        (d) = __d; } while (0)
  554. #endif
  555. /* Do these first two rotates actually set carry correctly for r2 == 0??? */
  556. #ifndef PERFORM_ROTATEL_CO
  557. #define PERFORM_ROTATEL_CO(d, co, r1, r2, ci) \
  558.   ((d) = (((r1) << TRUNC_CNT(r2))                    \
  559.       | ((unsigned_word) (r1) >> TRUNC_CNT(BITS_PER_WORD - (r2)))),    \
  560.    (co) = (d) & 1)
  561. #endif
  562. #ifndef PERFORM_ROTATER_CO
  563. #define PERFORM_ROTATER_CO(d, co, r1, r2, ci) \
  564.   ((d) = (((r1) >> TRUNC_CNT(r2))                    \
  565.       | ((unsigned_word) (r1) << TRUNC_CNT(BITS_PER_WORD - (r2)))),    \
  566.    (co) = ((d) >> (BITS_PER_WORD - 1)) & 1)
  567. #endif
  568. #ifndef PERFORM_ROTATEXL_CIO
  569. #define PERFORM_ROTATEXL_CIO(d, co, r1, r2, ci) \
  570.   do { word __d;  unsigned cnt = TRUNC_CNT(r2);                \
  571.        if (cnt != 0)                            \
  572.      {                                \
  573.        __d = ((r1) << cnt) | ((ci) << (cnt - 1));            \
  574.        if (cnt != 1)                        \
  575.          __d |= (unsigned_word) (r1) >> (BITS_PER_WORD - (cnt - 1));\
  576.        (co) = ((unsigned_word) (r1) >> (BITS_PER_WORD - cnt)) & 1;    \
  577.        (d) = __d;                            \
  578.      }                                \
  579.        else                                \
  580.      {                                \
  581.        (co) = (ci);                            \
  582.        (d) = (r1);                            \
  583.      }                                \
  584.      } while (0)
  585. #endif
  586. #ifndef PERFORM_ROTATEXR_CIO
  587. #define PERFORM_ROTATEXR_CIO(d, co, r1, r2, ci) \
  588.   do { word __d;  unsigned cnt = TRUNC_CNT(r2);                \
  589.        if (cnt != 0)                            \
  590.      {                                \
  591.        __d = ((unsigned_word) (r1) >> cnt) | ((ci) << (BITS_PER_WORD - cnt)); \
  592.        if (cnt != 1)                        \
  593.          __d |= ((r1) << (BITS_PER_WORD - (cnt - 1)));        \
  594.        (co) = ((unsigned_word) (r1) >> (cnt - 1)) & 1;        \
  595.        (d) = __d;                            \
  596.      }                                \
  597.        else                                \
  598.      {                                \
  599.        (co) = (ci);                            \
  600.        (d) = (r1);                            \
  601.      }                                \
  602.      } while (0)
  603. #endif
  604. #ifndef PERFORM_EXTS1
  605. #define PERFORM_EXTS1(d, co, r1, r2, ci) \
  606.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)) << 31 >> 31, (co) = (ci))
  607. #endif
  608. #ifndef PERFORM_EXTS2
  609. #define PERFORM_EXTS2(d, co, r1, r2, ci) \
  610.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)) << 30 >> 30, (co) = (ci))
  611. #endif
  612. #ifndef PERFORM_EXTS8
  613. #define PERFORM_EXTS8(d, co, r1, r2, ci) \
  614.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)) << 24 >> 24, (co) = (ci))
  615. #endif
  616. #ifndef PERFORM_EXTS16
  617. #define PERFORM_EXTS16(d, co, r1, r2, ci) \
  618.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)) << 16 >> 16, (co) = (ci))
  619. #endif
  620. #ifndef PERFORM_EXTU1
  621. #define PERFORM_EXTU1(d, co, r1, r2, ci) \
  622.   ((d) = ((unsigned_word) (r1) >> TRUNC_CNT(r2)) & 1, (co) = (ci))
  623. #endif
  624. #ifndef PERFORM_EXTU2
  625. #define PERFORM_EXTU2(d, co, r1, r2, ci) \
  626.   ((d) = ((unsigned_word) (r1) >> TRUNC_CNT(r2)) & 3, (co) = (ci))
  627. #endif
  628.  
  629. #ifndef PERFORM_DOZ
  630. #define PERFORM_DOZ(d, co, r1, r2, ci) \
  631.   (((d) = (signed_word) (r1) > (signed_word) (r2) ? (r1) - (r2) : 0),    \
  632.    (co) = (ci))
  633. #endif
  634.  
  635. #ifndef PERFORM_CPEQ
  636. #define PERFORM_CPEQ(d, co, r1, r2, ci) \
  637.   ((d) = ((r1) == (r2)) << 31, (co) = (ci))
  638. #endif
  639. #ifndef PERFORM_CPGE
  640. #define PERFORM_CPGE(d, co, r1, r2, ci) \
  641.   ((d) = ((signed_word) (r1) >= (signed_word) (r2)) << 31, (co) = (ci))
  642. #endif
  643. #ifndef PERFORM_CPGEU
  644. #define PERFORM_CPGEU(d, co, r1, r2, ci) \
  645.   ((d) = ((unsigned_word) (r1) >= (unsigned_word) (r2)) << 31, (co) = (ci))
  646. #endif
  647. #ifndef PERFORM_CPGT
  648. #define PERFORM_CPGT(d, co, r1, r2, ci) \
  649.   ((d) = ((signed_word) (r1) > (signed_word) (r2)) << 31, (co) = (ci))
  650. #endif
  651. #ifndef PERFORM_CPGTU
  652. #define PERFORM_CPGTU(d, co, r1, r2, ci) \
  653.   ((d) = ((unsigned_word) (r1) > (unsigned_word) (r2)) << 31, (co) = (ci))
  654. #endif
  655. #ifndef PERFORM_CPLE
  656. #define PERFORM_CPLE(d, co, r1, r2, ci) \
  657.   ((d) = ((signed_word) (r1) <= (signed_word) (r2)) << 31, (co) = (ci))
  658. #endif
  659. #ifndef PERFORM_CPLEU
  660. #define PERFORM_CPLEU(d, co, r1, r2, ci) \
  661.   ((d) = ((unsigned_word) (r1) <= (unsigned_word) (r2)) << 31, (co) = (ci))
  662. #endif
  663. #ifndef PERFORM_CPLT
  664. #define PERFORM_CPLT(d, co, r1, r2, ci) \
  665.   ((d) = ((signed_word) (r1) < (signed_word) (r2)) << 31, (co) = (ci))
  666. #endif
  667. #ifndef PERFORM_CPLTU
  668. #define PERFORM_CPLTU(d, co, r1, r2, ci) \
  669.   ((d) = ((unsigned_word) (r1) < (unsigned_word) (r2)) << 31, (co) = (ci))
  670. #endif
  671. #ifndef PERFORM_CPNEQ
  672. #define PERFORM_CPNEQ(d, co, r1, r2, ci) \
  673.   ((d) = ((r1) != (r2)) << 31, (co) = (ci))
  674. #endif
  675.  
  676. #ifndef PERFORM_CMPEQ
  677. #define PERFORM_CMPEQ(d, co, r1, r2, ci) \
  678.   ((d) = (r1) == (r2), (co) = (ci))
  679. #endif
  680. #ifndef PERFORM_CMPLE
  681. #define PERFORM_CMPLE(d, co, r1, r2, ci) \
  682.   ((d) = (signed_word) (r1) <= (signed_word) (r2), (co) = (ci))
  683. #endif
  684. #ifndef PERFORM_CMPLEU
  685. #define PERFORM_CMPLEU(d, co, r1, r2, ci) \
  686.   ((d) = (unsigned_word) (r1) <= (unsigned_word) (r2), (co) = (ci))
  687. #endif
  688. #ifndef PERFORM_CMPLT
  689. #define PERFORM_CMPLT(d, co, r1, r2, ci) \
  690.   ((d) = (signed_word) (r1) < (signed_word) (r2), (co) = (ci))
  691. #endif
  692. #ifndef PERFORM_CMPLTU
  693. #define PERFORM_CMPLTU(d, co, r1, r2, ci) \
  694.   ((d) = (unsigned_word) (r1) < (unsigned_word) (r2), (co) = (ci))
  695. #endif
  696.  
  697. #ifndef PERFORM_CYEQ
  698. #define PERFORM_CYEQ(d, co, r1, r2, ci) \
  699.   ((co) = (r1) == (r2))
  700. #endif
  701. #ifndef PERFORM_CYGES
  702. #define PERFORM_CYGES(d, co, r1, r2, ci) \
  703.   ((co) = (signed_word) (r1) >= (signed_word) (r2))
  704. #endif
  705. #ifndef PERFORM_CYGEU
  706. #define PERFORM_CYGEU(d, co, r1, r2, ci) \
  707.   ((co) = (unsigned_word) (r1) >= (unsigned_word) (r2))
  708. #endif
  709. #ifndef PERFORM_CYGTS
  710. #define PERFORM_CYGTS(d, co, r1, r2, ci) \
  711.   ((co) = (signed_word) (r1) > (signed_word) (r2))
  712. #endif
  713. #ifndef PERFORM_CYGTU
  714. #define PERFORM_CYGTU(d, co, r1, r2, ci) \
  715.   ((co) = (unsigned_word) (r1) > (unsigned_word) (r2))
  716. #endif
  717. #ifndef PERFORM_CYAND
  718. #define PERFORM_CYAND(d, co, r1, r2, ci) \
  719.   ((co) = ((r1) & (r2)) == 0)
  720. #endif
  721. #ifndef PERFORM_MERGE16
  722. #define PERFORM_MERGE16(d, co, r1, r2, ci) \
  723.   ((d) = ((word) (r1) >> 16) | ((r2) << 16), (co) = (ci))
  724. #endif
  725. #ifndef PERFORM_DECR_CYEQ
  726. #define PERFORM_DECR_CYEQ(d, co, r1, r2, ci) \
  727.   ((d) = ((r1) - 1), (co) = (r1) == (r2))   /* should protect from samevar(d,r1/r2) ??? */
  728. #endif
  729.  
  730. /* Unary operations.  */
  731. #ifndef PERFORM_CLZ
  732. #define PERFORM_CLZ(d, co, r1, ci) \
  733.   do {                                    \
  734.     int __a = 0;                            \
  735.     word __r = (r1);                            \
  736.     if (__r > 0xffffffff)                        \
  737.       __r = __r >> 31 >> 1, __a += 32;                    \
  738.     if (__r > 0xffff)                            \
  739.       __r >>= 16, __a += 16;                        \
  740.     if (__r > 0xff)                            \
  741.       __r >>= 8, __a += 8;                        \
  742.     (d) = clz_tab[__r] - __a + BITS_PER_WORD - 32;            \
  743.     (co) = (ci);                            \
  744.   } while (0)
  745. #endif
  746. #ifndef PERFORM_CTZ
  747. /* This can be done faster using the (x & -x) trick.  */
  748. #define PERFORM_CTZ(d, co, r1, ci) \
  749.   do {                                    \
  750.     int __a;                                \
  751.     abort ();                                \
  752.     __a = ((r1) & 0xffff == 0)                        \
  753.       ? (((r1) & 0xff0000) == 0 ? 24 : 16)                \
  754.       : ((r1) & 0xff == 0) ? 8 : 0;                    \
  755.     (d) = ctz_tab[((r1) >> __a) & 0xff] + __a;                \
  756.     (co) = (ci);                            \
  757.   } while (0)
  758. #endif
  759. #ifndef PERFORM_FF1
  760. #define PERFORM_FF1(d, co, r1, ci) \
  761.   do {                                    \
  762.     int __a;                                \
  763.     __a = (r1) <= 0xffff                        \
  764.       ? ((r1) <= 0xff ? 0 : 8)                        \
  765.       : ((r1) <= 0xffffff ?  16 : 24);                    \
  766.     (d) = ff1_tab[(r1) >> __a] + __a;                    \
  767.     (co) = (ci);                            \
  768.   } while (0)
  769. #endif
  770. #ifndef PERFORM_FF0
  771. #define PERFORM_FF0(d, co, r1, ci) \
  772.   PERFORM_FF1(d, co, ~(r1), ci)
  773. #endif
  774. #ifndef PERFORM_FFS
  775. #define PERFORM_FFS(d, co, r1, ci) \
  776.   do {                                    \
  777.     word __x = (r1) & (-r1);                        \
  778.     PERFORM_CLZ(d, co, __x, ci);                    \
  779.     (d) = BITS_PER_WORD - (d);                        \
  780.   } while (0)
  781. #endif
  782. #ifndef PERFORM_BSF86
  783. #define PERFORM_BSF86(d, co, r1, ci) \
  784.   do {                                                                  \
  785.     if ((r1) == 0)                            \
  786.       (d) = random_word ();                        \
  787.     else                                \
  788.       PERFORM_FF1(d, co, (r1) & -(r1), ci);                \
  789.     (co) = -1;                                \
  790.   } while (0)
  791. #endif
  792. #ifndef PERFORM_ABSVAL
  793. #define PERFORM_ABSVAL(d, co, r1, ci) \
  794.   ((d) = (signed_word) (r1) < 0 ? -(r1) : (r1), (co) = (ci))
  795. #endif
  796. #ifndef PERFORM_NABSVAL
  797. #define PERFORM_NABSVAL(d, co, r1, ci) \
  798.   ((d) = (signed_word) (r1) > 0 ? -(r1) : (r1), (co) = (ci))
  799. #endif
  800.  
  801. #ifndef PERFORM_CMOVEQ
  802. #define PERFORM_CMOVEQ(d, co, r1, r2, ci) \
  803.   ((d) = (r1) == 0 ? (r2) : (d), (co) = (ci))
  804. #endif
  805. #ifndef PERFORM_CMOVNE
  806. #define PERFORM_CMOVNE(d, co, r1, r2, ci) \
  807.   ((d) = (r1) != 0 ? (r2) : (d), (co) = (ci))
  808. #endif
  809. #ifndef PERFORM_CMOVLT
  810. #define PERFORM_CMOVLT(d, co, r1, r2, ci) \
  811.   ((d) = (signed_word) (r1) < 0 ? (r2) : (d), (co) = (ci))
  812. #endif
  813. #ifndef PERFORM_CMOVGE
  814. #define PERFORM_CMOVGE(d, co, r1, r2, ci) \
  815.   ((d) = (signed_word) (r1) >= 0 ? (r2) : (d), (co) = (ci))
  816. #endif
  817. #ifndef PERFORM_CMOVLE
  818. #define PERFORM_CMOVLE(d, co, r1, r2, ci) \
  819.   ((d) = (signed_word) (r1) <= 0 ? (r2) : (d), (co) = (ci))
  820. #endif
  821. #ifndef PERFORM_CMOVGT
  822. #define PERFORM_CMOVGT(d, co, r1, r2, ci) \
  823.   ((d) = (signed_word) (r1) > 0 ? (r2) : (d), (co) = (ci))
  824. #endif
  825.  
  826. #ifndef PERFORM_INVDIV
  827. #define PERFORM_INVDIV(v, co, r1, ci) \
  828.   do {                                    \
  829.     word __q, __r;                            \
  830.     udiv_qrnnd (__q, __r, -(r1), 0, (r1));                \
  831.     (v) = __q;                                \
  832.     (co) = (ci);                            \
  833.   } while (0)
  834. #endif
  835. #ifndef PERFORM_INVMOD
  836. #define PERFORM_INVMOD(v, co, r1, ci) \
  837.   do {                                    \
  838.     word __q, __r;                            \
  839.     udiv_qrnnd (__q, __r, -(r1), 0, (r1));                \
  840.     (v) = __r;                                \
  841.     (co) = (ci);                            \
  842.   } while (0)
  843. #endif
  844. #ifndef PERFORM_MUL
  845. #define PERFORM_MUL(v, co, r1, r2, ci) \
  846.   do {                                    \
  847.     (v) = (r1) * (r2);                            \
  848.     (co) = (ci);                            \
  849.   } while (0)
  850. #endif
  851. #ifndef PERFORM_UMULWIDEN_HI
  852. #define PERFORM_UMULWIDEN_HI(v, co, r1, r2, ci) \
  853.   do {                                    \
  854.     word __ph, __pl;                            \
  855.     umul_ppmm (__ph, __pl, (r1), (r2));                    \
  856.     (v) = __ph;                                \
  857.     (co) = (ci);                            \
  858.   } while (0)
  859. #endif
  860.  
  861. #ifdef UDIV_WITH_SDIV
  862. #define PERFORM_SDIV(v, co, r1, r2, ci) \
  863.   do {                                    \
  864.     if ((r2) != 0)                            \
  865.       (v) = (signed_word) (r1) / (signed_word) (r2);            \
  866.     else                                \
  867.       (v) = 0;                                \
  868.     (co) = (ci);                            \
  869.     } while (0)
  870. #endif /* UDIV_WITH_SDIV */
  871.  
  872. /* HP-PA nullifying instructions.  */
  873. #define PERFORM_NULLIFIED(v, co, sc, ci) \
  874.   ((v) = values[dr], (co) = (ci), (sc) = 0)
  875. #define PERFORM_COPY_S(d, co, sc, r1, ci) \
  876.   ((d) = (r1), (co) = (ci), (sc) = 1)
  877.  
  878. #define PERFORM_ADD_SEQ(d, co, sc, r1, r2, ci) \
  879.   ((d) = (r1) + (r2), (co) = (ci),                    \
  880.    sc = (r1) == -(r2))
  881. #define PERFORM_ADD_SNE(d, co, sc, r1, r2, ci) \
  882.   ((d) = (r1) + (r2), (co) = (ci),                    \
  883.    sc = (r1) != -(r2))
  884. #define PERFORM_ADD_SLTS(d, co, sc, r1, r2, ci) \
  885.   ((d) = (r1) + (r2), (co) = (ci),                    \
  886.    sc = (signed_word) (r1) < -(signed_word) (r2))
  887. #define PERFORM_ADD_SGES(d, co, sc, r1, r2, ci) \
  888.   ((d) = (r1) + (r2), (co) = (ci),                    \
  889.    sc = (signed_word) (r1) >= -(signed_word) (r2))
  890. #define PERFORM_ADD_SLES(d, co, sc, r1, r2, ci) \
  891.   ((d) = (r1) + (r2), (co) = (ci),                    \
  892.    sc = (signed_word) (r1) <= -(signed_word) (r2))
  893. #define PERFORM_ADD_SGTS(d, co, sc, r1, r2, ci) \
  894.   ((d) = (r1) + (r2), (co) = (ci),                    \
  895.    sc = (signed_word) (r1) > -(signed_word) (r2))
  896. #define PERFORM_ADD_SLTU(d, co, sc, r1, r2, ci) \
  897.   ((d) = (r1) + (r2), (co) = (ci),                    \
  898.    sc = (unsigned_word) (r1) < -(unsigned_word) (r2))
  899. #define PERFORM_ADD_SGEU(d, co, sc, r1, r2, ci) \
  900.   ((d) = (r1) + (r2), (co) = (ci),                    \
  901.    sc = (unsigned_word) (r1) >= -(unsigned_word) (r2))
  902. #define PERFORM_ADD_SLEU(d, co, sc, r1, r2, ci) \
  903.   ((d) = (r1) + (r2), (co) = (ci),                    \
  904.    sc = (unsigned_word) (r1) <= -(unsigned_word) (r2))
  905. #define PERFORM_ADD_SGTU(d, co, sc, r1, r2, ci) \
  906.   ((d) = (r1) + (r2), (co) = (ci),                    \
  907.    sc = (unsigned_word) (r1) > -(unsigned_word) (r2))
  908. #define PERFORM_ADD_SOVS(d, co, sc, r1, r2, ci) \
  909.   ((d) = (r1) + (r2), (co) = (ci),                    \
  910.    sc = (signed_word) (~((r1) ^ (r2)) & ((d) ^ (r1))) < 0)
  911. #define PERFORM_ADD_SNVS(d, co, sc, r1, r2, ci) \
  912.   ((d) = (r1) + (r2), (co) = (ci),                    \
  913.    sc = (signed_word) (~((r1) ^ (r2)) & ((d) ^ (r1))) >= 0)
  914. #define PERFORM_ADD_SODD(d, co, sc, r1, r2, ci) \
  915.   ((d) = (r1) + (r2), (co) = (ci),                    \
  916.    sc = ((d) & 1) != 0)
  917. #define PERFORM_ADD_SEVN(d, co, sc, r1, r2, ci) \
  918.   ((d) = (r1) + (r2), (co) = (ci),                    \
  919.    sc = ((d) & 1) == 0)
  920. #define PERFORM_ADD_S(d, co, sc, r1, r2, ci) \
  921.   ((d) = (r1) + (r2), (co) = (ci), (sc) = 1)
  922.  
  923. #define PERFORM_ADD_CIO_SEQ(d, co, sc, r1, r2, ci) \
  924.   do { word __d = (r1) + (r2);                        \
  925.        word __cy = __d < (r1);                        \
  926.        __d += (ci);                            \
  927.        __cy += (__d < (ci));                        \
  928.        (d) = __d;                            \
  929.        (co) = __cy;                            \
  930.        (sc) = __d == 0; } while (0)
  931. #define PERFORM_ADD_CIO_SNE(d, co, sc, r1, r2, ci) \
  932.   do { word __d = (r1) + (r2);                        \
  933.        word __cy = __d < (r1);                        \
  934.        __d += (ci);                            \
  935.        __cy += (__d < (ci));                        \
  936.        (d) = __d;                            \
  937.        (co) = __cy;                            \
  938.        (sc) = __d != 0; } while (0)
  939. #define PERFORM_ADD_CIO_SLTU(d, co, sc, r1, r2, ci) \
  940.   do { word __d = (r1) + (r2);                        \
  941.        word __cy = __d < (r1);                        \
  942.        __d += (ci);                            \
  943.        __cy += (__d < (ci));                        \
  944.        (d) = __d;                            \
  945.        (co) = __cy;                            \
  946.        (sc) = __cy == 0; } while (0)
  947. #define PERFORM_ADD_CIO_SGEU(d, co, sc, r1, r2, ci) \
  948.   do { word __d = (r1) + (r2);                        \
  949.        word __cy = __d < (r1);                        \
  950.        __d += (ci);                            \
  951.        __cy += (__d < (ci));                        \
  952.        (d) = __d;                            \
  953.        (co) = __cy;                            \
  954.        (sc) = __cy; } while (0)
  955. #define PERFORM_ADD_CIO_SLEU(d, co, sc, r1, r2, ci) \
  956.   do { word __d = (r1) + (r2);                        \
  957.        word __cy = __d < (r1);                        \
  958.        __d += (ci);                            \
  959.        __cy += (__d < (ci));                        \
  960.        (d) = __d;                            \
  961.        (co) = __cy;                            \
  962.        (sc) = __cy == 0 || __d == 0; } while (0)
  963. #define PERFORM_ADD_CIO_SGTU(d, co, sc, r1, r2, ci) \
  964.   do { word __d = (r1) + (r2);                        \
  965.        word __cy = __d < (r1);                        \
  966.        __d += (ci);                            \
  967.        __cy += (__d < (ci));                        \
  968.        (d) = __d;                            \
  969.        (co) = __cy;                            \
  970.        (sc) = __cy && __d != 0; } while (0)
  971. #define PERFORM_ADD_CIO_SODD(d, co, sc, r1, r2, ci) \
  972.   do { word __d = (r1) + (r2);                        \
  973.        word __cy = __d < (r1);                        \
  974.        __d += (ci);                            \
  975.        __cy += (__d < (ci));                        \
  976.        (d) = __d;                            \
  977.        (co) = __cy;                            \
  978.        (sc) = (__d & 1) != 0; } while (0)
  979. #define PERFORM_ADD_CIO_SEVN(d, co, sc, r1, r2, ci) \
  980.   do { word __d = (r1) + (r2);                        \
  981.        word __cy = __d < (r1);                        \
  982.        __d += (ci);                            \
  983.        __cy += (__d < (ci));                        \
  984.        (d) = __d;                            \
  985.        (co) = __cy;                            \
  986.        (sc) = (__d & 1) == 0; } while (0)
  987. #define PERFORM_ADD_CIO_S(d, co, sc, r1, r2, ci) \
  988.   do { word __d = (r1) + (r2);                        \
  989.        word __cy = __d < (r1);                        \
  990.        __d += (ci);                            \
  991.        __cy += (__d < (ci));                        \
  992.        (d) = __d;                            \
  993.        (co) = __cy;                            \
  994.        (sc) = 1; } while (0)
  995.  
  996. #define PERFORM_ADD_CO_SEQ(d, co, sc, r1, r2, ci) \
  997.   do { word __d = (r1) + (r2);                        \
  998.        word __cy = __d < (r1);                        \
  999.        (d) = __d;                            \
  1000.        (co) = __cy;                            \
  1001.        (sc) = __d == 0; } while (0)
  1002. #define PERFORM_ADD_CO_SNE(d, co, sc, r1, r2, ci) \
  1003.   do { word __d = (r1) + (r2);                        \
  1004.        word __cy = __d < (r1);                        \
  1005.        (d) = __d;                            \
  1006.        (co) = __cy;                            \
  1007.        (sc) = __d != 0; } while (0)
  1008. #define PERFORM_ADD_CO_SLTU(d, co, sc, r1, r2, ci) \
  1009.   do { word __d = (r1) + (r2);                        \
  1010.        word __cy = __d < (r1);                        \
  1011.        (d) = __d;                            \
  1012.        (co) = __cy;                            \
  1013.        (sc) = __cy == 0; } while (0)
  1014. #define PERFORM_ADD_CO_SGEU(d, co, sc, r1, r2, ci) \
  1015.   do { word __d = (r1) + (r2);                        \
  1016.        word __cy = __d < (r1);                        \
  1017.        (d) = __d;                            \
  1018.        (co) = __cy;                            \
  1019.        (sc) = __cy; } while (0)
  1020. #define PERFORM_ADD_CO_SLEU(d, co, sc, r1, r2, ci) \
  1021.   do { word __d = (r1) + (r2);                        \
  1022.        word __cy = __d < (r1);                        \
  1023.        (d) = __d;                            \
  1024.        (co) = __cy;                            \
  1025.        (sc) = __cy == 0 || __d == 0; } while (0)
  1026. #define PERFORM_ADD_CO_SGTU(d, co, sc, r1, r2, ci) \
  1027.   do { word __d = (r1) + (r2);                        \
  1028.        word __cy = __d < (r1);                        \
  1029.        (d) = __d;                            \
  1030.        (co) = __cy;                            \
  1031.        (sc) = __cy && __d != 0; } while (0)
  1032. #define PERFORM_ADD_CO_SODD(d, co, sc, r1, r2, ci) \
  1033.   do { word __d = (r1) + (r2);                        \
  1034.        word __cy = __d < (r1);                        \
  1035.        (d) = __d;                            \
  1036.        (co) = __cy;                            \
  1037.        (sc) = (__d & 1) != 0; } while (0)
  1038. #define PERFORM_ADD_CO_SEVN(d, co, sc, r1, r2, ci) \
  1039.   do { word __d = (r1) + (r2);                        \
  1040.        word __cy = __d < (r1);                        \
  1041.        (d) = __d;                            \
  1042.        (co) = __cy;                            \
  1043.        (sc) = (__d & 1) == 0; } while (0)
  1044. #define PERFORM_ADD_CO_S(d, co, sc, r1, r2, ci) \
  1045.   do { word __d = (r1) + (r2);                        \
  1046.        word __cy = __d < (r1);                        \
  1047.        (d) = __d;                            \
  1048.        (co) = __cy;                            \
  1049.        (sc) = 1; } while (0)
  1050.  
  1051. /* These are used with the hppa andc instruction to complement stuff.
  1052.    The conditions might be incorrect for any other usage.  */
  1053. #define PERFORM_SUB_SEQ(d, co, sc, r1, r2, ci) \
  1054.   ((d) = (r1) - (r2), (co) = (ci),                    \
  1055.    sc = (d) == 0)
  1056. #define PERFORM_SUB_SNE(d, co, sc, r1, r2, ci) \
  1057.   ((d) = (r1) - (r2), (co) = (ci),                    \
  1058.    sc = (d) != 0)
  1059. #define PERFORM_SUB_SLTS(d, co, sc, r1, r2, ci) \
  1060.   ((d) = (r1) - (r2), (co) = (ci),                    \
  1061.    sc = (signed_word) (d) < 0)
  1062. #define PERFORM_SUB_SGES(d, co, sc, r1, r2, ci) \
  1063.   ((d) = (r1) - (r2), (co) = (ci),                    \
  1064.    sc = (signed_word) (d) >= 0)
  1065. #define PERFORM_SUB_SLES(d, co, sc, r1, r2, ci) \
  1066.   ((d) = (r1) - (r2), (co) = (ci),                    \
  1067.    sc = (signed_word) (d) <= 0)
  1068. #define PERFORM_SUB_SGTS(d, co, sc, r1, r2, ci) \
  1069.   ((d) = (r1) - (r2), (co) = (ci),                    \
  1070.    sc = (signed_word) (d) > 0)
  1071. #define PERFORM_SUB_SODD(d, co, sc, r1, r2, ci) \
  1072.   ((d) = (r1) - (r2), (co) = (ci),                    \
  1073.    sc = ((d) & 1) != 0)
  1074. #define PERFORM_SUB_SEVN(d, co, sc, r1, r2, ci) \
  1075.   ((d) = (r1) - (r2), (co) = (ci),                    \
  1076.    sc = ((d) & 1) == 0)
  1077. #define PERFORM_SUB_S(d, co, sc, r1, r2, ci) \
  1078.   ((d) = (r1) - (r2), (co) = (ci), (sc) = 1)
  1079.  
  1080. #define PERFORM_ADC_CIO_SEQ(d, co, sc, r1, r2, ci) \
  1081.   do { word __d = (r1) + ~(r2);                        \
  1082.        word __cy = __d < (r1);                        \
  1083.        __d += (ci);                            \
  1084.        __cy += (__d < (ci));                        \
  1085.        (d) = __d;                            \
  1086.        (co) = __cy;                            \
  1087.        (sc) = __d == 0; } while (0)
  1088. #define PERFORM_ADC_CIO_SNE(d, co, sc, r1, r2, ci) \
  1089.   do { word __d = (r1) + ~(r2);                        \
  1090.        word __cy = __d < (r1);                        \
  1091.        __d += (ci);                            \
  1092.        __cy += (__d < (ci));                        \
  1093.        (d) = __d;                            \
  1094.        (co) = __cy;                            \
  1095.        (sc) = __d != 0; } while (0)
  1096. #define PERFORM_ADC_CIO_SLTU(d, co, sc, r1, r2, ci) \
  1097.   do { word __d = (r1) + ~(r2);                        \
  1098.        word __cy = __d < (r1);                        \
  1099.        __d += (ci);                            \
  1100.        __cy += (__d < (ci));                        \
  1101.        (d) = __d;                            \
  1102.        (co) = __cy;                            \
  1103.        (sc) = __cy == 0; } while (0)
  1104. #define PERFORM_ADC_CIO_SGEU(d, co, sc, r1, r2, ci) \
  1105.   do { word __d = (r1) + ~(r2);                        \
  1106.        word __cy = __d < (r1);                        \
  1107.        __d += (ci);                            \
  1108.        __cy += (__d < (ci));                        \
  1109.        (d) = __d;                            \
  1110.        (co) = __cy;                            \
  1111.        (sc) = __cy; } while (0)
  1112. #define PERFORM_ADC_CIO_SLEU(d, co, sc, r1, r2, ci) \
  1113.   do { word __d = (r1) + ~(r2);                        \
  1114.        word __cy = __d < (r1);                        \
  1115.        __d += (ci);                            \
  1116.        __cy += (__d < (ci));                        \
  1117.        (d) = __d;                            \
  1118.        (co) = __cy;                            \
  1119.        (sc) = __cy == 0 || __d == 0; } while (0)
  1120. #define PERFORM_ADC_CIO_SGTU(d, co, sc, r1, r2, ci) \
  1121.   do { word __d = (r1) + ~(r2);                        \
  1122.        word __cy = __d < (r1);                        \
  1123.        __d += (ci);                            \
  1124.        __cy += (__d < (ci));                        \
  1125.        (d) = __d;                            \
  1126.        (co) = __cy;                            \
  1127.        (sc) = __cy && __d != 0; } while (0)
  1128. #define PERFORM_ADC_CIO_SODD(d, co, sc, r1, r2, ci) \
  1129.   do { word __d = (r1) + ~(r2);                        \
  1130.        word __cy = __d < (r1);                        \
  1131.        __d += (ci);                            \
  1132.        __cy += (__d < (ci));                        \
  1133.        (d) = __d;                            \
  1134.        (co) = __cy;                            \
  1135.        (sc) = (__d & 1) != 0; } while (0)
  1136. #define PERFORM_ADC_CIO_SEVN(d, co, sc, r1, r2, ci) \
  1137.   do { word __d = (r1) + ~(r2);                        \
  1138.        word __cy = __d < (r1);                        \
  1139.        __d += (ci);                            \
  1140.        __cy += (__d < (ci));                        \
  1141.        (d) = __d;                            \
  1142.        (co) = __cy;                            \
  1143.        (sc) = (__d & 1) == 0; } while (0)
  1144. #define PERFORM_ADC_CIO_S(d, co, sc, r1, r2, ci) \
  1145.   do { word __d = (r1) + ~(r2);                        \
  1146.        word __cy = __d < (r1);                        \
  1147.        __d += (ci);                            \
  1148.        __cy += (__d < (ci));                        \
  1149.        (d) = __d;                            \
  1150.        (co) = __cy;                            \
  1151.        (sc) = 1; } while (0)
  1152.  
  1153. #define PERFORM_ADC_CO_SEQ(d, co, sc, r1, r2, ci) \
  1154.   do { word __d = (r1) + ~(r2) + 1;                    \
  1155.        word __cy = __d <= (r1);                        \
  1156.        (d) = __d;                            \
  1157.        (co) = __cy;                            \
  1158.        (sc) = __d == 0; } while (0)
  1159. #define PERFORM_ADC_CO_SNE(d, co, sc, r1, r2, ci) \
  1160.   do { word __d = (r1) + ~(r2) + 1;                    \
  1161.        word __cy = __d <= (r1);                        \
  1162.        (d) = __d;                            \
  1163.        (co) = __cy;                            \
  1164.        (sc) = __d != 0; } while (0)
  1165. #define PERFORM_ADC_CO_SLTU(d, co, sc, r1, r2, ci) \
  1166.   do { word __d = (r1) + ~(r2) + 1;                    \
  1167.        word __cy = __d <= (r1);                        \
  1168.        (d) = __d;                            \
  1169.        (co) = __cy;                            \
  1170.        (sc) = __cy == 0; } while (0)
  1171. #define PERFORM_ADC_CO_SGEU(d, co, sc, r1, r2, ci) \
  1172.   do { word __d = (r1) + ~(r2) + 1;                    \
  1173.        word __cy = __d <= (r1);                        \
  1174.        (d) = __d;                            \
  1175.        (co) = __cy;                            \
  1176.        (sc) = __cy; } while (0)
  1177. #define PERFORM_ADC_CO_SLEU(d, co, sc, r1, r2, ci) \
  1178.   do { word __d = (r1) + ~(r2) + 1;                    \
  1179.        word __cy = __d <= (r1);                        \
  1180.        (d) = __d;                            \
  1181.        (co) = __cy;                            \
  1182.        (sc) = __cy == 0 || __d == 0; } while (0)
  1183. #define PERFORM_ADC_CO_SGTU(d, co, sc, r1, r2, ci) \
  1184.   do { word __d = (r1) + ~(r2) + 1;                    \
  1185.        word __cy = __d <= (r1);                        \
  1186.        (d) = __d;                            \
  1187.        (co) = __cy;                            \
  1188.        (sc) = __cy && __d != 0; } while (0)
  1189. #define PERFORM_ADC_CO_SODD(d, co, sc, r1, r2, ci) \
  1190.   do { word __d = (r1) + ~(r2) + 1;                    \
  1191.        word __cy = __d <= (r1);                        \
  1192.        (d) = __d;                            \
  1193.        (co) = __cy;                            \
  1194.        (sc) = (__d & 1) != 0; } while (0)
  1195. #define PERFORM_ADC_CO_SEVN(d, co, sc, r1, r2, ci) \
  1196.   do { word __d = (r1) + ~(r2) + 1;                    \
  1197.        word __cy = __d <= (r1);                        \
  1198.        (d) = __d;                            \
  1199.        (co) = __cy;                            \
  1200.        (sc) = (__d & 1) == 0; } while (0)
  1201. #define PERFORM_ADC_CO_S(d, co, sc, r1, r2, ci) \
  1202.   do { word __d = (r1) + ~(r2) + 1;                    \
  1203.        word __cy = __d <= (r1);                        \
  1204.        (d) = __d;                            \
  1205.        (co) = __cy;                            \
  1206.        (sc) = 1; } while (0)
  1207.  
  1208. /* Compare two quantities and nullify on condition; Clear destination register.  */
  1209. #define PERFORM_COMCLR_SEQ(d, co, sc, r1, r2, ci) \
  1210.   ((sc) = (r1) == (r2), (d) = 0, (co) = (ci))
  1211. #define PERFORM_COMCLR_SNE(d, co, sc, r1, r2, ci) \
  1212.   ((sc) = (r1) != (r2), (d) = 0, (co) = (ci))
  1213. #define PERFORM_COMCLR_SLTS(d, co, sc, r1, r2, ci) \
  1214.   ((sc) = (signed_word) (r1) < (signed_word) (r2), (d) = 0, (co) = (ci))
  1215. #define PERFORM_COMCLR_SGES(d, co, sc, r1, r2, ci) \
  1216.   ((sc) = (signed_word) (r1) >= (signed_word) (r2), (d) = 0, (co) = (ci))
  1217. #define PERFORM_COMCLR_SLES(d, co, sc, r1, r2, ci) \
  1218.   ((sc) = (signed_word) (r1) <= (signed_word) (r2), (d) = 0, (co) = (ci))
  1219. #define PERFORM_COMCLR_SGTS(d, co, sc, r1, r2, ci) \
  1220.   ((sc) = (signed_word) (r1) > (signed_word) (r2), (d) = 0, (co) = (ci))
  1221. #define PERFORM_COMCLR_SLTU(d, co, sc, r1, r2, ci) \
  1222.   ((sc) = (unsigned_word) (r1) < (unsigned_word) (r2), (d) = 0, (co) = (ci))
  1223. #define PERFORM_COMCLR_SGEU(d, co, sc, r1, r2, ci) \
  1224.   ((sc) = (unsigned_word) (r1) >= (unsigned_word) (r2), (d) = 0, (co) = (ci))
  1225. #define PERFORM_COMCLR_SLEU(d, co, sc, r1, r2, ci) \
  1226.   ((sc) = (unsigned_word) (r1) <= (unsigned_word) (r2), (d) = 0, (co) = (ci))
  1227. #define PERFORM_COMCLR_SGTU(d, co, sc, r1, r2, ci) \
  1228.   ((sc) = (unsigned_word) (r1) > (unsigned_word) (r2), (d) = 0, (co) = (ci))
  1229. #define PERFORM_COMCLR_SODD(d, co, sc, r1, r2, ci) \
  1230.   ((sc) = (((r1) - (r2)) & 1) != 0, (d) = 0, (co) = (ci))
  1231. #define PERFORM_COMCLR_SEVN(d, co, sc, r1, r2, ci) \
  1232.   ((sc) = (((r1) - (r2)) & 1) == 0, (d) = 0, (co) = (ci))
  1233.  
  1234. /* Logic operations that don't affect carry.  */
  1235. #define PERFORM_AND_SEQ(d, co, sc, r1, r2, ci) \
  1236.   ((d) = (r1) & (r2), (co) = (ci), (sc) = (d) == 0)
  1237. #define PERFORM_AND_SNE(d, co, sc, r1, r2, ci) \
  1238.   ((d) = (r1) & (r2), (co) = (ci), (sc) = (d) != 0)
  1239. #define PERFORM_AND_SLTS(d, co, sc, r1, r2, ci) \
  1240.   ((d) = (r1) & (r2), (co) = (ci), (sc) = (signed_word) (d) < 0)
  1241. #define PERFORM_AND_SGES(d, co, sc, r1, r2, ci) \
  1242.   ((d) = (r1) & (r2), (co) = (ci), (sc) = (signed_word) (d) >= 0)
  1243. #define PERFORM_AND_SLES(d, co, sc, r1, r2, ci) \
  1244.   ((d) = (r1) & (r2), (co) = (ci), (sc) = (signed_word) (d) <= 0)
  1245. #define PERFORM_AND_SGTS(d, co, sc, r1, r2, ci) \
  1246.   ((d) = (r1) & (r2), (co) = (ci), (sc) = (signed_word) (d) == 0)
  1247. #define PERFORM_AND_SODD(d, co, sc, r1, r2, ci) \
  1248.   ((d) = (r1) & (r2), (co) = (ci), (sc) = ((d) & 1) != 0)
  1249. #define PERFORM_AND_SEVN(d, co, sc, r1, r2, ci) \
  1250.   ((d) = (r1) & (r2), (co) = (ci), (sc) = ((d) & 1) == 0)
  1251. #define PERFORM_AND_S(d, co, sc, r1, r2, ci) \
  1252.   ((d) = (r1) & (r2), (co) = (ci), (sc) = 1)
  1253. #define PERFORM_IOR_SEQ(d, co, sc, r1, r2, ci) \
  1254.   ((d) = (r1) | (r2), (co) = (ci), (sc) = (d) == 0)
  1255. #define PERFORM_IOR_SNE(d, co, sc, r1, r2, ci) \
  1256.   ((d) = (r1) | (r2), (co) = (ci), (sc) = (d) != 0)
  1257. #define PERFORM_IOR_SLTS(d, co, sc, r1, r2, ci) \
  1258.   ((d) = (r1) | (r2), (co) = (ci), (sc) = (signed_word) (d) < 0)
  1259. #define PERFORM_IOR_SGES(d, co, sc, r1, r2, ci) \
  1260.   ((d) = (r1) | (r2), (co) = (ci), (sc) = (signed_word) (d) >= 0)
  1261. #define PERFORM_IOR_SLES(d, co, sc, r1, r2, ci) \
  1262.   ((d) = (r1) | (r2), (co) = (ci), (sc) = (signed_word) (d) <= 0)
  1263. #define PERFORM_IOR_SGTS(d, co, sc, r1, r2, ci) \
  1264.   ((d) = (r1) | (r2), (co) = (ci), (sc) = (signed_word) (d) == 0)
  1265. #define PERFORM_IOR_SODD(d, co, sc, r1, r2, ci) \
  1266.   ((d) = (r1) | (r2), (co) = (ci), (sc) = ((d) & 1) != 0)
  1267. #define PERFORM_IOR_SEVN(d, co, sc, r1, r2, ci) \
  1268.   ((d) = (r1) | (r2), (co) = (ci), (sc) = ((d) & 1) == 0)
  1269. #define PERFORM_IOR_S(d, co, sc, r1, r2, ci) \
  1270.   ((d) = (r1) | (r2), (co) = (ci), (sc) = 1)
  1271.  
  1272. #define PERFORM_XOR_SEQ(d, co, sc, r1, r2, ci) \
  1273.   ((d) = (r1) ^ (r2), (co) = (ci), (sc) = (d) == 0)
  1274. #define PERFORM_XOR_SNE(d, co, sc, r1, r2, ci) \
  1275.   ((d) = (r1) ^ (r2), (co) = (ci), (sc) = (d) != 0)
  1276. #define PERFORM_XOR_SLTS(d, co, sc, r1, r2, ci) \
  1277.   ((d) = (r1) ^ (r2), (co) = (ci), (sc) = (signed_word) (d) < 0)
  1278. #define PERFORM_XOR_SGES(d, co, sc, r1, r2, ci) \
  1279.   ((d) = (r1) ^ (r2), (co) = (ci), (sc) = (signed_word) (d) >= 0)
  1280. #define PERFORM_XOR_SLES(d, co, sc, r1, r2, ci) \
  1281.   ((d) = (r1) ^ (r2), (co) = (ci), (sc) = (signed_word) (d) <= 0)
  1282. #define PERFORM_XOR_SGTS(d, co, sc, r1, r2, ci) \
  1283.   ((d) = (r1) ^ (r2), (co) = (ci), (sc) = (signed_word) (d) > 0)
  1284. #define PERFORM_XOR_SODD(d, co, sc, r1, r2, ci) \
  1285.   ((d) = (r1) ^ (r2), (co) = (ci), (sc) = ((d) & 1) != 0)
  1286. #define PERFORM_XOR_SEVN(d, co, sc, r1, r2, ci) \
  1287.   ((d) = (r1) ^ (r2), (co) = (ci), (sc) = ((d) & 1) == 0)
  1288. #define PERFORM_XOR_S(d, co, sc, r1, r2, ci) \
  1289.   ((d) = (r1) ^ (r2), (co) = (ci), (sc) = 1)
  1290.  
  1291. #define PERFORM_ANDC_SEQ(d, co, sc, r1, r2, ci) \
  1292.   ((d) = (r1) & ~(r2), (co) = (ci), (sc) = (d) == 0)
  1293. #define PERFORM_ANDC_SNE(d, co, sc, r1, r2, ci) \
  1294.   ((d) = (r1) & ~(r2), (co) = (ci), (sc) = (d) != 0)
  1295. #define PERFORM_ANDC_SLTS(d, co, sc, r1, r2, ci) \
  1296.   ((d) = (r1) & ~(r2), (co) = (ci), (sc) = (signed_word) (d) < 0)
  1297. #define PERFORM_ANDC_SGES(d, co, sc, r1, r2, ci) \
  1298.   ((d) = (r1) & ~(r2), (co) = (ci), (sc) = (signed_word) (d) >= 0)
  1299. #define PERFORM_ANDC_SLES(d, co, sc, r1, r2, ci) \
  1300.   ((d) = (r1) & ~(r2), (co) = (ci), (sc) = (signed_word) (d) <= 0)
  1301. #define PERFORM_ANDC_SGTS(d, co, sc, r1, r2, ci) \
  1302.   ((d) = (r1) & ~(r2), (co) = (ci), (sc) = (signed_word) (d) == 0)
  1303. #define PERFORM_ANDC_SODD(d, co, sc, r1, r2, ci) \
  1304.   ((d) = (r1) & ~(r2), (co) = (ci), (sc) = ((d) & 1) != 0)
  1305. #define PERFORM_ANDC_SEVN(d, co, sc, r1, r2, ci) \
  1306.   ((d) = (r1) & ~(r2), (co) = (ci), (sc) = ((d) & 1) == 0)
  1307. #define PERFORM_ANDC_S(d, co, sc, r1, r2, ci) \
  1308.   ((d) = (r1) & ~(r2), (co) = (ci), (sc) = 1)
  1309.  
  1310. #define PERFORM_LSHIFTR_S(d, co, sc, r1, r2, ci) \
  1311.   ((d) = ((unsigned_word) (r1) >> TRUNC_CNT(r2)), (co) = (ci), (sc) = 1)
  1312. #define PERFORM_ASHIFTR_S(d, co, sc, r1, r2, ci) \
  1313.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)), (co) = (ci), (sc) = 1)
  1314. #define PERFORM_SHIFTL_S(d, co, sc, r1, r2, ci) \
  1315.   ((d) = ((unsigned_word) (r1) << TRUNC_CNT(r2)), (co) = (ci), (sc) = 1)
  1316. #define PERFORM_ROTATEL_S(d, co, sc, r1, r2, ci) \
  1317.  ((d) = TRUNC_CNT(r2) == 0 ? (r1)                    \
  1318.   : ((r1) << TRUNC_CNT(r2)) | ((r1) >> TRUNC_CNT(BITS_PER_WORD - (r2))),\
  1319.   (co) = (ci), (sc) = 1)
  1320. #define PERFORM_EXTS1_S(d, co, sc, r1, r2, ci) \
  1321.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)) << 31 >> 31, (co) = (ci), (sc) = 1)
  1322. #define PERFORM_EXTS2_S(d, co, sc, r1, r2, ci) \
  1323.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)) << 30 >> 30, (co) = (ci), (sc) = 1)
  1324. #define PERFORM_EXTS8_S(d, co, sc, r1, r2, ci) \
  1325.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)) << 24 >> 24, (co) = (ci), (sc) = 1)
  1326. #define PERFORM_EXTS16_S(d, co, sc, r1, r2, ci) \
  1327.   ((d) = ((signed_word) (r1) >> TRUNC_CNT(r2)) << 16 >> 16, (co) = (ci), (sc) = 1)
  1328. #define PERFORM_EXTU1_S(d, co, sc, r1, r2, ci) \
  1329.   ((d) = ((unsigned_word) (r1) >> TRUNC_CNT(r2)) & 1, (co) = (ci), (sc) = 1)
  1330. #define PERFORM_EXTU2_S(d, co, sc, r1, r2, ci) \
  1331.   ((d) = ((unsigned_word) (r1) >> TRUNC_CNT(r2)) & 3, (co) = (ci), (sc) = 1)
  1332.  
  1333. #define IB0(x) x
  1334. #define IB1(x) ((x) << 1)
  1335. #define IB2(x) ((x) << 2)
  1336. #define EB0(x) ((x) & 1)
  1337. #define EB1(x) (((x) >> 1) & 1)
  1338. #define EB2(x) (((x) >> 2) & 1)
  1339.  
  1340. #define PERFORM_ADDC_960(d, co, r1, r2, ci) \
  1341.   do { word __d = (r1) + EB1(ci);                    \
  1342.        word __cy = __d < (r1);                        \
  1343.        (d) = __d + (r2);                        \
  1344.        (co) = (IB1(((d) < __d) + __cy)                    \
  1345.            | IB0((signed_word) (~((r1) ^ (r2)) & ((d) ^ (r1))) < 0));\
  1346.   } while (0)
  1347. #define PERFORM_SUBC_960(d, co, r1, r2, ci) \
  1348.   do { word __d = (r1) + EB1(ci);                    \
  1349.        word __cy = __d < (r1);                        \
  1350.        (d) = __d + ~(r2);                        \
  1351.        (co) = (IB1(((d) < __d) + __cy)                    \
  1352.            | IB0((signed_word) (~((r1) ^ ~(r2)) & ((d) ^ (r1))) < 0));\
  1353.   } while (0)
  1354. #define PERFORM_SEL_NO_960(d, co, r1, r2, ci) \
  1355.   ((d) = (ci) == 0 ? (r2) : (r1), (co) = (ci))
  1356. #define PERFORM_SEL_G_960(d, co, r1, r2, ci) \
  1357.   ((d) = ((ci) & 1) != 0 ? (r2) : (r1), (co) = (ci))
  1358. #define PERFORM_SEL_E_960(d, co, r1, r2, ci) \
  1359.   ((d) = ((ci) & 2) != 0 ? (r2) : (r1), (co) = (ci))
  1360. #define PERFORM_SEL_GE_960(d, co, r1, r2, ci) \
  1361.   ((d) = ((ci) & 3) != 0 ? (r2) : (r1), (co) = (ci))
  1362. #define PERFORM_SEL_L_960(d, co, r1, r2, ci) \
  1363.   ((d) = ((ci) & 4) != 0 ? (r2) : (r1), (co) = (ci))
  1364. #define PERFORM_SEL_NE_960(d, co, r1, r2, ci) \
  1365.   ((d) = ((ci) & 5) != 0 ? (r2) : (r1), (co) = (ci))
  1366. #define PERFORM_SEL_LE_960(d, co, r1, r2, ci) \
  1367.   ((d) = ((ci) & 6) != 0 ? (r2) : (r1), (co) = (ci))
  1368. #define PERFORM_SEL_O_960(d, co, r1, r2, ci) \
  1369.   ((d) = ((ci) & 7) != 0 ? (r2) : (r1), (co) = (ci))
  1370. #define PERFORM_CONCMPO_960(d, co, r1, r2, ci) \
  1371.   ((co) = EB2(ci) == 0                            \
  1372.    ? ((unsigned_word) (r1) <= (unsigned_word) (r2)) + 1 : (ci))
  1373. #define PERFORM_CONCMPI_960(d, co, r1, r2, ci) \
  1374.   ((co) = EB2(ci) == 0                            \
  1375.    ? ((signed_word) (r1) <= (signed_word) (r2)) + 1 : (ci))
  1376. #define PERFORM_CMPO_960(d, co, r1, r2, ci) \
  1377.   ((co) = (IB0((unsigned_word) (r1) > (unsigned_word) (r2))        \
  1378.        | IB1((r1) == (r2))                        \
  1379.        | IB2((unsigned_word) (r1) < (unsigned_word) (r2))))
  1380. #define PERFORM_CMPI_960(d, co, r1, r2, ci) \
  1381.   ((co) = (IB0((signed_word) (r1) > (signed_word) (r2))            \
  1382.        | IB1((r1) == (r2))                        \
  1383.        | IB2((signed_word) (r1) < (signed_word) (r2))))
  1384. #define PERFORM_SHIFTL_NT(d, co, r1, r2, ci) \
  1385.   ((d) = ((r2) < BITS_PER_WORD ? ((unsigned_word) (r1) << (r2)) : 0), (co) = (ci))
  1386. #define PERFORM_LSHIFTR_NT(d, co, r1, r2, ci) \
  1387.   ((d) = ((r2) < BITS_PER_WORD ? ((unsigned_word) (r1) >> (r2)) : 0), (co) = (ci))
  1388. #define PERFORM_ASHIFTR_NT(d, co, r1, r2, ci) \
  1389.   ((d) = ((r2) < BITS_PER_WORD                        \
  1390.       ? ((signed_word) (r1) >> (r2))                \
  1391.       : -(signed_word) (r1) < 0), (co) = (ci))
  1392. #define PERFORM_ADDO_NO_960(d, co, r1, r2, ci) \
  1393.   ((d) = (ci) == 0 ? (r1) + (r2) : (d), (co) = (ci))
  1394. #define PERFORM_ADDO_G_960(d, co, r1, r2, ci) \
  1395.   ((d) = ((ci) & 1) != 0 ? (r1) + (r2) : (d), (co) = (ci))
  1396. #define PERFORM_ADDO_E_960(d, co, r1, r2, ci) \
  1397.   ((d) = ((ci) & 2) != 0 ? (r1) + (r2) : (d), (co) = (ci))
  1398. #define PERFORM_ADDO_GE_960(d, co, r1, r2, ci) \
  1399.   ((d) = ((ci) & 3) != 0 ? (r1) + (r2) : (d), (co) = (ci))
  1400. #define PERFORM_ADDO_L_960(d, co, r1, r2, ci) \
  1401.   ((d) = ((ci) & 4) != 0 ? (r1) + (r2) : (d), (co) = (ci))
  1402. #define PERFORM_ADDO_NE_960(d, co, r1, r2, ci) \
  1403.   ((d) = ((ci) & 5) != 0 ? (r1) + (r2) : (d), (co) = (ci))
  1404. #define PERFORM_ADDO_LE_960(d, co, r1, r2, ci) \
  1405.   ((d) = ((ci) & 6) != 0 ? (r1) + (r2) : (d), (co) = (ci))
  1406. #define PERFORM_ADDO_O_960(d, co, r1, r2, ci) \
  1407.   ((d) = ((ci) & 7) != 0 ? (r1) + (r2) : (d), (co) = (ci))
  1408.  
  1409. #define PERFORM_SUBO_NO_960(d, co, r1, r2, ci) \
  1410.   ((d) = (ci) == 0 ? (r1) - (r2) : (d), (co) = (ci))
  1411. #define PERFORM_SUBO_G_960(d, co, r1, r2, ci) \
  1412.   ((d) = ((ci) & 1) != 0 ? (r1) - (r2) : (d), (co) = (ci))
  1413. #define PERFORM_SUBO_E_960(d, co, r1, r2, ci) \
  1414.   ((d) = ((ci) & 2) != 0 ? (r1) - (r2) : (d), (co) = (ci))
  1415. #define PERFORM_SUBO_GE_960(d, co, r1, r2, ci) \
  1416.   ((d) = ((ci) & 3) != 0 ? (r1) - (r2) : (d), (co) = (ci))
  1417. #define PERFORM_SUBO_L_960(d, co, r1, r2, ci) \
  1418.   ((d) = ((ci) & 4) != 0 ? (r1) - (r2) : (d), (co) = (ci))
  1419. #define PERFORM_SUBO_NE_960(d, co, r1, r2, ci) \
  1420.   ((d) = ((ci) & 5) != 0 ? (r1) - (r2) : (d), (co) = (ci))
  1421. #define PERFORM_SUBO_LE_960(d, co, r1, r2, ci) \
  1422.   ((d) = ((ci) & 6) != 0 ? (r1) - (r2) : (d), (co) = (ci))
  1423. #define PERFORM_SUBO_O_960(d, co, r1, r2, ci) \
  1424.   ((d) = ((ci) & 7) != 0 ? (r1) - (r2) : (d), (co) = (ci))
  1425.  
  1426. #define PERFORM_ALTERBIT(d, co, r1, r2, ci) \
  1427.   ((d) = (EB1(ci) ? (r1) | ((word) 1 << TRUNC_CNT(r2))            \
  1428.           : (r1) & ~((word) 1 << TRUNC_CNT(r2))),        \
  1429.    (co) = (ci))
  1430. #define PERFORM_SETBIT(d, co, r1, r2, ci) \
  1431.   ((d) = (r1) | ((word) 1 << TRUNC_CNT(r2)), (co) = (ci))
  1432. #define PERFORM_CLRBIT(d, co, r1, r2, ci) \
  1433.   ((d) = (r1) & ~((word) 1 << TRUNC_CNT(r2)), (co) = (ci))
  1434. #define PERFORM_CHKBIT(d, co, r1, r2, ci) \
  1435.   ((co) = IB1(((r1) >> TRUNC_CNT(r2)) & 1))
  1436. #define PERFORM_NOTBIT(d, co, r1, r2, ci) \
  1437.   ((d) = (r1) ^ ((word) 1 << TRUNC_CNT(r2)), (co) = (ci))
  1438.  
  1439. enum goal_func
  1440. {
  1441. #undef    DEF_GOAL
  1442. #define DEF_GOAL(SYM,ARITY,NAME,CODE) SYM,
  1443. #undef    DEF_SYNONYM
  1444. #define DEF_SYNONYM(SYM,NAME)
  1445. #include "goal.def"
  1446.   LAST_AND_UNUSED_GOAL_CODE
  1447. };
  1448.  
  1449. enum prune_flags
  1450. {
  1451.   NO_PRUNE = 0,
  1452.   CY_0 = 1,
  1453.   CY_1 = 2,
  1454.   CY_JUST_SET = 4,
  1455.   NULLIFYING_INSN = 8,
  1456. };
  1457.  
  1458. #if HAS_NULLIFICATION
  1459. void synth(insn_t *, int, word *, int, word, int, int, int, int);
  1460. void synth_last(insn_t *, int, word *, int, word, int, int, int, int);
  1461. void synth_nonskip(insn_t *, int, word *, int, word, int, int, int, int);
  1462. void synth_nonskip_last(insn_t *, int, word *, int, word, int, int, int, int);
  1463. void synth_condskip(insn_t *, int, word *, int, word, int, int, int, int);
  1464. void synth_skip(insn_t *, int, word *, int, word, int, int, int, int);
  1465. #else
  1466. void synth(insn_t *, int, word *, int, word, int, int, int);
  1467. void synth_last(insn_t *, int, word *, int, word, int, int, int);
  1468. #endif
  1469.  
  1470. void
  1471. test_sequence(insn_t *sequence, int n_insns);
  1472. int
  1473. #if HAS_NULLIFICATION
  1474. run_program(insn_t *sequence, int n_insns, word *regs, int arity);
  1475. #else
  1476. run_program(insn_t *sequence, int n_insns, word *regs);
  1477. #endif
  1478.  
  1479. extern const char clz_tab[];
  1480. extern const char ctz_tab[];
  1481. extern const char ff1_tab[];
  1482.