Subversion Repositories openrisc_2011-10-31

/* RTL reader for GCC.

   Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999, 2000, 2001, 2002,

   2003, 2004, 2005, 2007, 2008

   Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "bconfig.h"

/* Disable rtl checking; it conflicts with the iterator handling.  */

#undef ENABLE_RTL_CHECKING

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "rtl.h"

#include "obstack.h"

#include "hashtab.h"

#include "gensupport.h"

static htab_t md_constants;

/* One element in a singly-linked list of (integer, string) pairs.  */

struct map_value {

  struct map_value *next;

  int number;

  const char *string;

};

/* Maps an iterator or attribute name to a list of (integer, string) pairs.

   The integers are mode or code values; the strings are either C conditions

   or attribute values.  */

struct mapping {

  /* The name of the iterator or attribute.  */

  const char *name;

  /* The group (modes or codes) to which the iterator or attribute belongs.  */

  struct iterator_group *group;

  /* Gives a unique number to the attribute or iterator.  Numbers are

     allocated consecutively, starting at 0.  */

  int index;

  /* The list of (integer, string) pairs.  */

  struct map_value *values;

};

/* A structure for abstracting the common parts of code and mode iterators.  */

struct iterator_group {

  /* Tables of "mapping" structures, one for attributes and one for iterators.  */

  htab_t attrs, iterators;

  /* The number of "real" modes or codes (and by extension, the first

     number available for use as an iterator placeholder).  */

  int num_builtins;

  /* Treat the given string as the name of a standard mode or code and

     return its integer value.  Use the given file for error reporting.  */

  int (*find_builtin) (const char *, FILE *);

  /* Return true if the given rtx uses the given mode or code.  */

  bool (*uses_iterator_p) (rtx, int);

  /* Make the given rtx use the given mode or code.  */

  void (*apply_iterator) (rtx, int);

};

/* Associates PTR (which can be a string, etc.) with the file location

   specified by FILENAME and LINENO.  */

struct ptr_loc {

  const void *ptr;

  const char *filename;

  int lineno;

};

/* A structure used to pass data from read_rtx to apply_iterator_traverse

   via htab_traverse.  */

struct iterator_traverse_data {

  /* Instruction queue.  */

  rtx queue;

  /* Attributes seen for modes.  */

  struct map_value *mode_maps;

  /* Input file.  */

  FILE *infile;

  /* The last unknown attribute used as a mode.  */

  const char *unknown_mode_attr;

};

/* If CODE is the number of a code iterator, return a real rtx code that

   has the same format.  Return CODE otherwise.  */

#define BELLWETHER_CODE(CODE) \

  ((CODE) < NUM_RTX_CODE ? CODE : bellwether_codes[CODE - NUM_RTX_CODE])

static void fatal_with_file_and_line (FILE *, const char *, ...)

  ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;

static void fatal_expected_char (FILE *, int, int) ATTRIBUTE_NORETURN;

static int find_mode (const char *, FILE *);

static bool uses_mode_iterator_p (rtx, int);

static void apply_mode_iterator (rtx, int);

static int find_code (const char *, FILE *);

static bool uses_code_iterator_p (rtx, int);

static void apply_code_iterator (rtx, int);

static const char *apply_iterator_to_string (const char *, struct mapping *, int);

static rtx apply_iterator_to_rtx (rtx, struct mapping *, int,

                                  struct map_value *, FILE *, const char **);

static bool uses_iterator_p (rtx, struct mapping *);

static const char *add_condition_to_string (const char *, const char *);

static void add_condition_to_rtx (rtx, const char *);

static int apply_iterator_traverse (void **, void *);

static struct mapping *add_mapping (struct iterator_group *, htab_t t,

                                    const char *, FILE *);

static struct map_value **add_map_value (struct map_value **,

                                         int, const char *);

static void initialize_iterators (void);

static void read_name (char *, FILE *);

static hashval_t leading_ptr_hash (const void *);

static int leading_ptr_eq_p (const void *, const void *);

static void set_rtx_ptr_loc (const void *, const char *, int);

static const struct ptr_loc *get_rtx_ptr_loc (const void *);

static char *read_string (FILE *, int);

static char *read_quoted_string (FILE *);

static char *read_braced_string (FILE *);

static void read_escape (FILE *);

static hashval_t def_hash (const void *);

static int def_name_eq_p (const void *, const void *);

static void read_constants (FILE *infile, char *tmp_char);

static void read_conditions (FILE *infile, char *tmp_char);

static void validate_const_int (FILE *, const char *);

static int find_iterator (struct iterator_group *, const char *, FILE *);

static struct mapping *read_mapping (struct iterator_group *, htab_t, FILE *);

static void check_code_iterator (struct mapping *, FILE *);

static rtx read_rtx_1 (FILE *, struct map_value **);

static rtx read_rtx_variadic (FILE *, struct map_value **, rtx);

/* The mode and code iterator structures.  */

static struct iterator_group modes, codes;

/* Index I is the value of BELLWETHER_CODE (I + NUM_RTX_CODE).  */

static enum rtx_code *bellwether_codes;

/* Obstack used for allocating RTL strings.  */

static struct obstack string_obstack;

/* A table of ptr_locs, hashed on the PTR field.  */

static htab_t ptr_locs;

/* An obstack for the above.  Plain xmalloc is a bit heavyweight for a

   small structure like ptr_loc.  */

static struct obstack ptr_loc_obstack;

/* A hash table of triples (A, B, C), where each of A, B and C is a condition

   and A is equivalent to "B && C".  This is used to keep track of the source

   of conditions that are made up of separate rtx strings (such as the split

   condition of a define_insn_and_split).  */

static htab_t joined_conditions;

/* An obstack for allocating joined_conditions entries.  */

static struct obstack joined_conditions_obstack;

/* Subroutines of read_rtx.  */

/* The current line number for the file.  */

int read_rtx_lineno = 1;

/* The filename for error reporting.  */

const char *read_rtx_filename = "<unknown>";

static void

fatal_with_file_and_line (FILE *infile, const char *msg, ...)

{

  char context[64];

  size_t i;

  int c;

  va_list ap;

  va_start (ap, msg);

  fprintf (stderr, "%s:%d: ", read_rtx_filename, read_rtx_lineno);

  vfprintf (stderr, msg, ap);

  putc ('\n', stderr);

  /* Gather some following context.  */

  for (i = 0; i < sizeof (context)-1; ++i)

    {

      c = getc (infile);

      if (c == EOF)

        break;

      if (c == '\r' || c == '\n')

        break;

      context[i] = c;

    }

  context[i] = '\0';

  fprintf (stderr, "%s:%d: following context is `%s'\n",

           read_rtx_filename, read_rtx_lineno, context);

  va_end (ap);

  exit (1);

}

/* Dump code after printing a message.  Used when read_rtx finds

   invalid data.  */

static void

fatal_expected_char (FILE *infile, int expected_c, int actual_c)

{

  if (actual_c == EOF)

    fatal_with_file_and_line (infile, "expected character `%c', found EOF",

                              expected_c);

  else

    fatal_with_file_and_line (infile, "expected character `%c', found `%c'",

                              expected_c, actual_c);

}

/* Implementations of the iterator_group callbacks for modes.  */

static int

find_mode (const char *name, FILE *infile)

{

  int i;

  for (i = 0; i < NUM_MACHINE_MODES; i++)

    if (strcmp (GET_MODE_NAME (i), name) == 0)

      return i;

  fatal_with_file_and_line (infile, "unknown mode `%s'", name);

}

static bool

uses_mode_iterator_p (rtx x, int mode)

{

  return (int) GET_MODE (x) == mode;

}

static void

apply_mode_iterator (rtx x, int mode)

{

  PUT_MODE (x, (enum machine_mode) mode);

}

/* Implementations of the iterator_group callbacks for codes.  */

static int

find_code (const char *name, FILE *infile)

{

  int i;

  for (i = 0; i < NUM_RTX_CODE; i++)

    if (strcmp (GET_RTX_NAME (i), name) == 0)

      return i;

  fatal_with_file_and_line (infile, "unknown rtx code `%s'", name);

}

static bool

uses_code_iterator_p (rtx x, int code)

{

  return (int) GET_CODE (x) == code;

}

static void

apply_code_iterator (rtx x, int code)

{

  PUT_CODE (x, (enum rtx_code) code);

}

/* Map a code or mode attribute string P to the underlying string for

   ITERATOR and VALUE.  */

static struct map_value *

map_attr_string (const char *p, struct mapping *iterator, int value)

{

  const char *attr;

  struct mapping *m;

  struct map_value *v;

  /* If there's a "iterator:" prefix, check whether the iterator name matches.

     Set ATTR to the start of the attribute name.  */

  attr = strchr (p, ':');

  if (attr == 0)

    attr = p;

  else

    {

      if (strncmp (p, iterator->name, attr - p) != 0

          || iterator->name[attr - p] != 0)

        return 0;

      attr++;

    }

  /* Find the attribute specification.  */

  m = (struct mapping *) htab_find (iterator->group->attrs, &attr);

  if (m == 0)

    return 0;

  /* Find the attribute value for VALUE.  */

  for (v = m->values; v != 0; v = v->next)

    if (v->number == value)

      break;

  return v;

}

/* Given an attribute string used as a machine mode, return an index

   to store in the machine mode to be translated by

   apply_iterator_to_rtx.  */

static unsigned int

mode_attr_index (struct map_value **mode_maps, const char *string)

{

  char *p;

  struct map_value *mv;

  /* Copy the attribute string into permanent storage, without the

     angle brackets around it.  */

  obstack_grow0 (&string_obstack, string + 1, strlen (string) - 2);

  p = XOBFINISH (&string_obstack, char *);

  mv = XNEW (struct map_value);

  mv->number = *mode_maps == 0 ? 0 : (*mode_maps)->number + 1;

  mv->string = p;

  mv->next = *mode_maps;

  *mode_maps = mv;

  /* We return a code which we can map back into this string: the

     number of machine modes + the number of mode iterators + the index

     we just used.  */

  return MAX_MACHINE_MODE + htab_elements (modes.iterators) + mv->number;

}

/* Apply MODE_MAPS to the top level of X, expanding cases where an

   attribute is used for a mode.  ITERATOR is the current iterator we are

   expanding, and VALUE is the value to which we are expanding it.

   INFILE is used for error messages.  This sets *UNKNOWN to true if

   we find a mode attribute which has not yet been defined, and does

   not change it otherwise.  */

static void

apply_mode_maps (rtx x, struct map_value *mode_maps, struct mapping *iterator,

                 int value, FILE *infile, const char **unknown)

{

  unsigned int offset;

  int indx;

  struct map_value *pm;

  offset = MAX_MACHINE_MODE + htab_elements (modes.iterators);

  if (GET_MODE (x) < offset)

    return;

  indx = GET_MODE (x) - offset;

  for (pm = mode_maps; pm; pm = pm->next)

    {

      if (pm->number == indx)

        {

          struct map_value *v;

          v = map_attr_string (pm->string, iterator, value);

          if (v)

            PUT_MODE (x, (enum machine_mode) find_mode (v->string, infile));

          else

            *unknown = pm->string;

          return;

        }

    }

}

/* Given that ITERATOR is being expanded as VALUE, apply the appropriate

   string substitutions to STRING.  Return the new string if any changes

   were needed, otherwise return STRING itself.  */

static const char *

apply_iterator_to_string (const char *string, struct mapping *iterator, int value)

{

  char *base, *copy, *p, *start, *end;

  struct map_value *v;

  if (string == 0)

    return string;

  base = p = copy = ASTRDUP (string);

  while ((start = strchr (p, '<')) && (end = strchr (start, '>')))

    {

      p = start + 1;

      *end = 0;

      v = map_attr_string (p, iterator, value);

      *end = '>';

      if (v == 0)

        continue;

      /* Add everything between the last copied byte and the '<',

         then add in the attribute value.  */

      obstack_grow (&string_obstack, base, start - base);

      obstack_grow (&string_obstack, v->string, strlen (v->string));

      base = end + 1;

    }

  if (base != copy)

    {

      obstack_grow (&string_obstack, base, strlen (base) + 1);

      copy = XOBFINISH (&string_obstack, char *);

      copy_rtx_ptr_loc (copy, string);

      return copy;

    }

  return string;

}

/* Return a copy of ORIGINAL in which all uses of ITERATOR have been

   replaced by VALUE.  MODE_MAPS holds information about attribute

   strings used for modes.  INFILE is used for error messages.  This

   sets *UNKNOWN_MODE_ATTR to the value of an unknown mode attribute,

   and does not change it otherwise.  */

static rtx

apply_iterator_to_rtx (rtx original, struct mapping *iterator, int value,

                       struct map_value *mode_maps, FILE *infile,

                       const char **unknown_mode_attr)

{

  struct iterator_group *group;

  const char *format_ptr;

  int i, j;

  rtx x;

  enum rtx_code bellwether_code;

  if (original == 0)

    return original;

  /* Create a shallow copy of ORIGINAL.  */

  bellwether_code = BELLWETHER_CODE (GET_CODE (original));

  x = rtx_alloc (bellwether_code);

  memcpy (x, original, RTX_CODE_SIZE (bellwether_code));

  /* Change the mode or code itself.  */

  group = iterator->group;

  if (group->uses_iterator_p (x, iterator->index + group->num_builtins))

    group->apply_iterator (x, value);

  if (mode_maps)

    apply_mode_maps (x, mode_maps, iterator, value, infile, unknown_mode_attr);

  /* Change each string and recursively change each rtx.  */

  format_ptr = GET_RTX_FORMAT (bellwether_code);

  for (i = 0; format_ptr[i] != 0; i++)

    switch (format_ptr[i])

      {

      case 'T':

        XTMPL (x, i) = apply_iterator_to_string (XTMPL (x, i), iterator, value);

        break;

      case 'S':

      case 's':

        XSTR (x, i) = apply_iterator_to_string (XSTR (x, i), iterator, value);

        break;

      case 'e':

        XEXP (x, i) = apply_iterator_to_rtx (XEXP (x, i), iterator, value,

                                             mode_maps, infile,

                                             unknown_mode_attr);

        break;

      case 'V':

      case 'E':

        if (XVEC (original, i))

          {

            XVEC (x, i) = rtvec_alloc (XVECLEN (original, i));

            for (j = 0; j < XVECLEN (x, i); j++)

              XVECEXP (x, i, j) = apply_iterator_to_rtx (XVECEXP (original, i, j),

                                                         iterator, value, mode_maps,

                                                         infile,

                                                         unknown_mode_attr);

          }

        break;

      default:

        break;

      }

  return x;

}

/* Return true if X (or some subexpression of X) uses iterator ITERATOR.  */

static bool

uses_iterator_p (rtx x, struct mapping *iterator)

{

  struct iterator_group *group;

  const char *format_ptr;

  int i, j;

  if (x == 0)

    return false;

  group = iterator->group;

  if (group->uses_iterator_p (x, iterator->index + group->num_builtins))

    return true;

  format_ptr = GET_RTX_FORMAT (BELLWETHER_CODE (GET_CODE (x)));

  for (i = 0; format_ptr[i] != 0; i++)

    switch (format_ptr[i])

      {

      case 'e':

        if (uses_iterator_p (XEXP (x, i), iterator))

          return true;

        break;

      case 'V':

      case 'E':

        if (XVEC (x, i))

          for (j = 0; j < XVECLEN (x, i); j++)

            if (uses_iterator_p (XVECEXP (x, i, j), iterator))

              return true;

        break;

      default:

        break;

      }

  return false;

}

/* Return a condition that must satisfy both ORIGINAL and EXTRA.  If ORIGINAL

   has the form "&& ..." (as used in define_insn_and_splits), assume that

   EXTRA is already satisfied.  Empty strings are treated like "true".  */

static const char *

add_condition_to_string (const char *original, const char *extra)

{

  if (original != 0 && original[0] == '&' && original[1] == '&')

    return original;

  return join_c_conditions (original, extra);

}

/* Like add_condition, but applied to all conditions in rtx X.  */

static void

add_condition_to_rtx (rtx x, const char *extra)

{

  switch (GET_CODE (x))

    {

    case DEFINE_INSN:

    case DEFINE_EXPAND:

      XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);

      break;

    case DEFINE_SPLIT:

    case DEFINE_PEEPHOLE:

    case DEFINE_PEEPHOLE2:

    case DEFINE_COND_EXEC:

      XSTR (x, 1) = add_condition_to_string (XSTR (x, 1), extra);

      break;

    case DEFINE_INSN_AND_SPLIT:

      XSTR (x, 2) = add_condition_to_string (XSTR (x, 2), extra);

      XSTR (x, 4) = add_condition_to_string (XSTR (x, 4), extra);

      break;

    default:

      break;

    }

}

/* A htab_traverse callback.  Search the EXPR_LIST given by DATA

   for rtxes that use the iterator in *SLOT.  Replace each such rtx

   with a list of expansions.  */

static int

apply_iterator_traverse (void **slot, void *data)

{

  struct iterator_traverse_data *mtd = (struct iterator_traverse_data *) data;

  struct mapping *iterator;

  struct map_value *v;

  rtx elem, new_elem, original, x;

  iterator = (struct mapping *) *slot;

  for (elem = mtd->queue; elem != 0; elem = XEXP (elem, 1))

    if (uses_iterator_p (XEXP (elem, 0), iterator))

      {

        /* For each iterator we expand, we set UNKNOWN_MODE_ATTR to NULL.

           If apply_iterator_rtx finds an unknown attribute for a mode,

           it will set it to the attribute.  We want to know whether

           the attribute is unknown after we have expanded all

           possible iterators, so setting it to NULL here gives us the

           right result when the hash table traversal is complete.  */

        mtd->unknown_mode_attr = NULL;

        original = XEXP (elem, 0);

        for (v = iterator->values; v != 0; v = v->next)

          {

            x = apply_iterator_to_rtx (original, iterator, v->number,

                                       mtd->mode_maps, mtd->infile,

                                       &mtd->unknown_mode_attr);

            add_condition_to_rtx (x, v->string);

            if (v != iterator->values)

              {

                /* Insert a new EXPR_LIST node after ELEM and put the

                   new expansion there.  */

                new_elem = rtx_alloc (EXPR_LIST);

                XEXP (new_elem, 1) = XEXP (elem, 1);

                XEXP (elem, 1) = new_elem;

                elem = new_elem;

              }

            XEXP (elem, 0) = x;

          }

    }

  return 1;

}

/* Add a new "mapping" structure to hashtable TABLE.  NAME is the name

   of the mapping, GROUP is the group to which it belongs, and INFILE

   is the file that defined the mapping.  */

static struct mapping *

add_mapping (struct iterator_group *group, htab_t table,

             const char *name, FILE *infile)

{

  struct mapping *m;

  void **slot;

  m = XNEW (struct mapping);

  m->name = xstrdup (name);

  m->group = group;

  m->index = htab_elements (table);

  m->values = 0;

  slot = htab_find_slot (table, m, INSERT);

  if (*slot != 0)

    fatal_with_file_and_line (infile, "`%s' already defined", name);

  *slot = m;

  return m;

}

/* Add the pair (NUMBER, STRING) to a list of map_value structures.

   END_PTR points to the current null terminator for the list; return

   a pointer the new null terminator.  */

static struct map_value **

add_map_value (struct map_value **end_ptr, int number, const char *string)

{

  struct map_value *value;

  value = XNEW (struct map_value);

  value->next = 0;

  value->number = number;

  value->string = string;

  *end_ptr = value;

  return &value->next;