home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / superopt-2.5-src.tgz / tar.out / fsf / superopt / run_program.def < prev    next >
Text File  |  1996-09-28  |  21KB  |  695 lines
  1. /* Superoptimizer -- execute a instruction sequence to in order to
  2.    test it's correctness.
  3.  
  4.    Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
  5.  
  6.    This program is free software; you can redistribute it and/or modify it
  7.    under the terms of the GNU General Public License as published by the
  8.    Free Software Foundation; either version 2, or (at your option) any
  9.    later version.
  10.  
  11.    This program is distributed in the hope that it will be useful, but
  12.    WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.    General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU General Public License along
  17.    with this program; see the file COPYING.  If not, write to the Free
  18.    Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. int
  21. #if HAS_NULLIFICATION
  22. run_program(insn_t *sequence, int n_insns, word *regs, int arity)
  23. #else
  24. run_program(insn_t *sequence, int n_insns, word *regs)
  25. #endif
  26. {
  27.   int pc;
  28.   insn_t insn;
  29.   word v, r1, r2;
  30.   int co, ci = -1;            /* Combine co and ci into cy?  */
  31. #if HAS_NULLIFICATION
  32.   int nullify_flag = 0;
  33.   char reg_defined[0x100];
  34.   int i;
  35. #endif
  36.  
  37.   if (n_insns == 0)
  38.     return ci;
  39.  
  40. #if HAS_NULLIFICATION
  41.   memset (reg_defined, 0, 0x100);
  42.  
  43.   for (i = 0; i < arity; i++)
  44.     reg_defined[i] = 1;
  45.   /* The immediate values should be considered `defined'.  */
  46.   for (i = -1; i < BITS_PER_WORD; i++)
  47.     reg_defined[0x20 + i] = 1;
  48.   reg_defined[0x20 - 2] = 1;
  49.   reg_defined[0x20 - 3] = 1;
  50.   reg_defined[0x20 - 4] = 1;
  51.   reg_defined[0x20 - 5] = 1;
  52. #endif
  53.  
  54.   for (pc = 0; pc < n_insns; pc++)
  55.     {
  56.       insn = sequence[pc];
  57.  
  58. #if HAS_NULLIFICATION
  59.       if (nullify_flag)
  60.     {
  61.       nullify_flag = 0;
  62.       continue;
  63.     }
  64.  
  65.       /* Check if the source operands has become defined.  */
  66.       if (!reg_defined[insn.s1] || !reg_defined[insn.s2])
  67.     return -2;
  68. #endif
  69.  
  70.       r1 = regs[insn.s1];
  71.       r2 = regs[insn.s2];
  72.  
  73.       switch (insn.opcode)
  74.     {
  75.     default:
  76.       fprintf(stderr,
  77.           "internal error: undefined instruction generated\n");
  78.       abort();
  79.  
  80.     case COPY:    PERFORM_COPY(v, co, r1, ci); break;
  81.     case EXCHANGE:
  82.       regs[insn.s1] = r2;
  83.       regs[insn.s2] = r1;
  84.       continue;
  85.  
  86.     case ADD:    PERFORM_ADD(v, co, r1, r2, ci); break;
  87.     case ADD_CI:    PERFORM_ADD_CI(v, co, r1, r2, ci); break;
  88.     case ADD_CO:    PERFORM_ADD_CO(v, co, r1, r2, ci); break;
  89.     case ADD_CIO:    PERFORM_ADD_CIO(v, co, r1, r2, ci); break;
  90.  
  91.     case SUB:    PERFORM_SUB(v, co, r1, r2, ci); break;
  92.     case SUB_CI:    PERFORM_SUB_CI(v, co, r1, r2, ci); break;
  93.     case SUB_CO:    PERFORM_SUB_CO(v, co, r1, r2, ci); break;
  94.     case SUB_CIO:    PERFORM_SUB_CIO(v, co, r1, r2, ci); break;
  95.  
  96.     case ADC_CI:    PERFORM_ADC_CI(v, co, r1, r2, ci); break;
  97.     case ADC_CO:    PERFORM_ADC_CO(v, co, r1, r2, ci); break;
  98.     case ADC_CIO:    PERFORM_ADC_CIO(v, co, r1, r2, ci); break;
  99.  
  100.     case ADDCMPL:    PERFORM_ADDCMPL(v, co, r1, r2, ci); break;
  101.  
  102.     case CMP:    PERFORM_CMP(v, co, r1, r2, ci); break;
  103.     case CMPPAR:    PERFORM_CMPPAR(v, co, r1, r2, ci); break;
  104.  
  105.     case AND:    PERFORM_AND(v, co, r1, r2, ci); break;
  106.     case IOR:    PERFORM_IOR(v, co, r1, r2, ci); break;
  107.     case XOR:    PERFORM_XOR(v, co, r1, r2, ci); break;
  108.     case ANDC:    PERFORM_ANDC(v, co, r1, r2, ci); break;
  109.     case IORC:    PERFORM_IORC(v, co, r1, r2, ci); break;
  110.     case EQV:    PERFORM_EQV(v, co, r1, r2, ci); break;
  111.     case NAND:    PERFORM_NAND(v, co, r1, r2, ci); break;
  112.     case NOR:    PERFORM_NOR(v, co, r1, r2, ci); break;
  113.  
  114.     case AND_RC:    PERFORM_AND_RC(v, co, r1, r2, ci); break;
  115.     case IOR_RC:    PERFORM_IOR_RC(v, co, r1, r2, ci); break;
  116.     case XOR_RC:    PERFORM_XOR_RC(v, co, r1, r2, ci); break;
  117.     case ANDC_RC:    PERFORM_ANDC_RC(v, co, r1, r2, ci); break;
  118.     case IORC_RC:    PERFORM_IORC_RC(v, co, r1, r2, ci); break;
  119.     case EQV_RC:    PERFORM_EQV_RC(v, co, r1, r2, ci); break;
  120.     case NAND_RC:    PERFORM_NAND_RC(v, co, r1, r2, ci); break;
  121.     case NOR_RC:    PERFORM_NOR_RC(v, co, r1, r2, ci); break;
  122.  
  123.     case AND_CC:    PERFORM_AND_CC(v, co, r1, r2, ci); break;
  124.     case IOR_CC:    PERFORM_IOR_CC(v, co, r1, r2, ci); break;
  125.     case XOR_CC:    PERFORM_XOR_CC(v, co, r1, r2, ci); break;
  126.     case ANDC_CC:    PERFORM_ANDC_CC(v, co, r1, r2, ci); break;
  127.     case IORC_CC:    PERFORM_IORC_CC(v, co, r1, r2, ci); break;
  128.     case EQV_CC:    PERFORM_EQV_CC(v, co, r1, r2, ci); break;
  129.     case NAND_CC:    PERFORM_NAND_CC(v, co, r1, r2, ci); break;
  130.     case NOR_CC:    PERFORM_NOR_CC(v, co, r1, r2, ci); break;
  131.  
  132.     case LSHIFTR:    PERFORM_LSHIFTR(v, co, r1, r2, ci); break;
  133.     case ASHIFTR:    PERFORM_ASHIFTR(v, co, r1, r2, ci); break;
  134.     case SHIFTL:    PERFORM_SHIFTL(v, co, r1, r2, ci); break;
  135.     case ROTATEL:    PERFORM_ROTATEL(v, co, r1, r2, ci); break;
  136.     case LSHIFTR_CO:PERFORM_LSHIFTR_CO(v, co, r1, r2, ci); break;
  137.     case ASHIFTR_CO:PERFORM_ASHIFTR_CO(v, co, r1, r2, ci); break;
  138.     case SHIFTL_CO:    PERFORM_SHIFTL_CO(v, co, r1, r2, ci); break;
  139.     case ROTATEL_CO:PERFORM_ROTATEL_CO(v, co, r1, r2, ci); break;
  140.     case ROTATER_CO:PERFORM_ROTATER_CO(v, co, r1, r2, ci); break;
  141.     case ROTATEXL_CIO:PERFORM_ROTATEXL_CIO(v, co, r1, r2, ci); break;
  142.     case ROTATEXR_CIO:PERFORM_ROTATEXR_CIO(v, co, r1, r2, ci); break;
  143.     case ASHIFTR_CON:PERFORM_ASHIFTR_CON(v, co, r1, r2, ci); break;
  144.  
  145.     case EXTS1:    PERFORM_EXTS1(v, co, r1, r2, ci); break;
  146.     case EXTS2:    PERFORM_EXTS2(v, co, r1, r2, ci); break;
  147.     case EXTS8:    PERFORM_EXTS8(v, co, r1, r2, ci); break;
  148.     case EXTS16:    PERFORM_EXTS16(v, co, r1, r2, ci); break;
  149.     case EXTU1:    PERFORM_EXTU1(v, co, r1, r2, ci); break;
  150.     case EXTU2:    PERFORM_EXTU2(v, co, r1, r2, ci); break;
  151.  
  152.     case CLZ:    PERFORM_CLZ(v, co, r1, ci); break;
  153.     case CTZ:    PERFORM_CTZ(v, co, r1, ci); break;
  154.     case FF1:    PERFORM_FF1(v, co, r1, ci); break;
  155.     case FF0:    PERFORM_FF0(v, co, r1, ci); break;
  156.     case BSF86:    PERFORM_BSF86(v, co, r1, ci); break;
  157.  
  158.     case ABSVAL:    PERFORM_ABSVAL(v, co, r1, ci); break;
  159.     case NABSVAL:    PERFORM_NABSVAL(v, co, r1, ci); break;
  160.  
  161.     case DOZ:    PERFORM_DOZ(v, co, r1, r2, ci); break;
  162.     case SETCY:    co = 1; break;
  163.     case CLRCY:    co = 0; break;
  164.     case COMCY:    co = ci ^ 1; break;
  165.  
  166.     case CPEQ:    PERFORM_CPEQ(v, co, r1, r2, ci); break;
  167.     case CPGE:    PERFORM_CPGE(v, co, r1, r2, ci); break;
  168.     case CPGEU:    PERFORM_CPGEU(v, co, r1, r2, ci); break;
  169.     case CPGT:    PERFORM_CPGT(v, co, r1, r2, ci); break;
  170.     case CPGTU:    PERFORM_CPGTU(v, co, r1, r2, ci); break;
  171.     case CPLE:    PERFORM_CPLE(v, co, r1, r2, ci); break;
  172.     case CPLEU:    PERFORM_CPLEU(v, co, r1, r2, ci); break;
  173.     case CPLT:    PERFORM_CPLT(v, co, r1, r2, ci); break;
  174.     case CPLTU:    PERFORM_CPLTU(v, co, r1, r2, ci); break;
  175.     case CPNEQ:    PERFORM_CPNEQ(v, co, r1, r2, ci); break;
  176.  
  177.     case CMPEQ:    PERFORM_CMPEQ(v, co, r1, r2, ci); break;
  178.     case CMPLE:    PERFORM_CMPLE(v, co, r1, r2, ci); break;
  179.     case CMPLEU:    PERFORM_CMPLEU(v, co, r1, r2, ci); break;
  180.     case CMPLT:    PERFORM_CMPLT(v, co, r1, r2, ci); break;
  181.     case CMPLTU:    PERFORM_CMPLTU(v, co, r1, r2, ci); break;
  182.  
  183.     case CYEQ:    PERFORM_CYEQ(v, co, r1, r2, ci); break;
  184.     case CYGES:    PERFORM_CYGES(v, co, r1, r2, ci); break;
  185.     case CYGEU:    PERFORM_CYGEU(v, co, r1, r2, ci); break;
  186.     case CYGTS:    PERFORM_CYGTS(v, co, r1, r2, ci); break;
  187.     case CYGTU:    PERFORM_CYGTU(v, co, r1, r2, ci); break;
  188.     case CYAND:    PERFORM_CYAND(v, co, r1, r2, ci); break;
  189.  
  190.     case MERGE16:    PERFORM_MERGE16(v, co, r1, r2, ci); break;
  191.     case DECR_CYEQ:    PERFORM_DECR_CYEQ(v, co, r1, r2, ci); break;
  192.  
  193.     case CMOVEQ:
  194.       v = regs[insn.d];
  195.       PERFORM_CMOVEQ(v, co, r1, r2, ci);
  196.       break;
  197.     case CMOVNE:
  198.       v = regs[insn.d];
  199.       PERFORM_CMOVNE(v, co, r1, r2, ci);
  200.       break;
  201.     case CMOVLT:
  202.       v = regs[insn.d];
  203.       PERFORM_CMOVLT(v, co, r1, r2, ci);
  204.       break;
  205.     case CMOVGE:
  206.       v = regs[insn.d];
  207.       PERFORM_CMOVGE(v, co, r1, r2, ci);
  208.       break;
  209.     case CMOVLE:
  210.       v = regs[insn.d];
  211.       PERFORM_CMOVLE(v, co, r1, r2, ci);
  212.       break;
  213.     case CMOVGT:
  214.       v = regs[insn.d];
  215.       PERFORM_CMOVGT(v, co, r1, r2, ci);
  216.       break;
  217.  
  218.     case MUL:    PERFORM_MUL(v, co, r1, r2, ci); break;
  219.     case UMULWIDEN_HI: PERFORM_UMULWIDEN_HI(v, co, r1, r2, ci); break;
  220.     case INVDIV: PERFORM_INVDIV(v, co, r1, ci); break;
  221.     case INVMOD: PERFORM_INVMOD(v, co, r1, ci); break;
  222.  
  223. #if HAS_NULLIFICATION
  224.     case ADD_SEQ:
  225.       PERFORM_ADD_SEQ(v, co, nullify_flag, r1, r2, ci);
  226.       break;
  227.     case ADD_SNE:
  228.       PERFORM_ADD_SNE(v, co, nullify_flag, r1, r2, ci);
  229.       break;
  230.     case ADD_SLTS:
  231.       PERFORM_ADD_SLTS(v, co, nullify_flag, r1, r2, ci);
  232.       break;
  233.     case ADD_SGES:
  234.       PERFORM_ADD_SGES(v, co, nullify_flag, r1, r2, ci);
  235.       break;
  236.     case ADD_SLES:
  237.       PERFORM_ADD_SLES(v, co, nullify_flag, r1, r2, ci);
  238.       break;
  239.     case ADD_SGTS:
  240.       PERFORM_ADD_SGTS(v, co, nullify_flag, r1, r2, ci);
  241.       break;
  242.     case ADD_SLTU:
  243.       PERFORM_ADD_SLTU(v, co, nullify_flag, r1, r2, ci);
  244.       break;
  245.     case ADD_SGEU:
  246.       PERFORM_ADD_SGEU(v, co, nullify_flag, r1, r2, ci);
  247.       break;
  248.     case ADD_SLEU:
  249.       PERFORM_ADD_SLEU(v, co, nullify_flag, r1, r2, ci);
  250.       break;
  251.     case ADD_SGTU:
  252.       PERFORM_ADD_SGTU(v, co, nullify_flag, r1, r2, ci);
  253.       break;
  254.     case ADD_SOVS:
  255.       PERFORM_ADD_SOVS(v, co, nullify_flag, r1, r2, ci);
  256.       break;
  257.     case ADD_SNVS:
  258.       PERFORM_ADD_SNVS(v, co, nullify_flag, r1, r2, ci);
  259.       break;
  260.     case ADD_SODD:
  261.       PERFORM_ADD_SODD(v, co, nullify_flag, r1, r2, ci);
  262.       break;
  263.     case ADD_SEVN:
  264.       PERFORM_ADD_SEVN(v, co, nullify_flag, r1, r2, ci);
  265.       break;
  266.     case ADD_S:
  267.       PERFORM_ADD_S(v, co, nullify_flag, r1, r2, ci);
  268.       break;
  269.     case ADD_CIO_SEQ:
  270.       PERFORM_ADD_CIO_SEQ(v, co, nullify_flag, r1, r2, ci);
  271.       break;
  272.     case ADD_CIO_SNE:
  273.       PERFORM_ADD_CIO_SNE(v, co, nullify_flag, r1, r2, ci);
  274.       break;
  275.     case ADD_CIO_SLTU:
  276.       PERFORM_ADD_CIO_SLTU(v, co, nullify_flag, r1, r2, ci);
  277.       break;
  278.     case ADD_CIO_SGEU:
  279.       PERFORM_ADD_CIO_SGEU(v, co, nullify_flag, r1, r2, ci);
  280.       break;
  281.     case ADD_CIO_SLEU:
  282.       PERFORM_ADD_CIO_SLEU(v, co, nullify_flag, r1, r2, ci);
  283.       break;
  284.     case ADD_CIO_SGTU:
  285.       PERFORM_ADD_CIO_SGTU(v, co, nullify_flag, r1, r2, ci);
  286.       break;
  287.     case ADD_CIO_SODD:
  288.       PERFORM_ADD_CIO_SODD(v, co, nullify_flag, r1, r2, ci);
  289.       break;
  290.     case ADD_CIO_SEVN:
  291.       PERFORM_ADD_CIO_SEVN(v, co, nullify_flag, r1, r2, ci);
  292.       break;
  293.     case ADD_CIO_S:
  294.       PERFORM_ADD_CIO_S(v, co, nullify_flag, r1, r2, ci);
  295.       break;
  296.     case ADD_CO_SEQ:
  297.       PERFORM_ADD_CO_SEQ(v, co, nullify_flag, r1, r2, ci);
  298.       break;
  299.     case ADD_CO_SNE:
  300.       PERFORM_ADD_CO_SNE(v, co, nullify_flag, r1, r2, ci);
  301.       break;
  302.     case ADD_CO_SLTU:
  303.       PERFORM_ADD_CO_SLTU(v, co, nullify_flag, r1, r2, ci);
  304.       break;
  305.     case ADD_CO_SGEU:
  306.       PERFORM_ADD_CO_SGEU(v, co, nullify_flag, r1, r2, ci);
  307.       break;
  308.     case ADD_CO_SLEU:
  309.       PERFORM_ADD_CO_SLEU(v, co, nullify_flag, r1, r2, ci);
  310.       break;
  311.     case ADD_CO_SGTU:
  312.       PERFORM_ADD_CO_SGTU(v, co, nullify_flag, r1, r2, ci);
  313.       break;
  314.     case ADD_CO_SODD:
  315.       PERFORM_ADD_CO_SODD(v, co, nullify_flag, r1, r2, ci);
  316.       break;
  317.     case ADD_CO_SEVN:
  318.       PERFORM_ADD_CO_SEVN(v, co, nullify_flag, r1, r2, ci);
  319.       break;
  320.     case ADD_CO_S:
  321.       PERFORM_ADD_CO_S(v, co, nullify_flag, r1, r2, ci);
  322.       break;
  323.     case SUB_SEQ:
  324.       PERFORM_SUB_SEQ(v, co, nullify_flag, r1, r2, ci);
  325.       break;
  326.     case SUB_SNE:
  327.       PERFORM_SUB_SNE(v, co, nullify_flag, r1, r2, ci);
  328.       break;
  329.     case SUB_SLTS:
  330.       PERFORM_SUB_SLTS(v, co, nullify_flag, r1, r2, ci);
  331.       break;
  332.     case SUB_SGES:
  333.       PERFORM_SUB_SGES(v, co, nullify_flag, r1, r2, ci);
  334.       break;
  335.     case SUB_SLES:
  336.       PERFORM_SUB_SLES(v, co, nullify_flag, r1, r2, ci);
  337.       break;
  338.     case SUB_SGTS:
  339.       PERFORM_SUB_SGTS(v, co, nullify_flag, r1, r2, ci);
  340.       break;
  341.     case SUB_SODD:
  342.       PERFORM_SUB_SODD(v, co, nullify_flag, r1, r2, ci);
  343.       break;
  344.     case SUB_SEVN:
  345.       PERFORM_SUB_SEVN(v, co, nullify_flag, r1, r2, ci);
  346.       break;
  347.     case SUB_S:
  348.       PERFORM_SUB_S(v, co, nullify_flag, r1, r2, ci);
  349.       break;
  350.     case ADC_CIO_SEQ:
  351.       PERFORM_ADC_CIO_SEQ(v, co, nullify_flag, r1, r2, ci);
  352.       break;
  353.     case ADC_CIO_SNE:
  354.       PERFORM_ADC_CIO_SNE(v, co, nullify_flag, r1, r2, ci);
  355.       break;
  356.     case ADC_CIO_SLTU:
  357.       PERFORM_ADC_CIO_SLTU(v, co, nullify_flag, r1, r2, ci);
  358.       break;
  359.     case ADC_CIO_SGEU:
  360.       PERFORM_ADC_CIO_SGEU(v, co, nullify_flag, r1, r2, ci);
  361.       break;
  362.     case ADC_CIO_SLEU:
  363.       PERFORM_ADC_CIO_SLEU(v, co, nullify_flag, r1, r2, ci);
  364.       break;
  365.     case ADC_CIO_SGTU:
  366.       PERFORM_ADC_CIO_SGTU(v, co, nullify_flag, r1, r2, ci);
  367.       break;
  368.     case ADC_CIO_SODD:
  369.       PERFORM_ADC_CIO_SODD(v, co, nullify_flag, r1, r2, ci);
  370.       break;
  371.     case ADC_CIO_SEVN:
  372.       PERFORM_ADC_CIO_SEVN(v, co, nullify_flag, r1, r2, ci);
  373.       break;
  374.     case ADC_CIO_S:
  375.       PERFORM_ADC_CIO_S(v, co, nullify_flag, r1, r2, ci);
  376.       break;
  377.     case ADC_CO_SEQ:
  378.       PERFORM_ADC_CO_SEQ(v, co, nullify_flag, r1, r2, ci);
  379.       break;
  380.     case ADC_CO_SNE:
  381.       PERFORM_ADC_CO_SNE(v, co, nullify_flag, r1, r2, ci);
  382.       break;
  383.     case ADC_CO_SLTU:
  384.       PERFORM_ADC_CO_SLTU(v, co, nullify_flag, r1, r2, ci);
  385.       break;
  386.     case ADC_CO_SGEU:
  387.       PERFORM_ADC_CO_SGEU(v, co, nullify_flag, r1, r2, ci);
  388.       break;
  389.     case ADC_CO_SLEU:
  390.       PERFORM_ADC_CO_SLEU(v, co, nullify_flag, r1, r2, ci);
  391.       break;
  392.     case ADC_CO_SGTU:
  393.       PERFORM_ADC_CO_SGTU(v, co, nullify_flag, r1, r2, ci);
  394.       break;
  395.     case ADC_CO_SODD:
  396.       PERFORM_ADC_CO_SODD(v, co, nullify_flag, r1, r2, ci);
  397.       break;
  398.     case ADC_CO_SEVN:
  399.       PERFORM_ADC_CO_SEVN(v, co, nullify_flag, r1, r2, ci);
  400.       break;
  401.     case ADC_CO_S:
  402.       PERFORM_ADC_CO_S(v, co, nullify_flag, r1, r2, ci);
  403.       break;
  404.  
  405.     case COMCLR_SEQ:
  406.       PERFORM_COMCLR_SEQ(v, co, nullify_flag, r1, r2, ci);
  407.       break;
  408.     case COMCLR_SNE:
  409.       PERFORM_COMCLR_SNE(v, co, nullify_flag, r1, r2, ci);
  410.       break;
  411.     case COMCLR_SLTS:
  412.       PERFORM_COMCLR_SLTS(v, co, nullify_flag, r1, r2, ci);
  413.       break;
  414.     case COMCLR_SGES:
  415.       PERFORM_COMCLR_SGES(v, co, nullify_flag, r1, r2, ci);
  416.       break;
  417.     case COMCLR_SLES:
  418.       PERFORM_COMCLR_SLES(v, co, nullify_flag, r1, r2, ci);
  419.       break;
  420.     case COMCLR_SGTS:
  421.       PERFORM_COMCLR_SGTS(v, co, nullify_flag, r1, r2, ci);
  422.       break;
  423.     case COMCLR_SLTU:
  424.       PERFORM_COMCLR_SLTU(v, co, nullify_flag, r1, r2, ci);
  425.       break;
  426.     case COMCLR_SGEU:
  427.       PERFORM_COMCLR_SGEU(v, co, nullify_flag, r1, r2, ci);
  428.       break;
  429.     case COMCLR_SLEU:
  430.       PERFORM_COMCLR_SLEU(v, co, nullify_flag, r1, r2, ci);
  431.       break;
  432.     case COMCLR_SGTU:
  433.       PERFORM_COMCLR_SGTU(v, co, nullify_flag, r1, r2, ci);
  434.       break;
  435.     case COMCLR_SODD:
  436.       PERFORM_COMCLR_SODD(v, co, nullify_flag, r1, r2, ci);
  437.       break;
  438.     case COMCLR_SEVN:
  439.       PERFORM_COMCLR_SEVN(v, co, nullify_flag, r1, r2, ci);
  440.       break;
  441.  
  442.     case AND_SEQ:
  443.       PERFORM_AND_SEQ(v, co, nullify_flag, r1, r2, ci);
  444.       break;
  445.     case AND_SNE:
  446.       PERFORM_AND_SNE(v, co, nullify_flag, r1, r2, ci);
  447.       break;
  448.     case AND_SLTS:
  449.       PERFORM_AND_SLTS(v, co, nullify_flag, r1, r2, ci);
  450.       break;
  451.     case AND_SGES:
  452.       PERFORM_AND_SGES(v, co, nullify_flag, r1, r2, ci);
  453.       break;
  454.     case AND_SLES:
  455.       PERFORM_AND_SLES(v, co, nullify_flag, r1, r2, ci);
  456.       break;
  457.     case AND_SGTS:
  458.       PERFORM_AND_SGTS(v, co, nullify_flag, r1, r2, ci);
  459.       break;
  460.     case AND_SODD:
  461.       PERFORM_AND_SODD(v, co, nullify_flag, r1, r2, ci);
  462.       break;
  463.     case AND_SEVN:
  464.       PERFORM_AND_SEVN(v, co, nullify_flag, r1, r2, ci);
  465.       break;
  466.     case AND_S:
  467.       PERFORM_AND_S(v, co, nullify_flag, r1, r2, ci);
  468.       break;
  469.     case IOR_SEQ:
  470.       PERFORM_IOR_SEQ(v, co, nullify_flag, r1, r2, ci);
  471.       break;
  472.     case IOR_SNE:
  473.       PERFORM_IOR_SNE(v, co, nullify_flag, r1, r2, ci);
  474.       break;
  475.     case IOR_SLTS:
  476.       PERFORM_IOR_SLTS(v, co, nullify_flag, r1, r2, ci);
  477.       break;
  478.     case IOR_SGES:
  479.       PERFORM_IOR_SGES(v, co, nullify_flag, r1, r2, ci);
  480.       break;
  481.     case IOR_SLES:
  482.       PERFORM_IOR_SLES(v, co, nullify_flag, r1, r2, ci);
  483.       break;
  484.     case IOR_SGTS:
  485.       PERFORM_IOR_SGTS(v, co, nullify_flag, r1, r2, ci);
  486.       break;
  487.     case IOR_SODD:
  488.       PERFORM_IOR_SODD(v, co, nullify_flag, r1, r2, ci);
  489.       break;
  490.     case IOR_SEVN:
  491.       PERFORM_IOR_SEVN(v, co, nullify_flag, r1, r2, ci);
  492.       break;
  493.     case IOR_S:
  494.       PERFORM_IOR_S(v, co, nullify_flag, r1, r2, ci);
  495.       break;
  496.     case XOR_SEQ:
  497.       PERFORM_XOR_SEQ(v, co, nullify_flag, r1, r2, ci);
  498.       break;
  499.     case XOR_SNE:
  500.       PERFORM_XOR_SNE(v, co, nullify_flag, r1, r2, ci);
  501.       break;
  502.     case XOR_SLTS:
  503.       PERFORM_XOR_SLTS(v, co, nullify_flag, r1, r2, ci);
  504.       break;
  505.     case XOR_SGES:
  506.       PERFORM_XOR_SGES(v, co, nullify_flag, r1, r2, ci);
  507.       break;
  508.     case XOR_SLES:
  509.       PERFORM_XOR_SLES(v, co, nullify_flag, r1, r2, ci);
  510.       break;
  511.     case XOR_SGTS:
  512.       PERFORM_XOR_SGTS(v, co, nullify_flag, r1, r2, ci);
  513.       break;
  514.     case XOR_SODD:
  515.       PERFORM_XOR_SODD(v, co, nullify_flag, r1, r2, ci);
  516.       break;
  517.     case XOR_SEVN:
  518.       PERFORM_XOR_SEVN(v, co, nullify_flag, r1, r2, ci);
  519.       break;
  520.     case XOR_S:
  521.       PERFORM_XOR_S(v, co, nullify_flag, r1, r2, ci);
  522.       break;
  523.     case ANDC_SEQ:
  524.       PERFORM_ANDC_SEQ(v, co, nullify_flag, r1, r2, ci);
  525.       break;
  526.     case ANDC_SNE:
  527.       PERFORM_ANDC_SNE(v, co, nullify_flag, r1, r2, ci);
  528.       break;
  529.     case ANDC_SLTS:
  530.       PERFORM_ANDC_SLTS(v, co, nullify_flag, r1, r2, ci);
  531.       break;
  532.     case ANDC_SGES:
  533.       PERFORM_ANDC_SGES(v, co, nullify_flag, r1, r2, ci);
  534.       break;
  535.     case ANDC_SLES:
  536.       PERFORM_ANDC_SLES(v, co, nullify_flag, r1, r2, ci);
  537.       break;
  538.     case ANDC_SGTS:
  539.       PERFORM_ANDC_SGTS(v, co, nullify_flag, r1, r2, ci);
  540.       break;
  541.     case ANDC_SODD:
  542.       PERFORM_ANDC_SODD(v, co, nullify_flag, r1, r2, ci);
  543.       break;
  544.     case ANDC_SEVN:
  545.       PERFORM_ANDC_SEVN(v, co, nullify_flag, r1, r2, ci);
  546.       break;
  547.     case ANDC_S:
  548.       PERFORM_ANDC_S(v, co, nullify_flag, r1, r2, ci);
  549.       break;
  550.     case LSHIFTR_S:
  551.       PERFORM_LSHIFTR_S(v, co, nullify_flag, r1, r2, ci);
  552.       break;
  553.     case ASHIFTR_S:
  554.       PERFORM_ASHIFTR_S(v, co, nullify_flag, r1, r2, ci);
  555.       break;
  556.     case SHIFTL_S:
  557.       PERFORM_SHIFTL_S(v, co, nullify_flag, r1, r2, ci);
  558.       break;
  559.     case ROTATEL_S:
  560.       PERFORM_ROTATEL_S(v, co, nullify_flag, r1, r2, ci);
  561.       break;
  562.     case EXTS1_S:
  563.       PERFORM_EXTS1_S(v, co, nullify_flag, r1, r2, ci);
  564.       break;
  565.     case EXTS2_S:
  566.       PERFORM_EXTS2_S(v, co, nullify_flag, r1, r2, ci);
  567.       break;
  568.     case EXTS8_S:
  569.       PERFORM_EXTS8_S(v, co, nullify_flag, r1, r2, ci);
  570.       break;
  571.     case EXTS16_S:
  572.       PERFORM_EXTS16_S(v, co, nullify_flag, r1, r2, ci);
  573.       break;
  574.     case EXTU1_S:
  575.       PERFORM_EXTU1_S(v, co, nullify_flag, r1, r2, ci);
  576.       break;
  577.     case EXTU2_S:
  578.       PERFORM_EXTU2_S(v, co, nullify_flag, r1, r2, ci);
  579.       break;
  580.     case COPY_S:
  581.       PERFORM_COPY_S(v, co, nullify_flag, r1, ci);
  582.       break;
  583.  
  584. #endif /* HAS_NULLIFICATION */
  585.  
  586.     case ADDC_960:        PERFORM_ADDC_960(v, co, r1, r2, ci); break;
  587.     case SUBC_960:        PERFORM_SUBC_960(v, co, r1, r2, ci); break;
  588.     case SEL_NO_960:    PERFORM_SEL_NO_960(v, co, r1, r2, ci); break;
  589.     case SEL_G_960:        PERFORM_SEL_G_960(v, co, r1, r2, ci); break;
  590.     case SEL_E_960:        PERFORM_SEL_E_960(v, co, r1, r2, ci); break;
  591.     case SEL_GE_960:    PERFORM_SEL_GE_960(v, co, r1, r2, ci); break;
  592.     case SEL_L_960:        PERFORM_SEL_L_960(v, co, r1, r2, ci); break;
  593.     case SEL_NE_960:    PERFORM_SEL_NE_960(v, co, r1, r2, ci); break;
  594.     case SEL_LE_960:    PERFORM_SEL_LE_960(v, co, r1, r2, ci); break;
  595.     case SEL_O_960:        PERFORM_SEL_O_960(v, co, r1, r2, ci); break;
  596.     case CONCMPO_960:    PERFORM_CONCMPO_960(v, co, r1, r2, ci); break;
  597.     case CONCMPI_960:    PERFORM_CONCMPI_960(v, co, r1, r2, ci); break;
  598.     case CMPO_960:        PERFORM_CMPO_960(v, co, r1, r2, ci); break;
  599.     case CMPI_960:        PERFORM_CMPI_960(v, co, r1, r2, ci); break;
  600.     case SHIFTL_NT:        PERFORM_SHIFTL_NT(v, co, r1, r2, ci); break;
  601.     case LSHIFTR_NT:    PERFORM_LSHIFTR_NT(v, co, r1, r2, ci); break;
  602.     case ASHIFTR_NT:    PERFORM_ASHIFTR_NT(v, co, r1, r2, ci); break;
  603.     case ADDO_NO_960:
  604.       v = regs[insn.d];
  605.       PERFORM_ADDO_NO_960(v, co, r1, r2, ci);
  606.       break;
  607.     case ADDO_G_960:
  608.       v = regs[insn.d];
  609.       PERFORM_ADDO_G_960(v, co, r1, r2, ci);
  610.       break;
  611.     case ADDO_E_960:
  612.       v = regs[insn.d];
  613.       PERFORM_ADDO_E_960(v, co, r1, r2, ci);
  614.       break;
  615.     case ADDO_GE_960:
  616.       v = regs[insn.d];
  617.       PERFORM_ADDO_GE_960(v, co, r1, r2, ci);
  618.       break;
  619.     case ADDO_L_960:
  620.       v = regs[insn.d];
  621.       PERFORM_ADDO_L_960(v, co, r1, r2, ci);
  622.       break;
  623.     case ADDO_NE_960:
  624.       v = regs[insn.d];
  625.       PERFORM_ADDO_NE_960(v, co, r1, r2, ci);
  626.       break;
  627.     case ADDO_LE_960:
  628.       v = regs[insn.d];
  629.       PERFORM_ADDO_LE_960(v, co, r1, r2, ci);
  630.       break;
  631.     case ADDO_O_960:
  632.       v = regs[insn.d];
  633.       PERFORM_ADDO_O_960(v, co, r1, r2, ci);
  634.       break;
  635.     case SUBO_NO_960:
  636.       v = regs[insn.d];
  637.       PERFORM_SUBO_NO_960(v, co, r1, r2, ci);
  638.       break;
  639.     case SUBO_G_960:
  640.       v = regs[insn.d];
  641.       PERFORM_SUBO_G_960(v, co, r1, r2, ci);
  642.       break;
  643.     case SUBO_E_960:
  644.       v = regs[insn.d];
  645.       PERFORM_SUBO_E_960(v, co, r1, r2, ci);
  646.       break;
  647.     case SUBO_GE_960:
  648.       v = regs[insn.d];
  649.       PERFORM_SUBO_GE_960(v, co, r1, r2, ci);
  650.       break;
  651.     case SUBO_L_960:
  652.       v = regs[insn.d];
  653.       PERFORM_SUBO_L_960(v, co, r1, r2, ci);
  654.       break;
  655.     case SUBO_NE_960:
  656.       v = regs[insn.d];
  657.       PERFORM_SUBO_NE_960(v, co, r1, r2, ci);
  658.       break;
  659.     case SUBO_LE_960:
  660.       v = regs[insn.d];
  661.       PERFORM_SUBO_LE_960(v, co, r1, r2, ci);
  662.       break;
  663.     case SUBO_O_960:
  664.       v = regs[insn.d];
  665.       PERFORM_SUBO_O_960(v, co, r1, r2, ci);
  666.       break;
  667.  
  668.     case ALTERBIT:        PERFORM_ALTERBIT(v, co, r1, r2, ci); break;
  669.     case SETBIT:        PERFORM_SETBIT(v, co, r1, r2, ci); break;
  670.     case CLRBIT:        PERFORM_CLRBIT(v, co, r1, r2, ci); break;
  671.     case CHKBIT:        PERFORM_CHKBIT(v, co, r1, r2, ci); break;
  672.     case NOTBIT:        PERFORM_NOTBIT(v, co, r1, r2, ci); break;
  673.  
  674. #ifdef UDIV_WITH_SDIV
  675.     case SDIV: PERFORM_SDIV(v, co, r1, r2, ci); break;
  676. #endif
  677.     }
  678.  
  679. #if HAS_NULLIFICATION
  680.       reg_defined[insn.d] = 1;
  681. #endif
  682.       /* Store result.  */
  683.       regs[insn.d] = v;
  684.       ci = co;
  685.     }
  686.  
  687. #if HAS_NULLIFICATION
  688.   /* Check if the destination has become defined for the current arguments.  */
  689.   if (!reg_defined[insn.d])
  690.     return -2;
  691. #endif
  692.  
  693.   return ci;
  694. }
  695.