Patchwork Cleanup tree-ssa-ter.c exports

login
register
mail settings
Submitter Andrew MacLeod
Date Sept. 13, 2013, 7:15 p.m.
Message ID <52336443.3020100@redhat.com>
Download mbox | patch
Permalink /patch/274858/
State New
Headers show

Comments

Andrew MacLeod - Sept. 13, 2013, 7:15 p.m.
On 09/13/2013 11:11 AM, Andrew MacLeod wrote:
> On 09/13/2013 03:54 AM, Richard Biener wrote:
>> On Thu, Sep 12, 2013 at 11:09 PM, Andrew MacLeod 
>> <amacleod@redhat.com> wrote:
>>> There are 2 parts of tre-ssa-ter.c to address.
>>>
>>> is_replaceable_p() is also used in expr.c, It has a flag to indicate 
>>> where
>>> its being called from, and we do different checks for each one.  
>>> There is a
>>> wrapper function stmt_is_replaceable_p() in tree-ssa-ter.c which 
>>> hides the
>>> setting of the flag to expr.c. Most of the function is common, so I
>>> extracted out the common part, and put it in tree-ssa.c.
>>> I then moved stmt_is_replaceable() to expr.c, has it call the common 
>>> routine
>>> and then added the extra bit it needs there.  Similarly 
>>> tree-ssa-ter.c gets
>>> ter_is_replaceable_p() which calls the common part, and then does 
>>> its own
>>> special checking.   This removes that general export and messiness from
>>> tree-ssa-ter.c
>>>
>>> I think I got the logic of the function right, but you might want to 
>>> double
>>> check...  It was giving me a headache when I split it :-)
>>>
>>> Unfortunately,  tree-ssa-ter.c also has 2 functions
>>> (find_replaceable_exprs() and  dump_replaceable_exprs()) which are 
>>> exported
>>> and utilized by tree-outof-ssa.c  (the file is a part of the out-of-ssa
>>> module).  So I moved the prototypes from tree-ssa-live.h into a newly
>>> created tree-ssa-ter.h file,  and included it directly from
>>> tree-outof-ssa.c, the only consumer.
>>>
>>> I also could have just left the is_replaceable_p() function as is, 
>>> put the
>>> prototype and the 'stmt_is_replaceable_p()' wrapper function in
>>> tree-ssa-ter.h, and then included that from expr.c...  but it just 
>>> seems
>>> like an odd thing to include directly there....  but that is an 
>>> option...
>>>
>>> eventually we mighty want to look at splitting expr.c.. it seems a bit
>>> multi-personality with some pure RTL, some tree/rtl and some 
>>> ssa...   even
>>> though they all serve the same ultimate function, it is 11,000+ 
>>> lines long
>>> now :-) .  A task for another day.
>> is_replaceable_p and friends is purely specific to the area of RTL 
>> expansion,
>> so putting it in tree-ssa.[ch] is definitely wrong.  It doesn't make 
>> sense to
>> use it anywhere else.
>>
>> The main driver of the RTL expansion process is in cfgexpand.c (the 
>> expand
>> pass itself) in gimple_expand_cfg.  We have one header file related to
>> the RTL expansion process and is_replaceable_p would simply fit in
>> ssaexpand.h (which doesn't have a .c file, so leaving the stuff in 
>> the .c files
>> where they are now is ok).
>>
>> So - I fear you have to re-do this patch (in a much simpler way).
>>
> I actually figured as much :-)  I had actually done that split before 
> I remembered there were other exports, and considered undoing that 
> part, but figured since I had done it I'd get opinion :-)
>
> Or are you suggesting we also bail on tree-ssa-ter.h and put those 
> prototypes in ssaexpand.h?
>
> If we want to make this fully consistent (.h's match .c exports) , I 
> could put is_replaceable_p() into a new ssaexpand.c, move the 3 
> tree-outof-ssa prototypes in ssaexpand.h into tree-outof-ssa.h, and 
> have ssaexpand.h include tree-ssa-ter.h and tree-outof-ssa.h.   That 
> would then be clean. and consistent.
>
> actually, we could just make is_replaceable_p() static inline in 
> ssaexpand.h...  thats not unreasonable either, but we'll probably find 
> functions which belong in ssaexpand.c sooner or later.
>
> No worries, I figured these first few patches would be slower and more 
> painful until a reasonable formula was determined :-)
>
>
> Andrew
>
OK, a slightly different take..
I realized that I should be adding tree-outof-ssa.h to handle the 3 
exports from tree-outof-ssa.c that are in ssaexpand.h...  In fact, by 
far the most sensible thing to do is to simply rename tree-outof-ssa.c 
to ssaexpand.c.  This actually resolves a number of warts... And 
is_replaceable_p() very naturally fits in ssaexpand.c now...

what do you think of this option? :-)  and svn rename preserves all the 
tree-outof-ssa.c history...

Andrew
Richard Guenther - Sept. 16, 2013, 8:55 a.m.
On Fri, Sep 13, 2013 at 9:15 PM, Andrew MacLeod <amacleod@redhat.com> wrote:
> On 09/13/2013 11:11 AM, Andrew MacLeod wrote:
>>
>> On 09/13/2013 03:54 AM, Richard Biener wrote:
>>>
>>> On Thu, Sep 12, 2013 at 11:09 PM, Andrew MacLeod <amacleod@redhat.com>
>>> wrote:
>>>>
>>>> There are 2 parts of tre-ssa-ter.c to address.
>>>>
>>>> is_replaceable_p() is also used in expr.c, It has a flag to indicate
>>>> where
>>>> its being called from, and we do different checks for each one.  There
>>>> is a
>>>> wrapper function stmt_is_replaceable_p() in tree-ssa-ter.c which hides
>>>> the
>>>> setting of the flag to expr.c. Most of the function is common, so I
>>>> extracted out the common part, and put it in tree-ssa.c.
>>>> I then moved stmt_is_replaceable() to expr.c, has it call the common
>>>> routine
>>>> and then added the extra bit it needs there.  Similarly tree-ssa-ter.c
>>>> gets
>>>> ter_is_replaceable_p() which calls the common part, and then does its
>>>> own
>>>> special checking.   This removes that general export and messiness from
>>>> tree-ssa-ter.c
>>>>
>>>> I think I got the logic of the function right, but you might want to
>>>> double
>>>> check...  It was giving me a headache when I split it :-)
>>>>
>>>> Unfortunately,  tree-ssa-ter.c also has 2 functions
>>>> (find_replaceable_exprs() and  dump_replaceable_exprs()) which are
>>>> exported
>>>> and utilized by tree-outof-ssa.c  (the file is a part of the out-of-ssa
>>>> module).  So I moved the prototypes from tree-ssa-live.h into a newly
>>>> created tree-ssa-ter.h file,  and included it directly from
>>>> tree-outof-ssa.c, the only consumer.
>>>>
>>>> I also could have just left the is_replaceable_p() function as is, put
>>>> the
>>>> prototype and the 'stmt_is_replaceable_p()' wrapper function in
>>>> tree-ssa-ter.h, and then included that from expr.c...  but it just seems
>>>> like an odd thing to include directly there....  but that is an
>>>> option...
>>>>
>>>> eventually we mighty want to look at splitting expr.c.. it seems a bit
>>>> multi-personality with some pure RTL, some tree/rtl and some ssa...
>>>> even
>>>> though they all serve the same ultimate function, it is 11,000+ lines
>>>> long
>>>> now :-) .  A task for another day.
>>>
>>> is_replaceable_p and friends is purely specific to the area of RTL
>>> expansion,
>>> so putting it in tree-ssa.[ch] is definitely wrong.  It doesn't make
>>> sense to
>>> use it anywhere else.
>>>
>>> The main driver of the RTL expansion process is in cfgexpand.c (the
>>> expand
>>> pass itself) in gimple_expand_cfg.  We have one header file related to
>>> the RTL expansion process and is_replaceable_p would simply fit in
>>> ssaexpand.h (which doesn't have a .c file, so leaving the stuff in the .c
>>> files
>>> where they are now is ok).
>>>
>>> So - I fear you have to re-do this patch (in a much simpler way).
>>>
>> I actually figured as much :-)  I had actually done that split before I
>> remembered there were other exports, and considered undoing that part, but
>> figured since I had done it I'd get opinion :-)
>>
>> Or are you suggesting we also bail on tree-ssa-ter.h and put those
>> prototypes in ssaexpand.h?
>>
>> If we want to make this fully consistent (.h's match .c exports) , I could
>> put is_replaceable_p() into a new ssaexpand.c, move the 3 tree-outof-ssa
>> prototypes in ssaexpand.h into tree-outof-ssa.h, and have ssaexpand.h
>> include tree-ssa-ter.h and tree-outof-ssa.h.   That would then be clean. and
>> consistent.
>>
>> actually, we could just make is_replaceable_p() static inline in
>> ssaexpand.h...  thats not unreasonable either, but we'll probably find
>> functions which belong in ssaexpand.c sooner or later.
>>
>> No worries, I figured these first few patches would be slower and more
>> painful until a reasonable formula was determined :-)
>>
>>
>> Andrew
>>
> OK, a slightly different take..
> I realized that I should be adding tree-outof-ssa.h to handle the 3 exports
> from tree-outof-ssa.c that are in ssaexpand.h...  In fact, by far the most
> sensible thing to do is to simply rename tree-outof-ssa.c to ssaexpand.c.
> This actually resolves a number of warts... And is_replaceable_p() very
> naturally fits in ssaexpand.c now...
>
> what do you think of this option? :-)  and svn rename preserves all the
> tree-outof-ssa.c history...

I don't like the new name for tree-outof-ssa.c, it matches less to its contents.

I'd say either keep ssaexpand.h and tree-outof-ssa.c as-is or rename
ssaexpand.h to tree-outof-ssa.h.  I prefer the latter.

The rest of the changes look ok to me, but watch out for odd whitespace
changes:

+static inline bool
+ter_is_replaceable_p (gimple stmt)
+{
+
+  if (ssa_is_replaceable_p (stmt))

spurious vertical space.

Thanks,
Richard.



> Andrew
>
>
>
>
Andrew MacLeod - Sept. 16, 2013, 2:42 p.m.
On 09/16/2013 04:55 AM, Richard Biener wrote:
> On Fri, Sep 13, 2013 at 9:15 PM, Andrew MacLeod <amacleod@redhat.com> wrote:
>>
>>
>> OK, a slightly different take..
>> I realized that I should be adding tree-outof-ssa.h to handle the 3 exports
>> from tree-outof-ssa.c that are in ssaexpand.h...  In fact, by far the most
>> sensible thing to do is to simply rename tree-outof-ssa.c to ssaexpand.c.
>> This actually resolves a number of warts... And is_replaceable_p() very
>> naturally fits in ssaexpand.c now...
>>
>> what do you think of this option? :-)  and svn rename preserves all the
>> tree-outof-ssa.c history...
> I don't like the new name for tree-outof-ssa.c, it matches less to its contents.
>
> I'd say either keep ssaexpand.h and tree-outof-ssa.c as-is or rename
> ssaexpand.h to tree-outof-ssa.h.  I prefer the latter.

I as well.  ssaexpand.h ->tree-outof-ssa.h it is.

>
> The rest of the changes look ok to me, but watch out for odd whitespace
> changes:
>
> +static inline bool
> +ter_is_replaceable_p (gimple stmt)
> +{
> +
> +  if (ssa_is_replaceable_p (stmt))
>
> spurious vertical space.
>
>
bah, where'd that come from :-P.

I'll check this approach in  after  running it through the gauntlet again.

Andrew

Patch


	* tree-ssa-live.h (find_replaceable_exprs, dump_replaceable_exprs): Move
	prototypes to...
	* tree-ssa-ter.h: New.  Move prototypes here.
	* tree-flow.h (stmt_is_replaceable_p): Move prototype to...
	* ssaexpand.h:  Here.  Include tree-ssa-ter.h
	* expr.c (stmt_is_replaceable_p): Relocate from tree-ssa-ter.c.  Use
	newly refactored ssa_is_replaceable_p.
	* tree-ssa-ter.c (is_replaceable_p, stmt_is_replaceable_p): Delete.
	(ter_is_replaceable_p): Use new refactored ssa_is_replaceable_p.
	(process_replaceable): Use ter_is_replaceable_p.
	(find_replaceable_in_bb): Use ter_is_replaceable_p.
	* Makefile.in: Update Dependencies and object files..
	* ssaexpand.c: Renamed from tree-outof-ssa.c.
	(ssa_is_replaceable_p): Import common bits of is_replaceable_p.
	* tree-outof-ssa.c: Delete.

Index: tree-ssa-live.h
===================================================================
--- tree-ssa-live.h	(revision 202567)
+++ tree-ssa-live.h	(working copy)
@@ -325,10 +325,4 @@ 
 /* From tree-ssa-coalesce.c  */
 extern var_map coalesce_ssa_name (void);
 
-
-/* From tree-ssa-ter.c  */
-extern bitmap find_replaceable_exprs (var_map);
-extern void dump_replaceable_exprs (FILE *, bitmap);
-
-
 #endif /* _TREE_SSA_LIVE_H  */
Index: tree-ssa-ter.h
===================================================================
--- tree-ssa-ter.h	(revision 0)
+++ tree-ssa-ter.h	(working copy)
@@ -0,0 +1,26 @@ 
+/* Header file for tree-ssa-ter.c exports.
+   Copyright (C) 2013 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/>.  */
+
+#ifndef GCC_TREE_SSA_TER_H
+#define GCC_TREE_SSA_TER_H
+
+extern bitmap find_replaceable_exprs (var_map);
+extern void dump_replaceable_exprs (FILE *, bitmap);
+
+#endif /* GCC_TREE_SSA_TER_H */
Index: tree-flow.h
===================================================================
--- tree-flow.h	(revision 202567)
+++ tree-flow.h	(working copy)
@@ -686,9 +686,6 @@ 
 /* In ipa-pure-const.c  */
 void warn_function_noreturn (tree);
 
-/* In tree-ssa-ter.c  */
-bool stmt_is_replaceable_p (gimple);
-
 /* In tree-parloops.c  */
 bool parallelized_function_p (tree);
 
Index: ssaexpand.h
===================================================================
--- ssaexpand.h	(revision 202567)
+++ ssaexpand.h	(working copy)
@@ -22,6 +22,7 @@ 
 #define _SSAEXPAND_H 1
 
 #include "tree-ssa-live.h"
+#include "tree-ssa-ter.h"
 
 /* This structure (of which only a singleton SA exists) is used to
    pass around information between the outof-SSA functions, cfgexpand
@@ -71,9 +72,9 @@ 
   return NULL;
 }
 
-/* In tree-outof-ssa.c.  */
-void finish_out_of_ssa (struct ssaexpand *sa);
-unsigned int rewrite_out_of_ssa (struct ssaexpand *sa);
-void expand_phi_nodes (struct ssaexpand *sa);
+extern bool ssa_is_replaceable_p (gimple stmt);
+extern void finish_out_of_ssa (struct ssaexpand *sa);
+extern unsigned int rewrite_out_of_ssa (struct ssaexpand *sa);
+extern void expand_phi_nodes (struct ssaexpand *sa);
 
 #endif
Index: expr.c
===================================================================
--- expr.c	(revision 202567)
+++ expr.c	(working copy)
@@ -9176,6 +9176,24 @@ 
 }
 #undef REDUCE_BIT_FIELD
 
+
+/* Return TRUE if expression STMT is suitable for replacement.  
+   Never consider memory loads as replaceable, because those don't ever lead 
+   into constant expressions.  */
+
+static bool
+stmt_is_replaceable_p (gimple stmt)
+{
+  if (ssa_is_replaceable_p (stmt))
+    {
+      /* Don't move around loads.  */
+      if (!gimple_assign_single_p (stmt)
+	  || is_gimple_val (gimple_assign_rhs1 (stmt)))
+	return true;
+    }
+  return false;
+}
+
 rtx
 expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
 		    enum expand_modifier modifier, rtx *alt_rtl)
Index: tree-ssa-ter.c
===================================================================
--- tree-ssa-ter.c	(revision 202567)
+++ tree-ssa-ter.c	(working copy)
@@ -28,7 +28,7 @@ 
 #include "bitmap.h"
 #include "tree-ssa.h"
 #include "dumpfile.h"
-#include "tree-ssa-live.h"
+#include "ssaexpand.h"
 #include "flags.h"
 
 
@@ -46,7 +46,7 @@ 
    information is tracked.
 
    Variables which only have one use, and whose defining stmt is considered
-   a replaceable expression (see is_replaceable_p) are tracked to see whether
+   a replaceable expression (see ssa_is_replaceable_p) are tracked to see whether
    they can be replaced at their use location.
 
    n_12 = C * 10
@@ -359,111 +359,6 @@ 
 }
 
 
-/* Return TRUE if expression STMT is suitable for replacement.
-   TER is true if is_replaceable_p is called from within TER, false
-   when used from within stmt_is_replaceable_p, i.e. EXPAND_INITIALIZER
-   expansion.  The differences are that with !TER some tests are skipped
-   to make it more aggressive (doesn't require the same bb, or for -O0
-   same locus and same BLOCK), on the other side never considers memory
-   loads as replaceable, because those don't ever lead into constant
-   expressions.  */
-
-static inline bool
-is_replaceable_p (gimple stmt, bool ter)
-{
-  use_operand_p use_p;
-  tree def;
-  gimple use_stmt;
-  location_t locus1, locus2;
-  tree block1, block2;
-
-  /* Only consider modify stmts.  */
-  if (!is_gimple_assign (stmt))
-    return false;
-
-  /* If the statement may throw an exception, it cannot be replaced.  */
-  if (stmt_could_throw_p (stmt))
-    return false;
-
-  /* Punt if there is more than 1 def.  */
-  def = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF);
-  if (!def)
-    return false;
-
-  /* Only consider definitions which have a single use.  */
-  if (!single_imm_use (def, &use_p, &use_stmt))
-    return false;
-
-  /* If the use isn't in this block, it wont be replaced either.  */
-  if (ter && gimple_bb (use_stmt) != gimple_bb (stmt))
-    return false;
-
-  locus1 = gimple_location (stmt);
-  block1 = LOCATION_BLOCK (locus1);
-  locus1 = LOCATION_LOCUS (locus1);
-
-  if (gimple_code (use_stmt) == GIMPLE_PHI)
-    locus2 = gimple_phi_arg_location (use_stmt, PHI_ARG_INDEX_FROM_USE (use_p));
-  else
-    locus2 = gimple_location (use_stmt);
-  block2 = LOCATION_BLOCK (locus2);
-  locus2 = LOCATION_LOCUS (locus2);
-
-  if ((!optimize || optimize_debug)
-      && ter
-      && ((locus1 != UNKNOWN_LOCATION
-	   && locus1 != locus2)
-	  || (block1 != NULL_TREE
-	      && block1 != block2)))
-    return false;
-
-  /* Used in this block, but at the TOP of the block, not the end.  */
-  if (gimple_code (use_stmt) == GIMPLE_PHI)
-    return false;
-
-  /* There must be no VDEFs.  */
-  if (gimple_vdef (stmt))
-    return false;
-
-  /* Without alias info we can't move around loads.  */
-  if ((!optimize || !ter)
-      && gimple_assign_single_p (stmt)
-      && !is_gimple_val (gimple_assign_rhs1 (stmt)))
-    return false;
-
-  /* Float expressions must go through memory if float-store is on.  */
-  if (flag_float_store
-      && FLOAT_TYPE_P (gimple_expr_type (stmt)))
-    return false;
-
-  /* An assignment with a register variable on the RHS is not
-     replaceable.  */
-  if (gimple_assign_rhs_code (stmt) == VAR_DECL
-      && DECL_HARD_REGISTER (gimple_assign_rhs1 (stmt)))
-    return false;
-
-  /* No function calls can be replaced.  */
-  if (is_gimple_call (stmt))
-    return false;
-
-  /* Leave any stmt with volatile operands alone as well.  */
-  if (gimple_has_volatile_ops (stmt))
-    return false;
-
-  return true;
-}
-
-
-/* Variant of is_replaceable_p test for use in EXPAND_INITIALIZER
-   expansion.  */
-
-bool
-stmt_is_replaceable_p (gimple stmt)
-{
-  return is_replaceable_p (stmt, false);
-}
-
-
 /* This function will remove the expression for VERSION from replacement
    consideration in table TAB.  If FREE_EXPR is true, then remove the
    expression from consideration as well by freeing the decl uid bitmap.  */
@@ -487,6 +382,62 @@ 
 }
 
 
+/* Return TRUE if expression STMT is suitable for replacement.
+   In addition to ssa_is_replaceable_p, require the same bb, and for -O0
+   same locus and same BLOCK), Considers memory loads as replaceable if aliasing
+   is available.  */
+
+static inline bool
+ter_is_replaceable_p (gimple stmt)
+{
+
+  if (ssa_is_replaceable_p (stmt))
+    {
+      use_operand_p use_p;
+      tree def;
+      gimple use_stmt;
+      location_t locus1, locus2;
+      tree block1, block2;
+
+      /* Only consider definitions which have a single use.  ssa_is_replaceable_p
+	 already performed this check, but the use stmt pointer is required for
+	 further checks.  */
+      def = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF);
+      if (!single_imm_use (def, &use_p, &use_stmt))
+	  return false;
+
+      /* If the use isn't in this block, it wont be replaced either.  */
+      if (gimple_bb (use_stmt) != gimple_bb (stmt))
+        return false;
+
+      locus1 = gimple_location (stmt);
+      block1 = LOCATION_BLOCK (locus1);
+      locus1 = LOCATION_LOCUS (locus1);
+
+      if (gimple_code (use_stmt) == GIMPLE_PHI)
+	locus2 = gimple_phi_arg_location (use_stmt, 
+					  PHI_ARG_INDEX_FROM_USE (use_p));
+      else
+	locus2 = gimple_location (use_stmt);
+      block2 = LOCATION_BLOCK (locus2);
+      locus2 = LOCATION_LOCUS (locus2);
+
+      if ((!optimize || optimize_debug)
+	  && ((locus1 != UNKNOWN_LOCATION && locus1 != locus2)
+	      || (block1 != NULL_TREE && block1 != block2)))
+	return false;
+
+      /* Without alias info we can't move around loads.  */
+      if (!optimize && gimple_assign_single_p (stmt)
+	  && !is_gimple_val (gimple_assign_rhs1 (stmt)))
+	return false;
+
+      return true;
+    }
+  return false;
+}
+
+
 /* Create an expression entry for a replaceable expression.  */
 
 static void
@@ -497,7 +448,7 @@ 
   ssa_op_iter iter;
   bitmap def_vars, use_vars;
 
-  gcc_checking_assert (is_replaceable_p (stmt, true));
+  gcc_checking_assert (ter_is_replaceable_p (stmt));
 
   def = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF);
   version = SSA_NAME_VERSION (def);
@@ -612,7 +563,7 @@ 
       if (is_gimple_debug (stmt))
 	continue;
 
-      stmt_replaceable = is_replaceable_p (stmt, true);
+      stmt_replaceable = ter_is_replaceable_p (stmt);
 
       /* Determine if this stmt finishes an existing expression.  */
       FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
Index: Makefile.in
===================================================================
--- Makefile.in	(revision 202567)
+++ Makefile.in	(working copy)
@@ -950,7 +950,7 @@ 
 TREE_SSA_H = tree-ssa.h $(TREE_FLOW_H)
 TREE_HASHER_H = tree-hasher.h $(HASH_TABLE_H) $(TREE_FLOW_H)
 TREE_SSA_LIVE_H = tree-ssa-live.h $(PARTITION_H)
-SSAEXPAND_H = ssaexpand.h $(TREE_SSA_LIVE_H)
+SSAEXPAND_H = ssaexpand.h $(TREE_SSA_LIVE_H) tree-ssa-ter.h
 PRETTY_PRINT_H = pretty-print.h $(INPUT_H) $(OBSTACK_H)
 TREE_PRETTY_PRINT_H = tree-pretty-print.h $(PRETTY_PRINT_H)
 GIMPLE_PRETTY_PRINT_H = gimple-pretty-print.h $(TREE_PRETTY_PRINT_H)
@@ -1370,6 +1370,7 @@ 
 	simplify-rtx.o \
 	sparseset.o \
 	sreal.o \
+	ssaexpand.o \
 	stack-ptr-mod.o \
 	statistics.o \
 	stmt.o \
@@ -1408,7 +1409,6 @@ 
 	tree-nrv.o \
 	tree-object-size.o \
 	tree-optimize.o \
-	tree-outof-ssa.o \
 	tree-parloops.o \
 	tree-phinodes.o \
 	tree-predcom.o \
@@ -2309,16 +2309,15 @@ 
    $(GIMPLE_H) $(TREE_INLINE_H) $(GIMPLE_PRETTY_PRINT_H)
 tree-ssa-ter.o : tree-ssa-ter.c $(TREE_SSA_H) $(CONFIG_H) $(SYSTEM_H) \
    $(TREE_H) $(DIAGNOSTIC_H) $(TM_H) coretypes.h $(DUMPFILE_H) \
-   $(TREE_SSA_LIVE_H) $(BITMAP_H) $(FLAGS_H) \
-   $(GIMPLE_PRETTY_PRINT_H)
+   $(SSAEXPAND_H) $(BITMAP_H) $(FLAGS_H) $(GIMPLE_PRETTY_PRINT_H)
 tree-ssa-coalesce.o : tree-ssa-coalesce.c $(TREE_SSA_H) $(CONFIG_H) \
    $(SYSTEM_H) $(TREE_H) $(DIAGNOSTIC_H) $(TM_H) coretypes.h $(DUMPFILE_H) \
    $(TREE_SSA_LIVE_H) $(BITMAP_H) $(FLAGS_H) $(HASH_TABLE_H) \
    $(TREE_PRETTY_PRINT_H)
-tree-outof-ssa.o : tree-outof-ssa.c $(TREE_SSA_H) $(CONFIG_H) $(SYSTEM_H) \
+ssaexpand.o : ssaexpand.c $(TREE_SSA_H) $(CONFIG_H) $(SYSTEM_H) \
    $(TREE_H) $(DIAGNOSTIC_H) $(TM_H) coretypes.h $(DUMPFILE_H) \
    $(TREE_SSA_LIVE_H) $(BASIC_BLOCK_H) $(BITMAP_H) $(GGC_H) \
-   $(EXPR_H) $(SSAEXPAND_H) $(GIMPLE_PRETTY_PRINT_H)
+   $(EXPR_H) $(SSAEXPAND_H) $(GIMPLE_PRETTY_PRINT_H) 
 tree-ssa-dse.o : tree-ssa-dse.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
    $(TM_H) $(GGC_H) $(TREE_H) $(TM_P_H) $(BASIC_BLOCK_H) \
    $(TREE_SSA_H) $(TREE_PASS_H) domwalk.h $(FLAGS_H) \
Index: ssaexpand.c
===================================================================
--- ssaexpand.c	(working copy)
+++ ssaexpand.c	(working copy)
@@ -37,7 +37,63 @@ 
 #include "expr.h"
 
 
+/* Return TRUE if expression STMT is suitable for replacement.  */
 
+bool
+ssa_is_replaceable_p (gimple stmt)
+{
+  use_operand_p use_p;
+  tree def;
+  gimple use_stmt;
+
+  /* Only consider modify stmts.  */
+  if (!is_gimple_assign (stmt))
+    return false;
+
+  /* If the statement may throw an exception, it cannot be replaced.  */
+  if (stmt_could_throw_p (stmt))
+    return false;
+
+  /* Punt if there is more than 1 def.  */
+  def = SINGLE_SSA_TREE_OPERAND (stmt, SSA_OP_DEF);
+  if (!def)
+    return false;
+
+  /* Only consider definitions which have a single use.  */
+  if (!single_imm_use (def, &use_p, &use_stmt))
+    return false;
+
+  /* Used in this block, but at the TOP of the block, not the end.  */
+  if (gimple_code (use_stmt) == GIMPLE_PHI)
+    return false;
+
+  /* There must be no VDEFs.  */
+  if (gimple_vdef (stmt))
+    return false;
+
+  /* Float expressions must go through memory if float-store is on.  */
+  if (flag_float_store
+      && FLOAT_TYPE_P (gimple_expr_type (stmt)))
+    return false;
+
+  /* An assignment with a register variable on the RHS is not
+     replaceable.  */
+  if (gimple_assign_rhs_code (stmt) == VAR_DECL
+      && DECL_HARD_REGISTER (gimple_assign_rhs1 (stmt)))
+    return false;
+
+  /* No function calls can be replaced.  */
+  if (is_gimple_call (stmt))
+    return false;
+
+  /* Leave any stmt with volatile operands alone as well.  */
+  if (gimple_has_volatile_ops (stmt))
+    return false;
+
+  return true;
+}
+
+
 /* Used to hold all the components required to do SSA PHI elimination.
    The node and pred/succ list is a simple linear list of nodes and
    edges represented as pairs of nodes.
Index: tree-outof-ssa.c
===================================================================
--- tree-outof-ssa.c	(revision 202567)
+++ tree-outof-ssa.c	(working copy)
@@ -1,1139 +0,0 @@ 
-/* Convert a program in SSA form into Normal form.
-   Copyright (C) 2004-2013 Free Software Foundation, Inc.
-   Contributed by Andrew Macleod <amacleod@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 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 "tm.h"
-#include "tree.h"
-#include "ggc.h"
-#include "basic-block.h"
-#include "gimple-pretty-print.h"
-#include "bitmap.h"
-#include "tree-ssa.h"
-#include "dumpfile.h"
-#include "diagnostic-core.h"
-#include "ssaexpand.h"
-
-/* FIXME: A lot of code here deals with expanding to RTL.  All that code
-   should be in cfgexpand.c.  */
-#include "expr.h"
-
-
-
-/* Used to hold all the components required to do SSA PHI elimination.
-   The node and pred/succ list is a simple linear list of nodes and
-   edges represented as pairs of nodes.
-
-   The predecessor and successor list:  Nodes are entered in pairs, where
-   [0] ->PRED, [1]->SUCC.  All the even indexes in the array represent
-   predecessors, all the odd elements are successors.
-
-   Rationale:
-   When implemented as bitmaps, very large programs SSA->Normal times were
-   being dominated by clearing the interference graph.
-
-   Typically this list of edges is extremely small since it only includes
-   PHI results and uses from a single edge which have not coalesced with
-   each other.  This means that no virtual PHI nodes are included, and
-   empirical evidence suggests that the number of edges rarely exceed
-   3, and in a bootstrap of GCC, the maximum size encountered was 7.
-   This also limits the number of possible nodes that are involved to
-   rarely more than 6, and in the bootstrap of gcc, the maximum number
-   of nodes encountered was 12.  */
-
-typedef struct _elim_graph {
-  /* Size of the elimination vectors.  */
-  int size;
-
-  /* List of nodes in the elimination graph.  */
-  vec<int> nodes;
-
-  /*  The predecessor and successor edge list.  */
-  vec<int> edge_list;
-
-  /* Source locus on each edge */
-  vec<source_location> edge_locus;
-
-  /* Visited vector.  */
-  sbitmap visited;
-
-  /* Stack for visited nodes.  */
-  vec<int> stack;
-
-  /* The variable partition map.  */
-  var_map map;
-
-  /* Edge being eliminated by this graph.  */
-  edge e;
-
-  /* List of constant copies to emit.  These are pushed on in pairs.  */
-  vec<int> const_dests;
-  vec<tree> const_copies;
-
-  /* Source locations for any constant copies.  */
-  vec<source_location> copy_locus;
-} *elim_graph;
-
-
-/* For an edge E find out a good source location to associate with
-   instructions inserted on edge E.  If E has an implicit goto set,
-   use its location.  Otherwise search instructions in predecessors
-   of E for a location, and use that one.  That makes sense because
-   we insert on edges for PHI nodes, and effects of PHIs happen on
-   the end of the predecessor conceptually.  */
-
-static void
-set_location_for_edge (edge e)
-{
-  if (e->goto_locus)
-    {
-      set_curr_insn_location (e->goto_locus);
-    }
-  else
-    {
-      basic_block bb = e->src;
-      gimple_stmt_iterator gsi;
-
-      do
-	{
-	  for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
-	    {
-	      gimple stmt = gsi_stmt (gsi);
-	      if (is_gimple_debug (stmt))
-		continue;
-	      if (gimple_has_location (stmt) || gimple_block (stmt))
-		{
-		  set_curr_insn_location (gimple_location (stmt));
-		  return;
-		}
-	    }
-	  /* Nothing found in this basic block.  Make a half-assed attempt
-	     to continue with another block.  */
-	  if (single_pred_p (bb))
-	    bb = single_pred (bb);
-	  else
-	    bb = e->src;
-	}
-      while (bb != e->src);
-    }
-}
-
-/* Emit insns to copy SRC into DEST converting SRC if necessary.  As
-   SRC/DEST might be BLKmode memory locations SIZEEXP is a tree from
-   which we deduce the size to copy in that case.  */
-
-static inline rtx
-emit_partition_copy (rtx dest, rtx src, int unsignedsrcp, tree sizeexp)
-{
-  rtx seq;
-
-  start_sequence ();
-
-  if (GET_MODE (src) != VOIDmode && GET_MODE (src) != GET_MODE (dest))
-    src = convert_to_mode (GET_MODE (dest), src, unsignedsrcp);
-  if (GET_MODE (src) == BLKmode)
-    {
-      gcc_assert (GET_MODE (dest) == BLKmode);
-      emit_block_move (dest, src, expr_size (sizeexp), BLOCK_OP_NORMAL);
-    }
-  else
-    emit_move_insn (dest, src);
-
-  seq = get_insns ();
-  end_sequence ();
-
-  return seq;
-}
-
-/* Insert a copy instruction from partition SRC to DEST onto edge E.  */
-
-static void
-insert_partition_copy_on_edge (edge e, int dest, int src, source_location locus)
-{
-  tree var;
-  rtx seq;
-  if (dump_file && (dump_flags & TDF_DETAILS))
-    {
-      fprintf (dump_file,
-	       "Inserting a partition copy on edge BB%d->BB%d :"
-	       "PART.%d = PART.%d",
-	       e->src->index,
-	       e->dest->index, dest, src);
-      fprintf (dump_file, "\n");
-    }
-
-  gcc_assert (SA.partition_to_pseudo[dest]);
-  gcc_assert (SA.partition_to_pseudo[src]);
-
-  set_location_for_edge (e);
-  /* If a locus is provided, override the default.  */
-  if (locus)
-    set_curr_insn_location (locus);
-
-  var = partition_to_var (SA.map, src);
-  seq = emit_partition_copy (SA.partition_to_pseudo[dest],
-			     SA.partition_to_pseudo[src],
-			     TYPE_UNSIGNED (TREE_TYPE (var)),
-			     var);
-
-  insert_insn_on_edge (seq, e);
-}
-
-/* Insert a copy instruction from expression SRC to partition DEST
-   onto edge E.  */
-
-static void
-insert_value_copy_on_edge (edge e, int dest, tree src, source_location locus)
-{
-  rtx seq, x;
-  enum machine_mode dest_mode, src_mode;
-  int unsignedp;
-  tree var;
-
-  if (dump_file && (dump_flags & TDF_DETAILS))
-    {
-      fprintf (dump_file,
-	       "Inserting a value copy on edge BB%d->BB%d : PART.%d = ",
-	       e->src->index,
-	       e->dest->index, dest);
-      print_generic_expr (dump_file, src, TDF_SLIM);
-      fprintf (dump_file, "\n");
-    }
-
-  gcc_assert (SA.partition_to_pseudo[dest]);
-
-  set_location_for_edge (e);
-  /* If a locus is provided, override the default.  */
-  if (locus)
-    set_curr_insn_location (locus);
-
-  start_sequence ();
-
-  var = SSA_NAME_VAR (partition_to_var (SA.map, dest));
-  src_mode = TYPE_MODE (TREE_TYPE (src));
-  dest_mode = GET_MODE (SA.partition_to_pseudo[dest]);
-  gcc_assert (src_mode == TYPE_MODE (TREE_TYPE (var)));
-  gcc_assert (!REG_P (SA.partition_to_pseudo[dest])
-	      || dest_mode == promote_decl_mode (var, &unsignedp));
-
-  if (src_mode != dest_mode)
-    {
-      x = expand_expr (src, NULL, src_mode, EXPAND_NORMAL);
-      x = convert_modes (dest_mode, src_mode, x, unsignedp);
-    }
-  else if (src_mode == BLKmode)
-    {
-      x = SA.partition_to_pseudo[dest];
-      store_expr (src, x, 0, false);
-    }
-  else
-    x = expand_expr (src, SA.partition_to_pseudo[dest],
-		     dest_mode, EXPAND_NORMAL);
-
-  if (x != SA.partition_to_pseudo[dest])
-    emit_move_insn (SA.partition_to_pseudo[dest], x);
-  seq = get_insns ();
-  end_sequence ();
-
-  insert_insn_on_edge (seq, e);
-}
-
-/* Insert a copy instruction from RTL expression SRC to partition DEST
-   onto edge E.  */
-
-static void
-insert_rtx_to_part_on_edge (edge e, int dest, rtx src, int unsignedsrcp,
-			    source_location locus)
-{
-  rtx seq;
-  if (dump_file && (dump_flags & TDF_DETAILS))
-    {
-      fprintf (dump_file,
-	       "Inserting a temp copy on edge BB%d->BB%d : PART.%d = ",
-	       e->src->index,
-	       e->dest->index, dest);
-      print_simple_rtl (dump_file, src);
-      fprintf (dump_file, "\n");
-    }
-
-  gcc_assert (SA.partition_to_pseudo[dest]);
-
-  set_location_for_edge (e);
-  /* If a locus is provided, override the default.  */
-  if (locus)
-    set_curr_insn_location (locus);
-
-  /* We give the destination as sizeexp in case src/dest are BLKmode
-     mems.  Usually we give the source.  As we result from SSA names
-     the left and right size should be the same (and no WITH_SIZE_EXPR
-     involved), so it doesn't matter.  */
-  seq = emit_partition_copy (SA.partition_to_pseudo[dest],
-			     src, unsignedsrcp,
-			     partition_to_var (SA.map, dest));
-
-  insert_insn_on_edge (seq, e);
-}
-
-/* Insert a copy instruction from partition SRC to RTL lvalue DEST
-   onto edge E.  */
-
-static void
-insert_part_to_rtx_on_edge (edge e, rtx dest, int src, source_location locus)
-{
-  tree var;
-  rtx seq;
-  if (dump_file && (dump_flags & TDF_DETAILS))
-    {
-      fprintf (dump_file,
-	       "Inserting a temp copy on edge BB%d->BB%d : ",
-	       e->src->index,
-	       e->dest->index);
-      print_simple_rtl (dump_file, dest);
-      fprintf (dump_file, "= PART.%d\n", src);
-    }
-
-  gcc_assert (SA.partition_to_pseudo[src]);
-
-  set_location_for_edge (e);
-  /* If a locus is provided, override the default.  */
-  if (locus)
-    set_curr_insn_location (locus);
-
-  var = partition_to_var (SA.map, src);
-  seq = emit_partition_copy (dest,
-			     SA.partition_to_pseudo[src],
-			     TYPE_UNSIGNED (TREE_TYPE (var)),
-			     var);
-
-  insert_insn_on_edge (seq, e);
-}
-
-
-/* Create an elimination graph with SIZE nodes and associated data
-   structures.  */
-
-static elim_graph
-new_elim_graph (int size)
-{
-  elim_graph g = (elim_graph) xmalloc (sizeof (struct _elim_graph));
-
-  g->nodes.create (30);
-  g->const_dests.create (20);
-  g->const_copies.create (20);
-  g->copy_locus.create (10);
-  g->edge_list.create (20);
-  g->edge_locus.create (10);
-  g->stack.create (30);
-
-  g->visited = sbitmap_alloc (size);
-
-  return g;
-}
-
-
-/* Empty elimination graph G.  */
-
-static inline void
-clear_elim_graph (elim_graph g)
-{
-  g->nodes.truncate (0);
-  g->edge_list.truncate (0);
-  g->edge_locus.truncate (0);
-}
-
-
-/* Delete elimination graph G.  */
-
-static inline void
-delete_elim_graph (elim_graph g)
-{
-  sbitmap_free (g->visited);
-  g->stack.release ();
-  g->edge_list.release ();
-  g->const_copies.release ();
-  g->const_dests.release ();
-  g->nodes.release ();
-  g->copy_locus.release ();
-  g->edge_locus.release ();
-
-  free (g);
-}
-
-
-/* Return the number of nodes in graph G.  */
-
-static inline int
-elim_graph_size (elim_graph g)
-{
-  return g->nodes.length ();
-}
-
-
-/* Add NODE to graph G, if it doesn't exist already.  */
-
-static inline void
-elim_graph_add_node (elim_graph g, int node)
-{
-  int x;
-  int t;
-
-  FOR_EACH_VEC_ELT (g->nodes, x, t)
-    if (t == node)
-      return;
-  g->nodes.safe_push (node);
-}
-
-
-/* Add the edge PRED->SUCC to graph G.  */
-
-static inline void
-elim_graph_add_edge (elim_graph g, int pred, int succ, source_location locus)
-{
-  g->edge_list.safe_push (pred);
-  g->edge_list.safe_push (succ);
-  g->edge_locus.safe_push (locus);
-}
-
-
-/* Remove an edge from graph G for which NODE is the predecessor, and
-   return the successor node.  -1 is returned if there is no such edge.  */
-
-static inline int
-elim_graph_remove_succ_edge (elim_graph g, int node, source_location *locus)
-{
-  int y;
-  unsigned x;
-  for (x = 0; x < g->edge_list.length (); x += 2)
-    if (g->edge_list[x] == node)
-      {
-        g->edge_list[x] = -1;
-	y = g->edge_list[x + 1];
-	g->edge_list[x + 1] = -1;
-	*locus = g->edge_locus[x / 2];
-	g->edge_locus[x / 2] = UNKNOWN_LOCATION;
-	return y;
-      }
-  *locus = UNKNOWN_LOCATION;
-  return -1;
-}
-
-
-/* Find all the nodes in GRAPH which are successors to NODE in the
-   edge list.  VAR will hold the partition number found.  CODE is the
-   code fragment executed for every node found.  */
-
-#define FOR_EACH_ELIM_GRAPH_SUCC(GRAPH, NODE, VAR, LOCUS, CODE)		\
-do {									\
-  unsigned x_;								\
-  int y_;								\
-  for (x_ = 0; x_ < (GRAPH)->edge_list.length (); x_ += 2)	\
-    {									\
-      y_ = (GRAPH)->edge_list[x_];					\
-      if (y_ != (NODE))							\
-        continue;							\
-      (void) ((VAR) = (GRAPH)->edge_list[x_ + 1]);			\
-      (void) ((LOCUS) = (GRAPH)->edge_locus[x_ / 2]);			\
-      CODE;								\
-    }									\
-} while (0)
-
-
-/* Find all the nodes which are predecessors of NODE in the edge list for
-   GRAPH.  VAR will hold the partition number found.  CODE is the
-   code fragment executed for every node found.  */
-
-#define FOR_EACH_ELIM_GRAPH_PRED(GRAPH, NODE, VAR, LOCUS, CODE)		\
-do {									\
-  unsigned x_;								\
-  int y_;								\
-  for (x_ = 0; x_ < (GRAPH)->edge_list.length (); x_ += 2)	\
-    {									\
-      y_ = (GRAPH)->edge_list[x_ + 1];					\
-      if (y_ != (NODE))							\
-        continue;							\
-      (void) ((VAR) = (GRAPH)->edge_list[x_]);				\
-      (void) ((LOCUS) = (GRAPH)->edge_locus[x_ / 2]);			\
-      CODE;								\
-    }									\
-} while (0)
-
-
-/* Add T to elimination graph G.  */
-
-static inline void
-eliminate_name (elim_graph g, int T)
-{
-  elim_graph_add_node (g, T);
-}
-
-
-/* Build elimination graph G for basic block BB on incoming PHI edge
-   G->e.  */
-
-static void
-eliminate_build (elim_graph g)
-{
-  tree Ti;
-  int p0, pi;
-  gimple_stmt_iterator gsi;
-
-  clear_elim_graph (g);
-
-  for (gsi = gsi_start_phis (g->e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
-    {
-      gimple phi = gsi_stmt (gsi);
-      source_location locus;
-
-      p0 = var_to_partition (g->map, gimple_phi_result (phi));
-      /* Ignore results which are not in partitions.  */
-      if (p0 == NO_PARTITION)
-	continue;
-
-      Ti = PHI_ARG_DEF (phi, g->e->dest_idx);
-      locus = gimple_phi_arg_location_from_edge (phi, g->e);
-
-      /* If this argument is a constant, or a SSA_NAME which is being
-	 left in SSA form, just queue a copy to be emitted on this
-	 edge.  */
-      if (!phi_ssa_name_p (Ti)
-	  || (TREE_CODE (Ti) == SSA_NAME
-	      && var_to_partition (g->map, Ti) == NO_PARTITION))
-        {
-	  /* Save constant copies until all other copies have been emitted
-	     on this edge.  */
-	  g->const_dests.safe_push (p0);
-	  g->const_copies.safe_push (Ti);
-	  g->copy_locus.safe_push (locus);
-	}
-      else
-        {
-	  pi = var_to_partition (g->map, Ti);
-	  if (p0 != pi)
-	    {
-	      eliminate_name (g, p0);
-	      eliminate_name (g, pi);
-	      elim_graph_add_edge (g, p0, pi, locus);
-	    }
-	}
-    }
-}
-
-
-/* Push successors of T onto the elimination stack for G.  */
-
-static void
-elim_forward (elim_graph g, int T)
-{
-  int S;
-  source_location locus;
-
-  bitmap_set_bit (g->visited, T);
-  FOR_EACH_ELIM_GRAPH_SUCC (g, T, S, locus,
-    {
-      if (!bitmap_bit_p (g->visited, S))
-        elim_forward (g, S);
-    });
-  g->stack.safe_push (T);
-}
-
-
-/* Return 1 if there unvisited predecessors of T in graph G.  */
-
-static int
-elim_unvisited_predecessor (elim_graph g, int T)
-{
-  int P;
-  source_location locus;
-
-  FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
-    {
-      if (!bitmap_bit_p (g->visited, P))
-        return 1;
-    });
-  return 0;
-}
-
-/* Process predecessors first, and insert a copy.  */
-
-static void
-elim_backward (elim_graph g, int T)
-{
-  int P;
-  source_location locus;
-
-  bitmap_set_bit (g->visited, T);
-  FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
-    {
-      if (!bitmap_bit_p (g->visited, P))
-        {
-	  elim_backward (g, P);
-	  insert_partition_copy_on_edge (g->e, P, T, locus);
-	}
-    });
-}
-
-/* Allocate a new pseudo register usable for storing values sitting
-   in NAME (a decl or SSA name), i.e. with matching mode and attributes.  */
-
-static rtx
-get_temp_reg (tree name)
-{
-  tree var = TREE_CODE (name) == SSA_NAME ? SSA_NAME_VAR (name) : name;
-  tree type = TREE_TYPE (var);
-  int unsignedp;
-  enum machine_mode reg_mode = promote_decl_mode (var, &unsignedp);
-  rtx x = gen_reg_rtx (reg_mode);
-  if (POINTER_TYPE_P (type))
-    mark_reg_pointer (x, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (var))));
-  return x;
-}
-
-/* Insert required copies for T in graph G.  Check for a strongly connected
-   region, and create a temporary to break the cycle if one is found.  */
-
-static void
-elim_create (elim_graph g, int T)
-{
-  int P, S;
-  source_location locus;
-
-  if (elim_unvisited_predecessor (g, T))
-    {
-      tree var = partition_to_var (g->map, T);
-      rtx U = get_temp_reg (var);
-      int unsignedsrcp = TYPE_UNSIGNED (TREE_TYPE (var));
-
-      insert_part_to_rtx_on_edge (g->e, U, T, UNKNOWN_LOCATION);
-      FOR_EACH_ELIM_GRAPH_PRED (g, T, P, locus,
-	{
-	  if (!bitmap_bit_p (g->visited, P))
-	    {
-	      elim_backward (g, P);
-	      insert_rtx_to_part_on_edge (g->e, P, U, unsignedsrcp, locus);
-	    }
-	});
-    }
-  else
-    {
-      S = elim_graph_remove_succ_edge (g, T, &locus);
-      if (S != -1)
-	{
-	  bitmap_set_bit (g->visited, T);
-	  insert_partition_copy_on_edge (g->e, T, S, locus);
-	}
-    }
-}
-
-
-/* Eliminate all the phi nodes on edge E in graph G.  */
-
-static void
-eliminate_phi (edge e, elim_graph g)
-{
-  int x;
-
-  gcc_assert (g->const_copies.length () == 0);
-  gcc_assert (g->copy_locus.length () == 0);
-
-  /* Abnormal edges already have everything coalesced.  */
-  if (e->flags & EDGE_ABNORMAL)
-    return;
-
-  g->e = e;
-
-  eliminate_build (g);
-
-  if (elim_graph_size (g) != 0)
-    {
-      int part;
-
-      bitmap_clear (g->visited);
-      g->stack.truncate (0);
-
-      FOR_EACH_VEC_ELT (g->nodes, x, part)
-        {
-	  if (!bitmap_bit_p (g->visited, part))
-	    elim_forward (g, part);
-	}
-
-      bitmap_clear (g->visited);
-      while (g->stack.length () > 0)
-	{
-	  x = g->stack.pop ();
-	  if (!bitmap_bit_p (g->visited, x))
-	    elim_create (g, x);
-	}
-    }
-
-  /* If there are any pending constant copies, issue them now.  */
-  while (g->const_copies.length () > 0)
-    {
-      int dest;
-      tree src;
-      source_location locus;
-
-      src = g->const_copies.pop ();
-      dest = g->const_dests.pop ();
-      locus = g->copy_locus.pop ();
-      insert_value_copy_on_edge (e, dest, src, locus);
-    }
-}
-
-
-/* Remove each argument from PHI.  If an arg was the last use of an SSA_NAME,
-   check to see if this allows another PHI node to be removed.  */
-
-static void
-remove_gimple_phi_args (gimple phi)
-{
-  use_operand_p arg_p;
-  ssa_op_iter iter;
-
-  if (dump_file && (dump_flags & TDF_DETAILS))
-    {
-      fprintf (dump_file, "Removing Dead PHI definition: ");
-      print_gimple_stmt (dump_file, phi, 0, TDF_SLIM);
-    }
-
-  FOR_EACH_PHI_ARG (arg_p, phi, iter, SSA_OP_USE)
-    {
-      tree arg = USE_FROM_PTR (arg_p);
-      if (TREE_CODE (arg) == SSA_NAME)
-        {
-	  /* Remove the reference to the existing argument.  */
-	  SET_USE (arg_p, NULL_TREE);
-	  if (has_zero_uses (arg))
-	    {
-	      gimple stmt;
-	      gimple_stmt_iterator gsi;
-
-	      stmt = SSA_NAME_DEF_STMT (arg);
-
-	      /* Also remove the def if it is a PHI node.  */
-	      if (gimple_code (stmt) == GIMPLE_PHI)
-		{
-		  remove_gimple_phi_args (stmt);
-		  gsi = gsi_for_stmt (stmt);
-		  remove_phi_node (&gsi, true);
-		}
-
-	    }
-	}
-    }
-}
-
-/* Remove any PHI node which is a virtual PHI, or a PHI with no uses.  */
-
-static void
-eliminate_useless_phis (void)
-{
-  basic_block bb;
-  gimple_stmt_iterator gsi;
-  tree result;
-
-  FOR_EACH_BB (bb)
-    {
-      for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); )
-        {
-	  gimple phi = gsi_stmt (gsi);
-	  result = gimple_phi_result (phi);
-	  if (virtual_operand_p (result))
-	    {
-#ifdef ENABLE_CHECKING
-	      size_t i;
-	      /* There should be no arguments which are not virtual, or the
-	         results will be incorrect.  */
-	      for (i = 0; i < gimple_phi_num_args (phi); i++)
-	        {
-		  tree arg = PHI_ARG_DEF (phi, i);
-		  if (TREE_CODE (arg) == SSA_NAME
-		      && !virtual_operand_p (arg))
-		    {
-		      fprintf (stderr, "Argument of PHI is not virtual (");
-		      print_generic_expr (stderr, arg, TDF_SLIM);
-		      fprintf (stderr, "), but the result is :");
-		      print_gimple_stmt (stderr, phi, 0, TDF_SLIM);
-		      internal_error ("SSA corruption");
-		    }
-		}
-#endif
-	      remove_phi_node (&gsi, true);
-	    }
-          else
-	    {
-	      /* Also remove real PHIs with no uses.  */
-	      if (has_zero_uses (result))
-	        {
-		  remove_gimple_phi_args (phi);
-		  remove_phi_node (&gsi, true);
-		}
-	      else
-		gsi_next (&gsi);
-	    }
-	}
-    }
-}
-
-
-/* This function will rewrite the current program using the variable mapping
-   found in MAP.  If the replacement vector VALUES is provided, any
-   occurrences of partitions with non-null entries in the vector will be
-   replaced with the expression in the vector instead of its mapped
-   variable.  */
-
-static void
-rewrite_trees (var_map map ATTRIBUTE_UNUSED)
-{
-#ifdef ENABLE_CHECKING
-  basic_block bb;
-  /* Search for PHIs where the destination has no partition, but one
-     or more arguments has a partition.  This should not happen and can
-     create incorrect code.  */
-  FOR_EACH_BB (bb)
-    {
-      gimple_stmt_iterator gsi;
-      for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-	{
-	  gimple phi = gsi_stmt (gsi);
-	  tree T0 = var_to_partition_to_var (map, gimple_phi_result (phi));
-	  if (T0 == NULL_TREE)
-	    {
-	      size_t i;
-	      for (i = 0; i < gimple_phi_num_args (phi); i++)
-		{
-		  tree arg = PHI_ARG_DEF (phi, i);
-
-		  if (TREE_CODE (arg) == SSA_NAME
-		      && var_to_partition (map, arg) != NO_PARTITION)
-		    {
-		      fprintf (stderr, "Argument of PHI is in a partition :(");
-		      print_generic_expr (stderr, arg, TDF_SLIM);
-		      fprintf (stderr, "), but the result is not :");
-		      print_gimple_stmt (stderr, phi, 0, TDF_SLIM);
-		      internal_error ("SSA corruption");
-		    }
-		}
-	    }
-	}
-    }
-#endif
-}
-
-/* Given the out-of-ssa info object SA (with prepared partitions)
-   eliminate all phi nodes in all basic blocks.  Afterwards no
-   basic block will have phi nodes anymore and there are possibly
-   some RTL instructions inserted on edges.  */
-
-void
-expand_phi_nodes (struct ssaexpand *sa)
-{
-  basic_block bb;
-  elim_graph g = new_elim_graph (sa->map->num_partitions);
-  g->map = sa->map;
-
-  FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR->next_bb, EXIT_BLOCK_PTR, next_bb)
-    if (!gimple_seq_empty_p (phi_nodes (bb)))
-      {
-	edge e;
-	edge_iterator ei;
-	FOR_EACH_EDGE (e, ei, bb->preds)
-	  eliminate_phi (e, g);
-	set_phi_nodes (bb, NULL);
-	/* We can't redirect EH edges in RTL land, so we need to do this
-	   here.  Redirection happens only when splitting is necessary,
-	   which it is only for critical edges, normally.  For EH edges
-	   it might also be necessary when the successor has more than
-	   one predecessor.  In that case the edge is either required to
-	   be fallthru (which EH edges aren't), or the predecessor needs
-	   to end with a jump (which again, isn't the case with EH edges).
-	   Hence, split all EH edges on which we inserted instructions
-	   and whose successor has multiple predecessors.  */
-	for (ei = ei_start (bb->preds); (e = ei_safe_edge (ei)); )
-	  {
-	    if (e->insns.r && (e->flags & EDGE_EH)
-		&& !single_pred_p (e->dest))
-	      {
-		rtx insns = e->insns.r;
-		basic_block bb;
-		e->insns.r = NULL_RTX;
-		bb = split_edge (e);
-		single_pred_edge (bb)->insns.r = insns;
-	      }
-	    else
-	      ei_next (&ei);
-	  }
-      }
-
-  delete_elim_graph (g);
-}
-
-
-/* Remove the ssa-names in the current function and translate them into normal
-   compiler variables.  PERFORM_TER is true if Temporary Expression Replacement
-   should also be used.  */
-
-static void
-remove_ssa_form (bool perform_ter, struct ssaexpand *sa)
-{
-  bitmap values = NULL;
-  var_map map;
-  unsigned i;
-
-  map = coalesce_ssa_name ();
-
-  /* Return to viewing the variable list as just all reference variables after
-     coalescing has been performed.  */
-  partition_view_normal (map, false);
-
-  if (dump_file && (dump_flags & TDF_DETAILS))
-    {
-      fprintf (dump_file, "After Coalescing:\n");
-      dump_var_map (dump_file, map);
-    }
-
-  if (perform_ter)
-    {
-      values = find_replaceable_exprs (map);
-      if (values && dump_file && (dump_flags & TDF_DETAILS))
-	dump_replaceable_exprs (dump_file, values);
-    }
-
-  rewrite_trees (map);
-
-  sa->map = map;
-  sa->values = values;
-  sa->partition_has_default_def = BITMAP_ALLOC (NULL);
-  for (i = 1; i < num_ssa_names; i++)
-    {
-      tree t = ssa_name (i);
-      if (t && SSA_NAME_IS_DEFAULT_DEF (t))
-	{
-	  int p = var_to_partition (map, t);
-	  if (p != NO_PARTITION)
-	    bitmap_set_bit (sa->partition_has_default_def, p);
-	}
-    }
-}
-
-
-/* If not already done so for basic block BB, assign increasing uids
-   to each of its instructions.  */
-
-static void
-maybe_renumber_stmts_bb (basic_block bb)
-{
-  unsigned i = 0;
-  gimple_stmt_iterator gsi;
-
-  if (!bb->aux)
-    return;
-  bb->aux = NULL;
-  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-    {
-      gimple stmt = gsi_stmt (gsi);
-      gimple_set_uid (stmt, i);
-      i++;
-    }
-}
-
-
-/* Return true if we can determine that the SSA_NAMEs RESULT (a result
-   of a PHI node) and ARG (one of its arguments) conflict.  Return false
-   otherwise, also when we simply aren't sure.  */
-
-static bool
-trivially_conflicts_p (basic_block bb, tree result, tree arg)
-{
-  use_operand_p use;
-  imm_use_iterator imm_iter;
-  gimple defa = SSA_NAME_DEF_STMT (arg);
-
-  /* If ARG isn't defined in the same block it's too complicated for
-     our little mind.  */
-  if (gimple_bb (defa) != bb)
-    return false;
-
-  FOR_EACH_IMM_USE_FAST (use, imm_iter, result)
-    {
-      gimple use_stmt = USE_STMT (use);
-      if (is_gimple_debug (use_stmt))
-	continue;
-      /* Now, if there's a use of RESULT that lies outside this basic block,
-	 then there surely is a conflict with ARG.  */
-      if (gimple_bb (use_stmt) != bb)
-	return true;
-      if (gimple_code (use_stmt) == GIMPLE_PHI)
-	continue;
-      /* The use now is in a real stmt of BB, so if ARG was defined
-         in a PHI node (like RESULT) both conflict.  */
-      if (gimple_code (defa) == GIMPLE_PHI)
-	return true;
-      maybe_renumber_stmts_bb (bb);
-      /* If the use of RESULT occurs after the definition of ARG,
-         the two conflict too.  */
-      if (gimple_uid (defa) < gimple_uid (use_stmt))
-	return true;
-    }
-
-  return false;
-}
-
-
-/* Search every PHI node for arguments associated with backedges which
-   we can trivially determine will need a copy (the argument is either
-   not an SSA_NAME or the argument has a different underlying variable
-   than the PHI result).
-
-   Insert a copy from the PHI argument to a new destination at the
-   end of the block with the backedge to the top of the loop.  Update
-   the PHI argument to reference this new destination.  */
-
-static void
-insert_backedge_copies (void)
-{
-  basic_block bb;
-  gimple_stmt_iterator gsi;
-
-  mark_dfs_back_edges ();
-
-  FOR_EACH_BB (bb)
-    {
-      /* Mark block as possibly needing calculation of UIDs.  */
-      bb->aux = &bb->aux;
-
-      for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
-	{
-	  gimple phi = gsi_stmt (gsi);
-	  tree result = gimple_phi_result (phi);
-	  size_t i;
-
-	  if (virtual_operand_p (result))
-	    continue;
-
-	  for (i = 0; i < gimple_phi_num_args (phi); i++)
-	    {
-	      tree arg = gimple_phi_arg_def (phi, i);
-	      edge e = gimple_phi_arg_edge (phi, i);
-
-	      /* If the argument is not an SSA_NAME, then we will need a
-		 constant initialization.  If the argument is an SSA_NAME with
-		 a different underlying variable then a copy statement will be
-		 needed.  */
-	      if ((e->flags & EDGE_DFS_BACK)
-		  && (TREE_CODE (arg) != SSA_NAME
-		      || SSA_NAME_VAR (arg) != SSA_NAME_VAR (result)
-		      || trivially_conflicts_p (bb, result, arg)))
-		{
-		  tree name;
-		  gimple stmt, last = NULL;
-		  gimple_stmt_iterator gsi2;
-
-		  gsi2 = gsi_last_bb (gimple_phi_arg_edge (phi, i)->src);
-		  if (!gsi_end_p (gsi2))
-		    last = gsi_stmt (gsi2);
-
-		  /* In theory the only way we ought to get back to the
-		     start of a loop should be with a COND_EXPR or GOTO_EXPR.
-		     However, better safe than sorry.
-		     If the block ends with a control statement or
-		     something that might throw, then we have to
-		     insert this assignment before the last
-		     statement.  Else insert it after the last statement.  */
-		  if (last && stmt_ends_bb_p (last))
-		    {
-		      /* If the last statement in the block is the definition
-			 site of the PHI argument, then we can't insert
-			 anything after it.  */
-		      if (TREE_CODE (arg) == SSA_NAME
-			  && SSA_NAME_DEF_STMT (arg) == last)
-			continue;
-		    }
-
-		  /* Create a new instance of the underlying variable of the
-		     PHI result.  */
-		  name = copy_ssa_name (result, NULL);
-		  stmt = gimple_build_assign (name,
-					      gimple_phi_arg_def (phi, i));
-
-		  /* copy location if present.  */
-		  if (gimple_phi_arg_has_location (phi, i))
-		    gimple_set_location (stmt,
-					 gimple_phi_arg_location (phi, i));
-
-		  /* Insert the new statement into the block and update
-		     the PHI node.  */
-		  if (last && stmt_ends_bb_p (last))
-		    gsi_insert_before (&gsi2, stmt, GSI_NEW_STMT);
-		  else
-		    gsi_insert_after (&gsi2, stmt, GSI_NEW_STMT);
-		  SET_PHI_ARG_DEF (phi, i, name);
-		}
-	    }
-	}
-
-      /* Unmark this block again.  */
-      bb->aux = NULL;
-    }
-}
-
-/* Free all memory associated with going out of SSA form.  SA is
-   the outof-SSA info object.  */
-
-void
-finish_out_of_ssa (struct ssaexpand *sa)
-{
-  free (sa->partition_to_pseudo);
-  if (sa->values)
-    BITMAP_FREE (sa->values);
-  delete_var_map (sa->map);
-  BITMAP_FREE (sa->partition_has_default_def);
-  memset (sa, 0, sizeof *sa);
-}
-
-/* Take the current function out of SSA form, translating PHIs as described in
-   R. Morgan, ``Building an Optimizing Compiler'',
-   Butterworth-Heinemann, Boston, MA, 1998. pp 176-186.  */
-
-unsigned int
-rewrite_out_of_ssa (struct ssaexpand *sa)
-{
-  /* If elimination of a PHI requires inserting a copy on a backedge,
-     then we will have to split the backedge which has numerous
-     undesirable performance effects.
-
-     A significant number of such cases can be handled here by inserting
-     copies into the loop itself.  */
-  insert_backedge_copies ();
-
-
-  /* Eliminate PHIs which are of no use, such as virtual or dead phis.  */
-  eliminate_useless_phis ();
-
-  if (dump_file && (dump_flags & TDF_DETAILS))
-    gimple_dump_cfg (dump_file, dump_flags & ~TDF_DETAILS);
-
-  remove_ssa_form (flag_tree_ter, sa);
-
-  if (dump_file && (dump_flags & TDF_DETAILS))
-    gimple_dump_cfg (dump_file, dump_flags & ~TDF_DETAILS);
-
-  return 0;
-}