/* Support routines for the various generation passes.
- Copyright (C) 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+ 2010, 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 2, or (at your option)
+ 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
License for more details.
You should have received a copy of the GNU General Public License
- along with GCC; see the file COPYING. If not, write to the Free
- Software Foundation, 59 Temple Place - Suite 330, Boston, MA
- 02111-1307, USA. */
+ along with GCC; see the file COPYING3. If not see
+ <http://www.gnu.org/licenses/>. */
-#include "hconfig.h"
+#include "bconfig.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "rtl.h"
#include "obstack.h"
#include "errors.h"
+#include "hashtab.h"
+#include "read-md.h"
#include "gensupport.h"
+/* In case some macros used by files we include need it, define this here. */
+int target_flags;
+
+int insn_elision = 1;
+
static struct obstack obstack;
struct obstack *rtl_obstack = &obstack;
-#define obstack_chunk_alloc xmalloc
-#define obstack_chunk_free free
-
static int sequence_num;
-static int errors;
static int predicable_default;
static const char *predicable_true;
static const char *predicable_false;
+static htab_t condition_table;
+
/* We initially queue all patterns, process the define_insn and
define_cond_exec patterns, then return them one at a time. */
struct queue_elem
{
rtx data;
+ const char *filename;
int lineno;
struct queue_elem *next;
+ /* In a DEFINE_INSN that came from a DEFINE_INSN_AND_SPLIT, SPLIT
+ points to the generated DEFINE_SPLIT. */
+ struct queue_elem *split;
};
static struct queue_elem *define_attr_queue;
static struct queue_elem **define_attr_tail = &define_attr_queue;
+static struct queue_elem *define_pred_queue;
+static struct queue_elem **define_pred_tail = &define_pred_queue;
static struct queue_elem *define_insn_queue;
static struct queue_elem **define_insn_tail = &define_insn_queue;
static struct queue_elem *define_cond_exec_queue;
static struct queue_elem *other_queue;
static struct queue_elem **other_tail = &other_queue;
-static void queue_pattern PARAMS ((rtx, struct queue_elem ***, int));
-static void remove_constraints PARAMS ((rtx));
-static void process_rtx PARAMS ((rtx, int));
-
-static int is_predicable PARAMS ((struct queue_elem *));
-static void identify_predicable_attribute PARAMS ((void));
-static int n_alternatives PARAMS ((const char *));
-static void collect_insn_data PARAMS ((rtx, int *, int *));
-static rtx alter_predicate_for_insn PARAMS ((rtx, int, int, int));
-static const char *alter_test_for_insn PARAMS ((struct queue_elem *,
- struct queue_elem *));
-static char *shift_output_template PARAMS ((char *, const char *, int));
-static const char *alter_output_for_insn PARAMS ((struct queue_elem *,
- struct queue_elem *,
- int, int));
-static void process_one_cond_exec PARAMS ((struct queue_elem *));
-static void process_define_cond_exec PARAMS ((void));
+static struct queue_elem *queue_pattern (rtx, struct queue_elem ***,
+ const char *, int);
+
+static void remove_constraints (rtx);
+static void process_rtx (rtx, int);
+
+static int is_predicable (struct queue_elem *);
+static void identify_predicable_attribute (void);
+static int n_alternatives (const char *);
+static void collect_insn_data (rtx, int *, int *);
+static rtx alter_predicate_for_insn (rtx, int, int, int);
+static const char *alter_test_for_insn (struct queue_elem *,
+ struct queue_elem *);
+static char *shift_output_template (char *, const char *, int);
+static const char *alter_output_for_insn (struct queue_elem *,
+ struct queue_elem *,
+ int, int);
+static void process_one_cond_exec (struct queue_elem *);
+static void process_define_cond_exec (void);
+static void init_predicate_table (void);
+static void record_insn_name (int, const char *);
\f
-void
-message_with_line VPARAMS ((int lineno, const char *msg, ...))
-{
- VA_OPEN (ap, msg);
- VA_FIXEDARG (ap, int, lineno);
- VA_FIXEDARG (ap, const char *, msg);
+/* Make a version of gen_rtx_CONST_INT so that GEN_INT can be used in
+ the gensupport programs. */
- fprintf (stderr, "%s:%d: ", read_rtx_filename, lineno);
- vfprintf (stderr, msg, ap);
- fputc ('\n', stderr);
+rtx
+gen_rtx_CONST_INT (enum machine_mode ARG_UNUSED (mode),
+ HOST_WIDE_INT arg)
+{
+ rtx rt = rtx_alloc (CONST_INT);
- VA_CLOSE (ap);
+ XWINT (rt, 0) = arg;
+ return rt;
}
\f
-/* Queue PATTERN on LIST_TAIL. */
+/* Queue PATTERN on LIST_TAIL. Return the address of the new queue
+ element. */
-static void
-queue_pattern (pattern, list_tail, lineno)
- rtx pattern;
- struct queue_elem ***list_tail;
- int lineno;
+static struct queue_elem *
+queue_pattern (rtx pattern, struct queue_elem ***list_tail,
+ const char *filename, int lineno)
{
- struct queue_elem *e = (struct queue_elem *) xmalloc (sizeof (*e));
+ struct queue_elem *e = XNEW(struct queue_elem);
e->data = pattern;
+ e->filename = filename;
e->lineno = lineno;
e->next = NULL;
+ e->split = NULL;
**list_tail = e;
*list_tail = &e->next;
+ return e;
}
/* Recursively remove constraints from an rtx. */
static void
-remove_constraints (part)
- rtx part;
+remove_constraints (rtx part)
{
int i, j;
const char *format_ptr;
}
}
-/* Process a top level rtx in some way, queueing as appropriate. */
+/* Process a top level rtx in some way, queuing as appropriate. */
static void
-process_rtx (desc, lineno)
- rtx desc;
- int lineno;
+process_rtx (rtx desc, int lineno)
{
switch (GET_CODE (desc))
{
case DEFINE_INSN:
- queue_pattern (desc, &define_insn_tail, lineno);
+ queue_pattern (desc, &define_insn_tail, read_md_filename, lineno);
break;
case DEFINE_COND_EXEC:
- queue_pattern (desc, &define_cond_exec_tail, lineno);
+ queue_pattern (desc, &define_cond_exec_tail, read_md_filename, lineno);
break;
case DEFINE_ATTR:
- queue_pattern (desc, &define_attr_tail, lineno);
+ case DEFINE_ENUM_ATTR:
+ queue_pattern (desc, &define_attr_tail, read_md_filename, lineno);
+ break;
+
+ case DEFINE_PREDICATE:
+ case DEFINE_SPECIAL_PREDICATE:
+ case DEFINE_CONSTRAINT:
+ case DEFINE_REGISTER_CONSTRAINT:
+ case DEFINE_MEMORY_CONSTRAINT:
+ case DEFINE_ADDRESS_CONSTRAINT:
+ queue_pattern (desc, &define_pred_tail, read_md_filename, lineno);
break;
case DEFINE_INSN_AND_SPLIT:
rtx split;
rtvec attr;
int i;
+ struct queue_elem *insn_elem;
+ struct queue_elem *split_elem;
/* Create a split with values from the insn_and_split. */
split = rtx_alloc (DEFINE_SPLIT);
split_cond = XSTR (desc, 4);
if (split_cond[0] == '&' && split_cond[1] == '&')
{
- const char *insn_cond = XSTR (desc, 2);
- size_t insn_cond_len = strlen (insn_cond);
- size_t split_cond_len = strlen (split_cond);
- char *combined;
-
- combined = (char *) xmalloc (insn_cond_len + split_cond_len + 1);
- memcpy (combined, insn_cond, insn_cond_len);
- memcpy (combined + insn_cond_len, split_cond, split_cond_len + 1);
-
- split_cond = combined;
+ copy_md_ptr_loc (split_cond + 2, split_cond);
+ split_cond = join_c_conditions (XSTR (desc, 2), split_cond + 2);
}
XSTR (split, 1) = split_cond;
XVEC (split, 2) = XVEC (desc, 5);
XVEC (desc, 4) = attr;
/* Queue them. */
- queue_pattern (desc, &define_insn_tail, lineno);
- queue_pattern (split, &other_tail, lineno);
+ insn_elem
+ = queue_pattern (desc, &define_insn_tail, read_md_filename,
+ lineno);
+ split_elem
+ = queue_pattern (split, &other_tail, read_md_filename, lineno);
+ insn_elem->split = split_elem;
break;
}
default:
- queue_pattern (desc, &other_tail, lineno);
+ queue_pattern (desc, &other_tail, read_md_filename, lineno);
break;
}
}
a DEFINE_INSN. */
static int
-is_predicable (elem)
- struct queue_elem *elem;
+is_predicable (struct queue_elem *elem)
{
rtvec vec = XVEC (elem->data, 4);
const char *value;
case SET_ATTR_ALTERNATIVE:
if (strcmp (XSTR (sub, 0), "predicable") == 0)
{
- message_with_line (elem->lineno,
- "multiple alternatives for `predicable'");
- errors = 1;
+ error_with_line (elem->lineno,
+ "multiple alternatives for `predicable'");
return 0;
}
break;
/* ??? It would be possible to handle this if we really tried.
It's not easy though, and I'm not going to bother until it
really proves necessary. */
- message_with_line (elem->lineno,
- "non-constant value for `predicable'");
- errors = 1;
+ error_with_line (elem->lineno,
+ "non-constant value for `predicable'");
return 0;
default:
- abort ();
+ gcc_unreachable ();
}
}
to do this. Delay this until we've got the basics solid. */
if (strchr (value, ',') != NULL)
{
- message_with_line (elem->lineno,
- "multiple alternatives for `predicable'");
- errors = 1;
+ error_with_line (elem->lineno, "multiple alternatives for `predicable'");
return 0;
}
if (strcmp (value, predicable_false) == 0)
return 0;
- message_with_line (elem->lineno,
- "Unknown value `%s' for `predicable' attribute",
- value);
- errors = 1;
+ error_with_line (elem->lineno,
+ "unknown value `%s' for `predicable' attribute", value);
return 0;
}
and its default. */
static void
-identify_predicable_attribute ()
+identify_predicable_attribute (void)
{
struct queue_elem *elem;
char *p_true, *p_false;
const char *value;
- size_t len;
/* Look for the DEFINE_ATTR for `predicable', which must exist. */
for (elem = define_attr_queue; elem ; elem = elem->next)
if (strcmp (XSTR (elem->data, 0), "predicable") == 0)
goto found;
- message_with_line (define_cond_exec_queue->lineno,
- "Attribute `predicable' not defined");
- errors = 1;
+ error_with_line (define_cond_exec_queue->lineno,
+ "attribute `predicable' not defined");
return;
found:
value = XSTR (elem->data, 1);
- len = strlen (value);
- p_false = (char *) xmalloc (len + 1);
- memcpy (p_false, value, len + 1);
-
+ p_false = xstrdup (value);
p_true = strchr (p_false, ',');
if (p_true == NULL || strchr (++p_true, ',') != NULL)
{
- message_with_line (elem->lineno,
- "Attribute `predicable' is not a boolean");
- errors = 1;
+ error_with_line (elem->lineno, "attribute `predicable' is not a boolean");
+ if (p_false)
+ free (p_false);
return;
}
p_true[-1] = '\0';
break;
case CONST:
- message_with_line (elem->lineno,
- "Attribute `predicable' cannot be const");
- errors = 1;
+ error_with_line (elem->lineno, "attribute `predicable' cannot be const");
+ if (p_false)
+ free (p_false);
return;
default:
- message_with_line (elem->lineno,
- "Attribute `predicable' must have a constant default");
- errors = 1;
+ error_with_line (elem->lineno,
+ "attribute `predicable' must have a constant default");
+ if (p_false)
+ free (p_false);
return;
}
predicable_default = 0;
else
{
- message_with_line (elem->lineno,
- "Unknown value `%s' for `predicable' attribute",
- value);
- errors = 1;
+ error_with_line (elem->lineno,
+ "unknown value `%s' for `predicable' attribute", value);
+ if (p_false)
+ free (p_false);
}
}
/* Return the number of alternatives in constraint S. */
static int
-n_alternatives (s)
- const char *s;
+n_alternatives (const char *s)
{
int n = 1;
operands. */
static void
-collect_insn_data (pattern, palt, pmax)
- rtx pattern;
- int *palt, *pmax;
+collect_insn_data (rtx pattern, int *palt, int *pmax)
{
const char *fmt;
enum rtx_code code;
case MATCH_OPERAND:
i = n_alternatives (XSTR (pattern, 2));
*palt = (i > *palt ? i : *palt);
- /* FALLTHRU */
+ /* Fall through. */
case MATCH_OPERATOR:
case MATCH_SCRATCH:
case MATCH_PARALLEL:
- case MATCH_INSN:
i = XINT (pattern, 0);
if (i > *pmax)
*pmax = i;
case 'V':
if (XVEC (pattern, i) == NULL)
break;
- /* FALLTHRU */
+ /* Fall through. */
case 'E':
for (j = XVECLEN (pattern, i) - 1; j >= 0; --j)
collect_insn_data (XVECEXP (pattern, i, j), palt, pmax);
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
}
static rtx
-alter_predicate_for_insn (pattern, alt, max_op, lineno)
- rtx pattern;
- int alt, max_op, lineno;
+alter_predicate_for_insn (rtx pattern, int alt, int max_op, int lineno)
{
const char *fmt;
enum rtx_code code;
if (n_alternatives (c) != 1)
{
- message_with_line (lineno,
- "Too many alternatives for operand %d",
- XINT (pattern, 0));
- errors = 1;
+ error_with_line (lineno, "too many alternatives for operand %d",
+ XINT (pattern, 0));
return NULL;
}
{
size_t c_len = strlen (c);
size_t len = alt * (c_len + 1);
- char *new_c = (char *) xmalloc (len);
+ char *new_c = XNEWVEC(char, len);
memcpy (new_c, c, c_len);
for (i = 1; i < alt; ++i)
XSTR (pattern, 2) = new_c;
}
}
- /* FALLTHRU */
+ /* Fall through. */
case MATCH_OPERATOR:
case MATCH_SCRATCH:
case MATCH_PARALLEL:
- case MATCH_INSN:
XINT (pattern, 0) += max_op;
break;
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
}
static const char *
-alter_test_for_insn (ce_elem, insn_elem)
- struct queue_elem *ce_elem, *insn_elem;
+alter_test_for_insn (struct queue_elem *ce_elem,
+ struct queue_elem *insn_elem)
{
- const char *ce_test, *insn_test;
- char *new_test;
- size_t len, ce_len, insn_len;
-
- ce_test = XSTR (ce_elem->data, 1);
- insn_test = XSTR (insn_elem->data, 2);
- if (!ce_test || *ce_test == '\0')
- return insn_test;
- if (!insn_test || *insn_test == '\0')
- return ce_test;
-
- ce_len = strlen (ce_test);
- insn_len = strlen (insn_test);
- len = 1 + ce_len + 1 + 4 + 1 + insn_len + 1 + 1;
- new_test = (char *) xmalloc (len);
-
- sprintf (new_test, "(%s) && (%s)", ce_test, insn_test);
-
- return new_test;
+ return join_c_conditions (XSTR (ce_elem->data, 1),
+ XSTR (insn_elem->data, 2));
}
-/* Adjust all of the operand numbers in OLD to match the shift they'll
+/* Adjust all of the operand numbers in SRC to match the shift they'll
get from an operand displacement of DISP. Return a pointer after the
adjusted string. */
static char *
-shift_output_template (new, old, disp)
- char *new;
- const char *old;
- int disp;
+shift_output_template (char *dest, const char *src, int disp)
{
- while (*old)
+ while (*src)
{
- char c = *old++;
- *new++ = c;
+ char c = *src++;
+ *dest++ = c;
if (c == '%')
{
- c = *old++;
+ c = *src++;
if (ISDIGIT ((unsigned char) c))
c += disp;
else if (ISALPHA (c))
{
- *new++ = c;
- c = *old++ + disp;
+ *dest++ = c;
+ c = *src++ + disp;
}
- *new++ = c;
+ *dest++ = c;
}
}
- return new;
+ return dest;
}
static const char *
-alter_output_for_insn (ce_elem, insn_elem, alt, max_op)
- struct queue_elem *ce_elem, *insn_elem;
- int alt, max_op;
+alter_output_for_insn (struct queue_elem *ce_elem,
+ struct queue_elem *insn_elem,
+ int alt, int max_op)
{
const char *ce_out, *insn_out;
- char *new, *p;
+ char *result, *p;
size_t len, ce_len, insn_len;
/* ??? Could coordinate with genoutput to not duplicate code here. */
if (*insn_out == '@')
{
len = (ce_len + 1) * alt + insn_len + 1;
- p = new = xmalloc (len);
+ p = result = XNEWVEC(char, len);
do
{
else
{
len = ce_len + 1 + insn_len + 1;
- new = xmalloc (len);
+ result = XNEWVEC (char, len);
- p = shift_output_template (new, ce_out, max_op);
+ p = shift_output_template (result, ce_out, max_op);
*p++ = ' ';
memcpy (p, insn_out, insn_len + 1);
}
- return new;
+ return result;
}
/* Replicate insns as appropriate for the given DEFINE_COND_EXEC. */
static void
-process_one_cond_exec (ce_elem)
- struct queue_elem *ce_elem;
+process_one_cond_exec (struct queue_elem *ce_elem)
{
struct queue_elem *insn_elem;
for (insn_elem = define_insn_queue; insn_elem ; insn_elem = insn_elem->next)
{
int alternatives, max_operand;
- rtx pred, insn, pattern;
+ rtx pred, insn, pattern, split;
+ char *new_name;
+ int i;
if (! is_predicable (insn_elem))
continue;
if (XVECLEN (ce_elem->data, 0) != 1)
{
- message_with_line (ce_elem->lineno,
- "too many patterns in predicate");
- errors = 1;
+ error_with_line (ce_elem->lineno, "too many patterns in predicate");
return;
}
/* Construct a new pattern for the new insn. */
insn = copy_rtx (insn_elem->data);
- XSTR (insn, 0) = "";
+ new_name = XNEWVAR (char, strlen XSTR (insn_elem->data, 0) + 4);
+ sprintf (new_name, "*p %s", XSTR (insn_elem->data, 0));
+ XSTR (insn, 0) = new_name;
pattern = rtx_alloc (COND_EXEC);
XEXP (pattern, 0) = pred;
if (XVECLEN (insn, 1) == 1)
patterns into the define_insn chain just after their generator
is something we'll have to experiment with. */
- queue_pattern (insn, &other_tail, insn_elem->lineno);
+ queue_pattern (insn, &other_tail, insn_elem->filename,
+ insn_elem->lineno);
+
+ if (!insn_elem->split)
+ continue;
+
+ /* If the original insn came from a define_insn_and_split,
+ generate a new split to handle the predicated insn. */
+ split = copy_rtx (insn_elem->split->data);
+ /* Predicate the pattern matched by the split. */
+ pattern = rtx_alloc (COND_EXEC);
+ XEXP (pattern, 0) = pred;
+ if (XVECLEN (split, 0) == 1)
+ {
+ XEXP (pattern, 1) = XVECEXP (split, 0, 0);
+ XVECEXP (split, 0, 0) = pattern;
+ PUT_NUM_ELEM (XVEC (split, 0), 1);
+ }
+ else
+ {
+ XEXP (pattern, 1) = rtx_alloc (PARALLEL);
+ XVEC (XEXP (pattern, 1), 0) = XVEC (split, 0);
+ XVEC (split, 0) = rtvec_alloc (1);
+ XVECEXP (split, 0, 0) = pattern;
+ }
+ /* Predicate all of the insns generated by the split. */
+ for (i = 0; i < XVECLEN (split, 2); i++)
+ {
+ pattern = rtx_alloc (COND_EXEC);
+ XEXP (pattern, 0) = pred;
+ XEXP (pattern, 1) = XVECEXP (split, 2, i);
+ XVECEXP (split, 2, i) = pattern;
+ }
+ /* Add the new split to the queue. */
+ queue_pattern (split, &other_tail, read_md_filename,
+ insn_elem->split->lineno);
}
}
patterns appropriately. */
static void
-process_define_cond_exec ()
+process_define_cond_exec (void)
{
struct queue_elem *elem;
identify_predicable_attribute ();
- if (errors)
+ if (have_error)
return;
for (elem = define_cond_exec_queue; elem ; elem = elem->next)
process_one_cond_exec (elem);
}
\f
-/* The entry point for initializing the reader. */
+/* A read_md_files callback for reading an rtx. */
-int
-init_md_reader (filename)
- const char *filename;
+static void
+rtx_handle_directive (int lineno, const char *rtx_name)
{
- FILE *input_file;
- int c;
+ rtx queue, x;
- read_rtx_filename = filename;
- input_file = fopen (filename, "r");
- if (input_file == 0)
- {
- perror (filename);
- return FATAL_EXIT_CODE;
- }
+ if (read_rtx (rtx_name, &queue))
+ for (x = queue; x; x = XEXP (x, 1))
+ process_rtx (XEXP (x, 0), lineno);
+}
+/* The entry point for initializing the reader. */
+
+bool
+init_rtx_reader_args_cb (int argc, char **argv,
+ bool (*parse_opt) (const char *))
+{
+ /* Prepare to read input. */
+ condition_table = htab_create (500, hash_c_test, cmp_c_test, NULL);
+ init_predicate_table ();
obstack_init (rtl_obstack);
- errors = 0;
sequence_num = 0;
- /* Read the entire file. */
- while (1)
- {
- rtx desc;
- int lineno;
-
- c = read_skip_spaces (input_file);
- if (c == EOF)
- break;
-
- ungetc (c, input_file);
- lineno = read_rtx_lineno;
- desc = read_rtx (input_file);
- process_rtx (desc, lineno);
- }
- fclose (input_file);
+ read_md_files (argc, argv, parse_opt, rtx_handle_directive);
/* Process define_cond_exec patterns. */
if (define_cond_exec_queue != NULL)
process_define_cond_exec ();
- return errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
+ return !have_error;
}
+/* Programs that don't have their own options can use this entry point
+ instead. */
+bool
+init_rtx_reader_args (int argc, char **argv)
+{
+ return init_rtx_reader_args_cb (argc, argv, 0);
+}
+\f
/* The entry point for reading a single rtx from an md file. */
rtx
-read_md_rtx (lineno, seqnr)
- int *lineno;
- int *seqnr;
+read_md_rtx (int *lineno, int *seqnr)
{
struct queue_elem **queue, *elem;
rtx desc;
+ discard:
+
/* Read all patterns from a given queue before moving on to the next. */
if (define_attr_queue != NULL)
queue = &define_attr_queue;
+ else if (define_pred_queue != NULL)
+ queue = &define_pred_queue;
else if (define_insn_queue != NULL)
queue = &define_insn_queue;
else if (other_queue != NULL)
elem = *queue;
*queue = elem->next;
desc = elem->data;
+ read_md_filename = elem->filename;
*lineno = elem->lineno;
*seqnr = sequence_num;
free (elem);
+ /* Discard insn patterns which we know can never match (because
+ their C test is provably always false). If insn_elision is
+ false, our caller needs to see all the patterns. Note that the
+ elided patterns are never counted by the sequence numbering; it
+ it is the caller's responsibility, when insn_elision is false, not
+ to use elided pattern numbers for anything. */
switch (GET_CODE (desc))
{
case DEFINE_INSN:
case DEFINE_EXPAND:
+ if (maybe_eval_c_test (XSTR (desc, 2)) != 0)
+ sequence_num++;
+ else if (insn_elision)
+ goto discard;
+
+ /* *seqnr is used here so the name table will match caller's
+ idea of insn numbering, whether or not elision is active. */
+ record_insn_name (*seqnr, XSTR (desc, 0));
+ break;
+
case DEFINE_SPLIT:
case DEFINE_PEEPHOLE:
case DEFINE_PEEPHOLE2:
- sequence_num++;
+ if (maybe_eval_c_test (XSTR (desc, 1)) != 0)
+ sequence_num++;
+ else if (insn_elision)
+ goto discard;
break;
default:
return desc;
}
-/* Until we can use the versions in libiberty. */
-char *
-xstrdup (input)
- const char *input;
+/* Helper functions for insn elision. */
+
+/* Compute a hash function of a c_test structure, which is keyed
+ by its ->expr field. */
+hashval_t
+hash_c_test (const void *x)
{
- size_t len = strlen (input) + 1;
- char *output = xmalloc (len);
- memcpy (output, input, len);
- return output;
+ const struct c_test *a = (const struct c_test *) x;
+ const unsigned char *base, *s = (const unsigned char *) a->expr;
+ hashval_t hash;
+ unsigned char c;
+ unsigned int len;
+
+ base = s;
+ hash = 0;
+
+ while ((c = *s++) != '\0')
+ {
+ hash += c + (c << 17);
+ hash ^= hash >> 2;
+ }
+
+ len = s - base;
+ hash += len + (len << 17);
+ hash ^= hash >> 2;
+
+ return hash;
}
-PTR
-xcalloc (nelem, elsize)
- size_t nelem, elsize;
+/* Compare two c_test expression structures. */
+int
+cmp_c_test (const void *x, const void *y)
{
- PTR newmem;
+ const struct c_test *a = (const struct c_test *) x;
+ const struct c_test *b = (const struct c_test *) y;
- if (nelem == 0 || elsize == 0)
- nelem = elsize = 1;
+ return !strcmp (a->expr, b->expr);
+}
+
+/* Given a string representing a C test expression, look it up in the
+ condition_table and report whether or not its value is known
+ at compile time. Returns a tristate: 1 for known true, 0 for
+ known false, -1 for unknown. */
+int
+maybe_eval_c_test (const char *expr)
+{
+ const struct c_test *test;
+ struct c_test dummy;
- newmem = really_call_calloc (nelem, elsize);
- if (!newmem)
- fatal ("virtual memory exhausted");
- return (newmem);
+ if (expr[0] == 0)
+ return 1;
+
+ dummy.expr = expr;
+ test = (const struct c_test *)htab_find (condition_table, &dummy);
+ if (!test)
+ return -1;
+ return test->value;
}
-PTR
-xrealloc (old, size)
- PTR old;
- size_t size;
+/* Record the C test expression EXPR in the condition_table, with
+ value VAL. Duplicates clobber previous entries. */
+
+void
+add_c_test (const char *expr, int value)
{
- PTR ptr;
- if (old)
- ptr = (PTR) really_call_realloc (old, size);
+ struct c_test *test;
+
+ if (expr[0] == 0)
+ return;
+
+ test = XNEW (struct c_test);
+ test->expr = expr;
+ test->value = value;
+
+ *(htab_find_slot (condition_table, test, INSERT)) = test;
+}
+
+/* For every C test, call CALLBACK with two arguments: a pointer to
+ the condition structure and INFO. Stops when CALLBACK returns zero. */
+void
+traverse_c_tests (htab_trav callback, void *info)
+{
+ if (condition_table)
+ htab_traverse (condition_table, callback, info);
+}
+
+/* Helper functions for define_predicate and define_special_predicate
+ processing. Shared between genrecog.c and genpreds.c. */
+
+static htab_t predicate_table;
+struct pred_data *first_predicate;
+static struct pred_data **last_predicate = &first_predicate;
+
+static hashval_t
+hash_struct_pred_data (const void *ptr)
+{
+ return htab_hash_string (((const struct pred_data *)ptr)->name);
+}
+
+static int
+eq_struct_pred_data (const void *a, const void *b)
+{
+ return !strcmp (((const struct pred_data *)a)->name,
+ ((const struct pred_data *)b)->name);
+}
+
+struct pred_data *
+lookup_predicate (const char *name)
+{
+ struct pred_data key;
+ key.name = name;
+ return (struct pred_data *) htab_find (predicate_table, &key);
+}
+
+/* Record that predicate PRED can accept CODE. */
+
+void
+add_predicate_code (struct pred_data *pred, enum rtx_code code)
+{
+ if (!pred->codes[code])
+ {
+ pred->num_codes++;
+ pred->codes[code] = true;
+
+ if (GET_RTX_CLASS (code) != RTX_CONST_OBJ)
+ pred->allows_non_const = true;
+
+ if (code != REG
+ && code != SUBREG
+ && code != MEM
+ && code != CONCAT
+ && code != PARALLEL
+ && code != STRICT_LOW_PART)
+ pred->allows_non_lvalue = true;
+
+ if (pred->num_codes == 1)
+ pred->singleton = code;
+ else if (pred->num_codes == 2)
+ pred->singleton = UNKNOWN;
+ }
+}
+
+void
+add_predicate (struct pred_data *pred)
+{
+ void **slot = htab_find_slot (predicate_table, pred, INSERT);
+ if (*slot)
+ {
+ error ("duplicate predicate definition for '%s'", pred->name);
+ return;
+ }
+ *slot = pred;
+ *last_predicate = pred;
+ last_predicate = &pred->next;
+}
+
+/* This array gives the initial content of the predicate table. It
+ has entries for all predicates defined in recog.c. */
+
+struct std_pred_table
+{
+ const char *name;
+ bool special;
+ bool allows_const_p;
+ RTX_CODE codes[NUM_RTX_CODE];
+};
+
+static const struct std_pred_table std_preds[] = {
+ {"general_operand", false, true, {SUBREG, REG, MEM}},
+ {"address_operand", true, true, {SUBREG, REG, MEM, PLUS, MINUS, MULT}},
+ {"register_operand", false, false, {SUBREG, REG}},
+ {"pmode_register_operand", true, false, {SUBREG, REG}},
+ {"scratch_operand", false, false, {SCRATCH, REG}},
+ {"immediate_operand", false, true, {UNKNOWN}},
+ {"const_int_operand", false, false, {CONST_INT}},
+ {"const_double_operand", false, false, {CONST_INT, CONST_DOUBLE}},
+ {"nonimmediate_operand", false, false, {SUBREG, REG, MEM}},
+ {"nonmemory_operand", false, true, {SUBREG, REG}},
+ {"push_operand", false, false, {MEM}},
+ {"pop_operand", false, false, {MEM}},
+ {"memory_operand", false, false, {SUBREG, MEM}},
+ {"indirect_operand", false, false, {SUBREG, MEM}},
+ {"ordered_comparison_operator", false, false, {EQ, NE,
+ LE, LT, GE, GT,
+ LEU, LTU, GEU, GTU}},
+ {"comparison_operator", false, false, {EQ, NE,
+ LE, LT, GE, GT,
+ LEU, LTU, GEU, GTU,
+ UNORDERED, ORDERED,
+ UNEQ, UNGE, UNGT,
+ UNLE, UNLT, LTGT}}
+};
+#define NUM_KNOWN_STD_PREDS ARRAY_SIZE (std_preds)
+
+/* Initialize the table of predicate definitions, starting with
+ the information we have on generic predicates. */
+
+static void
+init_predicate_table (void)
+{
+ size_t i, j;
+ struct pred_data *pred;
+
+ predicate_table = htab_create_alloc (37, hash_struct_pred_data,
+ eq_struct_pred_data, 0,
+ xcalloc, free);
+
+ for (i = 0; i < NUM_KNOWN_STD_PREDS; i++)
+ {
+ pred = XCNEW (struct pred_data);
+ pred->name = std_preds[i].name;
+ pred->special = std_preds[i].special;
+
+ for (j = 0; std_preds[i].codes[j] != 0; j++)
+ add_predicate_code (pred, std_preds[i].codes[j]);
+
+ if (std_preds[i].allows_const_p)
+ for (j = 0; j < NUM_RTX_CODE; j++)
+ if (GET_RTX_CLASS (j) == RTX_CONST_OBJ)
+ add_predicate_code (pred, (enum rtx_code) j);
+
+ add_predicate (pred);
+ }
+}
+\f
+/* These functions allow linkage with print-rtl.c. Also, some generators
+ like to annotate their output with insn names. */
+
+/* Holds an array of names indexed by insn_code_number. */
+static char **insn_name_ptr = 0;
+static int insn_name_ptr_size = 0;
+
+const char *
+get_insn_name (int code)
+{
+ if (code < insn_name_ptr_size)
+ return insn_name_ptr[code];
else
- ptr = (PTR) really_call_malloc (size);
- if (!ptr)
- fatal ("virtual memory exhausted");
- return ptr;
+ return NULL;
}
-PTR
-xmalloc (size)
- size_t size;
+static void
+record_insn_name (int code, const char *name)
{
- PTR val = (PTR) really_call_malloc (size);
+ static const char *last_real_name = "insn";
+ static int last_real_code = 0;
+ char *new_name;
+
+ if (insn_name_ptr_size <= code)
+ {
+ int new_size;
+ new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
+ insn_name_ptr = XRESIZEVEC (char *, insn_name_ptr, new_size);
+ memset (insn_name_ptr + insn_name_ptr_size, 0,
+ sizeof(char *) * (new_size - insn_name_ptr_size));
+ insn_name_ptr_size = new_size;
+ }
+
+ if (!name || name[0] == '\0')
+ {
+ new_name = XNEWVAR (char, strlen (last_real_name) + 10);
+ sprintf (new_name, "%s+%d", last_real_name, code - last_real_code);
+ }
+ else
+ {
+ last_real_name = new_name = xstrdup (name);
+ last_real_code = code;
+ }
- if (val == 0)
- fatal ("virtual memory exhausted");
- return val;
+ insn_name_ptr[code] = new_name;
}
OSDN Git Service
