1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 88, 92-97, 1998 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. */
46 #define obstack_chunk_alloc xmalloc
47 #define obstack_chunk_free free
48 /* obstack.[ch] explicitly declined to prototype this. */
49 extern int _obstack_allocated_p
PROTO ((struct obstack
*h
, GENERIC_PTR obj
));
51 /* Tree nodes of permanent duration are allocated in this obstack.
52 They are the identifier nodes, and everything outside of
53 the bodies and parameters of function definitions. */
55 struct obstack permanent_obstack
;
57 /* The initial RTL, and all ..._TYPE nodes, in a function
58 are allocated in this obstack. Usually they are freed at the
59 end of the function, but if the function is inline they are saved.
60 For top-level functions, this is maybepermanent_obstack.
61 Separate obstacks are made for nested functions. */
63 struct obstack
*function_maybepermanent_obstack
;
65 /* This is the function_maybepermanent_obstack for top-level functions. */
67 struct obstack maybepermanent_obstack
;
69 /* This is a list of function_maybepermanent_obstacks for top-level inline
70 functions that are compiled in the middle of compiling other functions. */
72 struct simple_obstack_stack
*toplev_inline_obstacks
;
74 /* Former elements of toplev_inline_obstacks that have been recycled. */
76 struct simple_obstack_stack
*extra_inline_obstacks
;
78 /* This is a list of function_maybepermanent_obstacks for inline functions
79 nested in the current function that were compiled in the middle of
80 compiling other functions. */
82 struct simple_obstack_stack
*inline_obstacks
;
84 /* The contents of the current function definition are allocated
85 in this obstack, and all are freed at the end of the function.
86 For top-level functions, this is temporary_obstack.
87 Separate obstacks are made for nested functions. */
89 struct obstack
*function_obstack
;
91 /* This is used for reading initializers of global variables. */
93 struct obstack temporary_obstack
;
95 /* The tree nodes of an expression are allocated
96 in this obstack, and all are freed at the end of the expression. */
98 struct obstack momentary_obstack
;
100 /* The tree nodes of a declarator are allocated
101 in this obstack, and all are freed when the declarator
104 static struct obstack temp_decl_obstack
;
106 /* This points at either permanent_obstack
107 or the current function_maybepermanent_obstack. */
109 struct obstack
*saveable_obstack
;
111 /* This is same as saveable_obstack during parse and expansion phase;
112 it points to the current function's obstack during optimization.
113 This is the obstack to be used for creating rtl objects. */
115 struct obstack
*rtl_obstack
;
117 /* This points at either permanent_obstack or the current function_obstack. */
119 struct obstack
*current_obstack
;
121 /* This points at either permanent_obstack or the current function_obstack
122 or momentary_obstack. */
124 struct obstack
*expression_obstack
;
126 /* Stack of obstack selections for push_obstacks and pop_obstacks. */
130 struct obstack_stack
*next
;
131 struct obstack
*current
;
132 struct obstack
*saveable
;
133 struct obstack
*expression
;
137 struct obstack_stack
*obstack_stack
;
139 /* Obstack for allocating struct obstack_stack entries. */
141 static struct obstack obstack_stack_obstack
;
143 /* Addresses of first objects in some obstacks.
144 This is for freeing their entire contents. */
145 char *maybepermanent_firstobj
;
146 char *temporary_firstobj
;
147 char *momentary_firstobj
;
148 char *temp_decl_firstobj
;
150 /* This is used to preserve objects (mainly array initializers) that need to
151 live until the end of the current function, but no further. */
152 char *momentary_function_firstobj
;
154 /* Nonzero means all ..._TYPE nodes should be allocated permanently. */
156 int all_types_permanent
;
158 /* Stack of places to restore the momentary obstack back to. */
160 struct momentary_level
162 /* Pointer back to previous such level. */
163 struct momentary_level
*prev
;
164 /* First object allocated within this level. */
166 /* Value of expression_obstack saved at entry to this level. */
167 struct obstack
*obstack
;
170 struct momentary_level
*momentary_stack
;
172 /* Table indexed by tree code giving a string containing a character
173 classifying the tree code. Possibilities are
174 t, d, s, c, r, <, 1, 2 and e. See tree.def for details. */
176 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
178 char tree_code_type
[MAX_TREE_CODES
] = {
183 /* Table indexed by tree code giving number of expression
184 operands beyond the fixed part of the node structure.
185 Not used for types or decls. */
187 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
189 int tree_code_length
[MAX_TREE_CODES
] = {
194 /* Names of tree components.
195 Used for printing out the tree and error messages. */
196 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
198 char *tree_code_name
[MAX_TREE_CODES
] = {
203 /* Statistics-gathering stuff. */
224 int tree_node_counts
[(int)all_kinds
];
225 int tree_node_sizes
[(int)all_kinds
];
226 int id_string_size
= 0;
228 char *tree_node_kind_names
[] = {
246 /* Hash table for uniquizing IDENTIFIER_NODEs by name. */
248 #define MAX_HASH_TABLE 1009
249 static tree hash_table
[MAX_HASH_TABLE
]; /* id hash buckets */
251 /* 0 while creating built-in identifiers. */
252 static int do_identifier_warnings
;
254 /* Unique id for next decl created. */
255 static int next_decl_uid
;
256 /* Unique id for next type created. */
257 static int next_type_uid
= 1;
259 /* The language-specific function for alias analysis. If NULL, the
260 language does not do any special alias analysis. */
261 int (*lang_get_alias_set
) PROTO((tree
));
263 /* Here is how primitive or already-canonicalized types' hash
265 #define TYPE_HASH(TYPE) ((unsigned long) (TYPE) & 0777777)
267 extern char *mode_name
[];
269 void gcc_obstack_init ();
271 /* Init the principal obstacks. */
276 gcc_obstack_init (&obstack_stack_obstack
);
277 gcc_obstack_init (&permanent_obstack
);
279 gcc_obstack_init (&temporary_obstack
);
280 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
281 gcc_obstack_init (&momentary_obstack
);
282 momentary_firstobj
= (char *) obstack_alloc (&momentary_obstack
, 0);
283 momentary_function_firstobj
= momentary_firstobj
;
284 gcc_obstack_init (&maybepermanent_obstack
);
285 maybepermanent_firstobj
286 = (char *) obstack_alloc (&maybepermanent_obstack
, 0);
287 gcc_obstack_init (&temp_decl_obstack
);
288 temp_decl_firstobj
= (char *) obstack_alloc (&temp_decl_obstack
, 0);
290 function_obstack
= &temporary_obstack
;
291 function_maybepermanent_obstack
= &maybepermanent_obstack
;
292 current_obstack
= &permanent_obstack
;
293 expression_obstack
= &permanent_obstack
;
294 rtl_obstack
= saveable_obstack
= &permanent_obstack
;
296 /* Init the hash table of identifiers. */
297 bzero ((char *) hash_table
, sizeof hash_table
);
301 gcc_obstack_init (obstack
)
302 struct obstack
*obstack
;
304 /* Let particular systems override the size of a chunk. */
305 #ifndef OBSTACK_CHUNK_SIZE
306 #define OBSTACK_CHUNK_SIZE 0
308 /* Let them override the alloc and free routines too. */
309 #ifndef OBSTACK_CHUNK_ALLOC
310 #define OBSTACK_CHUNK_ALLOC xmalloc
312 #ifndef OBSTACK_CHUNK_FREE
313 #define OBSTACK_CHUNK_FREE free
315 _obstack_begin (obstack
, OBSTACK_CHUNK_SIZE
, 0,
316 (void *(*) ()) OBSTACK_CHUNK_ALLOC
,
317 (void (*) ()) OBSTACK_CHUNK_FREE
);
320 /* Save all variables describing the current status into the structure *P.
321 This is used before starting a nested function.
323 CONTEXT is the decl_function_context for the function we're about to
324 compile; if it isn't current_function_decl, we have to play some games. */
327 save_tree_status (p
, context
)
331 p
->all_types_permanent
= all_types_permanent
;
332 p
->momentary_stack
= momentary_stack
;
333 p
->maybepermanent_firstobj
= maybepermanent_firstobj
;
334 p
->temporary_firstobj
= temporary_firstobj
;
335 p
->momentary_firstobj
= momentary_firstobj
;
336 p
->momentary_function_firstobj
= momentary_function_firstobj
;
337 p
->function_obstack
= function_obstack
;
338 p
->function_maybepermanent_obstack
= function_maybepermanent_obstack
;
339 p
->current_obstack
= current_obstack
;
340 p
->expression_obstack
= expression_obstack
;
341 p
->saveable_obstack
= saveable_obstack
;
342 p
->rtl_obstack
= rtl_obstack
;
343 p
->inline_obstacks
= inline_obstacks
;
345 if (context
== current_function_decl
)
346 /* Objects that need to be saved in this function can be in the nonsaved
347 obstack of the enclosing function since they can't possibly be needed
348 once it has returned. */
349 function_maybepermanent_obstack
= function_obstack
;
352 /* We're compiling a function which isn't nested in the current
353 function. We need to create a new maybepermanent_obstack for this
354 function, since it can't go onto any of the existing obstacks. */
355 struct simple_obstack_stack
**head
;
356 struct simple_obstack_stack
*current
;
358 if (context
== NULL_TREE
)
359 head
= &toplev_inline_obstacks
;
362 struct function
*f
= find_function_data (context
);
363 head
= &f
->inline_obstacks
;
366 if (context
== NULL_TREE
&& extra_inline_obstacks
)
368 current
= extra_inline_obstacks
;
369 extra_inline_obstacks
= current
->next
;
373 current
= ((struct simple_obstack_stack
*)
374 xmalloc (sizeof (struct simple_obstack_stack
)));
377 = (struct obstack
*) xmalloc (sizeof (struct obstack
));
378 gcc_obstack_init (current
->obstack
);
381 function_maybepermanent_obstack
= current
->obstack
;
383 current
->next
= *head
;
387 maybepermanent_firstobj
388 = (char *) obstack_finish (function_maybepermanent_obstack
);
390 function_obstack
= (struct obstack
*) xmalloc (sizeof (struct obstack
));
391 gcc_obstack_init (function_obstack
);
393 current_obstack
= &permanent_obstack
;
394 expression_obstack
= &permanent_obstack
;
395 rtl_obstack
= saveable_obstack
= &permanent_obstack
;
397 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
398 momentary_firstobj
= (char *) obstack_finish (&momentary_obstack
);
399 momentary_function_firstobj
= momentary_firstobj
;
402 /* Restore all variables describing the current status from the structure *P.
403 This is used after a nested function. */
406 restore_tree_status (p
, context
)
410 all_types_permanent
= p
->all_types_permanent
;
411 momentary_stack
= p
->momentary_stack
;
413 obstack_free (&momentary_obstack
, momentary_function_firstobj
);
415 /* Free saveable storage used by the function just compiled and not
418 CAUTION: This is in function_obstack of the containing function.
419 So we must be sure that we never allocate from that obstack during
420 the compilation of a nested function if we expect it to survive
421 past the nested function's end. */
422 obstack_free (function_maybepermanent_obstack
, maybepermanent_firstobj
);
424 /* If we were compiling a toplevel function, we can free this space now. */
425 if (context
== NULL_TREE
)
427 obstack_free (&temporary_obstack
, temporary_firstobj
);
428 obstack_free (&momentary_obstack
, momentary_function_firstobj
);
431 /* If we were compiling a toplevel function that we don't actually want
432 to save anything from, return the obstack to the pool. */
433 if (context
== NULL_TREE
434 && obstack_empty_p (function_maybepermanent_obstack
))
436 struct simple_obstack_stack
*current
, **p
= &toplev_inline_obstacks
;
440 while ((*p
)->obstack
!= function_maybepermanent_obstack
)
445 current
->next
= extra_inline_obstacks
;
446 extra_inline_obstacks
= current
;
450 obstack_free (function_obstack
, 0);
451 free (function_obstack
);
453 temporary_firstobj
= p
->temporary_firstobj
;
454 momentary_firstobj
= p
->momentary_firstobj
;
455 momentary_function_firstobj
= p
->momentary_function_firstobj
;
456 maybepermanent_firstobj
= p
->maybepermanent_firstobj
;
457 function_obstack
= p
->function_obstack
;
458 function_maybepermanent_obstack
= p
->function_maybepermanent_obstack
;
459 current_obstack
= p
->current_obstack
;
460 expression_obstack
= p
->expression_obstack
;
461 saveable_obstack
= p
->saveable_obstack
;
462 rtl_obstack
= p
->rtl_obstack
;
463 inline_obstacks
= p
->inline_obstacks
;
466 /* Start allocating on the temporary (per function) obstack.
467 This is done in start_function before parsing the function body,
468 and before each initialization at top level, and to go back
469 to temporary allocation after doing permanent_allocation. */
472 temporary_allocation ()
474 /* Note that function_obstack at top level points to temporary_obstack.
475 But within a nested function context, it is a separate obstack. */
476 current_obstack
= function_obstack
;
477 expression_obstack
= function_obstack
;
478 rtl_obstack
= saveable_obstack
= function_maybepermanent_obstack
;
483 /* Start allocating on the permanent obstack but don't
484 free the temporary data. After calling this, call
485 `permanent_allocation' to fully resume permanent allocation status. */
488 end_temporary_allocation ()
490 current_obstack
= &permanent_obstack
;
491 expression_obstack
= &permanent_obstack
;
492 rtl_obstack
= saveable_obstack
= &permanent_obstack
;
495 /* Resume allocating on the temporary obstack, undoing
496 effects of `end_temporary_allocation'. */
499 resume_temporary_allocation ()
501 current_obstack
= function_obstack
;
502 expression_obstack
= function_obstack
;
503 rtl_obstack
= saveable_obstack
= function_maybepermanent_obstack
;
506 /* While doing temporary allocation, switch to allocating in such a
507 way as to save all nodes if the function is inlined. Call
508 resume_temporary_allocation to go back to ordinary temporary
512 saveable_allocation ()
514 /* Note that function_obstack at top level points to temporary_obstack.
515 But within a nested function context, it is a separate obstack. */
516 expression_obstack
= current_obstack
= saveable_obstack
;
519 /* Switch to current obstack CURRENT and maybepermanent obstack SAVEABLE,
520 recording the previously current obstacks on a stack.
521 This does not free any storage in any obstack. */
524 push_obstacks (current
, saveable
)
525 struct obstack
*current
, *saveable
;
527 struct obstack_stack
*p
528 = (struct obstack_stack
*) obstack_alloc (&obstack_stack_obstack
,
529 (sizeof (struct obstack_stack
)));
531 p
->current
= current_obstack
;
532 p
->saveable
= saveable_obstack
;
533 p
->expression
= expression_obstack
;
534 p
->rtl
= rtl_obstack
;
535 p
->next
= obstack_stack
;
538 current_obstack
= current
;
539 expression_obstack
= current
;
540 rtl_obstack
= saveable_obstack
= saveable
;
543 /* Save the current set of obstacks, but don't change them. */
546 push_obstacks_nochange ()
548 struct obstack_stack
*p
549 = (struct obstack_stack
*) obstack_alloc (&obstack_stack_obstack
,
550 (sizeof (struct obstack_stack
)));
552 p
->current
= current_obstack
;
553 p
->saveable
= saveable_obstack
;
554 p
->expression
= expression_obstack
;
555 p
->rtl
= rtl_obstack
;
556 p
->next
= obstack_stack
;
560 /* Pop the obstack selection stack. */
565 struct obstack_stack
*p
= obstack_stack
;
566 obstack_stack
= p
->next
;
568 current_obstack
= p
->current
;
569 saveable_obstack
= p
->saveable
;
570 expression_obstack
= p
->expression
;
571 rtl_obstack
= p
->rtl
;
573 obstack_free (&obstack_stack_obstack
, p
);
576 /* Nonzero if temporary allocation is currently in effect.
577 Zero if currently doing permanent allocation. */
580 allocation_temporary_p ()
582 return current_obstack
!= &permanent_obstack
;
585 /* Go back to allocating on the permanent obstack
586 and free everything in the temporary obstack.
588 FUNCTION_END is true only if we have just finished compiling a function.
589 In that case, we also free preserved initial values on the momentary
593 permanent_allocation (function_end
)
596 /* Free up previous temporary obstack data */
597 obstack_free (&temporary_obstack
, temporary_firstobj
);
600 obstack_free (&momentary_obstack
, momentary_function_firstobj
);
601 momentary_firstobj
= momentary_function_firstobj
;
604 obstack_free (&momentary_obstack
, momentary_firstobj
);
605 obstack_free (function_maybepermanent_obstack
, maybepermanent_firstobj
);
606 obstack_free (&temp_decl_obstack
, temp_decl_firstobj
);
608 /* Free up the maybepermanent_obstacks for any of our nested functions
609 which were compiled at a lower level. */
610 while (inline_obstacks
)
612 struct simple_obstack_stack
*current
= inline_obstacks
;
613 inline_obstacks
= current
->next
;
614 obstack_free (current
->obstack
, 0);
615 free (current
->obstack
);
619 current_obstack
= &permanent_obstack
;
620 expression_obstack
= &permanent_obstack
;
621 rtl_obstack
= saveable_obstack
= &permanent_obstack
;
624 /* Save permanently everything on the maybepermanent_obstack. */
629 maybepermanent_firstobj
630 = (char *) obstack_alloc (function_maybepermanent_obstack
, 0);
634 preserve_initializer ()
636 struct momentary_level
*tem
;
640 = (char *) obstack_alloc (&temporary_obstack
, 0);
641 maybepermanent_firstobj
642 = (char *) obstack_alloc (function_maybepermanent_obstack
, 0);
644 old_momentary
= momentary_firstobj
;
646 = (char *) obstack_alloc (&momentary_obstack
, 0);
647 if (momentary_firstobj
!= old_momentary
)
648 for (tem
= momentary_stack
; tem
; tem
= tem
->prev
)
649 tem
->base
= momentary_firstobj
;
652 /* Start allocating new rtl in current_obstack.
653 Use resume_temporary_allocation
654 to go back to allocating rtl in saveable_obstack. */
657 rtl_in_current_obstack ()
659 rtl_obstack
= current_obstack
;
662 /* Start allocating rtl from saveable_obstack. Intended to be used after
663 a call to push_obstacks_nochange. */
666 rtl_in_saveable_obstack ()
668 rtl_obstack
= saveable_obstack
;
671 /* Allocate SIZE bytes in the current obstack
672 and return a pointer to them.
673 In practice the current obstack is always the temporary one. */
679 return (char *) obstack_alloc (current_obstack
, size
);
682 /* Free the object PTR in the current obstack
683 as well as everything allocated since PTR.
684 In practice the current obstack is always the temporary one. */
690 obstack_free (current_obstack
, ptr
);
693 /* Allocate SIZE bytes in the permanent obstack
694 and return a pointer to them. */
700 return (char *) obstack_alloc (&permanent_obstack
, size
);
703 /* Allocate NELEM items of SIZE bytes in the permanent obstack
704 and return a pointer to them. The storage is cleared before
705 returning the value. */
708 perm_calloc (nelem
, size
)
712 char *rval
= (char *) obstack_alloc (&permanent_obstack
, nelem
* size
);
713 bzero (rval
, nelem
* size
);
717 /* Allocate SIZE bytes in the saveable obstack
718 and return a pointer to them. */
724 return (char *) obstack_alloc (saveable_obstack
, size
);
727 /* Allocate SIZE bytes in the expression obstack
728 and return a pointer to them. */
734 return (char *) obstack_alloc (expression_obstack
, size
);
737 /* Print out which obstack an object is in. */
740 print_obstack_name (object
, file
, prefix
)
745 struct obstack
*obstack
= NULL
;
746 char *obstack_name
= NULL
;
749 for (p
= outer_function_chain
; p
; p
= p
->next
)
751 if (_obstack_allocated_p (p
->function_obstack
, object
))
753 obstack
= p
->function_obstack
;
754 obstack_name
= "containing function obstack";
756 if (_obstack_allocated_p (p
->function_maybepermanent_obstack
, object
))
758 obstack
= p
->function_maybepermanent_obstack
;
759 obstack_name
= "containing function maybepermanent obstack";
763 if (_obstack_allocated_p (&obstack_stack_obstack
, object
))
765 obstack
= &obstack_stack_obstack
;
766 obstack_name
= "obstack_stack_obstack";
768 else if (_obstack_allocated_p (function_obstack
, object
))
770 obstack
= function_obstack
;
771 obstack_name
= "function obstack";
773 else if (_obstack_allocated_p (&permanent_obstack
, object
))
775 obstack
= &permanent_obstack
;
776 obstack_name
= "permanent_obstack";
778 else if (_obstack_allocated_p (&momentary_obstack
, object
))
780 obstack
= &momentary_obstack
;
781 obstack_name
= "momentary_obstack";
783 else if (_obstack_allocated_p (function_maybepermanent_obstack
, object
))
785 obstack
= function_maybepermanent_obstack
;
786 obstack_name
= "function maybepermanent obstack";
788 else if (_obstack_allocated_p (&temp_decl_obstack
, object
))
790 obstack
= &temp_decl_obstack
;
791 obstack_name
= "temp_decl_obstack";
794 /* Check to see if the object is in the free area of the obstack. */
797 if (object
>= obstack
->next_free
798 && object
< obstack
->chunk_limit
)
799 fprintf (file
, "%s in free portion of obstack %s",
800 prefix
, obstack_name
);
802 fprintf (file
, "%s allocated from %s", prefix
, obstack_name
);
805 fprintf (file
, "%s not allocated from any obstack", prefix
);
809 debug_obstack (object
)
812 print_obstack_name (object
, stderr
, "object");
813 fprintf (stderr
, ".\n");
816 /* Return 1 if OBJ is in the permanent obstack.
817 This is slow, and should be used only for debugging.
818 Use TREE_PERMANENT for other purposes. */
821 object_permanent_p (obj
)
824 return _obstack_allocated_p (&permanent_obstack
, obj
);
827 /* Start a level of momentary allocation.
828 In C, each compound statement has its own level
829 and that level is freed at the end of each statement.
830 All expression nodes are allocated in the momentary allocation level. */
835 struct momentary_level
*tem
836 = (struct momentary_level
*) obstack_alloc (&momentary_obstack
,
837 sizeof (struct momentary_level
));
838 tem
->prev
= momentary_stack
;
839 tem
->base
= (char *) obstack_base (&momentary_obstack
);
840 tem
->obstack
= expression_obstack
;
841 momentary_stack
= tem
;
842 expression_obstack
= &momentary_obstack
;
845 /* Set things up so the next clear_momentary will only clear memory
846 past our present position in momentary_obstack. */
849 preserve_momentary ()
851 momentary_stack
->base
= (char *) obstack_base (&momentary_obstack
);
854 /* Free all the storage in the current momentary-allocation level.
855 In C, this happens at the end of each statement. */
860 obstack_free (&momentary_obstack
, momentary_stack
->base
);
863 /* Discard a level of momentary allocation.
864 In C, this happens at the end of each compound statement.
865 Restore the status of expression node allocation
866 that was in effect before this level was created. */
871 struct momentary_level
*tem
= momentary_stack
;
872 momentary_stack
= tem
->prev
;
873 expression_obstack
= tem
->obstack
;
874 /* We can't free TEM from the momentary_obstack, because there might
875 be objects above it which have been saved. We can free back to the
876 stack of the level we are popping off though. */
877 obstack_free (&momentary_obstack
, tem
->base
);
880 /* Pop back to the previous level of momentary allocation,
881 but don't free any momentary data just yet. */
884 pop_momentary_nofree ()
886 struct momentary_level
*tem
= momentary_stack
;
887 momentary_stack
= tem
->prev
;
888 expression_obstack
= tem
->obstack
;
891 /* Call when starting to parse a declaration:
892 make expressions in the declaration last the length of the function.
893 Returns an argument that should be passed to resume_momentary later. */
898 register int tem
= expression_obstack
== &momentary_obstack
;
899 expression_obstack
= saveable_obstack
;
903 /* Call when finished parsing a declaration:
904 restore the treatment of node-allocation that was
905 in effect before the suspension.
906 YES should be the value previously returned by suspend_momentary. */
909 resume_momentary (yes
)
913 expression_obstack
= &momentary_obstack
;
916 /* Init the tables indexed by tree code.
917 Note that languages can add to these tables to define their own codes. */
925 /* Return a newly allocated node of code CODE.
926 Initialize the node's unique id and its TREE_PERMANENT flag.
927 For decl and type nodes, some other fields are initialized.
928 The rest of the node is initialized to zero.
930 Achoo! I got a code in the node. */
937 register int type
= TREE_CODE_CLASS (code
);
938 register int length
= 0;
939 register struct obstack
*obstack
= current_obstack
;
941 #ifdef GATHER_STATISTICS
942 register tree_node_kind kind
;
947 case 'd': /* A decl node */
948 #ifdef GATHER_STATISTICS
951 length
= sizeof (struct tree_decl
);
952 /* All decls in an inline function need to be saved. */
953 if (obstack
!= &permanent_obstack
)
954 obstack
= saveable_obstack
;
956 /* PARM_DECLs go on the context of the parent. If this is a nested
957 function, then we must allocate the PARM_DECL on the parent's
958 obstack, so that they will live to the end of the parent's
959 closing brace. This is necessary in case we try to inline the
960 function into its parent.
962 PARM_DECLs of top-level functions do not have this problem. However,
963 we allocate them where we put the FUNCTION_DECL for languages such as
964 Ada that need to consult some flags in the PARM_DECLs of the function
967 See comment in restore_tree_status for why we can't put this
968 in function_obstack. */
969 if (code
== PARM_DECL
&& obstack
!= &permanent_obstack
)
972 if (current_function_decl
)
973 context
= decl_function_context (current_function_decl
);
977 = find_function_data (context
)->function_maybepermanent_obstack
;
981 case 't': /* a type node */
982 #ifdef GATHER_STATISTICS
985 length
= sizeof (struct tree_type
);
986 /* All data types are put where we can preserve them if nec. */
987 if (obstack
!= &permanent_obstack
)
988 obstack
= all_types_permanent
? &permanent_obstack
: saveable_obstack
;
991 case 'b': /* a lexical block */
992 #ifdef GATHER_STATISTICS
995 length
= sizeof (struct tree_block
);
996 /* All BLOCK nodes are put where we can preserve them if nec. */
997 if (obstack
!= &permanent_obstack
)
998 obstack
= saveable_obstack
;
1001 case 's': /* an expression with side effects */
1002 #ifdef GATHER_STATISTICS
1006 case 'r': /* a reference */
1007 #ifdef GATHER_STATISTICS
1011 case 'e': /* an expression */
1012 case '<': /* a comparison expression */
1013 case '1': /* a unary arithmetic expression */
1014 case '2': /* a binary arithmetic expression */
1015 #ifdef GATHER_STATISTICS
1019 obstack
= expression_obstack
;
1020 /* All BIND_EXPR nodes are put where we can preserve them if nec. */
1021 if (code
== BIND_EXPR
&& obstack
!= &permanent_obstack
)
1022 obstack
= saveable_obstack
;
1023 length
= sizeof (struct tree_exp
)
1024 + (tree_code_length
[(int) code
] - 1) * sizeof (char *);
1027 case 'c': /* a constant */
1028 #ifdef GATHER_STATISTICS
1031 obstack
= expression_obstack
;
1033 /* We can't use tree_code_length for INTEGER_CST, since the number of
1034 words is machine-dependent due to varying length of HOST_WIDE_INT,
1035 which might be wider than a pointer (e.g., long long). Similarly
1036 for REAL_CST, since the number of words is machine-dependent due
1037 to varying size and alignment of `double'. */
1039 if (code
== INTEGER_CST
)
1040 length
= sizeof (struct tree_int_cst
);
1041 else if (code
== REAL_CST
)
1042 length
= sizeof (struct tree_real_cst
);
1044 length
= sizeof (struct tree_common
)
1045 + tree_code_length
[(int) code
] * sizeof (char *);
1048 case 'x': /* something random, like an identifier. */
1049 #ifdef GATHER_STATISTICS
1050 if (code
== IDENTIFIER_NODE
)
1052 else if (code
== OP_IDENTIFIER
)
1054 else if (code
== TREE_VEC
)
1059 length
= sizeof (struct tree_common
)
1060 + tree_code_length
[(int) code
] * sizeof (char *);
1061 /* Identifier nodes are always permanent since they are
1062 unique in a compiler run. */
1063 if (code
== IDENTIFIER_NODE
) obstack
= &permanent_obstack
;
1070 t
= (tree
) obstack_alloc (obstack
, length
);
1072 #ifdef GATHER_STATISTICS
1073 tree_node_counts
[(int)kind
]++;
1074 tree_node_sizes
[(int)kind
] += length
;
1077 /* Clear a word at a time. */
1078 for (i
= (length
/ sizeof (int)) - 1; i
>= 0; i
--)
1080 /* Clear any extra bytes. */
1081 for (i
= length
/ sizeof (int) * sizeof (int); i
< length
; i
++)
1082 ((char *) t
)[i
] = 0;
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
++;
1106 TYPE_UID (t
) = next_type_uid
++;
1108 TYPE_MAIN_VARIANT (t
) = t
;
1109 TYPE_OBSTACK (t
) = obstack
;
1110 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
1111 #ifdef SET_DEFAULT_TYPE_ATTRIBUTES
1112 SET_DEFAULT_TYPE_ATTRIBUTES (t
);
1114 /* Note that we have not yet computed the alias set for this
1116 TYPE_ALIAS_SET (t
) = -1;
1120 TREE_CONSTANT (t
) = 1;
1127 /* Return a new node with the same contents as NODE
1128 except that its TREE_CHAIN is zero and it has a fresh uid. */
1135 register enum tree_code code
= TREE_CODE (node
);
1136 register int length
= 0;
1139 switch (TREE_CODE_CLASS (code
))
1141 case 'd': /* A decl node */
1142 length
= sizeof (struct tree_decl
);
1145 case 't': /* a type node */
1146 length
= sizeof (struct tree_type
);
1149 case 'b': /* a lexical block node */
1150 length
= sizeof (struct tree_block
);
1153 case 'r': /* a reference */
1154 case 'e': /* an expression */
1155 case 's': /* an expression with side effects */
1156 case '<': /* a comparison expression */
1157 case '1': /* a unary arithmetic expression */
1158 case '2': /* a binary arithmetic expression */
1159 length
= sizeof (struct tree_exp
)
1160 + (tree_code_length
[(int) code
] - 1) * sizeof (char *);
1163 case 'c': /* a constant */
1164 /* We can't use tree_code_length for INTEGER_CST, since the number of
1165 words is machine-dependent due to varying length of HOST_WIDE_INT,
1166 which might be wider than a pointer (e.g., long long). Similarly
1167 for REAL_CST, since the number of words is machine-dependent due
1168 to varying size and alignment of `double'. */
1169 if (code
== INTEGER_CST
)
1170 length
= sizeof (struct tree_int_cst
);
1171 else if (code
== REAL_CST
)
1172 length
= sizeof (struct tree_real_cst
);
1174 length
= (sizeof (struct tree_common
)
1175 + tree_code_length
[(int) code
] * sizeof (char *));
1178 case 'x': /* something random, like an identifier. */
1179 length
= sizeof (struct tree_common
)
1180 + tree_code_length
[(int) code
] * sizeof (char *);
1181 if (code
== TREE_VEC
)
1182 length
+= (TREE_VEC_LENGTH (node
) - 1) * sizeof (char *);
1185 t
= (tree
) obstack_alloc (current_obstack
, length
);
1187 for (i
= (length
/ sizeof (int)) - 1; i
>= 0; i
--)
1188 ((int *) t
)[i
] = ((int *) node
)[i
];
1189 /* Clear any extra bytes. */
1190 for (i
= length
/ sizeof (int) * sizeof (int); i
< length
; i
++)
1191 ((char *) t
)[i
] = ((char *) node
)[i
];
1193 /* EXPR_WITH_FILE_LOCATION must keep filename info stored in TREE_CHAIN */
1194 if (TREE_CODE (node
) != EXPR_WITH_FILE_LOCATION
)
1196 TREE_ASM_WRITTEN (t
) = 0;
1198 if (TREE_CODE_CLASS (code
) == 'd')
1199 DECL_UID (t
) = next_decl_uid
++;
1200 else if (TREE_CODE_CLASS (code
) == 't')
1202 TYPE_UID (t
) = next_type_uid
++;
1203 TYPE_OBSTACK (t
) = current_obstack
;
1205 /* The following is so that the debug code for
1206 the copy is different from the original type.
1207 The two statements usually duplicate each other
1208 (because they clear fields of the same union),
1209 but the optimizer should catch that. */
1210 TYPE_SYMTAB_POINTER (t
) = 0;
1211 TYPE_SYMTAB_ADDRESS (t
) = 0;
1214 TREE_PERMANENT (t
) = (current_obstack
== &permanent_obstack
);
1219 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1220 For example, this can copy a list made of TREE_LIST nodes. */
1227 register tree prev
, next
;
1232 head
= prev
= copy_node (list
);
1233 next
= TREE_CHAIN (list
);
1236 TREE_CHAIN (prev
) = copy_node (next
);
1237 prev
= TREE_CHAIN (prev
);
1238 next
= TREE_CHAIN (next
);
1245 /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
1246 If an identifier with that name has previously been referred to,
1247 the same node is returned this time. */
1250 get_identifier (text
)
1251 register char *text
;
1256 register int len
, hash_len
;
1258 /* Compute length of text in len. */
1259 for (len
= 0; text
[len
]; len
++);
1261 /* Decide how much of that length to hash on */
1263 if (warn_id_clash
&& len
> id_clash_len
)
1264 hash_len
= id_clash_len
;
1266 /* Compute hash code */
1267 hi
= hash_len
* 613 + (unsigned) text
[0];
1268 for (i
= 1; i
< hash_len
; i
+= 2)
1269 hi
= ((hi
* 613) + (unsigned) (text
[i
]));
1271 hi
&= (1 << HASHBITS
) - 1;
1272 hi
%= MAX_HASH_TABLE
;
1274 /* Search table for identifier */
1275 for (idp
= hash_table
[hi
]; idp
; idp
= TREE_CHAIN (idp
))
1276 if (IDENTIFIER_LENGTH (idp
) == len
1277 && IDENTIFIER_POINTER (idp
)[0] == text
[0]
1278 && !bcmp (IDENTIFIER_POINTER (idp
), text
, len
))
1279 return idp
; /* <-- return if found */
1281 /* Not found; optionally warn about a similar identifier */
1282 if (warn_id_clash
&& do_identifier_warnings
&& len
>= id_clash_len
)
1283 for (idp
= hash_table
[hi
]; idp
; idp
= TREE_CHAIN (idp
))
1284 if (!strncmp (IDENTIFIER_POINTER (idp
), text
, id_clash_len
))
1286 warning ("`%s' and `%s' identical in first %d characters",
1287 IDENTIFIER_POINTER (idp
), text
, id_clash_len
);
1291 if (tree_code_length
[(int) IDENTIFIER_NODE
] < 0)
1292 abort (); /* set_identifier_size hasn't been called. */
1294 /* Not found, create one, add to chain */
1295 idp
= make_node (IDENTIFIER_NODE
);
1296 IDENTIFIER_LENGTH (idp
) = len
;
1297 #ifdef GATHER_STATISTICS
1298 id_string_size
+= len
;
1301 IDENTIFIER_POINTER (idp
) = obstack_copy0 (&permanent_obstack
, text
, len
);
1303 TREE_CHAIN (idp
) = hash_table
[hi
];
1304 hash_table
[hi
] = idp
;
1305 return idp
; /* <-- return if created */
1308 /* If an identifier with the name TEXT (a null-terminated string) has
1309 previously been referred to, return that node; otherwise return
1313 maybe_get_identifier (text
)
1314 register char *text
;
1319 register int len
, hash_len
;
1321 /* Compute length of text in len. */
1322 for (len
= 0; text
[len
]; len
++);
1324 /* Decide how much of that length to hash on */
1326 if (warn_id_clash
&& len
> id_clash_len
)
1327 hash_len
= id_clash_len
;
1329 /* Compute hash code */
1330 hi
= hash_len
* 613 + (unsigned) text
[0];
1331 for (i
= 1; i
< hash_len
; i
+= 2)
1332 hi
= ((hi
* 613) + (unsigned) (text
[i
]));
1334 hi
&= (1 << HASHBITS
) - 1;
1335 hi
%= MAX_HASH_TABLE
;
1337 /* Search table for identifier */
1338 for (idp
= hash_table
[hi
]; idp
; idp
= TREE_CHAIN (idp
))
1339 if (IDENTIFIER_LENGTH (idp
) == len
1340 && IDENTIFIER_POINTER (idp
)[0] == text
[0]
1341 && !bcmp (IDENTIFIER_POINTER (idp
), text
, len
))
1342 return idp
; /* <-- return if found */
1347 /* Enable warnings on similar identifiers (if requested).
1348 Done after the built-in identifiers are created. */
1351 start_identifier_warnings ()
1353 do_identifier_warnings
= 1;
1356 /* Record the size of an identifier node for the language in use.
1357 SIZE is the total size in bytes.
1358 This is called by the language-specific files. This must be
1359 called before allocating any identifiers. */
1362 set_identifier_size (size
)
1365 tree_code_length
[(int) IDENTIFIER_NODE
]
1366 = (size
- sizeof (struct tree_common
)) / sizeof (tree
);
1369 /* Return a newly constructed INTEGER_CST node whose constant value
1370 is specified by the two ints LOW and HI.
1371 The TREE_TYPE is set to `int'.
1373 This function should be used via the `build_int_2' macro. */
1376 build_int_2_wide (low
, hi
)
1377 HOST_WIDE_INT low
, hi
;
1379 register tree t
= make_node (INTEGER_CST
);
1380 TREE_INT_CST_LOW (t
) = low
;
1381 TREE_INT_CST_HIGH (t
) = hi
;
1382 TREE_TYPE (t
) = integer_type_node
;
1386 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1389 build_real (type
, d
)
1396 /* Check for valid float value for this type on this target machine;
1397 if not, can print error message and store a valid value in D. */
1398 #ifdef CHECK_FLOAT_VALUE
1399 CHECK_FLOAT_VALUE (TYPE_MODE (type
), d
, overflow
);
1402 v
= make_node (REAL_CST
);
1403 TREE_TYPE (v
) = type
;
1404 TREE_REAL_CST (v
) = d
;
1405 TREE_OVERFLOW (v
) = TREE_CONSTANT_OVERFLOW (v
) = overflow
;
1409 /* Return a new REAL_CST node whose type is TYPE
1410 and whose value is the integer value of the INTEGER_CST node I. */
1412 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1415 real_value_from_int_cst (type
, i
)
1420 #ifdef REAL_ARITHMETIC
1421 if (! TREE_UNSIGNED (TREE_TYPE (i
)))
1422 REAL_VALUE_FROM_INT (d
, TREE_INT_CST_LOW (i
), TREE_INT_CST_HIGH (i
),
1425 REAL_VALUE_FROM_UNSIGNED_INT (d
, TREE_INT_CST_LOW (i
),
1426 TREE_INT_CST_HIGH (i
), TYPE_MODE (type
));
1427 #else /* not REAL_ARITHMETIC */
1428 /* Some 386 compilers mishandle unsigned int to float conversions,
1429 so introduce a temporary variable E to avoid those bugs. */
1430 if (TREE_INT_CST_HIGH (i
) < 0 && ! TREE_UNSIGNED (TREE_TYPE (i
)))
1434 d
= (double) (~ TREE_INT_CST_HIGH (i
));
1435 e
= ((double) ((HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
/ 2))
1436 * (double) ((HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
/ 2)));
1438 e
= (double) (unsigned HOST_WIDE_INT
) (~ TREE_INT_CST_LOW (i
));
1446 d
= (double) (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (i
);
1447 e
= ((double) ((HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
/ 2))
1448 * (double) ((HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
/ 2)));
1450 e
= (double) (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (i
);
1453 #endif /* not REAL_ARITHMETIC */
1457 /* This function can't be implemented if we can't do arithmetic
1458 on the float representation. */
1461 build_real_from_int_cst (type
, i
)
1466 int overflow
= TREE_OVERFLOW (i
);
1468 jmp_buf float_error
;
1470 v
= make_node (REAL_CST
);
1471 TREE_TYPE (v
) = type
;
1473 if (setjmp (float_error
))
1480 set_float_handler (float_error
);
1482 #ifdef REAL_ARITHMETIC
1483 d
= real_value_from_int_cst (type
, i
);
1485 d
= REAL_VALUE_TRUNCATE (TYPE_MODE (type
),
1486 real_value_from_int_cst (type
, i
));
1489 /* Check for valid float value for this type on this target machine. */
1492 set_float_handler (NULL_PTR
);
1494 #ifdef CHECK_FLOAT_VALUE
1495 CHECK_FLOAT_VALUE (TYPE_MODE (type
), d
, overflow
);
1498 TREE_REAL_CST (v
) = d
;
1499 TREE_OVERFLOW (v
) = TREE_CONSTANT_OVERFLOW (v
) = overflow
;
1503 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1505 /* Return a newly constructed STRING_CST node whose value is
1506 the LEN characters at STR.
1507 The TREE_TYPE is not initialized. */
1510 build_string (len
, str
)
1514 /* Put the string in saveable_obstack since it will be placed in the RTL
1515 for an "asm" statement and will also be kept around a while if
1516 deferring constant output in varasm.c. */
1518 register tree s
= make_node (STRING_CST
);
1519 TREE_STRING_LENGTH (s
) = len
;
1520 TREE_STRING_POINTER (s
) = obstack_copy0 (saveable_obstack
, str
, len
);
1524 /* Return a newly constructed COMPLEX_CST node whose value is
1525 specified by the real and imaginary parts REAL and IMAG.
1526 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1527 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1530 build_complex (type
, real
, imag
)
1534 register tree t
= make_node (COMPLEX_CST
);
1536 TREE_REALPART (t
) = real
;
1537 TREE_IMAGPART (t
) = imag
;
1538 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
1539 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
1540 TREE_CONSTANT_OVERFLOW (t
)
1541 = TREE_CONSTANT_OVERFLOW (real
) | TREE_CONSTANT_OVERFLOW (imag
);
1545 /* Build a newly constructed TREE_VEC node of length LEN. */
1552 register int length
= (len
-1) * sizeof (tree
) + sizeof (struct tree_vec
);
1553 register struct obstack
*obstack
= current_obstack
;
1556 #ifdef GATHER_STATISTICS
1557 tree_node_counts
[(int)vec_kind
]++;
1558 tree_node_sizes
[(int)vec_kind
] += length
;
1561 t
= (tree
) obstack_alloc (obstack
, length
);
1563 for (i
= (length
/ sizeof (int)) - 1; i
>= 0; i
--)
1566 TREE_SET_CODE (t
, TREE_VEC
);
1567 TREE_VEC_LENGTH (t
) = len
;
1568 if (obstack
== &permanent_obstack
)
1569 TREE_PERMANENT (t
) = 1;
1574 /* Return 1 if EXPR is the integer constant zero or a complex constant
1578 integer_zerop (expr
)
1583 return ((TREE_CODE (expr
) == INTEGER_CST
1584 && ! TREE_CONSTANT_OVERFLOW (expr
)
1585 && TREE_INT_CST_LOW (expr
) == 0
1586 && TREE_INT_CST_HIGH (expr
) == 0)
1587 || (TREE_CODE (expr
) == COMPLEX_CST
1588 && integer_zerop (TREE_REALPART (expr
))
1589 && integer_zerop (TREE_IMAGPART (expr
))));
1592 /* Return 1 if EXPR is the integer constant one or the corresponding
1593 complex constant. */
1601 return ((TREE_CODE (expr
) == INTEGER_CST
1602 && ! TREE_CONSTANT_OVERFLOW (expr
)
1603 && TREE_INT_CST_LOW (expr
) == 1
1604 && TREE_INT_CST_HIGH (expr
) == 0)
1605 || (TREE_CODE (expr
) == COMPLEX_CST
1606 && integer_onep (TREE_REALPART (expr
))
1607 && integer_zerop (TREE_IMAGPART (expr
))));
1610 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1611 it contains. Likewise for the corresponding complex constant. */
1614 integer_all_onesp (expr
)
1622 if (TREE_CODE (expr
) == COMPLEX_CST
1623 && integer_all_onesp (TREE_REALPART (expr
))
1624 && integer_zerop (TREE_IMAGPART (expr
)))
1627 else if (TREE_CODE (expr
) != INTEGER_CST
1628 || TREE_CONSTANT_OVERFLOW (expr
))
1631 uns
= TREE_UNSIGNED (TREE_TYPE (expr
));
1633 return TREE_INT_CST_LOW (expr
) == -1 && TREE_INT_CST_HIGH (expr
) == -1;
1635 /* Note that using TYPE_PRECISION here is wrong. We care about the
1636 actual bits, not the (arbitrary) range of the type. */
1637 prec
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)));
1638 if (prec
>= HOST_BITS_PER_WIDE_INT
)
1640 int high_value
, shift_amount
;
1642 shift_amount
= prec
- HOST_BITS_PER_WIDE_INT
;
1644 if (shift_amount
> HOST_BITS_PER_WIDE_INT
)
1645 /* Can not handle precisions greater than twice the host int size. */
1647 else if (shift_amount
== HOST_BITS_PER_WIDE_INT
)
1648 /* Shifting by the host word size is undefined according to the ANSI
1649 standard, so we must handle this as a special case. */
1652 high_value
= ((HOST_WIDE_INT
) 1 << shift_amount
) - 1;
1654 return TREE_INT_CST_LOW (expr
) == -1
1655 && TREE_INT_CST_HIGH (expr
) == high_value
;
1658 return TREE_INT_CST_LOW (expr
) == ((HOST_WIDE_INT
) 1 << prec
) - 1;
1661 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1665 integer_pow2p (expr
)
1669 HOST_WIDE_INT high
, low
;
1673 if (TREE_CODE (expr
) == COMPLEX_CST
1674 && integer_pow2p (TREE_REALPART (expr
))
1675 && integer_zerop (TREE_IMAGPART (expr
)))
1678 if (TREE_CODE (expr
) != INTEGER_CST
|| TREE_CONSTANT_OVERFLOW (expr
))
1681 prec
= (POINTER_TYPE_P (TREE_TYPE (expr
))
1682 ? POINTER_SIZE
: TYPE_PRECISION (TREE_TYPE (expr
)));
1683 high
= TREE_INT_CST_HIGH (expr
);
1684 low
= TREE_INT_CST_LOW (expr
);
1686 /* First clear all bits that are beyond the type's precision in case
1687 we've been sign extended. */
1689 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
1691 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1692 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1696 if (prec
< HOST_BITS_PER_WIDE_INT
)
1697 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1700 if (high
== 0 && low
== 0)
1703 return ((high
== 0 && (low
& (low
- 1)) == 0)
1704 || (low
== 0 && (high
& (high
- 1)) == 0));
1707 /* Return the power of two represented by a tree node known to be a
1715 HOST_WIDE_INT high
, low
;
1719 if (TREE_CODE (expr
) == COMPLEX_CST
)
1720 return tree_log2 (TREE_REALPART (expr
));
1722 prec
= (POINTER_TYPE_P (TREE_TYPE (expr
))
1723 ? POINTER_SIZE
: TYPE_PRECISION (TREE_TYPE (expr
)));
1725 high
= TREE_INT_CST_HIGH (expr
);
1726 low
= TREE_INT_CST_LOW (expr
);
1728 /* First clear all bits that are beyond the type's precision in case
1729 we've been sign extended. */
1731 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
1733 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1734 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1738 if (prec
< HOST_BITS_PER_WIDE_INT
)
1739 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1742 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ exact_log2 (high
)
1743 : exact_log2 (low
));
1746 /* Return 1 if EXPR is the real constant zero. */
1754 return ((TREE_CODE (expr
) == REAL_CST
1755 && ! TREE_CONSTANT_OVERFLOW (expr
)
1756 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst0
))
1757 || (TREE_CODE (expr
) == COMPLEX_CST
1758 && real_zerop (TREE_REALPART (expr
))
1759 && real_zerop (TREE_IMAGPART (expr
))));
1762 /* Return 1 if EXPR is the real constant one in real or complex form. */
1770 return ((TREE_CODE (expr
) == REAL_CST
1771 && ! TREE_CONSTANT_OVERFLOW (expr
)
1772 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst1
))
1773 || (TREE_CODE (expr
) == COMPLEX_CST
1774 && real_onep (TREE_REALPART (expr
))
1775 && real_zerop (TREE_IMAGPART (expr
))));
1778 /* Return 1 if EXPR is the real constant two. */
1786 return ((TREE_CODE (expr
) == REAL_CST
1787 && ! TREE_CONSTANT_OVERFLOW (expr
)
1788 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst2
))
1789 || (TREE_CODE (expr
) == COMPLEX_CST
1790 && real_twop (TREE_REALPART (expr
))
1791 && real_zerop (TREE_IMAGPART (expr
))));
1794 /* Nonzero if EXP is a constant or a cast of a constant. */
1797 really_constant_p (exp
)
1800 /* This is not quite the same as STRIP_NOPS. It does more. */
1801 while (TREE_CODE (exp
) == NOP_EXPR
1802 || TREE_CODE (exp
) == CONVERT_EXPR
1803 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
1804 exp
= TREE_OPERAND (exp
, 0);
1805 return TREE_CONSTANT (exp
);
1808 /* Return first list element whose TREE_VALUE is ELEM.
1809 Return 0 if ELEM is not in LIST. */
1812 value_member (elem
, list
)
1817 if (elem
== TREE_VALUE (list
))
1819 list
= TREE_CHAIN (list
);
1824 /* Return first list element whose TREE_PURPOSE is ELEM.
1825 Return 0 if ELEM is not in LIST. */
1828 purpose_member (elem
, list
)
1833 if (elem
== TREE_PURPOSE (list
))
1835 list
= TREE_CHAIN (list
);
1840 /* Return first list element whose BINFO_TYPE is ELEM.
1841 Return 0 if ELEM is not in LIST. */
1844 binfo_member (elem
, list
)
1849 if (elem
== BINFO_TYPE (list
))
1851 list
= TREE_CHAIN (list
);
1856 /* Return nonzero if ELEM is part of the chain CHAIN. */
1859 chain_member (elem
, chain
)
1866 chain
= TREE_CHAIN (chain
);
1872 /* Return nonzero if ELEM is equal to TREE_VALUE (CHAIN) for any piece of
1874 /* ??? This function was added for machine specific attributes but is no
1875 longer used. It could be deleted if we could confirm all front ends
1879 chain_member_value (elem
, chain
)
1884 if (elem
== TREE_VALUE (chain
))
1886 chain
= TREE_CHAIN (chain
);
1892 /* Return nonzero if ELEM is equal to TREE_PURPOSE (CHAIN)
1893 for any piece of chain CHAIN. */
1894 /* ??? This function was added for machine specific attributes but is no
1895 longer used. It could be deleted if we could confirm all front ends
1899 chain_member_purpose (elem
, chain
)
1904 if (elem
== TREE_PURPOSE (chain
))
1906 chain
= TREE_CHAIN (chain
);
1912 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1913 We expect a null pointer to mark the end of the chain.
1914 This is the Lisp primitive `length'. */
1921 register int len
= 0;
1923 for (tail
= t
; tail
; tail
= TREE_CHAIN (tail
))
1929 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1930 by modifying the last node in chain 1 to point to chain 2.
1931 This is the Lisp primitive `nconc'. */
1943 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
1945 TREE_CHAIN (t1
) = op2
;
1946 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
1948 abort (); /* Circularity created. */
1954 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
1958 register tree chain
;
1962 while ((next
= TREE_CHAIN (chain
)))
1967 /* Reverse the order of elements in the chain T,
1968 and return the new head of the chain (old last element). */
1974 register tree prev
= 0, decl
, next
;
1975 for (decl
= t
; decl
; decl
= next
)
1977 next
= TREE_CHAIN (decl
);
1978 TREE_CHAIN (decl
) = prev
;
1984 /* Given a chain CHAIN of tree nodes,
1985 construct and return a list of those nodes. */
1991 tree result
= NULL_TREE
;
1992 tree in_tail
= chain
;
1993 tree out_tail
= NULL_TREE
;
1997 tree next
= tree_cons (NULL_TREE
, in_tail
, NULL_TREE
);
1999 TREE_CHAIN (out_tail
) = next
;
2003 in_tail
= TREE_CHAIN (in_tail
);
2009 /* Return a newly created TREE_LIST node whose
2010 purpose and value fields are PARM and VALUE. */
2013 build_tree_list (parm
, value
)
2016 register tree t
= make_node (TREE_LIST
);
2017 TREE_PURPOSE (t
) = parm
;
2018 TREE_VALUE (t
) = value
;
2022 /* Similar, but build on the temp_decl_obstack. */
2025 build_decl_list (parm
, value
)
2029 register struct obstack
*ambient_obstack
= current_obstack
;
2030 current_obstack
= &temp_decl_obstack
;
2031 node
= build_tree_list (parm
, value
);
2032 current_obstack
= ambient_obstack
;
2036 /* Similar, but build on the expression_obstack. */
2039 build_expr_list (parm
, value
)
2043 register struct obstack
*ambient_obstack
= current_obstack
;
2044 current_obstack
= expression_obstack
;
2045 node
= build_tree_list (parm
, value
);
2046 current_obstack
= ambient_obstack
;
2050 /* Return a newly created TREE_LIST node whose
2051 purpose and value fields are PARM and VALUE
2052 and whose TREE_CHAIN is CHAIN. */
2055 tree_cons (purpose
, value
, chain
)
2056 tree purpose
, value
, chain
;
2059 register tree node
= make_node (TREE_LIST
);
2062 register tree node
= (tree
) obstack_alloc (current_obstack
, sizeof (struct tree_list
));
2063 #ifdef GATHER_STATISTICS
2064 tree_node_counts
[(int)x_kind
]++;
2065 tree_node_sizes
[(int)x_kind
] += sizeof (struct tree_list
);
2068 for (i
= (sizeof (struct tree_common
) / sizeof (int)) - 1; i
>= 0; i
--)
2069 ((int *) node
)[i
] = 0;
2071 TREE_SET_CODE (node
, TREE_LIST
);
2072 if (current_obstack
== &permanent_obstack
)
2073 TREE_PERMANENT (node
) = 1;
2076 TREE_CHAIN (node
) = chain
;
2077 TREE_PURPOSE (node
) = purpose
;
2078 TREE_VALUE (node
) = value
;
2082 /* Similar, but build on the temp_decl_obstack. */
2085 decl_tree_cons (purpose
, value
, chain
)
2086 tree purpose
, value
, chain
;
2089 register struct obstack
*ambient_obstack
= current_obstack
;
2090 current_obstack
= &temp_decl_obstack
;
2091 node
= tree_cons (purpose
, value
, chain
);
2092 current_obstack
= ambient_obstack
;
2096 /* Similar, but build on the expression_obstack. */
2099 expr_tree_cons (purpose
, value
, chain
)
2100 tree purpose
, value
, chain
;
2103 register struct obstack
*ambient_obstack
= current_obstack
;
2104 current_obstack
= expression_obstack
;
2105 node
= tree_cons (purpose
, value
, chain
);
2106 current_obstack
= ambient_obstack
;
2110 /* Same as `tree_cons' but make a permanent object. */
2113 perm_tree_cons (purpose
, value
, chain
)
2114 tree purpose
, value
, chain
;
2117 register struct obstack
*ambient_obstack
= current_obstack
;
2118 current_obstack
= &permanent_obstack
;
2120 node
= tree_cons (purpose
, value
, chain
);
2121 current_obstack
= ambient_obstack
;
2125 /* Same as `tree_cons', but make this node temporary, regardless. */
2128 temp_tree_cons (purpose
, value
, chain
)
2129 tree purpose
, value
, chain
;
2132 register struct obstack
*ambient_obstack
= current_obstack
;
2133 current_obstack
= &temporary_obstack
;
2135 node
= tree_cons (purpose
, value
, chain
);
2136 current_obstack
= ambient_obstack
;
2140 /* Same as `tree_cons', but save this node if the function's RTL is saved. */
2143 saveable_tree_cons (purpose
, value
, chain
)
2144 tree purpose
, value
, chain
;
2147 register struct obstack
*ambient_obstack
= current_obstack
;
2148 current_obstack
= saveable_obstack
;
2150 node
= tree_cons (purpose
, value
, chain
);
2151 current_obstack
= ambient_obstack
;
2155 /* Return the size nominally occupied by an object of type TYPE
2156 when it resides in memory. The value is measured in units of bytes,
2157 and its data type is that normally used for type sizes
2158 (which is the first type created by make_signed_type or
2159 make_unsigned_type). */
2162 size_in_bytes (type
)
2167 if (type
== error_mark_node
)
2168 return integer_zero_node
;
2170 type
= TYPE_MAIN_VARIANT (type
);
2171 t
= TYPE_SIZE_UNIT (type
);
2174 incomplete_type_error (NULL_TREE
, type
);
2175 return integer_zero_node
;
2177 if (TREE_CODE (t
) == INTEGER_CST
)
2178 force_fit_type (t
, 0);
2183 /* Return the size of TYPE (in bytes) as a wide integer
2184 or return -1 if the size can vary or is larger than an integer. */
2187 int_size_in_bytes (type
)
2192 if (type
== error_mark_node
)
2195 type
= TYPE_MAIN_VARIANT (type
);
2196 t
= TYPE_SIZE_UNIT (type
);
2198 || TREE_CODE (t
) != INTEGER_CST
2199 || TREE_INT_CST_HIGH (t
) != 0)
2202 return TREE_INT_CST_LOW (t
);
2205 /* Return, as a tree node, the number of elements for TYPE (which is an
2206 ARRAY_TYPE) minus one. This counts only elements of the top array.
2208 Don't let any SAVE_EXPRs escape; if we are called as part of a cleanup
2209 action, they would get unsaved. */
2212 array_type_nelts (type
)
2215 tree index_type
, min
, max
;
2217 /* If they did it with unspecified bounds, then we should have already
2218 given an error about it before we got here. */
2219 if (! TYPE_DOMAIN (type
))
2220 return error_mark_node
;
2222 index_type
= TYPE_DOMAIN (type
);
2223 min
= TYPE_MIN_VALUE (index_type
);
2224 max
= TYPE_MAX_VALUE (index_type
);
2226 if (! TREE_CONSTANT (min
))
2229 if (TREE_CODE (min
) == SAVE_EXPR
)
2230 min
= build (RTL_EXPR
, TREE_TYPE (TYPE_MIN_VALUE (index_type
)), 0,
2231 SAVE_EXPR_RTL (min
));
2233 min
= TYPE_MIN_VALUE (index_type
);
2236 if (! TREE_CONSTANT (max
))
2239 if (TREE_CODE (max
) == SAVE_EXPR
)
2240 max
= build (RTL_EXPR
, TREE_TYPE (TYPE_MAX_VALUE (index_type
)), 0,
2241 SAVE_EXPR_RTL (max
));
2243 max
= TYPE_MAX_VALUE (index_type
);
2246 return (integer_zerop (min
)
2248 : fold (build (MINUS_EXPR
, TREE_TYPE (max
), max
, min
)));
2251 /* Return nonzero if arg is static -- a reference to an object in
2252 static storage. This is not the same as the C meaning of `static'. */
2258 switch (TREE_CODE (arg
))
2261 /* Nested functions aren't static, since taking their address
2262 involves a trampoline. */
2263 return (decl_function_context (arg
) == 0 || DECL_NO_STATIC_CHAIN (arg
))
2264 && ! DECL_NON_ADDR_CONST_P (arg
);
2267 return (TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
2268 && ! DECL_NON_ADDR_CONST_P (arg
);
2271 return TREE_STATIC (arg
);
2276 /* If we are referencing a bitfield, we can't evaluate an
2277 ADDR_EXPR at compile time and so it isn't a constant. */
2279 return (! DECL_BIT_FIELD (TREE_OPERAND (arg
, 1))
2280 && staticp (TREE_OPERAND (arg
, 0)));
2286 /* This case is technically correct, but results in setting
2287 TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
2290 return TREE_CONSTANT (TREE_OPERAND (arg
, 0));
2294 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
2295 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
2296 return staticp (TREE_OPERAND (arg
, 0));
2303 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2304 Do this to any expression which may be used in more than one place,
2305 but must be evaluated only once.
2307 Normally, expand_expr would reevaluate the expression each time.
2308 Calling save_expr produces something that is evaluated and recorded
2309 the first time expand_expr is called on it. Subsequent calls to
2310 expand_expr just reuse the recorded value.
2312 The call to expand_expr that generates code that actually computes
2313 the value is the first call *at compile time*. Subsequent calls
2314 *at compile time* generate code to use the saved value.
2315 This produces correct result provided that *at run time* control
2316 always flows through the insns made by the first expand_expr
2317 before reaching the other places where the save_expr was evaluated.
2318 You, the caller of save_expr, must make sure this is so.
2320 Constants, and certain read-only nodes, are returned with no
2321 SAVE_EXPR because that is safe. Expressions containing placeholders
2322 are not touched; see tree.def for an explanation of what these
2329 register tree t
= fold (expr
);
2331 /* We don't care about whether this can be used as an lvalue in this
2333 while (TREE_CODE (t
) == NON_LVALUE_EXPR
)
2334 t
= TREE_OPERAND (t
, 0);
2336 /* If the tree evaluates to a constant, then we don't want to hide that
2337 fact (i.e. this allows further folding, and direct checks for constants).
2338 However, a read-only object that has side effects cannot be bypassed.
2339 Since it is no problem to reevaluate literals, we just return the
2342 if (TREE_CONSTANT (t
) || (TREE_READONLY (t
) && ! TREE_SIDE_EFFECTS (t
))
2343 || TREE_CODE (t
) == SAVE_EXPR
|| TREE_CODE (t
) == ERROR_MARK
)
2346 /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2347 it means that the size or offset of some field of an object depends on
2348 the value within another field.
2350 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2351 and some variable since it would then need to be both evaluated once and
2352 evaluated more than once. Front-ends must assure this case cannot
2353 happen by surrounding any such subexpressions in their own SAVE_EXPR
2354 and forcing evaluation at the proper time. */
2355 if (contains_placeholder_p (t
))
2358 t
= build (SAVE_EXPR
, TREE_TYPE (expr
), t
, current_function_decl
, NULL_TREE
);
2360 /* This expression might be placed ahead of a jump to ensure that the
2361 value was computed on both sides of the jump. So make sure it isn't
2362 eliminated as dead. */
2363 TREE_SIDE_EFFECTS (t
) = 1;
2367 /* Arrange for an expression to be expanded multiple independent
2368 times. This is useful for cleanup actions, as the backend can
2369 expand them multiple times in different places. */
2377 /* If this is already protected, no sense in protecting it again. */
2378 if (TREE_CODE (expr
) == UNSAVE_EXPR
)
2381 t
= build1 (UNSAVE_EXPR
, TREE_TYPE (expr
), expr
);
2382 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (expr
);
2386 /* Returns the index of the first non-tree operand for CODE, or the number
2387 of operands if all are trees. */
2391 enum tree_code code
;
2401 case WITH_CLEANUP_EXPR
:
2402 /* Should be defined to be 2. */
2404 case METHOD_CALL_EXPR
:
2407 return tree_code_length
[(int) code
];
2411 /* Modify a tree in place so that all the evaluate only once things
2412 are cleared out. Return the EXPR given. */
2415 unsave_expr_now (expr
)
2418 enum tree_code code
;
2422 if (expr
== NULL_TREE
)
2425 code
= TREE_CODE (expr
);
2426 first_rtl
= first_rtl_op (code
);
2430 SAVE_EXPR_RTL (expr
) = 0;
2434 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
2435 TREE_OPERAND (expr
, 3) = NULL_TREE
;
2439 /* I don't yet know how to emit a sequence multiple times. */
2440 if (RTL_EXPR_SEQUENCE (expr
) != 0)
2445 CALL_EXPR_RTL (expr
) = 0;
2446 if (TREE_OPERAND (expr
, 1)
2447 && TREE_CODE (TREE_OPERAND (expr
, 1)) == TREE_LIST
)
2449 tree exp
= TREE_OPERAND (expr
, 1);
2452 unsave_expr_now (TREE_VALUE (exp
));
2453 exp
= TREE_CHAIN (exp
);
2462 switch (TREE_CODE_CLASS (code
))
2464 case 'c': /* a constant */
2465 case 't': /* a type node */
2466 case 'x': /* something random, like an identifier or an ERROR_MARK. */
2467 case 'd': /* A decl node */
2468 case 'b': /* A block node */
2471 case 'e': /* an expression */
2472 case 'r': /* a reference */
2473 case 's': /* an expression with side effects */
2474 case '<': /* a comparison expression */
2475 case '2': /* a binary arithmetic expression */
2476 case '1': /* a unary arithmetic expression */
2477 for (i
= first_rtl
- 1; i
>= 0; i
--)
2478 unsave_expr_now (TREE_OPERAND (expr
, i
));
2486 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2487 or offset that depends on a field within a record. */
2490 contains_placeholder_p (exp
)
2493 register enum tree_code code
= TREE_CODE (exp
);
2496 /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
2497 in it since it is supplying a value for it. */
2498 if (code
== WITH_RECORD_EXPR
)
2500 else if (code
== PLACEHOLDER_EXPR
)
2503 switch (TREE_CODE_CLASS (code
))
2506 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2507 position computations since they will be converted into a
2508 WITH_RECORD_EXPR involving the reference, which will assume
2509 here will be valid. */
2510 return contains_placeholder_p (TREE_OPERAND (exp
, 0));
2513 if (code
== TREE_LIST
)
2514 return (contains_placeholder_p (TREE_VALUE (exp
))
2515 || (TREE_CHAIN (exp
) != 0
2516 && contains_placeholder_p (TREE_CHAIN (exp
))));
2525 /* Ignoring the first operand isn't quite right, but works best. */
2526 return contains_placeholder_p (TREE_OPERAND (exp
, 1));
2533 return (contains_placeholder_p (TREE_OPERAND (exp
, 0))
2534 || contains_placeholder_p (TREE_OPERAND (exp
, 1))
2535 || contains_placeholder_p (TREE_OPERAND (exp
, 2)));
2538 /* If we already know this doesn't have a placeholder, don't
2540 if (SAVE_EXPR_NOPLACEHOLDER (exp
) || SAVE_EXPR_RTL (exp
) != 0)
2543 SAVE_EXPR_NOPLACEHOLDER (exp
) = 1;
2544 result
= contains_placeholder_p (TREE_OPERAND (exp
, 0));
2546 SAVE_EXPR_NOPLACEHOLDER (exp
) = 0;
2551 return (TREE_OPERAND (exp
, 1) != 0
2552 && contains_placeholder_p (TREE_OPERAND (exp
, 1)));
2558 switch (tree_code_length
[(int) code
])
2561 return contains_placeholder_p (TREE_OPERAND (exp
, 0));
2563 return (contains_placeholder_p (TREE_OPERAND (exp
, 0))
2564 || contains_placeholder_p (TREE_OPERAND (exp
, 1)));
2575 /* Return 1 if EXP contains any expressions that produce cleanups for an
2576 outer scope to deal with. Used by fold. */
2584 if (! TREE_SIDE_EFFECTS (exp
))
2587 switch (TREE_CODE (exp
))
2590 case WITH_CLEANUP_EXPR
:
2593 case CLEANUP_POINT_EXPR
:
2597 for (exp
= TREE_OPERAND (exp
, 1); exp
; exp
= TREE_CHAIN (exp
))
2599 cmp
= has_cleanups (TREE_VALUE (exp
));
2609 /* This general rule works for most tree codes. All exceptions should be
2610 handled above. If this is a language-specific tree code, we can't
2611 trust what might be in the operand, so say we don't know
2613 if ((int) TREE_CODE (exp
) >= (int) LAST_AND_UNUSED_TREE_CODE
)
2616 nops
= first_rtl_op (TREE_CODE (exp
));
2617 for (i
= 0; i
< nops
; i
++)
2618 if (TREE_OPERAND (exp
, i
) != 0)
2620 int type
= TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, i
)));
2621 if (type
== 'e' || type
== '<' || type
== '1' || type
== '2'
2622 || type
== 'r' || type
== 's')
2624 cmp
= has_cleanups (TREE_OPERAND (exp
, i
));
2633 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2634 return a tree with all occurrences of references to F in a
2635 PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
2636 contains only arithmetic expressions or a CALL_EXPR with a
2637 PLACEHOLDER_EXPR occurring only in its arglist. */
2640 substitute_in_expr (exp
, f
, r
)
2645 enum tree_code code
= TREE_CODE (exp
);
2650 switch (TREE_CODE_CLASS (code
))
2657 if (code
== PLACEHOLDER_EXPR
)
2659 else if (code
== TREE_LIST
)
2661 op0
= (TREE_CHAIN (exp
) == 0
2662 ? 0 : substitute_in_expr (TREE_CHAIN (exp
), f
, r
));
2663 op1
= substitute_in_expr (TREE_VALUE (exp
), f
, r
);
2664 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
2667 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
2676 switch (tree_code_length
[(int) code
])
2679 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2680 if (op0
== TREE_OPERAND (exp
, 0))
2683 new = fold (build1 (code
, TREE_TYPE (exp
), op0
));
2687 /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
2688 could, but we don't support it. */
2689 if (code
== RTL_EXPR
)
2691 else if (code
== CONSTRUCTOR
)
2694 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2695 op1
= substitute_in_expr (TREE_OPERAND (exp
, 1), f
, r
);
2696 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
2699 new = fold (build (code
, TREE_TYPE (exp
), op0
, op1
));
2703 /* It cannot be that anything inside a SAVE_EXPR contains a
2704 PLACEHOLDER_EXPR. */
2705 if (code
== SAVE_EXPR
)
2708 else if (code
== CALL_EXPR
)
2710 op1
= substitute_in_expr (TREE_OPERAND (exp
, 1), f
, r
);
2711 if (op1
== TREE_OPERAND (exp
, 1))
2714 return build (code
, TREE_TYPE (exp
),
2715 TREE_OPERAND (exp
, 0), op1
, NULL_TREE
);
2718 else if (code
!= COND_EXPR
)
2721 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2722 op1
= substitute_in_expr (TREE_OPERAND (exp
, 1), f
, r
);
2723 op2
= substitute_in_expr (TREE_OPERAND (exp
, 2), f
, r
);
2724 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
2725 && op2
== TREE_OPERAND (exp
, 2))
2728 new = fold (build (code
, TREE_TYPE (exp
), op0
, op1
, op2
));
2741 /* If this expression is getting a value from a PLACEHOLDER_EXPR
2742 and it is the right field, replace it with R. */
2743 for (inner
= TREE_OPERAND (exp
, 0);
2744 TREE_CODE_CLASS (TREE_CODE (inner
)) == 'r';
2745 inner
= TREE_OPERAND (inner
, 0))
2747 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
2748 && TREE_OPERAND (exp
, 1) == f
)
2751 /* If this expression hasn't been completed let, leave it
2753 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
2754 && TREE_TYPE (inner
) == 0)
2757 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2758 if (op0
== TREE_OPERAND (exp
, 0))
2761 new = fold (build (code
, TREE_TYPE (exp
), op0
,
2762 TREE_OPERAND (exp
, 1)));
2766 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2767 op1
= substitute_in_expr (TREE_OPERAND (exp
, 1), f
, r
);
2768 op2
= substitute_in_expr (TREE_OPERAND (exp
, 2), f
, r
);
2769 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
2770 && op2
== TREE_OPERAND (exp
, 2))
2773 new = fold (build (code
, TREE_TYPE (exp
), op0
, op1
, op2
));
2778 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2779 if (op0
== TREE_OPERAND (exp
, 0))
2782 new = fold (build1 (code
, TREE_TYPE (exp
), op0
));
2794 TREE_READONLY (new) = TREE_READONLY (exp
);
2798 /* Stabilize a reference so that we can use it any number of times
2799 without causing its operands to be evaluated more than once.
2800 Returns the stabilized reference. This works by means of save_expr,
2801 so see the caveats in the comments about save_expr.
2803 Also allows conversion expressions whose operands are references.
2804 Any other kind of expression is returned unchanged. */
2807 stabilize_reference (ref
)
2810 register tree result
;
2811 register enum tree_code code
= TREE_CODE (ref
);
2818 /* No action is needed in this case. */
2824 case FIX_TRUNC_EXPR
:
2825 case FIX_FLOOR_EXPR
:
2826 case FIX_ROUND_EXPR
:
2828 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
2832 result
= build_nt (INDIRECT_REF
,
2833 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
2837 result
= build_nt (COMPONENT_REF
,
2838 stabilize_reference (TREE_OPERAND (ref
, 0)),
2839 TREE_OPERAND (ref
, 1));
2843 result
= build_nt (BIT_FIELD_REF
,
2844 stabilize_reference (TREE_OPERAND (ref
, 0)),
2845 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
2846 stabilize_reference_1 (TREE_OPERAND (ref
, 2)));
2850 result
= build_nt (ARRAY_REF
,
2851 stabilize_reference (TREE_OPERAND (ref
, 0)),
2852 stabilize_reference_1 (TREE_OPERAND (ref
, 1)));
2856 /* We cannot wrap the first expression in a SAVE_EXPR, as then
2857 it wouldn't be ignored. This matters when dealing with
2859 return stabilize_reference_1 (ref
);
2862 result
= build1 (INDIRECT_REF
, TREE_TYPE (ref
),
2863 save_expr (build1 (ADDR_EXPR
,
2864 build_pointer_type (TREE_TYPE (ref
)),
2869 /* If arg isn't a kind of lvalue we recognize, make no change.
2870 Caller should recognize the error for an invalid lvalue. */
2875 return error_mark_node
;
2878 TREE_TYPE (result
) = TREE_TYPE (ref
);
2879 TREE_READONLY (result
) = TREE_READONLY (ref
);
2880 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
2881 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
2882 TREE_RAISES (result
) = TREE_RAISES (ref
);
2887 /* Subroutine of stabilize_reference; this is called for subtrees of
2888 references. Any expression with side-effects must be put in a SAVE_EXPR
2889 to ensure that it is only evaluated once.
2891 We don't put SAVE_EXPR nodes around everything, because assigning very
2892 simple expressions to temporaries causes us to miss good opportunities
2893 for optimizations. Among other things, the opportunity to fold in the
2894 addition of a constant into an addressing mode often gets lost, e.g.
2895 "y[i+1] += x;". In general, we take the approach that we should not make
2896 an assignment unless we are forced into it - i.e., that any non-side effect
2897 operator should be allowed, and that cse should take care of coalescing
2898 multiple utterances of the same expression should that prove fruitful. */
2901 stabilize_reference_1 (e
)
2904 register tree result
;
2905 register enum tree_code code
= TREE_CODE (e
);
2907 /* We cannot ignore const expressions because it might be a reference
2908 to a const array but whose index contains side-effects. But we can
2909 ignore things that are actual constant or that already have been
2910 handled by this function. */
2912 if (TREE_CONSTANT (e
) || code
== SAVE_EXPR
)
2915 switch (TREE_CODE_CLASS (code
))
2925 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2926 so that it will only be evaluated once. */
2927 /* The reference (r) and comparison (<) classes could be handled as
2928 below, but it is generally faster to only evaluate them once. */
2929 if (TREE_SIDE_EFFECTS (e
))
2930 return save_expr (e
);
2934 /* Constants need no processing. In fact, we should never reach
2939 /* Division is slow and tends to be compiled with jumps,
2940 especially the division by powers of 2 that is often
2941 found inside of an array reference. So do it just once. */
2942 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
2943 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
2944 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
2945 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
2946 return save_expr (e
);
2947 /* Recursively stabilize each operand. */
2948 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
2949 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
2953 /* Recursively stabilize each operand. */
2954 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
2961 TREE_TYPE (result
) = TREE_TYPE (e
);
2962 TREE_READONLY (result
) = TREE_READONLY (e
);
2963 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
2964 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
2965 TREE_RAISES (result
) = TREE_RAISES (e
);
2970 /* Low-level constructors for expressions. */
2972 /* Build an expression of code CODE, data type TYPE,
2973 and operands as specified by the arguments ARG1 and following arguments.
2974 Expressions and reference nodes can be created this way.
2975 Constants, decls, types and misc nodes cannot be. */
2978 build
VPROTO((enum tree_code code
, tree tt
, ...))
2981 enum tree_code code
;
2986 register int length
;
2992 code
= va_arg (p
, enum tree_code
);
2993 tt
= va_arg (p
, tree
);
2996 t
= make_node (code
);
2997 length
= tree_code_length
[(int) code
];
3002 /* This is equivalent to the loop below, but faster. */
3003 register tree arg0
= va_arg (p
, tree
);
3004 register tree arg1
= va_arg (p
, tree
);
3005 TREE_OPERAND (t
, 0) = arg0
;
3006 TREE_OPERAND (t
, 1) = arg1
;
3007 if ((arg0
&& TREE_SIDE_EFFECTS (arg0
))
3008 || (arg1
&& TREE_SIDE_EFFECTS (arg1
)))
3009 TREE_SIDE_EFFECTS (t
) = 1;
3011 = (arg0
&& TREE_RAISES (arg0
)) || (arg1
&& TREE_RAISES (arg1
));
3013 else if (length
== 1)
3015 register tree arg0
= va_arg (p
, tree
);
3017 /* Call build1 for this! */
3018 if (TREE_CODE_CLASS (code
) != 's')
3020 TREE_OPERAND (t
, 0) = arg0
;
3021 if (arg0
&& TREE_SIDE_EFFECTS (arg0
))
3022 TREE_SIDE_EFFECTS (t
) = 1;
3023 TREE_RAISES (t
) = (arg0
&& TREE_RAISES (arg0
));
3027 for (i
= 0; i
< length
; i
++)
3029 register tree operand
= va_arg (p
, tree
);
3030 TREE_OPERAND (t
, i
) = operand
;
3033 if (TREE_SIDE_EFFECTS (operand
))
3034 TREE_SIDE_EFFECTS (t
) = 1;
3035 if (TREE_RAISES (operand
))
3036 TREE_RAISES (t
) = 1;
3044 /* Same as above, but only builds for unary operators.
3045 Saves lions share of calls to `build'; cuts down use
3046 of varargs, which is expensive for RISC machines. */
3049 build1 (code
, type
, node
)
3050 enum tree_code code
;
3054 register struct obstack
*obstack
= expression_obstack
;
3055 register int i
, length
;
3056 #ifdef GATHER_STATISTICS
3057 register tree_node_kind kind
;
3061 #ifdef GATHER_STATISTICS
3062 if (TREE_CODE_CLASS (code
) == 'r')
3068 length
= sizeof (struct tree_exp
);
3070 t
= (tree
) obstack_alloc (obstack
, length
);
3072 #ifdef GATHER_STATISTICS
3073 tree_node_counts
[(int)kind
]++;
3074 tree_node_sizes
[(int)kind
] += length
;
3077 for (i
= (length
/ sizeof (int)) - 1; i
>= 0; i
--)
3080 TREE_TYPE (t
) = type
;
3081 TREE_SET_CODE (t
, code
);
3083 if (obstack
== &permanent_obstack
)
3084 TREE_PERMANENT (t
) = 1;
3086 TREE_OPERAND (t
, 0) = node
;
3089 if (TREE_SIDE_EFFECTS (node
))
3090 TREE_SIDE_EFFECTS (t
) = 1;
3091 if (TREE_RAISES (node
))
3092 TREE_RAISES (t
) = 1;
3098 /* Similar except don't specify the TREE_TYPE
3099 and leave the TREE_SIDE_EFFECTS as 0.
3100 It is permissible for arguments to be null,
3101 or even garbage if their values do not matter. */
3104 build_nt
VPROTO((enum tree_code code
, ...))
3107 enum tree_code code
;
3111 register int length
;
3117 code
= va_arg (p
, enum tree_code
);
3120 t
= make_node (code
);
3121 length
= tree_code_length
[(int) code
];
3123 for (i
= 0; i
< length
; i
++)
3124 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3130 /* Similar to `build_nt', except we build
3131 on the temp_decl_obstack, regardless. */
3134 build_parse_node
VPROTO((enum tree_code code
, ...))
3137 enum tree_code code
;
3139 register struct obstack
*ambient_obstack
= expression_obstack
;
3142 register int length
;
3148 code
= va_arg (p
, enum tree_code
);
3151 expression_obstack
= &temp_decl_obstack
;
3153 t
= make_node (code
);
3154 length
= tree_code_length
[(int) code
];
3156 for (i
= 0; i
< length
; i
++)
3157 TREE_OPERAND (t
, i
) = va_arg (p
, tree
);
3160 expression_obstack
= ambient_obstack
;
3165 /* Commented out because this wants to be done very
3166 differently. See cp-lex.c. */
3168 build_op_identifier (op1
, op2
)
3171 register tree t
= make_node (OP_IDENTIFIER
);
3172 TREE_PURPOSE (t
) = op1
;
3173 TREE_VALUE (t
) = op2
;
3178 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3179 We do NOT enter this node in any sort of symbol table.
3181 layout_decl is used to set up the decl's storage layout.
3182 Other slots are initialized to 0 or null pointers. */
3185 build_decl (code
, name
, type
)
3186 enum tree_code code
;
3191 t
= make_node (code
);
3193 /* if (type == error_mark_node)
3194 type = integer_type_node; */
3195 /* That is not done, deliberately, so that having error_mark_node
3196 as the type can suppress useless errors in the use of this variable. */
3198 DECL_NAME (t
) = name
;
3199 DECL_ASSEMBLER_NAME (t
) = name
;
3200 TREE_TYPE (t
) = type
;
3202 if (code
== VAR_DECL
|| code
== PARM_DECL
|| code
== RESULT_DECL
)
3204 else if (code
== FUNCTION_DECL
)
3205 DECL_MODE (t
) = FUNCTION_MODE
;
3210 /* BLOCK nodes are used to represent the structure of binding contours
3211 and declarations, once those contours have been exited and their contents
3212 compiled. This information is used for outputting debugging info. */
3215 build_block (vars
, tags
, subblocks
, supercontext
, chain
)
3216 tree vars
, tags
, subblocks
, supercontext
, chain
;
3218 register tree block
= make_node (BLOCK
);
3219 BLOCK_VARS (block
) = vars
;
3220 BLOCK_TYPE_TAGS (block
) = tags
;
3221 BLOCK_SUBBLOCKS (block
) = subblocks
;
3222 BLOCK_SUPERCONTEXT (block
) = supercontext
;
3223 BLOCK_CHAIN (block
) = chain
;
3227 /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact
3228 location where an expression or an identifier were encountered. It
3229 is necessary for languages where the frontend parser will handle
3230 recursively more than one file (Java is one of them). */
3233 build_expr_wfl (node
, file
, line
, col
)
3238 static char *last_file
= 0;
3239 static tree last_filenode
= NULL_TREE
;
3240 register tree wfl
= make_node (EXPR_WITH_FILE_LOCATION
);
3242 EXPR_WFL_NODE (wfl
) = node
;
3243 EXPR_WFL_SET_LINECOL (wfl
, line
, col
);
3244 if (file
!= last_file
)
3247 last_filenode
= file
? get_identifier (file
) : NULL_TREE
;
3249 EXPR_WFL_FILENAME_NODE (wfl
) = last_filenode
;
3252 TREE_SIDE_EFFECTS (wfl
) = TREE_SIDE_EFFECTS (node
);
3253 TREE_TYPE (wfl
) = TREE_TYPE (node
);
3258 /* Return a declaration like DDECL except that its DECL_MACHINE_ATTRIBUTE
3262 build_decl_attribute_variant (ddecl
, attribute
)
3263 tree ddecl
, attribute
;
3265 DECL_MACHINE_ATTRIBUTES (ddecl
) = attribute
;
3269 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
3272 Record such modified types already made so we don't make duplicates. */
3275 build_type_attribute_variant (ttype
, attribute
)
3276 tree ttype
, attribute
;
3278 if ( ! attribute_list_equal (TYPE_ATTRIBUTES (ttype
), attribute
))
3280 register int hashcode
;
3281 register struct obstack
*ambient_obstack
= current_obstack
;
3284 if (ambient_obstack
!= &permanent_obstack
)
3285 current_obstack
= TYPE_OBSTACK (ttype
);
3287 ntype
= copy_node (ttype
);
3288 current_obstack
= ambient_obstack
;
3290 TYPE_POINTER_TO (ntype
) = 0;
3291 TYPE_REFERENCE_TO (ntype
) = 0;
3292 TYPE_ATTRIBUTES (ntype
) = attribute
;
3294 /* Create a new main variant of TYPE. */
3295 TYPE_MAIN_VARIANT (ntype
) = ntype
;
3296 TYPE_NEXT_VARIANT (ntype
) = 0;
3297 TYPE_READONLY (ntype
) = TYPE_VOLATILE (ntype
) = 0;
3299 hashcode
= TYPE_HASH (TREE_CODE (ntype
))
3300 + TYPE_HASH (TREE_TYPE (ntype
))
3301 + attribute_hash_list (attribute
);
3303 switch (TREE_CODE (ntype
))
3306 hashcode
+= TYPE_HASH (TYPE_ARG_TYPES (ntype
));
3309 hashcode
+= TYPE_HASH (TYPE_DOMAIN (ntype
));
3312 hashcode
+= TYPE_HASH (TYPE_MAX_VALUE (ntype
));
3315 hashcode
+= TYPE_HASH (TYPE_PRECISION (ntype
));
3321 ntype
= type_hash_canon (hashcode
, ntype
);
3322 ttype
= build_type_variant (ntype
, TYPE_READONLY (ttype
),
3323 TYPE_VOLATILE (ttype
));
3329 /* Return a 1 if ATTR_NAME and ATTR_ARGS is valid for either declaration DECL
3330 or type TYPE and 0 otherwise. Validity is determined the configuration
3331 macros VALID_MACHINE_DECL_ATTRIBUTE and VALID_MACHINE_TYPE_ATTRIBUTE. */
3334 valid_machine_attribute (attr_name
, attr_args
, decl
, type
)
3335 tree attr_name
, attr_args
;
3340 #ifdef VALID_MACHINE_DECL_ATTRIBUTE
3341 tree decl_attr_list
= decl
!= 0 ? DECL_MACHINE_ATTRIBUTES (decl
) : 0;
3343 #ifdef VALID_MACHINE_TYPE_ATTRIBUTE
3344 tree type_attr_list
= TYPE_ATTRIBUTES (type
);
3347 if (TREE_CODE (attr_name
) != IDENTIFIER_NODE
)
3350 #ifdef VALID_MACHINE_DECL_ATTRIBUTE
3352 && VALID_MACHINE_DECL_ATTRIBUTE (decl
, decl_attr_list
, attr_name
, attr_args
))
3354 tree attr
= lookup_attribute (IDENTIFIER_POINTER (attr_name
),
3357 if (attr
!= NULL_TREE
)
3359 /* Override existing arguments. Declarations are unique so we can
3360 modify this in place. */
3361 TREE_VALUE (attr
) = attr_args
;
3365 decl_attr_list
= tree_cons (attr_name
, attr_args
, decl_attr_list
);
3366 decl
= build_decl_attribute_variant (decl
, decl_attr_list
);
3373 #ifdef VALID_MACHINE_TYPE_ATTRIBUTE
3375 /* Don't apply the attribute to both the decl and the type. */;
3376 else if (VALID_MACHINE_TYPE_ATTRIBUTE (type
, type_attr_list
, attr_name
,
3379 tree attr
= lookup_attribute (IDENTIFIER_POINTER (attr_name
),
3382 if (attr
!= NULL_TREE
)
3384 /* Override existing arguments.
3385 ??? This currently works since attribute arguments are not
3386 included in `attribute_hash_list'. Something more complicated
3387 may be needed in the future. */
3388 TREE_VALUE (attr
) = attr_args
;
3392 /* If this is part of a declaration, create a type variant,
3393 otherwise, this is part of a type definition, so add it
3394 to the base type. */
3395 type_attr_list
= tree_cons (attr_name
, attr_args
, type_attr_list
);
3397 type
= build_type_attribute_variant (type
, type_attr_list
);
3399 TYPE_ATTRIBUTES (type
) = type_attr_list
;
3402 TREE_TYPE (decl
) = type
;
3406 /* Handle putting a type attribute on pointer-to-function-type by putting
3407 the attribute on the function type. */
3408 else if (POINTER_TYPE_P (type
)
3409 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
3410 && VALID_MACHINE_TYPE_ATTRIBUTE (TREE_TYPE (type
), type_attr_list
,
3411 attr_name
, attr_args
))
3413 tree inner_type
= TREE_TYPE (type
);
3414 tree inner_attr_list
= TYPE_ATTRIBUTES (inner_type
);
3415 tree attr
= lookup_attribute (IDENTIFIER_POINTER (attr_name
),
3418 if (attr
!= NULL_TREE
)
3419 TREE_VALUE (attr
) = attr_args
;
3422 inner_attr_list
= tree_cons (attr_name
, attr_args
, inner_attr_list
);
3423 inner_type
= build_type_attribute_variant (inner_type
,
3428 TREE_TYPE (decl
) = build_pointer_type (inner_type
);
3437 /* Return non-zero if IDENT is a valid name for attribute ATTR,
3440 We try both `text' and `__text__', ATTR may be either one. */
3441 /* ??? It might be a reasonable simplification to require ATTR to be only
3442 `text'. One might then also require attribute lists to be stored in
3443 their canonicalized form. */
3446 is_attribute_p (attr
, ident
)
3450 int ident_len
, attr_len
;
3453 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
3456 if (strcmp (attr
, IDENTIFIER_POINTER (ident
)) == 0)
3459 p
= IDENTIFIER_POINTER (ident
);
3460 ident_len
= strlen (p
);
3461 attr_len
= strlen (attr
);
3463 /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
3467 || attr
[attr_len
- 2] != '_'
3468 || attr
[attr_len
- 1] != '_')
3470 if (ident_len
== attr_len
- 4
3471 && strncmp (attr
+ 2, p
, attr_len
- 4) == 0)
3476 if (ident_len
== attr_len
+ 4
3477 && p
[0] == '_' && p
[1] == '_'
3478 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
3479 && strncmp (attr
, p
+ 2, attr_len
) == 0)
3486 /* Given an attribute name and a list of attributes, return a pointer to the
3487 attribute's list element if the attribute is part of the list, or NULL_TREE
3491 lookup_attribute (attr_name
, list
)
3497 for (l
= list
; l
; l
= TREE_CHAIN (l
))
3499 if (TREE_CODE (TREE_PURPOSE (l
)) != IDENTIFIER_NODE
)
3501 if (is_attribute_p (attr_name
, TREE_PURPOSE (l
)))
3508 /* Return an attribute list that is the union of a1 and a2. */
3511 merge_attributes (a1
, a2
)
3512 register tree a1
, a2
;
3516 /* Either one unset? Take the set one. */
3518 if (! (attributes
= a1
))
3521 /* One that completely contains the other? Take it. */
3523 else if (a2
&& ! attribute_list_contained (a1
, a2
))
3525 if (attribute_list_contained (a2
, a1
))
3529 /* Pick the longest list, and hang on the other list. */
3530 /* ??? For the moment we punt on the issue of attrs with args. */
3532 if (list_length (a1
) < list_length (a2
))
3533 attributes
= a2
, a2
= a1
;
3535 for (; a2
; a2
= TREE_CHAIN (a2
))
3536 if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2
)),
3537 attributes
) == NULL_TREE
)
3539 a1
= copy_node (a2
);
3540 TREE_CHAIN (a1
) = attributes
;
3548 /* Given types T1 and T2, merge their attributes and return
3552 merge_machine_type_attributes (t1
, t2
)
3555 #ifdef MERGE_MACHINE_TYPE_ATTRIBUTES
3556 return MERGE_MACHINE_TYPE_ATTRIBUTES (t1
, t2
);
3558 return merge_attributes (TYPE_ATTRIBUTES (t1
),
3559 TYPE_ATTRIBUTES (t2
));
3563 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
3567 merge_machine_decl_attributes (olddecl
, newdecl
)
3568 tree olddecl
, newdecl
;
3570 #ifdef MERGE_MACHINE_DECL_ATTRIBUTES
3571 return MERGE_MACHINE_DECL_ATTRIBUTES (olddecl
, newdecl
);
3573 return merge_attributes (DECL_MACHINE_ATTRIBUTES (olddecl
),
3574 DECL_MACHINE_ATTRIBUTES (newdecl
));
3578 /* Return a type like TYPE except that its TYPE_READONLY is CONSTP
3579 and its TYPE_VOLATILE is VOLATILEP.
3581 Such variant types already made are recorded so that duplicates
3584 A variant types should never be used as the type of an expression.
3585 Always copy the variant information into the TREE_READONLY
3586 and TREE_THIS_VOLATILE of the expression, and then give the expression
3587 as its type the "main variant", the variant whose TYPE_READONLY
3588 and TYPE_VOLATILE are zero. Use TYPE_MAIN_VARIANT to find the
3592 build_type_variant (type
, constp
, volatilep
)
3594 int constp
, volatilep
;
3598 /* Treat any nonzero argument as 1. */
3600 volatilep
= !!volatilep
;
3602 /* Search the chain of variants to see if there is already one there just
3603 like the one we need to have. If so, use that existing one. We must
3604 preserve the TYPE_NAME, since there is code that depends on this. */
3606 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
3607 if (constp
== TYPE_READONLY (t
) && volatilep
== TYPE_VOLATILE (t
)
3608 && TYPE_NAME (t
) == TYPE_NAME (type
))
3611 /* We need a new one. */
3613 t
= build_type_copy (type
);
3614 TYPE_READONLY (t
) = constp
;
3615 TYPE_VOLATILE (t
) = volatilep
;
3620 /* Create a new variant of TYPE, equivalent but distinct.
3621 This is so the caller can modify it. */
3624 build_type_copy (type
)
3627 register tree t
, m
= TYPE_MAIN_VARIANT (type
);
3628 register struct obstack
*ambient_obstack
= current_obstack
;
3630 current_obstack
= TYPE_OBSTACK (type
);
3631 t
= copy_node (type
);
3632 current_obstack
= ambient_obstack
;
3634 TYPE_POINTER_TO (t
) = 0;
3635 TYPE_REFERENCE_TO (t
) = 0;
3637 /* Add this type to the chain of variants of TYPE. */
3638 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
3639 TYPE_NEXT_VARIANT (m
) = t
;
3644 /* Hashing of types so that we don't make duplicates.
3645 The entry point is `type_hash_canon'. */
3647 /* Each hash table slot is a bucket containing a chain
3648 of these structures. */
3652 struct type_hash
*next
; /* Next structure in the bucket. */
3653 int hashcode
; /* Hash code of this type. */
3654 tree type
; /* The type recorded here. */
3657 /* Now here is the hash table. When recording a type, it is added
3658 to the slot whose index is the hash code mod the table size.
3659 Note that the hash table is used for several kinds of types
3660 (function types, array types and array index range types, for now).
3661 While all these live in the same table, they are completely independent,
3662 and the hash code is computed differently for each of these. */
3664 #define TYPE_HASH_SIZE 59
3665 struct type_hash
*type_hash_table
[TYPE_HASH_SIZE
];
3667 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
3668 with types in the TREE_VALUE slots), by adding the hash codes
3669 of the individual types. */
3672 type_hash_list (list
)
3675 register int hashcode
;
3677 for (hashcode
= 0, tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3678 hashcode
+= TYPE_HASH (TREE_VALUE (tail
));
3682 /* Look in the type hash table for a type isomorphic to TYPE.
3683 If one is found, return it. Otherwise return 0. */
3686 type_hash_lookup (hashcode
, type
)
3690 register struct type_hash
*h
;
3691 for (h
= type_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
3692 if (h
->hashcode
== hashcode
3693 && TREE_CODE (h
->type
) == TREE_CODE (type
)
3694 && TREE_TYPE (h
->type
) == TREE_TYPE (type
)
3695 && attribute_list_equal (TYPE_ATTRIBUTES (h
->type
),
3696 TYPE_ATTRIBUTES (type
))
3697 && (TYPE_MAX_VALUE (h
->type
) == TYPE_MAX_VALUE (type
)
3698 || tree_int_cst_equal (TYPE_MAX_VALUE (h
->type
),
3699 TYPE_MAX_VALUE (type
)))
3700 && (TYPE_MIN_VALUE (h
->type
) == TYPE_MIN_VALUE (type
)
3701 || tree_int_cst_equal (TYPE_MIN_VALUE (h
->type
),
3702 TYPE_MIN_VALUE (type
)))
3703 /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE. */
3704 && (TYPE_DOMAIN (h
->type
) == TYPE_DOMAIN (type
)
3705 || (TYPE_DOMAIN (h
->type
)
3706 && TREE_CODE (TYPE_DOMAIN (h
->type
)) == TREE_LIST
3707 && TYPE_DOMAIN (type
)
3708 && TREE_CODE (TYPE_DOMAIN (type
)) == TREE_LIST
3709 && type_list_equal (TYPE_DOMAIN (h
->type
),
3710 TYPE_DOMAIN (type
)))))
3715 /* Add an entry to the type-hash-table
3716 for a type TYPE whose hash code is HASHCODE. */
3719 type_hash_add (hashcode
, type
)
3723 register struct type_hash
*h
;
3725 h
= (struct type_hash
*) oballoc (sizeof (struct type_hash
));
3726 h
->hashcode
= hashcode
;
3728 h
->next
= type_hash_table
[hashcode
% TYPE_HASH_SIZE
];
3729 type_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
3732 /* Given TYPE, and HASHCODE its hash code, return the canonical
3733 object for an identical type if one already exists.
3734 Otherwise, return TYPE, and record it as the canonical object
3735 if it is a permanent object.
3737 To use this function, first create a type of the sort you want.
3738 Then compute its hash code from the fields of the type that
3739 make it different from other similar types.
3740 Then call this function and use the value.
3741 This function frees the type you pass in if it is a duplicate. */
3743 /* Set to 1 to debug without canonicalization. Never set by program. */
3744 int debug_no_type_hash
= 0;
3747 type_hash_canon (hashcode
, type
)
3753 if (debug_no_type_hash
)
3756 t1
= type_hash_lookup (hashcode
, type
);
3759 obstack_free (TYPE_OBSTACK (type
), type
);
3760 #ifdef GATHER_STATISTICS
3761 tree_node_counts
[(int)t_kind
]--;
3762 tree_node_sizes
[(int)t_kind
] -= sizeof (struct tree_type
);
3767 /* If this is a permanent type, record it for later reuse. */
3768 if (TREE_PERMANENT (type
))
3769 type_hash_add (hashcode
, type
);
3774 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
3775 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
3776 by adding the hash codes of the individual attributes. */
3779 attribute_hash_list (list
)
3782 register int hashcode
;
3784 for (hashcode
= 0, tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3785 /* ??? Do we want to add in TREE_VALUE too? */
3786 hashcode
+= TYPE_HASH (TREE_PURPOSE (tail
));
3790 /* Given two lists of attributes, return true if list l2 is
3791 equivalent to l1. */
3794 attribute_list_equal (l1
, l2
)
3797 return attribute_list_contained (l1
, l2
)
3798 && attribute_list_contained (l2
, l1
);
3801 /* Given two lists of attributes, return true if list L2 is
3802 completely contained within L1. */
3803 /* ??? This would be faster if attribute names were stored in a canonicalized
3804 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
3805 must be used to show these elements are equivalent (which they are). */
3806 /* ??? It's not clear that attributes with arguments will always be handled
3810 attribute_list_contained (l1
, l2
)
3813 register tree t1
, t2
;
3815 /* First check the obvious, maybe the lists are identical. */
3819 /* Maybe the lists are similar. */
3820 for (t1
= l1
, t2
= l2
;
3822 && TREE_PURPOSE (t1
) == TREE_PURPOSE (t2
)
3823 && TREE_VALUE (t1
) == TREE_VALUE (t2
);
3824 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
));
3826 /* Maybe the lists are equal. */
3827 if (t1
== 0 && t2
== 0)
3830 for (; t2
; t2
= TREE_CHAIN (t2
))
3833 = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2
)), l1
);
3835 if (attr
== NULL_TREE
)
3837 if (simple_cst_equal (TREE_VALUE (t2
), TREE_VALUE (attr
)) != 1)
3844 /* Given two lists of types
3845 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
3846 return 1 if the lists contain the same types in the same order.
3847 Also, the TREE_PURPOSEs must match. */
3850 type_list_equal (l1
, l2
)
3853 register tree t1
, t2
;
3855 for (t1
= l1
, t2
= l2
; t1
&& t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
3856 if (TREE_VALUE (t1
) != TREE_VALUE (t2
)
3857 || (TREE_PURPOSE (t1
) != TREE_PURPOSE (t2
)
3858 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
))
3859 && (TREE_TYPE (TREE_PURPOSE (t1
))
3860 == TREE_TYPE (TREE_PURPOSE (t2
))))))
3866 /* Nonzero if integer constants T1 and T2
3867 represent the same constant value. */
3870 tree_int_cst_equal (t1
, t2
)
3875 if (t1
== 0 || t2
== 0)
3877 if (TREE_CODE (t1
) == INTEGER_CST
3878 && TREE_CODE (t2
) == INTEGER_CST
3879 && TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
3880 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
))
3885 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
3886 The precise way of comparison depends on their data type. */
3889 tree_int_cst_lt (t1
, t2
)
3895 if (!TREE_UNSIGNED (TREE_TYPE (t1
)))
3896 return INT_CST_LT (t1
, t2
);
3897 return INT_CST_LT_UNSIGNED (t1
, t2
);
3900 /* Return an indication of the sign of the integer constant T.
3901 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3902 Note that -1 will never be returned it T's type is unsigned. */
3905 tree_int_cst_sgn (t
)
3908 if (TREE_INT_CST_LOW (t
) == 0 && TREE_INT_CST_HIGH (t
) == 0)
3910 else if (TREE_UNSIGNED (TREE_TYPE (t
)))
3912 else if (TREE_INT_CST_HIGH (t
) < 0)
3918 /* Compare two constructor-element-type constants. Return 1 if the lists
3919 are known to be equal; otherwise return 0. */
3922 simple_cst_list_equal (l1
, l2
)
3925 while (l1
!= NULL_TREE
&& l2
!= NULL_TREE
)
3927 if (simple_cst_equal (TREE_VALUE (l1
), TREE_VALUE (l2
)) != 1)
3930 l1
= TREE_CHAIN (l1
);
3931 l2
= TREE_CHAIN (l2
);
3937 /* Return truthvalue of whether T1 is the same tree structure as T2.
3938 Return 1 if they are the same.
3939 Return 0 if they are understandably different.
3940 Return -1 if either contains tree structure not understood by
3944 simple_cst_equal (t1
, t2
)
3947 register enum tree_code code1
, code2
;
3952 if (t1
== 0 || t2
== 0)
3955 code1
= TREE_CODE (t1
);
3956 code2
= TREE_CODE (t2
);
3958 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
3960 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
3961 || code2
== NON_LVALUE_EXPR
)
3962 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3964 return simple_cst_equal (TREE_OPERAND (t1
, 0), t2
);
3966 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
3967 || code2
== NON_LVALUE_EXPR
)
3968 return simple_cst_equal (t1
, TREE_OPERAND (t2
, 0));
3976 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
3977 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
3980 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
3983 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3984 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3985 TREE_STRING_LENGTH (t1
));
3988 if (CONSTRUCTOR_ELTS (t1
) == CONSTRUCTOR_ELTS (t2
))
3994 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3997 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4000 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
4003 /* Special case: if either target is an unallocated VAR_DECL,
4004 it means that it's going to be unified with whatever the
4005 TARGET_EXPR is really supposed to initialize, so treat it
4006 as being equivalent to anything. */
4007 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
4008 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
4009 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
4010 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
4011 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
4012 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
4015 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4018 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
4020 case WITH_CLEANUP_EXPR
:
4021 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4024 return simple_cst_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
4027 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
4028 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4041 /* This general rule works for most tree codes. All exceptions should be
4042 handled above. If this is a language-specific tree code, we can't
4043 trust what might be in the operand, so say we don't know
4045 if ((int) code1
>= (int) LAST_AND_UNUSED_TREE_CODE
)
4048 switch (TREE_CODE_CLASS (code1
))
4058 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
4060 cmp
= simple_cst_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
4071 /* Constructors for pointer, array and function types.
4072 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
4073 constructed by language-dependent code, not here.) */
4075 /* Construct, lay out and return the type of pointers to TO_TYPE.
4076 If such a type has already been constructed, reuse it. */
4079 build_pointer_type (to_type
)
4082 register tree t
= TYPE_POINTER_TO (to_type
);
4084 /* First, if we already have a type for pointers to TO_TYPE, use it. */
4089 /* We need a new one. Put this in the same obstack as TO_TYPE. */
4090 push_obstacks (TYPE_OBSTACK (to_type
), TYPE_OBSTACK (to_type
));
4091 t
= make_node (POINTER_TYPE
);
4094 TREE_TYPE (t
) = to_type
;
4096 /* Record this type as the pointer to TO_TYPE. */
4097 TYPE_POINTER_TO (to_type
) = t
;
4099 /* Lay out the type. This function has many callers that are concerned
4100 with expression-construction, and this simplifies them all.
4101 Also, it guarantees the TYPE_SIZE is in the same obstack as the type. */
4107 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
4108 MAXVAL should be the maximum value in the domain
4109 (one less than the length of the array).
4111 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
4112 We don't enforce this limit, that is up to caller (e.g. language front end).
4113 The limit exists because the result is a signed type and we don't handle
4114 sizes that use more than one HOST_WIDE_INT. */
4117 build_index_type (maxval
)
4120 register tree itype
= make_node (INTEGER_TYPE
);
4122 TYPE_PRECISION (itype
) = TYPE_PRECISION (sizetype
);
4123 TYPE_MIN_VALUE (itype
) = size_zero_node
;
4125 push_obstacks (TYPE_OBSTACK (itype
), TYPE_OBSTACK (itype
));
4126 TYPE_MAX_VALUE (itype
) = convert (sizetype
, maxval
);
4129 TYPE_MODE (itype
) = TYPE_MODE (sizetype
);
4130 TYPE_SIZE (itype
) = TYPE_SIZE (sizetype
);
4131 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (sizetype
);
4132 TYPE_ALIGN (itype
) = TYPE_ALIGN (sizetype
);
4133 if (TREE_CODE (maxval
) == INTEGER_CST
)
4135 int maxint
= (int) TREE_INT_CST_LOW (maxval
);
4136 /* If the domain should be empty, make sure the maxval
4137 remains -1 and is not spoiled by truncation. */
4138 if (INT_CST_LT (maxval
, integer_zero_node
))
4140 TYPE_MAX_VALUE (itype
) = build_int_2 (-1, -1);
4141 TREE_TYPE (TYPE_MAX_VALUE (itype
)) = sizetype
;
4143 return type_hash_canon (maxint
< 0 ? ~maxint
: maxint
, itype
);
4149 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
4150 ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
4151 low bound LOWVAL and high bound HIGHVAL.
4152 if TYPE==NULL_TREE, sizetype is used. */
4155 build_range_type (type
, lowval
, highval
)
4156 tree type
, lowval
, highval
;
4158 register tree itype
= make_node (INTEGER_TYPE
);
4160 TREE_TYPE (itype
) = type
;
4161 if (type
== NULL_TREE
)
4164 push_obstacks (TYPE_OBSTACK (itype
), TYPE_OBSTACK (itype
));
4165 TYPE_MIN_VALUE (itype
) = convert (type
, lowval
);
4166 TYPE_MAX_VALUE (itype
) = highval
? convert (type
, highval
) : NULL
;
4169 TYPE_PRECISION (itype
) = TYPE_PRECISION (type
);
4170 TYPE_MODE (itype
) = TYPE_MODE (type
);
4171 TYPE_SIZE (itype
) = TYPE_SIZE (type
);
4172 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (type
);
4173 TYPE_ALIGN (itype
) = TYPE_ALIGN (type
);
4174 if (TREE_CODE (lowval
) == INTEGER_CST
)
4176 HOST_WIDE_INT lowint
, highint
;
4179 lowint
= TREE_INT_CST_LOW (lowval
);
4180 if (highval
&& TREE_CODE (highval
) == INTEGER_CST
)
4181 highint
= TREE_INT_CST_LOW (highval
);
4183 highint
= (~(unsigned HOST_WIDE_INT
)0) >> 1;
4185 maxint
= (int) (highint
- lowint
);
4186 return type_hash_canon (maxint
< 0 ? ~maxint
: maxint
, itype
);
4192 /* Just like build_index_type, but takes lowval and highval instead
4193 of just highval (maxval). */
4196 build_index_2_type (lowval
,highval
)
4197 tree lowval
, highval
;
4199 return build_range_type (NULL_TREE
, lowval
, highval
);
4202 /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense).
4203 Needed because when index types are not hashed, equal index types
4204 built at different times appear distinct, even though structurally,
4208 index_type_equal (itype1
, itype2
)
4209 tree itype1
, itype2
;
4211 if (TREE_CODE (itype1
) != TREE_CODE (itype2
))
4213 if (TREE_CODE (itype1
) == INTEGER_TYPE
)
4215 if (TYPE_PRECISION (itype1
) != TYPE_PRECISION (itype2
)
4216 || TYPE_MODE (itype1
) != TYPE_MODE (itype2
)
4217 || simple_cst_equal (TYPE_SIZE (itype1
), TYPE_SIZE (itype2
)) != 1
4218 || TYPE_ALIGN (itype1
) != TYPE_ALIGN (itype2
))
4220 if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1
),
4221 TYPE_MIN_VALUE (itype2
))
4222 && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1
),
4223 TYPE_MAX_VALUE (itype2
)))
4230 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
4231 and number of elements specified by the range of values of INDEX_TYPE.
4232 If such a type has already been constructed, reuse it. */
4235 build_array_type (elt_type
, index_type
)
4236 tree elt_type
, index_type
;
4241 if (TREE_CODE (elt_type
) == FUNCTION_TYPE
)
4243 error ("arrays of functions are not meaningful");
4244 elt_type
= integer_type_node
;
4247 /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
4248 build_pointer_type (elt_type
);
4250 /* Allocate the array after the pointer type,
4251 in case we free it in type_hash_canon. */
4252 t
= make_node (ARRAY_TYPE
);
4253 TREE_TYPE (t
) = elt_type
;
4254 TYPE_DOMAIN (t
) = index_type
;
4256 if (index_type
== 0)
4261 hashcode
= TYPE_HASH (elt_type
) + TYPE_HASH (index_type
);
4262 t
= type_hash_canon (hashcode
, t
);
4264 if (TYPE_SIZE (t
) == 0)
4269 /* Return the TYPE of the elements comprising
4270 the innermost dimension of ARRAY. */
4273 get_inner_array_type (array
)
4276 tree type
= TREE_TYPE (array
);
4278 while (TREE_CODE (type
) == ARRAY_TYPE
)
4279 type
= TREE_TYPE (type
);
4284 /* Construct, lay out and return
4285 the type of functions returning type VALUE_TYPE
4286 given arguments of types ARG_TYPES.
4287 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
4288 are data type nodes for the arguments of the function.
4289 If such a type has already been constructed, reuse it. */
4292 build_function_type (value_type
, arg_types
)
4293 tree value_type
, arg_types
;
4298 if (TREE_CODE (value_type
) == FUNCTION_TYPE
)
4300 error ("function return type cannot be function");
4301 value_type
= integer_type_node
;
4304 /* Make a node of the sort we want. */
4305 t
= make_node (FUNCTION_TYPE
);
4306 TREE_TYPE (t
) = value_type
;
4307 TYPE_ARG_TYPES (t
) = arg_types
;
4309 /* If we already have such a type, use the old one and free this one. */
4310 hashcode
= TYPE_HASH (value_type
) + type_hash_list (arg_types
);
4311 t
= type_hash_canon (hashcode
, t
);
4313 if (TYPE_SIZE (t
) == 0)
4318 /* Build the node for the type of references-to-TO_TYPE. */
4321 build_reference_type (to_type
)
4324 register tree t
= TYPE_REFERENCE_TO (to_type
);
4326 /* First, if we already have a type for pointers to TO_TYPE, use it. */
4331 /* We need a new one. Put this in the same obstack as TO_TYPE. */
4332 push_obstacks (TYPE_OBSTACK (to_type
), TYPE_OBSTACK (to_type
));
4333 t
= make_node (REFERENCE_TYPE
);
4336 TREE_TYPE (t
) = to_type
;
4338 /* Record this type as the pointer to TO_TYPE. */
4339 TYPE_REFERENCE_TO (to_type
) = t
;
4346 /* Construct, lay out and return the type of methods belonging to class
4347 BASETYPE and whose arguments and values are described by TYPE.
4348 If that type exists already, reuse it.
4349 TYPE must be a FUNCTION_TYPE node. */
4352 build_method_type (basetype
, type
)
4353 tree basetype
, type
;
4358 /* Make a node of the sort we want. */
4359 t
= make_node (METHOD_TYPE
);
4361 if (TREE_CODE (type
) != FUNCTION_TYPE
)
4364 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
4365 TREE_TYPE (t
) = TREE_TYPE (type
);
4367 /* The actual arglist for this function includes a "hidden" argument
4368 which is "this". Put it into the list of argument types. */
4371 = tree_cons (NULL_TREE
,
4372 build_pointer_type (basetype
), TYPE_ARG_TYPES (type
));
4374 /* If we already have such a type, use the old one and free this one. */
4375 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (type
);
4376 t
= type_hash_canon (hashcode
, t
);
4378 if (TYPE_SIZE (t
) == 0)
4384 /* Construct, lay out and return the type of offsets to a value
4385 of type TYPE, within an object of type BASETYPE.
4386 If a suitable offset type exists already, reuse it. */
4389 build_offset_type (basetype
, type
)
4390 tree basetype
, type
;
4395 /* Make a node of the sort we want. */
4396 t
= make_node (OFFSET_TYPE
);
4398 TYPE_OFFSET_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
4399 TREE_TYPE (t
) = type
;
4401 /* If we already have such a type, use the old one and free this one. */
4402 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (type
);
4403 t
= type_hash_canon (hashcode
, t
);
4405 if (TYPE_SIZE (t
) == 0)
4411 /* Create a complex type whose components are COMPONENT_TYPE. */
4414 build_complex_type (component_type
)
4415 tree component_type
;
4420 /* Make a node of the sort we want. */
4421 t
= make_node (COMPLEX_TYPE
);
4423 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (component_type
);
4424 TYPE_VOLATILE (t
) = TYPE_VOLATILE (component_type
);
4425 TYPE_READONLY (t
) = TYPE_READONLY (component_type
);
4427 /* If we already have such a type, use the old one and free this one. */
4428 hashcode
= TYPE_HASH (component_type
);
4429 t
= type_hash_canon (hashcode
, t
);
4431 if (TYPE_SIZE (t
) == 0)
4437 /* Return OP, stripped of any conversions to wider types as much as is safe.
4438 Converting the value back to OP's type makes a value equivalent to OP.
4440 If FOR_TYPE is nonzero, we return a value which, if converted to
4441 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
4443 If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
4444 narrowest type that can hold the value, even if they don't exactly fit.
4445 Otherwise, bit-field references are changed to a narrower type
4446 only if they can be fetched directly from memory in that type.
4448 OP must have integer, real or enumeral type. Pointers are not allowed!
4450 There are some cases where the obvious value we could return
4451 would regenerate to OP if converted to OP's type,
4452 but would not extend like OP to wider types.
4453 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
4454 For example, if OP is (unsigned short)(signed char)-1,
4455 we avoid returning (signed char)-1 if FOR_TYPE is int,
4456 even though extending that to an unsigned short would regenerate OP,
4457 since the result of extending (signed char)-1 to (int)
4458 is different from (int) OP. */
4461 get_unwidened (op
, for_type
)
4465 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
4466 register tree type
= TREE_TYPE (op
);
4467 register unsigned final_prec
4468 = TYPE_PRECISION (for_type
!= 0 ? for_type
: type
);
4470 = (for_type
!= 0 && for_type
!= type
4471 && final_prec
> TYPE_PRECISION (type
)
4472 && TREE_UNSIGNED (type
));
4473 register tree win
= op
;
4475 while (TREE_CODE (op
) == NOP_EXPR
)
4477 register int bitschange
4478 = TYPE_PRECISION (TREE_TYPE (op
))
4479 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
4481 /* Truncations are many-one so cannot be removed.
4482 Unless we are later going to truncate down even farther. */
4484 && final_prec
> TYPE_PRECISION (TREE_TYPE (op
)))
4487 /* See what's inside this conversion. If we decide to strip it,
4489 op
= TREE_OPERAND (op
, 0);
4491 /* If we have not stripped any zero-extensions (uns is 0),
4492 we can strip any kind of extension.
4493 If we have previously stripped a zero-extension,
4494 only zero-extensions can safely be stripped.
4495 Any extension can be stripped if the bits it would produce
4496 are all going to be discarded later by truncating to FOR_TYPE. */
4500 if (! uns
|| final_prec
<= TYPE_PRECISION (TREE_TYPE (op
)))
4502 /* TREE_UNSIGNED says whether this is a zero-extension.
4503 Let's avoid computing it if it does not affect WIN
4504 and if UNS will not be needed again. */
4505 if ((uns
|| TREE_CODE (op
) == NOP_EXPR
)
4506 && TREE_UNSIGNED (TREE_TYPE (op
)))
4514 if (TREE_CODE (op
) == COMPONENT_REF
4515 /* Since type_for_size always gives an integer type. */
4516 && TREE_CODE (type
) != REAL_TYPE
4517 /* Don't crash if field not laid out yet. */
4518 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0)
4520 unsigned innerprec
= TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op
, 1)));
4521 type
= type_for_size (innerprec
, TREE_UNSIGNED (TREE_OPERAND (op
, 1)));
4523 /* We can get this structure field in the narrowest type it fits in.
4524 If FOR_TYPE is 0, do this only for a field that matches the
4525 narrower type exactly and is aligned for it
4526 The resulting extension to its nominal type (a fullword type)
4527 must fit the same conditions as for other extensions. */
4529 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
4530 && (for_type
|| ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1)))
4531 && (! uns
|| final_prec
<= innerprec
4532 || TREE_UNSIGNED (TREE_OPERAND (op
, 1)))
4535 win
= build (COMPONENT_REF
, type
, TREE_OPERAND (op
, 0),
4536 TREE_OPERAND (op
, 1));
4537 TREE_SIDE_EFFECTS (win
) = TREE_SIDE_EFFECTS (op
);
4538 TREE_THIS_VOLATILE (win
) = TREE_THIS_VOLATILE (op
);
4539 TREE_RAISES (win
) = TREE_RAISES (op
);
4545 /* Return OP or a simpler expression for a narrower value
4546 which can be sign-extended or zero-extended to give back OP.
4547 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4548 or 0 if the value should be sign-extended. */
4551 get_narrower (op
, unsignedp_ptr
)
4555 register int uns
= 0;
4557 register tree win
= op
;
4559 while (TREE_CODE (op
) == NOP_EXPR
)
4561 register int bitschange
4562 = TYPE_PRECISION (TREE_TYPE (op
))
4563 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
4565 /* Truncations are many-one so cannot be removed. */
4569 /* See what's inside this conversion. If we decide to strip it,
4571 op
= TREE_OPERAND (op
, 0);
4575 /* An extension: the outermost one can be stripped,
4576 but remember whether it is zero or sign extension. */
4578 uns
= TREE_UNSIGNED (TREE_TYPE (op
));
4579 /* Otherwise, if a sign extension has been stripped,
4580 only sign extensions can now be stripped;
4581 if a zero extension has been stripped, only zero-extensions. */
4582 else if (uns
!= TREE_UNSIGNED (TREE_TYPE (op
)))
4586 else /* bitschange == 0 */
4588 /* A change in nominal type can always be stripped, but we must
4589 preserve the unsignedness. */
4591 uns
= TREE_UNSIGNED (TREE_TYPE (op
));
4598 if (TREE_CODE (op
) == COMPONENT_REF
4599 /* Since type_for_size always gives an integer type. */
4600 && TREE_CODE (TREE_TYPE (op
)) != REAL_TYPE
)
4602 unsigned innerprec
= TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op
, 1)));
4603 tree type
= type_for_size (innerprec
, TREE_UNSIGNED (op
));
4605 /* We can get this structure field in a narrower type that fits it,
4606 but the resulting extension to its nominal type (a fullword type)
4607 must satisfy the same conditions as for other extensions.
4609 Do this only for fields that are aligned (not bit-fields),
4610 because when bit-field insns will be used there is no
4611 advantage in doing this. */
4613 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
4614 && ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1))
4615 && (first
|| uns
== TREE_UNSIGNED (TREE_OPERAND (op
, 1)))
4619 uns
= TREE_UNSIGNED (TREE_OPERAND (op
, 1));
4620 win
= build (COMPONENT_REF
, type
, TREE_OPERAND (op
, 0),
4621 TREE_OPERAND (op
, 1));
4622 TREE_SIDE_EFFECTS (win
) = TREE_SIDE_EFFECTS (op
);
4623 TREE_THIS_VOLATILE (win
) = TREE_THIS_VOLATILE (op
);
4624 TREE_RAISES (win
) = TREE_RAISES (op
);
4627 *unsignedp_ptr
= uns
;
4631 /* Nonzero if integer constant C has a value that is permissible
4632 for type TYPE (an INTEGER_TYPE). */
4635 int_fits_type_p (c
, type
)
4638 if (TREE_UNSIGNED (type
))
4639 return (! (TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
4640 && INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type
), c
))
4641 && ! (TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
4642 && INT_CST_LT_UNSIGNED (c
, TYPE_MIN_VALUE (type
)))
4643 /* Negative ints never fit unsigned types. */
4644 && ! (TREE_INT_CST_HIGH (c
) < 0
4645 && ! TREE_UNSIGNED (TREE_TYPE (c
))));
4647 return (! (TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
4648 && INT_CST_LT (TYPE_MAX_VALUE (type
), c
))
4649 && ! (TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
4650 && INT_CST_LT (c
, TYPE_MIN_VALUE (type
)))
4651 /* Unsigned ints with top bit set never fit signed types. */
4652 && ! (TREE_INT_CST_HIGH (c
) < 0
4653 && TREE_UNSIGNED (TREE_TYPE (c
))));
4656 /* Return the innermost context enclosing DECL that is
4657 a FUNCTION_DECL, or zero if none. */
4660 decl_function_context (decl
)
4665 if (TREE_CODE (decl
) == ERROR_MARK
)
4668 if (TREE_CODE (decl
) == SAVE_EXPR
)
4669 context
= SAVE_EXPR_CONTEXT (decl
);
4671 context
= DECL_CONTEXT (decl
);
4673 while (context
&& TREE_CODE (context
) != FUNCTION_DECL
)
4675 if (TREE_CODE_CLASS (TREE_CODE (context
)) == 't')
4676 context
= TYPE_CONTEXT (context
);
4677 else if (TREE_CODE_CLASS (TREE_CODE (context
)) == 'd')
4678 context
= DECL_CONTEXT (context
);
4679 else if (TREE_CODE (context
) == BLOCK
)
4680 context
= BLOCK_SUPERCONTEXT (context
);
4682 /* Unhandled CONTEXT !? */
4689 /* Return the innermost context enclosing DECL that is
4690 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4691 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
4694 decl_type_context (decl
)
4697 tree context
= DECL_CONTEXT (decl
);
4701 if (TREE_CODE (context
) == RECORD_TYPE
4702 || TREE_CODE (context
) == UNION_TYPE
4703 || TREE_CODE (context
) == QUAL_UNION_TYPE
)
4705 if (TREE_CODE (context
) == TYPE_DECL
4706 || TREE_CODE (context
) == FUNCTION_DECL
)
4707 context
= DECL_CONTEXT (context
);
4708 else if (TREE_CODE (context
) == BLOCK
)
4709 context
= BLOCK_SUPERCONTEXT (context
);
4711 /* Unhandled CONTEXT!? */
4717 /* Print debugging information about the size of the
4718 toplev_inline_obstacks. */
4721 print_inline_obstack_statistics ()
4723 struct simple_obstack_stack
*current
= toplev_inline_obstacks
;
4728 for (; current
; current
= current
->next
, ++n_obstacks
)
4730 struct obstack
*o
= current
->obstack
;
4731 struct _obstack_chunk
*chunk
= o
->chunk
;
4733 n_alloc
+= o
->next_free
- chunk
->contents
;
4734 chunk
= chunk
->prev
;
4736 for (; chunk
; chunk
= chunk
->prev
, ++n_chunks
)
4737 n_alloc
+= chunk
->limit
- &chunk
->contents
[0];
4739 fprintf (stderr
, "inline obstacks: %d obstacks, %d bytes, %d chunks\n",
4740 n_obstacks
, n_alloc
, n_chunks
);
4743 /* Print debugging information about the obstack O, named STR. */
4746 print_obstack_statistics (str
, o
)
4750 struct _obstack_chunk
*chunk
= o
->chunk
;
4754 n_alloc
+= o
->next_free
- chunk
->contents
;
4755 chunk
= chunk
->prev
;
4759 n_alloc
+= chunk
->limit
- &chunk
->contents
[0];
4760 chunk
= chunk
->prev
;
4762 fprintf (stderr
, "obstack %s: %u bytes, %d chunks\n",
4763 str
, n_alloc
, n_chunks
);
4766 /* Print debugging information about tree nodes generated during the compile,
4767 and any language-specific information. */
4770 dump_tree_statistics ()
4772 #ifdef GATHER_STATISTICS
4774 int total_nodes
, total_bytes
;
4777 fprintf (stderr
, "\n??? tree nodes created\n\n");
4778 #ifdef GATHER_STATISTICS
4779 fprintf (stderr
, "Kind Nodes Bytes\n");
4780 fprintf (stderr
, "-------------------------------------\n");
4781 total_nodes
= total_bytes
= 0;
4782 for (i
= 0; i
< (int) all_kinds
; i
++)
4784 fprintf (stderr
, "%-20s %6d %9d\n", tree_node_kind_names
[i
],
4785 tree_node_counts
[i
], tree_node_sizes
[i
]);
4786 total_nodes
+= tree_node_counts
[i
];
4787 total_bytes
+= tree_node_sizes
[i
];
4789 fprintf (stderr
, "%-20s %9d\n", "identifier names", id_string_size
);
4790 fprintf (stderr
, "-------------------------------------\n");
4791 fprintf (stderr
, "%-20s %6d %9d\n", "Total", total_nodes
, total_bytes
);
4792 fprintf (stderr
, "-------------------------------------\n");
4794 fprintf (stderr
, "(No per-node statistics)\n");
4796 print_obstack_statistics ("permanent_obstack", &permanent_obstack
);
4797 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack
);
4798 print_obstack_statistics ("temporary_obstack", &temporary_obstack
);
4799 print_obstack_statistics ("momentary_obstack", &momentary_obstack
);
4800 print_obstack_statistics ("temp_decl_obstack", &temp_decl_obstack
);
4801 print_inline_obstack_statistics ();
4802 print_lang_statistics ();
4805 #define FILE_FUNCTION_PREFIX_LEN 9
4807 #ifndef NO_DOLLAR_IN_LABEL
4808 #define FILE_FUNCTION_FORMAT "_GLOBAL_$%s$%s"
4809 #else /* NO_DOLLAR_IN_LABEL */
4810 #ifndef NO_DOT_IN_LABEL
4811 #define FILE_FUNCTION_FORMAT "_GLOBAL_.%s.%s"
4812 #else /* NO_DOT_IN_LABEL */
4813 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4814 #endif /* NO_DOT_IN_LABEL */
4815 #endif /* NO_DOLLAR_IN_LABEL */
4817 extern char * first_global_object_name
;
4818 extern char * weak_global_object_name
;
4820 /* TYPE is some string to identify this function to the linker or
4824 get_file_function_name_long (type
)
4830 if (first_global_object_name
)
4831 p
= first_global_object_name
;
4832 else if (weak_global_object_name
)
4833 p
= weak_global_object_name
;
4834 else if (main_input_filename
)
4835 p
= main_input_filename
;
4839 buf
= (char *) alloca (sizeof (FILE_FUNCTION_FORMAT
) + strlen (p
)
4842 /* Set up the name of the file-level functions we may need. */
4843 /* Use a global object (which is already required to be unique over
4844 the program) rather than the file name (which imposes extra
4845 constraints). -- Raeburn@MIT.EDU, 10 Jan 1990. */
4846 sprintf (buf
, FILE_FUNCTION_FORMAT
, type
, p
);
4848 /* Don't need to pull weird characters out of global names. */
4849 if (p
!= first_global_object_name
)
4851 for (p
= buf
+11; *p
; p
++)
4852 if (! ((*p
>= '0' && *p
<= '9')
4853 #if 0 /* we always want labels, which are valid C++ identifiers (+ `$') */
4854 #ifndef ASM_IDENTIFY_GCC /* this is required if `.' is invalid -- k. raeburn */
4858 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
4861 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
4864 || (*p
>= 'A' && *p
<= 'Z')
4865 || (*p
>= 'a' && *p
<= 'z')))
4869 return get_identifier (buf
);
4872 /* If KIND=='I', return a suitable global initializer (constructor) name.
4873 If KIND=='D', return a suitable global clean-up (destructor) name. */
4876 get_file_function_name (kind
)
4883 return get_file_function_name_long (p
);
4887 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4888 The result is placed in BUFFER (which has length BIT_SIZE),
4889 with one bit in each char ('\000' or '\001').
4891 If the constructor is constant, NULL_TREE is returned.
4892 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4895 get_set_constructor_bits (init
, buffer
, bit_size
)
4902 HOST_WIDE_INT domain_min
4903 = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init
))));
4904 tree non_const_bits
= NULL_TREE
;
4905 for (i
= 0; i
< bit_size
; i
++)
4908 for (vals
= TREE_OPERAND (init
, 1);
4909 vals
!= NULL_TREE
; vals
= TREE_CHAIN (vals
))
4911 if (TREE_CODE (TREE_VALUE (vals
)) != INTEGER_CST
4912 || (TREE_PURPOSE (vals
) != NULL_TREE
4913 && TREE_CODE (TREE_PURPOSE (vals
)) != INTEGER_CST
))
4915 = tree_cons (TREE_PURPOSE (vals
), TREE_VALUE (vals
), non_const_bits
);
4916 else if (TREE_PURPOSE (vals
) != NULL_TREE
)
4918 /* Set a range of bits to ones. */
4919 HOST_WIDE_INT lo_index
4920 = TREE_INT_CST_LOW (TREE_PURPOSE (vals
)) - domain_min
;
4921 HOST_WIDE_INT hi_index
4922 = TREE_INT_CST_LOW (TREE_VALUE (vals
)) - domain_min
;
4923 if (lo_index
< 0 || lo_index
>= bit_size
4924 || hi_index
< 0 || hi_index
>= bit_size
)
4926 for ( ; lo_index
<= hi_index
; lo_index
++)
4927 buffer
[lo_index
] = 1;
4931 /* Set a single bit to one. */
4933 = TREE_INT_CST_LOW (TREE_VALUE (vals
)) - domain_min
;
4934 if (index
< 0 || index
>= bit_size
)
4936 error ("invalid initializer for bit string");
4942 return non_const_bits
;
4945 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4946 The result is placed in BUFFER (which is an array of bytes).
4947 If the constructor is constant, NULL_TREE is returned.
4948 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4951 get_set_constructor_bytes (init
, buffer
, wd_size
)
4953 unsigned char *buffer
;
4957 int set_word_size
= BITS_PER_UNIT
;
4958 int bit_size
= wd_size
* set_word_size
;
4960 unsigned char *bytep
= buffer
;
4961 char *bit_buffer
= (char *) alloca(bit_size
);
4962 tree non_const_bits
= get_set_constructor_bits (init
, bit_buffer
, bit_size
);
4964 for (i
= 0; i
< wd_size
; i
++)
4967 for (i
= 0; i
< bit_size
; i
++)
4971 if (BYTES_BIG_ENDIAN
)
4972 *bytep
|= (1 << (set_word_size
- 1 - bit_pos
));
4974 *bytep
|= 1 << bit_pos
;
4977 if (bit_pos
>= set_word_size
)
4978 bit_pos
= 0, bytep
++;
4980 return non_const_bits
;
4983 #ifdef ENABLE_CHECKING
4985 /* Complain if the tree code does not match the expected one.
4986 NODE is the tree node in question, CODE is the expected tree code,
4987 and FILE and LINE are the filename and line number, respectively,
4988 of the line on which the check was done. If NONFATAL is nonzero,
4989 don't abort if the reference is invalid; instead, return 0.
4990 If the reference is valid, return NODE. */
4993 tree_check (node
, code
, file
, line
, nofatal
)
4995 enum tree_code code
;
5000 if (TREE_CODE (node
) == code
)
5005 fatal ("%s:%d: Expect %s, have %s\n", file
, line
,
5006 tree_code_name
[code
], tree_code_name
[TREE_CODE (node
)]);
5009 /* Similar to above, except that we check for a class of tree
5010 code, given in CL. */
5013 tree_class_check (node
, cl
, file
, line
, nofatal
)
5020 if (TREE_CODE_CLASS (TREE_CODE (node
)) == cl
)
5025 fatal ("%s:%d: Expect '%c', have '%s'\n", file
, line
,
5026 cl
, tree_code_name
[TREE_CODE (node
)]);
5029 /* Likewise, but complain if the tree node is not an expression. */
5032 expr_check (node
, ignored
, file
, line
, nofatal
)
5039 switch (TREE_CODE_CLASS (TREE_CODE (node
)))
5053 fatal ("%s:%d: Expect expression, have '%s'\n", file
, line
,
5054 tree_code_name
[TREE_CODE (node
)]);
5061 /* Return the alias set for T, which may be either a type or an
5068 if (!flag_strict_aliasing
|| !lang_get_alias_set
)
5069 /* If we're not doing any lanaguage-specific alias analysis, just
5070 assume everything aliases everything else. */
5073 return (*lang_get_alias_set
) (t
);
5076 /* Return a brand-new alias set. */
5081 static int last_alias_set
;
5082 return ++last_alias_set
;