75    std::vector<std::unordered_map<Temp, std::pair<uint32_t, uint32_t>>> next_use_distances_start;
76    std::vector<std::unordered_map<Temp, std::pair<uint32_t, uint32_t>>> next_use_distances_end;
77    std::vector<std::vector<std::pair<Temp, uint32_t>>> local_next_use_distance; /* Working buffer */
78    std::vector<std::pair<RegClass, std::unordered_set<uint32_t>>> interferences;
179    for (std::unordered_map<Temp, std::pair<uint32_t, uint32_t>>::iterator it =
214       std::pair<uint32_t, uint32_t> distance{block_idx, 0};
230             std::pair<uint32_t, uint32_t>& entry_distance = insert_result.first->second;
240    for (std::pair<const Temp, std::pair<uint32_t, uint32_t>>& pair : next_use_distances_start) {
241       Temp temp = pair.first;
245       uint32_t distance = pair.second.second;
246       uint32_t dom = pair.second.first;
252             std::make_pair(temp, std::pair<uint32_t, uint32_t>{}));
254          std::pair<uint32_t, uint32_t>& entry_distance = insert_result.first->second;
260          if (entry_distance != std::pair<uint32_t, uint32_t>{dom, distance}) {
381                 std::vector<std::vector<std::pair<Temp, uint32_t>>>& local_next_uses)
390    for (std::pair<const Temp, std::pair<uint32_t, uint32_t>>& pair :
393          (Temp)pair.first, pair.second.second + block->instructions.size()));
414                                    [op](auto& pair) { return pair.first == op.getTemp(); });
425                                    [def](auto& pair) { return pair.first == def.getTemp(); });
535          for (const std::pair<const Temp, std::pair<uint32_t, uint32_t>>& pair :
537             if (pair.first.type() == type &&
538                 (pair.second.first >= loop_end ||
539                  (ctx.remat.count(pair.first) && type == RegType::sgpr)) &&
540                 pair.second.second > distance && !ctx.spills_entry[block_idx].count(pair.first)) {
541                to_spill = pair.first;
542                distance = pair.second.second;
578          for (const std::pair<const Temp, std::pair<uint32_t, uint32_t>>& pair :
580             if (pair.first.type() == type && pair.second.second > distance &&
581                 !ctx.spills_entry[block_idx].count(pair.first)) {
582                to_spill = pair.first;
583                distance = pair.second.second;
599       for (std::pair<Temp, uint32_t> pair : ctx.spills_exit[pred_idx]) {
600          if (pair.first.type() != RegType::sgpr) {
603          auto next_use_distance_it = next_use_distances.find(pair.first);
606             ctx.spills_entry[block_idx].insert(pair);
607             spilled_registers.sgpr += pair.first.size();
612          for (std::pair<Temp, uint32_t> pair : ctx.spills_exit[pred_idx]) {
613             if (pair.first.type() != RegType::vgpr) {
616             auto next_use_distance_it = next_use_distances.find(pair.first);
619                ctx.spills_entry[block_idx].insert(pair);
620                spilled_registers.vgpr += pair.first.size();
629          for (std::pair<Temp, uint32_t> pair : ctx.spills_exit[pred_idx]) {
630             if (pair.first.type() == RegType::sgpr && next_use_distances.count(pair.first) &&
631                 ctx.spills_entry[block_idx].insert(pair).second) {
632                spilled_registers.sgpr += pair.first.size();
639          for (std::pair<Temp, uint32_t> pair : ctx.spills_exit[pred_idx]) {
640             if (pair.first.type() == RegType::vgpr && next_use_distances.count(pair.first) &&
641                 ctx.spills_entry[block_idx].insert(pair).second) {
642                spilled_registers.vgpr += pair.first.size();
654    for (const std::pair<const Temp, std::pair<uint32_t, uint32_t>>& pair : next_use_distances) {
656          pair.first.is_linear() ? block->linear_preds : block->logical_preds;
663       bool remat = ctx.remat.count(pair.first);
668          if (!ctx.next_use_distances_end[pred_idx].count(pair.first)) {
672          if (!ctx.spills_exit[pred_idx].count(pair.first)) {
676             partial_spills.insert(pair.first);
679             spill_id = ctx.spills_exit[pred_idx][pair.first];
685          ctx.spills_entry[block_idx][pair.first] = spill_id;
686          partial_spills.erase(pair.first);
687          spilled_registers += pair.first;
770       for (std::pair<const Temp, std::pair<uint32_t, uint32_t>>& live :
806          for (std::pair<const Temp, std::pair<uint32_t, uint32_t>>& live :
904          for (std::pair<Temp, uint32_t> pair : ctx.spills_exit[pred_idx])
905             ctx.add_interference(spill_id, pair.second);
931    for (std::pair<Temp, uint32_t> pair : ctx.spills_entry[block_idx]) {
933          pair.first.is_linear() ? block->linear_preds : block->logical_preds;
937          auto spilled = ctx.spills_exit[pred_idx].find(pair.first);
939             if (spilled->second != pair.second)
940                ctx.add_affinity(pair.second, spilled->second);
945          if (!ctx.next_use_distances_end[pred_idx].count(pair.first))
949          for (std::pair<Temp, uint32_t> exit_spill : ctx.spills_exit[pred_idx]) {
950             if (exit_spill.first == pair.first)
952             ctx.add_interference(exit_spill.second, pair.second);
957          Temp var = pair.first;
967          spill->operands[1] = Operand::c32(pair.second);
973          } while (pair.first.type() == RegType::vgpr &&
977          ctx.spills_exit[pred.index][pair.first] = pair.second;
1042    for (std::pair<const Temp, std::pair<uint32_t, uint32_t>>& pair :
1045       if (ctx.spills_entry[block_idx].count(pair.first))
1048          pair.first.is_linear() ? block->linear_preds : block->logical_preds;
1053          if (!ctx.next_use_distances_end[pred_idx].count(pair.first))
1060          if (!ctx.spills_exit[pred_idx].count(pair.first))
1064          Temp new_name = ctx.program->allocateTmp(pair.first.regClass());
1070          } while (pair.first.type() == RegType::vgpr &&
1075             do_reload(ctx, pair.first, new_name, ctx.spills_exit[pred.index][pair.first]);
1078          ctx.spills_exit[pred.index].erase(pair.first);
1079          ctx.renames[pred.index][pair.first] = new_name;
1086          if (!ctx.renames[pred_idx].count(pair.first)) {
1088                rename = pair.first;
1090                is_same = rename == pair.first;
1093                rename = ctx.renames[pred_idx][pair.first];
1095                is_same = rename == ctx.renames[pred_idx][pair.first];
1104          aco_opcode opcode = pair.first.is_linear() ? aco_opcode::p_linear_phi : aco_opcode::p_phi;
1107          rename = ctx.program->allocateTmp(pair.first.regClass());
1110             if (ctx.renames[preds[i]].count(pair.first)) {
1111                tmp = ctx.renames[preds[i]][pair.first];
1115                tmp = pair.first;
1127       if (!(rename == Temp() || rename == pair.first))
1128          ctx.renames[block_idx][pair.first] = rename;
1178       std::map<Temp, std::pair<Temp, uint32_t>> reloads;
1224             for (std::pair<Temp, uint32_t> pair : ctx.local_next_use_distance[idx]) {
1225                if (pair.first.type() != type)
1227                bool can_rematerialize = ctx.remat.count(pair.first);
1228                if (((pair.second > distance && can_rematerialize == do_rematerialize) ||
1229                     (can_rematerialize && !do_rematerialize && pair.second > idx)) &&
1230                    !current_spills.count(pair.first)) {
1231                   to_spill = pair.first;
1232                   distance = pair.second;
1241             for (std::pair<Temp, uint32_t> pair : current_spills)
1242                ctx.add_interference(spill_id, pair.second);
1243             for (std::pair<const Temp, std::pair<Temp, uint32_t>>& pair : reloads)
1244                ctx.add_interference(spill_id, pair.second.second);
1264       for (std::pair<const Temp, std::pair<Temp, uint32_t>>& pair : reloads) {
1266             do_reload(ctx, pair.second.first, pair.first, pair.second.second);
1331    for (std::pair<Temp, Temp> rename : renames) {
1617             for (std::pair<Temp, uint32_t> pair : ctx.spills_entry[block.index]) {
1619                if (ctx.interferences[pair.second].first.type() == RegType::sgpr &&
1620                    slots[pair.second] / ctx.wave_size == i) {

Indexes created Wed Dec 10 04:09:55 GMT 2025