gcc/sibcall.c

   1 /* Generic sibling call optimization support
   2    Copyright (C) 1999, 2000, 2001, 2002, 2003
   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 under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, 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 COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26
  27 #include "rtl.h"
  28 #include "regs.h"
  29 #include "function.h"
  30 #include "hard-reg-set.h"
  31 #include "flags.h"
  32 #include "insn-config.h"
  33 #include "recog.h"
  34 #include "basic-block.h"
  35 #include "output.h"
  36 #include "except.h"
  37 #include "tree.h"
  38
  39 /* In case alternate_exit_block contains copy from pseudo, to return value,
  40    record the pseudo here.  In such case the pseudo must be set to function
  41    return in the sibcall sequence.  */
  42 static rtx return_value_pseudo;
  43
  44 static int identify_call_return_value (rtx, rtx *, rtx *);
  45 static rtx skip_copy_to_return_value (rtx);
  46 static rtx skip_use_of_return_value (rtx, enum rtx_code);
  47 static rtx skip_stack_adjustment (rtx);
  48 static rtx skip_pic_restore (rtx);
  49 static rtx skip_jump_insn (rtx);
  50 static int call_ends_block_p (rtx, rtx);
  51 static int uses_addressof (rtx);
  52 static int sequence_uses_addressof (rtx);
  53 static void purge_reg_equiv_notes (void);
  54 static void purge_mem_unchanging_flag (rtx);
  55 static rtx skip_unreturned_value (rtx);
  56
  57 /* Examine a CALL_PLACEHOLDER pattern and determine where the call's
  58    return value is located.  P_HARD_RETURN receives the hard register
  59    that the function used; P_SOFT_RETURN receives the pseudo register
  60    that the sequence used.  Return nonzero if the values were located.  */
  61
  62 static int
  63 identify_call_return_value (rtx cp, rtx *p_hard_return, rtx *p_soft_return)
  64 {
  65   rtx insn, set, hard, soft;
  66
  67   insn = XEXP (cp, 0);
  68   /* Search backward through the "normal" call sequence to the CALL insn.  */
  69   while (NEXT_INSN (insn))
  70     insn = NEXT_INSN (insn);
  71   while (GET_CODE (insn) != CALL_INSN)
  72     insn = PREV_INSN (insn);
  73
  74   /* Assume the pattern is (set (dest) (call ...)), or that the first
  75      member of a parallel is.  This is the hard return register used
  76      by the function.  */
  77   if (GET_CODE (PATTERN (insn)) == SET
  78       && GET_CODE (SET_SRC (PATTERN (insn))) == CALL)
  79     hard = SET_DEST (PATTERN (insn));
  80   else if (GET_CODE (PATTERN (insn)) == PARALLEL
  81            && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET
  82            && GET_CODE (SET_SRC (XVECEXP (PATTERN (insn), 0, 0))) == CALL)
  83     hard = SET_DEST (XVECEXP (PATTERN (insn), 0, 0));
  84   else
  85     return 0;
  86
  87   /* If we didn't get a single hard register (e.g. a parallel), give up.  */
  88   if (GET_CODE (hard) != REG)
  89     return 0;
  90
  91   /* Stack adjustment done after call may appear here.  */
  92   insn = skip_stack_adjustment (insn);
  93   if (! insn)
  94     return 0;
  95
  96   /* Restore of GP register may appear here.  */
  97   insn = skip_pic_restore (insn);
  98   if (! insn)
  99     return 0;
 100
 101   /* If there's nothing after, there's no soft return value.  */
 102   insn = NEXT_INSN (insn);
 103   if (! insn)
 104     return 0;
 105
 106   /* We're looking for a source of the hard return register.  */
 107   set = single_set (insn);
 108   if (! set || SET_SRC (set) != hard)
 109     return 0;
 110
 111   soft = SET_DEST (set);
 112   insn = NEXT_INSN (insn);
 113
 114   /* Allow this first destination to be copied to a second register,
 115      as might happen if the first register wasn't the particular pseudo
 116      we'd been expecting.  */
 117   if (insn
 118       && (set = single_set (insn)) != NULL_RTX
 119       && SET_SRC (set) == soft)
 120     {
 121       soft = SET_DEST (set);
 122       insn = NEXT_INSN (insn);
 123     }
 124
 125   /* Don't fool with anything but pseudo registers.  */
 126   if (GET_CODE (soft) != REG || REGNO (soft) < FIRST_PSEUDO_REGISTER)
 127     return 0;
 128
 129   /* This value must not be modified before the end of the sequence.  */
 130   if (reg_set_between_p (soft, insn, NULL_RTX))
 131     return 0;
 132
 133   *p_hard_return = hard;
 134   *p_soft_return = soft;
 135
 136   return 1;
 137 }
 138
 139 /* If the first real insn after ORIG_INSN copies to this function's
 140    return value from RETVAL, then return the insn which performs the
 141    copy.  Otherwise return ORIG_INSN.  */
 142
 143 static rtx
 144 skip_copy_to_return_value (rtx orig_insn)
 145 {
 146   rtx insn, set = NULL_RTX;
 147   rtx hardret, softret;
 148
 149   /* If there is no return value, we have nothing to do.  */
 150   if (! identify_call_return_value (PATTERN (orig_insn), &hardret, &softret))
 151     return orig_insn;
 152
 153   insn = next_nonnote_insn (orig_insn);
 154   if (! insn)
 155     return orig_insn;
 156
 157   set = single_set (insn);
 158   if (! set)
 159     return orig_insn;
 160
 161   if (return_value_pseudo)
 162     {
 163       if (SET_DEST (set) == return_value_pseudo
 164           && SET_SRC (set) == softret)
 165         return insn;
 166       return orig_insn;
 167     }
 168
 169   /* The destination must be the same as the called function's return
 170      value to ensure that any return value is put in the same place by the
 171      current function and the function we're calling.
 172
 173      Further, the source must be the same as the pseudo into which the
 174      called function's return value was copied.  Otherwise we're returning
 175      some other value.  */
 176
 177 #ifndef OUTGOING_REGNO
 178 #define OUTGOING_REGNO(N) (N)
 179 #endif
 180
 181   if (SET_DEST (set) == current_function_return_rtx
 182       && REG_P (SET_DEST (set))
 183       && OUTGOING_REGNO (REGNO (SET_DEST (set))) == REGNO (hardret)
 184       && SET_SRC (set) == softret)
 185     return insn;
 186
 187   /* Recognize the situation when the called function's return value
 188      is copied in two steps: first into an intermediate pseudo, then
 189      the into the calling functions return value register.  */
 190
 191   if (REG_P (SET_DEST (set))
 192       && SET_SRC (set) == softret)
 193     {
 194       rtx x = SET_DEST (set);
 195
 196       insn = next_nonnote_insn (insn);
 197       if (! insn)
 198         return orig_insn;
 199
 200       set = single_set (insn);
 201       if (! set)
 202         return orig_insn;
 203
 204       if (SET_DEST (set) == current_function_return_rtx
 205           && REG_P (SET_DEST (set))
 206           && OUTGOING_REGNO (REGNO (SET_DEST (set))) == REGNO (hardret)
 207           && SET_SRC (set) == x)
 208         return insn;
 209     }
 210
 211   /* It did not look like a copy of the return value, so return the
 212      same insn we were passed.  */
 213   return orig_insn;
 214 }
 215
 216 /* If the first real insn after ORIG_INSN is a CODE of this function's return
 217    value, return insn.  Otherwise return ORIG_INSN.  */
 218
 219 static rtx
 220 skip_use_of_return_value (rtx orig_insn, enum rtx_code code)
 221 {
 222   rtx insn;
 223
 224   insn = next_nonnote_insn (orig_insn);
 225
 226   if (insn
 227       && GET_CODE (insn) == INSN
 228       && GET_CODE (PATTERN (insn)) == code
 229       && (XEXP (PATTERN (insn), 0) == current_function_return_rtx
 230           || XEXP (PATTERN (insn), 0) == const0_rtx))
 231     return insn;
 232
 233   return orig_insn;
 234 }
 235
 236 /* In case function does not return value,  we get clobber of pseudo followed
 237    by set to hard return value.  */
 238 static rtx
 239 skip_unreturned_value (rtx orig_insn)
 240 {
 241   rtx insn = next_nonnote_insn (orig_insn);
 242
 243   /* Skip possible clobber of pseudo return register.  */
 244   if (insn
 245       && GET_CODE (insn) == INSN
 246       && GET_CODE (PATTERN (insn)) == CLOBBER
 247       && REG_P (XEXP (PATTERN (insn), 0))
 248       && (REGNO (XEXP (PATTERN (insn), 0)) >= FIRST_PSEUDO_REGISTER))
 249     {
 250       rtx set_insn = next_nonnote_insn (insn);
 251       rtx set;
 252       if (!set_insn)
 253         return insn;
 254       set = single_set (set_insn);
 255       if (!set
 256           || SET_SRC (set) != XEXP (PATTERN (insn), 0)
 257           || SET_DEST (set) != current_function_return_rtx)
 258         return insn;
 259       return set_insn;
 260     }
 261   return orig_insn;
 262 }
 263
 264 /* If the first real insn after ORIG_INSN adjusts the stack pointer
 265    by a constant, return the insn with the stack pointer adjustment.
 266    Otherwise return ORIG_INSN.  */
 267
 268 static rtx
 269 skip_stack_adjustment (rtx orig_insn)
 270 {
 271   rtx insn, set = NULL_RTX;
 272
 273   insn = next_nonnote_insn (orig_insn);
 274
 275   if (insn)
 276     set = single_set (insn);
 277
 278   if (insn
 279       && set
 280       && GET_CODE (SET_SRC (set)) == PLUS
 281       && XEXP (SET_SRC (set), 0) == stack_pointer_rtx
 282       && GET_CODE (XEXP (SET_SRC (set), 1)) == CONST_INT
 283       && SET_DEST (set) == stack_pointer_rtx)
 284     return insn;
 285
 286   return orig_insn;
 287 }
 288
 289 /* If the first real insn after ORIG_INSN sets the pic register,
 290    return it.  Otherwise return ORIG_INSN.  */
 291
 292 static rtx
 293 skip_pic_restore (rtx orig_insn)
 294 {
 295   rtx insn, set = NULL_RTX;
 296
 297   insn = next_nonnote_insn (orig_insn);
 298
 299   if (insn)
 300     set = single_set (insn);
 301
 302   if (insn && set && SET_DEST (set) == pic_offset_table_rtx)
 303     return insn;
 304
 305   return orig_insn;
 306 }
 307
 308 /* If the first real insn after ORIG_INSN is a jump, return the JUMP_INSN.
 309    Otherwise return ORIG_INSN.  */
 310
 311 static rtx
 312 skip_jump_insn (rtx orig_insn)
 313 {
 314   rtx insn;
 315
 316   insn = next_nonnote_insn (orig_insn);
 317
 318   if (insn
 319       && GET_CODE (insn) == JUMP_INSN
 320       && any_uncondjump_p (insn))
 321     return insn;
 322
 323   return orig_insn;
 324 }
 325 \f
 326 /* Using the above functions, see if INSN, skipping any of the above,
 327    goes all the way to END, the end of a basic block.  Return 1 if so.  */
 328
 329 static int
 330 call_ends_block_p (rtx insn, rtx end)
 331 {
 332   rtx new_insn;
 333   /* END might be a note, so get the last nonnote insn of the block.  */
 334   end = next_nonnote_insn (PREV_INSN (end));
 335
 336   /* If the call was the end of the block, then we're OK.  */
 337   if (insn == end)
 338     return 1;
 339
 340   /* Skip over copying from the call's return value pseudo into
 341      this function's hard return register and if that's the end
 342      of the block, we're OK.  */
 343   new_insn = skip_copy_to_return_value (insn);
 344
 345   /* In case we return value in pseudo, we must set the pseudo to
 346      return value of called function, otherwise we are returning
 347      something else.  */
 348   if (return_value_pseudo && insn == new_insn)
 349     return 0;
 350   insn = new_insn;
 351
 352   if (insn == end)
 353     return 1;
 354
 355   /* Skip any stack adjustment.  */
 356   insn = skip_stack_adjustment (insn);
 357   if (insn == end)
 358     return 1;
 359
 360   /* Skip over a CLOBBER of the return value as a hard reg.  */
 361   insn = skip_use_of_return_value (insn, CLOBBER);
 362   if (insn == end)
 363     return 1;
 364
 365   /* Skip over a CLOBBER of the return value as a hard reg.  */
 366   insn = skip_unreturned_value (insn);
 367   if (insn == end)
 368     return 1;
 369
 370   /* Skip over a USE of the return value (as a hard reg).  */
 371   insn = skip_use_of_return_value (insn, USE);
 372   if (insn == end)
 373     return 1;
 374
 375   /* Skip over a JUMP_INSN at the end of the block.  If that doesn't end the
 376      block, the original CALL_INSN didn't.  */
 377   insn = skip_jump_insn (insn);
 378   return insn == end;
 379 }
 380
 381 /* Scan the rtx X for ADDRESSOF expressions or
 382    current_function_internal_arg_pointer registers.
 383    Return nonzero if an ADDRESSOF or current_function_internal_arg_pointer
 384    is found outside of some MEM expression, else return zero.  */
 385
 386 static int
 387 uses_addressof (rtx x)
 388 {
 389   RTX_CODE code;
 390   int i, j;
 391   const char *fmt;
 392
 393   if (x == NULL_RTX)
 394     return 0;
 395
 396   code = GET_CODE (x);
 397
 398   if (code == ADDRESSOF || x == current_function_internal_arg_pointer)
 399     return 1;
 400
 401   if (code == MEM)
 402     return 0;
 403
 404   /* Scan all subexpressions.  */
 405   fmt = GET_RTX_FORMAT (code);
 406   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
 407     {
 408       if (*fmt == 'e')
 409         {
 410           if (uses_addressof (XEXP (x, i)))
 411             return 1;
 412         }
 413       else if (*fmt == 'E')
 414         {
 415           for (j = 0; j < XVECLEN (x, i); j++)
 416             if (uses_addressof (XVECEXP (x, i, j)))
 417               return 1;
 418         }
 419     }
 420   return 0;
 421 }
 422
 423 /* Scan the sequence of insns in SEQ to see if any have an ADDRESSOF
 424    rtl expression or current_function_internal_arg_pointer occurrences
 425    not enclosed within a MEM.  If an ADDRESSOF expression or
 426    current_function_internal_arg_pointer is found, return nonzero, otherwise
 427    return zero.
 428
 429    This function handles CALL_PLACEHOLDERs which contain multiple sequences
 430    of insns.  */
 431
 432 static int
 433 sequence_uses_addressof (rtx seq)
 434 {
 435   rtx insn;
 436
 437   for (insn = seq; insn; insn = NEXT_INSN (insn))
 438     if (INSN_P (insn))
 439       {
 440         /* If this is a CALL_PLACEHOLDER, then recursively call ourselves
 441            with each nonempty sequence attached to the CALL_PLACEHOLDER.  */
 442         if (GET_CODE (insn) == CALL_INSN
 443             && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
 444           {
 445             if (XEXP (PATTERN (insn), 0) != NULL_RTX
 446                 && sequence_uses_addressof (XEXP (PATTERN (insn), 0)))
 447               return 1;
 448             if (XEXP (PATTERN (insn), 1) != NULL_RTX
 449                 && sequence_uses_addressof (XEXP (PATTERN (insn), 1)))
 450               return 1;
 451             if (XEXP (PATTERN (insn), 2) != NULL_RTX
 452                 && sequence_uses_addressof (XEXP (PATTERN (insn), 2)))
 453               return 1;
 454           }
 455         else if (uses_addressof (PATTERN (insn))
 456                  || (REG_NOTES (insn) && uses_addressof (REG_NOTES (insn))))
 457           return 1;
 458       }
 459   return 0;
 460 }
 461
 462 /* Remove all REG_EQUIV notes found in the insn chain.  */
 463
 464 static void
 465 purge_reg_equiv_notes (void)
 466 {
 467   rtx insn;
 468
 469   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
 470     {
 471       while (1)
 472         {
 473           rtx note = find_reg_note (insn, REG_EQUIV, 0);
 474           if (note)
 475             {
 476               /* Remove the note and keep looking at the notes for
 477                  this insn.  */
 478               remove_note (insn, note);
 479               continue;
 480             }
 481           break;
 482         }
 483     }
 484 }
 485
 486 /* Clear RTX_UNCHANGING_P flag of incoming argument MEMs.  */
 487
 488 static void
 489 purge_mem_unchanging_flag (rtx x)
 490 {
 491   RTX_CODE code;
 492   int i, j;
 493   const char *fmt;
 494
 495   if (x == NULL_RTX)
 496     return;
 497
 498   code = GET_CODE (x);
 499
 500   if (code == MEM)
 501     {
 502       if (RTX_UNCHANGING_P (x)
 503           && (XEXP (x, 0) == current_function_internal_arg_pointer
 504               || (GET_CODE (XEXP (x, 0)) == PLUS
 505                   && XEXP (XEXP (x, 0), 0) ==
 506                      current_function_internal_arg_pointer
 507                   && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)))
 508         RTX_UNCHANGING_P (x) = 0;
 509       return;
 510     }
 511
 512   /* Scan all subexpressions.  */
 513   fmt = GET_RTX_FORMAT (code);
 514   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
 515     {
 516       if (*fmt == 'e')
 517         purge_mem_unchanging_flag (XEXP (x, i));
 518       else if (*fmt == 'E')
 519         for (j = 0; j < XVECLEN (x, i); j++)
 520           purge_mem_unchanging_flag (XVECEXP (x, i, j));
 521     }
 522 }
 523
 524 /* Replace the CALL_PLACEHOLDER with one of its children.  INSN should be
 525    the CALL_PLACEHOLDER insn; USE tells which child to use.  */
 526
 527 void
 528 replace_call_placeholder (rtx insn, sibcall_use_t use)
 529 {
 530   if (use == sibcall_use_tail_recursion)
 531     emit_insn_before (XEXP (PATTERN (insn), 2), insn);
 532   else if (use == sibcall_use_sibcall)
 533     emit_insn_before (XEXP (PATTERN (insn), 1), insn);
 534   else if (use == sibcall_use_normal)
 535     emit_insn_before (XEXP (PATTERN (insn), 0), insn);
 536   else
 537     abort ();
 538
 539   /* Turn off LABEL_PRESERVE_P for the tail recursion label if it
 540      exists.  We only had to set it long enough to keep the jump
 541      pass above from deleting it as unused.  */
 542   if (XEXP (PATTERN (insn), 3))
 543     LABEL_PRESERVE_P (XEXP (PATTERN (insn), 3)) = 0;
 544
 545   /* "Delete" the placeholder insn.  */
 546   remove_insn (insn);
 547 }
 548
 549 /* Given a (possibly empty) set of potential sibling or tail recursion call
 550    sites, determine if optimization is possible.
 551
 552    Potential sibling or tail recursion calls are marked with CALL_PLACEHOLDER
 553    insns.  The CALL_PLACEHOLDER insn holds chains of insns to implement a
 554    normal call, sibling call or tail recursive call.
 555
 556    Replace the CALL_PLACEHOLDER with an appropriate insn chain.  */
 557
 558 void
 559 optimize_sibling_and_tail_recursive_calls (void)
 560 {
 561   rtx insn, insns;
 562   basic_block alternate_exit = EXIT_BLOCK_PTR;
 563   bool no_sibcalls_this_function = false;
 564   bool successful_replacement = false;
 565   bool replaced_call_placeholder = false;
 566   edge e;
 567
 568   insns = get_insns ();
 569
 570   cleanup_cfg (CLEANUP_PRE_SIBCALL | CLEANUP_PRE_LOOP);
 571
 572   /* If there are no basic blocks, then there is nothing to do.  */
 573   if (n_basic_blocks == 0)
 574     return;
 575
 576   /* If we are using sjlj exceptions, we may need to add a call to
 577      _Unwind_SjLj_Unregister at exit of the function.  Which means
 578      that we cannot do any sibcall transformations.  */
 579   if (USING_SJLJ_EXCEPTIONS && current_function_has_exception_handlers ())
 580     no_sibcalls_this_function = true;
 581
 582   return_value_pseudo = NULL_RTX;
 583
 584   /* Find the exit block.
 585
 586      It is possible that we have blocks which can reach the exit block
 587      directly.  However, most of the time a block will jump (or fall into)
 588      N_BASIC_BLOCKS - 1, which in turn falls into the exit block.  */
 589   for (e = EXIT_BLOCK_PTR->pred;
 590        e && alternate_exit == EXIT_BLOCK_PTR;
 591        e = e->pred_next)
 592     {
 593       rtx insn;
 594
 595       if (e->dest != EXIT_BLOCK_PTR || e->succ_next != NULL)
 596         continue;
 597
 598       /* Walk forwards through the last normal block and see if it
 599          does nothing except fall into the exit block.  */
 600       for (insn = BB_HEAD (EXIT_BLOCK_PTR->prev_bb);
 601            insn;
 602            insn = NEXT_INSN (insn))
 603         {
 604           rtx set;
 605           /* This should only happen once, at the start of this block.  */
 606           if (GET_CODE (insn) == CODE_LABEL)
 607             continue;
 608
 609           if (GET_CODE (insn) == NOTE)
 610             continue;
 611
 612           if (GET_CODE (insn) == INSN
 613               && GET_CODE (PATTERN (insn)) == USE)
 614             continue;
 615
 616           /* Exit block also may contain copy from pseudo containing
 617              return value to hard register.  */
 618           if (GET_CODE (insn) == INSN
 619               && (set = single_set (insn))
 620               && SET_DEST (set) == current_function_return_rtx
 621               && REG_P (SET_SRC (set))
 622               && !return_value_pseudo)
 623             {
 624               return_value_pseudo = SET_SRC (set);
 625               continue;
 626             }
 627
 628           break;
 629         }
 630
 631       /* If INSN is zero, then the search walked all the way through the
 632          block without hitting anything interesting.  This block is a
 633          valid alternate exit block.  */
 634       if (insn == NULL)
 635         alternate_exit = e->src;
 636       else
 637         return_value_pseudo = NULL;
 638     }
 639
 640   /* If the function uses ADDRESSOF, we can't (easily) determine
 641      at this point if the value will end up on the stack.  */
 642   no_sibcalls_this_function |= sequence_uses_addressof (insns);
 643
 644   /* Walk the insn chain and find any CALL_PLACEHOLDER insns.  We need to
 645      select one of the insn sequences attached to each CALL_PLACEHOLDER.
 646
 647      The different sequences represent different ways to implement the call,
 648      ie, tail recursion, sibling call or normal call.
 649
 650      Since we do not create nested CALL_PLACEHOLDERs, the scan
 651      continues with the insn that was after a replaced CALL_PLACEHOLDER;
 652      we don't rescan the replacement insns.  */
 653   for (insn = insns; insn; insn = NEXT_INSN (insn))
 654     {
 655       if (GET_CODE (insn) == CALL_INSN
 656           && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
 657         {
 658           int sibcall = (XEXP (PATTERN (insn), 1) != NULL_RTX);
 659           int tailrecursion = (XEXP (PATTERN (insn), 2) != NULL_RTX);
 660           basic_block call_block = BLOCK_FOR_INSN (insn);
 661
 662           /* alloca (until we have stack slot life analysis) inhibits
 663              sibling call optimizations, but not tail recursion.
 664              Similarly if we use varargs or stdarg since they implicitly
 665              may take the address of an argument.  */
 666           if (current_function_calls_alloca || current_function_stdarg)
 667             sibcall = 0;
 668
 669           /* See if there are any reasons we can't perform either sibling or
 670              tail call optimizations.  We must be careful with stack slots
 671              which are live at potential optimization sites.  */
 672           if (no_sibcalls_this_function
 673               /* ??? Overly conservative.  */
 674               || frame_offset
 675               /* Any function that calls setjmp might have longjmp called from
 676                  any called function.  ??? We really should represent this
 677                  properly in the CFG so that this needn't be special cased.  */
 678               || current_function_calls_setjmp
 679               /* Can't if more than one successor or single successor is not
 680                  exit block.  These two tests prevent tail call optimization
 681                  in the presence of active exception handlers.  */
 682               || call_block->succ == NULL
 683               || call_block->succ->succ_next != NULL
 684               || (call_block->succ->dest != EXIT_BLOCK_PTR
 685                   && call_block->succ->dest != alternate_exit)
 686               /* If this call doesn't end the block, there are operations at
 687                  the end of the block which we must execute after returning.  */
 688               || ! call_ends_block_p (insn, BB_END (call_block)))
 689             sibcall = 0, tailrecursion = 0;
 690
 691           /* Select a set of insns to implement the call and emit them.
 692              Tail recursion is the most efficient, so select it over
 693              a tail/sibling call.  */
 694
 695           if (sibcall || tailrecursion)
 696             successful_replacement = true;
 697           replaced_call_placeholder = true;
 698
 699           replace_call_placeholder (insn,
 700                                     tailrecursion != 0
 701                                       ? sibcall_use_tail_recursion
 702                                       : sibcall != 0
 703                                          ? sibcall_use_sibcall
 704                                          : sibcall_use_normal);
 705         }
 706     }
 707
 708   if (successful_replacement)
 709     {
 710       rtx insn;
 711       tree arg;
 712
 713       /* A sibling call sequence invalidates any REG_EQUIV notes made for
 714          this function's incoming arguments.
 715
 716          At the start of RTL generation we know the only REG_EQUIV notes
 717          in the rtl chain are those for incoming arguments, so we can safely
 718          flush any REG_EQUIV note.
 719
 720          This is (slight) overkill.  We could keep track of the highest
 721          argument we clobber and be more selective in removing notes, but it
 722          does not seem to be worth the effort.  */
 723       purge_reg_equiv_notes ();
 724
 725       /* A sibling call sequence also may invalidate RTX_UNCHANGING_P
 726          flag of some incoming arguments MEM RTLs, because it can write into
 727          those slots.  We clear all those bits now.
 728
 729          This is (slight) overkill, we could keep track of which arguments
 730          we actually write into.  */
 731       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
 732         {
 733           if (INSN_P (insn))
 734             purge_mem_unchanging_flag (PATTERN (insn));
 735         }
 736
 737       /* Similarly, invalidate RTX_UNCHANGING_P for any incoming
 738          arguments passed in registers.  */
 739       for (arg = DECL_ARGUMENTS (current_function_decl);
 740            arg;
 741            arg = TREE_CHAIN (arg))
 742         {
 743           if (REG_P (DECL_RTL (arg)))
 744             RTX_UNCHANGING_P (DECL_RTL (arg)) = false;
 745         }
 746     }
 747
 748   /* There may have been NOTE_INSN_BLOCK_{BEGIN,END} notes in the
 749      CALL_PLACEHOLDER alternatives that we didn't emit.  Rebuild the
 750      lexical block tree to correspond to the notes that still exist.  */
 751   if (replaced_call_placeholder)
 752     reorder_blocks ();
 753
 754   /* This information will be invalid after inline expansion.  Kill it now.  */
 755   free_basic_block_vars (0);
 756   free_EXPR_LIST_list (&tail_recursion_label_list);
 757 }