OSDN Git Service

* gensupport.c (process_one_cond_exec): Derive name for COND_EXEC
[pf3gnuchains/gcc-fork.git] / gcc / gensupport.c
1 /* Support routines for the various generation passes.
2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3    Free Software Foundation, Inc.
4
5    This file is part of GCC.
6
7    GCC is free software; you can redistribute it and/or modify it
8    under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3, or (at your option)
10    any later version.
11
12    GCC is distributed in the hope that it will be useful, but WITHOUT
13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15    License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GCC; see the file COPYING3.  If not see
19    <http://www.gnu.org/licenses/>.  */
20
21 #include "bconfig.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "rtl.h"
26 #include "obstack.h"
27 #include "errors.h"
28 #include "hashtab.h"
29 #include "gensupport.h"
30
31
32 /* In case some macros used by files we include need it, define this here.  */
33 int target_flags;
34
35 int insn_elision = 1;
36
37 const char *in_fname;
38
39 /* This callback will be invoked whenever an rtl include directive is
40    processed.  To be used for creation of the dependency file.  */
41 void (*include_callback) (const char *);
42
43 static struct obstack obstack;
44 struct obstack *rtl_obstack = &obstack;
45
46 static int sequence_num;
47 static int errors;
48
49 static int predicable_default;
50 static const char *predicable_true;
51 static const char *predicable_false;
52
53 static htab_t condition_table;
54
55 static char *base_dir = NULL;
56
57 /* We initially queue all patterns, process the define_insn and
58    define_cond_exec patterns, then return them one at a time.  */
59
60 struct queue_elem
61 {
62   rtx data;
63   const char *filename;
64   int lineno;
65   struct queue_elem *next;
66   /* In a DEFINE_INSN that came from a DEFINE_INSN_AND_SPLIT, SPLIT
67      points to the generated DEFINE_SPLIT.  */
68   struct queue_elem *split;
69 };
70
71 static struct queue_elem *define_attr_queue;
72 static struct queue_elem **define_attr_tail = &define_attr_queue;
73 static struct queue_elem *define_pred_queue;
74 static struct queue_elem **define_pred_tail = &define_pred_queue;
75 static struct queue_elem *define_insn_queue;
76 static struct queue_elem **define_insn_tail = &define_insn_queue;
77 static struct queue_elem *define_cond_exec_queue;
78 static struct queue_elem **define_cond_exec_tail = &define_cond_exec_queue;
79 static struct queue_elem *other_queue;
80 static struct queue_elem **other_tail = &other_queue;
81
82 static struct queue_elem *queue_pattern (rtx, struct queue_elem ***,
83                                          const char *, int);
84
85 /* Current maximum length of directory names in the search path
86    for include files.  (Altered as we get more of them.)  */
87
88 size_t max_include_len;
89
90 struct file_name_list
91   {
92     struct file_name_list *next;
93     const char *fname;
94   };
95
96 struct file_name_list *first_dir_md_include = 0;  /* First dir to search */
97         /* First dir to search for <file> */
98 struct file_name_list *first_bracket_include = 0;
99 struct file_name_list *last_dir_md_include = 0;        /* Last in chain */
100
101 static void remove_constraints (rtx);
102 static void process_rtx (rtx, int);
103
104 static int is_predicable (struct queue_elem *);
105 static void identify_predicable_attribute (void);
106 static int n_alternatives (const char *);
107 static void collect_insn_data (rtx, int *, int *);
108 static rtx alter_predicate_for_insn (rtx, int, int, int);
109 static const char *alter_test_for_insn (struct queue_elem *,
110                                         struct queue_elem *);
111 static char *shift_output_template (char *, const char *, int);
112 static const char *alter_output_for_insn (struct queue_elem *,
113                                           struct queue_elem *,
114                                           int, int);
115 static void process_one_cond_exec (struct queue_elem *);
116 static void process_define_cond_exec (void);
117 static void process_include (rtx, int);
118 static char *save_string (const char *, int);
119 static void init_predicate_table (void);
120 static void record_insn_name (int, const char *);
121 \f
122 void
123 message_with_line (int lineno, const char *msg, ...)
124 {
125   va_list ap;
126
127   va_start (ap, msg);
128
129   fprintf (stderr, "%s:%d: ", read_rtx_filename, lineno);
130   vfprintf (stderr, msg, ap);
131   fputc ('\n', stderr);
132
133   va_end (ap);
134 }
135
136 /* Make a version of gen_rtx_CONST_INT so that GEN_INT can be used in
137    the gensupport programs.  */
138
139 rtx
140 gen_rtx_CONST_INT (enum machine_mode ARG_UNUSED (mode),
141                    HOST_WIDE_INT arg)
142 {
143   rtx rt = rtx_alloc (CONST_INT);
144
145   XWINT (rt, 0) = arg;
146   return rt;
147 }
148 \f
149 /* Queue PATTERN on LIST_TAIL.  Return the address of the new queue
150    element.  */
151
152 static struct queue_elem *
153 queue_pattern (rtx pattern, struct queue_elem ***list_tail,
154                const char *filename, int lineno)
155 {
156   struct queue_elem *e = XNEW(struct queue_elem);
157   e->data = pattern;
158   e->filename = filename;
159   e->lineno = lineno;
160   e->next = NULL;
161   e->split = NULL;
162   **list_tail = e;
163   *list_tail = &e->next;
164   return e;
165 }
166
167 /* Recursively remove constraints from an rtx.  */
168
169 static void
170 remove_constraints (rtx part)
171 {
172   int i, j;
173   const char *format_ptr;
174
175   if (part == 0)
176     return;
177
178   if (GET_CODE (part) == MATCH_OPERAND)
179     XSTR (part, 2) = "";
180   else if (GET_CODE (part) == MATCH_SCRATCH)
181     XSTR (part, 1) = "";
182
183   format_ptr = GET_RTX_FORMAT (GET_CODE (part));
184
185   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
186     switch (*format_ptr++)
187       {
188       case 'e':
189       case 'u':
190         remove_constraints (XEXP (part, i));
191         break;
192       case 'E':
193         if (XVEC (part, i) != NULL)
194           for (j = 0; j < XVECLEN (part, i); j++)
195             remove_constraints (XVECEXP (part, i, j));
196         break;
197       }
198 }
199
200 /* Process an include file assuming that it lives in gcc/config/{target}/
201    if the include looks like (include "file").  */
202
203 static void
204 process_include (rtx desc, int lineno)
205 {
206   const char *filename = XSTR (desc, 0);
207   const char *old_filename;
208   int old_lineno;
209   char *pathname;
210   FILE *input_file;
211
212   /* If specified file name is absolute, skip the include stack.  */
213   if (! IS_ABSOLUTE_PATH (filename))
214     {
215       struct file_name_list *stackp;
216
217       /* Search directory path, trying to open the file.  */
218       for (stackp = first_dir_md_include; stackp; stackp = stackp->next)
219         {
220           static const char sep[2] = { DIR_SEPARATOR, '\0' };
221
222           pathname = concat (stackp->fname, sep, filename, NULL);
223           input_file = fopen (pathname, "r");
224           if (input_file != NULL)
225             goto success;
226           free (pathname);
227         }
228     }
229
230   if (base_dir)
231     pathname = concat (base_dir, filename, NULL);
232   else
233     pathname = xstrdup (filename);
234   input_file = fopen (pathname, "r");
235   if (input_file == NULL)
236     {
237       free (pathname);
238       message_with_line (lineno, "include file `%s' not found", filename);
239       errors = 1;
240       return;
241     }
242  success:
243
244   /* Save old cursor; setup new for the new file.  Note that "lineno" the
245      argument to this function is the beginning of the include statement,
246      while read_rtx_lineno has already been advanced.  */
247   old_filename = read_rtx_filename;
248   old_lineno = read_rtx_lineno;
249   read_rtx_filename = pathname;
250   read_rtx_lineno = 1;
251
252   if (include_callback)
253     include_callback (pathname);
254
255   /* Read the entire file.  */
256   while (read_rtx (input_file, &desc, &lineno))
257     process_rtx (desc, lineno);
258
259   /* Do not free pathname.  It is attached to the various rtx queue
260      elements.  */
261
262   read_rtx_filename = old_filename;
263   read_rtx_lineno = old_lineno;
264
265   fclose (input_file);
266 }
267
268 /* Process a top level rtx in some way, queuing as appropriate.  */
269
270 static void
271 process_rtx (rtx desc, int lineno)
272 {
273   switch (GET_CODE (desc))
274     {
275     case DEFINE_INSN:
276       queue_pattern (desc, &define_insn_tail, read_rtx_filename, lineno);
277       break;
278
279     case DEFINE_COND_EXEC:
280       queue_pattern (desc, &define_cond_exec_tail, read_rtx_filename, lineno);
281       break;
282
283     case DEFINE_ATTR:
284       queue_pattern (desc, &define_attr_tail, read_rtx_filename, lineno);
285       break;
286
287     case DEFINE_PREDICATE:
288     case DEFINE_SPECIAL_PREDICATE:
289     case DEFINE_CONSTRAINT:
290     case DEFINE_REGISTER_CONSTRAINT:
291     case DEFINE_MEMORY_CONSTRAINT:
292     case DEFINE_ADDRESS_CONSTRAINT:
293       queue_pattern (desc, &define_pred_tail, read_rtx_filename, lineno);
294       break;
295
296     case INCLUDE:
297       process_include (desc, lineno);
298       break;
299
300     case DEFINE_INSN_AND_SPLIT:
301       {
302         const char *split_cond;
303         rtx split;
304         rtvec attr;
305         int i;
306         struct queue_elem *insn_elem;
307         struct queue_elem *split_elem;
308
309         /* Create a split with values from the insn_and_split.  */
310         split = rtx_alloc (DEFINE_SPLIT);
311
312         i = XVECLEN (desc, 1);
313         XVEC (split, 0) = rtvec_alloc (i);
314         while (--i >= 0)
315           {
316             XVECEXP (split, 0, i) = copy_rtx (XVECEXP (desc, 1, i));
317             remove_constraints (XVECEXP (split, 0, i));
318           }
319
320         /* If the split condition starts with "&&", append it to the
321            insn condition to create the new split condition.  */
322         split_cond = XSTR (desc, 4);
323         if (split_cond[0] == '&' && split_cond[1] == '&')
324           {
325             copy_rtx_ptr_loc (split_cond + 2, split_cond);
326             split_cond = join_c_conditions (XSTR (desc, 2), split_cond + 2);
327           }
328         XSTR (split, 1) = split_cond;
329         XVEC (split, 2) = XVEC (desc, 5);
330         XSTR (split, 3) = XSTR (desc, 6);
331
332         /* Fix up the DEFINE_INSN.  */
333         attr = XVEC (desc, 7);
334         PUT_CODE (desc, DEFINE_INSN);
335         XVEC (desc, 4) = attr;
336
337         /* Queue them.  */
338         insn_elem
339           = queue_pattern (desc, &define_insn_tail, read_rtx_filename,
340                            lineno);
341         split_elem
342           = queue_pattern (split, &other_tail, read_rtx_filename, lineno);
343         insn_elem->split = split_elem;
344         break;
345       }
346
347     default:
348       queue_pattern (desc, &other_tail, read_rtx_filename, lineno);
349       break;
350     }
351 }
352 \f
353 /* Return true if attribute PREDICABLE is true for ELEM, which holds
354    a DEFINE_INSN.  */
355
356 static int
357 is_predicable (struct queue_elem *elem)
358 {
359   rtvec vec = XVEC (elem->data, 4);
360   const char *value;
361   int i;
362
363   if (! vec)
364     return predicable_default;
365
366   for (i = GET_NUM_ELEM (vec) - 1; i >= 0; --i)
367     {
368       rtx sub = RTVEC_ELT (vec, i);
369       switch (GET_CODE (sub))
370         {
371         case SET_ATTR:
372           if (strcmp (XSTR (sub, 0), "predicable") == 0)
373             {
374               value = XSTR (sub, 1);
375               goto found;
376             }
377           break;
378
379         case SET_ATTR_ALTERNATIVE:
380           if (strcmp (XSTR (sub, 0), "predicable") == 0)
381             {
382               message_with_line (elem->lineno,
383                                  "multiple alternatives for `predicable'");
384               errors = 1;
385               return 0;
386             }
387           break;
388
389         case SET:
390           if (GET_CODE (SET_DEST (sub)) != ATTR
391               || strcmp (XSTR (SET_DEST (sub), 0), "predicable") != 0)
392             break;
393           sub = SET_SRC (sub);
394           if (GET_CODE (sub) == CONST_STRING)
395             {
396               value = XSTR (sub, 0);
397               goto found;
398             }
399
400           /* ??? It would be possible to handle this if we really tried.
401              It's not easy though, and I'm not going to bother until it
402              really proves necessary.  */
403           message_with_line (elem->lineno,
404                              "non-constant value for `predicable'");
405           errors = 1;
406           return 0;
407
408         default:
409           gcc_unreachable ();
410         }
411     }
412
413   return predicable_default;
414
415  found:
416   /* Verify that predicability does not vary on the alternative.  */
417   /* ??? It should be possible to handle this by simply eliminating
418      the non-predicable alternatives from the insn.  FRV would like
419      to do this.  Delay this until we've got the basics solid.  */
420   if (strchr (value, ',') != NULL)
421     {
422       message_with_line (elem->lineno,
423                          "multiple alternatives for `predicable'");
424       errors = 1;
425       return 0;
426     }
427
428   /* Find out which value we're looking at.  */
429   if (strcmp (value, predicable_true) == 0)
430     return 1;
431   if (strcmp (value, predicable_false) == 0)
432     return 0;
433
434   message_with_line (elem->lineno,
435                      "unknown value `%s' for `predicable' attribute",
436                      value);
437   errors = 1;
438   return 0;
439 }
440
441 /* Examine the attribute "predicable"; discover its boolean values
442    and its default.  */
443
444 static void
445 identify_predicable_attribute (void)
446 {
447   struct queue_elem *elem;
448   char *p_true, *p_false;
449   const char *value;
450
451   /* Look for the DEFINE_ATTR for `predicable', which must exist.  */
452   for (elem = define_attr_queue; elem ; elem = elem->next)
453     if (strcmp (XSTR (elem->data, 0), "predicable") == 0)
454       goto found;
455
456   message_with_line (define_cond_exec_queue->lineno,
457                      "attribute `predicable' not defined");
458   errors = 1;
459   return;
460
461  found:
462   value = XSTR (elem->data, 1);
463   p_false = xstrdup (value);
464   p_true = strchr (p_false, ',');
465   if (p_true == NULL || strchr (++p_true, ',') != NULL)
466     {
467       message_with_line (elem->lineno,
468                          "attribute `predicable' is not a boolean");
469       errors = 1;
470       if (p_false)
471         free (p_false);
472       return;
473     }
474   p_true[-1] = '\0';
475
476   predicable_true = p_true;
477   predicable_false = p_false;
478
479   switch (GET_CODE (XEXP (elem->data, 2)))
480     {
481     case CONST_STRING:
482       value = XSTR (XEXP (elem->data, 2), 0);
483       break;
484
485     case CONST:
486       message_with_line (elem->lineno,
487                          "attribute `predicable' cannot be const");
488       errors = 1;
489       if (p_false)
490         free (p_false);
491       return;
492
493     default:
494       message_with_line (elem->lineno,
495                          "attribute `predicable' must have a constant default");
496       errors = 1;
497       if (p_false)
498         free (p_false);
499       return;
500     }
501
502   if (strcmp (value, p_true) == 0)
503     predicable_default = 1;
504   else if (strcmp (value, p_false) == 0)
505     predicable_default = 0;
506   else
507     {
508       message_with_line (elem->lineno,
509                          "unknown value `%s' for `predicable' attribute",
510                          value);
511       errors = 1;
512       if (p_false)
513         free (p_false);
514     }
515 }
516
517 /* Return the number of alternatives in constraint S.  */
518
519 static int
520 n_alternatives (const char *s)
521 {
522   int n = 1;
523
524   if (s)
525     while (*s)
526       n += (*s++ == ',');
527
528   return n;
529 }
530
531 /* Determine how many alternatives there are in INSN, and how many
532    operands.  */
533
534 static void
535 collect_insn_data (rtx pattern, int *palt, int *pmax)
536 {
537   const char *fmt;
538   enum rtx_code code;
539   int i, j, len;
540
541   code = GET_CODE (pattern);
542   switch (code)
543     {
544     case MATCH_OPERAND:
545       i = n_alternatives (XSTR (pattern, 2));
546       *palt = (i > *palt ? i : *palt);
547       /* Fall through.  */
548
549     case MATCH_OPERATOR:
550     case MATCH_SCRATCH:
551     case MATCH_PARALLEL:
552       i = XINT (pattern, 0);
553       if (i > *pmax)
554         *pmax = i;
555       break;
556
557     default:
558       break;
559     }
560
561   fmt = GET_RTX_FORMAT (code);
562   len = GET_RTX_LENGTH (code);
563   for (i = 0; i < len; i++)
564     {
565       switch (fmt[i])
566         {
567         case 'e': case 'u':
568           collect_insn_data (XEXP (pattern, i), palt, pmax);
569           break;
570
571         case 'V':
572           if (XVEC (pattern, i) == NULL)
573             break;
574           /* Fall through.  */
575         case 'E':
576           for (j = XVECLEN (pattern, i) - 1; j >= 0; --j)
577             collect_insn_data (XVECEXP (pattern, i, j), palt, pmax);
578           break;
579
580         case 'i': case 'w': case '0': case 's': case 'S': case 'T':
581           break;
582
583         default:
584           gcc_unreachable ();
585         }
586     }
587 }
588
589 static rtx
590 alter_predicate_for_insn (rtx pattern, int alt, int max_op, int lineno)
591 {
592   const char *fmt;
593   enum rtx_code code;
594   int i, j, len;
595
596   code = GET_CODE (pattern);
597   switch (code)
598     {
599     case MATCH_OPERAND:
600       {
601         const char *c = XSTR (pattern, 2);
602
603         if (n_alternatives (c) != 1)
604           {
605             message_with_line (lineno,
606                                "too many alternatives for operand %d",
607                                XINT (pattern, 0));
608             errors = 1;
609             return NULL;
610           }
611
612         /* Replicate C as needed to fill out ALT alternatives.  */
613         if (c && *c && alt > 1)
614           {
615             size_t c_len = strlen (c);
616             size_t len = alt * (c_len + 1);
617             char *new_c = XNEWVEC(char, len);
618
619             memcpy (new_c, c, c_len);
620             for (i = 1; i < alt; ++i)
621               {
622                 new_c[i * (c_len + 1) - 1] = ',';
623                 memcpy (&new_c[i * (c_len + 1)], c, c_len);
624               }
625             new_c[len - 1] = '\0';
626             XSTR (pattern, 2) = new_c;
627           }
628       }
629       /* Fall through.  */
630
631     case MATCH_OPERATOR:
632     case MATCH_SCRATCH:
633     case MATCH_PARALLEL:
634       XINT (pattern, 0) += max_op;
635       break;
636
637     default:
638       break;
639     }
640
641   fmt = GET_RTX_FORMAT (code);
642   len = GET_RTX_LENGTH (code);
643   for (i = 0; i < len; i++)
644     {
645       rtx r;
646
647       switch (fmt[i])
648         {
649         case 'e': case 'u':
650           r = alter_predicate_for_insn (XEXP (pattern, i), alt,
651                                         max_op, lineno);
652           if (r == NULL)
653             return r;
654           break;
655
656         case 'E':
657           for (j = XVECLEN (pattern, i) - 1; j >= 0; --j)
658             {
659               r = alter_predicate_for_insn (XVECEXP (pattern, i, j),
660                                             alt, max_op, lineno);
661               if (r == NULL)
662                 return r;
663             }
664           break;
665
666         case 'i': case 'w': case '0': case 's':
667           break;
668
669         default:
670           gcc_unreachable ();
671         }
672     }
673
674   return pattern;
675 }
676
677 static const char *
678 alter_test_for_insn (struct queue_elem *ce_elem,
679                      struct queue_elem *insn_elem)
680 {
681   return join_c_conditions (XSTR (ce_elem->data, 1),
682                             XSTR (insn_elem->data, 2));
683 }
684
685 /* Adjust all of the operand numbers in SRC to match the shift they'll
686    get from an operand displacement of DISP.  Return a pointer after the
687    adjusted string.  */
688
689 static char *
690 shift_output_template (char *dest, const char *src, int disp)
691 {
692   while (*src)
693     {
694       char c = *src++;
695       *dest++ = c;
696       if (c == '%')
697         {
698           c = *src++;
699           if (ISDIGIT ((unsigned char) c))
700             c += disp;
701           else if (ISALPHA (c))
702             {
703               *dest++ = c;
704               c = *src++ + disp;
705             }
706           *dest++ = c;
707         }
708     }
709
710   return dest;
711 }
712
713 static const char *
714 alter_output_for_insn (struct queue_elem *ce_elem,
715                        struct queue_elem *insn_elem,
716                        int alt, int max_op)
717 {
718   const char *ce_out, *insn_out;
719   char *result, *p;
720   size_t len, ce_len, insn_len;
721
722   /* ??? Could coordinate with genoutput to not duplicate code here.  */
723
724   ce_out = XSTR (ce_elem->data, 2);
725   insn_out = XTMPL (insn_elem->data, 3);
726   if (!ce_out || *ce_out == '\0')
727     return insn_out;
728
729   ce_len = strlen (ce_out);
730   insn_len = strlen (insn_out);
731
732   if (*insn_out == '*')
733     /* You must take care of the predicate yourself.  */
734     return insn_out;
735
736   if (*insn_out == '@')
737     {
738       len = (ce_len + 1) * alt + insn_len + 1;
739       p = result = XNEWVEC(char, len);
740
741       do
742         {
743           do
744             *p++ = *insn_out++;
745           while (ISSPACE ((unsigned char) *insn_out));
746
747           if (*insn_out != '#')
748             {
749               p = shift_output_template (p, ce_out, max_op);
750               *p++ = ' ';
751             }
752
753           do
754             *p++ = *insn_out++;
755           while (*insn_out && *insn_out != '\n');
756         }
757       while (*insn_out);
758       *p = '\0';
759     }
760   else
761     {
762       len = ce_len + 1 + insn_len + 1;
763       result = XNEWVEC (char, len);
764
765       p = shift_output_template (result, ce_out, max_op);
766       *p++ = ' ';
767       memcpy (p, insn_out, insn_len + 1);
768     }
769
770   return result;
771 }
772
773 /* Replicate insns as appropriate for the given DEFINE_COND_EXEC.  */
774
775 static void
776 process_one_cond_exec (struct queue_elem *ce_elem)
777 {
778   struct queue_elem *insn_elem;
779   for (insn_elem = define_insn_queue; insn_elem ; insn_elem = insn_elem->next)
780     {
781       int alternatives, max_operand;
782       rtx pred, insn, pattern, split;
783       char *new_name;
784       int i;
785
786       if (! is_predicable (insn_elem))
787         continue;
788
789       alternatives = 1;
790       max_operand = -1;
791       collect_insn_data (insn_elem->data, &alternatives, &max_operand);
792       max_operand += 1;
793
794       if (XVECLEN (ce_elem->data, 0) != 1)
795         {
796           message_with_line (ce_elem->lineno,
797                              "too many patterns in predicate");
798           errors = 1;
799           return;
800         }
801
802       pred = copy_rtx (XVECEXP (ce_elem->data, 0, 0));
803       pred = alter_predicate_for_insn (pred, alternatives, max_operand,
804                                        ce_elem->lineno);
805       if (pred == NULL)
806         return;
807
808       /* Construct a new pattern for the new insn.  */
809       insn = copy_rtx (insn_elem->data);
810       new_name = XNEWVAR (char, strlen XSTR (insn_elem->data, 0) + 4);
811       sprintf (new_name, "*p %s", XSTR (insn_elem->data, 0));
812       XSTR (insn, 0) = new_name;
813       pattern = rtx_alloc (COND_EXEC);
814       XEXP (pattern, 0) = pred;
815       if (XVECLEN (insn, 1) == 1)
816         {
817           XEXP (pattern, 1) = XVECEXP (insn, 1, 0);
818           XVECEXP (insn, 1, 0) = pattern;
819           PUT_NUM_ELEM (XVEC (insn, 1), 1);
820         }
821       else
822         {
823           XEXP (pattern, 1) = rtx_alloc (PARALLEL);
824           XVEC (XEXP (pattern, 1), 0) = XVEC (insn, 1);
825           XVEC (insn, 1) = rtvec_alloc (1);
826           XVECEXP (insn, 1, 0) = pattern;
827         }
828
829       XSTR (insn, 2) = alter_test_for_insn (ce_elem, insn_elem);
830       XTMPL (insn, 3) = alter_output_for_insn (ce_elem, insn_elem,
831                                               alternatives, max_operand);
832
833       /* ??? Set `predicable' to false.  Not crucial since it's really
834          only used here, and we won't reprocess this new pattern.  */
835
836       /* Put the new pattern on the `other' list so that it
837          (a) is not reprocessed by other define_cond_exec patterns
838          (b) appears after all normal define_insn patterns.
839
840          ??? B is debatable.  If one has normal insns that match
841          cond_exec patterns, they will be preferred over these
842          generated patterns.  Whether this matters in practice, or if
843          it's a good thing, or whether we should thread these new
844          patterns into the define_insn chain just after their generator
845          is something we'll have to experiment with.  */
846
847       queue_pattern (insn, &other_tail, insn_elem->filename,
848                      insn_elem->lineno);
849
850       if (!insn_elem->split)
851         continue;
852
853       /* If the original insn came from a define_insn_and_split,
854          generate a new split to handle the predicated insn.  */
855       split = copy_rtx (insn_elem->split->data);
856       /* Predicate the pattern matched by the split.  */
857       pattern = rtx_alloc (COND_EXEC);
858       XEXP (pattern, 0) = pred;
859       if (XVECLEN (split, 0) == 1)
860         {
861           XEXP (pattern, 1) = XVECEXP (split, 0, 0);
862           XVECEXP (split, 0, 0) = pattern;
863           PUT_NUM_ELEM (XVEC (split, 0), 1);
864         }
865       else
866         {
867           XEXP (pattern, 1) = rtx_alloc (PARALLEL);
868           XVEC (XEXP (pattern, 1), 0) = XVEC (split, 0);
869           XVEC (split, 0) = rtvec_alloc (1);
870           XVECEXP (split, 0, 0) = pattern;
871         }
872       /* Predicate all of the insns generated by the split.  */
873       for (i = 0; i < XVECLEN (split, 2); i++)
874         {
875           pattern = rtx_alloc (COND_EXEC);
876           XEXP (pattern, 0) = pred;
877           XEXP (pattern, 1) = XVECEXP (split, 2, i);
878           XVECEXP (split, 2, i) = pattern;
879         }
880       /* Add the new split to the queue.  */
881       queue_pattern (split, &other_tail, read_rtx_filename,
882                      insn_elem->split->lineno);
883     }
884 }
885
886 /* If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN
887    patterns appropriately.  */
888
889 static void
890 process_define_cond_exec (void)
891 {
892   struct queue_elem *elem;
893
894   identify_predicable_attribute ();
895   if (errors)
896     return;
897
898   for (elem = define_cond_exec_queue; elem ; elem = elem->next)
899     process_one_cond_exec (elem);
900 }
901
902 static char *
903 save_string (const char *s, int len)
904 {
905   char *result = XNEWVEC (char, len + 1);
906
907   memcpy (result, s, len);
908   result[len] = 0;
909   return result;
910 }
911
912 \f
913 /* The entry point for initializing the reader.  */
914
915 int
916 init_md_reader_args_cb (int argc, char **argv, bool (*parse_opt)(const char *))
917 {
918   FILE *input_file;
919   int c, i, lineno;
920   char *lastsl;
921   rtx desc;
922   bool no_more_options;
923   bool already_read_stdin;
924
925   /* Unlock the stdio streams.  */
926   unlock_std_streams ();
927
928   /* First we loop over all the options.  */
929   for (i = 1; i < argc; i++)
930     {
931       if (argv[i][0] != '-')
932         continue;
933
934       c = argv[i][1];
935       switch (c)
936         {
937         case 'I':               /* Add directory to path for includes.  */
938           {
939             struct file_name_list *dirtmp;
940
941             dirtmp = XNEW (struct file_name_list);
942             dirtmp->next = 0;   /* New one goes on the end */
943             if (first_dir_md_include == 0)
944               first_dir_md_include = dirtmp;
945             else
946               last_dir_md_include->next = dirtmp;
947             last_dir_md_include = dirtmp;       /* Tail follows the last one */
948             if (argv[i][1] == 'I' && argv[i][2] != 0)
949               dirtmp->fname = argv[i] + 2;
950             else if (i + 1 == argc)
951               fatal ("directory name missing after -I option");
952             else
953               dirtmp->fname = argv[++i];
954             if (strlen (dirtmp->fname) > max_include_len)
955               max_include_len = strlen (dirtmp->fname);
956           }
957           break;
958
959         case '\0':
960           /* An argument consisting of exactly one dash is a request to
961              read stdin.  This will be handled in the second loop.  */
962           continue;
963
964         case '-':
965           /* An argument consisting of just two dashes causes option
966              parsing to cease.  */
967           if (argv[i][2] == '\0')
968             goto stop_parsing_options;
969
970         default:
971           /* The program may have provided a callback so it can
972              accept its own options.  */
973           if (parse_opt && parse_opt (argv[i]))
974             break;
975
976           fatal ("invalid option `%s'", argv[i]);
977         }
978     }
979
980  stop_parsing_options:
981
982   /* Prepare to read input.  */
983   condition_table = htab_create (500, hash_c_test, cmp_c_test, NULL);
984   init_predicate_table ();
985   obstack_init (rtl_obstack);
986   errors = 0;
987   sequence_num = 0;
988   no_more_options = false;
989   already_read_stdin = false;
990
991
992   /* Now loop over all input files.  */
993   for (i = 1; i < argc; i++)
994     {
995       if (argv[i][0] == '-')
996         {
997           if (argv[i][1] == '\0')
998             {
999               /* Read stdin.  */
1000               if (already_read_stdin)
1001                 fatal ("cannot read standard input twice");
1002
1003               base_dir = NULL;
1004               read_rtx_filename = in_fname = "<stdin>";
1005               read_rtx_lineno = 1;
1006               input_file = stdin;
1007               already_read_stdin = true;
1008
1009               while (read_rtx (input_file, &desc, &lineno))
1010                 process_rtx (desc, lineno);
1011               fclose (input_file);
1012               continue;
1013             }
1014           else if (argv[i][1] == '-' && argv[i][2] == '\0')
1015             {
1016               /* No further arguments are to be treated as options.  */
1017               no_more_options = true;
1018               continue;
1019             }
1020           else if (!no_more_options)
1021             continue;
1022         }
1023
1024       /* If we get here we are looking at a non-option argument, i.e.
1025          a file to be processed.  */
1026
1027       in_fname = argv[i];
1028       lastsl = strrchr (in_fname, '/');
1029       if (lastsl != NULL)
1030         base_dir = save_string (in_fname, lastsl - in_fname + 1 );
1031       else
1032         base_dir = NULL;
1033
1034       read_rtx_filename = in_fname;
1035       read_rtx_lineno = 1;
1036       input_file = fopen (in_fname, "r");
1037       if (input_file == 0)
1038         {
1039           perror (in_fname);
1040           return FATAL_EXIT_CODE;
1041         }
1042
1043       while (read_rtx (input_file, &desc, &lineno))
1044         process_rtx (desc, lineno);
1045       fclose (input_file);
1046     }
1047
1048   /* If we get to this point without having seen any files to process,
1049      read standard input now.  */
1050   if (!in_fname)
1051     {
1052       base_dir = NULL;
1053       read_rtx_filename = in_fname = "<stdin>";
1054       read_rtx_lineno = 1;
1055       input_file = stdin;
1056
1057       while (read_rtx (input_file, &desc, &lineno))
1058         process_rtx (desc, lineno);
1059       fclose (input_file);
1060     }
1061
1062   /* Process define_cond_exec patterns.  */
1063   if (define_cond_exec_queue != NULL)
1064     process_define_cond_exec ();
1065
1066   return errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
1067 }
1068
1069 /* Programs that don't have their own options can use this entry point
1070    instead.  */
1071 int
1072 init_md_reader_args (int argc, char **argv)
1073 {
1074   return init_md_reader_args_cb (argc, argv, 0);
1075 }
1076 \f
1077 /* The entry point for reading a single rtx from an md file.  */
1078
1079 rtx
1080 read_md_rtx (int *lineno, int *seqnr)
1081 {
1082   struct queue_elem **queue, *elem;
1083   rtx desc;
1084
1085  discard:
1086
1087   /* Read all patterns from a given queue before moving on to the next.  */
1088   if (define_attr_queue != NULL)
1089     queue = &define_attr_queue;
1090   else if (define_pred_queue != NULL)
1091     queue = &define_pred_queue;
1092   else if (define_insn_queue != NULL)
1093     queue = &define_insn_queue;
1094   else if (other_queue != NULL)
1095     queue = &other_queue;
1096   else
1097     return NULL_RTX;
1098
1099   elem = *queue;
1100   *queue = elem->next;
1101   desc = elem->data;
1102   read_rtx_filename = elem->filename;
1103   *lineno = elem->lineno;
1104   *seqnr = sequence_num;
1105
1106   free (elem);
1107
1108   /* Discard insn patterns which we know can never match (because
1109      their C test is provably always false).  If insn_elision is
1110      false, our caller needs to see all the patterns.  Note that the
1111      elided patterns are never counted by the sequence numbering; it
1112      it is the caller's responsibility, when insn_elision is false, not
1113      to use elided pattern numbers for anything.  */
1114   switch (GET_CODE (desc))
1115     {
1116     case DEFINE_INSN:
1117     case DEFINE_EXPAND:
1118       if (maybe_eval_c_test (XSTR (desc, 2)) != 0)
1119         sequence_num++;
1120       else if (insn_elision)
1121         goto discard;
1122
1123       /* *seqnr is used here so the name table will match caller's
1124          idea of insn numbering, whether or not elision is active.  */
1125       record_insn_name (*seqnr, XSTR (desc, 0));
1126       break;
1127
1128     case DEFINE_SPLIT:
1129     case DEFINE_PEEPHOLE:
1130     case DEFINE_PEEPHOLE2:
1131       if (maybe_eval_c_test (XSTR (desc, 1)) != 0)
1132         sequence_num++;
1133       else if (insn_elision)
1134             goto discard;
1135       break;
1136
1137     default:
1138       break;
1139     }
1140
1141   return desc;
1142 }
1143
1144 /* Helper functions for insn elision.  */
1145
1146 /* Compute a hash function of a c_test structure, which is keyed
1147    by its ->expr field.  */
1148 hashval_t
1149 hash_c_test (const void *x)
1150 {
1151   const struct c_test *a = (const struct c_test *) x;
1152   const unsigned char *base, *s = (const unsigned char *) a->expr;
1153   hashval_t hash;
1154   unsigned char c;
1155   unsigned int len;
1156
1157   base = s;
1158   hash = 0;
1159
1160   while ((c = *s++) != '\0')
1161     {
1162       hash += c + (c << 17);
1163       hash ^= hash >> 2;
1164     }
1165
1166   len = s - base;
1167   hash += len + (len << 17);
1168   hash ^= hash >> 2;
1169
1170   return hash;
1171 }
1172
1173 /* Compare two c_test expression structures.  */
1174 int
1175 cmp_c_test (const void *x, const void *y)
1176 {
1177   const struct c_test *a = (const struct c_test *) x;
1178   const struct c_test *b = (const struct c_test *) y;
1179
1180   return !strcmp (a->expr, b->expr);
1181 }
1182
1183 /* Given a string representing a C test expression, look it up in the
1184    condition_table and report whether or not its value is known
1185    at compile time.  Returns a tristate: 1 for known true, 0 for
1186    known false, -1 for unknown.  */
1187 int
1188 maybe_eval_c_test (const char *expr)
1189 {
1190   const struct c_test *test;
1191   struct c_test dummy;
1192
1193   if (expr[0] == 0)
1194     return 1;
1195
1196   dummy.expr = expr;
1197   test = (const struct c_test *)htab_find (condition_table, &dummy);
1198   if (!test)
1199     return -1;
1200   return test->value;
1201 }
1202
1203 /* Record the C test expression EXPR in the condition_table, with
1204    value VAL.  Duplicates clobber previous entries.  */
1205
1206 void
1207 add_c_test (const char *expr, int value)
1208 {
1209   struct c_test *test;
1210
1211   if (expr[0] == 0)
1212     return;
1213
1214   test = XNEW (struct c_test);
1215   test->expr = expr;
1216   test->value = value;
1217
1218   *(htab_find_slot (condition_table, test, INSERT)) = test;
1219 }
1220
1221 /* For every C test, call CALLBACK with two arguments: a pointer to
1222    the condition structure and INFO.  Stops when CALLBACK returns zero.  */
1223 void
1224 traverse_c_tests (htab_trav callback, void *info)
1225 {
1226   if (condition_table)
1227     htab_traverse (condition_table, callback, info);
1228 }
1229
1230
1231 /* Given a string, return the number of comma-separated elements in it.
1232    Return 0 for the null string.  */
1233 int
1234 n_comma_elts (const char *s)
1235 {
1236   int n;
1237
1238   if (*s == '\0')
1239     return 0;
1240
1241   for (n = 1; *s; s++)
1242     if (*s == ',')
1243       n++;
1244
1245   return n;
1246 }
1247
1248 /* Given a pointer to a (char *), return a pointer to the beginning of the
1249    next comma-separated element in the string.  Advance the pointer given
1250    to the end of that element.  Return NULL if at end of string.  Caller
1251    is responsible for copying the string if necessary.  White space between
1252    a comma and an element is ignored.  */
1253
1254 const char *
1255 scan_comma_elt (const char **pstr)
1256 {
1257   const char *start;
1258   const char *p = *pstr;
1259
1260   if (*p == ',')
1261     p++;
1262   while (ISSPACE(*p))
1263     p++;
1264
1265   if (*p == '\0')
1266     return NULL;
1267
1268   start = p;
1269
1270   while (*p != ',' && *p != '\0')
1271     p++;
1272
1273   *pstr = p;
1274   return start;
1275 }
1276
1277 /* Helper functions for define_predicate and define_special_predicate
1278    processing.  Shared between genrecog.c and genpreds.c.  */
1279
1280 static htab_t predicate_table;
1281 struct pred_data *first_predicate;
1282 static struct pred_data **last_predicate = &first_predicate;
1283
1284 static hashval_t
1285 hash_struct_pred_data (const void *ptr)
1286 {
1287   return htab_hash_string (((const struct pred_data *)ptr)->name);
1288 }
1289
1290 static int
1291 eq_struct_pred_data (const void *a, const void *b)
1292 {
1293   return !strcmp (((const struct pred_data *)a)->name,
1294                   ((const struct pred_data *)b)->name);
1295 }
1296
1297 struct pred_data *
1298 lookup_predicate (const char *name)
1299 {
1300   struct pred_data key;
1301   key.name = name;
1302   return (struct pred_data *) htab_find (predicate_table, &key);
1303 }
1304
1305 /* Record that predicate PRED can accept CODE.  */
1306
1307 void
1308 add_predicate_code (struct pred_data *pred, enum rtx_code code)
1309 {
1310   if (!pred->codes[code])
1311     {
1312       pred->num_codes++;
1313       pred->codes[code] = true;
1314
1315       if (GET_RTX_CLASS (code) != RTX_CONST_OBJ)
1316         pred->allows_non_const = true;
1317
1318       if (code != REG
1319           && code != SUBREG
1320           && code != MEM
1321           && code != CONCAT
1322           && code != PARALLEL
1323           && code != STRICT_LOW_PART)
1324         pred->allows_non_lvalue = true;
1325
1326       if (pred->num_codes == 1)
1327         pred->singleton = code;
1328       else if (pred->num_codes == 2)
1329         pred->singleton = UNKNOWN;
1330     }
1331 }
1332
1333 void
1334 add_predicate (struct pred_data *pred)
1335 {
1336   void **slot = htab_find_slot (predicate_table, pred, INSERT);
1337   if (*slot)
1338     {
1339       error ("duplicate predicate definition for '%s'", pred->name);
1340       return;
1341     }
1342   *slot = pred;
1343   *last_predicate = pred;
1344   last_predicate = &pred->next;
1345 }
1346
1347 /* This array gives the initial content of the predicate table.  It
1348    has entries for all predicates defined in recog.c.  */
1349
1350 struct std_pred_table
1351 {
1352   const char *name;
1353   bool special;
1354   bool allows_const_p;
1355   RTX_CODE codes[NUM_RTX_CODE];
1356 };
1357
1358 static const struct std_pred_table std_preds[] = {
1359   {"general_operand", false, true, {SUBREG, REG, MEM}},
1360   {"address_operand", true, true, {SUBREG, REG, MEM, PLUS, MINUS, MULT}},
1361   {"register_operand", false, false, {SUBREG, REG}},
1362   {"pmode_register_operand", true, false, {SUBREG, REG}},
1363   {"scratch_operand", false, false, {SCRATCH, REG}},
1364   {"immediate_operand", false, true, {UNKNOWN}},
1365   {"const_int_operand", false, false, {CONST_INT}},
1366   {"const_double_operand", false, false, {CONST_INT, CONST_DOUBLE}},
1367   {"nonimmediate_operand", false, false, {SUBREG, REG, MEM}},
1368   {"nonmemory_operand", false, true, {SUBREG, REG}},
1369   {"push_operand", false, false, {MEM}},
1370   {"pop_operand", false, false, {MEM}},
1371   {"memory_operand", false, false, {SUBREG, MEM}},
1372   {"indirect_operand", false, false, {SUBREG, MEM}},
1373   {"ordered_comparison_operator", false, false, {EQ, NE,
1374                                                  LE, LT, GE, GT,
1375                                                  LEU, LTU, GEU, GTU}},
1376   {"comparison_operator", false, false, {EQ, NE,
1377                                          LE, LT, GE, GT,
1378                                          LEU, LTU, GEU, GTU,
1379                                          UNORDERED, ORDERED,
1380                                          UNEQ, UNGE, UNGT,
1381                                          UNLE, UNLT, LTGT}}
1382 };
1383 #define NUM_KNOWN_STD_PREDS ARRAY_SIZE (std_preds)
1384
1385 /* Initialize the table of predicate definitions, starting with
1386    the information we have on generic predicates.  */
1387
1388 static void
1389 init_predicate_table (void)
1390 {
1391   size_t i, j;
1392   struct pred_data *pred;
1393
1394   predicate_table = htab_create_alloc (37, hash_struct_pred_data,
1395                                        eq_struct_pred_data, 0,
1396                                        xcalloc, free);
1397
1398   for (i = 0; i < NUM_KNOWN_STD_PREDS; i++)
1399     {
1400       pred = XCNEW (struct pred_data);
1401       pred->name = std_preds[i].name;
1402       pred->special = std_preds[i].special;
1403
1404       for (j = 0; std_preds[i].codes[j] != 0; j++)
1405         add_predicate_code (pred, std_preds[i].codes[j]);
1406
1407       if (std_preds[i].allows_const_p)
1408         for (j = 0; j < NUM_RTX_CODE; j++)
1409           if (GET_RTX_CLASS (j) == RTX_CONST_OBJ)
1410             add_predicate_code (pred, (enum rtx_code) j);
1411
1412       add_predicate (pred);
1413     }
1414 }
1415 \f
1416 /* These functions allow linkage with print-rtl.c.  Also, some generators
1417    like to annotate their output with insn names.  */
1418
1419 /* Holds an array of names indexed by insn_code_number.  */
1420 static char **insn_name_ptr = 0;
1421 static int insn_name_ptr_size = 0;
1422
1423 const char *
1424 get_insn_name (int code)
1425 {
1426   if (code < insn_name_ptr_size)
1427     return insn_name_ptr[code];
1428   else
1429     return NULL;
1430 }
1431
1432 static void
1433 record_insn_name (int code, const char *name)
1434 {
1435   static const char *last_real_name = "insn";
1436   static int last_real_code = 0;
1437   char *new_name;
1438
1439   if (insn_name_ptr_size <= code)
1440     {
1441       int new_size;
1442       new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
1443       insn_name_ptr = XRESIZEVEC (char *, insn_name_ptr, new_size);
1444       memset (insn_name_ptr + insn_name_ptr_size, 0,
1445               sizeof(char *) * (new_size - insn_name_ptr_size));
1446       insn_name_ptr_size = new_size;
1447     }
1448
1449   if (!name || name[0] == '\0')
1450     {
1451       new_name = XNEWVAR (char, strlen (last_real_name) + 10);
1452       sprintf (new_name, "%s+%d", last_real_name, code - last_real_code);
1453     }
1454   else
1455     {
1456       last_real_name = new_name = xstrdup (name);
1457       last_real_code = code;
1458     }
1459
1460   insn_name_ptr[code] = new_name;
1461 }