i386.md: Global update to use new string syntax where it will improve readability.
[gcc.git] / gcc / rtl.c
1 /* RTL utility routines.
2 Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4
5 This file is part of GNU CC.
6
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "rtl.h"
25 #include "real.h"
26 #include "ggc.h"
27
28 \f
29 /* Calculate the format for CONST_DOUBLE. This depends on the relative
30 widths of HOST_WIDE_INT and REAL_VALUE_TYPE.
31
32 We need to go out to e0wwwww, since REAL_ARITHMETIC assumes 16-bits
33 per element in REAL_VALUE_TYPE.
34
35 This is duplicated in gengenrtl.c.
36
37 A number of places assume that there are always at least two 'w'
38 slots in a CONST_DOUBLE, so we provide them even if one would suffice. */
39
40 #ifdef REAL_ARITHMETIC
41 # if MAX_LONG_DOUBLE_TYPE_SIZE == 96
42 # define REAL_WIDTH \
43 (11*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
44 # else
45 # if MAX_LONG_DOUBLE_TYPE_SIZE == 128
46 # define REAL_WIDTH \
47 (19*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
48 # else
49 # if HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
50 # define REAL_WIDTH \
51 (7*8 + HOST_BITS_PER_WIDE_INT)/HOST_BITS_PER_WIDE_INT
52 # endif
53 # endif
54 # endif
55 #endif /* REAL_ARITHMETIC */
56
57 #ifndef REAL_WIDTH
58 # if HOST_BITS_PER_WIDE_INT*2 >= MAX_LONG_DOUBLE_TYPE_SIZE
59 # define REAL_WIDTH 2
60 # else
61 # if HOST_BITS_PER_WIDE_INT*3 >= MAX_LONG_DOUBLE_TYPE_SIZE
62 # define REAL_WIDTH 3
63 # else
64 # if HOST_BITS_PER_WIDE_INT*4 >= MAX_LONG_DOUBLE_TYPE_SIZE
65 # define REAL_WIDTH 4
66 # endif
67 # endif
68 # endif
69 #endif /* REAL_WIDTH */
70
71 #if REAL_WIDTH == 1
72 # define CONST_DOUBLE_FORMAT "e0ww"
73 #else
74 # if REAL_WIDTH == 2
75 # define CONST_DOUBLE_FORMAT "e0ww"
76 # else
77 # if REAL_WIDTH == 3
78 # define CONST_DOUBLE_FORMAT "e0www"
79 # else
80 # if REAL_WIDTH == 4
81 # define CONST_DOUBLE_FORMAT "e0wwww"
82 # else
83 # if REAL_WIDTH == 5
84 # define CONST_DOUBLE_FORMAT "e0wwwww"
85 # else
86 # define CONST_DOUBLE_FORMAT /* nothing - will cause syntax error */
87 # endif
88 # endif
89 # endif
90 # endif
91 #endif
92
93 /* Indexed by rtx code, gives number of operands for an rtx with that code.
94 Does NOT include rtx header data (code and links). */
95
96 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) sizeof FORMAT - 1 ,
97
98 const int rtx_length[NUM_RTX_CODE + 1] = {
99 #include "rtl.def"
100 };
101
102 #undef DEF_RTL_EXPR
103
104 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string. */
105
106 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
107
108 const char * const rtx_name[] = {
109 #include "rtl.def" /* rtl expressions are documented here */
110 };
111
112 #undef DEF_RTL_EXPR
113
114 /* Indexed by machine mode, gives the name of that machine mode.
115 This name does not include the letters "mode". */
116
117 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) NAME,
118
119 const char * const mode_name[(int) MAX_MACHINE_MODE + 1] = {
120 #include "machmode.def"
121 /* Add an extra field to avoid a core dump if someone tries to convert
122 MAX_MACHINE_MODE to a string. */
123 ""
124 };
125
126 #undef DEF_MACHMODE
127
128 /* Indexed by machine mode, gives the class mode for GET_MODE_CLASS. */
129
130 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) CLASS,
131
132 const enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
133 #include "machmode.def"
134 };
135
136 #undef DEF_MACHMODE
137
138 /* Indexed by machine mode, gives the length of the mode, in bits.
139 GET_MODE_BITSIZE uses this. */
140
141 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) BITSIZE,
142
143 const unsigned int mode_bitsize[(int) MAX_MACHINE_MODE] = {
144 #include "machmode.def"
145 };
146
147 #undef DEF_MACHMODE
148
149 /* Indexed by machine mode, gives the length of the mode, in bytes.
150 GET_MODE_SIZE uses this. */
151
152 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) SIZE,
153
154 const unsigned int mode_size[(int) MAX_MACHINE_MODE] = {
155 #include "machmode.def"
156 };
157
158 #undef DEF_MACHMODE
159
160 /* Indexed by machine mode, gives the length of the mode's subunit.
161 GET_MODE_UNIT_SIZE uses this. */
162
163 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) UNIT,
164
165 const unsigned int mode_unit_size[(int) MAX_MACHINE_MODE] = {
166 #include "machmode.def" /* machine modes are documented here */
167 };
168
169 #undef DEF_MACHMODE
170
171 /* Indexed by machine mode, gives next wider natural mode
172 (QI -> HI -> SI -> DI, etc.) Widening multiply instructions
173 use this. */
174
175 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) \
176 (unsigned char) WIDER,
177
178 const unsigned char mode_wider_mode[(int) MAX_MACHINE_MODE] = {
179 #include "machmode.def" /* machine modes are documented here */
180 };
181
182 #undef DEF_MACHMODE
183
184 #define DEF_MACHMODE(SYM, NAME, CLASS, BITSIZE, SIZE, UNIT, WIDER) \
185 ((BITSIZE) >= HOST_BITS_PER_WIDE_INT) ? ~(unsigned HOST_WIDE_INT)0 : ((unsigned HOST_WIDE_INT) 1 << (BITSIZE)) - 1,
186
187 /* Indexed by machine mode, gives mask of significant bits in mode. */
188
189 const unsigned HOST_WIDE_INT mode_mask_array[(int) MAX_MACHINE_MODE] = {
190 #include "machmode.def"
191 };
192
193 /* Indexed by mode class, gives the narrowest mode for each class.
194 The Q modes are always of width 1 (2 for complex) - it is impossible
195 for any mode to be narrower.
196
197 Note that we use QImode instead of BImode for MODE_INT, since
198 otherwise the middle end will try to use it for bitfields in
199 structures and the like, which we do not want. Only the target
200 md file should generate BImode widgets. */
201
202 const enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS] = {
203 /* MODE_RANDOM */ VOIDmode,
204 /* MODE_INT */ QImode,
205 /* MODE_FLOAT */ QFmode,
206 /* MODE_PARTIAL_INT */ PQImode,
207 /* MODE_CC */ CCmode,
208 /* MODE_COMPLEX_INT */ CQImode,
209 /* MODE_COMPLEX_FLOAT */ QCmode,
210 /* MODE_VECTOR_INT */ V2QImode,
211 /* MODE_VECTOR_FLOAT */ V2SFmode
212 };
213
214
215 /* Indexed by rtx code, gives a sequence of operand-types for
216 rtx's of that code. The sequence is a C string in which
217 each character describes one operand. */
218
219 const char * const rtx_format[] = {
220 /* "*" undefined.
221 can cause a warning message
222 "0" field is unused (or used in a phase-dependent manner)
223 prints nothing
224 "i" an integer
225 prints the integer
226 "n" like "i", but prints entries from `note_insn_name'
227 "w" an integer of width HOST_BITS_PER_WIDE_INT
228 prints the integer
229 "s" a pointer to a string
230 prints the string
231 "S" like "s", but optional:
232 the containing rtx may end before this operand
233 "e" a pointer to an rtl expression
234 prints the expression
235 "E" a pointer to a vector that points to a number of rtl expressions
236 prints a list of the rtl expressions
237 "V" like "E", but optional:
238 the containing rtx may end before this operand
239 "u" a pointer to another insn
240 prints the uid of the insn.
241 "b" is a pointer to a bitmap header.
242 "t" is a tree pointer. */
243
244 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
245 #include "rtl.def" /* rtl expressions are defined here */
246 #undef DEF_RTL_EXPR
247 };
248
249 /* Indexed by rtx code, gives a character representing the "class" of
250 that rtx code. See rtl.def for documentation on the defined classes. */
251
252 const char rtx_class[] = {
253 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) CLASS,
254 #include "rtl.def" /* rtl expressions are defined here */
255 #undef DEF_RTL_EXPR
256 };
257
258 /* Names for kinds of NOTEs and REG_NOTEs. */
259
260 const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] =
261 {
262 "", "NOTE_INSN_DELETED",
263 "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
264 "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
265 "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
266 "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
267 "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
268 "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
269 "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
270 "NOTE_INSN_REPEATED_LINE_NUMBER", "NOTE_INSN_RANGE_BEG",
271 "NOTE_INSN_RANGE_END", "NOTE_INSN_LIVE",
272 "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE"
273 };
274
275 const char * const reg_note_name[] =
276 {
277 "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
278 "REG_WAS_0", "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
279 "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
280 "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
281 "REG_EXEC_COUNT", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
282 "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
283 "REG_EH_RETHROW", "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
284 "REG_NON_LOCAL_GOTO"
285 };
286
287 \f
288 /* Allocate an rtx vector of N elements.
289 Store the length, and initialize all elements to zero. */
290
291 rtvec
292 rtvec_alloc (n)
293 int n;
294 {
295 rtvec rt;
296
297 rt = ggc_alloc_rtvec (n);
298 /* clear out the vector */
299 memset (&rt->elem[0], 0, n * sizeof (rtx));
300
301 PUT_NUM_ELEM (rt, n);
302 return rt;
303 }
304
305 /* Allocate an rtx of code CODE. The CODE is stored in the rtx;
306 all the rest is initialized to zero. */
307
308 rtx
309 rtx_alloc (code)
310 RTX_CODE code;
311 {
312 rtx rt;
313 int n = GET_RTX_LENGTH (code);
314
315 rt = ggc_alloc_rtx (n);
316
317 /* We want to clear everything up to the FLD array. Normally, this
318 is one int, but we don't want to assume that and it isn't very
319 portable anyway; this is. */
320
321 memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
322 PUT_CODE (rt, code);
323 return rt;
324 }
325
326 \f
327 /* Create a new copy of an rtx.
328 Recursively copies the operands of the rtx,
329 except for those few rtx codes that are sharable. */
330
331 rtx
332 copy_rtx (orig)
333 register rtx orig;
334 {
335 register rtx copy;
336 register int i, j;
337 register RTX_CODE code;
338 register const char *format_ptr;
339
340 code = GET_CODE (orig);
341
342 switch (code)
343 {
344 case REG:
345 case QUEUED:
346 case CONST_INT:
347 case CONST_DOUBLE:
348 case SYMBOL_REF:
349 case CODE_LABEL:
350 case PC:
351 case CC0:
352 case SCRATCH:
353 /* SCRATCH must be shared because they represent distinct values. */
354 case ADDRESSOF:
355 return orig;
356
357 case CONST:
358 /* CONST can be shared if it contains a SYMBOL_REF. If it contains
359 a LABEL_REF, it isn't sharable. */
360 if (GET_CODE (XEXP (orig, 0)) == PLUS
361 && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
362 && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
363 return orig;
364 break;
365
366 /* A MEM with a constant address is not sharable. The problem is that
367 the constant address may need to be reloaded. If the mem is shared,
368 then reloading one copy of this mem will cause all copies to appear
369 to have been reloaded. */
370
371 default:
372 break;
373 }
374
375 copy = rtx_alloc (code);
376
377 /* Copy the various flags, and other information. We assume that
378 all fields need copying, and then clear the fields that should
379 not be copied. That is the sensible default behavior, and forces
380 us to explicitly document why we are *not* copying a flag. */
381 memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
382
383 /* We do not copy the USED flag, which is used as a mark bit during
384 walks over the RTL. */
385 copy->used = 0;
386
387 /* We do not copy FRAME_RELATED for INSNs. */
388 if (GET_RTX_CLASS (code) == 'i')
389 copy->frame_related = 0;
390 copy->jump = orig->jump;
391 copy->call = orig->call;
392
393 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
394
395 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
396 {
397 copy->fld[i] = orig->fld[i];
398 switch (*format_ptr++)
399 {
400 case 'e':
401 if (XEXP (orig, i) != NULL)
402 XEXP (copy, i) = copy_rtx (XEXP (orig, i));
403 break;
404
405 case 'E':
406 case 'V':
407 if (XVEC (orig, i) != NULL)
408 {
409 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
410 for (j = 0; j < XVECLEN (copy, i); j++)
411 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
412 }
413 break;
414
415 case 't':
416 case 'w':
417 case 'i':
418 case 's':
419 case 'S':
420 case 'u':
421 case '0':
422 /* These are left unchanged. */
423 break;
424
425 default:
426 abort ();
427 }
428 }
429 return copy;
430 }
431
432 /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
433 placed in the result directly, rather than being copied. */
434
435 rtx
436 copy_most_rtx (orig, may_share)
437 register rtx orig;
438 register rtx may_share;
439 {
440 register rtx copy;
441 register int i, j;
442 register RTX_CODE code;
443 register const char *format_ptr;
444
445 if (orig == may_share)
446 return orig;
447
448 code = GET_CODE (orig);
449
450 switch (code)
451 {
452 case REG:
453 case QUEUED:
454 case CONST_INT:
455 case CONST_DOUBLE:
456 case SYMBOL_REF:
457 case CODE_LABEL:
458 case PC:
459 case CC0:
460 return orig;
461 default:
462 break;
463 }
464
465 copy = rtx_alloc (code);
466 PUT_MODE (copy, GET_MODE (orig));
467 copy->in_struct = orig->in_struct;
468 copy->volatil = orig->volatil;
469 copy->unchanging = orig->unchanging;
470 copy->integrated = orig->integrated;
471 copy->frame_related = orig->frame_related;
472
473 format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
474
475 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
476 {
477 switch (*format_ptr++)
478 {
479 case 'e':
480 XEXP (copy, i) = XEXP (orig, i);
481 if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
482 XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
483 break;
484
485 case 'u':
486 XEXP (copy, i) = XEXP (orig, i);
487 break;
488
489 case 'E':
490 case 'V':
491 XVEC (copy, i) = XVEC (orig, i);
492 if (XVEC (orig, i) != NULL)
493 {
494 XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
495 for (j = 0; j < XVECLEN (copy, i); j++)
496 XVECEXP (copy, i, j)
497 = copy_most_rtx (XVECEXP (orig, i, j), may_share);
498 }
499 break;
500
501 case 'w':
502 XWINT (copy, i) = XWINT (orig, i);
503 break;
504
505 case 'n':
506 case 'i':
507 XINT (copy, i) = XINT (orig, i);
508 break;
509
510 case 't':
511 XTREE (copy, i) = XTREE (orig, i);
512 break;
513
514 case 's':
515 case 'S':
516 XSTR (copy, i) = XSTR (orig, i);
517 break;
518
519 case '0':
520 /* Copy this through the wide int field; that's safest. */
521 X0WINT (copy, i) = X0WINT (orig, i);
522 break;
523
524 default:
525 abort ();
526 }
527 }
528 return copy;
529 }
530
531 /* Create a new copy of an rtx. Only copy just one level. */
532 rtx
533 shallow_copy_rtx (orig)
534 rtx orig;
535 {
536 register int i;
537 register RTX_CODE code = GET_CODE (orig);
538 register rtx copy = rtx_alloc (code);
539
540 PUT_MODE (copy, GET_MODE (orig));
541 copy->in_struct = orig->in_struct;
542 copy->volatil = orig->volatil;
543 copy->unchanging = orig->unchanging;
544 copy->integrated = orig->integrated;
545 copy->frame_related = orig->frame_related;
546
547 for (i = 0; i < GET_RTX_LENGTH (code); i++)
548 copy->fld[i] = orig->fld[i];
549
550 return copy;
551 }
552 \f
553 /* This is 1 until after the rtl generation pass. */
554 int rtx_equal_function_value_matters;
555
556 /* Nonzero when we are generating CONCATs. */
557 int generating_concat_p;
558 \f
559 /* Return 1 if X and Y are identical-looking rtx's.
560 This is the Lisp function EQUAL for rtx arguments. */
561
562 int
563 rtx_equal_p (x, y)
564 rtx x, y;
565 {
566 register int i;
567 register int j;
568 register enum rtx_code code;
569 register const char *fmt;
570
571 if (x == y)
572 return 1;
573 if (x == 0 || y == 0)
574 return 0;
575
576 code = GET_CODE (x);
577 /* Rtx's of different codes cannot be equal. */
578 if (code != GET_CODE (y))
579 return 0;
580
581 /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
582 (REG:SI x) and (REG:HI x) are NOT equivalent. */
583
584 if (GET_MODE (x) != GET_MODE (y))
585 return 0;
586
587 /* Some RTL can be compared nonrecursively. */
588 switch (code)
589 {
590 case REG:
591 /* Until rtl generation is complete, don't consider a reference to the
592 return register of the current function the same as the return from a
593 called function. This eases the job of function integration. Once the
594 distinction is no longer needed, they can be considered equivalent. */
595 return (REGNO (x) == REGNO (y)
596 && (! rtx_equal_function_value_matters
597 || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
598
599 case LABEL_REF:
600 return XEXP (x, 0) == XEXP (y, 0);
601
602 case SYMBOL_REF:
603 return XSTR (x, 0) == XSTR (y, 0);
604
605 case SCRATCH:
606 case CONST_DOUBLE:
607 case CONST_INT:
608 return 0;
609
610 default:
611 break;
612 }
613
614 /* Compare the elements. If any pair of corresponding elements
615 fail to match, return 0 for the whole things. */
616
617 fmt = GET_RTX_FORMAT (code);
618 for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
619 {
620 switch (fmt[i])
621 {
622 case 'w':
623 if (XWINT (x, i) != XWINT (y, i))
624 return 0;
625 break;
626
627 case 'n':
628 case 'i':
629 if (XINT (x, i) != XINT (y, i))
630 return 0;
631 break;
632
633 case 'V':
634 case 'E':
635 /* Two vectors must have the same length. */
636 if (XVECLEN (x, i) != XVECLEN (y, i))
637 return 0;
638
639 /* And the corresponding elements must match. */
640 for (j = 0; j < XVECLEN (x, i); j++)
641 if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
642 return 0;
643 break;
644
645 case 'e':
646 if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
647 return 0;
648 break;
649
650 case 'S':
651 case 's':
652 if (strcmp (XSTR (x, i), XSTR (y, i)))
653 return 0;
654 break;
655
656 case 'u':
657 /* These are just backpointers, so they don't matter. */
658 break;
659
660 case '0':
661 case 't':
662 break;
663
664 /* It is believed that rtx's at this level will never
665 contain anything but integers and other rtx's,
666 except for within LABEL_REFs and SYMBOL_REFs. */
667 default:
668 abort ();
669 }
670 }
671 return 1;
672 }
673 \f
674 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
675 void
676 rtl_check_failed_bounds (r, n, file, line, func)
677 rtx r;
678 int n;
679 const char *file;
680 int line;
681 const char *func;
682 {
683 internal_error
684 ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
685 n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
686 func, trim_filename (file), line);
687 }
688
689 void
690 rtl_check_failed_type1 (r, n, c1, file, line, func)
691 rtx r;
692 int n;
693 int c1;
694 const char *file;
695 int line;
696 const char *func;
697 {
698 internal_error
699 ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
700 n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
701 func, trim_filename (file), line);
702 }
703
704 void
705 rtl_check_failed_type2 (r, n, c1, c2, file, line, func)
706 rtx r;
707 int n;
708 int c1;
709 int c2;
710 const char *file;
711 int line;
712 const char *func;
713 {
714 internal_error
715 ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
716 n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
717 func, trim_filename (file), line);
718 }
719
720 void
721 rtl_check_failed_code1 (r, code, file, line, func)
722 rtx r;
723 enum rtx_code code;
724 const char *file;
725 int line;
726 const char *func;
727 {
728 internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
729 GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
730 trim_filename (file), line);
731 }
732
733 void
734 rtl_check_failed_code2 (r, code1, code2, file, line, func)
735 rtx r;
736 enum rtx_code code1, code2;
737 const char *file;
738 int line;
739 const char *func;
740 {
741 internal_error
742 ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
743 GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
744 func, trim_filename (file), line);
745 }
746
747 /* XXX Maybe print the vector? */
748 void
749 rtvec_check_failed_bounds (r, n, file, line, func)
750 rtvec r;
751 int n;
752 const char *file;
753 int line;
754 const char *func;
755 {
756 internal_error
757 ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
758 n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
759 }
760 #endif /* ENABLE_RTL_CHECKING */