2014-11-17 07:03:07 +01:00
|
|
|
/* Conditional compare related functions
|
2022-01-03 10:42:10 +01:00
|
|
|
Copyright (C) 2014-2022 Free Software Foundation, Inc.
|
2014-11-17 07:03:07 +01:00
|
|
|
|
|
|
|
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"
|
2015-07-08 02:53:03 +02:00
|
|
|
#include "backend.h"
|
2015-10-29 14:57:32 +01:00
|
|
|
#include "target.h"
|
|
|
|
#include "rtl.h"
|
2015-07-08 02:53:03 +02:00
|
|
|
#include "tree.h"
|
|
|
|
#include "gimple.h"
|
Move MEMMODEL_* from coretypes.h to memmodel.h
2016-10-13 Thomas Preud'homme <thomas.preudhomme@arm.com>
gcc/
* coretypes.h: Move MEMMODEL_* macros and enum memmodel definition
into ...
* memmodel.h: This file.
* alias.c, asan.c, auto-inc-dec.c, bb-reorder.c, bt-load.c,
caller-save.c, calls.c, ccmp.c, cfgbuild.c, cfgcleanup.c,
cfgexpand.c, cfgloopanal.c, cfgrtl.c, cilk-common.c, combine.c,
combine-stack-adj.c, common/config/aarch64/aarch64-common.c,
common/config/arm/arm-common.c, common/config/bfin/bfin-common.c,
common/config/c6x/c6x-common.c, common/config/i386/i386-common.c,
common/config/ia64/ia64-common.c, common/config/nvptx/nvptx-common.c,
compare-elim.c, config/aarch64/aarch64-builtins.c,
config/aarch64/aarch64-c.c, config/aarch64/cortex-a57-fma-steering.c,
config/arc/arc.c, config/arc/arc-c.c, config/arm/arm-builtins.c,
config/arm/arm-c.c, config/avr/avr.c, config/avr/avr-c.c,
config/avr/avr-log.c, config/bfin/bfin.c, config/c6x/c6x.c,
config/cr16/cr16.c, config/cris/cris.c, config/darwin-c.c,
config/darwin.c, config/epiphany/epiphany.c,
config/epiphany/mode-switch-use.c,
config/epiphany/resolve-sw-modes.c, config/fr30/fr30.c,
config/frv/frv.c, config/ft32/ft32.c, config/h8300/h8300.c,
config/i386/i386-c.c, config/i386/winnt.c, config/iq2000/iq2000.c,
config/lm32/lm32.c, config/m32c/m32c.c, config/m32r/m32r.c,
config/m68k/m68k.c, config/mcore/mcore.c,
config/microblaze/microblaze.c, config/mmix/mmix.c,
config/mn10300/mn10300.c, config/moxie/moxie.c,
config/msp430/msp430.c, config/nds32/nds32-cost.c,
config/nds32/nds32-intrinsic.c, config/nds32/nds32-md-auxiliary.c,
config/nds32/nds32-memory-manipulation.c,
config/nds32/nds32-predicates.c, config/nds32/nds32.c,
config/nios2/nios2.c, config/nvptx/nvptx.c, config/pa/pa.c,
config/pdp11/pdp11.c, config/rl78/rl78.c, config/rs6000/rs6000-c.c,
config/rx/rx.c, config/s390/s390-c.c, config/s390/s390.c,
config/sh/sh.c, config/sh/sh-c.c, config/sh/sh-mem.cc,
config/sh/sh_treg_combine.cc, config/sol2.c, config/spu/spu.c,
config/stormy16/stormy16.c, config/tilegx/tilegx.c,
config/tilepro/tilepro.c, config/v850/v850.c, config/vax/vax.c,
config/visium/visium.c, config/vms/vms-c.c, config/xtensa/xtensa.c,
coverage.c, cppbuiltin.c, cprop.c, cse.c, cselib.c, dbxout.c, dce.c,
df-core.c, df-problems.c, df-scan.c, dojump.c, dse.c, dwarf2asm.c,
dwarf2cfi.c, dwarf2out.c, emit-rtl.c, except.c, explow.c, expmed.c,
expr.c, final.c, fold-const.c, function.c, fwprop.c, gcse.c,
ggc-page.c, haifa-sched.c, hsa-brig.c, hsa-gen.c, hw-doloop.c,
ifcvt.c, init-regs.c, internal-fn.c, ira-build.c, ira-color.c,
ira-conflicts.c, ira-costs.c, ira-emit.c, ira-lives.c, ira.c, jump.c,
loop-doloop.c, loop-invariant.c, loop-iv.c, loop-unroll.c,
lower-subreg.c, lra.c, lra-assigns.c, lra-coalesce.c,
lra-constraints.c, lra-eliminations.c, lra-lives.c, lra-remat.c,
lra-spills.c, mode-switching.c, modulo-sched.c, omp-low.c, passes.c,
postreload-gcse.c, postreload.c, predict.c, print-rtl-function.c,
recog.c, ree.c, reg-stack.c, regcprop.c, reginfo.c, regrename.c,
reload.c, reload1.c, reorg.c, resource.c, rtl-chkp.c, rtl-tests.c,
rtlanal.c, rtlhooks.c, sched-deps.c, sched-rgn.c, sdbout.c,
sel-sched-ir.c, sel-sched.c, shrink-wrap.c, simplify-rtx.c,
stack-ptr-mod.c, stmt.c, stor-layout.c, target-globals.c,
targhooks.c, toplev.c, tree-nested.c, tree-outof-ssa.c,
tree-profile.c, tree-ssa-coalesce.c, tree-ssa-ifcombine.c,
tree-ssa-loop-ivopts.c, tree-ssa-loop.c, tree-ssa-reassoc.c,
tree-ssa-sccvn.c, tree-vect-data-refs.c, ubsan.c, valtrack.c,
var-tracking.c, varasm.c: Include memmodel.h.
* genattrtab.c (write_header): Include memmodel.h in generated file.
* genautomata.c (main): Likewise.
* gengtype.c (open_base_files): Likewise.
* genopinit.c (main): Likewise.
* genconditions.c (write_header): Include memmodel.h earlier in
generated file.
* genemit.c (main): Likewise.
* genoutput.c (output_prologue): Likewise.
* genpeep.c (main): Likewise.
* genpreds.c (write_insn_preds_c): Likewise.
* genrecog.c (write_header): Likewise.
* Makefile.in (PLUGIN_HEADERS): Include memmodel.h
gcc/ada/
* gcc-interface/utils2.c: Include memmodel.h.
gcc/c-family/
* c-cppbuiltin.c: Include memmodel.h.
* c-opts.c: Likewise.
* c-pragma.c: Likewise.
* c-warn.c: Likewise.
gcc/c/
* c-typeck.c: Include memmodel.h.
gcc/cp/
* decl2.c: Include memmodel.h.
* rtti.c: Likewise.
gcc/fortran/
* trans-intrinsic.c: Include memmodel.h.
gcc/go/
* go-backend.c: Include memmodel.h.
libgcc/
* libgcov-profiler.c: Replace MEMMODEL_* macros by their __ATOMIC_*
equivalent.
* config/tilepro/atomic.c: Likewise and stop casting model to
enum memmodel.
From-SVN: r241121
2016-10-13 16:17:52 +02:00
|
|
|
#include "memmodel.h"
|
2014-11-17 07:03:07 +01:00
|
|
|
#include "tm_p.h"
|
2015-10-29 14:57:32 +01:00
|
|
|
#include "ssa.h"
|
|
|
|
#include "expmed.h"
|
|
|
|
#include "optabs.h"
|
|
|
|
#include "emit-rtl.h"
|
2014-11-17 07:03:07 +01:00
|
|
|
#include "stor-layout.h"
|
|
|
|
#include "tree-ssa-live.h"
|
|
|
|
#include "tree-outof-ssa.h"
|
|
|
|
#include "cfgexpand.h"
|
|
|
|
#include "ccmp.h"
|
2016-01-19 15:14:56 +01:00
|
|
|
#include "predict.h"
|
2014-11-17 07:03:07 +01:00
|
|
|
|
2017-06-29 20:20:14 +02:00
|
|
|
/* 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;
|
|
|
|
}
|
|
|
|
|
2014-11-17 07:03:07 +01:00
|
|
|
/* 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.
|
|
|
|
|
2016-01-19 14:59:56 +01:00
|
|
|
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.
|
|
|
|
|
2015-01-21 16:47:49 +01:00
|
|
|
* We use cstorecc4 pattern to convert the CCmode intermediate to
|
|
|
|
the integer mode result that expand_normal is expecting.
|
2015-01-16 12:48:00 +01:00
|
|
|
|
|
|
|
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. */
|
2014-11-17 07:03:07 +01:00
|
|
|
|
|
|
|
/* Check whether G is a potential conditional compare candidate. */
|
|
|
|
static bool
|
2015-09-20 02:52:59 +02:00
|
|
|
ccmp_candidate_p (gimple *g)
|
2014-11-17 07:03:07 +01:00
|
|
|
{
|
|
|
|
tree lhs, op0, op1;
|
2015-09-20 02:52:59 +02:00
|
|
|
gimple *gs0, *gs1;
|
2017-06-29 20:20:14 +02:00
|
|
|
tree_code tcode;
|
|
|
|
basic_block bb;
|
|
|
|
|
|
|
|
if (!g)
|
|
|
|
return false;
|
2014-11-17 07:03:07 +01:00
|
|
|
|
2018-12-11 12:07:24 +01:00
|
|
|
tcode = gimple_assign_rhs_code (g);
|
2014-11-17 07:03:07 +01:00
|
|
|
if (tcode != BIT_AND_EXPR && tcode != BIT_IOR_EXPR)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
lhs = gimple_assign_lhs (g);
|
2018-12-11 12:07:24 +01:00
|
|
|
op0 = gimple_assign_rhs1 (g);
|
|
|
|
op1 = gimple_assign_rhs2 (g);
|
2014-11-17 07:03:07 +01:00
|
|
|
if ((TREE_CODE (op0) != SSA_NAME) || (TREE_CODE (op1) != SSA_NAME)
|
|
|
|
|| !has_single_use (lhs))
|
|
|
|
return false;
|
|
|
|
|
2018-12-11 12:07:24 +01:00
|
|
|
bb = gimple_bb (g);
|
2017-06-29 20:20:14 +02:00
|
|
|
gs0 = get_gimple_for_ssa_name (op0); /* gs0 may be NULL */
|
|
|
|
gs1 = get_gimple_for_ssa_name (op1); /* gs1 may be NULL */
|
2014-11-17 07:03:07 +01:00
|
|
|
|
2017-06-29 20:20:14 +02:00
|
|
|
if (ccmp_tree_comparison_p (op0, bb) && ccmp_tree_comparison_p (op1, bb))
|
2014-11-17 07:03:07 +01:00
|
|
|
return true;
|
2017-06-29 20:20:14 +02:00
|
|
|
if (ccmp_tree_comparison_p (op0, bb) && ccmp_candidate_p (gs1))
|
2014-11-17 07:03:07 +01:00
|
|
|
return true;
|
2017-06-29 20:20:14 +02:00
|
|
|
if (ccmp_tree_comparison_p (op1, bb) && ccmp_candidate_p (gs0))
|
2014-11-17 07:03:07 +01:00
|
|
|
return true;
|
|
|
|
/* We skip ccmp_candidate_p (gs1) && ccmp_candidate_p (gs0) since
|
2017-06-29 20:20:14 +02:00
|
|
|
there is no way to set and maintain the CC flag on both sides of
|
|
|
|
the logical operator at the same time. */
|
2014-11-17 07:03:07 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-06-29 20:20:14 +02:00
|
|
|
/* 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));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-19 14:59:56 +01:00
|
|
|
/* 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.
|
2015-01-16 12:48:00 +01:00
|
|
|
PREP_SEQ returns all insns to prepare opearands for compare.
|
2016-01-19 14:59:56 +01:00
|
|
|
GEN_SEQ returns all compare insns. */
|
2015-01-16 12:48:00 +01:00
|
|
|
static rtx
|
2017-06-29 20:20:14 +02:00
|
|
|
expand_ccmp_next (tree op, tree_code code, rtx prev,
|
2016-11-03 10:27:55 +01:00
|
|
|
rtx_insn **prep_seq, rtx_insn **gen_seq)
|
2015-01-16 12:48:00 +01:00
|
|
|
{
|
2016-01-19 15:14:56 +01:00
|
|
|
rtx_code rcode;
|
2017-06-29 20:20:14 +02:00
|
|
|
int unsignedp;
|
|
|
|
tree rhs1, rhs2;
|
2015-01-16 12:48:00 +01:00
|
|
|
|
2017-06-29 20:20:14 +02:00
|
|
|
get_compare_parts(op, &unsignedp, &rcode, &rhs1, &rhs2);
|
2015-01-16 12:48:00 +01:00
|
|
|
return targetm.gen_ccmp_next (prep_seq, gen_seq, prev, rcode,
|
2017-06-29 20:20:14 +02:00
|
|
|
rhs1, rhs2, get_rtx_code (code, 0));
|
2015-01-16 12:48:00 +01:00
|
|
|
}
|
|
|
|
|
2014-11-17 07:03:07 +01:00
|
|
|
/* 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.
|
2015-01-16 12:48:00 +01:00
|
|
|
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. */
|
2014-11-17 07:03:07 +01:00
|
|
|
static rtx
|
2016-11-03 10:27:55 +01:00
|
|
|
expand_ccmp_expr_1 (gimple *g, rtx_insn **prep_seq, rtx_insn **gen_seq)
|
2014-11-17 07:03:07 +01:00
|
|
|
{
|
2019-05-17 10:15:46 +02:00
|
|
|
tree_code code = gimple_assign_rhs_code (g);
|
2017-06-29 20:20:14 +02:00
|
|
|
basic_block bb = gimple_bb (g);
|
|
|
|
|
2019-05-17 10:15:46 +02:00
|
|
|
tree op0 = gimple_assign_rhs1 (g);
|
|
|
|
tree op1 = gimple_assign_rhs2 (g);
|
2017-06-29 20:20:14 +02:00
|
|
|
gimple *gs0 = get_gimple_for_ssa_name (op0);
|
|
|
|
gimple *gs1 = get_gimple_for_ssa_name (op1);
|
2014-11-17 07:03:07 +01:00
|
|
|
rtx tmp;
|
|
|
|
|
|
|
|
gcc_assert (code == BIT_AND_EXPR || code == BIT_IOR_EXPR);
|
|
|
|
|
2017-06-29 20:20:14 +02:00
|
|
|
if (ccmp_tree_comparison_p (op0, bb))
|
2014-11-17 07:03:07 +01:00
|
|
|
{
|
2017-06-29 20:20:14 +02:00
|
|
|
if (ccmp_tree_comparison_p (op1, bb))
|
2014-11-17 07:03:07 +01:00
|
|
|
{
|
2016-01-19 15:14:56 +01:00
|
|
|
int unsignedp0, unsignedp1;
|
|
|
|
rtx_code rcode0, rcode1;
|
2017-06-29 20:20:14 +02:00
|
|
|
tree logical_op0_rhs1, logical_op0_rhs2;
|
|
|
|
tree logical_op1_rhs1, logical_op1_rhs2;
|
2016-01-19 15:14:56 +01:00
|
|
|
int speed_p = optimize_insn_for_speed_p ();
|
2017-06-29 20:20:14 +02:00
|
|
|
|
2016-02-04 19:23:35 +01:00
|
|
|
rtx tmp2 = NULL_RTX, ret = NULL_RTX, ret2 = NULL_RTX;
|
2016-01-19 15:14:56 +01:00
|
|
|
unsigned cost1 = MAX_COST;
|
|
|
|
unsigned cost2 = MAX_COST;
|
2014-11-17 07:03:07 +01:00
|
|
|
|
2017-06-29 20:20:14 +02:00
|
|
|
get_compare_parts (op0, &unsignedp0, &rcode0,
|
|
|
|
&logical_op0_rhs1, &logical_op0_rhs2);
|
|
|
|
|
|
|
|
get_compare_parts (op1, &unsignedp1, &rcode1,
|
|
|
|
&logical_op1_rhs1, &logical_op1_rhs2);
|
2015-01-16 12:48:00 +01:00
|
|
|
|
2016-11-03 10:27:55 +01:00
|
|
|
rtx_insn *prep_seq_1, *gen_seq_1;
|
2016-01-19 15:14:56 +01:00
|
|
|
tmp = targetm.gen_ccmp_first (&prep_seq_1, &gen_seq_1, rcode0,
|
2017-06-29 20:20:14 +02:00
|
|
|
logical_op0_rhs1, logical_op0_rhs2);
|
2016-01-19 15:14:56 +01:00
|
|
|
if (tmp != NULL)
|
|
|
|
{
|
2017-06-29 20:20:14 +02:00
|
|
|
ret = expand_ccmp_next (op1, code, tmp, &prep_seq_1, &gen_seq_1);
|
2016-11-03 10:27:55 +01:00
|
|
|
cost1 = seq_cost (prep_seq_1, speed_p);
|
|
|
|
cost1 += seq_cost (gen_seq_1, speed_p);
|
2016-01-19 15:14:56 +01:00
|
|
|
}
|
2016-02-04 19:23:35 +01:00
|
|
|
|
|
|
|
/* 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. */
|
2016-11-03 10:27:55 +01:00
|
|
|
rtx_insn *prep_seq_2, *gen_seq_2;
|
2016-02-04 19:23:35 +01:00
|
|
|
if (tmp == NULL || cost1 < COSTS_N_INSNS (25))
|
|
|
|
tmp2 = targetm.gen_ccmp_first (&prep_seq_2, &gen_seq_2, rcode1,
|
2017-06-29 20:20:14 +02:00
|
|
|
logical_op1_rhs1, logical_op1_rhs2);
|
2016-02-04 19:23:35 +01:00
|
|
|
if (!tmp && !tmp2)
|
|
|
|
return NULL_RTX;
|
2016-01-19 15:14:56 +01:00
|
|
|
if (tmp2 != NULL)
|
|
|
|
{
|
2017-06-29 20:20:14 +02:00
|
|
|
ret2 = expand_ccmp_next (op0, code, tmp2, &prep_seq_2,
|
2016-01-19 15:14:56 +01:00
|
|
|
&gen_seq_2);
|
2016-11-03 10:27:55 +01:00
|
|
|
cost2 = seq_cost (prep_seq_2, speed_p);
|
|
|
|
cost2 += seq_cost (gen_seq_2, speed_p);
|
2016-01-19 15:14:56 +01:00
|
|
|
}
|
|
|
|
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;
|
2014-11-17 07:03:07 +01:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-01-16 12:48:00 +01:00
|
|
|
tmp = expand_ccmp_expr_1 (gs1, prep_seq, gen_seq);
|
|
|
|
if (!tmp)
|
|
|
|
return NULL_RTX;
|
2017-06-29 20:20:14 +02:00
|
|
|
return expand_ccmp_next (op0, code, tmp, prep_seq, gen_seq);
|
2014-11-17 07:03:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
gcc_assert (gimple_assign_rhs_code (gs0) == BIT_AND_EXPR
|
|
|
|
|| gimple_assign_rhs_code (gs0) == BIT_IOR_EXPR);
|
2017-06-29 20:20:14 +02:00
|
|
|
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);
|
2014-11-17 07:03:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-19 14:59:56 +01:00
|
|
|
/* Main entry to expand conditional compare statement G.
|
2014-11-17 07:03:07 +01:00
|
|
|
Return NULL_RTX if G is not a legal candidate or expand fail.
|
|
|
|
Otherwise return the target. */
|
|
|
|
rtx
|
2017-06-29 20:20:14 +02:00
|
|
|
expand_ccmp_expr (gimple *g, machine_mode mode)
|
2014-11-17 07:03:07 +01:00
|
|
|
{
|
|
|
|
rtx_insn *last;
|
|
|
|
rtx tmp;
|
|
|
|
|
|
|
|
if (!ccmp_candidate_p (g))
|
|
|
|
return NULL_RTX;
|
|
|
|
|
|
|
|
last = get_last_insn ();
|
2016-11-03 10:27:55 +01:00
|
|
|
|
|
|
|
rtx_insn *prep_seq = NULL, *gen_seq = NULL;
|
2015-01-16 12:48:00 +01:00
|
|
|
tmp = expand_ccmp_expr_1 (g, &prep_seq, &gen_seq);
|
2014-11-17 07:03:07 +01:00
|
|
|
|
|
|
|
if (tmp)
|
|
|
|
{
|
2016-01-19 15:14:56 +01:00
|
|
|
insn_code icode;
|
|
|
|
machine_mode cc_mode = CCmode;
|
2016-01-19 14:59:56 +01:00
|
|
|
rtx_code cmp_code = GET_CODE (tmp);
|
2015-01-16 12:48:00 +01:00
|
|
|
|
2014-11-17 07:03:07 +01:00
|
|
|
#ifdef SELECT_CC_MODE
|
2016-01-19 14:59:56 +01:00
|
|
|
cc_mode = SELECT_CC_MODE (cmp_code, XEXP (tmp, 0), const0_rtx);
|
2014-11-17 07:03:07 +01:00
|
|
|
#endif
|
|
|
|
icode = optab_handler (cstore_optab, cc_mode);
|
|
|
|
if (icode != CODE_FOR_nothing)
|
|
|
|
{
|
|
|
|
rtx target = gen_reg_rtx (mode);
|
2015-01-16 12:48:00 +01:00
|
|
|
|
|
|
|
emit_insn (prep_seq);
|
|
|
|
emit_insn (gen_seq);
|
|
|
|
|
2016-01-19 14:59:56 +01:00
|
|
|
tmp = emit_cstore (target, icode, cmp_code, cc_mode, cc_mode,
|
|
|
|
0, XEXP (tmp, 0), const0_rtx, 1, mode);
|
2014-11-17 07:03:07 +01:00
|
|
|
if (tmp)
|
|
|
|
return tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Clean up. */
|
|
|
|
delete_insns_since (last);
|
|
|
|
return NULL_RTX;
|
|
|
|
}
|