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