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) 7 8 This file is part of GCC. 9 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. 14 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. 19 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/>. */ 23 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" 35 36 static char *safe_concat (char *, char *, const char *); 37 38 #define BUF_LEN 2048 39 40 static char * 41 safe_concat (char *buf, char *cur, const char *str) 42 { 43 char *end = buf + BUF_LEN - 2; /* Leave room for null. */ 44 int c; 45 46 if (cur > end) 47 { 48 *end = '\0'; 49 return end; 50 } 51 52 while (cur < end && (c = *str++) != '\0') 53 *cur++ = c; 54 55 *cur = '\0'; 56 return cur; 57 } 58 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. */ 62 63 static void 64 print_exp (char *buf, const_rtx x, int verbose) 65 { 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; 73 74 for (i = 0; i < 4; i++) 75 { 76 st[i] = (char *) 0; 77 op[i] = NULL_RTX; 78 } 79 80 switch (GET_CODE (x)) 81 { 82 case PLUS: 83 op[0] = XEXP (x, 0); 84 if (CONST_INT_P (XEXP (x, 1)) 85 && INTVAL (XEXP (x, 1)) < 0) 86 { 87 st[1] = "-"; 88 op[1] = GEN_INT (-INTVAL (XEXP (x, 1))); 89 } 90 else 91 { 92 st[1] = "+"; 93 op[1] = XEXP (x, 1); 94 } 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) 347 { 348 st[1] = " argc:"; 349 op[1] = XEXP (x, 1); 350 } 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: 373 { 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++) 380 { 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 = ","; 385 } 386 cur = safe_concat (buf, cur, "] "); 387 sprintf (tmp, "%d", XINT (x, 1)); 388 cur = safe_concat (buf, cur, tmp); 389 } 390 break; 391 default: 392 /* If (verbose) debug_rtx (x); */ 393 st[0] = GET_RTX_NAME (GET_CODE (x)); 394 break; 395 } 396 397 /* Print this as a function? */ 398 if (fun) 399 { 400 cur = safe_concat (buf, cur, fun); 401 cur = safe_concat (buf, cur, "("); 402 } 403 404 for (i = 0; i < 4; i++) 405 { 406 if (st[i]) 407 cur = safe_concat (buf, cur, st[i]); 408 409 if (op[i]) 410 { 411 if (fun && i != 0) 412 cur = safe_concat (buf, cur, ","); 413 414 print_value (tmp, op[i], verbose); 415 cur = safe_concat (buf, cur, tmp); 416 } 417 } 418 419 if (fun) 420 cur = safe_concat (buf, cur, ")"); 421 } /* print_exp */ 422 423 /* Prints rtxes, I customarily classified as values. They're constants, 424 registers, labels, symbols and memory accesses. */ 425 426 void 427 print_value (char *buf, const_rtx x, int verbose) 428 { 429 char t[BUF_LEN]; 430 char *cur = buf; 431 432 if (!x) 433 { 434 safe_concat (buf, buf, "(nil)"); 435 return; 436 } 437 switch (GET_CODE (x)) 438 { 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) 486 { 487 int c = reg_names[REGNO (x)][0]; 488 if (ISDIGIT (c)) 489 cur = safe_concat (buf, cur, "%"); 490 491 cur = safe_concat (buf, cur, reg_names[REGNO (x)]); 492 } 493 else 494 { 495 sprintf (t, "r%d", REGNO (x)); 496 cur = safe_concat (buf, cur, t); 497 } 498 if (verbose 499 #ifdef INSN_SCHEDULING 500 && !current_sched_info 501 #endif 502 ) 503 { 504 sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x))); 505 cur = safe_concat (buf, cur, t); 506 } 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 STRICT_LOW_PART: 515 print_value (t, XEXP (x, 0), verbose); 516 cur = safe_concat (buf, cur, "strict_low_part("); 517 cur = safe_concat (buf, cur, t); 518 cur = safe_concat (buf, cur, ")"); 519 break; 520 case SCRATCH: 521 cur = safe_concat (buf, cur, "scratch"); 522 break; 523 case CC0: 524 cur = safe_concat (buf, cur, "cc0"); 525 break; 526 case PC: 527 cur = safe_concat (buf, cur, "pc"); 528 break; 529 case MEM: 530 print_value (t, XEXP (x, 0), verbose); 531 cur = safe_concat (buf, cur, "["); 532 cur = safe_concat (buf, cur, t); 533 cur = safe_concat (buf, cur, "]"); 534 break; 535 case DEBUG_EXPR: 536 sprintf (t, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))); 537 cur = safe_concat (buf, cur, t); 538 break; 539 default: 540 print_exp (t, x, verbose); 541 cur = safe_concat (buf, cur, t); 542 break; 543 } 544 } /* print_value */ 545 546 /* The next step in insn detalization, its pattern recognition. */ 547 548 void 549 print_pattern (char *buf, const_rtx x, int verbose) 550 { 551 char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN]; 552 553 switch (GET_CODE (x)) 554 { 555 case SET: 556 print_value (t1, SET_DEST (x), verbose); 557 print_value (t2, SET_SRC (x), verbose); 558 sprintf (buf, "%s=%s", t1, t2); 559 break; 560 case RETURN: 561 sprintf (buf, "return"); 562 break; 563 case SIMPLE_RETURN: 564 sprintf (buf, "simple_return"); 565 break; 566 case CALL: 567 print_exp (buf, x, verbose); 568 break; 569 case CLOBBER: 570 print_value (t1, XEXP (x, 0), verbose); 571 sprintf (buf, "clobber %s", t1); 572 break; 573 case USE: 574 print_value (t1, XEXP (x, 0), verbose); 575 sprintf (buf, "use %s", t1); 576 break; 577 case VAR_LOCATION: 578 print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose); 579 sprintf (buf, "loc %s", t1); 580 break; 581 case COND_EXEC: 582 if (GET_CODE (COND_EXEC_TEST (x)) == NE 583 && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx) 584 print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose); 585 else if (GET_CODE (COND_EXEC_TEST (x)) == EQ 586 && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx) 587 { 588 t1[0] = '!'; 589 print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose); 590 } 591 else 592 print_value (t1, COND_EXEC_TEST (x), verbose); 593 print_pattern (t2, COND_EXEC_CODE (x), verbose); 594 sprintf (buf, "(%s) %s", t1, t2); 595 break; 596 case PARALLEL: 597 { 598 int i; 599 600 sprintf (t1, "{"); 601 for (i = 0; i < XVECLEN (x, 0); i++) 602 { 603 print_pattern (t2, XVECEXP (x, 0, i), verbose); 604 sprintf (t3, "%s%s;", t1, t2); 605 strcpy (t1, t3); 606 } 607 sprintf (buf, "%s}", t1); 608 } 609 break; 610 case SEQUENCE: 611 /* Should never see SEQUENCE codes until after reorg. */ 612 gcc_unreachable (); 613 case ASM_INPUT: 614 sprintf (buf, "asm {%s}", XSTR (x, 0)); 615 break; 616 case ADDR_VEC: 617 /* Fall through. */ 618 case ADDR_DIFF_VEC: 619 print_value (buf, XEXP (x, 0), verbose); 620 break; 621 case TRAP_IF: 622 print_value (t1, TRAP_CONDITION (x), verbose); 623 sprintf (buf, "trap_if %s", t1); 624 break; 625 case UNSPEC: 626 { 627 int i; 628 629 sprintf (t1, "unspec{"); 630 for (i = 0; i < XVECLEN (x, 0); i++) 631 { 632 print_pattern (t2, XVECEXP (x, 0, i), verbose); 633 sprintf (t3, "%s%s;", t1, t2); 634 strcpy (t1, t3); 635 } 636 sprintf (buf, "%s}", t1); 637 } 638 break; 639 case UNSPEC_VOLATILE: 640 { 641 int i; 642 643 sprintf (t1, "unspec/v{"); 644 for (i = 0; i < XVECLEN (x, 0); i++) 645 { 646 print_pattern (t2, XVECEXP (x, 0, i), verbose); 647 sprintf (t3, "%s%s;", t1, t2); 648 strcpy (t1, t3); 649 } 650 sprintf (buf, "%s}", t1); 651 } 652 break; 653 default: 654 print_value (buf, x, verbose); 655 } 656 } /* print_pattern */ 657 658 /* This is the main function in rtl visualization mechanism. It 659 accepts an rtx and tries to recognize it as an insn, then prints it 660 properly in human readable form, resembling assembler mnemonics. 661 For every insn it prints its UID and BB the insn belongs too. 662 (Probably the last "option" should be extended somehow, since it 663 depends now on sched.c inner variables ...) */ 664 665 void 666 print_insn (char *buf, const_rtx x, int verbose) 667 { 668 char t[BUF_LEN]; 669 const_rtx insn = x; 670 671 switch (GET_CODE (x)) 672 { 673 case INSN: 674 print_pattern (t, PATTERN (x), verbose); 675 #ifdef INSN_SCHEDULING 676 if (verbose && current_sched_info) 677 sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1), 678 t); 679 else 680 #endif 681 sprintf (buf, " %4d %s", INSN_UID (x), t); 682 break; 683 684 case DEBUG_INSN: 685 { 686 const char *name = "?"; 687 688 if (DECL_P (INSN_VAR_LOCATION_DECL (insn))) 689 { 690 tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (insn)); 691 char idbuf[32]; 692 if (id) 693 name = IDENTIFIER_POINTER (id); 694 else if (TREE_CODE (INSN_VAR_LOCATION_DECL (insn)) 695 == DEBUG_EXPR_DECL) 696 { 697 sprintf (idbuf, "D#%i", 698 DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (insn))); 699 name = idbuf; 700 } 701 else 702 { 703 sprintf (idbuf, "D.%i", 704 DECL_UID (INSN_VAR_LOCATION_DECL (insn))); 705 name = idbuf; 706 } 707 } 708 if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn))) 709 sprintf (buf, " %4d: debug %s optimized away", INSN_UID (insn), name); 710 else 711 { 712 print_pattern (t, INSN_VAR_LOCATION_LOC (insn), verbose); 713 sprintf (buf, " %4d: debug %s => %s", INSN_UID (insn), name, t); 714 } 715 } 716 break; 717 718 case JUMP_INSN: 719 print_pattern (t, PATTERN (x), verbose); 720 #ifdef INSN_SCHEDULING 721 if (verbose && current_sched_info) 722 sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1), 723 t); 724 else 725 #endif 726 sprintf (buf, " %4d %s", INSN_UID (x), t); 727 break; 728 case CALL_INSN: 729 x = PATTERN (insn); 730 if (GET_CODE (x) == PARALLEL) 731 { 732 x = XVECEXP (x, 0, 0); 733 print_pattern (t, x, verbose); 734 } 735 else 736 strcpy (t, "call <...>"); 737 #ifdef INSN_SCHEDULING 738 if (verbose && current_sched_info) 739 sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t); 740 else 741 #endif 742 sprintf (buf, " %4d %s", INSN_UID (insn), t); 743 break; 744 case CODE_LABEL: 745 sprintf (buf, "L%d:", INSN_UID (x)); 746 break; 747 case BARRIER: 748 sprintf (buf, "i%4d: barrier", INSN_UID (x)); 749 break; 750 case NOTE: 751 sprintf (buf, " %4d %s", INSN_UID (x), 752 GET_NOTE_INSN_NAME (NOTE_KIND (x))); 753 break; 754 default: 755 sprintf (buf, "i%4d <What %s?>", INSN_UID (x), 756 GET_RTX_NAME (GET_CODE (x))); 757 } 758 } /* print_insn */ 759 760 /* Emit a slim dump of X (an insn) to the file F, including any register 761 note attached to the instruction. */ 762 void 763 dump_insn_slim (FILE *f, rtx x) 764 { 765 char t[BUF_LEN + 32]; 766 rtx note; 767 768 print_insn (t, x, 1); 769 fputs (t, f); 770 putc ('\n', f); 771 if (INSN_P (x) && REG_NOTES (x)) 772 for (note = REG_NOTES (x); note; note = XEXP (note, 1)) 773 { 774 print_value (t, XEXP (note, 0), 1); 775 fprintf (f, " %s: %s\n", 776 GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t); 777 } 778 } 779 780 /* Emit a slim dump of X (an insn) to stderr. */ 781 DEBUG_FUNCTION void 782 debug_insn_slim (rtx x) 783 { 784 dump_insn_slim (stderr, x); 785 } 786 787 /* Provide a slim dump the instruction chain starting at FIRST to F, honoring 788 the dump flags given in FLAGS. Currently, TDF_BLOCKS and TDF_DETAILS 789 include more information on the basic blocks. */ 790 void 791 print_rtl_slim_with_bb (FILE *f, rtx first, int flags) 792 { 793 print_rtl_slim (f, first, NULL, -1, flags); 794 } 795 796 /* Same as above, but stop at LAST or when COUNT == 0. 797 If COUNT < 0 it will stop only at LAST or NULL rtx. */ 798 void 799 print_rtl_slim (FILE *f, rtx first, rtx last, int count, int flags) 800 { 801 basic_block current_bb = NULL; 802 rtx insn, tail; 803 804 tail = last ? NEXT_INSN (last) : NULL_RTX; 805 for (insn = first; 806 (insn != NULL) && (insn != tail) && (count != 0); 807 insn = NEXT_INSN (insn)) 808 { 809 if ((flags & TDF_BLOCKS) 810 && (INSN_P (insn) || NOTE_P (insn)) 811 && BLOCK_FOR_INSN (insn) 812 && !current_bb) 813 { 814 current_bb = BLOCK_FOR_INSN (insn); 815 dump_bb_info (current_bb, true, false, flags, ";; ", f); 816 } 817 818 dump_insn_slim (f, insn); 819 820 if ((flags & TDF_BLOCKS) 821 && current_bb 822 && insn == BB_END (current_bb)) 823 { 824 dump_bb_info (current_bb, false, true, flags, ";; ", f); 825 current_bb = NULL; 826 } 827 if (count > 0) 828 count--; 829 } 830 } 831 832 DEBUG_FUNCTION void 833 debug_bb_slim (struct basic_block_def *bb) 834 { 835 print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32); 836 } 837 838 DEBUG_FUNCTION void 839 debug_bb_n_slim (int n) 840 { 841 struct basic_block_def *bb = BASIC_BLOCK (n); 842 debug_bb_slim (bb); 843 } 844 845