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

/* Conditional compare related functions
   Copyright (C) 2014-2018 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 exp = gimple_assign_rhs_to_tree (g);
  tree_code code = TREE_CODE (exp);
  basic_block bb = gimple_bb (g);

  tree op0 = TREE_OPERAND (exp, 0);
  tree op1 = TREE_OPERAND (exp, 1);
  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
9336ad57	1	/* Conditional compare related functions
8e8f6434	2	Copyright (C) 2014-2018 Free Software Foundation, Inc.
9336ad57	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"
9ef16211	23	#include "backend.h"
7c29e30e	24	#include "target.h"
7c29e30e	25	#include "rtl.h"
9ef16211	26	#include "tree.h"
9ef16211	27	#include "gimple.h"
ad7b10a2	28	#include "memmodel.h"
9336ad57	29	#include "tm_p.h"
7c29e30e	30	#include "ssa.h"
	31	#include "expmed.h"
	32	#include "optabs.h"
7c29e30e	33	#include "emit-rtl.h"
9336ad57	34	#include "stor-layout.h"
9336ad57	35	#include "tree-ssa-live.h"
	36	#include "tree-outof-ssa.h"
	37	#include "cfgexpand.h"
9336ad57	38	#include "ccmp.h"
07bd240e	39	#include "predict.h"
9336ad57	40
7b65258a	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
9336ad57	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
dad0993e	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
7e6fef85	81	* We use cstorecc4 pattern to convert the CCmode intermediate to
7e6fef85	82	the integer mode result that expand_normal is expecting.
636fb80b	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. */
9336ad57	92
	93	/* Check whether G is a potential conditional compare candidate. */
	94	static bool
42acab1c	95	ccmp_candidate_p (gimple *g)
9336ad57	96	{
9336ad57	97	tree lhs, op0, op1;
42acab1c	98	gimple gs0, gs1;
7b65258a	99	tree_code tcode;
	100	basic_block bb;
	101
	102	if (!g)
	103	return false;
9336ad57	104
2bb3e41d	105	tcode = gimple_assign_rhs_code (g);
9336ad57	106	if (tcode != BIT_AND_EXPR && tcode != BIT_IOR_EXPR)
	107	return false;
	108
	109	lhs = gimple_assign_lhs (g);
2bb3e41d	110	op0 = gimple_assign_rhs1 (g);
2bb3e41d	111	op1 = gimple_assign_rhs2 (g);
9336ad57	112	if ((TREE_CODE (op0) != SSA_NAME) \|\| (TREE_CODE (op1) != SSA_NAME)
	113	\|\| !has_single_use (lhs))
	114	return false;
	115
2bb3e41d	116	bb = gimple_bb (g);
7b65258a	117	gs0 = get_gimple_for_ssa_name (op0); /* gs0 may be NULL */
7b65258a	118	gs1 = get_gimple_for_ssa_name (op1); /* gs1 may be NULL */
9336ad57	119
7b65258a	120	if (ccmp_tree_comparison_p (op0, bb) && ccmp_tree_comparison_p (op1, bb))
9336ad57	121	return true;
7b65258a	122	if (ccmp_tree_comparison_p (op0, bb) && ccmp_candidate_p (gs1))
9336ad57	123	return true;
7b65258a	124	if (ccmp_tree_comparison_p (op1, bb) && ccmp_candidate_p (gs0))
9336ad57	125	return true;
9336ad57	126	/* We skip ccmp_candidate_p (gs1) && ccmp_candidate_p (gs0) since
7b65258a	127	there is no way to set and maintain the CC flag on both sides of
7b65258a	128	the logical operator at the same time. */
9336ad57	129	return false;
	130	}
	131
7b65258a	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
dad0993e	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.
636fb80b	161	PREP_SEQ returns all insns to prepare opearands for compare.
dad0993e	162	GEN_SEQ returns all compare insns. */
636fb80b	163	static rtx
7b65258a	164	expand_ccmp_next (tree op, tree_code code, rtx prev,
d1ff5c63	165	rtx_insn prep_seq, rtx_insn gen_seq)
636fb80b	166	{
07bd240e	167	rtx_code rcode;
7b65258a	168	int unsignedp;
7b65258a	169	tree rhs1, rhs2;
636fb80b	170
7b65258a	171	get_compare_parts(op, &unsignedp, &rcode, &rhs1, &rhs2);
636fb80b	172	return targetm.gen_ccmp_next (prep_seq, gen_seq, prev, rcode,
7b65258a	173	rhs1, rhs2, get_rtx_code (code, 0));
636fb80b	174	}
636fb80b	175
9336ad57	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.
636fb80b	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. */
9336ad57	187	static rtx
d1ff5c63	188	expand_ccmp_expr_1 (gimple g, rtx_insn prep_seq, rtx_insn *gen_seq)
9336ad57	189	{
9336ad57	190	tree exp = gimple_assign_rhs_to_tree (g);
07bd240e	191	tree_code code = TREE_CODE (exp);
7b65258a	192	basic_block bb = gimple_bb (g);
	193
	194	tree op0 = TREE_OPERAND (exp, 0);
	195	tree op1 = TREE_OPERAND (exp, 1);
	196	gimple *gs0 = get_gimple_for_ssa_name (op0);
	197	gimple *gs1 = get_gimple_for_ssa_name (op1);
9336ad57	198	rtx tmp;
9336ad57	199
9336ad57	200	gcc_assert (code == BIT_AND_EXPR \|\| code == BIT_IOR_EXPR);
9336ad57	201
7b65258a	202	if (ccmp_tree_comparison_p (op0, bb))
9336ad57	203	{
7b65258a	204	if (ccmp_tree_comparison_p (op1, bb))
9336ad57	205	{
07bd240e	206	int unsignedp0, unsignedp1;
07bd240e	207	rtx_code rcode0, rcode1;
7b65258a	208	tree logical_op0_rhs1, logical_op0_rhs2;
7b65258a	209	tree logical_op1_rhs1, logical_op1_rhs2;
07bd240e	210	int speed_p = optimize_insn_for_speed_p ();
7b65258a	211
08fd6cf5	212	rtx tmp2 = NULL_RTX, ret = NULL_RTX, ret2 = NULL_RTX;
07bd240e	213	unsigned cost1 = MAX_COST;
07bd240e	214	unsigned cost2 = MAX_COST;
9336ad57	215
7b65258a	216	get_compare_parts (op0, &unsignedp0, &rcode0,
	217	&logical_op0_rhs1, &logical_op0_rhs2);
	218
	219	get_compare_parts (op1, &unsignedp1, &rcode1,
	220	&logical_op1_rhs1, &logical_op1_rhs2);
636fb80b	221
d1ff5c63	222	rtx_insn prep_seq_1, gen_seq_1;
07bd240e	223	tmp = targetm.gen_ccmp_first (&prep_seq_1, &gen_seq_1, rcode0,
7b65258a	224	logical_op0_rhs1, logical_op0_rhs2);
07bd240e	225	if (tmp != NULL)
07bd240e	226	{
7b65258a	227	ret = expand_ccmp_next (op1, code, tmp, &prep_seq_1, &gen_seq_1);
d1ff5c63	228	cost1 = seq_cost (prep_seq_1, speed_p);
d1ff5c63	229	cost1 += seq_cost (gen_seq_1, speed_p);
07bd240e	230	}
08fd6cf5	231
	232	/* FIXME: Temporary workaround for PR69619.
	233	Avoid exponential compile time due to expanding gs0 and gs1 twice.
	234	If gs0 and gs1 are complex, the cost will be high, so avoid
	235	reevaluation if above an arbitrary threshold. */
d1ff5c63	236	rtx_insn prep_seq_2, gen_seq_2;
08fd6cf5	237	if (tmp == NULL \|\| cost1 < COSTS_N_INSNS (25))
08fd6cf5	238	tmp2 = targetm.gen_ccmp_first (&prep_seq_2, &gen_seq_2, rcode1,
7b65258a	239	logical_op1_rhs1, logical_op1_rhs2);
08fd6cf5	240	if (!tmp && !tmp2)
08fd6cf5	241	return NULL_RTX;
07bd240e	242	if (tmp2 != NULL)
07bd240e	243	{
7b65258a	244	ret2 = expand_ccmp_next (op0, code, tmp2, &prep_seq_2,
07bd240e	245	&gen_seq_2);
d1ff5c63	246	cost2 = seq_cost (prep_seq_2, speed_p);
d1ff5c63	247	cost2 += seq_cost (gen_seq_2, speed_p);
07bd240e	248	}
07bd240e	249	if (cost2 < cost1)
	250	{
	251	*prep_seq = prep_seq_2;
	252	*gen_seq = gen_seq_2;
	253	return ret2;
	254	}
07bd240e	255	*prep_seq = prep_seq_1;
	256	*gen_seq = gen_seq_1;
	257	return ret;
9336ad57	258	}
	259	else
	260	{
636fb80b	261	tmp = expand_ccmp_expr_1 (gs1, prep_seq, gen_seq);
	262	if (!tmp)
	263	return NULL_RTX;
7b65258a	264	return expand_ccmp_next (op0, code, tmp, prep_seq, gen_seq);
9336ad57	265	}
	266	}
	267	else
	268	{
	269	gcc_assert (gimple_assign_rhs_code (gs0) == BIT_AND_EXPR
	270	\|\| gimple_assign_rhs_code (gs0) == BIT_IOR_EXPR);
7b65258a	271	gcc_assert (ccmp_tree_comparison_p (op1, bb));
	272	tmp = expand_ccmp_expr_1 (gs0, prep_seq, gen_seq);
	273	if (!tmp)
	274	return NULL_RTX;
	275	return expand_ccmp_next (op1, code, tmp, prep_seq, gen_seq);
9336ad57	276	}
	277
	278	return NULL_RTX;
	279	}
	280
dad0993e	281	/* Main entry to expand conditional compare statement G.
9336ad57	282	Return NULL_RTX if G is not a legal candidate or expand fail.
	283	Otherwise return the target. */
	284	rtx
7b65258a	285	expand_ccmp_expr (gimple *g, machine_mode mode)
9336ad57	286	{
	287	rtx_insn *last;
	288	rtx tmp;
	289
	290	if (!ccmp_candidate_p (g))
	291	return NULL_RTX;
	292
	293	last = get_last_insn ();
d1ff5c63	294
d1ff5c63	295	rtx_insn prep_seq = NULL, gen_seq = NULL;
636fb80b	296	tmp = expand_ccmp_expr_1 (g, &prep_seq, &gen_seq);
9336ad57	297
	298	if (tmp)
	299	{
07bd240e	300	insn_code icode;
07bd240e	301	machine_mode cc_mode = CCmode;
dad0993e	302	rtx_code cmp_code = GET_CODE (tmp);
636fb80b	303
9336ad57	304	#ifdef SELECT_CC_MODE
dad0993e	305	cc_mode = SELECT_CC_MODE (cmp_code, XEXP (tmp, 0), const0_rtx);
9336ad57	306	#endif
9336ad57	307	icode = optab_handler (cstore_optab, cc_mode);
	308	if (icode != CODE_FOR_nothing)
	309	{
9336ad57	310	rtx target = gen_reg_rtx (mode);
636fb80b	311
	312	emit_insn (prep_seq);
	313	emit_insn (gen_seq);
	314
dad0993e	315	tmp = emit_cstore (target, icode, cmp_code, cc_mode, cc_mode,
dad0993e	316	0, XEXP (tmp, 0), const0_rtx, 1, mode);
9336ad57	317	if (tmp)
	318	return tmp;
	319	}
	320	}
	321	/* Clean up. */
	322	delete_insns_since (last);
	323	return NULL_RTX;
	324	}