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