1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 88, 92-98, 1999 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* This file contains the low level primitives for operating on tree nodes,
23 including allocation, list operations, interning of identifiers,
24 construction of data type nodes and statement nodes,
25 and construction of type conversion nodes. It also contains
26 tables index by tree code that describe how to take apart
29 It is intended to be language-independent, but occasionally
30 calls language-dependent routines defined (for C) in typecheck.c.
32 The low-level allocation routines oballoc and permalloc
33 are used also for allocating many other kinds of objects
34 by all passes of the compiler. */
44 #define obstack_chunk_alloc xmalloc
45 #define obstack_chunk_free free
46 /* obstack.[ch] explicitly declined to prototype this. */
47 extern int _obstack_allocated_p PROTO ((struct obstack *h, GENERIC_PTR obj));
49 /* Tree nodes of permanent duration are allocated in this obstack.
50 They are the identifier nodes, and everything outside of
51 the bodies and parameters of function definitions. */
53 struct obstack permanent_obstack;
55 /* The initial RTL, and all ..._TYPE nodes, in a function
56 are allocated in this obstack. Usually they are freed at the
57 end of the function, but if the function is inline they are saved.
58 For top-level functions, this is maybepermanent_obstack.
59 Separate obstacks are made for nested functions. */
61 struct obstack *function_maybepermanent_obstack;
63 /* This is the function_maybepermanent_obstack for top-level functions. */
65 struct obstack maybepermanent_obstack;
67 /* This is a list of function_maybepermanent_obstacks for top-level inline
68 functions that are compiled in the middle of compiling other functions. */
70 struct simple_obstack_stack *toplev_inline_obstacks;
72 /* Former elements of toplev_inline_obstacks that have been recycled. */
74 struct simple_obstack_stack *extra_inline_obstacks;
76 /* This is a list of function_maybepermanent_obstacks for inline functions
77 nested in the current function that were compiled in the middle of
78 compiling other functions. */
80 struct simple_obstack_stack *inline_obstacks;
82 /* The contents of the current function definition are allocated
83 in this obstack, and all are freed at the end of the function.
84 For top-level functions, this is temporary_obstack.
85 Separate obstacks are made for nested functions. */
87 struct obstack *function_obstack;
89 /* This is used for reading initializers of global variables. */
91 struct obstack temporary_obstack;
93 /* The tree nodes of an expression are allocated
94 in this obstack, and all are freed at the end of the expression. */
96 struct obstack momentary_obstack;
98 /* The tree nodes of a declarator are allocated
99 in this obstack, and all are freed when the declarator
102 static struct obstack temp_decl_obstack;
104 /* This points at either permanent_obstack
105 or the current function_maybepermanent_obstack. */
107 struct obstack *saveable_obstack;
109 /* This is same as saveable_obstack during parse and expansion phase;
110 it points to the current function's obstack during optimization.
111 This is the obstack to be used for creating rtl objects. */
113 struct obstack *rtl_obstack;
115 /* This points at either permanent_obstack or the current function_obstack. */
117 struct obstack *current_obstack;
119 /* This points at either permanent_obstack or the current function_obstack
120 or momentary_obstack. */
122 struct obstack *expression_obstack;
124 /* Stack of obstack selections for push_obstacks and pop_obstacks. */
128 struct obstack_stack *next;
129 struct obstack *current;
130 struct obstack *saveable;
131 struct obstack *expression;
135 struct obstack_stack *obstack_stack;
137 /* Obstack for allocating struct obstack_stack entries. */
139 static struct obstack obstack_stack_obstack;
141 /* Addresses of first objects in some obstacks.
142 This is for freeing their entire contents. */
143 char *maybepermanent_firstobj;
144 char *temporary_firstobj;
145 char *momentary_firstobj;
146 char *temp_decl_firstobj;
148 /* This is used to preserve objects (mainly array initializers) that need to
149 live until the end of the current function, but no further. */
150 char *momentary_function_firstobj;
152 /* Nonzero means all ..._TYPE nodes should be allocated permanently. */
154 int all_types_permanent;
156 /* Stack of places to restore the momentary obstack back to. */
158 struct momentary_level
160 /* Pointer back to previous such level. */
161 struct momentary_level *prev;
162 /* First object allocated within this level. */
164 /* Value of expression_obstack saved at entry to this level. */
165 struct obstack *obstack;
168 struct momentary_level *momentary_stack;
170 /* Table indexed by tree code giving a string containing a character
171 classifying the tree code. Possibilities are
172 t, d, s, c, r, <, 1, 2 and e. See tree.def for details. */
174 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
176 char tree_code_type[MAX_TREE_CODES] = {
181 /* Table indexed by tree code giving number of expression
182 operands beyond the fixed part of the node structure.
183 Not used for types or decls. */
185 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
187 int tree_code_length[MAX_TREE_CODES] = {
192 /* Names of tree components.
193 Used for printing out the tree and error messages. */
194 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
196 char *tree_code_name[MAX_TREE_CODES] = {
201 /* Statistics-gathering stuff. */
222 int tree_node_counts[(int)all_kinds];
223 int tree_node_sizes[(int)all_kinds];
224 int id_string_size = 0;
226 const char *tree_node_kind_names[] = {
244 /* Hash table for uniquizing IDENTIFIER_NODEs by name. */
246 #define MAX_HASH_TABLE 1009
247 static tree hash_table[MAX_HASH_TABLE]; /* id hash buckets */
249 /* 0 while creating built-in identifiers. */
250 static int do_identifier_warnings;
252 /* Unique id for next decl created. */
253 static int next_decl_uid;
254 /* Unique id for next type created. */
255 static int next_type_uid = 1;
257 /* The language-specific function for alias analysis. If NULL, the
258 language does not do any special alias analysis. */
259 int (*lang_get_alias_set) PROTO((tree));
261 /* Here is how primitive or already-canonicalized types' hash
263 #define TYPE_HASH(TYPE) ((unsigned long) (TYPE) & 0777777)
265 static void set_type_quals PROTO((tree, int));
266 static void append_random_chars PROTO((char *));
267 static void build_real_from_int_cst_1 PROTO((PTR));
269 void gcc_obstack_init ();
271 /* If non-null, a language specific helper for unsave_expr_now. */
273 int (*lang_unsave_expr_now) PROTO((tree));
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;
1130 /* Return a new node with the same contents as NODE
1131 except that its TREE_CHAIN is zero and it has a fresh uid. */
1138 register enum tree_code code = TREE_CODE (node);
1139 register int length = 0;
1141 switch (TREE_CODE_CLASS (code))
1143 case 'd': /* A decl node */
1144 length = sizeof (struct tree_decl);
1147 case 't': /* a type node */
1148 length = sizeof (struct tree_type);
1151 case 'b': /* a lexical block node */
1152 length = sizeof (struct tree_block);
1155 case 'r': /* a reference */
1156 case 'e': /* an expression */
1157 case 's': /* an expression with side effects */
1158 case '<': /* a comparison expression */
1159 case '1': /* a unary arithmetic expression */
1160 case '2': /* a binary arithmetic expression */
1161 length = sizeof (struct tree_exp)
1162 + (tree_code_length[(int) code] - 1) * sizeof (char *);
1165 case 'c': /* a constant */
1166 /* We can't use tree_code_length for INTEGER_CST, since the number of
1167 words is machine-dependent due to varying length of HOST_WIDE_INT,
1168 which might be wider than a pointer (e.g., long long). Similarly
1169 for REAL_CST, since the number of words is machine-dependent due
1170 to varying size and alignment of `double'. */
1171 if (code == INTEGER_CST)
1172 length = sizeof (struct tree_int_cst);
1173 else if (code == REAL_CST)
1174 length = sizeof (struct tree_real_cst);
1176 length = (sizeof (struct tree_common)
1177 + tree_code_length[(int) code] * sizeof (char *));
1180 case 'x': /* something random, like an identifier. */
1181 length = sizeof (struct tree_common)
1182 + tree_code_length[(int) code] * sizeof (char *);
1183 if (code == TREE_VEC)
1184 length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *);
1187 t = (tree) obstack_alloc (current_obstack, length);
1188 memcpy (t, node, length);
1190 /* EXPR_WITH_FILE_LOCATION must keep filename info stored in TREE_CHAIN */
1191 if (TREE_CODE (node) != EXPR_WITH_FILE_LOCATION)
1193 TREE_ASM_WRITTEN (t) = 0;
1195 if (TREE_CODE_CLASS (code) == 'd')
1196 DECL_UID (t) = next_decl_uid++;
1197 else if (TREE_CODE_CLASS (code) == 't')
1199 TYPE_UID (t) = next_type_uid++;
1200 TYPE_OBSTACK (t) = current_obstack;
1202 /* The following is so that the debug code for
1203 the copy is different from the original type.
1204 The two statements usually duplicate each other
1205 (because they clear fields of the same union),
1206 but the optimizer should catch that. */
1207 TYPE_SYMTAB_POINTER (t) = 0;
1208 TYPE_SYMTAB_ADDRESS (t) = 0;
1211 TREE_PERMANENT (t) = (current_obstack == &permanent_obstack);
1216 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1217 For example, this can copy a list made of TREE_LIST nodes. */
1224 register tree prev, next;
1229 head = prev = copy_node (list);
1230 next = TREE_CHAIN (list);
1233 TREE_CHAIN (prev) = copy_node (next);
1234 prev = TREE_CHAIN (prev);
1235 next = TREE_CHAIN (next);
1242 /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
1243 If an identifier with that name has previously been referred to,
1244 the same node is returned this time. */
1247 get_identifier (text)
1248 register const char *text;
1253 register int len, hash_len;
1255 /* Compute length of text in len. */
1256 len = strlen (text);
1258 /* Decide how much of that length to hash on */
1260 if (warn_id_clash && (unsigned)len > id_clash_len)
1261 hash_len = id_clash_len;
1263 /* Compute hash code */
1264 hi = hash_len * 613 + (unsigned) text[0];
1265 for (i = 1; i < hash_len; i += 2)
1266 hi = ((hi * 613) + (unsigned) (text[i]));
1268 hi &= (1 << HASHBITS) - 1;
1269 hi %= MAX_HASH_TABLE;
1271 /* Search table for identifier */
1272 for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
1273 if (IDENTIFIER_LENGTH (idp) == len
1274 && IDENTIFIER_POINTER (idp)[0] == text[0]
1275 && !bcmp (IDENTIFIER_POINTER (idp), text, len))
1276 return idp; /* <-- return if found */
1278 /* Not found; optionally warn about a similar identifier */
1279 if (warn_id_clash && do_identifier_warnings && (unsigned)len >= id_clash_len)
1280 for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
1281 if (!strncmp (IDENTIFIER_POINTER (idp), text, id_clash_len))
1283 warning ("`%s' and `%s' identical in first %d characters",
1284 IDENTIFIER_POINTER (idp), text, id_clash_len);
1288 if (tree_code_length[(int) IDENTIFIER_NODE] < 0)
1289 abort (); /* set_identifier_size hasn't been called. */
1291 /* Not found, create one, add to chain */
1292 idp = make_node (IDENTIFIER_NODE);
1293 IDENTIFIER_LENGTH (idp) = len;
1294 #ifdef GATHER_STATISTICS
1295 id_string_size += len;
1298 IDENTIFIER_POINTER (idp) = obstack_copy0 (&permanent_obstack, text, len);
1300 TREE_CHAIN (idp) = hash_table[hi];
1301 hash_table[hi] = idp;
1302 return idp; /* <-- return if created */
1305 /* If an identifier with the name TEXT (a null-terminated string) has
1306 previously been referred to, return that node; otherwise return
1310 maybe_get_identifier (text)
1311 register const char *text;
1316 register int len, hash_len;
1318 /* Compute length of text in len. */
1319 len = strlen (text);
1321 /* Decide how much of that length to hash on */
1323 if (warn_id_clash && (unsigned)len > id_clash_len)
1324 hash_len = id_clash_len;
1326 /* Compute hash code */
1327 hi = hash_len * 613 + (unsigned) text[0];
1328 for (i = 1; i < hash_len; i += 2)
1329 hi = ((hi * 613) + (unsigned) (text[i]));
1331 hi &= (1 << HASHBITS) - 1;
1332 hi %= MAX_HASH_TABLE;
1334 /* Search table for identifier */
1335 for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp))
1336 if (IDENTIFIER_LENGTH (idp) == len
1337 && IDENTIFIER_POINTER (idp)[0] == text[0]
1338 && !bcmp (IDENTIFIER_POINTER (idp), text, len))
1339 return idp; /* <-- return if found */
1344 /* Enable warnings on similar identifiers (if requested).
1345 Done after the built-in identifiers are created. */
1348 start_identifier_warnings ()
1350 do_identifier_warnings = 1;
1353 /* Record the size of an identifier node for the language in use.
1354 SIZE is the total size in bytes.
1355 This is called by the language-specific files. This must be
1356 called before allocating any identifiers. */
1359 set_identifier_size (size)
1362 tree_code_length[(int) IDENTIFIER_NODE]
1363 = (size - sizeof (struct tree_common)) / sizeof (tree);
1366 /* Return a newly constructed INTEGER_CST node whose constant value
1367 is specified by the two ints LOW and HI.
1368 The TREE_TYPE is set to `int'.
1370 This function should be used via the `build_int_2' macro. */
1373 build_int_2_wide (low, hi)
1374 HOST_WIDE_INT low, hi;
1376 register tree t = make_node (INTEGER_CST);
1377 TREE_INT_CST_LOW (t) = low;
1378 TREE_INT_CST_HIGH (t) = hi;
1379 TREE_TYPE (t) = integer_type_node;
1383 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1386 build_real (type, d)
1393 /* Check for valid float value for this type on this target machine;
1394 if not, can print error message and store a valid value in D. */
1395 #ifdef CHECK_FLOAT_VALUE
1396 CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
1399 v = make_node (REAL_CST);
1400 TREE_TYPE (v) = type;
1401 TREE_REAL_CST (v) = d;
1402 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
1406 /* Return a new REAL_CST node whose type is TYPE
1407 and whose value is the integer value of the INTEGER_CST node I. */
1409 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1412 real_value_from_int_cst (type, i)
1417 #ifdef REAL_ARITHMETIC
1418 if (! TREE_UNSIGNED (TREE_TYPE (i)))
1419 REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1422 REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i),
1423 TREE_INT_CST_HIGH (i), TYPE_MODE (type));
1424 #else /* not REAL_ARITHMETIC */
1425 /* Some 386 compilers mishandle unsigned int to float conversions,
1426 so introduce a temporary variable E to avoid those bugs. */
1427 if (TREE_INT_CST_HIGH (i) < 0 && ! TREE_UNSIGNED (TREE_TYPE (i)))
1431 d = (double) (~ TREE_INT_CST_HIGH (i));
1432 e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
1433 * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
1435 e = (double) (unsigned HOST_WIDE_INT) (~ TREE_INT_CST_LOW (i));
1443 d = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (i);
1444 e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
1445 * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
1447 e = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (i);
1450 #endif /* not REAL_ARITHMETIC */
1463 build_real_from_int_cst_1 (data)
1466 struct brfic_args * args = (struct brfic_args *) data;
1468 #ifdef REAL_ARITHMETIC
1469 args->d = real_value_from_int_cst (args->type, args->i);
1472 REAL_VALUE_TRUNCATE (TYPE_MODE (args->type),
1473 real_value_from_int_cst (args->type, args->i));
1477 /* This function can't be implemented if we can't do arithmetic
1478 on the float representation. */
1481 build_real_from_int_cst (type, i)
1486 int overflow = TREE_OVERFLOW (i);
1488 struct brfic_args args;
1490 v = make_node (REAL_CST);
1491 TREE_TYPE (v) = type;
1493 /* Setup input for build_real_from_int_cst_1() */
1497 if (do_float_handler (build_real_from_int_cst_1, (PTR) &args))
1499 /* Receive output from build_real_from_int_cst_1() */
1504 /* We got an exception from build_real_from_int_cst_1() */
1509 /* Check for valid float value for this type on this target machine. */
1511 #ifdef CHECK_FLOAT_VALUE
1512 CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow);
1515 TREE_REAL_CST (v) = d;
1516 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
1520 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1522 /* Return a newly constructed STRING_CST node whose value is
1523 the LEN characters at STR.
1524 The TREE_TYPE is not initialized. */
1527 build_string (len, str)
1531 /* Put the string in saveable_obstack since it will be placed in the RTL
1532 for an "asm" statement and will also be kept around a while if
1533 deferring constant output in varasm.c. */
1535 register tree s = make_node (STRING_CST);
1536 TREE_STRING_LENGTH (s) = len;
1537 TREE_STRING_POINTER (s) = obstack_copy0 (saveable_obstack, str, len);
1541 /* Return a newly constructed COMPLEX_CST node whose value is
1542 specified by the real and imaginary parts REAL and IMAG.
1543 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1544 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1547 build_complex (type, real, imag)
1551 register tree t = make_node (COMPLEX_CST);
1553 TREE_REALPART (t) = real;
1554 TREE_IMAGPART (t) = imag;
1555 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1556 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1557 TREE_CONSTANT_OVERFLOW (t)
1558 = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
1562 /* Build a newly constructed TREE_VEC node of length LEN. */
1569 register int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec);
1570 register struct obstack *obstack = current_obstack;
1572 #ifdef GATHER_STATISTICS
1573 tree_node_counts[(int)vec_kind]++;
1574 tree_node_sizes[(int)vec_kind] += length;
1577 t = (tree) obstack_alloc (obstack, length);
1578 bzero ((PTR) t, length);
1580 TREE_SET_CODE (t, TREE_VEC);
1581 TREE_VEC_LENGTH (t) = len;
1582 if (obstack == &permanent_obstack)
1583 TREE_PERMANENT (t) = 1;
1588 /* Return 1 if EXPR is the integer constant zero or a complex constant
1592 integer_zerop (expr)
1597 return ((TREE_CODE (expr) == INTEGER_CST
1598 && ! TREE_CONSTANT_OVERFLOW (expr)
1599 && TREE_INT_CST_LOW (expr) == 0
1600 && TREE_INT_CST_HIGH (expr) == 0)
1601 || (TREE_CODE (expr) == COMPLEX_CST
1602 && integer_zerop (TREE_REALPART (expr))
1603 && integer_zerop (TREE_IMAGPART (expr))));
1606 /* Return 1 if EXPR is the integer constant one or the corresponding
1607 complex constant. */
1615 return ((TREE_CODE (expr) == INTEGER_CST
1616 && ! TREE_CONSTANT_OVERFLOW (expr)
1617 && TREE_INT_CST_LOW (expr) == 1
1618 && TREE_INT_CST_HIGH (expr) == 0)
1619 || (TREE_CODE (expr) == COMPLEX_CST
1620 && integer_onep (TREE_REALPART (expr))
1621 && integer_zerop (TREE_IMAGPART (expr))));
1624 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1625 it contains. Likewise for the corresponding complex constant. */
1628 integer_all_onesp (expr)
1636 if (TREE_CODE (expr) == COMPLEX_CST
1637 && integer_all_onesp (TREE_REALPART (expr))
1638 && integer_zerop (TREE_IMAGPART (expr)))
1641 else if (TREE_CODE (expr) != INTEGER_CST
1642 || TREE_CONSTANT_OVERFLOW (expr))
1645 uns = TREE_UNSIGNED (TREE_TYPE (expr));
1647 return TREE_INT_CST_LOW (expr) == -1 && TREE_INT_CST_HIGH (expr) == -1;
1649 /* Note that using TYPE_PRECISION here is wrong. We care about the
1650 actual bits, not the (arbitrary) range of the type. */
1651 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1652 if (prec >= HOST_BITS_PER_WIDE_INT)
1654 int high_value, shift_amount;
1656 shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1658 if (shift_amount > HOST_BITS_PER_WIDE_INT)
1659 /* Can not handle precisions greater than twice the host int size. */
1661 else if (shift_amount == HOST_BITS_PER_WIDE_INT)
1662 /* Shifting by the host word size is undefined according to the ANSI
1663 standard, so we must handle this as a special case. */
1666 high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1668 return TREE_INT_CST_LOW (expr) == -1
1669 && TREE_INT_CST_HIGH (expr) == high_value;
1672 return TREE_INT_CST_LOW (expr) == ((HOST_WIDE_INT) 1 << prec) - 1;
1675 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1679 integer_pow2p (expr)
1683 HOST_WIDE_INT high, low;
1687 if (TREE_CODE (expr) == COMPLEX_CST
1688 && integer_pow2p (TREE_REALPART (expr))
1689 && integer_zerop (TREE_IMAGPART (expr)))
1692 if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr))
1695 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1696 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1697 high = TREE_INT_CST_HIGH (expr);
1698 low = TREE_INT_CST_LOW (expr);
1700 /* First clear all bits that are beyond the type's precision in case
1701 we've been sign extended. */
1703 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1705 else if (prec > HOST_BITS_PER_WIDE_INT)
1706 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1710 if (prec < HOST_BITS_PER_WIDE_INT)
1711 low &= ~((HOST_WIDE_INT) (-1) << prec);
1714 if (high == 0 && low == 0)
1717 return ((high == 0 && (low & (low - 1)) == 0)
1718 || (low == 0 && (high & (high - 1)) == 0));
1721 /* Return the power of two represented by a tree node known to be a
1729 HOST_WIDE_INT high, low;
1733 if (TREE_CODE (expr) == COMPLEX_CST)
1734 return tree_log2 (TREE_REALPART (expr));
1736 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1737 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1739 high = TREE_INT_CST_HIGH (expr);
1740 low = TREE_INT_CST_LOW (expr);
1742 /* First clear all bits that are beyond the type's precision in case
1743 we've been sign extended. */
1745 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1747 else if (prec > HOST_BITS_PER_WIDE_INT)
1748 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1752 if (prec < HOST_BITS_PER_WIDE_INT)
1753 low &= ~((HOST_WIDE_INT) (-1) << prec);
1756 return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1757 : exact_log2 (low));
1760 /* Return 1 if EXPR is the real constant zero. */
1768 return ((TREE_CODE (expr) == REAL_CST
1769 && ! TREE_CONSTANT_OVERFLOW (expr)
1770 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
1771 || (TREE_CODE (expr) == COMPLEX_CST
1772 && real_zerop (TREE_REALPART (expr))
1773 && real_zerop (TREE_IMAGPART (expr))));
1776 /* Return 1 if EXPR is the real constant one in real or complex form. */
1784 return ((TREE_CODE (expr) == REAL_CST
1785 && ! TREE_CONSTANT_OVERFLOW (expr)
1786 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
1787 || (TREE_CODE (expr) == COMPLEX_CST
1788 && real_onep (TREE_REALPART (expr))
1789 && real_zerop (TREE_IMAGPART (expr))));
1792 /* Return 1 if EXPR is the real constant two. */
1800 return ((TREE_CODE (expr) == REAL_CST
1801 && ! TREE_CONSTANT_OVERFLOW (expr)
1802 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
1803 || (TREE_CODE (expr) == COMPLEX_CST
1804 && real_twop (TREE_REALPART (expr))
1805 && real_zerop (TREE_IMAGPART (expr))));
1808 /* Nonzero if EXP is a constant or a cast of a constant. */
1811 really_constant_p (exp)
1814 /* This is not quite the same as STRIP_NOPS. It does more. */
1815 while (TREE_CODE (exp) == NOP_EXPR
1816 || TREE_CODE (exp) == CONVERT_EXPR
1817 || TREE_CODE (exp) == NON_LVALUE_EXPR)
1818 exp = TREE_OPERAND (exp, 0);
1819 return TREE_CONSTANT (exp);
1822 /* Return first list element whose TREE_VALUE is ELEM.
1823 Return 0 if ELEM is not in LIST. */
1826 value_member (elem, list)
1831 if (elem == TREE_VALUE (list))
1833 list = TREE_CHAIN (list);
1838 /* Return first list element whose TREE_PURPOSE is ELEM.
1839 Return 0 if ELEM is not in LIST. */
1842 purpose_member (elem, list)
1847 if (elem == TREE_PURPOSE (list))
1849 list = TREE_CHAIN (list);
1854 /* Return first list element whose BINFO_TYPE is ELEM.
1855 Return 0 if ELEM is not in LIST. */
1858 binfo_member (elem, list)
1863 if (elem == BINFO_TYPE (list))
1865 list = TREE_CHAIN (list);
1870 /* Return nonzero if ELEM is part of the chain CHAIN. */
1873 chain_member (elem, chain)
1880 chain = TREE_CHAIN (chain);
1886 /* Return nonzero if ELEM is equal to TREE_VALUE (CHAIN) for any piece of
1888 /* ??? This function was added for machine specific attributes but is no
1889 longer used. It could be deleted if we could confirm all front ends
1893 chain_member_value (elem, chain)
1898 if (elem == TREE_VALUE (chain))
1900 chain = TREE_CHAIN (chain);
1906 /* Return nonzero if ELEM is equal to TREE_PURPOSE (CHAIN)
1907 for any piece of chain CHAIN. */
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_purpose (elem, chain)
1918 if (elem == TREE_PURPOSE (chain))
1920 chain = TREE_CHAIN (chain);
1926 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1927 We expect a null pointer to mark the end of the chain.
1928 This is the Lisp primitive `length'. */
1935 register int len = 0;
1937 for (tail = t; tail; tail = TREE_CHAIN (tail))
1943 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1944 by modifying the last node in chain 1 to point to chain 2.
1945 This is the Lisp primitive `nconc'. */
1955 #ifdef ENABLE_CHECKING
1959 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
1961 TREE_CHAIN (t1) = op2;
1962 #ifdef ENABLE_CHECKING
1963 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
1965 abort (); /* Circularity created. */
1972 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
1976 register tree chain;
1980 while ((next = TREE_CHAIN (chain)))
1985 /* Reverse the order of elements in the chain T,
1986 and return the new head of the chain (old last element). */
1992 register tree prev = 0, decl, next;
1993 for (decl = t; decl; decl = next)
1995 next = TREE_CHAIN (decl);
1996 TREE_CHAIN (decl) = prev;
2002 /* Given a chain CHAIN of tree nodes,
2003 construct and return a list of those nodes. */
2009 tree result = NULL_TREE;
2010 tree in_tail = chain;
2011 tree out_tail = NULL_TREE;
2015 tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE);
2017 TREE_CHAIN (out_tail) = next;
2021 in_tail = TREE_CHAIN (in_tail);
2027 /* Return a newly created TREE_LIST node whose
2028 purpose and value fields are PARM and VALUE. */
2031 build_tree_list (parm, value)
2034 register tree t = make_node (TREE_LIST);
2035 TREE_PURPOSE (t) = parm;
2036 TREE_VALUE (t) = value;
2040 /* Similar, but build on the temp_decl_obstack. */
2043 build_decl_list (parm, value)
2047 register struct obstack *ambient_obstack = current_obstack;
2048 current_obstack = &temp_decl_obstack;
2049 node = build_tree_list (parm, value);
2050 current_obstack = ambient_obstack;
2054 /* Similar, but build on the expression_obstack. */
2057 build_expr_list (parm, value)
2061 register struct obstack *ambient_obstack = current_obstack;
2062 current_obstack = expression_obstack;
2063 node = build_tree_list (parm, value);
2064 current_obstack = ambient_obstack;
2068 /* Return a newly created TREE_LIST node whose
2069 purpose and value fields are PARM and VALUE
2070 and whose TREE_CHAIN is CHAIN. */
2073 tree_cons (purpose, value, chain)
2074 tree purpose, value, chain;
2077 register tree node = make_node (TREE_LIST);
2080 register tree node = (tree) obstack_alloc (current_obstack, sizeof (struct tree_list));
2081 #ifdef GATHER_STATISTICS
2082 tree_node_counts[(int)x_kind]++;
2083 tree_node_sizes[(int)x_kind] += sizeof (struct tree_list);
2086 for (i = (sizeof (struct tree_common) / sizeof (int)) - 1; i >= 0; i--)
2087 ((int *) node)[i] = 0;
2089 TREE_SET_CODE (node, TREE_LIST);
2090 if (current_obstack == &permanent_obstack)
2091 TREE_PERMANENT (node) = 1;
2094 TREE_CHAIN (node) = chain;
2095 TREE_PURPOSE (node) = purpose;
2096 TREE_VALUE (node) = value;
2100 /* Similar, but build on the temp_decl_obstack. */
2103 decl_tree_cons (purpose, value, chain)
2104 tree purpose, value, chain;
2107 register struct obstack *ambient_obstack = current_obstack;
2108 current_obstack = &temp_decl_obstack;
2109 node = tree_cons (purpose, value, chain);
2110 current_obstack = ambient_obstack;
2114 /* Similar, but build on the expression_obstack. */
2117 expr_tree_cons (purpose, value, chain)
2118 tree purpose, value, chain;
2121 register struct obstack *ambient_obstack = current_obstack;
2122 current_obstack = expression_obstack;
2123 node = tree_cons (purpose, value, chain);
2124 current_obstack = ambient_obstack;
2128 /* Same as `tree_cons' but make a permanent object. */
2131 perm_tree_cons (purpose, value, chain)
2132 tree purpose, value, chain;
2135 register struct obstack *ambient_obstack = current_obstack;
2136 current_obstack = &permanent_obstack;
2138 node = tree_cons (purpose, value, chain);
2139 current_obstack = ambient_obstack;
2143 /* Same as `tree_cons', but make this node temporary, regardless. */
2146 temp_tree_cons (purpose, value, chain)
2147 tree purpose, value, chain;
2150 register struct obstack *ambient_obstack = current_obstack;
2151 current_obstack = &temporary_obstack;
2153 node = tree_cons (purpose, value, chain);
2154 current_obstack = ambient_obstack;
2158 /* Same as `tree_cons', but save this node if the function's RTL is saved. */
2161 saveable_tree_cons (purpose, value, chain)
2162 tree purpose, value, chain;
2165 register struct obstack *ambient_obstack = current_obstack;
2166 current_obstack = saveable_obstack;
2168 node = tree_cons (purpose, value, chain);
2169 current_obstack = ambient_obstack;
2173 /* Return the size nominally occupied by an object of type TYPE
2174 when it resides in memory. The value is measured in units of bytes,
2175 and its data type is that normally used for type sizes
2176 (which is the first type created by make_signed_type or
2177 make_unsigned_type). */
2180 size_in_bytes (type)
2185 if (type == error_mark_node)
2186 return integer_zero_node;
2188 type = TYPE_MAIN_VARIANT (type);
2189 t = TYPE_SIZE_UNIT (type);
2192 incomplete_type_error (NULL_TREE, type);
2193 return integer_zero_node;
2195 if (TREE_CODE (t) == INTEGER_CST)
2196 force_fit_type (t, 0);
2201 /* Return the size of TYPE (in bytes) as a wide integer
2202 or return -1 if the size can vary or is larger than an integer. */
2205 int_size_in_bytes (type)
2210 if (type == error_mark_node)
2213 type = TYPE_MAIN_VARIANT (type);
2214 t = TYPE_SIZE_UNIT (type);
2216 || TREE_CODE (t) != INTEGER_CST
2217 || TREE_INT_CST_HIGH (t) != 0)
2220 return TREE_INT_CST_LOW (t);
2223 /* Return, as a tree node, the number of elements for TYPE (which is an
2224 ARRAY_TYPE) minus one. This counts only elements of the top array.
2226 Don't let any SAVE_EXPRs escape; if we are called as part of a cleanup
2227 action, they would get unsaved. */
2230 array_type_nelts (type)
2233 tree index_type, min, max;
2235 /* If they did it with unspecified bounds, then we should have already
2236 given an error about it before we got here. */
2237 if (! TYPE_DOMAIN (type))
2238 return error_mark_node;
2240 index_type = TYPE_DOMAIN (type);
2241 min = TYPE_MIN_VALUE (index_type);
2242 max = TYPE_MAX_VALUE (index_type);
2244 if (! TREE_CONSTANT (min))
2247 if (TREE_CODE (min) == SAVE_EXPR)
2248 min = build (RTL_EXPR, TREE_TYPE (TYPE_MIN_VALUE (index_type)), 0,
2249 SAVE_EXPR_RTL (min));
2251 min = TYPE_MIN_VALUE (index_type);
2254 if (! TREE_CONSTANT (max))
2257 if (TREE_CODE (max) == SAVE_EXPR)
2258 max = build (RTL_EXPR, TREE_TYPE (TYPE_MAX_VALUE (index_type)), 0,
2259 SAVE_EXPR_RTL (max));
2261 max = TYPE_MAX_VALUE (index_type);
2264 return (integer_zerop (min)
2266 : fold (build (MINUS_EXPR, TREE_TYPE (max), max, min)));
2269 /* Return nonzero if arg is static -- a reference to an object in
2270 static storage. This is not the same as the C meaning of `static'. */
2276 switch (TREE_CODE (arg))
2279 /* Nested functions aren't static, since taking their address
2280 involves a trampoline. */
2281 return (decl_function_context (arg) == 0 || DECL_NO_STATIC_CHAIN (arg))
2282 && ! DECL_NON_ADDR_CONST_P (arg);
2285 return (TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2286 && ! DECL_NON_ADDR_CONST_P (arg);
2289 return TREE_STATIC (arg);
2294 /* If we are referencing a bitfield, we can't evaluate an
2295 ADDR_EXPR at compile time and so it isn't a constant. */
2297 return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
2298 && staticp (TREE_OPERAND (arg, 0)));
2304 /* This case is technically correct, but results in setting
2305 TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
2308 return TREE_CONSTANT (TREE_OPERAND (arg, 0));
2312 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2313 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2314 return staticp (TREE_OPERAND (arg, 0));
2321 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2322 Do this to any expression which may be used in more than one place,
2323 but must be evaluated only once.
2325 Normally, expand_expr would reevaluate the expression each time.
2326 Calling save_expr produces something that is evaluated and recorded
2327 the first time expand_expr is called on it. Subsequent calls to
2328 expand_expr just reuse the recorded value.
2330 The call to expand_expr that generates code that actually computes
2331 the value is the first call *at compile time*. Subsequent calls
2332 *at compile time* generate code to use the saved value.
2333 This produces correct result provided that *at run time* control
2334 always flows through the insns made by the first expand_expr
2335 before reaching the other places where the save_expr was evaluated.
2336 You, the caller of save_expr, must make sure this is so.
2338 Constants, and certain read-only nodes, are returned with no
2339 SAVE_EXPR because that is safe. Expressions containing placeholders
2340 are not touched; see tree.def for an explanation of what these
2347 register tree t = fold (expr);
2349 /* We don't care about whether this can be used as an lvalue in this
2351 while (TREE_CODE (t) == NON_LVALUE_EXPR)
2352 t = TREE_OPERAND (t, 0);
2354 /* If the tree evaluates to a constant, then we don't want to hide that
2355 fact (i.e. this allows further folding, and direct checks for constants).
2356 However, a read-only object that has side effects cannot be bypassed.
2357 Since it is no problem to reevaluate literals, we just return the
2360 if (TREE_CONSTANT (t) || (TREE_READONLY (t) && ! TREE_SIDE_EFFECTS (t))
2361 || TREE_CODE (t) == SAVE_EXPR || TREE_CODE (t) == ERROR_MARK)
2364 /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2365 it means that the size or offset of some field of an object depends on
2366 the value within another field.
2368 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2369 and some variable since it would then need to be both evaluated once and
2370 evaluated more than once. Front-ends must assure this case cannot
2371 happen by surrounding any such subexpressions in their own SAVE_EXPR
2372 and forcing evaluation at the proper time. */
2373 if (contains_placeholder_p (t))
2376 t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
2378 /* This expression might be placed ahead of a jump to ensure that the
2379 value was computed on both sides of the jump. So make sure it isn't
2380 eliminated as dead. */
2381 TREE_SIDE_EFFECTS (t) = 1;
2385 /* Arrange for an expression to be expanded multiple independent
2386 times. This is useful for cleanup actions, as the backend can
2387 expand them multiple times in different places. */
2395 /* If this is already protected, no sense in protecting it again. */
2396 if (TREE_CODE (expr) == UNSAVE_EXPR)
2399 t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
2400 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
2404 /* Returns the index of the first non-tree operand for CODE, or the number
2405 of operands if all are trees. */
2409 enum tree_code code;
2415 case GOTO_SUBROUTINE_EXPR:
2420 case WITH_CLEANUP_EXPR:
2421 /* Should be defined to be 2. */
2423 case METHOD_CALL_EXPR:
2426 return tree_code_length [(int) code];
2430 /* Modify a tree in place so that all the evaluate only once things
2431 are cleared out. Return the EXPR given.
2433 LANG_UNSAVE_EXPR_NOW, if set, is a pointer to a function to handle
2434 language specific nodes.
2438 unsave_expr_now (expr)
2441 enum tree_code code;
2445 if (expr == NULL_TREE)
2448 code = TREE_CODE (expr);
2449 first_rtl = first_rtl_op (code);
2453 SAVE_EXPR_RTL (expr) = 0;
2457 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
2458 TREE_OPERAND (expr, 3) = NULL_TREE;
2462 /* I don't yet know how to emit a sequence multiple times. */
2463 if (RTL_EXPR_SEQUENCE (expr) != 0)
2468 CALL_EXPR_RTL (expr) = 0;
2469 if (TREE_OPERAND (expr, 1)
2470 && TREE_CODE (TREE_OPERAND (expr, 1)) == TREE_LIST)
2472 tree exp = TREE_OPERAND (expr, 1);
2475 unsave_expr_now (TREE_VALUE (exp));
2476 exp = TREE_CHAIN (exp);
2482 if (lang_unsave_expr_now)
2483 (*lang_unsave_expr_now) (expr);
2487 switch (TREE_CODE_CLASS (code))
2489 case 'c': /* a constant */
2490 case 't': /* a type node */
2491 case 'x': /* something random, like an identifier or an ERROR_MARK. */
2492 case 'd': /* A decl node */
2493 case 'b': /* A block node */
2496 case 'e': /* an expression */
2497 case 'r': /* a reference */
2498 case 's': /* an expression with side effects */
2499 case '<': /* a comparison expression */
2500 case '2': /* a binary arithmetic expression */
2501 case '1': /* a unary arithmetic expression */
2502 for (i = first_rtl - 1; i >= 0; i--)
2503 unsave_expr_now (TREE_OPERAND (expr, i));
2511 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2512 or offset that depends on a field within a record. */
2515 contains_placeholder_p (exp)
2518 register enum tree_code code = TREE_CODE (exp);
2521 /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
2522 in it since it is supplying a value for it. */
2523 if (code == WITH_RECORD_EXPR)
2525 else if (code == PLACEHOLDER_EXPR)
2528 switch (TREE_CODE_CLASS (code))
2531 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2532 position computations since they will be converted into a
2533 WITH_RECORD_EXPR involving the reference, which will assume
2534 here will be valid. */
2535 return contains_placeholder_p (TREE_OPERAND (exp, 0));
2538 if (code == TREE_LIST)
2539 return (contains_placeholder_p (TREE_VALUE (exp))
2540 || (TREE_CHAIN (exp) != 0
2541 && contains_placeholder_p (TREE_CHAIN (exp))));
2550 /* Ignoring the first operand isn't quite right, but works best. */
2551 return contains_placeholder_p (TREE_OPERAND (exp, 1));
2558 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
2559 || contains_placeholder_p (TREE_OPERAND (exp, 1))
2560 || contains_placeholder_p (TREE_OPERAND (exp, 2)));
2563 /* If we already know this doesn't have a placeholder, don't
2565 if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
2568 SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
2569 result = contains_placeholder_p (TREE_OPERAND (exp, 0));
2571 SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
2576 return (TREE_OPERAND (exp, 1) != 0
2577 && contains_placeholder_p (TREE_OPERAND (exp, 1)));
2583 switch (tree_code_length[(int) code])
2586 return contains_placeholder_p (TREE_OPERAND (exp, 0));
2588 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
2589 || contains_placeholder_p (TREE_OPERAND (exp, 1)));
2600 /* Return 1 if EXP contains any expressions that produce cleanups for an
2601 outer scope to deal with. Used by fold. */
2609 if (! TREE_SIDE_EFFECTS (exp))
2612 switch (TREE_CODE (exp))
2615 case GOTO_SUBROUTINE_EXPR:
2616 case WITH_CLEANUP_EXPR:
2619 case CLEANUP_POINT_EXPR:
2623 for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
2625 cmp = has_cleanups (TREE_VALUE (exp));
2635 /* This general rule works for most tree codes. All exceptions should be
2636 handled above. If this is a language-specific tree code, we can't
2637 trust what might be in the operand, so say we don't know
2639 if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
2642 nops = first_rtl_op (TREE_CODE (exp));
2643 for (i = 0; i < nops; i++)
2644 if (TREE_OPERAND (exp, i) != 0)
2646 int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
2647 if (type == 'e' || type == '<' || type == '1' || type == '2'
2648 || type == 'r' || type == 's')
2650 cmp = has_cleanups (TREE_OPERAND (exp, i));
2659 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2660 return a tree with all occurrences of references to F in a
2661 PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
2662 contains only arithmetic expressions or a CALL_EXPR with a
2663 PLACEHOLDER_EXPR occurring only in its arglist. */
2666 substitute_in_expr (exp, f, r)
2671 enum tree_code code = TREE_CODE (exp);
2676 switch (TREE_CODE_CLASS (code))
2683 if (code == PLACEHOLDER_EXPR)
2685 else if (code == TREE_LIST)
2687 op0 = (TREE_CHAIN (exp) == 0
2688 ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
2689 op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
2690 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2693 return tree_cons (TREE_PURPOSE (exp), op1, op0);
2702 switch (tree_code_length[(int) code])
2705 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2706 if (op0 == TREE_OPERAND (exp, 0))
2709 new = fold (build1 (code, TREE_TYPE (exp), op0));
2713 /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
2714 could, but we don't support it. */
2715 if (code == RTL_EXPR)
2717 else if (code == CONSTRUCTOR)
2720 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2721 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2722 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
2725 new = fold (build (code, TREE_TYPE (exp), op0, op1));
2729 /* It cannot be that anything inside a SAVE_EXPR contains a
2730 PLACEHOLDER_EXPR. */
2731 if (code == SAVE_EXPR)
2734 else if (code == CALL_EXPR)
2736 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2737 if (op1 == TREE_OPERAND (exp, 1))
2740 return build (code, TREE_TYPE (exp),
2741 TREE_OPERAND (exp, 0), op1, NULL_TREE);
2744 else if (code != COND_EXPR)
2747 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2748 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2749 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2750 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2751 && op2 == TREE_OPERAND (exp, 2))
2754 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2767 /* If this expression is getting a value from a PLACEHOLDER_EXPR
2768 and it is the right field, replace it with R. */
2769 for (inner = TREE_OPERAND (exp, 0);
2770 TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
2771 inner = TREE_OPERAND (inner, 0))
2773 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2774 && TREE_OPERAND (exp, 1) == f)
2777 /* If this expression hasn't been completed let, leave it
2779 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2780 && TREE_TYPE (inner) == 0)
2783 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2784 if (op0 == TREE_OPERAND (exp, 0))
2787 new = fold (build (code, TREE_TYPE (exp), op0,
2788 TREE_OPERAND (exp, 1)));
2792 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2793 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2794 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2795 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2796 && op2 == TREE_OPERAND (exp, 2))
2799 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2804 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2805 if (op0 == TREE_OPERAND (exp, 0))
2808 new = fold (build1 (code, TREE_TYPE (exp), op0));
2820 TREE_READONLY (new) = TREE_READONLY (exp);
2824 /* Stabilize a reference so that we can use it any number of times
2825 without causing its operands to be evaluated more than once.
2826 Returns the stabilized reference. This works by means of save_expr,
2827 so see the caveats in the comments about save_expr.
2829 Also allows conversion expressions whose operands are references.
2830 Any other kind of expression is returned unchanged. */
2833 stabilize_reference (ref)
2836 register tree result;
2837 register enum tree_code code = TREE_CODE (ref);
2844 /* No action is needed in this case. */
2850 case FIX_TRUNC_EXPR:
2851 case FIX_FLOOR_EXPR:
2852 case FIX_ROUND_EXPR:
2854 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
2858 result = build_nt (INDIRECT_REF,
2859 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
2863 result = build_nt (COMPONENT_REF,
2864 stabilize_reference (TREE_OPERAND (ref, 0)),
2865 TREE_OPERAND (ref, 1));
2869 result = build_nt (BIT_FIELD_REF,
2870 stabilize_reference (TREE_OPERAND (ref, 0)),
2871 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2872 stabilize_reference_1 (TREE_OPERAND (ref, 2)));
2876 result = build_nt (ARRAY_REF,
2877 stabilize_reference (TREE_OPERAND (ref, 0)),
2878 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2882 /* We cannot wrap the first expression in a SAVE_EXPR, as then
2883 it wouldn't be ignored. This matters when dealing with
2885 return stabilize_reference_1 (ref);
2888 result = build1 (INDIRECT_REF, TREE_TYPE (ref),
2889 save_expr (build1 (ADDR_EXPR,
2890 build_pointer_type (TREE_TYPE (ref)),
2895 /* If arg isn't a kind of lvalue we recognize, make no change.
2896 Caller should recognize the error for an invalid lvalue. */
2901 return error_mark_node;
2904 TREE_TYPE (result) = TREE_TYPE (ref);
2905 TREE_READONLY (result) = TREE_READONLY (ref);
2906 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
2907 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
2908 TREE_RAISES (result) = TREE_RAISES (ref);
2913 /* Subroutine of stabilize_reference; this is called for subtrees of
2914 references. Any expression with side-effects must be put in a SAVE_EXPR
2915 to ensure that it is only evaluated once.
2917 We don't put SAVE_EXPR nodes around everything, because assigning very
2918 simple expressions to temporaries causes us to miss good opportunities
2919 for optimizations. Among other things, the opportunity to fold in the
2920 addition of a constant into an addressing mode often gets lost, e.g.
2921 "y[i+1] += x;". In general, we take the approach that we should not make
2922 an assignment unless we are forced into it - i.e., that any non-side effect
2923 operator should be allowed, and that cse should take care of coalescing
2924 multiple utterances of the same expression should that prove fruitful. */
2927 stabilize_reference_1 (e)
2930 register tree result;
2931 register enum tree_code code = TREE_CODE (e);
2933 /* We cannot ignore const expressions because it might be a reference
2934 to a const array but whose index contains side-effects. But we can
2935 ignore things that are actual constant or that already have been
2936 handled by this function. */
2938 if (TREE_CONSTANT (e) || code == SAVE_EXPR)
2941 switch (TREE_CODE_CLASS (code))
2951 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2952 so that it will only be evaluated once. */
2953 /* The reference (r) and comparison (<) classes could be handled as
2954 below, but it is generally faster to only evaluate them once. */
2955 if (TREE_SIDE_EFFECTS (e))
2956 return save_expr (e);
2960 /* Constants need no processing. In fact, we should never reach
2965 /* Division is slow and tends to be compiled with jumps,
2966 especially the division by powers of 2 that is often
2967 found inside of an array reference. So do it just once. */
2968 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
2969 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
2970 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
2971 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
2972 return save_expr (e);
2973 /* Recursively stabilize each operand. */
2974 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
2975 stabilize_reference_1 (TREE_OPERAND (e, 1)));
2979 /* Recursively stabilize each operand. */
2980 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
2987 TREE_TYPE (result) = TREE_TYPE (e);
2988 TREE_READONLY (result) = TREE_READONLY (e);
2989 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2990 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2991 TREE_RAISES (result) = TREE_RAISES (e);
2996 /* Low-level constructors for expressions. */
2998 /* Build an expression of code CODE, data type TYPE,
2999 and operands as specified by the arguments ARG1 and following arguments.
3000 Expressions and reference nodes can be created this way.
3001 Constants, decls, types and misc nodes cannot be. */
3004 build VPROTO((enum tree_code code, tree tt, ...))
3006 #ifndef ANSI_PROTOTYPES
3007 enum tree_code code;
3012 register int length;
3017 #ifndef ANSI_PROTOTYPES
3018 code = va_arg (p, enum tree_code);
3019 tt = va_arg (p, tree);
3022 t = make_node (code);
3023 length = tree_code_length[(int) code];
3028 /* This is equivalent to the loop below, but faster. */
3029 register tree arg0 = va_arg (p, tree);
3030 register tree arg1 = va_arg (p, tree);
3031 TREE_OPERAND (t, 0) = arg0;
3032 TREE_OPERAND (t, 1) = arg1;
3033 if ((arg0 && TREE_SIDE_EFFECTS (arg0))
3034 || (arg1 && TREE_SIDE_EFFECTS (arg1)))
3035 TREE_SIDE_EFFECTS (t) = 1;
3037 = (arg0 && TREE_RAISES (arg0)) || (arg1 && TREE_RAISES (arg1));
3039 else if (length == 1)
3041 register tree arg0 = va_arg (p, tree);
3043 /* Call build1 for this! */
3044 if (TREE_CODE_CLASS (code) != 's')
3046 TREE_OPERAND (t, 0) = arg0;
3047 if (arg0 && TREE_SIDE_EFFECTS (arg0))
3048 TREE_SIDE_EFFECTS (t) = 1;
3049 TREE_RAISES (t) = (arg0 && TREE_RAISES (arg0));
3053 for (i = 0; i < length; i++)
3055 register tree operand = va_arg (p, tree);
3056 TREE_OPERAND (t, i) = operand;
3059 if (TREE_SIDE_EFFECTS (operand))
3060 TREE_SIDE_EFFECTS (t) = 1;
3061 if (TREE_RAISES (operand))
3062 TREE_RAISES (t) = 1;
3070 /* Same as above, but only builds for unary operators.
3071 Saves lions share of calls to `build'; cuts down use
3072 of varargs, which is expensive for RISC machines. */
3075 build1 (code, type, node)
3076 enum tree_code code;
3080 register struct obstack *obstack = expression_obstack;
3081 register int length;
3082 #ifdef GATHER_STATISTICS
3083 register tree_node_kind kind;
3087 #ifdef GATHER_STATISTICS
3088 if (TREE_CODE_CLASS (code) == 'r')
3094 length = sizeof (struct tree_exp);
3096 t = (tree) obstack_alloc (obstack, length);
3097 bzero ((PTR) t, length);
3099 #ifdef GATHER_STATISTICS
3100 tree_node_counts[(int)kind]++;
3101 tree_node_sizes[(int)kind] += length;
3104 TREE_TYPE (t) = type;
3105 TREE_SET_CODE (t, code);
3107 if (obstack == &permanent_obstack)
3108 TREE_PERMANENT (t) = 1;
3110 TREE_OPERAND (t, 0) = node;
3113 if (TREE_SIDE_EFFECTS (node))
3114 TREE_SIDE_EFFECTS (t) = 1;
3115 if (TREE_RAISES (node))
3116 TREE_RAISES (t) = 1;
3122 /* Similar except don't specify the TREE_TYPE
3123 and leave the TREE_SIDE_EFFECTS as 0.
3124 It is permissible for arguments to be null,
3125 or even garbage if their values do not matter. */
3128 build_nt VPROTO((enum tree_code code, ...))
3130 #ifndef ANSI_PROTOTYPES
3131 enum tree_code code;
3135 register int length;
3140 #ifndef ANSI_PROTOTYPES
3141 code = va_arg (p, enum tree_code);
3144 t = make_node (code);
3145 length = tree_code_length[(int) code];
3147 for (i = 0; i < length; i++)
3148 TREE_OPERAND (t, i) = va_arg (p, tree);
3154 /* Similar to `build_nt', except we build
3155 on the temp_decl_obstack, regardless. */
3158 build_parse_node VPROTO((enum tree_code code, ...))
3160 #ifndef ANSI_PROTOTYPES
3161 enum tree_code code;
3163 register struct obstack *ambient_obstack = expression_obstack;
3166 register int length;
3171 #ifndef ANSI_PROTOTYPES
3172 code = va_arg (p, enum tree_code);
3175 expression_obstack = &temp_decl_obstack;
3177 t = make_node (code);
3178 length = tree_code_length[(int) code];
3180 for (i = 0; i < length; i++)
3181 TREE_OPERAND (t, i) = va_arg (p, tree);
3184 expression_obstack = ambient_obstack;
3189 /* Commented out because this wants to be done very
3190 differently. See cp-lex.c. */
3192 build_op_identifier (op1, op2)
3195 register tree t = make_node (OP_IDENTIFIER);
3196 TREE_PURPOSE (t) = op1;
3197 TREE_VALUE (t) = op2;
3202 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3203 We do NOT enter this node in any sort of symbol table.
3205 layout_decl is used to set up the decl's storage layout.
3206 Other slots are initialized to 0 or null pointers. */
3209 build_decl (code, name, type)
3210 enum tree_code code;
3215 t = make_node (code);
3217 /* if (type == error_mark_node)
3218 type = integer_type_node; */
3219 /* That is not done, deliberately, so that having error_mark_node
3220 as the type can suppress useless errors in the use of this variable. */
3222 DECL_NAME (t) = name;
3223 DECL_ASSEMBLER_NAME (t) = name;
3224 TREE_TYPE (t) = type;
3226 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
3228 else if (code == FUNCTION_DECL)
3229 DECL_MODE (t) = FUNCTION_MODE;
3234 /* BLOCK nodes are used to represent the structure of binding contours
3235 and declarations, once those contours have been exited and their contents
3236 compiled. This information is used for outputting debugging info. */
3239 build_block (vars, tags, subblocks, supercontext, chain)
3240 tree vars, tags, subblocks, supercontext, chain;
3242 register tree block = make_node (BLOCK);
3243 BLOCK_VARS (block) = vars;
3244 BLOCK_TYPE_TAGS (block) = tags;
3245 BLOCK_SUBBLOCKS (block) = subblocks;
3246 BLOCK_SUPERCONTEXT (block) = supercontext;
3247 BLOCK_CHAIN (block) = chain;
3251 /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact
3252 location where an expression or an identifier were encountered. It
3253 is necessary for languages where the frontend parser will handle
3254 recursively more than one file (Java is one of them). */
3257 build_expr_wfl (node, file, line, col)
3262 static const char *last_file = 0;
3263 static tree last_filenode = NULL_TREE;
3264 register tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
3266 EXPR_WFL_NODE (wfl) = node;
3267 EXPR_WFL_SET_LINECOL (wfl, line, col);
3268 if (file != last_file)
3271 last_filenode = file ? get_identifier (file) : NULL_TREE;
3273 EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
3276 TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
3277 TREE_TYPE (wfl) = TREE_TYPE (node);
3282 /* Return a declaration like DDECL except that its DECL_MACHINE_ATTRIBUTE
3286 build_decl_attribute_variant (ddecl, attribute)
3287 tree ddecl, attribute;
3289 DECL_MACHINE_ATTRIBUTES (ddecl) = attribute;
3293 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
3296 Record such modified types already made so we don't make duplicates. */
3299 build_type_attribute_variant (ttype, attribute)
3300 tree ttype, attribute;
3302 if ( ! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
3304 register int hashcode;
3305 register struct obstack *ambient_obstack = current_obstack;
3308 if (ambient_obstack != &permanent_obstack)
3309 current_obstack = TYPE_OBSTACK (ttype);
3311 ntype = copy_node (ttype);
3313 TYPE_POINTER_TO (ntype) = 0;
3314 TYPE_REFERENCE_TO (ntype) = 0;
3315 TYPE_ATTRIBUTES (ntype) = attribute;
3317 /* Create a new main variant of TYPE. */
3318 TYPE_MAIN_VARIANT (ntype) = ntype;
3319 TYPE_NEXT_VARIANT (ntype) = 0;
3320 set_type_quals (ntype, TYPE_UNQUALIFIED);
3322 hashcode = TYPE_HASH (TREE_CODE (ntype))
3323 + TYPE_HASH (TREE_TYPE (ntype))
3324 + attribute_hash_list (attribute);
3326 switch (TREE_CODE (ntype))
3329 hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
3332 hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));
3335 hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));
3338 hashcode += TYPE_HASH (TYPE_PRECISION (ntype));
3344 ntype = type_hash_canon (hashcode, ntype);
3345 ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
3347 /* We must restore the current obstack after the type_hash_canon call,
3348 because type_hash_canon calls type_hash_add for permanent types, and
3349 then type_hash_add calls oballoc expecting to get something permanent
3351 current_obstack = ambient_obstack;
3357 /* Return a 1 if ATTR_NAME and ATTR_ARGS is valid for either declaration DECL
3358 or type TYPE and 0 otherwise. Validity is determined the configuration
3359 macros VALID_MACHINE_DECL_ATTRIBUTE and VALID_MACHINE_TYPE_ATTRIBUTE. */
3362 valid_machine_attribute (attr_name, attr_args, decl, type)
3364 tree attr_args ATTRIBUTE_UNUSED;
3365 tree decl ATTRIBUTE_UNUSED;
3366 tree type ATTRIBUTE_UNUSED;
3369 #ifdef VALID_MACHINE_DECL_ATTRIBUTE
3370 tree decl_attr_list = decl != 0 ? DECL_MACHINE_ATTRIBUTES (decl) : 0;
3372 #ifdef VALID_MACHINE_TYPE_ATTRIBUTE
3373 tree type_attr_list = TYPE_ATTRIBUTES (type);
3376 if (TREE_CODE (attr_name) != IDENTIFIER_NODE)
3379 #ifdef VALID_MACHINE_DECL_ATTRIBUTE
3381 && VALID_MACHINE_DECL_ATTRIBUTE (decl, decl_attr_list, attr_name, attr_args))
3383 tree attr = lookup_attribute (IDENTIFIER_POINTER (attr_name),
3386 if (attr != NULL_TREE)
3388 /* Override existing arguments. Declarations are unique so we can
3389 modify this in place. */
3390 TREE_VALUE (attr) = attr_args;
3394 decl_attr_list = tree_cons (attr_name, attr_args, decl_attr_list);
3395 decl = build_decl_attribute_variant (decl, decl_attr_list);
3402 #ifdef VALID_MACHINE_TYPE_ATTRIBUTE
3404 /* Don't apply the attribute to both the decl and the type. */;
3405 else if (VALID_MACHINE_TYPE_ATTRIBUTE (type, type_attr_list, attr_name,
3408 tree attr = lookup_attribute (IDENTIFIER_POINTER (attr_name),
3411 if (attr != NULL_TREE)
3413 /* Override existing arguments.
3414 ??? This currently works since attribute arguments are not
3415 included in `attribute_hash_list'. Something more complicated
3416 may be needed in the future. */
3417 TREE_VALUE (attr) = attr_args;
3421 /* If this is part of a declaration, create a type variant,
3422 otherwise, this is part of a type definition, so add it
3423 to the base type. */
3424 type_attr_list = tree_cons (attr_name, attr_args, type_attr_list);
3426 type = build_type_attribute_variant (type, type_attr_list);
3428 TYPE_ATTRIBUTES (type) = type_attr_list;
3431 TREE_TYPE (decl) = type;
3435 /* Handle putting a type attribute on pointer-to-function-type by putting
3436 the attribute on the function type. */
3437 else if (POINTER_TYPE_P (type)
3438 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3439 && VALID_MACHINE_TYPE_ATTRIBUTE (TREE_TYPE (type), type_attr_list,
3440 attr_name, attr_args))
3442 tree inner_type = TREE_TYPE (type);
3443 tree inner_attr_list = TYPE_ATTRIBUTES (inner_type);
3444 tree attr = lookup_attribute (IDENTIFIER_POINTER (attr_name),
3447 if (attr != NULL_TREE)
3448 TREE_VALUE (attr) = attr_args;
3451 inner_attr_list = tree_cons (attr_name, attr_args, inner_attr_list);
3452 inner_type = build_type_attribute_variant (inner_type,
3457 TREE_TYPE (decl) = build_pointer_type (inner_type);
3460 /* Clear TYPE_POINTER_TO for the old inner type, since
3461 `type' won't be pointing to it anymore. */
3462 TYPE_POINTER_TO (TREE_TYPE (type)) = NULL_TREE;
3463 TREE_TYPE (type) = inner_type;
3473 /* Return non-zero if IDENT is a valid name for attribute ATTR,
3476 We try both `text' and `__text__', ATTR may be either one. */
3477 /* ??? It might be a reasonable simplification to require ATTR to be only
3478 `text'. One might then also require attribute lists to be stored in
3479 their canonicalized form. */
3482 is_attribute_p (attr, ident)
3486 int ident_len, attr_len;
3489 if (TREE_CODE (ident) != IDENTIFIER_NODE)
3492 if (strcmp (attr, IDENTIFIER_POINTER (ident)) == 0)
3495 p = IDENTIFIER_POINTER (ident);
3496 ident_len = strlen (p);
3497 attr_len = strlen (attr);
3499 /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
3503 || attr[attr_len - 2] != '_'
3504 || attr[attr_len - 1] != '_')
3506 if (ident_len == attr_len - 4
3507 && strncmp (attr + 2, p, attr_len - 4) == 0)
3512 if (ident_len == attr_len + 4
3513 && p[0] == '_' && p[1] == '_'
3514 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
3515 && strncmp (attr, p + 2, attr_len) == 0)
3522 /* Given an attribute name and a list of attributes, return a pointer to the
3523 attribute's list element if the attribute is part of the list, or NULL_TREE
3527 lookup_attribute (attr_name, list)
3528 const char *attr_name;
3533 for (l = list; l; l = TREE_CHAIN (l))
3535 if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE)
3537 if (is_attribute_p (attr_name, TREE_PURPOSE (l)))
3544 /* Return an attribute list that is the union of a1 and a2. */
3547 merge_attributes (a1, a2)
3548 register tree a1, a2;
3552 /* Either one unset? Take the set one. */
3554 if (! (attributes = a1))
3557 /* One that completely contains the other? Take it. */
3559 else if (a2 && ! attribute_list_contained (a1, a2))
3561 if (attribute_list_contained (a2, a1))
3565 /* Pick the longest list, and hang on the other list. */
3566 /* ??? For the moment we punt on the issue of attrs with args. */
3568 if (list_length (a1) < list_length (a2))
3569 attributes = a2, a2 = a1;
3571 for (; a2; a2 = TREE_CHAIN (a2))
3572 if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
3573 attributes) == NULL_TREE)
3575 a1 = copy_node (a2);
3576 TREE_CHAIN (a1) = attributes;
3584 /* Given types T1 and T2, merge their attributes and return
3588 merge_machine_type_attributes (t1, t2)
3591 #ifdef MERGE_MACHINE_TYPE_ATTRIBUTES
3592 return MERGE_MACHINE_TYPE_ATTRIBUTES (t1, t2);
3594 return merge_attributes (TYPE_ATTRIBUTES (t1),
3595 TYPE_ATTRIBUTES (t2));
3599 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
3603 merge_machine_decl_attributes (olddecl, newdecl)
3604 tree olddecl, newdecl;
3606 #ifdef MERGE_MACHINE_DECL_ATTRIBUTES
3607 return MERGE_MACHINE_DECL_ATTRIBUTES (olddecl, newdecl);
3609 return merge_attributes (DECL_MACHINE_ATTRIBUTES (olddecl),
3610 DECL_MACHINE_ATTRIBUTES (newdecl));
3614 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
3615 of the various TYPE_QUAL values. */
3618 set_type_quals (type, type_quals)
3622 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
3623 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
3624 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
3627 /* Given a type node TYPE and a TYPE_QUALIFIER_SET, return a type for
3628 the same kind of data as TYPE describes. Variants point to the
3629 "main variant" (which has no qualifiers set) via TYPE_MAIN_VARIANT,
3630 and it points to a chain of other variants so that duplicate
3631 variants are never made. Only main variants should ever appear as
3632 types of expressions. */
3635 build_qualified_type (type, type_quals)
3641 /* Search the chain of variants to see if there is already one there just
3642 like the one we need to have. If so, use that existing one. We must
3643 preserve the TYPE_NAME, since there is code that depends on this. */
3645 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
3646 if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type))
3649 /* We need a new one. */
3650 t = build_type_copy (type);
3651 set_type_quals (t, type_quals);
3655 /* Create a new variant of TYPE, equivalent but distinct.
3656 This is so the caller can modify it. */
3659 build_type_copy (type)
3662 register tree t, m = TYPE_MAIN_VARIANT (type);
3663 register struct obstack *ambient_obstack = current_obstack;
3665 current_obstack = TYPE_OBSTACK (type);
3666 t = copy_node (type);
3667 current_obstack = ambient_obstack;
3669 TYPE_POINTER_TO (t) = 0;
3670 TYPE_REFERENCE_TO (t) = 0;
3672 /* Add this type to the chain of variants of TYPE. */
3673 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
3674 TYPE_NEXT_VARIANT (m) = t;
3679 /* Hashing of types so that we don't make duplicates.
3680 The entry point is `type_hash_canon'. */
3682 /* Each hash table slot is a bucket containing a chain
3683 of these structures. */
3687 struct type_hash *next; /* Next structure in the bucket. */
3688 int hashcode; /* Hash code of this type. */
3689 tree type; /* The type recorded here. */
3692 /* Now here is the hash table. When recording a type, it is added
3693 to the slot whose index is the hash code mod the table size.
3694 Note that the hash table is used for several kinds of types
3695 (function types, array types and array index range types, for now).
3696 While all these live in the same table, they are completely independent,
3697 and the hash code is computed differently for each of these. */
3699 #define TYPE_HASH_SIZE 59
3700 struct type_hash *type_hash_table[TYPE_HASH_SIZE];
3702 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
3703 with types in the TREE_VALUE slots), by adding the hash codes
3704 of the individual types. */
3707 type_hash_list (list)
3710 register int hashcode;
3712 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3713 hashcode += TYPE_HASH (TREE_VALUE (tail));
3717 /* Look in the type hash table for a type isomorphic to TYPE.
3718 If one is found, return it. Otherwise return 0. */
3721 type_hash_lookup (hashcode, type)
3725 register struct type_hash *h;
3726 for (h = type_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next)
3727 if (h->hashcode == hashcode
3728 && TREE_CODE (h->type) == TREE_CODE (type)
3729 && TREE_TYPE (h->type) == TREE_TYPE (type)
3730 && attribute_list_equal (TYPE_ATTRIBUTES (h->type),
3731 TYPE_ATTRIBUTES (type))
3732 && (TYPE_MAX_VALUE (h->type) == TYPE_MAX_VALUE (type)
3733 || tree_int_cst_equal (TYPE_MAX_VALUE (h->type),
3734 TYPE_MAX_VALUE (type)))
3735 && (TYPE_MIN_VALUE (h->type) == TYPE_MIN_VALUE (type)
3736 || tree_int_cst_equal (TYPE_MIN_VALUE (h->type),
3737 TYPE_MIN_VALUE (type)))
3738 /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE. */
3739 && (TYPE_DOMAIN (h->type) == TYPE_DOMAIN (type)
3740 || (TYPE_DOMAIN (h->type)
3741 && TREE_CODE (TYPE_DOMAIN (h->type)) == TREE_LIST
3742 && TYPE_DOMAIN (type)
3743 && TREE_CODE (TYPE_DOMAIN (type)) == TREE_LIST
3744 && type_list_equal (TYPE_DOMAIN (h->type),
3745 TYPE_DOMAIN (type)))))
3750 /* Add an entry to the type-hash-table
3751 for a type TYPE whose hash code is HASHCODE. */
3754 type_hash_add (hashcode, type)
3758 register struct type_hash *h;
3760 h = (struct type_hash *) permalloc (sizeof (struct type_hash));
3761 h->hashcode = hashcode;
3763 h->next = type_hash_table[hashcode % TYPE_HASH_SIZE];
3764 type_hash_table[hashcode % TYPE_HASH_SIZE] = h;
3767 /* Given TYPE, and HASHCODE its hash code, return the canonical
3768 object for an identical type if one already exists.
3769 Otherwise, return TYPE, and record it as the canonical object
3770 if it is a permanent object.
3772 To use this function, first create a type of the sort you want.
3773 Then compute its hash code from the fields of the type that
3774 make it different from other similar types.
3775 Then call this function and use the value.
3776 This function frees the type you pass in if it is a duplicate. */
3778 /* Set to 1 to debug without canonicalization. Never set by program. */
3779 int debug_no_type_hash = 0;
3782 type_hash_canon (hashcode, type)
3788 if (debug_no_type_hash)
3791 t1 = type_hash_lookup (hashcode, type);
3794 obstack_free (TYPE_OBSTACK (type), type);
3795 #ifdef GATHER_STATISTICS
3796 tree_node_counts[(int)t_kind]--;
3797 tree_node_sizes[(int)t_kind] -= sizeof (struct tree_type);
3802 /* If this is a permanent type, record it for later reuse. */
3803 if (TREE_PERMANENT (type))
3804 type_hash_add (hashcode, type);
3809 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
3810 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
3811 by adding the hash codes of the individual attributes. */
3814 attribute_hash_list (list)
3817 register int hashcode;
3819 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3820 /* ??? Do we want to add in TREE_VALUE too? */
3821 hashcode += TYPE_HASH (TREE_PURPOSE (tail));
3825 /* Given two lists of attributes, return true if list l2 is
3826 equivalent to l1. */
3829 attribute_list_equal (l1, l2)
3832 return attribute_list_contained (l1, l2)
3833 && attribute_list_contained (l2, l1);
3836 /* Given two lists of attributes, return true if list L2 is
3837 completely contained within L1. */
3838 /* ??? This would be faster if attribute names were stored in a canonicalized
3839 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
3840 must be used to show these elements are equivalent (which they are). */
3841 /* ??? It's not clear that attributes with arguments will always be handled
3845 attribute_list_contained (l1, l2)
3848 register tree t1, t2;
3850 /* First check the obvious, maybe the lists are identical. */
3854 /* Maybe the lists are similar. */
3855 for (t1 = l1, t2 = l2;
3857 && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
3858 && TREE_VALUE (t1) == TREE_VALUE (t2);
3859 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
3861 /* Maybe the lists are equal. */
3862 if (t1 == 0 && t2 == 0)
3865 for (; t2; t2 = TREE_CHAIN (t2))
3868 = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
3870 if (attr == NULL_TREE)
3872 if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1)
3879 /* Given two lists of types
3880 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
3881 return 1 if the lists contain the same types in the same order.
3882 Also, the TREE_PURPOSEs must match. */
3885 type_list_equal (l1, l2)
3888 register tree t1, t2;
3890 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
3891 if (TREE_VALUE (t1) != TREE_VALUE (t2)
3892 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
3893 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
3894 && (TREE_TYPE (TREE_PURPOSE (t1))
3895 == TREE_TYPE (TREE_PURPOSE (t2))))))
3901 /* Nonzero if integer constants T1 and T2
3902 represent the same constant value. */
3905 tree_int_cst_equal (t1, t2)
3910 if (t1 == 0 || t2 == 0)
3912 if (TREE_CODE (t1) == INTEGER_CST
3913 && TREE_CODE (t2) == INTEGER_CST
3914 && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3915 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
3920 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
3921 The precise way of comparison depends on their data type. */
3924 tree_int_cst_lt (t1, t2)
3930 if (!TREE_UNSIGNED (TREE_TYPE (t1)))
3931 return INT_CST_LT (t1, t2);
3932 return INT_CST_LT_UNSIGNED (t1, t2);
3935 /* Return an indication of the sign of the integer constant T.
3936 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3937 Note that -1 will never be returned it T's type is unsigned. */
3940 tree_int_cst_sgn (t)
3943 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
3945 else if (TREE_UNSIGNED (TREE_TYPE (t)))
3947 else if (TREE_INT_CST_HIGH (t) < 0)
3953 /* Compare two constructor-element-type constants. Return 1 if the lists
3954 are known to be equal; otherwise return 0. */
3957 simple_cst_list_equal (l1, l2)
3960 while (l1 != NULL_TREE && l2 != NULL_TREE)
3962 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
3965 l1 = TREE_CHAIN (l1);
3966 l2 = TREE_CHAIN (l2);
3972 /* Return truthvalue of whether T1 is the same tree structure as T2.
3973 Return 1 if they are the same.
3974 Return 0 if they are understandably different.
3975 Return -1 if either contains tree structure not understood by
3979 simple_cst_equal (t1, t2)
3982 register enum tree_code code1, code2;
3987 if (t1 == 0 || t2 == 0)
3990 code1 = TREE_CODE (t1);
3991 code2 = TREE_CODE (t2);
3993 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
3995 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3996 || code2 == NON_LVALUE_EXPR)
3997 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3999 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
4001 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
4002 || code2 == NON_LVALUE_EXPR)
4003 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
4011 return TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
4012 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2);
4015 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
4018 return TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
4019 && !bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
4020 TREE_STRING_LENGTH (t1));
4023 if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2))
4029 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4032 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4035 return simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
4038 /* Special case: if either target is an unallocated VAR_DECL,
4039 it means that it's going to be unified with whatever the
4040 TARGET_EXPR is really supposed to initialize, so treat it
4041 as being equivalent to anything. */
4042 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
4043 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
4044 && DECL_RTL (TREE_OPERAND (t1, 0)) == 0)
4045 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
4046 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
4047 && DECL_RTL (TREE_OPERAND (t2, 0)) == 0))
4050 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4053 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
4055 case WITH_CLEANUP_EXPR:
4056 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4059 return simple_cst_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2));
4062 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
4063 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
4076 /* This general rule works for most tree codes. All exceptions should be
4077 handled above. If this is a language-specific tree code, we can't
4078 trust what might be in the operand, so say we don't know
4080 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
4083 switch (TREE_CODE_CLASS (code1))
4093 for (i=0; i<tree_code_length[(int) code1]; ++i)
4095 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
4106 /* Constructors for pointer, array and function types.
4107 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
4108 constructed by language-dependent code, not here.) */
4110 /* Construct, lay out and return the type of pointers to TO_TYPE.
4111 If such a type has already been constructed, reuse it. */
4114 build_pointer_type (to_type)
4117 register tree t = TYPE_POINTER_TO (to_type);
4119 /* First, if we already have a type for pointers to TO_TYPE, use it. */
4124 /* We need a new one. Put this in the same obstack as TO_TYPE. */
4125 push_obstacks (TYPE_OBSTACK (to_type), TYPE_OBSTACK (to_type));
4126 t = make_node (POINTER_TYPE);
4129 TREE_TYPE (t) = to_type;
4131 /* Record this type as the pointer to TO_TYPE. */
4132 TYPE_POINTER_TO (to_type) = t;
4134 /* Lay out the type. This function has many callers that are concerned
4135 with expression-construction, and this simplifies them all.
4136 Also, it guarantees the TYPE_SIZE is in the same obstack as the type. */
4142 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
4143 MAXVAL should be the maximum value in the domain
4144 (one less than the length of the array).
4146 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
4147 We don't enforce this limit, that is up to caller (e.g. language front end).
4148 The limit exists because the result is a signed type and we don't handle
4149 sizes that use more than one HOST_WIDE_INT. */
4152 build_index_type (maxval)
4155 register tree itype = make_node (INTEGER_TYPE);
4157 TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
4158 TYPE_MIN_VALUE (itype) = size_zero_node;
4160 push_obstacks (TYPE_OBSTACK (itype), TYPE_OBSTACK (itype));
4161 TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
4164 TYPE_MODE (itype) = TYPE_MODE (sizetype);
4165 TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
4166 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
4167 TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
4168 if (TREE_CODE (maxval) == INTEGER_CST)
4170 int maxint = (int) TREE_INT_CST_LOW (maxval);
4171 /* If the domain should be empty, make sure the maxval
4172 remains -1 and is not spoiled by truncation. */
4173 if (INT_CST_LT (maxval, integer_zero_node))
4175 TYPE_MAX_VALUE (itype) = build_int_2 (-1, -1);
4176 TREE_TYPE (TYPE_MAX_VALUE (itype)) = sizetype;
4178 return type_hash_canon (maxint < 0 ? ~maxint : maxint, itype);
4184 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
4185 ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
4186 low bound LOWVAL and high bound HIGHVAL.
4187 if TYPE==NULL_TREE, sizetype is used. */
4190 build_range_type (type, lowval, highval)
4191 tree type, lowval, highval;
4193 register tree itype = make_node (INTEGER_TYPE);
4195 TREE_TYPE (itype) = type;
4196 if (type == NULL_TREE)
4199 push_obstacks (TYPE_OBSTACK (itype), TYPE_OBSTACK (itype));
4200 TYPE_MIN_VALUE (itype) = convert (type, lowval);
4201 TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
4204 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
4205 TYPE_MODE (itype) = TYPE_MODE (type);
4206 TYPE_SIZE (itype) = TYPE_SIZE (type);
4207 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
4208 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
4209 if (TREE_CODE (lowval) == INTEGER_CST)
4211 HOST_WIDE_INT lowint, highint;
4214 lowint = TREE_INT_CST_LOW (lowval);
4215 if (highval && TREE_CODE (highval) == INTEGER_CST)
4216 highint = TREE_INT_CST_LOW (highval);
4218 highint = (~(unsigned HOST_WIDE_INT)0) >> 1;
4220 maxint = (int) (highint - lowint);
4221 return type_hash_canon (maxint < 0 ? ~maxint : maxint, itype);
4227 /* Just like build_index_type, but takes lowval and highval instead
4228 of just highval (maxval). */
4231 build_index_2_type (lowval,highval)
4232 tree lowval, highval;
4234 return build_range_type (NULL_TREE, lowval, highval);
4237 /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense).
4238 Needed because when index types are not hashed, equal index types
4239 built at different times appear distinct, even though structurally,
4243 index_type_equal (itype1, itype2)
4244 tree itype1, itype2;
4246 if (TREE_CODE (itype1) != TREE_CODE (itype2))
4248 if (TREE_CODE (itype1) == INTEGER_TYPE)
4250 if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2)
4251 || TYPE_MODE (itype1) != TYPE_MODE (itype2)
4252 || simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2)) != 1
4253 || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2))
4255 if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1),
4256 TYPE_MIN_VALUE (itype2))
4257 && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1),
4258 TYPE_MAX_VALUE (itype2)))
4265 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
4266 and number of elements specified by the range of values of INDEX_TYPE.
4267 If such a type has already been constructed, reuse it. */
4270 build_array_type (elt_type, index_type)
4271 tree elt_type, index_type;
4276 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
4278 error ("arrays of functions are not meaningful");
4279 elt_type = integer_type_node;
4282 /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
4283 build_pointer_type (elt_type);
4285 /* Allocate the array after the pointer type,
4286 in case we free it in type_hash_canon. */
4287 t = make_node (ARRAY_TYPE);
4288 TREE_TYPE (t) = elt_type;
4289 TYPE_DOMAIN (t) = index_type;
4291 if (index_type == 0)
4296 hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
4297 t = type_hash_canon (hashcode, t);
4299 if (TYPE_SIZE (t) == 0)
4304 /* Return the TYPE of the elements comprising
4305 the innermost dimension of ARRAY. */
4308 get_inner_array_type (array)
4311 tree type = TREE_TYPE (array);
4313 while (TREE_CODE (type) == ARRAY_TYPE)
4314 type = TREE_TYPE (type);
4319 /* Construct, lay out and return
4320 the type of functions returning type VALUE_TYPE
4321 given arguments of types ARG_TYPES.
4322 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
4323 are data type nodes for the arguments of the function.
4324 If such a type has already been constructed, reuse it. */
4327 build_function_type (value_type, arg_types)
4328 tree value_type, arg_types;
4333 if (TREE_CODE (value_type) == FUNCTION_TYPE)
4335 error ("function return type cannot be function");
4336 value_type = integer_type_node;
4339 /* Make a node of the sort we want. */
4340 t = make_node (FUNCTION_TYPE);
4341 TREE_TYPE (t) = value_type;
4342 TYPE_ARG_TYPES (t) = arg_types;
4344 /* If we already have such a type, use the old one and free this one. */
4345 hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
4346 t = type_hash_canon (hashcode, t);
4348 if (TYPE_SIZE (t) == 0)
4353 /* Build the node for the type of references-to-TO_TYPE. */
4356 build_reference_type (to_type)
4359 register tree t = TYPE_REFERENCE_TO (to_type);
4361 /* First, if we already have a type for pointers to TO_TYPE, use it. */
4366 /* We need a new one. Put this in the same obstack as TO_TYPE. */
4367 push_obstacks (TYPE_OBSTACK (to_type), TYPE_OBSTACK (to_type));
4368 t = make_node (REFERENCE_TYPE);
4371 TREE_TYPE (t) = to_type;
4373 /* Record this type as the pointer to TO_TYPE. */
4374 TYPE_REFERENCE_TO (to_type) = t;
4381 /* Construct, lay out and return the type of methods belonging to class
4382 BASETYPE and whose arguments and values are described by TYPE.
4383 If that type exists already, reuse it.
4384 TYPE must be a FUNCTION_TYPE node. */
4387 build_method_type (basetype, type)
4388 tree basetype, type;
4393 /* Make a node of the sort we want. */
4394 t = make_node (METHOD_TYPE);
4396 if (TREE_CODE (type) != FUNCTION_TYPE)
4399 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
4400 TREE_TYPE (t) = TREE_TYPE (type);
4402 /* The actual arglist for this function includes a "hidden" argument
4403 which is "this". Put it into the list of argument types. */
4406 = tree_cons (NULL_TREE,
4407 build_pointer_type (basetype), TYPE_ARG_TYPES (type));
4409 /* If we already have such a type, use the old one and free this one. */
4410 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
4411 t = type_hash_canon (hashcode, t);
4413 if (TYPE_SIZE (t) == 0)
4419 /* Construct, lay out and return the type of offsets to a value
4420 of type TYPE, within an object of type BASETYPE.
4421 If a suitable offset type exists already, reuse it. */
4424 build_offset_type (basetype, type)
4425 tree basetype, type;
4430 /* Make a node of the sort we want. */
4431 t = make_node (OFFSET_TYPE);
4433 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
4434 TREE_TYPE (t) = type;
4436 /* If we already have such a type, use the old one and free this one. */
4437 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
4438 t = type_hash_canon (hashcode, t);
4440 if (TYPE_SIZE (t) == 0)
4446 /* Create a complex type whose components are COMPONENT_TYPE. */
4449 build_complex_type (component_type)
4450 tree component_type;
4455 /* Make a node of the sort we want. */
4456 t = make_node (COMPLEX_TYPE);
4458 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
4459 set_type_quals (t, TYPE_QUALS (component_type));
4461 /* If we already have such a type, use the old one and free this one. */
4462 hashcode = TYPE_HASH (component_type);
4463 t = type_hash_canon (hashcode, t);
4465 if (TYPE_SIZE (t) == 0)
4471 /* Return OP, stripped of any conversions to wider types as much as is safe.
4472 Converting the value back to OP's type makes a value equivalent to OP.
4474 If FOR_TYPE is nonzero, we return a value which, if converted to
4475 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
4477 If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
4478 narrowest type that can hold the value, even if they don't exactly fit.
4479 Otherwise, bit-field references are changed to a narrower type
4480 only if they can be fetched directly from memory in that type.
4482 OP must have integer, real or enumeral type. Pointers are not allowed!
4484 There are some cases where the obvious value we could return
4485 would regenerate to OP if converted to OP's type,
4486 but would not extend like OP to wider types.
4487 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
4488 For example, if OP is (unsigned short)(signed char)-1,
4489 we avoid returning (signed char)-1 if FOR_TYPE is int,
4490 even though extending that to an unsigned short would regenerate OP,
4491 since the result of extending (signed char)-1 to (int)
4492 is different from (int) OP. */
4495 get_unwidened (op, for_type)
4499 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
4500 register tree type = TREE_TYPE (op);
4501 register unsigned final_prec
4502 = TYPE_PRECISION (for_type != 0 ? for_type : type);
4504 = (for_type != 0 && for_type != type
4505 && final_prec > TYPE_PRECISION (type)
4506 && TREE_UNSIGNED (type));
4507 register tree win = op;
4509 while (TREE_CODE (op) == NOP_EXPR)
4511 register int bitschange
4512 = TYPE_PRECISION (TREE_TYPE (op))
4513 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
4515 /* Truncations are many-one so cannot be removed.
4516 Unless we are later going to truncate down even farther. */
4518 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
4521 /* See what's inside this conversion. If we decide to strip it,
4523 op = TREE_OPERAND (op, 0);
4525 /* If we have not stripped any zero-extensions (uns is 0),
4526 we can strip any kind of extension.
4527 If we have previously stripped a zero-extension,
4528 only zero-extensions can safely be stripped.
4529 Any extension can be stripped if the bits it would produce
4530 are all going to be discarded later by truncating to FOR_TYPE. */
4534 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
4536 /* TREE_UNSIGNED says whether this is a zero-extension.
4537 Let's avoid computing it if it does not affect WIN
4538 and if UNS will not be needed again. */
4539 if ((uns || TREE_CODE (op) == NOP_EXPR)
4540 && TREE_UNSIGNED (TREE_TYPE (op)))
4548 if (TREE_CODE (op) == COMPONENT_REF
4549 /* Since type_for_size always gives an integer type. */
4550 && TREE_CODE (type) != REAL_TYPE
4551 /* Don't crash if field not laid out yet. */
4552 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
4554 unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
4555 type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1)));
4557 /* We can get this structure field in the narrowest type it fits in.
4558 If FOR_TYPE is 0, do this only for a field that matches the
4559 narrower type exactly and is aligned for it
4560 The resulting extension to its nominal type (a fullword type)
4561 must fit the same conditions as for other extensions. */
4563 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4564 && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
4565 && (! uns || final_prec <= innerprec
4566 || TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4569 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4570 TREE_OPERAND (op, 1));
4571 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4572 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4573 TREE_RAISES (win) = TREE_RAISES (op);
4579 /* Return OP or a simpler expression for a narrower value
4580 which can be sign-extended or zero-extended to give back OP.
4581 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4582 or 0 if the value should be sign-extended. */
4585 get_narrower (op, unsignedp_ptr)
4589 register int uns = 0;
4591 register tree win = op;
4593 while (TREE_CODE (op) == NOP_EXPR)
4595 register int bitschange
4596 = TYPE_PRECISION (TREE_TYPE (op))
4597 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
4599 /* Truncations are many-one so cannot be removed. */
4603 /* See what's inside this conversion. If we decide to strip it,
4605 op = TREE_OPERAND (op, 0);
4609 /* An extension: the outermost one can be stripped,
4610 but remember whether it is zero or sign extension. */
4612 uns = TREE_UNSIGNED (TREE_TYPE (op));
4613 /* Otherwise, if a sign extension has been stripped,
4614 only sign extensions can now be stripped;
4615 if a zero extension has been stripped, only zero-extensions. */
4616 else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
4620 else /* bitschange == 0 */
4622 /* A change in nominal type can always be stripped, but we must
4623 preserve the unsignedness. */
4625 uns = TREE_UNSIGNED (TREE_TYPE (op));
4632 if (TREE_CODE (op) == COMPONENT_REF
4633 /* Since type_for_size always gives an integer type. */
4634 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE)
4636 unsigned innerprec = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)));
4637 tree type = type_for_size (innerprec, TREE_UNSIGNED (op));
4639 /* We can get this structure field in a narrower type that fits it,
4640 but the resulting extension to its nominal type (a fullword type)
4641 must satisfy the same conditions as for other extensions.
4643 Do this only for fields that are aligned (not bit-fields),
4644 because when bit-field insns will be used there is no
4645 advantage in doing this. */
4647 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4648 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
4649 && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4653 uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4654 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4655 TREE_OPERAND (op, 1));
4656 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4657 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4658 TREE_RAISES (win) = TREE_RAISES (op);
4661 *unsignedp_ptr = uns;
4665 /* Nonzero if integer constant C has a value that is permissible
4666 for type TYPE (an INTEGER_TYPE). */
4669 int_fits_type_p (c, type)
4672 if (TREE_UNSIGNED (type))
4673 return (! (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
4674 && INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c))
4675 && ! (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
4676 && INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type)))
4677 /* Negative ints never fit unsigned types. */
4678 && ! (TREE_INT_CST_HIGH (c) < 0
4679 && ! TREE_UNSIGNED (TREE_TYPE (c))));
4681 return (! (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
4682 && INT_CST_LT (TYPE_MAX_VALUE (type), c))
4683 && ! (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
4684 && INT_CST_LT (c, TYPE_MIN_VALUE (type)))
4685 /* Unsigned ints with top bit set never fit signed types. */
4686 && ! (TREE_INT_CST_HIGH (c) < 0
4687 && TREE_UNSIGNED (TREE_TYPE (c))));
4690 /* Return the innermost context enclosing DECL that is
4691 a FUNCTION_DECL, or zero if none. */
4694 decl_function_context (decl)
4699 if (TREE_CODE (decl) == ERROR_MARK)
4702 if (TREE_CODE (decl) == SAVE_EXPR)
4703 context = SAVE_EXPR_CONTEXT (decl);
4705 context = DECL_CONTEXT (decl);
4707 while (context && TREE_CODE (context) != FUNCTION_DECL)
4709 if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
4710 context = TYPE_CONTEXT (context);
4711 else if (TREE_CODE_CLASS (TREE_CODE (context)) == 'd')
4712 context = DECL_CONTEXT (context);
4713 else if (TREE_CODE (context) == BLOCK)
4714 context = BLOCK_SUPERCONTEXT (context);
4716 /* Unhandled CONTEXT !? */
4723 /* Return the innermost context enclosing DECL that is
4724 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4725 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
4728 decl_type_context (decl)
4731 tree context = DECL_CONTEXT (decl);
4735 if (TREE_CODE (context) == RECORD_TYPE
4736 || TREE_CODE (context) == UNION_TYPE
4737 || TREE_CODE (context) == QUAL_UNION_TYPE)
4739 if (TREE_CODE (context) == TYPE_DECL
4740 || TREE_CODE (context) == FUNCTION_DECL)
4741 context = DECL_CONTEXT (context);
4742 else if (TREE_CODE (context) == BLOCK)
4743 context = BLOCK_SUPERCONTEXT (context);
4745 /* Unhandled CONTEXT!? */
4751 /* Print debugging information about the size of the
4752 toplev_inline_obstacks. */
4755 print_inline_obstack_statistics ()
4757 struct simple_obstack_stack *current = toplev_inline_obstacks;
4762 for (; current; current = current->next, ++n_obstacks)
4764 struct obstack *o = current->obstack;
4765 struct _obstack_chunk *chunk = o->chunk;
4767 n_alloc += o->next_free - chunk->contents;
4768 chunk = chunk->prev;
4770 for (; chunk; chunk = chunk->prev, ++n_chunks)
4771 n_alloc += chunk->limit - &chunk->contents[0];
4773 fprintf (stderr, "inline obstacks: %d obstacks, %d bytes, %d chunks\n",
4774 n_obstacks, n_alloc, n_chunks);
4777 /* Print debugging information about the obstack O, named STR. */
4780 print_obstack_statistics (str, o)
4784 struct _obstack_chunk *chunk = o->chunk;
4788 n_alloc += o->next_free - chunk->contents;
4789 chunk = chunk->prev;
4793 n_alloc += chunk->limit - &chunk->contents[0];
4794 chunk = chunk->prev;
4796 fprintf (stderr, "obstack %s: %u bytes, %d chunks\n",
4797 str, n_alloc, n_chunks);
4800 /* Print debugging information about tree nodes generated during the compile,
4801 and any language-specific information. */
4804 dump_tree_statistics ()
4806 #ifdef GATHER_STATISTICS
4808 int total_nodes, total_bytes;
4811 fprintf (stderr, "\n??? tree nodes created\n\n");
4812 #ifdef GATHER_STATISTICS
4813 fprintf (stderr, "Kind Nodes Bytes\n");
4814 fprintf (stderr, "-------------------------------------\n");
4815 total_nodes = total_bytes = 0;
4816 for (i = 0; i < (int) all_kinds; i++)
4818 fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
4819 tree_node_counts[i], tree_node_sizes[i]);
4820 total_nodes += tree_node_counts[i];
4821 total_bytes += tree_node_sizes[i];
4823 fprintf (stderr, "%-20s %9d\n", "identifier names", id_string_size);
4824 fprintf (stderr, "-------------------------------------\n");
4825 fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
4826 fprintf (stderr, "-------------------------------------\n");
4828 fprintf (stderr, "(No per-node statistics)\n");
4830 print_obstack_statistics ("permanent_obstack", &permanent_obstack);
4831 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack);
4832 print_obstack_statistics ("temporary_obstack", &temporary_obstack);
4833 print_obstack_statistics ("momentary_obstack", &momentary_obstack);
4834 print_obstack_statistics ("temp_decl_obstack", &temp_decl_obstack);
4835 print_inline_obstack_statistics ();
4836 print_lang_statistics ();
4839 #define FILE_FUNCTION_PREFIX_LEN 9
4841 #ifndef NO_DOLLAR_IN_LABEL
4842 #define FILE_FUNCTION_FORMAT "_GLOBAL_$%s$%s"
4843 #else /* NO_DOLLAR_IN_LABEL */
4844 #ifndef NO_DOT_IN_LABEL
4845 #define FILE_FUNCTION_FORMAT "_GLOBAL_.%s.%s"
4846 #else /* NO_DOT_IN_LABEL */
4847 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4848 #endif /* NO_DOT_IN_LABEL */
4849 #endif /* NO_DOLLAR_IN_LABEL */
4851 extern char * first_global_object_name;
4852 extern char * weak_global_object_name;
4854 /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name
4855 clashes in cases where we can't reliably choose a unique name.
4857 Derived from mkstemp.c in libiberty. */
4860 append_random_chars (template)
4863 static const char letters[]
4864 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
4865 static unsigned HOST_WIDE_INT value;
4866 unsigned HOST_WIDE_INT v;
4868 #ifdef HAVE_GETTIMEOFDAY
4872 template += strlen (template);
4874 #ifdef HAVE_GETTIMEOFDAY
4875 /* Get some more or less random data. */
4876 gettimeofday (&tv, NULL);
4877 value += ((unsigned HOST_WIDE_INT) tv.tv_usec << 16) ^ tv.tv_sec ^ getpid ();
4884 /* Fill in the random bits. */
4885 template[0] = letters[v % 62];
4887 template[1] = letters[v % 62];
4889 template[2] = letters[v % 62];
4891 template[3] = letters[v % 62];
4893 template[4] = letters[v % 62];
4895 template[5] = letters[v % 62];
4900 /* Generate a name for a function unique to this translation unit.
4901 TYPE is some string to identify the purpose of this function to the
4902 linker or collect2. */
4905 get_file_function_name_long (type)
4911 if (first_global_object_name)
4912 p = first_global_object_name;
4915 /* We don't have anything that we know to be unique to this translation
4916 unit, so use what we do have and throw in some randomness. */
4918 const char *name = weak_global_object_name;
4919 const char *file = main_input_filename;
4924 file = input_filename;
4926 p = (char *) alloca (7 + strlen (name) + strlen (file));
4928 sprintf (p, "%s%s", name, file);
4929 append_random_chars (p);
4932 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
4935 /* Set up the name of the file-level functions we may need. */
4936 /* Use a global object (which is already required to be unique over
4937 the program) rather than the file name (which imposes extra
4938 constraints). -- Raeburn@MIT.EDU, 10 Jan 1990. */
4939 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
4941 /* Don't need to pull weird characters out of global names. */
4942 if (p != first_global_object_name)
4944 for (p = buf+11; *p; p++)
4945 if (! ((*p >= '0' && *p <= '9')
4946 #if 0 /* we always want labels, which are valid C++ identifiers (+ `$') */
4947 #ifndef ASM_IDENTIFY_GCC /* this is required if `.' is invalid -- k. raeburn */
4951 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
4954 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
4957 || (*p >= 'A' && *p <= 'Z')
4958 || (*p >= 'a' && *p <= 'z')))
4962 return get_identifier (buf);
4965 /* If KIND=='I', return a suitable global initializer (constructor) name.
4966 If KIND=='D', return a suitable global clean-up (destructor) name. */
4969 get_file_function_name (kind)
4976 return get_file_function_name_long (p);
4980 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4981 The result is placed in BUFFER (which has length BIT_SIZE),
4982 with one bit in each char ('\000' or '\001').
4984 If the constructor is constant, NULL_TREE is returned.
4985 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4988 get_set_constructor_bits (init, buffer, bit_size)
4995 HOST_WIDE_INT domain_min
4996 = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))));
4997 tree non_const_bits = NULL_TREE;
4998 for (i = 0; i < bit_size; i++)
5001 for (vals = TREE_OPERAND (init, 1);
5002 vals != NULL_TREE; vals = TREE_CHAIN (vals))
5004 if (TREE_CODE (TREE_VALUE (vals)) != INTEGER_CST
5005 || (TREE_PURPOSE (vals) != NULL_TREE
5006 && TREE_CODE (TREE_PURPOSE (vals)) != INTEGER_CST))
5008 = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
5009 else if (TREE_PURPOSE (vals) != NULL_TREE)
5011 /* Set a range of bits to ones. */
5012 HOST_WIDE_INT lo_index
5013 = TREE_INT_CST_LOW (TREE_PURPOSE (vals)) - domain_min;
5014 HOST_WIDE_INT hi_index
5015 = TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min;
5016 if (lo_index < 0 || lo_index >= bit_size
5017 || hi_index < 0 || hi_index >= bit_size)
5019 for ( ; lo_index <= hi_index; lo_index++)
5020 buffer[lo_index] = 1;
5024 /* Set a single bit to one. */
5026 = TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min;
5027 if (index < 0 || index >= bit_size)
5029 error ("invalid initializer for bit string");
5035 return non_const_bits;
5038 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
5039 The result is placed in BUFFER (which is an array of bytes).
5040 If the constructor is constant, NULL_TREE is returned.
5041 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
5044 get_set_constructor_bytes (init, buffer, wd_size)
5046 unsigned char *buffer;
5050 int set_word_size = BITS_PER_UNIT;
5051 int bit_size = wd_size * set_word_size;
5053 unsigned char *bytep = buffer;
5054 char *bit_buffer = (char *) alloca(bit_size);
5055 tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
5057 for (i = 0; i < wd_size; i++)
5060 for (i = 0; i < bit_size; i++)
5064 if (BYTES_BIG_ENDIAN)
5065 *bytep |= (1 << (set_word_size - 1 - bit_pos));
5067 *bytep |= 1 << bit_pos;
5070 if (bit_pos >= set_word_size)
5071 bit_pos = 0, bytep++;
5073 return non_const_bits;
5076 #ifdef ENABLE_CHECKING
5078 #if defined __GNUC__ && (__GNUC__ > 2 || __GNUC_MINOR__ > 6)
5080 /* Complain that the tree code of NODE does not match the expected CODE.
5081 FILE, LINE, and FUNCTION are of the caller.
5083 FIXME: should print the blather about reporting the bug. */
5085 tree_check_failed (node, code, file, line, function)
5087 enum tree_code code;
5090 const char *function;
5092 fatal ("Internal compiler error in `%s', at %s:%d:\n\
5093 \texpected %s, have %s\n",
5094 function, trim_filename (file), line,
5095 tree_code_name[code], tree_code_name[TREE_CODE (node)]);
5098 /* Similar to above, except that we check for a class of tree
5099 code, given in CL. */
5101 tree_class_check_failed (node, cl, file, line, function)
5106 const char *function;
5108 fatal ("Internal compiler error in `%s', at %s:%d:\n\
5109 \texpected '%c', have '%c' (%s)\n",
5110 function, trim_filename (file), line, cl,
5111 TREE_CODE_CLASS (TREE_CODE (node)),
5112 tree_code_name[TREE_CODE (node)]);
5115 #else /* not gcc or old gcc */
5117 /* These functions are just like the above, but they have to
5118 do the check as well as report the error. */
5120 tree_check (node, code, file, line)
5122 enum tree_code code;
5126 if (TREE_CODE (node) == code)
5129 fatal ("Internal compiler error at %s:%d:\n\texpected %s, have %s\n",
5130 file, trim_filename (file), tree_code_name[code], tree_code_name[TREE_CODE(node)]);
5134 tree_class_check (node, class, file, line)
5140 if (TREE_CODE_CLASS (TREE_CODE (node)) == class)
5143 fatal ("Internal compiler error at %s:%d:\n\
5144 \texpected '%c', have '%c' (%s)\n",
5145 file, trim_filename (file), class, TREE_CODE_CLASS (TREE_CODE (node)),
5146 tree_code_name[TREE_CODE(node)]);
5150 cst_or_constructor_check (node, file, line)
5155 enum tree_code code = TREE_CODE (node);
5157 if (code == CONSTRUCTOR || TREE_CODE_CLASS (code) == 'c')
5160 fatal ("Internal compiler error at %s:%d:\n\
5161 \texpected constructor, have %s\n",
5162 file, line, tree_code_name[code]);
5166 expr_check (node, file, line)
5171 char c = TREE_CODE_CLASS (TREE_CODE (node));
5173 if (c == 'r' || c == 's' || c == '<'
5174 || c == '1' || c == '2' || c == 'e')
5177 fatal ("Internal compiler error at %s:%d:\n\
5178 \texpected 'e', have '%c' (%s)\n",
5179 file, trim_filename (file), c, tree_code_name[TREE_CODE (node)]);
5182 #endif /* not gcc or old gcc */
5183 #endif /* ENABLE_CHECKING */
5185 /* Return the alias set for T, which may be either a type or an
5192 if (!flag_strict_aliasing || !lang_get_alias_set)
5193 /* If we're not doing any lanaguage-specific alias analysis, just
5194 assume everything aliases everything else. */
5197 return (*lang_get_alias_set) (t);
5200 /* Return a brand-new alias set. */
5205 static int last_alias_set;
5206 if (flag_strict_aliasing)
5207 return ++last_alias_set;