1 /* Instruction scheduling pass.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 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"
35 #ifdef INSN_SCHEDULING
36 /* target_units bitmask has 1 for each unit in the cpu. It should be
37 possible to compute this variable from the machine description.
38 But currently it is computed by examining the insn list. Since
39 this is only needed for visualization, it seems an acceptable
40 solution. (For understanding the mapping of bits to units, see
41 definition of function_units[] in "insn-attrtab.c".) */
43 static int target_units = 0;
45 static char *safe_concat PARAMS ((char *, char *, const char *));
46 static int get_visual_tbl_length PARAMS ((void));
47 static void print_exp PARAMS ((char *, rtx, int));
48 static void print_value PARAMS ((char *, rtx, int));
49 static void print_pattern PARAMS ((char *, rtx, int));
50 static void print_insn PARAMS ((char *, rtx, int));
52 /* Print names of units on which insn can/should execute, for debugging. */
55 insn_print_units (insn)
59 int unit = insn_unit (insn);
62 fprintf (sched_dump, "none");
64 fprintf (sched_dump, "%s", function_units[unit].name);
67 fprintf (sched_dump, "[");
68 for (i = 0, unit = ~unit; unit; i++, unit >>= 1)
71 fprintf (sched_dump, "%s", function_units[i].name);
73 fprintf (sched_dump, " ");
75 fprintf (sched_dump, "]");
79 /* MAX_VISUAL_LINES is the maximum number of lines in visualization table
80 of a basic block. If more lines are needed, table is splitted to two.
81 n_visual_lines is the number of lines printed so far for a block.
82 visual_tbl contains the block visualization info.
83 vis_no_unit holds insns in a cycle that are not mapped to any unit. */
84 #define MAX_VISUAL_LINES 100
87 static unsigned visual_tbl_line_length;
90 #define MAX_VISUAL_NO_UNIT 20
91 rtx vis_no_unit[MAX_VISUAL_NO_UNIT];
93 /* Finds units that are in use in this fuction. Required only
102 for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
107 unit = insn_unit (insn);
110 target_units |= ~unit;
112 target_units |= (1 << unit);
116 /* Return the length of the visualization table. */
119 get_visual_tbl_length ()
125 /* Compute length of one field in line. */
126 s = (char *) alloca (INSN_LEN + 6);
127 sprintf (s, " %33s", "uname");
130 /* Compute length of one line. */
133 for (unit = 0; unit < FUNCTION_UNITS_SIZE; unit++)
134 if (function_units[unit].bitmask & target_units)
135 for (i = 0; i < function_units[unit].multiplicity; i++)
138 n += strlen ("\n") + 2;
140 visual_tbl_line_length = n;
142 /* Compute length of visualization string. */
143 return (MAX_VISUAL_LINES * n);
146 /* Init block visualization debugging info. */
149 init_block_visualization ()
151 strcpy (visual_tbl, "");
159 safe_concat (buf, cur, str)
164 char *end = buf + BUF_LEN - 2; /* Leave room for null. */
173 while (cur < end && (c = *str++) != '\0')
180 /* This recognizes rtx, I classified as expressions. These are always
181 represent some action on values or results of other expression, that
182 may be stored in objects representing values. */
185 print_exp (buf, x, verbose)
193 const char *fun = (char *) 0;
198 for (i = 0; i < 4; i++)
204 switch (GET_CODE (x))
208 if (GET_CODE (XEXP (x, 1)) == CONST_INT
209 && INTVAL (XEXP (x, 1)) < 0)
212 op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
392 fun = (verbose) ? "sign_extract" : "sxt";
398 fun = (verbose) ? "zero_extract" : "zxt";
404 fun = (verbose) ? "sign_extend" : "sxn";
408 fun = (verbose) ? "zero_extend" : "zxn";
412 fun = (verbose) ? "float_extend" : "fxn";
416 fun = (verbose) ? "trunc" : "trn";
420 fun = (verbose) ? "float_trunc" : "ftr";
424 fun = (verbose) ? "float" : "flt";
428 fun = (verbose) ? "uns_float" : "ufl";
436 fun = (verbose) ? "uns_fix" : "ufx";
475 op[0] = TRAP_CONDITION (x);
478 case UNSPEC_VOLATILE:
480 cur = safe_concat (buf, cur, "unspec");
481 if (GET_CODE (x) == UNSPEC_VOLATILE)
482 cur = safe_concat (buf, cur, "/v");
483 cur = safe_concat (buf, cur, "[");
485 for (i = 0; i < XVECLEN (x, 0); i++)
487 print_pattern (tmp, XVECEXP (x, 0, i), verbose);
488 cur = safe_concat (buf, cur, sep);
489 cur = safe_concat (buf, cur, tmp);
492 cur = safe_concat (buf, cur, "] ");
493 sprintf (tmp, "%d", XINT (x, 1));
494 cur = safe_concat (buf, cur, tmp);
498 /* If (verbose) debug_rtx (x); */
499 st[0] = GET_RTX_NAME (GET_CODE (x));
503 /* Print this as a function? */
506 cur = safe_concat (buf, cur, fun);
507 cur = safe_concat (buf, cur, "(");
510 for (i = 0; i < 4; i++)
513 cur = safe_concat (buf, cur, st[i]);
518 cur = safe_concat (buf, cur, ",");
520 print_value (tmp, op[i], verbose);
521 cur = safe_concat (buf, cur, tmp);
526 cur = safe_concat (buf, cur, ")");
529 /* Prints rtxes, I customly classified as values. They're constants,
530 registers, labels, symbols and memory accesses. */
533 print_value (buf, x, verbose)
541 switch (GET_CODE (x))
544 sprintf (t, HOST_WIDE_INT_PRINT_HEX, INTVAL (x));
545 cur = safe_concat (buf, cur, t);
548 sprintf (t, "<0x%lx,0x%lx>", (long) XWINT (x, 2), (long) XWINT (x, 3));
549 cur = safe_concat (buf, cur, t);
552 cur = safe_concat (buf, cur, "\"");
553 cur = safe_concat (buf, cur, XSTR (x, 0));
554 cur = safe_concat (buf, cur, "\"");
557 cur = safe_concat (buf, cur, "`");
558 cur = safe_concat (buf, cur, XSTR (x, 0));
559 cur = safe_concat (buf, cur, "'");
562 sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
563 cur = safe_concat (buf, cur, t);
566 print_value (t, XEXP (x, 0), verbose);
567 cur = safe_concat (buf, cur, "const(");
568 cur = safe_concat (buf, cur, t);
569 cur = safe_concat (buf, cur, ")");
572 print_value (t, XEXP (x, 0), verbose);
573 cur = safe_concat (buf, cur, "high(");
574 cur = safe_concat (buf, cur, t);
575 cur = safe_concat (buf, cur, ")");
578 if (REGNO (x) < FIRST_PSEUDO_REGISTER)
580 int c = reg_names[REGNO (x)][0];
581 if (c >= '0' && c <= '9')
582 cur = safe_concat (buf, cur, "%");
584 cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
588 sprintf (t, "r%d", REGNO (x));
589 cur = safe_concat (buf, cur, t);
593 print_value (t, SUBREG_REG (x), verbose);
594 cur = safe_concat (buf, cur, t);
595 sprintf (t, "#%d", SUBREG_BYTE (x));
596 cur = safe_concat (buf, cur, t);
599 cur = safe_concat (buf, cur, "scratch");
602 cur = safe_concat (buf, cur, "cc0");
605 cur = safe_concat (buf, cur, "pc");
608 print_value (t, XEXP (x, 0), verbose);
609 cur = safe_concat (buf, cur, "[");
610 cur = safe_concat (buf, cur, t);
611 cur = safe_concat (buf, cur, "]");
614 print_exp (t, x, verbose);
615 cur = safe_concat (buf, cur, t);
620 /* The next step in insn detalization, its pattern recognition. */
623 print_pattern (buf, x, verbose)
628 char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
630 switch (GET_CODE (x))
633 print_value (t1, SET_DEST (x), verbose);
634 print_value (t2, SET_SRC (x), verbose);
635 sprintf (buf, "%s=%s", t1, t2);
638 sprintf (buf, "return");
641 print_exp (buf, x, verbose);
644 print_value (t1, XEXP (x, 0), verbose);
645 sprintf (buf, "clobber %s", t1);
648 print_value (t1, XEXP (x, 0), verbose);
649 sprintf (buf, "use %s", t1);
652 if (GET_CODE (COND_EXEC_TEST (x)) == NE
653 && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
654 print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
655 else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
656 && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
659 print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
662 print_value (t1, COND_EXEC_TEST (x), verbose);
663 print_pattern (t2, COND_EXEC_CODE (x), verbose);
664 sprintf (buf, "(%s) %s", t1, t2);
671 for (i = 0; i < XVECLEN (x, 0); i++)
673 print_pattern (t2, XVECEXP (x, 0, i), verbose);
674 sprintf (t3, "%s%s;", t1, t2);
677 sprintf (buf, "%s}", t1);
685 for (i = 0; i < XVECLEN (x, 0); i++)
687 print_insn (t2, XVECEXP (x, 0, i), verbose);
688 sprintf (t3, "%s%s;", t1, t2);
691 sprintf (buf, "%s%%}", t1);
695 sprintf (buf, "asm {%s}", XSTR (x, 0));
700 print_value (buf, XEXP (x, 0), verbose);
703 print_value (t1, TRAP_CONDITION (x), verbose);
704 sprintf (buf, "trap_if %s", t1);
710 sprintf (t1, "unspec{");
711 for (i = 0; i < XVECLEN (x, 0); i++)
713 print_pattern (t2, XVECEXP (x, 0, i), verbose);
714 sprintf (t3, "%s%s;", t1, t2);
717 sprintf (buf, "%s}", t1);
720 case UNSPEC_VOLATILE:
724 sprintf (t1, "unspec/v{");
725 for (i = 0; i < XVECLEN (x, 0); i++)
727 print_pattern (t2, XVECEXP (x, 0, i), verbose);
728 sprintf (t3, "%s%s;", t1, t2);
731 sprintf (buf, "%s}", t1);
735 print_value (buf, x, verbose);
737 } /* print_pattern */
739 /* This is the main function in rtl visualization mechanism. It
740 accepts an rtx and tries to recognize it as an insn, then prints it
741 properly in human readable form, resembling assembler mnemonics.
742 For every insn it prints its UID and BB the insn belongs too.
743 (Probably the last "option" should be extended somehow, since it
744 depends now on sched.c inner variables ...) */
747 print_insn (buf, x, verbose)
755 switch (GET_CODE (x))
758 print_pattern (t, PATTERN (x), verbose);
760 sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
763 sprintf (buf, "%-4d %s", INSN_UID (x), t);
766 print_pattern (t, PATTERN (x), verbose);
768 sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
771 sprintf (buf, "%-4d %s", INSN_UID (x), t);
775 if (GET_CODE (x) == PARALLEL)
777 x = XVECEXP (x, 0, 0);
778 print_pattern (t, x, verbose);
781 strcpy (t, "call <...>");
783 sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1), t);
785 sprintf (buf, "%-4d %s", INSN_UID (insn), t);
788 sprintf (buf, "L%d:", INSN_UID (x));
791 sprintf (buf, "i% 4d: barrier", INSN_UID (x));
794 if (NOTE_LINE_NUMBER (x) > 0)
795 sprintf (buf, "%4d note \"%s\" %d", INSN_UID (x),
796 NOTE_SOURCE_FILE (x), NOTE_LINE_NUMBER (x));
798 sprintf (buf, "%4d %s", INSN_UID (x),
799 GET_NOTE_INSN_NAME (NOTE_LINE_NUMBER (x)));
804 sprintf (buf, "Not an INSN at all\n");
808 sprintf (buf, "i%-4d <What?>", INSN_UID (x));
812 /* Print visualization debugging info. */
815 print_block_visualization (s)
821 fprintf (sched_dump, "\n;; ==================== scheduling visualization %s \n", s);
823 /* Print names of units. */
824 fprintf (sched_dump, ";; %-8s", "clock");
825 for (unit = 0; unit < FUNCTION_UNITS_SIZE; unit++)
826 if (function_units[unit].bitmask & target_units)
827 for (i = 0; i < function_units[unit].multiplicity; i++)
828 fprintf (sched_dump, " %-33s", function_units[unit].name);
829 fprintf (sched_dump, " %-8s\n", "no-unit");
831 fprintf (sched_dump, ";; %-8s", "=====");
832 for (unit = 0; unit < FUNCTION_UNITS_SIZE; unit++)
833 if (function_units[unit].bitmask & target_units)
834 for (i = 0; i < function_units[unit].multiplicity; i++)
835 fprintf (sched_dump, " %-33s", "==============================");
836 fprintf (sched_dump, " %-8s\n", "=======");
838 /* Print insns in each cycle. */
839 fprintf (sched_dump, "%s\n", visual_tbl);
842 /* Print insns in the 'no_unit' column of visualization. */
845 visualize_no_unit (insn)
848 if (n_vis_no_unit < MAX_VISUAL_NO_UNIT)
850 vis_no_unit[n_vis_no_unit] = insn;
855 /* Print insns scheduled in clock, for visualization. */
858 visualize_scheduled_insns (clock)
863 /* If no more room, split table into two. */
864 if (n_visual_lines >= MAX_VISUAL_LINES)
866 print_block_visualization ("(incomplete)");
867 init_block_visualization ();
872 sprintf (visual_tbl + strlen (visual_tbl), ";; %-8d", clock);
873 for (unit = 0; unit < FUNCTION_UNITS_SIZE; unit++)
874 if (function_units[unit].bitmask & target_units)
875 for (i = 0; i < function_units[unit].multiplicity; i++)
877 int instance = unit + i * FUNCTION_UNITS_SIZE;
878 rtx insn = get_unit_last_insn (instance);
880 /* Print insns that still keep the unit busy. */
882 && actual_hazard_this_instance (unit, instance, insn, clock, 0))
885 print_insn (str, insn, 0);
886 str[INSN_LEN] = '\0';
887 sprintf (visual_tbl + strlen (visual_tbl), " %-33s", str);
890 sprintf (visual_tbl + strlen (visual_tbl), " %-33s", "------------------------------");
893 /* Print insns that are not assigned to any unit. */
894 for (i = 0; i < n_vis_no_unit; i++)
895 sprintf (visual_tbl + strlen (visual_tbl), " %-8d",
896 INSN_UID (vis_no_unit[i]));
899 sprintf (visual_tbl + strlen (visual_tbl), "\n");
902 /* Print stalled cycles. */
905 visualize_stall_cycles (stalls)
908 static const char *const prefix = ";; ";
909 const char *suffix = "\n";
912 /* If no more room, split table into two. */
913 if (n_visual_lines >= MAX_VISUAL_LINES)
915 print_block_visualization ("(incomplete)");
916 init_block_visualization ();
921 p = visual_tbl + strlen (visual_tbl);
923 p += strlen (prefix);
925 if ((unsigned)stalls >
926 visual_tbl_line_length - strlen (prefix) - strlen (suffix))
929 stalls = visual_tbl_line_length - strlen (prefix) - strlen (suffix);
932 memset (p, '.', stalls);
938 /* Allocate data used for visualization during scheduling. */
943 visual_tbl = xmalloc (get_visual_tbl_length ());
946 /* Free data used for visualization. */