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"
33 #include "sched-int.h"
36 #ifdef INSN_SCHEDULING
37 /* target_units bitmask has 1 for each unit in the cpu. It should be
38 possible to compute this variable from the machine description.
39 But currently it is computed by examining the insn list. Since
40 this is only needed for visualization, it seems an acceptable
41 solution. (For understanding the mapping of bits to units, see
42 definition of function_units[] in "insn-attrtab.c".) The scheduler
43 using only DFA description should never use the following variable. */
45 static int target_units = 0;
47 static char *safe_concat PARAMS ((char *, char *, const char *));
48 static int get_visual_tbl_length PARAMS ((void));
49 static void print_exp PARAMS ((char *, rtx, int));
50 static void print_value PARAMS ((char *, rtx, int));
51 static void print_pattern PARAMS ((char *, rtx, int));
52 static void print_insn 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 sprintf (t, "<0x%lx,0x%lx>", (long) XWINT (x, 2), (long) XWINT (x, 3));
565 cur = safe_concat (buf, cur, t);
568 cur = safe_concat (buf, cur, "\"");
569 cur = safe_concat (buf, cur, XSTR (x, 0));
570 cur = safe_concat (buf, cur, "\"");
573 cur = safe_concat (buf, cur, "`");
574 cur = safe_concat (buf, cur, XSTR (x, 0));
575 cur = safe_concat (buf, cur, "'");
578 sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
579 cur = safe_concat (buf, cur, t);
582 print_value (t, XEXP (x, 0), verbose);
583 cur = safe_concat (buf, cur, "const(");
584 cur = safe_concat (buf, cur, t);
585 cur = safe_concat (buf, cur, ")");
588 print_value (t, XEXP (x, 0), verbose);
589 cur = safe_concat (buf, cur, "high(");
590 cur = safe_concat (buf, cur, t);
591 cur = safe_concat (buf, cur, ")");
594 if (REGNO (x) < FIRST_PSEUDO_REGISTER)
596 int c = reg_names[REGNO (x)][0];
598 cur = safe_concat (buf, cur, "%");
600 cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
604 sprintf (t, "r%d", REGNO (x));
605 cur = safe_concat (buf, cur, t);
609 print_value (t, SUBREG_REG (x), verbose);
610 cur = safe_concat (buf, cur, t);
611 sprintf (t, "#%d", SUBREG_BYTE (x));
612 cur = safe_concat (buf, cur, t);
615 cur = safe_concat (buf, cur, "scratch");
618 cur = safe_concat (buf, cur, "cc0");
621 cur = safe_concat (buf, cur, "pc");
624 print_value (t, XEXP (x, 0), verbose);
625 cur = safe_concat (buf, cur, "[");
626 cur = safe_concat (buf, cur, t);
627 cur = safe_concat (buf, cur, "]");
630 print_exp (t, x, verbose);
631 cur = safe_concat (buf, cur, t);
636 /* The next step in insn detalization, its pattern recognition. */
639 print_pattern (buf, x, verbose)
644 char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
646 switch (GET_CODE (x))
649 print_value (t1, SET_DEST (x), verbose);
650 print_value (t2, SET_SRC (x), verbose);
651 sprintf (buf, "%s=%s", t1, t2);
654 sprintf (buf, "return");
657 print_exp (buf, x, verbose);
660 print_value (t1, XEXP (x, 0), verbose);
661 sprintf (buf, "clobber %s", t1);
664 print_value (t1, XEXP (x, 0), verbose);
665 sprintf (buf, "use %s", t1);
668 if (GET_CODE (COND_EXEC_TEST (x)) == NE
669 && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
670 print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
671 else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
672 && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
675 print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
678 print_value (t1, COND_EXEC_TEST (x), verbose);
679 print_pattern (t2, COND_EXEC_CODE (x), verbose);
680 sprintf (buf, "(%s) %s", t1, t2);
687 for (i = 0; i < XVECLEN (x, 0); i++)
689 print_pattern (t2, XVECEXP (x, 0, i), verbose);
690 sprintf (t3, "%s%s;", t1, t2);
693 sprintf (buf, "%s}", t1);
701 for (i = 0; i < XVECLEN (x, 0); i++)
703 print_insn (t2, XVECEXP (x, 0, i), verbose);
704 sprintf (t3, "%s%s;", t1, t2);
707 sprintf (buf, "%s%%}", t1);
711 sprintf (buf, "asm {%s}", XSTR (x, 0));
716 print_value (buf, XEXP (x, 0), verbose);
719 print_value (t1, TRAP_CONDITION (x), verbose);
720 sprintf (buf, "trap_if %s", t1);
726 sprintf (t1, "unspec{");
727 for (i = 0; i < XVECLEN (x, 0); i++)
729 print_pattern (t2, XVECEXP (x, 0, i), verbose);
730 sprintf (t3, "%s%s;", t1, t2);
733 sprintf (buf, "%s}", t1);
736 case UNSPEC_VOLATILE:
740 sprintf (t1, "unspec/v{");
741 for (i = 0; i < XVECLEN (x, 0); i++)
743 print_pattern (t2, XVECEXP (x, 0, i), verbose);
744 sprintf (t3, "%s%s;", t1, t2);
747 sprintf (buf, "%s}", t1);
751 print_value (buf, x, verbose);
753 } /* print_pattern */
755 /* This is the main function in rtl visualization mechanism. It
756 accepts an rtx and tries to recognize it as an insn, then prints it
757 properly in human readable form, resembling assembler mnemonics.
758 For every insn it prints its UID and BB the insn belongs too.
759 (Probably the last "option" should be extended somehow, since it
760 depends now on sched.c inner variables ...) */
763 print_insn (buf, x, verbose)
771 switch (GET_CODE (x))
774 print_pattern (t, PATTERN (x), verbose);
776 sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
779 sprintf (buf, "%-4d %s", INSN_UID (x), t);
782 print_pattern (t, PATTERN (x), verbose);
784 sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
787 sprintf (buf, "%-4d %s", INSN_UID (x), t);
791 if (GET_CODE (x) == PARALLEL)
793 x = XVECEXP (x, 0, 0);
794 print_pattern (t, x, verbose);
797 strcpy (t, "call <...>");
799 sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1), t);
801 sprintf (buf, "%-4d %s", INSN_UID (insn), t);
804 sprintf (buf, "L%d:", INSN_UID (x));
807 sprintf (buf, "i% 4d: barrier", INSN_UID (x));
810 if (NOTE_LINE_NUMBER (x) > 0)
811 sprintf (buf, "%4d note \"%s\" %d", INSN_UID (x),
812 NOTE_SOURCE_FILE (x), NOTE_LINE_NUMBER (x));
814 sprintf (buf, "%4d %s", INSN_UID (x),
815 GET_NOTE_INSN_NAME (NOTE_LINE_NUMBER (x)));
820 sprintf (buf, "Not an INSN at all\n");
824 sprintf (buf, "i%-4d <What?>", INSN_UID (x));
828 /* Print visualization debugging info. The scheduler using only DFA
829 description should never use the following function. */
832 print_block_visualization (s)
838 fprintf (sched_dump, "\n;; ==================== scheduling visualization %s \n", s);
840 /* Print names of units. */
841 fprintf (sched_dump, ";; %-8s", "clock");
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", function_units[unit].name);
846 fprintf (sched_dump, " %-8s\n", "no-unit");
848 fprintf (sched_dump, ";; %-8s", "=====");
849 for (unit = 0; unit < FUNCTION_UNITS_SIZE; unit++)
850 if (function_units[unit].bitmask & target_units)
851 for (i = 0; i < function_units[unit].multiplicity; i++)
852 fprintf (sched_dump, " %-33s", "==============================");
853 fprintf (sched_dump, " %-8s\n", "=======");
855 /* Print insns in each cycle. */
856 fprintf (sched_dump, "%s\n", visual_tbl);
859 /* Print insns in the 'no_unit' column of visualization. */
862 visualize_no_unit (insn)
865 if (n_vis_no_unit < MAX_VISUAL_NO_UNIT)
867 vis_no_unit[n_vis_no_unit] = insn;
872 /* Print insns scheduled in clock, for visualization. */
875 visualize_scheduled_insns (clock)
880 /* If no more room, split table into two. */
881 if (n_visual_lines >= MAX_VISUAL_LINES)
883 print_block_visualization ("(incomplete)");
884 init_block_visualization ();
889 sprintf (visual_tbl + strlen (visual_tbl), ";; %-8d", clock);
890 for (unit = 0; unit < FUNCTION_UNITS_SIZE; unit++)
891 if (function_units[unit].bitmask & target_units)
892 for (i = 0; i < function_units[unit].multiplicity; i++)
894 int instance = unit + i * FUNCTION_UNITS_SIZE;
895 rtx insn = get_unit_last_insn (instance);
897 /* Print insns that still keep the unit busy. */
899 && actual_hazard_this_instance (unit, instance, insn, clock, 0))
902 print_insn (str, insn, 0);
903 str[INSN_LEN] = '\0';
904 sprintf (visual_tbl + strlen (visual_tbl), " %-33s", str);
907 sprintf (visual_tbl + strlen (visual_tbl), " %-33s", "------------------------------");
910 /* Print insns that are not assigned to any unit. */
911 for (i = 0; i < n_vis_no_unit; i++)
912 sprintf (visual_tbl + strlen (visual_tbl), " %-8d",
913 INSN_UID (vis_no_unit[i]));
916 sprintf (visual_tbl + strlen (visual_tbl), "\n");
919 /* Print stalled cycles. */
922 visualize_stall_cycles (stalls)
925 static const char *const prefix = ";; ";
926 const char *suffix = "\n";
929 /* If no more room, split table into two. */
930 if (n_visual_lines >= MAX_VISUAL_LINES)
932 print_block_visualization ("(incomplete)");
933 init_block_visualization ();
938 p = visual_tbl + strlen (visual_tbl);
940 p += strlen (prefix);
942 if ((unsigned) stalls >
943 visual_tbl_line_length - strlen (prefix) - strlen (suffix))
946 stalls = visual_tbl_line_length - strlen (prefix) - strlen (suffix);
949 memset (p, '.', stalls);
955 /* Allocate data used for visualization during scheduling. */
960 visual_tbl = xmalloc (get_visual_tbl_length ());
963 /* Free data used for visualization. */