![[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 [GCC 1.x] / gcc|
Return to decl.c CVS log | Up to [GCC 1.x] / gcc |
1.1 root 1: /* Process declarations and variables for C compiler.
2: Copyright (C) 1987 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 "parse.h"
31: #include "tree.h"
32: #include "c-tree.h"
33:
34: /* In grokdeclarator, distinguish syntactic contexts of declarators. */
35: enum decl_context
36: { NORMAL, /* Ordinary declaration */
37: PARM, /* Declaration of parm before function body */
38: FIELD, /* Declaration inside struct or union */
39: TYPENAME}; /* Typename (inside cast or sizeof) */
40:
41: #define NULL 0
42: #define min(X,Y) ((X) < (Y) ? (X) : (Y))
43:
44: static tree grokparms (), grokdeclarator ();
45: static tree make_index_type ();
46: static void builtin_function ();
47:
48: static tree lookup_labelname ();
49: static tree lookup_tag ();
50: static tree lookup_name_current_level ();
51:
52: /* a node which has tree code ERROR_MARK, and whose type is itself.
53: All erroneous expressions are replaced with this node. All functions
54: that accept nodes as arguments should avoid generating error messages
55: if this node is one of the arguments, since it is undesirable to get
56: multiple error messages from one error in the input. */
57:
58: tree error_mark_node;
59:
60: /* INTEGER_TYPE and REAL_TYPE nodes for the standard data types */
61:
62: tree short_integer_type_node;
63: tree integer_type_node;
64: tree long_integer_type_node;
65:
66: tree short_unsigned_type_node;
67: tree unsigned_type_node;
68: tree long_unsigned_type_node;
69:
70: tree unsigned_char_type_node;
71: tree char_type_node;
72:
73: tree float_type_node;
74: tree double_type_node;
75: tree long_double_type_node;
76:
77: /* a VOID_TYPE node. */
78:
79: tree void_type_node;
80:
81: /* A node for type `void *'. */
82:
83: tree ptr_type_node;
84:
85: /* A node for type `char *'. */
86:
87: tree string_type_node;
88:
89: /* Type `char[256]' or something like it.
90: Used when an array of char is needed and the size is irrelevant. */
91:
92: tree char_array_type_node;
93:
94: /* type `int ()' -- used for implicit declaration of functions. */
95:
96: tree default_function_type;
97:
98: /* function types `double (double)' and `double (double, double)', etc. */
99:
100: tree double_ftype_double, double_ftype_double_double;
101: tree int_ftype_int, long_ftype_long;
102:
103: /* Function type `void (void *, void *, int)' and similar ones */
104:
105: tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int, void_ftype_ptr_int_int;
106:
107: /* Two expressions that are constants with value zero.
108: The first is of type `int', the second of type `void *'. */
109:
110: tree integer_zero_node;
111: tree null_pointer_node;
112:
113: /* A node for the integer constant 1. */
114:
115: tree integer_one_node;
116:
117: /* An identifier whose name is <value>. This is used as the "name"
118: of the RESULT_DECLs for values of functions. */
119:
120: tree value_identifier;
121:
122: /* Enumeration type currently being built, or 0 if not doing that now. */
123:
124: tree current_enum_type;
125:
126: /* Default value for next enumerator of enumeration type currently being read,
127: or undefined at other times. */
128:
129: int enum_next_value;
130:
131: /* Parsing a function declarator leaves a list of parameter names here.
132: If the declarator is the beginning of a function definition,
133: the names are stored into the function declaration when it is created. */
134:
135: static tree last_function_parm_names;
136:
137: /* A list (chain of TREE_LIST nodes) of all LABEL_STMTs in the function
138: that have names. Here so we can clear out their names' definitions
139: at the end of the function. */
140:
141: static tree named_labels;
142:
143: /* A list of all GOTO_STMT nodes in the current function,
144: so we can fill in the LABEL_STMTs they go to once all are defined. */
145:
146: static tree all_gotos;
147:
148: /* Set to 0 at beginning of a function definition, set to 1 if
149: a return statement that specifies a return value is seen. */
150:
151: int current_function_returns_value;
152:
153: /* For each binding contour we allocate a binding_level structure
154: * which records the names defined in that contour.
155: * Contours include:
156: * 0) the global one
157: * 1) one for each function definition,
158: * where internal declarations of the parameters appear.
159: * 2) one for each compound statement,
160: * to record its declarations.
161: *
162: * The current meaning of a name can be found by searching the levels from
163: * the current one out to the global one.
164: */
165:
166: /* Note that the information in the `names' component of the global contour
167: is duplicated in the IDENTIFIER_GLOBAL_VALUEs of all identifiers. */
168:
169: static struct binding_level
170: {
171: /* A chain of _DECL nodes for all variables, constants, functions,
172: and typedef types. These are in the reverse of the order supplied.
173: */
174: tree names;
175:
176: /* A list of structure, union and enum definitions,
177: * for looking up tag names.
178: * It is a chain of TREE_LIST nodes, each of whose TREE_PURPOSE is a name,
179: * or NULL_TREE; and whose TREE_VALUE is a RECORD_TYPE, UNION_TYPE,
180: * or ENUMERAL_TYPE node.
181: */
182: tree tags;
183:
184: /* For each level, a list of shadowed outer-level local definitions
185: to be restored when this level is popped.
186: Each link is a TREE_LIST whose TREE_PURPOSE is an identifier and
187: whose TREE_VALUE is its old definition (a kind of ..._DECL node). */
188: tree shadowed;
189:
190: /* The binding level which this one is contained in (inherits from). */
191: struct binding_level *level_chain;
192: };
193:
194: #define NULL_BINDING_LEVEL (struct binding_level *) NULL
195:
196: /* The binding level currently in effect. */
197:
198: static struct binding_level *current_binding_level;
199:
200: /* A chain of binding_level structures awaiting reuse. */
201:
202: static struct binding_level *free_binding_level;
203:
204: /* The outermost binding level, for names of file scope.
205: This is created when the compiler is started and exists
206: through the entire run. */
207:
208: static struct binding_level *global_binding_level;
209:
210: /* Binding level structures are initialized by copying this one. */
211:
212: static struct binding_level clear_binding_level =
213: {NULL, NULL, NULL, NULL};
214:
215: /* Create a new `struct binding_level'. */
216:
217: static
218: struct binding_level *
219: make_binding_level ()
220: {
221: /* NOSTRICT */
222: return (struct binding_level *) xmalloc (sizeof (struct binding_level));
223: }
224:
225: /* Enter a new binding level. */
226:
227: void
228: pushlevel ()
229: {
230: register struct binding_level *newlevel = NULL_BINDING_LEVEL;
231:
232: /* If this is the top level of a function,
233: just make sure that ALL_GOTOS and NAMED_LABELS are 0.
234: They should have been set to 0 at the end of the previous function. */
235:
236: if (current_binding_level == global_binding_level)
237: {
238: if (all_gotos || named_labels)
239: abort ();
240: }
241:
242: /* Reuse or create a struct for this binding level. */
243:
244: if (free_binding_level)
245: {
246: newlevel = free_binding_level;
247: free_binding_level = free_binding_level->level_chain;
248: }
249: else
250: {
251: newlevel = make_binding_level ();
252: }
253:
254: /* Add this level to the front of the chain (stack) of levels that
255: are active. */
256:
257: *newlevel = clear_binding_level;
258: newlevel->level_chain = current_binding_level;
259: current_binding_level = newlevel;
260: }
261:
262: /* Exit a binding level. */
263:
264: void
265: poplevel ()
266: {
267: register tree link;
268:
269: /* Clear out the meanings of the local variables of this level. */
270:
271: for (link = current_binding_level->names; link; link = TREE_CHAIN (link))
272: IDENTIFIER_LOCAL_VALUE (DECL_NAME (link)) = 0;
273:
274: /* Restore all name-meanings of the outer levels
275: that were shadowed by this level. */
276:
277: for (link = current_binding_level->shadowed; link; link = TREE_CHAIN (link))
278: IDENTIFIER_LOCAL_VALUE (TREE_PURPOSE (link)) = TREE_VALUE (link);
279:
280: /* If the level being exited is the top level of a function,
281: match all goto statements with their labels. */
282:
283: if (current_binding_level->level_chain == global_binding_level)
284: {
285: /* Search for labels for any unresolved gotos. */
286:
287: for (link = all_gotos; link; link = TREE_CHAIN (link))
288: {
289: register tree stmt = TREE_VALUE (link);
290: register tree label = lookup_labelname (STMT_BODY (stmt));
291:
292: if (label)
293: STMT_BODY (stmt) = label;
294: else
295: {
296: yylineerror (STMT_SOURCE_LINE (stmt),
297: "no label %s visible for goto",
298: IDENTIFIER_POINTER (STMT_BODY (stmt)));
299: STMT_BODY (stmt) = NULL_TREE;
300: }
301: }
302:
303: /* Then clear out the definitions of all label names,
304: since their scopes end here. */
305:
306: for (link = named_labels; link; link = TREE_CHAIN (link))
307: IDENTIFIER_LABEL_VALUE (DECL_NAME (STMT_BODY (TREE_VALUE (link)))) = 0;
308:
309: named_labels = 0;
310: all_gotos = 0;
311: }
312:
313: /* Pop the current level, and free the structure for reuse. */
314:
315: {
316: register struct binding_level *level = current_binding_level;
317: current_binding_level = current_binding_level->level_chain;
318:
319: level->level_chain = free_binding_level;
320: free_binding_level = level;
321: }
322: }
323:
324: /* Push a definition of struct, union or enum tag "name".
325: "type" should be the type node.
326: Note that the definition may really be just a forward reference.
327: In that case, the TYPE_SIZE will be zero. */
328:
329: void
330: pushtag (name, type)
331: tree name, type;
332: {
333: register tree t;
334:
335: /* If the type has a name, check for duplicate definitions of the name. */
336:
337: if (name)
338: {
339: for (t = current_binding_level->tags; t; t = TREE_CHAIN (t))
340: if (TREE_PURPOSE (t) == name)
341: {
342: yyerror ("redeclaration of struct, union or enum tag %s",
343: IDENTIFIER_POINTER (name));
344: return;
345: }
346:
347: /* Record the identifier as the type's name if it has none. */
348:
349: if (TYPE_NAME (type) == 0)
350: TYPE_NAME (type) = name;
351: }
352:
353: current_binding_level->tags
354: = tree_cons (name, type, current_binding_level->tags);
355: }
356:
357:
358: /* Handle when a new declaration X has the same name as an old one T
359: in the same binding contour.
360: May alter the old decl to say what the new one says.
361:
362: Returns the old decl T if the two are more or less compatible;
363: returns the new one X if they are thoroughly alien. */
364:
365: static tree
366: duplicate_decls (x, t)
367: register tree x, t;
368: {
369: /* At top level in file, if the old definition is "tentative" and
370: this one is close enough, no error. */
371: if (! allowed_redeclaration (x, t,
372: current_binding_level == global_binding_level))
373: yylineerror (DECL_SOURCE_LINE (x), "redeclaration of %s",
374: IDENTIFIER_POINTER (DECL_NAME (x)));
375:
376: /* Install latest semantics. */
377: if (TREE_CODE (t) == TREE_CODE (x))
378: {
379: bcopy ((char *) x + sizeof (struct tree_shared),
380: (char *) t + sizeof (struct tree_shared),
381: sizeof (struct tree_decl) - sizeof (struct tree_shared));
382: TREE_TYPE (t) = TREE_TYPE (x);
383: DECL_ARGUMENTS (t) = DECL_ARGUMENTS (x);
384: DECL_RESULT (t) = DECL_RESULT (x);
385: DECL_SOURCE_FILE (t) = DECL_SOURCE_FILE (x);
386: DECL_SOURCE_LINE (t) = DECL_SOURCE_LINE (x);
387: TREE_STATIC (t) = TREE_STATIC (x);
388: TREE_EXTERNAL (t) = TREE_EXTERNAL (x);
389: TREE_PUBLIC (t) = TREE_PUBLIC (x);
390: if (DECL_INITIAL (x))
391: DECL_INITIAL (t) = DECL_INITIAL (x);
392: return t;
393: }
394: return x;
395: }
396:
397: /* Record a decl-node X as belonging to the current lexical scope.
398: Check for errors (such as an incompatible declaration for the same
399: name already seen in the same scope).
400:
401: Returns either X or an old decl for the same name.
402: If an old decl is returned, it has been smashed
403: to agree with what X says. */
404:
405: tree
406: pushdecl (x)
407: tree x;
408: {
409: register tree t;
410: register tree name = DECL_NAME (x);
411:
412: if (name)
413: {
414: t = lookup_name_current_level (name);
415: if (t)
416: return duplicate_decls (x, t);
417:
418: /* If declaring a type as a typedef, and the type has no known
419: typedef name, install this TYPE_DECL as its typedef name. */
420: if (TREE_CODE (x) == TYPE_DECL)
421: if (TYPE_NAME (TREE_TYPE (x)) == 0
422: || TREE_CODE (TYPE_NAME (TREE_TYPE (x))) != TYPE_DECL)
423: TYPE_NAME (TREE_TYPE (x)) = x;
424: }
425:
426: /* This name is new.
427: Install the new declaration and return it. */
428: if (current_binding_level == global_binding_level)
429: {
430: IDENTIFIER_GLOBAL_VALUE (name) = x;
431: }
432: else
433: {
434: /* If storing a local value, there may already be one (inherited).
435: If so, record it for restoration when this binding level ends. */
436: if (IDENTIFIER_LOCAL_VALUE (name))
437: current_binding_level->shadowed
438: = tree_cons (name, IDENTIFIER_LOCAL_VALUE (name),
439: current_binding_level->shadowed);
440: IDENTIFIER_LOCAL_VALUE (name) = x;
441: }
442:
443: /* Put decls on list in reverse order.
444: We will reverse them later if necessary. */
445: current_binding_level->names = chainon (x, current_binding_level->names);
446:
447: return x;
448: }
449:
450: /* Record a C label name. X is a LABEL_STMT and its STMT_BODY is a LABEL_DECL.
451: That is where we find the name. */
452:
453: void
454: pushlabel (x)
455: tree x;
456: {
457: register tree decl = STMT_BODY (x);
458:
459: if (0 == DECL_NAME (decl))
460: return;
461:
462: if (IDENTIFIER_LABEL_VALUE (DECL_NAME (decl)))
463: yyerror ("duplicate label %s",
464: IDENTIFIER_POINTER (DECL_NAME (decl)));
465: else
466: IDENTIFIER_LABEL_VALUE (DECL_NAME (decl)) = decl;
467:
468: named_labels
469: = tree_cons (NULL_TREE, x, named_labels);
470: }
471:
472: /* Record the goto statement X on the list of all gotos in the
473: current function. The list is used to find them all at
474: the end of the function so that their target labels can be found then. */
475:
476: void
477: pushgoto (x)
478: tree x;
479: {
480: all_gotos = tree_cons (NULL_TREE, x, all_gotos);
481: }
482:
483: /* Return the list of declarations of the current level.
484: They are pushed on the list in reverse order since that is easiest.
485: We reverse them to the correct order here. */
486:
487: tree
488: getdecls ()
489: {
490: return
491: current_binding_level->names = nreverse (current_binding_level->names);
492: }
493:
494: /* Return the list of type-tags (for structs, etc) of the current level. */
495:
496: tree
497: gettags ()
498: {
499: return current_binding_level->tags;
500: }
501:
502: /* Store the list of declarations of the current level.
503: This is done for the parameter declarations of a function being defined,
504: after they are modified in the light of any missing parameters. */
505:
506: void
507: storedecls (decls)
508: tree decls;
509: {
510: current_binding_level->names = decls;
511: }
512:
513: /* Given NAME, an IDENTIFIER_NODE,
514: return the structure (or union or enum) definition for that name.
515: Searches binding levels from BINDING_LEVEL up to the global level.
516: If THISLEVEL_ONLY is nonzero, searches only the specified context.
517: FORM says which kind of type the caller wants;
518: it is RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE.
519: If the wrong kind of type is found, an error is reported. */
520:
521: static tree
522: lookup_tag (form, name, binding_level, thislevel_only)
523: enum tree_code form;
524: struct binding_level *binding_level;
525: tree name;
526: int thislevel_only;
527: {
528: register struct binding_level *level;
529:
530: for (level = binding_level; level; level = level->level_chain)
531: {
532: register tree tail;
533: for (tail = level->tags; tail; tail = TREE_CHAIN (tail))
534: {
535: if (TREE_PURPOSE (tail) == name)
536: {
537: if (TREE_CODE (TREE_VALUE (tail)) != form)
538: {
539: /* Definition isn't the kind we were looking for. */
540: yyerror ("%s defined as wrong kind of tag",
541: IDENTIFIER_POINTER (name));
542: }
543: return TREE_VALUE (tail);
544: }
545: }
546: if (thislevel_only)
547: return NULL_TREE;
548: }
549: return NULL_TREE;
550: }
551:
552: /* Look up NAME in the current binding level and its superiors
553: in the namespace of variables, functions and typedefs.
554: Return a ..._DECL node of some kind representing its definition,
555: or return 0 if it is undefined. */
556:
557: tree
558: lookup_name (name)
559: tree name;
560: {
561: if (current_binding_level != global_binding_level
562: && IDENTIFIER_LOCAL_VALUE (name))
563: return IDENTIFIER_LOCAL_VALUE (name);
564: return IDENTIFIER_GLOBAL_VALUE (name);
565: }
566:
567: /* Similar to `lookup_name' but look only at current binding level. */
568:
569: static tree
570: lookup_name_current_level (name)
571: tree name;
572: {
573: register tree t;
574:
575: if (current_binding_level == global_binding_level)
576: return IDENTIFIER_GLOBAL_VALUE (name);
577:
578: if (IDENTIFIER_LOCAL_VALUE (name) == 0)
579: return 0;
580:
581: for (t = current_binding_level->names; t; t = TREE_CHAIN (t))
582: if (DECL_NAME (t) == name)
583: break;
584:
585: return t;
586: }
587:
588: /* Return the definition of NAME as a label (a LABEL-DECL node),
589: or 0 if it has no definition as a label. */
590:
591: static
592: tree
593: lookup_labelname (name)
594: tree name;
595: {
596: return IDENTIFIER_LABEL_VALUE (name);
597: }
598:
599: /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
600: STATICP nonzero means this is declared `static' in the C sense;
601: EXTERNP means it is declared `extern' in the C sense.
602: The name's definition is *not* entered in the symbol table.
603:
604: The source file and line number are left 0.
605: layout_decl is used to set up the decl's storage layout.
606: are initialized to 0 or null pointers. */
607:
608: tree
609: build_decl (code, name, type, staticp, externp)
610: enum tree_code code;
611: tree name, type;
612: int staticp, externp;
613: {
614: register tree t;
615:
616: t = make_node (code);
617:
618: /* if (type == error_mark_node)
619: type = integer_type_node; */
620: /* That is not done, deliberately, so that having error_mark_node
621: as the type can suppress useless errors in the use of this variable. */
622:
623: DECL_NAME (t) = name;
624: TREE_TYPE (t) = type;
625: DECL_ARGUMENTS (t) = NULL_TREE;
626: DECL_INITIAL (t) = NULL_TREE;
627: if (externp)
628: TREE_EXTERNAL (t) = 1;
629: if (staticp)
630: TREE_STATIC (t) = 1;
631:
632: if (current_binding_level == global_binding_level)
633: {
634: if (!TREE_STATIC (t))
635: TREE_PUBLIC (t) = 1;
636: TREE_STATIC (t) = (code != FUNCTION_DECL);
637: }
638:
639: if (TREE_EXTERNAL (t))
640: TREE_STATIC (t) = 0;
641:
642: if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
643: layout_decl (t, 0);
644: else if (code == FUNCTION_DECL)
645: /* all functions considered external unless def in this file */
646: {
647: TREE_EXTERNAL (t) = 1;
648: DECL_MODE (t) = FUNCTION_MODE;
649: }
650: return t;
651: }
652:
653: /* Create a LABEL_STMT statement node containing a LABEL_DECL named NAME.
654: NAME may be a null pointer.
655: FILE ane LINENUM say where in the source the label is.
656: CONTEXT is the LET_STMT node which is the context of this label name.
657: The label name definition is entered in the symbol table. */
658:
659: tree
660: build_label (filename, line, name, context)
661: char *filename;
662: int line;
663: tree name;
664: tree context;
665: {
666: register tree t = make_node (LABEL_STMT);
667: register tree decl = build_decl (LABEL_DECL, name, NULL_TREE, 1, 0);
668:
669: STMT_SOURCE_FILE (t) = filename;
670: STMT_SOURCE_LINE (t) = line;
671: STMT_BODY (t) = decl;
672: DECL_SOURCE_FILE (decl) = filename;
673: DECL_SOURCE_LINE (decl) = line;
674: DECL_MODE (decl) = VOIDmode;
675: DECL_CONTEXT (decl) = context;
676: pushlabel (t);
677: return t;
678: }
679:
680: /* Store the data into a LET_STMT node.
681: Each C braced grouping with declarations is represented
682: by a LET_STMT node. The node is created when the open-brace is read,
683: but the contents to put in it are not known until the close-brace.
684: This function is called at the time of the close-brace
685: to install the proper contents.
686:
687: BLOCK is the LET_STMT node itself.
688: DCLS is the chain of declarations within the grouping.
689: TAGS is the chain of struct, union and enum tags defined within it.
690: STMTS is the chain of statements making up the inside of the grouping. */
691:
692: finish_block (block, dcls, tags, stmts)
693: tree block, dcls, tags, stmts;
694: {
695: register tree tem;
696:
697: /* In each decl, record the block it belongs to. */
698: for (tem = dcls; tem; tem = TREE_CHAIN (tem))
699: DECL_CONTEXT (tem) = block;
700:
701: STMT_VARS (block) = dcls;
702: STMT_BODY (block) = stmts;
703: STMT_TYPE_TAGS (block) = tags;
704: }
705:
706: finish_tree ()
707: {
708: }
709:
710: /* Create the predefined scalar types of C,
711: and some nodes representing standard constants (0, 1, (void *)0).
712: Initialize the global binding level.
713: Make definitions for built-in primitive functions. */
714:
715: void
716: init_decl_processing ()
717: {
718: register tree endlink;
719:
720: named_labels = NULL;
721: all_gotos = NULL;
722: current_binding_level = NULL_BINDING_LEVEL;
723: free_binding_level = NULL_BINDING_LEVEL;
724: pushlevel (); /* make the binding_level structure for global names */
725: global_binding_level = current_binding_level;
726:
727: value_identifier = get_identifier ("<value>");
728:
729: /* This must be the first type made and laid out,
730: so that it will get used as the type for expressions
731: for the sizes of types. */
732:
733: integer_type_node = make_signed_type (BITS_PER_WORD);
734: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_INT],
735: integer_type_node, 1, 0));
736:
737: error_mark_node = make_node (ERROR_MARK);
738: TREE_TYPE (error_mark_node) = error_mark_node;
739:
740: short_integer_type_node = make_signed_type (BITS_PER_UNIT * min (UNITS_PER_WORD / 2, 2));
741: pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),
742: short_integer_type_node, 1, 0));
743:
744: long_integer_type_node = make_signed_type (BITS_PER_WORD);
745: pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),
746: long_integer_type_node, 1, 0));
747:
748: short_unsigned_type_node = make_unsigned_type (BITS_PER_UNIT * min (UNITS_PER_WORD / 2, 2));
749: pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),
750: short_unsigned_type_node, 1, 0));
751:
752: unsigned_type_node = make_unsigned_type (BITS_PER_WORD);
753: pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),
754: unsigned_type_node, 1, 0));
755:
756: long_unsigned_type_node = make_unsigned_type (BITS_PER_WORD);
757: pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),
758: long_unsigned_type_node, 1, 0));
759:
760: char_type_node = make_signed_type (BITS_PER_UNIT);
761: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_CHAR],
762: char_type_node, 1, 0));
763:
764: unsigned_char_type_node = make_unsigned_type (BITS_PER_UNIT);
765: pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),
766: unsigned_char_type_node, 1, 0));
767:
768: float_type_node = make_node (REAL_TYPE);
769: TYPE_PRECISION (float_type_node) = BITS_PER_WORD;
770: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_FLOAT],
771: float_type_node, 1, 0));
772: layout_type (float_type_node);
773:
774: double_type_node = make_node (REAL_TYPE);
775: TYPE_PRECISION (double_type_node) = 2 * BITS_PER_WORD;
776: pushdecl (build_decl (TYPE_DECL, ridpointers[(int) RID_DOUBLE],
777: double_type_node, 1, 0));
778: layout_type (double_type_node);
779:
780: long_double_type_node = make_node (REAL_TYPE);
781: TYPE_PRECISION (long_double_type_node) = 2 * BITS_PER_WORD;
782: pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),
783: long_double_type_node, 1, 0));
784: layout_type (long_double_type_node);
785:
786: integer_zero_node = build_int_2 (0, 0);
787: TREE_TYPE (integer_zero_node) = integer_type_node;
788: integer_one_node = build_int_2 (1, 0);
789: TREE_TYPE (integer_one_node) = integer_type_node;
790:
791: void_type_node = make_node (VOID_TYPE);
792: pushdecl (build_decl (TYPE_DECL,
793: ridpointers[(int) RID_VOID], void_type_node,
794: 1, 0));
795: layout_type (void_type_node); /* Uses integer_zero_node */
796:
797: null_pointer_node = build_int_2 (0, 0);
798: TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
799: layout_type (TREE_TYPE (null_pointer_node));
800:
801: string_type_node = build_pointer_type (char_type_node);
802: layout_type (string_type_node);
803:
804: /* make a type for arrays of 256 characters.
805: 256 is picked randomly because we have a type for integers from 0 to 255.
806: With luck nothing will ever really depend on the length of this
807: array type. */
808: char_array_type_node
809: = build_array_type (char_type_node, unsigned_char_type_node);
810: layout_type (char_array_type_node);
811:
812: default_function_type
813: = build_function_type (integer_type_node, NULL_TREE);
814: layout_type (default_function_type);
815:
816: ptr_type_node = build_pointer_type (void_type_node);
817: endlink = tree_cons (NULL_TREE, void_type_node, NULL_TREE);
818:
819: double_ftype_double
820: = build_function_type (double_type_node,
821: tree_cons (NULL_TREE, double_type_node, endlink));
822:
823: double_ftype_double_double
824: = build_function_type (double_type_node,
825: tree_cons (NULL_TREE, double_type_node,
826: tree_cons (NULL_TREE,
827: double_type_node, endlink)));
828:
829: int_ftype_int
830: = build_function_type (integer_type_node,
831: tree_cons (NULL_TREE, integer_type_node, endlink));
832:
833: long_ftype_long
834: = build_function_type (long_integer_type_node,
835: tree_cons (NULL_TREE,
836: long_integer_type_node, endlink));
837:
838: void_ftype_ptr_ptr_int
839: = build_function_type (void_type_node,
840: tree_cons (NULL_TREE, ptr_type_node,
841: tree_cons (NULL_TREE, ptr_type_node,
842: tree_cons (NULL_TREE,
843: integer_type_node,
844: endlink))));
845:
846: int_ftype_ptr_ptr_int
847: = build_function_type (integer_type_node,
848: tree_cons (NULL_TREE, ptr_type_node,
849: tree_cons (NULL_TREE, ptr_type_node,
850: tree_cons (NULL_TREE,
851: integer_type_node,
852: endlink))));
853:
854: void_ftype_ptr_int_int
855: = build_function_type (void_type_node,
856: tree_cons (NULL_TREE, ptr_type_node,
857: tree_cons (NULL_TREE, integer_type_node,
858: tree_cons (NULL_TREE,
859: integer_type_node,
860: endlink))));
861:
862: builtin_function ("_builtin_alloca",
863: build_function_type (ptr_type_node,
864: tree_cons (NULL_TREE,
865: integer_type_node,
866: endlink)),
867: BUILT_IN_ALLOCA);
868:
869: builtin_function ("_builtin_abs", int_ftype_int, BUILT_IN_ABS);
870: builtin_function ("_builtin_fabs", double_ftype_double, BUILT_IN_FABS);
871: builtin_function ("_builtin_labs", long_ftype_long, BUILT_IN_LABS);
872: /* builtin_function ("_builtin_div", default_ftype, BUILT_IN_DIV);
873: builtin_function ("_builtin_ldiv", default_ftype, BUILT_IN_LDIV); */
874: builtin_function ("_builtin_ffloor", double_ftype_double, BUILT_IN_FFLOOR);
875: builtin_function ("_builtin_fceil", double_ftype_double, BUILT_IN_FCEIL);
876: builtin_function ("_builtin_fmod", double_ftype_double_double, BUILT_IN_FMOD);
877: builtin_function ("_builtin_frem", double_ftype_double_double, BUILT_IN_FREM);
878: builtin_function ("_builtin_memcpy", void_ftype_ptr_ptr_int, BUILT_IN_MEMCPY);
879: builtin_function ("_builtin_memcmp", int_ftype_ptr_ptr_int, BUILT_IN_MEMCMP);
880: builtin_function ("_builtin_memset", void_ftype_ptr_int_int, BUILT_IN_MEMSET);
881: builtin_function ("_builtin_fsqrt", double_ftype_double, BUILT_IN_FSQRT);
882: builtin_function ("_builtin_getexp", double_ftype_double, BUILT_IN_GETEXP);
883: builtin_function ("_builtin_getman", double_ftype_double, BUILT_IN_GETMAN);
884: }
885:
886: /* Make a definition for a builtin function named NAME and whose data type
887: is TYPE. TYPE should be a function type with argument types.
888: FUNCTION_CODE tells later passes how to compile calls to this function.
889: See tree.h for its possible values. */
890:
891: static void
892: builtin_function (name, type, function_code)
893: char *name;
894: tree type;
895: enum built_in_function function_code;
896: {
897: tree decl = build_decl (FUNCTION_DECL, get_identifier (name), type, 0, 1);
898: make_function_rtl (decl);
899: pushdecl (decl);
900: DECL_SET_FUNCTION_CODE (decl, function_code);
901: }
902:
903: /* Validate a structure, union or enum type: make sure it
904: is not just a forward reference.
905: If it is valid, return it. Otherwise, return error_mark_node.
906: Callers may want to use the returned value instead of the original type. */
907:
908: tree
909: resolve_tags (type)
910: tree type;
911: {
912: register char *errmsg = NULL;
913:
914: switch (TREE_CODE (type))
915: {
916: case RECORD_TYPE:
917: errmsg = "undefined struct tag %s";
918: break;
919:
920: case UNION_TYPE:
921: errmsg = "undefined union tag %s";
922: break;
923:
924: case ENUMERAL_TYPE:
925: errmsg = "undefined enum tag %s";
926: break;
927:
928: default:
929: return type;
930: }
931:
932: if (TYPE_SIZE (type) != 0)
933: return type;
934:
935: yyerror (errmsg, IDENTIFIER_POINTER (TYPE_NAME (type)));
936: return error_mark_node;
937: }
938:
939: /* Called when a declaration is seen that contains no names to declare.
940: If its type is a reference to a structure, union or enum inherited
941: from a containing scope, shadow that tag name for the current scope
942: with a forward reference.
943: If its type defines a new named structure or union
944: or defines an enum, it is valid but we need not do anything here.
945: Otherwise, it is an error. */
946:
947: void
948: shadow_tag (declspecs)
949: tree declspecs;
950: {
951: register tree link;
952:
953: for (link = declspecs; link; link = TREE_CHAIN (link))
954: {
955: register tree value = TREE_VALUE (link);
956: register enum tree_code code = TREE_CODE (value);
957: if ((code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
958: && TYPE_SIZE (value) != 0)
959: {
960: register tree name = TYPE_NAME (value);
961: register tree t = lookup_tag (code, name, current_binding_level, 1);
962: if (t == 0)
963: {
964: t = make_node (code);
965: pushtag (name, t);
966: return;
967: }
968: if (name != 0 || code == ENUMERAL_TYPE)
969: return;
970: }
971: }
972: warning ("empty declaration");
973: }
974:
975: /* Decode a "typename", such as "int **", returning a ..._TYPE node. */
976:
977: tree
978: groktypename (typename)
979: tree typename;
980: {
981: return grokdeclarator (TREE_VALUE (typename),
982: TREE_PURPOSE (typename),
983: TYPENAME);
984: }
985:
986: /* Decode a declarator in an ordinary declaration or data definition.
987: This is called as soon as the type information and variable name
988: have been parsed, before parsing the initializer if any.
989: Here we create the ..._DECL node, fill in its type,
990: and put it on the list of decls for the current context.
991: The ..._DECL node is returned as the value.
992:
993: Exception: for arrays where the length is not specified,
994: the type is left null, to be filled in by `finish_decl'.
995:
996: Function definitions do not come here; they go to start_function
997: instead. However, external and forward declarations of functions
998: do go through here. Structure field declarations are done by
999: grokfield and not through here. */
1000:
1001: tree
1002: start_decl (declarator, declspecs, initialized)
1003: tree declspecs, declarator;
1004: int initialized;
1005: {
1006: register tree decl = grokdeclarator (declarator, declspecs, NORMAL);
1007: if (initialized)
1008: TREE_EXTERNAL (decl) = 0;
1009: return pushdecl (decl);
1010: }
1011:
1012: /* Finish processing of a declaration;
1013: install its line number and initial value.
1014: If the length of an array type is not known before,
1015: it must be determined now, from the initial value, or it is an error. */
1016:
1017: void
1018: finish_decl (filename, line, decl, init)
1019: char *filename;
1020: int line;
1021: tree decl, init;
1022: {
1023: register tree type = TREE_TYPE (decl);
1024:
1025: if (init) store_init_value (decl, init);
1026:
1027: /* deduce size of array from initialization, if not already known */
1028:
1029: if (TREE_CODE (type) == ARRAY_TYPE
1030: && TYPE_DOMAIN (type) == 0)
1031: {
1032: register tree maxindex = NULL_TREE;
1033:
1034: if (init)
1035: {
1036: /* Note MAXINDEX is really the maximum index,
1037: one less than the size. */
1038: if (TREE_CODE (init) == ADDR_EXPR
1039: && TREE_CODE (TREE_OPERAND (init, 0)) == STRING_CST)
1040: maxindex = build_int_2 (TREE_STRING_LENGTH (TREE_OPERAND (init, 0)) - 1, 0);
1041: else if (TREE_CODE (init) == CONSTRUCTOR)
1042: {
1043: int nelts = list_length (TREE_OPERAND (DECL_INITIAL (decl), 0));
1044: maxindex = build_int_2 (nelts - 1, 0);
1045: }
1046: }
1047:
1048: if (!maxindex)
1049: {
1050: if (!pedantic)
1051: TREE_EXTERNAL (decl) = 1;
1052: else if (!TREE_EXTERNAL (decl))
1053: {
1054: yylineerror (line, "size missing in array declaration");
1055: maxindex = build_int_2 (0, 0);
1056: }
1057: }
1058:
1059: if (maxindex)
1060: {
1061: if (pedantic && integer_zerop (maxindex))
1062: yylineerror (line, "zero-size array");
1063: TYPE_DOMAIN (type) = make_index_type (maxindex);
1064: if (!TREE_TYPE (maxindex))
1065: TREE_TYPE (maxindex) = TYPE_DOMAIN (type);
1066: }
1067:
1068: layout_type (type);
1069:
1070: layout_decl (decl, 0);
1071: }
1072:
1073: /* Output the assembler code for the variable. */
1074:
1075: rest_of_compilation (decl, current_binding_level == global_binding_level);
1076: }
1077:
1078: /* Given declspecs and a declarator,
1079: determine the name and type of the object declared.
1080: DECLSPECS is a chain of tree_list nodes whose value fields
1081: are the storage classes and type specifiers.
1082:
1083: DECL_CONTEXT says which syntactic context this declaration is in:
1084: NORMAL for most contexts. Make a VAR_DECL or FUNCTION_DECL or TYPE_DECL.
1085: PARM for a paramater declaration (either within a function prototype
1086: or before a function body). Make a PARM_DECL.
1087: TYPENAME if for a typename (in a cast or sizeof).
1088: Don't make a DECL node; just return the type.
1089: FIELD for a struct or union field; make a FIELD_DECL.
1090:
1091: In the TYPENAME case, DECLARATOR is really an absolute declarator.
1092: It may also be so in the PARM case, for a prototype where the
1093: argument type is specified but not the name. */
1094:
1095: static tree
1096: grokdeclarator (declarator, declspecs, decl_context)
1097: tree declspecs;
1098: tree declarator;
1099: enum decl_context decl_context;
1100: {
1101: int specbits = 0;
1102: tree spec;
1103: tree type = NULL_TREE;
1104: int longlong = 0;
1105: int constp;
1106: int volatilep;
1107: int explicit_int = 0;
1108:
1109: /* Anything declared one level down from the top level
1110: must be one of the parameters of a function
1111: (because the body is at least two levels down). */
1112:
1113: if (decl_context == NORMAL
1114: && current_binding_level->level_chain == global_binding_level)
1115: decl_context = PARM;
1116:
1117: /* Look through the decl specs and record which ones appear.
1118: Some typespecs are defined as built-in typenames.
1119: Others, the ones that are modifiers of other types,
1120: are represented by bits in SPECBITS: set the bits for
1121: the modifiers that appear. Storage class keywords are also in SPECBITS.
1122:
1123: If there is a typedef name or a type, store the type in TYPE.
1124: This includes builtin typedefs such as `int'.
1125:
1126: Set EXPLICIT_INT if the type is `int' or `char' and did not
1127: come from a user typedef.
1128:
1129: Set LONGLONG if `long' is mentioned twice. */
1130:
1131: for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
1132: {
1133: register int i;
1134: register tree id = TREE_VALUE (spec);
1135:
1136: if (id == ridpointers[(int) RID_INT]
1137: || id == ridpointers[(int) RID_CHAR])
1138: explicit_int = 1;
1139:
1140: for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++)
1141: {
1142: if (ridpointers[i] == id)
1143: {
1144: if (i == (int) RID_LONG && specbits & (1<<i))
1145: longlong = 1;
1146: specbits |= 1 << i;
1147: goto found;
1148: }
1149: }
1150: if (type) yyerror ("two or more data types in declaration");
1151: else if (TREE_CODE (id) == RECORD_TYPE || TREE_CODE (id) == UNION_TYPE || TREE_CODE (id) == ENUMERAL_TYPE)
1152: type = id;
1153: else
1154: {
1155: register tree t = lookup_name (id);
1156: if (!t || TREE_CODE (t) != TYPE_DECL)
1157: yyerror ("%s fails to be a typedef or built in type",
1158: IDENTIFIER_POINTER (id));
1159: else type = TREE_TYPE (t);
1160: }
1161:
1162: found: {}
1163: }
1164:
1165: /* No type at all: default to `int', and set EXPLICIT_INT
1166: because it was not a user-defined typedef. */
1167:
1168: if (type == 0)
1169: {
1170: explicit_int = 1;
1171: type = integer_type_node;
1172: }
1173:
1174: /* Now process the modifiers that were specified
1175: and check for invalid combinations. */
1176:
1177: /* Long double is a special combination. */
1178:
1179: if ((specbits & 1 << RID_LONG) && type == double_type_node)
1180: {
1181: specbits &= ~ (1 << RID_LONG);
1182: type = long_double_type_node;
1183: }
1184:
1185: /* Check all other uses of type modifiers. */
1186:
1187: if (specbits & ((1 << RID_LONG) | (1 << RID_SHORT)
1188: | (1 << RID_UNSIGNED) | (1 << RID_SIGNED)))
1189: {
1190: if (!explicit_int)
1191: yyerror ("long, short, signed or unsigned used invalidly");
1192: else if ((specbits & 1 << RID_LONG) && (specbits & 1 << RID_SHORT))
1193: yyerror ("long and short specified together");
1194: else if ((specbits & 1 << RID_SIGNED) && (specbits & 1 << RID_UNSIGNED))
1195: yyerror ("signed and unsigned specified together");
1196: else
1197: {
1198: if (specbits & 1 << RID_UNSIGNED)
1199: {
1200: if (specbits & 1 << RID_LONG)
1201: type = long_unsigned_type_node;
1202: else if (specbits & 1 << RID_SHORT)
1203: type = short_unsigned_type_node;
1204: else if (type == char_type_node)
1205: type = unsigned_char_type_node;
1206: else
1207: type = unsigned_type_node;
1208: }
1209: else if (specbits & 1 << RID_LONG)
1210: type = long_integer_type_node;
1211: else if (specbits & 1 << RID_SHORT)
1212: type = short_integer_type_node;
1213: }
1214: }
1215:
1216: /* Set CONSTP if this declaration is `const', whether by
1217: explicit specification or via a typedef.
1218: Likewise for VOLATILEP. */
1219:
1220: constp = (specbits & 1 << RID_CONST) | TREE_READONLY (type);
1221: volatilep = (specbits & 1 << RID_VOLATILE) | TREE_VOLATILE (type);
1222: type = TYPE_MAIN_VARIANT (type);
1223:
1224: /* Warn if two storage classes are given. Default to `auto'. */
1225:
1226: {
1227: int nclasses = 0;
1228:
1229: if (specbits & 1 << RID_AUTO) nclasses++;
1230: if (specbits & 1 << RID_STATIC) nclasses++;
1231: if (specbits & 1 << RID_EXTERN) nclasses++;
1232: if (specbits & 1 << RID_REGISTER) nclasses++;
1233: if (specbits & 1 << RID_TYPEDEF) nclasses++;
1234:
1235: if (nclasses == 0) specbits |= 1 << RID_AUTO;
1236:
1237: /* Warn about storage classes that are invalid for certain
1238: kinds of declarations (parameters, typenames, etc.). */
1239:
1240: if (nclasses > 1)
1241: yyerror ("two or more storage classes in declaration");
1242: else if (decl_context != NORMAL && nclasses > 0)
1243: {
1244: if (decl_context == PARM && specbits & 1 << RID_REGISTER)
1245: ;
1246: else if (decl_context == FIELD)
1247: yyerror ("storage class specified in structure field");
1248: else yyerror (decl_context == PARM
1249: ? "storage class specified in parameter list"
1250: : "storage class specified in typename");
1251: }
1252: else if (current_binding_level == global_binding_level
1253: && nclasses > 0)
1254: {
1255: if (specbits & (1 << RID_AUTO))
1256: yyerror ("auto specified in external declaration");
1257: if (specbits & (1 << RID_REGISTER))
1258: yyerror ("auto specified in external declaration");
1259: }
1260: }
1261:
1262: /* Now figure out the structure of the declarator proper.
1263: Descend through it, creating more complex types, until we reach
1264: the declared identifier (or NULL_TREE, in an absolute declarator). */
1265:
1266: while (declarator && TREE_CODE (declarator) != IDENTIFIER_NODE)
1267: {
1268: /* Each level of DECLARATOR is either an ARRAY_REF (for ...[..]),
1269: an INDIRECT_REF (for *...),
1270: a CALL_EXPR (for ...(...)),
1271: an identifier (for the name being declared)
1272: or a null pointer (for the place in an absolute declarator
1273: where the name was omitted).
1274: For the last two cases, we have just exited the loop.
1275:
1276: At this point, TYPE is the type of elements of an array,
1277: or for a function to return, or for a pointer to point to.
1278: After this sequence of ifs, TYPE is the type of the
1279: array or function or pointer, and DECLARATOR has had its
1280: outermost layer removed. */
1281:
1282: if (TREE_CODE (declarator) == ARRAY_REF)
1283: {
1284: register tree itype = NULL_TREE;
1285: register tree size = TREE_OPERAND (declarator, 1);
1286:
1287: /* Make sure we have a valid type for the array elements. */
1288: type = resolve_tags (type);
1289: /* Make a variant that is const or volatile as needed. */
1290: if (constp || volatilep)
1291: type = build_type_variant (type, constp, volatilep);
1292: /* Record that any const-ness or volatility are taken care of. */
1293: constp = 0;
1294: volatilep = 0;
1295:
1296: /* Check for some types that there cannot be arrays of. */
1297:
1298: if (type == void_type_node)
1299: {
1300: yyerror ("array of voids declared");
1301: type = integer_type_node;
1302: }
1303:
1304: if (TREE_CODE (type) == FUNCTION_TYPE)
1305: {
1306: yyerror ("array of functions declared");
1307: type = integer_type_node;
1308: }
1309:
1310: /* If size was specified, set ITYPE to a range-type for that size.
1311: Otherwise, ITYPE remains null. finish_decl may figure it out
1312: from an initial value. */
1313:
1314: if (size)
1315: {
1316: if (TREE_LITERAL (size))
1317: itype = make_index_type (build_int_2 (TREE_INT_CST_LOW (size) - 1, 0));
1318: else
1319: itype = make_index_type (build_binary_op (MINUS_EXPR, size, integer_one_node));
1320: }
1321:
1322: /* Build the array type itself. */
1323:
1324: type = build_array_type (type, itype);
1325:
1326: /* Make sure there is a valid pointer type
1327: for automatic coercion of array to pointer. */
1328:
1329: layout_type (TYPE_POINTER_TO (TREE_TYPE (type)));
1330:
1331: declarator = TREE_OPERAND (declarator, 0);
1332:
1333: /* if size unknown, don't lay it out until finish_decl */
1334: if (!itype) goto nolayout;
1335: }
1336: else if (TREE_CODE (declarator) == CALL_EXPR)
1337: {
1338: /* Declaring a function type.
1339: Make sure we have a valid type for the function to return. */
1340: type = resolve_tags (type);
1341:
1342: /* Is this an error? Should they be merged into TYPE here? */
1343: constp = 0;
1344: volatilep = 0;
1345:
1346: /* Warn about some types functions can't return. */
1347:
1348: if (TREE_CODE (type) == FUNCTION_TYPE)
1349: {
1350: yyerror ("function returning a function declared");
1351: type = integer_type_node;
1352: }
1353: if (TREE_CODE (type) == ARRAY_TYPE)
1354: {
1355: yyerror ("function returning an array declared");
1356: type = integer_type_node;
1357: }
1358:
1359: /* Construct the function type and go to the next
1360: inner layer of declarator. */
1361:
1362: type =
1363: build_function_type (type,
1364: grokparms (TREE_OPERAND (declarator, 1)));
1365: declarator = TREE_OPERAND (declarator, 0);
1366: }
1367: else if (TREE_CODE (declarator) == INDIRECT_REF)
1368: {
1369: /* Merge any constancy or volatility into the target type
1370: for the pointer. */
1371:
1372: if (constp || volatilep)
1373: type = build_type_variant (type, constp, volatilep);
1374: constp = 0;
1375: volatilep = 0;
1376:
1377: type = build_pointer_type (type);
1378:
1379: /* Process a list of type modifier keywords
1380: (such as const or volatile) that were given inside the `*'. */
1381:
1382: if (TREE_TYPE (declarator))
1383: {
1384: register tree typemodlist;
1385: for (typemodlist = TREE_TYPE (declarator); typemodlist;
1386: typemodlist = TREE_CHAIN (typemodlist))
1387: {
1388: if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_CONST])
1389: constp = 1;
1390: if (TREE_VALUE (typemodlist) == ridpointers[(int) RID_VOLATILE])
1391: volatilep = 1;
1392: }
1393: }
1394:
1395: declarator = TREE_OPERAND (declarator, 0);
1396: }
1397: else
1398: abort ();
1399:
1400: layout_type (type);
1401:
1402: /* @@ Should perhaps replace the following code by changes in
1403: * @@ stor_layout.c. */
1404: if (TREE_CODE (type) == FUNCTION_DECL)
1405: {
1406: /* A function variable in C should be Pmode rather than EPmode
1407: because it has just the address of a function, no static chain.*/
1408: TYPE_MODE (type) = Pmode;
1409: }
1410:
1411: nolayout: ;
1412: }
1413:
1414: /* Now TYPE has the actual type; but if it is an ARRAY_TYPE
1415: then it has not been laid out of its size wasn't specified. */
1416:
1417: /* If this is declaring a typedef name, return a TYPE_DECL. */
1418:
1419: if (specbits & 1 << RID_TYPEDEF)
1420: {
1421: /* Note that the grammar rejects storage classes
1422: in typenames, fields or parameters */
1423: if (constp || volatilep)
1424: type = build_type_variant (type, constp, volatilep);
1425: return build_decl (TYPE_DECL, declarator, type, 0, 0);
1426: }
1427:
1428: /* It is ok to typedef a forward reference to a structure tag,
1429: but using it for other purposes requires it to be defined
1430: (except when it's inside a pointer; but in that case, what we
1431: get here would be a pointer type and `resolve_tags' would do nothing. */
1432:
1433: type = resolve_tags (type);
1434:
1435: /* If this is a type name (such as, in a cast or sizeof),
1436: compute the type and return it now. */
1437:
1438: if (decl_context == TYPENAME)
1439: {
1440: /* Note that the grammar rejects storage classes
1441: in typenames, fields or parameters */
1442: if (constp || volatilep)
1443: type = build_type_variant (type, constp, volatilep);
1444: return type;
1445: }
1446:
1447: /* `void' at top level (not within pointer)
1448: is allowed only in typedefs or type names. */
1449:
1450: if (type == void_type_node)
1451: {
1452: yyerror ("variable or field %s declared void",
1453: IDENTIFIER_POINTER (declarator));
1454: type = integer_type_node;
1455: }
1456:
1457: /* Now create the decl, which may be a VAR_DECL, a PARM_DECL
1458: or a FUNCTION_DECL, depending on DECL_CONTEXT and TYPE. */
1459:
1460: {
1461: register tree decl;
1462:
1463: if (decl_context == PARM)
1464: {
1465: /* A parameter declared as an array of T is really a pointer to T.
1466: One declared as a function is really a pointer to a function. */
1467:
1468: if (TREE_CODE (type) == ARRAY_TYPE)
1469: type = build_pointer_type (TREE_TYPE (type));
1470: if (TREE_CODE (type) == FUNCTION_TYPE)
1471: {
1472: type = build_pointer_type (type);
1473: layout_type (type);
1474: }
1475:
1476: decl = build_decl (PARM_DECL, declarator, type, 0, 0);
1477: DECL_ARG_TYPE (decl) = type;
1478: if (type == float_type_node)
1479: DECL_ARG_TYPE (decl) = double_type_node;
1480: else if (TREE_CODE (type) == INTEGER_TYPE
1481: && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1482: DECL_ARG_TYPE (decl) = integer_type_node;
1483: }
1484: else if (decl_context == FIELD)
1485: {
1486: /* Structure field. It may not be a function. */
1487:
1488: if (TREE_CODE (type) == FUNCTION_TYPE)
1489: {
1490: yyerror ("field %s declared as a function",
1491: IDENTIFIER_POINTER (declarator));
1492: type = build_pointer_type (type);
1493: layout_type (type);
1494: }
1495: decl = build_decl (FIELD_DECL, declarator, type, 0, 0);
1496: }
1497: else
1498: {
1499: /* Declaration in ordinary context
1500: is either a variable or a function depending on TYPE. */
1501:
1502: decl = build_decl (((TREE_CODE (type) == FUNCTION_TYPE)
1503: ? FUNCTION_DECL : VAR_DECL),
1504: declarator, type,
1505: specbits & 1 << RID_STATIC,
1506: specbits & 1 << RID_EXTERN);
1507:
1508:
1509: /* For function declaration,
1510: store list of parameter names in the parameters field.
1511: finish_function will replace it with
1512: chained declarations of them. */
1513:
1514: if (TREE_CODE (type) == FUNCTION_TYPE)
1515: DECL_ARGUMENTS (decl) = last_function_parm_names;
1516: }
1517:
1518: /* Record `register' declaration for warnings on &
1519: and in case doing stupid register allocation. */
1520:
1521: if (specbits & 1 << RID_REGISTER)
1522: TREE_REGDECL (decl) = 1;
1523:
1524: /* Record constancy and volatility. */
1525:
1526: if (constp)
1527: TREE_READONLY (decl) = 1;
1528: if (volatilep)
1529: {
1530: TREE_VOLATILE (decl) = 1;
1531: TREE_THIS_VOLATILE (decl) = 1;
1532: }
1533:
1534: return decl;
1535: }
1536: }
1537:
1538: /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
1539: MAXVAL should be the maximum value in the domain
1540: (one less than the length of the array). */
1541:
1542: static
1543: tree
1544: make_index_type (maxval)
1545: tree maxval;
1546: {
1547: register tree itype = make_node (INTEGER_TYPE);
1548: TYPE_PRECISION (itype) = BITS_PER_WORD;
1549: TYPE_MIN_VALUE (itype) = build_int_2 (0, 0);
1550: TREE_TYPE (TYPE_MIN_VALUE (itype)) = itype;
1551: TYPE_MAX_VALUE (itype) = maxval;
1552: TREE_TYPE (maxval) = itype;
1553: TYPE_MODE (itype) = SImode;
1554: TYPE_SIZE (itype) = TYPE_SIZE (integer_type_node);
1555: TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (integer_type_node);
1556: TYPE_ALIGN (itype) = TYPE_ALIGN (integer_type_node);
1557: return itype;
1558: }
1559:
1560: /* Decode the list of parameter types for a function type.
1561: Given the list of things declared inside the parens,
1562: return a list of types.
1563:
1564: The list we receive can have three kinds of elements:
1565: an IDENTIFIER_NODE for names given without types,
1566: a TREE_LIST node for arguments given as typespecs or names with typespecs,
1567: or void_type_node, to mark the end of an argument list
1568: when additional arguments are not permitted (... was not used).
1569:
1570: If all elements of the input list contain types,
1571: we return a list of the types.
1572: If all elements contain no type (except perhaps a void_type_node
1573: at the end), we return a null list.
1574: If some have types and some do not, it is an error, and we
1575: return a null list.
1576:
1577: Also stores a list of names (IDENTIFIER_NODEs)
1578: in last_function_parm_names. The list links have the names
1579: as the TREE_VALUE and their types (if specified) as the TREE_PURPOSE. */
1580:
1581: static
1582: tree
1583: grokparms (first_parm)
1584: tree first_parm;
1585: {
1586: register tree parm;
1587: tree result = NULL_TREE;
1588: tree names = NULL_TREE;
1589: int notfirst = 0;
1590: int erring = 0;
1591:
1592: for (parm = first_parm;
1593: parm != NULL_TREE;
1594: parm = TREE_CHAIN (parm))
1595: {
1596: register tree parm_node = TREE_VALUE (parm);
1597: register tree name, type;
1598: if (TREE_CODE (parm_node) == VOID_TYPE)
1599: {
1600: name = 0;
1601: if (result != 0)
1602: result = chainon (result, build_tree_list (0, parm_node));
1603: break;
1604: }
1605: else if (TREE_CODE (parm_node) == IDENTIFIER_NODE)
1606: {
1607: name = parm_node;
1608: type = 0;
1609: }
1610: else
1611: {
1612: name = TREE_VALUE (parm_node);
1613: type = TREE_TYPE (grokdeclarator (TREE_VALUE (parm_node),
1614: TREE_PURPOSE (parm_node),
1615: PARM));
1616: }
1617:
1618: if (notfirst && !erring && (type != 0) != (result != 0))
1619: {
1620: yyerror ("types sometimes given and sometimes omitted in parameter list");
1621: erring = 1;
1622: }
1623: notfirst = 1;
1624:
1625: names = chainon (names, build_tree_list (type, name));
1626: if (type != 0)
1627: result = chainon (result, build_tree_list (0, type));
1628: }
1629:
1630: last_function_parm_names = names;
1631: if (erring)
1632: return 0;
1633: return result;
1634: }
1635:
1636: /* Process the specs, declarator (NULL if omitted) and width (NULL if omitted)
1637: of a structure component, returning a FIELD_DECL node.
1638: WIDTH is non-NULL for bit fields only, and is an INTEGER_CST node.
1639:
1640: This is done during the parsing of the struct declaration.
1641: The FIELD_DECL nodes are chained together and the lot of them
1642: are ultimately passed to `build_struct' to make the RECORD_TYPE node. */
1643:
1644: tree
1645: grokfield (filename, line, declarator, declspecs, width)
1646: char *filename;
1647: int line;
1648: tree declarator, declspecs, width;
1649: {
1650: register tree value = grokdeclarator (declarator, declspecs, FIELD);
1651: register tree semantics = TREE_TYPE (value);
1652:
1653: finish_decl (filename, line, value, NULL);
1654: DECL_INITIAL (value) = width;
1655: DECL_ALIGN (value) = TYPE_ALIGN (semantics);
1656: return value;
1657: }
1658:
1659: /* Create a RECORD_TYPE or UNION_TYPE node for a C struct or union declaration.
1660: CODE says which one; it is RECORD_TYPE or UNION_TYPE.
1661: FILENAME and LINE say where the declaration is located in the source.
1662: NAME is the name of the struct or union tag, or 0 if there is none.
1663: FIELDLIST is a chain of FIELD_DECL nodes for the fields.
1664: XREF is nonzero to make a cross reference to a struct or union
1665: defined elsewhere; this is how `struct foo' with no members
1666: is handled. */
1667:
1668: tree
1669: build_struct (code, filename, line, name, fieldlist, xref)
1670: enum tree_code code;
1671: char *filename;
1672: int line;
1673: tree name, fieldlist;
1674: int xref;
1675: {
1676: register tree t;
1677: register tree x;
1678:
1679: if (xref)
1680: {
1681: /* If a cross reference is requested, look up the type
1682: already defined for this tag and return it. */
1683:
1684: register tree ref = lookup_tag (code, name, current_binding_level, 0);
1685: if (ref) return ref;
1686:
1687: /* If no such tag is yet defined, create a forward-reference node
1688: and record it as the "definition".
1689: When a real declaration of this type is found,
1690: the forward-reference will be altered into a real type. */
1691:
1692: t = make_node (code);
1693: pushtag (name, t);
1694: return t;
1695: }
1696:
1697: /* If we have previously made forward reference to this type,
1698: fill in the contents in the same object that used to be the
1699: forward reference. */
1700:
1701: if (name)
1702: t = lookup_tag (code, name, current_binding_level, 1);
1703: else
1704: t = 0;
1705:
1706: /* Otherwise, create a new node for this type. */
1707:
1708: if (t == 0)
1709: {
1710: t = make_node (code);
1711: pushtag (name, t);
1712: }
1713:
1714: /* Install struct as DECL_CONTEXT of each field decl.
1715: Also process specified field sizes.
1716: Set DECL_SIZE_UNIT to the specified size, or 0 if none specified.
1717: The specified size is found in the DECL_INITIAL.
1718: Store 0 there, except for ": 0" fields (so we can find them
1719: and delete them, below). */
1720:
1721: for (x = fieldlist; x; x = TREE_CHAIN (x))
1722: {
1723: DECL_CONTEXT (x) = t;
1724: DECL_SIZE_UNIT (x) = 0;
1725: /* detect invalid field size */
1726: if (DECL_INITIAL (x) && TREE_CODE (DECL_INITIAL (x)) != INTEGER_CST)
1727: {
1728: yylineerror (DECL_SOURCE_LINE (x),
1729: "structure field %s width not an integer constant",
1730: IDENTIFIER_POINTER (DECL_NAME (x)));
1731: DECL_INITIAL (x) = NULL;
1732: }
1733: /* process valid field size */
1734: if (DECL_INITIAL (x))
1735: {
1736: register int prec = TREE_INT_CST_LOW (DECL_INITIAL (x));
1737:
1738: if (prec == 0)
1739: {
1740: /* field size 0 => mark following field as "aligned" */
1741: if (TREE_CHAIN (x))
1742: DECL_ALIGN (TREE_CHAIN (x)) = BITS_PER_WORD;
1743: }
1744: else
1745: {
1746: DECL_INITIAL (x) = NULL;
1747: DECL_SIZE_UNIT (x) = prec > 0 ? prec : - prec;
1748: TREE_PACKED (x) = 1;
1749: }
1750: }
1751: }
1752: /* delete all ": 0" fields from the front of the fieldlist */
1753: while (fieldlist
1754: && DECL_INITIAL (fieldlist))
1755: fieldlist = TREE_CHAIN (fieldlist);
1756: /* delete all such fields from the rest of the fieldlist */
1757: for (x = fieldlist; x;)
1758: {
1759: if (TREE_CHAIN (x) && DECL_INITIAL (TREE_CHAIN (x)))
1760: TREE_CHAIN (x) = TREE_CHAIN (TREE_CHAIN (x));
1761: else x = TREE_CHAIN (x);
1762: }
1763:
1764: TYPE_FIELDS (t) = fieldlist;
1765:
1766: layout_type (t);
1767:
1768: /* Round the size up to be a multiple of the required alignment */
1769: TYPE_SIZE (t)
1770: = convert_units (TYPE_SIZE (t), TYPE_SIZE_UNIT (t), TYPE_ALIGN (t));
1771: TYPE_SIZE_UNIT (t) = TYPE_ALIGN (t);
1772:
1773: return t;
1774: }
1775:
1776: /* Begin compiling the definition of an enumeration type.
1777: NAME is its name (or null if anonymous).
1778: Returns the type object, as yet incomplete.
1779: Also records info about it so that build_enumerator
1780: may be used to declare the individual values as they are read. */
1781:
1782: tree
1783: start_enum (name)
1784: tree name;
1785: {
1786: register tree enumtype = 0;
1787:
1788: /* If this is the real definition for a previous forward reference,
1789: fill in the contents in the same object that used to be the
1790: forward reference. */
1791:
1792: if (name != 0)
1793: enumtype = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 1);
1794:
1795: if (enumtype == 0)
1796: {
1797: enumtype = make_node (ENUMERAL_TYPE);
1798: pushtag (name, enumtype);
1799: }
1800:
1801: if (TYPE_VALUES (enumtype) != 0)
1802: {
1803: /* This enum is a named one that has been declared already. */
1804: yyerror ("redeclaration of enum %s", IDENTIFIER_POINTER (name));
1805:
1806: /* Completely replace its old definition.
1807: The old enumerators remain defined, however. */
1808: TYPE_VALUES (enumtype) = 0;
1809: }
1810:
1811: /* Initially, set up this enum as like `int'
1812: so that we can create the enumerators' declarations and values.
1813: Later on, the precision of the type may be changed and
1814: it may be layed out again. */
1815:
1816: TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node);
1817: TYPE_SIZE (enumtype) = 0;
1818: fixup_unsigned_type (enumtype);
1819:
1820: enum_next_value = 0;
1821: current_enum_type = enumtype;
1822:
1823: return enumtype;
1824: }
1825:
1826: /* Return the enumeration type tagged with NAME
1827: or create and return a forward reference to such a type. */
1828:
1829: tree
1830: xref_enum (name)
1831: tree name;
1832: {
1833: register tree ref = lookup_tag (ENUMERAL_TYPE, name, current_binding_level, 0);
1834: /* If we find an already-defined enum type, or a previous
1835: forward reference, return it. */
1836: if (ref) return ref;
1837:
1838: /* If this is a forward reference for the first time,
1839: record it as the "definition". */
1840: ref = make_node (ENUMERAL_TYPE);
1841: pushtag (name, ref);
1842: return ref;
1843: }
1844:
1845: /* After processing and defining all the values of an enumeration type,
1846: install their decls in the enumeration type and finish it off.
1847: ENUMTYPE is the type object and VALUES a list of name-value pairs.
1848: Returns ENUMTYPE. */
1849:
1850: tree
1851: finish_enum (enumtype, values)
1852: register tree enumtype, values;
1853: {
1854: register tree pair = values;
1855: register long maxvalue = 0;
1856: register int i;
1857:
1858: TYPE_VALUES (enumtype) = values;
1859:
1860: /* Calculate the maximum value of any enumerator in this type. */
1861:
1862: for (pair = values; pair; pair = TREE_CHAIN (pair))
1863: {
1864: int value = TREE_INT_CST_LOW (TREE_VALUE (pair));
1865: if (value > maxvalue)
1866: maxvalue = value;
1867: }
1868:
1869: #if 0
1870: /* Determine the precision this type needs, lay it out, and define it. */
1871:
1872: for (i = maxvalue; i; i >>= 1)
1873: TYPE_PRECISION (enumtype)++;
1874:
1875: if (!TYPE_PRECISION (enumtype))
1876: TYPE_PRECISION (enumtype) = 1;
1877: #endif
1878:
1879: /* Cancel the laying out previously done for the enum type,
1880: so that fixup_unsigned_type will do it over. */
1881: TYPE_SIZE (enumtype) = 0;
1882:
1883: fixup_unsigned_type (enumtype);
1884: TREE_INT_CST_LOW (TYPE_MAX_VALUE (enumtype)) = maxvalue;
1885:
1886: current_enum_type = 0;
1887:
1888: return enumtype;
1889: }
1890:
1891: /* Build and install a CONST_DECL for one value of the
1892: current enumeration type (one that was begun with start_enum).
1893: Return a tree-list containing the name and its value.
1894: Assignment of sequential values by default is handled here. */
1895:
1896: tree
1897: build_enumerator (name, value)
1898: tree name, value;
1899: {
1900: register tree decl;
1901:
1902: /* Validate and default VALUE. */
1903:
1904: if (value != 0 && TREE_CODE (value) != INTEGER_CST)
1905: {
1906: yyerror ("enumerator value for %s not integer constant",
1907: IDENTIFIER_POINTER (name));
1908: value = 0;
1909: }
1910:
1911: if (value == 0)
1912: value = build_int_2 (enum_next_value, 0);
1913:
1914: /* Set default for following value. */
1915:
1916: enum_next_value = TREE_INT_CST_LOW (value) + 1;
1917:
1918: /* Now create a declaration for the enum value name. */
1919:
1920: decl = build_decl (CONST_DECL, name,
1921: current_enum_type, 0, 0);
1922: DECL_INITIAL (decl) = value;
1923: TREE_TYPE (value) = current_enum_type;
1924: pushdecl (decl);
1925:
1926: return build_tree_list (name, value);
1927: }
1928:
1929: /* Create the FUNCTION_DECL for a function definition.
1930: LINE1 is the line number that the definition absolutely begins on.
1931: LINE2 is the line number that the name of the function appears on.
1932: DECLSPECS and DECLARATOR are the parts of the declaration;
1933: they describe the function's name and the type it returns,
1934: but twisted together in a fashion that parallels the syntax of C.
1935:
1936: This function creates a binding context for the function body
1937: as well as setting up the FUNCTION_DECL in current_function_decl.
1938:
1939: Returns 1 on success. If the DECLARATOR is not suitable for a function
1940: (it defines a datum instead), we return 0, which tells
1941: yyparse to report a parse error. */
1942:
1943: int
1944: start_function (declspecs, declarator)
1945: tree declarator, declspecs;
1946: {
1947: tree pushed_decl, decl1;
1948:
1949: current_function_returns_value = 0; /* assume it doesn't until we see it does. */
1950:
1951: decl1 = grokdeclarator (declarator, declspecs, NORMAL);
1952: if (TREE_CODE (decl1) != FUNCTION_DECL)
1953: return 0;
1954:
1955: current_function_decl = decl1;
1956:
1957: announce_function (current_function_decl);
1958:
1959: /* Make the init_value nonzero so pushdecl knows this is not tentative.
1960: 1 is not a legitimate value,
1961: but it is replaced below with the LET_STMT. */
1962: DECL_INITIAL (current_function_decl) = (tree)1;
1963: pushed_decl = pushdecl (current_function_decl);
1964:
1965: /* If this is an erroneous redeclaration of something not a function,
1966: return the original declaration (that nobody else can see)
1967: to avoid bombing out reading in the body of the function. */
1968:
1969: if (TREE_CODE (pushed_decl) == FUNCTION_DECL)
1970: current_function_decl = pushed_decl;
1971:
1972: pushlevel ();
1973:
1974: make_function_rtl (current_function_decl);
1975:
1976: /* Allocate further tree nodes temporarily during compilation
1977: of this function only. */
1978: temporary_allocation ();
1979:
1980: current_block = build_let (NULL, NULL, NULL, NULL, NULL, NULL);
1981: DECL_INITIAL (current_function_decl) = current_block;
1982: DECL_RESULT (current_function_decl)
1983: = build_decl (RESULT_DECL, value_identifier,
1984: TREE_TYPE (TREE_TYPE (current_function_decl)), 0, 0);
1985:
1986: /* Make the FUNCTION_DECL's contents appear in a local tree dump
1987: and make the FUNCTION_DECL itself not appear in the permanent dump. */
1988:
1989: TREE_PERMANENT (current_function_decl) = 0;
1990:
1991: /* Must mark the RESULT_DECL as being in this function. */
1992:
1993: DECL_CONTEXT (DECL_RESULT (current_function_decl)) = current_block;
1994:
1995: return 1;
1996: }
1997:
1998: /* Store the parameter declarations into the current function declaration.
1999: This is called after parsing the parameter declarations, before
2000: digesting the body of the function. */
2001:
2002: void
2003: store_parm_decls ()
2004: {
2005: register tree parmdecls = getdecls ();
2006: register tree fndecl = current_function_decl;
2007: register tree block = DECL_INITIAL (fndecl);
2008: register tree parm;
2009:
2010: /* First match each formal parameter name with its declaration.
2011: The DECL_ARGUMENTS is a chain of TREE_LIST nodes
2012: each with a parm name as the TREE_VALUE.
2013: (A declared type may be in the TREE_PURPOSE.)
2014:
2015: Associate decls with the names and store the decls
2016: into the TREE_PURPOSE slots. */
2017:
2018: for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
2019: {
2020: register tree tail, found = NULL;
2021:
2022: if (TREE_VALUE (parm) == 0)
2023: {
2024: yylineerror (DECL_SOURCE_LINE (fndecl),
2025: "parameter name missing from parameter list");
2026: TREE_PURPOSE (parm) = 0;
2027: continue;
2028: }
2029:
2030: /* See if any of the parmdecls specifies this parm by name. */
2031: for (tail = parmdecls; tail; tail = TREE_CHAIN (tail))
2032: if (DECL_NAME (tail) == TREE_VALUE (parm))
2033: {
2034: found = tail;
2035: break;
2036: }
2037:
2038: /* If declaration already marked, we have a duplicate name.
2039: Complain, and don't use this decl twice. */
2040: if (found && DECL_CONTEXT (found) != 0)
2041: {
2042: yylineerror (DECL_SOURCE_LINE (fndecl),
2043: "multiple parameters named %s",
2044: IDENTIFIER_POINTER (TREE_VALUE (parm)));
2045: found = 0;
2046: }
2047:
2048: /* See if the type was given in the arglist.
2049: If so, that overrides any parmdecl. */
2050: if (TREE_PURPOSE (parm) != 0)
2051: {
2052: /* Error to have type in the arglist and have a parmdecl. */
2053: if (found)
2054: yylineerror (DECL_SOURCE_LINE (fndecl),
2055: "type for parameter %s given twice",
2056: IDENTIFIER_POINTER (TREE_VALUE (parm)));
2057:
2058: found = build_decl (PARM_DECL, TREE_VALUE (parm),
2059: TREE_PURPOSE (parm), 0, 0);
2060: DECL_ARG_TYPE (found) == TREE_TYPE (found);
2061:
2062: DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
2063: DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
2064: /* Note that this pushdecl is needed despite the storedecls below
2065: in order to make the name know about its decl. */
2066: pushdecl (found);
2067: }
2068:
2069: /* If no declaration found, default to int. */
2070: if (!found)
2071: {
2072: found = build_decl (PARM_DECL, TREE_VALUE (parm),
2073: integer_type_node, 0, 0);
2074: DECL_ARG_TYPE (found) = TREE_TYPE (found);
2075: DECL_SOURCE_LINE (found) = DECL_SOURCE_LINE (fndecl);
2076: DECL_SOURCE_FILE (found) = DECL_SOURCE_FILE (fndecl);
2077: pushdecl (found);
2078: }
2079:
2080: TREE_PURPOSE (parm) = found;
2081:
2082: /* Mark this declaration as belonging to this function. */
2083:
2084: DECL_CONTEXT (found) = block;
2085: }
2086:
2087: /* Complain about declarations not matched with any names. */
2088:
2089: for (parm = parmdecls; parm; parm = TREE_CHAIN (parm))
2090: {
2091: if (DECL_CONTEXT (parm) == 0)
2092: yylineerror (DECL_SOURCE_LINE (parm),
2093: "declaration for parameter %s but no such parameter",
2094: IDENTIFIER_POINTER (DECL_NAME (parm)));
2095: }
2096:
2097: /* Chain the declarations together in the order of the list of names. */
2098: /* Store that chain in the function decl, replacing the list of names. */
2099: parm = DECL_ARGUMENTS (fndecl);
2100: DECL_ARGUMENTS (fndecl) = 0;
2101: {
2102: register tree last;
2103: for (last = 0; parm; parm = TREE_CHAIN (parm))
2104: if (TREE_PURPOSE (parm))
2105: {
2106: if (last == 0)
2107: DECL_ARGUMENTS (fndecl) = TREE_PURPOSE (parm);
2108: else
2109: TREE_CHAIN (last) = TREE_PURPOSE (parm);
2110: last = TREE_PURPOSE (parm);
2111: TREE_CHAIN (last) = 0;
2112: }
2113: }
2114:
2115: /* Now store the final chain of decls for the arguments
2116: as the decl-chain of the current lexical scope. */
2117:
2118: storedecls (DECL_ARGUMENTS (fndecl));
2119:
2120: /* Compute the offset of each parameter wrt the entire arglist
2121: and store it in the parameter's decl node. */
2122:
2123: layout_parms (fndecl);
2124: }
2125:
2126: /* Finish up a function declaration and compile that function
2127: all the way to assembler language output. The free the storage
2128: for the function definition.
2129:
2130: This is called after parsing the body of the function definition.
2131: STMTS is the chain of statements that makes up the function body. */
2132:
2133: void
2134: finish_function (filename, line, stmts)
2135: char *filename;
2136: int line;
2137: tree stmts;
2138: {
2139: register tree fndecl = current_function_decl;
2140: register tree block = DECL_INITIAL (fndecl);
2141: int old_uid;
2142:
2143: register tree link;
2144:
2145: /* TREE_READONLY (fndecl) = 1;
2146: This caused &foo to be of type ptr-to-const-function
2147: which then got a warning when stored in a ptr-to-function variable. */
2148:
2149: TREE_EXTERNAL (fndecl) = 0;
2150: TREE_STATIC (fndecl) = 1;
2151:
2152: finish_block (block, NULL_TREE, NULL, stmts);
2153:
2154: DECL_SOURCE_FILE (block) = filename;
2155: DECL_SOURCE_LINE (block) = line;
2156:
2157: poplevel ();
2158: current_switch_stmt = NULL;
2159: current_block = NULL;
2160:
2161: rest_of_compilation (fndecl, 1);
2162:
2163: /* Free all the tree nodes making up this function. */
2164: /* Switch back to allocating nodes permanently
2165: until we start another function. */
2166: permanent_allocation ();
2167:
2168: /* Stop pointing to the local nodes about to be freed. */
2169: /* But DECL_INITIAL must remain nonzero so we know this
2170: was an actual function definition. */
2171: DECL_INITIAL (fndecl) = (tree) 1;
2172: DECL_ARGUMENTS (fndecl) = 0;
2173: DECL_RESULT (fndecl) = 0;
2174: }
2175:
2176: tree
2177: implicitly_declare (functionid)
2178: tree functionid;
2179: {
2180: register tree decl
2181: = build_decl (FUNCTION_DECL, functionid,
2182: default_function_type, 0, 1);
2183:
2184: /* ANSI standard says implicit declarations are in the innermost block */
2185: pushdecl (decl);
2186: return decl;
2187: }
2188:
2189: /* Return nonzero if the declaration new is legal
2190: when the declaration old (assumed to be for the same name)
2191: has already been seen. */
2192:
2193: int
2194: allowed_redeclaration (new, old, global)
2195: tree new, old;
2196: int global;
2197: {
2198: if (!comptypes (TREE_TYPE (new), TREE_TYPE (old)))
2199: return 0;
2200:
2201: if (global)
2202: {
2203: /* Reject two definitions. */
2204: if (DECL_INITIAL (old) != 0 && DECL_INITIAL (new) != 0)
2205: return 0;
2206: /* Reject two tentative definitions with different linkage. */
2207: if (!TREE_EXTERNAL (new) && !TREE_EXTERNAL (old)
2208: && TREE_STATIC (old) != TREE_STATIC (new))
2209: return 0;
2210: return 1;
2211: }
2212: else if (TREE_CODE (TREE_TYPE (new)) == FUNCTION_TYPE)
2213: {
2214: /* Declarations of functions inside blocks
2215: are just references, and do not determine linkage. */
2216: return 1;
2217: }
2218: else
2219: {
2220: /* Reject two definitions, and reject a definition
2221: together with an external reference. */
2222: return TREE_EXTERNAL (new) && TREE_EXTERNAL (old);
2223: }
2224: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.