OSDN Git Service

2008-03-13 Jerry DeLisle <jvdelisle@gcc.gnu.org>
[pf3gnuchains/gcc-fork.git] / gcc / tree-complex.c
index e3e6741..10fa0ae 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, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, 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, 59 Temple Place - Suite 330, 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
@@ -52,9 +52,39 @@ DEF_VEC_ALLOC_I(complex_lattice_t, heap);
 
 static VEC(complex_lattice_t, heap) *complex_lattice_values;
 
 
 static VEC(complex_lattice_t, heap) *complex_lattice_values;
 
-/* For each complex variable, a pair of variables for the components.  */
-static VEC(tree, heap) *complex_variable_components;
+/* For each complex variable, a pair of variables for the components exists in
+   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 
+cvc_lookup (unsigned int uid)
+{
+  struct int_tree_map *h, in;
+  in.uid = uid;
+  h = htab_find_with_hash (complex_variable_components, &in, uid);
+  return h ? h->to : NULL;
+}
+/* Insert the pair UID, TO into the complex_variable_components hashtable.  */
+
+static void 
+cvc_insert (unsigned int uid, tree to)
+{ 
+  struct int_tree_map *h;
+  void **loc;
+
+  h = XNEW (struct int_tree_map);
+  h->uid = uid;
+  h->to = to;
+  loc = htab_find_slot_with_hash (complex_variable_components, h,
+                                 uid, INSERT);
+  *(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.  */
@@ -66,6 +96,8 @@ some_nonzerop (tree t)
 
   if (TREE_CODE (t) == REAL_CST)
     zerop = REAL_VALUES_IDENTICAL (TREE_REAL_CST (t), dconst0);
 
   if (TREE_CODE (t) == REAL_CST)
     zerop = REAL_VALUES_IDENTICAL (TREE_REAL_CST (t), dconst0);
+  else if (TREE_CODE (t) == FIXED_CST)
+    zerop = fixed_zerop (t);
   else if (TREE_CODE (t) == INTEGER_CST)
     zerop = integer_zerop (t);
 
   else if (TREE_CODE (t) == INTEGER_CST)
     zerop = integer_zerop (t);
 
@@ -129,15 +161,14 @@ is_complex_reg (tree lhs)
 static void
 init_parameter_lattice_values (void)
 {
 static void
 init_parameter_lattice_values (void)
 {
-  tree parm;
+  tree parm, ssa_name;
 
   for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = TREE_CHAIN (parm))
 
   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);
-       VEC_replace (complex_lattice_t, complex_lattice_values,
-                    SSA_NAME_VERSION (ssa_name), VARYING);
-      }
+    if (is_complex_reg (parm)
+       && var_ann (parm) != NULL
+       && (ssa_name = gimple_default_def (cfun, parm)) != NULL_TREE)
+      VEC_replace (complex_lattice_t, complex_lattice_values,
+                  SSA_NAME_VERSION (ssa_name), VARYING);
 }
 
 /* Initialize DONT_SIMULATE_AGAIN for each stmt and phi.  Return false if
 }
 
 /* Initialize DONT_SIMULATE_AGAIN for each stmt and phi.  Return false if
@@ -150,7 +181,7 @@ init_dont_simulate_again (void)
   basic_block bb;
   block_stmt_iterator bsi;
   tree phi;
   basic_block bb;
   block_stmt_iterator bsi;
   tree phi;
-  bool saw_a_complex_value = false;
+  bool saw_a_complex_op = false;
 
   FOR_EACH_BB (bb)
     {
 
   FOR_EACH_BB (bb)
     {
@@ -159,21 +190,81 @@ init_dont_simulate_again (void)
 
       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
        {
 
       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
        {
-         tree stmt = bsi_stmt (bsi);
-         bool dsa = true;
+         tree orig_stmt, stmt, rhs = NULL;
+         bool dsa;
+
+         orig_stmt = stmt = bsi_stmt (bsi);
 
 
-         if (TREE_CODE (stmt) == MODIFY_EXPR
-             && is_complex_reg (TREE_OPERAND (stmt, 0)))
+         /* Most control-altering statements must be initially 
+            simulated, else we won't cover the entire cfg.  */
+         dsa = !stmt_ends_bb_p (stmt);
+
+         switch (TREE_CODE (stmt))
            {
            {
-             dsa = false;
-             saw_a_complex_value = true;
+           case RETURN_EXPR:
+             /* We don't care what the lattice value of <retval> is,
+                since it's never used as an input to another computation.  */
+             dsa = true;
+             stmt = TREE_OPERAND (stmt, 0);
+             if (!stmt || TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
+               break;
+             /* FALLTHRU */
+
+           case GIMPLE_MODIFY_STMT:
+             dsa = !is_complex_reg (GIMPLE_STMT_OPERAND (stmt, 0));
+             rhs = GIMPLE_STMT_OPERAND (stmt, 1);
+             break;
+
+           case COND_EXPR:
+             rhs = TREE_OPERAND (stmt, 0);
+             break;
+
+           default:
+             break;
            }
 
            }
 
-         DONT_SIMULATE_AGAIN (stmt) = dsa;
+         if (rhs)
+           switch (TREE_CODE (rhs))
+             {
+             case EQ_EXPR:
+             case NE_EXPR:
+               rhs = TREE_OPERAND (rhs, 0);
+               /* FALLTHRU */
+
+             case PLUS_EXPR:
+             case MINUS_EXPR:
+             case MULT_EXPR:
+             case TRUNC_DIV_EXPR:
+             case CEIL_DIV_EXPR:
+             case FLOOR_DIV_EXPR:
+             case ROUND_DIV_EXPR:
+             case RDIV_EXPR:
+             case NEGATE_EXPR:
+             case CONJ_EXPR:
+               if (TREE_CODE (TREE_TYPE (rhs)) == COMPLEX_TYPE)
+                 saw_a_complex_op = true;
+               break;
+
+             case REALPART_EXPR:
+             case IMAGPART_EXPR:
+               /* The total store transformation performed during
+                  gimplification creates such uninitialized loads
+                  and we need to lower the statement to be able
+                  to fix things up.  */
+               if (TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME
+                   && ssa_undefined_value_p (TREE_OPERAND (rhs, 0)))
+                 saw_a_complex_op = true;
+               break;
+
+             default:
+               break;
+             }
+
+         DONT_SIMULATE_AGAIN (orig_stmt) = dsa;
        }
     }
 
        }
     }
 
-  return saw_a_complex_value;
+  return saw_a_complex_op;
 }
 
 
 }
 
 
@@ -187,13 +278,14 @@ complex_visit_stmt (tree stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
   unsigned int ver;
   tree lhs, rhs;
 
   unsigned int ver;
   tree lhs, rhs;
 
-  /* These conditions should be satisfied due to the initial filter
-     set up in init_dont_simulate_again.  */
-  gcc_assert (TREE_CODE (stmt) == MODIFY_EXPR);
+  if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT)
+    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.  */
   gcc_assert (TREE_CODE (lhs) == SSA_NAME);
   gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
 
   gcc_assert (TREE_CODE (lhs) == SSA_NAME);
   gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
 
@@ -299,66 +391,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 k, n;
+  tree r = create_tmp_var (type, prefix);
+  add_referenced_var (r);
 
 
-  n = num_referenced_vars;
-  complex_variable_components = VEC_alloc (tree, heap, 2*n);
-  VEC_safe_grow (tree, heap, complex_variable_components, 2*n);
+  DECL_SOURCE_LOCATION (r) = DECL_SOURCE_LOCATION (orig);
+  DECL_ARTIFICIAL (r) = 1;
 
 
-  for (k = 0; k < n; ++k)
+  if (DECL_NAME (orig) && !DECL_IGNORED_P (orig))
     {
     {
-      tree var = referenced_var (k);
-      tree r = NULL, i = NULL;
+      const char *name = IDENTIFIER_POINTER (DECL_NAME (orig));
+      tree inner_type;
 
 
-      if (var != NULL
-         && TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
-         && is_gimple_reg (var))
-       {
-         tree inner_type = TREE_TYPE (TREE_TYPE (var));
+      DECL_NAME (r) = get_identifier (ACONCAT ((name, suffix, NULL)));
 
 
-         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;
+      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
+    {
+      DECL_IGNORED_P (r) = 1;
+      TREE_NO_WARNING (r) = 1;
+    }
 
 
-         if (DECL_NAME (var) && !DECL_IGNORED_P (var))
-           {
-             const char *name = IDENTIFIER_POINTER (DECL_NAME (var));
+  return r;
+}
 
 
-             DECL_NAME (r) = get_identifier (ACONCAT ((name, "$real", NULL)));
-             DECL_NAME (i) = get_identifier (ACONCAT ((name, "$imag", NULL)));
+/* Retrieve a value for a complex component of VAR.  */
 
 
-             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;
+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_IGNORED_P (r) = 0;
-             DECL_IGNORED_P (i) = 0;
+  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);
+    }
 
 
-             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;
-           }
+  return ret;
+}
+
+/* Retrieve a value for a complex component of SSA_NAME.  */
+
+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);
        }
 
        }
 
-      VEC_replace (tree, complex_variable_components, 2*k, r);
-      VEC_replace (tree, complex_variable_components, 2*k + 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.
@@ -378,6 +569,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:
@@ -395,25 +587,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 VEC_index (tree, complex_variable_components,
-                         var_ann (SSA_NAME_VAR (t))->uid * 2 + imagpart_p);
-      }
+      return get_component_ssa_name (t, imagpart_p);
 
     default:
       gcc_unreachable ();
 
     default:
       gcc_unreachable ();
@@ -425,20 +599,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 = var_ann (SSA_NAME_VAR (TREE_OPERAND (stmt, 0)))->uid;
-  tree v, x;
-
-  v = VEC_index (tree, complex_variable_components, 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 = VEC_index (tree, complex_variable_components, 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
+update_complex_components_on_edge (edge e, tree lhs, tree r, tree i)
+{
+  tree list;
+
+  list = set_component_ssa_name (lhs, false, r);
+  if (list)
+    bsi_insert_on_edge (e, list);
+
+  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.  */
@@ -452,11 +636,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);
 }
 
@@ -472,23 +656,19 @@ update_parameter_components (void)
   for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = TREE_CHAIN (parm))
     {
       tree type = TREE_TYPE (parm);
   for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = TREE_CHAIN (parm))
     {
       tree type = TREE_TYPE (parm);
-      tree ssa_name, x, y;
-      unsigned int uid;
+      tree ssa_name, r, i;
 
       if (TREE_CODE (type) != COMPLEX_TYPE || !is_gimple_reg (parm))
        continue;
 
       type = TREE_TYPE (type);
 
       if (TREE_CODE (type) != COMPLEX_TYPE || !is_gimple_reg (parm))
        continue;
 
       type = TREE_TYPE (type);
-      ssa_name = default_def (parm);
-      uid = var_ann (parm)->uid;
-
-      x = VEC_index (tree, complex_variable_components, 2*uid);
-      y = build1 (REALPART_EXPR, type, ssa_name);
-      bsi_insert_on_edge (entry_edge, build2 (MODIFY_EXPR, type, x, y));
+      ssa_name = gimple_default_def (cfun, parm);
+      if (!ssa_name)
+       continue;
 
 
-      x = VEC_index (tree, complex_variable_components, 2*uid + 1);
-      y = build1 (IMAGPART_EXPR, type, ssa_name);
-      bsi_insert_on_edge (entry_edge, build2 (MODIFY_EXPR, type, x, y));
+      r = build1 (REALPART_EXPR, type, ssa_name);
+      i = build1 (IMAGPART_EXPR, type, ssa_name);
+      update_complex_components_on_edge (entry_edge, ssa_name, r, i);
     }
 }
 
     }
 }
 
@@ -503,27 +683,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)))
       {
-       unsigned int i, n, uid;
-       tree real, imag, type;
+       tree lr, li, pr = NULL, pi = NULL;
+       unsigned int i, n;
 
 
-       uid = var_ann (SSA_NAME_VAR (PHI_RESULT (phi)))->uid;
-       real = VEC_index (tree, complex_variable_components, 2*uid);
-       imag = VEC_index (tree, complex_variable_components, 2*uid + 1);
-       type = TREE_TYPE (real);
+       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 x;
-
-           x = extract_component (NULL, arg, 0, false);
-           if (real != x)
-             bsi_insert_on_edge (e, build2 (MODIFY_EXPR, type, real, x));
-
-           x = extract_component (NULL, arg, 1, false);
-           if (imag != x)
-             bsi_insert_on_edge (e, build2 (MODIFY_EXPR, type, imag, x));
+           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);
+             }
          }
       }
 }
          }
       }
 }
@@ -555,10 +744,29 @@ expand_complex_move (block_stmt_iterator *bsi, tree stmt, tree type,
 
   if (TREE_CODE (lhs) == SSA_NAME)
     {
 
   if (TREE_CODE (lhs) == SSA_NAME)
     {
-      if (TREE_CODE (rhs) == CALL_EXPR || TREE_SIDE_EFFECTS (rhs))
+      if (is_ctrl_altering_stmt (bsi_stmt (*bsi)))
        {
        {
-         r = build1 (REALPART_EXPR, inner_type, unshare_expr (lhs));
-         i = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
+         edge_iterator ei;
+         edge e;
+
+         /* The value is not assigned on the exception edges, so we need not
+            concern ourselves there.  We do need to update on the fallthru
+            edge.  Find it.  */
+         FOR_EACH_EDGE (e, ei, bsi->bb->succs)
+           if (e->flags & EDGE_FALLTHRU)
+             goto found_fallthru;
+         gcc_unreachable ();
+       found_fallthru:
+
+         r = build1 (REALPART_EXPR, inner_type, lhs);
+         i = build1 (IMAGPART_EXPR, inner_type, lhs);
+         update_complex_components_on_edge (e, lhs, r, i);
+       }
+      else if (TREE_CODE (rhs) == CALL_EXPR || TREE_SIDE_EFFECTS (rhs)
+              || TREE_CODE (rhs) == PAREN_EXPR)
+       {
+         r = build1 (REALPART_EXPR, inner_type, lhs);
+         i = build1 (IMAGPART_EXPR, inner_type, lhs);
          update_complex_components (bsi, stmt, r, i);
        }
       else
          update_complex_components (bsi, stmt, r, i);
        }
       else
@@ -577,25 +785,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);
@@ -651,7 +858,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):
@@ -665,7 +872,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):
@@ -690,15 +897,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);
@@ -710,13 +912,13 @@ 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),
                                 build1 (IMAGPART_EXPR, type, lhs));
       update_complex_components (bsi, stmt,
                                 build1 (REALPART_EXPR, type, lhs),
                                 build1 (IMAGPART_EXPR, type, lhs));
@@ -851,7 +1053,7 @@ expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
   /* Examine |br| < |bi|, and branch.  */
   t1 = gimplify_build1 (bsi, ABS_EXPR, inner_type, br);
   t2 = gimplify_build1 (bsi, ABS_EXPR, inner_type, bi);
   /* Examine |br| < |bi|, and branch.  */
   t1 = gimplify_build1 (bsi, ABS_EXPR, inner_type, br);
   t2 = gimplify_build1 (bsi, ABS_EXPR, inner_type, bi);
-  cond = fold (build (LT_EXPR, boolean_type_node, t1, t2));
+  cond = fold_build2 (LT_EXPR, boolean_type_node, t1, t2);
   STRIP_NOPS (cond);
 
   bb_cond = bb_true = bb_false = bb_join = NULL;
   STRIP_NOPS (cond);
 
   bb_cond = bb_true = bb_false = bb_join = NULL;
@@ -860,7 +1062,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.  */
@@ -870,11 +1072,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);
@@ -925,11 +1122,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);
        }
     }
 
        }
     }
 
@@ -964,11 +1161,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);
        }
     }
 
        }
     }
 
@@ -1110,9 +1307,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;
@@ -1141,12 +1338,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:
@@ -1187,8 +1384,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);
@@ -1196,7 +1400,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);
@@ -1225,7 +1429,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)
@@ -1285,7 +1489,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;
@@ -1293,20 +1497,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)
     {
@@ -1319,8 +1528,10 @@ tree_lower_complex (void)
 
   bsi_commit_edge_inserts ();
 
 
   bsi_commit_edge_inserts ();
 
-  VEC_free (tree, heap, 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 = 
@@ -1334,9 +1545,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 */
@@ -1345,7 +1557,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;
@@ -1359,12 +1571,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 =