![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tree.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 tree.c CVS log | Up to [GCC 1.x] / gcc |
1.1 root 1: /* Language-indepednent node constructors for parse phase of GNU 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: /* This file contains the low level primitives for operating on tree nodes,
23: including allocation, list operations, interning of identifiers,
24: construction of data type nodes and statement nodes,
25: and construction of type conversion nodes. It also contains
26: tables index by tree code that describe how to take apart
27: nodes of that code.
28:
29: It is intended to be language-independent, but occasionally
30: calls language-dependent routines defined (for C) in typecheck.c.
31:
32: The low-level allocation routines oballoc and permalloc
33: are used also for allocating many other kinds of objects
34: by all passes of the compiler. */
35:
36: #include "config.h"
37: #include <stdio.h>
38: #include "tree.h"
39: #include "obstack.h"
40:
41: #define obstack_chunk_alloc xmalloc
42: #define obstack_chunk_free free
43:
44: extern int xmalloc ();
45: extern void free ();
46:
47: /* Tree nodes of permanent duration are allocated in this obstack.
48: They are the identifier nodes, and everything outside of
49: the bodies and parameters of function definitions. */
50:
51: struct obstack permanent_obstack;
52:
53: /* The contents of the current function definition are allocated
54: in this obstack, and all are freed at the end of the function. */
55:
56: struct obstack temporary_obstack;
57:
58: /* This points at either permanent_obstack or temporary_obstack. */
59:
60: struct obstack *current_obstack;
61:
62: /* Table indexed by tree code giving a string containing a character
63: classifying the tree code. Possibilities are
64: t, d, s, c, r and e. See tree.def for details. */
65:
66: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
67:
68: char *tree_code_type[] = {
69: #include "tree.def"
70: };
71: #undef DEFTREECODE
72:
73: /* Table indexed by tree code giving number of expression
74: operands beyond the fixed part of the node structure.
75: Not used for types or decls. */
76:
77: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
78:
79: int tree_code_length[] = {
80: #include "tree.def"
81: };
82: #undef DEFTREECODE
83:
84: /* Counter for assigning unique ids to all tree nodes. */
85:
86: int tree_node_counter = 0;
87:
88: /* Hash table for uniquizing IDENTIFIER_NODEs by name. */
89:
90: #define MAX_HASH_TABLE 1008
91: static tree hash_table[MAX_HASH_TABLE]; /* id hash buckets */
92:
93: /* Init data for node creation, at the beginning of compilation. */
94:
95: void
96: init_tree ()
97: {
98: obstack_init (&permanent_obstack);
99: current_obstack = &permanent_obstack;
100: tree_node_counter = 1;
101: bzero (hash_table, sizeof hash_table);
102: }
103:
104: /* Start allocating on the temporary (per function) obstack.
105: This is done in start_function before parsing the function body. */
106:
107: temporary_allocation ()
108: {
109: /* Set up the obstack: */
110: obstack_init (&temporary_obstack);
111:
112: current_obstack = &temporary_obstack;
113: }
114:
115: /* Go back to allocating on the permanent obstack
116: and free everything in the temporary obstack.
117: This is done in finish_function after fully compiling a function. */
118:
119: permanent_allocation ()
120: {
121: /* Free up previous temporary obstack data */
122: obstack_free (&temporary_obstack, NULL);
123:
124: current_obstack = &permanent_obstack;
125: }
126:
127: /* Allocate SIZE bytes in the current obstack
128: and return a pointer to them.
129: In practice the current obstack is always the temporary one. */
130:
131: char *
132: oballoc (size)
133: int size;
134: {
135: return (char *) obstack_alloc (current_obstack, size);
136: }
137:
138: /* Free the object PTR in the current obstack
139: as well as everything allocated since PTR.
140: In practice the current obstack is always the temporary one. */
141:
142: void
143: obfree (ptr)
144: char *ptr;
145: {
146: obstack_free (current_obstack, ptr);
147: }
148:
149: /* Allocate SIZE bytes in the permanent obstack
150: and return a pointer to them. */
151:
152: char *
153: permalloc (size)
154: long size;
155: {
156: char *object;
157:
158: return (char *) obstack_alloc (&permanent_obstack, size);
159: }
160:
161: /* Return a newly allocated node of code CODE.
162: Initialize the node's unique id and its TREE_PERMANENT flag.
163: For decl and type nodes, some other fields are initialized.
164: The rest of the node is initialized to zero.
165:
166: Achoo! I got a code in the node. */
167:
168: tree
169: make_node (code)
170: enum tree_code code;
171: {
172: register tree t;
173: register int type = *tree_code_type[(int) code];
174: register int length;
175: register struct obstack *obstack;
176: register int i;
177:
178: switch (type)
179: {
180: case 'd': /* A decl node */
181: length = sizeof (struct tree_decl);
182: break;
183:
184: case 't': /* a type node */
185: length = sizeof (struct tree_type);
186: break;
187:
188: case 's': /* a stmt node */
189: length = sizeof (struct tree_shared)
190: + 2 * sizeof (int)
191: + tree_code_length[(int) code] * sizeof (char *);
192: break;
193:
194: default: /* an expression or constant. */
195: length = sizeof (struct tree_shared)
196: + tree_code_length[(int) code] * sizeof (char *);
197: }
198:
199: obstack = (code != IDENTIFIER_NODE) ? current_obstack : &permanent_obstack;
200:
201: t = (tree) obstack_alloc (obstack, length);
202:
203: TREE_UID (t) = tree_node_counter++;
204: TREE_TYPE (t) = 0;
205: TREE_CHAIN (t) = 0;
206: for (i = (length / sizeof (int)) - 1;
207: i >= sizeof (struct tree_shared) / sizeof (int) - 1;
208: i--)
209: ((int *) t)[i] = 0;
210:
211: TREE_SET_CODE (t, code);
212: if (obstack == &permanent_obstack)
213: TREE_PERMANENT (t) = 1;
214:
215: if (type == 'd')
216: {
217: extern int lineno;
218:
219: DECL_ALIGN (t) = 1;
220: DECL_SIZE_UNIT (t) = 1;
221: DECL_VOFFSET_UNIT (t) = 1;
222: DECL_SOURCE_LINE (t) = lineno;
223: DECL_SOURCE_FILE (t) = input_filename;
224: }
225:
226: if (type == 't')
227: {
228: TYPE_ALIGN (t) = 1;
229: TYPE_SIZE_UNIT (t) = 1;
230: TYPE_SEP_UNIT (t) = 1;
231: TYPE_MAIN_VARIANT (t) = t;
232: }
233:
234: if (type == 'c')
235: {
236: TREE_LITERAL (t) = 1;
237: }
238:
239: return t;
240: }
241:
242: /* Return a new node with the same contents as NODE
243: except that its TREE_CHAIN is zero and it has a fresh uid. */
244:
245: tree
246: copy_node (node)
247: tree node;
248: {
249: register tree t;
250: register enum tree_code code = TREE_CODE (node);
251: register int length;
252: register int i;
253:
254: switch (*tree_code_type[(int) code])
255: {
256: case 'd': /* A decl node */
257: length = sizeof (struct tree_decl);
258: break;
259:
260: case 't': /* a type node */
261: length = sizeof (struct tree_type);
262: break;
263:
264: case 's':
265: length = sizeof (struct tree_shared)
266: + 2 * sizeof (int)
267: + tree_code_length[(int) code] * sizeof (char *);
268: break;
269:
270: default: /* a statement, expression or constant. */
271: length = sizeof (struct tree_shared)
272: + tree_code_length[(int) code] * sizeof (char *);
273: }
274:
275: t = (tree) obstack_alloc (current_obstack, length);
276:
277: for (i = (length / sizeof (int)) - 1;
278: i >= 0;
279: i--)
280: ((int *) t)[i] = ((int *) node)[i];
281:
282: TREE_UID (t) = tree_node_counter++;
283: TREE_CHAIN (t) = 0;
284:
285: TREE_PERMANENT (t) = (current_obstack == &permanent_obstack);
286:
287: return t;
288: }
289:
290: #define HASHBITS 30
291:
292: /* Return an IDENTIFIER_NODE whose name is TEXT (a null-terminated string).
293: If an identifier with that name has previously been referred to,
294: the same node is returned this time. */
295:
296: tree
297: get_identifier (text)
298: register char *text;
299: {
300: register int hi;
301: register int i;
302: register tree idp;
303: register int len;
304:
305: /* Compute length of text in len. */
306: for (len = 0; text[len]; len++);
307:
308: /* Compute hash code */
309: hi = len;
310: for (i = 0; i < len; i++)
311: hi = ((hi * 613) + (unsigned)(text[i]));
312:
313: hi &= (1 << HASHBITS) - 1;
314: hi %= MAX_HASH_TABLE;
315:
316: /* Search table for identifier */
317: for (idp = hash_table[hi]; idp!=NULL; idp = TREE_CHAIN (idp))
318: if (IDENTIFIER_LENGTH (idp) == len &&
319: !strcmp (IDENTIFIER_POINTER (idp), text))
320: return idp; /* <-- return if found */
321:
322: /* Not found, create one, add to chain */
323: idp = make_node (IDENTIFIER_NODE);
324: IDENTIFIER_LENGTH (idp) = len;
325:
326: IDENTIFIER_POINTER (idp) = obstack_copy0 (&permanent_obstack, text, len);
327:
328: TREE_CHAIN (idp) = hash_table[hi];
329: hash_table[hi] = idp;
330: return idp; /* <-- return if created */
331: }
332:
333: /* Return a newly constructed INTEGER_CST node whose constant value
334: is specified by the two ints LOW and HI.
335: The TREE_TYPE is not initialized. */
336:
337: tree
338: build_int_2 (low, hi)
339: int low, hi;
340: {
341: register tree t = make_node (INTEGER_CST);
342: TREE_INT_CST_LOW (t) = low;
343: TREE_INT_CST_HIGH (t) = hi;
344: TREE_TYPE (t) = integer_type_node;
345: return t;
346: }
347:
348: /* Return a REAL_CST node containing a value atoi (STR) * 10**EX.
349: The TREE_TYPE is not initialized. */
350:
351: tree
352: build_real_from_string (str, ex)
353: char *str;
354: int ex;
355: {
356: double r;
357: int i;
358: tree t;
359:
360: t = make_node (REAL_CST);
361: /* ??? This conversion code is not good.
362: Use the new atof once it is done. */
363: sscanf (str, "%lf", &r);
364: if (0 < ex)
365: for (i = 0; i < ex; i++)
366: r = r * 10;
367: else
368: for (i = 0; i < -ex; i++)
369: r = r / 10;
370:
371: TREE_REAL_CST (t) = r;
372: return (t);
373: }
374:
375: /* Return a newly constructed REAL_CST node whose value is D.
376: The TREE_TYPE is not initialized. */
377:
378: tree
379: build_real (d)
380: double d;
381: {
382: tree v;
383:
384: v = make_node (REAL_CST);
385: TREE_REAL_CST (v) = d;
386: return v;
387: }
388:
389: /* Return a newly constructed REAL_CST node whose value
390: is the integer value of the INTEGER_CST node I.
391: The TREE_TYPE is not initialized. */
392:
393: tree
394: build_real_from_int_cst (i)
395: tree i;
396: {
397: tree v;
398:
399: v = make_node (REAL_CST);
400: TREE_REAL_CST (v)
401: = (double) TREE_INT_CST_LOW (i)
402: + ((double) (1 << (HOST_BITS_PER_INT / 2))
403: * (double) (1 << (HOST_BITS_PER_INT / 2))
404: * (double) TREE_INT_CST_HIGH (i));
405: return v;
406: }
407:
408: /* Return a newly constructed STRING_CST node whose value is
409: the LEN characters at STR.
410: The TREE_TYPE is not initialized. */
411:
412: tree
413: build_string (len, str)
414: int len;
415: char *str;
416: {
417: register tree s = make_node (STRING_CST);
418: TREE_STRING_LENGTH (s) = len;
419: TREE_STRING_POINTER (s) = obstack_copy0 (current_obstack, str, len);
420: return s;
421: }
422:
423: /* Return a newly constructed COMPLEX_CST node whose value is
424: specified by the real and imaginary parts REAL and IMAG.
425: Both REAL and IMAG should be constant nodes.
426: The TREE_TYPE is not initialized. */
427:
428: tree
429: build_complex (real, imag)
430: tree real, imag;
431: {
432: register tree t = make_node (COMPLEX_CST);
433: TREE_REALPART (t) = real;
434: TREE_IMAGPART (t) = imag;
435: return t;
436: }
437:
438: /* Return nonzero if the type FTYPE is unsigned (all possible values >= 0).
439: Nonscalar types are considered unsigned; real types considered signed. */
440:
441: int
442: type_unsigned_p (ftype)
443: tree ftype;
444: {
445: register tree type = ftype;
446: register tree t;
447:
448: if (TREE_CODE (ftype) == POINTER_TYPE)
449: return 1;
450: if (TREE_CODE (ftype) == REAL_TYPE)
451: return 0;
452: if (TREE_CODE (ftype) != INTEGER_TYPE
453: && TREE_CODE (ftype) != ENUMERAL_TYPE)
454: return 1;
455:
456: while (1)
457: {
458: t = TYPE_MIN_VALUE (type);
459: if (TREE_CODE (t) == INTEGER_CST)
460: return TREE_INT_CST_HIGH (t) >= 0;
461:
462: type = TREE_TYPE (type);
463: if (type == 0)
464: return 0;
465: }
466: }
467:
468: /* Return 1 if EXPR is the integer constant zero. */
469:
470: int
471: integer_zerop (expr)
472: tree expr;
473: {
474: return TREE_CODE (expr) == INTEGER_CST
475: && TREE_INT_CST_LOW (expr) == 0
476: && TREE_INT_CST_HIGH (expr) == 0;
477: }
478:
479: /* Return 1 if EXPR is the integer constant one. */
480:
481: int
482: integer_onep (expr)
483: tree expr;
484: {
485: return TREE_CODE (expr) == INTEGER_CST
486: && TREE_INT_CST_LOW (expr) == 1
487: && TREE_INT_CST_HIGH (expr) == 0;
488: }
489:
490: /* Return 1 if EXPR is an integer containing all 1's
491: in as much precision as it contains. */
492:
493: int
494: integer_all_onesp (expr)
495: tree expr;
496: {
497: register int prec;
498: register int uns;
499:
500: if (TREE_CODE (expr) != INTEGER_CST)
501: return 0;
502:
503: uns = type_unsigned_p (TREE_TYPE (expr));
504: if (!uns)
505: return TREE_INT_CST_LOW (expr) == -1 && TREE_INT_CST_HIGH (expr) == -1;
506:
507: prec = TYPE_PRECISION (TREE_TYPE (expr));
508: if (prec >= HOST_BITS_PER_INT)
509: return TREE_INT_CST_LOW (expr) == -1
510: && TREE_INT_CST_HIGH (expr) == (1 << (prec - HOST_BITS_PER_INT)) - 1;
511: else
512: return TREE_INT_CST_LOW (expr) == (1 << prec) - 1;
513: }
514:
515: /* Return the length of a chain of nodes chained through TREE_CHAIN.
516: We expect a null pointer to mark the end of the chain.
517: This is the Lisp primitive `length'. */
518:
519: int
520: list_length (t)
521: tree t;
522: {
523: register tree tail;
524: register int len = 0;
525:
526: for (tail = t; tail; tail = TREE_CHAIN (tail))
527: len++;
528:
529: return len;
530: }
531:
532: /* Concatenate two chains of nodes (chained through TREE_CHAIN)
533: by modifying the last node in chain 1 to point to chain 2.
534: This is the Lisp primitive `nconc'. */
535:
536: tree
537: chainon (op1, op2)
538: tree op1, op2;
539: {
540: tree t;
541:
542: if (op1)
543: {
544: for (t = op1; TREE_CHAIN (t); t = TREE_CHAIN (t))
545: if (t == op2) abort (); /* Circularity being created */
546: TREE_CHAIN (t) = op2;
547: return op1;
548: }
549: else return op2;
550: }
551:
552: /* Return a newly created TREE_LIST node whose
553: purpose and value fields are PARM and VALUE. */
554:
555: tree
556: build_tree_list (parm, value)
557: tree parm, value;
558: {
559: register tree t = make_node (TREE_LIST);
560: TREE_PURPOSE (t) = parm;
561: TREE_VALUE (t) = value;
562: return t;
563: }
564:
565: /* Return a newly created TREE_LIST node whose
566: purpose and value fields are PARM and VALUE
567: and whose TREE_CHAIN is CHAIN. */
568:
569: tree
570: tree_cons (purpose, value, chain)
571: tree purpose, value, chain;
572: {
573: register tree node = make_node (TREE_LIST);
574: TREE_CHAIN (node) = chain;
575: TREE_PURPOSE (node) = purpose;
576: TREE_VALUE (node) = value;
577: return node;
578: }
579:
580: /* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
581:
582: tree
583: tree_last (chain)
584: register tree chain;
585: {
586: register tree next;
587: if (chain)
588: while (next = TREE_CHAIN (chain))
589: chain = next;
590: return chain;
591: }
592:
593: /* Reverse the order of elements in the chain T,
594: and return the new head of the chain (old last element). */
595:
596: tree
597: nreverse (t)
598: tree t;
599: {
600: register tree prev = 0, decl, next;
601: for (decl = t; decl; decl = next)
602: {
603: next = TREE_CHAIN (decl);
604: TREE_CHAIN (decl) = prev;
605: prev = decl;
606: }
607: return prev;
608: }
609:
610: /* Return the size nominally occupied by an object of type TYPE
611: when it resides in memory. The value is measured in units of bytes,
612: and its data type is that normally used for type sizes
613: (which is the first type created by make_signed_type or
614: make_unsigned_type). */
615:
616: tree
617: size_in_bytes (type)
618: tree type;
619: {
620: if (type == error_mark_node)
621: return integer_zero_node;
622: return convert_units (TYPE_SIZE (type), TYPE_SIZE_UNIT (type),
623: BITS_PER_UNIT);
624: }
625:
626: /* Return nonzero if arg is static -- a reference to an object in
627: static storage. This is not the same as the C meaning of `static'. */
628:
629: int
630: staticp (arg)
631: tree arg;
632: {
633: register enum tree_code code = TREE_CODE (arg);
634:
635: if ((code == VAR_DECL || code == FUNCTION_DECL)
636: && (TREE_STATIC (arg) || TREE_EXTERNAL (arg)))
637: return 1;
638:
639: if (code == COMPONENT_REF)
640: return staticp (TREE_OPERAND (arg, 0));
641:
642: return 0;
643: }
644:
645: /* Verify that an expression, REF, is a reference to data that makes sense
646: to modify or take the address of
647: (i.e., for processing the argument to unary & or the left arg to =).
648: Error if REF is some other kind of expression.
649:
650: We can safely ignore the difference between "makes sense to modify"
651: and "makes sense to take the address of", because attempting to
652: take the address of a variable will force it into memory anyway. */
653:
654: int
655: lvalue_or_else (ref)
656: tree ref;
657: {
658: register enum tree_code code = TREE_CODE (ref);
659:
660: if (code == COMPONENT_REF)
661: return lvalue_or_else (TREE_OPERAND (ref, 0));
662: else if (code == INDIRECT_REF || code == ARRAY_REF || code == VAR_DECL
663: || code == FUNCTION_DECL || code == PARM_DECL || code == RESULT_DECL
664: || code == ERROR_MARK)
665: return 1;
666: yyerror ("invalid lvalue (not a reference to data in memory)");
667: return 0;
668: }
669:
670: /* This should be applied to any node which may be used in more than one place,
671: but must be evaluated only once. Normally, the code generator would
672: reevaluate the node each time; this forces it to compute it once and save
673: the result. This is done by encapsulating the node in a SAVE_EXPR. */
674:
675: tree
676: save_expr (expr)
677: tree expr;
678: {
679: register tree t = fold (expr);
680:
681: /* If the tree evaluates to a constant, then we don't what to hide that
682: fact (i.e. this allows further folding, and direct checks for constants).
683: Since it is no problem to reevaluate literals, we just return the
684: literal node. */
685:
686: if (TREE_LITERAL (t) || TREE_READONLY (t) || TREE_CODE (t) == SAVE_EXPR)
687: return t;
688:
689: t = build2 (SAVE_EXPR, t, NULL);
690: TREE_TYPE (t) = TREE_TYPE (expr);
691: TREE_VOLATILE (t) = TREE_VOLATILE (expr);
692: return t;
693: }
694:
695: /* Stabilize a reference so that we can use it any number of times
696: without causing its operands to be evaluated more than once.
697: Returns the stabilized reference. */
698:
699: tree
700: stabilize_reference (ref)
701: tree ref;
702: {
703: register tree result;
704: register enum tree_code code = TREE_CODE (ref);
705:
706: if (code == INDIRECT_REF)
707: {
708: result = build1 (INDIRECT_REF, save_expr (TREE_OPERAND (ref, 0)));
709: }
710: else if (code == COMPONENT_REF)
711: {
712: result = build2 (COMPONENT_REF,
713: stabilize_reference (TREE_OPERAND (ref, 0)),
714: TREE_OPERAND (ref, 1));
715: }
716: else if (code == ARRAY_REF)
717: {
718: result = build2 (ARRAY_REF, save_expr (TREE_OPERAND (ref, 0)),
719: save_expr (TREE_OPERAND (ref, 1)));
720: }
721: else if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
722: {
723: result = ref;
724: }
725: else
726: {
727: if (code != ERROR_MARK)
728: yyerror ("invalid lvalue (not a reference to data in memory)");
729: return error_mark_node;
730: }
731:
732: TREE_TYPE (result) = TREE_TYPE (ref);
733: TREE_VOLATILE (result) = TREE_VOLATILE (ref);
734:
735: return result;
736: }
737:
738: /* Low-level constructors for expressions. */
739:
740: /* Return a newly created expression-node of code SC and operand ARG1.
741: Used for codes that want one operand.
742: The TREE_TYPE is not initialized. */
743:
744: tree
745: build1 (sc, arg1)
746: enum tree_code sc;
747: tree arg1;
748: {
749: register tree t = make_node (sc);
750:
751: TREE_OPERAND (t, 0) = arg1;
752: return t;
753: }
754:
755: /* Return a newly created expression-node of code SC
756: and operands ARG1 and ARG2.
757: Used for codes that want two operands.
758: The TREE_TYPE is not initialized. */
759:
760: tree
761: build2 (sc, arg1, arg2)
762: enum tree_code sc;
763: tree arg1, arg2;
764: {
765: register tree t = make_node (sc);
766:
767: TREE_OPERAND (t, 0) = arg1;
768: TREE_OPERAND (t, 1) = arg2;
769: return t;
770: }
771:
772: /* Return a newly created expression-node of code SC
773: and operands ARG1, ARG2 and ARG3.
774: Used for codes that want three operands.
775: The TREE_TYPE is not initialized. */
776:
777: tree
778: build3 (sc, arg1, arg2, arg3)
779: int sc;
780: tree arg1, arg2, arg3;
781: {
782: register tree t = make_node (sc);
783:
784: TREE_OPERAND (t, 0) = arg1;
785: TREE_OPERAND (t, 1) = arg2;
786: TREE_OPERAND (t, 2) = arg3;
787: return t;
788: }
789:
790: /* Low-level constructors for statements.
791: These constructors all expect source file name and line number
792: as arguments, as well as enough arguments to fill in the data
793: in the statement node. */
794:
795: tree
796: build_goto (filename, line, label)
797: char *filename;
798: int line;
799: tree label;
800: {
801: register tree t = make_node (GOTO_STMT);
802: STMT_SOURCE_FILE (t) = filename;
803: STMT_SOURCE_LINE (t) = line;
804: STMT_BODY (t) = label;
805: return t;
806: }
807:
808: tree
809: build_return (filename, line, arg)
810: char *filename;
811: int line;
812: tree arg;
813: {
814: register tree t = make_node (RETURN_STMT);
815:
816: STMT_SOURCE_FILE (t) = filename;
817: STMT_SOURCE_LINE (t) = line;
818: STMT_BODY (t) = arg;
819: return t;
820: }
821:
822: tree
823: build_expr_stmt (filename, line, expr)
824: char *filename;
825: int line;
826: tree expr;
827: {
828: register tree t = make_node (EXPR_STMT);
829:
830: STMT_SOURCE_FILE (t) = filename;
831: STMT_SOURCE_LINE (t) = line;
832: STMT_BODY (t) = expr;
833: return t;
834: }
835:
836: tree
837: build_if (filename, line, cond, thenclause, elseclause)
838: char *filename;
839: int line;
840: tree cond, thenclause, elseclause;
841: {
842: register tree t = make_node (IF_STMT);
843:
844: STMT_SOURCE_FILE (t) = filename;
845: STMT_SOURCE_LINE (t) = line;
846: STMT_COND (t) = cond;
847: STMT_THEN (t) = thenclause;
848: STMT_ELSE (t) = elseclause;
849: return t;
850: }
851:
852: tree
853: build_exit (filename, line, cond)
854: char *filename;
855: int line;
856: tree cond;
857: {
858: register tree t = make_node (EXIT_STMT);
859: STMT_SOURCE_FILE (t) = filename;
860: STMT_SOURCE_LINE (t) = line;
861: STMT_BODY (t) = cond;
862: return t;
863: }
864:
865: tree
866: build_asm_stmt (filename, line, asmcode)
867: char *filename;
868: int line;
869: tree asmcode;
870: {
871: register tree t = make_node (ASM_STMT);
872: STMT_SOURCE_FILE (t) = filename;
873: STMT_SOURCE_LINE (t) = line;
874: STMT_BODY (t) = asmcode;
875: return t;
876: }
877:
878: tree
879: build_case (filename, line, object, cases)
880: char *filename;
881: int line;
882: tree object, cases;
883: {
884: register tree t = make_node (CASE_STMT);
885: STMT_SOURCE_FILE (t) = filename;
886: STMT_SOURCE_LINE (t) = line;
887: STMT_CASE_INDEX (t) = object;
888: STMT_CASE_LIST (t) = cases;
889: return t;
890: }
891:
892: tree
893: build_let (filename, line, vars, body, supercontext, tags)
894: char *filename;
895: int line;
896: tree vars, body, supercontext, tags;
897: {
898: register tree t = make_node (LET_STMT);
899: STMT_SOURCE_FILE (t) = filename;
900: STMT_SOURCE_LINE (t) = line;
901: STMT_VARS (t) = vars;
902: STMT_BODY (t) = body;
903: STMT_SUPERCONTEXT (t) = supercontext;
904: STMT_BIND_SIZE (t) = 0;
905: STMT_TYPE_TAGS (t) = tags;
906: return t;
907: }
908:
909: tree
910: build_loop (filename, line, body)
911: char *filename;
912: int line;
913: tree body;
914: {
915: register tree t = make_node (LOOP_STMT);
916: STMT_SOURCE_FILE (t) = filename;
917: STMT_SOURCE_LINE (t) = line;
918: STMT_BODY (t) = body;
919: return t;
920: }
921:
922: tree
923: build_compound (filename, line, body)
924: char *filename;
925: int line;
926: tree body;
927: {
928: register tree t = make_node (COMPOUND_STMT);
929: STMT_SOURCE_FILE (t) = filename;
930: STMT_SOURCE_LINE (t) = line;
931: STMT_BODY (t) = body;
932: return t;
933: }
934:
935: /* Return a type like TYPE except that its TREE_READONLY is CONSTP
936: and its TREE_VOLATILE is VOLATILEP.
937:
938: Such variant types already made are recorded so that duplicates
939: are not made.
940:
941: A variant types should never be used as the type of an expression.
942: Always copy the variant information into the TREE_READONLY
943: and TREE_VOLATILE of the expression, and then give the expression
944: as its type the "main variant", the variant whose TREE_READONLY
945: and TREE_VOLATILE are zero. Use TYPE_MAIN_VARIANT to find the
946: main variant. */
947:
948: tree
949: build_type_variant (type, constp, volatilep)
950: tree type;
951: int constp, volatilep;
952: {
953: register tree t, m = TYPE_MAIN_VARIANT (type);
954: register struct obstack *ambient_obstack = current_obstack;
955:
956: /* Treat any nonzero argument as 1. */
957: constp = !!constp;
958: volatilep = !!volatilep;
959:
960: /* First search the chain variants for one that is what we want. */
961:
962: for (t = m; t; t = TYPE_NEXT_VARIANT (t))
963: if (constp == TREE_READONLY (t)
964: && volatilep == TREE_VOLATILE (t))
965: return t;
966:
967: /* We need a new one. */
968: current_obstack = TREE_PERMANENT (type) ? &permanent_obstack : &temporary_obstack;
969:
970: t = copy_node (type);
971: TREE_READONLY (t) = constp;
972: TREE_VOLATILE (t) = volatilep;
973: TYPE_POINTER_TO (t) = 0;
974:
975: /* Add this type to the chain of variants of TYPE. */
976: TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
977: TYPE_NEXT_VARIANT (m) = t;
978:
979: current_obstack = ambient_obstack;
980: return t;
981: }
982:
983: /* Constructors for pointer, array and function types.
984: (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
985: constructed by language-dependent code, not here.) */
986:
987: tree
988: build_pointer_type (to_type)
989: tree to_type;
990: {
991: register tree t = TYPE_POINTER_TO (to_type);
992: register struct obstack *ambient_obstack = current_obstack;
993:
994: /* First, if we already have a type for pointers to TO_TYPE, use it. */
995:
996: if (t)
997: return t;
998:
999: /* We need a new one. If TO_TYPE is permanent, make this permanent too. */
1000: current_obstack = (TREE_PERMANENT (to_type)
1001: ? &permanent_obstack
1002: : &temporary_obstack);
1003:
1004: t = make_node (POINTER_TYPE);
1005: TREE_TYPE (t) = to_type;
1006:
1007: /* Record this type as the pointer to TO_TYPE. */
1008: TYPE_POINTER_TO (to_type) = t;
1009:
1010: /* If this type is permanent but we are really inside a function,
1011: lay it out now, so that the size, etc. are permanent too. */
1012: if (current_obstack != ambient_obstack)
1013: layout_type (t);
1014:
1015: current_obstack = ambient_obstack;
1016: return t;
1017: }
1018:
1019: tree
1020: build_array_type (elt_type, index_type)
1021: tree elt_type, index_type;
1022: {
1023: register tree t = make_node (ARRAY_TYPE);
1024:
1025: if (TREE_CODE (elt_type) == FUNCTION_TYPE)
1026: {
1027: yyerror ("arrays of functions are not meaningful");
1028: elt_type = integer_type_node;
1029: }
1030:
1031: TREE_TYPE (t) = elt_type;
1032: TYPE_DOMAIN (t) = index_type;
1033: /* Make sure TYPE_POINTER_TO (elt_type) is filled in. */
1034: build_pointer_type (elt_type);
1035: return t;
1036: }
1037:
1038: /* Build a function type, which is a FUNCTION_TYPE node.
1039: The TREE_TYPE of this node is the type of the value returned.
1040: If no value is returned, the TREE_TYPE may be 0 or it
1041: may be a node for a void type.
1042: ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
1043: are data type nodes for the arguments of the function. */
1044:
1045: tree
1046: build_function_type (value_type, arg_types)
1047: tree value_type, arg_types;
1048: {
1049: register tree t;
1050:
1051: if (TREE_CODE (value_type) == FUNCTION_DECL
1052: || TREE_CODE (value_type) == ARRAY_TYPE)
1053: {
1054: yyerror ("function return type cannot be function or array");
1055: value_type = integer_type_node;
1056: }
1057:
1058: t = make_node (FUNCTION_TYPE);
1059: TREE_TYPE (t) = value_type;
1060: TYPE_ARG_TYPES (t) = arg_types;
1061: return t;
1062: }
1063:
1064: /* Return OP, stripped of any conversions to wider types as much as is safe.
1065: Converting the value back to OP's type makes a value equivalent to OP.
1066:
1067: If FOR_TYPE is nonzero, we return a value which, if converted to
1068: type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
1069:
1070: OP must have integer, real or enumeral type. Pointers are not allowed!
1071:
1072: There are some cases where the obvious value we could return
1073: would regenerate to OP if converted to OP's type,
1074: but would not extend like OP to wider types.
1075: If FOR_TYPE indicates such extension is contemplated, we eschew such values.
1076: For example, if OP is (unsigned short)(signed char)-1,
1077: we avoid returning (signed char)-1 if FOR_TYPE is int,
1078: even though extending that to an unsigned short would regenerate OP,
1079: since the result of extending (signed char)-1 to (int)
1080: is different from (int) OP. */
1081:
1082: tree
1083: get_unwidened (op, for_type)
1084: register tree op;
1085: tree for_type;
1086: {
1087: /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
1088: /* TYPE_PRECISION is safe in place of type_precision since
1089: pointer types are not allowed. */
1090: register tree type = TREE_TYPE (op);
1091: register int final_prec = TYPE_PRECISION (for_type != 0 ? for_type : type);
1092: register int uns
1093: = (for_type != 0 && for_type != type
1094: && final_prec > TYPE_PRECISION (type)
1095: && type_unsigned_p (type));
1096: register tree win = op;
1097:
1098: while (TREE_CODE (op) == NOP_EXPR)
1099: {
1100: register int bitschange
1101: = TYPE_PRECISION (TREE_TYPE (op))
1102: - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
1103:
1104: /* Truncations are many-one so cannot be removed.
1105: Unless we are later going to truncate down even farther. */
1106: if (bitschange < 0
1107: && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
1108: break;
1109:
1110: /* See what's inside this conversion. If we decide to strip it,
1111: we will set WIN. */
1112: op = TREE_OPERAND (op, 0);
1113:
1114: /* If we have not stripped any zero-extensions (uns is 0),
1115: we can strip any kind of extension.
1116: If we have previously stripped a zero-extension,
1117: only zero-extensions can safely be stripped.
1118: Any extension can be stripped if the bits it would produce
1119: are all going to be discarded later by truncating to FOR_TYPE. */
1120:
1121: if (bitschange > 0)
1122: {
1123: if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
1124: win = op;
1125: /* type_unsigned_p says whether this is a zero-extension.
1126: Let's avoid computing it if it does not affect WIN
1127: and if UNS will not be needed again. */
1128: if ((uns || TREE_CODE (op) == NOP_EXPR)
1129: && type_unsigned_p (TREE_TYPE (op)))
1130: {
1131: uns = 1;
1132: win = op;
1133: }
1134: }
1135: }
1136:
1137: if (TREE_CODE (op) == COMPONENT_REF)
1138: {
1139: int innerprec = (TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)))
1140: * DECL_SIZE_UNIT (TREE_OPERAND (op, 1)));
1141: type = type_for_size (innerprec, type_unsigned_p (TREE_TYPE (op)));
1142:
1143: /* We can get this structure field in the narrowest type it fits in
1144: but the resulting extension to its nominal type (a fullword type)
1145: must fit the same conditions as for other extensions. */
1146:
1147: if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
1148: && (! uns || final_prec <= innerprec
1149: || type_unsigned_p (TREE_TYPE (op))))
1150: {
1151: if (type != 0)
1152: {
1153: win = build2 (COMPONENT_REF, TREE_OPERAND (op, 0),
1154: TREE_OPERAND (op, 1));
1155: TREE_TYPE (win) = type;
1156: }
1157: }
1158: }
1159: return win;
1160: }
1161:
1162: /* Return OP or a simpler expression for a narrower value
1163: which can be sign-extended or zero-extended to give back OP.
1164: Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
1165: or 0 if the value should be sign-extended. */
1166:
1167: tree
1168: get_narrower (op, unsignedp_ptr)
1169: register tree op;
1170: int *unsignedp_ptr;
1171: {
1172: register int uns = 0;
1173: int first = 1;
1174: register tree win = op;
1175:
1176: while (TREE_CODE (op) == NOP_EXPR)
1177: {
1178: register int bitschange
1179: = TYPE_PRECISION (TREE_TYPE (op))
1180: - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
1181:
1182: /* Truncations are many-one so cannot be removed. */
1183: if (bitschange < 0)
1184: break;
1185:
1186: /* See what's inside this conversion. If we decide to strip it,
1187: we will set WIN. */
1188: op = TREE_OPERAND (op, 0);
1189:
1190: if (bitschange > 0)
1191: {
1192: /* An extension: the outermost one can be stripped,
1193: but remember whether it is zero or sign extension. */
1194: if (first)
1195: uns = type_unsigned_p (TREE_TYPE (op));
1196: /* Otherwise, if a sign extension has been stripped,
1197: only sign extensions can now be stripped;
1198: if a zero extension has been stripped, only zero-extensions. */
1199: else if (uns != type_unsigned_p (TREE_TYPE (op)))
1200: break;
1201: first = 0;
1202: }
1203: /* A change in nominal type can always be stripped. */
1204:
1205: win = op;
1206: }
1207:
1208: if (TREE_CODE (op) == COMPONENT_REF)
1209: {
1210: int innerprec = (TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (op, 1)))
1211: * DECL_SIZE_UNIT (TREE_OPERAND (op, 1)));
1212: tree type = type_for_size (innerprec, type_unsigned_p (TREE_TYPE (op)));
1213:
1214: /* We can get this structure field in a narrower type that fits it,
1215: but the resulting extension to its nominal type (a fullword type)
1216: must satisfy the same conditions as for other extensions. */
1217:
1218: if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
1219: && (first || uns == type_unsigned_p (TREE_TYPE (op)))
1220: && type != 0)
1221: {
1222: win = build2 (COMPONENT_REF, TREE_OPERAND (op, 0),
1223: TREE_OPERAND (op, 1));
1224: TREE_TYPE (win) = type;
1225: }
1226: }
1227: *unsignedp_ptr = uns;
1228: return win;
1229: }
1230:
1231: /* Return the precision of a type, for arithmetic purposes.
1232: Supports all types on which arithmetic is possible
1233: (including pointer types).
1234: It's not clear yet what will be right for complex types. */
1235:
1236: int
1237: type_precision (type)
1238: register tree type;
1239: {
1240: return ((TREE_CODE (type) == INTEGER_TYPE
1241: || TREE_CODE (type) == ENUMERAL_TYPE
1242: || TREE_CODE (type) == REAL_TYPE)
1243: ? TYPE_PRECISION (type) : BITS_PER_WORD);
1244: }
1245:
1246: /* Nonzero if integer constant C has a value that is permissible
1247: for type TYPE (an INTEGER_TYPE). */
1248:
1249: int
1250: int_fits_type_p (c, type)
1251: tree c, type;
1252: {
1253: if (type_unsigned_p (type))
1254: return (!INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)
1255: && !INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type)));
1256: else
1257: return (!INT_CST_LT (TYPE_MAX_VALUE (type), c)
1258: && !INT_CST_LT (c, TYPE_MIN_VALUE (type)));
1259: }
1260:
1261: /* Subroutines of `convert'. */
1262:
1263: /* Change of width--truncation and extension of integers or reals--
1264: is represented with NOP_EXPR. Proper functioning of many things
1265: assumes that no other conversions can be NOP_EXPRs.
1266:
1267: Conversion between integer and pointer is represented with CONVERT_EXPR.
1268: Converting integer to real uses FLOAT_EXPR
1269: and real to integer uses FIX_TRUNC_EXPR. */
1270:
1271: /* Generate an expression for a conversion using expression code CODE.
1272: It will convert EXPR to type TYPE. */
1273:
1274: static tree
1275: build_convert (code, type, expr)
1276: enum tree_code code;
1277: tree type, expr;
1278: {
1279: register tree tem = build1 (code, expr);
1280:
1281: TREE_TYPE (tem) = type;
1282: TREE_VOLATILE (tem) = TREE_VOLATILE (expr);
1283: return tem;
1284: }
1285:
1286: static tree
1287: convert_to_pointer (type, expr)
1288: tree type, expr;
1289: {
1290: register tree intype = TREE_TYPE (expr);
1291: register enum tree_code form = TREE_CODE (intype);
1292:
1293: if (integer_zerop (expr))
1294: {
1295: if (type == TREE_TYPE (null_pointer_node))
1296: return null_pointer_node;
1297: expr = build_int_2 (0, 0);
1298: TREE_TYPE (expr) = type;
1299: return expr;
1300: }
1301:
1302: if (form == POINTER_TYPE)
1303: return build_convert (NOP_EXPR, type, expr);
1304:
1305: if (intype == integer_type_node)
1306: return build_convert (CONVERT_EXPR, type, expr);
1307:
1308: if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
1309: return convert_to_pointer (type, convert (integer_type_node, expr));
1310:
1311: yyerror ("cannot convert to a pointer type");
1312:
1313: return null_pointer_node;
1314: }
1315:
1316: /* The result of this is always supposed to be a newly created tree node
1317: not in use in any existing structure. */
1318:
1319: static tree
1320: convert_to_integer (type, expr)
1321: tree type, expr;
1322: {
1323: register tree intype = TREE_TYPE (expr);
1324: register enum tree_code form = TREE_CODE (intype);
1325: extern tree build_binary_op_nodefault ();
1326: extern tree build_unary_op ();
1327:
1328: if (form == POINTER_TYPE)
1329: {
1330: if (integer_zerop (expr))
1331: expr = integer_zero_node;
1332: else
1333: expr = fold (build_convert (CONVERT_EXPR, integer_type_node, expr));
1334: intype = TREE_TYPE (expr);
1335: form = TREE_CODE (intype);
1336: }
1337:
1338: if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
1339: {
1340: register int outprec = TYPE_PRECISION (type);
1341: register int inprec = TYPE_PRECISION (intype);
1342: register enum tree_code ex_form = TREE_CODE (expr);
1343:
1344: if (outprec >= inprec)
1345: return build_convert (NOP_EXPR, type, expr);
1346:
1347: /* Here detect when we can distribute the truncation down past some arithmetic.
1348: For example, if adding two longs and converting to an int,
1349: we can equally well convert both to ints and then add.
1350: For the operations handled here, such truncation distribution
1351: is always safe.
1352: It is desirable in these cases:
1353: 1) when truncating down to full-word from a larger size
1354: 2) when truncating takes no work.
1355: 3) when at least one operand of the arithmetic has been extended
1356: (as by C's default conversions). In this case we need two conversions
1357: if we do the arithmetic as already requested, so we might as well
1358: truncate both and then combine. Perhaps that way we need only one.
1359:
1360: Note that in general we cannot do the arithmetic in a type
1361: shorter than the desired result of conversion, even if the operands
1362: are both extended from a shorter type, because they might overflow
1363: if combined in that type. The exceptions to this--the times when
1364: two narrow values can be combined in their narrow type even to
1365: make a wider result--are handled by "shorten" in build_binary_op. */
1366:
1367: switch (ex_form)
1368: {
1369: case RSHIFT_EXPR:
1370: /* We can pass truncation down through right shifting
1371: when the shift count is a negative constant. */
1372: if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
1373: || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) > 0)
1374: break;
1375: goto trunc1;
1376:
1377: case LSHIFT_EXPR:
1378: /* We can pass truncation down through left shifting
1379: when the shift count is a positive constant. */
1380: if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
1381: || TREE_INT_CST_LOW (TREE_OPERAND (expr, 1)) < 0)
1382: break;
1383: /* In this case, shifting is like multiplication. */
1384:
1385: case PLUS_EXPR:
1386: case MINUS_EXPR:
1387: case MULT_EXPR:
1388: case MAX_EXPR:
1389: case MIN_EXPR:
1390: case BIT_AND_EXPR:
1391: case BIT_IOR_EXPR:
1392: case BIT_XOR_EXPR:
1393: case BIT_ANDTC_EXPR:
1394: trunc1:
1395: {
1396: tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
1397: tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
1398:
1399: if (outprec >= BITS_PER_WORD
1400: || TRULY_NOOP_TRUNCATION (outprec, inprec)
1401: || inprec > TYPE_PRECISION (TREE_TYPE (arg0))
1402: || inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
1403: {
1404: /* Do the arithmetic in type TYPEX,
1405: then convert result to TYPE. */
1406: register tree typex = type;
1407:
1408: /* Can't do arithmetic in enumeral types
1409: so use an integer type that will hold the values. */
1410: if (TREE_CODE (typex) == ENUMERAL_TYPE)
1411: typex = type_for_size (TYPE_PRECISION (typex));
1412:
1413: /* But now perhaps TYPEX is as wide as INPREC.
1414: In that case, do nothing special here.
1415: (Otherwise would recurse infinitely in convert. */
1416: if (TYPE_PRECISION (typex) != inprec)
1417: {
1418: /* Don't do unsigned arithmetic where signed was wanted,
1419: or vice versa. */
1420: typex = (type_unsigned_p (TREE_TYPE (expr))
1421: ? unsigned_type (typex) : signed_type (typex));
1422: return convert (type,
1423: build_binary_op_nodefault (ex_form,
1424: convert (typex, arg0),
1425: convert (typex, arg1)));
1426: }
1427: }
1428: }
1429: break;
1430:
1431: case EQ_EXPR:
1432: case NE_EXPR:
1433: case GT_EXPR:
1434: case GE_EXPR:
1435: case LT_EXPR:
1436: case LE_EXPR:
1437: case TRUTH_AND_EXPR:
1438: case TRUTH_OR_EXPR:
1439: case TRUTH_NOT_EXPR:
1440: /* If we want result of comparison converted to a byte,
1441: we can just regard it as a byte, since it is 0 or 1. */
1442: TREE_TYPE (expr) = type;
1443: return expr;
1444:
1445: case NEGATE_EXPR:
1446: case BIT_NOT_EXPR:
1447: case ABS_EXPR:
1448: {
1449: register tree typex = type;
1450:
1451: /* Can't do arithmetic in enumeral types
1452: so use an integer type that will hold the values. */
1453: if (TREE_CODE (typex) == ENUMERAL_TYPE)
1454: typex = type_for_size (TYPE_PRECISION (typex));
1455:
1456: /* But now perhaps TYPEX is as wide as INPREC.
1457: In that case, do nothing special here.
1458: (Otherwise would recurse infinitely in convert. */
1459: if (TYPE_PRECISION (typex) != inprec)
1460: {
1461: /* Don't do unsigned arithmetic where signed was wanted,
1462: or vice versa. */
1463: typex = (type_unsigned_p (TREE_TYPE (expr))
1464: ? unsigned_type (typex) : signed_type (typex));
1465: return convert (type,
1466: build_unary_op (ex_form,
1467: convert (typex, TREE_OPERAND (expr, 0)),
1468: 1));
1469: }
1470: }
1471:
1472: case NOP_EXPR:
1473: /* If truncating after truncating, might as well do all at once.
1474: If truncating after extending, we may get rid of wasted work. */
1475: return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
1476: }
1477:
1478: return build_convert (NOP_EXPR, type, expr);
1479: }
1480:
1481: if (form == REAL_TYPE)
1482: return build_convert (FIX_TRUNC_EXPR, type, expr);
1483:
1484: yyerror ("aggregate value used where an integer was expected");
1485:
1486: {
1487: register tree tem = build_int_2 (0, 0);
1488: TREE_TYPE (tem) = type;
1489: return tem;
1490: }
1491: }
1492:
1493: static tree
1494: convert_to_real (type, expr)
1495: tree type, expr;
1496: {
1497: register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
1498:
1499: if (form == REAL_TYPE)
1500: return build_convert (NOP_EXPR, type, expr);
1501:
1502: if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
1503: return build_convert (FLOAT_EXPR, type, expr);
1504:
1505: if (form == POINTER_TYPE)
1506: yyerror ("pointer value used where a float was expected");
1507: else
1508: yyerror ("aggregate value used where a float was expected");
1509:
1510: {
1511: register tree tem = make_node (REAL_CST);
1512: TREE_TYPE (tem) = type;
1513: TREE_REAL_CST (tem) = 0;
1514: return tem;
1515: }
1516: }
1517:
1518: /* Create an expression whose value is that of EXPR,
1519: converted to type TYPE. The TREE_TYPE of the value
1520: is always TYPE. This function implements all reasonable
1521: conversions; callers should filter out those that are
1522: not permitted by the language being compiled. */
1523:
1524: tree
1525: convert (type, expr)
1526: tree type, expr;
1527: {
1528: register tree e = expr;
1529: register enum tree_code code = TREE_CODE (type);
1530:
1531: if (type == TREE_TYPE (expr) || TREE_CODE (expr) == ERROR_MARK)
1532: return expr;
1533: if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
1534: {
1535: yyerror ("void value not ignored as it ought to be");
1536: return error_mark_node;
1537: }
1538: if (code == VOID_TYPE)
1539: return build_convert (CONVERT_EXPR, type, e);
1540: #if 0
1541: /* This is incorrect. A truncation can't be stripped this way.
1542: Extensions will be stripped by the use of get_unwidened. */
1543: if (TREE_CODE (expr) == NOP_EXPR)
1544: return convert (type, TREE_OPERAND (expr, 0));
1545: #endif
1546: if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
1547: return fold (convert_to_integer (type, e));
1548: if (code == POINTER_TYPE)
1549: return fold (convert_to_pointer (type, e));
1550: if (code == REAL_TYPE)
1551: return fold (convert_to_real (type, e));
1552:
1553: yyerror ("conversion to non-scalar type requested");
1554: return error_mark_node;
1555: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.