Branch data Line data Source code
1 : : /* Decompose multiword subregs.
2 : : Copyright (C) 2007-2024 Free Software Foundation, Inc.
3 : : Contributed by Richard Henderson <rth@redhat.com>
4 : : Ian Lance Taylor <iant@google.com>
5 : :
6 : : This file is part of GCC.
7 : :
8 : : GCC is free software; you can redistribute it and/or modify it under
9 : : the terms of the GNU General Public License as published by the Free
10 : : Software Foundation; either version 3, or (at your option) any later
11 : : version.
12 : :
13 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 : : for more details.
17 : :
18 : : You should have received a copy of the GNU General Public License
19 : : along with GCC; see the file COPYING3. If not see
20 : : <http://www.gnu.org/licenses/>. */
21 : :
22 : : #include "config.h"
23 : : #include "system.h"
24 : : #include "coretypes.h"
25 : : #include "backend.h"
26 : : #include "rtl.h"
27 : : #include "tree.h"
28 : : #include "cfghooks.h"
29 : : #include "df.h"
30 : : #include "memmodel.h"
31 : : #include "tm_p.h"
32 : : #include "expmed.h"
33 : : #include "insn-config.h"
34 : : #include "emit-rtl.h"
35 : : #include "recog.h"
36 : : #include "cfgrtl.h"
37 : : #include "cfgbuild.h"
38 : : #include "dce.h"
39 : : #include "expr.h"
40 : : #include "explow.h"
41 : : #include "tree-pass.h"
42 : : #include "lower-subreg.h"
43 : : #include "rtl-iter.h"
44 : : #include "target.h"
45 : :
46 : :
47 : : /* Decompose multi-word pseudo-registers into individual
48 : : pseudo-registers when possible and profitable. This is possible
49 : : when all the uses of a multi-word register are via SUBREG, or are
50 : : copies of the register to another location. Breaking apart the
51 : : register permits more CSE and permits better register allocation.
52 : : This is profitable if the machine does not have move instructions
53 : : to do this.
54 : :
55 : : This pass only splits moves with modes that are wider than
56 : : word_mode and ASHIFTs, LSHIFTRTs, ASHIFTRTs and ZERO_EXTENDs with
57 : : integer modes that are twice the width of word_mode. The latter
58 : : could be generalized if there was a need to do this, but the trend in
59 : : architectures is to not need this.
60 : :
61 : : There are two useful preprocessor defines for use by maintainers:
62 : :
63 : : #define LOG_COSTS 1
64 : :
65 : : if you wish to see the actual cost estimates that are being used
66 : : for each mode wider than word mode and the cost estimates for zero
67 : : extension and the shifts. This can be useful when port maintainers
68 : : are tuning insn rtx costs.
69 : :
70 : : #define FORCE_LOWERING 1
71 : :
72 : : if you wish to test the pass with all the transformation forced on.
73 : : This can be useful for finding bugs in the transformations. */
74 : :
75 : : #define LOG_COSTS 0
76 : : #define FORCE_LOWERING 0
77 : :
78 : : /* Bit N in this bitmap is set if regno N is used in a context in
79 : : which we can decompose it. */
80 : : static bitmap decomposable_context;
81 : :
82 : : /* Bit N in this bitmap is set if regno N is used in a context in
83 : : which it cannot be decomposed. */
84 : : static bitmap non_decomposable_context;
85 : :
86 : : /* Bit N in this bitmap is set if regno N is used in a subreg
87 : : which changes the mode but not the size. This typically happens
88 : : when the register accessed as a floating-point value; we want to
89 : : avoid generating accesses to its subwords in integer modes. */
90 : : static bitmap subreg_context;
91 : :
92 : : /* Bit N in the bitmap in element M of this array is set if there is a
93 : : copy from reg M to reg N. */
94 : : static vec<bitmap> reg_copy_graph;
95 : :
96 : : struct target_lower_subreg default_target_lower_subreg;
97 : : #if SWITCHABLE_TARGET
98 : : struct target_lower_subreg *this_target_lower_subreg
99 : : = &default_target_lower_subreg;
100 : : #endif
101 : :
102 : : #define twice_word_mode \
103 : : this_target_lower_subreg->x_twice_word_mode
104 : : #define choices \
105 : : this_target_lower_subreg->x_choices
106 : :
107 : : /* Return true if MODE is a mode we know how to lower. When returning true,
108 : : store its byte size in *BYTES and its word size in *WORDS. */
109 : :
110 : : static inline bool
111 : 110947788 : interesting_mode_p (machine_mode mode, unsigned int *bytes,
112 : : unsigned int *words)
113 : : {
114 : 221895576 : if (!GET_MODE_SIZE (mode).is_constant (bytes))
115 : : return false;
116 : 110947788 : *words = CEIL (*bytes, UNITS_PER_WORD);
117 : 110947788 : return true;
118 : : }
119 : :
120 : : /* RTXes used while computing costs. */
121 : : struct cost_rtxes {
122 : : /* Source and target registers. */
123 : : rtx source;
124 : : rtx target;
125 : :
126 : : /* A twice_word_mode ZERO_EXTEND of SOURCE. */
127 : : rtx zext;
128 : :
129 : : /* A shift of SOURCE. */
130 : : rtx shift;
131 : :
132 : : /* A SET of TARGET. */
133 : : rtx set;
134 : : };
135 : :
136 : : /* Return the cost of a CODE shift in mode MODE by OP1 bits, using the
137 : : rtxes in RTXES. SPEED_P selects between the speed and size cost. */
138 : :
139 : : static int
140 : 181910464 : shift_cost (bool speed_p, struct cost_rtxes *rtxes, enum rtx_code code,
141 : : machine_mode mode, int op1)
142 : : {
143 : 181910464 : PUT_CODE (rtxes->shift, code);
144 : 181910464 : PUT_MODE (rtxes->shift, mode);
145 : 181910464 : PUT_MODE (rtxes->source, mode);
146 : 181910464 : XEXP (rtxes->shift, 1) = gen_int_shift_amount (mode, op1);
147 : 181910464 : return set_src_cost (rtxes->shift, mode, speed_p);
148 : : }
149 : :
150 : : /* For each X in the range [0, BITS_PER_WORD), set SPLITTING[X]
151 : : to true if it is profitable to split a double-word CODE shift
152 : : of X + BITS_PER_WORD bits. SPEED_P says whether we are testing
153 : : for speed or size profitability.
154 : :
155 : : Use the rtxes in RTXES to calculate costs. WORD_MOVE_ZERO_COST is
156 : : the cost of moving zero into a word-mode register. WORD_MOVE_COST
157 : : is the cost of moving between word registers. */
158 : :
159 : : static void
160 : 1245840 : compute_splitting_shift (bool speed_p, struct cost_rtxes *rtxes,
161 : : bool *splitting, enum rtx_code code,
162 : : int word_move_zero_cost, int word_move_cost)
163 : : {
164 : 1245840 : int wide_cost, narrow_cost, upper_cost, i;
165 : :
166 : 81012732 : for (i = 0; i < BITS_PER_WORD; i++)
167 : : {
168 : 78673536 : wide_cost = shift_cost (speed_p, rtxes, code, twice_word_mode,
169 : : i + BITS_PER_WORD);
170 : 78673536 : if (i == 0)
171 : : narrow_cost = word_move_cost;
172 : : else
173 : 77427696 : narrow_cost = shift_cost (speed_p, rtxes, code, word_mode, i);
174 : :
175 : 78673536 : if (code != ASHIFTRT)
176 : : upper_cost = word_move_zero_cost;
177 : 26577920 : else if (i == BITS_PER_WORD - 1)
178 : : upper_cost = word_move_cost;
179 : : else
180 : 25809232 : upper_cost = shift_cost (speed_p, rtxes, code, word_mode,
181 : : BITS_PER_WORD - 1);
182 : :
183 : 78673536 : if (LOG_COSTS)
184 : : fprintf (stderr, "%s %s by %d: original cost %d, split cost %d + %d\n",
185 : : GET_MODE_NAME (twice_word_mode), GET_RTX_NAME (code),
186 : : i + BITS_PER_WORD, wide_cost, narrow_cost, upper_cost);
187 : :
188 : 78673536 : if (FORCE_LOWERING || wide_cost >= narrow_cost + upper_cost)
189 : 78673536 : splitting[i] = true;
190 : : }
191 : 1245840 : }
192 : :
193 : : /* Compute what we should do when optimizing for speed or size; SPEED_P
194 : : selects which. Use RTXES for computing costs. */
195 : :
196 : : static void
197 : 415280 : compute_costs (bool speed_p, struct cost_rtxes *rtxes)
198 : : {
199 : 415280 : unsigned int i;
200 : 415280 : int word_move_zero_cost, word_move_cost;
201 : :
202 : 415280 : PUT_MODE (rtxes->target, word_mode);
203 : 415280 : SET_SRC (rtxes->set) = CONST0_RTX (word_mode);
204 : 415280 : word_move_zero_cost = set_rtx_cost (rtxes->set, speed_p);
205 : :
206 : 415280 : SET_SRC (rtxes->set) = rtxes->source;
207 : 415280 : word_move_cost = set_rtx_cost (rtxes->set, speed_p);
208 : :
209 : 415280 : if (LOG_COSTS)
210 : : fprintf (stderr, "%s move: from zero cost %d, from reg cost %d\n",
211 : : GET_MODE_NAME (word_mode), word_move_zero_cost, word_move_cost);
212 : :
213 : 54401680 : for (i = 0; i < MAX_MACHINE_MODE; i++)
214 : : {
215 : 53986400 : machine_mode mode = (machine_mode) i;
216 : 53986400 : unsigned int size, factor;
217 : 53986400 : if (interesting_mode_p (mode, &size, &factor) && factor > 1)
218 : : {
219 : 28426788 : unsigned int mode_move_cost;
220 : :
221 : 28426788 : PUT_MODE (rtxes->target, mode);
222 : 28426788 : PUT_MODE (rtxes->source, mode);
223 : 28426788 : mode_move_cost = set_rtx_cost (rtxes->set, speed_p);
224 : :
225 : 28426788 : if (LOG_COSTS)
226 : : fprintf (stderr, "%s move: original cost %d, split cost %d * %d\n",
227 : : GET_MODE_NAME (mode), mode_move_cost,
228 : : word_move_cost, factor);
229 : :
230 : 28426788 : if (FORCE_LOWERING || mode_move_cost >= word_move_cost * factor)
231 : : {
232 : 22278718 : choices[speed_p].move_modes_to_split[i] = true;
233 : 22278718 : choices[speed_p].something_to_do = true;
234 : : }
235 : : }
236 : : }
237 : :
238 : : /* For the moves and shifts, the only case that is checked is one
239 : : where the mode of the target is an integer mode twice the width
240 : : of the word_mode.
241 : :
242 : : If it is not profitable to split a double word move then do not
243 : : even consider the shifts or the zero extension. */
244 : 415280 : if (choices[speed_p].move_modes_to_split[(int) twice_word_mode])
245 : : {
246 : 415280 : int zext_cost;
247 : :
248 : : /* The only case here to check to see if moving the upper part with a
249 : : zero is cheaper than doing the zext itself. */
250 : 415280 : PUT_MODE (rtxes->source, word_mode);
251 : 415280 : zext_cost = set_src_cost (rtxes->zext, twice_word_mode, speed_p);
252 : :
253 : 415280 : if (LOG_COSTS)
254 : : fprintf (stderr, "%s %s: original cost %d, split cost %d + %d\n",
255 : : GET_MODE_NAME (twice_word_mode), GET_RTX_NAME (ZERO_EXTEND),
256 : : zext_cost, word_move_cost, word_move_zero_cost);
257 : :
258 : 415280 : if (FORCE_LOWERING || zext_cost >= word_move_cost + word_move_zero_cost)
259 : 0 : choices[speed_p].splitting_zext = true;
260 : :
261 : 415280 : compute_splitting_shift (speed_p, rtxes,
262 : 415280 : choices[speed_p].splitting_ashift, ASHIFT,
263 : : word_move_zero_cost, word_move_cost);
264 : 415280 : compute_splitting_shift (speed_p, rtxes,
265 : 415280 : choices[speed_p].splitting_lshiftrt, LSHIFTRT,
266 : : word_move_zero_cost, word_move_cost);
267 : 415280 : compute_splitting_shift (speed_p, rtxes,
268 : 415280 : choices[speed_p].splitting_ashiftrt, ASHIFTRT,
269 : : word_move_zero_cost, word_move_cost);
270 : : }
271 : 415280 : }
272 : :
273 : : /* Do one-per-target initialisation. This involves determining
274 : : which operations on the machine are profitable. If none are found,
275 : : then the pass just returns when called. */
276 : :
277 : : void
278 : 207640 : init_lower_subreg (void)
279 : : {
280 : 207640 : struct cost_rtxes rtxes;
281 : :
282 : 207640 : memset (this_target_lower_subreg, 0, sizeof (*this_target_lower_subreg));
283 : :
284 : 207640 : twice_word_mode = GET_MODE_2XWIDER_MODE (word_mode).require ();
285 : :
286 : 207640 : rtxes.target = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 1);
287 : 207640 : rtxes.source = gen_rtx_REG (word_mode, LAST_VIRTUAL_REGISTER + 2);
288 : 207640 : rtxes.set = gen_rtx_SET (rtxes.target, rtxes.source);
289 : 207640 : rtxes.zext = gen_rtx_ZERO_EXTEND (twice_word_mode, rtxes.source);
290 : 207640 : rtxes.shift = gen_rtx_ASHIFT (twice_word_mode, rtxes.source, const0_rtx);
291 : :
292 : 207640 : if (LOG_COSTS)
293 : : fprintf (stderr, "\nSize costs\n==========\n\n");
294 : 207640 : compute_costs (false, &rtxes);
295 : :
296 : 207640 : if (LOG_COSTS)
297 : : fprintf (stderr, "\nSpeed costs\n===========\n\n");
298 : 207640 : compute_costs (true, &rtxes);
299 : 207640 : }
300 : :
301 : : static bool
302 : 76971119 : simple_move_operand (rtx x)
303 : : {
304 : 76971119 : if (GET_CODE (x) == SUBREG)
305 : 3401968 : x = SUBREG_REG (x);
306 : :
307 : 76971119 : if (!OBJECT_P (x))
308 : : return false;
309 : :
310 : 76381334 : if (GET_CODE (x) == LABEL_REF
311 : 76381334 : || GET_CODE (x) == SYMBOL_REF
312 : 73464584 : || GET_CODE (x) == HIGH
313 : 73464584 : || GET_CODE (x) == CONST)
314 : : return false;
315 : :
316 : 73348735 : if (MEM_P (x)
317 : 73348735 : && (MEM_VOLATILE_P (x)
318 : 20284344 : || mode_dependent_address_p (XEXP (x, 0), MEM_ADDR_SPACE (x))))
319 : 3692687 : return false;
320 : :
321 : : return true;
322 : : }
323 : :
324 : : /* If X is an operator that can be treated as a simple move that we
325 : : can split, then return the operand that is operated on. */
326 : :
327 : : static rtx
328 : 41532577 : operand_for_swap_move_operator (rtx x)
329 : : {
330 : : /* A word sized rotate of a register pair is equivalent to swapping
331 : : the registers in the register pair. */
332 : 41532577 : if (GET_CODE (x) == ROTATE
333 : 10 : && GET_MODE (x) == twice_word_mode
334 : 10 : && simple_move_operand (XEXP (x, 0))
335 : 10 : && CONST_INT_P (XEXP (x, 1))
336 : 41532587 : && INTVAL (XEXP (x, 1)) == BITS_PER_WORD)
337 : 10 : return XEXP (x, 0);
338 : :
339 : : return NULL_RTX;
340 : : }
341 : :
342 : : /* If INSN is a single set between two objects that we want to split,
343 : : return the single set. SPEED_P says whether we are optimizing
344 : : INSN for speed or size.
345 : :
346 : : INSN should have been passed to recog and extract_insn before this
347 : : is called. */
348 : :
349 : : static rtx
350 : 100838159 : simple_move (rtx_insn *insn, bool speed_p)
351 : : {
352 : 100838159 : rtx x, op;
353 : 100838159 : rtx set;
354 : 100838159 : machine_mode mode;
355 : :
356 : 100838159 : if (recog_data.n_operands != 2)
357 : : return NULL_RTX;
358 : :
359 : 53153059 : set = single_set (insn);
360 : 53153059 : if (!set)
361 : : return NULL_RTX;
362 : :
363 : 50436648 : x = SET_DEST (set);
364 : 50436648 : if (x != recog_data.operand[0] && x != recog_data.operand[1])
365 : : return NULL_RTX;
366 : 40802945 : if (!simple_move_operand (x))
367 : : return NULL_RTX;
368 : :
369 : 37241867 : x = SET_SRC (set);
370 : 37241867 : if ((op = operand_for_swap_move_operator (x)) != NULL_RTX)
371 : 5 : x = op;
372 : :
373 : 37241867 : if (x != recog_data.operand[0] && x != recog_data.operand[1])
374 : : return NULL_RTX;
375 : : /* For the src we can handle ASM_OPERANDS, and it is beneficial for
376 : : things like x86 rdtsc which returns a DImode value. */
377 : 36168164 : if (GET_CODE (x) != ASM_OPERANDS
378 : 36168164 : && !simple_move_operand (x))
379 : : return NULL_RTX;
380 : :
381 : : /* We try to decompose in integer modes, to avoid generating
382 : : inefficient code copying between integer and floating point
383 : : registers. That means that we can't decompose if this is a
384 : : non-integer mode for which there is no integer mode of the same
385 : : size. */
386 : 32414171 : mode = GET_MODE (SET_DEST (set));
387 : 32414171 : scalar_int_mode int_mode;
388 : 32414171 : if (!SCALAR_INT_MODE_P (mode)
389 : 35888206 : && (!int_mode_for_size (GET_MODE_BITSIZE (mode), 0).exists (&int_mode)
390 : 3472328 : || !targetm.modes_tieable_p (mode, int_mode)))
391 : 453618 : return NULL_RTX;
392 : :
393 : : /* Reject PARTIAL_INT modes. They are used for processor specific
394 : : purposes and it's probably best not to tamper with them. */
395 : 31960553 : if (GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
396 : : return NULL_RTX;
397 : :
398 : 31960553 : if (!choices[speed_p].move_modes_to_split[(int) mode])
399 : : return NULL_RTX;
400 : :
401 : : return set;
402 : : }
403 : :
404 : : /* If SET is a copy from one multi-word pseudo-register to another,
405 : : record that in reg_copy_graph. Return whether it is such a
406 : : copy. */
407 : :
408 : : static bool
409 : 2704592 : find_pseudo_copy (rtx set)
410 : : {
411 : 2704592 : rtx dest = SET_DEST (set);
412 : 2704592 : rtx src = SET_SRC (set);
413 : 2704592 : rtx op;
414 : 2704592 : unsigned int rd, rs;
415 : 2704592 : bitmap b;
416 : :
417 : 2704592 : if ((op = operand_for_swap_move_operator (src)) != NULL_RTX)
418 : 4 : src = op;
419 : :
420 : 2704592 : if (!REG_P (dest) || !REG_P (src))
421 : : return false;
422 : :
423 : 421579 : rd = REGNO (dest);
424 : 421579 : rs = REGNO (src);
425 : 421579 : if (HARD_REGISTER_NUM_P (rd) || HARD_REGISTER_NUM_P (rs))
426 : : return false;
427 : :
428 : 130700 : b = reg_copy_graph[rs];
429 : 130700 : if (b == NULL)
430 : : {
431 : 128284 : b = BITMAP_ALLOC (NULL);
432 : 128284 : reg_copy_graph[rs] = b;
433 : : }
434 : :
435 : 130700 : bitmap_set_bit (b, rd);
436 : :
437 : 130700 : return true;
438 : : }
439 : :
440 : : /* Look through the registers in DECOMPOSABLE_CONTEXT. For each case
441 : : where they are copied to another register, add the register to
442 : : which they are copied to DECOMPOSABLE_CONTEXT. Use
443 : : NON_DECOMPOSABLE_CONTEXT to limit this--we don't bother to track
444 : : copies of registers which are in NON_DECOMPOSABLE_CONTEXT. */
445 : :
446 : : static void
447 : 109990 : propagate_pseudo_copies (void)
448 : : {
449 : 109990 : auto_bitmap queue, propagate;
450 : :
451 : 109990 : bitmap_copy (queue, decomposable_context);
452 : 112048 : do
453 : : {
454 : 112048 : bitmap_iterator iter;
455 : 112048 : unsigned int i;
456 : :
457 : 112048 : bitmap_clear (propagate);
458 : :
459 : 407024 : EXECUTE_IF_SET_IN_BITMAP (queue, 0, i, iter)
460 : : {
461 : 294976 : bitmap b = reg_copy_graph[i];
462 : 294976 : if (b)
463 : 4093 : bitmap_ior_and_compl_into (propagate, b, non_decomposable_context);
464 : : }
465 : :
466 : 112048 : bitmap_and_compl (queue, propagate, decomposable_context);
467 : 112048 : bitmap_ior_into (decomposable_context, propagate);
468 : : }
469 : 112048 : while (!bitmap_empty_p (queue));
470 : 109990 : }
471 : :
472 : : /* A pointer to one of these values is passed to
473 : : find_decomposable_subregs. */
474 : :
475 : : enum classify_move_insn
476 : : {
477 : : /* Not a simple move from one location to another. */
478 : : NOT_SIMPLE_MOVE,
479 : : /* A simple move we want to decompose. */
480 : : DECOMPOSABLE_SIMPLE_MOVE,
481 : : /* Any other simple move. */
482 : : SIMPLE_MOVE
483 : : };
484 : :
485 : : /* If we find a SUBREG in *LOC which we could use to decompose a
486 : : pseudo-register, set a bit in DECOMPOSABLE_CONTEXT. If we find an
487 : : unadorned register which is not a simple pseudo-register copy,
488 : : DATA will point at the type of move, and we set a bit in
489 : : DECOMPOSABLE_CONTEXT or NON_DECOMPOSABLE_CONTEXT as appropriate. */
490 : :
491 : : static void
492 : 117603852 : find_decomposable_subregs (rtx *loc, enum classify_move_insn *pcmi)
493 : : {
494 : 117603852 : subrtx_var_iterator::array_type array;
495 : 266319885 : FOR_EACH_SUBRTX_VAR (iter, array, *loc, NONCONST)
496 : : {
497 : 148716033 : rtx x = *iter;
498 : 148716033 : if (GET_CODE (x) == SUBREG)
499 : : {
500 : 2965939 : rtx inner = SUBREG_REG (x);
501 : 2965939 : unsigned int regno, outer_size, inner_size, outer_words, inner_words;
502 : :
503 : 2965939 : if (!REG_P (inner))
504 : 1788630 : continue;
505 : :
506 : 2965936 : regno = REGNO (inner);
507 : 2965936 : if (HARD_REGISTER_NUM_P (regno))
508 : : {
509 : 2 : iter.skip_subrtxes ();
510 : 2 : continue;
511 : : }
512 : :
513 : 2965934 : if (!interesting_mode_p (GET_MODE (x), &outer_size, &outer_words)
514 : 2965934 : || !interesting_mode_p (GET_MODE (inner), &inner_size,
515 : : &inner_words))
516 : : continue;
517 : :
518 : : /* We only try to decompose single word subregs of multi-word
519 : : registers. When we find one, we return -1 to avoid iterating
520 : : over the inner register.
521 : :
522 : : ??? This doesn't allow, e.g., DImode subregs of TImode values
523 : : on 32-bit targets. We would need to record the way the
524 : : pseudo-register was used, and only decompose if all the uses
525 : : were the same number and size of pieces. Hopefully this
526 : : doesn't happen much. */
527 : :
528 : 2965934 : if (outer_words == 1
529 : 2094848 : && inner_words > 1
530 : : /* Don't allow to decompose floating point subregs of
531 : : multi-word pseudos if the floating point mode does
532 : : not have word size, because otherwise we'd generate
533 : : a subreg with that floating mode from a different
534 : : sized integral pseudo which is not allowed by
535 : : validate_subreg. */
536 : 1786863 : && (!FLOAT_MODE_P (GET_MODE (x))
537 : 7032 : || outer_size == UNITS_PER_WORD))
538 : : {
539 : 1786623 : bitmap_set_bit (decomposable_context, regno);
540 : 1786623 : iter.skip_subrtxes ();
541 : 1786623 : continue;
542 : : }
543 : :
544 : : /* If this is a cast from one mode to another, where the modes
545 : : have the same size, and they are not tieable, then mark this
546 : : register as non-decomposable. If we decompose it we are
547 : : likely to mess up whatever the backend is trying to do. */
548 : 1181313 : if (outer_words > 1
549 : 871086 : && outer_size == inner_size
550 : 1336527 : && !targetm.modes_tieable_p (GET_MODE (x), GET_MODE (inner)))
551 : : {
552 : 2002 : bitmap_set_bit (non_decomposable_context, regno);
553 : 2002 : bitmap_set_bit (subreg_context, regno);
554 : 2002 : iter.skip_subrtxes ();
555 : 2002 : continue;
556 : : }
557 : : }
558 : 145750094 : else if (REG_P (x))
559 : : {
560 : 73739319 : unsigned int regno, size, words;
561 : :
562 : : /* We will see an outer SUBREG before we see the inner REG, so
563 : : when we see a plain REG here it means a direct reference to
564 : : the register.
565 : :
566 : : If this is not a simple copy from one location to another,
567 : : then we cannot decompose this register. If this is a simple
568 : : copy we want to decompose, and the mode is right,
569 : : then we mark the register as decomposable.
570 : : Otherwise we don't say anything about this register --
571 : : it could be decomposed, but whether that would be
572 : : profitable depends upon how it is used elsewhere.
573 : :
574 : : We only set bits in the bitmap for multi-word
575 : : pseudo-registers, since those are the only ones we care about
576 : : and it keeps the size of the bitmaps down. */
577 : :
578 : 73739319 : regno = REGNO (x);
579 : 73739319 : if (!HARD_REGISTER_NUM_P (regno)
580 : 46017473 : && interesting_mode_p (GET_MODE (x), &size, &words)
581 : 119756792 : && words > 1)
582 : : {
583 : 8124656 : switch (*pcmi)
584 : : {
585 : 5332204 : case NOT_SIMPLE_MOVE:
586 : 5332204 : bitmap_set_bit (non_decomposable_context, regno);
587 : 5332204 : break;
588 : 15250 : case DECOMPOSABLE_SIMPLE_MOVE:
589 : 15250 : if (targetm.modes_tieable_p (GET_MODE (x), word_mode))
590 : 0 : bitmap_set_bit (decomposable_context, regno);
591 : : break;
592 : : case SIMPLE_MOVE:
593 : : break;
594 : 0 : default:
595 : 0 : gcc_unreachable ();
596 : : }
597 : : }
598 : : }
599 : 72010775 : else if (MEM_P (x))
600 : : {
601 : 15322249 : enum classify_move_insn cmi_mem = NOT_SIMPLE_MOVE;
602 : :
603 : : /* Any registers used in a MEM do not participate in a
604 : : SIMPLE_MOVE or DECOMPOSABLE_SIMPLE_MOVE. Do our own recursion
605 : : here, and return -1 to block the parent's recursion. */
606 : 15322249 : find_decomposable_subregs (&XEXP (x, 0), &cmi_mem);
607 : 15322249 : iter.skip_subrtxes ();
608 : : }
609 : : }
610 : 117603852 : }
611 : :
612 : : /* Decompose REGNO into word-sized components. We smash the REG node
613 : : in place. This ensures that (1) something goes wrong quickly if we
614 : : fail to make some replacement, and (2) the debug information inside
615 : : the symbol table is automatically kept up to date. */
616 : :
617 : : static void
618 : 294976 : decompose_register (unsigned int regno)
619 : : {
620 : 294976 : rtx reg;
621 : 294976 : unsigned int size, words, i;
622 : 294976 : rtvec v;
623 : :
624 : 294976 : reg = regno_reg_rtx[regno];
625 : :
626 : 294976 : regno_reg_rtx[regno] = NULL_RTX;
627 : :
628 : 294976 : if (!interesting_mode_p (GET_MODE (reg), &size, &words))
629 : : gcc_unreachable ();
630 : :
631 : 294976 : v = rtvec_alloc (words);
632 : 1194654 : for (i = 0; i < words; ++i)
633 : 783218 : RTVEC_ELT (v, i) = gen_reg_rtx_offset (reg, word_mode, i * UNITS_PER_WORD);
634 : :
635 : 294976 : PUT_CODE (reg, CONCATN);
636 : 294976 : XVEC (reg, 0) = v;
637 : :
638 : 294976 : if (dump_file)
639 : : {
640 : 0 : fprintf (dump_file, "; Splitting reg %u ->", regno);
641 : 0 : for (i = 0; i < words; ++i)
642 : 0 : fprintf (dump_file, " %u", REGNO (XVECEXP (reg, 0, i)));
643 : 0 : fputc ('\n', dump_file);
644 : : }
645 : 294976 : }
646 : :
647 : : /* Get a SUBREG of a CONCATN. */
648 : :
649 : : static rtx
650 : 1485884 : simplify_subreg_concatn (machine_mode outermode, rtx op, poly_uint64 orig_byte)
651 : : {
652 : 1485884 : unsigned int outer_size, outer_words, inner_size, inner_words;
653 : 1485884 : machine_mode innermode, partmode;
654 : 1485884 : rtx part;
655 : 1485884 : unsigned int final_offset;
656 : 1485884 : unsigned int byte;
657 : :
658 : 1485884 : innermode = GET_MODE (op);
659 : 1485884 : if (!interesting_mode_p (outermode, &outer_size, &outer_words)
660 : 1485884 : || !interesting_mode_p (innermode, &inner_size, &inner_words))
661 : : gcc_unreachable ();
662 : :
663 : : /* Must be constant if interesting_mode_p passes. */
664 : 1485884 : byte = orig_byte.to_constant ();
665 : 1485884 : gcc_assert (GET_CODE (op) == CONCATN);
666 : 1485884 : gcc_assert (byte % outer_size == 0);
667 : :
668 : 1485884 : gcc_assert (byte < inner_size);
669 : 1485884 : if (outer_size > inner_size)
670 : : return NULL_RTX;
671 : :
672 : 1485884 : inner_size /= XVECLEN (op, 0);
673 : 1485884 : part = XVECEXP (op, 0, byte / inner_size);
674 : 1485884 : partmode = GET_MODE (part);
675 : :
676 : 1485884 : final_offset = byte % inner_size;
677 : 1485884 : if (final_offset + outer_size > inner_size)
678 : : return NULL_RTX;
679 : :
680 : : /* VECTOR_CSTs in debug expressions are expanded into CONCATN instead of
681 : : regular CONST_VECTORs. They have vector or integer modes, depending
682 : : on the capabilities of the target. Cope with them. */
683 : 1485873 : if (partmode == VOIDmode && VECTOR_MODE_P (innermode))
684 : 0 : partmode = GET_MODE_INNER (innermode);
685 : 0 : else if (partmode == VOIDmode)
686 : 0 : partmode = mode_for_size (inner_size * BITS_PER_UNIT,
687 : 0 : GET_MODE_CLASS (innermode), 0).require ();
688 : :
689 : 1485873 : return simplify_gen_subreg (outermode, part, partmode, final_offset);
690 : : }
691 : :
692 : : /* Wrapper around simplify_gen_subreg which handles CONCATN. */
693 : :
694 : : static rtx
695 : 1137373 : simplify_gen_subreg_concatn (machine_mode outermode, rtx op,
696 : : machine_mode innermode, unsigned int byte)
697 : : {
698 : 1137651 : rtx ret;
699 : :
700 : : /* We have to handle generating a SUBREG of a SUBREG of a CONCATN.
701 : : If OP is a SUBREG of a CONCATN, then it must be a simple mode
702 : : change with the same size and offset 0, or it must extract a
703 : : part. We shouldn't see anything else here. */
704 : 1137651 : if (GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == CONCATN)
705 : : {
706 : 282 : rtx op2;
707 : :
708 : 564 : if (known_eq (GET_MODE_SIZE (GET_MODE (op)),
709 : : GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))))
710 : 282 : && known_eq (SUBREG_BYTE (op), 0))
711 : : return simplify_gen_subreg_concatn (outermode, SUBREG_REG (op),
712 : : GET_MODE (SUBREG_REG (op)), byte);
713 : :
714 : 8 : op2 = simplify_subreg_concatn (GET_MODE (op), SUBREG_REG (op),
715 : 4 : SUBREG_BYTE (op));
716 : 4 : if (op2 == NULL_RTX)
717 : : {
718 : : /* We don't handle paradoxical subregs here. */
719 : 4 : gcc_assert (!paradoxical_subreg_p (outermode, GET_MODE (op)));
720 : 4 : gcc_assert (!paradoxical_subreg_p (op));
721 : 8 : op2 = simplify_subreg_concatn (outermode, SUBREG_REG (op),
722 : 4 : byte + SUBREG_BYTE (op));
723 : 4 : gcc_assert (op2 != NULL_RTX);
724 : : return op2;
725 : : }
726 : :
727 : 0 : op = op2;
728 : 0 : gcc_assert (op != NULL_RTX);
729 : 0 : gcc_assert (innermode == GET_MODE (op));
730 : : }
731 : :
732 : 1137369 : if (GET_CODE (op) == CONCATN)
733 : 632323 : return simplify_subreg_concatn (outermode, op, byte);
734 : :
735 : 505046 : ret = simplify_gen_subreg (outermode, op, innermode, byte);
736 : :
737 : : /* If we see an insn like (set (reg:DI) (subreg:DI (reg:SI) 0)) then
738 : : resolve_simple_move will ask for the high part of the paradoxical
739 : : subreg, which does not have a value. Just return a zero. */
740 : 505046 : if (ret == NULL_RTX
741 : 505046 : && paradoxical_subreg_p (op))
742 : 1 : return CONST0_RTX (outermode);
743 : :
744 : 505045 : gcc_assert (ret != NULL_RTX);
745 : : return ret;
746 : : }
747 : :
748 : : /* Return whether we should resolve X into the registers into which it
749 : : was decomposed. */
750 : :
751 : : static bool
752 : 38029009 : resolve_reg_p (rtx x)
753 : : {
754 : 38029009 : return GET_CODE (x) == CONCATN;
755 : : }
756 : :
757 : : /* Return whether X is a SUBREG of a register which we need to
758 : : resolve. */
759 : :
760 : : static bool
761 : 105573040 : resolve_subreg_p (rtx x)
762 : : {
763 : 3002005 : if (GET_CODE (x) != SUBREG)
764 : : return false;
765 : 0 : return resolve_reg_p (SUBREG_REG (x));
766 : : }
767 : :
768 : : /* Look for SUBREGs in *LOC which need to be decomposed. */
769 : :
770 : : static bool
771 : 50909313 : resolve_subreg_use (rtx *loc, rtx insn)
772 : : {
773 : 50909313 : subrtx_ptr_iterator::array_type array;
774 : 125537898 : FOR_EACH_SUBRTX_PTR (iter, array, loc, NONCONST)
775 : : {
776 : 74630710 : rtx *loc = *iter;
777 : 74630710 : rtx x = *loc;
778 : 74630710 : if (resolve_subreg_p (x))
779 : : {
780 : 1565856 : x = simplify_subreg_concatn (GET_MODE (x), SUBREG_REG (x),
781 : 782928 : SUBREG_BYTE (x));
782 : :
783 : : /* It is possible for a note to contain a reference which we can
784 : : decompose. In this case, return 1 to the caller to indicate
785 : : that the note must be removed. */
786 : 782928 : if (!x)
787 : : {
788 : 3 : gcc_assert (!insn);
789 : 2125 : return true;
790 : : }
791 : :
792 : 782925 : validate_change (insn, loc, x, 1);
793 : 782925 : iter.skip_subrtxes ();
794 : : }
795 : 73847782 : else if (resolve_reg_p (x))
796 : : /* Return 1 to the caller to indicate that we found a direct
797 : : reference to a register which is being decomposed. This can
798 : : happen inside notes, multiword shift or zero-extend
799 : : instructions. */
800 : : return true;
801 : : }
802 : :
803 : 50907188 : return false;
804 : 50909313 : }
805 : :
806 : : /* Resolve any decomposed registers which appear in register notes on
807 : : INSN. */
808 : :
809 : : static void
810 : 34480084 : resolve_reg_notes (rtx_insn *insn)
811 : : {
812 : 34480084 : rtx *pnote, note;
813 : :
814 : 34480084 : note = find_reg_equal_equiv_note (insn);
815 : 34480084 : if (note)
816 : : {
817 : 541501 : int old_count = num_validated_changes ();
818 : 541501 : if (resolve_subreg_use (&XEXP (note, 0), NULL_RTX))
819 : 2125 : remove_note (insn, note);
820 : : else
821 : 539376 : if (old_count != num_validated_changes ())
822 : 3369 : df_notes_rescan (insn);
823 : : }
824 : :
825 : 34480084 : pnote = ®_NOTES (insn);
826 : 45839514 : while (*pnote != NULL_RTX)
827 : : {
828 : 11359430 : bool del = false;
829 : :
830 : 11359430 : note = *pnote;
831 : 11359430 : switch (REG_NOTE_KIND (note))
832 : : {
833 : 3758779 : case REG_DEAD:
834 : 3758779 : case REG_UNUSED:
835 : 3758779 : if (resolve_reg_p (XEXP (note, 0)))
836 : 7198 : del = true;
837 : : break;
838 : :
839 : : default:
840 : : break;
841 : : }
842 : :
843 : 7198 : if (del)
844 : 7198 : *pnote = XEXP (note, 1);
845 : : else
846 : 11352232 : pnote = &XEXP (note, 1);
847 : : }
848 : 34480084 : }
849 : :
850 : : /* Return whether X can be decomposed into subwords. */
851 : :
852 : : static bool
853 : 478870 : can_decompose_p (rtx x)
854 : : {
855 : 478870 : if (REG_P (x))
856 : : {
857 : 137446 : unsigned int regno = REGNO (x);
858 : :
859 : 137446 : if (HARD_REGISTER_NUM_P (regno))
860 : : {
861 : 94592 : unsigned int byte, num_bytes, num_words;
862 : :
863 : 94592 : if (!interesting_mode_p (GET_MODE (x), &num_bytes, &num_words))
864 : : return false;
865 : 291860 : for (byte = 0; byte < num_bytes; byte += UNITS_PER_WORD)
866 : 189184 : if (simplify_subreg_regno (regno, GET_MODE (x), byte, word_mode) < 0)
867 : : return false;
868 : : return true;
869 : : }
870 : : else
871 : 42854 : return !bitmap_bit_p (subreg_context, regno);
872 : : }
873 : :
874 : : return true;
875 : : }
876 : :
877 : : /* OPND is a concatn operand this is used with a simple move operator.
878 : : Return a new rtx with the concatn's operands swapped. */
879 : :
880 : : static rtx
881 : 1 : resolve_operand_for_swap_move_operator (rtx opnd)
882 : : {
883 : 1 : gcc_assert (GET_CODE (opnd) == CONCATN);
884 : 1 : rtx concatn = copy_rtx (opnd);
885 : 1 : rtx op0 = XVECEXP (concatn, 0, 0);
886 : 1 : rtx op1 = XVECEXP (concatn, 0, 1);
887 : 1 : XVECEXP (concatn, 0, 0) = op1;
888 : 1 : XVECEXP (concatn, 0, 1) = op0;
889 : 1 : return concatn;
890 : : }
891 : :
892 : : /* Decompose the registers used in a simple move SET within INSN. If
893 : : we don't change anything, return INSN, otherwise return the start
894 : : of the sequence of moves. */
895 : :
896 : : static rtx_insn *
897 : 1586118 : resolve_simple_move (rtx set, rtx_insn *insn)
898 : : {
899 : 1586118 : rtx src, dest, real_dest, src_op;
900 : 1586118 : rtx_insn *insns;
901 : 1586118 : machine_mode orig_mode, dest_mode;
902 : 1586118 : unsigned int orig_size, words;
903 : 1586118 : bool pushing;
904 : :
905 : 1586118 : src = SET_SRC (set);
906 : 1586118 : dest = SET_DEST (set);
907 : 1586118 : orig_mode = GET_MODE (dest);
908 : :
909 : 1586118 : if (!interesting_mode_p (orig_mode, &orig_size, &words))
910 : : gcc_unreachable ();
911 : 1586118 : gcc_assert (words > 1);
912 : :
913 : 1586118 : start_sequence ();
914 : :
915 : : /* We have to handle copying from a SUBREG of a decomposed reg where
916 : : the SUBREG is larger than word size. Rather than assume that we
917 : : can take a word_mode SUBREG of the destination, we copy to a new
918 : : register and then copy that to the destination. */
919 : :
920 : 1586118 : real_dest = NULL_RTX;
921 : :
922 : 1586118 : if ((src_op = operand_for_swap_move_operator (src)) != NULL_RTX)
923 : : {
924 : 1 : if (resolve_reg_p (dest))
925 : : {
926 : : /* DEST is a CONCATN, so swap its operands and strip
927 : : SRC's operator. */
928 : 1 : dest = resolve_operand_for_swap_move_operator (dest);
929 : 1 : src = src_op;
930 : 1 : if (resolve_reg_p (src))
931 : : {
932 : 1 : gcc_assert (GET_CODE (src) == CONCATN);
933 : 1 : if (reg_overlap_mentioned_p (XVECEXP (dest, 0, 0),
934 : 1 : XVECEXP (src, 0, 1)))
935 : : {
936 : : /* If there is overlap between the first half of the
937 : : destination and what will be stored to the second one,
938 : : use a temporary pseudo. See PR114211. */
939 : 1 : rtx tem = gen_reg_rtx (GET_MODE (XVECEXP (src, 0, 1)));
940 : 1 : emit_move_insn (tem, XVECEXP (src, 0, 1));
941 : 1 : src = copy_rtx (src);
942 : 1 : XVECEXP (src, 0, 1) = tem;
943 : : }
944 : : }
945 : : }
946 : 0 : else if (resolve_reg_p (src_op))
947 : : {
948 : : /* SRC is an operation on a CONCATN, so strip the operator and
949 : : swap the CONCATN's operands. */
950 : 0 : src = resolve_operand_for_swap_move_operator (src_op);
951 : : }
952 : : }
953 : :
954 : 1586118 : if (GET_CODE (src) == SUBREG
955 : 12059 : && resolve_reg_p (SUBREG_REG (src))
956 : 1586197 : && (maybe_ne (SUBREG_BYTE (src), 0)
957 : 156 : || maybe_ne (orig_size, GET_MODE_SIZE (GET_MODE (SUBREG_REG (src))))))
958 : : {
959 : 2 : real_dest = dest;
960 : 2 : dest = gen_reg_rtx (orig_mode);
961 : 2 : if (REG_P (real_dest))
962 : 2 : REG_ATTRS (dest) = REG_ATTRS (real_dest);
963 : : }
964 : :
965 : : /* Similarly if we are copying to a SUBREG of a decomposed reg where
966 : : the SUBREG is larger than word size. */
967 : :
968 : 1586118 : if (GET_CODE (dest) == SUBREG
969 : 880 : && resolve_reg_p (SUBREG_REG (dest))
970 : 1586179 : && (maybe_ne (SUBREG_BYTE (dest), 0)
971 : 61 : || maybe_ne (orig_size,
972 : 122 : GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest))))))
973 : : {
974 : 0 : rtx reg, smove;
975 : 0 : rtx_insn *minsn;
976 : :
977 : 0 : reg = gen_reg_rtx (orig_mode);
978 : 0 : minsn = emit_move_insn (reg, src);
979 : 0 : smove = single_set (minsn);
980 : 0 : gcc_assert (smove != NULL_RTX);
981 : 0 : resolve_simple_move (smove, minsn);
982 : 0 : src = reg;
983 : : }
984 : :
985 : : /* If we didn't have any big SUBREGS of decomposed registers, and
986 : : neither side of the move is a register we are decomposing, then
987 : : we don't have to do anything here. */
988 : :
989 : 1586118 : if (src == SET_SRC (set)
990 : 1586117 : && dest == SET_DEST (set)
991 : 1586115 : && !resolve_reg_p (src)
992 : 12057 : && !resolve_subreg_p (src)
993 : 1553102 : && !resolve_reg_p (dest)
994 : 1586993 : && !resolve_subreg_p (dest))
995 : : {
996 : 1346683 : end_sequence ();
997 : 1346683 : return insn;
998 : : }
999 : :
1000 : : /* It's possible for the code to use a subreg of a decomposed
1001 : : register while forming an address. We need to handle that before
1002 : : passing the address to emit_move_insn. We pass NULL_RTX as the
1003 : : insn parameter to resolve_subreg_use because we cannot validate
1004 : : the insn yet. */
1005 : 239435 : if (MEM_P (src) || MEM_P (dest))
1006 : : {
1007 : 70757 : int acg;
1008 : :
1009 : 70757 : if (MEM_P (src))
1010 : 58481 : resolve_subreg_use (&XEXP (src, 0), NULL_RTX);
1011 : 70757 : if (MEM_P (dest))
1012 : 12276 : resolve_subreg_use (&XEXP (dest, 0), NULL_RTX);
1013 : 70757 : acg = apply_change_group ();
1014 : 70757 : gcc_assert (acg);
1015 : : }
1016 : :
1017 : : /* If SRC is a register which we can't decompose, or has side
1018 : : effects, we need to move via a temporary register. */
1019 : :
1020 : 239435 : if (!can_decompose_p (src)
1021 : 239289 : || side_effects_p (src)
1022 : 478724 : || GET_CODE (src) == ASM_OPERANDS)
1023 : : {
1024 : 146 : rtx reg;
1025 : :
1026 : 146 : reg = gen_reg_rtx (orig_mode);
1027 : :
1028 : 146 : if (AUTO_INC_DEC)
1029 : : {
1030 : : rtx_insn *move = emit_move_insn (reg, src);
1031 : : if (MEM_P (src))
1032 : : {
1033 : : rtx note = find_reg_note (insn, REG_INC, NULL_RTX);
1034 : : if (note)
1035 : : add_reg_note (move, REG_INC, XEXP (note, 0));
1036 : : }
1037 : : }
1038 : : else
1039 : 146 : emit_move_insn (reg, src);
1040 : :
1041 : 146 : src = reg;
1042 : : }
1043 : :
1044 : : /* If DEST is a register which we can't decompose, or has side
1045 : : effects, we need to first move to a temporary register. We
1046 : : handle the common case of pushing an operand directly. We also
1047 : : go through a temporary register if it holds a floating point
1048 : : value. This gives us better code on systems which can't move
1049 : : data easily between integer and floating point registers. */
1050 : :
1051 : 239435 : dest_mode = orig_mode;
1052 : 239435 : pushing = push_operand (dest, dest_mode);
1053 : 239435 : if (!can_decompose_p (dest)
1054 : 239429 : || (side_effects_p (dest) && !pushing)
1055 : 478864 : || (!SCALAR_INT_MODE_P (dest_mode)
1056 : 0 : && !resolve_reg_p (dest)
1057 : 0 : && !resolve_subreg_p (dest)))
1058 : : {
1059 : 6 : if (real_dest == NULL_RTX)
1060 : 6 : real_dest = dest;
1061 : 6 : if (!SCALAR_INT_MODE_P (dest_mode))
1062 : 0 : dest_mode = int_mode_for_mode (dest_mode).require ();
1063 : 6 : dest = gen_reg_rtx (dest_mode);
1064 : 6 : if (REG_P (real_dest))
1065 : 6 : REG_ATTRS (dest) = REG_ATTRS (real_dest);
1066 : : }
1067 : :
1068 : 239435 : if (pushing)
1069 : : {
1070 : 0 : unsigned int i, j, jinc;
1071 : :
1072 : 0 : gcc_assert (orig_size % UNITS_PER_WORD == 0);
1073 : 0 : gcc_assert (GET_CODE (XEXP (dest, 0)) != PRE_MODIFY);
1074 : 0 : gcc_assert (GET_CODE (XEXP (dest, 0)) != POST_MODIFY);
1075 : :
1076 : 0 : if (WORDS_BIG_ENDIAN == STACK_GROWS_DOWNWARD)
1077 : : {
1078 : : j = 0;
1079 : : jinc = 1;
1080 : : }
1081 : : else
1082 : : {
1083 : 0 : j = words - 1;
1084 : 0 : jinc = -1;
1085 : : }
1086 : :
1087 : 0 : for (i = 0; i < words; ++i, j += jinc)
1088 : : {
1089 : 0 : rtx temp;
1090 : :
1091 : 0 : temp = copy_rtx (XEXP (dest, 0));
1092 : 0 : temp = adjust_automodify_address_nv (dest, word_mode, temp,
1093 : : j * UNITS_PER_WORD);
1094 : 0 : emit_move_insn (temp,
1095 : : simplify_gen_subreg_concatn (word_mode, src,
1096 : : orig_mode,
1097 : 0 : j * UNITS_PER_WORD));
1098 : : }
1099 : : }
1100 : : else
1101 : : {
1102 : 239435 : unsigned int i;
1103 : :
1104 : 239435 : if (REG_P (dest) && !HARD_REGISTER_NUM_P (REGNO (dest)))
1105 : 1155 : emit_clobber (dest);
1106 : :
1107 : 741541 : for (i = 0; i < words; ++i)
1108 : : {
1109 : 502106 : rtx t = simplify_gen_subreg_concatn (word_mode, dest,
1110 : : dest_mode,
1111 : 502106 : i * UNITS_PER_WORD);
1112 : : /* simplify_gen_subreg_concatn can return (const_int 0) for
1113 : : some sub-objects of paradoxical subregs. As a source operand,
1114 : : that's fine. As a destination it must be avoided. Those are
1115 : : supposed to be don't care bits, so we can just drop that store
1116 : : on the floor. */
1117 : 502106 : if (t != CONST0_RTX (word_mode))
1118 : 502106 : emit_move_insn (t,
1119 : : simplify_gen_subreg_concatn (word_mode, src,
1120 : : orig_mode,
1121 : 502106 : i * UNITS_PER_WORD));
1122 : : }
1123 : : }
1124 : :
1125 : 239435 : if (real_dest != NULL_RTX)
1126 : : {
1127 : 8 : rtx mdest, smove;
1128 : 8 : rtx_insn *minsn;
1129 : :
1130 : 8 : if (dest_mode == orig_mode)
1131 : : mdest = dest;
1132 : : else
1133 : 0 : mdest = simplify_gen_subreg (orig_mode, dest, GET_MODE (dest), 0);
1134 : 8 : minsn = emit_move_insn (real_dest, mdest);
1135 : :
1136 : 8 : if (AUTO_INC_DEC && MEM_P (real_dest)
1137 : : && !(resolve_reg_p (real_dest) || resolve_subreg_p (real_dest)))
1138 : : {
1139 : : rtx note = find_reg_note (insn, REG_INC, NULL_RTX);
1140 : : if (note)
1141 : : add_reg_note (minsn, REG_INC, XEXP (note, 0));
1142 : : }
1143 : :
1144 : 8 : smove = single_set (minsn);
1145 : 8 : gcc_assert (smove != NULL_RTX);
1146 : :
1147 : 8 : resolve_simple_move (smove, minsn);
1148 : : }
1149 : :
1150 : 239435 : insns = get_insns ();
1151 : 239435 : end_sequence ();
1152 : :
1153 : 239435 : copy_reg_eh_region_note_forward (insn, insns, NULL_RTX);
1154 : :
1155 : 239435 : emit_insn_before (insns, insn);
1156 : :
1157 : : /* If we get here via self-recursion, then INSN is not yet in the insns
1158 : : chain and delete_insn will fail. We only want to remove INSN from the
1159 : : current sequence. See PR56738. */
1160 : 239435 : if (in_sequence_p ())
1161 : 0 : remove_insn (insn);
1162 : : else
1163 : 239435 : delete_insn (insn);
1164 : :
1165 : : return insns;
1166 : : }
1167 : :
1168 : : /* Change a CLOBBER of a decomposed register into a CLOBBER of the
1169 : : component registers. Return whether we changed something. */
1170 : :
1171 : : static bool
1172 : 151080 : resolve_clobber (rtx pat, rtx_insn *insn)
1173 : : {
1174 : 151080 : rtx reg;
1175 : 151080 : machine_mode orig_mode;
1176 : 151080 : unsigned int orig_size, words, i;
1177 : 151080 : int ret;
1178 : :
1179 : 151080 : reg = XEXP (pat, 0);
1180 : : /* For clobbers we can look through paradoxical subregs which
1181 : : we do not handle in simplify_gen_subreg_concatn. */
1182 : 151080 : if (paradoxical_subreg_p (reg))
1183 : 0 : reg = SUBREG_REG (reg);
1184 : 151080 : if (!resolve_reg_p (reg) && !resolve_subreg_p (reg))
1185 : : return false;
1186 : :
1187 : 48993 : orig_mode = GET_MODE (reg);
1188 : 48993 : if (!interesting_mode_p (orig_mode, &orig_size, &words))
1189 : : gcc_unreachable ();
1190 : :
1191 : 48993 : ret = validate_change (NULL_RTX, &XEXP (pat, 0),
1192 : : simplify_gen_subreg_concatn (word_mode, reg,
1193 : : orig_mode, 0),
1194 : : 0);
1195 : 48993 : df_insn_rescan (insn);
1196 : 48993 : gcc_assert (ret != 0);
1197 : :
1198 : 97986 : for (i = words - 1; i > 0; --i)
1199 : : {
1200 : 48993 : rtx x;
1201 : :
1202 : 48993 : x = simplify_gen_subreg_concatn (word_mode, reg, orig_mode,
1203 : 48993 : i * UNITS_PER_WORD);
1204 : 48993 : x = gen_rtx_CLOBBER (VOIDmode, x);
1205 : 48993 : emit_insn_after (x, insn);
1206 : : }
1207 : :
1208 : 48993 : resolve_reg_notes (insn);
1209 : :
1210 : 48993 : return true;
1211 : : }
1212 : :
1213 : : /* A USE of a decomposed register is no longer meaningful. Return
1214 : : whether we changed something. */
1215 : :
1216 : : static bool
1217 : 66727 : resolve_use (rtx pat, rtx_insn *insn)
1218 : : {
1219 : 66727 : if (resolve_reg_p (XEXP (pat, 0)) || resolve_subreg_p (XEXP (pat, 0)))
1220 : : {
1221 : 0 : delete_insn (insn);
1222 : 0 : return true;
1223 : : }
1224 : :
1225 : 66727 : resolve_reg_notes (insn);
1226 : :
1227 : 66727 : return false;
1228 : : }
1229 : :
1230 : : /* A VAR_LOCATION can be simplified. */
1231 : :
1232 : : static void
1233 : 11518608 : resolve_debug (rtx_insn *insn)
1234 : : {
1235 : 11518608 : subrtx_ptr_iterator::array_type array;
1236 : 39392206 : FOR_EACH_SUBRTX_PTR (iter, array, &PATTERN (insn), NONCONST)
1237 : : {
1238 : 27873598 : rtx *loc = *iter;
1239 : 27873598 : rtx x = *loc;
1240 : 27873598 : if (resolve_subreg_p (x))
1241 : : {
1242 : 141250 : x = simplify_subreg_concatn (GET_MODE (x), SUBREG_REG (x),
1243 : 70625 : SUBREG_BYTE (x));
1244 : :
1245 : 70625 : if (x)
1246 : 70621 : *loc = x;
1247 : : else
1248 : 4 : x = copy_rtx (*loc);
1249 : : }
1250 : 27873598 : if (resolve_reg_p (x))
1251 : 30304 : *loc = copy_rtx (x);
1252 : : }
1253 : :
1254 : 11518608 : df_insn_rescan (insn);
1255 : :
1256 : 11518608 : resolve_reg_notes (insn);
1257 : 11518608 : }
1258 : :
1259 : : /* Check if INSN is a decomposable multiword-shift or zero-extend and
1260 : : set the decomposable_context bitmap accordingly. SPEED_P is true
1261 : : if we are optimizing INSN for speed rather than size. Return true
1262 : : if INSN is decomposable. */
1263 : :
1264 : : static bool
1265 : 78027340 : find_decomposable_shift_zext (rtx_insn *insn, bool speed_p)
1266 : : {
1267 : 78027340 : rtx set;
1268 : 78027340 : rtx op;
1269 : 78027340 : rtx op_operand;
1270 : :
1271 : 78027340 : set = single_set (insn);
1272 : 78027340 : if (!set)
1273 : : return false;
1274 : :
1275 : 44140356 : op = SET_SRC (set);
1276 : 44140356 : if (GET_CODE (op) != ASHIFT
1277 : : && GET_CODE (op) != LSHIFTRT
1278 : : && GET_CODE (op) != ASHIFTRT
1279 : : && GET_CODE (op) != ZERO_EXTEND)
1280 : : return false;
1281 : :
1282 : 856046 : op_operand = XEXP (op, 0);
1283 : 839161 : if (!REG_P (SET_DEST (set)) || !REG_P (op_operand)
1284 : 741191 : || HARD_REGISTER_NUM_P (REGNO (SET_DEST (set)))
1285 : 737722 : || HARD_REGISTER_NUM_P (REGNO (op_operand))
1286 : 1593761 : || GET_MODE (op) != twice_word_mode)
1287 : : return false;
1288 : :
1289 : 117859 : if (GET_CODE (op) == ZERO_EXTEND)
1290 : : {
1291 : 54101 : if (GET_MODE (op_operand) != word_mode
1292 : 54101 : || !choices[speed_p].splitting_zext)
1293 : : return false;
1294 : : }
1295 : : else /* left or right shift */
1296 : : {
1297 : 63758 : bool *splitting = (GET_CODE (op) == ASHIFT
1298 : 17092 : ? choices[speed_p].splitting_ashift
1299 : : : GET_CODE (op) == ASHIFTRT
1300 : 9173 : ? choices[speed_p].splitting_ashiftrt
1301 : 37493 : : choices[speed_p].splitting_lshiftrt);
1302 : 63758 : if (!CONST_INT_P (XEXP (op, 1))
1303 : 117450 : || !IN_RANGE (INTVAL (XEXP (op, 1)), BITS_PER_WORD,
1304 : : 2 * BITS_PER_WORD - 1)
1305 : 55811 : || !splitting[INTVAL (XEXP (op, 1)) - BITS_PER_WORD])
1306 : : return false;
1307 : :
1308 : 34937 : bitmap_set_bit (decomposable_context, REGNO (op_operand));
1309 : : }
1310 : :
1311 : 34937 : bitmap_set_bit (decomposable_context, REGNO (SET_DEST (set)));
1312 : :
1313 : 34937 : return true;
1314 : : }
1315 : :
1316 : : /* Decompose a more than word wide shift (in INSN) of a multiword
1317 : : pseudo or a multiword zero-extend of a wordmode pseudo into a move
1318 : : and 'set to zero' insn. SPEED_P says whether we are optimizing
1319 : : for speed or size, when checking if a ZERO_EXTEND is preferable.
1320 : : Return a pointer to the new insn when a replacement was done. */
1321 : :
1322 : : static rtx_insn *
1323 : 21259646 : resolve_shift_zext (rtx_insn *insn, bool speed_p)
1324 : : {
1325 : 21259646 : rtx set;
1326 : 21259646 : rtx op;
1327 : 21259646 : rtx op_operand;
1328 : 21259646 : rtx_insn *insns;
1329 : 21259646 : rtx src_reg, dest_reg, dest_upper, upper_src = NULL_RTX;
1330 : 21259646 : int src_reg_num, dest_reg_num, offset1, offset2, src_offset;
1331 : 21259646 : scalar_int_mode inner_mode;
1332 : :
1333 : 21259646 : set = single_set (insn);
1334 : 21259646 : if (!set)
1335 : : return NULL;
1336 : :
1337 : 20095525 : op = SET_SRC (set);
1338 : 20095525 : if (GET_CODE (op) != ASHIFT
1339 : : && GET_CODE (op) != LSHIFTRT
1340 : : && GET_CODE (op) != ASHIFTRT
1341 : : && GET_CODE (op) != ZERO_EXTEND)
1342 : : return NULL;
1343 : :
1344 : 425523 : op_operand = XEXP (op, 0);
1345 : 425523 : if (!is_a <scalar_int_mode> (GET_MODE (op_operand), &inner_mode))
1346 : : return NULL;
1347 : :
1348 : : /* We can tear this operation apart only if the regs were already
1349 : : torn apart. */
1350 : 390763 : if (!resolve_reg_p (SET_DEST (set)) && !resolve_reg_p (op_operand))
1351 : : return NULL;
1352 : :
1353 : : /* src_reg_num is the number of the word mode register which we
1354 : : are operating on. For a left shift and a zero_extend on little
1355 : : endian machines this is register 0. */
1356 : 23450 : src_reg_num = (GET_CODE (op) == LSHIFTRT || GET_CODE (op) == ASHIFTRT)
1357 : 11725 : ? 1 : 0;
1358 : :
1359 : 11725 : if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (inner_mode) > UNITS_PER_WORD)
1360 : : src_reg_num = 1 - src_reg_num;
1361 : :
1362 : 11725 : if (GET_CODE (op) == ZERO_EXTEND)
1363 : : dest_reg_num = WORDS_BIG_ENDIAN ? 1 : 0;
1364 : : else
1365 : 11725 : dest_reg_num = 1 - src_reg_num;
1366 : :
1367 : 11725 : offset1 = UNITS_PER_WORD * dest_reg_num;
1368 : 11725 : offset2 = UNITS_PER_WORD * (1 - dest_reg_num);
1369 : 11725 : src_offset = UNITS_PER_WORD * src_reg_num;
1370 : :
1371 : 11725 : start_sequence ();
1372 : :
1373 : 23450 : dest_reg = simplify_gen_subreg_concatn (word_mode, SET_DEST (set),
1374 : 11725 : GET_MODE (SET_DEST (set)),
1375 : : offset1);
1376 : 23450 : dest_upper = simplify_gen_subreg_concatn (word_mode, SET_DEST (set),
1377 : 11725 : GET_MODE (SET_DEST (set)),
1378 : : offset2);
1379 : 23450 : src_reg = simplify_gen_subreg_concatn (word_mode, op_operand,
1380 : 11725 : GET_MODE (op_operand),
1381 : : src_offset);
1382 : 11725 : if (GET_CODE (op) == ASHIFTRT
1383 : 3239 : && INTVAL (XEXP (op, 1)) != 2 * BITS_PER_WORD - 1)
1384 : 3153 : upper_src = expand_shift (RSHIFT_EXPR, word_mode, copy_rtx (src_reg),
1385 : 3203 : BITS_PER_WORD - 1, NULL_RTX, 0);
1386 : :
1387 : 11725 : if (GET_CODE (op) != ZERO_EXTEND)
1388 : : {
1389 : 11725 : int shift_count = INTVAL (XEXP (op, 1));
1390 : 15752 : if (shift_count > BITS_PER_WORD)
1391 : 2943 : src_reg = expand_shift (GET_CODE (op) == ASHIFT ?
1392 : : LSHIFT_EXPR : RSHIFT_EXPR,
1393 : : word_mode, src_reg,
1394 : 2943 : shift_count - BITS_PER_WORD,
1395 : : dest_reg, GET_CODE (op) != ASHIFTRT);
1396 : : }
1397 : :
1398 : : /* Consider using ZERO_EXTEND instead of setting DEST_UPPER to zero
1399 : : if this is considered reasonable. */
1400 : 11725 : if (GET_CODE (op) == LSHIFTRT
1401 : 8332 : && GET_MODE (op) == twice_word_mode
1402 : 8332 : && REG_P (SET_DEST (set))
1403 : 11894 : && !choices[speed_p].splitting_zext)
1404 : : {
1405 : 169 : rtx tmp = force_reg (word_mode, copy_rtx (src_reg));
1406 : 169 : tmp = simplify_gen_unary (ZERO_EXTEND, twice_word_mode, tmp, word_mode);
1407 : 169 : emit_move_insn (SET_DEST (set), tmp);
1408 : : }
1409 : : else
1410 : : {
1411 : 11556 : if (dest_reg != src_reg)
1412 : 8659 : emit_move_insn (dest_reg, src_reg);
1413 : 11556 : if (GET_CODE (op) != ASHIFTRT)
1414 : 8373 : emit_move_insn (dest_upper, CONST0_RTX (word_mode));
1415 : 3239 : else if (INTVAL (XEXP (op, 1)) == 2 * BITS_PER_WORD - 1)
1416 : 30 : emit_move_insn (dest_upper, copy_rtx (src_reg));
1417 : : else
1418 : 3153 : emit_move_insn (dest_upper, upper_src);
1419 : : }
1420 : :
1421 : 11725 : insns = get_insns ();
1422 : :
1423 : 11725 : end_sequence ();
1424 : :
1425 : 11725 : emit_insn_before (insns, insn);
1426 : :
1427 : 11725 : if (dump_file)
1428 : : {
1429 : 0 : rtx_insn *in;
1430 : 0 : fprintf (dump_file, "; Replacing insn: %d with insns: ", INSN_UID (insn));
1431 : 0 : for (in = insns; in != insn; in = NEXT_INSN (in))
1432 : 0 : fprintf (dump_file, "%d ", INSN_UID (in));
1433 : 0 : fprintf (dump_file, "\n");
1434 : : }
1435 : :
1436 : 11725 : delete_insn (insn);
1437 : 11725 : return insns;
1438 : : }
1439 : :
1440 : : /* Print to dump_file a description of what we're doing with shift code CODE.
1441 : : SPLITTING[X] is true if we are splitting shifts by X + BITS_PER_WORD. */
1442 : :
1443 : : static void
1444 : 360 : dump_shift_choices (enum rtx_code code, bool *splitting)
1445 : : {
1446 : 360 : int i;
1447 : 360 : const char *sep;
1448 : :
1449 : 360 : fprintf (dump_file,
1450 : : " Splitting mode %s for %s lowering with shift amounts = ",
1451 : 360 : GET_MODE_NAME (twice_word_mode), GET_RTX_NAME (code));
1452 : 360 : sep = "";
1453 : 23760 : for (i = 0; i < BITS_PER_WORD; i++)
1454 : 23040 : if (splitting[i])
1455 : : {
1456 : 23040 : fprintf (dump_file, "%s%d", sep, i + BITS_PER_WORD);
1457 : 23040 : sep = ",";
1458 : : }
1459 : 360 : fprintf (dump_file, "\n");
1460 : 360 : }
1461 : :
1462 : : /* Print to dump_file a description of what we're doing when optimizing
1463 : : for speed or size; SPEED_P says which. DESCRIPTION is a description
1464 : : of the SPEED_P choice. */
1465 : :
1466 : : static void
1467 : 120 : dump_choices (bool speed_p, const char *description)
1468 : : {
1469 : 120 : unsigned int size, factor, i;
1470 : :
1471 : 120 : fprintf (dump_file, "Choices when optimizing for %s:\n", description);
1472 : :
1473 : 15840 : for (i = 0; i < MAX_MACHINE_MODE; i++)
1474 : 15600 : if (interesting_mode_p ((machine_mode) i, &size, &factor)
1475 : 15600 : && factor > 1)
1476 : 8160 : fprintf (dump_file, " %s mode %s for copy lowering.\n",
1477 : 8160 : choices[speed_p].move_modes_to_split[i]
1478 : : ? "Splitting"
1479 : : : "Skipping",
1480 : 8160 : GET_MODE_NAME ((machine_mode) i));
1481 : :
1482 : 120 : fprintf (dump_file, " %s mode %s for zero_extend lowering.\n",
1483 : 120 : choices[speed_p].splitting_zext ? "Splitting" : "Skipping",
1484 : 120 : GET_MODE_NAME (twice_word_mode));
1485 : :
1486 : 120 : dump_shift_choices (ASHIFT, choices[speed_p].splitting_ashift);
1487 : 120 : dump_shift_choices (LSHIFTRT, choices[speed_p].splitting_lshiftrt);
1488 : 120 : dump_shift_choices (ASHIFTRT, choices[speed_p].splitting_ashiftrt);
1489 : 120 : fprintf (dump_file, "\n");
1490 : 120 : }
1491 : :
1492 : : /* Look for registers which are always accessed via word-sized SUBREGs
1493 : : or -if DECOMPOSE_COPIES is true- via copies. Decompose these
1494 : : registers into several word-sized pseudo-registers. */
1495 : :
1496 : : static void
1497 : 1996755 : decompose_multiword_subregs (bool decompose_copies)
1498 : : {
1499 : 1996755 : unsigned int max;
1500 : 1996755 : basic_block bb;
1501 : 1996755 : bool speed_p;
1502 : :
1503 : 1996755 : if (dump_file)
1504 : : {
1505 : 60 : dump_choices (false, "size");
1506 : 60 : dump_choices (true, "speed");
1507 : : }
1508 : :
1509 : : /* Check if this target even has any modes to consider lowering. */
1510 : 1996755 : if (!choices[false].something_to_do && !choices[true].something_to_do)
1511 : : {
1512 : 0 : if (dump_file)
1513 : 0 : fprintf (dump_file, "Nothing to do!\n");
1514 : 0 : return;
1515 : : }
1516 : :
1517 : 1996755 : max = max_reg_num ();
1518 : :
1519 : : /* First see if there are any multi-word pseudo-registers. If there
1520 : : aren't, there is nothing we can do. This should speed up this
1521 : : pass in the normal case, since it should be faster than scanning
1522 : : all the insns. */
1523 : 1996755 : {
1524 : 1996755 : unsigned int i;
1525 : 1996755 : bool useful_modes_seen = false;
1526 : :
1527 : 73816778 : for (i = FIRST_PSEUDO_REGISTER; i < max; ++i)
1528 : 72140407 : if (regno_reg_rtx[i] != NULL)
1529 : : {
1530 : 72047973 : machine_mode mode = GET_MODE (regno_reg_rtx[i]);
1531 : 72047973 : if (choices[false].move_modes_to_split[(int) mode]
1532 : 71727589 : || choices[true].move_modes_to_split[(int) mode])
1533 : : {
1534 : : useful_modes_seen = true;
1535 : : break;
1536 : : }
1537 : : }
1538 : :
1539 : 1996755 : if (!useful_modes_seen)
1540 : : {
1541 : 1676371 : if (dump_file)
1542 : 60 : fprintf (dump_file, "Nothing to lower in this function.\n");
1543 : 1676371 : return;
1544 : : }
1545 : : }
1546 : :
1547 : 320384 : if (df)
1548 : : {
1549 : 142643 : df_set_flags (DF_DEFER_INSN_RESCAN);
1550 : 142643 : run_word_dce ();
1551 : : }
1552 : :
1553 : : /* FIXME: It may be possible to change this code to look for each
1554 : : multi-word pseudo-register and to find each insn which sets or
1555 : : uses that register. That should be faster than scanning all the
1556 : : insns. */
1557 : :
1558 : 320384 : decomposable_context = BITMAP_ALLOC (NULL);
1559 : 320384 : non_decomposable_context = BITMAP_ALLOC (NULL);
1560 : 320384 : subreg_context = BITMAP_ALLOC (NULL);
1561 : :
1562 : 320384 : reg_copy_graph.create (max);
1563 : 320384 : reg_copy_graph.safe_grow_cleared (max, true);
1564 : 320384 : memset (reg_copy_graph.address (), 0, sizeof (bitmap) * max);
1565 : :
1566 : 320384 : speed_p = optimize_function_for_speed_p (cfun);
1567 : 8084881 : FOR_EACH_BB_FN (bb, cfun)
1568 : : {
1569 : 7764497 : rtx_insn *insn;
1570 : :
1571 : 99325347 : FOR_BB_INSNS (bb, insn)
1572 : : {
1573 : 91560850 : rtx set;
1574 : 91560850 : enum classify_move_insn cmi;
1575 : 91560850 : int i, n;
1576 : :
1577 : 105094360 : if (!INSN_P (insn)
1578 : 78350438 : || GET_CODE (PATTERN (insn)) == CLOBBER
1579 : 169781081 : || GET_CODE (PATTERN (insn)) == USE)
1580 : 13568447 : continue;
1581 : :
1582 : 78027340 : recog_memoized (insn);
1583 : :
1584 : 78027340 : if (find_decomposable_shift_zext (insn, speed_p))
1585 : 34937 : continue;
1586 : :
1587 : 77992403 : extract_insn (insn);
1588 : :
1589 : 77992403 : set = simple_move (insn, speed_p);
1590 : :
1591 : 77992403 : if (!set)
1592 : 75287811 : cmi = NOT_SIMPLE_MOVE;
1593 : : else
1594 : : {
1595 : : /* We mark pseudo-to-pseudo copies as decomposable during the
1596 : : second pass only. The first pass is so early that there is
1597 : : good chance such moves will be optimized away completely by
1598 : : subsequent optimizations anyway.
1599 : :
1600 : : However, we call find_pseudo_copy even during the first pass
1601 : : so as to properly set up the reg_copy_graph. */
1602 : 2704592 : if (find_pseudo_copy (set))
1603 : 253775 : cmi = decompose_copies? DECOMPOSABLE_SIMPLE_MOVE : SIMPLE_MOVE;
1604 : : else
1605 : 2573892 : cmi = SIMPLE_MOVE;
1606 : : }
1607 : :
1608 : 77992403 : n = recog_data.n_operands;
1609 : 180274006 : for (i = 0; i < n; ++i)
1610 : : {
1611 : 102281603 : find_decomposable_subregs (&recog_data.operand[i], &cmi);
1612 : :
1613 : : /* We handle ASM_OPERANDS as a special case to support
1614 : : things like x86 rdtsc which returns a DImode value.
1615 : : We can decompose the output, which will certainly be
1616 : : operand 0, but not the inputs. */
1617 : :
1618 : 102281603 : if (cmi == SIMPLE_MOVE
1619 : 5393934 : && GET_CODE (SET_SRC (set)) == ASM_OPERANDS)
1620 : : {
1621 : 0 : gcc_assert (i == 0);
1622 : 0 : cmi = NOT_SIMPLE_MOVE;
1623 : : }
1624 : : }
1625 : : }
1626 : : }
1627 : :
1628 : 320384 : bitmap_and_compl_into (decomposable_context, non_decomposable_context);
1629 : 320384 : if (!bitmap_empty_p (decomposable_context))
1630 : : {
1631 : 109990 : unsigned int i;
1632 : 109990 : sbitmap_iterator sbi;
1633 : 109990 : bitmap_iterator iter;
1634 : 109990 : unsigned int regno;
1635 : :
1636 : 109990 : propagate_pseudo_copies ();
1637 : :
1638 : 109990 : auto_sbitmap sub_blocks (last_basic_block_for_fn (cfun));
1639 : 109990 : bitmap_clear (sub_blocks);
1640 : :
1641 : 404966 : EXECUTE_IF_SET_IN_BITMAP (decomposable_context, 0, regno, iter)
1642 : 294976 : decompose_register (regno);
1643 : :
1644 : 3897365 : FOR_EACH_BB_FN (bb, cfun)
1645 : : {
1646 : 3787375 : rtx_insn *insn;
1647 : :
1648 : 44502052 : FOR_BB_INSNS (bb, insn)
1649 : : {
1650 : 40714677 : rtx pat;
1651 : :
1652 : 40714677 : if (!INSN_P (insn))
1653 : 6132506 : continue;
1654 : :
1655 : 34582171 : pat = PATTERN (insn);
1656 : 34582171 : if (GET_CODE (pat) == CLOBBER)
1657 : 151080 : resolve_clobber (pat, insn);
1658 : 34431091 : else if (GET_CODE (pat) == USE)
1659 : 66727 : resolve_use (pat, insn);
1660 : 34364364 : else if (DEBUG_INSN_P (insn))
1661 : 11518608 : resolve_debug (insn);
1662 : : else
1663 : : {
1664 : 22845756 : rtx set;
1665 : 22845756 : int i;
1666 : :
1667 : 22845756 : recog_memoized (insn);
1668 : 22845756 : extract_insn (insn);
1669 : :
1670 : 22845756 : set = simple_move (insn, speed_p);
1671 : 22845756 : if (set)
1672 : : {
1673 : 1586110 : rtx_insn *orig_insn = insn;
1674 : 1586110 : bool cfi = control_flow_insn_p (insn);
1675 : :
1676 : : /* We can end up splitting loads to multi-word pseudos
1677 : : into separate loads to machine word size pseudos.
1678 : : When this happens, we first had one load that can
1679 : : throw, and after resolve_simple_move we'll have a
1680 : : bunch of loads (at least two). All those loads may
1681 : : trap if we can have non-call exceptions, so they
1682 : : all will end the current basic block. We split the
1683 : : block after the outer loop over all insns, but we
1684 : : make sure here that we will be able to split the
1685 : : basic block and still produce the correct control
1686 : : flow graph for it. */
1687 : 1586110 : gcc_assert (!cfi
1688 : : || (cfun->can_throw_non_call_exceptions
1689 : : && can_throw_internal (insn)));
1690 : :
1691 : 1586110 : insn = resolve_simple_move (set, insn);
1692 : 1586110 : if (insn != orig_insn)
1693 : : {
1694 : 239435 : recog_memoized (insn);
1695 : 239435 : extract_insn (insn);
1696 : :
1697 : 239435 : if (cfi)
1698 : 6718 : bitmap_set_bit (sub_blocks, bb->index);
1699 : : }
1700 : : }
1701 : : else
1702 : : {
1703 : 21259646 : rtx_insn *decomposed_shift;
1704 : :
1705 : 21259646 : decomposed_shift = resolve_shift_zext (insn, speed_p);
1706 : 21259646 : if (decomposed_shift != NULL_RTX)
1707 : : {
1708 : 11725 : insn = decomposed_shift;
1709 : 11725 : recog_memoized (insn);
1710 : 11725 : extract_insn (insn);
1711 : : }
1712 : : }
1713 : :
1714 : 73142811 : for (i = recog_data.n_operands - 1; i >= 0; --i)
1715 : 50297055 : resolve_subreg_use (recog_data.operand_loc[i], insn);
1716 : :
1717 : 22845756 : resolve_reg_notes (insn);
1718 : :
1719 : 22845756 : if (num_validated_changes () > 0)
1720 : : {
1721 : 769143 : for (i = recog_data.n_dups - 1; i >= 0; --i)
1722 : : {
1723 : 8547 : rtx *pl = recog_data.dup_loc[i];
1724 : 8547 : int dup_num = recog_data.dup_num[i];
1725 : 8547 : rtx *px = recog_data.operand_loc[dup_num];
1726 : :
1727 : 8547 : validate_unshare_change (insn, pl, *px, 1);
1728 : : }
1729 : :
1730 : 760596 : i = apply_change_group ();
1731 : 760596 : gcc_assert (i);
1732 : : }
1733 : : }
1734 : : }
1735 : : }
1736 : :
1737 : : /* If we had insns to split that caused control flow insns in the middle
1738 : : of a basic block, split those blocks now. Note that we only handle
1739 : : the case where splitting a load has caused multiple possibly trapping
1740 : : loads to appear. */
1741 : 226698 : EXECUTE_IF_SET_IN_BITMAP (sub_blocks, 0, i, sbi)
1742 : : {
1743 : 6718 : rtx_insn *insn, *end;
1744 : 6718 : edge fallthru;
1745 : :
1746 : 6718 : bb = BASIC_BLOCK_FOR_FN (cfun, i);
1747 : 6718 : insn = BB_HEAD (bb);
1748 : 6718 : end = BB_END (bb);
1749 : :
1750 : 39613 : while (insn != end)
1751 : : {
1752 : 32895 : if (control_flow_insn_p (insn))
1753 : : {
1754 : : /* Split the block after insn. There will be a fallthru
1755 : : edge, which is OK so we keep it. We have to create the
1756 : : exception edges ourselves. */
1757 : 6864 : fallthru = split_block (bb, insn);
1758 : 6864 : rtl_make_eh_edge (NULL, bb, BB_END (bb));
1759 : 6864 : bb = fallthru->dest;
1760 : 6864 : insn = BB_HEAD (bb);
1761 : : }
1762 : : else
1763 : 26031 : insn = NEXT_INSN (insn);
1764 : : }
1765 : : }
1766 : 109990 : }
1767 : :
1768 : 59138985 : for (bitmap b : reg_copy_graph)
1769 : 58177833 : if (b)
1770 : 128284 : BITMAP_FREE (b);
1771 : :
1772 : 320384 : reg_copy_graph.release ();
1773 : :
1774 : 320384 : BITMAP_FREE (decomposable_context);
1775 : 320384 : BITMAP_FREE (non_decomposable_context);
1776 : 320384 : BITMAP_FREE (subreg_context);
1777 : : }
1778 : :
1779 : : /* Implement first lower subreg pass. */
1780 : :
1781 : : namespace {
1782 : :
1783 : : const pass_data pass_data_lower_subreg =
1784 : : {
1785 : : RTL_PASS, /* type */
1786 : : "subreg1", /* name */
1787 : : OPTGROUP_NONE, /* optinfo_flags */
1788 : : TV_LOWER_SUBREG, /* tv_id */
1789 : : 0, /* properties_required */
1790 : : 0, /* properties_provided */
1791 : : 0, /* properties_destroyed */
1792 : : 0, /* todo_flags_start */
1793 : : 0, /* todo_flags_finish */
1794 : : };
1795 : :
1796 : : class pass_lower_subreg : public rtl_opt_pass
1797 : : {
1798 : : public:
1799 : 280114 : pass_lower_subreg (gcc::context *ctxt)
1800 : 560228 : : rtl_opt_pass (pass_data_lower_subreg, ctxt)
1801 : : {}
1802 : :
1803 : : /* opt_pass methods: */
1804 : 1415668 : bool gate (function *) final override { return flag_split_wide_types != 0; }
1805 : 998377 : unsigned int execute (function *) final override
1806 : : {
1807 : 998377 : decompose_multiword_subregs (false);
1808 : 998377 : return 0;
1809 : : }
1810 : :
1811 : : }; // class pass_lower_subreg
1812 : :
1813 : : } // anon namespace
1814 : :
1815 : : rtl_opt_pass *
1816 : 280114 : make_pass_lower_subreg (gcc::context *ctxt)
1817 : : {
1818 : 280114 : return new pass_lower_subreg (ctxt);
1819 : : }
1820 : :
1821 : : /* Implement second lower subreg pass. */
1822 : :
1823 : : namespace {
1824 : :
1825 : : const pass_data pass_data_lower_subreg2 =
1826 : : {
1827 : : RTL_PASS, /* type */
1828 : : "subreg2", /* name */
1829 : : OPTGROUP_NONE, /* optinfo_flags */
1830 : : TV_LOWER_SUBREG, /* tv_id */
1831 : : 0, /* properties_required */
1832 : : 0, /* properties_provided */
1833 : : 0, /* properties_destroyed */
1834 : : 0, /* todo_flags_start */
1835 : : TODO_df_finish, /* todo_flags_finish */
1836 : : };
1837 : :
1838 : : class pass_lower_subreg2 : public rtl_opt_pass
1839 : : {
1840 : : public:
1841 : 280114 : pass_lower_subreg2 (gcc::context *ctxt)
1842 : 560228 : : rtl_opt_pass (pass_data_lower_subreg2, ctxt)
1843 : : {}
1844 : :
1845 : : /* opt_pass methods: */
1846 : 1415668 : bool gate (function *) final override
1847 : : {
1848 : 1415668 : return flag_split_wide_types && flag_split_wide_types_early;
1849 : : }
1850 : 0 : unsigned int execute (function *) final override
1851 : : {
1852 : 0 : decompose_multiword_subregs (true);
1853 : 0 : return 0;
1854 : : }
1855 : :
1856 : : }; // class pass_lower_subreg2
1857 : :
1858 : : } // anon namespace
1859 : :
1860 : : rtl_opt_pass *
1861 : 280114 : make_pass_lower_subreg2 (gcc::context *ctxt)
1862 : : {
1863 : 280114 : return new pass_lower_subreg2 (ctxt);
1864 : : }
1865 : :
1866 : : /* Implement third lower subreg pass. */
1867 : :
1868 : : namespace {
1869 : :
1870 : : const pass_data pass_data_lower_subreg3 =
1871 : : {
1872 : : RTL_PASS, /* type */
1873 : : "subreg3", /* name */
1874 : : OPTGROUP_NONE, /* optinfo_flags */
1875 : : TV_LOWER_SUBREG, /* tv_id */
1876 : : 0, /* properties_required */
1877 : : 0, /* properties_provided */
1878 : : 0, /* properties_destroyed */
1879 : : 0, /* todo_flags_start */
1880 : : TODO_df_finish, /* todo_flags_finish */
1881 : : };
1882 : :
1883 : : class pass_lower_subreg3 : public rtl_opt_pass
1884 : : {
1885 : : public:
1886 : 280114 : pass_lower_subreg3 (gcc::context *ctxt)
1887 : 560228 : : rtl_opt_pass (pass_data_lower_subreg3, ctxt)
1888 : : {}
1889 : :
1890 : : /* opt_pass methods: */
1891 : 1415668 : bool gate (function *) final override { return flag_split_wide_types; }
1892 : 998378 : unsigned int execute (function *) final override
1893 : : {
1894 : 998378 : decompose_multiword_subregs (true);
1895 : 998378 : return 0;
1896 : : }
1897 : :
1898 : : }; // class pass_lower_subreg3
1899 : :
1900 : : } // anon namespace
1901 : :
1902 : : rtl_opt_pass *
1903 : 280114 : make_pass_lower_subreg3 (gcc::context *ctxt)
1904 : : {
1905 : 280114 : return new pass_lower_subreg3 (ctxt);
1906 : : }
|
