![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tree.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to tree.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* Language-indepednent node constructors for parse phase of GNU compiler.
2: Copyright (C) 1987, 1988 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: /* This 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"
40: #include "varargs.h"
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:
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:
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:
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:
80: /* This points at either permanent_obstack or temporary_obstack. */
81:
82: struct obstack *current_obstack;
83:
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:
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:
137: #define MAX_HASH_TABLE 1009
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);
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:
155: current_obstack = &permanent_obstack;
156: expression_obstack = &permanent_obstack;
157: rtl_obstack = saveable_obstack = &permanent_obstack;
158: tree_node_counter = 1;
159: bzero (hash_table, sizeof hash_table);
160: }
161:
162: /* Start allocating on the temporary (per function) obstack.
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. */
166:
167: void
168: temporary_allocation ()
169: {
170: current_obstack = &temporary_obstack;
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;
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:
192: void
193: permanent_allocation ()
194: {
195: /* Free up previous temporary obstack data */
196: obstack_free (&temporary_obstack, temporary_firstobj);
197: obstack_free (&momentary_obstack, momentary_firstobj);
198: obstack_free (&maybepermanent_obstack, maybepermanent_firstobj);
199:
200: current_obstack = &permanent_obstack;
201: expression_obstack = &permanent_obstack;
202: rtl_obstack = saveable_obstack = &permanent_obstack;
203: }
204:
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:
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:
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:
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;
326: register struct obstack *obstack = current_obstack;
327: register int i;
328:
329: switch (type)
330: {
331: case 'd': /* A decl node */
332: length = sizeof (struct tree_decl);
333: /* All decls in an inline function need to be saved. */
334: if (obstack != &permanent_obstack)
335: obstack = saveable_obstack;
336: break;
337:
338: case 't': /* a type node */
339: length = sizeof (struct tree_type);
340: /* All data types are put where we can preserve them if nec. */
341: if (obstack != &permanent_obstack)
342: obstack = saveable_obstack;
343: break;
344:
345: case 's': /* a stmt node */
346: length = sizeof (struct tree_common)
347: + 2 * sizeof (int)
348: + tree_code_length[(int) code] * sizeof (char *);
349: /* All stmts are put where we can preserve them if nec. */
350: if (obstack != &permanent_obstack)
351: obstack = saveable_obstack;
352: break;
353:
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)
373: + tree_code_length[(int) code] * sizeof (char *);
374: /* Identifier nodes are always permanent since they are
375: unique in a compiler run. */
376: if (code == IDENTIFIER_NODE) obstack = &permanent_obstack;
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;
385: i >= sizeof (struct tree_common) / sizeof (int) - 1;
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':
442: length = sizeof (struct tree_common)
443: + 2 * sizeof (int)
444: + tree_code_length[(int) code] * sizeof (char *);
445: break;
446:
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)
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.
527: The TREE_TYPE is set to `int'. */
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;
563: double d;
564:
565: v = make_node (REAL_CST);
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;
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;
598: TREE_STRING_POINTER (s) = obstack_copy0 (saveable_obstack, str, len);
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: {
623: return (TREE_CODE (expr) == INTEGER_CST
624: && TREE_INT_CST_LOW (expr) == 0
625: && TREE_INT_CST_HIGH (expr) == 0);
626: }
627:
628: /* Return 1 if EXPR is the integer constant one. */
629:
630: int
631: integer_onep (expr)
632: tree expr;
633: {
634: return (TREE_CODE (expr) == INTEGER_CST
635: && TREE_INT_CST_LOW (expr) == 1
636: && TREE_INT_CST_HIGH (expr) == 0);
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:
652: uns = TREE_UNSIGNED (TREE_TYPE (expr));
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:
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:
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;
790: if (TYPE_SIZE (type) == 0)
791: {
792: incomplete_type_error (0, type);
793: return integer_zero_node;
794: }
795: return convert_units (TYPE_SIZE (type), TYPE_SIZE_UNIT (type),
796: BITS_PER_UNIT);
797: }
798:
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:
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:
826: if ((code == VAR_DECL || code == FUNCTION_DECL || code == CONSTRUCTOR)
827: && (TREE_STATIC (arg) || TREE_EXTERNAL (arg)))
828: return 1;
829:
830: if (code == STRING_CST)
831: return 1;
832:
833: if (code == COMPONENT_REF)
834: return staticp (TREE_OPERAND (arg, 0));
835:
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:
843: return 0;
844: }
845:
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. */
849:
850: int
851: lvalue_p (ref)
852: tree ref;
853: {
854: register enum tree_code code = TREE_CODE (ref);
855:
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: }
874: return 0;
875: }
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: }
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:
902: /* If the tree evaluates to a constant, then we don't want to hide that
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:
910: return build (SAVE_EXPR, TREE_TYPE (expr), t, NULL);
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.
915: Returns the stabilized reference.
916:
917: Also allows conversion expressions whose operands are references.
918: Any other kind of expression is returned unchanged. */
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:
927: switch (code)
928: {
929: case VAR_DECL:
930: case PARM_DECL:
931: case RESULT_DECL:
932: result = ref;
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:
966: return error_mark_node;
967: }
968:
969: TREE_TYPE (result) = TREE_TYPE (ref);
970: TREE_READONLY (result) = TREE_READONLY (ref);
971: TREE_VOLATILE (result) = TREE_VOLATILE (ref);
972: TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
973:
974: return result;
975: }
976:
977: /* Low-level constructors for expressions. */
978:
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. */
983:
984: tree
985: build (va_alist)
986: va_dcl
987: {
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);
995:
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);
1022: return t;
1023: }
1024:
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. */
1029:
1030: tree
1031: build_nt (va_alist)
1032: va_dcl
1033: {
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);
1041:
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);
1050: return t;
1051: }
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.
1055:
1056: layout_decl is used to set up the decl's storage layout.
1057: Other slots are initialized to 0 or null pointers. */
1058:
1059: tree
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:
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. */
1264: current_obstack
1265: = TREE_PERMANENT (type) ? &permanent_obstack : saveable_obstack;
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:
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:
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:
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:
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
1478: : saveable_obstack);
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:
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);
1490:
1491: current_obstack = ambient_obstack;
1492: return t;
1493: }
1494:
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:
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);
1504: int hashcode;
1505:
1506: if (TREE_CODE (elt_type) == FUNCTION_TYPE)
1507: {
1508: error ("arrays of functions are not meaningful");
1509: elt_type = integer_type_node;
1510: }
1511:
1512: TREE_TYPE (t) = elt_type;
1513: TYPE_DOMAIN (t) = index_type;
1514:
1515: /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
1516: build_pointer_type (elt_type);
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);
1526: return t;
1527: }
1528:
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. */
1535:
1536: tree
1537: build_function_type (value_type, arg_types)
1538: tree value_type, arg_types;
1539: {
1540: register tree t;
1541: int hashcode;
1542:
1543: if (TREE_CODE (value_type) == FUNCTION_TYPE
1544: || TREE_CODE (value_type) == ARRAY_TYPE)
1545: {
1546: error ("function return type cannot be function or array");
1547: value_type = integer_type_node;
1548: }
1549:
1550: /* Make a node of the sort we want. */
1551: t = make_node (FUNCTION_TYPE);
1552: TREE_TYPE (t) = value_type;
1553: TYPE_ARG_TYPES (t) = arg_types;
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);
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:
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:
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)
1600: && TREE_UNSIGNED (type));
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;
1630: /* TREE_UNSIGNED says whether this is a zero-extension.
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)
1634: && TREE_UNSIGNED (TREE_TYPE (op)))
1635: {
1636: uns = 1;
1637: win = op;
1638: }
1639: }
1640: }
1641:
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: }
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)
1704: uns = TREE_UNSIGNED (TREE_TYPE (op));
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. */
1708: else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
1709: break;
1710: first = 0;
1711: }
1712: /* A change in nominal type can always be stripped. */
1713:
1714: win = op;
1715: }
1716:
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)
1720: {
1721: int innerprec = (TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)))
1722: * DECL_SIZE_UNIT (TREE_OPERAND (op, 1)));
1723: tree type = type_for_size (innerprec, TREE_UNSIGNED (op));
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)
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. */
1732:
1733: if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
1734: && DECL_MODE (TREE_OPERAND (op, 1)) != BImode
1735: && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
1736: && type != 0)
1737: {
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);
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)
1762: ? TYPE_PRECISION (type) : POINTER_SIZE);
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: {
1772: if (TREE_UNSIGNED (type))
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)
1807: return build (NOP_EXPR, type, expr);
1808:
1809:
1810: if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
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: }
1818:
1819: error ("cannot convert to a pointer type");
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
1841: expr = fold (build (CONVERT_EXPR,
1842: type_for_size (POINTER_SIZE, 0), expr));
1843: intype = TREE_TYPE (expr);
1844: form = TREE_CODE (intype);
1845: if (intype == type)
1846: return expr;
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)
1856: return build (NOP_EXPR, type, expr);
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)
1922: typex = type_for_size (TYPE_PRECISION (typex),
1923: TREE_UNSIGNED (typex));
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. */
1932: typex = (TREE_UNSIGNED (TREE_TYPE (expr))
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)
1966: typex = type_for_size (TYPE_PRECISION (typex),
1967: TREE_UNSIGNED (typex));
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. */
1976: typex = (TREE_UNSIGNED (TREE_TYPE (expr))
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:
1991: return build (NOP_EXPR, type, expr);
1992: }
1993:
1994: if (form == REAL_TYPE)
1995: return build (FIX_TRUNC_EXPR, type, expr);
1996:
1997: error ("aggregate value used where an integer was expected");
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));
2011: extern int flag_float_store;
2012:
2013: if (form == REAL_TYPE)
2014: return build (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
2015: type, expr);
2016:
2017: if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
2018: return build (FLOAT_EXPR, type, expr);
2019:
2020: if (form == POINTER_TYPE)
2021: error ("pointer value used where a float was expected");
2022: else
2023: error ("aggregate value used where a float was expected");
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;
2048: if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
2049: return error_mark_node;
2050: if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
2051: {
2052: error ("void value not ignored as it ought to be");
2053: return error_mark_node;
2054: }
2055: if (code == VOID_TYPE)
2056: return build (CONVERT_EXPR, type, e);
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:
2070: error ("conversion to non-scalar type requested");
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.