118334Speter/* C-compiler utilities for types and variables storage layout 290075Sobrien Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998, 3169689Skan 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4169689Skan Free Software Foundation, Inc. 518334Speter 690075SobrienThis file is part of GCC. 718334Speter 890075SobrienGCC is free software; you can redistribute it and/or modify it under 990075Sobrienthe terms of the GNU General Public License as published by the Free 1090075SobrienSoftware Foundation; either version 2, or (at your option) any later 1190075Sobrienversion. 1218334Speter 1390075SobrienGCC is distributed in the hope that it will be useful, but WITHOUT ANY 1490075SobrienWARRANTY; without even the implied warranty of MERCHANTABILITY or 1590075SobrienFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1690075Sobrienfor more details. 1718334Speter 1818334SpeterYou should have received a copy of the GNU General Public License 1990075Sobrienalong with GCC; see the file COPYING. If not, write to the Free 20169689SkanSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 21169689Skan02110-1301, USA. */ 2218334Speter 2318334Speter 2418334Speter#include "config.h" 2550397Sobrien#include "system.h" 26132718Skan#include "coretypes.h" 27132718Skan#include "tm.h" 2818334Speter#include "tree.h" 2950397Sobrien#include "rtl.h" 3090075Sobrien#include "tm_p.h" 3118334Speter#include "flags.h" 3218334Speter#include "function.h" 3350397Sobrien#include "expr.h" 34169689Skan#include "output.h" 3550397Sobrien#include "toplev.h" 3690075Sobrien#include "ggc.h" 3796263Sobrien#include "target.h" 38117395Skan#include "langhooks.h" 39169689Skan#include "regs.h" 40169689Skan#include "params.h" 4118334Speter 4218334Speter/* Data type for the expressions representing sizes of data types. 4350397Sobrien It is the first integer type laid out. */ 4490075Sobrientree sizetype_tab[(int) TYPE_KIND_LAST]; 4518334Speter 4618334Speter/* If nonzero, this is an upper limit on alignment of structure fields. 4718334Speter The value is measured in bits. */ 48169689Skanunsigned int maximum_field_alignment = TARGET_DEFAULT_PACK_STRUCT * BITS_PER_UNIT; 49169689Skan/* ... and its original value in bytes, specified via -fpack-struct=<value>. */ 50169689Skanunsigned int initial_max_fld_align = TARGET_DEFAULT_PACK_STRUCT; 5118334Speter 5290075Sobrien/* Nonzero if all REFERENCE_TYPEs are internal and hence should be 5390075Sobrien allocated in Pmode, not ptr_mode. Set only by internal_reference_types 5490075Sobrien called only by a front end. */ 5590075Sobrienstatic int reference_types_internal = 0; 5690075Sobrien 57132718Skanstatic void finalize_record_size (record_layout_info); 58132718Skanstatic void finalize_type_size (tree); 59132718Skanstatic void place_union_field (record_layout_info, tree); 60132718Skan#if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED) 61132718Skanstatic int excess_unit_span (HOST_WIDE_INT, HOST_WIDE_INT, HOST_WIDE_INT, 62132718Skan HOST_WIDE_INT, tree); 63132718Skan#endif 64132718Skanextern void debug_rli (record_layout_info); 6518334Speter 6618334Speter/* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */ 6718334Speter 68117395Skanstatic GTY(()) tree pending_sizes; 6918334Speter 7090075Sobrien/* Show that REFERENCE_TYPES are internal and should be Pmode. Called only 7190075Sobrien by front end. */ 7290075Sobrien 7390075Sobrienvoid 74132718Skaninternal_reference_types (void) 7590075Sobrien{ 7690075Sobrien reference_types_internal = 1; 7790075Sobrien} 7890075Sobrien 7990075Sobrien/* Get a list of all the objects put on the pending sizes list. */ 8090075Sobrien 8118334Spetertree 82132718Skanget_pending_sizes (void) 8318334Speter{ 8418334Speter tree chain = pending_sizes; 8518334Speter 8618334Speter pending_sizes = 0; 8718334Speter return chain; 8818334Speter} 8918334Speter 9090075Sobrien/* Add EXPR to the pending sizes list. */ 9190075Sobrien 9218334Spetervoid 93132718Skanput_pending_size (tree expr) 9490075Sobrien{ 9590075Sobrien /* Strip any simple arithmetic from EXPR to see if it has an underlying 9690075Sobrien SAVE_EXPR. */ 97132718Skan expr = skip_simple_arithmetic (expr); 9890075Sobrien 9990075Sobrien if (TREE_CODE (expr) == SAVE_EXPR) 10090075Sobrien pending_sizes = tree_cons (NULL_TREE, expr, pending_sizes); 10190075Sobrien} 10290075Sobrien 10390075Sobrien/* Put a chain of objects into the pending sizes list, which must be 10490075Sobrien empty. */ 10590075Sobrien 10690075Sobrienvoid 107132718Skanput_pending_sizes (tree chain) 10818334Speter{ 109169689Skan gcc_assert (!pending_sizes); 11018334Speter pending_sizes = chain; 11118334Speter} 11218334Speter 11318334Speter/* Given a size SIZE that may not be a constant, return a SAVE_EXPR 11418334Speter to serve as the actual size-expression for a type or decl. */ 11518334Speter 11618334Spetertree 117132718Skanvariable_size (tree size) 11818334Speter{ 119132718Skan tree save; 120132718Skan 12118334Speter /* If the language-processor is to take responsibility for variable-sized 12218334Speter items (e.g., languages which have elaboration procedures like Ada), 12390075Sobrien just return SIZE unchanged. Likewise for self-referential sizes and 12490075Sobrien constant sizes. */ 12518334Speter if (TREE_CONSTANT (size) 126169689Skan || lang_hooks.decls.global_bindings_p () < 0 127132718Skan || CONTAINS_PLACEHOLDER_P (size)) 12818334Speter return size; 12918334Speter 130169689Skan size = save_expr (size); 13118334Speter 13290075Sobrien /* If an array with a variable number of elements is declared, and 13390075Sobrien the elements require destruction, we will emit a cleanup for the 13490075Sobrien array. That cleanup is run both on normal exit from the block 13590075Sobrien and in the exception-handler for the block. Normally, when code 13690075Sobrien is used in both ordinary code and in an exception handler it is 13790075Sobrien `unsaved', i.e., all SAVE_EXPRs are recalculated. However, we do 13890075Sobrien not wish to do that here; the array-size is the same in both 13990075Sobrien places. */ 140169689Skan save = skip_simple_arithmetic (size); 14190075Sobrien 142169689Skan if (cfun && cfun->x_dont_save_pending_sizes_p) 143169689Skan /* The front-end doesn't want us to keep a list of the expressions 144169689Skan that determine sizes for variable size objects. Trust it. */ 145169689Skan return size; 146169689Skan 147169689Skan if (lang_hooks.decls.global_bindings_p ()) 14818334Speter { 14918334Speter if (TREE_CONSTANT (size)) 150169689Skan error ("type size can%'t be explicitly evaluated"); 15118334Speter else 15218334Speter error ("variable-size type declared outside of any function"); 15318334Speter 15490075Sobrien return size_one_node; 15518334Speter } 15618334Speter 157169689Skan put_pending_size (save); 15818334Speter 15918334Speter return size; 16018334Speter} 16118334Speter 16218334Speter#ifndef MAX_FIXED_MODE_SIZE 16318334Speter#define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode) 16418334Speter#endif 16518334Speter 166132718Skan/* Return the machine mode to use for a nonscalar of SIZE bits. The 167132718Skan mode must be in class CLASS, and have exactly that many value bits; 168132718Skan it may have padding as well. If LIMIT is nonzero, modes of wider 169132718Skan than MAX_FIXED_MODE_SIZE will not be used. */ 17018334Speter 17118334Speterenum machine_mode 172132718Skanmode_for_size (unsigned int size, enum mode_class class, int limit) 17318334Speter{ 17490075Sobrien enum machine_mode mode; 17518334Speter 17690075Sobrien if (limit && size > MAX_FIXED_MODE_SIZE) 17718334Speter return BLKmode; 17818334Speter 17918334Speter /* Get the first mode which has this size, in the specified class. */ 18018334Speter for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; 18118334Speter mode = GET_MODE_WIDER_MODE (mode)) 182132718Skan if (GET_MODE_PRECISION (mode) == size) 18318334Speter return mode; 18418334Speter 18518334Speter return BLKmode; 18618334Speter} 18718334Speter 18890075Sobrien/* Similar, except passed a tree node. */ 18990075Sobrien 19090075Sobrienenum machine_mode 191132718Skanmode_for_size_tree (tree size, enum mode_class class, int limit) 19290075Sobrien{ 193169689Skan unsigned HOST_WIDE_INT uhwi; 194169689Skan unsigned int ui; 195169689Skan 196169689Skan if (!host_integerp (size, 1)) 19790075Sobrien return BLKmode; 198169689Skan uhwi = tree_low_cst (size, 1); 199169689Skan ui = uhwi; 200169689Skan if (uhwi != ui) 201169689Skan return BLKmode; 202169689Skan return mode_for_size (ui, class, limit); 20390075Sobrien} 20490075Sobrien 20518334Speter/* Similar, but never return BLKmode; return the narrowest mode that 206132718Skan contains at least the requested number of value bits. */ 20718334Speter 20852284Sobrienenum machine_mode 209132718Skansmallest_mode_for_size (unsigned int size, enum mode_class class) 21018334Speter{ 21190075Sobrien enum machine_mode mode; 21218334Speter 21318334Speter /* Get the first mode which has at least this size, in the 21418334Speter specified class. */ 21518334Speter for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; 21618334Speter mode = GET_MODE_WIDER_MODE (mode)) 217132718Skan if (GET_MODE_PRECISION (mode) >= size) 21818334Speter return mode; 21918334Speter 220169689Skan gcc_unreachable (); 22118334Speter} 22218334Speter 22352284Sobrien/* Find an integer mode of the exact same size, or BLKmode on failure. */ 22452284Sobrien 22552284Sobrienenum machine_mode 226132718Skanint_mode_for_mode (enum machine_mode mode) 22752284Sobrien{ 22852284Sobrien switch (GET_MODE_CLASS (mode)) 22952284Sobrien { 23052284Sobrien case MODE_INT: 23152284Sobrien case MODE_PARTIAL_INT: 23252284Sobrien break; 23352284Sobrien 23452284Sobrien case MODE_COMPLEX_INT: 23552284Sobrien case MODE_COMPLEX_FLOAT: 23652284Sobrien case MODE_FLOAT: 237169689Skan case MODE_DECIMAL_FLOAT: 23890075Sobrien case MODE_VECTOR_INT: 23990075Sobrien case MODE_VECTOR_FLOAT: 24052284Sobrien mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0); 24152284Sobrien break; 24252284Sobrien 24352284Sobrien case MODE_RANDOM: 24452284Sobrien if (mode == BLKmode) 245117395Skan break; 24652284Sobrien 24790075Sobrien /* ... fall through ... */ 24890075Sobrien 24952284Sobrien case MODE_CC: 25052284Sobrien default: 251169689Skan gcc_unreachable (); 25252284Sobrien } 25352284Sobrien 25452284Sobrien return mode; 25552284Sobrien} 25652284Sobrien 257117395Skan/* Return the alignment of MODE. This will be bounded by 1 and 258117395Skan BIGGEST_ALIGNMENT. */ 259117395Skan 260117395Skanunsigned int 261132718Skanget_mode_alignment (enum machine_mode mode) 262117395Skan{ 263132718Skan return MIN (BIGGEST_ALIGNMENT, MAX (1, mode_base_align[mode]*BITS_PER_UNIT)); 264117395Skan} 265117395Skan 26618334Speter 267132718Skan/* Subroutine of layout_decl: Force alignment required for the data type. 268132718Skan But if the decl itself wants greater alignment, don't override that. */ 269132718Skan 270132718Skanstatic inline void 271132718Skando_type_align (tree type, tree decl) 272132718Skan{ 273132718Skan if (TYPE_ALIGN (type) > DECL_ALIGN (decl)) 274132718Skan { 275132718Skan DECL_ALIGN (decl) = TYPE_ALIGN (type); 276132718Skan if (TREE_CODE (decl) == FIELD_DECL) 277132718Skan DECL_USER_ALIGN (decl) = TYPE_USER_ALIGN (type); 278132718Skan } 279132718Skan} 280132718Skan 28118334Speter/* Set the size, mode and alignment of a ..._DECL node. 28218334Speter TYPE_DECL does need this for C++. 28318334Speter Note that LABEL_DECL and CONST_DECL nodes do not need this, 28418334Speter and FUNCTION_DECL nodes have them set up in a special (and simple) way. 28518334Speter Don't call layout_decl for them. 28618334Speter 28718334Speter KNOWN_ALIGN is the amount of alignment we can assume this 28818334Speter decl has with no special effort. It is relevant only for FIELD_DECLs 28918334Speter and depends on the previous fields. 29018334Speter All that matters about KNOWN_ALIGN is which powers of 2 divide it. 29118334Speter If KNOWN_ALIGN is 0, it means, "as much alignment as you like": 29218334Speter the record will be aligned to suit. */ 29318334Speter 29418334Spetervoid 295132718Skanlayout_decl (tree decl, unsigned int known_align) 29618334Speter{ 29790075Sobrien tree type = TREE_TYPE (decl); 29890075Sobrien enum tree_code code = TREE_CODE (decl); 299117395Skan rtx rtl = NULL_RTX; 30018334Speter 30118334Speter if (code == CONST_DECL) 30218334Speter return; 30318334Speter 304169689Skan gcc_assert (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL 305169689Skan || code == TYPE_DECL ||code == FIELD_DECL); 306169689Skan 307117395Skan rtl = DECL_RTL_IF_SET (decl); 308117395Skan 30918334Speter if (type == error_mark_node) 31090075Sobrien type = void_type_node; 31118334Speter 31290075Sobrien /* Usually the size and mode come from the data type without change, 31390075Sobrien however, the front-end may set the explicit width of the field, so its 31490075Sobrien size may not be the same as the size of its type. This happens with 31590075Sobrien bitfields, of course (an `int' bitfield may be only 2 bits, say), but it 31690075Sobrien also happens with other fields. For example, the C++ front-end creates 31790075Sobrien zero-sized fields corresponding to empty base classes, and depends on 31890075Sobrien layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the 31990075Sobrien size in bytes from the size in bits. If we have already set the mode, 32090075Sobrien don't set it again since we can be called twice for FIELD_DECLs. */ 32118334Speter 322169689Skan DECL_UNSIGNED (decl) = TYPE_UNSIGNED (type); 32390075Sobrien if (DECL_MODE (decl) == VOIDmode) 32490075Sobrien DECL_MODE (decl) = TYPE_MODE (type); 32590075Sobrien 32618334Speter if (DECL_SIZE (decl) == 0) 32718334Speter { 32890075Sobrien DECL_SIZE (decl) = TYPE_SIZE (type); 32990075Sobrien DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type); 33090075Sobrien } 331132718Skan else if (DECL_SIZE_UNIT (decl) == 0) 33290075Sobrien DECL_SIZE_UNIT (decl) 333169689Skan = fold_convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl), 334169689Skan bitsize_unit_node)); 33518334Speter 336132718Skan if (code != FIELD_DECL) 337132718Skan /* For non-fields, update the alignment from the type. */ 338132718Skan do_type_align (type, decl); 339132718Skan else 340132718Skan /* For fields, it's a bit more complicated... */ 341117395Skan { 342132718Skan bool old_user_align = DECL_USER_ALIGN (decl); 343169689Skan bool zero_bitfield = false; 344169689Skan bool packed_p = DECL_PACKED (decl); 345169689Skan unsigned int mfa; 34618334Speter 347132718Skan if (DECL_BIT_FIELD (decl)) 348132718Skan { 349132718Skan DECL_BIT_FIELD_TYPE (decl) = type; 35090075Sobrien 351132718Skan /* A zero-length bit-field affects the alignment of the next 352169689Skan field. In essence such bit-fields are not influenced by 353169689Skan any packing due to #pragma pack or attribute packed. */ 354132718Skan if (integer_zerop (DECL_SIZE (decl)) 355169689Skan && ! targetm.ms_bitfield_layout_p (DECL_FIELD_CONTEXT (decl))) 356132718Skan { 357169689Skan zero_bitfield = true; 358169689Skan packed_p = false; 359132718Skan#ifdef PCC_BITFIELD_TYPE_MATTERS 360132718Skan if (PCC_BITFIELD_TYPE_MATTERS) 361132718Skan do_type_align (type, decl); 362132718Skan else 363132718Skan#endif 364132718Skan { 365132718Skan#ifdef EMPTY_FIELD_BOUNDARY 366132718Skan if (EMPTY_FIELD_BOUNDARY > DECL_ALIGN (decl)) 367132718Skan { 368132718Skan DECL_ALIGN (decl) = EMPTY_FIELD_BOUNDARY; 369132718Skan DECL_USER_ALIGN (decl) = 0; 370132718Skan } 371132718Skan#endif 372132718Skan } 373132718Skan } 374132718Skan 375132718Skan /* See if we can use an ordinary integer mode for a bit-field. 376132718Skan Conditions are: a fixed size that is correct for another mode 377132718Skan and occupying a complete byte or bytes on proper boundary. */ 378132718Skan if (TYPE_SIZE (type) != 0 379132718Skan && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 380132718Skan && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT) 381132718Skan { 382132718Skan enum machine_mode xmode 383132718Skan = mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1); 384132718Skan 385169689Skan if (xmode != BLKmode 386132718Skan && (known_align == 0 387132718Skan || known_align >= GET_MODE_ALIGNMENT (xmode))) 388132718Skan { 389132718Skan DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode), 390132718Skan DECL_ALIGN (decl)); 391132718Skan DECL_MODE (decl) = xmode; 392132718Skan DECL_BIT_FIELD (decl) = 0; 393132718Skan } 394132718Skan } 395132718Skan 396132718Skan /* Turn off DECL_BIT_FIELD if we won't need it set. */ 397132718Skan if (TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode 398132718Skan && known_align >= TYPE_ALIGN (type) 399132718Skan && DECL_ALIGN (decl) >= TYPE_ALIGN (type)) 400132718Skan DECL_BIT_FIELD (decl) = 0; 401132718Skan } 402169689Skan else if (packed_p && DECL_USER_ALIGN (decl)) 403132718Skan /* Don't touch DECL_ALIGN. For other packed fields, go ahead and 404132718Skan round up; we'll reduce it again below. We want packing to 405132718Skan supersede USER_ALIGN inherited from the type, but defer to 406132718Skan alignment explicitly specified on the field decl. */; 407132718Skan else 408132718Skan do_type_align (type, decl); 409132718Skan 41090075Sobrien /* If the field is of variable size, we can't misalign it since we 41190075Sobrien have no way to make a temporary to align the result. But this 41290075Sobrien isn't an issue if the decl is not addressable. Likewise if it 413132718Skan is of unknown size. 41418334Speter 415132718Skan Note that do_type_align may set DECL_USER_ALIGN, so we need to 416132718Skan check old_user_align instead. */ 417169689Skan if (packed_p 418132718Skan && !old_user_align 419132718Skan && (DECL_NONADDRESSABLE_P (decl) 420132718Skan || DECL_SIZE_UNIT (decl) == 0 421132718Skan || TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST)) 422132718Skan DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT); 42318334Speter 424169689Skan if (! packed_p && ! DECL_USER_ALIGN (decl)) 42518334Speter { 426132718Skan /* Some targets (i.e. i386, VMS) limit struct field alignment 427132718Skan to a lower boundary than alignment of variables unless 428132718Skan it was overridden by attribute aligned. */ 429132718Skan#ifdef BIGGEST_FIELD_ALIGNMENT 430132718Skan DECL_ALIGN (decl) 431132718Skan = MIN (DECL_ALIGN (decl), (unsigned) BIGGEST_FIELD_ALIGNMENT); 432132718Skan#endif 433132718Skan#ifdef ADJUST_FIELD_ALIGN 434132718Skan DECL_ALIGN (decl) = ADJUST_FIELD_ALIGN (decl, DECL_ALIGN (decl)); 435132718Skan#endif 43618334Speter } 437169689Skan 438169689Skan if (zero_bitfield) 439169689Skan mfa = initial_max_fld_align * BITS_PER_UNIT; 440169689Skan else 441169689Skan mfa = maximum_field_alignment; 442169689Skan /* Should this be controlled by DECL_USER_ALIGN, too? */ 443169689Skan if (mfa != 0) 444169689Skan DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), mfa); 44518334Speter } 44618334Speter 44718334Speter /* Evaluate nonconstant size only once, either now or as soon as safe. */ 44818334Speter if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) 44918334Speter DECL_SIZE (decl) = variable_size (DECL_SIZE (decl)); 45090075Sobrien if (DECL_SIZE_UNIT (decl) != 0 45190075Sobrien && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST) 45290075Sobrien DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl)); 45390075Sobrien 45490075Sobrien /* If requested, warn about definitions of large data objects. */ 45590075Sobrien if (warn_larger_than 45690075Sobrien && (code == VAR_DECL || code == PARM_DECL) 45790075Sobrien && ! DECL_EXTERNAL (decl)) 45890075Sobrien { 45990075Sobrien tree size = DECL_SIZE_UNIT (decl); 46090075Sobrien 46190075Sobrien if (size != 0 && TREE_CODE (size) == INTEGER_CST 46290075Sobrien && compare_tree_int (size, larger_than_size) > 0) 46390075Sobrien { 464132718Skan int size_as_int = TREE_INT_CST_LOW (size); 46590075Sobrien 46690075Sobrien if (compare_tree_int (size, size_as_int) == 0) 467169689Skan warning (0, "size of %q+D is %d bytes", decl, size_as_int); 46890075Sobrien else 469169689Skan warning (0, "size of %q+D is larger than %wd bytes", 470169689Skan decl, larger_than_size); 47190075Sobrien } 47290075Sobrien } 473117395Skan 474117395Skan /* If the RTL was already set, update its mode and mem attributes. */ 475117395Skan if (rtl) 476117395Skan { 477117395Skan PUT_MODE (rtl, DECL_MODE (decl)); 478117395Skan SET_DECL_RTL (decl, 0); 479117395Skan set_mem_attributes (rtl, decl, 1); 480117395Skan SET_DECL_RTL (decl, rtl); 481117395Skan } 48218334Speter} 483169689Skan 484169689Skan/* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of 485169689Skan a previous call to layout_decl and calls it again. */ 486169689Skan 487169689Skanvoid 488169689Skanrelayout_decl (tree decl) 489169689Skan{ 490169689Skan DECL_SIZE (decl) = DECL_SIZE_UNIT (decl) = 0; 491169689Skan DECL_MODE (decl) = VOIDmode; 492169689Skan if (!DECL_USER_ALIGN (decl)) 493169689Skan DECL_ALIGN (decl) = 0; 494169689Skan SET_DECL_RTL (decl, 0); 495169689Skan 496169689Skan layout_decl (decl, 0); 497169689Skan} 49818334Speter 49990075Sobrien/* Hook for a front-end function that can modify the record layout as needed 50090075Sobrien immediately before it is finalized. */ 50118334Speter 502169689Skanstatic void (*lang_adjust_rli) (record_layout_info) = 0; 50318334Speter 50490075Sobrienvoid 505132718Skanset_lang_adjust_rli (void (*f) (record_layout_info)) 50690075Sobrien{ 50790075Sobrien lang_adjust_rli = f; 50890075Sobrien} 50918334Speter 51090075Sobrien/* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or 51190075Sobrien QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which 51290075Sobrien is to be passed to all other layout functions for this record. It is the 513117395Skan responsibility of the caller to call `free' for the storage returned. 51490075Sobrien Note that garbage collection is not permitted until we finish laying 51590075Sobrien out the record. */ 51690075Sobrien 51790075Sobrienrecord_layout_info 518132718Skanstart_record_layout (tree t) 51918334Speter{ 520132718Skan record_layout_info rli = xmalloc (sizeof (struct record_layout_info_s)); 52118334Speter 52290075Sobrien rli->t = t; 52390075Sobrien 52490075Sobrien /* If the type has a minimum specified alignment (via an attribute 52590075Sobrien declaration, for example) use it -- otherwise, start with a 52690075Sobrien one-byte alignment. */ 52790075Sobrien rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t)); 528132718Skan rli->unpacked_align = rli->record_align; 52990075Sobrien rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT); 53090075Sobrien 53150397Sobrien#ifdef STRUCTURE_SIZE_BOUNDARY 53250397Sobrien /* Packed structures don't need to have minimum size. */ 53390075Sobrien if (! TYPE_PACKED (t)) 534132718Skan rli->record_align = MAX (rli->record_align, (unsigned) STRUCTURE_SIZE_BOUNDARY); 53550397Sobrien#endif 53618334Speter 53790075Sobrien rli->offset = size_zero_node; 53890075Sobrien rli->bitpos = bitsize_zero_node; 53996263Sobrien rli->prev_field = 0; 54090075Sobrien rli->pending_statics = 0; 54190075Sobrien rli->packed_maybe_necessary = 0; 542169689Skan rli->remaining_in_alignment = 0; 54390075Sobrien 54490075Sobrien return rli; 54590075Sobrien} 54690075Sobrien 54790075Sobrien/* These four routines perform computations that convert between 54890075Sobrien the offset/bitpos forms and byte and bit offsets. */ 54990075Sobrien 55090075Sobrientree 551132718Skanbit_from_pos (tree offset, tree bitpos) 55290075Sobrien{ 55390075Sobrien return size_binop (PLUS_EXPR, bitpos, 554169689Skan size_binop (MULT_EXPR, 555169689Skan fold_convert (bitsizetype, offset), 55690075Sobrien bitsize_unit_node)); 55790075Sobrien} 55890075Sobrien 55990075Sobrientree 560132718Skanbyte_from_pos (tree offset, tree bitpos) 56190075Sobrien{ 56290075Sobrien return size_binop (PLUS_EXPR, offset, 563169689Skan fold_convert (sizetype, 564169689Skan size_binop (TRUNC_DIV_EXPR, bitpos, 565169689Skan bitsize_unit_node))); 56690075Sobrien} 56790075Sobrien 56890075Sobrienvoid 569132718Skanpos_from_bit (tree *poffset, tree *pbitpos, unsigned int off_align, 570132718Skan tree pos) 57190075Sobrien{ 57290075Sobrien *poffset = size_binop (MULT_EXPR, 573169689Skan fold_convert (sizetype, 574169689Skan size_binop (FLOOR_DIV_EXPR, pos, 575169689Skan bitsize_int (off_align))), 57690075Sobrien size_int (off_align / BITS_PER_UNIT)); 57790075Sobrien *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, bitsize_int (off_align)); 57890075Sobrien} 57990075Sobrien 58090075Sobrien/* Given a pointer to bit and byte offsets and an offset alignment, 58190075Sobrien normalize the offsets so they are within the alignment. */ 58290075Sobrien 58390075Sobrienvoid 584132718Skannormalize_offset (tree *poffset, tree *pbitpos, unsigned int off_align) 58590075Sobrien{ 58690075Sobrien /* If the bit position is now larger than it should be, adjust it 58790075Sobrien downwards. */ 58890075Sobrien if (compare_tree_int (*pbitpos, off_align) >= 0) 58918334Speter { 59090075Sobrien tree extra_aligns = size_binop (FLOOR_DIV_EXPR, *pbitpos, 59190075Sobrien bitsize_int (off_align)); 59218334Speter 59390075Sobrien *poffset 59490075Sobrien = size_binop (PLUS_EXPR, *poffset, 595169689Skan size_binop (MULT_EXPR, 596169689Skan fold_convert (sizetype, extra_aligns), 59790075Sobrien size_int (off_align / BITS_PER_UNIT))); 598117395Skan 59990075Sobrien *pbitpos 60090075Sobrien = size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align)); 60190075Sobrien } 60290075Sobrien} 60318334Speter 60490075Sobrien/* Print debugging information about the information in RLI. */ 60518334Speter 60690075Sobrienvoid 607132718Skandebug_rli (record_layout_info rli) 60890075Sobrien{ 60990075Sobrien print_node_brief (stderr, "type", rli->t, 0); 61090075Sobrien print_node_brief (stderr, "\noffset", rli->offset, 0); 61190075Sobrien print_node_brief (stderr, " bitpos", rli->bitpos, 0); 61290075Sobrien 613132718Skan fprintf (stderr, "\naligns: rec = %u, unpack = %u, off = %u\n", 614132718Skan rli->record_align, rli->unpacked_align, 61590075Sobrien rli->offset_align); 616169689Skan 617169689Skan /* The ms_struct code is the only that uses this. */ 618169689Skan if (targetm.ms_bitfield_layout_p (rli->t)) 619169689Skan fprintf (stderr, "remaining in alignment = %u\n", rli->remaining_in_alignment); 620169689Skan 62190075Sobrien if (rli->packed_maybe_necessary) 62290075Sobrien fprintf (stderr, "packed may be necessary\n"); 62390075Sobrien 62490075Sobrien if (rli->pending_statics) 62590075Sobrien { 62690075Sobrien fprintf (stderr, "pending statics:\n"); 62790075Sobrien debug_tree (rli->pending_statics); 62890075Sobrien } 62990075Sobrien} 63090075Sobrien 63190075Sobrien/* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and 63290075Sobrien BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */ 63390075Sobrien 63490075Sobrienvoid 635132718Skannormalize_rli (record_layout_info rli) 63690075Sobrien{ 63790075Sobrien normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align); 63890075Sobrien} 63990075Sobrien 64090075Sobrien/* Returns the size in bytes allocated so far. */ 64190075Sobrien 64290075Sobrientree 643132718Skanrli_size_unit_so_far (record_layout_info rli) 64490075Sobrien{ 64590075Sobrien return byte_from_pos (rli->offset, rli->bitpos); 64690075Sobrien} 64790075Sobrien 64890075Sobrien/* Returns the size in bits allocated so far. */ 64990075Sobrien 65090075Sobrientree 651132718Skanrli_size_so_far (record_layout_info rli) 65290075Sobrien{ 65390075Sobrien return bit_from_pos (rli->offset, rli->bitpos); 65490075Sobrien} 65590075Sobrien 656117395Skan/* FIELD is about to be added to RLI->T. The alignment (in bits) of 657169689Skan the next available location within the record is given by KNOWN_ALIGN. 658169689Skan Update the variable alignment fields in RLI, and return the alignment 659169689Skan to give the FIELD. */ 66090075Sobrien 661169689Skanunsigned int 662132718Skanupdate_alignment_for_field (record_layout_info rli, tree field, 663132718Skan unsigned int known_align) 66490075Sobrien{ 665117395Skan /* The alignment required for FIELD. */ 66690075Sobrien unsigned int desired_align; 667117395Skan /* The type of this field. */ 668117395Skan tree type = TREE_TYPE (field); 669117395Skan /* True if the field was explicitly aligned by the user. */ 670117395Skan bool user_align; 671132718Skan bool is_bitfield; 67290075Sobrien 673169689Skan /* Do not attempt to align an ERROR_MARK node */ 674169689Skan if (TREE_CODE (type) == ERROR_MARK) 675169689Skan return 0; 676169689Skan 677132718Skan /* Lay out the field so we know what alignment it needs. */ 678132718Skan layout_decl (field, known_align); 67990075Sobrien desired_align = DECL_ALIGN (field); 680117395Skan user_align = DECL_USER_ALIGN (field); 68190075Sobrien 682132718Skan is_bitfield = (type != error_mark_node 683132718Skan && DECL_BIT_FIELD_TYPE (field) 684132718Skan && ! integer_zerop (TYPE_SIZE (type))); 68590075Sobrien 686117395Skan /* Record must have at least as much alignment as any field. 687117395Skan Otherwise, the alignment of the field within the record is 688117395Skan meaningless. */ 689169689Skan if (targetm.ms_bitfield_layout_p (rli->t)) 690117395Skan { 691117395Skan /* Here, the alignment of the underlying type of a bitfield can 692117395Skan affect the alignment of a record; even a zero-sized field 693117395Skan can do this. The alignment should be to the alignment of 694117395Skan the type, except that for zero-size bitfields this only 695117395Skan applies if there was an immediately prior, nonzero-size 696117395Skan bitfield. (That's the way it is, experimentally.) */ 697169689Skan if ((!is_bitfield && !DECL_PACKED (field)) 698169689Skan || (!integer_zerop (DECL_SIZE (field)) 699169689Skan ? !DECL_PACKED (field) 700169689Skan : (rli->prev_field 701169689Skan && DECL_BIT_FIELD_TYPE (rli->prev_field) 702169689Skan && ! integer_zerop (DECL_SIZE (rli->prev_field))))) 703117395Skan { 704117395Skan unsigned int type_align = TYPE_ALIGN (type); 705117395Skan type_align = MAX (type_align, desired_align); 706117395Skan if (maximum_field_alignment != 0) 707117395Skan type_align = MIN (type_align, maximum_field_alignment); 708117395Skan rli->record_align = MAX (rli->record_align, type_align); 709117395Skan rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); 710117395Skan } 711117395Skan } 71290075Sobrien#ifdef PCC_BITFIELD_TYPE_MATTERS 713132718Skan else if (is_bitfield && PCC_BITFIELD_TYPE_MATTERS) 71490075Sobrien { 715132718Skan /* Named bit-fields cause the entire structure to have the 716169689Skan alignment implied by their type. Some targets also apply the same 717169689Skan rules to unnamed bitfields. */ 718169689Skan if (DECL_NAME (field) != 0 719169689Skan || targetm.align_anon_bitfield ()) 720117395Skan { 721117395Skan unsigned int type_align = TYPE_ALIGN (type); 722117395Skan 723102780Skan#ifdef ADJUST_FIELD_ALIGN 724117395Skan if (! TYPE_USER_ALIGN (type)) 725117395Skan type_align = ADJUST_FIELD_ALIGN (field, type_align); 726102780Skan#endif 727117395Skan 728169689Skan /* Targets might chose to handle unnamed and hence possibly 729169689Skan zero-width bitfield. Those are not influenced by #pragmas 730169689Skan or packed attributes. */ 731169689Skan if (integer_zerop (DECL_SIZE (field))) 732169689Skan { 733169689Skan if (initial_max_fld_align) 734169689Skan type_align = MIN (type_align, 735169689Skan initial_max_fld_align * BITS_PER_UNIT); 736169689Skan } 737169689Skan else if (maximum_field_alignment != 0) 738117395Skan type_align = MIN (type_align, maximum_field_alignment); 739117395Skan else if (DECL_PACKED (field)) 740117395Skan type_align = MIN (type_align, BITS_PER_UNIT); 741117395Skan 742132718Skan /* The alignment of the record is increased to the maximum 743132718Skan of the current alignment, the alignment indicated on the 744132718Skan field (i.e., the alignment specified by an __aligned__ 745132718Skan attribute), and the alignment indicated by the type of 746132718Skan the field. */ 747132718Skan rli->record_align = MAX (rli->record_align, desired_align); 748117395Skan rli->record_align = MAX (rli->record_align, type_align); 749132718Skan 750117395Skan if (warn_packed) 751117395Skan rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); 752117395Skan user_align |= TYPE_USER_ALIGN (type); 753117395Skan } 75490075Sobrien } 755132718Skan#endif 756117395Skan else 757117395Skan { 758117395Skan rli->record_align = MAX (rli->record_align, desired_align); 759117395Skan rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); 760117395Skan } 76118334Speter 762117395Skan TYPE_USER_ALIGN (rli->t) |= user_align; 763117395Skan 764117395Skan return desired_align; 765117395Skan} 766117395Skan 767117395Skan/* Called from place_field to handle unions. */ 768117395Skan 769117395Skanstatic void 770132718Skanplace_union_field (record_layout_info rli, tree field) 771117395Skan{ 772117395Skan update_alignment_for_field (rli, field, /*known_align=*/0); 773117395Skan 774117395Skan DECL_FIELD_OFFSET (field) = size_zero_node; 775117395Skan DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node; 776117395Skan SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT); 777117395Skan 778169689Skan /* If this is an ERROR_MARK return *after* having set the 779169689Skan field at the start of the union. This helps when parsing 780169689Skan invalid fields. */ 781169689Skan if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK) 782169689Skan return; 783169689Skan 78490075Sobrien /* We assume the union's size will be a multiple of a byte so we don't 78590075Sobrien bother with BITPOS. */ 78690075Sobrien if (TREE_CODE (rli->t) == UNION_TYPE) 78790075Sobrien rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field)); 78890075Sobrien else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE) 789169689Skan rli->offset = fold_build3 (COND_EXPR, sizetype, 79090075Sobrien DECL_QUALIFIER (field), 791169689Skan DECL_SIZE_UNIT (field), rli->offset); 79290075Sobrien} 79318334Speter 794132718Skan#if defined (PCC_BITFIELD_TYPE_MATTERS) || defined (BITFIELD_NBYTES_LIMITED) 795132718Skan/* A bitfield of SIZE with a required access alignment of ALIGN is allocated 796132718Skan at BYTE_OFFSET / BIT_OFFSET. Return nonzero if the field would span more 797132718Skan units of alignment than the underlying TYPE. */ 798132718Skanstatic int 799132718Skanexcess_unit_span (HOST_WIDE_INT byte_offset, HOST_WIDE_INT bit_offset, 800132718Skan HOST_WIDE_INT size, HOST_WIDE_INT align, tree type) 801132718Skan{ 802132718Skan /* Note that the calculation of OFFSET might overflow; we calculate it so 803132718Skan that we still get the right result as long as ALIGN is a power of two. */ 804132718Skan unsigned HOST_WIDE_INT offset = byte_offset * BITS_PER_UNIT + bit_offset; 805132718Skan 806132718Skan offset = offset % align; 807132718Skan return ((offset + size + align - 1) / align 808132718Skan > ((unsigned HOST_WIDE_INT) tree_low_cst (TYPE_SIZE (type), 1) 809132718Skan / align)); 810132718Skan} 811132718Skan#endif 812132718Skan 81390075Sobrien/* RLI contains information about the layout of a RECORD_TYPE. FIELD 81490075Sobrien is a FIELD_DECL to be added after those fields already present in 81590075Sobrien T. (FIELD is not actually added to the TYPE_FIELDS list here; 81690075Sobrien callers that desire that behavior must manually perform that step.) */ 81718334Speter 81890075Sobrienvoid 819132718Skanplace_field (record_layout_info rli, tree field) 82090075Sobrien{ 82190075Sobrien /* The alignment required for FIELD. */ 82290075Sobrien unsigned int desired_align; 82390075Sobrien /* The alignment FIELD would have if we just dropped it into the 82490075Sobrien record as it presently stands. */ 82590075Sobrien unsigned int known_align; 82690075Sobrien unsigned int actual_align; 82790075Sobrien /* The type of this field. */ 82890075Sobrien tree type = TREE_TYPE (field); 829117395Skan 830169689Skan gcc_assert (TREE_CODE (field) != ERROR_MARK); 83118334Speter 83290075Sobrien /* If FIELD is static, then treat it like a separate variable, not 83390075Sobrien really like a structure field. If it is a FUNCTION_DECL, it's a 83490075Sobrien method. In both cases, all we do is lay out the decl, and we do 83590075Sobrien it *after* the record is laid out. */ 83690075Sobrien if (TREE_CODE (field) == VAR_DECL) 83790075Sobrien { 83890075Sobrien rli->pending_statics = tree_cons (NULL_TREE, field, 83990075Sobrien rli->pending_statics); 84090075Sobrien return; 84190075Sobrien } 84218334Speter 84390075Sobrien /* Enumerators and enum types which are local to this class need not 84490075Sobrien be laid out. Likewise for initialized constant fields. */ 84590075Sobrien else if (TREE_CODE (field) != FIELD_DECL) 84690075Sobrien return; 84790075Sobrien 84890075Sobrien /* Unions are laid out very differently than records, so split 84990075Sobrien that code off to another function. */ 85090075Sobrien else if (TREE_CODE (rli->t) != RECORD_TYPE) 85190075Sobrien { 85290075Sobrien place_union_field (rli, field); 85390075Sobrien return; 85490075Sobrien } 85590075Sobrien 856169689Skan else if (TREE_CODE (type) == ERROR_MARK) 857169689Skan { 858169689Skan /* Place this field at the current allocation position, so we 859169689Skan maintain monotonicity. */ 860169689Skan DECL_FIELD_OFFSET (field) = rli->offset; 861169689Skan DECL_FIELD_BIT_OFFSET (field) = rli->bitpos; 862169689Skan SET_DECL_OFFSET_ALIGN (field, rli->offset_align); 863169689Skan return; 864169689Skan } 865169689Skan 86690075Sobrien /* Work out the known alignment so far. Note that A & (-A) is the 86790075Sobrien value of the least-significant bit in A that is one. */ 86890075Sobrien if (! integer_zerop (rli->bitpos)) 86990075Sobrien known_align = (tree_low_cst (rli->bitpos, 1) 87090075Sobrien & - tree_low_cst (rli->bitpos, 1)); 87190075Sobrien else if (integer_zerop (rli->offset)) 872169689Skan known_align = 0; 87390075Sobrien else if (host_integerp (rli->offset, 1)) 87490075Sobrien known_align = (BITS_PER_UNIT 87590075Sobrien * (tree_low_cst (rli->offset, 1) 87690075Sobrien & - tree_low_cst (rli->offset, 1))); 87790075Sobrien else 87890075Sobrien known_align = rli->offset_align; 879132718Skan 880117395Skan desired_align = update_alignment_for_field (rli, field, known_align); 881169689Skan if (known_align == 0) 882169689Skan known_align = MAX (BIGGEST_ALIGNMENT, rli->record_align); 88390075Sobrien 88490075Sobrien if (warn_packed && DECL_PACKED (field)) 88590075Sobrien { 886132718Skan if (known_align >= TYPE_ALIGN (type)) 88790075Sobrien { 88890075Sobrien if (TYPE_ALIGN (type) > desired_align) 88990075Sobrien { 89090075Sobrien if (STRICT_ALIGNMENT) 891169689Skan warning (OPT_Wattributes, "packed attribute causes " 892169689Skan "inefficient alignment for %q+D", field); 89390075Sobrien else 894169689Skan warning (OPT_Wattributes, "packed attribute is " 895169689Skan "unnecessary for %q+D", field); 89690075Sobrien } 89790075Sobrien } 89890075Sobrien else 89990075Sobrien rli->packed_maybe_necessary = 1; 90090075Sobrien } 90118334Speter 90290075Sobrien /* Does this field automatically have alignment it needs by virtue 903169689Skan of the fields that precede it and the record's own alignment? 904169689Skan We already align ms_struct fields, so don't re-align them. */ 905169689Skan if (known_align < desired_align 906169689Skan && !targetm.ms_bitfield_layout_p (rli->t)) 90790075Sobrien { 90890075Sobrien /* No, we need to skip space before this field. 90990075Sobrien Bump the cumulative size to multiple of field alignment. */ 91090075Sobrien 911169689Skan warning (OPT_Wpadded, "padding struct to align %q+D", field); 91290075Sobrien 91390075Sobrien /* If the alignment is still within offset_align, just align 91490075Sobrien the bit position. */ 91590075Sobrien if (desired_align < rli->offset_align) 91690075Sobrien rli->bitpos = round_up (rli->bitpos, desired_align); 91718334Speter else 91818334Speter { 91990075Sobrien /* First adjust OFFSET by the partial bits, then align. */ 92090075Sobrien rli->offset 92190075Sobrien = size_binop (PLUS_EXPR, rli->offset, 922169689Skan fold_convert (sizetype, 923169689Skan size_binop (CEIL_DIV_EXPR, rli->bitpos, 924169689Skan bitsize_unit_node))); 92590075Sobrien rli->bitpos = bitsize_zero_node; 92618334Speter 92790075Sobrien rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT); 92818334Speter } 92918334Speter 93090075Sobrien if (! TREE_CONSTANT (rli->offset)) 93190075Sobrien rli->offset_align = desired_align; 93218334Speter 93390075Sobrien } 93418334Speter 93590075Sobrien /* Handle compatibility with PCC. Note that if the record has any 93690075Sobrien variable-sized fields, we need not worry about compatibility. */ 93790075Sobrien#ifdef PCC_BITFIELD_TYPE_MATTERS 93890075Sobrien if (PCC_BITFIELD_TYPE_MATTERS 939169689Skan && ! targetm.ms_bitfield_layout_p (rli->t) 94090075Sobrien && TREE_CODE (field) == FIELD_DECL 94190075Sobrien && type != error_mark_node 94290075Sobrien && DECL_BIT_FIELD (field) 94390075Sobrien && ! DECL_PACKED (field) 94490075Sobrien && maximum_field_alignment == 0 94590075Sobrien && ! integer_zerop (DECL_SIZE (field)) 94690075Sobrien && host_integerp (DECL_SIZE (field), 1) 94790075Sobrien && host_integerp (rli->offset, 1) 94890075Sobrien && host_integerp (TYPE_SIZE (type), 1)) 94990075Sobrien { 95090075Sobrien unsigned int type_align = TYPE_ALIGN (type); 95190075Sobrien tree dsize = DECL_SIZE (field); 95290075Sobrien HOST_WIDE_INT field_size = tree_low_cst (dsize, 1); 95390075Sobrien HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0); 95490075Sobrien HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0); 95590075Sobrien 956102780Skan#ifdef ADJUST_FIELD_ALIGN 957102780Skan if (! TYPE_USER_ALIGN (type)) 958102780Skan type_align = ADJUST_FIELD_ALIGN (field, type_align); 959102780Skan#endif 960102780Skan 96190075Sobrien /* A bit field may not span more units of alignment of its type 96290075Sobrien than its type itself. Advance to next boundary if necessary. */ 963132718Skan if (excess_unit_span (offset, bit_offset, field_size, type_align, type)) 96490075Sobrien rli->bitpos = round_up (rli->bitpos, type_align); 965102780Skan 966117395Skan TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type); 96718334Speter } 96890075Sobrien#endif 96918334Speter 97090075Sobrien#ifdef BITFIELD_NBYTES_LIMITED 97190075Sobrien if (BITFIELD_NBYTES_LIMITED 972169689Skan && ! targetm.ms_bitfield_layout_p (rli->t) 97390075Sobrien && TREE_CODE (field) == FIELD_DECL 97490075Sobrien && type != error_mark_node 97590075Sobrien && DECL_BIT_FIELD_TYPE (field) 97690075Sobrien && ! DECL_PACKED (field) 97790075Sobrien && ! integer_zerop (DECL_SIZE (field)) 97890075Sobrien && host_integerp (DECL_SIZE (field), 1) 97990075Sobrien && host_integerp (rli->offset, 1) 98090075Sobrien && host_integerp (TYPE_SIZE (type), 1)) 98190075Sobrien { 98290075Sobrien unsigned int type_align = TYPE_ALIGN (type); 98390075Sobrien tree dsize = DECL_SIZE (field); 98490075Sobrien HOST_WIDE_INT field_size = tree_low_cst (dsize, 1); 98590075Sobrien HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0); 98690075Sobrien HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0); 98718334Speter 988102780Skan#ifdef ADJUST_FIELD_ALIGN 989102780Skan if (! TYPE_USER_ALIGN (type)) 990102780Skan type_align = ADJUST_FIELD_ALIGN (field, type_align); 991102780Skan#endif 992102780Skan 99390075Sobrien if (maximum_field_alignment != 0) 99490075Sobrien type_align = MIN (type_align, maximum_field_alignment); 99590075Sobrien /* ??? This test is opposite the test in the containing if 99690075Sobrien statement, so this code is unreachable currently. */ 99790075Sobrien else if (DECL_PACKED (field)) 99890075Sobrien type_align = MIN (type_align, BITS_PER_UNIT); 99990075Sobrien 100090075Sobrien /* A bit field may not span the unit of alignment of its type. 100190075Sobrien Advance to next boundary if necessary. */ 1002132718Skan if (excess_unit_span (offset, bit_offset, field_size, type_align, type)) 100390075Sobrien rli->bitpos = round_up (rli->bitpos, type_align); 1004102780Skan 1005117395Skan TYPE_USER_ALIGN (rli->t) |= TYPE_USER_ALIGN (type); 100690075Sobrien } 100790075Sobrien#endif 100890075Sobrien 1009117395Skan /* See the docs for TARGET_MS_BITFIELD_LAYOUT_P for details. 1010117395Skan A subtlety: 1011117395Skan When a bit field is inserted into a packed record, the whole 1012117395Skan size of the underlying type is used by one or more same-size 1013132718Skan adjacent bitfields. (That is, if its long:3, 32 bits is 1014117395Skan used in the record, and any additional adjacent long bitfields are 1015117395Skan packed into the same chunk of 32 bits. However, if the size 1016117395Skan changes, a new field of that size is allocated.) In an unpacked 1017132718Skan record, this is the same as using alignment, but not equivalent 1018132718Skan when packing. 1019117395Skan 1020132718Skan Note: for compatibility, we use the type size, not the type alignment 1021117395Skan to determine alignment, since that matches the documentation */ 1022117395Skan 1023169689Skan if (targetm.ms_bitfield_layout_p (rli->t)) 102496263Sobrien { 1025117395Skan tree prev_saved = rli->prev_field; 1026169689Skan tree prev_type = prev_saved ? DECL_BIT_FIELD_TYPE (prev_saved) : NULL; 102796263Sobrien 1028169689Skan /* This is a bitfield if it exists. */ 1029169689Skan if (rli->prev_field) 1030117395Skan { 1031117395Skan /* If both are bitfields, nonzero, and the same size, this is 1032117395Skan the middle of a run. Zero declared size fields are special 1033117395Skan and handled as "end of run". (Note: it's nonzero declared 1034117395Skan size, but equal type sizes!) (Since we know that both 1035117395Skan the current and previous fields are bitfields by the 1036117395Skan time we check it, DECL_SIZE must be present for both.) */ 1037117395Skan if (DECL_BIT_FIELD_TYPE (field) 1038117395Skan && !integer_zerop (DECL_SIZE (field)) 1039117395Skan && !integer_zerop (DECL_SIZE (rli->prev_field)) 1040132718Skan && host_integerp (DECL_SIZE (rli->prev_field), 0) 1041132718Skan && host_integerp (TYPE_SIZE (type), 0) 1042169689Skan && simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type))) 1043117395Skan { 1044117395Skan /* We're in the middle of a run of equal type size fields; make 1045117395Skan sure we realign if we run out of bits. (Not decl size, 1046117395Skan type size!) */ 1047169689Skan HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1); 104896263Sobrien 1049117395Skan if (rli->remaining_in_alignment < bitsize) 1050117395Skan { 1051169689Skan HOST_WIDE_INT typesize = tree_low_cst (TYPE_SIZE (type), 1); 1052169689Skan 1053117395Skan /* out of bits; bump up to next 'word'. */ 1054132718Skan rli->bitpos 1055169689Skan = size_binop (PLUS_EXPR, rli->bitpos, 1056169689Skan bitsize_int (rli->remaining_in_alignment)); 1057117395Skan rli->prev_field = field; 1058169689Skan if (typesize < bitsize) 1059169689Skan rli->remaining_in_alignment = 0; 1060169689Skan else 1061169689Skan rli->remaining_in_alignment = typesize - bitsize; 1062117395Skan } 1063169689Skan else 1064169689Skan rli->remaining_in_alignment -= bitsize; 1065117395Skan } 1066117395Skan else 1067117395Skan { 1068132718Skan /* End of a run: if leaving a run of bitfields of the same type 1069132718Skan size, we have to "use up" the rest of the bits of the type 1070117395Skan size. 107196263Sobrien 1072117395Skan Compute the new position as the sum of the size for the prior 1073117395Skan type and where we first started working on that type. 1074117395Skan Note: since the beginning of the field was aligned then 1075117395Skan of course the end will be too. No round needed. */ 1076117395Skan 1077117395Skan if (!integer_zerop (DECL_SIZE (rli->prev_field))) 1078117395Skan { 1079132718Skan rli->bitpos 1080169689Skan = size_binop (PLUS_EXPR, rli->bitpos, 1081169689Skan bitsize_int (rli->remaining_in_alignment)); 1082117395Skan } 1083117395Skan else 1084132718Skan /* We "use up" size zero fields; the code below should behave 1085132718Skan as if the prior field was not a bitfield. */ 1086132718Skan prev_saved = NULL; 1087117395Skan 1088132718Skan /* Cause a new bitfield to be captured, either this time (if 1089117395Skan currently a bitfield) or next time we see one. */ 1090117395Skan if (!DECL_BIT_FIELD_TYPE(field) 1091169689Skan || integer_zerop (DECL_SIZE (field))) 1092132718Skan rli->prev_field = NULL; 1093117395Skan } 1094132718Skan 1095117395Skan normalize_rli (rli); 1096117395Skan } 1097117395Skan 1098117395Skan /* If we're starting a new run of same size type bitfields 1099117395Skan (or a run of non-bitfields), set up the "first of the run" 1100132718Skan fields. 1101117395Skan 1102117395Skan That is, if the current field is not a bitfield, or if there 1103117395Skan was a prior bitfield the type sizes differ, or if there wasn't 1104117395Skan a prior bitfield the size of the current field is nonzero. 1105117395Skan 1106117395Skan Note: we must be sure to test ONLY the type size if there was 1107117395Skan a prior bitfield and ONLY for the current field being zero if 1108117395Skan there wasn't. */ 1109117395Skan 1110117395Skan if (!DECL_BIT_FIELD_TYPE (field) 1111169689Skan || (prev_saved != NULL 1112169689Skan ? !simple_cst_equal (TYPE_SIZE (type), TYPE_SIZE (prev_type)) 1113132718Skan : !integer_zerop (DECL_SIZE (field)) )) 1114117395Skan { 1115132718Skan /* Never smaller than a byte for compatibility. */ 1116132718Skan unsigned int type_align = BITS_PER_UNIT; 1117117395Skan 1118132718Skan /* (When not a bitfield), we could be seeing a flex array (with 1119117395Skan no DECL_SIZE). Since we won't be using remaining_in_alignment 1120132718Skan until we see a bitfield (and come by here again) we just skip 1121117395Skan calculating it. */ 1122132718Skan if (DECL_SIZE (field) != NULL 1123132718Skan && host_integerp (TYPE_SIZE (TREE_TYPE (field)), 0) 1124132718Skan && host_integerp (DECL_SIZE (field), 0)) 1125169689Skan { 1126169689Skan HOST_WIDE_INT bitsize = tree_low_cst (DECL_SIZE (field), 1); 1127169689Skan HOST_WIDE_INT typesize 1128169689Skan = tree_low_cst (TYPE_SIZE (TREE_TYPE (field)), 1); 1129117395Skan 1130169689Skan if (typesize < bitsize) 1131169689Skan rli->remaining_in_alignment = 0; 1132169689Skan else 1133169689Skan rli->remaining_in_alignment = typesize - bitsize; 1134169689Skan } 1135169689Skan 1136117395Skan /* Now align (conventionally) for the new type. */ 1137169689Skan type_align = TYPE_ALIGN (TREE_TYPE (field)); 1138117395Skan 1139117395Skan if (maximum_field_alignment != 0) 1140117395Skan type_align = MIN (type_align, maximum_field_alignment); 1141117395Skan 1142117395Skan rli->bitpos = round_up (rli->bitpos, type_align); 1143132718Skan 1144117395Skan /* If we really aligned, don't allow subsequent bitfields 1145117395Skan to undo that. */ 1146117395Skan rli->prev_field = NULL; 1147117395Skan } 114896263Sobrien } 114996263Sobrien 115090075Sobrien /* Offset so far becomes the position of this field after normalizing. */ 115190075Sobrien normalize_rli (rli); 115290075Sobrien DECL_FIELD_OFFSET (field) = rli->offset; 115390075Sobrien DECL_FIELD_BIT_OFFSET (field) = rli->bitpos; 115490075Sobrien SET_DECL_OFFSET_ALIGN (field, rli->offset_align); 115590075Sobrien 115690075Sobrien /* If this field ended up more aligned than we thought it would be (we 115790075Sobrien approximate this by seeing if its position changed), lay out the field 115890075Sobrien again; perhaps we can use an integral mode for it now. */ 115990075Sobrien if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field))) 116090075Sobrien actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1) 116190075Sobrien & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)); 116290075Sobrien else if (integer_zerop (DECL_FIELD_OFFSET (field))) 1163169689Skan actual_align = MAX (BIGGEST_ALIGNMENT, rli->record_align); 116490075Sobrien else if (host_integerp (DECL_FIELD_OFFSET (field), 1)) 116590075Sobrien actual_align = (BITS_PER_UNIT 116690075Sobrien * (tree_low_cst (DECL_FIELD_OFFSET (field), 1) 116790075Sobrien & - tree_low_cst (DECL_FIELD_OFFSET (field), 1))); 116890075Sobrien else 116990075Sobrien actual_align = DECL_OFFSET_ALIGN (field); 1170169689Skan /* ACTUAL_ALIGN is still the actual alignment *within the record* . 1171169689Skan store / extract bit field operations will check the alignment of the 1172169689Skan record against the mode of bit fields. */ 117390075Sobrien 117490075Sobrien if (known_align != actual_align) 117590075Sobrien layout_decl (field, actual_align); 117690075Sobrien 1177169689Skan if (rli->prev_field == NULL && DECL_BIT_FIELD_TYPE (field)) 1178169689Skan rli->prev_field = field; 117996263Sobrien 118090075Sobrien /* Now add size of this field to the size of the record. If the size is 118190075Sobrien not constant, treat the field as being a multiple of bytes and just 118290075Sobrien adjust the offset, resetting the bit position. Otherwise, apportion the 118390075Sobrien size amongst the bit position and offset. First handle the case of an 118490075Sobrien unspecified size, which can happen when we have an invalid nested struct 118590075Sobrien definition, such as struct j { struct j { int i; } }. The error message 118690075Sobrien is printed in finish_struct. */ 118790075Sobrien if (DECL_SIZE (field) == 0) 118890075Sobrien /* Do nothing. */; 1189169689Skan else if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST 1190169689Skan || TREE_CONSTANT_OVERFLOW (DECL_SIZE (field))) 119118334Speter { 119290075Sobrien rli->offset 119390075Sobrien = size_binop (PLUS_EXPR, rli->offset, 1194169689Skan fold_convert (sizetype, 1195169689Skan size_binop (CEIL_DIV_EXPR, rli->bitpos, 1196169689Skan bitsize_unit_node))); 119790075Sobrien rli->offset 119890075Sobrien = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field)); 119990075Sobrien rli->bitpos = bitsize_zero_node; 1200132718Skan rli->offset_align = MIN (rli->offset_align, desired_align); 120118334Speter } 1202169689Skan else if (targetm.ms_bitfield_layout_p (rli->t)) 1203169689Skan { 1204169689Skan rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field)); 1205169689Skan 1206169689Skan /* If we ended a bitfield before the full length of the type then 1207169689Skan pad the struct out to the full length of the last type. */ 1208169689Skan if ((TREE_CHAIN (field) == NULL 1209169689Skan || TREE_CODE (TREE_CHAIN (field)) != FIELD_DECL) 1210169689Skan && DECL_BIT_FIELD_TYPE (field) 1211169689Skan && !integer_zerop (DECL_SIZE (field))) 1212169689Skan rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, 1213169689Skan bitsize_int (rli->remaining_in_alignment)); 1214169689Skan 1215169689Skan normalize_rli (rli); 1216169689Skan } 121718334Speter else 121818334Speter { 121990075Sobrien rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field)); 122090075Sobrien normalize_rli (rli); 122118334Speter } 122290075Sobrien} 122318334Speter 122490075Sobrien/* Assuming that all the fields have been laid out, this function uses 122590075Sobrien RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type 1226132718Skan indicated by RLI. */ 122790075Sobrien 122890075Sobrienstatic void 1229132718Skanfinalize_record_size (record_layout_info rli) 123090075Sobrien{ 123190075Sobrien tree unpadded_size, unpadded_size_unit; 123290075Sobrien 123390075Sobrien /* Now we want just byte and bit offsets, so set the offset alignment 123490075Sobrien to be a byte and then normalize. */ 123590075Sobrien rli->offset_align = BITS_PER_UNIT; 123690075Sobrien normalize_rli (rli); 123790075Sobrien 123818334Speter /* Determine the desired alignment. */ 123918334Speter#ifdef ROUND_TYPE_ALIGN 124090075Sobrien TYPE_ALIGN (rli->t) = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), 124190075Sobrien rli->record_align); 124218334Speter#else 124390075Sobrien TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align); 124418334Speter#endif 124518334Speter 124690075Sobrien /* Compute the size so far. Be sure to allow for extra bits in the 124790075Sobrien size in bytes. We have guaranteed above that it will be no more 124890075Sobrien than a single byte. */ 124990075Sobrien unpadded_size = rli_size_so_far (rli); 125090075Sobrien unpadded_size_unit = rli_size_unit_so_far (rli); 125190075Sobrien if (! integer_zerop (rli->bitpos)) 125290075Sobrien unpadded_size_unit 125390075Sobrien = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node); 125490075Sobrien 1255132718Skan /* Round the size up to be a multiple of the required alignment. */ 125690075Sobrien TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t)); 1257169689Skan TYPE_SIZE_UNIT (rli->t) 1258169689Skan = round_up (unpadded_size_unit, TYPE_ALIGN_UNIT (rli->t)); 125918334Speter 1260169689Skan if (TREE_CONSTANT (unpadded_size) 126190075Sobrien && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0) 1262169689Skan warning (OPT_Wpadded, "padding struct size to alignment boundary"); 1263117395Skan 126490075Sobrien if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE 126590075Sobrien && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary 126690075Sobrien && TREE_CONSTANT (unpadded_size)) 126790075Sobrien { 126890075Sobrien tree unpacked_size; 126990075Sobrien 127090075Sobrien#ifdef ROUND_TYPE_ALIGN 127190075Sobrien rli->unpacked_align 127290075Sobrien = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align); 127390075Sobrien#else 127490075Sobrien rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align); 127590075Sobrien#endif 127690075Sobrien 127790075Sobrien unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align); 127890075Sobrien if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t))) 127990075Sobrien { 128090075Sobrien TYPE_PACKED (rli->t) = 0; 128190075Sobrien 128290075Sobrien if (TYPE_NAME (rli->t)) 128390075Sobrien { 128490075Sobrien const char *name; 128590075Sobrien 128690075Sobrien if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE) 128790075Sobrien name = IDENTIFIER_POINTER (TYPE_NAME (rli->t)); 128890075Sobrien else 128990075Sobrien name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t))); 129090075Sobrien 129190075Sobrien if (STRICT_ALIGNMENT) 1292169689Skan warning (OPT_Wpacked, "packed attribute causes inefficient " 1293169689Skan "alignment for %qs", name); 129490075Sobrien else 1295169689Skan warning (OPT_Wpacked, 1296169689Skan "packed attribute is unnecessary for %qs", name); 129790075Sobrien } 129890075Sobrien else 129990075Sobrien { 130090075Sobrien if (STRICT_ALIGNMENT) 1301169689Skan warning (OPT_Wpacked, 1302169689Skan "packed attribute causes inefficient alignment"); 130390075Sobrien else 1304169689Skan warning (OPT_Wpacked, "packed attribute is unnecessary"); 130590075Sobrien } 130690075Sobrien } 130790075Sobrien } 130818334Speter} 130918334Speter 131090075Sobrien/* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */ 131190075Sobrien 131290075Sobrienvoid 1313132718Skancompute_record_mode (tree type) 131418334Speter{ 131590075Sobrien tree field; 131690075Sobrien enum machine_mode mode = VOIDmode; 131718334Speter 131890075Sobrien /* Most RECORD_TYPEs have BLKmode, so we start off assuming that. 131990075Sobrien However, if possible, we use a mode that fits in a register 132090075Sobrien instead, in order to allow for better optimization down the 132190075Sobrien line. */ 132290075Sobrien TYPE_MODE (type) = BLKmode; 132318334Speter 132490075Sobrien if (! host_integerp (TYPE_SIZE (type), 1)) 132590075Sobrien return; 132650397Sobrien 132790075Sobrien /* A record which has any BLKmode members must itself be 132890075Sobrien BLKmode; it can't go in a register. Unless the member is 132990075Sobrien BLKmode only because it isn't aligned. */ 133090075Sobrien for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 133190075Sobrien { 133290075Sobrien if (TREE_CODE (field) != FIELD_DECL) 133318334Speter continue; 133418334Speter 133590075Sobrien if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK 133690075Sobrien || (TYPE_MODE (TREE_TYPE (field)) == BLKmode 1337132718Skan && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field)) 1338132718Skan && !(TYPE_SIZE (TREE_TYPE (field)) != 0 1339132718Skan && integer_zerop (TYPE_SIZE (TREE_TYPE (field))))) 134090075Sobrien || ! host_integerp (bit_position (field), 1) 134190075Sobrien || DECL_SIZE (field) == 0 134290075Sobrien || ! host_integerp (DECL_SIZE (field), 1)) 134390075Sobrien return; 134418334Speter 134590075Sobrien /* If this field is the whole struct, remember its mode so 134690075Sobrien that, say, we can put a double in a class into a DF 134790075Sobrien register instead of forcing it to live in the stack. */ 134890075Sobrien if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field))) 134990075Sobrien mode = DECL_MODE (field); 135018334Speter 135190075Sobrien#ifdef MEMBER_TYPE_FORCES_BLK 135290075Sobrien /* With some targets, eg. c4x, it is sub-optimal 135390075Sobrien to access an aligned BLKmode structure as a scalar. */ 135418334Speter 1355117395Skan if (MEMBER_TYPE_FORCES_BLK (field, mode)) 135690075Sobrien return; 135790075Sobrien#endif /* MEMBER_TYPE_FORCES_BLK */ 135890075Sobrien } 135918334Speter 1360169689Skan /* If we only have one real field; use its mode if that mode's size 1361169689Skan matches the type's size. This only applies to RECORD_TYPE. This 1362169689Skan does not apply to unions. */ 1363169689Skan if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode 1364169689Skan && host_integerp (TYPE_SIZE (type), 1) 1365169689Skan && GET_MODE_BITSIZE (mode) == TREE_INT_CST_LOW (TYPE_SIZE (type))) 136690075Sobrien TYPE_MODE (type) = mode; 136718334Speter else 136890075Sobrien TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); 136918334Speter 137090075Sobrien /* If structure's known alignment is less than what the scalar 137190075Sobrien mode would need, and it matters, then stick with BLKmode. */ 137290075Sobrien if (TYPE_MODE (type) != BLKmode 137390075Sobrien && STRICT_ALIGNMENT 137490075Sobrien && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT 137590075Sobrien || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type)))) 137690075Sobrien { 137790075Sobrien /* If this is the only reason this type is BLKmode, then 137890075Sobrien don't force containing types to be BLKmode. */ 137990075Sobrien TYPE_NO_FORCE_BLK (type) = 1; 138090075Sobrien TYPE_MODE (type) = BLKmode; 138190075Sobrien } 138290075Sobrien} 138390075Sobrien 138490075Sobrien/* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid 138590075Sobrien out. */ 138690075Sobrien 138790075Sobrienstatic void 1388132718Skanfinalize_type_size (tree type) 138990075Sobrien{ 139090075Sobrien /* Normally, use the alignment corresponding to the mode chosen. 139190075Sobrien However, where strict alignment is not required, avoid 139290075Sobrien over-aligning structures, since most compilers do not do this 139390075Sobrien alignment. */ 139490075Sobrien 139590075Sobrien if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode 139690075Sobrien && (STRICT_ALIGNMENT 139790075Sobrien || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE 139890075Sobrien && TREE_CODE (type) != QUAL_UNION_TYPE 139990075Sobrien && TREE_CODE (type) != ARRAY_TYPE))) 140090075Sobrien { 1401169689Skan unsigned mode_align = GET_MODE_ALIGNMENT (TYPE_MODE (type)); 1402169689Skan 1403169689Skan /* Don't override a larger alignment requirement coming from a user 1404169689Skan alignment of one of the fields. */ 1405169689Skan if (mode_align >= TYPE_ALIGN (type)) 1406169689Skan { 1407169689Skan TYPE_ALIGN (type) = mode_align; 1408169689Skan TYPE_USER_ALIGN (type) = 0; 1409169689Skan } 141090075Sobrien } 141190075Sobrien 141290075Sobrien /* Do machine-dependent extra alignment. */ 141318334Speter#ifdef ROUND_TYPE_ALIGN 141490075Sobrien TYPE_ALIGN (type) 141590075Sobrien = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT); 141618334Speter#endif 141718334Speter 141890075Sobrien /* If we failed to find a simple way to calculate the unit size 141990075Sobrien of the type, find it by division. */ 142090075Sobrien if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0) 142190075Sobrien /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the 142290075Sobrien result will fit in sizetype. We will get more efficient code using 142390075Sobrien sizetype, so we force a conversion. */ 142490075Sobrien TYPE_SIZE_UNIT (type) 1425169689Skan = fold_convert (sizetype, 1426169689Skan size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type), 1427169689Skan bitsize_unit_node)); 142890075Sobrien 142990075Sobrien if (TYPE_SIZE (type) != 0) 143090075Sobrien { 143190075Sobrien TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type)); 1432169689Skan TYPE_SIZE_UNIT (type) = round_up (TYPE_SIZE_UNIT (type), 1433169689Skan TYPE_ALIGN_UNIT (type)); 143490075Sobrien } 143590075Sobrien 143690075Sobrien /* Evaluate nonconstant sizes only once, either now or as soon as safe. */ 143790075Sobrien if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 143890075Sobrien TYPE_SIZE (type) = variable_size (TYPE_SIZE (type)); 143990075Sobrien if (TYPE_SIZE_UNIT (type) != 0 144090075Sobrien && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST) 144190075Sobrien TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type)); 144290075Sobrien 144390075Sobrien /* Also layout any other variants of the type. */ 144490075Sobrien if (TYPE_NEXT_VARIANT (type) 144590075Sobrien || type != TYPE_MAIN_VARIANT (type)) 144690075Sobrien { 144790075Sobrien tree variant; 144890075Sobrien /* Record layout info of this variant. */ 144990075Sobrien tree size = TYPE_SIZE (type); 145090075Sobrien tree size_unit = TYPE_SIZE_UNIT (type); 145190075Sobrien unsigned int align = TYPE_ALIGN (type); 145290075Sobrien unsigned int user_align = TYPE_USER_ALIGN (type); 145390075Sobrien enum machine_mode mode = TYPE_MODE (type); 145490075Sobrien 145590075Sobrien /* Copy it into all variants. */ 145690075Sobrien for (variant = TYPE_MAIN_VARIANT (type); 145790075Sobrien variant != 0; 145890075Sobrien variant = TYPE_NEXT_VARIANT (variant)) 145990075Sobrien { 146090075Sobrien TYPE_SIZE (variant) = size; 146190075Sobrien TYPE_SIZE_UNIT (variant) = size_unit; 146290075Sobrien TYPE_ALIGN (variant) = align; 146390075Sobrien TYPE_USER_ALIGN (variant) = user_align; 146490075Sobrien TYPE_MODE (variant) = mode; 146590075Sobrien } 146690075Sobrien } 146718334Speter} 146890075Sobrien 146990075Sobrien/* Do all of the work required to layout the type indicated by RLI, 147090075Sobrien once the fields have been laid out. This function will call `free' 1471117395Skan for RLI, unless FREE_P is false. Passing a value other than false 1472117395Skan for FREE_P is bad practice; this option only exists to support the 1473117395Skan G++ 3.2 ABI. */ 147490075Sobrien 147590075Sobrienvoid 1476132718Skanfinish_record_layout (record_layout_info rli, int free_p) 147790075Sobrien{ 1478169689Skan tree variant; 1479169689Skan 148090075Sobrien /* Compute the final size. */ 148190075Sobrien finalize_record_size (rli); 148290075Sobrien 148390075Sobrien /* Compute the TYPE_MODE for the record. */ 148490075Sobrien compute_record_mode (rli->t); 148590075Sobrien 148690075Sobrien /* Perform any last tweaks to the TYPE_SIZE, etc. */ 148790075Sobrien finalize_type_size (rli->t); 148890075Sobrien 1489169689Skan /* Propagate TYPE_PACKED to variants. With C++ templates, 1490169689Skan handle_packed_attribute is too early to do this. */ 1491169689Skan for (variant = TYPE_NEXT_VARIANT (rli->t); variant; 1492169689Skan variant = TYPE_NEXT_VARIANT (variant)) 1493169689Skan TYPE_PACKED (variant) = TYPE_PACKED (rli->t); 1494169689Skan 149590075Sobrien /* Lay out any static members. This is done now because their type 149690075Sobrien may use the record's type. */ 149790075Sobrien while (rli->pending_statics) 149890075Sobrien { 149990075Sobrien layout_decl (TREE_VALUE (rli->pending_statics), 0); 150090075Sobrien rli->pending_statics = TREE_CHAIN (rli->pending_statics); 150190075Sobrien } 150290075Sobrien 150390075Sobrien /* Clean up. */ 1504117395Skan if (free_p) 1505117395Skan free (rli); 150690075Sobrien} 150718334Speter 1508132718Skan 1509132718Skan/* Finish processing a builtin RECORD_TYPE type TYPE. It's name is 1510132718Skan NAME, its fields are chained in reverse on FIELDS. 1511132718Skan 1512132718Skan If ALIGN_TYPE is non-null, it is given the same alignment as 1513132718Skan ALIGN_TYPE. */ 1514132718Skan 1515132718Skanvoid 1516132718Skanfinish_builtin_struct (tree type, const char *name, tree fields, 1517132718Skan tree align_type) 1518132718Skan{ 1519132718Skan tree tail, next; 1520132718Skan 1521132718Skan for (tail = NULL_TREE; fields; tail = fields, fields = next) 1522132718Skan { 1523132718Skan DECL_FIELD_CONTEXT (fields) = type; 1524132718Skan next = TREE_CHAIN (fields); 1525132718Skan TREE_CHAIN (fields) = tail; 1526132718Skan } 1527132718Skan TYPE_FIELDS (type) = tail; 1528132718Skan 1529132718Skan if (align_type) 1530132718Skan { 1531132718Skan TYPE_ALIGN (type) = TYPE_ALIGN (align_type); 1532132718Skan TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (align_type); 1533132718Skan } 1534132718Skan 1535132718Skan layout_type (type); 1536132718Skan#if 0 /* not yet, should get fixed properly later */ 1537132718Skan TYPE_NAME (type) = make_type_decl (get_identifier (name), type); 1538132718Skan#else 1539132718Skan TYPE_NAME (type) = build_decl (TYPE_DECL, get_identifier (name), type); 1540132718Skan#endif 1541132718Skan TYPE_STUB_DECL (type) = TYPE_NAME (type); 1542132718Skan layout_decl (TYPE_NAME (type), 0); 1543132718Skan} 1544132718Skan 154518334Speter/* Calculate the mode, size, and alignment for TYPE. 154618334Speter For an array type, calculate the element separation as well. 154718334Speter Record TYPE on the chain of permanent or temporary types 154818334Speter so that dbxout will find out about it. 154918334Speter 155018334Speter TYPE_SIZE of a type is nonzero if the type has been laid out already. 155118334Speter layout_type does nothing on such a type. 155218334Speter 155318334Speter If the type is incomplete, its TYPE_SIZE remains zero. */ 155418334Speter 155518334Spetervoid 1556132718Skanlayout_type (tree type) 155718334Speter{ 1558169689Skan gcc_assert (type); 155918334Speter 1560169689Skan if (type == error_mark_node) 1561169689Skan return; 1562169689Skan 156318334Speter /* Do nothing if type has been laid out before. */ 156418334Speter if (TYPE_SIZE (type)) 156518334Speter return; 156618334Speter 156718334Speter switch (TREE_CODE (type)) 156818334Speter { 156918334Speter case LANG_TYPE: 157018334Speter /* This kind of type is the responsibility 157118334Speter of the language-specific code. */ 1572169689Skan gcc_unreachable (); 157318334Speter 157490075Sobrien case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */ 157550397Sobrien if (TYPE_PRECISION (type) == 0) 157690075Sobrien TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */ 157750397Sobrien 157890075Sobrien /* ... fall through ... */ 157990075Sobrien 158018334Speter case INTEGER_TYPE: 158118334Speter case ENUMERAL_TYPE: 158218334Speter if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST 158318334Speter && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0) 1584169689Skan TYPE_UNSIGNED (type) = 1; 158518334Speter 158618334Speter TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type), 158718334Speter MODE_INT); 158890075Sobrien TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 158950397Sobrien TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 159018334Speter break; 159118334Speter 159218334Speter case REAL_TYPE: 159318334Speter TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0); 159490075Sobrien TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 159550397Sobrien TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 159618334Speter break; 159718334Speter 159818334Speter case COMPLEX_TYPE: 1599169689Skan TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type)); 160018334Speter TYPE_MODE (type) 160118334Speter = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)), 1602169689Skan (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE 1603169689Skan ? MODE_COMPLEX_FLOAT : MODE_COMPLEX_INT), 160418334Speter 0); 160590075Sobrien TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 160650397Sobrien TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 160718334Speter break; 160818334Speter 160990075Sobrien case VECTOR_TYPE: 161090075Sobrien { 1611169689Skan int nunits = TYPE_VECTOR_SUBPARTS (type); 1612169689Skan tree nunits_tree = build_int_cst (NULL_TREE, nunits); 1613169689Skan tree innertype = TREE_TYPE (type); 161490075Sobrien 1615169689Skan gcc_assert (!(nunits & (nunits - 1))); 1616169689Skan 1617169689Skan /* Find an appropriate mode for the vector type. */ 1618169689Skan if (TYPE_MODE (type) == VOIDmode) 1619169689Skan { 1620169689Skan enum machine_mode innermode = TYPE_MODE (innertype); 1621169689Skan enum machine_mode mode; 1622169689Skan 1623169689Skan /* First, look for a supported vector type. */ 1624169689Skan if (SCALAR_FLOAT_MODE_P (innermode)) 1625169689Skan mode = MIN_MODE_VECTOR_FLOAT; 1626169689Skan else 1627169689Skan mode = MIN_MODE_VECTOR_INT; 1628169689Skan 1629169689Skan for (; mode != VOIDmode ; mode = GET_MODE_WIDER_MODE (mode)) 1630169689Skan if (GET_MODE_NUNITS (mode) == nunits 1631169689Skan && GET_MODE_INNER (mode) == innermode 1632169689Skan && targetm.vector_mode_supported_p (mode)) 1633169689Skan break; 1634169689Skan 1635169689Skan /* For integers, try mapping it to a same-sized scalar mode. */ 1636169689Skan if (mode == VOIDmode 1637169689Skan && GET_MODE_CLASS (innermode) == MODE_INT) 1638169689Skan mode = mode_for_size (nunits * GET_MODE_BITSIZE (innermode), 1639169689Skan MODE_INT, 0); 1640169689Skan 1641169689Skan if (mode == VOIDmode || !have_regs_of_mode[mode]) 1642169689Skan TYPE_MODE (type) = BLKmode; 1643169689Skan else 1644169689Skan TYPE_MODE (type) = mode; 1645169689Skan } 1646169689Skan 1647169689Skan TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type)); 1648169689Skan TYPE_SIZE_UNIT (type) = int_const_binop (MULT_EXPR, 1649169689Skan TYPE_SIZE_UNIT (innertype), 1650169689Skan nunits_tree, 0); 1651169689Skan TYPE_SIZE (type) = int_const_binop (MULT_EXPR, TYPE_SIZE (innertype), 1652169689Skan nunits_tree, 0); 1653169689Skan 1654169689Skan /* Always naturally align vectors. This prevents ABI changes 1655169689Skan depending on whether or not native vector modes are supported. */ 1656169689Skan TYPE_ALIGN (type) = tree_low_cst (TYPE_SIZE (type), 0); 1657169689Skan break; 165890075Sobrien } 165990075Sobrien 166018334Speter case VOID_TYPE: 166190075Sobrien /* This is an incomplete type and so doesn't have a size. */ 166218334Speter TYPE_ALIGN (type) = 1; 166390075Sobrien TYPE_USER_ALIGN (type) = 0; 166418334Speter TYPE_MODE (type) = VOIDmode; 166518334Speter break; 166618334Speter 166718334Speter case OFFSET_TYPE: 166890075Sobrien TYPE_SIZE (type) = bitsize_int (POINTER_SIZE); 166950397Sobrien TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT); 167090075Sobrien /* A pointer might be MODE_PARTIAL_INT, 167190075Sobrien but ptrdiff_t must be integral. */ 167290075Sobrien TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0); 167318334Speter break; 167418334Speter 167518334Speter case FUNCTION_TYPE: 167618334Speter case METHOD_TYPE: 1677169689Skan /* It's hard to see what the mode and size of a function ought to 1678169689Skan be, but we do know the alignment is FUNCTION_BOUNDARY, so 1679169689Skan make it consistent with that. */ 1680169689Skan TYPE_MODE (type) = mode_for_size (FUNCTION_BOUNDARY, MODE_INT, 0); 1681169689Skan TYPE_SIZE (type) = bitsize_int (FUNCTION_BOUNDARY); 1682169689Skan TYPE_SIZE_UNIT (type) = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT); 168318334Speter break; 168418334Speter 168518334Speter case POINTER_TYPE: 168618334Speter case REFERENCE_TYPE: 168790075Sobrien { 168890075Sobrien 1689132718Skan enum machine_mode mode = ((TREE_CODE (type) == REFERENCE_TYPE 1690132718Skan && reference_types_internal) 1691132718Skan ? Pmode : TYPE_MODE (type)); 1692132718Skan 1693132718Skan int nbits = GET_MODE_BITSIZE (mode); 1694132718Skan 169590075Sobrien TYPE_SIZE (type) = bitsize_int (nbits); 1696132718Skan TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (mode)); 1697169689Skan TYPE_UNSIGNED (type) = 1; 169890075Sobrien TYPE_PRECISION (type) = nbits; 169990075Sobrien } 170018334Speter break; 170118334Speter 170218334Speter case ARRAY_TYPE: 170318334Speter { 170490075Sobrien tree index = TYPE_DOMAIN (type); 170590075Sobrien tree element = TREE_TYPE (type); 170618334Speter 170718334Speter build_pointer_type (element); 170818334Speter 170918334Speter /* We need to know both bounds in order to compute the size. */ 171018334Speter if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index) 171118334Speter && TYPE_SIZE (element)) 171218334Speter { 171318334Speter tree ub = TYPE_MAX_VALUE (index); 171418334Speter tree lb = TYPE_MIN_VALUE (index); 171518334Speter tree length; 171652284Sobrien tree element_size; 171718334Speter 171850397Sobrien /* The initial subtraction should happen in the original type so 171950397Sobrien that (possible) negative values are handled appropriately. */ 172018334Speter length = size_binop (PLUS_EXPR, size_one_node, 1721169689Skan fold_convert (sizetype, 1722169689Skan fold_build2 (MINUS_EXPR, 1723169689Skan TREE_TYPE (lb), 1724169689Skan ub, lb))); 172518334Speter 172652284Sobrien /* Special handling for arrays of bits (for Chill). */ 172752284Sobrien element_size = TYPE_SIZE (element); 172890075Sobrien if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element) 172990075Sobrien && (integer_zerop (TYPE_MAX_VALUE (element)) 173090075Sobrien || integer_onep (TYPE_MAX_VALUE (element))) 173190075Sobrien && host_integerp (TYPE_MIN_VALUE (element), 1)) 173252284Sobrien { 173390075Sobrien HOST_WIDE_INT maxvalue 173490075Sobrien = tree_low_cst (TYPE_MAX_VALUE (element), 1); 173590075Sobrien HOST_WIDE_INT minvalue 173690075Sobrien = tree_low_cst (TYPE_MIN_VALUE (element), 1); 173790075Sobrien 173852284Sobrien if (maxvalue - minvalue == 1 173952284Sobrien && (maxvalue == 1 || maxvalue == 0)) 174052284Sobrien element_size = integer_one_node; 174152284Sobrien } 174250397Sobrien 1743132718Skan /* If neither bound is a constant and sizetype is signed, make 1744132718Skan sure the size is never negative. We should really do this 1745132718Skan if *either* bound is non-constant, but this is the best 1746132718Skan compromise between C and Ada. */ 1747169689Skan if (!TYPE_UNSIGNED (sizetype) 1748132718Skan && TREE_CODE (TYPE_MIN_VALUE (index)) != INTEGER_CST 1749132718Skan && TREE_CODE (TYPE_MAX_VALUE (index)) != INTEGER_CST) 1750132718Skan length = size_binop (MAX_EXPR, length, size_zero_node); 1751132718Skan 175290075Sobrien TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size, 1753169689Skan fold_convert (bitsizetype, 1754169689Skan length)); 175552284Sobrien 175650397Sobrien /* If we know the size of the element, calculate the total 175750397Sobrien size directly, rather than do some division thing below. 175850397Sobrien This optimization helps Fortran assumed-size arrays 175950397Sobrien (where the size of the array is determined at runtime) 176052284Sobrien substantially. 176152284Sobrien Note that we can't do this in the case where the size of 176252284Sobrien the elements is one bit since TYPE_SIZE_UNIT cannot be 176352284Sobrien set correctly in that case. */ 176490075Sobrien if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size)) 176590075Sobrien TYPE_SIZE_UNIT (type) 176690075Sobrien = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length); 176718334Speter } 176818334Speter 176918334Speter /* Now round the alignment and size, 177018334Speter using machine-dependent criteria if any. */ 177118334Speter 177218334Speter#ifdef ROUND_TYPE_ALIGN 177318334Speter TYPE_ALIGN (type) 177418334Speter = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT); 177518334Speter#else 177618334Speter TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT); 177718334Speter#endif 177890075Sobrien TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element); 177918334Speter TYPE_MODE (type) = BLKmode; 178018334Speter if (TYPE_SIZE (type) != 0 178190075Sobrien#ifdef MEMBER_TYPE_FORCES_BLK 1782117395Skan && ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode) 178390075Sobrien#endif 178418334Speter /* BLKmode elements force BLKmode aggregate; 178518334Speter else extract/store fields may lose. */ 178618334Speter && (TYPE_MODE (TREE_TYPE (type)) != BLKmode 178718334Speter || TYPE_NO_FORCE_BLK (TREE_TYPE (type)))) 178818334Speter { 178996263Sobrien /* One-element arrays get the component type's mode. */ 179096263Sobrien if (simple_cst_equal (TYPE_SIZE (type), 179196263Sobrien TYPE_SIZE (TREE_TYPE (type)))) 179296263Sobrien TYPE_MODE (type) = TYPE_MODE (TREE_TYPE (type)); 179396263Sobrien else 179496263Sobrien TYPE_MODE (type) 179596263Sobrien = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); 179618334Speter 179790075Sobrien if (TYPE_MODE (type) != BLKmode 179890075Sobrien && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT 179990075Sobrien && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)) 180018334Speter && TYPE_MODE (type) != BLKmode) 180118334Speter { 180218334Speter TYPE_NO_FORCE_BLK (type) = 1; 180318334Speter TYPE_MODE (type) = BLKmode; 180418334Speter } 180518334Speter } 1806169689Skan /* When the element size is constant, check that it is at least as 1807169689Skan large as the element alignment. */ 1808169689Skan if (TYPE_SIZE_UNIT (element) 1809169689Skan && TREE_CODE (TYPE_SIZE_UNIT (element)) == INTEGER_CST 1810169689Skan /* If TYPE_SIZE_UNIT overflowed, then it is certainly larger than 1811169689Skan TYPE_ALIGN_UNIT. */ 1812169689Skan && !TREE_CONSTANT_OVERFLOW (TYPE_SIZE_UNIT (element)) 1813169689Skan && !integer_zerop (TYPE_SIZE_UNIT (element)) 1814169689Skan && compare_tree_int (TYPE_SIZE_UNIT (element), 1815169689Skan TYPE_ALIGN_UNIT (element)) < 0) 1816169689Skan error ("alignment of array elements is greater than element size"); 181718334Speter break; 181818334Speter } 181918334Speter 182018334Speter case RECORD_TYPE: 182190075Sobrien case UNION_TYPE: 182290075Sobrien case QUAL_UNION_TYPE: 182390075Sobrien { 182490075Sobrien tree field; 182590075Sobrien record_layout_info rli; 182650397Sobrien 182790075Sobrien /* Initialize the layout information. */ 182890075Sobrien rli = start_record_layout (type); 182918334Speter 183090075Sobrien /* If this is a QUAL_UNION_TYPE, we want to process the fields 183190075Sobrien in the reverse order in building the COND_EXPR that denotes 183290075Sobrien its size. We reverse them again later. */ 183390075Sobrien if (TREE_CODE (type) == QUAL_UNION_TYPE) 183490075Sobrien TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type)); 183518334Speter 183690075Sobrien /* Place all the fields. */ 183790075Sobrien for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 183890075Sobrien place_field (rli, field); 183918334Speter 184090075Sobrien if (TREE_CODE (type) == QUAL_UNION_TYPE) 184190075Sobrien TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type)); 184218334Speter 184390075Sobrien if (lang_adjust_rli) 184490075Sobrien (*lang_adjust_rli) (rli); 184518334Speter 184690075Sobrien /* Finish laying out the record. */ 1847117395Skan finish_record_layout (rli, /*free_p=*/true); 184890075Sobrien } 184918334Speter break; 185018334Speter 185118334Speter default: 1852169689Skan gcc_unreachable (); 185350397Sobrien } 185450397Sobrien 185590075Sobrien /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For 185690075Sobrien records and unions, finish_record_layout already called this 185790075Sobrien function. */ 1858117395Skan if (TREE_CODE (type) != RECORD_TYPE 185990075Sobrien && TREE_CODE (type) != UNION_TYPE 186090075Sobrien && TREE_CODE (type) != QUAL_UNION_TYPE) 186190075Sobrien finalize_type_size (type); 186250397Sobrien 186390075Sobrien /* If an alias set has been set for this aggregate when it was incomplete, 186490075Sobrien force it into alias set 0. 186590075Sobrien This is too conservative, but we cannot call record_component_aliases 186690075Sobrien here because some frontends still change the aggregates after 186790075Sobrien layout_type. */ 186890075Sobrien if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type)) 186990075Sobrien TYPE_ALIAS_SET (type) = 0; 187018334Speter} 187118334Speter 187218334Speter/* Create and return a type for signed integers of PRECISION bits. */ 187318334Speter 187418334Spetertree 1875132718Skanmake_signed_type (int precision) 187618334Speter{ 187790075Sobrien tree type = make_node (INTEGER_TYPE); 187818334Speter 187918334Speter TYPE_PRECISION (type) = precision; 188018334Speter 188190075Sobrien fixup_signed_type (type); 188218334Speter return type; 188318334Speter} 188418334Speter 188518334Speter/* Create and return a type for unsigned integers of PRECISION bits. */ 188618334Speter 188718334Spetertree 1888132718Skanmake_unsigned_type (int precision) 188918334Speter{ 189090075Sobrien tree type = make_node (INTEGER_TYPE); 189118334Speter 189218334Speter TYPE_PRECISION (type) = precision; 189318334Speter 189418334Speter fixup_unsigned_type (type); 189518334Speter return type; 189618334Speter} 189790075Sobrien 189890075Sobrien/* Initialize sizetype and bitsizetype to a reasonable and temporary 189990075Sobrien value to enable integer types to be created. */ 190018334Speter 190190075Sobrienvoid 1902169689Skaninitialize_sizetypes (bool signed_p) 190390075Sobrien{ 190490075Sobrien tree t = make_node (INTEGER_TYPE); 1905169689Skan int precision = GET_MODE_BITSIZE (SImode); 190690075Sobrien 190790075Sobrien TYPE_MODE (t) = SImode; 190890075Sobrien TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode); 190990075Sobrien TYPE_USER_ALIGN (t) = 0; 191090075Sobrien TYPE_IS_SIZETYPE (t) = 1; 1911169689Skan TYPE_UNSIGNED (t) = !signed_p; 1912169689Skan TYPE_SIZE (t) = build_int_cst (t, precision); 1913169689Skan TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode)); 1914169689Skan TYPE_PRECISION (t) = precision; 191590075Sobrien 1916169689Skan /* Set TYPE_MIN_VALUE and TYPE_MAX_VALUE. */ 1917169689Skan set_min_and_max_values_for_integral_type (t, precision, !signed_p); 191890075Sobrien 191990075Sobrien sizetype = t; 1920169689Skan bitsizetype = build_distinct_type_copy (t); 192190075Sobrien} 192290075Sobrien 1923169689Skan/* Make sizetype a version of TYPE, and initialize *sizetype 1924169689Skan accordingly. We do this by overwriting the stub sizetype and 1925169689Skan bitsizetype nodes created by initialize_sizetypes. This makes sure 1926169689Skan that (a) anything stubby about them no longer exists, (b) any 1927169689Skan INTEGER_CSTs created with such a type, remain valid. */ 192850397Sobrien 192950397Sobrienvoid 1930132718Skanset_sizetype (tree type) 193150397Sobrien{ 193290075Sobrien int oprecision = TYPE_PRECISION (type); 193350397Sobrien /* The *bitsizetype types use a precision that avoids overflows when 193490075Sobrien calculating signed sizes / offsets in bits. However, when 193590075Sobrien cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit 193690075Sobrien precision. */ 1937169689Skan int precision = MIN (MIN (oprecision + BITS_PER_UNIT_LOG + 1, 1938169689Skan MAX_FIXED_MODE_SIZE), 193990075Sobrien 2 * HOST_BITS_PER_WIDE_INT); 194090075Sobrien tree t; 194150397Sobrien 1942169689Skan gcc_assert (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype)); 194350397Sobrien 1944169689Skan t = build_distinct_type_copy (type); 1945169689Skan /* We do want to use sizetype's cache, as we will be replacing that 1946169689Skan type. */ 1947169689Skan TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (sizetype); 1948169689Skan TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (sizetype); 1949169689Skan TREE_TYPE (TYPE_CACHED_VALUES (t)) = type; 1950169689Skan TYPE_UID (t) = TYPE_UID (sizetype); 1951169689Skan TYPE_IS_SIZETYPE (t) = 1; 195290075Sobrien 1953169689Skan /* Replace our original stub sizetype. */ 1954169689Skan memcpy (sizetype, t, tree_size (sizetype)); 1955169689Skan TYPE_MAIN_VARIANT (sizetype) = sizetype; 195690075Sobrien 1957169689Skan t = make_node (INTEGER_TYPE); 1958169689Skan TYPE_NAME (t) = get_identifier ("bit_size_type"); 1959169689Skan /* We do want to use bitsizetype's cache, as we will be replacing that 1960169689Skan type. */ 1961169689Skan TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (bitsizetype); 1962169689Skan TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (bitsizetype); 1963169689Skan TYPE_PRECISION (t) = precision; 1964169689Skan TYPE_UID (t) = TYPE_UID (bitsizetype); 1965169689Skan TYPE_IS_SIZETYPE (t) = 1; 196650397Sobrien 1967169689Skan /* Replace our original stub bitsizetype. */ 1968169689Skan memcpy (bitsizetype, t, tree_size (bitsizetype)); 1969169689Skan TYPE_MAIN_VARIANT (bitsizetype) = bitsizetype; 1970169689Skan 1971169689Skan if (TYPE_UNSIGNED (type)) 197250397Sobrien { 1973169689Skan fixup_unsigned_type (bitsizetype); 1974169689Skan ssizetype = build_distinct_type_copy (make_signed_type (oprecision)); 1975169689Skan TYPE_IS_SIZETYPE (ssizetype) = 1; 1976169689Skan sbitsizetype = build_distinct_type_copy (make_signed_type (precision)); 1977169689Skan TYPE_IS_SIZETYPE (sbitsizetype) = 1; 197850397Sobrien } 197950397Sobrien else 198050397Sobrien { 1981169689Skan fixup_signed_type (bitsizetype); 198250397Sobrien ssizetype = sizetype; 198350397Sobrien sbitsizetype = bitsizetype; 198450397Sobrien } 198590075Sobrien 1986169689Skan /* If SIZETYPE is unsigned, we need to fix TYPE_MAX_VALUE so that 1987169689Skan it is sign extended in a way consistent with force_fit_type. */ 1988169689Skan if (TYPE_UNSIGNED (type)) 198990075Sobrien { 1990169689Skan tree orig_max, new_max; 199190075Sobrien 1992169689Skan orig_max = TYPE_MAX_VALUE (sizetype); 199390075Sobrien 1994169689Skan /* Build a new node with the same values, but a different type. */ 1995169689Skan new_max = build_int_cst_wide (sizetype, 1996169689Skan TREE_INT_CST_LOW (orig_max), 1997169689Skan TREE_INT_CST_HIGH (orig_max)); 1998169689Skan 1999169689Skan /* Now sign extend it using force_fit_type to ensure 2000169689Skan consistency. */ 2001169689Skan new_max = force_fit_type (new_max, 0, 0, 0); 2002169689Skan TYPE_MAX_VALUE (sizetype) = new_max; 200390075Sobrien } 200450397Sobrien} 200590075Sobrien 2006169689Skan/* TYPE is an integral type, i.e., an INTEGRAL_TYPE, ENUMERAL_TYPE 2007169689Skan or BOOLEAN_TYPE. Set TYPE_MIN_VALUE and TYPE_MAX_VALUE 2008132718Skan for TYPE, based on the PRECISION and whether or not the TYPE 2009132718Skan IS_UNSIGNED. PRECISION need not correspond to a width supported 2010132718Skan natively by the hardware; for example, on a machine with 8-bit, 2011132718Skan 16-bit, and 32-bit register modes, PRECISION might be 7, 23, or 2012132718Skan 61. */ 2013132718Skan 2014132718Skanvoid 2015132718Skanset_min_and_max_values_for_integral_type (tree type, 2016132718Skan int precision, 2017132718Skan bool is_unsigned) 2018132718Skan{ 2019132718Skan tree min_value; 2020132718Skan tree max_value; 2021132718Skan 2022132718Skan if (is_unsigned) 2023132718Skan { 2024169689Skan min_value = build_int_cst (type, 0); 2025169689Skan max_value 2026169689Skan = build_int_cst_wide (type, precision - HOST_BITS_PER_WIDE_INT >= 0 2027169689Skan ? -1 2028169689Skan : ((HOST_WIDE_INT) 1 << precision) - 1, 2029169689Skan precision - HOST_BITS_PER_WIDE_INT > 0 2030169689Skan ? ((unsigned HOST_WIDE_INT) ~0 2031169689Skan >> (HOST_BITS_PER_WIDE_INT 2032169689Skan - (precision - HOST_BITS_PER_WIDE_INT))) 2033169689Skan : 0); 2034132718Skan } 2035132718Skan else 2036132718Skan { 2037169689Skan min_value 2038169689Skan = build_int_cst_wide (type, 2039169689Skan (precision - HOST_BITS_PER_WIDE_INT > 0 2040169689Skan ? 0 2041169689Skan : (HOST_WIDE_INT) (-1) << (precision - 1)), 2042169689Skan (((HOST_WIDE_INT) (-1) 2043169689Skan << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 2044169689Skan ? precision - HOST_BITS_PER_WIDE_INT - 1 2045169689Skan : 0)))); 2046132718Skan max_value 2047169689Skan = build_int_cst_wide (type, 2048169689Skan (precision - HOST_BITS_PER_WIDE_INT > 0 2049169689Skan ? -1 2050169689Skan : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1), 2051169689Skan (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 2052169689Skan ? (((HOST_WIDE_INT) 1 2053169689Skan << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1 2054169689Skan : 0)); 2055132718Skan } 2056132718Skan 2057132718Skan TYPE_MIN_VALUE (type) = min_value; 2058132718Skan TYPE_MAX_VALUE (type) = max_value; 2059132718Skan} 2060132718Skan 206118334Speter/* Set the extreme values of TYPE based on its precision in bits, 206218334Speter then lay it out. Used when make_signed_type won't do 206318334Speter because the tree code is not INTEGER_TYPE. 206418334Speter E.g. for Pascal, when the -fsigned-char option is given. */ 206518334Speter 206618334Spetervoid 2067132718Skanfixup_signed_type (tree type) 206818334Speter{ 206990075Sobrien int precision = TYPE_PRECISION (type); 207018334Speter 207190075Sobrien /* We can not represent properly constants greater then 207290075Sobrien 2 * HOST_BITS_PER_WIDE_INT, still we need the types 207390075Sobrien as they are used by i386 vector extensions and friends. */ 207490075Sobrien if (precision > HOST_BITS_PER_WIDE_INT * 2) 207590075Sobrien precision = HOST_BITS_PER_WIDE_INT * 2; 207690075Sobrien 2077169689Skan set_min_and_max_values_for_integral_type (type, precision, 2078132718Skan /*is_unsigned=*/false); 207918334Speter 208018334Speter /* Lay out the type: set its alignment, size, etc. */ 208118334Speter layout_type (type); 208218334Speter} 208318334Speter 208418334Speter/* Set the extreme values of TYPE based on its precision in bits, 208518334Speter then lay it out. This is used both in `make_unsigned_type' 208618334Speter and for enumeral types. */ 208718334Speter 208818334Spetervoid 2089132718Skanfixup_unsigned_type (tree type) 209018334Speter{ 209190075Sobrien int precision = TYPE_PRECISION (type); 209218334Speter 209390075Sobrien /* We can not represent properly constants greater then 209490075Sobrien 2 * HOST_BITS_PER_WIDE_INT, still we need the types 209590075Sobrien as they are used by i386 vector extensions and friends. */ 209690075Sobrien if (precision > HOST_BITS_PER_WIDE_INT * 2) 209790075Sobrien precision = HOST_BITS_PER_WIDE_INT * 2; 209890075Sobrien 2099169689Skan TYPE_UNSIGNED (type) = 1; 2100169689Skan 2101169689Skan set_min_and_max_values_for_integral_type (type, precision, 2102132718Skan /*is_unsigned=*/true); 210318334Speter 210418334Speter /* Lay out the type: set its alignment, size, etc. */ 210518334Speter layout_type (type); 210618334Speter} 210718334Speter 210818334Speter/* Find the best machine mode to use when referencing a bit field of length 210918334Speter BITSIZE bits starting at BITPOS. 211018334Speter 211118334Speter The underlying object is known to be aligned to a boundary of ALIGN bits. 211218334Speter If LARGEST_MODE is not VOIDmode, it means that we should not use a mode 211318334Speter larger than LARGEST_MODE (usually SImode). 211418334Speter 2115169689Skan If no mode meets all these conditions, we return VOIDmode. 211618334Speter 2117169689Skan If VOLATILEP is false and SLOW_BYTE_ACCESS is false, we return the 2118169689Skan smallest mode meeting these conditions. 211918334Speter 2120169689Skan If VOLATILEP is false and SLOW_BYTE_ACCESS is true, we return the 2121169689Skan largest mode (but a mode no wider than UNITS_PER_WORD) that meets 2122169689Skan all the conditions. 2123169689Skan 2124169689Skan If VOLATILEP is true the narrow_volatile_bitfields target hook is used to 2125169689Skan decide which of the above modes should be used. */ 2126169689Skan 212718334Speterenum machine_mode 2128132718Skanget_best_mode (int bitsize, int bitpos, unsigned int align, 2129132718Skan enum machine_mode largest_mode, int volatilep) 213018334Speter{ 213118334Speter enum machine_mode mode; 213290075Sobrien unsigned int unit = 0; 213318334Speter 213418334Speter /* Find the narrowest integer mode that contains the bit field. */ 213518334Speter for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode; 213618334Speter mode = GET_MODE_WIDER_MODE (mode)) 213718334Speter { 213818334Speter unit = GET_MODE_BITSIZE (mode); 213950397Sobrien if ((bitpos % unit) + bitsize <= unit) 214018334Speter break; 214118334Speter } 214218334Speter 214390075Sobrien if (mode == VOIDmode 214418334Speter /* It is tempting to omit the following line 214518334Speter if STRICT_ALIGNMENT is true. 214618334Speter But that is incorrect, since if the bitfield uses part of 3 bytes 214718334Speter and we use a 4-byte mode, we could get a spurious segv 214818334Speter if the extra 4th byte is past the end of memory. 214918334Speter (Though at least one Unix compiler ignores this problem: 215018334Speter that on the Sequent 386 machine. */ 215118334Speter || MIN (unit, BIGGEST_ALIGNMENT) > align 215218334Speter || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode))) 215318334Speter return VOIDmode; 215418334Speter 2155169689Skan if ((SLOW_BYTE_ACCESS && ! volatilep) 2156169689Skan || (volatilep && !targetm.narrow_volatile_bitfield())) 215718334Speter { 215818334Speter enum machine_mode wide_mode = VOIDmode, tmode; 215918334Speter 216018334Speter for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode; 216118334Speter tmode = GET_MODE_WIDER_MODE (tmode)) 216218334Speter { 216318334Speter unit = GET_MODE_BITSIZE (tmode); 216418334Speter if (bitpos / unit == (bitpos + bitsize - 1) / unit 216518334Speter && unit <= BITS_PER_WORD 216618334Speter && unit <= MIN (align, BIGGEST_ALIGNMENT) 216718334Speter && (largest_mode == VOIDmode 216818334Speter || unit <= GET_MODE_BITSIZE (largest_mode))) 216918334Speter wide_mode = tmode; 217018334Speter } 217118334Speter 217218334Speter if (wide_mode != VOIDmode) 217318334Speter return wide_mode; 217418334Speter } 217518334Speter 217618334Speter return mode; 217718334Speter} 217818334Speter 2179169689Skan/* Gets minimal and maximal values for MODE (signed or unsigned depending on 2180169689Skan SIGN). The returned constants are made to be usable in TARGET_MODE. */ 2181169689Skan 2182169689Skanvoid 2183169689Skanget_mode_bounds (enum machine_mode mode, int sign, 2184169689Skan enum machine_mode target_mode, 2185169689Skan rtx *mmin, rtx *mmax) 2186169689Skan{ 2187169689Skan unsigned size = GET_MODE_BITSIZE (mode); 2188169689Skan unsigned HOST_WIDE_INT min_val, max_val; 2189169689Skan 2190169689Skan gcc_assert (size <= HOST_BITS_PER_WIDE_INT); 2191169689Skan 2192169689Skan if (sign) 2193169689Skan { 2194169689Skan min_val = -((unsigned HOST_WIDE_INT) 1 << (size - 1)); 2195169689Skan max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1)) - 1; 2196169689Skan } 2197169689Skan else 2198169689Skan { 2199169689Skan min_val = 0; 2200169689Skan max_val = ((unsigned HOST_WIDE_INT) 1 << (size - 1) << 1) - 1; 2201169689Skan } 2202169689Skan 2203169689Skan *mmin = gen_int_mode (min_val, target_mode); 2204169689Skan *mmax = gen_int_mode (max_val, target_mode); 2205169689Skan} 2206169689Skan 2207117395Skan#include "gt-stor-layout.h" 2208