1243789Sdim//===- MetaRenamer.cpp - Rename everything with metasyntatic names --------===// 2243789Sdim// 3243789Sdim// The LLVM Compiler Infrastructure 4243789Sdim// 5243789Sdim// This file is distributed under the University of Illinois Open Source 6243789Sdim// License. See LICENSE.TXT for details. 7243789Sdim// 8243789Sdim//===----------------------------------------------------------------------===// 9243789Sdim// 10243789Sdim// This pass renames everything with metasyntatic names. The intent is to use 11243789Sdim// this pass after bugpoint reduction to conceal the nature of the original 12243789Sdim// program. 13243789Sdim// 14243789Sdim//===----------------------------------------------------------------------===// 15243789Sdim 16249423Sdim#include "llvm/Transforms/IPO.h" 17243789Sdim#include "llvm/ADT/STLExtras.h" 18243789Sdim#include "llvm/ADT/SmallString.h" 19249423Sdim#include "llvm/IR/DerivedTypes.h" 20249423Sdim#include "llvm/IR/Function.h" 21249423Sdim#include "llvm/IR/Module.h" 22249423Sdim#include "llvm/IR/Type.h" 23249423Sdim#include "llvm/IR/TypeFinder.h" 24243789Sdim#include "llvm/Pass.h" 25243789Sdimusing namespace llvm; 26243789Sdim 27243789Sdimnamespace { 28243789Sdim 29243789Sdim // This PRNG is from the ISO C spec. It is intentionally simple and 30243789Sdim // unsuitable for cryptographic use. We're just looking for enough 31243789Sdim // variety to surprise and delight users. 32243789Sdim struct PRNG { 33243789Sdim unsigned long next; 34243789Sdim 35243789Sdim void srand(unsigned int seed) { 36243789Sdim next = seed; 37243789Sdim } 38243789Sdim 39249423Sdim int rand() { 40243789Sdim next = next * 1103515245 + 12345; 41243789Sdim return (unsigned int)(next / 65536) % 32768; 42243789Sdim } 43243789Sdim }; 44243789Sdim 45243789Sdim struct MetaRenamer : public ModulePass { 46243789Sdim static char ID; // Pass identification, replacement for typeid 47243789Sdim MetaRenamer() : ModulePass(ID) { 48243789Sdim initializeMetaRenamerPass(*PassRegistry::getPassRegistry()); 49243789Sdim } 50243789Sdim 51243789Sdim void getAnalysisUsage(AnalysisUsage &AU) const { 52243789Sdim AU.setPreservesAll(); 53243789Sdim } 54243789Sdim 55243789Sdim bool runOnModule(Module &M) { 56263508Sdim static const char *const metaNames[] = { 57243789Sdim // See http://en.wikipedia.org/wiki/Metasyntactic_variable 58243789Sdim "foo", "bar", "baz", "quux", "barney", "snork", "zot", "blam", "hoge", 59243789Sdim "wibble", "wobble", "widget", "wombat", "ham", "eggs", "pluto", "spam" 60243789Sdim }; 61243789Sdim 62243789Sdim // Seed our PRNG with simple additive sum of ModuleID. We're looking to 63243789Sdim // simply avoid always having the same function names, and we need to 64243789Sdim // remain deterministic. 65243789Sdim unsigned int randSeed = 0; 66243789Sdim for (std::string::const_iterator I = M.getModuleIdentifier().begin(), 67243789Sdim E = M.getModuleIdentifier().end(); I != E; ++I) 68243789Sdim randSeed += *I; 69243789Sdim 70243789Sdim PRNG prng; 71243789Sdim prng.srand(randSeed); 72243789Sdim 73243789Sdim // Rename all aliases 74243789Sdim for (Module::alias_iterator AI = M.alias_begin(), AE = M.alias_end(); 75249423Sdim AI != AE; ++AI) { 76249423Sdim StringRef Name = AI->getName(); 77249423Sdim if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1)) 78249423Sdim continue; 79249423Sdim 80243789Sdim AI->setName("alias"); 81249423Sdim } 82249423Sdim 83243789Sdim // Rename all global variables 84243789Sdim for (Module::global_iterator GI = M.global_begin(), GE = M.global_end(); 85249423Sdim GI != GE; ++GI) { 86249423Sdim StringRef Name = GI->getName(); 87249423Sdim if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1)) 88249423Sdim continue; 89249423Sdim 90243789Sdim GI->setName("global"); 91249423Sdim } 92243789Sdim 93243789Sdim // Rename all struct types 94243789Sdim TypeFinder StructTypes; 95243789Sdim StructTypes.run(M, true); 96243789Sdim for (unsigned i = 0, e = StructTypes.size(); i != e; ++i) { 97243789Sdim StructType *STy = StructTypes[i]; 98243789Sdim if (STy->isLiteral() || STy->getName().empty()) continue; 99243789Sdim 100243789Sdim SmallString<128> NameStorage; 101243789Sdim STy->setName((Twine("struct.") + metaNames[prng.rand() % 102243789Sdim array_lengthof(metaNames)]).toStringRef(NameStorage)); 103243789Sdim } 104243789Sdim 105243789Sdim // Rename all functions 106243789Sdim for (Module::iterator FI = M.begin(), FE = M.end(); 107243789Sdim FI != FE; ++FI) { 108249423Sdim StringRef Name = FI->getName(); 109249423Sdim if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1)) 110249423Sdim continue; 111249423Sdim 112243789Sdim FI->setName(metaNames[prng.rand() % array_lengthof(metaNames)]); 113243789Sdim runOnFunction(*FI); 114243789Sdim } 115243789Sdim return true; 116243789Sdim } 117243789Sdim 118243789Sdim bool runOnFunction(Function &F) { 119243789Sdim for (Function::arg_iterator AI = F.arg_begin(), AE = F.arg_end(); 120243789Sdim AI != AE; ++AI) 121243789Sdim if (!AI->getType()->isVoidTy()) 122243789Sdim AI->setName("arg"); 123243789Sdim 124243789Sdim for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { 125243789Sdim BB->setName("bb"); 126243789Sdim 127243789Sdim for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 128243789Sdim if (!I->getType()->isVoidTy()) 129243789Sdim I->setName("tmp"); 130243789Sdim } 131243789Sdim return true; 132243789Sdim } 133243789Sdim }; 134243789Sdim} 135243789Sdim 136243789Sdimchar MetaRenamer::ID = 0; 137243789SdimINITIALIZE_PASS(MetaRenamer, "metarenamer", 138243789Sdim "Assign new names to everything", false, false) 139243789Sdim//===----------------------------------------------------------------------===// 140243789Sdim// 141243789Sdim// MetaRenamer - Rename everything with metasyntactic names. 142243789Sdim// 143243789SdimModulePass *llvm::createMetaRenamerPass() { 144243789Sdim return new MetaRenamer(); 145243789Sdim} 146