maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[MetaRenamer][NewPM] Port metarenamer to NPM 

Reviewed By: asbirlea

Differential Revision: https://reviews.llvm.org/D88690
This commit is contained in:
Arthur Eubanks 2020-10-01 11:49:45 -07:00
parent b113fa4510
commit 321986fe68
6 changed files with 139 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
llvm/include/llvm/Transforms/Utils/MetaRenamer.h Normal file
View File

@ -0,0 +1,26 @@
//===- MetaRenamer.h - Rename everything with metasyntatic names ----------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This pass renames everything with metasyntatic names. The intent is to use
// this pass after bugpoint reduction to conceal the nature of the original
// program.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TRANSFORMS_UTILS_METARENAMER_H
#define LLVM_TRANSFORMS_UTILS_METARENAMER_H
#include "llvm/IR/PassManager.h"
namespace llvm {
struct MetaRenamerPass : PassInfoMixin<MetaRenamerPass> {
PreservedAnalyses run(Module &, ModuleAnalysisManager &);
};
} // namespace llvm
#endif // LLVM_TRANSFORMS_UTILS_METARENAMER_H

1
llvm/lib/Passes/PassBuilder.cpp
View File

@ -203,6 +203,7 @@
#include "llvm/Transforms/Utils/LowerInvoke.h"
#include "llvm/Transforms/Utils/LowerSwitch.h"
#include "llvm/Transforms/Utils/Mem2Reg.h"
#include "llvm/Transforms/Utils/MetaRenamer.h"
#include "llvm/Transforms/Utils/NameAnonGlobals.h"
#include "llvm/Transforms/Utils/SymbolRewriter.h"
#include "llvm/Transforms/Vectorize/LoadStoreVectorizer.h"

1
llvm/lib/Passes/PassRegistry.def
View File

@ -68,6 +68,7 @@ MODULE_PASS("invalidate<all>", InvalidateAllAnalysesPass())
MODULE_PASS("ipsccp", IPSCCPPass())
MODULE_PASS("print-ir-similarity", IRSimilarityAnalysisPrinterPass(dbgs()))
MODULE_PASS("lowertypetests", LowerTypeTestsPass())
MODULE_PASS("metarenamer", MetaRenamerPass())
MODULE_PASS("mergefunc", MergeFunctionsPass())
MODULE_PASS("name-anon-globals", NameAnonGlobalPass())
MODULE_PASS("no-op-module", NoOpModulePass())

203
llvm/lib/Transforms/Utils/MetaRenamer.cpp
View File

@ -12,6 +12,7 @@
//
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Utils/MetaRenamer.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h"
@ -25,6 +26,7 @@
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/Instruction.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/TypeFinder.h"
#include "llvm/InitializePasses.h"
@ -40,123 +42,125 @@ static const char *const metaNames[] = {
};
namespace {
// This PRNG is from the ISO C spec. It is intentionally simple and
// unsuitable for cryptographic use. We're just looking for enough
// variety to surprise and delight users.
struct PRNG {
unsigned long next;
// This PRNG is from the ISO C spec. It is intentionally simple and
// unsuitable for cryptographic use. We're just looking for enough
// variety to surprise and delight users.
struct PRNG {
unsigned long next;
void srand(unsigned int seed) { next = seed; }
void srand(unsigned int seed) {
next = seed;
}
int rand() {
next = next * 1103515245 + 12345;
return (unsigned int)(next / 65536) % 32768;
}
};
int rand() {
next = next * 1103515245 + 12345;
return (unsigned int)(next / 65536) % 32768;
}
};
struct Renamer {
Renamer(unsigned int seed) { prng.srand(seed); }
struct Renamer {
Renamer(unsigned int seed) {
prng.srand(seed);
}
const char *newName() {
return metaNames[prng.rand() % array_lengthof(metaNames)];
}
const char *newName() {
return metaNames[prng.rand() % array_lengthof(metaNames)];
}
PRNG prng;
};
PRNG prng;
};
void MetaRename(Function &F) {
for (auto AI = F.arg_begin(), AE = F.arg_end(); AI != AE; ++AI)
if (!AI->getType()->isVoidTy())
AI->setName("arg");
struct MetaRenamer : public ModulePass {
// Pass identification, replacement for typeid
static char ID;
for (auto &BB : F) {
BB.setName("bb");
MetaRenamer() : ModulePass(ID) {
initializeMetaRenamerPass(*PassRegistry::getPassRegistry());
}
for (auto &I : BB)
if (!I.getType()->isVoidTy())
I.setName("tmp");
}
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<TargetLibraryInfoWrapperPass>();
AU.setPreservesAll();
}
void MetaRename(Module &M,
function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
// Seed our PRNG with simple additive sum of ModuleID. We're looking to
// simply avoid always having the same function names, and we need to
// remain deterministic.
unsigned int randSeed = 0;
for (auto C : M.getModuleIdentifier())
randSeed += C;
bool runOnModule(Module &M) override {
// Seed our PRNG with simple additive sum of ModuleID. We're looking to
// simply avoid always having the same function names, and we need to
// remain deterministic.
unsigned int randSeed = 0;
for (auto C : M.getModuleIdentifier())
randSeed += C;
Renamer renamer(randSeed);
Renamer renamer(randSeed);
// Rename all aliases
for (auto AI = M.alias_begin(), AE = M.alias_end(); AI != AE; ++AI) {
StringRef Name = AI->getName();
if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1))
continue;
// Rename all aliases
for (auto AI = M.alias_begin(), AE = M.alias_end(); AI != AE; ++AI) {
StringRef Name = AI->getName();
if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1))
continue;
AI->setName("alias");
}
AI->setName("alias");
}
// Rename all global variables
for (auto GI = M.global_begin(), GE = M.global_end(); GI != GE; ++GI) {
StringRef Name = GI->getName();
if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1))
continue;
// Rename all global variables
for (auto GI = M.global_begin(), GE = M.global_end(); GI != GE; ++GI) {
StringRef Name = GI->getName();
if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1))
continue;
GI->setName("global");
}
GI->setName("global");
}
// Rename all struct types
TypeFinder StructTypes;
StructTypes.run(M, true);
for (StructType *STy : StructTypes) {
if (STy->isLiteral() || STy->getName().empty())
continue;
// Rename all struct types
TypeFinder StructTypes;
StructTypes.run(M, true);
for (StructType *STy : StructTypes) {
if (STy->isLiteral() || STy->getName().empty()) continue;
SmallString<128> NameStorage;
STy->setName(
(Twine("struct.") + renamer.newName()).toStringRef(NameStorage));
}
SmallString<128> NameStorage;
STy->setName((Twine("struct.") +
renamer.newName()).toStringRef(NameStorage));
}
// Rename all functions
for (auto &F : M) {
StringRef Name = F.getName();
LibFunc Tmp;
// Leave library functions alone because their presence or absence could
// affect the behavior of other passes.
if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1) ||
GetTLI(F).getLibFunc(F, Tmp))
continue;
// Rename all functions
for (auto &F : M) {
StringRef Name = F.getName();
LibFunc Tmp;
// Leave library functions alone because their presence or absence could
// affect the behavior of other passes.
if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1) ||
getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F).getLibFunc(
F, Tmp))
continue;
// Leave @main alone. The output of -metarenamer might be passed to
// lli for execution and the latter needs a main entry point.
if (Name != "main")
F.setName(renamer.newName());
// Leave @main alone. The output of -metarenamer might be passed to
// lli for execution and the latter needs a main entry point.
if (Name != "main")
F.setName(renamer.newName());
MetaRename(F);
}
}
runOnFunction(F);
}
return true;
}
struct MetaRenamer : public ModulePass {
// Pass identification, replacement for typeid
static char ID;
bool runOnFunction(Function &F) {
for (auto AI = F.arg_begin(), AE = F.arg_end(); AI != AE; ++AI)
if (!AI->getType()->isVoidTy())
AI->setName("arg");
MetaRenamer() : ModulePass(ID) {
initializeMetaRenamerPass(*PassRegistry::getPassRegistry());
}
for (auto &BB : F) {
BB.setName("bb");
void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.addRequired<TargetLibraryInfoWrapperPass>();
AU.setPreservesAll();
}
for (auto &I : BB)
if (!I.getType()->isVoidTy())
I.setName("tmp");
}
return true;
}
};
bool runOnModule(Module &M) override {
auto GetTLI = [this](Function &F) -> TargetLibraryInfo & {
return this->getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
};
MetaRename(M, GetTLI);
return true;
}
};
} // end anonymous namespace
@ -175,3 +179,14 @@ INITIALIZE_PASS_END(MetaRenamer, "metarenamer",
ModulePass *llvm::createMetaRenamerPass() {
return new MetaRenamer();
}
PreservedAnalyses MetaRenamerPass::run(Module &M, ModuleAnalysisManager &AM) {
FunctionAnalysisManager &FAM =
AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
auto GetTLI = [&FAM](Function &F) -> TargetLibraryInfo & {
return FAM.getResult<TargetLibraryAnalysis>(F);
};
MetaRename(M, GetTLI);
return PreservedAnalyses::all();
}

1
llvm/test/Transforms/MetaRenamer/main.ll
View File

@ -1,5 +1,6 @@
; Make sure @main is left untouched.
; RUN: opt -metarenamer -S %s | FileCheck %s
; RUN: opt -passes=metarenamer -S %s | FileCheck %s
; CHECK: define void @main
; CHECK: call void @main

1
llvm/test/Transforms/MetaRenamer/metarenamer.ll
View File

@ -1,4 +1,5 @@
; RUN: opt -metarenamer -S < %s | FileCheck %s
; RUN: opt -passes=metarenamer -S < %s | FileCheck %s
; CHECK: target triple {{.*}}
; CHECK-NOT: {{^x*}}xxx{{^x*}}