RegUsageInfoPropagate.cpp Source File (original) (raw)

35using namespace llvm;

37#define DEBUG_TYPE "ip-regalloc"

39#define RUIP_NAME "Register Usage Information Propagation"

41namespace {

43class RegUsageInfoPropagation {

44public:

46 : PRUI(PRUI) {}

50private:

56 ->getRegInfo().getTargetRegisterInfo()

57 ->getNumRegs())

58 && "expected register mask size");

60 if (MO.isRegMask())

61 MO.setRegMask(RegMask.data());

62 }

63 }

64};

67public:

68 static char ID;

72 }

78 void getAnalysisUsage(AnalysisUsage &AU) const override {

82 }

83};

85}

93char RegUsageInfoPropagationLegacy::ID = 0;

99 if (MO.isGlobal())

100 return dyn_cast(MO.getGlobal());

101

102 if (MO.isSymbol())

103 return M.getFunction(MO.getSymbolName());

104 }

105

106 return nullptr;

107}

108

109bool RegUsageInfoPropagationLegacy::runOnMachineFunction(MachineFunction &MF) {

110 PhysicalRegisterUsageInfo *PRUI =

111 &getAnalysis().getPRUI();

112

113 RegUsageInfoPropagation RUIP(PRUI);

114 return RUIP.run(MF);

115}

116

117PreservedAnalyses

122 .getCachedResult(MFA);

123 assert(PRUI && "PhysicalRegisterUsageAnalysis not available");

124 RegUsageInfoPropagation(PRUI).run(MF);

126}

127

130

132 << " ++++++++++++++++++++ \n");

134

137 return false;

138

140

143 if (.isCall())

144 continue;

147 << "Call Instruction Before Register Usage Info Propagation : \n"

148 << MI << "\n");

149

150 auto UpdateRegMask = [&](const Function &F) {

152 if (RegMask.empty())

153 return;

154 setRegMask(MI, RegMask);

156 };

157

159 if (F->isDefinitionExact()) {

160 UpdateRegMask(*F);

161 } else {

162 LLVM_DEBUG(dbgs() << "Function definition is not exact\n");

163 }

164 } else {

165 LLVM_DEBUG(dbgs() << "Failed to find call target function\n");

166 }

167

170 << "Call Instruction After Register Usage Info Propagation : \n"

171 << MI << '\n');

172 }

173 }

174

176 dbgs() << " +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"

177 "++++++ \n");

179}

180

182 return new RegUsageInfoPropagationLegacy();

183}

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

Module.h This file contains the declarations for the Module class.

#define INITIALIZE_PASS_DEPENDENCY(depName)

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

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

#define RUIP_NAME

Definition RegUsageInfoPropagate.cpp:39

static const Function * findCalledFunction(const Module &M, const MachineInstr &MI)

Definition RegUsageInfoPropagate.cpp:96

This pass is required to take advantage of the interprocedural register allocation infrastructure.

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

void setPreservesAll()

Set by analyses that do not transform their input at all.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

size_t size() const

size - Get the array size.

bool empty() const

empty - Check if the array is empty.

FunctionPass class - This class is used to implement most global optimizations.

Module * getParent()

Get the module that this global value is contained inside of...

The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.

bool hasCalls() const

Return true if the current function has any function calls.

bool hasTailCall() const

Returns true if the function contains a tail call.

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.

StringRef getName() const

getName - Return the name of the corresponding LLVM function.

MachineFrameInfo & getFrameInfo()

getFrameInfo - Return the frame info object for the current function.

Function & getFunction()

Return the LLVM function that this machine code represents.

Representation of each machine instruction.

MachineOperand class - Representation of each machine instruction operand.

static unsigned getRegMaskSize(unsigned NumRegs)

Returns number of elements needed for a regmask array.

A Module instance is used to store all the information related to an LLVM module.

PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...

static LLVM_ABI PassRegistry * getPassRegistry()

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

ArrayRef< uint32_t > getRegUsageInfo(const Function &FP)

To query stored RegMask for given Function *, it will returns ane empty array if function is not know...

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)

Definition RegUsageInfoPropagate.cpp:118

A global registry used in conjunction with static constructors to make pluggable components (like tar...

StringRef - Represent a constant reference to a string, i.e.

Pass manager infrastructure for declaring and invalidating analyses.

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

This is an optimization pass for GlobalISel generic memory operations.

OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy

Provide the ModuleAnalysisManager to Function proxy.

AnalysisManager< MachineFunction > MachineFunctionAnalysisManager

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

LLVM_ABI FunctionPass * createRegUsageInfoPropPass()

Return a MachineFunction pass that identifies call sites and propagates register usage information of...

Definition RegUsageInfoPropagate.cpp:181

LLVM_ABI void initializeRegUsageInfoPropagationLegacyPass(PassRegistry &)