Mercurial > hg > CbC > CbC_gcc
annotate gcc/genpreds.c @ 63:b7f97abdc517 gcc-4.6-20100522
update gcc from gcc-4.5.0 to gcc-4.6
author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
---|---|
date | Mon, 24 May 2010 12:47:05 +0900 |
parents | 77e2b8dfacca |
children | f6334be47118 |
rev | line source |
---|---|
0 | 1 /* Generate from machine description: |
2 - prototype declarations for operand predicates (tm-preds.h) | |
3 - function definitions of operand predicates, if defined new-style | |
4 (insn-preds.c) | |
5 Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 | |
6 Free Software Foundation, Inc. | |
7 | |
8 This file is part of GCC. | |
9 | |
10 GCC is free software; you can redistribute it and/or modify | |
11 it under the terms of the GNU General Public License as published by | |
12 the Free Software Foundation; either version 3, or (at your option) | |
13 any later version. | |
14 | |
15 GCC is distributed in the hope that it will be useful, | |
16 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 GNU General Public License for more details. | |
19 | |
20 You should have received a copy of the GNU General Public License | |
21 along with GCC; see the file COPYING3. If not see | |
22 <http://www.gnu.org/licenses/>. */ | |
23 | |
24 #include "bconfig.h" | |
25 #include "system.h" | |
26 #include "coretypes.h" | |
27 #include "tm.h" | |
28 #include "rtl.h" | |
29 #include "errors.h" | |
30 #include "obstack.h" | |
31 #include "gensupport.h" | |
32 | |
33 /* Given a predicate expression EXP, from form NAME at line LINENO, | |
34 verify that it does not contain any RTL constructs which are not | |
35 valid in predicate definitions. Returns true if EXP is | |
36 INvalid; issues error messages, caller need not. */ | |
37 static bool | |
38 validate_exp (rtx exp, const char *name, int lineno) | |
39 { | |
40 if (exp == 0) | |
41 { | |
42 message_with_line (lineno, "%s: must give a predicate expression", name); | |
43 return true; | |
44 } | |
45 | |
46 switch (GET_CODE (exp)) | |
47 { | |
48 /* Ternary, binary, unary expressions: recurse into subexpressions. */ | |
49 case IF_THEN_ELSE: | |
50 if (validate_exp (XEXP (exp, 2), name, lineno)) | |
51 return true; | |
52 /* else fall through */ | |
53 case AND: | |
54 case IOR: | |
55 if (validate_exp (XEXP (exp, 1), name, lineno)) | |
56 return true; | |
57 /* else fall through */ | |
58 case NOT: | |
59 return validate_exp (XEXP (exp, 0), name, lineno); | |
60 | |
61 /* MATCH_CODE might have a syntax error in its path expression. */ | |
62 case MATCH_CODE: | |
63 { | |
64 const char *p; | |
65 for (p = XSTR (exp, 1); *p; p++) | |
66 { | |
67 if (!ISDIGIT (*p) && !ISLOWER (*p)) | |
68 { | |
69 message_with_line (lineno, "%s: invalid character in path " | |
70 "string '%s'", name, XSTR (exp, 1)); | |
71 have_error = 1; | |
72 return true; | |
73 } | |
74 } | |
75 } | |
76 /* fall through */ | |
77 | |
78 /* These need no special checking. */ | |
79 case MATCH_OPERAND: | |
80 case MATCH_TEST: | |
81 return false; | |
82 | |
83 default: | |
84 message_with_line (lineno, | |
85 "%s: cannot use '%s' in a predicate expression", | |
86 name, GET_RTX_NAME (GET_CODE (exp))); | |
87 have_error = 1; | |
88 return true; | |
89 } | |
90 } | |
91 | |
92 /* Predicates are defined with (define_predicate) or | |
93 (define_special_predicate) expressions in the machine description. */ | |
94 static void | |
95 process_define_predicate (rtx defn, int lineno) | |
96 { | |
97 struct pred_data *pred; | |
98 const char *p; | |
99 | |
100 if (!ISALPHA (XSTR (defn, 0)[0]) && XSTR (defn, 0)[0] != '_') | |
101 goto bad_name; | |
102 for (p = XSTR (defn, 0) + 1; *p; p++) | |
103 if (!ISALNUM (*p) && *p != '_') | |
104 goto bad_name; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
105 |
0 | 106 if (validate_exp (XEXP (defn, 1), XSTR (defn, 0), lineno)) |
107 return; | |
108 | |
109 pred = XCNEW (struct pred_data); | |
110 pred->name = XSTR (defn, 0); | |
111 pred->exp = XEXP (defn, 1); | |
112 pred->c_block = XSTR (defn, 2); | |
113 | |
114 if (GET_CODE (defn) == DEFINE_SPECIAL_PREDICATE) | |
115 pred->special = true; | |
116 | |
117 add_predicate (pred); | |
118 return; | |
119 | |
120 bad_name: | |
121 message_with_line (lineno, | |
122 "%s: predicate name must be a valid C function name", | |
123 XSTR (defn, 0)); | |
124 have_error = 1; | |
125 return; | |
126 } | |
127 | |
128 /* Given a predicate, if it has an embedded C block, write the block | |
129 out as a static inline subroutine, and augment the RTL test with a | |
130 match_test that calls that subroutine. For instance, | |
131 | |
132 (define_predicate "basereg_operand" | |
133 (match_operand 0 "register_operand") | |
134 { | |
135 if (GET_CODE (op) == SUBREG) | |
136 op = SUBREG_REG (op); | |
137 return REG_POINTER (op); | |
138 }) | |
139 | |
140 becomes | |
141 | |
142 static inline int basereg_operand_1(rtx op, enum machine_mode mode) | |
143 { | |
144 if (GET_CODE (op) == SUBREG) | |
145 op = SUBREG_REG (op); | |
146 return REG_POINTER (op); | |
147 } | |
148 | |
149 (define_predicate "basereg_operand" | |
150 (and (match_operand 0 "register_operand") | |
151 (match_test "basereg_operand_1 (op, mode)"))) | |
152 | |
153 The only wart is that there's no way to insist on a { } string in | |
154 an RTL template, so we have to handle "" strings. */ | |
155 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
156 |
0 | 157 static void |
158 write_predicate_subfunction (struct pred_data *p) | |
159 { | |
160 const char *match_test_str; | |
161 rtx match_test_exp, and_exp; | |
162 | |
163 if (p->c_block[0] == '\0') | |
164 return; | |
165 | |
166 /* Construct the function-call expression. */ | |
167 obstack_grow (rtl_obstack, p->name, strlen (p->name)); | |
168 obstack_grow (rtl_obstack, "_1 (op, mode)", | |
169 sizeof "_1 (op, mode)"); | |
170 match_test_str = XOBFINISH (rtl_obstack, const char *); | |
171 | |
172 /* Add the function-call expression to the complete expression to be | |
173 evaluated. */ | |
174 match_test_exp = rtx_alloc (MATCH_TEST); | |
175 XSTR (match_test_exp, 0) = match_test_str; | |
176 | |
177 and_exp = rtx_alloc (AND); | |
178 XEXP (and_exp, 0) = p->exp; | |
179 XEXP (and_exp, 1) = match_test_exp; | |
180 | |
181 p->exp = and_exp; | |
182 | |
183 printf ("static inline int\n" | |
184 "%s_1 (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n", | |
185 p->name); | |
186 print_rtx_ptr_loc (p->c_block); | |
187 if (p->c_block[0] == '{') | |
188 fputs (p->c_block, stdout); | |
189 else | |
190 printf ("{\n %s\n}", p->c_block); | |
191 fputs ("\n\n", stdout); | |
192 } | |
193 | |
194 /* Given a predicate expression EXP, from form NAME, determine whether | |
195 it refers to the variable given as VAR. */ | |
196 static bool | |
197 needs_variable (rtx exp, const char *var) | |
198 { | |
199 switch (GET_CODE (exp)) | |
200 { | |
201 /* Ternary, binary, unary expressions need a variable if | |
202 any of their subexpressions do. */ | |
203 case IF_THEN_ELSE: | |
204 if (needs_variable (XEXP (exp, 2), var)) | |
205 return true; | |
206 /* else fall through */ | |
207 case AND: | |
208 case IOR: | |
209 if (needs_variable (XEXP (exp, 1), var)) | |
210 return true; | |
211 /* else fall through */ | |
212 case NOT: | |
213 return needs_variable (XEXP (exp, 0), var); | |
214 | |
215 /* MATCH_CODE uses "op", but nothing else. */ | |
216 case MATCH_CODE: | |
217 return !strcmp (var, "op"); | |
218 | |
219 /* MATCH_OPERAND uses "op" and may use "mode". */ | |
220 case MATCH_OPERAND: | |
221 if (!strcmp (var, "op")) | |
222 return true; | |
223 if (!strcmp (var, "mode") && GET_MODE (exp) == VOIDmode) | |
224 return true; | |
225 return false; | |
226 | |
227 /* MATCH_TEST uses var if XSTR (exp, 0) =~ /\b${var}\b/o; */ | |
228 case MATCH_TEST: | |
229 { | |
230 const char *p = XSTR (exp, 0); | |
231 const char *q = strstr (p, var); | |
232 if (!q) | |
233 return false; | |
234 if (q != p && (ISALNUM (q[-1]) || q[-1] == '_')) | |
235 return false; | |
236 q += strlen (var); | |
237 if (ISALNUM (q[0]) || q[0] == '_') | |
238 return false; | |
239 } | |
240 return true; | |
241 | |
242 default: | |
243 gcc_unreachable (); | |
244 } | |
245 } | |
246 | |
247 /* Given an RTL expression EXP, find all subexpressions which we may | |
248 assume to perform mode tests. Normal MATCH_OPERAND does; | |
249 MATCH_CODE does if it applies to the whole expression and accepts | |
250 CONST_INT or CONST_DOUBLE; and we have to assume that MATCH_TEST | |
251 does not. These combine in almost-boolean fashion - the only | |
252 exception is that (not X) must be assumed not to perform a mode | |
253 test, whether or not X does. | |
254 | |
255 The mark is the RTL /v flag, which is true for subexpressions which | |
256 do *not* perform mode tests. | |
257 */ | |
258 #define NO_MODE_TEST(EXP) RTX_FLAG (EXP, volatil) | |
259 static void | |
260 mark_mode_tests (rtx exp) | |
261 { | |
262 switch (GET_CODE (exp)) | |
263 { | |
264 case MATCH_OPERAND: | |
265 { | |
266 struct pred_data *p = lookup_predicate (XSTR (exp, 1)); | |
267 if (!p) | |
268 error ("reference to undefined predicate '%s'", XSTR (exp, 1)); | |
269 else if (p->special || GET_MODE (exp) != VOIDmode) | |
270 NO_MODE_TEST (exp) = 1; | |
271 } | |
272 break; | |
273 | |
274 case MATCH_CODE: | |
275 if (XSTR (exp, 1)[0] != '\0' | |
276 || (!strstr (XSTR (exp, 0), "const_int") | |
277 && !strstr (XSTR (exp, 0), "const_double"))) | |
278 NO_MODE_TEST (exp) = 1; | |
279 break; | |
280 | |
281 case MATCH_TEST: | |
282 case NOT: | |
283 NO_MODE_TEST (exp) = 1; | |
284 break; | |
285 | |
286 case AND: | |
287 mark_mode_tests (XEXP (exp, 0)); | |
288 mark_mode_tests (XEXP (exp, 1)); | |
289 | |
290 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0)) | |
291 && NO_MODE_TEST (XEXP (exp, 1))); | |
292 break; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
293 |
0 | 294 case IOR: |
295 mark_mode_tests (XEXP (exp, 0)); | |
296 mark_mode_tests (XEXP (exp, 1)); | |
297 | |
298 NO_MODE_TEST (exp) = (NO_MODE_TEST (XEXP (exp, 0)) | |
299 || NO_MODE_TEST (XEXP (exp, 1))); | |
300 break; | |
301 | |
302 case IF_THEN_ELSE: | |
303 /* A ? B : C does a mode test if (one of A and B) does a mode | |
304 test, and C does too. */ | |
305 mark_mode_tests (XEXP (exp, 0)); | |
306 mark_mode_tests (XEXP (exp, 1)); | |
307 mark_mode_tests (XEXP (exp, 2)); | |
308 | |
309 NO_MODE_TEST (exp) = ((NO_MODE_TEST (XEXP (exp, 0)) | |
310 && NO_MODE_TEST (XEXP (exp, 1))) | |
311 || NO_MODE_TEST (XEXP (exp, 2))); | |
312 break; | |
313 | |
314 default: | |
315 gcc_unreachable (); | |
316 } | |
317 } | |
318 | |
319 /* Determine whether the expression EXP is a MATCH_CODE that should | |
320 be written as a switch statement. */ | |
321 static bool | |
322 generate_switch_p (rtx exp) | |
323 { | |
324 return GET_CODE (exp) == MATCH_CODE | |
325 && strchr (XSTR (exp, 0), ','); | |
326 } | |
327 | |
328 /* Given a predicate, work out where in its RTL expression to add | |
329 tests for proper modes. Special predicates do not get any such | |
330 tests. We try to avoid adding tests when we don't have to; in | |
331 particular, other normal predicates can be counted on to do it for | |
332 us. */ | |
333 | |
334 static void | |
335 add_mode_tests (struct pred_data *p) | |
336 { | |
337 rtx match_test_exp, and_exp; | |
338 rtx *pos; | |
339 | |
340 /* Don't touch special predicates. */ | |
341 if (p->special) | |
342 return; | |
343 | |
344 mark_mode_tests (p->exp); | |
345 | |
346 /* If the whole expression already tests the mode, we're done. */ | |
347 if (!NO_MODE_TEST (p->exp)) | |
348 return; | |
349 | |
350 match_test_exp = rtx_alloc (MATCH_TEST); | |
351 XSTR (match_test_exp, 0) = "mode == VOIDmode || GET_MODE (op) == mode"; | |
352 and_exp = rtx_alloc (AND); | |
353 XEXP (and_exp, 1) = match_test_exp; | |
354 | |
355 /* It is always correct to rewrite p->exp as | |
356 | |
357 (and (...) (match_test "mode == VOIDmode || GET_MODE (op) == mode")) | |
358 | |
359 but there are a couple forms where we can do better. If the | |
360 top-level pattern is an IOR, and one of the two branches does test | |
361 the mode, we can wrap just the branch that doesn't. Likewise, if | |
362 we have an IF_THEN_ELSE, and one side of it tests the mode, we can | |
363 wrap just the side that doesn't. And, of course, we can repeat this | |
364 descent as many times as it works. */ | |
365 | |
366 pos = &p->exp; | |
367 for (;;) | |
368 { | |
369 rtx subexp = *pos; | |
370 | |
371 switch (GET_CODE (subexp)) | |
372 { | |
373 case AND: | |
374 /* The switch code generation in write_predicate_stmts prefers | |
375 rtx code tests to be at the top of the expression tree. So | |
376 push this AND down into the second operand of an existing | |
377 AND expression. */ | |
378 if (generate_switch_p (XEXP (subexp, 0))) | |
379 pos = &XEXP (subexp, 1); | |
380 goto break_loop; | |
381 | |
382 case IOR: | |
383 { | |
384 int test0 = NO_MODE_TEST (XEXP (subexp, 0)); | |
385 int test1 = NO_MODE_TEST (XEXP (subexp, 1)); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
386 |
0 | 387 gcc_assert (test0 || test1); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
388 |
0 | 389 if (test0 && test1) |
390 goto break_loop; | |
391 pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1); | |
392 } | |
393 break; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
394 |
0 | 395 case IF_THEN_ELSE: |
396 { | |
397 int test0 = NO_MODE_TEST (XEXP (subexp, 0)); | |
398 int test1 = NO_MODE_TEST (XEXP (subexp, 1)); | |
399 int test2 = NO_MODE_TEST (XEXP (subexp, 2)); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
400 |
0 | 401 gcc_assert ((test0 && test1) || test2); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
402 |
0 | 403 if (test0 && test1 && test2) |
404 goto break_loop; | |
405 if (test0 && test1) | |
406 /* Must put it on the dependent clause, not the | |
407 controlling expression, or we change the meaning of | |
408 the test. */ | |
409 pos = &XEXP (subexp, 1); | |
410 else | |
411 pos = &XEXP (subexp, 2); | |
412 } | |
413 break; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
414 |
0 | 415 default: |
416 goto break_loop; | |
417 } | |
418 } | |
419 break_loop: | |
420 XEXP (and_exp, 0) = *pos; | |
421 *pos = and_exp; | |
422 } | |
423 | |
424 /* PATH is a string describing a path from the root of an RTL | |
425 expression to an inner subexpression to be tested. Output | |
426 code which computes the subexpression from the variable | |
427 holding the root of the expression. */ | |
428 static void | |
429 write_extract_subexp (const char *path) | |
430 { | |
431 int len = strlen (path); | |
432 int i; | |
433 | |
434 /* We first write out the operations (XEXP or XVECEXP) in reverse | |
435 order, then write "op", then the indices in forward order. */ | |
436 for (i = len - 1; i >= 0; i--) | |
437 { | |
438 if (ISLOWER (path[i])) | |
439 fputs ("XVECEXP (", stdout); | |
440 else if (ISDIGIT (path[i])) | |
441 fputs ("XEXP (", stdout); | |
442 else | |
443 gcc_unreachable (); | |
444 } | |
445 | |
446 fputs ("op", stdout); | |
447 | |
448 for (i = 0; i < len; i++) | |
449 { | |
450 if (ISLOWER (path[i])) | |
451 printf (", 0, %d)", path[i] - 'a'); | |
452 else if (ISDIGIT (path[i])) | |
453 printf (", %d)", path[i] - '0'); | |
454 else | |
455 gcc_unreachable (); | |
456 } | |
457 } | |
458 | |
459 /* CODES is a list of RTX codes. Write out an expression which | |
460 determines whether the operand has one of those codes. */ | |
461 static void | |
462 write_match_code (const char *path, const char *codes) | |
463 { | |
464 const char *code; | |
465 | |
466 while ((code = scan_comma_elt (&codes)) != 0) | |
467 { | |
468 fputs ("GET_CODE (", stdout); | |
469 write_extract_subexp (path); | |
470 fputs (") == ", stdout); | |
471 while (code < codes) | |
472 { | |
473 putchar (TOUPPER (*code)); | |
474 code++; | |
475 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
476 |
0 | 477 if (*codes == ',') |
478 fputs (" || ", stdout); | |
479 } | |
480 } | |
481 | |
482 /* EXP is an RTL (sub)expression for a predicate. Recursively | |
483 descend the expression and write out an equivalent C expression. */ | |
484 static void | |
485 write_predicate_expr (rtx exp) | |
486 { | |
487 switch (GET_CODE (exp)) | |
488 { | |
489 case AND: | |
490 putchar ('('); | |
491 write_predicate_expr (XEXP (exp, 0)); | |
492 fputs (") && (", stdout); | |
493 write_predicate_expr (XEXP (exp, 1)); | |
494 putchar (')'); | |
495 break; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
496 |
0 | 497 case IOR: |
498 putchar ('('); | |
499 write_predicate_expr (XEXP (exp, 0)); | |
500 fputs (") || (", stdout); | |
501 write_predicate_expr (XEXP (exp, 1)); | |
502 putchar (')'); | |
503 break; | |
504 | |
505 case NOT: | |
506 fputs ("!(", stdout); | |
507 write_predicate_expr (XEXP (exp, 0)); | |
508 putchar (')'); | |
509 break; | |
510 | |
511 case IF_THEN_ELSE: | |
512 putchar ('('); | |
513 write_predicate_expr (XEXP (exp, 0)); | |
514 fputs (") ? (", stdout); | |
515 write_predicate_expr (XEXP (exp, 1)); | |
516 fputs (") : (", stdout); | |
517 write_predicate_expr (XEXP (exp, 2)); | |
518 putchar (')'); | |
519 break; | |
520 | |
521 case MATCH_OPERAND: | |
522 if (GET_MODE (exp) == VOIDmode) | |
523 printf ("%s (op, mode)", XSTR (exp, 1)); | |
524 else | |
525 printf ("%s (op, %smode)", XSTR (exp, 1), mode_name[GET_MODE (exp)]); | |
526 break; | |
527 | |
528 case MATCH_CODE: | |
529 write_match_code (XSTR (exp, 1), XSTR (exp, 0)); | |
530 break; | |
531 | |
532 case MATCH_TEST: | |
533 print_c_condition (XSTR (exp, 0)); | |
534 break; | |
535 | |
536 default: | |
537 gcc_unreachable (); | |
538 } | |
539 } | |
540 | |
541 /* Write the MATCH_CODE expression EXP as a switch statement. */ | |
542 | |
543 static void | |
544 write_match_code_switch (rtx exp) | |
545 { | |
546 const char *codes = XSTR (exp, 0); | |
547 const char *path = XSTR (exp, 1); | |
548 const char *code; | |
549 | |
550 fputs (" switch (GET_CODE (", stdout); | |
551 write_extract_subexp (path); | |
552 fputs ("))\n {\n", stdout); | |
553 | |
554 while ((code = scan_comma_elt (&codes)) != 0) | |
555 { | |
556 fputs (" case ", stdout); | |
557 while (code < codes) | |
558 { | |
559 putchar (TOUPPER (*code)); | |
560 code++; | |
561 } | |
562 fputs(":\n", stdout); | |
563 } | |
564 } | |
565 | |
566 /* Given a predicate expression EXP, write out a sequence of stmts | |
567 to evaluate it. This is similar to write_predicate_expr but can | |
568 generate efficient switch statements. */ | |
569 | |
570 static void | |
571 write_predicate_stmts (rtx exp) | |
572 { | |
573 switch (GET_CODE (exp)) | |
574 { | |
575 case MATCH_CODE: | |
576 if (generate_switch_p (exp)) | |
577 { | |
578 write_match_code_switch (exp); | |
579 puts (" return true;\n" | |
580 " default:\n" | |
581 " break;\n" | |
582 " }\n" | |
583 " return false;"); | |
584 return; | |
585 } | |
586 break; | |
587 | |
588 case AND: | |
589 if (generate_switch_p (XEXP (exp, 0))) | |
590 { | |
591 write_match_code_switch (XEXP (exp, 0)); | |
592 puts (" break;\n" | |
593 " default:\n" | |
594 " return false;\n" | |
595 " }"); | |
596 exp = XEXP (exp, 1); | |
597 } | |
598 break; | |
599 | |
600 case IOR: | |
601 if (generate_switch_p (XEXP (exp, 0))) | |
602 { | |
603 write_match_code_switch (XEXP (exp, 0)); | |
604 puts (" return true;\n" | |
605 " default:\n" | |
606 " break;\n" | |
607 " }"); | |
608 exp = XEXP (exp, 1); | |
609 } | |
610 break; | |
611 | |
612 case NOT: | |
613 if (generate_switch_p (XEXP (exp, 0))) | |
614 { | |
615 write_match_code_switch (XEXP (exp, 0)); | |
616 puts (" return false;\n" | |
617 " default:\n" | |
618 " break;\n" | |
619 " }\n" | |
620 " return true;"); | |
621 return; | |
622 } | |
623 break; | |
624 | |
625 default: | |
626 break; | |
627 } | |
628 | |
629 fputs(" return ",stdout); | |
630 write_predicate_expr (exp); | |
631 fputs(";\n", stdout); | |
632 } | |
633 | |
634 /* Given a predicate, write out a complete C function to compute it. */ | |
635 static void | |
636 write_one_predicate_function (struct pred_data *p) | |
637 { | |
638 if (!p->exp) | |
639 return; | |
640 | |
641 write_predicate_subfunction (p); | |
642 add_mode_tests (p); | |
643 | |
644 /* A normal predicate can legitimately not look at enum machine_mode | |
645 if it accepts only CONST_INTs and/or CONST_DOUBLEs. */ | |
646 printf ("int\n%s (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)\n{\n", | |
647 p->name); | |
648 write_predicate_stmts (p->exp); | |
649 fputs ("}\n\n", stdout); | |
650 } | |
651 | |
652 /* Constraints fall into two categories: register constraints | |
653 (define_register_constraint), and others (define_constraint, | |
654 define_memory_constraint, define_address_constraint). We | |
655 work out automatically which of the various old-style macros | |
656 they correspond to, and produce appropriate code. They all | |
657 go in the same hash table so we can verify that there are no | |
658 duplicate names. */ | |
659 | |
660 /* All data from one constraint definition. */ | |
661 struct constraint_data | |
662 { | |
663 struct constraint_data *next_this_letter; | |
664 struct constraint_data *next_textual; | |
665 const char *name; | |
666 const char *c_name; /* same as .name unless mangling is necessary */ | |
667 size_t namelen; | |
668 const char *regclass; /* for register constraints */ | |
669 rtx exp; /* for other constraints */ | |
670 unsigned int lineno; /* line of definition */ | |
671 unsigned int is_register : 1; | |
672 unsigned int is_const_int : 1; | |
673 unsigned int is_const_dbl : 1; | |
674 unsigned int is_extra : 1; | |
675 unsigned int is_memory : 1; | |
676 unsigned int is_address : 1; | |
677 }; | |
678 | |
679 /* Overview of all constraints beginning with a given letter. */ | |
680 | |
681 static struct constraint_data * | |
682 constraints_by_letter_table[1<<CHAR_BIT]; | |
683 | |
684 /* For looking up all the constraints in the order that they appeared | |
685 in the machine description. */ | |
686 static struct constraint_data *first_constraint; | |
687 static struct constraint_data **last_constraint_ptr = &first_constraint; | |
688 | |
689 #define FOR_ALL_CONSTRAINTS(iter_) \ | |
690 for (iter_ = first_constraint; iter_; iter_ = iter_->next_textual) | |
691 | |
692 /* These letters, and all names beginning with them, are reserved for | |
693 generic constraints. | |
694 The 'm' constraint is not mentioned here since that constraint | |
695 letter can be overridden by the back end by defining the | |
696 TARGET_MEM_CONSTRAINT macro. */ | |
697 static const char generic_constraint_letters[] = "EFVXginoprs"; | |
698 | |
699 /* Machine-independent code expects that constraints with these | |
700 (initial) letters will allow only (a subset of all) CONST_INTs. */ | |
701 | |
702 static const char const_int_constraints[] = "IJKLMNOP"; | |
703 | |
704 /* Machine-independent code expects that constraints with these | |
705 (initial) letters will allow only (a subset of all) CONST_DOUBLEs. */ | |
706 | |
707 static const char const_dbl_constraints[] = "GH"; | |
708 | |
709 /* Summary data used to decide whether to output various functions and | |
710 macro definitions. */ | |
711 static unsigned int constraint_max_namelen; | |
712 static bool have_register_constraints; | |
713 static bool have_memory_constraints; | |
714 static bool have_address_constraints; | |
715 static bool have_extra_constraints; | |
716 static bool have_const_int_constraints; | |
717 static bool have_const_dbl_constraints; | |
718 | |
719 /* Convert NAME, which contains angle brackets and/or underscores, to | |
720 a string that can be used as part of a C identifier. The string | |
721 comes from the rtl_obstack. */ | |
722 static const char * | |
723 mangle (const char *name) | |
724 { | |
725 for (; *name; name++) | |
726 switch (*name) | |
727 { | |
728 case '_': obstack_grow (rtl_obstack, "__", 2); break; | |
729 case '<': obstack_grow (rtl_obstack, "_l", 2); break; | |
730 case '>': obstack_grow (rtl_obstack, "_g", 2); break; | |
731 default: obstack_1grow (rtl_obstack, *name); break; | |
732 } | |
733 | |
734 obstack_1grow (rtl_obstack, '\0'); | |
735 return XOBFINISH (rtl_obstack, const char *); | |
736 } | |
737 | |
738 /* Add one constraint, of any sort, to the tables. NAME is its name; | |
739 REGCLASS is the register class, if any; EXP is the expression to | |
740 test, if any; IS_MEMORY and IS_ADDRESS indicate memory and address | |
741 constraints, respectively; LINENO is the line number from the MD reader. | |
742 Not all combinations of arguments are valid; most importantly, REGCLASS | |
743 is mutually exclusive with EXP, and IS_MEMORY/IS_ADDRESS are only | |
744 meaningful for constraints with EXP. | |
745 | |
746 This function enforces all syntactic and semantic rules about what | |
747 constraints can be defined. */ | |
748 | |
749 static void | |
750 add_constraint (const char *name, const char *regclass, | |
751 rtx exp, bool is_memory, bool is_address, | |
752 int lineno) | |
753 { | |
754 struct constraint_data *c, **iter, **slot; | |
755 const char *p; | |
756 bool need_mangled_name = false; | |
757 bool is_const_int; | |
758 bool is_const_dbl; | |
759 size_t namelen; | |
760 | |
761 if (exp && validate_exp (exp, name, lineno)) | |
762 return; | |
763 | |
764 if (!ISALPHA (name[0]) && name[0] != '_') | |
765 { | |
766 if (name[1] == '\0') | |
767 message_with_line (lineno, "constraint name '%s' is not " | |
768 "a letter or underscore", name); | |
769 else | |
770 message_with_line (lineno, "constraint name '%s' does not begin " | |
771 "with a letter or underscore", name); | |
772 have_error = 1; | |
773 return; | |
774 } | |
775 for (p = name; *p; p++) | |
776 if (!ISALNUM (*p)) | |
777 { | |
778 if (*p == '<' || *p == '>' || *p == '_') | |
779 need_mangled_name = true; | |
780 else | |
781 { | |
782 message_with_line (lineno, | |
783 "constraint name '%s' must be composed of " | |
784 "letters, digits, underscores, and " | |
785 "angle brackets", name); | |
786 have_error = 1; | |
787 return; | |
788 } | |
789 } | |
790 | |
791 if (strchr (generic_constraint_letters, name[0])) | |
792 { | |
793 if (name[1] == '\0') | |
794 message_with_line (lineno, "constraint letter '%s' cannot be " | |
795 "redefined by the machine description", name); | |
796 else | |
797 message_with_line (lineno, "constraint name '%s' cannot be defined by " | |
798 "the machine description, as it begins with '%c'", | |
799 name, name[0]); | |
800 have_error = 1; | |
801 return; | |
802 } | |
803 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
804 |
0 | 805 namelen = strlen (name); |
806 slot = &constraints_by_letter_table[(unsigned int)name[0]]; | |
807 for (iter = slot; *iter; iter = &(*iter)->next_this_letter) | |
808 { | |
809 /* This causes slot to end up pointing to the | |
810 next_this_letter field of the last constraint with a name | |
811 of equal or greater length than the new constraint; hence | |
812 the new constraint will be inserted after all previous | |
813 constraints with names of the same length. */ | |
814 if ((*iter)->namelen >= namelen) | |
815 slot = iter; | |
816 | |
817 if (!strcmp ((*iter)->name, name)) | |
818 { | |
819 message_with_line (lineno, "redefinition of constraint '%s'", name); | |
820 message_with_line ((*iter)->lineno, "previous definition is here"); | |
821 have_error = 1; | |
822 return; | |
823 } | |
824 else if (!strncmp ((*iter)->name, name, (*iter)->namelen)) | |
825 { | |
826 message_with_line (lineno, "defining constraint '%s' here", name); | |
827 message_with_line ((*iter)->lineno, "renders constraint '%s' " | |
828 "(defined here) a prefix", (*iter)->name); | |
829 have_error = 1; | |
830 return; | |
831 } | |
832 else if (!strncmp ((*iter)->name, name, namelen)) | |
833 { | |
834 message_with_line (lineno, "constraint '%s' is a prefix", name); | |
835 message_with_line ((*iter)->lineno, "of constraint '%s' " | |
836 "(defined here)", (*iter)->name); | |
837 have_error = 1; | |
838 return; | |
839 } | |
840 } | |
841 | |
842 is_const_int = strchr (const_int_constraints, name[0]) != 0; | |
843 is_const_dbl = strchr (const_dbl_constraints, name[0]) != 0; | |
844 | |
845 if (is_const_int || is_const_dbl) | |
846 { | |
847 enum rtx_code appropriate_code | |
848 = is_const_int ? CONST_INT : CONST_DOUBLE; | |
849 | |
850 /* Consider relaxing this requirement in the future. */ | |
851 if (regclass | |
852 || GET_CODE (exp) != AND | |
853 || GET_CODE (XEXP (exp, 0)) != MATCH_CODE | |
854 || strcmp (XSTR (XEXP (exp, 0), 0), | |
855 GET_RTX_NAME (appropriate_code))) | |
856 { | |
857 if (name[1] == '\0') | |
858 message_with_line (lineno, "constraint letter '%c' is reserved " | |
859 "for %s constraints", | |
860 name[0], GET_RTX_NAME (appropriate_code)); | |
861 else | |
862 message_with_line (lineno, "constraint names beginning with '%c' " | |
863 "(%s) are reserved for %s constraints", | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
864 name[0], name, |
0 | 865 GET_RTX_NAME (appropriate_code)); |
866 | |
867 have_error = 1; | |
868 return; | |
869 } | |
870 | |
871 if (is_memory) | |
872 { | |
873 if (name[1] == '\0') | |
874 message_with_line (lineno, "constraint letter '%c' cannot be a " | |
875 "memory constraint", name[0]); | |
876 else | |
877 message_with_line (lineno, "constraint name '%s' begins with '%c', " | |
878 "and therefore cannot be a memory constraint", | |
879 name, name[0]); | |
880 | |
881 have_error = 1; | |
882 return; | |
883 } | |
884 else if (is_address) | |
885 { | |
886 if (name[1] == '\0') | |
887 message_with_line (lineno, "constraint letter '%c' cannot be a " | |
888 "memory constraint", name[0]); | |
889 else | |
890 message_with_line (lineno, "constraint name '%s' begins with '%c', " | |
891 "and therefore cannot be a memory constraint", | |
892 name, name[0]); | |
893 | |
894 have_error = 1; | |
895 return; | |
896 } | |
897 } | |
898 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
899 |
0 | 900 c = XOBNEW (rtl_obstack, struct constraint_data); |
901 c->name = name; | |
902 c->c_name = need_mangled_name ? mangle (name) : name; | |
903 c->lineno = lineno; | |
904 c->namelen = namelen; | |
905 c->regclass = regclass; | |
906 c->exp = exp; | |
907 c->is_register = regclass != 0; | |
908 c->is_const_int = is_const_int; | |
909 c->is_const_dbl = is_const_dbl; | |
910 c->is_extra = !(regclass || is_const_int || is_const_dbl); | |
911 c->is_memory = is_memory; | |
912 c->is_address = is_address; | |
913 | |
914 c->next_this_letter = *slot; | |
915 *slot = c; | |
916 | |
917 /* Insert this constraint in the list of all constraints in textual | |
918 order. */ | |
919 c->next_textual = 0; | |
920 *last_constraint_ptr = c; | |
921 last_constraint_ptr = &c->next_textual; | |
922 | |
923 constraint_max_namelen = MAX (constraint_max_namelen, strlen (name)); | |
924 have_register_constraints |= c->is_register; | |
925 have_const_int_constraints |= c->is_const_int; | |
926 have_const_dbl_constraints |= c->is_const_dbl; | |
927 have_extra_constraints |= c->is_extra; | |
928 have_memory_constraints |= c->is_memory; | |
929 have_address_constraints |= c->is_address; | |
930 } | |
931 | |
932 /* Process a DEFINE_CONSTRAINT, DEFINE_MEMORY_CONSTRAINT, or | |
933 DEFINE_ADDRESS_CONSTRAINT expression, C. */ | |
934 static void | |
935 process_define_constraint (rtx c, int lineno) | |
936 { | |
937 add_constraint (XSTR (c, 0), 0, XEXP (c, 2), | |
938 GET_CODE (c) == DEFINE_MEMORY_CONSTRAINT, | |
939 GET_CODE (c) == DEFINE_ADDRESS_CONSTRAINT, | |
940 lineno); | |
941 } | |
942 | |
943 /* Process a DEFINE_REGISTER_CONSTRAINT expression, C. */ | |
944 static void | |
945 process_define_register_constraint (rtx c, int lineno) | |
946 { | |
947 add_constraint (XSTR (c, 0), XSTR (c, 1), 0, false, false, lineno); | |
948 } | |
949 | |
950 /* Write out an enumeration with one entry per machine-specific | |
951 constraint. */ | |
952 static void | |
953 write_enum_constraint_num (void) | |
954 { | |
955 struct constraint_data *c; | |
956 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
957 fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout); |
0 | 958 fputs ("enum constraint_num\n" |
959 "{\n" | |
960 " CONSTRAINT__UNKNOWN = 0", stdout); | |
961 FOR_ALL_CONSTRAINTS (c) | |
962 printf (",\n CONSTRAINT_%s", c->c_name); | |
963 puts (",\n CONSTRAINT__LIMIT\n};\n"); | |
964 } | |
965 | |
966 /* Write out a function which looks at a string and determines what | |
967 constraint name, if any, it begins with. */ | |
968 static void | |
969 write_lookup_constraint (void) | |
970 { | |
971 unsigned int i; | |
972 puts ("enum constraint_num\n" | |
973 "lookup_constraint (const char *str)\n" | |
974 "{\n" | |
975 " switch (str[0])\n" | |
976 " {"); | |
977 | |
978 for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++) | |
979 { | |
980 struct constraint_data *c = constraints_by_letter_table[i]; | |
981 if (!c) | |
982 continue; | |
983 | |
984 printf (" case '%c':\n", i); | |
985 if (c->namelen == 1) | |
986 printf (" return CONSTRAINT_%s;\n", c->c_name); | |
987 else | |
988 { | |
989 do | |
990 { | |
991 printf (" if (!strncmp (str, \"%s\", %lu))\n" | |
992 " return CONSTRAINT_%s;\n", | |
993 c->name, (unsigned long int) c->namelen, c->c_name); | |
994 c = c->next_this_letter; | |
995 } | |
996 while (c); | |
997 puts (" break;"); | |
998 } | |
999 } | |
1000 | |
1001 puts (" default: break;\n" | |
1002 " }\n" | |
1003 " return CONSTRAINT__UNKNOWN;\n" | |
1004 "}\n"); | |
1005 } | |
1006 | |
1007 /* Write out a function which looks at a string and determines what | |
1008 the constraint name length is. */ | |
1009 static void | |
1010 write_insn_constraint_len (void) | |
1011 { | |
1012 unsigned int i; | |
1013 | |
1014 puts ("static inline size_t\n" | |
1015 "insn_constraint_len (char fc, const char *str ATTRIBUTE_UNUSED)\n" | |
1016 "{\n" | |
1017 " switch (fc)\n" | |
1018 " {"); | |
1019 | |
1020 for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++) | |
1021 { | |
1022 struct constraint_data *c = constraints_by_letter_table[i]; | |
1023 | |
1024 if (!c | |
1025 || c->namelen == 1) | |
1026 continue; | |
1027 | |
1028 /* Constraints with multiple characters should have the same | |
1029 length. */ | |
1030 { | |
1031 struct constraint_data *c2 = c->next_this_letter; | |
1032 size_t len = c->namelen; | |
1033 while (c2) | |
1034 { | |
1035 if (c2->namelen != len) | |
1036 error ("Multi-letter constraints with first letter '%c' " | |
1037 "should have same length", i); | |
1038 c2 = c2->next_this_letter; | |
1039 } | |
1040 } | |
1041 | |
1042 printf (" case '%c': return %lu;\n", | |
1043 i, (unsigned long int) c->namelen); | |
1044 } | |
1045 | |
1046 puts (" default: break;\n" | |
1047 " }\n" | |
1048 " return 1;\n" | |
1049 "}\n"); | |
1050 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1051 |
0 | 1052 /* Write out the function which computes the register class corresponding |
1053 to a register constraint. */ | |
1054 static void | |
1055 write_regclass_for_constraint (void) | |
1056 { | |
1057 struct constraint_data *c; | |
1058 | |
1059 puts ("enum reg_class\n" | |
1060 "regclass_for_constraint (enum constraint_num c)\n" | |
1061 "{\n" | |
1062 " switch (c)\n" | |
1063 " {"); | |
1064 | |
1065 FOR_ALL_CONSTRAINTS (c) | |
1066 if (c->is_register) | |
1067 printf (" case CONSTRAINT_%s: return %s;\n", c->c_name, c->regclass); | |
1068 | |
1069 puts (" default: break;\n" | |
1070 " }\n" | |
1071 " return NO_REGS;\n" | |
1072 "}\n"); | |
1073 } | |
1074 | |
1075 /* Write out the functions which compute whether a given value matches | |
1076 a given non-register constraint. */ | |
1077 static void | |
1078 write_tm_constrs_h (void) | |
1079 { | |
1080 struct constraint_data *c; | |
1081 | |
1082 printf ("\ | |
1083 /* Generated automatically by the program '%s'\n\ | |
1084 from the machine description file '%s'. */\n\n", progname, in_fname); | |
1085 | |
1086 puts ("\ | |
1087 #ifndef GCC_TM_CONSTRS_H\n\ | |
1088 #define GCC_TM_CONSTRS_H\n"); | |
1089 | |
1090 FOR_ALL_CONSTRAINTS (c) | |
1091 if (!c->is_register) | |
1092 { | |
1093 bool needs_ival = needs_variable (c->exp, "ival"); | |
1094 bool needs_hval = needs_variable (c->exp, "hval"); | |
1095 bool needs_lval = needs_variable (c->exp, "lval"); | |
1096 bool needs_rval = needs_variable (c->exp, "rval"); | |
1097 bool needs_mode = (needs_variable (c->exp, "mode") | |
1098 || needs_hval || needs_lval || needs_rval); | |
1099 bool needs_op = (needs_variable (c->exp, "op") | |
1100 || needs_ival || needs_mode); | |
1101 | |
1102 printf ("static inline bool\n" | |
1103 "satisfies_constraint_%s (rtx %s)\n" | |
1104 "{\n", c->c_name, | |
1105 needs_op ? "op" : "ARG_UNUSED (op)"); | |
1106 if (needs_mode) | |
1107 puts (" enum machine_mode mode = GET_MODE (op);"); | |
1108 if (needs_ival) | |
1109 puts (" HOST_WIDE_INT ival = 0;"); | |
1110 if (needs_hval) | |
1111 puts (" HOST_WIDE_INT hval = 0;"); | |
1112 if (needs_lval) | |
1113 puts (" unsigned HOST_WIDE_INT lval = 0;"); | |
1114 if (needs_rval) | |
1115 puts (" const REAL_VALUE_TYPE *rval = 0;"); | |
1116 | |
1117 if (needs_ival) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1118 puts (" if (CONST_INT_P (op))\n" |
0 | 1119 " ival = INTVAL (op);"); |
1120 if (needs_hval) | |
1121 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)" | |
1122 " hval = CONST_DOUBLE_HIGH (op);"); | |
1123 if (needs_lval) | |
1124 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode == VOIDmode)" | |
1125 " lval = CONST_DOUBLE_LOW (op);"); | |
1126 if (needs_rval) | |
1127 puts (" if (GET_CODE (op) == CONST_DOUBLE && mode != VOIDmode)" | |
1128 " rval = CONST_DOUBLE_REAL_VALUE (op);"); | |
1129 | |
1130 write_predicate_stmts (c->exp); | |
1131 fputs ("}\n", stdout); | |
1132 } | |
1133 puts ("#endif /* tm-constrs.h */"); | |
1134 } | |
1135 | |
1136 /* Write out the wrapper function, constraint_satisfied_p, that maps | |
1137 a CONSTRAINT_xxx constant to one of the predicate functions generated | |
1138 above. */ | |
1139 static void | |
1140 write_constraint_satisfied_p (void) | |
1141 { | |
1142 struct constraint_data *c; | |
1143 | |
1144 puts ("bool\n" | |
1145 "constraint_satisfied_p (rtx op, enum constraint_num c)\n" | |
1146 "{\n" | |
1147 " switch (c)\n" | |
1148 " {"); | |
1149 | |
1150 FOR_ALL_CONSTRAINTS (c) | |
1151 if (!c->is_register) | |
1152 printf (" case CONSTRAINT_%s: " | |
1153 "return satisfies_constraint_%s (op);\n", | |
1154 c->c_name, c->c_name); | |
1155 | |
1156 puts (" default: break;\n" | |
1157 " }\n" | |
1158 " return false;\n" | |
1159 "}\n"); | |
1160 } | |
1161 | |
1162 /* Write out the function which computes whether a given value matches | |
1163 a given CONST_INT constraint. This doesn't just forward to | |
1164 constraint_satisfied_p because caller passes the INTVAL, not the RTX. */ | |
1165 static void | |
1166 write_insn_const_int_ok_for_constraint (void) | |
1167 { | |
1168 struct constraint_data *c; | |
1169 | |
1170 puts ("bool\n" | |
1171 "insn_const_int_ok_for_constraint (HOST_WIDE_INT ival, " | |
1172 "enum constraint_num c)\n" | |
1173 "{\n" | |
1174 " switch (c)\n" | |
1175 " {"); | |
1176 | |
1177 FOR_ALL_CONSTRAINTS (c) | |
1178 if (c->is_const_int) | |
1179 { | |
1180 printf (" case CONSTRAINT_%s:\n return ", c->c_name); | |
1181 /* c->exp is guaranteed to be (and (match_code "const_int") (...)); | |
1182 we know at this point that we have a const_int, so we need not | |
1183 bother with that part of the test. */ | |
1184 write_predicate_expr (XEXP (c->exp, 1)); | |
1185 fputs (";\n\n", stdout); | |
1186 } | |
1187 | |
1188 puts (" default: break;\n" | |
1189 " }\n" | |
1190 " return false;\n" | |
1191 "}\n"); | |
1192 } | |
1193 | |
1194 | |
1195 /* Write out the function which computes whether a given constraint is | |
1196 a memory constraint. */ | |
1197 static void | |
1198 write_insn_extra_memory_constraint (void) | |
1199 { | |
1200 struct constraint_data *c; | |
1201 | |
1202 puts ("bool\n" | |
1203 "insn_extra_memory_constraint (enum constraint_num c)\n" | |
1204 "{\n" | |
1205 " switch (c)\n" | |
1206 " {"); | |
1207 | |
1208 FOR_ALL_CONSTRAINTS (c) | |
1209 if (c->is_memory) | |
1210 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name); | |
1211 | |
1212 puts (" default: break;\n" | |
1213 " }\n" | |
1214 " return false;\n" | |
1215 "}\n"); | |
1216 } | |
1217 | |
1218 /* Write out the function which computes whether a given constraint is | |
1219 an address constraint. */ | |
1220 static void | |
1221 write_insn_extra_address_constraint (void) | |
1222 { | |
1223 struct constraint_data *c; | |
1224 | |
1225 puts ("bool\n" | |
1226 "insn_extra_address_constraint (enum constraint_num c)\n" | |
1227 "{\n" | |
1228 " switch (c)\n" | |
1229 " {"); | |
1230 | |
1231 FOR_ALL_CONSTRAINTS (c) | |
1232 if (c->is_address) | |
1233 printf (" case CONSTRAINT_%s:\n return true;\n\n", c->c_name); | |
1234 | |
1235 puts (" default: break;\n" | |
1236 " }\n" | |
1237 " return false;\n" | |
1238 "}\n"); | |
1239 } | |
1240 | |
1241 | |
1242 /* Write tm-preds.h. Unfortunately, it is impossible to forward-declare | |
1243 an enumeration in portable C, so we have to condition all these | |
1244 prototypes on HAVE_MACHINE_MODES. */ | |
1245 static void | |
1246 write_tm_preds_h (void) | |
1247 { | |
1248 struct pred_data *p; | |
1249 | |
1250 printf ("\ | |
1251 /* Generated automatically by the program '%s'\n\ | |
1252 from the machine description file '%s'. */\n\n", progname, in_fname); | |
1253 | |
1254 puts ("\ | |
1255 #ifndef GCC_TM_PREDS_H\n\ | |
1256 #define GCC_TM_PREDS_H\n\ | |
1257 \n\ | |
1258 #ifdef HAVE_MACHINE_MODES"); | |
1259 | |
1260 FOR_ALL_PREDICATES (p) | |
1261 printf ("extern int %s (rtx, enum machine_mode);\n", p->name); | |
1262 | |
1263 puts ("#endif /* HAVE_MACHINE_MODES */\n"); | |
1264 | |
1265 if (constraint_max_namelen > 0) | |
1266 { | |
1267 write_enum_constraint_num (); | |
1268 puts ("extern enum constraint_num lookup_constraint (const char *);\n" | |
1269 "extern bool constraint_satisfied_p (rtx, enum constraint_num);\n"); | |
1270 | |
1271 if (constraint_max_namelen > 1) | |
1272 { | |
1273 write_insn_constraint_len (); | |
1274 puts ("#define CONSTRAINT_LEN(c_,s_) " | |
1275 "insn_constraint_len (c_,s_)\n"); | |
1276 } | |
1277 else | |
1278 puts ("#define CONSTRAINT_LEN(c_,s_) 1\n"); | |
1279 if (have_register_constraints) | |
1280 puts ("extern enum reg_class regclass_for_constraint " | |
1281 "(enum constraint_num);\n" | |
1282 "#define REG_CLASS_FROM_CONSTRAINT(c_,s_) \\\n" | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1283 " regclass_for_constraint (lookup_constraint (s_))\n" |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1284 "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n" |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1285 " regclass_for_constraint (x_)\n"); |
0 | 1286 else |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1287 puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS\n" |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1288 "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n" |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1289 " NO_REGS\n"); |
0 | 1290 if (have_const_int_constraints) |
1291 puts ("extern bool insn_const_int_ok_for_constraint " | |
1292 "(HOST_WIDE_INT, enum constraint_num);\n" | |
1293 "#define CONST_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n" | |
1294 " insn_const_int_ok_for_constraint (v_, " | |
1295 "lookup_constraint (s_))\n"); | |
1296 if (have_const_dbl_constraints) | |
1297 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) \\\n" | |
1298 " constraint_satisfied_p (v_, lookup_constraint (s_))\n"); | |
1299 else | |
1300 puts ("#define CONST_DOUBLE_OK_FOR_CONSTRAINT_P(v_,c_,s_) 0\n"); | |
1301 if (have_extra_constraints) | |
1302 puts ("#define EXTRA_CONSTRAINT_STR(v_,c_,s_) \\\n" | |
1303 " constraint_satisfied_p (v_, lookup_constraint (s_))\n"); | |
1304 if (have_memory_constraints) | |
1305 puts ("extern bool " | |
1306 "insn_extra_memory_constraint (enum constraint_num);\n" | |
1307 "#define EXTRA_MEMORY_CONSTRAINT(c_,s_) " | |
1308 "insn_extra_memory_constraint (lookup_constraint (s_))\n"); | |
1309 else | |
1310 puts ("#define EXTRA_MEMORY_CONSTRAINT(c_,s_) false\n"); | |
1311 if (have_address_constraints) | |
1312 puts ("extern bool " | |
1313 "insn_extra_address_constraint (enum constraint_num);\n" | |
1314 "#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) " | |
1315 "insn_extra_address_constraint (lookup_constraint (s_))\n"); | |
1316 else | |
1317 puts ("#define EXTRA_ADDRESS_CONSTRAINT(c_,s_) false\n"); | |
1318 } | |
1319 | |
1320 puts ("#endif /* tm-preds.h */"); | |
1321 } | |
1322 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1323 /* Write insn-preds.c. |
0 | 1324 N.B. the list of headers to include was copied from genrecog; it |
1325 may not be ideal. | |
1326 | |
1327 FUTURE: Write #line markers referring back to the machine | |
1328 description. (Can't practically do this now since we don't know | |
1329 the line number of the C block - just the line number of the enclosing | |
1330 expression.) */ | |
1331 static void | |
1332 write_insn_preds_c (void) | |
1333 { | |
1334 struct pred_data *p; | |
1335 | |
1336 printf ("\ | |
1337 /* Generated automatically by the program '%s'\n\ | |
1338 from the machine description file '%s'. */\n\n", progname, in_fname); | |
1339 | |
1340 puts ("\ | |
1341 #include \"config.h\"\n\ | |
1342 #include \"system.h\"\n\ | |
1343 #include \"coretypes.h\"\n\ | |
1344 #include \"tm.h\"\n\ | |
1345 #include \"rtl.h\"\n\ | |
1346 #include \"tree.h\"\n\ | |
1347 #include \"tm_p.h\"\n\ | |
1348 #include \"function.h\"\n\ | |
1349 #include \"insn-config.h\"\n\ | |
1350 #include \"recog.h\"\n\ | |
1351 #include \"output.h\"\n\ | |
1352 #include \"flags.h\"\n\ | |
1353 #include \"hard-reg-set.h\"\n\ | |
1354 #include \"resource.h\"\n\ | |
1355 #include \"toplev.h\"\n\ | |
1356 #include \"reload.h\"\n\ | |
1357 #include \"regs.h\"\n\ | |
1358 #include \"tm-constrs.h\"\n"); | |
1359 | |
1360 FOR_ALL_PREDICATES (p) | |
1361 write_one_predicate_function (p); | |
1362 | |
1363 if (constraint_max_namelen > 0) | |
1364 { | |
1365 write_lookup_constraint (); | |
1366 if (have_register_constraints) | |
1367 write_regclass_for_constraint (); | |
1368 write_constraint_satisfied_p (); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1369 |
0 | 1370 if (have_const_int_constraints) |
1371 write_insn_const_int_ok_for_constraint (); | |
1372 | |
1373 if (have_memory_constraints) | |
1374 write_insn_extra_memory_constraint (); | |
1375 if (have_address_constraints) | |
1376 write_insn_extra_address_constraint (); | |
1377 } | |
1378 } | |
1379 | |
1380 /* Argument parsing. */ | |
1381 static bool gen_header; | |
1382 static bool gen_constrs; | |
1383 | |
1384 static bool | |
1385 parse_option (const char *opt) | |
1386 { | |
1387 if (!strcmp (opt, "-h")) | |
1388 { | |
1389 gen_header = true; | |
1390 return 1; | |
1391 } | |
1392 else if (!strcmp (opt, "-c")) | |
1393 { | |
1394 gen_constrs = true; | |
1395 return 1; | |
1396 } | |
1397 else | |
1398 return 0; | |
1399 } | |
1400 | |
1401 /* Master control. */ | |
1402 int | |
1403 main (int argc, char **argv) | |
1404 { | |
1405 rtx defn; | |
1406 int pattern_lineno, next_insn_code = 0; | |
1407 | |
1408 progname = argv[0]; | |
1409 if (argc <= 1) | |
1410 fatal ("no input file name"); | |
1411 if (init_md_reader_args_cb (argc, argv, parse_option) != SUCCESS_EXIT_CODE) | |
1412 return FATAL_EXIT_CODE; | |
1413 | |
1414 while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0) | |
1415 switch (GET_CODE (defn)) | |
1416 { | |
1417 case DEFINE_PREDICATE: | |
1418 case DEFINE_SPECIAL_PREDICATE: | |
1419 process_define_predicate (defn, pattern_lineno); | |
1420 break; | |
1421 | |
1422 case DEFINE_CONSTRAINT: | |
1423 case DEFINE_MEMORY_CONSTRAINT: | |
1424 case DEFINE_ADDRESS_CONSTRAINT: | |
1425 process_define_constraint (defn, pattern_lineno); | |
1426 break; | |
1427 | |
1428 case DEFINE_REGISTER_CONSTRAINT: | |
1429 process_define_register_constraint (defn, pattern_lineno); | |
1430 break; | |
1431 | |
1432 default: | |
1433 break; | |
1434 } | |
1435 | |
1436 if (gen_header) | |
1437 write_tm_preds_h (); | |
1438 else if (gen_constrs) | |
1439 write_tm_constrs_h (); | |
1440 else | |
1441 write_insn_preds_c (); | |
1442 | |
1443 if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout)) | |
1444 return FATAL_EXIT_CODE; | |
1445 | |
1446 return SUCCESS_EXIT_CODE; | |
1447 } |