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; 105 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 156 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; 293 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)); 386 387 gcc_assert (test0 || test1); 388 389 if (test0 && test1) 390 goto break_loop; 391 pos = test0 ? &XEXP (subexp, 0) : &XEXP (subexp, 1); 392 } 393 break; 394 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)); 400 401 gcc_assert ((test0 && test1) || test2); 402 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; 414 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 } 476 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; 496 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 804 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", 864 name[0], name, 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 899 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 957 fputs ("#define CONSTRAINT_NUM_DEFINED_P 1\n", stdout); 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 } 1051 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) 1118 puts (" if (CONST_INT_P (op))\n" 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" 1283 " regclass_for_constraint (lookup_constraint (s_))\n" 1284 "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n" 1285 " regclass_for_constraint (x_)\n"); 1286 else 1287 puts ("#define REG_CLASS_FROM_CONSTRAINT(c_,s_) NO_REGS\n" 1288 "#define REG_CLASS_FOR_CONSTRAINT(x_) \\\n" 1289 " NO_REGS\n"); 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 1323 /* Write insn-preds.c. 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 \"real.h\"\n\ 1352 #include \"output.h\"\n\ 1353 #include \"flags.h\"\n\ 1354 #include \"hard-reg-set.h\"\n\ 1355 #include \"resource.h\"\n\ 1356 #include \"toplev.h\"\n\ 1357 #include \"reload.h\"\n\ 1358 #include \"regs.h\"\n\ 1359 #include \"tm-constrs.h\"\n"); 1360 1361 FOR_ALL_PREDICATES (p) 1362 write_one_predicate_function (p); 1363 1364 if (constraint_max_namelen > 0) 1365 { 1366 write_lookup_constraint (); 1367 if (have_register_constraints) 1368 write_regclass_for_constraint (); 1369 write_constraint_satisfied_p (); 1370 1371 if (have_const_int_constraints) 1372 write_insn_const_int_ok_for_constraint (); 1373 1374 if (have_memory_constraints) 1375 write_insn_extra_memory_constraint (); 1376 if (have_address_constraints) 1377 write_insn_extra_address_constraint (); 1378 } 1379 } 1380 1381 /* Argument parsing. */ 1382 static bool gen_header; 1383 static bool gen_constrs; 1384 1385 static bool 1386 parse_option (const char *opt) 1387 { 1388 if (!strcmp (opt, "-h")) 1389 { 1390 gen_header = true; 1391 return 1; 1392 } 1393 else if (!strcmp (opt, "-c")) 1394 { 1395 gen_constrs = true; 1396 return 1; 1397 } 1398 else 1399 return 0; 1400 } 1401 1402 /* Master control. */ 1403 int 1404 main (int argc, char **argv) 1405 { 1406 rtx defn; 1407 int pattern_lineno, next_insn_code = 0; 1408 1409 progname = argv[0]; 1410 if (argc <= 1) 1411 fatal ("no input file name"); 1412 if (init_md_reader_args_cb (argc, argv, parse_option) != SUCCESS_EXIT_CODE) 1413 return FATAL_EXIT_CODE; 1414 1415 while ((defn = read_md_rtx (&pattern_lineno, &next_insn_code)) != 0) 1416 switch (GET_CODE (defn)) 1417 { 1418 case DEFINE_PREDICATE: 1419 case DEFINE_SPECIAL_PREDICATE: 1420 process_define_predicate (defn, pattern_lineno); 1421 break; 1422 1423 case DEFINE_CONSTRAINT: 1424 case DEFINE_MEMORY_CONSTRAINT: 1425 case DEFINE_ADDRESS_CONSTRAINT: 1426 process_define_constraint (defn, pattern_lineno); 1427 break; 1428 1429 case DEFINE_REGISTER_CONSTRAINT: 1430 process_define_register_constraint (defn, pattern_lineno); 1431 break; 1432 1433 default: 1434 break; 1435 } 1436 1437 if (gen_header) 1438 write_tm_preds_h (); 1439 else if (gen_constrs) 1440 write_tm_constrs_h (); 1441 else 1442 write_insn_preds_c (); 1443 1444 if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout)) 1445 return FATAL_EXIT_CODE; 1446 1447 return SUCCESS_EXIT_CODE; 1448 } 1449