1 /* Convert RTL to assembler code and output it, for GNU compiler.
2 Copyright (C) 1987-2013 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. */
47 #include "coretypes.h"
54 #include "insn-config.h"
55 #include "insn-attr.h"
57 #include "conditions.h"
59 #include "hard-reg-set.h"
63 #include "rtl-error.h"
64 #include "toplev.h" /* exact_log2, floor_log2 */
67 #include "basic-block.h"
69 #include "targhooks.h"
72 #include "tree-pass.h"
73 #include "tree-flow.h"
80 #include "tree-pretty-print.h" /* for dump_function_header */
82 #ifdef XCOFF_DEBUGGING_INFO
83 #include "xcoffout.h" /* Needed for external data
84 declarations for e.g. AIX 4.x. */
87 #include "dwarf2out.h"
89 #ifdef DBX_DEBUGGING_INFO
93 #ifdef SDB_DEBUGGING_INFO
97 /* Most ports that aren't using cc0 don't need to define CC_STATUS_INIT.
98 So define a null default for it to save conditionalization later. */
99 #ifndef CC_STATUS_INIT
100 #define CC_STATUS_INIT
103 /* Is the given character a logical line separator for the assembler? */
104 #ifndef IS_ASM_LOGICAL_LINE_SEPARATOR
105 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) ((C) == ';')
108 #ifndef JUMP_TABLES_IN_TEXT_SECTION
109 #define JUMP_TABLES_IN_TEXT_SECTION 0
112 /* Bitflags used by final_scan_insn. */
115 #define SEEN_EMITTED 4
117 /* Last insn processed by final_scan_insn. */
118 static rtx debug_insn
;
119 rtx current_output_insn
;
121 /* Line number of last NOTE. */
122 static int last_linenum
;
124 /* Last discriminator written to assembly. */
125 static int last_discriminator
;
127 /* Discriminator of current block. */
128 static int discriminator
;
130 /* Highest line number in current block. */
131 static int high_block_linenum
;
133 /* Likewise for function. */
134 static int high_function_linenum
;
136 /* Filename of last NOTE. */
137 static const char *last_filename
;
139 /* Override filename and line number. */
140 static const char *override_filename
;
141 static int override_linenum
;
143 /* Whether to force emission of a line note before the next insn. */
144 static bool force_source_line
= false;
146 extern const int length_unit_log
; /* This is defined in insn-attrtab.c. */
148 /* Nonzero while outputting an `asm' with operands.
149 This means that inconsistencies are the user's fault, so don't die.
150 The precise value is the insn being output, to pass to error_for_asm. */
151 rtx this_is_asm_operands
;
153 /* Number of operands of this insn, for an `asm' with operands. */
154 static unsigned int insn_noperands
;
156 /* Compare optimization flag. */
158 static rtx last_ignored_compare
= 0;
160 /* Assign a unique number to each insn that is output.
161 This can be used to generate unique local labels. */
163 static int insn_counter
= 0;
166 /* This variable contains machine-dependent flags (defined in tm.h)
167 set and examined by output routines
168 that describe how to interpret the condition codes properly. */
172 /* During output of an insn, this contains a copy of cc_status
173 from before the insn. */
175 CC_STATUS cc_prev_status
;
178 /* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen. */
180 static int block_depth
;
182 /* Nonzero if have enabled APP processing of our assembler output. */
186 /* If we are outputting an insn sequence, this contains the sequence rtx.
191 #ifdef ASSEMBLER_DIALECT
193 /* Number of the assembler dialect to use, starting at 0. */
194 static int dialect_number
;
197 /* Nonnull if the insn currently being emitted was a COND_EXEC pattern. */
198 rtx current_insn_predicate
;
200 /* True if printing into -fdump-final-insns= dump. */
201 bool final_insns_dump_p
;
203 /* True if profile_function should be called, but hasn't been called yet. */
204 static bool need_profile_function
;
206 static int asm_insn_count (rtx
);
207 static void profile_function (FILE *);
208 static void profile_after_prologue (FILE *);
209 static bool notice_source_line (rtx
, bool *);
210 static rtx
walk_alter_subreg (rtx
*, bool *);
211 static void output_asm_name (void);
212 static void output_alternate_entry_point (FILE *, rtx
);
213 static tree
get_mem_expr_from_op (rtx
, int *);
214 static void output_asm_operand_names (rtx
*, int *, int);
215 #ifdef LEAF_REGISTERS
216 static void leaf_renumber_regs (rtx
);
219 static int alter_cond (rtx
);
221 #ifndef ADDR_VEC_ALIGN
222 static int final_addr_vec_align (rtx
);
224 static int align_fuzz (rtx
, rtx
, int, unsigned);
226 /* Initialize data in final at the beginning of a compilation. */
229 init_final (const char *filename ATTRIBUTE_UNUSED
)
234 #ifdef ASSEMBLER_DIALECT
235 dialect_number
= ASSEMBLER_DIALECT
;
239 /* Default target function prologue and epilogue assembler output.
241 If not overridden for epilogue code, then the function body itself
242 contains return instructions wherever needed. */
244 default_function_pro_epilogue (FILE *file ATTRIBUTE_UNUSED
,
245 HOST_WIDE_INT size ATTRIBUTE_UNUSED
)
250 default_function_switched_text_sections (FILE *file ATTRIBUTE_UNUSED
,
251 tree decl ATTRIBUTE_UNUSED
,
252 bool new_is_cold ATTRIBUTE_UNUSED
)
256 /* Default target hook that outputs nothing to a stream. */
258 no_asm_to_stream (FILE *file ATTRIBUTE_UNUSED
)
262 /* Enable APP processing of subsequent output.
263 Used before the output from an `asm' statement. */
270 fputs (ASM_APP_ON
, asm_out_file
);
275 /* Disable APP processing of subsequent output.
276 Called from varasm.c before most kinds of output. */
283 fputs (ASM_APP_OFF
, asm_out_file
);
288 /* Return the number of slots filled in the current
289 delayed branch sequence (we don't count the insn needing the
290 delay slot). Zero if not in a delayed branch sequence. */
294 dbr_sequence_length (void)
296 if (final_sequence
!= 0)
297 return XVECLEN (final_sequence
, 0) - 1;
303 /* The next two pages contain routines used to compute the length of an insn
304 and to shorten branches. */
306 /* Arrays for insn lengths, and addresses. The latter is referenced by
307 `insn_current_length'. */
309 static int *insn_lengths
;
311 vec
<int> insn_addresses_
;
313 /* Max uid for which the above arrays are valid. */
314 static int insn_lengths_max_uid
;
316 /* Address of insn being processed. Used by `insn_current_length'. */
317 int insn_current_address
;
319 /* Address of insn being processed in previous iteration. */
320 int insn_last_address
;
322 /* known invariant alignment of insn being processed. */
323 int insn_current_align
;
325 /* After shorten_branches, for any insn, uid_align[INSN_UID (insn)]
326 gives the next following alignment insn that increases the known
327 alignment, or NULL_RTX if there is no such insn.
328 For any alignment obtained this way, we can again index uid_align with
329 its uid to obtain the next following align that in turn increases the
330 alignment, till we reach NULL_RTX; the sequence obtained this way
331 for each insn we'll call the alignment chain of this insn in the following
334 struct label_alignment
340 static rtx
*uid_align
;
341 static int *uid_shuid
;
342 static struct label_alignment
*label_align
;
344 /* Indicate that branch shortening hasn't yet been done. */
347 init_insn_lengths (void)
358 insn_lengths_max_uid
= 0;
360 if (HAVE_ATTR_length
)
361 INSN_ADDRESSES_FREE ();
369 /* Obtain the current length of an insn. If branch shortening has been done,
370 get its actual length. Otherwise, use FALLBACK_FN to calculate the
373 get_attr_length_1 (rtx insn
, int (*fallback_fn
) (rtx
))
379 if (!HAVE_ATTR_length
)
382 if (insn_lengths_max_uid
> INSN_UID (insn
))
383 return insn_lengths
[INSN_UID (insn
)];
385 switch (GET_CODE (insn
))
395 length
= fallback_fn (insn
);
399 body
= PATTERN (insn
);
400 if (GET_CODE (body
) == USE
|| GET_CODE (body
) == CLOBBER
)
403 else if (GET_CODE (body
) == ASM_INPUT
|| asm_noperands (body
) >= 0)
404 length
= asm_insn_count (body
) * fallback_fn (insn
);
405 else if (GET_CODE (body
) == SEQUENCE
)
406 for (i
= 0; i
< XVECLEN (body
, 0); i
++)
407 length
+= get_attr_length_1 (XVECEXP (body
, 0, i
), fallback_fn
);
409 length
= fallback_fn (insn
);
416 #ifdef ADJUST_INSN_LENGTH
417 ADJUST_INSN_LENGTH (insn
, length
);
422 /* Obtain the current length of an insn. If branch shortening has been done,
423 get its actual length. Otherwise, get its maximum length. */
425 get_attr_length (rtx insn
)
427 return get_attr_length_1 (insn
, insn_default_length
);
430 /* Obtain the current length of an insn. If branch shortening has been done,
431 get its actual length. Otherwise, get its minimum length. */
433 get_attr_min_length (rtx insn
)
435 return get_attr_length_1 (insn
, insn_min_length
);
438 /* Code to handle alignment inside shorten_branches. */
440 /* Here is an explanation how the algorithm in align_fuzz can give
443 Call a sequence of instructions beginning with alignment point X
444 and continuing until the next alignment point `block X'. When `X'
445 is used in an expression, it means the alignment value of the
448 Call the distance between the start of the first insn of block X, and
449 the end of the last insn of block X `IX', for the `inner size of X'.
450 This is clearly the sum of the instruction lengths.
452 Likewise with the next alignment-delimited block following X, which we
455 Call the distance between the start of the first insn of block X, and
456 the start of the first insn of block Y `OX', for the `outer size of X'.
458 The estimated padding is then OX - IX.
460 OX can be safely estimated as
465 OX = round_up(IX, X) + Y - X
467 Clearly est(IX) >= real(IX), because that only depends on the
468 instruction lengths, and those being overestimated is a given.
470 Clearly round_up(foo, Z) >= round_up(bar, Z) if foo >= bar, so
471 we needn't worry about that when thinking about OX.
473 When X >= Y, the alignment provided by Y adds no uncertainty factor
474 for branch ranges starting before X, so we can just round what we have.
475 But when X < Y, we don't know anything about the, so to speak,
476 `middle bits', so we have to assume the worst when aligning up from an
477 address mod X to one mod Y, which is Y - X. */
480 #define LABEL_ALIGN(LABEL) align_labels_log
484 #define LOOP_ALIGN(LABEL) align_loops_log
487 #ifndef LABEL_ALIGN_AFTER_BARRIER
488 #define LABEL_ALIGN_AFTER_BARRIER(LABEL) 0
492 #define JUMP_ALIGN(LABEL) align_jumps_log
496 default_label_align_after_barrier_max_skip (rtx insn ATTRIBUTE_UNUSED
)
502 default_loop_align_max_skip (rtx insn ATTRIBUTE_UNUSED
)
504 return align_loops_max_skip
;
508 default_label_align_max_skip (rtx insn ATTRIBUTE_UNUSED
)
510 return align_labels_max_skip
;
514 default_jump_align_max_skip (rtx insn ATTRIBUTE_UNUSED
)
516 return align_jumps_max_skip
;
519 #ifndef ADDR_VEC_ALIGN
521 final_addr_vec_align (rtx addr_vec
)
523 int align
= GET_MODE_SIZE (GET_MODE (PATTERN (addr_vec
)));
525 if (align
> BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
526 align
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
527 return exact_log2 (align
);
531 #define ADDR_VEC_ALIGN(ADDR_VEC) final_addr_vec_align (ADDR_VEC)
534 #ifndef INSN_LENGTH_ALIGNMENT
535 #define INSN_LENGTH_ALIGNMENT(INSN) length_unit_log
538 #define INSN_SHUID(INSN) (uid_shuid[INSN_UID (INSN)])
540 static int min_labelno
, max_labelno
;
542 #define LABEL_TO_ALIGNMENT(LABEL) \
543 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].alignment)
545 #define LABEL_TO_MAX_SKIP(LABEL) \
546 (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].max_skip)
548 /* For the benefit of port specific code do this also as a function. */
551 label_to_alignment (rtx label
)
553 if (CODE_LABEL_NUMBER (label
) <= max_labelno
)
554 return LABEL_TO_ALIGNMENT (label
);
559 label_to_max_skip (rtx label
)
561 if (CODE_LABEL_NUMBER (label
) <= max_labelno
)
562 return LABEL_TO_MAX_SKIP (label
);
566 /* The differences in addresses
567 between a branch and its target might grow or shrink depending on
568 the alignment the start insn of the range (the branch for a forward
569 branch or the label for a backward branch) starts out on; if these
570 differences are used naively, they can even oscillate infinitely.
571 We therefore want to compute a 'worst case' address difference that
572 is independent of the alignment the start insn of the range end
573 up on, and that is at least as large as the actual difference.
574 The function align_fuzz calculates the amount we have to add to the
575 naively computed difference, by traversing the part of the alignment
576 chain of the start insn of the range that is in front of the end insn
577 of the range, and considering for each alignment the maximum amount
578 that it might contribute to a size increase.
580 For casesi tables, we also want to know worst case minimum amounts of
581 address difference, in case a machine description wants to introduce
582 some common offset that is added to all offsets in a table.
583 For this purpose, align_fuzz with a growth argument of 0 computes the
584 appropriate adjustment. */
586 /* Compute the maximum delta by which the difference of the addresses of
587 START and END might grow / shrink due to a different address for start
588 which changes the size of alignment insns between START and END.
589 KNOWN_ALIGN_LOG is the alignment known for START.
590 GROWTH should be ~0 if the objective is to compute potential code size
591 increase, and 0 if the objective is to compute potential shrink.
592 The return value is undefined for any other value of GROWTH. */
595 align_fuzz (rtx start
, rtx end
, int known_align_log
, unsigned int growth
)
597 int uid
= INSN_UID (start
);
599 int known_align
= 1 << known_align_log
;
600 int end_shuid
= INSN_SHUID (end
);
603 for (align_label
= uid_align
[uid
]; align_label
; align_label
= uid_align
[uid
])
605 int align_addr
, new_align
;
607 uid
= INSN_UID (align_label
);
608 align_addr
= INSN_ADDRESSES (uid
) - insn_lengths
[uid
];
609 if (uid_shuid
[uid
] > end_shuid
)
611 known_align_log
= LABEL_TO_ALIGNMENT (align_label
);
612 new_align
= 1 << known_align_log
;
613 if (new_align
< known_align
)
615 fuzz
+= (-align_addr
^ growth
) & (new_align
- known_align
);
616 known_align
= new_align
;
621 /* Compute a worst-case reference address of a branch so that it
622 can be safely used in the presence of aligned labels. Since the
623 size of the branch itself is unknown, the size of the branch is
624 not included in the range. I.e. for a forward branch, the reference
625 address is the end address of the branch as known from the previous
626 branch shortening pass, minus a value to account for possible size
627 increase due to alignment. For a backward branch, it is the start
628 address of the branch as known from the current pass, plus a value
629 to account for possible size increase due to alignment.
630 NB.: Therefore, the maximum offset allowed for backward branches needs
631 to exclude the branch size. */
634 insn_current_reference_address (rtx branch
)
639 if (! INSN_ADDRESSES_SET_P ())
642 seq
= NEXT_INSN (PREV_INSN (branch
));
643 seq_uid
= INSN_UID (seq
);
644 if (!JUMP_P (branch
))
645 /* This can happen for example on the PA; the objective is to know the
646 offset to address something in front of the start of the function.
647 Thus, we can treat it like a backward branch.
648 We assume here that FUNCTION_BOUNDARY / BITS_PER_UNIT is larger than
649 any alignment we'd encounter, so we skip the call to align_fuzz. */
650 return insn_current_address
;
651 dest
= JUMP_LABEL (branch
);
653 /* BRANCH has no proper alignment chain set, so use SEQ.
654 BRANCH also has no INSN_SHUID. */
655 if (INSN_SHUID (seq
) < INSN_SHUID (dest
))
657 /* Forward branch. */
658 return (insn_last_address
+ insn_lengths
[seq_uid
]
659 - align_fuzz (seq
, dest
, length_unit_log
, ~0));
663 /* Backward branch. */
664 return (insn_current_address
665 + align_fuzz (dest
, seq
, length_unit_log
, ~0));
669 /* Compute branch alignments based on frequency information in the
673 compute_alignments (void)
675 int log
, max_skip
, max_log
;
678 int freq_threshold
= 0;
686 max_labelno
= max_label_num ();
687 min_labelno
= get_first_label_num ();
688 label_align
= XCNEWVEC (struct label_alignment
, max_labelno
- min_labelno
+ 1);
690 /* If not optimizing or optimizing for size, don't assign any alignments. */
691 if (! optimize
|| optimize_function_for_size_p (cfun
))
696 dump_reg_info (dump_file
);
697 dump_flow_info (dump_file
, TDF_DETAILS
);
698 flow_loops_dump (dump_file
, NULL
, 1);
700 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
702 if (bb
->frequency
> freq_max
)
703 freq_max
= bb
->frequency
;
704 freq_threshold
= freq_max
/ PARAM_VALUE (PARAM_ALIGN_THRESHOLD
);
707 fprintf(dump_file
, "freq_max: %i\n",freq_max
);
710 rtx label
= BB_HEAD (bb
);
711 int fallthru_frequency
= 0, branch_frequency
= 0, has_fallthru
= 0;
716 || optimize_bb_for_size_p (bb
))
719 fprintf(dump_file
, "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n",
720 bb
->index
, bb
->frequency
, bb
->loop_father
->num
,
724 max_log
= LABEL_ALIGN (label
);
725 max_skip
= targetm
.asm_out
.label_align_max_skip (label
);
727 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
729 if (e
->flags
& EDGE_FALLTHRU
)
730 has_fallthru
= 1, fallthru_frequency
+= EDGE_FREQUENCY (e
);
732 branch_frequency
+= EDGE_FREQUENCY (e
);
736 fprintf(dump_file
, "BB %4i freq %4i loop %2i loop_depth %2i fall %4i branch %4i",
737 bb
->index
, bb
->frequency
, bb
->loop_father
->num
,
739 fallthru_frequency
, branch_frequency
);
740 if (!bb
->loop_father
->inner
&& bb
->loop_father
->num
)
741 fprintf (dump_file
, " inner_loop");
742 if (bb
->loop_father
->header
== bb
)
743 fprintf (dump_file
, " loop_header");
744 fprintf (dump_file
, "\n");
747 /* There are two purposes to align block with no fallthru incoming edge:
748 1) to avoid fetch stalls when branch destination is near cache boundary
749 2) to improve cache efficiency in case the previous block is not executed
750 (so it does not need to be in the cache).
752 We to catch first case, we align frequently executed blocks.
753 To catch the second, we align blocks that are executed more frequently
754 than the predecessor and the predecessor is likely to not be executed
755 when function is called. */
758 && (branch_frequency
> freq_threshold
759 || (bb
->frequency
> bb
->prev_bb
->frequency
* 10
760 && (bb
->prev_bb
->frequency
761 <= ENTRY_BLOCK_PTR
->frequency
/ 2))))
763 log
= JUMP_ALIGN (label
);
765 fprintf(dump_file
, " jump alignment added.\n");
769 max_skip
= targetm
.asm_out
.jump_align_max_skip (label
);
772 /* In case block is frequent and reached mostly by non-fallthru edge,
773 align it. It is most likely a first block of loop. */
775 && optimize_bb_for_speed_p (bb
)
776 && branch_frequency
+ fallthru_frequency
> freq_threshold
778 > fallthru_frequency
* PARAM_VALUE (PARAM_ALIGN_LOOP_ITERATIONS
)))
780 log
= LOOP_ALIGN (label
);
782 fprintf(dump_file
, " internal loop alignment added.\n");
786 max_skip
= targetm
.asm_out
.loop_align_max_skip (label
);
789 LABEL_TO_ALIGNMENT (label
) = max_log
;
790 LABEL_TO_MAX_SKIP (label
) = max_skip
;
793 loop_optimizer_finalize ();
794 free_dominance_info (CDI_DOMINATORS
);
798 /* Grow the LABEL_ALIGN array after new labels are created. */
801 grow_label_align (void)
803 int old
= max_labelno
;
807 max_labelno
= max_label_num ();
809 n_labels
= max_labelno
- min_labelno
+ 1;
810 n_old_labels
= old
- min_labelno
+ 1;
812 label_align
= XRESIZEVEC (struct label_alignment
, label_align
, n_labels
);
814 /* Range of labels grows monotonically in the function. Failing here
815 means that the initialization of array got lost. */
816 gcc_assert (n_old_labels
<= n_labels
);
818 memset (label_align
+ n_old_labels
, 0,
819 (n_labels
- n_old_labels
) * sizeof (struct label_alignment
));
822 /* Update the already computed alignment information. LABEL_PAIRS is a vector
823 made up of pairs of labels for which the alignment information of the first
824 element will be copied from that of the second element. */
827 update_alignments (vec
<rtx
> &label_pairs
)
832 if (max_labelno
!= max_label_num ())
835 FOR_EACH_VEC_ELT (label_pairs
, i
, iter
)
838 LABEL_TO_ALIGNMENT (label
) = LABEL_TO_ALIGNMENT (iter
);
839 LABEL_TO_MAX_SKIP (label
) = LABEL_TO_MAX_SKIP (iter
);
847 const pass_data pass_data_compute_alignments
=
850 "alignments", /* name */
851 OPTGROUP_NONE
, /* optinfo_flags */
852 false, /* has_gate */
853 true, /* has_execute */
855 0, /* properties_required */
856 0, /* properties_provided */
857 0, /* properties_destroyed */
858 0, /* todo_flags_start */
859 TODO_verify_rtl_sharing
, /* todo_flags_finish */
862 class pass_compute_alignments
: public rtl_opt_pass
865 pass_compute_alignments(gcc::context
*ctxt
)
866 : rtl_opt_pass(pass_data_compute_alignments
, ctxt
)
869 /* opt_pass methods: */
870 unsigned int execute () { return compute_alignments (); }
872 }; // class pass_compute_alignments
877 make_pass_compute_alignments (gcc::context
*ctxt
)
879 return new pass_compute_alignments (ctxt
);
883 /* Make a pass over all insns and compute their actual lengths by shortening
884 any branches of variable length if possible. */
886 /* shorten_branches might be called multiple times: for example, the SH
887 port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG.
888 In order to do this, it needs proper length information, which it obtains
889 by calling shorten_branches. This cannot be collapsed with
890 shorten_branches itself into a single pass unless we also want to integrate
891 reorg.c, since the branch splitting exposes new instructions with delay
895 shorten_branches (rtx first
)
902 #define MAX_CODE_ALIGN 16
904 int something_changed
= 1;
905 char *varying_length
;
908 rtx align_tab
[MAX_CODE_ALIGN
];
910 /* Compute maximum UID and allocate label_align / uid_shuid. */
911 max_uid
= get_max_uid ();
913 /* Free uid_shuid before reallocating it. */
916 uid_shuid
= XNEWVEC (int, max_uid
);
918 if (max_labelno
!= max_label_num ())
921 /* Initialize label_align and set up uid_shuid to be strictly
922 monotonically rising with insn order. */
923 /* We use max_log here to keep track of the maximum alignment we want to
924 impose on the next CODE_LABEL (or the current one if we are processing
925 the CODE_LABEL itself). */
930 for (insn
= get_insns (), i
= 1; insn
; insn
= NEXT_INSN (insn
))
934 INSN_SHUID (insn
) = i
++;
941 bool next_is_jumptable
;
943 /* Merge in alignments computed by compute_alignments. */
944 log
= LABEL_TO_ALIGNMENT (insn
);
948 max_skip
= LABEL_TO_MAX_SKIP (insn
);
951 next
= next_nonnote_insn (insn
);
952 next_is_jumptable
= next
&& JUMP_TABLE_DATA_P (next
);
953 if (!next_is_jumptable
)
955 log
= LABEL_ALIGN (insn
);
959 max_skip
= targetm
.asm_out
.label_align_max_skip (insn
);
962 /* ADDR_VECs only take room if read-only data goes into the text
964 if ((JUMP_TABLES_IN_TEXT_SECTION
965 || readonly_data_section
== text_section
)
966 && next_is_jumptable
)
968 log
= ADDR_VEC_ALIGN (next
);
972 max_skip
= targetm
.asm_out
.label_align_max_skip (insn
);
975 LABEL_TO_ALIGNMENT (insn
) = max_log
;
976 LABEL_TO_MAX_SKIP (insn
) = max_skip
;
980 else if (BARRIER_P (insn
))
984 for (label
= insn
; label
&& ! INSN_P (label
);
985 label
= NEXT_INSN (label
))
988 log
= LABEL_ALIGN_AFTER_BARRIER (insn
);
992 max_skip
= targetm
.asm_out
.label_align_after_barrier_max_skip (label
);
998 if (!HAVE_ATTR_length
)
1001 /* Allocate the rest of the arrays. */
1002 insn_lengths
= XNEWVEC (int, max_uid
);
1003 insn_lengths_max_uid
= max_uid
;
1004 /* Syntax errors can lead to labels being outside of the main insn stream.
1005 Initialize insn_addresses, so that we get reproducible results. */
1006 INSN_ADDRESSES_ALLOC (max_uid
);
1008 varying_length
= XCNEWVEC (char, max_uid
);
1010 /* Initialize uid_align. We scan instructions
1011 from end to start, and keep in align_tab[n] the last seen insn
1012 that does an alignment of at least n+1, i.e. the successor
1013 in the alignment chain for an insn that does / has a known
1015 uid_align
= XCNEWVEC (rtx
, max_uid
);
1017 for (i
= MAX_CODE_ALIGN
; --i
>= 0;)
1018 align_tab
[i
] = NULL_RTX
;
1019 seq
= get_last_insn ();
1020 for (; seq
; seq
= PREV_INSN (seq
))
1022 int uid
= INSN_UID (seq
);
1024 log
= (LABEL_P (seq
) ? LABEL_TO_ALIGNMENT (seq
) : 0);
1025 uid_align
[uid
] = align_tab
[0];
1028 /* Found an alignment label. */
1029 uid_align
[uid
] = align_tab
[log
];
1030 for (i
= log
- 1; i
>= 0; i
--)
1035 /* When optimizing, we start assuming minimum length, and keep increasing
1036 lengths as we find the need for this, till nothing changes.
1037 When not optimizing, we start assuming maximum lengths, and
1038 do a single pass to update the lengths. */
1039 bool increasing
= optimize
!= 0;
1041 #ifdef CASE_VECTOR_SHORTEN_MODE
1044 /* Look for ADDR_DIFF_VECs, and initialize their minimum and maximum
1047 int min_shuid
= INSN_SHUID (get_insns ()) - 1;
1048 int max_shuid
= INSN_SHUID (get_last_insn ()) + 1;
1051 for (insn
= first
; insn
!= 0; insn
= NEXT_INSN (insn
))
1053 rtx min_lab
= NULL_RTX
, max_lab
= NULL_RTX
, pat
;
1054 int len
, i
, min
, max
, insn_shuid
;
1056 addr_diff_vec_flags flags
;
1058 if (! JUMP_TABLE_DATA_P (insn
)
1059 || GET_CODE (PATTERN (insn
)) != ADDR_DIFF_VEC
)
1061 pat
= PATTERN (insn
);
1062 len
= XVECLEN (pat
, 1);
1063 gcc_assert (len
> 0);
1064 min_align
= MAX_CODE_ALIGN
;
1065 for (min
= max_shuid
, max
= min_shuid
, i
= len
- 1; i
>= 0; i
--)
1067 rtx lab
= XEXP (XVECEXP (pat
, 1, i
), 0);
1068 int shuid
= INSN_SHUID (lab
);
1079 if (min_align
> LABEL_TO_ALIGNMENT (lab
))
1080 min_align
= LABEL_TO_ALIGNMENT (lab
);
1082 XEXP (pat
, 2) = gen_rtx_LABEL_REF (Pmode
, min_lab
);
1083 XEXP (pat
, 3) = gen_rtx_LABEL_REF (Pmode
, max_lab
);
1084 insn_shuid
= INSN_SHUID (insn
);
1085 rel
= INSN_SHUID (XEXP (XEXP (pat
, 0), 0));
1086 memset (&flags
, 0, sizeof (flags
));
1087 flags
.min_align
= min_align
;
1088 flags
.base_after_vec
= rel
> insn_shuid
;
1089 flags
.min_after_vec
= min
> insn_shuid
;
1090 flags
.max_after_vec
= max
> insn_shuid
;
1091 flags
.min_after_base
= min
> rel
;
1092 flags
.max_after_base
= max
> rel
;
1093 ADDR_DIFF_VEC_FLAGS (pat
) = flags
;
1096 PUT_MODE (pat
, CASE_VECTOR_SHORTEN_MODE (0, 0, pat
));
1099 #endif /* CASE_VECTOR_SHORTEN_MODE */
1101 /* Compute initial lengths, addresses, and varying flags for each insn. */
1102 int (*length_fun
) (rtx
) = increasing
? insn_min_length
: insn_default_length
;
1104 for (insn_current_address
= 0, insn
= first
;
1106 insn_current_address
+= insn_lengths
[uid
], insn
= NEXT_INSN (insn
))
1108 uid
= INSN_UID (insn
);
1110 insn_lengths
[uid
] = 0;
1114 int log
= LABEL_TO_ALIGNMENT (insn
);
1117 int align
= 1 << log
;
1118 int new_address
= (insn_current_address
+ align
- 1) & -align
;
1119 insn_lengths
[uid
] = new_address
- insn_current_address
;
1123 INSN_ADDRESSES (uid
) = insn_current_address
+ insn_lengths
[uid
];
1125 if (NOTE_P (insn
) || BARRIER_P (insn
)
1126 || LABEL_P (insn
) || DEBUG_INSN_P(insn
))
1128 if (INSN_DELETED_P (insn
))
1131 body
= PATTERN (insn
);
1132 if (JUMP_TABLE_DATA_P (insn
))
1134 /* This only takes room if read-only data goes into the text
1136 if (JUMP_TABLES_IN_TEXT_SECTION
1137 || readonly_data_section
== text_section
)
1138 insn_lengths
[uid
] = (XVECLEN (body
,
1139 GET_CODE (body
) == ADDR_DIFF_VEC
)
1140 * GET_MODE_SIZE (GET_MODE (body
)));
1141 /* Alignment is handled by ADDR_VEC_ALIGN. */
1143 else if (GET_CODE (body
) == ASM_INPUT
|| asm_noperands (body
) >= 0)
1144 insn_lengths
[uid
] = asm_insn_count (body
) * insn_default_length (insn
);
1145 else if (GET_CODE (body
) == SEQUENCE
)
1148 int const_delay_slots
;
1150 const_delay_slots
= const_num_delay_slots (XVECEXP (body
, 0, 0));
1152 const_delay_slots
= 0;
1154 int (*inner_length_fun
) (rtx
)
1155 = const_delay_slots
? length_fun
: insn_default_length
;
1156 /* Inside a delay slot sequence, we do not do any branch shortening
1157 if the shortening could change the number of delay slots
1159 for (i
= 0; i
< XVECLEN (body
, 0); i
++)
1161 rtx inner_insn
= XVECEXP (body
, 0, i
);
1162 int inner_uid
= INSN_UID (inner_insn
);
1165 if (GET_CODE (body
) == ASM_INPUT
1166 || asm_noperands (PATTERN (XVECEXP (body
, 0, i
))) >= 0)
1167 inner_length
= (asm_insn_count (PATTERN (inner_insn
))
1168 * insn_default_length (inner_insn
));
1170 inner_length
= inner_length_fun (inner_insn
);
1172 insn_lengths
[inner_uid
] = inner_length
;
1173 if (const_delay_slots
)
1175 if ((varying_length
[inner_uid
]
1176 = insn_variable_length_p (inner_insn
)) != 0)
1177 varying_length
[uid
] = 1;
1178 INSN_ADDRESSES (inner_uid
) = (insn_current_address
1179 + insn_lengths
[uid
]);
1182 varying_length
[inner_uid
] = 0;
1183 insn_lengths
[uid
] += inner_length
;
1186 else if (GET_CODE (body
) != USE
&& GET_CODE (body
) != CLOBBER
)
1188 insn_lengths
[uid
] = length_fun (insn
);
1189 varying_length
[uid
] = insn_variable_length_p (insn
);
1192 /* If needed, do any adjustment. */
1193 #ifdef ADJUST_INSN_LENGTH
1194 ADJUST_INSN_LENGTH (insn
, insn_lengths
[uid
]);
1195 if (insn_lengths
[uid
] < 0)
1196 fatal_insn ("negative insn length", insn
);
1200 /* Now loop over all the insns finding varying length insns. For each,
1201 get the current insn length. If it has changed, reflect the change.
1202 When nothing changes for a full pass, we are done. */
1204 while (something_changed
)
1206 something_changed
= 0;
1207 insn_current_align
= MAX_CODE_ALIGN
- 1;
1208 for (insn_current_address
= 0, insn
= first
;
1210 insn
= NEXT_INSN (insn
))
1213 #ifdef ADJUST_INSN_LENGTH
1218 uid
= INSN_UID (insn
);
1222 int log
= LABEL_TO_ALIGNMENT (insn
);
1224 #ifdef CASE_VECTOR_SHORTEN_MODE
1225 /* If the mode of a following jump table was changed, we
1226 may need to update the alignment of this label. */
1228 bool next_is_jumptable
;
1230 next
= next_nonnote_insn (insn
);
1231 next_is_jumptable
= next
&& JUMP_TABLE_DATA_P (next
);
1232 if ((JUMP_TABLES_IN_TEXT_SECTION
1233 || readonly_data_section
== text_section
)
1234 && next_is_jumptable
)
1236 int newlog
= ADDR_VEC_ALIGN (next
);
1240 LABEL_TO_ALIGNMENT (insn
) = log
;
1241 something_changed
= 1;
1246 if (log
> insn_current_align
)
1248 int align
= 1 << log
;
1249 int new_address
= (insn_current_address
+ align
- 1) & -align
;
1250 insn_lengths
[uid
] = new_address
- insn_current_address
;
1251 insn_current_align
= log
;
1252 insn_current_address
= new_address
;
1255 insn_lengths
[uid
] = 0;
1256 INSN_ADDRESSES (uid
) = insn_current_address
;
1260 length_align
= INSN_LENGTH_ALIGNMENT (insn
);
1261 if (length_align
< insn_current_align
)
1262 insn_current_align
= length_align
;
1264 insn_last_address
= INSN_ADDRESSES (uid
);
1265 INSN_ADDRESSES (uid
) = insn_current_address
;
1267 #ifdef CASE_VECTOR_SHORTEN_MODE
1269 && JUMP_TABLE_DATA_P (insn
)
1270 && GET_CODE (PATTERN (insn
)) == ADDR_DIFF_VEC
)
1272 rtx body
= PATTERN (insn
);
1273 int old_length
= insn_lengths
[uid
];
1274 rtx rel_lab
= XEXP (XEXP (body
, 0), 0);
1275 rtx min_lab
= XEXP (XEXP (body
, 2), 0);
1276 rtx max_lab
= XEXP (XEXP (body
, 3), 0);
1277 int rel_addr
= INSN_ADDRESSES (INSN_UID (rel_lab
));
1278 int min_addr
= INSN_ADDRESSES (INSN_UID (min_lab
));
1279 int max_addr
= INSN_ADDRESSES (INSN_UID (max_lab
));
1282 addr_diff_vec_flags flags
;
1283 enum machine_mode vec_mode
;
1285 /* Avoid automatic aggregate initialization. */
1286 flags
= ADDR_DIFF_VEC_FLAGS (body
);
1288 /* Try to find a known alignment for rel_lab. */
1289 for (prev
= rel_lab
;
1291 && ! insn_lengths
[INSN_UID (prev
)]
1292 && ! (varying_length
[INSN_UID (prev
)] & 1);
1293 prev
= PREV_INSN (prev
))
1294 if (varying_length
[INSN_UID (prev
)] & 2)
1296 rel_align
= LABEL_TO_ALIGNMENT (prev
);
1300 /* See the comment on addr_diff_vec_flags in rtl.h for the
1301 meaning of the flags values. base: REL_LAB vec: INSN */
1302 /* Anything after INSN has still addresses from the last
1303 pass; adjust these so that they reflect our current
1304 estimate for this pass. */
1305 if (flags
.base_after_vec
)
1306 rel_addr
+= insn_current_address
- insn_last_address
;
1307 if (flags
.min_after_vec
)
1308 min_addr
+= insn_current_address
- insn_last_address
;
1309 if (flags
.max_after_vec
)
1310 max_addr
+= insn_current_address
- insn_last_address
;
1311 /* We want to know the worst case, i.e. lowest possible value
1312 for the offset of MIN_LAB. If MIN_LAB is after REL_LAB,
1313 its offset is positive, and we have to be wary of code shrink;
1314 otherwise, it is negative, and we have to be vary of code
1316 if (flags
.min_after_base
)
1318 /* If INSN is between REL_LAB and MIN_LAB, the size
1319 changes we are about to make can change the alignment
1320 within the observed offset, therefore we have to break
1321 it up into two parts that are independent. */
1322 if (! flags
.base_after_vec
&& flags
.min_after_vec
)
1324 min_addr
-= align_fuzz (rel_lab
, insn
, rel_align
, 0);
1325 min_addr
-= align_fuzz (insn
, min_lab
, 0, 0);
1328 min_addr
-= align_fuzz (rel_lab
, min_lab
, rel_align
, 0);
1332 if (flags
.base_after_vec
&& ! flags
.min_after_vec
)
1334 min_addr
-= align_fuzz (min_lab
, insn
, 0, ~0);
1335 min_addr
-= align_fuzz (insn
, rel_lab
, 0, ~0);
1338 min_addr
-= align_fuzz (min_lab
, rel_lab
, 0, ~0);
1340 /* Likewise, determine the highest lowest possible value
1341 for the offset of MAX_LAB. */
1342 if (flags
.max_after_base
)
1344 if (! flags
.base_after_vec
&& flags
.max_after_vec
)
1346 max_addr
+= align_fuzz (rel_lab
, insn
, rel_align
, ~0);
1347 max_addr
+= align_fuzz (insn
, max_lab
, 0, ~0);
1350 max_addr
+= align_fuzz (rel_lab
, max_lab
, rel_align
, ~0);
1354 if (flags
.base_after_vec
&& ! flags
.max_after_vec
)
1356 max_addr
+= align_fuzz (max_lab
, insn
, 0, 0);
1357 max_addr
+= align_fuzz (insn
, rel_lab
, 0, 0);
1360 max_addr
+= align_fuzz (max_lab
, rel_lab
, 0, 0);
1362 vec_mode
= CASE_VECTOR_SHORTEN_MODE (min_addr
- rel_addr
,
1363 max_addr
- rel_addr
, body
);
1365 || (GET_MODE_SIZE (vec_mode
)
1366 >= GET_MODE_SIZE (GET_MODE (body
))))
1367 PUT_MODE (body
, vec_mode
);
1368 if (JUMP_TABLES_IN_TEXT_SECTION
1369 || readonly_data_section
== text_section
)
1372 = (XVECLEN (body
, 1) * GET_MODE_SIZE (GET_MODE (body
)));
1373 insn_current_address
+= insn_lengths
[uid
];
1374 if (insn_lengths
[uid
] != old_length
)
1375 something_changed
= 1;
1380 #endif /* CASE_VECTOR_SHORTEN_MODE */
1382 if (! (varying_length
[uid
]))
1384 if (NONJUMP_INSN_P (insn
)
1385 && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1389 body
= PATTERN (insn
);
1390 for (i
= 0; i
< XVECLEN (body
, 0); i
++)
1392 rtx inner_insn
= XVECEXP (body
, 0, i
);
1393 int inner_uid
= INSN_UID (inner_insn
);
1395 INSN_ADDRESSES (inner_uid
) = insn_current_address
;
1397 insn_current_address
+= insn_lengths
[inner_uid
];
1401 insn_current_address
+= insn_lengths
[uid
];
1406 if (NONJUMP_INSN_P (insn
) && GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1410 body
= PATTERN (insn
);
1412 for (i
= 0; i
< XVECLEN (body
, 0); i
++)
1414 rtx inner_insn
= XVECEXP (body
, 0, i
);
1415 int inner_uid
= INSN_UID (inner_insn
);
1418 INSN_ADDRESSES (inner_uid
) = insn_current_address
;
1420 /* insn_current_length returns 0 for insns with a
1421 non-varying length. */
1422 if (! varying_length
[inner_uid
])
1423 inner_length
= insn_lengths
[inner_uid
];
1425 inner_length
= insn_current_length (inner_insn
);
1427 if (inner_length
!= insn_lengths
[inner_uid
])
1429 if (!increasing
|| inner_length
> insn_lengths
[inner_uid
])
1431 insn_lengths
[inner_uid
] = inner_length
;
1432 something_changed
= 1;
1435 inner_length
= insn_lengths
[inner_uid
];
1437 insn_current_address
+= inner_length
;
1438 new_length
+= inner_length
;
1443 new_length
= insn_current_length (insn
);
1444 insn_current_address
+= new_length
;
1447 #ifdef ADJUST_INSN_LENGTH
1448 /* If needed, do any adjustment. */
1449 tmp_length
= new_length
;
1450 ADJUST_INSN_LENGTH (insn
, new_length
);
1451 insn_current_address
+= (new_length
- tmp_length
);
1454 if (new_length
!= insn_lengths
[uid
]
1455 && (!increasing
|| new_length
> insn_lengths
[uid
]))
1457 insn_lengths
[uid
] = new_length
;
1458 something_changed
= 1;
1461 insn_current_address
+= insn_lengths
[uid
] - new_length
;
1463 /* For a non-optimizing compile, do only a single pass. */
1468 free (varying_length
);
1471 /* Given the body of an INSN known to be generated by an ASM statement, return
1472 the number of machine instructions likely to be generated for this insn.
1473 This is used to compute its length. */
1476 asm_insn_count (rtx body
)
1480 if (GET_CODE (body
) == ASM_INPUT
)
1481 templ
= XSTR (body
, 0);
1483 templ
= decode_asm_operands (body
, NULL
, NULL
, NULL
, NULL
, NULL
);
1485 return asm_str_count (templ
);
1488 /* Return the number of machine instructions likely to be generated for the
1489 inline-asm template. */
1491 asm_str_count (const char *templ
)
1498 for (; *templ
; templ
++)
1499 if (IS_ASM_LOGICAL_LINE_SEPARATOR (*templ
, templ
)
1506 /* ??? This is probably the wrong place for these. */
1507 /* Structure recording the mapping from source file and directory
1508 names at compile time to those to be embedded in debug
1510 typedef struct debug_prefix_map
1512 const char *old_prefix
;
1513 const char *new_prefix
;
1516 struct debug_prefix_map
*next
;
1519 /* Linked list of such structures. */
1520 static debug_prefix_map
*debug_prefix_maps
;
1523 /* Record a debug file prefix mapping. ARG is the argument to
1524 -fdebug-prefix-map and must be of the form OLD=NEW. */
1527 add_debug_prefix_map (const char *arg
)
1529 debug_prefix_map
*map
;
1532 p
= strchr (arg
, '=');
1535 error ("invalid argument %qs to -fdebug-prefix-map", arg
);
1538 map
= XNEW (debug_prefix_map
);
1539 map
->old_prefix
= xstrndup (arg
, p
- arg
);
1540 map
->old_len
= p
- arg
;
1542 map
->new_prefix
= xstrdup (p
);
1543 map
->new_len
= strlen (p
);
1544 map
->next
= debug_prefix_maps
;
1545 debug_prefix_maps
= map
;
1548 /* Perform user-specified mapping of debug filename prefixes. Return
1549 the new name corresponding to FILENAME. */
1552 remap_debug_filename (const char *filename
)
1554 debug_prefix_map
*map
;
1559 for (map
= debug_prefix_maps
; map
; map
= map
->next
)
1560 if (filename_ncmp (filename
, map
->old_prefix
, map
->old_len
) == 0)
1564 name
= filename
+ map
->old_len
;
1565 name_len
= strlen (name
) + 1;
1566 s
= (char *) alloca (name_len
+ map
->new_len
);
1567 memcpy (s
, map
->new_prefix
, map
->new_len
);
1568 memcpy (s
+ map
->new_len
, name
, name_len
);
1569 return ggc_strdup (s
);
1572 /* Return true if DWARF2 debug info can be emitted for DECL. */
1575 dwarf2_debug_info_emitted_p (tree decl
)
1577 if (write_symbols
!= DWARF2_DEBUG
&& write_symbols
!= VMS_AND_DWARF2_DEBUG
)
1580 if (DECL_IGNORED_P (decl
))
1586 /* Return scope resulting from combination of S1 and S2. */
1588 choose_inner_scope (tree s1
, tree s2
)
1594 if (BLOCK_NUMBER (s1
) > BLOCK_NUMBER (s2
))
1599 /* Emit lexical block notes needed to change scope from S1 to S2. */
1602 change_scope (rtx orig_insn
, tree s1
, tree s2
)
1604 rtx insn
= orig_insn
;
1605 tree com
= NULL_TREE
;
1606 tree ts1
= s1
, ts2
= s2
;
1611 gcc_assert (ts1
&& ts2
);
1612 if (BLOCK_NUMBER (ts1
) > BLOCK_NUMBER (ts2
))
1613 ts1
= BLOCK_SUPERCONTEXT (ts1
);
1614 else if (BLOCK_NUMBER (ts1
) < BLOCK_NUMBER (ts2
))
1615 ts2
= BLOCK_SUPERCONTEXT (ts2
);
1618 ts1
= BLOCK_SUPERCONTEXT (ts1
);
1619 ts2
= BLOCK_SUPERCONTEXT (ts2
);
1628 rtx note
= emit_note_before (NOTE_INSN_BLOCK_END
, insn
);
1629 NOTE_BLOCK (note
) = s
;
1630 s
= BLOCK_SUPERCONTEXT (s
);
1637 insn
= emit_note_before (NOTE_INSN_BLOCK_BEG
, insn
);
1638 NOTE_BLOCK (insn
) = s
;
1639 s
= BLOCK_SUPERCONTEXT (s
);
1643 /* Rebuild all the NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes based
1644 on the scope tree and the newly reordered instructions. */
1647 reemit_insn_block_notes (void)
1649 tree cur_block
= DECL_INITIAL (cfun
->decl
);
1652 insn
= get_insns ();
1653 for (; insn
; insn
= next_insn (insn
))
1657 /* Prevent lexical blocks from straddling section boundaries. */
1658 if (NOTE_P (insn
) && NOTE_KIND (insn
) == NOTE_INSN_SWITCH_TEXT_SECTIONS
)
1660 for (tree s
= cur_block
; s
!= DECL_INITIAL (cfun
->decl
);
1661 s
= BLOCK_SUPERCONTEXT (s
))
1663 rtx note
= emit_note_before (NOTE_INSN_BLOCK_END
, insn
);
1664 NOTE_BLOCK (note
) = s
;
1665 note
= emit_note_after (NOTE_INSN_BLOCK_BEG
, insn
);
1666 NOTE_BLOCK (note
) = s
;
1670 if (!active_insn_p (insn
))
1673 /* Avoid putting scope notes between jump table and its label. */
1674 if (JUMP_TABLE_DATA_P (insn
))
1677 this_block
= insn_scope (insn
);
1678 /* For sequences compute scope resulting from merging all scopes
1679 of instructions nested inside. */
1680 if (GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1683 rtx body
= PATTERN (insn
);
1686 for (i
= 0; i
< XVECLEN (body
, 0); i
++)
1687 this_block
= choose_inner_scope (this_block
,
1688 insn_scope (XVECEXP (body
, 0, i
)));
1692 if (INSN_LOCATION (insn
) == UNKNOWN_LOCATION
)
1695 this_block
= DECL_INITIAL (cfun
->decl
);
1698 if (this_block
!= cur_block
)
1700 change_scope (insn
, cur_block
, this_block
);
1701 cur_block
= this_block
;
1705 /* change_scope emits before the insn, not after. */
1706 note
= emit_note (NOTE_INSN_DELETED
);
1707 change_scope (note
, cur_block
, DECL_INITIAL (cfun
->decl
));
1713 /* Output assembler code for the start of a function,
1714 and initialize some of the variables in this file
1715 for the new function. The label for the function and associated
1716 assembler pseudo-ops have already been output in `assemble_start_function'.
1718 FIRST is the first insn of the rtl for the function being compiled.
1719 FILE is the file to write assembler code to.
1720 OPTIMIZE_P is nonzero if we should eliminate redundant
1721 test and compare insns. */
1724 final_start_function (rtx first
, FILE *file
,
1725 int optimize_p ATTRIBUTE_UNUSED
)
1729 this_is_asm_operands
= 0;
1731 need_profile_function
= false;
1733 last_filename
= LOCATION_FILE (prologue_location
);
1734 last_linenum
= LOCATION_LINE (prologue_location
);
1735 last_discriminator
= discriminator
= 0;
1737 high_block_linenum
= high_function_linenum
= last_linenum
;
1739 if (!DECL_IGNORED_P (current_function_decl
))
1740 debug_hooks
->begin_prologue (last_linenum
, last_filename
);
1742 if (!dwarf2_debug_info_emitted_p (current_function_decl
))
1743 dwarf2out_begin_prologue (0, NULL
);
1745 #ifdef LEAF_REG_REMAP
1746 if (crtl
->uses_only_leaf_regs
)
1747 leaf_renumber_regs (first
);
1750 /* The Sun386i and perhaps other machines don't work right
1751 if the profiling code comes after the prologue. */
1752 if (targetm
.profile_before_prologue () && crtl
->profile
)
1754 if (targetm
.asm_out
.function_prologue
1755 == default_function_pro_epilogue
1756 #ifdef HAVE_prologue
1762 for (insn
= first
; insn
; insn
= NEXT_INSN (insn
))
1768 else if (NOTE_KIND (insn
) == NOTE_INSN_BASIC_BLOCK
1769 || NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
)
1771 else if (NOTE_KIND (insn
) == NOTE_INSN_DELETED
1772 || NOTE_KIND (insn
) == NOTE_INSN_VAR_LOCATION
)
1781 need_profile_function
= true;
1783 profile_function (file
);
1786 profile_function (file
);
1789 /* If debugging, assign block numbers to all of the blocks in this
1793 reemit_insn_block_notes ();
1794 number_blocks (current_function_decl
);
1795 /* We never actually put out begin/end notes for the top-level
1796 block in the function. But, conceptually, that block is
1798 TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl
)) = 1;
1801 if (warn_frame_larger_than
1802 && get_frame_size () > frame_larger_than_size
)
1804 /* Issue a warning */
1805 warning (OPT_Wframe_larger_than_
,
1806 "the frame size of %wd bytes is larger than %wd bytes",
1807 get_frame_size (), frame_larger_than_size
);
1810 /* First output the function prologue: code to set up the stack frame. */
1811 targetm
.asm_out
.function_prologue (file
, get_frame_size ());
1813 /* If the machine represents the prologue as RTL, the profiling code must
1814 be emitted when NOTE_INSN_PROLOGUE_END is scanned. */
1815 #ifdef HAVE_prologue
1816 if (! HAVE_prologue
)
1818 profile_after_prologue (file
);
1822 profile_after_prologue (FILE *file ATTRIBUTE_UNUSED
)
1824 if (!targetm
.profile_before_prologue () && crtl
->profile
)
1825 profile_function (file
);
1829 profile_function (FILE *file ATTRIBUTE_UNUSED
)
1831 #ifndef NO_PROFILE_COUNTERS
1832 # define NO_PROFILE_COUNTERS 0
1834 #ifdef ASM_OUTPUT_REG_PUSH
1835 rtx sval
= NULL
, chain
= NULL
;
1837 if (cfun
->returns_struct
)
1838 sval
= targetm
.calls
.struct_value_rtx (TREE_TYPE (current_function_decl
),
1840 if (cfun
->static_chain_decl
)
1841 chain
= targetm
.calls
.static_chain (current_function_decl
, true);
1842 #endif /* ASM_OUTPUT_REG_PUSH */
1844 if (! NO_PROFILE_COUNTERS
)
1846 int align
= MIN (BIGGEST_ALIGNMENT
, LONG_TYPE_SIZE
);
1847 switch_to_section (data_section
);
1848 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
1849 targetm
.asm_out
.internal_label (file
, "LP", current_function_funcdef_no
);
1850 assemble_integer (const0_rtx
, LONG_TYPE_SIZE
/ BITS_PER_UNIT
, align
, 1);
1853 switch_to_section (current_function_section ());
1855 #ifdef ASM_OUTPUT_REG_PUSH
1856 if (sval
&& REG_P (sval
))
1857 ASM_OUTPUT_REG_PUSH (file
, REGNO (sval
));
1858 if (chain
&& REG_P (chain
))
1859 ASM_OUTPUT_REG_PUSH (file
, REGNO (chain
));
1862 FUNCTION_PROFILER (file
, current_function_funcdef_no
);
1864 #ifdef ASM_OUTPUT_REG_PUSH
1865 if (chain
&& REG_P (chain
))
1866 ASM_OUTPUT_REG_POP (file
, REGNO (chain
));
1867 if (sval
&& REG_P (sval
))
1868 ASM_OUTPUT_REG_POP (file
, REGNO (sval
));
1872 /* Output assembler code for the end of a function.
1873 For clarity, args are same as those of `final_start_function'
1874 even though not all of them are needed. */
1877 final_end_function (void)
1881 if (!DECL_IGNORED_P (current_function_decl
))
1882 debug_hooks
->end_function (high_function_linenum
);
1884 /* Finally, output the function epilogue:
1885 code to restore the stack frame and return to the caller. */
1886 targetm
.asm_out
.function_epilogue (asm_out_file
, get_frame_size ());
1888 /* And debug output. */
1889 if (!DECL_IGNORED_P (current_function_decl
))
1890 debug_hooks
->end_epilogue (last_linenum
, last_filename
);
1892 if (!dwarf2_debug_info_emitted_p (current_function_decl
)
1893 && dwarf2out_do_frame ())
1894 dwarf2out_end_epilogue (last_linenum
, last_filename
);
1898 /* Dumper helper for basic block information. FILE is the assembly
1899 output file, and INSN is the instruction being emitted. */
1902 dump_basic_block_info (FILE *file
, rtx insn
, basic_block
*start_to_bb
,
1903 basic_block
*end_to_bb
, int bb_map_size
, int *bb_seqn
)
1907 if (!flag_debug_asm
)
1910 if (INSN_UID (insn
) < bb_map_size
1911 && (bb
= start_to_bb
[INSN_UID (insn
)]) != NULL
)
1916 fprintf (file
, "%s BLOCK %d", ASM_COMMENT_START
, bb
->index
);
1918 fprintf (file
, " freq:%d", bb
->frequency
);
1920 fprintf (file
, " count:" HOST_WIDEST_INT_PRINT_DEC
,
1922 fprintf (file
, " seq:%d", (*bb_seqn
)++);
1923 fprintf (file
, "\n%s PRED:", ASM_COMMENT_START
);
1924 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1926 dump_edge_info (file
, e
, TDF_DETAILS
, 0);
1928 fprintf (file
, "\n");
1930 if (INSN_UID (insn
) < bb_map_size
1931 && (bb
= end_to_bb
[INSN_UID (insn
)]) != NULL
)
1936 fprintf (asm_out_file
, "%s SUCC:", ASM_COMMENT_START
);
1937 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1939 dump_edge_info (asm_out_file
, e
, TDF_DETAILS
, 1);
1941 fprintf (file
, "\n");
1945 /* Output assembler code for some insns: all or part of a function.
1946 For description of args, see `final_start_function', above. */
1949 final (rtx first
, FILE *file
, int optimize_p
)
1954 /* Used for -dA dump. */
1955 basic_block
*start_to_bb
= NULL
;
1956 basic_block
*end_to_bb
= NULL
;
1957 int bb_map_size
= 0;
1960 last_ignored_compare
= 0;
1963 for (insn
= first
; insn
; insn
= NEXT_INSN (insn
))
1965 /* If CC tracking across branches is enabled, record the insn which
1966 jumps to each branch only reached from one place. */
1967 if (optimize_p
&& JUMP_P (insn
))
1969 rtx lab
= JUMP_LABEL (insn
);
1970 if (lab
&& LABEL_P (lab
) && LABEL_NUSES (lab
) == 1)
1972 LABEL_REFS (lab
) = insn
;
1986 bb_map_size
= get_max_uid () + 1;
1987 start_to_bb
= XCNEWVEC (basic_block
, bb_map_size
);
1988 end_to_bb
= XCNEWVEC (basic_block
, bb_map_size
);
1990 /* There is no cfg for a thunk. */
1991 if (!cfun
->is_thunk
)
1992 FOR_EACH_BB_REVERSE (bb
)
1994 start_to_bb
[INSN_UID (BB_HEAD (bb
))] = bb
;
1995 end_to_bb
[INSN_UID (BB_END (bb
))] = bb
;
1999 /* Output the insns. */
2000 for (insn
= first
; insn
;)
2002 if (HAVE_ATTR_length
)
2004 if ((unsigned) INSN_UID (insn
) >= INSN_ADDRESSES_SIZE ())
2006 /* This can be triggered by bugs elsewhere in the compiler if
2007 new insns are created after init_insn_lengths is called. */
2008 gcc_assert (NOTE_P (insn
));
2009 insn_current_address
= -1;
2012 insn_current_address
= INSN_ADDRESSES (INSN_UID (insn
));
2015 dump_basic_block_info (file
, insn
, start_to_bb
, end_to_bb
,
2016 bb_map_size
, &bb_seqn
);
2017 insn
= final_scan_insn (insn
, file
, optimize_p
, 0, &seen
);
2026 /* Remove CFI notes, to avoid compare-debug failures. */
2027 for (insn
= first
; insn
; insn
= next
)
2029 next
= NEXT_INSN (insn
);
2031 && (NOTE_KIND (insn
) == NOTE_INSN_CFI
2032 || NOTE_KIND (insn
) == NOTE_INSN_CFI_LABEL
))
2038 get_insn_template (int code
, rtx insn
)
2040 switch (insn_data
[code
].output_format
)
2042 case INSN_OUTPUT_FORMAT_SINGLE
:
2043 return insn_data
[code
].output
.single
;
2044 case INSN_OUTPUT_FORMAT_MULTI
:
2045 return insn_data
[code
].output
.multi
[which_alternative
];
2046 case INSN_OUTPUT_FORMAT_FUNCTION
:
2048 return (*insn_data
[code
].output
.function
) (recog_data
.operand
, insn
);
2055 /* Emit the appropriate declaration for an alternate-entry-point
2056 symbol represented by INSN, to FILE. INSN is a CODE_LABEL with
2057 LABEL_KIND != LABEL_NORMAL.
2059 The case fall-through in this function is intentional. */
2061 output_alternate_entry_point (FILE *file
, rtx insn
)
2063 const char *name
= LABEL_NAME (insn
);
2065 switch (LABEL_KIND (insn
))
2067 case LABEL_WEAK_ENTRY
:
2068 #ifdef ASM_WEAKEN_LABEL
2069 ASM_WEAKEN_LABEL (file
, name
);
2071 case LABEL_GLOBAL_ENTRY
:
2072 targetm
.asm_out
.globalize_label (file
, name
);
2073 case LABEL_STATIC_ENTRY
:
2074 #ifdef ASM_OUTPUT_TYPE_DIRECTIVE
2075 ASM_OUTPUT_TYPE_DIRECTIVE (file
, name
, "function");
2077 ASM_OUTPUT_LABEL (file
, name
);
2086 /* Given a CALL_INSN, find and return the nested CALL. */
2088 call_from_call_insn (rtx insn
)
2091 gcc_assert (CALL_P (insn
));
2094 while (GET_CODE (x
) != CALL
)
2096 switch (GET_CODE (x
))
2101 x
= COND_EXEC_CODE (x
);
2104 x
= XVECEXP (x
, 0, 0);
2114 /* The final scan for one insn, INSN.
2115 Args are same as in `final', except that INSN
2116 is the insn being scanned.
2117 Value returned is the next insn to be scanned.
2119 NOPEEPHOLES is the flag to disallow peephole processing (currently
2120 used for within delayed branch sequence output).
2122 SEEN is used to track the end of the prologue, for emitting
2123 debug information. We force the emission of a line note after
2124 both NOTE_INSN_PROLOGUE_END and NOTE_INSN_FUNCTION_BEG, or
2125 at the beginning of the second basic block, whichever comes
2129 final_scan_insn (rtx insn
, FILE *file
, int optimize_p ATTRIBUTE_UNUSED
,
2130 int nopeepholes ATTRIBUTE_UNUSED
, int *seen
)
2139 /* Ignore deleted insns. These can occur when we split insns (due to a
2140 template of "#") while not optimizing. */
2141 if (INSN_DELETED_P (insn
))
2142 return NEXT_INSN (insn
);
2144 switch (GET_CODE (insn
))
2147 switch (NOTE_KIND (insn
))
2149 case NOTE_INSN_DELETED
:
2152 case NOTE_INSN_SWITCH_TEXT_SECTIONS
:
2153 in_cold_section_p
= !in_cold_section_p
;
2155 if (dwarf2out_do_frame ())
2156 dwarf2out_switch_text_section ();
2157 else if (!DECL_IGNORED_P (current_function_decl
))
2158 debug_hooks
->switch_text_section ();
2160 switch_to_section (current_function_section ());
2161 targetm
.asm_out
.function_switched_text_sections (asm_out_file
,
2162 current_function_decl
,
2166 case NOTE_INSN_BASIC_BLOCK
:
2167 if (need_profile_function
)
2169 profile_function (asm_out_file
);
2170 need_profile_function
= false;
2173 if (targetm
.asm_out
.unwind_emit
)
2174 targetm
.asm_out
.unwind_emit (asm_out_file
, insn
);
2176 if ((*seen
& (SEEN_EMITTED
| SEEN_BB
)) == SEEN_BB
)
2178 *seen
|= SEEN_EMITTED
;
2179 force_source_line
= true;
2184 discriminator
= NOTE_BASIC_BLOCK (insn
)->discriminator
;
2188 case NOTE_INSN_EH_REGION_BEG
:
2189 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LEHB",
2190 NOTE_EH_HANDLER (insn
));
2193 case NOTE_INSN_EH_REGION_END
:
2194 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LEHE",
2195 NOTE_EH_HANDLER (insn
));
2198 case NOTE_INSN_PROLOGUE_END
:
2199 targetm
.asm_out
.function_end_prologue (file
);
2200 profile_after_prologue (file
);
2202 if ((*seen
& (SEEN_EMITTED
| SEEN_NOTE
)) == SEEN_NOTE
)
2204 *seen
|= SEEN_EMITTED
;
2205 force_source_line
= true;
2212 case NOTE_INSN_EPILOGUE_BEG
:
2213 if (!DECL_IGNORED_P (current_function_decl
))
2214 (*debug_hooks
->begin_epilogue
) (last_linenum
, last_filename
);
2215 targetm
.asm_out
.function_begin_epilogue (file
);
2219 dwarf2out_emit_cfi (NOTE_CFI (insn
));
2222 case NOTE_INSN_CFI_LABEL
:
2223 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LCFI",
2224 NOTE_LABEL_NUMBER (insn
));
2227 case NOTE_INSN_FUNCTION_BEG
:
2228 if (need_profile_function
)
2230 profile_function (asm_out_file
);
2231 need_profile_function
= false;
2235 if (!DECL_IGNORED_P (current_function_decl
))
2236 debug_hooks
->end_prologue (last_linenum
, last_filename
);
2238 if ((*seen
& (SEEN_EMITTED
| SEEN_NOTE
)) == SEEN_NOTE
)
2240 *seen
|= SEEN_EMITTED
;
2241 force_source_line
= true;
2248 case NOTE_INSN_BLOCK_BEG
:
2249 if (debug_info_level
== DINFO_LEVEL_NORMAL
2250 || debug_info_level
== DINFO_LEVEL_VERBOSE
2251 || write_symbols
== DWARF2_DEBUG
2252 || write_symbols
== VMS_AND_DWARF2_DEBUG
2253 || write_symbols
== VMS_DEBUG
)
2255 int n
= BLOCK_NUMBER (NOTE_BLOCK (insn
));
2259 high_block_linenum
= last_linenum
;
2261 /* Output debugging info about the symbol-block beginning. */
2262 if (!DECL_IGNORED_P (current_function_decl
))
2263 debug_hooks
->begin_block (last_linenum
, n
);
2265 /* Mark this block as output. */
2266 TREE_ASM_WRITTEN (NOTE_BLOCK (insn
)) = 1;
2268 if (write_symbols
== DBX_DEBUG
2269 || write_symbols
== SDB_DEBUG
)
2271 location_t
*locus_ptr
2272 = block_nonartificial_location (NOTE_BLOCK (insn
));
2274 if (locus_ptr
!= NULL
)
2276 override_filename
= LOCATION_FILE (*locus_ptr
);
2277 override_linenum
= LOCATION_LINE (*locus_ptr
);
2282 case NOTE_INSN_BLOCK_END
:
2283 if (debug_info_level
== DINFO_LEVEL_NORMAL
2284 || debug_info_level
== DINFO_LEVEL_VERBOSE
2285 || write_symbols
== DWARF2_DEBUG
2286 || write_symbols
== VMS_AND_DWARF2_DEBUG
2287 || write_symbols
== VMS_DEBUG
)
2289 int n
= BLOCK_NUMBER (NOTE_BLOCK (insn
));
2293 /* End of a symbol-block. */
2295 gcc_assert (block_depth
>= 0);
2297 if (!DECL_IGNORED_P (current_function_decl
))
2298 debug_hooks
->end_block (high_block_linenum
, n
);
2300 if (write_symbols
== DBX_DEBUG
2301 || write_symbols
== SDB_DEBUG
)
2303 tree outer_block
= BLOCK_SUPERCONTEXT (NOTE_BLOCK (insn
));
2304 location_t
*locus_ptr
2305 = block_nonartificial_location (outer_block
);
2307 if (locus_ptr
!= NULL
)
2309 override_filename
= LOCATION_FILE (*locus_ptr
);
2310 override_linenum
= LOCATION_LINE (*locus_ptr
);
2314 override_filename
= NULL
;
2315 override_linenum
= 0;
2320 case NOTE_INSN_DELETED_LABEL
:
2321 /* Emit the label. We may have deleted the CODE_LABEL because
2322 the label could be proved to be unreachable, though still
2323 referenced (in the form of having its address taken. */
2324 ASM_OUTPUT_DEBUG_LABEL (file
, "L", CODE_LABEL_NUMBER (insn
));
2327 case NOTE_INSN_DELETED_DEBUG_LABEL
:
2328 /* Similarly, but need to use different namespace for it. */
2329 if (CODE_LABEL_NUMBER (insn
) != -1)
2330 ASM_OUTPUT_DEBUG_LABEL (file
, "LDL", CODE_LABEL_NUMBER (insn
));
2333 case NOTE_INSN_VAR_LOCATION
:
2334 case NOTE_INSN_CALL_ARG_LOCATION
:
2335 if (!DECL_IGNORED_P (current_function_decl
))
2336 debug_hooks
->var_location (insn
);
2349 /* The target port might emit labels in the output function for
2350 some insn, e.g. sh.c output_branchy_insn. */
2351 if (CODE_LABEL_NUMBER (insn
) <= max_labelno
)
2353 int align
= LABEL_TO_ALIGNMENT (insn
);
2354 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
2355 int max_skip
= LABEL_TO_MAX_SKIP (insn
);
2358 if (align
&& NEXT_INSN (insn
))
2360 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
2361 ASM_OUTPUT_MAX_SKIP_ALIGN (file
, align
, max_skip
);
2363 #ifdef ASM_OUTPUT_ALIGN_WITH_NOP
2364 ASM_OUTPUT_ALIGN_WITH_NOP (file
, align
);
2366 ASM_OUTPUT_ALIGN (file
, align
);
2373 if (!DECL_IGNORED_P (current_function_decl
) && LABEL_NAME (insn
))
2374 debug_hooks
->label (insn
);
2378 next
= next_nonnote_insn (insn
);
2379 /* If this label is followed by a jump-table, make sure we put
2380 the label in the read-only section. Also possibly write the
2381 label and jump table together. */
2382 if (next
!= 0 && JUMP_TABLE_DATA_P (next
))
2384 #if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2385 /* In this case, the case vector is being moved by the
2386 target, so don't output the label at all. Leave that
2387 to the back end macros. */
2389 if (! JUMP_TABLES_IN_TEXT_SECTION
)
2393 switch_to_section (targetm
.asm_out
.function_rodata_section
2394 (current_function_decl
));
2396 #ifdef ADDR_VEC_ALIGN
2397 log_align
= ADDR_VEC_ALIGN (next
);
2399 log_align
= exact_log2 (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
);
2401 ASM_OUTPUT_ALIGN (file
, log_align
);
2404 switch_to_section (current_function_section ());
2406 #ifdef ASM_OUTPUT_CASE_LABEL
2407 ASM_OUTPUT_CASE_LABEL (file
, "L", CODE_LABEL_NUMBER (insn
),
2410 targetm
.asm_out
.internal_label (file
, "L", CODE_LABEL_NUMBER (insn
));
2415 if (LABEL_ALT_ENTRY_P (insn
))
2416 output_alternate_entry_point (file
, insn
);
2418 targetm
.asm_out
.internal_label (file
, "L", CODE_LABEL_NUMBER (insn
));
2423 rtx body
= PATTERN (insn
);
2424 int insn_code_number
;
2428 /* Reset this early so it is correct for ASM statements. */
2429 current_insn_predicate
= NULL_RTX
;
2431 /* An INSN, JUMP_INSN or CALL_INSN.
2432 First check for special kinds that recog doesn't recognize. */
2434 if (GET_CODE (body
) == USE
/* These are just declarations. */
2435 || GET_CODE (body
) == CLOBBER
)
2440 /* If there is a REG_CC_SETTER note on this insn, it means that
2441 the setting of the condition code was done in the delay slot
2442 of the insn that branched here. So recover the cc status
2443 from the insn that set it. */
2445 rtx note
= find_reg_note (insn
, REG_CC_SETTER
, NULL_RTX
);
2448 NOTICE_UPDATE_CC (PATTERN (XEXP (note
, 0)), XEXP (note
, 0));
2449 cc_prev_status
= cc_status
;
2454 /* Detect insns that are really jump-tables
2455 and output them as such. */
2457 if (JUMP_TABLE_DATA_P (insn
))
2459 #if !(defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC))
2463 if (! JUMP_TABLES_IN_TEXT_SECTION
)
2464 switch_to_section (targetm
.asm_out
.function_rodata_section
2465 (current_function_decl
));
2467 switch_to_section (current_function_section ());
2471 #if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2472 if (GET_CODE (body
) == ADDR_VEC
)
2474 #ifdef ASM_OUTPUT_ADDR_VEC
2475 ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn
), body
);
2482 #ifdef ASM_OUTPUT_ADDR_DIFF_VEC
2483 ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn
), body
);
2489 vlen
= XVECLEN (body
, GET_CODE (body
) == ADDR_DIFF_VEC
);
2490 for (idx
= 0; idx
< vlen
; idx
++)
2492 if (GET_CODE (body
) == ADDR_VEC
)
2494 #ifdef ASM_OUTPUT_ADDR_VEC_ELT
2495 ASM_OUTPUT_ADDR_VEC_ELT
2496 (file
, CODE_LABEL_NUMBER (XEXP (XVECEXP (body
, 0, idx
), 0)));
2503 #ifdef ASM_OUTPUT_ADDR_DIFF_ELT
2504 ASM_OUTPUT_ADDR_DIFF_ELT
2507 CODE_LABEL_NUMBER (XEXP (XVECEXP (body
, 1, idx
), 0)),
2508 CODE_LABEL_NUMBER (XEXP (XEXP (body
, 0), 0)));
2514 #ifdef ASM_OUTPUT_CASE_END
2515 ASM_OUTPUT_CASE_END (file
,
2516 CODE_LABEL_NUMBER (PREV_INSN (insn
)),
2521 switch_to_section (current_function_section ());
2525 /* Output this line note if it is the first or the last line
2527 if (!DECL_IGNORED_P (current_function_decl
)
2528 && notice_source_line (insn
, &is_stmt
))
2529 (*debug_hooks
->source_line
) (last_linenum
, last_filename
,
2530 last_discriminator
, is_stmt
);
2532 if (GET_CODE (body
) == ASM_INPUT
)
2534 const char *string
= XSTR (body
, 0);
2536 /* There's no telling what that did to the condition codes. */
2541 expanded_location loc
;
2544 loc
= expand_location (ASM_INPUT_SOURCE_LOCATION (body
));
2545 if (*loc
.file
&& loc
.line
)
2546 fprintf (asm_out_file
, "%s %i \"%s\" 1\n",
2547 ASM_COMMENT_START
, loc
.line
, loc
.file
);
2548 fprintf (asm_out_file
, "\t%s\n", string
);
2549 #if HAVE_AS_LINE_ZERO
2550 if (*loc
.file
&& loc
.line
)
2551 fprintf (asm_out_file
, "%s 0 \"\" 2\n", ASM_COMMENT_START
);
2557 /* Detect `asm' construct with operands. */
2558 if (asm_noperands (body
) >= 0)
2560 unsigned int noperands
= asm_noperands (body
);
2561 rtx
*ops
= XALLOCAVEC (rtx
, noperands
);
2564 expanded_location expanded
;
2566 /* There's no telling what that did to the condition codes. */
2569 /* Get out the operand values. */
2570 string
= decode_asm_operands (body
, ops
, NULL
, NULL
, NULL
, &loc
);
2571 /* Inhibit dying on what would otherwise be compiler bugs. */
2572 insn_noperands
= noperands
;
2573 this_is_asm_operands
= insn
;
2574 expanded
= expand_location (loc
);
2576 #ifdef FINAL_PRESCAN_INSN
2577 FINAL_PRESCAN_INSN (insn
, ops
, insn_noperands
);
2580 /* Output the insn using them. */
2584 if (expanded
.file
&& expanded
.line
)
2585 fprintf (asm_out_file
, "%s %i \"%s\" 1\n",
2586 ASM_COMMENT_START
, expanded
.line
, expanded
.file
);
2587 output_asm_insn (string
, ops
);
2588 #if HAVE_AS_LINE_ZERO
2589 if (expanded
.file
&& expanded
.line
)
2590 fprintf (asm_out_file
, "%s 0 \"\" 2\n", ASM_COMMENT_START
);
2594 if (targetm
.asm_out
.final_postscan_insn
)
2595 targetm
.asm_out
.final_postscan_insn (file
, insn
, ops
,
2598 this_is_asm_operands
= 0;
2604 if (GET_CODE (body
) == SEQUENCE
)
2606 /* A delayed-branch sequence */
2609 final_sequence
= body
;
2611 /* The first insn in this SEQUENCE might be a JUMP_INSN that will
2612 force the restoration of a comparison that was previously
2613 thought unnecessary. If that happens, cancel this sequence
2614 and cause that insn to be restored. */
2616 next
= final_scan_insn (XVECEXP (body
, 0, 0), file
, 0, 1, seen
);
2617 if (next
!= XVECEXP (body
, 0, 1))
2623 for (i
= 1; i
< XVECLEN (body
, 0); i
++)
2625 rtx insn
= XVECEXP (body
, 0, i
);
2626 rtx next
= NEXT_INSN (insn
);
2627 /* We loop in case any instruction in a delay slot gets
2630 insn
= final_scan_insn (insn
, file
, 0, 1, seen
);
2631 while (insn
!= next
);
2633 #ifdef DBR_OUTPUT_SEQEND
2634 DBR_OUTPUT_SEQEND (file
);
2638 /* If the insn requiring the delay slot was a CALL_INSN, the
2639 insns in the delay slot are actually executed before the
2640 called function. Hence we don't preserve any CC-setting
2641 actions in these insns and the CC must be marked as being
2642 clobbered by the function. */
2643 if (CALL_P (XVECEXP (body
, 0, 0)))
2650 /* We have a real machine instruction as rtl. */
2652 body
= PATTERN (insn
);
2655 set
= single_set (insn
);
2657 /* Check for redundant test and compare instructions
2658 (when the condition codes are already set up as desired).
2659 This is done only when optimizing; if not optimizing,
2660 it should be possible for the user to alter a variable
2661 with the debugger in between statements
2662 and the next statement should reexamine the variable
2663 to compute the condition codes. */
2668 && GET_CODE (SET_DEST (set
)) == CC0
2669 && insn
!= last_ignored_compare
)
2672 if (GET_CODE (SET_SRC (set
)) == SUBREG
)
2673 SET_SRC (set
) = alter_subreg (&SET_SRC (set
), true);
2675 src1
= SET_SRC (set
);
2677 if (GET_CODE (SET_SRC (set
)) == COMPARE
)
2679 if (GET_CODE (XEXP (SET_SRC (set
), 0)) == SUBREG
)
2680 XEXP (SET_SRC (set
), 0)
2681 = alter_subreg (&XEXP (SET_SRC (set
), 0), true);
2682 if (GET_CODE (XEXP (SET_SRC (set
), 1)) == SUBREG
)
2683 XEXP (SET_SRC (set
), 1)
2684 = alter_subreg (&XEXP (SET_SRC (set
), 1), true);
2685 if (XEXP (SET_SRC (set
), 1)
2686 == CONST0_RTX (GET_MODE (XEXP (SET_SRC (set
), 0))))
2687 src2
= XEXP (SET_SRC (set
), 0);
2689 if ((cc_status
.value1
!= 0
2690 && rtx_equal_p (src1
, cc_status
.value1
))
2691 || (cc_status
.value2
!= 0
2692 && rtx_equal_p (src1
, cc_status
.value2
))
2693 || (src2
!= 0 && cc_status
.value1
!= 0
2694 && rtx_equal_p (src2
, cc_status
.value1
))
2695 || (src2
!= 0 && cc_status
.value2
!= 0
2696 && rtx_equal_p (src2
, cc_status
.value2
)))
2698 /* Don't delete insn if it has an addressing side-effect. */
2699 if (! FIND_REG_INC_NOTE (insn
, NULL_RTX
)
2700 /* or if anything in it is volatile. */
2701 && ! volatile_refs_p (PATTERN (insn
)))
2703 /* We don't really delete the insn; just ignore it. */
2704 last_ignored_compare
= insn
;
2711 /* If this is a conditional branch, maybe modify it
2712 if the cc's are in a nonstandard state
2713 so that it accomplishes the same thing that it would
2714 do straightforwardly if the cc's were set up normally. */
2716 if (cc_status
.flags
!= 0
2718 && GET_CODE (body
) == SET
2719 && SET_DEST (body
) == pc_rtx
2720 && GET_CODE (SET_SRC (body
)) == IF_THEN_ELSE
2721 && COMPARISON_P (XEXP (SET_SRC (body
), 0))
2722 && XEXP (XEXP (SET_SRC (body
), 0), 0) == cc0_rtx
)
2724 /* This function may alter the contents of its argument
2725 and clear some of the cc_status.flags bits.
2726 It may also return 1 meaning condition now always true
2727 or -1 meaning condition now always false
2728 or 2 meaning condition nontrivial but altered. */
2729 int result
= alter_cond (XEXP (SET_SRC (body
), 0));
2730 /* If condition now has fixed value, replace the IF_THEN_ELSE
2731 with its then-operand or its else-operand. */
2733 SET_SRC (body
) = XEXP (SET_SRC (body
), 1);
2735 SET_SRC (body
) = XEXP (SET_SRC (body
), 2);
2737 /* The jump is now either unconditional or a no-op.
2738 If it has become a no-op, don't try to output it.
2739 (It would not be recognized.) */
2740 if (SET_SRC (body
) == pc_rtx
)
2745 else if (ANY_RETURN_P (SET_SRC (body
)))
2746 /* Replace (set (pc) (return)) with (return). */
2747 PATTERN (insn
) = body
= SET_SRC (body
);
2749 /* Rerecognize the instruction if it has changed. */
2751 INSN_CODE (insn
) = -1;
2754 /* If this is a conditional trap, maybe modify it if the cc's
2755 are in a nonstandard state so that it accomplishes the same
2756 thing that it would do straightforwardly if the cc's were
2758 if (cc_status
.flags
!= 0
2759 && NONJUMP_INSN_P (insn
)
2760 && GET_CODE (body
) == TRAP_IF
2761 && COMPARISON_P (TRAP_CONDITION (body
))
2762 && XEXP (TRAP_CONDITION (body
), 0) == cc0_rtx
)
2764 /* This function may alter the contents of its argument
2765 and clear some of the cc_status.flags bits.
2766 It may also return 1 meaning condition now always true
2767 or -1 meaning condition now always false
2768 or 2 meaning condition nontrivial but altered. */
2769 int result
= alter_cond (TRAP_CONDITION (body
));
2771 /* If TRAP_CONDITION has become always false, delete the
2779 /* If TRAP_CONDITION has become always true, replace
2780 TRAP_CONDITION with const_true_rtx. */
2782 TRAP_CONDITION (body
) = const_true_rtx
;
2784 /* Rerecognize the instruction if it has changed. */
2786 INSN_CODE (insn
) = -1;
2789 /* Make same adjustments to instructions that examine the
2790 condition codes without jumping and instructions that
2791 handle conditional moves (if this machine has either one). */
2793 if (cc_status
.flags
!= 0
2796 rtx cond_rtx
, then_rtx
, else_rtx
;
2799 && GET_CODE (SET_SRC (set
)) == IF_THEN_ELSE
)
2801 cond_rtx
= XEXP (SET_SRC (set
), 0);
2802 then_rtx
= XEXP (SET_SRC (set
), 1);
2803 else_rtx
= XEXP (SET_SRC (set
), 2);
2807 cond_rtx
= SET_SRC (set
);
2808 then_rtx
= const_true_rtx
;
2809 else_rtx
= const0_rtx
;
2812 if (COMPARISON_P (cond_rtx
)
2813 && XEXP (cond_rtx
, 0) == cc0_rtx
)
2816 result
= alter_cond (cond_rtx
);
2818 validate_change (insn
, &SET_SRC (set
), then_rtx
, 0);
2819 else if (result
== -1)
2820 validate_change (insn
, &SET_SRC (set
), else_rtx
, 0);
2821 else if (result
== 2)
2822 INSN_CODE (insn
) = -1;
2823 if (SET_DEST (set
) == SET_SRC (set
))
2830 #ifdef HAVE_peephole
2831 /* Do machine-specific peephole optimizations if desired. */
2833 if (optimize_p
&& !flag_no_peephole
&& !nopeepholes
)
2835 rtx next
= peephole (insn
);
2836 /* When peepholing, if there were notes within the peephole,
2837 emit them before the peephole. */
2838 if (next
!= 0 && next
!= NEXT_INSN (insn
))
2840 rtx note
, prev
= PREV_INSN (insn
);
2842 for (note
= NEXT_INSN (insn
); note
!= next
;
2843 note
= NEXT_INSN (note
))
2844 final_scan_insn (note
, file
, optimize_p
, nopeepholes
, seen
);
2846 /* Put the notes in the proper position for a later
2847 rescan. For example, the SH target can do this
2848 when generating a far jump in a delayed branch
2850 note
= NEXT_INSN (insn
);
2851 PREV_INSN (note
) = prev
;
2852 NEXT_INSN (prev
) = note
;
2853 NEXT_INSN (PREV_INSN (next
)) = insn
;
2854 PREV_INSN (insn
) = PREV_INSN (next
);
2855 NEXT_INSN (insn
) = next
;
2856 PREV_INSN (next
) = insn
;
2859 /* PEEPHOLE might have changed this. */
2860 body
= PATTERN (insn
);
2864 /* Try to recognize the instruction.
2865 If successful, verify that the operands satisfy the
2866 constraints for the instruction. Crash if they don't,
2867 since `reload' should have changed them so that they do. */
2869 insn_code_number
= recog_memoized (insn
);
2870 cleanup_subreg_operands (insn
);
2872 /* Dump the insn in the assembly for debugging (-dAP).
2873 If the final dump is requested as slim RTL, dump slim
2874 RTL to the assembly file also. */
2875 if (flag_dump_rtl_in_asm
)
2877 print_rtx_head
= ASM_COMMENT_START
;
2878 if (! (dump_flags
& TDF_SLIM
))
2879 print_rtl_single (asm_out_file
, insn
);
2881 dump_insn_slim (asm_out_file
, insn
);
2882 print_rtx_head
= "";
2885 if (! constrain_operands_cached (1))
2886 fatal_insn_not_found (insn
);
2888 /* Some target machines need to prescan each insn before
2891 #ifdef FINAL_PRESCAN_INSN
2892 FINAL_PRESCAN_INSN (insn
, recog_data
.operand
, recog_data
.n_operands
);
2895 if (targetm
.have_conditional_execution ()
2896 && GET_CODE (PATTERN (insn
)) == COND_EXEC
)
2897 current_insn_predicate
= COND_EXEC_TEST (PATTERN (insn
));
2900 cc_prev_status
= cc_status
;
2902 /* Update `cc_status' for this instruction.
2903 The instruction's output routine may change it further.
2904 If the output routine for a jump insn needs to depend
2905 on the cc status, it should look at cc_prev_status. */
2907 NOTICE_UPDATE_CC (body
, insn
);
2910 current_output_insn
= debug_insn
= insn
;
2912 /* Find the proper template for this insn. */
2913 templ
= get_insn_template (insn_code_number
, insn
);
2915 /* If the C code returns 0, it means that it is a jump insn
2916 which follows a deleted test insn, and that test insn
2917 needs to be reinserted. */
2922 gcc_assert (prev_nonnote_insn (insn
) == last_ignored_compare
);
2924 /* We have already processed the notes between the setter and
2925 the user. Make sure we don't process them again, this is
2926 particularly important if one of the notes is a block
2927 scope note or an EH note. */
2929 prev
!= last_ignored_compare
;
2930 prev
= PREV_INSN (prev
))
2933 delete_insn (prev
); /* Use delete_note. */
2939 /* If the template is the string "#", it means that this insn must
2941 if (templ
[0] == '#' && templ
[1] == '\0')
2943 rtx new_rtx
= try_split (body
, insn
, 0);
2945 /* If we didn't split the insn, go away. */
2946 if (new_rtx
== insn
&& PATTERN (new_rtx
) == body
)
2947 fatal_insn ("could not split insn", insn
);
2949 /* If we have a length attribute, this instruction should have
2950 been split in shorten_branches, to ensure that we would have
2951 valid length info for the splitees. */
2952 gcc_assert (!HAVE_ATTR_length
);
2957 /* ??? This will put the directives in the wrong place if
2958 get_insn_template outputs assembly directly. However calling it
2959 before get_insn_template breaks if the insns is split. */
2960 if (targetm
.asm_out
.unwind_emit_before_insn
2961 && targetm
.asm_out
.unwind_emit
)
2962 targetm
.asm_out
.unwind_emit (asm_out_file
, insn
);
2966 rtx x
= call_from_call_insn (insn
);
2968 if (x
&& MEM_P (x
) && GET_CODE (XEXP (x
, 0)) == SYMBOL_REF
)
2972 t
= SYMBOL_REF_DECL (x
);
2974 assemble_external (t
);
2976 if (!DECL_IGNORED_P (current_function_decl
))
2977 debug_hooks
->var_location (insn
);
2980 /* Output assembler code from the template. */
2981 output_asm_insn (templ
, recog_data
.operand
);
2983 /* Some target machines need to postscan each insn after
2985 if (targetm
.asm_out
.final_postscan_insn
)
2986 targetm
.asm_out
.final_postscan_insn (file
, insn
, recog_data
.operand
,
2987 recog_data
.n_operands
);
2989 if (!targetm
.asm_out
.unwind_emit_before_insn
2990 && targetm
.asm_out
.unwind_emit
)
2991 targetm
.asm_out
.unwind_emit (asm_out_file
, insn
);
2993 current_output_insn
= debug_insn
= 0;
2996 return NEXT_INSN (insn
);
2999 /* Return whether a source line note needs to be emitted before INSN.
3000 Sets IS_STMT to TRUE if the line should be marked as a possible
3001 breakpoint location. */
3004 notice_source_line (rtx insn
, bool *is_stmt
)
3006 const char *filename
;
3009 if (override_filename
)
3011 filename
= override_filename
;
3012 linenum
= override_linenum
;
3016 filename
= insn_file (insn
);
3017 linenum
= insn_line (insn
);
3020 if (filename
== NULL
)
3023 if (force_source_line
3024 || filename
!= last_filename
3025 || last_linenum
!= linenum
)
3027 force_source_line
= false;
3028 last_filename
= filename
;
3029 last_linenum
= linenum
;
3030 last_discriminator
= discriminator
;
3032 high_block_linenum
= MAX (last_linenum
, high_block_linenum
);
3033 high_function_linenum
= MAX (last_linenum
, high_function_linenum
);
3037 if (SUPPORTS_DISCRIMINATOR
&& last_discriminator
!= discriminator
)
3039 /* If the discriminator changed, but the line number did not,
3040 output the line table entry with is_stmt false so the
3041 debugger does not treat this as a breakpoint location. */
3042 last_discriminator
= discriminator
;
3050 /* For each operand in INSN, simplify (subreg (reg)) so that it refers
3051 directly to the desired hard register. */
3054 cleanup_subreg_operands (rtx insn
)
3057 bool changed
= false;
3058 extract_insn_cached (insn
);
3059 for (i
= 0; i
< recog_data
.n_operands
; i
++)
3061 /* The following test cannot use recog_data.operand when testing
3062 for a SUBREG: the underlying object might have been changed
3063 already if we are inside a match_operator expression that
3064 matches the else clause. Instead we test the underlying
3065 expression directly. */
3066 if (GET_CODE (*recog_data
.operand_loc
[i
]) == SUBREG
)
3068 recog_data
.operand
[i
] = alter_subreg (recog_data
.operand_loc
[i
], true);
3071 else if (GET_CODE (recog_data
.operand
[i
]) == PLUS
3072 || GET_CODE (recog_data
.operand
[i
]) == MULT
3073 || MEM_P (recog_data
.operand
[i
]))
3074 recog_data
.operand
[i
] = walk_alter_subreg (recog_data
.operand_loc
[i
], &changed
);
3077 for (i
= 0; i
< recog_data
.n_dups
; i
++)
3079 if (GET_CODE (*recog_data
.dup_loc
[i
]) == SUBREG
)
3081 *recog_data
.dup_loc
[i
] = alter_subreg (recog_data
.dup_loc
[i
], true);
3084 else if (GET_CODE (*recog_data
.dup_loc
[i
]) == PLUS
3085 || GET_CODE (*recog_data
.dup_loc
[i
]) == MULT
3086 || MEM_P (*recog_data
.dup_loc
[i
]))
3087 *recog_data
.dup_loc
[i
] = walk_alter_subreg (recog_data
.dup_loc
[i
], &changed
);
3090 df_insn_rescan (insn
);
3093 /* If X is a SUBREG, try to replace it with a REG or a MEM, based on
3094 the thing it is a subreg of. Do it anyway if FINAL_P. */
3097 alter_subreg (rtx
*xp
, bool final_p
)
3100 rtx y
= SUBREG_REG (x
);
3102 /* simplify_subreg does not remove subreg from volatile references.
3103 We are required to. */
3106 int offset
= SUBREG_BYTE (x
);
3108 /* For paradoxical subregs on big-endian machines, SUBREG_BYTE
3109 contains 0 instead of the proper offset. See simplify_subreg. */
3111 && GET_MODE_SIZE (GET_MODE (y
)) < GET_MODE_SIZE (GET_MODE (x
)))
3113 int difference
= GET_MODE_SIZE (GET_MODE (y
))
3114 - GET_MODE_SIZE (GET_MODE (x
));
3115 if (WORDS_BIG_ENDIAN
)
3116 offset
+= (difference
/ UNITS_PER_WORD
) * UNITS_PER_WORD
;
3117 if (BYTES_BIG_ENDIAN
)
3118 offset
+= difference
% UNITS_PER_WORD
;
3122 *xp
= adjust_address (y
, GET_MODE (x
), offset
);
3124 *xp
= adjust_address_nv (y
, GET_MODE (x
), offset
);
3128 rtx new_rtx
= simplify_subreg (GET_MODE (x
), y
, GET_MODE (y
),
3133 else if (final_p
&& REG_P (y
))
3135 /* Simplify_subreg can't handle some REG cases, but we have to. */
3137 HOST_WIDE_INT offset
;
3139 regno
= subreg_regno (x
);
3140 if (subreg_lowpart_p (x
))
3141 offset
= byte_lowpart_offset (GET_MODE (x
), GET_MODE (y
));
3143 offset
= SUBREG_BYTE (x
);
3144 *xp
= gen_rtx_REG_offset (y
, GET_MODE (x
), regno
, offset
);
3151 /* Do alter_subreg on all the SUBREGs contained in X. */
3154 walk_alter_subreg (rtx
*xp
, bool *changed
)
3157 switch (GET_CODE (x
))
3162 XEXP (x
, 0) = walk_alter_subreg (&XEXP (x
, 0), changed
);
3163 XEXP (x
, 1) = walk_alter_subreg (&XEXP (x
, 1), changed
);
3168 XEXP (x
, 0) = walk_alter_subreg (&XEXP (x
, 0), changed
);
3173 return alter_subreg (xp
, true);
3184 /* Given BODY, the body of a jump instruction, alter the jump condition
3185 as required by the bits that are set in cc_status.flags.
3186 Not all of the bits there can be handled at this level in all cases.
3188 The value is normally 0.
3189 1 means that the condition has become always true.
3190 -1 means that the condition has become always false.
3191 2 means that COND has been altered. */
3194 alter_cond (rtx cond
)
3198 if (cc_status
.flags
& CC_REVERSED
)
3201 PUT_CODE (cond
, swap_condition (GET_CODE (cond
)));
3204 if (cc_status
.flags
& CC_INVERTED
)
3207 PUT_CODE (cond
, reverse_condition (GET_CODE (cond
)));
3210 if (cc_status
.flags
& CC_NOT_POSITIVE
)
3211 switch (GET_CODE (cond
))
3216 /* Jump becomes unconditional. */
3222 /* Jump becomes no-op. */
3226 PUT_CODE (cond
, EQ
);
3231 PUT_CODE (cond
, NE
);
3239 if (cc_status
.flags
& CC_NOT_NEGATIVE
)
3240 switch (GET_CODE (cond
))
3244 /* Jump becomes unconditional. */
3249 /* Jump becomes no-op. */
3254 PUT_CODE (cond
, EQ
);
3260 PUT_CODE (cond
, NE
);
3268 if (cc_status
.flags
& CC_NO_OVERFLOW
)
3269 switch (GET_CODE (cond
))
3272 /* Jump becomes unconditional. */
3276 PUT_CODE (cond
, EQ
);
3281 PUT_CODE (cond
, NE
);
3286 /* Jump becomes no-op. */
3293 if (cc_status
.flags
& (CC_Z_IN_NOT_N
| CC_Z_IN_N
))
3294 switch (GET_CODE (cond
))
3300 PUT_CODE (cond
, cc_status
.flags
& CC_Z_IN_N
? GE
: LT
);
3305 PUT_CODE (cond
, cc_status
.flags
& CC_Z_IN_N
? LT
: GE
);
3310 if (cc_status
.flags
& CC_NOT_SIGNED
)
3311 /* The flags are valid if signed condition operators are converted
3313 switch (GET_CODE (cond
))
3316 PUT_CODE (cond
, LEU
);
3321 PUT_CODE (cond
, LTU
);
3326 PUT_CODE (cond
, GTU
);
3331 PUT_CODE (cond
, GEU
);
3343 /* Report inconsistency between the assembler template and the operands.
3344 In an `asm', it's the user's fault; otherwise, the compiler's fault. */
3347 output_operand_lossage (const char *cmsgid
, ...)
3351 const char *pfx_str
;
3354 va_start (ap
, cmsgid
);
3356 pfx_str
= this_is_asm_operands
? _("invalid 'asm': ") : "output_operand: ";
3357 asprintf (&fmt_string
, "%s%s", pfx_str
, _(cmsgid
));
3358 vasprintf (&new_message
, fmt_string
, ap
);
3360 if (this_is_asm_operands
)
3361 error_for_asm (this_is_asm_operands
, "%s", new_message
);
3363 internal_error ("%s", new_message
);
3370 /* Output of assembler code from a template, and its subroutines. */
3372 /* Annotate the assembly with a comment describing the pattern and
3373 alternative used. */
3376 output_asm_name (void)
3380 int num
= INSN_CODE (debug_insn
);
3381 fprintf (asm_out_file
, "\t%s %d\t%s",
3382 ASM_COMMENT_START
, INSN_UID (debug_insn
),
3383 insn_data
[num
].name
);
3384 if (insn_data
[num
].n_alternatives
> 1)
3385 fprintf (asm_out_file
, "/%d", which_alternative
+ 1);
3387 if (HAVE_ATTR_length
)
3388 fprintf (asm_out_file
, "\t[length = %d]",
3389 get_attr_length (debug_insn
));
3391 /* Clear this so only the first assembler insn
3392 of any rtl insn will get the special comment for -dp. */
3397 /* If OP is a REG or MEM and we can find a MEM_EXPR corresponding to it
3398 or its address, return that expr . Set *PADDRESSP to 1 if the expr
3399 corresponds to the address of the object and 0 if to the object. */
3402 get_mem_expr_from_op (rtx op
, int *paddressp
)
3410 return REG_EXPR (op
);
3411 else if (!MEM_P (op
))
3414 if (MEM_EXPR (op
) != 0)
3415 return MEM_EXPR (op
);
3417 /* Otherwise we have an address, so indicate it and look at the address. */
3421 /* First check if we have a decl for the address, then look at the right side
3422 if it is a PLUS. Otherwise, strip off arithmetic and keep looking.
3423 But don't allow the address to itself be indirect. */
3424 if ((expr
= get_mem_expr_from_op (op
, &inner_addressp
)) && ! inner_addressp
)
3426 else if (GET_CODE (op
) == PLUS
3427 && (expr
= get_mem_expr_from_op (XEXP (op
, 1), &inner_addressp
)))
3431 || GET_RTX_CLASS (GET_CODE (op
)) == RTX_BIN_ARITH
)
3434 expr
= get_mem_expr_from_op (op
, &inner_addressp
);
3435 return inner_addressp
? 0 : expr
;
3438 /* Output operand names for assembler instructions. OPERANDS is the
3439 operand vector, OPORDER is the order to write the operands, and NOPS
3440 is the number of operands to write. */
3443 output_asm_operand_names (rtx
*operands
, int *oporder
, int nops
)
3448 for (i
= 0; i
< nops
; i
++)
3451 rtx op
= operands
[oporder
[i
]];
3452 tree expr
= get_mem_expr_from_op (op
, &addressp
);
3454 fprintf (asm_out_file
, "%c%s",
3455 wrote
? ',' : '\t', wrote
? "" : ASM_COMMENT_START
);
3459 fprintf (asm_out_file
, "%s",
3460 addressp
? "*" : "");
3461 print_mem_expr (asm_out_file
, expr
);
3464 else if (REG_P (op
) && ORIGINAL_REGNO (op
)
3465 && ORIGINAL_REGNO (op
) != REGNO (op
))
3466 fprintf (asm_out_file
, " tmp%i", ORIGINAL_REGNO (op
));
3470 #ifdef ASSEMBLER_DIALECT
3471 /* Helper function to parse assembler dialects in the asm string.
3472 This is called from output_asm_insn and asm_fprintf. */
3474 do_assembler_dialects (const char *p
, int *dialect
)
3485 output_operand_lossage ("nested assembly dialect alternatives");
3489 /* If we want the first dialect, do nothing. Otherwise, skip
3490 DIALECT_NUMBER of strings ending with '|'. */
3491 for (i
= 0; i
< dialect_number
; i
++)
3493 while (*p
&& *p
!= '}')
3501 /* Skip over any character after a percent sign. */
3513 output_operand_lossage ("unterminated assembly dialect alternative");
3520 /* Skip to close brace. */
3525 output_operand_lossage ("unterminated assembly dialect alternative");
3529 /* Skip over any character after a percent sign. */
3530 if (*p
== '%' && p
[1])
3544 putc (c
, asm_out_file
);
3549 putc (c
, asm_out_file
);
3560 /* Output text from TEMPLATE to the assembler output file,
3561 obeying %-directions to substitute operands taken from
3562 the vector OPERANDS.
3564 %N (for N a digit) means print operand N in usual manner.
3565 %lN means require operand N to be a CODE_LABEL or LABEL_REF
3566 and print the label name with no punctuation.
3567 %cN means require operand N to be a constant
3568 and print the constant expression with no punctuation.
3569 %aN means expect operand N to be a memory address
3570 (not a memory reference!) and print a reference
3572 %nN means expect operand N to be a constant
3573 and print a constant expression for minus the value
3574 of the operand, with no other punctuation. */
3577 output_asm_insn (const char *templ
, rtx
*operands
)
3581 #ifdef ASSEMBLER_DIALECT
3584 int oporder
[MAX_RECOG_OPERANDS
];
3585 char opoutput
[MAX_RECOG_OPERANDS
];
3588 /* An insn may return a null string template
3589 in a case where no assembler code is needed. */
3593 memset (opoutput
, 0, sizeof opoutput
);
3595 putc ('\t', asm_out_file
);
3597 #ifdef ASM_OUTPUT_OPCODE
3598 ASM_OUTPUT_OPCODE (asm_out_file
, p
);
3605 if (flag_verbose_asm
)
3606 output_asm_operand_names (operands
, oporder
, ops
);
3607 if (flag_print_asm_name
)
3611 memset (opoutput
, 0, sizeof opoutput
);
3613 putc (c
, asm_out_file
);
3614 #ifdef ASM_OUTPUT_OPCODE
3615 while ((c
= *p
) == '\t')
3617 putc (c
, asm_out_file
);
3620 ASM_OUTPUT_OPCODE (asm_out_file
, p
);
3624 #ifdef ASSEMBLER_DIALECT
3628 p
= do_assembler_dialects (p
, &dialect
);
3633 /* %% outputs a single %. %{, %} and %| print {, } and | respectively
3634 if ASSEMBLER_DIALECT defined and these characters have a special
3635 meaning as dialect delimiters.*/
3637 #ifdef ASSEMBLER_DIALECT
3638 || *p
== '{' || *p
== '}' || *p
== '|'
3642 putc (*p
, asm_out_file
);
3645 /* %= outputs a number which is unique to each insn in the entire
3646 compilation. This is useful for making local labels that are
3647 referred to more than once in a given insn. */
3651 fprintf (asm_out_file
, "%d", insn_counter
);
3653 /* % followed by a letter and some digits
3654 outputs an operand in a special way depending on the letter.
3655 Letters `acln' are implemented directly.
3656 Other letters are passed to `output_operand' so that
3657 the TARGET_PRINT_OPERAND hook can define them. */
3658 else if (ISALPHA (*p
))
3661 unsigned long opnum
;
3664 opnum
= strtoul (p
, &endptr
, 10);
3667 output_operand_lossage ("operand number missing "
3669 else if (this_is_asm_operands
&& opnum
>= insn_noperands
)
3670 output_operand_lossage ("operand number out of range");
3671 else if (letter
== 'l')
3672 output_asm_label (operands
[opnum
]);
3673 else if (letter
== 'a')
3674 output_address (operands
[opnum
]);
3675 else if (letter
== 'c')
3677 if (CONSTANT_ADDRESS_P (operands
[opnum
]))
3678 output_addr_const (asm_out_file
, operands
[opnum
]);
3680 output_operand (operands
[opnum
], 'c');
3682 else if (letter
== 'n')
3684 if (CONST_INT_P (operands
[opnum
]))
3685 fprintf (asm_out_file
, HOST_WIDE_INT_PRINT_DEC
,
3686 - INTVAL (operands
[opnum
]));
3689 putc ('-', asm_out_file
);
3690 output_addr_const (asm_out_file
, operands
[opnum
]);
3694 output_operand (operands
[opnum
], letter
);
3696 if (!opoutput
[opnum
])
3697 oporder
[ops
++] = opnum
;
3698 opoutput
[opnum
] = 1;
3703 /* % followed by a digit outputs an operand the default way. */
3704 else if (ISDIGIT (*p
))
3706 unsigned long opnum
;
3709 opnum
= strtoul (p
, &endptr
, 10);
3710 if (this_is_asm_operands
&& opnum
>= insn_noperands
)
3711 output_operand_lossage ("operand number out of range");
3713 output_operand (operands
[opnum
], 0);
3715 if (!opoutput
[opnum
])
3716 oporder
[ops
++] = opnum
;
3717 opoutput
[opnum
] = 1;
3722 /* % followed by punctuation: output something for that
3723 punctuation character alone, with no operand. The
3724 TARGET_PRINT_OPERAND hook decides what is actually done. */
3725 else if (targetm
.asm_out
.print_operand_punct_valid_p ((unsigned char) *p
))
3726 output_operand (NULL_RTX
, *p
++);
3728 output_operand_lossage ("invalid %%-code");
3732 putc (c
, asm_out_file
);
3735 /* Write out the variable names for operands, if we know them. */
3736 if (flag_verbose_asm
)
3737 output_asm_operand_names (operands
, oporder
, ops
);
3738 if (flag_print_asm_name
)
3741 putc ('\n', asm_out_file
);
3744 /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */
3747 output_asm_label (rtx x
)
3751 if (GET_CODE (x
) == LABEL_REF
)
3755 && NOTE_KIND (x
) == NOTE_INSN_DELETED_LABEL
))
3756 ASM_GENERATE_INTERNAL_LABEL (buf
, "L", CODE_LABEL_NUMBER (x
));
3758 output_operand_lossage ("'%%l' operand isn't a label");
3760 assemble_name (asm_out_file
, buf
);
3763 /* Helper rtx-iteration-function for mark_symbol_refs_as_used and
3764 output_operand. Marks SYMBOL_REFs as referenced through use of
3765 assemble_external. */
3768 mark_symbol_ref_as_used (rtx
*xp
, void *dummy ATTRIBUTE_UNUSED
)
3772 /* If we have a used symbol, we may have to emit assembly
3773 annotations corresponding to whether the symbol is external, weak
3774 or has non-default visibility. */
3775 if (GET_CODE (x
) == SYMBOL_REF
)
3779 t
= SYMBOL_REF_DECL (x
);
3781 assemble_external (t
);
3789 /* Marks SYMBOL_REFs in x as referenced through use of assemble_external. */
3792 mark_symbol_refs_as_used (rtx x
)
3794 for_each_rtx (&x
, mark_symbol_ref_as_used
, NULL
);
3797 /* Print operand X using machine-dependent assembler syntax.
3798 CODE is a non-digit that preceded the operand-number in the % spec,
3799 such as 'z' if the spec was `%z3'. CODE is 0 if there was no char
3800 between the % and the digits.
3801 When CODE is a non-letter, X is 0.
3803 The meanings of the letters are machine-dependent and controlled
3804 by TARGET_PRINT_OPERAND. */
3807 output_operand (rtx x
, int code ATTRIBUTE_UNUSED
)
3809 if (x
&& GET_CODE (x
) == SUBREG
)
3810 x
= alter_subreg (&x
, true);
3812 /* X must not be a pseudo reg. */
3813 gcc_assert (!x
|| !REG_P (x
) || REGNO (x
) < FIRST_PSEUDO_REGISTER
);
3815 targetm
.asm_out
.print_operand (asm_out_file
, x
, code
);
3820 for_each_rtx (&x
, mark_symbol_ref_as_used
, NULL
);
3823 /* Print a memory reference operand for address X using
3824 machine-dependent assembler syntax. */
3827 output_address (rtx x
)
3829 bool changed
= false;
3830 walk_alter_subreg (&x
, &changed
);
3831 targetm
.asm_out
.print_operand_address (asm_out_file
, x
);
3834 /* Print an integer constant expression in assembler syntax.
3835 Addition and subtraction are the only arithmetic
3836 that may appear in these expressions. */
3839 output_addr_const (FILE *file
, rtx x
)
3844 switch (GET_CODE (x
))
3851 if (SYMBOL_REF_DECL (x
))
3852 assemble_external (SYMBOL_REF_DECL (x
));
3853 #ifdef ASM_OUTPUT_SYMBOL_REF
3854 ASM_OUTPUT_SYMBOL_REF (file
, x
);
3856 assemble_name (file
, XSTR (x
, 0));
3864 ASM_GENERATE_INTERNAL_LABEL (buf
, "L", CODE_LABEL_NUMBER (x
));
3865 #ifdef ASM_OUTPUT_LABEL_REF
3866 ASM_OUTPUT_LABEL_REF (file
, buf
);
3868 assemble_name (file
, buf
);
3873 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, INTVAL (x
));
3877 /* This used to output parentheses around the expression,
3878 but that does not work on the 386 (either ATT or BSD assembler). */
3879 output_addr_const (file
, XEXP (x
, 0));
3883 if (GET_MODE (x
) == VOIDmode
)
3885 /* We can use %d if the number is one word and positive. */
3886 if (CONST_DOUBLE_HIGH (x
))
3887 fprintf (file
, HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
3888 (unsigned HOST_WIDE_INT
) CONST_DOUBLE_HIGH (x
),
3889 (unsigned HOST_WIDE_INT
) CONST_DOUBLE_LOW (x
));
3890 else if (CONST_DOUBLE_LOW (x
) < 0)
3891 fprintf (file
, HOST_WIDE_INT_PRINT_HEX
,
3892 (unsigned HOST_WIDE_INT
) CONST_DOUBLE_LOW (x
));
3894 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, CONST_DOUBLE_LOW (x
));
3897 /* We can't handle floating point constants;
3898 PRINT_OPERAND must handle them. */
3899 output_operand_lossage ("floating constant misused");
3903 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, CONST_FIXED_VALUE_LOW (x
));
3907 /* Some assemblers need integer constants to appear last (eg masm). */
3908 if (CONST_INT_P (XEXP (x
, 0)))
3910 output_addr_const (file
, XEXP (x
, 1));
3911 if (INTVAL (XEXP (x
, 0)) >= 0)
3912 fprintf (file
, "+");
3913 output_addr_const (file
, XEXP (x
, 0));
3917 output_addr_const (file
, XEXP (x
, 0));
3918 if (!CONST_INT_P (XEXP (x
, 1))
3919 || INTVAL (XEXP (x
, 1)) >= 0)
3920 fprintf (file
, "+");
3921 output_addr_const (file
, XEXP (x
, 1));
3926 /* Avoid outputting things like x-x or x+5-x,
3927 since some assemblers can't handle that. */
3928 x
= simplify_subtraction (x
);
3929 if (GET_CODE (x
) != MINUS
)
3932 output_addr_const (file
, XEXP (x
, 0));
3933 fprintf (file
, "-");
3934 if ((CONST_INT_P (XEXP (x
, 1)) && INTVAL (XEXP (x
, 1)) >= 0)
3935 || GET_CODE (XEXP (x
, 1)) == PC
3936 || GET_CODE (XEXP (x
, 1)) == SYMBOL_REF
)
3937 output_addr_const (file
, XEXP (x
, 1));
3940 fputs (targetm
.asm_out
.open_paren
, file
);
3941 output_addr_const (file
, XEXP (x
, 1));
3942 fputs (targetm
.asm_out
.close_paren
, file
);
3950 output_addr_const (file
, XEXP (x
, 0));
3954 if (targetm
.asm_out
.output_addr_const_extra (file
, x
))
3957 output_operand_lossage ("invalid expression as operand");
3961 /* Output a quoted string. */
3964 output_quoted_string (FILE *asm_file
, const char *string
)
3966 #ifdef OUTPUT_QUOTED_STRING
3967 OUTPUT_QUOTED_STRING (asm_file
, string
);
3971 putc ('\"', asm_file
);
3972 while ((c
= *string
++) != 0)
3976 if (c
== '\"' || c
== '\\')
3977 putc ('\\', asm_file
);
3981 fprintf (asm_file
, "\\%03o", (unsigned char) c
);
3983 putc ('\"', asm_file
);
3987 /* Write a HOST_WIDE_INT number in hex form 0x1234, fast. */
3990 fprint_whex (FILE *f
, unsigned HOST_WIDE_INT value
)
3992 char buf
[2 + CHAR_BIT
* sizeof (value
) / 4];
3997 char *p
= buf
+ sizeof (buf
);
3999 *--p
= "0123456789abcdef"[value
% 16];
4000 while ((value
/= 16) != 0);
4003 fwrite (p
, 1, buf
+ sizeof (buf
) - p
, f
);
4007 /* Internal function that prints an unsigned long in decimal in reverse.
4008 The output string IS NOT null-terminated. */
4011 sprint_ul_rev (char *s
, unsigned long value
)
4016 s
[i
] = "0123456789"[value
% 10];
4019 /* alternate version, without modulo */
4020 /* oldval = value; */
4022 /* s[i] = "0123456789" [oldval - 10*value]; */
4029 /* Write an unsigned long as decimal to a file, fast. */
4032 fprint_ul (FILE *f
, unsigned long value
)
4034 /* python says: len(str(2**64)) == 20 */
4038 i
= sprint_ul_rev (s
, value
);
4040 /* It's probably too small to bother with string reversal and fputs. */
4049 /* Write an unsigned long as decimal to a string, fast.
4050 s must be wide enough to not overflow, at least 21 chars.
4051 Returns the length of the string (without terminating '\0'). */
4054 sprint_ul (char *s
, unsigned long value
)
4061 len
= sprint_ul_rev (s
, value
);
4064 /* Reverse the string. */
4078 /* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
4079 %R prints the value of REGISTER_PREFIX.
4080 %L prints the value of LOCAL_LABEL_PREFIX.
4081 %U prints the value of USER_LABEL_PREFIX.
4082 %I prints the value of IMMEDIATE_PREFIX.
4083 %O runs ASM_OUTPUT_OPCODE to transform what follows in the string.
4084 Also supported are %d, %i, %u, %x, %X, %o, %c, %s and %%.
4086 We handle alternate assembler dialects here, just like output_asm_insn. */
4089 asm_fprintf (FILE *file
, const char *p
, ...)
4093 #ifdef ASSEMBLER_DIALECT
4098 va_start (argptr
, p
);
4105 #ifdef ASSEMBLER_DIALECT
4109 p
= do_assembler_dialects (p
, &dialect
);
4116 while (strchr ("-+ #0", c
))
4121 while (ISDIGIT (c
) || c
== '.')
4132 case 'd': case 'i': case 'u':
4133 case 'x': case 'X': case 'o':
4137 fprintf (file
, buf
, va_arg (argptr
, int));
4141 /* This is a prefix to the 'd', 'i', 'u', 'x', 'X', and
4142 'o' cases, but we do not check for those cases. It
4143 means that the value is a HOST_WIDE_INT, which may be
4144 either `long' or `long long'. */
4145 memcpy (q
, HOST_WIDE_INT_PRINT
, strlen (HOST_WIDE_INT_PRINT
));
4146 q
+= strlen (HOST_WIDE_INT_PRINT
);
4149 fprintf (file
, buf
, va_arg (argptr
, HOST_WIDE_INT
));
4154 #ifdef HAVE_LONG_LONG
4160 fprintf (file
, buf
, va_arg (argptr
, long long));
4167 fprintf (file
, buf
, va_arg (argptr
, long));
4175 fprintf (file
, buf
, va_arg (argptr
, char *));
4179 #ifdef ASM_OUTPUT_OPCODE
4180 ASM_OUTPUT_OPCODE (asm_out_file
, p
);
4185 #ifdef REGISTER_PREFIX
4186 fprintf (file
, "%s", REGISTER_PREFIX
);
4191 #ifdef IMMEDIATE_PREFIX
4192 fprintf (file
, "%s", IMMEDIATE_PREFIX
);
4197 #ifdef LOCAL_LABEL_PREFIX
4198 fprintf (file
, "%s", LOCAL_LABEL_PREFIX
);
4203 fputs (user_label_prefix
, file
);
4206 #ifdef ASM_FPRINTF_EXTENSIONS
4207 /* Uppercase letters are reserved for general use by asm_fprintf
4208 and so are not available to target specific code. In order to
4209 prevent the ASM_FPRINTF_EXTENSIONS macro from using them then,
4210 they are defined here. As they get turned into real extensions
4211 to asm_fprintf they should be removed from this list. */
4212 case 'A': case 'B': case 'C': case 'D': case 'E':
4213 case 'F': case 'G': case 'H': case 'J': case 'K':
4214 case 'M': case 'N': case 'P': case 'Q': case 'S':
4215 case 'T': case 'V': case 'W': case 'Y': case 'Z':
4218 ASM_FPRINTF_EXTENSIONS (file
, argptr
, p
)
4231 /* Return nonzero if this function has no function calls. */
4234 leaf_function_p (void)
4238 if (crtl
->profile
|| profile_arc_flag
)
4241 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4244 && ! SIBLING_CALL_P (insn
))
4246 if (NONJUMP_INSN_P (insn
)
4247 && GET_CODE (PATTERN (insn
)) == SEQUENCE
4248 && CALL_P (XVECEXP (PATTERN (insn
), 0, 0))
4249 && ! SIBLING_CALL_P (XVECEXP (PATTERN (insn
), 0, 0)))
4256 /* Return 1 if branch is a forward branch.
4257 Uses insn_shuid array, so it works only in the final pass. May be used by
4258 output templates to customary add branch prediction hints.
4261 final_forward_branch_p (rtx insn
)
4263 int insn_id
, label_id
;
4265 gcc_assert (uid_shuid
);
4266 insn_id
= INSN_SHUID (insn
);
4267 label_id
= INSN_SHUID (JUMP_LABEL (insn
));
4268 /* We've hit some insns that does not have id information available. */
4269 gcc_assert (insn_id
&& label_id
);
4270 return insn_id
< label_id
;
4273 /* On some machines, a function with no call insns
4274 can run faster if it doesn't create its own register window.
4275 When output, the leaf function should use only the "output"
4276 registers. Ordinarily, the function would be compiled to use
4277 the "input" registers to find its arguments; it is a candidate
4278 for leaf treatment if it uses only the "input" registers.
4279 Leaf function treatment means renumbering so the function
4280 uses the "output" registers instead. */
4282 #ifdef LEAF_REGISTERS
4284 /* Return 1 if this function uses only the registers that can be
4285 safely renumbered. */
4288 only_leaf_regs_used (void)
4291 const char *const permitted_reg_in_leaf_functions
= LEAF_REGISTERS
;
4293 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
4294 if ((df_regs_ever_live_p (i
) || global_regs
[i
])
4295 && ! permitted_reg_in_leaf_functions
[i
])
4298 if (crtl
->uses_pic_offset_table
4299 && pic_offset_table_rtx
!= 0
4300 && REG_P (pic_offset_table_rtx
)
4301 && ! permitted_reg_in_leaf_functions
[REGNO (pic_offset_table_rtx
)])
4307 /* Scan all instructions and renumber all registers into those
4308 available in leaf functions. */
4311 leaf_renumber_regs (rtx first
)
4315 /* Renumber only the actual patterns.
4316 The reg-notes can contain frame pointer refs,
4317 and renumbering them could crash, and should not be needed. */
4318 for (insn
= first
; insn
; insn
= NEXT_INSN (insn
))
4320 leaf_renumber_regs_insn (PATTERN (insn
));
4323 /* Scan IN_RTX and its subexpressions, and renumber all regs into those
4324 available in leaf functions. */
4327 leaf_renumber_regs_insn (rtx in_rtx
)
4330 const char *format_ptr
;
4335 /* Renumber all input-registers into output-registers.
4336 renumbered_regs would be 1 for an output-register;
4343 /* Don't renumber the same reg twice. */
4347 newreg
= REGNO (in_rtx
);
4348 /* Don't try to renumber pseudo regs. It is possible for a pseudo reg
4349 to reach here as part of a REG_NOTE. */
4350 if (newreg
>= FIRST_PSEUDO_REGISTER
)
4355 newreg
= LEAF_REG_REMAP (newreg
);
4356 gcc_assert (newreg
>= 0);
4357 df_set_regs_ever_live (REGNO (in_rtx
), false);
4358 df_set_regs_ever_live (newreg
, true);
4359 SET_REGNO (in_rtx
, newreg
);
4363 if (INSN_P (in_rtx
))
4365 /* Inside a SEQUENCE, we find insns.
4366 Renumber just the patterns of these insns,
4367 just as we do for the top-level insns. */
4368 leaf_renumber_regs_insn (PATTERN (in_rtx
));
4372 format_ptr
= GET_RTX_FORMAT (GET_CODE (in_rtx
));
4374 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (in_rtx
)); i
++)
4375 switch (*format_ptr
++)
4378 leaf_renumber_regs_insn (XEXP (in_rtx
, i
));
4382 if (NULL
!= XVEC (in_rtx
, i
))
4384 for (j
= 0; j
< XVECLEN (in_rtx
, i
); j
++)
4385 leaf_renumber_regs_insn (XVECEXP (in_rtx
, i
, j
));
4404 /* Turn the RTL into assembly. */
4406 rest_of_handle_final (void)
4411 /* Get the function's name, as described by its RTL. This may be
4412 different from the DECL_NAME name used in the source file. */
4414 x
= DECL_RTL (current_function_decl
);
4415 gcc_assert (MEM_P (x
));
4417 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
4418 fnname
= XSTR (x
, 0);
4420 assemble_start_function (current_function_decl
, fnname
);
4421 final_start_function (get_insns (), asm_out_file
, optimize
);
4422 final (get_insns (), asm_out_file
, optimize
);
4423 final_end_function ();
4425 /* The IA-64 ".handlerdata" directive must be issued before the ".endp"
4426 directive that closes the procedure descriptor. Similarly, for x64 SEH.
4427 Otherwise it's not strictly necessary, but it doesn't hurt either. */
4428 output_function_exception_table (fnname
);
4430 assemble_end_function (current_function_decl
, fnname
);
4432 user_defined_section_attribute
= false;
4434 /* Free up reg info memory. */
4438 fflush (asm_out_file
);
4440 /* Write DBX symbols if requested. */
4442 /* Note that for those inline functions where we don't initially
4443 know for certain that we will be generating an out-of-line copy,
4444 the first invocation of this routine (rest_of_compilation) will
4445 skip over this code by doing a `goto exit_rest_of_compilation;'.
4446 Later on, wrapup_global_declarations will (indirectly) call
4447 rest_of_compilation again for those inline functions that need
4448 to have out-of-line copies generated. During that call, we
4449 *will* be routed past here. */
4451 timevar_push (TV_SYMOUT
);
4452 if (!DECL_IGNORED_P (current_function_decl
))
4453 debug_hooks
->function_decl (current_function_decl
);
4454 timevar_pop (TV_SYMOUT
);
4456 /* Release the blocks that are linked to DECL_INITIAL() to free the memory. */
4457 DECL_INITIAL (current_function_decl
) = error_mark_node
;
4459 if (DECL_STATIC_CONSTRUCTOR (current_function_decl
)
4460 && targetm
.have_ctors_dtors
)
4461 targetm
.asm_out
.constructor (XEXP (DECL_RTL (current_function_decl
), 0),
4462 decl_init_priority_lookup
4463 (current_function_decl
));
4464 if (DECL_STATIC_DESTRUCTOR (current_function_decl
)
4465 && targetm
.have_ctors_dtors
)
4466 targetm
.asm_out
.destructor (XEXP (DECL_RTL (current_function_decl
), 0),
4467 decl_fini_priority_lookup
4468 (current_function_decl
));
4474 const pass_data pass_data_final
=
4476 RTL_PASS
, /* type */
4478 OPTGROUP_NONE
, /* optinfo_flags */
4479 false, /* has_gate */
4480 true, /* has_execute */
4481 TV_FINAL
, /* tv_id */
4482 0, /* properties_required */
4483 0, /* properties_provided */
4484 0, /* properties_destroyed */
4485 0, /* todo_flags_start */
4486 0, /* todo_flags_finish */
4489 class pass_final
: public rtl_opt_pass
4492 pass_final(gcc::context
*ctxt
)
4493 : rtl_opt_pass(pass_data_final
, ctxt
)
4496 /* opt_pass methods: */
4497 unsigned int execute () { return rest_of_handle_final (); }
4499 }; // class pass_final
4504 make_pass_final (gcc::context
*ctxt
)
4506 return new pass_final (ctxt
);
4511 rest_of_handle_shorten_branches (void)
4513 /* Shorten branches. */
4514 shorten_branches (get_insns ());
4520 const pass_data pass_data_shorten_branches
=
4522 RTL_PASS
, /* type */
4523 "shorten", /* name */
4524 OPTGROUP_NONE
, /* optinfo_flags */
4525 false, /* has_gate */
4526 true, /* has_execute */
4527 TV_SHORTEN_BRANCH
, /* tv_id */
4528 0, /* properties_required */
4529 0, /* properties_provided */
4530 0, /* properties_destroyed */
4531 0, /* todo_flags_start */
4532 0, /* todo_flags_finish */
4535 class pass_shorten_branches
: public rtl_opt_pass
4538 pass_shorten_branches(gcc::context
*ctxt
)
4539 : rtl_opt_pass(pass_data_shorten_branches
, ctxt
)
4542 /* opt_pass methods: */
4543 unsigned int execute () { return rest_of_handle_shorten_branches (); }
4545 }; // class pass_shorten_branches
4550 make_pass_shorten_branches (gcc::context
*ctxt
)
4552 return new pass_shorten_branches (ctxt
);
4557 rest_of_clean_state (void)
4560 FILE *final_output
= NULL
;
4561 int save_unnumbered
= flag_dump_unnumbered
;
4562 int save_noaddr
= flag_dump_noaddr
;
4564 if (flag_dump_final_insns
)
4566 final_output
= fopen (flag_dump_final_insns
, "a");
4569 error ("could not open final insn dump file %qs: %m",
4570 flag_dump_final_insns
);
4571 flag_dump_final_insns
= NULL
;
4575 flag_dump_noaddr
= flag_dump_unnumbered
= 1;
4576 if (flag_compare_debug_opt
|| flag_compare_debug
)
4577 dump_flags
|= TDF_NOUID
;
4578 dump_function_header (final_output
, current_function_decl
,
4580 final_insns_dump_p
= true;
4582 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4584 INSN_UID (insn
) = CODE_LABEL_NUMBER (insn
);
4588 set_block_for_insn (insn
, NULL
);
4589 INSN_UID (insn
) = 0;
4594 /* It is very important to decompose the RTL instruction chain here:
4595 debug information keeps pointing into CODE_LABEL insns inside the function
4596 body. If these remain pointing to the other insns, we end up preserving
4597 whole RTL chain and attached detailed debug info in memory. */
4598 for (insn
= get_insns (); insn
; insn
= next
)
4600 next
= NEXT_INSN (insn
);
4601 NEXT_INSN (insn
) = NULL
;
4602 PREV_INSN (insn
) = NULL
;
4605 && (!NOTE_P (insn
) ||
4606 (NOTE_KIND (insn
) != NOTE_INSN_VAR_LOCATION
4607 && NOTE_KIND (insn
) != NOTE_INSN_CALL_ARG_LOCATION
4608 && NOTE_KIND (insn
) != NOTE_INSN_BLOCK_BEG
4609 && NOTE_KIND (insn
) != NOTE_INSN_BLOCK_END
4610 && NOTE_KIND (insn
) != NOTE_INSN_DELETED_DEBUG_LABEL
)))
4611 print_rtl_single (final_output
, insn
);
4616 flag_dump_noaddr
= save_noaddr
;
4617 flag_dump_unnumbered
= save_unnumbered
;
4618 final_insns_dump_p
= false;
4620 if (fclose (final_output
))
4622 error ("could not close final insn dump file %qs: %m",
4623 flag_dump_final_insns
);
4624 flag_dump_final_insns
= NULL
;
4628 /* In case the function was not output,
4629 don't leave any temporary anonymous types
4630 queued up for sdb output. */
4631 #ifdef SDB_DEBUGGING_INFO
4632 if (write_symbols
== SDB_DEBUG
)
4633 sdbout_types (NULL_TREE
);
4636 flag_rerun_cse_after_global_opts
= 0;
4637 reload_completed
= 0;
4638 epilogue_completed
= 0;
4640 regstack_completed
= 0;
4643 /* Clear out the insn_length contents now that they are no
4645 init_insn_lengths ();
4647 /* Show no temporary slots allocated. */
4650 free_bb_for_insn ();
4654 /* We can reduce stack alignment on call site only when we are sure that
4655 the function body just produced will be actually used in the final
4657 if (decl_binds_to_current_def_p (current_function_decl
))
4659 unsigned int pref
= crtl
->preferred_stack_boundary
;
4660 if (crtl
->stack_alignment_needed
> crtl
->preferred_stack_boundary
)
4661 pref
= crtl
->stack_alignment_needed
;
4662 cgraph_rtl_info (current_function_decl
)->preferred_incoming_stack_boundary
4666 /* Make sure volatile mem refs aren't considered valid operands for
4667 arithmetic insns. We must call this here if this is a nested inline
4668 function, since the above code leaves us in the init_recog state,
4669 and the function context push/pop code does not save/restore volatile_ok.
4671 ??? Maybe it isn't necessary for expand_start_function to call this
4672 anymore if we do it here? */
4674 init_recog_no_volatile ();
4676 /* We're done with this function. Free up memory if we can. */
4677 free_after_parsing (cfun
);
4678 free_after_compilation (cfun
);
4684 const pass_data pass_data_clean_state
=
4686 RTL_PASS
, /* type */
4687 "*clean_state", /* name */
4688 OPTGROUP_NONE
, /* optinfo_flags */
4689 false, /* has_gate */
4690 true, /* has_execute */
4691 TV_FINAL
, /* tv_id */
4692 0, /* properties_required */
4693 0, /* properties_provided */
4694 PROP_rtl
, /* properties_destroyed */
4695 0, /* todo_flags_start */
4696 0, /* todo_flags_finish */
4699 class pass_clean_state
: public rtl_opt_pass
4702 pass_clean_state(gcc::context
*ctxt
)
4703 : rtl_opt_pass(pass_data_clean_state
, ctxt
)
4706 /* opt_pass methods: */
4707 unsigned int execute () { return rest_of_clean_state (); }
4709 }; // class pass_clean_state
4714 make_pass_clean_state (gcc::context
*ctxt
)
4716 return new pass_clean_state (ctxt
);