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