SymbolRewriter.cpp [plain text]
#define DEBUG_TYPE "symbol-rewriter"
#include "llvm/CodeGen/Passes.h"
#include "llvm/Pass.h"
#include "llvm/PassManager.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Regex.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/YAMLParser.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"
#include "llvm/Transforms/Utils/SymbolRewriter.h"
using namespace llvm;
static cl::list<std::string> RewriteMapFiles("rewrite-map-file",
cl::desc("Symbol Rewrite Map"),
cl::value_desc("filename"));
namespace llvm {
namespace SymbolRewriter {
void rewriteComdat(Module &M, GlobalObject *GO, const std::string &Source,
const std::string &Target) {
if (Comdat *CD = GO->getComdat()) {
auto &Comdats = M.getComdatSymbolTable();
Comdat *C = M.getOrInsertComdat(Target);
C->setSelectionKind(CD->getSelectionKind());
GO->setComdat(C);
Comdats.erase(Comdats.find(Source));
}
}
template <RewriteDescriptor::Type DT, typename ValueType,
ValueType *(llvm::Module::*Get)(StringRef) const>
class ExplicitRewriteDescriptor : public RewriteDescriptor {
public:
const std::string Source;
const std::string Target;
ExplicitRewriteDescriptor(StringRef S, StringRef T, const bool Naked)
: RewriteDescriptor(DT), Source(Naked ? StringRef("\01" + S.str()) : S),
Target(T) {}
bool performOnModule(Module &M) override;
static bool classof(const RewriteDescriptor *RD) {
return RD->getType() == DT;
}
};
template <RewriteDescriptor::Type DT, typename ValueType,
ValueType *(llvm::Module::*Get)(StringRef) const>
bool ExplicitRewriteDescriptor<DT, ValueType, Get>::performOnModule(Module &M) {
bool Changed = false;
if (ValueType *S = (M.*Get)(Source)) {
if (GlobalObject *GO = dyn_cast<GlobalObject>(S))
rewriteComdat(M, GO, Source, Target);
if (Value *T = (M.*Get)(Target))
S->setValueName(T->getValueName());
else
S->setName(Target);
Changed = true;
}
return Changed;
}
template <RewriteDescriptor::Type DT, typename ValueType,
ValueType *(llvm::Module::*Get)(StringRef) const,
iterator_range<typename iplist<ValueType>::iterator>
(llvm::Module::*Iterator)()>
class PatternRewriteDescriptor : public RewriteDescriptor {
public:
const std::string Pattern;
const std::string Transform;
PatternRewriteDescriptor(StringRef P, StringRef T)
: RewriteDescriptor(DT), Pattern(P), Transform(T) { }
bool performOnModule(Module &M) override;
static bool classof(const RewriteDescriptor *RD) {
return RD->getType() == DT;
}
};
template <RewriteDescriptor::Type DT, typename ValueType,
ValueType *(llvm::Module::*Get)(StringRef) const,
iterator_range<typename iplist<ValueType>::iterator>
(llvm::Module::*Iterator)()>
bool PatternRewriteDescriptor<DT, ValueType, Get, Iterator>::
performOnModule(Module &M) {
bool Changed = false;
for (auto &C : (M.*Iterator)()) {
std::string Error;
std::string Name = Regex(Pattern).sub(Transform, C.getName(), &Error);
if (!Error.empty())
report_fatal_error("unable to transforn " + C.getName() + " in " +
M.getModuleIdentifier() + ": " + Error);
if (C.getName() == Name)
continue;
if (GlobalObject *GO = dyn_cast<GlobalObject>(&C))
rewriteComdat(M, GO, C.getName(), Name);
if (Value *V = (M.*Get)(Name))
C.setValueName(V->getValueName());
else
C.setName(Name);
Changed = true;
}
return Changed;
}
typedef ExplicitRewriteDescriptor<RewriteDescriptor::Type::Function,
llvm::Function, &llvm::Module::getFunction>
ExplicitRewriteFunctionDescriptor;
typedef ExplicitRewriteDescriptor<RewriteDescriptor::Type::GlobalVariable,
llvm::GlobalVariable,
&llvm::Module::getGlobalVariable>
ExplicitRewriteGlobalVariableDescriptor;
typedef ExplicitRewriteDescriptor<RewriteDescriptor::Type::NamedAlias,
llvm::GlobalAlias,
&llvm::Module::getNamedAlias>
ExplicitRewriteNamedAliasDescriptor;
typedef PatternRewriteDescriptor<RewriteDescriptor::Type::Function,
llvm::Function, &llvm::Module::getFunction,
&llvm::Module::functions>
PatternRewriteFunctionDescriptor;
typedef PatternRewriteDescriptor<RewriteDescriptor::Type::GlobalVariable,
llvm::GlobalVariable,
&llvm::Module::getGlobalVariable,
&llvm::Module::globals>
PatternRewriteGlobalVariableDescriptor;
typedef PatternRewriteDescriptor<RewriteDescriptor::Type::NamedAlias,
llvm::GlobalAlias,
&llvm::Module::getNamedAlias,
&llvm::Module::aliases>
PatternRewriteNamedAliasDescriptor;
bool RewriteMapParser::parse(const std::string &MapFile,
RewriteDescriptorList *DL) {
ErrorOr<std::unique_ptr<MemoryBuffer>> Mapping =
MemoryBuffer::getFile(MapFile);
if (!Mapping)
report_fatal_error("unable to read rewrite map '" + MapFile + "': " +
Mapping.getError().message());
if (!parse(*Mapping, DL))
report_fatal_error("unable to parse rewrite map '" + MapFile + "'");
return true;
}
bool RewriteMapParser::parse(std::unique_ptr<MemoryBuffer> &MapFile,
RewriteDescriptorList *DL) {
SourceMgr SM;
yaml::Stream YS(MapFile->getBuffer(), SM);
for (auto &Document : YS) {
yaml::MappingNode *DescriptorList;
if (isa<yaml::NullNode>(Document.getRoot()))
continue;
DescriptorList = dyn_cast<yaml::MappingNode>(Document.getRoot());
if (!DescriptorList) {
YS.printError(Document.getRoot(), "DescriptorList node must be a map");
return false;
}
for (auto &Descriptor : *DescriptorList)
if (!parseEntry(YS, Descriptor, DL))
return false;
}
return true;
}
bool RewriteMapParser::parseEntry(yaml::Stream &YS, yaml::KeyValueNode &Entry,
RewriteDescriptorList *DL) {
yaml::ScalarNode *Key;
yaml::MappingNode *Value;
SmallString<32> KeyStorage;
StringRef RewriteType;
Key = dyn_cast<yaml::ScalarNode>(Entry.getKey());
if (!Key) {
YS.printError(Entry.getKey(), "rewrite type must be a scalar");
return false;
}
Value = dyn_cast<yaml::MappingNode>(Entry.getValue());
if (!Value) {
YS.printError(Entry.getValue(), "rewrite descriptor must be a map");
return false;
}
RewriteType = Key->getValue(KeyStorage);
if (RewriteType.equals("function"))
return parseRewriteFunctionDescriptor(YS, Key, Value, DL);
else if (RewriteType.equals("global variable"))
return parseRewriteGlobalVariableDescriptor(YS, Key, Value, DL);
else if (RewriteType.equals("global alias"))
return parseRewriteGlobalAliasDescriptor(YS, Key, Value, DL);
YS.printError(Entry.getKey(), "unknown rewrite type");
return false;
}
bool RewriteMapParser::
parseRewriteFunctionDescriptor(yaml::Stream &YS, yaml::ScalarNode *K,
yaml::MappingNode *Descriptor,
RewriteDescriptorList *DL) {
bool Naked = false;
std::string Source;
std::string Target;
std::string Transform;
for (auto &Field : *Descriptor) {
yaml::ScalarNode *Key;
yaml::ScalarNode *Value;
SmallString<32> KeyStorage;
SmallString<32> ValueStorage;
StringRef KeyValue;
Key = dyn_cast<yaml::ScalarNode>(Field.getKey());
if (!Key) {
YS.printError(Field.getKey(), "descriptor key must be a scalar");
return false;
}
Value = dyn_cast<yaml::ScalarNode>(Field.getValue());
if (!Value) {
YS.printError(Field.getValue(), "descriptor value must be a scalar");
return false;
}
KeyValue = Key->getValue(KeyStorage);
if (KeyValue.equals("source")) {
std::string Error;
Source = Value->getValue(ValueStorage);
if (!Regex(Source).isValid(Error)) {
YS.printError(Field.getKey(), "invalid regex: " + Error);
return false;
}
} else if (KeyValue.equals("target")) {
Target = Value->getValue(ValueStorage);
} else if (KeyValue.equals("transform")) {
Transform = Value->getValue(ValueStorage);
} else if (KeyValue.equals("naked")) {
std::string Undecorated;
Undecorated = Value->getValue(ValueStorage);
Naked = StringRef(Undecorated).lower() == "true" || Undecorated == "1";
} else {
YS.printError(Field.getKey(), "unknown key for function");
return false;
}
}
if (Transform.empty() == Target.empty()) {
YS.printError(Descriptor,
"exactly one of transform or target must be specified");
return false;
}
if (!Target.empty())
DL->push_back(new ExplicitRewriteFunctionDescriptor(Source, Target, Naked));
else
DL->push_back(new PatternRewriteFunctionDescriptor(Source, Transform));
return true;
}
bool RewriteMapParser::
parseRewriteGlobalVariableDescriptor(yaml::Stream &YS, yaml::ScalarNode *K,
yaml::MappingNode *Descriptor,
RewriteDescriptorList *DL) {
std::string Source;
std::string Target;
std::string Transform;
for (auto &Field : *Descriptor) {
yaml::ScalarNode *Key;
yaml::ScalarNode *Value;
SmallString<32> KeyStorage;
SmallString<32> ValueStorage;
StringRef KeyValue;
Key = dyn_cast<yaml::ScalarNode>(Field.getKey());
if (!Key) {
YS.printError(Field.getKey(), "descriptor Key must be a scalar");
return false;
}
Value = dyn_cast<yaml::ScalarNode>(Field.getValue());
if (!Value) {
YS.printError(Field.getValue(), "descriptor value must be a scalar");
return false;
}
KeyValue = Key->getValue(KeyStorage);
if (KeyValue.equals("source")) {
std::string Error;
Source = Value->getValue(ValueStorage);
if (!Regex(Source).isValid(Error)) {
YS.printError(Field.getKey(), "invalid regex: " + Error);
return false;
}
} else if (KeyValue.equals("target")) {
Target = Value->getValue(ValueStorage);
} else if (KeyValue.equals("transform")) {
Transform = Value->getValue(ValueStorage);
} else {
YS.printError(Field.getKey(), "unknown Key for Global Variable");
return false;
}
}
if (Transform.empty() == Target.empty()) {
YS.printError(Descriptor,
"exactly one of transform or target must be specified");
return false;
}
if (!Target.empty())
DL->push_back(new ExplicitRewriteGlobalVariableDescriptor(Source, Target,
false));
else
DL->push_back(new PatternRewriteGlobalVariableDescriptor(Source,
Transform));
return true;
}
bool RewriteMapParser::
parseRewriteGlobalAliasDescriptor(yaml::Stream &YS, yaml::ScalarNode *K,
yaml::MappingNode *Descriptor,
RewriteDescriptorList *DL) {
std::string Source;
std::string Target;
std::string Transform;
for (auto &Field : *Descriptor) {
yaml::ScalarNode *Key;
yaml::ScalarNode *Value;
SmallString<32> KeyStorage;
SmallString<32> ValueStorage;
StringRef KeyValue;
Key = dyn_cast<yaml::ScalarNode>(Field.getKey());
if (!Key) {
YS.printError(Field.getKey(), "descriptor key must be a scalar");
return false;
}
Value = dyn_cast<yaml::ScalarNode>(Field.getValue());
if (!Value) {
YS.printError(Field.getValue(), "descriptor value must be a scalar");
return false;
}
KeyValue = Key->getValue(KeyStorage);
if (KeyValue.equals("source")) {
std::string Error;
Source = Value->getValue(ValueStorage);
if (!Regex(Source).isValid(Error)) {
YS.printError(Field.getKey(), "invalid regex: " + Error);
return false;
}
} else if (KeyValue.equals("target")) {
Target = Value->getValue(ValueStorage);
} else if (KeyValue.equals("transform")) {
Transform = Value->getValue(ValueStorage);
} else {
YS.printError(Field.getKey(), "unknown key for Global Alias");
return false;
}
}
if (Transform.empty() == Target.empty()) {
YS.printError(Descriptor,
"exactly one of transform or target must be specified");
return false;
}
if (!Target.empty())
DL->push_back(new ExplicitRewriteNamedAliasDescriptor(Source, Target,
false));
else
DL->push_back(new PatternRewriteNamedAliasDescriptor(Source, Transform));
return true;
}
}
}
namespace {
class RewriteSymbols : public ModulePass {
public:
static char ID;
RewriteSymbols();
RewriteSymbols(SymbolRewriter::RewriteDescriptorList &DL);
bool runOnModule(Module &M) override;
private:
void loadAndParseMapFiles();
SymbolRewriter::RewriteDescriptorList Descriptors;
};
char RewriteSymbols::ID = 0;
RewriteSymbols::RewriteSymbols() : ModulePass(ID) {
initializeRewriteSymbolsPass(*PassRegistry::getPassRegistry());
loadAndParseMapFiles();
}
RewriteSymbols::RewriteSymbols(SymbolRewriter::RewriteDescriptorList &DL)
: ModulePass(ID) {
Descriptors.splice(Descriptors.begin(), DL);
}
bool RewriteSymbols::runOnModule(Module &M) {
bool Changed;
Changed = false;
for (auto &Descriptor : Descriptors)
Changed |= Descriptor.performOnModule(M);
return Changed;
}
void RewriteSymbols::loadAndParseMapFiles() {
const std::vector<std::string> MapFiles(RewriteMapFiles);
SymbolRewriter::RewriteMapParser parser;
for (const auto &MapFile : MapFiles)
parser.parse(MapFile, &Descriptors);
}
}
INITIALIZE_PASS(RewriteSymbols, "rewrite-symbols", "Rewrite Symbols", false,
false)
ModulePass *llvm::createRewriteSymbolsPass() { return new RewriteSymbols(); }
ModulePass *
llvm::createRewriteSymbolsPass(SymbolRewriter::RewriteDescriptorList &DL) {
return new RewriteSymbols(DL);
}