![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stor-layout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to stor-layout.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* C-compiler utilities for types and variables storage layout
2: Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: #include "config.h"
22: #include <stdio.h>
23:
24: #include "tree.h"
25: #include "function.h"
26:
27: #define CEIL(x,y) (((x) + (y) - 1) / (y))
28:
29: /* Data type for the expressions representing sizes of data types.
30: It is the first integer type laid out.
31: In C, this is int. */
32:
33: tree sizetype;
34:
35: /* An integer constant with value 0 whose type is sizetype. */
36:
37: tree size_zero_node;
38:
39: /* An integer constant with value 1 whose type is sizetype. */
40:
41: tree size_one_node;
42:
43: #define GET_MODE_ALIGNMENT(MODE) \
44: MIN (BIGGEST_ALIGNMENT, \
45: MAX (1, (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT)))
46:
47: /* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */
48:
49: static tree pending_sizes;
50:
51: /* Nonzero means cannot safely call expand_expr now,
52: so put variable sizes onto `pending_sizes' instead. */
53:
54: int immediate_size_expand;
55:
56: tree
57: get_pending_sizes ()
58: {
59: tree chain = pending_sizes;
60: pending_sizes = 0;
61: return chain;
62: }
63:
64: /* Given a size SIZE that isn't constant, return a SAVE_EXPR
65: to serve as the actual size-expression for a type or decl. */
66:
67: static tree
68: variable_size (size)
69: tree size;
70: {
71: size = save_expr (size);
72:
73: if (global_bindings_p ())
74: {
75: error ("variable-size type declared outside of any function");
76: return size_int (1);
77: }
78:
79: if (immediate_size_expand)
80: expand_expr (size, 0, VOIDmode, 0);
81: else
82: pending_sizes = tree_cons (0, size, pending_sizes);
83:
84: return size;
85: }
86:
87: #ifndef MAX_FIXED_MODE_SIZE
88: #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
89: #endif
90:
91: /* Return the machine mode to use for a nonscalar of SIZE bits.
92: The mode must be in class CLASS, and have exactly that many bits.
93: If LIMIT is nonzero, modes of wider than MAX_FIXED_MODE_SIZE will not
94: be used. */
95:
96: enum machine_mode
97: mode_for_size (size, class, limit)
98: unsigned int size;
99: enum mode_class class;
100: int limit;
101: {
102: register enum machine_mode mode;
103:
104: if (limit && size > MAX_FIXED_MODE_SIZE)
105: return BLKmode;
106:
107: /* Get the last mode which has this size, in the specified class. */
108: for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
109: mode = GET_MODE_WIDER_MODE (mode))
110: if (GET_MODE_BITSIZE (mode) == size)
111: return mode;
112:
113: return BLKmode;
114: }
115:
116: /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
117:
118: tree
119: round_up (value, divisor)
120: tree value;
121: int divisor;
122: {
123: return size_binop (MULT_EXPR,
124: size_binop (CEIL_DIV_EXPR, value, size_int (divisor)),
125: size_int (divisor));
126: }
127:
128: /* Set the size, mode and alignment of a ..._DECL node.
129: TYPE_DECL does need this for C++.
130: Note that LABEL_DECL and CONST_DECL nodes do not need this,
131: and FUNCTION_DECL nodes have them set up in a special (and simple) way.
132: Don't call layout_decl for them.
133:
134: KNOWN_ALIGN is the amount of alignment we can assume this
135: decl has with no special effort. It is relevant only for FIELD_DECLs
136: and depends on the previous fields.
137: All that matters about KNOWN_ALIGN is which powers of 2 divide it.
138: If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
139: the record will be aligned to suit. */
140:
141: void
142: layout_decl (decl, known_align)
143: tree decl;
144: unsigned known_align;
145: {
146: register tree type = TREE_TYPE (decl);
147: register enum tree_code code = TREE_CODE (decl);
148: int spec_size = DECL_FRAME_SIZE (decl);
149:
150: if (code == CONST_DECL)
151: return;
152:
153: if (code != VAR_DECL && code != PARM_DECL && code != RESULT_DECL
154: && code != FIELD_DECL && code != TYPE_DECL)
155: abort ();
156:
157: if (type == error_mark_node)
158: {
159: type = void_type_node;
160: spec_size = 0;
161: }
162:
163: /* Usually the size and mode come from the data type without change. */
164:
165: DECL_MODE (decl) = TYPE_MODE (type);
166: DECL_SIZE (decl) = TYPE_SIZE (type);
167: TREE_UNSIGNED (decl) = TREE_UNSIGNED (type);
168:
169: if (code == FIELD_DECL && DECL_BIT_FIELD (decl))
170: {
171: /* This is a bit-field. We don't know how to handle
172: them except for integers and enums, and front end should
173: never generate them otherwise. */
174:
175: if (! (TREE_CODE (type) == INTEGER_TYPE
176: || TREE_CODE (type) == ENUMERAL_TYPE))
177: abort ();
178:
179: if (spec_size == 0 && DECL_NAME (decl) != 0)
180: abort ();
181:
182: /* Size is specified number of bits. */
183: DECL_SIZE (decl) = size_int (spec_size);
184: }
185: /* Force alignment required for the data type.
186: But if the decl itself wants greater alignment, don't override that. */
187: else if (TYPE_ALIGN (type) > DECL_ALIGN (decl))
188: DECL_ALIGN (decl) = TYPE_ALIGN (type);
189:
190: /* See if we can use an ordinary integer mode for a bit-field. */
191: /* Conditions are: a fixed size that is correct for another mode
192: and occupying a complete byte or bytes on proper boundary. */
193: if (code == FIELD_DECL)
194: DECL_BIT_FIELD_TYPE (decl) = DECL_BIT_FIELD (decl) ? type : 0;
195: if (DECL_BIT_FIELD (decl)
196: && TYPE_SIZE (type) != 0
197: && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
198: {
199: register enum machine_mode xmode
200: = mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl)), MODE_INT, 1);
201:
202: if (xmode != BLKmode
203: && known_align % GET_MODE_ALIGNMENT (xmode) == 0)
204: {
205: DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode),
206: DECL_ALIGN (decl));
207: DECL_MODE (decl) = xmode;
208: DECL_SIZE (decl) = size_int (GET_MODE_BITSIZE (xmode));
209: /* This no longer needs to be accessed as a bit field. */
210: DECL_BIT_FIELD (decl) = 0;
211: }
212: }
213:
214: /* Evaluate nonconstant size only once, either now or as soon as safe. */
215: if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
216: DECL_SIZE (decl) = variable_size (DECL_SIZE (decl));
217: }
218:
219: /* Lay out a RECORD_TYPE type (a C struct).
220: This means laying out the fields, determining their positions,
221: and computing the overall size and required alignment of the record.
222: Note that if you set the TYPE_ALIGN before calling this
223: then the struct is aligned to at least that boundary.
224:
225: If the type has basetypes, you must call layout_basetypes
226: before calling this function.
227:
228: The return value is a list of static members of the record.
229: They still need to be laid out. */
230:
231: static tree
232: layout_record (rec)
233: tree rec;
234: {
235: register tree field;
236: #ifdef STRUCTURE_SIZE_BOUNDARY
237: unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
238: #else
239: unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
240: #endif
241: /* These must be laid out *after* the record is. */
242: tree pending_statics = NULL_TREE;
243: /* Record size so far is CONST_SIZE + VAR_SIZE bits,
244: where CONST_SIZE is an integer
245: and VAR_SIZE is a tree expression.
246: If VAR_SIZE is null, the size is just CONST_SIZE.
247: Naturally we try to avoid using VAR_SIZE. */
248: register int const_size = 0;
249: register tree var_size = 0;
250: /* Once we start using VAR_SIZE, this is the maximum alignment
251: that we know VAR_SIZE has. */
252: register int var_align = BITS_PER_UNIT;
253:
254:
255: for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
256: {
257: register int desired_align;
258:
259: /* If FIELD is static, then treat it like a separate variable,
260: not really like a structure field.
261: If it is a FUNCTION_DECL, it's a method.
262: In both cases, all we do is lay out the decl,
263: and we do it *after* the record is laid out. */
264:
265: if (TREE_STATIC (field))
266: {
267: pending_statics = tree_cons (NULL, field, pending_statics);
268: continue;
269: }
270: /* Enumerators and enum types which are local to this class need not
271: be laid out. Likewise for initialized constant fields. */
272: if (TREE_CODE (field) != FIELD_DECL)
273: continue;
274:
275: /* Lay out the field so we know what alignment it needs.
276: For KNOWN_ALIGN, pass the number of bits from start of record
277: or some divisor of it. */
278:
279: /* For a packed field, use the alignment as specified,
280: disregarding what the type would want. */
281: if (DECL_PACKED (field))
282: desired_align = DECL_ALIGN (field);
283: layout_decl (field, var_size ? var_align : const_size);
284: if (! DECL_PACKED (field))
285: desired_align = DECL_ALIGN (field);
286: /* Some targets (i.e. VMS) limit struct field alignment
287: to a lower boundary than alignment of variables. */
288: #ifdef BIGGEST_FIELD_ALIGNMENT
289: desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT);
290: #endif
291:
292: /* Record must have at least as much alignment as any field.
293: Otherwise, the alignment of the field within the record
294: is meaningless. */
295:
296: #ifndef PCC_BITFIELD_TYPE_MATTERS
297: record_align = MAX (record_align, desired_align);
298: #else
299: if (PCC_BITFIELD_TYPE_MATTERS && TREE_TYPE (field) != error_mark_node
300: && ! integer_zerop (TYPE_SIZE (TREE_TYPE (field))))
301: {
302: /* For these machines, a zero-length field does not
303: affect the alignment of the structure as a whole.
304: It does, however, affect the alignment of the next field
305: within the structure. */
306: if (! integer_zerop (DECL_SIZE (field)))
307: record_align = MAX (record_align, desired_align);
308: else if (! DECL_PACKED (field))
309: desired_align = TYPE_ALIGN (TREE_TYPE (field));
310: /* A named bit field of declared type `int'
311: forces the entire structure to have `int' alignment. */
312: if (DECL_NAME (field) != 0)
313: record_align = MAX (record_align, TYPE_ALIGN (TREE_TYPE (field)));
314: }
315: else
316: record_align = MAX (record_align, desired_align);
317: #endif
318:
319: /* Does this field automatically have alignment it needs
320: by virtue of the fields that precede it and the record's
321: own alignment? */
322:
323: if (const_size % desired_align != 0
324: || (var_align % desired_align != 0
325: && var_size != 0))
326: {
327: /* No, we need to skip space before this field.
328: Bump the cumulative size to multiple of field alignment. */
329:
330: if (var_size == 0
331: || var_align % desired_align == 0)
332: const_size
333: = CEIL (const_size, desired_align) * desired_align;
334: else
335: {
336: if (const_size > 0)
337: var_size = size_binop (PLUS_EXPR, var_size, const_size);
338: const_size = 0;
339: var_size = round_up (var_size, desired_align);
340: var_align = MIN (var_align, desired_align);
341: }
342: }
343:
344: #ifdef PCC_BITFIELD_TYPE_MATTERS
345: if (PCC_BITFIELD_TYPE_MATTERS
346: && TREE_CODE (field) == FIELD_DECL
347: && TREE_TYPE (field) != error_mark_node
348: && !DECL_PACKED (field)
349: && !integer_zerop (DECL_SIZE (field)))
350: {
351: int type_align = TYPE_ALIGN (TREE_TYPE (field));
352: register tree dsize = DECL_SIZE (field);
353: int field_size = TREE_INT_CST_LOW (dsize);
354:
355: /* A bit field may not span the unit of alignment of its type.
356: Advance to next boundary if necessary. */
357: if (const_size / type_align
358: != (const_size + field_size - 1) / type_align)
359: const_size = CEIL (const_size, type_align) * type_align;
360: }
361: #endif
362:
363: /* No existing machine description uses this parameter.
364: So I have made it in this aspect identical to PCC_BITFIELD_TYPE_MATTERS. */
365: #ifdef BITFIELD_NBYTES_LIMITED
366: if (BITFIELD_NBYTES_LIMITED
367: && TREE_CODE (field) == FIELD_DECL
368: && TREE_TYPE (field) != error_mark_node
369: && !DECL_PACKED (field)
370: && !integer_zerop (DECL_SIZE (field)))
371: {
372: int type_align = TYPE_ALIGN (TREE_TYPE (field));
373: register tree dsize = DECL_SIZE (field);
374: int field_size = TREE_INT_CST_LOW (dsize);
375:
376: /* A bit field may not span the unit of alignment of its type.
377: Advance to next boundary if necessary. */
378: if (const_size / type_align
379: != (const_size + field_size - 1) / type_align)
380: const_size = CEIL (const_size, type_align) * type_align;
381: }
382: #endif
383:
384: /* Size so far becomes the position of this field. */
385:
386: if (var_size && const_size)
387: DECL_FIELD_BITPOS (field)
388: = size_binop (PLUS_EXPR, var_size, size_int (const_size));
389: else if (var_size)
390: DECL_FIELD_BITPOS (field) = var_size;
391: else
392: DECL_FIELD_BITPOS (field) = size_int (const_size);
393:
394: /* If this field is an anonymous union,
395: give each union-member the same position as the union has. */
396:
397: if (DECL_NAME (field) == 0
398: && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
399: {
400: tree uelt = TYPE_FIELDS (TREE_TYPE (field));
401: for (; uelt; uelt = TREE_CHAIN (uelt))
402: {
403: DECL_FIELD_CONTEXT (uelt) = DECL_FIELD_CONTEXT (field);
404: DECL_FIELD_BITPOS (uelt) = DECL_FIELD_BITPOS (field);
405: }
406: }
407:
408: /* Now add size of this field to the size of the record. */
409:
410: {
411: register tree dsize = DECL_SIZE (field);
412:
413: if (TREE_CODE (dsize) == INTEGER_CST)
414: const_size += TREE_INT_CST_LOW (dsize);
415: else
416: {
417: if (var_size == 0)
418: var_size = dsize;
419: else
420: var_size = size_binop (PLUS_EXPR, var_size, dsize);
421: }
422: }
423: }
424:
425: /* Work out the total size and alignment of the record
426: as one expression and store in the record type.
427: Round it up to a multiple of the record's alignment. */
428:
429: if (var_size == 0)
430: {
431: TYPE_SIZE (rec) = size_int (const_size);
432: }
433: else
434: {
435: if (const_size)
436: var_size
437: = size_binop (PLUS_EXPR, var_size, size_int (const_size));
438: TYPE_SIZE (rec) = var_size;
439: }
440:
441: /* Determine the desired alignment. */
442: #ifdef ROUND_TYPE_ALIGN
443: TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), record_align);
444: #else
445: TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), record_align);
446: #endif
447:
448: #ifdef ROUND_TYPE_SIZE
449: TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
450: #else
451: /* Round the size up to be a multiple of the required alignment */
452: TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
453: #endif
454:
455: return pending_statics;
456: }
457:
458: /* Lay out a UNION_TYPE type.
459: Lay out all the fields, set their positions to zero,
460: and compute the size and alignment of the union (maximum of any field).
461: Note that if you set the TYPE_ALIGN before calling this
462: then the union align is aligned to at least that boundary. */
463:
464: static void
465: layout_union (rec)
466: tree rec;
467: {
468: register tree field;
469: #ifdef STRUCTURE_SIZE_BOUNDARY
470: unsigned union_align = STRUCTURE_SIZE_BOUNDARY;
471: #else
472: unsigned union_align = BITS_PER_UNIT;
473: #endif
474:
475: /* The size of the union, based on the fields scanned so far,
476: is max (CONST_SIZE, VAR_SIZE).
477: VAR_SIZE may be null; then CONST_SIZE by itself is the size. */
478: register int const_size = 0;
479: register tree var_size = 0;
480:
481: for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
482: {
483: /* Enums which are local to this class need not be laid out. */
484: if (TREE_CODE (field) == CONST_DECL || TREE_CODE (field) == TYPE_DECL)
485: continue;
486:
487: layout_decl (field, 0);
488: DECL_FIELD_BITPOS (field) = size_int (0);
489:
490: /* Union must be at least as aligned as any field requires. */
491:
492: union_align = MAX (union_align, DECL_ALIGN (field));
493:
494: #ifdef PCC_BITFIELD_TYPE_MATTERS
495: /* On the m88000, a bit field of declare type `int'
496: forces the entire union to have `int' alignment. */
497: if (PCC_BITFIELD_TYPE_MATTERS)
498: union_align = MAX (union_align, TYPE_ALIGN (TREE_TYPE (field)));
499: #endif
500:
501: /* Set union_size to max (decl_size, union_size).
502: There are more and less general ways to do this.
503: Use only CONST_SIZE unless forced to use VAR_SIZE. */
504:
505: if (TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
506: const_size = MAX (const_size, TREE_INT_CST_LOW (DECL_SIZE (field)));
507: else if (var_size == 0)
508: var_size = DECL_SIZE (field);
509: else
510: var_size = size_binop (MAX_EXPR, var_size, DECL_SIZE (field));
511: }
512:
513: /* Determine the ultimate size of the union (in bytes). */
514: if (NULL == var_size)
515: TYPE_SIZE (rec) = size_int (CEIL (const_size, BITS_PER_UNIT)
516: * BITS_PER_UNIT);
517: else if (const_size == 0)
518: TYPE_SIZE (rec) = var_size;
519: else
520: TYPE_SIZE (rec) = size_binop (MAX_EXPR, var_size,
521: round_up (size_int (const_size),
522: BITS_PER_UNIT));
523:
524: /* Determine the desired alignment. */
525: #ifdef ROUND_TYPE_ALIGN
526: TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), union_align);
527: #else
528: TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), union_align);
529: #endif
530:
531: #ifdef ROUND_TYPE_SIZE
532: TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
533: #else
534: /* Round the size up to be a multiple of the required alignment */
535: TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
536: #endif
537: }
538:
539: /* Calculate the mode, size, and alignment for TYPE.
540: For an array type, calculate the element separation as well.
541: Record TYPE on the chain of permanent or temporary types
542: so that dbxout will find out about it.
543:
544: TYPE_SIZE of a type is nonzero if the type has been laid out already.
545: layout_type does nothing on such a type.
546:
547: If the type is incomplete, its TYPE_SIZE remains zero. */
548:
549: void
550: layout_type (type)
551: tree type;
552: {
553: int old;
554: tree pending_statics;
555:
556: if (type == 0)
557: abort ();
558:
559: /* Do nothing if type has been laid out before. */
560: if (TYPE_SIZE (type))
561: return;
562:
563: /* Make sure all nodes we allocate are not momentary;
564: they must last past the current statement. */
565: old = suspend_momentary ();
566:
567: /* If we are processing a permanent type, make nodes permanent.
568: If processing a temporary type, make it saveable, since the
569: type node itself is. This is important if the function is inline,
570: since its decls will get copied later. */
571: push_obstacks_nochange ();
572: if (allocation_temporary_p ())
573: {
574: if (TREE_PERMANENT (type))
575: end_temporary_allocation ();
576: else
577: saveable_allocation ();
578: }
579:
580: switch (TREE_CODE (type))
581: {
582: case LANG_TYPE:
583: /* This kind of type is the responsibility
584: of the languge-specific code. */
585: abort ();
586:
587: case INTEGER_TYPE:
588: case ENUMERAL_TYPE:
589: if (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (type)) >= 0)
590: TREE_UNSIGNED (type) = 1;
591:
592: /* We pass 0 for the last arg of mode_for_size because otherwise
593: on the Apollo using long long causes a crash.
594: It seems better to use integer modes than to try to support
595: integer types with BLKmode. */
596: TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_INT, 0);
597: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
598: break;
599:
600: case REAL_TYPE:
601: TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
602: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
603: break;
604:
605: case COMPLEX_TYPE:
606: TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type));
607: TYPE_MODE (type)
608: = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
609: (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
610: ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT),
611: 0);
612: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
613: break;
614:
615: case VOID_TYPE:
616: TYPE_SIZE (type) = size_zero_node;
617: TYPE_ALIGN (type) = 1;
618: TYPE_MODE (type) = VOIDmode;
619: break;
620:
621: case FUNCTION_TYPE:
622: case METHOD_TYPE:
623: TYPE_MODE (type) = mode_for_size (2 * GET_MODE_BITSIZE (Pmode),
624: MODE_INT, 0);
625: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
626: break;
627:
628: case POINTER_TYPE:
629: case REFERENCE_TYPE:
630: TYPE_MODE (type) = Pmode;
631: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
632: TREE_UNSIGNED (type) = 1;
633: TYPE_PRECISION (type) = GET_MODE_BITSIZE (TYPE_MODE (type));
634: break;
635:
636: case ARRAY_TYPE:
637: {
638: register tree index = TYPE_DOMAIN (type);
639: register tree element = TREE_TYPE (type);
640:
641: build_pointer_type (element);
642:
643: /* We need to know both bounds in order to compute the size. */
644: if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
645: && TYPE_SIZE (element))
646: {
647: tree length
648: = size_binop (PLUS_EXPR, size_one_node,
649: size_binop (MINUS_EXPR, TYPE_MAX_VALUE (index),
650: TYPE_MIN_VALUE (index)));
651:
652: TYPE_SIZE (type) = size_binop (MULT_EXPR, length,
653: TYPE_SIZE (element));
654: }
655:
656: /* Now round the alignment and size,
657: using machine-dependent criteria if any. */
658:
659: #ifdef ROUND_TYPE_ALIGN
660: TYPE_ALIGN (type)
661: = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
662: #else
663: TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
664: #endif
665:
666: #ifdef ROUND_TYPE_SIZE
667: if (TYPE_SIZE (type) != 0)
668: TYPE_SIZE (type)
669: = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
670: #endif
671:
672: TYPE_MODE (type) = BLKmode;
673: if (TYPE_SIZE (type) != 0
674: && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
675: /* BLKmode elements force BLKmode aggregate;
676: else extract/store fields may lose. */
677: && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
678: || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
679: {
680: TYPE_MODE (type)
681: = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
682: MODE_INT, 1);
683:
684: #ifdef STRICT_ALIGNMENT
685: if (TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
686: && TYPE_ALIGN (type) < TREE_INT_CST_LOW (TYPE_SIZE (type))
687: && TYPE_MODE (type) != BLKmode)
688: {
689: TYPE_NO_FORCE_BLK (type) = 1;
690: TYPE_MODE (type) = BLKmode;
691: }
692: #endif
693: }
694: break;
695: }
696:
697: case RECORD_TYPE:
698: pending_statics = layout_record (type);
699: TYPE_MODE (type) = BLKmode;
700: if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
701: {
702: tree field;
703: /* A record which has any BLKmode members must itself be BLKmode;
704: it can't go in a register.
705: Unless the member is BLKmode only because it isn't aligned. */
706: for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
707: {
708: int bitpos;
709:
710: if (TREE_CODE (field) != FIELD_DECL)
711: continue;
712:
713: if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
714: && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
715: goto record_lose;
716:
717: if (TREE_CODE (DECL_FIELD_BITPOS (field)) != INTEGER_CST)
718: goto record_lose;
719:
720: bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
721:
722: /* Must be BLKmode if any field crosses a word boundary,
723: since extract_bit_field can't handle that in registers. */
724: if (bitpos / BITS_PER_WORD
725: != ((TREE_INT_CST_LOW (DECL_SIZE (field)) + bitpos - 1)
726: / BITS_PER_WORD)
727: /* But there is no problem if the field is entire words. */
728: && TREE_INT_CST_LOW (DECL_SIZE (field)) % BITS_PER_WORD == 0)
729: goto record_lose;
730: }
731:
732: TYPE_MODE (type)
733: = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
734: MODE_INT, 1);
735:
736: /* If structure's known alignment is less than
737: what the scalar mode would need, and it matters,
738: then stick with BLKmode. */
739: #ifdef STRICT_ALIGNMENT
740: if (! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
741: || TYPE_ALIGN (type) >= TREE_INT_CST_LOW (TYPE_SIZE (type))))
742: {
743: if (TYPE_MODE (type) != BLKmode)
744: /* If this is the only reason this type is BLKmode,
745: then don't force containing types to be BLKmode. */
746: TYPE_NO_FORCE_BLK (type) = 1;
747: TYPE_MODE (type) = BLKmode;
748: }
749: #endif
750: record_lose: ;
751: }
752:
753: /* Lay out any static members. This is done now
754: because their type may use the record's type. */
755: while (pending_statics)
756: {
757: layout_decl (TREE_VALUE (pending_statics), 0);
758: pending_statics = TREE_CHAIN (pending_statics);
759: }
760: break;
761:
762: case UNION_TYPE:
763: layout_union (type);
764: TYPE_MODE (type) = BLKmode;
765: if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
766: /* If structure's known alignment is less than
767: what the scalar mode would need, and it matters,
768: then stick with BLKmode. */
769: #ifdef STRICT_ALIGNMENT
770: && (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
771: || TYPE_ALIGN (type) >= TREE_INT_CST_LOW (TYPE_SIZE (type)))
772: #endif
773: )
774: {
775: tree field;
776: /* A union which has any BLKmode members must itself be BLKmode;
777: it can't go in a register.
778: Unless the member is BLKmode only because it isn't aligned. */
779: for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
780: {
781: if (TREE_CODE (field) != FIELD_DECL)
782: continue;
783:
784: if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
785: && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
786: goto union_lose;
787: }
788:
789: TYPE_MODE (type)
790: = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
791: MODE_INT, 1);
792:
793: union_lose: ;
794: }
795: break;
796:
797: default:
798: abort ();
799: } /* end switch */
800:
801: /* Normally, use the alignment corresponding to the mode chosen.
802: However, where strict alignment is not required, avoid
803: over-aligning structures, since most compilers do not do this
804: alignment. */
805:
806: if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
807: #ifndef STRICT_ALIGNMENT
808: && (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
809: && TREE_CODE (type) != ARRAY_TYPE)
810: #endif
811: )
812: TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
813:
814: /* Evaluate nonconstant size only once, either now or as soon as safe. */
815: if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
816: TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
817:
818: /* Also layout any other variants of the type. */
819: if (TYPE_NEXT_VARIANT (type)
820: || type != TYPE_MAIN_VARIANT (type))
821: {
822: tree variant;
823: /* Record layout info of this variant. */
824: tree size = TYPE_SIZE (type);
825: int align = TYPE_ALIGN (type);
826: enum machine_mode mode = TYPE_MODE (type);
827:
828: /* Copy it into all variants. */
829: for (variant = TYPE_MAIN_VARIANT (type);
830: variant;
831: variant = TYPE_NEXT_VARIANT (variant))
832: {
833: TYPE_SIZE (variant) = size;
834: TYPE_ALIGN (variant) = align;
835: TYPE_MODE (variant) = mode;
836: }
837: }
838:
839: pop_obstacks ();
840: resume_momentary (old);
841: }
842:
843: /* Create and return a type for signed integers of PRECISION bits. */
844:
845: tree
846: make_signed_type (precision)
847: int precision;
848: {
849: register tree type = make_node (INTEGER_TYPE);
850:
851: TYPE_PRECISION (type) = precision;
852:
853: /* Create the extreme values based on the number of bits. */
854:
855: TYPE_MIN_VALUE (type)
856: = build_int_2 ((precision-HOST_BITS_PER_INT > 0 ? 0 : (-1)<<(precision-1)),
857: (-1)<<(precision-HOST_BITS_PER_INT-1 > 0
858: ? precision-HOST_BITS_PER_INT-1
859: : 0));
860: TYPE_MAX_VALUE (type)
861: = build_int_2 ((precision-HOST_BITS_PER_INT > 0 ? -1 : (1<<(precision-1))-1),
862: (precision-HOST_BITS_PER_INT-1 > 0
863: ? (1<<(precision-HOST_BITS_PER_INT-1))-1
864: : 0));
865:
866: /* Give this type's extreme values this type as their type. */
867:
868: TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
869: TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
870:
871: /* The first type made with this or `make_unsigned_type'
872: is the type for size values. */
873:
874: if (sizetype == 0)
875: {
876: sizetype = type;
877: }
878:
879: /* Lay out the type: set its alignment, size, etc. */
880:
881: layout_type (type);
882:
883: return type;
884: }
885:
886: /* Create and return a type for unsigned integers of PRECISION bits. */
887:
888: tree
889: make_unsigned_type (precision)
890: int precision;
891: {
892: register tree type = make_node (INTEGER_TYPE);
893:
894: TYPE_PRECISION (type) = precision;
895:
896: /* The first type made with this or `make_signed_type'
897: is the type for size values. */
898:
899: if (sizetype == 0)
900: {
901: sizetype = type;
902: }
903:
904: fixup_unsigned_type (type);
905: return type;
906: }
907:
908: /* Set the extreme values of TYPE based on its precision in bits,
909: the lay it out. This is used both in `make_unsigned_type'
910: and for enumeral types. */
911:
912: void
913: fixup_unsigned_type (type)
914: tree type;
915: {
916: register int precision = TYPE_PRECISION (type);
917:
918: TYPE_MIN_VALUE (type) = build_int_2 (0, 0);
919: TYPE_MAX_VALUE (type)
920: = build_int_2 (precision-HOST_BITS_PER_INT >= 0 ? -1 : (1<<precision)-1,
921: precision-HOST_BITS_PER_INT > 0
922: ? ((unsigned) ~0
923: >> (HOST_BITS_PER_INT - (precision - HOST_BITS_PER_INT)))
924: : 0);
925: TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
926: TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
927:
928: /* Lay out the type: set its alignment, size, etc. */
929:
930: layout_type (type);
931: }
932:
933: /* Find the best machine mode to use when referencing a bit field of length
934: BITSIZE bits starting at BITPOS.
935:
936: The underlying object is known to be aligned to a boundary of ALIGN bits.
937: If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
938: larger than LARGEST_MODE (usually SImode).
939:
940: If no mode meets all these conditions, we return VOIDmode. Otherwise, if
941: VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest
942: mode meeting these conditions.
943:
944: Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), if a mode
945: whose size is UNITS_PER_WORD meets all the conditions, it is returned
946: instead. */
947:
948: enum machine_mode
949: get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
950: int bitsize, bitpos;
951: int align;
952: enum machine_mode largest_mode;
953: int volatilep;
954: {
955: enum machine_mode mode;
956: int unit;
957:
958: /* Find the narrowest integer mode that contains the bit field. */
959: for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
960: mode = GET_MODE_WIDER_MODE (mode))
961: {
962: unit = GET_MODE_BITSIZE (mode);
963: if (bitpos / unit == (bitpos + bitsize - 1) / unit)
964: break;
965: }
966:
967: if (mode == MAX_MACHINE_MODE
968: /* It is tempting to omit the following line
969: if STRICT_ALIGNMENT is not defined.
970: But that is incorrect, since if the bitfield uses part of 3 bytes
971: and we use a 4-byte mode, we could get a spurious segv
972: if the extra 4th byte is past the end of memory.
973: (Though at least one Unix compiler ignores this problem:
974: that on the Sequent 386 machine. */
975: || MIN (unit, BIGGEST_ALIGNMENT) > align
976: || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
977: return VOIDmode;
978:
979: if (SLOW_BYTE_ACCESS
980: && ! volatilep
981: && BITS_PER_WORD <= MIN (align, BIGGEST_ALIGNMENT)
982: && (largest_mode == VOIDmode
983: || BITS_PER_WORD <= GET_MODE_BITSIZE (largest_mode)))
984: return word_mode;
985:
986: return mode;
987: }
988:
989: /* Save all variables describing the current status into the structure *P.
990: This is used before starting a nested function. */
991:
992: void
993: save_storage_status (p)
994: struct function *p;
995: {
996: #if 0 /* Need not save, since always 0 and non0 (resp.) within a function. */
997: p->pending_sizes = pending_sizes;
998: p->immediate_size_expand = immediate_size_expand;
999: #endif /* 0 */
1000: }
1001:
1002: /* Restore all variables describing the current status from the structure *P.
1003: This is used after a nested function. */
1004:
1005: void
1006: restore_storage_status (p)
1007: struct function *p;
1008: {
1009: #if 0
1010: pending_sizes = p->pending_sizes;
1011: immediate_size_expand = p->immediate_size_expand;
1012: #endif /* 0 */
1013: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.