Lines Matching refs:chain
669 /* Make sure that the last insn in the chain
1339 struct insn_chain *chain;
1341 for (chain = reload_insn_chain; chain != 0; chain = chain->next)
1347 if (! INSN_P (chain->insn)
1348 || (noperands = asm_noperands (PATTERN (chain->insn))) < 0)
1350 pat = PATTERN (chain->insn);
1436 CLEAR_REGNO_REG_SET (&chain->live_throughout, i);
1437 CLEAR_REGNO_REG_SET (&chain->dead_or_set, i);
1448 copy_reloads (struct insn_chain *chain)
1450 chain->n_reloads = n_reloads;
1451 chain->rld = obstack_alloc (&reload_obstack,
1453 memcpy (chain->rld, rld, n_reloads * sizeof (struct reload));
1457 /* Walk the chain of insns, and determine for each whether it needs reloads
1464 struct insn_chain *chain, *next = 0;
1469 for (chain = reload_insn_chain; chain != 0; chain = next)
1471 rtx insn = chain->insn;
1473 next = chain->next;
1476 chain->n_reloads = 0;
1477 chain->need_elim = 0;
1478 chain->need_reload = 0;
1479 chain->need_operand_change = 0;
1530 /* Delete it from the reload chain. */
1531 if (chain->prev)
1532 chain->prev->next = next;
1536 next->prev = chain->prev;
1537 chain->next = unused_insn_chains;
1538 unused_insn_chains = chain;
1547 chain->need_elim = did_elimination;
1548 chain->need_reload = n_reloads > 0;
1549 chain->need_operand_change = operands_changed;
1565 copy_reloads (chain);
1566 *pprev_reload = chain;
1567 pprev_reload = &chain->next_need_reload;
1647 order_regs_for_reload (struct insn_chain *chain)
1663 REG_SET_TO_HARD_REG_SET (used_by_pseudos, &chain->live_throughout);
1664 REG_SET_TO_HARD_REG_SET (used_by_pseudos2, &chain->dead_or_set);
1673 (&chain->live_throughout, FIRST_PSEUDO_REGISTER, i, rsi)
1678 (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, i, rsi)
1718 find_reg (struct insn_chain *chain, int order)
1797 (&chain->live_throughout, FIRST_PSEUDO_REGISTER, j, rsi)
1803 (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, j, rsi)
1824 find_reload_regs (struct insn_chain *chain)
1832 for (i = 0; i < chain->n_reloads; i++)
1835 if (chain->rld[i].reg_rtx)
1837 int regno = REGNO (chain->rld[i].reg_rtx);
1838 chain->rld[i].regno = regno;
1839 chain->rld[i].nregs
1840 = hard_regno_nregs[regno][GET_MODE (chain->rld[i].reg_rtx)];
1843 chain->rld[i].regno = -1;
1847 n_reloads = chain->n_reloads;
1848 memcpy (rld, chain->rld, n_reloads * sizeof (struct reload));
1853 fprintf (dump_file, "Spilling for insn %d.\n", INSN_UID (chain->insn));
1859 order_regs_for_reload (chain);
1869 if (! find_reg (chain, i))
1873 spill_failure (chain->insn, rld[r].class);
1879 COPY_HARD_REG_SET (chain->used_spill_regs, used_spill_regs_local);
1882 memcpy (chain->rld, rld, n_reloads * sizeof (struct reload));
1888 struct insn_chain *chain;
1891 for (chain = insns_need_reload; chain != 0;
1892 chain = chain->next_need_reload)
1893 find_reload_regs (chain);
2543 /* Now do eliminations in the rest of the chain. If this was
3682 struct insn_chain *chain;
3733 for (chain = insns_need_reload; chain; chain = chain->next_need_reload)
3736 (&chain->live_throughout, FIRST_PSEUDO_REGISTER, i, rsi)
3739 chain->used_spill_regs);
3742 (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, i, rsi)
3745 chain->used_spill_regs);
3767 /* Fix up the register information in the insn chain.
3770 for (chain = reload_insn_chain; chain; chain = chain->next)
3775 AND_COMPL_REG_SET (&chain->live_throughout, &spilled_pseudos);
3776 AND_COMPL_REG_SET (&chain->dead_or_set, &spilled_pseudos);
3780 if (chain->need_reload)
3782 REG_SET_TO_HARD_REG_SET (used_by_pseudos, &chain->live_throughout);
3783 REG_SET_TO_HARD_REG_SET (used_by_pseudos2, &chain->dead_or_set);
3787 COPY_HARD_REG_SET (used_by_pseudos2, chain->used_spill_regs);
3789 compute_use_by_pseudos (&used_by_pseudos, &chain->live_throughout);
3790 compute_use_by_pseudos (&used_by_pseudos, &chain->dead_or_set);
3791 COMPL_HARD_REG_SET (chain->used_spill_regs, used_by_pseudos);
3792 AND_HARD_REG_SET (chain->used_spill_regs, used_spill_regs);
3795 GO_IF_HARD_REG_SUBSET (used_by_pseudos2, chain->used_spill_regs, ok);
3918 struct insn_chain *chain;
3933 for (chain = reload_insn_chain; chain; chain = chain->next)
3936 rtx insn = chain->insn;
3963 if ((num_eliminable || num_eliminable_invariants) && chain->need_elim)
3981 if (! chain->need_elim && ! chain->need_reload
3982 && ! chain->need_operand_change)
4008 choose_reload_regs (chain);
4018 emit_reload_insns (chain);
4047 if (num_eliminable && chain->need_elim)
5275 allocate_reload_reg (struct insn_chain *chain ATTRIBUTE_UNUSED, int r,
5398 choose_reload_regs_init (struct insn_chain *chain, rtx *save_reload_reg_rtx)
5419 REG_SET_TO_HARD_REG_SET (tmp, &chain->live_throughout);
5421 REG_SET_TO_HARD_REG_SET (tmp, &chain->dead_or_set);
5423 compute_use_by_pseudos (®_used_in_insn, &chain->live_throughout);
5424 compute_use_by_pseudos (®_used_in_insn, &chain->dead_or_set);
5437 COMPL_HARD_REG_SET (reload_reg_unavailable, chain->used_spill_regs);
5457 choose_reload_regs (struct insn_chain *chain)
5459 rtx insn = chain->insn;
5509 choose_reload_regs_init (chain, save_reload_reg_rtx);
5564 allocate_reload_reg (chain, reload_order[i], 0);
5987 allocate_reload_reg (chain, r, j == n_reloads - 1);
6006 if (! allocate_reload_reg (chain, r, j == n_reloads - 1))
6024 choose_reload_regs_init (chain, save_reload_reg_rtx);
6028 gcc_assert (chain->n_reloads == n_reloads);
6032 if (chain->rld[i].regno < 0 || chain->rld[i].reg_rtx != 0)
6034 gcc_assert (chain->rld[i].when_needed == rld[i].when_needed);
6036 if (spill_regs[j] == chain->rld[i].regno)
6038 failed_reload (chain->insn, i);
6391 emit_input_reload_insns (struct insn_chain *chain, struct reload *rl,
6394 rtx insn = chain->insn;
6855 emit_output_reload_insns (struct insn_chain *chain, struct reload *rl,
6859 rtx insn = chain->insn;
7080 do_input_reload (struct insn_chain *chain, struct reload *rl, int j)
7082 rtx insn = chain->insn;
7092 emit_input_reload_insns (chain, rld + j, old, j);
7139 do_output_reload (struct insn_chain *chain, struct reload *rl, int j)
7142 rtx insn = chain->insn;
7201 emit_output_reload_insns (chain, rld + j, j);
7228 emit_reload_insns (struct insn_chain *chain)
7230 rtx insn = chain->insn;
7265 do_input_reload (chain, rld + j, j);
7266 do_output_reload (chain, rld + j, j);