1 //===- MetaRenamer.cpp - Rename everything with metasyntatic names --------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This pass renames everything with metasyntatic names. The intent is to use 11 // this pass after bugpoint reduction to conceal the nature of the original 12 // program. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #include "llvm/Transforms/IPO.h" 17 #include "llvm/ADT/STLExtras.h" 18 #include "llvm/ADT/SmallString.h" 19 #include "llvm/IR/DerivedTypes.h" 20 #include "llvm/IR/Function.h" 21 #include "llvm/IR/Module.h" 22 #include "llvm/IR/Type.h" 23 #include "llvm/IR/TypeFinder.h" 24 #include "llvm/Pass.h" 25 using namespace llvm; 26 27 namespace { 28 29 // This PRNG is from the ISO C spec. It is intentionally simple and 30 // unsuitable for cryptographic use. We're just looking for enough 31 // variety to surprise and delight users. 32 struct PRNG { 33 unsigned long next; 34 35 void srand(unsigned int seed) { 36 next = seed; 37 } 38 39 int rand() { 40 next = next * 1103515245 + 12345; 41 return (unsigned int)(next / 65536) % 32768; 42 } 43 }; 44 45 static const char *const metaNames[] = { 46 // See http://en.wikipedia.org/wiki/Metasyntactic_variable 47 "foo", "bar", "baz", "quux", "barney", "snork", "zot", "blam", "hoge", 48 "wibble", "wobble", "widget", "wombat", "ham", "eggs", "pluto", "spam" 49 }; 50 51 struct Renamer { 52 Renamer(unsigned int seed) { 53 prng.srand(seed); 54 } 55 56 const char *newName() { 57 return metaNames[prng.rand() % array_lengthof(metaNames)]; 58 } 59 60 PRNG prng; 61 }; 62 63 struct MetaRenamer : public ModulePass { 64 static char ID; // Pass identification, replacement for typeid 65 MetaRenamer() : ModulePass(ID) { 66 initializeMetaRenamerPass(*PassRegistry::getPassRegistry()); 67 } 68 69 void getAnalysisUsage(AnalysisUsage &AU) const override { 70 AU.setPreservesAll(); 71 } 72 73 bool runOnModule(Module &M) override { 74 // Seed our PRNG with simple additive sum of ModuleID. We're looking to 75 // simply avoid always having the same function names, and we need to 76 // remain deterministic. 77 unsigned int randSeed = 0; 78 for (auto C : M.getModuleIdentifier()) 79 randSeed += C; 80 81 Renamer renamer(randSeed); 82 83 // Rename all aliases 84 for (auto AI = M.alias_begin(), AE = M.alias_end(); AI != AE; ++AI) { 85 StringRef Name = AI->getName(); 86 if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1)) 87 continue; 88 89 AI->setName("alias"); 90 } 91 92 // Rename all global variables 93 for (auto GI = M.global_begin(), GE = M.global_end(); GI != GE; ++GI) { 94 StringRef Name = GI->getName(); 95 if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1)) 96 continue; 97 98 GI->setName("global"); 99 } 100 101 // Rename all struct types 102 TypeFinder StructTypes; 103 StructTypes.run(M, true); 104 for (StructType *STy : StructTypes) { 105 if (STy->isLiteral() || STy->getName().empty()) continue; 106 107 SmallString<128> NameStorage; 108 STy->setName((Twine("struct.") + 109 renamer.newName()).toStringRef(NameStorage)); 110 } 111 112 // Rename all functions 113 for (auto &F : M) { 114 StringRef Name = F.getName(); 115 if (Name.startswith("llvm.") || (!Name.empty() && Name[0] == 1)) 116 continue; 117 118 F.setName(renamer.newName()); 119 runOnFunction(F); 120 } 121 return true; 122 } 123 124 bool runOnFunction(Function &F) { 125 for (auto AI = F.arg_begin(), AE = F.arg_end(); AI != AE; ++AI) 126 if (!AI->getType()->isVoidTy()) 127 AI->setName("arg"); 128 129 for (auto &BB : F) { 130 BB.setName("bb"); 131 132 for (auto &I : BB) 133 if (!I.getType()->isVoidTy()) 134 I.setName("tmp"); 135 } 136 return true; 137 } 138 }; 139 } 140 141 char MetaRenamer::ID = 0; 142 INITIALIZE_PASS(MetaRenamer, "metarenamer", 143 "Assign new names to everything", false, false) 144 //===----------------------------------------------------------------------===// 145 // 146 // MetaRenamer - Rename everything with metasyntactic names. 147 // 148 ModulePass *llvm::createMetaRenamerPass() { 149 return new MetaRenamer(); 150 } 151