MetaRenamer.cpp Source File (original) (raw)

36using namespace llvm;

39 "rename-exclude-function-prefixes",

40 cl::desc("Prefixes for functions that don't need to be renamed, separated "

41 "by a comma"),

45 "rename-exclude-alias-prefixes",

46 cl::desc("Prefixes for aliases that don't need to be renamed, separated "

47 "by a comma"),

51 "rename-exclude-global-prefixes",

53 "Prefixes for global values that don't need to be renamed, separated "

54 "by a comma"),

58 "rename-exclude-struct-prefixes",

59 cl::desc("Prefixes for structs that don't need to be renamed, separated "

60 "by a comma"),

65 cl::desc("only rename the instructions in the function"),

70 "foo", "bar", "baz", "quux", "barney", "snork", "zot", "blam", "hoge",

71 "wibble", "wobble", "widget", "wombat", "ham", "eggs", "pluto", "spam"

72};

74namespace {

78struct PRNG {

79 unsigned long next;

81 void srand(unsigned int seed) { next = seed; }

83 int rand() {

84 next = next * 1103515245 + 12345;

85 return (unsigned int)(next / 65536) % 32768;

86 }

87};

89struct Renamer {

90 Renamer(unsigned int seed) { prng.srand(seed); }

92 const char *newName() {

94 }

96 PRNG prng;

97};

99static void

100parseExcludedPrefixes(StringRef PrefixesStr,

102 for (;;) {

103 auto PrefixesSplit = PrefixesStr.split(',');

104 if (PrefixesSplit.first.empty())

105 break;

106 ExcludedPrefixes.push_back(PrefixesSplit.first);

107 PrefixesStr = PrefixesSplit.second;

108 }

109}

110

111void MetaRenameOnlyInstructions(Function &F) {

113 if (.getType()->isVoidTy() && I.getName().empty())

114 I.setName(I.getOpcodeName());

115}

116

119 if (!Arg.getType()->isVoidTy())

120 Arg.setName("arg");

121

122 for (auto &BB : F) {

123 BB.setName("bb");

124

125 for (auto &I : BB)

126 if (.getType()->isVoidTy())

127 I.setName(I.getOpcodeName());

128 }

129}

130

131void MetaRename(Module &M,

133

134

135

136 unsigned int randSeed = 0;

137 for (auto C : M.getModuleIdentifier())

138 randSeed += C;

139

140 Renamer renamer(randSeed);

141

150

153 return any_of(ExcludedPrefixes,

154 [&Name](auto &Prefix) { return Name.starts_with(Prefix); });

155 };

156

157

158

159 auto ExcludeLibFuncs = [&](Function &F) {

160 LibFunc Tmp;

162 return F.isIntrinsic() || ( Name .empty() && Name[0] == 1) ||

163 GetTLI(F).getLibFunc(F, Tmp) ||

164 IsNameExcluded(Name, ExcludedFuncPrefixes);

165 };

166

168

169 for (auto &F : M) {

170 if (ExcludeLibFuncs(F))

171 continue;

172 MetaRenameOnlyInstructions(F);

173 }

174 return;

175 }

176

177

180 if (Name.starts_with("llvm.") || ( Name .empty() && Name[0] == 1) ||

181 IsNameExcluded(Name, ExcludedAliasesPrefixes))

182 continue;

183

184 GA.setName("alias");

185 }

186

187

190 if (Name.starts_with("llvm.") || ( Name .empty() && Name[0] == 1) ||

191 IsNameExcluded(Name, ExcludedGlobalsPrefixes))

192 continue;

193

194 GV.setName("global");

195 }

196

197

199 StructTypes.run(M, true);

200 for (StructType *STy : StructTypes) {

202 if (STy->isLiteral() || Name.empty() ||

203 IsNameExcluded(Name, ExcludedStructsPrefixes))

204 continue;

205

207 STy->setName(

208 (Twine("struct.") + renamer.newName()).toStringRef(NameStorage));

209 }

210

211

212 for (auto &F : M) {

213 if (ExcludeLibFuncs(F))

214 continue;

215

216

217

218 if (F.getName() != "main")

219 F.setName(renamer.newName());

220

221 MetaRename(F);

222 }

223}

224

225}

226

232 };

233 MetaRename(M, GetTLI);

234

236}

Expand Atomic instructions

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

This header defines various interfaces for pass management in LLVM.

FunctionAnalysisManager FAM

This file defines the SmallString class.

This file defines the SmallVector class.

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

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

This class represents an incoming formal argument to a Function.

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

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.

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

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

std::pair< StringRef, StringRef > split(char Separator) const

Split into two substrings around the first occurrence of a separator character.

Class to represent struct types.

Analysis pass providing the TargetLibraryInfo.

Provides information about what library functions are available for the current target.

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

TypeFinder - Walk over a module, identifying all of the types that are used by the module.

void run(const Module &M, bool onlyNamed)

An efficient, type-erasing, non-owning reference to a callable.

@ C

The default llvm calling convention, compatible with C.

initializer< Ty > init(const Ty &Val)

This is an optimization pass for GlobalISel generic memory operations.

InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy

Provide the FunctionAnalysisManager to Module proxy.

bool any_of(R &&range, UnaryPredicate P)

Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

AnalysisManager< Module > ModuleAnalysisManager

Convenience typedef for the Module analysis manager.