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