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