1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
From: Felix Fietkau <nbd@nbd.name>
Date: Tue, 16 Nov 2021 10:39:51 +0100
Subject: [PATCH] Revert "Cleanup range of address calculations."
This reverts commit 47923622c663ffad8b14aa93706183290d4f6791.
This commit is causing issues with offset of struct members.
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=103255
---
delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr78655.c
--- a/gcc/gimple-range.cc
+++ b/gcc/gimple-range.cc
@@ -431,9 +431,8 @@ gimple_ranger::range_of_range_op (irange
m_cache.register_dependency (lhs, op2);
}
- if (gimple_code (s) == GIMPLE_ASSIGN
- && gimple_assign_rhs_code (s) == ADDR_EXPR)
- return range_of_address (r, s);
+ if (range_of_non_trivial_assignment (r, s))
+ return true;
if (range_of_expr (range1, op1, s))
{
@@ -447,84 +446,48 @@ gimple_ranger::range_of_range_op (irange
return true;
}
-// Calculate the range of an assignment containing an ADDR_EXPR.
+// Calculate the range of a non-trivial assignment. That is, is one
+// inolving arithmetic on an SSA name (for example, an ADDR_EXPR).
// Return the range in R.
-// If a range cannot be calculated, set it to VARYING and return true.
+//
+// If a range cannot be calculated, return false.
bool
-gimple_ranger::range_of_address (irange &r, gimple *stmt)
+gimple_ranger::range_of_non_trivial_assignment (irange &r, gimple *stmt)
{
- gcc_checking_assert (gimple_code (stmt) == GIMPLE_ASSIGN);
- gcc_checking_assert (gimple_assign_rhs_code (stmt) == ADDR_EXPR);
+ if (gimple_code (stmt) != GIMPLE_ASSIGN)
+ return false;
- bool strict_overflow_p;
- tree expr = gimple_assign_rhs1 (stmt);
- poly_int64 bitsize, bitpos;
- tree offset;
- machine_mode mode;
- int unsignedp, reversep, volatilep;
- tree base = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize,
- &bitpos, &offset, &mode, &unsignedp,
- &reversep, &volatilep);
-
-
- if (base != NULL_TREE
- && TREE_CODE (base) == MEM_REF
- && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
+ tree base = gimple_range_base_of_assignment (stmt);
+ if (base)
{
- tree ssa = TREE_OPERAND (base, 0);
- gcc_checking_assert (irange::supports_type_p (TREE_TYPE (ssa)));
- range_of_expr (r, ssa, stmt);
- range_cast (r, TREE_TYPE (gimple_assign_rhs1 (stmt)));
-
- poly_offset_int off = 0;
- bool off_cst = false;
- if (offset == NULL_TREE || TREE_CODE (offset) == INTEGER_CST)
+ if (TREE_CODE (base) == MEM_REF)
{
- off = mem_ref_offset (base);
- if (offset)
- off += poly_offset_int::from (wi::to_poly_wide (offset),
- SIGNED);
- off <<= LOG2_BITS_PER_UNIT;
- off += bitpos;
- off_cst = true;
+ if (TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
+ {
+ int_range_max range1;
+ tree ssa = TREE_OPERAND (base, 0);
+ if (range_of_expr (range1, ssa, stmt))
+ {
+ tree type = TREE_TYPE (ssa);
+ range_operator *op = range_op_handler (POINTER_PLUS_EXPR,
+ type);
+ int_range<2> offset (TREE_OPERAND (base, 1),
+ TREE_OPERAND (base, 1));
+ op->fold_range (r, type, range1, offset);
+ return true;
+ }
+ }
+ return false;
}
- /* If &X->a is equal to X, the range of X is the result. */
- if (off_cst && known_eq (off, 0))
- return true;
- else if (flag_delete_null_pointer_checks
- && !TYPE_OVERFLOW_WRAPS (TREE_TYPE (expr)))
- {
- /* For -fdelete-null-pointer-checks -fno-wrapv-pointer we don't
- allow going from non-NULL pointer to NULL. */
- if(!range_includes_zero_p (&r))
- return true;
- }
- /* If MEM_REF has a "positive" offset, consider it non-NULL
- always, for -fdelete-null-pointer-checks also "negative"
- ones. Punt for unknown offsets (e.g. variable ones). */
- if (!TYPE_OVERFLOW_WRAPS (TREE_TYPE (expr))
- && off_cst
- && known_ne (off, 0)
- && (flag_delete_null_pointer_checks || known_gt (off, 0)))
+ if (gimple_assign_rhs_code (stmt) == ADDR_EXPR)
{
+ // Handle "= &a" and return non-zero.
r = range_nonzero (TREE_TYPE (gimple_assign_rhs1 (stmt)));
return true;
}
- r = int_range<2> (TREE_TYPE (gimple_assign_rhs1 (stmt)));
- return true;
- }
-
- // Handle "= &a".
- if (tree_single_nonzero_warnv_p (expr, &strict_overflow_p))
- {
- r = range_nonzero (TREE_TYPE (gimple_assign_rhs1 (stmt)));
- return true;
}
-
- // Otherwise return varying.
- r = int_range<2> (TREE_TYPE (gimple_assign_rhs1 (stmt)));
- return true;
+ return false;
}
// Calculate a range for phi statement S and return it in R.
--- a/gcc/gimple-range.h
+++ b/gcc/gimple-range.h
@@ -62,7 +62,7 @@ protected:
ranger_cache m_cache;
private:
bool range_of_phi (irange &r, gphi *phi);
- bool range_of_address (irange &r, gimple *s);
+ bool range_of_non_trivial_assignment (irange &r, gimple *s);
bool range_of_builtin_call (irange &r, gcall *call);
bool range_with_loop_info (irange &r, tree name);
void range_of_ssa_name_with_loop_info (irange &, tree, class loop *,
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -3447,7 +3447,6 @@ pointer_table::pointer_table ()
set (GT_EXPR, op_gt);
set (GE_EXPR, op_ge);
set (SSA_NAME, op_identity);
- set (INTEGER_CST, op_integer_cst);
set (ADDR_EXPR, op_addr);
set (NOP_EXPR, op_convert);
set (CONVERT_EXPR, op_convert);
|
