stor-layout.c revision 132718
1/* C-compiler utilities for types and variables storage layout 2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998, 3 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2002111-1307, USA. */ 21 22 23#include "config.h" 24#include "system.h" 25#include "coretypes.h" 26#include "tm.h" 27#include "tree.h" 28#include "rtl.h" 29#include "tm_p.h" 30#include "flags.h" 31#include "function.h" 32#include "expr.h" 33#include "toplev.h" 34#include "ggc.h" 35#include "target.h" 36#include "langhooks.h" 37 38/* Set to one when set_sizetype has been called. */ 39static int sizetype_set; 40 41/* List of types created before set_sizetype has been called. We do not 42 make this a GGC root since we want these nodes to be reclaimed. */ 43static tree early_type_list; 44 45/* Data type for the expressions representing sizes of data types. 46 It is the first integer type laid out. */ 47tree sizetype_tab[(int) TYPE_KIND_LAST]; 48 49/* If nonzero, this is an upper limit on alignment of structure fields. 50 The value is measured in bits. */ 51unsigned int maximum_field_alignment; 52 53/* If nonzero, the alignment of a bitstring or (power-)set value, in bits. 54 May be overridden by front-ends. */ 55unsigned int set_alignment = 0; 56 57/* Nonzero if all REFERENCE_TYPEs are internal and hence should be 58 allocated in Pmode, not ptr_mode. Set only by internal_reference_types 59 called only by a front end. */ 60static int reference_types_internal = 0; 61 62static void finalize_record_size (record_layout_info); 63static void finalize_type_size (tree); 64static void place_union_field (record_layout_info, tree); 65#if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED) 66static int excess_unit_span (HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT, 67 HOST_WIDE_INT, tree); 68#endif 69static unsigned int update_alignment_for_field (record_layout_info, tree, 70 unsigned int); 71extern void debug_rli (record_layout_info); 72 73/* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */ 74 75static GTY(()) tree pending_sizes; 76 77/* Nonzero means cannot safely call expand_expr now, 78 so put variable sizes onto `pending_sizes' instead. */ 79 80int immediate_size_expand; 81 82/* Show that REFERENCE_TYPES are internal and should be Pmode. Called only 83 by front end. */ 84 85void 86internal_reference_types (void) 87{ 88 reference_types_internal = 1; 89} 90 91/* Get a list of all the objects put on the pending sizes list. */ 92 93tree 94get_pending_sizes (void) 95{ 96 tree chain = pending_sizes; 97 tree t; 98 99 /* Put each SAVE_EXPR into the current function. */ 100 for (t = chain; t; t = TREE_CHAIN (t)) 101 SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = current_function_decl; 102 103 pending_sizes = 0; 104 return chain; 105} 106 107/* Return nonzero if EXPR is present on the pending sizes list. */ 108 109int 110is_pending_size (tree expr) 111{ 112 tree t; 113 114 for (t = pending_sizes; t; t = TREE_CHAIN (t)) 115 if (TREE_VALUE (t) == expr) 116 return 1; 117 return 0; 118} 119 120/* Add EXPR to the pending sizes list. */ 121 122void 123put_pending_size (tree expr) 124{ 125 /* Strip any simple arithmetic from EXPR to see if it has an underlying 126 SAVE_EXPR. */ 127 expr = skip_simple_arithmetic (expr); 128 129 if (TREE_CODE (expr) == SAVE_EXPR) 130 pending_sizes = tree_cons (NULL_TREE, expr, pending_sizes); 131} 132 133/* Put a chain of objects into the pending sizes list, which must be 134 empty. */ 135 136void 137put_pending_sizes (tree chain) 138{ 139 if (pending_sizes) 140 abort (); 141 142 pending_sizes = chain; 143} 144 145/* Given a size SIZE that may not be a constant, return a SAVE_EXPR 146 to serve as the actual size-expression for a type or decl. */ 147 148tree 149variable_size (tree size) 150{ 151 tree save; 152 153 /* If the language-processor is to take responsibility for variable-sized 154 items (e.g., languages which have elaboration procedures like Ada), 155 just return SIZE unchanged. Likewise for self-referential sizes and 156 constant sizes. */ 157 if (TREE_CONSTANT (size) 158 || (*lang_hooks.decls.global_bindings_p) () < 0 159 || CONTAINS_PLACEHOLDER_P (size)) 160 return size; 161 162 if (TREE_CODE (size) == MINUS_EXPR && integer_onep (TREE_OPERAND (size, 1))) 163 /* If this is the upper bound of a C array, leave the minus 1 outside 164 the SAVE_EXPR so it can be folded away. */ 165 TREE_OPERAND (size, 0) = save = save_expr (TREE_OPERAND (size, 0)); 166 else 167 size = save = save_expr (size); 168 169 /* If an array with a variable number of elements is declared, and 170 the elements require destruction, we will emit a cleanup for the 171 array. That cleanup is run both on normal exit from the block 172 and in the exception-handler for the block. Normally, when code 173 is used in both ordinary code and in an exception handler it is 174 `unsaved', i.e., all SAVE_EXPRs are recalculated. However, we do 175 not wish to do that here; the array-size is the same in both 176 places. */ 177 if (TREE_CODE (save) == SAVE_EXPR) 178 SAVE_EXPR_PERSISTENT_P (save) = 1; 179 180 if ((*lang_hooks.decls.global_bindings_p) ()) 181 { 182 if (TREE_CONSTANT (size)) 183 error ("type size can't be explicitly evaluated"); 184 else 185 error ("variable-size type declared outside of any function"); 186 187 return size_one_node; 188 } 189 190 if (immediate_size_expand) 191 expand_expr (save, const0_rtx, VOIDmode, 0); 192 else if (cfun != 0 && cfun->x_dont_save_pending_sizes_p) 193 /* The front-end doesn't want us to keep a list of the expressions 194 that determine sizes for variable size objects. */ 195 ; 196 else 197 put_pending_size (save); 198 199 return size; 200} 201 202#ifndef MAX_FIXED_MODE_SIZE 203#define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode) 204#endif 205 206/* Return the machine mode to use for a nonscalar of SIZE bits. The 207 mode must be in class CLASS, and have exactly that many value bits; 208 it may have padding as well. If LIMIT is nonzero, modes of wider 209 than MAX_FIXED_MODE_SIZE will not be used. */ 210 211enum machine_mode 212mode_for_size (unsigned int size, enum mode_class class, int limit) 213{ 214 enum machine_mode mode; 215 216 if (limit && size > MAX_FIXED_MODE_SIZE) 217 return BLKmode; 218 219 /* Get the first mode which has this size, in the specified class. */ 220 for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; 221 mode = GET_MODE_WIDER_MODE (mode)) 222 if (GET_MODE_PRECISION (mode) == size) 223 return mode; 224 225 return BLKmode; 226} 227 228/* Similar, except passed a tree node. */ 229 230enum machine_mode 231mode_for_size_tree (tree size, enum mode_class class, int limit) 232{ 233 if (TREE_CODE (size) != INTEGER_CST 234 || TREE_OVERFLOW (size) 235 /* What we really want to say here is that the size can fit in a 236 host integer, but we know there's no way we'd find a mode for 237 this many bits, so there's no point in doing the precise test. */ 238 || compare_tree_int (size, 1000) > 0) 239 return BLKmode; 240 else 241 return mode_for_size (tree_low_cst (size, 1), class, limit); 242} 243 244/* Similar, but never return BLKmode; return the narrowest mode that 245 contains at least the requested number of value bits. */ 246 247enum machine_mode 248smallest_mode_for_size (unsigned int size, enum mode_class class) 249{ 250 enum machine_mode mode; 251 252 /* Get the first mode which has at least this size, in the 253 specified class. */ 254 for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; 255 mode = GET_MODE_WIDER_MODE (mode)) 256 if (GET_MODE_PRECISION (mode) >= size) 257 return mode; 258 259 abort (); 260} 261 262/* Find an integer mode of the exact same size, or BLKmode on failure. */ 263 264enum machine_mode 265int_mode_for_mode (enum machine_mode mode) 266{ 267 switch (GET_MODE_CLASS (mode)) 268 { 269 case MODE_INT: 270 case MODE_PARTIAL_INT: 271 break; 272 273 case MODE_COMPLEX_INT: 274 case MODE_COMPLEX_FLOAT: 275 case MODE_FLOAT: 276 case MODE_VECTOR_INT: 277 case MODE_VECTOR_FLOAT: 278 mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0); 279 break; 280 281 case MODE_RANDOM: 282 if (mode == BLKmode) 283 break; 284 285 /* ... fall through ... */ 286 287 case MODE_CC: 288 default: 289 abort (); 290 } 291 292 return mode; 293} 294 295/* Return the alignment of MODE. This will be bounded by 1 and 296 BIGGEST_ALIGNMENT. */ 297 298unsigned int 299get_mode_alignment (enum machine_mode mode) 300{ 301 return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT)); 302} 303 304/* Return the value of VALUE, rounded up to a multiple of DIVISOR. 305 This can only be applied to objects of a sizetype. */ 306 307tree 308round_up (tree value, int divisor) 309{ 310 tree arg = size_int_type (divisor, TREE_TYPE (value)); 311 312 return size_binop (MULT_EXPR, size_binop (CEIL_DIV_EXPR, value, arg), arg); 313} 314 315/* Likewise, but round down. */ 316 317tree 318round_down (tree value, int divisor) 319{ 320 tree arg = size_int_type (divisor, TREE_TYPE (value)); 321 322 return size_binop (MULT_EXPR, size_binop (FLOOR_DIV_EXPR, value, arg), arg); 323} 324 325/* Subroutine of layout_decl: Force alignment required for the data type. 326 But if the decl itself wants greater alignment, don't override that. */ 327 328static inline void 329do_type_align (tree type, tree decl) 330{ 331 if (TYPE_ALIGN (type) > DECL_ALIGN (decl)) 332 { 333 DECL_ALIGN (decl) = TYPE_ALIGN (type); 334 if (TREE_CODE (decl) == FIELD_DECL) 335 DECL_USER_ALIGN (decl) = TYPE_USER_ALIGN (type); 336 } 337} 338 339/* Set the size, mode and alignment of a ..._DECL node. 340 TYPE_DECL does need this for C++. 341 Note that LABEL_DECL and CONST_DECL nodes do not need this, 342 and FUNCTION_DECL nodes have them set up in a special (and simple) way. 343 Don't call layout_decl for them. 344 345 KNOWN_ALIGN is the amount of alignment we can assume this 346 decl has with no special effort. It is relevant only for FIELD_DECLs 347 and depends on the previous fields. 348 All that matters about KNOWN_ALIGN is which powers of 2 divide it. 349 If KNOWN_ALIGN is 0, it means, "as much alignment as you like": 350 the record will be aligned to suit. */ 351 352void 353layout_decl (tree decl, unsigned int known_align) 354{ 355 tree type = TREE_TYPE (decl); 356 enum tree_code code = TREE_CODE (decl); 357 rtx rtl = NULL_RTX; 358 359 if (code == CONST_DECL) 360 return; 361 else if (code != VAR_DECL && code != PARM_DECL && code != RESULT_DECL 362 && code != TYPE_DECL && code != FIELD_DECL) 363 abort (); 364 365 rtl = DECL_RTL_IF_SET (decl); 366 367 if (type == error_mark_node) 368 type = void_type_node; 369 370 /* Usually the size and mode come from the data type without change, 371 however, the front-end may set the explicit width of the field, so its 372 size may not be the same as the size of its type. This happens with 373 bitfields, of course (an `int' bitfield may be only 2 bits, say), but it 374 also happens with other fields. For example, the C++ front-end creates 375 zero-sized fields corresponding to empty base classes, and depends on 376 layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the 377 size in bytes from the size in bits. If we have already set the mode, 378 don't set it again since we can be called twice for FIELD_DECLs. */ 379 380 TREE_UNSIGNED (decl) = TREE_UNSIGNED (type); 381 if (DECL_MODE (decl) == VOIDmode) 382 DECL_MODE (decl) = TYPE_MODE (type); 383 384 if (DECL_SIZE (decl) == 0) 385 { 386 DECL_SIZE (decl) = TYPE_SIZE (type); 387 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type); 388 } 389 else if (DECL_SIZE_UNIT (decl) == 0) 390 DECL_SIZE_UNIT (decl) 391 = convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl), 392 bitsize_unit_node)); 393 394 if (code != FIELD_DECL) 395 /* For non-fields, update the alignment from the type. */ 396 do_type_align (type, decl); 397 else 398 /* For fields, it's a bit more complicated... */ 399 { 400 bool old_user_align = DECL_USER_ALIGN (decl); 401 402 if (DECL_BIT_FIELD (decl)) 403 { 404 DECL_BIT_FIELD_TYPE (decl) = type; 405 406 /* A zero-length bit-field affects the alignment of the next 407 field. */ 408 if (integer_zerop (DECL_SIZE (decl)) 409 && ! DECL_PACKED (decl) 410 && ! (*targetm.ms_bitfield_layout_p) (DECL_FIELD_CONTEXT (decl))) 411 { 412#ifdef PCC_BITFIELD_TYPE_MATTERS 413 if (PCC_BITFIELD_TYPE_MATTERS) 414 do_type_align (type, decl); 415 else 416#endif 417 { 418#ifdef EMPTY_FIELD_BOUNDARY 419 if (EMPTY_FIELD_BOUNDARY > DECL_ALIGN (decl)) 420 { 421 DECL_ALIGN (decl) = EMPTY_FIELD_BOUNDARY; 422 DECL_USER_ALIGN (decl) = 0; 423 } 424#endif 425 } 426 } 427 428 /* See if we can use an ordinary integer mode for a bit-field. 429 Conditions are: a fixed size that is correct for another mode 430 and occupying a complete byte or bytes on proper boundary. */ 431 if (TYPE_SIZE (type) != 0 432 && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 433 && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT) 434 { 435 enum machine_mode xmode 436 = mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1); 437 438 if (xmode != BLKmode 439 && (known_align == 0 440 || known_align >= GET_MODE_ALIGNMENT (xmode))) 441 { 442 DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode), 443 DECL_ALIGN (decl)); 444 DECL_MODE (decl) = xmode; 445 DECL_BIT_FIELD (decl) = 0; 446 } 447 } 448 449 /* Turn off DECL_BIT_FIELD if we won't need it set. */ 450 if (TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode 451 && known_align >= TYPE_ALIGN (type) 452 && DECL_ALIGN (decl) >= TYPE_ALIGN (type)) 453 DECL_BIT_FIELD (decl) = 0; 454 } 455 else if (DECL_PACKED (decl) && DECL_USER_ALIGN (decl)) 456 /* Don't touch DECL_ALIGN. For other packed fields, go ahead and 457 round up; we'll reduce it again below. We want packing to 458 supersede USER_ALIGN inherited from the type, but defer to 459 alignment explicitly specified on the field decl. */; 460 else 461 do_type_align (type, decl); 462 463 /* If the field is of variable size, we can't misalign it since we 464 have no way to make a temporary to align the result. But this 465 isn't an issue if the decl is not addressable. Likewise if it 466 is of unknown size. 467 468 Note that do_type_align may set DECL_USER_ALIGN, so we need to 469 check old_user_align instead. */ 470 if (DECL_PACKED (decl) 471 && !old_user_align 472 && (DECL_NONADDRESSABLE_P (decl) 473 || DECL_SIZE_UNIT (decl) == 0 474 || TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST)) 475 DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT); 476 477 /* Should this be controlled by DECL_USER_ALIGN, too? */ 478 if (maximum_field_alignment != 0) 479 DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment); 480 if (! DECL_USER_ALIGN (decl)) 481 { 482 /* Some targets (i.e. i386, VMS) limit struct field alignment 483 to a lower boundary than alignment of variables unless 484 it was overridden by attribute aligned. */ 485#ifdef BIGGEST_FIELD_ALIGNMENT 486 DECL_ALIGN (decl) 487 = MIN (DECL_ALIGN (decl), (unsigned) BIGGEST_FIELD_ALIGNMENT); 488#endif 489#ifdef ADJUST_FIELD_ALIGN 490 DECL_ALIGN (decl) = ADJUST_FIELD_ALIGN (decl, DECL_ALIGN (decl)); 491#endif 492 } 493 } 494 495 /* Evaluate nonconstant size only once, either now or as soon as safe. */ 496 if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) 497 DECL_SIZE (decl) = variable_size (DECL_SIZE (decl)); 498 if (DECL_SIZE_UNIT (decl) != 0 499 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST) 500 DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl)); 501 502 /* If requested, warn about definitions of large data objects. */ 503 if (warn_larger_than 504 && (code == VAR_DECL || code == PARM_DECL) 505 && ! DECL_EXTERNAL (decl)) 506 { 507 tree size = DECL_SIZE_UNIT (decl); 508 509 if (size != 0 && TREE_CODE (size) == INTEGER_CST 510 && compare_tree_int (size, larger_than_size) > 0) 511 { 512 int size_as_int = TREE_INT_CST_LOW (size); 513 514 if (compare_tree_int (size, size_as_int) == 0) 515 warning ("%Jsize of '%D' is %d bytes", decl, decl, size_as_int); 516 else 517 warning ("%Jsize of '%D' is larger than %d bytes", 518 decl, decl, larger_than_size); 519 } 520 } 521 522 /* If the RTL was already set, update its mode and mem attributes. */ 523 if (rtl) 524 { 525 PUT_MODE (rtl, DECL_MODE (decl)); 526 SET_DECL_RTL (decl, 0); 527 set_mem_attributes (rtl, decl, 1); 528 SET_DECL_RTL (decl, rtl); 529 } 530} 531 532/* Hook for a front-end function that can modify the record layout as needed 533 immediately before it is finalized. */ 534 535void (*lang_adjust_rli) (record_layout_info) = 0; 536 537void 538set_lang_adjust_rli (void (*f) (record_layout_info)) 539{ 540 lang_adjust_rli = f; 541} 542 543/* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or 544 QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which 545 is to be passed to all other layout functions for this record. It is the 546 responsibility of the caller to call `free' for the storage returned. 547 Note that garbage collection is not permitted until we finish laying 548 out the record. */ 549 550record_layout_info 551start_record_layout (tree t) 552{ 553 record_layout_info rli = xmalloc (sizeof (struct record_layout_info_s)); 554 555 rli->t = t; 556 557 /* If the type has a minimum specified alignment (via an attribute 558 declaration, for example) use it -- otherwise, start with a 559 one-byte alignment. */ 560 rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t)); 561 rli->unpacked_align = rli->record_align; 562 rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT); 563 564#ifdef STRUCTURE_SIZE_BOUNDARY 565 /* Packed structures don't need to have minimum size. */ 566 if (! TYPE_PACKED (t)) 567 rli->record_align = MAX (rli->record_align, (unsigned) STRUCTURE_SIZE_BOUNDARY); 568#endif 569 570 rli->offset = size_zero_node; 571 rli->bitpos = bitsize_zero_node; 572 rli->prev_field = 0; 573 rli->pending_statics = 0; 574 rli->packed_maybe_necessary = 0; 575 576 return rli; 577} 578 579/* These four routines perform computations that convert between 580 the offset/bitpos forms and byte and bit offsets. */ 581 582tree 583bit_from_pos (tree offset, tree bitpos) 584{ 585 return size_binop (PLUS_EXPR, bitpos, 586 size_binop (MULT_EXPR, convert (bitsizetype, offset), 587 bitsize_unit_node)); 588} 589 590tree 591byte_from_pos (tree offset, tree bitpos) 592{ 593 return size_binop (PLUS_EXPR, offset, 594 convert (sizetype, 595 size_binop (TRUNC_DIV_EXPR, bitpos, 596 bitsize_unit_node))); 597} 598 599void 600pos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align, 601 tree pos) 602{ 603 *poffset = size_binop (MULT_EXPR, 604 convert (sizetype, 605 size_binop (FLOOR_DIV_EXPR, pos, 606 bitsize_int (off_align))), 607 size_int (off_align / BITS_PER_UNIT)); 608 *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, bitsize_int (off_align)); 609} 610 611/* Given a pointer to bit and byte offsets and an offset alignment, 612 normalize the offsets so they are within the alignment. */ 613 614void 615normalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align) 616{ 617 /* If the bit position is now larger than it should be, adjust it 618 downwards. */ 619 if (compare_tree_int (*pbitpos, off_align) >= 0) 620 { 621 tree extra_aligns = size_binop (FLOOR_DIV_EXPR, *pbitpos, 622 bitsize_int (off_align)); 623 624 *poffset 625 = size_binop (PLUS_EXPR, *poffset, 626 size_binop (MULT_EXPR, convert (sizetype, extra_aligns), 627 size_int (off_align / BITS_PER_UNIT))); 628 629 *pbitpos 630 = size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align)); 631 } 632} 633 634/* Print debugging information about the information in RLI. */ 635 636void 637debug_rli (record_layout_info rli) 638{ 639 print_node_brief (stderr, "type", rli->t, 0); 640 print_node_brief (stderr, "\noffset", rli->offset, 0); 641 print_node_brief (stderr, " bitpos", rli->bitpos, 0); 642 643 fprintf (stderr, "\naligns: rec = %u, unpack = %u, off = %u\n", 644 rli->record_align, rli->unpacked_align, 645 rli->offset_align); 646 if (rli->packed_maybe_necessary) 647 fprintf (stderr, "packed may be necessary\n"); 648 649 if (rli->pending_statics) 650 { 651 fprintf (stderr, "pending statics:\n"); 652 debug_tree (rli->pending_statics); 653 } 654} 655 656/* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and 657 BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */ 658 659void 660normalize_rli (record_layout_info rli) 661{ 662 normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align); 663} 664 665/* Returns the size in bytes allocated so far. */ 666 667tree 668rli_size_unit_so_far (record_layout_info rli) 669{ 670 return byte_from_pos (rli->offset, rli->bitpos); 671} 672 673/* Returns the size in bits allocated so far. */ 674 675tree 676rli_size_so_far (record_layout_info rli) 677{ 678 return bit_from_pos (rli->offset, rli->bitpos); 679} 680 681/* FIELD is about to be added to RLI->T. The alignment (in bits) of 682 the next available location is given by KNOWN_ALIGN. Update the 683 variable alignment fields in RLI, and return the alignment to give 684 the FIELD. */ 685 686static unsigned int 687update_alignment_for_field (record_layout_info rli, tree field, 688 unsigned int known_align) 689{ 690 /* The alignment required for FIELD. */ 691 unsigned int desired_align; 692 /* The type of this field. */ 693 tree type = TREE_TYPE (field); 694 /* True if the field was explicitly aligned by the user. */ 695 bool user_align; 696 bool is_bitfield; 697 698 /* Lay out the field so we know what alignment it needs. */ 699 layout_decl (field, known_align); 700 desired_align = DECL_ALIGN (field); 701 user_align = DECL_USER_ALIGN (field); 702 703 is_bitfield = (type != error_mark_node 704 && DECL_BIT_FIELD_TYPE (field) 705 && ! integer_zerop (TYPE_SIZE (type))); 706 707 /* Record must have at least as much alignment as any field. 708 Otherwise, the alignment of the field within the record is 709 meaningless. */ 710 if (is_bitfield && (* targetm.ms_bitfield_layout_p) (rli->t)) 711 { 712 /* Here, the alignment of the underlying type of a bitfield can 713 affect the alignment of a record; even a zero-sized field 714 can do this. The alignment should be to the alignment of 715 the type, except that for zero-size bitfields this only 716 applies if there was an immediately prior, nonzero-size 717 bitfield. (That's the way it is, experimentally.) */ 718 if (! integer_zerop (DECL_SIZE (field)) 719 ? ! DECL_PACKED (field) 720 : (rli->prev_field 721 && DECL_BIT_FIELD_TYPE (rli->prev_field) 722 && ! integer_zerop (DECL_SIZE (rli->prev_field)))) 723 { 724 unsigned int type_align = TYPE_ALIGN (type); 725 type_align = MAX (type_align, desired_align); 726 if (maximum_field_alignment != 0) 727 type_align = MIN (type_align, maximum_field_alignment); 728 rli->record_align = MAX (rli->record_align, type_align); 729 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); 730 } 731 } 732#ifdef PCC_BITFIELD_TYPE_MATTERS 733 else if (is_bitfield && PCC_BITFIELD_TYPE_MATTERS) 734 { 735 /* Named bit-fields cause the entire structure to have the 736 alignment implied by their type. */ 737 if (DECL_NAME (field) != 0) 738 { 739 unsigned int type_align = TYPE_ALIGN (type); 740 741#ifdef ADJUST_FIELD_ALIGN 742 if (! TYPE_USER_ALIGN (type)) 743 type_align = ADJUST_FIELD_ALIGN (field, type_align); 744#endif 745 746 if (maximum_field_alignment != 0) 747 type_align = MIN (type_align, maximum_field_alignment); 748 else if (DECL_PACKED (field)) 749 type_align = MIN (type_align, BITS_PER_UNIT); 750 751 /* The alignment of the record is increased to the maximum 752 of the current alignment, the alignment indicated on the 753 field (i.e., the alignment specified by an __aligned__ 754 attribute), and the alignment indicated by the type of 755 the field. */ 756 rli->record_align = MAX (rli->record_align, desired_align); 757 rli->record_align = MAX (rli->record_align, type_align); 758 759 if (warn_packed) 760 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); 761 user_align |= TYPE_USER_ALIGN (type); 762 } 763 } 764#endif 765 else 766 { 767 rli->record_align = MAX (rli->record_align, desired_align); 768 rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); 769 } 770 771 TYPE_USER_ALIGN (rli->t) |= user_align; 772 773 return desired_align; 774} 775 776/* Called from place_field to handle unions. */ 777 778static void 779place_union_field (record_layout_info rli, tree field) 780{ 781 update_alignment_for_field (rli, field, /*known_align=*/0); 782 783 DECL_FIELD_OFFSET (field) = size_zero_node; 784 DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node; 785 SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT); 786 787 /* We assume the union's size will be a multiple of a byte so we don't 788 bother with BITPOS. */ 789 if (TREE_CODE (rli->t) == UNION_TYPE) 790 rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field)); 791 else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE) 792 rli->offset = fold (build (COND_EXPR, sizetype, 793 DECL_QUALIFIER (field), 794 DECL_SIZE_UNIT (field), rli->offset)); 795} 796 797#if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED) 798/* A bitfield of SIZE with a required access alignment of ALIGN is allocated 799 at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more 800 units of alignment than the underlying TYPE. */ 801static int 802excess_unit_span (HOST_WIDE_INT byte_offset, HOST_WIDE_INT bit_offset, 803 HOST_WIDE_INT size, HOST_WIDE_INT align, tree type) 804{ 805 /* Note that the calculation of OFFSET might overflow; we calculate it so 806 that we still get the right result as long as ALIGN is a power of two. */ 807 unsigned HOST_WIDE_INT offset = byte_offset * BITS_PER_UNIT + bit_offset; 808 809 offset = offset % align; 810 return ((offset + size + align - 1) / align 811 > ((unsigned HOST_WIDE_INT) tree_low_cst (TYPE_SIZE (type), 1) 812 / align)); 813} 814#endif 815 816/* RLI contains information about the layout of a RECORD_TYPE. FIELD 817 is a FIELD_DECL to be added after those fields already present in 818 T. (FIELD is not actually added to the TYPE_FIELDS list here; 819 callers that desire that behavior must manually perform that step.) */ 820 821void 822place_field (record_layout_info rli, tree field) 823{ 824 /* The alignment required for FIELD. */ 825 unsigned int desired_align; 826 /* The alignment FIELD would have if we just dropped it into the 827 record as it presently stands. */ 828 unsigned int known_align; 829 unsigned int actual_align; 830 /* The type of this field. */ 831 tree type = TREE_TYPE (field); 832 833 if (TREE_CODE (field) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK) 834 return; 835 836 /* If FIELD is static, then treat it like a separate variable, not 837 really like a structure field. If it is a FUNCTION_DECL, it's a 838 method. In both cases, all we do is lay out the decl, and we do 839 it *after* the record is laid out. */ 840 if (TREE_CODE (field) == VAR_DECL) 841 { 842 rli->pending_statics = tree_cons (NULL_TREE, field, 843 rli->pending_statics); 844 return; 845 } 846 847 /* Enumerators and enum types which are local to this class need not 848 be laid out. Likewise for initialized constant fields. */ 849 else if (TREE_CODE (field) != FIELD_DECL) 850 return; 851 852 /* Unions are laid out very differently than records, so split 853 that code off to another function. */ 854 else if (TREE_CODE (rli->t) != RECORD_TYPE) 855 { 856 place_union_field (rli, field); 857 return; 858 } 859 860 /* Work out the known alignment so far. Note that A & (-A) is the 861 value of the least-significant bit in A that is one. */ 862 if (! integer_zerop (rli->bitpos)) 863 known_align = (tree_low_cst (rli->bitpos, 1) 864 & - tree_low_cst (rli->bitpos, 1)); 865 else if (integer_zerop (rli->offset)) 866 known_align = BIGGEST_ALIGNMENT; 867 else if (host_integerp (rli->offset, 1)) 868 known_align = (BITS_PER_UNIT 869 * (tree_low_cst (rli->offset, 1) 870 & - tree_low_cst (rli->offset, 1))); 871 else 872 known_align = rli->offset_align; 873 874 desired_align = update_alignment_for_field (rli, field, known_align); 875 876 if (warn_packed && DECL_PACKED (field)) 877 { 878 if (known_align >= TYPE_ALIGN (type)) 879 { 880 if (TYPE_ALIGN (type) > desired_align) 881 { 882 if (STRICT_ALIGNMENT) 883 warning ("%Jpacked attribute causes inefficient alignment " 884 "for '%D'", field, field); 885 else 886 warning ("%Jpacked attribute is unnecessary for '%D'", 887 field, field); 888 } 889 } 890 else 891 rli->packed_maybe_necessary = 1; 892 } 893 894 /* Does this field automatically have alignment it needs by virtue 895 of the fields that precede it and the record's own alignment? */ 896 if (known_align < desired_align) 897 { 898 /* No, we need to skip space before this field. 899 Bump the cumulative size to multiple of field alignment. */ 900 901 if (warn_padded) 902 warning ("%Jpadding struct to align '%D'", field, field); 903 904 /* If the alignment is still within offset_align, just align 905 the bit position. */ 906 if (desired_align < rli->offset_align) 907 rli->bitpos = round_up (rli->bitpos, desired_align); 908 else 909 { 910 /* First adjust OFFSET by the partial bits, then align. */ 911 rli->offset 912 = size_binop (PLUS_EXPR, rli->offset, 913 convert (sizetype, 914 size_binop (CEIL_DIV_EXPR, rli->bitpos, 915 bitsize_unit_node))); 916 rli->bitpos = bitsize_zero_node; 917 918 rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT); 919 } 920 921 if (! TREE_CONSTANT (rli->offset)) 922 rli->offset_align = desired_align; 923 924 } 925 926 /* Handle compatibility with PCC. Note that if the record has any 927 variable-sized fields, we need not worry about compatibility. */ 928#ifdef PCC_BITFIELD_TYPE_MATTERS 929 if (PCC_BITFIELD_TYPE_MATTERS 930 && ! (* targetm.ms_bitfield_layout_p) (rli->t) 931 && TREE_CODE (field) == FIELD_DECL 932 && type != error_mark_node 933 && DECL_BIT_FIELD (field) 934 && ! DECL_PACKED (field) 935 && maximum_field_alignment == 0 936 && ! integer_zerop (DECL_SIZE (field)) 937 && host_integerp (DECL_SIZE (field), 1) 938 && host_integerp (rli->offset, 1) 939 && host_integerp (TYPE_SIZE (type), 1)) 940 { 941 unsigned int type_align = TYPE_ALIGN (type); 942 tree dsize = DECL_SIZE (field); 943 HOST_WIDE_INT field_size = tree_low_cst (dsize, 1); 944 HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0); 945 HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0); 946 947#ifdef ADJUST_FIELD_ALIGN 948 if (! TYPE_USER_ALIGN (type)) 949 type_align = ADJUST_FIELD_ALIGN (field, type_align); 950#endif 951 952 /* A bit field may not span more units of alignment of its type 953 than its type itself. Advance to next boundary if necessary. */ 954 if (excess_unit_span (offset, bit_offset, field_size, type_align, type)) 955 rli->bitpos = round_up (rli->bitpos, type_align); 956 957 TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type); 958 } 959#endif 960 961#ifdef BITFIELD_NBYTES_LIMITED 962 if (BITFIELD_NBYTES_LIMITED 963 && ! (* targetm.ms_bitfield_layout_p) (rli->t) 964 && TREE_CODE (field) == FIELD_DECL 965 && type != error_mark_node 966 && DECL_BIT_FIELD_TYPE (field) 967 && ! DECL_PACKED (field) 968 && ! integer_zerop (DECL_SIZE (field)) 969 && host_integerp (DECL_SIZE (field), 1) 970 && host_integerp (rli->offset, 1) 971 && host_integerp (TYPE_SIZE (type), 1)) 972 { 973 unsigned int type_align = TYPE_ALIGN (type); 974 tree dsize = DECL_SIZE (field); 975 HOST_WIDE_INT field_size = tree_low_cst (dsize, 1); 976 HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0); 977 HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0); 978 979#ifdef ADJUST_FIELD_ALIGN 980 if (! TYPE_USER_ALIGN (type)) 981 type_align = ADJUST_FIELD_ALIGN (field, type_align); 982#endif 983 984 if (maximum_field_alignment != 0) 985 type_align = MIN (type_align, maximum_field_alignment); 986 /* ??? This test is opposite the test in the containing if 987 statement, so this code is unreachable currently. */ 988 else if (DECL_PACKED (field)) 989 type_align = MIN (type_align, BITS_PER_UNIT); 990 991 /* A bit field may not span the unit of alignment of its type. 992 Advance to next boundary if necessary. */ 993 if (excess_unit_span (offset, bit_offset, field_size, type_align, type)) 994 rli->bitpos = round_up (rli->bitpos, type_align); 995 996 TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type); 997 } 998#endif 999 1000 /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details. 1001 A subtlety: 1002 When a bit field is inserted into a packed record, the whole 1003 size of the underlying type is used by one or more same-size 1004 adjacent bitfields. (That is, if its long:3, 32 bits is 1005 used in the record, and any additional adjacent long bitfields are 1006 packed into the same chunk of 32 bits. However, if the size 1007 changes, a new field of that size is allocated.) In an unpacked 1008 record, this is the same as using alignment, but not equivalent 1009 when packing. 1010 1011 Note: for compatibility, we use the type size, not the type alignment 1012 to determine alignment, since that matches the documentation */ 1013 1014 if ((* targetm.ms_bitfield_layout_p) (rli->t) 1015 && ((DECL_BIT_FIELD_TYPE (field) && ! DECL_PACKED (field)) 1016 || (rli->prev_field && ! DECL_PACKED (rli->prev_field)))) 1017 { 1018 /* At this point, either the prior or current are bitfields, 1019 (possibly both), and we're dealing with MS packing. */ 1020 tree prev_saved = rli->prev_field; 1021 1022 /* Is the prior field a bitfield? If so, handle "runs" of same 1023 type size fields. */ 1024 if (rli->prev_field /* necessarily a bitfield if it exists. */) 1025 { 1026 /* If both are bitfields, nonzero, and the same size, this is 1027 the middle of a run. Zero declared size fields are special 1028 and handled as "end of run". (Note: it's nonzero declared 1029 size, but equal type sizes!) (Since we know that both 1030 the current and previous fields are bitfields by the 1031 time we check it, DECL_SIZE must be present for both.) */ 1032 if (DECL_BIT_FIELD_TYPE (field) 1033 && !integer_zerop (DECL_SIZE (field)) 1034 && !integer_zerop (DECL_SIZE (rli->prev_field)) 1035 && host_integerp (DECL_SIZE (rli->prev_field), 0) 1036 && host_integerp (TYPE_SIZE (type), 0) 1037 && simple_cst_equal (TYPE_SIZE (type), 1038 TYPE_SIZE (TREE_TYPE (rli->prev_field)))) 1039 { 1040 /* We're in the middle of a run of equal type size fields; make 1041 sure we realign if we run out of bits. (Not decl size, 1042 type size!) */ 1043 HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 0); 1044 1045 if (rli->remaining_in_alignment < bitsize) 1046 { 1047 /* out of bits; bump up to next 'word'. */ 1048 rli->offset = DECL_FIELD_OFFSET (rli->prev_field); 1049 rli->bitpos 1050 = size_binop (PLUS_EXPR, TYPE_SIZE (type), 1051 DECL_FIELD_BIT_OFFSET (rli->prev_field)); 1052 rli->prev_field = field; 1053 rli->remaining_in_alignment 1054 = tree_low_cst (TYPE_SIZE (type), 0); 1055 } 1056 1057 rli->remaining_in_alignment -= bitsize; 1058 } 1059 else 1060 { 1061 /* End of a run: if leaving a run of bitfields of the same type 1062 size, we have to "use up" the rest of the bits of the type 1063 size. 1064 1065 Compute the new position as the sum of the size for the prior 1066 type and where we first started working on that type. 1067 Note: since the beginning of the field was aligned then 1068 of course the end will be too. No round needed. */ 1069 1070 if (!integer_zerop (DECL_SIZE (rli->prev_field))) 1071 { 1072 tree type_size = TYPE_SIZE (TREE_TYPE (rli->prev_field)); 1073 1074 rli->bitpos 1075 = size_binop (PLUS_EXPR, type_size, 1076 DECL_FIELD_BIT_OFFSET (rli->prev_field)); 1077 } 1078 else 1079 /* We "use up" size zero fields; the code below should behave 1080 as if the prior field was not a bitfield. */ 1081 prev_saved = NULL; 1082 1083 /* Cause a new bitfield to be captured, either this time (if 1084 currently a bitfield) or next time we see one. */ 1085 if (!DECL_BIT_FIELD_TYPE(field) 1086 || integer_zerop (DECL_SIZE (field))) 1087 rli->prev_field = NULL; 1088 } 1089 1090 normalize_rli (rli); 1091 } 1092 1093 /* If we're starting a new run of same size type bitfields 1094 (or a run of non-bitfields), set up the "first of the run" 1095 fields. 1096 1097 That is, if the current field is not a bitfield, or if there 1098 was a prior bitfield the type sizes differ, or if there wasn't 1099 a prior bitfield the size of the current field is nonzero. 1100 1101 Note: we must be sure to test ONLY the type size if there was 1102 a prior bitfield and ONLY for the current field being zero if 1103 there wasn't. */ 1104 1105 if (!DECL_BIT_FIELD_TYPE (field) 1106 || ( prev_saved != NULL 1107 ? !simple_cst_equal (TYPE_SIZE (type), 1108 TYPE_SIZE (TREE_TYPE (prev_saved))) 1109 : !integer_zerop (DECL_SIZE (field)) )) 1110 { 1111 /* Never smaller than a byte for compatibility. */ 1112 unsigned int type_align = BITS_PER_UNIT; 1113 1114 /* (When not a bitfield), we could be seeing a flex array (with 1115 no DECL_SIZE). Since we won't be using remaining_in_alignment 1116 until we see a bitfield (and come by here again) we just skip 1117 calculating it. */ 1118 if (DECL_SIZE (field) != NULL 1119 && host_integerp (TYPE_SIZE (TREE_TYPE (field)), 0) 1120 && host_integerp (DECL_SIZE (field), 0)) 1121 rli->remaining_in_alignment 1122 = tree_low_cst (TYPE_SIZE (TREE_TYPE(field)), 0) 1123 - tree_low_cst (DECL_SIZE (field), 0); 1124 1125 /* Now align (conventionally) for the new type. */ 1126 if (!DECL_PACKED(field)) 1127 type_align = MAX(TYPE_ALIGN (type), type_align); 1128 1129 if (prev_saved 1130 && DECL_BIT_FIELD_TYPE (prev_saved) 1131 /* If the previous bit-field is zero-sized, we've already 1132 accounted for its alignment needs (or ignored it, if 1133 appropriate) while placing it. */ 1134 && ! integer_zerop (DECL_SIZE (prev_saved))) 1135 type_align = MAX (type_align, 1136 TYPE_ALIGN (TREE_TYPE (prev_saved))); 1137 1138 if (maximum_field_alignment != 0) 1139 type_align = MIN (type_align, maximum_field_alignment); 1140 1141 rli->bitpos = round_up (rli->bitpos, type_align); 1142 1143 /* If we really aligned, don't allow subsequent bitfields 1144 to undo that. */ 1145 rli->prev_field = NULL; 1146 } 1147 } 1148 1149 /* Offset so far becomes the position of this field after normalizing. */ 1150 normalize_rli (rli); 1151 DECL_FIELD_OFFSET (field) = rli->offset; 1152 DECL_FIELD_BIT_OFFSET (field) = rli->bitpos; 1153 SET_DECL_OFFSET_ALIGN (field, rli->offset_align); 1154 1155 /* If this field ended up more aligned than we thought it would be (we 1156 approximate this by seeing if its position changed), lay out the field 1157 again; perhaps we can use an integral mode for it now. */ 1158 if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field))) 1159 actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1) 1160 & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)); 1161 else if (integer_zerop (DECL_FIELD_OFFSET (field))) 1162 actual_align = BIGGEST_ALIGNMENT; 1163 else if (host_integerp (DECL_FIELD_OFFSET (field), 1)) 1164 actual_align = (BITS_PER_UNIT 1165 * (tree_low_cst (DECL_FIELD_OFFSET (field), 1) 1166 & - tree_low_cst (DECL_FIELD_OFFSET (field), 1))); 1167 else 1168 actual_align = DECL_OFFSET_ALIGN (field); 1169 1170 if (known_align != actual_align) 1171 layout_decl (field, actual_align); 1172 1173 /* Only the MS bitfields use this. */ 1174 if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE(field)) 1175 rli->prev_field = field; 1176 1177 /* Now add size of this field to the size of the record. If the size is 1178 not constant, treat the field as being a multiple of bytes and just 1179 adjust the offset, resetting the bit position. Otherwise, apportion the 1180 size amongst the bit position and offset. First handle the case of an 1181 unspecified size, which can happen when we have an invalid nested struct 1182 definition, such as struct j { struct j { int i; } }. The error message 1183 is printed in finish_struct. */ 1184 if (DECL_SIZE (field) == 0) 1185 /* Do nothing. */; 1186 else if (TREE_CODE (DECL_SIZE_UNIT (field)) != INTEGER_CST 1187 || TREE_CONSTANT_OVERFLOW (DECL_SIZE_UNIT (field))) 1188 { 1189 rli->offset 1190 = size_binop (PLUS_EXPR, rli->offset, 1191 convert (sizetype, 1192 size_binop (CEIL_DIV_EXPR, rli->bitpos, 1193 bitsize_unit_node))); 1194 rli->offset 1195 = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field)); 1196 rli->bitpos = bitsize_zero_node; 1197 rli->offset_align = MIN (rli->offset_align, desired_align); 1198 } 1199 else 1200 { 1201 rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field)); 1202 normalize_rli (rli); 1203 } 1204} 1205 1206/* Assuming that all the fields have been laid out, this function uses 1207 RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type 1208 indicated by RLI. */ 1209 1210static void 1211finalize_record_size (record_layout_info rli) 1212{ 1213 tree unpadded_size, unpadded_size_unit; 1214 1215 /* Now we want just byte and bit offsets, so set the offset alignment 1216 to be a byte and then normalize. */ 1217 rli->offset_align = BITS_PER_UNIT; 1218 normalize_rli (rli); 1219 1220 /* Determine the desired alignment. */ 1221#ifdef ROUND_TYPE_ALIGN 1222 TYPE_ALIGN (rli->t) = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), 1223 rli->record_align); 1224#else 1225 TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align); 1226#endif 1227 1228 /* Compute the size so far. Be sure to allow for extra bits in the 1229 size in bytes. We have guaranteed above that it will be no more 1230 than a single byte. */ 1231 unpadded_size = rli_size_so_far (rli); 1232 unpadded_size_unit = rli_size_unit_so_far (rli); 1233 if (! integer_zerop (rli->bitpos)) 1234 unpadded_size_unit 1235 = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node); 1236 1237 /* Round the size up to be a multiple of the required alignment. */ 1238 TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t)); 1239 TYPE_SIZE_UNIT (rli->t) = round_up (unpadded_size_unit, 1240 TYPE_ALIGN (rli->t) / BITS_PER_UNIT); 1241 1242 if (warn_padded && TREE_CONSTANT (unpadded_size) 1243 && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0) 1244 warning ("padding struct size to alignment boundary"); 1245 1246 if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE 1247 && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary 1248 && TREE_CONSTANT (unpadded_size)) 1249 { 1250 tree unpacked_size; 1251 1252#ifdef ROUND_TYPE_ALIGN 1253 rli->unpacked_align 1254 = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align); 1255#else 1256 rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align); 1257#endif 1258 1259 unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align); 1260 if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t))) 1261 { 1262 TYPE_PACKED (rli->t) = 0; 1263 1264 if (TYPE_NAME (rli->t)) 1265 { 1266 const char *name; 1267 1268 if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE) 1269 name = IDENTIFIER_POINTER (TYPE_NAME (rli->t)); 1270 else 1271 name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t))); 1272 1273 if (STRICT_ALIGNMENT) 1274 warning ("packed attribute causes inefficient alignment for `%s'", name); 1275 else 1276 warning ("packed attribute is unnecessary for `%s'", name); 1277 } 1278 else 1279 { 1280 if (STRICT_ALIGNMENT) 1281 warning ("packed attribute causes inefficient alignment"); 1282 else 1283 warning ("packed attribute is unnecessary"); 1284 } 1285 } 1286 } 1287} 1288 1289/* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */ 1290 1291void 1292compute_record_mode (tree type) 1293{ 1294 tree field; 1295 enum machine_mode mode = VOIDmode; 1296 1297 /* Most RECORD_TYPEs have BLKmode, so we start off assuming that. 1298 However, if possible, we use a mode that fits in a register 1299 instead, in order to allow for better optimization down the 1300 line. */ 1301 TYPE_MODE (type) = BLKmode; 1302 1303 if (! host_integerp (TYPE_SIZE (type), 1)) 1304 return; 1305 1306 /* A record which has any BLKmode members must itself be 1307 BLKmode; it can't go in a register. Unless the member is 1308 BLKmode only because it isn't aligned. */ 1309 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 1310 { 1311 if (TREE_CODE (field) != FIELD_DECL) 1312 continue; 1313 1314 if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK 1315 || (TYPE_MODE (TREE_TYPE (field)) == BLKmode 1316 && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)) 1317 && !(TYPE_SIZE (TREE_TYPE (field)) != 0 1318 && integer_zerop (TYPE_SIZE (TREE_TYPE (field))))) 1319 || ! host_integerp (bit_position (field), 1) 1320 || DECL_SIZE (field) == 0 1321 || ! host_integerp (DECL_SIZE (field), 1)) 1322 return; 1323 1324 /* If this field is the whole struct, remember its mode so 1325 that, say, we can put a double in a class into a DF 1326 register instead of forcing it to live in the stack. */ 1327 if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field))) 1328 mode = DECL_MODE (field); 1329 1330#ifdef MEMBER_TYPE_FORCES_BLK 1331 /* With some targets, eg. c4x, it is sub-optimal 1332 to access an aligned BLKmode structure as a scalar. */ 1333 1334 if (MEMBER_TYPE_FORCES_BLK (field, mode)) 1335 return; 1336#endif /* MEMBER_TYPE_FORCES_BLK */ 1337 } 1338 1339 /* If we only have one real field; use its mode. This only applies to 1340 RECORD_TYPE. This does not apply to unions. */ 1341 if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode) 1342 TYPE_MODE (type) = mode; 1343 else 1344 TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); 1345 1346 /* If structure's known alignment is less than what the scalar 1347 mode would need, and it matters, then stick with BLKmode. */ 1348 if (TYPE_MODE (type) != BLKmode 1349 && STRICT_ALIGNMENT 1350 && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT 1351 || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type)))) 1352 { 1353 /* If this is the only reason this type is BLKmode, then 1354 don't force containing types to be BLKmode. */ 1355 TYPE_NO_FORCE_BLK (type) = 1; 1356 TYPE_MODE (type) = BLKmode; 1357 } 1358} 1359 1360/* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid 1361 out. */ 1362 1363static void 1364finalize_type_size (tree type) 1365{ 1366 /* Normally, use the alignment corresponding to the mode chosen. 1367 However, where strict alignment is not required, avoid 1368 over-aligning structures, since most compilers do not do this 1369 alignment. */ 1370 1371 if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode 1372 && (STRICT_ALIGNMENT 1373 || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE 1374 && TREE_CODE (type) != QUAL_UNION_TYPE 1375 && TREE_CODE (type) != ARRAY_TYPE))) 1376 { 1377 TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type)); 1378 TYPE_USER_ALIGN (type) = 0; 1379 } 1380 1381 /* Do machine-dependent extra alignment. */ 1382#ifdef ROUND_TYPE_ALIGN 1383 TYPE_ALIGN (type) 1384 = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT); 1385#endif 1386 1387 /* If we failed to find a simple way to calculate the unit size 1388 of the type, find it by division. */ 1389 if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0) 1390 /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the 1391 result will fit in sizetype. We will get more efficient code using 1392 sizetype, so we force a conversion. */ 1393 TYPE_SIZE_UNIT (type) 1394 = convert (sizetype, 1395 size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type), 1396 bitsize_unit_node)); 1397 1398 if (TYPE_SIZE (type) != 0) 1399 { 1400 TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type)); 1401 TYPE_SIZE_UNIT (type) 1402 = round_up (TYPE_SIZE_UNIT (type), TYPE_ALIGN (type) / BITS_PER_UNIT); 1403 } 1404 1405 /* Evaluate nonconstant sizes only once, either now or as soon as safe. */ 1406 if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 1407 TYPE_SIZE (type) = variable_size (TYPE_SIZE (type)); 1408 if (TYPE_SIZE_UNIT (type) != 0 1409 && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST) 1410 TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type)); 1411 1412 /* Also layout any other variants of the type. */ 1413 if (TYPE_NEXT_VARIANT (type) 1414 || type != TYPE_MAIN_VARIANT (type)) 1415 { 1416 tree variant; 1417 /* Record layout info of this variant. */ 1418 tree size = TYPE_SIZE (type); 1419 tree size_unit = TYPE_SIZE_UNIT (type); 1420 unsigned int align = TYPE_ALIGN (type); 1421 unsigned int user_align = TYPE_USER_ALIGN (type); 1422 enum machine_mode mode = TYPE_MODE (type); 1423 1424 /* Copy it into all variants. */ 1425 for (variant = TYPE_MAIN_VARIANT (type); 1426 variant != 0; 1427 variant = TYPE_NEXT_VARIANT (variant)) 1428 { 1429 TYPE_SIZE (variant) = size; 1430 TYPE_SIZE_UNIT (variant) = size_unit; 1431 TYPE_ALIGN (variant) = align; 1432 TYPE_USER_ALIGN (variant) = user_align; 1433 TYPE_MODE (variant) = mode; 1434 } 1435 } 1436} 1437 1438/* Do all of the work required to layout the type indicated by RLI, 1439 once the fields have been laid out. This function will call `free' 1440 for RLI, unless FREE_P is false. Passing a value other than false 1441 for FREE_P is bad practice; this option only exists to support the 1442 G++ 3.2 ABI. */ 1443 1444void 1445finish_record_layout (record_layout_info rli, int free_p) 1446{ 1447 /* Compute the final size. */ 1448 finalize_record_size (rli); 1449 1450 /* Compute the TYPE_MODE for the record. */ 1451 compute_record_mode (rli->t); 1452 1453 /* Perform any last tweaks to the TYPE_SIZE, etc. */ 1454 finalize_type_size (rli->t); 1455 1456 /* Lay out any static members. This is done now because their type 1457 may use the record's type. */ 1458 while (rli->pending_statics) 1459 { 1460 layout_decl (TREE_VALUE (rli->pending_statics), 0); 1461 rli->pending_statics = TREE_CHAIN (rli->pending_statics); 1462 } 1463 1464 /* Clean up. */ 1465 if (free_p) 1466 free (rli); 1467} 1468 1469 1470/* Finish processing a builtin RECORD_TYPE type TYPE. It's name is 1471 NAME, its fields are chained in reverse on FIELDS. 1472 1473 If ALIGN_TYPE is non-null, it is given the same alignment as 1474 ALIGN_TYPE. */ 1475 1476void 1477finish_builtin_struct (tree type, const char *name, tree fields, 1478 tree align_type) 1479{ 1480 tree tail, next; 1481 1482 for (tail = NULL_TREE; fields; tail = fields, fields = next) 1483 { 1484 DECL_FIELD_CONTEXT (fields) = type; 1485 next = TREE_CHAIN (fields); 1486 TREE_CHAIN (fields) = tail; 1487 } 1488 TYPE_FIELDS (type) = tail; 1489 1490 if (align_type) 1491 { 1492 TYPE_ALIGN (type) = TYPE_ALIGN (align_type); 1493 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (align_type); 1494 } 1495 1496 layout_type (type); 1497#if 0 /* not yet, should get fixed properly later */ 1498 TYPE_NAME (type) = make_type_decl (get_identifier (name), type); 1499#else 1500 TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type); 1501#endif 1502 TYPE_STUB_DECL (type) = TYPE_NAME (type); 1503 layout_decl (TYPE_NAME (type), 0); 1504} 1505 1506/* Calculate the mode, size, and alignment for TYPE. 1507 For an array type, calculate the element separation as well. 1508 Record TYPE on the chain of permanent or temporary types 1509 so that dbxout will find out about it. 1510 1511 TYPE_SIZE of a type is nonzero if the type has been laid out already. 1512 layout_type does nothing on such a type. 1513 1514 If the type is incomplete, its TYPE_SIZE remains zero. */ 1515 1516void 1517layout_type (tree type) 1518{ 1519 if (type == 0) 1520 abort (); 1521 1522 /* Do nothing if type has been laid out before. */ 1523 if (TYPE_SIZE (type)) 1524 return; 1525 1526 switch (TREE_CODE (type)) 1527 { 1528 case LANG_TYPE: 1529 /* This kind of type is the responsibility 1530 of the language-specific code. */ 1531 abort (); 1532 1533 case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */ 1534 if (TYPE_PRECISION (type) == 0) 1535 TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */ 1536 1537 /* ... fall through ... */ 1538 1539 case INTEGER_TYPE: 1540 case ENUMERAL_TYPE: 1541 case CHAR_TYPE: 1542 if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST 1543 && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0) 1544 TREE_UNSIGNED (type) = 1; 1545 1546 TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type), 1547 MODE_INT); 1548 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 1549 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 1550 break; 1551 1552 case REAL_TYPE: 1553 TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0); 1554 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 1555 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 1556 break; 1557 1558 case COMPLEX_TYPE: 1559 TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type)); 1560 TYPE_MODE (type) 1561 = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)), 1562 (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE 1563 ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT), 1564 0); 1565 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 1566 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 1567 break; 1568 1569 case VECTOR_TYPE: 1570 { 1571 tree subtype; 1572 1573 subtype = TREE_TYPE (type); 1574 TREE_UNSIGNED (type) = TREE_UNSIGNED (subtype); 1575 TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 1576 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 1577 } 1578 break; 1579 1580 case VOID_TYPE: 1581 /* This is an incomplete type and so doesn't have a size. */ 1582 TYPE_ALIGN (type) = 1; 1583 TYPE_USER_ALIGN (type) = 0; 1584 TYPE_MODE (type) = VOIDmode; 1585 break; 1586 1587 case OFFSET_TYPE: 1588 TYPE_SIZE (type) = bitsize_int (POINTER_SIZE); 1589 TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT); 1590 /* A pointer might be MODE_PARTIAL_INT, 1591 but ptrdiff_t must be integral. */ 1592 TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0); 1593 break; 1594 1595 case FUNCTION_TYPE: 1596 case METHOD_TYPE: 1597 TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0); 1598 TYPE_SIZE (type) = bitsize_int (2 * POINTER_SIZE); 1599 TYPE_SIZE_UNIT (type) = size_int ((2 * POINTER_SIZE) / BITS_PER_UNIT); 1600 break; 1601 1602 case POINTER_TYPE: 1603 case REFERENCE_TYPE: 1604 { 1605 1606 enum machine_mode mode = ((TREE_CODE (type) == REFERENCE_TYPE 1607 && reference_types_internal) 1608 ? Pmode : TYPE_MODE (type)); 1609 1610 int nbits = GET_MODE_BITSIZE (mode); 1611 1612 TYPE_SIZE (type) = bitsize_int (nbits); 1613 TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode)); 1614 TREE_UNSIGNED (type) = 1; 1615 TYPE_PRECISION (type) = nbits; 1616 } 1617 break; 1618 1619 case ARRAY_TYPE: 1620 { 1621 tree index = TYPE_DOMAIN (type); 1622 tree element = TREE_TYPE (type); 1623 1624 build_pointer_type (element); 1625 1626 /* We need to know both bounds in order to compute the size. */ 1627 if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index) 1628 && TYPE_SIZE (element)) 1629 { 1630 tree ub = TYPE_MAX_VALUE (index); 1631 tree lb = TYPE_MIN_VALUE (index); 1632 tree length; 1633 tree element_size; 1634 1635 /* The initial subtraction should happen in the original type so 1636 that (possible) negative values are handled appropriately. */ 1637 length = size_binop (PLUS_EXPR, size_one_node, 1638 convert (sizetype, 1639 fold (build (MINUS_EXPR, 1640 TREE_TYPE (lb), 1641 ub, lb)))); 1642 1643 /* Special handling for arrays of bits (for Chill). */ 1644 element_size = TYPE_SIZE (element); 1645 if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element) 1646 && (integer_zerop (TYPE_MAX_VALUE (element)) 1647 || integer_onep (TYPE_MAX_VALUE (element))) 1648 && host_integerp (TYPE_MIN_VALUE (element), 1)) 1649 { 1650 HOST_WIDE_INT maxvalue 1651 = tree_low_cst (TYPE_MAX_VALUE (element), 1); 1652 HOST_WIDE_INT minvalue 1653 = tree_low_cst (TYPE_MIN_VALUE (element), 1); 1654 1655 if (maxvalue - minvalue == 1 1656 && (maxvalue == 1 || maxvalue == 0)) 1657 element_size = integer_one_node; 1658 } 1659 1660 /* If neither bound is a constant and sizetype is signed, make 1661 sure the size is never negative. We should really do this 1662 if *either* bound is non-constant, but this is the best 1663 compromise between C and Ada. */ 1664 if (! TREE_UNSIGNED (sizetype) 1665 && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST 1666 && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST) 1667 length = size_binop (MAX_EXPR, length, size_zero_node); 1668 1669 TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size, 1670 convert (bitsizetype, length)); 1671 1672 /* If we know the size of the element, calculate the total 1673 size directly, rather than do some division thing below. 1674 This optimization helps Fortran assumed-size arrays 1675 (where the size of the array is determined at runtime) 1676 substantially. 1677 Note that we can't do this in the case where the size of 1678 the elements is one bit since TYPE_SIZE_UNIT cannot be 1679 set correctly in that case. */ 1680 if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size)) 1681 TYPE_SIZE_UNIT (type) 1682 = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length); 1683 } 1684 1685 /* Now round the alignment and size, 1686 using machine-dependent criteria if any. */ 1687 1688#ifdef ROUND_TYPE_ALIGN 1689 TYPE_ALIGN (type) 1690 = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT); 1691#else 1692 TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT); 1693#endif 1694 TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element); 1695 TYPE_MODE (type) = BLKmode; 1696 if (TYPE_SIZE (type) != 0 1697#ifdef MEMBER_TYPE_FORCES_BLK 1698 && ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode) 1699#endif 1700 /* BLKmode elements force BLKmode aggregate; 1701 else extract/store fields may lose. */ 1702 && (TYPE_MODE (TREE_TYPE (type)) != BLKmode 1703 || TYPE_NO_FORCE_BLK (TREE_TYPE (type)))) 1704 { 1705 /* One-element arrays get the component type's mode. */ 1706 if (simple_cst_equal (TYPE_SIZE (type), 1707 TYPE_SIZE (TREE_TYPE (type)))) 1708 TYPE_MODE (type) = TYPE_MODE (TREE_TYPE (type)); 1709 else 1710 TYPE_MODE (type) 1711 = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); 1712 1713 if (TYPE_MODE (type) != BLKmode 1714 && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT 1715 && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)) 1716 && TYPE_MODE (type) != BLKmode) 1717 { 1718 TYPE_NO_FORCE_BLK (type) = 1; 1719 TYPE_MODE (type) = BLKmode; 1720 } 1721 } 1722 break; 1723 } 1724 1725 case RECORD_TYPE: 1726 case UNION_TYPE: 1727 case QUAL_UNION_TYPE: 1728 { 1729 tree field; 1730 record_layout_info rli; 1731 1732 /* Initialize the layout information. */ 1733 rli = start_record_layout (type); 1734 1735 /* If this is a QUAL_UNION_TYPE, we want to process the fields 1736 in the reverse order in building the COND_EXPR that denotes 1737 its size. We reverse them again later. */ 1738 if (TREE_CODE (type) == QUAL_UNION_TYPE) 1739 TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type)); 1740 1741 /* Place all the fields. */ 1742 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 1743 place_field (rli, field); 1744 1745 if (TREE_CODE (type) == QUAL_UNION_TYPE) 1746 TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type)); 1747 1748 if (lang_adjust_rli) 1749 (*lang_adjust_rli) (rli); 1750 1751 /* Finish laying out the record. */ 1752 finish_record_layout (rli, /*free_p=*/true); 1753 } 1754 break; 1755 1756 case SET_TYPE: /* Used by Chill and Pascal. */ 1757 if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST 1758 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST) 1759 abort (); 1760 else 1761 { 1762#ifndef SET_WORD_SIZE 1763#define SET_WORD_SIZE BITS_PER_WORD 1764#endif 1765 unsigned int alignment 1766 = set_alignment ? set_alignment : SET_WORD_SIZE; 1767 HOST_WIDE_INT size_in_bits 1768 = (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0) 1769 - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1); 1770 HOST_WIDE_INT rounded_size 1771 = ((size_in_bits + alignment - 1) / alignment) * alignment; 1772 1773 if (rounded_size > (int) alignment) 1774 TYPE_MODE (type) = BLKmode; 1775 else 1776 TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1); 1777 1778 TYPE_SIZE (type) = bitsize_int (rounded_size); 1779 TYPE_SIZE_UNIT (type) = size_int (rounded_size / BITS_PER_UNIT); 1780 TYPE_ALIGN (type) = alignment; 1781 TYPE_USER_ALIGN (type) = 0; 1782 TYPE_PRECISION (type) = size_in_bits; 1783 } 1784 break; 1785 1786 case FILE_TYPE: 1787 /* The size may vary in different languages, so the language front end 1788 should fill in the size. */ 1789 TYPE_ALIGN (type) = BIGGEST_ALIGNMENT; 1790 TYPE_USER_ALIGN (type) = 0; 1791 TYPE_MODE (type) = BLKmode; 1792 break; 1793 1794 default: 1795 abort (); 1796 } 1797 1798 /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For 1799 records and unions, finish_record_layout already called this 1800 function. */ 1801 if (TREE_CODE (type) != RECORD_TYPE 1802 && TREE_CODE (type) != UNION_TYPE 1803 && TREE_CODE (type) != QUAL_UNION_TYPE) 1804 finalize_type_size (type); 1805 1806 /* If this type is created before sizetype has been permanently set, 1807 record it so set_sizetype can fix it up. */ 1808 if (! sizetype_set) 1809 early_type_list = tree_cons (NULL_TREE, type, early_type_list); 1810 1811 /* If an alias set has been set for this aggregate when it was incomplete, 1812 force it into alias set 0. 1813 This is too conservative, but we cannot call record_component_aliases 1814 here because some frontends still change the aggregates after 1815 layout_type. */ 1816 if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type)) 1817 TYPE_ALIAS_SET (type) = 0; 1818} 1819 1820/* Create and return a type for signed integers of PRECISION bits. */ 1821 1822tree 1823make_signed_type (int precision) 1824{ 1825 tree type = make_node (INTEGER_TYPE); 1826 1827 TYPE_PRECISION (type) = precision; 1828 1829 fixup_signed_type (type); 1830 return type; 1831} 1832 1833/* Create and return a type for unsigned integers of PRECISION bits. */ 1834 1835tree 1836make_unsigned_type (int precision) 1837{ 1838 tree type = make_node (INTEGER_TYPE); 1839 1840 TYPE_PRECISION (type) = precision; 1841 1842 fixup_unsigned_type (type); 1843 return type; 1844} 1845 1846/* Initialize sizetype and bitsizetype to a reasonable and temporary 1847 value to enable integer types to be created. */ 1848 1849void 1850initialize_sizetypes (void) 1851{ 1852 tree t = make_node (INTEGER_TYPE); 1853 1854 /* Set this so we do something reasonable for the build_int_2 calls 1855 below. */ 1856 integer_type_node = t; 1857 1858 TYPE_MODE (t) = SImode; 1859 TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode); 1860 TYPE_USER_ALIGN (t) = 0; 1861 TYPE_SIZE (t) = build_int_2 (GET_MODE_BITSIZE (SImode), 0); 1862 TYPE_SIZE_UNIT (t) = build_int_2 (GET_MODE_SIZE (SImode), 0); 1863 TREE_UNSIGNED (t) = 1; 1864 TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode); 1865 TYPE_MIN_VALUE (t) = build_int_2 (0, 0); 1866 TYPE_IS_SIZETYPE (t) = 1; 1867 1868 /* 1000 avoids problems with possible overflow and is certainly 1869 larger than any size value we'd want to be storing. */ 1870 TYPE_MAX_VALUE (t) = build_int_2 (1000, 0); 1871 1872 /* These two must be different nodes because of the caching done in 1873 size_int_wide. */ 1874 sizetype = t; 1875 bitsizetype = copy_node (t); 1876 integer_type_node = 0; 1877} 1878 1879/* Set sizetype to TYPE, and initialize *sizetype accordingly. 1880 Also update the type of any standard type's sizes made so far. */ 1881 1882void 1883set_sizetype (tree type) 1884{ 1885 int oprecision = TYPE_PRECISION (type); 1886 /* The *bitsizetype types use a precision that avoids overflows when 1887 calculating signed sizes / offsets in bits. However, when 1888 cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit 1889 precision. */ 1890 int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1, 1891 2 * HOST_BITS_PER_WIDE_INT); 1892 unsigned int i; 1893 tree t; 1894 1895 if (sizetype_set) 1896 abort (); 1897 1898 /* Make copies of nodes since we'll be setting TYPE_IS_SIZETYPE. */ 1899 sizetype = copy_node (type); 1900 TYPE_DOMAIN (sizetype) = type; 1901 TYPE_IS_SIZETYPE (sizetype) = 1; 1902 bitsizetype = make_node (INTEGER_TYPE); 1903 TYPE_NAME (bitsizetype) = TYPE_NAME (type); 1904 TYPE_PRECISION (bitsizetype) = precision; 1905 TYPE_IS_SIZETYPE (bitsizetype) = 1; 1906 1907 if (TREE_UNSIGNED (type)) 1908 fixup_unsigned_type (bitsizetype); 1909 else 1910 fixup_signed_type (bitsizetype); 1911 1912 layout_type (bitsizetype); 1913 1914 if (TREE_UNSIGNED (type)) 1915 { 1916 usizetype = sizetype; 1917 ubitsizetype = bitsizetype; 1918 ssizetype = copy_node (make_signed_type (oprecision)); 1919 sbitsizetype = copy_node (make_signed_type (precision)); 1920 } 1921 else 1922 { 1923 ssizetype = sizetype; 1924 sbitsizetype = bitsizetype; 1925 usizetype = copy_node (make_unsigned_type (oprecision)); 1926 ubitsizetype = copy_node (make_unsigned_type (precision)); 1927 } 1928 1929 TYPE_NAME (bitsizetype) = get_identifier ("bit_size_type"); 1930 1931 /* Show is a sizetype, is a main type, and has no pointers to it. */ 1932 for (i = 0; i < ARRAY_SIZE (sizetype_tab); i++) 1933 { 1934 TYPE_IS_SIZETYPE (sizetype_tab[i]) = 1; 1935 TYPE_MAIN_VARIANT (sizetype_tab[i]) = sizetype_tab[i]; 1936 TYPE_NEXT_VARIANT (sizetype_tab[i]) = 0; 1937 TYPE_POINTER_TO (sizetype_tab[i]) = 0; 1938 TYPE_REFERENCE_TO (sizetype_tab[i]) = 0; 1939 } 1940 1941 /* Go down each of the types we already made and set the proper type 1942 for the sizes in them. */ 1943 for (t = early_type_list; t != 0; t = TREE_CHAIN (t)) 1944 { 1945 if (TREE_CODE (TREE_VALUE (t)) != INTEGER_TYPE 1946 && TREE_CODE (TREE_VALUE (t)) != BOOLEAN_TYPE) 1947 abort (); 1948 1949 TREE_TYPE (TYPE_SIZE (TREE_VALUE (t))) = bitsizetype; 1950 TREE_TYPE (TYPE_SIZE_UNIT (TREE_VALUE (t))) = sizetype; 1951 } 1952 1953 early_type_list = 0; 1954 sizetype_set = 1; 1955} 1956 1957/* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE, 1958 BOOLEAN_TYPE, or CHAR_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE 1959 for TYPE, based on the PRECISION and whether or not the TYPE 1960 IS_UNSIGNED. PRECISION need not correspond to a width supported 1961 natively by the hardware; for example, on a machine with 8-bit, 1962 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or 1963 61. */ 1964 1965void 1966set_min_and_max_values_for_integral_type (tree type, 1967 int precision, 1968 bool is_unsigned) 1969{ 1970 tree min_value; 1971 tree max_value; 1972 1973 if (is_unsigned) 1974 { 1975 min_value = build_int_2 (0, 0); 1976 max_value 1977 = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0 1978 ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1, 1979 precision - HOST_BITS_PER_WIDE_INT > 0 1980 ? ((unsigned HOST_WIDE_INT) ~0 1981 >> (HOST_BITS_PER_WIDE_INT 1982 - (precision - HOST_BITS_PER_WIDE_INT))) 1983 : 0); 1984 } 1985 else 1986 { 1987 min_value 1988 = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 1989 ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)), 1990 (((HOST_WIDE_INT) (-1) 1991 << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 1992 ? precision - HOST_BITS_PER_WIDE_INT - 1 1993 : 0)))); 1994 max_value 1995 = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 1996 ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1), 1997 (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 1998 ? (((HOST_WIDE_INT) 1 1999 << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1 2000 : 0)); 2001 } 2002 2003 TREE_TYPE (min_value) = type; 2004 TREE_TYPE (max_value) = type; 2005 TYPE_MIN_VALUE (type) = min_value; 2006 TYPE_MAX_VALUE (type) = max_value; 2007} 2008 2009/* Set the extreme values of TYPE based on its precision in bits, 2010 then lay it out. Used when make_signed_type won't do 2011 because the tree code is not INTEGER_TYPE. 2012 E.g. for Pascal, when the -fsigned-char option is given. */ 2013 2014void 2015fixup_signed_type (tree type) 2016{ 2017 int precision = TYPE_PRECISION (type); 2018 2019 /* We can not represent properly constants greater then 2020 2 * HOST_BITS_PER_WIDE_INT, still we need the types 2021 as they are used by i386 vector extensions and friends. */ 2022 if (precision > HOST_BITS_PER_WIDE_INT * 2) 2023 precision = HOST_BITS_PER_WIDE_INT * 2; 2024 2025 set_min_and_max_values_for_integral_type (type, precision, 2026 /*is_unsigned=*/false); 2027 2028 /* Lay out the type: set its alignment, size, etc. */ 2029 layout_type (type); 2030} 2031 2032/* Set the extreme values of TYPE based on its precision in bits, 2033 then lay it out. This is used both in `make_unsigned_type' 2034 and for enumeral types. */ 2035 2036void 2037fixup_unsigned_type (tree type) 2038{ 2039 int precision = TYPE_PRECISION (type); 2040 2041 /* We can not represent properly constants greater then 2042 2 * HOST_BITS_PER_WIDE_INT, still we need the types 2043 as they are used by i386 vector extensions and friends. */ 2044 if (precision > HOST_BITS_PER_WIDE_INT * 2) 2045 precision = HOST_BITS_PER_WIDE_INT * 2; 2046 2047 set_min_and_max_values_for_integral_type (type, precision, 2048 /*is_unsigned=*/true); 2049 2050 /* Lay out the type: set its alignment, size, etc. */ 2051 layout_type (type); 2052} 2053 2054/* Find the best machine mode to use when referencing a bit field of length 2055 BITSIZE bits starting at BITPOS. 2056 2057 The underlying object is known to be aligned to a boundary of ALIGN bits. 2058 If LARGEST_MODE is not VOIDmode, it means that we should not use a mode 2059 larger than LARGEST_MODE (usually SImode). 2060 2061 If no mode meets all these conditions, we return VOIDmode. Otherwise, if 2062 VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest 2063 mode meeting these conditions. 2064 2065 Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return 2066 the largest mode (but a mode no wider than UNITS_PER_WORD) that meets 2067 all the conditions. */ 2068 2069enum machine_mode 2070get_best_mode (int bitsize, int bitpos, unsigned int align, 2071 enum machine_mode largest_mode, int volatilep) 2072{ 2073 enum machine_mode mode; 2074 unsigned int unit = 0; 2075 2076 /* Find the narrowest integer mode that contains the bit field. */ 2077 for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode; 2078 mode = GET_MODE_WIDER_MODE (mode)) 2079 { 2080 unit = GET_MODE_BITSIZE (mode); 2081 if ((bitpos % unit) + bitsize <= unit) 2082 break; 2083 } 2084 2085 if (mode == VOIDmode 2086 /* It is tempting to omit the following line 2087 if STRICT_ALIGNMENT is true. 2088 But that is incorrect, since if the bitfield uses part of 3 bytes 2089 and we use a 4-byte mode, we could get a spurious segv 2090 if the extra 4th byte is past the end of memory. 2091 (Though at least one Unix compiler ignores this problem: 2092 that on the Sequent 386 machine. */ 2093 || MIN (unit, BIGGEST_ALIGNMENT) > align 2094 || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode))) 2095 return VOIDmode; 2096 2097 if (SLOW_BYTE_ACCESS && ! volatilep) 2098 { 2099 enum machine_mode wide_mode = VOIDmode, tmode; 2100 2101 for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode; 2102 tmode = GET_MODE_WIDER_MODE (tmode)) 2103 { 2104 unit = GET_MODE_BITSIZE (tmode); 2105 if (bitpos / unit == (bitpos + bitsize - 1) / unit 2106 && unit <= BITS_PER_WORD 2107 && unit <= MIN (align, BIGGEST_ALIGNMENT) 2108 && (largest_mode == VOIDmode 2109 || unit <= GET_MODE_BITSIZE (largest_mode))) 2110 wide_mode = tmode; 2111 } 2112 2113 if (wide_mode != VOIDmode) 2114 return wide_mode; 2115 } 2116 2117 return mode; 2118} 2119 2120#include "gt-stor-layout.h" 2121