gcc/rtl.c

   1 /* RTL utility routines.
   2    Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   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
  10 version.
  11
  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.
  16
  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
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "rtl.h"
  27 #include "real.h"
  28 #include "ggc.h"
  29 #include "errors.h"
  30
  31 \f
  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).  */
  34
  35 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   sizeof FORMAT - 1 ,
  36
  37 const unsigned char rtx_length[NUM_RTX_CODE] = {
  38 #include "rtl.def"
  39 };
  40
  41 #undef DEF_RTL_EXPR
  42
  43 /* Indexed by rtx code, gives the name of that kind of rtx, as a C string.  */
  44
  45 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
  46
  47 const char * const rtx_name[NUM_RTX_CODE] = {
  48 #include "rtl.def"              /* rtl expressions are documented here */
  49 };
  50
  51 #undef DEF_RTL_EXPR
  52
  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.  */
  56
  57 const char * const rtx_format[NUM_RTX_CODE] = {
  58   /* "*" undefined.
  59          can cause a warning message
  60      "0" field is unused (or used in a phase-dependent manner)
  61          prints nothing
  62      "i" an integer
  63          prints the integer
  64      "n" like "i", but prints entries from `note_insn_name'
  65      "w" an integer of width HOST_BITS_PER_WIDE_INT
  66          prints the integer
  67      "s" a pointer to a string
  68          prints the 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
  74          prints the 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.  */
  84
  85 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
  86 #include "rtl.def"              /* rtl expressions are defined here */
  87 #undef DEF_RTL_EXPR
  88 };
  89
  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.  */
  92
  93 const char rtx_class[NUM_RTX_CODE] = {
  94 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   CLASS,
  95 #include "rtl.def"              /* rtl expressions are defined here */
  96 #undef DEF_RTL_EXPR
  97 };
  98
  99 /* Names for kinds of NOTEs and REG_NOTEs.  */
 100
 101 const char * const note_insn_name[NOTE_INSN_MAX - NOTE_INSN_BIAS] =
 102 {
 103   "", "NOTE_INSN_DELETED",
 104   "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
 105   "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
 106   "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP",
 107   "NOTE_INSN_LOOP_END_TOP_COND", "NOTE_INSN_FUNCTION_END",
 108   "NOTE_INSN_PROLOGUE_END", "NOTE_INSN_EPILOGUE_BEG",
 109   "NOTE_INSN_DELETED_LABEL", "NOTE_INSN_FUNCTION_BEG",
 110   "NOTE_INSN_EH_REGION_BEG", "NOTE_INSN_EH_REGION_END",
 111   "NOTE_INSN_REPEATED_LINE_NUMBER",
 112   "NOTE_INSN_BASIC_BLOCK", "NOTE_INSN_EXPECTED_VALUE",
 113   "NOTE_INSN_PREDICTION"
 114 };
 115
 116 const char * const reg_note_name[] =
 117 {
 118   "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_EQUAL",
 119   "REG_RETVAL", "REG_LIBCALL", "REG_NONNEG",
 120   "REG_NO_CONFLICT", "REG_UNUSED", "REG_CC_SETTER", "REG_CC_USER",
 121   "REG_LABEL", "REG_DEP_ANTI", "REG_DEP_OUTPUT", "REG_BR_PROB",
 122   "REG_VALUE_PROFILE", "REG_NOALIAS", "REG_SAVE_AREA", "REG_BR_PRED",
 123   "REG_FRAME_RELATED_EXPR", "REG_EH_CONTEXT", "REG_EH_REGION",
 124   "REG_SAVE_NOTE", "REG_MAYBE_DEAD", "REG_NORETURN",
 125   "REG_NON_LOCAL_GOTO", "REG_SETJMP", "REG_ALWAYS_RETURN",
 126   "REG_VTABLE_REF"
 127 };
 128
 129 \f
 130 /* Allocate an rtx vector of N elements.
 131    Store the length, and initialize all elements to zero.  */
 132
 133 rtvec
 134 rtvec_alloc (int n)
 135 {
 136   rtvec rt;
 137
 138   rt = ggc_alloc_rtvec (n);
 139   /* clear out the vector */
 140   memset (&rt->elem[0], 0, n * sizeof (rtx));
 141
 142   PUT_NUM_ELEM (rt, n);
 143   return rt;
 144 }
 145
 146 /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
 147    all the rest is initialized to zero.  */
 148
 149 rtx
 150 rtx_alloc (RTX_CODE code)
 151 {
 152   rtx rt;
 153   int n = GET_RTX_LENGTH (code);
 154
 155   rt = ggc_alloc_rtx (n);
 156
 157   /* We want to clear everything up to the FLD array.  Normally, this
 158      is one int, but we don't want to assume that and it isn't very
 159      portable anyway; this is.  */
 160
 161   memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
 162   PUT_CODE (rt, code);
 163   return rt;
 164 }
 165
 166 \f
 167 /* Create a new copy of an rtx.
 168    Recursively copies the operands of the rtx,
 169    except for those few rtx codes that are sharable.  */
 170
 171 rtx
 172 copy_rtx (rtx orig)
 173 {
 174   rtx copy;
 175   int i, j;
 176   RTX_CODE code;
 177   const char *format_ptr;
 178
 179   code = GET_CODE (orig);
 180
 181   switch (code)
 182     {
 183     case REG:
 184     case QUEUED:
 185     case CONST_INT:
 186     case CONST_DOUBLE:
 187     case CONST_VECTOR:
 188     case SYMBOL_REF:
 189     case CODE_LABEL:
 190     case PC:
 191     case CC0:
 192     case SCRATCH:
 193       /* SCRATCH must be shared because they represent distinct values.  */
 194     case ADDRESSOF:
 195       return orig;
 196
 197     case CONST:
 198       /* CONST can be shared if it contains a SYMBOL_REF.  If it contains
 199          a LABEL_REF, it isn't sharable.  */
 200       if (GET_CODE (XEXP (orig, 0)) == PLUS
 201           && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
 202           && GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
 203         return orig;
 204       break;
 205
 206       /* A MEM with a constant address is not sharable.  The problem is that
 207          the constant address may need to be reloaded.  If the mem is shared,
 208          then reloading one copy of this mem will cause all copies to appear
 209          to have been reloaded.  */
 210
 211     default:
 212       break;
 213     }
 214
 215   copy = rtx_alloc (code);
 216
 217   /* Copy the various flags, and other information.  We assume that
 218      all fields need copying, and then clear the fields that should
 219      not be copied.  That is the sensible default behavior, and forces
 220      us to explicitly document why we are *not* copying a flag.  */
 221   memcpy (copy, orig, sizeof (struct rtx_def) - sizeof (rtunion));
 222
 223   /* We do not copy the USED flag, which is used as a mark bit during
 224      walks over the RTL.  */
 225   RTX_FLAG (copy, used) = 0;
 226
 227   /* We do not copy FRAME_RELATED for INSNs.  */
 228   if (GET_RTX_CLASS (code) == 'i')
 229     RTX_FLAG (copy, frame_related) = 0;
 230   RTX_FLAG (copy, jump) = RTX_FLAG (orig, jump);
 231   RTX_FLAG (copy, call) = RTX_FLAG (orig, call);
 232
 233   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
 234
 235   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
 236     {
 237       copy->fld[i] = orig->fld[i];
 238       switch (*format_ptr++)
 239         {
 240         case 'e':
 241           if (XEXP (orig, i) != NULL)
 242             XEXP (copy, i) = copy_rtx (XEXP (orig, i));
 243           break;
 244
 245         case 'E':
 246         case 'V':
 247           if (XVEC (orig, i) != NULL)
 248             {
 249               XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
 250               for (j = 0; j < XVECLEN (copy, i); j++)
 251                 XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
 252             }
 253           break;
 254
 255         case 't':
 256         case 'w':
 257         case 'i':
 258         case 's':
 259         case 'S':
 260         case 'T':
 261         case 'u':
 262         case 'B':
 263         case '0':
 264           /* These are left unchanged.  */
 265           break;
 266
 267         default:
 268           abort ();
 269         }
 270     }
 271   return copy;
 272 }
 273
 274 /* Create a new copy of an rtx.  Only copy just one level.  */
 275
 276 rtx
 277 shallow_copy_rtx (rtx orig)
 278 {
 279   RTX_CODE code = GET_CODE (orig);
 280   size_t n = GET_RTX_LENGTH (code);
 281   rtx copy = ggc_alloc_rtx (n);
 282
 283   memcpy (copy, orig,
 284           sizeof (struct rtx_def) + sizeof (rtunion) * (n - 1));
 285
 286   return copy;
 287 }
 288 \f
 289 /* This is 1 until after the rtl generation pass.  */
 290 int rtx_equal_function_value_matters;
 291
 292 /* Nonzero when we are generating CONCATs.  */
 293 int generating_concat_p;
 294 \f
 295 /* Return 1 if X and Y are identical-looking rtx's.
 296    This is the Lisp function EQUAL for rtx arguments.  */
 297
 298 int
 299 rtx_equal_p (rtx x, rtx y)
 300 {
 301   int i;
 302   int j;
 303   enum rtx_code code;
 304   const char *fmt;
 305
 306   if (x == y)
 307     return 1;
 308   if (x == 0 || y == 0)
 309     return 0;
 310
 311   code = GET_CODE (x);
 312   /* Rtx's of different codes cannot be equal.  */
 313   if (code != GET_CODE (y))
 314     return 0;
 315
 316   /* (MULT:SI x y) and (MULT:HI x y) are NOT equivalent.
 317      (REG:SI x) and (REG:HI x) are NOT equivalent.  */
 318
 319   if (GET_MODE (x) != GET_MODE (y))
 320     return 0;
 321
 322   /* Some RTL can be compared nonrecursively.  */
 323   switch (code)
 324     {
 325     case REG:
 326       /* Until rtl generation is complete, don't consider a reference
 327          to the return register of the current function the same as
 328          the return from a called function.  This eases the job of
 329          function integration.  Once the distinction is no longer
 330          needed, they can be considered equivalent.  */
 331       return (REGNO (x) == REGNO (y)
 332               && (! rtx_equal_function_value_matters
 333                   || REG_FUNCTION_VALUE_P (x) == REG_FUNCTION_VALUE_P (y)));
 334
 335     case LABEL_REF:
 336       return XEXP (x, 0) == XEXP (y, 0);
 337
 338     case SYMBOL_REF:
 339       return XSTR (x, 0) == XSTR (y, 0);
 340
 341     case SCRATCH:
 342     case CONST_DOUBLE:
 343     case CONST_INT:
 344     case CONST_VECTOR:
 345       return 0;
 346
 347     default:
 348       break;
 349     }
 350
 351   /* Compare the elements.  If any pair of corresponding elements
 352      fail to match, return 0 for the whole things.  */
 353
 354   fmt = GET_RTX_FORMAT (code);
 355   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 356     {
 357       switch (fmt[i])
 358         {
 359         case 'w':
 360           if (XWINT (x, i) != XWINT (y, i))
 361             return 0;
 362           break;
 363
 364         case 'n':
 365         case 'i':
 366           if (XINT (x, i) != XINT (y, i))
 367             return 0;
 368           break;
 369
 370         case 'V':
 371         case 'E':
 372           /* Two vectors must have the same length.  */
 373           if (XVECLEN (x, i) != XVECLEN (y, i))
 374             return 0;
 375
 376           /* And the corresponding elements must match.  */
 377           for (j = 0; j < XVECLEN (x, i); j++)
 378             if (rtx_equal_p (XVECEXP (x, i, j), XVECEXP (y, i, j)) == 0)
 379               return 0;
 380           break;
 381
 382         case 'e':
 383           if (rtx_equal_p (XEXP (x, i), XEXP (y, i)) == 0)
 384             return 0;
 385           break;
 386
 387         case 'S':
 388         case 's':
 389           if ((XSTR (x, i) || XSTR (y, i))
 390               && (! XSTR (x, i) || ! XSTR (y, i)
 391                   || strcmp (XSTR (x, i), XSTR (y, i))))
 392             return 0;
 393           break;
 394
 395         case 'u':
 396           /* These are just backpointers, so they don't matter.  */
 397           break;
 398
 399         case '0':
 400         case 't':
 401           break;
 402
 403           /* It is believed that rtx's at this level will never
 404              contain anything but integers and other rtx's,
 405              except for within LABEL_REFs and SYMBOL_REFs.  */
 406         default:
 407           abort ();
 408         }
 409     }
 410   return 1;
 411 }
 412 \f
 413 #if defined ENABLE_RTL_CHECKING && (GCC_VERSION >= 2007)
 414 void
 415 rtl_check_failed_bounds (rtx r, int n, const char *file, int line,
 416                          const char *func)
 417 {
 418   internal_error
 419     ("RTL check: access of elt %d of `%s' with last elt %d in %s, at %s:%d",
 420      n, GET_RTX_NAME (GET_CODE (r)), GET_RTX_LENGTH (GET_CODE (r)) - 1,
 421      func, trim_filename (file), line);
 422 }
 423
 424 void
 425 rtl_check_failed_type1 (rtx r, int n, int c1, const char *file, int line,
 426                         const char *func)
 427 {
 428   internal_error
 429     ("RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d",
 430      n, c1, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 431      func, trim_filename (file), line);
 432 }
 433
 434 void
 435 rtl_check_failed_type2 (rtx r, int n, int c1, int c2, const char *file,
 436                         int line, const char *func)
 437 {
 438   internal_error
 439     ("RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d",
 440      n, c1, c2, GET_RTX_FORMAT (GET_CODE (r))[n], GET_RTX_NAME (GET_CODE (r)),
 441      func, trim_filename (file), line);
 442 }
 443
 444 void
 445 rtl_check_failed_code1 (rtx r, enum rtx_code code, const char *file,
 446                         int line, const char *func)
 447 {
 448   internal_error ("RTL check: expected code `%s', have `%s' in %s, at %s:%d",
 449                   GET_RTX_NAME (code), GET_RTX_NAME (GET_CODE (r)), func,
 450                   trim_filename (file), line);
 451 }
 452
 453 void
 454 rtl_check_failed_code2 (rtx r, enum rtx_code code1, enum rtx_code code2,
 455                         const char *file, int line, const char *func)
 456 {
 457   internal_error
 458     ("RTL check: expected code `%s' or `%s', have `%s' in %s, at %s:%d",
 459      GET_RTX_NAME (code1), GET_RTX_NAME (code2), GET_RTX_NAME (GET_CODE (r)),
 460      func, trim_filename (file), line);
 461 }
 462
 463 /* XXX Maybe print the vector?  */
 464 void
 465 rtvec_check_failed_bounds (rtvec r, int n, const char *file, int line,
 466                            const char *func)
 467 {
 468   internal_error
 469     ("RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d",
 470      n, GET_NUM_ELEM (r) - 1, func, trim_filename (file), line);
 471 }
 472 #endif /* ENABLE_RTL_CHECKING */
 473
 474 #if defined ENABLE_RTL_FLAG_CHECKING
 475 void
 476 rtl_check_failed_flag (const char *name, rtx r, const char *file,
 477                        int line, const char *func)
 478 {
 479   internal_error
 480     ("RTL flag check: %s used with unexpected rtx code `%s' in %s, at %s:%d",
 481      name, GET_RTX_NAME (GET_CODE (r)), func, trim_filename (file), line);
 482 }
 483 #endif /* ENABLE_RTL_FLAG_CHECKING */