[thirdparty/gcc.git] / gcc / optabs-tree.c

/* Tree-based target query functions relating to optabs
   Copyright (C) 1987-2020 Free Software Foundation, Inc.

This file is part of GCC.

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

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

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */


#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "target.h"
#include "insn-codes.h"
#include "rtl.h"
#include "tree.h"
#include "memmodel.h"
#include "optabs.h"
#include "optabs-tree.h"
#include "stor-layout.h"

/* Return the optab used for computing the operation given by the tree code,
   CODE and the tree EXP.  This function is not always usable (for example, it
   cannot give complete results for multiplication or division) but probably
   ought to be relied on more widely throughout the expander.  */
optab
optab_for_tree_code (enum tree_code code, const_tree type,
		     enum optab_subtype subtype)
{
  bool trapv;
  switch (code)
    {
    case BIT_AND_EXPR:
      return and_optab;

    case BIT_IOR_EXPR:
      return ior_optab;

    case BIT_NOT_EXPR:
      return one_cmpl_optab;

    case BIT_XOR_EXPR:
      return xor_optab;

    case MULT_HIGHPART_EXPR:
      return TYPE_UNSIGNED (type) ? umul_highpart_optab : smul_highpart_optab;

    case TRUNC_MOD_EXPR:
    case CEIL_MOD_EXPR:
    case FLOOR_MOD_EXPR:
    case ROUND_MOD_EXPR:
      return TYPE_UNSIGNED (type) ? umod_optab : smod_optab;

    case RDIV_EXPR:
    case TRUNC_DIV_EXPR:
    case CEIL_DIV_EXPR:
    case FLOOR_DIV_EXPR:
    case ROUND_DIV_EXPR:
    case EXACT_DIV_EXPR:
      if (TYPE_SATURATING (type))
	return TYPE_UNSIGNED (type) ? usdiv_optab : ssdiv_optab;
      return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;

    case LSHIFT_EXPR:
      if (TREE_CODE (type) == VECTOR_TYPE)
	{
	  if (subtype == optab_vector)
	    return TYPE_SATURATING (type) ? unknown_optab : vashl_optab;

	  gcc_assert (subtype == optab_scalar);
	}
      if (TYPE_SATURATING (type))
	return TYPE_UNSIGNED (type) ? usashl_optab : ssashl_optab;
      return ashl_optab;

    case RSHIFT_EXPR:
      if (TREE_CODE (type) == VECTOR_TYPE)
	{
	  if (subtype == optab_vector)
	    return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab;

	  gcc_assert (subtype == optab_scalar);
	}
      return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;

    case LROTATE_EXPR:
      if (TREE_CODE (type) == VECTOR_TYPE)
	{
	  if (subtype == optab_vector)
	    return vrotl_optab;

	  gcc_assert (subtype == optab_scalar);
	}
      return rotl_optab;

    case RROTATE_EXPR:
      if (TREE_CODE (type) == VECTOR_TYPE)
	{
	  if (subtype == optab_vector)
	    return vrotr_optab;

	  gcc_assert (subtype == optab_scalar);
	}
      return rotr_optab;

    case MAX_EXPR:
      return TYPE_UNSIGNED (type) ? umax_optab : smax_optab;

    case MIN_EXPR:
      return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;

    case REALIGN_LOAD_EXPR:
      return vec_realign_load_optab;

    case WIDEN_SUM_EXPR:
      return TYPE_UNSIGNED (type) ? usum_widen_optab : ssum_widen_optab;

    case DOT_PROD_EXPR:
      return TYPE_UNSIGNED (type) ? udot_prod_optab : sdot_prod_optab;

    case SAD_EXPR:
      return TYPE_UNSIGNED (type) ? usad_optab : ssad_optab;

    case WIDEN_MULT_PLUS_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? (TYPE_SATURATING (type)
		 ? usmadd_widen_optab : umadd_widen_optab)
	      : (TYPE_SATURATING (type)
		 ? ssmadd_widen_optab : smadd_widen_optab));

    case WIDEN_MULT_MINUS_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? (TYPE_SATURATING (type)
		 ? usmsub_widen_optab : umsub_widen_optab)
	      : (TYPE_SATURATING (type)
		 ? ssmsub_widen_optab : smsub_widen_optab));

    case VEC_WIDEN_MULT_HI_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? vec_widen_umult_hi_optab : vec_widen_smult_hi_optab);

    case VEC_WIDEN_MULT_LO_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? vec_widen_umult_lo_optab : vec_widen_smult_lo_optab);

    case VEC_WIDEN_MULT_EVEN_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? vec_widen_umult_even_optab : vec_widen_smult_even_optab);

    case VEC_WIDEN_MULT_ODD_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? vec_widen_umult_odd_optab : vec_widen_smult_odd_optab);

    case VEC_WIDEN_LSHIFT_HI_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? vec_widen_ushiftl_hi_optab : vec_widen_sshiftl_hi_optab);

    case VEC_WIDEN_LSHIFT_LO_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? vec_widen_ushiftl_lo_optab : vec_widen_sshiftl_lo_optab);

    case VEC_UNPACK_HI_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? vec_unpacku_hi_optab : vec_unpacks_hi_optab);

    case VEC_UNPACK_LO_EXPR:
      return (TYPE_UNSIGNED (type)
	      ? vec_unpacku_lo_optab : vec_unpacks_lo_optab);

    case VEC_UNPACK_FLOAT_HI_EXPR:
      /* The signedness is determined from input operand.  */
      return (TYPE_UNSIGNED (type)
	      ? vec_unpacku_float_hi_optab : vec_unpacks_float_hi_optab);

    case VEC_UNPACK_FLOAT_LO_EXPR:
      /* The signedness is determined from input operand.  */
      return (TYPE_UNSIGNED (type)
	      ? vec_unpacku_float_lo_optab : vec_unpacks_float_lo_optab);

    case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
      /* The signedness is determined from output operand.  */
      return (TYPE_UNSIGNED (type)
	      ? vec_unpack_ufix_trunc_hi_optab
	      : vec_unpack_sfix_trunc_hi_optab);

    case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
      /* The signedness is determined from output operand.  */
      return (TYPE_UNSIGNED (type)
	      ? vec_unpack_ufix_trunc_lo_optab
	      : vec_unpack_sfix_trunc_lo_optab);

    case VEC_PACK_TRUNC_EXPR:
      return vec_pack_trunc_optab;

    case VEC_PACK_SAT_EXPR:
      return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab;

    case VEC_PACK_FIX_TRUNC_EXPR:
      /* The signedness is determined from output operand.  */
      return (TYPE_UNSIGNED (type)
	      ? vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab);

    case VEC_PACK_FLOAT_EXPR:
      /* The signedness is determined from input operand.  */
      return (TYPE_UNSIGNED (type)
	      ? vec_packu_float_optab : vec_packs_float_optab);

    case VEC_DUPLICATE_EXPR:
      return vec_duplicate_optab;

    case VEC_SERIES_EXPR:
      return vec_series_optab;

    default:
      break;
    }

  trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
  switch (code)
    {
    case POINTER_PLUS_EXPR:
    case PLUS_EXPR:
      if (TYPE_SATURATING (type))
	return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab;
      return trapv ? addv_optab : add_optab;

    case POINTER_DIFF_EXPR:
    case MINUS_EXPR:
      if (TYPE_SATURATING (type))
	return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab;
      return trapv ? subv_optab : sub_optab;

    case MULT_EXPR:
      if (TYPE_SATURATING (type))
	return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab;
      return trapv ? smulv_optab : smul_optab;

    case NEGATE_EXPR:
      if (TYPE_SATURATING (type))
	return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab;
      return trapv ? negv_optab : neg_optab;

    case ABS_EXPR:
      return trapv ? absv_optab : abs_optab;

    case ABSU_EXPR:
      return abs_optab;
    default:
      return unknown_optab;
    }
}

/* Function supportable_convert_operation

   Check whether an operation represented by the code CODE is a
   convert operation that is supported by the target platform in
   vector form (i.e., when operating on arguments of type VECTYPE_IN
   producing a result of type VECTYPE_OUT).

   Convert operations we currently support directly are FIX_TRUNC and FLOAT.
   This function checks if these operations are supported
   by the target platform directly (via vector tree-codes).

   Output:
   - CODE1 is code of vector operation to be used when
   vectorizing the operation, if available.  */

bool
supportable_convert_operation (enum tree_code code,
			       tree vectype_out, tree vectype_in,
			       enum tree_code *code1)
{
  machine_mode m1,m2;
  bool truncp;

  gcc_assert (VECTOR_TYPE_P (vectype_out) && VECTOR_TYPE_P (vectype_in));

  m1 = TYPE_MODE (vectype_out);
  m2 = TYPE_MODE (vectype_in);

  if (!VECTOR_MODE_P (m1) || !VECTOR_MODE_P (m2))
    return false;

  /* First check if we can done conversion directly.  */
  if ((code == FIX_TRUNC_EXPR
       && can_fix_p (m1,m2,TYPE_UNSIGNED (vectype_out), &truncp)
	  != CODE_FOR_nothing)
      || (code == FLOAT_EXPR
	  && can_float_p (m1,m2,TYPE_UNSIGNED (vectype_in))
	     != CODE_FOR_nothing))
    {
      *code1 = code;
      return true;
    }

  if (GET_MODE_UNIT_PRECISION (m1) > GET_MODE_UNIT_PRECISION (m2)
      && can_extend_p (m1, m2, TYPE_UNSIGNED (vectype_in)))
    {
      *code1 = code;
      return true;
    }

  if (GET_MODE_UNIT_PRECISION (m1) < GET_MODE_UNIT_PRECISION (m2)
      && convert_optab_handler (trunc_optab, m1, m2) != CODE_FOR_nothing)
    {
      *code1 = code;
      return true;
    }

  return false;
}

/* Return TRUE if appropriate vector insn is available
   for vector comparison expr with vector type VALUE_TYPE
   and resulting mask with MASK_TYPE.  */

bool
expand_vec_cmp_expr_p (tree value_type, tree mask_type, enum tree_code code)
{
  if (get_vec_cmp_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type),
			 TYPE_UNSIGNED (value_type)) != CODE_FOR_nothing)
    return true;
  if ((code == EQ_EXPR || code == NE_EXPR)
      && (get_vec_cmp_eq_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type))
	  != CODE_FOR_nothing))
    return true;
  return false;
}

/* Return true iff vcond_optab/vcondu_optab can handle a vector
   comparison for code CODE, comparing operands of type CMP_OP_TYPE and
   producing a result of type VALUE_TYPE.  */

static bool
vcond_icode_p (tree value_type, tree cmp_op_type, enum tree_code code)
{
  return can_vcond_compare_p (get_rtx_code (code, TYPE_UNSIGNED (cmp_op_type)),
			      TYPE_MODE (value_type), TYPE_MODE (cmp_op_type));
}

/* Return true iff vcondeq_optab can handle a vector comparison for code CODE,
   comparing operands of type CMP_OP_TYPE and producing a result of type
   VALUE_TYPE.  */

static bool
vcond_eq_icode_p (tree value_type, tree cmp_op_type, enum tree_code code)
{
  if (code != EQ_EXPR && code != NE_EXPR)
    return false;

  return get_vcond_eq_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type))
	 != CODE_FOR_nothing;
}

/* Return TRUE iff, appropriate vector insns are available
   for vector cond expr with vector type VALUE_TYPE and a comparison
   with operand vector types in CMP_OP_TYPE.  */

bool
expand_vec_cond_expr_p (tree value_type, tree cmp_op_type, enum tree_code code)
{
  machine_mode value_mode = TYPE_MODE (value_type);
  machine_mode cmp_op_mode = TYPE_MODE (cmp_op_type);
  if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type)
      && get_vcond_mask_icode (TYPE_MODE (value_type),
			       TYPE_MODE (cmp_op_type)) != CODE_FOR_nothing)
    return true;

  if (maybe_ne (GET_MODE_SIZE (value_mode), GET_MODE_SIZE (cmp_op_mode))
      || maybe_ne (GET_MODE_NUNITS (value_mode), GET_MODE_NUNITS (cmp_op_mode)))
    return false;

  if (TREE_CODE_CLASS (code) != tcc_comparison)
    /* This may happen, for example, if code == SSA_NAME, in which case we
       cannot be certain whether a vector insn is available.  */
    return false;

  return vcond_icode_p (value_type, cmp_op_type, code)
	 || vcond_eq_icode_p (value_type, cmp_op_type, code);
}

/* Use the current target and options to initialize
   TREE_OPTIMIZATION_OPTABS (OPTNODE).  */

void
init_tree_optimization_optabs (tree optnode)
{
  /* Quick exit if we have already computed optabs for this target.  */
  if (TREE_OPTIMIZATION_BASE_OPTABS (optnode) == this_target_optabs)
    return;

  /* Forget any previous information and set up for the current target.  */
  TREE_OPTIMIZATION_BASE_OPTABS (optnode) = this_target_optabs;
  struct target_optabs *tmp_optabs = (struct target_optabs *)
    TREE_OPTIMIZATION_OPTABS (optnode);
  if (tmp_optabs)
    memset (tmp_optabs, 0, sizeof (struct target_optabs));
  else
    tmp_optabs = ggc_cleared_alloc<target_optabs> ();

  /* Generate a new set of optabs into tmp_optabs.  */
  init_all_optabs (tmp_optabs);

  /* If the optabs changed, record it.  */
  if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs)))
    TREE_OPTIMIZATION_OPTABS (optnode) = tmp_optabs;
  else
    {
      TREE_OPTIMIZATION_OPTABS (optnode) = NULL;
      ggc_free (tmp_optabs);
    }
}

/* Return TRUE if the target has support for vector right shift of an
   operand of type TYPE.  If OT_TYPE is OPTAB_DEFAULT, check for existence
   of a shift by either a scalar or a vector.  Otherwise, check only
   for a shift that matches OT_TYPE.  */

bool
target_supports_op_p (tree type, enum tree_code code,
		      enum optab_subtype ot_subtype)
{
  optab ot = optab_for_tree_code (code, type, ot_subtype);
  return (ot != unknown_optab
	  && optab_handler (ot, TYPE_MODE (type)) != CODE_FOR_nothing);
}
Commit	Line	Data
385399a8	1	/* Tree-based target query functions relating to optabs
8d9254fc	2	Copyright (C) 1987-2020 Free Software Foundation, Inc.
385399a8 RS	3
	4	This file is part of GCC.
	5
	6	GCC is free software; you can redistribute it and/or modify it under
	7	the terms of the GNU General Public License as published by the Free
	8	Software Foundation; either version 3, or (at your option) any later
	9	version.
	10
	11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with GCC; see the file COPYING3. If not see
	18	<http://www.gnu.org/licenses/>. */
	19
	20
	21	#include "config.h"
	22	#include "system.h"
	23	#include "coretypes.h"
	24	#include "target.h"
	25	#include "insn-codes.h"
dcd2ca63	26	#include "rtl.h"
385399a8	27	#include "tree.h"
dcd2ca63 IL	28	#include "memmodel.h"
dcd2ca63 IL	29	#include "optabs.h"
385399a8 RS	30	#include "optabs-tree.h"
	31	#include "stor-layout.h"
	32
	33	/* Return the optab used for computing the operation given by the tree code,
	34	CODE and the tree EXP. This function is not always usable (for example, it
	35	cannot give complete results for multiplication or division) but probably
	36	ought to be relied on more widely throughout the expander. */
	37	optab
	38	optab_for_tree_code (enum tree_code code, const_tree type,
	39	enum optab_subtype subtype)
	40	{
	41	bool trapv;
	42	switch (code)
	43	{
	44	case BIT_AND_EXPR:
	45	return and_optab;
	46
	47	case BIT_IOR_EXPR:
	48	return ior_optab;
	49
	50	case BIT_NOT_EXPR:
	51	return one_cmpl_optab;
	52
	53	case BIT_XOR_EXPR:
	54	return xor_optab;
	55
	56	case MULT_HIGHPART_EXPR:
	57	return TYPE_UNSIGNED (type) ? umul_highpart_optab : smul_highpart_optab;
	58
	59	case TRUNC_MOD_EXPR:
	60	case CEIL_MOD_EXPR:
	61	case FLOOR_MOD_EXPR:
	62	case ROUND_MOD_EXPR:
	63	return TYPE_UNSIGNED (type) ? umod_optab : smod_optab;
	64
	65	case RDIV_EXPR:
	66	case TRUNC_DIV_EXPR:
	67	case CEIL_DIV_EXPR:
	68	case FLOOR_DIV_EXPR:
	69	case ROUND_DIV_EXPR:
	70	case EXACT_DIV_EXPR:
	71	if (TYPE_SATURATING (type))
	72	return TYPE_UNSIGNED (type) ? usdiv_optab : ssdiv_optab;
	73	return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;
	74
	75	case LSHIFT_EXPR:
	76	if (TREE_CODE (type) == VECTOR_TYPE)
	77	{
	78	if (subtype == optab_vector)
	79	return TYPE_SATURATING (type) ? unknown_optab : vashl_optab;
	80
	81	gcc_assert (subtype == optab_scalar);
	82	}
	83	if (TYPE_SATURATING (type))
	84	return TYPE_UNSIGNED (type) ? usashl_optab : ssashl_optab;
	85	return ashl_optab;
	86
	87	case RSHIFT_EXPR:
	88	if (TREE_CODE (type) == VECTOR_TYPE)
	89	{
	90	if (subtype == optab_vector)
	91	return TYPE_UNSIGNED (type) ? vlshr_optab : vashr_optab;
	92
	93	gcc_assert (subtype == optab_scalar);
94	}
95	return TYPE_UNSIGNED (type) ? lshr_optab : ashr_optab;
96
97	case LROTATE_EXPR:
98	if (TREE_CODE (type) == VECTOR_TYPE)
99	{
100	if (subtype == optab_vector)
101	return vrotl_optab;
102
103	gcc_assert (subtype == optab_scalar);
104	}
105	return rotl_optab;
106
107	case RROTATE_EXPR:
108	if (TREE_CODE (type) == VECTOR_TYPE)
109	{
110	if (subtype == optab_vector)
111	return vrotr_optab;
112
113	gcc_assert (subtype == optab_scalar);
114	}
115	return rotr_optab;
116
117	case MAX_EXPR:
118	return TYPE_UNSIGNED (type) ? umax_optab : smax_optab;
119
120	case MIN_EXPR:
121	return TYPE_UNSIGNED (type) ? umin_optab : smin_optab;
122
123	case REALIGN_LOAD_EXPR:
124	return vec_realign_load_optab;
125
126	case WIDEN_SUM_EXPR:
127	return TYPE_UNSIGNED (type) ? usum_widen_optab : ssum_widen_optab;
128
129	case DOT_PROD_EXPR:
130	return TYPE_UNSIGNED (type) ? udot_prod_optab : sdot_prod_optab;
131
132	case SAD_EXPR:
133	return TYPE_UNSIGNED (type) ? usad_optab : ssad_optab;
134
135	case WIDEN_MULT_PLUS_EXPR:
136	return (TYPE_UNSIGNED (type)
137	? (TYPE_SATURATING (type)
138	? usmadd_widen_optab : umadd_widen_optab)
139	: (TYPE_SATURATING (type)
140	? ssmadd_widen_optab : smadd_widen_optab));
141
142	case WIDEN_MULT_MINUS_EXPR:
143	return (TYPE_UNSIGNED (type)
144	? (TYPE_SATURATING (type)
145	? usmsub_widen_optab : umsub_widen_optab)
146	: (TYPE_SATURATING (type)
147	? ssmsub_widen_optab : smsub_widen_optab));
148
385399a8	149	case VEC_WIDEN_MULT_HI_EXPR:
1bda738b JJ	150	return (TYPE_UNSIGNED (type)
1bda738b JJ	151	? vec_widen_umult_hi_optab : vec_widen_smult_hi_optab);
385399a8 RS	152
385399a8 RS	153	case VEC_WIDEN_MULT_LO_EXPR:
1bda738b JJ	154	return (TYPE_UNSIGNED (type)
1bda738b JJ	155	? vec_widen_umult_lo_optab : vec_widen_smult_lo_optab);
385399a8 RS	156
385399a8 RS	157	case VEC_WIDEN_MULT_EVEN_EXPR:
1bda738b JJ	158	return (TYPE_UNSIGNED (type)
1bda738b JJ	159	? vec_widen_umult_even_optab : vec_widen_smult_even_optab);
385399a8 RS	160
385399a8 RS	161	case VEC_WIDEN_MULT_ODD_EXPR:
1bda738b JJ	162	return (TYPE_UNSIGNED (type)
1bda738b JJ	163	? vec_widen_umult_odd_optab : vec_widen_smult_odd_optab);
385399a8 RS	164
385399a8 RS	165	case VEC_WIDEN_LSHIFT_HI_EXPR:
1bda738b JJ	166	return (TYPE_UNSIGNED (type)
1bda738b JJ	167	? vec_widen_ushiftl_hi_optab : vec_widen_sshiftl_hi_optab);
385399a8 RS	168
385399a8 RS	169	case VEC_WIDEN_LSHIFT_LO_EXPR:
1bda738b JJ	170	return (TYPE_UNSIGNED (type)
1bda738b JJ	171	? vec_widen_ushiftl_lo_optab : vec_widen_sshiftl_lo_optab);
385399a8 RS	172
385399a8 RS	173	case VEC_UNPACK_HI_EXPR:
1bda738b JJ	174	return (TYPE_UNSIGNED (type)
1bda738b JJ	175	? vec_unpacku_hi_optab : vec_unpacks_hi_optab);
385399a8 RS	176
385399a8 RS	177	case VEC_UNPACK_LO_EXPR:
1bda738b JJ	178	return (TYPE_UNSIGNED (type)
1bda738b JJ	179	? vec_unpacku_lo_optab : vec_unpacks_lo_optab);
385399a8 RS	180
	181	case VEC_UNPACK_FLOAT_HI_EXPR:
	182	/* The signedness is determined from input operand. */
1bda738b JJ	183	return (TYPE_UNSIGNED (type)
1bda738b JJ	184	? vec_unpacku_float_hi_optab : vec_unpacks_float_hi_optab);
385399a8 RS	185
	186	case VEC_UNPACK_FLOAT_LO_EXPR:
	187	/* The signedness is determined from input operand. */
1bda738b JJ	188	return (TYPE_UNSIGNED (type)
	189	? vec_unpacku_float_lo_optab : vec_unpacks_float_lo_optab);
	190
	191	case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
	192	/* The signedness is determined from output operand. */
	193	return (TYPE_UNSIGNED (type)
	194	? vec_unpack_ufix_trunc_hi_optab
	195	: vec_unpack_sfix_trunc_hi_optab);
	196
	197	case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
	198	/* The signedness is determined from output operand. */
	199	return (TYPE_UNSIGNED (type)
	200	? vec_unpack_ufix_trunc_lo_optab
	201	: vec_unpack_sfix_trunc_lo_optab);
385399a8 RS	202
	203	case VEC_PACK_TRUNC_EXPR:
	204	return vec_pack_trunc_optab;
	205
	206	case VEC_PACK_SAT_EXPR:
	207	return TYPE_UNSIGNED (type) ? vec_pack_usat_optab : vec_pack_ssat_optab;
	208
	209	case VEC_PACK_FIX_TRUNC_EXPR:
	210	/* The signedness is determined from output operand. */
1bda738b JJ	211	return (TYPE_UNSIGNED (type)
	212	? vec_pack_ufix_trunc_optab : vec_pack_sfix_trunc_optab);
	213
	214	case VEC_PACK_FLOAT_EXPR:
	215	/* The signedness is determined from input operand. */
	216	return (TYPE_UNSIGNED (type)
	217	? vec_packu_float_optab : vec_packs_float_optab);
385399a8	218
be4c1d4a RS	219	case VEC_DUPLICATE_EXPR:
	220	return vec_duplicate_optab;
	221
9adab579 RS	222	case VEC_SERIES_EXPR:
	223	return vec_series_optab;
	224
385399a8 RS	225	default:
	226	break;
	227	}
	228
	229	trapv = INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type);
	230	switch (code)
	231	{
	232	case POINTER_PLUS_EXPR:
	233	case PLUS_EXPR:
	234	if (TYPE_SATURATING (type))
	235	return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab;
	236	return trapv ? addv_optab : add_optab;
	237
1af4ebf5	238	case POINTER_DIFF_EXPR:
385399a8 RS	239	case MINUS_EXPR:
	240	if (TYPE_SATURATING (type))
	241	return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab;
	242	return trapv ? subv_optab : sub_optab;
	243
	244	case MULT_EXPR:
	245	if (TYPE_SATURATING (type))
	246	return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab;
	247	return trapv ? smulv_optab : smul_optab;
	248
	249	case NEGATE_EXPR:
	250	if (TYPE_SATURATING (type))
	251	return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab;
	252	return trapv ? negv_optab : neg_optab;
	253
	254	case ABS_EXPR:
	255	return trapv ? absv_optab : abs_optab;
	256
e197e64e KV	257	case ABSU_EXPR:
e197e64e KV	258	return abs_optab;
385399a8 RS	259	default:
	260	return unknown_optab;
	261	}
	262	}
	263
385399a8 RS	264	/* Function supportable_convert_operation
	265
	266	Check whether an operation represented by the code CODE is a
	267	convert operation that is supported by the target platform in
	268	vector form (i.e., when operating on arguments of type VECTYPE_IN
	269	producing a result of type VECTYPE_OUT).
	270
	271	Convert operations we currently support directly are FIX_TRUNC and FLOAT.
	272	This function checks if these operations are supported
477daf83	273	by the target platform directly (via vector tree-codes).
385399a8 RS	274
	275	Output:
	276	- CODE1 is code of vector operation to be used when
477daf83	277	vectorizing the operation, if available. */
385399a8 RS	278
	279	bool
	280	supportable_convert_operation (enum tree_code code,
	281	tree vectype_out, tree vectype_in,
477daf83	282	enum tree_code *code1)
385399a8 RS	283	{
	284	machine_mode m1,m2;
	285	bool truncp;
	286
b6268016 RS	287	gcc_assert (VECTOR_TYPE_P (vectype_out) && VECTOR_TYPE_P (vectype_in));
b6268016 RS	288
385399a8 RS	289	m1 = TYPE_MODE (vectype_out);
	290	m2 = TYPE_MODE (vectype_in);
	291
b6268016 RS	292	if (!VECTOR_MODE_P (m1) \|\| !VECTOR_MODE_P (m2))
	293	return false;
	294
385399a8 RS	295	/* First check if we can done conversion directly. */
	296	if ((code == FIX_TRUNC_EXPR
	297	&& can_fix_p (m1,m2,TYPE_UNSIGNED (vectype_out), &truncp)
	298	!= CODE_FOR_nothing)
	299	\|\| (code == FLOAT_EXPR
	300	&& can_float_p (m1,m2,TYPE_UNSIGNED (vectype_in))
	301	!= CODE_FOR_nothing))
	302	{
	303	*code1 = code;
	304	return true;
	305	}
	306
9c437a10 RS	307	if (GET_MODE_UNIT_PRECISION (m1) > GET_MODE_UNIT_PRECISION (m2)
	308	&& can_extend_p (m1, m2, TYPE_UNSIGNED (vectype_in)))
	309	{
	310	*code1 = code;
	311	return true;
	312	}
	313
	314	if (GET_MODE_UNIT_PRECISION (m1) < GET_MODE_UNIT_PRECISION (m2)
	315	&& convert_optab_handler (trunc_optab, m1, m2) != CODE_FOR_nothing)
	316	{
	317	*code1 = code;
	318	return true;
	319	}
	320
385399a8 RS	321	return false;
	322	}
	323
42fd8198 IE	324	/* Return TRUE if appropriate vector insn is available
	325	for vector comparison expr with vector type VALUE_TYPE
	326	and resulting mask with MASK_TYPE. */
	327
	328	bool
96592eed	329	expand_vec_cmp_expr_p (tree value_type, tree mask_type, enum tree_code code)
42fd8198	330	{
96592eed JJ	331	if (get_vec_cmp_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type),
	332	TYPE_UNSIGNED (value_type)) != CODE_FOR_nothing)
	333	return true;
	334	if ((code == EQ_EXPR \|\| code == NE_EXPR)
	335	&& (get_vec_cmp_eq_icode (TYPE_MODE (value_type), TYPE_MODE (mask_type))
	336	!= CODE_FOR_nothing))
	337	return true;
	338	return false;
42fd8198 IE	339	}
42fd8198 IE	340
dcd2ca63 IL	341	/* Return true iff vcond_optab/vcondu_optab can handle a vector
	342	comparison for code CODE, comparing operands of type CMP_OP_TYPE and
	343	producing a result of type VALUE_TYPE. */
	344
	345	static bool
	346	vcond_icode_p (tree value_type, tree cmp_op_type, enum tree_code code)
	347	{
	348	return can_vcond_compare_p (get_rtx_code (code, TYPE_UNSIGNED (cmp_op_type)),
	349	TYPE_MODE (value_type), TYPE_MODE (cmp_op_type));
	350	}
	351
	352	/* Return true iff vcondeq_optab can handle a vector comparison for code CODE,
	353	comparing operands of type CMP_OP_TYPE and producing a result of type
	354	VALUE_TYPE. */
	355
	356	static bool
	357	vcond_eq_icode_p (tree value_type, tree cmp_op_type, enum tree_code code)
	358	{
	359	if (code != EQ_EXPR && code != NE_EXPR)
	360	return false;
	361
	362	return get_vcond_eq_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type))
	363	!= CODE_FOR_nothing;
	364	}
	365
385399a8 RS	366	/* Return TRUE iff, appropriate vector insns are available
	367	for vector cond expr with vector type VALUE_TYPE and a comparison
	368	with operand vector types in CMP_OP_TYPE. */
	369
	370	bool
96592eed	371	expand_vec_cond_expr_p (tree value_type, tree cmp_op_type, enum tree_code code)
385399a8 RS	372	{
	373	machine_mode value_mode = TYPE_MODE (value_type);
	374	machine_mode cmp_op_mode = TYPE_MODE (cmp_op_type);
0d99886f AP	375	if (VECTOR_BOOLEAN_TYPE_P (cmp_op_type)
	376	&& get_vcond_mask_icode (TYPE_MODE (value_type),
	377	TYPE_MODE (cmp_op_type)) != CODE_FOR_nothing)
	378	return true;
	379
cf098191	380	if (maybe_ne (GET_MODE_SIZE (value_mode), GET_MODE_SIZE (cmp_op_mode))
7b777afa	381	\|\| maybe_ne (GET_MODE_NUNITS (value_mode), GET_MODE_NUNITS (cmp_op_mode)))
385399a8	382	return false;
96592eed	383
dcd2ca63 IL	384	if (TREE_CODE_CLASS (code) != tcc_comparison)
	385	/* This may happen, for example, if code == SSA_NAME, in which case we
	386	cannot be certain whether a vector insn is available. */
96592eed JJ	387	return false;
96592eed JJ	388
dcd2ca63 IL	389	return vcond_icode_p (value_type, cmp_op_type, code)
dcd2ca63 IL	390	\|\| vcond_eq_icode_p (value_type, cmp_op_type, code);
385399a8 RS	391	}
	392
	393	/* Use the current target and options to initialize
	394	TREE_OPTIMIZATION_OPTABS (OPTNODE). */
	395
	396	void
	397	init_tree_optimization_optabs (tree optnode)
	398	{
	399	/* Quick exit if we have already computed optabs for this target. */
	400	if (TREE_OPTIMIZATION_BASE_OPTABS (optnode) == this_target_optabs)
	401	return;
	402
	403	/* Forget any previous information and set up for the current target. */
	404	TREE_OPTIMIZATION_BASE_OPTABS (optnode) = this_target_optabs;
	405	struct target_optabs tmp_optabs = (struct target_optabs )
	406	TREE_OPTIMIZATION_OPTABS (optnode);
	407	if (tmp_optabs)
	408	memset (tmp_optabs, 0, sizeof (struct target_optabs));
	409	else
bfaa08b7	410	tmp_optabs = ggc_cleared_alloc<target_optabs> ();
385399a8 RS	411
	412	/* Generate a new set of optabs into tmp_optabs. */
	413	init_all_optabs (tmp_optabs);
	414
	415	/* If the optabs changed, record it. */
	416	if (memcmp (tmp_optabs, this_target_optabs, sizeof (struct target_optabs)))
	417	TREE_OPTIMIZATION_OPTABS (optnode) = tmp_optabs;
	418	else
	419	{
	420	TREE_OPTIMIZATION_OPTABS (optnode) = NULL;
	421	ggc_free (tmp_optabs);
	422	}
	423	}
71f82be9 JG	424
	425	/* Return TRUE if the target has support for vector right shift of an
	426	operand of type TYPE. If OT_TYPE is OPTAB_DEFAULT, check for existence
	427	of a shift by either a scalar or a vector. Otherwise, check only
	428	for a shift that matches OT_TYPE. */
	429
	430	bool
	431	target_supports_op_p (tree type, enum tree_code code,
	432	enum optab_subtype ot_subtype)
	433	{
	434	optab ot = optab_for_tree_code (code, type, ot_subtype);
	435	return (ot != unknown_optab
	436	&& optab_handler (ot, TYPE_MODE (type)) != CODE_FOR_nothing);
	437	}
	438