1//===- llvm/CodeGen/CriticalAntiDepBreaker.h - Anti-Dep Support -*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the CriticalAntiDepBreaker class, which
10// implements register anti-dependence breaking along a blocks
11// critical path during post-RA scheduler.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_LIB_CODEGEN_CRITICALANTIDEPBREAKER_H
16#define LLVM_LIB_CODEGEN_CRITICALANTIDEPBREAKER_H
17
18#include "AntiDepBreaker.h"
19#include "llvm/ADT/BitVector.h"
20#include "llvm/Support/Compiler.h"
21#include <map>
22#include <vector>
23
24namespace llvm {
25
26class MachineBasicBlock;
27class MachineFunction;
28class MachineInstr;
29class MachineOperand;
30class MachineRegisterInfo;
31class RegisterClassInfo;
32class TargetInstrInfo;
33class TargetRegisterClass;
34class TargetRegisterInfo;
35
36class LLVM_LIBRARY_VISIBILITY CriticalAntiDepBreaker : public AntiDepBreaker {
37    MachineFunction& MF;
38    MachineRegisterInfo &MRI;
39    const TargetInstrInfo *TII;
40    const TargetRegisterInfo *TRI;
41    const RegisterClassInfo &RegClassInfo;
42
43    /// The set of allocatable registers.
44    /// We'll be ignoring anti-dependencies on non-allocatable registers,
45    /// because they may not be safe to break.
46    const BitVector AllocatableSet;
47
48    /// For live regs that are only used in one register class in a
49    /// live range, the register class. If the register is not live, the
50    /// corresponding value is null. If the register is live but used in
51    /// multiple register classes, the corresponding value is -1 casted to a
52    /// pointer.
53    std::vector<const TargetRegisterClass *> Classes;
54
55    /// Map registers to all their references within a live range.
56    std::multimap<unsigned, MachineOperand *> RegRefs;
57
58    using RegRefIter =
59        std::multimap<unsigned, MachineOperand *>::const_iterator;
60
61    /// The index of the most recent kill (proceeding bottom-up),
62    /// or ~0u if the register is not live.
63    std::vector<unsigned> KillIndices;
64
65    /// The index of the most recent complete def (proceeding
66    /// bottom up), or ~0u if the register is live.
67    std::vector<unsigned> DefIndices;
68
69    /// A set of registers which are live and cannot be changed to
70    /// break anti-dependencies.
71    BitVector KeepRegs;
72
73  public:
74    CriticalAntiDepBreaker(MachineFunction& MFi, const RegisterClassInfo &RCI);
75    ~CriticalAntiDepBreaker() override;
76
77    /// Initialize anti-dep breaking for a new basic block.
78    void StartBlock(MachineBasicBlock *BB) override;
79
80    /// Identifiy anti-dependencies along the critical path
81    /// of the ScheduleDAG and break them by renaming registers.
82    unsigned BreakAntiDependencies(const std::vector<SUnit> &SUnits,
83                                   MachineBasicBlock::iterator Begin,
84                                   MachineBasicBlock::iterator End,
85                                   unsigned InsertPosIndex,
86                                   DbgValueVector &DbgValues) override;
87
88    /// Update liveness information to account for the current
89    /// instruction, which will not be scheduled.
90    void Observe(MachineInstr &MI, unsigned Count,
91                 unsigned InsertPosIndex) override;
92
93    /// Finish anti-dep breaking for a basic block.
94    void FinishBlock() override;
95
96  private:
97    void PrescanInstruction(MachineInstr &MI);
98    void ScanInstruction(MachineInstr &MI, unsigned Count);
99    bool isNewRegClobberedByRefs(RegRefIter RegRefBegin,
100                                 RegRefIter RegRefEnd,
101                                 unsigned NewReg);
102    unsigned findSuitableFreeRegister(RegRefIter RegRefBegin,
103                                      RegRefIter RegRefEnd,
104                                      unsigned AntiDepReg,
105                                      unsigned LastNewReg,
106                                      const TargetRegisterClass *RC,
107                                      SmallVectorImpl<unsigned> &Forbid);
108  };
109
110} // end namespace llvm
111
112#endif // LLVM_LIB_CODEGEN_CRITICALANTIDEPBREAKER_H
113