| 1 | /* C-compiler utilities for types and variables storage layout |
| 2 | Copyright (C) 1987, 1988, 1992 Free Software Foundation, Inc. |
| 3 | |
| 4 | This file is part of GNU CC. |
| 5 | |
| 6 | GNU CC is free software; you can redistribute it and/or modify |
| 7 | it under the terms of the GNU General Public License as published by |
| 8 | the Free Software Foundation; either version 2, or (at your option) |
| 9 | any later version. |
| 10 | |
| 11 | GNU CC is distributed in the hope that it will be useful, |
| 12 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 14 | GNU General Public License for more details. |
| 15 | |
| 16 | You should have received a copy of the GNU General Public License |
| 17 | along with GNU CC; see the file COPYING. If not, write to |
| 18 | the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ |
| 19 | |
| 20 | |
| 21 | #include "config.h" |
| 22 | #include <stdio.h> |
| 23 | |
| 24 | #include "tree.h" |
| 25 | #include "function.h" |
| 26 | |
| 27 | #define CEIL(x,y) (((x) + (y) - 1) / (y)) |
| 28 | |
| 29 | /* Data type for the expressions representing sizes of data types. |
| 30 | It is the first integer type laid out. |
| 31 | In C, this is int. */ |
| 32 | |
| 33 | tree sizetype; |
| 34 | |
| 35 | /* An integer constant with value 0 whose type is sizetype. */ |
| 36 | |
| 37 | tree size_zero_node; |
| 38 | |
| 39 | /* An integer constant with value 1 whose type is sizetype. */ |
| 40 | |
| 41 | tree size_one_node; |
| 42 | |
| 43 | /* If nonzero, this is an upper limit on alignment of structure fields. |
| 44 | The value is measured in bits. */ |
| 45 | int maximum_field_alignment; |
| 46 | |
| 47 | #define GET_MODE_ALIGNMENT(MODE) \ |
| 48 | MIN (BIGGEST_ALIGNMENT, \ |
| 49 | MAX (1, (GET_MODE_UNIT_SIZE (MODE) * BITS_PER_UNIT))) |
| 50 | \f |
| 51 | /* SAVE_EXPRs for sizes of types and decls, waiting to be expanded. */ |
| 52 | |
| 53 | static tree pending_sizes; |
| 54 | |
| 55 | /* Nonzero means cannot safely call expand_expr now, |
| 56 | so put variable sizes onto `pending_sizes' instead. */ |
| 57 | |
| 58 | int immediate_size_expand; |
| 59 | |
| 60 | tree |
| 61 | get_pending_sizes () |
| 62 | { |
| 63 | tree chain = pending_sizes; |
| 64 | tree t; |
| 65 | |
| 66 | /* Put each SAVE_EXPR into the current function. */ |
| 67 | for (t = chain; t; t = TREE_CHAIN (t)) |
| 68 | SAVE_EXPR_CONTEXT (TREE_VALUE (t)) = current_function_decl; |
| 69 | pending_sizes = 0; |
| 70 | return chain; |
| 71 | } |
| 72 | |
| 73 | /* Given a size SIZE that isn't constant, return a SAVE_EXPR |
| 74 | to serve as the actual size-expression for a type or decl. */ |
| 75 | |
| 76 | tree |
| 77 | variable_size (size) |
| 78 | tree size; |
| 79 | { |
| 80 | size = save_expr (size); |
| 81 | |
| 82 | if (global_bindings_p ()) |
| 83 | { |
| 84 | if (TREE_CONSTANT (size)) |
| 85 | error ("type size can't be explicitly evaluated"); |
| 86 | else |
| 87 | error ("variable-size type declared outside of any function"); |
| 88 | |
| 89 | return size_int (1); |
| 90 | } |
| 91 | |
| 92 | if (immediate_size_expand) |
| 93 | /* NULL_RTX is not defined; neither is the rtx type. |
| 94 | Also, we would like to pass const0_rtx here, but don't have it. */ |
| 95 | expand_expr (size, expand_expr (integer_zero_node, NULL_PTR, VOIDmode, 0), |
| 96 | VOIDmode, 0); |
| 97 | else |
| 98 | pending_sizes = tree_cons (NULL_TREE, size, pending_sizes); |
| 99 | |
| 100 | return size; |
| 101 | } |
| 102 | \f |
| 103 | #ifndef MAX_FIXED_MODE_SIZE |
| 104 | #define MAX_FIXED_MODE_SIZE GET_MODE_BITSIZE (DImode) |
| 105 | #endif |
| 106 | |
| 107 | /* Return the machine mode to use for a nonscalar of SIZE bits. |
| 108 | The mode must be in class CLASS, and have exactly that many bits. |
| 109 | If LIMIT is nonzero, modes of wider than MAX_FIXED_MODE_SIZE will not |
| 110 | be used. */ |
| 111 | |
| 112 | enum machine_mode |
| 113 | mode_for_size (size, class, limit) |
| 114 | unsigned int size; |
| 115 | enum mode_class class; |
| 116 | int limit; |
| 117 | { |
| 118 | register enum machine_mode mode; |
| 119 | |
| 120 | if (limit && size > MAX_FIXED_MODE_SIZE) |
| 121 | return BLKmode; |
| 122 | |
| 123 | /* Get the last mode which has this size, in the specified class. */ |
| 124 | for (mode = GET_CLASS_NARROWEST_MODE (class); mode != VOIDmode; |
| 125 | mode = GET_MODE_WIDER_MODE (mode)) |
| 126 | if (GET_MODE_BITSIZE (mode) == size) |
| 127 | return mode; |
| 128 | |
| 129 | return BLKmode; |
| 130 | } |
| 131 | |
| 132 | /* Return the value of VALUE, rounded up to a multiple of DIVISOR. */ |
| 133 | |
| 134 | tree |
| 135 | round_up (value, divisor) |
| 136 | tree value; |
| 137 | int divisor; |
| 138 | { |
| 139 | return size_binop (MULT_EXPR, |
| 140 | size_binop (CEIL_DIV_EXPR, value, size_int (divisor)), |
| 141 | size_int (divisor)); |
| 142 | } |
| 143 | \f |
| 144 | /* Set the size, mode and alignment of a ..._DECL node. |
| 145 | TYPE_DECL does need this for C++. |
| 146 | Note that LABEL_DECL and CONST_DECL nodes do not need this, |
| 147 | and FUNCTION_DECL nodes have them set up in a special (and simple) way. |
| 148 | Don't call layout_decl for them. |
| 149 | |
| 150 | KNOWN_ALIGN is the amount of alignment we can assume this |
| 151 | decl has with no special effort. It is relevant only for FIELD_DECLs |
| 152 | and depends on the previous fields. |
| 153 | All that matters about KNOWN_ALIGN is which powers of 2 divide it. |
| 154 | If KNOWN_ALIGN is 0, it means, "as much alignment as you like": |
| 155 | the record will be aligned to suit. */ |
| 156 | |
| 157 | void |
| 158 | layout_decl (decl, known_align) |
| 159 | tree decl; |
| 160 | unsigned known_align; |
| 161 | { |
| 162 | register tree type = TREE_TYPE (decl); |
| 163 | register enum tree_code code = TREE_CODE (decl); |
| 164 | int spec_size = DECL_FIELD_SIZE (decl); |
| 165 | |
| 166 | if (code == CONST_DECL) |
| 167 | return; |
| 168 | |
| 169 | if (code != VAR_DECL && code != PARM_DECL && code != RESULT_DECL |
| 170 | && code != FIELD_DECL && code != TYPE_DECL) |
| 171 | abort (); |
| 172 | |
| 173 | if (type == error_mark_node) |
| 174 | { |
| 175 | type = void_type_node; |
| 176 | spec_size = 0; |
| 177 | } |
| 178 | |
| 179 | /* Usually the size and mode come from the data type without change. */ |
| 180 | |
| 181 | DECL_MODE (decl) = TYPE_MODE (type); |
| 182 | DECL_SIZE (decl) = TYPE_SIZE (type); |
| 183 | TREE_UNSIGNED (decl) = TREE_UNSIGNED (type); |
| 184 | |
| 185 | if (code == FIELD_DECL && DECL_BIT_FIELD (decl)) |
| 186 | { |
| 187 | /* This is a bit-field. We don't know how to handle |
| 188 | them except for integers and enums, and front end should |
| 189 | never generate them otherwise. */ |
| 190 | |
| 191 | if (! (TREE_CODE (type) == INTEGER_TYPE |
| 192 | || TREE_CODE (type) == ENUMERAL_TYPE)) |
| 193 | abort (); |
| 194 | |
| 195 | if (spec_size == 0 && DECL_NAME (decl) != 0) |
| 196 | abort (); |
| 197 | |
| 198 | /* Size is specified number of bits. */ |
| 199 | DECL_SIZE (decl) = size_int (spec_size); |
| 200 | } |
| 201 | /* Force alignment required for the data type. |
| 202 | But if the decl itself wants greater alignment, don't override that. |
| 203 | Likewise, if the decl is packed, don't override it. */ |
| 204 | else if (DECL_ALIGN (decl) == 0 |
| 205 | || (! DECL_PACKED (decl) && TYPE_ALIGN (type) > DECL_ALIGN (decl))) |
| 206 | DECL_ALIGN (decl) = TYPE_ALIGN (type); |
| 207 | |
| 208 | /* See if we can use an ordinary integer mode for a bit-field. */ |
| 209 | /* Conditions are: a fixed size that is correct for another mode |
| 210 | and occupying a complete byte or bytes on proper boundary. */ |
| 211 | if (code == FIELD_DECL) |
| 212 | { |
| 213 | DECL_BIT_FIELD_TYPE (decl) = DECL_BIT_FIELD (decl) ? type : 0; |
| 214 | if (maximum_field_alignment != 0) |
| 215 | DECL_ALIGN (decl) = MIN (DECL_ALIGN (decl), maximum_field_alignment); |
| 216 | } |
| 217 | |
| 218 | if (DECL_BIT_FIELD (decl) |
| 219 | && TYPE_SIZE (type) != 0 |
| 220 | && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST) |
| 221 | { |
| 222 | register enum machine_mode xmode |
| 223 | = mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl)), MODE_INT, 1); |
| 224 | |
| 225 | if (xmode != BLKmode |
| 226 | && known_align % GET_MODE_ALIGNMENT (xmode) == 0) |
| 227 | { |
| 228 | DECL_ALIGN (decl) = MAX (GET_MODE_ALIGNMENT (xmode), |
| 229 | DECL_ALIGN (decl)); |
| 230 | DECL_MODE (decl) = xmode; |
| 231 | DECL_SIZE (decl) = size_int (GET_MODE_BITSIZE (xmode)); |
| 232 | /* This no longer needs to be accessed as a bit field. */ |
| 233 | DECL_BIT_FIELD (decl) = 0; |
| 234 | } |
| 235 | } |
| 236 | |
| 237 | /* Evaluate nonconstant size only once, either now or as soon as safe. */ |
| 238 | if (DECL_SIZE (decl) != 0 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST) |
| 239 | DECL_SIZE (decl) = variable_size (DECL_SIZE (decl)); |
| 240 | } |
| 241 | \f |
| 242 | /* Lay out a RECORD_TYPE type (a C struct). |
| 243 | This means laying out the fields, determining their positions, |
| 244 | and computing the overall size and required alignment of the record. |
| 245 | Note that if you set the TYPE_ALIGN before calling this |
| 246 | then the struct is aligned to at least that boundary. |
| 247 | |
| 248 | If the type has basetypes, you must call layout_basetypes |
| 249 | before calling this function. |
| 250 | |
| 251 | The return value is a list of static members of the record. |
| 252 | They still need to be laid out. */ |
| 253 | |
| 254 | static tree |
| 255 | layout_record (rec) |
| 256 | tree rec; |
| 257 | { |
| 258 | register tree field; |
| 259 | #ifdef STRUCTURE_SIZE_BOUNDARY |
| 260 | unsigned record_align = MAX (STRUCTURE_SIZE_BOUNDARY, TYPE_ALIGN (rec)); |
| 261 | #else |
| 262 | unsigned record_align = MAX (BITS_PER_UNIT, TYPE_ALIGN (rec)); |
| 263 | #endif |
| 264 | /* These must be laid out *after* the record is. */ |
| 265 | tree pending_statics = NULL_TREE; |
| 266 | /* Record size so far is CONST_SIZE + VAR_SIZE bits, |
| 267 | where CONST_SIZE is an integer |
| 268 | and VAR_SIZE is a tree expression. |
| 269 | If VAR_SIZE is null, the size is just CONST_SIZE. |
| 270 | Naturally we try to avoid using VAR_SIZE. */ |
| 271 | register int const_size = 0; |
| 272 | register tree var_size = 0; |
| 273 | /* Once we start using VAR_SIZE, this is the maximum alignment |
| 274 | that we know VAR_SIZE has. */ |
| 275 | register int var_align = BITS_PER_UNIT; |
| 276 | |
| 277 | |
| 278 | for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field)) |
| 279 | { |
| 280 | register int desired_align; |
| 281 | |
| 282 | /* If FIELD is static, then treat it like a separate variable, |
| 283 | not really like a structure field. |
| 284 | If it is a FUNCTION_DECL, it's a method. |
| 285 | In both cases, all we do is lay out the decl, |
| 286 | and we do it *after* the record is laid out. */ |
| 287 | |
| 288 | if (TREE_STATIC (field)) |
| 289 | { |
| 290 | pending_statics = tree_cons (NULL_TREE, field, pending_statics); |
| 291 | continue; |
| 292 | } |
| 293 | /* Enumerators and enum types which are local to this class need not |
| 294 | be laid out. Likewise for initialized constant fields. */ |
| 295 | if (TREE_CODE (field) != FIELD_DECL) |
| 296 | continue; |
| 297 | |
| 298 | /* Lay out the field so we know what alignment it needs. |
| 299 | For KNOWN_ALIGN, pass the number of bits from start of record |
| 300 | or some divisor of it. */ |
| 301 | |
| 302 | /* For a packed field, use the alignment as specified, |
| 303 | disregarding what the type would want. */ |
| 304 | if (DECL_PACKED (field)) |
| 305 | desired_align = DECL_ALIGN (field); |
| 306 | layout_decl (field, var_size ? var_align : const_size); |
| 307 | if (! DECL_PACKED (field)) |
| 308 | desired_align = DECL_ALIGN (field); |
| 309 | /* Some targets (i.e. VMS) limit struct field alignment |
| 310 | to a lower boundary than alignment of variables. */ |
| 311 | #ifdef BIGGEST_FIELD_ALIGNMENT |
| 312 | desired_align = MIN (desired_align, BIGGEST_FIELD_ALIGNMENT); |
| 313 | #endif |
| 314 | |
| 315 | /* Record must have at least as much alignment as any field. |
| 316 | Otherwise, the alignment of the field within the record |
| 317 | is meaningless. */ |
| 318 | |
| 319 | #ifndef PCC_BITFIELD_TYPE_MATTERS |
| 320 | record_align = MAX (record_align, desired_align); |
| 321 | #else |
| 322 | if (PCC_BITFIELD_TYPE_MATTERS && TREE_TYPE (field) != error_mark_node |
| 323 | && DECL_BIT_FIELD_TYPE (field) |
| 324 | && ! integer_zerop (TYPE_SIZE (TREE_TYPE (field)))) |
| 325 | { |
| 326 | /* For these machines, a zero-length field does not |
| 327 | affect the alignment of the structure as a whole. |
| 328 | It does, however, affect the alignment of the next field |
| 329 | within the structure. */ |
| 330 | if (! integer_zerop (DECL_SIZE (field))) |
| 331 | record_align = MAX (record_align, desired_align); |
| 332 | else if (! DECL_PACKED (field)) |
| 333 | desired_align = TYPE_ALIGN (TREE_TYPE (field)); |
| 334 | /* A named bit field of declared type `int' |
| 335 | forces the entire structure to have `int' alignment. */ |
| 336 | if (DECL_NAME (field) != 0) |
| 337 | { |
| 338 | int type_align = TYPE_ALIGN (TREE_TYPE (field)); |
| 339 | if (maximum_field_alignment != 0) |
| 340 | type_align = MIN (type_align, maximum_field_alignment); |
| 341 | |
| 342 | record_align = MAX (record_align, type_align); |
| 343 | } |
| 344 | } |
| 345 | else |
| 346 | record_align = MAX (record_align, desired_align); |
| 347 | #endif |
| 348 | |
| 349 | /* Does this field automatically have alignment it needs |
| 350 | by virtue of the fields that precede it and the record's |
| 351 | own alignment? */ |
| 352 | |
| 353 | if (const_size % desired_align != 0 |
| 354 | || (var_align % desired_align != 0 |
| 355 | && var_size != 0)) |
| 356 | { |
| 357 | /* No, we need to skip space before this field. |
| 358 | Bump the cumulative size to multiple of field alignment. */ |
| 359 | |
| 360 | if (var_size == 0 |
| 361 | || var_align % desired_align == 0) |
| 362 | const_size |
| 363 | = CEIL (const_size, desired_align) * desired_align; |
| 364 | else |
| 365 | { |
| 366 | if (const_size > 0) |
| 367 | var_size = size_binop (PLUS_EXPR, var_size, |
| 368 | size_int (const_size)); |
| 369 | const_size = 0; |
| 370 | var_size = round_up (var_size, desired_align); |
| 371 | var_align = MIN (var_align, desired_align); |
| 372 | } |
| 373 | } |
| 374 | |
| 375 | #ifdef PCC_BITFIELD_TYPE_MATTERS |
| 376 | if (PCC_BITFIELD_TYPE_MATTERS |
| 377 | && TREE_CODE (field) == FIELD_DECL |
| 378 | && TREE_TYPE (field) != error_mark_node |
| 379 | && DECL_BIT_FIELD_TYPE (field) |
| 380 | && !DECL_PACKED (field) |
| 381 | && !integer_zerop (DECL_SIZE (field))) |
| 382 | { |
| 383 | int type_align = TYPE_ALIGN (TREE_TYPE (field)); |
| 384 | register tree dsize = DECL_SIZE (field); |
| 385 | int field_size = TREE_INT_CST_LOW (dsize); |
| 386 | |
| 387 | if (maximum_field_alignment != 0) |
| 388 | type_align = MIN (type_align, maximum_field_alignment); |
| 389 | |
| 390 | /* A bit field may not span the unit of alignment of its type. |
| 391 | Advance to next boundary if necessary. */ |
| 392 | /* ??? There is some uncertainty here as to what |
| 393 | should be done if type_align is less than the width of the type. |
| 394 | That can happen because the width exceeds BIGGEST_ALIGNMENT |
| 395 | or because it exceeds maximum_field_alignment. */ |
| 396 | if (const_size / type_align |
| 397 | != (const_size + field_size - 1) / type_align) |
| 398 | const_size = CEIL (const_size, type_align) * type_align; |
| 399 | } |
| 400 | #endif |
| 401 | |
| 402 | /* No existing machine description uses this parameter. |
| 403 | So I have made it in this aspect identical to PCC_BITFIELD_TYPE_MATTERS. */ |
| 404 | #ifdef BITFIELD_NBYTES_LIMITED |
| 405 | if (BITFIELD_NBYTES_LIMITED |
| 406 | && TREE_CODE (field) == FIELD_DECL |
| 407 | && TREE_TYPE (field) != error_mark_node |
| 408 | && DECL_BIT_FIELD_TYPE (field) |
| 409 | && !DECL_PACKED (field) |
| 410 | && !integer_zerop (DECL_SIZE (field))) |
| 411 | { |
| 412 | int type_align = TYPE_ALIGN (TREE_TYPE (field)); |
| 413 | register tree dsize = DECL_SIZE (field); |
| 414 | int field_size = TREE_INT_CST_LOW (dsize); |
| 415 | |
| 416 | if (maximum_field_alignment != 0) |
| 417 | type_align = MIN (type_align, maximum_field_alignment); |
| 418 | |
| 419 | /* A bit field may not span the unit of alignment of its type. |
| 420 | Advance to next boundary if necessary. */ |
| 421 | if (const_size / type_align |
| 422 | != (const_size + field_size - 1) / type_align) |
| 423 | const_size = CEIL (const_size, type_align) * type_align; |
| 424 | } |
| 425 | #endif |
| 426 | |
| 427 | /* Size so far becomes the position of this field. */ |
| 428 | |
| 429 | if (var_size && const_size) |
| 430 | DECL_FIELD_BITPOS (field) |
| 431 | = size_binop (PLUS_EXPR, var_size, size_int (const_size)); |
| 432 | else if (var_size) |
| 433 | DECL_FIELD_BITPOS (field) = var_size; |
| 434 | else |
| 435 | DECL_FIELD_BITPOS (field) = size_int (const_size); |
| 436 | |
| 437 | /* If this field is an anonymous union, |
| 438 | give each union-member the same position as the union has. |
| 439 | |
| 440 | ??? This is a real kludge because it makes the structure |
| 441 | of the types look strange. This feature is only used by |
| 442 | C++, which should have build_component_ref build two |
| 443 | COMPONENT_REF operations, one for the union and one for |
| 444 | the inner field. We set the offset of this field to zero |
| 445 | so that either the old or the correct method will work. |
| 446 | Setting DECL_FIELD_CONTEXT is wrong unless the inner fields are |
| 447 | moved into the type of this field, but nothing seems to break |
| 448 | by doing this. This kludge should be removed after 2.4. */ |
| 449 | |
| 450 | if (DECL_NAME (field) == 0 |
| 451 | && TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) |
| 452 | { |
| 453 | tree uelt = TYPE_FIELDS (TREE_TYPE (field)); |
| 454 | for (; uelt; uelt = TREE_CHAIN (uelt)) |
| 455 | { |
| 456 | DECL_FIELD_CONTEXT (uelt) = DECL_FIELD_CONTEXT (field); |
| 457 | DECL_FIELD_BITPOS (uelt) = DECL_FIELD_BITPOS (field); |
| 458 | } |
| 459 | |
| 460 | DECL_FIELD_BITPOS (field) = integer_zero_node; |
| 461 | } |
| 462 | |
| 463 | /* Now add size of this field to the size of the record. */ |
| 464 | |
| 465 | { |
| 466 | register tree dsize = DECL_SIZE (field); |
| 467 | |
| 468 | /* This can happen when we have an invalid nested struct definition, |
| 469 | such as struct j { struct j { int i; } }. The error message is |
| 470 | printed in finish_struct. */ |
| 471 | if (dsize == 0) |
| 472 | /* Do nothing. */; |
| 473 | else if (TREE_CODE (dsize) == INTEGER_CST |
| 474 | && TREE_INT_CST_HIGH (dsize) == 0 |
| 475 | && TREE_INT_CST_LOW (dsize) + const_size > const_size) |
| 476 | /* Use const_size if there's no overflow. */ |
| 477 | const_size += TREE_INT_CST_LOW (dsize); |
| 478 | else |
| 479 | { |
| 480 | if (var_size == 0) |
| 481 | var_size = dsize; |
| 482 | else |
| 483 | var_size = size_binop (PLUS_EXPR, var_size, dsize); |
| 484 | } |
| 485 | } |
| 486 | } |
| 487 | |
| 488 | /* Work out the total size and alignment of the record |
| 489 | as one expression and store in the record type. |
| 490 | Round it up to a multiple of the record's alignment. */ |
| 491 | |
| 492 | if (var_size == 0) |
| 493 | { |
| 494 | TYPE_SIZE (rec) = size_int (const_size); |
| 495 | } |
| 496 | else |
| 497 | { |
| 498 | if (const_size) |
| 499 | var_size |
| 500 | = size_binop (PLUS_EXPR, var_size, size_int (const_size)); |
| 501 | TYPE_SIZE (rec) = var_size; |
| 502 | } |
| 503 | |
| 504 | /* Determine the desired alignment. */ |
| 505 | #ifdef ROUND_TYPE_ALIGN |
| 506 | TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), record_align); |
| 507 | #else |
| 508 | TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), record_align); |
| 509 | #endif |
| 510 | |
| 511 | #ifdef ROUND_TYPE_SIZE |
| 512 | TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec)); |
| 513 | #else |
| 514 | /* Round the size up to be a multiple of the required alignment */ |
| 515 | TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec)); |
| 516 | #endif |
| 517 | |
| 518 | return pending_statics; |
| 519 | } |
| 520 | \f |
| 521 | /* Lay out a UNION_TYPE or QUAL_UNION_TYPE type. |
| 522 | Lay out all the fields, set their positions to zero, |
| 523 | and compute the size and alignment of the union (maximum of any field). |
| 524 | Note that if you set the TYPE_ALIGN before calling this |
| 525 | then the union align is aligned to at least that boundary. */ |
| 526 | |
| 527 | static void |
| 528 | layout_union (rec) |
| 529 | tree rec; |
| 530 | { |
| 531 | register tree field; |
| 532 | #ifdef STRUCTURE_SIZE_BOUNDARY |
| 533 | unsigned union_align = STRUCTURE_SIZE_BOUNDARY; |
| 534 | #else |
| 535 | unsigned union_align = BITS_PER_UNIT; |
| 536 | #endif |
| 537 | |
| 538 | /* The size of the union, based on the fields scanned so far, |
| 539 | is max (CONST_SIZE, VAR_SIZE). |
| 540 | VAR_SIZE may be null; then CONST_SIZE by itself is the size. */ |
| 541 | register int const_size = 0; |
| 542 | register tree var_size = 0; |
| 543 | |
| 544 | /* If this is a QUAL_UNION_TYPE, we want to process the fields in |
| 545 | the reverse order in building the COND_EXPR that denotes its |
| 546 | size. We reverse them again later. */ |
| 547 | if (TREE_CODE (rec) == QUAL_UNION_TYPE) |
| 548 | TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec)); |
| 549 | |
| 550 | for (field = TYPE_FIELDS (rec); field; field = TREE_CHAIN (field)) |
| 551 | { |
| 552 | /* Enums which are local to this class need not be laid out. */ |
| 553 | if (TREE_CODE (field) == CONST_DECL || TREE_CODE (field) == TYPE_DECL) |
| 554 | continue; |
| 555 | |
| 556 | layout_decl (field, 0); |
| 557 | DECL_FIELD_BITPOS (field) = size_int (0); |
| 558 | |
| 559 | /* Union must be at least as aligned as any field requires. */ |
| 560 | |
| 561 | union_align = MAX (union_align, DECL_ALIGN (field)); |
| 562 | |
| 563 | #ifdef PCC_BITFIELD_TYPE_MATTERS |
| 564 | /* On the m88000, a bit field of declare type `int' |
| 565 | forces the entire union to have `int' alignment. */ |
| 566 | if (PCC_BITFIELD_TYPE_MATTERS && DECL_BIT_FIELD_TYPE (field)) |
| 567 | union_align = MAX (union_align, TYPE_ALIGN (TREE_TYPE (field))); |
| 568 | #endif |
| 569 | |
| 570 | if (TREE_CODE (rec) == UNION_TYPE) |
| 571 | { |
| 572 | /* Set union_size to max (decl_size, union_size). |
| 573 | There are more and less general ways to do this. |
| 574 | Use only CONST_SIZE unless forced to use VAR_SIZE. */ |
| 575 | |
| 576 | if (TREE_CODE (DECL_SIZE (field)) == INTEGER_CST) |
| 577 | const_size |
| 578 | = MAX (const_size, TREE_INT_CST_LOW (DECL_SIZE (field))); |
| 579 | else if (var_size == 0) |
| 580 | var_size = DECL_SIZE (field); |
| 581 | else |
| 582 | var_size = size_binop (MAX_EXPR, var_size, DECL_SIZE (field)); |
| 583 | } |
| 584 | else if (TREE_CODE (rec) == QUAL_UNION_TYPE) |
| 585 | var_size = fold (build (COND_EXPR, sizetype, DECL_QUALIFIER (field), |
| 586 | DECL_SIZE (field), |
| 587 | var_size ? var_size : integer_zero_node)); |
| 588 | } |
| 589 | |
| 590 | if (TREE_CODE (rec) == QUAL_UNION_TYPE) |
| 591 | TYPE_FIELDS (rec) = nreverse (TYPE_FIELDS (rec)); |
| 592 | |
| 593 | /* Determine the ultimate size of the union (in bytes). */ |
| 594 | if (NULL == var_size) |
| 595 | TYPE_SIZE (rec) = size_int (CEIL (const_size, BITS_PER_UNIT) |
| 596 | * BITS_PER_UNIT); |
| 597 | else if (const_size == 0) |
| 598 | TYPE_SIZE (rec) = var_size; |
| 599 | else |
| 600 | TYPE_SIZE (rec) = size_binop (MAX_EXPR, var_size, |
| 601 | round_up (size_int (const_size), |
| 602 | BITS_PER_UNIT)); |
| 603 | |
| 604 | /* Determine the desired alignment. */ |
| 605 | #ifdef ROUND_TYPE_ALIGN |
| 606 | TYPE_ALIGN (rec) = ROUND_TYPE_ALIGN (rec, TYPE_ALIGN (rec), union_align); |
| 607 | #else |
| 608 | TYPE_ALIGN (rec) = MAX (TYPE_ALIGN (rec), union_align); |
| 609 | #endif |
| 610 | |
| 611 | #ifdef ROUND_TYPE_SIZE |
| 612 | TYPE_SIZE (rec) = ROUND_TYPE_SIZE (rec, TYPE_SIZE (rec), TYPE_ALIGN (rec)); |
| 613 | #else |
| 614 | /* Round the size up to be a multiple of the required alignment */ |
| 615 | TYPE_SIZE (rec) = round_up (TYPE_SIZE (rec), TYPE_ALIGN (rec)); |
| 616 | #endif |
| 617 | } |
| 618 | \f |
| 619 | /* Calculate the mode, size, and alignment for TYPE. |
| 620 | For an array type, calculate the element separation as well. |
| 621 | Record TYPE on the chain of permanent or temporary types |
| 622 | so that dbxout will find out about it. |
| 623 | |
| 624 | TYPE_SIZE of a type is nonzero if the type has been laid out already. |
| 625 | layout_type does nothing on such a type. |
| 626 | |
| 627 | If the type is incomplete, its TYPE_SIZE remains zero. */ |
| 628 | |
| 629 | void |
| 630 | layout_type (type) |
| 631 | tree type; |
| 632 | { |
| 633 | int old; |
| 634 | tree pending_statics; |
| 635 | |
| 636 | if (type == 0) |
| 637 | abort (); |
| 638 | |
| 639 | /* Do nothing if type has been laid out before. */ |
| 640 | if (TYPE_SIZE (type)) |
| 641 | return; |
| 642 | |
| 643 | /* Make sure all nodes we allocate are not momentary; |
| 644 | they must last past the current statement. */ |
| 645 | old = suspend_momentary (); |
| 646 | |
| 647 | /* If we are processing a permanent type, make nodes permanent. |
| 648 | If processing a temporary type, make it saveable, since the |
| 649 | type node itself is. This is important if the function is inline, |
| 650 | since its decls will get copied later. */ |
| 651 | push_obstacks_nochange (); |
| 652 | if (allocation_temporary_p ()) |
| 653 | { |
| 654 | if (TREE_PERMANENT (type)) |
| 655 | end_temporary_allocation (); |
| 656 | else |
| 657 | saveable_allocation (); |
| 658 | } |
| 659 | |
| 660 | switch (TREE_CODE (type)) |
| 661 | { |
| 662 | case LANG_TYPE: |
| 663 | /* This kind of type is the responsibility |
| 664 | of the languge-specific code. */ |
| 665 | abort (); |
| 666 | |
| 667 | case INTEGER_TYPE: |
| 668 | case ENUMERAL_TYPE: |
| 669 | if (TREE_INT_CST_HIGH (TYPE_MIN_VALUE (type)) >= 0) |
| 670 | TREE_UNSIGNED (type) = 1; |
| 671 | |
| 672 | /* We pass 0 for the last arg of mode_for_size because otherwise |
| 673 | on the Apollo using long long causes a crash. |
| 674 | It seems better to use integer modes than to try to support |
| 675 | integer types with BLKmode. */ |
| 676 | TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_INT, 0); |
| 677 | TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type))); |
| 678 | break; |
| 679 | |
| 680 | case REAL_TYPE: |
| 681 | TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0); |
| 682 | TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type))); |
| 683 | break; |
| 684 | |
| 685 | case COMPLEX_TYPE: |
| 686 | TREE_UNSIGNED (type) = TREE_UNSIGNED (TREE_TYPE (type)); |
| 687 | TYPE_MODE (type) |
| 688 | = mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)), |
| 689 | (TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE |
| 690 | ? MODE_COMPLEX_INT : MODE_COMPLEX_FLOAT), |
| 691 | 0); |
| 692 | TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type))); |
| 693 | break; |
| 694 | |
| 695 | case VOID_TYPE: |
| 696 | TYPE_SIZE (type) = size_zero_node; |
| 697 | TYPE_ALIGN (type) = 1; |
| 698 | TYPE_MODE (type) = VOIDmode; |
| 699 | break; |
| 700 | |
| 701 | case OFFSET_TYPE: |
| 702 | TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (Pmode)); |
| 703 | TYPE_MODE (type) = Pmode; |
| 704 | break; |
| 705 | |
| 706 | case FUNCTION_TYPE: |
| 707 | case METHOD_TYPE: |
| 708 | TYPE_MODE (type) = mode_for_size (2 * GET_MODE_BITSIZE (Pmode), |
| 709 | MODE_INT, 0); |
| 710 | TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type))); |
| 711 | break; |
| 712 | |
| 713 | case POINTER_TYPE: |
| 714 | case REFERENCE_TYPE: |
| 715 | TYPE_MODE (type) = Pmode; |
| 716 | TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type))); |
| 717 | TREE_UNSIGNED (type) = 1; |
| 718 | TYPE_PRECISION (type) = GET_MODE_BITSIZE (TYPE_MODE (type)); |
| 719 | break; |
| 720 | |
| 721 | case ARRAY_TYPE: |
| 722 | { |
| 723 | register tree index = TYPE_DOMAIN (type); |
| 724 | register tree element = TREE_TYPE (type); |
| 725 | |
| 726 | build_pointer_type (element); |
| 727 | |
| 728 | /* We need to know both bounds in order to compute the size. */ |
| 729 | if (index && TYPE_MAX_VALUE (index) && TYPE_MIN_VALUE (index) |
| 730 | && TYPE_SIZE (element)) |
| 731 | { |
| 732 | tree length |
| 733 | = size_binop (PLUS_EXPR, size_one_node, |
| 734 | size_binop (MINUS_EXPR, TYPE_MAX_VALUE (index), |
| 735 | TYPE_MIN_VALUE (index))); |
| 736 | |
| 737 | TYPE_SIZE (type) = size_binop (MULT_EXPR, length, |
| 738 | TYPE_SIZE (element)); |
| 739 | } |
| 740 | |
| 741 | /* Now round the alignment and size, |
| 742 | using machine-dependent criteria if any. */ |
| 743 | |
| 744 | #ifdef ROUND_TYPE_ALIGN |
| 745 | TYPE_ALIGN (type) |
| 746 | = ROUND_TYPE_ALIGN (type, TYPE_ALIGN (element), BITS_PER_UNIT); |
| 747 | #else |
| 748 | TYPE_ALIGN (type) = MAX (TYPE_ALIGN (element), BITS_PER_UNIT); |
| 749 | #endif |
| 750 | |
| 751 | #ifdef ROUND_TYPE_SIZE |
| 752 | if (TYPE_SIZE (type) != 0) |
| 753 | TYPE_SIZE (type) |
| 754 | = ROUND_TYPE_SIZE (type, TYPE_SIZE (type), TYPE_ALIGN (type)); |
| 755 | #endif |
| 756 | |
| 757 | TYPE_MODE (type) = BLKmode; |
| 758 | if (TYPE_SIZE (type) != 0 |
| 759 | && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST |
| 760 | /* BLKmode elements force BLKmode aggregate; |
| 761 | else extract/store fields may lose. */ |
| 762 | && (TYPE_MODE (TREE_TYPE (type)) != BLKmode |
| 763 | || TYPE_NO_FORCE_BLK (TREE_TYPE (type)))) |
| 764 | { |
| 765 | TYPE_MODE (type) |
| 766 | = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)), |
| 767 | MODE_INT, 1); |
| 768 | |
| 769 | if (STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT |
| 770 | && TYPE_ALIGN (type) < TREE_INT_CST_LOW (TYPE_SIZE (type)) |
| 771 | && TYPE_MODE (type) != BLKmode) |
| 772 | { |
| 773 | TYPE_NO_FORCE_BLK (type) = 1; |
| 774 | TYPE_MODE (type) = BLKmode; |
| 775 | } |
| 776 | } |
| 777 | break; |
| 778 | } |
| 779 | |
| 780 | case RECORD_TYPE: |
| 781 | pending_statics = layout_record (type); |
| 782 | TYPE_MODE (type) = BLKmode; |
| 783 | if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST) |
| 784 | { |
| 785 | tree field; |
| 786 | /* A record which has any BLKmode members must itself be BLKmode; |
| 787 | it can't go in a register. |
| 788 | Unless the member is BLKmode only because it isn't aligned. */ |
| 789 | for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) |
| 790 | { |
| 791 | int bitpos; |
| 792 | |
| 793 | if (TREE_CODE (field) != FIELD_DECL) |
| 794 | continue; |
| 795 | |
| 796 | if (TYPE_MODE (TREE_TYPE (field)) == BLKmode |
| 797 | && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field))) |
| 798 | goto record_lose; |
| 799 | |
| 800 | if (TREE_CODE (DECL_FIELD_BITPOS (field)) != INTEGER_CST) |
| 801 | goto record_lose; |
| 802 | |
| 803 | bitpos = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)); |
| 804 | |
| 805 | /* Must be BLKmode if any field crosses a word boundary, |
| 806 | since extract_bit_field can't handle that in registers. */ |
| 807 | if (bitpos / BITS_PER_WORD |
| 808 | != ((TREE_INT_CST_LOW (DECL_SIZE (field)) + bitpos - 1) |
| 809 | / BITS_PER_WORD) |
| 810 | /* But there is no problem if the field is entire words. */ |
| 811 | && TREE_INT_CST_LOW (DECL_SIZE (field)) % BITS_PER_WORD == 0) |
| 812 | goto record_lose; |
| 813 | } |
| 814 | |
| 815 | TYPE_MODE (type) |
| 816 | = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)), |
| 817 | MODE_INT, 1); |
| 818 | |
| 819 | /* If structure's known alignment is less than |
| 820 | what the scalar mode would need, and it matters, |
| 821 | then stick with BLKmode. */ |
| 822 | if (STRICT_ALIGNMENT |
| 823 | && ! (TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT |
| 824 | || (TYPE_ALIGN (type) |
| 825 | >= TREE_INT_CST_LOW (TYPE_SIZE (type))))) |
| 826 | { |
| 827 | if (TYPE_MODE (type) != BLKmode) |
| 828 | /* If this is the only reason this type is BLKmode, |
| 829 | then don't force containing types to be BLKmode. */ |
| 830 | TYPE_NO_FORCE_BLK (type) = 1; |
| 831 | TYPE_MODE (type) = BLKmode; |
| 832 | } |
| 833 | |
| 834 | record_lose: ; |
| 835 | } |
| 836 | |
| 837 | /* Lay out any static members. This is done now |
| 838 | because their type may use the record's type. */ |
| 839 | while (pending_statics) |
| 840 | { |
| 841 | layout_decl (TREE_VALUE (pending_statics), 0); |
| 842 | pending_statics = TREE_CHAIN (pending_statics); |
| 843 | } |
| 844 | break; |
| 845 | |
| 846 | case UNION_TYPE: |
| 847 | case QUAL_UNION_TYPE: |
| 848 | layout_union (type); |
| 849 | TYPE_MODE (type) = BLKmode; |
| 850 | if (TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST |
| 851 | /* If structure's known alignment is less than |
| 852 | what the scalar mode would need, and it matters, |
| 853 | then stick with BLKmode. */ |
| 854 | && (! STRICT_ALIGNMENT |
| 855 | || TYPE_ALIGN (type) >= BIGGEST_ALIGNMENT |
| 856 | || TYPE_ALIGN (type) >= TREE_INT_CST_LOW (TYPE_SIZE (type)))) |
| 857 | { |
| 858 | tree field; |
| 859 | /* A union which has any BLKmode members must itself be BLKmode; |
| 860 | it can't go in a register. |
| 861 | Unless the member is BLKmode only because it isn't aligned. */ |
| 862 | for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) |
| 863 | { |
| 864 | if (TREE_CODE (field) != FIELD_DECL) |
| 865 | continue; |
| 866 | |
| 867 | if (TYPE_MODE (TREE_TYPE (field)) == BLKmode |
| 868 | && ! TYPE_NO_FORCE_BLK (TREE_TYPE (field))) |
| 869 | goto union_lose; |
| 870 | } |
| 871 | |
| 872 | TYPE_MODE (type) |
| 873 | = mode_for_size (TREE_INT_CST_LOW (TYPE_SIZE (type)), |
| 874 | MODE_INT, 1); |
| 875 | |
| 876 | union_lose: ; |
| 877 | } |
| 878 | break; |
| 879 | |
| 880 | /* Pascal types */ |
| 881 | case BOOLEAN_TYPE: /* store one byte/boolean for now. */ |
| 882 | TYPE_MODE (type) = QImode; |
| 883 | TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type))); |
| 884 | TYPE_PRECISION (type) = 1; |
| 885 | TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type)); |
| 886 | break; |
| 887 | |
| 888 | case CHAR_TYPE: |
| 889 | TYPE_MODE (type) = QImode; |
| 890 | TYPE_SIZE (type) = size_int (GET_MODE_BITSIZE (TYPE_MODE (type))); |
| 891 | TYPE_PRECISION (type) = GET_MODE_BITSIZE (TYPE_MODE (type)); |
| 892 | TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type)); |
| 893 | break; |
| 894 | |
| 895 | case FILE_TYPE: |
| 896 | /* The size may vary in different languages, so the language front end |
| 897 | should fill in the size. */ |
| 898 | TYPE_ALIGN (type) = BIGGEST_ALIGNMENT; |
| 899 | TYPE_MODE (type) = BLKmode; |
| 900 | break; |
| 901 | |
| 902 | default: |
| 903 | abort (); |
| 904 | } /* end switch */ |
| 905 | |
| 906 | /* Normally, use the alignment corresponding to the mode chosen. |
| 907 | However, where strict alignment is not required, avoid |
| 908 | over-aligning structures, since most compilers do not do this |
| 909 | alignment. */ |
| 910 | |
| 911 | if (TYPE_MODE (type) != BLKmode && TYPE_MODE (type) != VOIDmode |
| 912 | && (STRICT_ALIGNMENT |
| 913 | || (TREE_CODE (type) != RECORD_TYPE && TREE_CODE (type) != UNION_TYPE |
| 914 | && TREE_CODE (type) != QUAL_UNION_TYPE |
| 915 | && TREE_CODE (type) != ARRAY_TYPE))) |
| 916 | TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type)); |
| 917 | |
| 918 | /* Evaluate nonconstant size only once, either now or as soon as safe. */ |
| 919 | if (TYPE_SIZE (type) != 0 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) |
| 920 | TYPE_SIZE (type) = variable_size (TYPE_SIZE (type)); |
| 921 | |
| 922 | /* Also layout any other variants of the type. */ |
| 923 | if (TYPE_NEXT_VARIANT (type) |
| 924 | || type != TYPE_MAIN_VARIANT (type)) |
| 925 | { |
| 926 | tree variant; |
| 927 | /* Record layout info of this variant. */ |
| 928 | tree size = TYPE_SIZE (type); |
| 929 | int align = TYPE_ALIGN (type); |
| 930 | enum machine_mode mode = TYPE_MODE (type); |
| 931 | |
| 932 | /* Copy it into all variants. */ |
| 933 | for (variant = TYPE_MAIN_VARIANT (type); |
| 934 | variant; |
| 935 | variant = TYPE_NEXT_VARIANT (variant)) |
| 936 | { |
| 937 | TYPE_SIZE (variant) = size; |
| 938 | TYPE_ALIGN (variant) = align; |
| 939 | TYPE_MODE (variant) = mode; |
| 940 | } |
| 941 | } |
| 942 | |
| 943 | pop_obstacks (); |
| 944 | resume_momentary (old); |
| 945 | } |
| 946 | \f |
| 947 | /* Create and return a type for signed integers of PRECISION bits. */ |
| 948 | |
| 949 | tree |
| 950 | make_signed_type (precision) |
| 951 | int precision; |
| 952 | { |
| 953 | register tree type = make_node (INTEGER_TYPE); |
| 954 | |
| 955 | TYPE_PRECISION (type) = precision; |
| 956 | |
| 957 | /* Create the extreme values based on the number of bits. */ |
| 958 | |
| 959 | TYPE_MIN_VALUE (type) |
| 960 | = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 |
| 961 | ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)), |
| 962 | (((HOST_WIDE_INT) (-1) |
| 963 | << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 |
| 964 | ? precision - HOST_BITS_PER_WIDE_INT - 1 |
| 965 | : 0)))); |
| 966 | TYPE_MAX_VALUE (type) |
| 967 | = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 |
| 968 | ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1), |
| 969 | (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 |
| 970 | ? (((HOST_WIDE_INT) 1 |
| 971 | << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1 |
| 972 | : 0)); |
| 973 | |
| 974 | /* Give this type's extreme values this type as their type. */ |
| 975 | |
| 976 | TREE_TYPE (TYPE_MIN_VALUE (type)) = type; |
| 977 | TREE_TYPE (TYPE_MAX_VALUE (type)) = type; |
| 978 | |
| 979 | /* The first type made with this or `make_unsigned_type' |
| 980 | is the type for size values. */ |
| 981 | |
| 982 | if (sizetype == 0) |
| 983 | { |
| 984 | sizetype = type; |
| 985 | } |
| 986 | |
| 987 | /* Lay out the type: set its alignment, size, etc. */ |
| 988 | |
| 989 | layout_type (type); |
| 990 | |
| 991 | return type; |
| 992 | } |
| 993 | |
| 994 | /* Create and return a type for unsigned integers of PRECISION bits. */ |
| 995 | |
| 996 | tree |
| 997 | make_unsigned_type (precision) |
| 998 | int precision; |
| 999 | { |
| 1000 | register tree type = make_node (INTEGER_TYPE); |
| 1001 | |
| 1002 | TYPE_PRECISION (type) = precision; |
| 1003 | |
| 1004 | /* The first type made with this or `make_signed_type' |
| 1005 | is the type for size values. */ |
| 1006 | |
| 1007 | if (sizetype == 0) |
| 1008 | { |
| 1009 | sizetype = type; |
| 1010 | } |
| 1011 | |
| 1012 | fixup_unsigned_type (type); |
| 1013 | return type; |
| 1014 | } |
| 1015 | |
| 1016 | /* Set the extreme values of TYPE based on its precision in bits, |
| 1017 | then lay it out. Used when make_signed_type won't do |
| 1018 | because the tree code is not INTEGER_TYPE. |
| 1019 | E.g. for Pascal, when the -fsigned-char option is given. */ |
| 1020 | |
| 1021 | void |
| 1022 | fixup_signed_type (type) |
| 1023 | tree type; |
| 1024 | { |
| 1025 | register int precision = TYPE_PRECISION (type); |
| 1026 | |
| 1027 | TYPE_MIN_VALUE (type) |
| 1028 | = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 |
| 1029 | ? 0 : (HOST_WIDE_INT) (-1) << (precision - 1)), |
| 1030 | (((HOST_WIDE_INT) (-1) |
| 1031 | << (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 |
| 1032 | ? precision - HOST_BITS_PER_WIDE_INT - 1 |
| 1033 | : 0)))); |
| 1034 | TYPE_MAX_VALUE (type) |
| 1035 | = build_int_2 ((precision - HOST_BITS_PER_WIDE_INT > 0 |
| 1036 | ? -1 : ((HOST_WIDE_INT) 1 << (precision - 1)) - 1), |
| 1037 | (precision - HOST_BITS_PER_WIDE_INT - 1 > 0 |
| 1038 | ? (((HOST_WIDE_INT) 1 |
| 1039 | << (precision - HOST_BITS_PER_WIDE_INT - 1))) - 1 |
| 1040 | : 0)); |
| 1041 | |
| 1042 | TREE_TYPE (TYPE_MIN_VALUE (type)) = type; |
| 1043 | TREE_TYPE (TYPE_MAX_VALUE (type)) = type; |
| 1044 | |
| 1045 | /* Lay out the type: set its alignment, size, etc. */ |
| 1046 | |
| 1047 | layout_type (type); |
| 1048 | } |
| 1049 | |
| 1050 | /* Set the extreme values of TYPE based on its precision in bits, |
| 1051 | then lay it out. This is used both in `make_unsigned_type' |
| 1052 | and for enumeral types. */ |
| 1053 | |
| 1054 | void |
| 1055 | fixup_unsigned_type (type) |
| 1056 | tree type; |
| 1057 | { |
| 1058 | register int precision = TYPE_PRECISION (type); |
| 1059 | |
| 1060 | TYPE_MIN_VALUE (type) = build_int_2 (0, 0); |
| 1061 | TYPE_MAX_VALUE (type) |
| 1062 | = build_int_2 (precision - HOST_BITS_PER_WIDE_INT >= 0 |
| 1063 | ? -1 : ((HOST_WIDE_INT) 1 << precision) - 1, |
| 1064 | precision - HOST_BITS_PER_WIDE_INT > 0 |
| 1065 | ? ((unsigned HOST_WIDE_INT) ~0 |
| 1066 | >> (HOST_BITS_PER_WIDE_INT |
| 1067 | - (precision - HOST_BITS_PER_WIDE_INT))) |
| 1068 | : 0); |
| 1069 | TREE_TYPE (TYPE_MIN_VALUE (type)) = type; |
| 1070 | TREE_TYPE (TYPE_MAX_VALUE (type)) = type; |
| 1071 | |
| 1072 | /* Lay out the type: set its alignment, size, etc. */ |
| 1073 | |
| 1074 | layout_type (type); |
| 1075 | } |
| 1076 | \f |
| 1077 | /* Find the best machine mode to use when referencing a bit field of length |
| 1078 | BITSIZE bits starting at BITPOS. |
| 1079 | |
| 1080 | The underlying object is known to be aligned to a boundary of ALIGN bits. |
| 1081 | If LARGEST_MODE is not VOIDmode, it means that we should not use a mode |
| 1082 | larger than LARGEST_MODE (usually SImode). |
| 1083 | |
| 1084 | If no mode meets all these conditions, we return VOIDmode. Otherwise, if |
| 1085 | VOLATILEP is true or SLOW_BYTE_ACCESS is false, we return the smallest |
| 1086 | mode meeting these conditions. |
| 1087 | |
| 1088 | Otherwise (VOLATILEP is false and SLOW_BYTE_ACCESS is true), we return |
| 1089 | the largest mode (but a mode no wider than UNITS_PER_WORD) that meets |
| 1090 | all the conditions. */ |
| 1091 | |
| 1092 | enum machine_mode |
| 1093 | get_best_mode (bitsize, bitpos, align, largest_mode, volatilep) |
| 1094 | int bitsize, bitpos; |
| 1095 | int align; |
| 1096 | enum machine_mode largest_mode; |
| 1097 | int volatilep; |
| 1098 | { |
| 1099 | enum machine_mode mode; |
| 1100 | int unit; |
| 1101 | |
| 1102 | /* Find the narrowest integer mode that contains the bit field. */ |
| 1103 | for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode; |
| 1104 | mode = GET_MODE_WIDER_MODE (mode)) |
| 1105 | { |
| 1106 | unit = GET_MODE_BITSIZE (mode); |
| 1107 | if (bitpos / unit == (bitpos + bitsize - 1) / unit) |
| 1108 | break; |
| 1109 | } |
| 1110 | |
| 1111 | if (mode == MAX_MACHINE_MODE |
| 1112 | /* It is tempting to omit the following line |
| 1113 | if STRICT_ALIGNMENT is true. |
| 1114 | But that is incorrect, since if the bitfield uses part of 3 bytes |
| 1115 | and we use a 4-byte mode, we could get a spurious segv |
| 1116 | if the extra 4th byte is past the end of memory. |
| 1117 | (Though at least one Unix compiler ignores this problem: |
| 1118 | that on the Sequent 386 machine. */ |
| 1119 | || MIN (unit, BIGGEST_ALIGNMENT) > align |
| 1120 | || (largest_mode != VOIDmode && unit > GET_MODE_BITSIZE (largest_mode))) |
| 1121 | return VOIDmode; |
| 1122 | |
| 1123 | if (SLOW_BYTE_ACCESS && ! volatilep) |
| 1124 | { |
| 1125 | enum machine_mode wide_mode = VOIDmode, tmode; |
| 1126 | |
| 1127 | for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT); tmode != VOIDmode; |
| 1128 | tmode = GET_MODE_WIDER_MODE (tmode)) |
| 1129 | { |
| 1130 | unit = GET_MODE_BITSIZE (tmode); |
| 1131 | if (bitpos / unit == (bitpos + bitsize - 1) / unit |
| 1132 | && unit <= BITS_PER_WORD |
| 1133 | && unit <= MIN (align, BIGGEST_ALIGNMENT) |
| 1134 | && (largest_mode == VOIDmode |
| 1135 | || unit <= GET_MODE_BITSIZE (largest_mode))) |
| 1136 | wide_mode = tmode; |
| 1137 | } |
| 1138 | |
| 1139 | if (wide_mode != VOIDmode) |
| 1140 | return wide_mode; |
| 1141 | } |
| 1142 | |
| 1143 | return mode; |
| 1144 | } |
| 1145 | \f |
| 1146 | /* Save all variables describing the current status into the structure *P. |
| 1147 | This is used before starting a nested function. */ |
| 1148 | |
| 1149 | void |
| 1150 | save_storage_status (p) |
| 1151 | struct function *p; |
| 1152 | { |
| 1153 | #if 0 /* Need not save, since always 0 and non0 (resp.) within a function. */ |
| 1154 | p->pending_sizes = pending_sizes; |
| 1155 | p->immediate_size_expand = immediate_size_expand; |
| 1156 | #endif /* 0 */ |
| 1157 | } |
| 1158 | |
| 1159 | /* Restore all variables describing the current status from the structure *P. |
| 1160 | This is used after a nested function. */ |
| 1161 | |
| 1162 | void |
| 1163 | restore_storage_status (p) |
| 1164 | struct function *p; |
| 1165 | { |
| 1166 | #if 0 |
| 1167 | pending_sizes = p->pending_sizes; |
| 1168 | immediate_size_expand = p->immediate_size_expand; |
| 1169 | #endif /* 0 */ |
| 1170 | } |