OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [sched-vis.c] - Blame information for rev 843

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn 
/* Instruction scheduling pass.
2 
   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 
   2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4 
   Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
5 
   and currently maintained by, Jim Wilson (wilson@cygnus.com)
6 
 
7 
This file is part of GCC.
8 
 
9 
GCC is free software; you can redistribute it and/or modify it under
10 
the terms of the GNU General Public License as published by the Free
11 
Software Foundation; either version 3, or (at your option) any later
12 
version.
13 
 
14 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 
WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17 
for more details.
18 
 
19 
You should have received a copy of the GNU General Public License
20 
along with GCC; see the file COPYING3.  If not see
21 
<http://www.gnu.org/licenses/>.  */
22 
 
23 
#include "config.h"
24 
#include "system.h"
25 
#include "coretypes.h"
26 
#include "tm.h"
27 
#include "rtl.h"
28 
#include "obstack.h"
29 
#include "hard-reg-set.h"
30 
#include "basic-block.h"
31 
#include "real.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 
  switch (GET_CODE (x))
433 
    {
434 
    case CONST_INT:
435 
      sprintf (t, HOST_WIDE_INT_PRINT_HEX,
436 
               (unsigned HOST_WIDE_INT) INTVAL (x));
437 
      cur = safe_concat (buf, cur, t);
438 
      break;
439 
    case CONST_DOUBLE:
440 
      if (FLOAT_MODE_P (GET_MODE (x)))
441 
        real_to_decimal (t, CONST_DOUBLE_REAL_VALUE (x), sizeof (t), 0, 1);
442 
      else
443 
        sprintf (t,
444 
                 "<" HOST_WIDE_INT_PRINT_HEX "," HOST_WIDE_INT_PRINT_HEX ">",
445 
                 (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x),
446 
                 (unsigned HOST_WIDE_INT) CONST_DOUBLE_HIGH (x));
447 
      cur = safe_concat (buf, cur, t);
448 
      break;
449 
    case CONST_FIXED:
450 
      fixed_to_decimal (t, CONST_FIXED_VALUE (x), sizeof (t));
451 
      cur = safe_concat (buf, cur, t);
452 
      break;
453 
    case CONST_STRING:
454 
      cur = safe_concat (buf, cur, "\"");
455 
      cur = safe_concat (buf, cur, XSTR (x, 0));
456 
      cur = safe_concat (buf, cur, "\"");
457 
      break;
458 
    case SYMBOL_REF:
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 LABEL_REF:
464 
      sprintf (t, "L%d", INSN_UID (XEXP (x, 0)));
465 
      cur = safe_concat (buf, cur, t);
466 
      break;
467 
    case CONST:
468 
      print_value (t, XEXP (x, 0), verbose);
469 
      cur = safe_concat (buf, cur, "const(");
470 
      cur = safe_concat (buf, cur, t);
471 
      cur = safe_concat (buf, cur, ")");
472 
      break;
473 
    case HIGH:
474 
      print_value (t, XEXP (x, 0), verbose);
475 
      cur = safe_concat (buf, cur, "high(");
476 
      cur = safe_concat (buf, cur, t);
477 
      cur = safe_concat (buf, cur, ")");
478 
      break;
479 
    case REG:
480 
      if (REGNO (x) < FIRST_PSEUDO_REGISTER)
481 
        {
482 
          int c = reg_names[REGNO (x)][0];
483 
          if (ISDIGIT (c))
484 
            cur = safe_concat (buf, cur, "%");
485 
 
486 
          cur = safe_concat (buf, cur, reg_names[REGNO (x)]);
487 
        }
488 
      else
489 
        {
490 
          sprintf (t, "r%d", REGNO (x));
491 
          cur = safe_concat (buf, cur, t);
492 
        }
493 
      if (verbose
494 
#ifdef INSN_SCHEDULING
495 
          && !current_sched_info
496 
#endif
497 
         )
498 
        {
499 
          sprintf (t, ":%s", GET_MODE_NAME (GET_MODE (x)));
500 
          cur = safe_concat (buf, cur, t);
501 
        }
502 
      break;
503 
    case SUBREG:
504 
      print_value (t, SUBREG_REG (x), verbose);
505 
      cur = safe_concat (buf, cur, t);
506 
      sprintf (t, "#%d", SUBREG_BYTE (x));
507 
      cur = safe_concat (buf, cur, t);
508 
      break;
509 
    case SCRATCH:
510 
      cur = safe_concat (buf, cur, "scratch");
511 
      break;
512 
    case CC0:
513 
      cur = safe_concat (buf, cur, "cc0");
514 
      break;
515 
    case PC:
516 
      cur = safe_concat (buf, cur, "pc");
517 
      break;
518 
    case MEM:
519 
      print_value (t, XEXP (x, 0), verbose);
520 
      cur = safe_concat (buf, cur, "[");
521 
      cur = safe_concat (buf, cur, t);
522 
      cur = safe_concat (buf, cur, "]");
523 
      break;
524 
    case DEBUG_EXPR:
525 
      sprintf (t, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
526 
      cur = safe_concat (buf, cur, t);
527 
      break;
528 
    default:
529 
      print_exp (t, x, verbose);
530 
      cur = safe_concat (buf, cur, t);
531 
      break;
532 
    }
533 
}                               /* print_value */
534 
 
535 
/* The next step in insn detalization, its pattern recognition.  */
536 
 
537 
void
538 
print_pattern (char *buf, const_rtx x, int verbose)
539 
{
540 
  char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
541 
 
542 
  switch (GET_CODE (x))
543 
    {
544 
    case SET:
545 
      print_value (t1, SET_DEST (x), verbose);
546 
      print_value (t2, SET_SRC (x), verbose);
547 
      sprintf (buf, "%s=%s", t1, t2);
548 
      break;
549 
    case RETURN:
550 
      sprintf (buf, "return");
551 
      break;
552 
    case CALL:
553 
      print_exp (buf, x, verbose);
554 
      break;
555 
    case CLOBBER:
556 
      print_value (t1, XEXP (x, 0), verbose);
557 
      sprintf (buf, "clobber %s", t1);
558 
      break;
559 
    case USE:
560 
      print_value (t1, XEXP (x, 0), verbose);
561 
      sprintf (buf, "use %s", t1);
562 
      break;
563 
    case VAR_LOCATION:
564 
      print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose);
565 
      sprintf (buf, "loc %s", t1);
566 
      break;
567 
    case COND_EXEC:
568 
      if (GET_CODE (COND_EXEC_TEST (x)) == NE
569 
          && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
570 
        print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
571 
      else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
572 
               && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
573 
        {
574 
          t1[0] = '!';
575 
          print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
576 
        }
577 
      else
578 
        print_value (t1, COND_EXEC_TEST (x), verbose);
579 
      print_pattern (t2, COND_EXEC_CODE (x), verbose);
580 
      sprintf (buf, "(%s) %s", t1, t2);
581 
      break;
582 
    case PARALLEL:
583 
      {
584 
        int i;
585 
 
586 
        sprintf (t1, "{");
587 
        for (i = 0; i < XVECLEN (x, 0); i++)
588 
          {
589 
            print_pattern (t2, XVECEXP (x, 0, i), verbose);
590 
            sprintf (t3, "%s%s;", t1, t2);
591 
            strcpy (t1, t3);
592 
          }
593 
        sprintf (buf, "%s}", t1);
594 
      }
595 
      break;
596 
    case SEQUENCE:
597 
      /* Should never see SEQUENCE codes until after reorg.  */
598 
      gcc_unreachable ();
599 
    case ASM_INPUT:
600 
      sprintf (buf, "asm {%s}", XSTR (x, 0));
601 
      break;
602 
    case ADDR_VEC:
603 
      break;
604 
    case ADDR_DIFF_VEC:
605 
      print_value (buf, XEXP (x, 0), verbose);
606 
      break;
607 
    case TRAP_IF:
608 
      print_value (t1, TRAP_CONDITION (x), verbose);
609 
      sprintf (buf, "trap_if %s", t1);
610 
      break;
611 
    case UNSPEC:
612 
      {
613 
        int i;
614 
 
615 
        sprintf (t1, "unspec{");
616 
        for (i = 0; i < XVECLEN (x, 0); i++)
617 
          {
618 
            print_pattern (t2, XVECEXP (x, 0, i), verbose);
619 
            sprintf (t3, "%s%s;", t1, t2);
620 
            strcpy (t1, t3);
621 
          }
622 
        sprintf (buf, "%s}", t1);
623 
      }
624 
      break;
625 
    case UNSPEC_VOLATILE:
626 
      {
627 
        int i;
628 
 
629 
        sprintf (t1, "unspec/v{");
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 
    default:
640 
      print_value (buf, x, verbose);
641 
    }
642 
}                               /* print_pattern */
643 
 
644 
/* This is the main function in rtl visualization mechanism. It
645 
   accepts an rtx and tries to recognize it as an insn, then prints it
646 
   properly in human readable form, resembling assembler mnemonics.
647 
   For every insn it prints its UID and BB the insn belongs too.
648 
   (Probably the last "option" should be extended somehow, since it
649 
   depends now on sched.c inner variables ...)  */
650 
 
651 
void
652 
print_insn (char *buf, const_rtx x, int verbose)
653 
{
654 
  char t[BUF_LEN];
655 
  const_rtx insn = x;
656 
 
657 
  switch (GET_CODE (x))
658 
    {
659 
    case INSN:
660 
      print_pattern (t, PATTERN (x), verbose);
661 
#ifdef INSN_SCHEDULING
662 
      if (verbose && current_sched_info)
663 
        sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
664 
                 t);
665 
      else
666 
#endif
667 
        sprintf (buf, " %4d %s", INSN_UID (x), t);
668 
      break;
669 
 
670 
    case DEBUG_INSN:
671 
      {
672 
        const char *name = "?";
673 
 
674 
        if (DECL_P (INSN_VAR_LOCATION_DECL (insn)))
675 
          {
676 
            tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (insn));
677 
            char idbuf[32];
678 
            if (id)
679 
              name = IDENTIFIER_POINTER (id);
680 
            else if (TREE_CODE (INSN_VAR_LOCATION_DECL (insn))
681 
                     == DEBUG_EXPR_DECL)
682 
              {
683 
                sprintf (idbuf, "D#%i",
684 
                         DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (insn)));
685 
                name = idbuf;
686 
              }
687 
            else
688 
              {
689 
                sprintf (idbuf, "D.%i",
690 
                         DECL_UID (INSN_VAR_LOCATION_DECL (insn)));
691 
                name = idbuf;
692 
              }
693 
          }
694 
        if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)))
695 
          sprintf (buf, " %4d: debug %s optimized away", INSN_UID (insn), name);
696 
        else
697 
          {
698 
            print_pattern (t, INSN_VAR_LOCATION_LOC (insn), verbose);
699 
            sprintf (buf, " %4d: debug %s => %s", INSN_UID (insn), name, t);
700 
          }
701 
      }
702 
      break;
703 
 
704 
    case JUMP_INSN:
705 
      print_pattern (t, PATTERN (x), verbose);
706 
#ifdef INSN_SCHEDULING
707 
      if (verbose && current_sched_info)
708 
        sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
709 
                 t);
710 
      else
711 
#endif
712 
        sprintf (buf, " %4d %s", INSN_UID (x), t);
713 
      break;
714 
    case CALL_INSN:
715 
      x = PATTERN (insn);
716 
      if (GET_CODE (x) == PARALLEL)
717 
        {
718 
          x = XVECEXP (x, 0, 0);
719 
          print_pattern (t, x, verbose);
720 
        }
721 
      else
722 
        strcpy (t, "call <...>");
723 
#ifdef INSN_SCHEDULING
724 
      if (verbose && current_sched_info)
725 
        sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
726 
      else
727 
#endif
728 
        sprintf (buf, " %4d %s", INSN_UID (insn), t);
729 
      break;
730 
    case CODE_LABEL:
731 
      sprintf (buf, "L%d:", INSN_UID (x));
732 
      break;
733 
    case BARRIER:
734 
      sprintf (buf, "i%4d: barrier", INSN_UID (x));
735 
      break;
736 
    case NOTE:
737 
      sprintf (buf, " %4d %s", INSN_UID (x),
738 
               GET_NOTE_INSN_NAME (NOTE_KIND (x)));
739 
      break;
740 
    default:
741 
      sprintf (buf, "i%4d  <What %s?>", INSN_UID (x),
742 
               GET_RTX_NAME (GET_CODE (x)));
743 
    }
744 
}                               /* print_insn */
745 
 
746 
/* Emit a slim dump of X (an insn) to the file F, including any register
747 
   note attached to the instruction.  */
748 
void
749 
dump_insn_slim (FILE *f, rtx x)
750 
{
751 
  char t[BUF_LEN + 32];
752 
  rtx note;
753 
 
754 
  print_insn (t, x, 1);
755 
  fputs (t, f);
756 
  putc ('\n', f);
757 
  if (INSN_P (x) && REG_NOTES (x))
758 
    for (note = REG_NOTES (x); note; note = XEXP (note, 1))
759 
      {
760 
        print_value (t, XEXP (note, 0), 1);
761 
        fprintf (f, "      %s: %s\n",
762 
                 GET_REG_NOTE_NAME (REG_NOTE_KIND (note)), t);
763 
      }
764 
}
765 
 
766 
/* Emit a slim dump of X (an insn) to stderr.  */
767 
void
768 
debug_insn_slim (rtx x)
769 
{
770 
  dump_insn_slim (stderr, x);
771 
}
772 
 
773 
/* Provide a slim dump the instruction chain starting at FIRST to F, honoring
774 
   the dump flags given in FLAGS.  Currently, TDF_BLOCKS and TDF_DETAILS
775 
   include more information on the basic blocks.  */
776 
void
777 
print_rtl_slim_with_bb (FILE *f, rtx first, int flags)
778 
{
779 
  print_rtl_slim (f, first, NULL, -1, flags);
780 
}
781 
 
782 
/* Same as above, but stop at LAST or when COUNT == 0.
783 
   If COUNT < 0 it will stop only at LAST or NULL rtx.  */
784 
void
785 
print_rtl_slim (FILE *f, rtx first, rtx last, int count, int flags)
786 
{
787 
  basic_block current_bb = NULL;
788 
  rtx insn, tail;
789 
 
790 
  tail = last ? NEXT_INSN (last) : NULL_RTX;
791 
  for (insn = first;
792 
       (insn != NULL) && (insn != tail) && (count != 0);
793 
       insn = NEXT_INSN (insn))
794 
    {
795 
      if ((flags & TDF_BLOCKS)
796 
          && (INSN_P (insn) || NOTE_P (insn))
797 
          && BLOCK_FOR_INSN (insn)
798 
          && !current_bb)
799 
        {
800 
          current_bb = BLOCK_FOR_INSN (insn);
801 
          dump_bb_info (current_bb, true, false, flags, ";; ", f);
802 
        }
803 
 
804 
      dump_insn_slim (f, insn);
805 
 
806 
      if ((flags & TDF_BLOCKS)
807 
          && current_bb
808 
          && insn == BB_END (current_bb))
809 
        {
810 
          dump_bb_info (current_bb, false, true, flags, ";; ", f);
811 
          current_bb = NULL;
812 
        }
813 
      if (count > 0)
814 
        count--;
815 
    }
816 
}
817 
 
818 
void
819 
debug_bb_slim (struct basic_block_def *bb)
820 
{
821 
  print_rtl_slim (stderr, BB_HEAD (bb), BB_END (bb), -1, 32);
822 
}
823 
 
824 
void
825 
debug_bb_n_slim (int n)
826 
{
827 
  struct basic_block_def *bb = BASIC_BLOCK (n);
828 
  debug_bb_slim (bb);
829 
}
830 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.