2010-07-27 Paolo Carlini <paolo.carlini@oracle.com>
[official-gcc/alias-decl.git] / gcc / rtl.c
blob79dafcb004f0bf363870eb968150e6817bd054a8
1 /* RTL utility routines.
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* This file is compiled twice: once for the generator programs
22 once for the compiler. */
23 #ifdef GENERATOR_FILE
24 #include "bconfig.h"
25 #else
26 #include "config.h"
27 #endif
29 #include "system.h"
30 #include "coretypes.h"
31 #include "tm.h"
32 #include "rtl.h"
33 #include "ggc.h"
34 #ifdef GENERATOR_FILE
35 # include "errors.h"
36 #else
37 # include "diagnostic-core.h"
38 #endif
41 /* Indexed by rtx code, gives number of operands for an rtx with that code.
42 Does NOT include rtx header data (code and links). */
44 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
46 const unsigned char rtx_length[NUM_RTX_CODE] = {
47 #include "rtl.def"
50 #undef DEF_RTL_EXPR
52 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
54 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
56 const char * const rtx_name[NUM_RTX_CODE] = {
57 #include "rtl.def" /* rtl expressions are documented here */
60 #undef DEF_RTL_EXPR
62 /* Indexed by rtx code, gives a sequence of operand-types for
63 rtx's of that code. The sequence is a C string in which
64 each character describes one operand. */
66 const char * const rtx_format[NUM_RTX_CODE] = {
67 /* "*" undefined.
68 can cause a warning message
69 "0" field is unused (or used in a phase-dependent manner)
70 prints nothing
71 "i" an integer
72 prints the integer
73 "n" like "i", but prints entries from `note_insn_name'
74 "w" an integer of width HOST_BITS_PER_WIDE_INT
75 prints the integer
76 "s" a pointer to a string
77 prints the string
78 "S" like "s", but optional:
79 the containing rtx may end before this operand
80 "T" like "s", but treated specially by the RTL reader;
81 only found in machine description patterns.
82 "e" a pointer to an rtl expression
83 prints the expression
84 "E" a pointer to a vector that points to a number of rtl expressions
85 prints a list of the rtl expressions
86 "V" like "E", but optional:
87 the containing rtx may end before this operand
88 "u" a pointer to another insn
89 prints the uid of the insn.
90 "b" is a pointer to a bitmap header.
91 "B" is a basic block pointer.
92 "t" is a tree pointer. */
94 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
95 #include "rtl.def" /* rtl expressions are defined here */
96 #undef DEF_RTL_EXPR
99 /* Indexed by rtx code, gives a character representing the "class" of
100 that rtx code. See rtl.def for documentation on the defined classes. */
102 const enum rtx_class rtx_class[NUM_RTX_CODE] = {
103 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
104 #include "rtl.def" /* rtl expressions are defined here */
105 #undef DEF_RTL_EXPR
108 /* Indexed by rtx code, gives the size of the rtx in bytes. */
110 const unsigned char rtx_code_size[NUM_RTX_CODE] = {
111 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) \
112 ((ENUM) == CONST_INT || (ENUM) == CONST_DOUBLE || (ENUM) == CONST_FIXED\
113 ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT) \
114 : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
116 #include "rtl.def"
117 #undef DEF_RTL_EXPR
120 /* Names for kinds of NOTEs and REG_NOTEs. */
122 const char * const note_insn_name[NOTE_INSN_MAX] =
124 #define DEF_INSN_NOTE(NAME) #NAME,
125 #include "insn-notes.def"
126 #undef DEF_INSN_NOTE
129 const char * const reg_note_name[REG_NOTE_MAX] =
131 #define DEF_REG_NOTE(NAME) #NAME,
132 #include "reg-notes.def"
133 #undef DEF_REG_NOTE
136 #ifdef GATHER_STATISTICS
137 static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
138 static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
139 static int rtvec_alloc_counts;
140 static int rtvec_alloc_sizes;
141 #endif
144 /* Allocate an rtx vector of N elements.
145 Store the length, and initialize all elements to zero. */
147 rtvec
148 rtvec_alloc (int n)
150 rtvec rt;
152 rt = ggc_alloc_rtvec_sized (n);
153 /* Clear out the vector. */
154 memset (&rt->elem[0], 0, n * sizeof (rtx));
156 PUT_NUM_ELEM (rt, n);
158 #ifdef GATHER_STATISTICS
159 rtvec_alloc_counts++;
160 rtvec_alloc_sizes += n * sizeof (rtx);
161 #endif
163 return rt;
166 /* Create a bitwise copy of VEC. */
168 rtvec
169 shallow_copy_rtvec (rtvec vec)
171 rtvec newvec;
172 int n;
174 n = GET_NUM_ELEM (vec);
175 newvec = rtvec_alloc (n);
176 memcpy (&newvec->elem[0], &vec->elem[0], sizeof (rtx) * n);
177 return newvec;
180 /* Return the number of bytes occupied by rtx value X. */
182 unsigned int
183 rtx_size (const_rtx x)
185 if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
186 return RTX_HDR_SIZE + sizeof (struct block_symbol);
187 return RTX_CODE_SIZE (GET_CODE (x));
190 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
191 all the rest is initialized to zero. */
194 rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL)
196 rtx rt = ggc_alloc_zone_rtx_def_stat (&rtl_zone, RTX_CODE_SIZE (code)
197 PASS_MEM_STAT);
199 /* We want to clear everything up to the FLD array. Normally, this
200 is one int, but we don't want to assume that and it isn't very
201 portable anyway; this is. */
203 memset (rt, 0, RTX_HDR_SIZE);
204 PUT_CODE (rt, code);
206 #ifdef GATHER_STATISTICS
207 rtx_alloc_counts[code]++;
208 rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
209 #endif
211 return rt;
215 /* Return true if ORIG is a sharable CONST. */
217 bool
218 shared_const_p (const_rtx orig)
220 gcc_assert (GET_CODE (orig) == CONST);
222 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
223 a LABEL_REF, it isn't sharable. */
224 return (GET_CODE (XEXP (orig, 0)) == PLUS
225 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
226 && CONST_INT_P(XEXP (XEXP (orig, 0), 1)));
230 /* Create a new copy of an rtx.
231 Recursively copies the operands of the rtx,
232 except for those few rtx codes that are sharable. */
235 copy_rtx (rtx orig)
237 rtx copy;
238 int i, j;
239 RTX_CODE code;
240 const char *format_ptr;
242 code = GET_CODE (orig);
244 switch (code)
246 case REG:
247 case DEBUG_EXPR:
248 case VALUE:
249 case CONST_INT:
250 case CONST_DOUBLE:
251 case CONST_FIXED:
252 case CONST_VECTOR:
253 case SYMBOL_REF:
254 case CODE_LABEL:
255 case PC:
256 case CC0:
257 case SCRATCH:
258 /* SCRATCH must be shared because they represent distinct values. */
259 return orig;
260 case CLOBBER:
261 if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER)
262 return orig;
263 break;
265 case CONST:
266 if (shared_const_p (orig))
267 return orig;
268 break;
270 /* A MEM with a constant address is not sharable. The problem is that
271 the constant address may need to be reloaded. If the mem is shared,
272 then reloading one copy of this mem will cause all copies to appear
273 to have been reloaded. */
275 default:
276 break;
279 /* Copy the various flags, fields, and other information. We assume
280 that all fields need copying, and then clear the fields that should
281 not be copied. That is the sensible default behavior, and forces
282 us to explicitly document why we are *not* copying a flag. */
283 copy = shallow_copy_rtx (orig);
285 /* We do not copy the USED flag, which is used as a mark bit during
286 walks over the RTL. */
287 RTX_FLAG (copy, used) = 0;
289 /* We do not copy FRAME_RELATED for INSNs. */
290 if (INSN_P (orig))
291 RTX_FLAG (copy, frame_related) = 0;
292 RTX_FLAG (copy, jump) = RTX_FLAG (orig, jump);
293 RTX_FLAG (copy, call) = RTX_FLAG (orig, call);
295 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
297 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
298 switch (*format_ptr++)
300 case 'e':
301 if (XEXP (orig, i) != NULL)
302 XEXP (copy, i) = copy_rtx (XEXP (orig, i));
303 break;
305 case 'E':
306 case 'V':
307 if (XVEC (orig, i) != NULL)
309 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
310 for (j = 0; j < XVECLEN (copy, i); j++)
311 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
313 break;
315 case 't':
316 case 'w':
317 case 'i':
318 case 's':
319 case 'S':
320 case 'T':
321 case 'u':
322 case 'B':
323 case '0':
324 /* These are left unchanged. */
325 break;
327 default:
328 gcc_unreachable ();
330 return copy;
333 /* Create a new copy of an rtx. Only copy just one level. */
336 shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL)
338 const unsigned int size = rtx_size (orig);
339 rtx const copy = ggc_alloc_zone_rtx_def_stat (&rtl_zone, size PASS_MEM_STAT);
340 return (rtx) memcpy (copy, orig, size);
343 /* Nonzero when we are generating CONCATs. */
344 int generating_concat_p;
346 /* Nonzero when we are expanding trees to RTL. */
347 int currently_expanding_to_rtl;
351 /* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
352 When the callback returns true, we continue with the new pair.
353 Whenever changing this function check if rtx_equal_p below doesn't need
354 changing as well. */
357 rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
359 int i;
360 int j;
361 enum rtx_code code;
362 const char *fmt;
363 rtx nx, ny;
365 if (x == y)
366 return 1;
367 if (x == 0 || y == 0)
368 return 0;
370 /* Invoke the callback first. */
371 if (cb != NULL
372 && ((*cb) (&x, &y, &nx, &ny)))
373 return rtx_equal_p_cb (nx, ny, cb);
375 code = GET_CODE (x);
376 /* Rtx's of different codes cannot be equal. */
377 if (code != GET_CODE (y))
378 return 0;
380 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
381 (REG:SI x) and (REG:HI x) are NOT equivalent. */
383 if (GET_MODE (x) != GET_MODE (y))
384 return 0;
386 /* MEMs refering to different address space are not equivalent. */
387 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
388 return 0;
390 /* Some RTL can be compared nonrecursively. */
391 switch (code)
393 case REG:
394 return (REGNO (x) == REGNO (y));
396 case LABEL_REF:
397 return XEXP (x, 0) == XEXP (y, 0);
399 case SYMBOL_REF:
400 return XSTR (x, 0) == XSTR (y, 0);
402 case DEBUG_EXPR:
403 case VALUE:
404 case SCRATCH:
405 case CONST_DOUBLE:
406 case CONST_INT:
407 case CONST_FIXED:
408 return 0;
410 default:
411 break;
414 /* Compare the elements. If any pair of corresponding elements
415 fail to match, return 0 for the whole thing. */
417 fmt = GET_RTX_FORMAT (code);
418 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
420 switch (fmt[i])
422 case 'w':
423 if (XWINT (x, i) != XWINT (y, i))
424 return 0;
425 break;
427 case 'n':
428 case 'i':
429 if (XINT (x, i) != XINT (y, i))
430 return 0;
431 break;
433 case 'V':
434 case 'E':
435 /* Two vectors must have the same length. */
436 if (XVECLEN (x, i) != XVECLEN (y, i))
437 return 0;
439 /* And the corresponding elements must match. */
440 for (j = 0; j < XVECLEN (x, i); j++)
441 if (rtx_equal_p_cb (XVECEXP (x, i, j),
442 XVECEXP (y, i, j), cb) == 0)
443 return 0;
444 break;
446 case 'e':
447 if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
448 return 0;
449 break;
451 case 'S':
452 case 's':
453 if ((XSTR (x, i) || XSTR (y, i))
454 && (! XSTR (x, i) || ! XSTR (y, i)
455 || strcmp (XSTR (x, i), XSTR (y, i))))
456 return 0;
457 break;
459 case 'u':
460 /* These are just backpointers, so they don't matter. */
461 break;
463 case '0':
464 case 't':
465 break;
467 /* It is believed that rtx's at this level will never
468 contain anything but integers and other rtx's,
469 except for within LABEL_REFs and SYMBOL_REFs. */
470 default:
471 gcc_unreachable ();
474 return 1;
477 /* Return 1 if X and Y are identical-looking rtx's.
478 This is the Lisp function EQUAL for rtx arguments.
479 Whenever changing this function check if rtx_equal_p_cb above doesn't need
480 changing as well. */
483 rtx_equal_p (const_rtx x, const_rtx y)
485 int i;
486 int j;
487 enum rtx_code code;
488 const char *fmt;
490 if (x == y)
491 return 1;
492 if (x == 0 || y == 0)
493 return 0;
495 code = GET_CODE (x);
496 /* Rtx's of different codes cannot be equal. */
497 if (code != GET_CODE (y))
498 return 0;
500 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
501 (REG:SI x) and (REG:HI x) are NOT equivalent. */
503 if (GET_MODE (x) != GET_MODE (y))
504 return 0;
506 /* MEMs refering to different address space are not equivalent. */
507 if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
508 return 0;
510 /* Some RTL can be compared nonrecursively. */
511 switch (code)
513 case REG:
514 return (REGNO (x) == REGNO (y));
516 case LABEL_REF:
517 return XEXP (x, 0) == XEXP (y, 0);
519 case SYMBOL_REF:
520 return XSTR (x, 0) == XSTR (y, 0);
522 case DEBUG_EXPR:
523 case VALUE:
524 case SCRATCH:
525 case CONST_DOUBLE:
526 case CONST_INT:
527 case CONST_FIXED:
528 return 0;
530 default:
531 break;
534 /* Compare the elements. If any pair of corresponding elements
535 fail to match, return 0 for the whole thing. */
537 fmt = GET_RTX_FORMAT (code);
538 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
540 switch (fmt[i])
542 case 'w':
543 if (XWINT (x, i) != XWINT (y, i))
544 return 0;
545 break;
547 case 'n':
548 case 'i':
549 if (XINT (x, i) != XINT (y, i))
550 return 0;
551 break;
553 case 'V':
554 case 'E':
555 /* Two vectors must have the same length. */
556 if (XVECLEN (x, i) != XVECLEN (y, i))
557 return 0;
559 /* And the corresponding elements must match. */
560 for (j = 0; j < XVECLEN (x, i); j++)
561 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
562 return 0;
563 break;
565 case 'e':
566 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
567 return 0;
568 break;
570 case 'S':
571 case 's':
572 if ((XSTR (x, i) || XSTR (y, i))
573 && (! XSTR (x, i) || ! XSTR (y, i)
574 || strcmp (XSTR (x, i), XSTR (y, i))))
575 return 0;
576 break;
578 case 'u':
579 /* These are just backpointers, so they don't matter. */
580 break;
582 case '0':
583 case 't':
584 break;
586 /* It is believed that rtx's at this level will never
587 contain anything but integers and other rtx's,
588 except for within LABEL_REFs and SYMBOL_REFs. */
589 default:
590 gcc_unreachable ();
593 return 1;
596 void
597 dump_rtx_statistics (void)
599 #ifdef GATHER_STATISTICS
600 int i;
601 int total_counts = 0;
602 int total_sizes = 0;
603 fprintf (stderr, "\nRTX Kind Count Bytes\n");
604 fprintf (stderr, "---------------------------------------\n");
605 for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
606 if (rtx_alloc_counts[i])
608 fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
609 rtx_alloc_counts[i], rtx_alloc_sizes[i]);
610 total_counts += rtx_alloc_counts[i];
611 total_sizes += rtx_alloc_sizes[i];
613 if (rtvec_alloc_counts)
615 fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
616 rtvec_alloc_counts, rtvec_alloc_sizes);
617 total_counts += rtvec_alloc_counts;
618 total_sizes += rtvec_alloc_sizes;
620 fprintf (stderr, "---------------------------------------\n");
621 fprintf (stderr, "%-20s %7d %10d\n",
622 "Total", total_counts, total_sizes);
623 fprintf (stderr, "---------------------------------------\n");
624 #endif
627 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
628 void
629 rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
630 const char *func)
632 internal_error
633 ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
634 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
635 func, trim_filename (file), line);
638 void
639 rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
640 const char *func)
642 internal_error
643 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
644 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
645 func, trim_filename (file), line);
648 void
649 rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
650 int line, const char *func)
652 internal_error
653 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
654 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
655 func, trim_filename (file), line);
658 void
659 rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
660 int line, const char *func)
662 internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
663 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
664 trim_filename (file), line);
667 void
668 rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
669 const char *file, int line, const char *func)
671 internal_error
672 ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
673 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
674 func, trim_filename (file), line);
677 void
678 rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, enum machine_mode mode,
679 bool not_mode, const char *file, int line,
680 const char *func)
682 internal_error ((not_mode
683 ? ("RTL check: expected code '%s' and not mode '%s', "
684 "have code '%s' and mode '%s' in %s, at %s:%d")
685 : ("RTL check: expected code '%s' and mode '%s', "
686 "have code '%s' and mode '%s' in %s, at %s:%d")),
687 GET_RTX_NAME (code), GET_MODE_NAME (mode),
688 GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
689 func, trim_filename (file), line);
692 /* Report that line LINE of FILE tried to access the block symbol fields
693 of a non-block symbol. FUNC is the function that contains the line. */
695 void
696 rtl_check_failed_block_symbol (const char *file, int line, const char *func)
698 internal_error
699 ("RTL check: attempt to treat non-block symbol as a block symbol "
700 "in %s, at %s:%d", func, trim_filename (file), line);
703 /* XXX Maybe print the vector? */
704 void
705 rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
706 const char *func)
708 internal_error
709 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
710 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
712 #endif /* ENABLE_RTL_CHECKING */
714 #if defined ENABLE_RTL_FLAG_CHECKING
715 void
716 rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
717 int line, const char *func)
719 internal_error
720 ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
721 name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
723 #endif /* ENABLE_RTL_FLAG_CHECKING */