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