mirrors/gcc
0
0
Fork 0
mirror of https://gcc.gnu.org/git/gcc.git synced 2025-01-08 20:17:14 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

stor-layout.c (initialize_sizetypes): Initialize all sizetypes based on target definitions.

Browse Source 
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.

From-SVN: r174748
This commit is contained in:
Richard Guenther 2011-06-07 14:37:39 +00:00 committed by Richard Biener
parent c3c79fc5a5
commit 67b884536d
4 changed files with 59 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gcc/ChangeLog
View File

@ -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

122
gcc/stor-layout.c
View File

@ -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);
int precision, bprecision;
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;
/* 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 ();
set_min_and_max_values_for_integral_type (t, precision,
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 = 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));
= double_int_to_tree (sizetype,
tree_to_double_int (TYPE_MAX_VALUE (sizetype)));
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);
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;
}

6
gcc/tree.c
View File

@ -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

1
gcc/tree.h
View File

@ -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);