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