![[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
1.1.1.8 root 2: Copyright (C) 1987, 88, 92, 93, 94, 1995 Free Software Foundation, Inc.
1.1 root 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
1.1.1.8 root 18: the Free Software Foundation, 59 Temple Place - Suite 330,
19: Boston, MA 02111-1307, USA. */
1.1 root 20:
21:
22: #include "config.h"
23: #include <stdio.h>
24:
25: #include "tree.h"
1.1.1.8 root 26: #include "flags.h"
1.1 root 27: #include "function.h"
28:
29: #define CEIL(x,y) (((x) + (y) - 1) / (y))
30:
31: /* Data type for the expressions representing sizes of data types.
32: It is the first integer type laid out.
33: In C, this is int. */
34:
35: tree sizetype;
36:
37: /* An integer constant with value 0 whose type is sizetype. */
38:
39: tree size_zero_node;
40:
41: /* An integer constant with value 1 whose type is sizetype. */
42:
43: tree size_one_node;
44:
1.1.1.4 root 45: /* If nonzero, this is an upper limit on alignment of structure fields.
46: The value is measured in bits. */
47: int maximum_field_alignment;
48:
1.1.1.8 root 49: /* If non-zero, the alignment of a bitstring or (power-)set value, in bits.
1.1.1.7 root 50: May be overridden by front-ends. */
51: int set_alignment = 0;
52:
1.1 root 53: #define GET_MODE_ALIGNMENT(MODE) \
54: MIN (BIGGEST_ALIGNMENT, \
55: MAX (1, (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT)))
1.1.1.6 root 56:
57: static enum machine_mode smallest_mode_for_size PROTO((unsigned int,
58: enum mode_class));
59: static tree layout_record PROTO((tree));
60: static void layout_union PROTO((tree));
1.1 root 61:
62: /* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */
63:
64: static tree pending_sizes;
65:
66: /* Nonzero means cannot safely call expand_expr now,
67: so put variable sizes onto `pending_sizes' instead. */
68:
69: int immediate_size_expand;
70:
71: tree
72: get_pending_sizes ()
73: {
74: tree chain = pending_sizes;
1.1.1.2 root 75: tree t;
76:
77: /* Put each SAVE_EXPR into the current function. */
78: for (t = chain; t; t = TREE_CHAIN (t))
79: SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = current_function_decl;
1.1 root 80: pending_sizes = 0;
81: return chain;
82: }
83:
1.1.1.8 root 84: void
85: put_pending_sizes (chain)
86: tree chain;
87: {
88: if (pending_sizes)
89: abort ();
90:
91: pending_sizes = chain;
92: }
93:
94: /* Given a size SIZE that may not be a constant, return a SAVE_EXPR
1.1 root 95: to serve as the actual size-expression for a type or decl. */
96:
1.1.1.2 root 97: tree
1.1 root 98: variable_size (size)
99: tree size;
100: {
1.1.1.6 root 101: /* If the language-processor is to take responsibility for variable-sized
102: items (e.g., languages which have elaboration procedures like Ada),
1.1.1.7 root 103: just return SIZE unchanged. Likewise for self-referential sizes. */
1.1.1.8 root 104: if (TREE_CONSTANT (size)
105: || global_bindings_p () < 0 || contains_placeholder_p (size))
1.1.1.6 root 106: return size;
107:
1.1.1.7 root 108: size = save_expr (size);
109:
110: if (global_bindings_p ())
1.1 root 111: {
1.1.1.5 root 112: if (TREE_CONSTANT (size))
113: error ("type size can't be explicitly evaluated");
114: else
115: error ("variable-size type declared outside of any function");
116:
1.1 root 117: return size_int (1);
118: }
119:
120: if (immediate_size_expand)
1.1.1.5 root 121: /* NULL_RTX is not defined; neither is the rtx type.
122: Also, we would like to pass const0_rtx here, but don't have it. */
123: expand_expr (size, expand_expr (integer_zero_node, NULL_PTR, VOIDmode, 0),
124: VOIDmode, 0);
1.1 root 125: else
1.1.1.4 root 126: pending_sizes = tree_cons (NULL_TREE, size, pending_sizes);
1.1 root 127:
128: return size;
129: }
130:
131: #ifndef MAX_FIXED_MODE_SIZE
132: #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode)
133: #endif
134:
135: /* Return the machine mode to use for a nonscalar of SIZE bits.
136: The mode must be in class CLASS, and have exactly that many bits.
137: If LIMIT is nonzero, modes of wider than MAX_FIXED_MODE_SIZE will not
138: be used. */
139:
140: enum machine_mode
141: mode_for_size (size, class, limit)
142: unsigned int size;
143: enum mode_class class;
144: int limit;
145: {
146: register enum machine_mode mode;
147:
148: if (limit && size > MAX_FIXED_MODE_SIZE)
149: return BLKmode;
150:
1.1.1.6 root 151: /* Get the first mode which has this size, in the specified class. */
1.1 root 152: for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
153: mode = GET_MODE_WIDER_MODE (mode))
154: if (GET_MODE_BITSIZE (mode) == size)
155: return mode;
156:
157: return BLKmode;
158: }
159:
1.1.1.6 root 160: /* Similar, but never return BLKmode; return the narrowest mode that
161: contains at least the requested number of bits. */
162:
163: static enum machine_mode
164: smallest_mode_for_size (size, class)
165: unsigned int size;
166: enum mode_class class;
167: {
168: register enum machine_mode mode;
169:
170: /* Get the first mode which has at least this size, in the
171: specified class. */
172: for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode;
173: mode = GET_MODE_WIDER_MODE (mode))
174: if (GET_MODE_BITSIZE (mode) >= size)
175: return mode;
176:
177: abort ();
178: }
179:
1.1 root 180: /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */
181:
182: tree
183: round_up (value, divisor)
184: tree value;
185: int divisor;
186: {
187: return size_binop (MULT_EXPR,
188: size_binop (CEIL_DIV_EXPR, value, size_int (divisor)),
189: size_int (divisor));
190: }
191:
192: /* Set the size, mode and alignment of a ..._DECL node.
193: TYPE_DECL does need this for C++.
194: Note that LABEL_DECL and CONST_DECL nodes do not need this,
195: and FUNCTION_DECL nodes have them set up in a special (and simple) way.
196: Don't call layout_decl for them.
197:
198: KNOWN_ALIGN is the amount of alignment we can assume this
199: decl has with no special effort. It is relevant only for FIELD_DECLs
200: and depends on the previous fields.
201: All that matters about KNOWN_ALIGN is which powers of 2 divide it.
202: If KNOWN_ALIGN is 0, it means, "as much alignment as you like":
203: the record will be aligned to suit. */
204:
205: void
206: layout_decl (decl, known_align)
207: tree decl;
208: unsigned known_align;
209: {
210: register tree type = TREE_TYPE (decl);
211: register enum tree_code code = TREE_CODE (decl);
1.1.1.3 root 212: int spec_size = DECL_FIELD_SIZE (decl);
1.1 root 213:
214: if (code == CONST_DECL)
215: return;
216:
217: if (code != VAR_DECL && code != PARM_DECL && code != RESULT_DECL
218: && code != FIELD_DECL && code != TYPE_DECL)
219: abort ();
220:
221: if (type == error_mark_node)
222: {
223: type = void_type_node;
224: spec_size = 0;
225: }
226:
227: /* Usually the size and mode come from the data type without change. */
228:
229: DECL_MODE (decl) = TYPE_MODE (type);
230: TREE_UNSIGNED (decl) = TREE_UNSIGNED (type);
1.1.1.6 root 231: if (DECL_SIZE (decl) == 0)
232: DECL_SIZE (decl) = TYPE_SIZE (type);
1.1 root 233:
234: if (code == FIELD_DECL && DECL_BIT_FIELD (decl))
235: {
236: if (spec_size == 0 && DECL_NAME (decl) != 0)
237: abort ();
238:
239: /* Size is specified number of bits. */
240: DECL_SIZE (decl) = size_int (spec_size);
241: }
242: /* Force alignment required for the data type.
1.1.1.3 root 243: But if the decl itself wants greater alignment, don't override that.
244: Likewise, if the decl is packed, don't override it. */
245: else if (DECL_ALIGN (decl) == 0
246: || (! DECL_PACKED (decl) && TYPE_ALIGN (type) > DECL_ALIGN (decl)))
1.1 root 247: DECL_ALIGN (decl) = TYPE_ALIGN (type);
248:
249: /* See if we can use an ordinary integer mode for a bit-field. */
250: /* Conditions are: a fixed size that is correct for another mode
251: and occupying a complete byte or bytes on proper boundary. */
252: if (code == FIELD_DECL)
1.1.1.4 root 253: {
254: DECL_BIT_FIELD_TYPE (decl) = DECL_BIT_FIELD (decl) ? type : 0;
255: if (maximum_field_alignment != 0)
256: DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment);
1.1.1.8 root 257: else if (flag_pack_struct)
258: DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT);
1.1.1.4 root 259: }
260:
1.1 root 261: if (DECL_BIT_FIELD (decl)
262: && TYPE_SIZE (type) != 0
263: && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
264: {
265: register enum machine_mode xmode
266: = mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl)), MODE_INT, 1);
267:
268: if (xmode != BLKmode
269: && known_align % GET_MODE_ALIGNMENT (xmode) == 0)
270: {
271: DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode),
272: DECL_ALIGN (decl));
273: DECL_MODE (decl) = xmode;
274: DECL_SIZE (decl) = size_int (GET_MODE_BITSIZE (xmode));
275: /* This no longer needs to be accessed as a bit field. */
276: DECL_BIT_FIELD (decl) = 0;
277: }
278: }
279:
280: /* Evaluate nonconstant size only once, either now or as soon as safe. */
281: if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
282: DECL_SIZE (decl) = variable_size (DECL_SIZE (decl));
283: }
284:
285: /* Lay out a RECORD_TYPE type (a C struct).
286: This means laying out the fields, determining their positions,
287: and computing the overall size and required alignment of the record.
288: Note that if you set the TYPE_ALIGN before calling this
289: then the struct is aligned to at least that boundary.
290:
291: If the type has basetypes, you must call layout_basetypes
292: before calling this function.
293:
294: The return value is a list of static members of the record.
295: They still need to be laid out. */
296:
297: static tree
298: layout_record (rec)
299: tree rec;
300: {
301: register tree field;
302: #ifdef STRUCTURE_SIZE_BOUNDARY
303: unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec));
304: #else
305: unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec));
306: #endif
307: /* These must be laid out *after* the record is. */
308: tree pending_statics = NULL_TREE;
309: /* Record size so far is CONST_SIZE + VAR_SIZE bits,
310: where CONST_SIZE is an integer
311: and VAR_SIZE is a tree expression.
312: If VAR_SIZE is null, the size is just CONST_SIZE.
313: Naturally we try to avoid using VAR_SIZE. */
314: register int const_size = 0;
315: register tree var_size = 0;
316: /* Once we start using VAR_SIZE, this is the maximum alignment
317: that we know VAR_SIZE has. */
318: register int var_align = BITS_PER_UNIT;
319:
320:
321: for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
322: {
1.1.1.7 root 323: register int known_align = var_size ? var_align : const_size;
1.1 root 324: register int desired_align;
325:
326: /* If FIELD is static, then treat it like a separate variable,
327: not really like a structure field.
328: If it is a FUNCTION_DECL, it's a method.
329: In both cases, all we do is lay out the decl,
330: and we do it *after* the record is laid out. */
331:
332: if (TREE_STATIC (field))
333: {
1.1.1.4 root 334: pending_statics = tree_cons (NULL_TREE, field, pending_statics);
1.1 root 335: continue;
336: }
337: /* Enumerators and enum types which are local to this class need not
338: be laid out. Likewise for initialized constant fields. */
339: if (TREE_CODE (field) != FIELD_DECL)
340: continue;
341:
342: /* Lay out the field so we know what alignment it needs.
1.1.1.7 root 343: For a packed field, use the alignment as specified,
1.1 root 344: disregarding what the type would want. */
345: if (DECL_PACKED (field))
346: desired_align = DECL_ALIGN (field);
1.1.1.7 root 347: layout_decl (field, known_align);
1.1 root 348: if (! DECL_PACKED (field))
349: desired_align = DECL_ALIGN (field);
350: /* Some targets (i.e. VMS) limit struct field alignment
351: to a lower boundary than alignment of variables. */
352: #ifdef BIGGEST_FIELD_ALIGNMENT
353: desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT);
354: #endif
355:
356: /* Record must have at least as much alignment as any field.
357: Otherwise, the alignment of the field within the record
358: is meaningless. */
359:
360: #ifndef PCC_BITFIELD_TYPE_MATTERS
361: record_align = MAX (record_align, desired_align);
362: #else
363: if (PCC_BITFIELD_TYPE_MATTERS && TREE_TYPE (field) != error_mark_node
1.1.1.3 root 364: && DECL_BIT_FIELD_TYPE (field)
1.1 root 365: && ! integer_zerop (TYPE_SIZE (TREE_TYPE (field))))
366: {
367: /* For these machines, a zero-length field does not
368: affect the alignment of the structure as a whole.
369: It does, however, affect the alignment of the next field
370: within the structure. */
371: if (! integer_zerop (DECL_SIZE (field)))
372: record_align = MAX (record_align, desired_align);
373: else if (! DECL_PACKED (field))
374: desired_align = TYPE_ALIGN (TREE_TYPE (field));
375: /* A named bit field of declared type `int'
376: forces the entire structure to have `int' alignment. */
377: if (DECL_NAME (field) != 0)
1.1.1.4 root 378: {
379: int type_align = TYPE_ALIGN (TREE_TYPE (field));
380: if (maximum_field_alignment != 0)
381: type_align = MIN (type_align, maximum_field_alignment);
1.1.1.8 root 382: else if (flag_pack_struct)
383: type_align = MIN (type_align, BITS_PER_UNIT);
1.1.1.4 root 384:
385: record_align = MAX (record_align, type_align);
386: }
1.1 root 387: }
388: else
389: record_align = MAX (record_align, desired_align);
390: #endif
391:
392: /* Does this field automatically have alignment it needs
393: by virtue of the fields that precede it and the record's
394: own alignment? */
395:
396: if (const_size % desired_align != 0
397: || (var_align % desired_align != 0
398: && var_size != 0))
399: {
400: /* No, we need to skip space before this field.
401: Bump the cumulative size to multiple of field alignment. */
402:
403: if (var_size == 0
404: || var_align % desired_align == 0)
405: const_size
406: = CEIL (const_size, desired_align) * desired_align;
407: else
408: {
409: if (const_size > 0)
1.1.1.3 root 410: var_size = size_binop (PLUS_EXPR, var_size,
411: size_int (const_size));
1.1 root 412: const_size = 0;
413: var_size = round_up (var_size, desired_align);
414: var_align = MIN (var_align, desired_align);
415: }
416: }
417:
418: #ifdef PCC_BITFIELD_TYPE_MATTERS
419: if (PCC_BITFIELD_TYPE_MATTERS
420: && TREE_CODE (field) == FIELD_DECL
421: && TREE_TYPE (field) != error_mark_node
1.1.1.3 root 422: && DECL_BIT_FIELD_TYPE (field)
1.1 root 423: && !DECL_PACKED (field)
1.1.1.6 root 424: /* If #pragma pack is in effect, turn off this feature. */
425: && maximum_field_alignment == 0
1.1.1.8 root 426: && !flag_pack_struct
1.1 root 427: && !integer_zerop (DECL_SIZE (field)))
428: {
429: int type_align = TYPE_ALIGN (TREE_TYPE (field));
430: register tree dsize = DECL_SIZE (field);
431: int field_size = TREE_INT_CST_LOW (dsize);
432:
433: /* A bit field may not span the unit of alignment of its type.
434: Advance to next boundary if necessary. */
1.1.1.4 root 435: /* ??? There is some uncertainty here as to what
436: should be done if type_align is less than the width of the type.
437: That can happen because the width exceeds BIGGEST_ALIGNMENT
438: or because it exceeds maximum_field_alignment. */
1.1 root 439: if (const_size / type_align
1.1.1.9 ! root 440: != (const_size + (field_size % type_align) - 1) / type_align)
1.1 root 441: const_size = CEIL (const_size, type_align) * type_align;
442: }
443: #endif
444:
445: /* No existing machine description uses this parameter.
446: So I have made it in this aspect identical to PCC_BITFIELD_TYPE_MATTERS. */
447: #ifdef BITFIELD_NBYTES_LIMITED
448: if (BITFIELD_NBYTES_LIMITED
449: && TREE_CODE (field) == FIELD_DECL
450: && TREE_TYPE (field) != error_mark_node
1.1.1.3 root 451: && DECL_BIT_FIELD_TYPE (field)
1.1 root 452: && !DECL_PACKED (field)
453: && !integer_zerop (DECL_SIZE (field)))
454: {
455: int type_align = TYPE_ALIGN (TREE_TYPE (field));
456: register tree dsize = DECL_SIZE (field);
457: int field_size = TREE_INT_CST_LOW (dsize);
458:
1.1.1.4 root 459: if (maximum_field_alignment != 0)
460: type_align = MIN (type_align, maximum_field_alignment);
1.1.1.8 root 461: else if (flag_pack_struct)
462: type_align = MIN (type_align, BITS_PER_UNIT);
1.1.1.4 root 463:
1.1 root 464: /* A bit field may not span the unit of alignment of its type.
465: Advance to next boundary if necessary. */
466: if (const_size / type_align
467: != (const_size + field_size - 1) / type_align)
468: const_size = CEIL (const_size, type_align) * type_align;
469: }
470: #endif
471:
472: /* Size so far becomes the position of this field. */
473:
474: if (var_size && const_size)
475: DECL_FIELD_BITPOS (field)
476: = size_binop (PLUS_EXPR, var_size, size_int (const_size));
477: else if (var_size)
478: DECL_FIELD_BITPOS (field) = var_size;
479: else
1.1.1.7 root 480: {
481: DECL_FIELD_BITPOS (field) = size_int (const_size);
482:
483: /* If this field ended up more aligned than we thought it
484: would be (we approximate this by seeing if its position
485: changed), lay out the field again; perhaps we can use an
486: integral mode for it now. */
487: if (known_align != const_size)
488: layout_decl (field, const_size);
489: }
1.1 root 490:
491: /* Now add size of this field to the size of the record. */
492:
493: {
494: register tree dsize = DECL_SIZE (field);
495:
1.1.1.4 root 496: /* This can happen when we have an invalid nested struct definition,
497: such as struct j { struct j { int i; } }. The error message is
498: printed in finish_struct. */
499: if (dsize == 0)
500: /* Do nothing. */;
1.1.1.5 root 501: else if (TREE_CODE (dsize) == INTEGER_CST
502: && TREE_INT_CST_HIGH (dsize) == 0
503: && TREE_INT_CST_LOW (dsize) + const_size > const_size)
504: /* Use const_size if there's no overflow. */
1.1 root 505: const_size += TREE_INT_CST_LOW (dsize);
506: else
507: {
508: if (var_size == 0)
509: var_size = dsize;
510: else
511: var_size = size_binop (PLUS_EXPR, var_size, dsize);
512: }
513: }
514: }
515:
516: /* Work out the total size and alignment of the record
517: as one expression and store in the record type.
518: Round it up to a multiple of the record's alignment. */
519:
520: if (var_size == 0)
521: {
522: TYPE_SIZE (rec) = size_int (const_size);
523: }
524: else
525: {
526: if (const_size)
527: var_size
528: = size_binop (PLUS_EXPR, var_size, size_int (const_size));
529: TYPE_SIZE (rec) = var_size;
530: }
531:
532: /* Determine the desired alignment. */
533: #ifdef ROUND_TYPE_ALIGN
534: TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), record_align);
535: #else
536: TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), record_align);
537: #endif
538:
539: #ifdef ROUND_TYPE_SIZE
540: TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
541: #else
542: /* Round the size up to be a multiple of the required alignment */
543: TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
544: #endif
545:
546: return pending_statics;
547: }
548:
1.1.1.5 root 549: /* Lay out a UNION_TYPE or QUAL_UNION_TYPE type.
1.1 root 550: Lay out all the fields, set their positions to zero,
551: and compute the size and alignment of the union (maximum of any field).
552: Note that if you set the TYPE_ALIGN before calling this
553: then the union align is aligned to at least that boundary. */
554:
555: static void
556: layout_union (rec)
557: tree rec;
558: {
559: register tree field;
560: #ifdef STRUCTURE_SIZE_BOUNDARY
561: unsigned union_align = STRUCTURE_SIZE_BOUNDARY;
562: #else
563: unsigned union_align = BITS_PER_UNIT;
564: #endif
565:
566: /* The size of the union, based on the fields scanned so far,
567: is max (CONST_SIZE, VAR_SIZE).
568: VAR_SIZE may be null; then CONST_SIZE by itself is the size. */
569: register int const_size = 0;
570: register tree var_size = 0;
571:
1.1.1.5 root 572: /* If this is a QUAL_UNION_TYPE, we want to process the fields in
573: the reverse order in building the COND_EXPR that denotes its
574: size. We reverse them again later. */
575: if (TREE_CODE (rec) == QUAL_UNION_TYPE)
576: TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec));
577:
1.1 root 578: for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field))
579: {
580: /* Enums which are local to this class need not be laid out. */
581: if (TREE_CODE (field) == CONST_DECL || TREE_CODE (field) == TYPE_DECL)
582: continue;
583:
584: layout_decl (field, 0);
585: DECL_FIELD_BITPOS (field) = size_int (0);
586:
587: /* Union must be at least as aligned as any field requires. */
588:
589: union_align = MAX (union_align, DECL_ALIGN (field));
590:
591: #ifdef PCC_BITFIELD_TYPE_MATTERS
592: /* On the m88000, a bit field of declare type `int'
593: forces the entire union to have `int' alignment. */
1.1.1.3 root 594: if (PCC_BITFIELD_TYPE_MATTERS && DECL_BIT_FIELD_TYPE (field))
1.1 root 595: union_align = MAX (union_align, TYPE_ALIGN (TREE_TYPE (field)));
596: #endif
597:
1.1.1.5 root 598: if (TREE_CODE (rec) == UNION_TYPE)
599: {
600: /* Set union_size to max (decl_size, union_size).
601: There are more and less general ways to do this.
602: Use only CONST_SIZE unless forced to use VAR_SIZE. */
603:
604: if (TREE_CODE (DECL_SIZE (field)) == INTEGER_CST)
605: const_size
606: = MAX (const_size, TREE_INT_CST_LOW (DECL_SIZE (field)));
607: else if (var_size == 0)
608: var_size = DECL_SIZE (field);
609: else
610: var_size = size_binop (MAX_EXPR, var_size, DECL_SIZE (field));
611: }
612: else if (TREE_CODE (rec) == QUAL_UNION_TYPE)
613: var_size = fold (build (COND_EXPR, sizetype, DECL_QUALIFIER (field),
614: DECL_SIZE (field),
615: var_size ? var_size : integer_zero_node));
616: }
617:
618: if (TREE_CODE (rec) == QUAL_UNION_TYPE)
619: TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec));
1.1 root 620:
621: /* Determine the ultimate size of the union (in bytes). */
622: if (NULL == var_size)
623: TYPE_SIZE (rec) = size_int (CEIL (const_size, BITS_PER_UNIT)
624: * BITS_PER_UNIT);
625: else if (const_size == 0)
626: TYPE_SIZE (rec) = var_size;
627: else
628: TYPE_SIZE (rec) = size_binop (MAX_EXPR, var_size,
629: round_up (size_int (const_size),
630: BITS_PER_UNIT));
631:
632: /* Determine the desired alignment. */
633: #ifdef ROUND_TYPE_ALIGN
634: TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), union_align);
635: #else
636: TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), union_align);
637: #endif
638:
639: #ifdef ROUND_TYPE_SIZE
640: TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec));
641: #else
642: /* Round the size up to be a multiple of the required alignment */
643: TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec));
644: #endif
645: }
646:
647: /* Calculate the mode, size, and alignment for TYPE.
648: For an array type, calculate the element separation as well.
649: Record TYPE on the chain of permanent or temporary types
650: so that dbxout will find out about it.
651:
652: TYPE_SIZE of a type is nonzero if the type has been laid out already.
653: layout_type does nothing on such a type.
654:
655: If the type is incomplete, its TYPE_SIZE remains zero. */
656:
657: void
658: layout_type (type)
659: tree type;
660: {
661: int old;
662: tree pending_statics;
663:
664: if (type == 0)
665: abort ();
666:
667: /* Do nothing if type has been laid out before. */
668: if (TYPE_SIZE (type))
669: return;
670:
671: /* Make sure all nodes we allocate are not momentary;
672: they must last past the current statement. */
673: old = suspend_momentary ();
674:
1.1.1.6 root 675: /* Put all our nodes into the same obstack as the type. Also,
676: make expressions saveable (this is a no-op for permanent types). */
677:
678: push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type));
679: saveable_allocation ();
1.1 root 680:
681: switch (TREE_CODE (type))
682: {
683: case LANG_TYPE:
684: /* This kind of type is the responsibility
1.1.1.8 root 685: of the language-specific code. */
1.1 root 686: abort ();
687:
688: case INTEGER_TYPE:
689: case ENUMERAL_TYPE:
1.1.1.7 root 690: if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
691: && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
1.1 root 692: TREE_UNSIGNED (type) = 1;
693:
1.1.1.6 root 694: TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
695: MODE_INT);
1.1 root 696: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
697: break;
698:
699: case REAL_TYPE:
700: TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
701: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
702: break;
703:
704: case COMPLEX_TYPE:
705: TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type));
706: TYPE_MODE (type)
707: = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
708: (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE
709: ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT),
710: 0);
711: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
712: break;
713:
714: case VOID_TYPE:
715: TYPE_SIZE (type) = size_zero_node;
716: TYPE_ALIGN (type) = 1;
717: TYPE_MODE (type) = VOIDmode;
718: break;
719:
1.1.1.2 root 720: case OFFSET_TYPE:
1.1.1.7 root 721: TYPE_SIZE (type) = size_int (POINTER_SIZE);
1.1.1.8 root 722: TYPE_MODE (type) = ptr_mode;
1.1.1.2 root 723: break;
724:
1.1 root 725: case FUNCTION_TYPE:
726: case METHOD_TYPE:
1.1.1.7 root 727: TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0);
728: TYPE_SIZE (type) = size_int (2 * POINTER_SIZE);
1.1 root 729: break;
730:
731: case POINTER_TYPE:
732: case REFERENCE_TYPE:
1.1.1.8 root 733: TYPE_MODE (type) = ptr_mode;
1.1.1.7 root 734: TYPE_SIZE (type) = size_int (POINTER_SIZE);
1.1 root 735: TREE_UNSIGNED (type) = 1;
1.1.1.7 root 736: TYPE_PRECISION (type) = POINTER_SIZE;
1.1 root 737: break;
738:
739: case ARRAY_TYPE:
740: {
741: register tree index = TYPE_DOMAIN (type);
742: register tree element = TREE_TYPE (type);
743:
744: build_pointer_type (element);
745:
746: /* We need to know both bounds in order to compute the size. */
747: if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index)
748: && TYPE_SIZE (element))
749: {
1.1.1.8 root 750: tree ub = TYPE_MAX_VALUE (index);
751: tree lb = TYPE_MIN_VALUE (index);
752: tree length;
753:
754: /* If UB is max (lb - 1, x), remove the MAX_EXPR since the
755: test for negative below covers it. */
756: if (TREE_CODE (ub) == MAX_EXPR
757: && TREE_CODE (TREE_OPERAND (ub, 0)) == MINUS_EXPR
758: && integer_onep (TREE_OPERAND (TREE_OPERAND (ub, 0), 1))
759: && operand_equal_p (TREE_OPERAND (TREE_OPERAND (ub, 0), 0),
760: lb, 0))
761: ub = TREE_OPERAND (ub, 1);
762: else if (TREE_CODE (ub) == MAX_EXPR
763: && TREE_CODE (TREE_OPERAND (ub, 1)) == MINUS_EXPR
764: && integer_onep (TREE_OPERAND (TREE_OPERAND (ub, 1), 1))
765: && operand_equal_p (TREE_OPERAND (TREE_OPERAND (ub, 1),
766: 0),
767: lb, 0))
768: ub = TREE_OPERAND (ub, 0);
769:
770: length = size_binop (PLUS_EXPR, size_one_node,
771: size_binop (MINUS_EXPR, ub, lb));
772:
773: /* If neither bound is a constant and sizetype is signed, make
774: sure the size is never negative. We should really do this
775: if *either* bound is non-constant, but this is the best
776: compromise between C and Ada. */
777: if (! TREE_UNSIGNED (sizetype)
778: && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST
779: && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST)
780: length = size_binop (MAX_EXPR, length, size_zero_node);
1.1 root 781:
782: TYPE_SIZE (type) = size_binop (MULT_EXPR, length,
783: TYPE_SIZE (element));
784: }
785:
786: /* Now round the alignment and size,
787: using machine-dependent criteria if any. */
788:
789: #ifdef ROUND_TYPE_ALIGN
790: TYPE_ALIGN (type)
791: = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT);
792: #else
793: TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT);
794: #endif
795:
796: #ifdef ROUND_TYPE_SIZE
797: if (TYPE_SIZE (type) != 0)
798: TYPE_SIZE (type)
799: = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type));
800: #endif
801:
802: TYPE_MODE (type) = BLKmode;
803: if (TYPE_SIZE (type) != 0
804: && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
805: /* BLKmode elements force BLKmode aggregate;
806: else extract/store fields may lose. */
807: && (TYPE_MODE (TREE_TYPE (type)) != BLKmode
808: || TYPE_NO_FORCE_BLK (TREE_TYPE (type))))
809: {
810: TYPE_MODE (type)
811: = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
812: MODE_INT, 1);
813:
1.1.1.2 root 814: if (STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
1.1 root 815: && TYPE_ALIGN (type) < TREE_INT_CST_LOW (TYPE_SIZE (type))
816: && TYPE_MODE (type) != BLKmode)
817: {
818: TYPE_NO_FORCE_BLK (type) = 1;
819: TYPE_MODE (type) = BLKmode;
820: }
821: }
822: break;
823: }
824:
825: case RECORD_TYPE:
826: pending_statics = layout_record (type);
827: TYPE_MODE (type) = BLKmode;
828: if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
829: {
830: tree field;
831: /* A record which has any BLKmode members must itself be BLKmode;
832: it can't go in a register.
833: Unless the member is BLKmode only because it isn't aligned. */
834: for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
835: {
836: int bitpos;
837:
838: if (TREE_CODE (field) != FIELD_DECL)
839: continue;
840:
841: if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
842: && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
843: goto record_lose;
844:
845: if (TREE_CODE (DECL_FIELD_BITPOS (field)) != INTEGER_CST)
846: goto record_lose;
847:
848: bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
849:
850: /* Must be BLKmode if any field crosses a word boundary,
851: since extract_bit_field can't handle that in registers. */
852: if (bitpos / BITS_PER_WORD
853: != ((TREE_INT_CST_LOW (DECL_SIZE (field)) + bitpos - 1)
854: / BITS_PER_WORD)
855: /* But there is no problem if the field is entire words. */
856: && TREE_INT_CST_LOW (DECL_SIZE (field)) % BITS_PER_WORD == 0)
857: goto record_lose;
858: }
859:
860: TYPE_MODE (type)
861: = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
862: MODE_INT, 1);
863:
864: /* If structure's known alignment is less than
865: what the scalar mode would need, and it matters,
866: then stick with BLKmode. */
1.1.1.2 root 867: if (STRICT_ALIGNMENT
868: && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
869: || (TYPE_ALIGN (type)
870: >= TREE_INT_CST_LOW (TYPE_SIZE (type)))))
1.1 root 871: {
872: if (TYPE_MODE (type) != BLKmode)
873: /* If this is the only reason this type is BLKmode,
874: then don't force containing types to be BLKmode. */
875: TYPE_NO_FORCE_BLK (type) = 1;
876: TYPE_MODE (type) = BLKmode;
877: }
1.1.1.2 root 878:
1.1 root 879: record_lose: ;
880: }
881:
882: /* Lay out any static members. This is done now
883: because their type may use the record's type. */
884: while (pending_statics)
885: {
886: layout_decl (TREE_VALUE (pending_statics), 0);
887: pending_statics = TREE_CHAIN (pending_statics);
888: }
889: break;
890:
891: case UNION_TYPE:
1.1.1.5 root 892: case QUAL_UNION_TYPE:
1.1 root 893: layout_union (type);
894: TYPE_MODE (type) = BLKmode;
895: if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
896: /* If structure's known alignment is less than
897: what the scalar mode would need, and it matters,
898: then stick with BLKmode. */
1.1.1.2 root 899: && (! STRICT_ALIGNMENT
900: || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT
901: || TYPE_ALIGN (type) >= TREE_INT_CST_LOW (TYPE_SIZE (type))))
1.1 root 902: {
903: tree field;
904: /* A union which has any BLKmode members must itself be BLKmode;
905: it can't go in a register.
906: Unless the member is BLKmode only because it isn't aligned. */
907: for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
908: {
909: if (TREE_CODE (field) != FIELD_DECL)
910: continue;
911:
912: if (TYPE_MODE (TREE_TYPE (field)) == BLKmode
913: && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)))
914: goto union_lose;
915: }
916:
917: TYPE_MODE (type)
918: = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)),
919: MODE_INT, 1);
920:
921: union_lose: ;
922: }
923: break;
924:
1.1.1.7 root 925: /* Pascal and Chill types */
1.1.1.4 root 926: case BOOLEAN_TYPE: /* store one byte/boolean for now. */
927: TYPE_MODE (type) = QImode;
928: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
929: TYPE_PRECISION (type) = 1;
930: TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
1.1.1.7 root 931: if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
932: && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
933: TREE_UNSIGNED (type) = 1;
1.1.1.4 root 934: break;
935:
936: case CHAR_TYPE:
937: TYPE_MODE (type) = QImode;
938: TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
939: TYPE_PRECISION (type) = GET_MODE_BITSIZE (TYPE_MODE (type));
940: TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
941: break;
942:
1.1.1.7 root 943: case SET_TYPE:
944: if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST
945: || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST)
946: abort();
947: else
948: {
949: #ifndef SET_WORD_SIZE
950: #define SET_WORD_SIZE BITS_PER_WORD
951: #endif
952: int alignment = set_alignment ? set_alignment : SET_WORD_SIZE;
953: int size_in_bits =
954: TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
955: - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1;
956: int rounded_size
957: = ((size_in_bits + alignment - 1) / alignment) * alignment;
958: if (rounded_size > alignment)
959: TYPE_MODE (type) = BLKmode;
960: else
961: TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1);
962: TYPE_SIZE (type) = size_int (rounded_size);
963: TYPE_ALIGN (type) = alignment;
964: TYPE_PRECISION (type) = size_in_bits;
965: }
966: break;
967:
1.1.1.4 root 968: case FILE_TYPE:
969: /* The size may vary in different languages, so the language front end
970: should fill in the size. */
971: TYPE_ALIGN (type) = BIGGEST_ALIGNMENT;
972: TYPE_MODE (type) = BLKmode;
973: break;
974:
1.1 root 975: default:
976: abort ();
977: } /* end switch */
978:
979: /* Normally, use the alignment corresponding to the mode chosen.
980: However, where strict alignment is not required, avoid
981: over-aligning structures, since most compilers do not do this
982: alignment. */
983:
984: if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode
1.1.1.2 root 985: && (STRICT_ALIGNMENT
986: || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE
1.1.1.5 root 987: && TREE_CODE (type) != QUAL_UNION_TYPE
1.1.1.2 root 988: && TREE_CODE (type) != ARRAY_TYPE)))
1.1 root 989: TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type));
990:
991: /* Evaluate nonconstant size only once, either now or as soon as safe. */
992: if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
993: TYPE_SIZE (type) = variable_size (TYPE_SIZE (type));
994:
995: /* Also layout any other variants of the type. */
996: if (TYPE_NEXT_VARIANT (type)
997: || type != TYPE_MAIN_VARIANT (type))
998: {
999: tree variant;
1000: /* Record layout info of this variant. */
1001: tree size = TYPE_SIZE (type);
1002: int align = TYPE_ALIGN (type);
1003: enum machine_mode mode = TYPE_MODE (type);
1004:
1005: /* Copy it into all variants. */
1006: for (variant = TYPE_MAIN_VARIANT (type);
1007: variant;
1008: variant = TYPE_NEXT_VARIANT (variant))
1009: {
1010: TYPE_SIZE (variant) = size;
1011: TYPE_ALIGN (variant) = align;
1012: TYPE_MODE (variant) = mode;
1013: }
1014: }
1015:
1016: pop_obstacks ();
1017: resume_momentary (old);
1018: }
1019:
1020: /* Create and return a type for signed integers of PRECISION bits. */
1021:
1022: tree
1023: make_signed_type (precision)
1024: int precision;
1025: {
1026: register tree type = make_node (INTEGER_TYPE);
1027:
1028: TYPE_PRECISION (type) = precision;
1029:
1030: /* Create the extreme values based on the number of bits. */
1031:
1032: TYPE_MIN_VALUE (type)
1.1.1.4 root 1033: = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1034: ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
1035: (((HOST_WIDE_INT) (-1)
1036: << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1.1.1.5 root 1037: ? precision - HOST_BITS_PER_WIDE_INT - 1
1.1.1.4 root 1038: : 0))));
1.1 root 1039: TYPE_MAX_VALUE (type)
1.1.1.5 root 1040: = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1.1.1.4 root 1041: ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1042: (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1043: ? (((HOST_WIDE_INT) 1
1.1.1.5 root 1044: << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
1.1 root 1045: : 0));
1046:
1047: /* Give this type's extreme values this type as their type. */
1048:
1049: TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1050: TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1051:
1052: /* The first type made with this or `make_unsigned_type'
1053: is the type for size values. */
1054:
1055: if (sizetype == 0)
1056: {
1057: sizetype = type;
1058: }
1059:
1060: /* Lay out the type: set its alignment, size, etc. */
1061:
1062: layout_type (type);
1063:
1064: return type;
1065: }
1066:
1067: /* Create and return a type for unsigned integers of PRECISION bits. */
1068:
1069: tree
1070: make_unsigned_type (precision)
1071: int precision;
1072: {
1073: register tree type = make_node (INTEGER_TYPE);
1074:
1075: TYPE_PRECISION (type) = precision;
1076:
1077: /* The first type made with this or `make_signed_type'
1078: is the type for size values. */
1079:
1080: if (sizetype == 0)
1081: {
1082: sizetype = type;
1083: }
1084:
1085: fixup_unsigned_type (type);
1086: return type;
1087: }
1088:
1089: /* Set the extreme values of TYPE based on its precision in bits,
1.1.1.5 root 1090: then lay it out. Used when make_signed_type won't do
1.1.1.4 root 1091: because the tree code is not INTEGER_TYPE.
1092: E.g. for Pascal, when the -fsigned-char option is given. */
1093:
1094: void
1095: fixup_signed_type (type)
1096: tree type;
1097: {
1098: register int precision = TYPE_PRECISION (type);
1099:
1100: TYPE_MIN_VALUE (type)
1.1.1.5 root 1101: = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1102: ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)),
1103: (((HOST_WIDE_INT) (-1)
1104: << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1105: ? precision - HOST_BITS_PER_WIDE_INT - 1
1106: : 0))));
1.1.1.4 root 1107: TYPE_MAX_VALUE (type)
1.1.1.5 root 1108: = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0
1109: ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1),
1110: (precision - HOST_BITS_PER_WIDE_INT - 1 > 0
1111: ? (((HOST_WIDE_INT) 1
1112: << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1
1.1.1.4 root 1113: : 0));
1114:
1115: TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1116: TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1117:
1118: /* Lay out the type: set its alignment, size, etc. */
1119:
1120: layout_type (type);
1121: }
1122:
1123: /* Set the extreme values of TYPE based on its precision in bits,
1.1.1.5 root 1124: then lay it out. This is used both in `make_unsigned_type'
1.1 root 1125: and for enumeral types. */
1126:
1127: void
1128: fixup_unsigned_type (type)
1129: tree type;
1130: {
1131: register int precision = TYPE_PRECISION (type);
1132:
1133: TYPE_MIN_VALUE (type) = build_int_2 (0, 0);
1134: TYPE_MAX_VALUE (type)
1.1.1.4 root 1135: = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0
1.1.1.5 root 1136: ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1,
1.1.1.4 root 1137: precision - HOST_BITS_PER_WIDE_INT > 0
1138: ? ((unsigned HOST_WIDE_INT) ~0
1139: >> (HOST_BITS_PER_WIDE_INT
1140: - (precision - HOST_BITS_PER_WIDE_INT)))
1.1 root 1141: : 0);
1142: TREE_TYPE (TYPE_MIN_VALUE (type)) = type;
1143: TREE_TYPE (TYPE_MAX_VALUE (type)) = type;
1144:
1145: /* Lay out the type: set its alignment, size, etc. */
1146:
1147: layout_type (type);
1148: }
1149:
1150: /* Find the best machine mode to use when referencing a bit field of length
1151: BITSIZE bits starting at BITPOS.
1152:
1153: The underlying object is known to be aligned to a boundary of ALIGN bits.
1154: If LARGEST_MODE is not VOIDmode, it means that we should not use a mode
1155: larger than LARGEST_MODE (usually SImode).
1156:
1157: If no mode meets all these conditions, we return VOIDmode. Otherwise, if
1158: VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest
1159: mode meeting these conditions.
1160:
1.1.1.4 root 1161: Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return
1162: the largest mode (but a mode no wider than UNITS_PER_WORD) that meets
1163: all the conditions. */
1.1 root 1164:
1165: enum machine_mode
1166: get_best_mode (bitsize, bitpos, align, largest_mode, volatilep)
1167: int bitsize, bitpos;
1168: int align;
1169: enum machine_mode largest_mode;
1170: int volatilep;
1171: {
1172: enum machine_mode mode;
1173: int unit;
1174:
1175: /* Find the narrowest integer mode that contains the bit field. */
1176: for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
1177: mode = GET_MODE_WIDER_MODE (mode))
1178: {
1179: unit = GET_MODE_BITSIZE (mode);
1180: if (bitpos / unit == (bitpos + bitsize - 1) / unit)
1181: break;
1182: }
1183:
1184: if (mode == MAX_MACHINE_MODE
1185: /* It is tempting to omit the following line
1.1.1.2 root 1186: if STRICT_ALIGNMENT is true.
1.1 root 1187: But that is incorrect, since if the bitfield uses part of 3 bytes
1188: and we use a 4-byte mode, we could get a spurious segv
1189: if the extra 4th byte is past the end of memory.
1190: (Though at least one Unix compiler ignores this problem:
1191: that on the Sequent 386 machine. */
1192: || MIN (unit, BIGGEST_ALIGNMENT) > align
1193: || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode)))
1194: return VOIDmode;
1195:
1.1.1.4 root 1196: if (SLOW_BYTE_ACCESS && ! volatilep)
1197: {
1198: enum machine_mode wide_mode = VOIDmode, tmode;
1199:
1200: for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode;
1201: tmode = GET_MODE_WIDER_MODE (tmode))
1202: {
1203: unit = GET_MODE_BITSIZE (tmode);
1204: if (bitpos / unit == (bitpos + bitsize - 1) / unit
1205: && unit <= BITS_PER_WORD
1206: && unit <= MIN (align, BIGGEST_ALIGNMENT)
1207: && (largest_mode == VOIDmode
1208: || unit <= GET_MODE_BITSIZE (largest_mode)))
1209: wide_mode = tmode;
1210: }
1211:
1212: if (wide_mode != VOIDmode)
1213: return wide_mode;
1214: }
1.1 root 1215:
1216: return mode;
1217: }
1218:
1219: /* Save all variables describing the current status into the structure *P.
1220: This is used before starting a nested function. */
1221:
1222: void
1223: save_storage_status (p)
1224: struct function *p;
1225: {
1226: #if 0 /* Need not save, since always 0 and non0 (resp.) within a function. */
1227: p->pending_sizes = pending_sizes;
1228: p->immediate_size_expand = immediate_size_expand;
1229: #endif /* 0 */
1230: }
1231:
1232: /* Restore all variables describing the current status from the structure *P.
1233: This is used after a nested function. */
1234:
1235: void
1236: restore_storage_status (p)
1237: struct function *p;
1238: {
1239: #if 0
1240: pending_sizes = p->pending_sizes;
1241: immediate_size_expand = p->immediate_size_expand;
1242: #endif /* 0 */
1243: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.