From e52403bc16be7cd4d5ba8584b7cf3b6788cad8c0 Mon Sep 17 00:00:00 2001 From: Richard Guenther Date: Tue, 3 Jan 2012 15:28:19 +0000 Subject: [PATCH] backport: re PR middle-end/50189 (Wrong code error in -O2 [-fstrict-enums] compile, target independent) 2012-01-03 Richard Guenther Backport from mainline 2011-10-12 Paul Koning PR tree-optimization/50189 * tree-vrp.c (extract_range_from_assert): Use the type of the variable, not the limit. * g++.dg/torture/pr50189.C: New testcase. From-SVN: r182850 --- gcc/ChangeLog | 9 ++ gcc/testsuite/ChangeLog | 8 ++ gcc/testsuite/g++.dg/torture/pr50189.C | 120 +++++++++++++++++++++++++ gcc/tree-vrp.c | 10 +-- 4 files changed, 142 insertions(+), 5 deletions(-) create mode 100644 gcc/testsuite/g++.dg/torture/pr50189.C diff --git a/gcc/ChangeLog b/gcc/ChangeLog index d8f3174d587a..148276d819f6 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,12 @@ +2012-01-03 Richard Guenther + + Backport from mainline + 2011-10-12 Paul Koning + + PR tree-optimization/50189 + * tree-vrp.c (extract_range_from_assert): Use the type of + the variable, not the limit. + 2012-01-03 Richard Guenther Backport from mainline diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 1fedf3408125..52d9121408ca 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,11 @@ +2012-01-03 Richard Guenther + + Backport from mainline + 2011-10-12 Paul Koning + + PR tree-optimization/50189 + * g++.dg/torture/pr50189.C: New testcase. + 2012-01-03 Richard Guenther Backport from mainline diff --git a/gcc/testsuite/g++.dg/torture/pr50189.C b/gcc/testsuite/g++.dg/torture/pr50189.C new file mode 100644 index 000000000000..519e1a48ad40 --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr50189.C @@ -0,0 +1,120 @@ +// { dg-do run } + +extern "C" void abort (void); +class CCUTILS_KeyedScalarLevelPosition +{ +public: + + typedef enum + { + UNINITED = 0, + AT_BEGIN = 1, + AT_END = 2, + AT_KEY = 3 + + } position_t; + + bool is_init() const + { return(m_timestamp != UNINITED); } + + bool is_at_begin() const + { return(m_timestamp == AT_BEGIN); } + + position_t get_state() const + { + return((m_timestamp >= AT_KEY) + ? AT_KEY + : ((position_t)m_timestamp)); + } + + void set_at_begin() + { m_timestamp = AT_BEGIN; } + + unsigned int get_index() const + { return(m_index); } + + void set_pos(unsigned int a_index, unsigned int a_timestmap) + { + m_index = a_index; + m_timestamp = a_timestmap; + } + + bool check_pos(unsigned int a_num_entries, unsigned int a_timestamp) const + { + if (get_state() != AT_KEY) + return(false); + + if (m_timestamp != a_timestamp) + return(false); + + return(m_index < a_num_entries); + } + + void set_not_init() + { m_timestamp = 0; } + +private: + + unsigned int m_timestamp; + unsigned int m_index; + +}; + +class CCUTILS_KeyedScalarPosition +{ +public: + + CCUTILS_KeyedScalarLevelPosition m_L1; + CCUTILS_KeyedScalarLevelPosition m_L2; +}; + +class baz +{ +public: + int *n[20]; + unsigned int m_cur_array_len; + unsigned int m_timestamp; + + unsigned int _get_timestamp() const + { return(m_timestamp); } + + bool _check_L1_pos(const CCUTILS_KeyedScalarPosition &a_position) const + { + return(a_position.m_L1.check_pos( + m_cur_array_len, _get_timestamp())); + } + + void *next (CCUTILS_KeyedScalarPosition &); +}; + +void * baz::next (CCUTILS_KeyedScalarPosition &a_position) +{ + if (a_position.m_L1.is_at_begin() || (!a_position.m_L1.is_init())) + { + a_position.m_L1.set_pos(0, _get_timestamp()); + a_position.m_L2.set_at_begin(); + } + else if (!_check_L1_pos(a_position)) + return(0); + + return n[a_position.m_L1.get_index ()]; +} + +int main (int, char **) +{ + baz obj; + CCUTILS_KeyedScalarPosition a_pos; + void *ret; + int n[5]; + + obj.n[0] = n; + obj.m_cur_array_len = 1; + obj.m_timestamp = 42; + + a_pos.m_L1.set_pos (0, 42); + + ret = obj.next (a_pos); + if (ret == 0) + abort (); + return 0; +} diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 62011fd0b96e..3ed7b56e8a60 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -1445,7 +1445,7 @@ extract_range_from_assert (value_range_t *vr_p, tree expr) limit = avoid_overflow_infinity (limit); - type = TREE_TYPE (limit); + type = TREE_TYPE (var); gcc_assert (limit != var); /* For pointer arithmetic, we only keep track of pointer equality @@ -1619,8 +1619,8 @@ extract_range_from_assert (value_range_t *vr_p, tree expr) /* For LT_EXPR, we create the range [MIN, MAX - 1]. */ if (cond_code == LT_EXPR) { - tree one = build_int_cst (type, 1); - max = fold_build2 (MINUS_EXPR, type, max, one); + tree one = build_int_cst (TREE_TYPE (max), 1); + max = fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, one); if (EXPR_P (max)) TREE_NO_WARNING (max) = 1; } @@ -1654,8 +1654,8 @@ extract_range_from_assert (value_range_t *vr_p, tree expr) /* For GT_EXPR, we create the range [MIN + 1, MAX]. */ if (cond_code == GT_EXPR) { - tree one = build_int_cst (type, 1); - min = fold_build2 (PLUS_EXPR, type, min, one); + tree one = build_int_cst (TREE_TYPE (min), 1); + min = fold_build2 (PLUS_EXPR, TREE_TYPE (min), min, one); if (EXPR_P (min)) TREE_NO_WARNING (min) = 1; } -- 2.47.2