/* This file contains the definitions and documentation for the instructions
   used in the Superoptimizer.

   Copyright (C) 1992 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License along
   with this program; see the file COPYING.  If not, write to the Free
   Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* The fields in the cpp macro call "DEF_INSN()" are:

   1. The internal name of the instruction.

   2. The class of the instruction.  These are stored in the insn_class
   array and are accessed via the GET_INSN_CLASS macro.  They are defined
   as  follows:

     "1" an rtx code for a unary arithmetic expression (e.g, ABSVAL, CLZ)
     "c" an rtx code for a commutative binary operation (e.g,  ADD, XOR)
     "2" an rtx code for a non-commutative binary operation (e.g., SUB, CMP)
     "x" everything else

   3. The printed name of the instruction.

   */

/* Arithmetic insns.  d = r1 + r2 [+ cy] */
DEF_INSN (ADD,            'b', "add")
DEF_INSN (ADD_CI,         'b', "add_ci")
DEF_INSN (ADD_CO,         'b', "add_co")
DEF_INSN (ADD_CIO,        'b', "add_cio")
/* Arithmetic insns.  d = r1 - r2 [- cy] */
DEF_INSN (SUB,            '2', "sub")
DEF_INSN (SUB_CI,         '2', "sub_ci")
DEF_INSN (SUB_CO,         '2', "sub_co")
DEF_INSN (SUB_CIO,        '2', "sub_cio")
/* Arithmetic insns.  d = r1 + ~r2 [+ cy] */
DEF_INSN (ADC_CI,         '2', "adc_ci")
DEF_INSN (ADC_CO,         '2', "adc_co")
DEF_INSN (ADC_CIO,        '2', "adc_cio")

/* Logical insns that don't affect the carry flag.  */
DEF_INSN (AND,            'b', "and")
DEF_INSN (IOR,            'b', "ior")
DEF_INSN (XOR,            'b', "xor")
DEF_INSN (ANDC,           '2', "andc")
DEF_INSN (IORC,           '2', "iorc")
DEF_INSN (EQV,            '2', "eqv")
DEF_INSN (NAND,           'b', "nand")
DEF_INSN (NOR,            'b', "nor")

/* Logical insns that reset the carry flag.  */
DEF_INSN (AND_RC,         'b', "and_rc")
DEF_INSN (IOR_RC,         'b', "ior_rc")
DEF_INSN (XOR_RC,         'b', "xor_rc")
DEF_INSN (ANDC_RC,        '2', "andc_rc")
DEF_INSN (IORC_RC,        '2', "iorc_rc")
DEF_INSN (EQV_RC,         '2', "eqv_rc")
DEF_INSN (NAND_RC,        'b', "nand_rc")
DEF_INSN (NOR_RC,         'b', "nor_rc")

/* Logical insns that clobber the carry flag.  */
DEF_INSN (AND_CC,         'b', "and_cc")
DEF_INSN (IOR_CC,         'b', "ior_cc")
DEF_INSN (XOR_CC,         'b', "xor_cc")
DEF_INSN (ANDC_CC,        '2', "andc_cc")
DEF_INSN (IORC_CC,        '2', "iorc_cc")
DEF_INSN (EQV_CC,         '2', "eqv_cc")
DEF_INSN (NAND_CC,        'b', "nand_cc")
DEF_INSN (NOR_CC,         'b', "nor_cc")

/* Bit shift and count.  */
DEF_INSN (LSHIFTR,        '2', "log_shift_right")
DEF_INSN (ASHIFTR,        '2', "arith_shift_right")
DEF_INSN (SHIFTL,         '2', "shift_left")
DEF_INSN (LSHIFTR_CO,     '2', "log_shift_right_co")
DEF_INSN (ASHIFTR_CO,     '2', "arith_shift_right_co")
DEF_INSN (SHIFTL_CO,      '2', "shift_left_co")
DEF_INSN (ROTATEL,        '2', "rotate_left")
DEF_INSN (ROTATEL_CO,     '2', "rotate_left_co")

/* Rotate thru carry.  */
DEF_INSN (ROTATEXL_CIO,   '2', "rotate_thru_carry_left_co")

/* Shift arithmetic right instruction and set carry iff the shifted
   operand is negative and any bit shifted out is 1.  */
DEF_INSN (ASHIFTR_CON,    '2', "arith_shift_right_set_carry_if_neg_and_nzbit_lost")

/* Extract.  */
DEF_INSN (EXTS1,          '2', "exts1")
DEF_INSN (EXTS2,          '2', "exts2")
DEF_INSN (EXTU1,          '2', "extu1")
DEF_INSN (EXTU2,          '2', "extu2")

/* Count leading/trailing zero instructions.  */
DEF_INSN (CLZ,            '1', "clz")
DEF_INSN (CTZ,            '1', "ctz")
DEF_INSN (FF1,            '1', "ff1")
DEF_INSN (FF0,            '1', "ff0")

DEF_INSN (ABSVAL,         '1', "abs")
DEF_INSN (NABSVAL,        '1', "nabs")
DEF_INSN (CMP,            '2', "cmp")

/* 29k CMP instructions.  */
DEF_INSN (CPEQ,           '2', "cpeq")
DEF_INSN (CPGE,           '2', "cpge")
DEF_INSN (CPGEU,          '2', "cpgeu")
DEF_INSN (CPGT,           '2', "cpgt")
DEF_INSN (CPGTU,          '2', "cpgtu")
DEF_INSN (CPLE,           '2', "cple")
DEF_INSN (CPLEU,          '2', "cpleu")
DEF_INSN (CPLT,           '2', "cplt")
DEF_INSN (CPLTU,          '2', "cpltu")
DEF_INSN (CPNEQ,          '2', "cpneq")

/* Alpha CMP instructions.  */
DEF_INSN (CMPEQ,           '2', "cmpeq")
DEF_INSN (CMPLE,           '2', "cmple")
DEF_INSN (CMPLEU,          '2', "cmpleu")
DEF_INSN (CMPLT,           '2', "cmplt")
DEF_INSN (CMPLTU,          '2', "cmpltu")

/* 88100 cmp instruction.  */
DEF_INSN (CMPPAR,         '2', "cmppar")

/* Difference-or-zero (rs6000) */
DEF_INSN (DOZ,            '2', "difference_or_zero")

DEF_INSN (COPY,           '1', "copy")
DEF_INSN (EXCHANGE,       '2', "exchange")

/* Complement carry */
DEF_INSN (COMCY,          '2', "complement_cy")

/* Alpha conditional move */
DEF_INSN (CMOVEQ,	  '2', "cmoveq")
DEF_INSN (CMOVNE,	  '2', "cmovne")
DEF_INSN (CMOVLT,	  '2', "cmovlt")
DEF_INSN (CMOVGE,	  '2', "cmovge")
DEF_INSN (CMOVLE,	  '2', "cmovle")
DEF_INSN (CMOVGT,	  '2', "cmovgt")

DEF_INSN (INVDIV,         '2', "invdiv")
DEF_INSN (INVMOD,         '2', "invmod")
DEF_INSN (UMULWIDEN_HI,   '2', "umulwiden_hi")
DEF_INSN (MUL,            '2', "mul")

#if UDIV_WITH_SDIV
DEF_INSN (SDIV,           '2', "sdiv")
#endif

/*
Local variables:
mode:c
version-control: t
End:
*/