![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genrecog.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to genrecog.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 ! root 1: /* Generate code from machine description to emit insns as rtl. ! 2: Copyright (C) 1987,1988 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is distributed in the hope that it will be useful, ! 7: but WITHOUT ANY WARRANTY. No author or distributor ! 8: accepts responsibility to anyone for the consequences of using it ! 9: or for whether it serves any particular purpose or works at all, ! 10: unless he says so in writing. Refer to the GNU CC General Public ! 11: License for full details. ! 12: ! 13: Everyone is granted permission to copy, modify and redistribute ! 14: GNU CC, but only under the conditions described in the ! 15: GNU CC General Public License. A copy of this license is ! 16: supposed to have been given to you along with GNU CC so you ! 17: can know your rights and responsibilities. It should be in a ! 18: file named COPYING. Among other things, the copyright notice ! 19: and this notice must be preserved on all copies. */ ! 20: ! 21: ! 22: /* This program is used to produce insn-recog.c, which contains ! 23: a function called `recog' plus its subroutines. ! 24: These functions contain a decision tree ! 25: that recognizes whether an rtx, the argument given to recog, ! 26: is a valid instruction. ! 27: ! 28: recog returns -1 if the rtx is not valid. ! 29: If the rtx is valid, recog returns a nonnegative number ! 30: which is the insn code number for the pattern that matched. ! 31: This is the same as the order in the machine description of the ! 32: entry that matched. This number can be used as an index into ! 33: insn_templates and insn_n_operands (found in insn-output.c) ! 34: or as an argument to output_insn_hairy (also in insn-output.c). */ ! 35: ! 36: #include <stdio.h> ! 37: #include "config.h" ! 38: #include "rtl.h" ! 39: #include "obstack.h" ! 40: ! 41: struct obstack obstack; ! 42: struct obstack *rtl_obstack = &obstack; ! 43: ! 44: #define obstack_chunk_alloc xmalloc ! 45: #define obstack_chunk_free free ! 46: extern int xmalloc (); ! 47: extern void free (); ! 48: ! 49: /* Data structure for decision tree for recognizing ! 50: legitimate instructions. */ ! 51: ! 52: struct decision ! 53: { ! 54: int number; ! 55: char *position; ! 56: RTX_CODE code; ! 57: char *exact; ! 58: enum machine_mode mode; ! 59: char *tests; ! 60: int insn_code_number; ! 61: struct decision *next; ! 62: struct decision *success; ! 63: int opno; ! 64: int dupno; ! 65: int dupcount; ! 66: int test_elt_zero_int; ! 67: int elt_zero_int; ! 68: int test_elt_one_int; ! 69: int elt_one_int; ! 70: int ignmode; ! 71: struct decision *afterward; ! 72: int label_needed; ! 73: char *c_test; ! 74: char *reg_class; ! 75: char enforce_mode; ! 76: int veclen; ! 77: int subroutine_number; ! 78: }; ! 79: ! 80: #define SUBROUTINE_THRESHOLD 50 ! 81: ! 82: int next_subroutine_number; ! 83: ! 84: /* ! 85: recognize (top) ! 86: { ! 87: staten: ! 88: x = XVECEXP (top, 0, 3); ! 89: if (test_code (GET_CODE (x)) ! 90: && test_mode (MODE (x)) ! 91: && whatever_else) ! 92: goto statep; ! 93: else if (next one...) ! 94: goto statem: ! 95: goto stater; ! 96: ! 97: statep: ! 98: actions...; ! 99: return 1; ! 100: ! 101: statem: ! 102: x = stack[depth--]; ! 103: more tests...; ! 104: ! 105: stateq: ! 106: stack[++depth] = x; ! 107: x = XEXP (stack[depth], 0); ! 108: more tests...; ! 109: ! 110: stater: ! 111: x = XEXP (stack[depth], 1); ! 112: } ! 113: ! 114: */ ! 115: ! 116: int next_number; ! 117: ! 118: int next_insn_code; ! 119: ! 120: /* Number of MATCH_DUP's seen so far in this instruction. */ ! 121: int dupcount; ! 122: ! 123: struct decision *add_to_sequence (); ! 124: struct decision *try_merge_2 (); ! 125: void write_subroutine (); ! 126: void print_code (); ! 127: void clear_codes (); ! 128: void clear_modes (); ! 129: void change_state (); ! 130: void write_tree (); ! 131: char *copystr (); ! 132: char *concat (); ! 133: void fatal (); ! 134: void mybzero (); ! 135: ! 136: struct decision *first; ! 137: ! 138: /* Construct and return a sequence of decisions ! 139: that will recognize INSN. */ ! 140: ! 141: struct decision * ! 142: make_insn_sequence (insn) ! 143: rtx insn; ! 144: { ! 145: rtx x; ! 146: char *c_test = XSTR (insn, 2); ! 147: struct decision *last; ! 148: ! 149: dupcount = 0; ! 150: ! 151: if (XVECLEN (insn, 1) == 1) ! 152: x = XVECEXP (insn, 1, 0); ! 153: else ! 154: { ! 155: x = rtx_alloc (PARALLEL); ! 156: XVEC (x, 0) = XVEC (insn, 1); ! 157: PUT_MODE (x, VOIDmode); ! 158: } ! 159: ! 160: last = add_to_sequence (x, 0, ""); ! 161: ! 162: if (c_test[0]) ! 163: last->c_test = c_test; ! 164: last->insn_code_number = next_insn_code++; ! 165: ! 166: return first; ! 167: } ! 168: ! 169: struct decision * ! 170: add_to_sequence (pattern, last, position) ! 171: rtx pattern; ! 172: struct decision *last; ! 173: char *position; ! 174: { ! 175: register RTX_CODE code; ! 176: register struct decision *new ! 177: = (struct decision *) xmalloc (sizeof (struct decision)); ! 178: struct decision *this; ! 179: char *newpos; ! 180: register char *fmt; ! 181: register int i; ! 182: int depth; ! 183: int len; ! 184: ! 185: new->number = next_number++; ! 186: new->position = copystr (position); ! 187: new->exact = 0; ! 188: new->next = 0; ! 189: new->success = 0; ! 190: new->insn_code_number = -1; ! 191: new->tests = 0; ! 192: new->opno = -1; ! 193: new->dupno = -1; ! 194: new->dupcount = -1; ! 195: new->test_elt_zero_int = 0; ! 196: new->test_elt_one_int = 0; ! 197: new->elt_zero_int = 0; ! 198: new->elt_one_int = 0; ! 199: new->enforce_mode = 0; ! 200: new->ignmode = 0; ! 201: new->afterward = 0; ! 202: new->label_needed = 0; ! 203: new->c_test = 0; ! 204: new->reg_class = 0; ! 205: new->veclen = 0; ! 206: new->subroutine_number = 0; ! 207: ! 208: this = new; ! 209: ! 210: if (last == 0) ! 211: first = new; ! 212: else ! 213: last->success = new; ! 214: ! 215: depth = strlen (position); ! 216: newpos = (char *) alloca (depth + 2); ! 217: strcpy (newpos, position); ! 218: newpos[depth + 1] = 0; ! 219: ! 220: restart: ! 221: ! 222: if (pattern == 0) ! 223: { ! 224: new->exact = "0"; ! 225: new->code = UNKNOWN; ! 226: new->mode = VOIDmode; ! 227: return new; ! 228: } ! 229: ! 230: switch (GET_MODE (pattern)) ! 231: { ! 232: case 0: ! 233: new->mode = VOIDmode; ! 234: break; ! 235: ! 236: default: ! 237: new->mode = GET_MODE (pattern); ! 238: break; ! 239: } ! 240: ! 241: new->code = code = GET_CODE (pattern);; ! 242: ! 243: switch (code) ! 244: { ! 245: case MATCH_OPERAND: ! 246: new->opno = XINT (pattern, 0); ! 247: new->code = UNKNOWN; ! 248: new->tests = XSTR (pattern, 1); ! 249: if (*new->tests == 0) ! 250: new->tests = 0; ! 251: new->reg_class = XSTR (pattern, 2); ! 252: if (*new->reg_class == 0) ! 253: new->reg_class = 0; ! 254: return new; ! 255: ! 256: case MATCH_DUP: ! 257: new->dupno = XINT (pattern, 0); ! 258: new->dupcount = dupcount++; ! 259: new->code = UNKNOWN; ! 260: return new; ! 261: ! 262: case ADDRESS: ! 263: pattern = XEXP (pattern, 0); ! 264: goto restart; ! 265: ! 266: case PC: ! 267: new->exact = "pc_rtx"; ! 268: return new; ! 269: ! 270: case CC0: ! 271: new->exact = "cc0_rtx"; ! 272: return new; ! 273: ! 274: case CONST_INT: ! 275: if (INTVAL (pattern) == 0) ! 276: { ! 277: new->exact = "const0_rtx"; ! 278: return new; ! 279: } ! 280: if (INTVAL (pattern) == 1) ! 281: { ! 282: new->exact = "const1_rtx"; ! 283: return new; ! 284: } ! 285: break; ! 286: ! 287: case SET: ! 288: newpos[depth] = '0'; ! 289: new = add_to_sequence (SET_DEST (pattern), new, newpos); ! 290: this->success->enforce_mode = 1; ! 291: newpos[depth] = '1'; ! 292: new = add_to_sequence (SET_SRC (pattern), new, newpos); ! 293: return new; ! 294: ! 295: case STRICT_LOW_PART: ! 296: newpos[depth] = '0'; ! 297: new = add_to_sequence (XEXP (pattern, 0), new, newpos); ! 298: this->success->enforce_mode = 1; ! 299: return new; ! 300: ! 301: case SUBREG: ! 302: this->test_elt_one_int = 1; ! 303: this->elt_one_int = XINT (pattern, 1); ! 304: newpos[depth] = '0'; ! 305: new = add_to_sequence (XEXP (pattern, 0), new, newpos); ! 306: this->success->enforce_mode = 1; ! 307: return new; ! 308: ! 309: case ZERO_EXTRACT: ! 310: case SIGN_EXTRACT: ! 311: newpos[depth] = '0'; ! 312: new = add_to_sequence (XEXP (pattern, 0), new, newpos); ! 313: this->success->enforce_mode = 1; ! 314: newpos[depth] = '1'; ! 315: new = add_to_sequence (XEXP (pattern, 1), new, newpos); ! 316: newpos[depth] = '2'; ! 317: new = add_to_sequence (XEXP (pattern, 2), new, newpos); ! 318: return new; ! 319: } ! 320: ! 321: fmt = GET_RTX_FORMAT (code); ! 322: len = GET_RTX_LENGTH (code); ! 323: for (i = 0; i < len; i++) ! 324: { ! 325: newpos[depth] = '0' + i; ! 326: if (fmt[i] == 'e' || fmt[i] == 'u') ! 327: new = add_to_sequence (XEXP (pattern, i), new, newpos); ! 328: else if (fmt[i] == 'i' && i == 0) ! 329: { ! 330: this->test_elt_zero_int = 1; ! 331: this->elt_zero_int = XINT (pattern, i); ! 332: } ! 333: else if (fmt[i] == 'i' && i == 1) ! 334: { ! 335: this->test_elt_one_int = 1; ! 336: this->elt_one_int = XINT (pattern, i); ! 337: } ! 338: else if (fmt[i] == 'E') ! 339: { ! 340: register int j; ! 341: /* We do not handle a vector appearing as other than ! 342: the first item, just because nothing uses them ! 343: and by handling only the special case ! 344: we can use one element in newpos for either ! 345: the item number of a subexpression ! 346: or the element number in a vector. */ ! 347: if (i != 0) ! 348: abort (); ! 349: this->veclen = XVECLEN (pattern, i); ! 350: for (j = 0; j < XVECLEN (pattern, i); j++) ! 351: { ! 352: newpos[depth] = 'a' + j; ! 353: new = add_to_sequence (XVECEXP (pattern, i, j), ! 354: new, newpos); ! 355: } ! 356: } ! 357: else if (fmt[i] != '0') ! 358: abort (); ! 359: } ! 360: return new; ! 361: } ! 362: ! 363: /* Merge two decision trees OLD and ADD, ! 364: modifying OLD destructively, ! 365: and return the merged tree. */ ! 366: ! 367: struct decision * ! 368: merge_trees (old, add) ! 369: register struct decision *old, *add; ! 370: { ! 371: while (add) ! 372: { ! 373: register struct decision *next = add->next; ! 374: add->next = 0; ! 375: if (!try_merge_1 (old, add)) ! 376: old = try_merge_2 (old, add); ! 377: add = next; ! 378: } ! 379: return old; ! 380: } ! 381: ! 382: /* Merge ADD into the next-chain starting with OLD ! 383: only if it overlaps a condition already tested in OLD. ! 384: Returns 1 if successful (OLD is modified), ! 385: 0 if nothing has been done. */ ! 386: ! 387: int ! 388: try_merge_1 (old, add) ! 389: register struct decision *old, *add; ! 390: { ! 391: while (old) ! 392: { ! 393: if ((old->position == add->position ! 394: || (old->position && add->position ! 395: && !strcmp (old->position, add->position))) ! 396: && (old->tests == add->tests ! 397: || (old->tests && add->tests && !strcmp (old->tests, add->tests))) ! 398: && (old->c_test == add->c_test ! 399: || (old->c_test && add->c_test && !strcmp (old->c_test, add->c_test))) ! 400: && old->test_elt_zero_int == add->test_elt_zero_int ! 401: && old->elt_zero_int == add->elt_zero_int ! 402: && old->test_elt_one_int == add->test_elt_one_int ! 403: && old->elt_one_int == add->elt_one_int ! 404: && old->veclen == add->veclen ! 405: && old->dupno == add->dupno ! 406: && old->opno == add->opno ! 407: && (old->tests == 0 ! 408: || (add->enforce_mode ? no_same_mode (old) : old->next == 0)) ! 409: && old->code == add->code ! 410: && old->mode == add->mode) ! 411: { ! 412: old->success = merge_trees (old->success, add->success); ! 413: if (old->insn_code_number >= 0 && add->insn_code_number >= 0) ! 414: fatal ("Two actions at one point in tree."); ! 415: if (old->insn_code_number == -1) ! 416: old->insn_code_number = add->insn_code_number; ! 417: return 1; ! 418: } ! 419: old = old->next; ! 420: } ! 421: return 0; ! 422: } ! 423: ! 424: /* Merge ADD into the next-chain that starts with OLD, ! 425: preferably after something that tests the same place ! 426: that ADD does. ! 427: The next-chain of ADD itself is ignored, and it is set ! 428: up for entering ADD into the new chain. ! 429: Returns the new chain. */ ! 430: ! 431: struct decision * ! 432: try_merge_2 (old, add) ! 433: struct decision *old, *add; ! 434: { ! 435: register struct decision *p; ! 436: struct decision *last = 0; ! 437: struct decision *last_same_place = 0; ! 438: ! 439: /* Put this in after the others that test the same place, ! 440: if there are any. If not, find the last chain element ! 441: and insert there. ! 442: ! 443: One modification: if this one is NOT a MATCH_OPERAND, ! 444: put it before any MATCH_OPERANDS that test the same place. ! 445: ! 446: Another: if enforce_mode (i.e. this is first operand of a SET), ! 447: put this after the last thing that tests the same place for ! 448: the same mode. */ ! 449: ! 450: int operand = 0 != add->tests; ! 451: ! 452: for (p = old; p; p = p->next) ! 453: { ! 454: if (p->position == add->position ! 455: || (p->position && add->position ! 456: && !strcmp (p->position, add->position))) ! 457: { ! 458: last_same_place = p; ! 459: /* If enforce_mode, segregate the modes in numerical order. */ ! 460: if (p->enforce_mode && (int) add->mode < (int) p->mode) ! 461: break; ! 462: /* Keep explicit decompositions before those that test predicates. ! 463: If enforce_mode, do this separately within each mode. */ ! 464: if (! p->enforce_mode || p->mode == add->mode) ! 465: if (!operand && p->tests) ! 466: break; ! 467: } ! 468: /* If this is past the end of the decisions at the same place as ADD, ! 469: stop looking now; add ADD before here. */ ! 470: else if (last_same_place) ! 471: break; ! 472: last = p; ! 473: } ! 474: ! 475: /* Insert before P, which means after LAST. */ ! 476: ! 477: if (last) ! 478: { ! 479: add->next = last->next; ! 480: last->next = add; ! 481: return old; ! 482: } ! 483: ! 484: add->next = old; ! 485: return add; ! 486: } ! 487: ! 488: int ! 489: no_same_mode (node) ! 490: struct decision *node; ! 491: { ! 492: register struct decision *p; ! 493: register enum machine_mode mode = node->mode; ! 494: ! 495: for (p = node->next; p; p = p->next) ! 496: if (p->mode == mode) ! 497: return 0; ! 498: ! 499: return 1; ! 500: } ! 501: ! 502: /* Count the number of subnodes of node NODE, assumed to be the start ! 503: of a next-chain. If the number is high enough, make NODE start ! 504: a separate subroutine in the C code that is generated. */ ! 505: ! 506: int ! 507: break_out_subroutines (node) ! 508: struct decision *node; ! 509: { ! 510: int size = 0; ! 511: struct decision *sub; ! 512: for (sub = node; sub; sub = sub->next) ! 513: size += 1 + break_out_subroutines (sub->success); ! 514: if (size > SUBROUTINE_THRESHOLD) ! 515: { ! 516: node->subroutine_number = ++next_subroutine_number; ! 517: write_subroutine (node); ! 518: size = 1; ! 519: } ! 520: return size; ! 521: } ! 522: ! 523: void ! 524: write_subroutine (tree) ! 525: struct decision *tree; ! 526: { ! 527: printf ("int\nrecog_%d (x0, insn)\n register rtx x0;\n rtx insn;\n{\n", ! 528: tree->subroutine_number); ! 529: printf (" register rtx x1, x2, x3, x4, x5;\n rtx x6, x7, x8, x9, x10, x11;\n"); ! 530: printf (" int tem;\n"); ! 531: write_tree (tree, "", 0, "", 1); ! 532: printf (" ret0: return -1;\n}\n\n"); ! 533: } ! 534: ! 535: /* Write out C code to perform the decisions in the tree. */ ! 536: ! 537: void ! 538: write_tree (tree, prevpos, afterward, afterpos, initial) ! 539: struct decision *tree; ! 540: char *prevpos; ! 541: int afterward; ! 542: char *afterpos; ! 543: int initial; ! 544: { ! 545: register struct decision *p, *p1; ! 546: char *pos; ! 547: register int depth; ! 548: int ignmode; ! 549: enum { NO_SWITCH, CODE_SWITCH, MODE_SWITCH } in_switch = NO_SWITCH; ! 550: char modemap[NUM_MACHINE_MODES]; ! 551: char codemap[NUM_RTX_CODE]; ! 552: ! 553: pos = prevpos; ! 554: ! 555: if (tree->subroutine_number > 0 && ! initial) ! 556: { ! 557: printf (" L%d:\n", tree->number); ! 558: ! 559: if (afterward) ! 560: { ! 561: printf (" tem = recog_%d (x0, insn);\n", ! 562: tree->subroutine_number); ! 563: printf (" if (tem >= 0) return tem;\n"); ! 564: change_state (pos, afterpos); ! 565: printf (" goto L%d;\n", afterward); ! 566: } ! 567: else ! 568: printf (" return recog_%d (x0, insn);\n", ! 569: tree->subroutine_number); ! 570: return; ! 571: } ! 572: ! 573: tree->label_needed = 1; ! 574: for (p = tree; p; p = p->next) ! 575: { ! 576: /* Find the next alternative to p ! 577: that might be true when p is true. ! 578: Test that one next if p's successors fail. ! 579: Note that when the `tests' field is nonzero ! 580: it is up to the specified test-function to compare machine modes ! 581: and some (such as general_operand) don't always do so. ! 582: But when inside a switch-on-modes we ignore this and ! 583: consider all modes mutually exclusive. */ ! 584: for (p1 = p->next; p1; p1 = p1->next) ! 585: if (((p->code == UNKNOWN || p1->code == UNKNOWN || p->code == p1->code) ! 586: && (p->mode == VOIDmode || p1->mode == VOIDmode ! 587: || p->mode == p1->mode ! 588: || (in_switch != MODE_SWITCH && (p->tests || p1->tests)))) ! 589: || strcmp (p1->position, p->position)) ! 590: break; ! 591: p->afterward = p1; ! 592: if (p1) p1->label_needed = 1; ! 593: ! 594: if (in_switch == MODE_SWITCH ! 595: && (p->mode == VOIDmode || (! p->enforce_mode && p->tests != 0))) ! 596: { ! 597: in_switch = NO_SWITCH; ! 598: printf (" }\n"); ! 599: } ! 600: if (in_switch == CODE_SWITCH && p->code == UNKNOWN) ! 601: { ! 602: in_switch = NO_SWITCH; ! 603: printf (" }\n"); ! 604: } ! 605: ! 606: if (p->label_needed) ! 607: printf (" L%d:\n", p->number); ! 608: ! 609: if (p->success == 0 && p->insn_code_number < 0) ! 610: abort (); ! 611: ! 612: change_state (pos, p->position); ! 613: pos = p->position; ! 614: depth = strlen (pos); ! 615: ! 616: ignmode = p->ignmode || pos[depth - 1] == '*' || p->tests; ! 617: ! 618: if (in_switch == NO_SWITCH) ! 619: { ! 620: /* If p and its alternatives all want the same mode, ! 621: reject all others at once, first, then ignore the mode. */ ! 622: if (!ignmode && p->mode != VOIDmode && p->next && same_modes (p, p->mode)) ! 623: { ! 624: printf (" if (GET_MODE (x%d) != %smode)\n", ! 625: depth, GET_MODE_NAME (p->mode)); ! 626: if (afterward) ! 627: { ! 628: printf (" {\n "); ! 629: change_state (pos, afterpos); ! 630: printf (" goto L%d;\n }\n", afterward); ! 631: } ! 632: else ! 633: printf (" goto ret0;\n"); ! 634: clear_modes (p); ! 635: ignmode = 1; ! 636: } ! 637: ! 638: /* If p and its alternatives all want the same code, ! 639: reject all others at once, first, then ignore the code. */ ! 640: if (p->code != UNKNOWN && p->next && same_codes (p, p->code)) ! 641: { ! 642: printf (" if (GET_CODE (x%d) != ", depth); ! 643: print_code (p->code); ! 644: printf (")\n"); ! 645: if (afterward) ! 646: { ! 647: printf (" {"); ! 648: change_state (pos, afterpos); ! 649: printf (" goto L%d; }\n", afterward); ! 650: } ! 651: else ! 652: printf (" goto ret0;\n"); ! 653: clear_codes (p); ! 654: } ! 655: } ! 656: ! 657: /* If p and its alternatives all have different modes ! 658: and there are at least 4 of them, make a switch. */ ! 659: if (in_switch == NO_SWITCH && pos[depth-1] != '*') ! 660: { ! 661: register int i; ! 662: int lose = 0; ! 663: ! 664: mybzero (modemap, sizeof modemap); ! 665: for (p1 = p, i = 0; ! 666: (p1 && p1->mode != VOIDmode ! 667: && (p1->tests == 0 || p1->enforce_mode)); ! 668: p1 = p1->next, i++) ! 669: { ! 670: if (! p->enforce_mode && modemap[(int) p1->mode]) ! 671: { ! 672: lose = 1; ! 673: break; ! 674: } ! 675: modemap[(int) p1->mode] = 1; ! 676: } ! 677: if (!lose && i >= 4) ! 678: { ! 679: in_switch = MODE_SWITCH; ! 680: printf (" switch (GET_MODE (x%d))\n {\n", depth); ! 681: } ! 682: } ! 683: ! 684: if (in_switch == NO_SWITCH) ! 685: { ! 686: register int i; ! 687: mybzero (codemap, sizeof codemap); ! 688: for (p1 = p, i = 0; p1 && p1->code != UNKNOWN; p1 = p1->next, i++) ! 689: { ! 690: if (codemap[(int) p1->code]) ! 691: break; ! 692: codemap[(int) p1->code] = 1; ! 693: } ! 694: if ((p1 == 0 || p1->code == UNKNOWN) && i >= 4) ! 695: { ! 696: in_switch = CODE_SWITCH; ! 697: printf (" switch (GET_CODE (x%d))\n {\n", depth); ! 698: } ! 699: } ! 700: ! 701: if (in_switch == MODE_SWITCH) ! 702: { ! 703: if (modemap[(int) p->mode]) ! 704: { ! 705: printf (" case %smode:\n", GET_MODE_NAME (p->mode)); ! 706: modemap[(int) p->mode] = 0; ! 707: } ! 708: } ! 709: if (in_switch == CODE_SWITCH) ! 710: { ! 711: if (codemap[(int) p->code]) ! 712: { ! 713: printf (" case "); ! 714: print_code (p->code); ! 715: printf (":\n"); ! 716: codemap[(int) p->code] = 0; ! 717: } ! 718: } ! 719: ! 720: printf (" if ("); ! 721: if (p->exact || (p->code != UNKNOWN && in_switch != CODE_SWITCH)) ! 722: { ! 723: if (p->exact) ! 724: printf ("x%d == %s", depth, p->exact); ! 725: else ! 726: { ! 727: printf ("GET_CODE (x%d) == ", depth); ! 728: print_code (p->code); ! 729: } ! 730: printf (" && "); ! 731: } ! 732: if (p->mode && !ignmode && in_switch != MODE_SWITCH) ! 733: printf ("GET_MODE (x%d) == %smode && ", ! 734: depth, GET_MODE_NAME (p->mode)); ! 735: if (p->test_elt_zero_int) ! 736: printf ("XINT (x%d, 0) == %d && ", depth, p->elt_zero_int); ! 737: if (p->veclen) ! 738: printf ("XVECLEN (x%d, 0) == %d && ", depth, p->veclen); ! 739: if (p->test_elt_one_int) ! 740: printf ("XINT (x%d, 1) == %d && ", depth, p->elt_one_int); ! 741: if (p->dupno >= 0) ! 742: printf ("rtx_equal_p (x%d, recog_operand[%d]) && ", depth, p->dupno); ! 743: if (p->tests) ! 744: printf ("%s (x%d, %smode)", p->tests, depth, ! 745: GET_MODE_NAME (p->mode)); ! 746: else ! 747: printf ("1"); ! 748: ! 749: if (p->opno >= 0) ! 750: printf (")\n { recog_operand[%d] = x%d; ", ! 751: p->opno, depth); ! 752: else ! 753: printf (")\n "); ! 754: ! 755: if (p->c_test) ! 756: printf ("if (%s) ", p->c_test); ! 757: ! 758: if (p->insn_code_number >= 0) ! 759: printf ("return %d;", p->insn_code_number); ! 760: else ! 761: printf ("goto L%d;", p->success->number); ! 762: ! 763: if (p->opno >= 0) ! 764: printf (" }\n"); ! 765: else ! 766: printf ("\n"); ! 767: ! 768: /* Now, if inside a switch, branch to next switch member ! 769: that might also need to be tested if this one fails. */ ! 770: ! 771: if (in_switch == CODE_SWITCH) ! 772: { ! 773: /* Find the next alternative to p ! 774: that might be applicable if p was applicable. */ ! 775: for (p1 = p->next; p1; p1 = p1->next) ! 776: if (p1->code == UNKNOWN || p->code == p1->code) ! 777: break; ! 778: if (p1 == 0 || p1->code == UNKNOWN) ! 779: printf (" break;\n"); ! 780: else if (p1 != p->next) ! 781: { ! 782: printf (" goto L%d;\n", p1->number); ! 783: p1->label_needed = 1; ! 784: } ! 785: } ! 786: ! 787: if (in_switch == MODE_SWITCH) ! 788: { ! 789: /* Find the next alternative to p ! 790: that might be applicable if p was applicable. */ ! 791: for (p1 = p->next; p1; p1 = p1->next) ! 792: if (p1->mode == VOIDmode || p->mode == p1->mode) ! 793: break; ! 794: if (p1 == 0 || p1->mode == VOIDmode) ! 795: printf (" break;\n"); ! 796: else if (p1 != p->next) ! 797: { ! 798: printf (" goto L%d;\n", p1->number); ! 799: p1->label_needed = 1; ! 800: } ! 801: } ! 802: } ! 803: ! 804: if (in_switch != NO_SWITCH) ! 805: printf (" }\n"); ! 806: ! 807: if (afterward) ! 808: { ! 809: change_state (pos, afterpos); ! 810: printf (" goto L%d;\n", afterward); ! 811: } ! 812: else ! 813: printf (" goto ret0;\n"); ! 814: ! 815: for (p = tree; p; p = p->next) ! 816: if (p->success) ! 817: { ! 818: { ! 819: pos = p->position; ! 820: write_tree (p->success, pos, ! 821: p->afterward ? p->afterward->number : afterward, ! 822: p->afterward ? pos : afterpos, ! 823: 0); ! 824: } ! 825: } ! 826: } ! 827: ! 828: void ! 829: print_code (code) ! 830: RTX_CODE code; ! 831: { ! 832: register char *p1; ! 833: for (p1 = GET_RTX_NAME (code); *p1; p1++) ! 834: { ! 835: if (*p1 >= 'a' && *p1 <= 'z') ! 836: putchar (*p1 + 'A' - 'a'); ! 837: else ! 838: putchar (*p1); ! 839: } ! 840: } ! 841: ! 842: int ! 843: same_codes (p, code) ! 844: register struct decision *p; ! 845: register RTX_CODE code; ! 846: { ! 847: for (; p; p = p->next) ! 848: if (p->code != code) ! 849: return 0; ! 850: ! 851: return 1; ! 852: } ! 853: ! 854: void ! 855: clear_codes (p) ! 856: register struct decision *p; ! 857: { ! 858: for (; p; p = p->next) ! 859: p->code = UNKNOWN; ! 860: } ! 861: ! 862: int ! 863: same_modes (p, mode) ! 864: register struct decision *p; ! 865: register enum machine_mode mode; ! 866: { ! 867: for (; p; p = p->next) ! 868: if (p->mode != mode || p->tests) ! 869: return 0; ! 870: ! 871: return 1; ! 872: } ! 873: ! 874: void ! 875: clear_modes (p) ! 876: register struct decision *p; ! 877: { ! 878: for (; p; p = p->next) ! 879: p->ignmode = 1; ! 880: } ! 881: ! 882: void ! 883: change_state (oldpos, newpos) ! 884: char *oldpos; ! 885: char *newpos; ! 886: { ! 887: int odepth = strlen (oldpos); ! 888: int depth = odepth; ! 889: int ndepth = strlen (newpos); ! 890: ! 891: /* Pop up as many levels as necessary. */ ! 892: ! 893: while (strncmp (oldpos, newpos, depth)) ! 894: --depth; ! 895: ! 896: /* Go down to desired level. */ ! 897: ! 898: while (depth < ndepth) ! 899: { ! 900: if (newpos[depth] == '*') ! 901: printf (" x%d = recog_addr_dummy;\n XEXP (x%d, 0) = x%d;\n", ! 902: depth + 1, depth + 1, depth); ! 903: else if (newpos[depth] >= 'a' && newpos[depth] <= 'z') ! 904: printf (" x%d = XVECEXP (x%d, 0, %c);\n", ! 905: depth + 1, depth, '0' + newpos[depth] - 'a'); ! 906: else ! 907: printf (" x%d = XEXP (x%d, %c);\n", ! 908: depth + 1, depth, newpos[depth]); ! 909: ++depth; ! 910: } ! 911: } ! 912: ! 913: char * ! 914: copystr (s1) ! 915: char *s1; ! 916: { ! 917: register char *tem; ! 918: ! 919: if (s1 == 0) ! 920: return 0; ! 921: ! 922: tem = (char *) xmalloc (strlen (s1) + 1); ! 923: strcpy (tem, s1); ! 924: ! 925: return tem; ! 926: } ! 927: ! 928: void ! 929: mybzero (b, length) ! 930: register char *b; ! 931: register int length; ! 932: { ! 933: while (length-- > 0) ! 934: *b++ = 0; ! 935: } ! 936: ! 937: char * ! 938: concat (s1, s2) ! 939: char *s1, *s2; ! 940: { ! 941: register char *tem; ! 942: ! 943: if (s1 == 0) ! 944: return s2; ! 945: if (s2 == 0) ! 946: return s1; ! 947: ! 948: tem = (char *) xmalloc (strlen (s1) + strlen (s2) + 2); ! 949: strcpy (tem, s1); ! 950: strcat (tem, " "); ! 951: strcat (tem, s2); ! 952: ! 953: return tem; ! 954: } ! 955: ! 956: int ! 957: xrealloc (ptr, size) ! 958: char *ptr; ! 959: int size; ! 960: { ! 961: int result = realloc (ptr, size); ! 962: if (!result) ! 963: fatal ("virtual memory exhausted"); ! 964: return result; ! 965: } ! 966: ! 967: int ! 968: xmalloc (size) ! 969: { ! 970: register int val = malloc (size); ! 971: ! 972: if (val == 0) ! 973: fatal ("virtual memory exhausted"); ! 974: return val; ! 975: } ! 976: ! 977: void ! 978: fatal (s, a1, a2) ! 979: { ! 980: fprintf (stderr, "genrecog: "); ! 981: fprintf (stderr, s, a1, a2); ! 982: fprintf (stderr, "\n"); ! 983: fprintf (stderr, "after %d instruction definitions\n", ! 984: next_insn_code); ! 985: exit (FATAL_EXIT_CODE); ! 986: } ! 987: ! 988: int ! 989: main (argc, argv) ! 990: int argc; ! 991: char **argv; ! 992: { ! 993: rtx desc; ! 994: struct decision *tree = 0; ! 995: FILE *infile; ! 996: extern rtx read_rtx (); ! 997: register int c; ! 998: ! 999: obstack_init (rtl_obstack); ! 1000: ! 1001: if (argc <= 1) ! 1002: fatal ("No input file name."); ! 1003: ! 1004: infile = fopen (argv[1], "r"); ! 1005: if (infile == 0) ! 1006: { ! 1007: perror (argv[1]); ! 1008: exit (FATAL_EXIT_CODE); ! 1009: } ! 1010: ! 1011: init_rtl (); ! 1012: next_insn_code = 0; ! 1013: ! 1014: printf ("/* Generated automatically by the program `genrecog'\n\ ! 1015: from the machine description file `md'. */\n\n"); ! 1016: ! 1017: /* Read the machine description. */ ! 1018: ! 1019: while (1) ! 1020: { ! 1021: c = read_skip_spaces (infile); ! 1022: if (c == EOF) ! 1023: break; ! 1024: ungetc (c, infile); ! 1025: ! 1026: desc = read_rtx (infile); ! 1027: if (GET_CODE (desc) == DEFINE_INSN) ! 1028: tree = merge_trees (tree, make_insn_sequence (desc)); ! 1029: if (GET_CODE (desc) == DEFINE_PEEPHOLE ! 1030: || GET_CODE (desc) == DEFINE_EXPAND) ! 1031: next_insn_code++; ! 1032: } ! 1033: ! 1034: printf ("#include \"config.h\"\n"); ! 1035: printf ("#include \"rtl.h\"\n"); ! 1036: printf ("#include \"insn-config.h\"\n"); ! 1037: printf ("#include \"recog.h\"\n"); ! 1038: printf ("\n\ ! 1039: /* `recog' contains a decision tree\n\ ! 1040: that recognizes whether the rtx X0 is a valid instruction.\n\ ! 1041: \n\ ! 1042: recog returns -1 if the rtx is not valid.\n\ ! 1043: If the rtx is valid, recog returns a nonnegative number\n\ ! 1044: which is the insn code number for the pattern that matched.\n"); ! 1045: printf (" This is the same as the order in the machine description of\n\ ! 1046: the entry that matched. This number can be used as an index into\n\ ! 1047: insn_templates and insn_n_operands (found in insn-output.c)\n\ ! 1048: or as an argument to output_insn_hairy (also in insn-output.c). */\n\n"); ! 1049: ! 1050: printf ("rtx recog_operand[MAX_RECOG_OPERANDS];\n\n"); ! 1051: printf ("rtx *recog_operand_loc[MAX_RECOG_OPERANDS];\n\n"); ! 1052: printf ("rtx *recog_dup_loc[MAX_DUP_OPERANDS];\n\n"); ! 1053: printf ("char recog_dup_num[MAX_DUP_OPERANDS];\n\n"); ! 1054: printf ("extern rtx recog_addr_dummy;\n\n"); ! 1055: printf ("#define operands recog_operand\n\n"); ! 1056: ! 1057: break_out_subroutines (tree); ! 1058: ! 1059: printf ("int\nrecog (x0, insn)\n register rtx x0;\n rtx insn;\n{\n"); ! 1060: printf (" register rtx x1, x2, x3, x4, x5;\n rtx x6, x7, x8, x9, x10, x11;\n"); ! 1061: printf (" int tem;\n"); ! 1062: ! 1063: write_tree (tree, "", 0, "", 1); ! 1064: printf (" ret0: return -1;\n}\n"); ! 1065: ! 1066: fflush (stdout); ! 1067: exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE); ! 1068: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.