Return to rtl.c CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/rtl.c, revision 1.1

1.1     ! root        1: /* Allocate and read RTL for GNU C Compiler.
        !             2:    Copyright (C) 1987, 1988, 1991 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: #include "config.h"
        !            22: #include <ctype.h>
        !            23: #include <stdio.h>
        !            24: #include "rtl.h"
        !            25: 
        !            26: #include "obstack.h"
        !            27: #define        obstack_chunk_alloc     xmalloc
        !            28: #define        obstack_chunk_free      free
        !            29: extern int xmalloc ();
        !            30: extern void free ();
        !            31: 
        !            32: /* Obstack used for allocating RTL objects.
        !            33:    Between functions, this is the permanent_obstack.
        !            34:    While parsing and expanding a function, this is maybepermanent_obstack
        !            35:    so we can save it if it is an inline function.
        !            36:    During optimization and output, this is function_obstack.  */
        !            37: 
        !            38: extern struct obstack *rtl_obstack;
        !            39: 
        !            40: extern long ftell();
        !            41: 
        !            42: /* Indexed by rtx code, gives number of operands for an rtx with that code.
        !            43:    Does NOT include rtx header data (code and links).
        !            44:    This array is initialized in init_rtl.  */
        !            45: 
        !            46: int rtx_length[NUM_RTX_CODE + 1];
        !            47: 
        !            48: /* Indexed by rtx code, gives the name of that kind of rtx, as a C string.  */
        !            49: 
        !            50: #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
        !            51: 
        !            52: char *rtx_name[] = {
        !            53: #include "rtl.def"             /* rtl expressions are documented here */
        !            54: };
        !            55: 
        !            56: #undef DEF_RTL_EXPR
        !            57: 
        !            58: /* Indexed by machine mode, gives the name of that machine mode.
        !            59:    This name does not include the letters "mode".  */
        !            60: 
        !            61: #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  NAME,
        !            62: 
        !            63: char *mode_name[(int) MAX_MACHINE_MODE] = {
        !            64: #include "machmode.def"
        !            65: 
        !            66: #ifdef EXTRA_CC_MODES
        !            67:   EXTRA_CC_NAMES
        !            68: #endif
        !            69: 
        !            70: };
        !            71: 
        !            72: #undef DEF_MACHMODE
        !            73: 
        !            74: /* Indexed by machine mode, gives the length of the mode, in bytes.
        !            75:    GET_MODE_CLASS uses this.  */
        !            76: 
        !            77: #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  CLASS,
        !            78: 
        !            79: enum mode_class mode_class[(int) MAX_MACHINE_MODE] = {
        !            80: #include "machmode.def"
        !            81: };
        !            82: 
        !            83: #undef DEF_MACHMODE
        !            84: 
        !            85: /* Indexed by machine mode, gives the length of the mode, in bytes.
        !            86:    GET_MODE_SIZE uses this.  */
        !            87: 
        !            88: #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  SIZE,
        !            89: 
        !            90: int mode_size[(int) MAX_MACHINE_MODE] = {
        !            91: #include "machmode.def"
        !            92: };
        !            93: 
        !            94: #undef DEF_MACHMODE
        !            95: 
        !            96: /* Indexed by machine mode, gives the length of the mode's subunit.
        !            97:    GET_MODE_UNIT_SIZE uses this.  */
        !            98: 
        !            99: #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  UNIT,
        !           100: 
        !           101: int mode_unit_size[(int) MAX_MACHINE_MODE] = {
        !           102: #include "machmode.def"                /* machine modes are documented here */
        !           103: };
        !           104: 
        !           105: #undef DEF_MACHMODE
        !           106: 
        !           107: /* Indexed by machine mode, gives next wider natural mode
        !           108:    (QI -> HI -> SI -> DI, etc.)  Widening multiply instructions
        !           109:    use this.  */
        !           110: 
        !           111: #define DEF_MACHMODE(SYM, NAME, CLASS, SIZE, UNIT, WIDER)  \
        !           112:   (enum machine_mode) WIDER,
        !           113: 
        !           114: enum machine_mode mode_wider_mode[(int) MAX_MACHINE_MODE] = {
        !           115: #include "machmode.def"                /* machine modes are documented here */
        !           116: };
        !           117: 
        !           118: #undef DEF_MACHMODE
        !           119: 
        !           120: /* Indexed by mode class, gives the narrowest mode for each class.  */
        !           121: 
        !           122: enum machine_mode class_narrowest_mode[(int) MAX_MODE_CLASS];
        !           123: 
        !           124: /* Commonly used modes.  */
        !           125: 
        !           126: enum machine_mode byte_mode;   /* Mode whose width is BITS_PER_UNIT */
        !           127: enum machine_mode word_mode;   /* Mode whose width is BITS_PER_WORD */
        !           128: 
        !           129: /* Indexed by rtx code, gives a sequence of operand-types for
        !           130:    rtx's of that code.  The sequence is a C string in which
        !           131:    each charcter describes one operand.  */
        !           132: 
        !           133: char *rtx_format[] = {
        !           134:   /* "*" undefined.
        !           135:          can cause a warning message
        !           136:      "0" field is unused (or used in a phase-dependent manner)
        !           137:          prints nothing
        !           138:      "i" an integer
        !           139:          prints the integer
        !           140:      "n" like "i", but prints entries from `note_insn_name'
        !           141:      "s" a pointer to a string
        !           142:          prints the string
        !           143:      "S" like "s", but optional:
        !           144:         the containing rtx may end before this operand
        !           145:      "e" a pointer to an rtl expression
        !           146:          prints the expression
        !           147:      "E" a pointer to a vector that points to a number of rtl expressions
        !           148:          prints a list of the rtl expressions
        !           149:      "V" like "E", but optional:
        !           150:         the containing rtx may end before this operand
        !           151:      "u" a pointer to another insn
        !           152:          prints the uid of the insn.  */
        !           153: 
        !           154: #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
        !           155: #include "rtl.def"             /* rtl expressions are defined here */
        !           156: #undef DEF_RTL_EXPR
        !           157: };
        !           158: 
        !           159: /* Indexed by rtx code, gives a character representing the "class" of
        !           160:    that rtx code.  See rtl.def for documentation on the defined classes.  */
        !           161: 
        !           162: char rtx_class[] = {
        !           163: #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   CLASS, 
        !           164: #include "rtl.def"             /* rtl expressions are defined here */
        !           165: #undef DEF_RTL_EXPR
        !           166: };
        !           167: 
        !           168: /* Names for kinds of NOTEs and REG_NOTEs.  */
        !           169: 
        !           170: char *note_insn_name[] = { "NOTE_INSN_FUNCTION_BEG", "NOTE_INSN_DELETED",
        !           171:                           "NOTE_INSN_BLOCK_BEG", "NOTE_INSN_BLOCK_END",
        !           172:                           "NOTE_INSN_LOOP_BEG", "NOTE_INSN_LOOP_END",
        !           173:                           "NOTE_INSN_FUNCTION_END", "NOTE_INSN_SETJMP",
        !           174:                           "NOTE_INSN_LOOP_CONT", "NOTE_INSN_LOOP_VTOP" };
        !           175: 
        !           176: char *reg_note_name[] = { "", "REG_DEAD", "REG_INC", "REG_EQUIV", "REG_WAS_0",
        !           177:                          "REG_EQUAL", "REG_RETVAL", "REG_LIBCALL",
        !           178:                          "REG_NONNEG", "REG_NO_CONFLICT", "REG_UNUSED",
        !           179:                          "REG_CC_SETTER", "REG_CC_USER", "REG_LABEL",
        !           180:                          "REG_DEP_ANTI", "REG_DEP_OUTPUT" };
        !           181: 
        !           182: /* Allocate an rtx vector of N elements.
        !           183:    Store the length, and initialize all elements to zero.  */
        !           184: 
        !           185: rtvec
        !           186: rtvec_alloc (n)
        !           187:      int n;
        !           188: {
        !           189:   rtvec rt;
        !           190:   int i;
        !           191: 
        !           192:   rt = (rtvec) obstack_alloc (rtl_obstack,
        !           193:                              sizeof (struct rtvec_def)
        !           194:                              + (( n - 1) * sizeof (rtunion)));
        !           195: 
        !           196:   /* clear out the vector */
        !           197:   PUT_NUM_ELEM(rt, n);
        !           198:   for (i=0; i < n; i++)
        !           199:     rt->elem[i].rtvec = NULL;  /* @@ not portable due to rtunion */
        !           200: 
        !           201:   return rt;
        !           202: }
        !           203: 
        !           204: /* Allocate an rtx of code CODE.  The CODE is stored in the rtx;
        !           205:    all the rest is initialized to zero.  */
        !           206: 
        !           207: rtx
        !           208: rtx_alloc (code)
        !           209:   RTX_CODE code;
        !           210: {
        !           211:   rtx rt;
        !           212:   register struct obstack *ob = rtl_obstack;
        !           213:   register int nelts = GET_RTX_LENGTH (code);
        !           214:   register int length = sizeof (struct rtx_def)
        !           215:     + (nelts - 1) * sizeof (rtunion);
        !           216: 
        !           217:   /* This function is called more than any other in GCC,
        !           218:      so we manipulate the obstack directly.
        !           219: 
        !           220:      Even though rtx objects are word aligned, we may be sharing an obstack
        !           221:      with tree nodes, which may have to be double-word aligned.  So align
        !           222:      our length to the alignment mask in the obstack.  */
        !           223: 
        !           224:   length = (length + ob->alignment_mask) & ~ ob->alignment_mask;
        !           225: 
        !           226:   if (ob->chunk_limit - ob->next_free < length)
        !           227:     _obstack_newchunk (ob, length);
        !           228:   rt = (rtx)ob->object_base;
        !           229:   ob->next_free += length;
        !           230:   ob->object_base = ob->next_free;
        !           231: 
        !           232:   * (int *) rt = 0;
        !           233:   PUT_CODE (rt, code);
        !           234: 
        !           235:   return rt;
        !           236: }
        !           237: 
        !           238: /* Create a new copy of an rtx.
        !           239:    Recursively copies the operands of the rtx,
        !           240:    except for those few rtx codes that are sharable.  */
        !           241: 
        !           242: rtx
        !           243: copy_rtx (orig)
        !           244:      register rtx orig;
        !           245: {
        !           246:   register rtx copy;
        !           247:   register int i, j;
        !           248:   register RTX_CODE code;
        !           249:   register char *format_ptr;
        !           250: 
        !           251:   code = GET_CODE (orig);
        !           252: 
        !           253:   switch (code)
        !           254:     {
        !           255:     case REG:
        !           256:     case QUEUED:
        !           257:     case CONST_INT:
        !           258:     case CONST_DOUBLE:
        !           259:     case SYMBOL_REF:
        !           260:     case CODE_LABEL:
        !           261:     case PC:
        !           262:     case CC0:
        !           263:       return orig;
        !           264:     }
        !           265: 
        !           266:   copy = rtx_alloc (code);
        !           267:   PUT_MODE (copy, GET_MODE (orig));
        !           268:   copy->in_struct = orig->in_struct;
        !           269:   copy->volatil = orig->volatil;
        !           270:   copy->unchanging = orig->unchanging;
        !           271:   copy->integrated = orig->integrated;
        !           272:   
        !           273:   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
        !           274: 
        !           275:   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
        !           276:     {
        !           277:       switch (*format_ptr++)
        !           278:        {
        !           279:        case 'e':
        !           280:          XEXP (copy, i) = XEXP (orig, i);
        !           281:          if (XEXP (orig, i) != NULL)
        !           282:            XEXP (copy, i) = copy_rtx (XEXP (orig, i));
        !           283:          break;
        !           284: 
        !           285:        case 'E':
        !           286:        case 'V':
        !           287:          XVEC (copy, i) = XVEC (orig, i);
        !           288:          if (XVEC (orig, i) != NULL)
        !           289:            {
        !           290:              XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
        !           291:              for (j = 0; j < XVECLEN (copy, i); j++)
        !           292:                XVECEXP (copy, i, j) = copy_rtx (XVECEXP (orig, i, j));
        !           293:            }
        !           294:          break;
        !           295: 
        !           296:        default:
        !           297:          XINT (copy, i) = XINT (orig, i);
        !           298:          break;
        !           299:        }
        !           300:     }
        !           301:   return copy;
        !           302: }
        !           303: 
        !           304: /* Similar to `copy_rtx' except that if MAY_SHARE is present, it is
        !           305:    placed in the result directly, rather than being copied.  */
        !           306: 
        !           307: rtx
        !           308: copy_most_rtx (orig, may_share)
        !           309:      register rtx orig;
        !           310:      register rtx may_share;
        !           311: {
        !           312:   register rtx copy;
        !           313:   register int i, j;
        !           314:   register RTX_CODE code;
        !           315:   register char *format_ptr;
        !           316: 
        !           317:   if (orig == may_share)
        !           318:     return orig;
        !           319: 
        !           320:   code = GET_CODE (orig);
        !           321: 
        !           322:   switch (code)
        !           323:     {
        !           324:     case REG:
        !           325:     case QUEUED:
        !           326:     case CONST_INT:
        !           327:     case CONST_DOUBLE:
        !           328:     case SYMBOL_REF:
        !           329:     case CODE_LABEL:
        !           330:     case PC:
        !           331:     case CC0:
        !           332:       return orig;
        !           333:     }
        !           334: 
        !           335:   copy = rtx_alloc (code);
        !           336:   PUT_MODE (copy, GET_MODE (orig));
        !           337:   copy->in_struct = orig->in_struct;
        !           338:   copy->volatil = orig->volatil;
        !           339:   copy->unchanging = orig->unchanging;
        !           340:   copy->integrated = orig->integrated;
        !           341:   
        !           342:   format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
        !           343: 
        !           344:   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
        !           345:     {
        !           346:       switch (*format_ptr++)
        !           347:        {
        !           348:        case 'e':
        !           349:          XEXP (copy, i) = XEXP (orig, i);
        !           350:          if (XEXP (orig, i) != NULL && XEXP (orig, i) != may_share)
        !           351:            XEXP (copy, i) = copy_most_rtx (XEXP (orig, i), may_share);
        !           352:          break;
        !           353: 
        !           354:        case 'E':
        !           355:        case 'V':
        !           356:          XVEC (copy, i) = XVEC (orig, i);
        !           357:          if (XVEC (orig, i) != NULL)
        !           358:            {
        !           359:              XVEC (copy, i) = rtvec_alloc (XVECLEN (orig, i));
        !           360:              for (j = 0; j < XVECLEN (copy, i); j++)
        !           361:                XVECEXP (copy, i, j)
        !           362:                  = copy_most_rtx (XVECEXP (orig, i, j), may_share);
        !           363:            }
        !           364:          break;
        !           365: 
        !           366:        default:
        !           367:          XINT (copy, i) = XINT (orig, i);
        !           368:          break;
        !           369:        }
        !           370:     }
        !           371:   return copy;
        !           372: }
        !           373: 
        !           374: /* Helper functions for instruction scheduling.  */
        !           375: 
        !           376: /* Add ELEM wrapped in an INSN_LIST with reg note kind DEP_TYPE to the
        !           377:    LOG_LINKS of INSN, if not already there.  DEP_TYPE indicates the type
        !           378:    of dependence that this link represents.  */
        !           379: 
        !           380: void
        !           381: add_dependence (insn, elem, dep_type)
        !           382:      rtx insn;
        !           383:      rtx elem;
        !           384:      enum reg_note dep_type;
        !           385: {
        !           386:   rtx link;
        !           387: 
        !           388:   /* Don't depend an insn on itself.  */
        !           389:   if (insn == elem)
        !           390:     return;
        !           391: 
        !           392:   /* If elem is part of a sequence that must be scheduled together, then
        !           393:      make the dependence point to the last insn of the sequence.  */
        !           394:   if (NEXT_INSN (elem) && SCHED_GROUP_P (NEXT_INSN (elem)))
        !           395:     {
        !           396:       while (NEXT_INSN (elem) && SCHED_GROUP_P (NEXT_INSN (elem)))
        !           397:        elem = NEXT_INSN (elem);
        !           398:       /* Again, don't depend an insn of itself.  */
        !           399:       if (insn == elem)
        !           400:        return;
        !           401:     }
        !           402: 
        !           403:   /* Check that we don't already have this dependence.  */
        !           404:   for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
        !           405:     if (XEXP (link, 0) == elem)
        !           406:       {
        !           407:        /* If this is a more restrictive type of dependence than the existing
        !           408:           one, then change the existing dependence to this type.  */
        !           409:        if ((int) dep_type < (int) REG_NOTE_KIND (link))
        !           410:          PUT_REG_NOTE_KIND (link, dep_type);
        !           411:        return;
        !           412:       }
        !           413:   /* Might want to check one level of transitivity to save conses.  */
        !           414: 
        !           415:   link = rtx_alloc (INSN_LIST);
        !           416:   /* Insn dependency, not data dependency.  */
        !           417:   PUT_REG_NOTE_KIND (link, dep_type);
        !           418:   XEXP (link, 0) = elem;
        !           419:   XEXP (link, 1) = LOG_LINKS (insn);
        !           420:   LOG_LINKS (insn) = link;
        !           421: }
        !           422: 
        !           423: /* Remove ELEM wrapped in an INSN_LIST from the LOG_LINKS
        !           424:    of INSN.  Abort if not found.  */
        !           425: void
        !           426: remove_dependence (insn, elem)
        !           427:      rtx insn;
        !           428:      rtx elem;
        !           429: {
        !           430:   rtx prev, link;
        !           431:   int found = 0;
        !           432: 
        !           433:   for (prev = 0, link = LOG_LINKS (insn); link;
        !           434:        prev = link, link = XEXP (link, 1))
        !           435:     {
        !           436:       if (XEXP (link, 0) == elem)
        !           437:        {
        !           438:          if (prev)
        !           439:            XEXP (prev, 1) = XEXP (link, 1);
        !           440:          else
        !           441:            LOG_LINKS (insn) = XEXP (link, 1);
        !           442:          found = 1;
        !           443:        }
        !           444:     }
        !           445: 
        !           446:   if (! found)
        !           447:     abort ();
        !           448:   return;
        !           449: }
        !           450: 
        !           451: /* Subroutines of read_rtx.  */
        !           452: 
        !           453: /* Dump code after printing a message.  Used when read_rtx finds
        !           454:    invalid data.  */
        !           455: 
        !           456: static void
        !           457: dump_and_abort (expected_c, actual_c, infile)
        !           458:      int expected_c, actual_c;
        !           459:      FILE *infile;
        !           460: {
        !           461:   int c, i;
        !           462: 
        !           463:   if (expected_c >= 0)
        !           464:     fprintf (stderr,
        !           465:             "Expected character %c.  Found character %c.",
        !           466:             expected_c, actual_c);
        !           467:   fprintf (stderr, "  At file position: %ld\n", ftell (infile));
        !           468:   fprintf (stderr, "Following characters are:\n\t");
        !           469:   for (i = 0; i < 200; i++)
        !           470:     {
        !           471:       c = getc (infile);
        !           472:       if (EOF == c) break;
        !           473:       putc (c, stderr);
        !           474:     }
        !           475:   fprintf (stderr, "Aborting.\n");
        !           476:   abort ();
        !           477: }
        !           478: 
        !           479: /* Read chars from INFILE until a non-whitespace char
        !           480:    and return that.  Comments, both Lisp style and C style,
        !           481:    are treated as whitespace.
        !           482:    Tools such as genflags use this function.  */
        !           483: 
        !           484: int
        !           485: read_skip_spaces (infile)
        !           486:      FILE *infile;
        !           487: {
        !           488:   register int c;
        !           489:   while (c = getc (infile))
        !           490:     {
        !           491:       if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
        !           492:        ;
        !           493:       else if (c == ';')
        !           494:        {
        !           495:          while ((c = getc (infile)) && c != '\n') ;
        !           496:        }
        !           497:       else if (c == '/')
        !           498:        {
        !           499:          register int prevc;
        !           500:          c = getc (infile);
        !           501:          if (c != '*')
        !           502:            dump_and_abort ('*', c, infile);
        !           503:          
        !           504:          prevc = 0;
        !           505:          while (c = getc (infile))
        !           506:            {
        !           507:              if (prevc == '*' && c == '/')
        !           508:                break;
        !           509:              prevc = c;
        !           510:            }
        !           511:        }
        !           512:       else break;
        !           513:     }
        !           514:   return c;
        !           515: }
        !           516: 
        !           517: /* Read an rtx code name into the buffer STR[].
        !           518:    It is terminated by any of the punctuation chars of rtx printed syntax.  */
        !           519: 
        !           520: static void
        !           521: read_name (str, infile)
        !           522:      char *str;
        !           523:      FILE *infile;
        !           524: {
        !           525:   register char *p;
        !           526:   register int c;
        !           527: 
        !           528:   c = read_skip_spaces(infile);
        !           529: 
        !           530:   p = str;
        !           531:   while (1)
        !           532:     {
        !           533:       if (c == ' ' || c == '\n' || c == '\t' || c == '\f')
        !           534:        break;
        !           535:       if (c == ':' || c == ')' || c == ']' || c == '"' || c == '/'
        !           536:          || c == '(' || c == '[')
        !           537:        {
        !           538:          ungetc (c, infile);
        !           539:          break;
        !           540:        }
        !           541:       *p++ = c;
        !           542:       c = getc (infile);
        !           543:     }
        !           544:   if (p == str)
        !           545:     {
        !           546:       fprintf (stderr, "missing name or number");
        !           547:       dump_and_abort (-1, -1, infile);
        !           548:     }
        !           549: 
        !           550:   *p = 0;
        !           551: }
        !           552: 
        !           553: /* Read an rtx in printed representation from INFILE
        !           554:    and return an actual rtx in core constructed accordingly.
        !           555:    read_rtx is not used in the compiler proper, but rather in
        !           556:    the utilities gen*.c that construct C code from machine descriptions.  */
        !           557: 
        !           558: rtx
        !           559: read_rtx (infile)
        !           560:      FILE *infile;
        !           561: {
        !           562:   register int i, j, list_counter;
        !           563:   RTX_CODE tmp_code;
        !           564:   register char *format_ptr;
        !           565:   /* tmp_char is a buffer used for reading decimal integers
        !           566:      and names of rtx types and machine modes.
        !           567:      Therefore, 256 must be enough.  */
        !           568:   char tmp_char[256];
        !           569:   rtx return_rtx;
        !           570:   register int c;
        !           571:   int tmp_int;
        !           572: 
        !           573:   /* Linked list structure for making RTXs: */
        !           574:   struct rtx_list
        !           575:     {
        !           576:       struct rtx_list *next;
        !           577:       rtx value;               /* Value of this node...                */
        !           578:     };
        !           579: 
        !           580:   c = read_skip_spaces (infile); /* Should be open paren.  */
        !           581:   if (c != '(')
        !           582:     dump_and_abort ('(', c, infile);
        !           583: 
        !           584:   read_name (tmp_char, infile);
        !           585: 
        !           586:   tmp_code = UNKNOWN;
        !           587: 
        !           588:   for (i=0; i < NUM_RTX_CODE; i++) /* @@ might speed this search up */
        !           589:     {
        !           590:       if (!(strcmp (tmp_char, GET_RTX_NAME (i))))
        !           591:        {
        !           592:          tmp_code = (RTX_CODE) i;      /* get value for name */
        !           593:          break;
        !           594:        }
        !           595:     }
        !           596:   if (tmp_code == UNKNOWN)
        !           597:     {
        !           598:       fprintf (stderr,
        !           599:               "Unknown rtx read in rtl.read_rtx(). Code name was %s .",
        !           600:               tmp_char);
        !           601:     }
        !           602:   /* (NIL) stands for an expression that isn't there.  */
        !           603:   if (tmp_code == NIL)
        !           604:     {
        !           605:       /* Discard the closeparen.  */
        !           606:       while ((c = getc (infile)) && c != ')');
        !           607:       return 0;
        !           608:     }
        !           609: 
        !           610:   return_rtx = rtx_alloc (tmp_code); /* if we end up with an insn expression
        !           611:                                       then we free this space below.  */
        !           612:   format_ptr = GET_RTX_FORMAT (GET_CODE (return_rtx));
        !           613: 
        !           614:   /* If what follows is `: mode ', read it and
        !           615:      store the mode in the rtx.  */
        !           616: 
        !           617:   i = read_skip_spaces (infile);
        !           618:   if (i == ':')
        !           619:     {
        !           620:       register int k;
        !           621:       read_name (tmp_char, infile);
        !           622:       for (k = 0; k < NUM_MACHINE_MODES; k++)
        !           623:        if (!strcmp (GET_MODE_NAME (k), tmp_char))
        !           624:          break;
        !           625: 
        !           626:       PUT_MODE (return_rtx, (enum machine_mode) k );
        !           627:     }
        !           628:   else
        !           629:     ungetc (i, infile);
        !           630: 
        !           631:   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (return_rtx)); i++)
        !           632:     switch (*format_ptr++)
        !           633:       {
        !           634:        /* 0 means a field for internal use only.
        !           635:           Don't expect it to be present in the input.  */
        !           636:       case '0':
        !           637:        break;
        !           638: 
        !           639:       case 'e':
        !           640:       case 'u':
        !           641:        XEXP (return_rtx, i) = read_rtx (infile);
        !           642:        break;
        !           643: 
        !           644:       case 'V':
        !           645:        /* 'V' is an optional vector: if a closeparen follows,
        !           646:           just store NULL for this element.  */
        !           647:        c = read_skip_spaces (infile);
        !           648:        ungetc (c, infile);
        !           649:        if (c == ')')
        !           650:          {
        !           651:            XVEC (return_rtx, i) = 0;
        !           652:            break;
        !           653:          }
        !           654:        /* Now process the vector.  */
        !           655:   
        !           656:       case 'E':
        !           657:        {
        !           658:          register struct rtx_list *next_rtx, *rtx_list_link;
        !           659:          struct rtx_list *list_rtx;
        !           660: 
        !           661:          c = read_skip_spaces (infile);
        !           662:          if (c != '[')
        !           663:            dump_and_abort ('[', c, infile);
        !           664: 
        !           665:          /* add expressions to a list, while keeping a count */
        !           666:          next_rtx = NULL;
        !           667:          list_counter = 0;
        !           668:          while ((c = read_skip_spaces (infile)) && c != ']')
        !           669:            {
        !           670:              ungetc (c, infile);
        !           671:              list_counter++;
        !           672:              rtx_list_link = (struct rtx_list *)
        !           673:                alloca (sizeof (struct rtx_list));
        !           674:              rtx_list_link->value = read_rtx (infile);
        !           675:              if (next_rtx == 0)
        !           676:                list_rtx = rtx_list_link;
        !           677:              else
        !           678:                next_rtx->next = rtx_list_link;
        !           679:              next_rtx = rtx_list_link;
        !           680:              rtx_list_link->next = 0;
        !           681:            }
        !           682:          /* get vector length and allocate it */
        !           683:          XVEC (return_rtx, i) = (list_counter
        !           684:                                  ? rtvec_alloc (list_counter)
        !           685:                                  : (struct rtvec_def *) NULL);
        !           686:          if (list_counter > 0)
        !           687:            {
        !           688:              next_rtx = list_rtx;
        !           689:              for (j = 0; j < list_counter; j++,
        !           690:                   next_rtx = next_rtx->next)
        !           691:                XVECEXP (return_rtx, i, j) = next_rtx->value;
        !           692:            }
        !           693:          /* close bracket gotten */
        !           694:        }
        !           695:        break;
        !           696: 
        !           697:       case 'S':
        !           698:        /* 'S' is an optional string: if a closeparen follows,
        !           699:           just store NULL for this element.  */
        !           700:        c = read_skip_spaces (infile);
        !           701:        ungetc (c, infile);
        !           702:        if (c == ')')
        !           703:          {
        !           704:            XSTR (return_rtx, i) = 0;
        !           705:            break;
        !           706:          }
        !           707: 
        !           708:       case 's':
        !           709:        {
        !           710:          int saw_paren = 0;
        !           711:          register char *stringbuf;
        !           712:          int stringbufsize;
        !           713: 
        !           714:          c = read_skip_spaces (infile);
        !           715:          if (c == '(')
        !           716:            {
        !           717:              saw_paren = 1;
        !           718:              c = read_skip_spaces (infile);
        !           719:            }
        !           720:          if (c != '"')
        !           721:            dump_and_abort ('"', c, infile);
        !           722:          j = 0;
        !           723:          stringbufsize = 10;
        !           724:          stringbuf = (char *) xmalloc (stringbufsize + 1);
        !           725: 
        !           726:          while (1)
        !           727:            {
        !           728:              if (j >= stringbufsize - 4)
        !           729:                {
        !           730:                  stringbufsize *= 2;
        !           731:                  stringbuf = (char *) xrealloc (stringbuf, stringbufsize + 1);
        !           732:                }
        !           733:              stringbuf[j] = getc (infile); /* Read the string  */
        !           734:              if (stringbuf[j] == '\\')
        !           735:                {
        !           736:                  stringbuf[j] = getc (infile); /* Read the string  */
        !           737:                  /* \; makes stuff for a C string constant containing
        !           738:                     newline and tab.  */
        !           739:                  if (stringbuf[j] == ';')
        !           740:                    {
        !           741:                      strcpy (&stringbuf[j], "\\n\\t");
        !           742:                      j += 3;
        !           743:                    }
        !           744:                }
        !           745:              else if (stringbuf[j] == '"')
        !           746:                break;
        !           747:              j++;
        !           748:            }
        !           749: 
        !           750:          stringbuf[j] = 0;     /* NUL terminate the string  */
        !           751:          stringbuf = (char *) xrealloc (stringbuf, j + 1);
        !           752: 
        !           753:          if (saw_paren)
        !           754:            {
        !           755:              c = read_skip_spaces (infile);
        !           756:              if (c != ')')
        !           757:                dump_and_abort (')', c, infile);
        !           758:            }
        !           759:          XSTR (return_rtx, i) = stringbuf;
        !           760:        }
        !           761:        break;
        !           762: 
        !           763:       case 'i':
        !           764:       case 'n':
        !           765:        read_name (tmp_char, infile);
        !           766:        tmp_int = atoi (tmp_char);
        !           767:        XINT (return_rtx, i) = tmp_int;
        !           768:        break;
        !           769: 
        !           770:       default:
        !           771:        fprintf (stderr,
        !           772:                 "switch format wrong in rtl.read_rtx(). format was: %c.\n",
        !           773:                 format_ptr[-1]);
        !           774:        fprintf (stderr, "\tfile position: %ld\n", ftell (infile));
        !           775:        abort ();
        !           776:       }
        !           777: 
        !           778:   c = read_skip_spaces (infile);
        !           779:   if (c != ')')
        !           780:     dump_and_abort (')', c, infile);
        !           781: 
        !           782:   return return_rtx;
        !           783: }
        !           784: 
        !           785: /* This is called once per compilation, before any rtx's are constructed.
        !           786:    It initializes the vector `rtx_length', the extra CC modes, if any,
        !           787:    and computes certain commonly-used modes.  */
        !           788: 
        !           789: void
        !           790: init_rtl ()
        !           791: {
        !           792:   int min_class_size[(int) MAX_MODE_CLASS];
        !           793:   enum machine_mode mode;
        !           794:   int i;
        !           795: 
        !           796:   for (i = 0; i < NUM_RTX_CODE; i++)
        !           797:     rtx_length[i] = strlen (rtx_format[i]);
        !           798: 
        !           799:   /* Make CONST_DOUBLE bigger, if real values are bigger than
        !           800:      it normally expects to have room for.
        !           801:      Note that REAL_VALUE_TYPE is not defined by default,
        !           802:      since tree.h is not included.  But the default dfn as `double'
        !           803:      would do no harm.  */
        !           804: #ifdef REAL_VALUE_TYPE
        !           805:   i = sizeof (REAL_VALUE_TYPE) / sizeof (rtunion) + 2;
        !           806:   if (rtx_length[(int) CONST_DOUBLE] < i)
        !           807:     {
        !           808:       char *s = (char *) xmalloc (i + 1);
        !           809:       rtx_length[(int) CONST_DOUBLE] = i;
        !           810:       rtx_format[(int) CONST_DOUBLE] = s;
        !           811:       *s++ = 'e';
        !           812:       *s++ = '0';
        !           813:       /* Set the GET_RTX_FORMAT of CONST_DOUBLE to a string
        !           814:         of as many `i's as we now have elements.  */
        !           815:       for (i = 0; i < rtx_length[(int) CONST_DOUBLE]; i++)
        !           816:        *s++ = 'i';
        !           817:       *s++ = 0;
        !           818:     }
        !           819: #endif
        !           820: 
        !           821: #ifdef EXTRA_CC_MODES
        !           822:   for (i = (int) CCmode + 1; i < (int) MAX_MACHINE_MODE; i++)
        !           823:     {
        !           824:       mode_class[i] = MODE_CC;
        !           825:       mode_size[i] = mode_size[(int) CCmode];
        !           826:       mode_unit_size[i] = mode_unit_size[(int) CCmode];
        !           827:       mode_wider_mode[i - 1] = (enum machine_mode) i;
        !           828:       mode_wider_mode[i] = VOIDmode;
        !           829:     }
        !           830: #endif
        !           831: 
        !           832:   /* Find the narrowest mode for each class and compute the word and byte
        !           833:      modes.  */
        !           834: 
        !           835:   for (i = 0; i < (int) MAX_MODE_CLASS; i++)
        !           836:     min_class_size[i] = 1000;
        !           837: 
        !           838:   for (mode = VOIDmode; (int) mode < (int) MAX_MACHINE_MODE;
        !           839:        mode = (enum machine_mode) ((int) mode + 1))
        !           840:     {
        !           841:       if (GET_MODE_SIZE (mode) < min_class_size[(int) GET_MODE_CLASS (mode)])
        !           842:        {
        !           843:          class_narrowest_mode[(int) GET_MODE_CLASS (mode)] = mode;
        !           844:          min_class_size[(int) GET_MODE_CLASS (mode)] = GET_MODE_SIZE (mode);
        !           845:        }
        !           846:       if (GET_MODE_CLASS (mode) == MODE_INT
        !           847:          && GET_MODE_BITSIZE (mode) == BITS_PER_UNIT)
        !           848:        byte_mode = mode;
        !           849: 
        !           850:       if (GET_MODE_CLASS (mode) == MODE_INT
        !           851:          && GET_MODE_BITSIZE (mode) == BITS_PER_WORD)
        !           852:        word_mode = mode;
        !           853:     }
        !           854: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.