1 /* Language-independent node constructors for parse phase of GNU compiler.
2 Copyright (C) 1987, 88, 92-98, 1999 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* This file contains the low level primitives for operating on tree nodes,
23 including allocation, list operations, interning of identifiers,
24 construction of data type nodes and statement nodes,
25 and construction of type conversion nodes. It also contains
26 tables index by tree code that describe how to take apart
29 It is intended to be language-independent, but occasionally
30 calls language-dependent routines defined (for C) in typecheck.c.
32 The low-level allocation routines oballoc and permalloc
33 are used also for allocating many other kinds of objects
34 by all passes of the compiler. */
45 #define obstack_chunk_alloc xmalloc
46 #define obstack_chunk_free free
47 /* obstack.[ch] explicitly declined to prototype this. */
48 extern int _obstack_allocated_p
PROTO ((struct obstack
*h
, GENERIC_PTR obj
));
50 /* Tree nodes of permanent duration are allocated in this obstack.
51 They are the identifier nodes, and everything outside of
52 the bodies and parameters of function definitions. */
54 struct obstack permanent_obstack
;
56 /* The initial RTL, and all ..._TYPE nodes, in a function
57 are allocated in this obstack. Usually they are freed at the
58 end of the function, but if the function is inline they are saved.
59 For top-level functions, this is maybepermanent_obstack.
60 Separate obstacks are made for nested functions. */
62 struct obstack
*function_maybepermanent_obstack
;
64 /* This is the function_maybepermanent_obstack for top-level functions. */
66 struct obstack maybepermanent_obstack
;
68 /* The contents of the current function definition are allocated
69 in this obstack, and all are freed at the end of the function.
70 For top-level functions, this is temporary_obstack.
71 Separate obstacks are made for nested functions. */
73 struct obstack
*function_obstack
;
75 /* This is used for reading initializers of global variables. */
77 struct obstack temporary_obstack
;
79 /* The tree nodes of an expression are allocated
80 in this obstack, and all are freed at the end of the expression. */
82 struct obstack momentary_obstack
;
84 /* The tree nodes of a declarator are allocated
85 in this obstack, and all are freed when the declarator
88 static struct obstack temp_decl_obstack
;
90 /* This points at either permanent_obstack
91 or the current function_maybepermanent_obstack. */
93 struct obstack
*saveable_obstack
;
95 /* This is same as saveable_obstack during parse and expansion phase;
96 it points to the current function's obstack during optimization.
97 This is the obstack to be used for creating rtl objects. */
99 struct obstack
*rtl_obstack
;
101 /* This points at either permanent_obstack or the current function_obstack. */
103 struct obstack
*current_obstack
;
105 /* This points at either permanent_obstack or the current function_obstack
106 or momentary_obstack. */
108 struct obstack
*expression_obstack
;
110 /* Stack of obstack selections for push_obstacks and pop_obstacks. */
114 struct obstack_stack
*next
;
115 struct obstack
*current
;
116 struct obstack
*saveable
;
117 struct obstack
*expression
;
121 struct obstack_stack
*obstack_stack
;
123 /* Obstack for allocating struct obstack_stack entries. */
125 static struct obstack obstack_stack_obstack
;
127 /* Addresses of first objects in some obstacks.
128 This is for freeing their entire contents. */
129 char *maybepermanent_firstobj
;
130 char *temporary_firstobj
;
131 char *momentary_firstobj
;
132 char *temp_decl_firstobj
;
134 /* This is used to preserve objects (mainly array initializers) that need to
135 live until the end of the current function, but no further. */
136 char *momentary_function_firstobj
;
138 /* Nonzero means all ..._TYPE nodes should be allocated permanently. */
140 int all_types_permanent
;
142 /* Stack of places to restore the momentary obstack back to. */
144 struct momentary_level
146 /* Pointer back to previous such level. */
147 struct momentary_level
*prev
;
148 /* First object allocated within this level. */
150 /* Value of expression_obstack saved at entry to this level. */
151 struct obstack
*obstack
;
154 struct momentary_level
*momentary_stack
;
156 /* Table indexed by tree code giving a string containing a character
157 classifying the tree code. Possibilities are
158 t, d, s, c, r, <, 1, 2 and e. See tree.def for details. */
160 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
162 char tree_code_type
[MAX_TREE_CODES
] = {
167 /* Table indexed by tree code giving number of expression
168 operands beyond the fixed part of the node structure.
169 Not used for types or decls. */
171 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
173 int tree_code_length
[MAX_TREE_CODES
] = {
178 /* Names of tree components.
179 Used for printing out the tree and error messages. */
180 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
182 const char *tree_code_name
[MAX_TREE_CODES
] = {
187 /* Statistics-gathering stuff. */
208 int tree_node_counts
[(int)all_kinds
];
209 int tree_node_sizes
[(int)all_kinds
];
210 int id_string_size
= 0;
212 const char *tree_node_kind_names
[] = {
230 /* Hash table for uniquizing IDENTIFIER_NODEs by name. */
232 #define MAX_HASH_TABLE 1009
233 static tree hash_table
[MAX_HASH_TABLE
]; /* id hash buckets */
235 /* 0 while creating built-in identifiers. */
236 static int do_identifier_warnings
;
238 /* Unique id for next decl created. */
239 static int next_decl_uid
;
240 /* Unique id for next type created. */
241 static int next_type_uid
= 1;
243 /* The language-specific function for alias analysis. If NULL, the
244 language does not do any special alias analysis. */
245 int (*lang_get_alias_set
) PROTO((tree
));
247 /* Here is how primitive or already-canonicalized types' hash
249 #define TYPE_HASH(TYPE) ((unsigned long) (TYPE) & 0777777)
251 /* Each hash table slot is a bucket containing a chain
252 of these structures. */
256 struct type_hash
*next
; /* Next structure in the bucket. */
257 int hashcode
; /* Hash code of this type. */
258 tree type
; /* The type recorded here. */
261 /* Now here is the hash table. When recording a type, it is added
262 to the slot whose index is the hash code mod the table size.
263 Note that the hash table is used for several kinds of types
264 (function types, array types and array index range types, for now).
265 While all these live in the same table, they are completely independent,
266 and the hash code is computed differently for each of these. */
268 #define TYPE_HASH_SIZE 59
269 struct type_hash
*type_hash_table
[TYPE_HASH_SIZE
];
271 static void set_type_quals
PROTO((tree
, int));
272 static void append_random_chars
PROTO((char *));
273 static void build_real_from_int_cst_1
PROTO((PTR
));
274 static void mark_type_hash
PROTO ((void *));
276 void gcc_obstack_init ();
278 /* If non-null, a language specific helper for unsave_expr_now. */
280 void (*lang_unsave_expr_now
) PROTO((tree
));
282 /* Init the principal obstacks. */
287 gcc_obstack_init (&obstack_stack_obstack
);
288 gcc_obstack_init (&permanent_obstack
);
290 gcc_obstack_init (&temporary_obstack
);
291 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
292 gcc_obstack_init (&momentary_obstack
);
293 momentary_firstobj
= (char *) obstack_alloc (&momentary_obstack
, 0);
294 momentary_function_firstobj
= momentary_firstobj
;
295 gcc_obstack_init (&maybepermanent_obstack
);
296 maybepermanent_firstobj
297 = (char *) obstack_alloc (&maybepermanent_obstack
, 0);
298 gcc_obstack_init (&temp_decl_obstack
);
299 temp_decl_firstobj
= (char *) obstack_alloc (&temp_decl_obstack
, 0);
301 function_obstack
= &temporary_obstack
;
302 function_maybepermanent_obstack
= &maybepermanent_obstack
;
303 current_obstack
= &permanent_obstack
;
304 expression_obstack
= &permanent_obstack
;
305 rtl_obstack
= saveable_obstack
= &permanent_obstack
;
307 /* Init the hash table of identifiers. */
308 bzero ((char *) hash_table
, sizeof hash_table
);
310 ggc_add_tree_root (hash_table
, MAX_HASH_TABLE
);
311 ggc_add_root (type_hash_table
, TYPE_HASH_SIZE
,
312 sizeof(struct type_hash
*),
317 gcc_obstack_init (obstack
)
318 struct obstack
*obstack
;
320 /* Let particular systems override the size of a chunk. */
321 #ifndef OBSTACK_CHUNK_SIZE
322 #define OBSTACK_CHUNK_SIZE 0
324 /* Let them override the alloc and free routines too. */
325 #ifndef OBSTACK_CHUNK_ALLOC
326 #define OBSTACK_CHUNK_ALLOC xmalloc
328 #ifndef OBSTACK_CHUNK_FREE
329 #define OBSTACK_CHUNK_FREE free
331 _obstack_begin (obstack
, OBSTACK_CHUNK_SIZE
, 0,
332 (void *(*) ()) OBSTACK_CHUNK_ALLOC
,
333 (void (*) ()) OBSTACK_CHUNK_FREE
);
336 /* Save all variables describing the current status into the structure
337 *P. This function is called whenever we start compiling one
338 function in the midst of compiling another. For example, when
339 compiling a nested function, or, in C++, a template instantiation
340 that is required by the function we are currently compiling.
342 CONTEXT is the decl_function_context for the function we're about to
343 compile; if it isn't current_function_decl, we have to play some games. */
349 p
->all_types_permanent
= all_types_permanent
;
350 p
->momentary_stack
= momentary_stack
;
351 p
->maybepermanent_firstobj
= maybepermanent_firstobj
;
352 p
->temporary_firstobj
= temporary_firstobj
;
353 p
->momentary_firstobj
= momentary_firstobj
;
354 p
->momentary_function_firstobj
= momentary_function_firstobj
;
355 p
->function_obstack
= function_obstack
;
356 p
->function_maybepermanent_obstack
= function_maybepermanent_obstack
;
357 p
->current_obstack
= current_obstack
;
358 p
->expression_obstack
= expression_obstack
;
359 p
->saveable_obstack
= saveable_obstack
;
360 p
->rtl_obstack
= rtl_obstack
;
362 function_maybepermanent_obstack
363 = (struct obstack
*) xmalloc (sizeof (struct obstack
));
364 gcc_obstack_init (function_maybepermanent_obstack
);
365 maybepermanent_firstobj
366 = (char *) obstack_finish (function_maybepermanent_obstack
);
368 function_obstack
= (struct obstack
*) xmalloc (sizeof (struct obstack
));
369 gcc_obstack_init (function_obstack
);
371 current_obstack
= &permanent_obstack
;
372 expression_obstack
= &permanent_obstack
;
373 rtl_obstack
= saveable_obstack
= &permanent_obstack
;
375 temporary_firstobj
= (char *) obstack_alloc (&temporary_obstack
, 0);
376 momentary_firstobj
= (char *) obstack_finish (&momentary_obstack
);
377 momentary_function_firstobj
= momentary_firstobj
;
380 /* Restore all variables describing the current status from the structure *P.
381 This is used after a nested function. */
384 restore_tree_status (p
)
387 all_types_permanent
= p
->all_types_permanent
;
388 momentary_stack
= p
->momentary_stack
;
390 obstack_free (&momentary_obstack
, momentary_function_firstobj
);
392 /* Free saveable storage used by the function just compiled and not
394 obstack_free (function_maybepermanent_obstack
, maybepermanent_firstobj
);
396 obstack_free (&temporary_obstack
, temporary_firstobj
);
397 obstack_free (&momentary_obstack
, momentary_function_firstobj
);
399 obstack_free (function_obstack
, 0);
401 if (obstack_empty_p (function_maybepermanent_obstack
))
402 free (function_maybepermanent_obstack
);
403 free (function_obstack
);
405 temporary_firstobj
= p
->temporary_firstobj
;
406 momentary_firstobj
= p
->momentary_firstobj
;
407 momentary_function_firstobj
= p
->momentary_function_firstobj
;
408 maybepermanent_firstobj
= p
->maybepermanent_firstobj
;
409 function_obstack
= p
->function_obstack
;
410 function_maybepermanent_obstack
= p
->function_maybepermanent_obstack
;
411 current_obstack
= p
->current_obstack
;
412 expression_obstack
= p
->expression_obstack
;
413 saveable_obstack
= p
->saveable_obstack
;
414 rtl_obstack
= p
->rtl_obstack
;
417 /* Start allocating on the temporary (per function) obstack.
418 This is done in start_function before parsing the function body,
419 and before each initialization at top level, and to go back
420 to temporary allocation after doing permanent_allocation. */
423 temporary_allocation ()
425 /* Note that function_obstack at top level points to temporary_obstack.
426 But within a nested function context, it is a separate obstack. */
427 current_obstack
= function_obstack
;
428 expression_obstack
= function_obstack
;
429 rtl_obstack
= saveable_obstack
= function_maybepermanent_obstack
;
433 /* Start allocating on the permanent obstack but don't
434 free the temporary data. After calling this, call
435 `permanent_allocation' to fully resume permanent allocation status. */
438 end_temporary_allocation ()
440 current_obstack
= &permanent_obstack
;
441 expression_obstack
= &permanent_obstack
;
442 rtl_obstack
= saveable_obstack
= &permanent_obstack
;
445 /* Resume allocating on the temporary obstack, undoing
446 effects of `end_temporary_allocation'. */
449 resume_temporary_allocation ()
451 current_obstack
= function_obstack
;
452 expression_obstack
= function_obstack
;
453 rtl_obstack
= saveable_obstack
= function_maybepermanent_obstack
;
456 /* While doing temporary allocation, switch to allocating in such a
457 way as to save all nodes if the function is inlined. Call
458 resume_temporary_allocation to go back to ordinary temporary
462 saveable_allocation ()
464 /* Note that function_obstack at top level points to temporary_obstack.
465 But within a nested function context, it is a separate obstack. */
466 expression_obstack
= current_obstack
= saveable_obstack
;
469 /* Switch to current obstack CURRENT and maybepermanent obstack SAVEABLE,
470 recording the previously current obstacks on a stack.
471 This does not free any storage in any obstack. */
474 push_obstacks (current
, saveable
)
475 struct obstack
*current
, *saveable
;
477 struct obstack_stack
*p
;
482 p
= (struct obstack_stack
*) obstack_alloc (&obstack_stack_obstack
,
483 (sizeof (struct obstack_stack
)));
485 p
->current
= current_obstack
;
486 p
->saveable
= saveable_obstack
;
487 p
->expression
= expression_obstack
;
488 p
->rtl
= rtl_obstack
;
489 p
->next
= obstack_stack
;
492 current_obstack
= current
;
493 expression_obstack
= current
;
494 rtl_obstack
= saveable_obstack
= saveable
;
497 /* Save the current set of obstacks, but don't change them. */
500 push_obstacks_nochange ()
502 struct obstack_stack
*p
;
507 p
= (struct obstack_stack
*) obstack_alloc (&obstack_stack_obstack
,
508 (sizeof (struct obstack_stack
)));
510 p
->current
= current_obstack
;
511 p
->saveable
= saveable_obstack
;
512 p
->expression
= expression_obstack
;
513 p
->rtl
= rtl_obstack
;
514 p
->next
= obstack_stack
;
518 /* Pop the obstack selection stack. */
523 struct obstack_stack
*p
;
529 obstack_stack
= p
->next
;
531 current_obstack
= p
->current
;
532 saveable_obstack
= p
->saveable
;
533 expression_obstack
= p
->expression
;
534 rtl_obstack
= p
->rtl
;
536 obstack_free (&obstack_stack_obstack
, p
);
539 /* Nonzero if temporary allocation is currently in effect.
540 Zero if currently doing permanent allocation. */
543 allocation_temporary_p ()
545 return current_obstack
!= &permanent_obstack
;
548 /* Go back to allocating on the permanent obstack
549 and free everything in the temporary obstack.
551 FUNCTION_END is true only if we have just finished compiling a function.
552 In that case, we also free preserved initial values on the momentary
556 permanent_allocation (function_end
)
559 /* Free up previous temporary obstack data */
560 obstack_free (&temporary_obstack
, temporary_firstobj
);
563 obstack_free (&momentary_obstack
, momentary_function_firstobj
);
564 momentary_firstobj
= momentary_function_firstobj
;
567 obstack_free (&momentary_obstack
, momentary_firstobj
);
568 obstack_free (function_maybepermanent_obstack
, maybepermanent_firstobj
);
569 obstack_free (&temp_decl_obstack
, temp_decl_firstobj
);
571 current_obstack
= &permanent_obstack
;
572 expression_obstack
= &permanent_obstack
;
573 rtl_obstack
= saveable_obstack
= &permanent_obstack
;
576 /* Save permanently everything on the maybepermanent_obstack. */
581 maybepermanent_firstobj
582 = (char *) obstack_alloc (function_maybepermanent_obstack
, 0);
586 preserve_initializer ()
588 struct momentary_level
*tem
;
592 = (char *) obstack_alloc (&temporary_obstack
, 0);
593 maybepermanent_firstobj
594 = (char *) obstack_alloc (function_maybepermanent_obstack
, 0);
596 old_momentary
= momentary_firstobj
;
598 = (char *) obstack_alloc (&momentary_obstack
, 0);
599 if (momentary_firstobj
!= old_momentary
)
600 for (tem
= momentary_stack
; tem
; tem
= tem
->prev
)
601 tem
->base
= momentary_firstobj
;
604 /* Start allocating new rtl in current_obstack.
605 Use resume_temporary_allocation
606 to go back to allocating rtl in saveable_obstack. */
609 rtl_in_current_obstack ()
611 rtl_obstack
= current_obstack
;
614 /* Start allocating rtl from saveable_obstack. Intended to be used after
615 a call to push_obstacks_nochange. */
618 rtl_in_saveable_obstack ()
620 rtl_obstack
= saveable_obstack
;
623 /* Allocate SIZE bytes in the current obstack
624 and return a pointer to them.
625 In practice the current obstack is always the temporary one. */
631 return (char *) obstack_alloc (current_obstack
, size
);
634 /* Free the object PTR in the current obstack
635 as well as everything allocated since PTR.
636 In practice the current obstack is always the temporary one. */
642 obstack_free (current_obstack
, ptr
);
645 /* Allocate SIZE bytes in the permanent obstack
646 and return a pointer to them. */
652 return (char *) obstack_alloc (&permanent_obstack
, size
);
655 /* Allocate NELEM items of SIZE bytes in the permanent obstack
656 and return a pointer to them. The storage is cleared before
657 returning the value. */
660 perm_calloc (nelem
, size
)
664 char *rval
= (char *) obstack_alloc (&permanent_obstack
, nelem
* size
);
665 bzero (rval
, nelem
* size
);
669 /* Allocate SIZE bytes in the saveable obstack
670 and return a pointer to them. */
676 return (char *) obstack_alloc (saveable_obstack
, size
);
679 /* Allocate SIZE bytes in the expression obstack
680 and return a pointer to them. */
686 return (char *) obstack_alloc (expression_obstack
, size
);
689 /* Print out which obstack an object is in. */
692 print_obstack_name (object
, file
, prefix
)
697 struct obstack
*obstack
= NULL
;
698 const char *obstack_name
= NULL
;
701 for (p
= outer_function_chain
; p
; p
= p
->next
)
703 if (_obstack_allocated_p (p
->function_obstack
, object
))
705 obstack
= p
->function_obstack
;
706 obstack_name
= "containing function obstack";
708 if (_obstack_allocated_p (p
->function_maybepermanent_obstack
, object
))
710 obstack
= p
->function_maybepermanent_obstack
;
711 obstack_name
= "containing function maybepermanent obstack";
715 if (_obstack_allocated_p (&obstack_stack_obstack
, object
))
717 obstack
= &obstack_stack_obstack
;
718 obstack_name
= "obstack_stack_obstack";
720 else if (_obstack_allocated_p (function_obstack
, object
))
722 obstack
= function_obstack
;
723 obstack_name
= "function obstack";
725 else if (_obstack_allocated_p (&permanent_obstack
, object
))
727 obstack
= &permanent_obstack
;
728 obstack_name
= "permanent_obstack";
730 else if (_obstack_allocated_p (&momentary_obstack
, object
))
732 obstack
= &momentary_obstack
;
733 obstack_name
= "momentary_obstack";
735 else if (_obstack_allocated_p (function_maybepermanent_obstack
, object
))
737 obstack
= function_maybepermanent_obstack
;
738 obstack_name
= "function maybepermanent obstack";
740 else if (_obstack_allocated_p (&temp_decl_obstack
, object
))
742 obstack
= &temp_decl_obstack
;
743 obstack_name
= "temp_decl_obstack";
746 /* Check to see if the object is in the free area of the obstack. */
749 if (object
>= obstack
->next_free
750 && object
< obstack
->chunk_limit
)
751 fprintf (file
, "%s in free portion of obstack %s",
752 prefix
, obstack_name
);
754 fprintf (file
, "%s allocated from %s", prefix
, obstack_name
);
757 fprintf (file
, "%s not allocated from any obstack", prefix
);
761 debug_obstack (object
)
764 print_obstack_name (object
, stderr
, "object");
765 fprintf (stderr
, ".\n");
768 /* Return 1 if OBJ is in the permanent obstack.
769 This is slow, and should be used only for debugging.
770 Use TREE_PERMANENT for other purposes. */
773 object_permanent_p (obj
)
776 return _obstack_allocated_p (&permanent_obstack
, obj
);
779 /* Start a level of momentary allocation.
780 In C, each compound statement has its own level
781 and that level is freed at the end of each statement.
782 All expression nodes are allocated in the momentary allocation level. */
787 struct momentary_level
*tem
788 = (struct momentary_level
*) obstack_alloc (&momentary_obstack
,
789 sizeof (struct momentary_level
));
790 tem
->prev
= momentary_stack
;
791 tem
->base
= (char *) obstack_base (&momentary_obstack
);
792 tem
->obstack
= expression_obstack
;
793 momentary_stack
= tem
;
794 expression_obstack
= &momentary_obstack
;
797 /* Set things up so the next clear_momentary will only clear memory
798 past our present position in momentary_obstack. */
801 preserve_momentary ()
803 momentary_stack
->base
= (char *) obstack_base (&momentary_obstack
);
806 /* Free all the storage in the current momentary-allocation level.
807 In C, this happens at the end of each statement. */
812 obstack_free (&momentary_obstack
, momentary_stack
->base
);
815 /* Discard a level of momentary allocation.
816 In C, this happens at the end of each compound statement.
817 Restore the status of expression node allocation
818 that was in effect before this level was created. */
823 struct momentary_level
*tem
= momentary_stack
;
824 momentary_stack
= tem
->prev
;
825 expression_obstack
= tem
->obstack
;
826 /* We can't free TEM from the momentary_obstack, because there might
827 be objects above it which have been saved. We can free back to the
828 stack of the level we are popping off though. */
829 obstack_free (&momentary_obstack
, tem
->base
);
832 /* Pop back to the previous level of momentary allocation,
833 but don't free any momentary data just yet. */
836 pop_momentary_nofree ()
838 struct momentary_level
*tem
= momentary_stack
;
839 momentary_stack
= tem
->prev
;
840 expression_obstack
= tem
->obstack
;
843 /* Call when starting to parse a declaration:
844 make expressions in the declaration last the length of the function.
845 Returns an argument that should be passed to resume_momentary later. */
850 register int tem
= expression_obstack
== &momentary_obstack
;
851 expression_obstack
= saveable_obstack
;
855 /* Call when finished parsing a declaration:
856 restore the treatment of node-allocation that was
857 in effect before the suspension.
858 YES should be the value previously returned by suspend_momentary. */
861 resume_momentary (yes
)
865 expression_obstack
= &momentary_obstack
;
868 /* Init the tables indexed by tree code.
869 Note that languages can add to these tables to define their own codes. */
877 /* Return a newly allocated node of code CODE.
878 Initialize the node's unique id and its TREE_PERMANENT flag.
879 For decl and type nodes, some other fields are initialized.
880 The rest of the node is initialized to zero.
882 Achoo! I got a code in the node. */
889 register int type
= TREE_CODE_CLASS (code
);
890 register int length
= 0;
891 register struct obstack
*obstack
= current_obstack
;
892 #ifdef GATHER_STATISTICS
893 register tree_node_kind kind
;
898 case 'd': /* A decl node */
899 #ifdef GATHER_STATISTICS
902 length
= sizeof (struct tree_decl
);
903 /* All decls in an inline function need to be saved. */
904 if (obstack
!= &permanent_obstack
)
905 obstack
= saveable_obstack
;
907 /* PARM_DECLs go on the context of the parent. If this is a nested
908 function, then we must allocate the PARM_DECL on the parent's
909 obstack, so that they will live to the end of the parent's
910 closing brace. This is necessary in case we try to inline the
911 function into its parent.
913 PARM_DECLs of top-level functions do not have this problem. However,
914 we allocate them where we put the FUNCTION_DECL for languages such as
915 Ada that need to consult some flags in the PARM_DECLs of the function
918 See comment in restore_tree_status for why we can't put this
919 in function_obstack. */
920 if (code
== PARM_DECL
&& obstack
!= &permanent_obstack
)
923 if (current_function_decl
)
924 context
= decl_function_context (current_function_decl
);
928 = find_function_data (context
)->function_maybepermanent_obstack
;
932 case 't': /* a type node */
933 #ifdef GATHER_STATISTICS
936 length
= sizeof (struct tree_type
);
937 /* All data types are put where we can preserve them if nec. */
938 if (obstack
!= &permanent_obstack
)
939 obstack
= all_types_permanent
? &permanent_obstack
: saveable_obstack
;
942 case 'b': /* a lexical block */
943 #ifdef GATHER_STATISTICS
946 length
= sizeof (struct tree_block
);
947 /* All BLOCK nodes are put where we can preserve them if nec. */
948 if (obstack
!= &permanent_obstack
)
949 obstack
= saveable_obstack
;
952 case 's': /* an expression with side effects */
953 #ifdef GATHER_STATISTICS
957 case 'r': /* a reference */
958 #ifdef GATHER_STATISTICS
962 case 'e': /* an expression */
963 case '<': /* a comparison expression */
964 case '1': /* a unary arithmetic expression */
965 case '2': /* a binary arithmetic expression */
966 #ifdef GATHER_STATISTICS
970 obstack
= expression_obstack
;
971 /* All BIND_EXPR nodes are put where we can preserve them if nec. */
972 if (code
== BIND_EXPR
&& obstack
!= &permanent_obstack
)
973 obstack
= saveable_obstack
;
974 length
= sizeof (struct tree_exp
)
975 + (tree_code_length
[(int) code
] - 1) * sizeof (char *);
978 case 'c': /* a constant */
979 #ifdef GATHER_STATISTICS
982 obstack
= expression_obstack
;
984 /* We can't use tree_code_length for INTEGER_CST, since the number of
985 words is machine-dependent due to varying length of HOST_WIDE_INT,
986 which might be wider than a pointer (e.g., long long). Similarly
987 for REAL_CST, since the number of words is machine-dependent due
988 to varying size and alignment of `double'. */
990 if (code
== INTEGER_CST
)
991 length
= sizeof (struct tree_int_cst
);
992 else if (code
== REAL_CST
)
993 length
= sizeof (struct tree_real_cst
);
995 length
= sizeof (struct tree_common
)
996 + tree_code_length
[(int) code
] * sizeof (char *);
999 case 'x': /* something random, like an identifier. */
1000 #ifdef GATHER_STATISTICS
1001 if (code
== IDENTIFIER_NODE
)
1003 else if (code
== OP_IDENTIFIER
)
1005 else if (code
== TREE_VEC
)
1010 length
= sizeof (struct tree_common
)
1011 + tree_code_length
[(int) code
] * sizeof (char *);
1012 /* Identifier nodes are always permanent since they are
1013 unique in a compiler run. */
1014 if (code
== IDENTIFIER_NODE
) obstack
= &permanent_obstack
;
1022 t
= ggc_alloc_tree (length
);
1025 t
= (tree
) obstack_alloc (obstack
, length
);
1026 bzero ((PTR
) t
, length
);
1029 #ifdef GATHER_STATISTICS
1030 tree_node_counts
[(int)kind
]++;
1031 tree_node_sizes
[(int)kind
] += length
;
1034 TREE_SET_CODE (t
, code
);
1035 if (obstack
== &permanent_obstack
)
1036 TREE_PERMANENT (t
) = 1;
1041 TREE_SIDE_EFFECTS (t
) = 1;
1042 TREE_TYPE (t
) = void_type_node
;
1046 if (code
!= FUNCTION_DECL
)
1048 DECL_IN_SYSTEM_HEADER (t
)
1049 = in_system_header
&& (obstack
== &permanent_obstack
);
1050 DECL_SOURCE_LINE (t
) = lineno
;
1051 DECL_SOURCE_FILE (t
) = (input_filename
) ? input_filename
: "<built-in>";
1052 DECL_UID (t
) = next_decl_uid
++;
1053 /* Note that we have not yet computed the alias set for this
1055 DECL_POINTER_ALIAS_SET (t
) = -1;
1059 TYPE_UID (t
) = next_type_uid
++;
1061 TYPE_MAIN_VARIANT (t
) = t
;
1062 TYPE_OBSTACK (t
) = obstack
;
1063 TYPE_ATTRIBUTES (t
) = NULL_TREE
;
1064 #ifdef SET_DEFAULT_TYPE_ATTRIBUTES
1065 SET_DEFAULT_TYPE_ATTRIBUTES (t
);
1067 /* Note that we have not yet computed the alias set for this
1069 TYPE_ALIAS_SET (t
) = -1;
1073 TREE_CONSTANT (t
) = 1;
1080 /* Return a new node with the same contents as NODE except that its
1081 TREE_CHAIN is zero and it has a fresh uid. Unlike make_node, this
1082 function always performs the allocation on the CURRENT_OBSTACK;
1083 it's up to the caller to pick the right obstack before calling this
1091 register enum tree_code code
= TREE_CODE (node
);
1092 register int length
= 0;
1094 switch (TREE_CODE_CLASS (code
))
1096 case 'd': /* A decl node */
1097 length
= sizeof (struct tree_decl
);
1100 case 't': /* a type node */
1101 length
= sizeof (struct tree_type
);
1104 case 'b': /* a lexical block node */
1105 length
= sizeof (struct tree_block
);
1108 case 'r': /* a reference */
1109 case 'e': /* an expression */
1110 case 's': /* an expression with side effects */
1111 case '<': /* a comparison expression */
1112 case '1': /* a unary arithmetic expression */
1113 case '2': /* a binary arithmetic expression */
1114 length
= sizeof (struct tree_exp
)
1115 + (tree_code_length
[(int) code
] - 1) * sizeof (char *);
1118 case 'c': /* a constant */
1119 /* We can't use tree_code_length for INTEGER_CST, since the number of
1120 words is machine-dependent due to varying length of HOST_WIDE_INT,
1121 which might be wider than a pointer (e.g., long long). Similarly
1122 for REAL_CST, since the number of words is machine-dependent due
1123 to varying size and alignment of `double'. */
1124 if (code
== INTEGER_CST
)
1125 length
= sizeof (struct tree_int_cst
);
1126 else if (code
== REAL_CST
)
1127 length
= sizeof (struct tree_real_cst
);
1129 length
= (sizeof (struct tree_common
)
1130 + tree_code_length
[(int) code
] * sizeof (char *));
1133 case 'x': /* something random, like an identifier. */
1134 length
= sizeof (struct tree_common
)
1135 + tree_code_length
[(int) code
] * sizeof (char *);
1136 if (code
== TREE_VEC
)
1137 length
+= (TREE_VEC_LENGTH (node
) - 1) * sizeof (char *);
1141 t
= ggc_alloc_tree (length
);
1143 t
= (tree
) obstack_alloc (current_obstack
, length
);
1144 memcpy (t
, node
, length
);
1146 /* EXPR_WITH_FILE_LOCATION must keep filename info stored in TREE_CHAIN */
1147 if (TREE_CODE (node
) != EXPR_WITH_FILE_LOCATION
)
1149 TREE_ASM_WRITTEN (t
) = 0;
1151 if (TREE_CODE_CLASS (code
) == 'd')
1152 DECL_UID (t
) = next_decl_uid
++;
1153 else if (TREE_CODE_CLASS (code
) == 't')
1155 TYPE_UID (t
) = next_type_uid
++;
1156 TYPE_OBSTACK (t
) = current_obstack
;
1158 /* The following is so that the debug code for
1159 the copy is different from the original type.
1160 The two statements usually duplicate each other
1161 (because they clear fields of the same union),
1162 but the optimizer should catch that. */
1163 TYPE_SYMTAB_POINTER (t
) = 0;
1164 TYPE_SYMTAB_ADDRESS (t
) = 0;
1167 TREE_PERMANENT (t
) = (current_obstack
== &permanent_obstack
);
1172 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1173 For example, this can copy a list made of TREE_LIST nodes. */
1180 register tree prev
, next
;
1185 head
= prev
= copy_node (list
);
1186 next
= TREE_CHAIN (list
);
1189 TREE_CHAIN (prev
) = copy_node (next
);
1190 prev
= TREE_CHAIN (prev
);
1191 next
= TREE_CHAIN (next
);
1198 /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
1199 If an identifier with that name has previously been referred to,
1200 the same node is returned this time. */
1203 get_identifier (text
)
1204 register const char *text
;
1209 register int len
, hash_len
;
1211 /* Compute length of text in len. */
1212 len
= strlen (text
);
1214 /* Decide how much of that length to hash on */
1216 if (warn_id_clash
&& (unsigned)len
> id_clash_len
)
1217 hash_len
= id_clash_len
;
1219 /* Compute hash code */
1220 hi
= hash_len
* 613 + (unsigned) text
[0];
1221 for (i
= 1; i
< hash_len
; i
+= 2)
1222 hi
= ((hi
* 613) + (unsigned) (text
[i
]));
1224 hi
&= (1 << HASHBITS
) - 1;
1225 hi
%= MAX_HASH_TABLE
;
1227 /* Search table for identifier */
1228 for (idp
= hash_table
[hi
]; idp
; idp
= TREE_CHAIN (idp
))
1229 if (IDENTIFIER_LENGTH (idp
) == len
1230 && IDENTIFIER_POINTER (idp
)[0] == text
[0]
1231 && !bcmp (IDENTIFIER_POINTER (idp
), text
, len
))
1232 return idp
; /* <-- return if found */
1234 /* Not found; optionally warn about a similar identifier */
1235 if (warn_id_clash
&& do_identifier_warnings
&& (unsigned)len
>= id_clash_len
)
1236 for (idp
= hash_table
[hi
]; idp
; idp
= TREE_CHAIN (idp
))
1237 if (!strncmp (IDENTIFIER_POINTER (idp
), text
, id_clash_len
))
1239 warning ("`%s' and `%s' identical in first %d characters",
1240 IDENTIFIER_POINTER (idp
), text
, id_clash_len
);
1244 if (tree_code_length
[(int) IDENTIFIER_NODE
] < 0)
1245 abort (); /* set_identifier_size hasn't been called. */
1247 /* Not found, create one, add to chain */
1248 idp
= make_node (IDENTIFIER_NODE
);
1249 IDENTIFIER_LENGTH (idp
) = len
;
1250 #ifdef GATHER_STATISTICS
1251 id_string_size
+= len
;
1255 IDENTIFIER_POINTER (idp
) = ggc_alloc_string (text
, len
);
1257 IDENTIFIER_POINTER (idp
) = obstack_copy0 (&permanent_obstack
, text
, len
);
1259 TREE_CHAIN (idp
) = hash_table
[hi
];
1260 hash_table
[hi
] = idp
;
1261 return idp
; /* <-- return if created */
1264 /* If an identifier with the name TEXT (a null-terminated string) has
1265 previously been referred to, return that node; otherwise return
1269 maybe_get_identifier (text
)
1270 register const char *text
;
1275 register int len
, hash_len
;
1277 /* Compute length of text in len. */
1278 len
= strlen (text
);
1280 /* Decide how much of that length to hash on */
1282 if (warn_id_clash
&& (unsigned)len
> id_clash_len
)
1283 hash_len
= id_clash_len
;
1285 /* Compute hash code */
1286 hi
= hash_len
* 613 + (unsigned) text
[0];
1287 for (i
= 1; i
< hash_len
; i
+= 2)
1288 hi
= ((hi
* 613) + (unsigned) (text
[i
]));
1290 hi
&= (1 << HASHBITS
) - 1;
1291 hi
%= MAX_HASH_TABLE
;
1293 /* Search table for identifier */
1294 for (idp
= hash_table
[hi
]; idp
; idp
= TREE_CHAIN (idp
))
1295 if (IDENTIFIER_LENGTH (idp
) == len
1296 && IDENTIFIER_POINTER (idp
)[0] == text
[0]
1297 && !bcmp (IDENTIFIER_POINTER (idp
), text
, len
))
1298 return idp
; /* <-- return if found */
1303 /* Enable warnings on similar identifiers (if requested).
1304 Done after the built-in identifiers are created. */
1307 start_identifier_warnings ()
1309 do_identifier_warnings
= 1;
1312 /* Record the size of an identifier node for the language in use.
1313 SIZE is the total size in bytes.
1314 This is called by the language-specific files. This must be
1315 called before allocating any identifiers. */
1318 set_identifier_size (size
)
1321 tree_code_length
[(int) IDENTIFIER_NODE
]
1322 = (size
- sizeof (struct tree_common
)) / sizeof (tree
);
1325 /* Return a newly constructed INTEGER_CST node whose constant value
1326 is specified by the two ints LOW and HI.
1327 The TREE_TYPE is set to `int'.
1329 This function should be used via the `build_int_2' macro. */
1332 build_int_2_wide (low
, hi
)
1333 HOST_WIDE_INT low
, hi
;
1335 register tree t
= make_node (INTEGER_CST
);
1336 TREE_INT_CST_LOW (t
) = low
;
1337 TREE_INT_CST_HIGH (t
) = hi
;
1338 TREE_TYPE (t
) = integer_type_node
;
1342 /* Return a new REAL_CST node whose type is TYPE and value is D. */
1345 build_real (type
, d
)
1352 /* Check for valid float value for this type on this target machine;
1353 if not, can print error message and store a valid value in D. */
1354 #ifdef CHECK_FLOAT_VALUE
1355 CHECK_FLOAT_VALUE (TYPE_MODE (type
), d
, overflow
);
1358 v
= make_node (REAL_CST
);
1359 TREE_TYPE (v
) = type
;
1360 TREE_REAL_CST (v
) = d
;
1361 TREE_OVERFLOW (v
) = TREE_CONSTANT_OVERFLOW (v
) = overflow
;
1365 /* Return a new REAL_CST node whose type is TYPE
1366 and whose value is the integer value of the INTEGER_CST node I. */
1368 #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC)
1371 real_value_from_int_cst (type
, i
)
1376 #ifdef REAL_ARITHMETIC
1377 if (! TREE_UNSIGNED (TREE_TYPE (i
)))
1378 REAL_VALUE_FROM_INT (d
, TREE_INT_CST_LOW (i
), TREE_INT_CST_HIGH (i
),
1381 REAL_VALUE_FROM_UNSIGNED_INT (d
, TREE_INT_CST_LOW (i
),
1382 TREE_INT_CST_HIGH (i
), TYPE_MODE (type
));
1383 #else /* not REAL_ARITHMETIC */
1384 /* Some 386 compilers mishandle unsigned int to float conversions,
1385 so introduce a temporary variable E to avoid those bugs. */
1386 if (TREE_INT_CST_HIGH (i
) < 0 && ! TREE_UNSIGNED (TREE_TYPE (i
)))
1390 d
= (double) (~ TREE_INT_CST_HIGH (i
));
1391 e
= ((double) ((HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
/ 2))
1392 * (double) ((HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
/ 2)));
1394 e
= (double) (unsigned HOST_WIDE_INT
) (~ TREE_INT_CST_LOW (i
));
1402 d
= (double) (unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (i
);
1403 e
= ((double) ((HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
/ 2))
1404 * (double) ((HOST_WIDE_INT
) 1 << (HOST_BITS_PER_WIDE_INT
/ 2)));
1406 e
= (double) (unsigned HOST_WIDE_INT
) TREE_INT_CST_LOW (i
);
1409 #endif /* not REAL_ARITHMETIC */
1422 build_real_from_int_cst_1 (data
)
1425 struct brfic_args
* args
= (struct brfic_args
*) data
;
1427 #ifdef REAL_ARITHMETIC
1428 args
->d
= real_value_from_int_cst (args
->type
, args
->i
);
1431 REAL_VALUE_TRUNCATE (TYPE_MODE (args
->type
),
1432 real_value_from_int_cst (args
->type
, args
->i
));
1436 /* This function can't be implemented if we can't do arithmetic
1437 on the float representation. */
1440 build_real_from_int_cst (type
, i
)
1445 int overflow
= TREE_OVERFLOW (i
);
1447 struct brfic_args args
;
1449 v
= make_node (REAL_CST
);
1450 TREE_TYPE (v
) = type
;
1452 /* Setup input for build_real_from_int_cst_1() */
1456 if (do_float_handler (build_real_from_int_cst_1
, (PTR
) &args
))
1458 /* Receive output from build_real_from_int_cst_1() */
1463 /* We got an exception from build_real_from_int_cst_1() */
1468 /* Check for valid float value for this type on this target machine. */
1470 #ifdef CHECK_FLOAT_VALUE
1471 CHECK_FLOAT_VALUE (TYPE_MODE (type
), d
, overflow
);
1474 TREE_REAL_CST (v
) = d
;
1475 TREE_OVERFLOW (v
) = TREE_CONSTANT_OVERFLOW (v
) = overflow
;
1479 #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */
1481 /* Return a newly constructed STRING_CST node whose value is
1482 the LEN characters at STR.
1483 The TREE_TYPE is not initialized. */
1486 build_string (len
, str
)
1490 /* Put the string in saveable_obstack since it will be placed in the RTL
1491 for an "asm" statement and will also be kept around a while if
1492 deferring constant output in varasm.c. */
1494 register tree s
= make_node (STRING_CST
);
1495 TREE_STRING_LENGTH (s
) = len
;
1497 TREE_STRING_POINTER (s
) = ggc_alloc_string (str
, len
);
1499 TREE_STRING_POINTER (s
) = obstack_copy0 (saveable_obstack
, str
, len
);
1503 /* Return a newly constructed COMPLEX_CST node whose value is
1504 specified by the real and imaginary parts REAL and IMAG.
1505 Both REAL and IMAG should be constant nodes. TYPE, if specified,
1506 will be the type of the COMPLEX_CST; otherwise a new type will be made. */
1509 build_complex (type
, real
, imag
)
1513 register tree t
= make_node (COMPLEX_CST
);
1515 TREE_REALPART (t
) = real
;
1516 TREE_IMAGPART (t
) = imag
;
1517 TREE_TYPE (t
) = type
? type
: build_complex_type (TREE_TYPE (real
));
1518 TREE_OVERFLOW (t
) = TREE_OVERFLOW (real
) | TREE_OVERFLOW (imag
);
1519 TREE_CONSTANT_OVERFLOW (t
)
1520 = TREE_CONSTANT_OVERFLOW (real
) | TREE_CONSTANT_OVERFLOW (imag
);
1524 /* Build a newly constructed TREE_VEC node of length LEN. */
1531 register int length
= (len
-1) * sizeof (tree
) + sizeof (struct tree_vec
);
1532 register struct obstack
*obstack
= current_obstack
;
1534 #ifdef GATHER_STATISTICS
1535 tree_node_counts
[(int)vec_kind
]++;
1536 tree_node_sizes
[(int)vec_kind
] += length
;
1540 t
= ggc_alloc_tree (length
);
1543 t
= (tree
) obstack_alloc (obstack
, length
);
1544 bzero ((PTR
) t
, length
);
1547 TREE_SET_CODE (t
, TREE_VEC
);
1548 TREE_VEC_LENGTH (t
) = len
;
1549 if (obstack
== &permanent_obstack
)
1550 TREE_PERMANENT (t
) = 1;
1555 /* Return 1 if EXPR is the integer constant zero or a complex constant
1559 integer_zerop (expr
)
1564 return ((TREE_CODE (expr
) == INTEGER_CST
1565 && ! TREE_CONSTANT_OVERFLOW (expr
)
1566 && TREE_INT_CST_LOW (expr
) == 0
1567 && TREE_INT_CST_HIGH (expr
) == 0)
1568 || (TREE_CODE (expr
) == COMPLEX_CST
1569 && integer_zerop (TREE_REALPART (expr
))
1570 && integer_zerop (TREE_IMAGPART (expr
))));
1573 /* Return 1 if EXPR is the integer constant one or the corresponding
1574 complex constant. */
1582 return ((TREE_CODE (expr
) == INTEGER_CST
1583 && ! TREE_CONSTANT_OVERFLOW (expr
)
1584 && TREE_INT_CST_LOW (expr
) == 1
1585 && TREE_INT_CST_HIGH (expr
) == 0)
1586 || (TREE_CODE (expr
) == COMPLEX_CST
1587 && integer_onep (TREE_REALPART (expr
))
1588 && integer_zerop (TREE_IMAGPART (expr
))));
1591 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1592 it contains. Likewise for the corresponding complex constant. */
1595 integer_all_onesp (expr
)
1603 if (TREE_CODE (expr
) == COMPLEX_CST
1604 && integer_all_onesp (TREE_REALPART (expr
))
1605 && integer_zerop (TREE_IMAGPART (expr
)))
1608 else if (TREE_CODE (expr
) != INTEGER_CST
1609 || TREE_CONSTANT_OVERFLOW (expr
))
1612 uns
= TREE_UNSIGNED (TREE_TYPE (expr
));
1614 return TREE_INT_CST_LOW (expr
) == -1 && TREE_INT_CST_HIGH (expr
) == -1;
1616 /* Note that using TYPE_PRECISION here is wrong. We care about the
1617 actual bits, not the (arbitrary) range of the type. */
1618 prec
= GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
)));
1619 if (prec
>= HOST_BITS_PER_WIDE_INT
)
1621 int high_value
, shift_amount
;
1623 shift_amount
= prec
- HOST_BITS_PER_WIDE_INT
;
1625 if (shift_amount
> HOST_BITS_PER_WIDE_INT
)
1626 /* Can not handle precisions greater than twice the host int size. */
1628 else if (shift_amount
== HOST_BITS_PER_WIDE_INT
)
1629 /* Shifting by the host word size is undefined according to the ANSI
1630 standard, so we must handle this as a special case. */
1633 high_value
= ((HOST_WIDE_INT
) 1 << shift_amount
) - 1;
1635 return TREE_INT_CST_LOW (expr
) == -1
1636 && TREE_INT_CST_HIGH (expr
) == high_value
;
1639 return TREE_INT_CST_LOW (expr
) == ((HOST_WIDE_INT
) 1 << prec
) - 1;
1642 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1646 integer_pow2p (expr
)
1650 HOST_WIDE_INT high
, low
;
1654 if (TREE_CODE (expr
) == COMPLEX_CST
1655 && integer_pow2p (TREE_REALPART (expr
))
1656 && integer_zerop (TREE_IMAGPART (expr
)))
1659 if (TREE_CODE (expr
) != INTEGER_CST
|| TREE_CONSTANT_OVERFLOW (expr
))
1662 prec
= (POINTER_TYPE_P (TREE_TYPE (expr
))
1663 ? POINTER_SIZE
: TYPE_PRECISION (TREE_TYPE (expr
)));
1664 high
= TREE_INT_CST_HIGH (expr
);
1665 low
= TREE_INT_CST_LOW (expr
);
1667 /* First clear all bits that are beyond the type's precision in case
1668 we've been sign extended. */
1670 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
1672 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1673 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1677 if (prec
< HOST_BITS_PER_WIDE_INT
)
1678 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1681 if (high
== 0 && low
== 0)
1684 return ((high
== 0 && (low
& (low
- 1)) == 0)
1685 || (low
== 0 && (high
& (high
- 1)) == 0));
1688 /* Return the power of two represented by a tree node known to be a
1696 HOST_WIDE_INT high
, low
;
1700 if (TREE_CODE (expr
) == COMPLEX_CST
)
1701 return tree_log2 (TREE_REALPART (expr
));
1703 prec
= (POINTER_TYPE_P (TREE_TYPE (expr
))
1704 ? POINTER_SIZE
: TYPE_PRECISION (TREE_TYPE (expr
)));
1706 high
= TREE_INT_CST_HIGH (expr
);
1707 low
= TREE_INT_CST_LOW (expr
);
1709 /* First clear all bits that are beyond the type's precision in case
1710 we've been sign extended. */
1712 if (prec
== 2 * HOST_BITS_PER_WIDE_INT
)
1714 else if (prec
> HOST_BITS_PER_WIDE_INT
)
1715 high
&= ~((HOST_WIDE_INT
) (-1) << (prec
- HOST_BITS_PER_WIDE_INT
));
1719 if (prec
< HOST_BITS_PER_WIDE_INT
)
1720 low
&= ~((HOST_WIDE_INT
) (-1) << prec
);
1723 return (high
!= 0 ? HOST_BITS_PER_WIDE_INT
+ exact_log2 (high
)
1724 : exact_log2 (low
));
1727 /* Return 1 if EXPR is the real constant zero. */
1735 return ((TREE_CODE (expr
) == REAL_CST
1736 && ! TREE_CONSTANT_OVERFLOW (expr
)
1737 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst0
))
1738 || (TREE_CODE (expr
) == COMPLEX_CST
1739 && real_zerop (TREE_REALPART (expr
))
1740 && real_zerop (TREE_IMAGPART (expr
))));
1743 /* Return 1 if EXPR is the real constant one in real or complex form. */
1751 return ((TREE_CODE (expr
) == REAL_CST
1752 && ! TREE_CONSTANT_OVERFLOW (expr
)
1753 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst1
))
1754 || (TREE_CODE (expr
) == COMPLEX_CST
1755 && real_onep (TREE_REALPART (expr
))
1756 && real_zerop (TREE_IMAGPART (expr
))));
1759 /* Return 1 if EXPR is the real constant two. */
1767 return ((TREE_CODE (expr
) == REAL_CST
1768 && ! TREE_CONSTANT_OVERFLOW (expr
)
1769 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr
), dconst2
))
1770 || (TREE_CODE (expr
) == COMPLEX_CST
1771 && real_twop (TREE_REALPART (expr
))
1772 && real_zerop (TREE_IMAGPART (expr
))));
1775 /* Nonzero if EXP is a constant or a cast of a constant. */
1778 really_constant_p (exp
)
1781 /* This is not quite the same as STRIP_NOPS. It does more. */
1782 while (TREE_CODE (exp
) == NOP_EXPR
1783 || TREE_CODE (exp
) == CONVERT_EXPR
1784 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
1785 exp
= TREE_OPERAND (exp
, 0);
1786 return TREE_CONSTANT (exp
);
1789 /* Return first list element whose TREE_VALUE is ELEM.
1790 Return 0 if ELEM is not in LIST. */
1793 value_member (elem
, list
)
1798 if (elem
== TREE_VALUE (list
))
1800 list
= TREE_CHAIN (list
);
1805 /* Return first list element whose TREE_PURPOSE is ELEM.
1806 Return 0 if ELEM is not in LIST. */
1809 purpose_member (elem
, list
)
1814 if (elem
== TREE_PURPOSE (list
))
1816 list
= TREE_CHAIN (list
);
1821 /* Return first list element whose BINFO_TYPE is ELEM.
1822 Return 0 if ELEM is not in LIST. */
1825 binfo_member (elem
, list
)
1830 if (elem
== BINFO_TYPE (list
))
1832 list
= TREE_CHAIN (list
);
1837 /* Return nonzero if ELEM is part of the chain CHAIN. */
1840 chain_member (elem
, chain
)
1847 chain
= TREE_CHAIN (chain
);
1853 /* Return nonzero if ELEM is equal to TREE_VALUE (CHAIN) for any piece of
1855 /* ??? This function was added for machine specific attributes but is no
1856 longer used. It could be deleted if we could confirm all front ends
1860 chain_member_value (elem
, chain
)
1865 if (elem
== TREE_VALUE (chain
))
1867 chain
= TREE_CHAIN (chain
);
1873 /* Return nonzero if ELEM is equal to TREE_PURPOSE (CHAIN)
1874 for any piece of chain CHAIN. */
1875 /* ??? This function was added for machine specific attributes but is no
1876 longer used. It could be deleted if we could confirm all front ends
1880 chain_member_purpose (elem
, chain
)
1885 if (elem
== TREE_PURPOSE (chain
))
1887 chain
= TREE_CHAIN (chain
);
1893 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1894 We expect a null pointer to mark the end of the chain.
1895 This is the Lisp primitive `length'. */
1902 register int len
= 0;
1904 for (tail
= t
; tail
; tail
= TREE_CHAIN (tail
))
1910 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1911 by modifying the last node in chain 1 to point to chain 2.
1912 This is the Lisp primitive `nconc'. */
1922 #ifdef ENABLE_CHECKING
1926 for (t1
= op1
; TREE_CHAIN (t1
); t1
= TREE_CHAIN (t1
))
1928 TREE_CHAIN (t1
) = op2
;
1929 #ifdef ENABLE_CHECKING
1930 for (t2
= op2
; t2
; t2
= TREE_CHAIN (t2
))
1932 abort (); /* Circularity created. */
1939 /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
1943 register tree chain
;
1947 while ((next
= TREE_CHAIN (chain
)))
1952 /* Reverse the order of elements in the chain T,
1953 and return the new head of the chain (old last element). */
1959 register tree prev
= 0, decl
, next
;
1960 for (decl
= t
; decl
; decl
= next
)
1962 next
= TREE_CHAIN (decl
);
1963 TREE_CHAIN (decl
) = prev
;
1969 /* Given a chain CHAIN of tree nodes,
1970 construct and return a list of those nodes. */
1976 tree result
= NULL_TREE
;
1977 tree in_tail
= chain
;
1978 tree out_tail
= NULL_TREE
;
1982 tree next
= tree_cons (NULL_TREE
, in_tail
, NULL_TREE
);
1984 TREE_CHAIN (out_tail
) = next
;
1988 in_tail
= TREE_CHAIN (in_tail
);
1994 /* Return a newly created TREE_LIST node whose
1995 purpose and value fields are PARM and VALUE. */
1998 build_tree_list (parm
, value
)
2001 register tree t
= make_node (TREE_LIST
);
2002 TREE_PURPOSE (t
) = parm
;
2003 TREE_VALUE (t
) = value
;
2007 /* Similar, but build on the temp_decl_obstack. */
2010 build_decl_list (parm
, value
)
2014 register struct obstack
*ambient_obstack
= current_obstack
;
2015 current_obstack
= &temp_decl_obstack
;
2016 node
= build_tree_list (parm
, value
);
2017 current_obstack
= ambient_obstack
;
2021 /* Similar, but build on the expression_obstack. */
2024 build_expr_list (parm
, value
)
2028 register struct obstack
*ambient_obstack
= current_obstack
;
2029 current_obstack
= expression_obstack
;
2030 node
= build_tree_list (parm
, value
);
2031 current_obstack
= ambient_obstack
;
2035 /* Return a newly created TREE_LIST node whose
2036 purpose and value fields are PARM and VALUE
2037 and whose TREE_CHAIN is CHAIN. */
2040 tree_cons (purpose
, value
, chain
)
2041 tree purpose
, value
, chain
;
2044 register tree node
= make_node (TREE_LIST
);
2049 node
= ggc_alloc_tree (sizeof (struct tree_list
));
2052 node
= (tree
) obstack_alloc (current_obstack
, sizeof (struct tree_list
));
2053 bzero (node
, sizeof (struct tree_common
));
2056 #ifdef GATHER_STATISTICS
2057 tree_node_counts
[(int)x_kind
]++;
2058 tree_node_sizes
[(int)x_kind
] += sizeof (struct tree_list
);
2062 TREE_SET_CODE (node
, TREE_LIST
);
2063 if (current_obstack
== &permanent_obstack
)
2064 TREE_PERMANENT (node
) = 1;
2067 TREE_CHAIN (node
) = chain
;
2068 TREE_PURPOSE (node
) = purpose
;
2069 TREE_VALUE (node
) = value
;
2073 /* Similar, but build on the temp_decl_obstack. */
2076 decl_tree_cons (purpose
, value
, chain
)
2077 tree purpose
, value
, chain
;
2080 register struct obstack
*ambient_obstack
= current_obstack
;
2081 current_obstack
= &temp_decl_obstack
;
2082 node
= tree_cons (purpose
, value
, chain
);
2083 current_obstack
= ambient_obstack
;
2087 /* Similar, but build on the expression_obstack. */
2090 expr_tree_cons (purpose
, value
, chain
)
2091 tree purpose
, value
, chain
;
2094 register struct obstack
*ambient_obstack
= current_obstack
;
2095 current_obstack
= expression_obstack
;
2096 node
= tree_cons (purpose
, value
, chain
);
2097 current_obstack
= ambient_obstack
;
2101 /* Same as `tree_cons' but make a permanent object. */
2104 perm_tree_cons (purpose
, value
, chain
)
2105 tree purpose
, value
, chain
;
2108 register struct obstack
*ambient_obstack
= current_obstack
;
2109 current_obstack
= &permanent_obstack
;
2111 node
= tree_cons (purpose
, value
, chain
);
2112 current_obstack
= ambient_obstack
;
2116 /* Same as `tree_cons', but make this node temporary, regardless. */
2119 temp_tree_cons (purpose
, value
, chain
)
2120 tree purpose
, value
, chain
;
2123 register struct obstack
*ambient_obstack
= current_obstack
;
2124 current_obstack
= &temporary_obstack
;
2126 node
= tree_cons (purpose
, value
, chain
);
2127 current_obstack
= ambient_obstack
;
2131 /* Same as `tree_cons', but save this node if the function's RTL is saved. */
2134 saveable_tree_cons (purpose
, value
, chain
)
2135 tree purpose
, value
, chain
;
2138 register struct obstack
*ambient_obstack
= current_obstack
;
2139 current_obstack
= saveable_obstack
;
2141 node
= tree_cons (purpose
, value
, chain
);
2142 current_obstack
= ambient_obstack
;
2146 /* Return the size nominally occupied by an object of type TYPE
2147 when it resides in memory. The value is measured in units of bytes,
2148 and its data type is that normally used for type sizes
2149 (which is the first type created by make_signed_type or
2150 make_unsigned_type). */
2153 size_in_bytes (type
)
2158 if (type
== error_mark_node
)
2159 return integer_zero_node
;
2161 type
= TYPE_MAIN_VARIANT (type
);
2162 t
= TYPE_SIZE_UNIT (type
);
2165 incomplete_type_error (NULL_TREE
, type
);
2166 return integer_zero_node
;
2168 if (TREE_CODE (t
) == INTEGER_CST
)
2169 force_fit_type (t
, 0);
2174 /* Return the size of TYPE (in bytes) as a wide integer
2175 or return -1 if the size can vary or is larger than an integer. */
2178 int_size_in_bytes (type
)
2183 if (type
== error_mark_node
)
2186 type
= TYPE_MAIN_VARIANT (type
);
2187 t
= TYPE_SIZE_UNIT (type
);
2189 || TREE_CODE (t
) != INTEGER_CST
2190 || TREE_INT_CST_HIGH (t
) != 0)
2193 return TREE_INT_CST_LOW (t
);
2196 /* Return, as a tree node, the number of elements for TYPE (which is an
2197 ARRAY_TYPE) minus one. This counts only elements of the top array.
2199 Don't let any SAVE_EXPRs escape; if we are called as part of a cleanup
2200 action, they would get unsaved. */
2203 array_type_nelts (type
)
2206 tree index_type
, min
, max
;
2208 /* If they did it with unspecified bounds, then we should have already
2209 given an error about it before we got here. */
2210 if (! TYPE_DOMAIN (type
))
2211 return error_mark_node
;
2213 index_type
= TYPE_DOMAIN (type
);
2214 min
= TYPE_MIN_VALUE (index_type
);
2215 max
= TYPE_MAX_VALUE (index_type
);
2217 if (! TREE_CONSTANT (min
))
2220 if (TREE_CODE (min
) == SAVE_EXPR
&& SAVE_EXPR_RTL (min
))
2221 min
= build (RTL_EXPR
, TREE_TYPE (TYPE_MIN_VALUE (index_type
)), 0,
2222 SAVE_EXPR_RTL (min
));
2224 min
= TYPE_MIN_VALUE (index_type
);
2227 if (! TREE_CONSTANT (max
))
2230 if (TREE_CODE (max
) == SAVE_EXPR
&& SAVE_EXPR_RTL (max
))
2231 max
= build (RTL_EXPR
, TREE_TYPE (TYPE_MAX_VALUE (index_type
)), 0,
2232 SAVE_EXPR_RTL (max
));
2234 max
= TYPE_MAX_VALUE (index_type
);
2237 return (integer_zerop (min
)
2239 : fold (build (MINUS_EXPR
, TREE_TYPE (max
), max
, min
)));
2242 /* Return nonzero if arg is static -- a reference to an object in
2243 static storage. This is not the same as the C meaning of `static'. */
2249 switch (TREE_CODE (arg
))
2252 /* Nested functions aren't static, since taking their address
2253 involves a trampoline. */
2254 return (decl_function_context (arg
) == 0 || DECL_NO_STATIC_CHAIN (arg
))
2255 && ! DECL_NON_ADDR_CONST_P (arg
);
2258 return (TREE_STATIC (arg
) || DECL_EXTERNAL (arg
))
2259 && ! DECL_NON_ADDR_CONST_P (arg
);
2262 return TREE_STATIC (arg
);
2267 /* If we are referencing a bitfield, we can't evaluate an
2268 ADDR_EXPR at compile time and so it isn't a constant. */
2270 return (! DECL_BIT_FIELD (TREE_OPERAND (arg
, 1))
2271 && staticp (TREE_OPERAND (arg
, 0)));
2277 /* This case is technically correct, but results in setting
2278 TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
2281 return TREE_CONSTANT (TREE_OPERAND (arg
, 0));
2285 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg
))) == INTEGER_CST
2286 && TREE_CODE (TREE_OPERAND (arg
, 1)) == INTEGER_CST
)
2287 return staticp (TREE_OPERAND (arg
, 0));
2294 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2295 Do this to any expression which may be used in more than one place,
2296 but must be evaluated only once.
2298 Normally, expand_expr would reevaluate the expression each time.
2299 Calling save_expr produces something that is evaluated and recorded
2300 the first time expand_expr is called on it. Subsequent calls to
2301 expand_expr just reuse the recorded value.
2303 The call to expand_expr that generates code that actually computes
2304 the value is the first call *at compile time*. Subsequent calls
2305 *at compile time* generate code to use the saved value.
2306 This produces correct result provided that *at run time* control
2307 always flows through the insns made by the first expand_expr
2308 before reaching the other places where the save_expr was evaluated.
2309 You, the caller of save_expr, must make sure this is so.
2311 Constants, and certain read-only nodes, are returned with no
2312 SAVE_EXPR because that is safe. Expressions containing placeholders
2313 are not touched; see tree.def for an explanation of what these
2320 register tree t
= fold (expr
);
2322 /* We don't care about whether this can be used as an lvalue in this
2324 while (TREE_CODE (t
) == NON_LVALUE_EXPR
)
2325 t
= TREE_OPERAND (t
, 0);
2327 /* If the tree evaluates to a constant, then we don't want to hide that
2328 fact (i.e. this allows further folding, and direct checks for constants).
2329 However, a read-only object that has side effects cannot be bypassed.
2330 Since it is no problem to reevaluate literals, we just return the
2333 if (TREE_CONSTANT (t
) || (TREE_READONLY (t
) && ! TREE_SIDE_EFFECTS (t
))
2334 || TREE_CODE (t
) == SAVE_EXPR
|| TREE_CODE (t
) == ERROR_MARK
)
2337 /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2338 it means that the size or offset of some field of an object depends on
2339 the value within another field.
2341 Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2342 and some variable since it would then need to be both evaluated once and
2343 evaluated more than once. Front-ends must assure this case cannot
2344 happen by surrounding any such subexpressions in their own SAVE_EXPR
2345 and forcing evaluation at the proper time. */
2346 if (contains_placeholder_p (t
))
2349 t
= build (SAVE_EXPR
, TREE_TYPE (expr
), t
, current_function_decl
, NULL_TREE
);
2351 /* This expression might be placed ahead of a jump to ensure that the
2352 value was computed on both sides of the jump. So make sure it isn't
2353 eliminated as dead. */
2354 TREE_SIDE_EFFECTS (t
) = 1;
2358 /* Arrange for an expression to be expanded multiple independent
2359 times. This is useful for cleanup actions, as the backend can
2360 expand them multiple times in different places. */
2368 /* If this is already protected, no sense in protecting it again. */
2369 if (TREE_CODE (expr
) == UNSAVE_EXPR
)
2372 t
= build1 (UNSAVE_EXPR
, TREE_TYPE (expr
), expr
);
2373 TREE_SIDE_EFFECTS (t
) = TREE_SIDE_EFFECTS (expr
);
2377 /* Returns the index of the first non-tree operand for CODE, or the number
2378 of operands if all are trees. */
2382 enum tree_code code
;
2388 case GOTO_SUBROUTINE_EXPR
:
2393 case WITH_CLEANUP_EXPR
:
2394 /* Should be defined to be 2. */
2396 case METHOD_CALL_EXPR
:
2399 return tree_code_length
[(int) code
];
2403 /* Modify a tree in place so that all the evaluate only once things
2404 are cleared out. Return the EXPR given.
2406 LANG_UNSAVE_EXPR_NOW, if set, is a pointer to a function to handle
2407 language specific nodes.
2411 unsave_expr_now (expr
)
2414 enum tree_code code
;
2418 if (expr
== NULL_TREE
)
2421 code
= TREE_CODE (expr
);
2422 first_rtl
= first_rtl_op (code
);
2426 SAVE_EXPR_RTL (expr
) = 0;
2430 TREE_OPERAND (expr
, 1) = TREE_OPERAND (expr
, 3);
2431 TREE_OPERAND (expr
, 3) = NULL_TREE
;
2435 /* I don't yet know how to emit a sequence multiple times. */
2436 if (RTL_EXPR_SEQUENCE (expr
) != 0)
2441 CALL_EXPR_RTL (expr
) = 0;
2442 if (TREE_OPERAND (expr
, 1)
2443 && TREE_CODE (TREE_OPERAND (expr
, 1)) == TREE_LIST
)
2445 tree exp
= TREE_OPERAND (expr
, 1);
2448 unsave_expr_now (TREE_VALUE (exp
));
2449 exp
= TREE_CHAIN (exp
);
2455 if (lang_unsave_expr_now
)
2456 (*lang_unsave_expr_now
) (expr
);
2460 switch (TREE_CODE_CLASS (code
))
2462 case 'c': /* a constant */
2463 case 't': /* a type node */
2464 case 'x': /* something random, like an identifier or an ERROR_MARK. */
2465 case 'd': /* A decl node */
2466 case 'b': /* A block node */
2469 case 'e': /* an expression */
2470 case 'r': /* a reference */
2471 case 's': /* an expression with side effects */
2472 case '<': /* a comparison expression */
2473 case '2': /* a binary arithmetic expression */
2474 case '1': /* a unary arithmetic expression */
2475 for (i
= first_rtl
- 1; i
>= 0; i
--)
2476 unsave_expr_now (TREE_OPERAND (expr
, i
));
2484 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2485 or offset that depends on a field within a record. */
2488 contains_placeholder_p (exp
)
2491 register enum tree_code code
= TREE_CODE (exp
);
2494 /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
2495 in it since it is supplying a value for it. */
2496 if (code
== WITH_RECORD_EXPR
)
2498 else if (code
== PLACEHOLDER_EXPR
)
2501 switch (TREE_CODE_CLASS (code
))
2504 /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2505 position computations since they will be converted into a
2506 WITH_RECORD_EXPR involving the reference, which will assume
2507 here will be valid. */
2508 return contains_placeholder_p (TREE_OPERAND (exp
, 0));
2511 if (code
== TREE_LIST
)
2512 return (contains_placeholder_p (TREE_VALUE (exp
))
2513 || (TREE_CHAIN (exp
) != 0
2514 && contains_placeholder_p (TREE_CHAIN (exp
))));
2523 /* Ignoring the first operand isn't quite right, but works best. */
2524 return contains_placeholder_p (TREE_OPERAND (exp
, 1));
2531 return (contains_placeholder_p (TREE_OPERAND (exp
, 0))
2532 || contains_placeholder_p (TREE_OPERAND (exp
, 1))
2533 || contains_placeholder_p (TREE_OPERAND (exp
, 2)));
2536 /* If we already know this doesn't have a placeholder, don't
2538 if (SAVE_EXPR_NOPLACEHOLDER (exp
) || SAVE_EXPR_RTL (exp
) != 0)
2541 SAVE_EXPR_NOPLACEHOLDER (exp
) = 1;
2542 result
= contains_placeholder_p (TREE_OPERAND (exp
, 0));
2544 SAVE_EXPR_NOPLACEHOLDER (exp
) = 0;
2549 return (TREE_OPERAND (exp
, 1) != 0
2550 && contains_placeholder_p (TREE_OPERAND (exp
, 1)));
2556 switch (tree_code_length
[(int) code
])
2559 return contains_placeholder_p (TREE_OPERAND (exp
, 0));
2561 return (contains_placeholder_p (TREE_OPERAND (exp
, 0))
2562 || contains_placeholder_p (TREE_OPERAND (exp
, 1)));
2573 /* Return 1 if EXP contains any expressions that produce cleanups for an
2574 outer scope to deal with. Used by fold. */
2582 if (! TREE_SIDE_EFFECTS (exp
))
2585 switch (TREE_CODE (exp
))
2588 case GOTO_SUBROUTINE_EXPR
:
2589 case WITH_CLEANUP_EXPR
:
2592 case CLEANUP_POINT_EXPR
:
2596 for (exp
= TREE_OPERAND (exp
, 1); exp
; exp
= TREE_CHAIN (exp
))
2598 cmp
= has_cleanups (TREE_VALUE (exp
));
2608 /* This general rule works for most tree codes. All exceptions should be
2609 handled above. If this is a language-specific tree code, we can't
2610 trust what might be in the operand, so say we don't know
2612 if ((int) TREE_CODE (exp
) >= (int) LAST_AND_UNUSED_TREE_CODE
)
2615 nops
= first_rtl_op (TREE_CODE (exp
));
2616 for (i
= 0; i
< nops
; i
++)
2617 if (TREE_OPERAND (exp
, i
) != 0)
2619 int type
= TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, i
)));
2620 if (type
== 'e' || type
== '<' || type
== '1' || type
== '2'
2621 || type
== 'r' || type
== 's')
2623 cmp
= has_cleanups (TREE_OPERAND (exp
, i
));
2632 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2633 return a tree with all occurrences of references to F in a
2634 PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
2635 contains only arithmetic expressions or a CALL_EXPR with a
2636 PLACEHOLDER_EXPR occurring only in its arglist. */
2639 substitute_in_expr (exp
, f
, r
)
2644 enum tree_code code
= TREE_CODE (exp
);
2649 switch (TREE_CODE_CLASS (code
))
2656 if (code
== PLACEHOLDER_EXPR
)
2658 else if (code
== TREE_LIST
)
2660 op0
= (TREE_CHAIN (exp
) == 0
2661 ? 0 : substitute_in_expr (TREE_CHAIN (exp
), f
, r
));
2662 op1
= substitute_in_expr (TREE_VALUE (exp
), f
, r
);
2663 if (op0
== TREE_CHAIN (exp
) && op1
== TREE_VALUE (exp
))
2666 return tree_cons (TREE_PURPOSE (exp
), op1
, op0
);
2675 switch (tree_code_length
[(int) code
])
2678 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2679 if (op0
== TREE_OPERAND (exp
, 0))
2682 new = fold (build1 (code
, TREE_TYPE (exp
), op0
));
2686 /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
2687 could, but we don't support it. */
2688 if (code
== RTL_EXPR
)
2690 else if (code
== CONSTRUCTOR
)
2693 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2694 op1
= substitute_in_expr (TREE_OPERAND (exp
, 1), f
, r
);
2695 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1))
2698 new = fold (build (code
, TREE_TYPE (exp
), op0
, op1
));
2702 /* It cannot be that anything inside a SAVE_EXPR contains a
2703 PLACEHOLDER_EXPR. */
2704 if (code
== SAVE_EXPR
)
2707 else if (code
== CALL_EXPR
)
2709 op1
= substitute_in_expr (TREE_OPERAND (exp
, 1), f
, r
);
2710 if (op1
== TREE_OPERAND (exp
, 1))
2713 return build (code
, TREE_TYPE (exp
),
2714 TREE_OPERAND (exp
, 0), op1
, NULL_TREE
);
2717 else if (code
!= COND_EXPR
)
2720 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2721 op1
= substitute_in_expr (TREE_OPERAND (exp
, 1), f
, r
);
2722 op2
= substitute_in_expr (TREE_OPERAND (exp
, 2), f
, r
);
2723 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
2724 && op2
== TREE_OPERAND (exp
, 2))
2727 new = fold (build (code
, TREE_TYPE (exp
), op0
, op1
, op2
));
2740 /* If this expression is getting a value from a PLACEHOLDER_EXPR
2741 and it is the right field, replace it with R. */
2742 for (inner
= TREE_OPERAND (exp
, 0);
2743 TREE_CODE_CLASS (TREE_CODE (inner
)) == 'r';
2744 inner
= TREE_OPERAND (inner
, 0))
2746 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
2747 && TREE_OPERAND (exp
, 1) == f
)
2750 /* If this expression hasn't been completed let, leave it
2752 if (TREE_CODE (inner
) == PLACEHOLDER_EXPR
2753 && TREE_TYPE (inner
) == 0)
2756 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2757 if (op0
== TREE_OPERAND (exp
, 0))
2760 new = fold (build (code
, TREE_TYPE (exp
), op0
,
2761 TREE_OPERAND (exp
, 1)));
2765 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2766 op1
= substitute_in_expr (TREE_OPERAND (exp
, 1), f
, r
);
2767 op2
= substitute_in_expr (TREE_OPERAND (exp
, 2), f
, r
);
2768 if (op0
== TREE_OPERAND (exp
, 0) && op1
== TREE_OPERAND (exp
, 1)
2769 && op2
== TREE_OPERAND (exp
, 2))
2772 new = fold (build (code
, TREE_TYPE (exp
), op0
, op1
, op2
));
2777 op0
= substitute_in_expr (TREE_OPERAND (exp
, 0), f
, r
);
2778 if (op0
== TREE_OPERAND (exp
, 0))
2781 new = fold (build1 (code
, TREE_TYPE (exp
), op0
));
2793 TREE_READONLY (new) = TREE_READONLY (exp
);
2797 /* Stabilize a reference so that we can use it any number of times
2798 without causing its operands to be evaluated more than once.
2799 Returns the stabilized reference. This works by means of save_expr,
2800 so see the caveats in the comments about save_expr.
2802 Also allows conversion expressions whose operands are references.
2803 Any other kind of expression is returned unchanged. */
2806 stabilize_reference (ref
)
2809 register tree result
;
2810 register enum tree_code code
= TREE_CODE (ref
);
2817 /* No action is needed in this case. */
2823 case FIX_TRUNC_EXPR
:
2824 case FIX_FLOOR_EXPR
:
2825 case FIX_ROUND_EXPR
:
2827 result
= build_nt (code
, stabilize_reference (TREE_OPERAND (ref
, 0)));
2831 result
= build_nt (INDIRECT_REF
,
2832 stabilize_reference_1 (TREE_OPERAND (ref
, 0)));
2836 result
= build_nt (COMPONENT_REF
,
2837 stabilize_reference (TREE_OPERAND (ref
, 0)),
2838 TREE_OPERAND (ref
, 1));
2842 result
= build_nt (BIT_FIELD_REF
,
2843 stabilize_reference (TREE_OPERAND (ref
, 0)),
2844 stabilize_reference_1 (TREE_OPERAND (ref
, 1)),
2845 stabilize_reference_1 (TREE_OPERAND (ref
, 2)));
2849 result
= build_nt (ARRAY_REF
,
2850 stabilize_reference (TREE_OPERAND (ref
, 0)),
2851 stabilize_reference_1 (TREE_OPERAND (ref
, 1)));
2855 /* We cannot wrap the first expression in a SAVE_EXPR, as then
2856 it wouldn't be ignored. This matters when dealing with
2858 return stabilize_reference_1 (ref
);
2861 result
= build1 (INDIRECT_REF
, TREE_TYPE (ref
),
2862 save_expr (build1 (ADDR_EXPR
,
2863 build_pointer_type (TREE_TYPE (ref
)),
2868 /* If arg isn't a kind of lvalue we recognize, make no change.
2869 Caller should recognize the error for an invalid lvalue. */
2874 return error_mark_node
;
2877 TREE_TYPE (result
) = TREE_TYPE (ref
);
2878 TREE_READONLY (result
) = TREE_READONLY (ref
);
2879 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (ref
);
2880 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (ref
);
2881 TREE_RAISES (result
) = TREE_RAISES (ref
);
2886 /* Subroutine of stabilize_reference; this is called for subtrees of
2887 references. Any expression with side-effects must be put in a SAVE_EXPR
2888 to ensure that it is only evaluated once.
2890 We don't put SAVE_EXPR nodes around everything, because assigning very
2891 simple expressions to temporaries causes us to miss good opportunities
2892 for optimizations. Among other things, the opportunity to fold in the
2893 addition of a constant into an addressing mode often gets lost, e.g.
2894 "y[i+1] += x;". In general, we take the approach that we should not make
2895 an assignment unless we are forced into it - i.e., that any non-side effect
2896 operator should be allowed, and that cse should take care of coalescing
2897 multiple utterances of the same expression should that prove fruitful. */
2900 stabilize_reference_1 (e
)
2903 register tree result
;
2904 register enum tree_code code
= TREE_CODE (e
);
2906 /* We cannot ignore const expressions because it might be a reference
2907 to a const array but whose index contains side-effects. But we can
2908 ignore things that are actual constant or that already have been
2909 handled by this function. */
2911 if (TREE_CONSTANT (e
) || code
== SAVE_EXPR
)
2914 switch (TREE_CODE_CLASS (code
))
2924 /* If the expression has side-effects, then encase it in a SAVE_EXPR
2925 so that it will only be evaluated once. */
2926 /* The reference (r) and comparison (<) classes could be handled as
2927 below, but it is generally faster to only evaluate them once. */
2928 if (TREE_SIDE_EFFECTS (e
))
2929 return save_expr (e
);
2933 /* Constants need no processing. In fact, we should never reach
2938 /* Division is slow and tends to be compiled with jumps,
2939 especially the division by powers of 2 that is often
2940 found inside of an array reference. So do it just once. */
2941 if (code
== TRUNC_DIV_EXPR
|| code
== TRUNC_MOD_EXPR
2942 || code
== FLOOR_DIV_EXPR
|| code
== FLOOR_MOD_EXPR
2943 || code
== CEIL_DIV_EXPR
|| code
== CEIL_MOD_EXPR
2944 || code
== ROUND_DIV_EXPR
|| code
== ROUND_MOD_EXPR
)
2945 return save_expr (e
);
2946 /* Recursively stabilize each operand. */
2947 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)),
2948 stabilize_reference_1 (TREE_OPERAND (e
, 1)));
2952 /* Recursively stabilize each operand. */
2953 result
= build_nt (code
, stabilize_reference_1 (TREE_OPERAND (e
, 0)));
2960 TREE_TYPE (result
) = TREE_TYPE (e
);
2961 TREE_READONLY (result
) = TREE_READONLY (e
);
2962 TREE_SIDE_EFFECTS (result
) = TREE_SIDE_EFFECTS (e
);
2963 TREE_THIS_VOLATILE (result
) = TREE_THIS_VOLATILE (e
);
2964 TREE_RAISES (result
) = TREE_RAISES (e
);
2969 /* Low-level constructors for expressions. */
2971 /* Build an expression of code CODE, data type TYPE,
2972 and operands as specified by the arguments ARG1 and following arguments.
2973 Expressions and reference nodes can be created this way.
2974 Constants, decls, types and misc nodes cannot be. */
2977 build
VPROTO((enum tree_code code
, tree tt
, ...))
2979 #ifndef ANSI_PROTOTYPES
2980 enum tree_code code
;
2985 register int length
;
2990 #ifndef ANSI_PROTOTYPES
2991 code
= va_arg (p
, enum tree_code
);
2992 tt
= va_arg (p
, tree
);
2995 t
= make_node (code
);
2996 length
= tree_code_length
[(int) code
];
3001 /* This is equivalent to the loop below, but faster. */
3002 register tree arg0
= va_arg (p
, tree
);
3003 register tree arg1
= va_arg (p
, tree
);
3004 TREE_OPERAND (t
, 0) = arg0
;
3005 TREE_OPERAND (t
, 1) = arg1
;
3006 if ((arg0
&& TREE_SIDE_EFFECTS (arg0
))
3007 || (arg1
&& TREE_SIDE_EFFECTS (arg1
)))
3008 TREE_SIDE_EFFECTS (t
) = 1;
3010 = (arg0
&& TREE_RAISES (arg0
)) || (arg1
&& TREE_RAISES (arg1
));
3012 else if (length
== 1)
3014 register tree arg0
= va_arg (p
, tree
);
3016 /* Call build1 for this! */
3017 if (TREE_CODE_CLASS (code
) != 's')
3019 TREE_OPERAND (t
, 0) = arg0
;
3020 if (arg0
&& TREE_SIDE_EFFECTS (arg0
))
3021 TREE_SIDE_EFFECTS (t
) = 1;
3022 TREE_RAISES (t
) = (arg0
&& TREE_RAISES (arg0
));
3026 for (i
= 0; i
< length
; i
++)
3028 register tree operand
= va_arg (p
, tree
);
3029 TREE_OPERAND (t
, i
) = operand
;
3032 if (TREE_SIDE_EFFECTS (operand
))
3033 TREE_SIDE_EFFECTS (t
) = 1;
3034 if (TREE_RAISES (operand
))
3035 TREE_RAISES (t
) = 1;
3043 /* Same as above, but only builds for unary operators.
3044 Saves lions share of calls to `build'; cuts down use
3045 of varargs, which is expensive for RISC machines. */
3048 build1 (code
, type
, node
)
3049 enum tree_code code
;
3053 register struct obstack
*obstack
= expression_obstack
;
3054 register int length
;
3055 #ifdef GATHER_STATISTICS
3056 register tree_node_kind kind
;
3060 #ifdef GATHER_STATISTICS
3061 if (TREE_CODE_CLASS (code
) == 'r')
3067 length
= sizeof (struct tree_exp
);
3070 t
= ggc_alloc_tree (length
);
3072 t
= (tree
) obstack_alloc (obstack
, length
);
3073 bzero ((PTR
) t
, length
);
3075 #ifdef GATHER_STATISTICS
3076 tree_node_counts
[(int)kind
]++;
3077 tree_node_sizes
[(int)kind
] += length
;
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
, ...))
3106 #ifndef ANSI_PROTOTYPES
3107 enum tree_code code
;
3111 register int length
;
3116 #ifndef ANSI_PROTOTYPES
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
, ...))
3136 #ifndef ANSI_PROTOTYPES
3137 enum tree_code code
;
3139 register struct obstack
*ambient_obstack
= expression_obstack
;
3142 register int length
;
3147 #ifndef ANSI_PROTOTYPES
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 const 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
);
3289 TYPE_POINTER_TO (ntype
) = 0;
3290 TYPE_REFERENCE_TO (ntype
) = 0;
3291 TYPE_ATTRIBUTES (ntype
) = attribute
;
3293 /* Create a new main variant of TYPE. */
3294 TYPE_MAIN_VARIANT (ntype
) = ntype
;
3295 TYPE_NEXT_VARIANT (ntype
) = 0;
3296 set_type_quals (ntype
, TYPE_UNQUALIFIED
);
3298 hashcode
= TYPE_HASH (TREE_CODE (ntype
))
3299 + TYPE_HASH (TREE_TYPE (ntype
))
3300 + attribute_hash_list (attribute
);
3302 switch (TREE_CODE (ntype
))
3305 hashcode
+= TYPE_HASH (TYPE_ARG_TYPES (ntype
));
3308 hashcode
+= TYPE_HASH (TYPE_DOMAIN (ntype
));
3311 hashcode
+= TYPE_HASH (TYPE_MAX_VALUE (ntype
));
3314 hashcode
+= TYPE_HASH (TYPE_PRECISION (ntype
));
3320 ntype
= type_hash_canon (hashcode
, ntype
);
3321 ttype
= build_qualified_type (ntype
, TYPE_QUALS (ttype
));
3323 /* We must restore the current obstack after the type_hash_canon call,
3324 because type_hash_canon calls type_hash_add for permanent types, and
3325 then type_hash_add calls oballoc expecting to get something permanent
3327 current_obstack
= ambient_obstack
;
3333 /* Return a 1 if ATTR_NAME and ATTR_ARGS is valid for either declaration DECL
3334 or type TYPE and 0 otherwise. Validity is determined the configuration
3335 macros VALID_MACHINE_DECL_ATTRIBUTE and VALID_MACHINE_TYPE_ATTRIBUTE. */
3338 valid_machine_attribute (attr_name
, attr_args
, decl
, type
)
3340 tree attr_args ATTRIBUTE_UNUSED
;
3341 tree decl ATTRIBUTE_UNUSED
;
3342 tree type ATTRIBUTE_UNUSED
;
3345 #ifdef VALID_MACHINE_DECL_ATTRIBUTE
3346 tree decl_attr_list
= decl
!= 0 ? DECL_MACHINE_ATTRIBUTES (decl
) : 0;
3348 #ifdef VALID_MACHINE_TYPE_ATTRIBUTE
3349 tree type_attr_list
= TYPE_ATTRIBUTES (type
);
3352 if (TREE_CODE (attr_name
) != IDENTIFIER_NODE
)
3355 #ifdef VALID_MACHINE_DECL_ATTRIBUTE
3357 && VALID_MACHINE_DECL_ATTRIBUTE (decl
, decl_attr_list
, attr_name
, attr_args
))
3359 tree attr
= lookup_attribute (IDENTIFIER_POINTER (attr_name
),
3362 if (attr
!= NULL_TREE
)
3364 /* Override existing arguments. Declarations are unique so we can
3365 modify this in place. */
3366 TREE_VALUE (attr
) = attr_args
;
3370 decl_attr_list
= tree_cons (attr_name
, attr_args
, decl_attr_list
);
3371 decl
= build_decl_attribute_variant (decl
, decl_attr_list
);
3378 #ifdef VALID_MACHINE_TYPE_ATTRIBUTE
3380 /* Don't apply the attribute to both the decl and the type. */;
3381 else if (VALID_MACHINE_TYPE_ATTRIBUTE (type
, type_attr_list
, attr_name
,
3384 tree attr
= lookup_attribute (IDENTIFIER_POINTER (attr_name
),
3387 if (attr
!= NULL_TREE
)
3389 /* Override existing arguments.
3390 ??? This currently works since attribute arguments are not
3391 included in `attribute_hash_list'. Something more complicated
3392 may be needed in the future. */
3393 TREE_VALUE (attr
) = attr_args
;
3397 /* If this is part of a declaration, create a type variant,
3398 otherwise, this is part of a type definition, so add it
3399 to the base type. */
3400 type_attr_list
= tree_cons (attr_name
, attr_args
, type_attr_list
);
3402 type
= build_type_attribute_variant (type
, type_attr_list
);
3404 TYPE_ATTRIBUTES (type
) = type_attr_list
;
3407 TREE_TYPE (decl
) = type
;
3411 /* Handle putting a type attribute on pointer-to-function-type by putting
3412 the attribute on the function type. */
3413 else if (POINTER_TYPE_P (type
)
3414 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
3415 && VALID_MACHINE_TYPE_ATTRIBUTE (TREE_TYPE (type
), type_attr_list
,
3416 attr_name
, attr_args
))
3418 tree inner_type
= TREE_TYPE (type
);
3419 tree inner_attr_list
= TYPE_ATTRIBUTES (inner_type
);
3420 tree attr
= lookup_attribute (IDENTIFIER_POINTER (attr_name
),
3423 if (attr
!= NULL_TREE
)
3424 TREE_VALUE (attr
) = attr_args
;
3427 inner_attr_list
= tree_cons (attr_name
, attr_args
, inner_attr_list
);
3428 inner_type
= build_type_attribute_variant (inner_type
,
3433 TREE_TYPE (decl
) = build_pointer_type (inner_type
);
3436 /* Clear TYPE_POINTER_TO for the old inner type, since
3437 `type' won't be pointing to it anymore. */
3438 TYPE_POINTER_TO (TREE_TYPE (type
)) = NULL_TREE
;
3439 TREE_TYPE (type
) = inner_type
;
3449 /* Return non-zero if IDENT is a valid name for attribute ATTR,
3452 We try both `text' and `__text__', ATTR may be either one. */
3453 /* ??? It might be a reasonable simplification to require ATTR to be only
3454 `text'. One might then also require attribute lists to be stored in
3455 their canonicalized form. */
3458 is_attribute_p (attr
, ident
)
3462 int ident_len
, attr_len
;
3465 if (TREE_CODE (ident
) != IDENTIFIER_NODE
)
3468 if (strcmp (attr
, IDENTIFIER_POINTER (ident
)) == 0)
3471 p
= IDENTIFIER_POINTER (ident
);
3472 ident_len
= strlen (p
);
3473 attr_len
= strlen (attr
);
3475 /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
3479 || attr
[attr_len
- 2] != '_'
3480 || attr
[attr_len
- 1] != '_')
3482 if (ident_len
== attr_len
- 4
3483 && strncmp (attr
+ 2, p
, attr_len
- 4) == 0)
3488 if (ident_len
== attr_len
+ 4
3489 && p
[0] == '_' && p
[1] == '_'
3490 && p
[ident_len
- 2] == '_' && p
[ident_len
- 1] == '_'
3491 && strncmp (attr
, p
+ 2, attr_len
) == 0)
3498 /* Given an attribute name and a list of attributes, return a pointer to the
3499 attribute's list element if the attribute is part of the list, or NULL_TREE
3503 lookup_attribute (attr_name
, list
)
3504 const char *attr_name
;
3509 for (l
= list
; l
; l
= TREE_CHAIN (l
))
3511 if (TREE_CODE (TREE_PURPOSE (l
)) != IDENTIFIER_NODE
)
3513 if (is_attribute_p (attr_name
, TREE_PURPOSE (l
)))
3520 /* Return an attribute list that is the union of a1 and a2. */
3523 merge_attributes (a1
, a2
)
3524 register tree a1
, a2
;
3528 /* Either one unset? Take the set one. */
3530 if (! (attributes
= a1
))
3533 /* One that completely contains the other? Take it. */
3535 else if (a2
&& ! attribute_list_contained (a1
, a2
))
3537 if (attribute_list_contained (a2
, a1
))
3541 /* Pick the longest list, and hang on the other list. */
3542 /* ??? For the moment we punt on the issue of attrs with args. */
3544 if (list_length (a1
) < list_length (a2
))
3545 attributes
= a2
, a2
= a1
;
3547 for (; a2
; a2
= TREE_CHAIN (a2
))
3548 if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2
)),
3549 attributes
) == NULL_TREE
)
3551 a1
= copy_node (a2
);
3552 TREE_CHAIN (a1
) = attributes
;
3560 /* Given types T1 and T2, merge their attributes and return
3564 merge_machine_type_attributes (t1
, t2
)
3567 #ifdef MERGE_MACHINE_TYPE_ATTRIBUTES
3568 return MERGE_MACHINE_TYPE_ATTRIBUTES (t1
, t2
);
3570 return merge_attributes (TYPE_ATTRIBUTES (t1
),
3571 TYPE_ATTRIBUTES (t2
));
3575 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
3579 merge_machine_decl_attributes (olddecl
, newdecl
)
3580 tree olddecl
, newdecl
;
3582 #ifdef MERGE_MACHINE_DECL_ATTRIBUTES
3583 return MERGE_MACHINE_DECL_ATTRIBUTES (olddecl
, newdecl
);
3585 return merge_attributes (DECL_MACHINE_ATTRIBUTES (olddecl
),
3586 DECL_MACHINE_ATTRIBUTES (newdecl
));
3590 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
3591 of the various TYPE_QUAL values. */
3594 set_type_quals (type
, type_quals
)
3598 TYPE_READONLY (type
) = (type_quals
& TYPE_QUAL_CONST
) != 0;
3599 TYPE_VOLATILE (type
) = (type_quals
& TYPE_QUAL_VOLATILE
) != 0;
3600 TYPE_RESTRICT (type
) = (type_quals
& TYPE_QUAL_RESTRICT
) != 0;
3603 /* Given a type node TYPE and a TYPE_QUALIFIER_SET, return a type for
3604 the same kind of data as TYPE describes. Variants point to the
3605 "main variant" (which has no qualifiers set) via TYPE_MAIN_VARIANT,
3606 and it points to a chain of other variants so that duplicate
3607 variants are never made. Only main variants should ever appear as
3608 types of expressions. */
3611 build_qualified_type (type
, type_quals
)
3617 /* Search the chain of variants to see if there is already one there just
3618 like the one we need to have. If so, use that existing one. We must
3619 preserve the TYPE_NAME, since there is code that depends on this. */
3621 for (t
= TYPE_MAIN_VARIANT (type
); t
; t
= TYPE_NEXT_VARIANT (t
))
3622 if (TYPE_QUALS (t
) == type_quals
&& TYPE_NAME (t
) == TYPE_NAME (type
))
3625 /* We need a new one. */
3626 t
= build_type_copy (type
);
3627 set_type_quals (t
, type_quals
);
3631 /* Create a new variant of TYPE, equivalent but distinct.
3632 This is so the caller can modify it. */
3635 build_type_copy (type
)
3638 register tree t
, m
= TYPE_MAIN_VARIANT (type
);
3639 register struct obstack
*ambient_obstack
= current_obstack
;
3641 current_obstack
= TYPE_OBSTACK (type
);
3642 t
= copy_node (type
);
3643 current_obstack
= ambient_obstack
;
3645 TYPE_POINTER_TO (t
) = 0;
3646 TYPE_REFERENCE_TO (t
) = 0;
3648 /* Add this type to the chain of variants of TYPE. */
3649 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
3650 TYPE_NEXT_VARIANT (m
) = t
;
3655 /* Hashing of types so that we don't make duplicates.
3656 The entry point is `type_hash_canon'. */
3658 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
3659 with types in the TREE_VALUE slots), by adding the hash codes
3660 of the individual types. */
3663 type_hash_list (list
)
3666 register int hashcode
;
3668 for (hashcode
= 0, tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3669 hashcode
+= TYPE_HASH (TREE_VALUE (tail
));
3673 /* Look in the type hash table for a type isomorphic to TYPE.
3674 If one is found, return it. Otherwise return 0. */
3677 type_hash_lookup (hashcode
, type
)
3681 register struct type_hash
*h
;
3682 for (h
= type_hash_table
[hashcode
% TYPE_HASH_SIZE
]; h
; h
= h
->next
)
3683 if (h
->hashcode
== hashcode
3684 && TREE_CODE (h
->type
) == TREE_CODE (type
)
3685 && TREE_TYPE (h
->type
) == TREE_TYPE (type
)
3686 && attribute_list_equal (TYPE_ATTRIBUTES (h
->type
),
3687 TYPE_ATTRIBUTES (type
))
3688 && (TYPE_MAX_VALUE (h
->type
) == TYPE_MAX_VALUE (type
)
3689 || tree_int_cst_equal (TYPE_MAX_VALUE (h
->type
),
3690 TYPE_MAX_VALUE (type
)))
3691 && (TYPE_MIN_VALUE (h
->type
) == TYPE_MIN_VALUE (type
)
3692 || tree_int_cst_equal (TYPE_MIN_VALUE (h
->type
),
3693 TYPE_MIN_VALUE (type
)))
3694 /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE. */
3695 && (TYPE_DOMAIN (h
->type
) == TYPE_DOMAIN (type
)
3696 || (TYPE_DOMAIN (h
->type
)
3697 && TREE_CODE (TYPE_DOMAIN (h
->type
)) == TREE_LIST
3698 && TYPE_DOMAIN (type
)
3699 && TREE_CODE (TYPE_DOMAIN (type
)) == TREE_LIST
3700 && type_list_equal (TYPE_DOMAIN (h
->type
),
3701 TYPE_DOMAIN (type
)))))
3706 /* Add an entry to the type-hash-table
3707 for a type TYPE whose hash code is HASHCODE. */
3710 type_hash_add (hashcode
, type
)
3714 register struct type_hash
*h
;
3716 h
= (struct type_hash
*) permalloc (sizeof (struct type_hash
));
3717 h
->hashcode
= hashcode
;
3719 h
->next
= type_hash_table
[hashcode
% TYPE_HASH_SIZE
];
3720 type_hash_table
[hashcode
% TYPE_HASH_SIZE
] = h
;
3723 /* Given TYPE, and HASHCODE its hash code, return the canonical
3724 object for an identical type if one already exists.
3725 Otherwise, return TYPE, and record it as the canonical object
3726 if it is a permanent object.
3728 To use this function, first create a type of the sort you want.
3729 Then compute its hash code from the fields of the type that
3730 make it different from other similar types.
3731 Then call this function and use the value.
3732 This function frees the type you pass in if it is a duplicate. */
3734 /* Set to 1 to debug without canonicalization. Never set by program. */
3735 int debug_no_type_hash
= 0;
3738 type_hash_canon (hashcode
, type
)
3744 if (debug_no_type_hash
)
3747 t1
= type_hash_lookup (hashcode
, type
);
3751 obstack_free (TYPE_OBSTACK (type
), type
);
3752 #ifdef GATHER_STATISTICS
3753 tree_node_counts
[(int)t_kind
]--;
3754 tree_node_sizes
[(int)t_kind
] -= sizeof (struct tree_type
);
3759 /* If this is a permanent type, record it for later reuse. */
3760 if (TREE_PERMANENT (type
))
3761 type_hash_add (hashcode
, type
);
3766 /* Mark ARG (which is really a struct type_hash **) for GC. */
3769 mark_type_hash (arg
)
3772 struct type_hash
*t
= *(struct type_hash
**) arg
;
3776 ggc_mark_tree (t
->type
);
3781 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
3782 with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
3783 by adding the hash codes of the individual attributes. */
3786 attribute_hash_list (list
)
3789 register int hashcode
;
3791 for (hashcode
= 0, tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3792 /* ??? Do we want to add in TREE_VALUE too? */
3793 hashcode
+= TYPE_HASH (TREE_PURPOSE (tail
));
3797 /* Given two lists of attributes, return true if list l2 is
3798 equivalent to l1. */
3801 attribute_list_equal (l1
, l2
)
3804 return attribute_list_contained (l1
, l2
)
3805 && attribute_list_contained (l2
, l1
);
3808 /* Given two lists of attributes, return true if list L2 is
3809 completely contained within L1. */
3810 /* ??? This would be faster if attribute names were stored in a canonicalized
3811 form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
3812 must be used to show these elements are equivalent (which they are). */
3813 /* ??? It's not clear that attributes with arguments will always be handled
3817 attribute_list_contained (l1
, l2
)
3820 register tree t1
, t2
;
3822 /* First check the obvious, maybe the lists are identical. */
3826 /* Maybe the lists are similar. */
3827 for (t1
= l1
, t2
= l2
;
3829 && TREE_PURPOSE (t1
) == TREE_PURPOSE (t2
)
3830 && TREE_VALUE (t1
) == TREE_VALUE (t2
);
3831 t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
));
3833 /* Maybe the lists are equal. */
3834 if (t1
== 0 && t2
== 0)
3837 for (; t2
; t2
= TREE_CHAIN (t2
))
3840 = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2
)), l1
);
3842 if (attr
== NULL_TREE
)
3844 if (simple_cst_equal (TREE_VALUE (t2
), TREE_VALUE (attr
)) != 1)
3851 /* Given two lists of types
3852 (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
3853 return 1 if the lists contain the same types in the same order.
3854 Also, the TREE_PURPOSEs must match. */
3857 type_list_equal (l1
, l2
)
3860 register tree t1
, t2
;
3862 for (t1
= l1
, t2
= l2
; t1
&& t2
; t1
= TREE_CHAIN (t1
), t2
= TREE_CHAIN (t2
))
3863 if (TREE_VALUE (t1
) != TREE_VALUE (t2
)
3864 || (TREE_PURPOSE (t1
) != TREE_PURPOSE (t2
)
3865 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
))
3866 && (TREE_TYPE (TREE_PURPOSE (t1
))
3867 == TREE_TYPE (TREE_PURPOSE (t2
))))))
3873 /* Nonzero if integer constants T1 and T2
3874 represent the same constant value. */
3877 tree_int_cst_equal (t1
, t2
)
3882 if (t1
== 0 || t2
== 0)
3884 if (TREE_CODE (t1
) == INTEGER_CST
3885 && TREE_CODE (t2
) == INTEGER_CST
3886 && TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
3887 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
))
3892 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
3893 The precise way of comparison depends on their data type. */
3896 tree_int_cst_lt (t1
, t2
)
3902 if (!TREE_UNSIGNED (TREE_TYPE (t1
)))
3903 return INT_CST_LT (t1
, t2
);
3904 return INT_CST_LT_UNSIGNED (t1
, t2
);
3907 /* Return an indication of the sign of the integer constant T.
3908 The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3909 Note that -1 will never be returned it T's type is unsigned. */
3912 tree_int_cst_sgn (t
)
3915 if (TREE_INT_CST_LOW (t
) == 0 && TREE_INT_CST_HIGH (t
) == 0)
3917 else if (TREE_UNSIGNED (TREE_TYPE (t
)))
3919 else if (TREE_INT_CST_HIGH (t
) < 0)
3925 /* Compare two constructor-element-type constants. Return 1 if the lists
3926 are known to be equal; otherwise return 0. */
3929 simple_cst_list_equal (l1
, l2
)
3932 while (l1
!= NULL_TREE
&& l2
!= NULL_TREE
)
3934 if (simple_cst_equal (TREE_VALUE (l1
), TREE_VALUE (l2
)) != 1)
3937 l1
= TREE_CHAIN (l1
);
3938 l2
= TREE_CHAIN (l2
);
3944 /* Return truthvalue of whether T1 is the same tree structure as T2.
3945 Return 1 if they are the same.
3946 Return 0 if they are understandably different.
3947 Return -1 if either contains tree structure not understood by
3951 simple_cst_equal (t1
, t2
)
3954 register enum tree_code code1
, code2
;
3959 if (t1
== 0 || t2
== 0)
3962 code1
= TREE_CODE (t1
);
3963 code2
= TREE_CODE (t2
);
3965 if (code1
== NOP_EXPR
|| code1
== CONVERT_EXPR
|| code1
== NON_LVALUE_EXPR
)
3967 if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
3968 || code2
== NON_LVALUE_EXPR
)
3969 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
3971 return simple_cst_equal (TREE_OPERAND (t1
, 0), t2
);
3973 else if (code2
== NOP_EXPR
|| code2
== CONVERT_EXPR
3974 || code2
== NON_LVALUE_EXPR
)
3975 return simple_cst_equal (t1
, TREE_OPERAND (t2
, 0));
3983 return TREE_INT_CST_LOW (t1
) == TREE_INT_CST_LOW (t2
)
3984 && TREE_INT_CST_HIGH (t1
) == TREE_INT_CST_HIGH (t2
);
3987 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
3990 return TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
3991 && !bcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
3992 TREE_STRING_LENGTH (t1
));
3995 if (CONSTRUCTOR_ELTS (t1
) == CONSTRUCTOR_ELTS (t2
))
4001 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4004 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4007 return simple_cst_list_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
4010 /* Special case: if either target is an unallocated VAR_DECL,
4011 it means that it's going to be unified with whatever the
4012 TARGET_EXPR is really supposed to initialize, so treat it
4013 as being equivalent to anything. */
4014 if ((TREE_CODE (TREE_OPERAND (t1
, 0)) == VAR_DECL
4015 && DECL_NAME (TREE_OPERAND (t1
, 0)) == NULL_TREE
4016 && DECL_RTL (TREE_OPERAND (t1
, 0)) == 0)
4017 || (TREE_CODE (TREE_OPERAND (t2
, 0)) == VAR_DECL
4018 && DECL_NAME (TREE_OPERAND (t2
, 0)) == NULL_TREE
4019 && DECL_RTL (TREE_OPERAND (t2
, 0)) == 0))
4022 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4025 return simple_cst_equal (TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1));
4027 case WITH_CLEANUP_EXPR
:
4028 cmp
= simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4031 return simple_cst_equal (TREE_OPERAND (t1
, 2), TREE_OPERAND (t1
, 2));
4034 if (TREE_OPERAND (t1
, 1) == TREE_OPERAND (t2
, 1))
4035 return simple_cst_equal (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
4048 /* This general rule works for most tree codes. All exceptions should be
4049 handled above. If this is a language-specific tree code, we can't
4050 trust what might be in the operand, so say we don't know
4052 if ((int) code1
>= (int) LAST_AND_UNUSED_TREE_CODE
)
4055 switch (TREE_CODE_CLASS (code1
))
4065 for (i
=0; i
<tree_code_length
[(int) code1
]; ++i
)
4067 cmp
= simple_cst_equal (TREE_OPERAND (t1
, i
), TREE_OPERAND (t2
, i
));
4078 /* Constructors for pointer, array and function types.
4079 (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
4080 constructed by language-dependent code, not here.) */
4082 /* Construct, lay out and return the type of pointers to TO_TYPE.
4083 If such a type has already been constructed, reuse it. */
4086 build_pointer_type (to_type
)
4089 register tree t
= TYPE_POINTER_TO (to_type
);
4091 /* First, if we already have a type for pointers to TO_TYPE, use it. */
4096 /* We need a new one. Put this in the same obstack as TO_TYPE. */
4097 push_obstacks (TYPE_OBSTACK (to_type
), TYPE_OBSTACK (to_type
));
4098 t
= make_node (POINTER_TYPE
);
4101 TREE_TYPE (t
) = to_type
;
4103 /* Record this type as the pointer to TO_TYPE. */
4104 TYPE_POINTER_TO (to_type
) = t
;
4106 /* Lay out the type. This function has many callers that are concerned
4107 with expression-construction, and this simplifies them all.
4108 Also, it guarantees the TYPE_SIZE is in the same obstack as the type. */
4114 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
4115 MAXVAL should be the maximum value in the domain
4116 (one less than the length of the array).
4118 The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
4119 We don't enforce this limit, that is up to caller (e.g. language front end).
4120 The limit exists because the result is a signed type and we don't handle
4121 sizes that use more than one HOST_WIDE_INT. */
4124 build_index_type (maxval
)
4127 register tree itype
= make_node (INTEGER_TYPE
);
4129 TYPE_PRECISION (itype
) = TYPE_PRECISION (sizetype
);
4130 TYPE_MIN_VALUE (itype
) = size_zero_node
;
4132 push_obstacks (TYPE_OBSTACK (itype
), TYPE_OBSTACK (itype
));
4133 TYPE_MAX_VALUE (itype
) = convert (sizetype
, maxval
);
4136 TYPE_MODE (itype
) = TYPE_MODE (sizetype
);
4137 TYPE_SIZE (itype
) = TYPE_SIZE (sizetype
);
4138 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (sizetype
);
4139 TYPE_ALIGN (itype
) = TYPE_ALIGN (sizetype
);
4140 if (TREE_CODE (maxval
) == INTEGER_CST
)
4142 int maxint
= (int) TREE_INT_CST_LOW (maxval
);
4143 /* If the domain should be empty, make sure the maxval
4144 remains -1 and is not spoiled by truncation. */
4145 if (INT_CST_LT (maxval
, integer_zero_node
))
4147 TYPE_MAX_VALUE (itype
) = build_int_2 (-1, -1);
4148 TREE_TYPE (TYPE_MAX_VALUE (itype
)) = sizetype
;
4150 return type_hash_canon (maxint
< 0 ? ~maxint
: maxint
, itype
);
4156 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
4157 ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
4158 low bound LOWVAL and high bound HIGHVAL.
4159 if TYPE==NULL_TREE, sizetype is used. */
4162 build_range_type (type
, lowval
, highval
)
4163 tree type
, lowval
, highval
;
4165 register tree itype
= make_node (INTEGER_TYPE
);
4167 TREE_TYPE (itype
) = type
;
4168 if (type
== NULL_TREE
)
4171 push_obstacks (TYPE_OBSTACK (itype
), TYPE_OBSTACK (itype
));
4172 TYPE_MIN_VALUE (itype
) = convert (type
, lowval
);
4173 TYPE_MAX_VALUE (itype
) = highval
? convert (type
, highval
) : NULL
;
4176 TYPE_PRECISION (itype
) = TYPE_PRECISION (type
);
4177 TYPE_MODE (itype
) = TYPE_MODE (type
);
4178 TYPE_SIZE (itype
) = TYPE_SIZE (type
);
4179 TYPE_SIZE_UNIT (itype
) = TYPE_SIZE_UNIT (type
);
4180 TYPE_ALIGN (itype
) = TYPE_ALIGN (type
);
4181 if (TREE_CODE (lowval
) == INTEGER_CST
)
4183 HOST_WIDE_INT lowint
, highint
;
4186 lowint
= TREE_INT_CST_LOW (lowval
);
4187 if (highval
&& TREE_CODE (highval
) == INTEGER_CST
)
4188 highint
= TREE_INT_CST_LOW (highval
);
4190 highint
= (~(unsigned HOST_WIDE_INT
)0) >> 1;
4192 maxint
= (int) (highint
- lowint
);
4193 return type_hash_canon (maxint
< 0 ? ~maxint
: maxint
, itype
);
4199 /* Just like build_index_type, but takes lowval and highval instead
4200 of just highval (maxval). */
4203 build_index_2_type (lowval
,highval
)
4204 tree lowval
, highval
;
4206 return build_range_type (NULL_TREE
, lowval
, highval
);
4209 /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense).
4210 Needed because when index types are not hashed, equal index types
4211 built at different times appear distinct, even though structurally,
4215 index_type_equal (itype1
, itype2
)
4216 tree itype1
, itype2
;
4218 if (TREE_CODE (itype1
) != TREE_CODE (itype2
))
4220 if (TREE_CODE (itype1
) == INTEGER_TYPE
)
4222 if (TYPE_PRECISION (itype1
) != TYPE_PRECISION (itype2
)
4223 || TYPE_MODE (itype1
) != TYPE_MODE (itype2
)
4224 || simple_cst_equal (TYPE_SIZE (itype1
), TYPE_SIZE (itype2
)) != 1
4225 || TYPE_ALIGN (itype1
) != TYPE_ALIGN (itype2
))
4227 if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1
),
4228 TYPE_MIN_VALUE (itype2
))
4229 && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1
),
4230 TYPE_MAX_VALUE (itype2
)))
4237 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
4238 and number of elements specified by the range of values of INDEX_TYPE.
4239 If such a type has already been constructed, reuse it. */
4242 build_array_type (elt_type
, index_type
)
4243 tree elt_type
, index_type
;
4248 if (TREE_CODE (elt_type
) == FUNCTION_TYPE
)
4250 error ("arrays of functions are not meaningful");
4251 elt_type
= integer_type_node
;
4254 /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
4255 build_pointer_type (elt_type
);
4257 /* Allocate the array after the pointer type,
4258 in case we free it in type_hash_canon. */
4259 t
= make_node (ARRAY_TYPE
);
4260 TREE_TYPE (t
) = elt_type
;
4261 TYPE_DOMAIN (t
) = index_type
;
4263 if (index_type
== 0)
4268 hashcode
= TYPE_HASH (elt_type
) + TYPE_HASH (index_type
);
4269 t
= type_hash_canon (hashcode
, t
);
4271 if (TYPE_SIZE (t
) == 0)
4276 /* Return the TYPE of the elements comprising
4277 the innermost dimension of ARRAY. */
4280 get_inner_array_type (array
)
4283 tree type
= TREE_TYPE (array
);
4285 while (TREE_CODE (type
) == ARRAY_TYPE
)
4286 type
= TREE_TYPE (type
);
4291 /* Construct, lay out and return
4292 the type of functions returning type VALUE_TYPE
4293 given arguments of types ARG_TYPES.
4294 ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
4295 are data type nodes for the arguments of the function.
4296 If such a type has already been constructed, reuse it. */
4299 build_function_type (value_type
, arg_types
)
4300 tree value_type
, arg_types
;
4305 if (TREE_CODE (value_type
) == FUNCTION_TYPE
)
4307 error ("function return type cannot be function");
4308 value_type
= integer_type_node
;
4311 /* Make a node of the sort we want. */
4312 t
= make_node (FUNCTION_TYPE
);
4313 TREE_TYPE (t
) = value_type
;
4314 TYPE_ARG_TYPES (t
) = arg_types
;
4316 /* If we already have such a type, use the old one and free this one. */
4317 hashcode
= TYPE_HASH (value_type
) + type_hash_list (arg_types
);
4318 t
= type_hash_canon (hashcode
, t
);
4320 if (TYPE_SIZE (t
) == 0)
4325 /* Build the node for the type of references-to-TO_TYPE. */
4328 build_reference_type (to_type
)
4331 register tree t
= TYPE_REFERENCE_TO (to_type
);
4333 /* First, if we already have a type for pointers to TO_TYPE, use it. */
4338 /* We need a new one. Put this in the same obstack as TO_TYPE. */
4339 push_obstacks (TYPE_OBSTACK (to_type
), TYPE_OBSTACK (to_type
));
4340 t
= make_node (REFERENCE_TYPE
);
4343 TREE_TYPE (t
) = to_type
;
4345 /* Record this type as the pointer to TO_TYPE. */
4346 TYPE_REFERENCE_TO (to_type
) = t
;
4353 /* Construct, lay out and return the type of methods belonging to class
4354 BASETYPE and whose arguments and values are described by TYPE.
4355 If that type exists already, reuse it.
4356 TYPE must be a FUNCTION_TYPE node. */
4359 build_method_type (basetype
, type
)
4360 tree basetype
, type
;
4365 /* Make a node of the sort we want. */
4366 t
= make_node (METHOD_TYPE
);
4368 if (TREE_CODE (type
) != FUNCTION_TYPE
)
4371 TYPE_METHOD_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
4372 TREE_TYPE (t
) = TREE_TYPE (type
);
4374 /* The actual arglist for this function includes a "hidden" argument
4375 which is "this". Put it into the list of argument types. */
4378 = tree_cons (NULL_TREE
,
4379 build_pointer_type (basetype
), TYPE_ARG_TYPES (type
));
4381 /* If we already have such a type, use the old one and free this one. */
4382 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (type
);
4383 t
= type_hash_canon (hashcode
, t
);
4385 if (TYPE_SIZE (t
) == 0)
4391 /* Construct, lay out and return the type of offsets to a value
4392 of type TYPE, within an object of type BASETYPE.
4393 If a suitable offset type exists already, reuse it. */
4396 build_offset_type (basetype
, type
)
4397 tree basetype
, type
;
4402 /* Make a node of the sort we want. */
4403 t
= make_node (OFFSET_TYPE
);
4405 TYPE_OFFSET_BASETYPE (t
) = TYPE_MAIN_VARIANT (basetype
);
4406 TREE_TYPE (t
) = type
;
4408 /* If we already have such a type, use the old one and free this one. */
4409 hashcode
= TYPE_HASH (basetype
) + TYPE_HASH (type
);
4410 t
= type_hash_canon (hashcode
, t
);
4412 if (TYPE_SIZE (t
) == 0)
4418 /* Create a complex type whose components are COMPONENT_TYPE. */
4421 build_complex_type (component_type
)
4422 tree component_type
;
4427 /* Make a node of the sort we want. */
4428 t
= make_node (COMPLEX_TYPE
);
4430 TREE_TYPE (t
) = TYPE_MAIN_VARIANT (component_type
);
4431 set_type_quals (t
, TYPE_QUALS (component_type
));
4433 /* If we already have such a type, use the old one and free this one. */
4434 hashcode
= TYPE_HASH (component_type
);
4435 t
= type_hash_canon (hashcode
, t
);
4437 if (TYPE_SIZE (t
) == 0)
4443 /* Return OP, stripped of any conversions to wider types as much as is safe.
4444 Converting the value back to OP's type makes a value equivalent to OP.
4446 If FOR_TYPE is nonzero, we return a value which, if converted to
4447 type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
4449 If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
4450 narrowest type that can hold the value, even if they don't exactly fit.
4451 Otherwise, bit-field references are changed to a narrower type
4452 only if they can be fetched directly from memory in that type.
4454 OP must have integer, real or enumeral type. Pointers are not allowed!
4456 There are some cases where the obvious value we could return
4457 would regenerate to OP if converted to OP's type,
4458 but would not extend like OP to wider types.
4459 If FOR_TYPE indicates such extension is contemplated, we eschew such values.
4460 For example, if OP is (unsigned short)(signed char)-1,
4461 we avoid returning (signed char)-1 if FOR_TYPE is int,
4462 even though extending that to an unsigned short would regenerate OP,
4463 since the result of extending (signed char)-1 to (int)
4464 is different from (int) OP. */
4467 get_unwidened (op
, for_type
)
4471 /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
4472 register tree type
= TREE_TYPE (op
);
4473 register unsigned final_prec
4474 = TYPE_PRECISION (for_type
!= 0 ? for_type
: type
);
4476 = (for_type
!= 0 && for_type
!= type
4477 && final_prec
> TYPE_PRECISION (type
)
4478 && TREE_UNSIGNED (type
));
4479 register tree win
= op
;
4481 while (TREE_CODE (op
) == NOP_EXPR
)
4483 register int bitschange
4484 = TYPE_PRECISION (TREE_TYPE (op
))
4485 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
4487 /* Truncations are many-one so cannot be removed.
4488 Unless we are later going to truncate down even farther. */
4490 && final_prec
> TYPE_PRECISION (TREE_TYPE (op
)))
4493 /* See what's inside this conversion. If we decide to strip it,
4495 op
= TREE_OPERAND (op
, 0);
4497 /* If we have not stripped any zero-extensions (uns is 0),
4498 we can strip any kind of extension.
4499 If we have previously stripped a zero-extension,
4500 only zero-extensions can safely be stripped.
4501 Any extension can be stripped if the bits it would produce
4502 are all going to be discarded later by truncating to FOR_TYPE. */
4506 if (! uns
|| final_prec
<= TYPE_PRECISION (TREE_TYPE (op
)))
4508 /* TREE_UNSIGNED says whether this is a zero-extension.
4509 Let's avoid computing it if it does not affect WIN
4510 and if UNS will not be needed again. */
4511 if ((uns
|| TREE_CODE (op
) == NOP_EXPR
)
4512 && TREE_UNSIGNED (TREE_TYPE (op
)))
4520 if (TREE_CODE (op
) == COMPONENT_REF
4521 /* Since type_for_size always gives an integer type. */
4522 && TREE_CODE (type
) != REAL_TYPE
4523 /* Don't crash if field not laid out yet. */
4524 && DECL_SIZE (TREE_OPERAND (op
, 1)) != 0)
4526 unsigned innerprec
= TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op
, 1)));
4527 type
= type_for_size (innerprec
, TREE_UNSIGNED (TREE_OPERAND (op
, 1)));
4529 /* We can get this structure field in the narrowest type it fits in.
4530 If FOR_TYPE is 0, do this only for a field that matches the
4531 narrower type exactly and is aligned for it
4532 The resulting extension to its nominal type (a fullword type)
4533 must fit the same conditions as for other extensions. */
4535 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
4536 && (for_type
|| ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1)))
4537 && (! uns
|| final_prec
<= innerprec
4538 || TREE_UNSIGNED (TREE_OPERAND (op
, 1)))
4541 win
= build (COMPONENT_REF
, type
, TREE_OPERAND (op
, 0),
4542 TREE_OPERAND (op
, 1));
4543 TREE_SIDE_EFFECTS (win
) = TREE_SIDE_EFFECTS (op
);
4544 TREE_THIS_VOLATILE (win
) = TREE_THIS_VOLATILE (op
);
4545 TREE_RAISES (win
) = TREE_RAISES (op
);
4551 /* Return OP or a simpler expression for a narrower value
4552 which can be sign-extended or zero-extended to give back OP.
4553 Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4554 or 0 if the value should be sign-extended. */
4557 get_narrower (op
, unsignedp_ptr
)
4561 register int uns
= 0;
4563 register tree win
= op
;
4565 while (TREE_CODE (op
) == NOP_EXPR
)
4567 register int bitschange
4568 = TYPE_PRECISION (TREE_TYPE (op
))
4569 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op
, 0)));
4571 /* Truncations are many-one so cannot be removed. */
4575 /* See what's inside this conversion. If we decide to strip it,
4577 op
= TREE_OPERAND (op
, 0);
4581 /* An extension: the outermost one can be stripped,
4582 but remember whether it is zero or sign extension. */
4584 uns
= TREE_UNSIGNED (TREE_TYPE (op
));
4585 /* Otherwise, if a sign extension has been stripped,
4586 only sign extensions can now be stripped;
4587 if a zero extension has been stripped, only zero-extensions. */
4588 else if (uns
!= TREE_UNSIGNED (TREE_TYPE (op
)))
4592 else /* bitschange == 0 */
4594 /* A change in nominal type can always be stripped, but we must
4595 preserve the unsignedness. */
4597 uns
= TREE_UNSIGNED (TREE_TYPE (op
));
4604 if (TREE_CODE (op
) == COMPONENT_REF
4605 /* Since type_for_size always gives an integer type. */
4606 && TREE_CODE (TREE_TYPE (op
)) != REAL_TYPE
)
4608 unsigned innerprec
= TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op
, 1)));
4609 tree type
= type_for_size (innerprec
, TREE_UNSIGNED (op
));
4611 /* We can get this structure field in a narrower type that fits it,
4612 but the resulting extension to its nominal type (a fullword type)
4613 must satisfy the same conditions as for other extensions.
4615 Do this only for fields that are aligned (not bit-fields),
4616 because when bit-field insns will be used there is no
4617 advantage in doing this. */
4619 if (innerprec
< TYPE_PRECISION (TREE_TYPE (op
))
4620 && ! DECL_BIT_FIELD (TREE_OPERAND (op
, 1))
4621 && (first
|| uns
== TREE_UNSIGNED (TREE_OPERAND (op
, 1)))
4625 uns
= TREE_UNSIGNED (TREE_OPERAND (op
, 1));
4626 win
= build (COMPONENT_REF
, type
, TREE_OPERAND (op
, 0),
4627 TREE_OPERAND (op
, 1));
4628 TREE_SIDE_EFFECTS (win
) = TREE_SIDE_EFFECTS (op
);
4629 TREE_THIS_VOLATILE (win
) = TREE_THIS_VOLATILE (op
);
4630 TREE_RAISES (win
) = TREE_RAISES (op
);
4633 *unsignedp_ptr
= uns
;
4637 /* Nonzero if integer constant C has a value that is permissible
4638 for type TYPE (an INTEGER_TYPE). */
4641 int_fits_type_p (c
, type
)
4644 if (TREE_UNSIGNED (type
))
4645 return (! (TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
4646 && INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type
), c
))
4647 && ! (TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
4648 && INT_CST_LT_UNSIGNED (c
, TYPE_MIN_VALUE (type
)))
4649 /* Negative ints never fit unsigned types. */
4650 && ! (TREE_INT_CST_HIGH (c
) < 0
4651 && ! TREE_UNSIGNED (TREE_TYPE (c
))));
4653 return (! (TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
4654 && INT_CST_LT (TYPE_MAX_VALUE (type
), c
))
4655 && ! (TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
4656 && INT_CST_LT (c
, TYPE_MIN_VALUE (type
)))
4657 /* Unsigned ints with top bit set never fit signed types. */
4658 && ! (TREE_INT_CST_HIGH (c
) < 0
4659 && TREE_UNSIGNED (TREE_TYPE (c
))));
4662 /* Return the innermost context enclosing DECL that is
4663 a FUNCTION_DECL, or zero if none. */
4666 decl_function_context (decl
)
4671 if (TREE_CODE (decl
) == ERROR_MARK
)
4674 if (TREE_CODE (decl
) == SAVE_EXPR
)
4675 context
= SAVE_EXPR_CONTEXT (decl
);
4677 context
= DECL_CONTEXT (decl
);
4679 while (context
&& TREE_CODE (context
) != FUNCTION_DECL
)
4681 if (TREE_CODE_CLASS (TREE_CODE (context
)) == 't')
4682 context
= TYPE_CONTEXT (context
);
4683 else if (TREE_CODE_CLASS (TREE_CODE (context
)) == 'd')
4684 context
= DECL_CONTEXT (context
);
4685 else if (TREE_CODE (context
) == BLOCK
)
4686 context
= BLOCK_SUPERCONTEXT (context
);
4688 /* Unhandled CONTEXT !? */
4695 /* Return the innermost context enclosing DECL that is
4696 a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4697 TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
4700 decl_type_context (decl
)
4703 tree context
= DECL_CONTEXT (decl
);
4707 if (TREE_CODE (context
) == RECORD_TYPE
4708 || TREE_CODE (context
) == UNION_TYPE
4709 || TREE_CODE (context
) == QUAL_UNION_TYPE
)
4711 if (TREE_CODE (context
) == TYPE_DECL
4712 || TREE_CODE (context
) == FUNCTION_DECL
)
4713 context
= DECL_CONTEXT (context
);
4714 else if (TREE_CODE (context
) == BLOCK
)
4715 context
= BLOCK_SUPERCONTEXT (context
);
4717 /* Unhandled CONTEXT!? */
4723 /* Print debugging information about the obstack O, named STR. */
4726 print_obstack_statistics (str
, o
)
4730 struct _obstack_chunk
*chunk
= o
->chunk
;
4734 n_alloc
+= o
->next_free
- chunk
->contents
;
4735 chunk
= chunk
->prev
;
4739 n_alloc
+= chunk
->limit
- &chunk
->contents
[0];
4740 chunk
= chunk
->prev
;
4742 fprintf (stderr
, "obstack %s: %u bytes, %d chunks\n",
4743 str
, n_alloc
, n_chunks
);
4746 /* Print debugging information about tree nodes generated during the compile,
4747 and any language-specific information. */
4750 dump_tree_statistics ()
4752 #ifdef GATHER_STATISTICS
4754 int total_nodes
, total_bytes
;
4757 fprintf (stderr
, "\n??? tree nodes created\n\n");
4758 #ifdef GATHER_STATISTICS
4759 fprintf (stderr
, "Kind Nodes Bytes\n");
4760 fprintf (stderr
, "-------------------------------------\n");
4761 total_nodes
= total_bytes
= 0;
4762 for (i
= 0; i
< (int) all_kinds
; i
++)
4764 fprintf (stderr
, "%-20s %6d %9d\n", tree_node_kind_names
[i
],
4765 tree_node_counts
[i
], tree_node_sizes
[i
]);
4766 total_nodes
+= tree_node_counts
[i
];
4767 total_bytes
+= tree_node_sizes
[i
];
4769 fprintf (stderr
, "%-20s %9d\n", "identifier names", id_string_size
);
4770 fprintf (stderr
, "-------------------------------------\n");
4771 fprintf (stderr
, "%-20s %6d %9d\n", "Total", total_nodes
, total_bytes
);
4772 fprintf (stderr
, "-------------------------------------\n");
4774 fprintf (stderr
, "(No per-node statistics)\n");
4776 print_obstack_statistics ("permanent_obstack", &permanent_obstack
);
4777 print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack
);
4778 print_obstack_statistics ("temporary_obstack", &temporary_obstack
);
4779 print_obstack_statistics ("momentary_obstack", &momentary_obstack
);
4780 print_obstack_statistics ("temp_decl_obstack", &temp_decl_obstack
);
4781 print_lang_statistics ();
4784 #define FILE_FUNCTION_PREFIX_LEN 9
4786 #ifndef NO_DOLLAR_IN_LABEL
4787 #define FILE_FUNCTION_FORMAT "_GLOBAL_$%s$%s"
4788 #else /* NO_DOLLAR_IN_LABEL */
4789 #ifndef NO_DOT_IN_LABEL
4790 #define FILE_FUNCTION_FORMAT "_GLOBAL_.%s.%s"
4791 #else /* NO_DOT_IN_LABEL */
4792 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4793 #endif /* NO_DOT_IN_LABEL */
4794 #endif /* NO_DOLLAR_IN_LABEL */
4796 extern char * first_global_object_name
;
4797 extern char * weak_global_object_name
;
4799 /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name
4800 clashes in cases where we can't reliably choose a unique name.
4802 Derived from mkstemp.c in libiberty. */
4805 append_random_chars (template)
4808 static const char letters
[]
4809 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
4810 static unsigned HOST_WIDE_INT value
;
4811 unsigned HOST_WIDE_INT v
;
4813 #ifdef HAVE_GETTIMEOFDAY
4817 template += strlen (template);
4819 #ifdef HAVE_GETTIMEOFDAY
4820 /* Get some more or less random data. */
4821 gettimeofday (&tv
, NULL
);
4822 value
+= ((unsigned HOST_WIDE_INT
) tv
.tv_usec
<< 16) ^ tv
.tv_sec
^ getpid ();
4829 /* Fill in the random bits. */
4830 template[0] = letters
[v
% 62];
4832 template[1] = letters
[v
% 62];
4834 template[2] = letters
[v
% 62];
4836 template[3] = letters
[v
% 62];
4838 template[4] = letters
[v
% 62];
4840 template[5] = letters
[v
% 62];
4845 /* Generate a name for a function unique to this translation unit.
4846 TYPE is some string to identify the purpose of this function to the
4847 linker or collect2. */
4850 get_file_function_name_long (type
)
4856 if (first_global_object_name
)
4857 p
= first_global_object_name
;
4860 /* We don't have anything that we know to be unique to this translation
4861 unit, so use what we do have and throw in some randomness. */
4863 const char *name
= weak_global_object_name
;
4864 const char *file
= main_input_filename
;
4869 file
= input_filename
;
4871 p
= (char *) alloca (7 + strlen (name
) + strlen (file
));
4873 sprintf (p
, "%s%s", name
, file
);
4874 append_random_chars (p
);
4877 buf
= (char *) alloca (sizeof (FILE_FUNCTION_FORMAT
) + strlen (p
)
4880 /* Set up the name of the file-level functions we may need. */
4881 /* Use a global object (which is already required to be unique over
4882 the program) rather than the file name (which imposes extra
4883 constraints). -- Raeburn@MIT.EDU, 10 Jan 1990. */
4884 sprintf (buf
, FILE_FUNCTION_FORMAT
, type
, p
);
4886 /* Don't need to pull weird characters out of global names. */
4887 if (p
!= first_global_object_name
)
4889 for (p
= buf
+11; *p
; p
++)
4890 if (! ((*p
>= '0' && *p
<= '9')
4891 #if 0 /* we always want labels, which are valid C++ identifiers (+ `$') */
4892 #ifndef ASM_IDENTIFY_GCC /* this is required if `.' is invalid -- k. raeburn */
4896 #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
4899 #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
4902 || (*p
>= 'A' && *p
<= 'Z')
4903 || (*p
>= 'a' && *p
<= 'z')))
4907 return get_identifier (buf
);
4910 /* If KIND=='I', return a suitable global initializer (constructor) name.
4911 If KIND=='D', return a suitable global clean-up (destructor) name. */
4914 get_file_function_name (kind
)
4921 return get_file_function_name_long (p
);
4925 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4926 The result is placed in BUFFER (which has length BIT_SIZE),
4927 with one bit in each char ('\000' or '\001').
4929 If the constructor is constant, NULL_TREE is returned.
4930 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4933 get_set_constructor_bits (init
, buffer
, bit_size
)
4940 HOST_WIDE_INT domain_min
4941 = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init
))));
4942 tree non_const_bits
= NULL_TREE
;
4943 for (i
= 0; i
< bit_size
; i
++)
4946 for (vals
= TREE_OPERAND (init
, 1);
4947 vals
!= NULL_TREE
; vals
= TREE_CHAIN (vals
))
4949 if (TREE_CODE (TREE_VALUE (vals
)) != INTEGER_CST
4950 || (TREE_PURPOSE (vals
) != NULL_TREE
4951 && TREE_CODE (TREE_PURPOSE (vals
)) != INTEGER_CST
))
4953 = tree_cons (TREE_PURPOSE (vals
), TREE_VALUE (vals
), non_const_bits
);
4954 else if (TREE_PURPOSE (vals
) != NULL_TREE
)
4956 /* Set a range of bits to ones. */
4957 HOST_WIDE_INT lo_index
4958 = TREE_INT_CST_LOW (TREE_PURPOSE (vals
)) - domain_min
;
4959 HOST_WIDE_INT hi_index
4960 = TREE_INT_CST_LOW (TREE_VALUE (vals
)) - domain_min
;
4961 if (lo_index
< 0 || lo_index
>= bit_size
4962 || hi_index
< 0 || hi_index
>= bit_size
)
4964 for ( ; lo_index
<= hi_index
; lo_index
++)
4965 buffer
[lo_index
] = 1;
4969 /* Set a single bit to one. */
4971 = TREE_INT_CST_LOW (TREE_VALUE (vals
)) - domain_min
;
4972 if (index
< 0 || index
>= bit_size
)
4974 error ("invalid initializer for bit string");
4980 return non_const_bits
;
4983 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4984 The result is placed in BUFFER (which is an array of bytes).
4985 If the constructor is constant, NULL_TREE is returned.
4986 Otherwise, a TREE_LIST of the non-constant elements is emitted. */
4989 get_set_constructor_bytes (init
, buffer
, wd_size
)
4991 unsigned char *buffer
;
4995 int set_word_size
= BITS_PER_UNIT
;
4996 int bit_size
= wd_size
* set_word_size
;
4998 unsigned char *bytep
= buffer
;
4999 char *bit_buffer
= (char *) alloca(bit_size
);
5000 tree non_const_bits
= get_set_constructor_bits (init
, bit_buffer
, bit_size
);
5002 for (i
= 0; i
< wd_size
; i
++)
5005 for (i
= 0; i
< bit_size
; i
++)
5009 if (BYTES_BIG_ENDIAN
)
5010 *bytep
|= (1 << (set_word_size
- 1 - bit_pos
));
5012 *bytep
|= 1 << bit_pos
;
5015 if (bit_pos
>= set_word_size
)
5016 bit_pos
= 0, bytep
++;
5018 return non_const_bits
;
5021 #if defined ENABLE_CHECKING && (__GNUC__ > 2 || __GNUC_MINOR__ > 6)
5022 /* Complain that the tree code of NODE does not match the expected CODE.
5023 FILE, LINE, and FUNCTION are of the caller. */
5025 tree_check_failed (node
, code
, file
, line
, function
)
5027 enum tree_code code
;
5030 const char *function
;
5032 error ("Tree check: expected %s, have %s",
5033 tree_code_name
[code
], tree_code_name
[TREE_CODE (node
)]);
5034 fancy_abort (file
, line
, function
);
5037 /* Similar to above, except that we check for a class of tree
5038 code, given in CL. */
5040 tree_class_check_failed (node
, cl
, file
, line
, function
)
5045 const char *function
;
5047 error ("Tree check: expected class '%c', have '%c' (%s)",
5048 cl
, TREE_CODE_CLASS (TREE_CODE (node
)),
5049 tree_code_name
[TREE_CODE (node
)]);
5050 fancy_abort (file
, line
, function
);
5053 #endif /* ENABLE_CHECKING */
5055 /* Return the alias set for T, which may be either a type or an
5062 if (!flag_strict_aliasing
|| !lang_get_alias_set
)
5063 /* If we're not doing any lanaguage-specific alias analysis, just
5064 assume everything aliases everything else. */
5067 return (*lang_get_alias_set
) (t
);
5070 /* Return a brand-new alias set. */
5075 static int last_alias_set
;
5076 if (flag_strict_aliasing
)
5077 return ++last_alias_set
;