[thirdparty/gcc.git] / gcc / ccmp.c

/* Conditional compare related functions
   Copyright (C) 2014-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 "backend.h"
#include "target.h"
#include "rtl.h"
#include "tree.h"
#include "gimple.h"
#include "memmodel.h"
#include "tm_p.h"
#include "ssa.h"
#include "expmed.h"
#include "optabs.h"
#include "emit-rtl.h"
#include "stor-layout.h"
#include "tree-ssa-live.h"
#include "tree-outof-ssa.h"
#include "cfgexpand.h"
#include "ccmp.h"
#include "predict.h"

/* Check whether T is a simple boolean variable or a SSA name
   set by a comparison operator in the same basic block.  */
static bool
ccmp_tree_comparison_p (tree t, basic_block bb)
{
  gimple *g = get_gimple_for_ssa_name (t);
  tree_code tcode;

  /* If we have a boolean variable allow it and generate a compare
     to zero reg when expanding.  */
  if (!g)
    return (TREE_CODE (TREE_TYPE (t)) == BOOLEAN_TYPE);

  /* Check to see if SSA name is set by a comparison operator in
     the same basic block.  */ 
  if (!is_gimple_assign (g))
    return false;
  if (bb != gimple_bb (g))
    return false;
  tcode = gimple_assign_rhs_code (g);
  return TREE_CODE_CLASS (tcode) == tcc_comparison;
}

/* The following functions expand conditional compare (CCMP) instructions.
   Here is a short description about the over all algorithm:
     * ccmp_candidate_p is used to identify the CCMP candidate

     * expand_ccmp_expr is the main entry, which calls expand_ccmp_expr_1
       to expand CCMP.

     * expand_ccmp_expr_1 uses a recursive algorithm to expand CCMP.
       It calls two target hooks gen_ccmp_first and gen_ccmp_next to generate
       CCMP instructions.
	 - gen_ccmp_first expands the first compare in CCMP.
	 - gen_ccmp_next expands the following compares.

       Both hooks return a comparison with the CC register that is equivalent
       to the value of the gimple comparison.  This is used by the next CCMP
       and in the final conditional store.

     * We use cstorecc4 pattern to convert the CCmode intermediate to
       the integer mode result that expand_normal is expecting.

   Since the operands of the later compares might clobber CC reg, we do not
   emit the insns during expand.  We keep the insn sequences in two seq

     * prep_seq, which includes all the insns to prepare the operands.
     * gen_seq, which includes all the compare and conditional compares.

   If all checks OK in expand_ccmp_expr, it emits insns in prep_seq, then
   insns in gen_seq.  */

/* Check whether G is a potential conditional compare candidate.  */
static bool
ccmp_candidate_p (gimple *g)
{
  tree lhs, op0, op1;
  gimple *gs0, *gs1;
  tree_code tcode;
  basic_block bb;

  if (!g)
    return false;

  tcode = gimple_assign_rhs_code (g);
  if (tcode != BIT_AND_EXPR && tcode != BIT_IOR_EXPR)
    return false;

  lhs = gimple_assign_lhs (g);
  op0 = gimple_assign_rhs1 (g);
  op1 = gimple_assign_rhs2 (g);
  if ((TREE_CODE (op0) != SSA_NAME) || (TREE_CODE (op1) != SSA_NAME)
      || !has_single_use (lhs))
    return false;

  bb = gimple_bb (g);
  gs0 = get_gimple_for_ssa_name (op0); /* gs0 may be NULL */
  gs1 = get_gimple_for_ssa_name (op1); /* gs1 may be NULL */

  if (ccmp_tree_comparison_p (op0, bb) && ccmp_tree_comparison_p (op1, bb))
    return true;
  if (ccmp_tree_comparison_p (op0, bb) && ccmp_candidate_p (gs1))
    return true;
  if (ccmp_tree_comparison_p (op1, bb) && ccmp_candidate_p (gs0))
    return true;
  /* We skip ccmp_candidate_p (gs1) && ccmp_candidate_p (gs0) since
     there is no way to set and maintain the CC flag on both sides of
     the logical operator at the same time.  */
  return false;
}

/* Extract the comparison we want to do from the tree.  */
void
get_compare_parts (tree t, int *up, rtx_code *rcode,
		   tree *rhs1, tree *rhs2)
{
  tree_code code;
  gimple *g = get_gimple_for_ssa_name (t);
  if (g)
    {
      *up = TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (g)));
      code = gimple_assign_rhs_code (g);
      *rcode = get_rtx_code (code, *up);
      *rhs1 = gimple_assign_rhs1 (g);
      *rhs2 = gimple_assign_rhs2 (g);
    }
  else
    {
      /* If g is not a comparison operator create a compare to zero.  */
      *up = 1;
      *rcode = NE;
      *rhs1 = t;
      *rhs2 = build_zero_cst (TREE_TYPE (t));
    }
}

/* PREV is a comparison with the CC register which represents the
   result of the previous CMP or CCMP.  The function expands the
   next compare based on G which is ANDed/ORed with the previous
   compare depending on CODE.
   PREP_SEQ returns all insns to prepare opearands for compare.
   GEN_SEQ returns all compare insns.  */
static rtx
expand_ccmp_next (tree op, tree_code code, rtx prev,
		  rtx_insn **prep_seq, rtx_insn **gen_seq)
{
  rtx_code rcode;
  int unsignedp;
  tree rhs1, rhs2;

  get_compare_parts(op, &unsignedp, &rcode, &rhs1, &rhs2);
  return targetm.gen_ccmp_next (prep_seq, gen_seq, prev, rcode,
				rhs1, rhs2, get_rtx_code (code, 0));
}

/* Expand conditional compare gimple G.  A typical CCMP sequence is like:

     CC0 = CMP (a, b);
     CC1 = CCMP (NE (CC0, 0), CMP (e, f));
     ...
     CCn = CCMP (NE (CCn-1, 0), CMP (...));

   hook gen_ccmp_first is used to expand the first compare.
   hook gen_ccmp_next is used to expand the following CCMP.
   PREP_SEQ returns all insns to prepare opearand.
   GEN_SEQ returns all compare insns.  */
static rtx
expand_ccmp_expr_1 (gimple *g, rtx_insn **prep_seq, rtx_insn **gen_seq)
{
  tree_code code = gimple_assign_rhs_code (g);
  basic_block bb = gimple_bb (g);

  tree op0 = gimple_assign_rhs1 (g);
  tree op1 = gimple_assign_rhs2 (g);
  gimple *gs0 = get_gimple_for_ssa_name (op0);
  gimple *gs1 = get_gimple_for_ssa_name (op1);
  rtx tmp;

  gcc_assert (code == BIT_AND_EXPR || code == BIT_IOR_EXPR);

  if (ccmp_tree_comparison_p (op0, bb))
    {
      if (ccmp_tree_comparison_p (op1, bb))
	{
	  int unsignedp0, unsignedp1;
	  rtx_code rcode0, rcode1;
	  tree logical_op0_rhs1, logical_op0_rhs2;
	  tree logical_op1_rhs1, logical_op1_rhs2;
	  int speed_p = optimize_insn_for_speed_p ();

	  rtx tmp2 = NULL_RTX, ret = NULL_RTX, ret2 = NULL_RTX;
	  unsigned cost1 = MAX_COST;
	  unsigned cost2 = MAX_COST;

	  get_compare_parts (op0, &unsignedp0, &rcode0,
			     &logical_op0_rhs1, &logical_op0_rhs2);

	  get_compare_parts (op1, &unsignedp1, &rcode1,
			     &logical_op1_rhs1, &logical_op1_rhs2);

	  rtx_insn *prep_seq_1, *gen_seq_1;
	  tmp = targetm.gen_ccmp_first (&prep_seq_1, &gen_seq_1, rcode0,
					logical_op0_rhs1, logical_op0_rhs2);
	  if (tmp != NULL)
	    {
	      ret = expand_ccmp_next (op1, code, tmp, &prep_seq_1, &gen_seq_1);
	      cost1 = seq_cost (prep_seq_1, speed_p);
	      cost1 += seq_cost (gen_seq_1, speed_p);
	    }

	  /* FIXME: Temporary workaround for PR69619.
	     Avoid exponential compile time due to expanding gs0 and gs1 twice.
	     If gs0 and gs1 are complex, the cost will be high, so avoid
	     reevaluation if above an arbitrary threshold.  */
	  rtx_insn *prep_seq_2, *gen_seq_2;
	  if (tmp == NULL || cost1 < COSTS_N_INSNS (25))
	    tmp2 = targetm.gen_ccmp_first (&prep_seq_2, &gen_seq_2, rcode1,
					   logical_op1_rhs1, logical_op1_rhs2);
	  if (!tmp && !tmp2)
	    return NULL_RTX;
	  if (tmp2 != NULL)
	    {
	      ret2 = expand_ccmp_next (op0, code, tmp2, &prep_seq_2,
				       &gen_seq_2);
	      cost2 = seq_cost (prep_seq_2, speed_p);
	      cost2 += seq_cost (gen_seq_2, speed_p);
	    }
	  if (cost2 < cost1)
	    {
	      *prep_seq = prep_seq_2;
	      *gen_seq = gen_seq_2;
	      return ret2;
	    }
	  *prep_seq = prep_seq_1;
	  *gen_seq = gen_seq_1;
	  return ret;
	}
      else
	{
	  tmp = expand_ccmp_expr_1 (gs1, prep_seq, gen_seq);
	  if (!tmp)
	    return NULL_RTX;
	  return expand_ccmp_next (op0, code, tmp, prep_seq, gen_seq);
	}
    }
  else
    {
      gcc_assert (gimple_assign_rhs_code (gs0) == BIT_AND_EXPR
                  || gimple_assign_rhs_code (gs0) == BIT_IOR_EXPR);
      gcc_assert (ccmp_tree_comparison_p (op1, bb));
      tmp = expand_ccmp_expr_1 (gs0, prep_seq, gen_seq);
      if (!tmp)
	return NULL_RTX;
      return expand_ccmp_next (op1, code, tmp, prep_seq, gen_seq);
    }

  return NULL_RTX;
}

/* Main entry to expand conditional compare statement G.
   Return NULL_RTX if G is not a legal candidate or expand fail.
   Otherwise return the target.  */
rtx
expand_ccmp_expr (gimple *g, machine_mode mode)
{
  rtx_insn *last;
  rtx tmp;

  if (!ccmp_candidate_p (g))
    return NULL_RTX;

  last = get_last_insn ();

  rtx_insn *prep_seq = NULL, *gen_seq = NULL;
  tmp = expand_ccmp_expr_1 (g, &prep_seq, &gen_seq);

  if (tmp)
    {
      insn_code icode;
      machine_mode cc_mode = CCmode;
      rtx_code cmp_code = GET_CODE (tmp);

#ifdef SELECT_CC_MODE
      cc_mode = SELECT_CC_MODE (cmp_code, XEXP (tmp, 0), const0_rtx);
#endif
      icode = optab_handler (cstore_optab, cc_mode);
      if (icode != CODE_FOR_nothing)
	{
	  rtx target = gen_reg_rtx (mode);

	  emit_insn (prep_seq);
	  emit_insn (gen_seq);

	  tmp = emit_cstore (target, icode, cmp_code, cc_mode, cc_mode,
			     0, XEXP (tmp, 0), const0_rtx, 1, mode);
	  if (tmp)
	    return tmp;
	}
    }
  /* Clean up.  */
  delete_insns_since (last);
  return NULL_RTX;
}
Commit	Line	Data
f06cd23d	1	/* Conditional compare related functions
8d9254fc	2	Copyright (C) 2014-2020 Free Software Foundation, Inc.
f06cd23d ZC	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	#include "config.h"
	21	#include "system.h"
	22	#include "coretypes.h"
c7131fb2	23	#include "backend.h"
957060b5 AM	24	#include "target.h"
957060b5 AM	25	#include "rtl.h"
c7131fb2 AM	26	#include "tree.h"
c7131fb2 AM	27	#include "gimple.h"
4d0cdd0c	28	#include "memmodel.h"
f06cd23d	29	#include "tm_p.h"
957060b5 AM	30	#include "ssa.h"
	31	#include "expmed.h"
	32	#include "optabs.h"
957060b5	33	#include "emit-rtl.h"
f06cd23d	34	#include "stor-layout.h"
f06cd23d ZC	35	#include "tree-ssa-live.h"
	36	#include "tree-outof-ssa.h"
	37	#include "cfgexpand.h"
f06cd23d	38	#include "ccmp.h"
078fe40a	39	#include "predict.h"
f06cd23d	40
f580a969 SE	41	/* Check whether T is a simple boolean variable or a SSA name
	42	set by a comparison operator in the same basic block. */
	43	static bool
	44	ccmp_tree_comparison_p (tree t, basic_block bb)
	45	{
	46	gimple *g = get_gimple_for_ssa_name (t);
	47	tree_code tcode;
	48
	49	/* If we have a boolean variable allow it and generate a compare
	50	to zero reg when expanding. */
	51	if (!g)
	52	return (TREE_CODE (TREE_TYPE (t)) == BOOLEAN_TYPE);
	53
	54	/* Check to see if SSA name is set by a comparison operator in
	55	the same basic block. */
	56	if (!is_gimple_assign (g))
	57	return false;
	58	if (bb != gimple_bb (g))
	59	return false;
	60	tcode = gimple_assign_rhs_code (g);
	61	return TREE_CODE_CLASS (tcode) == tcc_comparison;
	62	}
	63
f06cd23d ZC	64	/* The following functions expand conditional compare (CCMP) instructions.
	65	Here is a short description about the over all algorithm:
	66	* ccmp_candidate_p is used to identify the CCMP candidate
	67
	68	* expand_ccmp_expr is the main entry, which calls expand_ccmp_expr_1
	69	to expand CCMP.
	70
	71	* expand_ccmp_expr_1 uses a recursive algorithm to expand CCMP.
	72	It calls two target hooks gen_ccmp_first and gen_ccmp_next to generate
	73	CCMP instructions.
	74	- gen_ccmp_first expands the first compare in CCMP.
	75	- gen_ccmp_next expands the following compares.
	76
c8012fbc WD	77	Both hooks return a comparison with the CC register that is equivalent
	78	to the value of the gimple comparison. This is used by the next CCMP
	79	and in the final conditional store.
	80
4005b96a RH	81	* We use cstorecc4 pattern to convert the CCmode intermediate to
4005b96a RH	82	the integer mode result that expand_normal is expecting.
5f3bc026 ZC	83
	84	Since the operands of the later compares might clobber CC reg, we do not
	85	emit the insns during expand. We keep the insn sequences in two seq
	86
	87	* prep_seq, which includes all the insns to prepare the operands.
	88	* gen_seq, which includes all the compare and conditional compares.
	89
	90	If all checks OK in expand_ccmp_expr, it emits insns in prep_seq, then
	91	insns in gen_seq. */
f06cd23d ZC	92
	93	/* Check whether G is a potential conditional compare candidate. */
	94	static bool
355fe088	95	ccmp_candidate_p (gimple *g)
f06cd23d	96	{
f06cd23d	97	tree lhs, op0, op1;
355fe088	98	gimple gs0, gs1;
f580a969 SE	99	tree_code tcode;
	100	basic_block bb;
	101
	102	if (!g)
	103	return false;
f06cd23d	104
d6a73cc3	105	tcode = gimple_assign_rhs_code (g);
f06cd23d ZC	106	if (tcode != BIT_AND_EXPR && tcode != BIT_IOR_EXPR)
	107	return false;
	108
	109	lhs = gimple_assign_lhs (g);
d6a73cc3 RB	110	op0 = gimple_assign_rhs1 (g);
d6a73cc3 RB	111	op1 = gimple_assign_rhs2 (g);
f06cd23d ZC	112	if ((TREE_CODE (op0) != SSA_NAME) \|\| (TREE_CODE (op1) != SSA_NAME)
	113	\|\| !has_single_use (lhs))
	114	return false;
	115
d6a73cc3	116	bb = gimple_bb (g);
f580a969 SE	117	gs0 = get_gimple_for_ssa_name (op0); /* gs0 may be NULL */
f580a969 SE	118	gs1 = get_gimple_for_ssa_name (op1); /* gs1 may be NULL */
f06cd23d	119
f580a969	120	if (ccmp_tree_comparison_p (op0, bb) && ccmp_tree_comparison_p (op1, bb))
f06cd23d	121	return true;
f580a969	122	if (ccmp_tree_comparison_p (op0, bb) && ccmp_candidate_p (gs1))
f06cd23d	123	return true;
f580a969	124	if (ccmp_tree_comparison_p (op1, bb) && ccmp_candidate_p (gs0))
f06cd23d ZC	125	return true;
f06cd23d ZC	126	/* We skip ccmp_candidate_p (gs1) && ccmp_candidate_p (gs0) since
f580a969 SE	127	there is no way to set and maintain the CC flag on both sides of
f580a969 SE	128	the logical operator at the same time. */
f06cd23d ZC	129	return false;
	130	}
	131
f580a969 SE	132	/* Extract the comparison we want to do from the tree. */
	133	void
	134	get_compare_parts (tree t, int up, rtx_code rcode,
	135	tree rhs1, tree rhs2)
	136	{
	137	tree_code code;
	138	gimple *g = get_gimple_for_ssa_name (t);
	139	if (g)
	140	{
	141	*up = TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (g)));
	142	code = gimple_assign_rhs_code (g);
	143	rcode = get_rtx_code (code, up);
	144	*rhs1 = gimple_assign_rhs1 (g);
	145	*rhs2 = gimple_assign_rhs2 (g);
	146	}
	147	else
	148	{
	149	/* If g is not a comparison operator create a compare to zero. */
	150	*up = 1;
	151	*rcode = NE;
	152	*rhs1 = t;
	153	*rhs2 = build_zero_cst (TREE_TYPE (t));
	154	}
	155	}
	156
c8012fbc WD	157	/* PREV is a comparison with the CC register which represents the
	158	result of the previous CMP or CCMP. The function expands the
	159	next compare based on G which is ANDed/ORed with the previous
	160	compare depending on CODE.
5f3bc026	161	PREP_SEQ returns all insns to prepare opearands for compare.
c8012fbc	162	GEN_SEQ returns all compare insns. */
5f3bc026	163	static rtx
f580a969	164	expand_ccmp_next (tree op, tree_code code, rtx prev,
cb4347e8	165	rtx_insn prep_seq, rtx_insn gen_seq)
5f3bc026	166	{
078fe40a	167	rtx_code rcode;
f580a969 SE	168	int unsignedp;
f580a969 SE	169	tree rhs1, rhs2;
5f3bc026	170
f580a969	171	get_compare_parts(op, &unsignedp, &rcode, &rhs1, &rhs2);
5f3bc026	172	return targetm.gen_ccmp_next (prep_seq, gen_seq, prev, rcode,
f580a969	173	rhs1, rhs2, get_rtx_code (code, 0));
5f3bc026 ZC	174	}
5f3bc026 ZC	175
f06cd23d ZC	176	/* Expand conditional compare gimple G. A typical CCMP sequence is like:
	177
	178	CC0 = CMP (a, b);
	179	CC1 = CCMP (NE (CC0, 0), CMP (e, f));
	180	...
	181	CCn = CCMP (NE (CCn-1, 0), CMP (...));
	182
	183	hook gen_ccmp_first is used to expand the first compare.
5f3bc026 ZC	184	hook gen_ccmp_next is used to expand the following CCMP.
	185	PREP_SEQ returns all insns to prepare opearand.
	186	GEN_SEQ returns all compare insns. */
f06cd23d	187	static rtx
cb4347e8	188	expand_ccmp_expr_1 (gimple g, rtx_insn prep_seq, rtx_insn *gen_seq)
f06cd23d	189	{
8666d8bd	190	tree_code code = gimple_assign_rhs_code (g);
f580a969 SE	191	basic_block bb = gimple_bb (g);
f580a969 SE	192
8666d8bd RB	193	tree op0 = gimple_assign_rhs1 (g);
8666d8bd RB	194	tree op1 = gimple_assign_rhs2 (g);
f580a969 SE	195	gimple *gs0 = get_gimple_for_ssa_name (op0);
f580a969 SE	196	gimple *gs1 = get_gimple_for_ssa_name (op1);
f06cd23d	197	rtx tmp;
f06cd23d ZC	198
f06cd23d ZC	199	gcc_assert (code == BIT_AND_EXPR \|\| code == BIT_IOR_EXPR);
f06cd23d	200
f580a969	201	if (ccmp_tree_comparison_p (op0, bb))
f06cd23d	202	{
f580a969	203	if (ccmp_tree_comparison_p (op1, bb))
f06cd23d	204	{
078fe40a WD	205	int unsignedp0, unsignedp1;
078fe40a WD	206	rtx_code rcode0, rcode1;
f580a969 SE	207	tree logical_op0_rhs1, logical_op0_rhs2;
f580a969 SE	208	tree logical_op1_rhs1, logical_op1_rhs2;
078fe40a	209	int speed_p = optimize_insn_for_speed_p ();
f580a969	210
e0b059b1	211	rtx tmp2 = NULL_RTX, ret = NULL_RTX, ret2 = NULL_RTX;
078fe40a WD	212	unsigned cost1 = MAX_COST;
078fe40a WD	213	unsigned cost2 = MAX_COST;
f06cd23d	214
f580a969 SE	215	get_compare_parts (op0, &unsignedp0, &rcode0,
	216	&logical_op0_rhs1, &logical_op0_rhs2);
	217
	218	get_compare_parts (op1, &unsignedp1, &rcode1,
	219	&logical_op1_rhs1, &logical_op1_rhs2);
5f3bc026	220
cb4347e8	221	rtx_insn prep_seq_1, gen_seq_1;
078fe40a	222	tmp = targetm.gen_ccmp_first (&prep_seq_1, &gen_seq_1, rcode0,
f580a969	223	logical_op0_rhs1, logical_op0_rhs2);
078fe40a WD	224	if (tmp != NULL)
078fe40a WD	225	{
f580a969	226	ret = expand_ccmp_next (op1, code, tmp, &prep_seq_1, &gen_seq_1);
cb4347e8 TS	227	cost1 = seq_cost (prep_seq_1, speed_p);
cb4347e8 TS	228	cost1 += seq_cost (gen_seq_1, speed_p);
078fe40a	229	}
e0b059b1 WD	230
	231	/* FIXME: Temporary workaround for PR69619.
	232	Avoid exponential compile time due to expanding gs0 and gs1 twice.
	233	If gs0 and gs1 are complex, the cost will be high, so avoid
	234	reevaluation if above an arbitrary threshold. */
cb4347e8	235	rtx_insn prep_seq_2, gen_seq_2;
e0b059b1 WD	236	if (tmp == NULL \|\| cost1 < COSTS_N_INSNS (25))
e0b059b1 WD	237	tmp2 = targetm.gen_ccmp_first (&prep_seq_2, &gen_seq_2, rcode1,
f580a969	238	logical_op1_rhs1, logical_op1_rhs2);
e0b059b1 WD	239	if (!tmp && !tmp2)
e0b059b1 WD	240	return NULL_RTX;
078fe40a WD	241	if (tmp2 != NULL)
078fe40a WD	242	{
f580a969	243	ret2 = expand_ccmp_next (op0, code, tmp2, &prep_seq_2,
078fe40a	244	&gen_seq_2);
cb4347e8 TS	245	cost2 = seq_cost (prep_seq_2, speed_p);
cb4347e8 TS	246	cost2 += seq_cost (gen_seq_2, speed_p);
078fe40a	247	}
078fe40a WD	248	if (cost2 < cost1)
	249	{
	250	*prep_seq = prep_seq_2;
	251	*gen_seq = gen_seq_2;
	252	return ret2;
	253	}
078fe40a WD	254	*prep_seq = prep_seq_1;
	255	*gen_seq = gen_seq_1;
	256	return ret;
f06cd23d ZC	257	}
	258	else
	259	{
5f3bc026 ZC	260	tmp = expand_ccmp_expr_1 (gs1, prep_seq, gen_seq);
	261	if (!tmp)
	262	return NULL_RTX;
f580a969	263	return expand_ccmp_next (op0, code, tmp, prep_seq, gen_seq);
f06cd23d ZC	264	}
	265	}
	266	else
	267	{
	268	gcc_assert (gimple_assign_rhs_code (gs0) == BIT_AND_EXPR
	269	\|\| gimple_assign_rhs_code (gs0) == BIT_IOR_EXPR);
f580a969 SE	270	gcc_assert (ccmp_tree_comparison_p (op1, bb));
	271	tmp = expand_ccmp_expr_1 (gs0, prep_seq, gen_seq);
	272	if (!tmp)
	273	return NULL_RTX;
	274	return expand_ccmp_next (op1, code, tmp, prep_seq, gen_seq);
f06cd23d ZC	275	}
	276
	277	return NULL_RTX;
	278	}
	279
c8012fbc	280	/* Main entry to expand conditional compare statement G.
f06cd23d ZC	281	Return NULL_RTX if G is not a legal candidate or expand fail.
	282	Otherwise return the target. */
	283	rtx
f580a969	284	expand_ccmp_expr (gimple *g, machine_mode mode)
f06cd23d ZC	285	{
	286	rtx_insn *last;
	287	rtx tmp;
	288
	289	if (!ccmp_candidate_p (g))
	290	return NULL_RTX;
	291
	292	last = get_last_insn ();
cb4347e8 TS	293
cb4347e8 TS	294	rtx_insn prep_seq = NULL, gen_seq = NULL;
5f3bc026	295	tmp = expand_ccmp_expr_1 (g, &prep_seq, &gen_seq);
f06cd23d ZC	296
	297	if (tmp)
	298	{
078fe40a WD	299	insn_code icode;
078fe40a WD	300	machine_mode cc_mode = CCmode;
c8012fbc	301	rtx_code cmp_code = GET_CODE (tmp);
5f3bc026	302
f06cd23d	303	#ifdef SELECT_CC_MODE
c8012fbc	304	cc_mode = SELECT_CC_MODE (cmp_code, XEXP (tmp, 0), const0_rtx);
f06cd23d	305	#endif
f06cd23d ZC	306	icode = optab_handler (cstore_optab, cc_mode);
	307	if (icode != CODE_FOR_nothing)
	308	{
f06cd23d	309	rtx target = gen_reg_rtx (mode);
5f3bc026 ZC	310
	311	emit_insn (prep_seq);
	312	emit_insn (gen_seq);
	313
c8012fbc WD	314	tmp = emit_cstore (target, icode, cmp_code, cc_mode, cc_mode,
c8012fbc WD	315	0, XEXP (tmp, 0), const0_rtx, 1, mode);
f06cd23d ZC	316	if (tmp)
	317	return tmp;
	318	}
	319	}
	320	/* Clean up. */
	321	delete_insns_since (last);
	322	return NULL_RTX;
	323	}