diff options
Diffstat (limited to 'gcc')
| -rw-r--r-- | gcc/ChangeLog | 8 | ||||
| -rw-r--r-- | gcc/stor-layout.c | 128 | ||||
| -rw-r--r-- | gcc/tree.c | 6 | ||||
| -rw-r--r-- | gcc/tree.h | 1 |
4 files changed, 62 insertions, 81 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 812b9be..f3656fd 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,11 @@ +2011-06-07 Richard Guenther <rguenther@suse.de> + + * stor-layout.c (initialize_sizetypes): Initialize all + sizetypes based on target definitions. + (set_sizetype): Remove. + * tree.c (build_common_tree_nodes): Do not call set_sizetype. + * tree.h (set_sizetype): Remove. + 2011-06-07 Nick Clifton <nickc@redhat.com> * config.gcc: Unify V850 architecture options and add support for diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c index 55c1e30..9bfde84 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -2189,93 +2189,69 @@ make_accum_type (int precision, int unsignedp, int satp) return type; } -/* Initialize sizetype and bitsizetype to a reasonable and temporary - value to enable integer types to be created. */ +/* Initialize sizetypes so layout_type can use them. */ void initialize_sizetypes (void) { - tree t = make_node (INTEGER_TYPE); - int precision = GET_MODE_BITSIZE (SImode); - - SET_TYPE_MODE (t, SImode); - TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode); - TYPE_IS_SIZETYPE (t) = 1; - TYPE_UNSIGNED (t) = 1; - TYPE_SIZE (t) = build_int_cst (t, precision); - TYPE_SIZE_UNIT (t) = build_int_cst (t, GET_MODE_SIZE (SImode)); - TYPE_PRECISION (t) = precision; - - set_min_and_max_values_for_integral_type (t, precision, - /*is_unsigned=*/true); - - sizetype = t; - bitsizetype = build_distinct_type_copy (t); -} - -/* Make sizetype a version of TYPE, and initialize *sizetype accordingly. - We do this by overwriting the stub sizetype and bitsizetype nodes created - by initialize_sizetypes. This makes sure that (a) anything stubby about - them no longer exists and (b) any INTEGER_CSTs created with such a type, - remain valid. */ - -void -set_sizetype (tree type) -{ - tree t, max; - int oprecision = TYPE_PRECISION (type); - /* The *bitsizetype types use a precision that avoids overflows when - calculating signed sizes / offsets in bits. However, when - cross-compiling from a 32 bit to a 64 bit host, we are limited to 64 bit - precision. */ - int precision - = MIN (oprecision + BITS_PER_UNIT_LOG + 1, MAX_FIXED_MODE_SIZE); - precision - = GET_MODE_PRECISION (smallest_mode_for_size (precision, MODE_INT)); - if (precision > HOST_BITS_PER_WIDE_INT * 2) - precision = HOST_BITS_PER_WIDE_INT * 2; - - /* sizetype must be an unsigned type. */ - gcc_assert (TYPE_UNSIGNED (type)); - - t = build_distinct_type_copy (type); - /* We want to use sizetype's cache, as we will be replacing that type. */ - TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (sizetype); - TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (sizetype); - TYPE_UID (t) = TYPE_UID (sizetype); - TYPE_IS_SIZETYPE (t) = 1; - - /* Replace our original stub sizetype. */ - memcpy (sizetype, t, tree_size (sizetype)); - TYPE_MAIN_VARIANT (sizetype) = sizetype; - TYPE_CANONICAL (sizetype) = sizetype; + int precision, bprecision; + + /* Get sizetypes precision from the SIZE_TYPE target macro. */ + if (strcmp (SIZE_TYPE, "unsigned int") == 0) + precision = INT_TYPE_SIZE; + else if (strcmp (SIZE_TYPE, "long unsigned int") == 0) + precision = LONG_TYPE_SIZE; + else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0) + precision = LONG_LONG_TYPE_SIZE; + else + gcc_unreachable (); + bprecision + = MIN (precision + BITS_PER_UNIT_LOG + 1, MAX_FIXED_MODE_SIZE); + bprecision + = GET_MODE_PRECISION (smallest_mode_for_size (bprecision, MODE_INT)); + if (bprecision > HOST_BITS_PER_WIDE_INT * 2) + bprecision = HOST_BITS_PER_WIDE_INT * 2; + + /* Create stubs for sizetype and bitsizetype so we can create constants. */ + sizetype = make_node (INTEGER_TYPE); + /* ??? We can't set a name for sizetype because it appears in C diagnostics + and pp_c_type_specifier doesn't deal with IDENTIFIER_NODE TYPE_NAMEs. */ + TYPE_PRECISION (sizetype) = precision; + TYPE_UNSIGNED (sizetype) = 1; + TYPE_IS_SIZETYPE (sizetype) = 1; + bitsizetype = make_node (INTEGER_TYPE); + TYPE_NAME (bitsizetype) = get_identifier ("bitsizetype"); + TYPE_PRECISION (bitsizetype) = bprecision; + TYPE_UNSIGNED (bitsizetype) = 1; + TYPE_IS_SIZETYPE (bitsizetype) = 1; + + /* Now layout both types manually. */ + SET_TYPE_MODE (sizetype, smallest_mode_for_size (precision, MODE_INT)); + TYPE_ALIGN (sizetype) = GET_MODE_ALIGNMENT (TYPE_MODE (sizetype)); + TYPE_SIZE (sizetype) = bitsize_int (precision); + TYPE_SIZE_UNIT (sizetype) = size_int (GET_MODE_SIZE (TYPE_MODE (sizetype))); + set_min_and_max_values_for_integral_type (sizetype, precision, + /*is_unsigned=*/true); /* sizetype is unsigned but we need to fix TYPE_MAX_VALUE so that it is sign-extended in a way consistent with force_fit_type. */ - max = TYPE_MAX_VALUE (sizetype); TYPE_MAX_VALUE (sizetype) - = double_int_to_tree (sizetype, tree_to_double_int (max)); - - t = make_node (INTEGER_TYPE); - TYPE_NAME (t) = get_identifier ("bit_size_type"); - /* We want to use bitsizetype's cache, as we will be replacing that type. */ - TYPE_CACHED_VALUES (t) = TYPE_CACHED_VALUES (bitsizetype); - TYPE_CACHED_VALUES_P (t) = TYPE_CACHED_VALUES_P (bitsizetype); - TYPE_PRECISION (t) = precision; - TYPE_UID (t) = TYPE_UID (bitsizetype); - TYPE_IS_SIZETYPE (t) = 1; - - /* Replace our original stub bitsizetype. */ - memcpy (bitsizetype, t, tree_size (bitsizetype)); - TYPE_MAIN_VARIANT (bitsizetype) = bitsizetype; - TYPE_CANONICAL (bitsizetype) = bitsizetype; - - fixup_unsigned_type (bitsizetype); + = double_int_to_tree (sizetype, + tree_to_double_int (TYPE_MAX_VALUE (sizetype))); + + SET_TYPE_MODE (bitsizetype, smallest_mode_for_size (bprecision, MODE_INT)); + TYPE_ALIGN (bitsizetype) = GET_MODE_ALIGNMENT (TYPE_MODE (bitsizetype)); + TYPE_SIZE (bitsizetype) = bitsize_int (bprecision); + TYPE_SIZE_UNIT (bitsizetype) + = size_int (GET_MODE_SIZE (TYPE_MODE (bitsizetype))); + set_min_and_max_values_for_integral_type (bitsizetype, bprecision, + /*is_unsigned=*/true); + /* ??? TYPE_MAX_VALUE is not properly sign-extended. */ /* Create the signed variants of *sizetype. */ - ssizetype = make_signed_type (oprecision); + ssizetype = make_signed_type (TYPE_PRECISION (sizetype)); TYPE_IS_SIZETYPE (ssizetype) = 1; - sbitsizetype = make_signed_type (precision); + sbitsizetype = make_signed_type (TYPE_PRECISION (bitsizetype)); TYPE_IS_SIZETYPE (sbitsizetype) = 1; } @@ -9098,8 +9098,7 @@ make_or_reuse_accum_type (unsigned size, int unsignedp, int satp) } /* Create nodes for all integer types (and error_mark_node) using the sizes - of C datatypes. The caller should call set_sizetype soon after calling - this function to select one of the types as sizetype. */ + of C datatypes. */ void build_common_tree_nodes (bool signed_char) @@ -9161,7 +9160,6 @@ build_common_tree_nodes (bool signed_char) size_type_node = long_long_unsigned_type_node; else gcc_unreachable (); - set_sizetype (size_type_node); /* Fill in the rest of the sized types. Reuse existing type nodes when possible. */ @@ -9182,7 +9180,7 @@ build_common_tree_nodes (bool signed_char) access_private_node = get_identifier ("private"); } -/* Call this function after calling build_common_tree_nodes and set_sizetype. +/* Call this function after calling build_common_tree_nodes. It will create several other common tree nodes. */ void @@ -4291,7 +4291,6 @@ extern tree signed_or_unsigned_type_for (int, tree); extern tree signed_type_for (tree); extern tree unsigned_type_for (tree); extern void initialize_sizetypes (void); -extern void set_sizetype (tree); extern void fixup_unsigned_type (tree); extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool); extern tree build_pointer_type (tree); |