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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [sched-vis.c] - Blame information for rev 684

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* 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
 

powered by: WebSVN 2.1.0

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