Daily bump.
[official-gcc.git] / gcc / gensupport.c
blob7cacfa4540b5551a46170c195942be6e25e0c02e
1 /* Support routines for the various generation passes.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 This file is part of GCC.
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.
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.
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/>. */
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"
32 /* In case some macros used by files we include need it, define this here. */
33 int target_flags;
35 int insn_elision = 1;
37 const char *in_fname;
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 *);
43 static struct obstack obstack;
44 struct obstack *rtl_obstack = &obstack;
46 static int sequence_num;
47 static int errors;
49 static int predicable_default;
50 static const char *predicable_true;
51 static const char *predicable_false;
53 static htab_t condition_table;
55 static char *base_dir = NULL;
57 /* We initially queue all patterns, process the define_insn and
58 define_cond_exec patterns, then return them one at a time. */
60 struct queue_elem
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;
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;
82 static struct queue_elem *queue_pattern (rtx, struct queue_elem ***,
83 const char *, int);
85 /* Current maximum length of directory names in the search path
86 for include files. (Altered as we get more of them.) */
88 size_t max_include_len;
90 struct file_name_list
92 struct file_name_list *next;
93 const char *fname;
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 */
101 static void remove_constraints (rtx);
102 static void process_rtx (rtx, int);
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 *);
122 void
123 message_with_line (int lineno, const char *msg, ...)
125 va_list ap;
127 va_start (ap, msg);
129 fprintf (stderr, "%s:%d: ", read_rtx_filename, lineno);
130 vfprintf (stderr, msg, ap);
131 fputc ('\n', stderr);
133 va_end (ap);
136 /* Make a version of gen_rtx_CONST_INT so that GEN_INT can be used in
137 the gensupport programs. */
140 gen_rtx_CONST_INT (enum machine_mode ARG_UNUSED (mode),
141 HOST_WIDE_INT arg)
143 rtx rt = rtx_alloc (CONST_INT);
145 XWINT (rt, 0) = arg;
146 return rt;
149 /* Queue PATTERN on LIST_TAIL. Return the address of the new queue
150 element. */
152 static struct queue_elem *
153 queue_pattern (rtx pattern, struct queue_elem ***list_tail,
154 const char *filename, int lineno)
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;
167 /* Recursively remove constraints from an rtx. */
169 static void
170 remove_constraints (rtx part)
172 int i, j;
173 const char *format_ptr;
175 if (part == 0)
176 return;
178 if (GET_CODE (part) == MATCH_OPERAND)
179 XSTR (part, 2) = "";
180 else if (GET_CODE (part) == MATCH_SCRATCH)
181 XSTR (part, 1) = "";
183 format_ptr = GET_RTX_FORMAT (GET_CODE (part));
185 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++)
186 switch (*format_ptr++)
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;
200 /* Process an include file assuming that it lives in gcc/config/{target}/
201 if the include looks like (include "file"). */
203 static void
204 process_include (rtx desc, int lineno)
206 const char *filename = XSTR (desc, 0);
207 const char *old_filename;
208 int old_lineno;
209 char *pathname;
210 FILE *input_file;
212 /* If specified file name is absolute, skip the include stack. */
213 if (! IS_ABSOLUTE_PATH (filename))
215 struct file_name_list *stackp;
217 /* Search directory path, trying to open the file. */
218 for (stackp = first_dir_md_include; stackp; stackp = stackp->next)
220 static const char sep[2] = { DIR_SEPARATOR, '\0' };
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);
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)
237 free (pathname);
238 message_with_line (lineno, "include file `%s' not found", filename);
239 errors = 1;
240 return;
242 success:
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;
252 if (include_callback)
253 include_callback (pathname);
255 /* Read the entire file. */
256 while (read_rtx (input_file, &desc, &lineno))
257 process_rtx (desc, lineno);
259 /* Do not free pathname. It is attached to the various rtx queue
260 elements. */
262 read_rtx_filename = old_filename;
263 read_rtx_lineno = old_lineno;
265 fclose (input_file);
268 /* Process a top level rtx in some way, queuing as appropriate. */
270 static void
271 process_rtx (rtx desc, int lineno)
273 switch (GET_CODE (desc))
275 case DEFINE_INSN:
276 queue_pattern (desc, &define_insn_tail, read_rtx_filename, lineno);
277 break;
279 case DEFINE_COND_EXEC:
280 queue_pattern (desc, &define_cond_exec_tail, read_rtx_filename, lineno);
281 break;
283 case DEFINE_ATTR:
284 queue_pattern (desc, &define_attr_tail, read_rtx_filename, lineno);
285 break;
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;
296 case INCLUDE:
297 process_include (desc, lineno);
298 break;
300 case DEFINE_INSN_AND_SPLIT:
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;
309 /* Create a split with values from the insn_and_split. */
310 split = rtx_alloc (DEFINE_SPLIT);
312 i = XVECLEN (desc, 1);
313 XVEC (split, 0) = rtvec_alloc (i);
314 while (--i >= 0)
316 XVECEXP (split, 0, i) = copy_rtx (XVECEXP (desc, 1, i));
317 remove_constraints (XVECEXP (split, 0, i));
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] == '&')
325 copy_rtx_ptr_loc (split_cond + 2, split_cond);
326 split_cond = join_c_conditions (XSTR (desc, 2), split_cond + 2);
328 XSTR (split, 1) = split_cond;
329 XVEC (split, 2) = XVEC (desc, 5);
330 XSTR (split, 3) = XSTR (desc, 6);
332 /* Fix up the DEFINE_INSN. */
333 attr = XVEC (desc, 7);
334 PUT_CODE (desc, DEFINE_INSN);
335 XVEC (desc, 4) = attr;
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;
347 default:
348 queue_pattern (desc, &other_tail, read_rtx_filename, lineno);
349 break;
353 /* Return true if attribute PREDICABLE is true for ELEM, which holds
354 a DEFINE_INSN. */
356 static int
357 is_predicable (struct queue_elem *elem)
359 rtvec vec = XVEC (elem->data, 4);
360 const char *value;
361 int i;
363 if (! vec)
364 return predicable_default;
366 for (i = GET_NUM_ELEM (vec) - 1; i >= 0; --i)
368 rtx sub = RTVEC_ELT (vec, i);
369 switch (GET_CODE (sub))
371 case SET_ATTR:
372 if (strcmp (XSTR (sub, 0), "predicable") == 0)
374 value = XSTR (sub, 1);
375 goto found;
377 break;
379 case SET_ATTR_ALTERNATIVE:
380 if (strcmp (XSTR (sub, 0), "predicable") == 0)
382 message_with_line (elem->lineno,
383 "multiple alternatives for `predicable'");
384 errors = 1;
385 return 0;
387 break;
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)
396 value = XSTR (sub, 0);
397 goto found;
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;
408 default:
409 gcc_unreachable ();
413 return predicable_default;
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)
422 message_with_line (elem->lineno,
423 "multiple alternatives for `predicable'");
424 errors = 1;
425 return 0;
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;
434 message_with_line (elem->lineno,
435 "unknown value `%s' for `predicable' attribute",
436 value);
437 errors = 1;
438 return 0;
441 /* Examine the attribute "predicable"; discover its boolean values
442 and its default. */
444 static void
445 identify_predicable_attribute (void)
447 struct queue_elem *elem;
448 char *p_true, *p_false;
449 const char *value;
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;
456 message_with_line (define_cond_exec_queue->lineno,
457 "attribute `predicable' not defined");
458 errors = 1;
459 return;
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)
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;
474 p_true[-1] = '\0';
476 predicable_true = p_true;
477 predicable_false = p_false;
479 switch (GET_CODE (XEXP (elem->data, 2)))
481 case CONST_STRING:
482 value = XSTR (XEXP (elem->data, 2), 0);
483 break;
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;
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;
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
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);
517 /* Return the number of alternatives in constraint S. */
519 static int
520 n_alternatives (const char *s)
522 int n = 1;
524 if (s)
525 while (*s)
526 n += (*s++ == ',');
528 return n;
531 /* Determine how many alternatives there are in INSN, and how many
532 operands. */
534 static void
535 collect_insn_data (rtx pattern, int *palt, int *pmax)
537 const char *fmt;
538 enum rtx_code code;
539 int i, j, len;
541 code = GET_CODE (pattern);
542 switch (code)
544 case MATCH_OPERAND:
545 i = n_alternatives (XSTR (pattern, 2));
546 *palt = (i > *palt ? i : *palt);
547 /* Fall through. */
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;
557 default:
558 break;
561 fmt = GET_RTX_FORMAT (code);
562 len = GET_RTX_LENGTH (code);
563 for (i = 0; i < len; i++)
565 switch (fmt[i])
567 case 'e': case 'u':
568 collect_insn_data (XEXP (pattern, i), palt, pmax);
569 break;
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;
580 case 'i': case 'w': case '0': case 's': case 'S': case 'T':
581 break;
583 default:
584 gcc_unreachable ();
589 static rtx
590 alter_predicate_for_insn (rtx pattern, int alt, int max_op, int lineno)
592 const char *fmt;
593 enum rtx_code code;
594 int i, j, len;
596 code = GET_CODE (pattern);
597 switch (code)
599 case MATCH_OPERAND:
601 const char *c = XSTR (pattern, 2);
603 if (n_alternatives (c) != 1)
605 message_with_line (lineno,
606 "too many alternatives for operand %d",
607 XINT (pattern, 0));
608 errors = 1;
609 return NULL;
612 /* Replicate C as needed to fill out ALT alternatives. */
613 if (c && *c && alt > 1)
615 size_t c_len = strlen (c);
616 size_t len = alt * (c_len + 1);
617 char *new_c = XNEWVEC(char, len);
619 memcpy (new_c, c, c_len);
620 for (i = 1; i < alt; ++i)
622 new_c[i * (c_len + 1) - 1] = ',';
623 memcpy (&new_c[i * (c_len + 1)], c, c_len);
625 new_c[len - 1] = '\0';
626 XSTR (pattern, 2) = new_c;
629 /* Fall through. */
631 case MATCH_OPERATOR:
632 case MATCH_SCRATCH:
633 case MATCH_PARALLEL:
634 XINT (pattern, 0) += max_op;
635 break;
637 default:
638 break;
641 fmt = GET_RTX_FORMAT (code);
642 len = GET_RTX_LENGTH (code);
643 for (i = 0; i < len; i++)
645 rtx r;
647 switch (fmt[i])
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;
656 case 'E':
657 for (j = XVECLEN (pattern, i) - 1; j >= 0; --j)
659 r = alter_predicate_for_insn (XVECEXP (pattern, i, j),
660 alt, max_op, lineno);
661 if (r == NULL)
662 return r;
664 break;
666 case 'i': case 'w': case '0': case 's':
667 break;
669 default:
670 gcc_unreachable ();
674 return pattern;
677 static const char *
678 alter_test_for_insn (struct queue_elem *ce_elem,
679 struct queue_elem *insn_elem)
681 return join_c_conditions (XSTR (ce_elem->data, 1),
682 XSTR (insn_elem->data, 2));
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. */
689 static char *
690 shift_output_template (char *dest, const char *src, int disp)
692 while (*src)
694 char c = *src++;
695 *dest++ = c;
696 if (c == '%')
698 c = *src++;
699 if (ISDIGIT ((unsigned char) c))
700 c += disp;
701 else if (ISALPHA (c))
703 *dest++ = c;
704 c = *src++ + disp;
706 *dest++ = c;
710 return dest;
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)
718 const char *ce_out, *insn_out;
719 char *result, *p;
720 size_t len, ce_len, insn_len;
722 /* ??? Could coordinate with genoutput to not duplicate code here. */
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;
729 ce_len = strlen (ce_out);
730 insn_len = strlen (insn_out);
732 if (*insn_out == '*')
733 /* You must take care of the predicate yourself. */
734 return insn_out;
736 if (*insn_out == '@')
738 len = (ce_len + 1) * alt + insn_len + 1;
739 p = result = XNEWVEC(char, len);
744 *p++ = *insn_out++;
745 while (ISSPACE ((unsigned char) *insn_out));
747 if (*insn_out != '#')
749 p = shift_output_template (p, ce_out, max_op);
750 *p++ = ' ';
754 *p++ = *insn_out++;
755 while (*insn_out && *insn_out != '\n');
757 while (*insn_out);
758 *p = '\0';
760 else
762 len = ce_len + 1 + insn_len + 1;
763 result = XNEWVEC (char, len);
765 p = shift_output_template (result, ce_out, max_op);
766 *p++ = ' ';
767 memcpy (p, insn_out, insn_len + 1);
770 return result;
773 /* Replicate insns as appropriate for the given DEFINE_COND_EXEC. */
775 static void
776 process_one_cond_exec (struct queue_elem *ce_elem)
778 struct queue_elem *insn_elem;
779 for (insn_elem = define_insn_queue; insn_elem ; insn_elem = insn_elem->next)
781 int alternatives, max_operand;
782 rtx pred, insn, pattern, split;
783 int i;
785 if (! is_predicable (insn_elem))
786 continue;
788 alternatives = 1;
789 max_operand = -1;
790 collect_insn_data (insn_elem->data, &alternatives, &max_operand);
791 max_operand += 1;
793 if (XVECLEN (ce_elem->data, 0) != 1)
795 message_with_line (ce_elem->lineno,
796 "too many patterns in predicate");
797 errors = 1;
798 return;
801 pred = copy_rtx (XVECEXP (ce_elem->data, 0, 0));
802 pred = alter_predicate_for_insn (pred, alternatives, max_operand,
803 ce_elem->lineno);
804 if (pred == NULL)
805 return;
807 /* Construct a new pattern for the new insn. */
808 insn = copy_rtx (insn_elem->data);
809 XSTR (insn, 0) = "";
810 pattern = rtx_alloc (COND_EXEC);
811 XEXP (pattern, 0) = pred;
812 if (XVECLEN (insn, 1) == 1)
814 XEXP (pattern, 1) = XVECEXP (insn, 1, 0);
815 XVECEXP (insn, 1, 0) = pattern;
816 PUT_NUM_ELEM (XVEC (insn, 1), 1);
818 else
820 XEXP (pattern, 1) = rtx_alloc (PARALLEL);
821 XVEC (XEXP (pattern, 1), 0) = XVEC (insn, 1);
822 XVEC (insn, 1) = rtvec_alloc (1);
823 XVECEXP (insn, 1, 0) = pattern;
826 XSTR (insn, 2) = alter_test_for_insn (ce_elem, insn_elem);
827 XTMPL (insn, 3) = alter_output_for_insn (ce_elem, insn_elem,
828 alternatives, max_operand);
830 /* ??? Set `predicable' to false. Not crucial since it's really
831 only used here, and we won't reprocess this new pattern. */
833 /* Put the new pattern on the `other' list so that it
834 (a) is not reprocessed by other define_cond_exec patterns
835 (b) appears after all normal define_insn patterns.
837 ??? B is debatable. If one has normal insns that match
838 cond_exec patterns, they will be preferred over these
839 generated patterns. Whether this matters in practice, or if
840 it's a good thing, or whether we should thread these new
841 patterns into the define_insn chain just after their generator
842 is something we'll have to experiment with. */
844 queue_pattern (insn, &other_tail, insn_elem->filename,
845 insn_elem->lineno);
847 if (!insn_elem->split)
848 continue;
850 /* If the original insn came from a define_insn_and_split,
851 generate a new split to handle the predicated insn. */
852 split = copy_rtx (insn_elem->split->data);
853 /* Predicate the pattern matched by the split. */
854 pattern = rtx_alloc (COND_EXEC);
855 XEXP (pattern, 0) = pred;
856 if (XVECLEN (split, 0) == 1)
858 XEXP (pattern, 1) = XVECEXP (split, 0, 0);
859 XVECEXP (split, 0, 0) = pattern;
860 PUT_NUM_ELEM (XVEC (split, 0), 1);
862 else
864 XEXP (pattern, 1) = rtx_alloc (PARALLEL);
865 XVEC (XEXP (pattern, 1), 0) = XVEC (split, 0);
866 XVEC (split, 0) = rtvec_alloc (1);
867 XVECEXP (split, 0, 0) = pattern;
869 /* Predicate all of the insns generated by the split. */
870 for (i = 0; i < XVECLEN (split, 2); i++)
872 pattern = rtx_alloc (COND_EXEC);
873 XEXP (pattern, 0) = pred;
874 XEXP (pattern, 1) = XVECEXP (split, 2, i);
875 XVECEXP (split, 2, i) = pattern;
877 /* Add the new split to the queue. */
878 queue_pattern (split, &other_tail, read_rtx_filename,
879 insn_elem->split->lineno);
883 /* If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN
884 patterns appropriately. */
886 static void
887 process_define_cond_exec (void)
889 struct queue_elem *elem;
891 identify_predicable_attribute ();
892 if (errors)
893 return;
895 for (elem = define_cond_exec_queue; elem ; elem = elem->next)
896 process_one_cond_exec (elem);
899 static char *
900 save_string (const char *s, int len)
902 char *result = XNEWVEC (char, len + 1);
904 memcpy (result, s, len);
905 result[len] = 0;
906 return result;
910 /* The entry point for initializing the reader. */
913 init_md_reader_args_cb (int argc, char **argv, bool (*parse_opt)(const char *))
915 FILE *input_file;
916 int c, i, lineno;
917 char *lastsl;
918 rtx desc;
919 bool no_more_options;
920 bool already_read_stdin;
922 /* Unlock the stdio streams. */
923 unlock_std_streams ();
925 /* First we loop over all the options. */
926 for (i = 1; i < argc; i++)
928 if (argv[i][0] != '-')
929 continue;
931 c = argv[i][1];
932 switch (c)
934 case 'I': /* Add directory to path for includes. */
936 struct file_name_list *dirtmp;
938 dirtmp = XNEW (struct file_name_list);
939 dirtmp->next = 0; /* New one goes on the end */
940 if (first_dir_md_include == 0)
941 first_dir_md_include = dirtmp;
942 else
943 last_dir_md_include->next = dirtmp;
944 last_dir_md_include = dirtmp; /* Tail follows the last one */
945 if (argv[i][1] == 'I' && argv[i][2] != 0)
946 dirtmp->fname = argv[i] + 2;
947 else if (i + 1 == argc)
948 fatal ("directory name missing after -I option");
949 else
950 dirtmp->fname = argv[++i];
951 if (strlen (dirtmp->fname) > max_include_len)
952 max_include_len = strlen (dirtmp->fname);
954 break;
956 case '\0':
957 /* An argument consisting of exactly one dash is a request to
958 read stdin. This will be handled in the second loop. */
959 continue;
961 case '-':
962 /* An argument consisting of just two dashes causes option
963 parsing to cease. */
964 if (argv[i][2] == '\0')
965 goto stop_parsing_options;
967 default:
968 /* The program may have provided a callback so it can
969 accept its own options. */
970 if (parse_opt && parse_opt (argv[i]))
971 break;
973 fatal ("invalid option `%s'", argv[i]);
977 stop_parsing_options:
979 /* Prepare to read input. */
980 condition_table = htab_create (500, hash_c_test, cmp_c_test, NULL);
981 init_predicate_table ();
982 obstack_init (rtl_obstack);
983 errors = 0;
984 sequence_num = 0;
985 no_more_options = false;
986 already_read_stdin = false;
989 /* Now loop over all input files. */
990 for (i = 1; i < argc; i++)
992 if (argv[i][0] == '-')
994 if (argv[i][1] == '\0')
996 /* Read stdin. */
997 if (already_read_stdin)
998 fatal ("cannot read standard input twice");
1000 base_dir = NULL;
1001 read_rtx_filename = in_fname = "<stdin>";
1002 read_rtx_lineno = 1;
1003 input_file = stdin;
1004 already_read_stdin = true;
1006 while (read_rtx (input_file, &desc, &lineno))
1007 process_rtx (desc, lineno);
1008 fclose (input_file);
1009 continue;
1011 else if (argv[i][1] == '-' && argv[i][2] == '\0')
1013 /* No further arguments are to be treated as options. */
1014 no_more_options = true;
1015 continue;
1017 else if (!no_more_options)
1018 continue;
1021 /* If we get here we are looking at a non-option argument, i.e.
1022 a file to be processed. */
1024 in_fname = argv[i];
1025 lastsl = strrchr (in_fname, '/');
1026 if (lastsl != NULL)
1027 base_dir = save_string (in_fname, lastsl - in_fname + 1 );
1028 else
1029 base_dir = NULL;
1031 read_rtx_filename = in_fname;
1032 read_rtx_lineno = 1;
1033 input_file = fopen (in_fname, "r");
1034 if (input_file == 0)
1036 perror (in_fname);
1037 return FATAL_EXIT_CODE;
1040 while (read_rtx (input_file, &desc, &lineno))
1041 process_rtx (desc, lineno);
1042 fclose (input_file);
1045 /* If we get to this point without having seen any files to process,
1046 read standard input now. */
1047 if (!in_fname)
1049 base_dir = NULL;
1050 read_rtx_filename = in_fname = "<stdin>";
1051 read_rtx_lineno = 1;
1052 input_file = stdin;
1054 while (read_rtx (input_file, &desc, &lineno))
1055 process_rtx (desc, lineno);
1056 fclose (input_file);
1059 /* Process define_cond_exec patterns. */
1060 if (define_cond_exec_queue != NULL)
1061 process_define_cond_exec ();
1063 return errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
1066 /* Programs that don't have their own options can use this entry point
1067 instead. */
1069 init_md_reader_args (int argc, char **argv)
1071 return init_md_reader_args_cb (argc, argv, 0);
1074 /* The entry point for reading a single rtx from an md file. */
1077 read_md_rtx (int *lineno, int *seqnr)
1079 struct queue_elem **queue, *elem;
1080 rtx desc;
1082 discard:
1084 /* Read all patterns from a given queue before moving on to the next. */
1085 if (define_attr_queue != NULL)
1086 queue = &define_attr_queue;
1087 else if (define_pred_queue != NULL)
1088 queue = &define_pred_queue;
1089 else if (define_insn_queue != NULL)
1090 queue = &define_insn_queue;
1091 else if (other_queue != NULL)
1092 queue = &other_queue;
1093 else
1094 return NULL_RTX;
1096 elem = *queue;
1097 *queue = elem->next;
1098 desc = elem->data;
1099 read_rtx_filename = elem->filename;
1100 *lineno = elem->lineno;
1101 *seqnr = sequence_num;
1103 free (elem);
1105 /* Discard insn patterns which we know can never match (because
1106 their C test is provably always false). If insn_elision is
1107 false, our caller needs to see all the patterns. Note that the
1108 elided patterns are never counted by the sequence numbering; it
1109 it is the caller's responsibility, when insn_elision is false, not
1110 to use elided pattern numbers for anything. */
1111 switch (GET_CODE (desc))
1113 case DEFINE_INSN:
1114 case DEFINE_EXPAND:
1115 if (maybe_eval_c_test (XSTR (desc, 2)) != 0)
1116 sequence_num++;
1117 else if (insn_elision)
1118 goto discard;
1120 /* *seqnr is used here so the name table will match caller's
1121 idea of insn numbering, whether or not elision is active. */
1122 record_insn_name (*seqnr, XSTR (desc, 0));
1123 break;
1125 case DEFINE_SPLIT:
1126 case DEFINE_PEEPHOLE:
1127 case DEFINE_PEEPHOLE2:
1128 if (maybe_eval_c_test (XSTR (desc, 1)) != 0)
1129 sequence_num++;
1130 else if (insn_elision)
1131 goto discard;
1132 break;
1134 default:
1135 break;
1138 return desc;
1141 /* Helper functions for insn elision. */
1143 /* Compute a hash function of a c_test structure, which is keyed
1144 by its ->expr field. */
1145 hashval_t
1146 hash_c_test (const void *x)
1148 const struct c_test *a = (const struct c_test *) x;
1149 const unsigned char *base, *s = (const unsigned char *) a->expr;
1150 hashval_t hash;
1151 unsigned char c;
1152 unsigned int len;
1154 base = s;
1155 hash = 0;
1157 while ((c = *s++) != '\0')
1159 hash += c + (c << 17);
1160 hash ^= hash >> 2;
1163 len = s - base;
1164 hash += len + (len << 17);
1165 hash ^= hash >> 2;
1167 return hash;
1170 /* Compare two c_test expression structures. */
1172 cmp_c_test (const void *x, const void *y)
1174 const struct c_test *a = (const struct c_test *) x;
1175 const struct c_test *b = (const struct c_test *) y;
1177 return !strcmp (a->expr, b->expr);
1180 /* Given a string representing a C test expression, look it up in the
1181 condition_table and report whether or not its value is known
1182 at compile time. Returns a tristate: 1 for known true, 0 for
1183 known false, -1 for unknown. */
1185 maybe_eval_c_test (const char *expr)
1187 const struct c_test *test;
1188 struct c_test dummy;
1190 if (expr[0] == 0)
1191 return 1;
1193 dummy.expr = expr;
1194 test = (const struct c_test *)htab_find (condition_table, &dummy);
1195 if (!test)
1196 return -1;
1197 return test->value;
1200 /* Record the C test expression EXPR in the condition_table, with
1201 value VAL. Duplicates clobber previous entries. */
1203 void
1204 add_c_test (const char *expr, int value)
1206 struct c_test *test;
1208 if (expr[0] == 0)
1209 return;
1211 test = XNEW (struct c_test);
1212 test->expr = expr;
1213 test->value = value;
1215 *(htab_find_slot (condition_table, test, INSERT)) = test;
1218 /* For every C test, call CALLBACK with two arguments: a pointer to
1219 the condition structure and INFO. Stops when CALLBACK returns zero. */
1220 void
1221 traverse_c_tests (htab_trav callback, void *info)
1223 if (condition_table)
1224 htab_traverse (condition_table, callback, info);
1228 /* Given a string, return the number of comma-separated elements in it.
1229 Return 0 for the null string. */
1231 n_comma_elts (const char *s)
1233 int n;
1235 if (*s == '\0')
1236 return 0;
1238 for (n = 1; *s; s++)
1239 if (*s == ',')
1240 n++;
1242 return n;
1245 /* Given a pointer to a (char *), return a pointer to the beginning of the
1246 next comma-separated element in the string. Advance the pointer given
1247 to the end of that element. Return NULL if at end of string. Caller
1248 is responsible for copying the string if necessary. White space between
1249 a comma and an element is ignored. */
1251 const char *
1252 scan_comma_elt (const char **pstr)
1254 const char *start;
1255 const char *p = *pstr;
1257 if (*p == ',')
1258 p++;
1259 while (ISSPACE(*p))
1260 p++;
1262 if (*p == '\0')
1263 return NULL;
1265 start = p;
1267 while (*p != ',' && *p != '\0')
1268 p++;
1270 *pstr = p;
1271 return start;
1274 /* Helper functions for define_predicate and define_special_predicate
1275 processing. Shared between genrecog.c and genpreds.c. */
1277 static htab_t predicate_table;
1278 struct pred_data *first_predicate;
1279 static struct pred_data **last_predicate = &first_predicate;
1281 static hashval_t
1282 hash_struct_pred_data (const void *ptr)
1284 return htab_hash_string (((const struct pred_data *)ptr)->name);
1287 static int
1288 eq_struct_pred_data (const void *a, const void *b)
1290 return !strcmp (((const struct pred_data *)a)->name,
1291 ((const struct pred_data *)b)->name);
1294 struct pred_data *
1295 lookup_predicate (const char *name)
1297 struct pred_data key;
1298 key.name = name;
1299 return (struct pred_data *) htab_find (predicate_table, &key);
1302 void
1303 add_predicate (struct pred_data *pred)
1305 void **slot = htab_find_slot (predicate_table, pred, INSERT);
1306 if (*slot)
1308 error ("duplicate predicate definition for '%s'", pred->name);
1309 return;
1311 *slot = pred;
1312 *last_predicate = pred;
1313 last_predicate = &pred->next;
1316 /* This array gives the initial content of the predicate table. It
1317 has entries for all predicates defined in recog.c. */
1319 struct std_pred_table
1321 const char *name;
1322 bool special;
1323 RTX_CODE codes[NUM_RTX_CODE];
1326 static const struct std_pred_table std_preds[] = {
1327 {"general_operand", false, {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
1328 LABEL_REF, SUBREG, REG, MEM }},
1329 {"address_operand", true, {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
1330 LABEL_REF, SUBREG, REG, MEM,
1331 PLUS, MINUS, MULT}},
1332 {"register_operand", false, {SUBREG, REG}},
1333 {"pmode_register_operand", true, {SUBREG, REG}},
1334 {"scratch_operand", false, {SCRATCH, REG}},
1335 {"immediate_operand", false, {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
1336 LABEL_REF}},
1337 {"const_int_operand", false, {CONST_INT}},
1338 {"const_double_operand", false, {CONST_INT, CONST_DOUBLE}},
1339 {"nonimmediate_operand", false, {SUBREG, REG, MEM}},
1340 {"nonmemory_operand", false, {CONST_INT, CONST_DOUBLE, CONST, SYMBOL_REF,
1341 LABEL_REF, SUBREG, REG}},
1342 {"push_operand", false, {MEM}},
1343 {"pop_operand", false, {MEM}},
1344 {"memory_operand", false, {SUBREG, MEM}},
1345 {"indirect_operand", false, {SUBREG, MEM}},
1346 {"comparison_operator", false, {EQ, NE, LE, LT, GE, GT, LEU, LTU, GEU, GTU,
1347 UNORDERED, ORDERED, UNEQ, UNGE, UNGT, UNLE,
1348 UNLT, LTGT}}
1350 #define NUM_KNOWN_STD_PREDS ARRAY_SIZE (std_preds)
1352 /* Initialize the table of predicate definitions, starting with
1353 the information we have on generic predicates. */
1355 static void
1356 init_predicate_table (void)
1358 size_t i, j;
1359 struct pred_data *pred;
1361 predicate_table = htab_create_alloc (37, hash_struct_pred_data,
1362 eq_struct_pred_data, 0,
1363 xcalloc, free);
1365 for (i = 0; i < NUM_KNOWN_STD_PREDS; i++)
1367 pred = XCNEW (struct pred_data);
1368 pred->name = std_preds[i].name;
1369 pred->special = std_preds[i].special;
1371 for (j = 0; std_preds[i].codes[j] != 0; j++)
1373 enum rtx_code code = std_preds[i].codes[j];
1375 pred->codes[code] = true;
1376 if (GET_RTX_CLASS (code) != RTX_CONST_OBJ)
1377 pred->allows_non_const = true;
1378 if (code != REG
1379 && code != SUBREG
1380 && code != MEM
1381 && code != CONCAT
1382 && code != PARALLEL
1383 && code != STRICT_LOW_PART)
1384 pred->allows_non_lvalue = true;
1386 if (j == 1)
1387 pred->singleton = std_preds[i].codes[0];
1389 add_predicate (pred);
1393 /* These functions allow linkage with print-rtl.c. Also, some generators
1394 like to annotate their output with insn names. */
1396 /* Holds an array of names indexed by insn_code_number. */
1397 static char **insn_name_ptr = 0;
1398 static int insn_name_ptr_size = 0;
1400 const char *
1401 get_insn_name (int code)
1403 if (code < insn_name_ptr_size)
1404 return insn_name_ptr[code];
1405 else
1406 return NULL;
1409 static void
1410 record_insn_name (int code, const char *name)
1412 static const char *last_real_name = "insn";
1413 static int last_real_code = 0;
1414 char *new;
1416 if (insn_name_ptr_size <= code)
1418 int new_size;
1419 new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
1420 insn_name_ptr = xrealloc (insn_name_ptr, sizeof(char *) * new_size);
1421 memset (insn_name_ptr + insn_name_ptr_size, 0,
1422 sizeof(char *) * (new_size - insn_name_ptr_size));
1423 insn_name_ptr_size = new_size;
1426 if (!name || name[0] == '\0')
1428 new = xmalloc (strlen (last_real_name) + 10);
1429 sprintf (new, "%s+%d", last_real_name, code - last_real_code);
1431 else
1433 last_real_name = new = xstrdup (name);
1434 last_real_code = code;
1437 insn_name_ptr[code] = new;