OptimizePHIs.cpp Source File (original) (raw)

25#include

27using namespace llvm;

29#define DEBUG_TYPE "opt-phis"

31 STATISTIC(NumPHICycles, "Number of PHI cycles replaced");

32 STATISTIC(NumDeadPHICycles, "Number of dead PHI cycles");

34namespace {

36class OptimizePHIs {

40public:

43private:

48 InstrSet &PHIsInCycle);

49 bool IsDeadPHICycle(MachineInstr *MI, InstrSet &PHIsInCycle);

51};

54public:

55 static char ID;

56 OptimizePHIsLegacy() : MachineFunctionPass(ID) {

58 }

60 bool runOnMachineFunction(MachineFunction &MF) override {

62 return false;

63 OptimizePHIs OP;

64 return OP.run(MF);

65 }

67 void getAnalysisUsage(AnalysisUsage &AU) const override {

70 }

71};

72}

74char OptimizePHIsLegacy::ID = 0;

79 "Optimize machine instruction PHIs", false, false)

83 OptimizePHIs OP;

84 if (.run(MF))

88 return PA;

89}

100 for (MachineBasicBlock &MBB : Fn)

102

104}

105

106

107

108

109

110

111bool OptimizePHIs::IsSingleValuePHICycle(MachineInstr *MI,

113 InstrSet &PHIsInCycle) {

114 assert(MI->isPHI() && "IsSingleValuePHICycle expects a PHI instruction");

115 Register DstReg = MI->getOperand(0).getReg();

116

117

118 if (!PHIsInCycle.insert(MI).second)

119 return true;

120

121

122 if (PHIsInCycle.size() == 16)

123 return false;

124

125

126 for (unsigned i = 1; i != MI->getNumOperands(); i += 2) {

127 Register SrcReg = MI->getOperand(i).getReg();

128 if (SrcReg == DstReg)

129 continue;

130 MachineInstr *SrcMI = MRI->getVRegDef(SrcReg);

131

132

137 SrcMI = MRI->getVRegDef(SrcReg);

138 }

139 if (!SrcMI)

140 return false;

141

142 if (SrcMI->isPHI()) {

143 if (!IsSingleValuePHICycle(SrcMI, SingleValReg, PHIsInCycle))

144 return false;

145 } else {

146

147 if (SingleValReg && SingleValReg != SrcReg)

148 return false;

149 SingleValReg = SrcReg;

150 }

151 }

152 return true;

153}

154

155

156

157bool OptimizePHIs::IsDeadPHICycle(MachineInstr *MI, InstrSet &PHIsInCycle) {

158 assert(MI->isPHI() && "IsDeadPHICycle expects a PHI instruction");

159 Register DstReg = MI->getOperand(0).getReg();

160 assert(DstReg.isVirtual() && "PHI destination is not a virtual register");

161

162

163 if (!PHIsInCycle.insert(MI).second)

164 return true;

165

166

167 if (PHIsInCycle.size() == 16)

168 return false;

169

170 for (MachineInstr &UseMI : MRI->use_nodbg_instructions(DstReg)) {

171 if ( UseMI .isPHI() || !IsDeadPHICycle(&UseMI, PHIsInCycle))

172 return false;

173 }

174

175 return true;

176}

177

178

179

180bool OptimizePHIs::OptimizeBB(MachineBasicBlock &MBB) {

184 MachineInstr *MI = &*MII++;

185 if (->isPHI())

186 break;

187

188

190 InstrSet PHIsInCycle;

191 if (IsSingleValuePHICycle(MI, SingleValReg, PHIsInCycle) && SingleValReg) {

192 Register OldReg = MI->getOperand(0).getReg();

193 if ( MRI ->constrainRegClass(SingleValReg, MRI->getRegClass(OldReg)))

194 continue;

195

196 MRI->replaceRegWith(OldReg, SingleValReg);

197 MI->eraseFromParent();

198

199

200 MRI->clearKillFlags(SingleValReg);

201

202 ++NumPHICycles;

204 continue;

205 }

206

207

208 PHIsInCycle.clear();

209 if (IsDeadPHICycle(MI, PHIsInCycle)) {

210 for (MachineInstr *PhiMI : PHIsInCycle) {

211 if (MII == PhiMI)

212 ++MII;

213 PhiMI->eraseFromParent();

214 }

215 ++NumDeadPHICycles;

217 }

218 }

220}

unsigned const MachineRegisterInfo * MRI

MachineInstrBuilder & UseMI

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

const TargetInstrInfo & TII

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

Promote Memory to Register

#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)

This file defines the SmallPtrSet class.

This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...

#define STATISTIC(VARNAME, DESC)

LLVM_ABI void setPreservesCFG()

This function should be called by the pass, iff they do not:

Represents analyses that only rely on functions' control flow.

MachineInstrBundleIterator< MachineInstr > iterator

MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

const TargetSubtargetInfo & getSubtarget() const

getSubtarget - Return the subtarget for which this machine code is being compiled.

MachineRegisterInfo & getRegInfo()

getRegInfo - Return information about the registers currently in use.

Function & getFunction()

Return the LLVM function that this machine code represents.

Representation of each machine instruction.

const MachineOperand & getOperand(unsigned i) const

unsigned getSubReg() const

getReg - Returns the register number.

MachineRegisterInfo - Keep track of information for virtual and physical registers,...

static LLVM_ABI PassRegistry * getPassRegistry()

getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...

A set of analyses that are preserved following a run of a transformation pass.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

Wrapper class representing virtual and physical registers.

constexpr bool isVirtual() const

Return true if the specified register number is in the virtual register namespace.

SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

TargetInstrInfo - Interface to description of machine instruction set.

virtual const TargetInstrInfo * getInstrInfo() const

This is an optimization pass for GlobalISel generic memory operations.

AnalysisManager< MachineFunction > MachineFunctionAnalysisManager

LLVM_ABI void initializeOptimizePHIsLegacyPass(PassRegistry &)

LLVM_ABI PreservedAnalyses getMachineFunctionPassPreservedAnalyses()

Returns the minimum set of Analyses that all machine function passes must preserve.

LLVM_ABI char & OptimizePHIsLegacyID

OptimizePHIs - This pass optimizes machine instruction PHIs to take advantage of opportunities create...

Definition OptimizePHIs.cpp:76