Daily bump.
[official-gcc.git] / gcc / sched-vis.c
blob25a0b600d10947f866b9dbbf10199a53ec955cb2
1 /* Instruction scheduling pass.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010
4 Free Software Foundation, Inc.
5 Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
6 and currently maintained by, Jim Wilson (wilson@cygnus.com)
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
13 version.
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "rtl.h"
29 #include "obstack.h"
30 #include "hard-reg-set.h"
31 #include "basic-block.h"
32 #include "insn-attr.h"
33 #include "sched-int.h"
34 #include "tree-pass.h"
36 static char *safe_concat (char *, char *, const char *);
38 #define BUF_LEN 2048
40 static char *
41 safe_concat (char *buf, char *cur, const char *str)
43 char *end = buf + BUF_LEN - 2; /* Leave room for null. */
44 int c;
46 if (cur > end)
48 *end = '\0';
49 return end;
52 while (cur < end && (c = *str++) != '\0')
53 *cur++ = c;
55 *cur = '\0';
56 return cur;
59 /* This recognizes rtx, I classified as expressions. These are always
60 represent some action on values or results of other expression, that
61 may be stored in objects representing values. */
63 static void
64 print_exp (char *buf, const_rtx x, int verbose)
66 char tmp[BUF_LEN];
67 const char *st[4];
68 char *cur = buf;
69 const char *fun = (char *) 0;
70 const char *sep;
71 rtx op[4];
72 int i;
74 for (i = 0; i < 4; i++)
76 st[i] = (char *) 0;
77 op[i] = NULL_RTX;
80 switch (GET_CODE (x))
82 case PLUS:
83 op[0] = XEXP (x, 0);
84 if (CONST_INT_P (XEXP (x, 1))
85 && INTVAL (XEXP (x, 1)) < 0)
87 st[1] = "-";
88 op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
90 else
92 st[1] = "+";
93 op[1] = XEXP (x, 1);
95 break;
96 case LO_SUM:
97 op[0] = XEXP (x, 0);
98 st[1] = "+low(";
99 op[1] = XEXP (x, 1);
100 st[2] = ")";
101 break;
102 case MINUS:
103 op[0] = XEXP (x, 0);
104 st[1] = "-";
105 op[1] = XEXP (x, 1);
106 break;
107 case COMPARE:
108 fun = "cmp";
109 op[0] = XEXP (x, 0);
110 op[1] = XEXP (x, 1);
111 break;
112 case NEG:
113 st[0] = "-";
114 op[0] = XEXP (x, 0);
115 break;
116 case MULT:
117 op[0] = XEXP (x, 0);
118 st[1] = "*";
119 op[1] = XEXP (x, 1);
120 break;
121 case DIV:
122 op[0] = XEXP (x, 0);
123 st[1] = "/";
124 op[1] = XEXP (x, 1);
125 break;
126 case UDIV:
127 fun = "udiv";
128 op[0] = XEXP (x, 0);
129 op[1] = XEXP (x, 1);
130 break;
131 case MOD:
132 op[0] = XEXP (x, 0);
133 st[1] = "%";
134 op[1] = XEXP (x, 1);
135 break;
136 case UMOD:
137 fun = "umod";
138 op[0] = XEXP (x, 0);
139 op[1] = XEXP (x, 1);
140 break;
141 case SMIN:
142 fun = "smin";
143 op[0] = XEXP (x, 0);
144 op[1] = XEXP (x, 1);
145 break;
146 case SMAX:
147 fun = "smax";
148 op[0] = XEXP (x, 0);
149 op[1] = XEXP (x, 1);
150 break;
151 case UMIN:
152 fun = "umin";
153 op[0] = XEXP (x, 0);
154 op[1] = XEXP (x, 1);
155 break;
156 case UMAX:
157 fun = "umax";
158 op[0] = XEXP (x, 0);
159 op[1] = XEXP (x, 1);
160 break;
161 case NOT:
162 st[0] = "!";
163 op[0] = XEXP (x, 0);
164 break;
165 case AND:
166 op[0] = XEXP (x, 0);
167 st[1] = "&";
168 op[1] = XEXP (x, 1);
169 break;
170 case IOR:
171 op[0] = XEXP (x, 0);
172 st[1] = "|";
173 op[1] = XEXP (x, 1);
174 break;
175 case XOR:
176 op[0] = XEXP (x, 0);
177 st[1] = "^";
178 op[1] = XEXP (x, 1);
179 break;
180 case ASHIFT:
181 op[0] = XEXP (x, 0);
182 st[1] = "<<";
183 op[1] = XEXP (x, 1);
184 break;
185 case LSHIFTRT:
186 op[0] = XEXP (x, 0);
187 st[1] = " 0>>";
188 op[1] = XEXP (x, 1);
189 break;
190 case ASHIFTRT:
191 op[0] = XEXP (x, 0);
192 st[1] = ">>";
193 op[1] = XEXP (x, 1);
194 break;
195 case ROTATE:
196 op[0] = XEXP (x, 0);
197 st[1] = "<-<";
198 op[1] = XEXP (x, 1);
199 break;
200 case ROTATERT:
201 op[0] = XEXP (x, 0);
202 st[1] = ">->";
203 op[1] = XEXP (x, 1);
204 break;
205 case ABS:
206 fun = "abs";
207 op[0] = XEXP (x, 0);
208 break;
209 case SQRT:
210 fun = "sqrt";
211 op[0] = XEXP (x, 0);
212 break;
213 case FFS:
214 fun = "ffs";
215 op[0] = XEXP (x, 0);
216 break;
217 case EQ:
218 op[0] = XEXP (x, 0);
219 st[1] = "==";
220 op[1] = XEXP (x, 1);
221 break;
222 case NE:
223 op[0] = XEXP (x, 0);
224 st[1] = "!=";
225 op[1] = XEXP (x, 1);
226 break;
227 case GT:
228 op[0] = XEXP (x, 0);
229 st[1] = ">";
230 op[1] = XEXP (x, 1);
231 break;
232 case GTU:
233 fun = "gtu";
234 op[0] = XEXP (x, 0);
235 op[1] = XEXP (x, 1);
236 break;
237 case LT:
238 op[0] = XEXP (x, 0);
239 st[1] = "<";
240 op[1] = XEXP (x, 1);
241 break;
242 case LTU:
243 fun = "ltu";
244 op[0] = XEXP (x, 0);
245 op[1] = XEXP (x, 1);
246 break;
247 case GE:
248 op[0] = XEXP (x, 0);
249 st[1] = ">=";
250 op[1] = XEXP (x, 1);
251 break;
252 case GEU:
253 fun = "geu";
254 op[0] = XEXP (x, 0);
255 op[1] = XEXP (x, 1);
256 break;
257 case LE:
258 op[0] = XEXP (x, 0);
259 st[1] = "<=";
260 op[1] = XEXP (x, 1);
261 break;
262 case LEU:
263 fun = "leu";
264 op[0] = XEXP (x, 0);
265 op[1] = XEXP (x, 1);
266 break;
267 case SIGN_EXTRACT:
268 fun = (verbose) ? "sign_extract" : "sxt";
269 op[0] = XEXP (x, 0);
270 op[1] = XEXP (x, 1);
271 op[2] = XEXP (x, 2);
272 break;
273 case ZERO_EXTRACT:
274 fun = (verbose) ? "zero_extract" : "zxt";
275 op[0] = XEXP (x, 0);
276 op[1] = XEXP (x, 1);
277 op[2] = XEXP (x, 2);
278 break;
279 case SIGN_EXTEND:
280 fun = (verbose) ? "sign_extend" : "sxn";
281 op[0] = XEXP (x, 0);
282 break;
283 case ZERO_EXTEND:
284 fun = (verbose) ? "zero_extend" : "zxn";
285 op[0] = XEXP (x, 0);
286 break;
287 case FLOAT_EXTEND:
288 fun = (verbose) ? "float_extend" : "fxn";
289 op[0] = XEXP (x, 0);
290 break;
291 case TRUNCATE:
292 fun = (verbose) ? "trunc" : "trn";
293 op[0] = XEXP (x, 0);
294 break;
295 case FLOAT_TRUNCATE:
296 fun = (verbose) ? "float_trunc" : "ftr";
297 op[0] = XEXP (x, 0);
298 break;
299 case FLOAT:
300 fun = (verbose) ? "float" : "flt";
301 op[0] = XEXP (x, 0);
302 break;
303 case UNSIGNED_FLOAT:
304 fun = (verbose) ? "uns_float" : "ufl";
305 op[0] = XEXP (x, 0);
306 break;
307 case FIX:
308 fun = "fix";
309 op[0] = XEXP (x, 0);
310 break;
311 case UNSIGNED_FIX:
312 fun = (verbose) ? "uns_fix" : "ufx";
313 op[0] = XEXP (x, 0);
314 break;
315 case PRE_DEC:
316 st[0] = "--";
317 op[0] = XEXP (x, 0);
318 break;
319 case PRE_INC:
320 st[0] = "++";
321 op[0] = XEXP (x, 0);
322 break;
323 case POST_DEC:
324 op[0] = XEXP (x, 0);
325 st[1] = "--";
326 break;
327 case POST_INC:
328 op[0] = XEXP (x, 0);
329 st[1] = "++";
330 break;
331 case PRE_MODIFY:
332 st[0] = "pre ";
333 op[0] = XEXP (XEXP (x, 1), 0);
334 st[1] = "+=";
335 op[1] = XEXP (XEXP (x, 1), 1);
336 break;
337 case POST_MODIFY:
338 st[0] = "post ";
339 op[0] = XEXP (XEXP (x, 1), 0);
340 st[1] = "+=";
341 op[1] = XEXP (XEXP (x, 1), 1);
342 break;
343 case CALL:
344 st[0] = "call ";
345 op[0] = XEXP (x, 0);
346 if (verbose)
348 st[1] = " argc:";
349 op[1] = XEXP (x, 1);
351 break;
352 case IF_THEN_ELSE:
353 st[0] = "{(";
354 op[0] = XEXP (x, 0);
355 st[1] = ")?";
356 op[1] = XEXP (x, 1);
357 st[2] = ":";
358 op[2] = XEXP (x, 2);
359 st[3] = "}";
360 break;
361 case TRAP_IF:
362 fun = "trap_if";
363 op[0] = TRAP_CONDITION (x);
364 break;
365 case PREFETCH:
366 fun = "prefetch";
367 op[0] = XEXP (x, 0);
368 op[1] = XEXP (x, 1);
369 op[2] = XEXP (x, 2);
370 break;
371 case UNSPEC:
372 case UNSPEC_VOLATILE:
374 cur = safe_concat (buf, cur, "unspec");
375 if (GET_CODE (x) == UNSPEC_VOLATILE)
376 cur = safe_concat (buf, cur, "/v");
377 cur = safe_concat (buf, cur, "[");
378 sep = "";
379 for (i = 0; i < XVECLEN (x, 0); i++)
381 print_pattern (tmp, XVECEXP (x, 0, i), verbose);
382 cur = safe_concat (buf, cur, sep);
383 cur = safe_concat (buf, cur, tmp);
384 sep = ",";
386 cur = safe_concat (buf, cur, "] ");
387 sprintf (tmp, "%d", XINT (x, 1));
388 cur = safe_concat (buf, cur, tmp);
390 break;
391 default:
392 /* If (verbose) debug_rtx (x); */
393 st[0] = GET_RTX_NAME (GET_CODE (x));
394 break;
397 /* Print this as a function? */
398 if (fun)
400 cur = safe_concat (buf, cur, fun);
401 cur = safe_concat (buf, cur, "(");
404 for (i = 0; i < 4; i++)
406 if (st[i])
407 cur = safe_concat (buf, cur, st[i]);
409 if (op[i])
411 if (fun && i != 0)
412 cur = safe_concat (buf, cur, ",");
414 print_value (tmp, op[i], verbose);
415 cur = safe_concat (buf, cur, tmp);
419 if (fun)
420 cur = safe_concat (buf, cur, ")");
421 } /* print_exp */
423 /* Prints rtxes, I customarily classified as values. They're constants,
424 registers, labels, symbols and memory accesses. */
426 void
427 print_value (char *buf, const_rtx x, int verbose)
429 char t[BUF_LEN];
430 char *cur = buf;
432 if (!x)
434 safe_concat (buf, buf, "(nil)");
435 return;
437 switch (GET_CODE (x))
439 case CONST_INT:
440 sprintf (t, HOST_WIDE_INT_PRINT_HEX,
441 (unsigned HOST_WIDE_INT) INTVAL (x));
442 cur = safe_concat (buf, cur, t);
443 break;
444 case CONST_DOUBLE:
445 if (FLOAT_MODE_P (GET_MODE (x)))
446 real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
447 else
448 sprintf (t,
449 "<" HOST_WIDE_INT_PRINT_HEX "," HOST_WIDE_INT_PRINT_HEX ">",
450 (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
451 (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
452 cur = safe_concat (buf, cur, t);
453 break;
454 case CONST_FIXED:
455 fixed_to_decimal (t, CONST_FIXED_VALUE (x), sizeof (t));
456 cur = safe_concat (buf, cur, t);
457 break;
458 case CONST_STRING:
459 cur = safe_concat (buf, cur, "\"");
460 cur = safe_concat (buf, cur, XSTR (x, 0));
461 cur = safe_concat (buf, cur, "\"");
462 break;
463 case SYMBOL_REF:
464 cur = safe_concat (buf, cur, "`");
465 cur = safe_concat (buf, cur, XSTR (x, 0));
466 cur = safe_concat (buf, cur, "'");
467 break;
468 case LABEL_REF:
469 sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
470 cur = safe_concat (buf, cur, t);
471 break;
472 case CONST:
473 print_value (t, XEXP (x, 0), verbose);
474 cur = safe_concat (buf, cur, "const(");
475 cur = safe_concat (buf, cur, t);
476 cur = safe_concat (buf, cur, ")");
477 break;
478 case HIGH:
479 print_value (t, XEXP (x, 0), verbose);
480 cur = safe_concat (buf, cur, "high(");
481 cur = safe_concat (buf, cur, t);
482 cur = safe_concat (buf, cur, ")");
483 break;
484 case REG:
485 if (REGNO (x) < FIRST_PSEUDO_REGISTER)
487 int c = reg_names[REGNO (x)][0];
488 if (ISDIGIT (c))
489 cur = safe_concat (buf, cur, "%");
491 cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
493 else
495 sprintf (t, "r%d", REGNO (x));
496 cur = safe_concat (buf, cur, t);
498 if (verbose
499 #ifdef INSN_SCHEDULING
500 && !current_sched_info
501 #endif
504 sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x)));
505 cur = safe_concat (buf, cur, t);
507 break;
508 case SUBREG:
509 print_value (t, SUBREG_REG (x), verbose);
510 cur = safe_concat (buf, cur, t);
511 sprintf (t, "#%d", SUBREG_BYTE (x));
512 cur = safe_concat (buf, cur, t);
513 break;
514 case SCRATCH:
515 cur = safe_concat (buf, cur, "scratch");
516 break;
517 case CC0:
518 cur = safe_concat (buf, cur, "cc0");
519 break;
520 case PC:
521 cur = safe_concat (buf, cur, "pc");
522 break;
523 case MEM:
524 print_value (t, XEXP (x, 0), verbose);
525 cur = safe_concat (buf, cur, "[");
526 cur = safe_concat (buf, cur, t);
527 cur = safe_concat (buf, cur, "]");
528 break;
529 case DEBUG_EXPR:
530 sprintf (t, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
531 cur = safe_concat (buf, cur, t);
532 break;
533 default:
534 print_exp (t, x, verbose);
535 cur = safe_concat (buf, cur, t);
536 break;
538 } /* print_value */
540 /* The next step in insn detalization, its pattern recognition. */
542 void
543 print_pattern (char *buf, const_rtx x, int verbose)
545 char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
547 switch (GET_CODE (x))
549 case SET:
550 print_value (t1, SET_DEST (x), verbose);
551 print_value (t2, SET_SRC (x), verbose);
552 sprintf (buf, "%s=%s", t1, t2);
553 break;
554 case RETURN:
555 sprintf (buf, "return");
556 break;
557 case CALL:
558 print_exp (buf, x, verbose);
559 break;
560 case CLOBBER:
561 print_value (t1, XEXP (x, 0), verbose);
562 sprintf (buf, "clobber %s", t1);
563 break;
564 case USE:
565 print_value (t1, XEXP (x, 0), verbose);
566 sprintf (buf, "use %s", t1);
567 break;
568 case VAR_LOCATION:
569 print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose);
570 sprintf (buf, "loc %s", t1);
571 break;
572 case COND_EXEC:
573 if (GET_CODE (COND_EXEC_TEST (x)) == NE
574 && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
575 print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
576 else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
577 && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
579 t1[0] = '!';
580 print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
582 else
583 print_value (t1, COND_EXEC_TEST (x), verbose);
584 print_pattern (t2, COND_EXEC_CODE (x), verbose);
585 sprintf (buf, "(%s) %s", t1, t2);
586 break;
587 case PARALLEL:
589 int i;
591 sprintf (t1, "{");
592 for (i = 0; i < XVECLEN (x, 0); i++)
594 print_pattern (t2, XVECEXP (x, 0, i), verbose);
595 sprintf (t3, "%s%s;", t1, t2);
596 strcpy (t1, t3);
598 sprintf (buf, "%s}", t1);
600 break;
601 case SEQUENCE:
602 /* Should never see SEQUENCE codes until after reorg. */
603 gcc_unreachable ();
604 case ASM_INPUT:
605 sprintf (buf, "asm {%s}", XSTR (x, 0));
606 break;
607 case ADDR_VEC:
608 /* Fall through. */
609 case ADDR_DIFF_VEC:
610 print_value (buf, XEXP (x, 0), verbose);
611 break;
612 case TRAP_IF:
613 print_value (t1, TRAP_CONDITION (x), verbose);
614 sprintf (buf, "trap_if %s", t1);
615 break;
616 case UNSPEC:
618 int i;
620 sprintf (t1, "unspec{");
621 for (i = 0; i < XVECLEN (x, 0); i++)
623 print_pattern (t2, XVECEXP (x, 0, i), verbose);
624 sprintf (t3, "%s%s;", t1, t2);
625 strcpy (t1, t3);
627 sprintf (buf, "%s}", t1);
629 break;
630 case UNSPEC_VOLATILE:
632 int i;
634 sprintf (t1, "unspec/v{");
635 for (i = 0; i < XVECLEN (x, 0); i++)
637 print_pattern (t2, XVECEXP (x, 0, i), verbose);
638 sprintf (t3, "%s%s;", t1, t2);
639 strcpy (t1, t3);
641 sprintf (buf, "%s}", t1);
643 break;
644 default:
645 print_value (buf, x, verbose);
647 } /* print_pattern */
649 /* This is the main function in rtl visualization mechanism. It
650 accepts an rtx and tries to recognize it as an insn, then prints it
651 properly in human readable form, resembling assembler mnemonics.
652 For every insn it prints its UID and BB the insn belongs too.
653 (Probably the last "option" should be extended somehow, since it
654 depends now on sched.c inner variables ...) */
656 void
657 print_insn (char *buf, const_rtx x, int verbose)
659 char t[BUF_LEN];
660 const_rtx insn = x;
662 switch (GET_CODE (x))
664 case INSN:
665 print_pattern (t, PATTERN (x), verbose);
666 #ifdef INSN_SCHEDULING
667 if (verbose && current_sched_info)
668 sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
670 else
671 #endif
672 sprintf (buf, " %4d %s", INSN_UID (x), t);
673 break;
675 case DEBUG_INSN:
677 const char *name = "?";
679 if (DECL_P (INSN_VAR_LOCATION_DECL (insn)))
681 tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (insn));
682 char idbuf[32];
683 if (id)
684 name = IDENTIFIER_POINTER (id);
685 else if (TREE_CODE (INSN_VAR_LOCATION_DECL (insn))
686 == DEBUG_EXPR_DECL)
688 sprintf (idbuf, "D#%i",
689 DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (insn)));
690 name = idbuf;
692 else
694 sprintf (idbuf, "D.%i",
695 DECL_UID (INSN_VAR_LOCATION_DECL (insn)));
696 name = idbuf;
699 if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)))
700 sprintf (buf, " %4d: debug %s optimized away", INSN_UID (insn), name);
701 else
703 print_pattern (t, INSN_VAR_LOCATION_LOC (insn), verbose);
704 sprintf (buf, " %4d: debug %s => %s", INSN_UID (insn), name, t);
707 break;
709 case JUMP_INSN:
710 print_pattern (t, PATTERN (x), verbose);
711 #ifdef INSN_SCHEDULING
712 if (verbose && current_sched_info)
713 sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
715 else
716 #endif
717 sprintf (buf, " %4d %s", INSN_UID (x), t);
718 break;
719 case CALL_INSN:
720 x = PATTERN (insn);
721 if (GET_CODE (x) == PARALLEL)
723 x = XVECEXP (x, 0, 0);
724 print_pattern (t, x, verbose);
726 else
727 strcpy (t, "call <...>");
728 #ifdef INSN_SCHEDULING
729 if (verbose && current_sched_info)
730 sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
731 else
732 #endif
733 sprintf (buf, " %4d %s", INSN_UID (insn), t);
734 break;
735 case CODE_LABEL:
736 sprintf (buf, "L%d:", INSN_UID (x));
737 break;
738 case BARRIER:
739 sprintf (buf, "i%4d: barrier", INSN_UID (x));
740 break;
741 case NOTE:
742 sprintf (buf, " %4d %s", INSN_UID (x),
743 GET_NOTE_INSN_NAME (NOTE_KIND (x)));
744 break;
745 default:
746 sprintf (buf, "i%4d <What %s?>", INSN_UID (x),
747 GET_RTX_NAME (GET_CODE (x)));
749 } /* print_insn */
751 /* Emit a slim dump of X (an insn) to the file F, including any register
752 note attached to the instruction. */
753 void
754 dump_insn_slim (FILE *f, rtx x)
756 char t[BUF_LEN + 32];
757 rtx note;
759 print_insn (t, x, 1);
760 fputs (t, f);
761 putc ('\n', f);
762 if (INSN_P (x) && REG_NOTES (x))
763 for (note = REG_NOTES (x); note; note = XEXP (note, 1))
765 print_value (t, XEXP (note, 0), 1);
766 fprintf (f, " %s: %s\n",
767 GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t);
771 /* Emit a slim dump of X (an insn) to stderr. */
772 DEBUG_FUNCTION void
773 debug_insn_slim (rtx x)
775 dump_insn_slim (stderr, x);
778 /* Provide a slim dump the instruction chain starting at FIRST to F, honoring
779 the dump flags given in FLAGS. Currently, TDF_BLOCKS and TDF_DETAILS
780 include more information on the basic blocks. */
781 void
782 print_rtl_slim_with_bb (FILE *f, rtx first, int flags)
784 print_rtl_slim (f, first, NULL, -1, flags);
787 /* Same as above, but stop at LAST or when COUNT == 0.
788 If COUNT < 0 it will stop only at LAST or NULL rtx. */
789 void
790 print_rtl_slim (FILE *f, rtx first, rtx last, int count, int flags)
792 basic_block current_bb = NULL;
793 rtx insn, tail;
795 tail = last ? NEXT_INSN (last) : NULL_RTX;
796 for (insn = first;
797 (insn != NULL) && (insn != tail) && (count != 0);
798 insn = NEXT_INSN (insn))
800 if ((flags & TDF_BLOCKS)
801 && (INSN_P (insn) || NOTE_P (insn))
802 && BLOCK_FOR_INSN (insn)
803 && !current_bb)
805 current_bb = BLOCK_FOR_INSN (insn);
806 dump_bb_info (current_bb, true, false, flags, ";; ", f);
809 dump_insn_slim (f, insn);
811 if ((flags & TDF_BLOCKS)
812 && current_bb
813 && insn == BB_END (current_bb))
815 dump_bb_info (current_bb, false, true, flags, ";; ", f);
816 current_bb = NULL;
818 if (count > 0)
819 count--;
823 DEBUG_FUNCTION void
824 debug_bb_slim (struct basic_block_def *bb)
826 print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32);
829 DEBUG_FUNCTION void
830 debug_bb_n_slim (int n)
832 struct basic_block_def *bb = BASIC_BLOCK (n);
833 debug_bb_slim (bb);