LCOV - code coverage report
Current view: top level - gcc - tree-complex.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 853 939 90.8 %
Date: 2020-03-28 11:57:23 Functions: 38 40 95.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Lower complex number operations to scalar operations.
       2                 :            :    Copyright (C) 2004-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it
       7                 :            : under the terms of the GNU General Public License as published by the
       8                 :            : Free Software Foundation; either version 3, or (at your option) any
       9                 :            : later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT
      12                 :            : ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "backend.h"
      24                 :            : #include "rtl.h"
      25                 :            : #include "tree.h"
      26                 :            : #include "gimple.h"
      27                 :            : #include "cfghooks.h"
      28                 :            : #include "tree-pass.h"
      29                 :            : #include "ssa.h"
      30                 :            : #include "fold-const.h"
      31                 :            : #include "stor-layout.h"
      32                 :            : #include "tree-eh.h"
      33                 :            : #include "gimplify.h"
      34                 :            : #include "gimple-iterator.h"
      35                 :            : #include "gimplify-me.h"
      36                 :            : #include "tree-cfg.h"
      37                 :            : #include "tree-dfa.h"
      38                 :            : #include "tree-ssa.h"
      39                 :            : #include "tree-ssa-propagate.h"
      40                 :            : #include "tree-hasher.h"
      41                 :            : #include "cfgloop.h"
      42                 :            : #include "cfganal.h"
      43                 :            : 
      44                 :            : 
      45                 :            : /* For each complex ssa name, a lattice value.  We're interested in finding
      46                 :            :    out whether a complex number is degenerate in some way, having only real
      47                 :            :    or only complex parts.  */
      48                 :            : 
      49                 :            : enum
      50                 :            : {
      51                 :            :   UNINITIALIZED = 0,
      52                 :            :   ONLY_REAL = 1,
      53                 :            :   ONLY_IMAG = 2,
      54                 :            :   VARYING = 3
      55                 :            : };
      56                 :            : 
      57                 :            : /* The type complex_lattice_t holds combinations of the above
      58                 :            :    constants.  */
      59                 :            : typedef int complex_lattice_t;
      60                 :            : 
      61                 :            : #define PAIR(a, b)  ((a) << 2 | (b))
      62                 :            : 
      63                 :       3425 : class complex_propagate : public ssa_propagation_engine
      64                 :            : {
      65                 :            :   enum ssa_prop_result visit_stmt (gimple *, edge *, tree *) FINAL OVERRIDE;
      66                 :            :   enum ssa_prop_result visit_phi (gphi *) FINAL OVERRIDE;
      67                 :            : };
      68                 :            : 
      69                 :            : static vec<complex_lattice_t> complex_lattice_values;
      70                 :            : 
      71                 :            : /* For each complex variable, a pair of variables for the components exists in
      72                 :            :    the hashtable.  */
      73                 :            : static int_tree_htab_type *complex_variable_components;
      74                 :            : 
      75                 :            : /* For each complex SSA_NAME, a pair of ssa names for the components.  */
      76                 :            : static vec<tree> complex_ssa_name_components;
      77                 :            : 
      78                 :            : /* Vector of PHI triplets (original complex PHI and corresponding real and
      79                 :            :    imag PHIs if real and/or imag PHIs contain temporarily
      80                 :            :    non-SSA_NAME/non-invariant args that need to be replaced by SSA_NAMEs.  */
      81                 :            : static vec<gphi *> phis_to_revisit;
      82                 :            : 
      83                 :            : /* BBs that need EH cleanup.  */
      84                 :            : static bitmap need_eh_cleanup;
      85                 :            : 
      86                 :            : /* Lookup UID in the complex_variable_components hashtable and return the
      87                 :            :    associated tree.  */
      88                 :            : static tree
      89                 :      30511 : cvc_lookup (unsigned int uid)
      90                 :            : {
      91                 :      30511 :   struct int_tree_map in;
      92                 :      30511 :   in.uid = uid;
      93                 :          0 :   return complex_variable_components->find_with_hash (in, uid).to;
      94                 :            : }
      95                 :            : 
      96                 :            : /* Insert the pair UID, TO into the complex_variable_components hashtable.  */
      97                 :            : 
      98                 :            : static void
      99                 :       9332 : cvc_insert (unsigned int uid, tree to)
     100                 :            : {
     101                 :       9332 :   int_tree_map h;
     102                 :       9332 :   int_tree_map *loc;
     103                 :            : 
     104                 :       9332 :   h.uid = uid;
     105                 :          0 :   loc = complex_variable_components->find_slot_with_hash (h, uid, INSERT);
     106                 :       9332 :   loc->uid = uid;
     107                 :       9332 :   loc->to = to;
     108                 :       9332 : }
     109                 :            : 
     110                 :            : /* Return true if T is not a zero constant.  In the case of real values,
     111                 :            :    we're only interested in +0.0.  */
     112                 :            : 
     113                 :            : static int
     114                 :      80470 : some_nonzerop (tree t)
     115                 :            : {
     116                 :      80470 :   int zerop = false;
     117                 :            : 
     118                 :            :   /* Operations with real or imaginary part of a complex number zero
     119                 :            :      cannot be treated the same as operations with a real or imaginary
     120                 :            :      operand if we care about the signs of zeros in the result.  */
     121                 :      80470 :   if (TREE_CODE (t) == REAL_CST && !flag_signed_zeros)
     122                 :       2384 :     zerop = real_identical (&TREE_REAL_CST (t), &dconst0);
     123                 :      78086 :   else if (TREE_CODE (t) == FIXED_CST)
     124                 :          0 :     zerop = fixed_zerop (t);
     125                 :      78086 :   else if (TREE_CODE (t) == INTEGER_CST)
     126                 :       7045 :     zerop = integer_zerop (t);
     127                 :            : 
     128                 :      80470 :   return !zerop;
     129                 :            : }
     130                 :            : 
     131                 :            : 
     132                 :            : /* Compute a lattice value from the components of a complex type REAL
     133                 :            :    and IMAG.  */
     134                 :            : 
     135                 :            : static complex_lattice_t
     136                 :      40235 : find_lattice_value_parts (tree real, tree imag)
     137                 :            : {
     138                 :      40235 :   int r, i;
     139                 :      40235 :   complex_lattice_t ret;
     140                 :            : 
     141                 :      40235 :   r = some_nonzerop (real);
     142                 :      40235 :   i = some_nonzerop (imag);
     143                 :      40235 :   ret = r * ONLY_REAL + i * ONLY_IMAG;
     144                 :            : 
     145                 :            :   /* ??? On occasion we could do better than mapping 0+0i to real, but we
     146                 :            :      certainly don't want to leave it UNINITIALIZED, which eventually gets
     147                 :            :      mapped to VARYING.  */
     148                 :      40235 :   if (ret == UNINITIALIZED)
     149                 :       1211 :     ret = ONLY_REAL;
     150                 :            : 
     151                 :      40235 :   return ret;
     152                 :            : }
     153                 :            : 
     154                 :            : 
     155                 :            : /* Compute a lattice value from gimple_val T.  */
     156                 :            : 
     157                 :            : static complex_lattice_t
     158                 :     573297 : find_lattice_value (tree t)
     159                 :            : {
     160                 :     573297 :   tree real, imag;
     161                 :            : 
     162                 :     573297 :   switch (TREE_CODE (t))
     163                 :            :     {
     164                 :     542179 :     case SSA_NAME:
     165                 :     542179 :       return complex_lattice_values[SSA_NAME_VERSION (t)];
     166                 :            : 
     167                 :      31118 :     case COMPLEX_CST:
     168                 :      31118 :       real = TREE_REALPART (t);
     169                 :      31118 :       imag = TREE_IMAGPART (t);
     170                 :      31118 :       break;
     171                 :            : 
     172                 :          0 :     default:
     173                 :          0 :       gcc_unreachable ();
     174                 :            :     }
     175                 :            : 
     176                 :      31118 :   return find_lattice_value_parts (real, imag);
     177                 :            : }
     178                 :            : 
     179                 :            : /* Determine if LHS is something for which we're interested in seeing
     180                 :            :    simulation results.  */
     181                 :            : 
     182                 :            : static bool
     183                 :   24685700 : is_complex_reg (tree lhs)
     184                 :            : {
     185                 :   24685700 :   return TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE && is_gimple_reg (lhs);
     186                 :            : }
     187                 :            : 
     188                 :            : /* Mark the incoming parameters to the function as VARYING.  */
     189                 :            : 
     190                 :            : static void
     191                 :       3425 : init_parameter_lattice_values (void)
     192                 :            : {
     193                 :       3425 :   tree parm, ssa_name;
     194                 :            : 
     195                 :       9228 :   for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = DECL_CHAIN (parm))
     196                 :       5803 :     if (is_complex_reg (parm)
     197                 :       5803 :         && (ssa_name = ssa_default_def (cfun, parm)) != NULL_TREE)
     198                 :       1316 :       complex_lattice_values[SSA_NAME_VERSION (ssa_name)] = VARYING;
     199                 :       3425 : }
     200                 :            : 
     201                 :            : /* Initialize simulation state for each statement.  Return false if we
     202                 :            :    found no statements we want to simulate, and thus there's nothing
     203                 :            :    for the entire pass to do.  */
     204                 :            : 
     205                 :            : static bool
     206                 :     943372 : init_dont_simulate_again (void)
     207                 :            : {
     208                 :     943372 :   basic_block bb;
     209                 :     943372 :   bool saw_a_complex_op = false;
     210                 :            : 
     211                 :    9251820 :   FOR_EACH_BB_FN (bb, cfun)
     212                 :            :     {
     213                 :   11424100 :       for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi);
     214                 :    3115600 :            gsi_next (&gsi))
     215                 :            :         {
     216                 :    3115600 :           gphi *phi = gsi.phi ();
     217                 :    3115600 :           prop_set_simulate_again (phi,
     218                 :    3115600 :                                    is_complex_reg (gimple_phi_result (phi)));
     219                 :            :         }
     220                 :            : 
     221                 :   76275800 :       for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi);
     222                 :   59658900 :            gsi_next (&gsi))
     223                 :            :         {
     224                 :   59658900 :           gimple *stmt;
     225                 :   59658900 :           tree op0, op1;
     226                 :   59658900 :           bool sim_again_p;
     227                 :            : 
     228                 :   59658900 :           stmt = gsi_stmt (gsi);
     229                 :   59658900 :           op0 = op1 = NULL_TREE;
     230                 :            : 
     231                 :            :           /* Most control-altering statements must be initially
     232                 :            :              simulated, else we won't cover the entire cfg.  */
     233                 :   59658900 :           sim_again_p = stmt_ends_bb_p (stmt);
     234                 :            : 
     235                 :   59658900 :           switch (gimple_code (stmt))
     236                 :            :             {
     237                 :    4510080 :             case GIMPLE_CALL:
     238                 :    4510080 :               if (gimple_call_lhs (stmt))
     239                 :    1633870 :                 sim_again_p = is_complex_reg (gimple_call_lhs (stmt));
     240                 :            :               break;
     241                 :            : 
     242                 :   19860200 :             case GIMPLE_ASSIGN:
     243                 :   19860200 :               sim_again_p = is_complex_reg (gimple_assign_lhs (stmt));
     244                 :   19860200 :               if (gimple_assign_rhs_code (stmt) == REALPART_EXPR
     245                 :   19860200 :                   || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR)
     246                 :     167315 :                 op0 = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
     247                 :            :               else
     248                 :   19692900 :                 op0 = gimple_assign_rhs1 (stmt);
     249                 :   19860200 :               if (gimple_num_ops (stmt) > 2)
     250                 :    4147130 :                 op1 = gimple_assign_rhs2 (stmt);
     251                 :            :               break;
     252                 :            : 
     253                 :    3420510 :             case GIMPLE_COND:
     254                 :    3420510 :               op0 = gimple_cond_lhs (stmt);
     255                 :    3420510 :               op1 = gimple_cond_rhs (stmt);
     256                 :    3420510 :               break;
     257                 :            : 
     258                 :            :             default:
     259                 :            :               break;
     260                 :            :             }
     261                 :            : 
     262                 :   59658900 :           if (op0 || op1)
     263                 :   23280700 :             switch (gimple_expr_code (stmt))
     264                 :            :               {
     265                 :    5316620 :               case EQ_EXPR:
     266                 :    5316620 :               case NE_EXPR:
     267                 :    5316620 :               case PLUS_EXPR:
     268                 :    5316620 :               case MINUS_EXPR:
     269                 :    5316620 :               case MULT_EXPR:
     270                 :    5316620 :               case TRUNC_DIV_EXPR:
     271                 :    5316620 :               case CEIL_DIV_EXPR:
     272                 :    5316620 :               case FLOOR_DIV_EXPR:
     273                 :    5316620 :               case ROUND_DIV_EXPR:
     274                 :    5316620 :               case RDIV_EXPR:
     275                 :    5316620 :                 if (TREE_CODE (TREE_TYPE (op0)) == COMPLEX_TYPE
     276                 :   10591800 :                     || TREE_CODE (TREE_TYPE (op1)) == COMPLEX_TYPE)
     277                 :            :                   saw_a_complex_op = true;
     278                 :            :                 break;
     279                 :            : 
     280                 :      35991 :               case NEGATE_EXPR:
     281                 :      35991 :               case CONJ_EXPR:
     282                 :      35991 :                 if (TREE_CODE (TREE_TYPE (op0)) == COMPLEX_TYPE)
     283                 :        326 :                   saw_a_complex_op = true;
     284                 :            :                 break;
     285                 :            : 
     286                 :     167313 :               case REALPART_EXPR:
     287                 :     167313 :               case IMAGPART_EXPR:
     288                 :            :                 /* The total store transformation performed during
     289                 :            :                   gimplification creates such uninitialized loads
     290                 :            :                   and we need to lower the statement to be able
     291                 :            :                   to fix things up.  */
     292                 :     167313 :                 if (TREE_CODE (op0) == SSA_NAME
     293                 :     167313 :                     && ssa_undefined_value_p (op0))
     294                 :            :                   saw_a_complex_op = true;
     295                 :            :                 break;
     296                 :            : 
     297                 :            :               default:
     298                 :            :                 break;
     299                 :            :               }
     300                 :            : 
     301                 :   59658900 :           prop_set_simulate_again (stmt, sim_again_p);
     302                 :            :         }
     303                 :            :     }
     304                 :            : 
     305                 :     943372 :   return saw_a_complex_op;
     306                 :            : }
     307                 :            : 
     308                 :            : 
     309                 :            : /* Evaluate statement STMT against the complex lattice defined above.  */
     310                 :            : 
     311                 :            : enum ssa_prop_result
     312                 :     207669 : complex_propagate::visit_stmt (gimple *stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
     313                 :            :                                tree *result_p)
     314                 :            : {
     315                 :     207669 :   complex_lattice_t new_l, old_l, op1_l, op2_l;
     316                 :     207669 :   unsigned int ver;
     317                 :     207669 :   tree lhs;
     318                 :            : 
     319                 :     207669 :   lhs = gimple_get_lhs (stmt);
     320                 :            :   /* Skip anything but GIMPLE_ASSIGN and GIMPLE_CALL with a lhs.  */
     321                 :     207669 :   if (!lhs)
     322                 :            :     return SSA_PROP_VARYING;
     323                 :            : 
     324                 :            :   /* These conditions should be satisfied due to the initial filter
     325                 :            :      set up in init_dont_simulate_again.  */
     326                 :      79927 :   gcc_assert (TREE_CODE (lhs) == SSA_NAME);
     327                 :      79927 :   gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
     328                 :            : 
     329                 :      79927 :   *result_p = lhs;
     330                 :      79927 :   ver = SSA_NAME_VERSION (lhs);
     331                 :      79927 :   old_l = complex_lattice_values[ver];
     332                 :            : 
     333                 :      79927 :   switch (gimple_expr_code (stmt))
     334                 :            :     {
     335                 :       1585 :     case SSA_NAME:
     336                 :       1585 :     case COMPLEX_CST:
     337                 :       1585 :       new_l = find_lattice_value (gimple_assign_rhs1 (stmt));
     338                 :       1585 :       break;
     339                 :            : 
     340                 :       9117 :     case COMPLEX_EXPR:
     341                 :       9117 :       new_l = find_lattice_value_parts (gimple_assign_rhs1 (stmt),
     342                 :            :                                         gimple_assign_rhs2 (stmt));
     343                 :       9117 :       break;
     344                 :            : 
     345                 :       8542 :     case PLUS_EXPR:
     346                 :       8542 :     case MINUS_EXPR:
     347                 :       8542 :       op1_l = find_lattice_value (gimple_assign_rhs1 (stmt));
     348                 :       8542 :       op2_l = find_lattice_value (gimple_assign_rhs2 (stmt));
     349                 :            : 
     350                 :            :       /* We've set up the lattice values such that IOR neatly
     351                 :            :          models addition.  */
     352                 :       8542 :       new_l = op1_l | op2_l;
     353                 :       8542 :       break;
     354                 :            : 
     355                 :       8164 :     case MULT_EXPR:
     356                 :       8164 :     case RDIV_EXPR:
     357                 :       8164 :     case TRUNC_DIV_EXPR:
     358                 :       8164 :     case CEIL_DIV_EXPR:
     359                 :       8164 :     case FLOOR_DIV_EXPR:
     360                 :       8164 :     case ROUND_DIV_EXPR:
     361                 :       8164 :       op1_l = find_lattice_value (gimple_assign_rhs1 (stmt));
     362                 :       8164 :       op2_l = find_lattice_value (gimple_assign_rhs2 (stmt));
     363                 :            : 
     364                 :            :       /* Obviously, if either varies, so does the result.  */
     365                 :       8164 :       if (op1_l == VARYING || op2_l == VARYING)
     366                 :            :         new_l = VARYING;
     367                 :            :       /* Don't prematurely promote variables if we've not yet seen
     368                 :            :          their inputs.  */
     369                 :         17 :       else if (op1_l == UNINITIALIZED)
     370                 :            :         new_l = op2_l;
     371                 :         15 :       else if (op2_l == UNINITIALIZED)
     372                 :            :         new_l = op1_l;
     373                 :            :       else
     374                 :            :         {
     375                 :            :           /* At this point both numbers have only one component. If the
     376                 :            :              numbers are of opposite kind, the result is imaginary,
     377                 :            :              otherwise the result is real. The add/subtract translates
     378                 :            :              the real/imag from/to 0/1; the ^ performs the comparison.  */
     379                 :         15 :           new_l = ((op1_l - ONLY_REAL) ^ (op2_l - ONLY_REAL)) + ONLY_REAL;
     380                 :            : 
     381                 :            :           /* Don't allow the lattice value to flip-flop indefinitely.  */
     382                 :         15 :           new_l |= old_l;
     383                 :            :         }
     384                 :            :       break;
     385                 :            : 
     386                 :        326 :     case NEGATE_EXPR:
     387                 :        326 :     case CONJ_EXPR:
     388                 :        326 :       new_l = find_lattice_value (gimple_assign_rhs1 (stmt));
     389                 :        326 :       break;
     390                 :            : 
     391                 :            :     default:
     392                 :            :       new_l = VARYING;
     393                 :            :       break;
     394                 :            :     }
     395                 :            : 
     396                 :            :   /* If nothing changed this round, let the propagator know.  */
     397                 :      79927 :   if (new_l == old_l)
     398                 :            :     return SSA_PROP_NOT_INTERESTING;
     399                 :            : 
     400                 :      79924 :   complex_lattice_values[ver] = new_l;
     401                 :      79924 :   return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
     402                 :            : }
     403                 :            : 
     404                 :            : /* Evaluate a PHI node against the complex lattice defined above.  */
     405                 :            : 
     406                 :            : enum ssa_prop_result
     407                 :       7195 : complex_propagate::visit_phi (gphi *phi)
     408                 :            : {
     409                 :       7195 :   complex_lattice_t new_l, old_l;
     410                 :       7195 :   unsigned int ver;
     411                 :       7195 :   tree lhs;
     412                 :       7195 :   int i;
     413                 :            : 
     414                 :       7195 :   lhs = gimple_phi_result (phi);
     415                 :            : 
     416                 :            :   /* This condition should be satisfied due to the initial filter
     417                 :            :      set up in init_dont_simulate_again.  */
     418                 :       7195 :   gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
     419                 :            : 
     420                 :            :   /* We've set up the lattice values such that IOR neatly models PHI meet.  */
     421                 :       7195 :   new_l = UNINITIALIZED;
     422                 :      21782 :   for (i = gimple_phi_num_args (phi) - 1; i >= 0; --i)
     423                 :      14587 :     new_l |= find_lattice_value (gimple_phi_arg_def (phi, i));
     424                 :            : 
     425                 :       7195 :   ver = SSA_NAME_VERSION (lhs);
     426                 :       7195 :   old_l = complex_lattice_values[ver];
     427                 :            : 
     428                 :       7195 :   if (new_l == old_l)
     429                 :            :     return SSA_PROP_NOT_INTERESTING;
     430                 :            : 
     431                 :       7180 :   complex_lattice_values[ver] = new_l;
     432                 :       7180 :   return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
     433                 :            : }
     434                 :            : 
     435                 :            : /* Create one backing variable for a complex component of ORIG.  */
     436                 :            : 
     437                 :            : static tree
     438                 :       9332 : create_one_component_var (tree type, tree orig, const char *prefix,
     439                 :            :                           const char *suffix, enum tree_code code)
     440                 :            : {
     441                 :       9332 :   tree r = create_tmp_var (type, prefix);
     442                 :            : 
     443                 :       9332 :   DECL_SOURCE_LOCATION (r) = DECL_SOURCE_LOCATION (orig);
     444                 :       9332 :   DECL_ARTIFICIAL (r) = 1;
     445                 :            : 
     446                 :      18643 :   if (DECL_NAME (orig) && !DECL_IGNORED_P (orig))
     447                 :            :     {
     448                 :       9311 :       const char *name = IDENTIFIER_POINTER (DECL_NAME (orig));
     449                 :       9311 :       name = ACONCAT ((name, suffix, NULL));
     450                 :       9311 :       DECL_NAME (r) = get_identifier (name);
     451                 :            : 
     452                 :       9311 :       SET_DECL_DEBUG_EXPR (r, build1 (code, type, orig));
     453                 :       9311 :       DECL_HAS_DEBUG_EXPR_P (r) = 1;
     454                 :       9311 :       DECL_IGNORED_P (r) = 0;
     455                 :       9311 :       TREE_NO_WARNING (r) = TREE_NO_WARNING (orig);
     456                 :            :     }
     457                 :            :   else
     458                 :            :     {
     459                 :         21 :       DECL_IGNORED_P (r) = 1;
     460                 :         21 :       TREE_NO_WARNING (r) = 1;
     461                 :            :     }
     462                 :            : 
     463                 :       9332 :   return r;
     464                 :            : }
     465                 :            : 
     466                 :            : /* Retrieve a value for a complex component of VAR.  */
     467                 :            : 
     468                 :            : static tree
     469                 :      30511 : get_component_var (tree var, bool imag_p)
     470                 :            : {
     471                 :      30511 :   size_t decl_index = DECL_UID (var) * 2 + imag_p;
     472                 :      30511 :   tree ret = cvc_lookup (decl_index);
     473                 :            : 
     474                 :      30511 :   if (ret == NULL)
     475                 :            :     {
     476                 :      27968 :       ret = create_one_component_var (TREE_TYPE (TREE_TYPE (var)), var,
     477                 :            :                                       imag_p ? "CI" : "CR",
     478                 :            :                                       imag_p ? "$imag" : "$real",
     479                 :            :                                       imag_p ? IMAGPART_EXPR : REALPART_EXPR);
     480                 :       9332 :       cvc_insert (decl_index, ret);
     481                 :            :     }
     482                 :            : 
     483                 :      30511 :   return ret;
     484                 :            : }
     485                 :            : 
     486                 :            : /* Retrieve a value for a complex component of SSA_NAME.  */
     487                 :            : 
     488                 :            : static tree
     489                 :     277732 : get_component_ssa_name (tree ssa_name, bool imag_p)
     490                 :            : {
     491                 :     277732 :   complex_lattice_t lattice = find_lattice_value (ssa_name);
     492                 :     277732 :   size_t ssa_name_index;
     493                 :     277732 :   tree ret;
     494                 :            : 
     495                 :     416897 :   if (lattice == (imag_p ? ONLY_REAL : ONLY_IMAG))
     496                 :            :     {
     497                 :        203 :       tree inner_type = TREE_TYPE (TREE_TYPE (ssa_name));
     498                 :        203 :       if (SCALAR_FLOAT_TYPE_P (inner_type))
     499                 :         23 :         return build_real (inner_type, dconst0);
     500                 :            :       else
     501                 :        180 :         return build_int_cst (inner_type, 0);
     502                 :            :     }
     503                 :            : 
     504                 :     277529 :   ssa_name_index = SSA_NAME_VERSION (ssa_name) * 2 + imag_p;
     505                 :     277529 :   ret = complex_ssa_name_components[ssa_name_index];
     506                 :     277529 :   if (ret == NULL)
     507                 :            :     {
     508                 :      87716 :       if (SSA_NAME_VAR (ssa_name))
     509                 :      22768 :         ret = get_component_var (SSA_NAME_VAR (ssa_name), imag_p);
     510                 :            :       else
     511                 :      64948 :         ret = TREE_TYPE (TREE_TYPE (ssa_name));
     512                 :      87716 :       ret = make_ssa_name (ret);
     513                 :            : 
     514                 :            :       /* Copy some properties from the original.  In particular, whether it
     515                 :            :          is used in an abnormal phi, and whether it's uninitialized.  */
     516                 :      87716 :       SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ret)
     517                 :      87716 :         = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name);
     518                 :      87716 :       if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
     519                 :      90634 :           && TREE_CODE (SSA_NAME_VAR (ssa_name)) == VAR_DECL)
     520                 :            :         {
     521                 :        286 :           SSA_NAME_DEF_STMT (ret) = SSA_NAME_DEF_STMT (ssa_name);
     522                 :        572 :           set_ssa_default_def (cfun, SSA_NAME_VAR (ret), ret);
     523                 :            :         }
     524                 :            : 
     525                 :      87716 :       complex_ssa_name_components[ssa_name_index] = ret;
     526                 :            :     }
     527                 :            : 
     528                 :            :   return ret;
     529                 :            : }
     530                 :            : 
     531                 :            : /* Set a value for a complex component of SSA_NAME, return a
     532                 :            :    gimple_seq of stuff that needs doing.  */
     533                 :            : 
     534                 :            : static gimple_seq
     535                 :     162572 : set_component_ssa_name (tree ssa_name, bool imag_p, tree value)
     536                 :            : {
     537                 :     162572 :   complex_lattice_t lattice = find_lattice_value (ssa_name);
     538                 :     162572 :   size_t ssa_name_index;
     539                 :     162572 :   tree comp;
     540                 :     162572 :   gimple *last;
     541                 :     162572 :   gimple_seq list;
     542                 :            : 
     543                 :            :   /* We know the value must be zero, else there's a bug in our lattice
     544                 :            :      analysis.  But the value may well be a variable known to contain
     545                 :            :      zero.  We should be safe ignoring it.  */
     546                 :     243858 :   if (lattice == (imag_p ? ONLY_REAL : ONLY_IMAG))
     547                 :            :     return NULL;
     548                 :            : 
     549                 :            :   /* If we've already assigned an SSA_NAME to this component, then this
     550                 :            :      means that our walk of the basic blocks found a use before the set.
     551                 :            :      This is fine.  Now we should create an initialization for the value
     552                 :            :      we created earlier.  */
     553                 :     162298 :   ssa_name_index = SSA_NAME_VERSION (ssa_name) * 2 + imag_p;
     554                 :     162298 :   comp = complex_ssa_name_components[ssa_name_index];
     555                 :     162298 :   if (comp)
     556                 :            :     ;
     557                 :            : 
     558                 :            :   /* If we've nothing assigned, and the value we're given is already stable,
     559                 :            :      then install that as the value for this SSA_NAME.  This preemptively
     560                 :            :      copy-propagates the value, which avoids unnecessary memory allocation.  */
     561                 :     156263 :   else if (is_gimple_min_invariant (value)
     562                 :     161373 :            && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
     563                 :            :     {
     564                 :       5103 :       complex_ssa_name_components[ssa_name_index] = value;
     565                 :       5103 :       return NULL;
     566                 :            :     }
     567                 :     151160 :   else if (TREE_CODE (value) == SSA_NAME
     568                 :     234505 :            && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
     569                 :            :     {
     570                 :            :       /* Replace an anonymous base value with the variable from cvc_lookup.
     571                 :            :          This should result in better debug info.  */
     572                 :      83345 :       if (SSA_NAME_VAR (ssa_name)
     573                 :       8242 :           && (!SSA_NAME_VAR (value) || DECL_IGNORED_P (SSA_NAME_VAR (value)))
     574                 :       7901 :           && !DECL_IGNORED_P (SSA_NAME_VAR (ssa_name)))
     575                 :            :         {
     576                 :       7743 :           comp = get_component_var (SSA_NAME_VAR (ssa_name), imag_p);
     577                 :       7743 :           replace_ssa_name_symbol (value, comp);
     578                 :            :         }
     579                 :            : 
     580                 :      83345 :       complex_ssa_name_components[ssa_name_index] = value;
     581                 :      83345 :       return NULL;
     582                 :            :     }
     583                 :            : 
     584                 :            :   /* Finally, we need to stabilize the result by installing the value into
     585                 :            :      a new ssa name.  */
     586                 :            :   else
     587                 :      67815 :     comp = get_component_ssa_name (ssa_name, imag_p);
     588                 :            : 
     589                 :            :   /* Do all the work to assign VALUE to COMP.  */
     590                 :      73850 :   list = NULL;
     591                 :      73850 :   value = force_gimple_operand (value, &list, false, NULL);
     592                 :      73850 :   last =  gimple_build_assign (comp, value);
     593                 :      73850 :   gimple_seq_add_stmt (&list, last);
     594                 :      73850 :   gcc_assert (SSA_NAME_DEF_STMT (comp) == last);
     595                 :            : 
     596                 :      73850 :   return list;
     597                 :            : }
     598                 :            : 
     599                 :            : /* Extract the real or imaginary part of a complex variable or constant.
     600                 :            :    Make sure that it's a proper gimple_val and gimplify it if not.
     601                 :            :    Emit any new code before gsi.  */
     602                 :            : 
     603                 :            : static tree
     604                 :     325102 : extract_component (gimple_stmt_iterator *gsi, tree t, bool imagpart_p,
     605                 :            :                    bool gimple_p, bool phiarg_p = false)
     606                 :            : {
     607                 :     325102 :   switch (TREE_CODE (t))
     608                 :            :     {
     609                 :      54999 :     case COMPLEX_CST:
     610                 :     109998 :       return imagpart_p ? TREE_IMAGPART (t) : TREE_REALPART (t);
     611                 :            : 
     612                 :          0 :     case COMPLEX_EXPR:
     613                 :          0 :       gcc_unreachable ();
     614                 :            : 
     615                 :          0 :     case BIT_FIELD_REF:
     616                 :          0 :       {
     617                 :          0 :         tree inner_type = TREE_TYPE (TREE_TYPE (t));
     618                 :          0 :         t = unshare_expr (t);
     619                 :          0 :         TREE_TYPE (t) = inner_type;
     620                 :          0 :         TREE_OPERAND (t, 1) = TYPE_SIZE (inner_type);
     621                 :          0 :         if (imagpart_p)
     622                 :          0 :           TREE_OPERAND (t, 2) = size_binop (PLUS_EXPR, TREE_OPERAND (t, 2),
     623                 :            :                                             TYPE_SIZE (inner_type));
     624                 :          0 :         if (gimple_p)
     625                 :          0 :           t = force_gimple_operand_gsi (gsi, t, true, NULL, true,
     626                 :            :                                         GSI_SAME_STMT);
     627                 :            :         return t;
     628                 :            :       }
     629                 :            : 
     630                 :      73776 :     case VAR_DECL:
     631                 :      73776 :     case RESULT_DECL:
     632                 :      73776 :     case PARM_DECL:
     633                 :      73776 :     case COMPONENT_REF:
     634                 :      73776 :     case ARRAY_REF:
     635                 :      73776 :     case VIEW_CONVERT_EXPR:
     636                 :      73776 :     case MEM_REF:
     637                 :      73776 :       {
     638                 :      73776 :         tree inner_type = TREE_TYPE (TREE_TYPE (t));
     639                 :            : 
     640                 :     110694 :         t = build1 ((imagpart_p ? IMAGPART_EXPR : REALPART_EXPR),
     641                 :            :                     inner_type, unshare_expr (t));
     642                 :            : 
     643                 :      73776 :         if (gimple_p)
     644                 :      39676 :           t = force_gimple_operand_gsi (gsi, t, true, NULL, true,
     645                 :            :                                         GSI_SAME_STMT);
     646                 :            : 
     647                 :            :         return t;
     648                 :            :       }
     649                 :            : 
     650                 :     196327 :     case SSA_NAME:
     651                 :     196327 :       t = get_component_ssa_name (t, imagpart_p);
     652                 :     196327 :       if (TREE_CODE (t) == SSA_NAME && SSA_NAME_DEF_STMT (t) == NULL)
     653                 :       6606 :         gcc_assert (phiarg_p);
     654                 :            :       return t;
     655                 :            : 
     656                 :          0 :     default:
     657                 :          0 :       gcc_unreachable ();
     658                 :            :     }
     659                 :            : }
     660                 :            : 
     661                 :            : /* Update the complex components of the ssa name on the lhs of STMT.  */
     662                 :            : 
     663                 :            : static void
     664                 :      79896 : update_complex_components (gimple_stmt_iterator *gsi, gimple *stmt, tree r,
     665                 :            :                            tree i)
     666                 :            : {
     667                 :      79896 :   tree lhs;
     668                 :      79896 :   gimple_seq list;
     669                 :            : 
     670                 :      79896 :   lhs = gimple_get_lhs (stmt);
     671                 :            : 
     672                 :      79896 :   list = set_component_ssa_name (lhs, false, r);
     673                 :      79896 :   if (list)
     674                 :      35539 :     gsi_insert_seq_after (gsi, list, GSI_CONTINUE_LINKING);
     675                 :            : 
     676                 :      79896 :   list = set_component_ssa_name (lhs, true, i);
     677                 :      79896 :   if (list)
     678                 :      35531 :     gsi_insert_seq_after (gsi, list, GSI_CONTINUE_LINKING);
     679                 :      79896 : }
     680                 :            : 
     681                 :            : static void
     682                 :       1346 : update_complex_components_on_edge (edge e, tree lhs, tree r, tree i)
     683                 :            : {
     684                 :       1346 :   gimple_seq list;
     685                 :            : 
     686                 :       1346 :   list = set_component_ssa_name (lhs, false, r);
     687                 :       1346 :   if (list)
     688                 :       1346 :     gsi_insert_seq_on_edge (e, list);
     689                 :            : 
     690                 :       1346 :   list = set_component_ssa_name (lhs, true, i);
     691                 :       1346 :   if (list)
     692                 :       1346 :     gsi_insert_seq_on_edge (e, list);
     693                 :       1346 : }
     694                 :            : 
     695                 :            : 
     696                 :            : /* Update an assignment to a complex variable in place.  */
     697                 :            : 
     698                 :            : static void
     699                 :      47588 : update_complex_assignment (gimple_stmt_iterator *gsi, tree r, tree i)
     700                 :            : {
     701                 :      47588 :   gimple *old_stmt = gsi_stmt (*gsi);
     702                 :      47588 :   gimple_assign_set_rhs_with_ops (gsi, COMPLEX_EXPR, r, i);
     703                 :      47588 :   gimple *stmt = gsi_stmt (*gsi);
     704                 :      47588 :   update_stmt (stmt);
     705                 :      47588 :   if (maybe_clean_or_replace_eh_stmt (old_stmt, stmt))
     706                 :          9 :     bitmap_set_bit (need_eh_cleanup, gimple_bb (stmt)->index);
     707                 :            : 
     708                 :      47588 :   update_complex_components (gsi, gsi_stmt (*gsi), r, i);
     709                 :      47588 : }
     710                 :            : 
     711                 :            : 
     712                 :            : /* Generate code at the entry point of the function to initialize the
     713                 :            :    component variables for a complex parameter.  */
     714                 :            : 
     715                 :            : static void
     716                 :       3425 : update_parameter_components (void)
     717                 :            : {
     718                 :       3425 :   edge entry_edge = single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun));
     719                 :       3425 :   tree parm;
     720                 :            : 
     721                 :       9228 :   for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = DECL_CHAIN (parm))
     722                 :            :     {
     723                 :       5803 :       tree type = TREE_TYPE (parm);
     724                 :       5803 :       tree ssa_name, r, i;
     725                 :            : 
     726                 :       5803 :       if (TREE_CODE (type) != COMPLEX_TYPE || !is_gimple_reg (parm))
     727                 :       4478 :         continue;
     728                 :            : 
     729                 :       1325 :       type = TREE_TYPE (type);
     730                 :       1325 :       ssa_name = ssa_default_def (cfun, parm);
     731                 :       1325 :       if (!ssa_name)
     732                 :          9 :         continue;
     733                 :            : 
     734                 :       1316 :       r = build1 (REALPART_EXPR, type, ssa_name);
     735                 :       1316 :       i = build1 (IMAGPART_EXPR, type, ssa_name);
     736                 :       1316 :       update_complex_components_on_edge (entry_edge, ssa_name, r, i);
     737                 :            :     }
     738                 :       3425 : }
     739                 :            : 
     740                 :            : /* Generate code to set the component variables of a complex variable
     741                 :            :    to match the PHI statements in block BB.  */
     742                 :            : 
     743                 :            : static void
     744                 :     205471 : update_phi_components (basic_block bb)
     745                 :            : {
     746                 :     205471 :   gphi_iterator gsi;
     747                 :            : 
     748                 :     275695 :   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     749                 :            :     {
     750                 :      70224 :       gphi *phi = gsi.phi ();
     751                 :            : 
     752                 :      70224 :       if (is_complex_reg (gimple_phi_result (phi)))
     753                 :            :         {
     754                 :       6795 :           gphi *p[2] = { NULL, NULL };
     755                 :       6795 :           unsigned int i, j, n;
     756                 :       6795 :           bool revisit_phi = false;
     757                 :            : 
     758                 :      20385 :           for (j = 0; j < 2; j++)
     759                 :            :             {
     760                 :      13590 :               tree l = get_component_ssa_name (gimple_phi_result (phi), j > 0);
     761                 :      13590 :               if (TREE_CODE (l) == SSA_NAME)
     762                 :      13580 :                 p[j] = create_phi_node (l, bb);
     763                 :            :             }
     764                 :            : 
     765                 :      20582 :           for (i = 0, n = gimple_phi_num_args (phi); i < n; ++i)
     766                 :            :             {
     767                 :      13787 :               tree comp, arg = gimple_phi_arg_def (phi, i);
     768                 :      41361 :               for (j = 0; j < 2; j++)
     769                 :      27574 :                 if (p[j])
     770                 :            :                   {
     771                 :      27554 :                     comp = extract_component (NULL, arg, j > 0, false, true);
     772                 :      27554 :                     if (TREE_CODE (comp) == SSA_NAME
     773                 :      27554 :                         && SSA_NAME_DEF_STMT (comp) == NULL)
     774                 :            :                       {
     775                 :            :                         /* For the benefit of any gimple simplification during
     776                 :            :                            this pass that might walk SSA_NAME def stmts,
     777                 :            :                            don't add SSA_NAMEs without definitions into the
     778                 :            :                            PHI arguments, but put a decl in there instead
     779                 :            :                            temporarily, and revisit this PHI later on.  */
     780                 :       6606 :                         if (SSA_NAME_VAR (comp))
     781                 :      27554 :                           comp = SSA_NAME_VAR (comp);
     782                 :            :                         else
     783                 :        228 :                           comp = create_tmp_reg (TREE_TYPE (comp),
     784                 :            :                                                  get_name (comp));
     785                 :            :                         revisit_phi = true;
     786                 :            :                       }
     787                 :      27554 :                     SET_PHI_ARG_DEF (p[j], i, comp);
     788                 :            :                   }
     789                 :            :             }
     790                 :            : 
     791                 :       6795 :           if (revisit_phi)
     792                 :            :             {
     793                 :       3304 :               phis_to_revisit.safe_push (phi);
     794                 :       3304 :               phis_to_revisit.safe_push (p[0]);
     795                 :       3304 :               phis_to_revisit.safe_push (p[1]);
     796                 :            :             }
     797                 :            :         }
     798                 :            :     }
     799                 :     205471 : }
     800                 :            : 
     801                 :            : /* Expand a complex move to scalars.  */
     802                 :            : 
     803                 :            : static void
     804                 :      91791 : expand_complex_move (gimple_stmt_iterator *gsi, tree type)
     805                 :            : {
     806                 :      91791 :   tree inner_type = TREE_TYPE (type);
     807                 :      91791 :   tree r, i, lhs, rhs;
     808                 :      91791 :   gimple *stmt = gsi_stmt (*gsi);
     809                 :            : 
     810                 :      91791 :   if (is_gimple_assign (stmt))
     811                 :            :     {
     812                 :      87771 :       lhs = gimple_assign_lhs (stmt);
     813                 :      87771 :       if (gimple_num_ops (stmt) == 2)
     814                 :      78654 :         rhs = gimple_assign_rhs1 (stmt);
     815                 :            :       else
     816                 :            :         rhs = NULL_TREE;
     817                 :            :     }
     818                 :       4020 :   else if (is_gimple_call (stmt))
     819                 :            :     {
     820                 :       4020 :       lhs = gimple_call_lhs (stmt);
     821                 :       4020 :       rhs = NULL_TREE;
     822                 :            :     }
     823                 :            :   else
     824                 :          0 :     gcc_unreachable ();
     825                 :            : 
     826                 :      91791 :   if (TREE_CODE (lhs) == SSA_NAME)
     827                 :            :     {
     828                 :      62895 :       if (is_ctrl_altering_stmt (stmt))
     829                 :            :         {
     830                 :         30 :           edge e;
     831                 :            : 
     832                 :            :           /* The value is not assigned on the exception edges, so we need not
     833                 :            :              concern ourselves there.  We do need to update on the fallthru
     834                 :            :              edge.  Find it.  */
     835                 :         30 :           e = find_fallthru_edge (gsi_bb (*gsi)->succs);
     836                 :         30 :           if (!e)
     837                 :          0 :             gcc_unreachable ();
     838                 :            : 
     839                 :         30 :           r = build1 (REALPART_EXPR, inner_type, lhs);
     840                 :         30 :           i = build1 (IMAGPART_EXPR, inner_type, lhs);
     841                 :         30 :           update_complex_components_on_edge (e, lhs, r, i);
     842                 :            :         }
     843                 :      62865 :       else if (is_gimple_call (stmt)
     844                 :      58871 :                || gimple_has_side_effects (stmt)
     845                 :      95702 :                || gimple_assign_rhs_code (stmt) == PAREN_EXPR)
     846                 :            :         {
     847                 :      30367 :           r = build1 (REALPART_EXPR, inner_type, lhs);
     848                 :      30367 :           i = build1 (IMAGPART_EXPR, inner_type, lhs);
     849                 :      30367 :           update_complex_components (gsi, stmt, r, i);
     850                 :            :         }
     851                 :            :       else
     852                 :            :         {
     853                 :      32498 :           if (gimple_assign_rhs_code (stmt) != COMPLEX_EXPR)
     854                 :            :             {
     855                 :      23381 :               r = extract_component (gsi, rhs, 0, true);
     856                 :      23381 :               i = extract_component (gsi, rhs, 1, true);
     857                 :            :             }
     858                 :            :           else
     859                 :            :             {
     860                 :       9117 :               r = gimple_assign_rhs1 (stmt);
     861                 :       9117 :               i = gimple_assign_rhs2 (stmt);
     862                 :            :             }
     863                 :      32498 :           update_complex_assignment (gsi, r, i);
     864                 :            :         }
     865                 :            :     }
     866                 :      44925 :   else if (rhs && TREE_CODE (rhs) == SSA_NAME && !TREE_SIDE_EFFECTS (lhs))
     867                 :            :     {
     868                 :       8971 :       tree x;
     869                 :       8971 :       gimple *t;
     870                 :       8971 :       location_t loc;
     871                 :            : 
     872                 :       8971 :       loc = gimple_location (stmt);
     873                 :       8971 :       r = extract_component (gsi, rhs, 0, false);
     874                 :       8971 :       i = extract_component (gsi, rhs, 1, false);
     875                 :            : 
     876                 :       8971 :       x = build1 (REALPART_EXPR, inner_type, unshare_expr (lhs));
     877                 :       8971 :       t = gimple_build_assign (x, r);
     878                 :       8971 :       gimple_set_location (t, loc);
     879                 :       8971 :       gsi_insert_before (gsi, t, GSI_SAME_STMT);
     880                 :            : 
     881                 :       8971 :       if (stmt == gsi_stmt (*gsi))
     882                 :            :         {
     883                 :       8971 :           x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
     884                 :       8971 :           gimple_assign_set_lhs (stmt, x);
     885                 :       8971 :           gimple_assign_set_rhs1 (stmt, i);
     886                 :            :         }
     887                 :            :       else
     888                 :            :         {
     889                 :          0 :           x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
     890                 :          0 :           t = gimple_build_assign (x, i);
     891                 :          0 :           gimple_set_location (t, loc);
     892                 :          0 :           gsi_insert_before (gsi, t, GSI_SAME_STMT);
     893                 :            : 
     894                 :          0 :           stmt = gsi_stmt (*gsi);
     895                 :          0 :           gcc_assert (gimple_code (stmt) == GIMPLE_RETURN);
     896                 :          0 :           gimple_return_set_retval (as_a <greturn *> (stmt), lhs);
     897                 :            :         }
     898                 :            : 
     899                 :       8971 :       update_stmt (stmt);
     900                 :            :     }
     901                 :      91791 : }
     902                 :            : 
     903                 :            : /* Expand complex addition to scalars:
     904                 :            :         a + b = (ar + br) + i(ai + bi)
     905                 :            :         a - b = (ar - br) + i(ai + bi)
     906                 :            : */
     907                 :            : 
     908                 :            : static void
     909                 :       8541 : expand_complex_addition (gimple_stmt_iterator *gsi, tree inner_type,
     910                 :            :                          tree ar, tree ai, tree br, tree bi,
     911                 :            :                          enum tree_code code,
     912                 :            :                          complex_lattice_t al, complex_lattice_t bl)
     913                 :            : {
     914                 :       8541 :   tree rr, ri;
     915                 :            : 
     916                 :       8541 :   switch (PAIR (al, bl))
     917                 :            :     {
     918                 :         81 :     case PAIR (ONLY_REAL, ONLY_REAL):
     919                 :         81 :       rr = gimplify_build2 (gsi, code, inner_type, ar, br);
     920                 :         81 :       ri = ai;
     921                 :         81 :       break;
     922                 :            : 
     923                 :          6 :     case PAIR (ONLY_REAL, ONLY_IMAG):
     924                 :          6 :       rr = ar;
     925                 :          6 :       if (code == MINUS_EXPR)
     926                 :          0 :         ri = gimplify_build2 (gsi, MINUS_EXPR, inner_type, ai, bi);
     927                 :            :       else
     928                 :            :         ri = bi;
     929                 :            :       break;
     930                 :            : 
     931                 :          6 :     case PAIR (ONLY_IMAG, ONLY_REAL):
     932                 :          6 :       if (code == MINUS_EXPR)
     933                 :          6 :         rr = gimplify_build2 (gsi, MINUS_EXPR, inner_type, ar, br);
     934                 :            :       else
     935                 :            :         rr = br;
     936                 :            :       ri = ai;
     937                 :            :       break;
     938                 :            : 
     939                 :          0 :     case PAIR (ONLY_IMAG, ONLY_IMAG):
     940                 :          0 :       rr = ar;
     941                 :          0 :       ri = gimplify_build2 (gsi, code, inner_type, ai, bi);
     942                 :          0 :       break;
     943                 :            : 
     944                 :       1248 :     case PAIR (VARYING, ONLY_REAL):
     945                 :       1248 :       rr = gimplify_build2 (gsi, code, inner_type, ar, br);
     946                 :       1248 :       ri = ai;
     947                 :       1248 :       break;
     948                 :            : 
     949                 :          3 :     case PAIR (VARYING, ONLY_IMAG):
     950                 :          3 :       rr = ar;
     951                 :          3 :       ri = gimplify_build2 (gsi, code, inner_type, ai, bi);
     952                 :          3 :       break;
     953                 :            : 
     954                 :          2 :     case PAIR (ONLY_REAL, VARYING):
     955                 :          2 :       if (code == MINUS_EXPR)
     956                 :          1 :         goto general;
     957                 :          1 :       rr = gimplify_build2 (gsi, code, inner_type, ar, br);
     958                 :          1 :       ri = bi;
     959                 :          1 :       break;
     960                 :            : 
     961                 :          0 :     case PAIR (ONLY_IMAG, VARYING):
     962                 :          0 :       if (code == MINUS_EXPR)
     963                 :          0 :         goto general;
     964                 :          0 :       rr = br;
     965                 :          0 :       ri = gimplify_build2 (gsi, code, inner_type, ai, bi);
     966                 :          0 :       break;
     967                 :            : 
     968                 :       7196 :     case PAIR (VARYING, VARYING):
     969                 :       7196 :     general:
     970                 :       7196 :       rr = gimplify_build2 (gsi, code, inner_type, ar, br);
     971                 :       7196 :       ri = gimplify_build2 (gsi, code, inner_type, ai, bi);
     972                 :       7196 :       break;
     973                 :            : 
     974                 :          0 :     default:
     975                 :          0 :       gcc_unreachable ();
     976                 :            :     }
     977                 :            : 
     978                 :       8541 :   update_complex_assignment (gsi, rr, ri);
     979                 :       8541 : }
     980                 :            : 
     981                 :            : /* Expand a complex multiplication or division to a libcall to the c99
     982                 :            :    compliant routines.  TYPE is the complex type of the operation.
     983                 :            :    If INPLACE_P replace the statement at GSI with
     984                 :            :    the libcall and return NULL_TREE.  Else insert the call, assign its
     985                 :            :    result to an output variable and return that variable.  If INPLACE_P
     986                 :            :    is true then the statement being replaced should be an assignment
     987                 :            :    statement.  */
     988                 :            : 
     989                 :            : static tree
     990                 :       4132 : expand_complex_libcall (gimple_stmt_iterator *gsi, tree type, tree ar, tree ai,
     991                 :            :                         tree br, tree bi, enum tree_code code, bool inplace_p)
     992                 :            : {
     993                 :       4132 :   machine_mode mode;
     994                 :       4132 :   enum built_in_function bcode;
     995                 :       4132 :   tree fn, lhs;
     996                 :       4132 :   gcall *stmt;
     997                 :            : 
     998                 :       4132 :   mode = TYPE_MODE (type);
     999                 :       4132 :   gcc_assert (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT);
    1000                 :            : 
    1001                 :       4132 :   if (code == MULT_EXPR)
    1002                 :       3519 :     bcode = ((enum built_in_function)
    1003                 :       3519 :              (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
    1004                 :        613 :   else if (code == RDIV_EXPR)
    1005                 :        613 :     bcode = ((enum built_in_function)
    1006                 :        613 :              (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
    1007                 :            :   else
    1008                 :          0 :     gcc_unreachable ();
    1009                 :       4132 :   fn = builtin_decl_explicit (bcode);
    1010                 :       4132 :   stmt = gimple_build_call (fn, 4, ar, ai, br, bi);
    1011                 :            : 
    1012                 :       4132 :   if (inplace_p)
    1013                 :            :     {
    1014                 :       1941 :       gimple *old_stmt = gsi_stmt (*gsi);
    1015                 :       1941 :       gimple_call_set_nothrow (stmt, !stmt_could_throw_p (cfun, old_stmt));
    1016                 :       1941 :       lhs = gimple_assign_lhs (old_stmt);
    1017                 :       1941 :       gimple_call_set_lhs (stmt, lhs);
    1018                 :       1941 :       gsi_replace (gsi, stmt, true);
    1019                 :            : 
    1020                 :       1941 :       type = TREE_TYPE (type);
    1021                 :       1941 :       if (stmt_can_throw_internal (cfun, stmt))
    1022                 :            :         {
    1023                 :         10 :           edge_iterator ei;
    1024                 :         10 :           edge e;
    1025                 :         20 :           FOR_EACH_EDGE (e, ei, gimple_bb (stmt)->succs)
    1026                 :         20 :               if (!(e->flags & EDGE_EH))
    1027                 :            :                 break;
    1028                 :         10 :           basic_block bb = split_edge (e);
    1029                 :         10 :           gimple_stmt_iterator gsi2 = gsi_start_bb (bb);
    1030                 :         10 :           update_complex_components (&gsi2, stmt,
    1031                 :            :                                      build1 (REALPART_EXPR, type, lhs),
    1032                 :            :                                      build1 (IMAGPART_EXPR, type, lhs));
    1033                 :         10 :           return NULL_TREE;
    1034                 :            :         }
    1035                 :            :       else
    1036                 :       1931 :         update_complex_components (gsi, stmt,
    1037                 :            :                                    build1 (REALPART_EXPR, type, lhs),
    1038                 :            :                                    build1 (IMAGPART_EXPR, type, lhs));
    1039                 :       1931 :       SSA_NAME_DEF_STMT (lhs) = stmt;
    1040                 :       1931 :       return NULL_TREE;
    1041                 :            :     }
    1042                 :            : 
    1043                 :       2191 :   gimple_call_set_nothrow (stmt, true);
    1044                 :       2191 :   lhs = make_ssa_name (type);
    1045                 :       2191 :   gimple_call_set_lhs (stmt, lhs);
    1046                 :       2191 :   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    1047                 :            : 
    1048                 :       2191 :   return lhs;
    1049                 :            : }
    1050                 :            : 
    1051                 :            : /* Perform a complex multiplication on two complex constants A, B represented
    1052                 :            :    by AR, AI, BR, BI of type TYPE.
    1053                 :            :    The operation we want is: a * b = (ar*br - ai*bi) + i(ar*bi + br*ai).
    1054                 :            :    Insert the GIMPLE statements into GSI.  Store the real and imaginary
    1055                 :            :    components of the result into RR and RI.  */
    1056                 :            : 
    1057                 :            : static void
    1058                 :       5903 : expand_complex_multiplication_components (gimple_stmt_iterator *gsi,
    1059                 :            :                                              tree type, tree ar, tree ai,
    1060                 :            :                                              tree br, tree bi,
    1061                 :            :                                              tree *rr, tree *ri)
    1062                 :            : {
    1063                 :       5903 :   tree t1, t2, t3, t4;
    1064                 :            : 
    1065                 :       5903 :   t1 = gimplify_build2 (gsi, MULT_EXPR, type, ar, br);
    1066                 :       5903 :   t2 = gimplify_build2 (gsi, MULT_EXPR, type, ai, bi);
    1067                 :       5903 :   t3 = gimplify_build2 (gsi, MULT_EXPR, type, ar, bi);
    1068                 :            : 
    1069                 :            :   /* Avoid expanding redundant multiplication for the common
    1070                 :            :      case of squaring a complex number.  */
    1071                 :       5903 :   if (ar == br && ai == bi)
    1072                 :            :     t4 = t3;
    1073                 :            :   else
    1074                 :       5815 :     t4 = gimplify_build2 (gsi, MULT_EXPR, type, ai, br);
    1075                 :            : 
    1076                 :       5903 :   *rr = gimplify_build2 (gsi, MINUS_EXPR, type, t1, t2);
    1077                 :       5903 :   *ri = gimplify_build2 (gsi, PLUS_EXPR, type, t3, t4);
    1078                 :       5903 : }
    1079                 :            : 
    1080                 :            : /* Expand complex multiplication to scalars:
    1081                 :            :         a * b = (ar*br - ai*bi) + i(ar*bi + br*ai)
    1082                 :            : */
    1083                 :            : 
    1084                 :            : static void
    1085                 :       7257 : expand_complex_multiplication (gimple_stmt_iterator *gsi, tree type,
    1086                 :            :                                tree ar, tree ai, tree br, tree bi,
    1087                 :            :                                complex_lattice_t al, complex_lattice_t bl)
    1088                 :            : {
    1089                 :       7257 :   tree rr, ri;
    1090                 :       7257 :   tree inner_type = TREE_TYPE (type);
    1091                 :            : 
    1092                 :       7257 :   if (al < bl)
    1093                 :            :     {
    1094                 :         16 :       complex_lattice_t tl;
    1095                 :         16 :       rr = ar, ar = br, br = rr;
    1096                 :         16 :       ri = ai, ai = bi, bi = ri;
    1097                 :         16 :       tl = al, al = bl, bl = tl;
    1098                 :            :     }
    1099                 :            : 
    1100                 :       7257 :   switch (PAIR (al, bl))
    1101                 :            :     {
    1102                 :          0 :     case PAIR (ONLY_REAL, ONLY_REAL):
    1103                 :          0 :       rr = gimplify_build2 (gsi, MULT_EXPR, inner_type, ar, br);
    1104                 :          0 :       ri = ai;
    1105                 :          0 :       break;
    1106                 :            : 
    1107                 :         12 :     case PAIR (ONLY_IMAG, ONLY_REAL):
    1108                 :         12 :       rr = ar;
    1109                 :         12 :       if (TREE_CODE (ai) == REAL_CST
    1110                 :         12 :           && real_identical (&TREE_REAL_CST (ai), &dconst1))
    1111                 :          0 :         ri = br;
    1112                 :            :       else
    1113                 :         12 :         ri = gimplify_build2 (gsi, MULT_EXPR, inner_type, ai, br);
    1114                 :            :       break;
    1115                 :            : 
    1116                 :          0 :     case PAIR (ONLY_IMAG, ONLY_IMAG):
    1117                 :          0 :       rr = gimplify_build2 (gsi, MULT_EXPR, inner_type, ai, bi);
    1118                 :          0 :       rr = gimplify_build1 (gsi, NEGATE_EXPR, inner_type, rr);
    1119                 :          0 :       ri = ar;
    1120                 :          0 :       break;
    1121                 :            : 
    1122                 :         14 :     case PAIR (VARYING, ONLY_REAL):
    1123                 :         14 :       rr = gimplify_build2 (gsi, MULT_EXPR, inner_type, ar, br);
    1124                 :         14 :       ri = gimplify_build2 (gsi, MULT_EXPR, inner_type, ai, br);
    1125                 :         14 :       break;
    1126                 :            : 
    1127                 :          0 :     case PAIR (VARYING, ONLY_IMAG):
    1128                 :          0 :       rr = gimplify_build2 (gsi, MULT_EXPR, inner_type, ai, bi);
    1129                 :          0 :       rr = gimplify_build1 (gsi, NEGATE_EXPR, inner_type, rr);
    1130                 :          0 :       ri = gimplify_build2 (gsi, MULT_EXPR, inner_type, ar, bi);
    1131                 :          0 :       break;
    1132                 :            : 
    1133                 :       7231 :     case PAIR (VARYING, VARYING):
    1134                 :       7231 :       if (flag_complex_method == 2 && SCALAR_FLOAT_TYPE_P (inner_type))
    1135                 :            :         {
    1136                 :            :           /* If optimizing for size or not at all just do a libcall.
    1137                 :            :              Same if there are exception-handling edges or signaling NaNs.  */
    1138                 :       3073 :           if (optimize == 0 || optimize_bb_for_size_p (gsi_bb (*gsi))
    1139                 :       2198 :              || stmt_can_throw_internal (cfun, gsi_stmt (*gsi))
    1140                 :       5718 :              || flag_signaling_nans)
    1141                 :            :             {
    1142                 :       1328 :               expand_complex_libcall (gsi, type, ar, ai, br, bi,
    1143                 :            :                                       MULT_EXPR, true);
    1144                 :       1328 :               return;
    1145                 :            :             }
    1146                 :            : 
    1147                 :       2195 :           if (!HONOR_NANS (inner_type))
    1148                 :            :             {
    1149                 :            :               /* If we are not worrying about NaNs expand to
    1150                 :            :                  (ar*br - ai*bi) + i(ar*bi + br*ai) directly.  */
    1151                 :          4 :               expand_complex_multiplication_components (gsi, inner_type,
    1152                 :            :                                                         ar, ai, br, bi,
    1153                 :            :                                                         &rr, &ri);
    1154                 :          4 :               break;
    1155                 :            :             }
    1156                 :            : 
    1157                 :            :           /* Else, expand x = a * b into
    1158                 :            :              x = (ar*br - ai*bi) + i(ar*bi + br*ai);
    1159                 :            :              if (isunordered (__real__ x, __imag__ x))
    1160                 :            :                 x = __muldc3 (a, b);  */
    1161                 :            : 
    1162                 :       2191 :           tree tmpr, tmpi;
    1163                 :       2191 :           expand_complex_multiplication_components (gsi, inner_type, ar, ai,
    1164                 :            :                                                     br, bi, &tmpr, &tmpi);
    1165                 :            : 
    1166                 :       2191 :           gimple *check
    1167                 :       2191 :             = gimple_build_cond (UNORDERED_EXPR, tmpr, tmpi,
    1168                 :            :                                  NULL_TREE, NULL_TREE);
    1169                 :            : 
    1170                 :       2191 :           basic_block orig_bb = gsi_bb (*gsi);
    1171                 :            :           /* We want to keep track of the original complex multiplication
    1172                 :            :              statement as we're going to modify it later in
    1173                 :            :              update_complex_assignment.  Make sure that insert_cond_bb leaves
    1174                 :            :              that statement in the join block.  */
    1175                 :       2191 :           gsi_prev (gsi);
    1176                 :       2191 :           basic_block cond_bb
    1177                 :       2191 :             = insert_cond_bb (gsi_bb (*gsi), gsi_stmt (*gsi), check,
    1178                 :            :                               profile_probability::very_unlikely ());
    1179                 :            : 
    1180                 :       2191 :           gimple_stmt_iterator cond_bb_gsi = gsi_last_bb (cond_bb);
    1181                 :       2191 :           gsi_insert_after (&cond_bb_gsi, gimple_build_nop (), GSI_NEW_STMT);
    1182                 :            : 
    1183                 :       2191 :           tree libcall_res
    1184                 :       2191 :             = expand_complex_libcall (&cond_bb_gsi, type, ar, ai, br,
    1185                 :            :                                       bi, MULT_EXPR, false);
    1186                 :       2191 :           tree cond_real = gimplify_build1 (&cond_bb_gsi, REALPART_EXPR,
    1187                 :            :                                             inner_type, libcall_res);
    1188                 :       2191 :           tree cond_imag = gimplify_build1 (&cond_bb_gsi, IMAGPART_EXPR,
    1189                 :            :                                             inner_type, libcall_res);
    1190                 :            : 
    1191                 :       2191 :           basic_block join_bb = single_succ_edge (cond_bb)->dest;
    1192                 :       2191 :           *gsi = gsi_start_nondebug_after_labels_bb (join_bb);
    1193                 :            : 
    1194                 :            :           /* We have a conditional block with some assignments in cond_bb.
    1195                 :            :              Wire up the PHIs to wrap up.  */
    1196                 :       2191 :           rr = make_ssa_name (inner_type);
    1197                 :       2191 :           ri = make_ssa_name (inner_type);
    1198                 :       2191 :           edge cond_to_join = single_succ_edge (cond_bb);
    1199                 :       2191 :           edge orig_to_join = find_edge (orig_bb, join_bb);
    1200                 :            : 
    1201                 :       2191 :           gphi *real_phi = create_phi_node (rr, gsi_bb (*gsi));
    1202                 :       2191 :           add_phi_arg (real_phi, cond_real, cond_to_join, UNKNOWN_LOCATION);
    1203                 :       2191 :           add_phi_arg (real_phi, tmpr, orig_to_join, UNKNOWN_LOCATION);
    1204                 :            : 
    1205                 :       2191 :           gphi *imag_phi = create_phi_node (ri, gsi_bb (*gsi));
    1206                 :       2191 :           add_phi_arg (imag_phi, cond_imag, cond_to_join, UNKNOWN_LOCATION);
    1207                 :       2191 :           add_phi_arg (imag_phi, tmpi, orig_to_join, UNKNOWN_LOCATION);
    1208                 :            :         }
    1209                 :            :       else
    1210                 :            :         /* If we are not worrying about NaNs expand to
    1211                 :            :           (ar*br - ai*bi) + i(ar*bi + br*ai) directly.  */
    1212                 :       3708 :         expand_complex_multiplication_components (gsi, inner_type, ar, ai,
    1213                 :            :                                                   br, bi, &rr, &ri);
    1214                 :            :       break;
    1215                 :            : 
    1216                 :          0 :     default:
    1217                 :          0 :       gcc_unreachable ();
    1218                 :            :     }
    1219                 :            : 
    1220                 :       5929 :   update_complex_assignment (gsi, rr, ri);
    1221                 :            : }
    1222                 :            : 
    1223                 :            : /* Keep this algorithm in sync with fold-const.c:const_binop().
    1224                 :            : 
    1225                 :            :    Expand complex division to scalars, straightforward algorithm.
    1226                 :            :         a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
    1227                 :            :             t = br*br + bi*bi
    1228                 :            : */
    1229                 :            : 
    1230                 :            : static void
    1231                 :          8 : expand_complex_div_straight (gimple_stmt_iterator *gsi, tree inner_type,
    1232                 :            :                              tree ar, tree ai, tree br, tree bi,
    1233                 :            :                              enum tree_code code)
    1234                 :            : {
    1235                 :          8 :   tree rr, ri, div, t1, t2, t3;
    1236                 :            : 
    1237                 :          8 :   t1 = gimplify_build2 (gsi, MULT_EXPR, inner_type, br, br);
    1238                 :          8 :   t2 = gimplify_build2 (gsi, MULT_EXPR, inner_type, bi, bi);
    1239                 :          8 :   div = gimplify_build2 (gsi, PLUS_EXPR, inner_type, t1, t2);
    1240                 :            : 
    1241                 :          8 :   t1 = gimplify_build2 (gsi, MULT_EXPR, inner_type, ar, br);
    1242                 :          8 :   t2 = gimplify_build2 (gsi, MULT_EXPR, inner_type, ai, bi);
    1243                 :          8 :   t3 = gimplify_build2 (gsi, PLUS_EXPR, inner_type, t1, t2);
    1244                 :          8 :   rr = gimplify_build2 (gsi, code, inner_type, t3, div);
    1245                 :            : 
    1246                 :          8 :   t1 = gimplify_build2 (gsi, MULT_EXPR, inner_type, ai, br);
    1247                 :          8 :   t2 = gimplify_build2 (gsi, MULT_EXPR, inner_type, ar, bi);
    1248                 :          8 :   t3 = gimplify_build2 (gsi, MINUS_EXPR, inner_type, t1, t2);
    1249                 :          8 :   ri = gimplify_build2 (gsi, code, inner_type, t3, div);
    1250                 :            : 
    1251                 :          8 :   update_complex_assignment (gsi, rr, ri);
    1252                 :          8 : }
    1253                 :            : 
    1254                 :            : /* Keep this algorithm in sync with fold-const.c:const_binop().
    1255                 :            : 
    1256                 :            :    Expand complex division to scalars, modified algorithm to minimize
    1257                 :            :    overflow with wide input ranges.  */
    1258                 :            : 
    1259                 :            : static void
    1260                 :        262 : expand_complex_div_wide (gimple_stmt_iterator *gsi, tree inner_type,
    1261                 :            :                          tree ar, tree ai, tree br, tree bi,
    1262                 :            :                          enum tree_code code)
    1263                 :            : {
    1264                 :        262 :   tree rr, ri, ratio, div, t1, t2, tr, ti, compare;
    1265                 :        262 :   basic_block bb_cond, bb_true, bb_false, bb_join;
    1266                 :        262 :   gimple *stmt;
    1267                 :            : 
    1268                 :            :   /* Examine |br| < |bi|, and branch.  */
    1269                 :        262 :   t1 = gimplify_build1 (gsi, ABS_EXPR, inner_type, br);
    1270                 :        262 :   t2 = gimplify_build1 (gsi, ABS_EXPR, inner_type, bi);
    1271                 :        262 :   compare = fold_build2_loc (gimple_location (gsi_stmt (*gsi)),
    1272                 :            :                              LT_EXPR, boolean_type_node, t1, t2);
    1273                 :        262 :   STRIP_NOPS (compare);
    1274                 :            : 
    1275                 :        262 :   bb_cond = bb_true = bb_false = bb_join = NULL;
    1276                 :        262 :   rr = ri = tr = ti = NULL;
    1277                 :        262 :   if (TREE_CODE (compare) != INTEGER_CST)
    1278                 :            :     {
    1279                 :        212 :       edge e;
    1280                 :        212 :       gimple *stmt;
    1281                 :        212 :       tree cond, tmp;
    1282                 :            : 
    1283                 :        212 :       tmp = make_ssa_name (boolean_type_node);
    1284                 :        212 :       stmt = gimple_build_assign (tmp, compare);
    1285                 :        212 :       gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    1286                 :            : 
    1287                 :        212 :       cond = fold_build2_loc (gimple_location (stmt),
    1288                 :            :                           EQ_EXPR, boolean_type_node, tmp, boolean_true_node);
    1289                 :        212 :       stmt = gimple_build_cond_from_tree (cond, NULL_TREE, NULL_TREE);
    1290                 :        212 :       gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    1291                 :            : 
    1292                 :            :       /* Split the original block, and create the TRUE and FALSE blocks.  */
    1293                 :        212 :       e = split_block (gsi_bb (*gsi), stmt);
    1294                 :        212 :       bb_cond = e->src;
    1295                 :        212 :       bb_join = e->dest;
    1296                 :        212 :       bb_true = create_empty_bb (bb_cond);
    1297                 :        212 :       bb_false = create_empty_bb (bb_true);
    1298                 :        424 :       bb_true->count = bb_false->count
    1299                 :        212 :          = bb_cond->count.apply_probability (profile_probability::even ());
    1300                 :            : 
    1301                 :            :       /* Wire the blocks together.  */
    1302                 :        212 :       e->flags = EDGE_TRUE_VALUE;
    1303                 :            :       /* TODO: With value profile we could add an historgram to determine real
    1304                 :            :          branch outcome.  */
    1305                 :        212 :       e->probability = profile_probability::even ();
    1306                 :        212 :       redirect_edge_succ (e, bb_true);
    1307                 :        212 :       edge e2 = make_edge (bb_cond, bb_false, EDGE_FALSE_VALUE);
    1308                 :        212 :       e2->probability = profile_probability::even ();
    1309                 :        212 :       make_single_succ_edge (bb_true, bb_join, EDGE_FALLTHRU);
    1310                 :        212 :       make_single_succ_edge (bb_false, bb_join, EDGE_FALLTHRU);
    1311                 :        212 :       add_bb_to_loop (bb_true, bb_cond->loop_father);
    1312                 :        212 :       add_bb_to_loop (bb_false, bb_cond->loop_father);
    1313                 :            : 
    1314                 :            :       /* Update dominance info.  Note that bb_join's data was
    1315                 :            :          updated by split_block.  */
    1316                 :        212 :       if (dom_info_available_p (CDI_DOMINATORS))
    1317                 :            :         {
    1318                 :        209 :           set_immediate_dominator (CDI_DOMINATORS, bb_true, bb_cond);
    1319                 :        209 :           set_immediate_dominator (CDI_DOMINATORS, bb_false, bb_cond);
    1320                 :            :         }
    1321                 :            : 
    1322                 :        212 :       rr = create_tmp_reg (inner_type);
    1323                 :        212 :       ri = create_tmp_reg (inner_type);
    1324                 :            :     }
    1325                 :            : 
    1326                 :            :   /* In the TRUE branch, we compute
    1327                 :            :       ratio = br/bi;
    1328                 :            :       div = (br * ratio) + bi;
    1329                 :            :       tr = (ar * ratio) + ai;
    1330                 :            :       ti = (ai * ratio) - ar;
    1331                 :            :       tr = tr / div;
    1332                 :            :       ti = ti / div;  */
    1333                 :        262 :   if (bb_true || integer_nonzerop (compare))
    1334                 :            :     {
    1335                 :        225 :       if (bb_true)
    1336                 :            :         {
    1337                 :        212 :           *gsi = gsi_last_bb (bb_true);
    1338                 :        212 :           gsi_insert_after (gsi, gimple_build_nop (), GSI_NEW_STMT);
    1339                 :            :         }
    1340                 :            : 
    1341                 :        225 :       ratio = gimplify_build2 (gsi, code, inner_type, br, bi);
    1342                 :            : 
    1343                 :        225 :       t1 = gimplify_build2 (gsi, MULT_EXPR, inner_type, br, ratio);
    1344                 :        225 :       div = gimplify_build2 (gsi, PLUS_EXPR, inner_type, t1, bi);
    1345                 :            : 
    1346                 :        225 :       t1 = gimplify_build2 (gsi, MULT_EXPR, inner_type, ar, ratio);
    1347                 :        225 :       tr = gimplify_build2 (gsi, PLUS_EXPR, inner_type, t1, ai);
    1348                 :            : 
    1349                 :        225 :       t1 = gimplify_build2 (gsi, MULT_EXPR, inner_type, ai, ratio);
    1350                 :        225 :       ti = gimplify_build2 (gsi, MINUS_EXPR, inner_type, t1, ar);
    1351                 :            : 
    1352                 :        225 :       tr = gimplify_build2 (gsi, code, inner_type, tr, div);
    1353                 :        225 :       ti = gimplify_build2 (gsi, code, inner_type, ti, div);
    1354                 :            : 
    1355                 :        225 :      if (bb_true)
    1356                 :            :        {
    1357                 :        212 :          stmt = gimple_build_assign (rr, tr);
    1358                 :        212 :          gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    1359                 :        212 :          stmt = gimple_build_assign (ri, ti);
    1360                 :        212 :          gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    1361                 :        212 :          gsi_remove (gsi, true);
    1362                 :            :        }
    1363                 :            :     }
    1364                 :            : 
    1365                 :            :   /* In the FALSE branch, we compute
    1366                 :            :       ratio = d/c;
    1367                 :            :       divisor = (d * ratio) + c;
    1368                 :            :       tr = (b * ratio) + a;
    1369                 :            :       ti = b - (a * ratio);
    1370                 :            :       tr = tr / div;
    1371                 :            :       ti = ti / div;  */
    1372                 :        262 :   if (bb_false || integer_zerop (compare))
    1373                 :            :     {
    1374                 :        249 :       if (bb_false)
    1375                 :            :         {
    1376                 :        212 :           *gsi = gsi_last_bb (bb_false);
    1377                 :        212 :           gsi_insert_after (gsi, gimple_build_nop (), GSI_NEW_STMT);
    1378                 :            :         }
    1379                 :            : 
    1380                 :        249 :       ratio = gimplify_build2 (gsi, code, inner_type, bi, br);
    1381                 :            : 
    1382                 :        249 :       t1 = gimplify_build2 (gsi, MULT_EXPR, inner_type, bi, ratio);
    1383                 :        249 :       div = gimplify_build2 (gsi, PLUS_EXPR, inner_type, t1, br);
    1384                 :            : 
    1385                 :        249 :       t1 = gimplify_build2 (gsi, MULT_EXPR, inner_type, ai, ratio);
    1386                 :        249 :       tr = gimplify_build2 (gsi, PLUS_EXPR, inner_type, t1, ar);
    1387                 :            : 
    1388                 :        249 :       t1 = gimplify_build2 (gsi, MULT_EXPR, inner_type, ar, ratio);
    1389                 :        249 :       ti = gimplify_build2 (gsi, MINUS_EXPR, inner_type, ai, t1);
    1390                 :            : 
    1391                 :        249 :       tr = gimplify_build2 (gsi, code, inner_type, tr, div);
    1392                 :        249 :       ti = gimplify_build2 (gsi, code, inner_type, ti, div);
    1393                 :            : 
    1394                 :        249 :      if (bb_false)
    1395                 :            :        {
    1396                 :        212 :          stmt = gimple_build_assign (rr, tr);
    1397                 :        212 :          gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    1398                 :        212 :          stmt = gimple_build_assign (ri, ti);
    1399                 :        212 :          gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
    1400                 :        212 :          gsi_remove (gsi, true);
    1401                 :            :        }
    1402                 :            :     }
    1403                 :            : 
    1404                 :        262 :   if (bb_join)
    1405                 :        424 :     *gsi = gsi_start_bb (bb_join);
    1406                 :            :   else
    1407                 :            :     rr = tr, ri = ti;
    1408                 :            : 
    1409                 :        262 :   update_complex_assignment (gsi, rr, ri);
    1410                 :        262 : }
    1411                 :            : 
    1412                 :            : /* Expand complex division to scalars.  */
    1413                 :            : 
    1414                 :            : static void
    1415                 :        907 : expand_complex_division (gimple_stmt_iterator *gsi, tree type,
    1416                 :            :                          tree ar, tree ai, tree br, tree bi,
    1417                 :            :                          enum tree_code code,
    1418                 :            :                          complex_lattice_t al, complex_lattice_t bl)
    1419                 :            : {
    1420                 :        907 :   tree rr, ri;
    1421                 :            : 
    1422                 :        907 :   tree inner_type = TREE_TYPE (type);
    1423                 :        907 :   switch (PAIR (al, bl))
    1424                 :            :     {
    1425                 :          3 :     case PAIR (ONLY_REAL, ONLY_REAL):
    1426                 :          3 :       rr = gimplify_build2 (gsi, code, inner_type, ar, br);
    1427                 :          3 :       ri = ai;
    1428                 :          3 :       break;
    1429                 :            : 
    1430                 :          0 :     case PAIR (ONLY_REAL, ONLY_IMAG):
    1431                 :          0 :       rr = ai;
    1432                 :          0 :       ri = gimplify_build2 (gsi, code, inner_type, ar, bi);
    1433                 :          0 :       ri = gimplify_build1 (gsi, NEGATE_EXPR, inner_type, ri);
    1434                 :          0 :       break;
    1435                 :            : 
    1436                 :          0 :     case PAIR (ONLY_IMAG, ONLY_REAL):
    1437                 :          0 :       rr = ar;
    1438                 :          0 :       ri = gimplify_build2 (gsi, code, inner_type, ai, br);
    1439                 :          0 :       break;
    1440                 :            : 
    1441                 :          0 :     case PAIR (ONLY_IMAG, ONLY_IMAG):
    1442                 :          0 :       rr = gimplify_build2 (gsi, code, inner_type, ai, bi);
    1443                 :          0 :       ri = ar;
    1444                 :          0 :       break;
    1445                 :            : 
    1446                 :         12 :     case PAIR (VARYING, ONLY_REAL):
    1447                 :         12 :       rr = gimplify_build2 (gsi, code, inner_type, ar, br);
    1448                 :         12 :       ri = gimplify_build2 (gsi, code, inner_type, ai, br);
    1449                 :         12 :       break;
    1450                 :            : 
    1451                 :          9 :     case PAIR (VARYING, ONLY_IMAG):
    1452                 :          9 :       rr = gimplify_build2 (gsi, code, inner_type, ai, bi);
    1453                 :          9 :       ri = gimplify_build2 (gsi, code, inner_type, ar, bi);
    1454                 :          9 :       ri = gimplify_build1 (gsi, NEGATE_EXPR, inner_type, ri);
    1455                 :          9 :       break;
    1456                 :            : 
    1457                 :        883 :     case PAIR (ONLY_REAL, VARYING):
    1458                 :        883 :     case PAIR (ONLY_IMAG, VARYING):
    1459                 :        883 :     case PAIR (VARYING, VARYING):
    1460                 :        883 :       switch (flag_complex_method)
    1461                 :            :         {
    1462                 :          8 :         case 0:
    1463                 :            :           /* straightforward implementation of complex divide acceptable.  */
    1464                 :          8 :           expand_complex_div_straight (gsi, inner_type, ar, ai, br, bi, code);
    1465                 :          8 :           break;
    1466                 :            : 
    1467                 :        643 :         case 2:
    1468                 :        643 :           if (SCALAR_FLOAT_TYPE_P (inner_type))
    1469                 :            :             {
    1470                 :        613 :               expand_complex_libcall (gsi, type, ar, ai, br, bi, code, true);
    1471                 :        613 :               break;
    1472                 :            :             }
    1473                 :            :           /* FALLTHRU */
    1474                 :            : 
    1475                 :        262 :         case 1:
    1476                 :            :           /* wide ranges of inputs must work for complex divide.  */
    1477                 :        262 :           expand_complex_div_wide (gsi, inner_type, ar, ai, br, bi, code);
    1478                 :        262 :           break;
    1479                 :            : 
    1480                 :          0 :         default:
    1481                 :          0 :           gcc_unreachable ();
    1482                 :            :         }
    1483                 :            :       return;
    1484                 :            : 
    1485                 :          0 :     default:
    1486                 :          0 :       gcc_unreachable ();
    1487                 :            :     }
    1488                 :            : 
    1489                 :         24 :   update_complex_assignment (gsi, rr, ri);
    1490                 :            : }
    1491                 :            : 
    1492                 :            : /* Expand complex negation to scalars:
    1493                 :            :         -a = (-ar) + i(-ai)
    1494                 :            : */
    1495                 :            : 
    1496                 :            : static void
    1497                 :         26 : expand_complex_negation (gimple_stmt_iterator *gsi, tree inner_type,
    1498                 :            :                          tree ar, tree ai)
    1499                 :            : {
    1500                 :         26 :   tree rr, ri;
    1501                 :            : 
    1502                 :         26 :   rr = gimplify_build1 (gsi, NEGATE_EXPR, inner_type, ar);
    1503                 :         26 :   ri = gimplify_build1 (gsi, NEGATE_EXPR, inner_type, ai);
    1504                 :            : 
    1505                 :         26 :   update_complex_assignment (gsi, rr, ri);
    1506                 :         26 : }
    1507                 :            : 
    1508                 :            : /* Expand complex conjugate to scalars:
    1509                 :            :         ~a = (ar) + i(-ai)
    1510                 :            : */
    1511                 :            : 
    1512                 :            : static void
    1513                 :        300 : expand_complex_conjugate (gimple_stmt_iterator *gsi, tree inner_type,
    1514                 :            :                           tree ar, tree ai)
    1515                 :            : {
    1516                 :        300 :   tree ri;
    1517                 :            : 
    1518                 :        300 :   ri = gimplify_build1 (gsi, NEGATE_EXPR, inner_type, ai);
    1519                 :            : 
    1520                 :        300 :   update_complex_assignment (gsi, ar, ri);
    1521                 :        300 : }
    1522                 :            : 
    1523                 :            : /* Expand complex comparison (EQ or NE only).  */
    1524                 :            : 
    1525                 :            : static void
    1526                 :      24741 : expand_complex_comparison (gimple_stmt_iterator *gsi, tree ar, tree ai,
    1527                 :            :                            tree br, tree bi, enum tree_code code)
    1528                 :            : {
    1529                 :      24741 :   tree cr, ci, cc, type;
    1530                 :      24741 :   gimple *stmt;
    1531                 :            : 
    1532                 :      24741 :   cr = gimplify_build2 (gsi, code, boolean_type_node, ar, br);
    1533                 :      24741 :   ci = gimplify_build2 (gsi, code, boolean_type_node, ai, bi);
    1534                 :      49123 :   cc = gimplify_build2 (gsi,
    1535                 :            :                         (code == EQ_EXPR ? TRUTH_AND_EXPR : TRUTH_OR_EXPR),
    1536                 :            :                         boolean_type_node, cr, ci);
    1537                 :            : 
    1538                 :      24741 :   stmt = gsi_stmt (*gsi);
    1539                 :            : 
    1540                 :      24741 :   switch (gimple_code (stmt))
    1541                 :            :     {
    1542                 :          0 :     case GIMPLE_RETURN:
    1543                 :          0 :       {
    1544                 :          0 :         greturn *return_stmt = as_a <greturn *> (stmt);
    1545                 :          0 :         type = TREE_TYPE (gimple_return_retval (return_stmt));
    1546                 :          0 :         gimple_return_set_retval (return_stmt, fold_convert (type, cc));
    1547                 :            :       }
    1548                 :            :       break;
    1549                 :            : 
    1550                 :        197 :     case GIMPLE_ASSIGN:
    1551                 :        197 :       type = TREE_TYPE (gimple_assign_lhs (stmt));
    1552                 :        197 :       gimple_assign_set_rhs_from_tree (gsi, fold_convert (type, cc));
    1553                 :        197 :       stmt = gsi_stmt (*gsi);
    1554                 :        197 :       break;
    1555                 :            : 
    1556                 :      24544 :     case GIMPLE_COND:
    1557                 :      24544 :       {
    1558                 :      24544 :         gcond *cond_stmt = as_a <gcond *> (stmt);
    1559                 :      24544 :         gimple_cond_set_code (cond_stmt, EQ_EXPR);
    1560                 :      24544 :         gimple_cond_set_lhs (cond_stmt, cc);
    1561                 :      24544 :         gimple_cond_set_rhs (cond_stmt, boolean_true_node);
    1562                 :            :       }
    1563                 :            :       break;
    1564                 :            : 
    1565                 :          0 :     default:
    1566                 :          0 :       gcc_unreachable ();
    1567                 :            :     }
    1568                 :            : 
    1569                 :      24741 :   update_stmt (stmt);
    1570                 :      24741 :   if (maybe_clean_eh_stmt (stmt))
    1571                 :          1 :     bitmap_set_bit (need_eh_cleanup, gimple_bb (stmt)->index);
    1572                 :      24741 : }
    1573                 :            : 
    1574                 :            : /* Expand inline asm that sets some complex SSA_NAMEs.  */
    1575                 :            : 
    1576                 :            : static void
    1577                 :        129 : expand_complex_asm (gimple_stmt_iterator *gsi)
    1578                 :            : {
    1579                 :        129 :   gasm *stmt = as_a <gasm *> (gsi_stmt (*gsi));
    1580                 :            :   unsigned int i;
    1581                 :            : 
    1582                 :        197 :   for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
    1583                 :            :     {
    1584                 :         68 :       tree link = gimple_asm_output_op (stmt, i);
    1585                 :         68 :       tree op = TREE_VALUE (link);
    1586                 :         68 :       if (TREE_CODE (op) == SSA_NAME
    1587                 :        130 :           && TREE_CODE (TREE_TYPE (op)) == COMPLEX_TYPE)
    1588                 :            :         {
    1589                 :         44 :           tree type = TREE_TYPE (op);
    1590                 :         44 :           tree inner_type = TREE_TYPE (type);
    1591                 :         44 :           tree r = build1 (REALPART_EXPR, inner_type, op);
    1592                 :         44 :           tree i = build1 (IMAGPART_EXPR, inner_type, op);
    1593                 :         44 :           gimple_seq list = set_component_ssa_name (op, false, r);
    1594                 :            : 
    1595                 :         44 :           if (list)
    1596                 :         44 :             gsi_insert_seq_after (gsi, list, GSI_CONTINUE_LINKING);
    1597                 :            : 
    1598                 :         44 :           list = set_component_ssa_name (op, true, i);
    1599                 :         44 :           if (list)
    1600                 :         44 :             gsi_insert_seq_after (gsi, list, GSI_CONTINUE_LINKING);
    1601                 :            :         }
    1602                 :            :     }
    1603                 :        129 : }
    1604                 :            : 
    1605                 :            : /* Process one statement.  If we identify a complex operation, expand it.  */
    1606                 :            : 
    1607                 :            : static void
    1608                 :     934066 : expand_complex_operations_1 (gimple_stmt_iterator *gsi)
    1609                 :            : {
    1610                 :     934066 :   gimple *stmt = gsi_stmt (*gsi);
    1611                 :     934066 :   tree type, inner_type, lhs;
    1612                 :     934066 :   tree ac, ar, ai, bc, br, bi;
    1613                 :     934066 :   complex_lattice_t al, bl;
    1614                 :     934066 :   enum tree_code code;
    1615                 :            : 
    1616                 :     934066 :   if (gimple_code (stmt) == GIMPLE_ASM)
    1617                 :            :     {
    1618                 :        129 :       expand_complex_asm (gsi);
    1619                 :        129 :       return;
    1620                 :            :     }
    1621                 :            : 
    1622                 :     933937 :   lhs = gimple_get_lhs (stmt);
    1623                 :     933937 :   if (!lhs && gimple_code (stmt) != GIMPLE_COND)
    1624                 :            :     return;
    1625                 :            : 
    1626                 :     689551 :   type = TREE_TYPE (gimple_op (stmt, 0));
    1627                 :     689551 :   code = gimple_expr_code (stmt);
    1628                 :            : 
    1629                 :            :   /* Initial filter for operations we handle.  */
    1630                 :     689551 :   switch (code)
    1631                 :            :     {
    1632                 :      96708 :     case PLUS_EXPR:
    1633                 :      96708 :     case MINUS_EXPR:
    1634                 :      96708 :     case MULT_EXPR:
    1635                 :      96708 :     case TRUNC_DIV_EXPR:
    1636                 :      96708 :     case CEIL_DIV_EXPR:
    1637                 :      96708 :     case FLOOR_DIV_EXPR:
    1638                 :      96708 :     case ROUND_DIV_EXPR:
    1639                 :      96708 :     case RDIV_EXPR:
    1640                 :      96708 :     case NEGATE_EXPR:
    1641                 :      96708 :     case CONJ_EXPR:
    1642                 :      96708 :       if (TREE_CODE (type) != COMPLEX_TYPE)
    1643                 :            :         return;
    1644                 :      17031 :       inner_type = TREE_TYPE (type);
    1645                 :      17031 :       break;
    1646                 :            : 
    1647                 :     107222 :     case EQ_EXPR:
    1648                 :     107222 :     case NE_EXPR:
    1649                 :            :       /* Note, both GIMPLE_ASSIGN and GIMPLE_COND may have an EQ_EXPR
    1650                 :            :          subcode, so we need to access the operands using gimple_op.  */
    1651                 :     107222 :       inner_type = TREE_TYPE (gimple_op (stmt, 1));
    1652                 :     107222 :       if (TREE_CODE (inner_type) != COMPLEX_TYPE)
    1653                 :            :         return;
    1654                 :            :       break;
    1655                 :            : 
    1656                 :     485621 :     default:
    1657                 :     485621 :       {
    1658                 :     485621 :         tree rhs;
    1659                 :            : 
    1660                 :            :         /* GIMPLE_COND may also fallthru here, but we do not need to
    1661                 :            :            do anything with it.  */
    1662                 :     485621 :         if (gimple_code (stmt) == GIMPLE_COND)
    1663                 :            :           return;
    1664                 :            : 
    1665                 :     470617 :         if (TREE_CODE (type) == COMPLEX_TYPE)
    1666                 :      91791 :           expand_complex_move (gsi, type);
    1667                 :     378826 :         else if (is_gimple_assign (stmt)
    1668                 :     296746 :                  && (gimple_assign_rhs_code (stmt) == REALPART_EXPR
    1669                 :     266392 :                      || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR)
    1670                 :     438898 :                  && TREE_CODE (lhs) == SSA_NAME)
    1671                 :            :           {
    1672                 :      60072 :             rhs = gimple_assign_rhs1 (stmt);
    1673                 :      60072 :             rhs = extract_component (gsi, TREE_OPERAND (rhs, 0),
    1674                 :            :                                      gimple_assign_rhs_code (stmt)
    1675                 :            :                                        == IMAGPART_EXPR,
    1676                 :            :                                      false);
    1677                 :      60072 :             gimple_assign_set_rhs_from_tree (gsi, rhs);
    1678                 :      60072 :             stmt = gsi_stmt (*gsi);
    1679                 :      60072 :             update_stmt (stmt);
    1680                 :            :           }
    1681                 :            :       }
    1682                 :            :       return;
    1683                 :            :     }
    1684                 :            : 
    1685                 :            :   /* Extract the components of the two complex values.  Make sure and
    1686                 :            :      handle the common case of the same value used twice specially.  */
    1687                 :      41772 :   if (is_gimple_assign (stmt))
    1688                 :            :     {
    1689                 :      17228 :       ac = gimple_assign_rhs1 (stmt);
    1690                 :      17228 :       bc = (gimple_num_ops (stmt) > 2) ? gimple_assign_rhs2 (stmt) : NULL;
    1691                 :            :     }
    1692                 :            :   /* GIMPLE_CALL cannot get here.  */
    1693                 :            :   else
    1694                 :            :     {
    1695                 :      24544 :       ac = gimple_cond_lhs (stmt);
    1696                 :      24544 :       bc = gimple_cond_rhs (stmt);
    1697                 :            :     }
    1698                 :            : 
    1699                 :      41772 :   ar = extract_component (gsi, ac, false, true);
    1700                 :      41772 :   ai = extract_component (gsi, ac, true, true);
    1701                 :            : 
    1702                 :      41772 :   if (ac == bc)
    1703                 :            :     br = ar, bi = ai;
    1704                 :      41637 :   else if (bc)
    1705                 :            :     {
    1706                 :      41311 :       br = extract_component (gsi, bc, 0, true);
    1707                 :      41311 :       bi = extract_component (gsi, bc, 1, true);
    1708                 :            :     }
    1709                 :            :   else
    1710                 :            :     br = bi = NULL_TREE;
    1711                 :            : 
    1712                 :      41772 :   al = find_lattice_value (ac);
    1713                 :      41772 :   if (al == UNINITIALIZED)
    1714                 :         46 :     al = VARYING;
    1715                 :            : 
    1716                 :      41772 :   if (TREE_CODE_CLASS (code) == tcc_unary)
    1717                 :            :     bl = UNINITIALIZED;
    1718                 :      41446 :   else if (ac == bc)
    1719                 :            :     bl = al;
    1720                 :            :   else
    1721                 :            :     {
    1722                 :      41311 :       bl = find_lattice_value (bc);
    1723                 :      41311 :       if (bl == UNINITIALIZED)
    1724                 :         20 :         bl = VARYING;
    1725                 :            :     }
    1726                 :            : 
    1727                 :      41772 :   switch (code)
    1728                 :            :     {
    1729                 :       8541 :     case PLUS_EXPR:
    1730                 :       8541 :     case MINUS_EXPR:
    1731                 :       8541 :       expand_complex_addition (gsi, inner_type, ar, ai, br, bi, code, al, bl);
    1732                 :       8541 :       break;
    1733                 :            : 
    1734                 :       7257 :     case MULT_EXPR:
    1735                 :       7257 :       expand_complex_multiplication (gsi, type, ar, ai, br, bi, al, bl);
    1736                 :       7257 :       break;
    1737                 :            : 
    1738                 :        907 :     case TRUNC_DIV_EXPR:
    1739                 :        907 :     case CEIL_DIV_EXPR:
    1740                 :        907 :     case FLOOR_DIV_EXPR:
    1741                 :        907 :     case ROUND_DIV_EXPR:
    1742                 :        907 :     case RDIV_EXPR:
    1743                 :        907 :       expand_complex_division (gsi, type, ar, ai, br, bi, code, al, bl);
    1744                 :        907 :       break;
    1745                 :            : 
    1746                 :         26 :     case NEGATE_EXPR:
    1747                 :         26 :       expand_complex_negation (gsi, inner_type, ar, ai);
    1748                 :         26 :       break;
    1749                 :            : 
    1750                 :        300 :     case CONJ_EXPR:
    1751                 :        300 :       expand_complex_conjugate (gsi, inner_type, ar, ai);
    1752                 :        300 :       break;
    1753                 :            : 
    1754                 :      24741 :     case EQ_EXPR:
    1755                 :      24741 :     case NE_EXPR:
    1756                 :      24741 :       expand_complex_comparison (gsi, ar, ai, br, bi, code);
    1757                 :      24741 :       break;
    1758                 :            : 
    1759                 :          0 :     default:
    1760                 :          0 :       gcc_unreachable ();
    1761                 :            :     }
    1762                 :            : }
    1763                 :            : 
    1764                 :            : 
    1765                 :            : /* Entry point for complex operation lowering during optimization.  */
    1766                 :            : 
    1767                 :            : static unsigned int
    1768                 :     943372 : tree_lower_complex (void)
    1769                 :            : {
    1770                 :     943372 :   gimple_stmt_iterator gsi;
    1771                 :     943372 :   basic_block bb;
    1772                 :     943372 :   int n_bbs, i;
    1773                 :     943372 :   int *rpo;
    1774                 :            : 
    1775                 :     943372 :   if (!init_dont_simulate_again ())
    1776                 :            :     return 0;
    1777                 :            : 
    1778                 :       3425 :   complex_lattice_values.create (num_ssa_names);
    1779                 :       6850 :   complex_lattice_values.safe_grow_cleared (num_ssa_names);
    1780                 :            : 
    1781                 :       3425 :   init_parameter_lattice_values ();
    1782                 :     946797 :   class complex_propagate complex_propagate;
    1783                 :       3425 :   complex_propagate.ssa_propagate ();
    1784                 :            : 
    1785                 :       3425 :   need_eh_cleanup = BITMAP_ALLOC (NULL);
    1786                 :            : 
    1787                 :       3425 :   complex_variable_components = new int_tree_htab_type (10);
    1788                 :            : 
    1789                 :       6850 :   complex_ssa_name_components.create (2 * num_ssa_names);
    1790                 :       6850 :   complex_ssa_name_components.safe_grow_cleared (2 * num_ssa_names);
    1791                 :            : 
    1792                 :       3425 :   update_parameter_components ();
    1793                 :            : 
    1794                 :       3425 :   rpo = XNEWVEC (int, last_basic_block_for_fn (cfun));
    1795                 :       3425 :   n_bbs = pre_and_rev_post_order_compute (NULL, rpo, false);
    1796                 :     208896 :   for (i = 0; i < n_bbs; i++)
    1797                 :            :     {
    1798                 :     205471 :       bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i]);
    1799                 :     205471 :       if (!bb)
    1800                 :          0 :         continue;
    1801                 :     205471 :       update_phi_components (bb);
    1802                 :    1345010 :       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    1803                 :     934066 :         expand_complex_operations_1 (&gsi);
    1804                 :            :     }
    1805                 :            : 
    1806                 :       3425 :   free (rpo);
    1807                 :            : 
    1808                 :       3425 :   if (!phis_to_revisit.is_empty ())
    1809                 :            :     {
    1810                 :       3593 :       unsigned int n = phis_to_revisit.length ();
    1811                 :       3593 :       for (unsigned int j = 0; j < n; j += 3)
    1812                 :       9912 :         for (unsigned int k = 0; k < 2; k++)
    1813                 :       6608 :           if (gphi *phi = phis_to_revisit[j + k + 1])
    1814                 :            :             {
    1815                 :       6606 :               unsigned int m = gimple_phi_num_args (phi);
    1816                 :      19818 :               for (unsigned int l = 0; l < m; ++l)
    1817                 :            :                 {
    1818                 :      13212 :                   tree op = gimple_phi_arg_def (phi, l);
    1819                 :      19818 :                   if (TREE_CODE (op) == SSA_NAME
    1820                 :      13212 :                       || is_gimple_min_invariant (op))
    1821                 :       6606 :                     continue;
    1822                 :       6606 :                   tree arg = gimple_phi_arg_def (phis_to_revisit[j], l);
    1823                 :       6606 :                   op = extract_component (NULL, arg, k > 0, false, false);
    1824                 :       6606 :                   SET_PHI_ARG_DEF (phi, l, op);
    1825                 :            :                 }
    1826                 :            :             }
    1827                 :        289 :       phis_to_revisit.release ();
    1828                 :            :     }
    1829                 :            : 
    1830                 :       3425 :   gsi_commit_edge_inserts ();
    1831                 :            : 
    1832                 :       3425 :   unsigned todo
    1833                 :       3425 :     = gimple_purge_all_dead_eh_edges (need_eh_cleanup) ? TODO_cleanup_cfg : 0;
    1834                 :       3425 :   BITMAP_FREE (need_eh_cleanup);
    1835                 :            : 
    1836                 :       3425 :   delete complex_variable_components;
    1837                 :       3425 :   complex_variable_components = NULL;
    1838                 :       3425 :   complex_ssa_name_components.release ();
    1839                 :       3425 :   complex_lattice_values.release ();
    1840                 :       3425 :   return todo;
    1841                 :            : }
    1842                 :            : 
    1843                 :            : namespace {
    1844                 :            : 
    1845                 :            : const pass_data pass_data_lower_complex =
    1846                 :            : {
    1847                 :            :   GIMPLE_PASS, /* type */
    1848                 :            :   "cplxlower", /* name */
    1849                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    1850                 :            :   TV_NONE, /* tv_id */
    1851                 :            :   PROP_ssa, /* properties_required */
    1852                 :            :   PROP_gimple_lcx, /* properties_provided */
    1853                 :            :   0, /* properties_destroyed */
    1854                 :            :   0, /* todo_flags_start */
    1855                 :            :   TODO_update_ssa, /* todo_flags_finish */
    1856                 :            : };
    1857                 :            : 
    1858                 :            : class pass_lower_complex : public gimple_opt_pass
    1859                 :            : {
    1860                 :            : public:
    1861                 :     401080 :   pass_lower_complex (gcc::context *ctxt)
    1862                 :     802160 :     : gimple_opt_pass (pass_data_lower_complex, ctxt)
    1863                 :            :   {}
    1864                 :            : 
    1865                 :            :   /* opt_pass methods: */
    1866                 :     200540 :   opt_pass * clone () { return new pass_lower_complex (m_ctxt); }
    1867                 :     687611 :   virtual unsigned int execute (function *) { return tree_lower_complex (); }
    1868                 :            : 
    1869                 :            : }; // class pass_lower_complex
    1870                 :            : 
    1871                 :            : } // anon namespace
    1872                 :            : 
    1873                 :            : gimple_opt_pass *
    1874                 :     200540 : make_pass_lower_complex (gcc::context *ctxt)
    1875                 :            : {
    1876                 :     200540 :   return new pass_lower_complex (ctxt);
    1877                 :            : }
    1878                 :            : 
    1879                 :            : 
    1880                 :            : namespace {
    1881                 :            : 
    1882                 :            : const pass_data pass_data_lower_complex_O0 =
    1883                 :            : {
    1884                 :            :   GIMPLE_PASS, /* type */
    1885                 :            :   "cplxlower0", /* name */
    1886                 :            :   OPTGROUP_NONE, /* optinfo_flags */
    1887                 :            :   TV_NONE, /* tv_id */
    1888                 :            :   PROP_cfg, /* properties_required */
    1889                 :            :   PROP_gimple_lcx, /* properties_provided */
    1890                 :            :   0, /* properties_destroyed */
    1891                 :            :   0, /* todo_flags_start */
    1892                 :            :   TODO_update_ssa, /* todo_flags_finish */
    1893                 :            : };
    1894                 :            : 
    1895                 :            : class pass_lower_complex_O0 : public gimple_opt_pass
    1896                 :            : {
    1897                 :            : public:
    1898                 :     200540 :   pass_lower_complex_O0 (gcc::context *ctxt)
    1899                 :     401080 :     : gimple_opt_pass (pass_data_lower_complex_O0, ctxt)
    1900                 :            :   {}
    1901                 :            : 
    1902                 :            :   /* opt_pass methods: */
    1903                 :     943374 :   virtual bool gate (function *fun)
    1904                 :            :     {
    1905                 :            :       /* With errors, normal optimization passes are not run.  If we don't
    1906                 :            :          lower complex operations at all, rtl expansion will abort.  */
    1907                 :     943374 :       return !(fun->curr_properties & PROP_gimple_lcx);
    1908                 :            :     }
    1909                 :            : 
    1910                 :     255761 :   virtual unsigned int execute (function *) { return tree_lower_complex (); }
    1911                 :            : 
    1912                 :            : }; // class pass_lower_complex_O0
    1913                 :            : 
    1914                 :            : } // anon namespace
    1915                 :            : 
    1916                 :            : gimple_opt_pass *
    1917                 :     200540 : make_pass_lower_complex_O0 (gcc::context *ctxt)
    1918                 :            : {
    1919                 :     200540 :   return new pass_lower_complex_O0 (ctxt);
    1920                 :            : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.