1 /* Convert RTL to assembler code and output it, for GNU compiler.
2 Copyright (C) 1987-2016 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
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
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. */
46 #define INCLUDE_ALGORITHM /* reverse */
48 #include "coretypes.h"
56 #include "insn-config.h"
61 #include "tree-pretty-print.h" /* for dump_function_header */
63 #include "insn-attr.h"
64 #include "conditions.h"
68 #include "rtl-error.h"
69 #include "toplev.h" /* exact_log2, floor_log2 */
74 #include "tree-pass.h"
80 #include "print-rtl.h"
82 #ifdef XCOFF_DEBUGGING_INFO
83 #include "xcoffout.h" /* Needed for external data declarations. */
86 #include "dwarf2out.h"
88 #ifdef DBX_DEBUGGING_INFO
94 /* Most ports that aren't using cc0 don't need to define CC_STATUS_INIT.
95 So define a null default for it to save conditionalization later. */
96 #ifndef CC_STATUS_INIT
97 #define CC_STATUS_INIT
100 /* Is the given character a logical line separator for the assembler? */
101 #ifndef IS_ASM_LOGICAL_LINE_SEPARATOR
102 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) ((C) == ';')
105 #ifndef JUMP_TABLES_IN_TEXT_SECTION
106 #define JUMP_TABLES_IN_TEXT_SECTION 0
109 /* Bitflags used by final_scan_insn. */
111 #define SEEN_EMITTED 2
113 /* Last insn processed by final_scan_insn. */
114 static rtx_insn *debug_insn;
115 rtx_insn *current_output_insn;
117 /* Line number of last NOTE. */
118 static int last_linenum;
120 /* Last discriminator written to assembly. */
121 static int last_discriminator;
123 /* Discriminator of current block. */
124 static int discriminator;
126 /* Highest line number in current block. */
127 static int high_block_linenum;
129 /* Likewise for function. */
130 static int high_function_linenum;
132 /* Filename of last NOTE. */
133 static const char *last_filename;
135 /* Override filename and line number. */
136 static const char *override_filename;
137 static int override_linenum;
139 /* Whether to force emission of a line note before the next insn. */
140 static bool force_source_line = false;
142 extern const int length_unit_log; /* This is defined in insn-attrtab.c. */
144 /* Nonzero while outputting an `asm' with operands.
145 This means that inconsistencies are the user's fault, so don't die.
146 The precise value is the insn being output, to pass to error_for_asm. */
147 const rtx_insn *this_is_asm_operands;
149 /* Number of operands of this insn, for an `asm' with operands. */
150 static unsigned int insn_noperands;
152 /* Compare optimization flag. */
154 static rtx last_ignored_compare = 0;
156 /* Assign a unique number to each insn that is output.
157 This can be used to generate unique local labels. */
159 static int insn_counter = 0;
161 /* This variable contains machine-dependent flags (defined in tm.h)
162 set and examined by output routines
163 that describe how to interpret the condition codes properly. */
167 /* During output of an insn, this contains a copy of cc_status
168 from before the insn. */
170 CC_STATUS cc_prev_status;
172 /* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen. */
174 static int block_depth;
176 /* Nonzero if have enabled APP processing of our assembler output. */
180 /* If we are outputting an insn sequence, this contains the sequence rtx.
183 rtx_sequence *final_sequence;
185 #ifdef ASSEMBLER_DIALECT
187 /* Number of the assembler dialect to use, starting at 0. */
188 static int dialect_number;
191 /* Nonnull if the insn currently being emitted was a COND_EXEC pattern. */
192 rtx current_insn_predicate;
194 /* True if printing into -fdump-final-insns= dump. */
195 bool final_insns_dump_p;
197 /* True if profile_function should be called, but hasn't been called yet. */
198 static bool need_profile_function;
200 static int asm_insn_count (rtx);
201 static void profile_function (FILE *);
202 static void profile_after_prologue (FILE *);
203 static bool notice_source_line (rtx_insn *, bool *);
204 static rtx walk_alter_subreg (rtx *, bool *);
205 static void output_asm_name (void);
206 static void output_alternate_entry_point (FILE *, rtx_insn *);
207 static tree get_mem_expr_from_op (rtx, int *);
208 static void output_asm_operand_names (rtx *, int *, int);
209 #ifdef LEAF_REGISTERS
210 static void leaf_renumber_regs (rtx_insn *);
213 static int alter_cond (rtx);
215 #ifndef ADDR_VEC_ALIGN
216 static int final_addr_vec_align (rtx);
218 static int align_fuzz (rtx, rtx, int, unsigned);
219 static void collect_fn_hard_reg_usage (void);
220 static tree get_call_fndecl (rtx_insn *);
222 /* Initialize data in final at the beginning of a compilation. */
225 init_final (const char *filename ATTRIBUTE_UNUSED)
230 #ifdef ASSEMBLER_DIALECT
231 dialect_number = ASSEMBLER_DIALECT;
235 /* Default target function prologue and epilogue assembler output.
237 If not overridden for epilogue code, then the function body itself
238 contains return instructions wherever needed. */
240 default_function_pro_epilogue (FILE *file ATTRIBUTE_UNUSED,
241 HOST_WIDE_INT size ATTRIBUTE_UNUSED)
246 default_function_switched_text_sections (FILE *file ATTRIBUTE_UNUSED,
247 tree decl ATTRIBUTE_UNUSED,
248 bool new_is_cold ATTRIBUTE_UNUSED)
252 /* Default target hook that outputs nothing to a stream. */
254 no_asm_to_stream (FILE *file ATTRIBUTE_UNUSED)
258 /* Enable APP processing of subsequent output.
259 Used before the output from an `asm' statement. */
266 fputs (ASM_APP_ON, asm_out_file);
271 /* Disable APP processing of subsequent output.
272 Called from varasm.c before most kinds of output. */
279 fputs (ASM_APP_OFF, asm_out_file);
284 /* Return the number of slots filled in the current
285 delayed branch sequence (we don't count the insn needing the
286 delay slot). Zero if not in a delayed branch sequence. */
289 dbr_sequence_length (void)
291 if (final_sequence != 0)
292 return XVECLEN (final_sequence, 0) - 1;
297 /* The next two pages contain routines used to compute the length of an insn
298 and to shorten branches. */
300 /* Arrays for insn lengths, and addresses. The latter is referenced by
301 `insn_current_length'. */
303 static int *insn_lengths;
305 vec<int> insn_addresses_;
307 /* Max uid for which the above arrays are valid. */
308 static int insn_lengths_max_uid;
310 /* Address of insn being processed. Used by `insn_current_length'. */
311 int insn_current_address;
313 /* Address of insn being processed in previous iteration. */
314 int insn_last_address;
316 /* known invariant alignment of insn being processed. */
317 int insn_current_align;
319 /* After shorten_branches, for any insn, uid_align[INSN_UID (insn)]
320 gives the next following alignment insn that increases the known
321 alignment, or NULL_RTX if there is no such insn.
322 For any alignment obtained this way, we can again index uid_align with
323 its uid to obtain the next following align that in turn increases the
324 alignment, till we reach NULL_RTX; the sequence obtained this way
325 for each insn we'll call the alignment chain of this insn in the following
328 struct label_alignment
334 static rtx *uid_align;
335 static int *uid_shuid;
336 static struct label_alignment *label_align;
338 /* Indicate that branch shortening hasn't yet been done. */
341 init_insn_lengths (void)
352 insn_lengths_max_uid = 0;
354 if (HAVE_ATTR_length)
355 INSN_ADDRESSES_FREE ();
363 /* Obtain the current length of an insn. If branch shortening has been done,
364 get its actual length. Otherwise, use FALLBACK_FN to calculate the
367 get_attr_length_1 (rtx_insn *insn, int (*fallback_fn) (rtx_insn *))
373 if (!HAVE_ATTR_length)
376 if (insn_lengths_max_uid > INSN_UID (insn))
377 return insn_lengths[INSN_UID (insn)];
379 switch (GET_CODE (insn))
389 length = fallback_fn (insn);
393 body = PATTERN (insn);
394 if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
397 else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
398 length = asm_insn_count (body) * fallback_fn (insn);
399 else if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (body))
400 for (i = 0; i < seq->len (); i++)
401 length += get_attr_length_1 (seq->insn (i), fallback_fn);
403 length = fallback_fn (insn);
410 #ifdef ADJUST_INSN_LENGTH
411 ADJUST_INSN_LENGTH (insn, length);
416 /* Obtain the current length of an insn. If branch shortening has been done,
417 get its actual length. Otherwise, get its maximum length. */
419 get_attr_length (rtx_insn *insn)
421 return get_attr_length_1 (insn, insn_default_length);
424 /* Obtain the current length of an insn. If branch shortening has been done,
425 get its actual length. Otherwise, get its minimum length. */
427 get_attr_min_length (rtx_insn *insn)
429 return get_attr_length_1 (insn, insn_min_length);
432 /* Code to handle alignment inside shorten_branches. */
434 /* Here is an explanation how the algorithm in align_fuzz can give
437 Call a sequence of instructions beginning with alignment point X
438 and continuing until the next alignment point `block X'. When `X'
439 is used in an expression, it means the alignment value of the
442 Call the distance between the start of the first insn of block X, and
443 the end of the last insn of block X `IX', for the `inner size of X'.
444 This is clearly the sum of the instruction lengths.
446 Likewise with the next alignment-delimited block following X, which we
449 Call the distance between the start of the first insn of block X, and
450 the start of the first insn of block Y `OX', for the `outer size of X'.
452 The estimated padding is then OX - IX.
454 OX can be safely estimated as
459 OX = round_up(IX, X) + Y - X
461 Clearly est(IX) >= real(IX), because that only depends on the
462 instruction lengths, and those being overestimated is a given.
464 Clearly round_up(foo, Z) >= round_up(bar, Z) if foo >= bar, so
465 we needn't worry about that when thinking about OX.
467 When X >= Y, the alignment provided by Y adds no uncertainty factor
468 for branch ranges starting before X, so we can just round what we have.
469 But when X < Y, we don't know anything about the, so to speak,
470 `middle bits', so we have to assume the worst when aligning up from an
471 address mod X to one mod Y, which is Y - X. */
474 #define LABEL_ALIGN(LABEL) align_labels_log
478 #define LOOP_ALIGN(LABEL) align_loops_log
481 #ifndef LABEL_ALIGN_AFTER_BARRIER
482 #define LABEL_ALIGN_AFTER_BARRIER(LABEL) 0
486 #define JUMP_ALIGN(LABEL) align_jumps_log
490 default_label_align_after_barrier_max_skip (rtx_insn *insn ATTRIBUTE_UNUSED)
496 default_loop_align_max_skip (rtx_insn *insn ATTRIBUTE_UNUSED)
498 return align_loops_max_skip;
502 default_label_align_max_skip (rtx_insn *insn ATTRIBUTE_UNUSED)
504 return align_labels_max_skip;
508 default_jump_align_max_skip (rtx_insn *insn ATTRIBUTE_UNUSED)
510 return align_jumps_max_skip;
513 #ifndef ADDR_VEC_ALIGN
515 final_addr_vec_align (rtx addr_vec)
517 int align = GET_MODE_SIZE (GET_MODE (PATTERN (addr_vec)));
519 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
520 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
521 return exact_log2 (align);
525 #define ADDR_VEC_ALIGN(ADDR_VEC) final_addr_vec_align (ADDR_VEC)
528 #ifndef INSN_LENGTH_ALIGNMENT
529 #define INSN_LENGTH_ALIGNMENT(INSN) length_unit_log
532 #define INSN_SHUID(INSN) (uid_shuid[INSN_UID (INSN)])
534 static int min_labelno, max_labelno;
536 #define LABEL_TO_ALIGNMENT(LABEL) \
537 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].alignment)
539 #define LABEL_TO_MAX_SKIP(LABEL) \
540 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].max_skip)
542 /* For the benefit of port specific code do this also as a function. */
545 label_to_alignment (rtx label)
547 if (CODE_LABEL_NUMBER (label) <= max_labelno)
548 return LABEL_TO_ALIGNMENT (label);
553 label_to_max_skip (rtx label)
555 if (CODE_LABEL_NUMBER (label) <= max_labelno)
556 return LABEL_TO_MAX_SKIP (label);
560 /* The differences in addresses
561 between a branch and its target might grow or shrink depending on
562 the alignment the start insn of the range (the branch for a forward
563 branch or the label for a backward branch) starts out on; if these
564 differences are used naively, they can even oscillate infinitely.
565 We therefore want to compute a 'worst case' address difference that
566 is independent of the alignment the start insn of the range end
567 up on, and that is at least as large as the actual difference.
568 The function align_fuzz calculates the amount we have to add to the
569 naively computed difference, by traversing the part of the alignment
570 chain of the start insn of the range that is in front of the end insn
571 of the range, and considering for each alignment the maximum amount
572 that it might contribute to a size increase.
574 For casesi tables, we also want to know worst case minimum amounts of
575 address difference, in case a machine description wants to introduce
576 some common offset that is added to all offsets in a table.
577 For this purpose, align_fuzz with a growth argument of 0 computes the
578 appropriate adjustment. */
580 /* Compute the maximum delta by which the difference of the addresses of
581 START and END might grow / shrink due to a different address for start
582 which changes the size of alignment insns between START and END.
583 KNOWN_ALIGN_LOG is the alignment known for START.
584 GROWTH should be ~0 if the objective is to compute potential code size
585 increase, and 0 if the objective is to compute potential shrink.
586 The return value is undefined for any other value of GROWTH. */
589 align_fuzz (rtx start, rtx end, int known_align_log, unsigned int growth)
591 int uid = INSN_UID (start);
593 int known_align = 1 << known_align_log;
594 int end_shuid = INSN_SHUID (end);
597 for (align_label = uid_align[uid]; align_label; align_label = uid_align[uid])
599 int align_addr, new_align;
601 uid = INSN_UID (align_label);
602 align_addr = INSN_ADDRESSES (uid) - insn_lengths[uid];
603 if (uid_shuid[uid] > end_shuid)
605 known_align_log = LABEL_TO_ALIGNMENT (align_label);
606 new_align = 1 << known_align_log;
607 if (new_align < known_align)
609 fuzz += (-align_addr ^ growth) & (new_align - known_align);
610 known_align = new_align;
615 /* Compute a worst-case reference address of a branch so that it
616 can be safely used in the presence of aligned labels. Since the
617 size of the branch itself is unknown, the size of the branch is
618 not included in the range. I.e. for a forward branch, the reference
619 address is the end address of the branch as known from the previous
620 branch shortening pass, minus a value to account for possible size
621 increase due to alignment. For a backward branch, it is the start
622 address of the branch as known from the current pass, plus a value
623 to account for possible size increase due to alignment.
624 NB.: Therefore, the maximum offset allowed for backward branches needs
625 to exclude the branch size. */
628 insn_current_reference_address (rtx_insn *branch)
633 if (! INSN_ADDRESSES_SET_P ())
636 rtx_insn *seq = NEXT_INSN (PREV_INSN (branch));
637 seq_uid = INSN_UID (seq);
638 if (!JUMP_P (branch))
639 /* This can happen for example on the PA; the objective is to know the
640 offset to address something in front of the start of the function.
641 Thus, we can treat it like a backward branch.
642 We assume here that FUNCTION_BOUNDARY / BITS_PER_UNIT is larger than
643 any alignment we'd encounter, so we skip the call to align_fuzz. */
644 return insn_current_address;
645 dest = JUMP_LABEL (branch);
647 /* BRANCH has no proper alignment chain set, so use SEQ.
648 BRANCH also has no INSN_SHUID. */
649 if (INSN_SHUID (seq) < INSN_SHUID (dest))
651 /* Forward branch. */
652 return (insn_last_address + insn_lengths[seq_uid]
653 - align_fuzz (seq, dest, length_unit_log, ~0));
657 /* Backward branch. */
658 return (insn_current_address
659 + align_fuzz (dest, seq, length_unit_log, ~0));
663 /* Compute branch alignments based on frequency information in the
667 compute_alignments (void)
669 int log, max_skip, max_log;
672 int freq_threshold = 0;
680 max_labelno = max_label_num ();
681 min_labelno = get_first_label_num ();
682 label_align = XCNEWVEC (struct label_alignment, max_labelno - min_labelno + 1);
684 /* If not optimizing or optimizing for size, don't assign any alignments. */
685 if (! optimize || optimize_function_for_size_p (cfun))
690 dump_reg_info (dump_file);
691 dump_flow_info (dump_file, TDF_DETAILS);
692 flow_loops_dump (dump_file, NULL, 1);
694 loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
695 FOR_EACH_BB_FN (bb, cfun)
696 if (bb->frequency > freq_max)
697 freq_max = bb->frequency;
698 freq_threshold = freq_max / PARAM_VALUE (PARAM_ALIGN_THRESHOLD);
701 fprintf (dump_file, "freq_max: %i\n",freq_max);
702 FOR_EACH_BB_FN (bb, cfun)
704 rtx_insn *label = BB_HEAD (bb);
705 int fallthru_frequency = 0, branch_frequency = 0, has_fallthru = 0;
710 || optimize_bb_for_size_p (bb))
714 "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n",
715 bb->index, bb->frequency, bb->loop_father->num,
719 max_log = LABEL_ALIGN (label);
720 max_skip = targetm.asm_out.label_align_max_skip (label);
722 FOR_EACH_EDGE (e, ei, bb->preds)
724 if (e->flags & EDGE_FALLTHRU)
725 has_fallthru = 1, fallthru_frequency += EDGE_FREQUENCY (e);
727 branch_frequency += EDGE_FREQUENCY (e);
731 fprintf (dump_file, "BB %4i freq %4i loop %2i loop_depth"
732 " %2i fall %4i branch %4i",
733 bb->index, bb->frequency, bb->loop_father->num,
735 fallthru_frequency, branch_frequency);
736 if (!bb->loop_father->inner && bb->loop_father->num)
737 fprintf (dump_file, " inner_loop");
738 if (bb->loop_father->header == bb)
739 fprintf (dump_file, " loop_header");
740 fprintf (dump_file, "\n");
743 /* There are two purposes to align block with no fallthru incoming edge:
744 1) to avoid fetch stalls when branch destination is near cache boundary
745 2) to improve cache efficiency in case the previous block is not executed
746 (so it does not need to be in the cache).
748 We to catch first case, we align frequently executed blocks.
749 To catch the second, we align blocks that are executed more frequently
750 than the predecessor and the predecessor is likely to not be executed
751 when function is called. */
754 && (branch_frequency > freq_threshold
755 || (bb->frequency > bb->prev_bb->frequency * 10
756 && (bb->prev_bb->frequency
757 <= ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency / 2))))
759 log = JUMP_ALIGN (label);
761 fprintf (dump_file, " jump alignment added.\n");
765 max_skip = targetm.asm_out.jump_align_max_skip (label);
768 /* In case block is frequent and reached mostly by non-fallthru edge,
769 align it. It is most likely a first block of loop. */
771 && !(single_succ_p (bb)
772 && single_succ (bb) == EXIT_BLOCK_PTR_FOR_FN (cfun))
773 && optimize_bb_for_speed_p (bb)
774 && branch_frequency + fallthru_frequency > freq_threshold
776 > fallthru_frequency * PARAM_VALUE (PARAM_ALIGN_LOOP_ITERATIONS)))
778 log = LOOP_ALIGN (label);
780 fprintf (dump_file, " internal loop alignment added.\n");
784 max_skip = targetm.asm_out.loop_align_max_skip (label);
787 LABEL_TO_ALIGNMENT (label) = max_log;
788 LABEL_TO_MAX_SKIP (label) = max_skip;
791 loop_optimizer_finalize ();
792 free_dominance_info (CDI_DOMINATORS);
796 /* Grow the LABEL_ALIGN array after new labels are created. */
799 grow_label_align (void)
801 int old = max_labelno;
805 max_labelno = max_label_num ();
807 n_labels = max_labelno - min_labelno + 1;
808 n_old_labels = old - min_labelno + 1;
810 label_align = XRESIZEVEC (struct label_alignment, label_align, n_labels);
812 /* Range of labels grows monotonically in the function. Failing here
813 means that the initialization of array got lost. */
814 gcc_assert (n_old_labels <= n_labels);
816 memset (label_align + n_old_labels, 0,
817 (n_labels - n_old_labels) * sizeof (struct label_alignment));
820 /* Update the already computed alignment information. LABEL_PAIRS is a vector
821 made up of pairs of labels for which the alignment information of the first
822 element will be copied from that of the second element. */
825 update_alignments (vec<rtx> &label_pairs)
828 rtx iter, label = NULL_RTX;
830 if (max_labelno != max_label_num ())
833 FOR_EACH_VEC_ELT (label_pairs, i, iter)
836 LABEL_TO_ALIGNMENT (label) = LABEL_TO_ALIGNMENT (iter);
837 LABEL_TO_MAX_SKIP (label) = LABEL_TO_MAX_SKIP (iter);
845 const pass_data pass_data_compute_alignments =
848 "alignments", /* name */
849 OPTGROUP_NONE, /* optinfo_flags */
851 0, /* properties_required */
852 0, /* properties_provided */
853 0, /* properties_destroyed */
854 0, /* todo_flags_start */
855 0, /* todo_flags_finish */
858 class pass_compute_alignments : public rtl_opt_pass
861 pass_compute_alignments (gcc::context *ctxt)
862 : rtl_opt_pass (pass_data_compute_alignments, ctxt)
865 /* opt_pass methods: */
866 virtual unsigned int execute (function *) { return compute_alignments (); }
868 }; // class pass_compute_alignments
873 make_pass_compute_alignments (gcc::context *ctxt)
875 return new pass_compute_alignments (ctxt);
879 /* Make a pass over all insns and compute their actual lengths by shortening
880 any branches of variable length if possible. */
882 /* shorten_branches might be called multiple times: for example, the SH
883 port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG.
884 In order to do this, it needs proper length information, which it obtains
885 by calling shorten_branches. This cannot be collapsed with
886 shorten_branches itself into a single pass unless we also want to integrate
887 reorg.c, since the branch splitting exposes new instructions with delay
891 shorten_branches (rtx_insn *first)
898 #define MAX_CODE_ALIGN 16
900 int something_changed = 1;
901 char *varying_length;
904 rtx align_tab[MAX_CODE_ALIGN];
906 /* Compute maximum UID and allocate label_align / uid_shuid. */
907 max_uid = get_max_uid ();
909 /* Free uid_shuid before reallocating it. */
912 uid_shuid = XNEWVEC (int, max_uid);
914 if (max_labelno != max_label_num ())
917 /* Initialize label_align and set up uid_shuid to be strictly
918 monotonically rising with insn order. */
919 /* We use max_log here to keep track of the maximum alignment we want to
920 impose on the next CODE_LABEL (or the current one if we are processing
921 the CODE_LABEL itself). */
926 for (insn = get_insns (), i = 1; insn; insn = NEXT_INSN (insn))
930 INSN_SHUID (insn) = i++;
937 bool next_is_jumptable;
939 /* Merge in alignments computed by compute_alignments. */
940 log = LABEL_TO_ALIGNMENT (insn);
944 max_skip = LABEL_TO_MAX_SKIP (insn);
947 next = next_nonnote_insn (insn);
948 next_is_jumptable = next && JUMP_TABLE_DATA_P (next);
949 if (!next_is_jumptable)
951 log = LABEL_ALIGN (insn);
955 max_skip = targetm.asm_out.label_align_max_skip (insn);
958 /* ADDR_VECs only take room if read-only data goes into the text
960 if ((JUMP_TABLES_IN_TEXT_SECTION
961 || readonly_data_section == text_section)
962 && next_is_jumptable)
964 log = ADDR_VEC_ALIGN (next);
968 max_skip = targetm.asm_out.label_align_max_skip (insn);
971 LABEL_TO_ALIGNMENT (insn) = max_log;
972 LABEL_TO_MAX_SKIP (insn) = max_skip;
976 else if (BARRIER_P (insn))
980 for (label = insn; label && ! INSN_P (label);
981 label = NEXT_INSN (label))
984 log = LABEL_ALIGN_AFTER_BARRIER (insn);
988 max_skip = targetm.asm_out.label_align_after_barrier_max_skip (label);
994 if (!HAVE_ATTR_length)
997 /* Allocate the rest of the arrays. */
998 insn_lengths = XNEWVEC (int, max_uid);
999 insn_lengths_max_uid = max_uid;
1000 /* Syntax errors can lead to labels being outside of the main insn stream.
1001 Initialize insn_addresses, so that we get reproducible results. */
1002 INSN_ADDRESSES_ALLOC (max_uid);
1004 varying_length = XCNEWVEC (char, max_uid);
1006 /* Initialize uid_align. We scan instructions
1007 from end to start, and keep in align_tab[n] the last seen insn
1008 that does an alignment of at least n+1, i.e. the successor
1009 in the alignment chain for an insn that does / has a known
1011 uid_align = XCNEWVEC (rtx, max_uid);
1013 for (i = MAX_CODE_ALIGN; --i >= 0;)
1014 align_tab[i] = NULL_RTX;
1015 seq = get_last_insn ();
1016 for (; seq; seq = PREV_INSN (seq))
1018 int uid = INSN_UID (seq);
1020 log = (LABEL_P (seq) ? LABEL_TO_ALIGNMENT (seq) : 0);
1021 uid_align[uid] = align_tab[0];
1024 /* Found an alignment label. */
1025 uid_align[uid] = align_tab[log];
1026 for (i = log - 1; i >= 0; i--)
1031 /* When optimizing, we start assuming minimum length, and keep increasing
1032 lengths as we find the need for this, till nothing changes.
1033 When not optimizing, we start assuming maximum lengths, and
1034 do a single pass to update the lengths. */
1035 bool increasing = optimize != 0;
1037 #ifdef CASE_VECTOR_SHORTEN_MODE
1040 /* Look for ADDR_DIFF_VECs, and initialize their minimum and maximum
1043 int min_shuid = INSN_SHUID (get_insns ()) - 1;
1044 int max_shuid = INSN_SHUID (get_last_insn ()) + 1;
1047 for (insn = first; insn != 0; insn = NEXT_INSN (insn))
1049 rtx min_lab = NULL_RTX, max_lab = NULL_RTX, pat;
1050 int len, i, min, max, insn_shuid;
1052 addr_diff_vec_flags flags;
1054 if (! JUMP_TABLE_DATA_P (insn)
1055 || GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
1057 pat = PATTERN (insn);
1058 len = XVECLEN (pat, 1);
1059 gcc_assert (len > 0);
1060 min_align = MAX_CODE_ALIGN;
1061 for (min = max_shuid, max = min_shuid, i = len - 1; i >= 0; i--)
1063 rtx lab = XEXP (XVECEXP (pat, 1, i), 0);
1064 int shuid = INSN_SHUID (lab);
1075 if (min_align > LABEL_TO_ALIGNMENT (lab))
1076 min_align = LABEL_TO_ALIGNMENT (lab);
1078 XEXP (pat, 2) = gen_rtx_LABEL_REF (Pmode, min_lab);
1079 XEXP (pat, 3) = gen_rtx_LABEL_REF (Pmode, max_lab);
1080 insn_shuid = INSN_SHUID (insn);
1081 rel = INSN_SHUID (XEXP (XEXP (pat, 0), 0));
1082 memset (&flags, 0, sizeof (flags));
1083 flags.min_align = min_align;
1084 flags.base_after_vec = rel > insn_shuid;
1085 flags.min_after_vec = min > insn_shuid;
1086 flags.max_after_vec = max > insn_shuid;
1087 flags.min_after_base = min > rel;
1088 flags.max_after_base = max > rel;
1089 ADDR_DIFF_VEC_FLAGS (pat) = flags;
1092 PUT_MODE (pat, CASE_VECTOR_SHORTEN_MODE (0, 0, pat));
1095 #endif /* CASE_VECTOR_SHORTEN_MODE */
1097 /* Compute initial lengths, addresses, and varying flags for each insn. */
1098 int (*length_fun) (rtx_insn *) = increasing ? insn_min_length : insn_default_length;
1100 for (insn_current_address = 0, insn = first;
1102 insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn))
1104 uid = INSN_UID (insn);
1106 insn_lengths[uid] = 0;
1110 int log = LABEL_TO_ALIGNMENT (insn);
1113 int align = 1 << log;
1114 int new_address = (insn_current_address + align - 1) & -align;
1115 insn_lengths[uid] = new_address - insn_current_address;
1119 INSN_ADDRESSES (uid) = insn_current_address + insn_lengths[uid];
1121 if (NOTE_P (insn) || BARRIER_P (insn)
1122 || LABEL_P (insn) || DEBUG_INSN_P (insn))
1124 if (insn->deleted ())
1127 body = PATTERN (insn);
1128 if (JUMP_TABLE_DATA_P (insn))
1130 /* This only takes room if read-only data goes into the text
1132 if (JUMP_TABLES_IN_TEXT_SECTION
1133 || readonly_data_section == text_section)
1134 insn_lengths[uid] = (XVECLEN (body,
1135 GET_CODE (body) == ADDR_DIFF_VEC)
1136 * GET_MODE_SIZE (GET_MODE (body)));
1137 /* Alignment is handled by ADDR_VEC_ALIGN. */
1139 else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
1140 insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
1141 else if (rtx_sequence *body_seq = dyn_cast <rtx_sequence *> (body))
1144 int const_delay_slots;
1146 const_delay_slots = const_num_delay_slots (body_seq->insn (0));
1148 const_delay_slots = 0;
1150 int (*inner_length_fun) (rtx_insn *)
1151 = const_delay_slots ? length_fun : insn_default_length;
1152 /* Inside a delay slot sequence, we do not do any branch shortening
1153 if the shortening could change the number of delay slots
1155 for (i = 0; i < body_seq->len (); i++)
1157 rtx_insn *inner_insn = body_seq->insn (i);
1158 int inner_uid = INSN_UID (inner_insn);
1161 if (GET_CODE (PATTERN (inner_insn)) == ASM_INPUT
1162 || asm_noperands (PATTERN (inner_insn)) >= 0)
1163 inner_length = (asm_insn_count (PATTERN (inner_insn))
1164 * insn_default_length (inner_insn));
1166 inner_length = inner_length_fun (inner_insn);
1168 insn_lengths[inner_uid] = inner_length;
1169 if (const_delay_slots)
1171 if ((varying_length[inner_uid]
1172 = insn_variable_length_p (inner_insn)) != 0)
1173 varying_length[uid] = 1;
1174 INSN_ADDRESSES (inner_uid) = (insn_current_address
1175 + insn_lengths[uid]);
1178 varying_length[inner_uid] = 0;
1179 insn_lengths[uid] += inner_length;
1182 else if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER)
1184 insn_lengths[uid] = length_fun (insn);
1185 varying_length[uid] = insn_variable_length_p (insn);
1188 /* If needed, do any adjustment. */
1189 #ifdef ADJUST_INSN_LENGTH
1190 ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
1191 if (insn_lengths[uid] < 0)
1192 fatal_insn ("negative insn length", insn);
1196 /* Now loop over all the insns finding varying length insns. For each,
1197 get the current insn length. If it has changed, reflect the change.
1198 When nothing changes for a full pass, we are done. */
1200 while (something_changed)
1202 something_changed = 0;
1203 insn_current_align = MAX_CODE_ALIGN - 1;
1204 for (insn_current_address = 0, insn = first;
1206 insn = NEXT_INSN (insn))
1209 #ifdef ADJUST_INSN_LENGTH
1214 uid = INSN_UID (insn);
1218 int log = LABEL_TO_ALIGNMENT (insn);
1220 #ifdef CASE_VECTOR_SHORTEN_MODE
1221 /* If the mode of a following jump table was changed, we
1222 may need to update the alignment of this label. */
1224 bool next_is_jumptable;
1226 next = next_nonnote_insn (insn);
1227 next_is_jumptable = next && JUMP_TABLE_DATA_P (next);
1228 if ((JUMP_TABLES_IN_TEXT_SECTION
1229 || readonly_data_section == text_section)
1230 && next_is_jumptable)
1232 int newlog = ADDR_VEC_ALIGN (next);
1236 LABEL_TO_ALIGNMENT (insn) = log;
1237 something_changed = 1;
1242 if (log > insn_current_align)
1244 int align = 1 << log;
1245 int new_address= (insn_current_address + align - 1) & -align;
1246 insn_lengths[uid] = new_address - insn_current_address;
1247 insn_current_align = log;
1248 insn_current_address = new_address;
1251 insn_lengths[uid] = 0;
1252 INSN_ADDRESSES (uid) = insn_current_address;
1256 length_align = INSN_LENGTH_ALIGNMENT (insn);
1257 if (length_align < insn_current_align)
1258 insn_current_align = length_align;
1260 insn_last_address = INSN_ADDRESSES (uid);
1261 INSN_ADDRESSES (uid) = insn_current_address;
1263 #ifdef CASE_VECTOR_SHORTEN_MODE
1265 && JUMP_TABLE_DATA_P (insn)
1266 && GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
1268 rtx body = PATTERN (insn);
1269 int old_length = insn_lengths[uid];
1271 safe_as_a <rtx_insn *> (XEXP (XEXP (body, 0), 0));
1272 rtx min_lab = XEXP (XEXP (body, 2), 0);
1273 rtx max_lab = XEXP (XEXP (body, 3), 0);
1274 int rel_addr = INSN_ADDRESSES (INSN_UID (rel_lab));
1275 int min_addr = INSN_ADDRESSES (INSN_UID (min_lab));
1276 int max_addr = INSN_ADDRESSES (INSN_UID (max_lab));
1279 addr_diff_vec_flags flags;
1280 machine_mode vec_mode;
1282 /* Avoid automatic aggregate initialization. */
1283 flags = ADDR_DIFF_VEC_FLAGS (body);
1285 /* Try to find a known alignment for rel_lab. */
1286 for (prev = rel_lab;
1288 && ! insn_lengths[INSN_UID (prev)]
1289 && ! (varying_length[INSN_UID (prev)] & 1);
1290 prev = PREV_INSN (prev))
1291 if (varying_length[INSN_UID (prev)] & 2)
1293 rel_align = LABEL_TO_ALIGNMENT (prev);
1297 /* See the comment on addr_diff_vec_flags in rtl.h for the
1298 meaning of the flags values. base: REL_LAB vec: INSN */
1299 /* Anything after INSN has still addresses from the last
1300 pass; adjust these so that they reflect our current
1301 estimate for this pass. */
1302 if (flags.base_after_vec)
1303 rel_addr += insn_current_address - insn_last_address;
1304 if (flags.min_after_vec)
1305 min_addr += insn_current_address - insn_last_address;
1306 if (flags.max_after_vec)
1307 max_addr += insn_current_address - insn_last_address;
1308 /* We want to know the worst case, i.e. lowest possible value
1309 for the offset of MIN_LAB. If MIN_LAB is after REL_LAB,
1310 its offset is positive, and we have to be wary of code shrink;
1311 otherwise, it is negative, and we have to be vary of code
1313 if (flags.min_after_base)
1315 /* If INSN is between REL_LAB and MIN_LAB, the size
1316 changes we are about to make can change the alignment
1317 within the observed offset, therefore we have to break
1318 it up into two parts that are independent. */
1319 if (! flags.base_after_vec && flags.min_after_vec)
1321 min_addr -= align_fuzz (rel_lab, insn, rel_align, 0);
1322 min_addr -= align_fuzz (insn, min_lab, 0, 0);
1325 min_addr -= align_fuzz (rel_lab, min_lab, rel_align, 0);
1329 if (flags.base_after_vec && ! flags.min_after_vec)
1331 min_addr -= align_fuzz (min_lab, insn, 0, ~0);
1332 min_addr -= align_fuzz (insn, rel_lab, 0, ~0);
1335 min_addr -= align_fuzz (min_lab, rel_lab, 0, ~0);
1337 /* Likewise, determine the highest lowest possible value
1338 for the offset of MAX_LAB. */
1339 if (flags.max_after_base)
1341 if (! flags.base_after_vec && flags.max_after_vec)
1343 max_addr += align_fuzz (rel_lab, insn, rel_align, ~0);
1344 max_addr += align_fuzz (insn, max_lab, 0, ~0);
1347 max_addr += align_fuzz (rel_lab, max_lab, rel_align, ~0);
1351 if (flags.base_after_vec && ! flags.max_after_vec)
1353 max_addr += align_fuzz (max_lab, insn, 0, 0);
1354 max_addr += align_fuzz (insn, rel_lab, 0, 0);
1357 max_addr += align_fuzz (max_lab, rel_lab, 0, 0);
1359 vec_mode = CASE_VECTOR_SHORTEN_MODE (min_addr - rel_addr,
1360 max_addr - rel_addr, body);
1362 || (GET_MODE_SIZE (vec_mode)
1363 >= GET_MODE_SIZE (GET_MODE (body))))
1364 PUT_MODE (body, vec_mode);
1365 if (JUMP_TABLES_IN_TEXT_SECTION
1366 || readonly_data_section == text_section)
1369 = (XVECLEN (body, 1) * GET_MODE_SIZE (GET_MODE (body)));
1370 insn_current_address += insn_lengths[uid];
1371 if (insn_lengths[uid] != old_length)
1372 something_changed = 1;
1377 #endif /* CASE_VECTOR_SHORTEN_MODE */
1379 if (! (varying_length[uid]))
1381 if (NONJUMP_INSN_P (insn)
1382 && GET_CODE (PATTERN (insn)) == SEQUENCE)
1386 body = PATTERN (insn);
1387 for (i = 0; i < XVECLEN (body, 0); i++)
1389 rtx inner_insn = XVECEXP (body, 0, i);
1390 int inner_uid = INSN_UID (inner_insn);
1392 INSN_ADDRESSES (inner_uid) = insn_current_address;
1394 insn_current_address += insn_lengths[inner_uid];
1398 insn_current_address += insn_lengths[uid];
1403 if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE)
1405 rtx_sequence *seqn = as_a <rtx_sequence *> (PATTERN (insn));
1408 body = PATTERN (insn);
1410 for (i = 0; i < seqn->len (); i++)
1412 rtx_insn *inner_insn = seqn->insn (i);
1413 int inner_uid = INSN_UID (inner_insn);
1416 INSN_ADDRESSES (inner_uid) = insn_current_address;
1418 /* insn_current_length returns 0 for insns with a
1419 non-varying length. */
1420 if (! varying_length[inner_uid])
1421 inner_length = insn_lengths[inner_uid];
1423 inner_length = insn_current_length (inner_insn);
1425 if (inner_length != insn_lengths[inner_uid])
1427 if (!increasing || inner_length > insn_lengths[inner_uid])
1429 insn_lengths[inner_uid] = inner_length;
1430 something_changed = 1;
1433 inner_length = insn_lengths[inner_uid];
1435 insn_current_address += inner_length;
1436 new_length += inner_length;
1441 new_length = insn_current_length (insn);
1442 insn_current_address += new_length;
1445 #ifdef ADJUST_INSN_LENGTH
1446 /* If needed, do any adjustment. */
1447 tmp_length = new_length;
1448 ADJUST_INSN_LENGTH (insn, new_length);
1449 insn_current_address += (new_length - tmp_length);
1452 if (new_length != insn_lengths[uid]
1453 && (!increasing || new_length > insn_lengths[uid]))
1455 insn_lengths[uid] = new_length;
1456 something_changed = 1;
1459 insn_current_address += insn_lengths[uid] - new_length;
1461 /* For a non-optimizing compile, do only a single pass. */
1466 free (varying_length);
1469 /* Given the body of an INSN known to be generated by an ASM statement, return
1470 the number of machine instructions likely to be generated for this insn.
1471 This is used to compute its length. */
1474 asm_insn_count (rtx body)
1478 if (GET_CODE (body) == ASM_INPUT)
1479 templ = XSTR (body, 0);
1481 templ = decode_asm_operands (body, NULL, NULL, NULL, NULL, NULL);
1483 return asm_str_count (templ);
1486 /* Return the number of machine instructions likely to be generated for the
1487 inline-asm template. */
1489 asm_str_count (const char *templ)
1496 for (; *templ; templ++)
1497 if (IS_ASM_LOGICAL_LINE_SEPARATOR (*templ, templ)
1504 /* ??? This is probably the wrong place for these. */
1505 /* Structure recording the mapping from source file and directory
1506 names at compile time to those to be embedded in debug
1508 struct debug_prefix_map
1510 const char *old_prefix;
1511 const char *new_prefix;
1514 struct debug_prefix_map *next;
1517 /* Linked list of such structures. */
1518 static debug_prefix_map *debug_prefix_maps;
1521 /* Record a debug file prefix mapping. ARG is the argument to
1522 -fdebug-prefix-map and must be of the form OLD=NEW. */
1525 add_debug_prefix_map (const char *arg)
1527 debug_prefix_map *map;
1530 p = strchr (arg, '=');
1533 error ("invalid argument %qs to -fdebug-prefix-map", arg);
1536 map = XNEW (debug_prefix_map);
1537 map->old_prefix = xstrndup (arg, p - arg);
1538 map->old_len = p - arg;
1540 map->new_prefix = xstrdup (p);
1541 map->new_len = strlen (p);
1542 map->next = debug_prefix_maps;
1543 debug_prefix_maps = map;
1546 /* Perform user-specified mapping of debug filename prefixes. Return
1547 the new name corresponding to FILENAME. */
1550 remap_debug_filename (const char *filename)
1552 debug_prefix_map *map;
1557 for (map = debug_prefix_maps; map; map = map->next)
1558 if (filename_ncmp (filename, map->old_prefix, map->old_len) == 0)
1562 name = filename + map->old_len;
1563 name_len = strlen (name) + 1;
1564 s = (char *) alloca (name_len + map->new_len);
1565 memcpy (s, map->new_prefix, map->new_len);
1566 memcpy (s + map->new_len, name, name_len);
1567 return ggc_strdup (s);
1570 /* Return true if DWARF2 debug info can be emitted for DECL. */
1573 dwarf2_debug_info_emitted_p (tree decl)
1575 if (write_symbols != DWARF2_DEBUG && write_symbols != VMS_AND_DWARF2_DEBUG)
1578 if (DECL_IGNORED_P (decl))
1584 /* Return scope resulting from combination of S1 and S2. */
1586 choose_inner_scope (tree s1, tree s2)
1592 if (BLOCK_NUMBER (s1) > BLOCK_NUMBER (s2))
1597 /* Emit lexical block notes needed to change scope from S1 to S2. */
1600 change_scope (rtx_insn *orig_insn, tree s1, tree s2)
1602 rtx_insn *insn = orig_insn;
1603 tree com = NULL_TREE;
1604 tree ts1 = s1, ts2 = s2;
1609 gcc_assert (ts1 && ts2);
1610 if (BLOCK_NUMBER (ts1) > BLOCK_NUMBER (ts2))
1611 ts1 = BLOCK_SUPERCONTEXT (ts1);
1612 else if (BLOCK_NUMBER (ts1) < BLOCK_NUMBER (ts2))
1613 ts2 = BLOCK_SUPERCONTEXT (ts2);
1616 ts1 = BLOCK_SUPERCONTEXT (ts1);
1617 ts2 = BLOCK_SUPERCONTEXT (ts2);
1626 rtx_note *note = emit_note_before (NOTE_INSN_BLOCK_END, insn);
1627 NOTE_BLOCK (note) = s;
1628 s = BLOCK_SUPERCONTEXT (s);
1635 insn = emit_note_before (NOTE_INSN_BLOCK_BEG, insn);
1636 NOTE_BLOCK (insn) = s;
1637 s = BLOCK_SUPERCONTEXT (s);
1641 /* Rebuild all the NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes based
1642 on the scope tree and the newly reordered instructions. */
1645 reemit_insn_block_notes (void)
1647 tree cur_block = DECL_INITIAL (cfun->decl);
1651 insn = get_insns ();
1652 for (; insn; insn = NEXT_INSN (insn))
1656 /* Prevent lexical blocks from straddling section boundaries. */
1657 if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
1659 for (tree s = cur_block; s != DECL_INITIAL (cfun->decl);
1660 s = BLOCK_SUPERCONTEXT (s))
1662 rtx_note *note = emit_note_before (NOTE_INSN_BLOCK_END, insn);
1663 NOTE_BLOCK (note) = s;
1664 note = emit_note_after (NOTE_INSN_BLOCK_BEG, insn);
1665 NOTE_BLOCK (note) = s;
1669 if (!active_insn_p (insn))
1672 /* Avoid putting scope notes between jump table and its label. */
1673 if (JUMP_TABLE_DATA_P (insn))
1676 this_block = insn_scope (insn);
1677 /* For sequences compute scope resulting from merging all scopes
1678 of instructions nested inside. */
1679 if (rtx_sequence *body = dyn_cast <rtx_sequence *> (PATTERN (insn)))
1684 for (i = 0; i < body->len (); i++)
1685 this_block = choose_inner_scope (this_block,
1686 insn_scope (body->insn (i)));
1690 if (INSN_LOCATION (insn) == UNKNOWN_LOCATION)
1693 this_block = DECL_INITIAL (cfun->decl);
1696 if (this_block != cur_block)
1698 change_scope (insn, cur_block, this_block);
1699 cur_block = this_block;
1703 /* change_scope emits before the insn, not after. */
1704 note = emit_note (NOTE_INSN_DELETED);
1705 change_scope (note, cur_block, DECL_INITIAL (cfun->decl));
1711 static const char *some_local_dynamic_name;
1713 /* Locate some local-dynamic symbol still in use by this function
1714 so that we can print its name in local-dynamic base patterns.
1715 Return null if there are no local-dynamic references. */
1718 get_some_local_dynamic_name ()
1720 subrtx_iterator::array_type array;
1723 if (some_local_dynamic_name)
1724 return some_local_dynamic_name;
1726 for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
1727 if (NONDEBUG_INSN_P (insn))
1728 FOR_EACH_SUBRTX (iter, array, PATTERN (insn), ALL)
1730 const_rtx x = *iter;
1731 if (GET_CODE (x) == SYMBOL_REF)
1733 if (SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
1734 return some_local_dynamic_name = XSTR (x, 0);
1735 if (CONSTANT_POOL_ADDRESS_P (x))
1736 iter.substitute (get_pool_constant (x));
1743 /* Output assembler code for the start of a function,
1744 and initialize some of the variables in this file
1745 for the new function. The label for the function and associated
1746 assembler pseudo-ops have already been output in `assemble_start_function'.
1748 FIRST is the first insn of the rtl for the function being compiled.
1749 FILE is the file to write assembler code to.
1750 OPTIMIZE_P is nonzero if we should eliminate redundant
1751 test and compare insns. */
1754 final_start_function (rtx_insn *first, FILE *file,
1755 int optimize_p ATTRIBUTE_UNUSED)
1759 this_is_asm_operands = 0;
1761 need_profile_function = false;
1763 last_filename = LOCATION_FILE (prologue_location);
1764 last_linenum = LOCATION_LINE (prologue_location);
1765 last_discriminator = discriminator = 0;
1767 high_block_linenum = high_function_linenum = last_linenum;
1769 if (flag_sanitize & SANITIZE_ADDRESS)
1770 asan_function_start ();
1772 if (!DECL_IGNORED_P (current_function_decl))
1773 debug_hooks->begin_prologue (last_linenum, last_filename);
1775 if (!dwarf2_debug_info_emitted_p (current_function_decl))
1776 dwarf2out_begin_prologue (0, NULL);
1778 #ifdef LEAF_REG_REMAP
1779 if (crtl->uses_only_leaf_regs)
1780 leaf_renumber_regs (first);
1783 /* The Sun386i and perhaps other machines don't work right
1784 if the profiling code comes after the prologue. */
1785 if (targetm.profile_before_prologue () && crtl->profile)
1787 if (targetm.asm_out.function_prologue == default_function_pro_epilogue
1788 && targetm.have_prologue ())
1791 for (insn = first; insn; insn = NEXT_INSN (insn))
1797 else if (NOTE_KIND (insn) == NOTE_INSN_BASIC_BLOCK
1798 || NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
1800 else if (NOTE_KIND (insn) == NOTE_INSN_DELETED
1801 || NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION)
1810 need_profile_function = true;
1812 profile_function (file);
1815 profile_function (file);
1818 /* If debugging, assign block numbers to all of the blocks in this
1822 reemit_insn_block_notes ();
1823 number_blocks (current_function_decl);
1824 /* We never actually put out begin/end notes for the top-level
1825 block in the function. But, conceptually, that block is
1827 TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl)) = 1;
1830 if (warn_frame_larger_than
1831 && get_frame_size () > frame_larger_than_size)
1833 /* Issue a warning */
1834 warning (OPT_Wframe_larger_than_,
1835 "the frame size of %wd bytes is larger than %wd bytes",
1836 get_frame_size (), frame_larger_than_size);
1839 /* First output the function prologue: code to set up the stack frame. */
1840 targetm.asm_out.function_prologue (file, get_frame_size ());
1842 /* If the machine represents the prologue as RTL, the profiling code must
1843 be emitted when NOTE_INSN_PROLOGUE_END is scanned. */
1844 if (! targetm.have_prologue ())
1845 profile_after_prologue (file);
1849 profile_after_prologue (FILE *file ATTRIBUTE_UNUSED)
1851 if (!targetm.profile_before_prologue () && crtl->profile)
1852 profile_function (file);
1856 profile_function (FILE *file ATTRIBUTE_UNUSED)
1858 #ifndef NO_PROFILE_COUNTERS
1859 # define NO_PROFILE_COUNTERS 0
1861 #ifdef ASM_OUTPUT_REG_PUSH
1862 rtx sval = NULL, chain = NULL;
1864 if (cfun->returns_struct)
1865 sval = targetm.calls.struct_value_rtx (TREE_TYPE (current_function_decl),
1867 if (cfun->static_chain_decl)
1868 chain = targetm.calls.static_chain (current_function_decl, true);
1869 #endif /* ASM_OUTPUT_REG_PUSH */
1871 if (! NO_PROFILE_COUNTERS)
1873 int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE);
1874 switch_to_section (data_section);
1875 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
1876 targetm.asm_out.internal_label (file, "LP", current_function_funcdef_no);
1877 assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, align, 1);
1880 switch_to_section (current_function_section ());
1882 #ifdef ASM_OUTPUT_REG_PUSH
1883 if (sval && REG_P (sval))
1884 ASM_OUTPUT_REG_PUSH (file, REGNO (sval));
1885 if (chain && REG_P (chain))
1886 ASM_OUTPUT_REG_PUSH (file, REGNO (chain));
1889 FUNCTION_PROFILER (file, current_function_funcdef_no);
1891 #ifdef ASM_OUTPUT_REG_PUSH
1892 if (chain && REG_P (chain))
1893 ASM_OUTPUT_REG_POP (file, REGNO (chain));
1894 if (sval && REG_P (sval))
1895 ASM_OUTPUT_REG_POP (file, REGNO (sval));
1899 /* Output assembler code for the end of a function.
1900 For clarity, args are same as those of `final_start_function'
1901 even though not all of them are needed. */
1904 final_end_function (void)
1908 if (!DECL_IGNORED_P (current_function_decl))
1909 debug_hooks->end_function (high_function_linenum);
1911 /* Finally, output the function epilogue:
1912 code to restore the stack frame and return to the caller. */
1913 targetm.asm_out.function_epilogue (asm_out_file, get_frame_size ());
1915 /* And debug output. */
1916 if (!DECL_IGNORED_P (current_function_decl))
1917 debug_hooks->end_epilogue (last_linenum, last_filename);
1919 if (!dwarf2_debug_info_emitted_p (current_function_decl)
1920 && dwarf2out_do_frame ())
1921 dwarf2out_end_epilogue (last_linenum, last_filename);
1923 some_local_dynamic_name = 0;
1927 /* Dumper helper for basic block information. FILE is the assembly
1928 output file, and INSN is the instruction being emitted. */
1931 dump_basic_block_info (FILE *file, rtx_insn *insn, basic_block *start_to_bb,
1932 basic_block *end_to_bb, int bb_map_size, int *bb_seqn)
1936 if (!flag_debug_asm)
1939 if (INSN_UID (insn) < bb_map_size
1940 && (bb = start_to_bb[INSN_UID (insn)]) != NULL)
1945 fprintf (file, "%s BLOCK %d", ASM_COMMENT_START, bb->index);
1947 fprintf (file, " freq:%d", bb->frequency);
1949 fprintf (file, " count:%" PRId64,
1951 fprintf (file, " seq:%d", (*bb_seqn)++);
1952 fprintf (file, "\n%s PRED:", ASM_COMMENT_START);
1953 FOR_EACH_EDGE (e, ei, bb->preds)
1955 dump_edge_info (file, e, TDF_DETAILS, 0);
1957 fprintf (file, "\n");
1959 if (INSN_UID (insn) < bb_map_size
1960 && (bb = end_to_bb[INSN_UID (insn)]) != NULL)
1965 fprintf (asm_out_file, "%s SUCC:", ASM_COMMENT_START);
1966 FOR_EACH_EDGE (e, ei, bb->succs)
1968 dump_edge_info (asm_out_file, e, TDF_DETAILS, 1);
1970 fprintf (file, "\n");
1974 /* Output assembler code for some insns: all or part of a function.
1975 For description of args, see `final_start_function', above. */
1978 final (rtx_insn *first, FILE *file, int optimize_p)
1980 rtx_insn *insn, *next;
1983 /* Used for -dA dump. */
1984 basic_block *start_to_bb = NULL;
1985 basic_block *end_to_bb = NULL;
1986 int bb_map_size = 0;
1989 last_ignored_compare = 0;
1992 for (insn = first; insn; insn = NEXT_INSN (insn))
1994 /* If CC tracking across branches is enabled, record the insn which
1995 jumps to each branch only reached from one place. */
1996 if (optimize_p && JUMP_P (insn))
1998 rtx lab = JUMP_LABEL (insn);
1999 if (lab && LABEL_P (lab) && LABEL_NUSES (lab) == 1)
2001 LABEL_REFS (lab) = insn;
2014 bb_map_size = get_max_uid () + 1;
2015 start_to_bb = XCNEWVEC (basic_block, bb_map_size);
2016 end_to_bb = XCNEWVEC (basic_block, bb_map_size);
2018 /* There is no cfg for a thunk. */
2019 if (!cfun->is_thunk)
2020 FOR_EACH_BB_REVERSE_FN (bb, cfun)
2022 start_to_bb[INSN_UID (BB_HEAD (bb))] = bb;
2023 end_to_bb[INSN_UID (BB_END (bb))] = bb;
2027 /* Output the insns. */
2028 for (insn = first; insn;)
2030 if (HAVE_ATTR_length)
2032 if ((unsigned) INSN_UID (insn) >= INSN_ADDRESSES_SIZE ())
2034 /* This can be triggered by bugs elsewhere in the compiler if
2035 new insns are created after init_insn_lengths is called. */
2036 gcc_assert (NOTE_P (insn));
2037 insn_current_address = -1;
2040 insn_current_address = INSN_ADDRESSES (INSN_UID (insn));
2043 dump_basic_block_info (file, insn, start_to_bb, end_to_bb,
2044 bb_map_size, &bb_seqn);
2045 insn = final_scan_insn (insn, file, optimize_p, 0, &seen);
2054 /* Remove CFI notes, to avoid compare-debug failures. */
2055 for (insn = first; insn; insn = next)
2057 next = NEXT_INSN (insn);
2059 && (NOTE_KIND (insn) == NOTE_INSN_CFI
2060 || NOTE_KIND (insn) == NOTE_INSN_CFI_LABEL))
2066 get_insn_template (int code, rtx insn)
2068 switch (insn_data[code].output_format)
2070 case INSN_OUTPUT_FORMAT_SINGLE:
2071 return insn_data[code].output.single;
2072 case INSN_OUTPUT_FORMAT_MULTI:
2073 return insn_data[code].output.multi[which_alternative];
2074 case INSN_OUTPUT_FORMAT_FUNCTION:
2076 return (*insn_data[code].output.function) (recog_data.operand,
2077 as_a <rtx_insn *> (insn));
2084 /* Emit the appropriate declaration for an alternate-entry-point
2085 symbol represented by INSN, to FILE. INSN is a CODE_LABEL with
2086 LABEL_KIND != LABEL_NORMAL.
2088 The case fall-through in this function is intentional. */
2090 output_alternate_entry_point (FILE *file, rtx_insn *insn)
2092 const char *name = LABEL_NAME (insn);
2094 switch (LABEL_KIND (insn))
2096 case LABEL_WEAK_ENTRY:
2097 #ifdef ASM_WEAKEN_LABEL
2098 ASM_WEAKEN_LABEL (file, name);
2101 case LABEL_GLOBAL_ENTRY:
2102 targetm.asm_out.globalize_label (file, name);
2104 case LABEL_STATIC_ENTRY:
2105 #ifdef ASM_OUTPUT_TYPE_DIRECTIVE
2106 ASM_OUTPUT_TYPE_DIRECTIVE (file, name, "function");
2108 ASM_OUTPUT_LABEL (file, name);
2117 /* Given a CALL_INSN, find and return the nested CALL. */
2119 call_from_call_insn (rtx_call_insn *insn)
2122 gcc_assert (CALL_P (insn));
2125 while (GET_CODE (x) != CALL)
2127 switch (GET_CODE (x))
2132 x = COND_EXEC_CODE (x);
2135 x = XVECEXP (x, 0, 0);
2145 /* The final scan for one insn, INSN.
2146 Args are same as in `final', except that INSN
2147 is the insn being scanned.
2148 Value returned is the next insn to be scanned.
2150 NOPEEPHOLES is the flag to disallow peephole processing (currently
2151 used for within delayed branch sequence output).
2153 SEEN is used to track the end of the prologue, for emitting
2154 debug information. We force the emission of a line note after
2155 both NOTE_INSN_PROLOGUE_END and NOTE_INSN_FUNCTION_BEG. */
2158 final_scan_insn (rtx_insn *insn, FILE *file, int optimize_p ATTRIBUTE_UNUSED,
2159 int nopeepholes ATTRIBUTE_UNUSED, int *seen)
2168 /* Ignore deleted insns. These can occur when we split insns (due to a
2169 template of "#") while not optimizing. */
2170 if (insn->deleted ())
2171 return NEXT_INSN (insn);
2173 switch (GET_CODE (insn))
2176 switch (NOTE_KIND (insn))
2178 case NOTE_INSN_DELETED:
2179 case NOTE_INSN_UPDATE_SJLJ_CONTEXT:
2182 case NOTE_INSN_SWITCH_TEXT_SECTIONS:
2183 in_cold_section_p = !in_cold_section_p;
2185 if (dwarf2out_do_frame ())
2186 dwarf2out_switch_text_section ();
2187 else if (!DECL_IGNORED_P (current_function_decl))
2188 debug_hooks->switch_text_section ();
2190 switch_to_section (current_function_section ());
2191 targetm.asm_out.function_switched_text_sections (asm_out_file,
2192 current_function_decl,
2194 /* Emit a label for the split cold section. Form label name by
2195 suffixing "cold" to the original function's name. */
2196 if (in_cold_section_p)
2199 = clone_function_name (current_function_decl, "cold");
2200 #ifdef ASM_DECLARE_COLD_FUNCTION_NAME
2201 ASM_DECLARE_COLD_FUNCTION_NAME (asm_out_file,
2203 (cold_function_name),
2204 current_function_decl);
2206 ASM_OUTPUT_LABEL (asm_out_file,
2207 IDENTIFIER_POINTER (cold_function_name));
2212 case NOTE_INSN_BASIC_BLOCK:
2213 if (need_profile_function)
2215 profile_function (asm_out_file);
2216 need_profile_function = false;
2219 if (targetm.asm_out.unwind_emit)
2220 targetm.asm_out.unwind_emit (asm_out_file, insn);
2222 discriminator = NOTE_BASIC_BLOCK (insn)->discriminator;
2226 case NOTE_INSN_EH_REGION_BEG:
2227 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHB",
2228 NOTE_EH_HANDLER (insn));
2231 case NOTE_INSN_EH_REGION_END:
2232 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LEHE",
2233 NOTE_EH_HANDLER (insn));
2236 case NOTE_INSN_PROLOGUE_END:
2237 targetm.asm_out.function_end_prologue (file);
2238 profile_after_prologue (file);
2240 if ((*seen & (SEEN_EMITTED | SEEN_NOTE)) == SEEN_NOTE)
2242 *seen |= SEEN_EMITTED;
2243 force_source_line = true;
2250 case NOTE_INSN_EPILOGUE_BEG:
2251 if (!DECL_IGNORED_P (current_function_decl))
2252 (*debug_hooks->begin_epilogue) (last_linenum, last_filename);
2253 targetm.asm_out.function_begin_epilogue (file);
2257 dwarf2out_emit_cfi (NOTE_CFI (insn));
2260 case NOTE_INSN_CFI_LABEL:
2261 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LCFI",
2262 NOTE_LABEL_NUMBER (insn));
2265 case NOTE_INSN_FUNCTION_BEG:
2266 if (need_profile_function)
2268 profile_function (asm_out_file);
2269 need_profile_function = false;
2273 if (!DECL_IGNORED_P (current_function_decl))
2274 debug_hooks->end_prologue (last_linenum, last_filename);
2276 if ((*seen & (SEEN_EMITTED | SEEN_NOTE)) == SEEN_NOTE)
2278 *seen |= SEEN_EMITTED;
2279 force_source_line = true;
2286 case NOTE_INSN_BLOCK_BEG:
2287 if (debug_info_level == DINFO_LEVEL_NORMAL
2288 || debug_info_level == DINFO_LEVEL_VERBOSE
2289 || write_symbols == DWARF2_DEBUG
2290 || write_symbols == VMS_AND_DWARF2_DEBUG
2291 || write_symbols == VMS_DEBUG)
2293 int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
2297 high_block_linenum = last_linenum;
2299 /* Output debugging info about the symbol-block beginning. */
2300 if (!DECL_IGNORED_P (current_function_decl))
2301 debug_hooks->begin_block (last_linenum, n);
2303 /* Mark this block as output. */
2304 TREE_ASM_WRITTEN (NOTE_BLOCK (insn)) = 1;
2306 if (write_symbols == DBX_DEBUG
2307 || write_symbols == SDB_DEBUG)
2309 location_t *locus_ptr
2310 = block_nonartificial_location (NOTE_BLOCK (insn));
2312 if (locus_ptr != NULL)
2314 override_filename = LOCATION_FILE (*locus_ptr);
2315 override_linenum = LOCATION_LINE (*locus_ptr);
2320 case NOTE_INSN_BLOCK_END:
2321 if (debug_info_level == DINFO_LEVEL_NORMAL
2322 || debug_info_level == DINFO_LEVEL_VERBOSE
2323 || write_symbols == DWARF2_DEBUG
2324 || write_symbols == VMS_AND_DWARF2_DEBUG
2325 || write_symbols == VMS_DEBUG)
2327 int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
2331 /* End of a symbol-block. */
2333 gcc_assert (block_depth >= 0);
2335 if (!DECL_IGNORED_P (current_function_decl))
2336 debug_hooks->end_block (high_block_linenum, n);
2338 if (write_symbols == DBX_DEBUG
2339 || write_symbols == SDB_DEBUG)
2341 tree outer_block = BLOCK_SUPERCONTEXT (NOTE_BLOCK (insn));
2342 location_t *locus_ptr
2343 = block_nonartificial_location (outer_block);
2345 if (locus_ptr != NULL)
2347 override_filename = LOCATION_FILE (*locus_ptr);
2348 override_linenum = LOCATION_LINE (*locus_ptr);
2352 override_filename = NULL;
2353 override_linenum = 0;
2358 case NOTE_INSN_DELETED_LABEL:
2359 /* Emit the label. We may have deleted the CODE_LABEL because
2360 the label could be proved to be unreachable, though still
2361 referenced (in the form of having its address taken. */
2362 ASM_OUTPUT_DEBUG_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
2365 case NOTE_INSN_DELETED_DEBUG_LABEL:
2366 /* Similarly, but need to use different namespace for it. */
2367 if (CODE_LABEL_NUMBER (insn) != -1)
2368 ASM_OUTPUT_DEBUG_LABEL (file, "LDL", CODE_LABEL_NUMBER (insn));
2371 case NOTE_INSN_VAR_LOCATION:
2372 case NOTE_INSN_CALL_ARG_LOCATION:
2373 if (!DECL_IGNORED_P (current_function_decl))
2374 debug_hooks->var_location (insn);
2387 /* The target port might emit labels in the output function for
2388 some insn, e.g. sh.c output_branchy_insn. */
2389 if (CODE_LABEL_NUMBER (insn) <= max_labelno)
2391 int align = LABEL_TO_ALIGNMENT (insn);
2392 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
2393 int max_skip = LABEL_TO_MAX_SKIP (insn);
2396 if (align && NEXT_INSN (insn))
2398 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
2399 ASM_OUTPUT_MAX_SKIP_ALIGN (file, align, max_skip);
2401 #ifdef ASM_OUTPUT_ALIGN_WITH_NOP
2402 ASM_OUTPUT_ALIGN_WITH_NOP (file, align);
2404 ASM_OUTPUT_ALIGN (file, align);
2411 if (!DECL_IGNORED_P (current_function_decl) && LABEL_NAME (insn))
2412 debug_hooks->label (as_a <rtx_code_label *> (insn));
2416 next = next_nonnote_insn (insn);
2417 /* If this label is followed by a jump-table, make sure we put
2418 the label in the read-only section. Also possibly write the
2419 label and jump table together. */
2420 if (next != 0 && JUMP_TABLE_DATA_P (next))
2422 #if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2423 /* In this case, the case vector is being moved by the
2424 target, so don't output the label at all. Leave that
2425 to the back end macros. */
2427 if (! JUMP_TABLES_IN_TEXT_SECTION)
2431 switch_to_section (targetm.asm_out.function_rodata_section
2432 (current_function_decl));
2434 #ifdef ADDR_VEC_ALIGN
2435 log_align = ADDR_VEC_ALIGN (next);
2437 log_align = exact_log2 (BIGGEST_ALIGNMENT / BITS_PER_UNIT);
2439 ASM_OUTPUT_ALIGN (file, log_align);
2442 switch_to_section (current_function_section ());
2444 #ifdef ASM_OUTPUT_CASE_LABEL
2445 ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn),
2448 targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (insn));
2453 if (LABEL_ALT_ENTRY_P (insn))
2454 output_alternate_entry_point (file, insn);
2456 targetm.asm_out.internal_label (file, "L", CODE_LABEL_NUMBER (insn));
2461 rtx body = PATTERN (insn);
2462 int insn_code_number;
2466 /* Reset this early so it is correct for ASM statements. */
2467 current_insn_predicate = NULL_RTX;
2469 /* An INSN, JUMP_INSN or CALL_INSN.
2470 First check for special kinds that recog doesn't recognize. */
2472 if (GET_CODE (body) == USE /* These are just declarations. */
2473 || GET_CODE (body) == CLOBBER)
2478 /* If there is a REG_CC_SETTER note on this insn, it means that
2479 the setting of the condition code was done in the delay slot
2480 of the insn that branched here. So recover the cc status
2481 from the insn that set it. */
2483 rtx note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
2486 rtx_insn *other = as_a <rtx_insn *> (XEXP (note, 0));
2487 NOTICE_UPDATE_CC (PATTERN (other), other);
2488 cc_prev_status = cc_status;
2493 /* Detect insns that are really jump-tables
2494 and output them as such. */
2496 if (JUMP_TABLE_DATA_P (insn))
2498 #if !(defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC))
2502 if (! JUMP_TABLES_IN_TEXT_SECTION)
2503 switch_to_section (targetm.asm_out.function_rodata_section
2504 (current_function_decl));
2506 switch_to_section (current_function_section ());
2510 #if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2511 if (GET_CODE (body) == ADDR_VEC)
2513 #ifdef ASM_OUTPUT_ADDR_VEC
2514 ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn), body);
2521 #ifdef ASM_OUTPUT_ADDR_DIFF_VEC
2522 ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn), body);
2528 vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC);
2529 for (idx = 0; idx < vlen; idx++)
2531 if (GET_CODE (body) == ADDR_VEC)
2533 #ifdef ASM_OUTPUT_ADDR_VEC_ELT
2534 ASM_OUTPUT_ADDR_VEC_ELT
2535 (file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
2542 #ifdef ASM_OUTPUT_ADDR_DIFF_ELT
2543 ASM_OUTPUT_ADDR_DIFF_ELT
2546 CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
2547 CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
2553 #ifdef ASM_OUTPUT_CASE_END
2554 ASM_OUTPUT_CASE_END (file,
2555 CODE_LABEL_NUMBER (PREV_INSN (insn)),
2560 switch_to_section (current_function_section ());
2564 /* Output this line note if it is the first or the last line
2566 if (!DECL_IGNORED_P (current_function_decl)
2567 && notice_source_line (insn, &is_stmt))
2568 (*debug_hooks->source_line) (last_linenum, last_filename,
2569 last_discriminator, is_stmt);
2571 if (GET_CODE (body) == ASM_INPUT)
2573 const char *string = XSTR (body, 0);
2575 /* There's no telling what that did to the condition codes. */
2580 expanded_location loc;
2583 loc = expand_location (ASM_INPUT_SOURCE_LOCATION (body));
2584 if (*loc.file && loc.line)
2585 fprintf (asm_out_file, "%s %i \"%s\" 1\n",
2586 ASM_COMMENT_START, loc.line, loc.file);
2587 fprintf (asm_out_file, "\t%s\n", string);
2588 #if HAVE_AS_LINE_ZERO
2589 if (*loc.file && loc.line)
2590 fprintf (asm_out_file, "%s 0 \"\" 2\n", ASM_COMMENT_START);
2596 /* Detect `asm' construct with operands. */
2597 if (asm_noperands (body) >= 0)
2599 unsigned int noperands = asm_noperands (body);
2600 rtx *ops = XALLOCAVEC (rtx, noperands);
2603 expanded_location expanded;
2605 /* There's no telling what that did to the condition codes. */
2608 /* Get out the operand values. */
2609 string = decode_asm_operands (body, ops, NULL, NULL, NULL, &loc);
2610 /* Inhibit dying on what would otherwise be compiler bugs. */
2611 insn_noperands = noperands;
2612 this_is_asm_operands = insn;
2613 expanded = expand_location (loc);
2615 #ifdef FINAL_PRESCAN_INSN
2616 FINAL_PRESCAN_INSN (insn, ops, insn_noperands);
2619 /* Output the insn using them. */
2623 if (expanded.file && expanded.line)
2624 fprintf (asm_out_file, "%s %i \"%s\" 1\n",
2625 ASM_COMMENT_START, expanded.line, expanded.file);
2626 output_asm_insn (string, ops);
2627 #if HAVE_AS_LINE_ZERO
2628 if (expanded.file && expanded.line)
2629 fprintf (asm_out_file, "%s 0 \"\" 2\n", ASM_COMMENT_START);
2633 if (targetm.asm_out.final_postscan_insn)
2634 targetm.asm_out.final_postscan_insn (file, insn, ops,
2637 this_is_asm_operands = 0;
2643 if (rtx_sequence *seq = dyn_cast <rtx_sequence *> (body))
2645 /* A delayed-branch sequence */
2648 final_sequence = seq;
2650 /* The first insn in this SEQUENCE might be a JUMP_INSN that will
2651 force the restoration of a comparison that was previously
2652 thought unnecessary. If that happens, cancel this sequence
2653 and cause that insn to be restored. */
2655 next = final_scan_insn (seq->insn (0), file, 0, 1, seen);
2656 if (next != seq->insn (1))
2662 for (i = 1; i < seq->len (); i++)
2664 rtx_insn *insn = seq->insn (i);
2665 rtx_insn *next = NEXT_INSN (insn);
2666 /* We loop in case any instruction in a delay slot gets
2669 insn = final_scan_insn (insn, file, 0, 1, seen);
2670 while (insn != next);
2672 #ifdef DBR_OUTPUT_SEQEND
2673 DBR_OUTPUT_SEQEND (file);
2677 /* If the insn requiring the delay slot was a CALL_INSN, the
2678 insns in the delay slot are actually executed before the
2679 called function. Hence we don't preserve any CC-setting
2680 actions in these insns and the CC must be marked as being
2681 clobbered by the function. */
2682 if (CALL_P (seq->insn (0)))
2689 /* We have a real machine instruction as rtl. */
2691 body = PATTERN (insn);
2694 set = single_set (insn);
2696 /* Check for redundant test and compare instructions
2697 (when the condition codes are already set up as desired).
2698 This is done only when optimizing; if not optimizing,
2699 it should be possible for the user to alter a variable
2700 with the debugger in between statements
2701 and the next statement should reexamine the variable
2702 to compute the condition codes. */
2707 && GET_CODE (SET_DEST (set)) == CC0
2708 && insn != last_ignored_compare)
2711 if (GET_CODE (SET_SRC (set)) == SUBREG)
2712 SET_SRC (set) = alter_subreg (&SET_SRC (set), true);
2714 src1 = SET_SRC (set);
2716 if (GET_CODE (SET_SRC (set)) == COMPARE)
2718 if (GET_CODE (XEXP (SET_SRC (set), 0)) == SUBREG)
2719 XEXP (SET_SRC (set), 0)
2720 = alter_subreg (&XEXP (SET_SRC (set), 0), true);
2721 if (GET_CODE (XEXP (SET_SRC (set), 1)) == SUBREG)
2722 XEXP (SET_SRC (set), 1)
2723 = alter_subreg (&XEXP (SET_SRC (set), 1), true);
2724 if (XEXP (SET_SRC (set), 1)
2725 == CONST0_RTX (GET_MODE (XEXP (SET_SRC (set), 0))))
2726 src2 = XEXP (SET_SRC (set), 0);
2728 if ((cc_status.value1 != 0
2729 && rtx_equal_p (src1, cc_status.value1))
2730 || (cc_status.value2 != 0
2731 && rtx_equal_p (src1, cc_status.value2))
2732 || (src2 != 0 && cc_status.value1 != 0
2733 && rtx_equal_p (src2, cc_status.value1))
2734 || (src2 != 0 && cc_status.value2 != 0
2735 && rtx_equal_p (src2, cc_status.value2)))
2737 /* Don't delete insn if it has an addressing side-effect. */
2738 if (! FIND_REG_INC_NOTE (insn, NULL_RTX)
2739 /* or if anything in it is volatile. */
2740 && ! volatile_refs_p (PATTERN (insn)))
2742 /* We don't really delete the insn; just ignore it. */
2743 last_ignored_compare = insn;
2750 /* If this is a conditional branch, maybe modify it
2751 if the cc's are in a nonstandard state
2752 so that it accomplishes the same thing that it would
2753 do straightforwardly if the cc's were set up normally. */
2755 if (cc_status.flags != 0
2757 && GET_CODE (body) == SET
2758 && SET_DEST (body) == pc_rtx
2759 && GET_CODE (SET_SRC (body)) == IF_THEN_ELSE
2760 && COMPARISON_P (XEXP (SET_SRC (body), 0))
2761 && XEXP (XEXP (SET_SRC (body), 0), 0) == cc0_rtx)
2763 /* This function may alter the contents of its argument
2764 and clear some of the cc_status.flags bits.
2765 It may also return 1 meaning condition now always true
2766 or -1 meaning condition now always false
2767 or 2 meaning condition nontrivial but altered. */
2768 int result = alter_cond (XEXP (SET_SRC (body), 0));
2769 /* If condition now has fixed value, replace the IF_THEN_ELSE
2770 with its then-operand or its else-operand. */
2772 SET_SRC (body) = XEXP (SET_SRC (body), 1);
2774 SET_SRC (body) = XEXP (SET_SRC (body), 2);
2776 /* The jump is now either unconditional or a no-op.
2777 If it has become a no-op, don't try to output it.
2778 (It would not be recognized.) */
2779 if (SET_SRC (body) == pc_rtx)
2784 else if (ANY_RETURN_P (SET_SRC (body)))
2785 /* Replace (set (pc) (return)) with (return). */
2786 PATTERN (insn) = body = SET_SRC (body);
2788 /* Rerecognize the instruction if it has changed. */
2790 INSN_CODE (insn) = -1;
2793 /* If this is a conditional trap, maybe modify it if the cc's
2794 are in a nonstandard state so that it accomplishes the same
2795 thing that it would do straightforwardly if the cc's were
2797 if (cc_status.flags != 0
2798 && NONJUMP_INSN_P (insn)
2799 && GET_CODE (body) == TRAP_IF
2800 && COMPARISON_P (TRAP_CONDITION (body))
2801 && XEXP (TRAP_CONDITION (body), 0) == cc0_rtx)
2803 /* This function may alter the contents of its argument
2804 and clear some of the cc_status.flags bits.
2805 It may also return 1 meaning condition now always true
2806 or -1 meaning condition now always false
2807 or 2 meaning condition nontrivial but altered. */
2808 int result = alter_cond (TRAP_CONDITION (body));
2810 /* If TRAP_CONDITION has become always false, delete the
2818 /* If TRAP_CONDITION has become always true, replace
2819 TRAP_CONDITION with const_true_rtx. */
2821 TRAP_CONDITION (body) = const_true_rtx;
2823 /* Rerecognize the instruction if it has changed. */
2825 INSN_CODE (insn) = -1;
2828 /* Make same adjustments to instructions that examine the
2829 condition codes without jumping and instructions that
2830 handle conditional moves (if this machine has either one). */
2832 if (cc_status.flags != 0
2835 rtx cond_rtx, then_rtx, else_rtx;
2838 && GET_CODE (SET_SRC (set)) == IF_THEN_ELSE)
2840 cond_rtx = XEXP (SET_SRC (set), 0);
2841 then_rtx = XEXP (SET_SRC (set), 1);
2842 else_rtx = XEXP (SET_SRC (set), 2);
2846 cond_rtx = SET_SRC (set);
2847 then_rtx = const_true_rtx;
2848 else_rtx = const0_rtx;
2851 if (COMPARISON_P (cond_rtx)
2852 && XEXP (cond_rtx, 0) == cc0_rtx)
2855 result = alter_cond (cond_rtx);
2857 validate_change (insn, &SET_SRC (set), then_rtx, 0);
2858 else if (result == -1)
2859 validate_change (insn, &SET_SRC (set), else_rtx, 0);
2860 else if (result == 2)
2861 INSN_CODE (insn) = -1;
2862 if (SET_DEST (set) == SET_SRC (set))
2869 /* Do machine-specific peephole optimizations if desired. */
2871 if (HAVE_peephole && optimize_p && !flag_no_peephole && !nopeepholes)
2873 rtx_insn *next = peephole (insn);
2874 /* When peepholing, if there were notes within the peephole,
2875 emit them before the peephole. */
2876 if (next != 0 && next != NEXT_INSN (insn))
2878 rtx_insn *note, *prev = PREV_INSN (insn);
2880 for (note = NEXT_INSN (insn); note != next;
2881 note = NEXT_INSN (note))
2882 final_scan_insn (note, file, optimize_p, nopeepholes, seen);
2884 /* Put the notes in the proper position for a later
2885 rescan. For example, the SH target can do this
2886 when generating a far jump in a delayed branch
2888 note = NEXT_INSN (insn);
2889 SET_PREV_INSN (note) = prev;
2890 SET_NEXT_INSN (prev) = note;
2891 SET_NEXT_INSN (PREV_INSN (next)) = insn;
2892 SET_PREV_INSN (insn) = PREV_INSN (next);
2893 SET_NEXT_INSN (insn) = next;
2894 SET_PREV_INSN (next) = insn;
2897 /* PEEPHOLE might have changed this. */
2898 body = PATTERN (insn);
2901 /* Try to recognize the instruction.
2902 If successful, verify that the operands satisfy the
2903 constraints for the instruction. Crash if they don't,
2904 since `reload' should have changed them so that they do. */
2906 insn_code_number = recog_memoized (insn);
2907 cleanup_subreg_operands (insn);
2909 /* Dump the insn in the assembly for debugging (-dAP).
2910 If the final dump is requested as slim RTL, dump slim
2911 RTL to the assembly file also. */
2912 if (flag_dump_rtl_in_asm)
2914 print_rtx_head = ASM_COMMENT_START;
2915 if (! (dump_flags & TDF_SLIM))
2916 print_rtl_single (asm_out_file, insn);
2918 dump_insn_slim (asm_out_file, insn);
2919 print_rtx_head = "";
2922 if (! constrain_operands_cached (insn, 1))
2923 fatal_insn_not_found (insn);
2925 /* Some target machines need to prescan each insn before
2928 #ifdef FINAL_PRESCAN_INSN
2929 FINAL_PRESCAN_INSN (insn, recog_data.operand, recog_data.n_operands);
2932 if (targetm.have_conditional_execution ()
2933 && GET_CODE (PATTERN (insn)) == COND_EXEC)
2934 current_insn_predicate = COND_EXEC_TEST (PATTERN (insn));
2937 cc_prev_status = cc_status;
2939 /* Update `cc_status' for this instruction.
2940 The instruction's output routine may change it further.
2941 If the output routine for a jump insn needs to depend
2942 on the cc status, it should look at cc_prev_status. */
2944 NOTICE_UPDATE_CC (body, insn);
2947 current_output_insn = debug_insn = insn;
2949 /* Find the proper template for this insn. */
2950 templ = get_insn_template (insn_code_number, insn);
2952 /* If the C code returns 0, it means that it is a jump insn
2953 which follows a deleted test insn, and that test insn
2954 needs to be reinserted. */
2959 gcc_assert (prev_nonnote_insn (insn) == last_ignored_compare);
2961 /* We have already processed the notes between the setter and
2962 the user. Make sure we don't process them again, this is
2963 particularly important if one of the notes is a block
2964 scope note or an EH note. */
2966 prev != last_ignored_compare;
2967 prev = PREV_INSN (prev))
2970 delete_insn (prev); /* Use delete_note. */
2976 /* If the template is the string "#", it means that this insn must
2978 if (templ[0] == '#' && templ[1] == '\0')
2980 rtx_insn *new_rtx = try_split (body, insn, 0);
2982 /* If we didn't split the insn, go away. */
2983 if (new_rtx == insn && PATTERN (new_rtx) == body)
2984 fatal_insn ("could not split insn", insn);
2986 /* If we have a length attribute, this instruction should have
2987 been split in shorten_branches, to ensure that we would have
2988 valid length info for the splitees. */
2989 gcc_assert (!HAVE_ATTR_length);
2994 /* ??? This will put the directives in the wrong place if
2995 get_insn_template outputs assembly directly. However calling it
2996 before get_insn_template breaks if the insns is split. */
2997 if (targetm.asm_out.unwind_emit_before_insn
2998 && targetm.asm_out.unwind_emit)
2999 targetm.asm_out.unwind_emit (asm_out_file, insn);
3001 rtx_call_insn *call_insn = dyn_cast <rtx_call_insn *> (insn);
3002 if (call_insn != NULL)
3004 rtx x = call_from_call_insn (call_insn);
3006 if (x && MEM_P (x) && GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
3010 t = SYMBOL_REF_DECL (x);
3012 assemble_external (t);
3016 /* Output assembler code from the template. */
3017 output_asm_insn (templ, recog_data.operand);
3019 /* Some target machines need to postscan each insn after
3021 if (targetm.asm_out.final_postscan_insn)
3022 targetm.asm_out.final_postscan_insn (file, insn, recog_data.operand,
3023 recog_data.n_operands);
3025 if (!targetm.asm_out.unwind_emit_before_insn
3026 && targetm.asm_out.unwind_emit)
3027 targetm.asm_out.unwind_emit (asm_out_file, insn);
3029 /* Let the debug info back-end know about this call. We do this only
3030 after the instruction has been emitted because labels that may be
3031 created to reference the call instruction must appear after it. */
3032 if (call_insn != NULL && !DECL_IGNORED_P (current_function_decl))
3033 debug_hooks->var_location (insn);
3035 current_output_insn = debug_insn = 0;
3038 return NEXT_INSN (insn);
3041 /* Return whether a source line note needs to be emitted before INSN.
3042 Sets IS_STMT to TRUE if the line should be marked as a possible
3043 breakpoint location. */
3046 notice_source_line (rtx_insn *insn, bool *is_stmt)
3048 const char *filename;
3051 if (override_filename)
3053 filename = override_filename;
3054 linenum = override_linenum;
3056 else if (INSN_HAS_LOCATION (insn))
3058 expanded_location xloc = insn_location (insn);
3059 filename = xloc.file;
3060 linenum = xloc.line;
3068 if (filename == NULL)
3071 if (force_source_line
3072 || filename != last_filename
3073 || last_linenum != linenum)
3075 force_source_line = false;
3076 last_filename = filename;
3077 last_linenum = linenum;
3078 last_discriminator = discriminator;
3080 high_block_linenum = MAX (last_linenum, high_block_linenum);
3081 high_function_linenum = MAX (last_linenum, high_function_linenum);
3085 if (SUPPORTS_DISCRIMINATOR && last_discriminator != discriminator)
3087 /* If the discriminator changed, but the line number did not,
3088 output the line table entry with is_stmt false so the
3089 debugger does not treat this as a breakpoint location. */
3090 last_discriminator = discriminator;
3098 /* For each operand in INSN, simplify (subreg (reg)) so that it refers
3099 directly to the desired hard register. */
3102 cleanup_subreg_operands (rtx_insn *insn)
3105 bool changed = false;
3106 extract_insn_cached (insn);
3107 for (i = 0; i < recog_data.n_operands; i++)
3109 /* The following test cannot use recog_data.operand when testing
3110 for a SUBREG: the underlying object might have been changed
3111 already if we are inside a match_operator expression that
3112 matches the else clause. Instead we test the underlying
3113 expression directly. */
3114 if (GET_CODE (*recog_data.operand_loc[i]) == SUBREG)
3116 recog_data.operand[i] = alter_subreg (recog_data.operand_loc[i], true);
3119 else if (GET_CODE (recog_data.operand[i]) == PLUS
3120 || GET_CODE (recog_data.operand[i]) == MULT
3121 || MEM_P (recog_data.operand[i]))
3122 recog_data.operand[i] = walk_alter_subreg (recog_data.operand_loc[i], &changed);
3125 for (i = 0; i < recog_data.n_dups; i++)
3127 if (GET_CODE (*recog_data.dup_loc[i]) == SUBREG)
3129 *recog_data.dup_loc[i] = alter_subreg (recog_data.dup_loc[i], true);
3132 else if (GET_CODE (*recog_data.dup_loc[i]) == PLUS
3133 || GET_CODE (*recog_data.dup_loc[i]) == MULT
3134 || MEM_P (*recog_data.dup_loc[i]))
3135 *recog_data.dup_loc[i] = walk_alter_subreg (recog_data.dup_loc[i], &changed);
3138 df_insn_rescan (insn);
3141 /* If X is a SUBREG, try to replace it with a REG or a MEM, based on
3142 the thing it is a subreg of. Do it anyway if FINAL_P. */
3145 alter_subreg (rtx *xp, bool final_p)
3148 rtx y = SUBREG_REG (x);
3150 /* simplify_subreg does not remove subreg from volatile references.
3151 We are required to. */
3154 int offset = SUBREG_BYTE (x);
3156 /* For paradoxical subregs on big-endian machines, SUBREG_BYTE
3157 contains 0 instead of the proper offset. See simplify_subreg. */
3159 && GET_MODE_SIZE (GET_MODE (y)) < GET_MODE_SIZE (GET_MODE (x)))
3161 int difference = GET_MODE_SIZE (GET_MODE (y))
3162 - GET_MODE_SIZE (GET_MODE (x));
3163 if (WORDS_BIG_ENDIAN)
3164 offset += (difference / UNITS_PER_WORD) * UNITS_PER_WORD;
3165 if (BYTES_BIG_ENDIAN)
3166 offset += difference % UNITS_PER_WORD;
3170 *xp = adjust_address (y, GET_MODE (x), offset);
3172 *xp = adjust_address_nv (y, GET_MODE (x), offset);
3174 else if (REG_P (y) && HARD_REGISTER_P (y))
3176 rtx new_rtx = simplify_subreg (GET_MODE (x), y, GET_MODE (y),
3181 else if (final_p && REG_P (y))
3183 /* Simplify_subreg can't handle some REG cases, but we have to. */
3185 HOST_WIDE_INT offset;
3187 regno = subreg_regno (x);
3188 if (subreg_lowpart_p (x))
3189 offset = byte_lowpart_offset (GET_MODE (x), GET_MODE (y));
3191 offset = SUBREG_BYTE (x);
3192 *xp = gen_rtx_REG_offset (y, GET_MODE (x), regno, offset);
3199 /* Do alter_subreg on all the SUBREGs contained in X. */
3202 walk_alter_subreg (rtx *xp, bool *changed)
3205 switch (GET_CODE (x))
3210 XEXP (x, 0) = walk_alter_subreg (&XEXP (x, 0), changed);
3211 XEXP (x, 1) = walk_alter_subreg (&XEXP (x, 1), changed);
3216 XEXP (x, 0) = walk_alter_subreg (&XEXP (x, 0), changed);
3221 return alter_subreg (xp, true);
3232 /* Given BODY, the body of a jump instruction, alter the jump condition
3233 as required by the bits that are set in cc_status.flags.
3234 Not all of the bits there can be handled at this level in all cases.
3236 The value is normally 0.
3237 1 means that the condition has become always true.
3238 -1 means that the condition has become always false.
3239 2 means that COND has been altered. */
3242 alter_cond (rtx cond)
3246 if (cc_status.flags & CC_REVERSED)
3249 PUT_CODE (cond, swap_condition (GET_CODE (cond)));
3252 if (cc_status.flags & CC_INVERTED)
3255 PUT_CODE (cond, reverse_condition (GET_CODE (cond)));
3258 if (cc_status.flags & CC_NOT_POSITIVE)
3259 switch (GET_CODE (cond))
3264 /* Jump becomes unconditional. */
3270 /* Jump becomes no-op. */
3274 PUT_CODE (cond, EQ);
3279 PUT_CODE (cond, NE);
3287 if (cc_status.flags & CC_NOT_NEGATIVE)
3288 switch (GET_CODE (cond))
3292 /* Jump becomes unconditional. */
3297 /* Jump becomes no-op. */
3302 PUT_CODE (cond, EQ);
3308 PUT_CODE (cond, NE);
3316 if (cc_status.flags & CC_NO_OVERFLOW)
3317 switch (GET_CODE (cond))
3320 /* Jump becomes unconditional. */
3324 PUT_CODE (cond, EQ);
3329 PUT_CODE (cond, NE);
3334 /* Jump becomes no-op. */
3341 if (cc_status.flags & (CC_Z_IN_NOT_N | CC_Z_IN_N))
3342 switch (GET_CODE (cond))
3348 PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? GE : LT);
3353 PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? LT : GE);
3358 if (cc_status.flags & CC_NOT_SIGNED)
3359 /* The flags are valid if signed condition operators are converted
3361 switch (GET_CODE (cond))
3364 PUT_CODE (cond, LEU);
3369 PUT_CODE (cond, LTU);
3374 PUT_CODE (cond, GTU);
3379 PUT_CODE (cond, GEU);
3391 /* Report inconsistency between the assembler template and the operands.
3392 In an `asm', it's the user's fault; otherwise, the compiler's fault. */
3395 output_operand_lossage (const char *cmsgid, ...)
3399 const char *pfx_str;
3402 va_start (ap, cmsgid);
3404 pfx_str = this_is_asm_operands ? _("invalid 'asm': ") : "output_operand: ";
3405 fmt_string = xasprintf ("%s%s", pfx_str, _(cmsgid));
3406 new_message = xvasprintf (fmt_string, ap);
3408 if (this_is_asm_operands)
3409 error_for_asm (this_is_asm_operands, "%s", new_message);
3411 internal_error ("%s", new_message);
3418 /* Output of assembler code from a template, and its subroutines. */
3420 /* Annotate the assembly with a comment describing the pattern and
3421 alternative used. */
3424 output_asm_name (void)
3428 int num = INSN_CODE (debug_insn);
3429 fprintf (asm_out_file, "\t%s %d\t%s",
3430 ASM_COMMENT_START, INSN_UID (debug_insn),
3431 insn_data[num].name);
3432 if (insn_data[num].n_alternatives > 1)
3433 fprintf (asm_out_file, "/%d", which_alternative + 1);
3435 if (HAVE_ATTR_length)
3436 fprintf (asm_out_file, "\t[length = %d]",
3437 get_attr_length (debug_insn));
3439 /* Clear this so only the first assembler insn
3440 of any rtl insn will get the special comment for -dp. */
3445 /* If OP is a REG or MEM and we can find a MEM_EXPR corresponding to it
3446 or its address, return that expr . Set *PADDRESSP to 1 if the expr
3447 corresponds to the address of the object and 0 if to the object. */
3450 get_mem_expr_from_op (rtx op, int *paddressp)
3458 return REG_EXPR (op);
3459 else if (!MEM_P (op))
3462 if (MEM_EXPR (op) != 0)
3463 return MEM_EXPR (op);
3465 /* Otherwise we have an address, so indicate it and look at the address. */
3469 /* First check if we have a decl for the address, then look at the right side
3470 if it is a PLUS. Otherwise, strip off arithmetic and keep looking.
3471 But don't allow the address to itself be indirect. */
3472 if ((expr = get_mem_expr_from_op (op, &inner_addressp)) && ! inner_addressp)
3474 else if (GET_CODE (op) == PLUS
3475 && (expr = get_mem_expr_from_op (XEXP (op, 1), &inner_addressp)))
3479 || GET_RTX_CLASS (GET_CODE (op)) == RTX_BIN_ARITH)
3482 expr = get_mem_expr_from_op (op, &inner_addressp);
3483 return inner_addressp ? 0 : expr;
3486 /* Output operand names for assembler instructions. OPERANDS is the
3487 operand vector, OPORDER is the order to write the operands, and NOPS
3488 is the number of operands to write. */
3491 output_asm_operand_names (rtx *operands, int *oporder, int nops)
3496 for (i = 0; i < nops; i++)
3499 rtx op = operands[oporder[i]];
3500 tree expr = get_mem_expr_from_op (op, &addressp);
3502 fprintf (asm_out_file, "%c%s",
3503 wrote ? ',' : '\t', wrote ? "" : ASM_COMMENT_START);
3507 fprintf (asm_out_file, "%s",
3508 addressp ? "*" : "");
3509 print_mem_expr (asm_out_file, expr);
3512 else if (REG_P (op) && ORIGINAL_REGNO (op)
3513 && ORIGINAL_REGNO (op) != REGNO (op))
3514 fprintf (asm_out_file, " tmp%i", ORIGINAL_REGNO (op));
3518 #ifdef ASSEMBLER_DIALECT
3519 /* Helper function to parse assembler dialects in the asm string.
3520 This is called from output_asm_insn and asm_fprintf. */
3522 do_assembler_dialects (const char *p, int *dialect)
3533 output_operand_lossage ("nested assembly dialect alternatives");
3537 /* If we want the first dialect, do nothing. Otherwise, skip
3538 DIALECT_NUMBER of strings ending with '|'. */
3539 for (i = 0; i < dialect_number; i++)
3541 while (*p && *p != '}')
3549 /* Skip over any character after a percent sign. */
3561 output_operand_lossage ("unterminated assembly dialect alternative");
3568 /* Skip to close brace. */
3573 output_operand_lossage ("unterminated assembly dialect alternative");
3577 /* Skip over any character after a percent sign. */
3578 if (*p == '%' && p[1])
3592 putc (c, asm_out_file);
3597 putc (c, asm_out_file);
3608 /* Output text from TEMPLATE to the assembler output file,
3609 obeying %-directions to substitute operands taken from
3610 the vector OPERANDS.
3612 %N (for N a digit) means print operand N in usual manner.
3613 %lN means require operand N to be a CODE_LABEL or LABEL_REF
3614 and print the label name with no punctuation.
3615 %cN means require operand N to be a constant
3616 and print the constant expression with no punctuation.
3617 %aN means expect operand N to be a memory address
3618 (not a memory reference!) and print a reference
3620 %nN means expect operand N to be a constant
3621 and print a constant expression for minus the value
3622 of the operand, with no other punctuation. */
3625 output_asm_insn (const char *templ, rtx *operands)
3629 #ifdef ASSEMBLER_DIALECT
3632 int oporder[MAX_RECOG_OPERANDS];
3633 char opoutput[MAX_RECOG_OPERANDS];
3636 /* An insn may return a null string template
3637 in a case where no assembler code is needed. */
3641 memset (opoutput, 0, sizeof opoutput);
3643 putc ('\t', asm_out_file);
3645 #ifdef ASM_OUTPUT_OPCODE
3646 ASM_OUTPUT_OPCODE (asm_out_file, p);
3653 if (flag_verbose_asm)
3654 output_asm_operand_names (operands, oporder, ops);
3655 if (flag_print_asm_name)
3659 memset (opoutput, 0, sizeof opoutput);
3661 putc (c, asm_out_file);
3662 #ifdef ASM_OUTPUT_OPCODE
3663 while ((c = *p) == '\t')
3665 putc (c, asm_out_file);
3668 ASM_OUTPUT_OPCODE (asm_out_file, p);
3672 #ifdef ASSEMBLER_DIALECT
3676 p = do_assembler_dialects (p, &dialect);
3681 /* %% outputs a single %. %{, %} and %| print {, } and | respectively
3682 if ASSEMBLER_DIALECT defined and these characters have a special
3683 meaning as dialect delimiters.*/
3685 #ifdef ASSEMBLER_DIALECT
3686 || *p == '{' || *p == '}' || *p == '|'
3690 putc (*p, asm_out_file);
3693 /* %= outputs a number which is unique to each insn in the entire
3694 compilation. This is useful for making local labels that are
3695 referred to more than once in a given insn. */
3699 fprintf (asm_out_file, "%d", insn_counter);
3701 /* % followed by a letter and some digits
3702 outputs an operand in a special way depending on the letter.
3703 Letters `acln' are implemented directly.
3704 Other letters are passed to `output_operand' so that
3705 the TARGET_PRINT_OPERAND hook can define them. */
3706 else if (ISALPHA (*p))
3709 unsigned long opnum;
3712 opnum = strtoul (p, &endptr, 10);
3715 output_operand_lossage ("operand number missing "
3717 else if (this_is_asm_operands && opnum >= insn_noperands)
3718 output_operand_lossage ("operand number out of range");
3719 else if (letter == 'l')
3720 output_asm_label (operands[opnum]);
3721 else if (letter == 'a')
3722 output_address (VOIDmode, operands[opnum]);
3723 else if (letter == 'c')
3725 if (CONSTANT_ADDRESS_P (operands[opnum]))
3726 output_addr_const (asm_out_file, operands[opnum]);
3728 output_operand (operands[opnum], 'c');
3730 else if (letter == 'n')
3732 if (CONST_INT_P (operands[opnum]))
3733 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC,
3734 - INTVAL (operands[opnum]));
3737 putc ('-', asm_out_file);
3738 output_addr_const (asm_out_file, operands[opnum]);
3742 output_operand (operands[opnum], letter);
3744 if (!opoutput[opnum])
3745 oporder[ops++] = opnum;
3746 opoutput[opnum] = 1;
3751 /* % followed by a digit outputs an operand the default way. */
3752 else if (ISDIGIT (*p))
3754 unsigned long opnum;
3757 opnum = strtoul (p, &endptr, 10);
3758 if (this_is_asm_operands && opnum >= insn_noperands)
3759 output_operand_lossage ("operand number out of range");
3761 output_operand (operands[opnum], 0);
3763 if (!opoutput[opnum])
3764 oporder[ops++] = opnum;
3765 opoutput[opnum] = 1;
3770 /* % followed by punctuation: output something for that
3771 punctuation character alone, with no operand. The
3772 TARGET_PRINT_OPERAND hook decides what is actually done. */
3773 else if (targetm.asm_out.print_operand_punct_valid_p ((unsigned char) *p))
3774 output_operand (NULL_RTX, *p++);
3776 output_operand_lossage ("invalid %%-code");
3780 putc (c, asm_out_file);
3783 /* Write out the variable names for operands, if we know them. */
3784 if (flag_verbose_asm)
3785 output_asm_operand_names (operands, oporder, ops);
3786 if (flag_print_asm_name)
3789 putc ('\n', asm_out_file);
3792 /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */
3795 output_asm_label (rtx x)
3799 if (GET_CODE (x) == LABEL_REF)
3800 x = LABEL_REF_LABEL (x);
3803 && NOTE_KIND (x) == NOTE_INSN_DELETED_LABEL))
3804 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
3806 output_operand_lossage ("'%%l' operand isn't a label");
3808 assemble_name (asm_out_file, buf);
3811 /* Marks SYMBOL_REFs in x as referenced through use of assemble_external. */
3814 mark_symbol_refs_as_used (rtx x)
3816 subrtx_iterator::array_type array;
3817 FOR_EACH_SUBRTX (iter, array, x, ALL)
3819 const_rtx x = *iter;
3820 if (GET_CODE (x) == SYMBOL_REF)
3821 if (tree t = SYMBOL_REF_DECL (x))
3822 assemble_external (t);
3826 /* Print operand X using machine-dependent assembler syntax.
3827 CODE is a non-digit that preceded the operand-number in the % spec,
3828 such as 'z' if the spec was `%z3'. CODE is 0 if there was no char
3829 between the % and the digits.
3830 When CODE is a non-letter, X is 0.
3832 The meanings of the letters are machine-dependent and controlled
3833 by TARGET_PRINT_OPERAND. */
3836 output_operand (rtx x, int code ATTRIBUTE_UNUSED)
3838 if (x && GET_CODE (x) == SUBREG)
3839 x = alter_subreg (&x, true);
3841 /* X must not be a pseudo reg. */
3842 if (!targetm.no_register_allocation)
3843 gcc_assert (!x || !REG_P (x) || REGNO (x) < FIRST_PSEUDO_REGISTER);
3845 targetm.asm_out.print_operand (asm_out_file, x, code);
3850 mark_symbol_refs_as_used (x);
3853 /* Print a memory reference operand for address X using
3854 machine-dependent assembler syntax. */
3857 output_address (machine_mode mode, rtx x)
3859 bool changed = false;
3860 walk_alter_subreg (&x, &changed);
3861 targetm.asm_out.print_operand_address (asm_out_file, mode, x);
3864 /* Print an integer constant expression in assembler syntax.
3865 Addition and subtraction are the only arithmetic
3866 that may appear in these expressions. */
3869 output_addr_const (FILE *file, rtx x)
3874 switch (GET_CODE (x))
3881 if (SYMBOL_REF_DECL (x))
3882 assemble_external (SYMBOL_REF_DECL (x));
3883 #ifdef ASM_OUTPUT_SYMBOL_REF
3884 ASM_OUTPUT_SYMBOL_REF (file, x);
3886 assemble_name (file, XSTR (x, 0));
3891 x = LABEL_REF_LABEL (x);
3894 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
3895 #ifdef ASM_OUTPUT_LABEL_REF
3896 ASM_OUTPUT_LABEL_REF (file, buf);
3898 assemble_name (file, buf);
3903 fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
3907 /* This used to output parentheses around the expression,
3908 but that does not work on the 386 (either ATT or BSD assembler). */
3909 output_addr_const (file, XEXP (x, 0));
3912 case CONST_WIDE_INT:
3913 /* We do not know the mode here so we have to use a round about
3914 way to build a wide-int to get it printed properly. */
3916 wide_int w = wide_int::from_array (&CONST_WIDE_INT_ELT (x, 0),
3917 CONST_WIDE_INT_NUNITS (x),
3918 CONST_WIDE_INT_NUNITS (x)
3919 * HOST_BITS_PER_WIDE_INT,
3921 print_decs (w, file);
3926 if (CONST_DOUBLE_AS_INT_P (x))
3928 /* We can use %d if the number is one word and positive. */
3929 if (CONST_DOUBLE_HIGH (x))
3930 fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3931 (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x),
3932 (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x));
3933 else if (CONST_DOUBLE_LOW (x) < 0)
3934 fprintf (file, HOST_WIDE_INT_PRINT_HEX,
3935 (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x));
3937 fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
3940 /* We can't handle floating point constants;
3941 PRINT_OPERAND must handle them. */
3942 output_operand_lossage ("floating constant misused");
3946 fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_FIXED_VALUE_LOW (x));
3950 /* Some assemblers need integer constants to appear last (eg masm). */
3951 if (CONST_INT_P (XEXP (x, 0)))
3953 output_addr_const (file, XEXP (x, 1));
3954 if (INTVAL (XEXP (x, 0)) >= 0)
3955 fprintf (file, "+");
3956 output_addr_const (file, XEXP (x, 0));
3960 output_addr_const (file, XEXP (x, 0));
3961 if (!CONST_INT_P (XEXP (x, 1))
3962 || INTVAL (XEXP (x, 1)) >= 0)
3963 fprintf (file, "+");
3964 output_addr_const (file, XEXP (x, 1));
3969 /* Avoid outputting things like x-x or x+5-x,
3970 since some assemblers can't handle that. */
3971 x = simplify_subtraction (x);
3972 if (GET_CODE (x) != MINUS)
3975 output_addr_const (file, XEXP (x, 0));
3976 fprintf (file, "-");
3977 if ((CONST_INT_P (XEXP (x, 1)) && INTVAL (XEXP (x, 1)) >= 0)
3978 || GET_CODE (XEXP (x, 1)) == PC
3979 || GET_CODE (XEXP (x, 1)) == SYMBOL_REF)
3980 output_addr_const (file, XEXP (x, 1));
3983 fputs (targetm.asm_out.open_paren, file);
3984 output_addr_const (file, XEXP (x, 1));
3985 fputs (targetm.asm_out.close_paren, file);
3993 output_addr_const (file, XEXP (x, 0));
3997 if (targetm.asm_out.output_addr_const_extra (file, x))
4000 output_operand_lossage ("invalid expression as operand");
4004 /* Output a quoted string. */
4007 output_quoted_string (FILE *asm_file, const char *string)
4009 #ifdef OUTPUT_QUOTED_STRING
4010 OUTPUT_QUOTED_STRING (asm_file, string);
4014 putc ('\"', asm_file);
4015 while ((c = *string++) != 0)
4019 if (c == '\"' || c == '\\')
4020 putc ('\\', asm_file);
4024 fprintf (asm_file, "\\%03o", (unsigned char) c);
4026 putc ('\"', asm_file);
4030 /* Write a HOST_WIDE_INT number in hex form 0x1234, fast. */
4033 fprint_whex (FILE *f, unsigned HOST_WIDE_INT value)
4035 char buf[2 + CHAR_BIT * sizeof (value) / 4];
4040 char *p = buf + sizeof (buf);
4042 *--p = "0123456789abcdef"[value % 16];
4043 while ((value /= 16) != 0);
4046 fwrite (p, 1, buf + sizeof (buf) - p, f);
4050 /* Internal function that prints an unsigned long in decimal in reverse.
4051 The output string IS NOT null-terminated. */
4054 sprint_ul_rev (char *s, unsigned long value)
4059 s[i] = "0123456789"[value % 10];
4062 /* alternate version, without modulo */
4063 /* oldval = value; */
4065 /* s[i] = "0123456789" [oldval - 10*value]; */
4072 /* Write an unsigned long as decimal to a file, fast. */
4075 fprint_ul (FILE *f, unsigned long value)
4077 /* python says: len(str(2**64)) == 20 */
4081 i = sprint_ul_rev (s, value);
4083 /* It's probably too small to bother with string reversal and fputs. */
4092 /* Write an unsigned long as decimal to a string, fast.
4093 s must be wide enough to not overflow, at least 21 chars.
4094 Returns the length of the string (without terminating '\0'). */
4097 sprint_ul (char *s, unsigned long value)
4099 int len = sprint_ul_rev (s, value);
4102 std::reverse (s, s + len);
4106 /* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
4107 %R prints the value of REGISTER_PREFIX.
4108 %L prints the value of LOCAL_LABEL_PREFIX.
4109 %U prints the value of USER_LABEL_PREFIX.
4110 %I prints the value of IMMEDIATE_PREFIX.
4111 %O runs ASM_OUTPUT_OPCODE to transform what follows in the string.
4112 Also supported are %d, %i, %u, %x, %X, %o, %c, %s and %%.
4114 We handle alternate assembler dialects here, just like output_asm_insn. */
4117 asm_fprintf (FILE *file, const char *p, ...)
4121 #ifdef ASSEMBLER_DIALECT
4126 va_start (argptr, p);
4133 #ifdef ASSEMBLER_DIALECT
4137 p = do_assembler_dialects (p, &dialect);
4144 while (strchr ("-+ #0", c))
4149 while (ISDIGIT (c) || c == '.')
4160 case 'd': case 'i': case 'u':
4161 case 'x': case 'X': case 'o':
4165 fprintf (file, buf, va_arg (argptr, int));
4169 /* This is a prefix to the 'd', 'i', 'u', 'x', 'X', and
4170 'o' cases, but we do not check for those cases. It
4171 means that the value is a HOST_WIDE_INT, which may be
4172 either `long' or `long long'. */
4173 memcpy (q, HOST_WIDE_INT_PRINT, strlen (HOST_WIDE_INT_PRINT));
4174 q += strlen (HOST_WIDE_INT_PRINT);
4177 fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT));
4182 #ifdef HAVE_LONG_LONG
4188 fprintf (file, buf, va_arg (argptr, long long));
4195 fprintf (file, buf, va_arg (argptr, long));
4203 fprintf (file, buf, va_arg (argptr, char *));
4207 #ifdef ASM_OUTPUT_OPCODE
4208 ASM_OUTPUT_OPCODE (asm_out_file, p);
4213 #ifdef REGISTER_PREFIX
4214 fprintf (file, "%s", REGISTER_PREFIX);
4219 #ifdef IMMEDIATE_PREFIX
4220 fprintf (file, "%s", IMMEDIATE_PREFIX);
4225 #ifdef LOCAL_LABEL_PREFIX
4226 fprintf (file, "%s", LOCAL_LABEL_PREFIX);
4231 fputs (user_label_prefix, file);
4234 #ifdef ASM_FPRINTF_EXTENSIONS
4235 /* Uppercase letters are reserved for general use by asm_fprintf
4236 and so are not available to target specific code. In order to
4237 prevent the ASM_FPRINTF_EXTENSIONS macro from using them then,
4238 they are defined here. As they get turned into real extensions
4239 to asm_fprintf they should be removed from this list. */
4240 case 'A': case 'B': case 'C': case 'D': case 'E':
4241 case 'F': case 'G': case 'H': case 'J': case 'K':
4242 case 'M': case 'N': case 'P': case 'Q': case 'S':
4243 case 'T': case 'V': case 'W': case 'Y': case 'Z':
4246 ASM_FPRINTF_EXTENSIONS (file, argptr, p)
4259 /* Return nonzero if this function has no function calls. */
4262 leaf_function_p (void)
4266 /* Some back-ends (e.g. s390) want leaf functions to stay leaf
4267 functions even if they call mcount. */
4268 if (crtl->profile && !targetm.keep_leaf_when_profiled ())
4271 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4274 && ! SIBLING_CALL_P (insn))
4276 if (NONJUMP_INSN_P (insn)
4277 && GET_CODE (PATTERN (insn)) == SEQUENCE
4278 && CALL_P (XVECEXP (PATTERN (insn), 0, 0))
4279 && ! SIBLING_CALL_P (XVECEXP (PATTERN (insn), 0, 0)))
4286 /* Return 1 if branch is a forward branch.
4287 Uses insn_shuid array, so it works only in the final pass. May be used by
4288 output templates to customary add branch prediction hints.
4291 final_forward_branch_p (rtx_insn *insn)
4293 int insn_id, label_id;
4295 gcc_assert (uid_shuid);
4296 insn_id = INSN_SHUID (insn);
4297 label_id = INSN_SHUID (JUMP_LABEL (insn));
4298 /* We've hit some insns that does not have id information available. */
4299 gcc_assert (insn_id && label_id);
4300 return insn_id < label_id;
4303 /* On some machines, a function with no call insns
4304 can run faster if it doesn't create its own register window.
4305 When output, the leaf function should use only the "output"
4306 registers. Ordinarily, the function would be compiled to use
4307 the "input" registers to find its arguments; it is a candidate
4308 for leaf treatment if it uses only the "input" registers.
4309 Leaf function treatment means renumbering so the function
4310 uses the "output" registers instead. */
4312 #ifdef LEAF_REGISTERS
4314 /* Return 1 if this function uses only the registers that can be
4315 safely renumbered. */
4318 only_leaf_regs_used (void)
4321 const char *const permitted_reg_in_leaf_functions = LEAF_REGISTERS;
4323 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4324 if ((df_regs_ever_live_p (i) || global_regs[i])
4325 && ! permitted_reg_in_leaf_functions[i])
4328 if (crtl->uses_pic_offset_table
4329 && pic_offset_table_rtx != 0
4330 && REG_P (pic_offset_table_rtx)
4331 && ! permitted_reg_in_leaf_functions[REGNO (pic_offset_table_rtx)])
4337 /* Scan all instructions and renumber all registers into those
4338 available in leaf functions. */
4341 leaf_renumber_regs (rtx_insn *first)
4345 /* Renumber only the actual patterns.
4346 The reg-notes can contain frame pointer refs,
4347 and renumbering them could crash, and should not be needed. */
4348 for (insn = first; insn; insn = NEXT_INSN (insn))
4350 leaf_renumber_regs_insn (PATTERN (insn));
4353 /* Scan IN_RTX and its subexpressions, and renumber all regs into those
4354 available in leaf functions. */
4357 leaf_renumber_regs_insn (rtx in_rtx)
4360 const char *format_ptr;
4365 /* Renumber all input-registers into output-registers.
4366 renumbered_regs would be 1 for an output-register;
4373 /* Don't renumber the same reg twice. */
4377 newreg = REGNO (in_rtx);
4378 /* Don't try to renumber pseudo regs. It is possible for a pseudo reg
4379 to reach here as part of a REG_NOTE. */
4380 if (newreg >= FIRST_PSEUDO_REGISTER)
4385 newreg = LEAF_REG_REMAP (newreg);
4386 gcc_assert (newreg >= 0);
4387 df_set_regs_ever_live (REGNO (in_rtx), false);
4388 df_set_regs_ever_live (newreg, true);
4389 SET_REGNO (in_rtx, newreg);
4394 if (INSN_P (in_rtx))
4396 /* Inside a SEQUENCE, we find insns.
4397 Renumber just the patterns of these insns,
4398 just as we do for the top-level insns. */
4399 leaf_renumber_regs_insn (PATTERN (in_rtx));
4403 format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
4405 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
4406 switch (*format_ptr++)
4409 leaf_renumber_regs_insn (XEXP (in_rtx, i));
4413 if (NULL != XVEC (in_rtx, i))
4415 for (j = 0; j < XVECLEN (in_rtx, i); j++)
4416 leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));
4435 /* Turn the RTL into assembly. */
4437 rest_of_handle_final (void)
4439 const char *fnname = get_fnname_from_decl (current_function_decl);
4441 assemble_start_function (current_function_decl, fnname);
4442 final_start_function (get_insns (), asm_out_file, optimize);
4443 final (get_insns (), asm_out_file, optimize);
4445 collect_fn_hard_reg_usage ();
4446 final_end_function ();
4448 /* The IA-64 ".handlerdata" directive must be issued before the ".endp"
4449 directive that closes the procedure descriptor. Similarly, for x64 SEH.
4450 Otherwise it's not strictly necessary, but it doesn't hurt either. */
4451 output_function_exception_table (fnname);
4453 assemble_end_function (current_function_decl, fnname);
4455 user_defined_section_attribute = false;
4457 /* Free up reg info memory. */
4461 fflush (asm_out_file);
4463 /* Write DBX symbols if requested. */
4465 /* Note that for those inline functions where we don't initially
4466 know for certain that we will be generating an out-of-line copy,
4467 the first invocation of this routine (rest_of_compilation) will
4468 skip over this code by doing a `goto exit_rest_of_compilation;'.
4469 Later on, wrapup_global_declarations will (indirectly) call
4470 rest_of_compilation again for those inline functions that need
4471 to have out-of-line copies generated. During that call, we
4472 *will* be routed past here. */
4474 timevar_push (TV_SYMOUT);
4475 if (!DECL_IGNORED_P (current_function_decl))
4476 debug_hooks->function_decl (current_function_decl);
4477 timevar_pop (TV_SYMOUT);
4479 /* Release the blocks that are linked to DECL_INITIAL() to free the memory. */
4480 DECL_INITIAL (current_function_decl) = error_mark_node;
4482 if (DECL_STATIC_CONSTRUCTOR (current_function_decl)
4483 && targetm.have_ctors_dtors)
4484 targetm.asm_out.constructor (XEXP (DECL_RTL (current_function_decl), 0),
4485 decl_init_priority_lookup
4486 (current_function_decl));
4487 if (DECL_STATIC_DESTRUCTOR (current_function_decl)
4488 && targetm.have_ctors_dtors)
4489 targetm.asm_out.destructor (XEXP (DECL_RTL (current_function_decl), 0),
4490 decl_fini_priority_lookup
4491 (current_function_decl));
4497 const pass_data pass_data_final =
4499 RTL_PASS, /* type */
4501 OPTGROUP_NONE, /* optinfo_flags */
4502 TV_FINAL, /* tv_id */
4503 0, /* properties_required */
4504 0, /* properties_provided */
4505 0, /* properties_destroyed */
4506 0, /* todo_flags_start */
4507 0, /* todo_flags_finish */
4510 class pass_final : public rtl_opt_pass
4513 pass_final (gcc::context *ctxt)
4514 : rtl_opt_pass (pass_data_final, ctxt)
4517 /* opt_pass methods: */
4518 virtual unsigned int execute (function *) { return rest_of_handle_final (); }
4520 }; // class pass_final
4525 make_pass_final (gcc::context *ctxt)
4527 return new pass_final (ctxt);
4532 rest_of_handle_shorten_branches (void)
4534 /* Shorten branches. */
4535 shorten_branches (get_insns ());
4541 const pass_data pass_data_shorten_branches =
4543 RTL_PASS, /* type */
4544 "shorten", /* name */
4545 OPTGROUP_NONE, /* optinfo_flags */
4546 TV_SHORTEN_BRANCH, /* tv_id */
4547 0, /* properties_required */
4548 0, /* properties_provided */
4549 0, /* properties_destroyed */
4550 0, /* todo_flags_start */
4551 0, /* todo_flags_finish */
4554 class pass_shorten_branches : public rtl_opt_pass
4557 pass_shorten_branches (gcc::context *ctxt)
4558 : rtl_opt_pass (pass_data_shorten_branches, ctxt)
4561 /* opt_pass methods: */
4562 virtual unsigned int execute (function *)
4564 return rest_of_handle_shorten_branches ();
4567 }; // class pass_shorten_branches
4572 make_pass_shorten_branches (gcc::context *ctxt)
4574 return new pass_shorten_branches (ctxt);
4579 rest_of_clean_state (void)
4581 rtx_insn *insn, *next;
4582 FILE *final_output = NULL;
4583 int save_unnumbered = flag_dump_unnumbered;
4584 int save_noaddr = flag_dump_noaddr;
4586 if (flag_dump_final_insns)
4588 final_output = fopen (flag_dump_final_insns, "a");
4591 error ("could not open final insn dump file %qs: %m",
4592 flag_dump_final_insns);
4593 flag_dump_final_insns = NULL;
4597 flag_dump_noaddr = flag_dump_unnumbered = 1;
4598 if (flag_compare_debug_opt || flag_compare_debug)
4599 dump_flags |= TDF_NOUID;
4600 dump_function_header (final_output, current_function_decl,
4602 final_insns_dump_p = true;
4604 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4606 INSN_UID (insn) = CODE_LABEL_NUMBER (insn);
4610 set_block_for_insn (insn, NULL);
4611 INSN_UID (insn) = 0;
4616 /* It is very important to decompose the RTL instruction chain here:
4617 debug information keeps pointing into CODE_LABEL insns inside the function
4618 body. If these remain pointing to the other insns, we end up preserving
4619 whole RTL chain and attached detailed debug info in memory. */
4620 for (insn = get_insns (); insn; insn = next)
4622 next = NEXT_INSN (insn);
4623 SET_NEXT_INSN (insn) = NULL;
4624 SET_PREV_INSN (insn) = NULL;
4627 && (!NOTE_P (insn) ||
4628 (NOTE_KIND (insn) != NOTE_INSN_VAR_LOCATION
4629 && NOTE_KIND (insn) != NOTE_INSN_CALL_ARG_LOCATION
4630 && NOTE_KIND (insn) != NOTE_INSN_BLOCK_BEG
4631 && NOTE_KIND (insn) != NOTE_INSN_BLOCK_END
4632 && NOTE_KIND (insn) != NOTE_INSN_DELETED_DEBUG_LABEL)))
4633 print_rtl_single (final_output, insn);
4638 flag_dump_noaddr = save_noaddr;
4639 flag_dump_unnumbered = save_unnumbered;
4640 final_insns_dump_p = false;
4642 if (fclose (final_output))
4644 error ("could not close final insn dump file %qs: %m",
4645 flag_dump_final_insns);
4646 flag_dump_final_insns = NULL;
4650 /* In case the function was not output,
4651 don't leave any temporary anonymous types
4652 queued up for sdb output. */
4653 if (SDB_DEBUGGING_INFO && write_symbols == SDB_DEBUG)
4654 sdbout_types (NULL_TREE);
4656 flag_rerun_cse_after_global_opts = 0;
4657 reload_completed = 0;
4658 epilogue_completed = 0;
4660 regstack_completed = 0;
4663 /* Clear out the insn_length contents now that they are no
4665 init_insn_lengths ();
4667 /* Show no temporary slots allocated. */
4670 free_bb_for_insn ();
4672 delete_tree_ssa (cfun);
4674 /* We can reduce stack alignment on call site only when we are sure that
4675 the function body just produced will be actually used in the final
4677 if (decl_binds_to_current_def_p (current_function_decl))
4679 unsigned int pref = crtl->preferred_stack_boundary;
4680 if (crtl->stack_alignment_needed > crtl->preferred_stack_boundary)
4681 pref = crtl->stack_alignment_needed;
4682 cgraph_node::rtl_info (current_function_decl)
4683 ->preferred_incoming_stack_boundary = pref;
4686 /* Make sure volatile mem refs aren't considered valid operands for
4687 arithmetic insns. We must call this here if this is a nested inline
4688 function, since the above code leaves us in the init_recog state,
4689 and the function context push/pop code does not save/restore volatile_ok.
4691 ??? Maybe it isn't necessary for expand_start_function to call this
4692 anymore if we do it here? */
4694 init_recog_no_volatile ();
4696 /* We're done with this function. Free up memory if we can. */
4697 free_after_parsing (cfun);
4698 free_after_compilation (cfun);
4704 const pass_data pass_data_clean_state =
4706 RTL_PASS, /* type */
4707 "*clean_state", /* name */
4708 OPTGROUP_NONE, /* optinfo_flags */
4709 TV_FINAL, /* tv_id */
4710 0, /* properties_required */
4711 0, /* properties_provided */
4712 PROP_rtl, /* properties_destroyed */
4713 0, /* todo_flags_start */
4714 0, /* todo_flags_finish */
4717 class pass_clean_state : public rtl_opt_pass
4720 pass_clean_state (gcc::context *ctxt)
4721 : rtl_opt_pass (pass_data_clean_state, ctxt)
4724 /* opt_pass methods: */
4725 virtual unsigned int execute (function *)
4727 return rest_of_clean_state ();
4730 }; // class pass_clean_state
4735 make_pass_clean_state (gcc::context *ctxt)
4737 return new pass_clean_state (ctxt);
4740 /* Return true if INSN is a call to the current function. */
4743 self_recursive_call_p (rtx_insn *insn)
4745 tree fndecl = get_call_fndecl (insn);
4746 return (fndecl == current_function_decl
4747 && decl_binds_to_current_def_p (fndecl));
4750 /* Collect hard register usage for the current function. */
4753 collect_fn_hard_reg_usage (void)
4759 struct cgraph_rtl_info *node;
4760 HARD_REG_SET function_used_regs;
4762 /* ??? To be removed when all the ports have been fixed. */
4763 if (!targetm.call_fusage_contains_non_callee_clobbers)
4766 CLEAR_HARD_REG_SET (function_used_regs);
4768 for (insn = get_insns (); insn != NULL_RTX; insn = next_insn (insn))
4770 HARD_REG_SET insn_used_regs;
4772 if (!NONDEBUG_INSN_P (insn))
4776 && !self_recursive_call_p (insn))
4778 if (!get_call_reg_set_usage (insn, &insn_used_regs,
4782 IOR_HARD_REG_SET (function_used_regs, insn_used_regs);
4785 find_all_hard_reg_sets (insn, &insn_used_regs, false);
4786 IOR_HARD_REG_SET (function_used_regs, insn_used_regs);
4789 /* Be conservative - mark fixed and global registers as used. */
4790 IOR_HARD_REG_SET (function_used_regs, fixed_reg_set);
4793 /* Handle STACK_REGS conservatively, since the df-framework does not
4794 provide accurate information for them. */
4796 for (i = FIRST_STACK_REG; i <= LAST_STACK_REG; i++)
4797 SET_HARD_REG_BIT (function_used_regs, i);
4800 /* The information we have gathered is only interesting if it exposes a
4801 register from the call_used_regs that is not used in this function. */
4802 if (hard_reg_set_subset_p (call_used_reg_set, function_used_regs))
4805 node = cgraph_node::rtl_info (current_function_decl);
4806 gcc_assert (node != NULL);
4808 COPY_HARD_REG_SET (node->function_used_regs, function_used_regs);
4809 node->function_used_regs_valid = 1;
4812 /* Get the declaration of the function called by INSN. */
4815 get_call_fndecl (rtx_insn *insn)
4819 note = find_reg_note (insn, REG_CALL_DECL, NULL_RTX);
4820 if (note == NULL_RTX)
4823 datum = XEXP (note, 0);
4824 if (datum != NULL_RTX)
4825 return SYMBOL_REF_DECL (datum);
4830 /* Return the cgraph_rtl_info of the function called by INSN. Returns NULL for
4831 call targets that can be overwritten. */
4833 static struct cgraph_rtl_info *
4834 get_call_cgraph_rtl_info (rtx_insn *insn)
4838 if (insn == NULL_RTX)
4841 fndecl = get_call_fndecl (insn);
4842 if (fndecl == NULL_TREE
4843 || !decl_binds_to_current_def_p (fndecl))
4846 return cgraph_node::rtl_info (fndecl);
4849 /* Find hard registers used by function call instruction INSN, and return them
4850 in REG_SET. Return DEFAULT_SET in REG_SET if not found. */
4853 get_call_reg_set_usage (rtx_insn *insn, HARD_REG_SET *reg_set,
4854 HARD_REG_SET default_set)
4858 struct cgraph_rtl_info *node = get_call_cgraph_rtl_info (insn);
4860 && node->function_used_regs_valid)
4862 COPY_HARD_REG_SET (*reg_set, node->function_used_regs);
4863 AND_HARD_REG_SET (*reg_set, default_set);
4868 COPY_HARD_REG_SET (*reg_set, default_set);