Mercurial > hg > CbC > CbC_gcc

comparison gcc/gensupport.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 77e2b8dfacca
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
1 /* Support routines for the various generation passes.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
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
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
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
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 int i;
784
785 if (! is_predicable (insn_elem))
786 continue;
787
788 alternatives = 1;
789 max_operand = -1;
790 collect_insn_data (insn_elem->data, &alternatives, &max_operand);
791 max_operand += 1;
792
793 if (XVECLEN (ce_elem->data, 0) != 1)
794 {
795 message_with_line (ce_elem->lineno,
796 "too many patterns in predicate");
797 errors = 1;
798 return;
799 }
800
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;
806
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)
813 {
814 XEXP (pattern, 1) = XVECEXP (insn, 1, 0);
815 XVECEXP (insn, 1, 0) = pattern;
816 PUT_NUM_ELEM (XVEC (insn, 1), 1);
817 }
818 else
819 {
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;
824 }
825
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);
829
830 /* ??? Set `predicable' to false. Not crucial since it's really
831 only used here, and we won't reprocess this new pattern. */
832
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.
836
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. */
843
844 queue_pattern (insn, &other_tail, insn_elem->filename,
845 insn_elem->lineno);
846
847 if (!insn_elem->split)
848 continue;
849
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)
857 {
858 XEXP (pattern, 1) = XVECEXP (split, 0, 0);
859 XVECEXP (split, 0, 0) = pattern;
860 PUT_NUM_ELEM (XVEC (split, 0), 1);
861 }
862 else
863 {
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;
868 }
869 /* Predicate all of the insns generated by the split. */
870 for (i = 0; i < XVECLEN (split, 2); i++)
871 {
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;
876 }
877 /* Add the new split to the queue. */
878 queue_pattern (split, &other_tail, read_rtx_filename,
879 insn_elem->split->lineno);
880 }
881 }
882
883 /* If we have any DEFINE_COND_EXEC patterns, expand the DEFINE_INSN
884 patterns appropriately. */
885
886 static void
887 process_define_cond_exec (void)
888 {
889 struct queue_elem *elem;
890
891 identify_predicable_attribute ();
892 if (errors)
893 return;
894
895 for (elem = define_cond_exec_queue; elem ; elem = elem->next)
896 process_one_cond_exec (elem);
897 }
898
899 static char *
900 save_string (const char *s, int len)
901 {
902 char *result = XNEWVEC (char, len + 1);
903
904 memcpy (result, s, len);
905 result[len] = 0;
906 return result;
907 }
908
909
910 /* The entry point for initializing the reader. */
911
912 int
913 init_md_reader_args_cb (int argc, char **argv, bool (*parse_opt)(const char *))
914 {
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;
921
922 /* Unlock the stdio streams. */
923 unlock_std_streams ();
924
925 /* First we loop over all the options. */
926 for (i = 1; i < argc; i++)
927 {
928 if (argv[i][0] != '-')
929 continue;
930
931 c = argv[i][1];
932 switch (c)
933 {
934 case 'I': /* Add directory to path for includes. */
935 {
936 struct file_name_list *dirtmp;
937
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);
953 }
954 break;
955
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;
960
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;
966
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;
972
973 fatal ("invalid option `%s'", argv[i]);
974 }
975 }
976
977 stop_parsing_options:
978
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;
987
988
989 /* Now loop over all input files. */
990 for (i = 1; i < argc; i++)
991 {
992 if (argv[i][0] == '-')
993 {
994 if (argv[i][1] == '\0')
995 {
996 /* Read stdin. */
997 if (already_read_stdin)
998 fatal ("cannot read standard input twice");
999
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;
1005
1006 while (read_rtx (input_file, &desc, &lineno))
1007 process_rtx (desc, lineno);
1008 fclose (input_file);
1009 continue;
1010 }
1011 else if (argv[i][1] == '-' && argv[i][2] == '\0')
1012 {
1013 /* No further arguments are to be treated as options. */
1014 no_more_options = true;
1015 continue;
1016 }
1017 else if (!no_more_options)
1018 continue;
1019 }
1020
1021 /* If we get here we are looking at a non-option argument, i.e.
1022 a file to be processed. */
1023
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;
1030
1031 read_rtx_filename = in_fname;
1032 read_rtx_lineno = 1;
1033 input_file = fopen (in_fname, "r");
1034 if (input_file == 0)
1035 {
1036 perror (in_fname);
1037 return FATAL_EXIT_CODE;
1038 }
1039
1040 while (read_rtx (input_file, &desc, &lineno))
1041 process_rtx (desc, lineno);
1042 fclose (input_file);
1043 }
1044
1045 /* If we get to this point without having seen any files to process,
1046 read standard input now. */
1047 if (!in_fname)
1048 {
1049 base_dir = NULL;
1050 read_rtx_filename = in_fname = "<stdin>";
1051 read_rtx_lineno = 1;
1052 input_file = stdin;
1053
1054 while (read_rtx (input_file, &desc, &lineno))
1055 process_rtx (desc, lineno);
1056 fclose (input_file);
1057 }
1058
1059 /* Process define_cond_exec patterns. */
1060 if (define_cond_exec_queue != NULL)
1061 process_define_cond_exec ();
1062
1063 return errors ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
1064 }
1065
1066 /* Programs that don't have their own options can use this entry point
1067 instead. */
1068 int
1069 init_md_reader_args (int argc, char **argv)
1070 {
1071 return init_md_reader_args_cb (argc, argv, 0);
1072 }
1073
1074 /* The entry point for reading a single rtx from an md file. */
1075
1076 rtx
1077 read_md_rtx (int *lineno, int *seqnr)
1078 {
1079 struct queue_elem **queue, *elem;
1080 rtx desc;
1081
1082 discard:
1083
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;
1095
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;
1102
1103 free (elem);
1104
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))
1112 {
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;
1119
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;
1124
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;
1133
1134 default:
1135 break;
1136 }
1137
1138 return desc;
1139 }
1140
1141 /* Helper functions for insn elision. */
1142
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)
1147 {
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;
1153
1154 base = s;
1155 hash = 0;
1156
1157 while ((c = *s++) != '\0')
1158 {
1159 hash += c + (c << 17);
1160 hash ^= hash >> 2;
1161 }
1162
1163 len = s - base;
1164 hash += len + (len << 17);
1165 hash ^= hash >> 2;
1166
1167 return hash;
1168 }
1169
1170 /* Compare two c_test expression structures. */
1171 int
1172 cmp_c_test (const void *x, const void *y)
1173 {
1174 const struct c_test *a = (const struct c_test *) x;
1175 const struct c_test *b = (const struct c_test *) y;
1176
1177 return !strcmp (a->expr, b->expr);
1178 }
1179
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. */
1184 int
1185 maybe_eval_c_test (const char *expr)
1186 {
1187 const struct c_test *test;
1188 struct c_test dummy;
1189
1190 if (expr[0] == 0)
1191 return 1;
1192
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;
1198 }
1199
1200 /* Record the C test expression EXPR in the condition_table, with
1201 value VAL. Duplicates clobber previous entries. */
1202
1203 void
1204 add_c_test (const char *expr, int value)
1205 {
1206 struct c_test *test;
1207
1208 if (expr[0] == 0)
1209 return;
1210
1211 test = XNEW (struct c_test);
1212 test->expr = expr;
1213 test->value = value;
1214
1215 *(htab_find_slot (condition_table, test, INSERT)) = test;
1216 }
1217
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)
1222 {
1223 if (condition_table)
1224 htab_traverse (condition_table, callback, info);
1225 }
1226
1227
1228 /* Given a string, return the number of comma-separated elements in it.
1229 Return 0 for the null string. */
1230 int
1231 n_comma_elts (const char *s)
1232 {
1233 int n;
1234
1235 if (*s == '\0')
1236 return 0;
1237
1238 for (n = 1; *s; s++)
1239 if (*s == ',')
1240 n++;
1241
1242 return n;
1243 }
1244
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. */
1250
1251 const char *
1252 scan_comma_elt (const char **pstr)
1253 {
1254 const char *start;
1255 const char *p = *pstr;
1256
1257 if (*p == ',')
1258 p++;
1259 while (ISSPACE(*p))
1260 p++;
1261
1262 if (*p == '\0')
1263 return NULL;
1264
1265 start = p;
1266
1267 while (*p != ',' && *p != '\0')
1268 p++;
1269
1270 *pstr = p;
1271 return start;
1272 }
1273
1274 /* Helper functions for define_predicate and define_special_predicate
1275 processing. Shared between genrecog.c and genpreds.c. */
1276
1277 static htab_t predicate_table;
1278 struct pred_data *first_predicate;
1279 static struct pred_data **last_predicate = &first_predicate;
1280
1281 static hashval_t
1282 hash_struct_pred_data (const void *ptr)
1283 {
1284 return htab_hash_string (((const struct pred_data *)ptr)->name);
1285 }
1286
1287 static int
1288 eq_struct_pred_data (const void *a, const void *b)
1289 {
1290 return !strcmp (((const struct pred_data *)a)->name,
1291 ((const struct pred_data *)b)->name);
1292 }
1293
1294 struct pred_data *
1295 lookup_predicate (const char *name)
1296 {
1297 struct pred_data key;
1298 key.name = name;
1299 return (struct pred_data *) htab_find (predicate_table, &key);
1300 }
1301
1302 /* Record that predicate PRED can accept CODE. */
1303
1304 void
1305 add_predicate_code (struct pred_data *pred, enum rtx_code code)
1306 {
1307 if (!pred->codes[code])
1308 {
1309 pred->num_codes++;
1310 pred->codes[code] = true;
1311
1312 if (GET_RTX_CLASS (code) != RTX_CONST_OBJ)
1313 pred->allows_non_const = true;
1314
1315 if (code != REG
1316 && code != SUBREG
1317 && code != MEM
1318 && code != CONCAT
1319 && code != PARALLEL
1320 && code != STRICT_LOW_PART)
1321 pred->allows_non_lvalue = true;
1322
1323 if (pred->num_codes == 1)
1324 pred->singleton = code;
1325 else if (pred->num_codes == 2)
1326 pred->singleton = UNKNOWN;
1327 }
1328 }
1329
1330 void
1331 add_predicate (struct pred_data *pred)
1332 {
1333 void **slot = htab_find_slot (predicate_table, pred, INSERT);
1334 if (*slot)
1335 {
1336 error ("duplicate predicate definition for '%s'", pred->name);
1337 return;
1338 }
1339 *slot = pred;
1340 *last_predicate = pred;
1341 last_predicate = &pred->next;
1342 }
1343
1344 /* This array gives the initial content of the predicate table. It
1345 has entries for all predicates defined in recog.c. */
1346
1347 struct std_pred_table
1348 {
1349 const char *name;
1350 bool special;
1351 bool allows_const_p;
1352 RTX_CODE codes[NUM_RTX_CODE];
1353 };
1354
1355 static const struct std_pred_table std_preds[] = {
1356 {"general_operand", false, true, {SUBREG, REG, MEM}},
1357 {"address_operand", true, true, {SUBREG, REG, MEM, PLUS, MINUS, MULT}},
1358 {"register_operand", false, false, {SUBREG, REG}},
1359 {"pmode_register_operand", true, false, {SUBREG, REG}},
1360 {"scratch_operand", false, false, {SCRATCH, REG}},
1361 {"immediate_operand", false, true, {0}},
1362 {"const_int_operand", false, false, {CONST_INT}},
1363 {"const_double_operand", false, false, {CONST_INT, CONST_DOUBLE}},
1364 {"nonimmediate_operand", false, false, {SUBREG, REG, MEM}},
1365 {"nonmemory_operand", false, true, {SUBREG, REG}},
1366 {"push_operand", false, false, {MEM}},
1367 {"pop_operand", false, false, {MEM}},
1368 {"memory_operand", false, false, {SUBREG, MEM}},
1369 {"indirect_operand", false, false, {SUBREG, MEM}},
1370 {"comparison_operator", false, false, {EQ, NE,
1371 LE, LT, GE, GT,
1372 LEU, LTU, GEU, GTU,
1373 UNORDERED, ORDERED,
1374 UNEQ, UNGE, UNGT,
1375 UNLE, UNLT, LTGT}}
1376 };
1377 #define NUM_KNOWN_STD_PREDS ARRAY_SIZE (std_preds)
1378
1379 /* Initialize the table of predicate definitions, starting with
1380 the information we have on generic predicates. */
1381
1382 static void
1383 init_predicate_table (void)
1384 {
1385 size_t i, j;
1386 struct pred_data *pred;
1387
1388 predicate_table = htab_create_alloc (37, hash_struct_pred_data,
1389 eq_struct_pred_data, 0,
1390 xcalloc, free);
1391
1392 for (i = 0; i < NUM_KNOWN_STD_PREDS; i++)
1393 {
1394 pred = XCNEW (struct pred_data);
1395 pred->name = std_preds[i].name;
1396 pred->special = std_preds[i].special;
1397
1398 for (j = 0; std_preds[i].codes[j] != 0; j++)
1399 add_predicate_code (pred, std_preds[i].codes[j]);
1400
1401 if (std_preds[i].allows_const_p)
1402 for (j = 0; j < NUM_RTX_CODE; j++)
1403 if (GET_RTX_CLASS (j) == RTX_CONST_OBJ)
1404 add_predicate_code (pred, j);
1405
1406 add_predicate (pred);
1407 }
1408 }
1409
1410 /* These functions allow linkage with print-rtl.c. Also, some generators
1411 like to annotate their output with insn names. */
1412
1413 /* Holds an array of names indexed by insn_code_number. */
1414 static char **insn_name_ptr = 0;
1415 static int insn_name_ptr_size = 0;
1416
1417 const char *
1418 get_insn_name (int code)
1419 {
1420 if (code < insn_name_ptr_size)
1421 return insn_name_ptr[code];
1422 else
1423 return NULL;
1424 }
1425
1426 static void
1427 record_insn_name (int code, const char *name)
1428 {
1429 static const char *last_real_name = "insn";
1430 static int last_real_code = 0;
1431 char *new_name;
1432
1433 if (insn_name_ptr_size <= code)
1434 {
1435 int new_size;
1436 new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
1437 insn_name_ptr = XRESIZEVEC (char *, insn_name_ptr, new_size);
1438 memset (insn_name_ptr + insn_name_ptr_size, 0,
1439 sizeof(char *) * (new_size - insn_name_ptr_size));
1440 insn_name_ptr_size = new_size;
1441 }
1442
1443 if (!name || name[0] == '\0')
1444 {
1445 new_name = XNEWVAR (char, strlen (last_real_name) + 10);
1446 sprintf (new_name, "%s+%d", last_real_name, code - last_real_code);
1447 }
1448 else
1449 {
1450 last_real_name = new_name = xstrdup (name);
1451 last_real_code = code;
1452 }
1453
1454 insn_name_ptr[code] = new_name;
1455 }