Branch data Line data Source code
1 : : /* Instruction scheduling pass. Log dumping infrastructure.
2 : : Copyright (C) 2006-2024 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
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
9 : : version.
10 : :
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
14 : : for more details.
15 : :
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/>. */
19 : :
20 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "backend.h"
24 : : #include "rtl.h"
25 : : #include "df.h"
26 : : #include "insn-attr.h"
27 : : #include "cselib.h"
28 : :
29 : : #ifdef INSN_SCHEDULING
30 : : #include "regset.h"
31 : : #include "sched-int.h"
32 : : #include "cfgloop.h"
33 : : #include "sel-sched-ir.h"
34 : : #include "sel-sched-dump.h"
35 : : #include "print-rtl.h"
36 : :
37 : :
38 : : /* These variables control high-level pretty printing. */
39 : : static int sel_dump_cfg_flags = SEL_DUMP_CFG_FLAGS;
40 : : static int sel_debug_cfg_flags = SEL_DUMP_CFG_FLAGS;
41 : :
42 : : /* True when a cfg should be dumped. */
43 : : static bool sel_dump_cfg_p;
44 : :
45 : : /* Variables that are used to build the cfg dump file name. */
46 : : static const char * const sel_debug_cfg_root = "./";
47 : : static const char * const sel_debug_cfg_root_postfix_default = "";
48 : : static const char *sel_debug_cfg_root_postfix = "";
49 : : static int sel_dump_cfg_fileno = -1;
50 : : static int sel_debug_cfg_fileno = -1;
51 : :
52 : : /* When this flag is on, we are dumping to the .dot file.
53 : : When it is off, we are dumping to log.
54 : : This is useful to differentiate formatting between log and .dot
55 : : files. */
56 : : bool sched_dump_to_dot_p = false;
57 : :
58 : : /* Controls how insns from a fence list should be dumped. */
59 : : static int dump_flist_insn_flags = (DUMP_INSN_UID | DUMP_INSN_BBN
60 : : | DUMP_INSN_SEQNO);
61 : :
62 : :
63 : : /* The variable used to hold the value of sched_dump when temporarily
64 : : switching dump output to the other source, e.g. the .dot file. */
65 : : static FILE *saved_sched_dump = NULL;
66 : :
67 : : /* Switch sched_dump to TO. It must not be called twice. */
68 : : static void
69 : 0 : switch_dump (FILE *to)
70 : : {
71 : 0 : gcc_assert (saved_sched_dump == NULL);
72 : :
73 : 0 : saved_sched_dump = sched_dump;
74 : 0 : sched_dump = to;
75 : 0 : }
76 : :
77 : : /* Restore previously switched dump. */
78 : : static void
79 : 0 : restore_dump (void)
80 : : {
81 : 0 : sched_dump = saved_sched_dump;
82 : 0 : saved_sched_dump = NULL;
83 : 0 : }
84 : :
85 : :
86 : : /* Functions for dumping instructions, av sets, and exprs. */
87 : :
88 : : /* Default flags for dumping insns. */
89 : : static int dump_insn_rtx_flags = DUMP_INSN_RTX_UID | DUMP_INSN_RTX_PATTERN;
90 : :
91 : : /* Default flags for dumping vinsns. */
92 : : static int dump_vinsn_flags = (DUMP_VINSN_INSN_RTX | DUMP_VINSN_TYPE
93 : : | DUMP_VINSN_COUNT);
94 : :
95 : : /* Default flags for dumping expressions. */
96 : : static int dump_expr_flags = DUMP_EXPR_ALL;
97 : :
98 : : /* Default flags for dumping insns when debugging. */
99 : : static int debug_insn_rtx_flags = DUMP_INSN_RTX_ALL;
100 : :
101 : : /* Default flags for dumping vinsns when debugging. */
102 : : static int debug_vinsn_flags = DUMP_VINSN_ALL;
103 : :
104 : : /* Default flags for dumping expressions when debugging. */
105 : : static int debug_expr_flags = DUMP_EXPR_ALL;
106 : :
107 : : /* Controls how an insn from stream should be dumped when debugging. */
108 : : static int debug_insn_flags = DUMP_INSN_ALL;
109 : :
110 : : /* Print an rtx X. */
111 : : void
112 : 0 : sel_print_rtl (rtx x)
113 : : {
114 : 0 : print_rtl_single (sched_dump, x);
115 : 0 : }
116 : :
117 : : /* Dump insn INSN honoring FLAGS. */
118 : : void
119 : 0 : dump_insn_rtx_1 (rtx insn, int flags)
120 : : {
121 : 0 : int all;
122 : :
123 : : /* flags == -1 also means dumping all. */
124 : 0 : all = (flags & 1);
125 : 0 : if (all)
126 : 0 : flags |= DUMP_INSN_RTX_ALL;
127 : :
128 : 0 : sel_print ("(");
129 : :
130 : 0 : if (flags & DUMP_INSN_RTX_UID)
131 : 0 : sel_print ("%d;", INSN_UID (insn));
132 : :
133 : 0 : if (flags & DUMP_INSN_RTX_PATTERN)
134 : 0 : sel_print ("%s;", str_pattern_slim (PATTERN (insn)));
135 : :
136 : 0 : if (flags & DUMP_INSN_RTX_BBN)
137 : : {
138 : 0 : basic_block bb = BLOCK_FOR_INSN (insn);
139 : :
140 : 0 : sel_print ("bb:%d;", bb != NULL ? bb->index : -1);
141 : : }
142 : :
143 : 0 : sel_print (")");
144 : 0 : }
145 : :
146 : :
147 : : /* Dump INSN with default flags. */
148 : : void
149 : 0 : dump_insn_rtx (rtx insn)
150 : : {
151 : 0 : dump_insn_rtx_1 (insn, dump_insn_rtx_flags);
152 : 0 : }
153 : :
154 : :
155 : : /* Dump INSN to stderr. */
156 : : DEBUG_FUNCTION void
157 : 0 : debug_insn_rtx (rtx insn)
158 : : {
159 : 0 : switch_dump (stderr);
160 : 0 : dump_insn_rtx_1 (insn, debug_insn_rtx_flags);
161 : 0 : sel_print ("\n");
162 : 0 : restore_dump ();
163 : 0 : }
164 : :
165 : : /* Dump vinsn VI honoring flags. */
166 : : void
167 : 0 : dump_vinsn_1 (vinsn_t vi, int flags)
168 : : {
169 : 0 : int all;
170 : :
171 : : /* flags == -1 also means dumping all. */
172 : 0 : all = flags & 1;
173 : 0 : if (all)
174 : 0 : flags |= DUMP_VINSN_ALL;
175 : :
176 : 0 : sel_print ("(");
177 : :
178 : 0 : if (flags & DUMP_VINSN_INSN_RTX)
179 : 0 : dump_insn_rtx_1 (VINSN_INSN_RTX (vi), dump_insn_rtx_flags | all);
180 : :
181 : 0 : if (flags & DUMP_VINSN_TYPE)
182 : 0 : sel_print ("type:%s;", GET_RTX_NAME (VINSN_TYPE (vi)));
183 : :
184 : 0 : if (flags & DUMP_VINSN_COUNT)
185 : 0 : sel_print ("count:%d;", VINSN_COUNT (vi));
186 : :
187 : 0 : if (flags & DUMP_VINSN_COST)
188 : : {
189 : 0 : int cost = vi->cost;
190 : :
191 : 0 : if (cost != -1)
192 : 0 : sel_print ("cost:%d;", cost);
193 : : }
194 : :
195 : 0 : sel_print (")");
196 : 0 : }
197 : :
198 : : /* Dump vinsn VI with default flags. */
199 : : void
200 : 0 : dump_vinsn (vinsn_t vi)
201 : : {
202 : 0 : dump_vinsn_1 (vi, dump_vinsn_flags);
203 : 0 : }
204 : :
205 : : DEBUG_FUNCTION void
206 : 0 : debug (vinsn_def &ref)
207 : : {
208 : 0 : switch_dump (stderr);
209 : 0 : dump_vinsn_1 (&ref, dump_vinsn_flags);
210 : 0 : sel_print ("\n");
211 : 0 : restore_dump ();
212 : 0 : }
213 : :
214 : : DEBUG_FUNCTION void
215 : 0 : debug (vinsn_def *ptr)
216 : : {
217 : 0 : if (ptr)
218 : 0 : debug (*ptr);
219 : : else
220 : 0 : fprintf (stderr, "<nil>\n");
221 : 0 : }
222 : :
223 : : DEBUG_FUNCTION void
224 : 0 : debug_verbose (vinsn_def &ref)
225 : : {
226 : 0 : switch_dump (stderr);
227 : 0 : dump_vinsn_1 (&ref, debug_vinsn_flags);
228 : 0 : sel_print ("\n");
229 : 0 : restore_dump ();
230 : 0 : }
231 : :
232 : : DEBUG_FUNCTION void
233 : 0 : debug_verbose (vinsn_def *ptr)
234 : : {
235 : 0 : if (ptr)
236 : 0 : debug (*ptr);
237 : : else
238 : 0 : fprintf (stderr, "<nil>\n");
239 : 0 : }
240 : :
241 : : /* Dump vinsn VI to stderr. */
242 : : DEBUG_FUNCTION void
243 : 0 : debug_vinsn (vinsn_t vi)
244 : : {
245 : 0 : switch_dump (stderr);
246 : 0 : dump_vinsn_1 (vi, debug_vinsn_flags);
247 : 0 : sel_print ("\n");
248 : 0 : restore_dump ();
249 : 0 : }
250 : :
251 : : /* Dump EXPR honoring flags. */
252 : : void
253 : 0 : dump_expr_1 (expr_t expr, int flags)
254 : : {
255 : 0 : int all;
256 : :
257 : : /* flags == -1 also means dumping all. */
258 : 0 : all = flags & 1;
259 : 0 : if (all)
260 : 0 : flags |= DUMP_EXPR_ALL;
261 : :
262 : 0 : sel_print ("[");
263 : :
264 : 0 : if (flags & DUMP_EXPR_VINSN)
265 : 0 : dump_vinsn_1 (EXPR_VINSN (expr), dump_vinsn_flags | all);
266 : :
267 : 0 : if (flags & DUMP_EXPR_SPEC)
268 : : {
269 : 0 : int spec = EXPR_SPEC (expr);
270 : :
271 : 0 : if (spec != 0)
272 : 0 : sel_print ("spec:%d;", spec);
273 : : }
274 : :
275 : 0 : if (flags & DUMP_EXPR_USEFULNESS)
276 : : {
277 : 0 : int use = EXPR_USEFULNESS (expr);
278 : :
279 : 0 : if (use != REG_BR_PROB_BASE)
280 : 0 : sel_print ("use:%d;", use);
281 : : }
282 : :
283 : 0 : if (flags & DUMP_EXPR_PRIORITY)
284 : 0 : sel_print ("prio:%d;", EXPR_PRIORITY (expr));
285 : :
286 : 0 : if (flags & DUMP_EXPR_SCHED_TIMES)
287 : : {
288 : 0 : int times = EXPR_SCHED_TIMES (expr);
289 : :
290 : 0 : if (times != 0)
291 : 0 : sel_print ("times:%d;", times);
292 : : }
293 : :
294 : 0 : if (flags & DUMP_EXPR_SPEC_DONE_DS)
295 : : {
296 : 0 : ds_t spec_done_ds = EXPR_SPEC_DONE_DS (expr);
297 : :
298 : 0 : if (spec_done_ds != 0)
299 : 0 : sel_print ("ds:%d;", spec_done_ds);
300 : : }
301 : :
302 : 0 : if (flags & DUMP_EXPR_ORIG_BB)
303 : : {
304 : 0 : int orig_bb = EXPR_ORIG_BB_INDEX (expr);
305 : :
306 : 0 : if (orig_bb != 0)
307 : 0 : sel_print ("orig_bb:%d;", orig_bb);
308 : : }
309 : :
310 : 0 : if (EXPR_TARGET_AVAILABLE (expr) < 1)
311 : 0 : sel_print ("target:%d;", EXPR_TARGET_AVAILABLE (expr));
312 : 0 : sel_print ("]");
313 : 0 : }
314 : :
315 : : /* Dump expression EXPR with default flags. */
316 : : void
317 : 0 : dump_expr (expr_t expr)
318 : : {
319 : 0 : dump_expr_1 (expr, dump_expr_flags);
320 : 0 : }
321 : :
322 : : /* Dump expression EXPR to stderr. */
323 : : DEBUG_FUNCTION void
324 : 0 : debug_expr (expr_t expr)
325 : : {
326 : 0 : switch_dump (stderr);
327 : 0 : dump_expr_1 (expr, debug_expr_flags);
328 : 0 : sel_print ("\n");
329 : 0 : restore_dump ();
330 : 0 : }
331 : :
332 : : /* Dump expression REF. */
333 : :
334 : : DEBUG_FUNCTION void
335 : 0 : debug (expr_def &ref)
336 : : {
337 : 0 : switch_dump (stderr);
338 : 0 : dump_expr_1 (&ref, 0);
339 : 0 : sel_print ("\n");
340 : 0 : restore_dump ();
341 : 0 : }
342 : :
343 : : DEBUG_FUNCTION void
344 : 0 : debug (expr_def *ptr)
345 : : {
346 : 0 : if (ptr)
347 : 0 : debug (*ptr);
348 : : else
349 : 0 : fprintf (stderr, "<nil>\n");
350 : 0 : }
351 : :
352 : : /* Dump expression REF verbosely. */
353 : :
354 : : DEBUG_FUNCTION void
355 : 0 : debug_verbose (expr_def &ref)
356 : : {
357 : 0 : switch_dump (stderr);
358 : 0 : dump_expr_1 (&ref, DUMP_EXPR_ALL);
359 : 0 : sel_print ("\n");
360 : 0 : restore_dump ();
361 : 0 : }
362 : :
363 : : DEBUG_FUNCTION void
364 : 0 : debug_verbose (expr_def *ptr)
365 : : {
366 : 0 : if (ptr)
367 : 0 : debug_verbose (*ptr);
368 : : else
369 : 0 : fprintf (stderr, "<nil>\n");
370 : 0 : }
371 : :
372 : : /* Dump insn I honoring FLAGS. */
373 : : void
374 : 0 : dump_insn_1 (insn_t i, int flags)
375 : : {
376 : 0 : int all;
377 : :
378 : 0 : all = flags & 1;
379 : 0 : if (all)
380 : 0 : flags |= DUMP_INSN_ALL;
381 : :
382 : 0 : if (!sched_dump_to_dot_p)
383 : 0 : sel_print ("(");
384 : :
385 : 0 : if (flags & DUMP_INSN_EXPR)
386 : : {
387 : 0 : dump_expr_1 (INSN_EXPR (i), dump_expr_flags | all);
388 : 0 : sel_print (";");
389 : : }
390 : 0 : else if (flags & DUMP_INSN_PATTERN)
391 : : {
392 : 0 : dump_insn_rtx_1 (i, DUMP_INSN_RTX_PATTERN | all);
393 : 0 : sel_print (";");
394 : : }
395 : 0 : else if (flags & DUMP_INSN_UID)
396 : 0 : sel_print ("uid:%d;", INSN_UID (i));
397 : :
398 : 0 : if (flags & DUMP_INSN_SEQNO)
399 : 0 : sel_print ("seqno:%d;", INSN_SEQNO (i));
400 : :
401 : 0 : if (flags & DUMP_INSN_SCHED_CYCLE)
402 : : {
403 : 0 : int cycle = INSN_SCHED_CYCLE (i);
404 : :
405 : 0 : if (cycle != 0)
406 : 0 : sel_print ("cycle:%d;", cycle);
407 : : }
408 : :
409 : 0 : if (!sched_dump_to_dot_p)
410 : 0 : sel_print (")");
411 : 0 : }
412 : :
413 : : /* Dump insn I with default flags. */
414 : : void
415 : 0 : dump_insn (insn_t i)
416 : : {
417 : 0 : dump_insn_1 (i, DUMP_INSN_EXPR | DUMP_INSN_SCHED_CYCLE);
418 : 0 : }
419 : :
420 : : /* Dump INSN to stderr. */
421 : : DEBUG_FUNCTION void
422 : 0 : debug_insn (insn_t insn)
423 : : {
424 : 0 : switch_dump (stderr);
425 : 0 : dump_insn_1 (insn, debug_insn_flags);
426 : 0 : sel_print ("\n");
427 : 0 : restore_dump ();
428 : 0 : }
429 : :
430 : : /* Dumps av_set AV. */
431 : : void
432 : 0 : dump_av_set (av_set_t av)
433 : : {
434 : 0 : av_set_iterator i;
435 : 0 : expr_t expr;
436 : :
437 : 0 : if (!sched_dump_to_dot_p)
438 : 0 : sel_print ("{");
439 : :
440 : 0 : FOR_EACH_EXPR (expr, i, av)
441 : : {
442 : 0 : dump_expr (expr);
443 : 0 : if (!sched_dump_to_dot_p)
444 : 0 : sel_print (" ");
445 : : else
446 : 0 : sel_print ("\n");
447 : : }
448 : :
449 : 0 : if (!sched_dump_to_dot_p)
450 : 0 : sel_print ("}");
451 : 0 : }
452 : :
453 : : /* Dumps lvset LV. */
454 : : void
455 : 0 : dump_lv_set (regset lv)
456 : : {
457 : 0 : sel_print ("{");
458 : :
459 : : /* This code was adapted from cfg.cc: dump_regset (). */
460 : 0 : if (lv == NULL)
461 : 0 : sel_print ("nil");
462 : : else
463 : : {
464 : 0 : unsigned i;
465 : 0 : reg_set_iterator rsi;
466 : 0 : int count = 0;
467 : :
468 : 0 : EXECUTE_IF_SET_IN_REG_SET (lv, 0, i, rsi)
469 : : {
470 : 0 : sel_print (" %d", i);
471 : 0 : if (i < FIRST_PSEUDO_REGISTER)
472 : : {
473 : 0 : sel_print (" [%s]", reg_names[i]);
474 : 0 : ++count;
475 : : }
476 : :
477 : 0 : ++count;
478 : :
479 : 0 : if (sched_dump_to_dot_p && count == 12)
480 : : {
481 : 0 : count = 0;
482 : 0 : sel_print ("\n");
483 : : }
484 : : }
485 : : }
486 : :
487 : 0 : sel_print ("}\n");
488 : 0 : }
489 : :
490 : : /* Dumps a list of instructions pointed to by P. */
491 : : static void
492 : 0 : dump_ilist (ilist_t p)
493 : : {
494 : 0 : while (p)
495 : : {
496 : 0 : dump_insn (ILIST_INSN (p));
497 : 0 : p = ILIST_NEXT (p);
498 : : }
499 : 0 : }
500 : :
501 : : /* Dumps a list of boundaries pointed to by BNDS. */
502 : : void
503 : 0 : dump_blist (blist_t bnds)
504 : : {
505 : 0 : for (; bnds; bnds = BLIST_NEXT (bnds))
506 : : {
507 : 0 : bnd_t bnd = BLIST_BND (bnds);
508 : :
509 : 0 : sel_print ("[to: %d; ptr: ", INSN_UID (BND_TO (bnd)));
510 : 0 : dump_ilist (BND_PTR (bnd));
511 : 0 : sel_print ("] ");
512 : : }
513 : 0 : }
514 : :
515 : : /* Dumps a list of fences pointed to by L. */
516 : : void
517 : 0 : dump_flist (flist_t l)
518 : : {
519 : 0 : while (l)
520 : : {
521 : 0 : dump_insn_1 (FENCE_INSN (FLIST_FENCE (l)), dump_flist_insn_flags);
522 : 0 : sel_print (" ");
523 : 0 : l = FLIST_NEXT (l);
524 : : }
525 : 0 : }
526 : :
527 : : /* Dumps an insn vector SUCCS. */
528 : : void
529 : 0 : dump_insn_vector (rtx_vec_t succs)
530 : : {
531 : 0 : for (rtx_insn *succ : succs)
532 : 0 : if (succ)
533 : 0 : dump_insn (succ);
534 : : else
535 : 0 : sel_print ("NULL ");
536 : 0 : }
537 : :
538 : : /* Dumps a hard reg set SET to FILE using PREFIX. */
539 : : static void
540 : 0 : print_hard_reg_set (FILE *file, const char *prefix, HARD_REG_SET set)
541 : : {
542 : 0 : int i;
543 : :
544 : 0 : fprintf (file, "%s{ ", prefix);
545 : 0 : for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
546 : : {
547 : 0 : if (TEST_HARD_REG_BIT (set, i))
548 : 0 : fprintf (file, "%d ", i);
549 : : }
550 : 0 : fprintf (file, "}\n");
551 : 0 : }
552 : :
553 : : /* Dumps a hard reg set SET using PREFIX. */
554 : : void
555 : 0 : dump_hard_reg_set (const char *prefix, HARD_REG_SET set)
556 : : {
557 : 0 : print_hard_reg_set (sched_dump, prefix, set);
558 : 0 : }
559 : :
560 : : /* Pretty print INSN. This is used as a hook. */
561 : : const char *
562 : 0 : sel_print_insn (const rtx_insn *insn, int aligned ATTRIBUTE_UNUSED)
563 : : {
564 : 0 : static char buf[80];
565 : :
566 : : /* '+' before insn means it is a new cycle start and it's not been
567 : : scheduled yet. '>' - has been scheduled. */
568 : 0 : if (s_i_d.exists () && INSN_LUID (insn) > 0)
569 : 0 : if (GET_MODE (insn) == TImode)
570 : 0 : sprintf (buf, "%s %4d",
571 : 0 : INSN_SCHED_TIMES (insn) > 0 ? "> " : "< ",
572 : : INSN_UID (insn));
573 : : else
574 : 0 : sprintf (buf, "%s %4d",
575 : 0 : INSN_SCHED_TIMES (insn) > 0 ? "! " : " ",
576 : : INSN_UID (insn));
577 : : else
578 : 0 : if (GET_MODE (insn) == TImode)
579 : 0 : sprintf (buf, "+ %4d", INSN_UID (insn));
580 : : else
581 : 0 : sprintf (buf, " %4d", INSN_UID (insn));
582 : :
583 : 0 : return buf;
584 : : }
585 : :
586 : :
587 : : /* Functions for pretty printing of CFG. */
588 : : /* FIXME: Using pretty-print here could simplify this stuff. */
589 : :
590 : : /* Replace all occurencies of STR1 to STR2 in BUF.
591 : : The BUF must be large enough to hold the result. */
592 : : static void
593 : 0 : replace_str_in_buf (char *buf, const char *str1, const char *str2)
594 : : {
595 : 0 : int buf_len = strlen (buf);
596 : 0 : int str1_len = strlen (str1);
597 : 0 : int str2_len = strlen (str2);
598 : 0 : int diff = str2_len - str1_len;
599 : :
600 : 0 : char *p = buf;
601 : 0 : do
602 : : {
603 : 0 : p = strstr (p, str1);
604 : 0 : if (p)
605 : : {
606 : 0 : char *p1 = p + str1_len;
607 : : /* Copy the rest of buf and '\0'. */
608 : 0 : int n = buf + buf_len - p1;
609 : 0 : int i;
610 : :
611 : : /* Shift str by DIFF chars. */
612 : 0 : if (diff > 0)
613 : 0 : for (i = n; i >= 0; i--)
614 : 0 : p1[i + diff] = p1[i];
615 : : else
616 : 0 : for (i = 0; i <= n; i++)
617 : 0 : p1[i + diff] = p1[i];
618 : :
619 : : /* Copy str2. */
620 : 0 : for (i = 0; i < str2_len; i++)
621 : 0 : p[i] = str2[i];
622 : :
623 : 0 : p += str2_len;
624 : 0 : buf_len += diff;
625 : : }
626 : :
627 : : }
628 : 0 : while (p);
629 : 0 : }
630 : :
631 : : /* Replace characters in BUF that have special meaning in .dot file.
632 : : Similar to pp_write_text_as_dot_label_to_stream. */
633 : : static void
634 : 0 : sel_prepare_string_for_dot_label (char *buf)
635 : : {
636 : 0 : static char specials_from[7][2] = { "<", ">", "{", "|", "}", "\"",
637 : : "\n" };
638 : 0 : static char specials_to[7][3] = { "\\<", "\\>", "\\{", "\\|", "\\}",
639 : : "\\\"", "\\l" };
640 : 0 : unsigned i;
641 : :
642 : 0 : for (i = 0; i < 7; i++)
643 : 0 : replace_str_in_buf (buf, specials_from[i], specials_to[i]);
644 : 0 : }
645 : :
646 : : /* This function acts like printf but dumps to the sched_dump file. */
647 : : void
648 : 0 : sel_print (const char *fmt, ...)
649 : : {
650 : 0 : va_list ap;
651 : 0 : va_start (ap, fmt);
652 : 0 : if (sched_dump_to_dot_p)
653 : : {
654 : 0 : char *message;
655 : 0 : if (vasprintf (&message, fmt, ap) >= 0 && message != NULL)
656 : : {
657 : 0 : message = (char *) xrealloc (message, 2 * strlen (message) + 1);
658 : 0 : sel_prepare_string_for_dot_label (message);
659 : 0 : fprintf (sched_dump, "%s", message);
660 : 0 : free (message);
661 : : }
662 : : }
663 : : else
664 : 0 : vfprintf (sched_dump, fmt, ap);
665 : 0 : va_end (ap);
666 : 0 : }
667 : :
668 : : /* Dump INSN with FLAGS. */
669 : : static void
670 : 0 : sel_dump_cfg_insn (insn_t insn, int flags)
671 : : {
672 : 0 : int insn_flags = DUMP_INSN_UID | DUMP_INSN_PATTERN;
673 : :
674 : 0 : if (sched_luids.exists () && INSN_LUID (insn) > 0)
675 : : {
676 : 0 : if (flags & SEL_DUMP_CFG_INSN_SEQNO)
677 : 0 : insn_flags |= DUMP_INSN_SEQNO | DUMP_INSN_SCHED_CYCLE | DUMP_INSN_EXPR;
678 : : }
679 : :
680 : 0 : dump_insn_1 (insn, insn_flags);
681 : 0 : }
682 : :
683 : : /* Dump E to the dot file F. */
684 : : static void
685 : 0 : sel_dump_cfg_edge (FILE *f, edge e)
686 : : {
687 : 0 : int w;
688 : 0 : const char *color;
689 : :
690 : 0 : if (e->flags & EDGE_FALLTHRU)
691 : : {
692 : : w = 10;
693 : : color = ", color = red";
694 : : }
695 : 0 : else if (e->src->next_bb == e->dest)
696 : : {
697 : : w = 3;
698 : : color = ", color = blue";
699 : : }
700 : : else
701 : : {
702 : 0 : w = 1;
703 : 0 : color = "";
704 : : }
705 : :
706 : 0 : fprintf (f, "\tbb%d -> bb%d [weight = %d%s];\n",
707 : 0 : e->src->index, e->dest->index, w, color);
708 : 0 : }
709 : :
710 : :
711 : : /* Return true if BB has a predesessor from current region.
712 : : TODO: Either make this function to trace back through empty block
713 : : or just remove those empty blocks. */
714 : : static bool
715 : 0 : has_preds_in_current_region_p (basic_block bb)
716 : : {
717 : 0 : edge e;
718 : 0 : edge_iterator ei;
719 : :
720 : 0 : gcc_assert (!in_current_region_p (bb));
721 : :
722 : 0 : FOR_EACH_EDGE (e, ei, bb->preds)
723 : 0 : if (in_current_region_p (e->src))
724 : : return true;
725 : :
726 : : return false;
727 : : }
728 : :
729 : : /* Dump a cfg region to the dot file F honoring FLAGS. */
730 : : static void
731 : 0 : sel_dump_cfg_2 (FILE *f, int flags)
732 : : {
733 : 0 : basic_block bb;
734 : :
735 : 0 : sched_dump_to_dot_p = true;
736 : 0 : switch_dump (f);
737 : :
738 : 0 : fprintf (f, "digraph G {\n"
739 : : "\tratio = 2.25;\n"
740 : : "\tnode [shape = record, fontsize = 9];\n");
741 : :
742 : 0 : if (flags & SEL_DUMP_CFG_FUNCTION_NAME)
743 : 0 : fprintf (f, "function [label = \"%s\"];\n", current_function_name ());
744 : :
745 : 0 : FOR_EACH_BB_FN (bb, cfun)
746 : : {
747 : 0 : insn_t insn = BB_HEAD (bb);
748 : 0 : insn_t next_tail = NEXT_INSN (BB_END (bb));
749 : 0 : edge e;
750 : 0 : edge_iterator ei;
751 : 0 : bool in_region_p = ((flags & SEL_DUMP_CFG_CURRENT_REGION)
752 : 0 : && in_current_region_p (bb));
753 : 0 : bool full_p = (!(flags & SEL_DUMP_CFG_CURRENT_REGION)
754 : 0 : || in_region_p);
755 : 0 : bool some_p = full_p || has_preds_in_current_region_p (bb);
756 : 0 : const char *color;
757 : 0 : const char *style;
758 : :
759 : 0 : if (!some_p)
760 : 0 : continue;
761 : :
762 : 0 : if ((flags & SEL_DUMP_CFG_CURRENT_REGION)
763 : 0 : && in_current_region_p (bb)
764 : 0 : && BLOCK_TO_BB (bb->index) == 0)
765 : : color = "color = green, ";
766 : : else
767 : : color = "";
768 : :
769 : 0 : if ((flags & SEL_DUMP_CFG_FENCES)
770 : 0 : && in_region_p)
771 : : {
772 : 0 : style = "";
773 : :
774 : 0 : if (!sel_bb_empty_p (bb))
775 : : {
776 : 0 : bool first_p = true;
777 : 0 : insn_t tail = BB_END (bb);
778 : 0 : insn_t cur_insn;
779 : :
780 : 0 : cur_insn = bb_note (bb);
781 : :
782 : 0 : do
783 : : {
784 : 0 : fence_t fence;
785 : :
786 : 0 : cur_insn = NEXT_INSN (cur_insn);
787 : 0 : fence = flist_lookup (fences, cur_insn);
788 : :
789 : 0 : if (fence != NULL)
790 : : {
791 : 0 : if (!FENCE_SCHEDULED_P (fence))
792 : : {
793 : 0 : if (first_p)
794 : : color = "color = red, ";
795 : : else
796 : 0 : color = "color = yellow, ";
797 : : }
798 : : else
799 : : color = "color = blue, ";
800 : : }
801 : :
802 : 0 : first_p = false;
803 : : }
804 : 0 : while (cur_insn != tail);
805 : : }
806 : : }
807 : 0 : else if (!full_p)
808 : : style = "style = dashed, ";
809 : : else
810 : 0 : style = "";
811 : :
812 : 0 : fprintf (f, "\tbb%d [%s%slabel = \"{Basic block %d", bb->index,
813 : : style, color, bb->index);
814 : :
815 : 0 : if ((flags & SEL_DUMP_CFG_BB_LOOP)
816 : 0 : && bb->loop_father != NULL)
817 : 0 : fprintf (f, ", loop %d", bb->loop_father->num);
818 : :
819 : 0 : if (full_p
820 : 0 : && (flags & SEL_DUMP_CFG_BB_NOTES_LIST))
821 : : {
822 : 0 : insn_t notes = BB_NOTE_LIST (bb);
823 : :
824 : 0 : if (notes != NULL_RTX)
825 : : {
826 : 0 : fprintf (f, "|");
827 : :
828 : : /* For simplicity, we dump notes from note_list in reversed order
829 : : to that what they will appear in the code. */
830 : 0 : while (notes != NULL_RTX)
831 : : {
832 : 0 : sel_dump_cfg_insn (notes, flags);
833 : 0 : fprintf (f, "\\l");
834 : :
835 : 0 : notes = PREV_INSN (notes);
836 : : }
837 : : }
838 : : }
839 : :
840 : 0 : if (full_p
841 : 0 : && (flags & SEL_DUMP_CFG_AV_SET)
842 : 0 : && in_current_region_p (bb)
843 : 0 : && !sel_bb_empty_p (bb))
844 : : {
845 : 0 : fprintf (f, "|");
846 : :
847 : 0 : if (BB_AV_SET_VALID_P (bb))
848 : 0 : dump_av_set (BB_AV_SET (bb));
849 : 0 : else if (BB_AV_LEVEL (bb) == -1)
850 : 0 : fprintf (f, "AV_SET needs update");
851 : : }
852 : :
853 : 0 : if ((flags & SEL_DUMP_CFG_LV_SET)
854 : 0 : && !sel_bb_empty_p (bb))
855 : : {
856 : 0 : fprintf (f, "|");
857 : :
858 : 0 : if (BB_LV_SET_VALID_P (bb))
859 : 0 : dump_lv_set (BB_LV_SET (bb));
860 : : else
861 : 0 : fprintf (f, "LV_SET needs update");
862 : : }
863 : :
864 : 0 : if (full_p
865 : 0 : && (flags & SEL_DUMP_CFG_BB_INSNS))
866 : : {
867 : 0 : fprintf (f, "|");
868 : 0 : while (insn != next_tail)
869 : : {
870 : 0 : sel_dump_cfg_insn (insn, flags);
871 : 0 : fprintf (f, "\\l");
872 : :
873 : 0 : insn = NEXT_INSN (insn);
874 : : }
875 : : }
876 : :
877 : 0 : fprintf (f, "}\"];\n");
878 : :
879 : 0 : FOR_EACH_EDGE (e, ei, bb->succs)
880 : 0 : if (full_p || in_current_region_p (e->dest))
881 : 0 : sel_dump_cfg_edge (f, e);
882 : : }
883 : :
884 : 0 : fprintf (f, "}");
885 : :
886 : 0 : restore_dump ();
887 : 0 : sched_dump_to_dot_p = false;
888 : 0 : }
889 : :
890 : : /* Dump a cfg region to the file specified by TAG honoring flags.
891 : : The file is created by the function. */
892 : : static void
893 : 0 : sel_dump_cfg_1 (const char *tag, int flags)
894 : : {
895 : 0 : char *buf;
896 : 0 : int i;
897 : 0 : FILE *f;
898 : :
899 : 0 : ++sel_dump_cfg_fileno;
900 : :
901 : 0 : if (!sel_dump_cfg_p)
902 : : return;
903 : :
904 : 0 : i = 1 + snprintf (NULL, 0, "%s/%s%05d-%s.dot", sel_debug_cfg_root,
905 : : sel_debug_cfg_root_postfix, sel_dump_cfg_fileno, tag);
906 : 0 : buf = XNEWVEC (char, i);
907 : 0 : snprintf (buf, i, "%s/%s%05d-%s.dot", sel_debug_cfg_root,
908 : : sel_debug_cfg_root_postfix, sel_dump_cfg_fileno, tag);
909 : :
910 : 0 : f = fopen (buf, "w");
911 : :
912 : 0 : if (f == NULL)
913 : 0 : fprintf (stderr, "Can't create file: %s.\n", buf);
914 : : else
915 : : {
916 : 0 : sel_dump_cfg_2 (f, flags);
917 : :
918 : 0 : fclose (f);
919 : : }
920 : :
921 : 0 : free (buf);
922 : : }
923 : :
924 : : /* Setup cfg dumping flags. Used for debugging. */
925 : : void
926 : 0 : setup_dump_cfg_params (void)
927 : : {
928 : 0 : sel_dump_cfg_flags = SEL_DUMP_CFG_FLAGS;
929 : 0 : sel_dump_cfg_p = 0;
930 : 0 : sel_debug_cfg_root_postfix = sel_debug_cfg_root_postfix_default;
931 : 0 : }
932 : :
933 : : /* Debug a cfg region with FLAGS. */
934 : : void
935 : 0 : sel_debug_cfg_1 (int flags)
936 : : {
937 : 0 : bool t1 = sel_dump_cfg_p;
938 : 0 : int t2 = sel_dump_cfg_fileno;
939 : :
940 : 0 : sel_dump_cfg_p = true;
941 : 0 : sel_dump_cfg_fileno = ++sel_debug_cfg_fileno;
942 : :
943 : 0 : sel_dump_cfg_1 ("sel-debug-cfg", flags);
944 : :
945 : 0 : sel_dump_cfg_fileno = t2;
946 : 0 : sel_dump_cfg_p = t1;
947 : 0 : }
948 : :
949 : : /* Dumps av_set AV to stderr. */
950 : : DEBUG_FUNCTION void
951 : 0 : debug_av_set (av_set_t av)
952 : : {
953 : 0 : switch_dump (stderr);
954 : 0 : dump_av_set (av);
955 : 0 : sel_print ("\n");
956 : 0 : restore_dump ();
957 : 0 : }
958 : :
959 : : /* Dump LV to stderr. */
960 : : DEBUG_FUNCTION void
961 : 0 : debug_lv_set (regset lv)
962 : : {
963 : 0 : switch_dump (stderr);
964 : 0 : dump_lv_set (lv);
965 : 0 : sel_print ("\n");
966 : 0 : restore_dump ();
967 : 0 : }
968 : :
969 : : /* Dump an instruction list P to stderr. */
970 : : DEBUG_FUNCTION void
971 : 0 : debug_ilist (ilist_t p)
972 : : {
973 : 0 : switch_dump (stderr);
974 : 0 : dump_ilist (p);
975 : 0 : sel_print ("\n");
976 : 0 : restore_dump ();
977 : 0 : }
978 : :
979 : : /* Dump a boundary list BNDS to stderr. */
980 : : DEBUG_FUNCTION void
981 : 0 : debug_blist (blist_t bnds)
982 : : {
983 : 0 : switch_dump (stderr);
984 : 0 : dump_blist (bnds);
985 : 0 : sel_print ("\n");
986 : 0 : restore_dump ();
987 : 0 : }
988 : :
989 : : /* Debug a cfg region with default flags. */
990 : : void
991 : 0 : sel_debug_cfg (void)
992 : : {
993 : 0 : sel_debug_cfg_1 (sel_debug_cfg_flags);
994 : 0 : }
995 : :
996 : : /* Print a current cselib value for X's address to stderr. */
997 : : DEBUG_FUNCTION rtx
998 : 0 : debug_mem_addr_value (rtx x)
999 : : {
1000 : 0 : rtx t, addr;
1001 : 0 : machine_mode address_mode;
1002 : :
1003 : 0 : gcc_assert (MEM_P (x));
1004 : 0 : address_mode = get_address_mode (x);
1005 : :
1006 : 0 : t = shallow_copy_rtx (x);
1007 : 0 : if (cselib_lookup (XEXP (t, 0), address_mode, 0, GET_MODE (t)))
1008 : 0 : XEXP (t, 0) = cselib_subst_to_values (XEXP (t, 0), GET_MODE (t));
1009 : :
1010 : 0 : t = canon_rtx (t);
1011 : 0 : addr = get_addr (XEXP (t, 0));
1012 : 0 : debug_rtx (t);
1013 : 0 : debug_rtx (addr);
1014 : 0 : return t;
1015 : : }
1016 : : #endif
1017 : :
|
