mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-03-21 08:30:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

re PR middle-end/38240 (Vector type definitions not compatible with attribute target)

Browse Source 
PR 38240
	* tree.h (TYPE_MODE): Invoke vector_type_mode when needed.
	(SET_TYPE_MODE): New.
	* c-decl.c (parser_xref_tag): Use it.
	(finish_enum): Likewise.
	* tree.c (build_pointer_type_for_mode): Likewise.
	(build_reference_type_for_mode, build_index_type): Likewise.
	(build_range_type, make_vector_type): Likewise.
	(build_common_tree_nodes_2): Likewise.
	* stor-layout.c (compute_record_mode): Likewise.
	(finalize_type_size, layout_type, make_fract_type): Likewise.
	(make_accum_type, initialize_sizetypes): Likewise.
	(vector_type_mode): New.
	* function.c (allocate_struct_function): Call
	invoke_set_current_function_hook before querying anything else.

	* config/i386/i386.c (ix86_valid_target_attribute_inner_p): Add avx.

cp/
	* class.c (finish_struct_bits): Use SET_TYPE_MODE.
	* decl.c (record_unknown_type): Likewise.
	(start_enum, finish_enum): Likewise.

From-SVN: r142556
This commit is contained in:
Richard Henderson 2008-12-08 09:12:55 -08:00 committed by Richard Henderson
parent be6568d8c6
commit 179d2f74d4
11 changed files with 135 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
gcc/ChangeLog
View File

@ -1,3 +1,23 @@
2008-12-08 Richard Henderson <rth@redhat.com>
PR 38240
* tree.h (TYPE_MODE): Invoke vector_type_mode when needed.
(SET_TYPE_MODE): New.
* c-decl.c (parser_xref_tag): Use it.
(finish_enum): Likewise.
* tree.c (build_pointer_type_for_mode): Likewise.
(build_reference_type_for_mode, build_index_type): Likewise.
(build_range_type, make_vector_type): Likewise.
(build_common_tree_nodes_2): Likewise.
* stor-layout.c (compute_record_mode): Likewise.
(finalize_type_size, layout_type, make_fract_type): Likewise.
(make_accum_type, initialize_sizetypes): Likewise.
(vector_type_mode): New.
* function.c (allocate_struct_function): Call
invoke_set_current_function_hook before querying anything else.
* config/i386/i386.c (ix86_valid_target_attribute_inner_p): Add avx.
2008-12-08 Luis Machado <luisgpm@br.ibm.com>
* alias.c (find_base_term): Synch LO_SUM handling with what

4
gcc/c-decl.c
View File

@ -5302,7 +5302,7 @@ parser_xref_tag (enum tree_code code, tree name)
{
/* Give the type a default layout like unsigned int
to avoid crashing if it does not get defined. */
TYPE_MODE (ref) = TYPE_MODE (unsigned_type_node);
SET_TYPE_MODE (ref, TYPE_MODE (unsigned_type_node));
TYPE_ALIGN (ref) = TYPE_ALIGN (unsigned_type_node);
TYPE_USER_ALIGN (ref) = 0;
TYPE_UNSIGNED (ref) = 1;
@ -5952,7 +5952,7 @@ finish_enum (tree enumtype, tree values, tree attributes)
TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype);
TYPE_SIZE (tem) = TYPE_SIZE (enumtype);
TYPE_SIZE_UNIT (tem) = TYPE_SIZE_UNIT (enumtype);
TYPE_MODE (tem) = TYPE_MODE (enumtype);
SET_TYPE_MODE (tem, TYPE_MODE (enumtype));
TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype);
TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype);
TYPE_USER_ALIGN (tem) = TYPE_USER_ALIGN (enumtype);

1
gcc/config/i386/i386.c
View File

@ -3408,6 +3408,7 @@ ix86_valid_target_attribute_inner_p (tree args, char *p_strings[])
IX86_ATTR_ISA ("3dnow", OPT_m3dnow),
IX86_ATTR_ISA ("abm", OPT_mabm),
IX86_ATTR_ISA ("aes", OPT_maes),
IX86_ATTR_ISA ("avx", OPT_mavx),
IX86_ATTR_ISA ("mmx", OPT_mmmx),
IX86_ATTR_ISA ("pclmul", OPT_mpclmul),
IX86_ATTR_ISA ("popcnt", OPT_mpopcnt),

7
gcc/cp/ChangeLog
View File

@ -1,3 +1,10 @@
2008-12-08 Richard Henderson <rth@redhat.com>
PR 38240
* class.c (finish_struct_bits): Use SET_TYPE_MODE.
* decl.c (record_unknown_type): Likewise.
(start_enum, finish_enum): Likewise.
2008-12-05 Jakub Jelinek <jakub@redhat.com>
PR c++/35336

2
gcc/cp/class.c
View File

@ -1494,7 +1494,7 @@ finish_struct_bits (tree t)
DECL_MODE (TYPE_MAIN_DECL (t)) = BLKmode;
for (variants = t; variants; variants = TYPE_NEXT_VARIANT (variants))
{
TYPE_MODE (variants) = BLKmode;
SET_TYPE_MODE (variants, BLKmode);
TREE_ADDRESSABLE (variants) = 1;
}
}

8
gcc/cp/decl.c
View File

@ -3199,7 +3199,7 @@ record_unknown_type (tree type, const char* name)
TYPE_SIZE (type) = TYPE_SIZE (void_type_node);
TYPE_ALIGN (type) = 1;
TYPE_USER_ALIGN (type) = 0;
TYPE_MODE (type) = TYPE_MODE (void_type_node);
SET_TYPE_MODE (type, TYPE_MODE (void_type_node));
}
/* A string for which we should create an IDENTIFIER_NODE at
@ -10912,7 +10912,7 @@ start_enum (tree name, tree underlying_type, bool scoped_enum_p)
TYPE_MAX_VALUE (enumtype) = TYPE_MAX_VALUE (underlying_type);
TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
TYPE_PRECISION (enumtype) = TYPE_PRECISION (underlying_type);
TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
@ -11065,7 +11065,7 @@ finish_enum (tree enumtype)
applied to the underlying type. */
TYPE_SIZE (enumtype) = TYPE_SIZE (underlying_type);
TYPE_SIZE_UNIT (enumtype) = TYPE_SIZE_UNIT (underlying_type);
TYPE_MODE (enumtype) = TYPE_MODE (underlying_type);
SET_TYPE_MODE (enumtype, TYPE_MODE (underlying_type));
TYPE_ALIGN (enumtype) = TYPE_ALIGN (underlying_type);
TYPE_USER_ALIGN (enumtype) = TYPE_USER_ALIGN (underlying_type);
TYPE_UNSIGNED (enumtype) = TYPE_UNSIGNED (underlying_type);
@ -11133,7 +11133,7 @@ finish_enum (tree enumtype)
TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (enumtype);
TYPE_SIZE (t) = TYPE_SIZE (enumtype);
TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (enumtype);
TYPE_MODE (t) = TYPE_MODE (enumtype);
SET_TYPE_MODE (t, TYPE_MODE (enumtype));
TYPE_PRECISION (t) = TYPE_PRECISION (enumtype);
TYPE_ALIGN (t) = TYPE_ALIGN (enumtype);
TYPE_USER_ALIGN (t) = TYPE_USER_ALIGN (enumtype);

4
gcc/function.c
View File

@ -3987,6 +3987,8 @@ allocate_struct_function (tree fndecl, bool abstract_p)
OVERRIDE_ABI_FORMAT (fndecl);
#endif
invoke_set_current_function_hook (fndecl);
if (fndecl != NULL_TREE)
{
DECL_STRUCT_FUNCTION (fndecl) = cfun;
@ -4012,8 +4014,6 @@ allocate_struct_function (tree fndecl, bool abstract_p)
cfun->va_list_gpr_size = VA_LIST_MAX_GPR_SIZE;
cfun->va_list_fpr_size = VA_LIST_MAX_FPR_SIZE;
}
invoke_set_current_function_hook (fndecl);
}
/* This is like allocate_struct_function, but pushes a new cfun for FNDECL

106
gcc/stor-layout.c
View File

@ -1316,7 +1316,7 @@ compute_record_mode (tree type)
However, if possible, we use a mode that fits in a register
instead, in order to allow for better optimization down the
line. */
TYPE_MODE (type) = BLKmode;
SET_TYPE_MODE (type, BLKmode);
if (! host_integerp (TYPE_SIZE (type), 1))
return;
@ -1360,9 +1360,9 @@ compute_record_mode (tree type)
if (TREE_CODE (type) == RECORD_TYPE && mode != VOIDmode
&& host_integerp (TYPE_SIZE (type), 1)
&& GET_MODE_BITSIZE (mode) == TREE_INT_CST_LOW (TYPE_SIZE (type)))
TYPE_MODE (type) = mode;
SET_TYPE_MODE (type, mode);
else
TYPE_MODE (type) = mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
SET_TYPE_MODE (type, mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1));
/* If structure's known alignment is less than what the scalar
mode would need, and it matters, then stick with BLKmode. */
@ -1374,7 +1374,7 @@ compute_record_mode (tree type)
/* If this is the only reason this type is BLKmode, then
don't force containing types to be BLKmode. */
TYPE_NO_FORCE_BLK (type) = 1;
TYPE_MODE (type) = BLKmode;
SET_TYPE_MODE (type, BLKmode);
}
}
@ -1458,7 +1458,7 @@ finalize_type_size (tree type)
TYPE_SIZE_UNIT (variant) = size_unit;
TYPE_ALIGN (variant) = align;
TYPE_USER_ALIGN (variant) = user_align;
TYPE_MODE (variant) = mode;
SET_TYPE_MODE (variant, mode);
}
}
}
@ -1580,14 +1580,15 @@ layout_type (tree type)
&& tree_int_cst_sgn (TYPE_MIN_VALUE (type)) >= 0)
TYPE_UNSIGNED (type) = 1;
TYPE_MODE (type) = smallest_mode_for_size (TYPE_PRECISION (type),
MODE_INT);
SET_TYPE_MODE (type,
smallest_mode_for_size (TYPE_PRECISION (type), MODE_INT));
TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
break;
case REAL_TYPE:
TYPE_MODE (type) = mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0);
SET_TYPE_MODE (type,
mode_for_size (TYPE_PRECISION (type), MODE_FLOAT, 0));
TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
break;
@ -1600,11 +1601,11 @@ layout_type (tree type)
case COMPLEX_TYPE:
TYPE_UNSIGNED (type) = TYPE_UNSIGNED (TREE_TYPE (type));
TYPE_MODE (type)
= mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
(TREE_CODE (TREE_TYPE (type)) == REAL_TYPE
? MODE_COMPLEX_FLOAT : MODE_COMPLEX_INT),
0);
SET_TYPE_MODE (type,
mode_for_size (2 * TYPE_PRECISION (TREE_TYPE (type)),
(TREE_CODE (TREE_TYPE (type)) == REAL_TYPE
? MODE_COMPLEX_FLOAT : MODE_COMPLEX_INT),
0));
TYPE_SIZE (type) = bitsize_int (GET_MODE_BITSIZE (TYPE_MODE (type)));
TYPE_SIZE_UNIT (type) = size_int (GET_MODE_SIZE (TYPE_MODE (type)));
break;
@ -1636,10 +1637,11 @@ layout_type (tree type)
else
mode = MIN_MODE_VECTOR_INT;
/* Do not check vector_mode_supported_p here. We'll do that
later in vector_type_mode. */
for (; mode != VOIDmode ; mode = GET_MODE_WIDER_MODE (mode))
if (GET_MODE_NUNITS (mode) == nunits
&& GET_MODE_INNER (mode) == innermode
&& targetm.vector_mode_supported_p (mode))
&& GET_MODE_INNER (mode) == innermode)
break;
/* For integers, try mapping it to a same-sized scalar mode. */
@ -1648,10 +1650,12 @@ layout_type (tree type)
mode = mode_for_size (nunits * GET_MODE_BITSIZE (innermode),
MODE_INT, 0);
if (mode == VOIDmode || !have_regs_of_mode[mode])
TYPE_MODE (type) = BLKmode;
if (mode == VOIDmode ||
(GET_MODE_CLASS (mode) == MODE_INT
&& !have_regs_of_mode[mode]))
SET_TYPE_MODE (type, BLKmode);
else
TYPE_MODE (type) = mode;
SET_TYPE_MODE (type, mode);
}
TYPE_SATURATING (type) = TYPE_SATURATING (TREE_TYPE (type));
@ -1672,7 +1676,7 @@ layout_type (tree type)
/* This is an incomplete type and so doesn't have a size. */
TYPE_ALIGN (type) = 1;
TYPE_USER_ALIGN (type) = 0;
TYPE_MODE (type) = VOIDmode;
SET_TYPE_MODE (type, VOIDmode);
break;
case OFFSET_TYPE:
@ -1680,7 +1684,7 @@ layout_type (tree type)
TYPE_SIZE_UNIT (type) = size_int (POINTER_SIZE / BITS_PER_UNIT);
/* A pointer might be MODE_PARTIAL_INT,
but ptrdiff_t must be integral. */
TYPE_MODE (type) = mode_for_size (POINTER_SIZE, MODE_INT, 0);
SET_TYPE_MODE (type, mode_for_size (POINTER_SIZE, MODE_INT, 0));
break;
case FUNCTION_TYPE:
@ -1688,7 +1692,7 @@ layout_type (tree type)
/* It's hard to see what the mode and size of a function ought to
be, but we do know the alignment is FUNCTION_BOUNDARY, so
make it consistent with that. */
TYPE_MODE (type) = mode_for_size (FUNCTION_BOUNDARY, MODE_INT, 0);
SET_TYPE_MODE (type, mode_for_size (FUNCTION_BOUNDARY, MODE_INT, 0));
TYPE_SIZE (type) = bitsize_int (FUNCTION_BOUNDARY);
TYPE_SIZE_UNIT (type) = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
break;
@ -1696,7 +1700,6 @@ layout_type (tree type)
case POINTER_TYPE:
case REFERENCE_TYPE:
{
enum machine_mode mode = ((TREE_CODE (type) == REFERENCE_TYPE
&& reference_types_internal)
? Pmode : TYPE_MODE (type));
@ -1792,7 +1795,7 @@ layout_type (tree type)
fall back on structural equality. */
SET_TYPE_STRUCTURAL_EQUALITY (type);
TYPE_USER_ALIGN (type) = TYPE_USER_ALIGN (element);
TYPE_MODE (type) = BLKmode;
SET_TYPE_MODE (type, BLKmode);
if (TYPE_SIZE (type) != 0
#ifdef MEMBER_TYPE_FORCES_BLK
&& ! MEMBER_TYPE_FORCES_BLK (type, VOIDmode)
@ -1805,17 +1808,17 @@ layout_type (tree type)
/* One-element arrays get the component type's mode. */
if (simple_cst_equal (TYPE_SIZE (type),
TYPE_SIZE (TREE_TYPE (type))))
TYPE_MODE (type) = TYPE_MODE (TREE_TYPE (type));
SET_TYPE_MODE (type, TYPE_MODE (TREE_TYPE (type)));
else
TYPE_MODE (type)
= mode_for_size_tree (TYPE_SIZE (type), MODE_INT, 1);
SET_TYPE_MODE (type, mode_for_size_tree (TYPE_SIZE (type),
MODE_INT, 1));
if (TYPE_MODE (type) != BLKmode
&& STRICT_ALIGNMENT && TYPE_ALIGN (type) < BIGGEST_ALIGNMENT
&& TYPE_ALIGN (type) < GET_MODE_ALIGNMENT (TYPE_MODE (type)))
{
TYPE_NO_FORCE_BLK (type) = 1;
TYPE_MODE (type) = BLKmode;
SET_TYPE_MODE (type, BLKmode);
}
}
/* When the element size is constant, check that it is at least as
@ -1877,6 +1880,45 @@ layout_type (tree type)
if (AGGREGATE_TYPE_P (type))
gcc_assert (!TYPE_ALIAS_SET_KNOWN_P (type));
}
/* Vector types need to re-check the target flags each time we report
the machine mode. We need to do this because attribute target can
change the result of vector_mode_supported_p and have_regs_of_mode
on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can
change on a per-function basis. */
/* ??? Possibly a better solution is to run through all the types
referenced by a function and re-compute the TYPE_MODE once, rather
than make the TYPE_MODE macro call a function. */
enum machine_mode
vector_type_mode (const_tree t)
{
enum machine_mode mode;
gcc_assert (TREE_CODE (t) == VECTOR_TYPE);
mode = t->type.mode;
if (VECTOR_MODE_P (mode)
&& (!targetm.vector_mode_supported_p (mode)
|| !have_regs_of_mode[mode]))
{
enum machine_mode innermode = TREE_TYPE (t)->type.mode;
/* For integers, try mapping it to a same-sized scalar mode. */
if (GET_MODE_CLASS (innermode) == MODE_INT)
{
mode = mode_for_size (TYPE_VECTOR_SUBPARTS (t)
* GET_MODE_BITSIZE (innermode), MODE_INT, 0);
if (mode != VOIDmode && have_regs_of_mode[mode])
return mode;
}
return BLKmode;
}
return mode;
}
/* Create and return a type for signed integers of PRECISION bits. */
@ -1921,10 +1963,10 @@ make_fract_type (int precision, int unsignedp, int satp)
if (unsignedp)
{
TYPE_UNSIGNED (type) = 1;
TYPE_MODE (type) = mode_for_size (precision, MODE_UFRACT, 0);
SET_TYPE_MODE (type, mode_for_size (precision, MODE_UFRACT, 0));
}
else
TYPE_MODE (type) = mode_for_size (precision, MODE_FRACT, 0);
SET_TYPE_MODE (type, mode_for_size (precision, MODE_FRACT, 0));
layout_type (type);
return type;
@ -1947,10 +1989,10 @@ make_accum_type (int precision, int unsignedp, int satp)
if (unsignedp)
{
TYPE_UNSIGNED (type) = 1;
TYPE_MODE (type) = mode_for_size (precision, MODE_UACCUM, 0);
SET_TYPE_MODE (type, mode_for_size (precision, MODE_UACCUM, 0));
}
else
TYPE_MODE (type) = mode_for_size (precision, MODE_ACCUM, 0);
SET_TYPE_MODE (type, mode_for_size (precision, MODE_ACCUM, 0));
layout_type (type);
return type;
@ -1965,7 +2007,7 @@ initialize_sizetypes (bool signed_p)
tree t = make_node (INTEGER_TYPE);
int precision = GET_MODE_BITSIZE (SImode);
TYPE_MODE (t) = SImode;
SET_TYPE_MODE (t, SImode);
TYPE_ALIGN (t) = GET_MODE_ALIGNMENT (SImode);
TYPE_USER_ALIGN (t) = 0;
TYPE_IS_SIZETYPE (t) = 1;

8
gcc/testsuite/gcc.target/i386/pr38240.c Normal file
View File

@ -0,0 +1,8 @@
/* { dg-do compile } */
typedef float V
__attribute__ ((__vector_size__ (16), __may_alias__));
V __attribute__((target("sse"))) f(const V *ptr) { return *ptr; }
V g(const V *ptr) { return *ptr; }

16
gcc/tree.c
View File

@ -5522,7 +5522,7 @@ build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
t = make_node (POINTER_TYPE);
TREE_TYPE (t) = to_type;
TYPE_MODE (t) = mode;
SET_TYPE_MODE (t, mode);
TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
TYPE_POINTER_TO (to_type) = t;
@ -5586,7 +5586,7 @@ build_reference_type_for_mode (tree to_type, enum machine_mode mode,
t = make_node (REFERENCE_TYPE);
TREE_TYPE (t) = to_type;
TYPE_MODE (t) = mode;
SET_TYPE_MODE (t, mode);
TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
TYPE_REFERENCE_TO (to_type) = t;
@ -5655,7 +5655,7 @@ build_index_type (tree maxval)
TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
TYPE_MIN_VALUE (itype) = size_zero_node;
TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
TYPE_MODE (itype) = TYPE_MODE (sizetype);
SET_TYPE_MODE (itype, TYPE_MODE (sizetype));
TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
@ -5711,7 +5711,7 @@ build_range_type (tree type, tree lowval, tree highval)
TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
TYPE_PRECISION (itype) = TYPE_PRECISION (type);
TYPE_MODE (itype) = TYPE_MODE (type);
SET_TYPE_MODE (itype, TYPE_MODE (type));
TYPE_SIZE (itype) = TYPE_SIZE (type);
TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
TYPE_ALIGN (itype) = TYPE_ALIGN (type);
@ -7296,7 +7296,7 @@ make_vector_type (tree innertype, int nunits, enum machine_mode mode)
t = make_node (VECTOR_TYPE);
TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
SET_TYPE_VECTOR_SUBPARTS (t, nunits);
TYPE_MODE (t) = mode;
SET_TYPE_MODE (t, mode);
TYPE_READONLY (t) = TYPE_READONLY (innertype);
TYPE_VOLATILE (t) = TYPE_VOLATILE (innertype);
@ -7553,19 +7553,19 @@ build_common_tree_nodes_2 (int short_double)
dfloat32_type_node = make_node (REAL_TYPE);
TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
layout_type (dfloat32_type_node);
TYPE_MODE (dfloat32_type_node) = SDmode;
SET_TYPE_MODE (dfloat32_type_node, SDmode);
dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
dfloat64_type_node = make_node (REAL_TYPE);
TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
layout_type (dfloat64_type_node);
TYPE_MODE (dfloat64_type_node) = DDmode;
SET_TYPE_MODE (dfloat64_type_node, DDmode);
dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
dfloat128_type_node = make_node (REAL_TYPE);
TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
layout_type (dfloat128_type_node);
TYPE_MODE (dfloat128_type_node) = TDmode;
SET_TYPE_MODE (dfloat128_type_node, TDmode);
dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
complex_integer_type_node = build_complex_type (integer_type_node);

9
gcc/tree.h
View File

@ -2050,7 +2050,6 @@ struct tree_block GTY(())
#define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type.uid)
#define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type.size)
#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit)
#define TYPE_MODE(NODE) (TYPE_CHECK (NODE)->type.mode)
#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values)
#define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type.values)
#define TYPE_FIELDS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.values)
@ -2078,6 +2077,14 @@ struct tree_block GTY(())
#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
#define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context)
/* Vector types need to check target flags to determine type. */
extern enum machine_mode vector_type_mode (const_tree);
#define TYPE_MODE(NODE) \
(TREE_CODE (TYPE_CHECK (NODE)) == VECTOR_TYPE \
? vector_type_mode (NODE) : (NODE)->type.mode)
#define SET_TYPE_MODE(NODE, MODE) \
(TYPE_CHECK (NODE)->type.mode = (MODE))
/* The "canonical" type for this type node, which can be used to
compare the type for equality with another type. If two types are
equal (based on the semantics of the language), then they will have