gcc/tree-complex.c

   1 /* Lower complex number operations to scalar operations.
   2    Copyright (C) 2004, 2005 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 2, 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 COPYING.  If not, write to the Free
  18 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "rtl.h"
  27 #include "real.h"
  28 #include "flags.h"
  29 #include "tree-flow.h"
  30 #include "tree-gimple.h"
  31 #include "tree-iterator.h"
  32 #include "tree-pass.h"
  33 #include "tree-ssa-propagate.h"
  34
  35
  36 /* For each complex ssa name, a lattice value.  We're interested in finding
  37    out whether a complex number is degenerate in some way, having only real
  38    or only complex parts.  */
  39
  40 typedef enum
  41 {
  42   UNINITIALIZED = 0,
  43   ONLY_REAL = 1,
  44   ONLY_IMAG = 2,
  45   VARYING = 3
  46 } complex_lattice_t;
  47
  48 #define PAIR(a, b)  ((a) << 2 | (b))
  49
  50 DEF_VEC_I(complex_lattice_t);
  51 DEF_VEC_ALLOC_I(complex_lattice_t, heap);
  52
  53 static VEC(complex_lattice_t, heap) *complex_lattice_values;
  54
  55 /* For each complex variable, a pair of variables for the components exists in
  56    the hashtable.  */
  57 static htab_t complex_variable_components;
  58
  59 /* Lookup UID in the complex_variable_components hashtable and return the
  60    associated tree.  */
  61 static tree
  62 cvc_lookup (unsigned int uid)
  63 {
  64   struct int_tree_map *h, in;
  65   in.uid = uid;
  66   h = htab_find_with_hash (complex_variable_components, &in, uid);
  67   gcc_assert (h);
  68   return h->to;
  69 }
  70
  71 /* Insert the pair UID, TO into the complex_variable_components hashtable.  */
  72
  73 static void
  74 cvc_insert (unsigned int uid, tree to)
  75 {
  76   struct int_tree_map *h;
  77   void **loc;
  78
  79   h = xmalloc (sizeof (struct int_tree_map));
  80   h->uid = uid;
  81   h->to = to;
  82   loc = htab_find_slot_with_hash (complex_variable_components, h,
  83                                   uid, INSERT);
  84   *(struct int_tree_map **)  loc = h;
  85 }
  86
  87
  88 /* Return true if T is not a zero constant.  In the case of real values,
  89    we're only interested in +0.0.  */
  90
  91 static int
  92 some_nonzerop (tree t)
  93 {
  94   int zerop = false;
  95
  96   if (TREE_CODE (t) == REAL_CST)
  97     zerop = REAL_VALUES_IDENTICAL (TREE_REAL_CST (t), dconst0);
  98   else if (TREE_CODE (t) == INTEGER_CST)
  99     zerop = integer_zerop (t);
 100
 101   return !zerop;
 102 }
 103
 104 /* Compute a lattice value from T.  It may be a gimple_val, or, as a
 105    special exception, a COMPLEX_EXPR.  */
 106
 107 static complex_lattice_t
 108 find_lattice_value (tree t)
 109 {
 110   tree real, imag;
 111   int r, i;
 112   complex_lattice_t ret;
 113
 114   switch (TREE_CODE (t))
 115     {
 116     case SSA_NAME:
 117       return VEC_index (complex_lattice_t, complex_lattice_values,
 118                         SSA_NAME_VERSION (t));
 119
 120     case COMPLEX_CST:
 121       real = TREE_REALPART (t);
 122       imag = TREE_IMAGPART (t);
 123       break;
 124
 125     case COMPLEX_EXPR:
 126       real = TREE_OPERAND (t, 0);
 127       imag = TREE_OPERAND (t, 1);
 128       break;
 129
 130     default:
 131       gcc_unreachable ();
 132     }
 133
 134   r = some_nonzerop (real);
 135   i = some_nonzerop (imag);
 136   ret = r*ONLY_REAL + i*ONLY_IMAG;
 137
 138   /* ??? On occasion we could do better than mapping 0+0i to real, but we
 139      certainly don't want to leave it UNINITIALIZED, which eventually gets
 140      mapped to VARYING.  */
 141   if (ret == UNINITIALIZED)
 142     ret = ONLY_REAL;
 143
 144   return ret;
 145 }
 146
 147 /* Determine if LHS is something for which we're interested in seeing
 148    simulation results.  */
 149
 150 static bool
 151 is_complex_reg (tree lhs)
 152 {
 153   return TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE && is_gimple_reg (lhs);
 154 }
 155
 156 /* Mark the incoming parameters to the function as VARYING.  */
 157
 158 static void
 159 init_parameter_lattice_values (void)
 160 {
 161   tree parm;
 162
 163   for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = TREE_CHAIN (parm))
 164     if (is_complex_reg (parm) && var_ann (parm) != NULL)
 165       {
 166         tree ssa_name = default_def (parm);
 167         VEC_replace (complex_lattice_t, complex_lattice_values,
 168                      SSA_NAME_VERSION (ssa_name), VARYING);
 169       }
 170 }
 171
 172 /* Initialize DONT_SIMULATE_AGAIN for each stmt and phi.  Return false if
 173    we found no statements we want to simulate, and thus there's nothing for
 174    the entire pass to do.  */
 175
 176 static bool
 177 init_dont_simulate_again (void)
 178 {
 179   basic_block bb;
 180   block_stmt_iterator bsi;
 181   tree phi;
 182   bool saw_a_complex_op = false;
 183
 184   FOR_EACH_BB (bb)
 185     {
 186       for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
 187         DONT_SIMULATE_AGAIN (phi) = !is_complex_reg (PHI_RESULT (phi));
 188
 189       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
 190         {
 191           tree orig_stmt, stmt, rhs = NULL;
 192           bool dsa;
 193
 194           orig_stmt = stmt = bsi_stmt (bsi);
 195
 196           /* Most control-altering statements must be initially
 197              simulated, else we won't cover the entire cfg.  */
 198           dsa = !stmt_ends_bb_p (stmt);
 199
 200           switch (TREE_CODE (stmt))
 201             {
 202             case RETURN_EXPR:
 203               /* We don't care what the lattice value of <retval> is,
 204                  since it's never used as an input to another computation.  */
 205               dsa = true;
 206               stmt = TREE_OPERAND (stmt, 0);
 207               if (!stmt || TREE_CODE (stmt) != MODIFY_EXPR)
 208                 break;
 209               /* FALLTHRU */
 210
 211             case MODIFY_EXPR:
 212               dsa = !is_complex_reg (TREE_OPERAND (stmt, 0));
 213               rhs = TREE_OPERAND (stmt, 1);
 214               break;
 215
 216             case COND_EXPR:
 217               rhs = TREE_OPERAND (stmt, 0);
 218               break;
 219
 220             default:
 221               break;
 222             }
 223
 224           if (rhs)
 225             switch (TREE_CODE (rhs))
 226               {
 227               case EQ_EXPR:
 228               case NE_EXPR:
 229                 rhs = TREE_OPERAND (rhs, 0);
 230                 /* FALLTHRU */
 231
 232               case PLUS_EXPR:
 233               case MINUS_EXPR:
 234               case MULT_EXPR:
 235               case TRUNC_DIV_EXPR:
 236               case CEIL_DIV_EXPR:
 237               case FLOOR_DIV_EXPR:
 238               case ROUND_DIV_EXPR:
 239               case RDIV_EXPR:
 240               case NEGATE_EXPR:
 241               case CONJ_EXPR:
 242                 if (TREE_CODE (TREE_TYPE (rhs)) == COMPLEX_TYPE)
 243                   saw_a_complex_op = true;
 244                 break;
 245
 246               default:
 247                 break;
 248               }
 249
 250           DONT_SIMULATE_AGAIN (orig_stmt) = dsa;
 251         }
 252     }
 253
 254   return saw_a_complex_op;
 255 }
 256
 257
 258 /* Evaluate statement STMT against the complex lattice defined above.  */
 259
 260 static enum ssa_prop_result
 261 complex_visit_stmt (tree stmt, edge *taken_edge_p ATTRIBUTE_UNUSED,
 262                     tree *result_p)
 263 {
 264   complex_lattice_t new_l, old_l, op1_l, op2_l;
 265   unsigned int ver;
 266   tree lhs, rhs;
 267
 268   if (TREE_CODE (stmt) != MODIFY_EXPR)
 269     return SSA_PROP_VARYING;
 270
 271   lhs = TREE_OPERAND (stmt, 0);
 272   rhs = TREE_OPERAND (stmt, 1);
 273
 274   /* These conditions should be satisfied due to the initial filter
 275      set up in init_dont_simulate_again.  */
 276   gcc_assert (TREE_CODE (lhs) == SSA_NAME);
 277   gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
 278
 279   *result_p = lhs;
 280   ver = SSA_NAME_VERSION (lhs);
 281   old_l = VEC_index (complex_lattice_t, complex_lattice_values, ver);
 282
 283   switch (TREE_CODE (rhs))
 284     {
 285     case SSA_NAME:
 286     case COMPLEX_EXPR:
 287     case COMPLEX_CST:
 288       new_l = find_lattice_value (rhs);
 289       break;
 290
 291     case PLUS_EXPR:
 292     case MINUS_EXPR:
 293       op1_l = find_lattice_value (TREE_OPERAND (rhs, 0));
 294       op2_l = find_lattice_value (TREE_OPERAND (rhs, 1));
 295
 296       /* We've set up the lattice values such that IOR neatly
 297          models addition.  */
 298       new_l = op1_l | op2_l;
 299       break;
 300
 301     case MULT_EXPR:
 302     case RDIV_EXPR:
 303     case TRUNC_DIV_EXPR:
 304     case CEIL_DIV_EXPR:
 305     case FLOOR_DIV_EXPR:
 306     case ROUND_DIV_EXPR:
 307       op1_l = find_lattice_value (TREE_OPERAND (rhs, 0));
 308       op2_l = find_lattice_value (TREE_OPERAND (rhs, 1));
 309
 310       /* Obviously, if either varies, so does the result.  */
 311       if (op1_l == VARYING || op2_l == VARYING)
 312         new_l = VARYING;
 313       /* Don't prematurely promote variables if we've not yet seen
 314          their inputs.  */
 315       else if (op1_l == UNINITIALIZED)
 316         new_l = op2_l;
 317       else if (op2_l == UNINITIALIZED)
 318         new_l = op1_l;
 319       else
 320         {
 321           /* At this point both numbers have only one component. If the
 322              numbers are of opposite kind, the result is imaginary,
 323              otherwise the result is real. The add/subtract translates
 324              the real/imag from/to 0/1; the ^ performs the comparison.  */
 325           new_l = ((op1_l - ONLY_REAL) ^ (op2_l - ONLY_REAL)) + ONLY_REAL;
 326
 327           /* Don't allow the lattice value to flip-flop indefinitely.  */
 328           new_l |= old_l;
 329         }
 330       break;
 331
 332     case NEGATE_EXPR:
 333     case CONJ_EXPR:
 334       new_l = find_lattice_value (TREE_OPERAND (rhs, 0));
 335       break;
 336
 337     default:
 338       new_l = VARYING;
 339       break;
 340     }
 341
 342   /* If nothing changed this round, let the propagator know.  */
 343   if (new_l == old_l)
 344     return SSA_PROP_NOT_INTERESTING;
 345
 346   VEC_replace (complex_lattice_t, complex_lattice_values, ver, new_l);
 347   return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
 348 }
 349
 350 /* Evaluate a PHI node against the complex lattice defined above.  */
 351
 352 static enum ssa_prop_result
 353 complex_visit_phi (tree phi)
 354 {
 355   complex_lattice_t new_l, old_l;
 356   unsigned int ver;
 357   tree lhs;
 358   int i;
 359
 360   lhs = PHI_RESULT (phi);
 361
 362   /* This condition should be satisfied due to the initial filter
 363      set up in init_dont_simulate_again.  */
 364   gcc_assert (TREE_CODE (TREE_TYPE (lhs)) == COMPLEX_TYPE);
 365
 366   /* We've set up the lattice values such that IOR neatly models PHI meet.  */
 367   new_l = UNINITIALIZED;
 368   for (i = PHI_NUM_ARGS (phi) - 1; i >= 0; --i)
 369     new_l |= find_lattice_value (PHI_ARG_DEF (phi, i));
 370
 371   ver = SSA_NAME_VERSION (lhs);
 372   old_l = VEC_index (complex_lattice_t, complex_lattice_values, ver);
 373
 374   if (new_l == old_l)
 375     return SSA_PROP_NOT_INTERESTING;
 376
 377   VEC_replace (complex_lattice_t, complex_lattice_values, ver, new_l);
 378   return new_l == VARYING ? SSA_PROP_VARYING : SSA_PROP_INTERESTING;
 379 }
 380
 381 /* For each referenced complex gimple register, set up a pair of registers
 382    to hold the components of the complex value.  */
 383
 384 static void
 385 create_components (void)
 386 {
 387   size_t n;
 388   tree var;
 389   referenced_var_iterator rvi;
 390
 391   n = num_referenced_vars;
 392   if (n == 0)
 393     return;
 394
 395   complex_variable_components = htab_create (10,  int_tree_map_hash,
 396                                              int_tree_map_eq, free);
 397
 398   FOR_EACH_REFERENCED_VAR (var, rvi)
 399     {
 400       tree r = NULL, i = NULL;
 401
 402       if (var != NULL
 403           && TREE_CODE (TREE_TYPE (var)) == COMPLEX_TYPE
 404           && is_gimple_reg (var))
 405         {
 406           tree inner_type = TREE_TYPE (TREE_TYPE (var));
 407
 408           r = make_rename_temp (inner_type, "CR");
 409           i = make_rename_temp (inner_type, "CI");
 410           DECL_SOURCE_LOCATION (r) = DECL_SOURCE_LOCATION (var);
 411           DECL_SOURCE_LOCATION (i) = DECL_SOURCE_LOCATION (var);
 412           DECL_ARTIFICIAL (r) = 1;
 413           DECL_ARTIFICIAL (i) = 1;
 414
 415           if (DECL_NAME (var) && !DECL_IGNORED_P (var))
 416             {
 417               const char *name = IDENTIFIER_POINTER (DECL_NAME (var));
 418
 419               DECL_NAME (r) = get_identifier (ACONCAT ((name, "$real", NULL)));
 420               DECL_NAME (i) = get_identifier (ACONCAT ((name, "$imag", NULL)));
 421
 422               SET_DECL_DEBUG_EXPR (r, build1 (REALPART_EXPR, inner_type, var));
 423               SET_DECL_DEBUG_EXPR (i, build1 (IMAGPART_EXPR, inner_type, var));
 424               DECL_DEBUG_EXPR_IS_FROM (r) = 1;
 425               DECL_DEBUG_EXPR_IS_FROM (i) = 1;
 426
 427               DECL_IGNORED_P (r) = 0;
 428               DECL_IGNORED_P (i) = 0;
 429
 430               TREE_NO_WARNING (r) = TREE_NO_WARNING (var);
 431               TREE_NO_WARNING (i) = TREE_NO_WARNING (var);
 432             }
 433           else
 434             {
 435               DECL_IGNORED_P (r) = 1;
 436               DECL_IGNORED_P (i) = 1;
 437               TREE_NO_WARNING (r) = 1;
 438               TREE_NO_WARNING (i) = 1;
 439             }
 440         }
 441
 442       cvc_insert (2 * DECL_UID (var), r);
 443       cvc_insert (2 * DECL_UID (var) + 1, i);
 444     }
 445 }
 446
 447 /* Extract the real or imaginary part of a complex variable or constant.
 448    Make sure that it's a proper gimple_val and gimplify it if not.
 449    Emit any new code before BSI.  */
 450
 451 static tree
 452 extract_component (block_stmt_iterator *bsi, tree t, bool imagpart_p,
 453                    bool gimple_p)
 454 {
 455   switch (TREE_CODE (t))
 456     {
 457     case COMPLEX_CST:
 458       return imagpart_p ? TREE_IMAGPART (t) : TREE_REALPART (t);
 459
 460     case COMPLEX_EXPR:
 461       return TREE_OPERAND (t, imagpart_p);
 462
 463     case VAR_DECL:
 464     case PARM_DECL:
 465     case INDIRECT_REF:
 466     case COMPONENT_REF:
 467     case ARRAY_REF:
 468       {
 469         tree inner_type = TREE_TYPE (TREE_TYPE (t));
 470
 471         t = build1 ((imagpart_p ? IMAGPART_EXPR : REALPART_EXPR),
 472                     inner_type, unshare_expr (t));
 473
 474         if (gimple_p)
 475           t = gimplify_val (bsi, inner_type, t);
 476
 477         return t;
 478       }
 479
 480     case SSA_NAME:
 481       {
 482         tree def = SSA_NAME_DEF_STMT (t);
 483
 484         if (TREE_CODE (def) == MODIFY_EXPR)
 485           {
 486             def = TREE_OPERAND (def, 1);
 487             if (TREE_CODE (def) == COMPLEX_CST)
 488               return imagpart_p ? TREE_IMAGPART (def) : TREE_REALPART (def);
 489             if (TREE_CODE (def) == COMPLEX_EXPR)
 490               {
 491                 def = TREE_OPERAND (def, imagpart_p);
 492                 if (TREE_CONSTANT (def))
 493                   return def;
 494               }
 495           }
 496
 497         return cvc_lookup (DECL_UID (SSA_NAME_VAR (t)) * 2 + imagpart_p);
 498       }
 499
 500     default:
 501       gcc_unreachable ();
 502     }
 503 }
 504
 505 /* Update the complex components of the ssa name on the lhs of STMT.  */
 506
 507 static void
 508 update_complex_components (block_stmt_iterator *bsi, tree stmt, tree r, tree i)
 509 {
 510   unsigned int uid = DECL_UID (SSA_NAME_VAR (TREE_OPERAND (stmt, 0)));
 511   tree v, x;
 512
 513   v = cvc_lookup (2*uid);
 514   x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, r);
 515   SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
 516   TREE_BLOCK (x) = TREE_BLOCK (stmt);
 517   bsi_insert_after (bsi, x, BSI_NEW_STMT);
 518
 519   v = cvc_lookup (2*uid + 1);
 520   x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, i);
 521   SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
 522   TREE_BLOCK (x) = TREE_BLOCK (stmt);
 523   bsi_insert_after (bsi, x, BSI_NEW_STMT);
 524 }
 525
 526 static void
 527 update_complex_components_on_edge (edge e, tree stmt, tree lhs, tree r, tree i)
 528 {
 529   unsigned int uid = DECL_UID (SSA_NAME_VAR (lhs));
 530   tree v, x;
 531
 532   v = cvc_lookup (2*uid);
 533   x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, r);
 534   if (stmt)
 535     {
 536       SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
 537       TREE_BLOCK (x) = TREE_BLOCK (stmt);
 538     }
 539   bsi_insert_on_edge (e, x);
 540
 541   v = cvc_lookup (2*uid + 1);
 542   x = build2 (MODIFY_EXPR, TREE_TYPE (v), v, i);
 543   if (stmt)
 544     {
 545       SET_EXPR_LOCUS (x, EXPR_LOCUS (stmt));
 546       TREE_BLOCK (x) = TREE_BLOCK (stmt);
 547     }
 548   bsi_insert_on_edge (e, x);
 549 }
 550
 551 /* Update an assignment to a complex variable in place.  */
 552
 553 static void
 554 update_complex_assignment (block_stmt_iterator *bsi, tree r, tree i)
 555 {
 556   tree stmt, mod;
 557   tree type;
 558
 559   mod = stmt = bsi_stmt (*bsi);
 560   if (TREE_CODE (stmt) == RETURN_EXPR)
 561     mod = TREE_OPERAND (mod, 0);
 562   else if (in_ssa_p)
 563     update_complex_components (bsi, stmt, r, i);
 564
 565   type = TREE_TYPE (TREE_OPERAND (mod, 1));
 566   TREE_OPERAND (mod, 1) = build (COMPLEX_EXPR, type, r, i);
 567   update_stmt (stmt);
 568 }
 569
 570 /* Generate code at the entry point of the function to initialize the
 571    component variables for a complex parameter.  */
 572
 573 static void
 574 update_parameter_components (void)
 575 {
 576   edge entry_edge = single_succ_edge (ENTRY_BLOCK_PTR);
 577   tree parm;
 578
 579   for (parm = DECL_ARGUMENTS (cfun->decl); parm ; parm = TREE_CHAIN (parm))
 580     {
 581       tree type = TREE_TYPE (parm);
 582       tree ssa_name, r, i;
 583
 584       if (TREE_CODE (type) != COMPLEX_TYPE || !is_gimple_reg (parm))
 585         continue;
 586
 587       type = TREE_TYPE (type);
 588       ssa_name = default_def (parm);
 589
 590       r = build1 (REALPART_EXPR, type, ssa_name);
 591       i = build1 (IMAGPART_EXPR, type, ssa_name);
 592       update_complex_components_on_edge (entry_edge, NULL, ssa_name, r, i);
 593     }
 594 }
 595
 596 /* Generate code to set the component variables of a complex variable
 597    to match the PHI statements in block BB.  */
 598
 599 static void
 600 update_phi_components (basic_block bb)
 601 {
 602   tree phi;
 603
 604   for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
 605     if (is_complex_reg (PHI_RESULT (phi)))
 606       {
 607         unsigned int i, n;
 608         tree lhs = PHI_RESULT (phi);
 609
 610         for (i = 0, n = PHI_NUM_ARGS (phi); i < n; ++i)
 611           {
 612             edge e = PHI_ARG_EDGE (phi, i);
 613             tree arg = PHI_ARG_DEF (phi, i);
 614             tree r, i;
 615
 616             /* Avoid no-op assignments.  This also prevents insertting stmts
 617                onto abnormal edges, assuming the PHI isn't already broken.  */
 618             if (TREE_CODE (arg) == SSA_NAME
 619                 && SSA_NAME_VAR (arg) == SSA_NAME_VAR (lhs))
 620               continue;
 621
 622             r = extract_component (NULL, arg, 0, false);
 623             i = extract_component (NULL, arg, 1, false);
 624             update_complex_components_on_edge (e, NULL, lhs, r, i);
 625           }
 626       }
 627 }
 628
 629 /* Mark each virtual op in STMT for ssa update.  */
 630
 631 static void
 632 update_all_vops (tree stmt)
 633 {
 634   ssa_op_iter iter;
 635   tree sym;
 636
 637   FOR_EACH_SSA_TREE_OPERAND (sym, stmt, iter, SSA_OP_ALL_VIRTUALS)
 638     {
 639       if (TREE_CODE (sym) == SSA_NAME)
 640         sym = SSA_NAME_VAR (sym);
 641       mark_sym_for_renaming (sym);
 642     }
 643 }
 644
 645 /* Expand a complex move to scalars.  */
 646
 647 static void
 648 expand_complex_move (block_stmt_iterator *bsi, tree stmt, tree type,
 649                      tree lhs, tree rhs)
 650 {
 651   tree inner_type = TREE_TYPE (type);
 652   tree r, i;
 653
 654   if (TREE_CODE (lhs) == SSA_NAME)
 655     {
 656       if (is_ctrl_altering_stmt (bsi_stmt (*bsi)))
 657         {
 658           edge_iterator ei;
 659           edge e;
 660
 661           /* The value is not assigned on the exception edges, so we need not
 662              concern ourselves there.  We do need to update on the fallthru
 663              edge.  Find it.  */
 664           FOR_EACH_EDGE (e, ei, bsi->bb->succs)
 665             if (e->flags & EDGE_FALLTHRU)
 666               goto found_fallthru;
 667           gcc_unreachable ();
 668         found_fallthru:
 669
 670           r = build1 (REALPART_EXPR, inner_type, lhs);
 671           i = build1 (IMAGPART_EXPR, inner_type, lhs);
 672           update_complex_components_on_edge (e, stmt, lhs, r, i);
 673         }
 674       else if (TREE_CODE (rhs) == CALL_EXPR || TREE_SIDE_EFFECTS (rhs))
 675         {
 676           r = build1 (REALPART_EXPR, inner_type, lhs);
 677           i = build1 (IMAGPART_EXPR, inner_type, lhs);
 678           update_complex_components (bsi, stmt, r, i);
 679         }
 680       else
 681         {
 682           update_all_vops (bsi_stmt (*bsi));
 683           r = extract_component (bsi, rhs, 0, true);
 684           i = extract_component (bsi, rhs, 1, true);
 685           update_complex_assignment (bsi, r, i);
 686         }
 687     }
 688   else if (TREE_CODE (rhs) == SSA_NAME && !TREE_SIDE_EFFECTS (lhs))
 689     {
 690       tree x;
 691
 692       r = extract_component (bsi, rhs, 0, false);
 693       i = extract_component (bsi, rhs, 1, false);
 694
 695       x = build1 (REALPART_EXPR, inner_type, unshare_expr (lhs));
 696       x = build2 (MODIFY_EXPR, inner_type, x, r);
 697       bsi_insert_before (bsi, x, BSI_SAME_STMT);
 698
 699       if (stmt == bsi_stmt (*bsi))
 700         {
 701           x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
 702           TREE_OPERAND (stmt, 0) = x;
 703           TREE_OPERAND (stmt, 1) = i;
 704           TREE_TYPE (stmt) = inner_type;
 705         }
 706       else
 707         {
 708           x = build1 (IMAGPART_EXPR, inner_type, unshare_expr (lhs));
 709           x = build2 (MODIFY_EXPR, inner_type, x, i);
 710           bsi_insert_before (bsi, x, BSI_SAME_STMT);
 711
 712           stmt = bsi_stmt (*bsi);
 713           gcc_assert (TREE_CODE (stmt) == RETURN_EXPR);
 714           TREE_OPERAND (stmt, 0) = lhs;
 715         }
 716
 717       update_all_vops (stmt);
 718       update_stmt (stmt);
 719     }
 720 }
 721
 722 /* Expand complex addition to scalars:
 723         a + b = (ar + br) + i(ai + bi)
 724         a - b = (ar - br) + i(ai + bi)
 725 */
 726
 727 static void
 728 expand_complex_addition (block_stmt_iterator *bsi, tree inner_type,
 729                          tree ar, tree ai, tree br, tree bi,
 730                          enum tree_code code,
 731                          complex_lattice_t al, complex_lattice_t bl)
 732 {
 733   tree rr, ri;
 734
 735   switch (PAIR (al, bl))
 736     {
 737     case PAIR (ONLY_REAL, ONLY_REAL):
 738       rr = gimplify_build2 (bsi, code, inner_type, ar, br);
 739       ri = ai;
 740       break;
 741
 742     case PAIR (ONLY_REAL, ONLY_IMAG):
 743       rr = ar;
 744       if (code == MINUS_EXPR)
 745         ri = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, bi);
 746       else
 747         ri = bi;
 748       break;
 749
 750     case PAIR (ONLY_IMAG, ONLY_REAL):
 751       if (code == MINUS_EXPR)
 752         rr = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ar, br);
 753       else
 754         rr = br;
 755       ri = ai;
 756       break;
 757
 758     case PAIR (ONLY_IMAG, ONLY_IMAG):
 759       rr = ar;
 760       ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
 761       break;
 762
 763     case PAIR (VARYING, ONLY_REAL):
 764       rr = gimplify_build2 (bsi, code, inner_type, ar, br);
 765       ri = ai;
 766       break;
 767
 768     case PAIR (VARYING, ONLY_IMAG):
 769       rr = ar;
 770       ri = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, bi);
 771       break;
 772
 773     case PAIR (ONLY_REAL, VARYING):
 774       if (code == MINUS_EXPR)
 775         goto general;
 776       rr = gimplify_build2 (bsi, code, inner_type, ar, br);
 777       ri = bi;
 778       break;
 779
 780     case PAIR (ONLY_IMAG, VARYING):
 781       if (code == MINUS_EXPR)
 782         goto general;
 783       rr = br;
 784       ri = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, bi);
 785       break;
 786
 787     case PAIR (VARYING, VARYING):
 788     general:
 789       rr = gimplify_build2 (bsi, code, inner_type, ar, br);
 790       ri = gimplify_build2 (bsi, code, inner_type, ai, bi);
 791       break;
 792
 793     default:
 794       gcc_unreachable ();
 795     }
 796
 797   update_complex_assignment (bsi, rr, ri);
 798 }
 799
 800 /* Expand a complex multiplication or division to a libcall to the c99
 801    compliant routines.  */
 802
 803 static void
 804 expand_complex_libcall (block_stmt_iterator *bsi, tree ar, tree ai,
 805                         tree br, tree bi, enum tree_code code)
 806 {
 807   enum machine_mode mode;
 808   enum built_in_function bcode;
 809   tree args, fn, stmt, type;
 810
 811   args = tree_cons (NULL, bi, NULL);
 812   args = tree_cons (NULL, br, args);
 813   args = tree_cons (NULL, ai, args);
 814   args = tree_cons (NULL, ar, args);
 815
 816   stmt = bsi_stmt (*bsi);
 817   type = TREE_TYPE (TREE_OPERAND (stmt, 1));
 818
 819   mode = TYPE_MODE (type);
 820   gcc_assert (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT);
 821   if (code == MULT_EXPR)
 822     bcode = BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
 823   else if (code == RDIV_EXPR)
 824     bcode = BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
 825   else
 826     gcc_unreachable ();
 827   fn = built_in_decls[bcode];
 828
 829   TREE_OPERAND (stmt, 1)
 830     = build3 (CALL_EXPR, type, build_fold_addr_expr (fn), args, NULL);
 831   update_stmt (stmt);
 832
 833   if (in_ssa_p)
 834     {
 835       tree lhs = TREE_OPERAND (stmt, 0);
 836       type = TREE_TYPE (type);
 837       update_complex_components (bsi, stmt,
 838                                  build1 (REALPART_EXPR, type, lhs),
 839                                  build1 (IMAGPART_EXPR, type, lhs));
 840     }
 841 }
 842
 843 /* Expand complex multiplication to scalars:
 844         a * b = (ar*br - ai*bi) + i(ar*bi + br*ai)
 845 */
 846
 847 static void
 848 expand_complex_multiplication (block_stmt_iterator *bsi, tree inner_type,
 849                                tree ar, tree ai, tree br, tree bi,
 850                                complex_lattice_t al, complex_lattice_t bl)
 851 {
 852   tree rr, ri;
 853
 854   if (al < bl)
 855     {
 856       complex_lattice_t tl;
 857       rr = ar, ar = br, br = rr;
 858       ri = ai, ai = bi, bi = ri;
 859       tl = al, al = bl, bl = tl;
 860     }
 861
 862   switch (PAIR (al, bl))
 863     {
 864     case PAIR (ONLY_REAL, ONLY_REAL):
 865       rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
 866       ri = ai;
 867       break;
 868
 869     case PAIR (ONLY_IMAG, ONLY_REAL):
 870       rr = ar;
 871       if (TREE_CODE (ai) == REAL_CST
 872           && REAL_VALUES_IDENTICAL (TREE_REAL_CST (ai), dconst1))
 873         ri = br;
 874       else
 875         ri = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
 876       break;
 877
 878     case PAIR (ONLY_IMAG, ONLY_IMAG):
 879       rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
 880       rr = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, rr);
 881       ri = ar;
 882       break;
 883
 884     case PAIR (VARYING, ONLY_REAL):
 885       rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
 886       ri = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
 887       break;
 888
 889     case PAIR (VARYING, ONLY_IMAG):
 890       rr = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
 891       rr = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, rr);
 892       ri = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, bi);
 893       break;
 894
 895     case PAIR (VARYING, VARYING):
 896       if (flag_complex_method == 2 && SCALAR_FLOAT_TYPE_P (inner_type))
 897         {
 898           expand_complex_libcall (bsi, ar, ai, br, bi, MULT_EXPR);
 899           return;
 900         }
 901       else
 902         {
 903           tree t1, t2, t3, t4;
 904
 905           t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
 906           t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
 907           t3 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, bi);
 908
 909           /* Avoid expanding redundant multiplication for the common
 910              case of squaring a complex number.  */
 911           if (ar == br && ai == bi)
 912             t4 = t3;
 913           else
 914             t4 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
 915
 916           rr = gimplify_build2 (bsi, MINUS_EXPR, inner_type, t1, t2);
 917           ri = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t3, t4);
 918         }
 919       break;
 920
 921     default:
 922       gcc_unreachable ();
 923     }
 924
 925   update_complex_assignment (bsi, rr, ri);
 926 }
 927
 928 /* Expand complex division to scalars, straightforward algorithm.
 929         a / b = ((ar*br + ai*bi)/t) + i((ai*br - ar*bi)/t)
 930             t = br*br + bi*bi
 931 */
 932
 933 static void
 934 expand_complex_div_straight (block_stmt_iterator *bsi, tree inner_type,
 935                              tree ar, tree ai, tree br, tree bi,
 936                              enum tree_code code)
 937 {
 938   tree rr, ri, div, t1, t2, t3;
 939
 940   t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, br, br);
 941   t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, bi, bi);
 942   div = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, t2);
 943
 944   t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, br);
 945   t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, bi);
 946   t3 = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, t2);
 947   rr = gimplify_build2 (bsi, code, inner_type, t3, div);
 948
 949   t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, br);
 950   t2 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, bi);
 951   t3 = gimplify_build2 (bsi, MINUS_EXPR, inner_type, t1, t2);
 952   ri = gimplify_build2 (bsi, code, inner_type, t3, div);
 953
 954   update_complex_assignment (bsi, rr, ri);
 955 }
 956
 957 /* Expand complex division to scalars, modified algorithm to minimize
 958    overflow with wide input ranges.  */
 959
 960 static void
 961 expand_complex_div_wide (block_stmt_iterator *bsi, tree inner_type,
 962                          tree ar, tree ai, tree br, tree bi,
 963                          enum tree_code code)
 964 {
 965   tree rr, ri, ratio, div, t1, t2, tr, ti, cond;
 966   basic_block bb_cond, bb_true, bb_false, bb_join;
 967
 968   /* Examine |br| < |bi|, and branch.  */
 969   t1 = gimplify_build1 (bsi, ABS_EXPR, inner_type, br);
 970   t2 = gimplify_build1 (bsi, ABS_EXPR, inner_type, bi);
 971   cond = fold_build2 (LT_EXPR, boolean_type_node, t1, t2);
 972   STRIP_NOPS (cond);
 973
 974   bb_cond = bb_true = bb_false = bb_join = NULL;
 975   rr = ri = tr = ti = NULL;
 976   if (!TREE_CONSTANT (cond))
 977     {
 978       edge e;
 979
 980       cond = build (COND_EXPR, void_type_node, cond, NULL, NULL);
 981       bsi_insert_before (bsi, cond, BSI_SAME_STMT);
 982
 983       /* Split the original block, and create the TRUE and FALSE blocks.  */
 984       e = split_block (bsi->bb, cond);
 985       bb_cond = e->src;
 986       bb_join = e->dest;
 987       bb_true = create_empty_bb (bb_cond);
 988       bb_false = create_empty_bb (bb_true);
 989
 990       t1 = build (GOTO_EXPR, void_type_node, tree_block_label (bb_true));
 991       t2 = build (GOTO_EXPR, void_type_node, tree_block_label (bb_false));
 992       COND_EXPR_THEN (cond) = t1;
 993       COND_EXPR_ELSE (cond) = t2;
 994
 995       /* Wire the blocks together.  */
 996       e->flags = EDGE_TRUE_VALUE;
 997       redirect_edge_succ (e, bb_true);
 998       make_edge (bb_cond, bb_false, EDGE_FALSE_VALUE);
 999       make_edge (bb_true, bb_join, EDGE_FALLTHRU);
1000       make_edge (bb_false, bb_join, EDGE_FALLTHRU);
1001
1002       /* Update dominance info.  Note that bb_join's data was
1003          updated by split_block.  */
1004       if (dom_info_available_p (CDI_DOMINATORS))
1005         {
1006           set_immediate_dominator (CDI_DOMINATORS, bb_true, bb_cond);
1007           set_immediate_dominator (CDI_DOMINATORS, bb_false, bb_cond);
1008         }
1009
1010       rr = make_rename_temp (inner_type, NULL);
1011       ri = make_rename_temp (inner_type, NULL);
1012     }
1013
1014   /* In the TRUE branch, we compute
1015       ratio = br/bi;
1016       div = (br * ratio) + bi;
1017       tr = (ar * ratio) + ai;
1018       ti = (ai * ratio) - ar;
1019       tr = tr / div;
1020       ti = ti / div;  */
1021   if (bb_true || integer_nonzerop (cond))
1022     {
1023       if (bb_true)
1024         {
1025           *bsi = bsi_last (bb_true);
1026           bsi_insert_after (bsi, build_empty_stmt (), BSI_NEW_STMT);
1027         }
1028
1029       ratio = gimplify_build2 (bsi, code, inner_type, br, bi);
1030
1031       t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, br, ratio);
1032       div = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, bi);
1033
1034       t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, ratio);
1035       tr = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, ai);
1036
1037       t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, ratio);
1038       ti = gimplify_build2 (bsi, MINUS_EXPR, inner_type, t1, ar);
1039
1040       tr = gimplify_build2 (bsi, code, inner_type, tr, div);
1041       ti = gimplify_build2 (bsi, code, inner_type, ti, div);
1042
1043      if (bb_true)
1044        {
1045          t1 = build (MODIFY_EXPR, inner_type, rr, tr);
1046          bsi_insert_before (bsi, t1, BSI_SAME_STMT);
1047          t1 = build (MODIFY_EXPR, inner_type, ri, ti);
1048          bsi_insert_before (bsi, t1, BSI_SAME_STMT);
1049          bsi_remove (bsi);
1050        }
1051     }
1052
1053   /* In the FALSE branch, we compute
1054       ratio = d/c;
1055       divisor = (d * ratio) + c;
1056       tr = (b * ratio) + a;
1057       ti = b - (a * ratio);
1058       tr = tr / div;
1059       ti = ti / div;  */
1060   if (bb_false || integer_zerop (cond))
1061     {
1062       if (bb_false)
1063         {
1064           *bsi = bsi_last (bb_false);
1065           bsi_insert_after (bsi, build_empty_stmt (), BSI_NEW_STMT);
1066         }
1067
1068       ratio = gimplify_build2 (bsi, code, inner_type, bi, br);
1069
1070       t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, bi, ratio);
1071       div = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, br);
1072
1073       t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ai, ratio);
1074       tr = gimplify_build2 (bsi, PLUS_EXPR, inner_type, t1, ar);
1075
1076       t1 = gimplify_build2 (bsi, MULT_EXPR, inner_type, ar, ratio);
1077       ti = gimplify_build2 (bsi, MINUS_EXPR, inner_type, ai, t1);
1078
1079       tr = gimplify_build2 (bsi, code, inner_type, tr, div);
1080       ti = gimplify_build2 (bsi, code, inner_type, ti, div);
1081
1082      if (bb_false)
1083        {
1084          t1 = build (MODIFY_EXPR, inner_type, rr, tr);
1085          bsi_insert_before (bsi, t1, BSI_SAME_STMT);
1086          t1 = build (MODIFY_EXPR, inner_type, ri, ti);
1087          bsi_insert_before (bsi, t1, BSI_SAME_STMT);
1088          bsi_remove (bsi);
1089        }
1090     }
1091
1092   if (bb_join)
1093     *bsi = bsi_start (bb_join);
1094   else
1095     rr = tr, ri = ti;
1096
1097   update_complex_assignment (bsi, rr, ri);
1098 }
1099
1100 /* Expand complex division to scalars.  */
1101
1102 static void
1103 expand_complex_division (block_stmt_iterator *bsi, tree inner_type,
1104                          tree ar, tree ai, tree br, tree bi,
1105                          enum tree_code code,
1106                          complex_lattice_t al, complex_lattice_t bl)
1107 {
1108   tree rr, ri;
1109
1110   switch (PAIR (al, bl))
1111     {
1112     case PAIR (ONLY_REAL, ONLY_REAL):
1113       rr = gimplify_build2 (bsi, code, inner_type, ar, br);
1114       ri = ai;
1115       break;
1116
1117     case PAIR (ONLY_REAL, ONLY_IMAG):
1118       rr = ai;
1119       ri = gimplify_build2 (bsi, code, inner_type, ar, bi);
1120       ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ri);
1121       break;
1122
1123     case PAIR (ONLY_IMAG, ONLY_REAL):
1124       rr = ar;
1125       ri = gimplify_build2 (bsi, code, inner_type, ai, br);
1126       break;
1127
1128     case PAIR (ONLY_IMAG, ONLY_IMAG):
1129       rr = gimplify_build2 (bsi, code, inner_type, ai, bi);
1130       ri = ar;
1131       break;
1132
1133     case PAIR (VARYING, ONLY_REAL):
1134       rr = gimplify_build2 (bsi, code, inner_type, ar, br);
1135       ri = gimplify_build2 (bsi, code, inner_type, ai, br);
1136       break;
1137
1138     case PAIR (VARYING, ONLY_IMAG):
1139       rr = gimplify_build2 (bsi, code, inner_type, ai, bi);
1140       ri = gimplify_build2 (bsi, code, inner_type, ar, bi);
1141       ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ri);
1142
1143     case PAIR (ONLY_REAL, VARYING):
1144     case PAIR (ONLY_IMAG, VARYING):
1145     case PAIR (VARYING, VARYING):
1146       switch (flag_complex_method)
1147         {
1148         case 0:
1149           /* straightforward implementation of complex divide acceptable.  */
1150           expand_complex_div_straight (bsi, inner_type, ar, ai, br, bi, code);
1151           break;
1152
1153         case 2:
1154           if (SCALAR_FLOAT_TYPE_P (inner_type))
1155             {
1156               expand_complex_libcall (bsi, ar, ai, br, bi, code);
1157               break;
1158             }
1159           /* FALLTHRU */
1160
1161         case 1:
1162           /* wide ranges of inputs must work for complex divide.  */
1163           expand_complex_div_wide (bsi, inner_type, ar, ai, br, bi, code);
1164           break;
1165
1166         default:
1167           gcc_unreachable ();
1168         }
1169       return;
1170
1171     default:
1172       gcc_unreachable ();
1173     }
1174
1175   update_complex_assignment (bsi, rr, ri);
1176 }
1177
1178 /* Expand complex negation to scalars:
1179         -a = (-ar) + i(-ai)
1180 */
1181
1182 static void
1183 expand_complex_negation (block_stmt_iterator *bsi, tree inner_type,
1184                          tree ar, tree ai)
1185 {
1186   tree rr, ri;
1187
1188   rr = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ar);
1189   ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ai);
1190
1191   update_complex_assignment (bsi, rr, ri);
1192 }
1193
1194 /* Expand complex conjugate to scalars:
1195         ~a = (ar) + i(-ai)
1196 */
1197
1198 static void
1199 expand_complex_conjugate (block_stmt_iterator *bsi, tree inner_type,
1200                           tree ar, tree ai)
1201 {
1202   tree ri;
1203
1204   ri = gimplify_build1 (bsi, NEGATE_EXPR, inner_type, ai);
1205
1206   update_complex_assignment (bsi, ar, ri);
1207 }
1208
1209 /* Expand complex comparison (EQ or NE only).  */
1210
1211 static void
1212 expand_complex_comparison (block_stmt_iterator *bsi, tree ar, tree ai,
1213                            tree br, tree bi, enum tree_code code)
1214 {
1215   tree cr, ci, cc, stmt, expr, type;
1216
1217   cr = gimplify_build2 (bsi, code, boolean_type_node, ar, br);
1218   ci = gimplify_build2 (bsi, code, boolean_type_node, ai, bi);
1219   cc = gimplify_build2 (bsi,
1220                         (code == EQ_EXPR ? TRUTH_AND_EXPR : TRUTH_OR_EXPR),
1221                         boolean_type_node, cr, ci);
1222
1223   stmt = expr = bsi_stmt (*bsi);
1224
1225   switch (TREE_CODE (stmt))
1226     {
1227     case RETURN_EXPR:
1228       expr = TREE_OPERAND (stmt, 0);
1229       /* FALLTHRU */
1230     case MODIFY_EXPR:
1231       type = TREE_TYPE (TREE_OPERAND (expr, 1));
1232       TREE_OPERAND (expr, 1) = fold_convert (type, cc);
1233       break;
1234     case COND_EXPR:
1235       TREE_OPERAND (stmt, 0) = cc;
1236       break;
1237     default:
1238       gcc_unreachable ();
1239     }
1240
1241   update_stmt (stmt);
1242 }
1243
1244 /* Process one statement.  If we identify a complex operation, expand it.  */
1245
1246 static void
1247 expand_complex_operations_1 (block_stmt_iterator *bsi)
1248 {
1249   tree stmt = bsi_stmt (*bsi);
1250   tree rhs, type, inner_type;
1251   tree ac, ar, ai, bc, br, bi;
1252   complex_lattice_t al, bl;
1253   enum tree_code code;
1254
1255   switch (TREE_CODE (stmt))
1256     {
1257     case RETURN_EXPR:
1258       stmt = TREE_OPERAND (stmt, 0);
1259       if (!stmt)
1260         return;
1261       if (TREE_CODE (stmt) != MODIFY_EXPR)
1262         return;
1263       /* FALLTHRU */
1264
1265     case MODIFY_EXPR:
1266       rhs = TREE_OPERAND (stmt, 1);
1267       break;
1268
1269     case COND_EXPR:
1270       rhs = TREE_OPERAND (stmt, 0);
1271       break;
1272
1273     default:
1274       return;
1275     }
1276
1277   type = TREE_TYPE (rhs);
1278   code = TREE_CODE (rhs);
1279
1280   /* Initial filter for operations we handle.  */
1281   switch (code)
1282     {
1283     case PLUS_EXPR:
1284     case MINUS_EXPR:
1285     case MULT_EXPR:
1286     case TRUNC_DIV_EXPR:
1287     case CEIL_DIV_EXPR:
1288     case FLOOR_DIV_EXPR:
1289     case ROUND_DIV_EXPR:
1290     case RDIV_EXPR:
1291     case NEGATE_EXPR:
1292     case CONJ_EXPR:
1293       if (TREE_CODE (type) != COMPLEX_TYPE)
1294         return;
1295       inner_type = TREE_TYPE (type);
1296       break;
1297
1298     case EQ_EXPR:
1299     case NE_EXPR:
1300       inner_type = TREE_TYPE (TREE_OPERAND (rhs, 1));
1301       if (TREE_CODE (inner_type) != COMPLEX_TYPE)
1302         return;
1303       break;
1304
1305     default:
1306       {
1307         tree lhs = TREE_OPERAND (stmt, 0);
1308         tree rhs = TREE_OPERAND (stmt, 1);
1309
1310         if (TREE_CODE (type) == COMPLEX_TYPE)
1311           expand_complex_move (bsi, stmt, type, lhs, rhs);
1312         else if ((TREE_CODE (rhs) == REALPART_EXPR
1313                   || TREE_CODE (rhs) == IMAGPART_EXPR)
1314                  && TREE_CODE (TREE_OPERAND (rhs, 0)) == SSA_NAME)
1315           {
1316             TREE_OPERAND (stmt, 1)
1317               = extract_component (bsi, TREE_OPERAND (rhs, 0),
1318                                    TREE_CODE (rhs) == IMAGPART_EXPR, false);
1319             update_stmt (stmt);
1320           }
1321       }
1322       return;
1323     }
1324
1325   /* Extract the components of the two complex values.  Make sure and
1326      handle the common case of the same value used twice specially.  */
1327   ac = TREE_OPERAND (rhs, 0);
1328   ar = extract_component (bsi, ac, 0, true);
1329   ai = extract_component (bsi, ac, 1, true);
1330
1331   if (TREE_CODE_CLASS (code) == tcc_unary)
1332     bc = br = bi = NULL;
1333   else
1334     {
1335       bc = TREE_OPERAND (rhs, 1);
1336       if (ac == bc)
1337         br = ar, bi = ai;
1338       else
1339         {
1340           br = extract_component (bsi, bc, 0, true);
1341           bi = extract_component (bsi, bc, 1, true);
1342         }
1343     }
1344
1345   if (in_ssa_p)
1346     {
1347       al = find_lattice_value (ac);
1348       if (al == UNINITIALIZED)
1349         al = VARYING;
1350
1351       if (TREE_CODE_CLASS (code) == tcc_unary)
1352         bl = UNINITIALIZED;
1353       else if (ac == bc)
1354         bl = al;
1355       else
1356         {
1357           bl = find_lattice_value (bc);
1358           if (bl == UNINITIALIZED)
1359             bl = VARYING;
1360         }
1361     }
1362   else
1363     al = bl = VARYING;
1364
1365   switch (code)
1366     {
1367     case PLUS_EXPR:
1368     case MINUS_EXPR:
1369       expand_complex_addition (bsi, inner_type, ar, ai, br, bi, code, al, bl);
1370       break;
1371
1372     case MULT_EXPR:
1373       expand_complex_multiplication (bsi, inner_type, ar, ai, br, bi, al, bl);
1374       break;
1375
1376     case TRUNC_DIV_EXPR:
1377     case CEIL_DIV_EXPR:
1378     case FLOOR_DIV_EXPR:
1379     case ROUND_DIV_EXPR:
1380     case RDIV_EXPR:
1381       expand_complex_division (bsi, inner_type, ar, ai, br, bi, code, al, bl);
1382       break;
1383
1384     case NEGATE_EXPR:
1385       expand_complex_negation (bsi, inner_type, ar, ai);
1386       break;
1387
1388     case CONJ_EXPR:
1389       expand_complex_conjugate (bsi, inner_type, ar, ai);
1390       break;
1391
1392     case EQ_EXPR:
1393     case NE_EXPR:
1394       expand_complex_comparison (bsi, ar, ai, br, bi, code);
1395       break;
1396
1397     default:
1398       gcc_unreachable ();
1399     }
1400 }
1401
1402 \f
1403 /* Entry point for complex operation lowering during optimization.  */
1404
1405 static void
1406 tree_lower_complex (void)
1407 {
1408   int old_last_basic_block;
1409   block_stmt_iterator bsi;
1410   basic_block bb;
1411
1412   if (!init_dont_simulate_again ())
1413     return;
1414
1415   complex_lattice_values = VEC_alloc (complex_lattice_t, heap, num_ssa_names);
1416   VEC_safe_grow (complex_lattice_t, heap,
1417                  complex_lattice_values, num_ssa_names);
1418   memset (VEC_address (complex_lattice_t, complex_lattice_values), 0,
1419           num_ssa_names * sizeof(complex_lattice_t));
1420   init_parameter_lattice_values ();
1421
1422   ssa_propagate (complex_visit_stmt, complex_visit_phi);
1423
1424   create_components ();
1425   update_parameter_components ();
1426
1427   old_last_basic_block = last_basic_block;
1428   FOR_EACH_BB (bb)
1429     {
1430       if (bb->index >= old_last_basic_block)
1431         continue;
1432       update_phi_components (bb);
1433       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
1434         expand_complex_operations_1 (&bsi);
1435     }
1436
1437   bsi_commit_edge_inserts ();
1438
1439   if (complex_variable_components)
1440     htab_delete (complex_variable_components);
1441
1442   VEC_free (complex_lattice_t, heap, complex_lattice_values);
1443 }
1444
1445 struct tree_opt_pass pass_lower_complex =
1446 {
1447   "cplxlower",                          /* name */
1448   0,                                    /* gate */
1449   tree_lower_complex,                   /* execute */
1450   NULL,                                 /* sub */
1451   NULL,                                 /* next */
1452   0,                                    /* static_pass_number */
1453   0,                                    /* tv_id */
1454   PROP_ssa,                             /* properties_required */
1455   0,                                    /* properties_provided */
1456   0,                                    /* properties_destroyed */
1457   0,                                    /* todo_flags_start */
1458   TODO_dump_func | TODO_ggc_collect
1459     | TODO_update_ssa
1460     | TODO_verify_stmts,                /* todo_flags_finish */
1461   0                                     /* letter */
1462 };
1463
1464 \f
1465 /* Entry point for complex operation lowering without optimization.  */
1466
1467 static void
1468 tree_lower_complex_O0 (void)
1469 {
1470   int old_last_basic_block = last_basic_block;
1471   block_stmt_iterator bsi;
1472   basic_block bb;
1473
1474   FOR_EACH_BB (bb)
1475     {
1476       if (bb->index >= old_last_basic_block)
1477         continue;
1478       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
1479         expand_complex_operations_1 (&bsi);
1480     }
1481 }
1482
1483 static bool
1484 gate_no_optimization (void)
1485 {
1486   return optimize == 0;
1487 }
1488
1489 struct tree_opt_pass pass_lower_complex_O0 =
1490 {
1491   "cplxlower0",                         /* name */
1492   gate_no_optimization,                 /* gate */
1493   tree_lower_complex_O0,                /* execute */
1494   NULL,                                 /* sub */
1495   NULL,                                 /* next */
1496   0,                                    /* static_pass_number */
1497   0,                                    /* tv_id */
1498   PROP_cfg,                             /* properties_required */
1499   0,                                    /* properties_provided */
1500   0,                                    /* properties_destroyed */
1501   0,                                    /* todo_flags_start */
1502   TODO_dump_func | TODO_ggc_collect
1503     | TODO_verify_stmts,                /* todo_flags_finish */
1504   0                                     /* letter */
1505 };