OSDN Git Service

2007-08-04 Andrew Pinski <andrew_pinski@playstation.sony.com>
[pf3gnuchains/gcc-fork.git] / gcc / tree-complex.c
index 21e9245..ea0eafc 100644 (file)
@@ -1,11 +1,11 @@
 /* Lower complex number operations to scalar operations.
 /* Lower complex number operations to scalar operations.
-   Copyright (C) 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2004, 2005, 2006, 2007 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
 
 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
+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
 later version.
    
 GCC is distributed in the hope that it will be useful, but WITHOUT
@@ -14,9 +14,8 @@ 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
 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, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
 
 #include "config.h"
 #include "system.h"
 
 #include "config.h"
 #include "system.h"
@@ -31,6 +30,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #include "tree-iterator.h"
 #include "tree-pass.h"
 #include "tree-ssa-propagate.h"
 #include "tree-iterator.h"
 #include "tree-pass.h"
 #include "tree-ssa-propagate.h"
+#include "diagnostic.h"
 
 
 /* For each complex ssa name, a lattice value.  We're interested in finding
 
 
 /* For each complex ssa name, a lattice value.  We're interested in finding
@@ -56,6 +56,9 @@ static VEC(complex_lattice_t, heap) *complex_lattice_values;
    the hashtable.  */
 static htab_t complex_variable_components;
 
    the hashtable.  */
 static htab_t complex_variable_components;
 
+/* For each complex SSA_NAME, a pair of ssa names for the components.  */
+static VEC(tree, heap) *complex_ssa_name_components;
+
 /* Lookup UID in the complex_variable_components hashtable and return the
    associated tree.  */
 static tree 
 /* Lookup UID in the complex_variable_components hashtable and return the
    associated tree.  */
 static tree 
@@ -64,8 +67,7 @@ cvc_lookup (unsigned int uid)
   struct int_tree_map *h, in;
   in.uid = uid;
   h = htab_find_with_hash (complex_variable_components, &in, uid);
   struct int_tree_map *h, in;
   in.uid = uid;
   h = htab_find_with_hash (complex_variable_components, &in, uid);
-  gcc_assert (h);
-  return h->to;
+  return h ? h->to : NULL;
 }
  
 /* Insert the pair UID, TO into the complex_variable_components hashtable.  */
 }
  
 /* Insert the pair UID, TO into the complex_variable_components hashtable.  */
@@ -76,15 +78,14 @@ cvc_insert (unsigned int uid, tree to)
   struct int_tree_map *h;
   void **loc;
 
   struct int_tree_map *h;
   void **loc;
 
-  h = xmalloc (sizeof (struct int_tree_map));
+  h = XNEW (struct int_tree_map);
   h->uid = uid;
   h->to = to;
   loc = htab_find_slot_with_hash (complex_variable_components, h,
                                  uid, INSERT);
   h->uid = uid;
   h->to = to;
   loc = htab_find_slot_with_hash (complex_variable_components, h,
                                  uid, INSERT);
-  *(struct int_tree_map **)  loc = h;
+  *(struct int_tree_map **) loc = h;
 }
 
 }
 
-
 /* Return true if T is not a zero constant.  In the case of real values,
    we're only interested in +0.0.  */
 
 /* Return true if T is not a zero constant.  In the case of real values,
    we're only interested in +0.0.  */
 
@@ -163,7 +164,7 @@ init_parameter_lattice_values (void)
   for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = TREE_CHAIN (parm))
     if (is_complex_reg (parm) && var_ann (parm) != NULL)
       {
   for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = TREE_CHAIN (parm))
     if (is_complex_reg (parm) && var_ann (parm) != NULL)
       {
-       tree ssa_name = default_def (parm);
+       tree ssa_name = gimple_default_def (cfun, parm);
        VEC_replace (complex_lattice_t, complex_lattice_values,
                     SSA_NAME_VERSION (ssa_name), VARYING);
       }
        VEC_replace (complex_lattice_t, complex_lattice_values,
                     SSA_NAME_VERSION (ssa_name), VARYING);
       }
@@ -204,13 +205,13 @@ init_dont_simulate_again (void)
                 since it's never used as an input to another computation.  */
              dsa = true;
              stmt = TREE_OPERAND (stmt, 0);
                 since it's never used as an input to another computation.  */
              dsa = true;
              stmt = TREE_OPERAND (stmt, 0);
-             if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
+             if (!stmt || TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
                break;
              /* FALLTHRU */
 
                break;
              /* FALLTHRU */
 
-           case MODIFY_EXPR:
-             dsa = !is_complex_reg (TREE_OPERAND (stmt, 0));
-             rhs = TREE_OPERAND (stmt, 1);
+           case GIMPLE_MODIFY_STMT:
+             dsa = !is_complex_reg (GIMPLE_STMT_OPERAND (stmt, 0));
+             rhs = GIMPLE_STMT_OPERAND (stmt, 1);
              break;
 
            case COND_EXPR:
              break;
 
            case COND_EXPR:
@@ -265,11 +266,11 @@ complex_visit_stmt (tree stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
   unsigned int ver;
   tree lhs, rhs;
 
   unsigned int ver;
   tree lhs, rhs;
 
-  if (TREE_CODE (stmt) != MODIFY_EXPR)
+  if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
     return SSA_PROP_VARYING;
 
     return SSA_PROP_VARYING;
 
-  lhs = TREE_OPERAND (stmt, 0);
-  rhs = TREE_OPERAND (stmt, 1);
+  lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+  rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 
   /* These conditions should be satisfied due to the initial filter
      set up in init_dont_simulate_again.  */
 
   /* These conditions should be satisfied due to the initial filter
      set up in init_dont_simulate_again.  */
@@ -378,70 +379,165 @@ complex_visit_phi (tree phi)
   return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
 }
 
   return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
 }
 
-/* For each referenced complex gimple register, set up a pair of registers
-   to hold the components of the complex value.  */
+/* Create one backing variable for a complex component of ORIG.  */
 
 
-static void
-create_components (void)
+static tree
+create_one_component_var (tree type, tree orig, const char *prefix,
+                         const char *suffix, enum tree_code code)
 {
 {
-  size_t n;
-  tree var;
-  referenced_var_iterator rvi;
+  tree r = create_tmp_var (type, prefix);
+  add_referenced_var (r);
 
 
-  n = num_referenced_vars;
-  if (n == 0)
-    return;
+  DECL_SOURCE_LOCATION (r) = DECL_SOURCE_LOCATION (orig);
+  DECL_ARTIFICIAL (r) = 1;
 
 
-  complex_variable_components = htab_create (10,  int_tree_map_hash,
-                                            int_tree_map_eq, free);
+  if (DECL_NAME (orig) && !DECL_IGNORED_P (orig))
+    {
+      const char *name = IDENTIFIER_POINTER (DECL_NAME (orig));
+      tree inner_type;
+
+      DECL_NAME (r) = get_identifier (ACONCAT ((name, suffix, NULL)));
 
 
-  FOR_EACH_REFERENCED_VAR (var, rvi)
+      inner_type = TREE_TYPE (TREE_TYPE (orig));
+      SET_DECL_DEBUG_EXPR (r, build1 (code, type, orig));
+      DECL_DEBUG_EXPR_IS_FROM (r) = 1;
+      DECL_IGNORED_P (r) = 0;
+      TREE_NO_WARNING (r) = TREE_NO_WARNING (orig);
+    }
+  else
     {
     {
-      tree r = NULL, i = NULL;
+      DECL_IGNORED_P (r) = 1;
+      TREE_NO_WARNING (r) = 1;
+    }
 
 
-      if (var != NULL
-         && TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
-         && is_gimple_reg (var))
-       {
-         tree inner_type = TREE_TYPE (TREE_TYPE (var));
+  return r;
+}
 
 
-         r = make_rename_temp (inner_type, "CR");
-         i = make_rename_temp (inner_type, "CI");
-         DECL_SOURCE_LOCATION (r) = DECL_SOURCE_LOCATION (var);
-         DECL_SOURCE_LOCATION (i) = DECL_SOURCE_LOCATION (var);
-         DECL_ARTIFICIAL (r) = 1;
-         DECL_ARTIFICIAL (i) = 1;
+/* Retrieve a value for a complex component of VAR.  */
 
 
-         if (DECL_NAME (var) && !DECL_IGNORED_P (var))
-           {
-             const char *name = IDENTIFIER_POINTER (DECL_NAME (var));
+static tree
+get_component_var (tree var, bool imag_p)
+{
+  size_t decl_index = DECL_UID (var) * 2 + imag_p;
+  tree ret = cvc_lookup (decl_index);
 
 
-             DECL_NAME (r) = get_identifier (ACONCAT ((name, "$real", NULL)));
-             DECL_NAME (i) = get_identifier (ACONCAT ((name, "$imag", NULL)));
+  if (ret == NULL)
+    {
+      ret = create_one_component_var (TREE_TYPE (TREE_TYPE (var)), var,
+                                     imag_p ? "CI" : "CR",
+                                     imag_p ? "$imag" : "$real",
+                                     imag_p ? IMAGPART_EXPR : REALPART_EXPR);
+      cvc_insert (decl_index, ret);
+    }
 
 
-             SET_DECL_DEBUG_EXPR (r, build1 (REALPART_EXPR, inner_type, var));
-             SET_DECL_DEBUG_EXPR (i, build1 (IMAGPART_EXPR, inner_type, var));
-             DECL_DEBUG_EXPR_IS_FROM (r) = 1;
-             DECL_DEBUG_EXPR_IS_FROM (i) = 1;
+  return ret;
+}
 
 
-             DECL_IGNORED_P (r) = 0;
-             DECL_IGNORED_P (i) = 0;
+/* Retrieve a value for a complex component of SSA_NAME.  */
 
 
-             TREE_NO_WARNING (r) = TREE_NO_WARNING (var);
-             TREE_NO_WARNING (i) = TREE_NO_WARNING (var);
-           }
-         else
-           {
-             DECL_IGNORED_P (r) = 1;
-             DECL_IGNORED_P (i) = 1;
-             TREE_NO_WARNING (r) = 1;
-             TREE_NO_WARNING (i) = 1;
-           }
+static tree
+get_component_ssa_name (tree ssa_name, bool imag_p)
+{
+  complex_lattice_t lattice = find_lattice_value (ssa_name);
+  size_t ssa_name_index;
+  tree ret;
+
+  if (lattice == (imag_p ? ONLY_REAL : ONLY_IMAG))
+    {
+      tree inner_type = TREE_TYPE (TREE_TYPE (ssa_name));
+      if (SCALAR_FLOAT_TYPE_P (inner_type))
+       return build_real (inner_type, dconst0);
+      else
+       return build_int_cst (inner_type, 0);
+    }
+
+  ssa_name_index = SSA_NAME_VERSION (ssa_name) * 2 + imag_p;
+  ret = VEC_index (tree, complex_ssa_name_components, ssa_name_index);
+  if (ret == NULL)
+    {
+      ret = get_component_var (SSA_NAME_VAR (ssa_name), imag_p);
+      ret = make_ssa_name (ret, NULL);
+
+      /* Copy some properties from the original.  In particular, whether it
+        is used in an abnormal phi, and whether it's uninitialized.  */
+      SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ret)
+       = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name);
+      if (TREE_CODE (SSA_NAME_VAR (ssa_name)) == VAR_DECL
+         && IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name)))
+       {
+         SSA_NAME_DEF_STMT (ret) = SSA_NAME_DEF_STMT (ssa_name);
+         set_default_def (SSA_NAME_VAR (ret), ret);
+       }
+
+      VEC_replace (tree, complex_ssa_name_components, ssa_name_index, ret);
+    }
+
+  return ret;
+}
+
+/* Set a value for a complex component of SSA_NAME, return a STMT_LIST of
+   stuff that needs doing.  */
+
+static tree
+set_component_ssa_name (tree ssa_name, bool imag_p, tree value)
+{
+  complex_lattice_t lattice = find_lattice_value (ssa_name);
+  size_t ssa_name_index;
+  tree comp, list, last;
+
+  /* We know the value must be zero, else there's a bug in our lattice
+     analysis.  But the value may well be a variable known to contain
+     zero.  We should be safe ignoring it.  */
+  if (lattice == (imag_p ? ONLY_REAL : ONLY_IMAG))
+    return NULL;
+
+  /* If we've already assigned an SSA_NAME to this component, then this
+     means that our walk of the basic blocks found a use before the set.
+     This is fine.  Now we should create an initialization for the value
+     we created earlier.  */
+  ssa_name_index = SSA_NAME_VERSION (ssa_name) * 2 + imag_p;
+  comp = VEC_index (tree, complex_ssa_name_components, ssa_name_index);
+  if (comp)
+    ;
+
+  /* If we've nothing assigned, and the value we're given is already stable,
+     then install that as the value for this SSA_NAME.  This preemptively
+     copy-propagates the value, which avoids unnecessary memory allocation.  */
+  else if (is_gimple_min_invariant (value))
+    {
+      VEC_replace (tree, complex_ssa_name_components, ssa_name_index, value);
+      return NULL;
+    }
+  else if (TREE_CODE (value) == SSA_NAME
+          && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
+    {
+      /* Replace an anonymous base value with the variable from cvc_lookup.
+        This should result in better debug info.  */
+      if (DECL_IGNORED_P (SSA_NAME_VAR (value))
+         && !DECL_IGNORED_P (SSA_NAME_VAR (ssa_name)))
+       {
+         comp = get_component_var (SSA_NAME_VAR (ssa_name), imag_p);
+         replace_ssa_name_symbol (value, comp);
        }
 
        }
 
-      cvc_insert (2 * DECL_UID (var), r);
-      cvc_insert (2 * DECL_UID (var) + 1, i);
+      VEC_replace (tree, complex_ssa_name_components, ssa_name_index, value);
+      return NULL;
     }
     }
+
+  /* Finally, we need to stabilize the result by installing the value into
+     a new ssa name.  */
+  else
+    comp = get_component_ssa_name (ssa_name, imag_p);
+  
+  /* Do all the work to assign VALUE to COMP.  */
+  value = force_gimple_operand (value, &list, false, NULL);
+  last = build_gimple_modify_stmt (comp, value);
+  append_to_statement_list (last, &list);
+
+  gcc_assert (SSA_NAME_DEF_STMT (comp) == NULL);
+  SSA_NAME_DEF_STMT (comp) = last;
+
+  return list;
 }
 
 /* Extract the real or imaginary part of a complex variable or constant.
 }
 
 /* Extract the real or imaginary part of a complex variable or constant.
@@ -461,6 +557,7 @@ extract_component (block_stmt_iterator *bsi, tree t, bool imagpart_p,
       return TREE_OPERAND (t, imagpart_p);
 
     case VAR_DECL:
       return TREE_OPERAND (t, imagpart_p);
 
     case VAR_DECL:
+    case RESULT_DECL:
     case PARM_DECL:
     case INDIRECT_REF:
     case COMPONENT_REF:
     case PARM_DECL:
     case INDIRECT_REF:
     case COMPONENT_REF:
@@ -478,24 +575,7 @@ extract_component (block_stmt_iterator *bsi, tree t, bool imagpart_p,
       }
 
     case SSA_NAME:
       }
 
     case SSA_NAME:
-      {
-       tree def = SSA_NAME_DEF_STMT (t);
-
-       if (TREE_CODE (def) == MODIFY_EXPR)
-         {
-           def = TREE_OPERAND (def, 1);
-           if (TREE_CODE (def) == COMPLEX_CST)
-             return imagpart_p ? TREE_IMAGPART (def) : TREE_REALPART (def);
-           if (TREE_CODE (def) == COMPLEX_EXPR)
-             {
-               def = TREE_OPERAND (def, imagpart_p);
-               if (TREE_CONSTANT (def))
-                 return def;
-             }
-         }
-
-       return cvc_lookup (DECL_UID (SSA_NAME_VAR (t)) * 2 + imagpart_p);
-      }
+      return get_component_ssa_name (t, imagpart_p);
 
     default:
       gcc_unreachable ();
 
     default:
       gcc_unreachable ();
@@ -507,45 +587,30 @@ extract_component (block_stmt_iterator *bsi, tree t, bool imagpart_p,
 static void
 update_complex_components (block_stmt_iterator *bsi, tree stmt, tree r, tree i)
 {
 static void
 update_complex_components (block_stmt_iterator *bsi, tree stmt, tree r, tree i)
 {
-  unsigned int uid = DECL_UID (SSA_NAME_VAR (TREE_OPERAND (stmt, 0)));
-  tree v, x;
-
-  v = cvc_lookup (2*uid);
-  x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, r);
-  SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
-  TREE_BLOCK (x) = TREE_BLOCK (stmt);
-  bsi_insert_after (bsi, x, BSI_NEW_STMT);
-
-  v = cvc_lookup (2*uid + 1);
-  x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, i);
-  SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
-  TREE_BLOCK (x) = TREE_BLOCK (stmt);
-  bsi_insert_after (bsi, x, BSI_NEW_STMT);
+  tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+  tree list;
+
+  list = set_component_ssa_name (lhs, false, r);
+  if (list)
+    bsi_insert_after (bsi, list, BSI_CONTINUE_LINKING);
+
+  list = set_component_ssa_name (lhs, true, i);
+  if (list)
+    bsi_insert_after (bsi, list, BSI_CONTINUE_LINKING);
 }
 
 static void
 }
 
 static void
-update_complex_components_on_edge (edge e, tree stmt, tree lhs, tree r, tree i)
+update_complex_components_on_edge (edge e, tree lhs, tree r, tree i)
 {
 {
-  unsigned int uid = DECL_UID (SSA_NAME_VAR (lhs));
-  tree v, x;
+  tree list;
 
 
-  v = cvc_lookup (2*uid);
-  x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, r);
-  if (stmt)
-    {
-      SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
-      TREE_BLOCK (x) = TREE_BLOCK (stmt);
-    }
-  bsi_insert_on_edge (e, x);
+  list = set_component_ssa_name (lhs, false, r);
+  if (list)
+    bsi_insert_on_edge (e, list);
 
 
-  v = cvc_lookup (2*uid + 1);
-  x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, i);
-  if (stmt)
-    {
-      SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
-      TREE_BLOCK (x) = TREE_BLOCK (stmt);
-    }
-  bsi_insert_on_edge (e, x);
+  list = set_component_ssa_name (lhs, true, i);
+  if (list)
+    bsi_insert_on_edge (e, list);
 }
 
 /* Update an assignment to a complex variable in place.  */
 }
 
 /* Update an assignment to a complex variable in place.  */
@@ -559,11 +624,11 @@ update_complex_assignment (block_stmt_iterator *bsi, tree r, tree i)
   mod = stmt = bsi_stmt (*bsi);
   if (TREE_CODE (stmt) == RETURN_EXPR)
     mod = TREE_OPERAND (mod, 0);
   mod = stmt = bsi_stmt (*bsi);
   if (TREE_CODE (stmt) == RETURN_EXPR)
     mod = TREE_OPERAND (mod, 0);
-  else if (in_ssa_p)
+  else if (gimple_in_ssa_p (cfun))
     update_complex_components (bsi, stmt, r, i);
   
     update_complex_components (bsi, stmt, r, i);
   
-  type = TREE_TYPE (TREE_OPERAND (mod, 1));
-  TREE_OPERAND (mod, 1) = build (COMPLEX_EXPR, type, r, i);
+  type = TREE_TYPE (GIMPLE_STMT_OPERAND (mod, 1));
+  GIMPLE_STMT_OPERAND (mod, 1) = build2 (COMPLEX_EXPR, type, r, i);
   update_stmt (stmt);
 }
 
   update_stmt (stmt);
 }
 
@@ -585,11 +650,13 @@ update_parameter_components (void)
        continue;
 
       type = TREE_TYPE (type);
        continue;
 
       type = TREE_TYPE (type);
-      ssa_name = default_def (parm);
+      ssa_name = gimple_default_def (cfun, parm);
+      if (!ssa_name)
+       continue;
 
       r = build1 (REALPART_EXPR, type, ssa_name);
       i = build1 (IMAGPART_EXPR, type, ssa_name);
 
       r = build1 (REALPART_EXPR, type, ssa_name);
       i = build1 (IMAGPART_EXPR, type, ssa_name);
-      update_complex_components_on_edge (entry_edge, NULL, ssa_name, r, i);
+      update_complex_components_on_edge (entry_edge, ssa_name, r, i);
     }
 }
 
     }
 }
 
@@ -604,24 +671,36 @@ update_phi_components (basic_block bb)
   for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
     if (is_complex_reg (PHI_RESULT (phi)))
       {
   for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
     if (is_complex_reg (PHI_RESULT (phi)))
       {
+       tree lr, li, pr = NULL, pi = NULL;
        unsigned int i, n;
        unsigned int i, n;
-       tree lhs = PHI_RESULT (phi);
 
 
+       lr = get_component_ssa_name (PHI_RESULT (phi), false);
+       if (TREE_CODE (lr) == SSA_NAME)
+         {
+           pr = create_phi_node (lr, bb);
+           SSA_NAME_DEF_STMT (lr) = pr;
+         }
+
+       li = get_component_ssa_name (PHI_RESULT (phi), true);
+       if (TREE_CODE (li) == SSA_NAME)
+         {
+           pi = create_phi_node (li, bb);
+           SSA_NAME_DEF_STMT (li) = pi;
+         }
+       
        for (i = 0, n = PHI_NUM_ARGS (phi); i < n; ++i)
          {
        for (i = 0, n = PHI_NUM_ARGS (phi); i < n; ++i)
          {
-           edge e = PHI_ARG_EDGE (phi, i);
-           tree arg = PHI_ARG_DEF (phi, i);
-           tree r, i;
-
-           /* Avoid no-op assignments.  This also prevents insertting stmts
-              onto abnormal edges, assuming the PHI isn't already broken.  */
-           if (TREE_CODE (arg) == SSA_NAME
-               && SSA_NAME_VAR (arg) == SSA_NAME_VAR (lhs))
-             continue;
-
-           r = extract_component (NULL, arg, 0, false);
-           i = extract_component (NULL, arg, 1, false);
-           update_complex_components_on_edge (e, NULL, lhs, r, i);
+           tree comp, arg = PHI_ARG_DEF (phi, i);
+           if (pr)
+             {
+               comp = extract_component (NULL, arg, false, false);
+               SET_PHI_ARG_DEF (pr, i, comp);
+             }
+           if (pi)
+             {
+               comp = extract_component (NULL, arg, true, false);
+               SET_PHI_ARG_DEF (pi, i, comp);
+             }
          }
       }
 }
          }
       }
 }
@@ -669,7 +748,7 @@ expand_complex_move (block_stmt_iterator *bsi, tree stmt, tree type,
 
          r = build1 (REALPART_EXPR, inner_type, lhs);
          i = build1 (IMAGPART_EXPR, inner_type, lhs);
 
          r = build1 (REALPART_EXPR, inner_type, lhs);
          i = build1 (IMAGPART_EXPR, inner_type, lhs);
-         update_complex_components_on_edge (e, stmt, lhs, r, i);
+         update_complex_components_on_edge (e, lhs, r, i);
        }
       else if (TREE_CODE (rhs) == CALL_EXPR || TREE_SIDE_EFFECTS (rhs))
        {
        }
       else if (TREE_CODE (rhs) == CALL_EXPR || TREE_SIDE_EFFECTS (rhs))
        {
@@ -693,25 +772,24 @@ expand_complex_move (block_stmt_iterator *bsi, tree stmt, tree type,
       i = extract_component (bsi, rhs, 1, false);
 
       x = build1 (REALPART_EXPR, inner_type, unshare_expr (lhs));
       i = extract_component (bsi, rhs, 1, false);
 
       x = build1 (REALPART_EXPR, inner_type, unshare_expr (lhs));
-      x = build2 (MODIFY_EXPR, inner_type, x, r);
+      x = build_gimple_modify_stmt (x, r);
       bsi_insert_before (bsi, x, BSI_SAME_STMT);
 
       if (stmt == bsi_stmt (*bsi))
        {
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
       bsi_insert_before (bsi, x, BSI_SAME_STMT);
 
       if (stmt == bsi_stmt (*bsi))
        {
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
-         TREE_OPERAND (stmt, 0) = x;
-         TREE_OPERAND (stmt, 1) = i;
-         TREE_TYPE (stmt) = inner_type;
+         GIMPLE_STMT_OPERAND (stmt, 0) = x;
+         GIMPLE_STMT_OPERAND (stmt, 1) = i;
        }
       else
        {
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
        }
       else
        {
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
-         x = build2 (MODIFY_EXPR, inner_type, x, i);
+         x = build_gimple_modify_stmt (x, i);
          bsi_insert_before (bsi, x, BSI_SAME_STMT);
 
          stmt = bsi_stmt (*bsi);
          gcc_assert (TREE_CODE (stmt) == RETURN_EXPR);
          bsi_insert_before (bsi, x, BSI_SAME_STMT);
 
          stmt = bsi_stmt (*bsi);
          gcc_assert (TREE_CODE (stmt) == RETURN_EXPR);
-         TREE_OPERAND (stmt, 0) = lhs;
+         GIMPLE_STMT_OPERAND (stmt, 0) = lhs;
        }
 
       update_all_vops (stmt);
        }
 
       update_all_vops (stmt);
@@ -767,7 +845,7 @@ expand_complex_addition (block_stmt_iterator *bsi, tree inner_type,
 
     case PAIR (VARYING, ONLY_IMAG):
       rr = ar;
 
     case PAIR (VARYING, ONLY_IMAG):
       rr = ar;
-      ri = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, bi);
+      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
       break;
 
     case PAIR (ONLY_REAL, VARYING):
       break;
 
     case PAIR (ONLY_REAL, VARYING):
@@ -781,7 +859,7 @@ expand_complex_addition (block_stmt_iterator *bsi, tree inner_type,
       if (code == MINUS_EXPR)
        goto general;
       rr = br;
       if (code == MINUS_EXPR)
        goto general;
       rr = br;
-      ri = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, bi);
+      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
       break;
 
     case PAIR (VARYING, VARYING):
       break;
 
     case PAIR (VARYING, VARYING):
@@ -806,15 +884,10 @@ expand_complex_libcall (block_stmt_iterator *bsi, tree ar, tree ai,
 {
   enum machine_mode mode;
   enum built_in_function bcode;
 {
   enum machine_mode mode;
   enum built_in_function bcode;
-  tree args, fn, stmt, type;
-
-  args = tree_cons (NULL, bi, NULL);
-  args = tree_cons (NULL, br, args);
-  args = tree_cons (NULL, ai, args);
-  args = tree_cons (NULL, ar, args);
+  tree fn, stmt, type;
 
   stmt = bsi_stmt (*bsi);
 
   stmt = bsi_stmt (*bsi);
-  type = TREE_TYPE (TREE_OPERAND (stmt, 1));
+  type = TREE_TYPE (GIMPLE_STMT_OPERAND (stmt, 1));
 
   mode = TYPE_MODE (type);
   gcc_assert (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT);
 
   mode = TYPE_MODE (type);
   gcc_assert (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT);
@@ -826,13 +899,12 @@ expand_complex_libcall (block_stmt_iterator *bsi, tree ar, tree ai,
     gcc_unreachable ();
   fn = built_in_decls[bcode];
 
     gcc_unreachable ();
   fn = built_in_decls[bcode];
 
-  TREE_OPERAND (stmt, 1)
-    = build3 (CALL_EXPR, type, build_fold_addr_expr (fn), args, NULL);
+  GIMPLE_STMT_OPERAND (stmt, 1) = build_call_expr (fn, 4, ar, ai, br, bi);
   update_stmt (stmt);
 
   update_stmt (stmt);
 
-  if (in_ssa_p)
+  if (gimple_in_ssa_p (cfun))
     {
     {
-      tree lhs = TREE_OPERAND (stmt, 0);
+      tree lhs = GIMPLE_STMT_OPERAND (stmt, 0);
       type = TREE_TYPE (type);
       update_complex_components (bsi, stmt,
                                 build1 (REALPART_EXPR, type, lhs),
       type = TREE_TYPE (type);
       update_complex_components (bsi, stmt,
                                 build1 (REALPART_EXPR, type, lhs),
@@ -977,7 +1049,7 @@ expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
     {
       edge e;
 
     {
       edge e;
 
-      cond = build (COND_EXPR, void_type_node, cond, NULL, NULL);
+      cond = build3 (COND_EXPR, void_type_node, cond, NULL_TREE, NULL_TREE);
       bsi_insert_before (bsi, cond, BSI_SAME_STMT);
 
       /* Split the original block, and create the TRUE and FALSE blocks.  */
       bsi_insert_before (bsi, cond, BSI_SAME_STMT);
 
       /* Split the original block, and create the TRUE and FALSE blocks.  */
@@ -987,11 +1059,6 @@ expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
       bb_true = create_empty_bb (bb_cond);
       bb_false = create_empty_bb (bb_true);
 
       bb_true = create_empty_bb (bb_cond);
       bb_false = create_empty_bb (bb_true);
 
-      t1 = build (GOTO_EXPR, void_type_node, tree_block_label (bb_true));
-      t2 = build (GOTO_EXPR, void_type_node, tree_block_label (bb_false));
-      COND_EXPR_THEN (cond) = t1;
-      COND_EXPR_ELSE (cond) = t2;
-
       /* Wire the blocks together.  */
       e->flags = EDGE_TRUE_VALUE;
       redirect_edge_succ (e, bb_true);
       /* Wire the blocks together.  */
       e->flags = EDGE_TRUE_VALUE;
       redirect_edge_succ (e, bb_true);
@@ -1042,11 +1109,11 @@ expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
 
      if (bb_true)
        {
 
      if (bb_true)
        {
-        t1 = build (MODIFY_EXPR, inner_type, rr, tr);
+        t1 = build_gimple_modify_stmt (rr, tr);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
-        t1 = build (MODIFY_EXPR, inner_type, ri, ti);
+        t1 = build_gimple_modify_stmt (ri, ti);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
-        bsi_remove (bsi);
+        bsi_remove (bsi, true);
        }
     }
 
        }
     }
 
@@ -1081,11 +1148,11 @@ expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
 
      if (bb_false)
        {
 
      if (bb_false)
        {
-        t1 = build (MODIFY_EXPR, inner_type, rr, tr);
+        t1 = build_gimple_modify_stmt (rr, tr);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
-        t1 = build (MODIFY_EXPR, inner_type, ri, ti);
+        t1 = build_gimple_modify_stmt (ri, ti);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
-        bsi_remove (bsi);
+        bsi_remove (bsi, true);
        }
     }
 
        }
     }
 
@@ -1227,9 +1294,9 @@ expand_complex_comparison (block_stmt_iterator *bsi, tree ar, tree ai,
     case RETURN_EXPR:
       expr = TREE_OPERAND (stmt, 0);
       /* FALLTHRU */
     case RETURN_EXPR:
       expr = TREE_OPERAND (stmt, 0);
       /* FALLTHRU */
-    case MODIFY_EXPR:
-      type = TREE_TYPE (TREE_OPERAND (expr, 1));
-      TREE_OPERAND (expr, 1) = fold_convert (type, cc);
+    case GIMPLE_MODIFY_STMT:
+      type = TREE_TYPE (GIMPLE_STMT_OPERAND (expr, 1));
+      GIMPLE_STMT_OPERAND (expr, 1) = fold_convert (type, cc);
       break;
     case COND_EXPR:
       TREE_OPERAND (stmt, 0) = cc;
       break;
     case COND_EXPR:
       TREE_OPERAND (stmt, 0) = cc;
@@ -1258,12 +1325,12 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
       stmt = TREE_OPERAND (stmt, 0);
       if (!stmt)
        return;
       stmt = TREE_OPERAND (stmt, 0);
       if (!stmt)
        return;
-      if (TREE_CODE (stmt) != MODIFY_EXPR)
+      if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
        return;
       /* FALLTHRU */
 
        return;
       /* FALLTHRU */
 
-    case MODIFY_EXPR:
-      rhs = TREE_OPERAND (stmt, 1);
+    case GIMPLE_MODIFY_STMT:
+      rhs = GIMPLE_STMT_OPERAND (stmt, 1);
       break;
 
     case COND_EXPR:
       break;
 
     case COND_EXPR:
@@ -1304,8 +1371,15 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
 
     default:
       {
 
     default:
       {
-       tree lhs = TREE_OPERAND (stmt, 0);
-       tree rhs = TREE_OPERAND (stmt, 1);
+       tree lhs, rhs;
+
+       /* COND_EXPR may also fallthru here, but we do not need to do anything
+          with it.  */
+       if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
+         return;
+
+       lhs = GIMPLE_STMT_OPERAND (stmt, 0);
+       rhs = GIMPLE_STMT_OPERAND (stmt, 1);
 
        if (TREE_CODE (type) == COMPLEX_TYPE)
          expand_complex_move (bsi, stmt, type, lhs, rhs);
 
        if (TREE_CODE (type) == COMPLEX_TYPE)
          expand_complex_move (bsi, stmt, type, lhs, rhs);
@@ -1313,7 +1387,7 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
                  || TREE_CODE (rhs) == IMAGPART_EXPR)
                 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
          {
                  || TREE_CODE (rhs) == IMAGPART_EXPR)
                 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
          {
-           TREE_OPERAND (stmt, 1)
+           GENERIC_TREE_OPERAND (stmt, 1)
              = extract_component (bsi, TREE_OPERAND (rhs, 0),
                                   TREE_CODE (rhs) == IMAGPART_EXPR, false);
            update_stmt (stmt);
              = extract_component (bsi, TREE_OPERAND (rhs, 0),
                                   TREE_CODE (rhs) == IMAGPART_EXPR, false);
            update_stmt (stmt);
@@ -1342,7 +1416,7 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
        }
     }
 
        }
     }
 
-  if (in_ssa_p)
+  if (gimple_in_ssa_p (cfun))
     {
       al = find_lattice_value (ac);
       if (al == UNINITIALIZED)
     {
       al = find_lattice_value (ac);
       if (al == UNINITIALIZED)
@@ -1402,7 +1476,7 @@ expand_complex_operations_1 (block_stmt_iterator *bsi)
 \f
 /* Entry point for complex operation lowering during optimization.  */
 
 \f
 /* Entry point for complex operation lowering during optimization.  */
 
-static void
+static unsigned int
 tree_lower_complex (void)
 {
   int old_last_basic_block;
 tree_lower_complex (void)
 {
   int old_last_basic_block;
@@ -1410,20 +1484,25 @@ tree_lower_complex (void)
   basic_block bb;
 
   if (!init_dont_simulate_again ())
   basic_block bb;
 
   if (!init_dont_simulate_again ())
-    return;
+    return 0;
 
   complex_lattice_values = VEC_alloc (complex_lattice_t, heap, num_ssa_names);
 
   complex_lattice_values = VEC_alloc (complex_lattice_t, heap, num_ssa_names);
-  VEC_safe_grow (complex_lattice_t, heap,
-                complex_lattice_values, num_ssa_names);
-  memset (VEC_address (complex_lattice_t, complex_lattice_values), 0,
-         num_ssa_names * sizeof(complex_lattice_t));
-  init_parameter_lattice_values ();
+  VEC_safe_grow_cleared (complex_lattice_t, heap,
+                        complex_lattice_values, num_ssa_names);
 
 
+  init_parameter_lattice_values ();
   ssa_propagate (complex_visit_stmt, complex_visit_phi);
 
   ssa_propagate (complex_visit_stmt, complex_visit_phi);
 
-  create_components ();
+  complex_variable_components = htab_create (10,  int_tree_map_hash,
+                                            int_tree_map_eq, free);
+
+  complex_ssa_name_components = VEC_alloc (tree, heap, 2*num_ssa_names);
+  VEC_safe_grow_cleared (tree, heap, complex_ssa_name_components,
+                        2 * num_ssa_names);
+
   update_parameter_components ();
 
   update_parameter_components ();
 
+  /* ??? Ideally we'd traverse the blocks in breadth-first order.  */
   old_last_basic_block = last_basic_block;
   FOR_EACH_BB (bb)
     {
   old_last_basic_block = last_basic_block;
   FOR_EACH_BB (bb)
     {
@@ -1436,10 +1515,10 @@ tree_lower_complex (void)
 
   bsi_commit_edge_inserts ();
 
 
   bsi_commit_edge_inserts ();
 
-  if (complex_variable_components)
-    htab_delete (complex_variable_components);
-
+  htab_delete (complex_variable_components);
+  VEC_free (tree, heap, complex_ssa_name_components);
   VEC_free (complex_lattice_t, heap, complex_lattice_values);
   VEC_free (complex_lattice_t, heap, complex_lattice_values);
+  return 0;
 }
 
 struct tree_opt_pass pass_lower_complex = 
 }
 
 struct tree_opt_pass pass_lower_complex = 
@@ -1453,9 +1532,10 @@ struct tree_opt_pass pass_lower_complex =
   0,                                   /* tv_id */
   PROP_ssa,                            /* properties_required */
   0,                                   /* properties_provided */
   0,                                   /* tv_id */
   PROP_ssa,                            /* properties_required */
   0,                                   /* properties_provided */
-  0,                                   /* properties_destroyed */
+  0,                                   /* properties_destroyed */
   0,                                   /* todo_flags_start */
   0,                                   /* todo_flags_start */
-  TODO_dump_func | TODO_ggc_collect
+  TODO_dump_func
+    | TODO_ggc_collect
     | TODO_update_ssa
     | TODO_verify_stmts,               /* todo_flags_finish */
   0                                    /* letter */
     | TODO_update_ssa
     | TODO_verify_stmts,               /* todo_flags_finish */
   0                                    /* letter */
@@ -1464,7 +1544,7 @@ struct tree_opt_pass pass_lower_complex =
 \f
 /* Entry point for complex operation lowering without optimization.  */
 
 \f
 /* Entry point for complex operation lowering without optimization.  */
 
-static void
+static unsigned int
 tree_lower_complex_O0 (void)
 {
   int old_last_basic_block = last_basic_block;
 tree_lower_complex_O0 (void)
 {
   int old_last_basic_block = last_basic_block;
@@ -1478,12 +1558,15 @@ tree_lower_complex_O0 (void)
       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
        expand_complex_operations_1 (&bsi);
     }
       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
        expand_complex_operations_1 (&bsi);
     }
+  return 0;
 }
 
 static bool
 gate_no_optimization (void)
 {
 }
 
 static bool
 gate_no_optimization (void)
 {
-  return optimize == 0;
+  /* With errors, normal optimization passes are not run.  If we don't
+     lower complex operations at all, rtl expansion will abort.  */
+  return optimize == 0 || sorrycount || errorcount;
 }
 
 struct tree_opt_pass pass_lower_complex_O0 = 
 }
 
 struct tree_opt_pass pass_lower_complex_O0 =