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