1/* RTL utility routines.
2   Copyright (C) 1987-2015 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3.  If not see
18<http://www.gnu.org/licenses/>.  */
19
20/* This file is compiled twice: once for the generator programs
21   once for the compiler.  */
22#ifdef GENERATOR_FILE
23#include "bconfig.h"
24#else
25#include "config.h"
26#endif
27
28#include "system.h"
29#include "coretypes.h"
30#include "tm.h"
31#include "ggc.h"
32#include "rtl.h"
33#ifdef GENERATOR_FILE
34# include "errors.h"
35#else
36# include "rtlhash.h"
37# include "diagnostic-core.h"
38#endif
39
40
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).  */
43
44#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   sizeof FORMAT - 1 ,
45
46const unsigned char rtx_length[NUM_RTX_CODE] = {
47#include "rtl.def"
48};
49
50#undef DEF_RTL_EXPR
51
52/* Indexed by rtx code, gives the name of that kind of rtx, as a C string.  */
53
54#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
55
56const char * const rtx_name[NUM_RTX_CODE] = {
57#include "rtl.def"		/* rtl expressions are documented here */
58};
59
60#undef DEF_RTL_EXPR
61
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.  */
65
66const 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.  */
93
94#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
95#include "rtl.def"		/* rtl expressions are defined here */
96#undef DEF_RTL_EXPR
97};
98
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.  */
101
102const 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
106};
107
108/* Indexed by rtx code, gives the size of the rtx in bytes.  */
109
110const unsigned char rtx_code_size[NUM_RTX_CODE] = {
111#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)				\
112  (((ENUM) == CONST_INT || (ENUM) == CONST_DOUBLE			\
113    || (ENUM) == CONST_FIXED || (ENUM) == CONST_WIDE_INT)		\
114   ? RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (HOST_WIDE_INT)	\
115   : RTX_HDR_SIZE + (sizeof FORMAT - 1) * sizeof (rtunion)),
116
117#include "rtl.def"
118#undef DEF_RTL_EXPR
119};
120
121/* Names for kinds of NOTEs and REG_NOTEs.  */
122
123const char * const note_insn_name[NOTE_INSN_MAX] =
124{
125#define DEF_INSN_NOTE(NAME) #NAME,
126#include "insn-notes.def"
127#undef DEF_INSN_NOTE
128};
129
130const char * const reg_note_name[REG_NOTE_MAX] =
131{
132#define DEF_REG_NOTE(NAME) #NAME,
133#include "reg-notes.def"
134#undef DEF_REG_NOTE
135};
136
137static int rtx_alloc_counts[(int) LAST_AND_UNUSED_RTX_CODE];
138static int rtx_alloc_sizes[(int) LAST_AND_UNUSED_RTX_CODE];
139static int rtvec_alloc_counts;
140static int rtvec_alloc_sizes;
141
142
143/* Allocate an rtx vector of N elements.
144   Store the length, and initialize all elements to zero.  */
145
146rtvec
147rtvec_alloc (int n)
148{
149  rtvec rt;
150
151  rt = ggc_alloc_rtvec_sized (n);
152  /* Clear out the vector.  */
153  memset (&rt->elem[0], 0, n * sizeof (rtx));
154
155  PUT_NUM_ELEM (rt, n);
156
157  if (GATHER_STATISTICS)
158    {
159      rtvec_alloc_counts++;
160      rtvec_alloc_sizes += n * sizeof (rtx);
161    }
162
163  return rt;
164}
165
166/* Create a bitwise copy of VEC.  */
167
168rtvec
169shallow_copy_rtvec (rtvec vec)
170{
171  rtvec newvec;
172  int n;
173
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;
178}
179
180/* Return the number of bytes occupied by rtx value X.  */
181
182unsigned int
183rtx_size (const_rtx x)
184{
185  if (CONST_WIDE_INT_P (x))
186    return (RTX_HDR_SIZE
187	    + sizeof (struct hwivec_def)
188	    + ((CONST_WIDE_INT_NUNITS (x) - 1)
189	       * sizeof (HOST_WIDE_INT)));
190  if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
191    return RTX_HDR_SIZE + sizeof (struct block_symbol);
192  return RTX_CODE_SIZE (GET_CODE (x));
193}
194
195/* Allocate an rtx of code CODE with EXTRA bytes in it.  The CODE is
196   stored in the rtx; all the rest is initialized to zero.  */
197
198rtx
199rtx_alloc_stat_v (RTX_CODE code MEM_STAT_DECL, int extra)
200{
201  rtx rt = ggc_alloc_rtx_def_stat (RTX_CODE_SIZE (code) + extra
202				   PASS_MEM_STAT);
203
204  /* We want to clear everything up to the FLD array.  Normally, this
205     is one int, but we don't want to assume that and it isn't very
206     portable anyway; this is.  */
207
208  memset (rt, 0, RTX_HDR_SIZE);
209  PUT_CODE (rt, code);
210
211  if (GATHER_STATISTICS)
212    {
213      rtx_alloc_counts[code]++;
214      rtx_alloc_sizes[code] += RTX_CODE_SIZE (code);
215    }
216
217  return rt;
218}
219
220/* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
221   all the rest is initialized to zero.  */
222
223rtx
224rtx_alloc_stat (RTX_CODE code MEM_STAT_DECL)
225{
226  return rtx_alloc_stat_v (code PASS_MEM_STAT, 0);
227}
228
229/* Write the wide constant X to OUTFILE.  */
230
231void
232cwi_output_hex (FILE *outfile, const_rtx x)
233{
234  int i = CWI_GET_NUM_ELEM (x);
235  gcc_assert (i > 0);
236  if (CWI_ELT (x, i - 1) == 0)
237    /* The HOST_WIDE_INT_PRINT_HEX prepends a 0x only if the val is
238       non zero.  We want all numbers to have a 0x prefix.  */
239    fprintf (outfile, "0x");
240  fprintf (outfile, HOST_WIDE_INT_PRINT_HEX, CWI_ELT (x, --i));
241  while (--i >= 0)
242    fprintf (outfile, HOST_WIDE_INT_PRINT_PADDED_HEX, CWI_ELT (x, i));
243}
244
245
246/* Return true if ORIG is a sharable CONST.  */
247
248bool
249shared_const_p (const_rtx orig)
250{
251  gcc_assert (GET_CODE (orig) == CONST);
252
253  /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
254     a LABEL_REF, it isn't sharable.  */
255  return (GET_CODE (XEXP (orig, 0)) == PLUS
256	  && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
257	  && CONST_INT_P (XEXP (XEXP (orig, 0), 1)));
258}
259
260
261/* Create a new copy of an rtx.
262   Recursively copies the operands of the rtx,
263   except for those few rtx codes that are sharable.  */
264
265rtx
266copy_rtx (rtx orig)
267{
268  rtx copy;
269  int i, j;
270  RTX_CODE code;
271  const char *format_ptr;
272
273  code = GET_CODE (orig);
274
275  switch (code)
276    {
277    case REG:
278    case DEBUG_EXPR:
279    case VALUE:
280    CASE_CONST_ANY:
281    case SYMBOL_REF:
282    case CODE_LABEL:
283    case PC:
284    case CC0:
285    case RETURN:
286    case SIMPLE_RETURN:
287    case SCRATCH:
288      /* SCRATCH must be shared because they represent distinct values.  */
289      return orig;
290    case CLOBBER:
291      /* Share clobbers of hard registers (like cc0), but do not share pseudo reg
292         clobbers or clobbers of hard registers that originated as pseudos.
293         This is needed to allow safe register renaming.  */
294      if (REG_P (XEXP (orig, 0)) && REGNO (XEXP (orig, 0)) < FIRST_PSEUDO_REGISTER
295	  && ORIGINAL_REGNO (XEXP (orig, 0)) == REGNO (XEXP (orig, 0)))
296	return orig;
297      break;
298
299    case CONST:
300      if (shared_const_p (orig))
301	return orig;
302      break;
303
304      /* A MEM with a constant address is not sharable.  The problem is that
305	 the constant address may need to be reloaded.  If the mem is shared,
306	 then reloading one copy of this mem will cause all copies to appear
307	 to have been reloaded.  */
308
309    default:
310      break;
311    }
312
313  /* Copy the various flags, fields, and other information.  We assume
314     that all fields need copying, and then clear the fields that should
315     not be copied.  That is the sensible default behavior, and forces
316     us to explicitly document why we are *not* copying a flag.  */
317  copy = shallow_copy_rtx (orig);
318
319  /* We do not copy the USED flag, which is used as a mark bit during
320     walks over the RTL.  */
321  RTX_FLAG (copy, used) = 0;
322
323  format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
324
325  for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
326    switch (*format_ptr++)
327      {
328      case 'e':
329	if (XEXP (orig, i) != NULL)
330	  XEXP (copy, i) = copy_rtx (XEXP (orig, i));
331	break;
332
333      case 'E':
334      case 'V':
335	if (XVEC (orig, i) != NULL)
336	  {
337	    XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
338	    for (j = 0; j < XVECLEN (copy, i); j++)
339	      XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
340	  }
341	break;
342
343      case 't':
344      case 'w':
345      case 'i':
346      case 's':
347      case 'S':
348      case 'T':
349      case 'u':
350      case 'B':
351      case '0':
352	/* These are left unchanged.  */
353	break;
354
355      default:
356	gcc_unreachable ();
357      }
358  return copy;
359}
360
361/* Create a new copy of an rtx.  Only copy just one level.  */
362
363rtx
364shallow_copy_rtx_stat (const_rtx orig MEM_STAT_DECL)
365{
366  const unsigned int size = rtx_size (orig);
367  rtx const copy = ggc_alloc_rtx_def_stat (size PASS_MEM_STAT);
368  return (rtx) memcpy (copy, orig, size);
369}
370
371/* Nonzero when we are generating CONCATs.  */
372int generating_concat_p;
373
374/* Nonzero when we are expanding trees to RTL.  */
375int currently_expanding_to_rtl;
376
377
378
379/* Same as rtx_equal_p, but call CB on each pair of rtx if CB is not NULL.
380   When the callback returns true, we continue with the new pair.
381   Whenever changing this function check if rtx_equal_p below doesn't need
382   changing as well.  */
383
384int
385rtx_equal_p_cb (const_rtx x, const_rtx y, rtx_equal_p_callback_function cb)
386{
387  int i;
388  int j;
389  enum rtx_code code;
390  const char *fmt;
391  rtx nx, ny;
392
393  if (x == y)
394    return 1;
395  if (x == 0 || y == 0)
396    return 0;
397
398  /* Invoke the callback first.  */
399  if (cb != NULL
400      && ((*cb) (&x, &y, &nx, &ny)))
401    return rtx_equal_p_cb (nx, ny, cb);
402
403  code = GET_CODE (x);
404  /* Rtx's of different codes cannot be equal.  */
405  if (code != GET_CODE (y))
406    return 0;
407
408  /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
409     (REG:SI x) and (REG:HI x) are NOT equivalent.  */
410
411  if (GET_MODE (x) != GET_MODE (y))
412    return 0;
413
414  /* MEMs referring to different address space are not equivalent.  */
415  if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
416    return 0;
417
418  /* Some RTL can be compared nonrecursively.  */
419  switch (code)
420    {
421    case REG:
422      return (REGNO (x) == REGNO (y));
423
424    case LABEL_REF:
425      return LABEL_REF_LABEL (x) == LABEL_REF_LABEL (y);
426
427    case SYMBOL_REF:
428      return XSTR (x, 0) == XSTR (y, 0);
429
430    case DEBUG_EXPR:
431    case VALUE:
432    case SCRATCH:
433    CASE_CONST_UNIQUE:
434      return 0;
435
436    case DEBUG_IMPLICIT_PTR:
437      return DEBUG_IMPLICIT_PTR_DECL (x)
438	     == DEBUG_IMPLICIT_PTR_DECL (y);
439
440    case DEBUG_PARAMETER_REF:
441      return DEBUG_PARAMETER_REF_DECL (x)
442	     == DEBUG_PARAMETER_REF_DECL (x);
443
444    case ENTRY_VALUE:
445      return rtx_equal_p_cb (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), cb);
446
447    default:
448      break;
449    }
450
451  /* Compare the elements.  If any pair of corresponding elements
452     fail to match, return 0 for the whole thing.  */
453
454  fmt = GET_RTX_FORMAT (code);
455  for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
456    {
457      switch (fmt[i])
458	{
459	case 'w':
460	  if (XWINT (x, i) != XWINT (y, i))
461	    return 0;
462	  break;
463
464	case 'n':
465	case 'i':
466	  if (XINT (x, i) != XINT (y, i))
467	    {
468#ifndef GENERATOR_FILE
469	      if (((code == ASM_OPERANDS && i == 6)
470		   || (code == ASM_INPUT && i == 1))
471		  && XINT (x, i) == XINT (y, i))
472		break;
473#endif
474	      return 0;
475	    }
476	  break;
477
478	case 'V':
479	case 'E':
480	  /* Two vectors must have the same length.  */
481	  if (XVECLEN (x, i) != XVECLEN (y, i))
482	    return 0;
483
484	  /* And the corresponding elements must match.  */
485	  for (j = 0; j < XVECLEN (x, i); j++)
486	    if (rtx_equal_p_cb (XVECEXP (x, i, j),
487                                XVECEXP (y, i, j), cb) == 0)
488	      return 0;
489	  break;
490
491	case 'e':
492	  if (rtx_equal_p_cb (XEXP (x, i), XEXP (y, i), cb) == 0)
493	    return 0;
494	  break;
495
496	case 'S':
497	case 's':
498	  if ((XSTR (x, i) || XSTR (y, i))
499	      && (! XSTR (x, i) || ! XSTR (y, i)
500		  || strcmp (XSTR (x, i), XSTR (y, i))))
501	    return 0;
502	  break;
503
504	case 'u':
505	  /* These are just backpointers, so they don't matter.  */
506	  break;
507
508	case '0':
509	case 't':
510	  break;
511
512	  /* It is believed that rtx's at this level will never
513	     contain anything but integers and other rtx's,
514	     except for within LABEL_REFs and SYMBOL_REFs.  */
515	default:
516	  gcc_unreachable ();
517	}
518    }
519  return 1;
520}
521
522/* Return 1 if X and Y are identical-looking rtx's.
523   This is the Lisp function EQUAL for rtx arguments.
524   Whenever changing this function check if rtx_equal_p_cb above doesn't need
525   changing as well.  */
526
527int
528rtx_equal_p (const_rtx x, const_rtx y)
529{
530  int i;
531  int j;
532  enum rtx_code code;
533  const char *fmt;
534
535  if (x == y)
536    return 1;
537  if (x == 0 || y == 0)
538    return 0;
539
540  code = GET_CODE (x);
541  /* Rtx's of different codes cannot be equal.  */
542  if (code != GET_CODE (y))
543    return 0;
544
545  /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
546     (REG:SI x) and (REG:HI x) are NOT equivalent.  */
547
548  if (GET_MODE (x) != GET_MODE (y))
549    return 0;
550
551  /* MEMs referring to different address space are not equivalent.  */
552  if (code == MEM && MEM_ADDR_SPACE (x) != MEM_ADDR_SPACE (y))
553    return 0;
554
555  /* Some RTL can be compared nonrecursively.  */
556  switch (code)
557    {
558    case REG:
559      return (REGNO (x) == REGNO (y));
560
561    case LABEL_REF:
562      return LABEL_REF_LABEL (x) == LABEL_REF_LABEL (y);
563
564    case SYMBOL_REF:
565      return XSTR (x, 0) == XSTR (y, 0);
566
567    case DEBUG_EXPR:
568    case VALUE:
569    case SCRATCH:
570    CASE_CONST_UNIQUE:
571      return 0;
572
573    case DEBUG_IMPLICIT_PTR:
574      return DEBUG_IMPLICIT_PTR_DECL (x)
575	     == DEBUG_IMPLICIT_PTR_DECL (y);
576
577    case DEBUG_PARAMETER_REF:
578      return DEBUG_PARAMETER_REF_DECL (x)
579	     == DEBUG_PARAMETER_REF_DECL (y);
580
581    case ENTRY_VALUE:
582      return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y));
583
584    default:
585      break;
586    }
587
588  /* Compare the elements.  If any pair of corresponding elements
589     fail to match, return 0 for the whole thing.  */
590
591  fmt = GET_RTX_FORMAT (code);
592  for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
593    {
594      switch (fmt[i])
595	{
596	case 'w':
597	  if (XWINT (x, i) != XWINT (y, i))
598	    return 0;
599	  break;
600
601	case 'n':
602	case 'i':
603	  if (XINT (x, i) != XINT (y, i))
604	    {
605#ifndef GENERATOR_FILE
606	      if (((code == ASM_OPERANDS && i == 6)
607		   || (code == ASM_INPUT && i == 1))
608		  && XINT (x, i) == XINT (y, i))
609		break;
610#endif
611	      return 0;
612	    }
613	  break;
614
615	case 'V':
616	case 'E':
617	  /* Two vectors must have the same length.  */
618	  if (XVECLEN (x, i) != XVECLEN (y, i))
619	    return 0;
620
621	  /* And the corresponding elements must match.  */
622	  for (j = 0; j < XVECLEN (x, i); j++)
623	    if (rtx_equal_p (XVECEXP (x, i, j),  XVECEXP (y, i, j)) == 0)
624	      return 0;
625	  break;
626
627	case 'e':
628	  if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
629	    return 0;
630	  break;
631
632	case 'S':
633	case 's':
634	  if ((XSTR (x, i) || XSTR (y, i))
635	      && (! XSTR (x, i) || ! XSTR (y, i)
636		  || strcmp (XSTR (x, i), XSTR (y, i))))
637	    return 0;
638	  break;
639
640	case 'u':
641	  /* These are just backpointers, so they don't matter.  */
642	  break;
643
644	case '0':
645	case 't':
646	  break;
647
648	  /* It is believed that rtx's at this level will never
649	     contain anything but integers and other rtx's,
650	     except for within LABEL_REFs and SYMBOL_REFs.  */
651	default:
652	  gcc_unreachable ();
653	}
654    }
655  return 1;
656}
657
658void
659dump_rtx_statistics (void)
660{
661  int i;
662  int total_counts = 0;
663  int total_sizes = 0;
664
665  if (! GATHER_STATISTICS)
666    {
667      fprintf (stderr, "No RTX statistics\n");
668      return;
669    }
670
671  fprintf (stderr, "\nRTX Kind               Count      Bytes\n");
672  fprintf (stderr, "---------------------------------------\n");
673  for (i = 0; i < LAST_AND_UNUSED_RTX_CODE; i++)
674    if (rtx_alloc_counts[i])
675      {
676        fprintf (stderr, "%-20s %7d %10d\n", GET_RTX_NAME (i),
677                 rtx_alloc_counts[i], rtx_alloc_sizes[i]);
678        total_counts += rtx_alloc_counts[i];
679        total_sizes += rtx_alloc_sizes[i];
680      }
681  if (rtvec_alloc_counts)
682    {
683      fprintf (stderr, "%-20s %7d %10d\n", "rtvec",
684               rtvec_alloc_counts, rtvec_alloc_sizes);
685      total_counts += rtvec_alloc_counts;
686      total_sizes += rtvec_alloc_sizes;
687    }
688  fprintf (stderr, "---------------------------------------\n");
689  fprintf (stderr, "%-20s %7d %10d\n",
690           "Total", total_counts, total_sizes);
691  fprintf (stderr, "---------------------------------------\n");
692}
693
694#if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
695void
696rtl_check_failed_bounds (const_rtx r, int n, const char *file, int line,
697			 const char *func)
698{
699  internal_error
700    ("RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d",
701     n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
702     func, trim_filename (file), line);
703}
704
705void
706rtl_check_failed_type1 (const_rtx r, int n, int c1, const char *file, int line,
707			const char *func)
708{
709  internal_error
710    ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
711     n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
712     func, trim_filename (file), line);
713}
714
715void
716rtl_check_failed_type2 (const_rtx r, int n, int c1, int c2, const char *file,
717			int line, const char *func)
718{
719  internal_error
720    ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
721     n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
722     func, trim_filename (file), line);
723}
724
725void
726rtl_check_failed_code1 (const_rtx r, enum rtx_code code, const char *file,
727			int line, const char *func)
728{
729  internal_error ("RTL check: expected code '%s', have '%s' in %s, at %s:%d",
730		  GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
731		  trim_filename (file), line);
732}
733
734void
735rtl_check_failed_code2 (const_rtx r, enum rtx_code code1, enum rtx_code code2,
736			const char *file, int line, const char *func)
737{
738  internal_error
739    ("RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d",
740     GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
741     func, trim_filename (file), line);
742}
743
744void
745rtl_check_failed_code_mode (const_rtx r, enum rtx_code code, machine_mode mode,
746			    bool not_mode, const char *file, int line,
747			    const char *func)
748{
749  internal_error ((not_mode
750		   ? ("RTL check: expected code '%s' and not mode '%s', "
751		      "have code '%s' and mode '%s' in %s, at %s:%d")
752		   : ("RTL check: expected code '%s' and mode '%s', "
753		      "have code '%s' and mode '%s' in %s, at %s:%d")),
754		  GET_RTX_NAME (code), GET_MODE_NAME (mode),
755		  GET_RTX_NAME (GET_CODE (r)), GET_MODE_NAME (GET_MODE (r)),
756		  func, trim_filename (file), line);
757}
758
759/* Report that line LINE of FILE tried to access the block symbol fields
760   of a non-block symbol.  FUNC is the function that contains the line.  */
761
762void
763rtl_check_failed_block_symbol (const char *file, int line, const char *func)
764{
765  internal_error
766    ("RTL check: attempt to treat non-block symbol as a block symbol "
767     "in %s, at %s:%d", func, trim_filename (file), line);
768}
769
770/* XXX Maybe print the vector?  */
771void
772cwi_check_failed_bounds (const_rtx x, int n, const char *file, int line,
773			 const char *func)
774{
775  internal_error
776    ("RTL check: access of hwi elt %d of vector with last elt %d in %s, at %s:%d",
777     n, CWI_GET_NUM_ELEM (x) - 1, func, trim_filename (file), line);
778}
779
780/* XXX Maybe print the vector?  */
781void
782rtvec_check_failed_bounds (const_rtvec r, int n, const char *file, int line,
783			   const char *func)
784{
785  internal_error
786    ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
787     n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
788}
789#endif /* ENABLE_RTL_CHECKING */
790
791#if defined ENABLE_RTL_FLAG_CHECKING
792void
793rtl_check_failed_flag (const char *name, const_rtx r, const char *file,
794		       int line, const char *func)
795{
796  internal_error
797    ("RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d",
798     name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
799}
800#endif /* ENABLE_RTL_FLAG_CHECKING */
801