Mercurial > hg > CbC > CbC_gcc
annotate gcc/sched-vis.c @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
| author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
|---|---|
| date | Tue, 22 Mar 2011 17:18:12 +0900 |
| parents | b7f97abdc517 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Instruction scheduling pass. |
| 2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
4 Free Software Foundation, Inc. |
| 0 | 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); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
84 if (CONST_INT_P (XEXP (x, 1)) |
| 0 | 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 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
432 if (!x) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
433 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
434 safe_concat (buf, buf, "(nil)"); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
435 return; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
436 } |
| 0 | 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 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; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
529 case DEBUG_EXPR: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
530 sprintf (t, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x))); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
531 cur = safe_concat (buf, cur, t); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
532 break; |
| 0 | 533 default: |
| 534 print_exp (t, x, verbose); | |
| 535 cur = safe_concat (buf, cur, t); | |
| 536 break; | |
| 537 } | |
| 538 } /* print_value */ | |
| 539 | |
| 540 /* The next step in insn detalization, its pattern recognition. */ | |
| 541 | |
| 542 void | |
| 543 print_pattern (char *buf, const_rtx x, int verbose) | |
| 544 { | |
| 545 char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN]; | |
| 546 | |
| 547 switch (GET_CODE (x)) | |
| 548 { | |
| 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; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
568 case VAR_LOCATION: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
569 print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
570 sprintf (buf, "loc %s", t1); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
571 break; |
| 0 | 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) | |
| 578 { | |
| 579 t1[0] = '!'; | |
| 580 print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose); | |
| 581 } | |
| 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: | |
| 588 { | |
| 589 int i; | |
| 590 | |
| 591 sprintf (t1, "{"); | |
| 592 for (i = 0; i < XVECLEN (x, 0); i++) | |
| 593 { | |
| 594 print_pattern (t2, XVECEXP (x, 0, i), verbose); | |
| 595 sprintf (t3, "%s%s;", t1, t2); | |
| 596 strcpy (t1, t3); | |
| 597 } | |
| 598 sprintf (buf, "%s}", t1); | |
| 599 } | |
| 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: | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
608 /* Fall through. */ |
| 0 | 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: | |
| 617 { | |
| 618 int i; | |
| 619 | |
| 620 sprintf (t1, "unspec{"); | |
| 621 for (i = 0; i < XVECLEN (x, 0); i++) | |
| 622 { | |
| 623 print_pattern (t2, XVECEXP (x, 0, i), verbose); | |
| 624 sprintf (t3, "%s%s;", t1, t2); | |
| 625 strcpy (t1, t3); | |
| 626 } | |
| 627 sprintf (buf, "%s}", t1); | |
| 628 } | |
| 629 break; | |
| 630 case UNSPEC_VOLATILE: | |
| 631 { | |
| 632 int i; | |
| 633 | |
| 634 sprintf (t1, "unspec/v{"); | |
| 635 for (i = 0; i < XVECLEN (x, 0); i++) | |
| 636 { | |
| 637 print_pattern (t2, XVECEXP (x, 0, i), verbose); | |
| 638 sprintf (t3, "%s%s;", t1, t2); | |
| 639 strcpy (t1, t3); | |
| 640 } | |
| 641 sprintf (buf, "%s}", t1); | |
| 642 } | |
| 643 break; | |
| 644 default: | |
| 645 print_value (buf, x, verbose); | |
| 646 } | |
| 647 } /* print_pattern */ | |
| 648 | |
| 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 ...) */ | |
| 655 | |
| 656 void | |
| 657 print_insn (char *buf, const_rtx x, int verbose) | |
| 658 { | |
| 659 char t[BUF_LEN]; | |
| 660 const_rtx insn = x; | |
| 661 | |
| 662 switch (GET_CODE (x)) | |
| 663 { | |
| 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), | |
| 669 t); | |
| 670 else | |
| 671 #endif | |
| 672 sprintf (buf, " %4d %s", INSN_UID (x), t); | |
| 673 break; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
674 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
675 case DEBUG_INSN: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
676 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
677 const char *name = "?"; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
678 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
679 if (DECL_P (INSN_VAR_LOCATION_DECL (insn))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
680 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
681 tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (insn)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
682 char idbuf[32]; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
683 if (id) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
684 name = IDENTIFIER_POINTER (id); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
685 else if (TREE_CODE (INSN_VAR_LOCATION_DECL (insn)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
686 == DEBUG_EXPR_DECL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
687 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
688 sprintf (idbuf, "D#%i", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
689 DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (insn))); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
690 name = idbuf; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
691 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
692 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
693 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
694 sprintf (idbuf, "D.%i", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
695 DECL_UID (INSN_VAR_LOCATION_DECL (insn))); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
696 name = idbuf; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
697 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
698 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
699 if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
700 sprintf (buf, " %4d: debug %s optimized away", INSN_UID (insn), name); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
701 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
702 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
703 print_pattern (t, INSN_VAR_LOCATION_LOC (insn), verbose); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
704 sprintf (buf, " %4d: debug %s => %s", INSN_UID (insn), name, t); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
705 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
706 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
707 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
708 |
| 0 | 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), | |
| 714 t); | |
| 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) | |
| 722 { | |
| 723 x = XVECEXP (x, 0, 0); | |
| 724 print_pattern (t, x, verbose); | |
| 725 } | |
| 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))); | |
| 748 } | |
| 749 } /* print_insn */ | |
| 750 | |
| 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) | |
| 755 { | |
| 756 char t[BUF_LEN + 32]; | |
| 757 rtx note; | |
| 758 | |
| 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)) | |
| 764 { | |
| 765 print_value (t, XEXP (note, 0), 1); | |
| 766 fprintf (f, " %s: %s\n", | |
| 767 GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t); | |
| 768 } | |
| 769 } | |
| 770 | |
| 771 /* Emit a slim dump of X (an insn) to stderr. */ | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
772 DEBUG_FUNCTION void |
| 0 | 773 debug_insn_slim (rtx x) |
| 774 { | |
| 775 dump_insn_slim (stderr, x); | |
| 776 } | |
| 777 | |
| 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) | |
| 783 { | |
| 784 print_rtl_slim (f, first, NULL, -1, flags); | |
| 785 } | |
| 786 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
787 /* Same as above, but stop at LAST or when COUNT == 0. |
| 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) | |
| 791 { | |
| 792 basic_block current_bb = NULL; | |
| 793 rtx insn, tail; | |
| 794 | |
| 795 tail = last ? NEXT_INSN (last) : NULL_RTX; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
796 for (insn = first; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
797 (insn != NULL) && (insn != tail) && (count != 0); |
| 0 | 798 insn = NEXT_INSN (insn)) |
| 799 { | |
| 800 if ((flags & TDF_BLOCKS) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
801 && (INSN_P (insn) || NOTE_P (insn)) |
| 0 | 802 && BLOCK_FOR_INSN (insn) |
| 803 && !current_bb) | |
| 804 { | |
| 805 current_bb = BLOCK_FOR_INSN (insn); | |
| 806 dump_bb_info (current_bb, true, false, flags, ";; ", f); | |
| 807 } | |
| 808 | |
| 809 dump_insn_slim (f, insn); | |
| 810 | |
| 811 if ((flags & TDF_BLOCKS) | |
| 812 && current_bb | |
| 813 && insn == BB_END (current_bb)) | |
| 814 { | |
| 815 dump_bb_info (current_bb, false, true, flags, ";; ", f); | |
| 816 current_bb = NULL; | |
| 817 } | |
| 818 if (count > 0) | |
| 819 count--; | |
| 820 } | |
| 821 } | |
| 822 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
823 DEBUG_FUNCTION void |
| 0 | 824 debug_bb_slim (struct basic_block_def *bb) |
| 825 { | |
| 826 print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32); | |
| 827 } | |
| 828 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
829 DEBUG_FUNCTION void |
| 0 | 830 debug_bb_n_slim (int n) |
| 831 { | |
| 832 struct basic_block_def *bb = BASIC_BLOCK (n); | |
| 833 debug_bb_slim (bb); | |
| 834 } | |
| 835 |