From 179d2f74d481593a39387918f89ef5766d9c64ea Mon Sep 17 00:00:00 2001 From: Richard Henderson Date: Mon, 8 Dec 2008 09:12:55 -0800 Subject: [PATCH] re PR middle-end/38240 (Vector type definitions not compatible with attribute target) 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 --- gcc/ChangeLog | 20 ++++++ gcc/c-decl.c | 4 +- gcc/config/i386/i386.c | 1 + gcc/cp/ChangeLog | 7 +++ gcc/cp/class.c | 2 +- gcc/cp/decl.c | 8 +-- gcc/function.c | 4 +- gcc/stor-layout.c | 106 ++++++++++++++++++++++---------- gcc/testsuite/gcc.target/i386/pr38240.c | 8 +++ gcc/tree.c | 16 ++--- gcc/tree.h | 9 ++- 11 files changed, 135 insertions(+), 50 deletions(-) create mode 100644 gcc/testsuite/gcc.target/i386/pr38240.c diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 2b4f6fa..2489791 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,23 @@ +2008-12-08 Richard Henderson + + 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 * alias.c (find_base_term): Synch LO_SUM handling with what diff --git a/gcc/c-decl.c b/gcc/c-decl.c index 6f88f62..7f7f2b0 100644 --- a/gcc/c-decl.c +++ b/gcc/c-decl.c @@ -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); diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c index f83ed7e..71fbeac 100644 --- a/gcc/config/i386/i386.c +++ b/gcc/config/i386/i386.c @@ -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), diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index dab6ed0..662fe32 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,10 @@ +2008-12-08 Richard Henderson + + 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 PR c++/35336 diff --git a/gcc/cp/class.c b/gcc/cp/class.c index 8553139..97ab9e3 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -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; } } diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 70ccd32..e786b39 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -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); diff --git a/gcc/function.c b/gcc/function.c index 0320871..2ed1748 100644 --- a/gcc/function.c +++ b/gcc/function.c @@ -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 diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c index 1765461..0e7caa5 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -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; diff --git a/gcc/testsuite/gcc.target/i386/pr38240.c b/gcc/testsuite/gcc.target/i386/pr38240.c new file mode 100644 index 0000000..6a35687 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr38240.c @@ -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; } diff --git a/gcc/tree.c b/gcc/tree.c index e74b779..03c54cc 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -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); diff --git a/gcc/tree.h b/gcc/tree.h index d85918f..55163b6 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -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 -- 2.7.4