StaticDataSplitter.cpp Source File (original) (raw)

35using namespace llvm;

37#define DEBUG_TYPE "static-data-splitter"

39 STATISTIC(NumHotJumpTables, "Number of hot jump tables seen.");

40 STATISTIC(NumColdJumpTables, "Number of cold jump tables seen.");

42 "Number of jump tables with unknown hotness. They are from functions "

43 "without profile information.");

65 bool partitionStaticDataWithProfiles(MachineFunction &MF);

71 void updateStatsWithoutProfiles(const MachineFunction &MF);

73 void annotateStaticDataWithoutProfiles(const MachineFunction &MF);

75public:

76 static char ID;

98};

104

106 .getStaticDataProfileInfo();

107

108 const bool ProfileAvailable = PSI && PSI->hasProfileSummary() && MBFI &&

110

111 if (!ProfileAvailable) {

112 annotateStaticDataWithoutProfiles(MF);

113 updateStatsWithoutProfiles(MF);

114 return false;

115 }

116

117 bool Changed = partitionStaticDataWithProfiles(MF);

118

119 updateStatsWithProfiles(MF);

121}

122

127 if (.isGlobal() && .isCPI())

128 return nullptr;

129

130 if (Op.isGlobal()) {

131

132 const GlobalVariable *GV = getLocalLinkageGlobalVariable(Op.getGlobal());

133

135 !inStaticDataSection(*GV, TM))

136 return nullptr;

137 return GV;

138 }

139 assert(Op.isCPI() && "Op must be constant pool index in this branch");

140 int CPI = Op.getIndex();

141 if (CPI == -1)

142 return nullptr;

143

144 assert(MCP != nullptr && "Constant pool info is not available.");

145 const MachineConstantPoolEntry &CPE = MCP->getConstants()[CPI];

146

148 return nullptr;

149

151}

152

153bool StaticDataSplitter::partitionStaticDataWithProfiles(MachineFunction &MF) {

154

155

156

157

158

159

160

161

163

165

166

167

168

169

170

171 for (const auto &MBB : MF) {

172 std::optional<uint64_t> Count = MBFI->getBlockProfileCount(&MBB);

173 for (const MachineInstr &I : MBB) {

174 for (const MachineOperand &Op : I.operands()) {

175 if (.isJTI() && .isGlobal() && .isCPI())

176 continue;

177

178 if (Op.isJTI()) {

179 assert(MJTI != nullptr && "Jump table info is not available.");

180 const int JTI = Op.getIndex();

181

182 if (JTI == -1)

183 continue;

184

185 auto Hotness = MachineFunctionDataHotness::Hot;

186

187

188

189

190 if (Count && PSI->isColdCount(*Count))

191 Hotness = MachineFunctionDataHotness::Cold;

192

194 } else if (const Constant *C =

195 getConstant(Op, MF.getTarget(), MF.getConstantPool())) {

196 SDPI->addConstantProfileCount(C, Count);

198 }

199 }

200 }

201 }

203}

204

206StaticDataSplitter::getLocalLinkageGlobalVariable(const GlobalValue *GV) {

207

208

209

211}

212

213bool StaticDataSplitter::inStaticDataSection(const GlobalVariable &GV,

215

217 return Kind.isData() || Kind.isReadOnly() || Kind.isReadOnlyWithRel() ||

218 Kind.isBSS();

219}

220

221void StaticDataSplitter::updateStatsWithProfiles(const MachineFunction &MF) {

223 return;

224

225 if (const MachineJumpTableInfo *MJTI = MF.getJumpTableInfo()) {

226 for (const auto &JumpTable : MJTI->getJumpTables()) {

227 if (JumpTable.Hotness == MachineFunctionDataHotness::Hot) {

228 ++NumHotJumpTables;

229 } else {

230 assert(JumpTable.Hotness == MachineFunctionDataHotness::Cold &&

231 "A jump table is either hot or cold when profile information is "

232 "available.");

233 ++NumColdJumpTables;

234 }

235 }

236 }

237}

238

239void StaticDataSplitter::annotateStaticDataWithoutProfiles(

241 for (const auto &MBB : MF)

242 for (const MachineInstr &I : MBB)

243 for (const MachineOperand &Op : I.operands())

244 if (const Constant *C =

245 getConstant(Op, MF.getTarget(), MF.getConstantPool()))

246 SDPI->addConstantProfileCount(C, std::nullopt);

247}

248

249void StaticDataSplitter::updateStatsWithoutProfiles(const MachineFunction &MF) {

251 return;

252

253 if (const MachineJumpTableInfo *MJTI = MF.getJumpTableInfo()) {

254 NumUnknownJumpTables += MJTI->getJumpTables().size();

255 }

256}

257

259

261 false, false)

268

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

This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...

#define INITIALIZE_PASS_DEPENDENCY(depName)

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

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

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

#define STATISTIC(VARNAME, DESC)

StaticDataSplitter()

Definition StaticDataSplitter.cpp:78

static char ID

Definition StaticDataSplitter.cpp:76

StringRef getPassName() const override

getPassName - Return a nice clean name for a pass.

Definition StaticDataSplitter.cpp:82

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

Definition StaticDataSplitter.cpp:84

bool runOnMachineFunction(MachineFunction &MF) override

runOnMachineFunction - This method must be overloaded to perform the desired machine code transformat...

Definition StaticDataSplitter.cpp:100

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

void setPreservesAll()

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

This is an important base class in LLVM.

bool hasProfileData(bool IncludeSynthetic=false) const

Return true if the function is annotated with profile data.

bool hasLocalLinkage() const

MachineBlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate machine basic b...

union llvm::MachineConstantPoolEntry::@004270020304201266316354007027341142157160323045 Val

The constant itself.

bool isMachineConstantPoolEntry() const

isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry is indeed a target specific ...

const Constant * ConstVal

The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...

const std::vector< MachineConstantPoolEntry > & getConstants() const

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

MachineFunctionPass(char &ID)

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

Function & getFunction()

Return the LLVM function that this machine code represents.

const MachineJumpTableInfo * getJumpTableInfo() const

getJumpTableInfo - Return the jump table info object for the current function.

LLVM_ABI bool updateJumpTableEntryHotness(size_t JTI, MachineFunctionDataHotness Hotness)

const std::vector< MachineJumpTableEntry > & getJumpTables() const

MachineOperand class - Representation of each machine instruction operand.

static LLVM_ABI PassRegistry * getPassRegistry()

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

AnalysisType & getAnalysis() const

getAnalysis() - This function is used by subclasses to get to the analysis information ...

An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.

Analysis providing profile information.

This wraps the StaticDataProfileInfo object as an immutable pass, for a backend pass to operate on.

A class that holds the constants that represent static data and their profile information and provide...

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

static SectionKind getKindForGlobal(const GlobalObject *GO, const TargetMachine &TM)

Classify the specified global variable into a set of target independent categories embodied in Sectio...

Primary interface to the complete machine description for the target machine.

@ C

The default llvm calling convention, compatible with C.

bool IsAnnotationOK(const GlobalVariable &GV)

Returns true if the annotation kind of the global variable GV is AnnotationOK.

This is an optimization pass for GlobalISel generic memory operations.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

LLVM_ABI void initializeStaticDataSplitterPass(PassRegistry &)

LLVM_ABI MachineFunctionPass * createStaticDataSplitterPass()

createStaticDataSplitterPass - This is a machine-function pass that categorizes static data hotness u...

Definition StaticDataSplitter.cpp:269

FunctionAddr VTableAddr Count

LLVM_ABI bool AreStatisticsEnabled()

Check if statistics are enabled.

DWARFExpression::Operation Op