stor-layout.c revision 90075
118334Speter/* C-compiler utilities for types and variables storage layout 290075Sobrien Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1996, 1998, 390075Sobrien 1999, 2000, 2001, 2002 Free Software Foundation, Inc. 418334Speter 590075SobrienThis file is part of GCC. 618334Speter 790075SobrienGCC is free software; you can redistribute it and/or modify it under 890075Sobrienthe terms of the GNU General Public License as published by the Free 990075SobrienSoftware Foundation; either version 2, or (at your option) any later 1090075Sobrienversion. 1118334Speter 1290075SobrienGCC is distributed in the hope that it will be useful, but WITHOUT ANY 1390075SobrienWARRANTY; without even the implied warranty of MERCHANTABILITY or 1490075SobrienFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1590075Sobrienfor more details. 1618334Speter 1718334SpeterYou should have received a copy of the GNU General Public License 1890075Sobrienalong with GCC; see the file COPYING. If not, write to the Free 1990075SobrienSoftware Foundation, 59 Temple Place - Suite 330, Boston, MA 2090075Sobrien02111-1307, USA. */ 2118334Speter 2218334Speter 2318334Speter#include "config.h" 2450397Sobrien#include "system.h" 2518334Speter#include "tree.h" 2650397Sobrien#include "rtl.h" 2790075Sobrien#include "tm_p.h" 2818334Speter#include "flags.h" 2918334Speter#include "function.h" 3050397Sobrien#include "expr.h" 3150397Sobrien#include "toplev.h" 3290075Sobrien#include "ggc.h" 3318334Speter 3490075Sobrien/* Set to one when set_sizetype has been called. */ 3590075Sobrienstatic int sizetype_set; 3618334Speter 3790075Sobrien/* List of types created before set_sizetype has been called. We do not 3890075Sobrien make this a GGC root since we want these nodes to be reclaimed. */ 3990075Sobrienstatic tree early_type_list; 4090075Sobrien 4118334Speter/* Data type for the expressions representing sizes of data types. 4250397Sobrien It is the first integer type laid out. */ 4390075Sobrientree sizetype_tab[(int) TYPE_KIND_LAST]; 4418334Speter 4518334Speter/* If nonzero, this is an upper limit on alignment of structure fields. 4618334Speter The value is measured in bits. */ 4790075Sobrienunsigned int maximum_field_alignment; 4818334Speter 4918334Speter/* If non-zero, the alignment of a bitstring or (power-)set value, in bits. 5018334Speter May be overridden by front-ends. */ 5190075Sobrienunsigned int set_alignment = 0; 5218334Speter 5390075Sobrien/* Nonzero if all REFERENCE_TYPEs are internal and hence should be 5490075Sobrien allocated in Pmode, not ptr_mode. Set only by internal_reference_types 5590075Sobrien called only by a front end. */ 5690075Sobrienstatic int reference_types_internal = 0; 5790075Sobrien 5890075Sobrienstatic void finalize_record_size PARAMS ((record_layout_info)); 5990075Sobrienstatic void finalize_type_size PARAMS ((tree)); 6090075Sobrienstatic void place_union_field PARAMS ((record_layout_info, tree)); 6190075Sobrienextern void debug_rli PARAMS ((record_layout_info)); 6218334Speter 6318334Speter/* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */ 6418334Speter 6518334Speterstatic tree pending_sizes; 6618334Speter 6718334Speter/* Nonzero means cannot safely call expand_expr now, 6818334Speter so put variable sizes onto `pending_sizes' instead. */ 6918334Speter 7018334Speterint immediate_size_expand; 7118334Speter 7290075Sobrien/* Show that REFERENCE_TYPES are internal and should be Pmode. Called only 7390075Sobrien by front end. */ 7490075Sobrien 7590075Sobrienvoid 7690075Sobrieninternal_reference_types () 7790075Sobrien{ 7890075Sobrien reference_types_internal = 1; 7990075Sobrien} 8090075Sobrien 8190075Sobrien/* Get a list of all the objects put on the pending sizes list. */ 8290075Sobrien 8318334Spetertree 8418334Speterget_pending_sizes () 8518334Speter{ 8618334Speter tree chain = pending_sizes; 8718334Speter tree t; 8818334Speter 8918334Speter /* Put each SAVE_EXPR into the current function. */ 9018334Speter for (t = chain; t; t = TREE_CHAIN (t)) 9118334Speter SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = current_function_decl; 9290075Sobrien 9318334Speter pending_sizes = 0; 9418334Speter return chain; 9518334Speter} 9618334Speter 9790075Sobrien/* Return non-zero if EXPR is present on the pending sizes list. */ 9890075Sobrien 9990075Sobrienint 10090075Sobrienis_pending_size (expr) 10190075Sobrien tree expr; 10290075Sobrien{ 10390075Sobrien tree t; 10490075Sobrien 10590075Sobrien for (t = pending_sizes; t; t = TREE_CHAIN (t)) 10690075Sobrien if (TREE_VALUE (t) == expr) 10790075Sobrien return 1; 10890075Sobrien return 0; 10990075Sobrien} 11090075Sobrien 11190075Sobrien/* Add EXPR to the pending sizes list. */ 11290075Sobrien 11318334Spetervoid 11490075Sobrienput_pending_size (expr) 11590075Sobrien tree expr; 11690075Sobrien{ 11790075Sobrien /* Strip any simple arithmetic from EXPR to see if it has an underlying 11890075Sobrien SAVE_EXPR. */ 11990075Sobrien while (TREE_CODE_CLASS (TREE_CODE (expr)) == '1' 12090075Sobrien || (TREE_CODE_CLASS (TREE_CODE (expr)) == '2' 12190075Sobrien && TREE_CONSTANT (TREE_OPERAND (expr, 1)))) 12290075Sobrien expr = TREE_OPERAND (expr, 0); 12390075Sobrien 12490075Sobrien if (TREE_CODE (expr) == SAVE_EXPR) 12590075Sobrien pending_sizes = tree_cons (NULL_TREE, expr, pending_sizes); 12690075Sobrien} 12790075Sobrien 12890075Sobrien/* Put a chain of objects into the pending sizes list, which must be 12990075Sobrien empty. */ 13090075Sobrien 13190075Sobrienvoid 13218334Speterput_pending_sizes (chain) 13318334Speter tree chain; 13418334Speter{ 13518334Speter if (pending_sizes) 13618334Speter abort (); 13718334Speter 13818334Speter pending_sizes = chain; 13918334Speter} 14018334Speter 14118334Speter/* Given a size SIZE that may not be a constant, return a SAVE_EXPR 14218334Speter to serve as the actual size-expression for a type or decl. */ 14318334Speter 14418334Spetertree 14518334Spetervariable_size (size) 14618334Speter tree size; 14718334Speter{ 14818334Speter /* If the language-processor is to take responsibility for variable-sized 14918334Speter items (e.g., languages which have elaboration procedures like Ada), 15090075Sobrien just return SIZE unchanged. Likewise for self-referential sizes and 15190075Sobrien constant sizes. */ 15218334Speter if (TREE_CONSTANT (size) 15318334Speter || global_bindings_p () < 0 || contains_placeholder_p (size)) 15418334Speter return size; 15518334Speter 15618334Speter size = save_expr (size); 15718334Speter 15890075Sobrien /* If an array with a variable number of elements is declared, and 15990075Sobrien the elements require destruction, we will emit a cleanup for the 16090075Sobrien array. That cleanup is run both on normal exit from the block 16190075Sobrien and in the exception-handler for the block. Normally, when code 16290075Sobrien is used in both ordinary code and in an exception handler it is 16390075Sobrien `unsaved', i.e., all SAVE_EXPRs are recalculated. However, we do 16490075Sobrien not wish to do that here; the array-size is the same in both 16590075Sobrien places. */ 16690075Sobrien if (TREE_CODE (size) == SAVE_EXPR) 16790075Sobrien SAVE_EXPR_PERSISTENT_P (size) = 1; 16890075Sobrien 16918334Speter if (global_bindings_p ()) 17018334Speter { 17118334Speter if (TREE_CONSTANT (size)) 17218334Speter error ("type size can't be explicitly evaluated"); 17318334Speter else 17418334Speter error ("variable-size type declared outside of any function"); 17518334Speter 17690075Sobrien return size_one_node; 17718334Speter } 17818334Speter 17918334Speter if (immediate_size_expand) 18018334Speter /* NULL_RTX is not defined; neither is the rtx type. 18118334Speter Also, we would like to pass const0_rtx here, but don't have it. */ 18290075Sobrien expand_expr (size, expand_expr (integer_zero_node, NULL_RTX, VOIDmode, 0), 18318334Speter VOIDmode, 0); 18490075Sobrien else if (cfun != 0 && cfun->x_dont_save_pending_sizes_p) 18590075Sobrien /* The front-end doesn't want us to keep a list of the expressions 18690075Sobrien that determine sizes for variable size objects. */ 18790075Sobrien ; 18818334Speter else 18990075Sobrien put_pending_size (size); 19018334Speter 19118334Speter return size; 19218334Speter} 19318334Speter 19418334Speter#ifndef MAX_FIXED_MODE_SIZE 19518334Speter#define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode) 19618334Speter#endif 19718334Speter 19818334Speter/* Return the machine mode to use for a nonscalar of SIZE bits. 19918334Speter The mode must be in class CLASS, and have exactly that many bits. 20018334Speter If LIMIT is nonzero, modes of wider than MAX_FIXED_MODE_SIZE will not 20118334Speter be used. */ 20218334Speter 20318334Speterenum machine_mode 20418334Spetermode_for_size (size, class, limit) 20518334Speter unsigned int size; 20618334Speter enum mode_class class; 20718334Speter int limit; 20818334Speter{ 20990075Sobrien enum machine_mode mode; 21018334Speter 21190075Sobrien if (limit && size > MAX_FIXED_MODE_SIZE) 21218334Speter return BLKmode; 21318334Speter 21418334Speter /* Get the first mode which has this size, in the specified class. */ 21518334Speter for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; 21618334Speter mode = GET_MODE_WIDER_MODE (mode)) 21790075Sobrien if (GET_MODE_BITSIZE (mode) == size) 21818334Speter return mode; 21918334Speter 22018334Speter return BLKmode; 22118334Speter} 22218334Speter 22390075Sobrien/* Similar, except passed a tree node. */ 22490075Sobrien 22590075Sobrienenum machine_mode 22690075Sobrienmode_for_size_tree (size, class, limit) 22790075Sobrien tree size; 22890075Sobrien enum mode_class class; 22990075Sobrien int limit; 23090075Sobrien{ 23190075Sobrien if (TREE_CODE (size) != INTEGER_CST 23290075Sobrien /* What we really want to say here is that the size can fit in a 23390075Sobrien host integer, but we know there's no way we'd find a mode for 23490075Sobrien this many bits, so there's no point in doing the precise test. */ 23590075Sobrien || compare_tree_int (size, 1000) > 0) 23690075Sobrien return BLKmode; 23790075Sobrien else 23890075Sobrien return mode_for_size (TREE_INT_CST_LOW (size), class, limit); 23990075Sobrien} 24090075Sobrien 24118334Speter/* Similar, but never return BLKmode; return the narrowest mode that 24218334Speter contains at least the requested number of bits. */ 24318334Speter 24452284Sobrienenum machine_mode 24518334Spetersmallest_mode_for_size (size, class) 24618334Speter unsigned int size; 24718334Speter enum mode_class class; 24818334Speter{ 24990075Sobrien enum machine_mode mode; 25018334Speter 25118334Speter /* Get the first mode which has at least this size, in the 25218334Speter specified class. */ 25318334Speter for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; 25418334Speter mode = GET_MODE_WIDER_MODE (mode)) 25590075Sobrien if (GET_MODE_BITSIZE (mode) >= size) 25618334Speter return mode; 25718334Speter 25818334Speter abort (); 25918334Speter} 26018334Speter 26152284Sobrien/* Find an integer mode of the exact same size, or BLKmode on failure. */ 26252284Sobrien 26352284Sobrienenum machine_mode 26452284Sobrienint_mode_for_mode (mode) 26552284Sobrien enum machine_mode mode; 26652284Sobrien{ 26752284Sobrien switch (GET_MODE_CLASS (mode)) 26852284Sobrien { 26952284Sobrien case MODE_INT: 27052284Sobrien case MODE_PARTIAL_INT: 27152284Sobrien break; 27252284Sobrien 27352284Sobrien case MODE_COMPLEX_INT: 27452284Sobrien case MODE_COMPLEX_FLOAT: 27552284Sobrien case MODE_FLOAT: 27690075Sobrien case MODE_VECTOR_INT: 27790075Sobrien case MODE_VECTOR_FLOAT: 27852284Sobrien mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0); 27952284Sobrien break; 28052284Sobrien 28152284Sobrien case MODE_RANDOM: 28252284Sobrien if (mode == BLKmode) 28352284Sobrien break; 28452284Sobrien 28590075Sobrien /* ... fall through ... */ 28690075Sobrien 28752284Sobrien case MODE_CC: 28852284Sobrien default: 28990075Sobrien abort (); 29052284Sobrien } 29152284Sobrien 29252284Sobrien return mode; 29352284Sobrien} 29452284Sobrien 29590075Sobrien/* Return the value of VALUE, rounded up to a multiple of DIVISOR. 29690075Sobrien This can only be applied to objects of a sizetype. */ 29718334Speter 29818334Spetertree 29918334Speterround_up (value, divisor) 30018334Speter tree value; 30118334Speter int divisor; 30218334Speter{ 30390075Sobrien tree arg = size_int_type (divisor, TREE_TYPE (value)); 30490075Sobrien 30590075Sobrien return size_binop (MULT_EXPR, size_binop (CEIL_DIV_EXPR, value, arg), arg); 30618334Speter} 30790075Sobrien 30890075Sobrien/* Likewise, but round down. */ 30990075Sobrien 31090075Sobrientree 31190075Sobrienround_down (value, divisor) 31290075Sobrien tree value; 31390075Sobrien int divisor; 31490075Sobrien{ 31590075Sobrien tree arg = size_int_type (divisor, TREE_TYPE (value)); 31690075Sobrien 31790075Sobrien return size_binop (MULT_EXPR, size_binop (FLOOR_DIV_EXPR, value, arg), arg); 31890075Sobrien} 31918334Speter 32018334Speter/* Set the size, mode and alignment of a ..._DECL node. 32118334Speter TYPE_DECL does need this for C++. 32218334Speter Note that LABEL_DECL and CONST_DECL nodes do not need this, 32318334Speter and FUNCTION_DECL nodes have them set up in a special (and simple) way. 32418334Speter Don't call layout_decl for them. 32518334Speter 32618334Speter KNOWN_ALIGN is the amount of alignment we can assume this 32718334Speter decl has with no special effort. It is relevant only for FIELD_DECLs 32818334Speter and depends on the previous fields. 32918334Speter All that matters about KNOWN_ALIGN is which powers of 2 divide it. 33018334Speter If KNOWN_ALIGN is 0, it means, "as much alignment as you like": 33118334Speter the record will be aligned to suit. */ 33218334Speter 33318334Spetervoid 33418334Speterlayout_decl (decl, known_align) 33518334Speter tree decl; 33690075Sobrien unsigned int known_align; 33718334Speter{ 33890075Sobrien tree type = TREE_TYPE (decl); 33990075Sobrien enum tree_code code = TREE_CODE (decl); 34018334Speter 34118334Speter if (code == CONST_DECL) 34218334Speter return; 34390075Sobrien else if (code != VAR_DECL && code != PARM_DECL && code != RESULT_DECL 34490075Sobrien && code != TYPE_DECL && code != FIELD_DECL) 34518334Speter abort (); 34618334Speter 34718334Speter if (type == error_mark_node) 34890075Sobrien type = void_type_node; 34918334Speter 35090075Sobrien /* Usually the size and mode come from the data type without change, 35190075Sobrien however, the front-end may set the explicit width of the field, so its 35290075Sobrien size may not be the same as the size of its type. This happens with 35390075Sobrien bitfields, of course (an `int' bitfield may be only 2 bits, say), but it 35490075Sobrien also happens with other fields. For example, the C++ front-end creates 35590075Sobrien zero-sized fields corresponding to empty base classes, and depends on 35690075Sobrien layout_type setting DECL_FIELD_BITPOS correctly for the field. Set the 35790075Sobrien size in bytes from the size in bits. If we have already set the mode, 35890075Sobrien don't set it again since we can be called twice for FIELD_DECLs. */ 35918334Speter 36018334Speter TREE_UNSIGNED (decl) = TREE_UNSIGNED (type); 36190075Sobrien if (DECL_MODE (decl) == VOIDmode) 36290075Sobrien DECL_MODE (decl) = TYPE_MODE (type); 36390075Sobrien 36418334Speter if (DECL_SIZE (decl) == 0) 36518334Speter { 36690075Sobrien DECL_SIZE (decl) = TYPE_SIZE (type); 36790075Sobrien DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type); 36890075Sobrien } 36990075Sobrien else 37090075Sobrien DECL_SIZE_UNIT (decl) 37190075Sobrien = convert (sizetype, size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl), 37290075Sobrien bitsize_unit_node)); 37318334Speter 37418334Speter /* Force alignment required for the data type. 37518334Speter But if the decl itself wants greater alignment, don't override that. 37618334Speter Likewise, if the decl is packed, don't override it. */ 37790075Sobrien if (! (code == FIELD_DECL && DECL_BIT_FIELD (decl)) 37890075Sobrien && (DECL_ALIGN (decl) == 0 37990075Sobrien || (! (code == FIELD_DECL && DECL_PACKED (decl)) 38090075Sobrien && TYPE_ALIGN (type) > DECL_ALIGN (decl)))) 38190075Sobrien { 38290075Sobrien DECL_ALIGN (decl) = TYPE_ALIGN (type); 38390075Sobrien DECL_USER_ALIGN (decl) = 0; 38490075Sobrien } 38518334Speter 38690075Sobrien /* For fields, set the bit field type and update the alignment. */ 38718334Speter if (code == FIELD_DECL) 38818334Speter { 38918334Speter DECL_BIT_FIELD_TYPE (decl) = DECL_BIT_FIELD (decl) ? type : 0; 39018334Speter if (maximum_field_alignment != 0) 39190075Sobrien DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment); 39290075Sobrien 39390075Sobrien /* If the field is of variable size, we can't misalign it since we 39490075Sobrien have no way to make a temporary to align the result. But this 39590075Sobrien isn't an issue if the decl is not addressable. Likewise if it 39690075Sobrien is of unknown size. */ 39790075Sobrien else if (DECL_PACKED (decl) 39890075Sobrien && (DECL_NONADDRESSABLE_P (decl) 39990075Sobrien || DECL_SIZE_UNIT (decl) == 0 40090075Sobrien || TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST)) 40190075Sobrien { 40290075Sobrien DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), BITS_PER_UNIT); 40390075Sobrien DECL_USER_ALIGN (decl) = 0; 40490075Sobrien } 40518334Speter } 40618334Speter 40790075Sobrien /* See if we can use an ordinary integer mode for a bit-field. 40890075Sobrien Conditions are: a fixed size that is correct for another mode 40990075Sobrien and occupying a complete byte or bytes on proper boundary. */ 41090075Sobrien if (code == FIELD_DECL && DECL_BIT_FIELD (decl) 41118334Speter && TYPE_SIZE (type) != 0 41250397Sobrien && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 41350397Sobrien && GET_MODE_CLASS (TYPE_MODE (type)) == MODE_INT) 41418334Speter { 41590075Sobrien enum machine_mode xmode 41690075Sobrien = mode_for_size_tree (DECL_SIZE (decl), MODE_INT, 1); 41718334Speter 41890075Sobrien if (xmode != BLKmode && known_align >= GET_MODE_ALIGNMENT (xmode)) 41918334Speter { 42090075Sobrien DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode), 42118334Speter DECL_ALIGN (decl)); 42218334Speter DECL_MODE (decl) = xmode; 42318334Speter DECL_BIT_FIELD (decl) = 0; 42418334Speter } 42518334Speter } 42618334Speter 42750397Sobrien /* Turn off DECL_BIT_FIELD if we won't need it set. */ 42890075Sobrien if (code == FIELD_DECL && DECL_BIT_FIELD (decl) 42990075Sobrien && TYPE_MODE (type) == BLKmode && DECL_MODE (decl) == BLKmode 43090075Sobrien && known_align >= TYPE_ALIGN (type) 43190075Sobrien && DECL_ALIGN (decl) >= TYPE_ALIGN (type) 43290075Sobrien && DECL_SIZE_UNIT (decl) != 0) 43350397Sobrien DECL_BIT_FIELD (decl) = 0; 43450397Sobrien 43518334Speter /* Evaluate nonconstant size only once, either now or as soon as safe. */ 43618334Speter if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) 43718334Speter DECL_SIZE (decl) = variable_size (DECL_SIZE (decl)); 43890075Sobrien if (DECL_SIZE_UNIT (decl) != 0 43990075Sobrien && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST) 44090075Sobrien DECL_SIZE_UNIT (decl) = variable_size (DECL_SIZE_UNIT (decl)); 44190075Sobrien 44290075Sobrien /* If requested, warn about definitions of large data objects. */ 44390075Sobrien if (warn_larger_than 44490075Sobrien && (code == VAR_DECL || code == PARM_DECL) 44590075Sobrien && ! DECL_EXTERNAL (decl)) 44690075Sobrien { 44790075Sobrien tree size = DECL_SIZE_UNIT (decl); 44890075Sobrien 44990075Sobrien if (size != 0 && TREE_CODE (size) == INTEGER_CST 45090075Sobrien && compare_tree_int (size, larger_than_size) > 0) 45190075Sobrien { 45290075Sobrien unsigned int size_as_int = TREE_INT_CST_LOW (size); 45390075Sobrien 45490075Sobrien if (compare_tree_int (size, size_as_int) == 0) 45590075Sobrien warning_with_decl (decl, "size of `%s' is %d bytes", size_as_int); 45690075Sobrien else 45790075Sobrien warning_with_decl (decl, "size of `%s' is larger than %d bytes", 45890075Sobrien larger_than_size); 45990075Sobrien } 46090075Sobrien } 46118334Speter} 46218334Speter 46390075Sobrien/* Hook for a front-end function that can modify the record layout as needed 46490075Sobrien immediately before it is finalized. */ 46518334Speter 46690075Sobrienvoid (*lang_adjust_rli) PARAMS ((record_layout_info)) = 0; 46718334Speter 46890075Sobrienvoid 46990075Sobrienset_lang_adjust_rli (f) 47090075Sobrien void (*f) PARAMS ((record_layout_info)); 47190075Sobrien{ 47290075Sobrien lang_adjust_rli = f; 47390075Sobrien} 47418334Speter 47590075Sobrien/* Begin laying out type T, which may be a RECORD_TYPE, UNION_TYPE, or 47690075Sobrien QUAL_UNION_TYPE. Return a pointer to a struct record_layout_info which 47790075Sobrien is to be passed to all other layout functions for this record. It is the 47890075Sobrien responsibility of the caller to call `free' for the storage returned. 47990075Sobrien Note that garbage collection is not permitted until we finish laying 48090075Sobrien out the record. */ 48190075Sobrien 48290075Sobrienrecord_layout_info 48390075Sobrienstart_record_layout (t) 48490075Sobrien tree t; 48518334Speter{ 48690075Sobrien record_layout_info rli 48790075Sobrien = (record_layout_info) xmalloc (sizeof (struct record_layout_info_s)); 48818334Speter 48990075Sobrien rli->t = t; 49090075Sobrien 49190075Sobrien /* If the type has a minimum specified alignment (via an attribute 49290075Sobrien declaration, for example) use it -- otherwise, start with a 49390075Sobrien one-byte alignment. */ 49490075Sobrien rli->record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (t)); 49590075Sobrien rli->unpacked_align = rli->unpadded_align = rli->record_align; 49690075Sobrien rli->offset_align = MAX (rli->record_align, BIGGEST_ALIGNMENT); 49790075Sobrien 49850397Sobrien#ifdef STRUCTURE_SIZE_BOUNDARY 49950397Sobrien /* Packed structures don't need to have minimum size. */ 50090075Sobrien if (! TYPE_PACKED (t)) 50190075Sobrien rli->record_align = MAX (rli->record_align, STRUCTURE_SIZE_BOUNDARY); 50250397Sobrien#endif 50318334Speter 50490075Sobrien rli->offset = size_zero_node; 50590075Sobrien rli->bitpos = bitsize_zero_node; 50690075Sobrien rli->pending_statics = 0; 50790075Sobrien rli->packed_maybe_necessary = 0; 50890075Sobrien 50990075Sobrien return rli; 51090075Sobrien} 51190075Sobrien 51290075Sobrien/* These four routines perform computations that convert between 51390075Sobrien the offset/bitpos forms and byte and bit offsets. */ 51490075Sobrien 51590075Sobrientree 51690075Sobrienbit_from_pos (offset, bitpos) 51790075Sobrien tree offset, bitpos; 51890075Sobrien{ 51990075Sobrien return size_binop (PLUS_EXPR, bitpos, 52090075Sobrien size_binop (MULT_EXPR, convert (bitsizetype, offset), 52190075Sobrien bitsize_unit_node)); 52290075Sobrien} 52390075Sobrien 52490075Sobrientree 52590075Sobrienbyte_from_pos (offset, bitpos) 52690075Sobrien tree offset, bitpos; 52790075Sobrien{ 52890075Sobrien return size_binop (PLUS_EXPR, offset, 52990075Sobrien convert (sizetype, 53090075Sobrien size_binop (TRUNC_DIV_EXPR, bitpos, 53190075Sobrien bitsize_unit_node))); 53290075Sobrien} 53390075Sobrien 53490075Sobrienvoid 53590075Sobrienpos_from_byte (poffset, pbitpos, off_align, pos) 53690075Sobrien tree *poffset, *pbitpos; 53790075Sobrien unsigned int off_align; 53890075Sobrien tree pos; 53990075Sobrien{ 54090075Sobrien *poffset 54190075Sobrien = size_binop (MULT_EXPR, 54290075Sobrien convert (sizetype, 54390075Sobrien size_binop (FLOOR_DIV_EXPR, pos, 54490075Sobrien bitsize_int (off_align 54590075Sobrien / BITS_PER_UNIT))), 54690075Sobrien size_int (off_align / BITS_PER_UNIT)); 54790075Sobrien *pbitpos = size_binop (MULT_EXPR, 54890075Sobrien size_binop (FLOOR_MOD_EXPR, pos, 54990075Sobrien bitsize_int (off_align / BITS_PER_UNIT)), 55090075Sobrien bitsize_unit_node); 55190075Sobrien} 55290075Sobrien 55390075Sobrienvoid 55490075Sobrienpos_from_bit (poffset, pbitpos, off_align, pos) 55590075Sobrien tree *poffset, *pbitpos; 55690075Sobrien unsigned int off_align; 55790075Sobrien tree pos; 55890075Sobrien{ 55990075Sobrien *poffset = size_binop (MULT_EXPR, 56090075Sobrien convert (sizetype, 56190075Sobrien size_binop (FLOOR_DIV_EXPR, pos, 56290075Sobrien bitsize_int (off_align))), 56390075Sobrien size_int (off_align / BITS_PER_UNIT)); 56490075Sobrien *pbitpos = size_binop (FLOOR_MOD_EXPR, pos, bitsize_int (off_align)); 56590075Sobrien} 56690075Sobrien 56790075Sobrien/* Given a pointer to bit and byte offsets and an offset alignment, 56890075Sobrien normalize the offsets so they are within the alignment. */ 56990075Sobrien 57090075Sobrienvoid 57190075Sobriennormalize_offset (poffset, pbitpos, off_align) 57290075Sobrien tree *poffset, *pbitpos; 57390075Sobrien unsigned int off_align; 57490075Sobrien{ 57590075Sobrien /* If the bit position is now larger than it should be, adjust it 57690075Sobrien downwards. */ 57790075Sobrien if (compare_tree_int (*pbitpos, off_align) >= 0) 57818334Speter { 57990075Sobrien tree extra_aligns = size_binop (FLOOR_DIV_EXPR, *pbitpos, 58090075Sobrien bitsize_int (off_align)); 58118334Speter 58290075Sobrien *poffset 58390075Sobrien = size_binop (PLUS_EXPR, *poffset, 58490075Sobrien size_binop (MULT_EXPR, convert (sizetype, extra_aligns), 58590075Sobrien size_int (off_align / BITS_PER_UNIT))); 58690075Sobrien 58790075Sobrien *pbitpos 58890075Sobrien = size_binop (FLOOR_MOD_EXPR, *pbitpos, bitsize_int (off_align)); 58990075Sobrien } 59090075Sobrien} 59118334Speter 59290075Sobrien/* Print debugging information about the information in RLI. */ 59318334Speter 59490075Sobrienvoid 59590075Sobriendebug_rli (rli) 59690075Sobrien record_layout_info rli; 59790075Sobrien{ 59890075Sobrien print_node_brief (stderr, "type", rli->t, 0); 59990075Sobrien print_node_brief (stderr, "\noffset", rli->offset, 0); 60090075Sobrien print_node_brief (stderr, " bitpos", rli->bitpos, 0); 60190075Sobrien 60290075Sobrien fprintf (stderr, "\naligns: rec = %u, unpack = %u, unpad = %u, off = %u\n", 60390075Sobrien rli->record_align, rli->unpacked_align, rli->unpadded_align, 60490075Sobrien rli->offset_align); 60590075Sobrien if (rli->packed_maybe_necessary) 60690075Sobrien fprintf (stderr, "packed may be necessary\n"); 60790075Sobrien 60890075Sobrien if (rli->pending_statics) 60990075Sobrien { 61090075Sobrien fprintf (stderr, "pending statics:\n"); 61190075Sobrien debug_tree (rli->pending_statics); 61290075Sobrien } 61390075Sobrien} 61490075Sobrien 61590075Sobrien/* Given an RLI with a possibly-incremented BITPOS, adjust OFFSET and 61690075Sobrien BITPOS if necessary to keep BITPOS below OFFSET_ALIGN. */ 61790075Sobrien 61890075Sobrienvoid 61990075Sobriennormalize_rli (rli) 62090075Sobrien record_layout_info rli; 62190075Sobrien{ 62290075Sobrien normalize_offset (&rli->offset, &rli->bitpos, rli->offset_align); 62390075Sobrien} 62490075Sobrien 62590075Sobrien/* Returns the size in bytes allocated so far. */ 62690075Sobrien 62790075Sobrientree 62890075Sobrienrli_size_unit_so_far (rli) 62990075Sobrien record_layout_info rli; 63090075Sobrien{ 63190075Sobrien return byte_from_pos (rli->offset, rli->bitpos); 63290075Sobrien} 63390075Sobrien 63490075Sobrien/* Returns the size in bits allocated so far. */ 63590075Sobrien 63690075Sobrientree 63790075Sobrienrli_size_so_far (rli) 63890075Sobrien record_layout_info rli; 63990075Sobrien{ 64090075Sobrien return bit_from_pos (rli->offset, rli->bitpos); 64190075Sobrien} 64290075Sobrien 64390075Sobrien/* Called from place_field to handle unions. */ 64490075Sobrien 64590075Sobrienstatic void 64690075Sobrienplace_union_field (rli, field) 64790075Sobrien record_layout_info rli; 64890075Sobrien tree field; 64990075Sobrien{ 65090075Sobrien unsigned int desired_align; 65190075Sobrien 65290075Sobrien layout_decl (field, 0); 65390075Sobrien 65490075Sobrien DECL_FIELD_OFFSET (field) = size_zero_node; 65590075Sobrien DECL_FIELD_BIT_OFFSET (field) = bitsize_zero_node; 65690075Sobrien SET_DECL_OFFSET_ALIGN (field, BIGGEST_ALIGNMENT); 65790075Sobrien 65890075Sobrien desired_align = DECL_ALIGN (field); 65990075Sobrien 66018334Speter#ifdef BIGGEST_FIELD_ALIGNMENT 66190075Sobrien /* Some targets (i.e. i386) limit union field alignment 66290075Sobrien to a lower boundary than alignment of variables unless 66390075Sobrien it was overridden by attribute aligned. */ 66490075Sobrien if (! DECL_USER_ALIGN (field)) 66590075Sobrien desired_align = 66690075Sobrien MIN (desired_align, (unsigned) BIGGEST_FIELD_ALIGNMENT); 66718334Speter#endif 66890075Sobrien 66950397Sobrien#ifdef ADJUST_FIELD_ALIGN 67090075Sobrien desired_align = ADJUST_FIELD_ALIGN (field, desired_align); 67150397Sobrien#endif 67218334Speter 67390075Sobrien TYPE_USER_ALIGN (rli->t) |= DECL_USER_ALIGN (field); 67418334Speter 67590075Sobrien /* Union must be at least as aligned as any field requires. */ 67690075Sobrien rli->record_align = MAX (rli->record_align, desired_align); 67790075Sobrien rli->unpadded_align = MAX (rli->unpadded_align, desired_align); 67818334Speter 67990075Sobrien#ifdef PCC_BITFIELD_TYPE_MATTERS 68090075Sobrien /* On the m88000, a bit field of declare type `int' forces the 68190075Sobrien entire union to have `int' alignment. */ 68290075Sobrien if (PCC_BITFIELD_TYPE_MATTERS && DECL_BIT_FIELD_TYPE (field)) 68390075Sobrien { 68490075Sobrien rli->record_align = MAX (rli->record_align, 68590075Sobrien TYPE_ALIGN (TREE_TYPE (field))); 68690075Sobrien rli->unpadded_align = MAX (rli->unpadded_align, 68790075Sobrien TYPE_ALIGN (TREE_TYPE (field))); 68890075Sobrien } 68918334Speter#endif 69018334Speter 69190075Sobrien /* We assume the union's size will be a multiple of a byte so we don't 69290075Sobrien bother with BITPOS. */ 69390075Sobrien if (TREE_CODE (rli->t) == UNION_TYPE) 69490075Sobrien rli->offset = size_binop (MAX_EXPR, rli->offset, DECL_SIZE_UNIT (field)); 69590075Sobrien else if (TREE_CODE (rli->t) == QUAL_UNION_TYPE) 69690075Sobrien rli->offset = fold (build (COND_EXPR, sizetype, 69790075Sobrien DECL_QUALIFIER (field), 69890075Sobrien DECL_SIZE_UNIT (field), rli->offset)); 69990075Sobrien} 70018334Speter 70190075Sobrien/* RLI contains information about the layout of a RECORD_TYPE. FIELD 70290075Sobrien is a FIELD_DECL to be added after those fields already present in 70390075Sobrien T. (FIELD is not actually added to the TYPE_FIELDS list here; 70490075Sobrien callers that desire that behavior must manually perform that step.) */ 70518334Speter 70690075Sobrienvoid 70790075Sobrienplace_field (rli, field) 70890075Sobrien record_layout_info rli; 70990075Sobrien tree field; 71090075Sobrien{ 71190075Sobrien /* The alignment required for FIELD. */ 71290075Sobrien unsigned int desired_align; 71390075Sobrien /* The alignment FIELD would have if we just dropped it into the 71490075Sobrien record as it presently stands. */ 71590075Sobrien unsigned int known_align; 71690075Sobrien unsigned int actual_align; 71790075Sobrien unsigned int user_align; 71890075Sobrien /* The type of this field. */ 71990075Sobrien tree type = TREE_TYPE (field); 72090075Sobrien 72190075Sobrien if (TREE_CODE (field) == ERROR_MARK || TREE_CODE (type) == ERROR_MARK) 72290075Sobrien return; 72318334Speter 72490075Sobrien /* If FIELD is static, then treat it like a separate variable, not 72590075Sobrien really like a structure field. If it is a FUNCTION_DECL, it's a 72690075Sobrien method. In both cases, all we do is lay out the decl, and we do 72790075Sobrien it *after* the record is laid out. */ 72890075Sobrien if (TREE_CODE (field) == VAR_DECL) 72990075Sobrien { 73090075Sobrien rli->pending_statics = tree_cons (NULL_TREE, field, 73190075Sobrien rli->pending_statics); 73290075Sobrien return; 73390075Sobrien } 73418334Speter 73590075Sobrien /* Enumerators and enum types which are local to this class need not 73690075Sobrien be laid out. Likewise for initialized constant fields. */ 73790075Sobrien else if (TREE_CODE (field) != FIELD_DECL) 73890075Sobrien return; 73990075Sobrien 74090075Sobrien /* Unions are laid out very differently than records, so split 74190075Sobrien that code off to another function. */ 74290075Sobrien else if (TREE_CODE (rli->t) != RECORD_TYPE) 74390075Sobrien { 74490075Sobrien place_union_field (rli, field); 74590075Sobrien return; 74690075Sobrien } 74790075Sobrien 74890075Sobrien /* Work out the known alignment so far. Note that A & (-A) is the 74990075Sobrien value of the least-significant bit in A that is one. */ 75090075Sobrien if (! integer_zerop (rli->bitpos)) 75190075Sobrien known_align = (tree_low_cst (rli->bitpos, 1) 75290075Sobrien & - tree_low_cst (rli->bitpos, 1)); 75390075Sobrien else if (integer_zerop (rli->offset)) 75490075Sobrien known_align = BIGGEST_ALIGNMENT; 75590075Sobrien else if (host_integerp (rli->offset, 1)) 75690075Sobrien known_align = (BITS_PER_UNIT 75790075Sobrien * (tree_low_cst (rli->offset, 1) 75890075Sobrien & - tree_low_cst (rli->offset, 1))); 75990075Sobrien else 76090075Sobrien known_align = rli->offset_align; 76190075Sobrien 76290075Sobrien /* Lay out the field so we know what alignment it needs. For a 76390075Sobrien packed field, use the alignment as specified, disregarding what 76490075Sobrien the type would want. */ 76590075Sobrien desired_align = DECL_ALIGN (field); 76690075Sobrien user_align = DECL_USER_ALIGN (field); 76790075Sobrien layout_decl (field, known_align); 76890075Sobrien if (! DECL_PACKED (field)) 76990075Sobrien { 77090075Sobrien desired_align = DECL_ALIGN (field); 77190075Sobrien user_align = DECL_USER_ALIGN (field); 77290075Sobrien } 77390075Sobrien 77490075Sobrien /* Some targets (i.e. i386, VMS) limit struct field alignment 77590075Sobrien to a lower boundary than alignment of variables unless 77690075Sobrien it was overridden by attribute aligned. */ 77790075Sobrien#ifdef BIGGEST_FIELD_ALIGNMENT 77890075Sobrien if (! user_align) 77990075Sobrien desired_align 78090075Sobrien = MIN (desired_align, (unsigned) BIGGEST_FIELD_ALIGNMENT); 78118334Speter#endif 78218334Speter 78390075Sobrien#ifdef ADJUST_FIELD_ALIGN 78490075Sobrien desired_align = ADJUST_FIELD_ALIGN (field, desired_align); 78590075Sobrien#endif 78690075Sobrien 78790075Sobrien /* Record must have at least as much alignment as any field. 78890075Sobrien Otherwise, the alignment of the field within the record is 78990075Sobrien meaningless. */ 79090075Sobrien#ifdef PCC_BITFIELD_TYPE_MATTERS 79190075Sobrien if (PCC_BITFIELD_TYPE_MATTERS && type != error_mark_node 79290075Sobrien && DECL_BIT_FIELD_TYPE (field) 79390075Sobrien && ! integer_zerop (TYPE_SIZE (type))) 79490075Sobrien { 79590075Sobrien /* For these machines, a zero-length field does not 79690075Sobrien affect the alignment of the structure as a whole. 79790075Sobrien It does, however, affect the alignment of the next field 79890075Sobrien within the structure. */ 79990075Sobrien if (! integer_zerop (DECL_SIZE (field))) 80090075Sobrien rli->record_align = MAX (rli->record_align, desired_align); 80190075Sobrien else if (! DECL_PACKED (field)) 80290075Sobrien desired_align = TYPE_ALIGN (type); 80390075Sobrien 80490075Sobrien /* A named bit field of declared type `int' 80590075Sobrien forces the entire structure to have `int' alignment. */ 80690075Sobrien if (DECL_NAME (field) != 0) 80718334Speter { 80890075Sobrien unsigned int type_align = TYPE_ALIGN (type); 80918334Speter 81018334Speter if (maximum_field_alignment != 0) 81118334Speter type_align = MIN (type_align, maximum_field_alignment); 81250397Sobrien else if (DECL_PACKED (field)) 81318334Speter type_align = MIN (type_align, BITS_PER_UNIT); 81418334Speter 81590075Sobrien rli->record_align = MAX (rli->record_align, type_align); 81690075Sobrien rli->unpadded_align = MAX (rli->unpadded_align, DECL_ALIGN (field)); 81790075Sobrien if (warn_packed) 81890075Sobrien rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); 81918334Speter } 82090075Sobrien } 82190075Sobrien else 82218334Speter#endif 82390075Sobrien { 82490075Sobrien rli->record_align = MAX (rli->record_align, desired_align); 82590075Sobrien rli->unpacked_align = MAX (rli->unpacked_align, TYPE_ALIGN (type)); 82690075Sobrien rli->unpadded_align = MAX (rli->unpadded_align, DECL_ALIGN (field)); 82790075Sobrien } 82818334Speter 82990075Sobrien if (warn_packed && DECL_PACKED (field)) 83090075Sobrien { 83190075Sobrien if (known_align > TYPE_ALIGN (type)) 83290075Sobrien { 83390075Sobrien if (TYPE_ALIGN (type) > desired_align) 83490075Sobrien { 83590075Sobrien if (STRICT_ALIGNMENT) 83690075Sobrien warning_with_decl (field, "packed attribute causes inefficient alignment for `%s'"); 83790075Sobrien else 83890075Sobrien warning_with_decl (field, "packed attribute is unnecessary for `%s'"); 83990075Sobrien } 84090075Sobrien } 84190075Sobrien else 84290075Sobrien rli->packed_maybe_necessary = 1; 84390075Sobrien } 84418334Speter 84590075Sobrien /* Does this field automatically have alignment it needs by virtue 84690075Sobrien of the fields that precede it and the record's own alignment? */ 84790075Sobrien if (known_align < desired_align) 84890075Sobrien { 84990075Sobrien /* No, we need to skip space before this field. 85090075Sobrien Bump the cumulative size to multiple of field alignment. */ 85190075Sobrien 85290075Sobrien if (warn_padded) 85390075Sobrien warning_with_decl (field, "padding struct to align `%s'"); 85490075Sobrien 85590075Sobrien /* If the alignment is still within offset_align, just align 85690075Sobrien the bit position. */ 85790075Sobrien if (desired_align < rli->offset_align) 85890075Sobrien rli->bitpos = round_up (rli->bitpos, desired_align); 85918334Speter else 86018334Speter { 86190075Sobrien /* First adjust OFFSET by the partial bits, then align. */ 86290075Sobrien rli->offset 86390075Sobrien = size_binop (PLUS_EXPR, rli->offset, 86490075Sobrien convert (sizetype, 86590075Sobrien size_binop (CEIL_DIV_EXPR, rli->bitpos, 86690075Sobrien bitsize_unit_node))); 86790075Sobrien rli->bitpos = bitsize_zero_node; 86818334Speter 86990075Sobrien rli->offset = round_up (rli->offset, desired_align / BITS_PER_UNIT); 87018334Speter } 87118334Speter 87290075Sobrien if (! TREE_CONSTANT (rli->offset)) 87390075Sobrien rli->offset_align = desired_align; 87418334Speter 87590075Sobrien } 87618334Speter 87790075Sobrien /* Handle compatibility with PCC. Note that if the record has any 87890075Sobrien variable-sized fields, we need not worry about compatibility. */ 87990075Sobrien#ifdef PCC_BITFIELD_TYPE_MATTERS 88090075Sobrien if (PCC_BITFIELD_TYPE_MATTERS 88190075Sobrien && TREE_CODE (field) == FIELD_DECL 88290075Sobrien && type != error_mark_node 88390075Sobrien && DECL_BIT_FIELD (field) 88490075Sobrien && ! DECL_PACKED (field) 88590075Sobrien && maximum_field_alignment == 0 88690075Sobrien && ! integer_zerop (DECL_SIZE (field)) 88790075Sobrien && host_integerp (DECL_SIZE (field), 1) 88890075Sobrien && host_integerp (rli->offset, 1) 88990075Sobrien && host_integerp (TYPE_SIZE (type), 1)) 89090075Sobrien { 89190075Sobrien unsigned int type_align = TYPE_ALIGN (type); 89290075Sobrien tree dsize = DECL_SIZE (field); 89390075Sobrien HOST_WIDE_INT field_size = tree_low_cst (dsize, 1); 89490075Sobrien HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0); 89590075Sobrien HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0); 89690075Sobrien 89790075Sobrien /* A bit field may not span more units of alignment of its type 89890075Sobrien than its type itself. Advance to next boundary if necessary. */ 89990075Sobrien if ((((offset * BITS_PER_UNIT + bit_offset + field_size + 90090075Sobrien type_align - 1) 90190075Sobrien / type_align) 90290075Sobrien - (offset * BITS_PER_UNIT + bit_offset) / type_align) 90390075Sobrien > tree_low_cst (TYPE_SIZE (type), 1) / type_align) 90490075Sobrien rli->bitpos = round_up (rli->bitpos, type_align); 90518334Speter } 90690075Sobrien#endif 90718334Speter 90890075Sobrien#ifdef BITFIELD_NBYTES_LIMITED 90990075Sobrien if (BITFIELD_NBYTES_LIMITED 91090075Sobrien && TREE_CODE (field) == FIELD_DECL 91190075Sobrien && type != error_mark_node 91290075Sobrien && DECL_BIT_FIELD_TYPE (field) 91390075Sobrien && ! DECL_PACKED (field) 91490075Sobrien && ! integer_zerop (DECL_SIZE (field)) 91590075Sobrien && host_integerp (DECL_SIZE (field), 1) 91690075Sobrien && host_integerp (rli->offset, 1) 91790075Sobrien && host_integerp (TYPE_SIZE (type), 1)) 91890075Sobrien { 91990075Sobrien unsigned int type_align = TYPE_ALIGN (type); 92090075Sobrien tree dsize = DECL_SIZE (field); 92190075Sobrien HOST_WIDE_INT field_size = tree_low_cst (dsize, 1); 92290075Sobrien HOST_WIDE_INT offset = tree_low_cst (rli->offset, 0); 92390075Sobrien HOST_WIDE_INT bit_offset = tree_low_cst (rli->bitpos, 0); 92418334Speter 92590075Sobrien if (maximum_field_alignment != 0) 92690075Sobrien type_align = MIN (type_align, maximum_field_alignment); 92790075Sobrien /* ??? This test is opposite the test in the containing if 92890075Sobrien statement, so this code is unreachable currently. */ 92990075Sobrien else if (DECL_PACKED (field)) 93090075Sobrien type_align = MIN (type_align, BITS_PER_UNIT); 93190075Sobrien 93290075Sobrien /* A bit field may not span the unit of alignment of its type. 93390075Sobrien Advance to next boundary if necessary. */ 93490075Sobrien /* ??? This code should match the code above for the 93590075Sobrien PCC_BITFIELD_TYPE_MATTERS case. */ 93690075Sobrien if ((offset * BITS_PER_UNIT + bit_offset) / type_align 93790075Sobrien != ((offset * BITS_PER_UNIT + bit_offset + field_size - 1) 93890075Sobrien / type_align)) 93990075Sobrien rli->bitpos = round_up (rli->bitpos, type_align); 94090075Sobrien } 94190075Sobrien#endif 94290075Sobrien 94390075Sobrien /* Offset so far becomes the position of this field after normalizing. */ 94490075Sobrien normalize_rli (rli); 94590075Sobrien DECL_FIELD_OFFSET (field) = rli->offset; 94690075Sobrien DECL_FIELD_BIT_OFFSET (field) = rli->bitpos; 94790075Sobrien SET_DECL_OFFSET_ALIGN (field, rli->offset_align); 94890075Sobrien 94990075Sobrien TYPE_USER_ALIGN (rli->t) |= user_align; 95090075Sobrien 95190075Sobrien /* If this field ended up more aligned than we thought it would be (we 95290075Sobrien approximate this by seeing if its position changed), lay out the field 95390075Sobrien again; perhaps we can use an integral mode for it now. */ 95490075Sobrien if (! integer_zerop (DECL_FIELD_BIT_OFFSET (field))) 95590075Sobrien actual_align = (tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1) 95690075Sobrien & - tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)); 95790075Sobrien else if (integer_zerop (DECL_FIELD_OFFSET (field))) 95890075Sobrien actual_align = BIGGEST_ALIGNMENT; 95990075Sobrien else if (host_integerp (DECL_FIELD_OFFSET (field), 1)) 96090075Sobrien actual_align = (BITS_PER_UNIT 96190075Sobrien * (tree_low_cst (DECL_FIELD_OFFSET (field), 1) 96290075Sobrien & - tree_low_cst (DECL_FIELD_OFFSET (field), 1))); 96390075Sobrien else 96490075Sobrien actual_align = DECL_OFFSET_ALIGN (field); 96590075Sobrien 96690075Sobrien if (known_align != actual_align) 96790075Sobrien layout_decl (field, actual_align); 96890075Sobrien 96990075Sobrien /* Now add size of this field to the size of the record. If the size is 97090075Sobrien not constant, treat the field as being a multiple of bytes and just 97190075Sobrien adjust the offset, resetting the bit position. Otherwise, apportion the 97290075Sobrien size amongst the bit position and offset. First handle the case of an 97390075Sobrien unspecified size, which can happen when we have an invalid nested struct 97490075Sobrien definition, such as struct j { struct j { int i; } }. The error message 97590075Sobrien is printed in finish_struct. */ 97690075Sobrien if (DECL_SIZE (field) == 0) 97790075Sobrien /* Do nothing. */; 97890075Sobrien else if (TREE_CODE (DECL_SIZE_UNIT (field)) != INTEGER_CST 97990075Sobrien || TREE_CONSTANT_OVERFLOW (DECL_SIZE_UNIT (field))) 98018334Speter { 98190075Sobrien rli->offset 98290075Sobrien = size_binop (PLUS_EXPR, rli->offset, 98390075Sobrien convert (sizetype, 98490075Sobrien size_binop (CEIL_DIV_EXPR, rli->bitpos, 98590075Sobrien bitsize_unit_node))); 98690075Sobrien rli->offset 98790075Sobrien = size_binop (PLUS_EXPR, rli->offset, DECL_SIZE_UNIT (field)); 98890075Sobrien rli->bitpos = bitsize_zero_node; 98990075Sobrien rli->offset_align = MIN (rli->offset_align, DECL_ALIGN (field)); 99018334Speter } 99118334Speter else 99218334Speter { 99390075Sobrien rli->bitpos = size_binop (PLUS_EXPR, rli->bitpos, DECL_SIZE (field)); 99490075Sobrien normalize_rli (rli); 99518334Speter } 99690075Sobrien} 99718334Speter 99890075Sobrien/* Assuming that all the fields have been laid out, this function uses 99990075Sobrien RLI to compute the final TYPE_SIZE, TYPE_ALIGN, etc. for the type 100090075Sobrien inidicated by RLI. */ 100190075Sobrien 100290075Sobrienstatic void 100390075Sobrienfinalize_record_size (rli) 100490075Sobrien record_layout_info rli; 100590075Sobrien{ 100690075Sobrien tree unpadded_size, unpadded_size_unit; 100790075Sobrien 100890075Sobrien /* Now we want just byte and bit offsets, so set the offset alignment 100990075Sobrien to be a byte and then normalize. */ 101090075Sobrien rli->offset_align = BITS_PER_UNIT; 101190075Sobrien normalize_rli (rli); 101290075Sobrien 101318334Speter /* Determine the desired alignment. */ 101418334Speter#ifdef ROUND_TYPE_ALIGN 101590075Sobrien TYPE_ALIGN (rli->t) = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), 101690075Sobrien rli->record_align); 101718334Speter#else 101890075Sobrien TYPE_ALIGN (rli->t) = MAX (TYPE_ALIGN (rli->t), rli->record_align); 101918334Speter#endif 102018334Speter 102190075Sobrien /* Compute the size so far. Be sure to allow for extra bits in the 102290075Sobrien size in bytes. We have guaranteed above that it will be no more 102390075Sobrien than a single byte. */ 102490075Sobrien unpadded_size = rli_size_so_far (rli); 102590075Sobrien unpadded_size_unit = rli_size_unit_so_far (rli); 102690075Sobrien if (! integer_zerop (rli->bitpos)) 102790075Sobrien unpadded_size_unit 102890075Sobrien = size_binop (PLUS_EXPR, unpadded_size_unit, size_one_node); 102990075Sobrien 103050397Sobrien /* Record the un-rounded size in the binfo node. But first we check 103150397Sobrien the size of TYPE_BINFO to make sure that BINFO_SIZE is available. */ 103290075Sobrien if (TYPE_BINFO (rli->t) && TREE_VEC_LENGTH (TYPE_BINFO (rli->t)) > 6) 103390075Sobrien { 103490075Sobrien TYPE_BINFO_SIZE (rli->t) = unpadded_size; 103590075Sobrien TYPE_BINFO_SIZE_UNIT (rli->t) = unpadded_size_unit; 103690075Sobrien } 103750397Sobrien 103890075Sobrien /* Round the size up to be a multiple of the required alignment */ 103918334Speter#ifdef ROUND_TYPE_SIZE 104090075Sobrien TYPE_SIZE (rli->t) = ROUND_TYPE_SIZE (rli->t, unpadded_size, 104190075Sobrien TYPE_ALIGN (rli->t)); 104290075Sobrien TYPE_SIZE_UNIT (rli->t) 104390075Sobrien = ROUND_TYPE_SIZE_UNIT (rli->t, unpadded_size_unit, 104490075Sobrien TYPE_ALIGN (rli->t) / BITS_PER_UNIT); 104518334Speter#else 104690075Sobrien TYPE_SIZE (rli->t) = round_up (unpadded_size, TYPE_ALIGN (rli->t)); 104790075Sobrien TYPE_SIZE_UNIT (rli->t) = round_up (unpadded_size_unit, 104890075Sobrien TYPE_ALIGN (rli->t) / BITS_PER_UNIT); 104918334Speter#endif 105018334Speter 105190075Sobrien if (warn_padded && TREE_CONSTANT (unpadded_size) 105290075Sobrien && simple_cst_equal (unpadded_size, TYPE_SIZE (rli->t)) == 0) 105390075Sobrien warning ("padding struct size to alignment boundary"); 105490075Sobrien 105590075Sobrien if (warn_packed && TREE_CODE (rli->t) == RECORD_TYPE 105690075Sobrien && TYPE_PACKED (rli->t) && ! rli->packed_maybe_necessary 105790075Sobrien && TREE_CONSTANT (unpadded_size)) 105890075Sobrien { 105990075Sobrien tree unpacked_size; 106090075Sobrien 106190075Sobrien#ifdef ROUND_TYPE_ALIGN 106290075Sobrien rli->unpacked_align 106390075Sobrien = ROUND_TYPE_ALIGN (rli->t, TYPE_ALIGN (rli->t), rli->unpacked_align); 106490075Sobrien#else 106590075Sobrien rli->unpacked_align = MAX (TYPE_ALIGN (rli->t), rli->unpacked_align); 106690075Sobrien#endif 106790075Sobrien 106890075Sobrien#ifdef ROUND_TYPE_SIZE 106990075Sobrien unpacked_size = ROUND_TYPE_SIZE (rli->t, TYPE_SIZE (rli->t), 107090075Sobrien rli->unpacked_align); 107190075Sobrien#else 107290075Sobrien unpacked_size = round_up (TYPE_SIZE (rli->t), rli->unpacked_align); 107390075Sobrien#endif 107490075Sobrien 107590075Sobrien if (simple_cst_equal (unpacked_size, TYPE_SIZE (rli->t))) 107690075Sobrien { 107790075Sobrien TYPE_PACKED (rli->t) = 0; 107890075Sobrien 107990075Sobrien if (TYPE_NAME (rli->t)) 108090075Sobrien { 108190075Sobrien const char *name; 108290075Sobrien 108390075Sobrien if (TREE_CODE (TYPE_NAME (rli->t)) == IDENTIFIER_NODE) 108490075Sobrien name = IDENTIFIER_POINTER (TYPE_NAME (rli->t)); 108590075Sobrien else 108690075Sobrien name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (rli->t))); 108790075Sobrien 108890075Sobrien if (STRICT_ALIGNMENT) 108990075Sobrien warning ("packed attribute causes inefficient alignment for `%s'", name); 109090075Sobrien else 109190075Sobrien warning ("packed attribute is unnecessary for `%s'", name); 109290075Sobrien } 109390075Sobrien else 109490075Sobrien { 109590075Sobrien if (STRICT_ALIGNMENT) 109690075Sobrien warning ("packed attribute causes inefficient alignment"); 109790075Sobrien else 109890075Sobrien warning ("packed attribute is unnecessary"); 109990075Sobrien } 110090075Sobrien } 110190075Sobrien } 110218334Speter} 110318334Speter 110490075Sobrien/* Compute the TYPE_MODE for the TYPE (which is a RECORD_TYPE). */ 110590075Sobrien 110690075Sobrienvoid 110790075Sobriencompute_record_mode (type) 110890075Sobrien tree type; 110918334Speter{ 111090075Sobrien tree field; 111190075Sobrien enum machine_mode mode = VOIDmode; 111218334Speter 111390075Sobrien /* Most RECORD_TYPEs have BLKmode, so we start off assuming that. 111490075Sobrien However, if possible, we use a mode that fits in a register 111590075Sobrien instead, in order to allow for better optimization down the 111690075Sobrien line. */ 111790075Sobrien TYPE_MODE (type) = BLKmode; 111818334Speter 111990075Sobrien if (! host_integerp (TYPE_SIZE (type), 1)) 112090075Sobrien return; 112150397Sobrien 112290075Sobrien /* A record which has any BLKmode members must itself be 112390075Sobrien BLKmode; it can't go in a register. Unless the member is 112490075Sobrien BLKmode only because it isn't aligned. */ 112590075Sobrien for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 112690075Sobrien { 112790075Sobrien unsigned HOST_WIDE_INT bitpos; 112818334Speter 112990075Sobrien if (TREE_CODE (field) != FIELD_DECL) 113018334Speter continue; 113118334Speter 113290075Sobrien if (TREE_CODE (TREE_TYPE (field)) == ERROR_MARK 113390075Sobrien || (TYPE_MODE (TREE_TYPE (field)) == BLKmode 113490075Sobrien && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field))) 113590075Sobrien || ! host_integerp (bit_position (field), 1) 113690075Sobrien || DECL_SIZE (field) == 0 113790075Sobrien || ! host_integerp (DECL_SIZE (field), 1)) 113890075Sobrien return; 113918334Speter 114090075Sobrien bitpos = int_bit_position (field); 114190075Sobrien 114290075Sobrien /* Must be BLKmode if any field crosses a word boundary, 114390075Sobrien since extract_bit_field can't handle that in registers. */ 114490075Sobrien if (bitpos / BITS_PER_WORD 114590075Sobrien != ((tree_low_cst (DECL_SIZE (field), 1) + bitpos - 1) 114690075Sobrien / BITS_PER_WORD) 114790075Sobrien /* But there is no problem if the field is entire words. */ 114890075Sobrien && tree_low_cst (DECL_SIZE (field), 1) % BITS_PER_WORD != 0) 114990075Sobrien return; 115018334Speter 115190075Sobrien /* If this field is the whole struct, remember its mode so 115290075Sobrien that, say, we can put a double in a class into a DF 115390075Sobrien register instead of forcing it to live in the stack. */ 115490075Sobrien if (simple_cst_equal (TYPE_SIZE (type), DECL_SIZE (field))) 115590075Sobrien mode = DECL_MODE (field); 115618334Speter 115790075Sobrien#ifdef MEMBER_TYPE_FORCES_BLK 115890075Sobrien /* With some targets, eg. c4x, it is sub-optimal 115990075Sobrien to access an aligned BLKmode structure as a scalar. */ 116018334Speter 116190075Sobrien /* On ia64-*-hpux we need to ensure that we don't change the 116290075Sobrien mode of a structure containing a single field or else we 116390075Sobrien will pass it incorrectly. Since a structure with a single 116490075Sobrien field causes mode to get set above we can't allow the 116590075Sobrien check for mode == VOIDmode in this case. Perhaps 116690075Sobrien MEMBER_TYPE_FORCES_BLK should be extended to include mode 116790075Sobrien as an argument and the check could be put in there for c4x. */ 116818334Speter 116990075Sobrien if ((mode == VOIDmode || FUNCTION_ARG_REG_LITTLE_ENDIAN) 117090075Sobrien && MEMBER_TYPE_FORCES_BLK (field)) 117190075Sobrien return; 117290075Sobrien#endif /* MEMBER_TYPE_FORCES_BLK */ 117390075Sobrien } 117418334Speter 117590075Sobrien /* If we only have one real field; use its mode. This only applies to 117690075Sobrien RECORD_TYPE. This does not apply to unions. */ 117790075Sobrien if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode) 117890075Sobrien TYPE_MODE (type) = mode; 117918334Speter else 118090075Sobrien TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); 118118334Speter 118290075Sobrien /* If structure's known alignment is less than what the scalar 118390075Sobrien mode would need, and it matters, then stick with BLKmode. */ 118490075Sobrien if (TYPE_MODE (type) != BLKmode 118590075Sobrien && STRICT_ALIGNMENT 118690075Sobrien && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT 118790075Sobrien || TYPE_ALIGN (type) >= GET_MODE_ALIGNMENT (TYPE_MODE (type)))) 118890075Sobrien { 118990075Sobrien /* If this is the only reason this type is BLKmode, then 119090075Sobrien don't force containing types to be BLKmode. */ 119190075Sobrien TYPE_NO_FORCE_BLK (type) = 1; 119290075Sobrien TYPE_MODE (type) = BLKmode; 119390075Sobrien } 119490075Sobrien} 119590075Sobrien 119690075Sobrien/* Compute TYPE_SIZE and TYPE_ALIGN for TYPE, once it has been laid 119790075Sobrien out. */ 119890075Sobrien 119990075Sobrienstatic void 120090075Sobrienfinalize_type_size (type) 120190075Sobrien tree type; 120290075Sobrien{ 120390075Sobrien /* Normally, use the alignment corresponding to the mode chosen. 120490075Sobrien However, where strict alignment is not required, avoid 120590075Sobrien over-aligning structures, since most compilers do not do this 120690075Sobrien alignment. */ 120790075Sobrien 120890075Sobrien if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode 120990075Sobrien && (STRICT_ALIGNMENT 121090075Sobrien || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE 121190075Sobrien && TREE_CODE (type) != QUAL_UNION_TYPE 121290075Sobrien && TREE_CODE (type) != ARRAY_TYPE))) 121390075Sobrien { 121490075Sobrien TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type)); 121590075Sobrien TYPE_USER_ALIGN (type) = 0; 121690075Sobrien } 121790075Sobrien 121890075Sobrien /* Do machine-dependent extra alignment. */ 121918334Speter#ifdef ROUND_TYPE_ALIGN 122090075Sobrien TYPE_ALIGN (type) 122190075Sobrien = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (type), BITS_PER_UNIT); 122218334Speter#endif 122318334Speter 122490075Sobrien /* If we failed to find a simple way to calculate the unit size 122590075Sobrien of the type, find it by division. */ 122690075Sobrien if (TYPE_SIZE_UNIT (type) == 0 && TYPE_SIZE (type) != 0) 122790075Sobrien /* TYPE_SIZE (type) is computed in bitsizetype. After the division, the 122890075Sobrien result will fit in sizetype. We will get more efficient code using 122990075Sobrien sizetype, so we force a conversion. */ 123090075Sobrien TYPE_SIZE_UNIT (type) 123190075Sobrien = convert (sizetype, 123290075Sobrien size_binop (FLOOR_DIV_EXPR, TYPE_SIZE (type), 123390075Sobrien bitsize_unit_node)); 123490075Sobrien 123590075Sobrien if (TYPE_SIZE (type) != 0) 123690075Sobrien { 123718334Speter#ifdef ROUND_TYPE_SIZE 123890075Sobrien TYPE_SIZE (type) 123990075Sobrien = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type)); 124090075Sobrien TYPE_SIZE_UNIT (type) 124190075Sobrien = ROUND_TYPE_SIZE_UNIT (type, TYPE_SIZE_UNIT (type), 124290075Sobrien TYPE_ALIGN (type) / BITS_PER_UNIT); 124318334Speter#else 124490075Sobrien TYPE_SIZE (type) = round_up (TYPE_SIZE (type), TYPE_ALIGN (type)); 124590075Sobrien TYPE_SIZE_UNIT (type) 124690075Sobrien = round_up (TYPE_SIZE_UNIT (type), TYPE_ALIGN (type) / BITS_PER_UNIT); 124718334Speter#endif 124890075Sobrien } 124990075Sobrien 125090075Sobrien /* Evaluate nonconstant sizes only once, either now or as soon as safe. */ 125190075Sobrien if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 125290075Sobrien TYPE_SIZE (type) = variable_size (TYPE_SIZE (type)); 125390075Sobrien if (TYPE_SIZE_UNIT (type) != 0 125490075Sobrien && TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST) 125590075Sobrien TYPE_SIZE_UNIT (type) = variable_size (TYPE_SIZE_UNIT (type)); 125690075Sobrien 125790075Sobrien /* Also layout any other variants of the type. */ 125890075Sobrien if (TYPE_NEXT_VARIANT (type) 125990075Sobrien || type != TYPE_MAIN_VARIANT (type)) 126090075Sobrien { 126190075Sobrien tree variant; 126290075Sobrien /* Record layout info of this variant. */ 126390075Sobrien tree size = TYPE_SIZE (type); 126490075Sobrien tree size_unit = TYPE_SIZE_UNIT (type); 126590075Sobrien unsigned int align = TYPE_ALIGN (type); 126690075Sobrien unsigned int user_align = TYPE_USER_ALIGN (type); 126790075Sobrien enum machine_mode mode = TYPE_MODE (type); 126890075Sobrien 126990075Sobrien /* Copy it into all variants. */ 127090075Sobrien for (variant = TYPE_MAIN_VARIANT (type); 127190075Sobrien variant != 0; 127290075Sobrien variant = TYPE_NEXT_VARIANT (variant)) 127390075Sobrien { 127490075Sobrien TYPE_SIZE (variant) = size; 127590075Sobrien TYPE_SIZE_UNIT (variant) = size_unit; 127690075Sobrien TYPE_ALIGN (variant) = align; 127790075Sobrien TYPE_USER_ALIGN (variant) = user_align; 127890075Sobrien TYPE_MODE (variant) = mode; 127990075Sobrien } 128090075Sobrien } 128118334Speter} 128290075Sobrien 128390075Sobrien/* Do all of the work required to layout the type indicated by RLI, 128490075Sobrien once the fields have been laid out. This function will call `free' 128590075Sobrien for RLI. */ 128690075Sobrien 128790075Sobrienvoid 128890075Sobrienfinish_record_layout (rli) 128990075Sobrien record_layout_info rli; 129090075Sobrien{ 129190075Sobrien /* Compute the final size. */ 129290075Sobrien finalize_record_size (rli); 129390075Sobrien 129490075Sobrien /* Compute the TYPE_MODE for the record. */ 129590075Sobrien compute_record_mode (rli->t); 129690075Sobrien 129790075Sobrien /* Perform any last tweaks to the TYPE_SIZE, etc. */ 129890075Sobrien finalize_type_size (rli->t); 129990075Sobrien 130090075Sobrien /* Lay out any static members. This is done now because their type 130190075Sobrien may use the record's type. */ 130290075Sobrien while (rli->pending_statics) 130390075Sobrien { 130490075Sobrien layout_decl (TREE_VALUE (rli->pending_statics), 0); 130590075Sobrien rli->pending_statics = TREE_CHAIN (rli->pending_statics); 130690075Sobrien } 130790075Sobrien 130890075Sobrien /* Clean up. */ 130990075Sobrien free (rli); 131090075Sobrien} 131118334Speter 131218334Speter/* Calculate the mode, size, and alignment for TYPE. 131318334Speter For an array type, calculate the element separation as well. 131418334Speter Record TYPE on the chain of permanent or temporary types 131518334Speter so that dbxout will find out about it. 131618334Speter 131718334Speter TYPE_SIZE of a type is nonzero if the type has been laid out already. 131818334Speter layout_type does nothing on such a type. 131918334Speter 132018334Speter If the type is incomplete, its TYPE_SIZE remains zero. */ 132118334Speter 132218334Spetervoid 132318334Speterlayout_type (type) 132418334Speter tree type; 132518334Speter{ 132618334Speter if (type == 0) 132718334Speter abort (); 132818334Speter 132918334Speter /* Do nothing if type has been laid out before. */ 133018334Speter if (TYPE_SIZE (type)) 133118334Speter return; 133218334Speter 133318334Speter switch (TREE_CODE (type)) 133418334Speter { 133518334Speter case LANG_TYPE: 133618334Speter /* This kind of type is the responsibility 133718334Speter of the language-specific code. */ 133818334Speter abort (); 133918334Speter 134090075Sobrien case BOOLEAN_TYPE: /* Used for Java, Pascal, and Chill. */ 134150397Sobrien if (TYPE_PRECISION (type) == 0) 134290075Sobrien TYPE_PRECISION (type) = 1; /* default to one byte/boolean. */ 134350397Sobrien 134490075Sobrien /* ... fall through ... */ 134590075Sobrien 134618334Speter case INTEGER_TYPE: 134718334Speter case ENUMERAL_TYPE: 134850397Sobrien case CHAR_TYPE: 134918334Speter if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST 135018334Speter && tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0) 135118334Speter TREE_UNSIGNED (type) = 1; 135218334Speter 135318334Speter TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type), 135418334Speter MODE_INT); 135590075Sobrien TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 135650397Sobrien TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 135718334Speter break; 135818334Speter 135918334Speter case REAL_TYPE: 136018334Speter TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0); 136190075Sobrien TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 136250397Sobrien TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 136318334Speter break; 136418334Speter 136518334Speter case COMPLEX_TYPE: 136618334Speter TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type)); 136718334Speter TYPE_MODE (type) 136818334Speter = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)), 136918334Speter (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE 137018334Speter ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT), 137118334Speter 0); 137290075Sobrien TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 137350397Sobrien TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 137418334Speter break; 137518334Speter 137690075Sobrien case VECTOR_TYPE: 137790075Sobrien { 137890075Sobrien tree subtype; 137990075Sobrien 138090075Sobrien subtype = TREE_TYPE (type); 138190075Sobrien TREE_UNSIGNED (type) = TREE_UNSIGNED (subtype); 138290075Sobrien TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type))); 138390075Sobrien TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type))); 138490075Sobrien } 138590075Sobrien break; 138690075Sobrien 138718334Speter case VOID_TYPE: 138890075Sobrien /* This is an incomplete type and so doesn't have a size. */ 138918334Speter TYPE_ALIGN (type) = 1; 139090075Sobrien TYPE_USER_ALIGN (type) = 0; 139118334Speter TYPE_MODE (type) = VOIDmode; 139218334Speter break; 139318334Speter 139418334Speter case OFFSET_TYPE: 139590075Sobrien TYPE_SIZE (type) = bitsize_int (POINTER_SIZE); 139650397Sobrien TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT); 139790075Sobrien /* A pointer might be MODE_PARTIAL_INT, 139890075Sobrien but ptrdiff_t must be integral. */ 139990075Sobrien TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0); 140018334Speter break; 140118334Speter 140218334Speter case FUNCTION_TYPE: 140318334Speter case METHOD_TYPE: 140418334Speter TYPE_MODE (type) = mode_for_size (2 * POINTER_SIZE, MODE_INT, 0); 140590075Sobrien TYPE_SIZE (type) = bitsize_int (2 * POINTER_SIZE); 140650397Sobrien TYPE_SIZE_UNIT (type) = size_int ((2 * POINTER_SIZE) / BITS_PER_UNIT); 140718334Speter break; 140818334Speter 140918334Speter case POINTER_TYPE: 141018334Speter case REFERENCE_TYPE: 141190075Sobrien { 141290075Sobrien int nbits = ((TREE_CODE (type) == REFERENCE_TYPE 141390075Sobrien && reference_types_internal) 141490075Sobrien ? GET_MODE_BITSIZE (Pmode) : POINTER_SIZE); 141590075Sobrien 141690075Sobrien TYPE_MODE (type) = nbits == POINTER_SIZE ? ptr_mode : Pmode; 141790075Sobrien TYPE_SIZE (type) = bitsize_int (nbits); 141890075Sobrien TYPE_SIZE_UNIT (type) = size_int (nbits / BITS_PER_UNIT); 141990075Sobrien TREE_UNSIGNED (type) = 1; 142090075Sobrien TYPE_PRECISION (type) = nbits; 142190075Sobrien } 142218334Speter break; 142318334Speter 142418334Speter case ARRAY_TYPE: 142518334Speter { 142690075Sobrien tree index = TYPE_DOMAIN (type); 142790075Sobrien tree element = TREE_TYPE (type); 142818334Speter 142918334Speter build_pointer_type (element); 143018334Speter 143118334Speter /* We need to know both bounds in order to compute the size. */ 143218334Speter if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index) 143318334Speter && TYPE_SIZE (element)) 143418334Speter { 143518334Speter tree ub = TYPE_MAX_VALUE (index); 143618334Speter tree lb = TYPE_MIN_VALUE (index); 143718334Speter tree length; 143852284Sobrien tree element_size; 143918334Speter 144050397Sobrien /* The initial subtraction should happen in the original type so 144150397Sobrien that (possible) negative values are handled appropriately. */ 144218334Speter length = size_binop (PLUS_EXPR, size_one_node, 144390075Sobrien convert (sizetype, 144490075Sobrien fold (build (MINUS_EXPR, 144590075Sobrien TREE_TYPE (lb), 144690075Sobrien ub, lb)))); 144718334Speter 144852284Sobrien /* Special handling for arrays of bits (for Chill). */ 144952284Sobrien element_size = TYPE_SIZE (element); 145090075Sobrien if (TYPE_PACKED (type) && INTEGRAL_TYPE_P (element) 145190075Sobrien && (integer_zerop (TYPE_MAX_VALUE (element)) 145290075Sobrien || integer_onep (TYPE_MAX_VALUE (element))) 145390075Sobrien && host_integerp (TYPE_MIN_VALUE (element), 1)) 145452284Sobrien { 145590075Sobrien HOST_WIDE_INT maxvalue 145690075Sobrien = tree_low_cst (TYPE_MAX_VALUE (element), 1); 145790075Sobrien HOST_WIDE_INT minvalue 145890075Sobrien = tree_low_cst (TYPE_MIN_VALUE (element), 1); 145990075Sobrien 146052284Sobrien if (maxvalue - minvalue == 1 146152284Sobrien && (maxvalue == 1 || maxvalue == 0)) 146252284Sobrien element_size = integer_one_node; 146352284Sobrien } 146450397Sobrien 146590075Sobrien TYPE_SIZE (type) = size_binop (MULT_EXPR, element_size, 146690075Sobrien convert (bitsizetype, length)); 146752284Sobrien 146850397Sobrien /* If we know the size of the element, calculate the total 146950397Sobrien size directly, rather than do some division thing below. 147050397Sobrien This optimization helps Fortran assumed-size arrays 147150397Sobrien (where the size of the array is determined at runtime) 147252284Sobrien substantially. 147352284Sobrien Note that we can't do this in the case where the size of 147452284Sobrien the elements is one bit since TYPE_SIZE_UNIT cannot be 147552284Sobrien set correctly in that case. */ 147690075Sobrien if (TYPE_SIZE_UNIT (element) != 0 && ! integer_onep (element_size)) 147790075Sobrien TYPE_SIZE_UNIT (type) 147890075Sobrien = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (element), length); 147918334Speter } 148018334Speter 148118334Speter /* Now round the alignment and size, 148218334Speter using machine-dependent criteria if any. */ 148318334Speter 148418334Speter#ifdef ROUND_TYPE_ALIGN 148518334Speter TYPE_ALIGN (type) 148618334Speter = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT); 148718334Speter#else 148818334Speter TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT); 148918334Speter#endif 149090075Sobrien TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element); 149118334Speter 149218334Speter#ifdef ROUND_TYPE_SIZE 149318334Speter if (TYPE_SIZE (type) != 0) 149450397Sobrien { 149590075Sobrien tree tmp 149690075Sobrien = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type)); 149790075Sobrien 149850397Sobrien /* If the rounding changed the size of the type, remove any 149950397Sobrien pre-calculated TYPE_SIZE_UNIT. */ 150050397Sobrien if (simple_cst_equal (TYPE_SIZE (type), tmp) != 1) 150150397Sobrien TYPE_SIZE_UNIT (type) = NULL; 150290075Sobrien 150350397Sobrien TYPE_SIZE (type) = tmp; 150450397Sobrien } 150518334Speter#endif 150618334Speter 150718334Speter TYPE_MODE (type) = BLKmode; 150818334Speter if (TYPE_SIZE (type) != 0 150990075Sobrien#ifdef MEMBER_TYPE_FORCES_BLK 151090075Sobrien && ! MEMBER_TYPE_FORCES_BLK (type) 151190075Sobrien#endif 151218334Speter /* BLKmode elements force BLKmode aggregate; 151318334Speter else extract/store fields may lose. */ 151418334Speter && (TYPE_MODE (TREE_TYPE (type)) != BLKmode 151518334Speter || TYPE_NO_FORCE_BLK (TREE_TYPE (type)))) 151618334Speter { 151718334Speter TYPE_MODE (type) 151890075Sobrien = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1); 151918334Speter 152090075Sobrien if (TYPE_MODE (type) != BLKmode 152190075Sobrien && STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT 152290075Sobrien && TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)) 152318334Speter && TYPE_MODE (type) != BLKmode) 152418334Speter { 152518334Speter TYPE_NO_FORCE_BLK (type) = 1; 152618334Speter TYPE_MODE (type) = BLKmode; 152718334Speter } 152818334Speter } 152918334Speter break; 153018334Speter } 153118334Speter 153218334Speter case RECORD_TYPE: 153390075Sobrien case UNION_TYPE: 153490075Sobrien case QUAL_UNION_TYPE: 153590075Sobrien { 153690075Sobrien tree field; 153790075Sobrien record_layout_info rli; 153850397Sobrien 153990075Sobrien /* Initialize the layout information. */ 154090075Sobrien rli = start_record_layout (type); 154118334Speter 154290075Sobrien /* If this is a QUAL_UNION_TYPE, we want to process the fields 154390075Sobrien in the reverse order in building the COND_EXPR that denotes 154490075Sobrien its size. We reverse them again later. */ 154590075Sobrien if (TREE_CODE (type) == QUAL_UNION_TYPE) 154690075Sobrien TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type)); 154718334Speter 154890075Sobrien /* Place all the fields. */ 154990075Sobrien for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 155090075Sobrien place_field (rli, field); 155118334Speter 155290075Sobrien if (TREE_CODE (type) == QUAL_UNION_TYPE) 155390075Sobrien TYPE_FIELDS (type) = nreverse (TYPE_FIELDS (type)); 155418334Speter 155590075Sobrien if (lang_adjust_rli) 155690075Sobrien (*lang_adjust_rli) (rli); 155718334Speter 155890075Sobrien /* Finish laying out the record. */ 155990075Sobrien finish_record_layout (rli); 156090075Sobrien } 156118334Speter break; 156218334Speter 156390075Sobrien case SET_TYPE: /* Used by Chill and Pascal. */ 156418334Speter if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST 156518334Speter || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST) 156690075Sobrien abort (); 156718334Speter else 156818334Speter { 156918334Speter#ifndef SET_WORD_SIZE 157018334Speter#define SET_WORD_SIZE BITS_PER_WORD 157118334Speter#endif 157290075Sobrien unsigned int alignment 157390075Sobrien = set_alignment ? set_alignment : SET_WORD_SIZE; 157450397Sobrien int size_in_bits 157550397Sobrien = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) 157650397Sobrien - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1); 157718334Speter int rounded_size 157818334Speter = ((size_in_bits + alignment - 1) / alignment) * alignment; 157990075Sobrien 158090075Sobrien if (rounded_size > (int) alignment) 158118334Speter TYPE_MODE (type) = BLKmode; 158218334Speter else 158318334Speter TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1); 158490075Sobrien 158590075Sobrien TYPE_SIZE (type) = bitsize_int (rounded_size); 158650397Sobrien TYPE_SIZE_UNIT (type) = size_int (rounded_size / BITS_PER_UNIT); 158718334Speter TYPE_ALIGN (type) = alignment; 158890075Sobrien TYPE_USER_ALIGN (type) = 0; 158918334Speter TYPE_PRECISION (type) = size_in_bits; 159018334Speter } 159118334Speter break; 159218334Speter 159318334Speter case FILE_TYPE: 159418334Speter /* The size may vary in different languages, so the language front end 159518334Speter should fill in the size. */ 159618334Speter TYPE_ALIGN (type) = BIGGEST_ALIGNMENT; 159790075Sobrien TYPE_USER_ALIGN (type) = 0; 159818334Speter TYPE_MODE (type) = BLKmode; 159918334Speter break; 160018334Speter 160118334Speter default: 160218334Speter abort (); 160350397Sobrien } 160450397Sobrien 160590075Sobrien /* Compute the final TYPE_SIZE, TYPE_ALIGN, etc. for TYPE. For 160690075Sobrien records and unions, finish_record_layout already called this 160790075Sobrien function. */ 160890075Sobrien if (TREE_CODE (type) != RECORD_TYPE 160990075Sobrien && TREE_CODE (type) != UNION_TYPE 161090075Sobrien && TREE_CODE (type) != QUAL_UNION_TYPE) 161190075Sobrien finalize_type_size (type); 161250397Sobrien 161390075Sobrien /* If this type is created before sizetype has been permanently set, 161490075Sobrien record it so set_sizetype can fix it up. */ 161590075Sobrien if (! sizetype_set) 161690075Sobrien early_type_list = tree_cons (NULL_TREE, type, early_type_list); 161718334Speter 161890075Sobrien /* If an alias set has been set for this aggregate when it was incomplete, 161990075Sobrien force it into alias set 0. 162090075Sobrien This is too conservative, but we cannot call record_component_aliases 162190075Sobrien here because some frontends still change the aggregates after 162290075Sobrien layout_type. */ 162390075Sobrien if (AGGREGATE_TYPE_P (type) && TYPE_ALIAS_SET_KNOWN_P (type)) 162490075Sobrien TYPE_ALIAS_SET (type) = 0; 162518334Speter} 162618334Speter 162718334Speter/* Create and return a type for signed integers of PRECISION bits. */ 162818334Speter 162918334Spetertree 163018334Spetermake_signed_type (precision) 163118334Speter int precision; 163218334Speter{ 163390075Sobrien tree type = make_node (INTEGER_TYPE); 163418334Speter 163518334Speter TYPE_PRECISION (type) = precision; 163618334Speter 163790075Sobrien fixup_signed_type (type); 163818334Speter return type; 163918334Speter} 164018334Speter 164118334Speter/* Create and return a type for unsigned integers of PRECISION bits. */ 164218334Speter 164318334Spetertree 164418334Spetermake_unsigned_type (precision) 164518334Speter int precision; 164618334Speter{ 164790075Sobrien tree type = make_node (INTEGER_TYPE); 164818334Speter 164918334Speter TYPE_PRECISION (type) = precision; 165018334Speter 165118334Speter fixup_unsigned_type (type); 165218334Speter return type; 165318334Speter} 165490075Sobrien 165590075Sobrien/* Initialize sizetype and bitsizetype to a reasonable and temporary 165690075Sobrien value to enable integer types to be created. */ 165718334Speter 165890075Sobrienvoid 165990075Sobrieninitialize_sizetypes () 166090075Sobrien{ 166190075Sobrien tree t = make_node (INTEGER_TYPE); 166290075Sobrien 166390075Sobrien /* Set this so we do something reasonable for the build_int_2 calls 166490075Sobrien below. */ 166590075Sobrien integer_type_node = t; 166690075Sobrien 166790075Sobrien TYPE_MODE (t) = SImode; 166890075Sobrien TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode); 166990075Sobrien TYPE_USER_ALIGN (t) = 0; 167090075Sobrien TYPE_SIZE (t) = build_int_2 (GET_MODE_BITSIZE (SImode), 0); 167190075Sobrien TYPE_SIZE_UNIT (t) = build_int_2 (GET_MODE_SIZE (SImode), 0); 167290075Sobrien TREE_UNSIGNED (t) = 1; 167390075Sobrien TYPE_PRECISION (t) = GET_MODE_BITSIZE (SImode); 167490075Sobrien TYPE_MIN_VALUE (t) = build_int_2 (0, 0); 167590075Sobrien TYPE_IS_SIZETYPE (t) = 1; 167690075Sobrien 167790075Sobrien /* 1000 avoids problems with possible overflow and is certainly 167890075Sobrien larger than any size value we'd want to be storing. */ 167990075Sobrien TYPE_MAX_VALUE (t) = build_int_2 (1000, 0); 168090075Sobrien 168190075Sobrien /* These two must be different nodes because of the caching done in 168290075Sobrien size_int_wide. */ 168390075Sobrien sizetype = t; 168490075Sobrien bitsizetype = copy_node (t); 168590075Sobrien integer_type_node = 0; 168690075Sobrien} 168790075Sobrien 168850397Sobrien/* Set sizetype to TYPE, and initialize *sizetype accordingly. 168950397Sobrien Also update the type of any standard type's sizes made so far. */ 169050397Sobrien 169150397Sobrienvoid 169250397Sobrienset_sizetype (type) 169350397Sobrien tree type; 169450397Sobrien{ 169590075Sobrien int oprecision = TYPE_PRECISION (type); 169650397Sobrien /* The *bitsizetype types use a precision that avoids overflows when 169790075Sobrien calculating signed sizes / offsets in bits. However, when 169890075Sobrien cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit 169990075Sobrien precision. */ 170090075Sobrien int precision = MIN (oprecision + BITS_PER_UNIT_LOG + 1, 170190075Sobrien 2 * HOST_BITS_PER_WIDE_INT); 170290075Sobrien unsigned int i; 170390075Sobrien tree t; 170450397Sobrien 170590075Sobrien if (sizetype_set) 170690075Sobrien abort (); 170750397Sobrien 170890075Sobrien /* Make copies of nodes since we'll be setting TYPE_IS_SIZETYPE. */ 170990075Sobrien sizetype = copy_node (type); 171090075Sobrien TYPE_DOMAIN (sizetype) = type; 171190075Sobrien TYPE_IS_SIZETYPE (sizetype) = 1; 171290075Sobrien bitsizetype = make_node (INTEGER_TYPE); 171390075Sobrien TYPE_NAME (bitsizetype) = TYPE_NAME (type); 171450397Sobrien TYPE_PRECISION (bitsizetype) = precision; 171590075Sobrien TYPE_IS_SIZETYPE (bitsizetype) = 1; 171690075Sobrien 171750397Sobrien if (TREE_UNSIGNED (type)) 171850397Sobrien fixup_unsigned_type (bitsizetype); 171950397Sobrien else 172050397Sobrien fixup_signed_type (bitsizetype); 172190075Sobrien 172250397Sobrien layout_type (bitsizetype); 172350397Sobrien 172450397Sobrien if (TREE_UNSIGNED (type)) 172550397Sobrien { 172650397Sobrien usizetype = sizetype; 172750397Sobrien ubitsizetype = bitsizetype; 172890075Sobrien ssizetype = copy_node (make_signed_type (oprecision)); 172990075Sobrien sbitsizetype = copy_node (make_signed_type (precision)); 173050397Sobrien } 173150397Sobrien else 173250397Sobrien { 173350397Sobrien ssizetype = sizetype; 173450397Sobrien sbitsizetype = bitsizetype; 173590075Sobrien usizetype = copy_node (make_unsigned_type (oprecision)); 173690075Sobrien ubitsizetype = copy_node (make_unsigned_type (precision)); 173750397Sobrien } 173890075Sobrien 173990075Sobrien TYPE_NAME (bitsizetype) = get_identifier ("bit_size_type"); 174090075Sobrien 174190075Sobrien /* Show is a sizetype, is a main type, and has no pointers to it. */ 174290075Sobrien for (i = 0; i < ARRAY_SIZE (sizetype_tab); i++) 174390075Sobrien { 174490075Sobrien TYPE_IS_SIZETYPE (sizetype_tab[i]) = 1; 174590075Sobrien TYPE_MAIN_VARIANT (sizetype_tab[i]) = sizetype_tab[i]; 174690075Sobrien TYPE_NEXT_VARIANT (sizetype_tab[i]) = 0; 174790075Sobrien TYPE_POINTER_TO (sizetype_tab[i]) = 0; 174890075Sobrien TYPE_REFERENCE_TO (sizetype_tab[i]) = 0; 174990075Sobrien } 175090075Sobrien 175190075Sobrien ggc_add_tree_root ((tree *) &sizetype_tab, 175290075Sobrien sizeof sizetype_tab / sizeof (tree)); 175390075Sobrien 175490075Sobrien /* Go down each of the types we already made and set the proper type 175590075Sobrien for the sizes in them. */ 175690075Sobrien for (t = early_type_list; t != 0; t = TREE_CHAIN (t)) 175790075Sobrien { 175890075Sobrien if (TREE_CODE (TREE_VALUE (t)) != INTEGER_TYPE) 175990075Sobrien abort (); 176090075Sobrien 176190075Sobrien TREE_TYPE (TYPE_SIZE (TREE_VALUE (t))) = bitsizetype; 176290075Sobrien TREE_TYPE (TYPE_SIZE_UNIT (TREE_VALUE (t))) = sizetype; 176390075Sobrien } 176490075Sobrien 176590075Sobrien early_type_list = 0; 176690075Sobrien sizetype_set = 1; 176750397Sobrien} 176890075Sobrien 176918334Speter/* Set the extreme values of TYPE based on its precision in bits, 177018334Speter then lay it out. Used when make_signed_type won't do 177118334Speter because the tree code is not INTEGER_TYPE. 177218334Speter E.g. for Pascal, when the -fsigned-char option is given. */ 177318334Speter 177418334Spetervoid 177518334Speterfixup_signed_type (type) 177618334Speter tree type; 177718334Speter{ 177890075Sobrien int precision = TYPE_PRECISION (type); 177918334Speter 178090075Sobrien /* We can not represent properly constants greater then 178190075Sobrien 2 * HOST_BITS_PER_WIDE_INT, still we need the types 178290075Sobrien as they are used by i386 vector extensions and friends. */ 178390075Sobrien if (precision > HOST_BITS_PER_WIDE_INT * 2) 178490075Sobrien precision = HOST_BITS_PER_WIDE_INT * 2; 178590075Sobrien 178618334Speter TYPE_MIN_VALUE (type) 178718334Speter = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 178818334Speter ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)), 178918334Speter (((HOST_WIDE_INT) (-1) 179018334Speter << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 179118334Speter ? precision - HOST_BITS_PER_WIDE_INT - 1 179218334Speter : 0)))); 179318334Speter TYPE_MAX_VALUE (type) 179418334Speter = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 179518334Speter ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1), 179618334Speter (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 179718334Speter ? (((HOST_WIDE_INT) 1 179818334Speter << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1 179918334Speter : 0)); 180018334Speter 180118334Speter TREE_TYPE (TYPE_MIN_VALUE (type)) = type; 180218334Speter TREE_TYPE (TYPE_MAX_VALUE (type)) = type; 180318334Speter 180418334Speter /* Lay out the type: set its alignment, size, etc. */ 180518334Speter layout_type (type); 180618334Speter} 180718334Speter 180818334Speter/* Set the extreme values of TYPE based on its precision in bits, 180918334Speter then lay it out. This is used both in `make_unsigned_type' 181018334Speter and for enumeral types. */ 181118334Speter 181218334Spetervoid 181318334Speterfixup_unsigned_type (type) 181418334Speter tree type; 181518334Speter{ 181690075Sobrien int precision = TYPE_PRECISION (type); 181718334Speter 181890075Sobrien /* We can not represent properly constants greater then 181990075Sobrien 2 * HOST_BITS_PER_WIDE_INT, still we need the types 182090075Sobrien as they are used by i386 vector extensions and friends. */ 182190075Sobrien if (precision > HOST_BITS_PER_WIDE_INT * 2) 182290075Sobrien precision = HOST_BITS_PER_WIDE_INT * 2; 182390075Sobrien 182418334Speter TYPE_MIN_VALUE (type) = build_int_2 (0, 0); 182518334Speter TYPE_MAX_VALUE (type) 182618334Speter = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0 182718334Speter ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1, 182818334Speter precision - HOST_BITS_PER_WIDE_INT > 0 182918334Speter ? ((unsigned HOST_WIDE_INT) ~0 183018334Speter >> (HOST_BITS_PER_WIDE_INT 183118334Speter - (precision - HOST_BITS_PER_WIDE_INT))) 183218334Speter : 0); 183318334Speter TREE_TYPE (TYPE_MIN_VALUE (type)) = type; 183418334Speter TREE_TYPE (TYPE_MAX_VALUE (type)) = type; 183518334Speter 183618334Speter /* Lay out the type: set its alignment, size, etc. */ 183718334Speter layout_type (type); 183818334Speter} 183918334Speter 184018334Speter/* Find the best machine mode to use when referencing a bit field of length 184118334Speter BITSIZE bits starting at BITPOS. 184218334Speter 184318334Speter The underlying object is known to be aligned to a boundary of ALIGN bits. 184418334Speter If LARGEST_MODE is not VOIDmode, it means that we should not use a mode 184518334Speter larger than LARGEST_MODE (usually SImode). 184618334Speter 184718334Speter If no mode meets all these conditions, we return VOIDmode. Otherwise, if 184818334Speter VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest 184918334Speter mode meeting these conditions. 185018334Speter 185118334Speter Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return 185218334Speter the largest mode (but a mode no wider than UNITS_PER_WORD) that meets 185318334Speter all the conditions. */ 185418334Speter 185518334Speterenum machine_mode 185618334Speterget_best_mode (bitsize, bitpos, align, largest_mode, volatilep) 185718334Speter int bitsize, bitpos; 185890075Sobrien unsigned int align; 185918334Speter enum machine_mode largest_mode; 186018334Speter int volatilep; 186118334Speter{ 186218334Speter enum machine_mode mode; 186390075Sobrien unsigned int unit = 0; 186418334Speter 186518334Speter /* Find the narrowest integer mode that contains the bit field. */ 186618334Speter for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode; 186718334Speter mode = GET_MODE_WIDER_MODE (mode)) 186818334Speter { 186918334Speter unit = GET_MODE_BITSIZE (mode); 187050397Sobrien if ((bitpos % unit) + bitsize <= unit) 187118334Speter break; 187218334Speter } 187318334Speter 187490075Sobrien if (mode == VOIDmode 187518334Speter /* It is tempting to omit the following line 187618334Speter if STRICT_ALIGNMENT is true. 187718334Speter But that is incorrect, since if the bitfield uses part of 3 bytes 187818334Speter and we use a 4-byte mode, we could get a spurious segv 187918334Speter if the extra 4th byte is past the end of memory. 188018334Speter (Though at least one Unix compiler ignores this problem: 188118334Speter that on the Sequent 386 machine. */ 188218334Speter || MIN (unit, BIGGEST_ALIGNMENT) > align 188318334Speter || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode))) 188418334Speter return VOIDmode; 188518334Speter 188618334Speter if (SLOW_BYTE_ACCESS && ! volatilep) 188718334Speter { 188818334Speter enum machine_mode wide_mode = VOIDmode, tmode; 188918334Speter 189018334Speter for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode; 189118334Speter tmode = GET_MODE_WIDER_MODE (tmode)) 189218334Speter { 189318334Speter unit = GET_MODE_BITSIZE (tmode); 189418334Speter if (bitpos / unit == (bitpos + bitsize - 1) / unit 189518334Speter && unit <= BITS_PER_WORD 189618334Speter && unit <= MIN (align, BIGGEST_ALIGNMENT) 189718334Speter && (largest_mode == VOIDmode 189818334Speter || unit <= GET_MODE_BITSIZE (largest_mode))) 189918334Speter wide_mode = tmode; 190018334Speter } 190118334Speter 190218334Speter if (wide_mode != VOIDmode) 190318334Speter return wide_mode; 190418334Speter } 190518334Speter 190618334Speter return mode; 190718334Speter} 190818334Speter 190990075Sobrien/* This function is run once to initialize stor-layout.c. */ 191018334Speter 191118334Spetervoid 191290075Sobrieninit_stor_layout_once () 191318334Speter{ 191490075Sobrien ggc_add_tree_root (&pending_sizes, 1); 191518334Speter} 1916