Branch data Line data Source code
1 : : /* Build live ranges for pseudos.
2 : : Copyright (C) 2010-2024 Free Software Foundation, Inc.
3 : : Contributed by Vladimir Makarov <vmakarov@redhat.com>.
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify it under
8 : : the terms of the GNU General Public License as published by the Free
9 : : Software Foundation; either version 3, or (at your option) any later
10 : : version.
11 : :
12 : : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 : : WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 : : for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : :
22 : : /* This file contains code to build pseudo live-ranges (analogous
23 : : structures used in IRA, so read comments about the live-ranges
24 : : there) and other info necessary for other passes to assign
25 : : hard-registers to pseudos, coalesce the spilled pseudos, and assign
26 : : stack memory slots to spilled pseudos. */
27 : :
28 : : #include "config.h"
29 : : #include "system.h"
30 : : #include "coretypes.h"
31 : : #include "backend.h"
32 : : #include "rtl.h"
33 : : #include "tree.h"
34 : : #include "predict.h"
35 : : #include "df.h"
36 : : #include "memmodel.h"
37 : : #include "tm_p.h"
38 : : #include "insn-config.h"
39 : : #include "regs.h"
40 : : #include "ira.h"
41 : : #include "ira-int.h"
42 : : #include "recog.h"
43 : : #include "cfganal.h"
44 : : #include "sparseset.h"
45 : : #include "lra-int.h"
46 : : #include "target.h"
47 : : #include "function-abi.h"
48 : :
49 : : /* Program points are enumerated by numbers from range
50 : : 0..LRA_LIVE_MAX_POINT-1. There are approximately two times more
51 : : program points than insns. Program points are places in the
52 : : program where liveness info can be changed. In most general case
53 : : (there are more complicated cases too) some program points
54 : : correspond to places where input operand dies and other ones
55 : : correspond to places where output operands are born. */
56 : : int lra_live_max_point;
57 : :
58 : : /* Accumulated execution frequency of all references for each hard
59 : : register. */
60 : : int lra_hard_reg_usage[FIRST_PSEUDO_REGISTER];
61 : :
62 : : /* A global flag whose true value says to build live ranges for all
63 : : pseudos, otherwise the live ranges only for pseudos got memory is
64 : : build. True value means also building copies and setting up hard
65 : : register preferences. The complete info is necessary for
66 : : assignment, rematerialization and spill to register passes. The
67 : : complete info is not needed for the coalescing and spill to memory
68 : : passes. */
69 : : static bool complete_info_p;
70 : :
71 : : /* Pseudos live at current point in the RTL scan. */
72 : : static sparseset pseudos_live;
73 : :
74 : : /* Pseudos probably living through calls and setjumps. As setjump is
75 : : a call too, if a bit in PSEUDOS_LIVE_THROUGH_SETJUMPS is set up
76 : : then the corresponding bit in PSEUDOS_LIVE_THROUGH_CALLS is set up
77 : : too. These data are necessary for cases when only one subreg of a
78 : : multi-reg pseudo is set up after a call. So we decide it is
79 : : probably live when traversing bb backward. We are sure about
80 : : living when we see its usage or definition of the pseudo. */
81 : : static sparseset pseudos_live_through_calls;
82 : : static sparseset pseudos_live_through_setjumps;
83 : :
84 : : /* Set of hard regs (except eliminable ones) currently live. */
85 : : static HARD_REG_SET hard_regs_live;
86 : :
87 : : /* Set of pseudos and hard registers start living/dying in the current
88 : : insn. These sets are used to update REG_DEAD and REG_UNUSED notes
89 : : in the insn. */
90 : : static sparseset start_living, start_dying;
91 : :
92 : : /* Set of pseudos and hard regs dead and unused in the current
93 : : insn. */
94 : : static sparseset unused_set, dead_set;
95 : :
96 : : /* Bitmap used for holding intermediate bitmap operation results. */
97 : : static bitmap_head temp_bitmap;
98 : :
99 : : /* Pool for pseudo live ranges. */
100 : : static object_allocator<lra_live_range> lra_live_range_pool ("live ranges");
101 : :
102 : : /* Free live range list LR. */
103 : : static void
104 : 309065393 : free_live_range_list (lra_live_range_t lr)
105 : : {
106 : 309065393 : lra_live_range_t next;
107 : :
108 : 404774636 : while (lr != NULL)
109 : : {
110 : 95709243 : next = lr->next;
111 : 95709243 : lra_live_range_pool.remove (lr);
112 : 95709243 : lr = next;
113 : : }
114 : 309065393 : }
115 : :
116 : : /* Create and return pseudo live range with given attributes. */
117 : : static lra_live_range_t
118 : 105935154 : create_live_range (int regno, int start, int finish, lra_live_range_t next)
119 : : {
120 : 0 : lra_live_range_t p = lra_live_range_pool.allocate ();
121 : 105935154 : p->regno = regno;
122 : 105935154 : p->start = start;
123 : 105935154 : p->finish = finish;
124 : 105935154 : p->next = next;
125 : 105935154 : return p;
126 : : }
127 : :
128 : : /* Copy live range R and return the result. */
129 : : static lra_live_range_t
130 : 2095442 : copy_live_range (lra_live_range_t r)
131 : : {
132 : 2095442 : return new (lra_live_range_pool) lra_live_range (*r);
133 : : }
134 : :
135 : : /* Copy live range list given by its head R and return the result. */
136 : : lra_live_range_t
137 : 1422890 : lra_copy_live_range_list (lra_live_range_t r)
138 : : {
139 : 1422890 : lra_live_range_t p, first, *chain;
140 : :
141 : 1422890 : first = NULL;
142 : 3518332 : for (chain = &first; r != NULL; r = r->next)
143 : : {
144 : 2095442 : p = copy_live_range (r);
145 : 2095442 : *chain = p;
146 : 2095442 : chain = &p->next;
147 : : }
148 : 1422890 : return first;
149 : : }
150 : :
151 : : /* Merge *non-intersected* ranges R1 and R2 and returns the result.
152 : : The function maintains the order of ranges and tries to minimize
153 : : size of the result range list. Ranges R1 and R2 may not be used
154 : : after the call. */
155 : : lra_live_range_t
156 : 1422890 : lra_merge_live_ranges (lra_live_range_t r1, lra_live_range_t r2)
157 : : {
158 : 1422890 : lra_live_range_t first, last;
159 : :
160 : 1422890 : if (r1 == NULL)
161 : : return r2;
162 : 654877 : if (r2 == NULL)
163 : : return r1;
164 : 5938123 : for (first = last = NULL; r1 != NULL && r2 != NULL;)
165 : : {
166 : 5283246 : if (r1->start < r2->start)
167 : 399523 : std::swap (r1, r2);
168 : :
169 : 5283246 : if (r1->start == r2->finish + 1)
170 : : {
171 : : /* Joint ranges: merge r1 and r2 into r1. */
172 : 41716 : r1->start = r2->start;
173 : 41716 : lra_live_range_t temp = r2;
174 : 41716 : r2 = r2->next;
175 : 41716 : lra_live_range_pool.remove (temp);
176 : : }
177 : : else
178 : : {
179 : 5241530 : gcc_assert (r2->finish + 1 < r1->start);
180 : : /* Add r1 to the result. */
181 : 5241530 : if (first == NULL)
182 : : first = last = r1;
183 : : else
184 : : {
185 : 4591075 : last->next = r1;
186 : 4591075 : last = r1;
187 : : }
188 : 5241530 : r1 = r1->next;
189 : : }
190 : : }
191 : 654877 : if (r1 != NULL)
192 : : {
193 : 15570 : if (first == NULL)
194 : : first = r1;
195 : : else
196 : 11148 : last->next = r1;
197 : : }
198 : : else
199 : : {
200 : 639307 : lra_assert (r2 != NULL);
201 : 639307 : if (first == NULL)
202 : : first = r2;
203 : : else
204 : 639307 : last->next = r2;
205 : : }
206 : : return first;
207 : : }
208 : :
209 : : /* Return TRUE if live ranges R1 and R2 intersect. */
210 : : bool
211 : 25637402 : lra_intersected_live_ranges_p (lra_live_range_t r1, lra_live_range_t r2)
212 : : {
213 : : /* Remember the live ranges are always kept ordered. */
214 : 41691144 : while (r1 != NULL && r2 != NULL)
215 : : {
216 : 41034182 : if (r1->start > r2->finish)
217 : 14771908 : r1 = r1->next;
218 : 26262274 : else if (r2->start > r1->finish)
219 : 1281834 : r2 = r2->next;
220 : : else
221 : : return true;
222 : : }
223 : : return false;
224 : : }
225 : :
226 : : enum point_type {
227 : : DEF_POINT,
228 : : USE_POINT
229 : : };
230 : :
231 : : /* Return TRUE if set A contains a pseudo register, otherwise, return FALSE. */
232 : : static bool
233 : 745700132 : sparseset_contains_pseudos_p (sparseset a)
234 : : {
235 : 745700132 : int regno;
236 : 878012651 : EXECUTE_IF_SET_IN_SPARSESET (a, regno)
237 : 321613603 : if (!HARD_REGISTER_NUM_P (regno))
238 : : return true;
239 : : return false;
240 : : }
241 : :
242 : : /* Mark pseudo REGNO as living or dying at program point POINT, depending on
243 : : whether TYPE is a definition or a use. If this is the first reference to
244 : : REGNO that we've encountered, then create a new live range for it. */
245 : :
246 : : static void
247 : 1222435210 : update_pseudo_point (int regno, int point, enum point_type type)
248 : : {
249 : 1222435210 : lra_live_range_t p;
250 : :
251 : : /* Don't compute points for hard registers. */
252 : 1222435210 : if (HARD_REGISTER_NUM_P (regno))
253 : : return;
254 : :
255 : 1119498099 : if (complete_info_p || lra_get_regno_hard_regno (regno) < 0)
256 : : {
257 : 1104123343 : if (type == DEF_POINT)
258 : : {
259 : 476870096 : if (sparseset_bit_p (pseudos_live, regno))
260 : : {
261 : 476870096 : p = lra_reg_info[regno].live_ranges;
262 : 476870096 : lra_assert (p != NULL);
263 : 476870096 : p->finish = point;
264 : : }
265 : : }
266 : : else /* USE_POINT */
267 : : {
268 : 627253247 : if (!sparseset_bit_p (pseudos_live, regno)
269 : 627253247 : && ((p = lra_reg_info[regno].live_ranges) == NULL
270 : 392513254 : || (p->finish != point && p->finish + 1 != point)))
271 : 105935154 : lra_reg_info[regno].live_ranges
272 : 105935154 : = create_live_range (regno, point, -1, p);
273 : : }
274 : : }
275 : : }
276 : :
277 : : /* The corresponding bitmaps of BB currently being processed. */
278 : : static bitmap bb_killed_pseudos, bb_gen_pseudos;
279 : :
280 : : /* Record hard register REGNO as now being live. It updates
281 : : living hard regs and START_LIVING. */
282 : : static void
283 : 220781890 : make_hard_regno_live (int regno)
284 : : {
285 : 220781890 : lra_assert (HARD_REGISTER_NUM_P (regno));
286 : 220781890 : if (TEST_HARD_REG_BIT (hard_regs_live, regno)
287 : 220781890 : || TEST_HARD_REG_BIT (eliminable_regset, regno))
288 : : return;
289 : 123912573 : SET_HARD_REG_BIT (hard_regs_live, regno);
290 : 123912573 : sparseset_set_bit (start_living, regno);
291 : 123912573 : if (fixed_regs[regno] || TEST_HARD_REG_BIT (hard_regs_spilled_into, regno))
292 : 72476161 : bitmap_set_bit (bb_gen_pseudos, regno);
293 : : }
294 : :
295 : : /* Process the definition of hard register REGNO. This updates
296 : : hard_regs_live, START_DYING and conflict hard regs for living
297 : : pseudos. */
298 : : static void
299 : 122298504 : make_hard_regno_dead (int regno)
300 : : {
301 : 122298504 : if (TEST_HARD_REG_BIT (eliminable_regset, regno))
302 : : return;
303 : :
304 : 122297600 : lra_assert (HARD_REGISTER_NUM_P (regno));
305 : 122297600 : unsigned int i;
306 : 1301886465 : EXECUTE_IF_SET_IN_SPARSESET (pseudos_live, i)
307 : 1179588865 : SET_HARD_REG_BIT (lra_reg_info[i].conflict_hard_regs, regno);
308 : :
309 : 122297600 : if (! TEST_HARD_REG_BIT (hard_regs_live, regno))
310 : : return;
311 : 122296871 : CLEAR_HARD_REG_BIT (hard_regs_live, regno);
312 : 122296871 : sparseset_set_bit (start_dying, regno);
313 : 122296871 : if (fixed_regs[regno] || TEST_HARD_REG_BIT (hard_regs_spilled_into, regno))
314 : : {
315 : 72476202 : bitmap_clear_bit (bb_gen_pseudos, regno);
316 : 72476202 : bitmap_set_bit (bb_killed_pseudos, regno);
317 : : }
318 : : }
319 : :
320 : : /* Mark pseudo REGNO as now being live and update START_LIVING. */
321 : : static void
322 : 638254299 : mark_pseudo_live (int regno)
323 : : {
324 : 638254299 : lra_assert (!HARD_REGISTER_NUM_P (regno));
325 : 638254299 : if (sparseset_bit_p (pseudos_live, regno))
326 : : return;
327 : :
328 : 486660151 : sparseset_set_bit (pseudos_live, regno);
329 : 486660151 : sparseset_set_bit (start_living, regno);
330 : : }
331 : :
332 : : /* Mark pseudo REGNO as now being dead and update START_DYING. */
333 : : static void
334 : 486660151 : mark_pseudo_dead (int regno)
335 : : {
336 : 486660151 : lra_assert (!HARD_REGISTER_NUM_P (regno));
337 : 486660151 : lra_reg_info[regno].conflict_hard_regs |= hard_regs_live;
338 : 486660151 : if (!sparseset_bit_p (pseudos_live, regno))
339 : : return;
340 : :
341 : 486660151 : sparseset_clear_bit (pseudos_live, regno);
342 : 486660151 : sparseset_set_bit (start_dying, regno);
343 : : }
344 : :
345 : : /* Mark register REGNO (pseudo or hard register) in MODE as being live
346 : : and update BB_GEN_PSEUDOS. */
347 : : static void
348 : 350654145 : mark_regno_live (int regno, machine_mode mode)
349 : : {
350 : 350654145 : int last;
351 : :
352 : 350654145 : if (HARD_REGISTER_NUM_P (regno))
353 : : {
354 : 199728056 : for (last = end_hard_regno (mode, regno); regno < last; regno++)
355 : 100155309 : make_hard_regno_live (regno);
356 : : }
357 : : else
358 : : {
359 : 251081398 : mark_pseudo_live (regno);
360 : 251081398 : bitmap_set_bit (bb_gen_pseudos, regno);
361 : : }
362 : 350654145 : }
363 : :
364 : :
365 : : /* Mark register REGNO (pseudo or hard register) in MODE as being dead
366 : : and update BB_GEN_PSEUDOS and BB_KILLED_PSEUDOS. */
367 : : static void
368 : 143772341 : mark_regno_dead (int regno, machine_mode mode)
369 : : {
370 : 143772341 : int last;
371 : :
372 : 143772341 : if (HARD_REGISTER_NUM_P (regno))
373 : : {
374 : 73727501 : for (last = end_hard_regno (mode, regno); regno < last; regno++)
375 : 37090021 : make_hard_regno_dead (regno);
376 : : }
377 : : else
378 : : {
379 : 107134861 : mark_pseudo_dead (regno);
380 : 107134861 : bitmap_clear_bit (bb_gen_pseudos, regno);
381 : 107134861 : bitmap_set_bit (bb_killed_pseudos, regno);
382 : : }
383 : 143772341 : }
384 : :
385 : :
386 : :
387 : : /* This page contains code for making global live analysis of pseudos.
388 : : The code works only when pseudo live info is changed on a BB
389 : : border. That might be a consequence of some global transformations
390 : : in LRA, e.g. PIC pseudo reuse or rematerialization. */
391 : :
392 : : /* Structure describing local BB data used for pseudo
393 : : live-analysis. */
394 : : class bb_data_pseudos
395 : : {
396 : : public:
397 : : /* Basic block about which the below data are. */
398 : : basic_block bb;
399 : : bitmap_head killed_pseudos; /* pseudos killed in the BB. */
400 : : bitmap_head gen_pseudos; /* pseudos generated in the BB. */
401 : : };
402 : :
403 : : /* Array for all BB data. Indexed by the corresponding BB index. */
404 : : typedef class bb_data_pseudos *bb_data_t;
405 : :
406 : : /* All basic block data are referred through the following array. */
407 : : static bb_data_t bb_data;
408 : :
409 : : /* Two small functions for access to the bb data. */
410 : : static inline bb_data_t
411 : 70194116 : get_bb_data (basic_block bb)
412 : : {
413 : 70194116 : return &bb_data[(bb)->index];
414 : : }
415 : :
416 : : static inline bb_data_t
417 : 7468840 : get_bb_data_by_index (int index)
418 : : {
419 : 7468840 : return &bb_data[index];
420 : : }
421 : :
422 : : /* Bitmap with all hard regs. */
423 : : static bitmap_head all_hard_regs_bitmap;
424 : :
425 : : /* The transfer function used by the DF equation solver to propagate
426 : : live info through block with BB_INDEX according to the following
427 : : equation:
428 : :
429 : : bb.livein = (bb.liveout - bb.kill) OR bb.gen
430 : : */
431 : : static bool
432 : 7468840 : live_trans_fun (int bb_index)
433 : : {
434 : 7468840 : basic_block bb = get_bb_data_by_index (bb_index)->bb;
435 : 7468840 : bitmap bb_liveout = df_get_live_out (bb);
436 : 7468840 : bitmap bb_livein = df_get_live_in (bb);
437 : 7468840 : bb_data_t bb_info = get_bb_data (bb);
438 : :
439 : 7468840 : bitmap_and_compl (&temp_bitmap, bb_liveout, &all_hard_regs_bitmap);
440 : 7468840 : return bitmap_ior_and_compl (bb_livein, &bb_info->gen_pseudos,
441 : 7468840 : &temp_bitmap, &bb_info->killed_pseudos);
442 : : }
443 : :
444 : : /* The confluence function used by the DF equation solver to set up
445 : : live info for a block BB without predecessor. */
446 : : static void
447 : 329635 : live_con_fun_0 (basic_block bb)
448 : : {
449 : 329635 : bitmap_and_into (df_get_live_out (bb), &all_hard_regs_bitmap);
450 : 329635 : }
451 : :
452 : : /* The confluence function used by the DF equation solver to propagate
453 : : live info from successor to predecessor on edge E according to the
454 : : following equation:
455 : :
456 : : bb.liveout = 0 for entry block | OR (livein of successors)
457 : : */
458 : : static bool
459 : 10849056 : live_con_fun_n (edge e)
460 : : {
461 : 10849056 : basic_block bb = e->src;
462 : 10849056 : basic_block dest = e->dest;
463 : 10849056 : bitmap bb_liveout = df_get_live_out (bb);
464 : 10849056 : bitmap dest_livein = df_get_live_in (dest);
465 : :
466 : 10849056 : return bitmap_ior_and_compl_into (bb_liveout,
467 : 10849056 : dest_livein, &all_hard_regs_bitmap);
468 : : }
469 : :
470 : : /* Indexes of all function blocks. */
471 : : static bitmap_head all_blocks;
472 : :
473 : : /* Allocate and initialize data needed for global pseudo live
474 : : analysis. */
475 : : static void
476 : 1415660 : initiate_live_solver (void)
477 : : {
478 : 1415660 : bitmap_initialize (&all_hard_regs_bitmap, ®_obstack);
479 : 1415660 : bitmap_set_range (&all_hard_regs_bitmap, 0, FIRST_PSEUDO_REGISTER);
480 : 1415660 : bb_data = XNEWVEC (class bb_data_pseudos, last_basic_block_for_fn (cfun));
481 : 1415660 : bitmap_initialize (&all_blocks, ®_obstack);
482 : :
483 : 1415660 : basic_block bb;
484 : 17808154 : FOR_ALL_BB_FN (bb, cfun)
485 : : {
486 : 16392494 : bb_data_t bb_info = get_bb_data (bb);
487 : 16392494 : bb_info->bb = bb;
488 : 16392494 : bitmap_initialize (&bb_info->killed_pseudos, ®_obstack);
489 : 16392494 : bitmap_initialize (&bb_info->gen_pseudos, ®_obstack);
490 : 16392494 : bitmap_set_bit (&all_blocks, bb->index);
491 : : }
492 : 1415660 : }
493 : :
494 : : /* Free all data needed for global pseudo live analysis. */
495 : : static void
496 : 1415660 : finish_live_solver (void)
497 : : {
498 : 1415660 : basic_block bb;
499 : :
500 : 1415660 : bitmap_clear (&all_blocks);
501 : 17808154 : FOR_ALL_BB_FN (bb, cfun)
502 : : {
503 : 16392494 : bb_data_t bb_info = get_bb_data (bb);
504 : 16392494 : bitmap_clear (&bb_info->killed_pseudos);
505 : 16392494 : bitmap_clear (&bb_info->gen_pseudos);
506 : : }
507 : 1415660 : free (bb_data);
508 : 1415660 : bitmap_clear (&all_hard_regs_bitmap);
509 : 1415660 : }
510 : :
511 : :
512 : :
513 : : /* Insn currently scanned. */
514 : : static rtx_insn *curr_insn;
515 : : /* The insn data. */
516 : : static lra_insn_recog_data_t curr_id;
517 : : /* The insn static data. */
518 : : static struct lra_static_insn_data *curr_static_id;
519 : :
520 : : /* Vec containing execution frequencies of program points. */
521 : : static vec<int> point_freq_vec;
522 : :
523 : : /* The start of the above vector elements. */
524 : : int *lra_point_freq;
525 : :
526 : : /* Increment the current program point POINT to the next point which has
527 : : execution frequency FREQ. */
528 : : static void
529 : 213251270 : next_program_point (int &point, int freq)
530 : : {
531 : 213251270 : point_freq_vec.safe_push (freq);
532 : 213251270 : lra_point_freq = point_freq_vec.address ();
533 : 213251270 : point++;
534 : 213251270 : }
535 : :
536 : : /* Update the preference of HARD_REGNO for pseudo REGNO by PROFIT. */
537 : : void
538 : 15325456 : lra_setup_reload_pseudo_preferenced_hard_reg (int regno,
539 : : int hard_regno, int profit)
540 : : {
541 : 15325456 : lra_assert (regno >= lra_constraint_new_regno_start);
542 : 15325456 : if (lra_reg_info[regno].preferred_hard_regno1 == hard_regno)
543 : 2873625 : lra_reg_info[regno].preferred_hard_regno_profit1 += profit;
544 : 12451831 : else if (lra_reg_info[regno].preferred_hard_regno2 == hard_regno)
545 : 85176 : lra_reg_info[regno].preferred_hard_regno_profit2 += profit;
546 : 12366655 : else if (lra_reg_info[regno].preferred_hard_regno1 < 0)
547 : : {
548 : 9836119 : lra_reg_info[regno].preferred_hard_regno1 = hard_regno;
549 : 9836119 : lra_reg_info[regno].preferred_hard_regno_profit1 = profit;
550 : : }
551 : 2530536 : else if (lra_reg_info[regno].preferred_hard_regno2 < 0
552 : 68518 : || profit > lra_reg_info[regno].preferred_hard_regno_profit2)
553 : : {
554 : 2486328 : lra_reg_info[regno].preferred_hard_regno2 = hard_regno;
555 : 2486328 : lra_reg_info[regno].preferred_hard_regno_profit2 = profit;
556 : : }
557 : : else
558 : : return;
559 : : /* Keep the 1st hard regno as more profitable. */
560 : 15281248 : if (lra_reg_info[regno].preferred_hard_regno1 >= 0
561 : 15281248 : && lra_reg_info[regno].preferred_hard_regno2 >= 0
562 : 2657727 : && (lra_reg_info[regno].preferred_hard_regno_profit2
563 : 2657727 : > lra_reg_info[regno].preferred_hard_regno_profit1))
564 : : {
565 : 107312 : std::swap (lra_reg_info[regno].preferred_hard_regno1,
566 : : lra_reg_info[regno].preferred_hard_regno2);
567 : 107312 : std::swap (lra_reg_info[regno].preferred_hard_regno_profit1,
568 : : lra_reg_info[regno].preferred_hard_regno_profit2);
569 : : }
570 : 15281248 : if (lra_dump_file != NULL)
571 : : {
572 : 268 : if ((hard_regno = lra_reg_info[regno].preferred_hard_regno1) >= 0)
573 : 268 : fprintf (lra_dump_file,
574 : : " Hard reg %d is preferable by r%d with profit %d\n",
575 : : hard_regno, regno,
576 : : lra_reg_info[regno].preferred_hard_regno_profit1);
577 : 268 : if ((hard_regno = lra_reg_info[regno].preferred_hard_regno2) >= 0)
578 : 94 : fprintf (lra_dump_file,
579 : : " Hard reg %d is preferable by r%d with profit %d\n",
580 : : hard_regno, regno,
581 : : lra_reg_info[regno].preferred_hard_regno_profit2);
582 : : }
583 : : }
584 : :
585 : : /* Check whether REGNO lives through calls and setjmps and clear
586 : : the corresponding bits in PSEUDOS_LIVE_THROUGH_CALLS and
587 : : PSEUDOS_LIVE_THROUGH_SETJUMPS. All calls in the region described
588 : : by PSEUDOS_LIVE_THROUGH_CALLS have the given ABI. */
589 : :
590 : : static inline void
591 : 440707878 : check_pseudos_live_through_calls (int regno, const function_abi &abi)
592 : : {
593 : 440707878 : if (! sparseset_bit_p (pseudos_live_through_calls, regno))
594 : : return;
595 : :
596 : 94749584 : machine_mode mode = PSEUDO_REGNO_MODE (regno);
597 : :
598 : 94749584 : sparseset_clear_bit (pseudos_live_through_calls, regno);
599 : 94749584 : lra_reg_info[regno].conflict_hard_regs |= abi.mode_clobbers (mode);
600 : 94749584 : if (! sparseset_bit_p (pseudos_live_through_setjumps, regno))
601 : : return;
602 : 6974 : sparseset_clear_bit (pseudos_live_through_setjumps, regno);
603 : : /* Don't allocate pseudos that cross setjmps or any call, if this
604 : : function receives a nonlocal goto. */
605 : 6974 : SET_HARD_REG_SET (lra_reg_info[regno].conflict_hard_regs);
606 : : }
607 : :
608 : : /* Return true if insn REG is an early clobber operand in alternative
609 : : NALT. Negative NALT means that we don't know the current insn
610 : : alternative. So assume the worst. */
611 : : static inline bool
612 : 366551354 : reg_early_clobber_p (const struct lra_insn_reg *reg, int n_alt)
613 : : {
614 : 366551354 : return (n_alt == LRA_UNKNOWN_ALT
615 : 366551354 : ? reg->early_clobber_alts != 0
616 : : : (n_alt != LRA_NON_CLOBBERED_ALT
617 : 349442186 : && TEST_BIT (reg->early_clobber_alts, n_alt)));
618 : : }
619 : :
620 : : /* Clear pseudo REGNO in SET or all hard registers of REGNO in MODE in SET. */
621 : : static void
622 : 145729420 : clear_sparseset_regnos (sparseset set, int regno, enum machine_mode mode)
623 : : {
624 : 145729420 : if (regno >= FIRST_PSEUDO_REGISTER)
625 : : {
626 : 80607883 : sparseset_clear_bit (dead_set, regno);
627 : 80607883 : return;
628 : : }
629 : 130478041 : for (int last = end_hard_regno (mode, regno); regno < last; regno++)
630 : 65356504 : sparseset_clear_bit (set, regno);
631 : : }
632 : :
633 : : /* Return true if pseudo REGNO is in SET or all hard registers of REGNO in MODE
634 : : are in SET. */
635 : : static bool
636 : 149223842 : regnos_in_sparseset_p (sparseset set, int regno, enum machine_mode mode)
637 : : {
638 : 149223842 : if (regno >= FIRST_PSEUDO_REGISTER)
639 : 83892036 : return sparseset_bit_p (dead_set, regno);
640 : 130688310 : for (int last = end_hard_regno (mode, regno); regno < last; regno++)
641 : 65566773 : if (!sparseset_bit_p (set, regno))
642 : : return false;
643 : : return true;
644 : : }
645 : :
646 : : /* Process insns of the basic block BB to update pseudo live ranges,
647 : : pseudo hard register conflicts, and insn notes. We do it on
648 : : backward scan of BB insns. CURR_POINT is the program point where
649 : : BB ends. The function updates this counter and returns in
650 : : CURR_POINT the program point where BB starts. The function also
651 : : does local live info updates and can delete the dead insns if
652 : : DEAD_INSN_P. It returns true if pseudo live info was
653 : : changed at the BB start. */
654 : : static bool
655 : 29940260 : process_bb_lives (basic_block bb, int &curr_point, bool dead_insn_p)
656 : : {
657 : 29940260 : int i, regno, freq;
658 : 29940260 : unsigned int j;
659 : 29940260 : bitmap_iterator bi;
660 : 29940260 : bitmap reg_live_out;
661 : 29940260 : unsigned int px;
662 : 29940260 : rtx_insn *next;
663 : 29940260 : rtx link, *link_loc;
664 : 29940260 : bool need_curr_point_incr;
665 : : /* Only has a meaningful value once we've seen a call. */
666 : 29940260 : function_abi last_call_abi = default_function_abi;
667 : :
668 : 29940260 : reg_live_out = df_get_live_out (bb);
669 : 29940260 : sparseset_clear (pseudos_live);
670 : 29940260 : sparseset_clear (pseudos_live_through_calls);
671 : 29940260 : sparseset_clear (pseudos_live_through_setjumps);
672 : 59880520 : REG_SET_TO_HARD_REG_SET (hard_regs_live, reg_live_out);
673 : 29940260 : hard_regs_live &= ~eliminable_regset;
674 : 417113161 : EXECUTE_IF_SET_IN_BITMAP (reg_live_out, FIRST_PSEUDO_REGISTER, j, bi)
675 : : {
676 : 387172901 : update_pseudo_point (j, curr_point, USE_POINT);
677 : 387172901 : mark_pseudo_live (j);
678 : : }
679 : :
680 : 29940260 : bb_gen_pseudos = &get_bb_data (bb)->gen_pseudos;
681 : 29940260 : bb_killed_pseudos = &get_bb_data (bb)->killed_pseudos;
682 : 29940260 : bitmap_clear (bb_gen_pseudos);
683 : 29940260 : bitmap_clear (bb_killed_pseudos);
684 : 29940260 : freq = REG_FREQ_FROM_BB (bb);
685 : :
686 : 29940260 : if (lra_dump_file != NULL)
687 : 581 : fprintf (lra_dump_file, " BB %d\n", bb->index);
688 : :
689 : : /* Scan the code of this basic block, noting which pseudos and hard
690 : : regs are born or die.
691 : :
692 : : Note that this loop treats uninitialized values as live until the
693 : : beginning of the block. For example, if an instruction uses
694 : : (reg:DI foo), and only (subreg:SI (reg:DI foo) 0) is ever set,
695 : : FOO will remain live until the beginning of the block. Likewise
696 : : if FOO is not set at all. This is unnecessarily pessimistic, but
697 : : it probably doesn't matter much in practice. */
698 : 818796912 : FOR_BB_INSNS_REVERSE_SAFE (bb, curr_insn, next)
699 : : {
700 : 379458196 : bool call_p;
701 : 379458196 : int n_alt, dst_regno, src_regno;
702 : 379458196 : rtx set;
703 : 379458196 : struct lra_insn_reg *reg;
704 : :
705 : 379458196 : if (!NONDEBUG_INSN_P (curr_insn))
706 : 172079900 : continue;
707 : :
708 : 207378296 : curr_id = lra_get_insn_recog_data (curr_insn);
709 : 207378296 : curr_static_id = curr_id->insn_static_data;
710 : 207378296 : n_alt = curr_id->used_insn_alternative;
711 : 207378296 : if (lra_dump_file != NULL)
712 : 2812 : fprintf (lra_dump_file, " Insn %u: point = %d, n_alt = %d\n",
713 : 2812 : INSN_UID (curr_insn), curr_point, n_alt);
714 : :
715 : 207378296 : set = single_set (curr_insn);
716 : :
717 : 207378296 : if (dead_insn_p && set != NULL_RTX
718 : 160352020 : && REG_P (SET_DEST (set)) && !HARD_REGISTER_P (SET_DEST (set))
719 : 84239345 : && find_reg_note (curr_insn, REG_EH_REGION, NULL_RTX) == NULL_RTX
720 : 83999913 : && ! may_trap_p (PATTERN (curr_insn))
721 : : /* Don't do premature remove of pic offset pseudo as we can
722 : : start to use it after some reload generation. */
723 : 282955369 : && (pic_offset_table_rtx == NULL_RTX
724 : 8909999 : || pic_offset_table_rtx != SET_DEST (set)))
725 : : {
726 : 75509880 : bool remove_p = true;
727 : :
728 : 76062198 : for (reg = curr_id->regs; reg != NULL; reg = reg->next)
729 : 76011241 : if (reg->type != OP_IN
730 : 76011241 : && (reg->regno < FIRST_PSEUDO_REGISTER
731 : 75509969 : ? TEST_HARD_REG_BIT (hard_regs_live, reg->regno)
732 : 75509967 : : sparseset_bit_p (pseudos_live, reg->regno)))
733 : : {
734 : : remove_p = false;
735 : : break;
736 : : }
737 : 76663906 : for (reg = curr_static_id->hard_regs; reg != NULL; reg = reg->next)
738 : 14840390 : if (reg->type != OP_IN)
739 : : {
740 : : remove_p = false;
741 : : break;
742 : : }
743 : :
744 : 75509880 : if (remove_p && ! volatile_refs_p (PATTERN (curr_insn)))
745 : : {
746 : 44015 : dst_regno = REGNO (SET_DEST (set));
747 : 44015 : if (lra_dump_file != NULL)
748 : 0 : fprintf (lra_dump_file, " Deleting dead insn %u\n",
749 : 0 : INSN_UID (curr_insn));
750 : 44015 : lra_set_insn_deleted (curr_insn);
751 : 44015 : if (lra_reg_info[dst_regno].nrefs == 0)
752 : : {
753 : : /* There might be some debug insns with the pseudo. */
754 : 5477 : unsigned int uid;
755 : 5477 : rtx_insn *insn;
756 : :
757 : 5477 : bitmap_copy (&temp_bitmap, &lra_reg_info[dst_regno].insn_bitmap);
758 : 5895 : EXECUTE_IF_SET_IN_BITMAP (&temp_bitmap, 0, uid, bi)
759 : : {
760 : 418 : insn = lra_insn_recog_data[uid]->insn;
761 : 418 : lra_substitute_pseudo_within_insn (insn, dst_regno,
762 : : SET_SRC (set), true);
763 : 418 : lra_update_insn_regno_info (insn);
764 : : }
765 : : }
766 : 44015 : continue;
767 : 44015 : }
768 : : }
769 : :
770 : : /* Update max ref width and hard reg usage. */
771 : 538578907 : for (reg = curr_id->regs; reg != NULL; reg = reg->next)
772 : : {
773 : 331244626 : int regno = reg->regno;
774 : :
775 : 331244626 : lra_update_biggest_mode (regno, reg->biggest_mode);
776 : 331244626 : if (HARD_REGISTER_NUM_P (regno))
777 : 88738707 : lra_hard_reg_usage[regno] += freq;
778 : : }
779 : :
780 : 207334281 : call_p = CALL_P (curr_insn);
781 : :
782 : : /* If we have a simple register copy and the source reg is live after
783 : : this instruction, then remove the source reg from the live set so
784 : : that it will not conflict with the destination reg. */
785 : 207334281 : rtx ignore_reg = non_conflicting_reg_copy_p (curr_insn);
786 : 207334281 : if (ignore_reg != NULL_RTX)
787 : : {
788 : 56596654 : int ignore_regno = REGNO (ignore_reg);
789 : 56596654 : if (HARD_REGISTER_NUM_P (ignore_regno)
790 : 56596654 : && TEST_HARD_REG_BIT (hard_regs_live, ignore_regno))
791 : 160999 : CLEAR_HARD_REG_BIT (hard_regs_live, ignore_regno);
792 : 56435655 : else if (!HARD_REGISTER_NUM_P (ignore_regno)
793 : 56435655 : && sparseset_bit_p (pseudos_live, ignore_regno))
794 : 11505706 : sparseset_clear_bit (pseudos_live, ignore_regno);
795 : : else
796 : : /* We don't need any special handling of the source reg if
797 : : it is dead after this instruction. */
798 : : ignore_reg = NULL_RTX;
799 : : }
800 : :
801 : 197989351 : src_regno = (set != NULL_RTX && REG_P (SET_SRC (set))
802 : 283327722 : ? REGNO (SET_SRC (set)) : -1);
803 : 197989351 : dst_regno = (set != NULL_RTX && REG_P (SET_DEST (set))
804 : 148355534 : ? REGNO (SET_DEST (set)) : -1);
805 : 207334281 : if (complete_info_p
806 : 206201120 : && src_regno >= 0 && dst_regno >= 0
807 : : /* Check that source regno does not conflict with
808 : : destination regno to exclude most impossible
809 : : preferences. */
810 : 263642524 : && (((!HARD_REGISTER_NUM_P (src_regno)
811 : 49771591 : && (! sparseset_bit_p (pseudos_live, src_regno)
812 : 8898 : || (!HARD_REGISTER_NUM_P (dst_regno)
813 : 56308243 : && lra_reg_val_equal_p (src_regno,
814 : : lra_reg_info[dst_regno].val,
815 : 0 : lra_reg_info[dst_regno].offset))))
816 : : || (HARD_REGISTER_NUM_P (src_regno)
817 : 6536652 : && ! TEST_HARD_REG_BIT (hard_regs_live, src_regno)))
818 : : /* It might be 'inheritance pseudo <- reload pseudo'. */
819 : 8911 : || (src_regno >= lra_constraint_new_regno_start
820 : 288 : && dst_regno >= lra_constraint_new_regno_start
821 : : /* Remember to skip special cases where src/dest regnos are
822 : : the same, e.g. insn SET pattern has matching constraints
823 : : like =r,0. */
824 : 0 : && src_regno != dst_regno)))
825 : : {
826 : 56299332 : int hard_regno = -1, regno = -1;
827 : :
828 : 56299332 : if (dst_regno >= lra_constraint_new_regno_start
829 : 15850574 : && src_regno >= lra_constraint_new_regno_start)
830 : : {
831 : : /* It might be still an original (non-reload) insn with
832 : : one unused output and a constraint requiring to use
833 : : the same reg for input/output operands. In this case
834 : : dst_regno and src_regno have the same value, we don't
835 : : need a misleading copy for this case. */
836 : 5959329 : if (dst_regno != src_regno)
837 : 5959329 : lra_create_copy (dst_regno, src_regno, freq);
838 : : }
839 : 50340003 : else if (dst_regno >= lra_constraint_new_regno_start)
840 : : {
841 : 9891245 : if (!HARD_REGISTER_NUM_P (hard_regno = src_regno))
842 : 9724586 : hard_regno = reg_renumber[src_regno];
843 : : regno = dst_regno;
844 : : }
845 : 40448758 : else if (src_regno >= lra_constraint_new_regno_start)
846 : : {
847 : 10597479 : if (!HARD_REGISTER_NUM_P (hard_regno = dst_regno))
848 : 9015609 : hard_regno = reg_renumber[dst_regno];
849 : : regno = src_regno;
850 : : }
851 : 56299332 : if (regno >= 0 && hard_regno >= 0)
852 : 12353283 : lra_setup_reload_pseudo_preferenced_hard_reg
853 : 12353283 : (regno, hard_regno, freq);
854 : : }
855 : :
856 : 207334281 : sparseset_clear (start_living);
857 : :
858 : : /* Mark each defined value as live. We need to do this for
859 : : unused values because they still conflict with quantities
860 : : that are live at the time of the definition. */
861 : 538578907 : for (reg = curr_id->regs; reg != NULL; reg = reg->next)
862 : 331244626 : if (reg->type != OP_IN)
863 : : {
864 : 144913364 : update_pseudo_point (reg->regno, curr_point, USE_POINT);
865 : 144913364 : mark_regno_live (reg->regno, reg->biggest_mode);
866 : : /* ??? Should be a no-op for unused registers. */
867 : 144913364 : check_pseudos_live_through_calls (reg->regno, last_call_abi);
868 : : }
869 : :
870 : 260349731 : for (reg = curr_static_id->hard_regs; reg != NULL; reg = reg->next)
871 : 53015450 : if (reg->type != OP_IN)
872 : 38362313 : make_hard_regno_live (reg->regno);
873 : :
874 : 207334281 : if (curr_id->arg_hard_regs != NULL)
875 : 29927280 : for (i = 0; (regno = curr_id->arg_hard_regs[i]) >= 0; i++)
876 : 21186669 : if (!HARD_REGISTER_NUM_P (regno))
877 : : /* It is a clobber. */
878 : 964263 : make_hard_regno_live (regno - FIRST_PSEUDO_REGISTER);
879 : :
880 : 207334281 : sparseset_copy (unused_set, start_living);
881 : :
882 : 207334281 : sparseset_clear (start_dying);
883 : :
884 : : /* See which defined values die here. */
885 : 538578907 : for (reg = curr_id->regs; reg != NULL; reg = reg->next)
886 : 331244626 : if (reg->type != OP_IN
887 : 619600538 : && ! reg_early_clobber_p (reg, n_alt) && ! reg->subreg_p)
888 : : {
889 : 143442548 : if (reg->type == OP_OUT)
890 : 124269720 : update_pseudo_point (reg->regno, curr_point, DEF_POINT);
891 : 143442548 : mark_regno_dead (reg->regno, reg->biggest_mode);
892 : : }
893 : :
894 : 260349731 : for (reg = curr_static_id->hard_regs; reg != NULL; reg = reg->next)
895 : 53015450 : if (reg->type != OP_IN
896 : 106626884 : && ! reg_early_clobber_p (reg, n_alt) && ! reg->subreg_p)
897 : 15249121 : make_hard_regno_dead (reg->regno);
898 : :
899 : 207334281 : if (curr_id->arg_hard_regs != NULL)
900 : 29927280 : for (i = 0; (regno = curr_id->arg_hard_regs[i]) >= 0; i++)
901 : 21186669 : if (!HARD_REGISTER_NUM_P (regno))
902 : : /* It is a clobber. */
903 : 964263 : make_hard_regno_dead (regno - FIRST_PSEUDO_REGISTER);
904 : :
905 : 207334281 : if (call_p)
906 : : {
907 : 11408476 : function_abi call_abi = insn_callee_abi (curr_insn);
908 : :
909 : 11408476 : if (last_call_abi != call_abi)
910 : 7585431 : EXECUTE_IF_SET_IN_SPARSESET (pseudos_live, j)
911 : 5470873 : check_pseudos_live_through_calls (j, last_call_abi);
912 : :
913 : 11408476 : last_call_abi = call_abi;
914 : :
915 : 11408476 : sparseset_ior (pseudos_live_through_calls,
916 : : pseudos_live_through_calls, pseudos_live);
917 : 11408476 : if (cfun->has_nonlocal_label
918 : 11408476 : || (!targetm.setjmp_preserves_nonvolatile_regs_p ()
919 : 11404224 : && (find_reg_note (curr_insn, REG_SETJMP, NULL_RTX)
920 : : != NULL_RTX)))
921 : 6535 : sparseset_ior (pseudos_live_through_setjumps,
922 : : pseudos_live_through_setjumps, pseudos_live);
923 : : }
924 : :
925 : : /* Increment the current program point if we must. */
926 : 207334281 : if (sparseset_contains_pseudos_p (unused_set)
927 : 207334281 : || sparseset_contains_pseudos_p (start_dying))
928 : 106476926 : next_program_point (curr_point, freq);
929 : :
930 : : /* If we removed the source reg from a simple register copy from the
931 : : live set above, then add it back now so we don't accidentally add
932 : : it to the start_living set below. */
933 : 207334281 : if (ignore_reg != NULL_RTX)
934 : : {
935 : 11666705 : int ignore_regno = REGNO (ignore_reg);
936 : 11666705 : if (HARD_REGISTER_NUM_P (ignore_regno))
937 : 160999 : SET_HARD_REG_BIT (hard_regs_live, ignore_regno);
938 : : else
939 : 11505706 : sparseset_set_bit (pseudos_live, ignore_regno);
940 : : }
941 : :
942 : 207334281 : sparseset_clear (start_living);
943 : :
944 : : /* Mark each used value as live. */
945 : 538578907 : for (reg = curr_id->regs; reg != NULL; reg = reg->next)
946 : 331244626 : if (reg->type != OP_OUT)
947 : : {
948 : 205633661 : if (reg->type == OP_IN)
949 : 186331262 : update_pseudo_point (reg->regno, curr_point, USE_POINT);
950 : 205633661 : mark_regno_live (reg->regno, reg->biggest_mode);
951 : 205633661 : check_pseudos_live_through_calls (reg->regno, last_call_abi);
952 : : }
953 : :
954 : 260349731 : for (reg = curr_static_id->hard_regs; reg != NULL; reg = reg->next)
955 : 53015450 : if (reg->type != OP_OUT)
956 : 15155653 : make_hard_regno_live (reg->regno);
957 : :
958 : 207334281 : if (curr_id->arg_hard_regs != NULL)
959 : : /* Make argument hard registers live. */
960 : 29927280 : for (i = 0; (regno = curr_id->arg_hard_regs[i]) >= 0; i++)
961 : 21186669 : if (HARD_REGISTER_NUM_P (regno))
962 : 20222406 : make_hard_regno_live (regno);
963 : :
964 : 207334281 : sparseset_and_compl (dead_set, start_living, start_dying);
965 : :
966 : 207334281 : sparseset_clear (start_dying);
967 : :
968 : : /* Mark early clobber outputs dead. */
969 : 538578907 : for (reg = curr_id->regs; reg != NULL; reg = reg->next)
970 : 331244626 : if (reg->type != OP_IN
971 : 476487783 : && reg_early_clobber_p (reg, n_alt) && ! reg->subreg_p)
972 : : {
973 : 329793 : if (reg->type == OP_OUT)
974 : 222673 : update_pseudo_point (reg->regno, curr_point, DEF_POINT);
975 : 329793 : mark_regno_dead (reg->regno, reg->biggest_mode);
976 : :
977 : : /* We're done processing inputs, so make sure early clobber
978 : : operands that are both inputs and outputs are still live. */
979 : 329793 : if (reg->type == OP_INOUT)
980 : 107120 : mark_regno_live (reg->regno, reg->biggest_mode);
981 : : }
982 : :
983 : 260349731 : for (reg = curr_static_id->hard_regs; reg != NULL; reg = reg->next)
984 : 53015450 : if (reg->type != OP_IN
985 : 114490955 : && reg_early_clobber_p (reg, n_alt) && ! reg->subreg_p)
986 : : {
987 : 23113192 : struct lra_insn_reg *reg2;
988 : :
989 : : /* We can have early clobbered non-operand hard reg and
990 : : the same hard reg as an insn input. Don't make hard
991 : : reg dead before the insns. */
992 : 46548818 : for (reg2 = curr_static_id->hard_regs; reg2 != NULL; reg2 = reg2->next)
993 : 23468034 : if (reg2->type != OP_OUT && reg2->regno == reg->regno)
994 : : break;
995 : 23113192 : if (reg2 != NULL)
996 : 32408 : continue;
997 : :
998 : : HARD_REG_SET clobbered_regset;
999 : 23080784 : CLEAR_HARD_REG_SET (clobbered_regset);
1000 : 23080784 : SET_HARD_REG_BIT (clobbered_regset, reg->regno);
1001 : :
1002 : 63820945 : for (reg2 = curr_id->regs; reg2 != NULL; reg2 = reg2->next)
1003 : 29007251 : if (reg2->type != OP_OUT && reg2->regno < FIRST_PSEUDO_REGISTER
1004 : 48848003 : && ira_hard_reg_set_intersection_p (reg2->regno,
1005 : 8100211 : reg2->biggest_mode,
1006 : : clobbered_regset))
1007 : : break;
1008 : 23080784 : if (reg2 == NULL)
1009 : : {
1010 : 23073153 : make_hard_regno_dead (reg->regno);
1011 : : }
1012 : : else
1013 : : {
1014 : 99084 : EXECUTE_IF_SET_IN_SPARSESET (pseudos_live, j)
1015 : 91453 : SET_HARD_REG_BIT (lra_reg_info[j].conflict_hard_regs,
1016 : : reg->regno);
1017 : : }
1018 : : }
1019 : :
1020 : : /* Increment the current program point if we must. */
1021 : 207334281 : if (sparseset_contains_pseudos_p (dead_set)
1022 : 207334281 : || sparseset_contains_pseudos_p (start_dying))
1023 : 82824158 : next_program_point (curr_point, freq);
1024 : :
1025 : : /* Update notes. */
1026 : 416741903 : for (link_loc = ®_NOTES (curr_insn); (link = *link_loc) != NULL_RTX;)
1027 : : {
1028 : 209407622 : if (REG_NOTE_KIND (link) != REG_DEAD
1029 : 86320239 : && REG_NOTE_KIND (link) != REG_UNUSED)
1030 : : ;
1031 : 149223842 : else if (REG_P (XEXP (link, 0)))
1032 : : {
1033 : 149223842 : rtx note_reg = XEXP (link, 0);
1034 : 149223842 : int note_regno = REGNO (note_reg);
1035 : :
1036 : 152718264 : if ((REG_NOTE_KIND (link) == REG_DEAD
1037 : 123087383 : && ! regnos_in_sparseset_p (dead_set, note_regno,
1038 : 123087383 : GET_MODE (note_reg)))
1039 : 270022972 : || (REG_NOTE_KIND (link) == REG_UNUSED
1040 : 26136459 : && ! regnos_in_sparseset_p (unused_set, note_regno,
1041 : 26136459 : GET_MODE (note_reg))))
1042 : : {
1043 : 3494422 : *link_loc = XEXP (link, 1);
1044 : 3494422 : continue;
1045 : : }
1046 : 145729420 : if (REG_NOTE_KIND (link) == REG_DEAD)
1047 : 120799130 : clear_sparseset_regnos (dead_set, note_regno,
1048 : 120799130 : GET_MODE (note_reg));
1049 : 24930290 : else if (REG_NOTE_KIND (link) == REG_UNUSED)
1050 : 24930290 : clear_sparseset_regnos (unused_set, note_regno,
1051 : 24930290 : GET_MODE (note_reg));
1052 : : }
1053 : 205913200 : link_loc = &XEXP (link, 1);
1054 : : }
1055 : 216314346 : EXECUTE_IF_SET_IN_SPARSESET (dead_set, j)
1056 : 8980065 : add_reg_note (curr_insn, REG_DEAD, regno_reg_rtx[j]);
1057 : 416599951 : EXECUTE_IF_SET_IN_SPARSESET (unused_set, j)
1058 : 1931389 : add_reg_note (curr_insn, REG_UNUSED, regno_reg_rtx[j]);
1059 : : }
1060 : :
1061 : 29940260 : if (bb_has_eh_pred (bb))
1062 : : /* Any pseudos that are currently live conflict with the eh_return
1063 : : data registers. For liveness purposes, these registers are set
1064 : : by artificial definitions at the start of the BB, so are not
1065 : : actually live on entry. */
1066 : 537717 : for (j = 0; ; ++j)
1067 : : {
1068 : 1613151 : unsigned int regno = EH_RETURN_DATA_REGNO (j);
1069 : :
1070 : 1075434 : if (regno == INVALID_REGNUM)
1071 : : break;
1072 : :
1073 : 1075434 : make_hard_regno_live (regno);
1074 : 1075434 : make_hard_regno_dead (regno);
1075 : 1075434 : }
1076 : :
1077 : : /* Pseudos can't go in stack regs at the start of a basic block that
1078 : : is reached by an abnormal edge. Likewise for registers that are at
1079 : : least partly call clobbered, because caller-save, fixup_abnormal_edges
1080 : : and possibly the table driven EH machinery are not quite ready to
1081 : : handle such pseudos live across such edges. */
1082 : 29940260 : if (bb_has_abnormal_pred (bb))
1083 : : {
1084 : : HARD_REG_SET clobbers;
1085 : :
1086 : 541023 : CLEAR_HARD_REG_SET (clobbers);
1087 : : #ifdef STACK_REGS
1088 : 1816434 : EXECUTE_IF_SET_IN_SPARSESET (pseudos_live, px)
1089 : 1275411 : lra_reg_info[px].no_stack_p = true;
1090 : 4869207 : for (px = FIRST_STACK_REG; px <= LAST_STACK_REG; px++)
1091 : 4328184 : SET_HARD_REG_BIT (clobbers, px);
1092 : : #endif
1093 : : /* No need to record conflicts for call clobbered regs if we
1094 : : have nonlocal labels around, as we don't ever try to
1095 : : allocate such regs in this case. */
1096 : 541023 : if (!cfun->has_nonlocal_label
1097 : 541023 : && has_abnormal_call_or_eh_pred_edge_p (bb))
1098 : 50006844 : for (px = 0; HARD_REGISTER_NUM_P (px); px++)
1099 : 49469136 : if (eh_edge_abi.clobbers_at_least_part_of_reg_p (px)
1100 : : #ifdef REAL_PIC_OFFSET_TABLE_REGNUM
1101 : : /* We should create a conflict of PIC pseudo with PIC
1102 : : hard reg as PIC hard reg can have a wrong value after
1103 : : jump described by the abnormal edge. In this case we
1104 : : cannot allocate PIC hard reg to PIC pseudo as PIC
1105 : : pseudo will also have a wrong value. */
1106 : 50046937 : || (px == REAL_PIC_OFFSET_TABLE_REGNUM
1107 : 537708 : && pic_offset_table_rtx != NULL_RTX
1108 : 25142 : && !HARD_REGISTER_P (pic_offset_table_rtx))
1109 : : #endif
1110 : : )
1111 : 44819992 : SET_HARD_REG_BIT (clobbers, px);
1112 : :
1113 : 541023 : clobbers &= ~hard_regs_live;
1114 : 50315139 : for (px = 0; HARD_REGISTER_NUM_P (px); px++)
1115 : 49774116 : if (TEST_HARD_REG_BIT (clobbers, px))
1116 : : {
1117 : 44846512 : make_hard_regno_live (px);
1118 : 44846512 : make_hard_regno_dead (px);
1119 : : }
1120 : : }
1121 : :
1122 : 29940260 : bool live_change_p = false;
1123 : : /* Check if bb border live info was changed. */
1124 : 29940260 : unsigned int live_pseudos_num = 0;
1125 : 408839606 : EXECUTE_IF_SET_IN_BITMAP (df_get_live_in (bb),
1126 : : FIRST_PSEUDO_REGISTER, j, bi)
1127 : : {
1128 : 379100903 : live_pseudos_num++;
1129 : 379100903 : if (! sparseset_bit_p (pseudos_live, j))
1130 : : {
1131 : 201557 : live_change_p = true;
1132 : 201557 : if (lra_dump_file != NULL)
1133 : 14 : fprintf (lra_dump_file,
1134 : : " r%d is removed as live at bb%d start\n", j, bb->index);
1135 : : break;
1136 : : }
1137 : : }
1138 : 14 : if (! live_change_p
1139 : 29738703 : && sparseset_cardinality (pseudos_live) != live_pseudos_num)
1140 : : {
1141 : 168015 : live_change_p = true;
1142 : 168015 : if (lra_dump_file != NULL)
1143 : 28 : EXECUTE_IF_SET_IN_SPARSESET (pseudos_live, j)
1144 : 7 : if (! bitmap_bit_p (df_get_live_in (bb), j))
1145 : 7 : fprintf (lra_dump_file,
1146 : : " r%d is added to live at bb%d start\n", j, bb->index);
1147 : : }
1148 : : /* See if we'll need an increment at the end of this basic block.
1149 : : An increment is needed if the PSEUDOS_LIVE set is not empty,
1150 : : to make sure the finish points are set up correctly. */
1151 : 29940260 : need_curr_point_incr = (sparseset_cardinality (pseudos_live) > 0);
1152 : :
1153 : 788990840 : EXECUTE_IF_SET_IN_SPARSESET (pseudos_live, i)
1154 : : {
1155 : 379525290 : update_pseudo_point (i, curr_point, DEF_POINT);
1156 : 379525290 : mark_pseudo_dead (i);
1157 : : }
1158 : :
1159 : 120419275 : EXECUTE_IF_SET_IN_BITMAP (df_get_live_in (bb), FIRST_PSEUDO_REGISTER, j, bi)
1160 : : {
1161 : 110899369 : if (sparseset_cardinality (pseudos_live_through_calls) == 0)
1162 : : break;
1163 : 90479015 : if (sparseset_bit_p (pseudos_live_through_calls, j))
1164 : 84689980 : check_pseudos_live_through_calls (j, last_call_abi);
1165 : : }
1166 : :
1167 : 2784444180 : for (i = 0; HARD_REGISTER_NUM_P (i); ++i)
1168 : : {
1169 : 2754503920 : if (!TEST_HARD_REG_BIT (hard_regs_live, i))
1170 : 2713061096 : continue;
1171 : :
1172 : 41442824 : if (!TEST_HARD_REG_BIT (hard_regs_spilled_into, i))
1173 : 41442824 : continue;
1174 : :
1175 : 0 : if (bitmap_bit_p (df_get_live_in (bb), i))
1176 : 0 : continue;
1177 : :
1178 : 0 : live_change_p = true;
1179 : 0 : if (lra_dump_file)
1180 : 0 : fprintf (lra_dump_file,
1181 : : " hard reg r%d is added to live at bb%d start\n", i,
1182 : : bb->index);
1183 : 0 : bitmap_set_bit (df_get_live_in (bb), i);
1184 : : }
1185 : :
1186 : 29940260 : if (need_curr_point_incr)
1187 : 23950186 : next_program_point (curr_point, freq);
1188 : :
1189 : 29940260 : return live_change_p;
1190 : : }
1191 : :
1192 : : /* Compress pseudo live ranges by removing program points where
1193 : : nothing happens. Complexity of many algorithms in LRA is linear
1194 : : function of program points number. To speed up the code we try to
1195 : : minimize the number of the program points here. */
1196 : : static void
1197 : 1510749 : remove_some_program_points_and_update_live_ranges (void)
1198 : : {
1199 : 1510749 : unsigned i;
1200 : 1510749 : int n, max_regno;
1201 : 1510749 : int *map;
1202 : 1510749 : lra_live_range_t r, prev_r, next_r;
1203 : 1510749 : sbitmap_iterator sbi;
1204 : 1510749 : bool born_p, dead_p, prev_born_p, prev_dead_p;
1205 : :
1206 : 1510749 : auto_sbitmap born (lra_live_max_point);
1207 : 1510749 : auto_sbitmap dead (lra_live_max_point);
1208 : 1510749 : bitmap_clear (born);
1209 : 1510749 : bitmap_clear (dead);
1210 : 1510749 : max_regno = max_reg_num ();
1211 : 163585066 : for (i = FIRST_PSEUDO_REGISTER; i < (unsigned) max_regno; i++)
1212 : : {
1213 : 268009471 : for (r = lra_reg_info[i].live_ranges; r != NULL; r = r->next)
1214 : : {
1215 : 105935154 : lra_assert (r->start <= r->finish);
1216 : 105935154 : bitmap_set_bit (born, r->start);
1217 : 105935154 : bitmap_set_bit (dead, r->finish);
1218 : : }
1219 : : }
1220 : 1510749 : auto_sbitmap born_or_dead (lra_live_max_point);
1221 : 1510749 : bitmap_ior (born_or_dead, born, dead);
1222 : 1510749 : map = XCNEWVEC (int, lra_live_max_point);
1223 : 1510749 : n = -1;
1224 : 1510749 : prev_born_p = prev_dead_p = false;
1225 : 187049403 : EXECUTE_IF_SET_IN_BITMAP (born_or_dead, 0, i, sbi)
1226 : : {
1227 : 184027905 : born_p = bitmap_bit_p (born, i);
1228 : 184027905 : dead_p = bitmap_bit_p (dead, i);
1229 : 184027905 : if ((prev_born_p && ! prev_dead_p && born_p && ! dead_p)
1230 : 170014990 : || (prev_dead_p && ! prev_born_p && dead_p && ! born_p))
1231 : : {
1232 : 40232818 : map[i] = n;
1233 : 40232818 : lra_point_freq[n] = MAX (lra_point_freq[n], lra_point_freq[i]);
1234 : : }
1235 : : else
1236 : : {
1237 : 143795087 : map[i] = ++n;
1238 : 143795087 : lra_point_freq[n] = lra_point_freq[i];
1239 : : }
1240 : 184027905 : prev_born_p = born_p;
1241 : 184027905 : prev_dead_p = dead_p;
1242 : : }
1243 : 1510749 : n++;
1244 : 1510749 : if (lra_dump_file != NULL)
1245 : 95 : fprintf (lra_dump_file, "Compressing live ranges: from %d to %d - %d%%\n",
1246 : : lra_live_max_point, n,
1247 : 95 : lra_live_max_point ? 100 * n / lra_live_max_point : 100);
1248 : 1510749 : if (n < lra_live_max_point)
1249 : : {
1250 : 1282188 : lra_live_max_point = n;
1251 : 160300004 : for (i = FIRST_PSEUDO_REGISTER; i < (unsigned) max_regno; i++)
1252 : : {
1253 : 159017816 : for (prev_r = NULL, r = lra_reg_info[i].live_ranges;
1254 : 264204762 : r != NULL;
1255 : : r = next_r)
1256 : : {
1257 : 105186946 : next_r = r->next;
1258 : 105186946 : r->start = map[r->start];
1259 : 105186946 : r->finish = map[r->finish];
1260 : 105186946 : if (prev_r == NULL || prev_r->start > r->finish + 1)
1261 : : {
1262 : 103171490 : prev_r = r;
1263 : 103171490 : continue;
1264 : : }
1265 : 2015456 : prev_r->start = r->start;
1266 : 2015456 : prev_r->next = next_r;
1267 : 2015456 : lra_live_range_pool.remove (r);
1268 : : }
1269 : : }
1270 : : }
1271 : 1510749 : free (map);
1272 : 1510749 : }
1273 : :
1274 : : /* Print live ranges R to file F. */
1275 : : void
1276 : 2578 : lra_print_live_range_list (FILE *f, lra_live_range_t r)
1277 : : {
1278 : 5706 : for (; r != NULL; r = r->next)
1279 : 3128 : fprintf (f, " [%d..%d]", r->start, r->finish);
1280 : 2578 : fprintf (f, "\n");
1281 : 2578 : }
1282 : :
1283 : : DEBUG_FUNCTION void
1284 : 0 : debug (lra_live_range &ref)
1285 : : {
1286 : 0 : lra_print_live_range_list (stderr, &ref);
1287 : 0 : }
1288 : :
1289 : : DEBUG_FUNCTION void
1290 : 0 : debug (lra_live_range *ptr)
1291 : : {
1292 : 0 : if (ptr)
1293 : 0 : debug (*ptr);
1294 : : else
1295 : 0 : fprintf (stderr, "<nil>\n");
1296 : 0 : }
1297 : :
1298 : : /* Print live ranges R to stderr. */
1299 : : void
1300 : 0 : lra_debug_live_range_list (lra_live_range_t r)
1301 : : {
1302 : 0 : lra_print_live_range_list (stderr, r);
1303 : 0 : }
1304 : :
1305 : : /* Print live ranges of pseudo REGNO to file F. */
1306 : : static void
1307 : 6052 : print_pseudo_live_ranges (FILE *f, int regno)
1308 : : {
1309 : 6052 : if (lra_reg_info[regno].live_ranges == NULL)
1310 : : return;
1311 : 2578 : fprintf (f, " r%d:", regno);
1312 : 2578 : lra_print_live_range_list (f, lra_reg_info[regno].live_ranges);
1313 : : }
1314 : :
1315 : : /* Print live ranges of pseudo REGNO to stderr. */
1316 : : void
1317 : 0 : lra_debug_pseudo_live_ranges (int regno)
1318 : : {
1319 : 0 : print_pseudo_live_ranges (stderr, regno);
1320 : 0 : }
1321 : :
1322 : : /* Print live ranges of all pseudos to file F. */
1323 : : static void
1324 : 190 : print_live_ranges (FILE *f)
1325 : : {
1326 : 190 : int i, max_regno;
1327 : :
1328 : 190 : max_regno = max_reg_num ();
1329 : 6432 : for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
1330 : 6052 : print_pseudo_live_ranges (f, i);
1331 : 190 : }
1332 : :
1333 : : /* Print live ranges of all pseudos to stderr. */
1334 : : void
1335 : 0 : lra_debug_live_ranges (void)
1336 : : {
1337 : 0 : print_live_ranges (stderr);
1338 : 0 : }
1339 : :
1340 : : /* Compress pseudo live ranges. */
1341 : : static void
1342 : 1510749 : compress_live_ranges (void)
1343 : : {
1344 : 1510749 : remove_some_program_points_and_update_live_ranges ();
1345 : 1510749 : if (lra_dump_file != NULL)
1346 : : {
1347 : 95 : fprintf (lra_dump_file, "Ranges after the compression:\n");
1348 : 95 : print_live_ranges (lra_dump_file);
1349 : : }
1350 : 1510749 : }
1351 : :
1352 : :
1353 : :
1354 : : /* The number of the current live range pass. */
1355 : : int lra_live_range_iter;
1356 : :
1357 : : /* The function creates live ranges only for memory pseudos (or for
1358 : : all ones if ALL_P), set up CONFLICT_HARD_REGS for the pseudos. It
1359 : : also does dead insn elimination if DEAD_INSN_P and global live
1360 : : analysis only for pseudos and only if the pseudo live info was
1361 : : changed on a BB border. Return TRUE if the live info was
1362 : : changed. */
1363 : : static bool
1364 : 1699098 : lra_create_live_ranges_1 (bool all_p, bool dead_insn_p)
1365 : : {
1366 : 1699098 : basic_block bb;
1367 : 1699098 : int i, hard_regno, max_regno = max_reg_num ();
1368 : 1699098 : int curr_point;
1369 : 1699098 : bool bb_live_change_p, have_referenced_pseudos = false;
1370 : :
1371 : 1699098 : timevar_push (TV_LRA_CREATE_LIVE_RANGES);
1372 : :
1373 : 1699098 : complete_info_p = all_p;
1374 : 1699098 : if (lra_dump_file != NULL)
1375 : 106 : fprintf (lra_dump_file,
1376 : : "\n********** Pseudo live ranges #%d: **********\n\n",
1377 : : ++lra_live_range_iter);
1378 : 1699098 : memset (lra_hard_reg_usage, 0, sizeof (lra_hard_reg_usage));
1379 : 322246051 : for (i = 0; i < max_regno; i++)
1380 : : {
1381 : 320546953 : lra_reg_info[i].live_ranges = NULL;
1382 : 320546953 : CLEAR_HARD_REG_SET (lra_reg_info[i].conflict_hard_regs);
1383 : 320546953 : lra_reg_info[i].preferred_hard_regno1 = -1;
1384 : 320546953 : lra_reg_info[i].preferred_hard_regno2 = -1;
1385 : 320546953 : lra_reg_info[i].preferred_hard_regno_profit1 = 0;
1386 : 320546953 : lra_reg_info[i].preferred_hard_regno_profit2 = 0;
1387 : : #ifdef STACK_REGS
1388 : 320546953 : lra_reg_info[i].no_stack_p = false;
1389 : : #endif
1390 : : /* The biggest mode is already set but its value might be to
1391 : : conservative because of recent transformation. Here in this
1392 : : file we recalculate it again as it costs practically
1393 : : nothing. */
1394 : 320546953 : if (!HARD_REGISTER_NUM_P (i) && regno_reg_rtx[i] != NULL_RTX)
1395 : 163405132 : lra_reg_info[i].biggest_mode = GET_MODE (regno_reg_rtx[i]);
1396 : : else
1397 : 157141821 : lra_reg_info[i].biggest_mode = VOIDmode;
1398 : 320546953 : if (!HARD_REGISTER_NUM_P (i)
1399 : 164229937 : && lra_reg_info[i].nrefs != 0)
1400 : : {
1401 : 84713233 : if ((hard_regno = reg_renumber[i]) >= 0)
1402 : 69352705 : lra_hard_reg_usage[hard_regno] += lra_reg_info[i].freq;
1403 : : have_referenced_pseudos = true;
1404 : : }
1405 : : }
1406 : 1699098 : lra_free_copies ();
1407 : :
1408 : : /* Under some circumstances, we can have functions without pseudo
1409 : : registers. For such functions, lra_live_max_point will be 0,
1410 : : see e.g. PR55604, and there's nothing more to do for us here. */
1411 : 1699098 : if (! have_referenced_pseudos)
1412 : : {
1413 : 188349 : timevar_pop (TV_LRA_CREATE_LIVE_RANGES);
1414 : 188349 : return false;
1415 : : }
1416 : :
1417 : 1510749 : pseudos_live = sparseset_alloc (max_regno);
1418 : 1510749 : pseudos_live_through_calls = sparseset_alloc (max_regno);
1419 : 1510749 : pseudos_live_through_setjumps = sparseset_alloc (max_regno);
1420 : 1510749 : start_living = sparseset_alloc (max_regno);
1421 : 1510749 : start_dying = sparseset_alloc (max_regno);
1422 : 1510749 : dead_set = sparseset_alloc (max_regno);
1423 : 1510749 : unused_set = sparseset_alloc (max_regno);
1424 : 1510749 : curr_point = 0;
1425 : 1510749 : unsigned new_length = get_max_uid () * 2;
1426 : 1510749 : point_freq_vec.truncate (0);
1427 : 1510749 : point_freq_vec.reserve_exact (new_length);
1428 : 1510749 : lra_point_freq = point_freq_vec.address ();
1429 : 1510749 : int *rpo = XNEWVEC (int, n_basic_blocks_for_fn (cfun));
1430 : 1510749 : int n = inverted_rev_post_order_compute (cfun, rpo);
1431 : 1510749 : lra_assert (n == n_basic_blocks_for_fn (cfun));
1432 : : bb_live_change_p = false;
1433 : 34472507 : for (i = 0; i < n; ++i)
1434 : : {
1435 : 32961758 : bb = BASIC_BLOCK_FOR_FN (cfun, rpo[i]);
1436 : 32961758 : if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || bb
1437 : 31451009 : == ENTRY_BLOCK_PTR_FOR_FN (cfun))
1438 : 3021498 : continue;
1439 : 29940260 : if (process_bb_lives (bb, curr_point, dead_insn_p))
1440 : 32961758 : bb_live_change_p = true;
1441 : : }
1442 : 1510749 : free (rpo);
1443 : 1510749 : if (bb_live_change_p)
1444 : : {
1445 : : /* We need to clear pseudo live info as some pseudos can
1446 : : disappear, e.g. pseudos with used equivalences. */
1447 : 5878328 : FOR_EACH_BB_FN (bb, cfun)
1448 : : {
1449 : 5770678 : bitmap_clear_range (df_get_live_in (bb), FIRST_PSEUDO_REGISTER,
1450 : 5770678 : max_regno - FIRST_PSEUDO_REGISTER);
1451 : 5770678 : bitmap_clear_range (df_get_live_out (bb), FIRST_PSEUDO_REGISTER,
1452 : : max_regno - FIRST_PSEUDO_REGISTER);
1453 : : }
1454 : : /* As we did not change CFG since LRA start we can use
1455 : : DF-infrastructure solver to solve live data flow problem. */
1456 : 10011450 : for (int i = 0; HARD_REGISTER_NUM_P (i); ++i)
1457 : : {
1458 : 9903800 : if (TEST_HARD_REG_BIT (hard_regs_spilled_into, i))
1459 : 0 : bitmap_clear_bit (&all_hard_regs_bitmap, i);
1460 : : }
1461 : 107650 : df_simple_dataflow
1462 : 107650 : (DF_BACKWARD, NULL, live_con_fun_0, live_con_fun_n,
1463 : : live_trans_fun, &all_blocks,
1464 : : df_get_postorder (DF_BACKWARD), df_get_n_blocks (DF_BACKWARD));
1465 : 107650 : if (lra_dump_file != NULL)
1466 : : {
1467 : 7 : fprintf (lra_dump_file,
1468 : : "Global pseudo live data have been updated:\n");
1469 : 7 : basic_block bb;
1470 : 35 : FOR_EACH_BB_FN (bb, cfun)
1471 : : {
1472 : 28 : bb_data_t bb_info = get_bb_data (bb);
1473 : 28 : bitmap bb_livein = df_get_live_in (bb);
1474 : 28 : bitmap bb_liveout = df_get_live_out (bb);
1475 : :
1476 : 28 : fprintf (lra_dump_file, "\nBB %d:\n", bb->index);
1477 : 28 : lra_dump_bitmap_with_title (" gen:",
1478 : : &bb_info->gen_pseudos, bb->index);
1479 : 28 : lra_dump_bitmap_with_title (" killed:",
1480 : : &bb_info->killed_pseudos, bb->index);
1481 : 28 : lra_dump_bitmap_with_title (" livein:", bb_livein, bb->index);
1482 : 28 : lra_dump_bitmap_with_title (" liveout:", bb_liveout, bb->index);
1483 : : }
1484 : : }
1485 : : }
1486 : 1510749 : lra_live_max_point = curr_point;
1487 : 1510749 : if (lra_dump_file != NULL)
1488 : 95 : print_live_ranges (lra_dump_file);
1489 : : /* Clean up. */
1490 : 1510749 : sparseset_free (unused_set);
1491 : 1510749 : sparseset_free (dead_set);
1492 : 1510749 : sparseset_free (start_dying);
1493 : 1510749 : sparseset_free (start_living);
1494 : 1510749 : sparseset_free (pseudos_live_through_calls);
1495 : 1510749 : sparseset_free (pseudos_live_through_setjumps);
1496 : 1510749 : sparseset_free (pseudos_live);
1497 : 1510749 : compress_live_ranges ();
1498 : 1510749 : timevar_pop (TV_LRA_CREATE_LIVE_RANGES);
1499 : 1510749 : return bb_live_change_p;
1500 : : }
1501 : :
1502 : : /* The main entry function creates live-ranges and other live info
1503 : : necessary for the assignment sub-pass. It uses
1504 : : lra_creates_live_ranges_1 -- so read comments for the
1505 : : function. */
1506 : : void
1507 : 1591448 : lra_create_live_ranges (bool all_p, bool dead_insn_p)
1508 : : {
1509 : 1591448 : if (! lra_create_live_ranges_1 (all_p, dead_insn_p))
1510 : : return;
1511 : 107650 : if (lra_dump_file != NULL)
1512 : 7 : fprintf (lra_dump_file, "Live info was changed -- recalculate it\n");
1513 : : /* Live info was changed on a bb border. It means that some info,
1514 : : e.g. about conflict regs, calls crossed, and live ranges may be
1515 : : wrong. We need this info for allocation. So recalculate it
1516 : : again but without removing dead insns which can change live info
1517 : : again. Repetitive live range calculations are expensive therefore
1518 : : we stop here as we already have correct info although some
1519 : : improvement in rare cases could be possible on this sub-pass if
1520 : : we do dead insn elimination again (still the improvement may
1521 : : happen later). */
1522 : 107650 : lra_clear_live_ranges ();
1523 : 107650 : bool res = lra_create_live_ranges_1 (all_p, false);
1524 : 107650 : lra_assert (! res);
1525 : : }
1526 : :
1527 : : /* Finish all live ranges. */
1528 : : void
1529 : 1685067 : lra_clear_live_ranges (void)
1530 : : {
1531 : 1685067 : int i;
1532 : :
1533 : 310750460 : for (i = 0; i < max_reg_num (); i++)
1534 : 309065393 : free_live_range_list (lra_reg_info[i].live_ranges);
1535 : 1685067 : point_freq_vec.release ();
1536 : 1685067 : }
1537 : :
1538 : : /* Initialize live ranges data once per function. */
1539 : : void
1540 : 1415660 : lra_live_ranges_init (void)
1541 : : {
1542 : 1415660 : bitmap_initialize (&temp_bitmap, ®_obstack);
1543 : 1415660 : initiate_live_solver ();
1544 : 1415660 : }
1545 : :
1546 : : /* Finish live ranges data once per function. */
1547 : : void
1548 : 1415660 : lra_live_ranges_finish (void)
1549 : : {
1550 : 1415660 : finish_live_solver ();
1551 : 1415660 : bitmap_clear (&temp_bitmap);
1552 : 1415660 : lra_live_range_pool.release ();
1553 : 1415660 : }
|
