Return to tree.c CVS log

Up to [GCC 1.x] / gcc

Annotation of gcc/tree.c, revision 1.1.1.2

1.1       root        1: /* Language-indepednent node constructors for parse phase of GNU compiler.
1.1.1.2 ! root        2:    Copyright (C) 1987, 1988 Free Software Foundation, Inc.
1.1       root        3: 
                      4: This file is part of GNU CC.
                      5: 
                      6: GNU CC is distributed in the hope that it will be useful,
                      7: but WITHOUT ANY WARRANTY.  No author or distributor
                      8: accepts responsibility to anyone for the consequences of using it
                      9: or for whether it serves any particular purpose or works at all,
                     10: unless he says so in writing.  Refer to the GNU CC General Public
                     11: License for full details.
                     12: 
                     13: Everyone is granted permission to copy, modify and redistribute
                     14: GNU CC, but only under the conditions described in the
                     15: GNU CC General Public License.   A copy of this license is
                     16: supposed to have been given to you along with GNU CC so you
                     17: can know your rights and responsibilities.  It should be in a
                     18: file named COPYING.  Among other things, the copyright notice
                     19: and this notice must be preserved on all copies.  */
                     20: 
                     21: 
                     22: /* This file contains the low level primitives for operating on tree nodes,
                     23:    including allocation, list operations, interning of identifiers,
                     24:    construction of data type nodes and statement nodes,
                     25:    and construction of type conversion nodes.  It also contains
                     26:    tables index by tree code that describe how to take apart
                     27:    nodes of that code.
                     28: 
                     29:    It is intended to be language-independent, but occasionally
                     30:    calls language-dependent routines defined (for C) in typecheck.c.
                     31: 
                     32:    The low-level allocation routines oballoc and permalloc
                     33:    are used also for allocating many other kinds of objects
                     34:    by all passes of the compiler.  */
                     35: 
                     36: #include "config.h"
                     37: #include <stdio.h>
                     38: #include "tree.h"
                     39: #include "obstack.h"
1.1.1.2 ! root       40: #include "varargs.h"
1.1       root       41: 
                     42: #define obstack_chunk_alloc xmalloc
                     43: #define obstack_chunk_free free
                     44: 
                     45: extern int xmalloc ();
                     46: extern void free ();
                     47: 
                     48: /* Tree nodes of permanent duration are allocated in this obstack.
                     49:    They are the identifier nodes, and everything outside of
                     50:    the bodies and parameters of function definitions.  */
                     51: 
                     52: struct obstack permanent_obstack;
                     53: 
1.1.1.2 ! root       54: /* The initial RTL, and all ..._TYPE nodes, in a function
        !            55:    are allocated in this obstack.  Usually they are freed at the
        !            56:    end of the function, but if the function is inline they are saved.  */
        !            57: 
        !            58: struct obstack maybepermanent_obstack;
        !            59: 
1.1       root       60: /* The contents of the current function definition are allocated
                     61:    in this obstack, and all are freed at the end of the function.  */
                     62: 
                     63: struct obstack temporary_obstack;
                     64: 
1.1.1.2 ! root       65: /* The tree nodes of an expression are allocated
        !            66:    in this obstack, and all are freed at the end of the expression.  */
        !            67: 
        !            68: struct obstack momentary_obstack;
        !            69: 
        !            70: /* This points at either permanent_obstack or maybepermanent_obstack.  */
        !            71: 
        !            72: struct obstack *saveable_obstack;
        !            73: 
        !            74: /* This is same as saveable_obstack during parse and expansion phase;
        !            75:    it points to temporary_obstack during optimization.
        !            76:    This is the obstack to be used for creating rtl objects.  */
        !            77: 
        !            78: struct obstack *rtl_obstack;
        !            79: 
1.1       root       80: /* This points at either permanent_obstack or temporary_obstack.  */
                     81: 
                     82: struct obstack *current_obstack;
                     83: 
1.1.1.2 ! root       84: /* This points at either permanent_obstack or temporary_obstack
        !            85:    or momentary_obstack.  */
        !            86: 
        !            87: struct obstack *expression_obstack;
        !            88: 
        !            89: /* Addresses of first objects in some obstacks.
        !            90:    This is for freeing their entire contents.  */
        !            91: char *maybepermanent_firstobj;
        !            92: char *temporary_firstobj;
        !            93: char *momentary_firstobj;
        !            94: 
        !            95: /* Stack of places to restore the momentary obstack back to.  */
        !            96:    
        !            97: struct momentary_level
        !            98: {
        !            99:   /* Pointer back to previous such level.  */
        !           100:   struct momentary_level *prev;
        !           101:   /* First object allocated within this level.  */
        !           102:   char *base;
        !           103:   /* Value of expression_obstack saved at entry to this level.  */
        !           104:   struct obstack *obstack;
        !           105: };
        !           106: 
        !           107: struct momentary_level *momentary_stack;
        !           108: 
1.1       root      109: /* Table indexed by tree code giving a string containing a character
                    110:    classifying the tree code.  Possibilities are
                    111:    t, d, s, c, r and e.  See tree.def for details.  */
                    112: 
                    113: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
                    114: 
                    115: char *tree_code_type[] = {
                    116: #include "tree.def"
                    117: };
                    118: #undef DEFTREECODE
                    119: 
                    120: /* Table indexed by tree code giving number of expression
                    121:    operands beyond the fixed part of the node structure.
                    122:    Not used for types or decls.  */
                    123: 
                    124: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
                    125: 
                    126: int tree_code_length[] = {
                    127: #include "tree.def"
                    128: };
                    129: #undef DEFTREECODE
                    130: 
                    131: /* Counter for assigning unique ids to all tree nodes.  */
                    132: 
                    133: int tree_node_counter = 0;
                    134: 
                    135: /* Hash table for uniquizing IDENTIFIER_NODEs by name.  */
                    136: 
1.1.1.2 ! root      137: #define MAX_HASH_TABLE 1009
1.1       root      138: static tree hash_table[MAX_HASH_TABLE];        /* id hash buckets */
                    139: 
                    140: /* Init data for node creation, at the beginning of compilation.  */
                    141: 
                    142: void
                    143: init_tree ()
                    144: {
                    145:   obstack_init (&permanent_obstack);
1.1.1.2 ! root      146: 
        !           147:   obstack_init (&temporary_obstack);
        !           148:   temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
        !           149:   obstack_init (&momentary_obstack);
        !           150:   momentary_firstobj = (char *) obstack_alloc (&momentary_obstack, 0);
        !           151:   obstack_init (&maybepermanent_obstack);
        !           152:   maybepermanent_firstobj
        !           153:     = (char *) obstack_alloc (&maybepermanent_obstack, 0);
        !           154: 
1.1       root      155:   current_obstack = &permanent_obstack;
1.1.1.2 ! root      156:   expression_obstack = &permanent_obstack;
        !           157:   rtl_obstack = saveable_obstack = &permanent_obstack;
1.1       root      158:   tree_node_counter = 1;
                    159:   bzero (hash_table, sizeof hash_table);
                    160: }
                    161: 
                    162: /* Start allocating on the temporary (per function) obstack.
1.1.1.2 ! root      163:    This is done in start_function before parsing the function body,
        !           164:    and before each initialization at top level, and to go back
        !           165:    to temporary allocation after doing end_temporary_allocation.  */
1.1       root      166: 
1.1.1.2 ! root      167: void
1.1       root      168: temporary_allocation ()
                    169: {
                    170:   current_obstack = &temporary_obstack;
1.1.1.2 ! root      171:   expression_obstack = &temporary_obstack;
        !           172:   rtl_obstack = saveable_obstack = &maybepermanent_obstack;
        !           173:   momentary_stack = 0;
        !           174: }
        !           175: 
        !           176: /* Start allocating on the permanent obstack but don't
        !           177:    free the temporary data.  After calling this, call
        !           178:    `permanent_allocation' to fully resume permanent allocation status.  */
        !           179: 
        !           180: void
        !           181: end_temporary_allocation ()
        !           182: {
        !           183:   current_obstack = &permanent_obstack;
        !           184:   expression_obstack = &permanent_obstack;
        !           185:   rtl_obstack = saveable_obstack = &permanent_obstack;
1.1       root      186: }
                    187: 
                    188: /* Go back to allocating on the permanent obstack
                    189:    and free everything in the temporary obstack.
                    190:    This is done in finish_function after fully compiling a function.  */
                    191: 
1.1.1.2 ! root      192: void
1.1       root      193: permanent_allocation ()
                    194: {
                    195:   /* Free up previous temporary obstack data */
1.1.1.2 ! root      196:   obstack_free (&temporary_obstack, temporary_firstobj);
        !           197:   obstack_free (&momentary_obstack, momentary_firstobj);
        !           198:   obstack_free (&maybepermanent_obstack, maybepermanent_firstobj);
1.1       root      199: 
                    200:   current_obstack = &permanent_obstack;
1.1.1.2 ! root      201:   expression_obstack = &permanent_obstack;
        !           202:   rtl_obstack = saveable_obstack = &permanent_obstack;
1.1       root      203: }
                    204: 
1.1.1.2 ! root      205: /* Save permanently everything on the maybepermanent_obstack.  */
        !           206: 
        !           207: void
        !           208: preserve_data ()
        !           209: {
        !           210:   maybepermanent_firstobj
        !           211:     = (char *) obstack_alloc (&maybepermanent_obstack, 0);
        !           212: }
        !           213: 
1.1       root      214: /* Allocate SIZE bytes in the current obstack
                    215:    and return a pointer to them.
                    216:    In practice the current obstack is always the temporary one.  */
                    217: 
                    218: char *
                    219: oballoc (size)
                    220:      int size;
                    221: {
                    222:   return (char *) obstack_alloc (current_obstack, size);
                    223: }
                    224: 
                    225: /* Free the object PTR in the current obstack
                    226:    as well as everything allocated since PTR.
                    227:    In practice the current obstack is always the temporary one.  */
                    228: 
                    229: void
                    230: obfree (ptr)
                    231:      char *ptr;
                    232: {
                    233:   obstack_free (current_obstack, ptr);
                    234: }
                    235: 
                    236: /* Allocate SIZE bytes in the permanent obstack
                    237:    and return a pointer to them.  */
                    238: 
                    239: char *
                    240: permalloc (size)
                    241:      long size;
                    242: {
                    243:   return (char *) obstack_alloc (&permanent_obstack, size);
                    244: }
                    245: 
1.1.1.2 ! root      246: /* Start a level of momentary allocation.
        !           247:    In C, each compound statement has its own level
        !           248:    and that level is freed at the end of each statement.
        !           249:    All expression nodes are allocated in the momentary allocation level.  */
        !           250: 
        !           251: void
        !           252: push_momentary ()
        !           253: {
        !           254:   struct momentary_level *tem
        !           255:     = (struct momentary_level *) obstack_alloc (&momentary_obstack,
        !           256:                                                sizeof (struct momentary_level));
        !           257:   tem->prev = momentary_stack;
        !           258:   tem->base = (char *) obstack_base (&momentary_obstack);
        !           259:   tem->obstack = expression_obstack;
        !           260:   momentary_stack = tem;
        !           261:   expression_obstack = &momentary_obstack;
        !           262: }
        !           263: 
        !           264: /* Free all the storage in the current momentary-allocation level.
        !           265:    In C, this happens at the end of each statement.  */
        !           266: 
        !           267: void
        !           268: clear_momentary ()
        !           269: {
        !           270:   obstack_free (&momentary_obstack, momentary_stack->base);
        !           271: }
        !           272: 
        !           273: /* Discard a level of momentary allocation.
        !           274:    In C, this happens at the end of each compound statement.
        !           275:    Restore the status of expression node allocation
        !           276:    that was in effect before this level was created.  */
        !           277: 
        !           278: void
        !           279: pop_momentary ()
        !           280: {
        !           281:   struct momentary_level *tem = momentary_stack;
        !           282:   momentary_stack = tem->prev;
        !           283:   obstack_free (&momentary_obstack, tem);
        !           284:   expression_obstack = tem->obstack;
        !           285: }
        !           286: 
        !           287: /* Call when starting to parse a declaration:
        !           288:    make expressions in the declaration last the length of the function.
        !           289:    Returns an argument that should be passed to resume_momentary later.  */
        !           290: 
        !           291: int
        !           292: suspend_momentary ()
        !           293: {
        !           294:   register int tem = expression_obstack == &momentary_obstack;
        !           295:   expression_obstack = current_obstack;
        !           296:   return tem;
        !           297: }
        !           298: 
        !           299: /* Call when finished parsing a declaration:
        !           300:    restore the treatment of node-allocation that was
        !           301:    in effect before the suspension.
        !           302:    YES should be the value previously returned by suspend_momentary.  */
        !           303: 
        !           304: void
        !           305: resume_momentary (yes)
        !           306:      int yes;
        !           307: {
        !           308:   if (yes)
        !           309:     expression_obstack = &momentary_obstack;
        !           310: }
        !           311: 
1.1       root      312: /* Return a newly allocated node of code CODE.
                    313:    Initialize the node's unique id and its TREE_PERMANENT flag.
                    314:    For decl and type nodes, some other fields are initialized.
                    315:    The rest of the node is initialized to zero.
                    316: 
                    317:    Achoo!  I got a code in the node.  */
                    318: 
                    319: tree
                    320: make_node (code)
                    321:      enum tree_code code;
                    322: {
                    323:   register tree t;
                    324:   register int type = *tree_code_type[(int) code];
                    325:   register int length;
1.1.1.2 ! root      326:   register struct obstack *obstack = current_obstack;
1.1       root      327:   register int i;
                    328: 
                    329:   switch (type)
                    330:     {
                    331:     case 'd':  /* A decl node */
                    332:       length = sizeof (struct tree_decl);
1.1.1.2 ! root      333:       /* All decls in an inline function need to be saved.  */
        !           334:       if (obstack != &permanent_obstack)
        !           335:        obstack = saveable_obstack;
1.1       root      336:       break;
                    337: 
                    338:     case 't':  /* a type node */
                    339:       length = sizeof (struct tree_type);
1.1.1.2 ! root      340:       /* All data types are put where we can preserve them if nec.  */
        !           341:       if (obstack != &permanent_obstack)
        !           342:        obstack = saveable_obstack;
1.1       root      343:       break;
                    344: 
                    345:     case 's':  /* a stmt node */
1.1.1.2 ! root      346:       length = sizeof (struct tree_common)
1.1       root      347:        + 2 * sizeof (int)
                    348:          + tree_code_length[(int) code] * sizeof (char *);
1.1.1.2 ! root      349:       /* All stmts are put where we can preserve them if nec.  */
        !           350:       if (obstack != &permanent_obstack)
        !           351:        obstack = saveable_obstack;
1.1       root      352:       break;
                    353: 
1.1.1.2 ! root      354:     case 'r':  /* a reference */
        !           355:     case 'e':  /* an expression */
        !           356:       obstack = expression_obstack;
        !           357:       length = sizeof (struct tree_exp)
        !           358:        + (tree_code_length[(int) code] - 1) * sizeof (char *);
        !           359:       break;
        !           360: 
        !           361:     case 'c':  /* a constant */
        !           362:       obstack = expression_obstack;
        !           363:       /* We can't use tree_code_length for this, since the number of words
        !           364:         is machine-dependent due to varying alignment of `double'.  */
        !           365:       if (code == REAL_CST)
        !           366:        {
        !           367:          length = sizeof (struct tree_real_cst);
        !           368:          break;
        !           369:        }
        !           370: 
        !           371:     case 'x':  /* something random, like an identifier.  */
        !           372:       length = sizeof (struct tree_common)
1.1       root      373:        + tree_code_length[(int) code] * sizeof (char *);
1.1.1.2 ! root      374:       /* Identifier nodes are always permanent since they are
        !           375:         unique in a compiler run.  */
        !           376:       if (code == IDENTIFIER_NODE) obstack = &permanent_obstack;
1.1       root      377:     }
                    378: 
                    379:   t = (tree) obstack_alloc (obstack, length);
                    380: 
                    381:   TREE_UID (t) = tree_node_counter++;
                    382:   TREE_TYPE (t) = 0;
                    383:   TREE_CHAIN (t) = 0;
                    384:   for (i = (length / sizeof (int)) - 1;
1.1.1.2 ! root      385:        i >= sizeof (struct tree_common) / sizeof (int) - 1;
1.1       root      386:        i--)
                    387:     ((int *) t)[i] = 0;
                    388: 
                    389:   TREE_SET_CODE (t, code);
                    390:   if (obstack == &permanent_obstack)
                    391:     TREE_PERMANENT (t) = 1;
                    392: 
                    393:   if (type == 'd')
                    394:     {
                    395:       extern int lineno;
                    396: 
                    397:       DECL_ALIGN (t) = 1;
                    398:       DECL_SIZE_UNIT (t) = 1;
                    399:       DECL_VOFFSET_UNIT (t) = 1;
                    400:       DECL_SOURCE_LINE (t) = lineno;
                    401:       DECL_SOURCE_FILE (t) = input_filename;
                    402:     }
                    403: 
                    404:   if (type == 't')
                    405:     {
                    406:       TYPE_ALIGN (t) = 1;
                    407:       TYPE_SIZE_UNIT (t) = 1;
                    408:       TYPE_MAIN_VARIANT (t) = t;
                    409:     }
                    410: 
                    411:   if (type == 'c')
                    412:     {
                    413:       TREE_LITERAL (t) = 1;
                    414:     }
                    415: 
                    416:   return t;
                    417: }
                    418: 
                    419: /* Return a new node with the same contents as NODE
                    420:    except that its TREE_CHAIN is zero and it has a fresh uid.  */
                    421: 
                    422: tree
                    423: copy_node (node)
                    424:      tree node;
                    425: {
                    426:   register tree t;
                    427:   register enum tree_code code = TREE_CODE (node);
                    428:   register int length;
                    429:   register int i;
                    430: 
                    431:   switch (*tree_code_type[(int) code])
                    432:     {
                    433:     case 'd':  /* A decl node */
                    434:       length = sizeof (struct tree_decl);
                    435:       break;
                    436: 
                    437:     case 't':  /* a type node */
                    438:       length = sizeof (struct tree_type);
                    439:       break;
                    440: 
                    441:     case 's':
1.1.1.2 ! root      442:       length = sizeof (struct tree_common)
1.1       root      443:        + 2 * sizeof (int)
                    444:          + tree_code_length[(int) code] * sizeof (char *);
                    445:       break;
                    446: 
1.1.1.2 ! root      447:     case 'r':  /* a reference */
        !           448:     case 'e':  /* a expression */
        !           449:       length = sizeof (struct tree_exp)
        !           450:        + (tree_code_length[(int) code] - 1) * sizeof (char *);
        !           451:       break;
        !           452: 
        !           453:     case 'c':  /* a constant */
        !           454:       /* We can't use tree_code_length for this, since the number of words
        !           455:         is machine-dependent due to varying alignment of `double'.  */
        !           456:       if (code == REAL_CST)
        !           457:        {
        !           458:          length = sizeof (struct tree_real_cst);
        !           459:          break;
        !           460:        }
        !           461: 
        !           462:     case 'x':  /* something random, like an identifier.  */
        !           463:       length = sizeof (struct tree_common)
1.1       root      464:        + tree_code_length[(int) code] * sizeof (char *);
                    465:     }
                    466: 
                    467:   t = (tree) obstack_alloc (current_obstack, length);
                    468: 
                    469:   for (i = (length / sizeof (int)) - 1;
                    470:        i >= 0;
                    471:        i--)
                    472:     ((int *) t)[i] = ((int *) node)[i];
                    473: 
                    474:   TREE_UID (t) = tree_node_counter++;
                    475:   TREE_CHAIN (t) = 0;
                    476: 
                    477:   TREE_PERMANENT (t) = (current_obstack == &permanent_obstack);
                    478: 
                    479:   return t;
                    480: }
                    481: 
                    482: #define HASHBITS 30
                    483: 
                    484: /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
                    485:    If an identifier with that name has previously been referred to,
                    486:    the same node is returned this time.  */
                    487: 
                    488: tree
                    489: get_identifier (text)
                    490:      register char *text;
                    491: {
                    492:   register int hi;
                    493:   register int i;
                    494:   register tree idp;
                    495:   register int len;
                    496: 
                    497:   /* Compute length of text in len.  */
                    498:   for (len = 0; text[len]; len++);
                    499: 
                    500:   /* Compute hash code */
                    501:   hi = len;
                    502:   for (i = 0; i < len; i++)
                    503:     hi = ((hi * 613) + (unsigned)(text[i]));
                    504: 
                    505:   hi &= (1 << HASHBITS) - 1;
                    506:   hi %= MAX_HASH_TABLE;
                    507:   
                    508:   /* Search table for identifier */
                    509:   for (idp = hash_table[hi]; idp!=NULL; idp = TREE_CHAIN (idp))
                    510:     if (IDENTIFIER_LENGTH (idp) == len &&
                    511:        !strcmp (IDENTIFIER_POINTER (idp), text))
                    512:       return idp;              /* <-- return if found */
                    513: 
                    514:   /* Not found, create one, add to chain */
                    515:   idp = make_node (IDENTIFIER_NODE);
                    516:   IDENTIFIER_LENGTH (idp) = len;
                    517: 
                    518:   IDENTIFIER_POINTER (idp) = obstack_copy0 (&permanent_obstack, text, len);
                    519: 
                    520:   TREE_CHAIN (idp) = hash_table[hi];
                    521:   hash_table[hi] = idp;
                    522:   return idp;                  /* <-- return if created */
                    523: }
                    524: 
                    525: /* Return a newly constructed INTEGER_CST node whose constant value
                    526:    is specified by the two ints LOW and HI.
1.1.1.2 ! root      527:    The TREE_TYPE is set to `int'.  */
1.1       root      528: 
                    529: tree
                    530: build_int_2 (low, hi)
                    531:      int low, hi;
                    532: {
                    533:   register tree t = make_node (INTEGER_CST);
                    534:   TREE_INT_CST_LOW (t) = low;
                    535:   TREE_INT_CST_HIGH (t) = hi;
                    536:   TREE_TYPE (t) = integer_type_node;
                    537:   return t;
                    538: }
                    539: 
                    540: /* Return a newly constructed REAL_CST node whose value is D.
                    541:    The TREE_TYPE is not initialized.  */
                    542: 
                    543: tree
                    544: build_real (d)
                    545:      double d;
                    546: {
                    547:   tree v;
                    548: 
                    549:   v = make_node (REAL_CST);
                    550:   TREE_REAL_CST (v) = d;
                    551:   return v;
                    552: }
                    553: 
                    554: /* Return a newly constructed REAL_CST node whose value
                    555:    is the integer value of the INTEGER_CST node I.
                    556:    The TREE_TYPE is not initialized.  */
                    557: 
                    558: tree
                    559: build_real_from_int_cst (i)
                    560:      tree i;
                    561: {
                    562:   tree v;
1.1.1.2 ! root      563:   double d;
1.1       root      564: 
                    565:   v = make_node (REAL_CST);
1.1.1.2 ! root      566: 
        !           567:   if (TREE_INT_CST_HIGH (i) < 0)
        !           568:     {
        !           569:       d = (double) (~ TREE_INT_CST_HIGH (i));
        !           570:       d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
        !           571:            * (double) (1 << (HOST_BITS_PER_INT / 2)));
        !           572:       d += (double) (unsigned) (~ TREE_INT_CST_LOW (i));
        !           573:       d = (- d - 1.0);
        !           574:     }
        !           575:   else
        !           576:     {
        !           577:       d = (double) TREE_INT_CST_HIGH (i);
        !           578:       d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
        !           579:            * (double) (1 << (HOST_BITS_PER_INT / 2)));
        !           580:       d += (double) (unsigned) TREE_INT_CST_LOW (i);
        !           581:     }
        !           582: 
        !           583:   TREE_REAL_CST (v) = d;
1.1       root      584:   return v;
                    585: }
                    586: 
                    587: /* Return a newly constructed STRING_CST node whose value is
                    588:    the LEN characters at STR.
                    589:    The TREE_TYPE is not initialized.  */
                    590: 
                    591: tree
                    592: build_string (len, str)
                    593:      int len;
                    594:      char *str;
                    595: {
                    596:   register tree s = make_node (STRING_CST);
                    597:   TREE_STRING_LENGTH (s) = len;
1.1.1.2 ! root      598:   TREE_STRING_POINTER (s) = obstack_copy0 (saveable_obstack, str, len);
1.1       root      599:   return s;
                    600: }
                    601: 
                    602: /* Return a newly constructed COMPLEX_CST node whose value is
                    603:    specified by the real and imaginary parts REAL and IMAG.
                    604:    Both REAL and IMAG should be constant nodes.
                    605:    The TREE_TYPE is not initialized.  */
                    606: 
                    607: tree
                    608: build_complex (real, imag)
                    609:      tree real, imag;
                    610: {
                    611:   register tree t = make_node (COMPLEX_CST);
                    612:   TREE_REALPART (t) = real;
                    613:   TREE_IMAGPART (t) = imag;
                    614:   return t;
                    615: }
                    616: 
                    617: /* Return 1 if EXPR is the integer constant zero.  */
                    618: 
                    619: int
                    620: integer_zerop (expr)
                    621:      tree expr;
                    622: {
1.1.1.2 ! root      623:   return (TREE_CODE (expr) == INTEGER_CST
        !           624:          && TREE_INT_CST_LOW (expr) == 0
        !           625:          && TREE_INT_CST_HIGH (expr) == 0);
1.1       root      626: }
                    627: 
                    628: /* Return 1 if EXPR is the integer constant one.  */
                    629: 
                    630: int
                    631: integer_onep (expr)
                    632:      tree expr;
                    633: {
1.1.1.2 ! root      634:   return (TREE_CODE (expr) == INTEGER_CST
        !           635:          && TREE_INT_CST_LOW (expr) == 1
        !           636:          && TREE_INT_CST_HIGH (expr) == 0);
1.1       root      637: }
                    638: 
                    639: /* Return 1 if EXPR is an integer containing all 1's
                    640:    in as much precision as it contains.  */
                    641: 
                    642: int
                    643: integer_all_onesp (expr)
                    644:      tree expr;
                    645: {
                    646:   register int prec;
                    647:   register int uns;
                    648: 
                    649:   if (TREE_CODE (expr) != INTEGER_CST)
                    650:     return 0;
                    651: 
1.1.1.2 ! root      652:   uns = TREE_UNSIGNED (TREE_TYPE (expr));
1.1       root      653:   if (!uns)
                    654:     return TREE_INT_CST_LOW (expr) == -1 && TREE_INT_CST_HIGH (expr) == -1;
                    655: 
                    656:   prec = TYPE_PRECISION (TREE_TYPE (expr));
                    657:   if (prec >= HOST_BITS_PER_INT)
                    658:     return TREE_INT_CST_LOW (expr) == -1
                    659:       && TREE_INT_CST_HIGH (expr) == (1 << (prec - HOST_BITS_PER_INT)) - 1;
                    660:   else
                    661:     return TREE_INT_CST_LOW (expr) == (1 << prec) - 1;
                    662: }
                    663: 
                    664: /* Return the length of a chain of nodes chained through TREE_CHAIN.
                    665:    We expect a null pointer to mark the end of the chain.
                    666:    This is the Lisp primitive `length'.  */
                    667: 
                    668: int
                    669: list_length (t)
                    670:      tree t;
                    671: {
                    672:   register tree tail;
                    673:   register int len = 0;
                    674: 
                    675:   for (tail = t; tail; tail = TREE_CHAIN (tail))
                    676:     len++;
                    677: 
                    678:   return len;
                    679: }
                    680: 
                    681: /* Concatenate two chains of nodes (chained through TREE_CHAIN)
                    682:    by modifying the last node in chain 1 to point to chain 2.
                    683:    This is the Lisp primitive `nconc'.  */
                    684: 
                    685: tree
                    686: chainon (op1, op2)
                    687:      tree op1, op2;
                    688: {
                    689:   tree t;
                    690: 
                    691:   if (op1)
                    692:     {
                    693:       for (t = op1; TREE_CHAIN (t); t = TREE_CHAIN (t))
                    694:        if (t == op2) abort (); /* Circularity being created */
                    695:       TREE_CHAIN (t) = op2;
                    696:       return op1;
                    697:     }
                    698:   else return op2;
                    699: }
                    700: 
                    701: /* Return a newly created TREE_LIST node whose
                    702:    purpose and value fields are PARM and VALUE.  */
                    703: 
                    704: tree
                    705: build_tree_list (parm, value)
                    706:      tree parm, value;
                    707: {
                    708:   register tree t = make_node (TREE_LIST);
                    709:   TREE_PURPOSE (t) = parm;
                    710:   TREE_VALUE (t) = value;
                    711:   return t;
                    712: }
                    713: 
                    714: /* Return a newly created TREE_LIST node whose
                    715:    purpose and value fields are PARM and VALUE
                    716:    and whose TREE_CHAIN is CHAIN.  */
                    717: 
                    718: tree
                    719: tree_cons (purpose, value, chain)
                    720:      tree purpose, value, chain;
                    721: {
                    722:   register tree node = make_node (TREE_LIST);
                    723:   TREE_CHAIN (node) = chain;
                    724:   TREE_PURPOSE (node) = purpose;
                    725:   TREE_VALUE (node) = value;
                    726:   return node;
                    727: }
                    728: 
1.1.1.2 ! root      729: /* Same as `tree_cons' but make a permanent object.  */
        !           730: 
        !           731: tree
        !           732: perm_tree_cons (purpose, value, chain)
        !           733:      tree purpose, value, chain;
        !           734: {
        !           735:   register tree node;
        !           736:   register struct obstack *ambient_obstack = current_obstack;
        !           737:   current_obstack = &permanent_obstack;
        !           738: 
        !           739:   node = make_node (TREE_LIST);
        !           740:   TREE_CHAIN (node) = chain;
        !           741:   TREE_PURPOSE (node) = purpose;
        !           742:   TREE_VALUE (node) = value;
        !           743: 
        !           744:   current_obstack = ambient_obstack;
        !           745:   return node;
        !           746: }
        !           747: 
1.1       root      748: /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
                    749: 
                    750: tree
                    751: tree_last (chain)
                    752:      register tree chain;
                    753: {
                    754:   register tree next;
                    755:   if (chain)
                    756:     while (next = TREE_CHAIN (chain))
                    757:       chain = next;
                    758:   return chain;
                    759: }
                    760: 
                    761: /* Reverse the order of elements in the chain T,
                    762:    and return the new head of the chain (old last element).  */
                    763: 
                    764: tree
                    765: nreverse (t)
                    766:      tree t;
                    767: {
                    768:   register tree prev = 0, decl, next;
                    769:   for (decl = t; decl; decl = next)
                    770:     {
                    771:       next = TREE_CHAIN (decl);
                    772:       TREE_CHAIN (decl) = prev;
                    773:       prev = decl;
                    774:     }
                    775:   return prev;
                    776: }
                    777: 
                    778: /* Return the size nominally occupied by an object of type TYPE
                    779:    when it resides in memory.  The value is measured in units of bytes,
                    780:    and its data type is that normally used for type sizes
                    781:    (which is the first type created by make_signed_type or
                    782:    make_unsigned_type).  */
                    783: 
                    784: tree
                    785: size_in_bytes (type)
                    786:      tree type;
                    787: {
                    788:   if (type == error_mark_node)
                    789:     return integer_zero_node;
1.1.1.2 ! root      790:   if (TYPE_SIZE (type) == 0)
        !           791:     {
        !           792:       incomplete_type_error (0, type);
        !           793:       return integer_zero_node;
        !           794:     }
1.1       root      795:   return convert_units (TYPE_SIZE (type), TYPE_SIZE_UNIT (type),
                    796:                        BITS_PER_UNIT);
                    797: }
                    798: 
1.1.1.2 ! root      799: /* Return the size of TYPE (in bytes) as an integer,
        !           800:    or return -1 if the size can vary.  */
        !           801: 
        !           802: int
        !           803: int_size_in_bytes (type)
        !           804:      tree type;
        !           805: {
        !           806:   int size;
        !           807:   if (type == error_mark_node)
        !           808:     return 0;
        !           809:   if (TYPE_SIZE (type) == 0)
        !           810:     return -1;
        !           811:   if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
        !           812:     return -1;
        !           813:   size = TREE_INT_CST_LOW (TYPE_SIZE (type)) * TYPE_SIZE_UNIT (type);
        !           814:   return (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
        !           815: }
        !           816: 
1.1       root      817: /* Return nonzero if arg is static -- a reference to an object in
                    818:    static storage.  This is not the same as the C meaning of `static'.  */
                    819: 
                    820: int
                    821: staticp (arg)
                    822:      tree arg;
                    823: {
                    824:   register enum tree_code code = TREE_CODE (arg);
                    825: 
1.1.1.2 ! root      826:   if ((code == VAR_DECL || code == FUNCTION_DECL || code == CONSTRUCTOR)
1.1       root      827:       && (TREE_STATIC (arg) || TREE_EXTERNAL (arg)))
                    828:     return 1;
                    829: 
1.1.1.2 ! root      830:   if (code == STRING_CST)
        !           831:     return 1;
        !           832: 
1.1       root      833:   if (code == COMPONENT_REF)
                    834:     return staticp (TREE_OPERAND (arg, 0));
                    835: 
1.1.1.2 ! root      836:   if (code == ARRAY_REF)
        !           837:     {
        !           838:       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
        !           839:          && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
        !           840:        return staticp (TREE_OPERAND (arg, 0));
        !           841:     }
        !           842: 
1.1       root      843:   return 0;
                    844: }
                    845: 
1.1.1.2 ! root      846: /* Return nonzero if REF is an lvalue valid for this language.
        !           847:    Lvalues can be assigned, unless they have TREE_READONLY.
        !           848:    Lvalues can have their address taken, unless they have TREE_REGDECL.  */
1.1       root      849: 
                    850: int
1.1.1.2 ! root      851: lvalue_p (ref)
1.1       root      852:      tree ref;
                    853: {
                    854:   register enum tree_code code = TREE_CODE (ref);
                    855: 
1.1.1.2 ! root      856:   if (language_lvalue_valid (ref))
        !           857:     switch (code)
        !           858:       {
        !           859:       case COMPONENT_REF:
        !           860:        return lvalue_p (TREE_OPERAND (ref, 0));
        !           861: 
        !           862:       case STRING_CST:
        !           863:        return 1;
        !           864: 
        !           865:       case INDIRECT_REF:
        !           866:       case ARRAY_REF:
        !           867:       case VAR_DECL:
        !           868:       case PARM_DECL:
        !           869:       case RESULT_DECL:
        !           870:       case ERROR_MARK:
        !           871:        if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE)
        !           872:          return 1;
        !           873:       }
1.1       root      874:   return 0;
                    875: }
1.1.1.2 ! root      876: 
        !           877: /* Return nonzero if REF is an lvalue valid for this language;
        !           878:    otherwise, print an error message and return zero.  */
        !           879: 
        !           880: int
        !           881: lvalue_or_else (ref, string)
        !           882:      tree ref;
        !           883:      char *string;
        !           884: {
        !           885:   int win = lvalue_p (ref);
        !           886:   if (! win)
        !           887:     error ("invalid lvalue in %s", string);
        !           888:   return win;
        !           889: }
1.1       root      890: 
                    891: /* This should be applied to any node which may be used in more than one place,
                    892:    but must be evaluated only once.  Normally, the code generator would
                    893:    reevaluate the node each time; this forces it to compute it once and save
                    894:    the result.  This is done by encapsulating the node in a SAVE_EXPR.  */
                    895: 
                    896: tree
                    897: save_expr (expr)
                    898:      tree expr;
                    899: {
                    900:   register tree t = fold (expr);
                    901: 
1.1.1.2 ! root      902:   /* If the tree evaluates to a constant, then we don't want to hide that
1.1       root      903:      fact (i.e. this allows further folding, and direct checks for constants).
                    904:      Since it is no problem to reevaluate literals, we just return the 
                    905:      literal node. */
                    906: 
                    907:   if (TREE_LITERAL (t) || TREE_READONLY (t) || TREE_CODE (t) == SAVE_EXPR)
                    908:     return t;
                    909: 
1.1.1.2 ! root      910:   return build (SAVE_EXPR, TREE_TYPE (expr), t, NULL);
1.1       root      911: }
                    912: 
                    913: /* Stabilize a reference so that we can use it any number of times
                    914:    without causing its operands to be evaluated more than once.
1.1.1.2 ! root      915:    Returns the stabilized reference.
        !           916: 
        !           917:    Also allows conversion expressions whose operands are references.
        !           918:    Any other kind of expression is returned unchanged.  */
1.1       root      919: 
                    920: tree
                    921: stabilize_reference (ref)
                    922:      tree ref;
                    923: {
                    924:   register tree result;
                    925:   register enum tree_code code = TREE_CODE (ref);
                    926: 
1.1.1.2 ! root      927:   switch (code)
1.1       root      928:     {
1.1.1.2 ! root      929:     case VAR_DECL:
        !           930:     case PARM_DECL:
        !           931:     case RESULT_DECL:
1.1       root      932:       result = ref;
1.1.1.2 ! root      933:       break;
        !           934: 
        !           935:     case NOP_EXPR:
        !           936:     case CONVERT_EXPR:
        !           937:     case FLOAT_EXPR:
        !           938:     case FIX_TRUNC_EXPR:
        !           939:     case FIX_FLOOR_EXPR:
        !           940:     case FIX_ROUND_EXPR:
        !           941:     case FIX_CEIL_EXPR:
        !           942:       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
        !           943:       break;
        !           944: 
        !           945:     case INDIRECT_REF:
        !           946:       result = build_nt (INDIRECT_REF, save_expr (TREE_OPERAND (ref, 0)));
        !           947:       break;
        !           948: 
        !           949:     case COMPONENT_REF:
        !           950:       result = build_nt (COMPONENT_REF,
        !           951:                         stabilize_reference (TREE_OPERAND (ref, 0)),
        !           952:                         TREE_OPERAND (ref, 1));
        !           953:       break;
        !           954: 
        !           955:     case ARRAY_REF:
        !           956:       result = build_nt (ARRAY_REF, stabilize_reference (TREE_OPERAND (ref, 0)),
        !           957:                         save_expr (TREE_OPERAND (ref, 1)));
        !           958:       break;
        !           959: 
        !           960:       /* If arg isn't a kind of lvalue we recognize, make no change.
        !           961:         Caller should recognize the error for an invalid lvalue.  */
        !           962:     default:
        !           963:       return ref;
        !           964: 
        !           965:     case ERROR_MARK:
1.1       root      966:       return error_mark_node;
                    967:     }
                    968: 
                    969:   TREE_TYPE (result) = TREE_TYPE (ref);
1.1.1.2 ! root      970:   TREE_READONLY (result) = TREE_READONLY (ref);
1.1       root      971:   TREE_VOLATILE (result) = TREE_VOLATILE (ref);
1.1.1.2 ! root      972:   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
1.1       root      973: 
                    974:   return result;
                    975: }
                    976: 
                    977: /* Low-level constructors for expressions.  */
                    978: 
1.1.1.2 ! root      979: /* Build an expression of code CODE, data type TYPE,
        !           980:    and operands as specified by the arguments ARG1 and following arguments.
        !           981:    Expressions and reference nodes can be created this way.
        !           982:    Constants, decls, types and misc nodes cannot be.  */
1.1       root      983: 
                    984: tree
1.1.1.2 ! root      985: build (va_alist)
        !           986:      va_dcl
1.1       root      987: {
1.1.1.2 ! root      988:   register va_list p;
        !           989:   enum tree_code code;
        !           990:   register tree t;
        !           991:   register int length;
        !           992:   register int i;
        !           993: 
        !           994:   va_start (p);
1.1       root      995: 
1.1.1.2 ! root      996:   code = va_arg (p, enum tree_code);
        !           997:   t = make_node (code);
        !           998:   length = tree_code_length[(int) code];
        !           999:   TREE_TYPE (t) = va_arg (p, tree);
        !          1000: 
        !          1001:   if (length == 2)
        !          1002:     {
        !          1003:       /* This is equivalent to the loop below, but faster.  */
        !          1004:       register tree arg0 = va_arg (p, tree);
        !          1005:       register tree arg1 = va_arg (p, tree);
        !          1006:       TREE_OPERAND (t, 0) = arg0;
        !          1007:       TREE_OPERAND (t, 1) = arg1;
        !          1008:       TREE_VOLATILE (t)
        !          1009:        = (arg0 && TREE_VOLATILE (arg0)) || (arg1 && TREE_VOLATILE (arg1));
        !          1010:     }
        !          1011:   else
        !          1012:     {
        !          1013:       for (i = 0; i < length; i++)
        !          1014:        {
        !          1015:          register tree operand = va_arg (p, tree);
        !          1016:          TREE_OPERAND (t, i) = operand;
        !          1017:          if (operand && TREE_VOLATILE (operand))
        !          1018:            TREE_VOLATILE (t) = 1;
        !          1019:        }
        !          1020:     }
        !          1021:   va_end (p);
1.1       root     1022:   return t;
                   1023: }
                   1024: 
1.1.1.2 ! root     1025: /* Similar except don't specify the TREE_TYPE
        !          1026:    and leave the TREE_VOLATILE as 0.
        !          1027:    It is permissible for arguments to be null,
        !          1028:    or even garbage if their values do not matter.  */
1.1       root     1029: 
                   1030: tree
1.1.1.2 ! root     1031: build_nt (va_alist)
        !          1032:      va_dcl
1.1       root     1033: {
1.1.1.2 ! root     1034:   register va_list p;
        !          1035:   register enum tree_code code;
        !          1036:   register tree t;
        !          1037:   register int length;
        !          1038:   register int i;
        !          1039: 
        !          1040:   va_start (p);
1.1       root     1041: 
1.1.1.2 ! root     1042:   code = va_arg (p, enum tree_code);
        !          1043:   t = make_node (code);
        !          1044:   length = tree_code_length[(int) code];
        !          1045: 
        !          1046:   for (i = 0; i < length; i++)
        !          1047:     TREE_OPERAND (t, i) = va_arg (p, tree);
        !          1048: 
        !          1049:   va_end (p);
1.1       root     1050:   return t;
                   1051: }
1.1.1.2 ! root     1052: 
        !          1053: /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
        !          1054:    We do NOT enter this node in any sort of symbol table.
1.1       root     1055: 
1.1.1.2 ! root     1056:    layout_decl is used to set up the decl's storage layout.
        !          1057:    Other slots are initialized to 0 or null pointers.  */
1.1       root     1058: 
                   1059: tree
1.1.1.2 ! root     1060: build_decl (code, name, type)
        !          1061:      enum tree_code code;
        !          1062:      tree name, type;
        !          1063: {
        !          1064:   register tree t;
        !          1065: 
        !          1066:   t = make_node (code);
        !          1067: 
        !          1068: /*  if (type == error_mark_node)
        !          1069:     type = integer_type_node; */
        !          1070: /* That is not done, deliberately, so that having error_mark_node
        !          1071:    as the type can suppress useless errors in the use of this variable.  */
        !          1072: 
        !          1073:   DECL_NAME (t) = name;
        !          1074:   TREE_TYPE (t) = type;
        !          1075:   DECL_ARGUMENTS (t) = NULL_TREE;
        !          1076:   DECL_INITIAL (t) = NULL_TREE;
        !          1077: 
        !          1078:   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
        !          1079:     layout_decl (t, 0);
        !          1080:   else if (code == FUNCTION_DECL)
        !          1081:     DECL_MODE (t) = FUNCTION_MODE;
        !          1082: 
1.1       root     1083:   return t;
                   1084: }
                   1085: 
                   1086: /* Low-level constructors for statements.
                   1087:    These constructors all expect source file name and line number
                   1088:    as arguments, as well as enough arguments to fill in the data
                   1089:    in the statement node.  */
                   1090: 
                   1091: tree
                   1092: build_goto (filename, line, label)
                   1093:      char *filename;
                   1094:      int line;
                   1095:      tree label;
                   1096: {
                   1097:   register tree t = make_node (GOTO_STMT);
                   1098:   STMT_SOURCE_FILE (t) = filename;
                   1099:   STMT_SOURCE_LINE (t) = line;
                   1100:   STMT_BODY (t) = label;
                   1101:   return t;
                   1102: }
                   1103: 
                   1104: tree
                   1105: build_return (filename, line, arg)
                   1106:      char *filename;
                   1107:      int line;
                   1108:      tree arg;
                   1109: {
                   1110:   register tree t = make_node (RETURN_STMT);
                   1111: 
                   1112:   STMT_SOURCE_FILE (t) = filename;
                   1113:   STMT_SOURCE_LINE (t) = line;
                   1114:   STMT_BODY (t) = arg;
                   1115:   return t;
                   1116: }
                   1117: 
                   1118: tree
                   1119: build_expr_stmt (filename, line, expr)
                   1120:      char *filename;
                   1121:      int line;
                   1122:      tree expr;
                   1123: {
                   1124:   register tree t = make_node (EXPR_STMT);
                   1125: 
                   1126:   STMT_SOURCE_FILE (t) = filename;
                   1127:   STMT_SOURCE_LINE (t) = line;
                   1128:   STMT_BODY (t) = expr;
                   1129:   return t;
                   1130: }
                   1131: 
                   1132: tree
                   1133: build_if (filename, line, cond, thenclause, elseclause)
                   1134:      char *filename;
                   1135:      int line;
                   1136:      tree cond, thenclause, elseclause;
                   1137: {
                   1138:   register tree t = make_node (IF_STMT);
                   1139: 
                   1140:   STMT_SOURCE_FILE (t) = filename;
                   1141:   STMT_SOURCE_LINE (t) = line;
                   1142:   STMT_COND (t) = cond;
                   1143:   STMT_THEN (t) = thenclause;
                   1144:   STMT_ELSE (t) = elseclause;
                   1145:   return t;
                   1146: }
                   1147: 
                   1148: tree
                   1149: build_exit (filename, line, cond)
                   1150:      char *filename;
                   1151:      int line;
                   1152:      tree cond;
                   1153: {
                   1154:   register tree t = make_node (EXIT_STMT);
                   1155:   STMT_SOURCE_FILE (t) = filename;
                   1156:   STMT_SOURCE_LINE (t) = line;
                   1157:   STMT_BODY (t) = cond;
                   1158:   return t;
                   1159: }
                   1160: 
                   1161: tree
                   1162: build_asm_stmt (filename, line, asmcode)
                   1163:      char *filename;
                   1164:      int line;
                   1165:      tree asmcode;
                   1166: {
                   1167:   register tree t = make_node (ASM_STMT);
                   1168:   STMT_SOURCE_FILE (t) = filename;
                   1169:   STMT_SOURCE_LINE (t) = line;
                   1170:   STMT_BODY (t) = asmcode;
                   1171:   return t;
                   1172: }
                   1173: 
                   1174: tree
                   1175: build_case (filename, line, object, cases)
                   1176:      char *filename;
                   1177:      int line;
                   1178:      tree object, cases;
                   1179: {
                   1180:   register tree t = make_node (CASE_STMT);
                   1181:   STMT_SOURCE_FILE (t) = filename;
                   1182:   STMT_SOURCE_LINE (t) = line;
                   1183:   STMT_CASE_INDEX (t) = object;
                   1184:   STMT_CASE_LIST (t) = cases;
                   1185:   return t;
                   1186: }
                   1187: 
                   1188: tree
                   1189: build_let (filename, line, vars, body, supercontext, tags)
                   1190:      char *filename;
                   1191:      int line;
                   1192:      tree vars, body, supercontext, tags;
                   1193: {
                   1194:   register tree t = make_node (LET_STMT);
                   1195:   STMT_SOURCE_FILE (t) = filename;
                   1196:   STMT_SOURCE_LINE (t) = line;
                   1197:   STMT_VARS (t) = vars;
                   1198:   STMT_BODY (t) = body;
                   1199:   STMT_SUPERCONTEXT (t) = supercontext;
                   1200:   STMT_BIND_SIZE (t) = 0;
                   1201:   STMT_TYPE_TAGS (t) = tags;
                   1202:   return t;
                   1203: }
                   1204: 
                   1205: tree
                   1206: build_loop (filename, line, body)
                   1207:      char *filename;
                   1208:      int line;
                   1209:      tree body;
                   1210: {
                   1211:   register tree t = make_node (LOOP_STMT);
                   1212:   STMT_SOURCE_FILE (t) = filename;
                   1213:   STMT_SOURCE_LINE (t) = line;
                   1214:   STMT_BODY (t) = body;
                   1215:   return t;
                   1216: }
                   1217: 
                   1218: tree
                   1219: build_compound (filename, line, body)
                   1220:      char *filename;
                   1221:      int line;
                   1222:      tree body;
                   1223: {
                   1224:   register tree t = make_node (COMPOUND_STMT);
                   1225:   STMT_SOURCE_FILE (t) = filename;
                   1226:   STMT_SOURCE_LINE (t) = line;
                   1227:   STMT_BODY (t) = body;
                   1228:   return t;
                   1229: }
                   1230: 
                   1231: /* Return a type like TYPE except that its TREE_READONLY is CONSTP
                   1232:    and its TREE_VOLATILE is VOLATILEP.
                   1233: 
                   1234:    Such variant types already made are recorded so that duplicates
                   1235:    are not made.
                   1236: 
                   1237:    A variant types should never be used as the type of an expression.
                   1238:    Always copy the variant information into the TREE_READONLY
                   1239:    and TREE_VOLATILE of the expression, and then give the expression
                   1240:    as its type the "main variant", the variant whose TREE_READONLY
                   1241:    and TREE_VOLATILE are zero.  Use TYPE_MAIN_VARIANT to find the
                   1242:    main variant.  */
                   1243: 
                   1244: tree
                   1245: build_type_variant (type, constp, volatilep)
                   1246:      tree type;
                   1247:      int constp, volatilep;
                   1248: {
                   1249:   register tree t, m = TYPE_MAIN_VARIANT (type);
                   1250:   register struct obstack *ambient_obstack = current_obstack;
                   1251: 
                   1252:   /* Treat any nonzero argument as 1.  */
                   1253:   constp = !!constp;
                   1254:   volatilep = !!volatilep;
                   1255: 
                   1256:   /* First search the chain variants for one that is what we want.  */
                   1257: 
                   1258:   for (t = m; t; t = TYPE_NEXT_VARIANT (t))
                   1259:     if (constp == TREE_READONLY (t)
                   1260:        && volatilep == TREE_VOLATILE (t))
                   1261:       return t;
                   1262: 
                   1263:   /* We need a new one.  */
1.1.1.2 ! root     1264:   current_obstack
        !          1265:     = TREE_PERMANENT (type) ? &permanent_obstack : saveable_obstack;
1.1       root     1266: 
                   1267:   t = copy_node (type);
                   1268:   TREE_READONLY (t) = constp;
                   1269:   TREE_VOLATILE (t) = volatilep;
                   1270:   TYPE_POINTER_TO (t) = 0;
                   1271: 
                   1272:   /* Add this type to the chain of variants of TYPE.  */
                   1273:   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
                   1274:   TYPE_NEXT_VARIANT (m) = t;
                   1275: 
                   1276:   current_obstack = ambient_obstack;
                   1277:   return t;
                   1278: }
                   1279: 
1.1.1.2 ! root     1280: /* Hashing of types so that we don't make duplicates.
        !          1281:    The entry point is `type_hash_canon'.  */
        !          1282: 
        !          1283: /* Each hash table slot is a bucket containing a chain
        !          1284:    of these structures.  */
        !          1285: 
        !          1286: struct type_hash
        !          1287: {
        !          1288:   struct type_hash *next;      /* Next structure in the bucket.  */
        !          1289:   int hashcode;                        /* Hash code of this type.  */
        !          1290:   tree type;                   /* The type recorded here.  */
        !          1291: };
        !          1292: 
        !          1293: /* Now here is the hash table.  When recording a type, it is added
        !          1294:    to the slot whose index is the hash code mod the table size.
        !          1295:    Note that the hash table is used for several kinds of types
        !          1296:    (function types, array types and array index range types, for now).
        !          1297:    While all these live in the same table, they are completely independent,
        !          1298:    and the hash code is computed differently for each of these.  */
        !          1299: 
        !          1300: #define TYPE_HASH_SIZE 29
        !          1301: struct type_hash *type_hash_table[TYPE_HASH_SIZE];
        !          1302: 
        !          1303: /* Here is how primitive or already-canonicalized types' hash
        !          1304:    codes are made.  */
        !          1305: #define TYPE_HASH(TYPE) TREE_UID (TYPE)
        !          1306: 
        !          1307: /* Compute a hash code for a list of types (chain of TREE_LIST nodes
        !          1308:    with types in the TREE_VALUE slots), by adding the hash codes
        !          1309:    of the individual types.  */
        !          1310: 
        !          1311: int
        !          1312: type_hash_list (list)
        !          1313:      tree list;
        !          1314: {
        !          1315:   register int hashcode;
        !          1316:   register tree tail;
        !          1317:   for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
        !          1318:     hashcode += TYPE_HASH (TREE_VALUE (tail));
        !          1319:   return hashcode;
        !          1320: }
        !          1321: 
        !          1322: /* Look in the type hash table for a type isomorphic to TYPE.
        !          1323:    If one is found, return it.  Otherwise return 0.  */
        !          1324: 
        !          1325: tree
        !          1326: type_hash_lookup (hashcode, type)
        !          1327:      int hashcode;
        !          1328:      tree type;
        !          1329: {
        !          1330:   register struct type_hash *h;
        !          1331:   for (h = type_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
        !          1332:     if (h->hashcode == hashcode
        !          1333:        && TREE_CODE (h->type) == TREE_CODE (type)
        !          1334:        && TREE_TYPE (h->type) == TREE_TYPE (type)
        !          1335:        && (TYPE_MAX_VALUE (h->type) == TYPE_MAX_VALUE (type)
        !          1336:            || tree_int_cst_equal (TYPE_MAX_VALUE (h->type),
        !          1337:                                   TYPE_MAX_VALUE (type)))
        !          1338:        && (TYPE_MIN_VALUE (h->type) == TYPE_MIN_VALUE (type)
        !          1339:            || tree_int_cst_equal (TYPE_MIN_VALUE (h->type),
        !          1340:                                   TYPE_MIN_VALUE (type)))
        !          1341:        && (TYPE_DOMAIN (h->type) == TYPE_DOMAIN (type)
        !          1342:            || (TREE_CODE (TYPE_DOMAIN (h->type)) == TREE_LIST
        !          1343:                && TREE_CODE (TYPE_DOMAIN (type)) == TREE_LIST
        !          1344:                && type_list_equal (TYPE_DOMAIN (h->type), TYPE_DOMAIN (type)))))
        !          1345:       return h->type;
        !          1346:   return 0;
        !          1347: }
        !          1348: 
        !          1349: /* Add an entry to the type-hash-table
        !          1350:    for a type TYPE whose hash code is HASHCODE.  */
        !          1351: 
        !          1352: void
        !          1353: type_hash_add (hashcode, type)
        !          1354:      int hashcode;
        !          1355:      tree type;
        !          1356: {
        !          1357:   register struct type_hash *h;
        !          1358: 
        !          1359:   h = (struct type_hash *) oballoc (sizeof (struct type_hash));
        !          1360:   h->hashcode = hashcode;
        !          1361:   h->type = type;
        !          1362:   h->next = type_hash_table[hashcode % TYPE_HASH_SIZE];
        !          1363:   type_hash_table[hashcode % TYPE_HASH_SIZE] = h;
        !          1364: }
        !          1365: 
        !          1366: /* Given TYPE, and HASHCODE its hash code, return the canonical
        !          1367:    object for an identical type if one already exists.
        !          1368:    Otherwise, return TYPE, and record it as the canonical object
        !          1369:    if it is a permanent object.
        !          1370: 
        !          1371:    To use this function, first create a type of the sort you want.
        !          1372:    Then compute its hash code from the fields of the type that
        !          1373:    make it different from other similar types.
        !          1374:    Then call this function and use the value.
        !          1375:    This function frees the type you pass in if it is a duplicate.  */
        !          1376: 
        !          1377: /* Set to 1 to debug without canonicalization.  Never set by program.  */
        !          1378: int debug_no_type_hash = 0;
        !          1379: 
        !          1380: tree
        !          1381: type_hash_canon (hashcode, type)
        !          1382:      int hashcode;
        !          1383:      tree type;
        !          1384: {
        !          1385:   tree t1;
        !          1386: 
        !          1387:   if (debug_no_type_hash)
        !          1388:     return type;
        !          1389: 
        !          1390:   t1 = type_hash_lookup (hashcode, type);
        !          1391:   if (t1 != 0)
        !          1392:     {
        !          1393:       struct obstack *o
        !          1394:        = TREE_PERMANENT (type) ? &permanent_obstack : saveable_obstack;
        !          1395:       obstack_free (o, type);
        !          1396:       return t1;
        !          1397:     }
        !          1398: 
        !          1399:   /* If this is a new type, record it for later reuse.  */
        !          1400:   if (current_obstack == &permanent_obstack)
        !          1401:     type_hash_add (hashcode, type);
        !          1402: 
        !          1403:   return type;
        !          1404: }
        !          1405: 
        !          1406: /* Given two lists of types
        !          1407:    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
        !          1408:    return 1 if the lists contain the same types in the same order.  */
        !          1409: 
        !          1410: int
        !          1411: type_list_equal (l1, l2)
        !          1412:      tree l1, l2;
        !          1413: {
        !          1414:   register tree t1, t2;
        !          1415:   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
        !          1416:     if (TREE_VALUE (t1) != TREE_VALUE (t2))
        !          1417:       return 0;
        !          1418: 
        !          1419:   return t1 == t2;
        !          1420: }
        !          1421: 
        !          1422: /* Nonzero if integer constants T1 and T2
        !          1423:    represent the same constant value.  */
        !          1424: 
        !          1425: int
        !          1426: tree_int_cst_equal (t1, t2)
        !          1427:      tree t1, t2;
        !          1428: {
        !          1429:   if (t1 == t2)
        !          1430:     return 1;
        !          1431:   if (t1 == 0 || t2 == 0)
        !          1432:     return 0;
        !          1433:   if (TREE_CODE (t1) == INTEGER_CST
        !          1434:       && TREE_CODE (t2) == INTEGER_CST
        !          1435:       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
        !          1436:       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
        !          1437:     return 1;
        !          1438:   return 0;
        !          1439: }
        !          1440: 
        !          1441: /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
        !          1442:    The precise way of comparison depends on their data type.  */
        !          1443: 
        !          1444: int
        !          1445: tree_int_cst_lt (t1, t2)
        !          1446:      tree t1, t2;
        !          1447: {
        !          1448:   if (t1 == t2)
        !          1449:     return 0;
        !          1450: 
        !          1451:   if (!TREE_UNSIGNED (TREE_TYPE (t1)))
        !          1452:     return INT_CST_LT (t1, t2);
        !          1453:   return INT_CST_LT_UNSIGNED (t1, t2);
        !          1454: }
        !          1455: 
1.1       root     1456: /* Constructors for pointer, array and function types.
                   1457:    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
                   1458:    constructed by language-dependent code, not here.)  */
                   1459: 
1.1.1.2 ! root     1460: /* Construct, lay out and return the type of pointers to TO_TYPE.
        !          1461:    If such a type has already been constructed, reuse it.  */
        !          1462: 
1.1       root     1463: tree
                   1464: build_pointer_type (to_type)
                   1465:      tree to_type;
                   1466: {
                   1467:   register tree t = TYPE_POINTER_TO (to_type);
                   1468:   register struct obstack *ambient_obstack = current_obstack;
                   1469: 
                   1470:   /* First, if we already have a type for pointers to TO_TYPE, use it.  */
                   1471: 
                   1472:   if (t)
                   1473:     return t;
                   1474: 
                   1475:   /* We need a new one.  If TO_TYPE is permanent, make this permanent too.  */
                   1476:   current_obstack = (TREE_PERMANENT (to_type)
                   1477:                     ? &permanent_obstack
1.1.1.2 ! root     1478:                     : saveable_obstack);
1.1       root     1479: 
                   1480:   t = make_node (POINTER_TYPE);
                   1481:   TREE_TYPE (t) = to_type;
                   1482: 
                   1483:   /* Record this type as the pointer to TO_TYPE.  */
                   1484:   TYPE_POINTER_TO (to_type) = t;
                   1485: 
1.1.1.2 ! root     1486:   /* Lay out the type.  This function has many callers that are concerned
        !          1487:      with expression-construction, and this simplifies them all.
        !          1488:      Also, it guarantees the TYPE_SIZE is permanent if the type is.  */
        !          1489:   layout_type (t);
1.1       root     1490: 
                   1491:   current_obstack = ambient_obstack;
                   1492:   return t;
                   1493: }
                   1494: 
1.1.1.2 ! root     1495: /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
        !          1496:    and number of elements specified by the range of values of INDEX_TYPE.
        !          1497:    If such a type has already been constructed, reuse it.  */
        !          1498: 
1.1       root     1499: tree
                   1500: build_array_type (elt_type, index_type)
                   1501:      tree elt_type, index_type;
                   1502: {
                   1503:   register tree t = make_node (ARRAY_TYPE);
1.1.1.2 ! root     1504:   int hashcode;
1.1       root     1505: 
                   1506:   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
                   1507:     {
1.1.1.2 ! root     1508:       error ("arrays of functions are not meaningful");
1.1       root     1509:       elt_type = integer_type_node;
                   1510:     }
                   1511: 
                   1512:   TREE_TYPE (t) = elt_type;
                   1513:   TYPE_DOMAIN (t) = index_type;
1.1.1.2 ! root     1514: 
1.1       root     1515:   /* Make sure TYPE_POINTER_TO (elt_type) is filled in.  */
                   1516:   build_pointer_type (elt_type);
1.1.1.2 ! root     1517: 
        !          1518:   if (index_type == 0)
        !          1519:     return t;
        !          1520: 
        !          1521:   hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
        !          1522:   t = type_hash_canon (hashcode, t);
        !          1523: 
        !          1524:   if (TYPE_SIZE (t) == 0)
        !          1525:     layout_type (t);
1.1       root     1526:   return t;
                   1527: }
                   1528: 
1.1.1.2 ! root     1529: /* Construct, lay out and return
        !          1530:    the type of functions returning type VALUE_TYPE
        !          1531:    given arguments of types ARG_TYPES.
        !          1532:    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
        !          1533:    are data type nodes for the arguments of the function.
        !          1534:    If such a type has already been constructed, reuse it.  */
1.1       root     1535: 
                   1536: tree
                   1537: build_function_type (value_type, arg_types)
                   1538:      tree value_type, arg_types;
                   1539: {
                   1540:   register tree t;
1.1.1.2 ! root     1541:   int hashcode;
1.1       root     1542: 
1.1.1.2 ! root     1543:   if (TREE_CODE (value_type) == FUNCTION_TYPE
1.1       root     1544:       || TREE_CODE (value_type) == ARRAY_TYPE)
                   1545:     {
1.1.1.2 ! root     1546:       error ("function return type cannot be function or array");
1.1       root     1547:       value_type = integer_type_node;
                   1548:     }
                   1549: 
1.1.1.2 ! root     1550:   /* Make a node of the sort we want.  */
1.1       root     1551:   t = make_node (FUNCTION_TYPE);
                   1552:   TREE_TYPE (t) = value_type;
                   1553:   TYPE_ARG_TYPES (t) = arg_types;
1.1.1.2 ! root     1554: 
        !          1555:   /* If we already have such a type, use the old one and free this one.  */
        !          1556:   hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
        !          1557:   t = type_hash_canon (hashcode, t);
        !          1558: 
        !          1559:   if (TYPE_SIZE (t) == 0)
        !          1560:     layout_type (t);
1.1       root     1561:   return t;
                   1562: }
                   1563: 
                   1564: /* Return OP, stripped of any conversions to wider types as much as is safe.
                   1565:    Converting the value back to OP's type makes a value equivalent to OP.
                   1566: 
                   1567:    If FOR_TYPE is nonzero, we return a value which, if converted to
                   1568:    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
                   1569: 
1.1.1.2 ! root     1570:    If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
        !          1571:    narrowest type that can hold the value, even if they don't exactly fit.
        !          1572:    Otherwise, bit-field references are changed to a narrower type
        !          1573:    only if they can be fetched directly from memory in that type.
        !          1574: 
1.1       root     1575:    OP must have integer, real or enumeral type.  Pointers are not allowed!
                   1576: 
                   1577:    There are some cases where the obvious value we could return
                   1578:    would regenerate to OP if converted to OP's type, 
                   1579:    but would not extend like OP to wider types.
                   1580:    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
                   1581:    For example, if OP is (unsigned short)(signed char)-1,
                   1582:    we avoid returning (signed char)-1 if FOR_TYPE is int,
                   1583:    even though extending that to an unsigned short would regenerate OP,
                   1584:    since the result of extending (signed char)-1 to (int)
                   1585:    is different from (int) OP.  */
                   1586: 
                   1587: tree
                   1588: get_unwidened (op, for_type)
                   1589:      register tree op;
                   1590:      tree for_type;
                   1591: {
                   1592:   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
                   1593:   /* TYPE_PRECISION is safe in place of type_precision since
                   1594:      pointer types are not allowed.  */
                   1595:   register tree type = TREE_TYPE (op);
                   1596:   register int final_prec = TYPE_PRECISION (for_type != 0 ? for_type : type);
                   1597:   register int uns
                   1598:     = (for_type != 0 && for_type != type
                   1599:        && final_prec > TYPE_PRECISION (type)
1.1.1.2 ! root     1600:        && TREE_UNSIGNED (type));
1.1       root     1601:   register tree win = op;
                   1602: 
                   1603:   while (TREE_CODE (op) == NOP_EXPR)
                   1604:     {
                   1605:       register int bitschange
                   1606:        = TYPE_PRECISION (TREE_TYPE (op))
                   1607:          - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
                   1608: 
                   1609:       /* Truncations are many-one so cannot be removed.
                   1610:         Unless we are later going to truncate down even farther.  */
                   1611:       if (bitschange < 0
                   1612:          && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
                   1613:        break;
                   1614: 
                   1615:       /* See what's inside this conversion.  If we decide to strip it,
                   1616:         we will set WIN.  */
                   1617:       op = TREE_OPERAND (op, 0);
                   1618: 
                   1619:       /* If we have not stripped any zero-extensions (uns is 0),
                   1620:         we can strip any kind of extension.
                   1621:         If we have previously stripped a zero-extension,
                   1622:         only zero-extensions can safely be stripped.
                   1623:         Any extension can be stripped if the bits it would produce
                   1624:         are all going to be discarded later by truncating to FOR_TYPE.  */
                   1625: 
                   1626:       if (bitschange > 0)
                   1627:        {
                   1628:          if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
                   1629:            win = op;
1.1.1.2 ! root     1630:          /* TREE_UNSIGNED says whether this is a zero-extension.
1.1       root     1631:             Let's avoid computing it if it does not affect WIN
                   1632:             and if UNS will not be needed again.  */
                   1633:          if ((uns || TREE_CODE (op) == NOP_EXPR)
1.1.1.2 ! root     1634:              && TREE_UNSIGNED (TREE_TYPE (op)))
1.1       root     1635:            {
                   1636:              uns = 1;
                   1637:              win = op;
                   1638:            }
                   1639:        }
                   1640:     }
                   1641: 
1.1.1.2 ! root     1642:   if (TREE_CODE (op) == COMPONENT_REF
        !          1643:       /* Since type_for_size always gives an integer type.  */
        !          1644:       && TREE_CODE (type) != REAL_TYPE)
        !          1645:     {
        !          1646:       int innerprec = (TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)))
        !          1647:                       * DECL_SIZE_UNIT (TREE_OPERAND (op, 1)));
        !          1648:       type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1)));
        !          1649: 
        !          1650:       /* We can get this structure field in the narrowest type it fits in.
        !          1651:         If FOR_TYPE is 0, do this only for a field that matches the
        !          1652:         narrower type exactly and is aligned for it (i.e. mode isn't BI).
        !          1653:         The resulting extension to its nominal type (a fullword type)
        !          1654:         must fit the same conditions as for other extensions.  */
        !          1655: 
        !          1656:       if (innerprec <= TYPE_PRECISION (TREE_TYPE (op))
        !          1657:          && (for_type || DECL_MODE (TREE_OPERAND (op, 1)) != BImode)
        !          1658:          && (! uns || final_prec <= innerprec
        !          1659:              || TREE_UNSIGNED (TREE_OPERAND (op, 1)))
        !          1660:          && type != 0)
        !          1661:        {
        !          1662:          win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
        !          1663:                       TREE_OPERAND (op, 1));
        !          1664:          TREE_VOLATILE (win) = TREE_VOLATILE (op);
        !          1665:          TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
        !          1666:        }
        !          1667:     }
1.1       root     1668:   return win;
                   1669: }
                   1670: 
                   1671: /* Return OP or a simpler expression for a narrower value
                   1672:    which can be sign-extended or zero-extended to give back OP.
                   1673:    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
                   1674:    or 0 if the value should be sign-extended.  */
                   1675: 
                   1676: tree
                   1677: get_narrower (op, unsignedp_ptr)
                   1678:      register tree op;
                   1679:      int *unsignedp_ptr;
                   1680: {
                   1681:   register int uns = 0;
                   1682:   int first = 1;
                   1683:   register tree win = op;
                   1684: 
                   1685:   while (TREE_CODE (op) == NOP_EXPR)
                   1686:     {
                   1687:       register int bitschange
                   1688:        = TYPE_PRECISION (TREE_TYPE (op))
                   1689:          - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
                   1690: 
                   1691:       /* Truncations are many-one so cannot be removed.  */
                   1692:       if (bitschange < 0)
                   1693:        break;
                   1694: 
                   1695:       /* See what's inside this conversion.  If we decide to strip it,
                   1696:         we will set WIN.  */
                   1697:       op = TREE_OPERAND (op, 0);
                   1698: 
                   1699:       if (bitschange > 0)
                   1700:        {
                   1701:          /* An extension: the outermost one can be stripped,
                   1702:             but remember whether it is zero or sign extension.  */
                   1703:          if (first)
1.1.1.2 ! root     1704:            uns = TREE_UNSIGNED (TREE_TYPE (op));
1.1       root     1705:          /* Otherwise, if a sign extension has been stripped,
                   1706:             only sign extensions can now be stripped;
                   1707:             if a zero extension has been stripped, only zero-extensions.  */
1.1.1.2 ! root     1708:          else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
1.1       root     1709:            break;
                   1710:          first = 0;
                   1711:        }
                   1712:       /* A change in nominal type can always be stripped.  */
                   1713: 
                   1714:       win = op;
                   1715:     }
                   1716: 
1.1.1.2 ! root     1717:   if (TREE_CODE (op) == COMPONENT_REF
        !          1718:       /* Since type_for_size always gives an integer type.  */
        !          1719:       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE)
1.1       root     1720:     {
                   1721:       int innerprec = (TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)))
                   1722:                       * DECL_SIZE_UNIT (TREE_OPERAND (op, 1)));
1.1.1.2 ! root     1723:       tree type = type_for_size (innerprec, TREE_UNSIGNED (op));
1.1       root     1724: 
                   1725:       /* We can get this structure field in a narrower type that fits it,
                   1726:         but the resulting extension to its nominal type (a fullword type)
1.1.1.2 ! root     1727:         must satisfy the same conditions as for other extensions.
        !          1728: 
        !          1729:         Do this only for fields that are aligned (not BImode),
        !          1730:         because when bit-field insns will be used there is no
        !          1731:         advantage in doing this.  */
1.1       root     1732: 
                   1733:       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
1.1.1.2 ! root     1734:          && DECL_MODE (TREE_OPERAND (op, 1)) != BImode
        !          1735:          && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
1.1       root     1736:          && type != 0)
                   1737:        {
1.1.1.2 ! root     1738:          if (first)
        !          1739:            uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
        !          1740:          win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
        !          1741:                       TREE_OPERAND (op, 1));
        !          1742:          TREE_VOLATILE (win) = TREE_VOLATILE (op);
        !          1743:          TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
1.1       root     1744:        }
                   1745:     }
                   1746:   *unsignedp_ptr = uns;
                   1747:   return win;
                   1748: }
                   1749: 
                   1750: /* Return the precision of a type, for arithmetic purposes.
                   1751:    Supports all types on which arithmetic is possible
                   1752:    (including pointer types).
                   1753:    It's not clear yet what will be right for complex types.  */
                   1754: 
                   1755: int
                   1756: type_precision (type)
                   1757:      register tree type;
                   1758: {
                   1759:   return ((TREE_CODE (type) == INTEGER_TYPE
                   1760:           || TREE_CODE (type) == ENUMERAL_TYPE
                   1761:           || TREE_CODE (type) == REAL_TYPE)
1.1.1.2 ! root     1762:          ? TYPE_PRECISION (type) : POINTER_SIZE);
1.1       root     1763: }
                   1764: 
                   1765: /* Nonzero if integer constant C has a value that is permissible
                   1766:    for type TYPE (an INTEGER_TYPE).  */
                   1767: 
                   1768: int
                   1769: int_fits_type_p (c, type)
                   1770:      tree c, type;
                   1771: {
1.1.1.2 ! root     1772:   if (TREE_UNSIGNED (type))
1.1       root     1773:     return (!INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)
                   1774:            && !INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type)));
                   1775:   else
                   1776:     return (!INT_CST_LT (TYPE_MAX_VALUE (type), c)
                   1777:            && !INT_CST_LT (c, TYPE_MIN_VALUE (type)));
                   1778: }
                   1779: 
                   1780: /* Subroutines of `convert'.  */
                   1781: 
                   1782: /* Change of width--truncation and extension of integers or reals--
                   1783:    is represented with NOP_EXPR.  Proper functioning of many things
                   1784:    assumes that no other conversions can be NOP_EXPRs.
                   1785: 
                   1786:    Conversion between integer and pointer is represented with CONVERT_EXPR.
                   1787:    Converting integer to real uses FLOAT_EXPR
                   1788:    and real to integer uses FIX_TRUNC_EXPR.  */
                   1789: 
                   1790: static tree
                   1791: convert_to_pointer (type, expr)
                   1792:      tree type, expr;
                   1793: {
                   1794:   register tree intype = TREE_TYPE (expr);
                   1795:   register enum tree_code form = TREE_CODE (intype);
                   1796:   
                   1797:   if (integer_zerop (expr))
                   1798:     {
                   1799:       if (type == TREE_TYPE (null_pointer_node))
                   1800:        return null_pointer_node;
                   1801:       expr = build_int_2 (0, 0);
                   1802:       TREE_TYPE (expr) = type;
                   1803:       return expr;
                   1804:     }
                   1805: 
                   1806:   if (form == POINTER_TYPE)
1.1.1.2 ! root     1807:     return build (NOP_EXPR, type, expr);
1.1       root     1808: 
                   1809: 
                   1810:   if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
1.1.1.2 ! root     1811:     {
        !          1812:       if (type_precision (intype) == POINTER_SIZE)
        !          1813:        return build (CONVERT_EXPR, type, expr);
        !          1814:       return convert_to_pointer (type,
        !          1815:                                 convert (type_for_size (POINTER_SIZE, 0),
        !          1816:                                          expr));
        !          1817:     }
1.1       root     1818: 
1.1.1.2 ! root     1819:   error ("cannot convert to a pointer type");
1.1       root     1820: 
                   1821:   return null_pointer_node;
                   1822: }
                   1823: 
                   1824: /* The result of this is always supposed to be a newly created tree node
                   1825:    not in use in any existing structure.  */
                   1826: 
                   1827: static tree
                   1828: convert_to_integer (type, expr)
                   1829:      tree type, expr;
                   1830: {
                   1831:   register tree intype = TREE_TYPE (expr);
                   1832:   register enum tree_code form = TREE_CODE (intype);
                   1833:   extern tree build_binary_op_nodefault ();
                   1834:   extern tree build_unary_op ();
                   1835: 
                   1836:   if (form == POINTER_TYPE)
                   1837:     {
                   1838:       if (integer_zerop (expr))
                   1839:        expr = integer_zero_node;
                   1840:       else
1.1.1.2 ! root     1841:        expr = fold (build (CONVERT_EXPR,
        !          1842:                            type_for_size (POINTER_SIZE, 0), expr));
1.1       root     1843:       intype = TREE_TYPE (expr);
                   1844:       form = TREE_CODE (intype);
1.1.1.2 ! root     1845:       if (intype == type)
        !          1846:        return expr;
1.1       root     1847:     }
                   1848: 
                   1849:   if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
                   1850:     {
                   1851:       register int outprec = TYPE_PRECISION (type);
                   1852:       register int inprec = TYPE_PRECISION (intype);
                   1853:       register enum tree_code ex_form = TREE_CODE (expr);
                   1854: 
                   1855:       if (outprec >= inprec)
1.1.1.2 ! root     1856:        return build (NOP_EXPR, type, expr);
1.1       root     1857: 
                   1858: /* Here detect when we can distribute the truncation down past some arithmetic.
                   1859:    For example, if adding two longs and converting to an int,
                   1860:    we can equally well convert both to ints and then add.
                   1861:    For the operations handled here, such truncation distribution
                   1862:    is always safe.
                   1863:    It is desirable in these cases:
                   1864:    1) when truncating down to full-word from a larger size
                   1865:    2) when truncating takes no work.
                   1866:    3) when at least one operand of the arithmetic has been extended
                   1867:    (as by C's default conversions).  In this case we need two conversions
                   1868:    if we do the arithmetic as already requested, so we might as well
                   1869:    truncate both and then combine.  Perhaps that way we need only one.
                   1870: 
                   1871:    Note that in general we cannot do the arithmetic in a type
                   1872:    shorter than the desired result of conversion, even if the operands
                   1873:    are both extended from a shorter type, because they might overflow
                   1874:    if combined in that type.  The exceptions to this--the times when
                   1875:    two narrow values can be combined in their narrow type even to
                   1876:    make a wider result--are handled by "shorten" in build_binary_op.  */
                   1877: 
                   1878:       switch (ex_form)
                   1879:        {
                   1880:        case RSHIFT_EXPR:
                   1881:          /* We can pass truncation down through right shifting
                   1882:             when the shift count is a negative constant.  */
                   1883:          if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
                   1884:              || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) > 0)
                   1885:            break;
                   1886:          goto trunc1;
                   1887: 
                   1888:        case LSHIFT_EXPR:
                   1889:          /* We can pass truncation down through left shifting
                   1890:             when the shift count is a positive constant.  */
                   1891:          if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
                   1892:              || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) < 0)
                   1893:            break;
                   1894:          /* In this case, shifting is like multiplication.  */
                   1895: 
                   1896:        case PLUS_EXPR:
                   1897:        case MINUS_EXPR:
                   1898:        case MULT_EXPR:
                   1899:        case MAX_EXPR:
                   1900:        case MIN_EXPR:
                   1901:        case BIT_AND_EXPR:
                   1902:        case BIT_IOR_EXPR:
                   1903:        case BIT_XOR_EXPR:
                   1904:        case BIT_ANDTC_EXPR:
                   1905:        trunc1:
                   1906:          {
                   1907:            tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
                   1908:            tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
                   1909: 
                   1910:            if (outprec >= BITS_PER_WORD
                   1911:                || TRULY_NOOP_TRUNCATION (outprec, inprec)
                   1912:                || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
                   1913:                || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
                   1914:              {
                   1915:                /* Do the arithmetic in type TYPEX,
                   1916:                   then convert result to TYPE.  */
                   1917:                register tree typex = type;
                   1918: 
                   1919:                /* Can't do arithmetic in enumeral types
                   1920:                   so use an integer type that will hold the values.  */
                   1921:                if (TREE_CODE (typex) == ENUMERAL_TYPE)
1.1.1.2 ! root     1922:                  typex = type_for_size (TYPE_PRECISION (typex),
        !          1923:                                         TREE_UNSIGNED (typex));
1.1       root     1924: 
                   1925:                /* But now perhaps TYPEX is as wide as INPREC.
                   1926:                   In that case, do nothing special here.
                   1927:                   (Otherwise would recurse infinitely in convert.  */
                   1928:                if (TYPE_PRECISION (typex) != inprec)
                   1929:                  {
                   1930:                    /* Don't do unsigned arithmetic where signed was wanted,
                   1931:                       or vice versa.  */
1.1.1.2 ! root     1932:                    typex = (TREE_UNSIGNED (TREE_TYPE (expr))
1.1       root     1933:                             ? unsigned_type (typex) : signed_type (typex));
                   1934:                    return convert (type,
                   1935:                                    build_binary_op_nodefault (ex_form,
                   1936:                                                               convert (typex, arg0),
                   1937:                                                               convert (typex, arg1)));
                   1938:                  }
                   1939:              }
                   1940:          }
                   1941:          break;
                   1942: 
                   1943:        case EQ_EXPR:
                   1944:        case NE_EXPR:
                   1945:        case GT_EXPR:
                   1946:        case GE_EXPR:
                   1947:        case LT_EXPR:
                   1948:        case LE_EXPR:
                   1949:        case TRUTH_AND_EXPR:
                   1950:        case TRUTH_OR_EXPR:
                   1951:        case TRUTH_NOT_EXPR:
                   1952:          /* If we want result of comparison converted to a byte,
                   1953:             we can just regard it as a byte, since it is 0 or 1.  */
                   1954:          TREE_TYPE (expr) = type;
                   1955:          return expr;
                   1956: 
                   1957:        case NEGATE_EXPR:
                   1958:        case BIT_NOT_EXPR:
                   1959:        case ABS_EXPR:
                   1960:          {
                   1961:            register tree typex = type;
                   1962: 
                   1963:            /* Can't do arithmetic in enumeral types
                   1964:               so use an integer type that will hold the values.  */
                   1965:            if (TREE_CODE (typex) == ENUMERAL_TYPE)
1.1.1.2 ! root     1966:              typex = type_for_size (TYPE_PRECISION (typex),
        !          1967:                                     TREE_UNSIGNED (typex));
1.1       root     1968: 
                   1969:            /* But now perhaps TYPEX is as wide as INPREC.
                   1970:               In that case, do nothing special here.
                   1971:               (Otherwise would recurse infinitely in convert.  */
                   1972:            if (TYPE_PRECISION (typex) != inprec)
                   1973:              {
                   1974:                /* Don't do unsigned arithmetic where signed was wanted,
                   1975:                   or vice versa.  */
1.1.1.2 ! root     1976:                typex = (TREE_UNSIGNED (TREE_TYPE (expr))
1.1       root     1977:                         ? unsigned_type (typex) : signed_type (typex));
                   1978:                return convert (type,
                   1979:                                build_unary_op (ex_form,
                   1980:                                                convert (typex, TREE_OPERAND (expr, 0)),
                   1981:                                                1));
                   1982:              }
                   1983:          }
                   1984: 
                   1985:        case NOP_EXPR:
                   1986:          /* If truncating after truncating, might as well do all at once.
                   1987:             If truncating after extending, we may get rid of wasted work.  */
                   1988:          return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
                   1989:        }
                   1990: 
1.1.1.2 ! root     1991:       return build (NOP_EXPR, type, expr);
1.1       root     1992:     }
                   1993: 
                   1994:   if (form == REAL_TYPE)
1.1.1.2 ! root     1995:     return build (FIX_TRUNC_EXPR, type, expr);
1.1       root     1996: 
1.1.1.2 ! root     1997:   error ("aggregate value used where an integer was expected");
1.1       root     1998: 
                   1999:   {
                   2000:     register tree tem = build_int_2 (0, 0);
                   2001:     TREE_TYPE (tem) = type;
                   2002:     return tem;
                   2003:   }
                   2004: }
                   2005: 
                   2006: static tree
                   2007: convert_to_real (type, expr)
                   2008:      tree type, expr;
                   2009: {
                   2010:   register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
1.1.1.2 ! root     2011:   extern int flag_float_store;
1.1       root     2012: 
                   2013:   if (form == REAL_TYPE)
1.1.1.2 ! root     2014:     return build (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
        !          2015:                  type, expr);
1.1       root     2016: 
                   2017:   if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
1.1.1.2 ! root     2018:     return build (FLOAT_EXPR, type, expr);
1.1       root     2019: 
                   2020:   if (form == POINTER_TYPE)
1.1.1.2 ! root     2021:     error ("pointer value used where a float was expected");
1.1       root     2022:   else
1.1.1.2 ! root     2023:     error ("aggregate value used where a float was expected");
1.1       root     2024: 
                   2025:   {
                   2026:     register tree tem = make_node (REAL_CST);
                   2027:     TREE_TYPE (tem) = type;
                   2028:     TREE_REAL_CST (tem) = 0;
                   2029:     return tem;
                   2030:   }
                   2031: }
                   2032: 
                   2033: /* Create an expression whose value is that of EXPR,
                   2034:    converted to type TYPE.  The TREE_TYPE of the value
                   2035:    is always TYPE.  This function implements all reasonable
                   2036:    conversions; callers should filter out those that are
                   2037:    not permitted by the language being compiled.  */
                   2038: 
                   2039: tree
                   2040: convert (type, expr)
                   2041:      tree type, expr;
                   2042: {
                   2043:   register tree e = expr;
                   2044:   register enum tree_code code = TREE_CODE (type);
                   2045: 
                   2046:   if (type == TREE_TYPE (expr) || TREE_CODE (expr) == ERROR_MARK)
                   2047:     return expr;
1.1.1.2 ! root     2048:   if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
        !          2049:     return error_mark_node;
1.1       root     2050:   if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
                   2051:     {
1.1.1.2 ! root     2052:       error ("void value not ignored as it ought to be");
1.1       root     2053:       return error_mark_node;
                   2054:     }
                   2055:   if (code == VOID_TYPE)
1.1.1.2 ! root     2056:     return build (CONVERT_EXPR, type, e);
1.1       root     2057: #if 0
                   2058:   /* This is incorrect.  A truncation can't be stripped this way.
                   2059:      Extensions will be stripped by the use of get_unwidened.  */
                   2060:   if (TREE_CODE (expr) == NOP_EXPR)
                   2061:     return convert (type, TREE_OPERAND (expr, 0));
                   2062: #endif
                   2063:   if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
                   2064:     return fold (convert_to_integer (type, e));
                   2065:   if (code == POINTER_TYPE)
                   2066:     return fold (convert_to_pointer (type, e));
                   2067:   if (code == REAL_TYPE)
                   2068:     return fold (convert_to_real (type, e));
                   2069: 
1.1.1.2 ! root     2070:   error ("conversion to non-scalar type requested");
1.1       root     2071:   return error_mark_node;
                   2072: }

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