Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-ssa-address.c @ 143:76e1cf5455ef
add cbc_gc test
author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
---|---|
date | Sun, 23 Dec 2018 19:24:05 +0900 |
parents | 84e7813d76e9 |
children | 1830386684a0 |
rev | line source |
---|---|
0 | 1 /* Memory address lowering and addressing mode selection. |
131 | 2 Copyright (C) 2004-2018 Free Software Foundation, Inc. |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3 |
0 | 4 This file is part of GCC. |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
5 |
0 | 6 GCC is free software; you can redistribute it and/or modify it |
7 under the terms of the GNU General Public License as published by the | |
8 Free Software Foundation; either version 3, or (at your option) any | |
9 later version. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
10 |
0 | 11 GCC is distributed in the hope that it will be useful, but WITHOUT |
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
14 for more details. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
15 |
0 | 16 You should have received a copy of the GNU General Public License |
17 along with GCC; see the file COPYING3. If not see | |
18 <http://www.gnu.org/licenses/>. */ | |
19 | |
20 /* Utility functions for manipulation with TARGET_MEM_REFs -- tree expressions | |
21 that directly map to addressing modes of the target. */ | |
22 | |
23 #include "config.h" | |
24 #include "system.h" | |
25 #include "coretypes.h" | |
111 | 26 #include "backend.h" |
27 #include "target.h" | |
28 #include "rtl.h" | |
0 | 29 #include "tree.h" |
111 | 30 #include "gimple.h" |
31 #include "memmodel.h" | |
32 #include "stringpool.h" | |
33 #include "tree-vrp.h" | |
34 #include "tree-ssanames.h" | |
35 #include "expmed.h" | |
36 #include "insn-config.h" | |
37 #include "emit-rtl.h" | |
38 #include "recog.h" | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
39 #include "tree-pretty-print.h" |
111 | 40 #include "fold-const.h" |
41 #include "stor-layout.h" | |
42 #include "gimple-iterator.h" | |
43 #include "gimplify-me.h" | |
44 #include "tree-ssa-loop-ivopts.h" | |
45 #include "expr.h" | |
46 #include "tree-dfa.h" | |
47 #include "dumpfile.h" | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
48 #include "tree-affine.h" |
111 | 49 #include "gimplify.h" |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
50 |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
51 /* FIXME: We compute address costs using RTL. */ |
111 | 52 #include "tree-ssa-address.h" |
0 | 53 |
54 /* TODO -- handling of symbols (according to Richard Hendersons | |
55 comments, http://gcc.gnu.org/ml/gcc-patches/2005-04/msg00949.html): | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
56 |
0 | 57 There are at least 5 different kinds of symbols that we can run up against: |
58 | |
59 (1) binds_local_p, small data area. | |
60 (2) binds_local_p, eg local statics | |
61 (3) !binds_local_p, eg global variables | |
62 (4) thread local, local_exec | |
63 (5) thread local, !local_exec | |
64 | |
65 Now, (1) won't appear often in an array context, but it certainly can. | |
66 All you have to do is set -GN high enough, or explicitly mark any | |
67 random object __attribute__((section (".sdata"))). | |
68 | |
69 All of these affect whether or not a symbol is in fact a valid address. | |
70 The only one tested here is (3). And that result may very well | |
71 be incorrect for (4) or (5). | |
72 | |
73 An incorrect result here does not cause incorrect results out the | |
74 back end, because the expander in expr.c validizes the address. However | |
75 it would be nice to improve the handling here in order to produce more | |
76 precise results. */ | |
77 | |
78 /* A "template" for memory address, used to determine whether the address is | |
79 valid for mode. */ | |
80 | |
111 | 81 struct GTY (()) mem_addr_template { |
0 | 82 rtx ref; /* The template. */ |
83 rtx * GTY ((skip)) step_p; /* The point in template where the step should be | |
84 filled in. */ | |
85 rtx * GTY ((skip)) off_p; /* The point in template where the offset should | |
86 be filled in. */ | |
111 | 87 }; |
0 | 88 |
89 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
90 /* The templates. Each of the low five bits of the index corresponds to one |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
91 component of TARGET_MEM_REF being present, while the high bits identify |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
92 the address space. See TEMPL_IDX. */ |
0 | 93 |
111 | 94 static GTY(()) vec<mem_addr_template, va_gc> *mem_addr_template_list; |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
95 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
96 #define TEMPL_IDX(AS, SYMBOL, BASE, INDEX, STEP, OFFSET) \ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
97 (((int) (AS) << 5) \ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
98 | ((SYMBOL != 0) << 4) \ |
0 | 99 | ((BASE != 0) << 3) \ |
100 | ((INDEX != 0) << 2) \ | |
101 | ((STEP != 0) << 1) \ | |
102 | (OFFSET != 0)) | |
103 | |
104 /* Stores address for memory reference with parameters SYMBOL, BASE, INDEX, | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
105 STEP and OFFSET to *ADDR using address mode ADDRESS_MODE. Stores pointers |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
106 to where step is placed to *STEP_P and offset to *OFFSET_P. */ |
0 | 107 |
108 static void | |
111 | 109 gen_addr_rtx (machine_mode address_mode, |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
110 rtx symbol, rtx base, rtx index, rtx step, rtx offset, |
0 | 111 rtx *addr, rtx **step_p, rtx **offset_p) |
112 { | |
113 rtx act_elem; | |
114 | |
115 *addr = NULL_RTX; | |
116 if (step_p) | |
117 *step_p = NULL; | |
118 if (offset_p) | |
119 *offset_p = NULL; | |
120 | |
111 | 121 if (index && index != const0_rtx) |
0 | 122 { |
123 act_elem = index; | |
124 if (step) | |
125 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
126 act_elem = gen_rtx_MULT (address_mode, act_elem, step); |
0 | 127 |
128 if (step_p) | |
129 *step_p = &XEXP (act_elem, 1); | |
130 } | |
131 | |
132 *addr = act_elem; | |
133 } | |
134 | |
111 | 135 if (base && base != const0_rtx) |
0 | 136 { |
137 if (*addr) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
138 *addr = simplify_gen_binary (PLUS, address_mode, base, *addr); |
0 | 139 else |
140 *addr = base; | |
141 } | |
142 | |
143 if (symbol) | |
144 { | |
145 act_elem = symbol; | |
146 if (offset) | |
147 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
148 act_elem = gen_rtx_PLUS (address_mode, act_elem, offset); |
0 | 149 |
150 if (offset_p) | |
151 *offset_p = &XEXP (act_elem, 1); | |
152 | |
153 if (GET_CODE (symbol) == SYMBOL_REF | |
154 || GET_CODE (symbol) == LABEL_REF | |
155 || GET_CODE (symbol) == CONST) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
156 act_elem = gen_rtx_CONST (address_mode, act_elem); |
0 | 157 } |
158 | |
159 if (*addr) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
160 *addr = gen_rtx_PLUS (address_mode, *addr, act_elem); |
0 | 161 else |
162 *addr = act_elem; | |
163 } | |
164 else if (offset) | |
165 { | |
166 if (*addr) | |
167 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
168 *addr = gen_rtx_PLUS (address_mode, *addr, offset); |
0 | 169 if (offset_p) |
170 *offset_p = &XEXP (*addr, 1); | |
171 } | |
172 else | |
173 { | |
174 *addr = offset; | |
175 if (offset_p) | |
176 *offset_p = addr; | |
177 } | |
178 } | |
179 | |
180 if (!*addr) | |
181 *addr = const0_rtx; | |
182 } | |
183 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
184 /* Returns address for TARGET_MEM_REF with parameters given by ADDR |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
185 in address space AS. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
186 If REALLY_EXPAND is false, just make fake registers instead |
0 | 187 of really expanding the operands, and perform the expansion in-place |
188 by using one of the "templates". */ | |
189 | |
190 rtx | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
191 addr_for_mem_ref (struct mem_address *addr, addr_space_t as, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
192 bool really_expand) |
0 | 193 { |
111 | 194 scalar_int_mode address_mode = targetm.addr_space.address_mode (as); |
195 scalar_int_mode pointer_mode = targetm.addr_space.pointer_mode (as); | |
0 | 196 rtx address, sym, bse, idx, st, off; |
197 struct mem_addr_template *templ; | |
198 | |
199 if (addr->step && !integer_onep (addr->step)) | |
111 | 200 st = immed_wide_int_const (wi::to_wide (addr->step), pointer_mode); |
0 | 201 else |
202 st = NULL_RTX; | |
203 | |
204 if (addr->offset && !integer_zerop (addr->offset)) | |
111 | 205 { |
131 | 206 poly_offset_int dc |
207 = poly_offset_int::from (wi::to_poly_wide (addr->offset), SIGNED); | |
111 | 208 off = immed_wide_int_const (dc, pointer_mode); |
209 } | |
0 | 210 else |
211 off = NULL_RTX; | |
212 | |
213 if (!really_expand) | |
214 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
215 unsigned int templ_index |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
216 = TEMPL_IDX (as, addr->symbol, addr->base, addr->index, st, off); |
0 | 217 |
111 | 218 if (templ_index >= vec_safe_length (mem_addr_template_list)) |
219 vec_safe_grow_cleared (mem_addr_template_list, templ_index + 1); | |
0 | 220 |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
221 /* Reuse the templates for addresses, so that we do not waste memory. */ |
111 | 222 templ = &(*mem_addr_template_list)[templ_index]; |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
223 if (!templ->ref) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
224 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
225 sym = (addr->symbol ? |
111 | 226 gen_rtx_SYMBOL_REF (pointer_mode, ggc_strdup ("test_symbol")) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
227 : NULL_RTX); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
228 bse = (addr->base ? |
111 | 229 gen_raw_REG (pointer_mode, LAST_VIRTUAL_REGISTER + 1) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
230 : NULL_RTX); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
231 idx = (addr->index ? |
111 | 232 gen_raw_REG (pointer_mode, LAST_VIRTUAL_REGISTER + 2) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
233 : NULL_RTX); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
234 |
111 | 235 gen_addr_rtx (pointer_mode, sym, bse, idx, |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
236 st? const0_rtx : NULL_RTX, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
237 off? const0_rtx : NULL_RTX, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
238 &templ->ref, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
239 &templ->step_p, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
240 &templ->off_p); |
0 | 241 } |
242 | |
243 if (st) | |
244 *templ->step_p = st; | |
245 if (off) | |
246 *templ->off_p = off; | |
247 | |
248 return templ->ref; | |
249 } | |
250 | |
251 /* Otherwise really expand the expressions. */ | |
252 sym = (addr->symbol | |
111 | 253 ? expand_expr (addr->symbol, NULL_RTX, pointer_mode, EXPAND_NORMAL) |
0 | 254 : NULL_RTX); |
255 bse = (addr->base | |
111 | 256 ? expand_expr (addr->base, NULL_RTX, pointer_mode, EXPAND_NORMAL) |
0 | 257 : NULL_RTX); |
258 idx = (addr->index | |
111 | 259 ? expand_expr (addr->index, NULL_RTX, pointer_mode, EXPAND_NORMAL) |
0 | 260 : NULL_RTX); |
261 | |
111 | 262 gen_addr_rtx (pointer_mode, sym, bse, idx, st, off, &address, NULL, NULL); |
263 if (pointer_mode != address_mode) | |
264 address = convert_memory_address (address_mode, address); | |
0 | 265 return address; |
266 } | |
267 | |
111 | 268 /* implement addr_for_mem_ref() directly from a tree, which avoids exporting |
269 the mem_address structure. */ | |
270 | |
271 rtx | |
272 addr_for_mem_ref (tree exp, addr_space_t as, bool really_expand) | |
273 { | |
274 struct mem_address addr; | |
275 get_address_description (exp, &addr); | |
276 return addr_for_mem_ref (&addr, as, really_expand); | |
277 } | |
278 | |
0 | 279 /* Returns address of MEM_REF in TYPE. */ |
280 | |
281 tree | |
282 tree_mem_ref_addr (tree type, tree mem_ref) | |
283 { | |
284 tree addr; | |
285 tree act_elem; | |
286 tree step = TMR_STEP (mem_ref), offset = TMR_OFFSET (mem_ref); | |
287 tree addr_base = NULL_TREE, addr_off = NULL_TREE; | |
288 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
289 addr_base = fold_convert (type, TMR_BASE (mem_ref)); |
0 | 290 |
291 act_elem = TMR_INDEX (mem_ref); | |
292 if (act_elem) | |
293 { | |
294 if (step) | |
111 | 295 act_elem = fold_build2 (MULT_EXPR, TREE_TYPE (act_elem), |
296 act_elem, step); | |
0 | 297 addr_off = act_elem; |
298 } | |
299 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
300 act_elem = TMR_INDEX2 (mem_ref); |
0 | 301 if (act_elem) |
302 { | |
303 if (addr_off) | |
111 | 304 addr_off = fold_build2 (PLUS_EXPR, TREE_TYPE (addr_off), |
305 addr_off, act_elem); | |
0 | 306 else |
307 addr_off = act_elem; | |
308 } | |
309 | |
310 if (offset && !integer_zerop (offset)) | |
311 { | |
312 if (addr_off) | |
111 | 313 addr_off = fold_build2 (PLUS_EXPR, TREE_TYPE (addr_off), addr_off, |
314 fold_convert (TREE_TYPE (addr_off), offset)); | |
0 | 315 else |
316 addr_off = offset; | |
317 } | |
318 | |
319 if (addr_off) | |
111 | 320 addr = fold_build_pointer_plus (addr_base, addr_off); |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
321 else |
0 | 322 addr = addr_base; |
323 | |
324 return addr; | |
325 } | |
326 | |
327 /* Returns true if a memory reference in MODE and with parameters given by | |
328 ADDR is valid on the current target. */ | |
329 | |
111 | 330 bool |
331 valid_mem_ref_p (machine_mode mode, addr_space_t as, | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
332 struct mem_address *addr) |
0 | 333 { |
334 rtx address; | |
335 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
336 address = addr_for_mem_ref (addr, as, false); |
0 | 337 if (!address) |
338 return false; | |
339 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
340 return memory_address_addr_space_p (mode, address, as); |
0 | 341 } |
342 | |
343 /* Checks whether a TARGET_MEM_REF with type TYPE and parameters given by ADDR | |
344 is valid on the current target and if so, creates and returns the | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
345 TARGET_MEM_REF. If VERIFY is false omit the verification step. */ |
0 | 346 |
347 static tree | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
348 create_mem_ref_raw (tree type, tree alias_ptr_type, struct mem_address *addr, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
349 bool verify) |
0 | 350 { |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
351 tree base, index2; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
352 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
353 if (verify |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
354 && !valid_mem_ref_p (TYPE_MODE (type), TYPE_ADDR_SPACE (type), addr)) |
0 | 355 return NULL_TREE; |
356 | |
357 if (addr->step && integer_onep (addr->step)) | |
358 addr->step = NULL_TREE; | |
359 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
360 if (addr->offset) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
361 addr->offset = fold_convert (alias_ptr_type, addr->offset); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
362 else |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
363 addr->offset = build_int_cst (alias_ptr_type, 0); |
0 | 364 |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
365 if (addr->symbol) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
366 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
367 base = addr->symbol; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
368 index2 = addr->base; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
369 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
370 else if (addr->base |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
371 && POINTER_TYPE_P (TREE_TYPE (addr->base))) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
372 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
373 base = addr->base; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
374 index2 = NULL_TREE; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
375 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
376 else |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
377 { |
111 | 378 base = build_int_cst (build_pointer_type (type), 0); |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
379 index2 = addr->base; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
380 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
381 |
111 | 382 /* If possible use a plain MEM_REF instead of a TARGET_MEM_REF. |
383 ??? As IVOPTs does not follow restrictions to where the base | |
384 pointer may point to create a MEM_REF only if we know that | |
385 base is valid. */ | |
386 if ((TREE_CODE (base) == ADDR_EXPR || TREE_CODE (base) == INTEGER_CST) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
387 && (!index2 || integer_zerop (index2)) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
388 && (!addr->index || integer_zerop (addr->index))) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
389 return fold_build2 (MEM_REF, type, base, addr->offset); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
390 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
391 return build5 (TARGET_MEM_REF, type, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
392 base, addr->offset, addr->index, addr->step, index2); |
0 | 393 } |
394 | |
395 /* Returns true if OBJ is an object whose address is a link time constant. */ | |
396 | |
397 static bool | |
398 fixed_address_object_p (tree obj) | |
399 { | |
111 | 400 return (VAR_P (obj) |
401 && (TREE_STATIC (obj) || DECL_EXTERNAL (obj)) | |
0 | 402 && ! DECL_DLLIMPORT_P (obj)); |
403 } | |
404 | |
405 /* If ADDR contains an address of object that is a link time constant, | |
406 move it to PARTS->symbol. */ | |
407 | |
111 | 408 void |
0 | 409 move_fixed_address_to_symbol (struct mem_address *parts, aff_tree *addr) |
410 { | |
411 unsigned i; | |
412 tree val = NULL_TREE; | |
413 | |
414 for (i = 0; i < addr->n; i++) | |
415 { | |
111 | 416 if (addr->elts[i].coef != 1) |
0 | 417 continue; |
418 | |
419 val = addr->elts[i].val; | |
420 if (TREE_CODE (val) == ADDR_EXPR | |
421 && fixed_address_object_p (TREE_OPERAND (val, 0))) | |
422 break; | |
423 } | |
424 | |
425 if (i == addr->n) | |
426 return; | |
427 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
428 parts->symbol = val; |
0 | 429 aff_combination_remove_elt (addr, i); |
430 } | |
431 | |
111 | 432 /* Return true if ADDR contains an instance of BASE_HINT and it's moved to |
433 PARTS->base. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
434 |
111 | 435 static bool |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
436 move_hint_to_base (tree type, struct mem_address *parts, tree base_hint, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
437 aff_tree *addr) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
438 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
439 unsigned i; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
440 tree val = NULL_TREE; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
441 int qual; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
442 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
443 for (i = 0; i < addr->n; i++) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
444 { |
111 | 445 if (addr->elts[i].coef != 1) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
446 continue; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
447 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
448 val = addr->elts[i].val; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
449 if (operand_equal_p (val, base_hint, 0)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
450 break; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
451 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
452 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
453 if (i == addr->n) |
111 | 454 return false; |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
455 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
456 /* Cast value to appropriate pointer type. We cannot use a pointer |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
457 to TYPE directly, as the back-end will assume registers of pointer |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
458 type are aligned, and just the base itself may not actually be. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
459 We use void pointer to the type's address space instead. */ |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
460 qual = ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (type)); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
461 type = build_qualified_type (void_type_node, qual); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
462 parts->base = fold_convert (build_pointer_type (type), val); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
463 aff_combination_remove_elt (addr, i); |
111 | 464 return true; |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
465 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
466 |
0 | 467 /* If ADDR contains an address of a dereferenced pointer, move it to |
468 PARTS->base. */ | |
469 | |
470 static void | |
471 move_pointer_to_base (struct mem_address *parts, aff_tree *addr) | |
472 { | |
473 unsigned i; | |
474 tree val = NULL_TREE; | |
475 | |
476 for (i = 0; i < addr->n; i++) | |
477 { | |
111 | 478 if (addr->elts[i].coef != 1) |
0 | 479 continue; |
480 | |
481 val = addr->elts[i].val; | |
482 if (POINTER_TYPE_P (TREE_TYPE (val))) | |
483 break; | |
484 } | |
485 | |
486 if (i == addr->n) | |
487 return; | |
488 | |
489 parts->base = val; | |
490 aff_combination_remove_elt (addr, i); | |
491 } | |
492 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
493 /* Moves the loop variant part V in linear address ADDR to be the index |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
494 of PARTS. */ |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
495 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
496 static void |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
497 move_variant_to_index (struct mem_address *parts, aff_tree *addr, tree v) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
498 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
499 unsigned i; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
500 tree val = NULL_TREE; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
501 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
502 gcc_assert (!parts->index); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
503 for (i = 0; i < addr->n; i++) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
504 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
505 val = addr->elts[i].val; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
506 if (operand_equal_p (val, v, 0)) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
507 break; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
508 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
509 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
510 if (i == addr->n) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
511 return; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
512 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
513 parts->index = fold_convert (sizetype, val); |
111 | 514 parts->step = wide_int_to_tree (sizetype, addr->elts[i].coef); |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
515 aff_combination_remove_elt (addr, i); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
516 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
517 |
0 | 518 /* Adds ELT to PARTS. */ |
519 | |
520 static void | |
521 add_to_parts (struct mem_address *parts, tree elt) | |
522 { | |
523 tree type; | |
524 | |
525 if (!parts->index) | |
526 { | |
527 parts->index = fold_convert (sizetype, elt); | |
528 return; | |
529 } | |
530 | |
531 if (!parts->base) | |
532 { | |
533 parts->base = elt; | |
534 return; | |
535 } | |
536 | |
537 /* Add ELT to base. */ | |
538 type = TREE_TYPE (parts->base); | |
539 if (POINTER_TYPE_P (type)) | |
111 | 540 parts->base = fold_build_pointer_plus (parts->base, elt); |
0 | 541 else |
111 | 542 parts->base = fold_build2 (PLUS_EXPR, type, parts->base, elt); |
543 } | |
544 | |
545 /* Returns true if multiplying by RATIO is allowed in an address. Test the | |
546 validity for a memory reference accessing memory of mode MODE in address | |
547 space AS. */ | |
548 | |
549 static bool | |
550 multiplier_allowed_in_address_p (HOST_WIDE_INT ratio, machine_mode mode, | |
551 addr_space_t as) | |
552 { | |
553 #define MAX_RATIO 128 | |
554 unsigned int data_index = (int) as * MAX_MACHINE_MODE + (int) mode; | |
555 static vec<sbitmap> valid_mult_list; | |
556 sbitmap valid_mult; | |
557 | |
558 if (data_index >= valid_mult_list.length ()) | |
559 valid_mult_list.safe_grow_cleared (data_index + 1); | |
560 | |
561 valid_mult = valid_mult_list[data_index]; | |
562 if (!valid_mult) | |
563 { | |
564 machine_mode address_mode = targetm.addr_space.address_mode (as); | |
565 rtx reg1 = gen_raw_REG (address_mode, LAST_VIRTUAL_REGISTER + 1); | |
566 rtx reg2 = gen_raw_REG (address_mode, LAST_VIRTUAL_REGISTER + 2); | |
567 rtx addr, scaled; | |
568 HOST_WIDE_INT i; | |
569 | |
570 valid_mult = sbitmap_alloc (2 * MAX_RATIO + 1); | |
571 bitmap_clear (valid_mult); | |
572 scaled = gen_rtx_fmt_ee (MULT, address_mode, reg1, NULL_RTX); | |
573 addr = gen_rtx_fmt_ee (PLUS, address_mode, scaled, reg2); | |
574 for (i = -MAX_RATIO; i <= MAX_RATIO; i++) | |
575 { | |
576 XEXP (scaled, 1) = gen_int_mode (i, address_mode); | |
577 if (memory_address_addr_space_p (mode, addr, as) | |
578 || memory_address_addr_space_p (mode, scaled, as)) | |
579 bitmap_set_bit (valid_mult, i + MAX_RATIO); | |
580 } | |
581 | |
582 if (dump_file && (dump_flags & TDF_DETAILS)) | |
583 { | |
584 fprintf (dump_file, " allowed multipliers:"); | |
585 for (i = -MAX_RATIO; i <= MAX_RATIO; i++) | |
586 if (bitmap_bit_p (valid_mult, i + MAX_RATIO)) | |
587 fprintf (dump_file, " %d", (int) i); | |
588 fprintf (dump_file, "\n"); | |
589 fprintf (dump_file, "\n"); | |
590 } | |
591 | |
592 valid_mult_list[data_index] = valid_mult; | |
593 } | |
594 | |
595 if (ratio > MAX_RATIO || ratio < -MAX_RATIO) | |
596 return false; | |
597 | |
598 return bitmap_bit_p (valid_mult, ratio + MAX_RATIO); | |
0 | 599 } |
600 | |
601 /* Finds the most expensive multiplication in ADDR that can be | |
602 expressed in an addressing mode and move the corresponding | |
603 element(s) to PARTS. */ | |
604 | |
605 static void | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
606 most_expensive_mult_to_index (tree type, struct mem_address *parts, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
607 aff_tree *addr, bool speed) |
0 | 608 { |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
609 addr_space_t as = TYPE_ADDR_SPACE (type); |
111 | 610 machine_mode address_mode = targetm.addr_space.address_mode (as); |
0 | 611 HOST_WIDE_INT coef; |
612 unsigned best_mult_cost = 0, acost; | |
613 tree mult_elt = NULL_TREE, elt; | |
614 unsigned i, j; | |
615 enum tree_code op_code; | |
616 | |
111 | 617 offset_int best_mult = 0; |
0 | 618 for (i = 0; i < addr->n; i++) |
619 { | |
111 | 620 if (!wi::fits_shwi_p (addr->elts[i].coef)) |
0 | 621 continue; |
622 | |
111 | 623 coef = addr->elts[i].coef.to_shwi (); |
0 | 624 if (coef == 1 |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
625 || !multiplier_allowed_in_address_p (coef, TYPE_MODE (type), as)) |
0 | 626 continue; |
627 | |
111 | 628 acost = mult_by_coeff_cost (coef, address_mode, speed); |
0 | 629 |
630 if (acost > best_mult_cost) | |
631 { | |
632 best_mult_cost = acost; | |
111 | 633 best_mult = offset_int::from (addr->elts[i].coef, SIGNED); |
0 | 634 } |
635 } | |
636 | |
637 if (!best_mult_cost) | |
638 return; | |
639 | |
640 /* Collect elements multiplied by best_mult. */ | |
641 for (i = j = 0; i < addr->n; i++) | |
642 { | |
111 | 643 offset_int amult = offset_int::from (addr->elts[i].coef, SIGNED); |
644 offset_int amult_neg = -wi::sext (amult, TYPE_PRECISION (addr->type)); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
645 |
111 | 646 if (amult == best_mult) |
0 | 647 op_code = PLUS_EXPR; |
111 | 648 else if (amult_neg == best_mult) |
0 | 649 op_code = MINUS_EXPR; |
650 else | |
651 { | |
652 addr->elts[j] = addr->elts[i]; | |
653 j++; | |
654 continue; | |
655 } | |
656 | |
657 elt = fold_convert (sizetype, addr->elts[i].val); | |
658 if (mult_elt) | |
659 mult_elt = fold_build2 (op_code, sizetype, mult_elt, elt); | |
660 else if (op_code == PLUS_EXPR) | |
661 mult_elt = elt; | |
662 else | |
663 mult_elt = fold_build1 (NEGATE_EXPR, sizetype, elt); | |
664 } | |
665 addr->n = j; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
666 |
0 | 667 parts->index = mult_elt; |
111 | 668 parts->step = wide_int_to_tree (sizetype, best_mult); |
0 | 669 } |
670 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
671 /* Splits address ADDR for a memory access of type TYPE into PARTS. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
672 If BASE_HINT is non-NULL, it specifies an SSA name to be used |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
673 preferentially as base of the reference, and IV_CAND is the selected |
111 | 674 iv candidate used in ADDR. Store true to VAR_IN_BASE if variant |
675 part of address is split to PARTS.base. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
676 |
0 | 677 TODO -- be more clever about the distribution of the elements of ADDR |
678 to PARTS. Some architectures do not support anything but single | |
679 register in address, possibly with a small integer offset; while | |
680 create_mem_ref will simplify the address to an acceptable shape | |
681 later, it would be more efficient to know that asking for complicated | |
682 addressing modes is useless. */ | |
683 | |
684 static void | |
111 | 685 addr_to_parts (tree type, aff_tree *addr, tree iv_cand, tree base_hint, |
686 struct mem_address *parts, bool *var_in_base, bool speed) | |
0 | 687 { |
688 tree part; | |
689 unsigned i; | |
690 | |
691 parts->symbol = NULL_TREE; | |
692 parts->base = NULL_TREE; | |
693 parts->index = NULL_TREE; | |
694 parts->step = NULL_TREE; | |
695 | |
131 | 696 if (maybe_ne (addr->offset, 0)) |
111 | 697 parts->offset = wide_int_to_tree (sizetype, addr->offset); |
0 | 698 else |
699 parts->offset = NULL_TREE; | |
700 | |
701 /* Try to find a symbol. */ | |
702 move_fixed_address_to_symbol (parts, addr); | |
703 | |
111 | 704 /* Since at the moment there is no reliable way to know how to |
705 distinguish between pointer and its offset, we decide if var | |
706 part is the pointer based on guess. */ | |
707 *var_in_base = (base_hint != NULL && parts->symbol == NULL); | |
708 if (*var_in_base) | |
709 *var_in_base = move_hint_to_base (type, parts, base_hint, addr); | |
710 else | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
711 move_variant_to_index (parts, addr, iv_cand); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
712 |
111 | 713 /* First move the most expensive feasible multiplication to index. */ |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
714 if (!parts->index) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
715 most_expensive_mult_to_index (type, parts, addr, speed); |
0 | 716 |
111 | 717 /* Move pointer into base. */ |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
718 if (!parts->symbol && !parts->base) |
0 | 719 move_pointer_to_base (parts, addr); |
720 | |
721 /* Then try to process the remaining elements. */ | |
722 for (i = 0; i < addr->n; i++) | |
723 { | |
724 part = fold_convert (sizetype, addr->elts[i].val); | |
111 | 725 if (addr->elts[i].coef != 1) |
0 | 726 part = fold_build2 (MULT_EXPR, sizetype, part, |
111 | 727 wide_int_to_tree (sizetype, addr->elts[i].coef)); |
0 | 728 add_to_parts (parts, part); |
729 } | |
730 if (addr->rest) | |
731 add_to_parts (parts, fold_convert (sizetype, addr->rest)); | |
732 } | |
733 | |
734 /* Force the PARTS to register. */ | |
735 | |
736 static void | |
737 gimplify_mem_ref_parts (gimple_stmt_iterator *gsi, struct mem_address *parts) | |
738 { | |
739 if (parts->base) | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
740 parts->base = force_gimple_operand_gsi_1 (gsi, parts->base, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
741 is_gimple_mem_ref_addr, NULL_TREE, |
0 | 742 true, GSI_SAME_STMT); |
743 if (parts->index) | |
744 parts->index = force_gimple_operand_gsi (gsi, parts->index, | |
745 true, NULL_TREE, | |
746 true, GSI_SAME_STMT); | |
747 } | |
748 | |
131 | 749 /* Return true if the OFFSET in PARTS is the only thing that is making |
750 it an invalid address for type TYPE. */ | |
751 | |
752 static bool | |
753 mem_ref_valid_without_offset_p (tree type, mem_address parts) | |
754 { | |
755 if (!parts.base) | |
756 parts.base = parts.offset; | |
757 parts.offset = NULL_TREE; | |
758 return valid_mem_ref_p (TYPE_MODE (type), TYPE_ADDR_SPACE (type), &parts); | |
759 } | |
760 | |
761 /* Fold PARTS->offset into PARTS->base, so that there is no longer | |
762 a separate offset. Emit any new instructions before GSI. */ | |
763 | |
764 static void | |
765 add_offset_to_base (gimple_stmt_iterator *gsi, mem_address *parts) | |
766 { | |
767 tree tmp = parts->offset; | |
768 if (parts->base) | |
769 { | |
770 tmp = fold_build_pointer_plus (parts->base, tmp); | |
771 tmp = force_gimple_operand_gsi_1 (gsi, tmp, is_gimple_mem_ref_addr, | |
772 NULL_TREE, true, GSI_SAME_STMT); | |
773 } | |
774 parts->base = tmp; | |
775 parts->offset = NULL_TREE; | |
776 } | |
777 | |
0 | 778 /* Creates and returns a TARGET_MEM_REF for address ADDR. If necessary |
779 computations are emitted in front of GSI. TYPE is the mode | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
780 of created memory reference. IV_CAND is the selected iv candidate in ADDR, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
781 and BASE_HINT is non NULL if IV_CAND comes from a base address |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
782 object. */ |
0 | 783 |
784 tree | |
785 create_mem_ref (gimple_stmt_iterator *gsi, tree type, aff_tree *addr, | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
786 tree alias_ptr_type, tree iv_cand, tree base_hint, bool speed) |
0 | 787 { |
111 | 788 bool var_in_base; |
0 | 789 tree mem_ref, tmp; |
790 struct mem_address parts; | |
791 | |
111 | 792 addr_to_parts (type, addr, iv_cand, base_hint, &parts, &var_in_base, speed); |
0 | 793 gimplify_mem_ref_parts (gsi, &parts); |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
794 mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true); |
0 | 795 if (mem_ref) |
796 return mem_ref; | |
797 | |
798 /* The expression is too complicated. Try making it simpler. */ | |
799 | |
111 | 800 /* Merge symbol into other parts. */ |
801 if (parts.symbol) | |
802 { | |
803 tmp = parts.symbol; | |
804 parts.symbol = NULL_TREE; | |
805 gcc_assert (is_gimple_val (tmp)); | |
806 | |
807 if (parts.base) | |
808 { | |
809 gcc_assert (useless_type_conversion_p (sizetype, | |
810 TREE_TYPE (parts.base))); | |
811 | |
812 if (parts.index) | |
813 { | |
814 /* Add the symbol to base, eventually forcing it to register. */ | |
815 tmp = fold_build_pointer_plus (tmp, parts.base); | |
816 tmp = force_gimple_operand_gsi_1 (gsi, tmp, | |
817 is_gimple_mem_ref_addr, | |
818 NULL_TREE, true, | |
819 GSI_SAME_STMT); | |
820 } | |
821 else | |
822 { | |
823 /* Move base to index, then move the symbol to base. */ | |
824 parts.index = parts.base; | |
825 } | |
826 parts.base = tmp; | |
827 } | |
828 else | |
829 parts.base = tmp; | |
830 | |
831 mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true); | |
832 if (mem_ref) | |
833 return mem_ref; | |
834 } | |
835 | |
836 /* Move multiplication to index by transforming address expression: | |
837 [... + index << step + ...] | |
838 into: | |
839 index' = index << step; | |
840 [... + index' + ,,,]. */ | |
0 | 841 if (parts.step && !integer_onep (parts.step)) |
842 { | |
843 gcc_assert (parts.index); | |
131 | 844 if (parts.offset && mem_ref_valid_without_offset_p (type, parts)) |
845 { | |
846 add_offset_to_base (gsi, &parts); | |
847 mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true); | |
848 gcc_assert (mem_ref); | |
849 return mem_ref; | |
850 } | |
851 | |
0 | 852 parts.index = force_gimple_operand_gsi (gsi, |
853 fold_build2 (MULT_EXPR, sizetype, | |
854 parts.index, parts.step), | |
855 true, NULL_TREE, true, GSI_SAME_STMT); | |
856 parts.step = NULL_TREE; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
857 |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
858 mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true); |
0 | 859 if (mem_ref) |
860 return mem_ref; | |
861 } | |
862 | |
111 | 863 /* Add offset to invariant part by transforming address expression: |
864 [base + index + offset] | |
865 into: | |
866 base' = base + offset; | |
867 [base' + index] | |
868 or: | |
869 index' = index + offset; | |
870 [base + index'] | |
871 depending on which one is invariant. */ | |
872 if (parts.offset && !integer_zerop (parts.offset)) | |
0 | 873 { |
111 | 874 tree old_base = unshare_expr (parts.base); |
875 tree old_index = unshare_expr (parts.index); | |
876 tree old_offset = unshare_expr (parts.offset); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
877 |
111 | 878 tmp = parts.offset; |
879 parts.offset = NULL_TREE; | |
880 /* Add offset to invariant part. */ | |
881 if (!var_in_base) | |
0 | 882 { |
111 | 883 if (parts.base) |
884 { | |
885 tmp = fold_build_pointer_plus (parts.base, tmp); | |
886 tmp = force_gimple_operand_gsi_1 (gsi, tmp, | |
887 is_gimple_mem_ref_addr, | |
888 NULL_TREE, true, | |
889 GSI_SAME_STMT); | |
890 } | |
891 parts.base = tmp; | |
892 } | |
893 else | |
894 { | |
0 | 895 if (parts.index) |
896 { | |
111 | 897 tmp = fold_build_pointer_plus (parts.index, tmp); |
898 tmp = force_gimple_operand_gsi_1 (gsi, tmp, | |
899 is_gimple_mem_ref_addr, | |
900 NULL_TREE, true, | |
901 GSI_SAME_STMT); | |
0 | 902 } |
111 | 903 parts.index = tmp; |
0 | 904 } |
111 | 905 |
906 mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true); | |
907 if (mem_ref) | |
908 return mem_ref; | |
909 | |
910 /* Restore parts.base, index and offset so that we can check if | |
911 [base + offset] addressing mode is supported in next step. | |
912 This is necessary for targets only support [base + offset], | |
913 but not [base + index] addressing mode. */ | |
914 parts.base = old_base; | |
915 parts.index = old_index; | |
916 parts.offset = old_offset; | |
917 } | |
918 | |
919 /* Transform [base + index + ...] into: | |
920 base' = base + index; | |
921 [base' + ...]. */ | |
922 if (parts.index) | |
923 { | |
924 tmp = parts.index; | |
925 parts.index = NULL_TREE; | |
926 /* Add index to base. */ | |
927 if (parts.base) | |
928 { | |
929 tmp = fold_build_pointer_plus (parts.base, tmp); | |
930 tmp = force_gimple_operand_gsi_1 (gsi, tmp, | |
931 is_gimple_mem_ref_addr, | |
932 NULL_TREE, true, GSI_SAME_STMT); | |
933 } | |
934 parts.base = tmp; | |
0 | 935 |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
936 mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true); |
0 | 937 if (mem_ref) |
938 return mem_ref; | |
939 } | |
940 | |
111 | 941 /* Transform [base + offset] into: |
942 base' = base + offset; | |
943 [base']. */ | |
944 if (parts.offset && !integer_zerop (parts.offset)) | |
0 | 945 { |
131 | 946 add_offset_to_base (gsi, &parts); |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
947 mem_ref = create_mem_ref_raw (type, alias_ptr_type, &parts, true); |
0 | 948 if (mem_ref) |
949 return mem_ref; | |
950 } | |
951 | |
952 /* Verify that the address is in the simplest possible shape | |
953 (only a register). If we cannot create such a memory reference, | |
954 something is really wrong. */ | |
955 gcc_assert (parts.symbol == NULL_TREE); | |
956 gcc_assert (parts.index == NULL_TREE); | |
957 gcc_assert (!parts.step || integer_onep (parts.step)); | |
958 gcc_assert (!parts.offset || integer_zerop (parts.offset)); | |
959 gcc_unreachable (); | |
960 } | |
961 | |
962 /* Copies components of the address from OP to ADDR. */ | |
963 | |
964 void | |
965 get_address_description (tree op, struct mem_address *addr) | |
966 { | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
967 if (TREE_CODE (TMR_BASE (op)) == ADDR_EXPR) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
968 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
969 addr->symbol = TMR_BASE (op); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
970 addr->base = TMR_INDEX2 (op); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
971 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
972 else |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
973 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
974 addr->symbol = NULL_TREE; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
975 if (TMR_INDEX2 (op)) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
976 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
977 gcc_assert (integer_zerop (TMR_BASE (op))); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
978 addr->base = TMR_INDEX2 (op); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
979 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
980 else |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
981 addr->base = TMR_BASE (op); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
982 } |
0 | 983 addr->index = TMR_INDEX (op); |
984 addr->step = TMR_STEP (op); | |
985 addr->offset = TMR_OFFSET (op); | |
986 } | |
987 | |
111 | 988 /* Copies the reference information from OLD_REF to NEW_REF, where |
989 NEW_REF should be either a MEM_REF or a TARGET_MEM_REF. */ | |
0 | 990 |
991 void | |
111 | 992 copy_ref_info (tree new_ref, tree old_ref) |
0 | 993 { |
111 | 994 tree new_ptr_base = NULL_TREE; |
995 | |
996 gcc_assert (TREE_CODE (new_ref) == MEM_REF | |
997 || TREE_CODE (new_ref) == TARGET_MEM_REF); | |
998 | |
999 TREE_SIDE_EFFECTS (new_ref) = TREE_SIDE_EFFECTS (old_ref); | |
1000 TREE_THIS_VOLATILE (new_ref) = TREE_THIS_VOLATILE (old_ref); | |
1001 | |
1002 new_ptr_base = TREE_OPERAND (new_ref, 0); | |
1003 | |
1004 /* We can transfer points-to information from an old pointer | |
1005 or decl base to the new one. */ | |
1006 if (new_ptr_base | |
1007 && TREE_CODE (new_ptr_base) == SSA_NAME | |
1008 && !SSA_NAME_PTR_INFO (new_ptr_base)) | |
1009 { | |
1010 tree base = get_base_address (old_ref); | |
1011 if (!base) | |
1012 ; | |
1013 else if ((TREE_CODE (base) == MEM_REF | |
1014 || TREE_CODE (base) == TARGET_MEM_REF) | |
1015 && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME | |
1016 && SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0))) | |
1017 { | |
1018 struct ptr_info_def *new_pi; | |
1019 unsigned int align, misalign; | |
1020 | |
1021 duplicate_ssa_name_ptr_info | |
1022 (new_ptr_base, SSA_NAME_PTR_INFO (TREE_OPERAND (base, 0))); | |
1023 new_pi = SSA_NAME_PTR_INFO (new_ptr_base); | |
1024 /* We have to be careful about transferring alignment information. */ | |
1025 if (get_ptr_info_alignment (new_pi, &align, &misalign) | |
1026 && TREE_CODE (old_ref) == MEM_REF | |
1027 && !(TREE_CODE (new_ref) == TARGET_MEM_REF | |
1028 && (TMR_INDEX2 (new_ref) | |
1029 /* TODO: Below conditions can be relaxed if TMR_INDEX | |
1030 is an indcution variable and its initial value and | |
1031 step are aligned. */ | |
1032 || (TMR_INDEX (new_ref) && !TMR_STEP (new_ref)) | |
1033 || (TMR_STEP (new_ref) | |
1034 && (TREE_INT_CST_LOW (TMR_STEP (new_ref)) | |
1035 < align))))) | |
1036 { | |
131 | 1037 poly_uint64 inc = (mem_ref_offset (old_ref) |
1038 - mem_ref_offset (new_ref)).force_uhwi (); | |
111 | 1039 adjust_ptr_info_misalignment (new_pi, inc); |
1040 } | |
1041 else | |
1042 mark_ptr_info_alignment_unknown (new_pi); | |
1043 } | |
1044 else if (VAR_P (base) | |
1045 || TREE_CODE (base) == PARM_DECL | |
1046 || TREE_CODE (base) == RESULT_DECL) | |
1047 { | |
1048 struct ptr_info_def *pi = get_ptr_info (new_ptr_base); | |
1049 pt_solution_set_var (&pi->pt, base); | |
1050 } | |
1051 } | |
0 | 1052 } |
1053 | |
1054 /* Move constants in target_mem_ref REF to offset. Returns the new target | |
1055 mem ref if anything changes, NULL_TREE otherwise. */ | |
1056 | |
1057 tree | |
1058 maybe_fold_tmr (tree ref) | |
1059 { | |
1060 struct mem_address addr; | |
1061 bool changed = false; | |
111 | 1062 tree new_ref, off; |
0 | 1063 |
1064 get_address_description (ref, &addr); | |
1065 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1066 if (addr.base |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1067 && TREE_CODE (addr.base) == INTEGER_CST |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1068 && !integer_zerop (addr.base)) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1069 { |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1070 addr.offset = fold_binary_to_constant (PLUS_EXPR, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1071 TREE_TYPE (addr.offset), |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1072 addr.offset, addr.base); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1073 addr.base = NULL_TREE; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1074 changed = true; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1075 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1076 |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1077 if (addr.symbol |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1078 && TREE_CODE (TREE_OPERAND (addr.symbol, 0)) == MEM_REF) |
0 | 1079 { |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1080 addr.offset = fold_binary_to_constant |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1081 (PLUS_EXPR, TREE_TYPE (addr.offset), |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1082 addr.offset, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1083 TREE_OPERAND (TREE_OPERAND (addr.symbol, 0), 1)); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1084 addr.symbol = TREE_OPERAND (TREE_OPERAND (addr.symbol, 0), 0); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1085 changed = true; |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1086 } |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1087 else if (addr.symbol |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1088 && handled_component_p (TREE_OPERAND (addr.symbol, 0))) |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1089 { |
131 | 1090 poly_int64 offset; |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1091 addr.symbol = build_fold_addr_expr |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1092 (get_addr_base_and_unit_offset |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1093 (TREE_OPERAND (addr.symbol, 0), &offset)); |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1094 addr.offset = int_const_binop (PLUS_EXPR, |
111 | 1095 addr.offset, size_int (offset)); |
0 | 1096 changed = true; |
1097 } | |
1098 | |
1099 if (addr.index && TREE_CODE (addr.index) == INTEGER_CST) | |
1100 { | |
1101 off = addr.index; | |
1102 if (addr.step) | |
1103 { | |
1104 off = fold_binary_to_constant (MULT_EXPR, sizetype, | |
1105 off, addr.step); | |
1106 addr.step = NULL_TREE; | |
1107 } | |
1108 | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1109 addr.offset = fold_binary_to_constant (PLUS_EXPR, |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1110 TREE_TYPE (addr.offset), |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1111 addr.offset, off); |
0 | 1112 addr.index = NULL_TREE; |
1113 changed = true; | |
1114 } | |
1115 | |
1116 if (!changed) | |
1117 return NULL_TREE; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1118 |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1119 /* If we have propagated something into this TARGET_MEM_REF and thus |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1120 ended up folding it, always create a new TARGET_MEM_REF regardless |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1121 if it is valid in this for on the target - the propagation result |
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1122 wouldn't be anyway. */ |
111 | 1123 new_ref = create_mem_ref_raw (TREE_TYPE (ref), |
1124 TREE_TYPE (addr.offset), &addr, false); | |
1125 TREE_SIDE_EFFECTS (new_ref) = TREE_SIDE_EFFECTS (ref); | |
1126 TREE_THIS_VOLATILE (new_ref) = TREE_THIS_VOLATILE (ref); | |
1127 return new_ref; | |
0 | 1128 } |
1129 | |
1130 /* Dump PARTS to FILE. */ | |
1131 | |
1132 extern void dump_mem_address (FILE *, struct mem_address *); | |
1133 void | |
1134 dump_mem_address (FILE *file, struct mem_address *parts) | |
1135 { | |
1136 if (parts->symbol) | |
1137 { | |
1138 fprintf (file, "symbol: "); | |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1139 print_generic_expr (file, TREE_OPERAND (parts->symbol, 0), TDF_SLIM); |
0 | 1140 fprintf (file, "\n"); |
1141 } | |
1142 if (parts->base) | |
1143 { | |
1144 fprintf (file, "base: "); | |
1145 print_generic_expr (file, parts->base, TDF_SLIM); | |
1146 fprintf (file, "\n"); | |
1147 } | |
1148 if (parts->index) | |
1149 { | |
1150 fprintf (file, "index: "); | |
1151 print_generic_expr (file, parts->index, TDF_SLIM); | |
1152 fprintf (file, "\n"); | |
1153 } | |
1154 if (parts->step) | |
1155 { | |
1156 fprintf (file, "step: "); | |
1157 print_generic_expr (file, parts->step, TDF_SLIM); | |
1158 fprintf (file, "\n"); | |
1159 } | |
1160 if (parts->offset) | |
1161 { | |
1162 fprintf (file, "offset: "); | |
1163 print_generic_expr (file, parts->offset, TDF_SLIM); | |
1164 fprintf (file, "\n"); | |
1165 } | |
1166 } | |
1167 | |
1168 #include "gt-tree-ssa-address.h" |