6866 lines
121 KiB
C
6866 lines
121 KiB
C
/* Generated automatically by the program `genoutput'
|
|
from the machine description file `md'. */
|
|
|
|
#include "config.h"
|
|
#include "rtl.h"
|
|
#include "regs.h"
|
|
#include "hard-reg-set.h"
|
|
#include "real.h"
|
|
#include "insn-config.h"
|
|
|
|
#include "conditions.h"
|
|
#include "insn-flags.h"
|
|
#include "insn-attr.h"
|
|
|
|
#include "insn-codes.h"
|
|
|
|
#include "recog.h"
|
|
|
|
#include <stdio.h>
|
|
#include "output.h"
|
|
|
|
static char *
|
|
output_0 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[0]))
|
|
return AS2 (test%L0,%0,%0);
|
|
|
|
operands[1] = const0_rtx;
|
|
return AS2 (cmp%L0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_2 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[0]))
|
|
return AS2 (test%W0,%0,%0);
|
|
|
|
operands[1] = const0_rtx;
|
|
return AS2 (cmp%W0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_4 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[0]))
|
|
return AS2 (test%B0,%0,%0);
|
|
|
|
operands[1] = const0_rtx;
|
|
return AS2 (cmp%B0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_6 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (! STACK_TOP_P (operands[0]))
|
|
abort ();
|
|
|
|
output_asm_insn ("ftst", operands);
|
|
|
|
if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
|
|
output_asm_insn (AS1 (fstp,%y0), operands);
|
|
|
|
return (char *) output_fp_cc0_set (insn);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_8 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (! STACK_TOP_P (operands[0]))
|
|
abort ();
|
|
|
|
output_asm_insn ("ftst", operands);
|
|
|
|
if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
|
|
output_asm_insn (AS1 (fstp,%y0), operands);
|
|
|
|
return (char *) output_fp_cc0_set (insn);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_10 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (! STACK_TOP_P (operands[0]))
|
|
abort ();
|
|
|
|
output_asm_insn ("ftst", operands);
|
|
|
|
if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
|
|
output_asm_insn (AS1 (fstp,%y0), operands);
|
|
|
|
return (char *) output_fp_cc0_set (insn);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_12 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (CONSTANT_P (operands[0]) || GET_CODE (operands[1]) == MEM)
|
|
{
|
|
cc_status.flags |= CC_REVERSED;
|
|
return AS2 (cmp%L0,%0,%1);
|
|
}
|
|
return AS2 (cmp%L0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_14 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (CONSTANT_P (operands[0]) || GET_CODE (operands[1]) == MEM)
|
|
{
|
|
cc_status.flags |= CC_REVERSED;
|
|
return AS2 (cmp%W0,%0,%1);
|
|
}
|
|
return AS2 (cmp%W0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_16 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (CONSTANT_P (operands[0]) || GET_CODE (operands[1]) == MEM)
|
|
{
|
|
cc_status.flags |= CC_REVERSED;
|
|
return AS2 (cmp%B0,%0,%1);
|
|
}
|
|
return AS2 (cmp%B0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_18 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_19 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_20 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_21 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_22 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_23 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_24 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_25 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_26 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_27 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_28 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_29 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_30 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_31 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_32 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_33 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_float_compare (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_43 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
/* For small integers, we may actually use testb. */
|
|
if (GET_CODE (operands[1]) == CONST_INT
|
|
&& ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0]))
|
|
&& (! REG_P (operands[0]) || QI_REG_P (operands[0])))
|
|
{
|
|
/* We may set the sign bit spuriously. */
|
|
|
|
if ((INTVAL (operands[1]) & ~0xff) == 0)
|
|
{
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
|
|
if ((INTVAL (operands[1]) & ~0xff00) == 0)
|
|
{
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
operands[1] = GEN_INT (INTVAL (operands[1]) >> 8);
|
|
|
|
if (QI_REG_P (operands[0]))
|
|
return AS2 (test%B0,%1,%h0);
|
|
else
|
|
{
|
|
operands[0] = adj_offsettable_operand (operands[0], 1);
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
}
|
|
|
|
if (GET_CODE (operands[0]) == MEM
|
|
&& (INTVAL (operands[1]) & ~0xff0000) == 0)
|
|
{
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
operands[1] = GEN_INT (INTVAL (operands[1]) >> 16);
|
|
operands[0] = adj_offsettable_operand (operands[0], 2);
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
|
|
if (GET_CODE (operands[0]) == MEM
|
|
&& (INTVAL (operands[1]) & ~0xff000000) == 0)
|
|
{
|
|
operands[1] = GEN_INT ((INTVAL (operands[1]) >> 24) & 0xff);
|
|
operands[0] = adj_offsettable_operand (operands[0], 3);
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
}
|
|
|
|
if (CONSTANT_P (operands[1]) || GET_CODE (operands[0]) == MEM)
|
|
return AS2 (test%L0,%1,%0);
|
|
|
|
return AS2 (test%L1,%0,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_44 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[1]) == CONST_INT
|
|
&& ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0]))
|
|
&& (! REG_P (operands[0]) || QI_REG_P (operands[0])))
|
|
{
|
|
if ((INTVAL (operands[1]) & 0xff00) == 0)
|
|
{
|
|
/* ??? This might not be necessary. */
|
|
if (INTVAL (operands[1]) & 0xffff0000)
|
|
operands[1] = GEN_INT (INTVAL (operands[1]) & 0xff);
|
|
|
|
/* We may set the sign bit spuriously. */
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
|
|
if ((INTVAL (operands[1]) & 0xff) == 0)
|
|
{
|
|
operands[1] = GEN_INT ((INTVAL (operands[1]) >> 8) & 0xff);
|
|
|
|
if (QI_REG_P (operands[0]))
|
|
return AS2 (test%B0,%1,%h0);
|
|
else
|
|
{
|
|
operands[0] = adj_offsettable_operand (operands[0], 1);
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (CONSTANT_P (operands[1]) || GET_CODE (operands[0]) == MEM)
|
|
return AS2 (test%W0,%1,%0);
|
|
|
|
return AS2 (test%W1,%0,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_45 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (CONSTANT_P (operands[1]) || GET_CODE (operands[0]) == MEM)
|
|
return AS2 (test%B0,%1,%0);
|
|
|
|
return AS2 (test%B1,%0,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_49 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx link;
|
|
if (operands[1] == const0_rtx && REG_P (operands[0]))
|
|
return AS2 (xor%L0,%0,%0);
|
|
|
|
if (operands[1] == const1_rtx
|
|
&& (link = find_reg_note (insn, REG_WAS_0, 0))
|
|
/* Make sure the insn that stored the 0 is still present. */
|
|
&& ! INSN_DELETED_P (XEXP (link, 0))
|
|
&& GET_CODE (XEXP (link, 0)) != NOTE
|
|
/* Make sure cross jumping didn't happen here. */
|
|
&& no_labels_between_p (XEXP (link, 0), insn)
|
|
/* Make sure the reg hasn't been clobbered. */
|
|
&& ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
|
|
/* Fastest way to change a 0 to a 1. */
|
|
return AS1 (inc%L0,%0);
|
|
|
|
return AS2 (mov%L0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_51 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx link;
|
|
if (REG_P (operands[0]) && operands[1] == const0_rtx)
|
|
return AS2 (xor%L0,%k0,%k0);
|
|
|
|
if (REG_P (operands[0]) && operands[1] == const1_rtx
|
|
&& (link = find_reg_note (insn, REG_WAS_0, 0))
|
|
/* Make sure the insn that stored the 0 is still present. */
|
|
&& ! INSN_DELETED_P (XEXP (link, 0))
|
|
&& GET_CODE (XEXP (link, 0)) != NOTE
|
|
/* Make sure cross jumping didn't happen here. */
|
|
&& no_labels_between_p (XEXP (link, 0), insn)
|
|
/* Make sure the reg hasn't been clobbered. */
|
|
&& ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
|
|
/* Fastest way to change a 0 to a 1. */
|
|
return AS1 (inc%L0,%k0);
|
|
|
|
if (REG_P (operands[0]))
|
|
{
|
|
if (REG_P (operands[1]))
|
|
return AS2 (mov%L0,%k1,%k0);
|
|
else if (CONSTANT_P (operands[1]))
|
|
return AS2 (mov%L0,%1,%k0);
|
|
}
|
|
|
|
return AS2 (mov%W0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_52 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx link;
|
|
if (operands[1] == const0_rtx && REG_P (operands[0]))
|
|
return AS2 (xor%W0,%0,%0);
|
|
|
|
if (operands[1] == const1_rtx
|
|
&& (link = find_reg_note (insn, REG_WAS_0, 0))
|
|
/* Make sure the insn that stored the 0 is still present. */
|
|
&& ! INSN_DELETED_P (XEXP (link, 0))
|
|
&& GET_CODE (XEXP (link, 0)) != NOTE
|
|
/* Make sure cross jumping didn't happen here. */
|
|
&& no_labels_between_p (XEXP (link, 0), insn)
|
|
/* Make sure the reg hasn't been clobbered. */
|
|
&& ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
|
|
/* Fastest way to change a 0 to a 1. */
|
|
return AS1 (inc%W0,%0);
|
|
|
|
return AS2 (mov%W0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_53 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
operands[1] = gen_rtx (REG, HImode, REGNO (operands[1]));
|
|
return AS1 (push%W0,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_54 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx link;
|
|
if (operands[1] == const0_rtx && REG_P (operands[0]))
|
|
return AS2 (xor%B0,%0,%0);
|
|
|
|
if (operands[1] == const1_rtx
|
|
&& (link = find_reg_note (insn, REG_WAS_0, 0))
|
|
/* Make sure the insn that stored the 0 is still present. */
|
|
&& ! INSN_DELETED_P (XEXP (link, 0))
|
|
&& GET_CODE (XEXP (link, 0)) != NOTE
|
|
/* Make sure cross jumping didn't happen here. */
|
|
&& no_labels_between_p (XEXP (link, 0), insn)
|
|
/* Make sure the reg hasn't been clobbered. */
|
|
&& ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
|
|
/* Fastest way to change a 0 to a 1. */
|
|
return AS1 (inc%B0,%0);
|
|
|
|
/* If mov%B0 isn't allowed for one of these regs, use mov%L0. */
|
|
if (NON_QI_REG_P (operands[0]) || NON_QI_REG_P (operands[1]))
|
|
return (AS2 (mov%L0,%k1,%k0));
|
|
|
|
return (AS2 (mov%B0,%1,%0));
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_55 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx link;
|
|
if (operands[1] == const0_rtx && REG_P (operands[0]))
|
|
return AS2 (xor%B0,%0,%0);
|
|
|
|
if (operands[1] == const1_rtx
|
|
&& (link = find_reg_note (insn, REG_WAS_0, 0))
|
|
/* Make sure the insn that stored the 0 is still present. */
|
|
&& ! INSN_DELETED_P (XEXP (link, 0))
|
|
&& GET_CODE (XEXP (link, 0)) != NOTE
|
|
/* Make sure cross jumping didn't happen here. */
|
|
&& no_labels_between_p (XEXP (link, 0), insn)
|
|
/* Make sure the reg hasn't been clobbered. */
|
|
&& ! reg_set_between_p (operands[0], XEXP (link, 0), insn))
|
|
/* Fastest way to change a 0 to a 1. */
|
|
return AS1 (inc%B0,%0);
|
|
|
|
/* If mov%B0 isn't allowed for one of these regs, use mov%L0. */
|
|
if (NON_QI_REG_P (operands[0]) || NON_QI_REG_P (operands[1]))
|
|
{
|
|
abort ();
|
|
return (AS2 (mov%L0,%k1,%k0));
|
|
}
|
|
|
|
return AS2 (mov%B0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_56 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (STACK_REG_P (operands[1]))
|
|
{
|
|
rtx xops[3];
|
|
|
|
if (! STACK_TOP_P (operands[1]))
|
|
abort ();
|
|
|
|
xops[0] = AT_SP (SFmode);
|
|
xops[1] = GEN_INT (4);
|
|
xops[2] = stack_pointer_rtx;
|
|
|
|
output_asm_insn (AS2 (sub%L2,%1,%2), xops);
|
|
|
|
if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
|
|
output_asm_insn (AS1 (fstp%S0,%0), xops);
|
|
else
|
|
output_asm_insn (AS1 (fst%S0,%0), xops);
|
|
RET;
|
|
}
|
|
return AS1 (push%L1,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_57 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
|
|
|
|
/* First handle a `pop' insn or a `fld %st(0)' */
|
|
|
|
if (STACK_TOP_P (operands[0]) && STACK_TOP_P (operands[1]))
|
|
{
|
|
if (stack_top_dies)
|
|
return AS1 (fstp,%y0);
|
|
else
|
|
return AS1 (fld,%y0);
|
|
}
|
|
|
|
/* Handle a transfer between the 387 and a 386 register */
|
|
|
|
if (STACK_TOP_P (operands[0]) && NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fld%z0,%y1));
|
|
RET;
|
|
}
|
|
|
|
if (STACK_TOP_P (operands[1]) && NON_STACK_REG_P (operands[0]))
|
|
{
|
|
output_to_reg (operands[0], stack_top_dies);
|
|
RET;
|
|
}
|
|
|
|
/* Handle other kinds of writes from the 387 */
|
|
|
|
if (STACK_TOP_P (operands[1]))
|
|
{
|
|
if (stack_top_dies)
|
|
return AS1 (fstp%z0,%y0);
|
|
else
|
|
return AS1 (fst%z0,%y0);
|
|
}
|
|
|
|
/* Handle other kinds of reads to the 387 */
|
|
|
|
if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE)
|
|
return (char *) output_move_const_single (operands);
|
|
|
|
if (STACK_TOP_P (operands[0]))
|
|
return AS1 (fld%z1,%y1);
|
|
|
|
/* Handle all SFmode moves not involving the 387 */
|
|
|
|
return (char *) singlemove_string (operands);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_58 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (STACK_REG_P (operands[1]))
|
|
{
|
|
rtx xops[3];
|
|
|
|
xops[0] = AT_SP (SFmode);
|
|
xops[1] = GEN_INT (8);
|
|
xops[2] = stack_pointer_rtx;
|
|
|
|
output_asm_insn (AS2 (sub%L2,%1,%2), xops);
|
|
|
|
if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
|
|
output_asm_insn (AS1 (fstp%Q0,%0), xops);
|
|
else
|
|
output_asm_insn (AS1 (fst%Q0,%0), xops);
|
|
|
|
RET;
|
|
}
|
|
else
|
|
return (char *) output_move_double (operands);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_59 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (STACK_TOP_P (operands[0]))
|
|
return AS1 (fxch,%1);
|
|
else
|
|
return AS1 (fxch,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_60 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
|
|
|
|
/* First handle a `pop' insn or a `fld %st(0)' */
|
|
|
|
if (STACK_TOP_P (operands[0]) && STACK_TOP_P (operands[1]))
|
|
{
|
|
if (stack_top_dies)
|
|
return AS1 (fstp,%y0);
|
|
else
|
|
return AS1 (fld,%y0);
|
|
}
|
|
|
|
/* Handle a transfer between the 387 and a 386 register */
|
|
|
|
if (STACK_TOP_P (operands[0]) && NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fld%z0,%y1));
|
|
RET;
|
|
}
|
|
|
|
if (STACK_TOP_P (operands[1]) && NON_STACK_REG_P (operands[0]))
|
|
{
|
|
output_to_reg (operands[0], stack_top_dies);
|
|
RET;
|
|
}
|
|
|
|
/* Handle other kinds of writes from the 387 */
|
|
|
|
if (STACK_TOP_P (operands[1]))
|
|
{
|
|
if (stack_top_dies)
|
|
return AS1 (fstp%z0,%y0);
|
|
else
|
|
return AS1 (fst%z0,%y0);
|
|
}
|
|
|
|
/* Handle other kinds of reads to the 387 */
|
|
|
|
if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE)
|
|
return (char *) output_move_const_single (operands);
|
|
|
|
if (STACK_TOP_P (operands[0]))
|
|
return AS1 (fld%z1,%y1);
|
|
|
|
/* Handle all DFmode moves not involving the 387 */
|
|
|
|
return (char *) output_move_double (operands);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_61 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (STACK_REG_P (operands[1]))
|
|
{
|
|
rtx xops[3];
|
|
|
|
xops[0] = AT_SP (SFmode);
|
|
xops[1] = GEN_INT (12);
|
|
xops[2] = stack_pointer_rtx;
|
|
|
|
output_asm_insn (AS2 (sub%L2,%1,%2), xops);
|
|
output_asm_insn (AS1 (fstp%T0,%0), xops);
|
|
if (! find_regno_note (insn, REG_DEAD, FIRST_STACK_REG))
|
|
output_asm_insn (AS1 (fld%T0,%0), xops);
|
|
|
|
RET;
|
|
}
|
|
else
|
|
return (char *) output_move_double (operands);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_62 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (STACK_TOP_P (operands[0]))
|
|
return AS1 (fxch,%1);
|
|
else
|
|
return AS1 (fxch,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_63 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
|
|
|
|
/* First handle a `pop' insn or a `fld %st(0)' */
|
|
|
|
if (STACK_TOP_P (operands[0]) && STACK_TOP_P (operands[1]))
|
|
{
|
|
if (stack_top_dies)
|
|
return AS1 (fstp,%y0);
|
|
else
|
|
return AS1 (fld,%y0);
|
|
}
|
|
|
|
/* Handle a transfer between the 387 and a 386 register */
|
|
|
|
if (STACK_TOP_P (operands[0]) && NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fld%z0,%y1));
|
|
RET;
|
|
}
|
|
|
|
if (STACK_TOP_P (operands[1]) && NON_STACK_REG_P (operands[0]))
|
|
{
|
|
output_to_reg (operands[0], stack_top_dies);
|
|
RET;
|
|
}
|
|
|
|
/* Handle other kinds of writes from the 387 */
|
|
|
|
if (STACK_TOP_P (operands[1]))
|
|
{
|
|
output_asm_insn (AS1 (fstp%z0,%y0), operands);
|
|
if (! stack_top_dies)
|
|
return AS1 (fld%z0,%y0);
|
|
|
|
RET;
|
|
}
|
|
|
|
/* Handle other kinds of reads to the 387 */
|
|
|
|
if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE)
|
|
return (char *) output_move_const_single (operands);
|
|
|
|
if (STACK_TOP_P (operands[0]))
|
|
return AS1 (fld%z1,%y1);
|
|
|
|
/* Handle all XFmode moves not involving the 387 */
|
|
|
|
return (char *) output_move_double (operands);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_64 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
return (char *) output_move_double (operands);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_65 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
return (char *) output_move_double (operands);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_66 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if ((TARGET_486 || REGNO (operands[0]) == 0)
|
|
&& REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1]))
|
|
{
|
|
rtx xops[2];
|
|
xops[0] = operands[0];
|
|
xops[1] = GEN_INT (0xffff);
|
|
output_asm_insn (AS2 (and%L0,%1,%k0), xops);
|
|
RET;
|
|
}
|
|
|
|
#ifdef INTEL_SYNTAX
|
|
return AS2 (movzx,%1,%0);
|
|
#else
|
|
return AS2 (movz%W0%L0,%1,%0);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_67 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if ((TARGET_486 || REGNO (operands[0]) == 0)
|
|
&& REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1]))
|
|
{
|
|
rtx xops[2];
|
|
xops[0] = operands[0];
|
|
xops[1] = GEN_INT (0xff);
|
|
output_asm_insn (AS2 (and%L0,%1,%k0), xops);
|
|
RET;
|
|
}
|
|
|
|
#ifdef INTEL_SYNTAX
|
|
return AS2 (movzx,%1,%0);
|
|
#else
|
|
return AS2 (movz%B0%W0,%1,%0);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_68 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if ((TARGET_486 || REGNO (operands[0]) == 0)
|
|
&& REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1]))
|
|
{
|
|
rtx xops[2];
|
|
xops[0] = operands[0];
|
|
xops[1] = GEN_INT (0xff);
|
|
output_asm_insn (AS2 (and%L0,%1,%k0), xops);
|
|
RET;
|
|
}
|
|
|
|
#ifdef INTEL_SYNTAX
|
|
return AS2 (movzx,%1,%0);
|
|
#else
|
|
return AS2 (movz%B0%L0,%1,%0);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_69 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
|
|
return AS2 (xor%L0,%0,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_70 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REGNO (operands[0]) == 0)
|
|
{
|
|
/* This used to be cwtl, but that extends HI to SI somehow. */
|
|
#ifdef INTEL_SYNTAX
|
|
return "cdq";
|
|
#else
|
|
return "cltd";
|
|
#endif
|
|
}
|
|
|
|
operands[1] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
|
|
output_asm_insn (AS2 (mov%L0,%0,%1), operands);
|
|
|
|
operands[0] = GEN_INT (31);
|
|
return AS2 (sar%L1,%0,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_71 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REGNO (operands[0]) == 0
|
|
&& REG_P (operands[1]) && REGNO (operands[1]) == 0)
|
|
#ifdef INTEL_SYNTAX
|
|
return "cwde";
|
|
#else
|
|
return "cwtl";
|
|
#endif
|
|
|
|
#ifdef INTEL_SYNTAX
|
|
return AS2 (movsx,%1,%0);
|
|
#else
|
|
return AS2 (movs%W0%L0,%1,%0);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_72 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REGNO (operands[0]) == 0
|
|
&& REG_P (operands[1]) && REGNO (operands[1]) == 0)
|
|
return "cbtw";
|
|
|
|
#ifdef INTEL_SYNTAX
|
|
return AS2 (movsx,%1,%0);
|
|
#else
|
|
return AS2 (movs%B0%W0,%1,%0);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_73 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
#ifdef INTEL_SYNTAX
|
|
return AS2 (movsx,%1,%0);
|
|
#else
|
|
return AS2 (movs%B0%L0,%1,%0);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_74 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
|
|
|
|
if (NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fld%z0,%y1));
|
|
RET;
|
|
}
|
|
|
|
if (NON_STACK_REG_P (operands[0]))
|
|
{
|
|
output_to_reg (operands[0], stack_top_dies);
|
|
RET;
|
|
}
|
|
|
|
if (STACK_TOP_P (operands[0]))
|
|
return AS1 (fld%z1,%y1);
|
|
|
|
if (GET_CODE (operands[0]) == MEM)
|
|
{
|
|
if (stack_top_dies)
|
|
return AS1 (fstp%z0,%y0);
|
|
else
|
|
return AS1 (fst%z0,%y0);
|
|
}
|
|
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_75 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
|
|
|
|
if (NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fld%z0,%y1));
|
|
RET;
|
|
}
|
|
|
|
if (NON_STACK_REG_P (operands[0]))
|
|
{
|
|
output_to_reg (operands[0], stack_top_dies);
|
|
RET;
|
|
}
|
|
|
|
if (STACK_TOP_P (operands[0]))
|
|
return AS1 (fld%z1,%y1);
|
|
|
|
if (GET_CODE (operands[0]) == MEM)
|
|
{
|
|
output_asm_insn (AS1 (fstp%z0,%y0), operands);
|
|
if (! stack_top_dies)
|
|
return AS1 (fld%z0,%y0);
|
|
RET;
|
|
}
|
|
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_76 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
|
|
|
|
if (NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fld%z0,%y1));
|
|
RET;
|
|
}
|
|
|
|
if (NON_STACK_REG_P (operands[0]))
|
|
{
|
|
output_to_reg (operands[0], stack_top_dies);
|
|
RET;
|
|
}
|
|
|
|
if (STACK_TOP_P (operands[0]))
|
|
return AS1 (fld%z1,%y1);
|
|
|
|
if (GET_CODE (operands[0]) == MEM)
|
|
{
|
|
output_asm_insn (AS1 (fstp%z0,%y0), operands);
|
|
if (! stack_top_dies)
|
|
return AS1 (fld%z0,%y0);
|
|
RET;
|
|
}
|
|
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_78 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
|
|
|
|
if (GET_CODE (operands[0]) == MEM)
|
|
{
|
|
if (stack_top_dies)
|
|
return AS1 (fstp%z0,%0);
|
|
else
|
|
return AS1 (fst%z0,%0);
|
|
}
|
|
else if (STACK_TOP_P (operands[0]))
|
|
{
|
|
output_asm_insn (AS1 (fstp%z2,%y2), operands);
|
|
return AS1 (fld%z2,%y2);
|
|
}
|
|
else
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_79 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
|
|
|
|
if (NON_STACK_REG_P (operands[0]))
|
|
{
|
|
if (stack_top_dies == 0)
|
|
{
|
|
output_asm_insn (AS1 (fld,%y1), operands);
|
|
stack_top_dies = 1;
|
|
}
|
|
output_to_reg (operands[0], stack_top_dies);
|
|
RET;
|
|
}
|
|
else if (GET_CODE (operands[0]) == MEM)
|
|
{
|
|
if (stack_top_dies)
|
|
return AS1 (fstp%z0,%0);
|
|
else
|
|
{
|
|
output_asm_insn (AS1 (fld,%y1), operands);
|
|
return AS1 (fstp%z0,%0);
|
|
}
|
|
}
|
|
else
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_80 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
int stack_top_dies = find_regno_note (insn, REG_DEAD, FIRST_STACK_REG) != 0;
|
|
|
|
if (NON_STACK_REG_P (operands[0]))
|
|
{
|
|
if (stack_top_dies == 0)
|
|
{
|
|
output_asm_insn (AS1 (fld,%y1), operands);
|
|
stack_top_dies = 1;
|
|
}
|
|
output_to_reg (operands[0], stack_top_dies);
|
|
RET;
|
|
}
|
|
else if (GET_CODE (operands[0]) == MEM)
|
|
{
|
|
if (stack_top_dies)
|
|
return AS1 (fstp%z0,%0);
|
|
else
|
|
{
|
|
output_asm_insn (AS1 (fld,%y1), operands);
|
|
return AS1 (fstp%z0,%0);
|
|
}
|
|
}
|
|
else
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_87 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_fix_trunc (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_88 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_fix_trunc (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_89 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_fix_trunc (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_93 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_fix_trunc (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_94 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_fix_trunc (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_95 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_fix_trunc (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_102 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fild%z0,%1));
|
|
RET;
|
|
}
|
|
else if (GET_CODE (operands[1]) == MEM)
|
|
return AS1 (fild%z1,%1);
|
|
else
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_103 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fild%z0,%1));
|
|
RET;
|
|
}
|
|
else if (GET_CODE (operands[1]) == MEM)
|
|
return AS1 (fild%z1,%1);
|
|
else
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_104 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fild%z0,%1));
|
|
RET;
|
|
}
|
|
else if (GET_CODE (operands[1]) == MEM)
|
|
return AS1 (fild%z1,%1);
|
|
else
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_105 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fild%z0,%1));
|
|
RET;
|
|
}
|
|
else if (GET_CODE (operands[1]) == MEM)
|
|
return AS1 (fild%z1,%1);
|
|
else
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_106 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fild%z0,%1));
|
|
RET;
|
|
}
|
|
else if (GET_CODE (operands[1]) == MEM)
|
|
return AS1 (fild%z1,%1);
|
|
else
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_107 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (NON_STACK_REG_P (operands[1]))
|
|
{
|
|
output_op_from_reg (operands[1], AS1 (fild%z0,%1));
|
|
RET;
|
|
}
|
|
else if (GET_CODE (operands[1]) == MEM)
|
|
return AS1 (fild%z1,%1);
|
|
else
|
|
abort ();
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_108 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx low[3], high[3];
|
|
|
|
CC_STATUS_INIT;
|
|
|
|
split_di (operands, 3, low, high);
|
|
|
|
if (GET_CODE (low[2]) != CONST_INT || INTVAL (low[2]) != 0)
|
|
{
|
|
output_asm_insn (AS2 (add%L0,%2,%0), low);
|
|
output_asm_insn (AS2 (adc%L0,%2,%0), high);
|
|
}
|
|
else
|
|
output_asm_insn (AS2 (add%L0,%2,%0), high);
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_109 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[0]) && REGNO (operands[0]) != REGNO (operands[1]))
|
|
{
|
|
if (REG_P (operands[2]) && REGNO (operands[0]) == REGNO (operands[2]))
|
|
return AS2 (add%L0,%1,%0);
|
|
|
|
if (! TARGET_486 || ! REG_P (operands[2]))
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
if (operands[2] == stack_pointer_rtx)
|
|
{
|
|
rtx temp;
|
|
|
|
temp = operands[1];
|
|
operands[1] = operands[2];
|
|
operands[2] = temp;
|
|
}
|
|
if (operands[2] != stack_pointer_rtx)
|
|
{
|
|
operands[1] = SET_SRC (PATTERN (insn));
|
|
return AS2 (lea%L0,%a1,%0);
|
|
}
|
|
}
|
|
|
|
output_asm_insn (AS2 (mov%L0,%1,%0), operands);
|
|
}
|
|
|
|
if (operands[2] == const1_rtx)
|
|
return AS1 (inc%L0,%0);
|
|
|
|
if (operands[2] == constm1_rtx)
|
|
return AS1 (dec%L0,%0);
|
|
|
|
return AS2 (add%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_110 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
/* ??? what about offsettable memory references? */
|
|
if (QI_REG_P (operands[0])
|
|
&& GET_CODE (operands[2]) == CONST_INT
|
|
&& (INTVAL (operands[2]) & 0xff) == 0)
|
|
{
|
|
int byteval = (INTVAL (operands[2]) >> 8) & 0xff;
|
|
CC_STATUS_INIT;
|
|
|
|
if (byteval == 1)
|
|
return AS1 (inc%B0,%h0);
|
|
else if (byteval == 255)
|
|
return AS1 (dec%B0,%h0);
|
|
|
|
operands[2] = GEN_INT (byteval);
|
|
return AS2 (add%B0,%2,%h0);
|
|
}
|
|
|
|
if (operands[2] == const1_rtx)
|
|
return AS1 (inc%W0,%0);
|
|
|
|
if (operands[2] == constm1_rtx
|
|
|| (GET_CODE (operands[2]) == CONST_INT
|
|
&& INTVAL (operands[2]) == 65535))
|
|
return AS1 (dec%W0,%0);
|
|
|
|
return AS2 (add%W0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_111 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (operands[2] == const1_rtx)
|
|
return AS1 (inc%B0,%0);
|
|
|
|
if (operands[2] == constm1_rtx
|
|
|| (GET_CODE (operands[2]) == CONST_INT
|
|
&& INTVAL (operands[2]) == 255))
|
|
return AS1 (dec%B0,%0);
|
|
|
|
return AS2 (add%B0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_112 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
CC_STATUS_INIT;
|
|
/* Adding a constant to a register is faster with an add. */
|
|
/* ??? can this ever happen? */
|
|
if (GET_CODE (operands[1]) == PLUS
|
|
&& GET_CODE (XEXP (operands[1], 1)) == CONST_INT
|
|
&& rtx_equal_p (operands[0], XEXP (operands[1], 0)))
|
|
{
|
|
operands[1] = XEXP (operands[1], 1);
|
|
|
|
if (operands[1] == const1_rtx)
|
|
return AS1 (inc%L0,%0);
|
|
|
|
if (operands[1] == constm1_rtx)
|
|
return AS1 (dec%L0,%0);
|
|
|
|
return AS2 (add%L0,%1,%0);
|
|
}
|
|
return AS2 (lea%L0,%a1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_116 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx low[3], high[3];
|
|
|
|
CC_STATUS_INIT;
|
|
|
|
split_di (operands, 3, low, high);
|
|
|
|
if (GET_CODE (low[2]) != CONST_INT || INTVAL (low[2]) != 0)
|
|
{
|
|
output_asm_insn (AS2 (sub%L0,%2,%0), low);
|
|
output_asm_insn (AS2 (sbb%L0,%2,%0), high);
|
|
}
|
|
else
|
|
output_asm_insn (AS2 (sub%L0,%2,%0), high);
|
|
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_117 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return AS2 (sub%L0,%2,%0);
|
|
}
|
|
|
|
static char *
|
|
output_118 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return AS2 (sub%W0,%2,%0);
|
|
}
|
|
|
|
static char *
|
|
output_119 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return AS2 (sub%B0,%2,%0);
|
|
}
|
|
|
|
static char *
|
|
output_123 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return AS2 (imul%W0,%2,%0);
|
|
}
|
|
|
|
static char *
|
|
output_124 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[1]) == REG
|
|
&& REGNO (operands[1]) == REGNO (operands[0])
|
|
&& (GET_CODE (operands[2]) == MEM || GET_CODE (operands[2]) == REG))
|
|
/* Assembler has weird restrictions. */
|
|
return AS2 (imul%W0,%2,%0);
|
|
return AS3 (imul%W0,%2,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_125 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return AS2 (imul%L0,%2,%0);
|
|
}
|
|
|
|
static char *
|
|
output_126 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[1]) == REG
|
|
&& REGNO (operands[1]) == REGNO (operands[0])
|
|
&& (GET_CODE (operands[2]) == MEM || GET_CODE (operands[2]) == REG))
|
|
/* Assembler has weird restrictions. */
|
|
return AS2 (imul%L0,%2,%0);
|
|
return AS3 (imul%L0,%2,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_139 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
#ifdef INTEL_SYNTAX
|
|
output_asm_insn ("cdq", operands);
|
|
#else
|
|
output_asm_insn ("cltd", operands);
|
|
#endif
|
|
return AS1 (idiv%L0,%2);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_141 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
output_asm_insn (AS2 (xor%L3,%3,%3), operands);
|
|
return AS1 (div%L0,%2);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_142 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
output_asm_insn (AS2 (xor%W0,%3,%3), operands);
|
|
return AS1 (div%W0,%2);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_143 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[2]) == CONST_INT
|
|
&& ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
|
|
{
|
|
if (INTVAL (operands[2]) == 0xffff && REG_P (operands[0])
|
|
&& (! REG_P (operands[1])
|
|
|| REGNO (operands[0]) != 0 || REGNO (operands[1]) != 0)
|
|
&& (! TARGET_486 || ! rtx_equal_p (operands[0], operands[1])))
|
|
{
|
|
/* ??? tege: Should forget CC_STATUS only if we clobber a
|
|
remembered operand. Fix that later. */
|
|
CC_STATUS_INIT;
|
|
#ifdef INTEL_SYNTAX
|
|
return AS2 (movzx,%w1,%0);
|
|
#else
|
|
return AS2 (movz%W0%L0,%w1,%0);
|
|
#endif
|
|
}
|
|
|
|
if (INTVAL (operands[2]) == 0xff && REG_P (operands[0])
|
|
&& !(REG_P (operands[1]) && NON_QI_REG_P (operands[1]))
|
|
&& (! REG_P (operands[1])
|
|
|| REGNO (operands[0]) != 0 || REGNO (operands[1]) != 0)
|
|
&& (! TARGET_486 || ! rtx_equal_p (operands[0], operands[1])))
|
|
{
|
|
/* ??? tege: Should forget CC_STATUS only if we clobber a
|
|
remembered operand. Fix that later. */
|
|
CC_STATUS_INIT;
|
|
#ifdef INTEL_SYNTAX
|
|
return AS2 (movzx,%b1,%0);
|
|
#else
|
|
return AS2 (movz%B0%L0,%b1,%0);
|
|
#endif
|
|
}
|
|
|
|
if (QI_REG_P (operands[0]) && ~(INTVAL (operands[2]) | 0xff) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
if (INTVAL (operands[2]) == 0xffffff00)
|
|
{
|
|
operands[2] = const0_rtx;
|
|
return AS2 (mov%B0,%2,%b0);
|
|
}
|
|
|
|
operands[2] = GEN_INT (INTVAL (operands[2]) & 0xff);
|
|
return AS2 (and%B0,%2,%b0);
|
|
}
|
|
|
|
if (QI_REG_P (operands[0]) && ~(INTVAL (operands[2]) | 0xff00) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
if (INTVAL (operands[2]) == 0xffff00ff)
|
|
{
|
|
operands[2] = const0_rtx;
|
|
return AS2 (mov%B0,%2,%h0);
|
|
}
|
|
|
|
operands[2] = GEN_INT ((INTVAL (operands[2]) >> 8) & 0xff);
|
|
return AS2 (and%B0,%2,%h0);
|
|
}
|
|
|
|
if (GET_CODE (operands[0]) == MEM && INTVAL (operands[2]) == 0xffff0000)
|
|
{
|
|
operands[2] = const0_rtx;
|
|
return AS2 (mov%W0,%2,%w0);
|
|
}
|
|
}
|
|
|
|
return AS2 (and%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_144 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[2]) == CONST_INT
|
|
&& ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
|
|
{
|
|
/* Can we ignore the upper byte? */
|
|
if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
|
|
&& (INTVAL (operands[2]) & 0xff00) == 0xff00)
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
if ((INTVAL (operands[2]) & 0xff) == 0)
|
|
{
|
|
operands[2] = const0_rtx;
|
|
return AS2 (mov%B0,%2,%b0);
|
|
}
|
|
|
|
operands[2] = GEN_INT (INTVAL (operands[2]) & 0xff);
|
|
return AS2 (and%B0,%2,%b0);
|
|
}
|
|
|
|
/* Can we ignore the lower byte? */
|
|
/* ??? what about offsettable memory references? */
|
|
if (QI_REG_P (operands[0]) && (INTVAL (operands[2]) & 0xff) == 0xff)
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
if ((INTVAL (operands[2]) & 0xff00) == 0)
|
|
{
|
|
operands[2] = const0_rtx;
|
|
return AS2 (mov%B0,%2,%h0);
|
|
}
|
|
|
|
operands[2] = GEN_INT ((INTVAL (operands[2]) >> 8) & 0xff);
|
|
return AS2 (and%B0,%2,%h0);
|
|
}
|
|
}
|
|
|
|
return AS2 (and%W0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_145 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return AS2 (and%B0,%2,%0);
|
|
}
|
|
|
|
static char *
|
|
output_146 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[2]) == CONST_INT
|
|
&& ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
|
|
{
|
|
if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
|
|
&& (INTVAL (operands[2]) & ~0xff) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
if (INTVAL (operands[2]) == 0xff)
|
|
return AS2 (mov%B0,%2,%b0);
|
|
|
|
return AS2 (or%B0,%2,%b0);
|
|
}
|
|
|
|
if (QI_REG_P (operands[0]) && (INTVAL (operands[2]) & ~0xff00) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
operands[2] = GEN_INT (INTVAL (operands[2]) >> 8);
|
|
|
|
if (INTVAL (operands[2]) == 0xff)
|
|
return AS2 (mov%B0,%2,%h0);
|
|
|
|
return AS2 (or%B0,%2,%h0);
|
|
}
|
|
}
|
|
|
|
return AS2 (or%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_147 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[2]) == CONST_INT
|
|
&& ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
|
|
{
|
|
/* Can we ignore the upper byte? */
|
|
if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
|
|
&& (INTVAL (operands[2]) & 0xff00) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
if (INTVAL (operands[2]) & 0xffff0000)
|
|
operands[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);
|
|
|
|
if (INTVAL (operands[2]) == 0xff)
|
|
return AS2 (mov%B0,%2,%b0);
|
|
|
|
return AS2 (or%B0,%2,%b0);
|
|
}
|
|
|
|
/* Can we ignore the lower byte? */
|
|
/* ??? what about offsettable memory references? */
|
|
if (QI_REG_P (operands[0])
|
|
&& (INTVAL (operands[2]) & 0xff) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
operands[2] = GEN_INT ((INTVAL (operands[2]) >> 8) & 0xff);
|
|
|
|
if (INTVAL (operands[2]) == 0xff)
|
|
return AS2 (mov%B0,%2,%h0);
|
|
|
|
return AS2 (or%B0,%2,%h0);
|
|
}
|
|
}
|
|
|
|
return AS2 (or%W0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_148 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return AS2 (or%B0,%2,%0);
|
|
}
|
|
|
|
static char *
|
|
output_149 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[2]) == CONST_INT
|
|
&& ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
|
|
{
|
|
if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
|
|
&& (INTVAL (operands[2]) & ~0xff) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
if (INTVAL (operands[2]) == 0xff)
|
|
return AS1 (not%B0,%b0);
|
|
|
|
return AS2 (xor%B0,%2,%b0);
|
|
}
|
|
|
|
if (QI_REG_P (operands[0]) && (INTVAL (operands[2]) & ~0xff00) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
operands[2] = GEN_INT (INTVAL (operands[2]) >> 8);
|
|
|
|
if (INTVAL (operands[2]) == 0xff)
|
|
return AS1 (not%B0,%h0);
|
|
|
|
return AS2 (xor%B0,%2,%h0);
|
|
}
|
|
}
|
|
|
|
return AS2 (xor%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_150 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[2]) == CONST_INT
|
|
&& ! (GET_CODE (operands[0]) == MEM && MEM_VOLATILE_P (operands[0])))
|
|
{
|
|
/* Can we ignore the upper byte? */
|
|
if ((! REG_P (operands[0]) || QI_REG_P (operands[0]))
|
|
&& (INTVAL (operands[2]) & 0xff00) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
if (INTVAL (operands[2]) & 0xffff0000)
|
|
operands[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);
|
|
|
|
if (INTVAL (operands[2]) == 0xff)
|
|
return AS1 (not%B0,%b0);
|
|
|
|
return AS2 (xor%B0,%2,%b0);
|
|
}
|
|
|
|
/* Can we ignore the lower byte? */
|
|
/* ??? what about offsettable memory references? */
|
|
if (QI_REG_P (operands[0])
|
|
&& (INTVAL (operands[2]) & 0xff) == 0)
|
|
{
|
|
CC_STATUS_INIT;
|
|
operands[2] = GEN_INT ((INTVAL (operands[2]) >> 8) & 0xff);
|
|
|
|
if (INTVAL (operands[2]) == 0xff)
|
|
return AS1 (not%B0,%h0);
|
|
|
|
return AS2 (xor%B0,%2,%h0);
|
|
}
|
|
}
|
|
|
|
return AS2 (xor%W0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_151 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return AS2 (xor%B0,%2,%0);
|
|
}
|
|
|
|
static char *
|
|
output_152 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[2], low[1], high[1];
|
|
|
|
CC_STATUS_INIT;
|
|
|
|
split_di (operands, 1, low, high);
|
|
xops[0] = const0_rtx;
|
|
xops[1] = high[0];
|
|
|
|
output_asm_insn (AS1 (neg%L0,%0), low);
|
|
output_asm_insn (AS2 (adc%L1,%0,%1), xops);
|
|
output_asm_insn (AS1 (neg%L0,%0), high);
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_182 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[4], low[1], high[1];
|
|
|
|
CC_STATUS_INIT;
|
|
|
|
split_di (operands, 1, low, high);
|
|
xops[0] = operands[2];
|
|
xops[1] = const1_rtx;
|
|
xops[2] = low[0];
|
|
xops[3] = high[0];
|
|
|
|
if (INTVAL (xops[0]) > 31)
|
|
{
|
|
output_asm_insn (AS2 (mov%L3,%2,%3), xops); /* Fast shift by 32 */
|
|
output_asm_insn (AS2 (xor%L2,%2,%2), xops);
|
|
|
|
if (INTVAL (xops[0]) > 32)
|
|
{
|
|
xops[0] = GEN_INT (INTVAL (xops[0]) - 32);
|
|
output_asm_insn (AS2 (sal%L3,%0,%3), xops); /* Remaining shift */
|
|
}
|
|
}
|
|
else
|
|
{
|
|
output_asm_insn (AS3 (shld%L3,%0,%2,%3), xops);
|
|
output_asm_insn (AS2 (sal%L2,%0,%2), xops);
|
|
}
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_183 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[4], low[1], high[1];
|
|
|
|
CC_STATUS_INIT;
|
|
|
|
split_di (operands, 1, low, high);
|
|
xops[0] = operands[2];
|
|
xops[1] = const1_rtx;
|
|
xops[2] = low[0];
|
|
xops[3] = high[0];
|
|
|
|
output_asm_insn (AS2 (ror%B0,%1,%0), xops); /* shift count / 2 */
|
|
|
|
output_asm_insn (AS3_SHIFT_DOUBLE (shld%L3,%0,%2,%3), xops);
|
|
output_asm_insn (AS2 (sal%L2,%0,%2), xops);
|
|
output_asm_insn (AS3_SHIFT_DOUBLE (shld%L3,%0,%2,%3), xops);
|
|
output_asm_insn (AS2 (sal%L2,%0,%2), xops);
|
|
|
|
xops[1] = GEN_INT (7); /* shift count & 1 */
|
|
|
|
output_asm_insn (AS2 (shr%B0,%1,%0), xops);
|
|
|
|
output_asm_insn (AS3_SHIFT_DOUBLE (shld%L3,%0,%2,%3), xops);
|
|
output_asm_insn (AS2 (sal%L2,%0,%2), xops);
|
|
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_184 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[0]) && REGNO (operands[0]) != REGNO (operands[1]))
|
|
{
|
|
if (TARGET_486 && INTVAL (operands[2]) == 1)
|
|
{
|
|
output_asm_insn (AS2 (mov%L0,%1,%0), operands);
|
|
return AS2 (add%L0,%1,%0);
|
|
}
|
|
else
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
if (operands[1] == stack_pointer_rtx)
|
|
{
|
|
output_asm_insn (AS2 (mov%L0,%1,%0), operands);
|
|
operands[1] = operands[0];
|
|
}
|
|
operands[1] = gen_rtx (MULT, SImode, operands[1],
|
|
GEN_INT (1 << INTVAL (operands[2])));
|
|
return AS2 (lea%L0,%a1,%0);
|
|
}
|
|
}
|
|
|
|
if (REG_P (operands[2]))
|
|
return AS2 (sal%L0,%b2,%0);
|
|
|
|
if (REG_P (operands[0]) && operands[2] == const1_rtx)
|
|
return AS2 (add%L0,%0,%0);
|
|
|
|
return AS2 (sal%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_185 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (sal%W0,%b2,%0);
|
|
|
|
if (REG_P (operands[0]) && operands[2] == const1_rtx)
|
|
return AS2 (add%W0,%0,%0);
|
|
|
|
return AS2 (sal%W0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_186 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (sal%B0,%b2,%0);
|
|
|
|
if (REG_P (operands[0]) && operands[2] == const1_rtx)
|
|
return AS2 (add%B0,%0,%0);
|
|
|
|
return AS2 (sal%B0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_188 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[4], low[1], high[1];
|
|
|
|
CC_STATUS_INIT;
|
|
|
|
split_di (operands, 1, low, high);
|
|
xops[0] = operands[2];
|
|
xops[1] = const1_rtx;
|
|
xops[2] = low[0];
|
|
xops[3] = high[0];
|
|
|
|
if (INTVAL (xops[0]) > 31)
|
|
{
|
|
xops[1] = GEN_INT (31);
|
|
output_asm_insn (AS2 (mov%L2,%3,%2), xops);
|
|
output_asm_insn (AS2 (sar%L3,%1,%3), xops); /* shift by 32 */
|
|
|
|
if (INTVAL (xops[0]) > 32)
|
|
{
|
|
xops[0] = GEN_INT (INTVAL (xops[0]) - 32);
|
|
output_asm_insn (AS2 (sar%L2,%0,%2), xops); /* Remaining shift */
|
|
}
|
|
}
|
|
else
|
|
{
|
|
output_asm_insn (AS3 (shrd%L2,%0,%3,%2), xops);
|
|
output_asm_insn (AS2 (sar%L3,%0,%3), xops);
|
|
}
|
|
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_189 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[4], low[1], high[1];
|
|
|
|
CC_STATUS_INIT;
|
|
|
|
split_di (operands, 1, low, high);
|
|
xops[0] = operands[2];
|
|
xops[1] = const1_rtx;
|
|
xops[2] = low[0];
|
|
xops[3] = high[0];
|
|
|
|
output_asm_insn (AS2 (ror%B0,%1,%0), xops); /* shift count / 2 */
|
|
|
|
output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
|
|
output_asm_insn (AS2 (sar%L3,%0,%3), xops);
|
|
output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
|
|
output_asm_insn (AS2 (sar%L3,%0,%3), xops);
|
|
|
|
xops[1] = GEN_INT (7); /* shift count & 1 */
|
|
|
|
output_asm_insn (AS2 (shr%B0,%1,%0), xops);
|
|
|
|
output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
|
|
output_asm_insn (AS2 (sar%L3,%0,%3), xops);
|
|
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_190 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (sar%L0,%b2,%0);
|
|
else
|
|
return AS2 (sar%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_191 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (sar%W0,%b2,%0);
|
|
else
|
|
return AS2 (sar%W0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_192 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (sar%B0,%b2,%0);
|
|
else
|
|
return AS2 (sar%B0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_194 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[4], low[1], high[1];
|
|
|
|
CC_STATUS_INIT;
|
|
|
|
split_di (operands, 1, low, high);
|
|
xops[0] = operands[2];
|
|
xops[1] = const1_rtx;
|
|
xops[2] = low[0];
|
|
xops[3] = high[0];
|
|
|
|
if (INTVAL (xops[0]) > 31)
|
|
{
|
|
output_asm_insn (AS2 (mov%L2,%3,%2), xops); /* Fast shift by 32 */
|
|
output_asm_insn (AS2 (xor%L3,%3,%3), xops);
|
|
|
|
if (INTVAL (xops[0]) > 32)
|
|
{
|
|
xops[0] = GEN_INT (INTVAL (xops[0]) - 32);
|
|
output_asm_insn (AS2 (shr%L2,%0,%2), xops); /* Remaining shift */
|
|
}
|
|
}
|
|
else
|
|
{
|
|
output_asm_insn (AS3 (shrd%L2,%0,%3,%2), xops);
|
|
output_asm_insn (AS2 (shr%L3,%0,%3), xops);
|
|
}
|
|
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_195 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[4], low[1], high[1];
|
|
|
|
CC_STATUS_INIT;
|
|
|
|
split_di (operands, 1, low, high);
|
|
xops[0] = operands[2];
|
|
xops[1] = const1_rtx;
|
|
xops[2] = low[0];
|
|
xops[3] = high[0];
|
|
|
|
output_asm_insn (AS2 (ror%B0,%1,%0), xops); /* shift count / 2 */
|
|
|
|
output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
|
|
output_asm_insn (AS2 (shr%L3,%0,%3), xops);
|
|
output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
|
|
output_asm_insn (AS2 (shr%L3,%0,%3), xops);
|
|
|
|
xops[1] = GEN_INT (7); /* shift count & 1 */
|
|
|
|
output_asm_insn (AS2 (shr%B0,%1,%0), xops);
|
|
|
|
output_asm_insn (AS3_SHIFT_DOUBLE (shrd%L2,%0,%3,%2), xops);
|
|
output_asm_insn (AS2 (shr%L3,%0,%3), xops);
|
|
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_196 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (shr%L0,%b2,%0);
|
|
else
|
|
return AS2 (shr%L0,%2,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_197 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (shr%W0,%b2,%0);
|
|
else
|
|
return AS2 (shr%W0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_198 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (shr%B0,%b2,%0);
|
|
else
|
|
return AS2 (shr%B0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_199 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (rol%L0,%b2,%0);
|
|
else
|
|
return AS2 (rol%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_200 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (rol%W0,%b2,%0);
|
|
else
|
|
return AS2 (rol%W0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_201 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (rol%B0,%b2,%0);
|
|
else
|
|
return AS2 (rol%B0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_202 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (ror%L0,%b2,%0);
|
|
else
|
|
return AS2 (ror%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_203 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (ror%W0,%b2,%0);
|
|
else
|
|
return AS2 (ror%W0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_204 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (REG_P (operands[2]))
|
|
return AS2 (ror%B0,%b2,%0);
|
|
else
|
|
return AS2 (ror%B0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_205 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
if (INTVAL (operands[3]) == 1)
|
|
return AS2 (bts%L0,%2,%0);
|
|
else
|
|
return AS2 (btr%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_206 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
return AS2 (btc%L0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_207 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
return AS2 (btc%L0,%2,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_208 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
cc_status.flags |= CC_Z_IN_NOT_C;
|
|
return AS2 (bt%L0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_209 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
unsigned int mask;
|
|
|
|
mask = ((1 << INTVAL (operands[1])) - 1) << INTVAL (operands[2]);
|
|
operands[1] = GEN_INT (mask);
|
|
|
|
if (QI_REG_P (operands[0]))
|
|
{
|
|
if ((mask & ~0xff) == 0)
|
|
{
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
|
|
if ((mask & ~0xff00) == 0)
|
|
{
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
operands[1] = GEN_INT (mask >> 8);
|
|
return AS2 (test%B0,%1,%h0);
|
|
}
|
|
}
|
|
|
|
return AS2 (test%L0,%1,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_210 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
unsigned int mask;
|
|
|
|
mask = ((1 << INTVAL (operands[1])) - 1) << INTVAL (operands[2]);
|
|
operands[1] = GEN_INT (mask);
|
|
|
|
if (! REG_P (operands[0]) || QI_REG_P (operands[0]))
|
|
{
|
|
if ((mask & ~0xff) == 0)
|
|
{
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
|
|
if ((mask & ~0xff00) == 0)
|
|
{
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
operands[1] = GEN_INT (mask >> 8);
|
|
|
|
if (QI_REG_P (operands[0]))
|
|
return AS2 (test%B0,%1,%h0);
|
|
else
|
|
{
|
|
operands[0] = adj_offsettable_operand (operands[0], 1);
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
}
|
|
|
|
if (GET_CODE (operands[0]) == MEM && (mask & ~0xff0000) == 0)
|
|
{
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
operands[1] = GEN_INT (mask >> 16);
|
|
operands[0] = adj_offsettable_operand (operands[0], 2);
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
|
|
if (GET_CODE (operands[0]) == MEM && (mask & ~0xff000000) == 0)
|
|
{
|
|
cc_status.flags |= CC_NOT_NEGATIVE;
|
|
operands[1] = GEN_INT (mask >> 24);
|
|
operands[0] = adj_offsettable_operand (operands[0], 3);
|
|
return AS2 (test%B0,%1,%b0);
|
|
}
|
|
}
|
|
|
|
if (CONSTANT_P (operands[1]) || GET_CODE (operands[0]) == MEM)
|
|
return AS2 (test%L0,%1,%0);
|
|
|
|
return AS2 (test%L1,%0,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_212 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (cc_prev_status.flags & CC_Z_IN_NOT_C)
|
|
return AS1 (setnb,%0);
|
|
else
|
|
return AS1 (sete,%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_214 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (cc_prev_status.flags & CC_Z_IN_NOT_C)
|
|
return AS1 (setb,%0);
|
|
else
|
|
return AS1 (setne,%0);
|
|
}
|
|
|
|
}
|
|
|
|
static char *
|
|
output_216 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (sete,%0);
|
|
|
|
OUTPUT_JUMP ("setg %0", "seta %0", NULL_PTR);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_218 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return "seta %0";
|
|
}
|
|
|
|
static char *
|
|
output_220 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (sete,%0);
|
|
|
|
OUTPUT_JUMP ("setl %0", "setb %0", "sets %0");
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_222 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return "setb %0";
|
|
}
|
|
|
|
static char *
|
|
output_224 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (sete,%0);
|
|
|
|
OUTPUT_JUMP ("setge %0", "setae %0", "setns %0");
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_226 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return "setae %0";
|
|
}
|
|
|
|
static char *
|
|
output_228 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (setb,%0);
|
|
|
|
OUTPUT_JUMP ("setle %0", "setbe %0", NULL_PTR);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_230 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return "setbe %0";
|
|
}
|
|
|
|
static char *
|
|
output_232 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (cc_prev_status.flags & CC_Z_IN_NOT_C)
|
|
return "jnc %l0";
|
|
else
|
|
return "je %l0";
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_234 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (cc_prev_status.flags & CC_Z_IN_NOT_C)
|
|
return "jc %l0";
|
|
else
|
|
return "jne %l0";
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_236 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (je,%l0);
|
|
|
|
OUTPUT_JUMP ("jg %l0", "ja %l0", NULL_PTR);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_240 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (je,%l0);
|
|
|
|
OUTPUT_JUMP ("jl %l0", "jb %l0", "js %l0");
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_244 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (je,%l0);
|
|
|
|
OUTPUT_JUMP ("jge %l0", "jae %l0", "jns %l0");
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_248 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (jb,%l0);
|
|
|
|
OUTPUT_JUMP ("jle %l0", "jbe %l0", NULL_PTR);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_251 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (cc_prev_status.flags & CC_Z_IN_NOT_C)
|
|
return "jc %l0";
|
|
else
|
|
return "jne %l0";
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_252 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (cc_prev_status.flags & CC_Z_IN_NOT_C)
|
|
return "jnc %l0";
|
|
else
|
|
return "je %l0";
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_253 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (jne,%l0);
|
|
|
|
OUTPUT_JUMP ("jle %l0", "jbe %l0", NULL_PTR);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_255 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (jne,%l0);
|
|
|
|
OUTPUT_JUMP ("jge %l0", "jae %l0", "jns %l0");
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_257 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (jne,%l0);
|
|
|
|
OUTPUT_JUMP ("jl %l0", "jb %l0", "js %l0");
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_259 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (TARGET_IEEE_FP && (cc_prev_status.flags & CC_IN_80387))
|
|
return AS1 (jae,%l0);
|
|
|
|
OUTPUT_JUMP ("jg %l0", "ja %l0", NULL_PTR);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_262 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
return AS1 (jmp,%*%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_264 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[4];
|
|
|
|
xops[0] = operands[0];
|
|
xops[1] = operands[1];
|
|
xops[2] = operands[2];
|
|
xops[3] = pic_offset_table_rtx;
|
|
|
|
output_asm_insn (AS2 (mov%L2,%3,%2), xops);
|
|
output_asm_insn ("sub%L2 %l1@GOTOFF(%3,%0,4),%2", xops);
|
|
output_asm_insn (AS1 (jmp,%*%2), xops);
|
|
ASM_OUTPUT_ALIGN_CODE (asm_out_file);
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_265 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
CC_STATUS_INIT;
|
|
|
|
return AS1 (jmp,%*%0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_267 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[0]) == MEM
|
|
&& ! CONSTANT_ADDRESS_P (XEXP (operands[0], 0)))
|
|
{
|
|
operands[0] = XEXP (operands[0], 0);
|
|
return AS1 (call,%*%0);
|
|
}
|
|
else
|
|
return AS1 (call,%P0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_270 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[0]) == MEM
|
|
&& ! CONSTANT_ADDRESS_P (XEXP (operands[0], 0)))
|
|
{
|
|
operands[0] = XEXP (operands[0], 0);
|
|
return AS1 (call,%*%0);
|
|
}
|
|
else
|
|
return AS1 (call,%P0);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_273 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[1]) == MEM
|
|
&& ! CONSTANT_ADDRESS_P (XEXP (operands[1], 0)))
|
|
{
|
|
operands[1] = XEXP (operands[1], 0);
|
|
output_asm_insn (AS1 (call,%*%1), operands);
|
|
}
|
|
else
|
|
output_asm_insn (AS1 (call,%P1), operands);
|
|
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_276 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
if (GET_CODE (operands[1]) == MEM
|
|
&& ! CONSTANT_ADDRESS_P (XEXP (operands[1], 0)))
|
|
{
|
|
operands[1] = XEXP (operands[1], 0);
|
|
output_asm_insn (AS1 (call,%*%1), operands);
|
|
}
|
|
else
|
|
output_asm_insn (AS1 (call,%P1), operands);
|
|
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_279 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx addr = operands[1];
|
|
|
|
if (GET_CODE (operands[0]) == MEM
|
|
&& ! CONSTANT_ADDRESS_P (XEXP (operands[0], 0)))
|
|
{
|
|
operands[0] = XEXP (operands[0], 0);
|
|
output_asm_insn (AS1 (call,%*%0), operands);
|
|
}
|
|
else
|
|
output_asm_insn (AS1 (call,%P0), operands);
|
|
|
|
operands[2] = gen_rtx (REG, SImode, 0);
|
|
output_asm_insn (AS2 (mov%L2,%2,%1), operands);
|
|
|
|
operands[2] = gen_rtx (REG, SImode, 1);
|
|
operands[1] = adj_offsettable_operand (addr, 4);
|
|
output_asm_insn (AS2 (mov%L2,%2,%1), operands);
|
|
|
|
operands[1] = adj_offsettable_operand (addr, 8);
|
|
return AS1 (fnsave,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_280 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx addr = operands[1];
|
|
|
|
output_asm_insn (AS1 (call,%P0), operands);
|
|
|
|
operands[2] = gen_rtx (REG, SImode, 0);
|
|
output_asm_insn (AS2 (mov%L2,%2,%1), operands);
|
|
|
|
operands[2] = gen_rtx (REG, SImode, 1);
|
|
operands[1] = adj_offsettable_operand (addr, 4);
|
|
output_asm_insn (AS2 (mov%L2,%2,%1), operands);
|
|
|
|
operands[1] = adj_offsettable_operand (addr, 8);
|
|
return AS1 (fnsave,%1);
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_283 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
function_epilogue (asm_out_file, get_frame_size ());
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_286 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[2];
|
|
|
|
output_asm_insn ("cld", operands);
|
|
if (GET_CODE (operands[2]) == CONST_INT)
|
|
{
|
|
if (INTVAL (operands[2]) & ~0x03)
|
|
{
|
|
xops[0] = GEN_INT ((INTVAL (operands[2]) >> 2) & 0x3fffffff);
|
|
xops[1] = operands[4];
|
|
|
|
output_asm_insn (AS2 (mov%L1,%0,%1), xops);
|
|
#ifdef INTEL_SYNTAX
|
|
output_asm_insn ("rep movsd", xops);
|
|
#else
|
|
output_asm_insn ("rep\n\tmovsl", xops);
|
|
#endif
|
|
}
|
|
if (INTVAL (operands[2]) & 0x02)
|
|
output_asm_insn ("movsw", operands);
|
|
if (INTVAL (operands[2]) & 0x01)
|
|
output_asm_insn ("movsb", operands);
|
|
}
|
|
else
|
|
abort ();
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_288 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[4], label;
|
|
|
|
label = gen_label_rtx ();
|
|
|
|
output_asm_insn ("cld", operands);
|
|
output_asm_insn (AS2 (xor%L0,%0,%0), operands);
|
|
output_asm_insn ("repz\n\tcmps%B2", operands);
|
|
output_asm_insn ("je %l0", &label);
|
|
|
|
xops[0] = operands[0];
|
|
xops[1] = gen_rtx (MEM, QImode,
|
|
gen_rtx (PLUS, SImode, operands[1], constm1_rtx));
|
|
xops[2] = gen_rtx (MEM, QImode,
|
|
gen_rtx (PLUS, SImode, operands[2], constm1_rtx));
|
|
xops[3] = operands[3];
|
|
|
|
output_asm_insn (AS2 (movz%B1%L0,%1,%0), xops);
|
|
output_asm_insn (AS2 (movz%B2%L3,%2,%3), xops);
|
|
|
|
output_asm_insn (AS2 (sub%L0,%3,%0), xops);
|
|
ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (label));
|
|
RET;
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_289 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[2];
|
|
|
|
cc_status.flags |= CC_NOT_SIGNED;
|
|
|
|
xops[0] = gen_rtx (REG, QImode, 0);
|
|
xops[1] = CONST0_RTX (QImode);
|
|
|
|
output_asm_insn ("cld", operands);
|
|
output_asm_insn (AS2 (test%B0,%1,%0), xops);
|
|
return "repz\n\tcmps%B2";
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_291 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[3];
|
|
static int ffssi_label_number;
|
|
char buffer[30];
|
|
|
|
xops[0] = operands[0];
|
|
xops[1] = operands[1];
|
|
xops[2] = constm1_rtx;
|
|
/* Can there be a way to avoid the jump here? */
|
|
output_asm_insn (AS2 (bsf%L0,%1,%0), xops);
|
|
#ifdef LOCAL_LABEL_PREFIX
|
|
sprintf (buffer, "jnz %sLFFSSI%d",
|
|
LOCAL_LABEL_PREFIX, ffssi_label_number);
|
|
#else
|
|
sprintf (buffer, "jnz %sLFFSSI%d",
|
|
"", ffssi_label_number);
|
|
#endif
|
|
output_asm_insn (buffer, xops);
|
|
output_asm_insn (AS2 (mov%L0,%2,%0), xops);
|
|
#ifdef LOCAL_LABEL_PREFIX
|
|
sprintf (buffer, "%sLFFSSI%d:",
|
|
LOCAL_LABEL_PREFIX, ffssi_label_number);
|
|
#else
|
|
sprintf (buffer, "%sLFFSSI%d:",
|
|
"", ffssi_label_number);
|
|
#endif
|
|
output_asm_insn (buffer, xops);
|
|
|
|
ffssi_label_number++;
|
|
return "";
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_293 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[3];
|
|
static int ffshi_label_number;
|
|
char buffer[30];
|
|
|
|
xops[0] = operands[0];
|
|
xops[1] = operands[1];
|
|
xops[2] = constm1_rtx;
|
|
output_asm_insn (AS2 (bsf%W0,%1,%0), xops);
|
|
#ifdef LOCAL_LABEL_PREFIX
|
|
sprintf (buffer, "jnz %sLFFSHI%d",
|
|
LOCAL_LABEL_PREFIX, ffshi_label_number);
|
|
#else
|
|
sprintf (buffer, "jnz %sLFFSHI%d",
|
|
"", ffshi_label_number);
|
|
#endif
|
|
output_asm_insn (buffer, xops);
|
|
output_asm_insn (AS2 (mov%W0,%2,%0), xops);
|
|
#ifdef LOCAL_LABEL_PREFIX
|
|
sprintf (buffer, "%sLFFSHI%d:",
|
|
LOCAL_LABEL_PREFIX, ffshi_label_number);
|
|
#else
|
|
sprintf (buffer, "%sLFFSHI%d:",
|
|
"", ffshi_label_number);
|
|
#endif
|
|
output_asm_insn (buffer, xops);
|
|
|
|
ffshi_label_number++;
|
|
return "";
|
|
}
|
|
}
|
|
|
|
static char *
|
|
output_294 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_295 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_296 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_297 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_298 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_299 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_300 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_301 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_302 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_303 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_304 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_305 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_306 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
return (char *) output_387_binary_op (insn, operands);
|
|
}
|
|
|
|
static char *
|
|
output_308 (operands, insn)
|
|
rtx *operands;
|
|
rtx insn;
|
|
{
|
|
|
|
{
|
|
rtx xops[2];
|
|
|
|
xops[0] = operands[0];
|
|
xops[1] = constm1_rtx;
|
|
output_asm_insn ("cld", operands);
|
|
output_asm_insn (AS2 (mov%L0,%1,%0), xops);
|
|
return "repnz\n\tscas%B2";
|
|
}
|
|
}
|
|
|
|
char * const insn_template[] =
|
|
{
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"push%L0 %1",
|
|
"push%L0 %1",
|
|
0,
|
|
0,
|
|
"push%W0 %1",
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"mul%B0 %2",
|
|
"imul%B0 %2",
|
|
"mul%L0 %2",
|
|
"imul%L0 %2",
|
|
0,
|
|
0,
|
|
0,
|
|
"idiv%B0 %2",
|
|
"div%B0 %2",
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"cwtd\n\tidiv%W0 %2",
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"neg%L0 %0",
|
|
"neg%W0 %0",
|
|
"neg%B0 %0",
|
|
"fchs",
|
|
"fchs",
|
|
"fchs",
|
|
"fchs",
|
|
"fchs",
|
|
"fabs",
|
|
"fabs",
|
|
"fabs",
|
|
"fabs",
|
|
"fabs",
|
|
"fsqrt",
|
|
"fsqrt",
|
|
"fsqrt",
|
|
"fsqrt",
|
|
"fsqrt",
|
|
"fsqrt",
|
|
"fsin",
|
|
"fsin",
|
|
"fsin",
|
|
"fcos",
|
|
"fcos",
|
|
"fcos",
|
|
"not%L0 %0",
|
|
"not%W0 %0",
|
|
"not%B0 %0",
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"ja %l0",
|
|
0,
|
|
0,
|
|
0,
|
|
"jb %l0",
|
|
0,
|
|
0,
|
|
0,
|
|
"jae %l0",
|
|
0,
|
|
0,
|
|
0,
|
|
"jbe %l0",
|
|
0,
|
|
0,
|
|
0,
|
|
"jbe %l0",
|
|
0,
|
|
"jae %l0",
|
|
0,
|
|
"jb %l0",
|
|
0,
|
|
"ja %l0",
|
|
"jmp %l0",
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"call %P0",
|
|
0,
|
|
0,
|
|
"call %P0",
|
|
0,
|
|
0,
|
|
"call %P1",
|
|
0,
|
|
0,
|
|
"call %P1",
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
"frstor %0",
|
|
0,
|
|
"nop",
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
};
|
|
|
|
char *(*const insn_outfun[])() =
|
|
{
|
|
output_0,
|
|
0,
|
|
output_2,
|
|
0,
|
|
output_4,
|
|
0,
|
|
output_6,
|
|
0,
|
|
output_8,
|
|
0,
|
|
output_10,
|
|
0,
|
|
output_12,
|
|
0,
|
|
output_14,
|
|
0,
|
|
output_16,
|
|
0,
|
|
output_18,
|
|
output_19,
|
|
output_20,
|
|
output_21,
|
|
output_22,
|
|
output_23,
|
|
output_24,
|
|
output_25,
|
|
output_26,
|
|
output_27,
|
|
output_28,
|
|
output_29,
|
|
output_30,
|
|
output_31,
|
|
output_32,
|
|
output_33,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
output_43,
|
|
output_44,
|
|
output_45,
|
|
0,
|
|
0,
|
|
0,
|
|
output_49,
|
|
0,
|
|
output_51,
|
|
output_52,
|
|
output_53,
|
|
output_54,
|
|
output_55,
|
|
output_56,
|
|
output_57,
|
|
output_58,
|
|
output_59,
|
|
output_60,
|
|
output_61,
|
|
output_62,
|
|
output_63,
|
|
output_64,
|
|
output_65,
|
|
output_66,
|
|
output_67,
|
|
output_68,
|
|
output_69,
|
|
output_70,
|
|
output_71,
|
|
output_72,
|
|
output_73,
|
|
output_74,
|
|
output_75,
|
|
output_76,
|
|
0,
|
|
output_78,
|
|
output_79,
|
|
output_80,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
output_87,
|
|
output_88,
|
|
output_89,
|
|
0,
|
|
0,
|
|
0,
|
|
output_93,
|
|
output_94,
|
|
output_95,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
output_102,
|
|
output_103,
|
|
output_104,
|
|
output_105,
|
|
output_106,
|
|
output_107,
|
|
output_108,
|
|
output_109,
|
|
output_110,
|
|
output_111,
|
|
output_112,
|
|
0,
|
|
0,
|
|
0,
|
|
output_116,
|
|
output_117,
|
|
output_118,
|
|
output_119,
|
|
0,
|
|
0,
|
|
0,
|
|
output_123,
|
|
output_124,
|
|
output_125,
|
|
output_126,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
output_139,
|
|
0,
|
|
output_141,
|
|
output_142,
|
|
output_143,
|
|
output_144,
|
|
output_145,
|
|
output_146,
|
|
output_147,
|
|
output_148,
|
|
output_149,
|
|
output_150,
|
|
output_151,
|
|
output_152,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
output_182,
|
|
output_183,
|
|
output_184,
|
|
output_185,
|
|
output_186,
|
|
0,
|
|
output_188,
|
|
output_189,
|
|
output_190,
|
|
output_191,
|
|
output_192,
|
|
0,
|
|
output_194,
|
|
output_195,
|
|
output_196,
|
|
output_197,
|
|
output_198,
|
|
output_199,
|
|
output_200,
|
|
output_201,
|
|
output_202,
|
|
output_203,
|
|
output_204,
|
|
output_205,
|
|
output_206,
|
|
output_207,
|
|
output_208,
|
|
output_209,
|
|
output_210,
|
|
0,
|
|
output_212,
|
|
0,
|
|
output_214,
|
|
0,
|
|
output_216,
|
|
0,
|
|
output_218,
|
|
0,
|
|
output_220,
|
|
0,
|
|
output_222,
|
|
0,
|
|
output_224,
|
|
0,
|
|
output_226,
|
|
0,
|
|
output_228,
|
|
0,
|
|
output_230,
|
|
0,
|
|
output_232,
|
|
0,
|
|
output_234,
|
|
0,
|
|
output_236,
|
|
0,
|
|
0,
|
|
0,
|
|
output_240,
|
|
0,
|
|
0,
|
|
0,
|
|
output_244,
|
|
0,
|
|
0,
|
|
0,
|
|
output_248,
|
|
0,
|
|
0,
|
|
output_251,
|
|
output_252,
|
|
output_253,
|
|
0,
|
|
output_255,
|
|
0,
|
|
output_257,
|
|
0,
|
|
output_259,
|
|
0,
|
|
0,
|
|
output_262,
|
|
0,
|
|
output_264,
|
|
output_265,
|
|
0,
|
|
output_267,
|
|
0,
|
|
0,
|
|
output_270,
|
|
0,
|
|
0,
|
|
output_273,
|
|
0,
|
|
0,
|
|
output_276,
|
|
0,
|
|
0,
|
|
output_279,
|
|
output_280,
|
|
0,
|
|
0,
|
|
output_283,
|
|
0,
|
|
0,
|
|
output_286,
|
|
0,
|
|
output_288,
|
|
output_289,
|
|
0,
|
|
output_291,
|
|
0,
|
|
output_293,
|
|
output_294,
|
|
output_295,
|
|
output_296,
|
|
output_297,
|
|
output_298,
|
|
output_299,
|
|
output_300,
|
|
output_301,
|
|
output_302,
|
|
output_303,
|
|
output_304,
|
|
output_305,
|
|
output_306,
|
|
0,
|
|
output_308,
|
|
};
|
|
|
|
rtx (*const insn_gen_function[]) () =
|
|
{
|
|
gen_tstsi_1,
|
|
gen_tstsi,
|
|
gen_tsthi_1,
|
|
gen_tsthi,
|
|
gen_tstqi_1,
|
|
gen_tstqi,
|
|
gen_tstsf_cc,
|
|
gen_tstsf,
|
|
gen_tstdf_cc,
|
|
gen_tstdf,
|
|
gen_tstxf_cc,
|
|
gen_tstxf,
|
|
gen_cmpsi_1,
|
|
gen_cmpsi,
|
|
gen_cmphi_1,
|
|
gen_cmphi,
|
|
gen_cmpqi_1,
|
|
gen_cmpqi,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
gen_cmpsf_cc_1,
|
|
0,
|
|
0,
|
|
0,
|
|
gen_cmpxf,
|
|
gen_cmpdf,
|
|
gen_cmpsf,
|
|
gen_cmpxf_cc,
|
|
gen_cmpxf_ccfpeq,
|
|
gen_cmpdf_cc,
|
|
gen_cmpdf_ccfpeq,
|
|
gen_cmpsf_cc,
|
|
gen_cmpsf_ccfpeq,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
gen_movsi,
|
|
0,
|
|
0,
|
|
gen_movhi,
|
|
gen_movstricthi,
|
|
0,
|
|
gen_movqi,
|
|
gen_movstrictqi,
|
|
0,
|
|
gen_movsf,
|
|
0,
|
|
gen_swapdf,
|
|
gen_movdf,
|
|
0,
|
|
gen_swapxf,
|
|
gen_movxf,
|
|
0,
|
|
gen_movdi,
|
|
gen_zero_extendhisi2,
|
|
gen_zero_extendqihi2,
|
|
gen_zero_extendqisi2,
|
|
gen_zero_extendsidi2,
|
|
gen_extendsidi2,
|
|
gen_extendhisi2,
|
|
gen_extendqihi2,
|
|
gen_extendqisi2,
|
|
gen_extendsfdf2,
|
|
gen_extenddfxf2,
|
|
gen_extendsfxf2,
|
|
gen_truncdfsf2,
|
|
0,
|
|
gen_truncxfsf2,
|
|
gen_truncxfdf2,
|
|
gen_fixuns_truncxfsi2,
|
|
gen_fixuns_truncdfsi2,
|
|
gen_fixuns_truncsfsi2,
|
|
gen_fix_truncxfdi2,
|
|
gen_fix_truncdfdi2,
|
|
gen_fix_truncsfdi2,
|
|
0,
|
|
0,
|
|
0,
|
|
gen_fix_truncxfsi2,
|
|
gen_fix_truncdfsi2,
|
|
gen_fix_truncsfsi2,
|
|
0,
|
|
0,
|
|
0,
|
|
gen_floatsisf2,
|
|
gen_floatdisf2,
|
|
gen_floatsidf2,
|
|
gen_floatdidf2,
|
|
gen_floatsixf2,
|
|
gen_floatdixf2,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
gen_adddi3,
|
|
gen_addsi3,
|
|
gen_addhi3,
|
|
gen_addqi3,
|
|
0,
|
|
gen_addxf3,
|
|
gen_adddf3,
|
|
gen_addsf3,
|
|
gen_subdi3,
|
|
gen_subsi3,
|
|
gen_subhi3,
|
|
gen_subqi3,
|
|
gen_subxf3,
|
|
gen_subdf3,
|
|
gen_subsf3,
|
|
0,
|
|
gen_mulhi3,
|
|
0,
|
|
gen_mulsi3,
|
|
gen_umulqihi3,
|
|
gen_mulqihi3,
|
|
gen_umulsidi3,
|
|
gen_mulsidi3,
|
|
gen_mulxf3,
|
|
gen_muldf3,
|
|
gen_mulsf3,
|
|
gen_divqi3,
|
|
gen_udivqi3,
|
|
gen_divxf3,
|
|
gen_divdf3,
|
|
gen_divsf3,
|
|
gen_divmodsi4,
|
|
gen_divmodhi4,
|
|
gen_udivmodsi4,
|
|
gen_udivmodhi4,
|
|
gen_andsi3,
|
|
gen_andhi3,
|
|
gen_andqi3,
|
|
gen_iorsi3,
|
|
gen_iorhi3,
|
|
gen_iorqi3,
|
|
gen_xorsi3,
|
|
gen_xorhi3,
|
|
gen_xorqi3,
|
|
gen_negdi2,
|
|
gen_negsi2,
|
|
gen_neghi2,
|
|
gen_negqi2,
|
|
gen_negsf2,
|
|
gen_negdf2,
|
|
0,
|
|
gen_negxf2,
|
|
0,
|
|
gen_abssf2,
|
|
gen_absdf2,
|
|
0,
|
|
gen_absxf2,
|
|
0,
|
|
gen_sqrtsf2,
|
|
gen_sqrtdf2,
|
|
0,
|
|
gen_sqrtxf2,
|
|
0,
|
|
0,
|
|
gen_sindf2,
|
|
gen_sinsf2,
|
|
0,
|
|
gen_cosdf2,
|
|
gen_cossf2,
|
|
0,
|
|
gen_one_cmplsi2,
|
|
gen_one_cmplhi2,
|
|
gen_one_cmplqi2,
|
|
gen_ashldi3,
|
|
gen_ashldi3_const_int,
|
|
gen_ashldi3_non_const_int,
|
|
gen_ashlsi3,
|
|
gen_ashlhi3,
|
|
gen_ashlqi3,
|
|
gen_ashrdi3,
|
|
gen_ashrdi3_const_int,
|
|
gen_ashrdi3_non_const_int,
|
|
gen_ashrsi3,
|
|
gen_ashrhi3,
|
|
gen_ashrqi3,
|
|
gen_lshrdi3,
|
|
gen_lshrdi3_const_int,
|
|
gen_lshrdi3_non_const_int,
|
|
gen_lshrsi3,
|
|
gen_lshrhi3,
|
|
gen_lshrqi3,
|
|
gen_rotlsi3,
|
|
gen_rotlhi3,
|
|
gen_rotlqi3,
|
|
gen_rotrsi3,
|
|
gen_rotrhi3,
|
|
gen_rotrqi3,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
gen_seq,
|
|
0,
|
|
gen_sne,
|
|
0,
|
|
gen_sgt,
|
|
0,
|
|
gen_sgtu,
|
|
0,
|
|
gen_slt,
|
|
0,
|
|
gen_sltu,
|
|
0,
|
|
gen_sge,
|
|
0,
|
|
gen_sgeu,
|
|
0,
|
|
gen_sle,
|
|
0,
|
|
gen_sleu,
|
|
0,
|
|
gen_beq,
|
|
0,
|
|
gen_bne,
|
|
0,
|
|
gen_bgt,
|
|
0,
|
|
gen_bgtu,
|
|
0,
|
|
gen_blt,
|
|
0,
|
|
gen_bltu,
|
|
0,
|
|
gen_bge,
|
|
0,
|
|
gen_bgeu,
|
|
0,
|
|
gen_ble,
|
|
0,
|
|
gen_bleu,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
gen_jump,
|
|
gen_indirect_jump,
|
|
gen_casesi,
|
|
0,
|
|
gen_tablejump,
|
|
gen_call_pop,
|
|
0,
|
|
0,
|
|
gen_call,
|
|
0,
|
|
0,
|
|
gen_call_value_pop,
|
|
0,
|
|
0,
|
|
gen_call_value,
|
|
0,
|
|
0,
|
|
gen_untyped_call,
|
|
0,
|
|
0,
|
|
gen_untyped_return,
|
|
gen_update_return,
|
|
gen_return,
|
|
gen_nop,
|
|
gen_movstrsi,
|
|
0,
|
|
gen_cmpstrsi,
|
|
0,
|
|
0,
|
|
gen_ffssi2,
|
|
0,
|
|
gen_ffshi2,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
gen_strlensi,
|
|
0,
|
|
};
|
|
|
|
char *insn_name[] =
|
|
{
|
|
"tstsi_1",
|
|
"tstsi",
|
|
"tsthi_1",
|
|
"tsthi",
|
|
"tstqi_1",
|
|
"tstqi",
|
|
"tstsf_cc",
|
|
"tstsf",
|
|
"tstdf_cc",
|
|
"tstdf",
|
|
"tstxf_cc",
|
|
"tstxf",
|
|
"cmpsi_1",
|
|
"cmpsi",
|
|
"cmphi_1",
|
|
"cmphi",
|
|
"cmpqi_1",
|
|
"cmpqi",
|
|
"cmpqi+1",
|
|
"cmpqi+2",
|
|
"cmpqi+3",
|
|
"cmpqi+4",
|
|
"cmpqi+5",
|
|
"cmpqi+6",
|
|
"cmpsf_cc_1-6",
|
|
"cmpsf_cc_1-5",
|
|
"cmpsf_cc_1-4",
|
|
"cmpsf_cc_1-3",
|
|
"cmpsf_cc_1-2",
|
|
"cmpsf_cc_1-1",
|
|
"cmpsf_cc_1",
|
|
"cmpsf_cc_1+1",
|
|
"cmpsf_cc_1+2",
|
|
"cmpxf-1",
|
|
"cmpxf",
|
|
"cmpdf",
|
|
"cmpsf",
|
|
"cmpxf_cc",
|
|
"cmpxf_ccfpeq",
|
|
"cmpdf_cc",
|
|
"cmpdf_ccfpeq",
|
|
"cmpsf_cc",
|
|
"cmpsf_ccfpeq",
|
|
"cmpsf_ccfpeq+1",
|
|
"cmpsf_ccfpeq+2",
|
|
"cmpsf_ccfpeq+3",
|
|
"movsi-2",
|
|
"movsi-1",
|
|
"movsi",
|
|
"movsi+1",
|
|
"movhi-1",
|
|
"movhi",
|
|
"movstricthi",
|
|
"movstricthi+1",
|
|
"movqi",
|
|
"movstrictqi",
|
|
"movstrictqi+1",
|
|
"movsf",
|
|
"movsf+1",
|
|
"swapdf",
|
|
"movdf",
|
|
"movdf+1",
|
|
"swapxf",
|
|
"movxf",
|
|
"movxf+1",
|
|
"movdi",
|
|
"zero_extendhisi2",
|
|
"zero_extendqihi2",
|
|
"zero_extendqisi2",
|
|
"zero_extendsidi2",
|
|
"extendsidi2",
|
|
"extendhisi2",
|
|
"extendqihi2",
|
|
"extendqisi2",
|
|
"extendsfdf2",
|
|
"extenddfxf2",
|
|
"extendsfxf2",
|
|
"truncdfsf2",
|
|
"truncdfsf2+1",
|
|
"truncxfsf2",
|
|
"truncxfdf2",
|
|
"fixuns_truncxfsi2",
|
|
"fixuns_truncdfsi2",
|
|
"fixuns_truncsfsi2",
|
|
"fix_truncxfdi2",
|
|
"fix_truncdfdi2",
|
|
"fix_truncsfdi2",
|
|
"fix_truncsfdi2+1",
|
|
"fix_truncsfdi2+2",
|
|
"fix_truncxfsi2-1",
|
|
"fix_truncxfsi2",
|
|
"fix_truncdfsi2",
|
|
"fix_truncsfsi2",
|
|
"fix_truncsfsi2+1",
|
|
"fix_truncsfsi2+2",
|
|
"floatsisf2-1",
|
|
"floatsisf2",
|
|
"floatdisf2",
|
|
"floatsidf2",
|
|
"floatdidf2",
|
|
"floatsixf2",
|
|
"floatdixf2",
|
|
"floatdixf2+1",
|
|
"floatdixf2+2",
|
|
"floatdixf2+3",
|
|
"adddi3-3",
|
|
"adddi3-2",
|
|
"adddi3-1",
|
|
"adddi3",
|
|
"addsi3",
|
|
"addhi3",
|
|
"addqi3",
|
|
"addqi3+1",
|
|
"addxf3",
|
|
"adddf3",
|
|
"addsf3",
|
|
"subdi3",
|
|
"subsi3",
|
|
"subhi3",
|
|
"subqi3",
|
|
"subxf3",
|
|
"subdf3",
|
|
"subsf3",
|
|
"subsf3+1",
|
|
"mulhi3",
|
|
"mulhi3+1",
|
|
"mulsi3",
|
|
"umulqihi3",
|
|
"mulqihi3",
|
|
"umulsidi3",
|
|
"mulsidi3",
|
|
"mulxf3",
|
|
"muldf3",
|
|
"mulsf3",
|
|
"divqi3",
|
|
"udivqi3",
|
|
"divxf3",
|
|
"divdf3",
|
|
"divsf3",
|
|
"divmodsi4",
|
|
"divmodhi4",
|
|
"udivmodsi4",
|
|
"udivmodhi4",
|
|
"andsi3",
|
|
"andhi3",
|
|
"andqi3",
|
|
"iorsi3",
|
|
"iorhi3",
|
|
"iorqi3",
|
|
"xorsi3",
|
|
"xorhi3",
|
|
"xorqi3",
|
|
"negdi2",
|
|
"negsi2",
|
|
"neghi2",
|
|
"negqi2",
|
|
"negsf2",
|
|
"negdf2",
|
|
"negdf2+1",
|
|
"negxf2",
|
|
"negxf2+1",
|
|
"abssf2",
|
|
"absdf2",
|
|
"absdf2+1",
|
|
"absxf2",
|
|
"absxf2+1",
|
|
"sqrtsf2",
|
|
"sqrtdf2",
|
|
"sqrtdf2+1",
|
|
"sqrtxf2",
|
|
"sqrtxf2+1",
|
|
"sindf2-1",
|
|
"sindf2",
|
|
"sinsf2",
|
|
"sinsf2+1",
|
|
"cosdf2",
|
|
"cossf2",
|
|
"cossf2+1",
|
|
"one_cmplsi2",
|
|
"one_cmplhi2",
|
|
"one_cmplqi2",
|
|
"ashldi3",
|
|
"ashldi3_const_int",
|
|
"ashldi3_non_const_int",
|
|
"ashlsi3",
|
|
"ashlhi3",
|
|
"ashlqi3",
|
|
"ashrdi3",
|
|
"ashrdi3_const_int",
|
|
"ashrdi3_non_const_int",
|
|
"ashrsi3",
|
|
"ashrhi3",
|
|
"ashrqi3",
|
|
"lshrdi3",
|
|
"lshrdi3_const_int",
|
|
"lshrdi3_non_const_int",
|
|
"lshrsi3",
|
|
"lshrhi3",
|
|
"lshrqi3",
|
|
"rotlsi3",
|
|
"rotlhi3",
|
|
"rotlqi3",
|
|
"rotrsi3",
|
|
"rotrhi3",
|
|
"rotrqi3",
|
|
"rotrqi3+1",
|
|
"rotrqi3+2",
|
|
"rotrqi3+3",
|
|
"seq-3",
|
|
"seq-2",
|
|
"seq-1",
|
|
"seq",
|
|
"seq+1",
|
|
"sne",
|
|
"sne+1",
|
|
"sgt",
|
|
"sgt+1",
|
|
"sgtu",
|
|
"sgtu+1",
|
|
"slt",
|
|
"slt+1",
|
|
"sltu",
|
|
"sltu+1",
|
|
"sge",
|
|
"sge+1",
|
|
"sgeu",
|
|
"sgeu+1",
|
|
"sle",
|
|
"sle+1",
|
|
"sleu",
|
|
"sleu+1",
|
|
"beq",
|
|
"beq+1",
|
|
"bne",
|
|
"bne+1",
|
|
"bgt",
|
|
"bgt+1",
|
|
"bgtu",
|
|
"bgtu+1",
|
|
"blt",
|
|
"blt+1",
|
|
"bltu",
|
|
"bltu+1",
|
|
"bge",
|
|
"bge+1",
|
|
"bgeu",
|
|
"bgeu+1",
|
|
"ble",
|
|
"ble+1",
|
|
"bleu",
|
|
"bleu+1",
|
|
"bleu+2",
|
|
"bleu+3",
|
|
"bleu+4",
|
|
"bleu+5",
|
|
"bleu+6",
|
|
"jump-5",
|
|
"jump-4",
|
|
"jump-3",
|
|
"jump-2",
|
|
"jump-1",
|
|
"jump",
|
|
"indirect_jump",
|
|
"casesi",
|
|
"casesi+1",
|
|
"tablejump",
|
|
"call_pop",
|
|
"call_pop+1",
|
|
"call-1",
|
|
"call",
|
|
"call+1",
|
|
"call_value_pop-1",
|
|
"call_value_pop",
|
|
"call_value_pop+1",
|
|
"call_value-1",
|
|
"call_value",
|
|
"call_value+1",
|
|
"untyped_call-1",
|
|
"untyped_call",
|
|
"untyped_call+1",
|
|
"untyped_return-1",
|
|
"untyped_return",
|
|
"update_return",
|
|
"return",
|
|
"nop",
|
|
"movstrsi",
|
|
"movstrsi+1",
|
|
"cmpstrsi",
|
|
"cmpstrsi+1",
|
|
"ffssi2-1",
|
|
"ffssi2",
|
|
"ffssi2+1",
|
|
"ffshi2",
|
|
"ffshi2+1",
|
|
"ffshi2+2",
|
|
"ffshi2+3",
|
|
"ffshi2+4",
|
|
"ffshi2+5",
|
|
"ffshi2+6",
|
|
"ffshi2+7",
|
|
"strlensi-7",
|
|
"strlensi-6",
|
|
"strlensi-5",
|
|
"strlensi-4",
|
|
"strlensi-3",
|
|
"strlensi-2",
|
|
"strlensi-1",
|
|
"strlensi",
|
|
"strlensi+1",
|
|
};
|
|
char **insn_name_ptr = insn_name;
|
|
|
|
const int insn_n_operands[] =
|
|
{
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
3,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
3,
|
|
4,
|
|
4,
|
|
4,
|
|
3,
|
|
2,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
3,
|
|
2,
|
|
2,
|
|
8,
|
|
8,
|
|
8,
|
|
6,
|
|
6,
|
|
6,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
4,
|
|
3,
|
|
3,
|
|
2,
|
|
3,
|
|
3,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
7,
|
|
3,
|
|
1,
|
|
4,
|
|
4,
|
|
4,
|
|
2,
|
|
2,
|
|
2,
|
|
5,
|
|
5,
|
|
5,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
3,
|
|
2,
|
|
1,
|
|
0,
|
|
0,
|
|
5,
|
|
5,
|
|
5,
|
|
5,
|
|
4,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
4,
|
|
};
|
|
|
|
const int insn_n_dups[] =
|
|
{
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
2,
|
|
0,
|
|
0,
|
|
2,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
7,
|
|
7,
|
|
7,
|
|
5,
|
|
5,
|
|
5,
|
|
1,
|
|
1,
|
|
1,
|
|
2,
|
|
2,
|
|
2,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
3,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
2,
|
|
2,
|
|
3,
|
|
3,
|
|
3,
|
|
2,
|
|
0,
|
|
2,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
5,
|
|
1,
|
|
};
|
|
|
|
char *const insn_operand_constraint[][MAX_RECOG_OPERANDS] =
|
|
{
|
|
{ "rm", },
|
|
{ "", },
|
|
{ "rm", },
|
|
{ "", },
|
|
{ "qm", },
|
|
{ "", },
|
|
{ "f", "=a", },
|
|
{ "", "", },
|
|
{ "f", "=a", },
|
|
{ "", "", },
|
|
{ "f", "=a", },
|
|
{ "", "", },
|
|
{ "mr,r", "ri,mr", },
|
|
{ "", "", },
|
|
{ "mr,r", "ri,mr", },
|
|
{ "", "", },
|
|
{ "q,mq", "qm,nq", },
|
|
{ "", "", },
|
|
{ "f", "f", "", "=a", },
|
|
{ "f", "rm", "", "=a", },
|
|
{ "rm", "f", "", "=a", },
|
|
{ "f", "fm", "", "=a", },
|
|
{ "f", "fm", "", "=a", },
|
|
{ "f", "f", "=a", },
|
|
{ "f,fm", "fm,f", "", "=a,a", },
|
|
{ "f", "rm", "", "=a", },
|
|
{ "rm", "f", "", "=a", },
|
|
{ "f", "fm", "", "=a", },
|
|
{ "fm", "f", "", "=a", },
|
|
{ "f", "f", "=a", },
|
|
{ "f,fm", "fm,f", "", "=a,a", },
|
|
{ "f", "rm", "", "=a", },
|
|
{ "rm", "f", "", "=a", },
|
|
{ "f", "f", "=a", },
|
|
{ "", "", },
|
|
{ "", "", },
|
|
{ "", "", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "%ro", "ri", },
|
|
{ "%ro", "ri", },
|
|
{ "%qm", "qi", },
|
|
{ "=<", "g", },
|
|
{ "=<", "ri", },
|
|
{ "", "", },
|
|
{ "=g,r", "ri,m", },
|
|
{ "=<", "g", },
|
|
{ "=g,r", "ri,m", },
|
|
{ "+g,r", "ri,m", },
|
|
{ "=<", "q", },
|
|
{ "=q,*r,qm", "*g,q,qn", },
|
|
{ "+qm,q", "*qn,m", },
|
|
{ "=<,<", "gF,f", },
|
|
{ "=*rfm,*rf,f,!*rm", "*rf,*rfm,fG,fF", },
|
|
{ "=<,<", "gF,f", },
|
|
{ "f", "f", },
|
|
{ "=*rfm,*rf,f,!*rm", "*rf,*rfm,fG,fF", },
|
|
{ "=<,<", "gF,f", },
|
|
{ "f", "f", },
|
|
{ "=f,fm,!*rf,!*rm", "fmG,f,*rfm,*rfF", },
|
|
{ "=<", "roiF", },
|
|
{ "=r,rm", "m,riF", },
|
|
{ "=r", "rm", },
|
|
{ "=r", "qm", },
|
|
{ "=r", "qm", },
|
|
{ "=r", "0", },
|
|
{ "=r", "0", },
|
|
{ "=r", "rm", },
|
|
{ "=r", "qm", },
|
|
{ "=r", "qm", },
|
|
{ "=fm,f", "f,fm", },
|
|
{ "=fm,f,f,!*r", "f,fm,!*r,f", },
|
|
{ "=fm,f,f,!*r", "f,fm,!*r,f", },
|
|
{ "", "", },
|
|
{ "=f,m", "0,f", "m,m", },
|
|
{ "=m,!*r", "f,f", },
|
|
{ "=m,!*r", "f,f", },
|
|
{ "", "", "", "", "", "", "", "", },
|
|
{ "", "", "", "", "", "", "", "", },
|
|
{ "", "", "", "", "", "", "", "", },
|
|
{ "", "", "", "", "", "", },
|
|
{ "", "", "", "", "", "", },
|
|
{ "", "", "", "", "", "", },
|
|
{ "=rm", "f", "m", "m", "=&q", },
|
|
{ "=rm", "f", "m", "m", "=&q", },
|
|
{ "=rm", "f", "m", "m", "=&q", },
|
|
{ "", "", "", "", "", },
|
|
{ "", "", "", "", "", },
|
|
{ "", "", "", "", "", },
|
|
{ "=rm", "f", "m", "m", "=&q", },
|
|
{ "=rm", "f", "m", "m", "=&q", },
|
|
{ "=rm", "f", "m", "m", "=&q", },
|
|
{ "", "", },
|
|
{ "", "", },
|
|
{ "", "", },
|
|
{ "", "", },
|
|
{ "", "", },
|
|
{ "", "", },
|
|
{ "=f", "rm", },
|
|
{ "=f", "rm", },
|
|
{ "=f", "rm", },
|
|
{ "=f", "rm", },
|
|
{ "=f,f", "m,!*r", },
|
|
{ "=f", "rm", },
|
|
{ "=&r,ro", "%0,0", "o,riF", },
|
|
{ "=?r,rm,r", "%r,0,0", "ri,ri,rm", },
|
|
{ "=rm,r", "%0,0", "ri,rm", },
|
|
{ "=qm,q", "%0,0", "qn,qmn", },
|
|
{ "=r", "p", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "=&r,ro", "0,0", "o,riF", },
|
|
{ "=rm,r", "0,0", "ri,rm", },
|
|
{ "=rm,r", "0,0", "ri,rm", },
|
|
{ "=qm,q", "0,0", "qn,qmn", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "=r", "%0", "r", },
|
|
{ "=r,r", "%0,rm", "g,i", },
|
|
{ "=r", "%0", "r", },
|
|
{ "=r,r", "%0,rm", "g,i", },
|
|
{ "=a", "%0", "qm", },
|
|
{ "=a", "%0", "qm", },
|
|
{ "=A", "%0", "rm", },
|
|
{ "=A", "%0", "rm", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "=a", "0", "qm", },
|
|
{ "=a", "0", "qm", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "", "", "", },
|
|
{ "=a", "0", "rm", "=&d", },
|
|
{ "=a", "0", "rm", "=&d", },
|
|
{ "=a", "0", "rm", "=&d", },
|
|
{ "=a", "0", "rm", "=&d", },
|
|
{ "=r,r,rm,r", "%rm,qm,0,0", "L,K,ri,rm", },
|
|
{ "=rm,r", "%0,0", "ri,rm", },
|
|
{ "=qm,q", "%0,0", "qn,qmn", },
|
|
{ "=rm,r", "%0,0", "ri,rm", },
|
|
{ "=rm,r", "%0,0", "ri,rm", },
|
|
{ "=qm,q", "%0,0", "qn,qmn", },
|
|
{ "=rm,r", "%0,0", "ri,rm", },
|
|
{ "=rm,r", "%0,0", "ri,rm", },
|
|
{ "=qm,q", "%0,0", "qn,qm", },
|
|
{ "=&ro", "0", },
|
|
{ "=rm", "0", },
|
|
{ "=rm", "0", },
|
|
{ "=qm", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=f", "0", },
|
|
{ "=rm", "0", },
|
|
{ "=rm", "0", },
|
|
{ "=qm", "0", },
|
|
{ "", "", "", },
|
|
{ "=&r", "0", "J", },
|
|
{ "=&r", "0", "c", },
|
|
{ "=r,rm", "r,0", "M,cI", },
|
|
{ "=rm", "0", "cI", },
|
|
{ "=qm", "0", "cI", },
|
|
{ "", "", "", },
|
|
{ "=&r", "0", "J", },
|
|
{ "=&r", "0", "c", },
|
|
{ "=rm", "0", "cI", },
|
|
{ "=rm", "0", "cI", },
|
|
{ "=qm", "0", "cI", },
|
|
{ "", "", "", },
|
|
{ "=&r", "0", "J", },
|
|
{ "=&r", "0", "c", },
|
|
{ "=rm", "0", "cI", },
|
|
{ "=rm", "0", "cI", },
|
|
{ "=qm", "0", "cI", },
|
|
{ "=rm", "0", "cI", },
|
|
{ "=rm", "0", "cI", },
|
|
{ "=qm", "0", "cI", },
|
|
{ "=rm", "0", "cI", },
|
|
{ "=rm", "0", "cI", },
|
|
{ "=qm", "0", "cI", },
|
|
{ "+rm", "", "r", "n", },
|
|
{ "=rm", "r", "0", },
|
|
{ "=rm", "0", "r", },
|
|
{ "r", "r", },
|
|
{ "r", "n", "n", },
|
|
{ "rm", "n", "n", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ "", },
|
|
{ "=q", },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ "rm", },
|
|
{ "", "", "", "", "", "", "", },
|
|
{ "r", "", "=&r", },
|
|
{ "rm", },
|
|
{ "", "", "", "", },
|
|
{ "m", "g", "", "i", },
|
|
{ "", "g", "", "i", },
|
|
{ "", "", },
|
|
{ "m", "g", },
|
|
{ "", "g", },
|
|
{ "", "", "", "", "", },
|
|
{ "=rf", "m", "g", "", "i", },
|
|
{ "=rf", "", "g", "", "i", },
|
|
{ "", "", "", },
|
|
{ "=rf", "m", "g", },
|
|
{ "=rf", "", "g", },
|
|
{ "", "", "", },
|
|
{ "m", "o", "", },
|
|
{ "", "o", "", },
|
|
{ "", "", },
|
|
{ "m", },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ "", "", "", "", "", },
|
|
{ "D", "S", "n", "i", "=&c", },
|
|
{ "", "", "", "", "", },
|
|
{ "=&r", "S", "D", "c", "i", },
|
|
{ "S", "D", "c", "i", },
|
|
{ "", "", },
|
|
{ "=&r", "rm", },
|
|
{ "", "", },
|
|
{ "=&r", "rm", },
|
|
{ "=f,f", "0,fm", "fm,0", "", },
|
|
{ "=f", "rm", "0", "", },
|
|
{ "=f,f", "0,f", "f,0", "", },
|
|
{ "=f", "rm", "0", "", },
|
|
{ "=f,f", "fm,0", "0,f", "", },
|
|
{ "=f", "0", "rm", "", },
|
|
{ "=f,f", "0,f", "fm,0", "", },
|
|
{ "=f,f", "fm,0", "0,f", "", },
|
|
{ "=f", "0", "rm", "", },
|
|
{ "=f,f", "0,f", "fm,0", "", },
|
|
{ "=f,f", "0,fm", "fm,0", "", },
|
|
{ "=f", "rm", "0", "", },
|
|
{ "=f", "0", "rm", "", },
|
|
{ "", "", "", "", },
|
|
{ "=&c", "D", "a", "i", },
|
|
};
|
|
|
|
const enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =
|
|
{
|
|
{ SImode, },
|
|
{ SImode, },
|
|
{ HImode, },
|
|
{ HImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ SFmode, HImode, },
|
|
{ SFmode, HImode, },
|
|
{ DFmode, HImode, },
|
|
{ DFmode, HImode, },
|
|
{ XFmode, HImode, },
|
|
{ XFmode, HImode, },
|
|
{ SImode, SImode, },
|
|
{ SImode, SImode, },
|
|
{ HImode, HImode, },
|
|
{ HImode, HImode, },
|
|
{ QImode, QImode, },
|
|
{ QImode, QImode, },
|
|
{ XFmode, XFmode, VOIDmode, HImode, },
|
|
{ XFmode, SImode, VOIDmode, HImode, },
|
|
{ SImode, XFmode, VOIDmode, HImode, },
|
|
{ XFmode, DFmode, VOIDmode, HImode, },
|
|
{ XFmode, SFmode, VOIDmode, HImode, },
|
|
{ XFmode, XFmode, HImode, },
|
|
{ DFmode, DFmode, VOIDmode, HImode, },
|
|
{ DFmode, SImode, VOIDmode, HImode, },
|
|
{ SImode, DFmode, VOIDmode, HImode, },
|
|
{ DFmode, SFmode, VOIDmode, HImode, },
|
|
{ SFmode, DFmode, VOIDmode, HImode, },
|
|
{ DFmode, DFmode, HImode, },
|
|
{ SFmode, SFmode, VOIDmode, HImode, },
|
|
{ SFmode, SImode, VOIDmode, HImode, },
|
|
{ SImode, SFmode, VOIDmode, HImode, },
|
|
{ SFmode, SFmode, HImode, },
|
|
{ XFmode, XFmode, },
|
|
{ DFmode, DFmode, },
|
|
{ SFmode, SFmode, },
|
|
{ XFmode, XFmode, HImode, },
|
|
{ XFmode, XFmode, HImode, },
|
|
{ DFmode, DFmode, HImode, },
|
|
{ DFmode, DFmode, HImode, },
|
|
{ SFmode, SFmode, HImode, },
|
|
{ SFmode, SFmode, HImode, },
|
|
{ SImode, SImode, },
|
|
{ HImode, HImode, },
|
|
{ QImode, QImode, },
|
|
{ SImode, SImode, },
|
|
{ SImode, SImode, },
|
|
{ SImode, SImode, },
|
|
{ SImode, SImode, },
|
|
{ HImode, HImode, },
|
|
{ HImode, HImode, },
|
|
{ HImode, HImode, },
|
|
{ QImode, QImode, },
|
|
{ QImode, QImode, },
|
|
{ QImode, QImode, },
|
|
{ SFmode, SFmode, },
|
|
{ SFmode, SFmode, },
|
|
{ DFmode, DFmode, },
|
|
{ DFmode, DFmode, },
|
|
{ DFmode, DFmode, },
|
|
{ XFmode, XFmode, },
|
|
{ XFmode, XFmode, },
|
|
{ XFmode, XFmode, },
|
|
{ DImode, DImode, },
|
|
{ DImode, DImode, },
|
|
{ SImode, HImode, },
|
|
{ HImode, QImode, },
|
|
{ SImode, QImode, },
|
|
{ DImode, SImode, },
|
|
{ DImode, SImode, },
|
|
{ SImode, HImode, },
|
|
{ HImode, QImode, },
|
|
{ SImode, QImode, },
|
|
{ DFmode, SFmode, },
|
|
{ XFmode, DFmode, },
|
|
{ XFmode, SFmode, },
|
|
{ SFmode, DFmode, },
|
|
{ SFmode, DFmode, SFmode, },
|
|
{ SFmode, XFmode, },
|
|
{ DFmode, XFmode, },
|
|
{ SImode, XFmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
|
|
{ SImode, DFmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
|
|
{ SImode, SFmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
|
|
{ DImode, XFmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
|
|
{ DImode, DFmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
|
|
{ DImode, SFmode, VOIDmode, VOIDmode, VOIDmode, SImode, },
|
|
{ DImode, XFmode, SImode, SImode, SImode, },
|
|
{ DImode, DFmode, SImode, SImode, SImode, },
|
|
{ DImode, SFmode, SImode, SImode, SImode, },
|
|
{ SImode, XFmode, VOIDmode, VOIDmode, SImode, },
|
|
{ SImode, DFmode, VOIDmode, VOIDmode, SImode, },
|
|
{ SImode, SFmode, VOIDmode, VOIDmode, SImode, },
|
|
{ SImode, XFmode, SImode, SImode, SImode, },
|
|
{ SImode, DFmode, SImode, SImode, SImode, },
|
|
{ SImode, SFmode, SImode, SImode, SImode, },
|
|
{ SFmode, SImode, },
|
|
{ SFmode, DImode, },
|
|
{ DFmode, SImode, },
|
|
{ DFmode, DImode, },
|
|
{ XFmode, SImode, },
|
|
{ XFmode, DImode, },
|
|
{ XFmode, DImode, },
|
|
{ DFmode, DImode, },
|
|
{ SFmode, DImode, },
|
|
{ DFmode, SImode, },
|
|
{ XFmode, SImode, },
|
|
{ SFmode, SImode, },
|
|
{ DImode, DImode, DImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ SImode, QImode, },
|
|
{ XFmode, XFmode, XFmode, },
|
|
{ DFmode, DFmode, DFmode, },
|
|
{ SFmode, SFmode, SFmode, },
|
|
{ DImode, DImode, DImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ XFmode, XFmode, XFmode, },
|
|
{ DFmode, DFmode, DFmode, },
|
|
{ SFmode, SFmode, SFmode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, QImode, QImode, },
|
|
{ HImode, QImode, QImode, },
|
|
{ DImode, SImode, SImode, },
|
|
{ DImode, SImode, SImode, },
|
|
{ XFmode, XFmode, XFmode, },
|
|
{ DFmode, DFmode, DFmode, },
|
|
{ SFmode, SFmode, SFmode, },
|
|
{ QImode, HImode, QImode, },
|
|
{ QImode, HImode, QImode, },
|
|
{ XFmode, XFmode, XFmode, },
|
|
{ DFmode, DFmode, DFmode, },
|
|
{ SFmode, SFmode, SFmode, },
|
|
{ SImode, SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, HImode, },
|
|
{ SImode, SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, HImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ DImode, DImode, },
|
|
{ SImode, SImode, },
|
|
{ HImode, HImode, },
|
|
{ QImode, QImode, },
|
|
{ SFmode, SFmode, },
|
|
{ DFmode, DFmode, },
|
|
{ DFmode, SFmode, },
|
|
{ XFmode, XFmode, },
|
|
{ XFmode, DFmode, },
|
|
{ SFmode, SFmode, },
|
|
{ DFmode, DFmode, },
|
|
{ DFmode, SFmode, },
|
|
{ XFmode, XFmode, },
|
|
{ XFmode, DFmode, },
|
|
{ SFmode, SFmode, },
|
|
{ DFmode, DFmode, },
|
|
{ DFmode, SFmode, },
|
|
{ XFmode, XFmode, },
|
|
{ XFmode, DFmode, },
|
|
{ XFmode, SFmode, },
|
|
{ DFmode, DFmode, },
|
|
{ SFmode, SFmode, },
|
|
{ DFmode, SFmode, },
|
|
{ DFmode, DFmode, },
|
|
{ SFmode, SFmode, },
|
|
{ DFmode, SFmode, },
|
|
{ SImode, SImode, },
|
|
{ HImode, HImode, },
|
|
{ QImode, QImode, },
|
|
{ DImode, DImode, QImode, },
|
|
{ DImode, DImode, QImode, },
|
|
{ DImode, DImode, QImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ DImode, DImode, QImode, },
|
|
{ DImode, DImode, QImode, },
|
|
{ DImode, DImode, QImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ DImode, DImode, QImode, },
|
|
{ DImode, DImode, QImode, },
|
|
{ DImode, DImode, QImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ HImode, HImode, HImode, },
|
|
{ QImode, QImode, QImode, },
|
|
{ SImode, VOIDmode, SImode, SImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ SImode, SImode, },
|
|
{ SImode, SImode, SImode, },
|
|
{ QImode, SImode, SImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ QImode, },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ SImode, },
|
|
{ SImode, SImode, SImode, VOIDmode, VOIDmode, VOIDmode, SImode, },
|
|
{ SImode, VOIDmode, SImode, },
|
|
{ SImode, },
|
|
{ QImode, SImode, VOIDmode, SImode, },
|
|
{ QImode, SImode, VOIDmode, SImode, },
|
|
{ SImode, SImode, VOIDmode, SImode, },
|
|
{ QImode, SImode, },
|
|
{ QImode, SImode, },
|
|
{ SImode, SImode, },
|
|
{ VOIDmode, QImode, SImode, VOIDmode, SImode, },
|
|
{ VOIDmode, QImode, SImode, VOIDmode, SImode, },
|
|
{ VOIDmode, SImode, SImode, VOIDmode, SImode, },
|
|
{ VOIDmode, QImode, SImode, },
|
|
{ VOIDmode, QImode, SImode, },
|
|
{ VOIDmode, SImode, SImode, },
|
|
{ QImode, BLKmode, VOIDmode, },
|
|
{ QImode, DImode, VOIDmode, },
|
|
{ SImode, DImode, VOIDmode, },
|
|
{ BLKmode, VOIDmode, },
|
|
{ SImode, },
|
|
{ VOIDmode },
|
|
{ VOIDmode },
|
|
{ BLKmode, BLKmode, SImode, SImode, SImode, },
|
|
{ SImode, SImode, SImode, SImode, SImode, },
|
|
{ SImode, BLKmode, BLKmode, SImode, SImode, },
|
|
{ SImode, SImode, SImode, SImode, SImode, },
|
|
{ SImode, SImode, SImode, SImode, },
|
|
{ SImode, SImode, },
|
|
{ SImode, SImode, },
|
|
{ HImode, HImode, },
|
|
{ HImode, SImode, },
|
|
{ DFmode, DFmode, DFmode, DFmode, },
|
|
{ DFmode, SImode, DFmode, DFmode, },
|
|
{ XFmode, XFmode, XFmode, XFmode, },
|
|
{ XFmode, SImode, XFmode, XFmode, },
|
|
{ XFmode, SFmode, XFmode, XFmode, },
|
|
{ XFmode, XFmode, SImode, XFmode, },
|
|
{ XFmode, XFmode, SFmode, XFmode, },
|
|
{ DFmode, SFmode, DFmode, DFmode, },
|
|
{ DFmode, DFmode, SImode, DFmode, },
|
|
{ DFmode, DFmode, SFmode, DFmode, },
|
|
{ SFmode, SFmode, SFmode, SFmode, },
|
|
{ SFmode, SImode, SFmode, SFmode, },
|
|
{ SFmode, SFmode, SImode, SFmode, },
|
|
{ SImode, BLKmode, QImode, SImode, },
|
|
{ SImode, SImode, QImode, SImode, },
|
|
};
|
|
|
|
const char insn_operand_strict_low[][MAX_RECOG_OPERANDS] =
|
|
{
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 1, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 1, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0, },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0, },
|
|
{ 0, 0, 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
{ 0, 0, 0, 0, },
|
|
};
|
|
|
|
extern int nonimmediate_operand ();
|
|
extern int register_operand ();
|
|
extern int scratch_operand ();
|
|
extern int general_operand ();
|
|
extern int VOIDmode_compare_op ();
|
|
extern int push_operand ();
|
|
extern int memory_operand ();
|
|
extern int address_operand ();
|
|
extern int nonmemory_operand ();
|
|
extern int const_int_operand ();
|
|
extern int indirect_operand ();
|
|
extern int immediate_operand ();
|
|
extern int call_insn_operand ();
|
|
extern int symbolic_operand ();
|
|
extern int binary_387_op ();
|
|
|
|
int (*const insn_operand_predicate[][MAX_RECOG_OPERANDS])() =
|
|
{
|
|
{ nonimmediate_operand, },
|
|
{ nonimmediate_operand, },
|
|
{ nonimmediate_operand, },
|
|
{ nonimmediate_operand, },
|
|
{ nonimmediate_operand, },
|
|
{ nonimmediate_operand, },
|
|
{ register_operand, scratch_operand, },
|
|
{ register_operand, scratch_operand, },
|
|
{ register_operand, scratch_operand, },
|
|
{ register_operand, scratch_operand, },
|
|
{ register_operand, scratch_operand, },
|
|
{ register_operand, scratch_operand, },
|
|
{ nonimmediate_operand, general_operand, },
|
|
{ nonimmediate_operand, general_operand, },
|
|
{ nonimmediate_operand, general_operand, },
|
|
{ nonimmediate_operand, general_operand, },
|
|
{ nonimmediate_operand, general_operand, },
|
|
{ nonimmediate_operand, general_operand, },
|
|
{ nonimmediate_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ register_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ nonimmediate_operand, register_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ register_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ register_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ register_operand, register_operand, scratch_operand, },
|
|
{ nonimmediate_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ register_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ nonimmediate_operand, register_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ register_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ nonimmediate_operand, register_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ register_operand, register_operand, scratch_operand, },
|
|
{ nonimmediate_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ register_operand, nonimmediate_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ nonimmediate_operand, register_operand, VOIDmode_compare_op, scratch_operand, },
|
|
{ register_operand, register_operand, scratch_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, register_operand, scratch_operand, },
|
|
{ register_operand, register_operand, scratch_operand, },
|
|
{ register_operand, register_operand, scratch_operand, },
|
|
{ register_operand, register_operand, scratch_operand, },
|
|
{ register_operand, register_operand, scratch_operand, },
|
|
{ register_operand, register_operand, scratch_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ push_operand, general_operand, },
|
|
{ push_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ push_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ push_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ push_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ push_operand, general_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ push_operand, general_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ push_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, nonimmediate_operand, },
|
|
{ general_operand, nonimmediate_operand, },
|
|
{ general_operand, nonimmediate_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ general_operand, nonimmediate_operand, },
|
|
{ general_operand, nonimmediate_operand, },
|
|
{ general_operand, nonimmediate_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ nonimmediate_operand, register_operand, },
|
|
{ nonimmediate_operand, register_operand, memory_operand, },
|
|
{ general_operand, register_operand, },
|
|
{ general_operand, register_operand, },
|
|
{ general_operand, register_operand, 0, 0, 0, 0, 0, scratch_operand, },
|
|
{ general_operand, register_operand, 0, 0, 0, 0, 0, scratch_operand, },
|
|
{ general_operand, register_operand, 0, 0, 0, 0, 0, scratch_operand, },
|
|
{ general_operand, register_operand, 0, 0, 0, scratch_operand, },
|
|
{ general_operand, register_operand, 0, 0, 0, scratch_operand, },
|
|
{ general_operand, register_operand, 0, 0, 0, scratch_operand, },
|
|
{ general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
|
|
{ general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
|
|
{ general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
|
|
{ general_operand, register_operand, 0, 0, scratch_operand, },
|
|
{ general_operand, register_operand, 0, 0, scratch_operand, },
|
|
{ general_operand, register_operand, 0, 0, scratch_operand, },
|
|
{ general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
|
|
{ general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
|
|
{ general_operand, register_operand, memory_operand, memory_operand, scratch_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, nonimmediate_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ register_operand, address_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ general_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, register_operand, nonimmediate_operand, },
|
|
{ register_operand, register_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, },
|
|
{ register_operand, register_operand, general_operand, register_operand, },
|
|
{ register_operand, register_operand, general_operand, register_operand, },
|
|
{ register_operand, register_operand, general_operand, register_operand, },
|
|
{ register_operand, register_operand, general_operand, register_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ register_operand, register_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ register_operand, register_operand, nonmemory_operand, },
|
|
{ register_operand, register_operand, const_int_operand, },
|
|
{ register_operand, register_operand, register_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ register_operand, register_operand, nonmemory_operand, },
|
|
{ register_operand, register_operand, const_int_operand, },
|
|
{ register_operand, register_operand, register_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ register_operand, register_operand, nonmemory_operand, },
|
|
{ register_operand, register_operand, const_int_operand, },
|
|
{ register_operand, register_operand, register_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, general_operand, nonmemory_operand, },
|
|
{ general_operand, 0, general_operand, const_int_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ general_operand, general_operand, general_operand, },
|
|
{ register_operand, general_operand, },
|
|
{ register_operand, const_int_operand, const_int_operand, },
|
|
{ general_operand, const_int_operand, const_int_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ register_operand, },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ general_operand, },
|
|
{ general_operand, general_operand, general_operand, 0, 0, 0, scratch_operand, },
|
|
{ register_operand, 0, scratch_operand, },
|
|
{ general_operand, },
|
|
{ indirect_operand, general_operand, 0, immediate_operand, },
|
|
{ call_insn_operand, general_operand, 0, immediate_operand, },
|
|
{ symbolic_operand, general_operand, 0, immediate_operand, },
|
|
{ indirect_operand, general_operand, },
|
|
{ call_insn_operand, general_operand, },
|
|
{ symbolic_operand, general_operand, },
|
|
{ 0, indirect_operand, general_operand, 0, immediate_operand, },
|
|
{ 0, call_insn_operand, general_operand, 0, immediate_operand, },
|
|
{ 0, symbolic_operand, general_operand, 0, immediate_operand, },
|
|
{ 0, indirect_operand, general_operand, },
|
|
{ 0, call_insn_operand, general_operand, },
|
|
{ 0, symbolic_operand, general_operand, },
|
|
{ indirect_operand, memory_operand, 0, },
|
|
{ call_insn_operand, memory_operand, 0, },
|
|
{ symbolic_operand, memory_operand, 0, },
|
|
{ memory_operand, 0, },
|
|
{ memory_operand, },
|
|
{ 0 },
|
|
{ 0 },
|
|
{ memory_operand, memory_operand, const_int_operand, const_int_operand, scratch_operand, },
|
|
{ address_operand, address_operand, const_int_operand, immediate_operand, scratch_operand, },
|
|
{ general_operand, general_operand, general_operand, general_operand, immediate_operand, },
|
|
{ general_operand, address_operand, address_operand, register_operand, immediate_operand, },
|
|
{ address_operand, address_operand, register_operand, immediate_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ general_operand, general_operand, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, nonimmediate_operand, nonimmediate_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, general_operand, general_operand, binary_387_op, },
|
|
{ register_operand, general_operand, register_operand, immediate_operand, },
|
|
{ register_operand, address_operand, register_operand, immediate_operand, },
|
|
};
|
|
|
|
const int insn_n_alternatives[] =
|
|
{
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
2,
|
|
0,
|
|
2,
|
|
0,
|
|
2,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
2,
|
|
1,
|
|
2,
|
|
2,
|
|
1,
|
|
3,
|
|
2,
|
|
2,
|
|
4,
|
|
2,
|
|
1,
|
|
4,
|
|
2,
|
|
1,
|
|
4,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
2,
|
|
4,
|
|
4,
|
|
0,
|
|
2,
|
|
2,
|
|
2,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
2,
|
|
1,
|
|
2,
|
|
3,
|
|
2,
|
|
2,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
2,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
4,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
2,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
2,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
0,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
2,
|
|
1,
|
|
2,
|
|
1,
|
|
2,
|
|
1,
|
|
2,
|
|
2,
|
|
1,
|
|
2,
|
|
2,
|
|
1,
|
|
1,
|
|
0,
|
|
1,
|
|
};
|