1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file contains the low level primitives for operating on tree nodes,
24 including allocation, list operations, interning of identifiers,
25 construction of data type nodes and statement nodes,
26 and construction of type conversion nodes. It also contains
27 tables index by tree code that describe how to take apart
30 It is intended to be language-independent, but occasionally
31 calls language-dependent routines defined (for C) in typecheck.c.
33 The low-level allocation routines oballoc and permalloc
34 are used also for allocating many other kinds of objects
35 by all passes of the compiler. */
46 #define obstack_chunk_alloc xmalloc
47 #define obstack_chunk_free free
48 /* obstack.[ch] explicitly declined to prototype this. */
49 extern int _obstack_allocated_p PROTO ((struct obstack *h, GENERIC_PTR obj));
51 /* Tree nodes of permanent duration are allocated in this obstack.
52 They are the identifier nodes, and everything outside of
53 the bodies and parameters of function definitions. */
55 struct obstack permanent_obstack;
57 /* The initial RTL, and all ..._TYPE nodes, in a function
58 are allocated in this obstack. Usually they are freed at the
59 end of the function, but if the function is inline they are saved.
60 For top-level functions, this is maybepermanent_obstack.
61 Separate obstacks are made for nested functions. */
63 struct obstack *function_maybepermanent_obstack;
65 /* This is the function_maybepermanent_obstack for top-level functions. */
67 struct obstack maybepermanent_obstack;
69 /* This is a list of function_maybepermanent_obstacks for top-level inline
70 functions that are compiled in the middle of compiling other functions. */
72 struct simple_obstack_stack *toplev_inline_obstacks;
74 /* Former elements of toplev_inline_obstacks that have been recycled. */
76 struct simple_obstack_stack *extra_inline_obstacks;
78 /* This is a list of function_maybepermanent_obstacks for inline functions
79 nested in the current function that were compiled in the middle of
80 compiling other functions. */
82 struct simple_obstack_stack *inline_obstacks;
84 /* The contents of the current function definition are allocated
85 in this obstack, and all are freed at the end of the function.
86 For top-level functions, this is temporary_obstack.
87 Separate obstacks are made for nested functions. */
89 struct obstack *function_obstack;
91 /* This is used for reading initializers of global variables. */
93 struct obstack temporary_obstack;
95 /* The tree nodes of an expression are allocated
96 in this obstack, and all are freed at the end of the expression. */
98 struct obstack momentary_obstack;
100 /* The tree nodes of a declarator are allocated
101 in this obstack, and all are freed when the declarator
104 static struct obstack temp_decl_obstack;
106 /* This points at either permanent_obstack
107 or the current function_maybepermanent_obstack. */
109 struct obstack *saveable_obstack;
111 /* This is same as saveable_obstack during parse and expansion phase;
112 it points to the current function's obstack during optimization.
113 This is the obstack to be used for creating rtl objects. */
115 struct obstack *rtl_obstack;
117 /* This points at either permanent_obstack or the current function_obstack. */
119 struct obstack *current_obstack;
121 /* This points at either permanent_obstack or the current function_obstack
122 or momentary_obstack. */
124 struct obstack *expression_obstack;
126 /* Stack of obstack selections for push_obstacks and pop_obstacks. */
130 struct obstack_stack *next;
131 struct obstack *current;
132 struct obstack *saveable;
133 struct obstack *expression;
137 struct obstack_stack *obstack_stack;
139 /* Obstack for allocating struct obstack_stack entries. */
141 static struct obstack obstack_stack_obstack;
143 /* Addresses of first objects in some obstacks.
144 This is for freeing their entire contents. */
145 char *maybepermanent_firstobj;
146 char *temporary_firstobj;
147 char *momentary_firstobj;
148 char *temp_decl_firstobj;
150 /* This is used to preserve objects (mainly array initializers) that need to
151 live until the end of the current function, but no further. */
152 char *momentary_function_firstobj;
154 /* Nonzero means all ..._TYPE nodes should be allocated permanently. */
156 int all_types_permanent;
158 /* Stack of places to restore the momentary obstack back to. */
160 struct momentary_level
162 /* Pointer back to previous such level. */
163 struct momentary_level *prev;
164 /* First object allocated within this level. */
166 /* Value of expression_obstack saved at entry to this level. */
167 struct obstack *obstack;
170 struct momentary_level *momentary_stack;
172 /* Table indexed by tree code giving a string containing a character
173 classifying the tree code. Possibilities are
174 t, d, s, c, r, <, 1, 2 and e. See tree.def for details. */
176 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
178 char tree_code_type[MAX_TREE_CODES] = {
183 /* Table indexed by tree code giving number of expression
184 operands beyond the fixed part of the node structure.
185 Not used for types or decls. */
187 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
189 int tree_code_length[MAX_TREE_CODES] = {
194 /* Names of tree components.
195 Used for printing out the tree and error messages. */
196 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
198 char *tree_code_name[MAX_TREE_CODES] = {
203 /* Statistics-gathering stuff. */
224 int tree_node_counts[(int)all_kinds];
225 int tree_node_sizes[(int)all_kinds];
226 int id_string_size = 0;
228 const char *tree_node_kind_names[] = {
246 /* Hash table for uniquizing IDENTIFIER_NODEs by name. */
248 #define MAX_HASH_TABLE 1009
249 static tree hash_table[MAX_HASH_TABLE]; /* id hash buckets */
251 /* 0 while creating built-in identifiers. */
252 static int do_identifier_warnings;
254 /* Unique id for next decl created. */
255 static int next_decl_uid;
256 /* Unique id for next type created. */
257 static int next_type_uid = 1;
259 /* The language-specific function for alias analysis. If NULL, the
260 language does not do any special alias analysis. */
261 int (*lang_get_alias_set) PROTO((tree));
263 /* Here is how primitive or already-canonicalized types' hash
265 #define TYPE_HASH(TYPE) ((unsigned long) (TYPE) & 0777777)
267 static void set_type_quals PROTO((tree, int));
268 static void append_random_chars PROTO((char *));
269 static void build_real_from_int_cst_1 PROTO((PTR));
271 extern char *mode_name[];
273 void gcc_obstack_init ();
275 /* Init the principal obstacks. */
280 gcc_obstack_init (&obstack_stack_obstack);
281 gcc_obstack_init (&permanent_obstack);
283 gcc_obstack_init (&temporary_obstack);
284 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
285 gcc_obstack_init (&momentary_obstack);
286 momentary_firstobj = (char *) obstack_alloc (&momentary_obstack, 0);
287 momentary_function_firstobj = momentary_firstobj;
288 gcc_obstack_init (&maybepermanent_obstack);
289 maybepermanent_firstobj
290 = (char *) obstack_alloc (&maybepermanent_obstack, 0);
291 gcc_obstack_init (&temp_decl_obstack);
292 temp_decl_firstobj = (char *) obstack_alloc (&temp_decl_obstack, 0);
294 function_obstack = &temporary_obstack;
295 function_maybepermanent_obstack = &maybepermanent_obstack;
296 current_obstack = &permanent_obstack;
297 expression_obstack = &permanent_obstack;
298 rtl_obstack = saveable_obstack = &permanent_obstack;
300 /* Init the hash table of identifiers. */
301 bzero ((char *) hash_table, sizeof hash_table);
305 gcc_obstack_init (obstack)
306 struct obstack *obstack;
308 /* Let particular systems override the size of a chunk. */
309 #ifndef OBSTACK_CHUNK_SIZE
310 #define OBSTACK_CHUNK_SIZE 0
312 /* Let them override the alloc and free routines too. */
313 #ifndef OBSTACK_CHUNK_ALLOC
314 #define OBSTACK_CHUNK_ALLOC xmalloc
316 #ifndef OBSTACK_CHUNK_FREE
317 #define OBSTACK_CHUNK_FREE free
319 _obstack_begin (obstack, OBSTACK_CHUNK_SIZE, 0,
320 (void *(*) ()) OBSTACK_CHUNK_ALLOC,
321 (void (*) ()) OBSTACK_CHUNK_FREE);
324 /* Save all variables describing the current status into the structure
325 *P. This function is called whenever we start compiling one
326 function in the midst of compiling another. For example, when
327 compiling a nested function, or, in C++, a template instantiation
328 that is required by the function we are currently compiling.
330 CONTEXT is the decl_function_context for the function we're about to
331 compile; if it isn't current_function_decl, we have to play some games. */
334 save_tree_status (p, context)
338 p->all_types_permanent = all_types_permanent;
339 p->momentary_stack = momentary_stack;
340 p->maybepermanent_firstobj = maybepermanent_firstobj;
341 p->temporary_firstobj = temporary_firstobj;
342 p->momentary_firstobj = momentary_firstobj;
343 p->momentary_function_firstobj = momentary_function_firstobj;
344 p->function_obstack = function_obstack;
345 p->function_maybepermanent_obstack = function_maybepermanent_obstack;
346 p->current_obstack = current_obstack;
347 p->expression_obstack = expression_obstack;
348 p->saveable_obstack = saveable_obstack;
349 p->rtl_obstack = rtl_obstack;
350 p->inline_obstacks = inline_obstacks;
352 if (current_function_decl && context == current_function_decl)
353 /* Objects that need to be saved in this function can be in the nonsaved
354 obstack of the enclosing function since they can't possibly be needed
355 once it has returned. */
356 function_maybepermanent_obstack = function_obstack;
359 /* We're compiling a function which isn't nested in the current
360 function. We need to create a new maybepermanent_obstack for this
361 function, since it can't go onto any of the existing obstacks. */
362 struct simple_obstack_stack **head;
363 struct simple_obstack_stack *current;
365 if (context == NULL_TREE)
366 head = &toplev_inline_obstacks;
369 struct function *f = find_function_data (context);
370 head = &f->inline_obstacks;
373 if (context == NULL_TREE && extra_inline_obstacks)
375 current = extra_inline_obstacks;
376 extra_inline_obstacks = current->next;
380 current = ((struct simple_obstack_stack *)
381 xmalloc (sizeof (struct simple_obstack_stack)));
384 = (struct obstack *) xmalloc (sizeof (struct obstack));
385 gcc_obstack_init (current->obstack);
388 function_maybepermanent_obstack = current->obstack;
390 current->next = *head;
394 maybepermanent_firstobj
395 = (char *) obstack_finish (function_maybepermanent_obstack);
397 function_obstack = (struct obstack *) xmalloc (sizeof (struct obstack));
398 gcc_obstack_init (function_obstack);
400 current_obstack = &permanent_obstack;
401 expression_obstack = &permanent_obstack;
402 rtl_obstack = saveable_obstack = &permanent_obstack;
404 temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0);
405 momentary_firstobj = (char *) obstack_finish (&momentary_obstack);
406 momentary_function_firstobj = momentary_firstobj;
409 /* Restore all variables describing the current status from the structure *P.
410 This is used after a nested function. */
413 restore_tree_status (p, context)
417 all_types_permanent = p->all_types_permanent;
418 momentary_stack = p->momentary_stack;
420 obstack_free (&momentary_obstack, momentary_function_firstobj);
422 /* Free saveable storage used by the function just compiled and not
425 CAUTION: This is in function_obstack of the containing function.
426 So we must be sure that we never allocate from that obstack during
427 the compilation of a nested function if we expect it to survive
428 past the nested function's end. */
429 obstack_free (function_maybepermanent_obstack, maybepermanent_firstobj);
431 /* If we were compiling a toplevel function, we can free this space now. */
432 if (context == NULL_TREE)
434 obstack_free (&temporary_obstack, temporary_firstobj);
435 obstack_free (&momentary_obstack, momentary_function_firstobj);
438 /* If we were compiling a toplevel function that we don't actually want
439 to save anything from, return the obstack to the pool. */
440 if (context == NULL_TREE
441 && obstack_empty_p (function_maybepermanent_obstack))
443 struct simple_obstack_stack *current, **p = &toplev_inline_obstacks;
447 while ((*p)->obstack != function_maybepermanent_obstack)
452 current->next = extra_inline_obstacks;
453 extra_inline_obstacks = current;
457 obstack_free (function_obstack, 0);
458 free (function_obstack);
460 temporary_firstobj = p->temporary_firstobj;
461 momentary_firstobj = p->momentary_firstobj;
462 momentary_function_firstobj = p->momentary_function_firstobj;
463 maybepermanent_firstobj = p->maybepermanent_firstobj;
464 function_obstack = p->function_obstack;
465 function_maybepermanent_obstack = p->function_maybepermanent_obstack;
466 current_obstack = p->current_obstack;
467 expression_obstack = p->expression_obstack;
468 saveable_obstack = p->saveable_obstack;
469 rtl_obstack = p->rtl_obstack;
470 inline_obstacks = p->inline_obstacks;
473 /* Start allocating on the temporary (per function) obstack.
474 This is done in start_function before parsing the function body,
475 and before each initialization at top level, and to go back
476 to temporary allocation after doing permanent_allocation. */
479 temporary_allocation ()
481 /* Note that function_obstack at top level points to temporary_obstack.
482 But within a nested function context, it is a separate obstack. */
483 current_obstack = function_obstack;
484 expression_obstack = function_obstack;
485 rtl_obstack = saveable_obstack = function_maybepermanent_obstack;
490 /* Start allocating on the permanent obstack but don't
491 free the temporary data. After calling this, call
492 `permanent_allocation' to fully resume permanent allocation status. */
495 end_temporary_allocation ()
497 current_obstack = &permanent_obstack;
498 expression_obstack = &permanent_obstack;
499 rtl_obstack = saveable_obstack = &permanent_obstack;
502 /* Resume allocating on the temporary obstack, undoing
503 effects of `end_temporary_allocation'. */
506 resume_temporary_allocation ()
508 current_obstack = function_obstack;
509 expression_obstack = function_obstack;
510 rtl_obstack = saveable_obstack = function_maybepermanent_obstack;
513 /* While doing temporary allocation, switch to allocating in such a
514 way as to save all nodes if the function is inlined. Call
515 resume_temporary_allocation to go back to ordinary temporary
519 saveable_allocation ()
521 /* Note that function_obstack at top level points to temporary_obstack.
522 But within a nested function context, it is a separate obstack. */
523 expression_obstack = current_obstack = saveable_obstack;
526 /* Switch to current obstack CURRENT and maybepermanent obstack SAVEABLE,
527 recording the previously current obstacks on a stack.
528 This does not free any storage in any obstack. */
531 push_obstacks (current, saveable)
532 struct obstack *current, *saveable;
534 struct obstack_stack *p
535 = (struct obstack_stack *) obstack_alloc (&obstack_stack_obstack,
536 (sizeof (struct obstack_stack)));
538 p->current = current_obstack;
539 p->saveable = saveable_obstack;
540 p->expression = expression_obstack;
541 p->rtl = rtl_obstack;
542 p->next = obstack_stack;
545 current_obstack = current;
546 expression_obstack = current;
547 rtl_obstack = saveable_obstack = saveable;
550 /* Save the current set of obstacks, but don't change them. */
553 push_obstacks_nochange ()
555 struct obstack_stack *p
556 = (struct obstack_stack *) obstack_alloc (&obstack_stack_obstack,
557 (sizeof (struct obstack_stack)));
559 p->current = current_obstack;
560 p->saveable = saveable_obstack;
561 p->expression = expression_obstack;
562 p->rtl = rtl_obstack;
563 p->next = obstack_stack;
567 /* Pop the obstack selection stack. */
572 struct obstack_stack *p = obstack_stack;
573 obstack_stack = p->next;
575 current_obstack = p->current;
576 saveable_obstack = p->saveable;
577 expression_obstack = p->expression;
578 rtl_obstack = p->rtl;
580 obstack_free (&obstack_stack_obstack, p);
583 /* Nonzero if temporary allocation is currently in effect.
584 Zero if currently doing permanent allocation. */
587 allocation_temporary_p ()
589 return current_obstack != &permanent_obstack;
592 /* Go back to allocating on the permanent obstack
593 and free everything in the temporary obstack.
595 FUNCTION_END is true only if we have just finished compiling a function.
596 In that case, we also free preserved initial values on the momentary
600 permanent_allocation (function_end)
603 /* Free up previous temporary obstack data */
604 obstack_free (&temporary_obstack, temporary_firstobj);
607 obstack_free (&momentary_obstack, momentary_function_firstobj);
608 momentary_firstobj = momentary_function_firstobj;
611 obstack_free (&momentary_obstack, momentary_firstobj);
612 obstack_free (function_maybepermanent_obstack, maybepermanent_firstobj);
613 obstack_free (&temp_decl_obstack, temp_decl_firstobj);
615 /* Free up the maybepermanent_obstacks for any of our nested functions
616 which were compiled at a lower level. */
617 while (inline_obstacks)
619 struct simple_obstack_stack *current = inline_obstacks;
620 inline_obstacks = current->next;
621 obstack_free (current->obstack, 0);
622 free (current->obstack);
626 current_obstack = &permanent_obstack;
627 expression_obstack = &permanent_obstack;
628 rtl_obstack = saveable_obstack = &permanent_obstack;
631 /* Save permanently everything on the maybepermanent_obstack. */
636 maybepermanent_firstobj
637 = (char *) obstack_alloc (function_maybepermanent_obstack, 0);
641 preserve_initializer ()
643 struct momentary_level *tem;
647 = (char *) obstack_alloc (&temporary_obstack, 0);
648 maybepermanent_firstobj
649 = (char *) obstack_alloc (function_maybepermanent_obstack, 0);
651 old_momentary = momentary_firstobj;
653 = (char *) obstack_alloc (&momentary_obstack, 0);
654 if (momentary_firstobj != old_momentary)
655 for (tem = momentary_stack; tem; tem = tem->prev)
656 tem->base = momentary_firstobj;
659 /* Start allocating new rtl in current_obstack.
660 Use resume_temporary_allocation
661 to go back to allocating rtl in saveable_obstack. */
664 rtl_in_current_obstack ()
666 rtl_obstack = current_obstack;
669 /* Start allocating rtl from saveable_obstack. Intended to be used after
670 a call to push_obstacks_nochange. */
673 rtl_in_saveable_obstack ()
675 rtl_obstack = saveable_obstack;
678 /* Allocate SIZE bytes in the current obstack
679 and return a pointer to them.
680 In practice the current obstack is always the temporary one. */
686 return (char *) obstack_alloc (current_obstack, size);
689 /* Free the object PTR in the current obstack
690 as well as everything allocated since PTR.
691 In practice the current obstack is always the temporary one. */
697 obstack_free (current_obstack, ptr);
700 /* Allocate SIZE bytes in the permanent obstack
701 and return a pointer to them. */
707 return (char *) obstack_alloc (&permanent_obstack, size);
710 /* Allocate NELEM items of SIZE bytes in the permanent obstack
711 and return a pointer to them. The storage is cleared before
712 returning the value. */
715 perm_calloc (nelem, size)
719 char *rval = (char *) obstack_alloc (&permanent_obstack, nelem * size);
720 bzero (rval, nelem * size);
724 /* Allocate SIZE bytes in the saveable obstack
725 and return a pointer to them. */
731 return (char *) obstack_alloc (saveable_obstack, size);
734 /* Allocate SIZE bytes in the expression obstack
735 and return a pointer to them. */
741 return (char *) obstack_alloc (expression_obstack, size);
744 /* Print out which obstack an object is in. */
747 print_obstack_name (object, file, prefix)
752 struct obstack *obstack = NULL;
753 const char *obstack_name = NULL;
756 for (p = outer_function_chain; p; p = p->next)
758 if (_obstack_allocated_p (p->function_obstack, object))
760 obstack = p->function_obstack;
761 obstack_name = "containing function obstack";
763 if (_obstack_allocated_p (p->function_maybepermanent_obstack, object))
765 obstack = p->function_maybepermanent_obstack;
766 obstack_name = "containing function maybepermanent obstack";
770 if (_obstack_allocated_p (&obstack_stack_obstack, object))
772 obstack = &obstack_stack_obstack;
773 obstack_name = "obstack_stack_obstack";
775 else if (_obstack_allocated_p (function_obstack, object))
777 obstack = function_obstack;
778 obstack_name = "function obstack";
780 else if (_obstack_allocated_p (&permanent_obstack, object))
782 obstack = &permanent_obstack;
783 obstack_name = "permanent_obstack";
785 else if (_obstack_allocated_p (&momentary_obstack, object))
787 obstack = &momentary_obstack;
788 obstack_name = "momentary_obstack";
790 else if (_obstack_allocated_p (function_maybepermanent_obstack, object))
792 obstack = function_maybepermanent_obstack;
793 obstack_name = "function maybepermanent obstack";
795 else if (_obstack_allocated_p (&temp_decl_obstack, object))
797 obstack = &temp_decl_obstack;
798 obstack_name = "temp_decl_obstack";
801 /* Check to see if the object is in the free area of the obstack. */
804 if (object >= obstack->next_free
805 && object < obstack->chunk_limit)
806 fprintf (file, "%s in free portion of obstack %s",
807 prefix, obstack_name);
809 fprintf (file, "%s allocated from %s", prefix, obstack_name);
812 fprintf (file, "%s not allocated from any obstack", prefix);
816 debug_obstack (object)
819 print_obstack_name (object, stderr, "object");
820 fprintf (stderr, ".\n");
823 /* Return 1 if OBJ is in the permanent obstack.
824 This is slow, and should be used only for debugging.
825 Use TREE_PERMANENT for other purposes. */
828 object_permanent_p (obj)
831 return _obstack_allocated_p (&permanent_obstack, obj);
834 /* Start a level of momentary allocation.
835 In C, each compound statement has its own level
836 and that level is freed at the end of each statement.
837 All expression nodes are allocated in the momentary allocation level. */
842 struct momentary_level *tem
843 = (struct momentary_level *) obstack_alloc (&momentary_obstack,
844 sizeof (struct momentary_level));
845 tem->prev = momentary_stack;
846 tem->base = (char *) obstack_base (&momentary_obstack);
847 tem->obstack = expression_obstack;
848 momentary_stack = tem;
849 expression_obstack = &momentary_obstack;
852 /* Set things up so the next clear_momentary will only clear memory
853 past our present position in momentary_obstack. */
856 preserve_momentary ()
858 momentary_stack->base = (char *) obstack_base (&momentary_obstack);
861 /* Free all the storage in the current momentary-allocation level.
862 In C, this happens at the end of each statement. */
867 obstack_free (&momentary_obstack, momentary_stack->base);
870 /* Discard a level of momentary allocation.
871 In C, this happens at the end of each compound statement.
872 Restore the status of expression node allocation
873 that was in effect before this level was created. */
878 struct momentary_level *tem = momentary_stack;
879 momentary_stack = tem->prev;
880 expression_obstack = tem->obstack;
881 /* We can't free TEM from the momentary_obstack, because there might
882 be objects above it which have been saved. We can free back to the
883 stack of the level we are popping off though. */
884 obstack_free (&momentary_obstack, tem->base);
887 /* Pop back to the previous level of momentary allocation,
888 but don't free any momentary data just yet. */
891 pop_momentary_nofree ()
893 struct momentary_level *tem = momentary_stack;
894 momentary_stack = tem->prev;
895 expression_obstack = tem->obstack;
898 /* Call when starting to parse a declaration:
899 make expressions in the declaration last the length of the function.
900 Returns an argument that should be passed to resume_momentary later. */
905 register int tem = expression_obstack == &momentary_obstack;
906 expression_obstack = saveable_obstack;
910 /* Call when finished parsing a declaration:
911 restore the treatment of node-allocation that was
912 in effect before the suspension.
913 YES should be the value previously returned by suspend_momentary. */
916 resume_momentary (yes)
920 expression_obstack = &momentary_obstack;
923 /* Init the tables indexed by tree code.
924 Note that languages can add to these tables to define their own codes. */
932 /* Return a newly allocated node of code CODE.
933 Initialize the node's unique id and its TREE_PERMANENT flag.
934 For decl and type nodes, some other fields are initialized.
935 The rest of the node is initialized to zero.
937 Achoo! I got a code in the node. */
944 register int type = TREE_CODE_CLASS (code);
945 register int length = 0;
946 register struct obstack *obstack = current_obstack;
947 #ifdef GATHER_STATISTICS
948 register tree_node_kind kind;
953 case 'd': /* A decl node */
954 #ifdef GATHER_STATISTICS
957 length = sizeof (struct tree_decl);
958 /* All decls in an inline function need to be saved. */
959 if (obstack != &permanent_obstack)
960 obstack = saveable_obstack;
962 /* PARM_DECLs go on the context of the parent. If this is a nested
963 function, then we must allocate the PARM_DECL on the parent's
964 obstack, so that they will live to the end of the parent's
965 closing brace. This is necessary in case we try to inline the
966 function into its parent.
968 PARM_DECLs of top-level functions do not have this problem. However,
969 we allocate them where we put the FUNCTION_DECL for languages such as
970 Ada that need to consult some flags in the PARM_DECLs of the function
973 See comment in restore_tree_status for why we can't put this
974 in function_obstack. */
975 if (code == PARM_DECL && obstack != &permanent_obstack)
978 if (current_function_decl)
979 context = decl_function_context (current_function_decl);
983 = find_function_data (context)->function_maybepermanent_obstack;
987 case 't': /* a type node */
988 #ifdef GATHER_STATISTICS
991 length = sizeof (struct tree_type);
992 /* All data types are put where we can preserve them if nec. */
993 if (obstack != &permanent_obstack)
994 obstack = all_types_permanent ? &permanent_obstack : saveable_obstack;
997 case 'b': /* a lexical block */
998 #ifdef GATHER_STATISTICS
1001 length = sizeof (struct tree_block);
1002 /* All BLOCK nodes are put where we can preserve them if nec. */
1003 if (obstack != &permanent_obstack)
1004 obstack = saveable_obstack;
1007 case 's': /* an expression with side effects */
1008 #ifdef GATHER_STATISTICS
1012 case 'r': /* a reference */
1013 #ifdef GATHER_STATISTICS
1017 case 'e': /* an expression */
1018 case '<': /* a comparison expression */
1019 case '1': /* a unary arithmetic expression */
1020 case '2': /* a binary arithmetic expression */
1021 #ifdef GATHER_STATISTICS
1025 obstack = expression_obstack;
1026 /* All BIND_EXPR nodes are put where we can preserve them if nec. */
1027 if (code == BIND_EXPR && obstack != &permanent_obstack)
1028 obstack = saveable_obstack;
1029 length = sizeof (struct tree_exp)
1030 + (tree_code_length[(int) code] - 1) * sizeof (char *);
1033 case 'c': /* a constant */
1034 #ifdef GATHER_STATISTICS
1037 obstack = expression_obstack;
1039 /* We can't use tree_code_length for INTEGER_CST, since the number of
1040 words is machine-dependent due to varying length of HOST_WIDE_INT,
1041 which might be wider than a pointer (e.g., long long). Similarly
1042 for REAL_CST, since the number of words is machine-dependent due
1043 to varying size and alignment of `double'. */
1045 if (code == INTEGER_CST)
1046 length = sizeof (struct tree_int_cst);
1047 else if (code == REAL_CST)
1048 length = sizeof (struct tree_real_cst);
1050 length = sizeof (struct tree_common)
1051 + tree_code_length[(int) code] * sizeof (char *);
1054 case 'x': /* something random, like an identifier. */
1055 #ifdef GATHER_STATISTICS
1056 if (code == IDENTIFIER_NODE)
1058 else if (code == OP_IDENTIFIER)
1060 else if (code == TREE_VEC)
1065 length = sizeof (struct tree_common)
1066 + tree_code_length[(int) code] * sizeof (char *);
1067 /* Identifier nodes are always permanent since they are
1068 unique in a compiler run. */
1069 if (code == IDENTIFIER_NODE) obstack = &permanent_obstack;
1076 t = (tree) obstack_alloc (obstack, length);
1077 bzero ((PTR) t, length);
1079 #ifdef GATHER_STATISTICS
1080 tree_node_counts[(int)kind]++;
1081 tree_node_sizes[(int)kind] += length;
1084 TREE_SET_CODE (t, code);
1085 if (obstack == &permanent_obstack)
1086 TREE_PERMANENT (t) = 1;
1091 TREE_SIDE_EFFECTS (t) = 1;
1092 TREE_TYPE (t) = void_type_node;
1096 if (code != FUNCTION_DECL)
1098 DECL_IN_SYSTEM_HEADER (t)
1099 = in_system_header && (obstack == &permanent_obstack);
1100 DECL_SOURCE_LINE (t) = lineno;
1101 DECL_SOURCE_FILE (t) = (input_filename) ? input_filename : "<built-in>";
1102 DECL_UID (t) = next_decl_uid++;
1103 /* Note that we have not yet computed the alias set for this
1105 DECL_POINTER_ALIAS_SET (t) = -1;
1109 TYPE_UID (t) = next_type_uid++;
1111 TYPE_MAIN_VARIANT (t) = t;
1112 TYPE_OBSTACK (t) = obstack;
1113 TYPE_ATTRIBUTES (t) = NULL_TREE;
1114 #ifdef SET_DEFAULT_TYPE_ATTRIBUTES
1115 SET_DEFAULT_TYPE_ATTRIBUTES (t);
1117 /* Note that we have not yet computed the alias set for this
1119 TYPE_ALIAS_SET (t) = -1;
1123 TREE_CONSTANT (t) = 1;
1132 case PREDECREMENT_EXPR:
1133 case PREINCREMENT_EXPR:
1134 case POSTDECREMENT_EXPR:
1135 case POSTINCREMENT_EXPR:
1136 /* All of these have side-effects, no matter what their
1138 TREE_SIDE_EFFECTS (t) = 1;
1150 /* Return a new node with the same contents as NODE
1151 except that its TREE_CHAIN is zero and it has a fresh uid. */
1158 register enum tree_code code = TREE_CODE (node);
1159 register int length = 0;
1161 switch (TREE_CODE_CLASS (code))
1163 case 'd': /* A decl node */
1164 length = sizeof (struct tree_decl);
1167 case 't': /* a type node */
1168 length = sizeof (struct tree_type);
1171 case 'b': /* a lexical block node */
1172 length = sizeof (struct tree_block);
1175 case 'r': /* a reference */
1176 case 'e': /* an expression */
1177 case 's': /* an expression with side effects */
1178 case '<': /* a comparison expression */
1179 case '1': /* a unary arithmetic expression */
1180 case '2': /* a binary arithmetic expression */
1181 length = sizeof (struct tree_exp)
1182 + (tree_code_length[(int) code] - 1) * sizeof (char *);
1185 case 'c': /* a constant */
1186 /* We can't use tree_code_length for INTEGER_CST, since the number of
1187 words is machine-dependent due to varying length of HOST_WIDE_INT,
1188 which might be wider than a pointer (e.g., long long). Similarly
1189 for REAL_CST, since the number of words is machine-dependent due
1190 to varying size and alignment of `double'. */
1191 if (code == INTEGER_CST)
1192 length = sizeof (struct tree_int_cst);
1193 else if (code == REAL_CST)
1194 length = sizeof (struct tree_real_cst);
1196 length = (sizeof (struct tree_common)
1197 + tree_code_length[(int) code] * sizeof (char *));
1200 case 'x': /* something random, like an identifier. */
1201 length = sizeof (struct tree_common)
1202 + tree_code_length[(int) code] * sizeof (char *);
1203 if (code == TREE_VEC)
1204 length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *);
1207 t = (tree) obstack_alloc (current_obstack, length);
1208 memcpy (t, node, length);
1210 /* EXPR_WITH_FILE_LOCATION must keep filename info stored in TREE_CHAIN */
1211 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
1213 TREE_ASM_WRITTEN (t) = 0;
1215 if (TREE_CODE_CLASS (code) == 'd')
1216 DECL_UID (t) = next_decl_uid++;
1217 else if (TREE_CODE_CLASS (code) == 't')
1219 TYPE_UID (t) = next_type_uid++;
1220 TYPE_OBSTACK (t) = current_obstack;
1222 /* The following is so that the debug code for
1223 the copy is different from the original type.
1224 The two statements usually duplicate each other
1225 (because they clear fields of the same union),
1226 but the optimizer should catch that. */
1227 TYPE_SYMTAB_POINTER (t) = 0;
1228 TYPE_SYMTAB_ADDRESS (t) = 0;
1231 TREE_PERMANENT (t) = (current_obstack == &permanent_obstack);
1236 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1237 For example, this can copy a list made of TREE_LIST nodes. */
1244 register tree prev, next;
1249 head = prev = copy_node (list);
1250 next = TREE_CHAIN (list);
1253 TREE_CHAIN (prev) = copy_node (next);
1254 prev = TREE_CHAIN (prev);
1255 next = TREE_CHAIN (next);
1262 /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
1263 If an identifier with that name has previously been referred to,
1264 the same node is returned this time. */
1267 get_identifier (text)
1268 register const char *text;
1273 register int len, hash_len;
1275 /* Compute length of text in len. */
1276 len = strlen (text);
1278 /* Decide how much of that length to hash on */
1280 if (warn_id_clash && (unsigned)len > id_clash_len)
1281 hash_len = id_clash_len;
1283 /* Compute hash code */
1284 hi = hash_len * 613 + (unsigned) text[0];
1285 for (i = 1; i < hash_len; i += 2)
1286 hi = ((hi * 613) + (unsigned) (text[i]));
1288 hi &= (1 << HASHBITS) - 1;
1289 hi %= MAX_HASH_TABLE;
1291 /* Search table for identifier */
1292 for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
1293 if (IDENTIFIER_LENGTH (idp) == len
1294 && IDENTIFIER_POINTER (idp)[0] == text[0]
1295 && !bcmp (IDENTIFIER_POINTER (idp), text, len))
1296 return idp; /* <-- return if found */
1298 /* Not found; optionally warn about a similar identifier */
1299 if (warn_id_clash && do_identifier_warnings && (unsigned)len >= id_clash_len)
1300 for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
1301 if (!strncmp (IDENTIFIER_POINTER (idp), text, id_clash_len))
1303 warning ("`%s' and `%s' identical in first %d characters",
1304 IDENTIFIER_POINTER (idp), text, id_clash_len);
1308 if (tree_code_length[(int) IDENTIFIER_NODE] < 0)
1309 abort (); /* set_identifier_size hasn't been called. */
1311 /* Not found, create one, add to chain */
1312 idp = make_node (IDENTIFIER_NODE);
1313 IDENTIFIER_LENGTH (idp) = len;
1314 #ifdef GATHER_STATISTICS
1315 id_string_size += len;
1318 IDENTIFIER_POINTER (idp) = obstack_copy0 (&permanent_obstack, text, len);
1320 TREE_CHAIN (idp) = hash_table[hi];
1321 hash_table[hi] = idp;
1322 return idp; /* <-- return if created */
1325 /* If an identifier with the name TEXT (a null-terminated string) has
1326 previously been referred to, return that node; otherwise return
1330 maybe_get_identifier (text)
1331 register const char *text;
1336 register int len, hash_len;
1338 /* Compute length of text in len. */
1339 len = strlen (text);
1341 /* Decide how much of that length to hash on */
1343 if (warn_id_clash && (unsigned)len > id_clash_len)
1344 hash_len = id_clash_len;
1346 /* Compute hash code */
1347 hi = hash_len * 613 + (unsigned) text[0];
1348 for (i = 1; i < hash_len; i += 2)
1349 hi = ((hi * 613) + (unsigned) (text[i]));
1351 hi &= (1 << HASHBITS) - 1;
1352 hi %= MAX_HASH_TABLE;
1354 /* Search table for identifier */
1355 for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
1356 if (IDENTIFIER_LENGTH (idp) == len
1357 && IDENTIFIER_POINTER (idp)[0] == text[0]
1358 && !bcmp (IDENTIFIER_POINTER (idp), text, len))
1359 return idp; /* <-- return if found */
1364 /* Enable warnings on similar identifiers (if requested).
1365 Done after the built-in identifiers are created. */
1368 start_identifier_warnings ()
1370 do_identifier_warnings = 1;
1373 /* Record the size of an identifier node for the language in use.
1374 SIZE is the total size in bytes.
1375 This is called by the language-specific files. This must be
1376 called before allocating any identifiers. */
1379 set_identifier_size (size)
1382 tree_code_length[(int) IDENTIFIER_NODE]
1383 = (size - sizeof (struct tree_common)) / sizeof (tree);
1386 /* Return a newly constructed INTEGER_CST node whose constant value
1387 is specified by the two ints LOW and HI.
1388 The TREE_TYPE is set to `int'.
1390 This function should be used via the `build_int_2' macro. */
1393 build_int_2_wide (low, hi)
1394 HOST_WIDE_INT low, hi;
1396 register tree t = make_node (INTEGER_CST);
1397 TREE_INT_CST_LOW (t) = low;
1398 TREE_INT_CST_HIGH (t) = hi;
1399 TREE_TYPE (t) = integer_type_node;
1403 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1406 build_real (type, d)
1413 /* Check for valid float value for this type on this target machine;
1414 if not, can print error message and store a valid value in D. */
1415 #ifdef CHECK_FLOAT_VALUE
1416 CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
1419 v = make_node (REAL_CST);
1420 TREE_TYPE (v) = type;
1421 TREE_REAL_CST (v) = d;
1422 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
1426 /* Return a new REAL_CST node whose type is TYPE
1427 and whose value is the integer value of the INTEGER_CST node I. */
1429 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1432 real_value_from_int_cst (type, i)
1437 #ifdef REAL_ARITHMETIC
1438 if (! TREE_UNSIGNED (TREE_TYPE (i)))
1439 REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1442 REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i),
1443 TREE_INT_CST_HIGH (i), TYPE_MODE (type));
1444 #else /* not REAL_ARITHMETIC */
1445 /* Some 386 compilers mishandle unsigned int to float conversions,
1446 so introduce a temporary variable E to avoid those bugs. */
1447 if (TREE_INT_CST_HIGH (i) < 0 && ! TREE_UNSIGNED (TREE_TYPE (i)))
1451 d = (double) (~ TREE_INT_CST_HIGH (i));
1452 e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
1453 * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
1455 e = (double) (unsigned HOST_WIDE_INT) (~ TREE_INT_CST_LOW (i));
1463 d = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (i);
1464 e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
1465 * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
1467 e = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (i);
1470 #endif /* not REAL_ARITHMETIC */
1483 build_real_from_int_cst_1 (data)
1486 struct brfic_args * args = (struct brfic_args *) data;
1488 #ifdef REAL_ARITHMETIC
1489 args->d = real_value_from_int_cst (args->type, args->i);
1492 REAL_VALUE_TRUNCATE (TYPE_MODE (args->type),
1493 real_value_from_int_cst (args->type, args->i));
1497 /* This function can't be implemented if we can't do arithmetic
1498 on the float representation. */
1501 build_real_from_int_cst (type, i)
1506 int overflow = TREE_OVERFLOW (i);
1508 struct brfic_args args;
1510 v = make_node (REAL_CST);
1511 TREE_TYPE (v) = type;
1513 /* Setup input for build_real_from_int_cst_1() */
1517 if (do_float_handler (build_real_from_int_cst_1, (PTR) &args))
1519 /* Receive output from build_real_from_int_cst_1() */
1524 /* We got an exception from build_real_from_int_cst_1() */
1529 /* Check for valid float value for this type on this target machine. */
1531 #ifdef CHECK_FLOAT_VALUE
1532 CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
1535 TREE_REAL_CST (v) = d;
1536 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
1540 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1542 /* Return a newly constructed STRING_CST node whose value is
1543 the LEN characters at STR.
1544 The TREE_TYPE is not initialized. */
1547 build_string (len, str)
1551 /* Put the string in saveable_obstack since it will be placed in the RTL
1552 for an "asm" statement and will also be kept around a while if
1553 deferring constant output in varasm.c. */
1555 register tree s = make_node (STRING_CST);
1556 TREE_STRING_LENGTH (s) = len;
1557 TREE_STRING_POINTER (s) = obstack_copy0 (saveable_obstack, str, len);
1561 /* Return a newly constructed COMPLEX_CST node whose value is
1562 specified by the real and imaginary parts REAL and IMAG.
1563 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1564 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1567 build_complex (type, real, imag)
1571 register tree t = make_node (COMPLEX_CST);
1573 TREE_REALPART (t) = real;
1574 TREE_IMAGPART (t) = imag;
1575 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1576 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1577 TREE_CONSTANT_OVERFLOW (t)
1578 = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
1582 /* Build a newly constructed TREE_VEC node of length LEN. */
1589 register int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
1590 register struct obstack *obstack = current_obstack;
1592 #ifdef GATHER_STATISTICS
1593 tree_node_counts[(int)vec_kind]++;
1594 tree_node_sizes[(int)vec_kind] += length;
1597 t = (tree) obstack_alloc (obstack, length);
1598 bzero ((PTR) t, length);
1600 TREE_SET_CODE (t, TREE_VEC);
1601 TREE_VEC_LENGTH (t) = len;
1602 if (obstack == &permanent_obstack)
1603 TREE_PERMANENT (t) = 1;
1608 /* Return 1 if EXPR is the integer constant zero or a complex constant
1612 integer_zerop (expr)
1617 return ((TREE_CODE (expr) == INTEGER_CST
1618 && ! TREE_CONSTANT_OVERFLOW (expr)
1619 && TREE_INT_CST_LOW (expr) == 0
1620 && TREE_INT_CST_HIGH (expr) == 0)
1621 || (TREE_CODE (expr) == COMPLEX_CST
1622 && integer_zerop (TREE_REALPART (expr))
1623 && integer_zerop (TREE_IMAGPART (expr))));
1626 /* Return 1 if EXPR is the integer constant one or the corresponding
1627 complex constant. */
1635 return ((TREE_CODE (expr) == INTEGER_CST
1636 && ! TREE_CONSTANT_OVERFLOW (expr)
1637 && TREE_INT_CST_LOW (expr) == 1
1638 && TREE_INT_CST_HIGH (expr) == 0)
1639 || (TREE_CODE (expr) == COMPLEX_CST
1640 && integer_onep (TREE_REALPART (expr))
1641 && integer_zerop (TREE_IMAGPART (expr))));
1644 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1645 it contains. Likewise for the corresponding complex constant. */
1648 integer_all_onesp (expr)
1656 if (TREE_CODE (expr) == COMPLEX_CST
1657 && integer_all_onesp (TREE_REALPART (expr))
1658 && integer_zerop (TREE_IMAGPART (expr)))
1661 else if (TREE_CODE (expr) != INTEGER_CST
1662 || TREE_CONSTANT_OVERFLOW (expr))
1665 uns = TREE_UNSIGNED (TREE_TYPE (expr));
1667 return TREE_INT_CST_LOW (expr) == -1 && TREE_INT_CST_HIGH (expr) == -1;
1669 /* Note that using TYPE_PRECISION here is wrong. We care about the
1670 actual bits, not the (arbitrary) range of the type. */
1671 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1672 if (prec >= HOST_BITS_PER_WIDE_INT)
1674 int high_value, shift_amount;
1676 shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1678 if (shift_amount > HOST_BITS_PER_WIDE_INT)
1679 /* Can not handle precisions greater than twice the host int size. */
1681 else if (shift_amount == HOST_BITS_PER_WIDE_INT)
1682 /* Shifting by the host word size is undefined according to the ANSI
1683 standard, so we must handle this as a special case. */
1686 high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1688 return TREE_INT_CST_LOW (expr) == -1
1689 && TREE_INT_CST_HIGH (expr) == high_value;
1692 return TREE_INT_CST_LOW (expr) == ((HOST_WIDE_INT) 1 << prec) - 1;
1695 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1699 integer_pow2p (expr)
1703 HOST_WIDE_INT high, low;
1707 if (TREE_CODE (expr) == COMPLEX_CST
1708 && integer_pow2p (TREE_REALPART (expr))
1709 && integer_zerop (TREE_IMAGPART (expr)))
1712 if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr))
1715 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1716 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1717 high = TREE_INT_CST_HIGH (expr);
1718 low = TREE_INT_CST_LOW (expr);
1720 /* First clear all bits that are beyond the type's precision in case
1721 we've been sign extended. */
1723 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1725 else if (prec > HOST_BITS_PER_WIDE_INT)
1726 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1730 if (prec < HOST_BITS_PER_WIDE_INT)
1731 low &= ~((HOST_WIDE_INT) (-1) << prec);
1734 if (high == 0 && low == 0)
1737 return ((high == 0 && (low & (low - 1)) == 0)
1738 || (low == 0 && (high & (high - 1)) == 0));
1741 /* Return the power of two represented by a tree node known to be a
1749 HOST_WIDE_INT high, low;
1753 if (TREE_CODE (expr) == COMPLEX_CST)
1754 return tree_log2 (TREE_REALPART (expr));
1756 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1757 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1759 high = TREE_INT_CST_HIGH (expr);
1760 low = TREE_INT_CST_LOW (expr);
1762 /* First clear all bits that are beyond the type's precision in case
1763 we've been sign extended. */
1765 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1767 else if (prec > HOST_BITS_PER_WIDE_INT)
1768 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1772 if (prec < HOST_BITS_PER_WIDE_INT)
1773 low &= ~((HOST_WIDE_INT) (-1) << prec);
1776 return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1777 : exact_log2 (low));
1780 /* Return 1 if EXPR is the real constant zero. */
1788 return ((TREE_CODE (expr) == REAL_CST
1789 && ! TREE_CONSTANT_OVERFLOW (expr)
1790 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
1791 || (TREE_CODE (expr) == COMPLEX_CST
1792 && real_zerop (TREE_REALPART (expr))
1793 && real_zerop (TREE_IMAGPART (expr))));
1796 /* Return 1 if EXPR is the real constant one in real or complex form. */
1804 return ((TREE_CODE (expr) == REAL_CST
1805 && ! TREE_CONSTANT_OVERFLOW (expr)
1806 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
1807 || (TREE_CODE (expr) == COMPLEX_CST
1808 && real_onep (TREE_REALPART (expr))
1809 && real_zerop (TREE_IMAGPART (expr))));
1812 /* Return 1 if EXPR is the real constant two. */
1820 return ((TREE_CODE (expr) == REAL_CST
1821 && ! TREE_CONSTANT_OVERFLOW (expr)
1822 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
1823 || (TREE_CODE (expr) == COMPLEX_CST
1824 && real_twop (TREE_REALPART (expr))
1825 && real_zerop (TREE_IMAGPART (expr))));
1828 /* Nonzero if EXP is a constant or a cast of a constant. */
1831 really_constant_p (exp)
1834 /* This is not quite the same as STRIP_NOPS. It does more. */
1835 while (TREE_CODE (exp) == NOP_EXPR
1836 || TREE_CODE (exp) == CONVERT_EXPR
1837 || TREE_CODE (exp) == NON_LVALUE_EXPR)
1838 exp = TREE_OPERAND (exp, 0);
1839 return TREE_CONSTANT (exp);
1842 /* Return first list element whose TREE_VALUE is ELEM.
1843 Return 0 if ELEM is not in LIST. */
1846 value_member (elem, list)
1851 if (elem == TREE_VALUE (list))
1853 list = TREE_CHAIN (list);
1858 /* Return first list element whose TREE_PURPOSE is ELEM.
1859 Return 0 if ELEM is not in LIST. */
1862 purpose_member (elem, list)
1867 if (elem == TREE_PURPOSE (list))
1869 list = TREE_CHAIN (list);
1874 /* Return first list element whose BINFO_TYPE is ELEM.
1875 Return 0 if ELEM is not in LIST. */
1878 binfo_member (elem, list)
1883 if (elem == BINFO_TYPE (list))
1885 list = TREE_CHAIN (list);
1890 /* Return nonzero if ELEM is part of the chain CHAIN. */
1893 chain_member (elem, chain)
1900 chain = TREE_CHAIN (chain);
1906 /* Return nonzero if ELEM is equal to TREE_VALUE (CHAIN) for any piece of
1908 /* ??? This function was added for machine specific attributes but is no
1909 longer used. It could be deleted if we could confirm all front ends
1913 chain_member_value (elem, chain)
1918 if (elem == TREE_VALUE (chain))
1920 chain = TREE_CHAIN (chain);
1926 /* Return nonzero if ELEM is equal to TREE_PURPOSE (CHAIN)
1927 for any piece of chain CHAIN. */
1928 /* ??? This function was added for machine specific attributes but is no
1929 longer used. It could be deleted if we could confirm all front ends
1933 chain_member_purpose (elem, chain)
1938 if (elem == TREE_PURPOSE (chain))
1940 chain = TREE_CHAIN (chain);
1946 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1947 We expect a null pointer to mark the end of the chain.
1948 This is the Lisp primitive `length'. */
1955 register int len = 0;
1957 for (tail = t; tail; tail = TREE_CHAIN (tail))
1963 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1964 by modifying the last node in chain 1 to point to chain 2.
1965 This is the Lisp primitive `nconc'. */
1977 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
1979 TREE_CHAIN (t1) = op2;
1980 #ifdef ENABLE_CHECKING
1981 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
1983 abort (); /* Circularity created. */
1990 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
1994 register tree chain;
1998 while ((next = TREE_CHAIN (chain)))
2003 /* Reverse the order of elements in the chain T,
2004 and return the new head of the chain (old last element). */
2010 register tree prev = 0, decl, next;
2011 for (decl = t; decl; decl = next)
2013 next = TREE_CHAIN (decl);
2014 TREE_CHAIN (decl) = prev;
2020 /* Given a chain CHAIN of tree nodes,
2021 construct and return a list of those nodes. */
2027 tree result = NULL_TREE;
2028 tree in_tail = chain;
2029 tree out_tail = NULL_TREE;
2033 tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE);
2035 TREE_CHAIN (out_tail) = next;
2039 in_tail = TREE_CHAIN (in_tail);
2045 /* Return a newly created TREE_LIST node whose
2046 purpose and value fields are PARM and VALUE. */
2049 build_tree_list (parm, value)
2052 register tree t = make_node (TREE_LIST);
2053 TREE_PURPOSE (t) = parm;
2054 TREE_VALUE (t) = value;
2058 /* Similar, but build on the temp_decl_obstack. */
2061 build_decl_list (parm, value)
2065 register struct obstack *ambient_obstack = current_obstack;
2066 current_obstack = &temp_decl_obstack;
2067 node = build_tree_list (parm, value);
2068 current_obstack = ambient_obstack;
2072 /* Similar, but build on the expression_obstack. */
2075 build_expr_list (parm, value)
2079 register struct obstack *ambient_obstack = current_obstack;
2080 current_obstack = expression_obstack;
2081 node = build_tree_list (parm, value);
2082 current_obstack = ambient_obstack;
2086 /* Return a newly created TREE_LIST node whose
2087 purpose and value fields are PARM and VALUE
2088 and whose TREE_CHAIN is CHAIN. */
2091 tree_cons (purpose, value, chain)
2092 tree purpose, value, chain;
2095 register tree node = make_node (TREE_LIST);
2098 register tree node = (tree) obstack_alloc (current_obstack, sizeof (struct tree_list));
2099 #ifdef GATHER_STATISTICS
2100 tree_node_counts[(int)x_kind]++;
2101 tree_node_sizes[(int)x_kind] += sizeof (struct tree_list);
2104 for (i = (sizeof (struct tree_common) / sizeof (int)) - 1; i >= 0; i--)
2105 ((int *) node)[i] = 0;
2107 TREE_SET_CODE (node, TREE_LIST);
2108 if (current_obstack == &permanent_obstack)
2109 TREE_PERMANENT (node) = 1;
2112 TREE_CHAIN (node) = chain;
2113 TREE_PURPOSE (node) = purpose;
2114 TREE_VALUE (node) = value;
2118 /* Similar, but build on the temp_decl_obstack. */
2121 decl_tree_cons (purpose, value, chain)
2122 tree purpose, value, chain;
2125 register struct obstack *ambient_obstack = current_obstack;
2126 current_obstack = &temp_decl_obstack;
2127 node = tree_cons (purpose, value, chain);
2128 current_obstack = ambient_obstack;
2132 /* Similar, but build on the expression_obstack. */
2135 expr_tree_cons (purpose, value, chain)
2136 tree purpose, value, chain;
2139 register struct obstack *ambient_obstack = current_obstack;
2140 current_obstack = expression_obstack;
2141 node = tree_cons (purpose, value, chain);
2142 current_obstack = ambient_obstack;
2146 /* Same as `tree_cons' but make a permanent object. */
2149 perm_tree_cons (purpose, value, chain)
2150 tree purpose, value, chain;
2153 register struct obstack *ambient_obstack = current_obstack;
2154 current_obstack = &permanent_obstack;
2156 node = tree_cons (purpose, value, chain);
2157 current_obstack = ambient_obstack;
2161 /* Same as `tree_cons', but make this node temporary, regardless. */
2164 temp_tree_cons (purpose, value, chain)
2165 tree purpose, value, chain;
2168 register struct obstack *ambient_obstack = current_obstack;
2169 current_obstack = &temporary_obstack;
2171 node = tree_cons (purpose, value, chain);
2172 current_obstack = ambient_obstack;
2176 /* Same as `tree_cons', but save this node if the function's RTL is saved. */
2179 saveable_tree_cons (purpose, value, chain)
2180 tree purpose, value, chain;
2183 register struct obstack *ambient_obstack = current_obstack;
2184 current_obstack = saveable_obstack;
2186 node = tree_cons (purpose, value, chain);
2187 current_obstack = ambient_obstack;
2191 /* Return the size nominally occupied by an object of type TYPE
2192 when it resides in memory. The value is measured in units of bytes,
2193 and its data type is that normally used for type sizes
2194 (which is the first type created by make_signed_type or
2195 make_unsigned_type). */
2198 size_in_bytes (type)
2203 if (type == error_mark_node)
2204 return integer_zero_node;
2206 type = TYPE_MAIN_VARIANT (type);
2207 t = TYPE_SIZE_UNIT (type);
2210 incomplete_type_error (NULL_TREE, type);
2211 return integer_zero_node;
2213 if (TREE_CODE (t) == INTEGER_CST)
2214 force_fit_type (t, 0);
2219 /* Return the size of TYPE (in bytes) as a wide integer
2220 or return -1 if the size can vary or is larger than an integer. */
2223 int_size_in_bytes (type)
2228 if (type == error_mark_node)
2231 type = TYPE_MAIN_VARIANT (type);
2232 t = TYPE_SIZE_UNIT (type);
2234 || TREE_CODE (t) != INTEGER_CST
2235 || TREE_INT_CST_HIGH (t) != 0)
2238 return TREE_INT_CST_LOW (t);
2241 /* Return, as a tree node, the number of elements for TYPE (which is an
2242 ARRAY_TYPE) minus one. This counts only elements of the top array.
2244 Don't let any SAVE_EXPRs escape; if we are called as part of a cleanup
2245 action, they would get unsaved. */
2248 array_type_nelts (type)
2251 tree index_type, min, max;
2253 /* If they did it with unspecified bounds, then we should have already
2254 given an error about it before we got here. */
2255 if (! TYPE_DOMAIN (type))
2256 return error_mark_node;
2258 index_type = TYPE_DOMAIN (type);
2259 min = TYPE_MIN_VALUE (index_type);
2260 max = TYPE_MAX_VALUE (index_type);
2262 if (! TREE_CONSTANT (min))
2265 if (TREE_CODE (min) == SAVE_EXPR)
2266 min = build (RTL_EXPR, TREE_TYPE (TYPE_MIN_VALUE (index_type)), 0,
2267 SAVE_EXPR_RTL (min));
2269 min = TYPE_MIN_VALUE (index_type);
2272 if (! TREE_CONSTANT (max))
2275 if (TREE_CODE (max) == SAVE_EXPR)
2276 max = build (RTL_EXPR, TREE_TYPE (TYPE_MAX_VALUE (index_type)), 0,
2277 SAVE_EXPR_RTL (max));
2279 max = TYPE_MAX_VALUE (index_type);
2282 return (integer_zerop (min)
2284 : fold (build (MINUS_EXPR, TREE_TYPE (max), max, min)));
2287 /* Return nonzero if arg is static -- a reference to an object in
2288 static storage. This is not the same as the C meaning of `static'. */
2294 switch (TREE_CODE (arg))
2297 /* Nested functions aren't static, since taking their address
2298 involves a trampoline. */
2299 return (decl_function_context (arg) == 0 || DECL_NO_STATIC_CHAIN (arg))
2300 && ! DECL_NON_ADDR_CONST_P (arg);
2303 return (TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2304 && ! DECL_NON_ADDR_CONST_P (arg);
2307 return TREE_STATIC (arg);
2312 /* If we are referencing a bitfield, we can't evaluate an
2313 ADDR_EXPR at compile time and so it isn't a constant. */
2315 return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
2316 && staticp (TREE_OPERAND (arg, 0)));
2322 /* This case is technically correct, but results in setting
2323 TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
2326 return TREE_CONSTANT (TREE_OPERAND (arg, 0));
2330 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2331 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2332 return staticp (TREE_OPERAND (arg, 0));
2339 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2340 Do this to any expression which may be used in more than one place,
2341 but must be evaluated only once.
2343 Normally, expand_expr would reevaluate the expression each time.
2344 Calling save_expr produces something that is evaluated and recorded
2345 the first time expand_expr is called on it. Subsequent calls to
2346 expand_expr just reuse the recorded value.
2348 The call to expand_expr that generates code that actually computes
2349 the value is the first call *at compile time*. Subsequent calls
2350 *at compile time* generate code to use the saved value.
2351 This produces correct result provided that *at run time* control
2352 always flows through the insns made by the first expand_expr
2353 before reaching the other places where the save_expr was evaluated.
2354 You, the caller of save_expr, must make sure this is so.
2356 Constants, and certain read-only nodes, are returned with no
2357 SAVE_EXPR because that is safe. Expressions containing placeholders
2358 are not touched; see tree.def for an explanation of what these
2365 register tree t = fold (expr);
2367 /* We don't care about whether this can be used as an lvalue in this
2369 while (TREE_CODE (t) == NON_LVALUE_EXPR)
2370 t = TREE_OPERAND (t, 0);
2372 /* If the tree evaluates to a constant, then we don't want to hide that
2373 fact (i.e. this allows further folding, and direct checks for constants).
2374 However, a read-only object that has side effects cannot be bypassed.
2375 Since it is no problem to reevaluate literals, we just return the
2378 if (TREE_CONSTANT (t) || (TREE_READONLY (t) && ! TREE_SIDE_EFFECTS (t))
2379 || TREE_CODE (t) == SAVE_EXPR || TREE_CODE (t) == ERROR_MARK)
2382 /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2383 it means that the size or offset of some field of an object depends on
2384 the value within another field.
2386 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2387 and some variable since it would then need to be both evaluated once and
2388 evaluated more than once. Front-ends must assure this case cannot
2389 happen by surrounding any such subexpressions in their own SAVE_EXPR
2390 and forcing evaluation at the proper time. */
2391 if (contains_placeholder_p (t))
2394 t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
2396 /* This expression might be placed ahead of a jump to ensure that the
2397 value was computed on both sides of the jump. So make sure it isn't
2398 eliminated as dead. */
2399 TREE_SIDE_EFFECTS (t) = 1;
2403 /* Arrange for an expression to be expanded multiple independent
2404 times. This is useful for cleanup actions, as the backend can
2405 expand them multiple times in different places. */
2413 /* If this is already protected, no sense in protecting it again. */
2414 if (TREE_CODE (expr) == UNSAVE_EXPR)
2417 t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
2418 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
2422 /* Returns the index of the first non-tree operand for CODE, or the number
2423 of operands if all are trees. */
2427 enum tree_code code;
2433 case GOTO_SUBROUTINE_EXPR:
2438 case WITH_CLEANUP_EXPR:
2439 /* Should be defined to be 2. */
2441 case METHOD_CALL_EXPR:
2444 return tree_code_length [(int) code];
2448 /* Modify a tree in place so that all the evaluate only once things
2449 are cleared out. Return the EXPR given. */
2452 unsave_expr_now (expr)
2455 enum tree_code code;
2459 if (expr == NULL_TREE)
2462 code = TREE_CODE (expr);
2463 first_rtl = first_rtl_op (code);
2467 SAVE_EXPR_RTL (expr) = 0;
2471 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
2472 TREE_OPERAND (expr, 3) = NULL_TREE;
2476 /* I don't yet know how to emit a sequence multiple times. */
2477 if (RTL_EXPR_SEQUENCE (expr) != 0)
2482 CALL_EXPR_RTL (expr) = 0;
2483 if (TREE_OPERAND (expr, 1)
2484 && TREE_CODE (TREE_OPERAND (expr, 1)) == TREE_LIST)
2486 tree exp = TREE_OPERAND (expr, 1);
2489 unsave_expr_now (TREE_VALUE (exp));
2490 exp = TREE_CHAIN (exp);
2499 switch (TREE_CODE_CLASS (code))
2501 case 'c': /* a constant */
2502 case 't': /* a type node */
2503 case 'x': /* something random, like an identifier or an ERROR_MARK. */
2504 case 'd': /* A decl node */
2505 case 'b': /* A block node */
2508 case 'e': /* an expression */
2509 case 'r': /* a reference */
2510 case 's': /* an expression with side effects */
2511 case '<': /* a comparison expression */
2512 case '2': /* a binary arithmetic expression */
2513 case '1': /* a unary arithmetic expression */
2514 for (i = first_rtl - 1; i >= 0; i--)
2515 unsave_expr_now (TREE_OPERAND (expr, i));
2523 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2524 or offset that depends on a field within a record. */
2527 contains_placeholder_p (exp)
2530 register enum tree_code code = TREE_CODE (exp);
2533 /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
2534 in it since it is supplying a value for it. */
2535 if (code == WITH_RECORD_EXPR)
2537 else if (code == PLACEHOLDER_EXPR)
2540 switch (TREE_CODE_CLASS (code))
2543 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2544 position computations since they will be converted into a
2545 WITH_RECORD_EXPR involving the reference, which will assume
2546 here will be valid. */
2547 return contains_placeholder_p (TREE_OPERAND (exp, 0));
2550 if (code == TREE_LIST)
2551 return (contains_placeholder_p (TREE_VALUE (exp))
2552 || (TREE_CHAIN (exp) != 0
2553 && contains_placeholder_p (TREE_CHAIN (exp))));
2562 /* Ignoring the first operand isn't quite right, but works best. */
2563 return contains_placeholder_p (TREE_OPERAND (exp, 1));
2570 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
2571 || contains_placeholder_p (TREE_OPERAND (exp, 1))
2572 || contains_placeholder_p (TREE_OPERAND (exp, 2)));
2575 /* If we already know this doesn't have a placeholder, don't
2577 if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
2580 SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
2581 result = contains_placeholder_p (TREE_OPERAND (exp, 0));
2583 SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
2588 return (TREE_OPERAND (exp, 1) != 0
2589 && contains_placeholder_p (TREE_OPERAND (exp, 1)));
2595 switch (tree_code_length[(int) code])
2598 return contains_placeholder_p (TREE_OPERAND (exp, 0));
2600 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
2601 || contains_placeholder_p (TREE_OPERAND (exp, 1)));
2612 /* Return 1 if EXP contains any expressions that produce cleanups for an
2613 outer scope to deal with. Used by fold. */
2621 if (! TREE_SIDE_EFFECTS (exp))
2624 switch (TREE_CODE (exp))
2627 case GOTO_SUBROUTINE_EXPR:
2628 case WITH_CLEANUP_EXPR:
2631 case CLEANUP_POINT_EXPR:
2635 for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
2637 cmp = has_cleanups (TREE_VALUE (exp));
2647 /* This general rule works for most tree codes. All exceptions should be
2648 handled above. If this is a language-specific tree code, we can't
2649 trust what might be in the operand, so say we don't know
2651 if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
2654 nops = first_rtl_op (TREE_CODE (exp));
2655 for (i = 0; i < nops; i++)
2656 if (TREE_OPERAND (exp, i) != 0)
2658 int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
2659 if (type == 'e' || type == '<' || type == '1' || type == '2'
2660 || type == 'r' || type == 's')
2662 cmp = has_cleanups (TREE_OPERAND (exp, i));
2671 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2672 return a tree with all occurrences of references to F in a
2673 PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
2674 contains only arithmetic expressions or a CALL_EXPR with a
2675 PLACEHOLDER_EXPR occurring only in its arglist. */
2678 substitute_in_expr (exp, f, r)
2683 enum tree_code code = TREE_CODE (exp);
2688 switch (TREE_CODE_CLASS (code))
2695 if (code == PLACEHOLDER_EXPR)
2697 else if (code == TREE_LIST)
2699 op0 = (TREE_CHAIN (exp) == 0
2700 ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
2701 op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
2702 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2705 return tree_cons (TREE_PURPOSE (exp), op1, op0);
2714 switch (tree_code_length[(int) code])
2717 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2718 if (op0 == TREE_OPERAND (exp, 0))
2721 new = fold (build1 (code, TREE_TYPE (exp), op0));
2725 /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
2726 could, but we don't support it. */
2727 if (code == RTL_EXPR)
2729 else if (code == CONSTRUCTOR)
2732 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2733 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2734 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
2737 new = fold (build (code, TREE_TYPE (exp), op0, op1));
2741 /* It cannot be that anything inside a SAVE_EXPR contains a
2742 PLACEHOLDER_EXPR. */
2743 if (code == SAVE_EXPR)
2746 else if (code == CALL_EXPR)
2748 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2749 if (op1 == TREE_OPERAND (exp, 1))
2752 return build (code, TREE_TYPE (exp),
2753 TREE_OPERAND (exp, 0), op1, NULL_TREE);
2756 else if (code != COND_EXPR)
2759 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2760 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2761 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2762 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2763 && op2 == TREE_OPERAND (exp, 2))
2766 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2779 /* If this expression is getting a value from a PLACEHOLDER_EXPR
2780 and it is the right field, replace it with R. */
2781 for (inner = TREE_OPERAND (exp, 0);
2782 TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
2783 inner = TREE_OPERAND (inner, 0))
2785 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2786 && TREE_OPERAND (exp, 1) == f)
2789 /* If this expression hasn't been completed let, leave it
2791 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2792 && TREE_TYPE (inner) == 0)
2795 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2796 if (op0 == TREE_OPERAND (exp, 0))
2799 new = fold (build (code, TREE_TYPE (exp), op0,
2800 TREE_OPERAND (exp, 1)));
2804 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2805 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2806 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2807 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2808 && op2 == TREE_OPERAND (exp, 2))
2811 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2816 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2817 if (op0 == TREE_OPERAND (exp, 0))
2820 new = fold (build1 (code, TREE_TYPE (exp), op0));
2832 TREE_READONLY (new) = TREE_READONLY (exp);
2836 /* Stabilize a reference so that we can use it any number of times
2837 without causing its operands to be evaluated more than once.
2838 Returns the stabilized reference. This works by means of save_expr,
2839 so see the caveats in the comments about save_expr.
2841 Also allows conversion expressions whose operands are references.
2842 Any other kind of expression is returned unchanged. */
2845 stabilize_reference (ref)
2848 register tree result;
2849 register enum tree_code code = TREE_CODE (ref);
2856 /* No action is needed in this case. */
2862 case FIX_TRUNC_EXPR:
2863 case FIX_FLOOR_EXPR:
2864 case FIX_ROUND_EXPR:
2866 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
2870 result = build_nt (INDIRECT_REF,
2871 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
2875 result = build_nt (COMPONENT_REF,
2876 stabilize_reference (TREE_OPERAND (ref, 0)),
2877 TREE_OPERAND (ref, 1));
2881 result = build_nt (BIT_FIELD_REF,
2882 stabilize_reference (TREE_OPERAND (ref, 0)),
2883 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2884 stabilize_reference_1 (TREE_OPERAND (ref, 2)));
2888 result = build_nt (ARRAY_REF,
2889 stabilize_reference (TREE_OPERAND (ref, 0)),
2890 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2894 /* We cannot wrap the first expression in a SAVE_EXPR, as then
2895 it wouldn't be ignored. This matters when dealing with
2897 return stabilize_reference_1 (ref);
2900 result = build1 (INDIRECT_REF, TREE_TYPE (ref),
2901 save_expr (build1 (ADDR_EXPR,
2902 build_pointer_type (TREE_TYPE (ref)),
2907 /* If arg isn't a kind of lvalue we recognize, make no change.
2908 Caller should recognize the error for an invalid lvalue. */
2913 return error_mark_node;
2916 TREE_TYPE (result) = TREE_TYPE (ref);
2917 TREE_READONLY (result) = TREE_READONLY (ref);
2918 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
2919 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
2920 TREE_RAISES (result) = TREE_RAISES (ref);
2925 /* Subroutine of stabilize_reference; this is called for subtrees of
2926 references. Any expression with side-effects must be put in a SAVE_EXPR
2927 to ensure that it is only evaluated once.
2929 We don't put SAVE_EXPR nodes around everything, because assigning very
2930 simple expressions to temporaries causes us to miss good opportunities
2931 for optimizations. Among other things, the opportunity to fold in the
2932 addition of a constant into an addressing mode often gets lost, e.g.
2933 "y[i+1] += x;". In general, we take the approach that we should not make
2934 an assignment unless we are forced into it - i.e., that any non-side effect
2935 operator should be allowed, and that cse should take care of coalescing
2936 multiple utterances of the same expression should that prove fruitful. */
2939 stabilize_reference_1 (e)
2942 register tree result;
2943 register enum tree_code code = TREE_CODE (e);
2945 /* We cannot ignore const expressions because it might be a reference
2946 to a const array but whose index contains side-effects. But we can
2947 ignore things that are actual constant or that already have been
2948 handled by this function. */
2950 if (TREE_CONSTANT (e) || code == SAVE_EXPR)
2953 switch (TREE_CODE_CLASS (code))
2963 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2964 so that it will only be evaluated once. */
2965 /* The reference (r) and comparison (<) classes could be handled as
2966 below, but it is generally faster to only evaluate them once. */
2967 if (TREE_SIDE_EFFECTS (e))
2968 return save_expr (e);
2972 /* Constants need no processing. In fact, we should never reach
2977 /* Division is slow and tends to be compiled with jumps,
2978 especially the division by powers of 2 that is often
2979 found inside of an array reference. So do it just once. */
2980 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
2981 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
2982 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
2983 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
2984 return save_expr (e);
2985 /* Recursively stabilize each operand. */
2986 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
2987 stabilize_reference_1 (TREE_OPERAND (e, 1)));
2991 /* Recursively stabilize each operand. */
2992 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
2999 TREE_TYPE (result) = TREE_TYPE (e);
3000 TREE_READONLY (result) = TREE_READONLY (e);
3001 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3002 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3003 TREE_RAISES (result) = TREE_RAISES (e);
3008 /* Low-level constructors for expressions. */
3010 /* Build an expression of code CODE, data type TYPE,
3011 and operands as specified by the arguments ARG1 and following arguments.
3012 Expressions and reference nodes can be created this way.
3013 Constants, decls, types and misc nodes cannot be. */
3016 build VPROTO((enum tree_code code, tree tt, ...))
3018 #ifndef ANSI_PROTOTYPES
3019 enum tree_code code;
3024 register int length;
3029 #ifndef ANSI_PROTOTYPES
3030 code = va_arg (p, enum tree_code);
3031 tt = va_arg (p, tree);
3034 t = make_node (code);
3035 length = tree_code_length[(int) code];
3040 /* This is equivalent to the loop below, but faster. */
3041 register tree arg0 = va_arg (p, tree);
3042 register tree arg1 = va_arg (p, tree);
3043 TREE_OPERAND (t, 0) = arg0;
3044 TREE_OPERAND (t, 1) = arg1;
3045 if ((arg0 && TREE_SIDE_EFFECTS (arg0))
3046 || (arg1 && TREE_SIDE_EFFECTS (arg1)))
3047 TREE_SIDE_EFFECTS (t) = 1;
3049 = (arg0 && TREE_RAISES (arg0)) || (arg1 && TREE_RAISES (arg1));
3051 else if (length == 1)
3053 register tree arg0 = va_arg (p, tree);
3055 /* Call build1 for this! */
3056 if (TREE_CODE_CLASS (code) != 's')
3058 TREE_OPERAND (t, 0) = arg0;
3059 if (arg0 && TREE_SIDE_EFFECTS (arg0))
3060 TREE_SIDE_EFFECTS (t) = 1;
3061 TREE_RAISES (t) = (arg0 && TREE_RAISES (arg0));
3065 for (i = 0; i < length; i++)
3067 register tree operand = va_arg (p, tree);
3068 TREE_OPERAND (t, i) = operand;
3071 if (TREE_SIDE_EFFECTS (operand))
3072 TREE_SIDE_EFFECTS (t) = 1;
3073 if (TREE_RAISES (operand))
3074 TREE_RAISES (t) = 1;
3082 /* Same as above, but only builds for unary operators.
3083 Saves lions share of calls to `build'; cuts down use
3084 of varargs, which is expensive for RISC machines. */
3087 build1 (code, type, node)
3088 enum tree_code code;
3092 register struct obstack *obstack = expression_obstack;
3093 register int length;
3094 #ifdef GATHER_STATISTICS
3095 register tree_node_kind kind;
3099 #ifdef GATHER_STATISTICS
3100 if (TREE_CODE_CLASS (code) == 'r')
3106 length = sizeof (struct tree_exp);
3108 t = (tree) obstack_alloc (obstack, length);
3109 bzero ((PTR) t, length);
3111 #ifdef GATHER_STATISTICS
3112 tree_node_counts[(int)kind]++;
3113 tree_node_sizes[(int)kind] += length;
3116 TREE_TYPE (t) = type;
3117 TREE_SET_CODE (t, code);
3119 if (obstack == &permanent_obstack)
3120 TREE_PERMANENT (t) = 1;
3122 TREE_OPERAND (t, 0) = node;
3125 if (TREE_SIDE_EFFECTS (node))
3126 TREE_SIDE_EFFECTS (t) = 1;
3127 if (TREE_RAISES (node))
3128 TREE_RAISES (t) = 1;
3136 case PREDECREMENT_EXPR:
3137 case PREINCREMENT_EXPR:
3138 case POSTDECREMENT_EXPR:
3139 case POSTINCREMENT_EXPR:
3140 /* All of these have side-effects, no matter what their
3142 TREE_SIDE_EFFECTS (t) = 1;
3152 /* Similar except don't specify the TREE_TYPE
3153 and leave the TREE_SIDE_EFFECTS as 0.
3154 It is permissible for arguments to be null,
3155 or even garbage if their values do not matter. */
3158 build_nt VPROTO((enum tree_code code, ...))
3160 #ifndef ANSI_PROTOTYPES
3161 enum tree_code code;
3165 register int length;
3170 #ifndef ANSI_PROTOTYPES
3171 code = va_arg (p, enum tree_code);
3174 t = make_node (code);
3175 length = tree_code_length[(int) code];
3177 for (i = 0; i < length; i++)
3178 TREE_OPERAND (t, i) = va_arg (p, tree);
3184 /* Similar to `build_nt', except we build
3185 on the temp_decl_obstack, regardless. */
3188 build_parse_node VPROTO((enum tree_code code, ...))
3190 #ifndef ANSI_PROTOTYPES
3191 enum tree_code code;
3193 register struct obstack *ambient_obstack = expression_obstack;
3196 register int length;
3201 #ifndef ANSI_PROTOTYPES
3202 code = va_arg (p, enum tree_code);
3205 expression_obstack = &temp_decl_obstack;
3207 t = make_node (code);
3208 length = tree_code_length[(int) code];
3210 for (i = 0; i < length; i++)
3211 TREE_OPERAND (t, i) = va_arg (p, tree);
3214 expression_obstack = ambient_obstack;
3219 /* Commented out because this wants to be done very
3220 differently. See cp-lex.c. */
3222 build_op_identifier (op1, op2)
3225 register tree t = make_node (OP_IDENTIFIER);
3226 TREE_PURPOSE (t) = op1;
3227 TREE_VALUE (t) = op2;
3232 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3233 We do NOT enter this node in any sort of symbol table.
3235 layout_decl is used to set up the decl's storage layout.
3236 Other slots are initialized to 0 or null pointers. */
3239 build_decl (code, name, type)
3240 enum tree_code code;
3245 t = make_node (code);
3247 /* if (type == error_mark_node)
3248 type = integer_type_node; */
3249 /* That is not done, deliberately, so that having error_mark_node
3250 as the type can suppress useless errors in the use of this variable. */
3252 DECL_NAME (t) = name;
3253 DECL_ASSEMBLER_NAME (t) = name;
3254 TREE_TYPE (t) = type;
3256 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
3258 else if (code == FUNCTION_DECL)
3259 DECL_MODE (t) = FUNCTION_MODE;
3264 /* BLOCK nodes are used to represent the structure of binding contours
3265 and declarations, once those contours have been exited and their contents
3266 compiled. This information is used for outputting debugging info. */
3269 build_block (vars, tags, subblocks, supercontext, chain)
3270 tree vars, tags, subblocks, supercontext, chain;
3272 register tree block = make_node (BLOCK);
3273 BLOCK_VARS (block) = vars;
3274 BLOCK_TYPE_TAGS (block) = tags;
3275 BLOCK_SUBBLOCKS (block) = subblocks;
3276 BLOCK_SUPERCONTEXT (block) = supercontext;
3277 BLOCK_CHAIN (block) = chain;
3281 /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact
3282 location where an expression or an identifier were encountered. It
3283 is necessary for languages where the frontend parser will handle
3284 recursively more than one file (Java is one of them). */
3287 build_expr_wfl (node, file, line, col)
3292 static const char *last_file = 0;
3293 static tree last_filenode = NULL_TREE;
3294 register tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
3296 EXPR_WFL_NODE (wfl) = node;
3297 EXPR_WFL_SET_LINECOL (wfl, line, col);
3298 if (file != last_file)
3301 last_filenode = file ? get_identifier (file) : NULL_TREE;
3303 EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
3306 TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
3307 TREE_TYPE (wfl) = TREE_TYPE (node);
3312 /* Return a declaration like DDECL except that its DECL_MACHINE_ATTRIBUTE
3316 build_decl_attribute_variant (ddecl, attribute)
3317 tree ddecl, attribute;
3319 DECL_MACHINE_ATTRIBUTES (ddecl) = attribute;
3323 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
3326 Record such modified types already made so we don't make duplicates. */
3329 build_type_attribute_variant (ttype, attribute)
3330 tree ttype, attribute;
3332 if ( ! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
3334 register int hashcode;
3335 register struct obstack *ambient_obstack = current_obstack;
3338 if (ambient_obstack != &permanent_obstack)
3339 current_obstack = TYPE_OBSTACK (ttype);
3341 ntype = copy_node (ttype);
3343 TYPE_POINTER_TO (ntype) = 0;
3344 TYPE_REFERENCE_TO (ntype) = 0;
3345 TYPE_ATTRIBUTES (ntype) = attribute;
3347 /* Create a new main variant of TYPE. */
3348 TYPE_MAIN_VARIANT (ntype) = ntype;
3349 TYPE_NEXT_VARIANT (ntype) = 0;
3350 set_type_quals (ntype, TYPE_UNQUALIFIED);
3352 hashcode = TYPE_HASH (TREE_CODE (ntype))
3353 + TYPE_HASH (TREE_TYPE (ntype))
3354 + attribute_hash_list (attribute);
3356 switch (TREE_CODE (ntype))
3359 hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
3362 hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));
3365 hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));
3368 hashcode += TYPE_HASH (TYPE_PRECISION (ntype));
3374 ntype = type_hash_canon (hashcode, ntype);
3375 ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
3377 /* We must restore the current obstack after the type_hash_canon call,
3378 because type_hash_canon calls type_hash_add for permanent types, and
3379 then type_hash_add calls oballoc expecting to get something permanent
3381 current_obstack = ambient_obstack;
3387 /* Return a 1 if ATTR_NAME and ATTR_ARGS is valid for either declaration DECL
3388 or type TYPE and 0 otherwise. Validity is determined the configuration
3389 macros VALID_MACHINE_DECL_ATTRIBUTE and VALID_MACHINE_TYPE_ATTRIBUTE. */
3392 valid_machine_attribute (attr_name, attr_args, decl, type)
3394 tree attr_args ATTRIBUTE_UNUSED;
3395 tree decl ATTRIBUTE_UNUSED;
3396 tree type ATTRIBUTE_UNUSED;
3399 #ifdef VALID_MACHINE_DECL_ATTRIBUTE
3400 tree decl_attr_list = decl != 0 ? DECL_MACHINE_ATTRIBUTES (decl) : 0;
3402 #ifdef VALID_MACHINE_TYPE_ATTRIBUTE
3403 tree type_attr_list = TYPE_ATTRIBUTES (type);
3406 if (TREE_CODE (attr_name) != IDENTIFIER_NODE)
3409 #ifdef VALID_MACHINE_DECL_ATTRIBUTE
3411 && VALID_MACHINE_DECL_ATTRIBUTE (decl, decl_attr_list, attr_name, attr_args))
3413 tree attr = lookup_attribute (IDENTIFIER_POINTER (attr_name),
3416 if (attr != NULL_TREE)
3418 /* Override existing arguments. Declarations are unique so we can
3419 modify this in place. */
3420 TREE_VALUE (attr) = attr_args;
3424 decl_attr_list = tree_cons (attr_name, attr_args, decl_attr_list);
3425 decl = build_decl_attribute_variant (decl, decl_attr_list);
3432 #ifdef VALID_MACHINE_TYPE_ATTRIBUTE
3434 /* Don't apply the attribute to both the decl and the type. */;
3435 else if (VALID_MACHINE_TYPE_ATTRIBUTE (type, type_attr_list, attr_name,
3438 tree attr = lookup_attribute (IDENTIFIER_POINTER (attr_name),
3441 if (attr != NULL_TREE)
3443 /* Override existing arguments.
3444 ??? This currently works since attribute arguments are not
3445 included in `attribute_hash_list'. Something more complicated
3446 may be needed in the future. */
3447 TREE_VALUE (attr) = attr_args;
3451 /* If this is part of a declaration, create a type variant,
3452 otherwise, this is part of a type definition, so add it
3453 to the base type. */
3454 type_attr_list = tree_cons (attr_name, attr_args, type_attr_list);
3456 type = build_type_attribute_variant (type, type_attr_list);
3458 TYPE_ATTRIBUTES (type) = type_attr_list;
3461 TREE_TYPE (decl) = type;
3465 /* Handle putting a type attribute on pointer-to-function-type by putting
3466 the attribute on the function type. */
3467 else if (POINTER_TYPE_P (type)
3468 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3469 && VALID_MACHINE_TYPE_ATTRIBUTE (TREE_TYPE (type), type_attr_list,
3470 attr_name, attr_args))
3472 tree inner_type = TREE_TYPE (type);
3473 tree inner_attr_list = TYPE_ATTRIBUTES (inner_type);
3474 tree attr = lookup_attribute (IDENTIFIER_POINTER (attr_name),
3477 if (attr != NULL_TREE)
3478 TREE_VALUE (attr) = attr_args;
3481 inner_attr_list = tree_cons (attr_name, attr_args, inner_attr_list);
3482 inner_type = build_type_attribute_variant (inner_type,
3487 TREE_TYPE (decl) = build_pointer_type (inner_type);
3490 /* Clear TYPE_POINTER_TO for the old inner type, since
3491 `type' won't be pointing to it anymore. */
3492 TYPE_POINTER_TO (TREE_TYPE (type)) = NULL_TREE;
3493 TREE_TYPE (type) = inner_type;
3503 /* Return non-zero if IDENT is a valid name for attribute ATTR,
3506 We try both `text' and `__text__', ATTR may be either one. */
3507 /* ??? It might be a reasonable simplification to require ATTR to be only
3508 `text'. One might then also require attribute lists to be stored in
3509 their canonicalized form. */
3512 is_attribute_p (attr, ident)
3516 int ident_len, attr_len;
3519 if (TREE_CODE (ident) != IDENTIFIER_NODE)
3522 if (strcmp (attr, IDENTIFIER_POINTER (ident)) == 0)
3525 p = IDENTIFIER_POINTER (ident);
3526 ident_len = strlen (p);
3527 attr_len = strlen (attr);
3529 /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
3533 || attr[attr_len - 2] != '_'
3534 || attr[attr_len - 1] != '_')
3536 if (ident_len == attr_len - 4
3537 && strncmp (attr + 2, p, attr_len - 4) == 0)
3542 if (ident_len == attr_len + 4
3543 && p[0] == '_' && p[1] == '_'
3544 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
3545 && strncmp (attr, p + 2, attr_len) == 0)
3552 /* Given an attribute name and a list of attributes, return a pointer to the
3553 attribute's list element if the attribute is part of the list, or NULL_TREE
3557 lookup_attribute (attr_name, list)
3558 const char *attr_name;
3563 for (l = list; l; l = TREE_CHAIN (l))
3565 if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE)
3567 if (is_attribute_p (attr_name, TREE_PURPOSE (l)))
3574 /* Return an attribute list that is the union of a1 and a2. */
3577 merge_attributes (a1, a2)
3578 register tree a1, a2;
3582 /* Either one unset? Take the set one. */
3584 if (! (attributes = a1))
3587 /* One that completely contains the other? Take it. */
3589 else if (a2 && ! attribute_list_contained (a1, a2))
3591 if (attribute_list_contained (a2, a1))
3595 /* Pick the longest list, and hang on the other list. */
3596 /* ??? For the moment we punt on the issue of attrs with args. */
3598 if (list_length (a1) < list_length (a2))
3599 attributes = a2, a2 = a1;
3601 for (; a2; a2 = TREE_CHAIN (a2))
3602 if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
3603 attributes) == NULL_TREE)
3605 a1 = copy_node (a2);
3606 TREE_CHAIN (a1) = attributes;
3614 /* Given types T1 and T2, merge their attributes and return
3618 merge_machine_type_attributes (t1, t2)
3621 #ifdef MERGE_MACHINE_TYPE_ATTRIBUTES
3622 return MERGE_MACHINE_TYPE_ATTRIBUTES (t1, t2);
3624 return merge_attributes (TYPE_ATTRIBUTES (t1),
3625 TYPE_ATTRIBUTES (t2));
3629 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
3633 merge_machine_decl_attributes (olddecl, newdecl)
3634 tree olddecl, newdecl;
3636 #ifdef MERGE_MACHINE_DECL_ATTRIBUTES
3637 return MERGE_MACHINE_DECL_ATTRIBUTES (olddecl, newdecl);
3639 return merge_attributes (DECL_MACHINE_ATTRIBUTES (olddecl),
3640 DECL_MACHINE_ATTRIBUTES (newdecl));
3644 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
3645 of the various TYPE_QUAL values. */
3648 set_type_quals (type, type_quals)
3652 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
3653 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
3654 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
3657 /* Given a type node TYPE and a TYPE_QUALIFIER_SET, return a type for
3658 the same kind of data as TYPE describes. Variants point to the
3659 "main variant" (which has no qualifiers set) via TYPE_MAIN_VARIANT,
3660 and it points to a chain of other variants so that duplicate
3661 variants are never made. Only main variants should ever appear as
3662 types of expressions. */
3665 build_qualified_type (type, type_quals)
3671 /* Search the chain of variants to see if there is already one there just
3672 like the one we need to have. If so, use that existing one. We must
3673 preserve the TYPE_NAME, since there is code that depends on this. */
3675 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
3676 if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type))
3679 /* We need a new one. */
3680 t = build_type_copy (type);
3681 set_type_quals (t, type_quals);
3685 /* Create a new variant of TYPE, equivalent but distinct.
3686 This is so the caller can modify it. */
3689 build_type_copy (type)
3692 register tree t, m = TYPE_MAIN_VARIANT (type);
3693 register struct obstack *ambient_obstack = current_obstack;
3695 current_obstack = TYPE_OBSTACK (type);
3696 t = copy_node (type);
3697 current_obstack = ambient_obstack;
3699 TYPE_POINTER_TO (t) = 0;
3700 TYPE_REFERENCE_TO (t) = 0;
3702 /* Add this type to the chain of variants of TYPE. */
3703 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
3704 TYPE_NEXT_VARIANT (m) = t;
3709 /* Hashing of types so that we don't make duplicates.
3710 The entry point is `type_hash_canon'. */
3712 /* Each hash table slot is a bucket containing a chain
3713 of these structures. */
3717 struct type_hash *next; /* Next structure in the bucket. */
3718 int hashcode; /* Hash code of this type. */
3719 tree type; /* The type recorded here. */
3722 /* Now here is the hash table. When recording a type, it is added
3723 to the slot whose index is the hash code mod the table size.
3724 Note that the hash table is used for several kinds of types
3725 (function types, array types and array index range types, for now).
3726 While all these live in the same table, they are completely independent,
3727 and the hash code is computed differently for each of these. */
3729 #define TYPE_HASH_SIZE 59
3730 struct type_hash *type_hash_table[TYPE_HASH_SIZE];
3732 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
3733 with types in the TREE_VALUE slots), by adding the hash codes
3734 of the individual types. */
3737 type_hash_list (list)
3740 register int hashcode;
3742 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3743 hashcode += TYPE_HASH (TREE_VALUE (tail));
3747 /* Look in the type hash table for a type isomorphic to TYPE.
3748 If one is found, return it. Otherwise return 0. */
3751 type_hash_lookup (hashcode, type)
3755 register struct type_hash *h;
3756 for (h = type_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
3757 if (h->hashcode == hashcode
3758 && TREE_CODE (h->type) == TREE_CODE (type)
3759 && TREE_TYPE (h->type) == TREE_TYPE (type)
3760 && attribute_list_equal (TYPE_ATTRIBUTES (h->type),
3761 TYPE_ATTRIBUTES (type))
3762 && (TYPE_MAX_VALUE (h->type) == TYPE_MAX_VALUE (type)
3763 || tree_int_cst_equal (TYPE_MAX_VALUE (h->type),
3764 TYPE_MAX_VALUE (type)))
3765 && (TYPE_MIN_VALUE (h->type) == TYPE_MIN_VALUE (type)
3766 || tree_int_cst_equal (TYPE_MIN_VALUE (h->type),
3767 TYPE_MIN_VALUE (type)))
3768 /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE. */
3769 && (TYPE_DOMAIN (h->type) == TYPE_DOMAIN (type)
3770 || (TYPE_DOMAIN (h->type)
3771 && TREE_CODE (TYPE_DOMAIN (h->type)) == TREE_LIST
3772 && TYPE_DOMAIN (type)
3773 && TREE_CODE (TYPE_DOMAIN (type)) == TREE_LIST
3774 && type_list_equal (TYPE_DOMAIN (h->type),
3775 TYPE_DOMAIN (type)))))
3780 /* Add an entry to the type-hash-table
3781 for a type TYPE whose hash code is HASHCODE. */
3784 type_hash_add (hashcode, type)
3788 register struct type_hash *h;
3790 h = (struct type_hash *) oballoc (sizeof (struct type_hash));
3791 h->hashcode = hashcode;
3793 h->next = type_hash_table[hashcode % TYPE_HASH_SIZE];
3794 type_hash_table[hashcode % TYPE_HASH_SIZE] = h;
3797 /* Given TYPE, and HASHCODE its hash code, return the canonical
3798 object for an identical type if one already exists.
3799 Otherwise, return TYPE, and record it as the canonical object
3800 if it is a permanent object.
3802 To use this function, first create a type of the sort you want.
3803 Then compute its hash code from the fields of the type that
3804 make it different from other similar types.
3805 Then call this function and use the value.
3806 This function frees the type you pass in if it is a duplicate. */
3808 /* Set to 1 to debug without canonicalization. Never set by program. */
3809 int debug_no_type_hash = 0;
3812 type_hash_canon (hashcode, type)
3818 if (debug_no_type_hash)
3821 t1 = type_hash_lookup (hashcode, type);
3824 obstack_free (TYPE_OBSTACK (type), type);
3825 #ifdef GATHER_STATISTICS
3826 tree_node_counts[(int)t_kind]--;
3827 tree_node_sizes[(int)t_kind] -= sizeof (struct tree_type);
3832 /* If this is a permanent type, record it for later reuse. */
3833 if (TREE_PERMANENT (type))
3834 type_hash_add (hashcode, type);
3839 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
3840 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
3841 by adding the hash codes of the individual attributes. */
3844 attribute_hash_list (list)
3847 register int hashcode;
3849 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3850 /* ??? Do we want to add in TREE_VALUE too? */
3851 hashcode += TYPE_HASH (TREE_PURPOSE (tail));
3855 /* Given two lists of attributes, return true if list l2 is
3856 equivalent to l1. */
3859 attribute_list_equal (l1, l2)
3862 return attribute_list_contained (l1, l2)
3863 && attribute_list_contained (l2, l1);
3866 /* Given two lists of attributes, return true if list L2 is
3867 completely contained within L1. */
3868 /* ??? This would be faster if attribute names were stored in a canonicalized
3869 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
3870 must be used to show these elements are equivalent (which they are). */
3871 /* ??? It's not clear that attributes with arguments will always be handled
3875 attribute_list_contained (l1, l2)
3878 register tree t1, t2;
3880 /* First check the obvious, maybe the lists are identical. */
3884 /* Maybe the lists are similar. */
3885 for (t1 = l1, t2 = l2;
3887 && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
3888 && TREE_VALUE (t1) == TREE_VALUE (t2);
3889 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
3891 /* Maybe the lists are equal. */
3892 if (t1 == 0 && t2 == 0)
3895 for (; t2; t2 = TREE_CHAIN (t2))
3898 = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
3900 if (attr == NULL_TREE)
3902 if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1)
3909 /* Given two lists of types
3910 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
3911 return 1 if the lists contain the same types in the same order.
3912 Also, the TREE_PURPOSEs must match. */
3915 type_list_equal (l1, l2)
3918 register tree t1, t2;
3920 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
3921 if (TREE_VALUE (t1) != TREE_VALUE (t2)
3922 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
3923 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
3924 && (TREE_TYPE (TREE_PURPOSE (t1))
3925 == TREE_TYPE (TREE_PURPOSE (t2))))))
3931 /* Nonzero if integer constants T1 and T2
3932 represent the same constant value. */
3935 tree_int_cst_equal (t1, t2)
3940 if (t1 == 0 || t2 == 0)
3942 if (TREE_CODE (t1) == INTEGER_CST
3943 && TREE_CODE (t2) == INTEGER_CST
3944 && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3945 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
3950 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
3951 The precise way of comparison depends on their data type. */
3954 tree_int_cst_lt (t1, t2)
3960 if (!TREE_UNSIGNED (TREE_TYPE (t1)))
3961 return INT_CST_LT (t1, t2);
3962 return INT_CST_LT_UNSIGNED (t1, t2);
3965 /* Return an indication of the sign of the integer constant T.
3966 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3967 Note that -1 will never be returned it T's type is unsigned. */
3970 tree_int_cst_sgn (t)
3973 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
3975 else if (TREE_UNSIGNED (TREE_TYPE (t)))
3977 else if (TREE_INT_CST_HIGH (t) < 0)
3983 /* Compare two constructor-element-type constants. Return 1 if the lists
3984 are known to be equal; otherwise return 0. */
3987 simple_cst_list_equal (l1, l2)
3990 while (l1 != NULL_TREE && l2 != NULL_TREE)
3992 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
3995 l1 = TREE_CHAIN (l1);
3996 l2 = TREE_CHAIN (l2);
4002 /* Return truthvalue of whether T1 is the same tree structure as T2.
4003 Return 1 if they are the same.
4004 Return 0 if they are understandably different.
4005 Return -1 if either contains tree structure not understood by
4009 simple_cst_equal (t1, t2)
4012 register enum tree_code code1, code2;
4017 if (t1 == 0 || t2 == 0)
4020 code1 = TREE_CODE (t1);
4021 code2 = TREE_CODE (t2);
4023 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
4025 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
4026 || code2 == NON_LVALUE_EXPR)
4027 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4029 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
4031 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
4032 || code2 == NON_LVALUE_EXPR)
4033 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
4041 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
4042 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
4045 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
4048 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
4049 && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
4050 TREE_STRING_LENGTH (t1));
4053 if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2))
4059 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4062 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4065 return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
4068 /* Special case: if either target is an unallocated VAR_DECL,
4069 it means that it's going to be unified with whatever the
4070 TARGET_EXPR is really supposed to initialize, so treat it
4071 as being equivalent to anything. */
4072 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
4073 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
4074 && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
4075 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
4076 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
4077 && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
4080 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4083 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
4085 case WITH_CLEANUP_EXPR:
4086 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4089 return simple_cst_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2));
4092 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
4093 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4106 /* This general rule works for most tree codes. All exceptions should be
4107 handled above. If this is a language-specific tree code, we can't
4108 trust what might be in the operand, so say we don't know
4110 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
4113 switch (TREE_CODE_CLASS (code1))
4123 for (i=0; i<tree_code_length[(int) code1]; ++i)
4125 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
4136 /* Constructors for pointer, array and function types.
4137 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
4138 constructed by language-dependent code, not here.) */
4140 /* Construct, lay out and return the type of pointers to TO_TYPE.
4141 If such a type has already been constructed, reuse it. */
4144 build_pointer_type (to_type)
4147 register tree t = TYPE_POINTER_TO (to_type);
4149 /* First, if we already have a type for pointers to TO_TYPE, use it. */
4154 /* We need a new one. Put this in the same obstack as TO_TYPE. */
4155 push_obstacks (TYPE_OBSTACK (to_type), TYPE_OBSTACK (to_type));
4156 t = make_node (POINTER_TYPE);
4159 TREE_TYPE (t) = to_type;
4161 /* Record this type as the pointer to TO_TYPE. */
4162 TYPE_POINTER_TO (to_type) = t;
4164 /* Lay out the type. This function has many callers that are concerned
4165 with expression-construction, and this simplifies them all.
4166 Also, it guarantees the TYPE_SIZE is in the same obstack as the type. */
4172 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
4173 MAXVAL should be the maximum value in the domain
4174 (one less than the length of the array).
4176 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
4177 We don't enforce this limit, that is up to caller (e.g. language front end).
4178 The limit exists because the result is a signed type and we don't handle
4179 sizes that use more than one HOST_WIDE_INT. */
4182 build_index_type (maxval)
4185 register tree itype = make_node (INTEGER_TYPE);
4187 TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
4188 TYPE_MIN_VALUE (itype) = size_zero_node;
4190 push_obstacks (TYPE_OBSTACK (itype), TYPE_OBSTACK (itype));
4191 TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
4194 TYPE_MODE (itype) = TYPE_MODE (sizetype);
4195 TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
4196 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
4197 TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
4198 if (TREE_CODE (maxval) == INTEGER_CST)
4200 int maxint = (int) TREE_INT_CST_LOW (maxval);
4201 /* If the domain should be empty, make sure the maxval
4202 remains -1 and is not spoiled by truncation. */
4203 if (INT_CST_LT (maxval, integer_zero_node))
4205 TYPE_MAX_VALUE (itype) = build_int_2 (-1, -1);
4206 TREE_TYPE (TYPE_MAX_VALUE (itype)) = sizetype;
4208 return type_hash_canon (maxint < 0 ? ~maxint : maxint, itype);
4214 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
4215 ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
4216 low bound LOWVAL and high bound HIGHVAL.
4217 if TYPE==NULL_TREE, sizetype is used. */
4220 build_range_type (type, lowval, highval)
4221 tree type, lowval, highval;
4223 register tree itype = make_node (INTEGER_TYPE);
4225 TREE_TYPE (itype) = type;
4226 if (type == NULL_TREE)
4229 push_obstacks (TYPE_OBSTACK (itype), TYPE_OBSTACK (itype));
4230 TYPE_MIN_VALUE (itype) = convert (type, lowval);
4231 TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
4234 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
4235 TYPE_MODE (itype) = TYPE_MODE (type);
4236 TYPE_SIZE (itype) = TYPE_SIZE (type);
4237 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
4238 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
4239 if (TREE_CODE (lowval) == INTEGER_CST)
4241 HOST_WIDE_INT lowint, highint;
4244 lowint = TREE_INT_CST_LOW (lowval);
4245 if (highval && TREE_CODE (highval) == INTEGER_CST)
4246 highint = TREE_INT_CST_LOW (highval);
4248 highint = (~(unsigned HOST_WIDE_INT)0) >> 1;
4250 maxint = (int) (highint - lowint);
4251 return type_hash_canon (maxint < 0 ? ~maxint : maxint, itype);
4257 /* Just like build_index_type, but takes lowval and highval instead
4258 of just highval (maxval). */
4261 build_index_2_type (lowval,highval)
4262 tree lowval, highval;
4264 return build_range_type (NULL_TREE, lowval, highval);
4267 /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense).
4268 Needed because when index types are not hashed, equal index types
4269 built at different times appear distinct, even though structurally,
4273 index_type_equal (itype1, itype2)
4274 tree itype1, itype2;
4276 if (TREE_CODE (itype1) != TREE_CODE (itype2))
4278 if (TREE_CODE (itype1) == INTEGER_TYPE)
4280 if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2)
4281 || TYPE_MODE (itype1) != TYPE_MODE (itype2)
4282 || simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2)) != 1
4283 || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2))
4285 if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1),
4286 TYPE_MIN_VALUE (itype2))
4287 && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1),
4288 TYPE_MAX_VALUE (itype2)))
4295 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
4296 and number of elements specified by the range of values of INDEX_TYPE.
4297 If such a type has already been constructed, reuse it. */
4300 build_array_type (elt_type, index_type)
4301 tree elt_type, index_type;
4306 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
4308 error ("arrays of functions are not meaningful");
4309 elt_type = integer_type_node;
4312 /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
4313 build_pointer_type (elt_type);
4315 /* Allocate the array after the pointer type,
4316 in case we free it in type_hash_canon. */
4317 t = make_node (ARRAY_TYPE);
4318 TREE_TYPE (t) = elt_type;
4319 TYPE_DOMAIN (t) = index_type;
4321 if (index_type == 0)
4326 hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
4327 t = type_hash_canon (hashcode, t);
4329 if (TYPE_SIZE (t) == 0)
4334 /* Return the TYPE of the elements comprising
4335 the innermost dimension of ARRAY. */
4338 get_inner_array_type (array)
4341 tree type = TREE_TYPE (array);
4343 while (TREE_CODE (type) == ARRAY_TYPE)
4344 type = TREE_TYPE (type);
4349 /* Construct, lay out and return
4350 the type of functions returning type VALUE_TYPE
4351 given arguments of types ARG_TYPES.
4352 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
4353 are data type nodes for the arguments of the function.
4354 If such a type has already been constructed, reuse it. */
4357 build_function_type (value_type, arg_types)
4358 tree value_type, arg_types;
4363 if (TREE_CODE (value_type) == FUNCTION_TYPE)
4365 error ("function return type cannot be function");
4366 value_type = integer_type_node;
4369 /* Make a node of the sort we want. */
4370 t = make_node (FUNCTION_TYPE);
4371 TREE_TYPE (t) = value_type;
4372 TYPE_ARG_TYPES (t) = arg_types;
4374 /* If we already have such a type, use the old one and free this one. */
4375 hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
4376 t = type_hash_canon (hashcode, t);
4378 if (TYPE_SIZE (t) == 0)
4383 /* Build the node for the type of references-to-TO_TYPE. */
4386 build_reference_type (to_type)
4389 register tree t = TYPE_REFERENCE_TO (to_type);
4391 /* First, if we already have a type for pointers to TO_TYPE, use it. */
4396 /* We need a new one. Put this in the same obstack as TO_TYPE. */
4397 push_obstacks (TYPE_OBSTACK (to_type), TYPE_OBSTACK (to_type));
4398 t = make_node (REFERENCE_TYPE);
4401 TREE_TYPE (t) = to_type;
4403 /* Record this type as the pointer to TO_TYPE. */
4404 TYPE_REFERENCE_TO (to_type) = t;
4411 /* Construct, lay out and return the type of methods belonging to class
4412 BASETYPE and whose arguments and values are described by TYPE.
4413 If that type exists already, reuse it.
4414 TYPE must be a FUNCTION_TYPE node. */
4417 build_method_type (basetype, type)
4418 tree basetype, type;
4423 /* Make a node of the sort we want. */
4424 t = make_node (METHOD_TYPE);
4426 if (TREE_CODE (type) != FUNCTION_TYPE)
4429 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
4430 TREE_TYPE (t) = TREE_TYPE (type);
4432 /* The actual arglist for this function includes a "hidden" argument
4433 which is "this". Put it into the list of argument types. */
4436 = tree_cons (NULL_TREE,
4437 build_pointer_type (basetype), TYPE_ARG_TYPES (type));
4439 /* If we already have such a type, use the old one and free this one. */
4440 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
4441 t = type_hash_canon (hashcode, t);
4443 if (TYPE_SIZE (t) == 0)
4449 /* Construct, lay out and return the type of offsets to a value
4450 of type TYPE, within an object of type BASETYPE.
4451 If a suitable offset type exists already, reuse it. */
4454 build_offset_type (basetype, type)
4455 tree basetype, type;
4460 /* Make a node of the sort we want. */
4461 t = make_node (OFFSET_TYPE);
4463 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
4464 TREE_TYPE (t) = type;
4466 /* If we already have such a type, use the old one and free this one. */
4467 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
4468 t = type_hash_canon (hashcode, t);
4470 if (TYPE_SIZE (t) == 0)
4476 /* Create a complex type whose components are COMPONENT_TYPE. */
4479 build_complex_type (component_type)
4480 tree component_type;
4485 /* Make a node of the sort we want. */
4486 t = make_node (COMPLEX_TYPE);
4488 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
4489 set_type_quals (t, TYPE_QUALS (component_type));
4491 /* If we already have such a type, use the old one and free this one. */
4492 hashcode = TYPE_HASH (component_type);
4493 t = type_hash_canon (hashcode, t);
4495 if (TYPE_SIZE (t) == 0)
4501 /* Return OP, stripped of any conversions to wider types as much as is safe.
4502 Converting the value back to OP's type makes a value equivalent to OP.
4504 If FOR_TYPE is nonzero, we return a value which, if converted to
4505 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
4507 If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
4508 narrowest type that can hold the value, even if they don't exactly fit.
4509 Otherwise, bit-field references are changed to a narrower type
4510 only if they can be fetched directly from memory in that type.
4512 OP must have integer, real or enumeral type. Pointers are not allowed!
4514 There are some cases where the obvious value we could return
4515 would regenerate to OP if converted to OP's type,
4516 but would not extend like OP to wider types.
4517 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
4518 For example, if OP is (unsigned short)(signed char)-1,
4519 we avoid returning (signed char)-1 if FOR_TYPE is int,
4520 even though extending that to an unsigned short would regenerate OP,
4521 since the result of extending (signed char)-1 to (int)
4522 is different from (int) OP. */
4525 get_unwidened (op, for_type)
4529 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
4530 register tree type = TREE_TYPE (op);
4531 register unsigned final_prec
4532 = TYPE_PRECISION (for_type != 0 ? for_type : type);
4534 = (for_type != 0 && for_type != type
4535 && final_prec > TYPE_PRECISION (type)
4536 && TREE_UNSIGNED (type));
4537 register tree win = op;
4539 while (TREE_CODE (op) == NOP_EXPR)
4541 register int bitschange
4542 = TYPE_PRECISION (TREE_TYPE (op))
4543 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
4545 /* Truncations are many-one so cannot be removed.
4546 Unless we are later going to truncate down even farther. */
4548 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
4551 /* See what's inside this conversion. If we decide to strip it,
4553 op = TREE_OPERAND (op, 0);
4555 /* If we have not stripped any zero-extensions (uns is 0),
4556 we can strip any kind of extension.
4557 If we have previously stripped a zero-extension,
4558 only zero-extensions can safely be stripped.
4559 Any extension can be stripped if the bits it would produce
4560 are all going to be discarded later by truncating to FOR_TYPE. */
4564 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
4566 /* TREE_UNSIGNED says whether this is a zero-extension.
4567 Let's avoid computing it if it does not affect WIN
4568 and if UNS will not be needed again. */
4569 if ((uns || TREE_CODE (op) == NOP_EXPR)
4570 && TREE_UNSIGNED (TREE_TYPE (op)))
4578 if (TREE_CODE (op) == COMPONENT_REF
4579 /* Since type_for_size always gives an integer type. */
4580 && TREE_CODE (type) != REAL_TYPE
4581 /* Don't crash if field not laid out yet. */
4582 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
4584 unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
4585 type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1)));
4587 /* We can get this structure field in the narrowest type it fits in.
4588 If FOR_TYPE is 0, do this only for a field that matches the
4589 narrower type exactly and is aligned for it
4590 The resulting extension to its nominal type (a fullword type)
4591 must fit the same conditions as for other extensions. */
4593 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4594 && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
4595 && (! uns || final_prec <= innerprec
4596 || TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4599 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4600 TREE_OPERAND (op, 1));
4601 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4602 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4603 TREE_RAISES (win) = TREE_RAISES (op);
4609 /* Return OP or a simpler expression for a narrower value
4610 which can be sign-extended or zero-extended to give back OP.
4611 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4612 or 0 if the value should be sign-extended. */
4615 get_narrower (op, unsignedp_ptr)
4619 register int uns = 0;
4621 register tree win = op;
4623 while (TREE_CODE (op) == NOP_EXPR)
4625 register int bitschange
4626 = TYPE_PRECISION (TREE_TYPE (op))
4627 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
4629 /* Truncations are many-one so cannot be removed. */
4633 /* See what's inside this conversion. If we decide to strip it,
4635 op = TREE_OPERAND (op, 0);
4639 /* An extension: the outermost one can be stripped,
4640 but remember whether it is zero or sign extension. */
4642 uns = TREE_UNSIGNED (TREE_TYPE (op));
4643 /* Otherwise, if a sign extension has been stripped,
4644 only sign extensions can now be stripped;
4645 if a zero extension has been stripped, only zero-extensions. */
4646 else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
4650 else /* bitschange == 0 */
4652 /* A change in nominal type can always be stripped, but we must
4653 preserve the unsignedness. */
4655 uns = TREE_UNSIGNED (TREE_TYPE (op));
4662 if (TREE_CODE (op) == COMPONENT_REF
4663 /* Since type_for_size always gives an integer type. */
4664 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE)
4666 unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
4667 tree type = type_for_size (innerprec, TREE_UNSIGNED (op));
4669 /* We can get this structure field in a narrower type that fits it,
4670 but the resulting extension to its nominal type (a fullword type)
4671 must satisfy the same conditions as for other extensions.
4673 Do this only for fields that are aligned (not bit-fields),
4674 because when bit-field insns will be used there is no
4675 advantage in doing this. */
4677 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4678 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
4679 && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4683 uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4684 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4685 TREE_OPERAND (op, 1));
4686 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4687 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4688 TREE_RAISES (win) = TREE_RAISES (op);
4691 *unsignedp_ptr = uns;
4695 /* Nonzero if integer constant C has a value that is permissible
4696 for type TYPE (an INTEGER_TYPE). */
4699 int_fits_type_p (c, type)
4702 if (TREE_UNSIGNED (type))
4703 return (! (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
4704 && INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c))
4705 && ! (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
4706 && INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type)))
4707 /* Negative ints never fit unsigned types. */
4708 && ! (TREE_INT_CST_HIGH (c) < 0
4709 && ! TREE_UNSIGNED (TREE_TYPE (c))));
4711 return (! (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
4712 && INT_CST_LT (TYPE_MAX_VALUE (type), c))
4713 && ! (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
4714 && INT_CST_LT (c, TYPE_MIN_VALUE (type)))
4715 /* Unsigned ints with top bit set never fit signed types. */
4716 && ! (TREE_INT_CST_HIGH (c) < 0
4717 && TREE_UNSIGNED (TREE_TYPE (c))));
4720 /* Return the innermost context enclosing DECL that is
4721 a FUNCTION_DECL, or zero if none. */
4724 decl_function_context (decl)
4729 if (TREE_CODE (decl) == ERROR_MARK)
4732 if (TREE_CODE (decl) == SAVE_EXPR)
4733 context = SAVE_EXPR_CONTEXT (decl);
4735 context = DECL_CONTEXT (decl);
4737 while (context && TREE_CODE (context) != FUNCTION_DECL)
4739 if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
4740 context = TYPE_CONTEXT (context);
4741 else if (TREE_CODE_CLASS (TREE_CODE (context)) == 'd')
4742 context = DECL_CONTEXT (context);
4743 else if (TREE_CODE (context) == BLOCK)
4744 context = BLOCK_SUPERCONTEXT (context);
4746 /* Unhandled CONTEXT !? */
4753 /* Return the innermost context enclosing DECL that is
4754 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4755 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
4758 decl_type_context (decl)
4761 tree context = DECL_CONTEXT (decl);
4765 if (TREE_CODE (context) == RECORD_TYPE
4766 || TREE_CODE (context) == UNION_TYPE
4767 || TREE_CODE (context) == QUAL_UNION_TYPE)
4769 if (TREE_CODE (context) == TYPE_DECL
4770 || TREE_CODE (context) == FUNCTION_DECL)
4771 context = DECL_CONTEXT (context);
4772 else if (TREE_CODE (context) == BLOCK)
4773 context = BLOCK_SUPERCONTEXT (context);
4775 /* Unhandled CONTEXT!? */
4781 /* Print debugging information about the size of the
4782 toplev_inline_obstacks. */
4785 print_inline_obstack_statistics ()
4787 struct simple_obstack_stack *current = toplev_inline_obstacks;
4792 for (; current; current = current->next, ++n_obstacks)
4794 struct obstack *o = current->obstack;
4795 struct _obstack_chunk *chunk = o->chunk;
4797 n_alloc += o->next_free - chunk->contents;
4798 chunk = chunk->prev;
4800 for (; chunk; chunk = chunk->prev, ++n_chunks)
4801 n_alloc += chunk->limit - &chunk->contents[0];
4803 fprintf (stderr, "inline obstacks: %d obstacks, %d bytes, %d chunks\n",
4804 n_obstacks, n_alloc, n_chunks);
4807 /* Print debugging information about the obstack O, named STR. */
4810 print_obstack_statistics (str, o)
4814 struct _obstack_chunk *chunk = o->chunk;
4818 n_alloc += o->next_free - chunk->contents;
4819 chunk = chunk->prev;
4823 n_alloc += chunk->limit - &chunk->contents[0];
4824 chunk = chunk->prev;
4826 fprintf (stderr, "obstack %s: %u bytes, %d chunks\n",
4827 str, n_alloc, n_chunks);
4830 /* Print debugging information about tree nodes generated during the compile,
4831 and any language-specific information. */
4834 dump_tree_statistics ()
4836 #ifdef GATHER_STATISTICS
4838 int total_nodes, total_bytes;
4841 fprintf (stderr, "\n??? tree nodes created\n\n");
4842 #ifdef GATHER_STATISTICS
4843 fprintf (stderr, "Kind Nodes Bytes\n");
4844 fprintf (stderr, "-------------------------------------\n");
4845 total_nodes = total_bytes = 0;
4846 for (i = 0; i < (int) all_kinds; i++)
4848 fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
4849 tree_node_counts[i], tree_node_sizes[i]);
4850 total_nodes += tree_node_counts[i];
4851 total_bytes += tree_node_sizes[i];
4853 fprintf (stderr, "%-20s %9d\n", "identifier names", id_string_size);
4854 fprintf (stderr, "-------------------------------------\n");
4855 fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
4856 fprintf (stderr, "-------------------------------------\n");
4858 fprintf (stderr, "(No per-node statistics)\n");
4860 print_obstack_statistics ("permanent_obstack", &permanent_obstack);
4861 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack);
4862 print_obstack_statistics ("temporary_obstack", &temporary_obstack);
4863 print_obstack_statistics ("momentary_obstack", &momentary_obstack);
4864 print_obstack_statistics ("temp_decl_obstack", &temp_decl_obstack);
4865 print_inline_obstack_statistics ();
4866 print_lang_statistics ();
4869 #define FILE_FUNCTION_PREFIX_LEN 9
4871 #ifndef NO_DOLLAR_IN_LABEL
4872 #define FILE_FUNCTION_FORMAT "_GLOBAL_$%s$%s"
4873 #else /* NO_DOLLAR_IN_LABEL */
4874 #ifndef NO_DOT_IN_LABEL
4875 #define FILE_FUNCTION_FORMAT "_GLOBAL_.%s.%s"
4876 #else /* NO_DOT_IN_LABEL */
4877 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4878 #endif /* NO_DOT_IN_LABEL */
4879 #endif /* NO_DOLLAR_IN_LABEL */
4881 extern char * first_global_object_name;
4882 extern char * weak_global_object_name;
4884 /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name
4885 clashes in cases where we can't reliably choose a unique name.
4887 Derived from mkstemp.c in libiberty. */
4890 append_random_chars (template)
4893 static const char letters[]
4894 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
4895 static unsigned HOST_WIDE_INT value;
4896 unsigned HOST_WIDE_INT v;
4898 #ifdef HAVE_GETTIMEOFDAY
4902 template += strlen (template);
4904 #ifdef HAVE_GETTIMEOFDAY
4905 /* Get some more or less random data. */
4906 gettimeofday (&tv, NULL);
4907 value += ((unsigned HOST_WIDE_INT) tv.tv_usec << 16) ^ tv.tv_sec ^ getpid ();
4914 /* Fill in the random bits. */
4915 template[0] = letters[v % 62];
4917 template[1] = letters[v % 62];
4919 template[2] = letters[v % 62];
4921 template[3] = letters[v % 62];
4923 template[4] = letters[v % 62];
4925 template[5] = letters[v % 62];
4930 /* Generate a name for a function unique to this translation unit.
4931 TYPE is some string to identify the purpose of this function to the
4932 linker or collect2. */
4935 get_file_function_name_long (type)
4941 if (first_global_object_name)
4942 p = first_global_object_name;
4945 /* We don't have anything that we know to be unique to this translation
4946 unit, so use what we do have and throw in some randomness. */
4948 const char *name = weak_global_object_name;
4949 const char *file = main_input_filename;
4954 file = input_filename;
4956 p = (char *) alloca (7 + strlen (name) + strlen (file));
4958 sprintf (p, "%s%s", name, file);
4959 append_random_chars (p);
4962 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
4965 /* Set up the name of the file-level functions we may need. */
4966 /* Use a global object (which is already required to be unique over
4967 the program) rather than the file name (which imposes extra
4968 constraints). -- Raeburn@MIT.EDU, 10 Jan 1990. */
4969 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
4971 /* Don't need to pull weird characters out of global names. */
4972 if (p != first_global_object_name)
4974 for (p = buf+11; *p; p++)
4975 if (! ((*p >= '0' && *p <= '9')
4976 #if 0 /* we always want labels, which are valid C++ identifiers (+ `$') */
4977 #ifndef ASM_IDENTIFY_GCC /* this is required if `.' is invalid -- k. raeburn */
4981 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
4984 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
4987 || (*p >= 'A' && *p <= 'Z')
4988 || (*p >= 'a' && *p <= 'z')))
4992 return get_identifier (buf);
4995 /* If KIND=='I', return a suitable global initializer (constructor) name.
4996 If KIND=='D', return a suitable global clean-up (destructor) name. */
4999 get_file_function_name (kind)
5006 return get_file_function_name_long (p);
5010 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
5011 The result is placed in BUFFER (which has length BIT_SIZE),
5012 with one bit in each char ('\000' or '\001').
5014 If the constructor is constant, NULL_TREE is returned.
5015 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
5018 get_set_constructor_bits (init, buffer, bit_size)
5025 HOST_WIDE_INT domain_min
5026 = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))));
5027 tree non_const_bits = NULL_TREE;
5028 for (i = 0; i < bit_size; i++)
5031 for (vals = TREE_OPERAND (init, 1);
5032 vals != NULL_TREE; vals = TREE_CHAIN (vals))
5034 if (TREE_CODE (TREE_VALUE (vals)) != INTEGER_CST
5035 || (TREE_PURPOSE (vals) != NULL_TREE
5036 && TREE_CODE (TREE_PURPOSE (vals)) != INTEGER_CST))
5038 = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
5039 else if (TREE_PURPOSE (vals) != NULL_TREE)
5041 /* Set a range of bits to ones. */
5042 HOST_WIDE_INT lo_index
5043 = TREE_INT_CST_LOW (TREE_PURPOSE (vals)) - domain_min;
5044 HOST_WIDE_INT hi_index
5045 = TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min;
5046 if (lo_index < 0 || lo_index >= bit_size
5047 || hi_index < 0 || hi_index >= bit_size)
5049 for ( ; lo_index <= hi_index; lo_index++)
5050 buffer[lo_index] = 1;
5054 /* Set a single bit to one. */
5056 = TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min;
5057 if (index < 0 || index >= bit_size)
5059 error ("invalid initializer for bit string");
5065 return non_const_bits;
5068 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
5069 The result is placed in BUFFER (which is an array of bytes).
5070 If the constructor is constant, NULL_TREE is returned.
5071 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
5074 get_set_constructor_bytes (init, buffer, wd_size)
5076 unsigned char *buffer;
5080 int set_word_size = BITS_PER_UNIT;
5081 int bit_size = wd_size * set_word_size;
5083 unsigned char *bytep = buffer;
5084 char *bit_buffer = (char *) alloca(bit_size);
5085 tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
5087 for (i = 0; i < wd_size; i++)
5090 for (i = 0; i < bit_size; i++)
5094 if (BYTES_BIG_ENDIAN)
5095 *bytep |= (1 << (set_word_size - 1 - bit_pos));
5097 *bytep |= 1 << bit_pos;
5100 if (bit_pos >= set_word_size)
5101 bit_pos = 0, bytep++;
5103 return non_const_bits;
5106 #ifdef ENABLE_CHECKING
5108 /* Complain if the tree code does not match the expected one.
5109 NODE is the tree node in question, CODE is the expected tree code,
5110 and FILE and LINE are the filename and line number, respectively,
5111 of the line on which the check was done. If NONFATAL is nonzero,
5112 don't abort if the reference is invalid; instead, return 0.
5113 If the reference is valid, return NODE. */
5116 tree_check (node, code, file, line, nofatal)
5118 enum tree_code code;
5123 if (TREE_CODE (node) == code)
5128 fatal ("%s:%d: Expect %s, have %s\n", file, line,
5129 tree_code_name[code], tree_code_name[TREE_CODE (node)]);
5132 /* Similar to above, except that we check for a class of tree
5133 code, given in CL. */
5136 tree_class_check (node, cl, file, line, nofatal)
5143 if (TREE_CODE_CLASS (TREE_CODE (node)) == cl)
5148 fatal ("%s:%d: Expect '%c', have '%s'\n", file, line,
5149 cl, tree_code_name[TREE_CODE (node)]);
5152 /* Likewise, but complain if the tree node is not an expression. */
5155 expr_check (node, ignored, file, line, nofatal)
5162 switch (TREE_CODE_CLASS (TREE_CODE (node)))
5176 fatal ("%s:%d: Expect expression, have '%s'\n", file, line,
5177 tree_code_name[TREE_CODE (node)]);
5184 /* Return the alias set for T, which may be either a type or an
5191 if (!flag_strict_aliasing || !lang_get_alias_set)
5192 /* If we're not doing any lanaguage-specific alias analysis, just
5193 assume everything aliases everything else. */
5196 return (*lang_get_alias_set) (t);
5199 /* Return a brand-new alias set. */
5204 static int last_alias_set;
5205 if (flag_strict_aliasing)
5206 return ++last_alias_set;