OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [tree-complex.c] - Diff between revs 154 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 154 Rev 816
/* Lower complex number operations to scalar operations.
/* Lower complex number operations to scalar operations.
   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
   Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
 
 
This file is part of GCC.
This file is part of GCC.
 
 
GCC is free software; you can redistribute it and/or modify it
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
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 3, or (at your option) any
Free Software Foundation; either version 3, or (at your option) any
later version.
later version.
 
 
GCC is distributed in the hope that it will be useful, but WITHOUT
GCC is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.
for more details.
 
 
You should have received a copy of the GNU General Public License
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
<http://www.gnu.org/licenses/>.  */
 
 
#include "config.h"
#include "config.h"
#include "system.h"
#include "system.h"
#include "coretypes.h"
#include "coretypes.h"
#include "tm.h"
#include "tm.h"
#include "tree.h"
#include "tree.h"
#include "rtl.h"
#include "rtl.h"
#include "real.h"
#include "real.h"
#include "flags.h"
#include "flags.h"
#include "tree-flow.h"
#include "tree-flow.h"
#include "tree-gimple.h"
#include "tree-gimple.h"
#include "tree-iterator.h"
#include "tree-iterator.h"
#include "tree-pass.h"
#include "tree-pass.h"
#include "tree-ssa-propagate.h"
#include "tree-ssa-propagate.h"
#include "diagnostic.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
   out whether a complex number is degenerate in some way, having only real
   out whether a complex number is degenerate in some way, having only real
   or only complex parts.  */
   or only complex parts.  */
 
 
typedef enum
typedef enum
{
{
  UNINITIALIZED = 0,
  UNINITIALIZED = 0,
  ONLY_REAL = 1,
  ONLY_REAL = 1,
  ONLY_IMAG = 2,
  ONLY_IMAG = 2,
  VARYING = 3
  VARYING = 3
} complex_lattice_t;
} complex_lattice_t;
 
 
#define PAIR(a, b)  ((a) << 2 | (b))
#define PAIR(a, b)  ((a) << 2 | (b))
 
 
DEF_VEC_I(complex_lattice_t);
DEF_VEC_I(complex_lattice_t);
DEF_VEC_ALLOC_I(complex_lattice_t, heap);
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 exists in
/* For each complex variable, a pair of variables for the components exists in
   the hashtable.  */
   the hashtable.  */
static htab_t complex_variable_components;
static htab_t complex_variable_components;
 
 
/* For each complex SSA_NAME, a pair of ssa names for the components.  */
/* For each complex SSA_NAME, a pair of ssa names for the components.  */
static VEC(tree, heap) *complex_ssa_name_components;
static VEC(tree, heap) *complex_ssa_name_components;
 
 
/* Lookup UID in the complex_variable_components hashtable and return the
/* Lookup UID in the complex_variable_components hashtable and return the
   associated tree.  */
   associated tree.  */
static tree
static tree
cvc_lookup (unsigned int uid)
cvc_lookup (unsigned int uid)
{
{
  struct int_tree_map *h, in;
  struct int_tree_map *h, in;
  in.uid = uid;
  in.uid = uid;
  h = htab_find_with_hash (complex_variable_components, &in, uid);
  h = htab_find_with_hash (complex_variable_components, &in, uid);
  return h ? h->to : NULL;
  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.  */
 
 
static void
static void
cvc_insert (unsigned int uid, tree to)
cvc_insert (unsigned int uid, tree to)
{
{
  struct int_tree_map *h;
  struct int_tree_map *h;
  void **loc;
  void **loc;
 
 
  h = XNEW (struct int_tree_map);
  h = XNEW (struct int_tree_map);
  h->uid = uid;
  h->uid = uid;
  h->to = to;
  h->to = to;
  loc = htab_find_slot_with_hash (complex_variable_components, h,
  loc = htab_find_slot_with_hash (complex_variable_components, h,
                                  uid, INSERT);
                                  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,
/* Return true if T is not a zero constant.  In the case of real values,
   we're only interested in +0.0.  */
   we're only interested in +0.0.  */
 
 
static int
static int
some_nonzerop (tree t)
some_nonzerop (tree t)
{
{
  int zerop = false;
  int zerop = false;
 
 
  if (TREE_CODE (t) == REAL_CST)
  if (TREE_CODE (t) == REAL_CST)
    zerop = REAL_VALUES_IDENTICAL (TREE_REAL_CST (t), dconst0);
    zerop = REAL_VALUES_IDENTICAL (TREE_REAL_CST (t), dconst0);
  else if (TREE_CODE (t) == INTEGER_CST)
  else if (TREE_CODE (t) == INTEGER_CST)
    zerop = integer_zerop (t);
    zerop = integer_zerop (t);
 
 
  return !zerop;
  return !zerop;
}
}
 
 
/* Compute a lattice value from T.  It may be a gimple_val, or, as a
/* Compute a lattice value from T.  It may be a gimple_val, or, as a
   special exception, a COMPLEX_EXPR.  */
   special exception, a COMPLEX_EXPR.  */
 
 
static complex_lattice_t
static complex_lattice_t
find_lattice_value (tree t)
find_lattice_value (tree t)
{
{
  tree real, imag;
  tree real, imag;
  int r, i;
  int r, i;
  complex_lattice_t ret;
  complex_lattice_t ret;
 
 
  switch (TREE_CODE (t))
  switch (TREE_CODE (t))
    {
    {
    case SSA_NAME:
    case SSA_NAME:
      return VEC_index (complex_lattice_t, complex_lattice_values,
      return VEC_index (complex_lattice_t, complex_lattice_values,
                        SSA_NAME_VERSION (t));
                        SSA_NAME_VERSION (t));
 
 
    case COMPLEX_CST:
    case COMPLEX_CST:
      real = TREE_REALPART (t);
      real = TREE_REALPART (t);
      imag = TREE_IMAGPART (t);
      imag = TREE_IMAGPART (t);
      break;
      break;
 
 
    case COMPLEX_EXPR:
    case COMPLEX_EXPR:
      real = TREE_OPERAND (t, 0);
      real = TREE_OPERAND (t, 0);
      imag = TREE_OPERAND (t, 1);
      imag = TREE_OPERAND (t, 1);
      break;
      break;
 
 
    default:
    default:
      gcc_unreachable ();
      gcc_unreachable ();
    }
    }
 
 
  r = some_nonzerop (real);
  r = some_nonzerop (real);
  i = some_nonzerop (imag);
  i = some_nonzerop (imag);
  ret = r*ONLY_REAL + i*ONLY_IMAG;
  ret = r*ONLY_REAL + i*ONLY_IMAG;
 
 
  /* ??? On occasion we could do better than mapping 0+0i to real, but we
  /* ??? On occasion we could do better than mapping 0+0i to real, but we
     certainly don't want to leave it UNINITIALIZED, which eventually gets
     certainly don't want to leave it UNINITIALIZED, which eventually gets
     mapped to VARYING.  */
     mapped to VARYING.  */
  if (ret == UNINITIALIZED)
  if (ret == UNINITIALIZED)
    ret = ONLY_REAL;
    ret = ONLY_REAL;
 
 
  return ret;
  return ret;
}
}
 
 
/* Determine if LHS is something for which we're interested in seeing
/* Determine if LHS is something for which we're interested in seeing
   simulation results.  */
   simulation results.  */
 
 
static bool
static bool
is_complex_reg (tree lhs)
is_complex_reg (tree lhs)
{
{
  return TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE && is_gimple_reg (lhs);
  return TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE && is_gimple_reg (lhs);
}
}
 
 
/* Mark the incoming parameters to the function as VARYING.  */
/* Mark the incoming parameters to the function as VARYING.  */
 
 
static void
static void
init_parameter_lattice_values (void)
init_parameter_lattice_values (void)
{
{
  tree parm;
  tree parm;
 
 
  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)
    if (is_complex_reg (parm) && var_ann (parm) != NULL)
      {
      {
        tree ssa_name = default_def (parm);
        tree ssa_name = default_def (parm);
        VEC_replace (complex_lattice_t, complex_lattice_values,
        VEC_replace (complex_lattice_t, complex_lattice_values,
                     SSA_NAME_VERSION (ssa_name), VARYING);
                     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
   we found no statements we want to simulate, and thus there's nothing for
   we found no statements we want to simulate, and thus there's nothing for
   the entire pass to do.  */
   the entire pass to do.  */
 
 
static bool
static bool
init_dont_simulate_again (void)
init_dont_simulate_again (void)
{
{
  basic_block bb;
  basic_block bb;
  block_stmt_iterator bsi;
  block_stmt_iterator bsi;
  tree phi;
  tree phi;
  bool saw_a_complex_op = false;
  bool saw_a_complex_op = false;
 
 
  FOR_EACH_BB (bb)
  FOR_EACH_BB (bb)
    {
    {
      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
      for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
        DONT_SIMULATE_AGAIN (phi) = !is_complex_reg (PHI_RESULT (phi));
        DONT_SIMULATE_AGAIN (phi) = !is_complex_reg (PHI_RESULT (phi));
 
 
      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 orig_stmt, stmt, rhs = NULL;
          tree orig_stmt, stmt, rhs = NULL;
          bool dsa;
          bool dsa;
 
 
          orig_stmt = stmt = bsi_stmt (bsi);
          orig_stmt = stmt = bsi_stmt (bsi);
 
 
          /* Most control-altering statements must be initially
          /* Most control-altering statements must be initially
             simulated, else we won't cover the entire cfg.  */
             simulated, else we won't cover the entire cfg.  */
          dsa = !stmt_ends_bb_p (stmt);
          dsa = !stmt_ends_bb_p (stmt);
 
 
          switch (TREE_CODE (stmt))
          switch (TREE_CODE (stmt))
            {
            {
            case RETURN_EXPR:
            case RETURN_EXPR:
              /* We don't care what the lattice value of <retval> is,
              /* We don't care what the lattice value of <retval> is,
                 since it's never used as an input to another computation.  */
                 since it's never used as an input to another computation.  */
              dsa = true;
              dsa = true;
              stmt = TREE_OPERAND (stmt, 0);
              stmt = TREE_OPERAND (stmt, 0);
              if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
              if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
                break;
                break;
              /* FALLTHRU */
              /* FALLTHRU */
 
 
            case MODIFY_EXPR:
            case MODIFY_EXPR:
              dsa = !is_complex_reg (TREE_OPERAND (stmt, 0));
              dsa = !is_complex_reg (TREE_OPERAND (stmt, 0));
              rhs = TREE_OPERAND (stmt, 1);
              rhs = TREE_OPERAND (stmt, 1);
              break;
              break;
 
 
            case COND_EXPR:
            case COND_EXPR:
              rhs = TREE_OPERAND (stmt, 0);
              rhs = TREE_OPERAND (stmt, 0);
              break;
              break;
 
 
            default:
            default:
              break;
              break;
            }
            }
 
 
          if (rhs)
          if (rhs)
            switch (TREE_CODE (rhs))
            switch (TREE_CODE (rhs))
              {
              {
              case EQ_EXPR:
              case EQ_EXPR:
              case NE_EXPR:
              case NE_EXPR:
                rhs = TREE_OPERAND (rhs, 0);
                rhs = TREE_OPERAND (rhs, 0);
                /* FALLTHRU */
                /* FALLTHRU */
 
 
              case PLUS_EXPR:
              case PLUS_EXPR:
              case MINUS_EXPR:
              case MINUS_EXPR:
              case MULT_EXPR:
              case MULT_EXPR:
              case TRUNC_DIV_EXPR:
              case TRUNC_DIV_EXPR:
              case CEIL_DIV_EXPR:
              case CEIL_DIV_EXPR:
              case FLOOR_DIV_EXPR:
              case FLOOR_DIV_EXPR:
              case ROUND_DIV_EXPR:
              case ROUND_DIV_EXPR:
              case RDIV_EXPR:
              case RDIV_EXPR:
              case NEGATE_EXPR:
              case NEGATE_EXPR:
              case CONJ_EXPR:
              case CONJ_EXPR:
                if (TREE_CODE (TREE_TYPE (rhs)) == COMPLEX_TYPE)
                if (TREE_CODE (TREE_TYPE (rhs)) == COMPLEX_TYPE)
                  saw_a_complex_op = true;
                  saw_a_complex_op = true;
                break;
                break;
 
 
              default:
              default:
                break;
                break;
              }
              }
 
 
          DONT_SIMULATE_AGAIN (orig_stmt) = dsa;
          DONT_SIMULATE_AGAIN (orig_stmt) = dsa;
        }
        }
    }
    }
 
 
  return saw_a_complex_op;
  return saw_a_complex_op;
}
}
 
 
 
 
/* Evaluate statement STMT against the complex lattice defined above.  */
/* Evaluate statement STMT against the complex lattice defined above.  */
 
 
static enum ssa_prop_result
static enum ssa_prop_result
complex_visit_stmt (tree stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
complex_visit_stmt (tree stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
                    tree *result_p)
                    tree *result_p)
{
{
  complex_lattice_t new_l, old_l, op1_l, op2_l;
  complex_lattice_t new_l, old_l, op1_l, op2_l;
  unsigned int ver;
  unsigned int ver;
  tree lhs, rhs;
  tree lhs, rhs;
 
 
  if (TREE_CODE (stmt) != MODIFY_EXPR)
  if (TREE_CODE (stmt) != MODIFY_EXPR)
    return SSA_PROP_VARYING;
    return SSA_PROP_VARYING;
 
 
  lhs = TREE_OPERAND (stmt, 0);
  lhs = TREE_OPERAND (stmt, 0);
  rhs = TREE_OPERAND (stmt, 1);
  rhs = TREE_OPERAND (stmt, 1);
 
 
  /* These conditions should be satisfied due to the initial filter
  /* These conditions should be satisfied due to the initial filter
     set up in init_dont_simulate_again.  */
     set up in init_dont_simulate_again.  */
  gcc_assert (TREE_CODE (lhs) == SSA_NAME);
  gcc_assert (TREE_CODE (lhs) == SSA_NAME);
  gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
  gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
 
 
  *result_p = lhs;
  *result_p = lhs;
  ver = SSA_NAME_VERSION (lhs);
  ver = SSA_NAME_VERSION (lhs);
  old_l = VEC_index (complex_lattice_t, complex_lattice_values, ver);
  old_l = VEC_index (complex_lattice_t, complex_lattice_values, ver);
 
 
  switch (TREE_CODE (rhs))
  switch (TREE_CODE (rhs))
    {
    {
    case SSA_NAME:
    case SSA_NAME:
    case COMPLEX_EXPR:
    case COMPLEX_EXPR:
    case COMPLEX_CST:
    case COMPLEX_CST:
      new_l = find_lattice_value (rhs);
      new_l = find_lattice_value (rhs);
      break;
      break;
 
 
    case PLUS_EXPR:
    case PLUS_EXPR:
    case MINUS_EXPR:
    case MINUS_EXPR:
      op1_l = find_lattice_value (TREE_OPERAND (rhs, 0));
      op1_l = find_lattice_value (TREE_OPERAND (rhs, 0));
      op2_l = find_lattice_value (TREE_OPERAND (rhs, 1));
      op2_l = find_lattice_value (TREE_OPERAND (rhs, 1));
 
 
      /* We've set up the lattice values such that IOR neatly
      /* We've set up the lattice values such that IOR neatly
         models addition.  */
         models addition.  */
      new_l = op1_l | op2_l;
      new_l = op1_l | op2_l;
      break;
      break;
 
 
    case MULT_EXPR:
    case MULT_EXPR:
    case RDIV_EXPR:
    case RDIV_EXPR:
    case TRUNC_DIV_EXPR:
    case TRUNC_DIV_EXPR:
    case CEIL_DIV_EXPR:
    case CEIL_DIV_EXPR:
    case FLOOR_DIV_EXPR:
    case FLOOR_DIV_EXPR:
    case ROUND_DIV_EXPR:
    case ROUND_DIV_EXPR:
      op1_l = find_lattice_value (TREE_OPERAND (rhs, 0));
      op1_l = find_lattice_value (TREE_OPERAND (rhs, 0));
      op2_l = find_lattice_value (TREE_OPERAND (rhs, 1));
      op2_l = find_lattice_value (TREE_OPERAND (rhs, 1));
 
 
      /* Obviously, if either varies, so does the result.  */
      /* Obviously, if either varies, so does the result.  */
      if (op1_l == VARYING || op2_l == VARYING)
      if (op1_l == VARYING || op2_l == VARYING)
        new_l = VARYING;
        new_l = VARYING;
      /* Don't prematurely promote variables if we've not yet seen
      /* Don't prematurely promote variables if we've not yet seen
         their inputs.  */
         their inputs.  */
      else if (op1_l == UNINITIALIZED)
      else if (op1_l == UNINITIALIZED)
        new_l = op2_l;
        new_l = op2_l;
      else if (op2_l == UNINITIALIZED)
      else if (op2_l == UNINITIALIZED)
        new_l = op1_l;
        new_l = op1_l;
      else
      else
        {
        {
          /* At this point both numbers have only one component. If the
          /* At this point both numbers have only one component. If the
             numbers are of opposite kind, the result is imaginary,
             numbers are of opposite kind, the result is imaginary,
             otherwise the result is real. The add/subtract translates
             otherwise the result is real. The add/subtract translates
             the real/imag from/to 0/1; the ^ performs the comparison.  */
             the real/imag from/to 0/1; the ^ performs the comparison.  */
          new_l = ((op1_l - ONLY_REAL) ^ (op2_l - ONLY_REAL)) + ONLY_REAL;
          new_l = ((op1_l - ONLY_REAL) ^ (op2_l - ONLY_REAL)) + ONLY_REAL;
 
 
          /* Don't allow the lattice value to flip-flop indefinitely.  */
          /* Don't allow the lattice value to flip-flop indefinitely.  */
          new_l |= old_l;
          new_l |= old_l;
        }
        }
      break;
      break;
 
 
    case NEGATE_EXPR:
    case NEGATE_EXPR:
    case CONJ_EXPR:
    case CONJ_EXPR:
      new_l = find_lattice_value (TREE_OPERAND (rhs, 0));
      new_l = find_lattice_value (TREE_OPERAND (rhs, 0));
      break;
      break;
 
 
    default:
    default:
      new_l = VARYING;
      new_l = VARYING;
      break;
      break;
    }
    }
 
 
  /* If nothing changed this round, let the propagator know.  */
  /* If nothing changed this round, let the propagator know.  */
  if (new_l == old_l)
  if (new_l == old_l)
    return SSA_PROP_NOT_INTERESTING;
    return SSA_PROP_NOT_INTERESTING;
 
 
  VEC_replace (complex_lattice_t, complex_lattice_values, ver, new_l);
  VEC_replace (complex_lattice_t, complex_lattice_values, ver, new_l);
  return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
  return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
}
}
 
 
/* Evaluate a PHI node against the complex lattice defined above.  */
/* Evaluate a PHI node against the complex lattice defined above.  */
 
 
static enum ssa_prop_result
static enum ssa_prop_result
complex_visit_phi (tree phi)
complex_visit_phi (tree phi)
{
{
  complex_lattice_t new_l, old_l;
  complex_lattice_t new_l, old_l;
  unsigned int ver;
  unsigned int ver;
  tree lhs;
  tree lhs;
  int i;
  int i;
 
 
  lhs = PHI_RESULT (phi);
  lhs = PHI_RESULT (phi);
 
 
  /* This condition should be satisfied due to the initial filter
  /* This condition should be satisfied due to the initial filter
     set up in init_dont_simulate_again.  */
     set up in init_dont_simulate_again.  */
  gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
  gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
 
 
  /* We've set up the lattice values such that IOR neatly models PHI meet.  */
  /* We've set up the lattice values such that IOR neatly models PHI meet.  */
  new_l = UNINITIALIZED;
  new_l = UNINITIALIZED;
  for (i = PHI_NUM_ARGS (phi) - 1; i >= 0; --i)
  for (i = PHI_NUM_ARGS (phi) - 1; i >= 0; --i)
    new_l |= find_lattice_value (PHI_ARG_DEF (phi, i));
    new_l |= find_lattice_value (PHI_ARG_DEF (phi, i));
 
 
  ver = SSA_NAME_VERSION (lhs);
  ver = SSA_NAME_VERSION (lhs);
  old_l = VEC_index (complex_lattice_t, complex_lattice_values, ver);
  old_l = VEC_index (complex_lattice_t, complex_lattice_values, ver);
 
 
  if (new_l == old_l)
  if (new_l == old_l)
    return SSA_PROP_NOT_INTERESTING;
    return SSA_PROP_NOT_INTERESTING;
 
 
  VEC_replace (complex_lattice_t, complex_lattice_values, ver, new_l);
  VEC_replace (complex_lattice_t, complex_lattice_values, ver, new_l);
  return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
  return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
}
}
 
 
/* Create one backing variable for a complex component of ORIG.  */
/* Create one backing variable for a complex component of ORIG.  */
 
 
static tree
static tree
create_one_component_var (tree type, tree orig, const char *prefix,
create_one_component_var (tree type, tree orig, const char *prefix,
                          const char *suffix, enum tree_code code)
                          const char *suffix, enum tree_code code)
{
{
  tree r = create_tmp_var (type, prefix);
  tree r = create_tmp_var (type, prefix);
  add_referenced_var (r);
  add_referenced_var (r);
 
 
  DECL_SOURCE_LOCATION (r) = DECL_SOURCE_LOCATION (orig);
  DECL_SOURCE_LOCATION (r) = DECL_SOURCE_LOCATION (orig);
  DECL_ARTIFICIAL (r) = 1;
  DECL_ARTIFICIAL (r) = 1;
 
 
  if (DECL_NAME (orig) && !DECL_IGNORED_P (orig))
  if (DECL_NAME (orig) && !DECL_IGNORED_P (orig))
    {
    {
      const char *name = IDENTIFIER_POINTER (DECL_NAME (orig));
      const char *name = IDENTIFIER_POINTER (DECL_NAME (orig));
      tree inner_type;
      tree inner_type;
 
 
      DECL_NAME (r) = get_identifier (ACONCAT ((name, suffix, NULL)));
      DECL_NAME (r) = get_identifier (ACONCAT ((name, suffix, NULL)));
 
 
      inner_type = TREE_TYPE (TREE_TYPE (orig));
      inner_type = TREE_TYPE (TREE_TYPE (orig));
      SET_DECL_DEBUG_EXPR (r, build1 (code, type, orig));
      SET_DECL_DEBUG_EXPR (r, build1 (code, type, orig));
      DECL_DEBUG_EXPR_IS_FROM (r) = 1;
      DECL_DEBUG_EXPR_IS_FROM (r) = 1;
      DECL_IGNORED_P (r) = 0;
      DECL_IGNORED_P (r) = 0;
      TREE_NO_WARNING (r) = TREE_NO_WARNING (orig);
      TREE_NO_WARNING (r) = TREE_NO_WARNING (orig);
    }
    }
  else
  else
    {
    {
      DECL_IGNORED_P (r) = 1;
      DECL_IGNORED_P (r) = 1;
      TREE_NO_WARNING (r) = 1;
      TREE_NO_WARNING (r) = 1;
    }
    }
 
 
  return r;
  return r;
}
}
 
 
/* Retrieve a value for a complex component of VAR.  */
/* Retrieve a value for a complex component of VAR.  */
 
 
static tree
static tree
get_component_var (tree var, bool imag_p)
get_component_var (tree var, bool imag_p)
{
{
  size_t decl_index = DECL_UID (var) * 2 + imag_p;
  size_t decl_index = DECL_UID (var) * 2 + imag_p;
  tree ret = cvc_lookup (decl_index);
  tree ret = cvc_lookup (decl_index);
 
 
  if (ret == NULL)
  if (ret == NULL)
    {
    {
      ret = create_one_component_var (TREE_TYPE (TREE_TYPE (var)), var,
      ret = create_one_component_var (TREE_TYPE (TREE_TYPE (var)), var,
                                      imag_p ? "CI" : "CR",
                                      imag_p ? "CI" : "CR",
                                      imag_p ? "$imag" : "$real",
                                      imag_p ? "$imag" : "$real",
                                      imag_p ? IMAGPART_EXPR : REALPART_EXPR);
                                      imag_p ? IMAGPART_EXPR : REALPART_EXPR);
      cvc_insert (decl_index, ret);
      cvc_insert (decl_index, ret);
    }
    }
 
 
  return ret;
  return ret;
}
}
 
 
/* Retrieve a value for a complex component of SSA_NAME.  */
/* Retrieve a value for a complex component of SSA_NAME.  */
 
 
static tree
static tree
get_component_ssa_name (tree ssa_name, bool imag_p)
get_component_ssa_name (tree ssa_name, bool imag_p)
{
{
  complex_lattice_t lattice = find_lattice_value (ssa_name);
  complex_lattice_t lattice = find_lattice_value (ssa_name);
  size_t ssa_name_index;
  size_t ssa_name_index;
  tree ret;
  tree ret;
 
 
  if (lattice == (imag_p ? ONLY_REAL : ONLY_IMAG))
  if (lattice == (imag_p ? ONLY_REAL : ONLY_IMAG))
    {
    {
      tree inner_type = TREE_TYPE (TREE_TYPE (ssa_name));
      tree inner_type = TREE_TYPE (TREE_TYPE (ssa_name));
      if (SCALAR_FLOAT_TYPE_P (inner_type))
      if (SCALAR_FLOAT_TYPE_P (inner_type))
        return build_real (inner_type, dconst0);
        return build_real (inner_type, dconst0);
      else
      else
        return build_int_cst (inner_type, 0);
        return build_int_cst (inner_type, 0);
    }
    }
 
 
  ssa_name_index = SSA_NAME_VERSION (ssa_name) * 2 + imag_p;
  ssa_name_index = SSA_NAME_VERSION (ssa_name) * 2 + imag_p;
  ret = VEC_index (tree, complex_ssa_name_components, ssa_name_index);
  ret = VEC_index (tree, complex_ssa_name_components, ssa_name_index);
  if (ret == NULL)
  if (ret == NULL)
    {
    {
      ret = get_component_var (SSA_NAME_VAR (ssa_name), imag_p);
      ret = get_component_var (SSA_NAME_VAR (ssa_name), imag_p);
      ret = make_ssa_name (ret, NULL);
      ret = make_ssa_name (ret, NULL);
 
 
      /* Copy some properties from the original.  In particular, whether it
      /* Copy some properties from the original.  In particular, whether it
         is used in an abnormal phi, and whether it's uninitialized.  */
         is used in an abnormal phi, and whether it's uninitialized.  */
      SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ret)
      SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ret)
        = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name);
        = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name);
      if (TREE_CODE (SSA_NAME_VAR (ssa_name)) == VAR_DECL
      if (TREE_CODE (SSA_NAME_VAR (ssa_name)) == VAR_DECL
          && IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name)))
          && IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name)))
        {
        {
          SSA_NAME_DEF_STMT (ret) = 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);
          set_default_def (SSA_NAME_VAR (ret), ret);
        }
        }
 
 
      VEC_replace (tree, complex_ssa_name_components, ssa_name_index, ret);
      VEC_replace (tree, complex_ssa_name_components, ssa_name_index, ret);
    }
    }
 
 
  return ret;
  return ret;
}
}
 
 
/* Set a value for a complex component of SSA_NAME, return a STMT_LIST of
/* Set a value for a complex component of SSA_NAME, return a STMT_LIST of
   stuff that needs doing.  */
   stuff that needs doing.  */
 
 
static tree
static tree
set_component_ssa_name (tree ssa_name, bool imag_p, tree value)
set_component_ssa_name (tree ssa_name, bool imag_p, tree value)
{
{
  complex_lattice_t lattice = find_lattice_value (ssa_name);
  complex_lattice_t lattice = find_lattice_value (ssa_name);
  size_t ssa_name_index;
  size_t ssa_name_index;
  tree comp, list, last;
  tree comp, list, last;
 
 
  /* We know the value must be zero, else there's a bug in our lattice
  /* 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
     analysis.  But the value may well be a variable known to contain
     zero.  We should be safe ignoring it.  */
     zero.  We should be safe ignoring it.  */
  if (lattice == (imag_p ? ONLY_REAL : ONLY_IMAG))
  if (lattice == (imag_p ? ONLY_REAL : ONLY_IMAG))
    return NULL;
    return NULL;
 
 
  /* If we've already assigned an SSA_NAME to this component, then this
  /* 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.
     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
     This is fine.  Now we should create an initialization for the value
     we created earlier.  */
     we created earlier.  */
  ssa_name_index = SSA_NAME_VERSION (ssa_name) * 2 + imag_p;
  ssa_name_index = SSA_NAME_VERSION (ssa_name) * 2 + imag_p;
  comp = VEC_index (tree, complex_ssa_name_components, ssa_name_index);
  comp = VEC_index (tree, complex_ssa_name_components, ssa_name_index);
  if (comp)
  if (comp)
    ;
    ;
 
 
  /* If we've nothing assigned, and the value we're given is already stable,
  /* 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
     then install that as the value for this SSA_NAME.  This preemptively
     copy-propagates the value, which avoids unnecessary memory allocation.  */
     copy-propagates the value, which avoids unnecessary memory allocation.  */
  else if (is_gimple_min_invariant (value))
  else if (is_gimple_min_invariant (value))
    {
    {
      VEC_replace (tree, complex_ssa_name_components, ssa_name_index, value);
      VEC_replace (tree, complex_ssa_name_components, ssa_name_index, value);
      return NULL;
      return NULL;
    }
    }
  else if (TREE_CODE (value) == SSA_NAME
  else if (TREE_CODE (value) == SSA_NAME
           && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
           && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
    {
    {
      /* Replace an anonymous base value with the variable from cvc_lookup.
      /* Replace an anonymous base value with the variable from cvc_lookup.
         This should result in better debug info.  */
         This should result in better debug info.  */
      if (DECL_IGNORED_P (SSA_NAME_VAR (value))
      if (DECL_IGNORED_P (SSA_NAME_VAR (value))
          && !DECL_IGNORED_P (SSA_NAME_VAR (ssa_name)))
          && !DECL_IGNORED_P (SSA_NAME_VAR (ssa_name)))
        {
        {
          comp = get_component_var (SSA_NAME_VAR (ssa_name), imag_p);
          comp = get_component_var (SSA_NAME_VAR (ssa_name), imag_p);
          replace_ssa_name_symbol (value, comp);
          replace_ssa_name_symbol (value, comp);
        }
        }
 
 
      VEC_replace (tree, complex_ssa_name_components, ssa_name_index, value);
      VEC_replace (tree, complex_ssa_name_components, ssa_name_index, value);
      return NULL;
      return NULL;
    }
    }
 
 
  /* Finally, we need to stabilize the result by installing the value into
  /* Finally, we need to stabilize the result by installing the value into
     a new ssa name.  */
     a new ssa name.  */
  else
  else
    comp = get_component_ssa_name (ssa_name, imag_p);
    comp = get_component_ssa_name (ssa_name, imag_p);
 
 
  /* Do all the work to assign VALUE to COMP.  */
  /* Do all the work to assign VALUE to COMP.  */
  value = force_gimple_operand (value, &list, false, NULL);
  value = force_gimple_operand (value, &list, false, NULL);
  last = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, value);
  last = build2 (MODIFY_EXPR, TREE_TYPE (comp), comp, value);
  append_to_statement_list (last, &list);
  append_to_statement_list (last, &list);
 
 
  gcc_assert (SSA_NAME_DEF_STMT (comp) == NULL);
  gcc_assert (SSA_NAME_DEF_STMT (comp) == NULL);
  SSA_NAME_DEF_STMT (comp) = last;
  SSA_NAME_DEF_STMT (comp) = last;
 
 
  return list;
  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.
   Make sure that it's a proper gimple_val and gimplify it if not.
   Make sure that it's a proper gimple_val and gimplify it if not.
   Emit any new code before BSI.  */
   Emit any new code before BSI.  */
 
 
static tree
static tree
extract_component (block_stmt_iterator *bsi, tree t, bool imagpart_p,
extract_component (block_stmt_iterator *bsi, tree t, bool imagpart_p,
                   bool gimple_p)
                   bool gimple_p)
{
{
  switch (TREE_CODE (t))
  switch (TREE_CODE (t))
    {
    {
    case COMPLEX_CST:
    case COMPLEX_CST:
      return imagpart_p ? TREE_IMAGPART (t) : TREE_REALPART (t);
      return imagpart_p ? TREE_IMAGPART (t) : TREE_REALPART (t);
 
 
    case COMPLEX_EXPR:
    case COMPLEX_EXPR:
      return TREE_OPERAND (t, imagpart_p);
      return TREE_OPERAND (t, imagpart_p);
 
 
    case VAR_DECL:
    case VAR_DECL:
    case RESULT_DECL:
    case RESULT_DECL:
    case PARM_DECL:
    case PARM_DECL:
    case INDIRECT_REF:
    case INDIRECT_REF:
    case COMPONENT_REF:
    case COMPONENT_REF:
    case ARRAY_REF:
    case ARRAY_REF:
      {
      {
        tree inner_type = TREE_TYPE (TREE_TYPE (t));
        tree inner_type = TREE_TYPE (TREE_TYPE (t));
 
 
        t = build1 ((imagpart_p ? IMAGPART_EXPR : REALPART_EXPR),
        t = build1 ((imagpart_p ? IMAGPART_EXPR : REALPART_EXPR),
                    inner_type, unshare_expr (t));
                    inner_type, unshare_expr (t));
 
 
        if (gimple_p)
        if (gimple_p)
          t = gimplify_val (bsi, inner_type, t);
          t = gimplify_val (bsi, inner_type, t);
 
 
        return t;
        return t;
      }
      }
 
 
    case SSA_NAME:
    case SSA_NAME:
      return get_component_ssa_name (t, imagpart_p);
      return get_component_ssa_name (t, imagpart_p);
 
 
    default:
    default:
      gcc_unreachable ();
      gcc_unreachable ();
    }
    }
}
}
 
 
/* Update the complex components of the ssa name on the lhs of STMT.  */
/* Update the complex components of the ssa name on the lhs of STMT.  */
 
 
static void
static void
update_complex_components (block_stmt_iterator *bsi, tree stmt, tree r, tree i)
update_complex_components (block_stmt_iterator *bsi, tree stmt, tree r, tree i)
{
{
  tree lhs = TREE_OPERAND (stmt, 0);
  tree lhs = TREE_OPERAND (stmt, 0);
  tree list;
  tree list;
 
 
  list = set_component_ssa_name (lhs, false, r);
  list = set_component_ssa_name (lhs, false, r);
  if (list)
  if (list)
    bsi_insert_after (bsi, list, BSI_CONTINUE_LINKING);
    bsi_insert_after (bsi, list, BSI_CONTINUE_LINKING);
 
 
  list = set_component_ssa_name (lhs, true, i);
  list = set_component_ssa_name (lhs, true, i);
  if (list)
  if (list)
    bsi_insert_after (bsi, list, BSI_CONTINUE_LINKING);
    bsi_insert_after (bsi, list, BSI_CONTINUE_LINKING);
}
}
 
 
static void
static void
update_complex_components_on_edge (edge e, tree lhs, tree r, tree i)
update_complex_components_on_edge (edge e, tree lhs, tree r, tree i)
{
{
  tree list;
  tree list;
 
 
  list = set_component_ssa_name (lhs, false, r);
  list = set_component_ssa_name (lhs, false, r);
  if (list)
  if (list)
    bsi_insert_on_edge (e, list);
    bsi_insert_on_edge (e, list);
 
 
  list = set_component_ssa_name (lhs, true, i);
  list = set_component_ssa_name (lhs, true, i);
  if (list)
  if (list)
    bsi_insert_on_edge (e, 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.  */
 
 
static void
static void
update_complex_assignment (block_stmt_iterator *bsi, tree r, tree i)
update_complex_assignment (block_stmt_iterator *bsi, tree r, tree i)
{
{
  tree stmt, mod;
  tree stmt, mod;
  tree type;
  tree type;
 
 
  mod = stmt = bsi_stmt (*bsi);
  mod = stmt = bsi_stmt (*bsi);
  if (TREE_CODE (stmt) == RETURN_EXPR)
  if (TREE_CODE (stmt) == RETURN_EXPR)
    mod = TREE_OPERAND (mod, 0);
    mod = TREE_OPERAND (mod, 0);
  else if (in_ssa_p)
  else if (in_ssa_p)
    update_complex_components (bsi, stmt, r, i);
    update_complex_components (bsi, stmt, r, i);
 
 
  type = TREE_TYPE (TREE_OPERAND (mod, 1));
  type = TREE_TYPE (TREE_OPERAND (mod, 1));
  TREE_OPERAND (mod, 1) = build2 (COMPLEX_EXPR, type, r, i);
  TREE_OPERAND (mod, 1) = build2 (COMPLEX_EXPR, type, r, i);
  update_stmt (stmt);
  update_stmt (stmt);
}
}
 
 
/* Generate code at the entry point of the function to initialize the
/* Generate code at the entry point of the function to initialize the
   component variables for a complex parameter.  */
   component variables for a complex parameter.  */
 
 
static void
static void
update_parameter_components (void)
update_parameter_components (void)
{
{
  edge entry_edge = single_succ_edge (ENTRY_BLOCK_PTR);
  edge entry_edge = single_succ_edge (ENTRY_BLOCK_PTR);
  tree parm;
  tree parm;
 
 
  for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = TREE_CHAIN (parm))
  for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = TREE_CHAIN (parm))
    {
    {
      tree type = TREE_TYPE (parm);
      tree type = TREE_TYPE (parm);
      tree ssa_name, r, i;
      tree ssa_name, r, i;
 
 
      if (TREE_CODE (type) != COMPLEX_TYPE || !is_gimple_reg (parm))
      if (TREE_CODE (type) != COMPLEX_TYPE || !is_gimple_reg (parm))
        continue;
        continue;
 
 
      type = TREE_TYPE (type);
      type = TREE_TYPE (type);
      ssa_name = default_def (parm);
      ssa_name = default_def (parm);
      if (!ssa_name)
      if (!ssa_name)
        continue;
        continue;
 
 
      r = build1 (REALPART_EXPR, type, ssa_name);
      r = build1 (REALPART_EXPR, type, ssa_name);
      i = build1 (IMAGPART_EXPR, type, ssa_name);
      i = build1 (IMAGPART_EXPR, type, ssa_name);
      update_complex_components_on_edge (entry_edge, ssa_name, r, i);
      update_complex_components_on_edge (entry_edge, ssa_name, r, i);
    }
    }
}
}
 
 
/* Generate code to set the component variables of a complex variable
/* Generate code to set the component variables of a complex variable
   to match the PHI statements in block BB.  */
   to match the PHI statements in block BB.  */
 
 
static void
static void
update_phi_components (basic_block bb)
update_phi_components (basic_block bb)
{
{
  tree phi;
  tree phi;
 
 
  for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
  for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
    if (is_complex_reg (PHI_RESULT (phi)))
    if (is_complex_reg (PHI_RESULT (phi)))
      {
      {
        tree lr, li, pr = NULL, pi = NULL;
        tree lr, li, pr = NULL, pi = NULL;
        unsigned int i, n;
        unsigned int i, n;
 
 
        lr = get_component_ssa_name (PHI_RESULT (phi), false);
        lr = get_component_ssa_name (PHI_RESULT (phi), false);
        if (TREE_CODE (lr) == SSA_NAME)
        if (TREE_CODE (lr) == SSA_NAME)
          {
          {
            pr = create_phi_node (lr, bb);
            pr = create_phi_node (lr, bb);
            SSA_NAME_DEF_STMT (lr) = pr;
            SSA_NAME_DEF_STMT (lr) = pr;
          }
          }
 
 
        li = get_component_ssa_name (PHI_RESULT (phi), true);
        li = get_component_ssa_name (PHI_RESULT (phi), true);
        if (TREE_CODE (li) == SSA_NAME)
        if (TREE_CODE (li) == SSA_NAME)
          {
          {
            pi = create_phi_node (li, bb);
            pi = create_phi_node (li, bb);
            SSA_NAME_DEF_STMT (li) = pi;
            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)
          {
          {
            tree comp, arg = PHI_ARG_DEF (phi, i);
            tree comp, arg = PHI_ARG_DEF (phi, i);
            if (pr)
            if (pr)
              {
              {
                comp = extract_component (NULL, arg, false, false);
                comp = extract_component (NULL, arg, false, false);
                SET_PHI_ARG_DEF (pr, i, comp);
                SET_PHI_ARG_DEF (pr, i, comp);
              }
              }
            if (pi)
            if (pi)
              {
              {
                comp = extract_component (NULL, arg, true, false);
                comp = extract_component (NULL, arg, true, false);
                SET_PHI_ARG_DEF (pi, i, comp);
                SET_PHI_ARG_DEF (pi, i, comp);
              }
              }
          }
          }
      }
      }
}
}
 
 
/* Mark each virtual op in STMT for ssa update.  */
/* Mark each virtual op in STMT for ssa update.  */
 
 
static void
static void
update_all_vops (tree stmt)
update_all_vops (tree stmt)
{
{
  ssa_op_iter iter;
  ssa_op_iter iter;
  tree sym;
  tree sym;
 
 
  FOR_EACH_SSA_TREE_OPERAND (sym, stmt, iter, SSA_OP_ALL_VIRTUALS)
  FOR_EACH_SSA_TREE_OPERAND (sym, stmt, iter, SSA_OP_ALL_VIRTUALS)
    {
    {
      if (TREE_CODE (sym) == SSA_NAME)
      if (TREE_CODE (sym) == SSA_NAME)
        sym = SSA_NAME_VAR (sym);
        sym = SSA_NAME_VAR (sym);
      mark_sym_for_renaming (sym);
      mark_sym_for_renaming (sym);
    }
    }
}
}
 
 
/* Expand a complex move to scalars.  */
/* Expand a complex move to scalars.  */
 
 
static void
static void
expand_complex_move (block_stmt_iterator *bsi, tree stmt, tree type,
expand_complex_move (block_stmt_iterator *bsi, tree stmt, tree type,
                     tree lhs, tree rhs)
                     tree lhs, tree rhs)
{
{
  tree inner_type = TREE_TYPE (type);
  tree inner_type = TREE_TYPE (type);
  tree r, i;
  tree r, i;
 
 
  if (TREE_CODE (lhs) == SSA_NAME)
  if (TREE_CODE (lhs) == SSA_NAME)
    {
    {
      if (is_ctrl_altering_stmt (bsi_stmt (*bsi)))
      if (is_ctrl_altering_stmt (bsi_stmt (*bsi)))
        {
        {
          edge_iterator ei;
          edge_iterator ei;
          edge e;
          edge e;
 
 
          /* The value is not assigned on the exception edges, so we need not
          /* The value is not assigned on the exception edges, so we need not
             concern ourselves there.  We do need to update on the fallthru
             concern ourselves there.  We do need to update on the fallthru
             edge.  Find it.  */
             edge.  Find it.  */
          FOR_EACH_EDGE (e, ei, bsi->bb->succs)
          FOR_EACH_EDGE (e, ei, bsi->bb->succs)
            if (e->flags & EDGE_FALLTHRU)
            if (e->flags & EDGE_FALLTHRU)
              goto found_fallthru;
              goto found_fallthru;
          gcc_unreachable ();
          gcc_unreachable ();
        found_fallthru:
        found_fallthru:
 
 
          r = build1 (REALPART_EXPR, inner_type, lhs);
          r = build1 (REALPART_EXPR, inner_type, lhs);
          i = build1 (IMAGPART_EXPR, inner_type, lhs);
          i = build1 (IMAGPART_EXPR, inner_type, lhs);
          update_complex_components_on_edge (e, 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))
        {
        {
          r = build1 (REALPART_EXPR, inner_type, lhs);
          r = build1 (REALPART_EXPR, inner_type, lhs);
          i = build1 (IMAGPART_EXPR, inner_type, lhs);
          i = build1 (IMAGPART_EXPR, inner_type, lhs);
          update_complex_components (bsi, stmt, r, i);
          update_complex_components (bsi, stmt, r, i);
        }
        }
      else
      else
        {
        {
          update_all_vops (bsi_stmt (*bsi));
          update_all_vops (bsi_stmt (*bsi));
          r = extract_component (bsi, rhs, 0, true);
          r = extract_component (bsi, rhs, 0, true);
          i = extract_component (bsi, rhs, 1, true);
          i = extract_component (bsi, rhs, 1, true);
          update_complex_assignment (bsi, r, i);
          update_complex_assignment (bsi, r, i);
        }
        }
    }
    }
  else if (TREE_CODE (rhs) == SSA_NAME && !TREE_SIDE_EFFECTS (lhs))
  else if (TREE_CODE (rhs) == SSA_NAME && !TREE_SIDE_EFFECTS (lhs))
    {
    {
      tree x;
      tree x;
 
 
      r = extract_component (bsi, rhs, 0, false);
      r = extract_component (bsi, rhs, 0, false);
      i = extract_component (bsi, rhs, 1, false);
      i = extract_component (bsi, rhs, 1, false);
 
 
      x = build1 (REALPART_EXPR, inner_type, unshare_expr (lhs));
      x = build1 (REALPART_EXPR, inner_type, unshare_expr (lhs));
      x = build2 (MODIFY_EXPR, inner_type, x, r);
      x = build2 (MODIFY_EXPR, inner_type, x, r);
      bsi_insert_before (bsi, x, BSI_SAME_STMT);
      bsi_insert_before (bsi, x, BSI_SAME_STMT);
 
 
      if (stmt == bsi_stmt (*bsi))
      if (stmt == bsi_stmt (*bsi))
        {
        {
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
          TREE_OPERAND (stmt, 0) = x;
          TREE_OPERAND (stmt, 0) = x;
          TREE_OPERAND (stmt, 1) = i;
          TREE_OPERAND (stmt, 1) = i;
          TREE_TYPE (stmt) = inner_type;
          TREE_TYPE (stmt) = inner_type;
        }
        }
      else
      else
        {
        {
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
          x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
          x = build2 (MODIFY_EXPR, inner_type, x, i);
          x = build2 (MODIFY_EXPR, inner_type, x, i);
          bsi_insert_before (bsi, x, BSI_SAME_STMT);
          bsi_insert_before (bsi, x, BSI_SAME_STMT);
 
 
          stmt = bsi_stmt (*bsi);
          stmt = bsi_stmt (*bsi);
          gcc_assert (TREE_CODE (stmt) == RETURN_EXPR);
          gcc_assert (TREE_CODE (stmt) == RETURN_EXPR);
          TREE_OPERAND (stmt, 0) = lhs;
          TREE_OPERAND (stmt, 0) = lhs;
        }
        }
 
 
      update_all_vops (stmt);
      update_all_vops (stmt);
      update_stmt (stmt);
      update_stmt (stmt);
    }
    }
}
}
 
 
/* Expand complex addition to scalars:
/* Expand complex addition to scalars:
        a + b = (ar + br) + i(ai + bi)
        a + b = (ar + br) + i(ai + bi)
        a - b = (ar - br) + i(ai + bi)
        a - b = (ar - br) + i(ai + bi)
*/
*/
 
 
static void
static void
expand_complex_addition (block_stmt_iterator *bsi, tree inner_type,
expand_complex_addition (block_stmt_iterator *bsi, tree inner_type,
                         tree ar, tree ai, tree br, tree bi,
                         tree ar, tree ai, tree br, tree bi,
                         enum tree_code code,
                         enum tree_code code,
                         complex_lattice_t al, complex_lattice_t bl)
                         complex_lattice_t al, complex_lattice_t bl)
{
{
  tree rr, ri;
  tree rr, ri;
 
 
  switch (PAIR (al, bl))
  switch (PAIR (al, bl))
    {
    {
    case PAIR (ONLY_REAL, ONLY_REAL):
    case PAIR (ONLY_REAL, ONLY_REAL):
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      ri = ai;
      ri = ai;
      break;
      break;
 
 
    case PAIR (ONLY_REAL, ONLY_IMAG):
    case PAIR (ONLY_REAL, ONLY_IMAG):
      rr = ar;
      rr = ar;
      if (code == MINUS_EXPR)
      if (code == MINUS_EXPR)
        ri = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, bi);
        ri = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, bi);
      else
      else
        ri = bi;
        ri = bi;
      break;
      break;
 
 
    case PAIR (ONLY_IMAG, ONLY_REAL):
    case PAIR (ONLY_IMAG, ONLY_REAL):
      if (code == MINUS_EXPR)
      if (code == MINUS_EXPR)
        rr = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ar, br);
        rr = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ar, br);
      else
      else
        rr = br;
        rr = br;
      ri = ai;
      ri = ai;
      break;
      break;
 
 
    case PAIR (ONLY_IMAG, ONLY_IMAG):
    case PAIR (ONLY_IMAG, ONLY_IMAG):
      rr = ar;
      rr = ar;
      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
      break;
      break;
 
 
    case PAIR (VARYING, ONLY_REAL):
    case PAIR (VARYING, ONLY_REAL):
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      ri = ai;
      ri = ai;
      break;
      break;
 
 
    case PAIR (VARYING, ONLY_IMAG):
    case PAIR (VARYING, ONLY_IMAG):
      rr = ar;
      rr = ar;
      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
      break;
      break;
 
 
    case PAIR (ONLY_REAL, VARYING):
    case PAIR (ONLY_REAL, VARYING):
      if (code == MINUS_EXPR)
      if (code == MINUS_EXPR)
        goto general;
        goto general;
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      ri = bi;
      ri = bi;
      break;
      break;
 
 
    case PAIR (ONLY_IMAG, VARYING):
    case PAIR (ONLY_IMAG, VARYING):
      if (code == MINUS_EXPR)
      if (code == MINUS_EXPR)
        goto general;
        goto general;
      rr = br;
      rr = br;
      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
      break;
      break;
 
 
    case PAIR (VARYING, VARYING):
    case PAIR (VARYING, VARYING):
    general:
    general:
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
      ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
      break;
      break;
 
 
    default:
    default:
      gcc_unreachable ();
      gcc_unreachable ();
    }
    }
 
 
  update_complex_assignment (bsi, rr, ri);
  update_complex_assignment (bsi, rr, ri);
}
}
 
 
/* Expand a complex multiplication or division to a libcall to the c99
/* Expand a complex multiplication or division to a libcall to the c99
   compliant routines.  */
   compliant routines.  */
 
 
static void
static void
expand_complex_libcall (block_stmt_iterator *bsi, tree ar, tree ai,
expand_complex_libcall (block_stmt_iterator *bsi, tree ar, tree ai,
                        tree br, tree bi, enum tree_code code)
                        tree br, tree bi, enum tree_code code)
{
{
  enum machine_mode mode;
  enum machine_mode mode;
  enum built_in_function bcode;
  enum built_in_function bcode;
  tree args, fn, stmt, type;
  tree args, fn, stmt, type;
 
 
  args = tree_cons (NULL, bi, NULL);
  args = tree_cons (NULL, bi, NULL);
  args = tree_cons (NULL, br, args);
  args = tree_cons (NULL, br, args);
  args = tree_cons (NULL, ai, args);
  args = tree_cons (NULL, ai, args);
  args = tree_cons (NULL, ar, args);
  args = tree_cons (NULL, ar, args);
 
 
  stmt = bsi_stmt (*bsi);
  stmt = bsi_stmt (*bsi);
  type = TREE_TYPE (TREE_OPERAND (stmt, 1));
  type = TREE_TYPE (TREE_OPERAND (stmt, 1));
 
 
  mode = TYPE_MODE (type);
  mode = TYPE_MODE (type);
  gcc_assert (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT);
  gcc_assert (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT);
  if (code == MULT_EXPR)
  if (code == MULT_EXPR)
    bcode = BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
    bcode = BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
  else if (code == RDIV_EXPR)
  else if (code == RDIV_EXPR)
    bcode = BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
    bcode = BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
  else
  else
    gcc_unreachable ();
    gcc_unreachable ();
  fn = built_in_decls[bcode];
  fn = built_in_decls[bcode];
 
 
  TREE_OPERAND (stmt, 1)
  TREE_OPERAND (stmt, 1)
    = build3 (CALL_EXPR, type, build_fold_addr_expr (fn), args, NULL);
    = build3 (CALL_EXPR, type, build_fold_addr_expr (fn), args, NULL);
  update_stmt (stmt);
  update_stmt (stmt);
 
 
  if (in_ssa_p)
  if (in_ssa_p)
    {
    {
      tree lhs = TREE_OPERAND (stmt, 0);
      tree lhs = TREE_OPERAND (stmt, 0);
      type = TREE_TYPE (type);
      type = TREE_TYPE (type);
      update_complex_components (bsi, stmt,
      update_complex_components (bsi, stmt,
                                 build1 (REALPART_EXPR, type, lhs),
                                 build1 (REALPART_EXPR, type, lhs),
                                 build1 (IMAGPART_EXPR, type, lhs));
                                 build1 (IMAGPART_EXPR, type, lhs));
    }
    }
}
}
 
 
/* Expand complex multiplication to scalars:
/* Expand complex multiplication to scalars:
        a * b = (ar*br - ai*bi) + i(ar*bi + br*ai)
        a * b = (ar*br - ai*bi) + i(ar*bi + br*ai)
*/
*/
 
 
static void
static void
expand_complex_multiplication (block_stmt_iterator *bsi, tree inner_type,
expand_complex_multiplication (block_stmt_iterator *bsi, tree inner_type,
                               tree ar, tree ai, tree br, tree bi,
                               tree ar, tree ai, tree br, tree bi,
                               complex_lattice_t al, complex_lattice_t bl)
                               complex_lattice_t al, complex_lattice_t bl)
{
{
  tree rr, ri;
  tree rr, ri;
 
 
  if (al < bl)
  if (al < bl)
    {
    {
      complex_lattice_t tl;
      complex_lattice_t tl;
      rr = ar, ar = br, br = rr;
      rr = ar, ar = br, br = rr;
      ri = ai, ai = bi, bi = ri;
      ri = ai, ai = bi, bi = ri;
      tl = al, al = bl, bl = tl;
      tl = al, al = bl, bl = tl;
    }
    }
 
 
  switch (PAIR (al, bl))
  switch (PAIR (al, bl))
    {
    {
    case PAIR (ONLY_REAL, ONLY_REAL):
    case PAIR (ONLY_REAL, ONLY_REAL):
      rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
      rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
      ri = ai;
      ri = ai;
      break;
      break;
 
 
    case PAIR (ONLY_IMAG, ONLY_REAL):
    case PAIR (ONLY_IMAG, ONLY_REAL):
      rr = ar;
      rr = ar;
      if (TREE_CODE (ai) == REAL_CST
      if (TREE_CODE (ai) == REAL_CST
          && REAL_VALUES_IDENTICAL (TREE_REAL_CST (ai), dconst1))
          && REAL_VALUES_IDENTICAL (TREE_REAL_CST (ai), dconst1))
        ri = br;
        ri = br;
      else
      else
        ri = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
        ri = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
      break;
      break;
 
 
    case PAIR (ONLY_IMAG, ONLY_IMAG):
    case PAIR (ONLY_IMAG, ONLY_IMAG):
      rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
      rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
      rr = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, rr);
      rr = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, rr);
      ri = ar;
      ri = ar;
      break;
      break;
 
 
    case PAIR (VARYING, ONLY_REAL):
    case PAIR (VARYING, ONLY_REAL):
      rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
      rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
      ri = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
      ri = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
      break;
      break;
 
 
    case PAIR (VARYING, ONLY_IMAG):
    case PAIR (VARYING, ONLY_IMAG):
      rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
      rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
      rr = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, rr);
      rr = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, rr);
      ri = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, bi);
      ri = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, bi);
      break;
      break;
 
 
    case PAIR (VARYING, VARYING):
    case PAIR (VARYING, VARYING):
      if (flag_complex_method == 2 && SCALAR_FLOAT_TYPE_P (inner_type))
      if (flag_complex_method == 2 && SCALAR_FLOAT_TYPE_P (inner_type))
        {
        {
          expand_complex_libcall (bsi, ar, ai, br, bi, MULT_EXPR);
          expand_complex_libcall (bsi, ar, ai, br, bi, MULT_EXPR);
          return;
          return;
        }
        }
      else
      else
        {
        {
          tree t1, t2, t3, t4;
          tree t1, t2, t3, t4;
 
 
          t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
          t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
          t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
          t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
          t3 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, bi);
          t3 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, bi);
 
 
          /* Avoid expanding redundant multiplication for the common
          /* Avoid expanding redundant multiplication for the common
             case of squaring a complex number.  */
             case of squaring a complex number.  */
          if (ar == br && ai == bi)
          if (ar == br && ai == bi)
            t4 = t3;
            t4 = t3;
          else
          else
            t4 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
            t4 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
 
 
          rr = gimplify_build2 (bsi, MINUS_EXPR, inner_type, t1, t2);
          rr = gimplify_build2 (bsi, MINUS_EXPR, inner_type, t1, t2);
          ri = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t3, t4);
          ri = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t3, t4);
        }
        }
      break;
      break;
 
 
    default:
    default:
      gcc_unreachable ();
      gcc_unreachable ();
    }
    }
 
 
  update_complex_assignment (bsi, rr, ri);
  update_complex_assignment (bsi, rr, ri);
}
}
 
 
/* Expand complex division to scalars, straightforward algorithm.
/* Expand complex division to scalars, straightforward algorithm.
        a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
        a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
            t = br*br + bi*bi
            t = br*br + bi*bi
*/
*/
 
 
static void
static void
expand_complex_div_straight (block_stmt_iterator *bsi, tree inner_type,
expand_complex_div_straight (block_stmt_iterator *bsi, tree inner_type,
                             tree ar, tree ai, tree br, tree bi,
                             tree ar, tree ai, tree br, tree bi,
                             enum tree_code code)
                             enum tree_code code)
{
{
  tree rr, ri, div, t1, t2, t3;
  tree rr, ri, div, t1, t2, t3;
 
 
  t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, br, br);
  t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, br, br);
  t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, bi, bi);
  t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, bi, bi);
  div = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, t2);
  div = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, t2);
 
 
  t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
  t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
  t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
  t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
  t3 = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, t2);
  t3 = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, t2);
  rr = gimplify_build2 (bsi, code, inner_type, t3, div);
  rr = gimplify_build2 (bsi, code, inner_type, t3, div);
 
 
  t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
  t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
  t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, bi);
  t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, bi);
  t3 = gimplify_build2 (bsi, MINUS_EXPR, inner_type, t1, t2);
  t3 = gimplify_build2 (bsi, MINUS_EXPR, inner_type, t1, t2);
  ri = gimplify_build2 (bsi, code, inner_type, t3, div);
  ri = gimplify_build2 (bsi, code, inner_type, t3, div);
 
 
  update_complex_assignment (bsi, rr, ri);
  update_complex_assignment (bsi, rr, ri);
}
}
 
 
/* Expand complex division to scalars, modified algorithm to minimize
/* Expand complex division to scalars, modified algorithm to minimize
   overflow with wide input ranges.  */
   overflow with wide input ranges.  */
 
 
static void
static void
expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
                         tree ar, tree ai, tree br, tree bi,
                         tree ar, tree ai, tree br, tree bi,
                         enum tree_code code)
                         enum tree_code code)
{
{
  tree rr, ri, ratio, div, t1, t2, tr, ti, cond;
  tree rr, ri, ratio, div, t1, t2, tr, ti, cond;
  basic_block bb_cond, bb_true, bb_false, bb_join;
  basic_block bb_cond, bb_true, bb_false, bb_join;
 
 
  /* Examine |br| < |bi|, and branch.  */
  /* Examine |br| < |bi|, and branch.  */
  t1 = gimplify_build1 (bsi, ABS_EXPR, inner_type, br);
  t1 = gimplify_build1 (bsi, ABS_EXPR, inner_type, br);
  t2 = gimplify_build1 (bsi, ABS_EXPR, inner_type, bi);
  t2 = gimplify_build1 (bsi, ABS_EXPR, inner_type, bi);
  cond = fold_build2 (LT_EXPR, boolean_type_node, t1, t2);
  cond = fold_build2 (LT_EXPR, boolean_type_node, t1, t2);
  STRIP_NOPS (cond);
  STRIP_NOPS (cond);
 
 
  bb_cond = bb_true = bb_false = bb_join = NULL;
  bb_cond = bb_true = bb_false = bb_join = NULL;
  rr = ri = tr = ti = NULL;
  rr = ri = tr = ti = NULL;
  if (!TREE_CONSTANT (cond))
  if (!TREE_CONSTANT (cond))
    {
    {
      edge e;
      edge e;
 
 
      cond = build3 (COND_EXPR, void_type_node, cond, NULL_TREE, NULL_TREE);
      cond = build3 (COND_EXPR, void_type_node, cond, NULL_TREE, NULL_TREE);
      bsi_insert_before (bsi, cond, BSI_SAME_STMT);
      bsi_insert_before (bsi, cond, BSI_SAME_STMT);
 
 
      /* Split the original block, and create the TRUE and FALSE blocks.  */
      /* Split the original block, and create the TRUE and FALSE blocks.  */
      e = split_block (bsi->bb, cond);
      e = split_block (bsi->bb, cond);
      bb_cond = e->src;
      bb_cond = e->src;
      bb_join = e->dest;
      bb_join = e->dest;
      bb_true = create_empty_bb (bb_cond);
      bb_true = create_empty_bb (bb_cond);
      bb_false = create_empty_bb (bb_true);
      bb_false = create_empty_bb (bb_true);
 
 
      t1 = build1 (GOTO_EXPR, void_type_node, tree_block_label (bb_true));
      t1 = build1 (GOTO_EXPR, void_type_node, tree_block_label (bb_true));
      t2 = build1 (GOTO_EXPR, void_type_node, tree_block_label (bb_false));
      t2 = build1 (GOTO_EXPR, void_type_node, tree_block_label (bb_false));
      COND_EXPR_THEN (cond) = t1;
      COND_EXPR_THEN (cond) = t1;
      COND_EXPR_ELSE (cond) = t2;
      COND_EXPR_ELSE (cond) = t2;
 
 
      /* Wire the blocks together.  */
      /* Wire the blocks together.  */
      e->flags = EDGE_TRUE_VALUE;
      e->flags = EDGE_TRUE_VALUE;
      redirect_edge_succ (e, bb_true);
      redirect_edge_succ (e, bb_true);
      make_edge (bb_cond, bb_false, EDGE_FALSE_VALUE);
      make_edge (bb_cond, bb_false, EDGE_FALSE_VALUE);
      make_edge (bb_true, bb_join, EDGE_FALLTHRU);
      make_edge (bb_true, bb_join, EDGE_FALLTHRU);
      make_edge (bb_false, bb_join, EDGE_FALLTHRU);
      make_edge (bb_false, bb_join, EDGE_FALLTHRU);
 
 
      /* Update dominance info.  Note that bb_join's data was
      /* Update dominance info.  Note that bb_join's data was
         updated by split_block.  */
         updated by split_block.  */
      if (dom_info_available_p (CDI_DOMINATORS))
      if (dom_info_available_p (CDI_DOMINATORS))
        {
        {
          set_immediate_dominator (CDI_DOMINATORS, bb_true, bb_cond);
          set_immediate_dominator (CDI_DOMINATORS, bb_true, bb_cond);
          set_immediate_dominator (CDI_DOMINATORS, bb_false, bb_cond);
          set_immediate_dominator (CDI_DOMINATORS, bb_false, bb_cond);
        }
        }
 
 
      rr = make_rename_temp (inner_type, NULL);
      rr = make_rename_temp (inner_type, NULL);
      ri = make_rename_temp (inner_type, NULL);
      ri = make_rename_temp (inner_type, NULL);
    }
    }
 
 
  /* In the TRUE branch, we compute
  /* In the TRUE branch, we compute
      ratio = br/bi;
      ratio = br/bi;
      div = (br * ratio) + bi;
      div = (br * ratio) + bi;
      tr = (ar * ratio) + ai;
      tr = (ar * ratio) + ai;
      ti = (ai * ratio) - ar;
      ti = (ai * ratio) - ar;
      tr = tr / div;
      tr = tr / div;
      ti = ti / div;  */
      ti = ti / div;  */
  if (bb_true || integer_nonzerop (cond))
  if (bb_true || integer_nonzerop (cond))
    {
    {
      if (bb_true)
      if (bb_true)
        {
        {
          *bsi = bsi_last (bb_true);
          *bsi = bsi_last (bb_true);
          bsi_insert_after (bsi, build_empty_stmt (), BSI_NEW_STMT);
          bsi_insert_after (bsi, build_empty_stmt (), BSI_NEW_STMT);
        }
        }
 
 
      ratio = gimplify_build2 (bsi, code, inner_type, br, bi);
      ratio = gimplify_build2 (bsi, code, inner_type, br, bi);
 
 
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, br, ratio);
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, br, ratio);
      div = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, bi);
      div = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, bi);
 
 
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, ratio);
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, ratio);
      tr = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, ai);
      tr = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, ai);
 
 
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, ratio);
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, ratio);
      ti = gimplify_build2 (bsi, MINUS_EXPR, inner_type, t1, ar);
      ti = gimplify_build2 (bsi, MINUS_EXPR, inner_type, t1, ar);
 
 
      tr = gimplify_build2 (bsi, code, inner_type, tr, div);
      tr = gimplify_build2 (bsi, code, inner_type, tr, div);
      ti = gimplify_build2 (bsi, code, inner_type, ti, div);
      ti = gimplify_build2 (bsi, code, inner_type, ti, div);
 
 
     if (bb_true)
     if (bb_true)
       {
       {
         t1 = build2 (MODIFY_EXPR, inner_type, rr, tr);
         t1 = build2 (MODIFY_EXPR, inner_type, rr, tr);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         t1 = build2 (MODIFY_EXPR, inner_type, ri, ti);
         t1 = build2 (MODIFY_EXPR, inner_type, ri, ti);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_remove (bsi, true);
         bsi_remove (bsi, true);
       }
       }
    }
    }
 
 
  /* In the FALSE branch, we compute
  /* In the FALSE branch, we compute
      ratio = d/c;
      ratio = d/c;
      divisor = (d * ratio) + c;
      divisor = (d * ratio) + c;
      tr = (b * ratio) + a;
      tr = (b * ratio) + a;
      ti = b - (a * ratio);
      ti = b - (a * ratio);
      tr = tr / div;
      tr = tr / div;
      ti = ti / div;  */
      ti = ti / div;  */
  if (bb_false || integer_zerop (cond))
  if (bb_false || integer_zerop (cond))
    {
    {
      if (bb_false)
      if (bb_false)
        {
        {
          *bsi = bsi_last (bb_false);
          *bsi = bsi_last (bb_false);
          bsi_insert_after (bsi, build_empty_stmt (), BSI_NEW_STMT);
          bsi_insert_after (bsi, build_empty_stmt (), BSI_NEW_STMT);
        }
        }
 
 
      ratio = gimplify_build2 (bsi, code, inner_type, bi, br);
      ratio = gimplify_build2 (bsi, code, inner_type, bi, br);
 
 
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, bi, ratio);
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, bi, ratio);
      div = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, br);
      div = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, br);
 
 
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, ratio);
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, ratio);
      tr = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, ar);
      tr = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, ar);
 
 
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, ratio);
      t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, ratio);
      ti = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, t1);
      ti = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, t1);
 
 
      tr = gimplify_build2 (bsi, code, inner_type, tr, div);
      tr = gimplify_build2 (bsi, code, inner_type, tr, div);
      ti = gimplify_build2 (bsi, code, inner_type, ti, div);
      ti = gimplify_build2 (bsi, code, inner_type, ti, div);
 
 
     if (bb_false)
     if (bb_false)
       {
       {
         t1 = build2 (MODIFY_EXPR, inner_type, rr, tr);
         t1 = build2 (MODIFY_EXPR, inner_type, rr, tr);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         t1 = build2 (MODIFY_EXPR, inner_type, ri, ti);
         t1 = build2 (MODIFY_EXPR, inner_type, ri, ti);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_insert_before (bsi, t1, BSI_SAME_STMT);
         bsi_remove (bsi, true);
         bsi_remove (bsi, true);
       }
       }
    }
    }
 
 
  if (bb_join)
  if (bb_join)
    *bsi = bsi_start (bb_join);
    *bsi = bsi_start (bb_join);
  else
  else
    rr = tr, ri = ti;
    rr = tr, ri = ti;
 
 
  update_complex_assignment (bsi, rr, ri);
  update_complex_assignment (bsi, rr, ri);
}
}
 
 
/* Expand complex division to scalars.  */
/* Expand complex division to scalars.  */
 
 
static void
static void
expand_complex_division (block_stmt_iterator *bsi, tree inner_type,
expand_complex_division (block_stmt_iterator *bsi, tree inner_type,
                         tree ar, tree ai, tree br, tree bi,
                         tree ar, tree ai, tree br, tree bi,
                         enum tree_code code,
                         enum tree_code code,
                         complex_lattice_t al, complex_lattice_t bl)
                         complex_lattice_t al, complex_lattice_t bl)
{
{
  tree rr, ri;
  tree rr, ri;
 
 
  switch (PAIR (al, bl))
  switch (PAIR (al, bl))
    {
    {
    case PAIR (ONLY_REAL, ONLY_REAL):
    case PAIR (ONLY_REAL, ONLY_REAL):
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      ri = ai;
      ri = ai;
      break;
      break;
 
 
    case PAIR (ONLY_REAL, ONLY_IMAG):
    case PAIR (ONLY_REAL, ONLY_IMAG):
      rr = ai;
      rr = ai;
      ri = gimplify_build2 (bsi, code, inner_type, ar, bi);
      ri = gimplify_build2 (bsi, code, inner_type, ar, bi);
      ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ri);
      ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ri);
      break;
      break;
 
 
    case PAIR (ONLY_IMAG, ONLY_REAL):
    case PAIR (ONLY_IMAG, ONLY_REAL):
      rr = ar;
      rr = ar;
      ri = gimplify_build2 (bsi, code, inner_type, ai, br);
      ri = gimplify_build2 (bsi, code, inner_type, ai, br);
      break;
      break;
 
 
    case PAIR (ONLY_IMAG, ONLY_IMAG):
    case PAIR (ONLY_IMAG, ONLY_IMAG):
      rr = gimplify_build2 (bsi, code, inner_type, ai, bi);
      rr = gimplify_build2 (bsi, code, inner_type, ai, bi);
      ri = ar;
      ri = ar;
      break;
      break;
 
 
    case PAIR (VARYING, ONLY_REAL):
    case PAIR (VARYING, ONLY_REAL):
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      rr = gimplify_build2 (bsi, code, inner_type, ar, br);
      ri = gimplify_build2 (bsi, code, inner_type, ai, br);
      ri = gimplify_build2 (bsi, code, inner_type, ai, br);
      break;
      break;
 
 
    case PAIR (VARYING, ONLY_IMAG):
    case PAIR (VARYING, ONLY_IMAG):
      rr = gimplify_build2 (bsi, code, inner_type, ai, bi);
      rr = gimplify_build2 (bsi, code, inner_type, ai, bi);
      ri = gimplify_build2 (bsi, code, inner_type, ar, bi);
      ri = gimplify_build2 (bsi, code, inner_type, ar, bi);
      ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ri);
      ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ri);
 
 
    case PAIR (ONLY_REAL, VARYING):
    case PAIR (ONLY_REAL, VARYING):
    case PAIR (ONLY_IMAG, VARYING):
    case PAIR (ONLY_IMAG, VARYING):
    case PAIR (VARYING, VARYING):
    case PAIR (VARYING, VARYING):
      switch (flag_complex_method)
      switch (flag_complex_method)
        {
        {
        case 0:
        case 0:
          /* straightforward implementation of complex divide acceptable.  */
          /* straightforward implementation of complex divide acceptable.  */
          expand_complex_div_straight (bsi, inner_type, ar, ai, br, bi, code);
          expand_complex_div_straight (bsi, inner_type, ar, ai, br, bi, code);
          break;
          break;
 
 
        case 2:
        case 2:
          if (SCALAR_FLOAT_TYPE_P (inner_type))
          if (SCALAR_FLOAT_TYPE_P (inner_type))
            {
            {
              expand_complex_libcall (bsi, ar, ai, br, bi, code);
              expand_complex_libcall (bsi, ar, ai, br, bi, code);
              break;
              break;
            }
            }
          /* FALLTHRU */
          /* FALLTHRU */
 
 
        case 1:
        case 1:
          /* wide ranges of inputs must work for complex divide.  */
          /* wide ranges of inputs must work for complex divide.  */
          expand_complex_div_wide (bsi, inner_type, ar, ai, br, bi, code);
          expand_complex_div_wide (bsi, inner_type, ar, ai, br, bi, code);
          break;
          break;
 
 
        default:
        default:
          gcc_unreachable ();
          gcc_unreachable ();
        }
        }
      return;
      return;
 
 
    default:
    default:
      gcc_unreachable ();
      gcc_unreachable ();
    }
    }
 
 
  update_complex_assignment (bsi, rr, ri);
  update_complex_assignment (bsi, rr, ri);
}
}
 
 
/* Expand complex negation to scalars:
/* Expand complex negation to scalars:
        -a = (-ar) + i(-ai)
        -a = (-ar) + i(-ai)
*/
*/
 
 
static void
static void
expand_complex_negation (block_stmt_iterator *bsi, tree inner_type,
expand_complex_negation (block_stmt_iterator *bsi, tree inner_type,
                         tree ar, tree ai)
                         tree ar, tree ai)
{
{
  tree rr, ri;
  tree rr, ri;
 
 
  rr = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ar);
  rr = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ar);
  ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ai);
  ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ai);
 
 
  update_complex_assignment (bsi, rr, ri);
  update_complex_assignment (bsi, rr, ri);
}
}
 
 
/* Expand complex conjugate to scalars:
/* Expand complex conjugate to scalars:
        ~a = (ar) + i(-ai)
        ~a = (ar) + i(-ai)
*/
*/
 
 
static void
static void
expand_complex_conjugate (block_stmt_iterator *bsi, tree inner_type,
expand_complex_conjugate (block_stmt_iterator *bsi, tree inner_type,
                          tree ar, tree ai)
                          tree ar, tree ai)
{
{
  tree ri;
  tree ri;
 
 
  ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ai);
  ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ai);
 
 
  update_complex_assignment (bsi, ar, ri);
  update_complex_assignment (bsi, ar, ri);
}
}
 
 
/* Expand complex comparison (EQ or NE only).  */
/* Expand complex comparison (EQ or NE only).  */
 
 
static void
static void
expand_complex_comparison (block_stmt_iterator *bsi, tree ar, tree ai,
expand_complex_comparison (block_stmt_iterator *bsi, tree ar, tree ai,
                           tree br, tree bi, enum tree_code code)
                           tree br, tree bi, enum tree_code code)
{
{
  tree cr, ci, cc, stmt, expr, type;
  tree cr, ci, cc, stmt, expr, type;
 
 
  cr = gimplify_build2 (bsi, code, boolean_type_node, ar, br);
  cr = gimplify_build2 (bsi, code, boolean_type_node, ar, br);
  ci = gimplify_build2 (bsi, code, boolean_type_node, ai, bi);
  ci = gimplify_build2 (bsi, code, boolean_type_node, ai, bi);
  cc = gimplify_build2 (bsi,
  cc = gimplify_build2 (bsi,
                        (code == EQ_EXPR ? TRUTH_AND_EXPR : TRUTH_OR_EXPR),
                        (code == EQ_EXPR ? TRUTH_AND_EXPR : TRUTH_OR_EXPR),
                        boolean_type_node, cr, ci);
                        boolean_type_node, cr, ci);
 
 
  stmt = expr = bsi_stmt (*bsi);
  stmt = expr = bsi_stmt (*bsi);
 
 
  switch (TREE_CODE (stmt))
  switch (TREE_CODE (stmt))
    {
    {
    case RETURN_EXPR:
    case RETURN_EXPR:
      expr = TREE_OPERAND (stmt, 0);
      expr = TREE_OPERAND (stmt, 0);
      /* FALLTHRU */
      /* FALLTHRU */
    case MODIFY_EXPR:
    case MODIFY_EXPR:
      type = TREE_TYPE (TREE_OPERAND (expr, 1));
      type = TREE_TYPE (TREE_OPERAND (expr, 1));
      TREE_OPERAND (expr, 1) = fold_convert (type, cc);
      TREE_OPERAND (expr, 1) = fold_convert (type, cc);
      break;
      break;
    case COND_EXPR:
    case COND_EXPR:
      TREE_OPERAND (stmt, 0) = cc;
      TREE_OPERAND (stmt, 0) = cc;
      break;
      break;
    default:
    default:
      gcc_unreachable ();
      gcc_unreachable ();
    }
    }
 
 
  update_stmt (stmt);
  update_stmt (stmt);
}
}
 
 
/* Process one statement.  If we identify a complex operation, expand it.  */
/* Process one statement.  If we identify a complex operation, expand it.  */
 
 
static void
static void
expand_complex_operations_1 (block_stmt_iterator *bsi)
expand_complex_operations_1 (block_stmt_iterator *bsi)
{
{
  tree stmt = bsi_stmt (*bsi);
  tree stmt = bsi_stmt (*bsi);
  tree rhs, type, inner_type;
  tree rhs, type, inner_type;
  tree ac, ar, ai, bc, br, bi;
  tree ac, ar, ai, bc, br, bi;
  complex_lattice_t al, bl;
  complex_lattice_t al, bl;
  enum tree_code code;
  enum tree_code code;
 
 
  switch (TREE_CODE (stmt))
  switch (TREE_CODE (stmt))
    {
    {
    case RETURN_EXPR:
    case RETURN_EXPR:
      stmt = TREE_OPERAND (stmt, 0);
      stmt = TREE_OPERAND (stmt, 0);
      if (!stmt)
      if (!stmt)
        return;
        return;
      if (TREE_CODE (stmt) != MODIFY_EXPR)
      if (TREE_CODE (stmt) != MODIFY_EXPR)
        return;
        return;
      /* FALLTHRU */
      /* FALLTHRU */
 
 
    case MODIFY_EXPR:
    case MODIFY_EXPR:
      rhs = TREE_OPERAND (stmt, 1);
      rhs = TREE_OPERAND (stmt, 1);
      break;
      break;
 
 
    case COND_EXPR:
    case COND_EXPR:
      rhs = TREE_OPERAND (stmt, 0);
      rhs = TREE_OPERAND (stmt, 0);
      break;
      break;
 
 
    default:
    default:
      return;
      return;
    }
    }
 
 
  type = TREE_TYPE (rhs);
  type = TREE_TYPE (rhs);
  code = TREE_CODE (rhs);
  code = TREE_CODE (rhs);
 
 
  /* Initial filter for operations we handle.  */
  /* Initial filter for operations we handle.  */
  switch (code)
  switch (code)
    {
    {
    case PLUS_EXPR:
    case PLUS_EXPR:
    case MINUS_EXPR:
    case MINUS_EXPR:
    case MULT_EXPR:
    case MULT_EXPR:
    case TRUNC_DIV_EXPR:
    case TRUNC_DIV_EXPR:
    case CEIL_DIV_EXPR:
    case CEIL_DIV_EXPR:
    case FLOOR_DIV_EXPR:
    case FLOOR_DIV_EXPR:
    case ROUND_DIV_EXPR:
    case ROUND_DIV_EXPR:
    case RDIV_EXPR:
    case RDIV_EXPR:
    case NEGATE_EXPR:
    case NEGATE_EXPR:
    case CONJ_EXPR:
    case CONJ_EXPR:
      if (TREE_CODE (type) != COMPLEX_TYPE)
      if (TREE_CODE (type) != COMPLEX_TYPE)
        return;
        return;
      inner_type = TREE_TYPE (type);
      inner_type = TREE_TYPE (type);
      break;
      break;
 
 
    case EQ_EXPR:
    case EQ_EXPR:
    case NE_EXPR:
    case NE_EXPR:
      inner_type = TREE_TYPE (TREE_OPERAND (rhs, 1));
      inner_type = TREE_TYPE (TREE_OPERAND (rhs, 1));
      if (TREE_CODE (inner_type) != COMPLEX_TYPE)
      if (TREE_CODE (inner_type) != COMPLEX_TYPE)
        return;
        return;
      break;
      break;
 
 
    default:
    default:
      {
      {
        tree lhs = TREE_OPERAND (stmt, 0);
        tree lhs = TREE_OPERAND (stmt, 0);
        tree rhs = TREE_OPERAND (stmt, 1);
        tree rhs = TREE_OPERAND (stmt, 1);
 
 
        if (TREE_CODE (type) == COMPLEX_TYPE)
        if (TREE_CODE (type) == COMPLEX_TYPE)
          expand_complex_move (bsi, stmt, type, lhs, rhs);
          expand_complex_move (bsi, stmt, type, lhs, rhs);
        else if ((TREE_CODE (rhs) == REALPART_EXPR
        else if ((TREE_CODE (rhs) == REALPART_EXPR
                  || TREE_CODE (rhs) == IMAGPART_EXPR)
                  || TREE_CODE (rhs) == IMAGPART_EXPR)
                 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
                 && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
          {
          {
            TREE_OPERAND (stmt, 1)
            TREE_OPERAND (stmt, 1)
              = extract_component (bsi, TREE_OPERAND (rhs, 0),
              = extract_component (bsi, TREE_OPERAND (rhs, 0),
                                   TREE_CODE (rhs) == IMAGPART_EXPR, false);
                                   TREE_CODE (rhs) == IMAGPART_EXPR, false);
            update_stmt (stmt);
            update_stmt (stmt);
          }
          }
      }
      }
      return;
      return;
    }
    }
 
 
  /* Extract the components of the two complex values.  Make sure and
  /* Extract the components of the two complex values.  Make sure and
     handle the common case of the same value used twice specially.  */
     handle the common case of the same value used twice specially.  */
  ac = TREE_OPERAND (rhs, 0);
  ac = TREE_OPERAND (rhs, 0);
  ar = extract_component (bsi, ac, 0, true);
  ar = extract_component (bsi, ac, 0, true);
  ai = extract_component (bsi, ac, 1, true);
  ai = extract_component (bsi, ac, 1, true);
 
 
  if (TREE_CODE_CLASS (code) == tcc_unary)
  if (TREE_CODE_CLASS (code) == tcc_unary)
    bc = br = bi = NULL;
    bc = br = bi = NULL;
  else
  else
    {
    {
      bc = TREE_OPERAND (rhs, 1);
      bc = TREE_OPERAND (rhs, 1);
      if (ac == bc)
      if (ac == bc)
        br = ar, bi = ai;
        br = ar, bi = ai;
      else
      else
        {
        {
          br = extract_component (bsi, bc, 0, true);
          br = extract_component (bsi, bc, 0, true);
          bi = extract_component (bsi, bc, 1, true);
          bi = extract_component (bsi, bc, 1, true);
        }
        }
    }
    }
 
 
  if (in_ssa_p)
  if (in_ssa_p)
    {
    {
      al = find_lattice_value (ac);
      al = find_lattice_value (ac);
      if (al == UNINITIALIZED)
      if (al == UNINITIALIZED)
        al = VARYING;
        al = VARYING;
 
 
      if (TREE_CODE_CLASS (code) == tcc_unary)
      if (TREE_CODE_CLASS (code) == tcc_unary)
        bl = UNINITIALIZED;
        bl = UNINITIALIZED;
      else if (ac == bc)
      else if (ac == bc)
        bl = al;
        bl = al;
      else
      else
        {
        {
          bl = find_lattice_value (bc);
          bl = find_lattice_value (bc);
          if (bl == UNINITIALIZED)
          if (bl == UNINITIALIZED)
            bl = VARYING;
            bl = VARYING;
        }
        }
    }
    }
  else
  else
    al = bl = VARYING;
    al = bl = VARYING;
 
 
  switch (code)
  switch (code)
    {
    {
    case PLUS_EXPR:
    case PLUS_EXPR:
    case MINUS_EXPR:
    case MINUS_EXPR:
      expand_complex_addition (bsi, inner_type, ar, ai, br, bi, code, al, bl);
      expand_complex_addition (bsi, inner_type, ar, ai, br, bi, code, al, bl);
      break;
      break;
 
 
    case MULT_EXPR:
    case MULT_EXPR:
      expand_complex_multiplication (bsi, inner_type, ar, ai, br, bi, al, bl);
      expand_complex_multiplication (bsi, inner_type, ar, ai, br, bi, al, bl);
      break;
      break;
 
 
    case TRUNC_DIV_EXPR:
    case TRUNC_DIV_EXPR:
    case CEIL_DIV_EXPR:
    case CEIL_DIV_EXPR:
    case FLOOR_DIV_EXPR:
    case FLOOR_DIV_EXPR:
    case ROUND_DIV_EXPR:
    case ROUND_DIV_EXPR:
    case RDIV_EXPR:
    case RDIV_EXPR:
      expand_complex_division (bsi, inner_type, ar, ai, br, bi, code, al, bl);
      expand_complex_division (bsi, inner_type, ar, ai, br, bi, code, al, bl);
      break;
      break;
 
 
    case NEGATE_EXPR:
    case NEGATE_EXPR:
      expand_complex_negation (bsi, inner_type, ar, ai);
      expand_complex_negation (bsi, inner_type, ar, ai);
      break;
      break;
 
 
    case CONJ_EXPR:
    case CONJ_EXPR:
      expand_complex_conjugate (bsi, inner_type, ar, ai);
      expand_complex_conjugate (bsi, inner_type, ar, ai);
      break;
      break;
 
 
    case EQ_EXPR:
    case EQ_EXPR:
    case NE_EXPR:
    case NE_EXPR:
      expand_complex_comparison (bsi, ar, ai, br, bi, code);
      expand_complex_comparison (bsi, ar, ai, br, bi, code);
      break;
      break;
 
 
    default:
    default:
      gcc_unreachable ();
      gcc_unreachable ();
    }
    }
}
}
 
 


/* Entry point for complex operation lowering during optimization.  */
/* Entry point for complex operation lowering during optimization.  */
 
 
static unsigned int
static unsigned int
tree_lower_complex (void)
tree_lower_complex (void)
{
{
  int old_last_basic_block;
  int old_last_basic_block;
  block_stmt_iterator bsi;
  block_stmt_iterator bsi;
  basic_block bb;
  basic_block bb;
 
 
  if (!init_dont_simulate_again ())
  if (!init_dont_simulate_again ())
    return 0;
    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,
  VEC_safe_grow (complex_lattice_t, heap,
                 complex_lattice_values, num_ssa_names);
                 complex_lattice_values, num_ssa_names);
  memset (VEC_address (complex_lattice_t, complex_lattice_values), 0,
  memset (VEC_address (complex_lattice_t, complex_lattice_values), 0,
          num_ssa_names * sizeof(complex_lattice_t));
          num_ssa_names * sizeof(complex_lattice_t));
 
 
  init_parameter_lattice_values ();
  init_parameter_lattice_values ();
  ssa_propagate (complex_visit_stmt, complex_visit_phi);
  ssa_propagate (complex_visit_stmt, complex_visit_phi);
 
 
  complex_variable_components = htab_create (10,  int_tree_map_hash,
  complex_variable_components = htab_create (10,  int_tree_map_hash,
                                             int_tree_map_eq, free);
                                             int_tree_map_eq, free);
 
 
  complex_ssa_name_components = VEC_alloc (tree, heap, 2*num_ssa_names);
  complex_ssa_name_components = VEC_alloc (tree, heap, 2*num_ssa_names);
  VEC_safe_grow (tree, heap, complex_ssa_name_components, 2*num_ssa_names);
  VEC_safe_grow (tree, heap, complex_ssa_name_components, 2*num_ssa_names);
  memset (VEC_address (tree, complex_ssa_name_components), 0,
  memset (VEC_address (tree, complex_ssa_name_components), 0,
          2 * num_ssa_names * sizeof(tree));
          2 * num_ssa_names * sizeof(tree));
 
 
  update_parameter_components ();
  update_parameter_components ();
 
 
  /* ??? Ideally we'd traverse the blocks in breadth-first order.  */
  /* ??? Ideally we'd traverse the blocks in breadth-first order.  */
  old_last_basic_block = last_basic_block;
  old_last_basic_block = last_basic_block;
  FOR_EACH_BB (bb)
  FOR_EACH_BB (bb)
    {
    {
      if (bb->index >= old_last_basic_block)
      if (bb->index >= old_last_basic_block)
        continue;
        continue;
      update_phi_components (bb);
      update_phi_components (bb);
      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
        expand_complex_operations_1 (&bsi);
        expand_complex_operations_1 (&bsi);
    }
    }
 
 
  bsi_commit_edge_inserts ();
  bsi_commit_edge_inserts ();
 
 
  htab_delete (complex_variable_components);
  htab_delete (complex_variable_components);
  VEC_free (tree, heap, complex_ssa_name_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;
  return 0;
}
}
 
 
struct tree_opt_pass pass_lower_complex =
struct tree_opt_pass pass_lower_complex =
{
{
  "cplxlower",                          /* name */
  "cplxlower",                          /* name */
  0,                                     /* gate */
  0,                                     /* gate */
  tree_lower_complex,                   /* execute */
  tree_lower_complex,                   /* execute */
  NULL,                                 /* sub */
  NULL,                                 /* sub */
  NULL,                                 /* next */
  NULL,                                 /* next */
  0,                                     /* static_pass_number */
  0,                                     /* static_pass_number */
  0,                                     /* tv_id */
  0,                                     /* tv_id */
  PROP_ssa,                             /* properties_required */
  PROP_ssa,                             /* properties_required */
  0,                                     /* properties_provided */
  0,                                     /* properties_provided */
  PROP_smt_usage,                       /* properties_destroyed */
  PROP_smt_usage,                       /* properties_destroyed */
  0,                                     /* todo_flags_start */
  0,                                     /* todo_flags_start */
  TODO_dump_func | TODO_ggc_collect
  TODO_dump_func | TODO_ggc_collect
  | TODO_update_smt_usage
  | TODO_update_smt_usage
  | TODO_update_ssa
  | TODO_update_ssa
  | TODO_verify_stmts,                  /* todo_flags_finish */
  | TODO_verify_stmts,                  /* todo_flags_finish */
  0                                      /* letter */
  0                                      /* letter */
};
};
 
 


/* Entry point for complex operation lowering without optimization.  */
/* Entry point for complex operation lowering without optimization.  */
 
 
static unsigned int
static unsigned int
tree_lower_complex_O0 (void)
tree_lower_complex_O0 (void)
{
{
  int old_last_basic_block = last_basic_block;
  int old_last_basic_block = last_basic_block;
  block_stmt_iterator bsi;
  block_stmt_iterator bsi;
  basic_block bb;
  basic_block bb;
 
 
  FOR_EACH_BB (bb)
  FOR_EACH_BB (bb)
    {
    {
      if (bb->index >= old_last_basic_block)
      if (bb->index >= old_last_basic_block)
        continue;
        continue;
      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
      for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
        expand_complex_operations_1 (&bsi);
        expand_complex_operations_1 (&bsi);
    }
    }
  return 0;
  return 0;
}
}
 
 
static bool
static bool
gate_no_optimization (void)
gate_no_optimization (void)
{
{
  /* With errors, normal optimization passes are not run.  If we don't
  /* With errors, normal optimization passes are not run.  If we don't
     lower complex operations at all, rtl expansion will abort.  */
     lower complex operations at all, rtl expansion will abort.  */
  return optimize == 0 || sorrycount || errorcount;
  return optimize == 0 || sorrycount || errorcount;
}
}
 
 
struct tree_opt_pass pass_lower_complex_O0 =
struct tree_opt_pass pass_lower_complex_O0 =
{
{
  "cplxlower0",                         /* name */
  "cplxlower0",                         /* name */
  gate_no_optimization,                 /* gate */
  gate_no_optimization,                 /* gate */
  tree_lower_complex_O0,                /* execute */
  tree_lower_complex_O0,                /* execute */
  NULL,                                 /* sub */
  NULL,                                 /* sub */
  NULL,                                 /* next */
  NULL,                                 /* next */
  0,                                     /* static_pass_number */
  0,                                     /* static_pass_number */
  0,                                     /* tv_id */
  0,                                     /* tv_id */
  PROP_cfg,                             /* properties_required */
  PROP_cfg,                             /* properties_required */
  0,                                     /* properties_provided */
  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_verify_stmts,                /* todo_flags_finish */
    | TODO_verify_stmts,                /* todo_flags_finish */
  0                                      /* letter */
  0                                      /* letter */
};
};
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.