Now that there is a single place left to call set_sizetype we can
remove it and initialize sizetypes properly from the start
(in initialize_sizetypes).
Bootstrapped and tested on x86_64-unknown-linux-gnu, applied to trunk.
Richard.
2011-06-07 Richard Guenther <rguent...@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.
Index: gcc/stor-layout.c
===================================================================
*** gcc/stor-layout.c.orig 2011-06-06 12:26:32.000000000 +0200
--- gcc/stor-layout.c 2011-06-07 15:04:44.000000000 +0200
*************** make_accum_type (int precision, int unsi
*** 2189,2281 ****
return type;
}
! /* Initialize sizetype and bitsizetype to a reasonable and temporary
! value to enable integer types to be created. */
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;
-
/* 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);
/* Create the signed variants of *sizetype. */
! ssizetype = make_signed_type (oprecision);
TYPE_IS_SIZETYPE (ssizetype) = 1;
! sbitsizetype = make_signed_type (precision);
TYPE_IS_SIZETYPE (sbitsizetype) = 1;
}
--- 2189,2257 ----
return type;
}
! /* Initialize sizetypes so layout_type can use them. */
void
initialize_sizetypes (void)
{
! 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. */
TYPE_MAX_VALUE (sizetype)
! = 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 (TYPE_PRECISION (sizetype));
TYPE_IS_SIZETYPE (ssizetype) = 1;
! sbitsizetype = make_signed_type (TYPE_PRECISION (bitsizetype));
TYPE_IS_SIZETYPE (sbitsizetype) = 1;
}
Index: gcc/tree.c
===================================================================
*** gcc/tree.c.orig 2011-06-07 15:02:12.000000000 +0200
--- gcc/tree.c 2011-06-07 15:05:08.000000000 +0200
*************** make_or_reuse_accum_type (unsigned size,
*** 9098,9105 ****
}
/* 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. */
void
build_common_tree_nodes (bool signed_char)
--- 9098,9104 ----
}
/* Create nodes for all integer types (and error_mark_node) using the sizes
! of C datatypes. */
void
build_common_tree_nodes (bool signed_char)
*************** build_common_tree_nodes (bool signed_cha
*** 9161,9167 ****
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. */
--- 9160,9165 ----
*************** build_common_tree_nodes (bool signed_cha
*** 9182,9188 ****
access_private_node = get_identifier ("private");
}
! /* Call this function after calling build_common_tree_nodes and set_sizetype.
It will create several other common tree nodes. */
void
--- 9180,9186 ----
access_private_node = get_identifier ("private");
}
! /* Call this function after calling build_common_tree_nodes.
It will create several other common tree nodes. */
void
Index: gcc/tree.h
===================================================================
*** gcc/tree.h.orig 2011-05-31 11:10:22.000000000 +0200
--- gcc/tree.h 2011-06-07 15:03:56.000000000 +0200
*************** extern tree signed_or_unsigned_type_for
*** 4291,4297 ****
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);
--- 4291,4296 ----
