![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to genoutput.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to genoutput.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 ! root 1: /* Generate code from to output assembler insns as recognized from rtl. ! 2: Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc. ! 3: ! 4: This file is part of GNU CC. ! 5: ! 6: GNU CC is free software; you can redistribute it and/or modify ! 7: it under the terms of the GNU General Public License as published by ! 8: the Free Software Foundation; either version 2, or (at your option) ! 9: any later version. ! 10: ! 11: GNU CC is distributed in the hope that it will be useful, ! 12: but WITHOUT ANY WARRANTY; without even the implied warranty of ! 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ! 14: GNU General Public License for more details. ! 15: ! 16: You should have received a copy of the GNU General Public License ! 17: along with GNU CC; see the file COPYING. If not, write to ! 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! 19: ! 20: ! 21: /* This program reads the machine description for the compiler target machine ! 22: and produces a file containing these things: ! 23: ! 24: 1. An array of strings `insn_template' which is indexed by insn code number ! 25: and contains the template for output of that insn, ! 26: ! 27: 2. An array of functions `insn_outfun' which, indexed by the insn code ! 28: number, gives the function that returns a template to use for output of ! 29: that insn. This is used only in the cases where the template is not ! 30: constant. These cases are specified by a * or @ at the beginning of the ! 31: template string in the machine description. They are identified for the ! 32: sake of other parts of the compiler by a zero element in `insn_template'. ! 33: ! 34: 3. An array of functions `insn_gen_function' which, indexed ! 35: by insn code number, gives the function to generate a body ! 36: for that pattern, given operands as arguments. ! 37: ! 38: 4. An array of strings `insn_name' which, indexed by insn code number, ! 39: gives the name for that pattern. Nameless patterns are given a name. ! 40: ! 41: 5. An array of ints `insn_n_operands' which is indexed by insn code number ! 42: and contains the number of distinct operands in the pattern for that insn, ! 43: ! 44: 6. An array of ints `insn_n_dups' which is indexed by insn code number ! 45: and contains the number of match_dup's that appear in the insn's pattern. ! 46: This says how many elements of `recog_dup_loc' are significant ! 47: after an insn has been recognized. ! 48: ! 49: 7. An array of arrays of operand constraint strings, ! 50: `insn_operand_constraint', ! 51: indexed first by insn code number and second by operand number, ! 52: containing the constraint for that operand. ! 53: ! 54: This array is generated only if register constraints appear in ! 55: match_operand rtx's. ! 56: ! 57: 8. An array of arrays of chars which indicate which operands of ! 58: which insn patterns appear within ADDRESS rtx's. This array is ! 59: called `insn_operand_address_p' and is generated only if there ! 60: are *no* register constraints in the match_operand rtx's. ! 61: ! 62: 9. An array of arrays of machine modes, `insn_operand_mode', ! 63: indexed first by insn code number and second by operand number, ! 64: containing the machine mode that that operand is supposed to have. ! 65: Also `insn_operand_strict_low', which is nonzero for operands ! 66: contained in a STRICT_LOW_PART. ! 67: ! 68: 10. An array of arrays of int-valued functions, `insn_operand_predicate', ! 69: indexed first by insn code number and second by operand number, ! 70: containing the match_operand predicate for this operand. ! 71: ! 72: 11. An array of ints, `insn_n_alternatives', that gives the number ! 73: of alternatives in the constraints of each pattern. ! 74: ! 75: The code number of an insn is simply its position in the machine description; ! 76: code numbers are assigned sequentially to entries in the description, ! 77: starting with code number 0. ! 78: ! 79: Thus, the following entry in the machine description ! 80: ! 81: (define_insn "clrdf" ! 82: [(set (match_operand:DF 0 "general_operand" "") ! 83: (const_int 0))] ! 84: "" ! 85: "clrd %0") ! 86: ! 87: assuming it is the 25th entry present, would cause ! 88: insn_template[24] to be "clrd %0", and insn_n_operands[24] to be 1. ! 89: It would not make an case in output_insn_hairy because the template ! 90: given in the entry is a constant (it does not start with `*'). */ ! 91: ! 92: #include <stdio.h> ! 93: #include "hconfig.h" ! 94: #include "rtl.h" ! 95: #include "obstack.h" ! 96: ! 97: /* No instruction can have more operands than this. ! 98: Sorry for this arbitrary limit, but what machine will ! 99: have an instruction with this many operands? */ ! 100: ! 101: #define MAX_MAX_OPERANDS 40 ! 102: ! 103: static struct obstack obstack; ! 104: struct obstack *rtl_obstack = &obstack; ! 105: ! 106: #define obstack_chunk_alloc xmalloc ! 107: #define obstack_chunk_free free ! 108: ! 109: extern void free (); ! 110: extern rtx read_rtx (); ! 111: ! 112: char *xmalloc (); ! 113: static void fatal (); ! 114: void fancy_abort (); ! 115: static void error (); ! 116: static void mybcopy (); ! 117: static void mybzero (); ! 118: static int n_occurrences (); ! 119: ! 120: /* insns in the machine description are assigned sequential code numbers ! 121: that are used by insn-recog.c (produced by genrecog) to communicate ! 122: to insn-output.c (produced by this program). */ ! 123: ! 124: static int next_code_number; ! 125: ! 126: /* This counts all definitions in the md file, ! 127: for the sake of error messages. */ ! 128: ! 129: static int next_index_number; ! 130: ! 131: /* Record in this chain all information that we will output, ! 132: associated with the code number of the insn. */ ! 133: ! 134: struct data ! 135: { ! 136: int code_number; ! 137: int index_number; ! 138: char *name; ! 139: char *template; /* string such as "movl %1,%0" */ ! 140: int n_operands; /* Number of operands this insn recognizes */ ! 141: int n_dups; /* Number times match_dup appears in pattern */ ! 142: int n_alternatives; /* Number of alternatives in each constraint */ ! 143: struct data *next; ! 144: char *constraints[MAX_MAX_OPERANDS]; ! 145: /* Number of alternatives in constraints of operand N. */ ! 146: int op_n_alternatives[MAX_MAX_OPERANDS]; ! 147: char *predicates[MAX_MAX_OPERANDS]; ! 148: char address_p[MAX_MAX_OPERANDS]; ! 149: enum machine_mode modes[MAX_MAX_OPERANDS]; ! 150: char strict_low[MAX_MAX_OPERANDS]; ! 151: char outfun; /* Nonzero means this has an output function */ ! 152: }; ! 153: ! 154: /* This variable points to the first link in the chain. */ ! 155: ! 156: struct data *insn_data; ! 157: ! 158: /* Pointer to the last link in the chain, so new elements ! 159: can be added at the end. */ ! 160: ! 161: struct data *end_of_insn_data; ! 162: ! 163: /* Nonzero if any match_operand has a constraint string; ! 164: implies that REGISTER_CONSTRAINTS will be defined ! 165: for this machine description. */ ! 166: ! 167: int have_constraints; ! 168: ! 169: /* Nonzero if some error has occurred. We will make all errors fatal, but ! 170: might as well continue until we see all of them. */ ! 171: ! 172: static int have_error; ! 173: ! 174: static void ! 175: output_prologue () ! 176: { ! 177: ! 178: printf ("/* Generated automatically by the program `genoutput'\n\ ! 179: from the machine description file `md'. */\n\n"); ! 180: ! 181: printf ("#include \"config.h\"\n"); ! 182: printf ("#include \"rtl.h\"\n"); ! 183: printf ("#include \"regs.h\"\n"); ! 184: printf ("#include \"hard-reg-set.h\"\n"); ! 185: printf ("#include \"real.h\"\n"); ! 186: printf ("#include \"insn-config.h\"\n\n"); ! 187: printf ("#include \"conditions.h\"\n"); ! 188: printf ("#include \"insn-flags.h\"\n"); ! 189: printf ("#include \"insn-attr.h\"\n\n"); ! 190: printf ("#include \"insn-codes.h\"\n\n"); ! 191: printf ("#include \"recog.h\"\n\n"); ! 192: ! 193: printf ("#include <stdio.h>\n"); ! 194: printf ("#include \"output.h\"\n"); ! 195: } ! 196: ! 197: static void ! 198: output_epilogue () ! 199: { ! 200: register struct data *d; ! 201: ! 202: printf ("\nchar * const insn_template[] =\n {\n"); ! 203: for (d = insn_data; d; d = d->next) ! 204: { ! 205: if (d->template) ! 206: printf (" \"%s\",\n", d->template); ! 207: else ! 208: printf (" 0,\n"); ! 209: } ! 210: printf (" };\n"); ! 211: ! 212: printf ("\nchar *(*const insn_outfun[])() =\n {\n"); ! 213: for (d = insn_data; d; d = d->next) ! 214: { ! 215: if (d->outfun) ! 216: printf (" output_%d,\n", d->code_number); ! 217: else ! 218: printf (" 0,\n"); ! 219: } ! 220: printf (" };\n"); ! 221: ! 222: printf ("\nrtx (*const insn_gen_function[]) () =\n {\n"); ! 223: for (d = insn_data; d; d = d->next) ! 224: { ! 225: if (d->name) ! 226: printf (" gen_%s,\n", d->name); ! 227: else ! 228: printf (" 0,\n"); ! 229: } ! 230: printf (" };\n"); ! 231: ! 232: printf ("\nchar *insn_name[] =\n {\n"); ! 233: { ! 234: int offset = 0; ! 235: int next; ! 236: char * last_name = 0; ! 237: char * next_name; ! 238: register struct data *n; ! 239: ! 240: for (n = insn_data, next = 0; n; n = n->next, next++) ! 241: if (n->name) ! 242: { ! 243: next_name = n->name; ! 244: break; ! 245: } ! 246: ! 247: for (d = insn_data; d; d = d->next) ! 248: { ! 249: if (d->name) ! 250: { ! 251: printf (" \"%s\",\n", d->name); ! 252: offset = 0; ! 253: last_name = d->name; ! 254: next_name = 0; ! 255: for (n = d->next, next = 1; n; n = n->next, next++) ! 256: if (n->name) ! 257: { ! 258: next_name = n->name; ! 259: break; ! 260: } ! 261: } ! 262: else ! 263: { ! 264: offset++; ! 265: if (next_name && (last_name == 0 || offset > next / 2)) ! 266: printf (" \"%s-%d\",\n", next_name, next - offset); ! 267: else ! 268: printf (" \"%s+%d\",\n", last_name, offset); ! 269: } ! 270: } ! 271: } ! 272: printf (" };\n"); ! 273: printf ("char **insn_name_ptr = insn_name;\n"); ! 274: ! 275: printf ("\nconst int insn_n_operands[] =\n {\n"); ! 276: for (d = insn_data; d; d = d->next) ! 277: printf (" %d,\n", d->n_operands); ! 278: printf (" };\n"); ! 279: ! 280: printf ("\nconst int insn_n_dups[] =\n {\n"); ! 281: for (d = insn_data; d; d = d->next) ! 282: printf (" %d,\n", d->n_dups); ! 283: printf (" };\n"); ! 284: ! 285: if (have_constraints) ! 286: { ! 287: printf ("\nchar *const insn_operand_constraint[][MAX_RECOG_OPERANDS] =\n {\n"); ! 288: for (d = insn_data; d; d = d->next) ! 289: { ! 290: register int i; ! 291: printf (" {"); ! 292: for (i = 0; i < d->n_operands; i++) ! 293: { ! 294: if (d->constraints[i] == 0) ! 295: printf (" \"\","); ! 296: else ! 297: printf (" \"%s\",", d->constraints[i]); ! 298: } ! 299: if (d->n_operands == 0) ! 300: printf (" 0"); ! 301: printf (" },\n"); ! 302: } ! 303: printf (" };\n"); ! 304: } ! 305: else ! 306: { ! 307: printf ("\nconst char insn_operand_address_p[][MAX_RECOG_OPERANDS] =\n {\n"); ! 308: for (d = insn_data; d; d = d->next) ! 309: { ! 310: register int i; ! 311: printf (" {"); ! 312: for (i = 0; i < d->n_operands; i++) ! 313: printf (" %d,", d->address_p[i]); ! 314: if (d->n_operands == 0) ! 315: printf (" 0"); ! 316: printf (" },\n"); ! 317: } ! 318: printf (" };\n"); ! 319: } ! 320: ! 321: printf ("\nconst enum machine_mode insn_operand_mode[][MAX_RECOG_OPERANDS] =\n {\n"); ! 322: for (d = insn_data; d; d = d->next) ! 323: { ! 324: register int i; ! 325: printf (" {"); ! 326: for (i = 0; i < d->n_operands; i++) ! 327: printf (" %smode,", GET_MODE_NAME (d->modes[i])); ! 328: if (d->n_operands == 0) ! 329: printf (" VOIDmode"); ! 330: printf (" },\n"); ! 331: } ! 332: printf (" };\n"); ! 333: ! 334: printf ("\nconst char insn_operand_strict_low[][MAX_RECOG_OPERANDS] =\n {\n"); ! 335: for (d = insn_data; d; d = d->next) ! 336: { ! 337: register int i; ! 338: printf (" {"); ! 339: for (i = 0; i < d->n_operands; i++) ! 340: printf (" %d,", d->strict_low[i]); ! 341: if (d->n_operands == 0) ! 342: printf (" 0"); ! 343: printf (" },\n"); ! 344: } ! 345: printf (" };\n"); ! 346: ! 347: { ! 348: /* We need to define all predicates used. Keep a list of those we ! 349: have defined so far. There normally aren't very many predicates used, ! 350: so a linked list should be fast enough. */ ! 351: struct predicate { char *name; struct predicate *next; } *predicates = 0; ! 352: struct predicate *p; ! 353: int i; ! 354: ! 355: printf ("\n"); ! 356: for (d = insn_data; d; d = d->next) ! 357: for (i = 0; i < d->n_operands; i++) ! 358: if (d->predicates[i] && d->predicates[i][0]) ! 359: { ! 360: for (p = predicates; p; p = p->next) ! 361: if (! strcmp (p->name, d->predicates[i])) ! 362: break; ! 363: ! 364: if (p == 0) ! 365: { ! 366: printf ("extern int %s ();\n", d->predicates[i]); ! 367: p = (struct predicate *) alloca (sizeof (struct predicate)); ! 368: p->name = d->predicates[i]; ! 369: p->next = predicates; ! 370: predicates = p; ! 371: } ! 372: } ! 373: ! 374: printf ("\nint (*const insn_operand_predicate[][MAX_RECOG_OPERANDS])() =\n {\n"); ! 375: for (d = insn_data; d; d = d->next) ! 376: { ! 377: printf (" {"); ! 378: for (i = 0; i < d->n_operands; i++) ! 379: printf (" %s,", ((d->predicates[i] && d->predicates[i][0]) ! 380: ? d->predicates[i] : "0")); ! 381: if (d->n_operands == 0) ! 382: printf (" 0"); ! 383: printf (" },\n"); ! 384: } ! 385: printf (" };\n"); ! 386: } ! 387: ! 388: printf ("\nconst int insn_n_alternatives[] =\n {\n"); ! 389: for (d = insn_data; d; d = d->next) ! 390: printf (" %d,\n", d->n_alternatives); ! 391: printf(" };\n"); ! 392: } ! 393: ! 394: /* scan_operands (X) stores in max_opno the largest operand ! 395: number present in X, if that is larger than the previous ! 396: value of max_opno. It stores all the constraints in `constraints' ! 397: and all the machine modes in `modes'. ! 398: ! 399: THIS_ADDRESS_P is nonzero if the containing rtx was an ADDRESS. ! 400: THIS_STRICT_LOW is nonzero if the containing rtx was a STRICT_LOW_PART. */ ! 401: ! 402: static int max_opno; ! 403: static int num_dups; ! 404: static char *constraints[MAX_MAX_OPERANDS]; ! 405: static int op_n_alternatives[MAX_MAX_OPERANDS]; ! 406: static char *predicates[MAX_MAX_OPERANDS]; ! 407: static char address_p[MAX_MAX_OPERANDS]; ! 408: static enum machine_mode modes[MAX_MAX_OPERANDS]; ! 409: static char strict_low[MAX_MAX_OPERANDS]; ! 410: static char seen[MAX_MAX_OPERANDS]; ! 411: ! 412: static void ! 413: scan_operands (part, this_address_p, this_strict_low) ! 414: rtx part; ! 415: int this_address_p; ! 416: int this_strict_low; ! 417: { ! 418: register int i, j; ! 419: register char *format_ptr; ! 420: int opno; ! 421: ! 422: if (part == 0) ! 423: return; ! 424: ! 425: switch (GET_CODE (part)) ! 426: { ! 427: case MATCH_OPERAND: ! 428: opno = XINT (part, 0); ! 429: if (opno > max_opno) ! 430: max_opno = opno; ! 431: if (max_opno >= MAX_MAX_OPERANDS) ! 432: { ! 433: error ("Too many operands (%d) in definition %d.\n", ! 434: max_opno + 1, next_index_number); ! 435: return; ! 436: } ! 437: if (seen[opno]) ! 438: error ("Definition %d specified operand number %d more than once.\n", ! 439: next_index_number, opno); ! 440: seen[opno] = 1; ! 441: modes[opno] = GET_MODE (part); ! 442: strict_low[opno] = this_strict_low; ! 443: predicates[opno] = XSTR (part, 1); ! 444: constraints[opno] = XSTR (part, 2); ! 445: if (XSTR (part, 2) != 0 && *XSTR (part, 2) != 0) ! 446: { ! 447: op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 2)) + 1; ! 448: have_constraints = 1; ! 449: } ! 450: address_p[opno] = this_address_p; ! 451: return; ! 452: ! 453: case MATCH_SCRATCH: ! 454: opno = XINT (part, 0); ! 455: if (opno > max_opno) ! 456: max_opno = opno; ! 457: if (max_opno >= MAX_MAX_OPERANDS) ! 458: { ! 459: error ("Too many operands (%d) in definition %d.\n", ! 460: max_opno + 1, next_index_number); ! 461: return; ! 462: } ! 463: if (seen[opno]) ! 464: error ("Definition %d specified operand number %d more than once.\n", ! 465: next_index_number, opno); ! 466: seen[opno] = 1; ! 467: modes[opno] = GET_MODE (part); ! 468: strict_low[opno] = 0; ! 469: predicates[opno] = "scratch_operand"; ! 470: constraints[opno] = XSTR (part, 1); ! 471: if (XSTR (part, 1) != 0 && *XSTR (part, 1) != 0) ! 472: { ! 473: op_n_alternatives[opno] = n_occurrences (',', XSTR (part, 1)) + 1; ! 474: have_constraints = 1; ! 475: } ! 476: address_p[opno] = 0; ! 477: return; ! 478: ! 479: case MATCH_OPERATOR: ! 480: case MATCH_PARALLEL: ! 481: opno = XINT (part, 0); ! 482: if (opno > max_opno) ! 483: max_opno = opno; ! 484: if (max_opno >= MAX_MAX_OPERANDS) ! 485: { ! 486: error ("Too many operands (%d) in definition %d.\n", ! 487: max_opno + 1, next_index_number); ! 488: return; ! 489: } ! 490: if (seen[opno]) ! 491: error ("Definition %d specified operand number %d more than once.\n", ! 492: next_index_number, opno); ! 493: seen[opno] = 1; ! 494: modes[opno] = GET_MODE (part); ! 495: strict_low[opno] = 0; ! 496: predicates[opno] = XSTR (part, 1); ! 497: constraints[opno] = 0; ! 498: address_p[opno] = 0; ! 499: for (i = 0; i < XVECLEN (part, 2); i++) ! 500: scan_operands (XVECEXP (part, 2, i), 0, 0); ! 501: return; ! 502: ! 503: case MATCH_DUP: ! 504: case MATCH_OP_DUP: ! 505: case MATCH_PAR_DUP: ! 506: ++num_dups; ! 507: return; ! 508: ! 509: case ADDRESS: ! 510: scan_operands (XEXP (part, 0), 1, 0); ! 511: return; ! 512: ! 513: case STRICT_LOW_PART: ! 514: scan_operands (XEXP (part, 0), 0, 1); ! 515: return; ! 516: } ! 517: ! 518: format_ptr = GET_RTX_FORMAT (GET_CODE (part)); ! 519: ! 520: for (i = 0; i < GET_RTX_LENGTH (GET_CODE (part)); i++) ! 521: switch (*format_ptr++) ! 522: { ! 523: case 'e': ! 524: scan_operands (XEXP (part, i), 0, 0); ! 525: break; ! 526: case 'E': ! 527: if (XVEC (part, i) != NULL) ! 528: for (j = 0; j < XVECLEN (part, i); j++) ! 529: scan_operands (XVECEXP (part, i, j), 0, 0); ! 530: break; ! 531: } ! 532: } ! 533: ! 534: /* Process an assembler template from a define_insn or a define_peephole. ! 535: It is either the assembler code template, a list of assembler code ! 536: templates, or C code to generate the assembler code template. */ ! 537: ! 538: static void ! 539: process_template (d, template) ! 540: struct data *d; ! 541: char *template; ! 542: { ! 543: register char *cp; ! 544: register int i; ! 545: ! 546: /* We need to consider only the instructions whose assembler code template ! 547: starts with a * or @. These are the ones where C code is run to decide ! 548: on a template to use. So for all others just return now. */ ! 549: ! 550: if (template[0] != '*' && template[0] != '@') ! 551: { ! 552: d->template = template; ! 553: d->outfun = 0; ! 554: return; ! 555: } ! 556: ! 557: d->template = 0; ! 558: d->outfun = 1; ! 559: ! 560: printf ("\nstatic char *\n"); ! 561: printf ("output_%d (operands, insn)\n", d->code_number); ! 562: printf (" rtx *operands;\n"); ! 563: printf (" rtx insn;\n"); ! 564: printf ("{\n"); ! 565: ! 566: /* If the assembler code template starts with a @ it is a newline-separated ! 567: list of assembler code templates, one for each alternative. So produce ! 568: a routine to select the correct one. */ ! 569: ! 570: if (template[0] == '@') ! 571: { ! 572: ! 573: printf (" static /*const*/ char *const strings_%d[] = {\n", ! 574: d->code_number); ! 575: ! 576: for (i = 0, cp = &template[1]; *cp; ) ! 577: { ! 578: while (*cp == '\n' || *cp == ' ' || *cp== '\t') ! 579: cp++; ! 580: ! 581: printf (" \""); ! 582: while (*cp != '\n' && *cp != '\0') ! 583: putchar (*cp++); ! 584: ! 585: printf ("\",\n"); ! 586: i++; ! 587: } ! 588: ! 589: printf (" };\n"); ! 590: printf (" return strings_%d[which_alternative];\n", d->code_number); ! 591: ! 592: if (i != d->n_alternatives) ! 593: fatal ("Insn pattern %d has %d alternatives but %d assembler choices", ! 594: d->index_number, d->n_alternatives, i); ! 595: ! 596: } ! 597: else ! 598: { ! 599: /* The following is done in a funny way to get around problems in ! 600: VAX-11 "C" on VMS. It is the equivalent of: ! 601: printf ("%s\n", &template[1])); */ ! 602: cp = &template[1]; ! 603: while (*cp) putchar (*cp++); ! 604: putchar ('\n'); ! 605: } ! 606: ! 607: printf ("}\n"); ! 608: } ! 609: ! 610: /* Check insn D for consistency in number of constraint alternatives. */ ! 611: ! 612: static void ! 613: validate_insn_alternatives (d) ! 614: struct data *d; ! 615: { ! 616: register int n = 0, start; ! 617: /* Make sure all the operands have the same number of ! 618: alternatives in their constraints. ! 619: Let N be that number. */ ! 620: for (start = 0; start < d->n_operands; start++) ! 621: if (d->op_n_alternatives[start] > 0) ! 622: { ! 623: if (n == 0) ! 624: n = d->op_n_alternatives[start]; ! 625: else if (n != d->op_n_alternatives[start]) ! 626: error ("wrong number of alternatives in operand %d of insn number %d", ! 627: start, d->index_number); ! 628: } ! 629: /* Record the insn's overall number of alternatives. */ ! 630: d->n_alternatives = n; ! 631: } ! 632: ! 633: /* Look at a define_insn just read. Assign its code number. ! 634: Record on insn_data the template and the number of arguments. ! 635: If the insn has a hairy output action, output a function for now. */ ! 636: ! 637: static void ! 638: gen_insn (insn) ! 639: rtx insn; ! 640: { ! 641: register struct data *d = (struct data *) xmalloc (sizeof (struct data)); ! 642: register int i; ! 643: ! 644: d->code_number = next_code_number++; ! 645: d->index_number = next_index_number; ! 646: if (XSTR (insn, 0)[0]) ! 647: d->name = XSTR (insn, 0); ! 648: else ! 649: d->name = 0; ! 650: ! 651: /* Build up the list in the same order as the insns are seen ! 652: in the machine description. */ ! 653: d->next = 0; ! 654: if (end_of_insn_data) ! 655: end_of_insn_data->next = d; ! 656: else ! 657: insn_data = d; ! 658: ! 659: end_of_insn_data = d; ! 660: ! 661: max_opno = -1; ! 662: num_dups = 0; ! 663: ! 664: mybzero (constraints, sizeof constraints); ! 665: mybzero (op_n_alternatives, sizeof op_n_alternatives); ! 666: mybzero (predicates, sizeof predicates); ! 667: mybzero (address_p, sizeof address_p); ! 668: mybzero (modes, sizeof modes); ! 669: mybzero (strict_low, sizeof strict_low); ! 670: mybzero (seen, sizeof seen); ! 671: ! 672: for (i = 0; i < XVECLEN (insn, 1); i++) ! 673: scan_operands (XVECEXP (insn, 1, i), 0, 0); ! 674: ! 675: d->n_operands = max_opno + 1; ! 676: d->n_dups = num_dups; ! 677: ! 678: mybcopy (constraints, d->constraints, sizeof constraints); ! 679: mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives); ! 680: mybcopy (predicates, d->predicates, sizeof predicates); ! 681: mybcopy (address_p, d->address_p, sizeof address_p); ! 682: mybcopy (modes, d->modes, sizeof modes); ! 683: mybcopy (strict_low, d->strict_low, sizeof strict_low); ! 684: ! 685: validate_insn_alternatives (d); ! 686: process_template (d, XSTR (insn, 3)); ! 687: } ! 688: ! 689: /* Look at a define_peephole just read. Assign its code number. ! 690: Record on insn_data the template and the number of arguments. ! 691: If the insn has a hairy output action, output it now. */ ! 692: ! 693: static void ! 694: gen_peephole (peep) ! 695: rtx peep; ! 696: { ! 697: register struct data *d = (struct data *) xmalloc (sizeof (struct data)); ! 698: register int i; ! 699: ! 700: d->code_number = next_code_number++; ! 701: d->index_number = next_index_number; ! 702: d->name = 0; ! 703: ! 704: /* Build up the list in the same order as the insns are seen ! 705: in the machine description. */ ! 706: d->next = 0; ! 707: if (end_of_insn_data) ! 708: end_of_insn_data->next = d; ! 709: else ! 710: insn_data = d; ! 711: ! 712: end_of_insn_data = d; ! 713: ! 714: max_opno = -1; ! 715: mybzero (constraints, sizeof constraints); ! 716: mybzero (op_n_alternatives, sizeof op_n_alternatives); ! 717: mybzero (predicates, sizeof predicates); ! 718: mybzero (address_p, sizeof address_p); ! 719: mybzero (modes, sizeof modes); ! 720: mybzero (strict_low, sizeof strict_low); ! 721: mybzero (seen, sizeof seen); ! 722: ! 723: /* Get the number of operands by scanning all the ! 724: patterns of the peephole optimizer. ! 725: But ignore all the rest of the information thus obtained. */ ! 726: for (i = 0; i < XVECLEN (peep, 0); i++) ! 727: scan_operands (XVECEXP (peep, 0, i), 0, 0); ! 728: ! 729: d->n_operands = max_opno + 1; ! 730: d->n_dups = 0; ! 731: ! 732: mybcopy (constraints, d->constraints, sizeof constraints); ! 733: mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives); ! 734: mybzero (d->predicates, sizeof predicates); ! 735: mybzero (d->address_p, sizeof address_p); ! 736: mybzero (d->modes, sizeof modes); ! 737: mybzero (d->strict_low, sizeof strict_low); ! 738: ! 739: validate_insn_alternatives (d); ! 740: process_template (d, XSTR (peep, 2)); ! 741: } ! 742: ! 743: /* Process a define_expand just read. Assign its code number, ! 744: only for the purposes of `insn_gen_function'. */ ! 745: ! 746: static void ! 747: gen_expand (insn) ! 748: rtx insn; ! 749: { ! 750: register struct data *d = (struct data *) xmalloc (sizeof (struct data)); ! 751: register int i; ! 752: ! 753: d->code_number = next_code_number++; ! 754: d->index_number = next_index_number; ! 755: if (XSTR (insn, 0)[0]) ! 756: d->name = XSTR (insn, 0); ! 757: else ! 758: d->name = 0; ! 759: ! 760: /* Build up the list in the same order as the insns are seen ! 761: in the machine description. */ ! 762: d->next = 0; ! 763: if (end_of_insn_data) ! 764: end_of_insn_data->next = d; ! 765: else ! 766: insn_data = d; ! 767: ! 768: end_of_insn_data = d; ! 769: ! 770: max_opno = -1; ! 771: num_dups = 0; ! 772: ! 773: /* Scan the operands to get the specified predicates and modes, ! 774: since expand_binop needs to know them. */ ! 775: ! 776: mybzero (constraints, sizeof constraints); ! 777: mybzero (op_n_alternatives, sizeof op_n_alternatives); ! 778: mybzero (predicates, sizeof predicates); ! 779: mybzero (address_p, sizeof address_p); ! 780: mybzero (modes, sizeof modes); ! 781: mybzero (strict_low, sizeof strict_low); ! 782: mybzero (seen, sizeof seen); ! 783: ! 784: if (XVEC (insn, 1)) ! 785: for (i = 0; i < XVECLEN (insn, 1); i++) ! 786: scan_operands (XVECEXP (insn, 1, i), 0, 0); ! 787: ! 788: d->n_operands = max_opno + 1; ! 789: d->n_dups = num_dups; ! 790: ! 791: mybcopy (constraints, d->constraints, sizeof constraints); ! 792: mybcopy (op_n_alternatives, d->op_n_alternatives, sizeof op_n_alternatives); ! 793: mybcopy (predicates, d->predicates, sizeof predicates); ! 794: mybcopy (address_p, d->address_p, sizeof address_p); ! 795: mybcopy (modes, d->modes, sizeof modes); ! 796: mybcopy (strict_low, d->strict_low, sizeof strict_low); ! 797: ! 798: d->template = 0; ! 799: d->outfun = 0; ! 800: validate_insn_alternatives (d); ! 801: } ! 802: ! 803: /* Process a define_split just read. Assign its code number, ! 804: only for reasons of consistency and to simplify genrecog. */ ! 805: ! 806: ! 807: static void ! 808: gen_split (split) ! 809: rtx split; ! 810: { ! 811: register struct data *d = (struct data *) xmalloc (sizeof (struct data)); ! 812: register int i; ! 813: ! 814: d->code_number = next_code_number++; ! 815: d->index_number = next_index_number; ! 816: d->name = 0; ! 817: ! 818: /* Build up the list in the same order as the insns are seen ! 819: in the machine description. */ ! 820: d->next = 0; ! 821: if (end_of_insn_data) ! 822: end_of_insn_data->next = d; ! 823: else ! 824: insn_data = d; ! 825: ! 826: end_of_insn_data = d; ! 827: ! 828: max_opno = -1; ! 829: num_dups = 0; ! 830: ! 831: mybzero (constraints, sizeof constraints); ! 832: mybzero (op_n_alternatives, sizeof op_n_alternatives); ! 833: mybzero (predicates, sizeof predicates); ! 834: mybzero (address_p, sizeof address_p); ! 835: mybzero (modes, sizeof modes); ! 836: mybzero (strict_low, sizeof strict_low); ! 837: mybzero (seen, sizeof seen); ! 838: ! 839: /* Get the number of operands by scanning all the ! 840: patterns of the split patterns. ! 841: But ignore all the rest of the information thus obtained. */ ! 842: for (i = 0; i < XVECLEN (split, 0); i++) ! 843: scan_operands (XVECEXP (split, 0, i), 0, 0); ! 844: ! 845: d->n_operands = max_opno + 1; ! 846: ! 847: mybzero (d->constraints, sizeof constraints); ! 848: mybzero (d->op_n_alternatives, sizeof op_n_alternatives); ! 849: mybzero (d->predicates, sizeof predicates); ! 850: mybzero (d->address_p, sizeof address_p); ! 851: mybzero (d->modes, sizeof modes); ! 852: mybzero (d->strict_low, sizeof strict_low); ! 853: ! 854: d->n_dups = 0; ! 855: d->n_alternatives = 0; ! 856: d->template = 0; ! 857: d->outfun = 0; ! 858: } ! 859: ! 860: char * ! 861: xmalloc (size) ! 862: unsigned size; ! 863: { ! 864: register char *val = (char *) malloc (size); ! 865: ! 866: if (val == 0) ! 867: fatal ("virtual memory exhausted"); ! 868: return val; ! 869: } ! 870: ! 871: char * ! 872: xrealloc (ptr, size) ! 873: char *ptr; ! 874: unsigned size; ! 875: { ! 876: char *result = (char *) realloc (ptr, size); ! 877: if (!result) ! 878: fatal ("virtual memory exhausted"); ! 879: return result; ! 880: } ! 881: ! 882: static void ! 883: mybzero (b, length) ! 884: register char *b; ! 885: register unsigned length; ! 886: { ! 887: while (length-- > 0) ! 888: *b++ = 0; ! 889: } ! 890: ! 891: static void ! 892: mybcopy (b1, b2, length) ! 893: register char *b1; ! 894: register char *b2; ! 895: register unsigned length; ! 896: { ! 897: while (length-- > 0) ! 898: *b2++ = *b1++; ! 899: } ! 900: ! 901: static void ! 902: fatal (s, a1, a2, a3, a4) ! 903: char *s; ! 904: { ! 905: fprintf (stderr, "genoutput: "); ! 906: fprintf (stderr, s, a1, a2, a3, a4); ! 907: fprintf (stderr, "\n"); ! 908: exit (FATAL_EXIT_CODE); ! 909: } ! 910: ! 911: /* More 'friendly' abort that prints the line and file. ! 912: config.h can #define abort fancy_abort if you like that sort of thing. */ ! 913: ! 914: void ! 915: fancy_abort () ! 916: { ! 917: fatal ("Internal gcc abort."); ! 918: } ! 919: ! 920: static void ! 921: error (s, a1, a2) ! 922: char *s; ! 923: { ! 924: fprintf (stderr, "genoutput: "); ! 925: fprintf (stderr, s, a1, a2); ! 926: fprintf (stderr, "\n"); ! 927: ! 928: have_error = 1; ! 929: } ! 930: ! 931: int ! 932: main (argc, argv) ! 933: int argc; ! 934: char **argv; ! 935: { ! 936: rtx desc; ! 937: FILE *infile; ! 938: register int c; ! 939: ! 940: obstack_init (rtl_obstack); ! 941: ! 942: if (argc <= 1) ! 943: fatal ("No input file name."); ! 944: ! 945: infile = fopen (argv[1], "r"); ! 946: if (infile == 0) ! 947: { ! 948: perror (argv[1]); ! 949: exit (FATAL_EXIT_CODE); ! 950: } ! 951: ! 952: init_rtl (); ! 953: ! 954: output_prologue (); ! 955: next_code_number = 0; ! 956: next_index_number = 0; ! 957: have_constraints = 0; ! 958: ! 959: /* Read the machine description. */ ! 960: ! 961: while (1) ! 962: { ! 963: c = read_skip_spaces (infile); ! 964: if (c == EOF) ! 965: break; ! 966: ungetc (c, infile); ! 967: ! 968: desc = read_rtx (infile); ! 969: if (GET_CODE (desc) == DEFINE_INSN) ! 970: gen_insn (desc); ! 971: if (GET_CODE (desc) == DEFINE_PEEPHOLE) ! 972: gen_peephole (desc); ! 973: if (GET_CODE (desc) == DEFINE_EXPAND) ! 974: gen_expand (desc); ! 975: if (GET_CODE (desc) == DEFINE_SPLIT) ! 976: gen_split (desc); ! 977: next_index_number++; ! 978: } ! 979: ! 980: output_epilogue (); ! 981: ! 982: fflush (stdout); ! 983: exit (ferror (stdout) != 0 || have_error ! 984: ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE); ! 985: ! 986: /* NOTREACHED */ ! 987: return 0; ! 988: } ! 989: ! 990: static int ! 991: n_occurrences (c, s) ! 992: char c; ! 993: char *s; ! 994: { ! 995: int n = 0; ! 996: while (*s) ! 997: n += (*s++ == c); ! 998: return n; ! 999: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.