1 /* CPU mode switching 2 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 3 2009 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 under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 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 "rtl.h" 26 #include "regs.h" 27 #include "hard-reg-set.h" 28 #include "flags.h" 29 #include "real.h" 30 #include "insn-config.h" 31 #include "recog.h" 32 #include "basic-block.h" 33 #include "output.h" 34 #include "tm_p.h" 35 #include "function.h" 36 #include "tree-pass.h" 37 #include "timevar.h" 38 #include "df.h" 39 40 /* We want target macros for the mode switching code to be able to refer 41 to instruction attribute values. */ 42 #include "insn-attr.h" 43 44 #ifdef OPTIMIZE_MODE_SWITCHING 45 46 /* The algorithm for setting the modes consists of scanning the insn list 47 and finding all the insns which require a specific mode. Each insn gets 48 a unique struct seginfo element. These structures are inserted into a list 49 for each basic block. For each entity, there is an array of bb_info over 50 the flow graph basic blocks (local var 'bb_info'), and contains a list 51 of all insns within that basic block, in the order they are encountered. 52 53 For each entity, any basic block WITHOUT any insns requiring a specific 54 mode are given a single entry, without a mode. (Each basic block 55 in the flow graph must have at least one entry in the segment table.) 56 57 The LCM algorithm is then run over the flow graph to determine where to 58 place the sets to the highest-priority value in respect of first the first 59 insn in any one block. Any adjustments required to the transparency 60 vectors are made, then the next iteration starts for the next-lower 61 priority mode, till for each entity all modes are exhausted. 62 63 More details are located in the code for optimize_mode_switching(). */ 64 65 /* This structure contains the information for each insn which requires 66 either single or double mode to be set. 67 MODE is the mode this insn must be executed in. 68 INSN_PTR is the insn to be executed (may be the note that marks the 69 beginning of a basic block). 70 BBNUM is the flow graph basic block this insn occurs in. 71 NEXT is the next insn in the same basic block. */ 72 struct seginfo 73 { 74 int mode; 75 rtx insn_ptr; 76 int bbnum; 77 struct seginfo *next; 78 HARD_REG_SET regs_live; 79 }; 80 81 struct bb_info 82 { 83 struct seginfo *seginfo; 84 int computing; 85 }; 86 87 /* These bitmaps are used for the LCM algorithm. */ 88 89 static sbitmap *antic; 90 static sbitmap *transp; 91 static sbitmap *comp; 92 93 static struct seginfo * new_seginfo (int, rtx, int, HARD_REG_SET); 94 static void add_seginfo (struct bb_info *, struct seginfo *); 95 static void reg_dies (rtx, HARD_REG_SET *); 96 static void reg_becomes_live (rtx, const_rtx, void *); 97 static void make_preds_opaque (basic_block, int); 98 99 100 /* This function will allocate a new BBINFO structure, initialized 101 with the MODE, INSN, and basic block BB parameters. */ 102 103 static struct seginfo * 104 new_seginfo (int mode, rtx insn, int bb, HARD_REG_SET regs_live) 105 { 106 struct seginfo *ptr; 107 ptr = XNEW (struct seginfo); 108 ptr->mode = mode; 109 ptr->insn_ptr = insn; 110 ptr->bbnum = bb; 111 ptr->next = NULL; 112 COPY_HARD_REG_SET (ptr->regs_live, regs_live); 113 return ptr; 114 } 115 116 /* Add a seginfo element to the end of a list. 117 HEAD is a pointer to the list beginning. 118 INFO is the structure to be linked in. */ 119 120 static void 121 add_seginfo (struct bb_info *head, struct seginfo *info) 122 { 123 struct seginfo *ptr; 124 125 if (head->seginfo == NULL) 126 head->seginfo = info; 127 else 128 { 129 ptr = head->seginfo; 130 while (ptr->next != NULL) 131 ptr = ptr->next; 132 ptr->next = info; 133 } 134 } 135 136 /* Make all predecessors of basic block B opaque, recursively, till we hit 137 some that are already non-transparent, or an edge where aux is set; that 138 denotes that a mode set is to be done on that edge. 139 J is the bit number in the bitmaps that corresponds to the entity that 140 we are currently handling mode-switching for. */ 141 142 static void 143 make_preds_opaque (basic_block b, int j) 144 { 145 edge e; 146 edge_iterator ei; 147 148 FOR_EACH_EDGE (e, ei, b->preds) 149 { 150 basic_block pb = e->src; 151 152 if (e->aux || ! TEST_BIT (transp[pb->index], j)) 153 continue; 154 155 RESET_BIT (transp[pb->index], j); 156 make_preds_opaque (pb, j); 157 } 158 } 159 160 /* Record in LIVE that register REG died. */ 161 162 static void 163 reg_dies (rtx reg, HARD_REG_SET *live) 164 { 165 int regno; 166 167 if (!REG_P (reg)) 168 return; 169 170 regno = REGNO (reg); 171 if (regno < FIRST_PSEUDO_REGISTER) 172 remove_from_hard_reg_set (live, GET_MODE (reg), regno); 173 } 174 175 /* Record in LIVE that register REG became live. 176 This is called via note_stores. */ 177 178 static void 179 reg_becomes_live (rtx reg, const_rtx setter ATTRIBUTE_UNUSED, void *live) 180 { 181 int regno; 182 183 if (GET_CODE (reg) == SUBREG) 184 reg = SUBREG_REG (reg); 185 186 if (!REG_P (reg)) 187 return; 188 189 regno = REGNO (reg); 190 if (regno < FIRST_PSEUDO_REGISTER) 191 add_to_hard_reg_set ((HARD_REG_SET *) live, GET_MODE (reg), regno); 192 } 193 194 /* Make sure if MODE_ENTRY is defined the MODE_EXIT is defined 195 and vice versa. */ 196 #if defined (MODE_ENTRY) != defined (MODE_EXIT) 197 #error "Both MODE_ENTRY and MODE_EXIT must be defined" 198 #endif 199 200 #if defined (MODE_ENTRY) && defined (MODE_EXIT) 201 /* Split the fallthrough edge to the exit block, so that we can note 202 that there NORMAL_MODE is required. Return the new block if it's 203 inserted before the exit block. Otherwise return null. */ 204 205 static basic_block 206 create_pre_exit (int n_entities, int *entity_map, const int *num_modes) 207 { 208 edge eg; 209 edge_iterator ei; 210 basic_block pre_exit; 211 212 /* The only non-call predecessor at this stage is a block with a 213 fallthrough edge; there can be at most one, but there could be 214 none at all, e.g. when exit is called. */ 215 pre_exit = 0; 216 FOR_EACH_EDGE (eg, ei, EXIT_BLOCK_PTR->preds) 217 if (eg->flags & EDGE_FALLTHRU) 218 { 219 basic_block src_bb = eg->src; 220 rtx last_insn, ret_reg; 221 222 gcc_assert (!pre_exit); 223 /* If this function returns a value at the end, we have to 224 insert the final mode switch before the return value copy 225 to its hard register. */ 226 if (EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 1 227 && NONJUMP_INSN_P ((last_insn = BB_END (src_bb))) 228 && GET_CODE (PATTERN (last_insn)) == USE 229 && GET_CODE ((ret_reg = XEXP (PATTERN (last_insn), 0))) == REG) 230 { 231 int ret_start = REGNO (ret_reg); 232 int nregs = hard_regno_nregs[ret_start][GET_MODE (ret_reg)]; 233 int ret_end = ret_start + nregs; 234 int short_block = 0; 235 int maybe_builtin_apply = 0; 236 int forced_late_switch = 0; 237 rtx before_return_copy; 238 239 do 240 { 241 rtx return_copy = PREV_INSN (last_insn); 242 rtx return_copy_pat, copy_reg; 243 int copy_start, copy_num; 244 int j; 245 246 if (INSN_P (return_copy)) 247 { 248 /* When using SJLJ exceptions, the call to the 249 unregister function is inserted between the 250 clobber of the return value and the copy. 251 We do not want to split the block before this 252 or any other call; if we have not found the 253 copy yet, the copy must have been deleted. */ 254 if (CALL_P (return_copy)) 255 { 256 short_block = 1; 257 break; 258 } 259 return_copy_pat = PATTERN (return_copy); 260 switch (GET_CODE (return_copy_pat)) 261 { 262 case USE: 263 /* Skip __builtin_apply pattern. */ 264 if (GET_CODE (XEXP (return_copy_pat, 0)) == REG 265 && (FUNCTION_VALUE_REGNO_P 266 (REGNO (XEXP (return_copy_pat, 0))))) 267 { 268 maybe_builtin_apply = 1; 269 last_insn = return_copy; 270 continue; 271 } 272 break; 273 274 case ASM_OPERANDS: 275 /* Skip barrier insns. */ 276 if (!MEM_VOLATILE_P (return_copy_pat)) 277 break; 278 279 /* Fall through. */ 280 281 case ASM_INPUT: 282 case UNSPEC_VOLATILE: 283 last_insn = return_copy; 284 continue; 285 286 default: 287 break; 288 } 289 290 /* If the return register is not (in its entirety) 291 likely spilled, the return copy might be 292 partially or completely optimized away. */ 293 return_copy_pat = single_set (return_copy); 294 if (!return_copy_pat) 295 { 296 return_copy_pat = PATTERN (return_copy); 297 if (GET_CODE (return_copy_pat) != CLOBBER) 298 break; 299 else if (!optimize) 300 { 301 /* This might be (clobber (reg [<result>])) 302 when not optimizing. Then check if 303 the previous insn is the clobber for 304 the return register. */ 305 copy_reg = SET_DEST (return_copy_pat); 306 if (GET_CODE (copy_reg) == REG 307 && !HARD_REGISTER_NUM_P (REGNO (copy_reg))) 308 { 309 if (INSN_P (PREV_INSN (return_copy))) 310 { 311 return_copy = PREV_INSN (return_copy); 312 return_copy_pat = PATTERN (return_copy); 313 if (GET_CODE (return_copy_pat) != CLOBBER) 314 break; 315 } 316 } 317 } 318 } 319 copy_reg = SET_DEST (return_copy_pat); 320 if (GET_CODE (copy_reg) == REG) 321 copy_start = REGNO (copy_reg); 322 else if (GET_CODE (copy_reg) == SUBREG 323 && GET_CODE (SUBREG_REG (copy_reg)) == REG) 324 copy_start = REGNO (SUBREG_REG (copy_reg)); 325 else 326 break; 327 if (copy_start >= FIRST_PSEUDO_REGISTER) 328 break; 329 copy_num 330 = hard_regno_nregs[copy_start][GET_MODE (copy_reg)]; 331 332 /* If the return register is not likely spilled, - as is 333 the case for floating point on SH4 - then it might 334 be set by an arithmetic operation that needs a 335 different mode than the exit block. */ 336 for (j = n_entities - 1; j >= 0; j--) 337 { 338 int e = entity_map[j]; 339 int mode = MODE_NEEDED (e, return_copy); 340 341 if (mode != num_modes[e] && mode != MODE_EXIT (e)) 342 break; 343 } 344 if (j >= 0) 345 { 346 /* For the SH4, floating point loads depend on fpscr, 347 thus we might need to put the final mode switch 348 after the return value copy. That is still OK, 349 because a floating point return value does not 350 conflict with address reloads. */ 351 if (copy_start >= ret_start 352 && copy_start + copy_num <= ret_end 353 && OBJECT_P (SET_SRC (return_copy_pat))) 354 forced_late_switch = 1; 355 break; 356 } 357 358 if (copy_start >= ret_start 359 && copy_start + copy_num <= ret_end) 360 nregs -= copy_num; 361 else if (!maybe_builtin_apply 362 || !FUNCTION_VALUE_REGNO_P (copy_start)) 363 break; 364 last_insn = return_copy; 365 } 366 /* ??? Exception handling can lead to the return value 367 copy being already separated from the return value use, 368 as in unwind-dw2.c . 369 Similarly, conditionally returning without a value, 370 and conditionally using builtin_return can lead to an 371 isolated use. */ 372 if (return_copy == BB_HEAD (src_bb)) 373 { 374 short_block = 1; 375 break; 376 } 377 last_insn = return_copy; 378 } 379 while (nregs); 380 381 /* If we didn't see a full return value copy, verify that there 382 is a plausible reason for this. If some, but not all of the 383 return register is likely spilled, we can expect that there 384 is a copy for the likely spilled part. */ 385 gcc_assert (!nregs 386 || forced_late_switch 387 || short_block 388 || !(CLASS_LIKELY_SPILLED_P 389 (REGNO_REG_CLASS (ret_start))) 390 || (nregs 391 != hard_regno_nregs[ret_start][GET_MODE (ret_reg)]) 392 /* For multi-hard-register floating point 393 values, sometimes the likely-spilled part 394 is ordinarily copied first, then the other 395 part is set with an arithmetic operation. 396 This doesn't actually cause reload 397 failures, so let it pass. */ 398 || (GET_MODE_CLASS (GET_MODE (ret_reg)) != MODE_INT 399 && nregs != 1)); 400 401 if (INSN_P (last_insn)) 402 { 403 before_return_copy 404 = emit_note_before (NOTE_INSN_DELETED, last_insn); 405 /* Instructions preceding LAST_INSN in the same block might 406 require a different mode than MODE_EXIT, so if we might 407 have such instructions, keep them in a separate block 408 from pre_exit. */ 409 if (last_insn != BB_HEAD (src_bb)) 410 src_bb = split_block (src_bb, 411 PREV_INSN (before_return_copy))->dest; 412 } 413 else 414 before_return_copy = last_insn; 415 pre_exit = split_block (src_bb, before_return_copy)->src; 416 } 417 else 418 { 419 pre_exit = split_edge (eg); 420 } 421 } 422 423 return pre_exit; 424 } 425 #endif 426 427 /* Find all insns that need a particular mode setting, and insert the 428 necessary mode switches. Return true if we did work. */ 429 430 static int 431 optimize_mode_switching (void) 432 { 433 rtx insn; 434 int e; 435 basic_block bb; 436 int need_commit = 0; 437 sbitmap *kill; 438 struct edge_list *edge_list; 439 static const int num_modes[] = NUM_MODES_FOR_MODE_SWITCHING; 440 #define N_ENTITIES ARRAY_SIZE (num_modes) 441 int entity_map[N_ENTITIES]; 442 struct bb_info *bb_info[N_ENTITIES]; 443 int i, j; 444 int n_entities; 445 int max_num_modes = 0; 446 bool emited = false; 447 basic_block post_entry ATTRIBUTE_UNUSED, pre_exit ATTRIBUTE_UNUSED; 448 449 for (e = N_ENTITIES - 1, n_entities = 0; e >= 0; e--) 450 if (OPTIMIZE_MODE_SWITCHING (e)) 451 { 452 int entry_exit_extra = 0; 453 454 /* Create the list of segments within each basic block. 455 If NORMAL_MODE is defined, allow for two extra 456 blocks split from the entry and exit block. */ 457 #if defined (MODE_ENTRY) && defined (MODE_EXIT) 458 entry_exit_extra = 3; 459 #endif 460 bb_info[n_entities] 461 = XCNEWVEC (struct bb_info, last_basic_block + entry_exit_extra); 462 entity_map[n_entities++] = e; 463 if (num_modes[e] > max_num_modes) 464 max_num_modes = num_modes[e]; 465 } 466 467 if (! n_entities) 468 return 0; 469 470 #if defined (MODE_ENTRY) && defined (MODE_EXIT) 471 /* Split the edge from the entry block, so that we can note that 472 there NORMAL_MODE is supplied. */ 473 post_entry = split_edge (single_succ_edge (ENTRY_BLOCK_PTR)); 474 pre_exit = create_pre_exit (n_entities, entity_map, num_modes); 475 #endif 476 477 df_analyze (); 478 479 /* Create the bitmap vectors. */ 480 481 antic = sbitmap_vector_alloc (last_basic_block, n_entities); 482 transp = sbitmap_vector_alloc (last_basic_block, n_entities); 483 comp = sbitmap_vector_alloc (last_basic_block, n_entities); 484 485 sbitmap_vector_ones (transp, last_basic_block); 486 487 for (j = n_entities - 1; j >= 0; j--) 488 { 489 int e = entity_map[j]; 490 int no_mode = num_modes[e]; 491 struct bb_info *info = bb_info[j]; 492 493 /* Determine what the first use (if any) need for a mode of entity E is. 494 This will be the mode that is anticipatable for this block. 495 Also compute the initial transparency settings. */ 496 FOR_EACH_BB (bb) 497 { 498 struct seginfo *ptr; 499 int last_mode = no_mode; 500 HARD_REG_SET live_now; 501 502 REG_SET_TO_HARD_REG_SET (live_now, df_get_live_in (bb)); 503 504 /* Pretend the mode is clobbered across abnormal edges. */ 505 { 506 edge_iterator ei; 507 edge e; 508 FOR_EACH_EDGE (e, ei, bb->preds) 509 if (e->flags & EDGE_COMPLEX) 510 break; 511 if (e) 512 { 513 ptr = new_seginfo (no_mode, BB_HEAD (bb), bb->index, live_now); 514 add_seginfo (info + bb->index, ptr); 515 RESET_BIT (transp[bb->index], j); 516 } 517 } 518 519 for (insn = BB_HEAD (bb); 520 insn != NULL && insn != NEXT_INSN (BB_END (bb)); 521 insn = NEXT_INSN (insn)) 522 { 523 if (INSN_P (insn)) 524 { 525 int mode = MODE_NEEDED (e, insn); 526 rtx link; 527 528 if (mode != no_mode && mode != last_mode) 529 { 530 last_mode = mode; 531 ptr = new_seginfo (mode, insn, bb->index, live_now); 532 add_seginfo (info + bb->index, ptr); 533 RESET_BIT (transp[bb->index], j); 534 } 535 #ifdef MODE_AFTER 536 last_mode = MODE_AFTER (last_mode, insn); 537 #endif 538 /* Update LIVE_NOW. */ 539 for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) 540 if (REG_NOTE_KIND (link) == REG_DEAD) 541 reg_dies (XEXP (link, 0), &live_now); 542 543 note_stores (PATTERN (insn), reg_becomes_live, &live_now); 544 for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) 545 if (REG_NOTE_KIND (link) == REG_UNUSED) 546 reg_dies (XEXP (link, 0), &live_now); 547 } 548 } 549 550 info[bb->index].computing = last_mode; 551 /* Check for blocks without ANY mode requirements. */ 552 if (last_mode == no_mode) 553 { 554 ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now); 555 add_seginfo (info + bb->index, ptr); 556 } 557 } 558 #if defined (MODE_ENTRY) && defined (MODE_EXIT) 559 { 560 int mode = MODE_ENTRY (e); 561 562 if (mode != no_mode) 563 { 564 bb = post_entry; 565 566 /* By always making this nontransparent, we save 567 an extra check in make_preds_opaque. We also 568 need this to avoid confusing pre_edge_lcm when 569 antic is cleared but transp and comp are set. */ 570 RESET_BIT (transp[bb->index], j); 571 572 /* Insert a fake computing definition of MODE into entry 573 blocks which compute no mode. This represents the mode on 574 entry. */ 575 info[bb->index].computing = mode; 576 577 if (pre_exit) 578 info[pre_exit->index].seginfo->mode = MODE_EXIT (e); 579 } 580 } 581 #endif /* NORMAL_MODE */ 582 } 583 584 kill = sbitmap_vector_alloc (last_basic_block, n_entities); 585 for (i = 0; i < max_num_modes; i++) 586 { 587 int current_mode[N_ENTITIES]; 588 sbitmap *del; 589 sbitmap *insert; 590 591 /* Set the anticipatable and computing arrays. */ 592 sbitmap_vector_zero (antic, last_basic_block); 593 sbitmap_vector_zero (comp, last_basic_block); 594 for (j = n_entities - 1; j >= 0; j--) 595 { 596 int m = current_mode[j] = MODE_PRIORITY_TO_MODE (entity_map[j], i); 597 struct bb_info *info = bb_info[j]; 598 599 FOR_EACH_BB (bb) 600 { 601 if (info[bb->index].seginfo->mode == m) 602 SET_BIT (antic[bb->index], j); 603 604 if (info[bb->index].computing == m) 605 SET_BIT (comp[bb->index], j); 606 } 607 } 608 609 /* Calculate the optimal locations for the 610 placement mode switches to modes with priority I. */ 611 612 FOR_EACH_BB (bb) 613 sbitmap_not (kill[bb->index], transp[bb->index]); 614 edge_list = pre_edge_lcm (n_entities, transp, comp, antic, 615 kill, &insert, &del); 616 617 for (j = n_entities - 1; j >= 0; j--) 618 { 619 /* Insert all mode sets that have been inserted by lcm. */ 620 int no_mode = num_modes[entity_map[j]]; 621 622 /* Wherever we have moved a mode setting upwards in the flow graph, 623 the blocks between the new setting site and the now redundant 624 computation ceases to be transparent for any lower-priority 625 mode of the same entity. First set the aux field of each 626 insertion site edge non-transparent, then propagate the new 627 non-transparency from the redundant computation upwards till 628 we hit an insertion site or an already non-transparent block. */ 629 for (e = NUM_EDGES (edge_list) - 1; e >= 0; e--) 630 { 631 edge eg = INDEX_EDGE (edge_list, e); 632 int mode; 633 basic_block src_bb; 634 HARD_REG_SET live_at_edge; 635 rtx mode_set; 636 637 eg->aux = 0; 638 639 if (! TEST_BIT (insert[e], j)) 640 continue; 641 642 eg->aux = (void *)1; 643 644 mode = current_mode[j]; 645 src_bb = eg->src; 646 647 REG_SET_TO_HARD_REG_SET (live_at_edge, df_get_live_out (src_bb)); 648 649 start_sequence (); 650 EMIT_MODE_SET (entity_map[j], mode, live_at_edge); 651 mode_set = get_insns (); 652 end_sequence (); 653 654 /* Do not bother to insert empty sequence. */ 655 if (mode_set == NULL_RTX) 656 continue; 657 658 /* We should not get an abnormal edge here. */ 659 gcc_assert (! (eg->flags & EDGE_ABNORMAL)); 660 661 need_commit = 1; 662 insert_insn_on_edge (mode_set, eg); 663 } 664 665 FOR_EACH_BB_REVERSE (bb) 666 if (TEST_BIT (del[bb->index], j)) 667 { 668 make_preds_opaque (bb, j); 669 /* Cancel the 'deleted' mode set. */ 670 bb_info[j][bb->index].seginfo->mode = no_mode; 671 } 672 } 673 674 sbitmap_vector_free (del); 675 sbitmap_vector_free (insert); 676 clear_aux_for_edges (); 677 free_edge_list (edge_list); 678 } 679 680 /* Now output the remaining mode sets in all the segments. */ 681 for (j = n_entities - 1; j >= 0; j--) 682 { 683 int no_mode = num_modes[entity_map[j]]; 684 685 FOR_EACH_BB_REVERSE (bb) 686 { 687 struct seginfo *ptr, *next; 688 for (ptr = bb_info[j][bb->index].seginfo; ptr; ptr = next) 689 { 690 next = ptr->next; 691 if (ptr->mode != no_mode) 692 { 693 rtx mode_set; 694 695 start_sequence (); 696 EMIT_MODE_SET (entity_map[j], ptr->mode, ptr->regs_live); 697 mode_set = get_insns (); 698 end_sequence (); 699 700 /* Insert MODE_SET only if it is nonempty. */ 701 if (mode_set != NULL_RTX) 702 { 703 emited = true; 704 if (NOTE_INSN_BASIC_BLOCK_P (ptr->insn_ptr)) 705 emit_insn_after (mode_set, ptr->insn_ptr); 706 else 707 emit_insn_before (mode_set, ptr->insn_ptr); 708 } 709 } 710 711 free (ptr); 712 } 713 } 714 715 free (bb_info[j]); 716 } 717 718 /* Finished. Free up all the things we've allocated. */ 719 sbitmap_vector_free (kill); 720 sbitmap_vector_free (antic); 721 sbitmap_vector_free (transp); 722 sbitmap_vector_free (comp); 723 724 if (need_commit) 725 commit_edge_insertions (); 726 727 #if defined (MODE_ENTRY) && defined (MODE_EXIT) 728 cleanup_cfg (CLEANUP_NO_INSN_DEL); 729 #else 730 if (!need_commit && !emited) 731 return 0; 732 #endif 733 734 return 1; 735 } 736 737 #endif /* OPTIMIZE_MODE_SWITCHING */ 738 739 static bool 740 gate_mode_switching (void) 741 { 742 #ifdef OPTIMIZE_MODE_SWITCHING 743 return true; 744 #else 745 return false; 746 #endif 747 } 748 749 static unsigned int 750 rest_of_handle_mode_switching (void) 751 { 752 #ifdef OPTIMIZE_MODE_SWITCHING 753 optimize_mode_switching (); 754 #endif /* OPTIMIZE_MODE_SWITCHING */ 755 return 0; 756 } 757 758 759 struct rtl_opt_pass pass_mode_switching = 760 { 761 { 762 RTL_PASS, 763 "mode_sw", /* name */ 764 gate_mode_switching, /* gate */ 765 rest_of_handle_mode_switching, /* execute */ 766 NULL, /* sub */ 767 NULL, /* next */ 768 0, /* static_pass_number */ 769 TV_MODE_SWITCH, /* tv_id */ 770 0, /* properties_required */ 771 0, /* properties_provided */ 772 0, /* properties_destroyed */ 773 0, /* todo_flags_start */ 774 TODO_df_finish | TODO_verify_rtl_sharing | 775 TODO_dump_func /* todo_flags_finish */ 776 } 777 }; 778