]>
Commit | Line | Data |
---|---|---|
c6a1db6c | 1 | /* Language-independent node constructors for parse phase of GNU compiler. |
06ceef4e RK |
2 | Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
3 | 1999, 2000 Free Software Foundation, Inc. | |
c6a1db6c RS |
4 | |
5 | This file is part of GNU CC. | |
6 | ||
7 | GNU CC is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2, or (at your option) | |
10 | any later version. | |
11 | ||
12 | GNU CC is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with GNU CC; see the file COPYING. If not, write to | |
e9fa0c7c RK |
19 | the Free Software Foundation, 59 Temple Place - Suite 330, |
20 | Boston, MA 02111-1307, USA. */ | |
c6a1db6c RS |
21 | |
22 | ||
23 | /* This file contains the low level primitives for operating on tree nodes, | |
24 | including allocation, list operations, interning of identifiers, | |
25 | construction of data type nodes and statement nodes, | |
26 | and construction of type conversion nodes. It also contains | |
27 | tables index by tree code that describe how to take apart | |
28 | nodes of that code. | |
29 | ||
30 | It is intended to be language-independent, but occasionally | |
31 | calls language-dependent routines defined (for C) in typecheck.c. | |
32 | ||
33 | The low-level allocation routines oballoc and permalloc | |
34 | are used also for allocating many other kinds of objects | |
35 | by all passes of the compiler. */ | |
36 | ||
37 | #include "config.h" | |
670ee920 | 38 | #include "system.h" |
c6a1db6c | 39 | #include "flags.h" |
c6a1db6c | 40 | #include "tree.h" |
6baf1cc8 | 41 | #include "tm_p.h" |
d69c4bd1 | 42 | #include "function.h" |
c6a1db6c | 43 | #include "obstack.h" |
10f0ad3d | 44 | #include "toplev.h" |
87ff9c8e | 45 | #include "ggc.h" |
956d6950 | 46 | |
c6a1db6c RS |
47 | #define obstack_chunk_alloc xmalloc |
48 | #define obstack_chunk_free free | |
cab634f2 | 49 | /* obstack.[ch] explicitly declined to prototype this. */ |
58782098 | 50 | extern int _obstack_allocated_p PARAMS ((struct obstack *h, PTR obj)); |
c6a1db6c | 51 | |
58782098 | 52 | static void unsave_expr_now_r PARAMS ((tree)); |
582db8e4 | 53 | |
c6a1db6c RS |
54 | /* Tree nodes of permanent duration are allocated in this obstack. |
55 | They are the identifier nodes, and everything outside of | |
56 | the bodies and parameters of function definitions. */ | |
57 | ||
58 | struct obstack permanent_obstack; | |
59 | ||
60 | /* The initial RTL, and all ..._TYPE nodes, in a function | |
61 | are allocated in this obstack. Usually they are freed at the | |
62 | end of the function, but if the function is inline they are saved. | |
63 | For top-level functions, this is maybepermanent_obstack. | |
64 | Separate obstacks are made for nested functions. */ | |
65 | ||
66 | struct obstack *function_maybepermanent_obstack; | |
67 | ||
68 | /* This is the function_maybepermanent_obstack for top-level functions. */ | |
69 | ||
70 | struct obstack maybepermanent_obstack; | |
71 | ||
72 | /* The contents of the current function definition are allocated | |
73 | in this obstack, and all are freed at the end of the function. | |
74 | For top-level functions, this is temporary_obstack. | |
75 | Separate obstacks are made for nested functions. */ | |
76 | ||
77 | struct obstack *function_obstack; | |
78 | ||
79 | /* This is used for reading initializers of global variables. */ | |
80 | ||
81 | struct obstack temporary_obstack; | |
82 | ||
83 | /* The tree nodes of an expression are allocated | |
84 | in this obstack, and all are freed at the end of the expression. */ | |
85 | ||
86 | struct obstack momentary_obstack; | |
87 | ||
88 | /* The tree nodes of a declarator are allocated | |
89 | in this obstack, and all are freed when the declarator | |
90 | has been parsed. */ | |
91 | ||
92 | static struct obstack temp_decl_obstack; | |
93 | ||
94 | /* This points at either permanent_obstack | |
95 | or the current function_maybepermanent_obstack. */ | |
96 | ||
97 | struct obstack *saveable_obstack; | |
98 | ||
99 | /* This is same as saveable_obstack during parse and expansion phase; | |
100 | it points to the current function's obstack during optimization. | |
101 | This is the obstack to be used for creating rtl objects. */ | |
102 | ||
103 | struct obstack *rtl_obstack; | |
104 | ||
105 | /* This points at either permanent_obstack or the current function_obstack. */ | |
106 | ||
107 | struct obstack *current_obstack; | |
108 | ||
109 | /* This points at either permanent_obstack or the current function_obstack | |
110 | or momentary_obstack. */ | |
111 | ||
112 | struct obstack *expression_obstack; | |
113 | ||
114 | /* Stack of obstack selections for push_obstacks and pop_obstacks. */ | |
115 | ||
116 | struct obstack_stack | |
117 | { | |
118 | struct obstack_stack *next; | |
119 | struct obstack *current; | |
120 | struct obstack *saveable; | |
121 | struct obstack *expression; | |
122 | struct obstack *rtl; | |
123 | }; | |
124 | ||
125 | struct obstack_stack *obstack_stack; | |
126 | ||
127 | /* Obstack for allocating struct obstack_stack entries. */ | |
128 | ||
129 | static struct obstack obstack_stack_obstack; | |
130 | ||
131 | /* Addresses of first objects in some obstacks. | |
132 | This is for freeing their entire contents. */ | |
133 | char *maybepermanent_firstobj; | |
134 | char *temporary_firstobj; | |
135 | char *momentary_firstobj; | |
136 | char *temp_decl_firstobj; | |
137 | ||
2b417d3c JW |
138 | /* This is used to preserve objects (mainly array initializers) that need to |
139 | live until the end of the current function, but no further. */ | |
140 | char *momentary_function_firstobj; | |
141 | ||
c6a1db6c RS |
142 | /* Nonzero means all ..._TYPE nodes should be allocated permanently. */ |
143 | ||
144 | int all_types_permanent; | |
145 | ||
146 | /* Stack of places to restore the momentary obstack back to. */ | |
147 | ||
148 | struct momentary_level | |
149 | { | |
150 | /* Pointer back to previous such level. */ | |
151 | struct momentary_level *prev; | |
152 | /* First object allocated within this level. */ | |
153 | char *base; | |
154 | /* Value of expression_obstack saved at entry to this level. */ | |
155 | struct obstack *obstack; | |
156 | }; | |
157 | ||
158 | struct momentary_level *momentary_stack; | |
159 | ||
160 | /* Table indexed by tree code giving a string containing a character | |
161 | classifying the tree code. Possibilities are | |
162 | t, d, s, c, r, <, 1, 2 and e. See tree.def for details. */ | |
163 | ||
164 | #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE, | |
165 | ||
0a6969ad | 166 | char tree_code_type[MAX_TREE_CODES] = { |
c6a1db6c RS |
167 | #include "tree.def" |
168 | }; | |
169 | #undef DEFTREECODE | |
170 | ||
171 | /* Table indexed by tree code giving number of expression | |
172 | operands beyond the fixed part of the node structure. | |
173 | Not used for types or decls. */ | |
174 | ||
175 | #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH, | |
176 | ||
0a6969ad | 177 | int tree_code_length[MAX_TREE_CODES] = { |
c6a1db6c RS |
178 | #include "tree.def" |
179 | }; | |
180 | #undef DEFTREECODE | |
181 | ||
182 | /* Names of tree components. | |
183 | Used for printing out the tree and error messages. */ | |
184 | #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME, | |
185 | ||
5f8ded66 | 186 | const char *tree_code_name[MAX_TREE_CODES] = { |
c6a1db6c RS |
187 | #include "tree.def" |
188 | }; | |
189 | #undef DEFTREECODE | |
190 | ||
c6a1db6c RS |
191 | /* Statistics-gathering stuff. */ |
192 | typedef enum | |
193 | { | |
03646189 RS |
194 | d_kind, |
195 | t_kind, | |
196 | b_kind, | |
197 | s_kind, | |
198 | r_kind, | |
199 | e_kind, | |
200 | c_kind, | |
201 | id_kind, | |
202 | op_id_kind, | |
203 | perm_list_kind, | |
204 | temp_list_kind, | |
205 | vec_kind, | |
206 | x_kind, | |
207 | lang_decl, | |
208 | lang_type, | |
209 | all_kinds | |
c6a1db6c | 210 | } tree_node_kind; |
03646189 | 211 | |
c6a1db6c RS |
212 | int tree_node_counts[(int)all_kinds]; |
213 | int tree_node_sizes[(int)all_kinds]; | |
214 | int id_string_size = 0; | |
03646189 | 215 | |
341a243e | 216 | static const char * const tree_node_kind_names[] = { |
03646189 RS |
217 | "decls", |
218 | "types", | |
219 | "blocks", | |
220 | "stmts", | |
221 | "refs", | |
222 | "exprs", | |
223 | "constants", | |
224 | "identifiers", | |
225 | "op_identifiers", | |
226 | "perm_tree_lists", | |
227 | "temp_tree_lists", | |
228 | "vecs", | |
229 | "random kinds", | |
230 | "lang_decl kinds", | |
231 | "lang_type kinds" | |
232 | }; | |
c6a1db6c RS |
233 | |
234 | /* Hash table for uniquizing IDENTIFIER_NODEs by name. */ | |
235 | ||
236 | #define MAX_HASH_TABLE 1009 | |
237 | static tree hash_table[MAX_HASH_TABLE]; /* id hash buckets */ | |
238 | ||
239 | /* 0 while creating built-in identifiers. */ | |
240 | static int do_identifier_warnings; | |
241 | ||
0e77444b RS |
242 | /* Unique id for next decl created. */ |
243 | static int next_decl_uid; | |
579f50b6 RK |
244 | /* Unique id for next type created. */ |
245 | static int next_type_uid = 1; | |
0e77444b | 246 | |
41472af8 MM |
247 | /* The language-specific function for alias analysis. If NULL, the |
248 | language does not do any special alias analysis. */ | |
58782098 | 249 | int (*lang_get_alias_set) PARAMS ((tree)); |
41472af8 | 250 | |
91e97eb8 RK |
251 | /* Here is how primitive or already-canonicalized types' hash |
252 | codes are made. */ | |
7bcac048 | 253 | #define TYPE_HASH(TYPE) ((unsigned long) (TYPE) & 0777777) |
91e97eb8 | 254 | |
87ff9c8e RH |
255 | /* Each hash table slot is a bucket containing a chain |
256 | of these structures. */ | |
257 | ||
258 | struct type_hash | |
259 | { | |
260 | struct type_hash *next; /* Next structure in the bucket. */ | |
05bccae2 | 261 | unsigned int hashcode; /* Hash code of this type. */ |
87ff9c8e RH |
262 | tree type; /* The type recorded here. */ |
263 | }; | |
264 | ||
265 | /* Now here is the hash table. When recording a type, it is added | |
266 | to the slot whose index is the hash code mod the table size. | |
267 | Note that the hash table is used for several kinds of types | |
268 | (function types, array types and array index range types, for now). | |
269 | While all these live in the same table, they are completely independent, | |
270 | and the hash code is computed differently for each of these. */ | |
271 | ||
272 | #define TYPE_HASH_SIZE 59 | |
273 | struct type_hash *type_hash_table[TYPE_HASH_SIZE]; | |
274 | ||
58782098 KG |
275 | static void build_real_from_int_cst_1 PARAMS ((PTR)); |
276 | static void set_type_quals PARAMS ((tree, int)); | |
277 | static void append_random_chars PARAMS ((char *)); | |
278 | static void mark_type_hash PARAMS ((void *)); | |
0a818f84 | 279 | |
582db8e4 MM |
280 | /* If non-null, these are language-specific helper functions for |
281 | unsave_expr_now. If present, LANG_UNSAVE is called before its | |
282 | argument (an UNSAVE_EXPR) is to be unsaved, and all other | |
283 | processing in unsave_expr_now is aborted. LANG_UNSAVE_EXPR_NOW is | |
284 | called from unsave_expr_1 for language-specific tree codes. */ | |
58782098 KG |
285 | void (*lang_unsave) PARAMS ((tree *)); |
286 | void (*lang_unsave_expr_now) PARAMS ((tree)); | |
5c7261ab AS |
287 | |
288 | /* The string used as a placeholder instead of a source file name for | |
289 | built-in tree nodes. The variable, which is dynamically allocated, | |
290 | should be used; the macro is only used to initialize it. */ | |
291 | ||
292 | static char *built_in_filename; | |
293 | #define BUILT_IN_FILENAME ("<built-in>") | |
c6a1db6c | 294 | \f |
81b3411c BS |
295 | tree global_trees[TI_MAX]; |
296 | \f | |
c6a1db6c RS |
297 | /* Init the principal obstacks. */ |
298 | ||
299 | void | |
300 | init_obstacks () | |
301 | { | |
302 | gcc_obstack_init (&obstack_stack_obstack); | |
303 | gcc_obstack_init (&permanent_obstack); | |
304 | ||
305 | gcc_obstack_init (&temporary_obstack); | |
306 | temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0); | |
307 | gcc_obstack_init (&momentary_obstack); | |
308 | momentary_firstobj = (char *) obstack_alloc (&momentary_obstack, 0); | |
2b417d3c | 309 | momentary_function_firstobj = momentary_firstobj; |
c6a1db6c RS |
310 | gcc_obstack_init (&maybepermanent_obstack); |
311 | maybepermanent_firstobj | |
312 | = (char *) obstack_alloc (&maybepermanent_obstack, 0); | |
313 | gcc_obstack_init (&temp_decl_obstack); | |
314 | temp_decl_firstobj = (char *) obstack_alloc (&temp_decl_obstack, 0); | |
315 | ||
316 | function_obstack = &temporary_obstack; | |
317 | function_maybepermanent_obstack = &maybepermanent_obstack; | |
318 | current_obstack = &permanent_obstack; | |
319 | expression_obstack = &permanent_obstack; | |
320 | rtl_obstack = saveable_obstack = &permanent_obstack; | |
321 | ||
322 | /* Init the hash table of identifiers. */ | |
4c9a05bc | 323 | bzero ((char *) hash_table, sizeof hash_table); |
d4b60170 RK |
324 | ggc_add_tree_root (hash_table, sizeof hash_table / sizeof (tree)); |
325 | ||
326 | /* Initialize the hash table of types. */ | |
327 | bzero ((char *) type_hash_table, | |
328 | sizeof type_hash_table / sizeof type_hash_table[0]); | |
329 | ggc_add_root (type_hash_table, | |
330 | sizeof type_hash_table / sizeof type_hash_table [0], | |
331 | sizeof type_hash_table[0], mark_type_hash); | |
81b3411c | 332 | ggc_add_tree_root (global_trees, TI_MAX); |
c6a1db6c RS |
333 | } |
334 | ||
335 | void | |
336 | gcc_obstack_init (obstack) | |
337 | struct obstack *obstack; | |
338 | { | |
339 | /* Let particular systems override the size of a chunk. */ | |
340 | #ifndef OBSTACK_CHUNK_SIZE | |
341 | #define OBSTACK_CHUNK_SIZE 0 | |
342 | #endif | |
343 | /* Let them override the alloc and free routines too. */ | |
344 | #ifndef OBSTACK_CHUNK_ALLOC | |
345 | #define OBSTACK_CHUNK_ALLOC xmalloc | |
346 | #endif | |
347 | #ifndef OBSTACK_CHUNK_FREE | |
348 | #define OBSTACK_CHUNK_FREE free | |
349 | #endif | |
350 | _obstack_begin (obstack, OBSTACK_CHUNK_SIZE, 0, | |
58782098 KG |
351 | (void *(*) PARAMS ((long))) OBSTACK_CHUNK_ALLOC, |
352 | (void (*) PARAMS ((void *))) OBSTACK_CHUNK_FREE); | |
c6a1db6c RS |
353 | } |
354 | ||
83fdb191 MM |
355 | /* Save all variables describing the current status into the structure |
356 | *P. This function is called whenever we start compiling one | |
357 | function in the midst of compiling another. For example, when | |
358 | compiling a nested function, or, in C++, a template instantiation | |
359 | that is required by the function we are currently compiling. | |
a0dabda5 JM |
360 | |
361 | CONTEXT is the decl_function_context for the function we're about to | |
362 | compile; if it isn't current_function_decl, we have to play some games. */ | |
c6a1db6c RS |
363 | |
364 | void | |
36edd3cc | 365 | save_tree_status (p) |
c6a1db6c RS |
366 | struct function *p; |
367 | { | |
368 | p->all_types_permanent = all_types_permanent; | |
369 | p->momentary_stack = momentary_stack; | |
370 | p->maybepermanent_firstobj = maybepermanent_firstobj; | |
8fa6b6c9 | 371 | p->temporary_firstobj = temporary_firstobj; |
c6a1db6c | 372 | p->momentary_firstobj = momentary_firstobj; |
2b417d3c | 373 | p->momentary_function_firstobj = momentary_function_firstobj; |
c6a1db6c RS |
374 | p->function_obstack = function_obstack; |
375 | p->function_maybepermanent_obstack = function_maybepermanent_obstack; | |
376 | p->current_obstack = current_obstack; | |
377 | p->expression_obstack = expression_obstack; | |
378 | p->saveable_obstack = saveable_obstack; | |
379 | p->rtl_obstack = rtl_obstack; | |
a0dabda5 | 380 | |
36edd3cc BS |
381 | function_maybepermanent_obstack |
382 | = (struct obstack *) xmalloc (sizeof (struct obstack)); | |
383 | gcc_obstack_init (function_maybepermanent_obstack); | |
24554b03 RH |
384 | maybepermanent_firstobj |
385 | = (char *) obstack_finish (function_maybepermanent_obstack); | |
19e7d354 | 386 | |
c6a1db6c RS |
387 | function_obstack = (struct obstack *) xmalloc (sizeof (struct obstack)); |
388 | gcc_obstack_init (function_obstack); | |
389 | ||
c6a1db6c RS |
390 | current_obstack = &permanent_obstack; |
391 | expression_obstack = &permanent_obstack; | |
392 | rtl_obstack = saveable_obstack = &permanent_obstack; | |
393 | ||
8fa6b6c9 | 394 | temporary_firstobj = (char *) obstack_alloc (&temporary_obstack, 0); |
c6a1db6c | 395 | momentary_firstobj = (char *) obstack_finish (&momentary_obstack); |
2b417d3c | 396 | momentary_function_firstobj = momentary_firstobj; |
c6a1db6c RS |
397 | } |
398 | ||
399 | /* Restore all variables describing the current status from the structure *P. | |
400 | This is used after a nested function. */ | |
401 | ||
402 | void | |
36edd3cc | 403 | restore_tree_status (p) |
c6a1db6c RS |
404 | struct function *p; |
405 | { | |
406 | all_types_permanent = p->all_types_permanent; | |
407 | momentary_stack = p->momentary_stack; | |
408 | ||
2b417d3c | 409 | obstack_free (&momentary_obstack, momentary_function_firstobj); |
19e7d354 | 410 | |
a0dabda5 | 411 | /* Free saveable storage used by the function just compiled and not |
36edd3cc | 412 | saved. */ |
a0dabda5 | 413 | obstack_free (function_maybepermanent_obstack, maybepermanent_firstobj); |
24554b03 RH |
414 | if (obstack_empty_p (function_maybepermanent_obstack)) |
415 | { | |
416 | obstack_free (function_maybepermanent_obstack, NULL); | |
417 | free (function_maybepermanent_obstack); | |
418 | } | |
19e7d354 | 419 | |
36edd3cc BS |
420 | obstack_free (&temporary_obstack, temporary_firstobj); |
421 | obstack_free (&momentary_obstack, momentary_function_firstobj); | |
d1485032 | 422 | |
69ba6af3 | 423 | obstack_free (function_obstack, NULL); |
c6a1db6c RS |
424 | free (function_obstack); |
425 | ||
8fa6b6c9 | 426 | temporary_firstobj = p->temporary_firstobj; |
c6a1db6c | 427 | momentary_firstobj = p->momentary_firstobj; |
2b417d3c | 428 | momentary_function_firstobj = p->momentary_function_firstobj; |
c6a1db6c RS |
429 | maybepermanent_firstobj = p->maybepermanent_firstobj; |
430 | function_obstack = p->function_obstack; | |
431 | function_maybepermanent_obstack = p->function_maybepermanent_obstack; | |
432 | current_obstack = p->current_obstack; | |
433 | expression_obstack = p->expression_obstack; | |
434 | saveable_obstack = p->saveable_obstack; | |
435 | rtl_obstack = p->rtl_obstack; | |
436 | } | |
437 | \f | |
438 | /* Start allocating on the temporary (per function) obstack. | |
439 | This is done in start_function before parsing the function body, | |
440 | and before each initialization at top level, and to go back | |
956af069 | 441 | to temporary allocation after doing permanent_allocation. */ |
c6a1db6c RS |
442 | |
443 | void | |
444 | temporary_allocation () | |
445 | { | |
446 | /* Note that function_obstack at top level points to temporary_obstack. | |
447 | But within a nested function context, it is a separate obstack. */ | |
448 | current_obstack = function_obstack; | |
449 | expression_obstack = function_obstack; | |
450 | rtl_obstack = saveable_obstack = function_maybepermanent_obstack; | |
451 | momentary_stack = 0; | |
452 | } | |
453 | ||
454 | /* Start allocating on the permanent obstack but don't | |
455 | free the temporary data. After calling this, call | |
456 | `permanent_allocation' to fully resume permanent allocation status. */ | |
457 | ||
458 | void | |
459 | end_temporary_allocation () | |
460 | { | |
461 | current_obstack = &permanent_obstack; | |
462 | expression_obstack = &permanent_obstack; | |
463 | rtl_obstack = saveable_obstack = &permanent_obstack; | |
464 | } | |
465 | ||
466 | /* Resume allocating on the temporary obstack, undoing | |
467 | effects of `end_temporary_allocation'. */ | |
468 | ||
469 | void | |
470 | resume_temporary_allocation () | |
471 | { | |
472 | current_obstack = function_obstack; | |
473 | expression_obstack = function_obstack; | |
474 | rtl_obstack = saveable_obstack = function_maybepermanent_obstack; | |
475 | } | |
476 | ||
477 | /* While doing temporary allocation, switch to allocating in such a | |
478 | way as to save all nodes if the function is inlined. Call | |
479 | resume_temporary_allocation to go back to ordinary temporary | |
480 | allocation. */ | |
481 | ||
482 | void | |
483 | saveable_allocation () | |
484 | { | |
485 | /* Note that function_obstack at top level points to temporary_obstack. | |
486 | But within a nested function context, it is a separate obstack. */ | |
487 | expression_obstack = current_obstack = saveable_obstack; | |
488 | } | |
489 | ||
490 | /* Switch to current obstack CURRENT and maybepermanent obstack SAVEABLE, | |
491 | recording the previously current obstacks on a stack. | |
492 | This does not free any storage in any obstack. */ | |
493 | ||
494 | void | |
495 | push_obstacks (current, saveable) | |
496 | struct obstack *current, *saveable; | |
497 | { | |
a3770a81 RH |
498 | struct obstack_stack *p; |
499 | ||
a3770a81 | 500 | p = (struct obstack_stack *) obstack_alloc (&obstack_stack_obstack, |
c6a1db6c RS |
501 | (sizeof (struct obstack_stack))); |
502 | ||
503 | p->current = current_obstack; | |
504 | p->saveable = saveable_obstack; | |
505 | p->expression = expression_obstack; | |
506 | p->rtl = rtl_obstack; | |
507 | p->next = obstack_stack; | |
508 | obstack_stack = p; | |
509 | ||
510 | current_obstack = current; | |
511 | expression_obstack = current; | |
512 | rtl_obstack = saveable_obstack = saveable; | |
513 | } | |
514 | ||
515 | /* Save the current set of obstacks, but don't change them. */ | |
516 | ||
517 | void | |
518 | push_obstacks_nochange () | |
519 | { | |
a3770a81 RH |
520 | struct obstack_stack *p; |
521 | ||
a3770a81 | 522 | p = (struct obstack_stack *) obstack_alloc (&obstack_stack_obstack, |
c6a1db6c RS |
523 | (sizeof (struct obstack_stack))); |
524 | ||
525 | p->current = current_obstack; | |
526 | p->saveable = saveable_obstack; | |
527 | p->expression = expression_obstack; | |
528 | p->rtl = rtl_obstack; | |
529 | p->next = obstack_stack; | |
530 | obstack_stack = p; | |
531 | } | |
532 | ||
533 | /* Pop the obstack selection stack. */ | |
534 | ||
535 | void | |
536 | pop_obstacks () | |
537 | { | |
a3770a81 RH |
538 | struct obstack_stack *p; |
539 | ||
a3770a81 | 540 | p = obstack_stack; |
c6a1db6c RS |
541 | obstack_stack = p->next; |
542 | ||
543 | current_obstack = p->current; | |
544 | saveable_obstack = p->saveable; | |
545 | expression_obstack = p->expression; | |
546 | rtl_obstack = p->rtl; | |
547 | ||
548 | obstack_free (&obstack_stack_obstack, p); | |
549 | } | |
550 | ||
551 | /* Nonzero if temporary allocation is currently in effect. | |
552 | Zero if currently doing permanent allocation. */ | |
553 | ||
554 | int | |
555 | allocation_temporary_p () | |
556 | { | |
557 | return current_obstack != &permanent_obstack; | |
558 | } | |
559 | ||
560 | /* Go back to allocating on the permanent obstack | |
561 | and free everything in the temporary obstack. | |
2b417d3c JW |
562 | |
563 | FUNCTION_END is true only if we have just finished compiling a function. | |
564 | In that case, we also free preserved initial values on the momentary | |
565 | obstack. */ | |
c6a1db6c RS |
566 | |
567 | void | |
2b417d3c JW |
568 | permanent_allocation (function_end) |
569 | int function_end; | |
c6a1db6c RS |
570 | { |
571 | /* Free up previous temporary obstack data */ | |
572 | obstack_free (&temporary_obstack, temporary_firstobj); | |
2b417d3c | 573 | if (function_end) |
c61f7d69 RK |
574 | { |
575 | obstack_free (&momentary_obstack, momentary_function_firstobj); | |
576 | momentary_firstobj = momentary_function_firstobj; | |
577 | } | |
2b417d3c JW |
578 | else |
579 | obstack_free (&momentary_obstack, momentary_firstobj); | |
d4b60170 | 580 | |
9ccd47de | 581 | obstack_free (function_maybepermanent_obstack, maybepermanent_firstobj); |
c6a1db6c RS |
582 | obstack_free (&temp_decl_obstack, temp_decl_firstobj); |
583 | ||
584 | current_obstack = &permanent_obstack; | |
585 | expression_obstack = &permanent_obstack; | |
586 | rtl_obstack = saveable_obstack = &permanent_obstack; | |
587 | } | |
588 | ||
589 | /* Save permanently everything on the maybepermanent_obstack. */ | |
590 | ||
591 | void | |
592 | preserve_data () | |
593 | { | |
594 | maybepermanent_firstobj | |
595 | = (char *) obstack_alloc (function_maybepermanent_obstack, 0); | |
596 | } | |
597 | ||
598 | void | |
599 | preserve_initializer () | |
600 | { | |
2b417d3c JW |
601 | struct momentary_level *tem; |
602 | char *old_momentary; | |
603 | ||
c6a1db6c RS |
604 | temporary_firstobj |
605 | = (char *) obstack_alloc (&temporary_obstack, 0); | |
c6a1db6c RS |
606 | maybepermanent_firstobj |
607 | = (char *) obstack_alloc (function_maybepermanent_obstack, 0); | |
2b417d3c JW |
608 | |
609 | old_momentary = momentary_firstobj; | |
610 | momentary_firstobj | |
611 | = (char *) obstack_alloc (&momentary_obstack, 0); | |
612 | if (momentary_firstobj != old_momentary) | |
613 | for (tem = momentary_stack; tem; tem = tem->prev) | |
614 | tem->base = momentary_firstobj; | |
c6a1db6c RS |
615 | } |
616 | ||
617 | /* Start allocating new rtl in current_obstack. | |
618 | Use resume_temporary_allocation | |
619 | to go back to allocating rtl in saveable_obstack. */ | |
620 | ||
621 | void | |
622 | rtl_in_current_obstack () | |
623 | { | |
624 | rtl_obstack = current_obstack; | |
625 | } | |
626 | ||
02e39be1 JW |
627 | /* Start allocating rtl from saveable_obstack. Intended to be used after |
628 | a call to push_obstacks_nochange. */ | |
c6a1db6c | 629 | |
02e39be1 | 630 | void |
c6a1db6c RS |
631 | rtl_in_saveable_obstack () |
632 | { | |
02e39be1 | 633 | rtl_obstack = saveable_obstack; |
c6a1db6c RS |
634 | } |
635 | \f | |
636 | /* Allocate SIZE bytes in the current obstack | |
637 | and return a pointer to them. | |
638 | In practice the current obstack is always the temporary one. */ | |
639 | ||
640 | char * | |
641 | oballoc (size) | |
642 | int size; | |
643 | { | |
644 | return (char *) obstack_alloc (current_obstack, size); | |
645 | } | |
646 | ||
647 | /* Free the object PTR in the current obstack | |
648 | as well as everything allocated since PTR. | |
649 | In practice the current obstack is always the temporary one. */ | |
650 | ||
651 | void | |
652 | obfree (ptr) | |
653 | char *ptr; | |
654 | { | |
655 | obstack_free (current_obstack, ptr); | |
656 | } | |
657 | ||
658 | /* Allocate SIZE bytes in the permanent obstack | |
659 | and return a pointer to them. */ | |
660 | ||
661 | char * | |
662 | permalloc (size) | |
37366632 | 663 | int size; |
c6a1db6c RS |
664 | { |
665 | return (char *) obstack_alloc (&permanent_obstack, size); | |
666 | } | |
667 | ||
668 | /* Allocate NELEM items of SIZE bytes in the permanent obstack | |
669 | and return a pointer to them. The storage is cleared before | |
670 | returning the value. */ | |
671 | ||
672 | char * | |
673 | perm_calloc (nelem, size) | |
674 | int nelem; | |
675 | long size; | |
676 | { | |
677 | char *rval = (char *) obstack_alloc (&permanent_obstack, nelem * size); | |
678 | bzero (rval, nelem * size); | |
679 | return rval; | |
680 | } | |
681 | ||
682 | /* Allocate SIZE bytes in the saveable obstack | |
683 | and return a pointer to them. */ | |
684 | ||
685 | char * | |
686 | savealloc (size) | |
687 | int size; | |
688 | { | |
689 | return (char *) obstack_alloc (saveable_obstack, size); | |
690 | } | |
f0632762 JM |
691 | |
692 | /* Allocate SIZE bytes in the expression obstack | |
693 | and return a pointer to them. */ | |
694 | ||
695 | char * | |
696 | expralloc (size) | |
697 | int size; | |
698 | { | |
699 | return (char *) obstack_alloc (expression_obstack, size); | |
700 | } | |
c6a1db6c RS |
701 | \f |
702 | /* Print out which obstack an object is in. */ | |
703 | ||
704 | void | |
c4be79d2 | 705 | print_obstack_name (object, file, prefix) |
c6a1db6c | 706 | char *object; |
c4be79d2 | 707 | FILE *file; |
37b37199 | 708 | const char *prefix; |
c6a1db6c RS |
709 | { |
710 | struct obstack *obstack = NULL; | |
37b37199 | 711 | const char *obstack_name = NULL; |
c6a1db6c RS |
712 | struct function *p; |
713 | ||
714 | for (p = outer_function_chain; p; p = p->next) | |
715 | { | |
716 | if (_obstack_allocated_p (p->function_obstack, object)) | |
717 | { | |
718 | obstack = p->function_obstack; | |
719 | obstack_name = "containing function obstack"; | |
720 | } | |
721 | if (_obstack_allocated_p (p->function_maybepermanent_obstack, object)) | |
722 | { | |
723 | obstack = p->function_maybepermanent_obstack; | |
724 | obstack_name = "containing function maybepermanent obstack"; | |
725 | } | |
726 | } | |
727 | ||
728 | if (_obstack_allocated_p (&obstack_stack_obstack, object)) | |
729 | { | |
730 | obstack = &obstack_stack_obstack; | |
731 | obstack_name = "obstack_stack_obstack"; | |
732 | } | |
733 | else if (_obstack_allocated_p (function_obstack, object)) | |
734 | { | |
735 | obstack = function_obstack; | |
736 | obstack_name = "function obstack"; | |
737 | } | |
738 | else if (_obstack_allocated_p (&permanent_obstack, object)) | |
739 | { | |
740 | obstack = &permanent_obstack; | |
741 | obstack_name = "permanent_obstack"; | |
742 | } | |
743 | else if (_obstack_allocated_p (&momentary_obstack, object)) | |
744 | { | |
745 | obstack = &momentary_obstack; | |
746 | obstack_name = "momentary_obstack"; | |
747 | } | |
748 | else if (_obstack_allocated_p (function_maybepermanent_obstack, object)) | |
749 | { | |
750 | obstack = function_maybepermanent_obstack; | |
751 | obstack_name = "function maybepermanent obstack"; | |
752 | } | |
753 | else if (_obstack_allocated_p (&temp_decl_obstack, object)) | |
754 | { | |
755 | obstack = &temp_decl_obstack; | |
756 | obstack_name = "temp_decl_obstack"; | |
757 | } | |
758 | ||
0f41302f | 759 | /* Check to see if the object is in the free area of the obstack. */ |
c6a1db6c RS |
760 | if (obstack != NULL) |
761 | { | |
762 | if (object >= obstack->next_free | |
763 | && object < obstack->chunk_limit) | |
c4be79d2 RK |
764 | fprintf (file, "%s in free portion of obstack %s", |
765 | prefix, obstack_name); | |
c6a1db6c | 766 | else |
c4be79d2 | 767 | fprintf (file, "%s allocated from %s", prefix, obstack_name); |
c6a1db6c RS |
768 | } |
769 | else | |
c4be79d2 RK |
770 | fprintf (file, "%s not allocated from any obstack", prefix); |
771 | } | |
772 | ||
773 | void | |
774 | debug_obstack (object) | |
775 | char *object; | |
776 | { | |
777 | print_obstack_name (object, stderr, "object"); | |
778 | fprintf (stderr, ".\n"); | |
c6a1db6c RS |
779 | } |
780 | ||
781 | /* Return 1 if OBJ is in the permanent obstack. | |
782 | This is slow, and should be used only for debugging. | |
783 | Use TREE_PERMANENT for other purposes. */ | |
784 | ||
785 | int | |
786 | object_permanent_p (obj) | |
787 | tree obj; | |
788 | { | |
789 | return _obstack_allocated_p (&permanent_obstack, obj); | |
790 | } | |
791 | \f | |
792 | /* Start a level of momentary allocation. | |
793 | In C, each compound statement has its own level | |
794 | and that level is freed at the end of each statement. | |
795 | All expression nodes are allocated in the momentary allocation level. */ | |
796 | ||
797 | void | |
798 | push_momentary () | |
799 | { | |
800 | struct momentary_level *tem | |
801 | = (struct momentary_level *) obstack_alloc (&momentary_obstack, | |
802 | sizeof (struct momentary_level)); | |
803 | tem->prev = momentary_stack; | |
804 | tem->base = (char *) obstack_base (&momentary_obstack); | |
805 | tem->obstack = expression_obstack; | |
806 | momentary_stack = tem; | |
807 | expression_obstack = &momentary_obstack; | |
808 | } | |
809 | ||
9e8730a4 RK |
810 | /* Set things up so the next clear_momentary will only clear memory |
811 | past our present position in momentary_obstack. */ | |
812 | ||
813 | void | |
814 | preserve_momentary () | |
815 | { | |
816 | momentary_stack->base = (char *) obstack_base (&momentary_obstack); | |
817 | } | |
818 | ||
c6a1db6c RS |
819 | /* Free all the storage in the current momentary-allocation level. |
820 | In C, this happens at the end of each statement. */ | |
821 | ||
822 | void | |
823 | clear_momentary () | |
824 | { | |
825 | obstack_free (&momentary_obstack, momentary_stack->base); | |
826 | } | |
827 | ||
828 | /* Discard a level of momentary allocation. | |
829 | In C, this happens at the end of each compound statement. | |
830 | Restore the status of expression node allocation | |
831 | that was in effect before this level was created. */ | |
832 | ||
833 | void | |
834 | pop_momentary () | |
835 | { | |
836 | struct momentary_level *tem = momentary_stack; | |
837 | momentary_stack = tem->prev; | |
838 | expression_obstack = tem->obstack; | |
2b417d3c JW |
839 | /* We can't free TEM from the momentary_obstack, because there might |
840 | be objects above it which have been saved. We can free back to the | |
841 | stack of the level we are popping off though. */ | |
842 | obstack_free (&momentary_obstack, tem->base); | |
c6a1db6c RS |
843 | } |
844 | ||
14b6efff RS |
845 | /* Pop back to the previous level of momentary allocation, |
846 | but don't free any momentary data just yet. */ | |
847 | ||
848 | void | |
849 | pop_momentary_nofree () | |
850 | { | |
851 | struct momentary_level *tem = momentary_stack; | |
852 | momentary_stack = tem->prev; | |
853 | expression_obstack = tem->obstack; | |
854 | } | |
855 | ||
c6a1db6c RS |
856 | /* Call when starting to parse a declaration: |
857 | make expressions in the declaration last the length of the function. | |
858 | Returns an argument that should be passed to resume_momentary later. */ | |
859 | ||
860 | int | |
861 | suspend_momentary () | |
862 | { | |
863 | register int tem = expression_obstack == &momentary_obstack; | |
864 | expression_obstack = saveable_obstack; | |
865 | return tem; | |
866 | } | |
867 | ||
868 | /* Call when finished parsing a declaration: | |
869 | restore the treatment of node-allocation that was | |
870 | in effect before the suspension. | |
871 | YES should be the value previously returned by suspend_momentary. */ | |
872 | ||
873 | void | |
874 | resume_momentary (yes) | |
875 | int yes; | |
876 | { | |
877 | if (yes) | |
878 | expression_obstack = &momentary_obstack; | |
879 | } | |
880 | \f | |
881 | /* Init the tables indexed by tree code. | |
882 | Note that languages can add to these tables to define their own codes. */ | |
883 | ||
884 | void | |
885 | init_tree_codes () | |
886 | { | |
d4b60170 RK |
887 | built_in_filename |
888 | = ggc_alloc_string (BUILT_IN_FILENAME, sizeof (BUILT_IN_FILENAME)); | |
5c7261ab | 889 | ggc_add_string_root (&built_in_filename, 1); |
c6a1db6c RS |
890 | } |
891 | ||
892 | /* Return a newly allocated node of code CODE. | |
893 | Initialize the node's unique id and its TREE_PERMANENT flag. | |
23dfa477 ZW |
894 | Note that if garbage collection is in use, TREE_PERMANENT will |
895 | always be zero - we want to eliminate use of TREE_PERMANENT. | |
c6a1db6c RS |
896 | For decl and type nodes, some other fields are initialized. |
897 | The rest of the node is initialized to zero. | |
898 | ||
899 | Achoo! I got a code in the node. */ | |
900 | ||
901 | tree | |
902 | make_node (code) | |
903 | enum tree_code code; | |
904 | { | |
905 | register tree t; | |
906 | register int type = TREE_CODE_CLASS (code); | |
c16ddde3 | 907 | register int length = 0; |
c6a1db6c | 908 | register struct obstack *obstack = current_obstack; |
5e9defae | 909 | #ifdef GATHER_STATISTICS |
c6a1db6c | 910 | register tree_node_kind kind; |
5e9defae | 911 | #endif |
c6a1db6c RS |
912 | |
913 | switch (type) | |
914 | { | |
915 | case 'd': /* A decl node */ | |
916 | #ifdef GATHER_STATISTICS | |
917 | kind = d_kind; | |
918 | #endif | |
919 | length = sizeof (struct tree_decl); | |
920 | /* All decls in an inline function need to be saved. */ | |
921 | if (obstack != &permanent_obstack) | |
922 | obstack = saveable_obstack; | |
f52b5958 RK |
923 | |
924 | /* PARM_DECLs go on the context of the parent. If this is a nested | |
925 | function, then we must allocate the PARM_DECL on the parent's | |
926 | obstack, so that they will live to the end of the parent's | |
9faa82d8 | 927 | closing brace. This is necessary in case we try to inline the |
f52b5958 RK |
928 | function into its parent. |
929 | ||
930 | PARM_DECLs of top-level functions do not have this problem. However, | |
9faa82d8 | 931 | we allocate them where we put the FUNCTION_DECL for languages such as |
f52b5958 | 932 | Ada that need to consult some flags in the PARM_DECLs of the function |
19e7d354 RK |
933 | when calling it. |
934 | ||
935 | See comment in restore_tree_status for why we can't put this | |
936 | in function_obstack. */ | |
937 | if (code == PARM_DECL && obstack != &permanent_obstack) | |
e97b2a1c JW |
938 | { |
939 | tree context = 0; | |
940 | if (current_function_decl) | |
941 | context = decl_function_context (current_function_decl); | |
f52b5958 | 942 | |
e97b2a1c | 943 | if (context) |
f52b5958 | 944 | obstack |
19e7d354 | 945 | = find_function_data (context)->function_maybepermanent_obstack; |
e97b2a1c | 946 | } |
c6a1db6c RS |
947 | break; |
948 | ||
949 | case 't': /* a type node */ | |
950 | #ifdef GATHER_STATISTICS | |
951 | kind = t_kind; | |
952 | #endif | |
953 | length = sizeof (struct tree_type); | |
954 | /* All data types are put where we can preserve them if nec. */ | |
955 | if (obstack != &permanent_obstack) | |
956 | obstack = all_types_permanent ? &permanent_obstack : saveable_obstack; | |
957 | break; | |
958 | ||
03646189 RS |
959 | case 'b': /* a lexical block */ |
960 | #ifdef GATHER_STATISTICS | |
961 | kind = b_kind; | |
962 | #endif | |
963 | length = sizeof (struct tree_block); | |
964 | /* All BLOCK nodes are put where we can preserve them if nec. */ | |
965 | if (obstack != &permanent_obstack) | |
966 | obstack = saveable_obstack; | |
967 | break; | |
968 | ||
c6a1db6c RS |
969 | case 's': /* an expression with side effects */ |
970 | #ifdef GATHER_STATISTICS | |
971 | kind = s_kind; | |
972 | goto usual_kind; | |
973 | #endif | |
974 | case 'r': /* a reference */ | |
975 | #ifdef GATHER_STATISTICS | |
976 | kind = r_kind; | |
977 | goto usual_kind; | |
978 | #endif | |
979 | case 'e': /* an expression */ | |
980 | case '<': /* a comparison expression */ | |
981 | case '1': /* a unary arithmetic expression */ | |
982 | case '2': /* a binary arithmetic expression */ | |
983 | #ifdef GATHER_STATISTICS | |
984 | kind = e_kind; | |
985 | usual_kind: | |
986 | #endif | |
987 | obstack = expression_obstack; | |
03646189 RS |
988 | /* All BIND_EXPR nodes are put where we can preserve them if nec. */ |
989 | if (code == BIND_EXPR && obstack != &permanent_obstack) | |
c6a1db6c RS |
990 | obstack = saveable_obstack; |
991 | length = sizeof (struct tree_exp) | |
992 | + (tree_code_length[(int) code] - 1) * sizeof (char *); | |
993 | break; | |
994 | ||
995 | case 'c': /* a constant */ | |
996 | #ifdef GATHER_STATISTICS | |
997 | kind = c_kind; | |
998 | #endif | |
999 | obstack = expression_obstack; | |
66212c2f RK |
1000 | |
1001 | /* We can't use tree_code_length for INTEGER_CST, since the number of | |
1002 | words is machine-dependent due to varying length of HOST_WIDE_INT, | |
1003 | which might be wider than a pointer (e.g., long long). Similarly | |
1004 | for REAL_CST, since the number of words is machine-dependent due | |
1005 | to varying size and alignment of `double'. */ | |
1006 | ||
1007 | if (code == INTEGER_CST) | |
1008 | length = sizeof (struct tree_int_cst); | |
1009 | else if (code == REAL_CST) | |
1010 | length = sizeof (struct tree_real_cst); | |
1011 | else | |
1012 | length = sizeof (struct tree_common) | |
1013 | + tree_code_length[(int) code] * sizeof (char *); | |
1014 | break; | |
c6a1db6c RS |
1015 | |
1016 | case 'x': /* something random, like an identifier. */ | |
1017 | #ifdef GATHER_STATISTICS | |
1018 | if (code == IDENTIFIER_NODE) | |
1019 | kind = id_kind; | |
1020 | else if (code == OP_IDENTIFIER) | |
1021 | kind = op_id_kind; | |
1022 | else if (code == TREE_VEC) | |
1023 | kind = vec_kind; | |
1024 | else | |
1025 | kind = x_kind; | |
1026 | #endif | |
1027 | length = sizeof (struct tree_common) | |
1028 | + tree_code_length[(int) code] * sizeof (char *); | |
1029 | /* Identifier nodes are always permanent since they are | |
1030 | unique in a compiler run. */ | |
1031 | if (code == IDENTIFIER_NODE) obstack = &permanent_obstack; | |
a7fcb968 RK |
1032 | break; |
1033 | ||
1034 | default: | |
1035 | abort (); | |
c6a1db6c RS |
1036 | } |
1037 | ||
a3770a81 RH |
1038 | if (ggc_p) |
1039 | t = ggc_alloc_tree (length); | |
1040 | else | |
1041 | { | |
1042 | t = (tree) obstack_alloc (obstack, length); | |
1fef02f6 | 1043 | memset ((PTR) t, 0, length); |
a3770a81 | 1044 | } |
c6a1db6c RS |
1045 | |
1046 | #ifdef GATHER_STATISTICS | |
1047 | tree_node_counts[(int)kind]++; | |
1048 | tree_node_sizes[(int)kind] += length; | |
1049 | #endif | |
1050 | ||
c6a1db6c | 1051 | TREE_SET_CODE (t, code); |
23dfa477 | 1052 | TREE_SET_PERMANENT (t); |
c6a1db6c RS |
1053 | |
1054 | switch (type) | |
1055 | { | |
1056 | case 's': | |
1057 | TREE_SIDE_EFFECTS (t) = 1; | |
1058 | TREE_TYPE (t) = void_type_node; | |
1059 | break; | |
1060 | ||
1061 | case 'd': | |
c0920bf9 | 1062 | if (code != FUNCTION_DECL) |
c7ee7249 | 1063 | DECL_ALIGN (t) = 1; |
23dfa477 | 1064 | DECL_IN_SYSTEM_HEADER (t) = in_system_header; |
c6a1db6c | 1065 | DECL_SOURCE_LINE (t) = lineno; |
5c7261ab AS |
1066 | DECL_SOURCE_FILE (t) = |
1067 | (input_filename) ? input_filename : built_in_filename; | |
0e77444b | 1068 | DECL_UID (t) = next_decl_uid++; |
3932261a MM |
1069 | /* Note that we have not yet computed the alias set for this |
1070 | declaration. */ | |
1071 | DECL_POINTER_ALIAS_SET (t) = -1; | |
c6a1db6c RS |
1072 | break; |
1073 | ||
1074 | case 't': | |
579f50b6 | 1075 | TYPE_UID (t) = next_type_uid++; |
c6a1db6c RS |
1076 | TYPE_ALIGN (t) = 1; |
1077 | TYPE_MAIN_VARIANT (t) = t; | |
d9cbc259 | 1078 | TYPE_OBSTACK (t) = obstack; |
91e97eb8 RK |
1079 | TYPE_ATTRIBUTES (t) = NULL_TREE; |
1080 | #ifdef SET_DEFAULT_TYPE_ATTRIBUTES | |
1081 | SET_DEFAULT_TYPE_ATTRIBUTES (t); | |
1082 | #endif | |
41472af8 MM |
1083 | /* Note that we have not yet computed the alias set for this |
1084 | type. */ | |
1085 | TYPE_ALIAS_SET (t) = -1; | |
c6a1db6c RS |
1086 | break; |
1087 | ||
1088 | case 'c': | |
1089 | TREE_CONSTANT (t) = 1; | |
1090 | break; | |
783feeb0 MM |
1091 | |
1092 | case 'e': | |
1093 | switch (code) | |
1094 | { | |
1095 | case INIT_EXPR: | |
1096 | case MODIFY_EXPR: | |
1097 | case VA_ARG_EXPR: | |
1098 | case RTL_EXPR: | |
1099 | case PREDECREMENT_EXPR: | |
1100 | case PREINCREMENT_EXPR: | |
1101 | case POSTDECREMENT_EXPR: | |
1102 | case POSTINCREMENT_EXPR: | |
1103 | /* All of these have side-effects, no matter what their | |
1104 | operands are. */ | |
1105 | TREE_SIDE_EFFECTS (t) = 1; | |
1106 | break; | |
1107 | ||
1108 | default: | |
1109 | break; | |
1110 | } | |
1111 | break; | |
c6a1db6c RS |
1112 | } |
1113 | ||
1114 | return t; | |
1115 | } | |
0f4fd75d FS |
1116 | |
1117 | /* A front-end can reset this to an appropriate function if types need | |
1118 | special handling. */ | |
1119 | ||
58782098 | 1120 | tree (*make_lang_type_fn) PARAMS ((enum tree_code)) = make_node; |
0f4fd75d FS |
1121 | |
1122 | /* Return a new type (with the indicated CODE), doing whatever | |
1123 | language-specific processing is required. */ | |
1124 | ||
1125 | tree | |
1126 | make_lang_type (code) | |
1127 | enum tree_code code; | |
1128 | { | |
1129 | return (*make_lang_type_fn) (code); | |
1130 | } | |
c6a1db6c | 1131 | \f |
c3da6f12 MM |
1132 | /* Return a new node with the same contents as NODE except that its |
1133 | TREE_CHAIN is zero and it has a fresh uid. Unlike make_node, this | |
1134 | function always performs the allocation on the CURRENT_OBSTACK; | |
1135 | it's up to the caller to pick the right obstack before calling this | |
1136 | function. */ | |
c6a1db6c RS |
1137 | |
1138 | tree | |
1139 | copy_node (node) | |
1140 | tree node; | |
1141 | { | |
1142 | register tree t; | |
1143 | register enum tree_code code = TREE_CODE (node); | |
4e86caed | 1144 | register int length = 0; |
c6a1db6c RS |
1145 | |
1146 | switch (TREE_CODE_CLASS (code)) | |
1147 | { | |
1148 | case 'd': /* A decl node */ | |
1149 | length = sizeof (struct tree_decl); | |
1150 | break; | |
1151 | ||
1152 | case 't': /* a type node */ | |
1153 | length = sizeof (struct tree_type); | |
1154 | break; | |
1155 | ||
03646189 RS |
1156 | case 'b': /* a lexical block node */ |
1157 | length = sizeof (struct tree_block); | |
1158 | break; | |
1159 | ||
c6a1db6c | 1160 | case 'r': /* a reference */ |
858a47b1 | 1161 | case 'e': /* an expression */ |
c6a1db6c RS |
1162 | case 's': /* an expression with side effects */ |
1163 | case '<': /* a comparison expression */ | |
1164 | case '1': /* a unary arithmetic expression */ | |
1165 | case '2': /* a binary arithmetic expression */ | |
1166 | length = sizeof (struct tree_exp) | |
1167 | + (tree_code_length[(int) code] - 1) * sizeof (char *); | |
1168 | break; | |
1169 | ||
1170 | case 'c': /* a constant */ | |
49b08aba RK |
1171 | /* We can't use tree_code_length for INTEGER_CST, since the number of |
1172 | words is machine-dependent due to varying length of HOST_WIDE_INT, | |
1173 | which might be wider than a pointer (e.g., long long). Similarly | |
1174 | for REAL_CST, since the number of words is machine-dependent due | |
1175 | to varying size and alignment of `double'. */ | |
1176 | if (code == INTEGER_CST) | |
b14b8129 | 1177 | length = sizeof (struct tree_int_cst); |
49b08aba | 1178 | else if (code == REAL_CST) |
b14b8129 | 1179 | length = sizeof (struct tree_real_cst); |
ff615e83 | 1180 | else |
b14b8129 RK |
1181 | length = (sizeof (struct tree_common) |
1182 | + tree_code_length[(int) code] * sizeof (char *)); | |
1183 | break; | |
c6a1db6c RS |
1184 | |
1185 | case 'x': /* something random, like an identifier. */ | |
1186 | length = sizeof (struct tree_common) | |
1187 | + tree_code_length[(int) code] * sizeof (char *); | |
1188 | if (code == TREE_VEC) | |
1189 | length += (TREE_VEC_LENGTH (node) - 1) * sizeof (char *); | |
1190 | } | |
1191 | ||
a3770a81 RH |
1192 | if (ggc_p) |
1193 | t = ggc_alloc_tree (length); | |
1194 | else | |
2e28f042 BS |
1195 | t = (tree) obstack_alloc (current_obstack, length); |
1196 | memcpy (t, node, length); | |
c6a1db6c | 1197 | |
1e54d32b | 1198 | TREE_CHAIN (t) = 0; |
69b7087e | 1199 | TREE_ASM_WRITTEN (t) = 0; |
c6a1db6c | 1200 | |
579f50b6 RK |
1201 | if (TREE_CODE_CLASS (code) == 'd') |
1202 | DECL_UID (t) = next_decl_uid++; | |
1203 | else if (TREE_CODE_CLASS (code) == 't') | |
d9cbc259 RK |
1204 | { |
1205 | TYPE_UID (t) = next_type_uid++; | |
1206 | TYPE_OBSTACK (t) = current_obstack; | |
28238567 PB |
1207 | |
1208 | /* The following is so that the debug code for | |
1209 | the copy is different from the original type. | |
1210 | The two statements usually duplicate each other | |
1211 | (because they clear fields of the same union), | |
0f41302f | 1212 | but the optimizer should catch that. */ |
28238567 PB |
1213 | TYPE_SYMTAB_POINTER (t) = 0; |
1214 | TYPE_SYMTAB_ADDRESS (t) = 0; | |
d9cbc259 | 1215 | } |
579f50b6 | 1216 | |
23dfa477 | 1217 | TREE_SET_PERMANENT (t); |
c6a1db6c RS |
1218 | |
1219 | return t; | |
1220 | } | |
1221 | ||
1222 | /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field. | |
1223 | For example, this can copy a list made of TREE_LIST nodes. */ | |
1224 | ||
1225 | tree | |
1226 | copy_list (list) | |
1227 | tree list; | |
1228 | { | |
1229 | tree head; | |
1230 | register tree prev, next; | |
1231 | ||
1232 | if (list == 0) | |
1233 | return 0; | |
1234 | ||
1235 | head = prev = copy_node (list); | |
1236 | next = TREE_CHAIN (list); | |
1237 | while (next) | |
1238 | { | |
1239 | TREE_CHAIN (prev) = copy_node (next); | |
1240 | prev = TREE_CHAIN (prev); | |
1241 | next = TREE_CHAIN (next); | |
1242 | } | |
1243 | return head; | |
1244 | } | |
1245 | \f | |
1246 | #define HASHBITS 30 | |
1247 | ||
1248 | /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string). | |
1249 | If an identifier with that name has previously been referred to, | |
1250 | the same node is returned this time. */ | |
1251 | ||
1252 | tree | |
1253 | get_identifier (text) | |
37b37199 | 1254 | register const char *text; |
c6a1db6c RS |
1255 | { |
1256 | register int hi; | |
1257 | register int i; | |
1258 | register tree idp; | |
1259 | register int len, hash_len; | |
1260 | ||
1261 | /* Compute length of text in len. */ | |
dfa27ef1 | 1262 | len = strlen (text); |
c6a1db6c RS |
1263 | |
1264 | /* Decide how much of that length to hash on */ | |
1265 | hash_len = len; | |
06ceef4e | 1266 | if (warn_id_clash && len > id_clash_len) |
c6a1db6c RS |
1267 | hash_len = id_clash_len; |
1268 | ||
1269 | /* Compute hash code */ | |
0f41302f | 1270 | hi = hash_len * 613 + (unsigned) text[0]; |
c6a1db6c | 1271 | for (i = 1; i < hash_len; i += 2) |
0f41302f | 1272 | hi = ((hi * 613) + (unsigned) (text[i])); |
c6a1db6c RS |
1273 | |
1274 | hi &= (1 << HASHBITS) - 1; | |
1275 | hi %= MAX_HASH_TABLE; | |
1276 | ||
1277 | /* Search table for identifier */ | |
1278 | for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp)) | |
1279 | if (IDENTIFIER_LENGTH (idp) == len | |
1280 | && IDENTIFIER_POINTER (idp)[0] == text[0] | |
1281 | && !bcmp (IDENTIFIER_POINTER (idp), text, len)) | |
1282 | return idp; /* <-- return if found */ | |
1283 | ||
1284 | /* Not found; optionally warn about a similar identifier */ | |
06ceef4e | 1285 | if (warn_id_clash && do_identifier_warnings && len >= id_clash_len) |
c6a1db6c RS |
1286 | for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp)) |
1287 | if (!strncmp (IDENTIFIER_POINTER (idp), text, id_clash_len)) | |
1288 | { | |
1289 | warning ("`%s' and `%s' identical in first %d characters", | |
1290 | IDENTIFIER_POINTER (idp), text, id_clash_len); | |
1291 | break; | |
1292 | } | |
1293 | ||
1294 | if (tree_code_length[(int) IDENTIFIER_NODE] < 0) | |
1295 | abort (); /* set_identifier_size hasn't been called. */ | |
1296 | ||
1297 | /* Not found, create one, add to chain */ | |
1298 | idp = make_node (IDENTIFIER_NODE); | |
1299 | IDENTIFIER_LENGTH (idp) = len; | |
1300 | #ifdef GATHER_STATISTICS | |
1301 | id_string_size += len; | |
1302 | #endif | |
1303 | ||
a3770a81 RH |
1304 | if (ggc_p) |
1305 | IDENTIFIER_POINTER (idp) = ggc_alloc_string (text, len); | |
1306 | else | |
1307 | IDENTIFIER_POINTER (idp) = obstack_copy0 (&permanent_obstack, text, len); | |
c6a1db6c RS |
1308 | |
1309 | TREE_CHAIN (idp) = hash_table[hi]; | |
1310 | hash_table[hi] = idp; | |
1311 | return idp; /* <-- return if created */ | |
1312 | } | |
1313 | ||
a94dbf2c JM |
1314 | /* If an identifier with the name TEXT (a null-terminated string) has |
1315 | previously been referred to, return that node; otherwise return | |
1316 | NULL_TREE. */ | |
1317 | ||
1318 | tree | |
1319 | maybe_get_identifier (text) | |
37b37199 | 1320 | register const char *text; |
a94dbf2c JM |
1321 | { |
1322 | register int hi; | |
1323 | register int i; | |
1324 | register tree idp; | |
1325 | register int len, hash_len; | |
1326 | ||
1327 | /* Compute length of text in len. */ | |
dfa27ef1 | 1328 | len = strlen (text); |
a94dbf2c JM |
1329 | |
1330 | /* Decide how much of that length to hash on */ | |
1331 | hash_len = len; | |
06ceef4e | 1332 | if (warn_id_clash && len > id_clash_len) |
a94dbf2c JM |
1333 | hash_len = id_clash_len; |
1334 | ||
1335 | /* Compute hash code */ | |
1336 | hi = hash_len * 613 + (unsigned) text[0]; | |
1337 | for (i = 1; i < hash_len; i += 2) | |
1338 | hi = ((hi * 613) + (unsigned) (text[i])); | |
1339 | ||
1340 | hi &= (1 << HASHBITS) - 1; | |
1341 | hi %= MAX_HASH_TABLE; | |
1342 | ||
1343 | /* Search table for identifier */ | |
1344 | for (idp = hash_table[hi]; idp; idp = TREE_CHAIN (idp)) | |
1345 | if (IDENTIFIER_LENGTH (idp) == len | |
1346 | && IDENTIFIER_POINTER (idp)[0] == text[0] | |
1347 | && !bcmp (IDENTIFIER_POINTER (idp), text, len)) | |
1348 | return idp; /* <-- return if found */ | |
1349 | ||
1350 | return NULL_TREE; | |
1351 | } | |
1352 | ||
c6a1db6c RS |
1353 | /* Enable warnings on similar identifiers (if requested). |
1354 | Done after the built-in identifiers are created. */ | |
1355 | ||
1356 | void | |
1357 | start_identifier_warnings () | |
1358 | { | |
1359 | do_identifier_warnings = 1; | |
1360 | } | |
1361 | ||
1362 | /* Record the size of an identifier node for the language in use. | |
1363 | SIZE is the total size in bytes. | |
1364 | This is called by the language-specific files. This must be | |
1365 | called before allocating any identifiers. */ | |
1366 | ||
1367 | void | |
1368 | set_identifier_size (size) | |
1369 | int size; | |
1370 | { | |
1371 | tree_code_length[(int) IDENTIFIER_NODE] | |
1372 | = (size - sizeof (struct tree_common)) / sizeof (tree); | |
1373 | } | |
1374 | \f | |
1375 | /* Return a newly constructed INTEGER_CST node whose constant value | |
1376 | is specified by the two ints LOW and HI. | |
37366632 RK |
1377 | The TREE_TYPE is set to `int'. |
1378 | ||
1379 | This function should be used via the `build_int_2' macro. */ | |
c6a1db6c RS |
1380 | |
1381 | tree | |
37366632 RK |
1382 | build_int_2_wide (low, hi) |
1383 | HOST_WIDE_INT low, hi; | |
c6a1db6c RS |
1384 | { |
1385 | register tree t = make_node (INTEGER_CST); | |
d4b60170 | 1386 | |
c6a1db6c RS |
1387 | TREE_INT_CST_LOW (t) = low; |
1388 | TREE_INT_CST_HIGH (t) = hi; | |
1389 | TREE_TYPE (t) = integer_type_node; | |
1390 | return t; | |
1391 | } | |
1392 | ||
1393 | /* Return a new REAL_CST node whose type is TYPE and value is D. */ | |
1394 | ||
1395 | tree | |
1396 | build_real (type, d) | |
1397 | tree type; | |
1398 | REAL_VALUE_TYPE d; | |
1399 | { | |
1400 | tree v; | |
0afbe93d | 1401 | int overflow = 0; |
c6a1db6c RS |
1402 | |
1403 | /* Check for valid float value for this type on this target machine; | |
1404 | if not, can print error message and store a valid value in D. */ | |
1405 | #ifdef CHECK_FLOAT_VALUE | |
0afbe93d | 1406 | CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow); |
c6a1db6c RS |
1407 | #endif |
1408 | ||
1409 | v = make_node (REAL_CST); | |
1410 | TREE_TYPE (v) = type; | |
1411 | TREE_REAL_CST (v) = d; | |
0afbe93d | 1412 | TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow; |
c6a1db6c RS |
1413 | return v; |
1414 | } | |
1415 | ||
1416 | /* Return a new REAL_CST node whose type is TYPE | |
1417 | and whose value is the integer value of the INTEGER_CST node I. */ | |
1418 | ||
1419 | #if !defined (REAL_IS_NOT_DOUBLE) || defined (REAL_ARITHMETIC) | |
1420 | ||
1421 | REAL_VALUE_TYPE | |
84c7be4b | 1422 | real_value_from_int_cst (type, i) |
7bdb32b9 | 1423 | tree type ATTRIBUTE_UNUSED, i; |
c6a1db6c RS |
1424 | { |
1425 | REAL_VALUE_TYPE d; | |
2026444a | 1426 | |
c6a1db6c | 1427 | #ifdef REAL_ARITHMETIC |
e545d37f RK |
1428 | /* Clear all bits of the real value type so that we can later do |
1429 | bitwise comparisons to see if two values are the same. */ | |
1430 | bzero ((char *) &d, sizeof d); | |
1431 | ||
15c76378 | 1432 | if (! TREE_UNSIGNED (TREE_TYPE (i))) |
84c7be4b RK |
1433 | REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i), |
1434 | TYPE_MODE (type)); | |
15c76378 | 1435 | else |
84c7be4b RK |
1436 | REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i), |
1437 | TREE_INT_CST_HIGH (i), TYPE_MODE (type)); | |
c6a1db6c | 1438 | #else /* not REAL_ARITHMETIC */ |
5e9defae KG |
1439 | /* Some 386 compilers mishandle unsigned int to float conversions, |
1440 | so introduce a temporary variable E to avoid those bugs. */ | |
db7e5239 | 1441 | if (TREE_INT_CST_HIGH (i) < 0 && ! TREE_UNSIGNED (TREE_TYPE (i))) |
c6a1db6c | 1442 | { |
5e9defae KG |
1443 | REAL_VALUE_TYPE e; |
1444 | ||
c6a1db6c | 1445 | d = (double) (~ TREE_INT_CST_HIGH (i)); |
2026444a | 1446 | e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) |
37366632 | 1447 | * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))); |
2026444a | 1448 | d *= e; |
05bccae2 | 1449 | e = (double) (~ TREE_INT_CST_LOW (i)); |
2026444a | 1450 | d += e; |
c6a1db6c RS |
1451 | d = (- d - 1.0); |
1452 | } | |
1453 | else | |
1454 | { | |
5e9defae KG |
1455 | REAL_VALUE_TYPE e; |
1456 | ||
db7e5239 | 1457 | d = (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (i); |
2026444a | 1458 | e = ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)) |
37366632 | 1459 | * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))); |
2026444a | 1460 | d *= e; |
05bccae2 | 1461 | e = (double) TREE_INT_CST_LOW (i); |
2026444a | 1462 | d += e; |
c6a1db6c RS |
1463 | } |
1464 | #endif /* not REAL_ARITHMETIC */ | |
1465 | return d; | |
1466 | } | |
1467 | ||
d4b60170 RK |
1468 | /* Args to pass to and from build_real_from_int_cst_1. */ |
1469 | ||
1a87eea2 KG |
1470 | struct brfic_args |
1471 | { | |
d4b60170 RK |
1472 | tree type; /* Input: type to conver to. */ |
1473 | tree i; /* Input: operand to convert */ | |
1474 | REAL_VALUE_TYPE d; /* Output: floating point value. */ | |
1a87eea2 KG |
1475 | }; |
1476 | ||
d4b60170 RK |
1477 | /* Convert an integer to a floating point value while protected by a floating |
1478 | point exception handler. */ | |
1479 | ||
1a87eea2 KG |
1480 | static void |
1481 | build_real_from_int_cst_1 (data) | |
1482 | PTR data; | |
1483 | { | |
d4b60170 | 1484 | struct brfic_args *args = (struct brfic_args *) data; |
1a87eea2 KG |
1485 | |
1486 | #ifdef REAL_ARITHMETIC | |
1487 | args->d = real_value_from_int_cst (args->type, args->i); | |
1488 | #else | |
d4b60170 RK |
1489 | args->d |
1490 | = REAL_VALUE_TRUNCATE (TYPE_MODE (args->type), | |
1491 | real_value_from_int_cst (args->type, args->i)); | |
1a87eea2 KG |
1492 | #endif |
1493 | } | |
1494 | ||
d4b60170 RK |
1495 | /* Given a tree representing an integer constant I, return a tree |
1496 | representing the same value as a floating-point constant of type TYPE. | |
1497 | We cannot perform this operation if there is no way of doing arithmetic | |
1498 | on floating-point values. */ | |
c6a1db6c RS |
1499 | |
1500 | tree | |
1501 | build_real_from_int_cst (type, i) | |
1502 | tree type; | |
1503 | tree i; | |
1504 | { | |
1505 | tree v; | |
53d74c3c | 1506 | int overflow = TREE_OVERFLOW (i); |
c6a1db6c | 1507 | REAL_VALUE_TYPE d; |
1a87eea2 | 1508 | struct brfic_args args; |
c6a1db6c RS |
1509 | |
1510 | v = make_node (REAL_CST); | |
1511 | TREE_TYPE (v) = type; | |
1512 | ||
1a87eea2 KG |
1513 | /* Setup input for build_real_from_int_cst_1() */ |
1514 | args.type = type; | |
1515 | args.i = i; | |
1516 | ||
1517 | if (do_float_handler (build_real_from_int_cst_1, (PTR) &args)) | |
d4b60170 RK |
1518 | /* Receive output from build_real_from_int_cst_1() */ |
1519 | d = args.d; | |
1a87eea2 KG |
1520 | else |
1521 | { | |
1522 | /* We got an exception from build_real_from_int_cst_1() */ | |
53d74c3c RK |
1523 | d = dconst0; |
1524 | overflow = 1; | |
53d74c3c | 1525 | } |
1a87eea2 | 1526 | |
53d74c3c RK |
1527 | /* Check for valid float value for this type on this target machine. */ |
1528 | ||
c6a1db6c | 1529 | #ifdef CHECK_FLOAT_VALUE |
53d74c3c | 1530 | CHECK_FLOAT_VALUE (TYPE_MODE (type), d, overflow); |
c6a1db6c RS |
1531 | #endif |
1532 | ||
1533 | TREE_REAL_CST (v) = d; | |
53d74c3c | 1534 | TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow; |
c6a1db6c RS |
1535 | return v; |
1536 | } | |
1537 | ||
1538 | #endif /* not REAL_IS_NOT_DOUBLE, or REAL_ARITHMETIC */ | |
1539 | ||
1540 | /* Return a newly constructed STRING_CST node whose value is | |
1541 | the LEN characters at STR. | |
1542 | The TREE_TYPE is not initialized. */ | |
1543 | ||
1544 | tree | |
1545 | build_string (len, str) | |
1546 | int len; | |
37b37199 | 1547 | const char *str; |
c6a1db6c | 1548 | { |
526a6253 RK |
1549 | /* Put the string in saveable_obstack since it will be placed in the RTL |
1550 | for an "asm" statement and will also be kept around a while if | |
1551 | deferring constant output in varasm.c. */ | |
1552 | ||
c6a1db6c | 1553 | register tree s = make_node (STRING_CST); |
d4b60170 | 1554 | |
c6a1db6c | 1555 | TREE_STRING_LENGTH (s) = len; |
a3770a81 RH |
1556 | if (ggc_p) |
1557 | TREE_STRING_POINTER (s) = ggc_alloc_string (str, len); | |
1558 | else | |
1559 | TREE_STRING_POINTER (s) = obstack_copy0 (saveable_obstack, str, len); | |
d4b60170 | 1560 | |
c6a1db6c RS |
1561 | return s; |
1562 | } | |
1563 | ||
1564 | /* Return a newly constructed COMPLEX_CST node whose value is | |
1565 | specified by the real and imaginary parts REAL and IMAG. | |
b217d7fe RK |
1566 | Both REAL and IMAG should be constant nodes. TYPE, if specified, |
1567 | will be the type of the COMPLEX_CST; otherwise a new type will be made. */ | |
c6a1db6c RS |
1568 | |
1569 | tree | |
b217d7fe RK |
1570 | build_complex (type, real, imag) |
1571 | tree type; | |
c6a1db6c RS |
1572 | tree real, imag; |
1573 | { | |
1574 | register tree t = make_node (COMPLEX_CST); | |
53d74c3c | 1575 | |
c6a1db6c RS |
1576 | TREE_REALPART (t) = real; |
1577 | TREE_IMAGPART (t) = imag; | |
b217d7fe | 1578 | TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real)); |
53d74c3c RK |
1579 | TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag); |
1580 | TREE_CONSTANT_OVERFLOW (t) | |
1581 | = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag); | |
c6a1db6c RS |
1582 | return t; |
1583 | } | |
1584 | ||
1585 | /* Build a newly constructed TREE_VEC node of length LEN. */ | |
0f41302f | 1586 | |
c6a1db6c RS |
1587 | tree |
1588 | make_tree_vec (len) | |
1589 | int len; | |
1590 | { | |
1591 | register tree t; | |
1592 | register int length = (len-1) * sizeof (tree) + sizeof (struct tree_vec); | |
1593 | register struct obstack *obstack = current_obstack; | |
c6a1db6c RS |
1594 | |
1595 | #ifdef GATHER_STATISTICS | |
1596 | tree_node_counts[(int)vec_kind]++; | |
1597 | tree_node_sizes[(int)vec_kind] += length; | |
1598 | #endif | |
1599 | ||
a3770a81 RH |
1600 | if (ggc_p) |
1601 | t = ggc_alloc_tree (length); | |
1602 | else | |
1603 | { | |
1604 | t = (tree) obstack_alloc (obstack, length); | |
1605 | bzero ((PTR) t, length); | |
1606 | } | |
508f8149 | 1607 | |
c6a1db6c RS |
1608 | TREE_SET_CODE (t, TREE_VEC); |
1609 | TREE_VEC_LENGTH (t) = len; | |
23dfa477 | 1610 | TREE_SET_PERMANENT (t); |
c6a1db6c RS |
1611 | |
1612 | return t; | |
1613 | } | |
1614 | \f | |
9ad265b0 RK |
1615 | /* Return 1 if EXPR is the integer constant zero or a complex constant |
1616 | of zero. */ | |
c6a1db6c RS |
1617 | |
1618 | int | |
1619 | integer_zerop (expr) | |
1620 | tree expr; | |
1621 | { | |
d964285c | 1622 | STRIP_NOPS (expr); |
c6a1db6c | 1623 | |
9ad265b0 | 1624 | return ((TREE_CODE (expr) == INTEGER_CST |
1ac876be | 1625 | && ! TREE_CONSTANT_OVERFLOW (expr) |
9ad265b0 RK |
1626 | && TREE_INT_CST_LOW (expr) == 0 |
1627 | && TREE_INT_CST_HIGH (expr) == 0) | |
1628 | || (TREE_CODE (expr) == COMPLEX_CST | |
1629 | && integer_zerop (TREE_REALPART (expr)) | |
1630 | && integer_zerop (TREE_IMAGPART (expr)))); | |
c6a1db6c RS |
1631 | } |
1632 | ||
9ad265b0 RK |
1633 | /* Return 1 if EXPR is the integer constant one or the corresponding |
1634 | complex constant. */ | |
c6a1db6c RS |
1635 | |
1636 | int | |
1637 | integer_onep (expr) | |
1638 | tree expr; | |
1639 | { | |
d964285c | 1640 | STRIP_NOPS (expr); |
c6a1db6c | 1641 | |
9ad265b0 | 1642 | return ((TREE_CODE (expr) == INTEGER_CST |
1ac876be | 1643 | && ! TREE_CONSTANT_OVERFLOW (expr) |
9ad265b0 RK |
1644 | && TREE_INT_CST_LOW (expr) == 1 |
1645 | && TREE_INT_CST_HIGH (expr) == 0) | |
1646 | || (TREE_CODE (expr) == COMPLEX_CST | |
1647 | && integer_onep (TREE_REALPART (expr)) | |
1648 | && integer_zerop (TREE_IMAGPART (expr)))); | |
c6a1db6c RS |
1649 | } |
1650 | ||
9ad265b0 RK |
1651 | /* Return 1 if EXPR is an integer containing all 1's in as much precision as |
1652 | it contains. Likewise for the corresponding complex constant. */ | |
c6a1db6c RS |
1653 | |
1654 | int | |
1655 | integer_all_onesp (expr) | |
1656 | tree expr; | |
1657 | { | |
1658 | register int prec; | |
1659 | register int uns; | |
1660 | ||
d964285c | 1661 | STRIP_NOPS (expr); |
c6a1db6c | 1662 | |
9ad265b0 RK |
1663 | if (TREE_CODE (expr) == COMPLEX_CST |
1664 | && integer_all_onesp (TREE_REALPART (expr)) | |
1665 | && integer_zerop (TREE_IMAGPART (expr))) | |
1666 | return 1; | |
1667 | ||
1ac876be RK |
1668 | else if (TREE_CODE (expr) != INTEGER_CST |
1669 | || TREE_CONSTANT_OVERFLOW (expr)) | |
c6a1db6c RS |
1670 | return 0; |
1671 | ||
1672 | uns = TREE_UNSIGNED (TREE_TYPE (expr)); | |
1673 | if (!uns) | |
05bccae2 RK |
1674 | return (TREE_INT_CST_LOW (expr) == ~ (unsigned HOST_WIDE_INT) 0 |
1675 | && TREE_INT_CST_HIGH (expr) == -1); | |
c6a1db6c | 1676 | |
8980b5a3 RK |
1677 | /* Note that using TYPE_PRECISION here is wrong. We care about the |
1678 | actual bits, not the (arbitrary) range of the type. */ | |
1679 | prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr))); | |
37366632 | 1680 | if (prec >= HOST_BITS_PER_WIDE_INT) |
c6a1db6c | 1681 | { |
05bccae2 RK |
1682 | HOST_WIDE_INT high_value; |
1683 | int shift_amount; | |
c6a1db6c | 1684 | |
37366632 | 1685 | shift_amount = prec - HOST_BITS_PER_WIDE_INT; |
c6a1db6c | 1686 | |
37366632 | 1687 | if (shift_amount > HOST_BITS_PER_WIDE_INT) |
c6a1db6c RS |
1688 | /* Can not handle precisions greater than twice the host int size. */ |
1689 | abort (); | |
37366632 | 1690 | else if (shift_amount == HOST_BITS_PER_WIDE_INT) |
c6a1db6c RS |
1691 | /* Shifting by the host word size is undefined according to the ANSI |
1692 | standard, so we must handle this as a special case. */ | |
1693 | high_value = -1; | |
1694 | else | |
37366632 | 1695 | high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1; |
c6a1db6c | 1696 | |
05bccae2 RK |
1697 | return (TREE_INT_CST_LOW (expr) == ~ (unsigned HOST_WIDE_INT) 0 |
1698 | && TREE_INT_CST_HIGH (expr) == high_value); | |
c6a1db6c RS |
1699 | } |
1700 | else | |
05bccae2 | 1701 | return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1; |
c6a1db6c RS |
1702 | } |
1703 | ||
1704 | /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only | |
1705 | one bit on). */ | |
1706 | ||
1707 | int | |
1708 | integer_pow2p (expr) | |
1709 | tree expr; | |
1710 | { | |
5cb1f2fa | 1711 | int prec; |
37366632 | 1712 | HOST_WIDE_INT high, low; |
c6a1db6c | 1713 | |
d964285c | 1714 | STRIP_NOPS (expr); |
c6a1db6c | 1715 | |
9ad265b0 RK |
1716 | if (TREE_CODE (expr) == COMPLEX_CST |
1717 | && integer_pow2p (TREE_REALPART (expr)) | |
1718 | && integer_zerop (TREE_IMAGPART (expr))) | |
1719 | return 1; | |
1720 | ||
1ac876be | 1721 | if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr)) |
c6a1db6c RS |
1722 | return 0; |
1723 | ||
e5e809f4 | 1724 | prec = (POINTER_TYPE_P (TREE_TYPE (expr)) |
5cb1f2fa | 1725 | ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr))); |
c6a1db6c RS |
1726 | high = TREE_INT_CST_HIGH (expr); |
1727 | low = TREE_INT_CST_LOW (expr); | |
1728 | ||
5cb1f2fa RK |
1729 | /* First clear all bits that are beyond the type's precision in case |
1730 | we've been sign extended. */ | |
1731 | ||
1732 | if (prec == 2 * HOST_BITS_PER_WIDE_INT) | |
1733 | ; | |
1734 | else if (prec > HOST_BITS_PER_WIDE_INT) | |
1735 | high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); | |
1736 | else | |
1737 | { | |
1738 | high = 0; | |
1739 | if (prec < HOST_BITS_PER_WIDE_INT) | |
1740 | low &= ~((HOST_WIDE_INT) (-1) << prec); | |
1741 | } | |
1742 | ||
c6a1db6c RS |
1743 | if (high == 0 && low == 0) |
1744 | return 0; | |
1745 | ||
1746 | return ((high == 0 && (low & (low - 1)) == 0) | |
1747 | || (low == 0 && (high & (high - 1)) == 0)); | |
1748 | } | |
1749 | ||
5cb1f2fa RK |
1750 | /* Return the power of two represented by a tree node known to be a |
1751 | power of two. */ | |
1752 | ||
1753 | int | |
1754 | tree_log2 (expr) | |
1755 | tree expr; | |
1756 | { | |
1757 | int prec; | |
1758 | HOST_WIDE_INT high, low; | |
1759 | ||
1760 | STRIP_NOPS (expr); | |
1761 | ||
1762 | if (TREE_CODE (expr) == COMPLEX_CST) | |
1763 | return tree_log2 (TREE_REALPART (expr)); | |
1764 | ||
e5e809f4 | 1765 | prec = (POINTER_TYPE_P (TREE_TYPE (expr)) |
5cb1f2fa RK |
1766 | ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr))); |
1767 | ||
1768 | high = TREE_INT_CST_HIGH (expr); | |
1769 | low = TREE_INT_CST_LOW (expr); | |
1770 | ||
1771 | /* First clear all bits that are beyond the type's precision in case | |
1772 | we've been sign extended. */ | |
1773 | ||
1774 | if (prec == 2 * HOST_BITS_PER_WIDE_INT) | |
1775 | ; | |
1776 | else if (prec > HOST_BITS_PER_WIDE_INT) | |
1777 | high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); | |
1778 | else | |
1779 | { | |
1780 | high = 0; | |
1781 | if (prec < HOST_BITS_PER_WIDE_INT) | |
1782 | low &= ~((HOST_WIDE_INT) (-1) << prec); | |
1783 | } | |
1784 | ||
1785 | return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high) | |
1786 | : exact_log2 (low)); | |
1787 | } | |
1788 | ||
05bccae2 RK |
1789 | /* Similar, but return the largest integer Y such that 2 ** Y is less |
1790 | than or equal to EXPR. */ | |
1791 | ||
1792 | int | |
1793 | tree_floor_log2 (expr) | |
1794 | tree expr; | |
1795 | { | |
1796 | int prec; | |
1797 | HOST_WIDE_INT high, low; | |
1798 | ||
1799 | STRIP_NOPS (expr); | |
1800 | ||
1801 | if (TREE_CODE (expr) == COMPLEX_CST) | |
1802 | return tree_log2 (TREE_REALPART (expr)); | |
1803 | ||
1804 | prec = (POINTER_TYPE_P (TREE_TYPE (expr)) | |
1805 | ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr))); | |
1806 | ||
1807 | high = TREE_INT_CST_HIGH (expr); | |
1808 | low = TREE_INT_CST_LOW (expr); | |
1809 | ||
1810 | /* First clear all bits that are beyond the type's precision in case | |
1811 | we've been sign extended. Ignore if type's precision hasn't been set | |
1812 | since what we are doing is setting it. */ | |
1813 | ||
1814 | if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0) | |
1815 | ; | |
1816 | else if (prec > HOST_BITS_PER_WIDE_INT) | |
1817 | high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); | |
1818 | else | |
1819 | { | |
1820 | high = 0; | |
1821 | if (prec < HOST_BITS_PER_WIDE_INT) | |
1822 | low &= ~((HOST_WIDE_INT) (-1) << prec); | |
1823 | } | |
1824 | ||
1825 | return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high) | |
1826 | : floor_log2 (low)); | |
1827 | } | |
1828 | ||
c6a1db6c RS |
1829 | /* Return 1 if EXPR is the real constant zero. */ |
1830 | ||
1831 | int | |
1832 | real_zerop (expr) | |
1833 | tree expr; | |
1834 | { | |
d964285c | 1835 | STRIP_NOPS (expr); |
c6a1db6c | 1836 | |
9ad265b0 | 1837 | return ((TREE_CODE (expr) == REAL_CST |
1ac876be | 1838 | && ! TREE_CONSTANT_OVERFLOW (expr) |
9ad265b0 RK |
1839 | && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)) |
1840 | || (TREE_CODE (expr) == COMPLEX_CST | |
1841 | && real_zerop (TREE_REALPART (expr)) | |
1842 | && real_zerop (TREE_IMAGPART (expr)))); | |
c6a1db6c RS |
1843 | } |
1844 | ||
9ad265b0 | 1845 | /* Return 1 if EXPR is the real constant one in real or complex form. */ |
c6a1db6c RS |
1846 | |
1847 | int | |
1848 | real_onep (expr) | |
1849 | tree expr; | |
1850 | { | |
d964285c | 1851 | STRIP_NOPS (expr); |
c6a1db6c | 1852 | |
9ad265b0 | 1853 | return ((TREE_CODE (expr) == REAL_CST |
1ac876be | 1854 | && ! TREE_CONSTANT_OVERFLOW (expr) |
9ad265b0 RK |
1855 | && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)) |
1856 | || (TREE_CODE (expr) == COMPLEX_CST | |
1857 | && real_onep (TREE_REALPART (expr)) | |
1858 | && real_zerop (TREE_IMAGPART (expr)))); | |
c6a1db6c RS |
1859 | } |
1860 | ||
1861 | /* Return 1 if EXPR is the real constant two. */ | |
1862 | ||
1863 | int | |
1864 | real_twop (expr) | |
1865 | tree expr; | |
1866 | { | |
d964285c | 1867 | STRIP_NOPS (expr); |
c6a1db6c | 1868 | |
9ad265b0 | 1869 | return ((TREE_CODE (expr) == REAL_CST |
1ac876be | 1870 | && ! TREE_CONSTANT_OVERFLOW (expr) |
9ad265b0 RK |
1871 | && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)) |
1872 | || (TREE_CODE (expr) == COMPLEX_CST | |
1873 | && real_twop (TREE_REALPART (expr)) | |
1874 | && real_zerop (TREE_IMAGPART (expr)))); | |
c6a1db6c RS |
1875 | } |
1876 | ||
1877 | /* Nonzero if EXP is a constant or a cast of a constant. */ | |
1878 | ||
1879 | int | |
1880 | really_constant_p (exp) | |
1881 | tree exp; | |
1882 | { | |
d964285c | 1883 | /* This is not quite the same as STRIP_NOPS. It does more. */ |
c6a1db6c RS |
1884 | while (TREE_CODE (exp) == NOP_EXPR |
1885 | || TREE_CODE (exp) == CONVERT_EXPR | |
1886 | || TREE_CODE (exp) == NON_LVALUE_EXPR) | |
1887 | exp = TREE_OPERAND (exp, 0); | |
1888 | return TREE_CONSTANT (exp); | |
1889 | } | |
1890 | \f | |
1891 | /* Return first list element whose TREE_VALUE is ELEM. | |
2a3c15b5 | 1892 | Return 0 if ELEM is not in LIST. */ |
c6a1db6c RS |
1893 | |
1894 | tree | |
1895 | value_member (elem, list) | |
1896 | tree elem, list; | |
1897 | { | |
1898 | while (list) | |
1899 | { | |
1900 | if (elem == TREE_VALUE (list)) | |
1901 | return list; | |
1902 | list = TREE_CHAIN (list); | |
1903 | } | |
1904 | return NULL_TREE; | |
1905 | } | |
1906 | ||
1907 | /* Return first list element whose TREE_PURPOSE is ELEM. | |
2a3c15b5 | 1908 | Return 0 if ELEM is not in LIST. */ |
c6a1db6c RS |
1909 | |
1910 | tree | |
1911 | purpose_member (elem, list) | |
1912 | tree elem, list; | |
1913 | { | |
1914 | while (list) | |
1915 | { | |
1916 | if (elem == TREE_PURPOSE (list)) | |
1917 | return list; | |
1918 | list = TREE_CHAIN (list); | |
1919 | } | |
1920 | return NULL_TREE; | |
1921 | } | |
1922 | ||
1923 | /* Return first list element whose BINFO_TYPE is ELEM. | |
2a3c15b5 | 1924 | Return 0 if ELEM is not in LIST. */ |
c6a1db6c RS |
1925 | |
1926 | tree | |
1927 | binfo_member (elem, list) | |
1928 | tree elem, list; | |
1929 | { | |
1930 | while (list) | |
1931 | { | |
1932 | if (elem == BINFO_TYPE (list)) | |
1933 | return list; | |
1934 | list = TREE_CHAIN (list); | |
1935 | } | |
1936 | return NULL_TREE; | |
1937 | } | |
1938 | ||
0f41302f | 1939 | /* Return nonzero if ELEM is part of the chain CHAIN. */ |
c6a1db6c RS |
1940 | |
1941 | int | |
1942 | chain_member (elem, chain) | |
1943 | tree elem, chain; | |
1944 | { | |
1945 | while (chain) | |
1946 | { | |
1947 | if (elem == chain) | |
1948 | return 1; | |
1949 | chain = TREE_CHAIN (chain); | |
1950 | } | |
1951 | ||
1952 | return 0; | |
1953 | } | |
1954 | ||
1a2927d2 | 1955 | /* Return nonzero if ELEM is equal to TREE_VALUE (CHAIN) for any piece of |
d4b60170 RK |
1956 | chain CHAIN. This and the next function are currently unused, but |
1957 | are retained for completeness. */ | |
1a2927d2 RK |
1958 | |
1959 | int | |
1960 | chain_member_value (elem, chain) | |
1961 | tree elem, chain; | |
1962 | { | |
1963 | while (chain) | |
1964 | { | |
1965 | if (elem == TREE_VALUE (chain)) | |
1966 | return 1; | |
1967 | chain = TREE_CHAIN (chain); | |
1968 | } | |
1969 | ||
1970 | return 0; | |
1971 | } | |
1972 | ||
33a79dfa | 1973 | /* Return nonzero if ELEM is equal to TREE_PURPOSE (CHAIN) |
0f41302f | 1974 | for any piece of chain CHAIN. */ |
0bcec367 RK |
1975 | |
1976 | int | |
1977 | chain_member_purpose (elem, chain) | |
1978 | tree elem, chain; | |
1979 | { | |
0bcec367 RK |
1980 | while (chain) |
1981 | { | |
33a79dfa | 1982 | if (elem == TREE_PURPOSE (chain)) |
0bcec367 RK |
1983 | return 1; |
1984 | chain = TREE_CHAIN (chain); | |
1985 | } | |
1986 | ||
1987 | return 0; | |
1988 | } | |
1989 | ||
c6a1db6c RS |
1990 | /* Return the length of a chain of nodes chained through TREE_CHAIN. |
1991 | We expect a null pointer to mark the end of the chain. | |
1992 | This is the Lisp primitive `length'. */ | |
1993 | ||
1994 | int | |
1995 | list_length (t) | |
1996 | tree t; | |
1997 | { | |
1998 | register tree tail; | |
1999 | register int len = 0; | |
2000 | ||
2001 | for (tail = t; tail; tail = TREE_CHAIN (tail)) | |
2002 | len++; | |
2003 | ||
2004 | return len; | |
2005 | } | |
2006 | ||
c3b247b4 JM |
2007 | /* Returns the number of FIELD_DECLs in TYPE. */ |
2008 | ||
2009 | int | |
2010 | fields_length (type) | |
2011 | tree type; | |
2012 | { | |
2013 | tree t = TYPE_FIELDS (type); | |
2014 | int count = 0; | |
2015 | ||
2016 | for (; t; t = TREE_CHAIN (t)) | |
2017 | if (TREE_CODE (t) == FIELD_DECL) | |
2018 | ++count; | |
2019 | ||
2020 | return count; | |
2021 | } | |
2022 | ||
c6a1db6c RS |
2023 | /* Concatenate two chains of nodes (chained through TREE_CHAIN) |
2024 | by modifying the last node in chain 1 to point to chain 2. | |
2025 | This is the Lisp primitive `nconc'. */ | |
2026 | ||
2027 | tree | |
2028 | chainon (op1, op2) | |
2029 | tree op1, op2; | |
2030 | { | |
c6a1db6c RS |
2031 | |
2032 | if (op1) | |
2033 | { | |
1810c3fa | 2034 | register tree t1; |
f4524c9e | 2035 | #ifdef ENABLE_TREE_CHECKING |
1810c3fa | 2036 | register tree t2; |
cbbfcb3b | 2037 | #endif |
1810c3fa RK |
2038 | |
2039 | for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1)) | |
2040 | ; | |
2041 | TREE_CHAIN (t1) = op2; | |
f4524c9e | 2042 | #ifdef ENABLE_TREE_CHECKING |
1810c3fa RK |
2043 | for (t2 = op2; t2; t2 = TREE_CHAIN (t2)) |
2044 | if (t2 == t1) | |
2045 | abort (); /* Circularity created. */ | |
0f4668ef | 2046 | #endif |
c6a1db6c RS |
2047 | return op1; |
2048 | } | |
2049 | else return op2; | |
2050 | } | |
2051 | ||
2052 | /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */ | |
2053 | ||
2054 | tree | |
2055 | tree_last (chain) | |
2056 | register tree chain; | |
2057 | { | |
2058 | register tree next; | |
2059 | if (chain) | |
5e9defae | 2060 | while ((next = TREE_CHAIN (chain))) |
c6a1db6c RS |
2061 | chain = next; |
2062 | return chain; | |
2063 | } | |
2064 | ||
2065 | /* Reverse the order of elements in the chain T, | |
2066 | and return the new head of the chain (old last element). */ | |
2067 | ||
2068 | tree | |
2069 | nreverse (t) | |
2070 | tree t; | |
2071 | { | |
2072 | register tree prev = 0, decl, next; | |
2073 | for (decl = t; decl; decl = next) | |
2074 | { | |
2075 | next = TREE_CHAIN (decl); | |
2076 | TREE_CHAIN (decl) = prev; | |
2077 | prev = decl; | |
2078 | } | |
2079 | return prev; | |
2080 | } | |
2081 | ||
2082 | /* Given a chain CHAIN of tree nodes, | |
2083 | construct and return a list of those nodes. */ | |
2084 | ||
2085 | tree | |
2086 | listify (chain) | |
2087 | tree chain; | |
2088 | { | |
2089 | tree result = NULL_TREE; | |
2090 | tree in_tail = chain; | |
2091 | tree out_tail = NULL_TREE; | |
2092 | ||
2093 | while (in_tail) | |
2094 | { | |
2095 | tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE); | |
2096 | if (out_tail) | |
2097 | TREE_CHAIN (out_tail) = next; | |
2098 | else | |
2099 | result = next; | |
2100 | out_tail = next; | |
2101 | in_tail = TREE_CHAIN (in_tail); | |
2102 | } | |
2103 | ||
2104 | return result; | |
2105 | } | |
2106 | \f | |
2107 | /* Return a newly created TREE_LIST node whose | |
2108 | purpose and value fields are PARM and VALUE. */ | |
2109 | ||
2110 | tree | |
2111 | build_tree_list (parm, value) | |
2112 | tree parm, value; | |
2113 | { | |
2114 | register tree t = make_node (TREE_LIST); | |
2115 | TREE_PURPOSE (t) = parm; | |
2116 | TREE_VALUE (t) = value; | |
2117 | return t; | |
2118 | } | |
2119 | ||
2120 | /* Similar, but build on the temp_decl_obstack. */ | |
2121 | ||
2122 | tree | |
2123 | build_decl_list (parm, value) | |
2124 | tree parm, value; | |
2125 | { | |
2126 | register tree node; | |
2127 | register struct obstack *ambient_obstack = current_obstack; | |
d4b60170 | 2128 | |
c6a1db6c RS |
2129 | current_obstack = &temp_decl_obstack; |
2130 | node = build_tree_list (parm, value); | |
2131 | current_obstack = ambient_obstack; | |
2132 | return node; | |
2133 | } | |
2134 | ||
f0632762 JM |
2135 | /* Similar, but build on the expression_obstack. */ |
2136 | ||
2137 | tree | |
2138 | build_expr_list (parm, value) | |
2139 | tree parm, value; | |
2140 | { | |
2141 | register tree node; | |
2142 | register struct obstack *ambient_obstack = current_obstack; | |
d4b60170 | 2143 | |
f0632762 JM |
2144 | current_obstack = expression_obstack; |
2145 | node = build_tree_list (parm, value); | |
2146 | current_obstack = ambient_obstack; | |
2147 | return node; | |
2148 | } | |
2149 | ||
c6a1db6c RS |
2150 | /* Return a newly created TREE_LIST node whose |
2151 | purpose and value fields are PARM and VALUE | |
2152 | and whose TREE_CHAIN is CHAIN. */ | |
2153 | ||
2154 | tree | |
2155 | tree_cons (purpose, value, chain) | |
2156 | tree purpose, value, chain; | |
2157 | { | |
a3770a81 RH |
2158 | register tree node; |
2159 | ||
2160 | if (ggc_p) | |
2161 | node = ggc_alloc_tree (sizeof (struct tree_list)); | |
2162 | else | |
2163 | { | |
2164 | node = (tree) obstack_alloc (current_obstack, sizeof (struct tree_list)); | |
341a243e | 2165 | memset (node, 0, sizeof (struct tree_common)); |
a3770a81 RH |
2166 | } |
2167 | ||
c6a1db6c RS |
2168 | #ifdef GATHER_STATISTICS |
2169 | tree_node_counts[(int)x_kind]++; | |
2170 | tree_node_sizes[(int)x_kind] += sizeof (struct tree_list); | |
2171 | #endif | |
2172 | ||
c6a1db6c | 2173 | TREE_SET_CODE (node, TREE_LIST); |
23dfa477 | 2174 | TREE_SET_PERMANENT (node); |
c6a1db6c RS |
2175 | |
2176 | TREE_CHAIN (node) = chain; | |
2177 | TREE_PURPOSE (node) = purpose; | |
2178 | TREE_VALUE (node) = value; | |
2179 | return node; | |
2180 | } | |
2181 | ||
2182 | /* Similar, but build on the temp_decl_obstack. */ | |
2183 | ||
2184 | tree | |
2185 | decl_tree_cons (purpose, value, chain) | |
2186 | tree purpose, value, chain; | |
2187 | { | |
2188 | register tree node; | |
2189 | register struct obstack *ambient_obstack = current_obstack; | |
d4b60170 | 2190 | |
c6a1db6c RS |
2191 | current_obstack = &temp_decl_obstack; |
2192 | node = tree_cons (purpose, value, chain); | |
f0632762 JM |
2193 | current_obstack = ambient_obstack; |
2194 | return node; | |
2195 | } | |
2196 | ||
2197 | /* Similar, but build on the expression_obstack. */ | |
2198 | ||
2199 | tree | |
2200 | expr_tree_cons (purpose, value, chain) | |
2201 | tree purpose, value, chain; | |
2202 | { | |
2203 | register tree node; | |
2204 | register struct obstack *ambient_obstack = current_obstack; | |
d4b60170 | 2205 | |
f0632762 JM |
2206 | current_obstack = expression_obstack; |
2207 | node = tree_cons (purpose, value, chain); | |
c6a1db6c RS |
2208 | current_obstack = ambient_obstack; |
2209 | return node; | |
2210 | } | |
2211 | ||
2212 | /* Same as `tree_cons' but make a permanent object. */ | |
2213 | ||
2214 | tree | |
2215 | perm_tree_cons (purpose, value, chain) | |
2216 | tree purpose, value, chain; | |
2217 | { | |
2218 | register tree node; | |
2219 | register struct obstack *ambient_obstack = current_obstack; | |
c6a1db6c | 2220 | |
d4b60170 | 2221 | current_obstack = &permanent_obstack; |
c6a1db6c RS |
2222 | node = tree_cons (purpose, value, chain); |
2223 | current_obstack = ambient_obstack; | |
2224 | return node; | |
2225 | } | |
2226 | ||
2227 | /* Same as `tree_cons', but make this node temporary, regardless. */ | |
2228 | ||
2229 | tree | |
2230 | temp_tree_cons (purpose, value, chain) | |
2231 | tree purpose, value, chain; | |
2232 | { | |
2233 | register tree node; | |
2234 | register struct obstack *ambient_obstack = current_obstack; | |
c6a1db6c | 2235 | |
d4b60170 | 2236 | current_obstack = &temporary_obstack; |
c6a1db6c RS |
2237 | node = tree_cons (purpose, value, chain); |
2238 | current_obstack = ambient_obstack; | |
2239 | return node; | |
2240 | } | |
2241 | ||
2242 | /* Same as `tree_cons', but save this node if the function's RTL is saved. */ | |
2243 | ||
2244 | tree | |
2245 | saveable_tree_cons (purpose, value, chain) | |
2246 | tree purpose, value, chain; | |
2247 | { | |
2248 | register tree node; | |
2249 | register struct obstack *ambient_obstack = current_obstack; | |
c6a1db6c | 2250 | |
d4b60170 | 2251 | current_obstack = saveable_obstack; |
c6a1db6c RS |
2252 | node = tree_cons (purpose, value, chain); |
2253 | current_obstack = ambient_obstack; | |
2254 | return node; | |
2255 | } | |
2256 | \f | |
2257 | /* Return the size nominally occupied by an object of type TYPE | |
2258 | when it resides in memory. The value is measured in units of bytes, | |
2259 | and its data type is that normally used for type sizes | |
2260 | (which is the first type created by make_signed_type or | |
2261 | make_unsigned_type). */ | |
2262 | ||
2263 | tree | |
2264 | size_in_bytes (type) | |
2265 | tree type; | |
2266 | { | |
cdc5a032 RS |
2267 | tree t; |
2268 | ||
c6a1db6c RS |
2269 | if (type == error_mark_node) |
2270 | return integer_zero_node; | |
ead17059 | 2271 | |
c6a1db6c | 2272 | type = TYPE_MAIN_VARIANT (type); |
ead17059 | 2273 | t = TYPE_SIZE_UNIT (type); |
d4b60170 | 2274 | |
ead17059 | 2275 | if (t == 0) |
c6a1db6c | 2276 | { |
37366632 | 2277 | incomplete_type_error (NULL_TREE, type); |
c6a1db6c RS |
2278 | return integer_zero_node; |
2279 | } | |
d4b60170 | 2280 | |
4d7d0403 | 2281 | if (TREE_CODE (t) == INTEGER_CST) |
b6542989 | 2282 | force_fit_type (t, 0); |
ead17059 | 2283 | |
cdc5a032 | 2284 | return t; |
c6a1db6c RS |
2285 | } |
2286 | ||
e5e809f4 JL |
2287 | /* Return the size of TYPE (in bytes) as a wide integer |
2288 | or return -1 if the size can vary or is larger than an integer. */ | |
c6a1db6c | 2289 | |
e5e809f4 | 2290 | HOST_WIDE_INT |
c6a1db6c RS |
2291 | int_size_in_bytes (type) |
2292 | tree type; | |
2293 | { | |
e5e809f4 JL |
2294 | tree t; |
2295 | ||
c6a1db6c RS |
2296 | if (type == error_mark_node) |
2297 | return 0; | |
e5e809f4 | 2298 | |
c6a1db6c | 2299 | type = TYPE_MAIN_VARIANT (type); |
ead17059 RH |
2300 | t = TYPE_SIZE_UNIT (type); |
2301 | if (t == 0 | |
2302 | || TREE_CODE (t) != INTEGER_CST | |
d4b60170 | 2303 | || TREE_OVERFLOW (t) |
665f2503 RK |
2304 | || TREE_INT_CST_HIGH (t) != 0 |
2305 | /* If the result would appear negative, it's too big to represent. */ | |
2306 | || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0) | |
c6a1db6c | 2307 | return -1; |
e5e809f4 JL |
2308 | |
2309 | return TREE_INT_CST_LOW (t); | |
c6a1db6c | 2310 | } |
665f2503 RK |
2311 | \f |
2312 | /* Return the bit position of FIELD, in bits from the start of the record. | |
2313 | This is a tree of type bitsizetype. */ | |
2314 | ||
2315 | tree | |
2316 | bit_position (field) | |
2317 | tree field; | |
2318 | { | |
2319 | return DECL_FIELD_BITPOS (field); | |
2320 | } | |
729a2125 | 2321 | |
665f2503 RK |
2322 | /* Likewise, but return as an integer. Abort if it cannot be represented |
2323 | in that way (since it could be a signed value, we don't have the option | |
2324 | of returning -1 like int_size_in_byte can. */ | |
2325 | ||
2326 | HOST_WIDE_INT | |
2327 | int_bit_position (field) | |
2328 | tree field; | |
2329 | { | |
2330 | return tree_low_cst (bit_position (field), 0); | |
2331 | } | |
2332 | \f | |
2333 | /* Return the strictest alignment, in bits, that T is known to have. */ | |
729a2125 RK |
2334 | |
2335 | unsigned int | |
2336 | expr_align (t) | |
2337 | tree t; | |
2338 | { | |
2339 | unsigned int align0, align1; | |
2340 | ||
2341 | switch (TREE_CODE (t)) | |
2342 | { | |
2343 | case NOP_EXPR: case CONVERT_EXPR: case NON_LVALUE_EXPR: | |
2344 | /* If we have conversions, we know that the alignment of the | |
2345 | object must meet each of the alignments of the types. */ | |
2346 | align0 = expr_align (TREE_OPERAND (t, 0)); | |
2347 | align1 = TYPE_ALIGN (TREE_TYPE (t)); | |
2348 | return MAX (align0, align1); | |
2349 | ||
2350 | case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR: | |
2351 | case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR: | |
2352 | case WITH_RECORD_EXPR: case CLEANUP_POINT_EXPR: case UNSAVE_EXPR: | |
2353 | /* These don't change the alignment of an object. */ | |
2354 | return expr_align (TREE_OPERAND (t, 0)); | |
2355 | ||
2356 | case COND_EXPR: | |
2357 | /* The best we can do is say that the alignment is the least aligned | |
2358 | of the two arms. */ | |
2359 | align0 = expr_align (TREE_OPERAND (t, 1)); | |
2360 | align1 = expr_align (TREE_OPERAND (t, 2)); | |
2361 | return MIN (align0, align1); | |
2362 | ||
06ceef4e | 2363 | case LABEL_DECL: case CONST_DECL: |
729a2125 RK |
2364 | case VAR_DECL: case PARM_DECL: case RESULT_DECL: |
2365 | if (DECL_ALIGN (t) != 0) | |
2366 | return DECL_ALIGN (t); | |
2367 | break; | |
2368 | ||
06ceef4e RK |
2369 | case FUNCTION_DECL: |
2370 | return FUNCTION_BOUNDARY; | |
2371 | ||
729a2125 RK |
2372 | default: |
2373 | break; | |
2374 | } | |
2375 | ||
2376 | /* Otherwise take the alignment from that of the type. */ | |
2377 | return TYPE_ALIGN (TREE_TYPE (t)); | |
2378 | } | |
c0560b8b RK |
2379 | \f |
2380 | /* Return, as a tree node, the number of elements for TYPE (which is an | |
d26f8097 | 2381 | ARRAY_TYPE) minus one. This counts only elements of the top array. */ |
c6a1db6c RS |
2382 | |
2383 | tree | |
2384 | array_type_nelts (type) | |
2385 | tree type; | |
2386 | { | |
7671d67b BK |
2387 | tree index_type, min, max; |
2388 | ||
2389 | /* If they did it with unspecified bounds, then we should have already | |
2390 | given an error about it before we got here. */ | |
2391 | if (! TYPE_DOMAIN (type)) | |
2392 | return error_mark_node; | |
2393 | ||
2394 | index_type = TYPE_DOMAIN (type); | |
2395 | min = TYPE_MIN_VALUE (index_type); | |
2396 | max = TYPE_MAX_VALUE (index_type); | |
83b853c9 | 2397 | |
83b853c9 JM |
2398 | return (integer_zerop (min) |
2399 | ? max | |
2400 | : fold (build (MINUS_EXPR, TREE_TYPE (max), max, min))); | |
c6a1db6c RS |
2401 | } |
2402 | \f | |
2403 | /* Return nonzero if arg is static -- a reference to an object in | |
2404 | static storage. This is not the same as the C meaning of `static'. */ | |
2405 | ||
2406 | int | |
2407 | staticp (arg) | |
2408 | tree arg; | |
2409 | { | |
2410 | switch (TREE_CODE (arg)) | |
2411 | { | |
c6a1db6c | 2412 | case FUNCTION_DECL: |
1324c5de | 2413 | /* Nested functions aren't static, since taking their address |
86270344 | 2414 | involves a trampoline. */ |
27da1b4d MK |
2415 | return (decl_function_context (arg) == 0 || DECL_NO_STATIC_CHAIN (arg)) |
2416 | && ! DECL_NON_ADDR_CONST_P (arg); | |
2417 | ||
86270344 | 2418 | case VAR_DECL: |
27da1b4d MK |
2419 | return (TREE_STATIC (arg) || DECL_EXTERNAL (arg)) |
2420 | && ! DECL_NON_ADDR_CONST_P (arg); | |
c6a1db6c | 2421 | |
492c86a4 RK |
2422 | case CONSTRUCTOR: |
2423 | return TREE_STATIC (arg); | |
2424 | ||
c6a1db6c RS |
2425 | case STRING_CST: |
2426 | return 1; | |
2427 | ||
f7fa6ef9 RK |
2428 | /* If we are referencing a bitfield, we can't evaluate an |
2429 | ADDR_EXPR at compile time and so it isn't a constant. */ | |
c6a1db6c | 2430 | case COMPONENT_REF: |
f7fa6ef9 RK |
2431 | return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1)) |
2432 | && staticp (TREE_OPERAND (arg, 0))); | |
2433 | ||
c6a1db6c | 2434 | case BIT_FIELD_REF: |
f7fa6ef9 | 2435 | return 0; |
c6a1db6c | 2436 | |
2cd2a93e RK |
2437 | #if 0 |
2438 | /* This case is technically correct, but results in setting | |
2439 | TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at | |
2440 | compile time. */ | |
c6a1db6c RS |
2441 | case INDIRECT_REF: |
2442 | return TREE_CONSTANT (TREE_OPERAND (arg, 0)); | |
2cd2a93e | 2443 | #endif |
c6a1db6c RS |
2444 | |
2445 | case ARRAY_REF: | |
2446 | if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST | |
2447 | && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST) | |
2448 | return staticp (TREE_OPERAND (arg, 0)); | |
c6a1db6c | 2449 | |
e9a25f70 JL |
2450 | default: |
2451 | return 0; | |
2452 | } | |
c6a1db6c RS |
2453 | } |
2454 | \f | |
3aa77500 RS |
2455 | /* Wrap a SAVE_EXPR around EXPR, if appropriate. |
2456 | Do this to any expression which may be used in more than one place, | |
2457 | but must be evaluated only once. | |
2458 | ||
2459 | Normally, expand_expr would reevaluate the expression each time. | |
2460 | Calling save_expr produces something that is evaluated and recorded | |
2461 | the first time expand_expr is called on it. Subsequent calls to | |
2462 | expand_expr just reuse the recorded value. | |
2463 | ||
2464 | The call to expand_expr that generates code that actually computes | |
2465 | the value is the first call *at compile time*. Subsequent calls | |
2466 | *at compile time* generate code to use the saved value. | |
2467 | This produces correct result provided that *at run time* control | |
2468 | always flows through the insns made by the first expand_expr | |
2469 | before reaching the other places where the save_expr was evaluated. | |
2470 | You, the caller of save_expr, must make sure this is so. | |
2471 | ||
2472 | Constants, and certain read-only nodes, are returned with no | |
2473 | SAVE_EXPR because that is safe. Expressions containing placeholders | |
c5af9901 RK |
2474 | are not touched; see tree.def for an explanation of what these |
2475 | are used for. */ | |
c6a1db6c RS |
2476 | |
2477 | tree | |
2478 | save_expr (expr) | |
2479 | tree expr; | |
2480 | { | |
2481 | register tree t = fold (expr); | |
2482 | ||
2483 | /* We don't care about whether this can be used as an lvalue in this | |
2484 | context. */ | |
2485 | while (TREE_CODE (t) == NON_LVALUE_EXPR) | |
2486 | t = TREE_OPERAND (t, 0); | |
2487 | ||
2488 | /* If the tree evaluates to a constant, then we don't want to hide that | |
2489 | fact (i.e. this allows further folding, and direct checks for constants). | |
af929c62 | 2490 | However, a read-only object that has side effects cannot be bypassed. |
c6a1db6c | 2491 | Since it is no problem to reevaluate literals, we just return the |
0f41302f | 2492 | literal node. */ |
c6a1db6c | 2493 | |
af929c62 | 2494 | if (TREE_CONSTANT (t) || (TREE_READONLY (t) && ! TREE_SIDE_EFFECTS (t)) |
e0094edb | 2495 | || TREE_CODE (t) == SAVE_EXPR || TREE_CODE (t) == ERROR_MARK) |
c6a1db6c RS |
2496 | return t; |
2497 | ||
dec20b4b RK |
2498 | /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since |
2499 | it means that the size or offset of some field of an object depends on | |
2500 | the value within another field. | |
2501 | ||
2502 | Note that it must not be the case that T contains both a PLACEHOLDER_EXPR | |
2503 | and some variable since it would then need to be both evaluated once and | |
2504 | evaluated more than once. Front-ends must assure this case cannot | |
2505 | happen by surrounding any such subexpressions in their own SAVE_EXPR | |
2506 | and forcing evaluation at the proper time. */ | |
2507 | if (contains_placeholder_p (t)) | |
2508 | return t; | |
2509 | ||
37366632 | 2510 | t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE); |
c6a1db6c RS |
2511 | |
2512 | /* This expression might be placed ahead of a jump to ensure that the | |
2513 | value was computed on both sides of the jump. So make sure it isn't | |
2514 | eliminated as dead. */ | |
2515 | TREE_SIDE_EFFECTS (t) = 1; | |
2516 | return t; | |
2517 | } | |
679163cf MS |
2518 | |
2519 | /* Arrange for an expression to be expanded multiple independent | |
2520 | times. This is useful for cleanup actions, as the backend can | |
2521 | expand them multiple times in different places. */ | |
0f41302f | 2522 | |
679163cf MS |
2523 | tree |
2524 | unsave_expr (expr) | |
2525 | tree expr; | |
2526 | { | |
2527 | tree t; | |
2528 | ||
2529 | /* If this is already protected, no sense in protecting it again. */ | |
2530 | if (TREE_CODE (expr) == UNSAVE_EXPR) | |
2531 | return expr; | |
2532 | ||
2533 | t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr); | |
2534 | TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr); | |
2535 | return t; | |
2536 | } | |
2537 | ||
b7f6588d JM |
2538 | /* Returns the index of the first non-tree operand for CODE, or the number |
2539 | of operands if all are trees. */ | |
2540 | ||
2541 | int | |
2542 | first_rtl_op (code) | |
2543 | enum tree_code code; | |
2544 | { | |
2545 | switch (code) | |
2546 | { | |
2547 | case SAVE_EXPR: | |
2548 | return 2; | |
8dd858ca | 2549 | case GOTO_SUBROUTINE_EXPR: |
b7f6588d JM |
2550 | case RTL_EXPR: |
2551 | return 0; | |
2552 | case CALL_EXPR: | |
2553 | return 2; | |
2554 | case WITH_CLEANUP_EXPR: | |
2555 | /* Should be defined to be 2. */ | |
2556 | return 1; | |
2557 | case METHOD_CALL_EXPR: | |
2558 | return 3; | |
2559 | default: | |
2560 | return tree_code_length [(int) code]; | |
2561 | } | |
2562 | } | |
2563 | ||
582db8e4 MM |
2564 | /* Perform any modifications to EXPR required when it is unsaved. Does |
2565 | not recurse into EXPR's subtrees. */ | |
0f41302f | 2566 | |
582db8e4 MM |
2567 | void |
2568 | unsave_expr_1 (expr) | |
679163cf MS |
2569 | tree expr; |
2570 | { | |
582db8e4 | 2571 | switch (TREE_CODE (expr)) |
679163cf MS |
2572 | { |
2573 | case SAVE_EXPR: | |
d4b60170 | 2574 | if (! SAVE_EXPR_PERSISTENT_P (expr)) |
d26f8097 | 2575 | SAVE_EXPR_RTL (expr) = 0; |
679163cf MS |
2576 | break; |
2577 | ||
2578 | case TARGET_EXPR: | |
4847c938 MS |
2579 | TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3); |
2580 | TREE_OPERAND (expr, 3) = NULL_TREE; | |
679163cf MS |
2581 | break; |
2582 | ||
2583 | case RTL_EXPR: | |
4847c938 | 2584 | /* I don't yet know how to emit a sequence multiple times. */ |
d4b60170 | 2585 | if (RTL_EXPR_SEQUENCE (expr) != 0) |
4847c938 | 2586 | abort (); |
679163cf MS |
2587 | break; |
2588 | ||
2589 | case CALL_EXPR: | |
4d12b2fe | 2590 | CALL_EXPR_RTL (expr) = 0; |
679163cf | 2591 | break; |
e9a25f70 JL |
2592 | |
2593 | default: | |
d4b60170 | 2594 | if (lang_unsave_expr_now != 0) |
0a818f84 | 2595 | (*lang_unsave_expr_now) (expr); |
e9a25f70 | 2596 | break; |
679163cf | 2597 | } |
582db8e4 MM |
2598 | } |
2599 | ||
2600 | /* Helper function for unsave_expr_now. */ | |
2601 | ||
2602 | static void | |
2603 | unsave_expr_now_r (expr) | |
2604 | tree expr; | |
2605 | { | |
2606 | enum tree_code code; | |
2607 | ||
7a12ace5 | 2608 | /* There's nothing to do for NULL_TREE. */ |
d4b60170 | 2609 | if (expr == 0) |
7a12ace5 MM |
2610 | return; |
2611 | ||
582db8e4 | 2612 | unsave_expr_1 (expr); |
679163cf | 2613 | |
582db8e4 MM |
2614 | code = TREE_CODE (expr); |
2615 | if (code == CALL_EXPR | |
2616 | && TREE_OPERAND (expr, 1) | |
2617 | && TREE_CODE (TREE_OPERAND (expr, 1)) == TREE_LIST) | |
2618 | { | |
2619 | tree exp = TREE_OPERAND (expr, 1); | |
2620 | while (exp) | |
2621 | { | |
2622 | unsave_expr_now_r (TREE_VALUE (exp)); | |
2623 | exp = TREE_CHAIN (exp); | |
2624 | } | |
2625 | } | |
2626 | ||
679163cf MS |
2627 | switch (TREE_CODE_CLASS (code)) |
2628 | { | |
2629 | case 'c': /* a constant */ | |
2630 | case 't': /* a type node */ | |
2631 | case 'x': /* something random, like an identifier or an ERROR_MARK. */ | |
2632 | case 'd': /* A decl node */ | |
2633 | case 'b': /* A block node */ | |
582db8e4 | 2634 | break; |
679163cf MS |
2635 | |
2636 | case 'e': /* an expression */ | |
2637 | case 'r': /* a reference */ | |
2638 | case 's': /* an expression with side effects */ | |
2639 | case '<': /* a comparison expression */ | |
2640 | case '2': /* a binary arithmetic expression */ | |
2641 | case '1': /* a unary arithmetic expression */ | |
582db8e4 MM |
2642 | { |
2643 | int i; | |
2644 | ||
2645 | for (i = first_rtl_op (code) - 1; i >= 0; i--) | |
2646 | unsave_expr_now_r (TREE_OPERAND (expr, i)); | |
2647 | } | |
2648 | break; | |
679163cf MS |
2649 | |
2650 | default: | |
2651 | abort (); | |
2652 | } | |
2653 | } | |
582db8e4 MM |
2654 | |
2655 | /* Modify a tree in place so that all the evaluate only once things | |
2656 | are cleared out. Return the EXPR given. */ | |
2657 | ||
2658 | tree | |
2659 | unsave_expr_now (expr) | |
2660 | tree expr; | |
2661 | { | |
d4b60170 | 2662 | if (lang_unsave!= 0) |
582db8e4 MM |
2663 | (*lang_unsave) (&expr); |
2664 | else | |
2665 | unsave_expr_now_r (expr); | |
2666 | ||
2667 | return expr; | |
2668 | } | |
dec20b4b RK |
2669 | \f |
2670 | /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size | |
3910a7cb | 2671 | or offset that depends on a field within a record. */ |
dec20b4b RK |
2672 | |
2673 | int | |
2674 | contains_placeholder_p (exp) | |
2675 | tree exp; | |
2676 | { | |
2677 | register enum tree_code code = TREE_CODE (exp); | |
e9a25f70 | 2678 | int result; |
dec20b4b | 2679 | |
67c8d7de RK |
2680 | /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR |
2681 | in it since it is supplying a value for it. */ | |
2682 | if (code == WITH_RECORD_EXPR) | |
2683 | return 0; | |
a5ee6e44 | 2684 | else if (code == PLACEHOLDER_EXPR) |
cc3c7c13 | 2685 | return 1; |
67c8d7de | 2686 | |
dec20b4b RK |
2687 | switch (TREE_CODE_CLASS (code)) |
2688 | { | |
2689 | case 'r': | |
cc3c7c13 RK |
2690 | /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit |
2691 | position computations since they will be converted into a | |
2692 | WITH_RECORD_EXPR involving the reference, which will assume | |
2693 | here will be valid. */ | |
2694 | return contains_placeholder_p (TREE_OPERAND (exp, 0)); | |
dec20b4b | 2695 | |
e9a25f70 JL |
2696 | case 'x': |
2697 | if (code == TREE_LIST) | |
2698 | return (contains_placeholder_p (TREE_VALUE (exp)) | |
2699 | || (TREE_CHAIN (exp) != 0 | |
2700 | && contains_placeholder_p (TREE_CHAIN (exp)))); | |
2701 | break; | |
2702 | ||
dec20b4b RK |
2703 | case '1': |
2704 | case '2': case '<': | |
2705 | case 'e': | |
3910a7cb RK |
2706 | switch (code) |
2707 | { | |
2708 | case COMPOUND_EXPR: | |
2709 | /* Ignoring the first operand isn't quite right, but works best. */ | |
cc3c7c13 | 2710 | return contains_placeholder_p (TREE_OPERAND (exp, 1)); |
3910a7cb RK |
2711 | |
2712 | case RTL_EXPR: | |
2713 | case CONSTRUCTOR: | |
2714 | return 0; | |
2715 | ||
2716 | case COND_EXPR: | |
cc3c7c13 RK |
2717 | return (contains_placeholder_p (TREE_OPERAND (exp, 0)) |
2718 | || contains_placeholder_p (TREE_OPERAND (exp, 1)) | |
2719 | || contains_placeholder_p (TREE_OPERAND (exp, 2))); | |
3910a7cb RK |
2720 | |
2721 | case SAVE_EXPR: | |
e9a25f70 JL |
2722 | /* If we already know this doesn't have a placeholder, don't |
2723 | check again. */ | |
2724 | if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0) | |
2725 | return 0; | |
2726 | ||
2727 | SAVE_EXPR_NOPLACEHOLDER (exp) = 1; | |
2728 | result = contains_placeholder_p (TREE_OPERAND (exp, 0)); | |
2729 | if (result) | |
2730 | SAVE_EXPR_NOPLACEHOLDER (exp) = 0; | |
2731 | ||
2732 | return result; | |
2733 | ||
2734 | case CALL_EXPR: | |
2735 | return (TREE_OPERAND (exp, 1) != 0 | |
2736 | && contains_placeholder_p (TREE_OPERAND (exp, 1))); | |
2737 | ||
2738 | default: | |
2739 | break; | |
3910a7cb RK |
2740 | } |
2741 | ||
dec20b4b RK |
2742 | switch (tree_code_length[(int) code]) |
2743 | { | |
2744 | case 1: | |
cc3c7c13 | 2745 | return contains_placeholder_p (TREE_OPERAND (exp, 0)); |
dec20b4b | 2746 | case 2: |
cc3c7c13 RK |
2747 | return (contains_placeholder_p (TREE_OPERAND (exp, 0)) |
2748 | || contains_placeholder_p (TREE_OPERAND (exp, 1))); | |
e9a25f70 JL |
2749 | default: |
2750 | return 0; | |
dec20b4b | 2751 | } |
dec20b4b | 2752 | |
e9a25f70 JL |
2753 | default: |
2754 | return 0; | |
2755 | } | |
1160f9ec | 2756 | return 0; |
dec20b4b | 2757 | } |
b7f6588d JM |
2758 | |
2759 | /* Return 1 if EXP contains any expressions that produce cleanups for an | |
2760 | outer scope to deal with. Used by fold. */ | |
2761 | ||
2762 | int | |
2763 | has_cleanups (exp) | |
2764 | tree exp; | |
2765 | { | |
2766 | int i, nops, cmp; | |
2767 | ||
2768 | if (! TREE_SIDE_EFFECTS (exp)) | |
2769 | return 0; | |
2770 | ||
2771 | switch (TREE_CODE (exp)) | |
2772 | { | |
2773 | case TARGET_EXPR: | |
8dd858ca | 2774 | case GOTO_SUBROUTINE_EXPR: |
b7f6588d JM |
2775 | case WITH_CLEANUP_EXPR: |
2776 | return 1; | |
2777 | ||
2778 | case CLEANUP_POINT_EXPR: | |
2779 | return 0; | |
2780 | ||
2781 | case CALL_EXPR: | |
2782 | for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp)) | |
2783 | { | |
2784 | cmp = has_cleanups (TREE_VALUE (exp)); | |
2785 | if (cmp) | |
2786 | return cmp; | |
2787 | } | |
2788 | return 0; | |
2789 | ||
2790 | default: | |
2791 | break; | |
2792 | } | |
2793 | ||
2794 | /* This general rule works for most tree codes. All exceptions should be | |
2795 | handled above. If this is a language-specific tree code, we can't | |
2796 | trust what might be in the operand, so say we don't know | |
2797 | the situation. */ | |
2798 | if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE) | |
2799 | return -1; | |
2800 | ||
2801 | nops = first_rtl_op (TREE_CODE (exp)); | |
2802 | for (i = 0; i < nops; i++) | |
2803 | if (TREE_OPERAND (exp, i) != 0) | |
2804 | { | |
2805 | int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i))); | |
2806 | if (type == 'e' || type == '<' || type == '1' || type == '2' | |
2807 | || type == 'r' || type == 's') | |
2808 | { | |
2809 | cmp = has_cleanups (TREE_OPERAND (exp, i)); | |
2810 | if (cmp) | |
2811 | return cmp; | |
2812 | } | |
2813 | } | |
2814 | ||
2815 | return 0; | |
2816 | } | |
dec20b4b RK |
2817 | \f |
2818 | /* Given a tree EXP, a FIELD_DECL F, and a replacement value R, | |
2819 | return a tree with all occurrences of references to F in a | |
2820 | PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP | |
e9a25f70 JL |
2821 | contains only arithmetic expressions or a CALL_EXPR with a |
2822 | PLACEHOLDER_EXPR occurring only in its arglist. */ | |
dec20b4b RK |
2823 | |
2824 | tree | |
2825 | substitute_in_expr (exp, f, r) | |
2826 | tree exp; | |
2827 | tree f; | |
2828 | tree r; | |
2829 | { | |
2830 | enum tree_code code = TREE_CODE (exp); | |
9b594acf | 2831 | tree op0, op1, op2; |
e9a25f70 | 2832 | tree new; |
dec20b4b RK |
2833 | tree inner; |
2834 | ||
2835 | switch (TREE_CODE_CLASS (code)) | |
2836 | { | |
2837 | case 'c': | |
2838 | case 'd': | |
2839 | return exp; | |
2840 | ||
2841 | case 'x': | |
2842 | if (code == PLACEHOLDER_EXPR) | |
2843 | return exp; | |
e9a25f70 JL |
2844 | else if (code == TREE_LIST) |
2845 | { | |
2846 | op0 = (TREE_CHAIN (exp) == 0 | |
2847 | ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r)); | |
2848 | op1 = substitute_in_expr (TREE_VALUE (exp), f, r); | |
956d6950 | 2849 | if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp)) |
e9a25f70 JL |
2850 | return exp; |
2851 | ||
956d6950 | 2852 | return tree_cons (TREE_PURPOSE (exp), op1, op0); |
e9a25f70 JL |
2853 | } |
2854 | ||
2855 | abort (); | |
dec20b4b RK |
2856 | |
2857 | case '1': | |
2858 | case '2': | |
2859 | case '<': | |
2860 | case 'e': | |
2861 | switch (tree_code_length[(int) code]) | |
2862 | { | |
2863 | case 1: | |
9b594acf RK |
2864 | op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r); |
2865 | if (op0 == TREE_OPERAND (exp, 0)) | |
2866 | return exp; | |
2867 | ||
2868 | new = fold (build1 (code, TREE_TYPE (exp), op0)); | |
abd23b66 | 2869 | break; |
dec20b4b RK |
2870 | |
2871 | case 2: | |
6a22e3a7 RK |
2872 | /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR |
2873 | could, but we don't support it. */ | |
2874 | if (code == RTL_EXPR) | |
2875 | return exp; | |
2876 | else if (code == CONSTRUCTOR) | |
dec20b4b RK |
2877 | abort (); |
2878 | ||
9b594acf RK |
2879 | op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r); |
2880 | op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r); | |
2881 | if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)) | |
2882 | return exp; | |
2883 | ||
2884 | new = fold (build (code, TREE_TYPE (exp), op0, op1)); | |
abd23b66 | 2885 | break; |
dec20b4b RK |
2886 | |
2887 | case 3: | |
6a22e3a7 RK |
2888 | /* It cannot be that anything inside a SAVE_EXPR contains a |
2889 | PLACEHOLDER_EXPR. */ | |
2890 | if (code == SAVE_EXPR) | |
2891 | return exp; | |
2892 | ||
e9a25f70 JL |
2893 | else if (code == CALL_EXPR) |
2894 | { | |
2895 | op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r); | |
2896 | if (op1 == TREE_OPERAND (exp, 1)) | |
2897 | return exp; | |
2898 | ||
2899 | return build (code, TREE_TYPE (exp), | |
2900 | TREE_OPERAND (exp, 0), op1, NULL_TREE); | |
2901 | } | |
2902 | ||
2903 | else if (code != COND_EXPR) | |
dec20b4b RK |
2904 | abort (); |
2905 | ||
9b594acf RK |
2906 | op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r); |
2907 | op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r); | |
2908 | op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r); | |
2909 | if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) | |
2910 | && op2 == TREE_OPERAND (exp, 2)) | |
2911 | return exp; | |
2912 | ||
2913 | new = fold (build (code, TREE_TYPE (exp), op0, op1, op2)); | |
e9a25f70 JL |
2914 | break; |
2915 | ||
2916 | default: | |
2917 | abort (); | |
dec20b4b RK |
2918 | } |
2919 | ||
2920 | break; | |
2921 | ||
2922 | case 'r': | |
2923 | switch (code) | |
2924 | { | |
2925 | case COMPONENT_REF: | |
2926 | /* If this expression is getting a value from a PLACEHOLDER_EXPR | |
2927 | and it is the right field, replace it with R. */ | |
2928 | for (inner = TREE_OPERAND (exp, 0); | |
2929 | TREE_CODE_CLASS (TREE_CODE (inner)) == 'r'; | |
2930 | inner = TREE_OPERAND (inner, 0)) | |
2931 | ; | |
2932 | if (TREE_CODE (inner) == PLACEHOLDER_EXPR | |
2933 | && TREE_OPERAND (exp, 1) == f) | |
2934 | return r; | |
2935 | ||
6cba9fcc RK |
2936 | /* If this expression hasn't been completed let, leave it |
2937 | alone. */ | |
2938 | if (TREE_CODE (inner) == PLACEHOLDER_EXPR | |
2939 | && TREE_TYPE (inner) == 0) | |
2940 | return exp; | |
2941 | ||
9b594acf RK |
2942 | op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r); |
2943 | if (op0 == TREE_OPERAND (exp, 0)) | |
2944 | return exp; | |
2945 | ||
2946 | new = fold (build (code, TREE_TYPE (exp), op0, | |
abd23b66 RK |
2947 | TREE_OPERAND (exp, 1))); |
2948 | break; | |
2949 | ||
dec20b4b | 2950 | case BIT_FIELD_REF: |
9b594acf RK |
2951 | op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r); |
2952 | op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r); | |
2953 | op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r); | |
2954 | if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) | |
2955 | && op2 == TREE_OPERAND (exp, 2)) | |
2956 | return exp; | |
2957 | ||
2958 | new = fold (build (code, TREE_TYPE (exp), op0, op1, op2)); | |
abd23b66 RK |
2959 | break; |
2960 | ||
dec20b4b RK |
2961 | case INDIRECT_REF: |
2962 | case BUFFER_REF: | |
9b594acf RK |
2963 | op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r); |
2964 | if (op0 == TREE_OPERAND (exp, 0)) | |
2965 | return exp; | |
2966 | ||
2967 | new = fold (build1 (code, TREE_TYPE (exp), op0)); | |
abd23b66 | 2968 | break; |
e9a25f70 JL |
2969 | |
2970 | default: | |
2971 | abort (); | |
dec20b4b | 2972 | } |
e9a25f70 JL |
2973 | break; |
2974 | ||
2975 | default: | |
2976 | abort (); | |
dec20b4b RK |
2977 | } |
2978 | ||
abd23b66 RK |
2979 | TREE_READONLY (new) = TREE_READONLY (exp); |
2980 | return new; | |
dec20b4b RK |
2981 | } |
2982 | \f | |
c6a1db6c RS |
2983 | /* Stabilize a reference so that we can use it any number of times |
2984 | without causing its operands to be evaluated more than once. | |
4b1d0fea RS |
2985 | Returns the stabilized reference. This works by means of save_expr, |
2986 | so see the caveats in the comments about save_expr. | |
c6a1db6c RS |
2987 | |
2988 | Also allows conversion expressions whose operands are references. | |
2989 | Any other kind of expression is returned unchanged. */ | |
2990 | ||
2991 | tree | |
2992 | stabilize_reference (ref) | |
2993 | tree ref; | |
2994 | { | |
2995 | register tree result; | |
2996 | register enum tree_code code = TREE_CODE (ref); | |
2997 | ||
2998 | switch (code) | |
2999 | { | |
3000 | case VAR_DECL: | |
3001 | case PARM_DECL: | |
3002 | case RESULT_DECL: | |
3003 | /* No action is needed in this case. */ | |
3004 | return ref; | |
3005 | ||
3006 | case NOP_EXPR: | |
3007 | case CONVERT_EXPR: | |
3008 | case FLOAT_EXPR: | |
3009 | case FIX_TRUNC_EXPR: | |
3010 | case FIX_FLOOR_EXPR: | |
3011 | case FIX_ROUND_EXPR: | |
3012 | case FIX_CEIL_EXPR: | |
3013 | result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0))); | |
3014 | break; | |
3015 | ||
3016 | case INDIRECT_REF: | |
3017 | result = build_nt (INDIRECT_REF, | |
3018 | stabilize_reference_1 (TREE_OPERAND (ref, 0))); | |
3019 | break; | |
3020 | ||
3021 | case COMPONENT_REF: | |
3022 | result = build_nt (COMPONENT_REF, | |
3023 | stabilize_reference (TREE_OPERAND (ref, 0)), | |
3024 | TREE_OPERAND (ref, 1)); | |
3025 | break; | |
3026 | ||
3027 | case BIT_FIELD_REF: | |
3028 | result = build_nt (BIT_FIELD_REF, | |
3029 | stabilize_reference (TREE_OPERAND (ref, 0)), | |
3030 | stabilize_reference_1 (TREE_OPERAND (ref, 1)), | |
3031 | stabilize_reference_1 (TREE_OPERAND (ref, 2))); | |
3032 | break; | |
3033 | ||
3034 | case ARRAY_REF: | |
3035 | result = build_nt (ARRAY_REF, | |
3036 | stabilize_reference (TREE_OPERAND (ref, 0)), | |
3037 | stabilize_reference_1 (TREE_OPERAND (ref, 1))); | |
3038 | break; | |
3039 | ||
c451a7a0 | 3040 | case COMPOUND_EXPR: |
7b8b9722 MS |
3041 | /* We cannot wrap the first expression in a SAVE_EXPR, as then |
3042 | it wouldn't be ignored. This matters when dealing with | |
3043 | volatiles. */ | |
3044 | return stabilize_reference_1 (ref); | |
c451a7a0 | 3045 | |
c36a127d RK |
3046 | case RTL_EXPR: |
3047 | result = build1 (INDIRECT_REF, TREE_TYPE (ref), | |
3048 | save_expr (build1 (ADDR_EXPR, | |
21f0e042 | 3049 | build_pointer_type (TREE_TYPE (ref)), |
c36a127d RK |
3050 | ref))); |
3051 | break; | |
3052 | ||
c451a7a0 | 3053 | |
c6a1db6c RS |
3054 | /* If arg isn't a kind of lvalue we recognize, make no change. |
3055 | Caller should recognize the error for an invalid lvalue. */ | |
3056 | default: | |
3057 | return ref; | |
3058 | ||
3059 | case ERROR_MARK: | |
3060 | return error_mark_node; | |
3061 | } | |
3062 | ||
3063 | TREE_TYPE (result) = TREE_TYPE (ref); | |
3064 | TREE_READONLY (result) = TREE_READONLY (ref); | |
3065 | TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref); | |
3066 | TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref); | |
c6a1db6c RS |
3067 | |
3068 | return result; | |
3069 | } | |
3070 | ||
3071 | /* Subroutine of stabilize_reference; this is called for subtrees of | |
3072 | references. Any expression with side-effects must be put in a SAVE_EXPR | |
3073 | to ensure that it is only evaluated once. | |
3074 | ||
3075 | We don't put SAVE_EXPR nodes around everything, because assigning very | |
3076 | simple expressions to temporaries causes us to miss good opportunities | |
3077 | for optimizations. Among other things, the opportunity to fold in the | |
3078 | addition of a constant into an addressing mode often gets lost, e.g. | |
3079 | "y[i+1] += x;". In general, we take the approach that we should not make | |
3080 | an assignment unless we are forced into it - i.e., that any non-side effect | |
3081 | operator should be allowed, and that cse should take care of coalescing | |
3082 | multiple utterances of the same expression should that prove fruitful. */ | |
3083 | ||
4745ddae | 3084 | tree |
c6a1db6c RS |
3085 | stabilize_reference_1 (e) |
3086 | tree e; | |
3087 | { | |
3088 | register tree result; | |
c6a1db6c RS |
3089 | register enum tree_code code = TREE_CODE (e); |
3090 | ||
af929c62 RK |
3091 | /* We cannot ignore const expressions because it might be a reference |
3092 | to a const array but whose index contains side-effects. But we can | |
3093 | ignore things that are actual constant or that already have been | |
3094 | handled by this function. */ | |
3095 | ||
3096 | if (TREE_CONSTANT (e) || code == SAVE_EXPR) | |
c6a1db6c RS |
3097 | return e; |
3098 | ||
3099 | switch (TREE_CODE_CLASS (code)) | |
3100 | { | |
3101 | case 'x': | |
3102 | case 't': | |
3103 | case 'd': | |
03646189 | 3104 | case 'b': |
c6a1db6c RS |
3105 | case '<': |
3106 | case 's': | |
3107 | case 'e': | |
3108 | case 'r': | |
3109 | /* If the expression has side-effects, then encase it in a SAVE_EXPR | |
3110 | so that it will only be evaluated once. */ | |
3111 | /* The reference (r) and comparison (<) classes could be handled as | |
3112 | below, but it is generally faster to only evaluate them once. */ | |
3113 | if (TREE_SIDE_EFFECTS (e)) | |
3114 | return save_expr (e); | |
3115 | return e; | |
3116 | ||
3117 | case 'c': | |
3118 | /* Constants need no processing. In fact, we should never reach | |
3119 | here. */ | |
3120 | return e; | |
3121 | ||
3122 | case '2': | |
ae698e41 RS |
3123 | /* Division is slow and tends to be compiled with jumps, |
3124 | especially the division by powers of 2 that is often | |
3125 | found inside of an array reference. So do it just once. */ | |
3126 | if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR | |
3127 | || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR | |
3128 | || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR | |
3129 | || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR) | |
3130 | return save_expr (e); | |
c6a1db6c RS |
3131 | /* Recursively stabilize each operand. */ |
3132 | result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)), | |
3133 | stabilize_reference_1 (TREE_OPERAND (e, 1))); | |
3134 | break; | |
3135 | ||
3136 | case '1': | |
3137 | /* Recursively stabilize each operand. */ | |
3138 | result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0))); | |
3139 | break; | |
a7fcb968 RK |
3140 | |
3141 | default: | |
3142 | abort (); | |
c6a1db6c RS |
3143 | } |
3144 | ||
3145 | TREE_TYPE (result) = TREE_TYPE (e); | |
3146 | TREE_READONLY (result) = TREE_READONLY (e); | |
3147 | TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e); | |
3148 | TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e); | |
c6a1db6c RS |
3149 | |
3150 | return result; | |
3151 | } | |
3152 | \f | |
3153 | /* Low-level constructors for expressions. */ | |
3154 | ||
3155 | /* Build an expression of code CODE, data type TYPE, | |
3156 | and operands as specified by the arguments ARG1 and following arguments. | |
3157 | Expressions and reference nodes can be created this way. | |
3158 | Constants, decls, types and misc nodes cannot be. */ | |
3159 | ||
3160 | tree | |
58782098 | 3161 | build VPARAMS ((enum tree_code code, tree tt, ...)) |
c6a1db6c | 3162 | { |
5148a72b | 3163 | #ifndef ANSI_PROTOTYPES |
c6a1db6c | 3164 | enum tree_code code; |
ba63ed56 RK |
3165 | tree tt; |
3166 | #endif | |
3167 | va_list p; | |
c6a1db6c RS |
3168 | register tree t; |
3169 | register int length; | |
3170 | register int i; | |
97ca93c3 | 3171 | int fro; |
c6a1db6c | 3172 | |
ba63ed56 | 3173 | VA_START (p, tt); |
c6a1db6c | 3174 | |
5148a72b | 3175 | #ifndef ANSI_PROTOTYPES |
c6a1db6c | 3176 | code = va_arg (p, enum tree_code); |
ba63ed56 RK |
3177 | tt = va_arg (p, tree); |
3178 | #endif | |
3179 | ||
c6a1db6c RS |
3180 | t = make_node (code); |
3181 | length = tree_code_length[(int) code]; | |
ba63ed56 | 3182 | TREE_TYPE (t) = tt; |
c6a1db6c | 3183 | |
97ca93c3 MM |
3184 | /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_RAISED for |
3185 | the result based on those same flags for the arguments. But, if | |
3186 | the arguments aren't really even `tree' expressions, we shouldn't | |
3187 | be trying to do this. */ | |
3188 | fro = first_rtl_op (code); | |
3189 | ||
c6a1db6c RS |
3190 | if (length == 2) |
3191 | { | |
3192 | /* This is equivalent to the loop below, but faster. */ | |
3193 | register tree arg0 = va_arg (p, tree); | |
3194 | register tree arg1 = va_arg (p, tree); | |
3195 | TREE_OPERAND (t, 0) = arg0; | |
3196 | TREE_OPERAND (t, 1) = arg1; | |
97ca93c3 MM |
3197 | if (arg0 && fro > 0) |
3198 | { | |
3199 | if (TREE_SIDE_EFFECTS (arg0)) | |
3200 | TREE_SIDE_EFFECTS (t) = 1; | |
97ca93c3 MM |
3201 | } |
3202 | if (arg1 && fro > 1) | |
3203 | { | |
3204 | if (TREE_SIDE_EFFECTS (arg1)) | |
3205 | TREE_SIDE_EFFECTS (t) = 1; | |
97ca93c3 | 3206 | } |
c6a1db6c RS |
3207 | } |
3208 | else if (length == 1) | |
3209 | { | |
3210 | register tree arg0 = va_arg (p, tree); | |
3211 | ||
3212 | /* Call build1 for this! */ | |
3213 | if (TREE_CODE_CLASS (code) != 's') | |
3214 | abort (); | |
3215 | TREE_OPERAND (t, 0) = arg0; | |
97ca93c3 MM |
3216 | if (fro > 0) |
3217 | { | |
3218 | if (arg0 && TREE_SIDE_EFFECTS (arg0)) | |
3219 | TREE_SIDE_EFFECTS (t) = 1; | |
97ca93c3 | 3220 | } |
c6a1db6c RS |
3221 | } |
3222 | else | |
3223 | { | |
3224 | for (i = 0; i < length; i++) | |
3225 | { | |
3226 | register tree operand = va_arg (p, tree); | |
3227 | TREE_OPERAND (t, i) = operand; | |
97ca93c3 | 3228 | if (operand && fro > i) |
c6a1db6c RS |
3229 | { |
3230 | if (TREE_SIDE_EFFECTS (operand)) | |
3231 | TREE_SIDE_EFFECTS (t) = 1; | |
c6a1db6c RS |
3232 | } |
3233 | } | |
3234 | } | |
3235 | va_end (p); | |
3236 | return t; | |
3237 | } | |
3238 | ||
3239 | /* Same as above, but only builds for unary operators. | |
3240 | Saves lions share of calls to `build'; cuts down use | |
3241 | of varargs, which is expensive for RISC machines. */ | |
0f41302f | 3242 | |
c6a1db6c RS |
3243 | tree |
3244 | build1 (code, type, node) | |
3245 | enum tree_code code; | |
3246 | tree type; | |
3247 | tree node; | |
3248 | { | |
0ac224f8 | 3249 | register struct obstack *obstack = expression_obstack; |
42cb11fc | 3250 | register int length; |
5e9defae | 3251 | #ifdef GATHER_STATISTICS |
c6a1db6c | 3252 | register tree_node_kind kind; |
5e9defae | 3253 | #endif |
c6a1db6c RS |
3254 | register tree t; |
3255 | ||
3256 | #ifdef GATHER_STATISTICS | |
3257 | if (TREE_CODE_CLASS (code) == 'r') | |
3258 | kind = r_kind; | |
3259 | else | |
3260 | kind = e_kind; | |
3261 | #endif | |
3262 | ||
c6a1db6c RS |
3263 | length = sizeof (struct tree_exp); |
3264 | ||
a3770a81 RH |
3265 | if (ggc_p) |
3266 | t = ggc_alloc_tree (length); | |
3267 | else | |
1fef02f6 RH |
3268 | { |
3269 | t = (tree) obstack_alloc (obstack, length); | |
3270 | memset ((PTR) t, 0, length); | |
3271 | } | |
c6a1db6c RS |
3272 | |
3273 | #ifdef GATHER_STATISTICS | |
3274 | tree_node_counts[(int)kind]++; | |
3275 | tree_node_sizes[(int)kind] += length; | |
3276 | #endif | |
3277 | ||
508f8149 | 3278 | TREE_TYPE (t) = type; |
c6a1db6c | 3279 | TREE_SET_CODE (t, code); |
23dfa477 | 3280 | TREE_SET_PERMANENT (t); |
c6a1db6c RS |
3281 | |
3282 | TREE_OPERAND (t, 0) = node; | |
97ca93c3 | 3283 | if (node && first_rtl_op (code) != 0) |
c6a1db6c RS |
3284 | { |
3285 | if (TREE_SIDE_EFFECTS (node)) | |
3286 | TREE_SIDE_EFFECTS (t) = 1; | |
c6a1db6c RS |
3287 | } |
3288 | ||
1fef02f6 RH |
3289 | switch (code) |
3290 | { | |
3291 | case INIT_EXPR: | |
3292 | case MODIFY_EXPR: | |
3293 | case VA_ARG_EXPR: | |
3294 | case RTL_EXPR: | |
3295 | case PREDECREMENT_EXPR: | |
3296 | case PREINCREMENT_EXPR: | |
3297 | case POSTDECREMENT_EXPR: | |
3298 | case POSTINCREMENT_EXPR: | |
3299 | /* All of these have side-effects, no matter what their | |
3300 | operands are. */ | |
3301 | TREE_SIDE_EFFECTS (t) = 1; | |
3302 | break; | |
3303 | ||
3304 | default: | |
3305 | break; | |
3306 | } | |
3307 | ||
c6a1db6c RS |
3308 | return t; |
3309 | } | |
3310 | ||
3311 | /* Similar except don't specify the TREE_TYPE | |
3312 | and leave the TREE_SIDE_EFFECTS as 0. | |
3313 | It is permissible for arguments to be null, | |
3314 | or even garbage if their values do not matter. */ | |
3315 | ||
3316 | tree | |
58782098 | 3317 | build_nt VPARAMS ((enum tree_code code, ...)) |
c6a1db6c | 3318 | { |
5148a72b | 3319 | #ifndef ANSI_PROTOTYPES |
c5ffba1a | 3320 | enum tree_code code; |
ba63ed56 RK |
3321 | #endif |
3322 | va_list p; | |
c6a1db6c RS |
3323 | register tree t; |
3324 | register int length; | |
3325 | register int i; | |
3326 | ||
ba63ed56 | 3327 | VA_START (p, code); |
c6a1db6c | 3328 | |
5148a72b | 3329 | #ifndef ANSI_PROTOTYPES |
c6a1db6c | 3330 | code = va_arg (p, enum tree_code); |
ba63ed56 RK |
3331 | #endif |
3332 | ||
c6a1db6c RS |
3333 | t = make_node (code); |
3334 | length = tree_code_length[(int) code]; | |
3335 | ||
3336 | for (i = 0; i < length; i++) | |
3337 | TREE_OPERAND (t, i) = va_arg (p, tree); | |
3338 | ||
3339 | va_end (p); | |
3340 | return t; | |
3341 | } | |
3342 | ||
3343 | /* Similar to `build_nt', except we build | |
3344 | on the temp_decl_obstack, regardless. */ | |
3345 | ||
3346 | tree | |
58782098 | 3347 | build_parse_node VPARAMS ((enum tree_code code, ...)) |
c6a1db6c | 3348 | { |
5148a72b | 3349 | #ifndef ANSI_PROTOTYPES |
c5ffba1a | 3350 | enum tree_code code; |
ba63ed56 | 3351 | #endif |
c6a1db6c RS |
3352 | register struct obstack *ambient_obstack = expression_obstack; |
3353 | va_list p; | |
c6a1db6c RS |
3354 | register tree t; |
3355 | register int length; | |
3356 | register int i; | |
3357 | ||
ba63ed56 | 3358 | VA_START (p, code); |
c6a1db6c | 3359 | |
5148a72b | 3360 | #ifndef ANSI_PROTOTYPES |
c6a1db6c | 3361 | code = va_arg (p, enum tree_code); |
ba63ed56 RK |
3362 | #endif |
3363 | ||
3364 | expression_obstack = &temp_decl_obstack; | |
3365 | ||
c6a1db6c RS |
3366 | t = make_node (code); |
3367 | length = tree_code_length[(int) code]; | |
3368 | ||
3369 | for (i = 0; i < length; i++) | |
3370 | TREE_OPERAND (t, i) = va_arg (p, tree); | |
3371 | ||
3372 | va_end (p); | |
3373 | expression_obstack = ambient_obstack; | |
3374 | return t; | |
3375 | } | |
3376 | ||
3377 | #if 0 | |
3378 | /* Commented out because this wants to be done very | |
3379 | differently. See cp-lex.c. */ | |
3380 | tree | |
3381 | build_op_identifier (op1, op2) | |
3382 | tree op1, op2; | |
3383 | { | |
3384 | register tree t = make_node (OP_IDENTIFIER); | |
3385 | TREE_PURPOSE (t) = op1; | |
3386 | TREE_VALUE (t) = op2; | |
3387 | return t; | |
3388 | } | |
3389 | #endif | |
3390 | \f | |
3391 | /* Create a DECL_... node of code CODE, name NAME and data type TYPE. | |
3392 | We do NOT enter this node in any sort of symbol table. | |
3393 | ||
3394 | layout_decl is used to set up the decl's storage layout. | |
3395 | Other slots are initialized to 0 or null pointers. */ | |
3396 | ||
3397 | tree | |
3398 | build_decl (code, name, type) | |
3399 | enum tree_code code; | |
3400 | tree name, type; | |
3401 | { | |
3402 | register tree t; | |
3403 | ||
3404 | t = make_node (code); | |
3405 | ||
3406 | /* if (type == error_mark_node) | |
3407 | type = integer_type_node; */ | |
3408 | /* That is not done, deliberately, so that having error_mark_node | |
3409 | as the type can suppress useless errors in the use of this variable. */ | |
3410 | ||
3411 | DECL_NAME (t) = name; | |
3412 | DECL_ASSEMBLER_NAME (t) = name; | |
3413 | TREE_TYPE (t) = type; | |
3414 | ||
3415 | if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL) | |
3416 | layout_decl (t, 0); | |
3417 | else if (code == FUNCTION_DECL) | |
3418 | DECL_MODE (t) = FUNCTION_MODE; | |
3419 | ||
3420 | return t; | |
3421 | } | |
3422 | \f | |
3423 | /* BLOCK nodes are used to represent the structure of binding contours | |
3424 | and declarations, once those contours have been exited and their contents | |
52d2830e | 3425 | compiled. This information is used for outputting debugging info. */ |
c6a1db6c RS |
3426 | |
3427 | tree | |
3428 | build_block (vars, tags, subblocks, supercontext, chain) | |
272df862 | 3429 | tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain; |
c6a1db6c RS |
3430 | { |
3431 | register tree block = make_node (BLOCK); | |
d4b60170 | 3432 | |
c6a1db6c | 3433 | BLOCK_VARS (block) = vars; |
c6a1db6c RS |
3434 | BLOCK_SUBBLOCKS (block) = subblocks; |
3435 | BLOCK_SUPERCONTEXT (block) = supercontext; | |
3436 | BLOCK_CHAIN (block) = chain; | |
3437 | return block; | |
3438 | } | |
bf1e5319 APB |
3439 | |
3440 | /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact | |
3441 | location where an expression or an identifier were encountered. It | |
3442 | is necessary for languages where the frontend parser will handle | |
3443 | recursively more than one file (Java is one of them). */ | |
3444 | ||
3445 | tree | |
3446 | build_expr_wfl (node, file, line, col) | |
3447 | tree node; | |
37b37199 | 3448 | const char *file; |
bf1e5319 APB |
3449 | int line, col; |
3450 | { | |
37b37199 | 3451 | static const char *last_file = 0; |
d4b60170 | 3452 | static tree last_filenode = NULL_TREE; |
bf1e5319 | 3453 | register tree wfl = make_node (EXPR_WITH_FILE_LOCATION); |
9fe9a2e1 | 3454 | |
bf1e5319 | 3455 | EXPR_WFL_NODE (wfl) = node; |
bf1e5319 | 3456 | EXPR_WFL_SET_LINECOL (wfl, line, col); |
9fe9a2e1 APB |
3457 | if (file != last_file) |
3458 | { | |
3459 | last_file = file; | |
3460 | last_filenode = file ? get_identifier (file) : NULL_TREE; | |
3461 | } | |
d4b60170 | 3462 | |
9fe9a2e1 APB |
3463 | EXPR_WFL_FILENAME_NODE (wfl) = last_filenode; |
3464 | if (node) | |
3465 | { | |
3466 | TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node); | |
3467 | TREE_TYPE (wfl) = TREE_TYPE (node); | |
3468 | } | |
d4b60170 | 3469 | |
bf1e5319 APB |
3470 | return wfl; |
3471 | } | |
c6a1db6c | 3472 | \f |
1a2927d2 | 3473 | /* Return a declaration like DDECL except that its DECL_MACHINE_ATTRIBUTE |
0f41302f | 3474 | is ATTRIBUTE. */ |
1a2927d2 RK |
3475 | |
3476 | tree | |
3477 | build_decl_attribute_variant (ddecl, attribute) | |
3478 | tree ddecl, attribute; | |
3479 | { | |
3480 | DECL_MACHINE_ATTRIBUTES (ddecl) = attribute; | |
3481 | return ddecl; | |
3482 | } | |
3483 | ||
91e97eb8 RK |
3484 | /* Return a type like TTYPE except that its TYPE_ATTRIBUTE |
3485 | is ATTRIBUTE. | |
3486 | ||
f8a89236 | 3487 | Record such modified types already made so we don't make duplicates. */ |
91e97eb8 RK |
3488 | |
3489 | tree | |
3490 | build_type_attribute_variant (ttype, attribute) | |
3491 | tree ttype, attribute; | |
3492 | { | |
3493 | if ( ! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute)) | |
3494 | { | |
05bccae2 | 3495 | unsigned int hashcode; |
91e97eb8 RK |
3496 | tree ntype; |
3497 | ||
14a774a9 | 3498 | push_obstacks (TYPE_OBSTACK (ttype), TYPE_OBSTACK (ttype)); |
91e97eb8 | 3499 | ntype = copy_node (ttype); |
91e97eb8 RK |
3500 | |
3501 | TYPE_POINTER_TO (ntype) = 0; | |
3502 | TYPE_REFERENCE_TO (ntype) = 0; | |
3503 | TYPE_ATTRIBUTES (ntype) = attribute; | |
3504 | ||
3505 | /* Create a new main variant of TYPE. */ | |
3506 | TYPE_MAIN_VARIANT (ntype) = ntype; | |
3507 | TYPE_NEXT_VARIANT (ntype) = 0; | |
3932261a | 3508 | set_type_quals (ntype, TYPE_UNQUALIFIED); |
91e97eb8 | 3509 | |
05bccae2 RK |
3510 | hashcode = (TYPE_HASH (TREE_CODE (ntype)) |
3511 | + TYPE_HASH (TREE_TYPE (ntype)) | |
3512 | + attribute_hash_list (attribute)); | |
91e97eb8 RK |
3513 | |
3514 | switch (TREE_CODE (ntype)) | |
3515 | { | |
e9a25f70 JL |
3516 | case FUNCTION_TYPE: |
3517 | hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype)); | |
3518 | break; | |
3519 | case ARRAY_TYPE: | |
3520 | hashcode += TYPE_HASH (TYPE_DOMAIN (ntype)); | |
3521 | break; | |
3522 | case INTEGER_TYPE: | |
3523 | hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype)); | |
3524 | break; | |
3525 | case REAL_TYPE: | |
3526 | hashcode += TYPE_HASH (TYPE_PRECISION (ntype)); | |
3527 | break; | |
3528 | default: | |
3529 | break; | |
91e97eb8 RK |
3530 | } |
3531 | ||
3532 | ntype = type_hash_canon (hashcode, ntype); | |
3932261a | 3533 | ttype = build_qualified_type (ntype, TYPE_QUALS (ttype)); |
14a774a9 | 3534 | pop_obstacks (); |
91e97eb8 RK |
3535 | } |
3536 | ||
3537 | return ttype; | |
3538 | } | |
1a2927d2 | 3539 | |
4084f789 RK |
3540 | /* Return a 1 if ATTR_NAME and ATTR_ARGS is valid for either declaration DECL |
3541 | or type TYPE and 0 otherwise. Validity is determined the configuration | |
0f41302f | 3542 | macros VALID_MACHINE_DECL_ATTRIBUTE and VALID_MACHINE_TYPE_ATTRIBUTE. */ |
1a2927d2 RK |
3543 | |
3544 | int | |
4084f789 | 3545 | valid_machine_attribute (attr_name, attr_args, decl, type) |
c84e2712 KG |
3546 | tree attr_name; |
3547 | tree attr_args ATTRIBUTE_UNUSED; | |
3548 | tree decl ATTRIBUTE_UNUSED; | |
3549 | tree type ATTRIBUTE_UNUSED; | |
1a2927d2 | 3550 | { |
ab87f8c8 | 3551 | int validated = 0; |
51723711 | 3552 | #ifdef VALID_MACHINE_DECL_ATTRIBUTE |
4084f789 | 3553 | tree decl_attr_list = decl != 0 ? DECL_MACHINE_ATTRIBUTES (decl) : 0; |
51723711 KG |
3554 | #endif |
3555 | #ifdef VALID_MACHINE_TYPE_ATTRIBUTE | |
1a2927d2 | 3556 | tree type_attr_list = TYPE_ATTRIBUTES (type); |
51723711 | 3557 | #endif |
1a2927d2 | 3558 | |
2a3c15b5 DE |
3559 | if (TREE_CODE (attr_name) != IDENTIFIER_NODE) |
3560 | abort (); | |
4084f789 | 3561 | |
1a2927d2 | 3562 | #ifdef VALID_MACHINE_DECL_ATTRIBUTE |
4084f789 | 3563 | if (decl != 0 |
d4b60170 RK |
3564 | && VALID_MACHINE_DECL_ATTRIBUTE (decl, decl_attr_list, attr_name, |
3565 | attr_args)) | |
1a2927d2 | 3566 | { |
2a3c15b5 DE |
3567 | tree attr = lookup_attribute (IDENTIFIER_POINTER (attr_name), |
3568 | decl_attr_list); | |
1a2927d2 | 3569 | |
2a3c15b5 DE |
3570 | if (attr != NULL_TREE) |
3571 | { | |
3572 | /* Override existing arguments. Declarations are unique so we can | |
3573 | modify this in place. */ | |
3574 | TREE_VALUE (attr) = attr_args; | |
3575 | } | |
3576 | else | |
3577 | { | |
3578 | decl_attr_list = tree_cons (attr_name, attr_args, decl_attr_list); | |
3e3d7e77 RK |
3579 | decl = build_decl_attribute_variant (decl, decl_attr_list); |
3580 | } | |
1a2927d2 | 3581 | |
ab87f8c8 | 3582 | validated = 1; |
1a2927d2 RK |
3583 | } |
3584 | #endif | |
3585 | ||
3586 | #ifdef VALID_MACHINE_TYPE_ATTRIBUTE | |
ab87f8c8 | 3587 | if (validated) |
226c39d3 JM |
3588 | /* Don't apply the attribute to both the decl and the type. */; |
3589 | else if (VALID_MACHINE_TYPE_ATTRIBUTE (type, type_attr_list, attr_name, | |
3590 | attr_args)) | |
1a2927d2 | 3591 | { |
2a3c15b5 DE |
3592 | tree attr = lookup_attribute (IDENTIFIER_POINTER (attr_name), |
3593 | type_attr_list); | |
3594 | ||
3595 | if (attr != NULL_TREE) | |
3e3d7e77 | 3596 | { |
2a3c15b5 DE |
3597 | /* Override existing arguments. |
3598 | ??? This currently works since attribute arguments are not | |
3599 | included in `attribute_hash_list'. Something more complicated | |
3600 | may be needed in the future. */ | |
3601 | TREE_VALUE (attr) = attr_args; | |
3602 | } | |
3603 | else | |
3604 | { | |
f022f9bc RE |
3605 | /* If this is part of a declaration, create a type variant, |
3606 | otherwise, this is part of a type definition, so add it | |
3607 | to the base type. */ | |
2a3c15b5 | 3608 | type_attr_list = tree_cons (attr_name, attr_args, type_attr_list); |
f022f9bc RE |
3609 | if (decl != 0) |
3610 | type = build_type_attribute_variant (type, type_attr_list); | |
3611 | else | |
3612 | TYPE_ATTRIBUTES (type) = type_attr_list; | |
3e3d7e77 | 3613 | } |
d4b60170 | 3614 | |
4084f789 RK |
3615 | if (decl != 0) |
3616 | TREE_TYPE (decl) = type; | |
d4b60170 | 3617 | |
ab87f8c8 | 3618 | validated = 1; |
1a2927d2 | 3619 | } |
15c8ec1c RK |
3620 | |
3621 | /* Handle putting a type attribute on pointer-to-function-type by putting | |
3622 | the attribute on the function type. */ | |
e5e809f4 | 3623 | else if (POINTER_TYPE_P (type) |
15c8ec1c RK |
3624 | && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE |
3625 | && VALID_MACHINE_TYPE_ATTRIBUTE (TREE_TYPE (type), type_attr_list, | |
3626 | attr_name, attr_args)) | |
3627 | { | |
3628 | tree inner_type = TREE_TYPE (type); | |
3629 | tree inner_attr_list = TYPE_ATTRIBUTES (inner_type); | |
3630 | tree attr = lookup_attribute (IDENTIFIER_POINTER (attr_name), | |
3631 | type_attr_list); | |
3632 | ||
3633 | if (attr != NULL_TREE) | |
3634 | TREE_VALUE (attr) = attr_args; | |
3635 | else | |
3636 | { | |
3637 | inner_attr_list = tree_cons (attr_name, attr_args, inner_attr_list); | |
3638 | inner_type = build_type_attribute_variant (inner_type, | |
3639 | inner_attr_list); | |
3640 | } | |
3641 | ||
3642 | if (decl != 0) | |
3643 | TREE_TYPE (decl) = build_pointer_type (inner_type); | |
ace3c40a JM |
3644 | else |
3645 | { | |
3646 | /* Clear TYPE_POINTER_TO for the old inner type, since | |
3647 | `type' won't be pointing to it anymore. */ | |
3648 | TYPE_POINTER_TO (TREE_TYPE (type)) = NULL_TREE; | |
3649 | TREE_TYPE (type) = inner_type; | |
3650 | } | |
15c8ec1c | 3651 | |
ab87f8c8 | 3652 | validated = 1; |
15c8ec1c | 3653 | } |
1a2927d2 RK |
3654 | #endif |
3655 | ||
ab87f8c8 | 3656 | return validated; |
1a2927d2 | 3657 | } |
2a3c15b5 DE |
3658 | |
3659 | /* Return non-zero if IDENT is a valid name for attribute ATTR, | |
3660 | or zero if not. | |
3661 | ||
3662 | We try both `text' and `__text__', ATTR may be either one. */ | |
3663 | /* ??? It might be a reasonable simplification to require ATTR to be only | |
3664 | `text'. One might then also require attribute lists to be stored in | |
3665 | their canonicalized form. */ | |
3666 | ||
3667 | int | |
3668 | is_attribute_p (attr, ident) | |
37b37199 | 3669 | const char *attr; |
2a3c15b5 DE |
3670 | tree ident; |
3671 | { | |
3672 | int ident_len, attr_len; | |
3673 | char *p; | |
3674 | ||
3675 | if (TREE_CODE (ident) != IDENTIFIER_NODE) | |
3676 | return 0; | |
3677 | ||
3678 | if (strcmp (attr, IDENTIFIER_POINTER (ident)) == 0) | |
3679 | return 1; | |
3680 | ||
3681 | p = IDENTIFIER_POINTER (ident); | |
3682 | ident_len = strlen (p); | |
3683 | attr_len = strlen (attr); | |
3684 | ||
3685 | /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */ | |
3686 | if (attr[0] == '_') | |
3687 | { | |
3688 | if (attr[1] != '_' | |
3689 | || attr[attr_len - 2] != '_' | |
3690 | || attr[attr_len - 1] != '_') | |
3691 | abort (); | |
3692 | if (ident_len == attr_len - 4 | |
3693 | && strncmp (attr + 2, p, attr_len - 4) == 0) | |
3694 | return 1; | |
3695 | } | |
3696 | else | |
3697 | { | |
3698 | if (ident_len == attr_len + 4 | |
3699 | && p[0] == '_' && p[1] == '_' | |
3700 | && p[ident_len - 2] == '_' && p[ident_len - 1] == '_' | |
3701 | && strncmp (attr, p + 2, attr_len) == 0) | |
3702 | return 1; | |
3703 | } | |
3704 | ||
3705 | return 0; | |
3706 | } | |
3707 | ||
3708 | /* Given an attribute name and a list of attributes, return a pointer to the | |
3709 | attribute's list element if the attribute is part of the list, or NULL_TREE | |
3710 | if not found. */ | |
3711 | ||
3712 | tree | |
3713 | lookup_attribute (attr_name, list) | |
37b37199 | 3714 | const char *attr_name; |
2a3c15b5 DE |
3715 | tree list; |
3716 | { | |
3717 | tree l; | |
3718 | ||
3719 | for (l = list; l; l = TREE_CHAIN (l)) | |
3720 | { | |
3721 | if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE) | |
3722 | abort (); | |
3723 | if (is_attribute_p (attr_name, TREE_PURPOSE (l))) | |
3724 | return l; | |
3725 | } | |
3726 | ||
3727 | return NULL_TREE; | |
3728 | } | |
f3209e2f DE |
3729 | |
3730 | /* Return an attribute list that is the union of a1 and a2. */ | |
3731 | ||
3732 | tree | |
3733 | merge_attributes (a1, a2) | |
3734 | register tree a1, a2; | |
3735 | { | |
3736 | tree attributes; | |
3737 | ||
3738 | /* Either one unset? Take the set one. */ | |
3739 | ||
d4b60170 | 3740 | if ((attributes = a1) == 0) |
f3209e2f DE |
3741 | attributes = a2; |
3742 | ||
3743 | /* One that completely contains the other? Take it. */ | |
3744 | ||
d4b60170 | 3745 | else if (a2 != 0 && ! attribute_list_contained (a1, a2)) |
51723711 | 3746 | { |
f3209e2f DE |
3747 | if (attribute_list_contained (a2, a1)) |
3748 | attributes = a2; | |
3749 | else | |
3750 | { | |
3751 | /* Pick the longest list, and hang on the other list. */ | |
3752 | /* ??? For the moment we punt on the issue of attrs with args. */ | |
3753 | ||
3754 | if (list_length (a1) < list_length (a2)) | |
3755 | attributes = a2, a2 = a1; | |
3756 | ||
d4b60170 | 3757 | for (; a2 != 0; a2 = TREE_CHAIN (a2)) |
f3209e2f DE |
3758 | if (lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)), |
3759 | attributes) == NULL_TREE) | |
3760 | { | |
3761 | a1 = copy_node (a2); | |
3762 | TREE_CHAIN (a1) = attributes; | |
3763 | attributes = a1; | |
3764 | } | |
3765 | } | |
51723711 | 3766 | } |
f3209e2f DE |
3767 | return attributes; |
3768 | } | |
d9525bec BK |
3769 | |
3770 | /* Given types T1 and T2, merge their attributes and return | |
3771 | the result. */ | |
3772 | ||
3773 | tree | |
3774 | merge_machine_type_attributes (t1, t2) | |
3775 | tree t1, t2; | |
3776 | { | |
3777 | #ifdef MERGE_MACHINE_TYPE_ATTRIBUTES | |
3778 | return MERGE_MACHINE_TYPE_ATTRIBUTES (t1, t2); | |
3779 | #else | |
3780 | return merge_attributes (TYPE_ATTRIBUTES (t1), | |
3781 | TYPE_ATTRIBUTES (t2)); | |
3782 | #endif | |
3783 | } | |
3784 | ||
3785 | /* Given decls OLDDECL and NEWDECL, merge their attributes and return | |
3786 | the result. */ | |
3787 | ||
3788 | tree | |
3789 | merge_machine_decl_attributes (olddecl, newdecl) | |
3790 | tree olddecl, newdecl; | |
3791 | { | |
3792 | #ifdef MERGE_MACHINE_DECL_ATTRIBUTES | |
3793 | return MERGE_MACHINE_DECL_ATTRIBUTES (olddecl, newdecl); | |
3794 | #else | |
3795 | return merge_attributes (DECL_MACHINE_ATTRIBUTES (olddecl), | |
3796 | DECL_MACHINE_ATTRIBUTES (newdecl)); | |
3797 | #endif | |
3798 | } | |
91e97eb8 | 3799 | \f |
3932261a MM |
3800 | /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask |
3801 | of the various TYPE_QUAL values. */ | |
c6a1db6c | 3802 | |
3932261a MM |
3803 | static void |
3804 | set_type_quals (type, type_quals) | |
3805 | tree type; | |
3806 | int type_quals; | |
3807 | { | |
3808 | TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0; | |
3809 | TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0; | |
3810 | TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0; | |
3811 | } | |
c6a1db6c | 3812 | |
3932261a MM |
3813 | /* Given a type node TYPE and a TYPE_QUALIFIER_SET, return a type for |
3814 | the same kind of data as TYPE describes. Variants point to the | |
3815 | "main variant" (which has no qualifiers set) via TYPE_MAIN_VARIANT, | |
3816 | and it points to a chain of other variants so that duplicate | |
3817 | variants are never made. Only main variants should ever appear as | |
3818 | types of expressions. */ | |
c6a1db6c RS |
3819 | |
3820 | tree | |
3932261a | 3821 | build_qualified_type (type, type_quals) |
c6a1db6c | 3822 | tree type; |
3932261a | 3823 | int type_quals; |
c6a1db6c | 3824 | { |
2c3dd6b7 | 3825 | register tree t; |
3932261a | 3826 | |
e24fa534 JW |
3827 | /* Search the chain of variants to see if there is already one there just |
3828 | like the one we need to have. If so, use that existing one. We must | |
3829 | preserve the TYPE_NAME, since there is code that depends on this. */ | |
3830 | ||
b217d7fe | 3831 | for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) |
3932261a | 3832 | if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type)) |
e24fa534 | 3833 | return t; |
c6a1db6c RS |
3834 | |
3835 | /* We need a new one. */ | |
2c3dd6b7 | 3836 | t = build_type_copy (type); |
3932261a | 3837 | set_type_quals (t, type_quals); |
c6a1db6c RS |
3838 | return t; |
3839 | } | |
b4ac57ab RS |
3840 | |
3841 | /* Create a new variant of TYPE, equivalent but distinct. | |
3842 | This is so the caller can modify it. */ | |
3843 | ||
3844 | tree | |
3845 | build_type_copy (type) | |
3846 | tree type; | |
3847 | { | |
3848 | register tree t, m = TYPE_MAIN_VARIANT (type); | |
3849 | register struct obstack *ambient_obstack = current_obstack; | |
3850 | ||
d9cbc259 | 3851 | current_obstack = TYPE_OBSTACK (type); |
b4ac57ab | 3852 | t = copy_node (type); |
d9cbc259 RK |
3853 | current_obstack = ambient_obstack; |
3854 | ||
b4ac57ab RS |
3855 | TYPE_POINTER_TO (t) = 0; |
3856 | TYPE_REFERENCE_TO (t) = 0; | |
3857 | ||
3858 | /* Add this type to the chain of variants of TYPE. */ | |
3859 | TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m); | |
3860 | TYPE_NEXT_VARIANT (m) = t; | |
3861 | ||
b4ac57ab RS |
3862 | return t; |
3863 | } | |
c6a1db6c RS |
3864 | \f |
3865 | /* Hashing of types so that we don't make duplicates. | |
3866 | The entry point is `type_hash_canon'. */ | |
3867 | ||
c6a1db6c RS |
3868 | /* Compute a hash code for a list of types (chain of TREE_LIST nodes |
3869 | with types in the TREE_VALUE slots), by adding the hash codes | |
3870 | of the individual types. */ | |
3871 | ||
05bccae2 | 3872 | unsigned int |
c6a1db6c RS |
3873 | type_hash_list (list) |
3874 | tree list; | |
3875 | { | |
05bccae2 | 3876 | unsigned int hashcode; |
c6a1db6c | 3877 | register tree tail; |
d4b60170 | 3878 | |
c6a1db6c RS |
3879 | for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail)) |
3880 | hashcode += TYPE_HASH (TREE_VALUE (tail)); | |
d4b60170 | 3881 | |
c6a1db6c RS |
3882 | return hashcode; |
3883 | } | |
3884 | ||
3885 | /* Look in the type hash table for a type isomorphic to TYPE. | |
3886 | If one is found, return it. Otherwise return 0. */ | |
3887 | ||
3888 | tree | |
3889 | type_hash_lookup (hashcode, type) | |
05bccae2 | 3890 | unsigned int hashcode; |
c6a1db6c RS |
3891 | tree type; |
3892 | { | |
3893 | register struct type_hash *h; | |
da48638e AH |
3894 | |
3895 | /* The TYPE_ALIGN field of a type is set by layout_type(), so we | |
3896 | must call that routine before comparing TYPE_ALIGNs. */ | |
3897 | layout_type (type); | |
3898 | ||
c6a1db6c RS |
3899 | for (h = type_hash_table[hashcode % TYPE_HASH_SIZE]; h; h = h->next) |
3900 | if (h->hashcode == hashcode | |
3901 | && TREE_CODE (h->type) == TREE_CODE (type) | |
3902 | && TREE_TYPE (h->type) == TREE_TYPE (type) | |
91e97eb8 RK |
3903 | && attribute_list_equal (TYPE_ATTRIBUTES (h->type), |
3904 | TYPE_ATTRIBUTES (type)) | |
da48638e | 3905 | && TYPE_ALIGN (h->type) == TYPE_ALIGN (type) |
c6a1db6c RS |
3906 | && (TYPE_MAX_VALUE (h->type) == TYPE_MAX_VALUE (type) |
3907 | || tree_int_cst_equal (TYPE_MAX_VALUE (h->type), | |
3908 | TYPE_MAX_VALUE (type))) | |
3909 | && (TYPE_MIN_VALUE (h->type) == TYPE_MIN_VALUE (type) | |
3910 | || tree_int_cst_equal (TYPE_MIN_VALUE (h->type), | |
3911 | TYPE_MIN_VALUE (type))) | |
364e1f1c | 3912 | /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE. */ |
c6a1db6c RS |
3913 | && (TYPE_DOMAIN (h->type) == TYPE_DOMAIN (type) |
3914 | || (TYPE_DOMAIN (h->type) | |
3915 | && TREE_CODE (TYPE_DOMAIN (h->type)) == TREE_LIST | |
3916 | && TYPE_DOMAIN (type) | |
3917 | && TREE_CODE (TYPE_DOMAIN (type)) == TREE_LIST | |
364e1f1c RK |
3918 | && type_list_equal (TYPE_DOMAIN (h->type), |
3919 | TYPE_DOMAIN (type))))) | |
c6a1db6c | 3920 | return h->type; |
d4b60170 | 3921 | |
c6a1db6c RS |
3922 | return 0; |
3923 | } | |
3924 | ||
3925 | /* Add an entry to the type-hash-table | |
3926 | for a type TYPE whose hash code is HASHCODE. */ | |
3927 | ||
3928 | void | |
3929 | type_hash_add (hashcode, type) | |
05bccae2 | 3930 | unsigned int hashcode; |
c6a1db6c RS |
3931 | tree type; |
3932 | { | |
3933 | register struct type_hash *h; | |
3934 | ||
63ebc275 | 3935 | h = (struct type_hash *) permalloc (sizeof (struct type_hash)); |
c6a1db6c RS |
3936 | h->hashcode = hashcode; |
3937 | h->type = type; | |
3938 | h->next = type_hash_table[hashcode % TYPE_HASH_SIZE]; | |
3939 | type_hash_table[hashcode % TYPE_HASH_SIZE] = h; | |
3940 | } | |
3941 | ||
3942 | /* Given TYPE, and HASHCODE its hash code, return the canonical | |
3943 | object for an identical type if one already exists. | |
3944 | Otherwise, return TYPE, and record it as the canonical object | |
3945 | if it is a permanent object. | |
3946 | ||
3947 | To use this function, first create a type of the sort you want. | |
3948 | Then compute its hash code from the fields of the type that | |
3949 | make it different from other similar types. | |
3950 | Then call this function and use the value. | |
3951 | This function frees the type you pass in if it is a duplicate. */ | |
3952 | ||
3953 | /* Set to 1 to debug without canonicalization. Never set by program. */ | |
3954 | int debug_no_type_hash = 0; | |
3955 | ||
3956 | tree | |
3957 | type_hash_canon (hashcode, type) | |
05bccae2 | 3958 | unsigned int hashcode; |
c6a1db6c RS |
3959 | tree type; |
3960 | { | |
3961 | tree t1; | |
3962 | ||
3963 | if (debug_no_type_hash) | |
3964 | return type; | |
3965 | ||
3966 | t1 = type_hash_lookup (hashcode, type); | |
3967 | if (t1 != 0) | |
3968 | { | |
a3770a81 RH |
3969 | if (!ggc_p) |
3970 | obstack_free (TYPE_OBSTACK (type), type); | |
d4b60170 | 3971 | |
c6a1db6c RS |
3972 | #ifdef GATHER_STATISTICS |
3973 | tree_node_counts[(int)t_kind]--; | |
3974 | tree_node_sizes[(int)t_kind] -= sizeof (struct tree_type); | |
3975 | #endif | |
3976 | return t1; | |
3977 | } | |
3978 | ||
af493865 | 3979 | /* If this is a permanent type, record it for later reuse. */ |
858e574f | 3980 | if (ggc_p || TREE_PERMANENT (type)) |
c6a1db6c RS |
3981 | type_hash_add (hashcode, type); |
3982 | ||
3983 | return type; | |
3984 | } | |
3985 | ||
87ff9c8e RH |
3986 | /* Mark ARG (which is really a struct type_hash **) for GC. */ |
3987 | ||
3988 | static void | |
3989 | mark_type_hash (arg) | |
3990 | void *arg; | |
3991 | { | |
3992 | struct type_hash *t = *(struct type_hash **) arg; | |
3993 | ||
3994 | while (t) | |
3995 | { | |
3996 | ggc_mark_tree (t->type); | |
3997 | t = t->next; | |
3998 | } | |
3999 | } | |
4000 | ||
2a3c15b5 DE |
4001 | /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes |
4002 | with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots), | |
4003 | by adding the hash codes of the individual attributes. */ | |
3e3d7e77 | 4004 | |
05bccae2 | 4005 | unsigned int |
2a3c15b5 DE |
4006 | attribute_hash_list (list) |
4007 | tree list; | |
3e3d7e77 | 4008 | { |
05bccae2 | 4009 | unsigned int hashcode; |
2a3c15b5 | 4010 | register tree tail; |
d4b60170 | 4011 | |
2a3c15b5 DE |
4012 | for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail)) |
4013 | /* ??? Do we want to add in TREE_VALUE too? */ | |
4014 | hashcode += TYPE_HASH (TREE_PURPOSE (tail)); | |
4015 | return hashcode; | |
3e3d7e77 RK |
4016 | } |
4017 | ||
91e97eb8 RK |
4018 | /* Given two lists of attributes, return true if list l2 is |
4019 | equivalent to l1. */ | |
4020 | ||
4021 | int | |
4022 | attribute_list_equal (l1, l2) | |
4023 | tree l1, l2; | |
4024 | { | |
4025 | return attribute_list_contained (l1, l2) | |
4026 | && attribute_list_contained (l2, l1); | |
4027 | } | |
4028 | ||
2a3c15b5 DE |
4029 | /* Given two lists of attributes, return true if list L2 is |
4030 | completely contained within L1. */ | |
4031 | /* ??? This would be faster if attribute names were stored in a canonicalized | |
4032 | form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method | |
4033 | must be used to show these elements are equivalent (which they are). */ | |
4034 | /* ??? It's not clear that attributes with arguments will always be handled | |
4035 | correctly. */ | |
91e97eb8 RK |
4036 | |
4037 | int | |
4038 | attribute_list_contained (l1, l2) | |
4039 | tree l1, l2; | |
4040 | { | |
4041 | register tree t1, t2; | |
4042 | ||
4043 | /* First check the obvious, maybe the lists are identical. */ | |
4044 | if (l1 == l2) | |
4045 | return 1; | |
4046 | ||
2a3c15b5 | 4047 | /* Maybe the lists are similar. */ |
91e97eb8 | 4048 | for (t1 = l1, t2 = l2; |
d4b60170 | 4049 | t1 != 0 && t2 != 0 |
2a3c15b5 | 4050 | && TREE_PURPOSE (t1) == TREE_PURPOSE (t2) |
91e97eb8 RK |
4051 | && TREE_VALUE (t1) == TREE_VALUE (t2); |
4052 | t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)); | |
4053 | ||
4054 | /* Maybe the lists are equal. */ | |
4055 | if (t1 == 0 && t2 == 0) | |
4056 | return 1; | |
4057 | ||
d4b60170 | 4058 | for (; t2 != 0; t2 = TREE_CHAIN (t2)) |
2a3c15b5 | 4059 | { |
364e1f1c RK |
4060 | tree attr |
4061 | = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1); | |
2a3c15b5 | 4062 | |
d4b60170 | 4063 | if (attr == 0) |
91e97eb8 | 4064 | return 0; |
d4b60170 | 4065 | |
2a3c15b5 DE |
4066 | if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1) |
4067 | return 0; | |
4068 | } | |
3e3d7e77 | 4069 | |
91e97eb8 RK |
4070 | return 1; |
4071 | } | |
4072 | ||
c6a1db6c RS |
4073 | /* Given two lists of types |
4074 | (chains of TREE_LIST nodes with types in the TREE_VALUE slots) | |
4075 | return 1 if the lists contain the same types in the same order. | |
4076 | Also, the TREE_PURPOSEs must match. */ | |
4077 | ||
4078 | int | |
4079 | type_list_equal (l1, l2) | |
4080 | tree l1, l2; | |
4081 | { | |
4082 | register tree t1, t2; | |
364e1f1c | 4083 | |
c6a1db6c | 4084 | for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)) |
364e1f1c RK |
4085 | if (TREE_VALUE (t1) != TREE_VALUE (t2) |
4086 | || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2) | |
bbda4250 JM |
4087 | && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)) |
4088 | && (TREE_TYPE (TREE_PURPOSE (t1)) | |
4089 | == TREE_TYPE (TREE_PURPOSE (t2)))))) | |
364e1f1c | 4090 | return 0; |
c6a1db6c RS |
4091 | |
4092 | return t1 == t2; | |
4093 | } | |
4094 | ||
4095 | /* Nonzero if integer constants T1 and T2 | |
4096 | represent the same constant value. */ | |
4097 | ||
4098 | int | |
4099 | tree_int_cst_equal (t1, t2) | |
4100 | tree t1, t2; | |
4101 | { | |
4102 | if (t1 == t2) | |
4103 | return 1; | |
d4b60170 | 4104 | |
c6a1db6c RS |
4105 | if (t1 == 0 || t2 == 0) |
4106 | return 0; | |
d4b60170 | 4107 | |
c6a1db6c RS |
4108 | if (TREE_CODE (t1) == INTEGER_CST |
4109 | && TREE_CODE (t2) == INTEGER_CST | |
4110 | && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) | |
4111 | && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2)) | |
4112 | return 1; | |
d4b60170 | 4113 | |
c6a1db6c RS |
4114 | return 0; |
4115 | } | |
4116 | ||
4117 | /* Nonzero if integer constants T1 and T2 represent values that satisfy <. | |
4118 | The precise way of comparison depends on their data type. */ | |
4119 | ||
4120 | int | |
4121 | tree_int_cst_lt (t1, t2) | |
4122 | tree t1, t2; | |
4123 | { | |
4124 | if (t1 == t2) | |
4125 | return 0; | |
4126 | ||
d4b60170 | 4127 | if (! TREE_UNSIGNED (TREE_TYPE (t1))) |
c6a1db6c | 4128 | return INT_CST_LT (t1, t2); |
d4b60170 | 4129 | |
c6a1db6c RS |
4130 | return INT_CST_LT_UNSIGNED (t1, t2); |
4131 | } | |
4132 | ||
665f2503 RK |
4133 | /* Return 1 if T is an INTEGER_CST that can be represented in a single |
4134 | HOST_WIDE_INT value. If POS is nonzero, the result must be positive. */ | |
4135 | ||
4136 | int | |
4137 | host_integerp (t, pos) | |
4138 | tree t; | |
4139 | int pos; | |
4140 | { | |
4141 | return (TREE_CODE (t) == INTEGER_CST | |
4142 | && ! TREE_OVERFLOW (t) | |
4143 | && ((TREE_INT_CST_HIGH (t) == 0 | |
4144 | && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0) | |
4145 | || (! pos && TREE_INT_CST_HIGH (t) == -1 | |
4146 | && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0))); | |
4147 | } | |
4148 | ||
4149 | /* Return the HOST_WIDE_INT least significant bits of T if it is an | |
4150 | INTEGER_CST and there is no overflow. POS is nonzero if the result must | |
4151 | be positive. Abort if we cannot satisfy the above conditions. */ | |
4152 | ||
4153 | HOST_WIDE_INT | |
4154 | tree_low_cst (t, pos) | |
4155 | tree t; | |
4156 | int pos; | |
4157 | { | |
4158 | if (host_integerp (t, pos)) | |
4159 | return TREE_INT_CST_LOW (t); | |
4160 | else | |
4161 | abort (); | |
4162 | } | |
4163 | ||
a49a6a68 JW |
4164 | /* Return the most significant bit of the integer constant T. */ |
4165 | ||
4166 | int | |
4167 | tree_int_cst_msb (t) | |
4168 | tree t; | |
4169 | { | |
4170 | register int prec; | |
4171 | HOST_WIDE_INT h; | |
4172 | HOST_WIDE_INT l; | |
4173 | ||
4174 | /* Note that using TYPE_PRECISION here is wrong. We care about the | |
4175 | actual bits, not the (arbitrary) range of the type. */ | |
4176 | prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1; | |
4177 | rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec, | |
4178 | 2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0); | |
4179 | return (l & 1) == 1; | |
4180 | } | |
4181 | ||
6d9cb074 RK |
4182 | /* Return an indication of the sign of the integer constant T. |
4183 | The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0. | |
4184 | Note that -1 will never be returned it T's type is unsigned. */ | |
4185 | ||
4186 | int | |
4187 | tree_int_cst_sgn (t) | |
4188 | tree t; | |
4189 | { | |
4190 | if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0) | |
4191 | return 0; | |
4192 | else if (TREE_UNSIGNED (TREE_TYPE (t))) | |
4193 | return 1; | |
4194 | else if (TREE_INT_CST_HIGH (t) < 0) | |
4195 | return -1; | |
4196 | else | |
4197 | return 1; | |
4198 | } | |
4199 | ||
364e1f1c RK |
4200 | /* Compare two constructor-element-type constants. Return 1 if the lists |
4201 | are known to be equal; otherwise return 0. */ | |
4202 | ||
c6a1db6c RS |
4203 | int |
4204 | simple_cst_list_equal (l1, l2) | |
4205 | tree l1, l2; | |
4206 | { | |
4207 | while (l1 != NULL_TREE && l2 != NULL_TREE) | |
4208 | { | |
364e1f1c | 4209 | if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1) |
c6a1db6c | 4210 | return 0; |
364e1f1c | 4211 | |
c6a1db6c RS |
4212 | l1 = TREE_CHAIN (l1); |
4213 | l2 = TREE_CHAIN (l2); | |
4214 | } | |
364e1f1c | 4215 | |
d4b60170 | 4216 | return l1 == l2; |
c6a1db6c RS |
4217 | } |
4218 | ||
4219 | /* Return truthvalue of whether T1 is the same tree structure as T2. | |
4220 | Return 1 if they are the same. | |
4221 | Return 0 if they are understandably different. | |
4222 | Return -1 if either contains tree structure not understood by | |
4223 | this function. */ | |
4224 | ||
4225 | int | |
4226 | simple_cst_equal (t1, t2) | |
4227 | tree t1, t2; | |
4228 | { | |
4229 | register enum tree_code code1, code2; | |
4230 | int cmp; | |
d4b60170 | 4231 | int i; |
c6a1db6c RS |
4232 | |
4233 | if (t1 == t2) | |
4234 | return 1; | |
4235 | if (t1 == 0 || t2 == 0) | |
4236 | return 0; | |
4237 | ||
4238 | code1 = TREE_CODE (t1); | |
4239 | code2 = TREE_CODE (t2); | |
4240 | ||
4241 | if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR) | |
af79bb86 JM |
4242 | { |
4243 | if (code2 == NOP_EXPR || code2 == CONVERT_EXPR | |
4244 | || code2 == NON_LVALUE_EXPR) | |
4245 | return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); | |
4246 | else | |
4247 | return simple_cst_equal (TREE_OPERAND (t1, 0), t2); | |
4248 | } | |
d4b60170 | 4249 | |
c6a1db6c RS |
4250 | else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR |
4251 | || code2 == NON_LVALUE_EXPR) | |
4252 | return simple_cst_equal (t1, TREE_OPERAND (t2, 0)); | |
4253 | ||
4254 | if (code1 != code2) | |
4255 | return 0; | |
4256 | ||
4257 | switch (code1) | |
4258 | { | |
4259 | case INTEGER_CST: | |
d4b60170 RK |
4260 | return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) |
4261 | && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2)); | |
c6a1db6c RS |
4262 | |
4263 | case REAL_CST: | |
41c9120b | 4264 | return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); |
c6a1db6c RS |
4265 | |
4266 | case STRING_CST: | |
d4b60170 RK |
4267 | return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2) |
4268 | && ! bcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2), | |
4269 | TREE_STRING_LENGTH (t1))); | |
c6a1db6c RS |
4270 | |
4271 | case CONSTRUCTOR: | |
b3abfd6f JM |
4272 | if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2)) |
4273 | return 1; | |
4274 | else | |
4275 | abort (); | |
c6a1db6c RS |
4276 | |
4277 | case SAVE_EXPR: | |
4278 | return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); | |
4279 | ||
4280 | case CALL_EXPR: | |
4281 | cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); | |
4282 | if (cmp <= 0) | |
4283 | return cmp; | |
d4b60170 RK |
4284 | return |
4285 | simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); | |
c6a1db6c RS |
4286 | |
4287 | case TARGET_EXPR: | |
4288 | /* Special case: if either target is an unallocated VAR_DECL, | |
4289 | it means that it's going to be unified with whatever the | |
4290 | TARGET_EXPR is really supposed to initialize, so treat it | |
4291 | as being equivalent to anything. */ | |
4292 | if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL | |
4293 | && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE | |
4294 | && DECL_RTL (TREE_OPERAND (t1, 0)) == 0) | |
4295 | || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL | |
4296 | && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE | |
4297 | && DECL_RTL (TREE_OPERAND (t2, 0)) == 0)) | |
4298 | cmp = 1; | |
4299 | else | |
4300 | cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); | |
d4b60170 | 4301 | |
c6a1db6c RS |
4302 | if (cmp <= 0) |
4303 | return cmp; | |
d4b60170 | 4304 | |
c6a1db6c RS |
4305 | return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); |
4306 | ||
4307 | case WITH_CLEANUP_EXPR: | |
4308 | cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); | |
4309 | if (cmp <= 0) | |
4310 | return cmp; | |
d4b60170 | 4311 | |
c6a1db6c RS |
4312 | return simple_cst_equal (TREE_OPERAND (t1, 2), TREE_OPERAND (t1, 2)); |
4313 | ||
4314 | case COMPONENT_REF: | |
4315 | if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1)) | |
4316 | return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); | |
d4b60170 | 4317 | |
c6a1db6c RS |
4318 | return 0; |
4319 | ||
c6a1db6c RS |
4320 | case VAR_DECL: |
4321 | case PARM_DECL: | |
4322 | case CONST_DECL: | |
4323 | case FUNCTION_DECL: | |
4324 | return 0; | |
e9a25f70 JL |
4325 | |
4326 | default: | |
4327 | break; | |
86aed40b | 4328 | } |
c6a1db6c | 4329 | |
8ae49a28 RK |
4330 | /* This general rule works for most tree codes. All exceptions should be |
4331 | handled above. If this is a language-specific tree code, we can't | |
4332 | trust what might be in the operand, so say we don't know | |
4333 | the situation. */ | |
0a6969ad | 4334 | if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE) |
8ae49a28 | 4335 | return -1; |
c6a1db6c | 4336 | |
86aed40b RS |
4337 | switch (TREE_CODE_CLASS (code1)) |
4338 | { | |
86aed40b RS |
4339 | case '1': |
4340 | case '2': | |
4341 | case '<': | |
4342 | case 'e': | |
4343 | case 'r': | |
4344 | case 's': | |
4345 | cmp = 1; | |
d4b60170 | 4346 | for (i = 0; i < tree_code_length[(int) code1]; i++) |
86aed40b RS |
4347 | { |
4348 | cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)); | |
4349 | if (cmp <= 0) | |
4350 | return cmp; | |
4351 | } | |
d4b60170 | 4352 | |
86aed40b | 4353 | return cmp; |
86aed40b | 4354 | |
e9a25f70 JL |
4355 | default: |
4356 | return -1; | |
4357 | } | |
c6a1db6c | 4358 | } |
05bccae2 RK |
4359 | |
4360 | /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value. | |
4361 | Return -1, 0, or 1 if the value of T is less than, equal to, or greater | |
4362 | than U, respectively. */ | |
4363 | ||
4364 | int | |
4365 | compare_tree_int (t, u) | |
4366 | tree t; | |
4367 | unsigned int u; | |
4368 | { | |
4369 | if (tree_int_cst_sgn (t) < 0) | |
4370 | return -1; | |
4371 | else if (TREE_INT_CST_HIGH (t) != 0) | |
4372 | return 1; | |
4373 | else if (TREE_INT_CST_LOW (t) == u) | |
4374 | return 0; | |
4375 | else if (TREE_INT_CST_LOW (t) < u) | |
4376 | return -1; | |
4377 | else | |
4378 | return 1; | |
4379 | } | |
c6a1db6c RS |
4380 | \f |
4381 | /* Constructors for pointer, array and function types. | |
4382 | (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are | |
4383 | constructed by language-dependent code, not here.) */ | |
4384 | ||
4385 | /* Construct, lay out and return the type of pointers to TO_TYPE. | |
4386 | If such a type has already been constructed, reuse it. */ | |
4387 | ||
4388 | tree | |
4389 | build_pointer_type (to_type) | |
4390 | tree to_type; | |
4391 | { | |
4392 | register tree t = TYPE_POINTER_TO (to_type); | |
c6a1db6c RS |
4393 | |
4394 | /* First, if we already have a type for pointers to TO_TYPE, use it. */ | |
4395 | ||
d4b60170 | 4396 | if (t != 0) |
c6a1db6c RS |
4397 | return t; |
4398 | ||
d9cbc259 RK |
4399 | /* We need a new one. Put this in the same obstack as TO_TYPE. */ |
4400 | push_obstacks (TYPE_OBSTACK (to_type), TYPE_OBSTACK (to_type)); | |
c6a1db6c | 4401 | t = make_node (POINTER_TYPE); |
d9cbc259 RK |
4402 | pop_obstacks (); |
4403 | ||
c6a1db6c RS |
4404 | TREE_TYPE (t) = to_type; |
4405 | ||
4406 | /* Record this type as the pointer to TO_TYPE. */ | |
4407 | TYPE_POINTER_TO (to_type) = t; | |
4408 | ||
4409 | /* Lay out the type. This function has many callers that are concerned | |
4410 | with expression-construction, and this simplifies them all. | |
d9cbc259 | 4411 | Also, it guarantees the TYPE_SIZE is in the same obstack as the type. */ |
c6a1db6c RS |
4412 | layout_type (t); |
4413 | ||
c6a1db6c RS |
4414 | return t; |
4415 | } | |
4416 | ||
d4b60170 RK |
4417 | /* Build the node for the type of references-to-TO_TYPE. */ |
4418 | ||
4419 | tree | |
4420 | build_reference_type (to_type) | |
4421 | tree to_type; | |
4422 | { | |
4423 | register tree t = TYPE_REFERENCE_TO (to_type); | |
4424 | ||
4425 | /* First, if we already have a type for pointers to TO_TYPE, use it. */ | |
4426 | ||
4427 | if (t) | |
4428 | return t; | |
4429 | ||
4430 | /* We need a new one. Put this in the same obstack as TO_TYPE. */ | |
4431 | push_obstacks (TYPE_OBSTACK (to_type), TYPE_OBSTACK (to_type)); | |
4432 | t = make_node (REFERENCE_TYPE); | |
4433 | pop_obstacks (); | |
4434 | ||
4435 | TREE_TYPE (t) = to_type; | |
4436 | ||
4437 | /* Record this type as the pointer to TO_TYPE. */ | |
4438 | TYPE_REFERENCE_TO (to_type) = t; | |
4439 | ||
4440 | layout_type (t); | |
4441 | ||
4442 | return t; | |
4443 | } | |
4444 | ||
c6a1db6c RS |
4445 | /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE. |
4446 | MAXVAL should be the maximum value in the domain | |
e9a25f70 JL |
4447 | (one less than the length of the array). |
4448 | ||
4449 | The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT. | |
4450 | We don't enforce this limit, that is up to caller (e.g. language front end). | |
4451 | The limit exists because the result is a signed type and we don't handle | |
4452 | sizes that use more than one HOST_WIDE_INT. */ | |
c6a1db6c RS |
4453 | |
4454 | tree | |
4455 | build_index_type (maxval) | |
4456 | tree maxval; | |
4457 | { | |
4458 | register tree itype = make_node (INTEGER_TYPE); | |
0fd17968 | 4459 | |
c6a1db6c | 4460 | TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype); |
0fd17968 RK |
4461 | TYPE_MIN_VALUE (itype) = size_zero_node; |
4462 | ||
4463 | push_obstacks (TYPE_OBSTACK (itype), TYPE_OBSTACK (itype)); | |
c6a1db6c | 4464 | TYPE_MAX_VALUE (itype) = convert (sizetype, maxval); |
0fd17968 RK |
4465 | pop_obstacks (); |
4466 | ||
c6a1db6c RS |
4467 | TYPE_MODE (itype) = TYPE_MODE (sizetype); |
4468 | TYPE_SIZE (itype) = TYPE_SIZE (sizetype); | |
def9b006 | 4469 | TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype); |
c6a1db6c RS |
4470 | TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype); |
4471 | if (TREE_CODE (maxval) == INTEGER_CST) | |
4472 | { | |
05bccae2 RK |
4473 | int maxint = TREE_INT_CST_LOW (maxval); |
4474 | ||
cdc5a032 RS |
4475 | /* If the domain should be empty, make sure the maxval |
4476 | remains -1 and is not spoiled by truncation. */ | |
05bccae2 | 4477 | if (tree_int_cst_sgn (maxval) < 0) |
cdc5a032 RS |
4478 | { |
4479 | TYPE_MAX_VALUE (itype) = build_int_2 (-1, -1); | |
4480 | TREE_TYPE (TYPE_MAX_VALUE (itype)) = sizetype; | |
4481 | } | |
05bccae2 | 4482 | |
bc99efc9 | 4483 | return type_hash_canon (maxint < 0 ? ~maxint : maxint, itype); |
c6a1db6c RS |
4484 | } |
4485 | else | |
4486 | return itype; | |
4487 | } | |
4488 | ||
742e43a2 | 4489 | /* Create a range of some discrete type TYPE (an INTEGER_TYPE, |
238a1856 | 4490 | ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with |
742e43a2 | 4491 | low bound LOWVAL and high bound HIGHVAL. |
0f41302f | 4492 | if TYPE==NULL_TREE, sizetype is used. */ |
c6a1db6c RS |
4493 | |
4494 | tree | |
742e43a2 PB |
4495 | build_range_type (type, lowval, highval) |
4496 | tree type, lowval, highval; | |
c6a1db6c RS |
4497 | { |
4498 | register tree itype = make_node (INTEGER_TYPE); | |
0fd17968 | 4499 | |
742e43a2 PB |
4500 | TREE_TYPE (itype) = type; |
4501 | if (type == NULL_TREE) | |
4502 | type = sizetype; | |
0fd17968 RK |
4503 | |
4504 | push_obstacks (TYPE_OBSTACK (itype), TYPE_OBSTACK (itype)); | |
742e43a2 | 4505 | TYPE_MIN_VALUE (itype) = convert (type, lowval); |
e1ee5cdc | 4506 | TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL; |
0fd17968 RK |
4507 | pop_obstacks (); |
4508 | ||
4509 | TYPE_PRECISION (itype) = TYPE_PRECISION (type); | |
742e43a2 PB |
4510 | TYPE_MODE (itype) = TYPE_MODE (type); |
4511 | TYPE_SIZE (itype) = TYPE_SIZE (type); | |
28372f41 | 4512 | TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type); |
742e43a2 | 4513 | TYPE_ALIGN (itype) = TYPE_ALIGN (type); |
e1ee5cdc | 4514 | if (TREE_CODE (lowval) == INTEGER_CST) |
c6a1db6c | 4515 | { |
e1ee5cdc RH |
4516 | HOST_WIDE_INT lowint, highint; |
4517 | int maxint; | |
4518 | ||
4519 | lowint = TREE_INT_CST_LOW (lowval); | |
4520 | if (highval && TREE_CODE (highval) == INTEGER_CST) | |
4521 | highint = TREE_INT_CST_LOW (highval); | |
4522 | else | |
05bccae2 | 4523 | highint = (~(unsigned HOST_WIDE_INT) 0) >> 1; |
e1ee5cdc RH |
4524 | |
4525 | maxint = (int) (highint - lowint); | |
05bccae2 | 4526 | |
bc99efc9 | 4527 | return type_hash_canon (maxint < 0 ? ~maxint : maxint, itype); |
c6a1db6c RS |
4528 | } |
4529 | else | |
4530 | return itype; | |
4531 | } | |
4532 | ||
742e43a2 | 4533 | /* Just like build_index_type, but takes lowval and highval instead |
0f41302f | 4534 | of just highval (maxval). */ |
742e43a2 PB |
4535 | |
4536 | tree | |
4537 | build_index_2_type (lowval,highval) | |
4538 | tree lowval, highval; | |
4539 | { | |
4540 | return build_range_type (NULL_TREE, lowval, highval); | |
4541 | } | |
4542 | ||
c6a1db6c RS |
4543 | /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense). |
4544 | Needed because when index types are not hashed, equal index types | |
4545 | built at different times appear distinct, even though structurally, | |
4546 | they are not. */ | |
4547 | ||
4548 | int | |
4549 | index_type_equal (itype1, itype2) | |
4550 | tree itype1, itype2; | |
4551 | { | |
4552 | if (TREE_CODE (itype1) != TREE_CODE (itype2)) | |
4553 | return 0; | |
d4b60170 | 4554 | |
c6a1db6c RS |
4555 | if (TREE_CODE (itype1) == INTEGER_TYPE) |
4556 | { | |
4557 | if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2) | |
4558 | || TYPE_MODE (itype1) != TYPE_MODE (itype2) | |
364e1f1c | 4559 | || simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2)) != 1 |
c6a1db6c RS |
4560 | || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2)) |
4561 | return 0; | |
d4b60170 | 4562 | |
364e1f1c RK |
4563 | if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1), |
4564 | TYPE_MIN_VALUE (itype2)) | |
4565 | && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1), | |
4566 | TYPE_MAX_VALUE (itype2))) | |
c6a1db6c RS |
4567 | return 1; |
4568 | } | |
364e1f1c | 4569 | |
c6a1db6c RS |
4570 | return 0; |
4571 | } | |
4572 | ||
4573 | /* Construct, lay out and return the type of arrays of elements with ELT_TYPE | |
4574 | and number of elements specified by the range of values of INDEX_TYPE. | |
4575 | If such a type has already been constructed, reuse it. */ | |
4576 | ||
4577 | tree | |
4578 | build_array_type (elt_type, index_type) | |
4579 | tree elt_type, index_type; | |
4580 | { | |
4581 | register tree t; | |
05bccae2 | 4582 | unsigned int hashcode; |
c6a1db6c RS |
4583 | |
4584 | if (TREE_CODE (elt_type) == FUNCTION_TYPE) | |
4585 | { | |
4586 | error ("arrays of functions are not meaningful"); | |
4587 | elt_type = integer_type_node; | |
4588 | } | |
4589 | ||
4590 | /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */ | |
4591 | build_pointer_type (elt_type); | |
4592 | ||
4593 | /* Allocate the array after the pointer type, | |
4594 | in case we free it in type_hash_canon. */ | |
4595 | t = make_node (ARRAY_TYPE); | |
4596 | TREE_TYPE (t) = elt_type; | |
4597 | TYPE_DOMAIN (t) = index_type; | |
4598 | ||
4599 | if (index_type == 0) | |
15c76378 | 4600 | { |
15c76378 RS |
4601 | return t; |
4602 | } | |
c6a1db6c RS |
4603 | |
4604 | hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type); | |
4605 | t = type_hash_canon (hashcode, t); | |
4606 | ||
4607 | if (TYPE_SIZE (t) == 0) | |
4608 | layout_type (t); | |
4609 | return t; | |
4610 | } | |
4611 | ||
a260abc9 DE |
4612 | /* Return the TYPE of the elements comprising |
4613 | the innermost dimension of ARRAY. */ | |
4614 | ||
4615 | tree | |
4616 | get_inner_array_type (array) | |
4617 | tree array; | |
4618 | { | |
4619 | tree type = TREE_TYPE (array); | |
4620 | ||
4621 | while (TREE_CODE (type) == ARRAY_TYPE) | |
4622 | type = TREE_TYPE (type); | |
4623 | ||
4624 | return type; | |
4625 | } | |
4626 | ||
c6a1db6c RS |
4627 | /* Construct, lay out and return |
4628 | the type of functions returning type VALUE_TYPE | |
4629 | given arguments of types ARG_TYPES. | |
4630 | ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs | |
4631 | are data type nodes for the arguments of the function. | |
4632 | If such a type has already been constructed, reuse it. */ | |
4633 | ||
4634 | tree | |
4635 | build_function_type (value_type, arg_types) | |
4636 | tree value_type, arg_types; | |
4637 | { | |
4638 | register tree t; | |
05bccae2 | 4639 | unsigned int hashcode; |
c6a1db6c | 4640 | |
c0560b8b | 4641 | if (TREE_CODE (value_type) == FUNCTION_TYPE) |
c6a1db6c | 4642 | { |
c0560b8b | 4643 | error ("function return type cannot be function"); |
c6a1db6c RS |
4644 | value_type = integer_type_node; |
4645 | } | |
4646 | ||
4647 | /* Make a node of the sort we want. */ | |
4648 | t = make_node (FUNCTION_TYPE); | |
4649 | TREE_TYPE (t) = value_type; | |
4650 | TYPE_ARG_TYPES (t) = arg_types; | |
4651 | ||
4652 | /* If we already have such a type, use the old one and free this one. */ | |
4653 | hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types); | |
4654 | t = type_hash_canon (hashcode, t); | |
4655 | ||
4656 | if (TYPE_SIZE (t) == 0) | |
4657 | layout_type (t); | |
4658 | return t; | |
4659 | } | |
4660 | ||
c6a1db6c RS |
4661 | /* Construct, lay out and return the type of methods belonging to class |
4662 | BASETYPE and whose arguments and values are described by TYPE. | |
4663 | If that type exists already, reuse it. | |
4664 | TYPE must be a FUNCTION_TYPE node. */ | |
4665 | ||
4666 | tree | |
4667 | build_method_type (basetype, type) | |
4668 | tree basetype, type; | |
4669 | { | |
4670 | register tree t; | |
05bccae2 | 4671 | unsigned int hashcode; |
c6a1db6c RS |
4672 | |
4673 | /* Make a node of the sort we want. */ | |
4674 | t = make_node (METHOD_TYPE); | |
4675 | ||
4676 | if (TREE_CODE (type) != FUNCTION_TYPE) | |
4677 | abort (); | |
4678 | ||
4679 | TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype); | |
4680 | TREE_TYPE (t) = TREE_TYPE (type); | |
4681 | ||
4682 | /* The actual arglist for this function includes a "hidden" argument | |
4683 | which is "this". Put it into the list of argument types. */ | |
4684 | ||
4685 | TYPE_ARG_TYPES (t) | |
37366632 RK |
4686 | = tree_cons (NULL_TREE, |
4687 | build_pointer_type (basetype), TYPE_ARG_TYPES (type)); | |
c6a1db6c RS |
4688 | |
4689 | /* If we already have such a type, use the old one and free this one. */ | |
4690 | hashcode = TYPE_HASH (basetype) + TYPE_HASH (type); | |
4691 | t = type_hash_canon (hashcode, t); | |
4692 | ||
4693 | if (TYPE_SIZE (t) == 0) | |
4694 | layout_type (t); | |
4695 | ||
4696 | return t; | |
4697 | } | |
4698 | ||
86aed40b RS |
4699 | /* Construct, lay out and return the type of offsets to a value |
4700 | of type TYPE, within an object of type BASETYPE. | |
4701 | If a suitable offset type exists already, reuse it. */ | |
c6a1db6c RS |
4702 | |
4703 | tree | |
4704 | build_offset_type (basetype, type) | |
4705 | tree basetype, type; | |
4706 | { | |
4707 | register tree t; | |
05bccae2 | 4708 | unsigned int hashcode; |
c6a1db6c RS |
4709 | |
4710 | /* Make a node of the sort we want. */ | |
4711 | t = make_node (OFFSET_TYPE); | |
4712 | ||
4713 | TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype); | |
4714 | TREE_TYPE (t) = type; | |
4715 | ||
4716 | /* If we already have such a type, use the old one and free this one. */ | |
4717 | hashcode = TYPE_HASH (basetype) + TYPE_HASH (type); | |
4718 | t = type_hash_canon (hashcode, t); | |
4719 | ||
4720 | if (TYPE_SIZE (t) == 0) | |
4721 | layout_type (t); | |
4722 | ||
4723 | return t; | |
4724 | } | |
4725 | ||
4726 | /* Create a complex type whose components are COMPONENT_TYPE. */ | |
4727 | ||
4728 | tree | |
4729 | build_complex_type (component_type) | |
4730 | tree component_type; | |
4731 | { | |
4732 | register tree t; | |
05bccae2 | 4733 | unsigned int hashcode; |
c6a1db6c RS |
4734 | |
4735 | /* Make a node of the sort we want. */ | |
4736 | t = make_node (COMPLEX_TYPE); | |
4737 | ||
4738 | TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type); | |
3932261a | 4739 | set_type_quals (t, TYPE_QUALS (component_type)); |
c6a1db6c RS |
4740 | |
4741 | /* If we already have such a type, use the old one and free this one. */ | |
4742 | hashcode = TYPE_HASH (component_type); | |
4743 | t = type_hash_canon (hashcode, t); | |
4744 | ||
4745 | if (TYPE_SIZE (t) == 0) | |
4746 | layout_type (t); | |
4747 | ||
405f63da MM |
4748 | /* If we are writing Dwarf2 output we need to create a name, |
4749 | since complex is a fundamental type. */ | |
4750 | if (write_symbols == DWARF2_DEBUG && ! TYPE_NAME (t)) | |
4751 | { | |
ec0ce6e2 | 4752 | const char *name; |
405f63da MM |
4753 | if (component_type == char_type_node) |
4754 | name = "complex char"; | |
4755 | else if (component_type == signed_char_type_node) | |
4756 | name = "complex signed char"; | |
4757 | else if (component_type == unsigned_char_type_node) | |
4758 | name = "complex unsigned char"; | |
4759 | else if (component_type == short_integer_type_node) | |
4760 | name = "complex short int"; | |
4761 | else if (component_type == short_unsigned_type_node) | |
4762 | name = "complex short unsigned int"; | |
4763 | else if (component_type == integer_type_node) | |
4764 | name = "complex int"; | |
4765 | else if (component_type == unsigned_type_node) | |
4766 | name = "complex unsigned int"; | |
4767 | else if (component_type == long_integer_type_node) | |
4768 | name = "complex long int"; | |
4769 | else if (component_type == long_unsigned_type_node) | |
4770 | name = "complex long unsigned int"; | |
4771 | else if (component_type == long_long_integer_type_node) | |
4772 | name = "complex long long int"; | |
4773 | else if (component_type == long_long_unsigned_type_node) | |
4774 | name = "complex long long unsigned int"; | |
4775 | else | |
d4b60170 | 4776 | name = 0; |
405f63da | 4777 | |
d4b60170 | 4778 | if (name != 0) |
405f63da MM |
4779 | TYPE_NAME (t) = get_identifier (name); |
4780 | } | |
4781 | ||
c6a1db6c RS |
4782 | return t; |
4783 | } | |
4784 | \f | |
4785 | /* Return OP, stripped of any conversions to wider types as much as is safe. | |
4786 | Converting the value back to OP's type makes a value equivalent to OP. | |
4787 | ||
4788 | If FOR_TYPE is nonzero, we return a value which, if converted to | |
4789 | type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE. | |
4790 | ||
4791 | If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the | |
4792 | narrowest type that can hold the value, even if they don't exactly fit. | |
4793 | Otherwise, bit-field references are changed to a narrower type | |
4794 | only if they can be fetched directly from memory in that type. | |
4795 | ||
4796 | OP must have integer, real or enumeral type. Pointers are not allowed! | |
4797 | ||
4798 | There are some cases where the obvious value we could return | |
4799 | would regenerate to OP if converted to OP's type, | |
4800 | but would not extend like OP to wider types. | |
4801 | If FOR_TYPE indicates such extension is contemplated, we eschew such values. | |
4802 | For example, if OP is (unsigned short)(signed char)-1, | |
4803 | we avoid returning (signed char)-1 if FOR_TYPE is int, | |
4804 | even though extending that to an unsigned short would regenerate OP, | |
4805 | since the result of extending (signed char)-1 to (int) | |
4806 | is different from (int) OP. */ | |
4807 | ||
4808 | tree | |
4809 | get_unwidened (op, for_type) | |
4810 | register tree op; | |
4811 | tree for_type; | |
4812 | { | |
4813 | /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */ | |
c6a1db6c RS |
4814 | register tree type = TREE_TYPE (op); |
4815 | register unsigned final_prec | |
4816 | = TYPE_PRECISION (for_type != 0 ? for_type : type); | |
4817 | register int uns | |
4818 | = (for_type != 0 && for_type != type | |
4819 | && final_prec > TYPE_PRECISION (type) | |
4820 | && TREE_UNSIGNED (type)); | |
4821 | register tree win = op; | |
4822 | ||
4823 | while (TREE_CODE (op) == NOP_EXPR) | |
4824 | { | |
4825 | register int bitschange | |
4826 | = TYPE_PRECISION (TREE_TYPE (op)) | |
4827 | - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))); | |
4828 | ||
4829 | /* Truncations are many-one so cannot be removed. | |
4830 | Unless we are later going to truncate down even farther. */ | |
4831 | if (bitschange < 0 | |
4832 | && final_prec > TYPE_PRECISION (TREE_TYPE (op))) | |
4833 | break; | |
4834 | ||
4835 | /* See what's inside this conversion. If we decide to strip it, | |
4836 | we will set WIN. */ | |
4837 | op = TREE_OPERAND (op, 0); | |
4838 | ||
4839 | /* If we have not stripped any zero-extensions (uns is 0), | |
4840 | we can strip any kind of extension. | |
4841 | If we have previously stripped a zero-extension, | |
4842 | only zero-extensions can safely be stripped. | |
4843 | Any extension can be stripped if the bits it would produce | |
4844 | are all going to be discarded later by truncating to FOR_TYPE. */ | |
4845 | ||
4846 | if (bitschange > 0) | |
4847 | { | |
4848 | if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op))) | |
4849 | win = op; | |
4850 | /* TREE_UNSIGNED says whether this is a zero-extension. | |
4851 | Let's avoid computing it if it does not affect WIN | |
4852 | and if UNS will not be needed again. */ | |
4853 | if ((uns || TREE_CODE (op) == NOP_EXPR) | |
4854 | && TREE_UNSIGNED (TREE_TYPE (op))) | |
4855 | { | |
4856 | uns = 1; | |
4857 | win = op; | |
4858 | } | |
4859 | } | |
4860 | } | |
4861 | ||
4862 | if (TREE_CODE (op) == COMPONENT_REF | |
4863 | /* Since type_for_size always gives an integer type. */ | |
02a27e82 | 4864 | && TREE_CODE (type) != REAL_TYPE |
956d6950 | 4865 | /* Don't crash if field not laid out yet. */ |
02a27e82 | 4866 | && DECL_SIZE (TREE_OPERAND (op, 1)) != 0) |
c6a1db6c | 4867 | { |
05bccae2 RK |
4868 | unsigned int innerprec |
4869 | = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1))); | |
4870 | ||
c6a1db6c RS |
4871 | type = type_for_size (innerprec, TREE_UNSIGNED (TREE_OPERAND (op, 1))); |
4872 | ||
4873 | /* We can get this structure field in the narrowest type it fits in. | |
4874 | If FOR_TYPE is 0, do this only for a field that matches the | |
4875 | narrower type exactly and is aligned for it | |
4876 | The resulting extension to its nominal type (a fullword type) | |
4877 | must fit the same conditions as for other extensions. */ | |
4878 | ||
4879 | if (innerprec < TYPE_PRECISION (TREE_TYPE (op)) | |
4880 | && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))) | |
4881 | && (! uns || final_prec <= innerprec | |
4882 | || TREE_UNSIGNED (TREE_OPERAND (op, 1))) | |
4883 | && type != 0) | |
4884 | { | |
4885 | win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0), | |
4886 | TREE_OPERAND (op, 1)); | |
4887 | TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op); | |
4888 | TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op); | |
c6a1db6c RS |
4889 | } |
4890 | } | |
4891 | return win; | |
4892 | } | |
4893 | \f | |
4894 | /* Return OP or a simpler expression for a narrower value | |
4895 | which can be sign-extended or zero-extended to give back OP. | |
4896 | Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended | |
4897 | or 0 if the value should be sign-extended. */ | |
4898 | ||
4899 | tree | |
4900 | get_narrower (op, unsignedp_ptr) | |
4901 | register tree op; | |
4902 | int *unsignedp_ptr; | |
4903 | { | |
4904 | register int uns = 0; | |
4905 | int first = 1; | |
4906 | register tree win = op; | |
4907 | ||
4908 | while (TREE_CODE (op) == NOP_EXPR) | |
4909 | { | |
4910 | register int bitschange | |
d4b60170 RK |
4911 | = (TYPE_PRECISION (TREE_TYPE (op)) |
4912 | - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)))); | |
c6a1db6c RS |
4913 | |
4914 | /* Truncations are many-one so cannot be removed. */ | |
4915 | if (bitschange < 0) | |
4916 | break; | |
4917 | ||
4918 | /* See what's inside this conversion. If we decide to strip it, | |
4919 | we will set WIN. */ | |
4920 | op = TREE_OPERAND (op, 0); | |
4921 | ||
4922 | if (bitschange > 0) | |
4923 | { | |
4924 | /* An extension: the outermost one can be stripped, | |
4925 | but remember whether it is zero or sign extension. */ | |
4926 | if (first) | |
4927 | uns = TREE_UNSIGNED (TREE_TYPE (op)); | |
4928 | /* Otherwise, if a sign extension has been stripped, | |
4929 | only sign extensions can now be stripped; | |
4930 | if a zero extension has been stripped, only zero-extensions. */ | |
4931 | else if (uns != TREE_UNSIGNED (TREE_TYPE (op))) | |
4932 | break; | |
4933 | first = 0; | |
4934 | } | |
e02b9957 DE |
4935 | else /* bitschange == 0 */ |
4936 | { | |
4937 | /* A change in nominal type can always be stripped, but we must | |
4938 | preserve the unsignedness. */ | |
4939 | if (first) | |
4940 | uns = TREE_UNSIGNED (TREE_TYPE (op)); | |
4941 | first = 0; | |
4942 | } | |
c6a1db6c RS |
4943 | |
4944 | win = op; | |
4945 | } | |
4946 | ||
4947 | if (TREE_CODE (op) == COMPONENT_REF | |
4948 | /* Since type_for_size always gives an integer type. */ | |
4949 | && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE) | |
4950 | { | |
05bccae2 RK |
4951 | unsigned int innerprec |
4952 | = TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1))); | |
4953 | ||
c6a1db6c RS |
4954 | tree type = type_for_size (innerprec, TREE_UNSIGNED (op)); |
4955 | ||
4956 | /* We can get this structure field in a narrower type that fits it, | |
4957 | but the resulting extension to its nominal type (a fullword type) | |
4958 | must satisfy the same conditions as for other extensions. | |
4959 | ||
4960 | Do this only for fields that are aligned (not bit-fields), | |
4961 | because when bit-field insns will be used there is no | |
4962 | advantage in doing this. */ | |
4963 | ||
4964 | if (innerprec < TYPE_PRECISION (TREE_TYPE (op)) | |
4965 | && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)) | |
4966 | && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1))) | |
4967 | && type != 0) | |
4968 | { | |
4969 | if (first) | |
4970 | uns = TREE_UNSIGNED (TREE_OPERAND (op, 1)); | |
4971 | win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0), | |
4972 | TREE_OPERAND (op, 1)); | |
4973 | TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op); | |
4974 | TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op); | |
c6a1db6c RS |
4975 | } |
4976 | } | |
4977 | *unsignedp_ptr = uns; | |
4978 | return win; | |
4979 | } | |
4980 | \f | |
c6a1db6c RS |
4981 | /* Nonzero if integer constant C has a value that is permissible |
4982 | for type TYPE (an INTEGER_TYPE). */ | |
4983 | ||
4984 | int | |
4985 | int_fits_type_p (c, type) | |
4986 | tree c, type; | |
4987 | { | |
4988 | if (TREE_UNSIGNED (type)) | |
857d2849 RK |
4989 | return (! (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST |
4990 | && INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)) | |
4991 | && ! (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST | |
ae0a3dfb RK |
4992 | && INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type))) |
4993 | /* Negative ints never fit unsigned types. */ | |
4994 | && ! (TREE_INT_CST_HIGH (c) < 0 | |
4995 | && ! TREE_UNSIGNED (TREE_TYPE (c)))); | |
c6a1db6c | 4996 | else |
857d2849 RK |
4997 | return (! (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST |
4998 | && INT_CST_LT (TYPE_MAX_VALUE (type), c)) | |
4999 | && ! (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST | |
ae0a3dfb RK |
5000 | && INT_CST_LT (c, TYPE_MIN_VALUE (type))) |
5001 | /* Unsigned ints with top bit set never fit signed types. */ | |
5002 | && ! (TREE_INT_CST_HIGH (c) < 0 | |
5003 | && TREE_UNSIGNED (TREE_TYPE (c)))); | |
c6a1db6c RS |
5004 | } |
5005 | ||
140b60b4 MM |
5006 | /* Given a DECL or TYPE, return the scope in which it was declared, or |
5007 | NUL_TREE if there is no containing scope. */ | |
5008 | ||
5009 | tree | |
5010 | get_containing_scope (t) | |
5011 | tree t; | |
5012 | { | |
5013 | return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t)); | |
5014 | } | |
5015 | ||
bfa30b22 | 5016 | /* Return the innermost context enclosing DECL that is |
c6a1db6c RS |
5017 | a FUNCTION_DECL, or zero if none. */ |
5018 | ||
5019 | tree | |
bfa30b22 RK |
5020 | decl_function_context (decl) |
5021 | tree decl; | |
c6a1db6c RS |
5022 | { |
5023 | tree context; | |
5024 | ||
bfa30b22 | 5025 | if (TREE_CODE (decl) == ERROR_MARK) |
c6a1db6c RS |
5026 | return 0; |
5027 | ||
bfa30b22 RK |
5028 | if (TREE_CODE (decl) == SAVE_EXPR) |
5029 | context = SAVE_EXPR_CONTEXT (decl); | |
6ff7fb95 JM |
5030 | /* C++ virtual functions use DECL_CONTEXT for the class of the vtable |
5031 | where we look up the function at runtime. Such functions always take | |
5032 | a first argument of type 'pointer to real context'. | |
5033 | ||
5034 | C++ should really be fixed to use DECL_CONTEXT for the real context, | |
5035 | and use something else for the "virtual context". */ | |
5036 | else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl)) | |
5037 | context = TYPE_MAIN_VARIANT | |
5038 | (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); | |
c6a1db6c | 5039 | else |
bfa30b22 | 5040 | context = DECL_CONTEXT (decl); |
c6a1db6c RS |
5041 | |
5042 | while (context && TREE_CODE (context) != FUNCTION_DECL) | |
5043 | { | |
140b60b4 | 5044 | if (TREE_CODE (context) == BLOCK) |
c6a1db6c | 5045 | context = BLOCK_SUPERCONTEXT (context); |
140b60b4 MM |
5046 | else |
5047 | context = get_containing_scope (context); | |
c6a1db6c RS |
5048 | } |
5049 | ||
5050 | return context; | |
5051 | } | |
5052 | ||
bfa30b22 | 5053 | /* Return the innermost context enclosing DECL that is |
c0560b8b | 5054 | a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none. |
c6a1db6c RS |
5055 | TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */ |
5056 | ||
5057 | tree | |
bfa30b22 RK |
5058 | decl_type_context (decl) |
5059 | tree decl; | |
c6a1db6c | 5060 | { |
bfa30b22 | 5061 | tree context = DECL_CONTEXT (decl); |
c6a1db6c RS |
5062 | |
5063 | while (context) | |
5064 | { | |
5065 | if (TREE_CODE (context) == RECORD_TYPE | |
c0560b8b RK |
5066 | || TREE_CODE (context) == UNION_TYPE |
5067 | || TREE_CODE (context) == QUAL_UNION_TYPE) | |
c6a1db6c | 5068 | return context; |
d4b60170 | 5069 | |
c6a1db6c RS |
5070 | if (TREE_CODE (context) == TYPE_DECL |
5071 | || TREE_CODE (context) == FUNCTION_DECL) | |
5072 | context = DECL_CONTEXT (context); | |
d4b60170 | 5073 | |
c6a1db6c RS |
5074 | else if (TREE_CODE (context) == BLOCK) |
5075 | context = BLOCK_SUPERCONTEXT (context); | |
d4b60170 | 5076 | |
c6a1db6c RS |
5077 | else |
5078 | /* Unhandled CONTEXT!? */ | |
5079 | abort (); | |
5080 | } | |
5081 | return NULL_TREE; | |
5082 | } | |
5083 | ||
582db8e4 MM |
5084 | /* CALL is a CALL_EXPR. Return the declaration for the function |
5085 | called, or NULL_TREE if the called function cannot be | |
5086 | determined. */ | |
5087 | ||
5088 | tree | |
5089 | get_callee_fndecl (call) | |
5090 | tree call; | |
5091 | { | |
5092 | tree addr; | |
5093 | ||
5094 | /* It's invalid to call this function with anything but a | |
5095 | CALL_EXPR. */ | |
5096 | if (TREE_CODE (call) != CALL_EXPR) | |
5097 | abort (); | |
5098 | ||
5099 | /* The first operand to the CALL is the address of the function | |
5100 | called. */ | |
5101 | addr = TREE_OPERAND (call, 0); | |
5102 | ||
5103 | /* If the address is just `&f' for some function `f', then we know | |
5104 | that `f' is being called. */ | |
5105 | if (TREE_CODE (addr) == ADDR_EXPR | |
5106 | && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL) | |
5107 | return TREE_OPERAND (addr, 0); | |
5108 | ||
5109 | /* We couldn't figure out what was being called. */ | |
5110 | return NULL_TREE; | |
5111 | } | |
5112 | ||
d1485032 JM |
5113 | /* Print debugging information about the obstack O, named STR. */ |
5114 | ||
c6a1db6c RS |
5115 | void |
5116 | print_obstack_statistics (str, o) | |
37b37199 | 5117 | const char *str; |
c6a1db6c RS |
5118 | struct obstack *o; |
5119 | { | |
5120 | struct _obstack_chunk *chunk = o->chunk; | |
d1485032 | 5121 | int n_chunks = 1; |
e9a25f70 | 5122 | int n_alloc = 0; |
c6a1db6c | 5123 | |
d1485032 JM |
5124 | n_alloc += o->next_free - chunk->contents; |
5125 | chunk = chunk->prev; | |
c6a1db6c RS |
5126 | while (chunk) |
5127 | { | |
5128 | n_chunks += 1; | |
5129 | n_alloc += chunk->limit - &chunk->contents[0]; | |
5130 | chunk = chunk->prev; | |
5131 | } | |
5e9defae | 5132 | fprintf (stderr, "obstack %s: %u bytes, %d chunks\n", |
c6a1db6c RS |
5133 | str, n_alloc, n_chunks); |
5134 | } | |
d1485032 JM |
5135 | |
5136 | /* Print debugging information about tree nodes generated during the compile, | |
5137 | and any language-specific information. */ | |
5138 | ||
c6a1db6c RS |
5139 | void |
5140 | dump_tree_statistics () | |
5141 | { | |
5e9defae | 5142 | #ifdef GATHER_STATISTICS |
c6a1db6c RS |
5143 | int i; |
5144 | int total_nodes, total_bytes; | |
5e9defae | 5145 | #endif |
c6a1db6c RS |
5146 | |
5147 | fprintf (stderr, "\n??? tree nodes created\n\n"); | |
5148 | #ifdef GATHER_STATISTICS | |
5149 | fprintf (stderr, "Kind Nodes Bytes\n"); | |
5150 | fprintf (stderr, "-------------------------------------\n"); | |
5151 | total_nodes = total_bytes = 0; | |
5152 | for (i = 0; i < (int) all_kinds; i++) | |
5153 | { | |
5154 | fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i], | |
5155 | tree_node_counts[i], tree_node_sizes[i]); | |
5156 | total_nodes += tree_node_counts[i]; | |
5157 | total_bytes += tree_node_sizes[i]; | |
5158 | } | |
5159 | fprintf (stderr, "%-20s %9d\n", "identifier names", id_string_size); | |
5160 | fprintf (stderr, "-------------------------------------\n"); | |
5161 | fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes); | |
5162 | fprintf (stderr, "-------------------------------------\n"); | |
5163 | #else | |
5164 | fprintf (stderr, "(No per-node statistics)\n"); | |
5165 | #endif | |
d1485032 JM |
5166 | print_obstack_statistics ("permanent_obstack", &permanent_obstack); |
5167 | print_obstack_statistics ("maybepermanent_obstack", &maybepermanent_obstack); | |
5168 | print_obstack_statistics ("temporary_obstack", &temporary_obstack); | |
5169 | print_obstack_statistics ("momentary_obstack", &momentary_obstack); | |
5170 | print_obstack_statistics ("temp_decl_obstack", &temp_decl_obstack); | |
c6a1db6c RS |
5171 | print_lang_statistics (); |
5172 | } | |
bb288278 PB |
5173 | \f |
5174 | #define FILE_FUNCTION_PREFIX_LEN 9 | |
5175 | ||
5176 | #ifndef NO_DOLLAR_IN_LABEL | |
2ce3c6c6 | 5177 | #define FILE_FUNCTION_FORMAT "_GLOBAL_$%s$%s" |
bb288278 PB |
5178 | #else /* NO_DOLLAR_IN_LABEL */ |
5179 | #ifndef NO_DOT_IN_LABEL | |
2ce3c6c6 | 5180 | #define FILE_FUNCTION_FORMAT "_GLOBAL_.%s.%s" |
bb288278 | 5181 | #else /* NO_DOT_IN_LABEL */ |
2ce3c6c6 | 5182 | #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s" |
bb288278 PB |
5183 | #endif /* NO_DOT_IN_LABEL */ |
5184 | #endif /* NO_DOLLAR_IN_LABEL */ | |
5185 | ||
d4b60170 RK |
5186 | extern char *first_global_object_name; |
5187 | extern char *weak_global_object_name; | |
bb288278 | 5188 | |
e2c31432 JM |
5189 | /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name |
5190 | clashes in cases where we can't reliably choose a unique name. | |
5191 | ||
5192 | Derived from mkstemp.c in libiberty. */ | |
5193 | ||
5194 | static void | |
5195 | append_random_chars (template) | |
5196 | char *template; | |
5197 | { | |
5198 | static const char letters[] | |
5199 | = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; | |
5200 | static unsigned HOST_WIDE_INT value; | |
5201 | unsigned HOST_WIDE_INT v; | |
5202 | ||
5203 | #ifdef HAVE_GETTIMEOFDAY | |
5204 | struct timeval tv; | |
5205 | #endif | |
5206 | ||
5207 | template += strlen (template); | |
5208 | ||
5209 | #ifdef HAVE_GETTIMEOFDAY | |
5210 | /* Get some more or less random data. */ | |
5211 | gettimeofday (&tv, NULL); | |
5212 | value += ((unsigned HOST_WIDE_INT) tv.tv_usec << 16) ^ tv.tv_sec ^ getpid (); | |
5213 | #else | |
5214 | value += getpid (); | |
5215 | #endif | |
5216 | ||
5217 | v = value; | |
5218 | ||
5219 | /* Fill in the random bits. */ | |
5220 | template[0] = letters[v % 62]; | |
5221 | v /= 62; | |
5222 | template[1] = letters[v % 62]; | |
5223 | v /= 62; | |
5224 | template[2] = letters[v % 62]; | |
5225 | v /= 62; | |
5226 | template[3] = letters[v % 62]; | |
5227 | v /= 62; | |
5228 | template[4] = letters[v % 62]; | |
5229 | v /= 62; | |
5230 | template[5] = letters[v % 62]; | |
5231 | ||
5232 | template[6] = '\0'; | |
5233 | } | |
5234 | ||
5235 | /* Generate a name for a function unique to this translation unit. | |
5236 | TYPE is some string to identify the purpose of this function to the | |
5237 | linker or collect2. */ | |
bb288278 PB |
5238 | |
5239 | tree | |
2ce3c6c6 | 5240 | get_file_function_name_long (type) |
37b37199 | 5241 | const char *type; |
bb288278 PB |
5242 | { |
5243 | char *buf; | |
5244 | register char *p; | |
5245 | ||
5246 | if (first_global_object_name) | |
5247 | p = first_global_object_name; | |
bb288278 | 5248 | else |
e2c31432 JM |
5249 | { |
5250 | /* We don't have anything that we know to be unique to this translation | |
5251 | unit, so use what we do have and throw in some randomness. */ | |
5252 | ||
37b37199 KG |
5253 | const char *name = weak_global_object_name; |
5254 | const char *file = main_input_filename; | |
e2c31432 JM |
5255 | |
5256 | if (! name) | |
5257 | name = ""; | |
5258 | if (! file) | |
5259 | file = input_filename; | |
5260 | ||
5261 | p = (char *) alloca (7 + strlen (name) + strlen (file)); | |
5262 | ||
5263 | sprintf (p, "%s%s", name, file); | |
5264 | append_random_chars (p); | |
5265 | } | |
bb288278 | 5266 | |
2ce3c6c6 JM |
5267 | buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p) |
5268 | + strlen (type)); | |
bb288278 | 5269 | |
d4b60170 RK |
5270 | /* Set up the name of the file-level functions we may need. |
5271 | Use a global object (which is already required to be unique over | |
bb288278 | 5272 | the program) rather than the file name (which imposes extra |
d4b60170 | 5273 | constraints). */ |
2ce3c6c6 | 5274 | sprintf (buf, FILE_FUNCTION_FORMAT, type, p); |
bb288278 | 5275 | |
9faa82d8 | 5276 | /* Don't need to pull weird characters out of global names. */ |
bb288278 PB |
5277 | if (p != first_global_object_name) |
5278 | { | |
5279 | for (p = buf+11; *p; p++) | |
f3ad1f9c | 5280 | if (! ( ISDIGIT(*p) |
bb288278 PB |
5281 | #if 0 /* we always want labels, which are valid C++ identifiers (+ `$') */ |
5282 | #ifndef ASM_IDENTIFY_GCC /* this is required if `.' is invalid -- k. raeburn */ | |
5283 | || *p == '.' | |
5284 | #endif | |
5285 | #endif | |
5286 | #ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */ | |
5287 | || *p == '$' | |
5288 | #endif | |
0f41302f | 5289 | #ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */ |
bb288278 PB |
5290 | || *p == '.' |
5291 | #endif | |
f3ad1f9c LV |
5292 | || ISUPPER(*p) |
5293 | || ISLOWER(*p))) | |
bb288278 PB |
5294 | *p = '_'; |
5295 | } | |
5296 | ||
bb288278 PB |
5297 | return get_identifier (buf); |
5298 | } | |
2ce3c6c6 JM |
5299 | |
5300 | /* If KIND=='I', return a suitable global initializer (constructor) name. | |
5301 | If KIND=='D', return a suitable global clean-up (destructor) name. */ | |
5302 | ||
5303 | tree | |
5304 | get_file_function_name (kind) | |
5305 | int kind; | |
5306 | { | |
5307 | char p[2]; | |
d4b60170 | 5308 | |
2ce3c6c6 JM |
5309 | p[0] = kind; |
5310 | p[1] = 0; | |
5311 | ||
5312 | return get_file_function_name_long (p); | |
5313 | } | |
bca949e2 | 5314 | \f |
9faa82d8 | 5315 | /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node. |
bca949e2 PB |
5316 | The result is placed in BUFFER (which has length BIT_SIZE), |
5317 | with one bit in each char ('\000' or '\001'). | |
5318 | ||
5319 | If the constructor is constant, NULL_TREE is returned. | |
0f41302f | 5320 | Otherwise, a TREE_LIST of the non-constant elements is emitted. */ |
bca949e2 PB |
5321 | |
5322 | tree | |
5323 | get_set_constructor_bits (init, buffer, bit_size) | |
5324 | tree init; | |
5325 | char *buffer; | |
5326 | int bit_size; | |
5327 | { | |
5328 | int i; | |
5329 | tree vals; | |
5330 | HOST_WIDE_INT domain_min | |
5331 | = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init)))); | |
5332 | tree non_const_bits = NULL_TREE; | |
5333 | for (i = 0; i < bit_size; i++) | |
5334 | buffer[i] = 0; | |
5335 | ||
5336 | for (vals = TREE_OPERAND (init, 1); | |
5337 | vals != NULL_TREE; vals = TREE_CHAIN (vals)) | |
5338 | { | |
5339 | if (TREE_CODE (TREE_VALUE (vals)) != INTEGER_CST | |
5340 | || (TREE_PURPOSE (vals) != NULL_TREE | |
5341 | && TREE_CODE (TREE_PURPOSE (vals)) != INTEGER_CST)) | |
db3cf6fb MS |
5342 | non_const_bits |
5343 | = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits); | |
bca949e2 PB |
5344 | else if (TREE_PURPOSE (vals) != NULL_TREE) |
5345 | { | |
0f41302f | 5346 | /* Set a range of bits to ones. */ |
bca949e2 PB |
5347 | HOST_WIDE_INT lo_index |
5348 | = TREE_INT_CST_LOW (TREE_PURPOSE (vals)) - domain_min; | |
5349 | HOST_WIDE_INT hi_index | |
5350 | = TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min; | |
05bccae2 | 5351 | |
bca949e2 PB |
5352 | if (lo_index < 0 || lo_index >= bit_size |
5353 | || hi_index < 0 || hi_index >= bit_size) | |
5354 | abort (); | |
5355 | for ( ; lo_index <= hi_index; lo_index++) | |
5356 | buffer[lo_index] = 1; | |
5357 | } | |
5358 | else | |
5359 | { | |
0f41302f | 5360 | /* Set a single bit to one. */ |
bca949e2 PB |
5361 | HOST_WIDE_INT index |
5362 | = TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min; | |
5363 | if (index < 0 || index >= bit_size) | |
5364 | { | |
5365 | error ("invalid initializer for bit string"); | |
5366 | return NULL_TREE; | |
5367 | } | |
5368 | buffer[index] = 1; | |
5369 | } | |
5370 | } | |
5371 | return non_const_bits; | |
5372 | } | |
5373 | ||
9faa82d8 | 5374 | /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node. |
f3ffec8e | 5375 | The result is placed in BUFFER (which is an array of bytes). |
bca949e2 | 5376 | If the constructor is constant, NULL_TREE is returned. |
0f41302f | 5377 | Otherwise, a TREE_LIST of the non-constant elements is emitted. */ |
bca949e2 PB |
5378 | |
5379 | tree | |
f3ffec8e | 5380 | get_set_constructor_bytes (init, buffer, wd_size) |
bca949e2 | 5381 | tree init; |
f3ffec8e | 5382 | unsigned char *buffer; |
bca949e2 PB |
5383 | int wd_size; |
5384 | { | |
5385 | int i; | |
f3ffec8e | 5386 | int set_word_size = BITS_PER_UNIT; |
bca949e2 PB |
5387 | int bit_size = wd_size * set_word_size; |
5388 | int bit_pos = 0; | |
f3ffec8e | 5389 | unsigned char *bytep = buffer; |
0f41302f | 5390 | char *bit_buffer = (char *) alloca(bit_size); |
bca949e2 PB |
5391 | tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size); |
5392 | ||
5393 | for (i = 0; i < wd_size; i++) | |
5394 | buffer[i] = 0; | |
5395 | ||
5396 | for (i = 0; i < bit_size; i++) | |
5397 | { | |
5398 | if (bit_buffer[i]) | |
5399 | { | |
8a0e8d4d | 5400 | if (BYTES_BIG_ENDIAN) |
f3ffec8e | 5401 | *bytep |= (1 << (set_word_size - 1 - bit_pos)); |
f76b9db2 | 5402 | else |
f3ffec8e | 5403 | *bytep |= 1 << bit_pos; |
bca949e2 PB |
5404 | } |
5405 | bit_pos++; | |
5406 | if (bit_pos >= set_word_size) | |
f3ffec8e | 5407 | bit_pos = 0, bytep++; |
bca949e2 PB |
5408 | } |
5409 | return non_const_bits; | |
5410 | } | |
9ec36da5 | 5411 | \f |
f4524c9e | 5412 | #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) |
8f985ec4 | 5413 | /* Complain that the tree code of NODE does not match the expected CODE. |
987009bf | 5414 | FILE, LINE, and FUNCTION are of the caller. */ |
8f985ec4 ZW |
5415 | void |
5416 | tree_check_failed (node, code, file, line, function) | |
5417 | const tree node; | |
12b195d9 | 5418 | enum tree_code code; |
37b37199 | 5419 | const char *file; |
12b195d9 | 5420 | int line; |
8f985ec4 | 5421 | const char *function; |
12b195d9 | 5422 | { |
987009bf | 5423 | error ("Tree check: expected %s, have %s", |
8f985ec4 | 5424 | tree_code_name[code], tree_code_name[TREE_CODE (node)]); |
987009bf | 5425 | fancy_abort (file, line, function); |
12b195d9 ML |
5426 | } |
5427 | ||
9ec36da5 JL |
5428 | /* Similar to above, except that we check for a class of tree |
5429 | code, given in CL. */ | |
8f985ec4 ZW |
5430 | void |
5431 | tree_class_check_failed (node, cl, file, line, function) | |
5432 | const tree node; | |
12b195d9 | 5433 | char cl; |
37b37199 | 5434 | const char *file; |
12b195d9 | 5435 | int line; |
8f985ec4 | 5436 | const char *function; |
12b195d9 | 5437 | { |
987009bf ZW |
5438 | error ("Tree check: expected class '%c', have '%c' (%s)", |
5439 | cl, TREE_CODE_CLASS (TREE_CODE (node)), | |
8f985ec4 | 5440 | tree_code_name[TREE_CODE (node)]); |
987009bf | 5441 | fancy_abort (file, line, function); |
8f985ec4 ZW |
5442 | } |
5443 | ||
f4524c9e | 5444 | #endif /* ENABLE_TREE_CHECKING */ |
41472af8 MM |
5445 | |
5446 | /* Return the alias set for T, which may be either a type or an | |
5447 | expression. */ | |
5448 | ||
2ba57343 RH |
5449 | int |
5450 | get_alias_set (t) | |
41472af8 MM |
5451 | tree t; |
5452 | { | |
d4b60170 | 5453 | if (! flag_strict_aliasing || lang_get_alias_set == 0) |
41472af8 MM |
5454 | /* If we're not doing any lanaguage-specific alias analysis, just |
5455 | assume everything aliases everything else. */ | |
5456 | return 0; | |
5457 | else | |
5458 | return (*lang_get_alias_set) (t); | |
5459 | } | |
2ba57343 RH |
5460 | |
5461 | /* Return a brand-new alias set. */ | |
5462 | ||
5463 | int | |
5464 | new_alias_set () | |
5465 | { | |
5466 | static int last_alias_set; | |
d4b60170 | 5467 | |
a17fcad7 RH |
5468 | if (flag_strict_aliasing) |
5469 | return ++last_alias_set; | |
5470 | else | |
5471 | return 0; | |
2ba57343 | 5472 | } |
81b3411c BS |
5473 | \f |
5474 | #ifndef CHAR_TYPE_SIZE | |
5475 | #define CHAR_TYPE_SIZE BITS_PER_UNIT | |
5476 | #endif | |
5477 | ||
5478 | #ifndef SHORT_TYPE_SIZE | |
5479 | #define SHORT_TYPE_SIZE (BITS_PER_UNIT * MIN ((UNITS_PER_WORD + 1) / 2, 2)) | |
5480 | #endif | |
5481 | ||
5482 | #ifndef INT_TYPE_SIZE | |
5483 | #define INT_TYPE_SIZE BITS_PER_WORD | |
5484 | #endif | |
5485 | ||
5486 | #ifndef LONG_TYPE_SIZE | |
5487 | #define LONG_TYPE_SIZE BITS_PER_WORD | |
5488 | #endif | |
5489 | ||
5490 | #ifndef LONG_LONG_TYPE_SIZE | |
5491 | #define LONG_LONG_TYPE_SIZE (BITS_PER_WORD * 2) | |
5492 | #endif | |
5493 | ||
5494 | #ifndef FLOAT_TYPE_SIZE | |
5495 | #define FLOAT_TYPE_SIZE BITS_PER_WORD | |
5496 | #endif | |
5497 | ||
5498 | #ifndef DOUBLE_TYPE_SIZE | |
5499 | #define DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) | |
5500 | #endif | |
5501 | ||
5502 | #ifndef LONG_DOUBLE_TYPE_SIZE | |
5503 | #define LONG_DOUBLE_TYPE_SIZE (BITS_PER_WORD * 2) | |
5504 | #endif | |
5505 | ||
5506 | /* Create nodes for all integer types (and error_mark_node) using the sizes | |
5507 | of C datatypes. The caller should call set_sizetype soon after calling | |
5508 | this function to select one of the types as sizetype. */ | |
5509 | ||
5510 | void | |
5511 | build_common_tree_nodes (signed_char) | |
5512 | int signed_char; | |
5513 | { | |
5514 | error_mark_node = make_node (ERROR_MARK); | |
5515 | TREE_TYPE (error_mark_node) = error_mark_node; | |
5516 | ||
fed3cef0 RK |
5517 | initialize_sizetypes (); |
5518 | ||
81b3411c BS |
5519 | /* Define both `signed char' and `unsigned char'. */ |
5520 | signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE); | |
5521 | unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE); | |
5522 | ||
5523 | /* Define `char', which is like either `signed char' or `unsigned char' | |
5524 | but not the same as either. */ | |
5525 | char_type_node | |
5526 | = (signed_char | |
5527 | ? make_signed_type (CHAR_TYPE_SIZE) | |
5528 | : make_unsigned_type (CHAR_TYPE_SIZE)); | |
5529 | ||
5530 | short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE); | |
5531 | short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE); | |
5532 | integer_type_node = make_signed_type (INT_TYPE_SIZE); | |
81b3411c BS |
5533 | unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE); |
5534 | long_integer_type_node = make_signed_type (LONG_TYPE_SIZE); | |
5535 | long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE); | |
5536 | long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE); | |
5537 | long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE); | |
5538 | ||
5539 | intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode)); | |
5540 | intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode)); | |
5541 | intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode)); | |
5542 | intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode)); | |
5543 | intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode)); | |
5544 | ||
5545 | unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode)); | |
5546 | unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode)); | |
5547 | unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode)); | |
5548 | unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode)); | |
5549 | unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode)); | |
5550 | } | |
5551 | ||
81b3411c | 5552 | /* Call this function after calling build_common_tree_nodes and set_sizetype. |
fed3cef0 | 5553 | It will create several other common tree nodes. */ |
d4b60170 | 5554 | |
81b3411c BS |
5555 | void |
5556 | build_common_tree_nodes_2 (short_double) | |
5557 | int short_double; | |
5558 | { | |
05bccae2 | 5559 | /* Define these next since types below may used them. */ |
81b3411c BS |
5560 | integer_zero_node = build_int_2 (0, 0); |
5561 | TREE_TYPE (integer_zero_node) = integer_type_node; | |
5562 | integer_one_node = build_int_2 (1, 0); | |
5563 | TREE_TYPE (integer_one_node) = integer_type_node; | |
5564 | ||
5565 | size_zero_node = build_int_2 (0, 0); | |
5566 | TREE_TYPE (size_zero_node) = sizetype; | |
5567 | size_one_node = build_int_2 (1, 0); | |
5568 | TREE_TYPE (size_one_node) = sizetype; | |
5569 | ||
5570 | void_type_node = make_node (VOID_TYPE); | |
05bccae2 | 5571 | layout_type (void_type_node); |
d4b60170 | 5572 | |
81b3411c BS |
5573 | /* We are not going to have real types in C with less than byte alignment, |
5574 | so we might as well not have any types that claim to have it. */ | |
5575 | TYPE_ALIGN (void_type_node) = BITS_PER_UNIT; | |
5576 | ||
5577 | null_pointer_node = build_int_2 (0, 0); | |
5578 | TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node); | |
5579 | layout_type (TREE_TYPE (null_pointer_node)); | |
5580 | ||
5581 | ptr_type_node = build_pointer_type (void_type_node); | |
5582 | const_ptr_type_node | |
5583 | = build_pointer_type (build_type_variant (void_type_node, 1, 0)); | |
5584 | ||
5585 | float_type_node = make_node (REAL_TYPE); | |
5586 | TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE; | |
5587 | layout_type (float_type_node); | |
5588 | ||
5589 | double_type_node = make_node (REAL_TYPE); | |
5590 | if (short_double) | |
5591 | TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE; | |
5592 | else | |
5593 | TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE; | |
5594 | layout_type (double_type_node); | |
5595 | ||
5596 | long_double_type_node = make_node (REAL_TYPE); | |
5597 | TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE; | |
5598 | layout_type (long_double_type_node); | |
5599 | ||
5600 | complex_integer_type_node = make_node (COMPLEX_TYPE); | |
5601 | TREE_TYPE (complex_integer_type_node) = integer_type_node; | |
5602 | layout_type (complex_integer_type_node); | |
5603 | ||
5604 | complex_float_type_node = make_node (COMPLEX_TYPE); | |
5605 | TREE_TYPE (complex_float_type_node) = float_type_node; | |
5606 | layout_type (complex_float_type_node); | |
5607 | ||
5608 | complex_double_type_node = make_node (COMPLEX_TYPE); | |
5609 | TREE_TYPE (complex_double_type_node) = double_type_node; | |
5610 | layout_type (complex_double_type_node); | |
5611 | ||
5612 | complex_long_double_type_node = make_node (COMPLEX_TYPE); | |
5613 | TREE_TYPE (complex_long_double_type_node) = long_double_type_node; | |
5614 | layout_type (complex_long_double_type_node); | |
5615 | ||
5616 | #ifdef BUILD_VA_LIST_TYPE | |
5617 | BUILD_VA_LIST_TYPE(va_list_type_node); | |
5618 | #else | |
5619 | va_list_type_node = ptr_type_node; | |
5620 | #endif | |
5621 | } |