stor-layout.c revision 18336
1/* C-compiler utilities for types and variables storage layout 2 Copyright (C) 1987, 88, 92, 93, 94, 1995 Free Software Foundation, Inc. 3 4This file is part of GNU CC. 5 6GNU CC is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 2, or (at your option) 9any later version. 10 11GNU CC is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with GNU CC; see the file COPYING. If not, write to 18the Free Software Foundation, 59 Temple Place - Suite 330, 19Boston, MA 02111-1307, USA. */ 20 21 22#include "config.h" 23#include <stdio.h> 24 25#include "tree.h" 26#include "flags.h" 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 35tree sizetype; 36 37/* An integer constant with value 0 whose type is sizetype. */ 38 39tree size_zero_node; 40 41/* An integer constant with value 1 whose type is sizetype. */ 42 43tree size_one_node; 44 45/* If nonzero, this is an upper limit on alignment of structure fields. 46 The value is measured in bits. */ 47int maximum_field_alignment; 48 49/* If non-zero, the alignment of a bitstring or (power-)set value, in bits. 50 May be overridden by front-ends. */ 51int set_alignment = 0; 52 53#define GET_MODE_ALIGNMENT(MODE) \ 54 MIN (BIGGEST_ALIGNMENT, \ 55 MAX (1, (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))) 56 57static enum machine_mode smallest_mode_for_size PROTO((unsigned int, 58 enum mode_class)); 59static tree layout_record PROTO((tree)); 60static void layout_union PROTO((tree)); 61 62/* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */ 63 64static tree pending_sizes; 65 66/* Nonzero means cannot safely call expand_expr now, 67 so put variable sizes onto `pending_sizes' instead. */ 68 69int immediate_size_expand; 70 71tree 72get_pending_sizes () 73{ 74 tree chain = pending_sizes; 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; 80 pending_sizes = 0; 81 return chain; 82} 83 84void 85put_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 95 to serve as the actual size-expression for a type or decl. */ 96 97tree 98variable_size (size) 99 tree size; 100{ 101 /* If the language-processor is to take responsibility for variable-sized 102 items (e.g., languages which have elaboration procedures like Ada), 103 just return SIZE unchanged. Likewise for self-referential sizes. */ 104 if (TREE_CONSTANT (size) 105 || global_bindings_p () < 0 || contains_placeholder_p (size)) 106 return size; 107 108 size = save_expr (size); 109 110 if (global_bindings_p ()) 111 { 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 117 return size_int (1); 118 } 119 120 if (immediate_size_expand) 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); 125 else 126 pending_sizes = tree_cons (NULL_TREE, size, pending_sizes); 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 140enum machine_mode 141mode_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 151 /* Get the first mode which has this size, in the specified class. */ 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 160/* Similar, but never return BLKmode; return the narrowest mode that 161 contains at least the requested number of bits. */ 162 163static enum machine_mode 164smallest_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 180/* Return the value of VALUE, rounded up to a multiple of DIVISOR. */ 181 182tree 183round_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 205void 206layout_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); 212 int spec_size = DECL_FIELD_SIZE (decl); 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); 231 if (DECL_SIZE (decl) == 0) 232 DECL_SIZE (decl) = TYPE_SIZE (type); 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. 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))) 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) 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); 257 else if (flag_pack_struct) 258 DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT); 259 } 260 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 297static tree 298layout_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 { 323 register int known_align = var_size ? var_align : const_size; 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 { 334 pending_statics = tree_cons (NULL_TREE, field, pending_statics); 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. 343 For a packed field, use the alignment as specified, 344 disregarding what the type would want. */ 345 if (DECL_PACKED (field)) 346 desired_align = DECL_ALIGN (field); 347 layout_decl (field, known_align); 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 364 && DECL_BIT_FIELD_TYPE (field) 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) 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); 382 else if (flag_pack_struct) 383 type_align = MIN (type_align, BITS_PER_UNIT); 384 385 record_align = MAX (record_align, type_align); 386 } 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) 410 var_size = size_binop (PLUS_EXPR, var_size, 411 size_int (const_size)); 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 422 && DECL_BIT_FIELD_TYPE (field) 423 && !DECL_PACKED (field) 424 /* If #pragma pack is in effect, turn off this feature. */ 425 && maximum_field_alignment == 0 426 && !flag_pack_struct 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. */ 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. */ 439 if (const_size / type_align 440 != (const_size + (field_size % type_align) - 1) / type_align) 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 451 && DECL_BIT_FIELD_TYPE (field) 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 459 if (maximum_field_alignment != 0) 460 type_align = MIN (type_align, maximum_field_alignment); 461 else if (flag_pack_struct) 462 type_align = MIN (type_align, BITS_PER_UNIT); 463 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 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 } 490 491 /* Now add size of this field to the size of the record. */ 492 493 { 494 register tree dsize = DECL_SIZE (field); 495 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. */; 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. */ 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 549/* Lay out a UNION_TYPE or QUAL_UNION_TYPE type. 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 555static void 556layout_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 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 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. */ 594 if (PCC_BITFIELD_TYPE_MATTERS && DECL_BIT_FIELD_TYPE (field)) 595 union_align = MAX (union_align, TYPE_ALIGN (TREE_TYPE (field))); 596#endif 597 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)); 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 657void 658layout_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 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 (); 680 681 switch (TREE_CODE (type)) 682 { 683 case LANG_TYPE: 684 /* This kind of type is the responsibility 685 of the language-specific code. */ 686 abort (); 687 688 case INTEGER_TYPE: 689 case ENUMERAL_TYPE: 690 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST 691 && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0) 692 TREE_UNSIGNED (type) = 1; 693 694 TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type), 695 MODE_INT); 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 720 case OFFSET_TYPE: 721 TYPE_SIZE (type) = size_int (POINTER_SIZE); 722 TYPE_MODE (type) = ptr_mode; 723 break; 724 725 case FUNCTION_TYPE: 726 case METHOD_TYPE: 727 TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0); 728 TYPE_SIZE (type) = size_int (2 * POINTER_SIZE); 729 break; 730 731 case POINTER_TYPE: 732 case REFERENCE_TYPE: 733 TYPE_MODE (type) = ptr_mode; 734 TYPE_SIZE (type) = size_int (POINTER_SIZE); 735 TREE_UNSIGNED (type) = 1; 736 TYPE_PRECISION (type) = POINTER_SIZE; 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 { 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); 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 814 if (STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT 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. */ 867 if (STRICT_ALIGNMENT 868 && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT 869 || (TYPE_ALIGN (type) 870 >= TREE_INT_CST_LOW (TYPE_SIZE (type))))) 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 } 878 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: 892 case QUAL_UNION_TYPE: 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. */ 899 && (! STRICT_ALIGNMENT 900 || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT 901 || TYPE_ALIGN (type) >= TREE_INT_CST_LOW (TYPE_SIZE (type)))) 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 925 /* Pascal and Chill types */ 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)); 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; 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 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 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 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 985 && (STRICT_ALIGNMENT 986 || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE 987 && TREE_CODE (type) != QUAL_UNION_TYPE 988 && TREE_CODE (type) != ARRAY_TYPE))) 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 1022tree 1023make_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) 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 1037 ? precision - HOST_BITS_PER_WIDE_INT - 1 1038 : 0)))); 1039 TYPE_MAX_VALUE (type) 1040 = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 1041 ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1), 1042 (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 1043 ? (((HOST_WIDE_INT) 1 1044 << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1 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 1069tree 1070make_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, 1090 then lay it out. Used when make_signed_type won't do 1091 because the tree code is not INTEGER_TYPE. 1092 E.g. for Pascal, when the -fsigned-char option is given. */ 1093 1094void 1095fixup_signed_type (type) 1096 tree type; 1097{ 1098 register int precision = TYPE_PRECISION (type); 1099 1100 TYPE_MIN_VALUE (type) 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)))); 1107 TYPE_MAX_VALUE (type) 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 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, 1124 then lay it out. This is used both in `make_unsigned_type' 1125 and for enumeral types. */ 1126 1127void 1128fixup_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) 1135 = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0 1136 ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1, 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))) 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 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. */ 1164 1165enum machine_mode 1166get_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 1186 if STRICT_ALIGNMENT is true. 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 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 } 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 1222void 1223save_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 1235void 1236restore_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} 1244