2 Copyright (C) 1987-2021 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 file is compiled twice: once for the generator programs,
21 once for the compiler. */
29 #include "coretypes.h"
33 /* These headers all define things which are not available in
34 generator programs. */
35 #ifndef GENERATOR_FILE
38 #include "basic-block.h"
39 #include "print-tree.h"
44 #include "basic-block.h"
45 #include "diagnostic.h"
46 #include "tree-pretty-print.h"
47 #include "alloc-pool.h"
49 #include "dumpfile.h" /* for dump_flags */
50 #include "dwarf2out.h"
51 #include "pretty-print.h"
54 #include "print-rtl.h"
57 /* Disable warnings about quoting issues in the pp_xxx calls below
58 that (intentionally) don't follow GCC diagnostic conventions. */
60 # pragma GCC diagnostic push
61 # pragma GCC diagnostic ignored "-Wformat-diag"
64 /* String printed at beginning of each RTL when it is dumped.
65 This string is set to ASM_COMMENT_START when the RTL is dumped in
66 the assembly output file. */
67 const char *print_rtx_head
= "";
70 /* These are defined from the .opt file when not used in generator
73 /* Nonzero means suppress output of instruction numbers
75 This must be defined here so that programs like gencodes can be linked. */
76 int flag_dump_unnumbered
= 0;
78 /* Nonzero means suppress output of instruction numbers for previous
79 and next insns in debugging dumps.
80 This must be defined here so that programs like gencodes can be linked. */
81 int flag_dump_unnumbered_links
= 0;
84 /* Constructor for rtx_writer. */
86 rtx_writer::rtx_writer (FILE *outf
, int ind
, bool simple
, bool compact
,
87 rtx_reuse_manager
*reuse_manager
)
88 : m_outfile (outf
), m_sawclose (0), m_indent (ind
),
89 m_in_call_function_usage (false), m_simple (simple
), m_compact (compact
),
90 m_rtx_reuse_manager (reuse_manager
)
94 #ifndef GENERATOR_FILE
96 /* rtx_reuse_manager's ctor. */
98 rtx_reuse_manager::rtx_reuse_manager ()
103 /* Determine if X is of a kind suitable for dumping via reuse_rtx. */
106 uses_rtx_reuse_p (const_rtx x
)
111 switch (GET_CODE (x
))
118 /* We don't use reuse_rtx for consts. */
125 /* Traverse X and its descendents, determining if we see any rtx more than
126 once. Any rtx suitable for "reuse_rtx" that is seen more than once is
130 rtx_reuse_manager::preprocess (const_rtx x
)
132 subrtx_iterator::array_type array
;
133 FOR_EACH_SUBRTX (iter
, array
, x
, NONCONST
)
134 if (uses_rtx_reuse_p (*iter
))
136 if (int *count
= m_rtx_occurrence_count
.get (*iter
))
139 m_rtx_reuse_ids
.put (*iter
, m_next_id
++);
142 m_rtx_occurrence_count
.put (*iter
, 1);
146 /* Return true iff X has been assigned a reuse ID. If it has,
147 and OUT is non-NULL, then write the reuse ID to *OUT. */
150 rtx_reuse_manager::has_reuse_id (const_rtx x
, int *out
)
152 int *id
= m_rtx_reuse_ids
.get (x
);
163 /* Determine if set_seen_def has been called for the given reuse ID. */
166 rtx_reuse_manager::seen_def_p (int reuse_id
)
168 return bitmap_bit_p (m_defs_seen
, reuse_id
);
171 /* Record that the definition of the given reuse ID has been seen. */
174 rtx_reuse_manager::set_seen_def (int reuse_id
)
176 bitmap_set_bit (m_defs_seen
, reuse_id
);
179 #endif /* #ifndef GENERATOR_FILE */
181 #ifndef GENERATOR_FILE
183 print_mem_expr (FILE *outfile
, const_tree expr
)
185 fputc (' ', outfile
);
186 print_generic_expr (outfile
, CONST_CAST_TREE (expr
),
187 dump_flags
| TDF_SLIM
);
191 /* Print X to FILE. */
194 print_poly_int (FILE *file
, poly_int64 x
)
196 HOST_WIDE_INT const_x
;
197 if (x
.is_constant (&const_x
))
198 fprintf (file
, HOST_WIDE_INT_PRINT_DEC
, const_x
);
201 fprintf (file
, "[" HOST_WIDE_INT_PRINT_DEC
, x
.coeffs
[0]);
202 for (int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
203 fprintf (file
, ", " HOST_WIDE_INT_PRINT_DEC
, x
.coeffs
[i
]);
208 /* Subroutine of print_rtx_operand for handling code '0'.
209 0 indicates a field for internal use that should not be printed.
210 However there are various special cases, such as the third field
211 of a NOTE, where it indicates that the field has several different
215 rtx_writer::print_rtx_operand_code_0 (const_rtx in_rtx ATTRIBUTE_UNUSED
,
216 int idx ATTRIBUTE_UNUSED
)
218 #ifndef GENERATOR_FILE
219 if (idx
== 1 && GET_CODE (in_rtx
) == SYMBOL_REF
)
221 int flags
= SYMBOL_REF_FLAGS (in_rtx
);
223 fprintf (m_outfile
, " [flags %#x]", flags
);
224 tree decl
= SYMBOL_REF_DECL (in_rtx
);
226 print_node_brief (m_outfile
, "", decl
, dump_flags
);
228 else if (idx
== 3 && NOTE_P (in_rtx
))
230 switch (NOTE_KIND (in_rtx
))
232 case NOTE_INSN_EH_REGION_BEG
:
233 case NOTE_INSN_EH_REGION_END
:
234 if (flag_dump_unnumbered
)
235 fprintf (m_outfile
, " #");
237 fprintf (m_outfile
, " %d", NOTE_EH_HANDLER (in_rtx
));
241 case NOTE_INSN_BLOCK_BEG
:
242 case NOTE_INSN_BLOCK_END
:
243 dump_addr (m_outfile
, " ", NOTE_BLOCK (in_rtx
));
247 case NOTE_INSN_BASIC_BLOCK
:
249 basic_block bb
= NOTE_BASIC_BLOCK (in_rtx
);
251 fprintf (m_outfile
, " [bb %d]", bb
->index
);
255 case NOTE_INSN_DELETED_LABEL
:
256 case NOTE_INSN_DELETED_DEBUG_LABEL
:
258 const char *label
= NOTE_DELETED_LABEL_NAME (in_rtx
);
260 fprintf (m_outfile
, " (\"%s\")", label
);
262 fprintf (m_outfile
, " \"\"");
266 case NOTE_INSN_SWITCH_TEXT_SECTIONS
:
268 basic_block bb
= NOTE_BASIC_BLOCK (in_rtx
);
270 fprintf (m_outfile
, " [bb %d]", bb
->index
);
274 case NOTE_INSN_VAR_LOCATION
:
275 fputc (' ', m_outfile
);
276 print_rtx (NOTE_VAR_LOCATION (in_rtx
));
280 fputc ('\n', m_outfile
);
281 output_cfi_directive (m_outfile
, NOTE_CFI (in_rtx
));
282 fputc ('\t', m_outfile
);
285 case NOTE_INSN_BEGIN_STMT
:
286 case NOTE_INSN_INLINE_ENTRY
:
287 #ifndef GENERATOR_FILE
289 expanded_location xloc
290 = expand_location (NOTE_MARKER_LOCATION (in_rtx
));
291 fprintf (m_outfile
, " %s:%i", xloc
.file
, xloc
.line
);
300 else if (idx
== 7 && JUMP_P (in_rtx
) && JUMP_LABEL (in_rtx
) != NULL
303 /* Output the JUMP_LABEL reference. */
304 fprintf (m_outfile
, "\n%s%*s -> ", print_rtx_head
, m_indent
* 2, "");
305 if (GET_CODE (JUMP_LABEL (in_rtx
)) == RETURN
)
306 fprintf (m_outfile
, "return");
307 else if (GET_CODE (JUMP_LABEL (in_rtx
)) == SIMPLE_RETURN
)
308 fprintf (m_outfile
, "simple_return");
310 fprintf (m_outfile
, "%d", INSN_UID (JUMP_LABEL (in_rtx
)));
312 else if (idx
== 0 && GET_CODE (in_rtx
) == VALUE
)
314 cselib_val
*val
= CSELIB_VAL_PTR (in_rtx
);
316 fprintf (m_outfile
, " %u:%u", val
->uid
, val
->hash
);
317 dump_addr (m_outfile
, " @", in_rtx
);
318 dump_addr (m_outfile
, "/", (void*)val
);
320 else if (idx
== 0 && GET_CODE (in_rtx
) == DEBUG_EXPR
)
322 fprintf (m_outfile
, " D#%i",
323 DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (in_rtx
)));
325 else if (idx
== 0 && GET_CODE (in_rtx
) == ENTRY_VALUE
)
329 fprintf (m_outfile
, " ");
330 print_rtx (ENTRY_VALUE_EXP (in_rtx
));
336 /* Subroutine of print_rtx_operand for handling code 'e'.
337 Also called by print_rtx_operand_code_u for handling code 'u'
338 for LABEL_REFs when they don't reference a CODE_LABEL. */
341 rtx_writer::print_rtx_operand_code_e (const_rtx in_rtx
, int idx
)
344 if (idx
== 6 && INSN_P (in_rtx
))
345 /* Put REG_NOTES on their own line. */
346 fprintf (m_outfile
, "\n%s%*s",
347 print_rtx_head
, m_indent
* 2, "");
349 fprintf (m_outfile
, " ");
350 if (idx
== 7 && CALL_P (in_rtx
))
352 m_in_call_function_usage
= true;
353 print_rtx (XEXP (in_rtx
, idx
));
354 m_in_call_function_usage
= false;
357 print_rtx (XEXP (in_rtx
, idx
));
361 /* Subroutine of print_rtx_operand for handling codes 'E' and 'V'. */
364 rtx_writer::print_rtx_operand_codes_E_and_V (const_rtx in_rtx
, int idx
)
369 fprintf (m_outfile
, "\n%s%*s",
370 print_rtx_head
, m_indent
* 2, "");
373 if (GET_CODE (in_rtx
) == CONST_VECTOR
374 && !GET_MODE_NUNITS (GET_MODE (in_rtx
)).is_constant ()
375 && CONST_VECTOR_DUPLICATE_P (in_rtx
))
376 fprintf (m_outfile
, " repeat");
377 fputs (" [", m_outfile
);
378 if (XVEC (in_rtx
, idx
) != NULL
)
381 if (XVECLEN (in_rtx
, idx
))
384 int barrier
= XVECLEN (in_rtx
, idx
);
385 if (GET_CODE (in_rtx
) == CONST_VECTOR
386 && !GET_MODE_NUNITS (GET_MODE (in_rtx
)).is_constant ())
387 barrier
= CONST_VECTOR_NPATTERNS (in_rtx
);
389 for (int j
= 0; j
< XVECLEN (in_rtx
, idx
); j
++)
395 fprintf (m_outfile
, "\n%s%*s",
396 print_rtx_head
, m_indent
* 2, "");
397 if (!CONST_VECTOR_STEPPED_P (in_rtx
))
398 fprintf (m_outfile
, "repeat [");
399 else if (CONST_VECTOR_NPATTERNS (in_rtx
) == 1)
400 fprintf (m_outfile
, "stepped [");
402 fprintf (m_outfile
, "stepped (interleave %d) [",
403 CONST_VECTOR_NPATTERNS (in_rtx
));
407 print_rtx (XVECEXP (in_rtx
, idx
, j
));
408 int limit
= MIN (barrier
, XVECLEN (in_rtx
, idx
));
409 for (j1
= j
+ 1; j1
< limit
; j1
++)
410 if (XVECEXP (in_rtx
, idx
, j
) != XVECEXP (in_rtx
, idx
, j1
))
415 fprintf (m_outfile
, " repeated x%i", j1
- j
);
420 if (barrier
< XVECLEN (in_rtx
, idx
))
423 fprintf (m_outfile
, "\n%s%*s]", print_rtx_head
, m_indent
* 2, "");
429 fprintf (m_outfile
, "\n%s%*s", print_rtx_head
, m_indent
* 2, "");
431 fputs ("]", m_outfile
);
436 /* Subroutine of print_rtx_operand for handling code 'i'. */
439 rtx_writer::print_rtx_operand_code_i (const_rtx in_rtx
, int idx
)
441 if (idx
== 4 && INSN_P (in_rtx
))
443 #ifndef GENERATOR_FILE
444 const rtx_insn
*in_insn
= as_a
<const rtx_insn
*> (in_rtx
);
446 /* Pretty-print insn locations. Ignore scoping as it is mostly
447 redundant with line number information and do not print anything
448 when there is no location information available. */
449 if (INSN_HAS_LOCATION (in_insn
))
451 expanded_location xloc
= insn_location (in_insn
);
452 fprintf (m_outfile
, " \"%s\":%i:%i", xloc
.file
, xloc
.line
,
457 else if (idx
== 6 && GET_CODE (in_rtx
) == ASM_OPERANDS
)
459 #ifndef GENERATOR_FILE
460 if (ASM_OPERANDS_SOURCE_LOCATION (in_rtx
) != UNKNOWN_LOCATION
)
461 fprintf (m_outfile
, " %s:%i",
462 LOCATION_FILE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx
)),
463 LOCATION_LINE (ASM_OPERANDS_SOURCE_LOCATION (in_rtx
)));
466 else if (idx
== 1 && GET_CODE (in_rtx
) == ASM_INPUT
)
468 #ifndef GENERATOR_FILE
469 if (ASM_INPUT_SOURCE_LOCATION (in_rtx
) != UNKNOWN_LOCATION
)
470 fprintf (m_outfile
, " %s:%i",
471 LOCATION_FILE (ASM_INPUT_SOURCE_LOCATION (in_rtx
)),
472 LOCATION_LINE (ASM_INPUT_SOURCE_LOCATION (in_rtx
)));
475 else if (idx
== 5 && NOTE_P (in_rtx
))
477 /* This field is only used for NOTE_INSN_DELETED_LABEL, and
478 other times often contains garbage from INSN->NOTE death. */
479 if (NOTE_KIND (in_rtx
) == NOTE_INSN_DELETED_LABEL
480 || NOTE_KIND (in_rtx
) == NOTE_INSN_DELETED_DEBUG_LABEL
)
481 fprintf (m_outfile
, " %d", XINT (in_rtx
, idx
));
483 #if !defined(GENERATOR_FILE) && NUM_UNSPECV_VALUES > 0
485 && GET_CODE (in_rtx
) == UNSPEC_VOLATILE
486 && XINT (in_rtx
, 1) >= 0
487 && XINT (in_rtx
, 1) < NUM_UNSPECV_VALUES
)
488 fprintf (m_outfile
, " %s", unspecv_strings
[XINT (in_rtx
, 1)]);
490 #if !defined(GENERATOR_FILE) && NUM_UNSPEC_VALUES > 0
492 && (GET_CODE (in_rtx
) == UNSPEC
493 || GET_CODE (in_rtx
) == UNSPEC_VOLATILE
)
494 && XINT (in_rtx
, 1) >= 0
495 && XINT (in_rtx
, 1) < NUM_UNSPEC_VALUES
)
496 fprintf (m_outfile
, " %s", unspec_strings
[XINT (in_rtx
, 1)]);
500 int value
= XINT (in_rtx
, idx
);
502 int is_insn
= INSN_P (in_rtx
);
504 /* Don't print INSN_CODEs in compact mode. */
505 if (m_compact
&& is_insn
&& &INSN_CODE (in_rtx
) == &XINT (in_rtx
, idx
))
511 if (flag_dump_unnumbered
512 && (is_insn
|| NOTE_P (in_rtx
)))
513 fputc ('#', m_outfile
);
515 fprintf (m_outfile
, " %d", value
);
517 if (is_insn
&& &INSN_CODE (in_rtx
) == &XINT (in_rtx
, idx
)
518 && XINT (in_rtx
, idx
) >= 0
519 && (name
= get_insn_name (XINT (in_rtx
, idx
))) != NULL
)
520 fprintf (m_outfile
, " {%s}", name
);
525 /* Subroutine of print_rtx_operand for handling code 'r'. */
528 rtx_writer::print_rtx_operand_code_r (const_rtx in_rtx
)
530 int is_insn
= INSN_P (in_rtx
);
531 unsigned int regno
= REGNO (in_rtx
);
533 #ifndef GENERATOR_FILE
534 /* For hard registers and virtuals, always print the
535 regno, except in compact mode. */
536 if (regno
<= LAST_VIRTUAL_REGISTER
&& !m_compact
)
537 fprintf (m_outfile
, " %d", regno
);
538 if (regno
< FIRST_PSEUDO_REGISTER
)
539 fprintf (m_outfile
, " %s", reg_names
[regno
]);
540 else if (regno
<= LAST_VIRTUAL_REGISTER
)
542 if (regno
== VIRTUAL_INCOMING_ARGS_REGNUM
)
543 fprintf (m_outfile
, " virtual-incoming-args");
544 else if (regno
== VIRTUAL_STACK_VARS_REGNUM
)
545 fprintf (m_outfile
, " virtual-stack-vars");
546 else if (regno
== VIRTUAL_STACK_DYNAMIC_REGNUM
)
547 fprintf (m_outfile
, " virtual-stack-dynamic");
548 else if (regno
== VIRTUAL_OUTGOING_ARGS_REGNUM
)
549 fprintf (m_outfile
, " virtual-outgoing-args");
550 else if (regno
== VIRTUAL_CFA_REGNUM
)
551 fprintf (m_outfile
, " virtual-cfa");
552 else if (regno
== VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM
)
553 fprintf (m_outfile
, " virtual-preferred-stack-boundary");
555 fprintf (m_outfile
, " virtual-reg-%d", regno
-FIRST_VIRTUAL_REGISTER
);
559 if (flag_dump_unnumbered
&& is_insn
)
560 fputc ('#', m_outfile
);
563 /* In compact mode, print pseudos with '< and '>' wrapping the regno,
564 offseting it by (LAST_VIRTUAL_REGISTER + 1), so that the
565 first non-virtual pseudo is dumped as "<0>". */
566 gcc_assert (regno
> LAST_VIRTUAL_REGISTER
);
567 fprintf (m_outfile
, " <%d>", regno
- (LAST_VIRTUAL_REGISTER
+ 1));
570 fprintf (m_outfile
, " %d", regno
);
572 #ifndef GENERATOR_FILE
573 if (REG_ATTRS (in_rtx
))
575 fputs (" [", m_outfile
);
576 if (regno
!= ORIGINAL_REGNO (in_rtx
))
577 fprintf (m_outfile
, "orig:%i", ORIGINAL_REGNO (in_rtx
));
578 if (REG_EXPR (in_rtx
))
579 print_mem_expr (m_outfile
, REG_EXPR (in_rtx
));
581 if (maybe_ne (REG_OFFSET (in_rtx
), 0))
583 fprintf (m_outfile
, "+");
584 print_poly_int (m_outfile
, REG_OFFSET (in_rtx
));
586 fputs (" ]", m_outfile
);
588 if (regno
!= ORIGINAL_REGNO (in_rtx
))
589 fprintf (m_outfile
, " [%d]", ORIGINAL_REGNO (in_rtx
));
593 /* Subroutine of print_rtx_operand for handling code 'u'. */
596 rtx_writer::print_rtx_operand_code_u (const_rtx in_rtx
, int idx
)
598 /* Don't print insn UIDs for PREV/NEXT_INSN in compact mode. */
599 if (m_compact
&& INSN_CHAIN_CODE_P (GET_CODE (in_rtx
)) && idx
< 2)
602 if (XEXP (in_rtx
, idx
) != NULL
)
604 rtx sub
= XEXP (in_rtx
, idx
);
605 enum rtx_code subc
= GET_CODE (sub
);
607 if (GET_CODE (in_rtx
) == LABEL_REF
)
610 && NOTE_KIND (sub
) == NOTE_INSN_DELETED_LABEL
)
612 if (flag_dump_unnumbered
)
613 fprintf (m_outfile
, " [# deleted]");
615 fprintf (m_outfile
, " [%d deleted]", INSN_UID (sub
));
620 if (subc
!= CODE_LABEL
)
622 print_rtx_operand_code_e (in_rtx
, idx
);
627 if (flag_dump_unnumbered
628 || (flag_dump_unnumbered_links
&& idx
<= 1
629 && (INSN_P (in_rtx
) || NOTE_P (in_rtx
)
630 || LABEL_P (in_rtx
) || BARRIER_P (in_rtx
))))
631 fputs (" #", m_outfile
);
633 fprintf (m_outfile
, " %d", INSN_UID (sub
));
636 fputs (" 0", m_outfile
);
640 /* Subroutine of print_rtx. Print operand IDX of IN_RTX. */
643 rtx_writer::print_rtx_operand (const_rtx in_rtx
, int idx
)
645 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (in_rtx
));
647 switch (format_ptr
[idx
])
652 str
= XTMPL (in_rtx
, idx
);
657 str
= XSTR (in_rtx
, idx
);
661 fputs (" (nil)", m_outfile
);
663 fprintf (m_outfile
, " (\"%s\")", str
);
668 print_rtx_operand_code_0 (in_rtx
, idx
);
672 print_rtx_operand_code_e (in_rtx
, idx
);
677 print_rtx_operand_codes_E_and_V (in_rtx
, idx
);
682 fprintf (m_outfile
, " ");
683 fprintf (m_outfile
, HOST_WIDE_INT_PRINT_DEC
, XWINT (in_rtx
, idx
));
684 if (! m_simple
&& !m_compact
)
685 fprintf (m_outfile
, " [" HOST_WIDE_INT_PRINT_HEX
"]",
686 (unsigned HOST_WIDE_INT
) XWINT (in_rtx
, idx
));
690 print_rtx_operand_code_i (in_rtx
, idx
);
694 fprintf (m_outfile
, " ");
695 print_poly_int (m_outfile
, SUBREG_BYTE (in_rtx
));
699 print_rtx_operand_code_r (in_rtx
);
702 /* Print NOTE_INSN names rather than integer codes. */
705 fprintf (m_outfile
, " %s", GET_NOTE_INSN_NAME (XINT (in_rtx
, idx
)));
710 print_rtx_operand_code_u (in_rtx
, idx
);
714 #ifndef GENERATOR_FILE
715 if (idx
== 0 && GET_CODE (in_rtx
) == DEBUG_IMPLICIT_PTR
)
716 print_mem_expr (m_outfile
, DEBUG_IMPLICIT_PTR_DECL (in_rtx
));
717 else if (idx
== 0 && GET_CODE (in_rtx
) == DEBUG_PARAMETER_REF
)
718 print_mem_expr (m_outfile
, DEBUG_PARAMETER_REF_DECL (in_rtx
));
720 dump_addr (m_outfile
, " ", XTREE (in_rtx
, idx
));
725 fputs (" Unknown", m_outfile
);
730 /* Don't print basic block ids in compact mode. */
733 #ifndef GENERATOR_FILE
734 if (XBBDEF (in_rtx
, idx
))
735 fprintf (m_outfile
, " %i", XBBDEF (in_rtx
, idx
)->index
);
744 /* Subroutine of rtx_writer::print_rtx.
745 In compact mode, determine if operand IDX of IN_RTX is interesting
746 to dump, or (if in a trailing position) it can be omitted. */
749 rtx_writer::operand_has_default_value_p (const_rtx in_rtx
, int idx
)
751 const char *format_ptr
= GET_RTX_FORMAT (GET_CODE (in_rtx
));
753 switch (format_ptr
[idx
])
757 return XEXP (in_rtx
, idx
) == NULL_RTX
;
760 return XSTR (in_rtx
, idx
) == NULL
;
763 switch (GET_CODE (in_rtx
))
766 /* JUMP_LABELs are always omitted in compact mode, so treat
767 any value here as omittable, so that earlier operands can
768 potentially be omitted also. */
781 /* Print IN_RTX onto m_outfile. This is the recursive part of printing. */
784 rtx_writer::print_rtx (const_rtx in_rtx
)
791 fputc (' ', m_outfile
);
793 fprintf (m_outfile
, "\n%s%*s", print_rtx_head
, m_indent
* 2, "");
799 fputs ("(nil)", m_outfile
);
803 else if (GET_CODE (in_rtx
) > NUM_RTX_CODE
)
805 fprintf (m_outfile
, "(??? bad code %d\n%s%*s)", GET_CODE (in_rtx
),
806 print_rtx_head
, m_indent
* 2, "");
811 fputc ('(', m_outfile
);
813 /* Print name of expression code. */
816 #ifndef GENERATOR_FILE
817 if (m_rtx_reuse_manager
)
820 if (m_rtx_reuse_manager
->has_reuse_id (in_rtx
, &reuse_id
))
822 /* Have we already seen the defn of this rtx? */
823 if (m_rtx_reuse_manager
->seen_def_p (reuse_id
))
825 fprintf (m_outfile
, "reuse_rtx %i)", reuse_id
);
831 /* First time we've seen this reused-rtx. */
832 fprintf (m_outfile
, "%i|", reuse_id
);
833 m_rtx_reuse_manager
->set_seen_def (reuse_id
);
837 #endif /* #ifndef GENERATOR_FILE */
839 /* In compact mode, prefix the code of insns with "c",
840 giving "cinsn", "cnote" etc. */
841 if (m_compact
&& is_a
<const rtx_insn
*, const struct rtx_def
> (in_rtx
))
843 /* "ccode_label" is slightly awkward, so special-case it as
845 rtx_code code
= GET_CODE (in_rtx
);
846 if (code
== CODE_LABEL
)
847 fprintf (m_outfile
, "clabel");
849 fprintf (m_outfile
, "c%s", GET_RTX_NAME (code
));
851 else if (m_simple
&& CONST_INT_P (in_rtx
))
854 fprintf (m_outfile
, "%s", GET_RTX_NAME (GET_CODE (in_rtx
)));
858 if (RTX_FLAG (in_rtx
, in_struct
))
859 fputs ("/s", m_outfile
);
861 if (RTX_FLAG (in_rtx
, volatil
))
862 fputs ("/v", m_outfile
);
864 if (RTX_FLAG (in_rtx
, unchanging
))
865 fputs ("/u", m_outfile
);
867 if (RTX_FLAG (in_rtx
, frame_related
))
868 fputs ("/f", m_outfile
);
870 if (RTX_FLAG (in_rtx
, jump
))
871 fputs ("/j", m_outfile
);
873 if (RTX_FLAG (in_rtx
, call
))
874 fputs ("/c", m_outfile
);
876 if (RTX_FLAG (in_rtx
, return_val
))
877 fputs ("/i", m_outfile
);
879 /* Print REG_NOTE names for EXPR_LIST and INSN_LIST. */
880 if ((GET_CODE (in_rtx
) == EXPR_LIST
881 || GET_CODE (in_rtx
) == INSN_LIST
882 || GET_CODE (in_rtx
) == INT_LIST
)
883 && (int)GET_MODE (in_rtx
) < REG_NOTE_MAX
884 && !m_in_call_function_usage
)
885 fprintf (m_outfile
, ":%s",
886 GET_REG_NOTE_NAME (GET_MODE (in_rtx
)));
888 /* For other rtl, print the mode if it's not VOID. */
889 else if (GET_MODE (in_rtx
) != VOIDmode
)
890 fprintf (m_outfile
, ":%s", GET_MODE_NAME (GET_MODE (in_rtx
)));
892 #ifndef GENERATOR_FILE
893 if (GET_CODE (in_rtx
) == VAR_LOCATION
)
895 if (TREE_CODE (PAT_VAR_LOCATION_DECL (in_rtx
)) == STRING_CST
)
896 fputs (" <debug string placeholder>", m_outfile
);
898 print_mem_expr (m_outfile
, PAT_VAR_LOCATION_DECL (in_rtx
));
899 fputc (' ', m_outfile
);
900 print_rtx (PAT_VAR_LOCATION_LOC (in_rtx
));
901 if (PAT_VAR_LOCATION_STATUS (in_rtx
)
902 == VAR_INIT_STATUS_UNINITIALIZED
)
903 fprintf (m_outfile
, " [uninit]");
905 idx
= GET_RTX_LENGTH (VAR_LOCATION
);
910 #ifndef GENERATOR_FILE
911 if (CONST_DOUBLE_AS_FLOAT_P (in_rtx
))
915 /* For insns, print the INSN_UID. */
916 if (INSN_CHAIN_CODE_P (GET_CODE (in_rtx
)))
918 if (flag_dump_unnumbered
)
919 fprintf (m_outfile
, " #");
921 fprintf (m_outfile
, " %d", INSN_UID (in_rtx
));
924 /* Determine which is the final operand to print.
925 In compact mode, skip trailing operands that have the default values
926 e.g. trailing "(nil)" values. */
927 int limit
= GET_RTX_LENGTH (GET_CODE (in_rtx
));
929 while (limit
> idx
&& operand_has_default_value_p (in_rtx
, limit
- 1))
932 /* Get the format string and skip the first elements if we have handled
935 for (; idx
< limit
; idx
++)
936 print_rtx_operand (in_rtx
, idx
);
938 switch (GET_CODE (in_rtx
))
940 #ifndef GENERATOR_FILE
942 if (__builtin_expect (final_insns_dump_p
, false))
943 fprintf (m_outfile
, " [");
945 fprintf (m_outfile
, " [" HOST_WIDE_INT_PRINT_DEC
,
946 (HOST_WIDE_INT
) MEM_ALIAS_SET (in_rtx
));
948 if (MEM_EXPR (in_rtx
))
949 print_mem_expr (m_outfile
, MEM_EXPR (in_rtx
));
951 fputc (' ', m_outfile
);
953 if (MEM_OFFSET_KNOWN_P (in_rtx
))
955 fprintf (m_outfile
, "+");
956 print_poly_int (m_outfile
, MEM_OFFSET (in_rtx
));
959 if (MEM_SIZE_KNOWN_P (in_rtx
))
961 fprintf (m_outfile
, " S");
962 print_poly_int (m_outfile
, MEM_SIZE (in_rtx
));
965 if (MEM_ALIGN (in_rtx
) != 1)
966 fprintf (m_outfile
, " A%u", MEM_ALIGN (in_rtx
));
968 if (!ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (in_rtx
)))
969 fprintf (m_outfile
, " AS%u", MEM_ADDR_SPACE (in_rtx
));
971 fputc (']', m_outfile
);
975 if (FLOAT_MODE_P (GET_MODE (in_rtx
)))
979 real_to_decimal (s
, CONST_DOUBLE_REAL_VALUE (in_rtx
),
981 fprintf (m_outfile
, " %s", s
);
983 real_to_hexadecimal (s
, CONST_DOUBLE_REAL_VALUE (in_rtx
),
985 fprintf (m_outfile
, " [%s]", s
);
990 fprintf (m_outfile
, " ");
991 cwi_output_hex (m_outfile
, in_rtx
);
995 fprintf (m_outfile
, " [");
996 print_dec (CONST_POLY_INT_COEFFS (in_rtx
)[0], m_outfile
, SIGNED
);
997 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
999 fprintf (m_outfile
, ", ");
1000 print_dec (CONST_POLY_INT_COEFFS (in_rtx
)[i
], m_outfile
, SIGNED
);
1002 fprintf (m_outfile
, "]");
1008 fprintf (m_outfile
, " [%d uses]", LABEL_NUSES (in_rtx
));
1009 switch (LABEL_KIND (in_rtx
))
1011 case LABEL_NORMAL
: break;
1012 case LABEL_STATIC_ENTRY
: fputs (" [entry]", m_outfile
); break;
1013 case LABEL_GLOBAL_ENTRY
: fputs (" [global entry]", m_outfile
); break;
1014 case LABEL_WEAK_ENTRY
: fputs (" [weak entry]", m_outfile
); break;
1015 default: gcc_unreachable ();
1023 fputc (')', m_outfile
);
1027 /* Emit a closing parenthesis and newline. */
1030 rtx_writer::finish_directive ()
1032 fprintf (m_outfile
, ")\n");
1036 /* Print an rtx on the current line of FILE. Initially indent IND
1040 print_inline_rtx (FILE *outf
, const_rtx x
, int ind
)
1042 rtx_writer
w (outf
, ind
, false, false, NULL
);
1046 /* Call this function from the debugger to see what X looks like. */
1049 debug_rtx (const_rtx x
)
1051 rtx_writer
w (stderr
, 0, false, false, NULL
);
1053 fprintf (stderr
, "\n");
1059 debug (const rtx_def
&ref
)
1065 debug (const rtx_def
*ptr
)
1070 fprintf (stderr
, "<nil>\n");
1073 /* Like debug_rtx but with no newline, as debug_helper will add one.
1075 Note: No debug_slim(rtx_insn *) variant implemented, as this
1076 function can serve for both rtx and rtx_insn. */
1079 debug_slim (const_rtx x
)
1081 rtx_writer
w (stderr
, 0, false, false, NULL
);
1085 DEFINE_DEBUG_VEC (rtx_def
*)
1086 DEFINE_DEBUG_VEC (rtx_insn
*)
1087 DEFINE_DEBUG_HASH_SET (rtx_def
*)
1088 DEFINE_DEBUG_HASH_SET (rtx_insn
*)
1090 /* Count of rtx's to print with debug_rtx_list.
1091 This global exists because gdb user defined commands have no arguments. */
1093 DEBUG_VARIABLE
int debug_rtx_count
= 0; /* 0 is treated as equivalent to 1 */
1095 /* Call this function to print list from X on.
1097 N is a count of the rtx's to print. Positive values print from the specified
1098 rtx_insn on. Negative values print a window around the rtx_insn.
1099 EG: -5 prints 2 rtx_insn's on either side (in addition to the specified
1103 debug_rtx_list (const rtx_insn
*x
, int n
)
1106 const rtx_insn
*insn
;
1108 count
= n
== 0 ? 1 : n
< 0 ? -n
: n
;
1110 /* If we are printing a window, back up to the start. */
1113 for (i
= count
/ 2; i
> 0; i
--)
1115 if (PREV_INSN (x
) == 0)
1120 for (i
= count
, insn
= x
; i
> 0 && insn
!= 0; i
--, insn
= NEXT_INSN (insn
))
1123 fprintf (stderr
, "\n");
1127 /* Call this function to print an rtx_insn list from START to END
1131 debug_rtx_range (const rtx_insn
*start
, const rtx_insn
*end
)
1136 fprintf (stderr
, "\n");
1137 if (!start
|| start
== end
)
1139 start
= NEXT_INSN (start
);
1143 /* Call this function to search an rtx_insn list to find one with insn uid UID,
1144 and then call debug_rtx_list to print it, using DEBUG_RTX_COUNT.
1145 The found insn is returned to enable further debugging analysis. */
1147 DEBUG_FUNCTION
const rtx_insn
*
1148 debug_rtx_find (const rtx_insn
*x
, int uid
)
1150 while (x
!= 0 && INSN_UID (x
) != uid
)
1154 debug_rtx_list (x
, debug_rtx_count
);
1159 fprintf (stderr
, "insn uid %d not found\n", uid
);
1164 /* External entry point for printing a chain of insns
1165 starting with RTX_FIRST.
1166 A blank line separates insns.
1168 If RTX_FIRST is not an insn, then it alone is printed, with no newline. */
1171 rtx_writer::print_rtl (const_rtx rtx_first
)
1173 const rtx_insn
*tmp_rtx
;
1177 fputs (print_rtx_head
, m_outfile
);
1178 fputs ("(nil)\n", m_outfile
);
1181 switch (GET_CODE (rtx_first
))
1188 case JUMP_TABLE_DATA
:
1190 for (tmp_rtx
= as_a
<const rtx_insn
*> (rtx_first
);
1192 tmp_rtx
= NEXT_INSN (tmp_rtx
))
1194 fputs (print_rtx_head
, m_outfile
);
1195 print_rtx (tmp_rtx
);
1196 fprintf (m_outfile
, "\n");
1201 fputs (print_rtx_head
, m_outfile
);
1202 print_rtx (rtx_first
);
1206 /* External entry point for printing a chain of insns
1207 starting with RTX_FIRST onto file OUTF.
1208 A blank line separates insns.
1210 If RTX_FIRST is not an insn, then it alone is printed, with no newline. */
1213 print_rtl (FILE *outf
, const_rtx rtx_first
)
1215 rtx_writer
w (outf
, 0, false, false, NULL
);
1216 w
.print_rtl (rtx_first
);
1219 /* Like print_rtx, except specify a file. */
1220 /* Return nonzero if we actually printed anything. */
1223 print_rtl_single (FILE *outf
, const_rtx x
)
1225 rtx_writer
w (outf
, 0, false, false, NULL
);
1226 return w
.print_rtl_single_with_indent (x
, 0);
1229 /* Like print_rtl_single, except specify an indentation. */
1232 rtx_writer::print_rtl_single_with_indent (const_rtx x
, int ind
)
1234 char *s_indent
= (char *) alloca ((size_t) ind
+ 1);
1235 memset ((void *) s_indent
, ' ', (size_t) ind
);
1236 s_indent
[ind
] = '\0';
1237 fputs (s_indent
, m_outfile
);
1238 fputs (print_rtx_head
, m_outfile
);
1240 int old_indent
= m_indent
;
1244 putc ('\n', m_outfile
);
1245 m_indent
= old_indent
;
1250 /* Like print_rtl except without all the detail; for example,
1251 if RTX is a CONST_INT then print in decimal format. */
1254 print_simple_rtl (FILE *outf
, const_rtx x
)
1256 rtx_writer
w (outf
, 0, true, false, NULL
);
1260 /* Print the elements of VEC to FILE. */
1263 print_rtx_insn_vec (FILE *file
, const vec
<rtx_insn
*> &vec
)
1267 unsigned int len
= vec
.length ();
1268 for (unsigned int i
= 0; i
< len
; i
++)
1270 print_rtl_single (file
, vec
[i
]);
1278 #ifndef GENERATOR_FILE
1279 /* The functions below try to print RTL in a form resembling assembler
1280 mnemonics. Because this form is more concise than the "traditional" form
1281 of RTL printing in Lisp-style, the form printed by this file is called
1282 "slim". RTL dumps in slim format can be obtained by appending the "-slim"
1283 option to -fdump-rtl-<pass>. Control flow graph output as a DOT file is
1284 always printed in slim form.
1286 The normal interface to the functionality provided in this pretty-printer
1287 is through the dump_*_slim functions to print to a stream, or via the
1288 print_*_slim functions to print into a user's pretty-printer.
1290 It is also possible to obtain a string for a single pattern as a string
1291 pointer, via str_pattern_slim, but this usage is discouraged. */
1293 /* This recognizes rtx'en classified as expressions. These are always
1294 represent some action on values or results of other expression, that
1295 may be stored in objects representing values. */
1298 print_exp (pretty_printer
*pp
, const_rtx x
, int verbose
)
1306 for (i
= 0; i
< 4; i
++)
1312 switch (GET_CODE (x
))
1315 op
[0] = XEXP (x
, 0);
1316 if (CONST_INT_P (XEXP (x
, 1))
1317 && INTVAL (XEXP (x
, 1)) < 0)
1320 op
[1] = GEN_INT (-INTVAL (XEXP (x
, 1)));
1325 op
[1] = XEXP (x
, 1);
1329 op
[0] = XEXP (x
, 0);
1331 op
[1] = XEXP (x
, 1);
1335 op
[0] = XEXP (x
, 0);
1337 op
[1] = XEXP (x
, 1);
1341 op
[0] = XEXP (x
, 0);
1342 op
[1] = XEXP (x
, 1);
1346 op
[0] = XEXP (x
, 0);
1350 op
[0] = XEXP (x
, 0);
1352 op
[1] = XEXP (x
, 1);
1354 op
[2] = XEXP (x
, 2);
1358 op
[0] = XEXP (x
, 0);
1360 op
[1] = XEXP (x
, 1);
1363 op
[0] = XEXP (x
, 0);
1365 op
[1] = XEXP (x
, 1);
1369 op
[0] = XEXP (x
, 0);
1370 op
[1] = XEXP (x
, 1);
1373 op
[0] = XEXP (x
, 0);
1375 op
[1] = XEXP (x
, 1);
1379 op
[0] = XEXP (x
, 0);
1380 op
[1] = XEXP (x
, 1);
1384 op
[0] = XEXP (x
, 0);
1385 op
[1] = XEXP (x
, 1);
1389 op
[0] = XEXP (x
, 0);
1390 op
[1] = XEXP (x
, 1);
1394 op
[0] = XEXP (x
, 0);
1395 op
[1] = XEXP (x
, 1);
1399 op
[0] = XEXP (x
, 0);
1400 op
[1] = XEXP (x
, 1);
1404 op
[0] = XEXP (x
, 0);
1407 op
[0] = XEXP (x
, 0);
1409 op
[1] = XEXP (x
, 1);
1412 op
[0] = XEXP (x
, 0);
1414 op
[1] = XEXP (x
, 1);
1417 op
[0] = XEXP (x
, 0);
1419 op
[1] = XEXP (x
, 1);
1422 op
[0] = XEXP (x
, 0);
1424 op
[1] = XEXP (x
, 1);
1427 op
[0] = XEXP (x
, 0);
1429 op
[1] = XEXP (x
, 1);
1432 op
[0] = XEXP (x
, 0);
1434 op
[1] = XEXP (x
, 1);
1437 op
[0] = XEXP (x
, 0);
1439 op
[1] = XEXP (x
, 1);
1442 op
[0] = XEXP (x
, 0);
1444 op
[1] = XEXP (x
, 1);
1447 op
[0] = XEXP (x
, 0);
1449 op
[1] = XEXP (x
, 1);
1452 op
[0] = XEXP (x
, 0);
1454 op
[1] = XEXP (x
, 1);
1457 op
[0] = XEXP (x
, 0);
1459 op
[1] = XEXP (x
, 1);
1462 op
[0] = XEXP (x
, 0);
1464 op
[1] = XEXP (x
, 1);
1467 op
[0] = XEXP (x
, 0);
1469 op
[1] = XEXP (x
, 1);
1472 op
[0] = XEXP (x
, 0);
1474 op
[1] = XEXP (x
, 1);
1477 fun
= (verbose
) ? "sign_extract" : "sxt";
1478 op
[0] = XEXP (x
, 0);
1479 op
[1] = XEXP (x
, 1);
1480 op
[2] = XEXP (x
, 2);
1483 fun
= (verbose
) ? "zero_extract" : "zxt";
1484 op
[0] = XEXP (x
, 0);
1485 op
[1] = XEXP (x
, 1);
1486 op
[2] = XEXP (x
, 2);
1489 fun
= (verbose
) ? "sign_extend" : "sxn";
1490 op
[0] = XEXP (x
, 0);
1493 fun
= (verbose
) ? "zero_extend" : "zxn";
1494 op
[0] = XEXP (x
, 0);
1497 fun
= (verbose
) ? "float_extend" : "fxn";
1498 op
[0] = XEXP (x
, 0);
1501 fun
= (verbose
) ? "trunc" : "trn";
1502 op
[0] = XEXP (x
, 0);
1504 case FLOAT_TRUNCATE
:
1505 fun
= (verbose
) ? "float_trunc" : "ftr";
1506 op
[0] = XEXP (x
, 0);
1509 fun
= (verbose
) ? "float" : "flt";
1510 op
[0] = XEXP (x
, 0);
1512 case UNSIGNED_FLOAT
:
1513 fun
= (verbose
) ? "uns_float" : "ufl";
1514 op
[0] = XEXP (x
, 0);
1518 op
[0] = XEXP (x
, 0);
1521 fun
= (verbose
) ? "uns_fix" : "ufx";
1522 op
[0] = XEXP (x
, 0);
1526 op
[0] = XEXP (x
, 0);
1530 op
[0] = XEXP (x
, 0);
1533 op
[0] = XEXP (x
, 0);
1537 op
[0] = XEXP (x
, 0);
1542 op
[0] = XEXP (XEXP (x
, 1), 0);
1544 op
[1] = XEXP (XEXP (x
, 1), 1);
1548 op
[0] = XEXP (XEXP (x
, 1), 0);
1550 op
[1] = XEXP (XEXP (x
, 1), 1);
1554 op
[0] = XEXP (x
, 0);
1558 op
[1] = XEXP (x
, 1);
1563 op
[0] = XEXP (x
, 0);
1565 op
[1] = XEXP (x
, 1);
1567 op
[2] = XEXP (x
, 2);
1572 op
[0] = TRAP_CONDITION (x
);
1576 op
[0] = XEXP (x
, 0);
1577 op
[1] = XEXP (x
, 1);
1578 op
[2] = XEXP (x
, 2);
1581 case UNSPEC_VOLATILE
:
1583 pp_string (pp
, "unspec");
1584 if (GET_CODE (x
) == UNSPEC_VOLATILE
)
1585 pp_string (pp
, "/v");
1586 pp_left_bracket (pp
);
1587 for (i
= 0; i
< XVECLEN (x
, 0); i
++)
1591 print_pattern (pp
, XVECEXP (x
, 0, i
), verbose
);
1593 pp_string (pp
, "] ");
1594 pp_decimal_int (pp
, XINT (x
, 1));
1599 /* Most unhandled codes can be printed as pseudo-functions. */
1600 if (GET_RTX_CLASS (GET_CODE (x
)) == RTX_UNARY
)
1602 fun
= GET_RTX_NAME (GET_CODE (x
));
1603 op
[0] = XEXP (x
, 0);
1605 else if (GET_RTX_CLASS (GET_CODE (x
)) == RTX_COMPARE
1606 || GET_RTX_CLASS (GET_CODE (x
)) == RTX_COMM_COMPARE
1607 || GET_RTX_CLASS (GET_CODE (x
)) == RTX_BIN_ARITH
1608 || GET_RTX_CLASS (GET_CODE (x
)) == RTX_COMM_ARITH
)
1610 fun
= GET_RTX_NAME (GET_CODE (x
));
1611 op
[0] = XEXP (x
, 0);
1612 op
[1] = XEXP (x
, 1);
1614 else if (GET_RTX_CLASS (GET_CODE (x
)) == RTX_TERNARY
)
1616 fun
= GET_RTX_NAME (GET_CODE (x
));
1617 op
[0] = XEXP (x
, 0);
1618 op
[1] = XEXP (x
, 1);
1619 op
[2] = XEXP (x
, 2);
1622 /* Give up, just print the RTX name. */
1623 st
[0] = GET_RTX_NAME (GET_CODE (x
));
1628 /* Print this as a function? */
1631 pp_string (pp
, fun
);
1635 for (i
= 0; i
< 4; i
++)
1638 pp_string (pp
, st
[i
]);
1644 print_value (pp
, op
[i
], verbose
);
1649 pp_right_paren (pp
);
1652 /* Prints rtxes, I customarily classified as values. They're constants,
1653 registers, labels, symbols and memory accesses. */
1656 print_value (pretty_printer
*pp
, const_rtx x
, int verbose
)
1662 pp_string (pp
, "(nil)");
1665 switch (GET_CODE (x
))
1668 pp_scalar (pp
, HOST_WIDE_INT_PRINT_HEX
,
1669 (unsigned HOST_WIDE_INT
) INTVAL (x
));
1672 case CONST_WIDE_INT
:
1674 const char *sep
= "<";
1676 for (i
= CONST_WIDE_INT_NUNITS (x
) - 1; i
>= 0; i
--)
1678 pp_string (pp
, sep
);
1680 sprintf (tmp
, HOST_WIDE_INT_PRINT_HEX
,
1681 (unsigned HOST_WIDE_INT
) CONST_WIDE_INT_ELT (x
, i
));
1682 pp_string (pp
, tmp
);
1688 case CONST_POLY_INT
:
1689 pp_left_bracket (pp
);
1690 pp_wide_int (pp
, CONST_POLY_INT_COEFFS (x
)[0], SIGNED
);
1691 for (unsigned int i
= 1; i
< NUM_POLY_INT_COEFFS
; ++i
)
1693 pp_string (pp
, ", ");
1694 pp_wide_int (pp
, CONST_POLY_INT_COEFFS (x
)[i
], SIGNED
);
1696 pp_right_bracket (pp
);
1700 if (FLOAT_MODE_P (GET_MODE (x
)))
1702 real_to_decimal (tmp
, CONST_DOUBLE_REAL_VALUE (x
),
1703 sizeof (tmp
), 0, 1);
1704 pp_string (pp
, tmp
);
1707 pp_printf (pp
, "<%wx,%wx>",
1708 (unsigned HOST_WIDE_INT
) CONST_DOUBLE_LOW (x
),
1709 (unsigned HOST_WIDE_INT
) CONST_DOUBLE_HIGH (x
));
1712 fixed_to_decimal (tmp
, CONST_FIXED_VALUE (x
), sizeof (tmp
));
1713 pp_string (pp
, tmp
);
1716 pp_string (pp
, "\"");
1717 pretty_print_string (pp
, XSTR (x
, 0), strlen (XSTR (x
, 0)));
1718 pp_string (pp
, "\"");
1721 pp_printf (pp
, "`%s'", XSTR (x
, 0));
1724 pp_printf (pp
, "L%d", INSN_UID (label_ref_label (x
)));
1728 case STRICT_LOW_PART
:
1729 pp_printf (pp
, "%s(", GET_RTX_NAME (GET_CODE (x
)));
1730 print_value (pp
, XEXP (x
, 0), verbose
);
1731 pp_right_paren (pp
);
1734 if (REGNO (x
) < FIRST_PSEUDO_REGISTER
)
1736 if (ISDIGIT (reg_names
[REGNO (x
)][0]))
1738 pp_string (pp
, reg_names
[REGNO (x
)]);
1741 pp_printf (pp
, "r%d", REGNO (x
));
1743 pp_printf (pp
, ":%s", GET_MODE_NAME (GET_MODE (x
)));
1746 print_value (pp
, SUBREG_REG (x
), verbose
);
1747 pp_printf (pp
, "#");
1748 pp_wide_integer (pp
, SUBREG_BYTE (x
));
1752 pp_string (pp
, GET_RTX_NAME (GET_CODE (x
)));
1755 pp_left_bracket (pp
);
1756 print_value (pp
, XEXP (x
, 0), verbose
);
1757 pp_right_bracket (pp
);
1760 pp_printf (pp
, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x
)));
1763 print_exp (pp
, x
, verbose
);
1768 /* The next step in insn detalization, its pattern recognition. */
1771 print_pattern (pretty_printer
*pp
, const_rtx x
, int verbose
)
1775 pp_string (pp
, "(nil)");
1779 switch (GET_CODE (x
))
1782 print_value (pp
, SET_DEST (x
), verbose
);
1784 print_value (pp
, SET_SRC (x
), verbose
);
1789 pp_string (pp
, GET_RTX_NAME (GET_CODE (x
)));
1792 print_exp (pp
, x
, verbose
);
1796 pp_printf (pp
, "%s ", GET_RTX_NAME (GET_CODE (x
)));
1797 print_value (pp
, XEXP (x
, 0), verbose
);
1800 pp_string (pp
, "loc ");
1801 print_value (pp
, PAT_VAR_LOCATION_LOC (x
), verbose
);
1805 if (GET_CODE (COND_EXEC_TEST (x
)) == NE
1806 && XEXP (COND_EXEC_TEST (x
), 1) == const0_rtx
)
1807 print_value (pp
, XEXP (COND_EXEC_TEST (x
), 0), verbose
);
1808 else if (GET_CODE (COND_EXEC_TEST (x
)) == EQ
1809 && XEXP (COND_EXEC_TEST (x
), 1) == const0_rtx
)
1811 pp_exclamation (pp
);
1812 print_value (pp
, XEXP (COND_EXEC_TEST (x
), 0), verbose
);
1815 print_value (pp
, COND_EXEC_TEST (x
), verbose
);
1816 pp_string (pp
, ") ");
1817 print_pattern (pp
, COND_EXEC_CODE (x
), verbose
);
1824 for (i
= 0; i
< XVECLEN (x
, 0); i
++)
1826 print_pattern (pp
, XVECEXP (x
, 0, i
), verbose
);
1829 pp_right_brace (pp
);
1834 const rtx_sequence
*seq
= as_a
<const rtx_sequence
*> (x
);
1835 pp_string (pp
, "sequence{");
1836 if (INSN_P (seq
->element (0)))
1838 /* Print the sequence insns indented. */
1839 const char * save_print_rtx_head
= print_rtx_head
;
1840 char indented_print_rtx_head
[32];
1843 gcc_assert (strlen (print_rtx_head
) < sizeof (indented_print_rtx_head
) - 4);
1844 snprintf (indented_print_rtx_head
,
1845 sizeof (indented_print_rtx_head
),
1846 "%s ", print_rtx_head
);
1847 print_rtx_head
= indented_print_rtx_head
;
1848 for (int i
= 0; i
< seq
->len (); i
++)
1849 print_insn_with_notes (pp
, seq
->insn (i
));
1850 pp_printf (pp
, "%s ", save_print_rtx_head
);
1851 print_rtx_head
= save_print_rtx_head
;
1855 for (int i
= 0; i
< seq
->len (); i
++)
1857 print_pattern (pp
, seq
->element (i
), verbose
);
1861 pp_right_brace (pp
);
1865 pp_printf (pp
, "asm {%s}", XSTR (x
, 0));
1868 for (int i
= 0; i
< XVECLEN (x
, 0); i
++)
1870 print_value (pp
, XVECEXP (x
, 0, i
), verbose
);
1875 for (int i
= 0; i
< XVECLEN (x
, 1); i
++)
1877 print_value (pp
, XVECEXP (x
, 1, i
), verbose
);
1882 pp_string (pp
, "trap_if ");
1883 print_value (pp
, TRAP_CONDITION (x
), verbose
);
1886 case UNSPEC_VOLATILE
:
1887 /* Fallthru -- leave UNSPECs to print_exp. */
1889 print_value (pp
, x
, verbose
);
1891 } /* print_pattern */
1893 /* This is the main function in slim rtl visualization mechanism.
1895 X is an insn, to be printed into PP.
1897 This function tries to print it properly in human-readable form,
1898 resembling assembler mnemonics (instead of the older Lisp-style
1901 If VERBOSE is TRUE, insns are printed with more complete (but
1902 longer) pattern names and with extra information, and prefixed
1903 with their INSN_UIDs. */
1906 print_insn (pretty_printer
*pp
, const rtx_insn
*x
, int verbose
)
1910 /* Blech, pretty-print can't print integers with a specified width. */
1911 char uid_prefix
[32];
1912 snprintf (uid_prefix
, sizeof uid_prefix
, " %4d: ", INSN_UID (x
));
1913 pp_string (pp
, uid_prefix
);
1916 switch (GET_CODE (x
))
1919 print_pattern (pp
, PATTERN (x
), verbose
);
1924 if (DEBUG_MARKER_INSN_P (x
))
1926 switch (INSN_DEBUG_MARKER_KIND (x
))
1928 case NOTE_INSN_BEGIN_STMT
:
1929 pp_string (pp
, "debug begin stmt marker");
1932 case NOTE_INSN_INLINE_ENTRY
:
1933 pp_string (pp
, "debug inline entry marker");
1942 const char *name
= "?";
1945 if (DECL_P (INSN_VAR_LOCATION_DECL (x
)))
1947 tree id
= DECL_NAME (INSN_VAR_LOCATION_DECL (x
));
1949 name
= IDENTIFIER_POINTER (id
);
1950 else if (TREE_CODE (INSN_VAR_LOCATION_DECL (x
))
1953 sprintf (idbuf
, "D#%i",
1954 DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (x
)));
1959 sprintf (idbuf
, "D.%i",
1960 DECL_UID (INSN_VAR_LOCATION_DECL (x
)));
1964 pp_printf (pp
, "debug %s => ", name
);
1965 if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (x
)))
1966 pp_string (pp
, "optimized away");
1968 print_pattern (pp
, INSN_VAR_LOCATION_LOC (x
), verbose
);
1973 print_pattern (pp
, PATTERN (x
), verbose
);
1976 if (GET_CODE (PATTERN (x
)) == PARALLEL
)
1977 print_pattern (pp
, XVECEXP (PATTERN (x
), 0, 0), verbose
);
1979 print_pattern (pp
, PATTERN (x
), verbose
);
1982 pp_printf (pp
, "L%d:", INSN_UID (x
));
1984 case JUMP_TABLE_DATA
:
1985 pp_string (pp
, "jump_table_data{\n");
1986 print_pattern (pp
, PATTERN (x
), verbose
);
1987 pp_right_brace (pp
);
1990 pp_string (pp
, "barrier");
1994 pp_string (pp
, GET_NOTE_INSN_NAME (NOTE_KIND (x
)));
1995 switch (NOTE_KIND (x
))
1997 case NOTE_INSN_EH_REGION_BEG
:
1998 case NOTE_INSN_EH_REGION_END
:
1999 pp_printf (pp
, " %d", NOTE_EH_HANDLER (x
));
2002 case NOTE_INSN_BLOCK_BEG
:
2003 case NOTE_INSN_BLOCK_END
:
2004 pp_printf (pp
, " %d", BLOCK_NUMBER (NOTE_BLOCK (x
)));
2007 case NOTE_INSN_BASIC_BLOCK
:
2008 pp_printf (pp
, " %d", NOTE_BASIC_BLOCK (x
)->index
);
2011 case NOTE_INSN_DELETED_LABEL
:
2012 case NOTE_INSN_DELETED_DEBUG_LABEL
:
2014 const char *label
= NOTE_DELETED_LABEL_NAME (x
);
2017 pp_printf (pp
, " (\"%s\")", label
);
2021 case NOTE_INSN_VAR_LOCATION
:
2023 print_pattern (pp
, NOTE_VAR_LOCATION (x
), verbose
);
2024 pp_right_brace (pp
);
2037 /* Pretty-print a slim dump of X (an insn) to PP, including any register
2038 note attached to the instruction. */
2041 print_insn_with_notes (pretty_printer
*pp
, const rtx_insn
*x
)
2043 pp_string (pp
, print_rtx_head
);
2044 print_insn (pp
, x
, 1);
2046 if (INSN_P (x
) && REG_NOTES (x
))
2047 for (rtx note
= REG_NOTES (x
); note
; note
= XEXP (note
, 1))
2049 pp_printf (pp
, "%s %s ", print_rtx_head
,
2050 GET_REG_NOTE_NAME (REG_NOTE_KIND (note
)));
2051 if (GET_CODE (note
) == INT_LIST
)
2052 pp_printf (pp
, "%d", XINT (note
, 0));
2054 print_pattern (pp
, XEXP (note
, 0), 1);
2059 /* Print X, an RTL value node, to file F in slim format. Include
2060 additional information if VERBOSE is nonzero.
2062 Value nodes are constants, registers, labels, symbols and
2066 dump_value_slim (FILE *f
, const_rtx x
, int verbose
)
2068 pretty_printer rtl_slim_pp
;
2069 rtl_slim_pp
.buffer
->stream
= f
;
2070 print_value (&rtl_slim_pp
, x
, verbose
);
2071 pp_flush (&rtl_slim_pp
);
2074 /* Emit a slim dump of X (an insn) to the file F, including any register
2075 note attached to the instruction. */
2077 dump_insn_slim (FILE *f
, const rtx_insn
*x
)
2079 pretty_printer rtl_slim_pp
;
2080 rtl_slim_pp
.buffer
->stream
= f
;
2081 print_insn_with_notes (&rtl_slim_pp
, x
);
2082 pp_flush (&rtl_slim_pp
);
2085 /* Same as above, but stop at LAST or when COUNT == 0.
2086 If COUNT < 0 it will stop only at LAST or NULL rtx. */
2089 dump_rtl_slim (FILE *f
, const rtx_insn
*first
, const rtx_insn
*last
,
2090 int count
, int flags ATTRIBUTE_UNUSED
)
2092 const rtx_insn
*insn
, *tail
;
2093 pretty_printer rtl_slim_pp
;
2094 rtl_slim_pp
.buffer
->stream
= f
;
2096 tail
= last
? NEXT_INSN (last
) : NULL
;
2098 (insn
!= NULL
) && (insn
!= tail
) && (count
!= 0);
2099 insn
= NEXT_INSN (insn
))
2101 print_insn_with_notes (&rtl_slim_pp
, insn
);
2106 pp_flush (&rtl_slim_pp
);
2109 /* Dumps basic block BB to pretty-printer PP in slim form and without and
2110 no indentation, for use as a label of a DOT graph record-node. */
2113 rtl_dump_bb_for_graph (pretty_printer
*pp
, basic_block bb
)
2118 /* TODO: inter-bb stuff. */
2119 FOR_BB_INSNS (bb
, insn
)
2124 pp_write_text_to_stream (pp
);
2127 print_insn_with_notes (pp
, insn
);
2128 pp_write_text_as_dot_label_to_stream (pp
, /*for_record=*/true);
2132 /* Pretty-print pattern X of some insn in non-verbose mode.
2133 Return a string pointer to the pretty-printer buffer.
2135 This function is only exported exists only to accommodate some older users
2136 of the slim RTL pretty printers. Please do not use it for new code. */
2139 str_pattern_slim (const_rtx x
)
2141 pretty_printer rtl_slim_pp
;
2142 print_pattern (&rtl_slim_pp
, x
, 0);
2143 return ggc_strdup (pp_formatted_text (&rtl_slim_pp
));
2146 /* Emit a slim dump of X (an insn) to stderr. */
2147 extern void debug_insn_slim (const rtx_insn
*);
2149 debug_insn_slim (const rtx_insn
*x
)
2151 dump_insn_slim (stderr
, x
);
2154 /* Same as above, but using dump_rtl_slim. */
2155 extern void debug_rtl_slim (FILE *, const rtx_insn
*, const rtx_insn
*,
2158 debug_rtl_slim (const rtx_insn
*first
, const rtx_insn
*last
, int count
,
2161 dump_rtl_slim (stderr
, first
, last
, count
, flags
);
2164 extern void debug_bb_slim (basic_block
);
2166 debug_bb_slim (basic_block bb
)
2168 debug_bb (bb
, TDF_SLIM
| TDF_BLOCKS
);
2171 extern void debug_bb_n_slim (int);
2173 debug_bb_n_slim (int n
)
2175 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, n
);
2182 # pragma GCC diagnostic pop