![[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 [GCC 2.x] / gcc|
Return to tree.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Language-independent node constructors for parse phase of GNU compiler.
2: Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: /* This file contains the low level primitives for operating on tree nodes,
22: including allocation, list operations, interning of identifiers,
23: construction of data type nodes and statement nodes,
24: and construction of type conversion nodes. It also contains
25: tables index by tree code that describe how to take apart
26: nodes of that code.
27:
28: It is intended to be language-independent, but occasionally
29: calls language-dependent routines defined (for C) in typecheck.c.
30:
31: The low-level allocation routines oballoc and permalloc
32: are used also for allocating many other kinds of objects
33: by all passes of the compiler. */
34:
35: #include "config.h"
36: #include <stdio.h>
37: #include "flags.h"
38: #include "function.h"
39: #include "tree.h"
40: #include "obstack.h"
41: #include "gvarargs.h"
42:
43: #define obstack_chunk_alloc xmalloc
44: #define obstack_chunk_free free
45:
46: extern int xmalloc ();
47: extern void free ();
48:
49: /* Tree nodes of permanent duration are allocated in this obstack.
50: They are the identifier nodes, and everything outside of
51: the bodies and parameters of function definitions. */
52:
53: struct obstack permanent_obstack;
54:
55: /* The initial RTL, and all ..._TYPE nodes, in a function
56: are allocated in this obstack. Usually they are freed at the
57: end of the function, but if the function is inline they are saved.
58: For top-level functions, this is maybepermanent_obstack.
59: Separate obstacks are made for nested functions. */
60:
61: struct obstack *function_maybepermanent_obstack;
62:
63: /* This is the function_maybepermanent_obstack for top-level functions. */
64:
65: struct obstack maybepermanent_obstack;
66:
67: /* The contents of the current function definition are allocated
68: in this obstack, and all are freed at the end of the function.
69: For top-level functions, this is temporary_obstack.
70: Separate obstacks are made for nested functions. */
71:
72: struct obstack *function_obstack;
73:
74: /* This is used for reading initializers of global variables. */
75:
76: struct obstack temporary_obstack;
77:
78: /* The tree nodes of an expression are allocated
79: in this obstack, and all are freed at the end of the expression. */
80:
81: struct obstack momentary_obstack;
82:
83: /* The tree nodes of a declarator are allocated
84: in this obstack, and all are freed when the declarator
85: has been parsed. */
86:
87: static struct obstack temp_decl_obstack;
88:
89: /* This points at either permanent_obstack
90: or the current function_maybepermanent_obstack. */
91:
92: struct obstack *saveable_obstack;
93:
94: /* This is same as saveable_obstack during parse and expansion phase;
95: it points to the current function's obstack during optimization.
96: This is the obstack to be used for creating rtl objects. */
97:
98: struct obstack *rtl_obstack;
99:
100: /* This points at either permanent_obstack or the current function_obstack. */
101:
102: struct obstack *current_obstack;
103:
104: /* This points at either permanent_obstack or the current function_obstack
105: or momentary_obstack. */
106:
107: struct obstack *expression_obstack;
108:
109: /* Stack of obstack selections for push_obstacks and pop_obstacks. */
110:
111: struct obstack_stack
112: {
113: struct obstack_stack *next;
114: struct obstack *current;
115: struct obstack *saveable;
116: struct obstack *expression;
117: struct obstack *rtl;
118: };
119:
120: struct obstack_stack *obstack_stack;
121:
122: /* Obstack for allocating struct obstack_stack entries. */
123:
124: static struct obstack obstack_stack_obstack;
125:
126: /* Addresses of first objects in some obstacks.
127: This is for freeing their entire contents. */
128: char *maybepermanent_firstobj;
129: char *temporary_firstobj;
130: char *momentary_firstobj;
131: char *temp_decl_firstobj;
132:
133: /* Nonzero means all ..._TYPE nodes should be allocated permanently. */
134:
135: int all_types_permanent;
136:
137: /* Stack of places to restore the momentary obstack back to. */
138:
139: struct momentary_level
140: {
141: /* Pointer back to previous such level. */
142: struct momentary_level *prev;
143: /* First object allocated within this level. */
144: char *base;
145: /* Value of expression_obstack saved at entry to this level. */
146: struct obstack *obstack;
147: };
148:
149: struct momentary_level *momentary_stack;
150:
151: /* Table indexed by tree code giving a string containing a character
152: classifying the tree code. Possibilities are
153: t, d, s, c, r, <, 1, 2 and e. See tree.def for details. */
154:
155: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
156:
157: char *standard_tree_code_type[] = {
158: #include "tree.def"
159: };
160: #undef DEFTREECODE
161:
162: /* Table indexed by tree code giving number of expression
163: operands beyond the fixed part of the node structure.
164: Not used for types or decls. */
165:
166: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
167:
168: int standard_tree_code_length[] = {
169: #include "tree.def"
170: };
171: #undef DEFTREECODE
172:
173: /* Names of tree components.
174: Used for printing out the tree and error messages. */
175: #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
176:
177: char *standard_tree_code_name[] = {
178: #include "tree.def"
179: };
180: #undef DEFTREECODE
181:
182: /* Table indexed by tree code giving a string containing a character
183: classifying the tree code. Possibilities are
184: t, d, s, c, r, e, <, 1 and 2. See tree.def for details. */
185:
186: char **tree_code_type;
187:
188: /* Table indexed by tree code giving number of expression
189: operands beyond the fixed part of the node structure.
190: Not used for types or decls. */
191:
192: int *tree_code_length;
193:
194: /* Table indexed by tree code giving name of tree code, as a string. */
195:
196: char **tree_code_name;
197:
198: /* Statistics-gathering stuff. */
199: typedef enum
200: {
201: d_kind, t_kind, s_kind, r_kind, e_kind, c_kind,
202: id_kind, op_id_kind, perm_list_kind, temp_list_kind,
203: vec_kind, x_kind, lang_decl, lang_type, all_kinds
204: } tree_node_kind;
205: int tree_node_counts[(int)all_kinds];
206: int tree_node_sizes[(int)all_kinds];
207: int id_string_size = 0;
208: char *tree_node_kind_names[] = { "decls", "types", "stmts", "refs", "exprs", "constants",
209: "identifiers", "op_identifiers", "perm_tree_lists", "temp_tree_lists",
210: "vecs", "random kinds", "lang_decl kinds", "lang_type kinds" };
211:
212: /* Hash table for uniquizing IDENTIFIER_NODEs by name. */
213:
214: #define MAX_HASH_TABLE 1009
215: static tree hash_table[MAX_HASH_TABLE]; /* id hash buckets */
216:
217: /* 0 while creating built-in identifiers. */
218: static int do_identifier_warnings;
219:
220: extern char *mode_name[];
221:
222: void gcc_obstack_init ();
223: static tree stabilize_reference_1 ();
224:
225: /* Init the principal obstacks. */
226:
227: void
228: init_obstacks ()
229: {
230: gcc_obstack_init (&obstack_stack_obstack);
231: gcc_obstack_init (&permanent_obstack);
232:
233: gcc_obstack_init (&temporary_obstack);
234: temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
235: gcc_obstack_init (&momentary_obstack);
236: momentary_firstobj = (char *) obstack_alloc (&momentary_obstack, 0);
237: gcc_obstack_init (&maybepermanent_obstack);
238: maybepermanent_firstobj
239: = (char *) obstack_alloc (&maybepermanent_obstack, 0);
240: gcc_obstack_init (&temp_decl_obstack);
241: temp_decl_firstobj = (char *) obstack_alloc (&temp_decl_obstack, 0);
242:
243: function_obstack = &temporary_obstack;
244: function_maybepermanent_obstack = &maybepermanent_obstack;
245: current_obstack = &permanent_obstack;
246: expression_obstack = &permanent_obstack;
247: rtl_obstack = saveable_obstack = &permanent_obstack;
248:
249: /* Init the hash table of identifiers. */
250: bzero (hash_table, sizeof hash_table);
251: }
252:
253: void
254: gcc_obstack_init (obstack)
255: struct obstack *obstack;
256: {
257: /* Let particular systems override the size of a chunk. */
258: #ifndef OBSTACK_CHUNK_SIZE
259: #define OBSTACK_CHUNK_SIZE 0
260: #endif
261: /* Let them override the alloc and free routines too. */
262: #ifndef OBSTACK_CHUNK_ALLOC
263: #define OBSTACK_CHUNK_ALLOC xmalloc
264: #endif
265: #ifndef OBSTACK_CHUNK_FREE
266: #define OBSTACK_CHUNK_FREE free
267: #endif
268: _obstack_begin (obstack, OBSTACK_CHUNK_SIZE, 0,
269: (void *(*) ()) OBSTACK_CHUNK_ALLOC,
270: (void (*) ()) OBSTACK_CHUNK_FREE);
271: }
272:
273: /* Save all variables describing the current status into the structure *P.
274: This is used before starting a nested function. */
275:
276: void
277: save_tree_status (p)
278: struct function *p;
279: {
280: p->all_types_permanent = all_types_permanent;
281: p->momentary_stack = momentary_stack;
282: p->maybepermanent_firstobj = maybepermanent_firstobj;
283: p->momentary_firstobj = momentary_firstobj;
284: p->function_obstack = function_obstack;
285: p->function_maybepermanent_obstack = function_maybepermanent_obstack;
286: p->current_obstack = current_obstack;
287: p->expression_obstack = expression_obstack;
288: p->saveable_obstack = saveable_obstack;
289: p->rtl_obstack = rtl_obstack;
290:
291: function_obstack = (struct obstack *) xmalloc (sizeof (struct obstack));
292: gcc_obstack_init (function_obstack);
293:
294: function_maybepermanent_obstack
295: = (struct obstack *) xmalloc (sizeof (struct obstack));
296: gcc_obstack_init (function_maybepermanent_obstack);
297:
298: current_obstack = &permanent_obstack;
299: expression_obstack = &permanent_obstack;
300: rtl_obstack = saveable_obstack = &permanent_obstack;
301:
302: momentary_firstobj = (char *) obstack_finish (&momentary_obstack);
303: maybepermanent_firstobj
304: = (char *) obstack_finish (function_maybepermanent_obstack);
305: }
306:
307: /* Restore all variables describing the current status from the structure *P.
308: This is used after a nested function. */
309:
310: void
311: restore_tree_status (p)
312: struct function *p;
313: {
314: all_types_permanent = p->all_types_permanent;
315: momentary_stack = p->momentary_stack;
316:
317: obstack_free (&momentary_obstack, momentary_firstobj);
318: obstack_free (function_obstack, 0);
319: obstack_free (function_maybepermanent_obstack, 0);
320: free (function_obstack);
321:
322: momentary_firstobj = p->momentary_firstobj;
323: maybepermanent_firstobj = p->maybepermanent_firstobj;
324: function_obstack = p->function_obstack;
325: function_maybepermanent_obstack = p->function_maybepermanent_obstack;
326: current_obstack = p->current_obstack;
327: expression_obstack = p->expression_obstack;
328: saveable_obstack = p->saveable_obstack;
329: rtl_obstack = p->rtl_obstack;
330: }
331:
332: /* Start allocating on the temporary (per function) obstack.
333: This is done in start_function before parsing the function body,
334: and before each initialization at top level, and to go back
335: to temporary allocation after doing end_temporary_allocation. */
336:
337: void
338: temporary_allocation ()
339: {
340: /* Note that function_obstack at top level points to temporary_obstack.
341: But within a nested function context, it is a separate obstack. */
342: current_obstack = function_obstack;
343: expression_obstack = function_obstack;
344: rtl_obstack = saveable_obstack = function_maybepermanent_obstack;
345: momentary_stack = 0;
346: }
347:
348: /* Start allocating on the permanent obstack but don't
349: free the temporary data. After calling this, call
350: `permanent_allocation' to fully resume permanent allocation status. */
351:
352: void
353: end_temporary_allocation ()
354: {
355: current_obstack = &permanent_obstack;
356: expression_obstack = &permanent_obstack;
357: rtl_obstack = saveable_obstack = &permanent_obstack;
358: }
359:
360: /* Resume allocating on the temporary obstack, undoing
361: effects of `end_temporary_allocation'. */
362:
363: void
364: resume_temporary_allocation ()
365: {
366: current_obstack = function_obstack;
367: expression_obstack = function_obstack;
368: rtl_obstack = saveable_obstack = function_maybepermanent_obstack;
369: }
370:
371: /* While doing temporary allocation, switch to allocating in such a
372: way as to save all nodes if the function is inlined. Call
373: resume_temporary_allocation to go back to ordinary temporary
374: allocation. */
375:
376: void
377: saveable_allocation ()
378: {
379: /* Note that function_obstack at top level points to temporary_obstack.
380: But within a nested function context, it is a separate obstack. */
381: expression_obstack = current_obstack = saveable_obstack;
382: }
383:
384: /* Switch to current obstack CURRENT and maybepermanent obstack SAVEABLE,
385: recording the previously current obstacks on a stack.
386: This does not free any storage in any obstack. */
387:
388: void
389: push_obstacks (current, saveable)
390: struct obstack *current, *saveable;
391: {
392: struct obstack_stack *p
393: = (struct obstack_stack *) obstack_alloc (&obstack_stack_obstack,
394: (sizeof (struct obstack_stack)));
395:
396: p->current = current_obstack;
397: p->saveable = saveable_obstack;
398: p->expression = expression_obstack;
399: p->rtl = rtl_obstack;
400: p->next = obstack_stack;
401: obstack_stack = p;
402:
403: current_obstack = current;
404: expression_obstack = current;
405: rtl_obstack = saveable_obstack = saveable;
406: }
407:
408: /* Save the current set of obstacks, but don't change them. */
409:
410: void
411: push_obstacks_nochange ()
412: {
413: struct obstack_stack *p
414: = (struct obstack_stack *) obstack_alloc (&obstack_stack_obstack,
415: (sizeof (struct obstack_stack)));
416:
417: p->current = current_obstack;
418: p->saveable = saveable_obstack;
419: p->expression = expression_obstack;
420: p->rtl = rtl_obstack;
421: p->next = obstack_stack;
422: obstack_stack = p;
423: }
424:
425: /* Pop the obstack selection stack. */
426:
427: void
428: pop_obstacks ()
429: {
430: struct obstack_stack *p = obstack_stack;
431: obstack_stack = p->next;
432:
433: current_obstack = p->current;
434: saveable_obstack = p->saveable;
435: expression_obstack = p->expression;
436: rtl_obstack = p->rtl;
437:
438: obstack_free (&obstack_stack_obstack, p);
439: }
440:
441: /* Nonzero if temporary allocation is currently in effect.
442: Zero if currently doing permanent allocation. */
443:
444: int
445: allocation_temporary_p ()
446: {
447: return current_obstack != &permanent_obstack;
448: }
449:
450: /* Go back to allocating on the permanent obstack
451: and free everything in the temporary obstack.
452: This is done in finish_function after fully compiling a function. */
453:
454: void
455: permanent_allocation ()
456: {
457: /* Free up previous temporary obstack data */
458: obstack_free (&temporary_obstack, temporary_firstobj);
459: obstack_free (&momentary_obstack, momentary_firstobj);
460: obstack_free (&maybepermanent_obstack, maybepermanent_firstobj);
461: obstack_free (&temp_decl_obstack, temp_decl_firstobj);
462:
463: current_obstack = &permanent_obstack;
464: expression_obstack = &permanent_obstack;
465: rtl_obstack = saveable_obstack = &permanent_obstack;
466: }
467:
468: /* Save permanently everything on the maybepermanent_obstack. */
469:
470: void
471: preserve_data ()
472: {
473: maybepermanent_firstobj
474: = (char *) obstack_alloc (function_maybepermanent_obstack, 0);
475: }
476:
477: void
478: preserve_initializer ()
479: {
480: temporary_firstobj
481: = (char *) obstack_alloc (&temporary_obstack, 0);
482: momentary_firstobj
483: = (char *) obstack_alloc (&momentary_obstack, 0);
484: maybepermanent_firstobj
485: = (char *) obstack_alloc (function_maybepermanent_obstack, 0);
486: }
487:
488: /* Start allocating new rtl in current_obstack.
489: Use resume_temporary_allocation
490: to go back to allocating rtl in saveable_obstack. */
491:
492: void
493: rtl_in_current_obstack ()
494: {
495: rtl_obstack = current_obstack;
496: }
497:
498: /* Temporarily allocate rtl from saveable_obstack. Return 1 if we were
499: previously allocating it from current_obstack. */
500:
501: int
502: rtl_in_saveable_obstack ()
503: {
504: if (rtl_obstack == current_obstack)
505: {
506: rtl_obstack = saveable_obstack;
507: return 1;
508: }
509: else
510: return 0;
511: }
512:
513: /* Allocate SIZE bytes in the current obstack
514: and return a pointer to them.
515: In practice the current obstack is always the temporary one. */
516:
517: char *
518: oballoc (size)
519: int size;
520: {
521: return (char *) obstack_alloc (current_obstack, size);
522: }
523:
524: /* Free the object PTR in the current obstack
525: as well as everything allocated since PTR.
526: In practice the current obstack is always the temporary one. */
527:
528: void
529: obfree (ptr)
530: char *ptr;
531: {
532: obstack_free (current_obstack, ptr);
533: }
534:
535: /* Allocate SIZE bytes in the permanent obstack
536: and return a pointer to them. */
537:
538: char *
539: permalloc (size)
540: long size;
541: {
542: return (char *) obstack_alloc (&permanent_obstack, size);
543: }
544:
545: /* Allocate NELEM items of SIZE bytes in the permanent obstack
546: and return a pointer to them. The storage is cleared before
547: returning the value. */
548:
549: char *
550: perm_calloc (nelem, size)
551: int nelem;
552: long size;
553: {
554: char *rval = (char *) obstack_alloc (&permanent_obstack, nelem * size);
555: bzero (rval, nelem * size);
556: return rval;
557: }
558:
559: /* Allocate SIZE bytes in the saveable obstack
560: and return a pointer to them. */
561:
562: char *
563: savealloc (size)
564: int size;
565: {
566: return (char *) obstack_alloc (saveable_obstack, size);
567: }
568:
569: /* Print out which obstack an object is in. */
570:
571: void
572: debug_obstack (object)
573: char *object;
574: {
575: struct obstack *obstack = NULL;
576: char *obstack_name = NULL;
577: struct function *p;
578:
579: for (p = outer_function_chain; p; p = p->next)
580: {
581: if (_obstack_allocated_p (p->function_obstack, object))
582: {
583: obstack = p->function_obstack;
584: obstack_name = "containing function obstack";
585: }
586: if (_obstack_allocated_p (p->function_maybepermanent_obstack, object))
587: {
588: obstack = p->function_maybepermanent_obstack;
589: obstack_name = "containing function maybepermanent obstack";
590: }
591: }
592:
593: if (_obstack_allocated_p (&obstack_stack_obstack, object))
594: {
595: obstack = &obstack_stack_obstack;
596: obstack_name = "obstack_stack_obstack";
597: }
598: else if (_obstack_allocated_p (function_obstack, object))
599: {
600: obstack = function_obstack;
601: obstack_name = "function obstack";
602: }
603: else if (_obstack_allocated_p (&permanent_obstack, object))
604: {
605: obstack = &permanent_obstack;
606: obstack_name = "permanent_obstack";
607: }
608: else if (_obstack_allocated_p (&momentary_obstack, object))
609: {
610: obstack = &momentary_obstack;
611: obstack_name = "momentary_obstack";
612: }
613: else if (_obstack_allocated_p (function_maybepermanent_obstack, object))
614: {
615: obstack = function_maybepermanent_obstack;
616: obstack_name = "function maybepermanent obstack";
617: }
618: else if (_obstack_allocated_p (&temp_decl_obstack, object))
619: {
620: obstack = &temp_decl_obstack;
621: obstack_name = "temp_decl_obstack";
622: }
623:
624: /* Check to see if the object is in the free area of the obstack. */
625: if (obstack != NULL)
626: {
627: if (object >= obstack->next_free
628: && object < obstack->chunk_limit)
629: fprintf (stderr, "object in free portion of obstack %s.\n",
630: obstack_name);
631: else
632: fprintf (stderr, "object allocated from %s.\n", obstack_name);
633: }
634: else
635: fprintf (stderr, "object not allocated from any obstack.\n");
636: }
637:
638: /* Return 1 if OBJ is in the permanent obstack.
639: This is slow, and should be used only for debugging.
640: Use TREE_PERMANENT for other purposes. */
641:
642: int
643: object_permanent_p (obj)
644: tree obj;
645: {
646: return _obstack_allocated_p (&permanent_obstack, obj);
647: }
648:
649: /* Start a level of momentary allocation.
650: In C, each compound statement has its own level
651: and that level is freed at the end of each statement.
652: All expression nodes are allocated in the momentary allocation level. */
653:
654: void
655: push_momentary ()
656: {
657: struct momentary_level *tem
658: = (struct momentary_level *) obstack_alloc (&momentary_obstack,
659: sizeof (struct momentary_level));
660: tem->prev = momentary_stack;
661: tem->base = (char *) obstack_base (&momentary_obstack);
662: tem->obstack = expression_obstack;
663: momentary_stack = tem;
664: expression_obstack = &momentary_obstack;
665: }
666:
667: /* Free all the storage in the current momentary-allocation level.
668: In C, this happens at the end of each statement. */
669:
670: void
671: clear_momentary ()
672: {
673: obstack_free (&momentary_obstack, momentary_stack->base);
674: }
675:
676: /* Discard a level of momentary allocation.
677: In C, this happens at the end of each compound statement.
678: Restore the status of expression node allocation
679: that was in effect before this level was created. */
680:
681: void
682: pop_momentary ()
683: {
684: struct momentary_level *tem = momentary_stack;
685: momentary_stack = tem->prev;
686: expression_obstack = tem->obstack;
687: obstack_free (&momentary_obstack, tem);
688: }
689:
690: /* Call when starting to parse a declaration:
691: make expressions in the declaration last the length of the function.
692: Returns an argument that should be passed to resume_momentary later. */
693:
694: int
695: suspend_momentary ()
696: {
697: register int tem = expression_obstack == &momentary_obstack;
698: expression_obstack = saveable_obstack;
699: return tem;
700: }
701:
702: /* Call when finished parsing a declaration:
703: restore the treatment of node-allocation that was
704: in effect before the suspension.
705: YES should be the value previously returned by suspend_momentary. */
706:
707: void
708: resume_momentary (yes)
709: int yes;
710: {
711: if (yes)
712: expression_obstack = &momentary_obstack;
713: }
714:
715: /* Init the tables indexed by tree code.
716: Note that languages can add to these tables to define their own codes. */
717:
718: void
719: init_tree_codes ()
720: {
721: tree_code_type = (char **) xmalloc (sizeof (standard_tree_code_type));
722: tree_code_length = (int *) xmalloc (sizeof (standard_tree_code_length));
723: tree_code_name = (char **) xmalloc (sizeof (standard_tree_code_name));
724: bcopy (standard_tree_code_type, tree_code_type,
725: sizeof (standard_tree_code_type));
726: bcopy (standard_tree_code_length, tree_code_length,
727: sizeof (standard_tree_code_length));
728: bcopy (standard_tree_code_name, tree_code_name,
729: sizeof (standard_tree_code_name));
730: }
731:
732: /* Return a newly allocated node of code CODE.
733: Initialize the node's unique id and its TREE_PERMANENT flag.
734: For decl and type nodes, some other fields are initialized.
735: The rest of the node is initialized to zero.
736:
737: Achoo! I got a code in the node. */
738:
739: tree
740: make_node (code)
741: enum tree_code code;
742: {
743: register tree t;
744: register int type = TREE_CODE_CLASS (code);
745: register int length;
746: register struct obstack *obstack = current_obstack;
747: register int i;
748: register tree_node_kind kind;
749:
750: switch (type)
751: {
752: case 'd': /* A decl node */
753: #ifdef GATHER_STATISTICS
754: kind = d_kind;
755: #endif
756: length = sizeof (struct tree_decl);
757: /* All decls in an inline function need to be saved. */
758: if (obstack != &permanent_obstack)
759: obstack = saveable_obstack;
760: /* PARM_DECLs always go on saveable_obstack, not permanent,
761: even though we may make them before the function turns
762: on temporary allocation. */
763: else if (code == PARM_DECL)
764: obstack = function_maybepermanent_obstack;
765: break;
766:
767: case 't': /* a type node */
768: #ifdef GATHER_STATISTICS
769: kind = t_kind;
770: #endif
771: length = sizeof (struct tree_type);
772: /* All data types are put where we can preserve them if nec. */
773: if (obstack != &permanent_obstack)
774: obstack = all_types_permanent ? &permanent_obstack : saveable_obstack;
775: break;
776:
777: case 's': /* an expression with side effects */
778: #ifdef GATHER_STATISTICS
779: kind = s_kind;
780: goto usual_kind;
781: #endif
782: case 'r': /* a reference */
783: #ifdef GATHER_STATISTICS
784: kind = r_kind;
785: goto usual_kind;
786: #endif
787: case 'e': /* an expression */
788: case '<': /* a comparison expression */
789: case '1': /* a unary arithmetic expression */
790: case '2': /* a binary arithmetic expression */
791: #ifdef GATHER_STATISTICS
792: kind = e_kind;
793: usual_kind:
794: #endif
795: obstack = expression_obstack;
796: /* All BLOCK nodes are put where we can preserve them if nec.
797: Also their potential controllers. */
798: if ((code == BLOCK || code == BIND_EXPR)
799: && obstack != &permanent_obstack)
800: obstack = saveable_obstack;
801: length = sizeof (struct tree_exp)
802: + (tree_code_length[(int) code] - 1) * sizeof (char *);
803: break;
804:
805: case 'c': /* a constant */
806: #ifdef GATHER_STATISTICS
807: kind = c_kind;
808: #endif
809: obstack = expression_obstack;
810: /* We can't use tree_code_length for this, since the number of words
811: is machine-dependent due to varying alignment of `double'. */
812: if (code == REAL_CST)
813: {
814: length = sizeof (struct tree_real_cst);
815: break;
816: }
817:
818: case 'x': /* something random, like an identifier. */
819: #ifdef GATHER_STATISTICS
820: if (code == IDENTIFIER_NODE)
821: kind = id_kind;
822: else if (code == OP_IDENTIFIER)
823: kind = op_id_kind;
824: else if (code == TREE_VEC)
825: kind = vec_kind;
826: else
827: kind = x_kind;
828: #endif
829: length = sizeof (struct tree_common)
830: + tree_code_length[(int) code] * sizeof (char *);
831: /* Identifier nodes are always permanent since they are
832: unique in a compiler run. */
833: if (code == IDENTIFIER_NODE) obstack = &permanent_obstack;
834: }
835:
836: t = (tree) obstack_alloc (obstack, length);
837:
838: #ifdef GATHER_STATISTICS
839: tree_node_counts[(int)kind]++;
840: tree_node_sizes[(int)kind] += length;
841: #endif
842:
843: TREE_TYPE (t) = 0;
844: TREE_CHAIN (t) = 0;
845: for (i = (length / sizeof (int)) - 1;
846: i >= sizeof (struct tree_common) / sizeof (int) - 1;
847: i--)
848: ((int *) t)[i] = 0;
849:
850: TREE_SET_CODE (t, code);
851: if (obstack == &permanent_obstack)
852: TREE_PERMANENT (t) = 1;
853:
854: switch (type)
855: {
856: case 's':
857: TREE_SIDE_EFFECTS (t) = 1;
858: TREE_TYPE (t) = void_type_node;
859: break;
860:
861: case 'd':
1.1.1.3 ! root 862: if (code != FUNCTION_DECL)
! 863: DECL_ALIGN (t) = 1;
1.1 root 864: DECL_SOURCE_LINE (t) = lineno;
865: DECL_SOURCE_FILE (t) = (input_filename) ? input_filename : "<built-in>";
866: break;
867:
868: case 't':
869: {
870: static unsigned next_type_uid = 1;
871:
872: TYPE_UID (t) = next_type_uid++;
873: }
874: TYPE_ALIGN (t) = 1;
875: TYPE_MAIN_VARIANT (t) = t;
876: break;
877:
878: case 'c':
879: TREE_CONSTANT (t) = 1;
880: break;
881: }
882:
883: return t;
884: }
885:
886: /* Return a new node with the same contents as NODE
887: except that its TREE_CHAIN is zero and it has a fresh uid. */
888:
889: tree
890: copy_node (node)
891: tree node;
892: {
893: register tree t;
894: register enum tree_code code = TREE_CODE (node);
895: register int length;
896: register int i;
897:
898: switch (TREE_CODE_CLASS (code))
899: {
900: case 'd': /* A decl node */
901: length = sizeof (struct tree_decl);
902: break;
903:
904: case 't': /* a type node */
905: length = sizeof (struct tree_type);
906: break;
907:
908: case 'r': /* a reference */
909: case 'e': /* a expression */
910: case 's': /* an expression with side effects */
911: case '<': /* a comparison expression */
912: case '1': /* a unary arithmetic expression */
913: case '2': /* a binary arithmetic expression */
914: length = sizeof (struct tree_exp)
915: + (tree_code_length[(int) code] - 1) * sizeof (char *);
916: break;
917:
918: case 'c': /* a constant */
919: /* We can't use tree_code_length for this, since the number of words
920: is machine-dependent due to varying alignment of `double'. */
921: if (code == REAL_CST)
922: {
923: length = sizeof (struct tree_real_cst);
924: break;
925: }
926:
927: case 'x': /* something random, like an identifier. */
928: length = sizeof (struct tree_common)
929: + tree_code_length[(int) code] * sizeof (char *);
930: if (code == TREE_VEC)
931: length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *);
932: }
933:
934: t = (tree) obstack_alloc (current_obstack, length);
935:
936: for (i = ((length + sizeof (int) - 1) / sizeof (int)) - 1;
937: i >= 0;
938: i--)
939: ((int *) t)[i] = ((int *) node)[i];
940:
941: TREE_CHAIN (t) = 0;
942:
943: TREE_PERMANENT (t) = (current_obstack == &permanent_obstack);
944:
945: return t;
946: }
947:
948: /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
949: For example, this can copy a list made of TREE_LIST nodes. */
950:
951: tree
952: copy_list (list)
953: tree list;
954: {
955: tree head;
956: register tree prev, next;
957:
958: if (list == 0)
959: return 0;
960:
961: head = prev = copy_node (list);
962: next = TREE_CHAIN (list);
963: while (next)
964: {
965: TREE_CHAIN (prev) = copy_node (next);
966: prev = TREE_CHAIN (prev);
967: next = TREE_CHAIN (next);
968: }
969: return head;
970: }
971:
972: #define HASHBITS 30
973:
974: /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
975: If an identifier with that name has previously been referred to,
976: the same node is returned this time. */
977:
978: tree
979: get_identifier (text)
980: register char *text;
981: {
982: register int hi;
983: register int i;
984: register tree idp;
985: register int len, hash_len;
986:
987: /* Compute length of text in len. */
988: for (len = 0; text[len]; len++);
989:
990: /* Decide how much of that length to hash on */
991: hash_len = len;
992: if (warn_id_clash && len > id_clash_len)
993: hash_len = id_clash_len;
994:
995: /* Compute hash code */
996: hi = hash_len * 613 + (unsigned)text[0];
997: for (i = 1; i < hash_len; i += 2)
998: hi = ((hi * 613) + (unsigned)(text[i]));
999:
1000: hi &= (1 << HASHBITS) - 1;
1001: hi %= MAX_HASH_TABLE;
1002:
1003: /* Search table for identifier */
1004: for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
1005: if (IDENTIFIER_LENGTH (idp) == len
1006: && IDENTIFIER_POINTER (idp)[0] == text[0]
1007: && !bcmp (IDENTIFIER_POINTER (idp), text, len))
1008: return idp; /* <-- return if found */
1009:
1010: /* Not found; optionally warn about a similar identifier */
1011: if (warn_id_clash && do_identifier_warnings && len >= id_clash_len)
1012: for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
1013: if (!strncmp (IDENTIFIER_POINTER (idp), text, id_clash_len))
1014: {
1015: warning ("`%s' and `%s' identical in first %d characters",
1016: IDENTIFIER_POINTER (idp), text, id_clash_len);
1017: break;
1018: }
1019:
1020: if (tree_code_length[(int) IDENTIFIER_NODE] < 0)
1021: abort (); /* set_identifier_size hasn't been called. */
1022:
1023: /* Not found, create one, add to chain */
1024: idp = make_node (IDENTIFIER_NODE);
1025: IDENTIFIER_LENGTH (idp) = len;
1026: #ifdef GATHER_STATISTICS
1027: id_string_size += len;
1028: #endif
1029:
1030: IDENTIFIER_POINTER (idp) = obstack_copy0 (&permanent_obstack, text, len);
1031:
1032: TREE_CHAIN (idp) = hash_table[hi];
1033: hash_table[hi] = idp;
1034: return idp; /* <-- return if created */
1035: }
1036:
1037: /* Enable warnings on similar identifiers (if requested).
1038: Done after the built-in identifiers are created. */
1039:
1040: void
1041: start_identifier_warnings ()
1042: {
1043: do_identifier_warnings = 1;
1044: }
1045:
1046: /* Record the size of an identifier node for the language in use.
1047: SIZE is the total size in bytes.
1048: This is called by the language-specific files. This must be
1049: called before allocating any identifiers. */
1050:
1051: void
1052: set_identifier_size (size)
1053: int size;
1054: {
1055: tree_code_length[(int) IDENTIFIER_NODE]
1056: = (size - sizeof (struct tree_common)) / sizeof (tree);
1057: }
1058:
1059: /* Return a newly constructed INTEGER_CST node whose constant value
1060: is specified by the two ints LOW and HI.
1061: The TREE_TYPE is set to `int'. */
1062:
1063: tree
1064: build_int_2 (low, hi)
1065: int low, hi;
1066: {
1067: register tree t = make_node (INTEGER_CST);
1068: TREE_INT_CST_LOW (t) = low;
1069: TREE_INT_CST_HIGH (t) = hi;
1070: TREE_TYPE (t) = integer_type_node;
1071: return t;
1072: }
1073:
1074: /* Return a new REAL_CST node whose type is TYPE and value is D. */
1075:
1076: tree
1077: build_real (type, d)
1078: tree type;
1079: REAL_VALUE_TYPE d;
1080: {
1081: tree v;
1082:
1083: /* Check for valid float value for this type on this target machine;
1084: if not, can print error message and store a valid value in D. */
1085: #ifdef CHECK_FLOAT_VALUE
1086: CHECK_FLOAT_VALUE (TYPE_MODE (type), d);
1087: #endif
1088:
1089: v = make_node (REAL_CST);
1090: TREE_TYPE (v) = type;
1091: TREE_REAL_CST (v) = d;
1092: return v;
1093: }
1094:
1095: /* Return a new REAL_CST node whose type is TYPE
1096: and whose value is the integer value of the INTEGER_CST node I. */
1097:
1098: #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1099:
1100: REAL_VALUE_TYPE
1101: real_value_from_int_cst (i)
1102: tree i;
1103: {
1104: REAL_VALUE_TYPE d;
1105: #ifdef REAL_ARITHMETIC
1106: REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i));
1107: #else /* not REAL_ARITHMETIC */
1108: if (TREE_INT_CST_HIGH (i) < 0)
1109: {
1110: d = (double) (~ TREE_INT_CST_HIGH (i));
1111: d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
1112: * (double) (1 << (HOST_BITS_PER_INT / 2)));
1113: d += (double) (unsigned) (~ TREE_INT_CST_LOW (i));
1114: d = (- d - 1.0);
1115: }
1116: else
1117: {
1118: d = (double) TREE_INT_CST_HIGH (i);
1119: d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
1120: * (double) (1 << (HOST_BITS_PER_INT / 2)));
1121: d += (double) (unsigned) TREE_INT_CST_LOW (i);
1122: }
1123: #endif /* not REAL_ARITHMETIC */
1124: return d;
1125: }
1126:
1127: /* This function can't be implemented if we can't do arithmetic
1128: on the float representation. */
1129:
1130: tree
1131: build_real_from_int_cst (type, i)
1132: tree type;
1133: tree i;
1134: {
1135: tree v;
1136: REAL_VALUE_TYPE d;
1137:
1138: v = make_node (REAL_CST);
1139: TREE_TYPE (v) = type;
1140:
1141: d = real_value_from_int_cst (i);
1142: /* Check for valid float value for this type on this target machine;
1143: if not, can print error message and store a valid value in D. */
1144: #ifdef CHECK_FLOAT_VALUE
1145: CHECK_FLOAT_VALUE (TYPE_MODE (type), d);
1146: #endif
1147:
1148: TREE_REAL_CST (v) = d;
1149: return v;
1150: }
1151:
1152: #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1153:
1154: /* Return a newly constructed STRING_CST node whose value is
1155: the LEN characters at STR.
1156: The TREE_TYPE is not initialized. */
1157:
1158: tree
1159: build_string (len, str)
1160: int len;
1161: char *str;
1162: {
1163: register tree s = make_node (STRING_CST);
1164: TREE_STRING_LENGTH (s) = len;
1165: TREE_STRING_POINTER (s) = obstack_copy0 (saveable_obstack, str, len);
1166: return s;
1167: }
1168:
1169: /* Return a newly constructed COMPLEX_CST node whose value is
1170: specified by the real and imaginary parts REAL and IMAG.
1171: Both REAL and IMAG should be constant nodes.
1172: The TREE_TYPE is not initialized. */
1173:
1174: tree
1175: build_complex (real, imag)
1176: tree real, imag;
1177: {
1178: register tree t = make_node (COMPLEX_CST);
1179: TREE_REALPART (t) = real;
1180: TREE_IMAGPART (t) = imag;
1181: return t;
1182: }
1183:
1184: /* Build a newly constructed TREE_VEC node of length LEN. */
1185: tree
1186: make_tree_vec (len)
1187: int len;
1188: {
1189: register tree t;
1190: register int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
1191: register struct obstack *obstack = current_obstack;
1192: register int i;
1193:
1194: #ifdef GATHER_STATISTICS
1195: tree_node_counts[(int)vec_kind]++;
1196: tree_node_sizes[(int)vec_kind] += length;
1197: #endif
1198:
1199: t = (tree) obstack_alloc (obstack, length);
1200:
1201: TREE_TYPE (t) = 0;
1202: TREE_CHAIN (t) = 0;
1203: for (i = (length / sizeof (int)) - 1;
1204: i >= sizeof (struct tree_common) / sizeof (int) - 1;
1205: i--)
1206: ((int *) t)[i] = 0;
1207: TREE_SET_CODE (t, TREE_VEC);
1208: TREE_VEC_LENGTH (t) = len;
1209: if (obstack == &permanent_obstack)
1210: TREE_PERMANENT (t) = 1;
1211:
1212: return t;
1213: }
1214:
1215: /* Return 1 if EXPR is the integer constant zero. */
1216:
1217: int
1218: integer_zerop (expr)
1219: tree expr;
1220: {
1221: while (TREE_CODE (expr) == NON_LVALUE_EXPR)
1222: expr = TREE_OPERAND (expr, 0);
1223:
1224: return (TREE_CODE (expr) == INTEGER_CST
1225: && TREE_INT_CST_LOW (expr) == 0
1226: && TREE_INT_CST_HIGH (expr) == 0);
1227: }
1228:
1229: /* Return 1 if EXPR is the integer constant one. */
1230:
1231: int
1232: integer_onep (expr)
1233: tree expr;
1234: {
1235: while (TREE_CODE (expr) == NON_LVALUE_EXPR)
1236: expr = TREE_OPERAND (expr, 0);
1237:
1238: return (TREE_CODE (expr) == INTEGER_CST
1239: && TREE_INT_CST_LOW (expr) == 1
1240: && TREE_INT_CST_HIGH (expr) == 0);
1241: }
1242:
1243: /* Return 1 if EXPR is an integer containing all 1's
1244: in as much precision as it contains. */
1245:
1246: int
1247: integer_all_onesp (expr)
1248: tree expr;
1249: {
1250: register int prec;
1251: register int uns;
1252:
1253: while (TREE_CODE (expr) == NON_LVALUE_EXPR)
1254: expr = TREE_OPERAND (expr, 0);
1255:
1256: if (TREE_CODE (expr) != INTEGER_CST)
1257: return 0;
1258:
1259: uns = TREE_UNSIGNED (TREE_TYPE (expr));
1260: if (!uns)
1261: return TREE_INT_CST_LOW (expr) == -1 && TREE_INT_CST_HIGH (expr) == -1;
1262:
1263: prec = TYPE_PRECISION (TREE_TYPE (expr));
1264: if (prec >= HOST_BITS_PER_INT)
1265: {
1266: int high_value, shift_amount;
1267:
1268: shift_amount = prec - HOST_BITS_PER_INT;
1269:
1270: if (shift_amount > HOST_BITS_PER_INT)
1271: /* Can not handle precisions greater than twice the host int size. */
1272: abort ();
1273: else if (shift_amount == HOST_BITS_PER_INT)
1274: /* Shifting by the host word size is undefined according to the ANSI
1275: standard, so we must handle this as a special case. */
1276: high_value = -1;
1277: else
1278: high_value = (1 << shift_amount) - 1;
1279:
1280: return TREE_INT_CST_LOW (expr) == -1
1281: && TREE_INT_CST_HIGH (expr) == high_value;
1282: }
1283: else
1284: return TREE_INT_CST_LOW (expr) == (1 << prec) - 1;
1285: }
1286:
1287: /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1288: one bit on). */
1289:
1290: int
1291: integer_pow2p (expr)
1292: tree expr;
1293: {
1294: int high, low;
1295:
1296: while (TREE_CODE (expr) == NON_LVALUE_EXPR)
1297: expr = TREE_OPERAND (expr, 0);
1298:
1299: if (TREE_CODE (expr) != INTEGER_CST)
1300: return 0;
1301:
1302: high = TREE_INT_CST_HIGH (expr);
1303: low = TREE_INT_CST_LOW (expr);
1304:
1305: if (high == 0 && low == 0)
1306: return 0;
1307:
1308: return ((high == 0 && (low & (low - 1)) == 0)
1309: || (low == 0 && (high & (high - 1)) == 0));
1310: }
1311:
1312: /* Return 1 if EXPR is the real constant zero. */
1313:
1314: int
1315: real_zerop (expr)
1316: tree expr;
1317: {
1318: while (TREE_CODE (expr) == NON_LVALUE_EXPR)
1319: expr = TREE_OPERAND (expr, 0);
1320:
1321: return (TREE_CODE (expr) == REAL_CST
1322: && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0));
1323: }
1324:
1325: /* Return 1 if EXPR is the real constant one. */
1326:
1327: int
1328: real_onep (expr)
1329: tree expr;
1330: {
1331: while (TREE_CODE (expr) == NON_LVALUE_EXPR)
1332: expr = TREE_OPERAND (expr, 0);
1333:
1334: return (TREE_CODE (expr) == REAL_CST
1335: && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1));
1336: }
1337:
1338: /* Return 1 if EXPR is the real constant two. */
1339:
1340: int
1341: real_twop (expr)
1342: tree expr;
1343: {
1344: while (TREE_CODE (expr) == NON_LVALUE_EXPR)
1345: expr = TREE_OPERAND (expr, 0);
1346:
1347: return (TREE_CODE (expr) == REAL_CST
1348: && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2));
1349: }
1350:
1351: /* Nonzero if EXP is a constant or a cast of a constant. */
1352:
1353: int
1354: really_constant_p (exp)
1355: tree exp;
1356: {
1357: while (TREE_CODE (exp) == NOP_EXPR
1358: || TREE_CODE (exp) == CONVERT_EXPR
1359: || TREE_CODE (exp) == NON_LVALUE_EXPR)
1360: exp = TREE_OPERAND (exp, 0);
1361: return TREE_CONSTANT (exp);
1362: }
1363:
1364: /* Return first list element whose TREE_VALUE is ELEM.
1365: Return 0 if ELEM is not it LIST. */
1366:
1367: tree
1368: value_member (elem, list)
1369: tree elem, list;
1370: {
1371: while (list)
1372: {
1373: if (elem == TREE_VALUE (list))
1374: return list;
1375: list = TREE_CHAIN (list);
1376: }
1377: return NULL_TREE;
1378: }
1379:
1380: /* Return first list element whose TREE_PURPOSE is ELEM.
1381: Return 0 if ELEM is not it LIST. */
1382:
1383: tree
1384: purpose_member (elem, list)
1385: tree elem, list;
1386: {
1387: while (list)
1388: {
1389: if (elem == TREE_PURPOSE (list))
1390: return list;
1391: list = TREE_CHAIN (list);
1392: }
1393: return NULL_TREE;
1394: }
1395:
1396: /* Return first list element whose BINFO_TYPE is ELEM.
1397: Return 0 if ELEM is not it LIST. */
1398:
1399: tree
1400: binfo_member (elem, list)
1401: tree elem, list;
1402: {
1403: while (list)
1404: {
1405: if (elem == BINFO_TYPE (list))
1406: return list;
1407: list = TREE_CHAIN (list);
1408: }
1409: return NULL_TREE;
1410: }
1411:
1412: /* Return nonzero if ELEM is part of the chain CHAIN. */
1413:
1414: int
1415: chain_member (elem, chain)
1416: tree elem, chain;
1417: {
1418: while (chain)
1419: {
1420: if (elem == chain)
1421: return 1;
1422: chain = TREE_CHAIN (chain);
1423: }
1424:
1425: return 0;
1426: }
1427:
1428: /* Return the length of a chain of nodes chained through TREE_CHAIN.
1429: We expect a null pointer to mark the end of the chain.
1430: This is the Lisp primitive `length'. */
1431:
1432: int
1433: list_length (t)
1434: tree t;
1435: {
1436: register tree tail;
1437: register int len = 0;
1438:
1439: for (tail = t; tail; tail = TREE_CHAIN (tail))
1440: len++;
1441:
1442: return len;
1443: }
1444:
1445: /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1446: by modifying the last node in chain 1 to point to chain 2.
1447: This is the Lisp primitive `nconc'. */
1448:
1449: tree
1450: chainon (op1, op2)
1451: tree op1, op2;
1452: {
1453: tree t;
1454:
1455: if (op1)
1456: {
1457: for (t = op1; TREE_CHAIN (t); t = TREE_CHAIN (t))
1458: if (t == op2) abort (); /* Circularity being created */
1459: TREE_CHAIN (t) = op2;
1460: return op1;
1461: }
1462: else return op2;
1463: }
1464:
1465: /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
1466:
1467: tree
1468: tree_last (chain)
1469: register tree chain;
1470: {
1471: register tree next;
1472: if (chain)
1473: while (next = TREE_CHAIN (chain))
1474: chain = next;
1475: return chain;
1476: }
1477:
1478: /* Reverse the order of elements in the chain T,
1479: and return the new head of the chain (old last element). */
1480:
1481: tree
1482: nreverse (t)
1483: tree t;
1484: {
1485: register tree prev = 0, decl, next;
1486: for (decl = t; decl; decl = next)
1487: {
1488: next = TREE_CHAIN (decl);
1489: TREE_CHAIN (decl) = prev;
1490: prev = decl;
1491: }
1492: return prev;
1493: }
1494:
1495: /* Given a chain CHAIN of tree nodes,
1496: construct and return a list of those nodes. */
1497:
1498: tree
1499: listify (chain)
1500: tree chain;
1501: {
1502: tree result = NULL_TREE;
1503: tree in_tail = chain;
1504: tree out_tail = NULL_TREE;
1505:
1506: while (in_tail)
1507: {
1508: tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE);
1509: if (out_tail)
1510: TREE_CHAIN (out_tail) = next;
1511: else
1512: result = next;
1513: out_tail = next;
1514: in_tail = TREE_CHAIN (in_tail);
1515: }
1516:
1517: return result;
1518: }
1519:
1520: /* Return a newly created TREE_LIST node whose
1521: purpose and value fields are PARM and VALUE. */
1522:
1523: tree
1524: build_tree_list (parm, value)
1525: tree parm, value;
1526: {
1527: register tree t = make_node (TREE_LIST);
1528: TREE_PURPOSE (t) = parm;
1529: TREE_VALUE (t) = value;
1530: return t;
1531: }
1532:
1533: /* Similar, but build on the temp_decl_obstack. */
1534:
1535: tree
1536: build_decl_list (parm, value)
1537: tree parm, value;
1538: {
1539: register tree node;
1540: register struct obstack *ambient_obstack = current_obstack;
1541: current_obstack = &temp_decl_obstack;
1542: node = build_tree_list (parm, value);
1543: current_obstack = ambient_obstack;
1544: return node;
1545: }
1546:
1547: /* Return a newly created TREE_LIST node whose
1548: purpose and value fields are PARM and VALUE
1549: and whose TREE_CHAIN is CHAIN. */
1550:
1551: tree
1552: tree_cons (purpose, value, chain)
1553: tree purpose, value, chain;
1554: {
1555: #if 0
1556: register tree node = make_node (TREE_LIST);
1557: #else
1558: register int i;
1559: register tree node = (tree) obstack_alloc (current_obstack, sizeof (struct tree_list));
1560: #ifdef GATHER_STATISTICS
1561: tree_node_counts[(int)x_kind]++;
1562: tree_node_sizes[(int)x_kind] += sizeof (struct tree_list);
1563: #endif
1564:
1565: ((int *)node)[(sizeof (struct tree_common)/sizeof (int)) - 1] = 0;
1566: TREE_SET_CODE (node, TREE_LIST);
1567: if (current_obstack == &permanent_obstack)
1568: TREE_PERMANENT (node) = 1;
1569: TREE_TYPE (node) = 0;
1570: #endif
1571:
1572: TREE_CHAIN (node) = chain;
1573: TREE_PURPOSE (node) = purpose;
1574: TREE_VALUE (node) = value;
1575: return node;
1576: }
1577:
1578: /* Similar, but build on the temp_decl_obstack. */
1579:
1580: tree
1581: decl_tree_cons (purpose, value, chain)
1582: tree purpose, value, chain;
1583: {
1584: register tree node;
1585: register struct obstack *ambient_obstack = current_obstack;
1586: current_obstack = &temp_decl_obstack;
1587: node = tree_cons (purpose, value, chain);
1588: current_obstack = ambient_obstack;
1589: return node;
1590: }
1591:
1592: /* Same as `tree_cons' but make a permanent object. */
1593:
1594: tree
1595: perm_tree_cons (purpose, value, chain)
1596: tree purpose, value, chain;
1597: {
1598: register tree node;
1599: register struct obstack *ambient_obstack = current_obstack;
1600: current_obstack = &permanent_obstack;
1601:
1602: node = tree_cons (purpose, value, chain);
1603: current_obstack = ambient_obstack;
1604: return node;
1605: }
1606:
1607: /* Same as `tree_cons', but make this node temporary, regardless. */
1608:
1609: tree
1610: temp_tree_cons (purpose, value, chain)
1611: tree purpose, value, chain;
1612: {
1613: register tree node;
1614: register struct obstack *ambient_obstack = current_obstack;
1615: current_obstack = &temporary_obstack;
1616:
1617: node = tree_cons (purpose, value, chain);
1618: current_obstack = ambient_obstack;
1619: return node;
1620: }
1621:
1622: /* Same as `tree_cons', but save this node if the function's RTL is saved. */
1623:
1624: tree
1625: saveable_tree_cons (purpose, value, chain)
1626: tree purpose, value, chain;
1627: {
1628: register tree node;
1629: register struct obstack *ambient_obstack = current_obstack;
1630: current_obstack = saveable_obstack;
1631:
1632: node = tree_cons (purpose, value, chain);
1633: current_obstack = ambient_obstack;
1634: return node;
1635: }
1636:
1637: /* Return the size nominally occupied by an object of type TYPE
1638: when it resides in memory. The value is measured in units of bytes,
1639: and its data type is that normally used for type sizes
1640: (which is the first type created by make_signed_type or
1641: make_unsigned_type). */
1642:
1643: tree
1644: size_in_bytes (type)
1645: tree type;
1646: {
1647: if (type == error_mark_node)
1648: return integer_zero_node;
1649: type = TYPE_MAIN_VARIANT (type);
1650: if (TYPE_SIZE (type) == 0)
1651: {
1652: incomplete_type_error (0, type);
1653: return integer_zero_node;
1654: }
1655: return size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
1656: size_int (BITS_PER_UNIT));
1657: }
1658:
1659: /* Return the size of TYPE (in bytes) as an integer,
1660: or return -1 if the size can vary. */
1661:
1662: int
1663: int_size_in_bytes (type)
1664: tree type;
1665: {
1666: int size;
1667: if (type == error_mark_node)
1668: return 0;
1669: type = TYPE_MAIN_VARIANT (type);
1670: if (TYPE_SIZE (type) == 0)
1671: return -1;
1672: if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1673: return -1;
1674: size = TREE_INT_CST_LOW (TYPE_SIZE (type));
1675: return (size + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
1676: }
1677:
1678: /* Return, as an INTEGER_CST node, the number of elements for
1.1.1.2 root 1679: TYPE (which is an ARRAY_TYPE) minus one.
1680: This counts only elements of the top array. */
1.1 root 1681:
1682: tree
1683: array_type_nelts (type)
1684: tree type;
1685: {
1686: tree index_type = TYPE_DOMAIN (type);
1687: return (tree_int_cst_equal (TYPE_MIN_VALUE (index_type), integer_zero_node)
1688: ? TYPE_MAX_VALUE (index_type)
1689: : fold (build (MINUS_EXPR, integer_type_node,
1690: TYPE_MAX_VALUE (index_type),
1691: TYPE_MIN_VALUE (index_type))));
1692: }
1693:
1694: /* Return nonzero if arg is static -- a reference to an object in
1695: static storage. This is not the same as the C meaning of `static'. */
1696:
1697: int
1698: staticp (arg)
1699: tree arg;
1700: {
1701: switch (TREE_CODE (arg))
1702: {
1703: case VAR_DECL:
1704: case FUNCTION_DECL:
1705: case CONSTRUCTOR:
1706: return TREE_STATIC (arg) || TREE_EXTERNAL (arg);
1707:
1708: case STRING_CST:
1709: return 1;
1710:
1711: case COMPONENT_REF:
1712: case BIT_FIELD_REF:
1713: return staticp (TREE_OPERAND (arg, 0));
1714:
1715: case INDIRECT_REF:
1716: return TREE_CONSTANT (TREE_OPERAND (arg, 0));
1717:
1718: case ARRAY_REF:
1719: if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
1720: && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
1721: return staticp (TREE_OPERAND (arg, 0));
1722: }
1723:
1724: return 0;
1725: }
1726:
1727: /* This should be applied to any node which may be used in more than one place,
1728: but must be evaluated only once. Normally, the code generator would
1729: reevaluate the node each time; this forces it to compute it once and save
1730: the result. This is done by encapsulating the node in a SAVE_EXPR. */
1731:
1732: tree
1733: save_expr (expr)
1734: tree expr;
1735: {
1736: register tree t = fold (expr);
1737:
1738: /* We don't care about whether this can be used as an lvalue in this
1739: context. */
1740: while (TREE_CODE (t) == NON_LVALUE_EXPR)
1741: t = TREE_OPERAND (t, 0);
1742:
1743: /* If the tree evaluates to a constant, then we don't want to hide that
1744: fact (i.e. this allows further folding, and direct checks for constants).
1.1.1.3 ! root 1745: However, a read-only object that has side effects cannot be bypassed.
1.1 root 1746: Since it is no problem to reevaluate literals, we just return the
1747: literal node. */
1748:
1.1.1.3 ! root 1749: if (TREE_CONSTANT (t) || (TREE_READONLY (t) && ! TREE_SIDE_EFFECTS (t))
! 1750: || TREE_CODE (t) == SAVE_EXPR)
1.1 root 1751: return t;
1752:
1753: t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL);
1754:
1755: /* This expression might be placed ahead of a jump to ensure that the
1756: value was computed on both sides of the jump. So make sure it isn't
1757: eliminated as dead. */
1758: TREE_SIDE_EFFECTS (t) = 1;
1759: return t;
1760: }
1761:
1762: /* Stabilize a reference so that we can use it any number of times
1763: without causing its operands to be evaluated more than once.
1764: Returns the stabilized reference.
1765:
1766: Also allows conversion expressions whose operands are references.
1767: Any other kind of expression is returned unchanged. */
1768:
1769: tree
1770: stabilize_reference (ref)
1771: tree ref;
1772: {
1773: register tree result;
1774: register enum tree_code code = TREE_CODE (ref);
1775:
1776: switch (code)
1777: {
1778: case VAR_DECL:
1779: case PARM_DECL:
1780: case RESULT_DECL:
1781: /* No action is needed in this case. */
1782: return ref;
1783:
1784: case NOP_EXPR:
1785: case CONVERT_EXPR:
1786: case FLOAT_EXPR:
1787: case FIX_TRUNC_EXPR:
1788: case FIX_FLOOR_EXPR:
1789: case FIX_ROUND_EXPR:
1790: case FIX_CEIL_EXPR:
1791: result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
1792: break;
1793:
1794: case INDIRECT_REF:
1795: result = build_nt (INDIRECT_REF,
1796: stabilize_reference_1 (TREE_OPERAND (ref, 0)));
1797: break;
1798:
1799: case COMPONENT_REF:
1800: result = build_nt (COMPONENT_REF,
1801: stabilize_reference (TREE_OPERAND (ref, 0)),
1802: TREE_OPERAND (ref, 1));
1803: break;
1804:
1805: case BIT_FIELD_REF:
1806: result = build_nt (BIT_FIELD_REF,
1807: stabilize_reference (TREE_OPERAND (ref, 0)),
1808: stabilize_reference_1 (TREE_OPERAND (ref, 1)),
1809: stabilize_reference_1 (TREE_OPERAND (ref, 2)));
1810: break;
1811:
1812: case ARRAY_REF:
1813: result = build_nt (ARRAY_REF,
1814: stabilize_reference (TREE_OPERAND (ref, 0)),
1815: stabilize_reference_1 (TREE_OPERAND (ref, 1)));
1816: break;
1817:
1818: /* If arg isn't a kind of lvalue we recognize, make no change.
1819: Caller should recognize the error for an invalid lvalue. */
1820: default:
1821: return ref;
1822:
1823: case ERROR_MARK:
1824: return error_mark_node;
1825: }
1826:
1827: TREE_TYPE (result) = TREE_TYPE (ref);
1828: TREE_READONLY (result) = TREE_READONLY (ref);
1829: TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
1830: TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
1831: TREE_RAISES (result) = TREE_RAISES (ref);
1832:
1833: return result;
1834: }
1835:
1836: /* Subroutine of stabilize_reference; this is called for subtrees of
1837: references. Any expression with side-effects must be put in a SAVE_EXPR
1838: to ensure that it is only evaluated once.
1839:
1840: We don't put SAVE_EXPR nodes around everything, because assigning very
1841: simple expressions to temporaries causes us to miss good opportunities
1842: for optimizations. Among other things, the opportunity to fold in the
1843: addition of a constant into an addressing mode often gets lost, e.g.
1844: "y[i+1] += x;". In general, we take the approach that we should not make
1845: an assignment unless we are forced into it - i.e., that any non-side effect
1846: operator should be allowed, and that cse should take care of coalescing
1847: multiple utterances of the same expression should that prove fruitful. */
1848:
1849: static tree
1850: stabilize_reference_1 (e)
1851: tree e;
1852: {
1853: register tree result;
1854: register int length;
1855: register enum tree_code code = TREE_CODE (e);
1856:
1.1.1.3 ! root 1857: /* We cannot ignore const expressions because it might be a reference
! 1858: to a const array but whose index contains side-effects. But we can
! 1859: ignore things that are actual constant or that already have been
! 1860: handled by this function. */
! 1861:
! 1862: if (TREE_CONSTANT (e) || code == SAVE_EXPR)
1.1 root 1863: return e;
1864:
1865: switch (TREE_CODE_CLASS (code))
1866: {
1867: case 'x':
1868: case 't':
1869: case 'd':
1870: case '<':
1871: case 's':
1872: case 'e':
1873: case 'r':
1874: /* If the expression has side-effects, then encase it in a SAVE_EXPR
1875: so that it will only be evaluated once. */
1876: /* The reference (r) and comparison (<) classes could be handled as
1877: below, but it is generally faster to only evaluate them once. */
1878: if (TREE_SIDE_EFFECTS (e))
1879: return save_expr (e);
1880: return e;
1881:
1882: case 'c':
1883: /* Constants need no processing. In fact, we should never reach
1884: here. */
1885: return e;
1886:
1887: case '2':
1888: /* Recursively stabilize each operand. */
1889: result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
1890: stabilize_reference_1 (TREE_OPERAND (e, 1)));
1891: break;
1892:
1893: case '1':
1894: /* Recursively stabilize each operand. */
1895: result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
1896: break;
1897: }
1898:
1899: TREE_TYPE (result) = TREE_TYPE (e);
1900: TREE_READONLY (result) = TREE_READONLY (e);
1901: TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
1902: TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
1903: TREE_RAISES (result) = TREE_RAISES (e);
1904:
1905: return result;
1906: }
1907:
1908: /* Low-level constructors for expressions. */
1909:
1910: /* Build an expression of code CODE, data type TYPE,
1911: and operands as specified by the arguments ARG1 and following arguments.
1912: Expressions and reference nodes can be created this way.
1913: Constants, decls, types and misc nodes cannot be. */
1914:
1915: tree
1916: build (va_alist)
1917: va_dcl
1918: {
1919: va_list p;
1920: enum tree_code code;
1921: register tree t;
1922: register int length;
1923: register int i;
1924:
1925: va_start (p);
1926:
1927: code = va_arg (p, enum tree_code);
1928: t = make_node (code);
1929: length = tree_code_length[(int) code];
1930: TREE_TYPE (t) = va_arg (p, tree);
1931:
1932: if (length == 2)
1933: {
1934: /* This is equivalent to the loop below, but faster. */
1935: register tree arg0 = va_arg (p, tree);
1936: register tree arg1 = va_arg (p, tree);
1937: TREE_OPERAND (t, 0) = arg0;
1938: TREE_OPERAND (t, 1) = arg1;
1939: if ((arg0 && TREE_SIDE_EFFECTS (arg0))
1940: || (arg1 && TREE_SIDE_EFFECTS (arg1)))
1941: TREE_SIDE_EFFECTS (t) = 1;
1942: TREE_RAISES (t)
1943: = (arg0 && TREE_RAISES (arg0)) || (arg1 && TREE_RAISES (arg1));
1944: }
1945: else if (length == 1)
1946: {
1947: register tree arg0 = va_arg (p, tree);
1948:
1949: /* Call build1 for this! */
1950: if (TREE_CODE_CLASS (code) != 's')
1951: abort ();
1952: TREE_OPERAND (t, 0) = arg0;
1953: if (arg0 && TREE_SIDE_EFFECTS (arg0))
1954: TREE_SIDE_EFFECTS (t) = 1;
1955: TREE_RAISES (t) = (arg0 && TREE_RAISES (arg0));
1956: }
1957: else
1958: {
1959: for (i = 0; i < length; i++)
1960: {
1961: register tree operand = va_arg (p, tree);
1962: TREE_OPERAND (t, i) = operand;
1963: if (operand)
1964: {
1965: if (TREE_SIDE_EFFECTS (operand))
1966: TREE_SIDE_EFFECTS (t) = 1;
1967: if (TREE_RAISES (operand))
1968: TREE_RAISES (t) = 1;
1969: }
1970: }
1971: }
1972: va_end (p);
1973: return t;
1974: }
1975:
1976: /* Same as above, but only builds for unary operators.
1977: Saves lions share of calls to `build'; cuts down use
1978: of varargs, which is expensive for RISC machines. */
1979: tree
1980: build1 (code, type, node)
1981: enum tree_code code;
1982: tree type;
1983: tree node;
1984: {
1985: register struct obstack *obstack = current_obstack;
1986: register int i, length;
1987: register tree_node_kind kind;
1988: register tree t;
1989:
1990: #ifdef GATHER_STATISTICS
1991: if (TREE_CODE_CLASS (code) == 'r')
1992: kind = r_kind;
1993: else
1994: kind = e_kind;
1995: #endif
1996:
1997: obstack = expression_obstack;
1998: length = sizeof (struct tree_exp);
1999:
2000: t = (tree) obstack_alloc (obstack, length);
2001:
2002: #ifdef GATHER_STATISTICS
2003: tree_node_counts[(int)kind]++;
2004: tree_node_sizes[(int)kind] += length;
2005: #endif
2006:
2007: TREE_TYPE (t) = type;
2008: TREE_CHAIN (t) = 0;
2009:
2010: for (i = (length / sizeof (int)) - 2;
2011: i >= sizeof (struct tree_common) / sizeof (int) - 1;
2012: i--)
2013: ((int *) t)[i] = 0;
2014: TREE_SET_CODE (t, code);
2015:
2016: if (obstack == &permanent_obstack)
2017: TREE_PERMANENT (t) = 1;
2018:
2019: TREE_OPERAND (t, 0) = node;
2020: if (node)
2021: {
2022: if (TREE_SIDE_EFFECTS (node))
2023: TREE_SIDE_EFFECTS (t) = 1;
2024: if (TREE_RAISES (node))
2025: TREE_RAISES (t) = 1;
2026: }
2027:
2028: return t;
2029: }
2030:
2031: /* Similar except don't specify the TREE_TYPE
2032: and leave the TREE_SIDE_EFFECTS as 0.
2033: It is permissible for arguments to be null,
2034: or even garbage if their values do not matter. */
2035:
2036: tree
2037: build_nt (va_alist)
2038: va_dcl
2039: {
2040: va_list p;
2041: register enum tree_code code;
2042: register tree t;
2043: register int length;
2044: register int i;
2045:
2046: va_start (p);
2047:
2048: code = va_arg (p, enum tree_code);
2049: t = make_node (code);
2050: length = tree_code_length[(int) code];
2051:
2052: for (i = 0; i < length; i++)
2053: TREE_OPERAND (t, i) = va_arg (p, tree);
2054:
2055: va_end (p);
2056: return t;
2057: }
2058:
2059: /* Similar to `build_nt', except we build
2060: on the temp_decl_obstack, regardless. */
2061:
2062: tree
2063: build_parse_node (va_alist)
2064: va_dcl
2065: {
2066: register struct obstack *ambient_obstack = expression_obstack;
2067: va_list p;
2068: register enum tree_code code;
2069: register tree t;
2070: register int length;
2071: register int i;
2072:
2073: expression_obstack = &temp_decl_obstack;
2074:
2075: va_start (p);
2076:
2077: code = va_arg (p, enum tree_code);
2078: t = make_node (code);
2079: length = tree_code_length[(int) code];
2080:
2081: for (i = 0; i < length; i++)
2082: TREE_OPERAND (t, i) = va_arg (p, tree);
2083:
2084: va_end (p);
2085: expression_obstack = ambient_obstack;
2086: return t;
2087: }
2088:
2089: #if 0
2090: /* Commented out because this wants to be done very
2091: differently. See cp-lex.c. */
2092: tree
2093: build_op_identifier (op1, op2)
2094: tree op1, op2;
2095: {
2096: register tree t = make_node (OP_IDENTIFIER);
2097: TREE_PURPOSE (t) = op1;
2098: TREE_VALUE (t) = op2;
2099: return t;
2100: }
2101: #endif
2102:
2103: /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
2104: We do NOT enter this node in any sort of symbol table.
2105:
2106: layout_decl is used to set up the decl's storage layout.
2107: Other slots are initialized to 0 or null pointers. */
2108:
2109: tree
2110: build_decl (code, name, type)
2111: enum tree_code code;
2112: tree name, type;
2113: {
2114: register tree t;
2115:
2116: t = make_node (code);
2117:
2118: /* if (type == error_mark_node)
2119: type = integer_type_node; */
2120: /* That is not done, deliberately, so that having error_mark_node
2121: as the type can suppress useless errors in the use of this variable. */
2122:
2123: DECL_NAME (t) = name;
2124: DECL_ASSEMBLER_NAME (t) = name;
2125: TREE_TYPE (t) = type;
2126:
2127: if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
2128: layout_decl (t, 0);
2129: else if (code == FUNCTION_DECL)
2130: DECL_MODE (t) = FUNCTION_MODE;
2131:
2132: return t;
2133: }
2134:
2135: /* BLOCK nodes are used to represent the structure of binding contours
2136: and declarations, once those contours have been exited and their contents
2137: compiled. This information is used for outputting debugging info.
2138: A BLOCK may have a "controller" which is a BIND_EXPR node.
2139: Then the BLOCK is ignored unless the controller has the TREE_USED flag. */
2140:
2141: tree
2142: build_block (vars, tags, subblocks, supercontext, chain)
2143: tree vars, tags, subblocks, supercontext, chain;
2144: {
2145: register tree block = make_node (BLOCK);
2146: BLOCK_VARS (block) = vars;
2147: BLOCK_TYPE_TAGS (block) = tags;
2148: BLOCK_SUBBLOCKS (block) = subblocks;
2149: BLOCK_SUPERCONTEXT (block) = supercontext;
2150: BLOCK_CHAIN (block) = chain;
2151: return block;
2152: }
2153:
2154: /* Return a type like TYPE except that its TYPE_READONLY is CONSTP
2155: and its TYPE_VOLATILE is VOLATILEP.
2156:
2157: Such variant types already made are recorded so that duplicates
2158: are not made.
2159:
2160: A variant types should never be used as the type of an expression.
2161: Always copy the variant information into the TREE_READONLY
2162: and TREE_THIS_VOLATILE of the expression, and then give the expression
2163: as its type the "main variant", the variant whose TYPE_READONLY
2164: and TYPE_VOLATILE are zero. Use TYPE_MAIN_VARIANT to find the
2165: main variant. */
2166:
2167: tree
2168: build_type_variant (type, constp, volatilep)
2169: tree type;
2170: int constp, volatilep;
2171: {
2172: register tree t, m = TYPE_MAIN_VARIANT (type);
2173: register struct obstack *ambient_obstack = current_obstack;
2174:
2175: /* Treat any nonzero argument as 1. */
2176: constp = !!constp;
2177: volatilep = !!volatilep;
2178:
1.1.1.2 root 2179: /* If not generating auxiliary info, search the chain of variants to see
1.1 root 2180: if there is already one there just like the one we need to have. If so,
2181: use that existing one.
2182:
2183: We don't do this in the case where we are generating aux info because
2184: in that case we want each typedef names to get it's own distinct type
2185: node, even if the type of this new typedef is the same as some other
2186: (existing) type. */
2187:
2188: if (!flag_gen_aux_info)
2189: for (t = m; t; t = TYPE_NEXT_VARIANT (t))
2190: if (constp == TYPE_READONLY (t) && volatilep == TYPE_VOLATILE (t))
2191: return t;
2192:
2193: /* We need a new one. */
2194: current_obstack
2195: = TREE_PERMANENT (type) ? &permanent_obstack : saveable_obstack;
2196:
2197: t = copy_node (type);
2198: TYPE_READONLY (t) = constp;
2199: TYPE_VOLATILE (t) = volatilep;
2200: TYPE_POINTER_TO (t) = 0;
2201: TYPE_REFERENCE_TO (t) = 0;
2202:
2203: /* Add this type to the chain of variants of TYPE. */
2204: TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
2205: TYPE_NEXT_VARIANT (m) = t;
2206:
2207: current_obstack = ambient_obstack;
2208: return t;
2209: }
1.1.1.2 root 2210:
2211: /* Create a new variant of TYPE, equivalent but distinct.
2212: This is so the caller can modify it. */
2213:
2214: tree
2215: build_type_copy (type)
2216: tree type;
2217: {
2218: register tree t, m = TYPE_MAIN_VARIANT (type);
2219: register struct obstack *ambient_obstack = current_obstack;
2220:
2221: current_obstack
2222: = TREE_PERMANENT (type) ? &permanent_obstack : saveable_obstack;
2223:
2224: t = copy_node (type);
2225: TYPE_POINTER_TO (t) = 0;
2226: TYPE_REFERENCE_TO (t) = 0;
2227:
2228: /* Add this type to the chain of variants of TYPE. */
2229: TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
2230: TYPE_NEXT_VARIANT (m) = t;
2231:
2232: current_obstack = ambient_obstack;
2233: return t;
2234: }
1.1 root 2235:
2236: /* Hashing of types so that we don't make duplicates.
2237: The entry point is `type_hash_canon'. */
2238:
2239: /* Each hash table slot is a bucket containing a chain
2240: of these structures. */
2241:
2242: struct type_hash
2243: {
2244: struct type_hash *next; /* Next structure in the bucket. */
2245: int hashcode; /* Hash code of this type. */
2246: tree type; /* The type recorded here. */
2247: };
2248:
2249: /* Now here is the hash table. When recording a type, it is added
2250: to the slot whose index is the hash code mod the table size.
2251: Note that the hash table is used for several kinds of types
2252: (function types, array types and array index range types, for now).
2253: While all these live in the same table, they are completely independent,
2254: and the hash code is computed differently for each of these. */
2255:
2256: #define TYPE_HASH_SIZE 59
2257: struct type_hash *type_hash_table[TYPE_HASH_SIZE];
2258:
2259: /* Here is how primitive or already-canonicalized types' hash
2260: codes are made. */
2261: #define TYPE_HASH(TYPE) ((int) (TYPE) & 0777777)
2262:
2263: /* Compute a hash code for a list of types (chain of TREE_LIST nodes
2264: with types in the TREE_VALUE slots), by adding the hash codes
2265: of the individual types. */
2266:
2267: int
2268: type_hash_list (list)
2269: tree list;
2270: {
2271: register int hashcode;
2272: register tree tail;
2273: for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
2274: hashcode += TYPE_HASH (TREE_VALUE (tail));
2275: return hashcode;
2276: }
2277:
2278: /* Look in the type hash table for a type isomorphic to TYPE.
2279: If one is found, return it. Otherwise return 0. */
2280:
2281: tree
2282: type_hash_lookup (hashcode, type)
2283: int hashcode;
2284: tree type;
2285: {
2286: register struct type_hash *h;
2287: for (h = type_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
2288: if (h->hashcode == hashcode
2289: && TREE_CODE (h->type) == TREE_CODE (type)
2290: && TREE_TYPE (h->type) == TREE_TYPE (type)
2291: && (TYPE_MAX_VALUE (h->type) == TYPE_MAX_VALUE (type)
2292: || tree_int_cst_equal (TYPE_MAX_VALUE (h->type),
2293: TYPE_MAX_VALUE (type)))
2294: && (TYPE_MIN_VALUE (h->type) == TYPE_MIN_VALUE (type)
2295: || tree_int_cst_equal (TYPE_MIN_VALUE (h->type),
2296: TYPE_MIN_VALUE (type)))
2297: && (TYPE_DOMAIN (h->type) == TYPE_DOMAIN (type)
2298: || (TYPE_DOMAIN (h->type)
2299: && TREE_CODE (TYPE_DOMAIN (h->type)) == TREE_LIST
2300: && TYPE_DOMAIN (type)
2301: && TREE_CODE (TYPE_DOMAIN (type)) == TREE_LIST
2302: && type_list_equal (TYPE_DOMAIN (h->type), TYPE_DOMAIN (type)))))
2303: return h->type;
2304: return 0;
2305: }
2306:
2307: /* Add an entry to the type-hash-table
2308: for a type TYPE whose hash code is HASHCODE. */
2309:
2310: void
2311: type_hash_add (hashcode, type)
2312: int hashcode;
2313: tree type;
2314: {
2315: register struct type_hash *h;
2316:
2317: h = (struct type_hash *) oballoc (sizeof (struct type_hash));
2318: h->hashcode = hashcode;
2319: h->type = type;
2320: h->next = type_hash_table[hashcode % TYPE_HASH_SIZE];
2321: type_hash_table[hashcode % TYPE_HASH_SIZE] = h;
2322: }
2323:
2324: /* Given TYPE, and HASHCODE its hash code, return the canonical
2325: object for an identical type if one already exists.
2326: Otherwise, return TYPE, and record it as the canonical object
2327: if it is a permanent object.
2328:
2329: To use this function, first create a type of the sort you want.
2330: Then compute its hash code from the fields of the type that
2331: make it different from other similar types.
2332: Then call this function and use the value.
2333: This function frees the type you pass in if it is a duplicate. */
2334:
2335: /* Set to 1 to debug without canonicalization. Never set by program. */
2336: int debug_no_type_hash = 0;
2337:
2338: tree
2339: type_hash_canon (hashcode, type)
2340: int hashcode;
2341: tree type;
2342: {
2343: tree t1;
2344:
2345: if (debug_no_type_hash)
2346: return type;
2347:
2348: t1 = type_hash_lookup (hashcode, type);
2349: if (t1 != 0)
2350: {
2351: struct obstack *o
2352: = TREE_PERMANENT (type) ? &permanent_obstack : saveable_obstack;
2353: obstack_free (o, type);
2354: #ifdef GATHER_STATISTICS
2355: tree_node_counts[(int)t_kind]--;
2356: tree_node_sizes[(int)t_kind] -= sizeof (struct tree_type);
2357: #endif
2358: return t1;
2359: }
2360:
2361: /* If this is a new type, record it for later reuse. */
2362: if (current_obstack == &permanent_obstack)
2363: type_hash_add (hashcode, type);
2364:
2365: return type;
2366: }
2367:
2368: /* Given two lists of types
2369: (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
2370: return 1 if the lists contain the same types in the same order.
2371: Also, the TREE_PURPOSEs must match. */
2372:
2373: int
2374: type_list_equal (l1, l2)
2375: tree l1, l2;
2376: {
2377: register tree t1, t2;
2378: for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
2379: {
2380: if (TREE_VALUE (t1) != TREE_VALUE (t2))
2381: return 0;
2382: if (TREE_PURPOSE (t1) != TREE_PURPOSE (t2))
2383: {
2384: int cmp = simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
2385: if (cmp < 0)
2386: abort ();
2387: if (cmp == 0)
2388: return 0;
2389: }
2390: }
2391:
2392: return t1 == t2;
2393: }
2394:
2395: /* Nonzero if integer constants T1 and T2
2396: represent the same constant value. */
2397:
2398: int
2399: tree_int_cst_equal (t1, t2)
2400: tree t1, t2;
2401: {
2402: if (t1 == t2)
2403: return 1;
2404: if (t1 == 0 || t2 == 0)
2405: return 0;
2406: if (TREE_CODE (t1) == INTEGER_CST
2407: && TREE_CODE (t2) == INTEGER_CST
2408: && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2409: && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
2410: return 1;
2411: return 0;
2412: }
2413:
2414: /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
2415: The precise way of comparison depends on their data type. */
2416:
2417: int
2418: tree_int_cst_lt (t1, t2)
2419: tree t1, t2;
2420: {
2421: if (t1 == t2)
2422: return 0;
2423:
2424: if (!TREE_UNSIGNED (TREE_TYPE (t1)))
2425: return INT_CST_LT (t1, t2);
2426: return INT_CST_LT_UNSIGNED (t1, t2);
2427: }
2428:
2429: /* Compare two constructor-element-type constants. */
2430: int
2431: simple_cst_list_equal (l1, l2)
2432: tree l1, l2;
2433: {
2434: while (l1 != NULL_TREE && l2 != NULL_TREE)
2435: {
2436: int cmp = simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2));
2437: if (cmp < 0)
2438: abort ();
2439: if (cmp == 0)
2440: return 0;
2441: l1 = TREE_CHAIN (l1);
2442: l2 = TREE_CHAIN (l2);
2443: }
2444: return (l1 == l2);
2445: }
2446:
2447: /* Return truthvalue of whether T1 is the same tree structure as T2.
2448: Return 1 if they are the same.
2449: Return 0 if they are understandably different.
2450: Return -1 if either contains tree structure not understood by
2451: this function. */
2452:
2453: int
2454: simple_cst_equal (t1, t2)
2455: tree t1, t2;
2456: {
2457: register enum tree_code code1, code2;
2458: int cmp;
2459:
2460: if (t1 == t2)
2461: return 1;
2462: if (t1 == 0 || t2 == 0)
2463: return 0;
2464:
2465: code1 = TREE_CODE (t1);
2466: code2 = TREE_CODE (t2);
2467:
2468: if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
2469: if (code2 == NOP_EXPR || code2 == CONVERT_EXPR || code2 == NON_LVALUE_EXPR)
2470: return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2471: else
2472: return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
2473: else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
2474: || code2 == NON_LVALUE_EXPR)
2475: return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
2476:
2477: if (code1 != code2)
2478: return 0;
2479:
2480: switch (code1)
2481: {
2482: case INTEGER_CST:
2483: return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
2484: && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
2485:
2486: case REAL_CST:
2487: return REAL_VALUES_EQUAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2488:
2489: case STRING_CST:
2490: return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2491: && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2492: TREE_STRING_LENGTH (t1));
2493:
2494: case CONSTRUCTOR:
2495: abort ();
2496:
2497: case SAVE_EXPR:
2498: return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2499:
2500: case CALL_EXPR:
2501: cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2502: if (cmp <= 0)
2503: return cmp;
2504: return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2505:
2506: case TARGET_EXPR:
2507: /* Special case: if either target is an unallocated VAR_DECL,
2508: it means that it's going to be unified with whatever the
2509: TARGET_EXPR is really supposed to initialize, so treat it
2510: as being equivalent to anything. */
2511: if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
2512: && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
2513: && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
2514: || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
2515: && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
2516: && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
2517: cmp = 1;
2518: else
2519: cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2520: if (cmp <= 0)
2521: return cmp;
2522: return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2523:
2524: case WITH_CLEANUP_EXPR:
2525: cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2526: if (cmp <= 0)
2527: return cmp;
2528: return simple_cst_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2));
2529:
2530: case COMPONENT_REF:
2531: if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
2532: return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2533: return 0;
2534:
2535: case BIT_FIELD_REF:
2536: return (simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2537: && simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1))
2538: && simple_cst_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t2, 2)));
2539:
2540: case VAR_DECL:
2541: case PARM_DECL:
2542: case CONST_DECL:
2543: case FUNCTION_DECL:
2544: return 0;
2545:
2546: case PLUS_EXPR:
2547: case MINUS_EXPR:
2548: case MULT_EXPR:
2549: case TRUNC_DIV_EXPR:
2550: case TRUNC_MOD_EXPR:
2551: case LSHIFT_EXPR:
2552: case RSHIFT_EXPR:
2553: cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2554: if (cmp <= 0)
2555: return cmp;
2556: return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
2557:
2558: case NEGATE_EXPR:
2559: case ADDR_EXPR:
2560: case REFERENCE_EXPR:
2561: case INDIRECT_REF:
2562: return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2563:
2564: default:
2565: #if 0
2566: return lang_simple_cst_equal (t1, t2);
2567: #else
2568: return -1;
2569: #endif
2570: }
2571: }
2572:
2573: /* Constructors for pointer, array and function types.
2574: (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
2575: constructed by language-dependent code, not here.) */
2576:
2577: /* Construct, lay out and return the type of pointers to TO_TYPE.
2578: If such a type has already been constructed, reuse it. */
2579:
2580: tree
2581: build_pointer_type (to_type)
2582: tree to_type;
2583: {
2584: register tree t = TYPE_POINTER_TO (to_type);
2585: register struct obstack *ambient_obstack = current_obstack;
2586: register struct obstack *ambient_saveable_obstack = saveable_obstack;
2587:
2588: /* First, if we already have a type for pointers to TO_TYPE, use it. */
2589:
2590: if (t)
2591: return t;
2592:
2593: /* We need a new one. If TO_TYPE is permanent, make this permanent too. */
2594: if (TREE_PERMANENT (to_type))
2595: {
2596: current_obstack = &permanent_obstack;
2597: saveable_obstack = &permanent_obstack;
2598: }
2599:
2600: t = make_node (POINTER_TYPE);
2601: TREE_TYPE (t) = to_type;
2602:
2603: /* Record this type as the pointer to TO_TYPE. */
2604: TYPE_POINTER_TO (to_type) = t;
2605:
2606: /* Lay out the type. This function has many callers that are concerned
2607: with expression-construction, and this simplifies them all.
2608: Also, it guarantees the TYPE_SIZE is permanent if the type is. */
2609: layout_type (t);
2610:
2611: current_obstack = ambient_obstack;
2612: saveable_obstack = ambient_saveable_obstack;
2613: return t;
2614: }
2615:
2616: /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
2617: MAXVAL should be the maximum value in the domain
2618: (one less than the length of the array). */
2619:
2620: tree
2621: build_index_type (maxval)
2622: tree maxval;
2623: {
2624: register tree itype = make_node (INTEGER_TYPE);
2625: TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
2626: TYPE_MIN_VALUE (itype) = build_int_2 (0, 0);
2627: TREE_TYPE (TYPE_MIN_VALUE (itype)) = sizetype;
2628: TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
2629: TYPE_MODE (itype) = TYPE_MODE (sizetype);
2630: TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
2631: TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
2632: if (TREE_CODE (maxval) == INTEGER_CST)
2633: {
2634: int maxint = TREE_INT_CST_LOW (maxval);
2635: return type_hash_canon (maxint > 0 ? maxint : - maxint, itype);
2636: }
2637: else
2638: return itype;
2639: }
2640:
2641: /* Just like build_index_type, but takes lowval and highval instead
2642: of just highval (maxval). */
2643:
2644: tree
2645: build_index_2_type (lowval,highval)
2646: tree lowval, highval;
2647: {
2648: register tree itype = make_node (INTEGER_TYPE);
2649: TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
2650: TYPE_MIN_VALUE (itype) = convert (sizetype, lowval);
2651: TYPE_MAX_VALUE (itype) = convert (sizetype, highval);
2652: TYPE_MODE (itype) = TYPE_MODE (sizetype);
2653: TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
2654: TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
2655: if ((TREE_CODE (lowval) == INTEGER_CST)
2656: && (TREE_CODE (highval) == INTEGER_CST))
2657: {
2658: int highint = TREE_INT_CST_LOW (highval);
2659: int lowint = TREE_INT_CST_LOW (lowval);
2660: int maxint = highint - lowint;
2661: return type_hash_canon (maxint > 0 ? maxint : - maxint, itype);
2662: }
2663: else
2664: return itype;
2665: }
2666:
2667: /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense).
2668: Needed because when index types are not hashed, equal index types
2669: built at different times appear distinct, even though structurally,
2670: they are not. */
2671:
2672: int
2673: index_type_equal (itype1, itype2)
2674: tree itype1, itype2;
2675: {
2676: if (TREE_CODE (itype1) != TREE_CODE (itype2))
2677: return 0;
2678: if (TREE_CODE (itype1) == INTEGER_TYPE)
2679: {
2680: if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2)
2681: || TYPE_MODE (itype1) != TYPE_MODE (itype2)
2682: || ! simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2))
2683: || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2))
2684: return 0;
2685: if (simple_cst_equal (TYPE_MIN_VALUE (itype1), TYPE_MIN_VALUE (itype2))
2686: && simple_cst_equal (TYPE_MAX_VALUE (itype1), TYPE_MAX_VALUE (itype2)))
2687: return 1;
2688: }
2689: return 0;
2690: }
2691:
2692: /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
2693: and number of elements specified by the range of values of INDEX_TYPE.
2694: If such a type has already been constructed, reuse it. */
2695:
2696: tree
2697: build_array_type (elt_type, index_type)
2698: tree elt_type, index_type;
2699: {
2700: register tree t;
2701: int hashcode;
2702:
2703: if (TREE_CODE (elt_type) == FUNCTION_TYPE)
2704: {
2705: error ("arrays of functions are not meaningful");
2706: elt_type = integer_type_node;
2707: }
2708:
2709: /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
2710: build_pointer_type (elt_type);
2711:
2712: /* Allocate the array after the pointer type,
2713: in case we free it in type_hash_canon. */
2714: t = make_node (ARRAY_TYPE);
2715: TREE_TYPE (t) = elt_type;
2716: TYPE_DOMAIN (t) = index_type;
2717:
2718: if (index_type == 0)
2719: return t;
2720:
2721: hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
2722: t = type_hash_canon (hashcode, t);
2723:
2724: if (TYPE_SIZE (t) == 0)
2725: layout_type (t);
2726: return t;
2727: }
2728:
2729: /* Construct, lay out and return
2730: the type of functions returning type VALUE_TYPE
2731: given arguments of types ARG_TYPES.
2732: ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
2733: are data type nodes for the arguments of the function.
2734: If such a type has already been constructed, reuse it. */
2735:
2736: tree
2737: build_function_type (value_type, arg_types)
2738: tree value_type, arg_types;
2739: {
2740: register tree t;
2741: int hashcode;
2742:
2743: if (TREE_CODE (value_type) == FUNCTION_TYPE
2744: || TREE_CODE (value_type) == ARRAY_TYPE)
2745: {
2746: error ("function return type cannot be function or array");
2747: value_type = integer_type_node;
2748: }
2749:
2750: /* Make a node of the sort we want. */
2751: t = make_node (FUNCTION_TYPE);
2752: TREE_TYPE (t) = value_type;
2753: TYPE_ARG_TYPES (t) = arg_types;
2754:
2755: /* If we already have such a type, use the old one and free this one. */
2756: hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
2757: t = type_hash_canon (hashcode, t);
2758:
2759: if (TYPE_SIZE (t) == 0)
2760: layout_type (t);
2761: return t;
2762: }
2763:
2764: /* Build the node for the type of references-to-TO_TYPE. */
2765:
2766: tree
2767: build_reference_type (to_type)
2768: tree to_type;
2769: {
2770: register tree t = TYPE_REFERENCE_TO (to_type);
2771: register struct obstack *ambient_obstack = current_obstack;
2772: register struct obstack *ambient_saveable_obstack = saveable_obstack;
2773:
2774: /* First, if we already have a type for pointers to TO_TYPE, use it. */
2775:
2776: if (t)
2777: return t;
2778:
2779: /* We need a new one. If TO_TYPE is permanent, make this permanent too. */
2780: if (TREE_PERMANENT (to_type))
2781: {
2782: current_obstack = &permanent_obstack;
2783: saveable_obstack = &permanent_obstack;
2784: }
2785:
2786: t = make_node (REFERENCE_TYPE);
2787: TREE_TYPE (t) = to_type;
2788:
2789: /* Record this type as the pointer to TO_TYPE. */
2790: TYPE_REFERENCE_TO (to_type) = t;
2791:
2792: layout_type (t);
2793:
2794: current_obstack = ambient_obstack;
2795: saveable_obstack = ambient_saveable_obstack;
2796: return t;
2797: }
2798:
2799: /* Construct, lay out and return the type of methods belonging to class
2800: BASETYPE and whose arguments and values are described by TYPE.
2801: If that type exists already, reuse it.
2802: TYPE must be a FUNCTION_TYPE node. */
2803:
2804: tree
2805: build_method_type (basetype, type)
2806: tree basetype, type;
2807: {
2808: register tree t;
2809: int hashcode;
2810:
2811: /* Make a node of the sort we want. */
2812: t = make_node (METHOD_TYPE);
2813:
2814: if (TREE_CODE (type) != FUNCTION_TYPE)
2815: abort ();
2816:
2817: TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
2818: TREE_TYPE (t) = TREE_TYPE (type);
2819:
2820: /* The actual arglist for this function includes a "hidden" argument
2821: which is "this". Put it into the list of argument types. */
2822:
2823: TYPE_ARG_TYPES (t)
2824: = tree_cons (NULL, build_pointer_type (basetype), TYPE_ARG_TYPES (type));
2825:
2826: /* If we already have such a type, use the old one and free this one. */
2827: hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
2828: t = type_hash_canon (hashcode, t);
2829:
2830: if (TYPE_SIZE (t) == 0)
2831: layout_type (t);
2832:
2833: return t;
2834: }
2835:
2836: /* Construct, lay out and return the type of methods belonging to class
2837: BASETYPE and whose arguments and values are described by TYPE.
2838: If that type exists already, reuse it.
2839: TYPE must be a FUNCTION_TYPE node. */
2840:
2841: tree
2842: build_offset_type (basetype, type)
2843: tree basetype, type;
2844: {
2845: register tree t;
2846: int hashcode;
2847:
2848: /* Make a node of the sort we want. */
2849: t = make_node (OFFSET_TYPE);
2850:
2851: TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
2852: TREE_TYPE (t) = type;
2853:
2854: /* If we already have such a type, use the old one and free this one. */
2855: hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
2856: t = type_hash_canon (hashcode, t);
2857:
2858: if (TYPE_SIZE (t) == 0)
2859: layout_type (t);
2860:
2861: return t;
2862: }
2863:
2864: /* Create a complex type whose components are COMPONENT_TYPE. */
2865:
2866: tree
2867: build_complex_type (component_type)
2868: tree component_type;
2869: {
2870: register tree t;
2871: int hashcode;
2872:
2873: /* Make a node of the sort we want. */
2874: t = make_node (COMPLEX_TYPE);
2875:
2876: TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
2877: TYPE_VOLATILE (t) = TYPE_VOLATILE (component_type);
2878: TYPE_READONLY (t) = TYPE_READONLY (component_type);
2879:
2880: /* If we already have such a type, use the old one and free this one. */
2881: hashcode = TYPE_HASH (component_type);
2882: t = type_hash_canon (hashcode, t);
2883:
2884: if (TYPE_SIZE (t) == 0)
2885: layout_type (t);
2886:
2887: return t;
2888: }
2889:
2890: /* Return OP, stripped of any conversions to wider types as much as is safe.
2891: Converting the value back to OP's type makes a value equivalent to OP.
2892:
2893: If FOR_TYPE is nonzero, we return a value which, if converted to
2894: type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
2895:
2896: If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
2897: narrowest type that can hold the value, even if they don't exactly fit.
2898: Otherwise, bit-field references are changed to a narrower type
2899: only if they can be fetched directly from memory in that type.
2900:
2901: OP must have integer, real or enumeral type. Pointers are not allowed!
2902:
2903: There are some cases where the obvious value we could return
2904: would regenerate to OP if converted to OP's type,
2905: but would not extend like OP to wider types.
2906: If FOR_TYPE indicates such extension is contemplated, we eschew such values.
2907: For example, if OP is (unsigned short)(signed char)-1,
2908: we avoid returning (signed char)-1 if FOR_TYPE is int,
2909: even though extending that to an unsigned short would regenerate OP,
2910: since the result of extending (signed char)-1 to (int)
2911: is different from (int) OP. */
2912:
2913: tree
2914: get_unwidened (op, for_type)
2915: register tree op;
2916: tree for_type;
2917: {
2918: /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
2919: /* TYPE_PRECISION is safe in place of type_precision since
2920: pointer types are not allowed. */
2921: register tree type = TREE_TYPE (op);
2922: register unsigned final_prec
2923: = TYPE_PRECISION (for_type != 0 ? for_type : type);
2924: register int uns
2925: = (for_type != 0 && for_type != type
2926: && final_prec > TYPE_PRECISION (type)
2927: && TREE_UNSIGNED (type));
2928: register tree win = op;
2929:
2930: while (TREE_CODE (op) == NOP_EXPR)
2931: {
2932: register int bitschange
2933: = TYPE_PRECISION (TREE_TYPE (op))
2934: - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
2935:
2936: /* Truncations are many-one so cannot be removed.
2937: Unless we are later going to truncate down even farther. */
2938: if (bitschange < 0
2939: && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
2940: break;
2941:
2942: /* See what's inside this conversion. If we decide to strip it,
2943: we will set WIN. */
2944: op = TREE_OPERAND (op, 0);
2945:
2946: /* If we have not stripped any zero-extensions (uns is 0),
2947: we can strip any kind of extension.
2948: If we have previously stripped a zero-extension,
2949: only zero-extensions can safely be stripped.
2950: Any extension can be stripped if the bits it would produce
2951: are all going to be discarded later by truncating to FOR_TYPE. */
2952:
2953: if (bitschange > 0)
2954: {
2955: if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
2956: win = op;
2957: /* TREE_UNSIGNED says whether this is a zero-extension.
2958: Let's avoid computing it if it does not affect WIN
2959: and if UNS will not be needed again. */
2960: if ((uns || TREE_CODE (op) == NOP_EXPR)
2961: && TREE_UNSIGNED (TREE_TYPE (op)))
2962: {
2963: uns = 1;
2964: win = op;
2965: }
2966: }
2967: }
2968:
2969: if (TREE_CODE (op) == COMPONENT_REF
2970: /* Since type_for_size always gives an integer type. */
2971: && TREE_CODE (type) != REAL_TYPE)
2972: {
2973: unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
2974: type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1)));
2975:
2976: /* We can get this structure field in the narrowest type it fits in.
2977: If FOR_TYPE is 0, do this only for a field that matches the
2978: narrower type exactly and is aligned for it
2979: The resulting extension to its nominal type (a fullword type)
2980: must fit the same conditions as for other extensions. */
2981:
2982: if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
2983: && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
2984: && (! uns || final_prec <= innerprec
2985: || TREE_UNSIGNED (TREE_OPERAND (op, 1)))
2986: && type != 0)
2987: {
2988: win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
2989: TREE_OPERAND (op, 1));
2990: TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
2991: TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
2992: TREE_RAISES (win) = TREE_RAISES (op);
2993: }
2994: }
2995: return win;
2996: }
2997:
2998: /* Return OP or a simpler expression for a narrower value
2999: which can be sign-extended or zero-extended to give back OP.
3000: Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
3001: or 0 if the value should be sign-extended. */
3002:
3003: tree
3004: get_narrower (op, unsignedp_ptr)
3005: register tree op;
3006: int *unsignedp_ptr;
3007: {
3008: register int uns = 0;
3009: int first = 1;
3010: register tree win = op;
3011:
3012: while (TREE_CODE (op) == NOP_EXPR)
3013: {
3014: register int bitschange
3015: = TYPE_PRECISION (TREE_TYPE (op))
3016: - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
3017:
3018: /* Truncations are many-one so cannot be removed. */
3019: if (bitschange < 0)
3020: break;
3021:
3022: /* See what's inside this conversion. If we decide to strip it,
3023: we will set WIN. */
3024: op = TREE_OPERAND (op, 0);
3025:
3026: if (bitschange > 0)
3027: {
3028: /* An extension: the outermost one can be stripped,
3029: but remember whether it is zero or sign extension. */
3030: if (first)
3031: uns = TREE_UNSIGNED (TREE_TYPE (op));
3032: /* Otherwise, if a sign extension has been stripped,
3033: only sign extensions can now be stripped;
3034: if a zero extension has been stripped, only zero-extensions. */
3035: else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
3036: break;
3037: first = 0;
3038: }
3039: /* A change in nominal type can always be stripped. */
3040:
3041: win = op;
3042: }
3043:
3044: if (TREE_CODE (op) == COMPONENT_REF
3045: /* Since type_for_size always gives an integer type. */
3046: && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE)
3047: {
3048: unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
3049: tree type = type_for_size (innerprec, TREE_UNSIGNED (op));
3050:
3051: /* We can get this structure field in a narrower type that fits it,
3052: but the resulting extension to its nominal type (a fullword type)
3053: must satisfy the same conditions as for other extensions.
3054:
3055: Do this only for fields that are aligned (not bit-fields),
3056: because when bit-field insns will be used there is no
3057: advantage in doing this. */
3058:
3059: if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
3060: && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
3061: && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
3062: && type != 0)
3063: {
3064: if (first)
3065: uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
3066: win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
3067: TREE_OPERAND (op, 1));
3068: TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
3069: TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
3070: TREE_RAISES (win) = TREE_RAISES (op);
3071: }
3072: }
3073: *unsignedp_ptr = uns;
3074: return win;
3075: }
3076:
3077: /* Return the precision of a type, for arithmetic purposes.
3078: Supports all types on which arithmetic is possible
3079: (including pointer types).
3080: It's not clear yet what will be right for complex types. */
3081:
3082: int
3083: type_precision (type)
3084: register tree type;
3085: {
3086: return ((TREE_CODE (type) == INTEGER_TYPE
3087: || TREE_CODE (type) == ENUMERAL_TYPE
3088: || TREE_CODE (type) == REAL_TYPE)
3089: ? TYPE_PRECISION (type) : POINTER_SIZE);
3090: }
3091:
3092: /* Nonzero if integer constant C has a value that is permissible
3093: for type TYPE (an INTEGER_TYPE). */
3094:
3095: int
3096: int_fits_type_p (c, type)
3097: tree c, type;
3098: {
3099: if (TREE_UNSIGNED (type))
3100: return (!INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)
3101: && !INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type)));
3102: else
3103: return (!INT_CST_LT (TYPE_MAX_VALUE (type), c)
3104: && !INT_CST_LT (c, TYPE_MIN_VALUE (type)));
3105: }
3106:
1.1.1.3 ! root 3107: /* Return the innermost context enclosing DECL that is
1.1 root 3108: a FUNCTION_DECL, or zero if none. */
3109:
3110: tree
1.1.1.3 ! root 3111: decl_function_context (decl)
! 3112: tree decl;
1.1 root 3113: {
3114: tree context;
3115:
1.1.1.3 ! root 3116: if (TREE_CODE (decl) == ERROR_MARK)
1.1 root 3117: return 0;
3118:
1.1.1.3 ! root 3119: if (TREE_CODE (decl) == SAVE_EXPR)
! 3120: context = SAVE_EXPR_CONTEXT (decl);
1.1 root 3121: else
1.1.1.3 ! root 3122: context = DECL_CONTEXT (decl);
1.1 root 3123:
3124: while (context && TREE_CODE (context) != FUNCTION_DECL)
3125: {
3126: if (TREE_CODE (context) == RECORD_TYPE
3127: || TREE_CODE (context) == UNION_TYPE)
3128: context = TYPE_CONTEXT (context);
3129: else if (TREE_CODE (context) == TYPE_DECL)
3130: context = DECL_CONTEXT (context);
3131: else if (TREE_CODE (context) == BLOCK)
3132: context = BLOCK_SUPERCONTEXT (context);
3133: else
3134: /* Unhandled CONTEXT !? */
3135: abort ();
3136: }
3137:
3138: return context;
3139: }
3140:
1.1.1.3 ! root 3141: /* Return the innermost context enclosing DECL that is
1.1 root 3142: a RECORD_TYPE or UNION_TYPE, or zero if none.
3143: TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
3144:
3145: tree
1.1.1.3 ! root 3146: decl_type_context (decl)
! 3147: tree decl;
1.1 root 3148: {
1.1.1.3 ! root 3149: tree context = DECL_CONTEXT (decl);
1.1 root 3150:
3151: while (context)
3152: {
3153: if (TREE_CODE (context) == RECORD_TYPE
3154: || TREE_CODE (context) == UNION_TYPE)
3155: return context;
3156: if (TREE_CODE (context) == TYPE_DECL
3157: || TREE_CODE (context) == FUNCTION_DECL)
3158: context = DECL_CONTEXT (context);
3159: else if (TREE_CODE (context) == BLOCK)
3160: context = BLOCK_SUPERCONTEXT (context);
3161: else
3162: /* Unhandled CONTEXT!? */
3163: abort ();
3164: }
3165: return NULL_TREE;
3166: }
3167:
3168: void
3169: print_obstack_statistics (str, o)
3170: char *str;
3171: struct obstack *o;
3172: {
3173: struct _obstack_chunk *chunk = o->chunk;
3174: int n_chunks = 0;
3175: int n_alloc = 0;
3176:
3177: while (chunk)
3178: {
3179: n_chunks += 1;
3180: n_alloc += chunk->limit - &chunk->contents[0];
3181: chunk = chunk->prev;
3182: }
3183: fprintf (stderr, "obstack %s: %d bytes, %d chunks\n",
3184: str, n_alloc, n_chunks);
3185: }
3186: void
3187: dump_tree_statistics ()
3188: {
3189: int i;
3190: int total_nodes, total_bytes;
3191:
3192: fprintf (stderr, "\n??? tree nodes created\n\n");
3193: #ifdef GATHER_STATISTICS
3194: fprintf (stderr, "Kind Nodes Bytes\n");
3195: fprintf (stderr, "-------------------------------------\n");
3196: total_nodes = total_bytes = 0;
3197: for (i = 0; i < (int) all_kinds; i++)
3198: {
3199: fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
3200: tree_node_counts[i], tree_node_sizes[i]);
3201: total_nodes += tree_node_counts[i];
3202: total_bytes += tree_node_sizes[i];
3203: }
3204: fprintf (stderr, "%-20s %9d\n", "identifier names", id_string_size);
3205: fprintf (stderr, "-------------------------------------\n");
3206: fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
3207: fprintf (stderr, "-------------------------------------\n");
3208: #else
3209: fprintf (stderr, "(No per-node statistics)\n");
3210: #endif
3211: print_lang_statistics ();
3212: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.