X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fgenoutput.c;h=74725fa57b312388b8741e8c5954762a9d2da2e3;hp=30d1280b76d733eb0c667c7b5beed181fde4bdeb;hb=3bdec96a2fb0b7f20277ab0fb361c2acd1a57731;hpb=a8482e91d66166ec082f4240b4192dbc3f294982 diff --git a/gcc/genoutput.c b/gcc/genoutput.c index 30d1280b76d..74725fa57b3 100644 --- a/gcc/genoutput.c +++ b/gcc/genoutput.c @@ -1,83 +1,79 @@ /* Generate code from to output assembler insns as recognized from rtl. - Copyright (C) 1987, 88, 92, 94-95, 97-98, 1999 Free Software Foundation, Inc. + Copyright (C) 1987, 1988, 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002, + 2003 Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -GNU CC 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) -any later version. +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) any later +version. -GNU CC 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. +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 GNU CC; 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 COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ /* This program reads the machine description for the compiler target machine and produces a file containing these things: - 1. An array of strings `insn_template' which is indexed by insn code number - and contains the template for output of that insn, + 1. An array of `struct insn_data', which is indexed by insn code number, + which contains: - 2. An array of functions `insn_outfun' which, indexed by the insn code - number, gives the function that returns a template to use for output of - that insn. This is used only in the cases where the template is not - constant. These cases are specified by a * or @ at the beginning of the - template string in the machine description. They are identified for the - sake of other parts of the compiler by a zero element in `insn_template'. - - 3. An array of functions `insn_gen_function' which, indexed - by insn code number, gives the function to generate a body - for that pattern, given operands as arguments. + a. `name' is the name for that pattern. Nameless patterns are + given a name. - 4. An array of strings `insn_name' which, indexed by insn code number, - gives the name for that pattern. Nameless patterns are given a name. + b. `output' hold either the output template, an array of output + templates, or an output function. - 5. An array of ints `insn_n_operands' which is indexed by insn code number - and contains the number of distinct operands in the pattern for that insn, + c. `genfun' is the function to generate a body for that pattern, + given operands as arguments. - 6. An array of ints `insn_n_dups' which is indexed by insn code number - and contains the number of match_dup's that appear in the insn's pattern. - This says how many elements of `recog_dup_loc' are significant - after an insn has been recognized. + d. `n_operands' is the number of distinct operands in the pattern + for that insn, - 7. An array of arrays of operand constraint strings, - `insn_operand_constraint', - indexed first by insn code number and second by operand number, - containing the constraint for that operand. + e. `n_dups' is the number of match_dup's that appear in the insn's + pattern. This says how many elements of `recog_data.dup_loc' are + significant after an insn has been recognized. - This array is generated only if register constraints appear in - match_operand rtx's. + f. `n_alternatives' is the number of alternatives in the constraints + of each pattern. - 8. An array of arrays of chars which indicate which operands of - which insn patterns appear within ADDRESS rtx's. This array is - called `insn_operand_address_p' and is generated only if there - are *no* register constraints in the match_operand rtx's. + g. `output_format' tells what type of thing `output' is. - 9. An array of arrays of machine modes, `insn_operand_mode', - indexed first by insn code number and second by operand number, - containing the machine mode that that operand is supposed to have. - Also `insn_operand_strict_low', which is nonzero for operands - contained in a STRICT_LOW_PART. + h. `operand' is the base of an array of operand data for the insn. - 10. An array of arrays of int-valued functions, `insn_operand_predicate', - indexed first by insn code number and second by operand number, - containing the match_operand predicate for this operand. + 2. An array of `struct insn_operand data', used by `operand' above. - 11. An array of ints, `insn_n_alternatives', that gives the number - of alternatives in the constraints of each pattern. + a. `predicate', an int-valued function, is the match_operand predicate + for this operand. -The code number of an insn is simply its position in the machine description; -code numbers are assigned sequentially to entries in the description, -starting with code number 0. + b. `constraint' is the constraint for this operand. This exists + only if register constraints appear in match_operand rtx's. -Thus, the following entry in the machine description + c. `address_p' indicates that the operand appears within ADDRESS + rtx's. This exists only if there are *no* register constraints + in the match_operand rtx's. + + d. `mode' is the machine mode that that operand is supposed to have. + + e. `strict_low', is nonzero for operands contained in a STRICT_LOW_PART. + + f. `eliminable', is nonzero for operands that are matched normally by + MATCH_OPERAND; it is zero for operands that should not be changed during + register elimination such as MATCH_OPERATORs. + + The code number of an insn is simply its position in the machine + description; code numbers are assigned sequentially to entries in + the description, starting with code number 0. + + Thus, the following entry in the machine description (define_insn "clrdf" [(set (match_operand:DF 0 "general_operand" "") @@ -85,36 +81,26 @@ Thus, the following entry in the machine description "" "clrd %0") -assuming it is the 25th entry present, would cause -insn_template[24] to be "clrd %0", and insn_n_operands[24] to be 1. -It would not make an case in output_insn_hairy because the template -given in the entry is a constant (it does not start with `*'). */ + assuming it is the 25th entry present, would cause + insn_data[24].template to be "clrd %0", and + insn_data[24].n_operands to be 1. */ -#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 "gensupport.h" -/* No instruction can have more operands than this. - Sorry for this arbitrary limit, but what machine will - have an instruction with this many operands? */ +/* No instruction can have more operands than this. Sorry for this + arbitrary limit, but what machine will have an instruction with + this many operands? */ #define MAX_MAX_OPERANDS 40 -static struct obstack obstack; -struct obstack *rtl_obstack = &obstack; - -#define obstack_chunk_alloc xmalloc -#define obstack_chunk_free free - -static void fatal PVPROTO ((const char *, ...)) - ATTRIBUTE_PRINTF_1 ATTRIBUTE_NORETURN; -void fancy_abort PROTO((void)) ATTRIBUTE_NORETURN; -static void error PVPROTO ((const char *, ...)) ATTRIBUTE_PRINTF_1; -static int n_occurrences PROTO((int, char *)); - -/* Define this so we can link with print-rtl.o to get debug_rtx function. */ -char **insn_name_ptr = 0; +static int n_occurrences (int, const char *); +static const char *strip_whitespace (const char *); /* insns in the machine description are assigned sequential code numbers that are used by insn-recog.c (produced by genrecog) to communicate @@ -127,69 +113,91 @@ static int next_code_number; static int next_index_number; +/* This counts all operands used in the md file. The first is null. */ + +static int next_operand_number = 1; + +/* Record in this chain all information about the operands we will output. */ + +struct operand_data +{ + struct operand_data *next; + int index; + const char *predicate; + const char *constraint; + enum machine_mode mode; + unsigned char n_alternatives; + char address_p; + char strict_low; + char eliminable; + char seen; +}; + +/* Begin with a null operand at index 0. */ + +static struct operand_data null_operand = +{ + 0, 0, "", "", VOIDmode, 0, 0, 0, 0, 0 +}; + +static struct operand_data *odata = &null_operand; +static struct operand_data **odata_end = &null_operand.next; + +/* Must match the constants in recog.h. */ + +#define INSN_OUTPUT_FORMAT_NONE 0 /* abort */ +#define INSN_OUTPUT_FORMAT_SINGLE 1 /* const char * */ +#define INSN_OUTPUT_FORMAT_MULTI 2 /* const char * const * */ +#define INSN_OUTPUT_FORMAT_FUNCTION 3 /* const char * (*)(...) */ + /* Record in this chain all information that we will output, associated with the code number of the insn. */ struct data { + struct data *next; + const char *name; + const char *template; int code_number; int index_number; - char *name; - char *template; /* string such as "movl %1,%0" */ + int lineno; int n_operands; /* Number of operands this insn recognizes */ int n_dups; /* Number times match_dup appears in pattern */ int n_alternatives; /* Number of alternatives in each constraint */ - struct data *next; - char *constraints[MAX_MAX_OPERANDS]; - /* Number of alternatives in constraints of operand N. */ - int op_n_alternatives[MAX_MAX_OPERANDS]; - char *predicates[MAX_MAX_OPERANDS]; - char address_p[MAX_MAX_OPERANDS]; - enum machine_mode modes[MAX_MAX_OPERANDS]; - char strict_low[MAX_MAX_OPERANDS]; - char outfun; /* Nonzero means this has an output function */ + int operand_number; /* Operand index in the big array. */ + int output_format; /* INSN_OUTPUT_FORMAT_*. */ + struct operand_data operand[MAX_MAX_OPERANDS]; }; -/* This variable points to the first link in the chain. */ - -struct data *insn_data; +/* This variable points to the first link in the insn chain. */ -/* Pointer to the last link in the chain, so new elements - can be added at the end. */ - -struct data *end_of_insn_data; - -/* Nonzero if any match_operand has a constraint string; - implies that REGISTER_CONSTRAINTS will be defined - for this machine description. */ - -int have_constraints; - -/* Nonzero if some error has occurred. We will make all errors fatal, but - might as well continue until we see all of them. */ - -static int have_error; +static struct data *idata, **idata_end = &idata; -static char * name_for_index PROTO((int)); -static void output_prologue PROTO((void)); -static void output_epilogue PROTO((void)); -static void scan_operands PROTO((rtx, int, int)); -static void process_template PROTO((struct data *, char *)); -static void validate_insn_alternatives PROTO((struct data *)); -static void gen_insn PROTO((rtx)); -static void gen_peephole PROTO((rtx)); -static void gen_expand PROTO((rtx)); -static void gen_split PROTO((rtx)); -static int n_occurrences PROTO((int, char *)); +static void output_prologue (void); +static void output_operand_data (void); +static void output_insn_data (void); +static void output_get_insn_name (void); +static void scan_operands (struct data *, rtx, int, int); +static int compare_operands (struct operand_data *, + struct operand_data *); +static void place_operands (struct data *); +static void process_template (struct data *, const char *); +static void validate_insn_alternatives (struct data *); +static void validate_insn_operands (struct data *); +static void gen_insn (rtx, int); +static void gen_peephole (rtx, int); +static void gen_expand (rtx, int); +static void gen_split (rtx, int); +static void check_constraint_len (void); +static int constraint_len (const char *, int); -static char * -name_for_index (index) - int index; +const char * +get_insn_name (int index) { static char buf[100]; struct data *i, *last_named = NULL; - for (i = insn_data; i ; i = i->next) + for (i = idata; i ; i = i->next) { if (i->index_number == index) return i->name; @@ -206,251 +214,193 @@ name_for_index (index) } static void -output_prologue () +output_prologue (void) { printf ("/* Generated automatically by the program `genoutput'\n\ -from the machine description file `md'. */\n\n"); + from the machine description file `md'. */\n\n"); printf ("#include \"config.h\"\n"); printf ("#include \"system.h\"\n"); + printf ("#include \"coretypes.h\"\n"); + printf ("#include \"tm.h\"\n"); printf ("#include \"flags.h\"\n"); + printf ("#include \"ggc.h\"\n"); printf ("#include \"rtl.h\"\n"); + printf ("#include \"expr.h\"\n"); + printf ("#include \"insn-codes.h\"\n"); + printf ("#include \"tm_p.h\"\n"); + printf ("#include \"function.h\"\n"); printf ("#include \"regs.h\"\n"); printf ("#include \"hard-reg-set.h\"\n"); printf ("#include \"real.h\"\n"); printf ("#include \"insn-config.h\"\n\n"); printf ("#include \"conditions.h\"\n"); - printf ("#include \"insn-flags.h\"\n"); printf ("#include \"insn-attr.h\"\n\n"); - printf ("#include \"insn-codes.h\"\n\n"); printf ("#include \"recog.h\"\n\n"); - + printf ("#include \"toplev.h\"\n"); printf ("#include \"output.h\"\n"); + printf ("#include \"target.h\"\n"); } static void -output_epilogue () +output_operand_data (void) { - register struct data *d; + struct operand_data *d; - printf ("\nconst char * const insn_template[] =\n {\n"); - for (d = insn_data; d; d = d->next) - { - if (d->template) - printf (" \"%s\",\n", d->template); - else - printf (" 0,\n"); - } - printf (" };\n"); + printf ("\nstatic const struct insn_operand_data operand_data[] = \n{\n"); - printf ("\nconst char *(*const insn_outfun[])() =\n {\n"); - for (d = insn_data; d; d = d->next) + for (d = odata; d; d = d->next) { - if (d->outfun) - printf (" output_%d,\n", d->code_number); - else - printf (" 0,\n"); - } - printf (" };\n"); + printf (" {\n"); - printf ("\nrtx (*const insn_gen_function[]) () =\n {\n"); - for (d = insn_data; d; d = d->next) - { - if (d->name && d->name[0] != '*') - printf (" gen_%s,\n", d->name); - else - printf (" 0,\n"); + printf (" %s,\n", + d->predicate && d->predicate[0] ? d->predicate : "0"); + + printf (" \"%s\",\n", d->constraint ? d->constraint : ""); + + printf (" %smode,\n", GET_MODE_NAME (d->mode)); + + printf (" %d,\n", d->strict_low); + + printf (" %d\n", d->eliminable); + + printf(" },\n"); } - printf (" };\n"); - - printf ("\nconst char *insn_name[] =\n {\n"); - { - int offset = 0; - int next; - char * last_name = 0; - char * next_name = 0; - register struct data *n; - - for (n = insn_data, next = 1; n; n = n->next, next++) - if (n->name) - { - next_name = n->name; - break; - } + printf("};\n\n\n"); +} - for (d = insn_data; d; d = d->next) +static void +output_insn_data (void) +{ + struct data *d; + int name_offset = 0; + int next_name_offset; + const char * last_name = 0; + const char * next_name = 0; + struct data *n; + + for (n = idata, next_name_offset = 1; n; n = n->next, next_name_offset++) + if (n->name) { - if (d->name) - { - printf (" \"%s\",\n", d->name); - offset = 0; - last_name = d->name; - next_name = 0; - for (n = d->next, next = 1; n; n = n->next, next++) - if (n->name) - { - next_name = n->name; - break; - } - } - else - { - offset++; - if (next_name && (last_name == 0 || offset > next / 2)) - printf (" \"%s-%d\",\n", next_name, next - offset); - else - printf (" \"%s+%d\",\n", last_name, offset); - } + next_name = n->name; + break; } - } - printf (" };\n"); - printf ("const char **insn_name_ptr = insn_name;\n"); - - printf ("\nconst int insn_n_operands[] =\n {\n"); - for (d = insn_data; d; d = d->next) - printf (" %d,\n", d->n_operands); - printf (" };\n"); - printf ("\nconst int insn_n_dups[] =\n {\n"); - for (d = insn_data; d; d = d->next) - printf (" %d,\n", d->n_dups); - printf (" };\n"); + printf ("\nconst struct insn_data insn_data[] = \n{\n"); - if (have_constraints) + for (d = idata; d; d = d->next) { - printf ("\nconst char *const insn_operand_constraint[][MAX_RECOG_OPERANDS] =\n {\n"); - for (d = insn_data; d; d = d->next) + printf (" {\n"); + + if (d->name) { - register int i; - printf (" {"); - for (i = 0; i < d->n_operands; i++) + printf (" \"%s\",\n", d->name); + name_offset = 0; + last_name = d->name; + next_name = 0; + for (n = d->next, next_name_offset = 1; n; + n = n->next, next_name_offset++) { - if (d->constraints[i] == 0) - printf (" \"\","); - else - printf (" \"%s\",", d->constraints[i]); + if (n->name) + { + next_name = n->name; + break; + } } - if (d->n_operands == 0) - printf (" 0"); - printf (" },\n"); } - printf (" };\n"); - } - else - { - printf ("\nconst char insn_operand_address_p[][MAX_RECOG_OPERANDS] =\n {\n"); - for (d = insn_data; d; d = d->next) + else { - register int i; - printf (" {"); - for (i = 0; i < d->n_operands; i++) - printf (" %d,", d->address_p[i]); - if (d->n_operands == 0) - printf (" 0"); - printf (" },\n"); + name_offset++; + if (next_name && (last_name == 0 + || name_offset > next_name_offset / 2)) + printf (" \"%s-%d\",\n", next_name, + next_name_offset - name_offset); + else + printf (" \"%s+%d\",\n", last_name, name_offset); } - printf (" };\n"); - } - - printf ("\nconst enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =\n {\n"); - for (d = insn_data; d; d = d->next) - { - register int i; - printf (" {"); - for (i = 0; i < d->n_operands; i++) - printf (" %smode,", GET_MODE_NAME (d->modes[i])); - if (d->n_operands == 0) - printf (" VOIDmode"); - printf (" },\n"); - } - printf (" };\n"); - printf ("\nconst char insn_operand_strict_low[][MAX_RECOG_OPERANDS] =\n {\n"); - for (d = insn_data; d; d = d->next) - { - register int i; - printf (" {"); - for (i = 0; i < d->n_operands; i++) - printf (" %d,", d->strict_low[i]); - if (d->n_operands == 0) - printf (" 0"); - printf (" },\n"); - } - printf (" };\n"); - - { - /* We need to define all predicates used. Keep a list of those we - have defined so far. There normally aren't very many predicates used, - so a linked list should be fast enough. */ - struct predicate { char *name; struct predicate *next; } *predicates = 0; - struct predicate *p; - int i; - - printf ("\n"); - for (d = insn_data; d; d = d->next) - for (i = 0; i < d->n_operands; i++) - if (d->predicates[i] && d->predicates[i][0]) + switch (d->output_format) + { + case INSN_OUTPUT_FORMAT_NONE: + printf (" 0,\n"); + break; + case INSN_OUTPUT_FORMAT_SINGLE: { - for (p = predicates; p; p = p->next) - if (! strcmp (p->name, d->predicates[i])) - break; + const char *p = d->template; + char prev = 0; - if (p == 0) + printf (" \""); + while (*p) { - printf ("extern int %s ();\n", d->predicates[i]); - p = (struct predicate *) alloca (sizeof (struct predicate)); - p->name = d->predicates[i]; - p->next = predicates; - predicates = p; + if (IS_VSPACE (*p) && prev != '\\') + { + /* Preserve two consecutive \n's or \r's, but treat \r\n + as a single newline. */ + if (*p == '\n' && prev != '\r') + printf ("\\n\\\n"); + } + else + putchar (*p); + prev = *p; + ++p; } + printf ("\",\n"); } - - printf ("\nint (*const insn_operand_predicate[][MAX_RECOG_OPERANDS])() =\n {\n"); - for (d = insn_data; d; d = d->next) - { - printf (" {"); - for (i = 0; i < d->n_operands; i++) - printf (" %s,", ((d->predicates[i] && d->predicates[i][0]) - ? d->predicates[i] : "0")); - if (d->n_operands == 0) - printf (" 0"); - printf (" },\n"); - } - printf (" };\n"); - } + break; + case INSN_OUTPUT_FORMAT_MULTI: + case INSN_OUTPUT_FORMAT_FUNCTION: + printf (" (const void *) output_%d,\n", d->code_number); + break; + default: + abort (); + } - printf ("\nconst int insn_n_alternatives[] =\n {\n"); - for (d = insn_data; d; d = d->next) - printf (" %d,\n", d->n_alternatives); - printf(" };\n"); + if (d->name && d->name[0] != '*') + printf (" (insn_gen_fn) gen_%s,\n", d->name); + else + printf (" 0,\n"); + + printf (" &operand_data[%d],\n", d->operand_number); + printf (" %d,\n", d->n_operands); + printf (" %d,\n", d->n_dups); + printf (" %d,\n", d->n_alternatives); + printf (" %d\n", d->output_format); + + printf(" },\n"); + } + printf ("};\n\n\n"); } + +static void +output_get_insn_name (void) +{ + printf ("const char *\n"); + printf ("get_insn_name (int code)\n"); + printf ("{\n"); + printf (" if (code == NOOP_MOVE_INSN_CODE)\n"); + printf (" return \"NOOP_MOVE\";\n"); + printf (" else\n"); + printf (" return insn_data[code].name;\n"); + printf ("}\n"); +} + -/* scan_operands (X) stores in max_opno the largest operand - number present in X, if that is larger than the previous - value of max_opno. It stores all the constraints in `constraints' - and all the machine modes in `modes'. +/* Stores in max_opno the largest operand number present in `part', if + that is larger than the previous value of max_opno, and the rest of + the operand data into `d->operand[i]'. THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS. THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART. */ static int max_opno; static int num_dups; -static char *constraints[MAX_MAX_OPERANDS]; -static int op_n_alternatives[MAX_MAX_OPERANDS]; -static const char *predicates[MAX_MAX_OPERANDS]; -static char address_p[MAX_MAX_OPERANDS]; -static enum machine_mode modes[MAX_MAX_OPERANDS]; -static char strict_low[MAX_MAX_OPERANDS]; -static char seen[MAX_MAX_OPERANDS]; static void -scan_operands (part, this_address_p, this_strict_low) - rtx part; - int this_address_p; - int this_strict_low; +scan_operands (struct data *d, rtx part, int this_address_p, + int this_strict_low) { - register int i, j; - register char *format_ptr; + int i, j; + const char *format_ptr; int opno; if (part == 0) @@ -464,24 +414,27 @@ scan_operands (part, this_address_p, this_strict_low) max_opno = opno; if (max_opno >= MAX_MAX_OPERANDS) { - error ("Too many operands (%d) in definition %s.\n", - max_opno + 1, name_for_index (next_index_number)); + message_with_line (d->lineno, + "maximum number of operands exceeded"); + have_error = 1; return; } - if (seen[opno]) - error ("Definition %s specified operand number %d more than once.\n", - name_for_index (next_index_number), opno); - seen[opno] = 1; - modes[opno] = GET_MODE (part); - strict_low[opno] = this_strict_low; - predicates[opno] = XSTR (part, 1); - constraints[opno] = XSTR (part, 2); - if (XSTR (part, 2) != 0 && *XSTR (part, 2) != 0) + if (d->operand[opno].seen) { - op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 2)) + 1; - have_constraints = 1; + message_with_line (d->lineno, + "repeated operand number %d\n", opno); + have_error = 1; } - address_p[opno] = this_address_p; + + d->operand[opno].seen = 1; + d->operand[opno].mode = GET_MODE (part); + d->operand[opno].strict_low = this_strict_low; + d->operand[opno].predicate = XSTR (part, 1); + d->operand[opno].constraint = strip_whitespace (XSTR (part, 2)); + d->operand[opno].n_alternatives + = n_occurrences (',', d->operand[opno].constraint) + 1; + d->operand[opno].address_p = this_address_p; + d->operand[opno].eliminable = 1; return; case MATCH_SCRATCH: @@ -490,24 +443,27 @@ scan_operands (part, this_address_p, this_strict_low) max_opno = opno; if (max_opno >= MAX_MAX_OPERANDS) { - error ("Too many operands (%d) in definition %s.\n", - max_opno + 1, name_for_index (next_index_number)); + message_with_line (d->lineno, + "maximum number of operands exceeded"); + have_error = 1; return; } - if (seen[opno]) - error ("Definition %s specified operand number %d more than once.\n", - name_for_index (next_index_number), opno); - seen[opno] = 1; - modes[opno] = GET_MODE (part); - strict_low[opno] = 0; - predicates[opno] = "scratch_operand"; - constraints[opno] = XSTR (part, 1); - if (XSTR (part, 1) != 0 && *XSTR (part, 1) != 0) + if (d->operand[opno].seen) { - op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 1)) + 1; - have_constraints = 1; + message_with_line (d->lineno, + "repeated operand number %d\n", opno); + have_error = 1; } - address_p[opno] = 0; + + d->operand[opno].seen = 1; + d->operand[opno].mode = GET_MODE (part); + d->operand[opno].strict_low = 0; + d->operand[opno].predicate = "scratch_operand"; + d->operand[opno].constraint = strip_whitespace (XSTR (part, 1)); + d->operand[opno].n_alternatives + = n_occurrences (',', d->operand[opno].constraint) + 1; + d->operand[opno].address_p = 0; + d->operand[opno].eliminable = 0; return; case MATCH_OPERATOR: @@ -517,37 +473,43 @@ scan_operands (part, this_address_p, this_strict_low) max_opno = opno; if (max_opno >= MAX_MAX_OPERANDS) { - error ("Too many operands (%d) in definition %s.\n", - max_opno + 1, name_for_index (next_index_number)); + message_with_line (d->lineno, + "maximum number of operands exceeded"); + have_error = 1; return; } - if (seen[opno]) - error ("Definition %s specified operand number %d more than once.\n", - name_for_index (next_index_number), opno); - seen[opno] = 1; - modes[opno] = GET_MODE (part); - strict_low[opno] = 0; - predicates[opno] = XSTR (part, 1); - constraints[opno] = 0; - address_p[opno] = 0; + if (d->operand[opno].seen) + { + message_with_line (d->lineno, + "repeated operand number %d\n", opno); + have_error = 1; + } + + d->operand[opno].seen = 1; + d->operand[opno].mode = GET_MODE (part); + d->operand[opno].strict_low = 0; + d->operand[opno].predicate = XSTR (part, 1); + d->operand[opno].constraint = 0; + d->operand[opno].address_p = 0; + d->operand[opno].eliminable = 0; for (i = 0; i < XVECLEN (part, 2); i++) - scan_operands (XVECEXP (part, 2, i), 0, 0); + scan_operands (d, XVECEXP (part, 2, i), 0, 0); return; case MATCH_DUP: case MATCH_OP_DUP: case MATCH_PAR_DUP: ++num_dups; - return; + break; case ADDRESS: - scan_operands (XEXP (part, 0), 1, 0); + scan_operands (d, XEXP (part, 0), 1, 0); return; case STRICT_LOW_PART: - scan_operands (XEXP (part, 0), 0, 1); + scan_operands (d, XEXP (part, 0), 0, 1); return; - + default: break; } @@ -559,65 +521,147 @@ scan_operands (part, this_address_p, this_strict_low) { case 'e': case 'u': - scan_operands (XEXP (part, i), 0, 0); + scan_operands (d, XEXP (part, i), 0, 0); break; case 'E': if (XVEC (part, i) != NULL) for (j = 0; j < XVECLEN (part, i); j++) - scan_operands (XVECEXP (part, i, j), 0, 0); + scan_operands (d, XVECEXP (part, i, j), 0, 0); break; } } + +/* Compare two operands for content equality. */ + +static int +compare_operands (struct operand_data *d0, struct operand_data *d1) +{ + const char *p0, *p1; + + p0 = d0->predicate; + if (!p0) + p0 = ""; + p1 = d1->predicate; + if (!p1) + p1 = ""; + if (strcmp (p0, p1) != 0) + return 0; + + p0 = d0->constraint; + if (!p0) + p0 = ""; + p1 = d1->constraint; + if (!p1) + p1 = ""; + if (strcmp (p0, p1) != 0) + return 0; + + if (d0->mode != d1->mode) + return 0; + + if (d0->strict_low != d1->strict_low) + return 0; + + if (d0->eliminable != d1->eliminable) + return 0; + + return 1; +} + +/* Scan the list of operands we've already committed to output and either + find a subsequence that is the same, or allocate a new one at the end. */ + +static void +place_operands (struct data *d) +{ + struct operand_data *od, *od2; + int i; + + if (d->n_operands == 0) + { + d->operand_number = 0; + return; + } + + /* Brute force substring search. */ + for (od = odata, i = 0; od; od = od->next, i = 0) + if (compare_operands (od, &d->operand[0])) + { + od2 = od->next; + i = 1; + while (1) + { + if (i == d->n_operands) + goto full_match; + if (od2 == NULL) + goto partial_match; + if (! compare_operands (od2, &d->operand[i])) + break; + ++i, od2 = od2->next; + } + } + + /* Either partial match at the end of the list, or no match. In either + case, we tack on what operands are remaining to the end of the list. */ + partial_match: + d->operand_number = next_operand_number - i; + for (; i < d->n_operands; ++i) + { + od2 = &d->operand[i]; + *odata_end = od2; + odata_end = &od2->next; + od2->index = next_operand_number++; + } + *odata_end = NULL; + return; + + full_match: + d->operand_number = od->index; + return; +} + /* Process an assembler template from a define_insn or a define_peephole. It is either the assembler code template, a list of assembler code templates, or C code to generate the assembler code template. */ static void -process_template (d, template) - struct data *d; - char *template; +process_template (struct data *d, const char *template) { - register char *cp; - register int i; - - /* We need to consider only the instructions whose assembler code template - starts with a * or @. These are the ones where C code is run to decide - on a template to use. So for all others just return now. */ + const char *cp; + int i; - if (template[0] != '*' && template[0] != '@') + /* Templates starting with * contain straight code to be run. */ + if (template[0] == '*') { - d->template = template; - d->outfun = 0; - return; - } + d->template = 0; + d->output_format = INSN_OUTPUT_FORMAT_FUNCTION; - d->template = 0; - d->outfun = 1; + puts ("\nstatic const char *"); + printf ("output_%d (rtx *operands ATTRIBUTE_UNUSED, rtx insn ATTRIBUTE_UNUSED)\n", + d->code_number); + puts ("{"); - printf ("\nstatic const char *\n"); - printf ("output_%d (operands, insn)\n", d->code_number); - printf (" rtx *operands ATTRIBUTE_UNUSED;\n"); - printf (" rtx insn ATTRIBUTE_UNUSED;\n"); - printf ("{\n"); + puts (template + 1); + puts ("}"); + } /* If the assembler code template starts with a @ it is a newline-separated - list of assembler code templates, one for each alternative. So produce - a routine to select the correct one. */ - - if (template[0] == '@') + list of assembler code templates, one for each alternative. */ + else if (template[0] == '@') { + d->template = 0; + d->output_format = INSN_OUTPUT_FORMAT_MULTI; - printf (" static const char *const strings_%d[] = {\n", - d->code_number); + printf ("\nstatic const char * const output_%d[] = {\n", d->code_number); for (i = 0, cp = &template[1]; *cp; ) { - while (*cp == '\n' || *cp == ' ' || *cp== '\t') + while (ISSPACE (*cp)) cp++; - printf (" \""); - while (*cp != '\n' && *cp != '\0') + printf (" \""); + while (!IS_VSPACE (*cp) && *cp != '\0') { putchar (*cp); cp++; @@ -626,68 +670,124 @@ process_template (d, template) printf ("\",\n"); i++; } - - printf (" };\n"); - printf (" return strings_%d[which_alternative];\n", d->code_number); - + if (i == 1) + message_with_line (d->lineno, + "'@' is redundant for output template with single alternative"); if (i != d->n_alternatives) - fatal ("Insn pattern %d has %d alternatives but %d assembler choices", - d->index_number, d->n_alternatives, i); + { + message_with_line (d->lineno, + "wrong number of alternatives in the output template"); + have_error = 1; + } + printf ("};\n"); } else { - /* The following is done in a funny way to get around problems in - VAX-11 "C" on VMS. It is the equivalent of: - printf ("%s\n", &template[1])); */ - cp = &template[1]; - while (*cp) - { - putchar (*cp); - cp++; - } - putchar ('\n'); + d->template = template; + d->output_format = INSN_OUTPUT_FORMAT_SINGLE; } - - printf ("}\n"); } /* Check insn D for consistency in number of constraint alternatives. */ static void -validate_insn_alternatives (d) - struct data *d; +validate_insn_alternatives (struct data *d) { - register int n = 0, start; - /* Make sure all the operands have the same number of - alternatives in their constraints. - Let N be that number. */ + int n = 0, start; + + /* Make sure all the operands have the same number of alternatives + in their constraints. Let N be that number. */ for (start = 0; start < d->n_operands; start++) - if (d->op_n_alternatives[start] > 0) + if (d->operand[start].n_alternatives > 0) { - if (n == 0) - n = d->op_n_alternatives[start]; - else if (n != d->op_n_alternatives[start]) - error ("wrong number of alternatives in operand %d of insn %s", - start, name_for_index (d->index_number)); + int len, i; + const char *p; + char c; + int which_alternative = 0; + int alternative_count_unsure = 0; + + for (p = d->operand[start].constraint; (c = *p); p += len) + { + len = CONSTRAINT_LEN (c, p); + + if (len < 1 || (len > 1 && strchr (",#*+=&%!0123456789", c))) + { + message_with_line (d->lineno, + "invalid length %d for char '%c' in alternative %d of operand %d", + len, c, which_alternative, start); + len = 1; + have_error = 1; + } + + if (c == ',') + { + which_alternative++; + continue; + } + + for (i = 1; i < len; i++) + if (p[i] == '\0') + { + message_with_line (d->lineno, + "NUL in alternative %d of operand %d", + which_alternative, start); + alternative_count_unsure = 1; + break; + } + else if (strchr (",#*", p[i])) + { + message_with_line (d->lineno, + "'%c' in alternative %d of operand %d", + p[i], which_alternative, start); + alternative_count_unsure = 1; + } + } + if (alternative_count_unsure) + have_error = 1; + else if (n == 0) + n = d->operand[start].n_alternatives; + else if (n != d->operand[start].n_alternatives) + { + message_with_line (d->lineno, + "wrong number of alternatives in operand %d", + start); + have_error = 1; + } } + /* Record the insn's overall number of alternatives. */ d->n_alternatives = n; } + +/* Verify that there are no gaps in operand numbers for INSNs. */ + +static void +validate_insn_operands (struct data *d) +{ + int i; + + for (i = 0; i < d->n_operands; ++i) + if (d->operand[i].seen == 0) + { + message_with_line (d->lineno, "missing operand %d", i); + have_error = 1; + } +} -/* Look at a define_insn just read. Assign its code number. - Record on insn_data the template and the number of arguments. - If the insn has a hairy output action, output a function for now. */ +/* Look at a define_insn just read. Assign its code number. Record + on idata the template and the number of arguments. If the insn has + a hairy output action, output a function for now. */ static void -gen_insn (insn) - rtx insn; +gen_insn (rtx insn, int lineno) { - register struct data *d = (struct data *) xmalloc (sizeof (struct data)); - register int i; + struct data *d = xmalloc (sizeof (struct data)); + int i; - d->code_number = next_code_number++; + d->code_number = next_code_number; d->index_number = next_index_number; + d->lineno = lineno; if (XSTR (insn, 0)[0]) d->name = XSTR (insn, 0); else @@ -696,107 +796,77 @@ gen_insn (insn) /* Build up the list in the same order as the insns are seen in the machine description. */ d->next = 0; - if (end_of_insn_data) - end_of_insn_data->next = d; - else - insn_data = d; - - end_of_insn_data = d; + *idata_end = d; + idata_end = &d->next; max_opno = -1; num_dups = 0; - - memset (constraints, 0, sizeof constraints); - memset (op_n_alternatives, 0, sizeof op_n_alternatives); - memset (predicates, 0, sizeof predicates); - memset (address_p, 0, sizeof address_p); - memset (modes, 0, sizeof modes); - memset (strict_low, 0, sizeof strict_low); - memset (seen, 0, sizeof seen); + memset (d->operand, 0, sizeof (d->operand)); for (i = 0; i < XVECLEN (insn, 1); i++) - scan_operands (XVECEXP (insn, 1, i), 0, 0); + scan_operands (d, XVECEXP (insn, 1, i), 0, 0); d->n_operands = max_opno + 1; d->n_dups = num_dups; - memcpy (d->constraints, constraints, sizeof constraints); - memcpy (d->op_n_alternatives, op_n_alternatives, sizeof op_n_alternatives); - memcpy (d->predicates, predicates, sizeof predicates); - memcpy (d->address_p, address_p, sizeof address_p); - memcpy (d->modes, modes, sizeof modes); - memcpy (d->strict_low, strict_low, sizeof strict_low); - + check_constraint_len (); + validate_insn_operands (d); validate_insn_alternatives (d); - process_template (d, XSTR (insn, 3)); + place_operands (d); + process_template (d, XTMPL (insn, 3)); } /* Look at a define_peephole just read. Assign its code number. - Record on insn_data the template and the number of arguments. + Record on idata the template and the number of arguments. If the insn has a hairy output action, output it now. */ static void -gen_peephole (peep) - rtx peep; +gen_peephole (rtx peep, int lineno) { - register struct data *d = (struct data *) xmalloc (sizeof (struct data)); - register int i; + struct data *d = xmalloc (sizeof (struct data)); + int i; - d->code_number = next_code_number++; + d->code_number = next_code_number; d->index_number = next_index_number; + d->lineno = lineno; d->name = 0; /* Build up the list in the same order as the insns are seen in the machine description. */ d->next = 0; - if (end_of_insn_data) - end_of_insn_data->next = d; - else - insn_data = d; - - end_of_insn_data = d; + *idata_end = d; + idata_end = &d->next; max_opno = -1; - memset (constraints, 0, sizeof constraints); - memset (op_n_alternatives, 0, sizeof op_n_alternatives); - memset (predicates, 0, sizeof predicates); - memset (address_p, 0, sizeof address_p); - memset (modes, 0, sizeof modes); - memset (strict_low, 0, sizeof strict_low); - memset (seen, 0, sizeof seen); - - /* Get the number of operands by scanning all the - patterns of the peephole optimizer. - But ignore all the rest of the information thus obtained. */ + num_dups = 0; + memset (d->operand, 0, sizeof (d->operand)); + + /* Get the number of operands by scanning all the patterns of the + peephole optimizer. But ignore all the rest of the information + thus obtained. */ for (i = 0; i < XVECLEN (peep, 0); i++) - scan_operands (XVECEXP (peep, 0, i), 0, 0); + scan_operands (d, XVECEXP (peep, 0, i), 0, 0); d->n_operands = max_opno + 1; d->n_dups = 0; - memcpy (d->constraints, constraints, sizeof constraints); - memcpy (d->op_n_alternatives, op_n_alternatives, sizeof op_n_alternatives); - memset (d->predicates, 0, sizeof predicates); - memset (d->address_p, 0, sizeof address_p); - memset (d->modes, 0, sizeof modes); - memset (d->strict_low, 0, sizeof strict_low); - validate_insn_alternatives (d); - process_template (d, XSTR (peep, 2)); + place_operands (d); + process_template (d, XTMPL (peep, 2)); } /* Process a define_expand just read. Assign its code number, only for the purposes of `insn_gen_function'. */ static void -gen_expand (insn) - rtx insn; +gen_expand (rtx insn, int lineno) { - register struct data *d = (struct data *) xmalloc (sizeof (struct data)); - register int i; + struct data *d = xmalloc (sizeof (struct data)); + int i; - d->code_number = next_code_number++; + d->code_number = next_code_number; d->index_number = next_index_number; + d->lineno = lineno; if (XSTR (insn, 0)[0]) d->name = XSTR (insn, 0); else @@ -805,247 +875,189 @@ gen_expand (insn) /* Build up the list in the same order as the insns are seen in the machine description. */ d->next = 0; - if (end_of_insn_data) - end_of_insn_data->next = d; - else - insn_data = d; - - end_of_insn_data = d; + *idata_end = d; + idata_end = &d->next; max_opno = -1; num_dups = 0; + memset (d->operand, 0, sizeof (d->operand)); /* Scan the operands to get the specified predicates and modes, since expand_binop needs to know them. */ - memset (constraints, 0, sizeof constraints); - memset (op_n_alternatives, 0, sizeof op_n_alternatives); - memset (predicates, 0, sizeof predicates); - memset (address_p, 0, sizeof address_p); - memset (modes, 0, sizeof modes); - memset (strict_low, 0, sizeof strict_low); - memset (seen, 0, sizeof seen); - if (XVEC (insn, 1)) for (i = 0; i < XVECLEN (insn, 1); i++) - scan_operands (XVECEXP (insn, 1, i), 0, 0); + scan_operands (d, XVECEXP (insn, 1, i), 0, 0); d->n_operands = max_opno + 1; d->n_dups = num_dups; - - memcpy (d->constraints, constraints, sizeof constraints); - memcpy (d->op_n_alternatives, op_n_alternatives, sizeof op_n_alternatives); - memcpy (d->predicates, predicates, sizeof predicates); - memcpy (d->address_p, address_p, sizeof address_p); - memcpy (d->modes, modes, sizeof modes); - memcpy (d->strict_low, strict_low, sizeof strict_low); - d->template = 0; - d->outfun = 0; + d->output_format = INSN_OUTPUT_FORMAT_NONE; + validate_insn_alternatives (d); + place_operands (d); } /* Process a define_split just read. Assign its code number, only for reasons of consistency and to simplify genrecog. */ - static void -gen_split (split) - rtx split; +gen_split (rtx split, int lineno) { - register struct data *d = (struct data *) xmalloc (sizeof (struct data)); - register int i; + struct data *d = xmalloc (sizeof (struct data)); + int i; - d->code_number = next_code_number++; + d->code_number = next_code_number; d->index_number = next_index_number; + d->lineno = lineno; d->name = 0; /* Build up the list in the same order as the insns are seen in the machine description. */ d->next = 0; - if (end_of_insn_data) - end_of_insn_data->next = d; - else - insn_data = d; - - end_of_insn_data = d; + *idata_end = d; + idata_end = &d->next; max_opno = -1; num_dups = 0; + memset (d->operand, 0, sizeof (d->operand)); - memset (constraints, 0, sizeof constraints); - memset (op_n_alternatives, 0, sizeof op_n_alternatives); - memset (predicates, 0, sizeof predicates); - memset (address_p, 0, sizeof address_p); - memset (modes, 0, sizeof modes); - memset (strict_low, 0, sizeof strict_low); - memset (seen, 0, sizeof seen); - - /* Get the number of operands by scanning all the - patterns of the split patterns. - But ignore all the rest of the information thus obtained. */ + /* Get the number of operands by scanning all the patterns of the + split patterns. But ignore all the rest of the information thus + obtained. */ for (i = 0; i < XVECLEN (split, 0); i++) - scan_operands (XVECEXP (split, 0, i), 0, 0); + scan_operands (d, XVECEXP (split, 0, i), 0, 0); d->n_operands = max_opno + 1; - - memset (d->constraints, 0, sizeof constraints); - memset (d->op_n_alternatives, 0, sizeof op_n_alternatives); - memset (d->predicates, 0, sizeof predicates); - memset (d->address_p, 0, sizeof address_p); - memset (d->modes, 0, sizeof modes); - memset (d->strict_low, 0, sizeof strict_low); - d->n_dups = 0; d->n_alternatives = 0; d->template = 0; - d->outfun = 0; -} - -PTR -xmalloc (size) - size_t size; -{ - register PTR val = (PTR) malloc (size); - - if (val == 0) - fatal ("virtual memory exhausted"); - return val; -} + d->output_format = INSN_OUTPUT_FORMAT_NONE; -PTR -xrealloc (old, size) - PTR old; - size_t size; -{ - register PTR ptr; - if (old) - ptr = (PTR) realloc (old, size); - else - ptr = (PTR) malloc (size); - if (!ptr) - fatal ("virtual memory exhausted"); - return ptr; + place_operands (d); } -static void -fatal VPROTO ((const char *format, ...)) -{ -#ifndef ANSI_PROTOTYPES - const char *format; -#endif - va_list ap; - - VA_START (ap, format); - -#ifndef ANSI_PROTOTYPES - format = va_arg (ap, const char *); -#endif - - fprintf (stderr, "genoutput: "); - vfprintf (stderr, format, ap); - va_end (ap); - fprintf (stderr, "\n"); - exit (FATAL_EXIT_CODE); -} - -/* More 'friendly' abort that prints the line and file. - config.h can #define abort fancy_abort if you like that sort of thing. */ - -void -fancy_abort () -{ - fatal ("Internal gcc abort."); -} - -static void -error VPROTO ((const char *format, ...)) -{ -#ifndef ANSI_PROTOTYPES - const char *format; -#endif - va_list ap; +extern int main (int, char **); - VA_START (ap, format); - -#ifndef ANSI_PROTOTYPES - format = va_arg (ap, const char *); -#endif - - fprintf (stderr, "genoutput: "); - vfprintf (stderr, format, ap); - va_end (ap); - fprintf (stderr, "\n"); - - have_error = 1; -} - int -main (argc, argv) - int argc; - char **argv; +main (int argc, char **argv) { rtx desc; - FILE *infile; - register int c; - obstack_init (rtl_obstack); + progname = "genoutput"; if (argc <= 1) - fatal ("No input file name."); - - infile = fopen (argv[1], "r"); - if (infile == 0) - { - perror (argv[1]); - exit (FATAL_EXIT_CODE); - } + fatal ("no input file name"); - init_rtl (); + if (init_md_reader_args (argc, argv) != SUCCESS_EXIT_CODE) + return (FATAL_EXIT_CODE); output_prologue (); next_code_number = 0; next_index_number = 0; - have_constraints = 0; /* Read the machine description. */ while (1) { - c = read_skip_spaces (infile); - if (c == EOF) + int line_no; + + desc = read_md_rtx (&line_no, &next_code_number); + if (desc == NULL) break; - ungetc (c, infile); - desc = read_rtx (infile); if (GET_CODE (desc) == DEFINE_INSN) - gen_insn (desc); + gen_insn (desc, line_no); if (GET_CODE (desc) == DEFINE_PEEPHOLE) - gen_peephole (desc); + gen_peephole (desc, line_no); if (GET_CODE (desc) == DEFINE_EXPAND) - gen_expand (desc); - if (GET_CODE (desc) == DEFINE_SPLIT) - gen_split (desc); + gen_expand (desc, line_no); + if (GET_CODE (desc) == DEFINE_SPLIT + || GET_CODE (desc) == DEFINE_PEEPHOLE2) + gen_split (desc, line_no); next_index_number++; } - output_epilogue (); + printf("\n\n"); + output_operand_data (); + output_insn_data (); + output_get_insn_name (); fflush (stdout); - exit (ferror (stdout) != 0 || have_error + return (ferror (stdout) != 0 || have_error ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE); - - /* NOTREACHED */ - return 0; } +/* Return the number of occurrences of character C in string S or + -1 if S is the null string. */ + static int -n_occurrences (c, s) - int c; - char *s; +n_occurrences (int c, const char *s) { int n = 0; + + if (s == 0 || *s == '\0') + return -1; + while (*s) n += (*s++ == c); + return n; } + +/* Remove whitespace in `s' by moving up characters until the end. + Return a new string. */ + +static const char * +strip_whitespace (const char *s) +{ + char *p, *q; + char ch; + + if (s == 0) + return 0; + + p = q = xmalloc (strlen (s) + 1); + while ((ch = *s++) != '\0') + if (! ISSPACE (ch)) + *p++ = ch; + + *p = '\0'; + return q; +} + +/* Verify that DEFAULT_CONSTRAINT_LEN is used properly and not + tampered with. This isn't bullet-proof, but it should catch + most genuine mistakes. */ +static void +check_constraint_len (void) +{ + const char *p; + int d; + + for (p = ",#*+=&%!1234567890"; *p; p++) + for (d = -9; d < 9; d++) + if (constraint_len (p, d) != d) + abort (); +} + +static int +constraint_len (const char *p, int genoutput_default_constraint_len) +{ + /* Check that we still match defaults.h . First we do a generation-time + check that fails if the value is not the expected one... */ + if (DEFAULT_CONSTRAINT_LEN (*p, p) != 1) + abort (); + /* And now a comile-time check that should give a diagnostic if the + definition doesn't exactly match. */ +#define DEFAULT_CONSTRAINT_LEN(C,STR) 1 + /* Now re-define DEFAULT_CONSTRAINT_LEN so that we can verify it is + being used. */ +#undef DEFAULT_CONSTRAINT_LEN +#define DEFAULT_CONSTRAINT_LEN(C,STR) \ + ((C) != *p || STR != p ? -1 : genoutput_default_constraint_len) + return CONSTRAINT_LEN (*p, p); + /* And set it back. */ +#undef DEFAULT_CONSTRAINT_LEN +#define DEFAULT_CONSTRAINT_LEN(C,STR) 1 +}