Daily bump.
[official-gcc.git] / gcc / final.c
blob6943c073d9bd3ef3e751506883df6fa4281d7e3d
1 /* Convert RTL to assembler code and output it, for GNU compiler.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
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 3, or (at your option) any later
9 version.
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.
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/>. */
20 /* This is the final pass of the compiler.
21 It looks at the rtl code for a function and outputs assembler code.
23 Call `final_start_function' to output the assembler code for function entry,
24 `final' to output assembler code for some RTL code,
25 `final_end_function' to output assembler code for function exit.
26 If a function is compiled in several pieces, each piece is
27 output separately with `final'.
29 Some optimizations are also done at this level.
30 Move instructions that were made unnecessary by good register allocation
31 are detected and omitted from the output. (Though most of these
32 are removed by the last jump pass.)
34 Instructions to set the condition codes are omitted when it can be
35 seen that the condition codes already had the desired values.
37 In some cases it is sufficient if the inherited condition codes
38 have related values, but this may require the following insn
39 (the one that tests the condition codes) to be modified.
41 The code for the function prologue and epilogue are generated
42 directly in assembler by the target functions function_prologue and
43 function_epilogue. Those instructions never exist as rtl. */
45 #include "config.h"
46 #define INCLUDE_ALGORITHM /* reverse */
47 #include "system.h"
48 #include "coretypes.h"
49 #include "backend.h"
50 #include "target.h"
51 #include "rtl.h"
52 #include "tree.h"
53 #include "cfghooks.h"
54 #include "df.h"
55 #include "memmodel.h"
56 #include "tm_p.h"
57 #include "insn-config.h"
58 #include "regs.h"
59 #include "emit-rtl.h"
60 #include "recog.h"
61 #include "cgraph.h"
62 #include "tree-pretty-print.h" /* for dump_function_header */
63 #include "varasm.h"
64 #include "insn-attr.h"
65 #include "conditions.h"
66 #include "flags.h"
67 #include "output.h"
68 #include "except.h"
69 #include "rtl-error.h"
70 #include "toplev.h" /* exact_log2, floor_log2 */
71 #include "reload.h"
72 #include "intl.h"
73 #include "cfgrtl.h"
74 #include "debug.h"
75 #include "tree-pass.h"
76 #include "tree-ssa.h"
77 #include "cfgloop.h"
78 #include "params.h"
79 #include "stringpool.h"
80 #include "attribs.h"
81 #include "asan.h"
82 #include "rtl-iter.h"
83 #include "print-rtl.h"
85 #ifdef XCOFF_DEBUGGING_INFO
86 #include "xcoffout.h" /* Needed for external data declarations. */
87 #endif
89 #include "dwarf2out.h"
91 #ifdef DBX_DEBUGGING_INFO
92 #include "dbxout.h"
93 #endif
95 /* Most ports that aren't using cc0 don't need to define CC_STATUS_INIT.
96 So define a null default for it to save conditionalization later. */
97 #ifndef CC_STATUS_INIT
98 #define CC_STATUS_INIT
99 #endif
101 /* Is the given character a logical line separator for the assembler? */
102 #ifndef IS_ASM_LOGICAL_LINE_SEPARATOR
103 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) ((C) == ';')
104 #endif
106 #ifndef JUMP_TABLES_IN_TEXT_SECTION
107 #define JUMP_TABLES_IN_TEXT_SECTION 0
108 #endif
110 /* Bitflags used by final_scan_insn. */
111 #define SEEN_NOTE 1
112 #define SEEN_EMITTED 2
113 #define SEEN_NEXT_VIEW 4
115 /* Last insn processed by final_scan_insn. */
116 static rtx_insn *debug_insn;
117 rtx_insn *current_output_insn;
119 /* Line number of last NOTE. */
120 static int last_linenum;
122 /* Column number of last NOTE. */
123 static int last_columnnum;
125 /* Discriminator written to assembly. */
126 static int last_discriminator;
128 /* Discriminator to be written to assembly for current instruction.
129 Note: actual usage depends on loc_discriminator_kind setting. */
130 static int discriminator;
132 /* Discriminator identifying current basic block among others sharing
133 the same locus. */
134 static int bb_discriminator;
136 /* Basic block discriminator for previous instruction. */
137 static int last_bb_discriminator;
139 /* Highest line number in current block. */
140 static int high_block_linenum;
142 /* Likewise for function. */
143 static int high_function_linenum;
145 /* Filename of last NOTE. */
146 static const char *last_filename;
148 /* Override filename, line and column number. */
149 static const char *override_filename;
150 static int override_linenum;
151 static int override_columnnum;
153 /* Whether to force emission of a line note before the next insn. */
154 static bool force_source_line = false;
156 extern const int length_unit_log; /* This is defined in insn-attrtab.c. */
158 /* Nonzero while outputting an `asm' with operands.
159 This means that inconsistencies are the user's fault, so don't die.
160 The precise value is the insn being output, to pass to error_for_asm. */
161 const rtx_insn *this_is_asm_operands;
163 /* Number of operands of this insn, for an `asm' with operands. */
164 static unsigned int insn_noperands;
166 /* Compare optimization flag. */
168 static rtx last_ignored_compare = 0;
170 /* Assign a unique number to each insn that is output.
171 This can be used to generate unique local labels. */
173 static int insn_counter = 0;
175 /* This variable contains machine-dependent flags (defined in tm.h)
176 set and examined by output routines
177 that describe how to interpret the condition codes properly. */
179 CC_STATUS cc_status;
181 /* During output of an insn, this contains a copy of cc_status
182 from before the insn. */
184 CC_STATUS cc_prev_status;
186 /* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen. */
188 static int block_depth;
190 /* Nonzero if have enabled APP processing of our assembler output. */
192 static int app_on;
194 /* If we are outputting an insn sequence, this contains the sequence rtx.
195 Zero otherwise. */
197 rtx_sequence *final_sequence;
199 #ifdef ASSEMBLER_DIALECT
201 /* Number of the assembler dialect to use, starting at 0. */
202 static int dialect_number;
203 #endif
205 /* Nonnull if the insn currently being emitted was a COND_EXEC pattern. */
206 rtx current_insn_predicate;
208 /* True if printing into -fdump-final-insns= dump. */
209 bool final_insns_dump_p;
211 /* True if profile_function should be called, but hasn't been called yet. */
212 static bool need_profile_function;
214 static int asm_insn_count (rtx);
215 static void profile_function (FILE *);
216 static void profile_after_prologue (FILE *);
217 static bool notice_source_line (rtx_insn *, bool *);
218 static rtx walk_alter_subreg (rtx *, bool *);
219 static void output_asm_name (void);
220 static void output_alternate_entry_point (FILE *, rtx_insn *);
221 static tree get_mem_expr_from_op (rtx, int *);
222 static void output_asm_operand_names (rtx *, int *, int);
223 #ifdef LEAF_REGISTERS
224 static void leaf_renumber_regs (rtx_insn *);
225 #endif
226 #if HAVE_cc0
227 static int alter_cond (rtx);
228 #endif
229 static int align_fuzz (rtx, rtx, int, unsigned);
230 static void collect_fn_hard_reg_usage (void);
231 static tree get_call_fndecl (rtx_insn *);
233 /* Initialize data in final at the beginning of a compilation. */
235 void
236 init_final (const char *filename ATTRIBUTE_UNUSED)
238 app_on = 0;
239 final_sequence = 0;
241 #ifdef ASSEMBLER_DIALECT
242 dialect_number = ASSEMBLER_DIALECT;
243 #endif
246 /* Default target function prologue and epilogue assembler output.
248 If not overridden for epilogue code, then the function body itself
249 contains return instructions wherever needed. */
250 void
251 default_function_pro_epilogue (FILE *)
255 void
256 default_function_switched_text_sections (FILE *file ATTRIBUTE_UNUSED,
257 tree decl ATTRIBUTE_UNUSED,
258 bool new_is_cold ATTRIBUTE_UNUSED)
262 /* Default target hook that outputs nothing to a stream. */
263 void
264 no_asm_to_stream (FILE *file ATTRIBUTE_UNUSED)
268 /* Enable APP processing of subsequent output.
269 Used before the output from an `asm' statement. */
271 void
272 app_enable (void)
274 if (! app_on)
276 fputs (ASM_APP_ON, asm_out_file);
277 app_on = 1;
281 /* Disable APP processing of subsequent output.
282 Called from varasm.c before most kinds of output. */
284 void
285 app_disable (void)
287 if (app_on)
289 fputs (ASM_APP_OFF, asm_out_file);
290 app_on = 0;
294 /* Return the number of slots filled in the current
295 delayed branch sequence (we don't count the insn needing the
296 delay slot). Zero if not in a delayed branch sequence. */
299 dbr_sequence_length (void)
301 if (final_sequence != 0)
302 return XVECLEN (final_sequence, 0) - 1;
303 else
304 return 0;
307 /* The next two pages contain routines used to compute the length of an insn
308 and to shorten branches. */
310 /* Arrays for insn lengths, and addresses. The latter is referenced by
311 `insn_current_length'. */
313 static int *insn_lengths;
315 vec<int> insn_addresses_;
317 /* Max uid for which the above arrays are valid. */
318 static int insn_lengths_max_uid;
320 /* Address of insn being processed. Used by `insn_current_length'. */
321 int insn_current_address;
323 /* Address of insn being processed in previous iteration. */
324 int insn_last_address;
326 /* known invariant alignment of insn being processed. */
327 int insn_current_align;
329 /* After shorten_branches, for any insn, uid_align[INSN_UID (insn)]
330 gives the next following alignment insn that increases the known
331 alignment, or NULL_RTX if there is no such insn.
332 For any alignment obtained this way, we can again index uid_align with
333 its uid to obtain the next following align that in turn increases the
334 alignment, till we reach NULL_RTX; the sequence obtained this way
335 for each insn we'll call the alignment chain of this insn in the following
336 comments. */
338 static rtx *uid_align;
339 static int *uid_shuid;
340 static vec<align_flags> label_align;
342 /* Indicate that branch shortening hasn't yet been done. */
344 void
345 init_insn_lengths (void)
347 if (uid_shuid)
349 free (uid_shuid);
350 uid_shuid = 0;
352 if (insn_lengths)
354 free (insn_lengths);
355 insn_lengths = 0;
356 insn_lengths_max_uid = 0;
358 if (HAVE_ATTR_length)
359 INSN_ADDRESSES_FREE ();
360 if (uid_align)
362 free (uid_align);
363 uid_align = 0;
367 /* Obtain the current length of an insn. If branch shortening has been done,
368 get its actual length. Otherwise, use FALLBACK_FN to calculate the
369 length. */
370 static int
371 get_attr_length_1 (rtx_insn *insn, int (*fallback_fn) (rtx_insn *))
373 rtx body;
374 int i;
375 int length = 0;
377 if (!HAVE_ATTR_length)
378 return 0;
380 if (insn_lengths_max_uid > INSN_UID (insn))
381 return insn_lengths[INSN_UID (insn)];
382 else
383 switch (GET_CODE (insn))
385 case NOTE:
386 case BARRIER:
387 case CODE_LABEL:
388 case DEBUG_INSN:
389 return 0;
391 case CALL_INSN:
392 case JUMP_INSN:
393 length = fallback_fn (insn);
394 break;
396 case INSN:
397 body = PATTERN (insn);
398 if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
399 return 0;
401 else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
402 length = asm_insn_count (body) * fallback_fn (insn);
403 else if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (body))
404 for (i = 0; i < seq->len (); i++)
405 length += get_attr_length_1 (seq->insn (i), fallback_fn);
406 else
407 length = fallback_fn (insn);
408 break;
410 default:
411 break;
414 #ifdef ADJUST_INSN_LENGTH
415 ADJUST_INSN_LENGTH (insn, length);
416 #endif
417 return length;
420 /* Obtain the current length of an insn. If branch shortening has been done,
421 get its actual length. Otherwise, get its maximum length. */
423 get_attr_length (rtx_insn *insn)
425 return get_attr_length_1 (insn, insn_default_length);
428 /* Obtain the current length of an insn. If branch shortening has been done,
429 get its actual length. Otherwise, get its minimum length. */
431 get_attr_min_length (rtx_insn *insn)
433 return get_attr_length_1 (insn, insn_min_length);
436 /* Code to handle alignment inside shorten_branches. */
438 /* Here is an explanation how the algorithm in align_fuzz can give
439 proper results:
441 Call a sequence of instructions beginning with alignment point X
442 and continuing until the next alignment point `block X'. When `X'
443 is used in an expression, it means the alignment value of the
444 alignment point.
446 Call the distance between the start of the first insn of block X, and
447 the end of the last insn of block X `IX', for the `inner size of X'.
448 This is clearly the sum of the instruction lengths.
450 Likewise with the next alignment-delimited block following X, which we
451 shall call block Y.
453 Call the distance between the start of the first insn of block X, and
454 the start of the first insn of block Y `OX', for the `outer size of X'.
456 The estimated padding is then OX - IX.
458 OX can be safely estimated as
460 if (X >= Y)
461 OX = round_up(IX, Y)
462 else
463 OX = round_up(IX, X) + Y - X
465 Clearly est(IX) >= real(IX), because that only depends on the
466 instruction lengths, and those being overestimated is a given.
468 Clearly round_up(foo, Z) >= round_up(bar, Z) if foo >= bar, so
469 we needn't worry about that when thinking about OX.
471 When X >= Y, the alignment provided by Y adds no uncertainty factor
472 for branch ranges starting before X, so we can just round what we have.
473 But when X < Y, we don't know anything about the, so to speak,
474 `middle bits', so we have to assume the worst when aligning up from an
475 address mod X to one mod Y, which is Y - X. */
477 #ifndef LABEL_ALIGN
478 #define LABEL_ALIGN(LABEL) align_labels
479 #endif
481 #ifndef LOOP_ALIGN
482 #define LOOP_ALIGN(LABEL) align_loops
483 #endif
485 #ifndef LABEL_ALIGN_AFTER_BARRIER
486 #define LABEL_ALIGN_AFTER_BARRIER(LABEL) 0
487 #endif
489 #ifndef JUMP_ALIGN
490 #define JUMP_ALIGN(LABEL) align_jumps
491 #endif
493 #ifndef ADDR_VEC_ALIGN
494 static int
495 final_addr_vec_align (rtx_jump_table_data *addr_vec)
497 int align = GET_MODE_SIZE (addr_vec->get_data_mode ());
499 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
500 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
501 return exact_log2 (align);
505 #define ADDR_VEC_ALIGN(ADDR_VEC) final_addr_vec_align (ADDR_VEC)
506 #endif
508 #ifndef INSN_LENGTH_ALIGNMENT
509 #define INSN_LENGTH_ALIGNMENT(INSN) length_unit_log
510 #endif
512 #define INSN_SHUID(INSN) (uid_shuid[INSN_UID (INSN)])
514 static int min_labelno, max_labelno;
516 #define LABEL_TO_ALIGNMENT(LABEL) \
517 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno])
519 /* For the benefit of port specific code do this also as a function. */
521 align_flags
522 label_to_alignment (rtx label)
524 if (CODE_LABEL_NUMBER (label) <= max_labelno)
525 return LABEL_TO_ALIGNMENT (label);
526 return align_flags ();
529 /* The differences in addresses
530 between a branch and its target might grow or shrink depending on
531 the alignment the start insn of the range (the branch for a forward
532 branch or the label for a backward branch) starts out on; if these
533 differences are used naively, they can even oscillate infinitely.
534 We therefore want to compute a 'worst case' address difference that
535 is independent of the alignment the start insn of the range end
536 up on, and that is at least as large as the actual difference.
537 The function align_fuzz calculates the amount we have to add to the
538 naively computed difference, by traversing the part of the alignment
539 chain of the start insn of the range that is in front of the end insn
540 of the range, and considering for each alignment the maximum amount
541 that it might contribute to a size increase.
543 For casesi tables, we also want to know worst case minimum amounts of
544 address difference, in case a machine description wants to introduce
545 some common offset that is added to all offsets in a table.
546 For this purpose, align_fuzz with a growth argument of 0 computes the
547 appropriate adjustment. */
549 /* Compute the maximum delta by which the difference of the addresses of
550 START and END might grow / shrink due to a different address for start
551 which changes the size of alignment insns between START and END.
552 KNOWN_ALIGN_LOG is the alignment known for START.
553 GROWTH should be ~0 if the objective is to compute potential code size
554 increase, and 0 if the objective is to compute potential shrink.
555 The return value is undefined for any other value of GROWTH. */
557 static int
558 align_fuzz (rtx start, rtx end, int known_align_log, unsigned int growth)
560 int uid = INSN_UID (start);
561 rtx align_label;
562 int known_align = 1 << known_align_log;
563 int end_shuid = INSN_SHUID (end);
564 int fuzz = 0;
566 for (align_label = uid_align[uid]; align_label; align_label = uid_align[uid])
568 int align_addr, new_align;
570 uid = INSN_UID (align_label);
571 align_addr = INSN_ADDRESSES (uid) - insn_lengths[uid];
572 if (uid_shuid[uid] > end_shuid)
573 break;
574 align_flags alignment = LABEL_TO_ALIGNMENT (align_label);
575 new_align = 1 << alignment.levels[0].log;
576 if (new_align < known_align)
577 continue;
578 fuzz += (-align_addr ^ growth) & (new_align - known_align);
579 known_align = new_align;
581 return fuzz;
584 /* Compute a worst-case reference address of a branch so that it
585 can be safely used in the presence of aligned labels. Since the
586 size of the branch itself is unknown, the size of the branch is
587 not included in the range. I.e. for a forward branch, the reference
588 address is the end address of the branch as known from the previous
589 branch shortening pass, minus a value to account for possible size
590 increase due to alignment. For a backward branch, it is the start
591 address of the branch as known from the current pass, plus a value
592 to account for possible size increase due to alignment.
593 NB.: Therefore, the maximum offset allowed for backward branches needs
594 to exclude the branch size. */
597 insn_current_reference_address (rtx_insn *branch)
599 rtx dest;
600 int seq_uid;
602 if (! INSN_ADDRESSES_SET_P ())
603 return 0;
605 rtx_insn *seq = NEXT_INSN (PREV_INSN (branch));
606 seq_uid = INSN_UID (seq);
607 if (!JUMP_P (branch))
608 /* This can happen for example on the PA; the objective is to know the
609 offset to address something in front of the start of the function.
610 Thus, we can treat it like a backward branch.
611 We assume here that FUNCTION_BOUNDARY / BITS_PER_UNIT is larger than
612 any alignment we'd encounter, so we skip the call to align_fuzz. */
613 return insn_current_address;
614 dest = JUMP_LABEL (branch);
616 /* BRANCH has no proper alignment chain set, so use SEQ.
617 BRANCH also has no INSN_SHUID. */
618 if (INSN_SHUID (seq) < INSN_SHUID (dest))
620 /* Forward branch. */
621 return (insn_last_address + insn_lengths[seq_uid]
622 - align_fuzz (seq, dest, length_unit_log, ~0));
624 else
626 /* Backward branch. */
627 return (insn_current_address
628 + align_fuzz (dest, seq, length_unit_log, ~0));
632 /* Compute branch alignments based on CFG profile. */
634 unsigned int
635 compute_alignments (void)
637 basic_block bb;
638 align_flags max_alignment;
640 label_align.truncate (0);
642 max_labelno = max_label_num ();
643 min_labelno = get_first_label_num ();
644 label_align.safe_grow_cleared (max_labelno - min_labelno + 1);
646 /* If not optimizing or optimizing for size, don't assign any alignments. */
647 if (! optimize || optimize_function_for_size_p (cfun))
648 return 0;
650 if (dump_file)
652 dump_reg_info (dump_file);
653 dump_flow_info (dump_file, TDF_DETAILS);
654 flow_loops_dump (dump_file, NULL, 1);
656 loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
657 profile_count count_threshold = cfun->cfg->count_max.apply_scale
658 (1, PARAM_VALUE (PARAM_ALIGN_THRESHOLD));
660 if (dump_file)
662 fprintf (dump_file, "count_max: ");
663 cfun->cfg->count_max.dump (dump_file);
664 fprintf (dump_file, "\n");
666 FOR_EACH_BB_FN (bb, cfun)
668 rtx_insn *label = BB_HEAD (bb);
669 bool has_fallthru = 0;
670 edge e;
671 edge_iterator ei;
673 if (!LABEL_P (label)
674 || optimize_bb_for_size_p (bb))
676 if (dump_file)
677 fprintf (dump_file,
678 "BB %4i loop %2i loop_depth %2i skipped.\n",
679 bb->index,
680 bb->loop_father->num,
681 bb_loop_depth (bb));
682 continue;
684 max_alignment = LABEL_ALIGN (label);
685 profile_count fallthru_count = profile_count::zero ();
686 profile_count branch_count = profile_count::zero ();
688 FOR_EACH_EDGE (e, ei, bb->preds)
690 if (e->flags & EDGE_FALLTHRU)
691 has_fallthru = 1, fallthru_count += e->count ();
692 else
693 branch_count += e->count ();
695 if (dump_file)
697 fprintf (dump_file, "BB %4i loop %2i loop_depth"
698 " %2i fall ",
699 bb->index, bb->loop_father->num,
700 bb_loop_depth (bb));
701 fallthru_count.dump (dump_file);
702 fprintf (dump_file, " branch ");
703 branch_count.dump (dump_file);
704 if (!bb->loop_father->inner && bb->loop_father->num)
705 fprintf (dump_file, " inner_loop");
706 if (bb->loop_father->header == bb)
707 fprintf (dump_file, " loop_header");
708 fprintf (dump_file, "\n");
710 if (!fallthru_count.initialized_p () || !branch_count.initialized_p ())
711 continue;
713 /* There are two purposes to align block with no fallthru incoming edge:
714 1) to avoid fetch stalls when branch destination is near cache boundary
715 2) to improve cache efficiency in case the previous block is not executed
716 (so it does not need to be in the cache).
718 We to catch first case, we align frequently executed blocks.
719 To catch the second, we align blocks that are executed more frequently
720 than the predecessor and the predecessor is likely to not be executed
721 when function is called. */
723 if (!has_fallthru
724 && (branch_count > count_threshold
725 || (bb->count > bb->prev_bb->count.apply_scale (10, 1)
726 && (bb->prev_bb->count
727 <= ENTRY_BLOCK_PTR_FOR_FN (cfun)
728 ->count.apply_scale (1, 2)))))
730 align_flags alignment = JUMP_ALIGN (label);
731 if (dump_file)
732 fprintf (dump_file, " jump alignment added.\n");
733 max_alignment = align_flags::max (max_alignment, alignment);
735 /* In case block is frequent and reached mostly by non-fallthru edge,
736 align it. It is most likely a first block of loop. */
737 if (has_fallthru
738 && !(single_succ_p (bb)
739 && single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun))
740 && optimize_bb_for_speed_p (bb)
741 && branch_count + fallthru_count > count_threshold
742 && (branch_count
743 > fallthru_count.apply_scale
744 (PARAM_VALUE (PARAM_ALIGN_LOOP_ITERATIONS), 1)))
746 align_flags alignment = LOOP_ALIGN (label);
747 if (dump_file)
748 fprintf (dump_file, " internal loop alignment added.\n");
749 max_alignment = align_flags::max (max_alignment, alignment);
751 LABEL_TO_ALIGNMENT (label) = max_alignment;
754 loop_optimizer_finalize ();
755 free_dominance_info (CDI_DOMINATORS);
756 return 0;
759 /* Grow the LABEL_ALIGN array after new labels are created. */
761 static void
762 grow_label_align (void)
764 int old = max_labelno;
765 int n_labels;
766 int n_old_labels;
768 max_labelno = max_label_num ();
770 n_labels = max_labelno - min_labelno + 1;
771 n_old_labels = old - min_labelno + 1;
773 label_align.safe_grow_cleared (n_labels);
775 /* Range of labels grows monotonically in the function. Failing here
776 means that the initialization of array got lost. */
777 gcc_assert (n_old_labels <= n_labels);
780 /* Update the already computed alignment information. LABEL_PAIRS is a vector
781 made up of pairs of labels for which the alignment information of the first
782 element will be copied from that of the second element. */
784 void
785 update_alignments (vec<rtx> &label_pairs)
787 unsigned int i = 0;
788 rtx iter, label = NULL_RTX;
790 if (max_labelno != max_label_num ())
791 grow_label_align ();
793 FOR_EACH_VEC_ELT (label_pairs, i, iter)
794 if (i & 1)
795 LABEL_TO_ALIGNMENT (label) = LABEL_TO_ALIGNMENT (iter);
796 else
797 label = iter;
800 namespace {
802 const pass_data pass_data_compute_alignments =
804 RTL_PASS, /* type */
805 "alignments", /* name */
806 OPTGROUP_NONE, /* optinfo_flags */
807 TV_NONE, /* tv_id */
808 0, /* properties_required */
809 0, /* properties_provided */
810 0, /* properties_destroyed */
811 0, /* todo_flags_start */
812 0, /* todo_flags_finish */
815 class pass_compute_alignments : public rtl_opt_pass
817 public:
818 pass_compute_alignments (gcc::context *ctxt)
819 : rtl_opt_pass (pass_data_compute_alignments, ctxt)
822 /* opt_pass methods: */
823 virtual unsigned int execute (function *) { return compute_alignments (); }
825 }; // class pass_compute_alignments
827 } // anon namespace
829 rtl_opt_pass *
830 make_pass_compute_alignments (gcc::context *ctxt)
832 return new pass_compute_alignments (ctxt);
836 /* Make a pass over all insns and compute their actual lengths by shortening
837 any branches of variable length if possible. */
839 /* shorten_branches might be called multiple times: for example, the SH
840 port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG.
841 In order to do this, it needs proper length information, which it obtains
842 by calling shorten_branches. This cannot be collapsed with
843 shorten_branches itself into a single pass unless we also want to integrate
844 reorg.c, since the branch splitting exposes new instructions with delay
845 slots. */
847 void
848 shorten_branches (rtx_insn *first)
850 rtx_insn *insn;
851 int max_uid;
852 int i;
853 rtx_insn *seq;
854 int something_changed = 1;
855 char *varying_length;
856 rtx body;
857 int uid;
858 rtx align_tab[MAX_CODE_ALIGN + 1];
860 /* Compute maximum UID and allocate label_align / uid_shuid. */
861 max_uid = get_max_uid ();
863 /* Free uid_shuid before reallocating it. */
864 free (uid_shuid);
866 uid_shuid = XNEWVEC (int, max_uid);
868 if (max_labelno != max_label_num ())
869 grow_label_align ();
871 /* Initialize label_align and set up uid_shuid to be strictly
872 monotonically rising with insn order. */
873 /* We use alignment here to keep track of the maximum alignment we want to
874 impose on the next CODE_LABEL (or the current one if we are processing
875 the CODE_LABEL itself). */
877 align_flags max_alignment;
879 for (insn = get_insns (), i = 1; insn; insn = NEXT_INSN (insn))
881 INSN_SHUID (insn) = i++;
882 if (INSN_P (insn))
883 continue;
885 if (rtx_code_label *label = dyn_cast <rtx_code_label *> (insn))
887 /* Merge in alignments computed by compute_alignments. */
888 align_flags alignment = LABEL_TO_ALIGNMENT (label);
889 max_alignment = align_flags::max (max_alignment, alignment);
891 rtx_jump_table_data *table = jump_table_for_label (label);
892 if (!table)
894 align_flags alignment = LABEL_ALIGN (label);
895 max_alignment = align_flags::max (max_alignment, alignment);
897 /* ADDR_VECs only take room if read-only data goes into the text
898 section. */
899 if ((JUMP_TABLES_IN_TEXT_SECTION
900 || readonly_data_section == text_section)
901 && table)
903 align_flags alignment = align_flags (ADDR_VEC_ALIGN (table));
904 max_alignment = align_flags::max (max_alignment, alignment);
906 LABEL_TO_ALIGNMENT (label) = max_alignment;
907 max_alignment = align_flags ();
909 else if (BARRIER_P (insn))
911 rtx_insn *label;
913 for (label = insn; label && ! INSN_P (label);
914 label = NEXT_INSN (label))
915 if (LABEL_P (label))
917 align_flags alignment
918 = align_flags (LABEL_ALIGN_AFTER_BARRIER (insn));
919 max_alignment = align_flags::max (max_alignment, alignment);
920 break;
924 if (!HAVE_ATTR_length)
925 return;
927 /* Allocate the rest of the arrays. */
928 insn_lengths = XNEWVEC (int, max_uid);
929 insn_lengths_max_uid = max_uid;
930 /* Syntax errors can lead to labels being outside of the main insn stream.
931 Initialize insn_addresses, so that we get reproducible results. */
932 INSN_ADDRESSES_ALLOC (max_uid);
934 varying_length = XCNEWVEC (char, max_uid);
936 /* Initialize uid_align. We scan instructions
937 from end to start, and keep in align_tab[n] the last seen insn
938 that does an alignment of at least n+1, i.e. the successor
939 in the alignment chain for an insn that does / has a known
940 alignment of n. */
941 uid_align = XCNEWVEC (rtx, max_uid);
943 for (i = MAX_CODE_ALIGN + 1; --i >= 0;)
944 align_tab[i] = NULL_RTX;
945 seq = get_last_insn ();
946 for (; seq; seq = PREV_INSN (seq))
948 int uid = INSN_UID (seq);
949 int log;
950 log = (LABEL_P (seq) ? LABEL_TO_ALIGNMENT (seq).levels[0].log : 0);
951 uid_align[uid] = align_tab[0];
952 if (log)
954 /* Found an alignment label. */
955 gcc_checking_assert (log < MAX_CODE_ALIGN + 1);
956 uid_align[uid] = align_tab[log];
957 for (i = log - 1; i >= 0; i--)
958 align_tab[i] = seq;
962 /* When optimizing, we start assuming minimum length, and keep increasing
963 lengths as we find the need for this, till nothing changes.
964 When not optimizing, we start assuming maximum lengths, and
965 do a single pass to update the lengths. */
966 bool increasing = optimize != 0;
968 #ifdef CASE_VECTOR_SHORTEN_MODE
969 if (optimize)
971 /* Look for ADDR_DIFF_VECs, and initialize their minimum and maximum
972 label fields. */
974 int min_shuid = INSN_SHUID (get_insns ()) - 1;
975 int max_shuid = INSN_SHUID (get_last_insn ()) + 1;
976 int rel;
978 for (insn = first; insn != 0; insn = NEXT_INSN (insn))
980 rtx min_lab = NULL_RTX, max_lab = NULL_RTX, pat;
981 int len, i, min, max, insn_shuid;
982 int min_align;
983 addr_diff_vec_flags flags;
985 if (! JUMP_TABLE_DATA_P (insn)
986 || GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
987 continue;
988 pat = PATTERN (insn);
989 len = XVECLEN (pat, 1);
990 gcc_assert (len > 0);
991 min_align = MAX_CODE_ALIGN;
992 for (min = max_shuid, max = min_shuid, i = len - 1; i >= 0; i--)
994 rtx lab = XEXP (XVECEXP (pat, 1, i), 0);
995 int shuid = INSN_SHUID (lab);
996 if (shuid < min)
998 min = shuid;
999 min_lab = lab;
1001 if (shuid > max)
1003 max = shuid;
1004 max_lab = lab;
1007 int label_alignment = LABEL_TO_ALIGNMENT (lab).levels[0].log;
1008 if (min_align > label_alignment)
1009 min_align = label_alignment;
1011 XEXP (pat, 2) = gen_rtx_LABEL_REF (Pmode, min_lab);
1012 XEXP (pat, 3) = gen_rtx_LABEL_REF (Pmode, max_lab);
1013 insn_shuid = INSN_SHUID (insn);
1014 rel = INSN_SHUID (XEXP (XEXP (pat, 0), 0));
1015 memset (&flags, 0, sizeof (flags));
1016 flags.min_align = min_align;
1017 flags.base_after_vec = rel > insn_shuid;
1018 flags.min_after_vec = min > insn_shuid;
1019 flags.max_after_vec = max > insn_shuid;
1020 flags.min_after_base = min > rel;
1021 flags.max_after_base = max > rel;
1022 ADDR_DIFF_VEC_FLAGS (pat) = flags;
1024 if (increasing)
1025 PUT_MODE (pat, CASE_VECTOR_SHORTEN_MODE (0, 0, pat));
1028 #endif /* CASE_VECTOR_SHORTEN_MODE */
1030 /* Compute initial lengths, addresses, and varying flags for each insn. */
1031 int (*length_fun) (rtx_insn *) = increasing ? insn_min_length : insn_default_length;
1033 for (insn_current_address = 0, insn = first;
1034 insn != 0;
1035 insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn))
1037 uid = INSN_UID (insn);
1039 insn_lengths[uid] = 0;
1041 if (LABEL_P (insn))
1043 int log = LABEL_TO_ALIGNMENT (insn).levels[0].log;
1044 if (log)
1046 int align = 1 << log;
1047 int new_address = (insn_current_address + align - 1) & -align;
1048 insn_lengths[uid] = new_address - insn_current_address;
1052 INSN_ADDRESSES (uid) = insn_current_address + insn_lengths[uid];
1054 if (NOTE_P (insn) || BARRIER_P (insn)
1055 || LABEL_P (insn) || DEBUG_INSN_P (insn))
1056 continue;
1057 if (insn->deleted ())
1058 continue;
1060 body = PATTERN (insn);
1061 if (rtx_jump_table_data *table = dyn_cast <rtx_jump_table_data *> (insn))
1063 /* This only takes room if read-only data goes into the text
1064 section. */
1065 if (JUMP_TABLES_IN_TEXT_SECTION
1066 || readonly_data_section == text_section)
1067 insn_lengths[uid] = (XVECLEN (body,
1068 GET_CODE (body) == ADDR_DIFF_VEC)
1069 * GET_MODE_SIZE (table->get_data_mode ()));
1070 /* Alignment is handled by ADDR_VEC_ALIGN. */
1072 else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
1073 insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
1074 else if (rtx_sequence *body_seq = dyn_cast <rtx_sequence *> (body))
1076 int i;
1077 int const_delay_slots;
1078 if (DELAY_SLOTS)
1079 const_delay_slots = const_num_delay_slots (body_seq->insn (0));
1080 else
1081 const_delay_slots = 0;
1083 int (*inner_length_fun) (rtx_insn *)
1084 = const_delay_slots ? length_fun : insn_default_length;
1085 /* Inside a delay slot sequence, we do not do any branch shortening
1086 if the shortening could change the number of delay slots
1087 of the branch. */
1088 for (i = 0; i < body_seq->len (); i++)
1090 rtx_insn *inner_insn = body_seq->insn (i);
1091 int inner_uid = INSN_UID (inner_insn);
1092 int inner_length;
1094 if (GET_CODE (PATTERN (inner_insn)) == ASM_INPUT
1095 || asm_noperands (PATTERN (inner_insn)) >= 0)
1096 inner_length = (asm_insn_count (PATTERN (inner_insn))
1097 * insn_default_length (inner_insn));
1098 else
1099 inner_length = inner_length_fun (inner_insn);
1101 insn_lengths[inner_uid] = inner_length;
1102 if (const_delay_slots)
1104 if ((varying_length[inner_uid]
1105 = insn_variable_length_p (inner_insn)) != 0)
1106 varying_length[uid] = 1;
1107 INSN_ADDRESSES (inner_uid) = (insn_current_address
1108 + insn_lengths[uid]);
1110 else
1111 varying_length[inner_uid] = 0;
1112 insn_lengths[uid] += inner_length;
1115 else if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER)
1117 insn_lengths[uid] = length_fun (insn);
1118 varying_length[uid] = insn_variable_length_p (insn);
1121 /* If needed, do any adjustment. */
1122 #ifdef ADJUST_INSN_LENGTH
1123 ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
1124 if (insn_lengths[uid] < 0)
1125 fatal_insn ("negative insn length", insn);
1126 #endif
1129 /* Now loop over all the insns finding varying length insns. For each,
1130 get the current insn length. If it has changed, reflect the change.
1131 When nothing changes for a full pass, we are done. */
1133 while (something_changed)
1135 something_changed = 0;
1136 insn_current_align = MAX_CODE_ALIGN - 1;
1137 for (insn_current_address = 0, insn = first;
1138 insn != 0;
1139 insn = NEXT_INSN (insn))
1141 int new_length;
1142 #ifdef ADJUST_INSN_LENGTH
1143 int tmp_length;
1144 #endif
1145 int length_align;
1147 uid = INSN_UID (insn);
1149 if (rtx_code_label *label = dyn_cast <rtx_code_label *> (insn))
1151 int log = LABEL_TO_ALIGNMENT (label).levels[0].log;
1153 #ifdef CASE_VECTOR_SHORTEN_MODE
1154 /* If the mode of a following jump table was changed, we
1155 may need to update the alignment of this label. */
1157 if (JUMP_TABLES_IN_TEXT_SECTION
1158 || readonly_data_section == text_section)
1160 rtx_jump_table_data *table = jump_table_for_label (label);
1161 if (table)
1163 int newlog = ADDR_VEC_ALIGN (table);
1164 if (newlog != log)
1166 log = newlog;
1167 LABEL_TO_ALIGNMENT (insn) = log;
1168 something_changed = 1;
1172 #endif
1174 if (log > insn_current_align)
1176 int align = 1 << log;
1177 int new_address= (insn_current_address + align - 1) & -align;
1178 insn_lengths[uid] = new_address - insn_current_address;
1179 insn_current_align = log;
1180 insn_current_address = new_address;
1182 else
1183 insn_lengths[uid] = 0;
1184 INSN_ADDRESSES (uid) = insn_current_address;
1185 continue;
1188 length_align = INSN_LENGTH_ALIGNMENT (insn);
1189 if (length_align < insn_current_align)
1190 insn_current_align = length_align;
1192 insn_last_address = INSN_ADDRESSES (uid);
1193 INSN_ADDRESSES (uid) = insn_current_address;
1195 #ifdef CASE_VECTOR_SHORTEN_MODE
1196 if (optimize
1197 && JUMP_TABLE_DATA_P (insn)
1198 && GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
1200 rtx_jump_table_data *table = as_a <rtx_jump_table_data *> (insn);
1201 rtx body = PATTERN (insn);
1202 int old_length = insn_lengths[uid];
1203 rtx_insn *rel_lab =
1204 safe_as_a <rtx_insn *> (XEXP (XEXP (body, 0), 0));
1205 rtx min_lab = XEXP (XEXP (body, 2), 0);
1206 rtx max_lab = XEXP (XEXP (body, 3), 0);
1207 int rel_addr = INSN_ADDRESSES (INSN_UID (rel_lab));
1208 int min_addr = INSN_ADDRESSES (INSN_UID (min_lab));
1209 int max_addr = INSN_ADDRESSES (INSN_UID (max_lab));
1210 rtx_insn *prev;
1211 int rel_align = 0;
1212 addr_diff_vec_flags flags;
1213 scalar_int_mode vec_mode;
1215 /* Avoid automatic aggregate initialization. */
1216 flags = ADDR_DIFF_VEC_FLAGS (body);
1218 /* Try to find a known alignment for rel_lab. */
1219 for (prev = rel_lab;
1220 prev
1221 && ! insn_lengths[INSN_UID (prev)]
1222 && ! (varying_length[INSN_UID (prev)] & 1);
1223 prev = PREV_INSN (prev))
1224 if (varying_length[INSN_UID (prev)] & 2)
1226 rel_align = LABEL_TO_ALIGNMENT (prev).levels[0].log;
1227 break;
1230 /* See the comment on addr_diff_vec_flags in rtl.h for the
1231 meaning of the flags values. base: REL_LAB vec: INSN */
1232 /* Anything after INSN has still addresses from the last
1233 pass; adjust these so that they reflect our current
1234 estimate for this pass. */
1235 if (flags.base_after_vec)
1236 rel_addr += insn_current_address - insn_last_address;
1237 if (flags.min_after_vec)
1238 min_addr += insn_current_address - insn_last_address;
1239 if (flags.max_after_vec)
1240 max_addr += insn_current_address - insn_last_address;
1241 /* We want to know the worst case, i.e. lowest possible value
1242 for the offset of MIN_LAB. If MIN_LAB is after REL_LAB,
1243 its offset is positive, and we have to be wary of code shrink;
1244 otherwise, it is negative, and we have to be vary of code
1245 size increase. */
1246 if (flags.min_after_base)
1248 /* If INSN is between REL_LAB and MIN_LAB, the size
1249 changes we are about to make can change the alignment
1250 within the observed offset, therefore we have to break
1251 it up into two parts that are independent. */
1252 if (! flags.base_after_vec && flags.min_after_vec)
1254 min_addr -= align_fuzz (rel_lab, insn, rel_align, 0);
1255 min_addr -= align_fuzz (insn, min_lab, 0, 0);
1257 else
1258 min_addr -= align_fuzz (rel_lab, min_lab, rel_align, 0);
1260 else
1262 if (flags.base_after_vec && ! flags.min_after_vec)
1264 min_addr -= align_fuzz (min_lab, insn, 0, ~0);
1265 min_addr -= align_fuzz (insn, rel_lab, 0, ~0);
1267 else
1268 min_addr -= align_fuzz (min_lab, rel_lab, 0, ~0);
1270 /* Likewise, determine the highest lowest possible value
1271 for the offset of MAX_LAB. */
1272 if (flags.max_after_base)
1274 if (! flags.base_after_vec && flags.max_after_vec)
1276 max_addr += align_fuzz (rel_lab, insn, rel_align, ~0);
1277 max_addr += align_fuzz (insn, max_lab, 0, ~0);
1279 else
1280 max_addr += align_fuzz (rel_lab, max_lab, rel_align, ~0);
1282 else
1284 if (flags.base_after_vec && ! flags.max_after_vec)
1286 max_addr += align_fuzz (max_lab, insn, 0, 0);
1287 max_addr += align_fuzz (insn, rel_lab, 0, 0);
1289 else
1290 max_addr += align_fuzz (max_lab, rel_lab, 0, 0);
1292 vec_mode = CASE_VECTOR_SHORTEN_MODE (min_addr - rel_addr,
1293 max_addr - rel_addr, body);
1294 if (!increasing
1295 || (GET_MODE_SIZE (vec_mode)
1296 >= GET_MODE_SIZE (table->get_data_mode ())))
1297 PUT_MODE (body, vec_mode);
1298 if (JUMP_TABLES_IN_TEXT_SECTION
1299 || readonly_data_section == text_section)
1301 insn_lengths[uid]
1302 = (XVECLEN (body, 1)
1303 * GET_MODE_SIZE (table->get_data_mode ()));
1304 insn_current_address += insn_lengths[uid];
1305 if (insn_lengths[uid] != old_length)
1306 something_changed = 1;
1309 continue;
1311 #endif /* CASE_VECTOR_SHORTEN_MODE */
1313 if (! (varying_length[uid]))
1315 if (NONJUMP_INSN_P (insn)
1316 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1318 int i;
1320 body = PATTERN (insn);
1321 for (i = 0; i < XVECLEN (body, 0); i++)
1323 rtx inner_insn = XVECEXP (body, 0, i);
1324 int inner_uid = INSN_UID (inner_insn);
1326 INSN_ADDRESSES (inner_uid) = insn_current_address;
1328 insn_current_address += insn_lengths[inner_uid];
1331 else
1332 insn_current_address += insn_lengths[uid];
1334 continue;
1337 if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
1339 rtx_sequence *seqn = as_a <rtx_sequence *> (PATTERN (insn));
1340 int i;
1342 body = PATTERN (insn);
1343 new_length = 0;
1344 for (i = 0; i < seqn->len (); i++)
1346 rtx_insn *inner_insn = seqn->insn (i);
1347 int inner_uid = INSN_UID (inner_insn);
1348 int inner_length;
1350 INSN_ADDRESSES (inner_uid) = insn_current_address;
1352 /* insn_current_length returns 0 for insns with a
1353 non-varying length. */
1354 if (! varying_length[inner_uid])
1355 inner_length = insn_lengths[inner_uid];
1356 else
1357 inner_length = insn_current_length (inner_insn);
1359 if (inner_length != insn_lengths[inner_uid])
1361 if (!increasing || inner_length > insn_lengths[inner_uid])
1363 insn_lengths[inner_uid] = inner_length;
1364 something_changed = 1;
1366 else
1367 inner_length = insn_lengths[inner_uid];
1369 insn_current_address += inner_length;
1370 new_length += inner_length;
1373 else
1375 new_length = insn_current_length (insn);
1376 insn_current_address += new_length;
1379 #ifdef ADJUST_INSN_LENGTH
1380 /* If needed, do any adjustment. */
1381 tmp_length = new_length;
1382 ADJUST_INSN_LENGTH (insn, new_length);
1383 insn_current_address += (new_length - tmp_length);
1384 #endif
1386 if (new_length != insn_lengths[uid]
1387 && (!increasing || new_length > insn_lengths[uid]))
1389 insn_lengths[uid] = new_length;
1390 something_changed = 1;
1392 else
1393 insn_current_address += insn_lengths[uid] - new_length;
1395 /* For a non-optimizing compile, do only a single pass. */
1396 if (!increasing)
1397 break;
1399 crtl->max_insn_address = insn_current_address;
1400 free (varying_length);
1403 /* Given the body of an INSN known to be generated by an ASM statement, return
1404 the number of machine instructions likely to be generated for this insn.
1405 This is used to compute its length. */
1407 static int
1408 asm_insn_count (rtx body)
1410 const char *templ;
1412 if (GET_CODE (body) == ASM_INPUT)
1413 templ = XSTR (body, 0);
1414 else
1415 templ = decode_asm_operands (body, NULL, NULL, NULL, NULL, NULL);
1417 return asm_str_count (templ);
1420 /* Return the number of machine instructions likely to be generated for the
1421 inline-asm template. */
1423 asm_str_count (const char *templ)
1425 int count = 1;
1427 if (!*templ)
1428 return 0;
1430 for (; *templ; templ++)
1431 if (IS_ASM_LOGICAL_LINE_SEPARATOR (*templ, templ)
1432 || *templ == '\n')
1433 count++;
1435 return count;
1438 /* Return true if DWARF2 debug info can be emitted for DECL. */
1440 static bool
1441 dwarf2_debug_info_emitted_p (tree decl)
1443 if (write_symbols != DWARF2_DEBUG && write_symbols != VMS_AND_DWARF2_DEBUG)
1444 return false;
1446 if (DECL_IGNORED_P (decl))
1447 return false;
1449 return true;
1452 /* Return scope resulting from combination of S1 and S2. */
1453 static tree
1454 choose_inner_scope (tree s1, tree s2)
1456 if (!s1)
1457 return s2;
1458 if (!s2)
1459 return s1;
1460 if (BLOCK_NUMBER (s1) > BLOCK_NUMBER (s2))
1461 return s1;
1462 return s2;
1465 /* Emit lexical block notes needed to change scope from S1 to S2. */
1467 static void
1468 change_scope (rtx_insn *orig_insn, tree s1, tree s2)
1470 rtx_insn *insn = orig_insn;
1471 tree com = NULL_TREE;
1472 tree ts1 = s1, ts2 = s2;
1473 tree s;
1475 while (ts1 != ts2)
1477 gcc_assert (ts1 && ts2);
1478 if (BLOCK_NUMBER (ts1) > BLOCK_NUMBER (ts2))
1479 ts1 = BLOCK_SUPERCONTEXT (ts1);
1480 else if (BLOCK_NUMBER (ts1) < BLOCK_NUMBER (ts2))
1481 ts2 = BLOCK_SUPERCONTEXT (ts2);
1482 else
1484 ts1 = BLOCK_SUPERCONTEXT (ts1);
1485 ts2 = BLOCK_SUPERCONTEXT (ts2);
1488 com = ts1;
1490 /* Close scopes. */
1491 s = s1;
1492 while (s != com)
1494 rtx_note *note = emit_note_before (NOTE_INSN_BLOCK_END, insn);
1495 NOTE_BLOCK (note) = s;
1496 s = BLOCK_SUPERCONTEXT (s);
1499 /* Open scopes. */
1500 s = s2;
1501 while (s != com)
1503 insn = emit_note_before (NOTE_INSN_BLOCK_BEG, insn);
1504 NOTE_BLOCK (insn) = s;
1505 s = BLOCK_SUPERCONTEXT (s);
1509 /* Rebuild all the NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes based
1510 on the scope tree and the newly reordered instructions. */
1512 static void
1513 reemit_insn_block_notes (void)
1515 tree cur_block = DECL_INITIAL (cfun->decl);
1516 rtx_insn *insn;
1518 insn = get_insns ();
1519 for (; insn; insn = NEXT_INSN (insn))
1521 tree this_block;
1523 /* Prevent lexical blocks from straddling section boundaries. */
1524 if (NOTE_P (insn))
1525 switch (NOTE_KIND (insn))
1527 case NOTE_INSN_SWITCH_TEXT_SECTIONS:
1529 for (tree s = cur_block; s != DECL_INITIAL (cfun->decl);
1530 s = BLOCK_SUPERCONTEXT (s))
1532 rtx_note *note = emit_note_before (NOTE_INSN_BLOCK_END, insn);
1533 NOTE_BLOCK (note) = s;
1534 note = emit_note_after (NOTE_INSN_BLOCK_BEG, insn);
1535 NOTE_BLOCK (note) = s;
1538 break;
1540 case NOTE_INSN_BEGIN_STMT:
1541 case NOTE_INSN_INLINE_ENTRY:
1542 this_block = LOCATION_BLOCK (NOTE_MARKER_LOCATION (insn));
1543 goto set_cur_block_to_this_block;
1545 default:
1546 continue;
1549 if (!active_insn_p (insn))
1550 continue;
1552 /* Avoid putting scope notes between jump table and its label. */
1553 if (JUMP_TABLE_DATA_P (insn))
1554 continue;
1556 this_block = insn_scope (insn);
1557 /* For sequences compute scope resulting from merging all scopes
1558 of instructions nested inside. */
1559 if (rtx_sequence *body = dyn_cast <rtx_sequence *> (PATTERN (insn)))
1561 int i;
1563 this_block = NULL;
1564 for (i = 0; i < body->len (); i++)
1565 this_block = choose_inner_scope (this_block,
1566 insn_scope (body->insn (i)));
1568 set_cur_block_to_this_block:
1569 if (! this_block)
1571 if (INSN_LOCATION (insn) == UNKNOWN_LOCATION)
1572 continue;
1573 else
1574 this_block = DECL_INITIAL (cfun->decl);
1577 if (this_block != cur_block)
1579 change_scope (insn, cur_block, this_block);
1580 cur_block = this_block;
1584 /* change_scope emits before the insn, not after. */
1585 rtx_note *note = emit_note (NOTE_INSN_DELETED);
1586 change_scope (note, cur_block, DECL_INITIAL (cfun->decl));
1587 delete_insn (note);
1589 reorder_blocks ();
1592 static const char *some_local_dynamic_name;
1594 /* Locate some local-dynamic symbol still in use by this function
1595 so that we can print its name in local-dynamic base patterns.
1596 Return null if there are no local-dynamic references. */
1598 const char *
1599 get_some_local_dynamic_name ()
1601 subrtx_iterator::array_type array;
1602 rtx_insn *insn;
1604 if (some_local_dynamic_name)
1605 return some_local_dynamic_name;
1607 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
1608 if (NONDEBUG_INSN_P (insn))
1609 FOR_EACH_SUBRTX (iter, array, PATTERN (insn), ALL)
1611 const_rtx x = *iter;
1612 if (GET_CODE (x) == SYMBOL_REF)
1614 if (SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
1615 return some_local_dynamic_name = XSTR (x, 0);
1616 if (CONSTANT_POOL_ADDRESS_P (x))
1617 iter.substitute (get_pool_constant (x));
1621 return 0;
1624 /* Arrange for us to emit a source location note before any further
1625 real insns or section changes, by setting the SEEN_NEXT_VIEW bit in
1626 *SEEN, as long as we are keeping track of location views. The bit
1627 indicates we have referenced the next view at the current PC, so we
1628 have to emit it. This should be called next to the var_location
1629 debug hook. */
1631 static inline void
1632 set_next_view_needed (int *seen)
1634 if (debug_variable_location_views)
1635 *seen |= SEEN_NEXT_VIEW;
1638 /* Clear the flag in *SEEN indicating we need to emit the next view.
1639 This should be called next to the source_line debug hook. */
1641 static inline void
1642 clear_next_view_needed (int *seen)
1644 *seen &= ~SEEN_NEXT_VIEW;
1647 /* Test whether we have a pending request to emit the next view in
1648 *SEEN, and emit it if needed, clearing the request bit. */
1650 static inline void
1651 maybe_output_next_view (int *seen)
1653 if ((*seen & SEEN_NEXT_VIEW) != 0)
1655 clear_next_view_needed (seen);
1656 (*debug_hooks->source_line) (last_linenum, last_columnnum,
1657 last_filename, last_discriminator,
1658 false);
1662 /* We want to emit param bindings (before the first begin_stmt) in the
1663 initial view, if we are emitting views. To that end, we may
1664 consume initial notes in the function, processing them in
1665 final_start_function, before signaling the beginning of the
1666 prologue, rather than in final.
1668 We don't test whether the DECLs are PARM_DECLs: the assumption is
1669 that there will be a NOTE_INSN_BEGIN_STMT marker before any
1670 non-parameter NOTE_INSN_VAR_LOCATION. It's ok if the marker is not
1671 there, we'll just have more variable locations bound in the initial
1672 view, which is consistent with their being bound without any code
1673 that would give them a value. */
1675 static inline bool
1676 in_initial_view_p (rtx_insn *insn)
1678 return (!DECL_IGNORED_P (current_function_decl)
1679 && debug_variable_location_views
1680 && insn && GET_CODE (insn) == NOTE
1681 && (NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION
1682 || NOTE_KIND (insn) == NOTE_INSN_DELETED));
1685 /* Output assembler code for the start of a function,
1686 and initialize some of the variables in this file
1687 for the new function. The label for the function and associated
1688 assembler pseudo-ops have already been output in `assemble_start_function'.
1690 FIRST is the first insn of the rtl for the function being compiled.
1691 FILE is the file to write assembler code to.
1692 SEEN should be initially set to zero, and it may be updated to
1693 indicate we have references to the next location view, that would
1694 require us to emit it at the current PC.
1695 OPTIMIZE_P is nonzero if we should eliminate redundant
1696 test and compare insns. */
1698 static void
1699 final_start_function_1 (rtx_insn **firstp, FILE *file, int *seen,
1700 int optimize_p ATTRIBUTE_UNUSED)
1702 block_depth = 0;
1704 this_is_asm_operands = 0;
1706 need_profile_function = false;
1708 last_filename = LOCATION_FILE (prologue_location);
1709 last_linenum = LOCATION_LINE (prologue_location);
1710 last_columnnum = LOCATION_COLUMN (prologue_location);
1711 last_discriminator = discriminator = 0;
1712 last_bb_discriminator = bb_discriminator = 0;
1714 high_block_linenum = high_function_linenum = last_linenum;
1716 if (flag_sanitize & SANITIZE_ADDRESS)
1717 asan_function_start ();
1719 rtx_insn *first = *firstp;
1720 if (in_initial_view_p (first))
1724 final_scan_insn (first, file, 0, 0, seen);
1725 first = NEXT_INSN (first);
1727 while (in_initial_view_p (first));
1728 *firstp = first;
1731 if (!DECL_IGNORED_P (current_function_decl))
1732 debug_hooks->begin_prologue (last_linenum, last_columnnum,
1733 last_filename);
1735 if (!dwarf2_debug_info_emitted_p (current_function_decl))
1736 dwarf2out_begin_prologue (0, 0, NULL);
1738 #ifdef LEAF_REG_REMAP
1739 if (crtl->uses_only_leaf_regs)
1740 leaf_renumber_regs (first);
1741 #endif
1743 /* The Sun386i and perhaps other machines don't work right
1744 if the profiling code comes after the prologue. */
1745 if (targetm.profile_before_prologue () && crtl->profile)
1747 if (targetm.asm_out.function_prologue == default_function_pro_epilogue
1748 && targetm.have_prologue ())
1750 rtx_insn *insn;
1751 for (insn = first; insn; insn = NEXT_INSN (insn))
1752 if (!NOTE_P (insn))
1754 insn = NULL;
1755 break;
1757 else if (NOTE_KIND (insn) == NOTE_INSN_BASIC_BLOCK
1758 || NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
1759 break;
1760 else if (NOTE_KIND (insn) == NOTE_INSN_DELETED
1761 || NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION)
1762 continue;
1763 else
1765 insn = NULL;
1766 break;
1769 if (insn)
1770 need_profile_function = true;
1771 else
1772 profile_function (file);
1774 else
1775 profile_function (file);
1778 /* If debugging, assign block numbers to all of the blocks in this
1779 function. */
1780 if (write_symbols)
1782 reemit_insn_block_notes ();
1783 number_blocks (current_function_decl);
1784 /* We never actually put out begin/end notes for the top-level
1785 block in the function. But, conceptually, that block is
1786 always needed. */
1787 TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl)) = 1;
1790 unsigned HOST_WIDE_INT min_frame_size
1791 = constant_lower_bound (get_frame_size ());
1792 if (min_frame_size > (unsigned HOST_WIDE_INT) warn_frame_larger_than_size)
1794 /* Issue a warning */
1795 warning (OPT_Wframe_larger_than_,
1796 "the frame size of %wu bytes is larger than %wu bytes",
1797 min_frame_size, warn_frame_larger_than_size);
1800 /* First output the function prologue: code to set up the stack frame. */
1801 targetm.asm_out.function_prologue (file);
1803 /* If the machine represents the prologue as RTL, the profiling code must
1804 be emitted when NOTE_INSN_PROLOGUE_END is scanned. */
1805 if (! targetm.have_prologue ())
1806 profile_after_prologue (file);
1809 /* This is an exported final_start_function_1, callable without SEEN. */
1811 void
1812 final_start_function (rtx_insn *first, FILE *file,
1813 int optimize_p ATTRIBUTE_UNUSED)
1815 int seen = 0;
1816 final_start_function_1 (&first, file, &seen, optimize_p);
1817 gcc_assert (seen == 0);
1820 static void
1821 profile_after_prologue (FILE *file ATTRIBUTE_UNUSED)
1823 if (!targetm.profile_before_prologue () && crtl->profile)
1824 profile_function (file);
1827 static void
1828 profile_function (FILE *file ATTRIBUTE_UNUSED)
1830 #ifndef NO_PROFILE_COUNTERS
1831 # define NO_PROFILE_COUNTERS 0
1832 #endif
1833 #ifdef ASM_OUTPUT_REG_PUSH
1834 rtx sval = NULL, chain = NULL;
1836 if (cfun->returns_struct)
1837 sval = targetm.calls.struct_value_rtx (TREE_TYPE (current_function_decl),
1838 true);
1839 if (cfun->static_chain_decl)
1840 chain = targetm.calls.static_chain (current_function_decl, true);
1841 #endif /* ASM_OUTPUT_REG_PUSH */
1843 if (! NO_PROFILE_COUNTERS)
1845 int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE);
1846 switch_to_section (data_section);
1847 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
1848 targetm.asm_out.internal_label (file, "LP", current_function_funcdef_no);
1849 assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, align, 1);
1852 switch_to_section (current_function_section ());
1854 #ifdef ASM_OUTPUT_REG_PUSH
1855 if (sval && REG_P (sval))
1856 ASM_OUTPUT_REG_PUSH (file, REGNO (sval));
1857 if (chain && REG_P (chain))
1858 ASM_OUTPUT_REG_PUSH (file, REGNO (chain));
1859 #endif
1861 FUNCTION_PROFILER (file, current_function_funcdef_no);
1863 #ifdef ASM_OUTPUT_REG_PUSH
1864 if (chain && REG_P (chain))
1865 ASM_OUTPUT_REG_POP (file, REGNO (chain));
1866 if (sval && REG_P (sval))
1867 ASM_OUTPUT_REG_POP (file, REGNO (sval));
1868 #endif
1871 /* Output assembler code for the end of a function.
1872 For clarity, args are same as those of `final_start_function'
1873 even though not all of them are needed. */
1875 void
1876 final_end_function (void)
1878 app_disable ();
1880 if (!DECL_IGNORED_P (current_function_decl))
1881 debug_hooks->end_function (high_function_linenum);
1883 /* Finally, output the function epilogue:
1884 code to restore the stack frame and return to the caller. */
1885 targetm.asm_out.function_epilogue (asm_out_file);
1887 /* And debug output. */
1888 if (!DECL_IGNORED_P (current_function_decl))
1889 debug_hooks->end_epilogue (last_linenum, last_filename);
1891 if (!dwarf2_debug_info_emitted_p (current_function_decl)
1892 && dwarf2out_do_frame ())
1893 dwarf2out_end_epilogue (last_linenum, last_filename);
1895 some_local_dynamic_name = 0;
1899 /* Dumper helper for basic block information. FILE is the assembly
1900 output file, and INSN is the instruction being emitted. */
1902 static void
1903 dump_basic_block_info (FILE *file, rtx_insn *insn, basic_block *start_to_bb,
1904 basic_block *end_to_bb, int bb_map_size, int *bb_seqn)
1906 basic_block bb;
1908 if (!flag_debug_asm)
1909 return;
1911 if (INSN_UID (insn) < bb_map_size
1912 && (bb = start_to_bb[INSN_UID (insn)]) != NULL)
1914 edge e;
1915 edge_iterator ei;
1917 fprintf (file, "%s BLOCK %d", ASM_COMMENT_START, bb->index);
1918 if (bb->count.initialized_p ())
1920 fprintf (file, ", count:");
1921 bb->count.dump (file);
1923 fprintf (file, " seq:%d", (*bb_seqn)++);
1924 fprintf (file, "\n%s PRED:", ASM_COMMENT_START);
1925 FOR_EACH_EDGE (e, ei, bb->preds)
1927 dump_edge_info (file, e, TDF_DETAILS, 0);
1929 fprintf (file, "\n");
1931 if (INSN_UID (insn) < bb_map_size
1932 && (bb = end_to_bb[INSN_UID (insn)]) != NULL)
1934 edge e;
1935 edge_iterator ei;
1937 fprintf (asm_out_file, "%s SUCC:", ASM_COMMENT_START);
1938 FOR_EACH_EDGE (e, ei, bb->succs)
1940 dump_edge_info (asm_out_file, e, TDF_DETAILS, 1);
1942 fprintf (file, "\n");
1946 /* Output assembler code for some insns: all or part of a function.
1947 For description of args, see `final_start_function', above. */
1949 static void
1950 final_1 (rtx_insn *first, FILE *file, int seen, int optimize_p)
1952 rtx_insn *insn, *next;
1954 /* Used for -dA dump. */
1955 basic_block *start_to_bb = NULL;
1956 basic_block *end_to_bb = NULL;
1957 int bb_map_size = 0;
1958 int bb_seqn = 0;
1960 last_ignored_compare = 0;
1962 if (HAVE_cc0)
1963 for (insn = first; insn; insn = NEXT_INSN (insn))
1965 /* If CC tracking across branches is enabled, record the insn which
1966 jumps to each branch only reached from one place. */
1967 if (optimize_p && JUMP_P (insn))
1969 rtx lab = JUMP_LABEL (insn);
1970 if (lab && LABEL_P (lab) && LABEL_NUSES (lab) == 1)
1972 LABEL_REFS (lab) = insn;
1977 init_recog ();
1979 CC_STATUS_INIT;
1981 if (flag_debug_asm)
1983 basic_block bb;
1985 bb_map_size = get_max_uid () + 1;
1986 start_to_bb = XCNEWVEC (basic_block, bb_map_size);
1987 end_to_bb = XCNEWVEC (basic_block, bb_map_size);
1989 /* There is no cfg for a thunk. */
1990 if (!cfun->is_thunk)
1991 FOR_EACH_BB_REVERSE_FN (bb, cfun)
1993 start_to_bb[INSN_UID (BB_HEAD (bb))] = bb;
1994 end_to_bb[INSN_UID (BB_END (bb))] = bb;
1998 /* Output the insns. */
1999 for (insn = first; insn;)
2001 if (HAVE_ATTR_length)
2003 if ((unsigned) INSN_UID (insn) >= INSN_ADDRESSES_SIZE ())
2005 /* This can be triggered by bugs elsewhere in the compiler if
2006 new insns are created after init_insn_lengths is called. */
2007 gcc_assert (NOTE_P (insn));
2008 insn_current_address = -1;
2010 else
2011 insn_current_address = INSN_ADDRESSES (INSN_UID (insn));
2012 /* final can be seen as an iteration of shorten_branches that
2013 does nothing (since a fixed point has already been reached). */
2014 insn_last_address = insn_current_address;
2017 dump_basic_block_info (file, insn, start_to_bb, end_to_bb,
2018 bb_map_size, &bb_seqn);
2019 insn = final_scan_insn (insn, file, optimize_p, 0, &seen);
2022 maybe_output_next_view (&seen);
2024 if (flag_debug_asm)
2026 free (start_to_bb);
2027 free (end_to_bb);
2030 /* Remove CFI notes, to avoid compare-debug failures. */
2031 for (insn = first; insn; insn = next)
2033 next = NEXT_INSN (insn);
2034 if (NOTE_P (insn)
2035 && (NOTE_KIND (insn) == NOTE_INSN_CFI
2036 || NOTE_KIND (insn) == NOTE_INSN_CFI_LABEL))
2037 delete_insn (insn);
2041 /* This is an exported final_1, callable without SEEN. */
2043 void
2044 final (rtx_insn *first, FILE *file, int optimize_p)
2046 /* Those that use the internal final_start_function_1/final_1 API
2047 skip initial debug bind notes in final_start_function_1, and pass
2048 the modified FIRST to final_1. But those that use the public
2049 final_start_function/final APIs, final_start_function can't move
2050 FIRST because it's not passed by reference, so if they were
2051 skipped there, skip them again here. */
2052 while (in_initial_view_p (first))
2053 first = NEXT_INSN (first);
2055 final_1 (first, file, 0, optimize_p);
2058 const char *
2059 get_insn_template (int code, rtx_insn *insn)
2061 switch (insn_data[code].output_format)
2063 case INSN_OUTPUT_FORMAT_SINGLE:
2064 return insn_data[code].output.single;
2065 case INSN_OUTPUT_FORMAT_MULTI:
2066 return insn_data[code].output.multi[which_alternative];
2067 case INSN_OUTPUT_FORMAT_FUNCTION:
2068 gcc_assert (insn);
2069 return (*insn_data[code].output.function) (recog_data.operand, insn);
2071 default:
2072 gcc_unreachable ();
2076 /* Emit the appropriate declaration for an alternate-entry-point
2077 symbol represented by INSN, to FILE. INSN is a CODE_LABEL with
2078 LABEL_KIND != LABEL_NORMAL.
2080 The case fall-through in this function is intentional. */
2081 static void
2082 output_alternate_entry_point (FILE *file, rtx_insn *insn)
2084 const char *name = LABEL_NAME (insn);
2086 switch (LABEL_KIND (insn))
2088 case LABEL_WEAK_ENTRY:
2089 #ifdef ASM_WEAKEN_LABEL
2090 ASM_WEAKEN_LABEL (file, name);
2091 gcc_fallthrough ();
2092 #endif
2093 case LABEL_GLOBAL_ENTRY:
2094 targetm.asm_out.globalize_label (file, name);
2095 gcc_fallthrough ();
2096 case LABEL_STATIC_ENTRY:
2097 #ifdef ASM_OUTPUT_TYPE_DIRECTIVE
2098 ASM_OUTPUT_TYPE_DIRECTIVE (file, name, "function");
2099 #endif
2100 ASM_OUTPUT_LABEL (file, name);
2101 break;
2103 case LABEL_NORMAL:
2104 default:
2105 gcc_unreachable ();
2109 /* Given a CALL_INSN, find and return the nested CALL. */
2110 static rtx
2111 call_from_call_insn (rtx_call_insn *insn)
2113 rtx x;
2114 gcc_assert (CALL_P (insn));
2115 x = PATTERN (insn);
2117 while (GET_CODE (x) != CALL)
2119 switch (GET_CODE (x))
2121 default:
2122 gcc_unreachable ();
2123 case COND_EXEC:
2124 x = COND_EXEC_CODE (x);
2125 break;
2126 case PARALLEL:
2127 x = XVECEXP (x, 0, 0);
2128 break;
2129 case SET:
2130 x = XEXP (x, 1);
2131 break;
2134 return x;
2137 /* Print a comment into the asm showing FILENAME, LINENUM, and the
2138 corresponding source line, if available. */
2140 static void
2141 asm_show_source (const char *filename, int linenum)
2143 if (!filename)
2144 return;
2146 char_span line = location_get_source_line (filename, linenum);
2147 if (!line)
2148 return;
2150 fprintf (asm_out_file, "%s %s:%i: ", ASM_COMMENT_START, filename, linenum);
2151 /* "line" is not 0-terminated, so we must use its length. */
2152 fwrite (line.get_buffer (), 1, line.length (), asm_out_file);
2153 fputc ('\n', asm_out_file);
2156 /* The final scan for one insn, INSN.
2157 Args are same as in `final', except that INSN
2158 is the insn being scanned.
2159 Value returned is the next insn to be scanned.
2161 NOPEEPHOLES is the flag to disallow peephole processing (currently
2162 used for within delayed branch sequence output).
2164 SEEN is used to track the end of the prologue, for emitting
2165 debug information. We force the emission of a line note after
2166 both NOTE_INSN_PROLOGUE_END and NOTE_INSN_FUNCTION_BEG. */
2168 static rtx_insn *
2169 final_scan_insn_1 (rtx_insn *insn, FILE *file, int optimize_p ATTRIBUTE_UNUSED,
2170 int nopeepholes ATTRIBUTE_UNUSED, int *seen)
2172 #if HAVE_cc0
2173 rtx set;
2174 #endif
2175 rtx_insn *next;
2176 rtx_jump_table_data *table;
2178 insn_counter++;
2180 /* Ignore deleted insns. These can occur when we split insns (due to a
2181 template of "#") while not optimizing. */
2182 if (insn->deleted ())
2183 return NEXT_INSN (insn);
2185 switch (GET_CODE (insn))
2187 case NOTE:
2188 switch (NOTE_KIND (insn))
2190 case NOTE_INSN_DELETED:
2191 case NOTE_INSN_UPDATE_SJLJ_CONTEXT:
2192 break;
2194 case NOTE_INSN_SWITCH_TEXT_SECTIONS:
2195 maybe_output_next_view (seen);
2197 output_function_exception_table (0);
2199 if (targetm.asm_out.unwind_emit)
2200 targetm.asm_out.unwind_emit (asm_out_file, insn);
2202 in_cold_section_p = !in_cold_section_p;
2204 if (in_cold_section_p)
2205 cold_function_name
2206 = clone_function_name (current_function_decl, "cold");
2208 if (dwarf2out_do_frame ())
2210 dwarf2out_switch_text_section ();
2211 if (!dwarf2_debug_info_emitted_p (current_function_decl)
2212 && !DECL_IGNORED_P (current_function_decl))
2213 debug_hooks->switch_text_section ();
2215 else if (!DECL_IGNORED_P (current_function_decl))
2216 debug_hooks->switch_text_section ();
2218 switch_to_section (current_function_section ());
2219 targetm.asm_out.function_switched_text_sections (asm_out_file,
2220 current_function_decl,
2221 in_cold_section_p);
2222 /* Emit a label for the split cold section. Form label name by
2223 suffixing "cold" to the original function's name. */
2224 if (in_cold_section_p)
2226 #ifdef ASM_DECLARE_COLD_FUNCTION_NAME
2227 ASM_DECLARE_COLD_FUNCTION_NAME (asm_out_file,
2228 IDENTIFIER_POINTER
2229 (cold_function_name),
2230 current_function_decl);
2231 #else
2232 ASM_OUTPUT_LABEL (asm_out_file,
2233 IDENTIFIER_POINTER (cold_function_name));
2234 #endif
2235 if (dwarf2out_do_frame ()
2236 && cfun->fde->dw_fde_second_begin != NULL)
2237 ASM_OUTPUT_LABEL (asm_out_file, cfun->fde->dw_fde_second_begin);
2239 break;
2241 case NOTE_INSN_BASIC_BLOCK:
2242 if (need_profile_function)
2244 profile_function (asm_out_file);
2245 need_profile_function = false;
2248 if (targetm.asm_out.unwind_emit)
2249 targetm.asm_out.unwind_emit (asm_out_file, insn);
2251 bb_discriminator = NOTE_BASIC_BLOCK (insn)->discriminator;
2252 break;
2254 case NOTE_INSN_EH_REGION_BEG:
2255 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHB",
2256 NOTE_EH_HANDLER (insn));
2257 break;
2259 case NOTE_INSN_EH_REGION_END:
2260 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHE",
2261 NOTE_EH_HANDLER (insn));
2262 break;
2264 case NOTE_INSN_PROLOGUE_END:
2265 targetm.asm_out.function_end_prologue (file);
2266 profile_after_prologue (file);
2268 if ((*seen & (SEEN_EMITTED | SEEN_NOTE)) == SEEN_NOTE)
2270 *seen |= SEEN_EMITTED;
2271 force_source_line = true;
2273 else
2274 *seen |= SEEN_NOTE;
2276 break;
2278 case NOTE_INSN_EPILOGUE_BEG:
2279 if (!DECL_IGNORED_P (current_function_decl))
2280 (*debug_hooks->begin_epilogue) (last_linenum, last_filename);
2281 targetm.asm_out.function_begin_epilogue (file);
2282 break;
2284 case NOTE_INSN_CFI:
2285 dwarf2out_emit_cfi (NOTE_CFI (insn));
2286 break;
2288 case NOTE_INSN_CFI_LABEL:
2289 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LCFI",
2290 NOTE_LABEL_NUMBER (insn));
2291 break;
2293 case NOTE_INSN_FUNCTION_BEG:
2294 if (need_profile_function)
2296 profile_function (asm_out_file);
2297 need_profile_function = false;
2300 app_disable ();
2301 if (!DECL_IGNORED_P (current_function_decl))
2302 debug_hooks->end_prologue (last_linenum, last_filename);
2304 if ((*seen & (SEEN_EMITTED | SEEN_NOTE)) == SEEN_NOTE)
2306 *seen |= SEEN_EMITTED;
2307 force_source_line = true;
2309 else
2310 *seen |= SEEN_NOTE;
2312 break;
2314 case NOTE_INSN_BLOCK_BEG:
2315 if (debug_info_level == DINFO_LEVEL_NORMAL
2316 || debug_info_level == DINFO_LEVEL_VERBOSE
2317 || write_symbols == DWARF2_DEBUG
2318 || write_symbols == VMS_AND_DWARF2_DEBUG
2319 || write_symbols == VMS_DEBUG)
2321 int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
2323 app_disable ();
2324 ++block_depth;
2325 high_block_linenum = last_linenum;
2327 /* Output debugging info about the symbol-block beginning. */
2328 if (!DECL_IGNORED_P (current_function_decl))
2329 debug_hooks->begin_block (last_linenum, n);
2331 /* Mark this block as output. */
2332 TREE_ASM_WRITTEN (NOTE_BLOCK (insn)) = 1;
2333 BLOCK_IN_COLD_SECTION_P (NOTE_BLOCK (insn)) = in_cold_section_p;
2335 if (write_symbols == DBX_DEBUG)
2337 location_t *locus_ptr
2338 = block_nonartificial_location (NOTE_BLOCK (insn));
2340 if (locus_ptr != NULL)
2342 override_filename = LOCATION_FILE (*locus_ptr);
2343 override_linenum = LOCATION_LINE (*locus_ptr);
2344 override_columnnum = LOCATION_COLUMN (*locus_ptr);
2347 break;
2349 case NOTE_INSN_BLOCK_END:
2350 maybe_output_next_view (seen);
2352 if (debug_info_level == DINFO_LEVEL_NORMAL
2353 || debug_info_level == DINFO_LEVEL_VERBOSE
2354 || write_symbols == DWARF2_DEBUG
2355 || write_symbols == VMS_AND_DWARF2_DEBUG
2356 || write_symbols == VMS_DEBUG)
2358 int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
2360 app_disable ();
2362 /* End of a symbol-block. */
2363 --block_depth;
2364 gcc_assert (block_depth >= 0);
2366 if (!DECL_IGNORED_P (current_function_decl))
2367 debug_hooks->end_block (high_block_linenum, n);
2368 gcc_assert (BLOCK_IN_COLD_SECTION_P (NOTE_BLOCK (insn))
2369 == in_cold_section_p);
2371 if (write_symbols == DBX_DEBUG)
2373 tree outer_block = BLOCK_SUPERCONTEXT (NOTE_BLOCK (insn));
2374 location_t *locus_ptr
2375 = block_nonartificial_location (outer_block);
2377 if (locus_ptr != NULL)
2379 override_filename = LOCATION_FILE (*locus_ptr);
2380 override_linenum = LOCATION_LINE (*locus_ptr);
2381 override_columnnum = LOCATION_COLUMN (*locus_ptr);
2383 else
2385 override_filename = NULL;
2386 override_linenum = 0;
2387 override_columnnum = 0;
2390 break;
2392 case NOTE_INSN_DELETED_LABEL:
2393 /* Emit the label. We may have deleted the CODE_LABEL because
2394 the label could be proved to be unreachable, though still
2395 referenced (in the form of having its address taken. */
2396 ASM_OUTPUT_DEBUG_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
2397 break;
2399 case NOTE_INSN_DELETED_DEBUG_LABEL:
2400 /* Similarly, but need to use different namespace for it. */
2401 if (CODE_LABEL_NUMBER (insn) != -1)
2402 ASM_OUTPUT_DEBUG_LABEL (file, "LDL", CODE_LABEL_NUMBER (insn));
2403 break;
2405 case NOTE_INSN_VAR_LOCATION:
2406 if (!DECL_IGNORED_P (current_function_decl))
2408 debug_hooks->var_location (insn);
2409 set_next_view_needed (seen);
2411 break;
2413 case NOTE_INSN_BEGIN_STMT:
2414 gcc_checking_assert (cfun->debug_nonbind_markers);
2415 if (!DECL_IGNORED_P (current_function_decl)
2416 && notice_source_line (insn, NULL))
2418 output_source_line:
2419 (*debug_hooks->source_line) (last_linenum, last_columnnum,
2420 last_filename, last_discriminator,
2421 true);
2422 clear_next_view_needed (seen);
2424 break;
2426 case NOTE_INSN_INLINE_ENTRY:
2427 gcc_checking_assert (cfun->debug_nonbind_markers);
2428 if (!DECL_IGNORED_P (current_function_decl))
2430 if (!notice_source_line (insn, NULL))
2431 break;
2432 (*debug_hooks->inline_entry) (LOCATION_BLOCK
2433 (NOTE_MARKER_LOCATION (insn)));
2434 goto output_source_line;
2436 break;
2438 default:
2439 gcc_unreachable ();
2440 break;
2442 break;
2444 case BARRIER:
2445 break;
2447 case CODE_LABEL:
2448 /* The target port might emit labels in the output function for
2449 some insn, e.g. sh.c output_branchy_insn. */
2450 if (CODE_LABEL_NUMBER (insn) <= max_labelno)
2452 align_flags alignment = LABEL_TO_ALIGNMENT (insn);
2453 if (alignment.levels[0].log && NEXT_INSN (insn))
2455 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
2456 /* Output both primary and secondary alignment. */
2457 ASM_OUTPUT_MAX_SKIP_ALIGN (file, alignment.levels[0].log,
2458 alignment.levels[0].maxskip);
2459 ASM_OUTPUT_MAX_SKIP_ALIGN (file, alignment.levels[1].log,
2460 alignment.levels[1].maxskip);
2461 #else
2462 #ifdef ASM_OUTPUT_ALIGN_WITH_NOP
2463 ASM_OUTPUT_ALIGN_WITH_NOP (file, alignment.levels[0].log);
2464 #else
2465 ASM_OUTPUT_ALIGN (file, alignment.levels[0].log);
2466 #endif
2467 #endif
2470 CC_STATUS_INIT;
2472 if (!DECL_IGNORED_P (current_function_decl) && LABEL_NAME (insn))
2473 debug_hooks->label (as_a <rtx_code_label *> (insn));
2475 app_disable ();
2477 /* If this label is followed by a jump-table, make sure we put
2478 the label in the read-only section. Also possibly write the
2479 label and jump table together. */
2480 table = jump_table_for_label (as_a <rtx_code_label *> (insn));
2481 if (table)
2483 #if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2484 /* In this case, the case vector is being moved by the
2485 target, so don't output the label at all. Leave that
2486 to the back end macros. */
2487 #else
2488 if (! JUMP_TABLES_IN_TEXT_SECTION)
2490 int log_align;
2492 switch_to_section (targetm.asm_out.function_rodata_section
2493 (current_function_decl));
2495 #ifdef ADDR_VEC_ALIGN
2496 log_align = ADDR_VEC_ALIGN (table);
2497 #else
2498 log_align = exact_log2 (BIGGEST_ALIGNMENT / BITS_PER_UNIT);
2499 #endif
2500 ASM_OUTPUT_ALIGN (file, log_align);
2502 else
2503 switch_to_section (current_function_section ());
2505 #ifdef ASM_OUTPUT_CASE_LABEL
2506 ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn), table);
2507 #else
2508 targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (insn));
2509 #endif
2510 #endif
2511 break;
2513 if (LABEL_ALT_ENTRY_P (insn))
2514 output_alternate_entry_point (file, insn);
2515 else
2516 targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (insn));
2517 break;
2519 default:
2521 rtx body = PATTERN (insn);
2522 int insn_code_number;
2523 const char *templ;
2524 bool is_stmt, *is_stmt_p;
2526 if (MAY_HAVE_DEBUG_MARKER_INSNS && cfun->debug_nonbind_markers)
2528 is_stmt = false;
2529 is_stmt_p = NULL;
2531 else
2532 is_stmt_p = &is_stmt;
2534 /* Reset this early so it is correct for ASM statements. */
2535 current_insn_predicate = NULL_RTX;
2537 /* An INSN, JUMP_INSN or CALL_INSN.
2538 First check for special kinds that recog doesn't recognize. */
2540 if (GET_CODE (body) == USE /* These are just declarations. */
2541 || GET_CODE (body) == CLOBBER)
2542 break;
2544 #if HAVE_cc0
2546 /* If there is a REG_CC_SETTER note on this insn, it means that
2547 the setting of the condition code was done in the delay slot
2548 of the insn that branched here. So recover the cc status
2549 from the insn that set it. */
2551 rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
2552 if (note)
2554 rtx_insn *other = as_a <rtx_insn *> (XEXP (note, 0));
2555 NOTICE_UPDATE_CC (PATTERN (other), other);
2556 cc_prev_status = cc_status;
2559 #endif
2561 /* Detect insns that are really jump-tables
2562 and output them as such. */
2564 if (JUMP_TABLE_DATA_P (insn))
2566 #if !(defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC))
2567 int vlen, idx;
2568 #endif
2570 if (! JUMP_TABLES_IN_TEXT_SECTION)
2571 switch_to_section (targetm.asm_out.function_rodata_section
2572 (current_function_decl));
2573 else
2574 switch_to_section (current_function_section ());
2576 app_disable ();
2578 #if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2579 if (GET_CODE (body) == ADDR_VEC)
2581 #ifdef ASM_OUTPUT_ADDR_VEC
2582 ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn), body);
2583 #else
2584 gcc_unreachable ();
2585 #endif
2587 else
2589 #ifdef ASM_OUTPUT_ADDR_DIFF_VEC
2590 ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn), body);
2591 #else
2592 gcc_unreachable ();
2593 #endif
2595 #else
2596 vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC);
2597 for (idx = 0; idx < vlen; idx++)
2599 if (GET_CODE (body) == ADDR_VEC)
2601 #ifdef ASM_OUTPUT_ADDR_VEC_ELT
2602 ASM_OUTPUT_ADDR_VEC_ELT
2603 (file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
2604 #else
2605 gcc_unreachable ();
2606 #endif
2608 else
2610 #ifdef ASM_OUTPUT_ADDR_DIFF_ELT
2611 ASM_OUTPUT_ADDR_DIFF_ELT
2612 (file,
2613 body,
2614 CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
2615 CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
2616 #else
2617 gcc_unreachable ();
2618 #endif
2621 #ifdef ASM_OUTPUT_CASE_END
2622 ASM_OUTPUT_CASE_END (file,
2623 CODE_LABEL_NUMBER (PREV_INSN (insn)),
2624 insn);
2625 #endif
2626 #endif
2628 switch_to_section (current_function_section ());
2630 if (debug_variable_location_views
2631 && !DECL_IGNORED_P (current_function_decl))
2632 debug_hooks->var_location (insn);
2634 break;
2636 /* Output this line note if it is the first or the last line
2637 note in a row. */
2638 if (!DECL_IGNORED_P (current_function_decl)
2639 && notice_source_line (insn, is_stmt_p))
2641 if (flag_verbose_asm)
2642 asm_show_source (last_filename, last_linenum);
2643 (*debug_hooks->source_line) (last_linenum, last_columnnum,
2644 last_filename, last_discriminator,
2645 is_stmt);
2646 clear_next_view_needed (seen);
2648 else
2649 maybe_output_next_view (seen);
2651 gcc_checking_assert (!DEBUG_INSN_P (insn));
2653 if (GET_CODE (body) == PARALLEL
2654 && GET_CODE (XVECEXP (body, 0, 0)) == ASM_INPUT)
2655 body = XVECEXP (body, 0, 0);
2657 if (GET_CODE (body) == ASM_INPUT)
2659 const char *string = XSTR (body, 0);
2661 /* There's no telling what that did to the condition codes. */
2662 CC_STATUS_INIT;
2664 if (string[0])
2666 expanded_location loc;
2668 app_enable ();
2669 loc = expand_location (ASM_INPUT_SOURCE_LOCATION (body));
2670 if (*loc.file && loc.line)
2671 fprintf (asm_out_file, "%s %i \"%s\" 1\n",
2672 ASM_COMMENT_START, loc.line, loc.file);
2673 fprintf (asm_out_file, "\t%s\n", string);
2674 #if HAVE_AS_LINE_ZERO
2675 if (*loc.file && loc.line)
2676 fprintf (asm_out_file, "%s 0 \"\" 2\n", ASM_COMMENT_START);
2677 #endif
2679 break;
2682 /* Detect `asm' construct with operands. */
2683 if (asm_noperands (body) >= 0)
2685 unsigned int noperands = asm_noperands (body);
2686 rtx *ops = XALLOCAVEC (rtx, noperands);
2687 const char *string;
2688 location_t loc;
2689 expanded_location expanded;
2691 /* There's no telling what that did to the condition codes. */
2692 CC_STATUS_INIT;
2694 /* Get out the operand values. */
2695 string = decode_asm_operands (body, ops, NULL, NULL, NULL, &loc);
2696 /* Inhibit dying on what would otherwise be compiler bugs. */
2697 insn_noperands = noperands;
2698 this_is_asm_operands = insn;
2699 expanded = expand_location (loc);
2701 #ifdef FINAL_PRESCAN_INSN
2702 FINAL_PRESCAN_INSN (insn, ops, insn_noperands);
2703 #endif
2705 /* Output the insn using them. */
2706 if (string[0])
2708 app_enable ();
2709 if (expanded.file && expanded.line)
2710 fprintf (asm_out_file, "%s %i \"%s\" 1\n",
2711 ASM_COMMENT_START, expanded.line, expanded.file);
2712 output_asm_insn (string, ops);
2713 #if HAVE_AS_LINE_ZERO
2714 if (expanded.file && expanded.line)
2715 fprintf (asm_out_file, "%s 0 \"\" 2\n", ASM_COMMENT_START);
2716 #endif
2719 if (targetm.asm_out.final_postscan_insn)
2720 targetm.asm_out.final_postscan_insn (file, insn, ops,
2721 insn_noperands);
2723 this_is_asm_operands = 0;
2724 break;
2727 app_disable ();
2729 if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (body))
2731 /* A delayed-branch sequence */
2732 int i;
2734 final_sequence = seq;
2736 /* The first insn in this SEQUENCE might be a JUMP_INSN that will
2737 force the restoration of a comparison that was previously
2738 thought unnecessary. If that happens, cancel this sequence
2739 and cause that insn to be restored. */
2741 next = final_scan_insn (seq->insn (0), file, 0, 1, seen);
2742 if (next != seq->insn (1))
2744 final_sequence = 0;
2745 return next;
2748 for (i = 1; i < seq->len (); i++)
2750 rtx_insn *insn = seq->insn (i);
2751 rtx_insn *next = NEXT_INSN (insn);
2752 /* We loop in case any instruction in a delay slot gets
2753 split. */
2755 insn = final_scan_insn (insn, file, 0, 1, seen);
2756 while (insn != next);
2758 #ifdef DBR_OUTPUT_SEQEND
2759 DBR_OUTPUT_SEQEND (file);
2760 #endif
2761 final_sequence = 0;
2763 /* If the insn requiring the delay slot was a CALL_INSN, the
2764 insns in the delay slot are actually executed before the
2765 called function. Hence we don't preserve any CC-setting
2766 actions in these insns and the CC must be marked as being
2767 clobbered by the function. */
2768 if (CALL_P (seq->insn (0)))
2770 CC_STATUS_INIT;
2772 break;
2775 /* We have a real machine instruction as rtl. */
2777 body = PATTERN (insn);
2779 #if HAVE_cc0
2780 set = single_set (insn);
2782 /* Check for redundant test and compare instructions
2783 (when the condition codes are already set up as desired).
2784 This is done only when optimizing; if not optimizing,
2785 it should be possible for the user to alter a variable
2786 with the debugger in between statements
2787 and the next statement should reexamine the variable
2788 to compute the condition codes. */
2790 if (optimize_p)
2792 if (set
2793 && GET_CODE (SET_DEST (set)) == CC0
2794 && insn != last_ignored_compare)
2796 rtx src1, src2;
2797 if (GET_CODE (SET_SRC (set)) == SUBREG)
2798 SET_SRC (set) = alter_subreg (&SET_SRC (set), true);
2800 src1 = SET_SRC (set);
2801 src2 = NULL_RTX;
2802 if (GET_CODE (SET_SRC (set)) == COMPARE)
2804 if (GET_CODE (XEXP (SET_SRC (set), 0)) == SUBREG)
2805 XEXP (SET_SRC (set), 0)
2806 = alter_subreg (&XEXP (SET_SRC (set), 0), true);
2807 if (GET_CODE (XEXP (SET_SRC (set), 1)) == SUBREG)
2808 XEXP (SET_SRC (set), 1)
2809 = alter_subreg (&XEXP (SET_SRC (set), 1), true);
2810 if (XEXP (SET_SRC (set), 1)
2811 == CONST0_RTX (GET_MODE (XEXP (SET_SRC (set), 0))))
2812 src2 = XEXP (SET_SRC (set), 0);
2814 if ((cc_status.value1 != 0
2815 && rtx_equal_p (src1, cc_status.value1))
2816 || (cc_status.value2 != 0
2817 && rtx_equal_p (src1, cc_status.value2))
2818 || (src2 != 0 && cc_status.value1 != 0
2819 && rtx_equal_p (src2, cc_status.value1))
2820 || (src2 != 0 && cc_status.value2 != 0
2821 && rtx_equal_p (src2, cc_status.value2)))
2823 /* Don't delete insn if it has an addressing side-effect. */
2824 if (! FIND_REG_INC_NOTE (insn, NULL_RTX)
2825 /* or if anything in it is volatile. */
2826 && ! volatile_refs_p (PATTERN (insn)))
2828 /* We don't really delete the insn; just ignore it. */
2829 last_ignored_compare = insn;
2830 break;
2836 /* If this is a conditional branch, maybe modify it
2837 if the cc's are in a nonstandard state
2838 so that it accomplishes the same thing that it would
2839 do straightforwardly if the cc's were set up normally. */
2841 if (cc_status.flags != 0
2842 && JUMP_P (insn)
2843 && GET_CODE (body) == SET
2844 && SET_DEST (body) == pc_rtx
2845 && GET_CODE (SET_SRC (body)) == IF_THEN_ELSE
2846 && COMPARISON_P (XEXP (SET_SRC (body), 0))
2847 && XEXP (XEXP (SET_SRC (body), 0), 0) == cc0_rtx)
2849 /* This function may alter the contents of its argument
2850 and clear some of the cc_status.flags bits.
2851 It may also return 1 meaning condition now always true
2852 or -1 meaning condition now always false
2853 or 2 meaning condition nontrivial but altered. */
2854 int result = alter_cond (XEXP (SET_SRC (body), 0));
2855 /* If condition now has fixed value, replace the IF_THEN_ELSE
2856 with its then-operand or its else-operand. */
2857 if (result == 1)
2858 SET_SRC (body) = XEXP (SET_SRC (body), 1);
2859 if (result == -1)
2860 SET_SRC (body) = XEXP (SET_SRC (body), 2);
2862 /* The jump is now either unconditional or a no-op.
2863 If it has become a no-op, don't try to output it.
2864 (It would not be recognized.) */
2865 if (SET_SRC (body) == pc_rtx)
2867 delete_insn (insn);
2868 break;
2870 else if (ANY_RETURN_P (SET_SRC (body)))
2871 /* Replace (set (pc) (return)) with (return). */
2872 PATTERN (insn) = body = SET_SRC (body);
2874 /* Rerecognize the instruction if it has changed. */
2875 if (result != 0)
2876 INSN_CODE (insn) = -1;
2879 /* If this is a conditional trap, maybe modify it if the cc's
2880 are in a nonstandard state so that it accomplishes the same
2881 thing that it would do straightforwardly if the cc's were
2882 set up normally. */
2883 if (cc_status.flags != 0
2884 && NONJUMP_INSN_P (insn)
2885 && GET_CODE (body) == TRAP_IF
2886 && COMPARISON_P (TRAP_CONDITION (body))
2887 && XEXP (TRAP_CONDITION (body), 0) == cc0_rtx)
2889 /* This function may alter the contents of its argument
2890 and clear some of the cc_status.flags bits.
2891 It may also return 1 meaning condition now always true
2892 or -1 meaning condition now always false
2893 or 2 meaning condition nontrivial but altered. */
2894 int result = alter_cond (TRAP_CONDITION (body));
2896 /* If TRAP_CONDITION has become always false, delete the
2897 instruction. */
2898 if (result == -1)
2900 delete_insn (insn);
2901 break;
2904 /* If TRAP_CONDITION has become always true, replace
2905 TRAP_CONDITION with const_true_rtx. */
2906 if (result == 1)
2907 TRAP_CONDITION (body) = const_true_rtx;
2909 /* Rerecognize the instruction if it has changed. */
2910 if (result != 0)
2911 INSN_CODE (insn) = -1;
2914 /* Make same adjustments to instructions that examine the
2915 condition codes without jumping and instructions that
2916 handle conditional moves (if this machine has either one). */
2918 if (cc_status.flags != 0
2919 && set != 0)
2921 rtx cond_rtx, then_rtx, else_rtx;
2923 if (!JUMP_P (insn)
2924 && GET_CODE (SET_SRC (set)) == IF_THEN_ELSE)
2926 cond_rtx = XEXP (SET_SRC (set), 0);
2927 then_rtx = XEXP (SET_SRC (set), 1);
2928 else_rtx = XEXP (SET_SRC (set), 2);
2930 else
2932 cond_rtx = SET_SRC (set);
2933 then_rtx = const_true_rtx;
2934 else_rtx = const0_rtx;
2937 if (COMPARISON_P (cond_rtx)
2938 && XEXP (cond_rtx, 0) == cc0_rtx)
2940 int result;
2941 result = alter_cond (cond_rtx);
2942 if (result == 1)
2943 validate_change (insn, &SET_SRC (set), then_rtx, 0);
2944 else if (result == -1)
2945 validate_change (insn, &SET_SRC (set), else_rtx, 0);
2946 else if (result == 2)
2947 INSN_CODE (insn) = -1;
2948 if (SET_DEST (set) == SET_SRC (set))
2949 delete_insn (insn);
2953 #endif
2955 /* Do machine-specific peephole optimizations if desired. */
2957 if (HAVE_peephole && optimize_p && !flag_no_peephole && !nopeepholes)
2959 rtx_insn *next = peephole (insn);
2960 /* When peepholing, if there were notes within the peephole,
2961 emit them before the peephole. */
2962 if (next != 0 && next != NEXT_INSN (insn))
2964 rtx_insn *note, *prev = PREV_INSN (insn);
2966 for (note = NEXT_INSN (insn); note != next;
2967 note = NEXT_INSN (note))
2968 final_scan_insn (note, file, optimize_p, nopeepholes, seen);
2970 /* Put the notes in the proper position for a later
2971 rescan. For example, the SH target can do this
2972 when generating a far jump in a delayed branch
2973 sequence. */
2974 note = NEXT_INSN (insn);
2975 SET_PREV_INSN (note) = prev;
2976 SET_NEXT_INSN (prev) = note;
2977 SET_NEXT_INSN (PREV_INSN (next)) = insn;
2978 SET_PREV_INSN (insn) = PREV_INSN (next);
2979 SET_NEXT_INSN (insn) = next;
2980 SET_PREV_INSN (next) = insn;
2983 /* PEEPHOLE might have changed this. */
2984 body = PATTERN (insn);
2987 /* Try to recognize the instruction.
2988 If successful, verify that the operands satisfy the
2989 constraints for the instruction. Crash if they don't,
2990 since `reload' should have changed them so that they do. */
2992 insn_code_number = recog_memoized (insn);
2993 cleanup_subreg_operands (insn);
2995 /* Dump the insn in the assembly for debugging (-dAP).
2996 If the final dump is requested as slim RTL, dump slim
2997 RTL to the assembly file also. */
2998 if (flag_dump_rtl_in_asm)
3000 print_rtx_head = ASM_COMMENT_START;
3001 if (! (dump_flags & TDF_SLIM))
3002 print_rtl_single (asm_out_file, insn);
3003 else
3004 dump_insn_slim (asm_out_file, insn);
3005 print_rtx_head = "";
3008 if (! constrain_operands_cached (insn, 1))
3009 fatal_insn_not_found (insn);
3011 /* Some target machines need to prescan each insn before
3012 it is output. */
3014 #ifdef FINAL_PRESCAN_INSN
3015 FINAL_PRESCAN_INSN (insn, recog_data.operand, recog_data.n_operands);
3016 #endif
3018 if (targetm.have_conditional_execution ()
3019 && GET_CODE (PATTERN (insn)) == COND_EXEC)
3020 current_insn_predicate = COND_EXEC_TEST (PATTERN (insn));
3022 #if HAVE_cc0
3023 cc_prev_status = cc_status;
3025 /* Update `cc_status' for this instruction.
3026 The instruction's output routine may change it further.
3027 If the output routine for a jump insn needs to depend
3028 on the cc status, it should look at cc_prev_status. */
3030 NOTICE_UPDATE_CC (body, insn);
3031 #endif
3033 current_output_insn = debug_insn = insn;
3035 /* Find the proper template for this insn. */
3036 templ = get_insn_template (insn_code_number, insn);
3038 /* If the C code returns 0, it means that it is a jump insn
3039 which follows a deleted test insn, and that test insn
3040 needs to be reinserted. */
3041 if (templ == 0)
3043 rtx_insn *prev;
3045 gcc_assert (prev_nonnote_insn (insn) == last_ignored_compare);
3047 /* We have already processed the notes between the setter and
3048 the user. Make sure we don't process them again, this is
3049 particularly important if one of the notes is a block
3050 scope note or an EH note. */
3051 for (prev = insn;
3052 prev != last_ignored_compare;
3053 prev = PREV_INSN (prev))
3055 if (NOTE_P (prev))
3056 delete_insn (prev); /* Use delete_note. */
3059 return prev;
3062 /* If the template is the string "#", it means that this insn must
3063 be split. */
3064 if (templ[0] == '#' && templ[1] == '\0')
3066 rtx_insn *new_rtx = try_split (body, insn, 0);
3068 /* If we didn't split the insn, go away. */
3069 if (new_rtx == insn && PATTERN (new_rtx) == body)
3070 fatal_insn ("could not split insn", insn);
3072 /* If we have a length attribute, this instruction should have
3073 been split in shorten_branches, to ensure that we would have
3074 valid length info for the splitees. */
3075 gcc_assert (!HAVE_ATTR_length);
3077 return new_rtx;
3080 /* ??? This will put the directives in the wrong place if
3081 get_insn_template outputs assembly directly. However calling it
3082 before get_insn_template breaks if the insns is split. */
3083 if (targetm.asm_out.unwind_emit_before_insn
3084 && targetm.asm_out.unwind_emit)
3085 targetm.asm_out.unwind_emit (asm_out_file, insn);
3087 rtx_call_insn *call_insn = dyn_cast <rtx_call_insn *> (insn);
3088 if (call_insn != NULL)
3090 rtx x = call_from_call_insn (call_insn);
3091 x = XEXP (x, 0);
3092 if (x && MEM_P (x) && GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
3094 tree t;
3095 x = XEXP (x, 0);
3096 t = SYMBOL_REF_DECL (x);
3097 if (t)
3098 assemble_external (t);
3102 /* Output assembler code from the template. */
3103 output_asm_insn (templ, recog_data.operand);
3105 /* Some target machines need to postscan each insn after
3106 it is output. */
3107 if (targetm.asm_out.final_postscan_insn)
3108 targetm.asm_out.final_postscan_insn (file, insn, recog_data.operand,
3109 recog_data.n_operands);
3111 if (!targetm.asm_out.unwind_emit_before_insn
3112 && targetm.asm_out.unwind_emit)
3113 targetm.asm_out.unwind_emit (asm_out_file, insn);
3115 /* Let the debug info back-end know about this call. We do this only
3116 after the instruction has been emitted because labels that may be
3117 created to reference the call instruction must appear after it. */
3118 if ((debug_variable_location_views || call_insn != NULL)
3119 && !DECL_IGNORED_P (current_function_decl))
3120 debug_hooks->var_location (insn);
3122 current_output_insn = debug_insn = 0;
3125 return NEXT_INSN (insn);
3128 /* This is a wrapper around final_scan_insn_1 that allows ports to
3129 call it recursively without a known value for SEEN. The value is
3130 saved at the outermost call, and recovered for recursive calls.
3131 Recursive calls MUST pass NULL, or the same pointer if they can
3132 otherwise get to it. */
3134 rtx_insn *
3135 final_scan_insn (rtx_insn *insn, FILE *file, int optimize_p,
3136 int nopeepholes, int *seen)
3138 static int *enclosing_seen;
3139 static int recursion_counter;
3141 gcc_assert (seen || recursion_counter);
3142 gcc_assert (!recursion_counter || !seen || seen == enclosing_seen);
3144 if (!recursion_counter++)
3145 enclosing_seen = seen;
3146 else if (!seen)
3147 seen = enclosing_seen;
3149 rtx_insn *ret = final_scan_insn_1 (insn, file, optimize_p, nopeepholes, seen);
3151 if (!--recursion_counter)
3152 enclosing_seen = NULL;
3154 return ret;
3159 /* Map DECLs to instance discriminators. This is allocated and
3160 defined in ada/gcc-interfaces/trans.c, when compiling with -gnateS.
3161 Mappings from this table are saved and restored for LTO, so
3162 link-time compilation will have this map set, at least in
3163 partitions containing at least one DECL with an associated instance
3164 discriminator. */
3166 decl_to_instance_map_t *decl_to_instance_map;
3168 /* Return the instance number assigned to DECL. */
3170 static inline int
3171 map_decl_to_instance (const_tree decl)
3173 int *inst;
3175 if (!decl_to_instance_map || !decl || !DECL_P (decl))
3176 return 0;
3178 inst = decl_to_instance_map->get (decl);
3180 if (!inst)
3181 return 0;
3183 return *inst;
3186 /* Set DISCRIMINATOR to the appropriate value, possibly derived from LOC. */
3188 static inline void
3189 maybe_set_discriminator (location_t loc)
3191 if (!decl_to_instance_map)
3192 discriminator = bb_discriminator;
3193 else
3195 tree block = LOCATION_BLOCK (loc);
3197 while (block && TREE_CODE (block) == BLOCK
3198 && !inlined_function_outer_scope_p (block))
3199 block = BLOCK_SUPERCONTEXT (block);
3201 tree decl;
3203 if (!block)
3204 decl = current_function_decl;
3205 else if (DECL_P (block))
3206 decl = block;
3207 else
3208 decl = block_ultimate_origin (block);
3210 discriminator = map_decl_to_instance (decl);
3214 /* Return whether a source line note needs to be emitted before INSN.
3215 Sets IS_STMT to TRUE if the line should be marked as a possible
3216 breakpoint location. */
3218 static bool
3219 notice_source_line (rtx_insn *insn, bool *is_stmt)
3221 const char *filename;
3222 int linenum, columnnum;
3224 if (NOTE_MARKER_P (insn))
3226 location_t loc = NOTE_MARKER_LOCATION (insn);
3227 /* The inline entry markers (gimple, insn, note) carry the
3228 location of the call, because that's what we want to carry
3229 during compilation, but the location we want to output in
3230 debug information for the inline entry point is the location
3231 of the function itself. */
3232 if (NOTE_KIND (insn) == NOTE_INSN_INLINE_ENTRY)
3234 tree block = LOCATION_BLOCK (loc);
3235 tree fn = block_ultimate_origin (block);
3236 loc = DECL_SOURCE_LOCATION (fn);
3238 expanded_location xloc = expand_location (loc);
3239 if (xloc.line == 0)
3241 gcc_checking_assert (LOCATION_LOCUS (loc) == UNKNOWN_LOCATION
3242 || LOCATION_LOCUS (loc) == BUILTINS_LOCATION);
3243 return false;
3245 filename = xloc.file;
3246 linenum = xloc.line;
3247 columnnum = xloc.column;
3248 maybe_set_discriminator (loc);
3249 force_source_line = true;
3251 else if (override_filename)
3253 filename = override_filename;
3254 linenum = override_linenum;
3255 columnnum = override_columnnum;
3257 else if (INSN_HAS_LOCATION (insn))
3259 expanded_location xloc = insn_location (insn);
3260 filename = xloc.file;
3261 linenum = xloc.line;
3262 columnnum = xloc.column;
3263 maybe_set_discriminator (INSN_LOCATION (insn));
3265 else
3267 filename = NULL;
3268 linenum = 0;
3269 columnnum = 0;
3272 if (filename == NULL)
3273 return false;
3275 if (force_source_line
3276 || filename != last_filename
3277 || last_linenum != linenum
3278 || (debug_column_info && last_columnnum != columnnum))
3280 force_source_line = false;
3281 last_filename = filename;
3282 last_linenum = linenum;
3283 last_columnnum = columnnum;
3284 last_discriminator = discriminator;
3285 if (is_stmt)
3286 *is_stmt = true;
3287 high_block_linenum = MAX (last_linenum, high_block_linenum);
3288 high_function_linenum = MAX (last_linenum, high_function_linenum);
3289 return true;
3292 if (SUPPORTS_DISCRIMINATOR && last_discriminator != discriminator)
3294 /* If the discriminator changed, but the line number did not,
3295 output the line table entry with is_stmt false so the
3296 debugger does not treat this as a breakpoint location. */
3297 last_discriminator = discriminator;
3298 if (is_stmt)
3299 *is_stmt = false;
3300 return true;
3303 return false;
3306 /* For each operand in INSN, simplify (subreg (reg)) so that it refers
3307 directly to the desired hard register. */
3309 void
3310 cleanup_subreg_operands (rtx_insn *insn)
3312 int i;
3313 bool changed = false;
3314 extract_insn_cached (insn);
3315 for (i = 0; i < recog_data.n_operands; i++)
3317 /* The following test cannot use recog_data.operand when testing
3318 for a SUBREG: the underlying object might have been changed
3319 already if we are inside a match_operator expression that
3320 matches the else clause. Instead we test the underlying
3321 expression directly. */
3322 if (GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
3324 recog_data.operand[i] = alter_subreg (recog_data.operand_loc[i], true);
3325 changed = true;
3327 else if (GET_CODE (recog_data.operand[i]) == PLUS
3328 || GET_CODE (recog_data.operand[i]) == MULT
3329 || MEM_P (recog_data.operand[i]))
3330 recog_data.operand[i] = walk_alter_subreg (recog_data.operand_loc[i], &changed);
3333 for (i = 0; i < recog_data.n_dups; i++)
3335 if (GET_CODE (*recog_data.dup_loc[i]) == SUBREG)
3337 *recog_data.dup_loc[i] = alter_subreg (recog_data.dup_loc[i], true);
3338 changed = true;
3340 else if (GET_CODE (*recog_data.dup_loc[i]) == PLUS
3341 || GET_CODE (*recog_data.dup_loc[i]) == MULT
3342 || MEM_P (*recog_data.dup_loc[i]))
3343 *recog_data.dup_loc[i] = walk_alter_subreg (recog_data.dup_loc[i], &changed);
3345 if (changed)
3346 df_insn_rescan (insn);
3349 /* If X is a SUBREG, try to replace it with a REG or a MEM, based on
3350 the thing it is a subreg of. Do it anyway if FINAL_P. */
3353 alter_subreg (rtx *xp, bool final_p)
3355 rtx x = *xp;
3356 rtx y = SUBREG_REG (x);
3358 /* simplify_subreg does not remove subreg from volatile references.
3359 We are required to. */
3360 if (MEM_P (y))
3362 poly_int64 offset = SUBREG_BYTE (x);
3364 /* For paradoxical subregs on big-endian machines, SUBREG_BYTE
3365 contains 0 instead of the proper offset. See simplify_subreg. */
3366 if (paradoxical_subreg_p (x))
3367 offset = byte_lowpart_offset (GET_MODE (x), GET_MODE (y));
3369 if (final_p)
3370 *xp = adjust_address (y, GET_MODE (x), offset);
3371 else
3372 *xp = adjust_address_nv (y, GET_MODE (x), offset);
3374 else if (REG_P (y) && HARD_REGISTER_P (y))
3376 rtx new_rtx = simplify_subreg (GET_MODE (x), y, GET_MODE (y),
3377 SUBREG_BYTE (x));
3379 if (new_rtx != 0)
3380 *xp = new_rtx;
3381 else if (final_p && REG_P (y))
3383 /* Simplify_subreg can't handle some REG cases, but we have to. */
3384 unsigned int regno;
3385 poly_int64 offset;
3387 regno = subreg_regno (x);
3388 if (subreg_lowpart_p (x))
3389 offset = byte_lowpart_offset (GET_MODE (x), GET_MODE (y));
3390 else
3391 offset = SUBREG_BYTE (x);
3392 *xp = gen_rtx_REG_offset (y, GET_MODE (x), regno, offset);
3396 return *xp;
3399 /* Do alter_subreg on all the SUBREGs contained in X. */
3401 static rtx
3402 walk_alter_subreg (rtx *xp, bool *changed)
3404 rtx x = *xp;
3405 switch (GET_CODE (x))
3407 case PLUS:
3408 case MULT:
3409 case AND:
3410 XEXP (x, 0) = walk_alter_subreg (&XEXP (x, 0), changed);
3411 XEXP (x, 1) = walk_alter_subreg (&XEXP (x, 1), changed);
3412 break;
3414 case MEM:
3415 case ZERO_EXTEND:
3416 XEXP (x, 0) = walk_alter_subreg (&XEXP (x, 0), changed);
3417 break;
3419 case SUBREG:
3420 *changed = true;
3421 return alter_subreg (xp, true);
3423 default:
3424 break;
3427 return *xp;
3430 #if HAVE_cc0
3432 /* Given BODY, the body of a jump instruction, alter the jump condition
3433 as required by the bits that are set in cc_status.flags.
3434 Not all of the bits there can be handled at this level in all cases.
3436 The value is normally 0.
3437 1 means that the condition has become always true.
3438 -1 means that the condition has become always false.
3439 2 means that COND has been altered. */
3441 static int
3442 alter_cond (rtx cond)
3444 int value = 0;
3446 if (cc_status.flags & CC_REVERSED)
3448 value = 2;
3449 PUT_CODE (cond, swap_condition (GET_CODE (cond)));
3452 if (cc_status.flags & CC_INVERTED)
3454 value = 2;
3455 PUT_CODE (cond, reverse_condition (GET_CODE (cond)));
3458 if (cc_status.flags & CC_NOT_POSITIVE)
3459 switch (GET_CODE (cond))
3461 case LE:
3462 case LEU:
3463 case GEU:
3464 /* Jump becomes unconditional. */
3465 return 1;
3467 case GT:
3468 case GTU:
3469 case LTU:
3470 /* Jump becomes no-op. */
3471 return -1;
3473 case GE:
3474 PUT_CODE (cond, EQ);
3475 value = 2;
3476 break;
3478 case LT:
3479 PUT_CODE (cond, NE);
3480 value = 2;
3481 break;
3483 default:
3484 break;
3487 if (cc_status.flags & CC_NOT_NEGATIVE)
3488 switch (GET_CODE (cond))
3490 case GE:
3491 case GEU:
3492 /* Jump becomes unconditional. */
3493 return 1;
3495 case LT:
3496 case LTU:
3497 /* Jump becomes no-op. */
3498 return -1;
3500 case LE:
3501 case LEU:
3502 PUT_CODE (cond, EQ);
3503 value = 2;
3504 break;
3506 case GT:
3507 case GTU:
3508 PUT_CODE (cond, NE);
3509 value = 2;
3510 break;
3512 default:
3513 break;
3516 if (cc_status.flags & CC_NO_OVERFLOW)
3517 switch (GET_CODE (cond))
3519 case GEU:
3520 /* Jump becomes unconditional. */
3521 return 1;
3523 case LEU:
3524 PUT_CODE (cond, EQ);
3525 value = 2;
3526 break;
3528 case GTU:
3529 PUT_CODE (cond, NE);
3530 value = 2;
3531 break;
3533 case LTU:
3534 /* Jump becomes no-op. */
3535 return -1;
3537 default:
3538 break;
3541 if (cc_status.flags & (CC_Z_IN_NOT_N | CC_Z_IN_N))
3542 switch (GET_CODE (cond))
3544 default:
3545 gcc_unreachable ();
3547 case NE:
3548 PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? GE : LT);
3549 value = 2;
3550 break;
3552 case EQ:
3553 PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? LT : GE);
3554 value = 2;
3555 break;
3558 if (cc_status.flags & CC_NOT_SIGNED)
3559 /* The flags are valid if signed condition operators are converted
3560 to unsigned. */
3561 switch (GET_CODE (cond))
3563 case LE:
3564 PUT_CODE (cond, LEU);
3565 value = 2;
3566 break;
3568 case LT:
3569 PUT_CODE (cond, LTU);
3570 value = 2;
3571 break;
3573 case GT:
3574 PUT_CODE (cond, GTU);
3575 value = 2;
3576 break;
3578 case GE:
3579 PUT_CODE (cond, GEU);
3580 value = 2;
3581 break;
3583 default:
3584 break;
3587 return value;
3589 #endif
3591 /* Report inconsistency between the assembler template and the operands.
3592 In an `asm', it's the user's fault; otherwise, the compiler's fault. */
3594 void
3595 output_operand_lossage (const char *cmsgid, ...)
3597 char *fmt_string;
3598 char *new_message;
3599 const char *pfx_str;
3600 va_list ap;
3602 va_start (ap, cmsgid);
3604 pfx_str = this_is_asm_operands ? _("invalid 'asm': ") : "output_operand: ";
3605 fmt_string = xasprintf ("%s%s", pfx_str, _(cmsgid));
3606 new_message = xvasprintf (fmt_string, ap);
3608 if (this_is_asm_operands)
3609 error_for_asm (this_is_asm_operands, "%s", new_message);
3610 else
3611 internal_error ("%s", new_message);
3613 free (fmt_string);
3614 free (new_message);
3615 va_end (ap);
3618 /* Output of assembler code from a template, and its subroutines. */
3620 /* Annotate the assembly with a comment describing the pattern and
3621 alternative used. */
3623 static void
3624 output_asm_name (void)
3626 if (debug_insn)
3628 fprintf (asm_out_file, "\t%s %d\t",
3629 ASM_COMMENT_START, INSN_UID (debug_insn));
3631 fprintf (asm_out_file, "[c=%d",
3632 insn_cost (debug_insn, optimize_insn_for_speed_p ()));
3633 if (HAVE_ATTR_length)
3634 fprintf (asm_out_file, " l=%d",
3635 get_attr_length (debug_insn));
3636 fprintf (asm_out_file, "] ");
3638 int num = INSN_CODE (debug_insn);
3639 fprintf (asm_out_file, "%s", insn_data[num].name);
3640 if (insn_data[num].n_alternatives > 1)
3641 fprintf (asm_out_file, "/%d", which_alternative);
3643 /* Clear this so only the first assembler insn
3644 of any rtl insn will get the special comment for -dp. */
3645 debug_insn = 0;
3649 /* If OP is a REG or MEM and we can find a MEM_EXPR corresponding to it
3650 or its address, return that expr . Set *PADDRESSP to 1 if the expr
3651 corresponds to the address of the object and 0 if to the object. */
3653 static tree
3654 get_mem_expr_from_op (rtx op, int *paddressp)
3656 tree expr;
3657 int inner_addressp;
3659 *paddressp = 0;
3661 if (REG_P (op))
3662 return REG_EXPR (op);
3663 else if (!MEM_P (op))
3664 return 0;
3666 if (MEM_EXPR (op) != 0)
3667 return MEM_EXPR (op);
3669 /* Otherwise we have an address, so indicate it and look at the address. */
3670 *paddressp = 1;
3671 op = XEXP (op, 0);
3673 /* First check if we have a decl for the address, then look at the right side
3674 if it is a PLUS. Otherwise, strip off arithmetic and keep looking.
3675 But don't allow the address to itself be indirect. */
3676 if ((expr = get_mem_expr_from_op (op, &inner_addressp)) && ! inner_addressp)
3677 return expr;
3678 else if (GET_CODE (op) == PLUS
3679 && (expr = get_mem_expr_from_op (XEXP (op, 1), &inner_addressp)))
3680 return expr;
3682 while (UNARY_P (op)
3683 || GET_RTX_CLASS (GET_CODE (op)) == RTX_BIN_ARITH)
3684 op = XEXP (op, 0);
3686 expr = get_mem_expr_from_op (op, &inner_addressp);
3687 return inner_addressp ? 0 : expr;
3690 /* Output operand names for assembler instructions. OPERANDS is the
3691 operand vector, OPORDER is the order to write the operands, and NOPS
3692 is the number of operands to write. */
3694 static void
3695 output_asm_operand_names (rtx *operands, int *oporder, int nops)
3697 int wrote = 0;
3698 int i;
3700 for (i = 0; i < nops; i++)
3702 int addressp;
3703 rtx op = operands[oporder[i]];
3704 tree expr = get_mem_expr_from_op (op, &addressp);
3706 fprintf (asm_out_file, "%c%s",
3707 wrote ? ',' : '\t', wrote ? "" : ASM_COMMENT_START);
3708 wrote = 1;
3709 if (expr)
3711 fprintf (asm_out_file, "%s",
3712 addressp ? "*" : "");
3713 print_mem_expr (asm_out_file, expr);
3714 wrote = 1;
3716 else if (REG_P (op) && ORIGINAL_REGNO (op)
3717 && ORIGINAL_REGNO (op) != REGNO (op))
3718 fprintf (asm_out_file, " tmp%i", ORIGINAL_REGNO (op));
3722 #ifdef ASSEMBLER_DIALECT
3723 /* Helper function to parse assembler dialects in the asm string.
3724 This is called from output_asm_insn and asm_fprintf. */
3725 static const char *
3726 do_assembler_dialects (const char *p, int *dialect)
3728 char c = *(p - 1);
3730 switch (c)
3732 case '{':
3734 int i;
3736 if (*dialect)
3737 output_operand_lossage ("nested assembly dialect alternatives");
3738 else
3739 *dialect = 1;
3741 /* If we want the first dialect, do nothing. Otherwise, skip
3742 DIALECT_NUMBER of strings ending with '|'. */
3743 for (i = 0; i < dialect_number; i++)
3745 while (*p && *p != '}')
3747 if (*p == '|')
3749 p++;
3750 break;
3753 /* Skip over any character after a percent sign. */
3754 if (*p == '%')
3755 p++;
3756 if (*p)
3757 p++;
3760 if (*p == '}')
3761 break;
3764 if (*p == '\0')
3765 output_operand_lossage ("unterminated assembly dialect alternative");
3767 break;
3769 case '|':
3770 if (*dialect)
3772 /* Skip to close brace. */
3775 if (*p == '\0')
3777 output_operand_lossage ("unterminated assembly dialect alternative");
3778 break;
3781 /* Skip over any character after a percent sign. */
3782 if (*p == '%' && p[1])
3784 p += 2;
3785 continue;
3788 if (*p++ == '}')
3789 break;
3791 while (1);
3793 *dialect = 0;
3795 else
3796 putc (c, asm_out_file);
3797 break;
3799 case '}':
3800 if (! *dialect)
3801 putc (c, asm_out_file);
3802 *dialect = 0;
3803 break;
3804 default:
3805 gcc_unreachable ();
3808 return p;
3810 #endif
3812 /* Output text from TEMPLATE to the assembler output file,
3813 obeying %-directions to substitute operands taken from
3814 the vector OPERANDS.
3816 %N (for N a digit) means print operand N in usual manner.
3817 %lN means require operand N to be a CODE_LABEL or LABEL_REF
3818 and print the label name with no punctuation.
3819 %cN means require operand N to be a constant
3820 and print the constant expression with no punctuation.
3821 %aN means expect operand N to be a memory address
3822 (not a memory reference!) and print a reference
3823 to that address.
3824 %nN means expect operand N to be a constant
3825 and print a constant expression for minus the value
3826 of the operand, with no other punctuation. */
3828 void
3829 output_asm_insn (const char *templ, rtx *operands)
3831 const char *p;
3832 int c;
3833 #ifdef ASSEMBLER_DIALECT
3834 int dialect = 0;
3835 #endif
3836 int oporder[MAX_RECOG_OPERANDS];
3837 char opoutput[MAX_RECOG_OPERANDS];
3838 int ops = 0;
3840 /* An insn may return a null string template
3841 in a case where no assembler code is needed. */
3842 if (*templ == 0)
3843 return;
3845 memset (opoutput, 0, sizeof opoutput);
3846 p = templ;
3847 putc ('\t', asm_out_file);
3849 #ifdef ASM_OUTPUT_OPCODE
3850 ASM_OUTPUT_OPCODE (asm_out_file, p);
3851 #endif
3853 while ((c = *p++))
3854 switch (c)
3856 case '\n':
3857 if (flag_verbose_asm)
3858 output_asm_operand_names (operands, oporder, ops);
3859 if (flag_print_asm_name)
3860 output_asm_name ();
3862 ops = 0;
3863 memset (opoutput, 0, sizeof opoutput);
3865 putc (c, asm_out_file);
3866 #ifdef ASM_OUTPUT_OPCODE
3867 while ((c = *p) == '\t')
3869 putc (c, asm_out_file);
3870 p++;
3872 ASM_OUTPUT_OPCODE (asm_out_file, p);
3873 #endif
3874 break;
3876 #ifdef ASSEMBLER_DIALECT
3877 case '{':
3878 case '}':
3879 case '|':
3880 p = do_assembler_dialects (p, &dialect);
3881 break;
3882 #endif
3884 case '%':
3885 /* %% outputs a single %. %{, %} and %| print {, } and | respectively
3886 if ASSEMBLER_DIALECT defined and these characters have a special
3887 meaning as dialect delimiters.*/
3888 if (*p == '%'
3889 #ifdef ASSEMBLER_DIALECT
3890 || *p == '{' || *p == '}' || *p == '|'
3891 #endif
3894 putc (*p, asm_out_file);
3895 p++;
3897 /* %= outputs a number which is unique to each insn in the entire
3898 compilation. This is useful for making local labels that are
3899 referred to more than once in a given insn. */
3900 else if (*p == '=')
3902 p++;
3903 fprintf (asm_out_file, "%d", insn_counter);
3905 /* % followed by a letter and some digits
3906 outputs an operand in a special way depending on the letter.
3907 Letters `acln' are implemented directly.
3908 Other letters are passed to `output_operand' so that
3909 the TARGET_PRINT_OPERAND hook can define them. */
3910 else if (ISALPHA (*p))
3912 int letter = *p++;
3913 unsigned long opnum;
3914 char *endptr;
3916 opnum = strtoul (p, &endptr, 10);
3918 if (endptr == p)
3919 output_operand_lossage ("operand number missing "
3920 "after %%-letter");
3921 else if (this_is_asm_operands && opnum >= insn_noperands)
3922 output_operand_lossage ("operand number out of range");
3923 else if (letter == 'l')
3924 output_asm_label (operands[opnum]);
3925 else if (letter == 'a')
3926 output_address (VOIDmode, operands[opnum]);
3927 else if (letter == 'c')
3929 if (CONSTANT_ADDRESS_P (operands[opnum]))
3930 output_addr_const (asm_out_file, operands[opnum]);
3931 else
3932 output_operand (operands[opnum], 'c');
3934 else if (letter == 'n')
3936 if (CONST_INT_P (operands[opnum]))
3937 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC,
3938 - INTVAL (operands[opnum]));
3939 else
3941 putc ('-', asm_out_file);
3942 output_addr_const (asm_out_file, operands[opnum]);
3945 else
3946 output_operand (operands[opnum], letter);
3948 if (!opoutput[opnum])
3949 oporder[ops++] = opnum;
3950 opoutput[opnum] = 1;
3952 p = endptr;
3953 c = *p;
3955 /* % followed by a digit outputs an operand the default way. */
3956 else if (ISDIGIT (*p))
3958 unsigned long opnum;
3959 char *endptr;
3961 opnum = strtoul (p, &endptr, 10);
3962 if (this_is_asm_operands && opnum >= insn_noperands)
3963 output_operand_lossage ("operand number out of range");
3964 else
3965 output_operand (operands[opnum], 0);
3967 if (!opoutput[opnum])
3968 oporder[ops++] = opnum;
3969 opoutput[opnum] = 1;
3971 p = endptr;
3972 c = *p;
3974 /* % followed by punctuation: output something for that
3975 punctuation character alone, with no operand. The
3976 TARGET_PRINT_OPERAND hook decides what is actually done. */
3977 else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned char) *p))
3978 output_operand (NULL_RTX, *p++);
3979 else
3980 output_operand_lossage ("invalid %%-code");
3981 break;
3983 default:
3984 putc (c, asm_out_file);
3987 /* Try to keep the asm a bit more readable. */
3988 if ((flag_verbose_asm || flag_print_asm_name) && strlen (templ) < 9)
3989 putc ('\t', asm_out_file);
3991 /* Write out the variable names for operands, if we know them. */
3992 if (flag_verbose_asm)
3993 output_asm_operand_names (operands, oporder, ops);
3994 if (flag_print_asm_name)
3995 output_asm_name ();
3997 putc ('\n', asm_out_file);
4000 /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */
4002 void
4003 output_asm_label (rtx x)
4005 char buf[256];
4007 if (GET_CODE (x) == LABEL_REF)
4008 x = label_ref_label (x);
4009 if (LABEL_P (x)
4010 || (NOTE_P (x)
4011 && NOTE_KIND (x) == NOTE_INSN_DELETED_LABEL))
4012 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
4013 else
4014 output_operand_lossage ("'%%l' operand isn't a label");
4016 assemble_name (asm_out_file, buf);
4019 /* Marks SYMBOL_REFs in x as referenced through use of assemble_external. */
4021 void
4022 mark_symbol_refs_as_used (rtx x)
4024 subrtx_iterator::array_type array;
4025 FOR_EACH_SUBRTX (iter, array, x, ALL)
4027 const_rtx x = *iter;
4028 if (GET_CODE (x) == SYMBOL_REF)
4029 if (tree t = SYMBOL_REF_DECL (x))
4030 assemble_external (t);
4034 /* Print operand X using machine-dependent assembler syntax.
4035 CODE is a non-digit that preceded the operand-number in the % spec,
4036 such as 'z' if the spec was `%z3'. CODE is 0 if there was no char
4037 between the % and the digits.
4038 When CODE is a non-letter, X is 0.
4040 The meanings of the letters are machine-dependent and controlled
4041 by TARGET_PRINT_OPERAND. */
4043 void
4044 output_operand (rtx x, int code ATTRIBUTE_UNUSED)
4046 if (x && GET_CODE (x) == SUBREG)
4047 x = alter_subreg (&x, true);
4049 /* X must not be a pseudo reg. */
4050 if (!targetm.no_register_allocation)
4051 gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
4053 targetm.asm_out.print_operand (asm_out_file, x, code);
4055 if (x == NULL_RTX)
4056 return;
4058 mark_symbol_refs_as_used (x);
4061 /* Print a memory reference operand for address X using
4062 machine-dependent assembler syntax. */
4064 void
4065 output_address (machine_mode mode, rtx x)
4067 bool changed = false;
4068 walk_alter_subreg (&x, &changed);
4069 targetm.asm_out.print_operand_address (asm_out_file, mode, x);
4072 /* Print an integer constant expression in assembler syntax.
4073 Addition and subtraction are the only arithmetic
4074 that may appear in these expressions. */
4076 void
4077 output_addr_const (FILE *file, rtx x)
4079 char buf[256];
4081 restart:
4082 switch (GET_CODE (x))
4084 case PC:
4085 putc ('.', file);
4086 break;
4088 case SYMBOL_REF:
4089 if (SYMBOL_REF_DECL (x))
4090 assemble_external (SYMBOL_REF_DECL (x));
4091 #ifdef ASM_OUTPUT_SYMBOL_REF
4092 ASM_OUTPUT_SYMBOL_REF (file, x);
4093 #else
4094 assemble_name (file, XSTR (x, 0));
4095 #endif
4096 break;
4098 case LABEL_REF:
4099 x = label_ref_label (x);
4100 /* Fall through. */
4101 case CODE_LABEL:
4102 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
4103 #ifdef ASM_OUTPUT_LABEL_REF
4104 ASM_OUTPUT_LABEL_REF (file, buf);
4105 #else
4106 assemble_name (file, buf);
4107 #endif
4108 break;
4110 case CONST_INT:
4111 fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
4112 break;
4114 case CONST:
4115 /* This used to output parentheses around the expression,
4116 but that does not work on the 386 (either ATT or BSD assembler). */
4117 output_addr_const (file, XEXP (x, 0));
4118 break;
4120 case CONST_WIDE_INT:
4121 /* We do not know the mode here so we have to use a round about
4122 way to build a wide-int to get it printed properly. */
4124 wide_int w = wide_int::from_array (&CONST_WIDE_INT_ELT (x, 0),
4125 CONST_WIDE_INT_NUNITS (x),
4126 CONST_WIDE_INT_NUNITS (x)
4127 * HOST_BITS_PER_WIDE_INT,
4128 false);
4129 print_decs (w, file);
4131 break;
4133 case CONST_DOUBLE:
4134 if (CONST_DOUBLE_AS_INT_P (x))
4136 /* We can use %d if the number is one word and positive. */
4137 if (CONST_DOUBLE_HIGH (x))
4138 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
4139 (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x),
4140 (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x));
4141 else if (CONST_DOUBLE_LOW (x) < 0)
4142 fprintf (file, HOST_WIDE_INT_PRINT_HEX,
4143 (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x));
4144 else
4145 fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
4147 else
4148 /* We can't handle floating point constants;
4149 PRINT_OPERAND must handle them. */
4150 output_operand_lossage ("floating constant misused");
4151 break;
4153 case CONST_FIXED:
4154 fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_FIXED_VALUE_LOW (x));
4155 break;
4157 case PLUS:
4158 /* Some assemblers need integer constants to appear last (eg masm). */
4159 if (CONST_INT_P (XEXP (x, 0)))
4161 output_addr_const (file, XEXP (x, 1));
4162 if (INTVAL (XEXP (x, 0)) >= 0)
4163 fprintf (file, "+");
4164 output_addr_const (file, XEXP (x, 0));
4166 else
4168 output_addr_const (file, XEXP (x, 0));
4169 if (!CONST_INT_P (XEXP (x, 1))
4170 || INTVAL (XEXP (x, 1)) >= 0)
4171 fprintf (file, "+");
4172 output_addr_const (file, XEXP (x, 1));
4174 break;
4176 case MINUS:
4177 /* Avoid outputting things like x-x or x+5-x,
4178 since some assemblers can't handle that. */
4179 x = simplify_subtraction (x);
4180 if (GET_CODE (x) != MINUS)
4181 goto restart;
4183 output_addr_const (file, XEXP (x, 0));
4184 fprintf (file, "-");
4185 if ((CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) >= 0)
4186 || GET_CODE (XEXP (x, 1)) == PC
4187 || GET_CODE (XEXP (x, 1)) == SYMBOL_REF)
4188 output_addr_const (file, XEXP (x, 1));
4189 else
4191 fputs (targetm.asm_out.open_paren, file);
4192 output_addr_const (file, XEXP (x, 1));
4193 fputs (targetm.asm_out.close_paren, file);
4195 break;
4197 case ZERO_EXTEND:
4198 case SIGN_EXTEND:
4199 case SUBREG:
4200 case TRUNCATE:
4201 output_addr_const (file, XEXP (x, 0));
4202 break;
4204 default:
4205 if (targetm.asm_out.output_addr_const_extra (file, x))
4206 break;
4208 output_operand_lossage ("invalid expression as operand");
4212 /* Output a quoted string. */
4214 void
4215 output_quoted_string (FILE *asm_file, const char *string)
4217 #ifdef OUTPUT_QUOTED_STRING
4218 OUTPUT_QUOTED_STRING (asm_file, string);
4219 #else
4220 char c;
4222 putc ('\"', asm_file);
4223 while ((c = *string++) != 0)
4225 if (ISPRINT (c))
4227 if (c == '\"' || c == '\\')
4228 putc ('\\', asm_file);
4229 putc (c, asm_file);
4231 else
4232 fprintf (asm_file, "\\%03o", (unsigned char) c);
4234 putc ('\"', asm_file);
4235 #endif
4238 /* Write a HOST_WIDE_INT number in hex form 0x1234, fast. */
4240 void
4241 fprint_whex (FILE *f, unsigned HOST_WIDE_INT value)
4243 char buf[2 + CHAR_BIT * sizeof (value) / 4];
4244 if (value == 0)
4245 putc ('0', f);
4246 else
4248 char *p = buf + sizeof (buf);
4250 *--p = "0123456789abcdef"[value % 16];
4251 while ((value /= 16) != 0);
4252 *--p = 'x';
4253 *--p = '0';
4254 fwrite (p, 1, buf + sizeof (buf) - p, f);
4258 /* Internal function that prints an unsigned long in decimal in reverse.
4259 The output string IS NOT null-terminated. */
4261 static int
4262 sprint_ul_rev (char *s, unsigned long value)
4264 int i = 0;
4267 s[i] = "0123456789"[value % 10];
4268 value /= 10;
4269 i++;
4270 /* alternate version, without modulo */
4271 /* oldval = value; */
4272 /* value /= 10; */
4273 /* s[i] = "0123456789" [oldval - 10*value]; */
4274 /* i++ */
4276 while (value != 0);
4277 return i;
4280 /* Write an unsigned long as decimal to a file, fast. */
4282 void
4283 fprint_ul (FILE *f, unsigned long value)
4285 /* python says: len(str(2**64)) == 20 */
4286 char s[20];
4287 int i;
4289 i = sprint_ul_rev (s, value);
4291 /* It's probably too small to bother with string reversal and fputs. */
4294 i--;
4295 putc (s[i], f);
4297 while (i != 0);
4300 /* Write an unsigned long as decimal to a string, fast.
4301 s must be wide enough to not overflow, at least 21 chars.
4302 Returns the length of the string (without terminating '\0'). */
4305 sprint_ul (char *s, unsigned long value)
4307 int len = sprint_ul_rev (s, value);
4308 s[len] = '\0';
4310 std::reverse (s, s + len);
4311 return len;
4314 /* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
4315 %R prints the value of REGISTER_PREFIX.
4316 %L prints the value of LOCAL_LABEL_PREFIX.
4317 %U prints the value of USER_LABEL_PREFIX.
4318 %I prints the value of IMMEDIATE_PREFIX.
4319 %O runs ASM_OUTPUT_OPCODE to transform what follows in the string.
4320 Also supported are %d, %i, %u, %x, %X, %o, %c, %s and %%.
4322 We handle alternate assembler dialects here, just like output_asm_insn. */
4324 void
4325 asm_fprintf (FILE *file, const char *p, ...)
4327 char buf[10];
4328 char *q, c;
4329 #ifdef ASSEMBLER_DIALECT
4330 int dialect = 0;
4331 #endif
4332 va_list argptr;
4334 va_start (argptr, p);
4336 buf[0] = '%';
4338 while ((c = *p++))
4339 switch (c)
4341 #ifdef ASSEMBLER_DIALECT
4342 case '{':
4343 case '}':
4344 case '|':
4345 p = do_assembler_dialects (p, &dialect);
4346 break;
4347 #endif
4349 case '%':
4350 c = *p++;
4351 q = &buf[1];
4352 while (strchr ("-+ #0", c))
4354 *q++ = c;
4355 c = *p++;
4357 while (ISDIGIT (c) || c == '.')
4359 *q++ = c;
4360 c = *p++;
4362 switch (c)
4364 case '%':
4365 putc ('%', file);
4366 break;
4368 case 'd': case 'i': case 'u':
4369 case 'x': case 'X': case 'o':
4370 case 'c':
4371 *q++ = c;
4372 *q = 0;
4373 fprintf (file, buf, va_arg (argptr, int));
4374 break;
4376 case 'w':
4377 /* This is a prefix to the 'd', 'i', 'u', 'x', 'X', and
4378 'o' cases, but we do not check for those cases. It
4379 means that the value is a HOST_WIDE_INT, which may be
4380 either `long' or `long long'. */
4381 memcpy (q, HOST_WIDE_INT_PRINT, strlen (HOST_WIDE_INT_PRINT));
4382 q += strlen (HOST_WIDE_INT_PRINT);
4383 *q++ = *p++;
4384 *q = 0;
4385 fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT));
4386 break;
4388 case 'l':
4389 *q++ = c;
4390 #ifdef HAVE_LONG_LONG
4391 if (*p == 'l')
4393 *q++ = *p++;
4394 *q++ = *p++;
4395 *q = 0;
4396 fprintf (file, buf, va_arg (argptr, long long));
4398 else
4399 #endif
4401 *q++ = *p++;
4402 *q = 0;
4403 fprintf (file, buf, va_arg (argptr, long));
4406 break;
4408 case 's':
4409 *q++ = c;
4410 *q = 0;
4411 fprintf (file, buf, va_arg (argptr, char *));
4412 break;
4414 case 'O':
4415 #ifdef ASM_OUTPUT_OPCODE
4416 ASM_OUTPUT_OPCODE (asm_out_file, p);
4417 #endif
4418 break;
4420 case 'R':
4421 #ifdef REGISTER_PREFIX
4422 fprintf (file, "%s", REGISTER_PREFIX);
4423 #endif
4424 break;
4426 case 'I':
4427 #ifdef IMMEDIATE_PREFIX
4428 fprintf (file, "%s", IMMEDIATE_PREFIX);
4429 #endif
4430 break;
4432 case 'L':
4433 #ifdef LOCAL_LABEL_PREFIX
4434 fprintf (file, "%s", LOCAL_LABEL_PREFIX);
4435 #endif
4436 break;
4438 case 'U':
4439 fputs (user_label_prefix, file);
4440 break;
4442 #ifdef ASM_FPRINTF_EXTENSIONS
4443 /* Uppercase letters are reserved for general use by asm_fprintf
4444 and so are not available to target specific code. In order to
4445 prevent the ASM_FPRINTF_EXTENSIONS macro from using them then,
4446 they are defined here. As they get turned into real extensions
4447 to asm_fprintf they should be removed from this list. */
4448 case 'A': case 'B': case 'C': case 'D': case 'E':
4449 case 'F': case 'G': case 'H': case 'J': case 'K':
4450 case 'M': case 'N': case 'P': case 'Q': case 'S':
4451 case 'T': case 'V': case 'W': case 'Y': case 'Z':
4452 break;
4454 ASM_FPRINTF_EXTENSIONS (file, argptr, p)
4455 #endif
4456 default:
4457 gcc_unreachable ();
4459 break;
4461 default:
4462 putc (c, file);
4464 va_end (argptr);
4467 /* Return nonzero if this function has no function calls. */
4470 leaf_function_p (void)
4472 rtx_insn *insn;
4474 /* Ensure we walk the entire function body. */
4475 gcc_assert (!in_sequence_p ());
4477 /* Some back-ends (e.g. s390) want leaf functions to stay leaf
4478 functions even if they call mcount. */
4479 if (crtl->profile && !targetm.keep_leaf_when_profiled ())
4480 return 0;
4482 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4484 if (CALL_P (insn)
4485 && ! SIBLING_CALL_P (insn))
4486 return 0;
4487 if (NONJUMP_INSN_P (insn)
4488 && GET_CODE (PATTERN (insn)) == SEQUENCE
4489 && CALL_P (XVECEXP (PATTERN (insn), 0, 0))
4490 && ! SIBLING_CALL_P (XVECEXP (PATTERN (insn), 0, 0)))
4491 return 0;
4494 return 1;
4497 /* Return 1 if branch is a forward branch.
4498 Uses insn_shuid array, so it works only in the final pass. May be used by
4499 output templates to customary add branch prediction hints.
4502 final_forward_branch_p (rtx_insn *insn)
4504 int insn_id, label_id;
4506 gcc_assert (uid_shuid);
4507 insn_id = INSN_SHUID (insn);
4508 label_id = INSN_SHUID (JUMP_LABEL (insn));
4509 /* We've hit some insns that does not have id information available. */
4510 gcc_assert (insn_id && label_id);
4511 return insn_id < label_id;
4514 /* On some machines, a function with no call insns
4515 can run faster if it doesn't create its own register window.
4516 When output, the leaf function should use only the "output"
4517 registers. Ordinarily, the function would be compiled to use
4518 the "input" registers to find its arguments; it is a candidate
4519 for leaf treatment if it uses only the "input" registers.
4520 Leaf function treatment means renumbering so the function
4521 uses the "output" registers instead. */
4523 #ifdef LEAF_REGISTERS
4525 /* Return 1 if this function uses only the registers that can be
4526 safely renumbered. */
4529 only_leaf_regs_used (void)
4531 int i;
4532 const char *const permitted_reg_in_leaf_functions = LEAF_REGISTERS;
4534 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4535 if ((df_regs_ever_live_p (i) || global_regs[i])
4536 && ! permitted_reg_in_leaf_functions[i])
4537 return 0;
4539 if (crtl->uses_pic_offset_table
4540 && pic_offset_table_rtx != 0
4541 && REG_P (pic_offset_table_rtx)
4542 && ! permitted_reg_in_leaf_functions[REGNO (pic_offset_table_rtx)])
4543 return 0;
4545 return 1;
4548 /* Scan all instructions and renumber all registers into those
4549 available in leaf functions. */
4551 static void
4552 leaf_renumber_regs (rtx_insn *first)
4554 rtx_insn *insn;
4556 /* Renumber only the actual patterns.
4557 The reg-notes can contain frame pointer refs,
4558 and renumbering them could crash, and should not be needed. */
4559 for (insn = first; insn; insn = NEXT_INSN (insn))
4560 if (INSN_P (insn))
4561 leaf_renumber_regs_insn (PATTERN (insn));
4564 /* Scan IN_RTX and its subexpressions, and renumber all regs into those
4565 available in leaf functions. */
4567 void
4568 leaf_renumber_regs_insn (rtx in_rtx)
4570 int i, j;
4571 const char *format_ptr;
4573 if (in_rtx == 0)
4574 return;
4576 /* Renumber all input-registers into output-registers.
4577 renumbered_regs would be 1 for an output-register;
4578 they */
4580 if (REG_P (in_rtx))
4582 int newreg;
4584 /* Don't renumber the same reg twice. */
4585 if (in_rtx->used)
4586 return;
4588 newreg = REGNO (in_rtx);
4589 /* Don't try to renumber pseudo regs. It is possible for a pseudo reg
4590 to reach here as part of a REG_NOTE. */
4591 if (newreg >= FIRST_PSEUDO_REGISTER)
4593 in_rtx->used = 1;
4594 return;
4596 newreg = LEAF_REG_REMAP (newreg);
4597 gcc_assert (newreg >= 0);
4598 df_set_regs_ever_live (REGNO (in_rtx), false);
4599 df_set_regs_ever_live (newreg, true);
4600 SET_REGNO (in_rtx, newreg);
4601 in_rtx->used = 1;
4602 return;
4605 if (INSN_P (in_rtx))
4607 /* Inside a SEQUENCE, we find insns.
4608 Renumber just the patterns of these insns,
4609 just as we do for the top-level insns. */
4610 leaf_renumber_regs_insn (PATTERN (in_rtx));
4611 return;
4614 format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
4616 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
4617 switch (*format_ptr++)
4619 case 'e':
4620 leaf_renumber_regs_insn (XEXP (in_rtx, i));
4621 break;
4623 case 'E':
4624 if (XVEC (in_rtx, i) != NULL)
4625 for (j = 0; j < XVECLEN (in_rtx, i); j++)
4626 leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));
4627 break;
4629 case 'S':
4630 case 's':
4631 case '0':
4632 case 'i':
4633 case 'w':
4634 case 'p':
4635 case 'n':
4636 case 'u':
4637 break;
4639 default:
4640 gcc_unreachable ();
4643 #endif
4645 /* Turn the RTL into assembly. */
4646 static unsigned int
4647 rest_of_handle_final (void)
4649 const char *fnname = get_fnname_from_decl (current_function_decl);
4651 /* Turn debug markers into notes if the var-tracking pass has not
4652 been invoked. */
4653 if (!flag_var_tracking && MAY_HAVE_DEBUG_MARKER_INSNS)
4654 delete_vta_debug_insns (false);
4656 assemble_start_function (current_function_decl, fnname);
4657 rtx_insn *first = get_insns ();
4658 int seen = 0;
4659 final_start_function_1 (&first, asm_out_file, &seen, optimize);
4660 final_1 (first, asm_out_file, seen, optimize);
4661 if (flag_ipa_ra
4662 && !lookup_attribute ("noipa", DECL_ATTRIBUTES (current_function_decl)))
4663 collect_fn_hard_reg_usage ();
4664 final_end_function ();
4666 /* The IA-64 ".handlerdata" directive must be issued before the ".endp"
4667 directive that closes the procedure descriptor. Similarly, for x64 SEH.
4668 Otherwise it's not strictly necessary, but it doesn't hurt either. */
4669 output_function_exception_table (crtl->has_bb_partition ? 1 : 0);
4671 assemble_end_function (current_function_decl, fnname);
4673 /* Free up reg info memory. */
4674 free_reg_info ();
4676 if (! quiet_flag)
4677 fflush (asm_out_file);
4679 /* Write DBX symbols if requested. */
4681 /* Note that for those inline functions where we don't initially
4682 know for certain that we will be generating an out-of-line copy,
4683 the first invocation of this routine (rest_of_compilation) will
4684 skip over this code by doing a `goto exit_rest_of_compilation;'.
4685 Later on, wrapup_global_declarations will (indirectly) call
4686 rest_of_compilation again for those inline functions that need
4687 to have out-of-line copies generated. During that call, we
4688 *will* be routed past here. */
4690 timevar_push (TV_SYMOUT);
4691 if (!DECL_IGNORED_P (current_function_decl))
4692 debug_hooks->function_decl (current_function_decl);
4693 timevar_pop (TV_SYMOUT);
4695 /* Release the blocks that are linked to DECL_INITIAL() to free the memory. */
4696 DECL_INITIAL (current_function_decl) = error_mark_node;
4698 if (DECL_STATIC_CONSTRUCTOR (current_function_decl)
4699 && targetm.have_ctors_dtors)
4700 targetm.asm_out.constructor (XEXP (DECL_RTL (current_function_decl), 0),
4701 decl_init_priority_lookup
4702 (current_function_decl));
4703 if (DECL_STATIC_DESTRUCTOR (current_function_decl)
4704 && targetm.have_ctors_dtors)
4705 targetm.asm_out.destructor (XEXP (DECL_RTL (current_function_decl), 0),
4706 decl_fini_priority_lookup
4707 (current_function_decl));
4708 return 0;
4711 namespace {
4713 const pass_data pass_data_final =
4715 RTL_PASS, /* type */
4716 "final", /* name */
4717 OPTGROUP_NONE, /* optinfo_flags */
4718 TV_FINAL, /* tv_id */
4719 0, /* properties_required */
4720 0, /* properties_provided */
4721 0, /* properties_destroyed */
4722 0, /* todo_flags_start */
4723 0, /* todo_flags_finish */
4726 class pass_final : public rtl_opt_pass
4728 public:
4729 pass_final (gcc::context *ctxt)
4730 : rtl_opt_pass (pass_data_final, ctxt)
4733 /* opt_pass methods: */
4734 virtual unsigned int execute (function *) { return rest_of_handle_final (); }
4736 }; // class pass_final
4738 } // anon namespace
4740 rtl_opt_pass *
4741 make_pass_final (gcc::context *ctxt)
4743 return new pass_final (ctxt);
4747 static unsigned int
4748 rest_of_handle_shorten_branches (void)
4750 /* Shorten branches. */
4751 shorten_branches (get_insns ());
4752 return 0;
4755 namespace {
4757 const pass_data pass_data_shorten_branches =
4759 RTL_PASS, /* type */
4760 "shorten", /* name */
4761 OPTGROUP_NONE, /* optinfo_flags */
4762 TV_SHORTEN_BRANCH, /* tv_id */
4763 0, /* properties_required */
4764 0, /* properties_provided */
4765 0, /* properties_destroyed */
4766 0, /* todo_flags_start */
4767 0, /* todo_flags_finish */
4770 class pass_shorten_branches : public rtl_opt_pass
4772 public:
4773 pass_shorten_branches (gcc::context *ctxt)
4774 : rtl_opt_pass (pass_data_shorten_branches, ctxt)
4777 /* opt_pass methods: */
4778 virtual unsigned int execute (function *)
4780 return rest_of_handle_shorten_branches ();
4783 }; // class pass_shorten_branches
4785 } // anon namespace
4787 rtl_opt_pass *
4788 make_pass_shorten_branches (gcc::context *ctxt)
4790 return new pass_shorten_branches (ctxt);
4794 static unsigned int
4795 rest_of_clean_state (void)
4797 rtx_insn *insn, *next;
4798 FILE *final_output = NULL;
4799 int save_unnumbered = flag_dump_unnumbered;
4800 int save_noaddr = flag_dump_noaddr;
4802 if (flag_dump_final_insns)
4804 final_output = fopen (flag_dump_final_insns, "a");
4805 if (!final_output)
4807 error ("could not open final insn dump file %qs: %m",
4808 flag_dump_final_insns);
4809 flag_dump_final_insns = NULL;
4811 else
4813 flag_dump_noaddr = flag_dump_unnumbered = 1;
4814 if (flag_compare_debug_opt || flag_compare_debug)
4815 dump_flags |= TDF_NOUID | TDF_COMPARE_DEBUG;
4816 dump_function_header (final_output, current_function_decl,
4817 dump_flags);
4818 final_insns_dump_p = true;
4820 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4821 if (LABEL_P (insn))
4822 INSN_UID (insn) = CODE_LABEL_NUMBER (insn);
4823 else
4825 if (NOTE_P (insn))
4826 set_block_for_insn (insn, NULL);
4827 INSN_UID (insn) = 0;
4832 /* It is very important to decompose the RTL instruction chain here:
4833 debug information keeps pointing into CODE_LABEL insns inside the function
4834 body. If these remain pointing to the other insns, we end up preserving
4835 whole RTL chain and attached detailed debug info in memory. */
4836 for (insn = get_insns (); insn; insn = next)
4838 next = NEXT_INSN (insn);
4839 SET_NEXT_INSN (insn) = NULL;
4840 SET_PREV_INSN (insn) = NULL;
4842 rtx_insn *call_insn = insn;
4843 if (NONJUMP_INSN_P (call_insn)
4844 && GET_CODE (PATTERN (call_insn)) == SEQUENCE)
4846 rtx_sequence *seq = as_a <rtx_sequence *> (PATTERN (call_insn));
4847 call_insn = seq->insn (0);
4849 if (CALL_P (call_insn))
4851 rtx note
4852 = find_reg_note (call_insn, REG_CALL_ARG_LOCATION, NULL_RTX);
4853 if (note)
4854 remove_note (call_insn, note);
4857 if (final_output
4858 && (!NOTE_P (insn)
4859 || (NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION
4860 && NOTE_KIND (insn) != NOTE_INSN_BEGIN_STMT
4861 && NOTE_KIND (insn) != NOTE_INSN_INLINE_ENTRY
4862 && NOTE_KIND (insn) != NOTE_INSN_BLOCK_BEG
4863 && NOTE_KIND (insn) != NOTE_INSN_BLOCK_END
4864 && NOTE_KIND (insn) != NOTE_INSN_DELETED_DEBUG_LABEL)))
4865 print_rtl_single (final_output, insn);
4868 if (final_output)
4870 flag_dump_noaddr = save_noaddr;
4871 flag_dump_unnumbered = save_unnumbered;
4872 final_insns_dump_p = false;
4874 if (fclose (final_output))
4876 error ("could not close final insn dump file %qs: %m",
4877 flag_dump_final_insns);
4878 flag_dump_final_insns = NULL;
4882 flag_rerun_cse_after_global_opts = 0;
4883 reload_completed = 0;
4884 epilogue_completed = 0;
4885 #ifdef STACK_REGS
4886 regstack_completed = 0;
4887 #endif
4889 /* Clear out the insn_length contents now that they are no
4890 longer valid. */
4891 init_insn_lengths ();
4893 /* Show no temporary slots allocated. */
4894 init_temp_slots ();
4896 free_bb_for_insn ();
4898 if (cfun->gimple_df)
4899 delete_tree_ssa (cfun);
4901 /* We can reduce stack alignment on call site only when we are sure that
4902 the function body just produced will be actually used in the final
4903 executable. */
4904 if (decl_binds_to_current_def_p (current_function_decl))
4906 unsigned int pref = crtl->preferred_stack_boundary;
4907 if (crtl->stack_alignment_needed > crtl->preferred_stack_boundary)
4908 pref = crtl->stack_alignment_needed;
4909 cgraph_node::rtl_info (current_function_decl)
4910 ->preferred_incoming_stack_boundary = pref;
4913 /* Make sure volatile mem refs aren't considered valid operands for
4914 arithmetic insns. We must call this here if this is a nested inline
4915 function, since the above code leaves us in the init_recog state,
4916 and the function context push/pop code does not save/restore volatile_ok.
4918 ??? Maybe it isn't necessary for expand_start_function to call this
4919 anymore if we do it here? */
4921 init_recog_no_volatile ();
4923 /* We're done with this function. Free up memory if we can. */
4924 free_after_parsing (cfun);
4925 free_after_compilation (cfun);
4926 return 0;
4929 namespace {
4931 const pass_data pass_data_clean_state =
4933 RTL_PASS, /* type */
4934 "*clean_state", /* name */
4935 OPTGROUP_NONE, /* optinfo_flags */
4936 TV_FINAL, /* tv_id */
4937 0, /* properties_required */
4938 0, /* properties_provided */
4939 PROP_rtl, /* properties_destroyed */
4940 0, /* todo_flags_start */
4941 0, /* todo_flags_finish */
4944 class pass_clean_state : public rtl_opt_pass
4946 public:
4947 pass_clean_state (gcc::context *ctxt)
4948 : rtl_opt_pass (pass_data_clean_state, ctxt)
4951 /* opt_pass methods: */
4952 virtual unsigned int execute (function *)
4954 return rest_of_clean_state ();
4957 }; // class pass_clean_state
4959 } // anon namespace
4961 rtl_opt_pass *
4962 make_pass_clean_state (gcc::context *ctxt)
4964 return new pass_clean_state (ctxt);
4967 /* Return true if INSN is a call to the current function. */
4969 static bool
4970 self_recursive_call_p (rtx_insn *insn)
4972 tree fndecl = get_call_fndecl (insn);
4973 return (fndecl == current_function_decl
4974 && decl_binds_to_current_def_p (fndecl));
4977 /* Collect hard register usage for the current function. */
4979 static void
4980 collect_fn_hard_reg_usage (void)
4982 rtx_insn *insn;
4983 #ifdef STACK_REGS
4984 int i;
4985 #endif
4986 struct cgraph_rtl_info *node;
4987 HARD_REG_SET function_used_regs;
4989 /* ??? To be removed when all the ports have been fixed. */
4990 if (!targetm.call_fusage_contains_non_callee_clobbers)
4991 return;
4993 CLEAR_HARD_REG_SET (function_used_regs);
4995 for (insn = get_insns (); insn != NULL_RTX; insn = next_insn (insn))
4997 HARD_REG_SET insn_used_regs;
4999 if (!NONDEBUG_INSN_P (insn))
5000 continue;
5002 if (CALL_P (insn)
5003 && !self_recursive_call_p (insn))
5005 if (!get_call_reg_set_usage (insn, &insn_used_regs,
5006 call_used_reg_set))
5007 return;
5009 IOR_HARD_REG_SET (function_used_regs, insn_used_regs);
5012 find_all_hard_reg_sets (insn, &insn_used_regs, false);
5013 IOR_HARD_REG_SET (function_used_regs, insn_used_regs);
5016 /* Be conservative - mark fixed and global registers as used. */
5017 IOR_HARD_REG_SET (function_used_regs, fixed_reg_set);
5019 #ifdef STACK_REGS
5020 /* Handle STACK_REGS conservatively, since the df-framework does not
5021 provide accurate information for them. */
5023 for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
5024 SET_HARD_REG_BIT (function_used_regs, i);
5025 #endif
5027 /* The information we have gathered is only interesting if it exposes a
5028 register from the call_used_regs that is not used in this function. */
5029 if (hard_reg_set_subset_p (call_used_reg_set, function_used_regs))
5030 return;
5032 node = cgraph_node::rtl_info (current_function_decl);
5033 gcc_assert (node != NULL);
5035 COPY_HARD_REG_SET (node->function_used_regs, function_used_regs);
5036 node->function_used_regs_valid = 1;
5039 /* Get the declaration of the function called by INSN. */
5041 static tree
5042 get_call_fndecl (rtx_insn *insn)
5044 rtx note, datum;
5046 note = find_reg_note (insn, REG_CALL_DECL, NULL_RTX);
5047 if (note == NULL_RTX)
5048 return NULL_TREE;
5050 datum = XEXP (note, 0);
5051 if (datum != NULL_RTX)
5052 return SYMBOL_REF_DECL (datum);
5054 return NULL_TREE;
5057 /* Return the cgraph_rtl_info of the function called by INSN. Returns NULL for
5058 call targets that can be overwritten. */
5060 static struct cgraph_rtl_info *
5061 get_call_cgraph_rtl_info (rtx_insn *insn)
5063 tree fndecl;
5065 if (insn == NULL_RTX)
5066 return NULL;
5068 fndecl = get_call_fndecl (insn);
5069 if (fndecl == NULL_TREE
5070 || !decl_binds_to_current_def_p (fndecl))
5071 return NULL;
5073 return cgraph_node::rtl_info (fndecl);
5076 /* Find hard registers used by function call instruction INSN, and return them
5077 in REG_SET. Return DEFAULT_SET in REG_SET if not found. */
5079 bool
5080 get_call_reg_set_usage (rtx_insn *insn, HARD_REG_SET *reg_set,
5081 HARD_REG_SET default_set)
5083 if (flag_ipa_ra)
5085 struct cgraph_rtl_info *node = get_call_cgraph_rtl_info (insn);
5086 if (node != NULL
5087 && node->function_used_regs_valid)
5089 COPY_HARD_REG_SET (*reg_set, node->function_used_regs);
5090 AND_HARD_REG_SET (*reg_set, default_set);
5091 return true;
5095 COPY_HARD_REG_SET (*reg_set, default_set);
5096 return false;