Mercurial > hg > CbC > CbC_gcc

comparison gcc/sel-sched-dump.c @ 55:77e2b8dfacca gcc-4.4.5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update it from 4.4.3 to 4.5.0
author ryoma <e075725@ie.u-ryukyu.ac.jp>
date Fri, 12 Feb 2010 23:39:51 +0900
parents a06113de4d67
children b7f97abdc517
comparison
equal deleted inserted replaced
52:c156f1bd5cd9 55:77e2b8dfacca
32 #include "insn-attr.h" 32 #include "insn-attr.h"
33 #include "params.h" 33 #include "params.h"
34 #include "output.h" 34 #include "output.h"
35 #include "basic-block.h" 35 #include "basic-block.h"
36 #include "cselib.h" 36 #include "cselib.h"
37 #include "target.h"
37 38
38 #ifdef INSN_SCHEDULING 39 #ifdef INSN_SCHEDULING
39 #include "sel-sched-ir.h" 40 #include "sel-sched-ir.h"
40 #include "sel-sched-dump.h" 41 #include "sel-sched-dump.h"
41 42
72 /* Switch sched_dump to TO. It must not be called twice. */ 73 /* Switch sched_dump to TO. It must not be called twice. */
73 static void 74 static void
74 switch_dump (FILE *to) 75 switch_dump (FILE *to)
75 { 76 {
76 gcc_assert (saved_sched_dump == NULL); 77 gcc_assert (saved_sched_dump == NULL);
77 78
78 saved_sched_dump = sched_dump; 79 saved_sched_dump = sched_dump;
79 sched_dump = to; 80 sched_dump = to;
80 } 81 }
81 82
82 /* Restore previously switched dump. */ 83 /* Restore previously switched dump. */
86 sched_dump = saved_sched_dump; 87 sched_dump = saved_sched_dump;
87 saved_sched_dump = NULL; 88 saved_sched_dump = NULL;
88 } 89 }
89 90
90 91
91 /* Functions for dumping instructions, av sets, and exprs. */ 92 /* Functions for dumping instructions, av sets, and exprs. */
92 93
93 /* Default flags for dumping insns. */ 94 /* Default flags for dumping insns. */
94 static int dump_insn_rtx_flags = DUMP_INSN_RTX_PATTERN; 95 static int dump_insn_rtx_flags = DUMP_INSN_RTX_PATTERN;
95 96
96 /* Default flags for dumping vinsns. */ 97 /* Default flags for dumping vinsns. */
216 void 217 void
217 debug_vinsn (vinsn_t vi) 218 debug_vinsn (vinsn_t vi)
218 { 219 {
219 switch_dump (stderr); 220 switch_dump (stderr);
220 dump_vinsn_1 (vi, debug_vinsn_flags); 221 dump_vinsn_1 (vi, debug_vinsn_flags);
221 sel_print ("\n"); 222 sel_print ("\n");
222 restore_dump (); 223 restore_dump ();
223 } 224 }
224 225
225 /* Dump EXPR honoring flags. */ 226 /* Dump EXPR honoring flags. */
226 void 227 void
278 int orig_bb = EXPR_ORIG_BB_INDEX (expr); 279 int orig_bb = EXPR_ORIG_BB_INDEX (expr);
279 280
280 if (orig_bb != 0) 281 if (orig_bb != 0)
281 sel_print ("orig_bb:%d;", orig_bb); 282 sel_print ("orig_bb:%d;", orig_bb);
282 } 283 }
283 284
284 if (EXPR_TARGET_AVAILABLE (expr) < 1) 285 if (EXPR_TARGET_AVAILABLE (expr) < 1)
285 sel_print ("target:%d;", EXPR_TARGET_AVAILABLE (expr)); 286 sel_print ("target:%d;", EXPR_TARGET_AVAILABLE (expr));
286 sel_print ("]"); 287 sel_print ("]");
287 } 288 }
288 289
365 void 366 void
366 dump_av_set (av_set_t av) 367 dump_av_set (av_set_t av)
367 { 368 {
368 av_set_iterator i; 369 av_set_iterator i;
369 expr_t expr; 370 expr_t expr;
370 371
371 if (!sched_dump_to_dot_p) 372 if (!sched_dump_to_dot_p)
372 sel_print ("{"); 373 sel_print ("{");
373 374
374 FOR_EACH_EXPR (expr, i, av) 375 FOR_EACH_EXPR (expr, i, av)
375 { 376 {
376 dump_expr (expr); 377 dump_expr (expr);
377 if (!sched_dump_to_dot_p) 378 if (!sched_dump_to_dot_p)
378 sel_print (" "); 379 sel_print (" ");
379 else 380 else
380 sel_print ("\n"); 381 sel_print ("\n");
381 } 382 }
382 383
383 if (!sched_dump_to_dot_p) 384 if (!sched_dump_to_dot_p)
384 sel_print ("}"); 385 sel_print ("}");
385 } 386 }
386 387
387 /* Dumps lvset LV. */ 388 /* Dumps lvset LV. */
396 else 397 else
397 { 398 {
398 unsigned i; 399 unsigned i;
399 reg_set_iterator rsi; 400 reg_set_iterator rsi;
400 int count = 0; 401 int count = 0;
401 402
402 EXECUTE_IF_SET_IN_REG_SET (lv, 0, i, rsi) 403 EXECUTE_IF_SET_IN_REG_SET (lv, 0, i, rsi)
403 { 404 {
404 sel_print (" %d", i); 405 sel_print (" %d", i);
405 if (i < FIRST_PSEUDO_REGISTER) 406 if (i < FIRST_PSEUDO_REGISTER)
406 { 407 {
407 sel_print (" [%s]", reg_names[i]); 408 sel_print (" [%s]", reg_names[i]);
408 ++count; 409 ++count;
409 } 410 }
410 411
411 ++count; 412 ++count;
412 413
413 if (sched_dump_to_dot_p && count == 12) 414 if (sched_dump_to_dot_p && count == 12)
414 { 415 {
415 count = 0; 416 count = 0;
416 sel_print ("\n"); 417 sel_print ("\n");
417 } 418 }
418 } 419 }
419 } 420 }
420 421
421 sel_print ("}\n"); 422 sel_print ("}\n");
422 } 423 }
423 424
424 /* Dumps a list of instructions pointed to by P. */ 425 /* Dumps a list of instructions pointed to by P. */
425 static void 426 static void
437 dump_blist (blist_t bnds) 438 dump_blist (blist_t bnds)
438 { 439 {
439 for (; bnds; bnds = BLIST_NEXT (bnds)) 440 for (; bnds; bnds = BLIST_NEXT (bnds))
440 { 441 {
441 bnd_t bnd = BLIST_BND (bnds); 442 bnd_t bnd = BLIST_BND (bnds);
442 443
443 sel_print ("[to: %d; ptr: ", INSN_UID (BND_TO (bnd))); 444 sel_print ("[to: %d; ptr: ", INSN_UID (BND_TO (bnd)));
444 dump_ilist (BND_PTR (bnd)); 445 dump_ilist (BND_PTR (bnd));
445 sel_print ("] "); 446 sel_print ("] ");
446 } 447 }
447 } 448 }
462 void 463 void
463 dump_insn_vector (rtx_vec_t succs) 464 dump_insn_vector (rtx_vec_t succs)
464 { 465 {
465 int i; 466 int i;
466 rtx succ; 467 rtx succ;
467 468
468 for (i = 0; VEC_iterate (rtx, succs, i, succ); i++) 469 for (i = 0; VEC_iterate (rtx, succs, i, succ); i++)
469 if (succ) 470 if (succ)
470 dump_insn (succ); 471 dump_insn (succ);
471 else 472 else
472 sel_print ("NULL "); 473 sel_print ("NULL ");
498 const char * 499 const char *
499 sel_print_insn (const_rtx insn, int aligned ATTRIBUTE_UNUSED) 500 sel_print_insn (const_rtx insn, int aligned ATTRIBUTE_UNUSED)
500 { 501 {
501 static char buf[80]; 502 static char buf[80];
502 503
503 /* '+' before insn means it is a new cycle start and it's not been 504 /* '+' before insn means it is a new cycle start and it's not been
504 scheduled yet. '>' - has been scheduled. */ 505 scheduled yet. '>' - has been scheduled. */
505 if (s_i_d && INSN_LUID (insn) > 0) 506 if (s_i_d && INSN_LUID (insn) > 0)
506 if (GET_MODE (insn) == TImode) 507 if (GET_MODE (insn) == TImode)
507 sprintf (buf, "%s %4d", 508 sprintf (buf, "%s %4d",
508 INSN_SCHED_TIMES (insn) > 0 ? "> " : "< ", 509 INSN_SCHED_TIMES (insn) > 0 ? "> " : "< ",
509 INSN_UID (insn)); 510 INSN_UID (insn));
510 else 511 else
511 sprintf (buf, "%s %4d", 512 sprintf (buf, "%s %4d",
512 INSN_SCHED_TIMES (insn) > 0 ? "! " : " ", 513 INSN_SCHED_TIMES (insn) > 0 ? "! " : " ",
513 INSN_UID (insn)); 514 INSN_UID (insn));
514 else 515 else
515 if (GET_MODE (insn) == TImode) 516 if (GET_MODE (insn) == TImode)
516 sprintf (buf, "+ %4d", INSN_UID (insn)); 517 sprintf (buf, "+ %4d", INSN_UID (insn));
517 else 518 else
535 536
536 char *p = buf; 537 char *p = buf;
537 do 538 do
538 { 539 {
539 p = strstr (p, str1); 540 p = strstr (p, str1);
540 if (p) 541 if (p)
541 { 542 {
542 char *p1 = p + str1_len; 543 char *p1 = p + str1_len;
543 /* Copy the rest of buf and '\0'. */ 544 /* Copy the rest of buf and '\0'. */
544 int n = buf + buf_len - p1; 545 int n = buf + buf_len - p1;
545 int i; 546 int i;
553 p1[i + diff] = p1[i]; 554 p1[i + diff] = p1[i];
554 555
555 /* Copy str2. */ 556 /* Copy str2. */
556 for (i = 0; i < str2_len; i++) 557 for (i = 0; i < str2_len; i++)
557 p[i] = str2[i]; 558 p[i] = str2[i];
558 559
559 p += str2_len; 560 p += str2_len;
560 buf_len += diff; 561 buf_len += diff;
561 } 562 }
562 563
563 } 564 }
568 void 569 void
569 sel_prepare_string_for_dot_label (char *buf) 570 sel_prepare_string_for_dot_label (char *buf)
570 { 571 {
571 static char specials_from[7][2] = { "<", ">", "{", "|", "}", "\"", 572 static char specials_from[7][2] = { "<", ">", "{", "|", "}", "\"",
572 "\n" }; 573 "\n" };
573 static char specials_to[7][3] = { "\\<", "\\>", "\\{", "\\|", "\\}", 574 static char specials_to[7][3] = { "\\<", "\\>", "\\{", "\\|", "\\}",
574 "\\\"", "\\l" }; 575 "\\\"", "\\l" };
575 unsigned i; 576 unsigned i;
576 577
577 for (i = 0; i < 7; i++) 578 for (i = 0; i < 7; i++)
578 replace_str_in_buf (buf, specials_from[i], specials_to[i]); 579 replace_str_in_buf (buf, specials_from[i], specials_to[i]);
798 799
799 restore_dump (); 800 restore_dump ();
800 sched_dump_to_dot_p = false; 801 sched_dump_to_dot_p = false;
801 } 802 }
802 803
803 /* Dump a cfg region to the file specified by TAG honoring flags. 804 /* Dump a cfg region to the file specified by TAG honoring flags.
804 The file is created by the function. */ 805 The file is created by the function. */
805 static void 806 static void
806 sel_dump_cfg_1 (const char *tag, int flags) 807 sel_dump_cfg_1 (const char *tag, int flags)
807 { 808 {
808 char *buf; 809 char *buf;
929 /* Print a current cselib value for X's address to stderr. */ 930 /* Print a current cselib value for X's address to stderr. */
930 rtx 931 rtx
931 debug_mem_addr_value (rtx x) 932 debug_mem_addr_value (rtx x)
932 { 933 {
933 rtx t, addr; 934 rtx t, addr;
935 enum machine_mode address_mode;
934 936
935 gcc_assert (MEM_P (x)); 937 gcc_assert (MEM_P (x));
938 address_mode = targetm.addr_space.address_mode (MEM_ADDR_SPACE (x));
939
936 t = shallow_copy_rtx (x); 940 t = shallow_copy_rtx (x);
937 if (cselib_lookup (XEXP (t, 0), Pmode, 0)) 941 if (cselib_lookup (XEXP (t, 0), address_mode, 0))
938 XEXP (t, 0) = cselib_subst_to_values (XEXP (t, 0)); 942 XEXP (t, 0) = cselib_subst_to_values (XEXP (t, 0));
939 943
940 t = canon_rtx (t); 944 t = canon_rtx (t);
941 addr = get_addr (XEXP (t, 0)); 945 addr = get_addr (XEXP (t, 0));
942 debug_rtx (t); 946 debug_rtx (t);