1 /* Instruction scheduling pass.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2002 Free Software Foundation, Inc.
4 Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
5 and currently maintained by, Jim Wilson (wilson@cygnus.com)
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 2, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to the Free
21 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
30 #include "hard-reg-set.h"
31 #include "basic-block.h"
32 #include "insn-attr.h"
34 #include "sched-int.h"
37 #ifdef INSN_SCHEDULING
38 /* target_units bitmask has 1 for each unit in the cpu. It should be
39 possible to compute this variable from the machine description.
40 But currently it is computed by examining the insn list. Since
41 this is only needed for visualization, it seems an acceptable
42 solution. (For understanding the mapping of bits to units, see
43 definition of function_units[] in "insn-attrtab.c".) The scheduler
44 using only DFA description should never use the following variable. */
46 static int target_units
= 0;
48 static char *safe_concat
PARAMS ((char *, char *, const char *));
49 static int get_visual_tbl_length
PARAMS ((void));
50 static void print_exp
PARAMS ((char *, rtx
, int));
51 static void print_value
PARAMS ((char *, rtx
, int));
52 static void print_pattern
PARAMS ((char *, rtx
, int));
54 /* Print names of units on which insn can/should execute, for debugging. */
57 insn_print_units (insn
)
61 int unit
= insn_unit (insn
);
64 fprintf (sched_dump
, "none");
66 fprintf (sched_dump
, "%s", function_units
[unit
].name
);
69 fprintf (sched_dump
, "[");
70 for (i
= 0, unit
= ~unit
; unit
; i
++, unit
>>= 1)
73 fprintf (sched_dump
, "%s", function_units
[i
].name
);
75 fprintf (sched_dump
, " ");
77 fprintf (sched_dump
, "]");
81 /* MAX_VISUAL_LINES is the maximum number of lines in visualization table
82 of a basic block. If more lines are needed, table is splitted to two.
83 n_visual_lines is the number of lines printed so far for a block.
84 visual_tbl contains the block visualization info.
85 vis_no_unit holds insns in a cycle that are not mapped to any unit. */
86 #define MAX_VISUAL_LINES 100
89 static unsigned visual_tbl_line_length
;
92 #define MAX_VISUAL_NO_UNIT 20
93 rtx vis_no_unit
[MAX_VISUAL_NO_UNIT
];
95 /* Finds units that are in use in this function. Required only
104 for (insn
= get_last_insn (); insn
; insn
= PREV_INSN (insn
))
109 unit
= insn_unit (insn
);
112 target_units
|= ~unit
;
114 target_units
|= (1 << unit
);
118 /* Return the length of the visualization table. */
121 get_visual_tbl_length ()
127 if (targetm
.sched
.use_dfa_pipeline_interface
128 && (*targetm
.sched
.use_dfa_pipeline_interface
) ())
130 visual_tbl_line_length
= 1;
131 return 1; /* Can't return 0 because that will cause problems
135 /* Compute length of one field in line. */
136 s
= (char *) alloca (INSN_LEN
+ 6);
137 sprintf (s
, " %33s", "uname");
140 /* Compute length of one line. */
143 for (unit
= 0; unit
< FUNCTION_UNITS_SIZE
; unit
++)
144 if (function_units
[unit
].bitmask
& target_units
)
145 for (i
= 0; i
< function_units
[unit
].multiplicity
; i
++)
148 n
+= strlen ("\n") + 2;
150 visual_tbl_line_length
= n
;
152 /* Compute length of visualization string. */
153 return (MAX_VISUAL_LINES
* n
);
156 /* Init block visualization debugging info. */
159 init_block_visualization ()
161 strcpy (visual_tbl
, "");
169 safe_concat (buf
, cur
, str
)
174 char *end
= buf
+ BUF_LEN
- 2; /* Leave room for null. */
183 while (cur
< end
&& (c
= *str
++) != '\0')
190 /* This recognizes rtx, I classified as expressions. These are always
191 represent some action on values or results of other expression, that
192 may be stored in objects representing values. */
195 print_exp (buf
, x
, verbose
)
203 const char *fun
= (char *) 0;
208 for (i
= 0; i
< 4; i
++)
214 switch (GET_CODE (x
))
218 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
219 && INTVAL (XEXP (x
, 1)) < 0)
222 op
[1] = GEN_INT (-INTVAL (XEXP (x
, 1)));
402 fun
= (verbose
) ? "sign_extract" : "sxt";
408 fun
= (verbose
) ? "zero_extract" : "zxt";
414 fun
= (verbose
) ? "sign_extend" : "sxn";
418 fun
= (verbose
) ? "zero_extend" : "zxn";
422 fun
= (verbose
) ? "float_extend" : "fxn";
426 fun
= (verbose
) ? "trunc" : "trn";
430 fun
= (verbose
) ? "float_trunc" : "ftr";
434 fun
= (verbose
) ? "float" : "flt";
438 fun
= (verbose
) ? "uns_float" : "ufl";
446 fun
= (verbose
) ? "uns_fix" : "ufx";
485 op
[0] = TRAP_CONDITION (x
);
494 case UNSPEC_VOLATILE
:
496 cur
= safe_concat (buf
, cur
, "unspec");
497 if (GET_CODE (x
) == UNSPEC_VOLATILE
)
498 cur
= safe_concat (buf
, cur
, "/v");
499 cur
= safe_concat (buf
, cur
, "[");
501 for (i
= 0; i
< XVECLEN (x
, 0); i
++)
503 print_pattern (tmp
, XVECEXP (x
, 0, i
), verbose
);
504 cur
= safe_concat (buf
, cur
, sep
);
505 cur
= safe_concat (buf
, cur
, tmp
);
508 cur
= safe_concat (buf
, cur
, "] ");
509 sprintf (tmp
, "%d", XINT (x
, 1));
510 cur
= safe_concat (buf
, cur
, tmp
);
514 /* If (verbose) debug_rtx (x); */
515 st
[0] = GET_RTX_NAME (GET_CODE (x
));
519 /* Print this as a function? */
522 cur
= safe_concat (buf
, cur
, fun
);
523 cur
= safe_concat (buf
, cur
, "(");
526 for (i
= 0; i
< 4; i
++)
529 cur
= safe_concat (buf
, cur
, st
[i
]);
534 cur
= safe_concat (buf
, cur
, ",");
536 print_value (tmp
, op
[i
], verbose
);
537 cur
= safe_concat (buf
, cur
, tmp
);
542 cur
= safe_concat (buf
, cur
, ")");
545 /* Prints rtxes, I customly classified as values. They're constants,
546 registers, labels, symbols and memory accesses. */
549 print_value (buf
, x
, verbose
)
557 switch (GET_CODE (x
))
560 sprintf (t
, HOST_WIDE_INT_PRINT_HEX
, INTVAL (x
));
561 cur
= safe_concat (buf
, cur
, t
);
564 if (FLOAT_MODE_P (GET_MODE (x
)))
565 real_to_decimal (t
, CONST_DOUBLE_REAL_VALUE (x
), sizeof (t
), 0, 1);
567 sprintf (t
, "<0x%lx,0x%lx>", (long) XWINT (x
, 2), (long) XWINT (x
, 3));
568 cur
= safe_concat (buf
, cur
, t
);
571 cur
= safe_concat (buf
, cur
, "\"");
572 cur
= safe_concat (buf
, cur
, XSTR (x
, 0));
573 cur
= safe_concat (buf
, cur
, "\"");
576 cur
= safe_concat (buf
, cur
, "`");
577 cur
= safe_concat (buf
, cur
, XSTR (x
, 0));
578 cur
= safe_concat (buf
, cur
, "'");
581 sprintf (t
, "L%d", INSN_UID (XEXP (x
, 0)));
582 cur
= safe_concat (buf
, cur
, t
);
585 print_value (t
, XEXP (x
, 0), verbose
);
586 cur
= safe_concat (buf
, cur
, "const(");
587 cur
= safe_concat (buf
, cur
, t
);
588 cur
= safe_concat (buf
, cur
, ")");
591 print_value (t
, XEXP (x
, 0), verbose
);
592 cur
= safe_concat (buf
, cur
, "high(");
593 cur
= safe_concat (buf
, cur
, t
);
594 cur
= safe_concat (buf
, cur
, ")");
597 if (REGNO (x
) < FIRST_PSEUDO_REGISTER
)
599 int c
= reg_names
[REGNO (x
)][0];
601 cur
= safe_concat (buf
, cur
, "%");
603 cur
= safe_concat (buf
, cur
, reg_names
[REGNO (x
)]);
607 sprintf (t
, "r%d", REGNO (x
));
608 cur
= safe_concat (buf
, cur
, t
);
612 print_value (t
, SUBREG_REG (x
), verbose
);
613 cur
= safe_concat (buf
, cur
, t
);
614 sprintf (t
, "#%d", SUBREG_BYTE (x
));
615 cur
= safe_concat (buf
, cur
, t
);
618 cur
= safe_concat (buf
, cur
, "scratch");
621 cur
= safe_concat (buf
, cur
, "cc0");
624 cur
= safe_concat (buf
, cur
, "pc");
627 print_value (t
, XEXP (x
, 0), verbose
);
628 cur
= safe_concat (buf
, cur
, "[");
629 cur
= safe_concat (buf
, cur
, t
);
630 cur
= safe_concat (buf
, cur
, "]");
633 print_exp (t
, x
, verbose
);
634 cur
= safe_concat (buf
, cur
, t
);
639 /* The next step in insn detalization, its pattern recognition. */
642 print_pattern (buf
, x
, verbose
)
647 char t1
[BUF_LEN
], t2
[BUF_LEN
], t3
[BUF_LEN
];
649 switch (GET_CODE (x
))
652 print_value (t1
, SET_DEST (x
), verbose
);
653 print_value (t2
, SET_SRC (x
), verbose
);
654 sprintf (buf
, "%s=%s", t1
, t2
);
657 sprintf (buf
, "return");
660 print_exp (buf
, x
, verbose
);
663 print_value (t1
, XEXP (x
, 0), verbose
);
664 sprintf (buf
, "clobber %s", t1
);
667 print_value (t1
, XEXP (x
, 0), verbose
);
668 sprintf (buf
, "use %s", t1
);
671 if (GET_CODE (COND_EXEC_TEST (x
)) == NE
672 && XEXP (COND_EXEC_TEST (x
), 1) == const0_rtx
)
673 print_value (t1
, XEXP (COND_EXEC_TEST (x
), 0), verbose
);
674 else if (GET_CODE (COND_EXEC_TEST (x
)) == EQ
675 && XEXP (COND_EXEC_TEST (x
), 1) == const0_rtx
)
678 print_value (t1
+ 1, XEXP (COND_EXEC_TEST (x
), 0), verbose
);
681 print_value (t1
, COND_EXEC_TEST (x
), verbose
);
682 print_pattern (t2
, COND_EXEC_CODE (x
), verbose
);
683 sprintf (buf
, "(%s) %s", t1
, t2
);
690 for (i
= 0; i
< XVECLEN (x
, 0); i
++)
692 print_pattern (t2
, XVECEXP (x
, 0, i
), verbose
);
693 sprintf (t3
, "%s%s;", t1
, t2
);
696 sprintf (buf
, "%s}", t1
);
700 /* Should never see SEQUENCE codes until after reorg. */
704 sprintf (buf
, "asm {%s}", XSTR (x
, 0));
709 print_value (buf
, XEXP (x
, 0), verbose
);
712 print_value (t1
, TRAP_CONDITION (x
), verbose
);
713 sprintf (buf
, "trap_if %s", t1
);
719 sprintf (t1
, "unspec{");
720 for (i
= 0; i
< XVECLEN (x
, 0); i
++)
722 print_pattern (t2
, XVECEXP (x
, 0, i
), verbose
);
723 sprintf (t3
, "%s%s;", t1
, t2
);
726 sprintf (buf
, "%s}", t1
);
729 case UNSPEC_VOLATILE
:
733 sprintf (t1
, "unspec/v{");
734 for (i
= 0; i
< XVECLEN (x
, 0); i
++)
736 print_pattern (t2
, XVECEXP (x
, 0, i
), verbose
);
737 sprintf (t3
, "%s%s;", t1
, t2
);
740 sprintf (buf
, "%s}", t1
);
744 print_value (buf
, x
, verbose
);
746 } /* print_pattern */
748 /* This is the main function in rtl visualization mechanism. It
749 accepts an rtx and tries to recognize it as an insn, then prints it
750 properly in human readable form, resembling assembler mnemonics.
751 For every insn it prints its UID and BB the insn belongs too.
752 (Probably the last "option" should be extended somehow, since it
753 depends now on sched.c inner variables ...) */
756 print_insn (buf
, x
, verbose
)
764 switch (GET_CODE (x
))
767 print_pattern (t
, PATTERN (x
), verbose
);
769 sprintf (buf
, "%s: %s", (*current_sched_info
->print_insn
) (x
, 1),
772 sprintf (buf
, "%-4d %s", INSN_UID (x
), t
);
775 print_pattern (t
, PATTERN (x
), verbose
);
777 sprintf (buf
, "%s: jump %s", (*current_sched_info
->print_insn
) (x
, 1),
780 sprintf (buf
, "%-4d %s", INSN_UID (x
), t
);
784 if (GET_CODE (x
) == PARALLEL
)
786 x
= XVECEXP (x
, 0, 0);
787 print_pattern (t
, x
, verbose
);
790 strcpy (t
, "call <...>");
792 sprintf (buf
, "%s: %s", (*current_sched_info
->print_insn
) (x
, 1), t
);
794 sprintf (buf
, "%-4d %s", INSN_UID (insn
), t
);
797 sprintf (buf
, "L%d:", INSN_UID (x
));
800 sprintf (buf
, "i% 4d: barrier", INSN_UID (x
));
803 if (NOTE_LINE_NUMBER (x
) > 0)
804 sprintf (buf
, "%4d note \"%s\" %d", INSN_UID (x
),
805 NOTE_SOURCE_FILE (x
), NOTE_LINE_NUMBER (x
));
807 sprintf (buf
, "%4d %s", INSN_UID (x
),
808 GET_NOTE_INSN_NAME (NOTE_LINE_NUMBER (x
)));
813 sprintf (buf
, "Not an INSN at all\n");
817 sprintf (buf
, "i%-4d <What?>", INSN_UID (x
));
821 /* Print visualization debugging info. The scheduler using only DFA
822 description should never use the following function. */
825 print_block_visualization (s
)
831 fprintf (sched_dump
, "\n;; ==================== scheduling visualization %s \n", s
);
833 /* Print names of units. */
834 fprintf (sched_dump
, ";; %-8s", "clock");
835 for (unit
= 0; unit
< FUNCTION_UNITS_SIZE
; unit
++)
836 if (function_units
[unit
].bitmask
& target_units
)
837 for (i
= 0; i
< function_units
[unit
].multiplicity
; i
++)
838 fprintf (sched_dump
, " %-33s", function_units
[unit
].name
);
839 fprintf (sched_dump
, " %-8s\n", "no-unit");
841 fprintf (sched_dump
, ";; %-8s", "=====");
842 for (unit
= 0; unit
< FUNCTION_UNITS_SIZE
; unit
++)
843 if (function_units
[unit
].bitmask
& target_units
)
844 for (i
= 0; i
< function_units
[unit
].multiplicity
; i
++)
845 fprintf (sched_dump
, " %-33s", "==============================");
846 fprintf (sched_dump
, " %-8s\n", "=======");
848 /* Print insns in each cycle. */
849 fprintf (sched_dump
, "%s\n", visual_tbl
);
852 /* Print insns in the 'no_unit' column of visualization. */
855 visualize_no_unit (insn
)
858 if (n_vis_no_unit
< MAX_VISUAL_NO_UNIT
)
860 vis_no_unit
[n_vis_no_unit
] = insn
;
865 /* Print insns scheduled in clock, for visualization. */
868 visualize_scheduled_insns (clock
)
873 /* If no more room, split table into two. */
874 if (n_visual_lines
>= MAX_VISUAL_LINES
)
876 print_block_visualization ("(incomplete)");
877 init_block_visualization ();
882 sprintf (visual_tbl
+ strlen (visual_tbl
), ";; %-8d", clock
);
883 for (unit
= 0; unit
< FUNCTION_UNITS_SIZE
; unit
++)
884 if (function_units
[unit
].bitmask
& target_units
)
885 for (i
= 0; i
< function_units
[unit
].multiplicity
; i
++)
887 int instance
= unit
+ i
* FUNCTION_UNITS_SIZE
;
888 rtx insn
= get_unit_last_insn (instance
);
890 /* Print insns that still keep the unit busy. */
892 && actual_hazard_this_instance (unit
, instance
, insn
, clock
, 0))
895 print_insn (str
, insn
, 0);
896 str
[INSN_LEN
] = '\0';
897 sprintf (visual_tbl
+ strlen (visual_tbl
), " %-33s", str
);
900 sprintf (visual_tbl
+ strlen (visual_tbl
), " %-33s", "------------------------------");
903 /* Print insns that are not assigned to any unit. */
904 for (i
= 0; i
< n_vis_no_unit
; i
++)
905 sprintf (visual_tbl
+ strlen (visual_tbl
), " %-8d",
906 INSN_UID (vis_no_unit
[i
]));
909 sprintf (visual_tbl
+ strlen (visual_tbl
), "\n");
912 /* Print stalled cycles. */
915 visualize_stall_cycles (stalls
)
918 static const char *const prefix
= ";; ";
919 const char *suffix
= "\n";
922 /* If no more room, split table into two. */
923 if (n_visual_lines
>= MAX_VISUAL_LINES
)
925 print_block_visualization ("(incomplete)");
926 init_block_visualization ();
931 p
= visual_tbl
+ strlen (visual_tbl
);
933 p
+= strlen (prefix
);
935 if ((unsigned) stalls
>
936 visual_tbl_line_length
- strlen (prefix
) - strlen (suffix
))
939 stalls
= visual_tbl_line_length
- strlen (prefix
) - strlen (suffix
);
942 memset (p
, '.', stalls
);
948 /* Allocate data used for visualization during scheduling. */
953 visual_tbl
= xmalloc (get_visual_tbl_length ());
956 /* Free data used for visualization. */