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