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