1 /* RTL utility routines.
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004 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 2, or (at your option) any later
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
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
32 /* Indexed by rtx code, gives number of operands for an rtx with that code.
33 Does NOT include rtx header data (code and links). */
35 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
37 const unsigned char rtx_length
[NUM_RTX_CODE
] = {
43 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
45 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
47 const char * const rtx_name
[NUM_RTX_CODE
] = {
48 #include "rtl.def" /* rtl expressions are documented here */
53 /* Indexed by rtx code, gives a sequence of operand-types for
54 rtx's of that code. The sequence is a C string in which
55 each character describes one operand. */
57 const char * const rtx_format
[NUM_RTX_CODE
] = {
59 can cause a warning message
60 "0" field is unused (or used in a phase-dependent manner)
64 "n" like "i", but prints entries from `note_insn_name'
65 "w" an integer of width HOST_BITS_PER_WIDE_INT
67 "s" a pointer to a string
69 "S" like "s", but optional:
70 the containing rtx may end before this operand
71 "T" like "s", but treated specially by the RTL reader;
72 only found in machine description patterns.
73 "e" a pointer to an rtl expression
75 "E" a pointer to a vector that points to a number of rtl expressions
76 prints a list of the rtl expressions
77 "V" like "E", but optional:
78 the containing rtx may end before this operand
79 "u" a pointer to another insn
80 prints the uid of the insn.
81 "b" is a pointer to a bitmap header.
82 "B" is a basic block pointer.
83 "t" is a tree pointer. */
85 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
86 #include "rtl.def" /* rtl expressions are defined here */
90 /* Indexed by rtx code, gives a character representing the "class" of
91 that rtx code. See rtl.def for documentation on the defined classes. */
93 const enum rtx_class rtx_class
[NUM_RTX_CODE
] = {
94 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
95 #include "rtl.def" /* rtl expressions are defined here */
99 /* Indexed by rtx code, gives the size of the rtx in bytes. */
101 const unsigned char rtx_size
[NUM_RTX_CODE
] = {
102 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) \
103 ((ENUM) == CONST_INT || (ENUM) == CONST_DOUBLE \
104 ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT) \
105 : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
111 /* Names for kinds of NOTEs and REG_NOTEs. */
113 const char * const note_insn_name
[NOTE_INSN_MAX
- NOTE_INSN_BIAS
] =
115 "", "NOTE_INSN_DELETED",
116 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
117 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
118 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
119 "NOTE_INSN_LOOP_END_TOP_COND", "NOTE_INSN_FUNCTION_END",
120 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
121 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
122 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
123 "NOTE_INSN_REPEATED_LINE_NUMBER",
124 "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE",
125 "NOTE_INSN_UNLIKELY_EXECUTED_CODE",
126 "NOTE_INSN_VAR_LOCATION"
129 const char * const reg_note_name
[] =
131 "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
132 "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
133 "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
134 "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
135 "REG_VALUE_PROFILE", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
136 "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
137 "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
138 "REG_NON_LOCAL_GOTO", "REG_CROSSING_JUMP", "REG_SETJMP", "REG_ALWAYS_RETURN"
142 #ifdef GATHER_STATISTICS
143 static int rtx_alloc_counts
[(int) LAST_AND_UNUSED_RTX_CODE
];
144 static int rtx_alloc_sizes
[(int) LAST_AND_UNUSED_RTX_CODE
];
145 static int rtvec_alloc_counts
;
146 static int rtvec_alloc_sizes
;
150 /* Allocate an rtx vector of N elements.
151 Store the length, and initialize all elements to zero. */
158 rt
= ggc_alloc_rtvec (n
);
159 /* Clear out the vector. */
160 memset (&rt
->elem
[0], 0, n
* sizeof (rtx
));
162 PUT_NUM_ELEM (rt
, n
);
164 #ifdef GATHER_STATISTICS
165 rtvec_alloc_counts
++;
166 rtvec_alloc_sizes
+= n
* sizeof (rtx
);
172 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
173 all the rest is initialized to zero. */
176 rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL
)
180 rt
= (rtx
) ggc_alloc_typed_stat (gt_ggc_e_7rtx_def
,
181 RTX_SIZE (code
) PASS_MEM_STAT
);
183 /* We want to clear everything up to the FLD array. Normally, this
184 is one int, but we don't want to assume that and it isn't very
185 portable anyway; this is. */
187 memset (rt
, 0, RTX_HDR_SIZE
);
190 #ifdef GATHER_STATISTICS
191 rtx_alloc_counts
[code
]++;
192 rtx_alloc_sizes
[code
] += RTX_SIZE (code
);
199 /* Create a new copy of an rtx.
200 Recursively copies the operands of the rtx,
201 except for those few rtx codes that are sharable. */
209 const char *format_ptr
;
211 code
= GET_CODE (orig
);
224 /* SCRATCH must be shared because they represent distinct values. */
227 if (REG_P (XEXP (orig
, 0)) && REGNO (XEXP (orig
, 0)) < FIRST_PSEUDO_REGISTER
)
232 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
233 a LABEL_REF, it isn't sharable. */
234 if (GET_CODE (XEXP (orig
, 0)) == PLUS
235 && GET_CODE (XEXP (XEXP (orig
, 0), 0)) == SYMBOL_REF
236 && GET_CODE (XEXP (XEXP (orig
, 0), 1)) == CONST_INT
)
240 /* A MEM with a constant address is not sharable. The problem is that
241 the constant address may need to be reloaded. If the mem is shared,
242 then reloading one copy of this mem will cause all copies to appear
243 to have been reloaded. */
249 copy
= rtx_alloc (code
);
251 /* Copy the various flags, and other information. We assume that
252 all fields need copying, and then clear the fields that should
253 not be copied. That is the sensible default behavior, and forces
254 us to explicitly document why we are *not* copying a flag. */
255 memcpy (copy
, orig
, RTX_HDR_SIZE
);
257 /* We do not copy the USED flag, which is used as a mark bit during
258 walks over the RTL. */
259 RTX_FLAG (copy
, used
) = 0;
261 /* We do not copy FRAME_RELATED for INSNs. */
263 RTX_FLAG (copy
, frame_related
) = 0;
264 RTX_FLAG (copy
, jump
) = RTX_FLAG (orig
, jump
);
265 RTX_FLAG (copy
, call
) = RTX_FLAG (orig
, call
);
267 format_ptr
= GET_RTX_FORMAT (GET_CODE (copy
));
269 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (copy
)); i
++)
271 copy
->u
.fld
[i
] = orig
->u
.fld
[i
];
272 switch (*format_ptr
++)
275 if (XEXP (orig
, i
) != NULL
)
276 XEXP (copy
, i
) = copy_rtx (XEXP (orig
, i
));
281 if (XVEC (orig
, i
) != NULL
)
283 XVEC (copy
, i
) = rtvec_alloc (XVECLEN (orig
, i
));
284 for (j
= 0; j
< XVECLEN (copy
, i
); j
++)
285 XVECEXP (copy
, i
, j
) = copy_rtx (XVECEXP (orig
, i
, j
));
298 /* These are left unchanged. */
308 /* Create a new copy of an rtx. Only copy just one level. */
311 shallow_copy_rtx_stat (rtx orig MEM_STAT_DECL
)
315 copy
= (rtx
) ggc_alloc_typed_stat (gt_ggc_e_7rtx_def
,
316 RTX_SIZE (GET_CODE (orig
)) PASS_MEM_STAT
);
317 memcpy (copy
, orig
, RTX_SIZE (GET_CODE (orig
)));
321 /* This is 1 until after the rtl generation pass. */
322 int rtx_equal_function_value_matters
;
324 /* Nonzero when we are generating CONCATs. */
325 int generating_concat_p
;
327 /* Return 1 if X and Y are identical-looking rtx's.
328 This is the Lisp function EQUAL for rtx arguments. */
331 rtx_equal_p (rtx x
, rtx y
)
340 if (x
== 0 || y
== 0)
344 /* Rtx's of different codes cannot be equal. */
345 if (code
!= GET_CODE (y
))
348 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
349 (REG:SI x) and (REG:HI x) are NOT equivalent. */
351 if (GET_MODE (x
) != GET_MODE (y
))
354 /* Some RTL can be compared nonrecursively. */
358 /* Until rtl generation is complete, don't consider a reference
359 to the return register of the current function the same as
360 the return from a called function. This eases the job of
361 function integration. Once the distinction is no longer
362 needed, they can be considered equivalent. */
363 return (REGNO (x
) == REGNO (y
)
364 && (! rtx_equal_function_value_matters
365 || REG_FUNCTION_VALUE_P (x
) == REG_FUNCTION_VALUE_P (y
)));
368 return XEXP (x
, 0) == XEXP (y
, 0);
371 return XSTR (x
, 0) == XSTR (y
, 0);
383 /* Compare the elements. If any pair of corresponding elements
384 fail to match, return 0 for the whole thing. */
386 fmt
= GET_RTX_FORMAT (code
);
387 for (i
= GET_RTX_LENGTH (code
) - 1; i
>= 0; i
--)
392 if (XWINT (x
, i
) != XWINT (y
, i
))
398 if (XINT (x
, i
) != XINT (y
, i
))
404 /* Two vectors must have the same length. */
405 if (XVECLEN (x
, i
) != XVECLEN (y
, i
))
408 /* And the corresponding elements must match. */
409 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
410 if (rtx_equal_p (XVECEXP (x
, i
, j
), XVECEXP (y
, i
, j
)) == 0)
415 if (rtx_equal_p (XEXP (x
, i
), XEXP (y
, i
)) == 0)
421 if ((XSTR (x
, i
) || XSTR (y
, i
))
422 && (! XSTR (x
, i
) || ! XSTR (y
, i
)
423 || strcmp (XSTR (x
, i
), XSTR (y
, i
))))
428 /* These are just backpointers, so they don't matter. */
435 /* It is believed that rtx's at this level will never
436 contain anything but integers and other rtx's,
437 except for within LABEL_REFs and SYMBOL_REFs. */
445 void dump_rtx_statistics (void)
447 #ifdef GATHER_STATISTICS
449 int total_counts
= 0;
451 fprintf (stderr
, "\nRTX Kind Count Bytes\n");
452 fprintf (stderr
, "---------------------------------------\n");
453 for (i
= 0; i
< LAST_AND_UNUSED_RTX_CODE
; i
++)
454 if (rtx_alloc_counts
[i
])
456 fprintf (stderr
, "%-20s %7d %10d\n", GET_RTX_NAME (i
),
457 rtx_alloc_counts
[i
], rtx_alloc_sizes
[i
]);
458 total_counts
+= rtx_alloc_counts
[i
];
459 total_sizes
+= rtx_alloc_sizes
[i
];
461 if (rtvec_alloc_counts
)
463 fprintf (stderr
, "%-20s %7d %10d\n", "rtvec",
464 rtvec_alloc_counts
, rtvec_alloc_sizes
);
465 total_counts
+= rtvec_alloc_counts
;
466 total_sizes
+= rtvec_alloc_sizes
;
468 fprintf (stderr
, "---------------------------------------\n");
469 fprintf (stderr
, "%-20s %7d %10d\n",
470 "Total", total_counts
, total_sizes
);
471 fprintf (stderr
, "---------------------------------------\n");
475 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
477 rtl_check_failed_bounds (rtx r
, int n
, const char *file
, int line
,
481 ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
482 n
, GET_RTX_NAME (GET_CODE (r
)), GET_RTX_LENGTH (GET_CODE (r
)) - 1,
483 func
, trim_filename (file
), line
);
487 rtl_check_failed_type1 (rtx r
, int n
, int c1
, const char *file
, int line
,
491 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
492 n
, c1
, GET_RTX_FORMAT (GET_CODE (r
))[n
], GET_RTX_NAME (GET_CODE (r
)),
493 func
, trim_filename (file
), line
);
497 rtl_check_failed_type2 (rtx r
, int n
, int c1
, int c2
, const char *file
,
498 int line
, const char *func
)
501 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
502 n
, c1
, c2
, GET_RTX_FORMAT (GET_CODE (r
))[n
], GET_RTX_NAME (GET_CODE (r
)),
503 func
, trim_filename (file
), line
);
507 rtl_check_failed_code1 (rtx r
, enum rtx_code code
, const char *file
,
508 int line
, const char *func
)
510 internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
511 GET_RTX_NAME (code
), GET_RTX_NAME (GET_CODE (r
)), func
,
512 trim_filename (file
), line
);
516 rtl_check_failed_code2 (rtx r
, enum rtx_code code1
, enum rtx_code code2
,
517 const char *file
, int line
, const char *func
)
520 ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
521 GET_RTX_NAME (code1
), GET_RTX_NAME (code2
), GET_RTX_NAME (GET_CODE (r
)),
522 func
, trim_filename (file
), line
);
525 /* XXX Maybe print the vector? */
527 rtvec_check_failed_bounds (rtvec r
, int n
, const char *file
, int line
,
531 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
532 n
, GET_NUM_ELEM (r
) - 1, func
, trim_filename (file
), line
);
534 #endif /* ENABLE_RTL_CHECKING */
536 #if defined ENABLE_RTL_FLAG_CHECKING
538 rtl_check_failed_flag (const char *name
, rtx r
, const char *file
,
539 int line
, const char *func
)
542 ("RTL flag check: %s used with unexpected rtx code `%s' in %s, at %s:%d",
543 name
, GET_RTX_NAME (GET_CODE (r
)), func
, trim_filename (file
), line
);
545 #endif /* ENABLE_RTL_FLAG_CHECKING */