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