![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to decl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to decl.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* Process declarations and variables for C compiler.
2: Copyright (C) 1988 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: /* Process declarations and symbol lookup for C front end.
23: Also constructs types; the standard scalar types at initialization,
24: and structure, union, array and enum types when they are declared. */
25:
26: /* ??? not all decl nodes are given the most useful possible
27: line numbers. For example, the CONST_DECLs for enum values. */
28:
29: #include "config.h"
30: #include "tree.h"
31: #include "flags.h"
32: #include "c-tree.h"
33: #include "parse.h"
34:
35: /* In grokdeclarator, distinguish syntactic contexts of declarators. */
36: enum decl_context
37: { NORMAL, /* Ordinary declaration */
38: FUNCDEF, /* Function definition */
39: PARM, /* Declaration of parm before function body */
40: FIELD, /* Declaration inside struct or union */
41: TYPENAME}; /* Typename (inside cast or sizeof) */
42:
43: #define NULL 0
44: #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
45: #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
46:
47: static tree grokparms (), grokdeclarator ();
48: tree pushdecl ();
49: tree make_index_type ();
50: static void builtin_function ();
51:
52: static tree lookup_tag ();
53: static tree lookup_tag_reverse ();
54: static tree lookup_name_current_level ();
55: static char *redeclaration_error_message ();
56:
57: /* a node which has tree code ERROR_MARK, and whose type is itself.
58: All erroneous expressions are replaced with this node. All functions
59: that accept nodes as arguments should avoid generating error messages
60: if this node is one of the arguments, since it is undesirable to get
61: multiple error messages from one error in the input. */
62:
63: tree error_mark_node;
64:
65: /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
66:
67: tree short_integer_type_node;
68: tree integer_type_node;
69: tree long_integer_type_node;
70:
71: tree short_unsigned_type_node;
72: tree unsigned_type_node;
73: tree long_unsigned_type_node;
74:
75: tree unsigned_char_type_node;
76: tree signed_char_type_node;
77: tree char_type_node;
78:
79: tree float_type_node;
80: tree double_type_node;
81: tree long_double_type_node;
82:
83: /* a VOID_TYPE node. */
84:
85: tree void_type_node;
86:
87: /* A node for type `void *'. */
88:
89: tree ptr_type_node;
90:
91: /* A node for type `char *'. */
92:
93: tree string_type_node;
94:
95: /* Type `char[256]' or something like it.
96: Used when an array of char is needed and the size is irrelevant. */
97:
98: tree char_array_type_node;
99:
100: /* Type `int[256]' or something like it.
101: Used when an array of int needed and the size is irrelevant. */
102:
103: tree int_array_type_node;
104:
105: /* type `int ()' -- used for implicit declaration of functions. */
106:
107: tree default_function_type;
108:
109: /* function types `double (double)' and `double (double, double)', etc. */
110:
111: tree double_ftype_double, double_ftype_double_double;
112: tree int_ftype_int, long_ftype_long;
113:
114: /* Function type `void (void *, void *, int)' and similar ones */
115:
116: tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int;
117:
118: /* Two expressions that are constants with value zero.
119: The first is of type `int', the second of type `void *'. */
120:
121: tree integer_zero_node;
122: tree null_pointer_node;
123:
124: /* A node for the integer constant 1. */
125:
126: tree integer_one_node;
127:
128: /* An identifier whose name is <value>. This is used as the "name"
129: of the RESULT_DECLs for values of functions. */
130:
131: tree value_identifier;
132:
133: /* While defining an enum type, this is 1 plus the last enumerator
134: constant value. */
135:
136: static tree enum_next_value;
137:
138: /* Parsing a function declarator leaves a list of parameter names
139: or a chain or parameter decls here. */
140:
141: static tree last_function_parms;
142:
143: /* Parsing a function declarator leaves here a chain of structure
144: and enum types declared in the parmlist. */
145:
146: static tree last_function_parm_tags;
147:
148: /* After parsing the declarator that starts a function definition,
149: `start_function' puts here the list of parameter names or chain of decls.
150: `store_parm_decls' finds it here. */
151:
152: static tree current_function_parms;
153:
154: /* Similar, for last_function_parm_tags. */
155: static tree current_function_parm_tags;
156:
157: /* A list (chain of TREE_LIST nodes) of all LABEL_STMTs in the function
158: that have names. Here so we can clear out their names' definitions
159: at the end of the function. */
160:
161: static tree named_labels;
162:
163: /* The FUNCTION_DECL for the function currently being compiled,
164: or 0 if between functions. */
165: tree current_function_decl;
166:
167: /* Set to 0 at beginning of a function definition, set to 1 if
168: a return statement that specifies a return value is seen. */
169:
170: int current_function_returns_value;
171:
172: /* Set to 0 at beginning of a function definition, set to 1 if
173: a return statement with no argument is seen. */
174:
175: int current_function_returns_null;
176:
177: /* Set to nonzero by `grokdeclarator' for a function
178: whose return type is defaulted, if warnings for this are desired. */
179:
180: static int warn_about_return_type;
181:
182: /* For each binding contour we allocate a binding_level structure
183: * which records the names defined in that contour.
184: * Contours include:
185: * 0) the global one
186: * 1) one for each function definition,
187: * where internal declarations of the parameters appear.
188: * 2) one for each compound statement,
189: * to record its declarations.
190: *
191: * The current meaning of a name can be found by searching the levels from
192: * the current one out to the global one.
193: */
194:
195: /* Note that the information in the `names' component of the global contour
196: is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
197:
198: struct binding_level
199: {
200: /* A chain of _DECL nodes for all variables, constants, functions,
201: and typedef types. These are in the reverse of the order supplied.
202: */
203: tree names;
204:
205: /* A list of structure, union and enum definitions,
206: * for looking up tag names.
207: * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
208: * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
209: * or ENUMERAL_TYPE node.
210: */
211: tree tags;
212:
213: /* For each level, a list of shadowed outer-level local definitions
214: to be restored when this level is popped.
215: Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
216: whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
217: tree shadowed;
218:
219: /* For each level (except not the global one),
220: a chain of LET_STMT nodes for all the levels
221: that were entered and exited one level down. */
222: tree blocks;
223:
224: /* The binding level which this one is contained in (inherits from). */
225: struct binding_level *level_chain;
226:
227: /* Nonzero for the level that holds the parameters of a function. */
228: char parm_flag;
229:
230: /* Nonzero if this level "doesn't exist" for tags. */
231: char tag_transparent;
232:
233: /* Number of decls in `names' that have incomplete
234: structure or union types. */
235: int n_incomplete;
236: };
237:
238: #define NULL_BINDING_LEVEL (struct binding_level *) NULL
239:
240: /* The binding level currently in effect. */
241:
242: static struct binding_level *current_binding_level;
243:
244: /* A chain of binding_level structures awaiting reuse. */
245:
246: static struct binding_level *free_binding_level;
247:
248: /* The outermost binding level, for names of file scope.
249: This is created when the compiler is started and exists
250: through the entire run. */
251:
252: static struct binding_level *global_binding_level;
253:
254: /* Binding level structures are initialized by copying this one. */
255:
256: static struct binding_level clear_binding_level
257: = {NULL, NULL, NULL, NULL, NULL, 0, 0, 0};
258:
259: /* Create a new `struct binding_level'. */
260:
261: static
262: struct binding_level *
263: make_binding_level ()
264: {
265: /* NOSTRICT */
266: return (struct binding_level *) xmalloc (sizeof (struct binding_level));
267: }
268:
269: /* Enter a new binding level.
270: If TAG_TRANSPARENT is nonzero, do so only for the name space of variables,
271: not for that of tags. */
272:
273: void
274: pushlevel (tag_transparent)
275: int tag_transparent;
276: {
277: register struct binding_level *newlevel = NULL_BINDING_LEVEL;
278:
279: /* If this is the top level of a function,
280: just make sure that NAMED_LABELS is 0.
281: They should have been set to 0 at the end of the previous function. */
282:
283: if (current_binding_level == global_binding_level)
284: {
285: if (named_labels)
286: abort ();
287: }
288:
289: /* Reuse or create a struct for this binding level. */
290:
291: if (free_binding_level)
292: {
293: newlevel = free_binding_level;
294: free_binding_level = free_binding_level->level_chain;
295: }
296: else
297: {
298: newlevel = make_binding_level ();
299: }
300:
301: /* Add this level to the front of the chain (stack) of levels that
302: are active. */
303:
304: *newlevel = clear_binding_level;
305: newlevel->level_chain = current_binding_level;
306: current_binding_level = newlevel;
307: newlevel->tag_transparent = tag_transparent;
308: }
309:
310: /* Exit a binding level.
311: Pop the level off, and restore the state of the identifier-decl mappings
312: that were in effect when this level was entered.
313:
314: If KEEP is nonzero, this level had explicit declarations, so
315: and create a "block" (a LET_STMT node) for the level
316: to record its declarations and subblocks for symbol table output.
317:
318: If FUNCTIONBODY is nonzero, this level is the body of a function,
319: so create a block as if KEEP were set and also clear out all
320: label names.
321:
322: If REVERSE is nonzero, reverse the order of decls before putting
323: them into the LET_STMT. */
324:
325: void
326: poplevel (keep, reverse, functionbody)
327: int keep;
328: int reverse;
329: int functionbody;
330: {
331: register tree link;
332: /* The chain of decls was accumulated in reverse order.
333: Put it into forward order, just for cleanliness. */
334: tree decls;
335: tree tags = current_binding_level->tags;
336: tree subblocks = current_binding_level->blocks;
337: tree block = 0;
338:
339: /* This warning is turned off because it causes warnings for
340: declarations like `extern struct foo *x'. */
341: #if 0
342: /* Warn about incomplete structure types in this level. */
343: for (link = tags; link; link = TREE_CHAIN (link))
344: if (TYPE_SIZE (TREE_VALUE (link)) == 0)
345: {
346: tree type = TREE_VALUE (link);
347: char *errmsg;
348: switch (TREE_CODE (type))
349: {
350: case RECORD_TYPE:
351: errmsg = "`struct %s' incomplete in scope ending here";
352: break;
353: case UNION_TYPE:
354: errmsg = "`union %s' incomplete in scope ending here";
355: break;
356: case ENUMERAL_TYPE:
357: errmsg = "`enum %s' incomplete in scope ending here";
358: break;
359: }
360: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
361: error (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
362: else
363: /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */
364: error (errmsg, IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
365: }
366: #endif /* 0 */
367:
368: /* Get the decls in the order they were written.
369: Usually current_binding_level->names is in reverse order.
370: But parameter decls were previously put in forward order. */
371:
372: if (reverse)
373: current_binding_level->names
374: = decls = nreverse (current_binding_level->names);
375: else
376: decls = current_binding_level->names;
377:
378: /* If there were any declarations or structure tags in that level,
379: or if this level is a function body,
380: create a LET_STMT to record them for the life of this function. */
381:
382: if (keep || functionbody)
383: block = build_let (0, 0, keep ? decls : 0,
384: subblocks, 0, keep ? tags : 0);
385:
386: /* In each subblock, record that this is its superior. */
387:
388: for (link = subblocks; link; link = TREE_CHAIN (link))
389: STMT_SUPERCONTEXT (link) = block;
390:
391: /* Clear out the meanings of the local variables of this level;
392: also record in each decl which block it belongs to. */
393:
394: for (link = decls; link; link = TREE_CHAIN (link))
395: {
396: if (DECL_NAME (link) != 0)
397: IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
398: DECL_CONTEXT (link) = block;
399: }
400:
401: /* Restore all name-meanings of the outer levels
402: that were shadowed by this level. */
403:
404: for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
405: IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
406:
407: /* If the level being exited is the top level of a function,
408: check over all the labels. */
409:
410: if (functionbody)
411: {
412: /* Clear out the definitions of all label names,
413: since their scopes end here. */
414:
415: for (link = named_labels; link; link = TREE_CHAIN (link))
416: {
417: if (DECL_SOURCE_LINE (TREE_VALUE (link)) == 0)
418: {
419: error ("label `%s' used somewhere above but not defined",
420: IDENTIFIER_POINTER (DECL_NAME (TREE_VALUE (link))));
421: /* Avoid crashing later. */
422: define_label (input_filename, 1, DECL_NAME (TREE_VALUE (link)));
423: }
424: IDENTIFIER_LABEL_VALUE (DECL_NAME (TREE_VALUE (link))) = 0;
425: }
426:
427: named_labels = 0;
428: }
429:
430: /* Pop the current level, and free the structure for reuse. */
431:
432: {
433: register struct binding_level *level = current_binding_level;
434: current_binding_level = current_binding_level->level_chain;
435:
436: level->level_chain = free_binding_level;
437: free_binding_level = level;
438: }
439:
440: if (functionbody)
441: {
442: DECL_INITIAL (current_function_decl) = block;
443: /* If this is the top level block of a function,
444: the vars are the function's parameters.
445: Don't leave them in the LET_STMT because they are
446: found in the FUNCTION_DECL instead. */
447: STMT_VARS (block) = 0;
448: }
449: else if (block)
450: current_binding_level->blocks
451: = chainon (current_binding_level->blocks, block);
452: /* If we did not make a block for the level just exited,
453: any blocks made for inner levels
454: (since they cannot be recorded as subblocks in that level)
455: must be carried forward so they will later become subblocks
456: of something else. */
457: else if (subblocks)
458: current_binding_level->blocks
459: = chainon (current_binding_level->blocks, subblocks);
460:
461: }
462:
463: /* Push a definition of struct, union or enum tag "name".
464: "type" should be the type node.
465: We assume that the tag "name" is not already defined.
466:
467: Note that the definition may really be just a forward reference.
468: In that case, the TYPE_SIZE will be zero. */
469:
470: void
471: pushtag (name, type)
472: tree name, type;
473: {
474: register struct binding_level *b = current_binding_level;
475: while (b->tag_transparent) b = b->level_chain;
476:
477: if (name)
478: {
479: /* Record the identifier as the type's name if it has none. */
480:
481: if (TYPE_NAME (type) == 0)
482: TYPE_NAME (type) = name;
483:
484: b->tags = tree_cons (name, type, b->tags);
485: }
486: }
487:
488: /* Handle when a new declaration NEW has the same name as an old one OLD
489: in the same binding contour. Prints an error message if appropriate.
490:
491: If safely possible, alter OLD to look like NEW, and return 1.
492: Otherwise, return 0. */
493:
494: static int
495: duplicate_decls (new, old)
496: register tree new, old;
497: {
498: int types_match = comptypes (TREE_TYPE (new), TREE_TYPE (old));
499:
500: /* If this decl has linkage, and the old one does too, maybe no error. */
501: if (TREE_CODE (old) != TREE_CODE (new))
502: error_with_decl (new, "`%s' redeclared as different kind of symbol");
503: else
504: {
505: if (!types_match)
506: error_with_decl (new, "conflicting types for `%s'");
507: else
508: {
509: char *errmsg = redeclaration_error_message (new, old);
510: if (errmsg)
511: error_with_decl (new, errmsg);
512: }
513: }
514:
515: if (TREE_CODE (old) == TREE_CODE (new))
516: {
517: /* Copy all the DECL_... slots specified in the new decl
518: except for any that we copy here from the old type. */
519:
520: if (types_match)
521: {
522: tree oldtype = TREE_TYPE (old);
523: /* Merge the data types specified in the two decls. */
524: TREE_TYPE (new)
525: = TREE_TYPE (old) = commontype (TREE_TYPE (new), TREE_TYPE (old));
526:
527: /* Lay the type out, unless already done. */
528: if (oldtype != TREE_TYPE (new))
529: {
530: if (TREE_TYPE (new) != error_mark_node)
531: layout_type (TREE_TYPE (new));
532: if (TREE_CODE (new) != FUNCTION_DECL
533: && TREE_CODE (new) != TYPE_DECL
534: && TREE_CODE (new) != CONST_DECL)
535: layout_decl (new);
536: }
537: else
538: {
539: /* Since the type is OLD's, make OLD's size go with. */
540: DECL_SIZE (new) = DECL_SIZE (old);
541: DECL_SIZE_UNIT (new) = DECL_SIZE_UNIT (old);
542: }
543:
544: /* Merge the initialization information. */
545: if (DECL_INITIAL (new) == 0)
546: DECL_INITIAL (new) = DECL_INITIAL (old);
547: /* Keep the old rtl since we can safely use it. */
548: DECL_RTL (new) = DECL_RTL (old);
549: }
550: /* If cannot merge, then use the new type
551: and discard the old rtl. */
552: else
553: TREE_TYPE (old) = TREE_TYPE (new);
554:
555: /* Merge the storage class information. */
556: if (TREE_EXTERNAL (new))
557: {
558: TREE_STATIC (new) = TREE_STATIC (old);
559: TREE_PUBLIC (new) = TREE_PUBLIC (old);
560: TREE_EXTERNAL (new) = TREE_EXTERNAL (old);
561: }
562: else
563: {
564: TREE_STATIC (old) = TREE_STATIC (new);
565: TREE_EXTERNAL (old) = 0;
566: TREE_PUBLIC (old) = TREE_PUBLIC (new);
567: }
568: /* If either decl says `inline', this fn is inline,
569: unless its definition was passed already. */
570: if (TREE_INLINE (new) && DECL_INITIAL (old) == 0)
571: TREE_INLINE (old) = 1;
572:
573: bcopy ((char *) new + sizeof (struct tree_common),
574: (char *) old + sizeof (struct tree_common),
575: sizeof (struct tree_decl) - sizeof (struct tree_common));
576: return 1;
577: }
578:
579: /* New decl is completely inconsistent with the old one =>
580: tell caller to replace the old one. */
581: return 0;
582: }
583:
584: /* Record a decl-node X as belonging to the current lexical scope.
585: Check for errors (such as an incompatible declaration for the same
586: name already seen in the same scope).
587:
588: Returns either X or an old decl for the same name.
589: If an old decl is returned, it may have been smashed
590: to agree with what X says. */
591:
592: tree
593: pushdecl (x)
594: tree x;
595: {
596: register tree t;
597: register tree name = DECL_NAME (x);
598:
599: if (name)
600: {
601: t = lookup_name_current_level (name);
602: if (t && duplicate_decls (x, t))
603: return t;
604:
605: /* If declaring a type as a typedef, and the type has no known
606: typedef name, install this TYPE_DECL as its typedef name. */
607: if (TREE_CODE (x) == TYPE_DECL)
608: if (TYPE_NAME (TREE_TYPE (x)) == 0)
609: TYPE_NAME (TREE_TYPE (x)) = x;
610:
611: /* This name is new in its binding level.
612: Install the new declaration and return it. */
613: if (current_binding_level == global_binding_level
614: /* In PCC-compatibility mode, extern decls
615: take effect at top level no matter where they are. */
616: || (flag_traditional && TREE_EXTERNAL (x)
617: && lookup_name (name) == 0))
618: {
619: /* Install a global value. */
620:
621: IDENTIFIER_GLOBAL_VALUE (name) = x;
622:
623: if (IDENTIFIER_IMPLICIT_DECL (name) != 0
624: /* If this real decl matches the implicit, don't complain. */
625: && ! (TREE_CODE (x) == FUNCTION_DECL
626: && TREE_TYPE (TREE_TYPE (x)) == integer_type_node))
627: warning ("`%s' was previously implicitly declared to return `int'",
628: IDENTIFIER_POINTER (name));
629: }
630: else
631: {
632: /* Here to install a non-global value. */
633: tree oldlocal = IDENTIFIER_LOCAL_VALUE (name);
634: IDENTIFIER_LOCAL_VALUE (name) = x;
635:
636: /* If this is an extern function declaration, see if we
637: have a global definition for the function. */
638: if (oldlocal == 0
639: && IDENTIFIER_GLOBAL_VALUE (name)
640: && TREE_CODE (x) == FUNCTION_DECL
641: && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == FUNCTION_DECL
642: && TREE_INLINE (IDENTIFIER_GLOBAL_VALUE (name)))
643: {
644: /* We have one. Their types must agree. */
645: if (! comptypes (TREE_TYPE (x),
646: TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name))))
647: warning_with_decl (x, "local declaration of `%s' doesn't match global one");
648: /* If the global one is inline, make the local one inline. */
649: else if (TREE_INLINE (IDENTIFIER_GLOBAL_VALUE (name)))
650: IDENTIFIER_LOCAL_VALUE (name) = IDENTIFIER_GLOBAL_VALUE (name);
651: }
652: /* Warn if shadowing an argument. */
653: if (oldlocal != 0
654: && TREE_CODE (oldlocal) == PARM_DECL
655: && current_binding_level->level_chain->parm_flag)
656: warning ("shadowing parameter `%s' with a local variable",
657: IDENTIFIER_POINTER (name));
658: /* If storing a local value, there may already be one (inherited).
659: If so, record it for restoration when this binding level ends. */
660: if (oldlocal != 0)
661: current_binding_level->shadowed
662: = tree_cons (name, oldlocal,
663: current_binding_level->shadowed);
664: }
665:
666: /* Keep count of variables in this level with incomplete type. */
667: if (TYPE_SIZE (TREE_TYPE (x)) == 0)
668: ++current_binding_level->n_incomplete;
669: }
670:
671: /* Put decls on list in reverse order.
672: We will reverse them later if necessary. */
673: TREE_CHAIN (x) = current_binding_level->names;
674: current_binding_level->names = x;
675:
676: return x;
677: }
678:
679: /* Generate an implicit declaration for identifier FUNCTIONID
680: as a function of type int (). Print a warning if appropriate. */
681:
682: tree
683: implicitly_declare (functionid)
684: tree functionid;
685: {
686: register tree decl;
687: int force_perm = 0;
688:
689: if (current_binding_level == global_binding_level
690: || flag_traditional)
691: /* An implicit declaration not inside a function?
692: It can happen with invalid input in an initializer.
693: A suitable error message will happen later,
694: but we must not put a temporary node in a global value!
695: If -traditional, ALL implicit decls must be permanent. */
696: force_perm = 1;
697:
698: if (force_perm)
699: end_temporary_allocation ();
700:
701: decl = build_decl (FUNCTION_DECL, functionid, default_function_type);
702:
703: TREE_EXTERNAL (decl) = 1;
704: TREE_PUBLIC (decl) = 1;
705:
706: /* ANSI standard says implicit declarations are in the innermost block.
707: So we record the decl in the standard fashion.
708: If flag_traditional is set, pushdecl does it top-level. */
709: pushdecl (decl);
710: rest_of_decl_compilation (decl, 0, 0, 0);
711:
712: if (warn_implicit
713: /* Only one warning per identifier. */
714: && IDENTIFIER_IMPLICIT_DECL (functionid) == 0)
715: warning ("implicit declaration of function `%s'",
716: IDENTIFIER_POINTER (functionid));
717:
718: IDENTIFIER_IMPLICIT_DECL (functionid) = decl;
719:
720: if (force_perm)
721: temporary_allocation ();
722:
723: return decl;
724: }
725:
726: /* Return zero if the declaration NEW is valid
727: when the declaration OLD (assumed to be for the same name)
728: has already been seen.
729: Otherwise return an error message format string with a %s
730: where the identifier should go. */
731:
732: static char *
733: redeclaration_error_message (new, old)
734: tree new, old;
735: {
736: if (TREE_CODE (new) == TYPE_DECL)
737: return "redefinition of `%s'";
738: else if (TREE_CODE (new) == FUNCTION_DECL)
739: {
740: /* Declarations of functions can insist on internal linkage
741: but they can't be inconsistent with internal linkage,
742: so there can be no error on that account.
743: However defining the same name twice is no good. */
744: if (DECL_INITIAL (old) != 0 && DECL_INITIAL (new) != 0)
745: return "redefinition of `%s'";
746: return 0;
747: }
748: else if (current_binding_level == global_binding_level)
749: {
750: /* Objects declared at top level: */
751: /* If at least one is a reference, it's ok. */
752: if (TREE_EXTERNAL (new) || TREE_EXTERNAL (old))
753: return 0;
754: /* Reject two definitions. */
755: if (DECL_INITIAL (old) != 0 && DECL_INITIAL (new) != 0)
756: return "redefinition of `%s'";
757: /* Now we have two tentative defs, or one tentative and one real def. */
758: /* Insist that the linkage match. */
759: if (TREE_PUBLIC (old) != TREE_PUBLIC (new))
760: return "conflicting declarations of `%s'";
761: return 0;
762: }
763: else
764: {
765: /* Objects declared with block scope: */
766: /* Reject two definitions, and reject a definition
767: together with an external reference. */
768: if (!(TREE_EXTERNAL (new) && TREE_EXTERNAL (old)))
769: return "redeclaration of `%s'";
770: return 0;
771: }
772: }
773:
774: /* Get the LABEL_DECL corresponding to identifier ID as a label.
775: Create one if none exists so far for the current function.
776: This function is called for both label definitions and label references. */
777:
778: tree
779: lookup_label (id)
780: tree id;
781: {
782: register tree decl = IDENTIFIER_LABEL_VALUE (id);
783:
784: if (decl != 0)
785: return decl;
786:
787: decl = build_decl (LABEL_DECL, id, NULL_TREE);
788: DECL_MODE (decl) = VOIDmode;
789: /* Mark that the label's definition has not been seen. */
790: DECL_SOURCE_LINE (decl) = 0;
791:
792: IDENTIFIER_LABEL_VALUE (id) = decl;
793:
794: named_labels
795: = tree_cons (NULL_TREE, decl, named_labels);
796:
797: return decl;
798: }
799:
800: /* Define a label, specifying the location in the source file.
801: Return the LABEL_DECL node for the label, if the definition is valid.
802: Otherwise return 0. */
803:
804: tree
805: define_label (filename, line, name)
806: char *filename;
807: int line;
808: tree name;
809: {
810: tree decl = lookup_label (name);
811: if (DECL_SOURCE_LINE (decl) != 0)
812: {
813: error_with_decl (decl, "duplicate label `%s'");
814: return 0;
815: }
816: else
817: {
818: /* Mark label as having been defined. */
819: DECL_SOURCE_FILE (decl) = filename;
820: DECL_SOURCE_LINE (decl) = line;
821: return decl;
822: }
823: }
824:
825: /* Return the list of declarations of the current level.
826: Note that this list is in reverse order unless/until
827: you nreverse it; and when you do nreverse it, you must
828: store the result back using `storedecls' or you will lose. */
829:
830: tree
831: getdecls ()
832: {
833: return current_binding_level->names;
834: }
835:
836: /* Return the list of type-tags (for structs, etc) of the current level. */
837:
838: tree
839: gettags ()
840: {
841: return current_binding_level->tags;
842: }
843:
844: /* Store the list of declarations of the current level.
845: This is done for the parameter declarations of a function being defined,
846: after they are modified in the light of any missing parameters. */
847:
848: static void
849: storedecls (decls)
850: tree decls;
851: {
852: current_binding_level->names = decls;
853: }
854:
855: /* Similarly, store the list of tags of the current level. */
856:
857: static void
858: storetags (tags)
859: tree tags;
860: {
861: current_binding_level->tags = tags;
862: }
863:
864: /* Given NAME, an IDENTIFIER_NODE,
865: return the structure (or union or enum) definition for that name.
866: Searches binding levels from BINDING_LEVEL up to the global level.
867: If THISLEVEL_ONLY is nonzero, searches only the specified context
868: (but skips any tag-transparent contexts to find one that is
869: meaningful for tags).
870: FORM says which kind of type the caller wants;
871: it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
872: If the wrong kind of type is found, an error is reported. */
873:
874: static tree
875: lookup_tag (form, name, binding_level, thislevel_only)
876: enum tree_code form;
877: struct binding_level *binding_level;
878: tree name;
879: int thislevel_only;
880: {
881: register struct binding_level *level;
882:
883: for (level = binding_level; level; level = level->level_chain)
884: {
885: register tree tail;
886: for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
887: {
888: if (TREE_PURPOSE (tail) == name)
889: {
890: if (TREE_CODE (TREE_VALUE (tail)) != form)
891: {
892: /* Definition isn't the kind we were looking for. */
893: error ("`%s' defined as wrong kind of tag",
894: IDENTIFIER_POINTER (name));
895: }
896: return TREE_VALUE (tail);
897: }
898: }
899: if (thislevel_only && ! level->tag_transparent)
900: return NULL_TREE;
901: }
902: return NULL_TREE;
903: }
904:
905: /* Given a type, find the tag that was defined for it and return the tag name.
906: Otherwise return 0. However, the value can never be 0
907: in the cases in which this is used. */
908:
909: static tree
910: lookup_tag_reverse (type)
911: tree type;
912: {
913: register struct binding_level *level;
914:
915: for (level = current_binding_level; level; level = level->level_chain)
916: {
917: register tree tail;
918: for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
919: {
920: if (TREE_VALUE (tail) == type)
921: return TREE_PURPOSE (tail);
922: }
923: }
924: return NULL_TREE;
925: }
926:
927: /* Look up NAME in the current binding level and its superiors
928: in the namespace of variables, functions and typedefs.
929: Return a ..._DECL node of some kind representing its definition,
930: or return 0 if it is undefined. */
931:
932: tree
933: lookup_name (name)
934: tree name;
935: {
936: register tree val;
937: if (current_binding_level != global_binding_level
938: && IDENTIFIER_LOCAL_VALUE (name))
939: val = IDENTIFIER_LOCAL_VALUE (name);
940: else
941: val = IDENTIFIER_GLOBAL_VALUE (name);
942: if (val && TREE_TYPE (val) == error_mark_node)
943: return error_mark_node;
944: return val;
945: }
946:
947: /* Similar to `lookup_name' but look only at current binding level. */
948:
949: static tree
950: lookup_name_current_level (name)
951: tree name;
952: {
953: register tree t;
954:
955: if (current_binding_level == global_binding_level)
956: return IDENTIFIER_GLOBAL_VALUE (name);
957:
958: if (IDENTIFIER_LOCAL_VALUE (name) == 0)
959: return 0;
960:
961: for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
962: if (DECL_NAME (t) == name)
963: break;
964:
965: return t;
966: }
967:
968: /* Create the predefined scalar types of C,
969: and some nodes representing standard constants (0, 1, (void *)0).
970: Initialize the global binding level.
971: Make definitions for built-in primitive functions. */
972:
973: void
974: init_decl_processing ()
975: {
976: register tree endlink;
977:
978: current_function_decl = NULL;
979: named_labels = NULL;
980: current_binding_level = NULL_BINDING_LEVEL;
981: free_binding_level = NULL_BINDING_LEVEL;
982: pushlevel (0); /* make the binding_level structure for global names */
983: global_binding_level = current_binding_level;
984:
985: value_identifier = get_identifier ("<value>");
986:
987: /* Define `int' and `char' first so that dbx will output them first. */
988:
989: #ifdef INT_TYPE_SIZE
990: integer_type_node = make_signed_type (INT_TYPE_SIZE);
991: #else
992: integer_type_node = make_signed_type (BITS_PER_WORD);
993: #endif
994: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT],
995: integer_type_node));
996:
997: /* Define `char', which is like either `signed char' or `unsigned char'
998: but not the same as either. */
999:
1000: char_type_node =
1001: (flag_signed_char
1002: ? make_signed_type (BITS_PER_UNIT)
1003: : make_unsigned_type (BITS_PER_UNIT));
1004: pushdecl (build_decl (TYPE_DECL, get_identifier ("char"),
1005: char_type_node));
1006:
1007: #ifdef INT_TYPE_SIZE
1008: unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
1009: #else
1010: unsigned_type_node = make_unsigned_type (BITS_PER_WORD);
1011: #endif
1012: pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
1013: unsigned_type_node));
1014:
1015: long_unsigned_type_node = make_unsigned_type (BITS_PER_WORD);
1016: pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),
1017: long_unsigned_type_node));
1018:
1019: /* `unsigned long' or `unsigned int' is the type for sizeof. */
1020: #ifdef INT_TYPE_SIZE
1021: if (INT_TYPE_SIZE != BITS_PER_WORD)
1022: sizetype = long_unsigned_type_node;
1023: else
1024: sizetype = unsigned_type_node;
1025: #else
1026: sizetype = unsigned_type_node;
1027: #endif
1028:
1029: TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype;
1030: TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype;
1031: TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype;
1032: TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype;
1033:
1034: error_mark_node = make_node (ERROR_MARK);
1035: TREE_TYPE (error_mark_node) = error_mark_node;
1036:
1037: short_integer_type_node = make_signed_type (BITS_PER_UNIT * MIN (UNITS_PER_WORD / 2, 2));
1038: pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),
1039: short_integer_type_node));
1040:
1041: long_integer_type_node = make_signed_type (BITS_PER_WORD);
1042: pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),
1043: long_integer_type_node));
1044:
1045: short_unsigned_type_node = make_unsigned_type (BITS_PER_UNIT * MIN (UNITS_PER_WORD / 2, 2));
1046: pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),
1047: short_unsigned_type_node));
1048:
1049: /* Define both `signed char' and `unsigned char'. */
1050: signed_char_type_node = make_signed_type (BITS_PER_UNIT);
1051: pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"),
1052: signed_char_type_node));
1053:
1054: unsigned_char_type_node = make_unsigned_type (BITS_PER_UNIT);
1055: pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),
1056: unsigned_char_type_node));
1057:
1058: float_type_node = make_node (REAL_TYPE);
1059: TYPE_PRECISION (float_type_node) = BITS_PER_WORD;
1060: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT],
1061: float_type_node));
1062: layout_type (float_type_node);
1063:
1064: double_type_node = make_node (REAL_TYPE);
1065: TYPE_PRECISION (double_type_node) = 2 * BITS_PER_WORD;
1066: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE],
1067: double_type_node));
1068: layout_type (double_type_node);
1069:
1070: long_double_type_node = make_node (REAL_TYPE);
1071: TYPE_PRECISION (long_double_type_node) = 2 * BITS_PER_WORD;
1072: pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),
1073: long_double_type_node));
1074: layout_type (long_double_type_node);
1075:
1076: integer_zero_node = build_int_2 (0, 0);
1077: TREE_TYPE (integer_zero_node) = integer_type_node;
1078: integer_one_node = build_int_2 (1, 0);
1079: TREE_TYPE (integer_one_node) = integer_type_node;
1080:
1081: size_zero_node = build_int_2 (0, 0);
1082: TREE_TYPE (size_zero_node) = sizetype;
1083: size_one_node = build_int_2 (1, 0);
1084: TREE_TYPE (size_one_node) = sizetype;
1085:
1086: void_type_node = make_node (VOID_TYPE);
1087: pushdecl (build_decl (TYPE_DECL,
1088: ridpointers[(int) RID_VOID], void_type_node));
1089: layout_type (void_type_node); /* Uses integer_zero_node */
1090:
1091: null_pointer_node = build_int_2 (0, 0);
1092: TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
1093: layout_type (TREE_TYPE (null_pointer_node));
1094:
1095: string_type_node = build_pointer_type (char_type_node);
1096:
1097: /* make a type for arrays of 256 characters.
1098: 256 is picked randomly because we have a type for integers from 0 to 255.
1099: With luck nothing will ever really depend on the length of this
1100: array type. */
1101: char_array_type_node
1102: = build_array_type (char_type_node, unsigned_char_type_node);
1103: /* Likewise for arrays of ints. */
1104: int_array_type_node
1105: = build_array_type (integer_type_node, unsigned_char_type_node);
1106:
1107: default_function_type
1108: = build_function_type (integer_type_node, NULL_TREE);
1109:
1110: ptr_type_node = build_pointer_type (void_type_node);
1111: endlink = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
1112:
1113: double_ftype_double
1114: = build_function_type (double_type_node,
1115: tree_cons (NULL_TREE, double_type_node, endlink));
1116:
1117: double_ftype_double_double
1118: = build_function_type (double_type_node,
1119: tree_cons (NULL_TREE, double_type_node,
1120: tree_cons (NULL_TREE,
1121: double_type_node, endlink)));
1122:
1123: int_ftype_int
1124: = build_function_type (integer_type_node,
1125: tree_cons (NULL_TREE, integer_type_node, endlink));
1126:
1127: long_ftype_long
1128: = build_function_type (long_integer_type_node,
1129: tree_cons (NULL_TREE,
1130: long_integer_type_node, endlink));
1131:
1132: void_ftype_ptr_ptr_int
1133: = build_function_type (void_type_node,
1134: tree_cons (NULL_TREE, ptr_type_node,
1135: tree_cons (NULL_TREE, ptr_type_node,
1136: tree_cons (NULL_TREE,
1137: integer_type_node,
1138: endlink))));
1139:
1140: int_ftype_ptr_ptr_int
1141: = build_function_type (integer_type_node,
1142: tree_cons (NULL_TREE, ptr_type_node,
1143: tree_cons (NULL_TREE, ptr_type_node,
1144: tree_cons (NULL_TREE,
1145: integer_type_node,
1146: endlink))));
1147:
1148: void_ftype_ptr_int_int
1149: = build_function_type (void_type_node,
1150: tree_cons (NULL_TREE, ptr_type_node,
1151: tree_cons (NULL_TREE, integer_type_node,
1152: tree_cons (NULL_TREE,
1153: integer_type_node,
1154: endlink))));
1155:
1156: builtin_function ("__builtin_alloca",
1157: build_function_type (ptr_type_node,
1158: tree_cons (NULL_TREE,
1159: integer_type_node,
1160: endlink)),
1161: BUILT_IN_ALLOCA);
1162:
1163: builtin_function ("__builtin_abs", int_ftype_int, BUILT_IN_ABS);
1164: builtin_function ("__builtin_fabs", double_ftype_double, BUILT_IN_FABS);
1165: builtin_function ("__builtin_labs", long_ftype_long, BUILT_IN_LABS);
1166: builtin_function ("__builtin_ffs", int_ftype_int, BUILT_IN_FFS);
1167: /* builtin_function ("__builtin_div", default_ftype, BUILT_IN_DIV);
1168: builtin_function ("__builtin_ldiv", default_ftype, BUILT_IN_LDIV); */
1169: builtin_function ("__builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR);
1170: builtin_function ("__builtin_fceil", double_ftype_double, BUILT_IN_FCEIL);
1171: builtin_function ("__builtin_fmod", double_ftype_double_double, BUILT_IN_FMOD);
1172: builtin_function ("__builtin_frem", double_ftype_double_double, BUILT_IN_FREM);
1173: builtin_function ("__builtin_memcpy", void_ftype_ptr_ptr_int, BUILT_IN_MEMCPY);
1174: builtin_function ("__builtin_memcmp", int_ftype_ptr_ptr_int, BUILT_IN_MEMCMP);
1175: builtin_function ("__builtin_memset", void_ftype_ptr_int_int, BUILT_IN_MEMSET);
1176: builtin_function ("__builtin_fsqrt", double_ftype_double, BUILT_IN_FSQRT);
1177: builtin_function ("__builtin_getexp", double_ftype_double, BUILT_IN_GETEXP);
1178: builtin_function ("__builtin_getman", double_ftype_double, BUILT_IN_GETMAN);
1179: }
1180:
1181: /* Make a definition for a builtin function named NAME and whose data type
1182: is TYPE. TYPE should be a function type with argument types.
1183: FUNCTION_CODE tells later passes how to compile calls to this function.
1184: See tree.h for its possible values. */
1185:
1186: static void
1187: builtin_function (name, type, function_code)
1188: char *name;
1189: tree type;
1190: enum built_in_function function_code;
1191: {
1192: tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type);
1193: TREE_EXTERNAL (decl) = 1;
1194: TREE_PUBLIC (decl) = 1;
1195: make_function_rtl (decl);
1196: pushdecl (decl);
1197: DECL_SET_FUNCTION_CODE (decl, function_code);
1198: }
1199:
1200: /* Called when a declaration is seen that contains no names to declare.
1201: If its type is a reference to a structure, union or enum inherited
1202: from a containing scope, shadow that tag name for the current scope
1203: with a forward reference.
1204: If its type defines a new named structure or union
1205: or defines an enum, it is valid but we need not do anything here.
1206: Otherwise, it is an error. */
1207:
1208: void
1209: shadow_tag (declspecs)
1210: tree declspecs;
1211: {
1212: register tree link;
1213:
1214: for (link = declspecs; link; link = TREE_CHAIN (link))
1215: {
1216: register tree value = TREE_VALUE (link);
1217: register enum tree_code code = TREE_CODE (value);
1218: if ((code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
1219: && TYPE_SIZE (value) != 0)
1220: {
1221: register tree name = lookup_tag_reverse (value);
1222: register tree t = lookup_tag (code, name, current_binding_level, 1);
1223: if (t == 0)
1224: {
1225: t = make_node (code);
1226: pushtag (name, t);
1227: return;
1228: }
1229: if (name != 0 || code == ENUMERAL_TYPE)
1230: return;
1231: }
1232: }
1233: warning ("empty declaration");
1234: }
1235:
1236: /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
1237:
1238: tree
1239: groktypename (typename)
1240: tree typename;
1241: {
1242: if (TREE_CODE (typename) != TREE_LIST)
1243: return typename;
1244: return grokdeclarator (TREE_VALUE (typename),
1245: TREE_PURPOSE (typename),
1246: TYPENAME, 0);
1247: }
1248:
1249: /* Decode a declarator in an ordinary declaration or data definition.
1250: This is called as soon as the type information and variable name
1251: have been parsed, before parsing the initializer if any.
1252: Here we create the ..._DECL node, fill in its type,
1253: and put it on the list of decls for the current context.
1254: The ..._DECL node is returned as the value.
1255:
1256: Exception: for arrays where the length is not specified,
1257: the type is left null, to be filled in by `finish_decl'.
1258:
1259: Function definitions do not come here; they go to start_function
1260: instead. However, external and forward declarations of functions
1261: do go through here. Structure field declarations are done by
1262: grokfield and not through here. */
1263:
1264: /* Set this nonzero to debug not using the temporary obstack
1265: to parse initializers. */
1266: int debug_no_temp_inits = 1;
1267:
1268: tree
1269: start_decl (declarator, declspecs, initialized)
1270: tree declspecs, declarator;
1271: int initialized;
1272: {
1273: register tree decl = grokdeclarator (declarator, declspecs,
1274: NORMAL, initialized);
1275: register tree tem;
1276: int init_written = initialized;
1277:
1278: if (initialized)
1279: /* Is it valid for this decl to have an initializer at all?
1280: If not, set INITIALIZED to zero, which will indirectly
1281: tell `finish_decl' to ignore the initializer once it is parsed. */
1282: switch (TREE_CODE (decl))
1283: {
1284: case TYPE_DECL:
1285: /* typedef foo = bar means give foo the same type as bar.
1286: We haven't parsed bar yet, so `finish_decl' will fix that up.
1287: Any other case of an initialization in a TYPE_DECL is an error. */
1288: if (pedantic || list_length (declspecs) > 1)
1289: {
1290: error ("typedef `%s' is initialized",
1291: IDENTIFIER_POINTER (DECL_NAME (decl)));
1292: initialized = 0;
1293: }
1294: break;
1295:
1296: case FUNCTION_DECL:
1297: error ("function `%s' is initialized like a variable",
1298: IDENTIFIER_POINTER (DECL_NAME (decl)));
1299: initialized = 0;
1300: break;
1301:
1302: default:
1303: /* Don't allow initializations for incomplete types
1304: except for arrays which might be completed by the initialization. */
1305: if (TYPE_SIZE (TREE_TYPE (decl)) != 0)
1306: ; /* A complete type is ok. */
1307: else if (TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE)
1308: {
1309: error ("variable `%s' has initializer but incomplete type",
1310: IDENTIFIER_POINTER (DECL_NAME (decl)));
1311: initialized = 0;
1312: }
1313: else if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl))) == 0)
1314: {
1315: error ("elements of array `%s' have incomplete type",
1316: IDENTIFIER_POINTER (DECL_NAME (decl)));
1317: initialized = 0;
1318: }
1319: }
1320:
1321: if (initialized)
1322: {
1323: if (current_binding_level != global_binding_level
1324: && TREE_EXTERNAL (decl))
1325: warning ("declaration of `%s' has `extern' and is initialized",
1326: IDENTIFIER_POINTER (DECL_NAME (decl)));
1327: TREE_EXTERNAL (decl) = 0;
1328: if (current_binding_level == global_binding_level)
1329: TREE_STATIC (decl) = 1;
1330:
1331: /* Tell `pushdecl' this is an initialized decl
1332: even though we don't yet have the initializer expression.
1333: Also tell `finish_decl' it may store the real initializer. */
1334: DECL_INITIAL (decl) = error_mark_node;
1335: }
1336:
1337: /* Add this decl to the current binding level. */
1338: tem = pushdecl (decl);
1339:
1340: if (init_written)
1341: {
1342: /* When parsing and digesting the initializer,
1343: use temporary storage. Do this even if we will ignore the value. */
1344: if (current_binding_level == global_binding_level
1345: && debug_no_temp_inits)
1346: temporary_allocation ();
1347: }
1348:
1349: return tem;
1350: }
1351:
1352: /* Finish processing of a declaration;
1353: install its line number and initial value.
1354: If the length of an array type is not known before,
1355: it must be determined now, from the initial value, or it is an error. */
1356:
1357: void
1358: finish_decl (decl, init, asmspec)
1359: tree decl, init;
1360: tree asmspec;
1361: {
1362: register tree type = TREE_TYPE (decl);
1363: int init_written = init != 0;
1364:
1365: /* If `start_decl' didn't like having an initialization, ignore it now. */
1366:
1367: if (init != 0 && DECL_INITIAL (decl) == 0)
1368: init = 0;
1369:
1370: if (init)
1371: {
1372: if (TREE_CODE (decl) != TYPE_DECL)
1373: store_init_value (decl, init);
1374: else
1375: {
1376: /* typedef foo = bar; store the type of bar as the type of foo. */
1377: TREE_TYPE (decl) = TREE_TYPE (init);
1378: DECL_INITIAL (decl) = init = 0;
1379: }
1380: }
1381:
1382: /* For top-level declaration, the initial value was read in
1383: the temporary obstack. MAXINDEX, rtl, etc. to be made below
1384: must go in the permanent obstack; but don't discard the
1385: temporary data yet. */
1386:
1387: if (debug_no_temp_inits && init_written
1388: && current_binding_level == global_binding_level)
1389: end_temporary_allocation ();
1390:
1391: /* Deduce size of array from initialization, if not already known */
1392:
1393: if (TREE_CODE (type) == ARRAY_TYPE
1394: && TYPE_DOMAIN (type) == 0
1395: && TREE_CODE (decl) != TYPE_DECL)
1396: {
1397: int do_default = ! ((!pedantic && TREE_STATIC (decl))
1398: || TREE_EXTERNAL (decl));
1399: int failure
1400: = complete_array_type (type, DECL_INITIAL (decl), do_default);
1401:
1402: if (failure == 1)
1403: error_with_decl (decl, "initializer fails to determine size of `%s'");
1404:
1405: if (failure == 2)
1406: {
1407: if (do_default)
1408: error_with_decl (decl, "array size missing in `%s'");
1409: else if (!pedantic && TREE_STATIC (decl))
1410: TREE_EXTERNAL (decl) = 1;
1411: }
1412:
1413: if (pedantic && TYPE_DOMAIN (type) != 0
1414: && integer_zerop (TYPE_MAX_VALUE (TYPE_DOMAIN (type))))
1415: error_with_decl (decl, "zero-size array `%s'");
1416:
1417: if (TREE_CODE (decl) != TYPE_DECL)
1418: layout_decl (decl, 0);
1419: }
1420:
1421: if (TREE_CODE (decl) == VAR_DECL)
1422: {
1423: if (TREE_STATIC (decl) && DECL_SIZE (decl) == 0)
1424: {
1425: /* A static variable with an incomplete type:
1426: that is an error if it is initialized or `static'.
1427: Otherwise, let it through, but if it is not `extern'
1428: then it may cause an error message later. */
1429: if (! (TREE_PUBLIC (decl) && DECL_INITIAL (decl) == 0))
1430: error_with_decl (decl, "storage size of `%s' isn't known");
1431: }
1432: else if (!TREE_EXTERNAL (decl) && DECL_SIZE (decl) == 0)
1433: {
1434: /* An automatic variable with an incomplete type:
1435: that is an error. */
1436: error_with_decl (decl, "storage size of `%s' isn't known");
1437: TREE_TYPE (decl) = error_mark_node;
1438: }
1439:
1440: if ((TREE_EXTERNAL (decl) || TREE_STATIC (decl))
1441: && DECL_SIZE (decl) != 0 && ! TREE_LITERAL (DECL_SIZE (decl)))
1442: error_with_decl (decl, "storage size of `%s' isn't constant");
1443: }
1444:
1445: /* Output the assembler code and/or RTL code for variables and functions,
1446: unless the type is an undefined structure or union.
1447: If not, it will get done when the type is completed. */
1448:
1449: if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL)
1450: {
1451: rest_of_decl_compilation (decl, asmspec,
1452: current_binding_level == global_binding_level,
1453: 0);
1454: if (TYPE_SIZE (TREE_TYPE (decl)) != 0
1455: || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1456: if (current_binding_level != global_binding_level)
1457: expand_decl (decl);
1458: }
1459:
1460: if (TREE_CODE (decl) == TYPE_DECL)
1461: rest_of_decl_compilation (decl, 0,
1462: current_binding_level == global_binding_level,
1463: 0);
1464:
1465: /* Resume permanent allocation, if not within a function. */
1466: if (debug_no_temp_inits && init_written
1467: && current_binding_level == global_binding_level)
1468: permanent_allocation ();
1469: }
1470:
1471: /* Given a parsed parameter declaration,
1472: decode it into a PARM_DECL and push that on the current binding level. */
1473:
1474: void
1475: push_parm_decl (parm)
1476: tree parm;
1477: {
1478: register tree decl = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm),
1479: PARM, 0);
1480:
1481: /* Add this decl to the current binding level. */
1482: finish_decl (pushdecl (decl), NULL_TREE, NULL_TREE);
1483: }
1484:
1485: /* Make TYPE a complete type based on INITIAL_VALUE.
1486: Return 0 if successful, 1 if INITIAL_VALUE can't be decyphered,
1487: 2 if there was no information (in which case assume 1 if DO_DEFAULT). */
1488:
1489: int
1490: complete_array_type (type, initial_value, do_default)
1491: tree type;
1492: tree initial_value;
1493: int do_default;
1494: {
1495: register tree maxindex = NULL_TREE;
1496: int value = 0;
1497:
1498: if (initial_value)
1499: {
1500: /* Note MAXINDEX is really the maximum index,
1501: one less than the size. */
1502: if (TREE_CODE (initial_value) == STRING_CST)
1503: maxindex = build_int_2 (TREE_STRING_LENGTH (initial_value) - 1, 0);
1504: else if (TREE_CODE (initial_value) == CONSTRUCTOR)
1505: {
1506: register int nelts
1507: = list_length (CONSTRUCTOR_ELTS (initial_value));
1508: maxindex = build_int_2 (nelts - 1, 0);
1509: }
1510: else
1511: {
1512: /* Make an error message unless that happened already. */
1513: if (initial_value != error_mark_node)
1514: value = 1;
1515:
1516: /* Prevent further error messages. */
1517: maxindex = build_int_2 (1, 0);
1518: }
1519: }
1520:
1521: if (!maxindex)
1522: {
1523: if (do_default)
1524: maxindex = build_int_2 (1, 0);
1525: value = 2;
1526: }
1527:
1528: if (maxindex)
1529: {
1530: TYPE_DOMAIN (type) = make_index_type (maxindex);
1531: if (!TREE_TYPE (maxindex))
1532: TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
1533: }
1534:
1535: /* Lay out the type now that we can get the real answer. */
1536:
1537: layout_type (type);
1538:
1539: return value;
1540: }
1541:
1542: /* Given declspecs and a declarator,
1543: determine the name and type of the object declared.
1544: DECLSPECS is a chain of tree_list nodes whose value fields
1545: are the storage classes and type specifiers.
1546:
1547: DECL_CONTEXT says which syntactic context this declaration is in:
1548: NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
1549: FUNCDEF for a function definition. Like NORMAL but a few different
1550: error messages in each case. Return value may be zero meaning
1551: this definition is too screwy to try to parse.
1552: PARM for a parameter declaration (either within a function prototype
1553: or before a function body). Make a PARM_DECL, or return void_type_node.
1554: TYPENAME if for a typename (in a cast or sizeof).
1555: Don't make a DECL node; just return the type.
1556: FIELD for a struct or union field; make a FIELD_DECL.
1557: INITIALIZED is 1 if the decl has an initializer.
1558:
1559: In the TYPENAME case, DECLARATOR is really an absolute declarator.
1560: It may also be so in the PARM case, for a prototype where the
1561: argument type is specified but not the name.
1562:
1563: This function is where the complicated C meanings of `static'
1564: and `extern' are intrepreted. */
1565:
1566: static tree
1567: grokdeclarator (declarator, declspecs, decl_context, initialized)
1568: tree declspecs;
1569: tree declarator;
1570: enum decl_context decl_context;
1571: int initialized;
1572: {
1573: int specbits = 0;
1574: tree spec;
1575: tree type = NULL_TREE;
1576: int longlong = 0;
1577: int constp;
1578: int volatilep;
1579: int inlinep;
1580: int explicit_int = 0;
1581: int explicit_char = 0;
1582: char *name;
1583: tree typedef_type = 0;
1584: int funcdef_flag = 0;
1585: enum tree_code innermost_code = ERROR_MARK;
1586:
1587: if (decl_context == FUNCDEF)
1588: funcdef_flag = 1, decl_context = NORMAL;
1589:
1590: /* Look inside a declarator for the name being declared
1591: and get it as a string, for an error message. */
1592: {
1593: register tree decl = declarator;
1594: name = 0;
1595:
1596: while (decl)
1597: switch (TREE_CODE (decl))
1598: {
1599: case ARRAY_REF:
1600: case INDIRECT_REF:
1601: case CALL_EXPR:
1602: innermost_code = TREE_CODE (decl);
1603: decl = TREE_OPERAND (decl, 0);
1604: break;
1605:
1606: case IDENTIFIER_NODE:
1607: name = IDENTIFIER_POINTER (decl);
1608: decl = 0;
1609: break;
1610:
1611: default:
1612: abort ();
1613: }
1614: if (name == 0)
1615: name = "type name";
1616: }
1617:
1618: /* A function definition's declarator must have the form of
1619: a function declarator. */
1620:
1621: if (funcdef_flag && innermost_code != CALL_EXPR)
1622: return 0;
1623:
1624: /* Anything declared one level down from the top level
1625: must be one of the parameters of a function
1626: (because the body is at least two levels down). */
1627:
1628: if (decl_context == NORMAL
1629: && current_binding_level->level_chain == global_binding_level)
1630: decl_context = PARM;
1631:
1632: /* Look through the decl specs and record which ones appear.
1633: Some typespecs are defined as built-in typenames.
1634: Others, the ones that are modifiers of other types,
1635: are represented by bits in SPECBITS: set the bits for
1636: the modifiers that appear. Storage class keywords are also in SPECBITS.
1637:
1638: If there is a typedef name or a type, store the type in TYPE.
1639: This includes builtin typedefs such as `int'.
1640:
1641: Set EXPLICIT_INT if the type is `int' or `char' and did not
1642: come from a user typedef.
1643:
1644: Set LONGLONG if `long' is mentioned twice. */
1645:
1646: for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
1647: {
1648: register int i;
1649: register tree id = TREE_VALUE (spec);
1650:
1651: if (id == ridpointers[(int) RID_INT])
1652: explicit_int = 1;
1653: if (id == ridpointers[(int) RID_CHAR])
1654: explicit_char = 1;
1655:
1656: if (TREE_CODE (id) == IDENTIFIER_NODE)
1657: for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
1658: {
1659: if (ridpointers[i] == id)
1660: {
1661: if (i == (int) RID_LONG && specbits & (1<<i))
1662: longlong = 1;
1663: if (specbits & (1 << i))
1664: warning ("duplicate `%s'", IDENTIFIER_POINTER (id));
1665: specbits |= 1 << i;
1666: goto found;
1667: }
1668: }
1669: if (type)
1670: error ("two or more data types in declaration of `%s'", name);
1671: else if (TREE_CODE (id) == IDENTIFIER_NODE)
1672: {
1673: register tree t = lookup_name (id);
1674: if (!t || TREE_CODE (t) != TYPE_DECL)
1675: error ("`%s' fails to be a typedef or built in type",
1676: IDENTIFIER_POINTER (id));
1677: else type = TREE_TYPE (t);
1678: }
1679: else if (TREE_CODE (id) != ERROR_MARK)
1680: type = id;
1681:
1682: found: {}
1683: }
1684:
1685: typedef_type = type;
1686:
1687: /* No type at all: default to `int', and set EXPLICIT_INT
1688: because it was not a user-defined typedef. */
1689:
1690: if (type == 0)
1691: {
1692: if (funcdef_flag && warn_return_type
1693: && ! (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
1694: | (1 << (int) RID_SIGNED) | (1 << (int) RID_UNSIGNED))))
1695: warn_about_return_type = 1;
1696: explicit_int = 1;
1697: type = integer_type_node;
1698: }
1699:
1700: /* Now process the modifiers that were specified
1701: and check for invalid combinations. */
1702:
1703: /* Long double is a special combination. */
1704:
1705: if ((specbits & 1 << (int) RID_LONG) && type == double_type_node)
1706: {
1707: specbits &= ~ (1 << (int) RID_LONG);
1708: type = long_double_type_node;
1709: }
1710:
1711: /* Check all other uses of type modifiers. */
1712:
1713: if (specbits & ((1 << (int) RID_LONG) | (1 << (int) RID_SHORT)
1714: | (1 << (int) RID_UNSIGNED) | (1 << (int) RID_SIGNED)))
1715: {
1716: if (!explicit_int && !explicit_char && !pedantic)
1717: error ("long, short, signed or unsigned used invalidly for `%s'", name);
1718: else if ((specbits & 1 << (int) RID_LONG) && (specbits & 1 << (int) RID_SHORT))
1719: error ("long and short specified together for `%s'", name);
1720: else if (((specbits & 1 << (int) RID_LONG) || (specbits & 1 << (int) RID_SHORT))
1721: && explicit_char)
1722: error ("long or short specified with char for `%s'", name);
1723: else if ((specbits & 1 << (int) RID_SIGNED) && (specbits & 1 << (int) RID_UNSIGNED))
1724: error ("signed and unsigned given together for `%s'", name);
1725: else
1726: {
1727: if (specbits & 1 << (int) RID_UNSIGNED)
1728: {
1729: if (specbits & 1 << (int) RID_LONG)
1730: type = long_unsigned_type_node;
1731: else if (specbits & 1 << (int) RID_SHORT)
1732: type = short_unsigned_type_node;
1733: else if (type == char_type_node)
1734: type = unsigned_char_type_node;
1735: else
1736: type = unsigned_type_node;
1737: }
1738: else if ((specbits & 1 << (int) RID_SIGNED)
1739: && type == char_type_node)
1740: type = signed_char_type_node;
1741: else if (specbits & 1 << (int) RID_LONG)
1742: type = long_integer_type_node;
1743: else if (specbits & 1 << (int) RID_SHORT)
1744: type = short_integer_type_node;
1745: }
1746: }
1747:
1748: /* Set CONSTP if this declaration is `const', whether by
1749: explicit specification or via a typedef.
1750: Likewise for VOLATILEP. */
1751:
1752: constp = !! (specbits & 1 << (int) RID_CONST) + TREE_READONLY (type);
1753: volatilep = !! (specbits & 1 << (int) RID_VOLATILE) + TREE_VOLATILE (type);
1754: inlinep = !! (specbits & (1 << (int) RID_INLINE));
1755: if (constp > 1)
1756: warning ("duplicate `const'");
1757: if (volatilep > 1)
1758: warning ("duplicate `volatile'");
1759: type = TYPE_MAIN_VARIANT (type);
1760:
1761: /* Warn if two storage classes are given. Default to `auto'. */
1762:
1763: {
1764: int nclasses = 0;
1765:
1766: if (specbits & 1 << (int) RID_AUTO) nclasses++;
1767: if (specbits & 1 << (int) RID_STATIC) nclasses++;
1768: if (specbits & 1 << (int) RID_EXTERN) nclasses++;
1769: if (specbits & 1 << (int) RID_REGISTER) nclasses++;
1770: if (specbits & 1 << (int) RID_TYPEDEF) nclasses++;
1771:
1772: /* Warn about storage classes that are invalid for certain
1773: kinds of declarations (parameters, typenames, etc.). */
1774:
1775: if (nclasses > 1)
1776: error ("multiple storage classes in declaration of `%s'", name);
1777: else if (decl_context != NORMAL && nclasses > 0)
1778: {
1779: if (decl_context == PARM && specbits & 1 << (int) RID_REGISTER)
1780: ;
1781: else
1782: {
1783: error ((decl_context == FIELD
1784: ? "storage class specified for structure field `%s'"
1785: : (decl_context == PARM
1786: ? "storage class specified for parameter `%s'"
1787: : "storage class specified for typename")),
1788: name);
1789: specbits &= ~ ((1 << (int) RID_TYPEDEF) | (1 << (int) RID_REGISTER)
1790: | (1 << (int) RID_AUTO) | (1 << (int) RID_STATIC)
1791: | (1 << (int) RID_EXTERN));
1792: }
1793: }
1794: else if (current_binding_level == global_binding_level)
1795: {
1796: if (specbits & (1 << (int) RID_AUTO))
1797: error ("top-level declaration of `%s' specifies `auto'", name);
1798: if (specbits & (1 << (int) RID_REGISTER))
1799: error ("top-level declaration of `%s' specifies `register'", name);
1800: }
1801: }
1802:
1803: /* Now figure out the structure of the declarator proper.
1804: Descend through it, creating more complex types, until we reach
1805: the declared identifier (or NULL_TREE, in an absolute declarator). */
1806:
1807: while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
1808: {
1809: if (type == error_mark_node)
1810: {
1811: declarator = TREE_OPERAND (declarator, 0);
1812: continue;
1813: }
1814:
1815: /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
1816: an INDIRECT_REF (for *...),
1817: a CALL_EXPR (for ...(...)),
1818: an identifier (for the name being declared)
1819: or a null pointer (for the place in an absolute declarator
1820: where the name was omitted).
1821: For the last two cases, we have just exited the loop.
1822:
1823: At this point, TYPE is the type of elements of an array,
1824: or for a function to return, or for a pointer to point to.
1825: After this sequence of ifs, TYPE is the type of the
1826: array or function or pointer, and DECLARATOR has had its
1827: outermost layer removed. */
1828:
1829: if (TREE_CODE (declarator) == ARRAY_REF)
1830: {
1831: register tree itype = NULL_TREE;
1832: register tree size = TREE_OPERAND (declarator, 1);
1833:
1834: declarator = TREE_OPERAND (declarator, 0);
1835:
1836: /* Check for some types that there cannot be arrays of. */
1837:
1838: if (type == void_type_node)
1839: {
1840: error ("declaration of `%s' as array of voids", name);
1841: type = error_mark_node;
1842: }
1843:
1844: if (TREE_CODE (type) == FUNCTION_TYPE)
1845: {
1846: error ("declaration of `%s' as array of functions", name);
1847: type = error_mark_node;
1848: }
1849:
1850: if (size == error_mark_node)
1851: type = error_mark_node;
1852:
1853: if (type == error_mark_node)
1854: continue;
1855:
1856: /* If size was specified, set ITYPE to a range-type for that size.
1857: Otherwise, ITYPE remains null. finish_decl may figure it out
1858: from an initial value. */
1859:
1860: if (size)
1861: {
1862: if (TREE_CODE (TREE_TYPE (size)) != INTEGER_TYPE
1863: && TREE_CODE (TREE_TYPE (size)) != ENUMERAL_TYPE)
1864: {
1865: error ("size of array `%s' has non-integer type", name);
1866: size = integer_one_node;
1867: }
1868: if (pedantic && integer_zerop (size))
1869: warning ("ANSI C forbids zero-size array `%s'", name);
1870: if (INT_CST_LT (size, integer_zero_node))
1871: {
1872: error ("size of array `%s' is negative", name);
1873: size = integer_one_node;
1874: }
1875: if (TREE_LITERAL (size))
1876: itype = make_index_type (build_int_2 (TREE_INT_CST_LOW (size) - 1, 0));
1877: else
1878: {
1879: if (pedantic)
1880: warning ("ANSI C forbids variable-size array `%s'", name);
1881: itype = build_binary_op (MINUS_EXPR, size, integer_one_node);
1882: itype = make_index_type (itype);
1883: }
1884: }
1885:
1886: /* Build the array type itself. */
1887:
1888: type = build_array_type (type, itype);
1889: }
1890: else if (TREE_CODE (declarator) == CALL_EXPR)
1891: {
1892: /* Declaring a function type.
1893: Make sure we have a valid type for the function to return. */
1894: if (type == error_mark_node)
1895: continue;
1896:
1897: /* Is this an error? Should they be merged into TYPE here? */
1898: if (constp || volatilep)
1899: warning ("function declared to return const or volatile result");
1900: constp = 0;
1901: volatilep = 0;
1902:
1903: /* Warn about some types functions can't return. */
1904:
1905: if (TREE_CODE (type) == FUNCTION_TYPE)
1906: {
1907: error ("`%s' declared as function returning a function", name);
1908: type = integer_type_node;
1909: }
1910: if (TREE_CODE (type) == ARRAY_TYPE)
1911: {
1912: error ("`%s' declared as function returning an array", name);
1913: type = integer_type_node;
1914: }
1915:
1916: /* Construct the function type and go to the next
1917: inner layer of declarator. */
1918:
1919: type =
1920: build_function_type (type,
1921: grokparms (TREE_OPERAND (declarator, 1),
1922: funcdef_flag
1923: /* Say it's a definition
1924: only for the CALL_EXPR
1925: closest to the identifier. */
1926: && TREE_CODE (TREE_OPERAND (declarator, 0)) == IDENTIFIER_NODE));
1927: declarator = TREE_OPERAND (declarator, 0);
1928: }
1929: else if (TREE_CODE (declarator) == INDIRECT_REF)
1930: {
1931: /* Merge any constancy or volatility into the target type
1932: for the pointer. */
1933:
1934: if (constp || volatilep)
1935: type = build_type_variant (type, constp, volatilep);
1936: constp = 0;
1937: volatilep = 0;
1938:
1939: type = build_pointer_type (type);
1940:
1941: /* Process a list of type modifier keywords
1942: (such as const or volatile) that were given inside the `*'. */
1943:
1944: if (TREE_TYPE (declarator))
1945: {
1946: register tree typemodlist;
1947: int erred = 0;
1948: for (typemodlist = TREE_TYPE (declarator); typemodlist;
1949: typemodlist = TREE_CHAIN (typemodlist))
1950: {
1951: if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
1952: constp++;
1953: else if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
1954: volatilep++;
1955: else if (!erred)
1956: {
1957: erred = 1;
1958: error ("invalid type modifier within pointer declarator");
1959: }
1960: }
1961: if (constp > 1)
1962: warning ("duplicate `const'");
1963: if (volatilep > 1)
1964: warning ("duplicate `volatile'");
1965: }
1966:
1967: declarator = TREE_OPERAND (declarator, 0);
1968: }
1969: else
1970: abort ();
1971:
1972: /* layout_type (type); */
1973:
1974: /* @@ Should perhaps replace the following code by changes in
1975: * @@ stor_layout.c. */
1976: if (TREE_CODE (type) == FUNCTION_DECL)
1977: {
1978: /* A function variable in C should be Pmode rather than EPmode
1979: because it has just the address of a function, no static chain.*/
1980: TYPE_MODE (type) = Pmode;
1981: }
1982: }
1983:
1984: /* Now TYPE has the actual type. */
1985:
1986: /* If this is declaring a typedef name, return a TYPE_DECL. */
1987:
1988: if (specbits & (1 << (int) RID_TYPEDEF))
1989: {
1990: /* Note that the grammar rejects storage classes
1991: in typenames, fields or parameters */
1992: if (constp || volatilep)
1993: type = build_type_variant (type, constp, volatilep);
1994: return build_decl (TYPE_DECL, declarator, type);
1995: }
1996:
1997: /* Detect the case of an array type of unspecified size
1998: which came, as such, direct from a typedef name.
1999: We must copy the type, so that each identifier gets
2000: a distinct type, so that each identifier's size can be
2001: controlled separately by its own initializer. */
2002:
2003: if (type == typedef_type && TREE_CODE (type) == ARRAY_TYPE
2004: && TYPE_DOMAIN (type) == 0)
2005: {
2006: type = build_array_type (TREE_TYPE (type), TYPE_DOMAIN (type));
2007: }
2008:
2009: /* If this is a type name (such as, in a cast or sizeof),
2010: compute the type and return it now. */
2011:
2012: if (decl_context == TYPENAME)
2013: {
2014: /* Note that the grammar rejects storage classes
2015: in typenames, fields or parameters */
2016: if (constp || volatilep)
2017: type = build_type_variant (type, constp, volatilep);
2018: return type;
2019: }
2020:
2021: /* `void' at top level (not within pointer)
2022: is allowed only in typedefs or type names.
2023: We don't complain about parms either, but that is because
2024: a better error message can be made later. */
2025:
2026: if (type == void_type_node && decl_context != PARM)
2027: {
2028: error ("variable or field `%s' declared void",
2029: IDENTIFIER_POINTER (declarator));
2030: type = integer_type_node;
2031: }
2032:
2033: /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
2034: or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
2035:
2036: {
2037: register tree decl;
2038:
2039: if (decl_context == PARM)
2040: {
2041: /* A parameter declared as an array of T is really a pointer to T.
2042: One declared as a function is really a pointer to a function. */
2043:
2044: if (TREE_CODE (type) == ARRAY_TYPE)
2045: {
2046: /* Transfer const-ness of array into that of type pointed to. */
2047: type = build_pointer_type
2048: (build_type_variant (TREE_TYPE (type), constp, volatilep));
2049: volatilep = constp = 0;
2050: }
2051: else if (TREE_CODE (type) == FUNCTION_TYPE)
2052: type = build_pointer_type (type);
2053:
2054: decl = build_decl (PARM_DECL, declarator, type);
2055:
2056: /* Compute the type actually passed in the parmlist,
2057: for the case where there is no prototype.
2058: (For example, shorts and chars are passed as ints.)
2059: When there is a prototype, this is overridden later. */
2060:
2061: DECL_ARG_TYPE (decl) = type;
2062: if (type == float_type_node)
2063: DECL_ARG_TYPE (decl) = double_type_node;
2064: else if (TREE_CODE (type) == INTEGER_TYPE
2065: && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
2066: DECL_ARG_TYPE (decl) = integer_type_node;
2067: }
2068: else if (decl_context == FIELD)
2069: {
2070: /* Structure field. It may not be a function. */
2071:
2072: if (TREE_CODE (type) == FUNCTION_TYPE)
2073: {
2074: error ("field `%s' declared as a function",
2075: IDENTIFIER_POINTER (declarator));
2076: type = build_pointer_type (type);
2077: }
2078: else if (TYPE_SIZE (type) == 0)
2079: {
2080: error ("field `%s' has incomplete type",
2081: IDENTIFIER_POINTER (declarator));
2082: type = error_mark_node;
2083: }
2084: decl = build_decl (FIELD_DECL, declarator, type);
2085: }
2086: else if (TREE_CODE (type) == FUNCTION_TYPE)
2087: {
2088: if (specbits & ((1 << (int) RID_AUTO) | (1 << (int) RID_REGISTER)))
2089: error ("invalid storage class for function `%s'",
2090: IDENTIFIER_POINTER (declarator));
2091: /* Function declaration not at top level.
2092: Storage classes other than `extern' are not allowed
2093: and `extern' makes no difference. */
2094: if (current_binding_level != global_binding_level
2095: && (specbits & ((1 << (int) RID_STATIC) | (1 << (int) RID_INLINE)))
2096: && pedantic)
2097: warning ("invalid storage class for function `%s'",
2098: IDENTIFIER_POINTER (declarator));
2099: decl = build_decl (FUNCTION_DECL, declarator, type);
2100: TREE_EXTERNAL (decl) = 1;
2101: /* Record presence of `static'. */
2102: TREE_PUBLIC (decl) = !(specbits & (1 << (int) RID_STATIC));
2103: /* Record presence of `inline', if it is reasonable. */
2104: if (inlinep)
2105: {
2106: tree last = tree_last (TYPE_ARG_TYPES (type));
2107:
2108: if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
2109: warning ("cannot inline function `main'");
2110: else if (last && TREE_VALUE (last) != void_type_node)
2111: error ("inline declaration ignored for function with `...'");
2112: else
2113: /* Assume that otherwise the function can be inlined. */
2114: TREE_INLINE (decl) = 1;
2115: }
2116: }
2117: else
2118: {
2119: /* It's a variable. */
2120:
2121: decl = build_decl (VAR_DECL, declarator, type);
2122:
2123: if (inlinep)
2124: warning_with_decl (decl, "variable `%s' declared `inline'");
2125:
2126: /* An uninitialized decl with `extern' is a reference. */
2127: TREE_EXTERNAL (decl)
2128: = !initialized && (specbits & (1 << (int) RID_EXTERN));
2129: /* At top level, either `static' or no s.c. makes a definition
2130: (perhaps tentative), and absence of `static' makes it public. */
2131: if (current_binding_level == global_binding_level)
2132: {
2133: TREE_PUBLIC (decl) = !(specbits & (1 << (int) RID_STATIC));
2134: TREE_STATIC (decl) = ! TREE_EXTERNAL (decl);
2135: }
2136: /* Not at top level, only `static' makes a static definition. */
2137: else
2138: {
2139: TREE_STATIC (decl) = (specbits & (1 << (int) RID_STATIC)) != 0;
2140: /* `extern' with initialization is invalid if not at top level. */
2141: if ((specbits & (1 << (int) RID_EXTERN)) && initialized)
2142: error ("`%s' has both `extern' and initializer", name);
2143: }
2144: }
2145:
2146: /* Record `register' declaration for warnings on &
2147: and in case doing stupid register allocation. */
2148:
2149: if (specbits & (1 << (int) RID_REGISTER))
2150: TREE_REGDECL (decl) = 1;
2151:
2152: /* Record constancy and volatility. */
2153:
2154: if (constp)
2155: TREE_READONLY (decl) = 1;
2156: if (volatilep)
2157: {
2158: TREE_VOLATILE (decl) = 1;
2159: TREE_THIS_VOLATILE (decl) = 1;
2160: }
2161:
2162: return decl;
2163: }
2164: }
2165:
2166: /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
2167: MAXVAL should be the maximum value in the domain
2168: (one less than the length of the array). */
2169:
2170: tree
2171: make_index_type (maxval)
2172: tree maxval;
2173: {
2174: register tree itype = make_node (INTEGER_TYPE);
2175: int maxint = TREE_INT_CST_LOW (maxval);
2176: TYPE_PRECISION (itype) = BITS_PER_WORD;
2177: TYPE_MIN_VALUE (itype) = build_int_2 (0, 0);
2178: TREE_TYPE (TYPE_MIN_VALUE (itype)) = itype;
2179: TYPE_MAX_VALUE (itype) = maxval;
2180: TREE_TYPE (maxval) = itype;
2181: TYPE_MODE (itype) = SImode;
2182: TYPE_SIZE (itype) = TYPE_SIZE (long_integer_type_node);
2183: TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (long_integer_type_node);
2184: TYPE_ALIGN (itype) = TYPE_ALIGN (long_integer_type_node);
2185: return type_hash_canon (maxint > 0 ? maxint : - maxint, itype);
2186: }
2187:
2188: /* Decode the parameter-list info for a function type or function definition.
2189: The argument is the value returned by `get_parm_info' (or made in parse.y
2190: if there is an identifier list instead of a parameter decl list).
2191: These two functions are separate because when a function returns
2192: or receives functions then each is called multiple times but the order
2193: of calls is different. The last call to `grokparms' is always the one
2194: that contains the formal parameter names of a function definition.
2195:
2196: Store in `last_function_parms' a chain of the decls of parms.
2197: Also store in `last_function_parm_tags' a chain of the struct and union
2198: tags declared among the parms.
2199:
2200: Return a list of arg types to use in the FUNCTION_TYPE for this function.
2201:
2202: FUNCDEF_FLAG is nonzero for a function definition, 0 for
2203: a mere declaration. A nonempty identifier-list gets an error message
2204: when FUNCDEF_FLAG is zero. */
2205:
2206: static tree
2207: grokparms (parms_info, funcdef_flag)
2208: tree parms_info;
2209: int funcdef_flag;
2210: {
2211: tree first_parm = TREE_CHAIN (parms_info);
2212:
2213: last_function_parms = TREE_PURPOSE (parms_info);
2214: last_function_parm_tags = TREE_VALUE (parms_info);
2215:
2216: if (first_parm != 0
2217: && TREE_CODE (TREE_VALUE (first_parm)) == IDENTIFIER_NODE)
2218: {
2219: if (! funcdef_flag)
2220: warning ("parameter names (without types) in function declaration");
2221:
2222: last_function_parms = first_parm;
2223: return 0;
2224: }
2225: else
2226: {
2227: tree t;
2228: /* In a fcn definition, arg types must be complete. */
2229: if (funcdef_flag)
2230: for (t = last_function_parms; t; t = TREE_CHAIN (t))
2231: {
2232: tree type = TREE_TYPE (t);
2233: if (TYPE_SIZE (type) == 0)
2234: {
2235: error ("parameter `%s' has incomplete type",
2236: IDENTIFIER_POINTER (DECL_NAME (t)));
2237: TREE_TYPE (t) = error_mark_node;
2238: }
2239: }
2240:
2241: return first_parm;
2242: }
2243: }
2244:
2245:
2246: /* Return a tree_list node with info on a parameter list just parsed.
2247: The TREE_PURPOSE is a chain of decls of those parms.
2248: The TREE_VALUE is a list of structure, union and enum tags defined.
2249: The TREE_CHAIN is a list of argument types to go in the FUNCTION_TYPE.
2250: This tree_list node is later fed to `grokparms'.
2251:
2252: VOID_AT_END nonzero means append `void' to the end of the type-list.
2253: Zero means the parmlist ended with an ellipsis so don't append `void'. */
2254:
2255: tree
2256: get_parm_info (void_at_end)
2257: int void_at_end;
2258: {
2259: register tree decl;
2260: register tree types = 0;
2261: tree link;
2262: int erred = 0;
2263: tree tags = gettags ();
2264: tree parms = nreverse (getdecls ());
2265:
2266: /* Just `void' (and no ellipsis) is special. There are really no parms. */
2267: if (void_at_end && parms != 0
2268: && TREE_CHAIN (parms) == 0
2269: && TREE_TYPE (parms) == void_type_node)
2270: {
2271: parms = NULL_TREE;
2272: storedecls (NULL_TREE);
2273: return tree_cons (NULL_TREE, NULL_TREE,
2274: tree_cons (NULL_TREE, void_type_node, NULL_TREE));
2275: }
2276:
2277: storedecls (parms);
2278:
2279: for (decl = parms; decl; decl = TREE_CHAIN (decl))
2280: {
2281: /* Since there is a prototype,
2282: args are passed in their declared types. */
2283: DECL_ARG_TYPE (decl) = TREE_TYPE (decl);
2284:
2285: types = tree_cons (NULL_TREE, TREE_TYPE (decl), types);
2286: if (TREE_VALUE (types) == void_type_node && ! erred)
2287: {
2288: error ("`void' in parameter list must be the entire list");
2289: erred = 1;
2290: }
2291: }
2292:
2293: if (void_at_end)
2294: return tree_cons (parms, tags,
2295: nreverse (tree_cons (NULL_TREE, void_type_node, types)));
2296:
2297: return tree_cons (parms, tags, nreverse (types));
2298: }
2299:
2300: /* Get the struct, enum or union (CODE says which) with tag NAME.
2301: Define the tag as a forward-reference if it is not defined. */
2302:
2303: tree
2304: xref_tag (code, name)
2305: tree name;
2306: {
2307: /* If a cross reference is requested, look up the type
2308: already defined for this tag and return it. */
2309:
2310: register tree ref = lookup_tag (code, name, current_binding_level, 0);
2311: if (ref) return ref;
2312:
2313: /* If no such tag is yet defined, create a forward-reference node
2314: and record it as the "definition".
2315: When a real declaration of this type is found,
2316: the forward-reference will be altered into a real type. */
2317:
2318: ref = make_node (code);
2319: pushtag (name, ref);
2320: return ref;
2321: }
2322:
2323: /* Make sure that the tag NAME is defined *in the current binding level*
2324: at least as a forward reference.
2325: CODE says which kind of tag NAME ought to be. */
2326:
2327: tree
2328: start_struct (code, name)
2329: enum tree_code code;
2330: tree name;
2331: {
2332: /* If there is already a tag defined at this binding level
2333: (as a forward reference), just return it. */
2334:
2335: register tree ref = 0;
2336:
2337: if (name != 0)
2338: ref = lookup_tag (code, name, current_binding_level, 1);
2339: if (ref && TREE_CODE (ref) == code)
2340: {
2341: if (TYPE_FIELDS (ref))
2342: error ((code == UNION_TYPE ? "redefinition of `union %s'"
2343: : "redefinition of `struct %s'"),
2344: IDENTIFIER_POINTER (name));
2345:
2346: return ref;
2347: }
2348:
2349: /* Otherwise create a forward-reference just so the tag is in scope. */
2350:
2351: ref = make_node (code);
2352: pushtag (name, ref);
2353: return ref;
2354: }
2355:
2356: /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
2357: of a structure component, returning a FIELD_DECL node.
2358: WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
2359:
2360: This is done during the parsing of the struct declaration.
2361: The FIELD_DECL nodes are chained together and the lot of them
2362: are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
2363:
2364: tree
2365: grokfield (filename, line, declarator, declspecs, width)
2366: char *filename;
2367: int line;
2368: tree declarator, declspecs, width;
2369: {
2370: register tree value = grokdeclarator (declarator, declspecs, FIELD, 0);
2371:
2372: finish_decl (value, NULL, NULL);
2373: DECL_INITIAL (value) = width;
2374:
2375: return value;
2376: }
2377:
2378: /* Fill in the fields of a RECORD_TYPE or UNION_TYPE node, T.
2379: FIELDLIST is a chain of FIELD_DECL nodes for the fields. */
2380:
2381: tree
2382: finish_struct (t, fieldlist)
2383: register tree t, fieldlist;
2384: {
2385: register tree x;
2386: int old;
2387: int round_up_size = 1;
2388:
2389: /* If this type was previously laid out as a forward reference,
2390: make sure we lay it out again. */
2391:
2392: TYPE_SIZE (t) = 0;
2393:
2394: old = suspend_momentary ();
2395:
2396: if (fieldlist == 0 && pedantic)
2397: warning ((TREE_CODE (t) == UNION_TYPE ? "union has no members"
2398: : "structure has no members"));
2399:
2400: /* Install struct as DECL_CONTEXT of each field decl.
2401: Also process specified field sizes.
2402: Set DECL_SIZE_UNIT to the specified size, or 0 if none specified.
2403: The specified size is found in the DECL_INITIAL.
2404: Store 0 there, except for ": 0" fields (so we can find them
2405: and delete them, below). */
2406:
2407: for (x = fieldlist; x; x = TREE_CHAIN (x))
2408: {
2409: DECL_CONTEXT (x) = t;
2410: DECL_SIZE_UNIT (x) = 0;
2411:
2412: /* If any field is const, the structure type is pseudo-const. */
2413: if (TREE_READONLY (x))
2414: C_TYPE_FIELDS_READONLY (t) = 1;
2415: else
2416: {
2417: /* A field that is pseudo-const makes the structure likewise. */
2418: tree t1 = TREE_TYPE (x);
2419: while (TREE_CODE (t1) == ARRAY_TYPE)
2420: t1 = TREE_TYPE (t1);
2421: if ((TREE_CODE (t1) == RECORD_TYPE || TREE_CODE (t1) == UNION_TYPE)
2422: && C_TYPE_FIELDS_READONLY (t1))
2423: C_TYPE_FIELDS_READONLY (t) = 1;
2424: }
2425:
2426: /* Detect invalid bit-field size. */
2427: if (DECL_INITIAL (x) && TREE_CODE (DECL_INITIAL (x)) != INTEGER_CST)
2428: {
2429: error_with_decl (x, "bit-field `%s' width not an integer constant");
2430: DECL_INITIAL (x) = NULL;
2431: }
2432:
2433: /* Detect invalid bit-field type. */
2434: if (DECL_INITIAL (x)
2435: && TREE_CODE (TREE_TYPE (x)) != INTEGER_TYPE
2436: && TREE_CODE (TREE_TYPE (x)) != ENUMERAL_TYPE)
2437: {
2438: error_with_decl (x, "bit-field `%s' has invalid type");
2439: DECL_INITIAL (x) = NULL;
2440: }
2441: if (DECL_INITIAL (x) && pedantic
2442: && TREE_TYPE (x) != integer_type_node
2443: && TREE_TYPE (x) != unsigned_type_node)
2444: warning_with_decl (x, "bit-field `%s' type invalid in ANSI C");
2445:
2446: /* Detect and ignore out of range field width. */
2447: if (DECL_INITIAL (x))
2448: {
2449: register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
2450:
2451: if (width < 0)
2452: {
2453: DECL_INITIAL (x) = NULL;
2454: warning_with_decl (x, "negative width in bit-field `%s'");
2455: }
2456: else if (width > TYPE_PRECISION (TREE_TYPE (x)))
2457: {
2458: DECL_INITIAL (x) = NULL;
2459: warning_with_decl (x, "width of `%s' exceeds its type");
2460: }
2461: }
2462:
2463: /* Process valid field width. */
2464: if (DECL_INITIAL (x))
2465: {
2466: register int width = TREE_INT_CST_LOW (DECL_INITIAL (x));
2467:
2468: if (width == 0)
2469: {
2470: /* field size 0 => mark following field as "aligned" */
2471: if (TREE_CHAIN (x))
2472: DECL_ALIGN (TREE_CHAIN (x))
2473: = MAX (DECL_ALIGN (TREE_CHAIN (x)), EMPTY_FIELD_BOUNDARY);
2474: /* field of size 0 at the end => round up the size. */
2475: else
2476: round_up_size = EMPTY_FIELD_BOUNDARY;
2477: }
2478: else
2479: {
2480: DECL_INITIAL (x) = NULL;
2481: DECL_SIZE_UNIT (x) = width;
2482: TREE_PACKED (x) = 1;
2483: /* Traditionally a bit field is unsigned
2484: even if declared signed. */
2485: if (flag_traditional
2486: && TREE_CODE (TREE_TYPE (x)) == INTEGER_TYPE)
2487: TREE_TYPE (x) = unsigned_type_node;
2488: }
2489: }
2490: else
2491: /* Non-bit-fields are aligned for their type. */
2492: DECL_ALIGN (x) = MAX (DECL_ALIGN (x), TYPE_ALIGN (TREE_TYPE (x)));
2493: }
2494:
2495: /* Now DECL_INITIAL is null on all members except for zero-width bit-fields.
2496: And they have already done their work. */
2497:
2498: /* Delete all zero-width bit-fields from the front of the fieldlist */
2499: while (fieldlist
2500: && DECL_INITIAL (fieldlist))
2501: fieldlist = TREE_CHAIN (fieldlist);
2502: /* Delete all such members from the rest of the fieldlist */
2503: for (x = fieldlist; x;)
2504: {
2505: if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
2506: TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
2507: else x = TREE_CHAIN (x);
2508: }
2509:
2510: /* Delete all duplicate fields from the fieldlist */
2511: for (x = fieldlist; x && TREE_CHAIN (x);)
2512: /* Anonymous fields aren't duplicates. */
2513: if (DECL_NAME (TREE_CHAIN (x)) == 0)
2514: x = TREE_CHAIN (x);
2515: else
2516: {
2517: register tree y = fieldlist;
2518:
2519: while (1)
2520: {
2521: if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
2522: break;
2523: if (y == x)
2524: break;
2525: y = TREE_CHAIN (y);
2526: }
2527: if (DECL_NAME (y) == DECL_NAME (TREE_CHAIN (x)))
2528: {
2529: error_with_decl (TREE_CHAIN (x), "duplicate member `%s'");
2530: TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
2531: }
2532: else x = TREE_CHAIN (x);
2533: }
2534:
2535: /* Now we have the final fieldlist. Record it,
2536: then lay out the structure or union (including the fields). */
2537:
2538: TYPE_FIELDS (t) = fieldlist;
2539:
2540: /* If there's a :0 field at the end, round the size to the
2541: EMPTY_FIELD_BOUNDARY. */
2542: TYPE_ALIGN (t) = round_up_size;
2543:
2544: layout_type (t);
2545:
2546: /* Promote each bit-field's type to int if it is narrower than that. */
2547: for (x = fieldlist; x; x = TREE_CHAIN (x))
2548: if (TREE_PACKED (x)
2549: && TREE_CODE (TREE_TYPE (x)) == INTEGER_TYPE
2550: && (TREE_INT_CST_LOW (DECL_SIZE (x)) * DECL_SIZE_UNIT (x)
2551: < TYPE_PRECISION (integer_type_node)))
2552: TREE_TYPE (x) = integer_type_node;
2553:
2554: /* If this structure or union completes the type of any previous
2555: variable declaration, lay it out and output its rtl. */
2556:
2557: if (current_binding_level->n_incomplete != 0)
2558: {
2559: tree decl;
2560: for (decl = current_binding_level->names; decl; decl = TREE_CHAIN (decl))
2561: if (TREE_TYPE (decl) == t
2562: && TREE_CODE (decl) != TYPE_DECL)
2563: {
2564: int toplevel = global_binding_level == current_binding_level;
2565: layout_decl (decl);
2566: rest_of_decl_compilation (decl, 0, toplevel, 0);
2567: if (! toplevel)
2568: expand_decl (decl);
2569: --current_binding_level->n_incomplete;
2570: }
2571: }
2572:
2573: resume_momentary (old);
2574:
2575: return t;
2576: }
2577:
2578: /* Begin compiling the definition of an enumeration type.
2579: NAME is its name (or null if anonymous).
2580: Returns the type object, as yet incomplete.
2581: Also records info about it so that build_enumerator
2582: may be used to declare the individual values as they are read. */
2583:
2584: tree
2585: start_enum (name)
2586: tree name;
2587: {
2588: register tree enumtype = 0;
2589:
2590: /* If this is the real definition for a previous forward reference,
2591: fill in the contents in the same object that used to be the
2592: forward reference. */
2593:
2594: if (name != 0)
2595: enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
2596:
2597: if (enumtype == 0 || TREE_CODE (enumtype) != ENUMERAL_TYPE)
2598: {
2599: enumtype = make_node (ENUMERAL_TYPE);
2600: pushtag (name, enumtype);
2601: }
2602:
2603: if (TYPE_VALUES (enumtype) != 0)
2604: {
2605: /* This enum is a named one that has been declared already. */
2606: error ("redeclaration of `enum %s'", IDENTIFIER_POINTER (name));
2607:
2608: /* Completely replace its old definition.
2609: The old enumerators remain defined, however. */
2610: TYPE_VALUES (enumtype) = 0;
2611: }
2612:
2613: /* Initially, set up this enum as like `int'
2614: so that we can create the enumerators' declarations and values.
2615: Later on, the precision of the type may be changed and
2616: it may be layed out again. */
2617:
2618: TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
2619: TYPE_SIZE (enumtype) = 0;
2620: fixup_unsigned_type (enumtype);
2621:
2622: enum_next_value = integer_zero_node;
2623:
2624: return enumtype;
2625: }
2626:
2627: /* After processing and defining all the values of an enumeration type,
2628: install their decls in the enumeration type and finish it off.
2629: ENUMTYPE is the type object and VALUES a list of name-value pairs.
2630: Returns ENUMTYPE. */
2631:
2632: tree
2633: finish_enum (enumtype, values)
2634: register tree enumtype, values;
2635: {
2636: register tree pair = values;
2637: register long maxvalue = 0;
2638: register int i;
2639:
2640: TYPE_VALUES (enumtype) = values;
2641:
2642: /* Calculate the maximum value of any enumerator in this type. */
2643:
2644: for (pair = values; pair; pair = TREE_CHAIN (pair))
2645: {
2646: int value = TREE_INT_CST_LOW (TREE_VALUE (pair));
2647: if (value > maxvalue)
2648: maxvalue = value;
2649: }
2650:
2651: #if 0
2652: /* Determine the precision this type needs, lay it out, and define it. */
2653:
2654: for (i = maxvalue; i; i >>= 1)
2655: TYPE_PRECISION (enumtype)++;
2656:
2657: if (!TYPE_PRECISION (enumtype))
2658: TYPE_PRECISION (enumtype) = 1;
2659:
2660: /* Cancel the laying out previously done for the enum type,
2661: so that fixup_unsigned_type will do it over. */
2662: TYPE_SIZE (enumtype) = 0;
2663:
2664: fixup_unsigned_type (enumtype);
2665: #endif
2666:
2667: TREE_INT_CST_LOW (TYPE_MAX_VALUE (enumtype)) = maxvalue;
2668:
2669: return enumtype;
2670: }
2671:
2672: /* Build and install a CONST_DECL for one value of the
2673: current enumeration type (one that was begun with start_enum).
2674: Return a tree-list containing the name and its value.
2675: Assignment of sequential values by default is handled here. */
2676:
2677: tree
2678: build_enumerator (name, value)
2679: tree name, value;
2680: {
2681: register tree decl;
2682:
2683: /* Validate and default VALUE. */
2684:
2685: if (value != 0 && TREE_CODE (value) != INTEGER_CST)
2686: {
2687: error ("enumerator value for `%s' not integer constant",
2688: IDENTIFIER_POINTER (name));
2689: value = 0;
2690: }
2691:
2692: /* Default based on previous value. */
2693: if (value == 0)
2694: value = enum_next_value;
2695:
2696: /* Set basis for default for next value. */
2697: enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
2698: integer_one_node);
2699:
2700: /* Now create a declaration for the enum value name. */
2701:
2702: decl = build_decl (CONST_DECL, name, integer_type_node);
2703: DECL_INITIAL (decl) = value;
2704: TREE_TYPE (value) = integer_type_node;
2705: pushdecl (decl);
2706:
2707: return build_tree_list (name, value);
2708: }
2709:
2710: /* Create the FUNCTION_DECL for a function definition.
2711: LINE1 is the line number that the definition absolutely begins on.
2712: LINE2 is the line number that the name of the function appears on.
2713: DECLSPECS and DECLARATOR are the parts of the declaration;
2714: they describe the function's name and the type it returns,
2715: but twisted together in a fashion that parallels the syntax of C.
2716:
2717: This function creates a binding context for the function body
2718: as well as setting up the FUNCTION_DECL in current_function_decl.
2719:
2720: Returns 1 on success. If the DECLARATOR is not suitable for a function
2721: (it defines a datum instead), we return 0, which tells
2722: yyparse to report a parse error. */
2723:
2724: int
2725: start_function (declspecs, declarator)
2726: tree declarator, declspecs;
2727: {
2728: tree decl1, old_decl;
2729: tree restype;
2730:
2731: current_function_returns_value = 0; /* Assume, until we see it does. */
2732: current_function_returns_null = 0;
2733: warn_about_return_type = 0;
2734:
2735: decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1);
2736:
2737: /* If the declarator is not suitable for a function definition,
2738: cause a syntax error. */
2739: if (decl1 == 0)
2740: return 0;
2741:
2742: current_function_decl = decl1;
2743:
2744: announce_function (current_function_decl);
2745:
2746: if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (decl1))) == 0)
2747: {
2748: error ("return-type is an incomplete type");
2749: /* Make it return void instead. */
2750: TREE_TYPE (decl1)
2751: = build_function_type (void_type_node,
2752: TYPE_ARG_TYPES (TREE_TYPE (decl1)));
2753: }
2754:
2755: if (warn_about_return_type)
2756: warning ("return-type defaults to `int'");
2757:
2758: /* Save the parm names or decls from this function's declarator
2759: where store_parm_decls will find them. */
2760: current_function_parms = last_function_parms;
2761: current_function_parm_tags = last_function_parm_tags;
2762:
2763: /* Make the init_value nonzero so pushdecl knows this is not tentative.
2764: error_mark_node is replaced below (in poplevel) with the LET_STMT. */
2765: DECL_INITIAL (current_function_decl) = error_mark_node;
2766:
2767: /* If this definition isn't a prototype and we had a prototype declaration
2768: before, copy the arg type info from that prototype. */
2769: old_decl = lookup_name_current_level (DECL_NAME (current_function_decl));
2770: if (old_decl != 0
2771: && TREE_TYPE (TREE_TYPE (current_function_decl)) == TREE_TYPE (TREE_TYPE (old_decl))
2772: && TYPE_ARG_TYPES (TREE_TYPE (current_function_decl)) == 0)
2773: TREE_TYPE (current_function_decl) = TREE_TYPE (old_decl);
2774:
2775: /* This is a definition, not a reference. */
2776: TREE_EXTERNAL (current_function_decl) = 0;
2777: /* This function exists in static storage.
2778: (This does not mean `static' in the C sense!) */
2779: TREE_STATIC (current_function_decl) = 1;
2780:
2781: /* Record the decl so that the function name is defined.
2782: If we already have a decl for this name, and it is a FUNCTION_DECL,
2783: use the old decl. */
2784:
2785: current_function_decl = pushdecl (current_function_decl);
2786:
2787: pushlevel (0);
2788: current_binding_level->parm_flag = 1;
2789:
2790: make_function_rtl (current_function_decl);
2791:
2792: /* Allocate further tree nodes temporarily during compilation
2793: of this function only. */
2794: temporary_allocation ();
2795:
2796: restype = TREE_TYPE (TREE_TYPE (current_function_decl));
2797: /* Promote the value to int before returning it. */
2798: if (TREE_CODE (restype) == INTEGER_TYPE
2799: && TYPE_PRECISION (restype) < TYPE_PRECISION (integer_type_node))
2800: restype = integer_type_node;
2801: DECL_RESULT (current_function_decl)
2802: = build_decl (RESULT_DECL, value_identifier, restype);
2803:
2804: /* Make the FUNCTION_DECL's contents appear in a local tree dump
2805: and make the FUNCTION_DECL itself not appear in the permanent dump. */
2806:
2807: TREE_PERMANENT (current_function_decl) = 0;
2808:
2809: return 1;
2810: }
2811:
2812: /* Store the parameter declarations into the current function declaration.
2813: This is called after parsing the parameter declarations, before
2814: digesting the body of the function. */
2815:
2816: void
2817: store_parm_decls ()
2818: {
2819: register tree fndecl = current_function_decl;
2820: register tree parm;
2821:
2822: /* This is either a chain of PARM_DECLs (if a prototype was used)
2823: or a list of IDENTIFIER_NODEs (for an old-fashioned C definition). */
2824: tree specparms = current_function_parms;
2825:
2826: /* This is a list of types declared among parms in a prototype. */
2827: tree parmtags = current_function_parm_tags;
2828:
2829: /* This is a chain of PARM_DECLs from old-style parm declarations. */
2830: register tree parmdecls = getdecls ();
2831:
2832: /* This is a chain of any other decls that came in among the parm
2833: declarations. If a parm is declared with enum {foo, bar} x;
2834: then CONST_DECLs for foo and bar are put here. */
2835: tree nonparms = 0;
2836:
2837: if (specparms != 0 && TREE_CODE (specparms) == PARM_DECL)
2838: {
2839: /* This case is when the function was defined with an ANSI prototype.
2840: The parms already have decls, so we need not do anything here
2841: except record them as in effect
2842: and complain if any redundant old-style parm decls were written. */
2843:
2844: register tree next;
2845:
2846: if (parmdecls != 0)
2847: error_with_decl (fndecl,
2848: "parm types given both in parmlist and separately");
2849:
2850: for (parm = nreverse (specparms); parm; parm = next)
2851: {
2852: next = TREE_CHAIN (parm);
2853: if (DECL_NAME (parm) == 0)
2854: error_with_decl (parm, "parameter name omitted");
2855: else if (TREE_TYPE (parm) == void_type_node)
2856: error_with_decl (parm, "parameter `%s' declared void");
2857: else
2858: pushdecl (parm);
2859: }
2860:
2861: /* Get the decls in their original chain order
2862: and record in the function. */
2863: DECL_ARGUMENTS (fndecl) = getdecls ();
2864:
2865: storetags (chainon (parmtags, gettags ()));
2866: }
2867: else
2868: {
2869: /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
2870: each with a parm name as the TREE_VALUE.
2871:
2872: PARMDECLS is a list of declarations for parameters.
2873: Warning! It can also contain CONST_DECLs which are not parameters
2874: but are names of enumerators of any enum types
2875: declared among the parameters.
2876:
2877: First match each formal parameter name with its declaration.
2878: Associate decls with the names and store the decls
2879: into the TREE_PURPOSE slots. */
2880:
2881: for (parm = specparms; parm; parm = TREE_CHAIN (parm))
2882: {
2883: register tree tail, found = NULL;
2884:
2885: if (TREE_VALUE (parm) == 0)
2886: {
2887: error_with_decl (fndecl, "parameter name missing from parameter list");
2888: TREE_PURPOSE (parm) = 0;
2889: continue;
2890: }
2891:
2892: /* See if any of the parmdecls specifies this parm by name.
2893: Ignore any enumerator decls. */
2894: for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
2895: if (DECL_NAME (tail) == TREE_VALUE (parm)
2896: && TREE_CODE (tail) == PARM_DECL)
2897: {
2898: found = tail;
2899: break;
2900: }
2901:
2902: /* If declaration already marked, we have a duplicate name.
2903: Complain, and don't use this decl twice. */
2904: if (found && DECL_CONTEXT (found) != 0)
2905: {
2906: error_with_decl (found, "multiple parameters named `%s'");
2907: found = 0;
2908: }
2909:
2910: /* If the declaration says "void", complain and ignore it. */
2911: if (found && TREE_TYPE (found) == void_type_node)
2912: {
2913: error_with_decl (found, "parameter `%s' declared void");
2914: TREE_TYPE (found) = integer_type_node;
2915: DECL_ARG_TYPE (found) = integer_type_node;
2916: layout_decl (found, 0);
2917: }
2918:
2919: /* If no declaration found, default to int. */
2920: if (!found)
2921: {
2922: found = build_decl (PARM_DECL, TREE_VALUE (parm),
2923: integer_type_node);
2924: DECL_ARG_TYPE (found) = TREE_TYPE (found);
2925: DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
2926: DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
2927: pushdecl (found);
2928: }
2929:
2930: TREE_PURPOSE (parm) = found;
2931:
2932: /* Mark this decl as "already found" -- see test, above.
2933: It is safe to clobber DECL_CONTEXT temporarily
2934: because the final values are not stored until
2935: the `poplevel' in `finish_function'. */
2936: DECL_CONTEXT (found) = error_mark_node;
2937: }
2938:
2939: /* Complain about declarations not matched with any names.
2940: Put any enumerator constants onto the list NONPARMS. */
2941:
2942: nonparms = 0;
2943: for (parm = parmdecls; parm; )
2944: {
2945: tree next = TREE_CHAIN (parm);
2946: TREE_CHAIN (parm) = 0;
2947:
2948: /* Complain about args with incomplete types. */
2949: if (TYPE_SIZE (TREE_TYPE (parm)) == 0)
2950: {
2951: error_with_decl (parm, "parameter `%s' has incomplete type");
2952: TREE_TYPE (parm) = error_mark_node;
2953: }
2954:
2955: if (TREE_CODE (parm) != PARM_DECL)
2956: nonparms = chainon (nonparms, parm);
2957:
2958: else if (DECL_CONTEXT (parm) == 0)
2959: {
2960: error_with_decl (parm,
2961: "declaration for parameter `%s' but no such parameter");
2962: /* Pretend the parameter was not missing.
2963: This gets us to a standard state and minimizes
2964: further error messages. */
2965: specparms
2966: = chainon (specparms,
2967: tree_cons (parm, NULL_TREE, NULL_TREE));
2968: }
2969:
2970: parm = next;
2971: }
2972:
2973: /* Chain the declarations together in the order of the list of names. */
2974: /* Store that chain in the function decl, replacing the list of names. */
2975: parm = specparms;
2976: DECL_ARGUMENTS (fndecl) = 0;
2977: {
2978: register tree last;
2979: for (last = 0; parm; parm = TREE_CHAIN (parm))
2980: if (TREE_PURPOSE (parm))
2981: {
2982: if (last == 0)
2983: DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
2984: else
2985: TREE_CHAIN (last) = TREE_PURPOSE (parm);
2986: last = TREE_PURPOSE (parm);
2987: TREE_CHAIN (last) = 0;
2988: DECL_CONTEXT (last) = 0;
2989: }
2990: }
2991:
2992: /* If there was a previous prototype,
2993: set the DECL_ARG_TYPE of each argument according to
2994: the type previously specified, and report any mismatches. */
2995:
2996: if (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
2997: {
2998: register tree type;
2999: for (parm = DECL_ARGUMENTS (fndecl),
3000: type = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
3001: parm || (type && TREE_VALUE (type) != void_type_node);
3002: parm = TREE_CHAIN (parm), type = TREE_CHAIN (type))
3003: {
3004: if (parm == 0 || type == 0
3005: || TREE_VALUE (type) == void_type_node)
3006: {
3007: error ("argument decls of `%s' don't match prototype",
3008: IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3009: break;
3010: }
3011: /* Type for passing arg must be consistent
3012: with that declared for the arg. */
3013: if (! comptypes (DECL_ARG_TYPE (parm), TREE_VALUE (type)))
3014: error ("argument `%s' doesn't match function prototype",
3015: IDENTIFIER_POINTER (DECL_NAME (parm)));
3016: }
3017: }
3018: }
3019:
3020: /* Now store the final chain of decls for the arguments
3021: as the decl-chain of the current lexical scope.
3022: Put the enumerators in as well, at the front so that
3023: DECL_ARGUMENTS is not modified. */
3024:
3025: storedecls (chainon (nonparms, DECL_ARGUMENTS (fndecl)));
3026:
3027: /* Initialize the RTL code for the function. */
3028:
3029: expand_function_start (fndecl);
3030: }
3031:
3032: /* Finish up a function declaration and compile that function
3033: all the way to assembler language output. The free the storage
3034: for the function definition.
3035:
3036: This is called after parsing the body of the function definition.
3037: STMTS is the chain of statements that makes up the function body. */
3038:
3039: void
3040: finish_function ()
3041: {
3042: register tree fndecl = current_function_decl;
3043:
3044: /* TREE_READONLY (fndecl) = 1;
3045: This caused &foo to be of type ptr-to-const-function
3046: which then got a warning when stored in a ptr-to-function variable. */
3047:
3048: poplevel (1, 0, 1);
3049:
3050: /* Must mark the RESULT_DECL as being in this function. */
3051:
3052: DECL_CONTEXT (DECL_RESULT (fndecl)) = DECL_INITIAL (fndecl);
3053:
3054: /* Generate rtl for function exit. */
3055: expand_function_end ();
3056:
3057: if (warn_return_type)
3058: /* So we can tell if jump_optimize sets it to 1. */
3059: current_function_returns_null = 0;
3060:
3061: /* Run the optimizers and output the assembler code for this function. */
3062: rest_of_compilation (fndecl);
3063:
3064: if (warn_return_type && current_function_returns_null
3065: && TREE_TYPE (TREE_TYPE (fndecl)) != void_type_node)
3066: /* If this function returns non-void and control can drop through,
3067: complain. */
3068: warning ("control reaches end of non-void function");
3069: /* With just -W, complain only if function returns both with
3070: and without a value. */
3071: else if (extra_warnings
3072: && current_function_returns_value && current_function_returns_null)
3073: warning ("this function may return with or without a value");
3074:
3075: /* Free all the tree nodes making up this function. */
3076: /* Switch back to allocating nodes permanently
3077: until we start another function. */
3078: permanent_allocation ();
3079:
3080: if (DECL_SAVED_INSNS (fndecl) == 0)
3081: {
3082: /* Stop pointing to the local nodes about to be freed. */
3083: /* But DECL_INITIAL must remain nonzero so we know this
3084: was an actual function definition. */
3085: DECL_INITIAL (fndecl) = error_mark_node;
3086: DECL_ARGUMENTS (fndecl) = 0;
3087: DECL_RESULT (fndecl) = 0;
3088: }
3089:
3090: /* Let the error reporting routines know that we're outside a function. */
3091: current_function_decl = NULL;
3092: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.