jimzah/freebsd-src
1
0
Fork 0
mirror of https://github.com/freebsd/freebsd-src.git synced 2024-11-29 08:52:46 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
4467cfa4b4
freebsd-src/contrib/gcc/ssa-ccp.c

1226 lines
36 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Conditional constant propagation pass for the GNU compiler.
Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
Original framework by Daniel Berlin <dan@cgsoftware.com>
Fleshed out and major cleanups by Jeff Law <law@redhat.com>
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 2, 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 COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
/* Conditional constant propagation.
References:
Constant propagation with conditional branches,
Wegman and Zadeck, ACM TOPLAS 13(2):181-210.
Building an Optimizing Compiler,
Robert Morgan, Butterworth-Heinemann, 1998, Section 8.9.
Advanced Compiler Design and Implementation,
Steven Muchnick, Morgan Kaufmann, 1997, Section 12.6
The overall structure is as follows:
1. Run a simple SSA based DCE pass to remove any dead code.
2. Run CCP to compute what registers are known constants
and what edges are not executable. Remove unexecutable
edges from the CFG and simplify PHI nodes.
3. Replace registers with constants where possible.
4. Remove unreachable blocks computed in step #2.
5. Another simple SSA DCE pass to remove dead code exposed
by CCP.
When we exit, we are still in SSA form.
Potential further enhancements:
1. Handle SUBREGs, STRICT_LOW_PART, etc in destinations more
gracefully.
2. Handle insns with multiple outputs more gracefully.
3. Handle CONST_DOUBLE and symbolic constants.
4. Fold expressions after performing constant substitutions. */
#include "config.h"
#include "system.h"
#include "rtl.h"
#include "hard-reg-set.h"
#include "basic-block.h"
#include "ssa.h"
#include "insn-config.h"
#include "recog.h"
#include "output.h"
#include "errors.h"
#include "ggc.h"
#include "df.h"
#include "function.h"
/* Possible lattice values. */
typedef enum
{
UNDEFINED,
CONSTANT,
VARYING
} latticevalue;
/* Main structure for CCP.
Contains the lattice value and, if it's a constant, the constant
value. */
typedef struct
{
latticevalue lattice_val;
rtx const_value;
} value;
/* Array of values indexed by register number. */
static value *values;
/* A bitmap to keep track of executable blocks in the CFG. */
static sbitmap executable_blocks;
/* A bitmap for all executable edges in the CFG. */
static sbitmap executable_edges;
/* Array of edges on the work list. */
static edge *edge_info;
/* We need an edge list to be able to get indexes easily. */
static struct edge_list *edges;
/* For building/following use-def and def-use chains. */
static struct df *df_analyzer;
/* Current edge we are operating on, from the worklist */
static edge flow_edges;
/* Bitmap of SSA edges which will need reexamination as their definition
has changed. */
static sbitmap ssa_edges;
/* Simple macros to simplify code */
#define SSA_NAME(x) REGNO (SET_DEST (x))
#define PHI_PARMS(x) XVEC (SET_SRC (x), 0)
#define EIE(x,y) EDGE_INDEX (edges, x, y)
static void visit_phi_node PARAMS ((rtx, basic_block));
static void visit_expression PARAMS ((rtx, basic_block));
static void defs_to_undefined PARAMS ((rtx));
static void defs_to_varying PARAMS ((rtx));
static void examine_flow_edges PARAMS ((void));
static int mark_references PARAMS ((rtx *, void *));
static void follow_def_use_chains PARAMS ((void));
static void optimize_unexecutable_edges PARAMS ((struct edge_list *, sbitmap));
static void ssa_ccp_substitute_constants PARAMS ((void));
static void ssa_ccp_df_delete_unreachable_insns PARAMS ((void));
static void ssa_fast_dce PARAMS ((struct df *));
/* Loop through the PHI_NODE's parameters for BLOCK and compare their
lattice values to determine PHI_NODE's lattice value. */
static void
visit_phi_node (phi_node, block)
rtx phi_node;
basic_block block;
{
unsigned int i;
rtx phi_node_expr = NULL;
unsigned int phi_node_name = SSA_NAME (PATTERN (phi_node));
latticevalue phi_node_lattice_val = UNDEFINED;
rtx pat = PATTERN (phi_node);
rtvec phi_vec = XVEC (SET_SRC (pat), 0);
unsigned int num_elem = GET_NUM_ELEM (phi_vec);
for (i = 0; i < num_elem; i += 2)
{
if (TEST_BIT (executable_edges,
EIE (BASIC_BLOCK (INTVAL (RTVEC_ELT (phi_vec, i + 1))),
block)))
{
unsigned int current_parm
= REGNO (RTVEC_ELT (phi_vec, i));
latticevalue current_parm_lattice_val
= values[current_parm].lattice_val;
/* If any node is VARYING, then new value of PHI_NODE
is VARYING. */
if (current_parm_lattice_val == VARYING)
{
phi_node_lattice_val = VARYING;
phi_node_expr = NULL;
break;
}
/* If we have more than one distinct constant, then the new
value of PHI_NODE is VARYING. */
if (current_parm_lattice_val == CONSTANT
&& phi_node_lattice_val == CONSTANT
&& values[current_parm].const_value != phi_node_expr)
{
phi_node_lattice_val = VARYING;
phi_node_expr = NULL;
break;
}
/* If the current value of PHI_NODE is UNDEFINED and one
node in PHI_NODE is CONSTANT, then the new value of the
PHI is that CONSTANT. Note this can turn into VARYING
if we find another distinct constant later. */
if (phi_node_lattice_val == UNDEFINED
&& phi_node_expr == NULL
&& current_parm_lattice_val == CONSTANT)
{
phi_node_expr = values[current_parm].const_value;
phi_node_lattice_val = CONSTANT;
continue;
}
}
}
/* If the value of PHI_NODE changed, then we will need to
re-execute uses of the output of PHI_NODE. */
if (phi_node_lattice_val != values[phi_node_name].lattice_val)
{
values[phi_node_name].lattice_val = phi_node_lattice_val;
values[phi_node_name].const_value = phi_node_expr;
SET_BIT (ssa_edges, phi_node_name);
}
}
/* Sets all defs in an insn to UNDEFINED. */
static void
defs_to_undefined (insn)
rtx insn;
{
struct df_link *currdef;
for (currdef = DF_INSN_DEFS (df_analyzer, insn); currdef;
currdef = currdef->next)
{
if (values[DF_REF_REGNO (currdef->ref)].lattice_val != UNDEFINED)
SET_BIT (ssa_edges, DF_REF_REGNO (currdef->ref));
values[DF_REF_REGNO (currdef->ref)].lattice_val = UNDEFINED;
}
}
/* Sets all defs in an insn to VARYING. */
static void
defs_to_varying (insn)
rtx insn;
{
struct df_link *currdef;
for (currdef = DF_INSN_DEFS (df_analyzer, insn); currdef;
currdef = currdef->next)
{
if (values[DF_REF_REGNO (currdef->ref)].lattice_val != VARYING)
SET_BIT (ssa_edges, DF_REF_REGNO (currdef->ref));
values[DF_REF_REGNO (currdef->ref)].lattice_val = VARYING;
}
}
/* Go through the expression, call the appropriate evaluation routines
to attempt cprop */
static void
visit_expression (insn, block)
rtx insn;
basic_block block;
{
rtx src, dest, set;
/* Ugh. CALL_INSNs may end a basic block and have multiple edges
leading out from them.
Mark all the outgoing edges as executable, then fall into the
normal processing below. */
if (GET_CODE (insn) == CALL_INSN && block->end == insn)
{
edge curredge;
for (curredge = block->succ; curredge;
curredge = curredge->succ_next)
{
int index = EIE (curredge->src, curredge->dest);
if (TEST_BIT (executable_edges, index))
continue;
SET_BIT (executable_edges, index);
edge_info[index] = flow_edges;
flow_edges = curredge;
}
}
set = single_set (insn);
if (! set)
{
defs_to_varying (insn);
return;
}
src = SET_SRC (set);
dest = SET_DEST (set);
/* We may want to refine this some day. */
if (GET_CODE (dest) != REG && dest != pc_rtx)
{
defs_to_varying (insn);
return;
}
/* Hard registers are not put in SSA form and thus we must consider
them varying. All the more reason to avoid hard registers in
RTL until as late as possible in the compilation. */
if (GET_CODE (dest) == REG && REGNO (dest) < FIRST_PSEUDO_REGISTER)
{
defs_to_varying (insn);
return;
}
/* If this is assigning DEST to a constant, record that fact. */
if (GET_CODE (src) == CONST_INT && GET_CODE (insn) == INSN)
{
unsigned int resultreg = REGNO (dest);
values[resultreg].lattice_val = CONSTANT;
values[resultreg].const_value = SET_SRC (PATTERN (insn));
SET_BIT (ssa_edges, resultreg);
}
/* If this is a copy operation, then we can copy the lattice values. */
else if (GET_CODE (src) == REG && GET_CODE (dest) == REG)
{
unsigned int old_value = REGNO (src);
latticevalue old_lattice_value = values[old_value].lattice_val;
unsigned int new_value = REGNO (dest);
/* Unless the lattice value is going to change, don't bother
adding the "new value" into the worklist. */
if (values[new_value].lattice_val != old_lattice_value
|| values[new_value].const_value != values[old_value].const_value)
SET_BIT (ssa_edges, new_value);
/* Copy the old lattice node info into the new value lattice node. */
values[new_value].lattice_val = old_lattice_value;
values[new_value].const_value = values[old_value].const_value;
}
/* Handle jumps. */
else if (GET_CODE (insn) == JUMP_INSN)
{
rtx x = pc_set (insn);
if (GET_CODE (src) != IF_THEN_ELSE)
{
edge curredge;
/* This is a computed jump, table jump, or an unconditional
jump. For all these cases we want to mark all successor
blocks as executable if they have not already been
marked.
One day we may try do better with swtich tables and
other computed jumps. */
for (curredge = block->succ; curredge;
curredge = curredge->succ_next)
{
int index = EIE (curredge->src, curredge->dest);
if (TEST_BIT (executable_edges, index))
continue;
SET_BIT (executable_edges, index);
edge_info[index] = flow_edges;
flow_edges = curredge;
}
}
else
{
edge curredge;
enum rtx_code comparison_code;
rtx comparison_src0;
rtx comparison_src1;
comparison_code = GET_CODE (XEXP (src, 0));
comparison_src0 = XEXP (XEXP (src, 0), 0);
comparison_src1 = XEXP (XEXP (src, 0), 1);
/* If either operand is undefined, then there is nothing to
do right now. If/when operands are later defined we will
revaluate the condition and take the appropriate action. */
if ((GET_CODE (comparison_src0) == REG
&& values[REGNO (comparison_src0)].lattice_val == UNDEFINED)
|| (GET_CODE (comparison_src1) == REG
&& values[REGNO (comparison_src1)].lattice_val == UNDEFINED))
return;
/* If either operand is varying, then we must consider all
paths as executable. */
if ((GET_CODE (comparison_src0) == REG
&& values[REGNO (comparison_src0)].lattice_val == VARYING)
|| (GET_CODE (comparison_src1) == REG
&& values[REGNO (comparison_src1)].lattice_val == VARYING))
{
for (curredge = block->succ; curredge;
curredge = curredge->succ_next)
{
int index = EIE (curredge->src, curredge->dest);
if (TEST_BIT (executable_edges, index))
continue;
SET_BIT (executable_edges, index);
edge_info[index] = flow_edges;
flow_edges = curredge;
}
return;
}
/* Try to simplify the comparison. */
if (GET_CODE (comparison_src0) == REG
&& values[REGNO (comparison_src0)].lattice_val == CONSTANT)
comparison_src0 = values[REGNO (comparison_src0)].const_value;
if (GET_CODE (comparison_src1) == REG
&& values[REGNO (comparison_src1)].lattice_val == CONSTANT)
comparison_src1 = values[REGNO (comparison_src1)].const_value;
x = simplify_ternary_operation (IF_THEN_ELSE,
VOIDmode,
GET_MODE (XEXP (src, 0)),
gen_rtx (comparison_code,
GET_MODE (XEXP (src, 0)),
comparison_src0,
comparison_src1),
XEXP (src, 1),
XEXP (src, 2));
/* Walk through all the outgoing edges from this block and see
which (if any) we should mark as executable. */
for (curredge = block->succ; curredge;
curredge = curredge->succ_next)
{
int index = EIE (curredge->src, curredge->dest);
if (TEST_BIT (executable_edges, index))
continue;
/* If we were unable to simplify the expression at this
point, it's highly unlikely we'll be able to simplify
it later. So consider all edges as executable if the
expression did not simplify.
If the expression simplified to (pc), then we know we
will take the fall-thru edge, so mark it. Similarly,
if the expression simplified to (label_ref ...), then
we know the branch will be taken and we mark that
edge as taken. */
if (!x
|| (x == pc_rtx
&& (curredge->flags & EDGE_FALLTHRU))
|| (GET_CODE (x) == LABEL_REF
&& ! (curredge->flags & EDGE_FALLTHRU)))
{
SET_BIT (executable_edges, index);
edge_info[index] = flow_edges;
flow_edges = curredge;
}
}
}
}
else if (!PHI_NODE_P (insn))
{
rtx simplified = NULL;
/* We've got some kind of INSN. If it's simple, try to evaluate
it and record the results.
We already know this insn is a single_set and that it sets
a pseudo register. So we just need to extract the source
arguments, simplify them to constants if possible, then
simplify the expression as a whole if possible. */
switch (GET_RTX_CLASS (GET_CODE (src)))
{
case '<':
{
rtx src0 = XEXP (src, 0);
rtx src1 = XEXP (src, 1);
enum machine_mode mode;
/* If either is undefined, then the result is undefined. */
if ((GET_CODE (src0) == REG
&& values[REGNO (src0)].lattice_val == UNDEFINED)
|| (GET_CODE (src1) == REG
&& values[REGNO (src1)].lattice_val == UNDEFINED))
{
defs_to_undefined (insn);
break;
}
/* Determine the mode for the operation before we simplify
our arguments to constants. */
mode = GET_MODE (src0);
if (mode == VOIDmode)
mode = GET_MODE (src1);
/* Simplify source operands to whatever known values they
may have. */
if (GET_CODE (src0) == REG
&& values[REGNO (src0)].lattice_val == CONSTANT)
src0 = values[REGNO (src0)].const_value;
if (GET_CODE (src1) == REG
&& values[REGNO (src1)].lattice_val == CONSTANT)
src1 = values[REGNO (src1)].const_value;
/* See if the simplifier can determine if this operation
computes a constant value. */
simplified = simplify_relational_operation (GET_CODE (src),
mode, src0, src1);
break;
}
case '1':
{
rtx src0 = XEXP (src, 0);
enum machine_mode mode0 = GET_MODE (src0);
/* If the operand is undefined, then the result is undefined. */
if (GET_CODE (src0) == REG
&& values[REGNO (src0)].lattice_val == UNDEFINED)
{
defs_to_undefined (insn);
break;
}
/* Simplify source operands to whatever known values they
may have. */
if (GET_CODE (src0) == REG
&& values[REGNO (src0)].lattice_val == CONSTANT)
src0 = values[REGNO (src0)].const_value;
/* See if the simplifier can determine if this operation
computes a constant value. */
simplified = simplify_unary_operation (GET_CODE (src),
GET_MODE (src),
src0,
mode0);
break;
}
case '2':
case 'c':
{
rtx src0 = XEXP (src, 0);
rtx src1 = XEXP (src, 1);
/* If either is undefined, then the result is undefined. */
if ((GET_CODE (src0) == REG
&& values[REGNO (src0)].lattice_val == UNDEFINED)
|| (GET_CODE (src1) == REG
&& values[REGNO (src1)].lattice_val == UNDEFINED))
{
defs_to_undefined (insn);
break;
}
/* Simplify source operands to whatever known values they
may have. */
if (GET_CODE (src0) == REG
&& values[REGNO (src0)].lattice_val == CONSTANT)
src0 = values[REGNO (src0)].const_value;
if (GET_CODE (src1) == REG
&& values[REGNO (src1)].lattice_val == CONSTANT)
src1 = values[REGNO (src1)].const_value;
/* See if the simplifier can determine if this operation
computes a constant value. */
simplified = simplify_binary_operation (GET_CODE (src),
GET_MODE (src),
src0, src1);
break;
}
case '3':
case 'b':
{
rtx src0 = XEXP (src, 0);
rtx src1 = XEXP (src, 1);
rtx src2 = XEXP (src, 2);
/* If either is undefined, then the result is undefined. */
if ((GET_CODE (src0) == REG
&& values[REGNO (src0)].lattice_val == UNDEFINED)
|| (GET_CODE (src1) == REG
&& values[REGNO (src1)].lattice_val == UNDEFINED)
|| (GET_CODE (src2) == REG
&& values[REGNO (src2)].lattice_val == UNDEFINED))
{
defs_to_undefined (insn);
break;
}
/* Simplify source operands to whatever known values they
may have. */
if (GET_CODE (src0) == REG
&& values[REGNO (src0)].lattice_val == CONSTANT)
src0 = values[REGNO (src0)].const_value;
if (GET_CODE (src1) == REG
&& values[REGNO (src1)].lattice_val == CONSTANT)
src1 = values[REGNO (src1)].const_value;
if (GET_CODE (src2) == REG
&& values[REGNO (src2)].lattice_val == CONSTANT)
src2 = values[REGNO (src2)].const_value;
/* See if the simplifier can determine if this operation
computes a constant value. */
simplified = simplify_ternary_operation (GET_CODE (src),
GET_MODE (src),
GET_MODE (src),
src0, src1, src2);
break;
}
default:
defs_to_varying (insn);
}
if (simplified && GET_CODE (simplified) == CONST_INT)
{
if (values[REGNO (dest)].lattice_val != CONSTANT
|| values[REGNO (dest)].const_value != simplified)
SET_BIT (ssa_edges, REGNO (dest));
values[REGNO (dest)].lattice_val = CONSTANT;
values[REGNO (dest)].const_value = simplified;
}
else
defs_to_varying (insn);
}
}
/* Iterate over the FLOW_EDGES work list. Simulate the target block
for each edge. */
static void
examine_flow_edges ()
{
while (flow_edges != NULL)
{
basic_block succ_block;
rtx curr_phi_node;
/* Pull the next block to simulate off the worklist. */
succ_block = flow_edges->dest;
flow_edges = edge_info[EIE (flow_edges->src, flow_edges->dest)];
/* There is nothing to do for the exit block. */
if (succ_block == EXIT_BLOCK_PTR)
continue;
/* Always simulate PHI nodes, even if we have simulated this block
before. Note that all PHI nodes are consecutive within a block. */
for (curr_phi_node = first_insn_after_basic_block_note (succ_block);
PHI_NODE_P (curr_phi_node);
curr_phi_node = NEXT_INSN (curr_phi_node))
visit_phi_node (curr_phi_node, succ_block);
/* If this is the first time we've simulated this block, then we
must simulate each of its insns. */
if (!TEST_BIT (executable_blocks, succ_block->index))
{
rtx currinsn;
edge succ_edge = succ_block->succ;
/* Note that we have simulated this block. */
SET_BIT (executable_blocks, succ_block->index);
/* Simulate each insn within the block. */
currinsn = succ_block->head;
while (currinsn != succ_block->end)
{
if (INSN_P (currinsn))
visit_expression (currinsn, succ_block);
currinsn = NEXT_INSN (currinsn);
}
/* Don't forget the last insn in the block. */
if (INSN_P (currinsn))
visit_expression (currinsn, succ_block);
/* If we haven't looked at the next block, and it has a
single successor, add it onto the worklist. This is because
if we only have one successor, we know it gets executed,
so we don't have to wait for cprop to tell us. */
if (succ_edge != NULL
&& succ_edge->succ_next == NULL
&& !TEST_BIT (executable_edges,
EIE (succ_edge->src, succ_edge->dest)))
{
SET_BIT (executable_edges,
EIE (succ_edge->src, succ_edge->dest));
edge_info[EIE (succ_edge->src, succ_edge->dest)] = flow_edges;
flow_edges = succ_edge;
}
}
}
}
/* Follow the def-use chains for each definition on the worklist and
simulate the uses of the definition. */
static void
follow_def_use_chains ()
{
/* Iterate over all the entries on the SSA_EDGES worklist. */
while (sbitmap_first_set_bit (ssa_edges) >= 0)
{
int member;
struct df_link *curruse;
/* Pick an entry off the worklist (it does not matter which
entry we pick). */
member = sbitmap_first_set_bit (ssa_edges);
RESET_BIT (ssa_edges, member);
/* Iterate through all the uses of this entry. */
for (curruse = df_analyzer->regs[member].uses; curruse;
curruse = curruse->next)
{
rtx useinsn;
useinsn = DF_REF_INSN (curruse->ref);
if (PHI_NODE_P (useinsn))
{
if (TEST_BIT (executable_blocks, BLOCK_NUM (useinsn)))
visit_phi_node (useinsn, BLOCK_FOR_INSN (useinsn));
}
else
{
if (TEST_BIT (executable_blocks, BLOCK_NUM (useinsn)))
visit_expression (useinsn, BLOCK_FOR_INSN (useinsn));
}
}
}
}
/* Examine each edge to see if we were able to prove any were
not executable.
If an edge is not executable, then we can remove its alternative
in PHI nodes as the destination of the edge, we can simplify the
conditional branch at the source of the edge, and we can remove
the edge from the CFG. Note we do not delete unreachable blocks
yet as the DF analyzer can not deal with that yet. */
static void
optimize_unexecutable_edges (edges, executable_edges)
struct edge_list *edges;
sbitmap executable_edges;
{
int i;
for (i = 0; i < NUM_EDGES (edges); i++)
{
if (!TEST_BIT (executable_edges, i))
{
edge edge = INDEX_EDGE (edges, i);
if (edge->flags & EDGE_ABNORMAL)
continue;
/* We found an edge that is not executable. First simplify
the PHI nodes in the target block. */
if (edge->dest != EXIT_BLOCK_PTR)
{
rtx insn = first_insn_after_basic_block_note (edge->dest);
while (PHI_NODE_P (insn))
{
remove_phi_alternative (PATTERN (insn), edge->src);
if (rtl_dump_file)
fprintf (rtl_dump_file,
"Removing alternative for bb %d of phi %d\n",
edge->src->index, SSA_NAME (PATTERN (insn)));
insn = NEXT_INSN (insn);
}
}
if (rtl_dump_file)
fprintf (rtl_dump_file,
"Removing unexecutable edge from %d to %d\n",
edge->src->index, edge->dest->index);
/* Since the edge was not executable, remove it from the CFG. */
remove_edge (edge);
}
}
/* We have removed all the unexecutable edges from the CFG. Fix up
the conditional jumps at the end of any affected block.
We have three cases to deal with:
a. Both outgoing edges are not executable. This happens if the
source block is not reachable. We will deal with this by
deleting all the insns in the block later.
b. The fall-thru edge is not executable. In this case we
change the conditional jump into an unconditional jump and
add a BARRIER after the unconditional jump. Note that since
we are working on generic RTL we can change the jump in-place
instead of dealing with the headache of reemitting the jump.
c. The branch taken edge is not executable. In this case
we turn the jump into (set (pc) (pc)) which is a nop-jump
and we will remove the unrecognizable insn later.
In cases B & C we are removing uses of registers, so make sure
to note those changes for the DF analyzer. */
for (i = 0; i < n_basic_blocks; i++)
{
basic_block bb = BASIC_BLOCK (i);
rtx insn = bb->end;
edge edge = bb->succ;
/* If we have no predecessors, then this block is unreachable and
will be cleaned up when we remove unreachable blocks. */
if (bb->pred == NULL || GET_CODE (insn) != JUMP_INSN)
continue;
/* If this block ends in a conditional jump, but only has one
successor, then the jump needs adjustment. */
if (condjump_p (insn) && ! simplejump_p (insn)
&& bb->succ && bb->succ->succ_next == NULL)
{
/* If the fallthru edge is the executable edge, then turn
this jump into a nop jump, otherwise make it an unconditinoal
jump to its target. */
if (edge->flags & EDGE_FALLTHRU)
{
PUT_CODE (insn, NOTE);
NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
}
else
{
SET_SRC (PATTERN (insn)) = gen_rtx_LABEL_REF (Pmode,
JUMP_LABEL (insn));
emit_barrier_after (insn);
INSN_CODE (insn) = -1;
}
/* Inform the DF analyzer that this insn changed. */
df_insn_modify (df_analyzer, BLOCK_FOR_INSN (insn), insn);
}
}
}
/* Perform substitution of known values for pseudo registers.
??? Note we do not do simplifications or constant folding here, it
is unlikely that any significant simplifications can be done here
anyway. Consider that if the simplification would result in an
expression that produces a constant value that the value would
have been discovered and recorded already.
We perform two transformations. First, we initialize pseudos to their
known constant values at their definition point. Second, we try to
replace uses with the known constant value. */
static void
ssa_ccp_substitute_constants ()
{
unsigned int i;
for (i = FIRST_PSEUDO_REGISTER; i < VARRAY_SIZE (ssa_definition); i++)
{
if (values[i].lattice_val == CONSTANT)
{
rtx def = VARRAY_RTX (ssa_definition, i);
rtx set = single_set (def);
struct df_link *curruse;
if (! set)
continue;
/* Do not try to simplify PHI nodes down to a constant load.
That will be done later as we translate out of SSA. Also,
doing that here could violate the rule that all PHI nodes
are consecutive at the start of the basic block.
Don't do anything to nodes that were already sets to
constants. */
if (! PHI_NODE_P (def)
&& ! ((GET_CODE (def) == INSN
&& GET_CODE (SET_SRC (set)) == CONST_INT)))
{
if (rtl_dump_file)
fprintf (rtl_dump_file,
"Register %d is now set to a constant\n",
SSA_NAME (PATTERN (def)));
SET_SRC (set) = values[i].const_value;
INSN_CODE (def) = -1;
df_insn_modify (df_analyzer, BLOCK_FOR_INSN (def), def);
}
/* Iterate through all the uses of this entry and try replacements
there too. Note it is not particularly profitable to try
and fold/simplify expressions here as most of the common
cases were handled above. */
for (curruse = df_analyzer->regs[i].uses;
curruse;
curruse = curruse->next)
{
rtx useinsn;
useinsn = DF_REF_INSN (curruse->ref);
if (!INSN_DELETED_P (useinsn)
&& ! (GET_CODE (useinsn) == NOTE
&& NOTE_LINE_NUMBER (useinsn) == NOTE_INSN_DELETED)
&& (GET_CODE (useinsn) == INSN
|| GET_CODE (useinsn) == JUMP_INSN))
{
if (validate_replace_src (regno_reg_rtx [i],
values[i].const_value,
useinsn))
{
if (rtl_dump_file)
fprintf (rtl_dump_file,
"Register %d in insn %d replaced with constant\n",
i, INSN_UID (useinsn));
INSN_CODE (useinsn) = -1;
df_insn_modify (df_analyzer,
BLOCK_FOR_INSN (useinsn),
useinsn);
}
}
}
}
}
}
/* Now find all unreachable basic blocks. All the insns in those
blocks are unreachable, so delete them and mark any necessary
updates for the DF analyzer. */
static void
ssa_ccp_df_delete_unreachable_insns ()
{
int i;
/* Use the CFG to find all the reachable blocks. */
find_unreachable_blocks ();
/* Now we know what blocks are not reachable. Mark all the insns
in those blocks as deleted for the DF analyzer. We'll let the
normal flow code actually remove the unreachable blocks. */
for (i = n_basic_blocks - 1; i >= 0; --i)
{
basic_block b = BASIC_BLOCK (i);
if (!(b->flags & BB_REACHABLE))
{
rtx start = b->head;
rtx end = b->end;
rtx tmp;
/* Include any jump table following the basic block. */
end = b->end;
if (GET_CODE (end) == JUMP_INSN
&& (tmp = JUMP_LABEL (end)) != NULL_RTX
&& (tmp = NEXT_INSN (tmp)) != NULL_RTX
&& GET_CODE (tmp) == JUMP_INSN
&& (GET_CODE (PATTERN (tmp)) == ADDR_VEC
|| GET_CODE (PATTERN (tmp)) == ADDR_DIFF_VEC))
end = tmp;
while (1)
{
rtx next = NEXT_INSN (start);
if (GET_CODE (start) == INSN
|| GET_CODE (start) == CALL_INSN
|| GET_CODE (start) == JUMP_INSN)
df_insn_delete (df_analyzer, BLOCK_FOR_INSN (start), start);
if (start == end)
break;
start = next;
}
}
}
}
/* Main entry point for SSA Conditional Constant Propagation.
Long term it should accept as input the specific flow graph to
operate on so that it can be called for sub-graphs. */
void
ssa_const_prop ()
{
unsigned int i;
edge curredge;
/* We need alias analysis (for what?) */
init_alias_analysis ();
df_analyzer = df_init ();
df_analyse (df_analyzer, 0,
DF_RD_CHAIN | DF_RU_CHAIN | DF_REG_INFO | DF_HARD_REGS);
/* We need mappings from insn to its containing block. */
compute_bb_for_insn (get_max_uid ());
/* Perform a quick and dirty dead code elimination pass. This is not
as aggressive as it could be, but it's good enough to clean up a
lot of unwanted junk and it is fast. */
ssa_fast_dce (df_analyzer);
/* Build an edge list from the CFG. */
edges = create_edge_list ();
/* Initialize the values array with everything as undefined. */
values = (value *) xmalloc (VARRAY_SIZE (ssa_definition) * sizeof (value));
for (i = 0; i < VARRAY_SIZE (ssa_definition); i++)
{
if (i < FIRST_PSEUDO_REGISTER)
values[i].lattice_val = VARYING;
else
values[i].lattice_val = UNDEFINED;
values[i].const_value = NULL;
}
ssa_edges = sbitmap_alloc (VARRAY_SIZE (ssa_definition));
sbitmap_zero (ssa_edges);
executable_blocks = sbitmap_alloc (n_basic_blocks);
sbitmap_zero (executable_blocks);
executable_edges = sbitmap_alloc (NUM_EDGES (edges));
sbitmap_zero (executable_edges);
edge_info = (edge *) xmalloc (NUM_EDGES (edges) * sizeof (edge));
flow_edges = ENTRY_BLOCK_PTR->succ;
/* Add the successors of the entry block to the edge worklist. That
is enough of a seed to get SSA-CCP started. */
for (curredge = ENTRY_BLOCK_PTR->succ; curredge;
curredge = curredge->succ_next)
{
int index = EIE (curredge->src, curredge->dest);
SET_BIT (executable_edges, index);
edge_info[index] = curredge->succ_next;
}
/* Iterate until until the worklists are empty. */
do
{
examine_flow_edges ();
follow_def_use_chains ();
}
while (flow_edges != NULL);
/* Now perform substitutions based on the known constant values. */
ssa_ccp_substitute_constants ();
/* Remove unexecutable edges from the CFG and make appropriate
adjustments to PHI nodes. */
optimize_unexecutable_edges (edges, executable_edges);
/* Now remove all unreachable insns and update the DF information.
as appropriate. */
ssa_ccp_df_delete_unreachable_insns ();
#if 0
/* The DF analyzer expects the number of blocks to remain constant,
so we can't remove unreachable blocks.
Code the DF analyzer calls expects there to be no unreachable
blocks in the CFG. So we can't leave unreachable blocks in the
CFG.
So, there is no way to do an incremental update of the DF data
at this point. */
df_analyse (df_analyzer, 0,
DF_RD_CHAIN | DF_RU_CHAIN | DF_REG_INFO | DF_HARD_REGS);
#endif
/* Clean up any dead code exposed by SSA-CCP, do this after updating
the dataflow information! */
ssa_fast_dce (df_analyzer);
free (values);
values = NULL;
free (edge_info);
edge_info = NULL;
sbitmap_free (executable_blocks);
executable_blocks = NULL;
sbitmap_free (ssa_edges);
ssa_edges = NULL;
free_edge_list (edges);
edges = NULL;
sbitmap_free (executable_edges);
executable_edges = NULL;
df_finish (df_analyzer);
end_alias_analysis ();
}
static int
mark_references (current_rtx, data)
rtx *current_rtx;
void *data;
{
rtx x = *current_rtx;
sbitmap worklist = (sbitmap) data;
if (x == NULL_RTX)
return 0;
if (GET_CODE (x) == SET)
{
rtx dest = SET_DEST (x);
if (GET_CODE (dest) == STRICT_LOW_PART
|| GET_CODE (dest) == SUBREG
|| GET_CODE (dest) == SIGN_EXTRACT
|| GET_CODE (dest) == ZERO_EXTRACT)
{
rtx reg;
reg = dest;
while (GET_CODE (reg) == STRICT_LOW_PART
|| GET_CODE (reg) == SUBREG
|| GET_CODE (reg) == SIGN_EXTRACT
|| GET_CODE (reg) == ZERO_EXTRACT)
reg = XEXP (reg, 0);
if (GET_CODE (reg) == REG)
SET_BIT (worklist, REGNO (reg));
}
if (GET_CODE (dest) == REG)
{
for_each_rtx (&SET_SRC (x), mark_references, data);
return -1;
}
return 0;
}
else if (GET_CODE (x) == REG)
{
SET_BIT (worklist, REGNO (x));
return -1;
}
else if (GET_CODE (x) == CLOBBER)
return -1;
else
return 0;
}
static void
ssa_fast_dce (df)
struct df *df;
{
sbitmap worklist = sbitmap_alloc (VARRAY_SIZE (ssa_definition));
sbitmap_ones (worklist);
/* Iterate on the worklist until there's no definitions left to
examine. */
while (sbitmap_first_set_bit (worklist) >= 0)
{
struct df_link *curruse;
int reg, found_use;
/* Remove an item from the worklist. */
reg = sbitmap_first_set_bit (worklist);
RESET_BIT (worklist, reg);
/* We never consider deleting assignments to hard regs or things
which do not have SSA definitions, or things we have already
deleted, or things with unusual side effects. */
if (reg < FIRST_PSEUDO_REGISTER
|| ! VARRAY_RTX (ssa_definition, reg)
|| INSN_DELETED_P (VARRAY_RTX (ssa_definition, reg))
|| (GET_CODE (VARRAY_RTX (ssa_definition, reg)) == NOTE
&& (NOTE_LINE_NUMBER (VARRAY_RTX (ssa_definition, reg))
== NOTE_INSN_DELETED))
|| side_effects_p (PATTERN (VARRAY_RTX (ssa_definition, reg))))
continue;
/* Iterate over the uses of this register. If we can not find
any uses that have not been deleted, then the definition of
this register is dead. */
found_use = 0;
for (curruse = df->regs[reg].uses; curruse; curruse = curruse->next)
{
if (curruse->ref
&& DF_REF_INSN (curruse->ref)
&& ! INSN_DELETED_P (DF_REF_INSN (curruse->ref))
&& ! (GET_CODE (DF_REF_INSN (curruse->ref)) == NOTE
&& (NOTE_LINE_NUMBER (DF_REF_INSN (curruse->ref))
== NOTE_INSN_DELETED))
&& DF_REF_INSN (curruse->ref) != VARRAY_RTX (ssa_definition, reg))
{
found_use = 1;
break;
}
}
/* If we did not find a use of this register, then the definition
of this register is dead. */
if (! found_use)
{
rtx def = VARRAY_RTX (ssa_definition, reg);
/* Add all registers referenced by INSN to the work
list. */
for_each_rtx (&PATTERN (def), mark_references, worklist);
/* Inform the analyzer that this insn is going to be
deleted. */
df_insn_delete (df, BLOCK_FOR_INSN (def), def);
VARRAY_RTX (ssa_definition, reg) = NULL;
}
}
sbitmap_free (worklist);
/* Update the use-def chains in the df_analyzer as needed. */
df_analyse (df_analyzer, 0,
DF_RD_CHAIN | DF_RU_CHAIN | DF_REG_INFO | DF_HARD_REGS);
}
Reference in New Issue View Git Blame Copy Permalink