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 826

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.