[Transforms/Utils] New -instanonymizer pass

[tpr]

Summary

By analogy with -instnamer, this is a little utility pass that removes
names from instructions. This is useful when building a library of bc
files where the toolchain using the library is sensitive to compile
time.

Change-Id: Ib66708c049a2725aa582849a59cb2044dab87e2f

[tpr]

Hi Michał and Chandler. I wasn't sure who to add as reviewers for this. If you can think of anyone more appropriate, please add them. Thanks.

[arsenm]

How is this different from -strip?

[tpr]

D'oh!

-strip actually does more, but will be fine for the application I need it for.

Thanks for pointing it out Matt.

docs/Passes.rst

 ``-instnamer``: Assign names to anonymous instructions
 ------------------------------------------------------
 
 This is a little utility pass that gives instructions names, this is mostly
 useful when diffing the effect of an optimization because deleting an unnamed
 instruction can change all other instruction numbering, making the diff very
 noisy.
 
+``-instanonymizer``: Remove names from instructions
+---------------------------------------------------
+
+This is a little utility pass that removes names from instructions. This is
+useful when building a library of bitcode files that will be used in a toolchain
+that is sensitive to compile time.
+
 .. _passes-verify:
 
 ``-verify``: Module Verifier
 ----------------------------
 
 Verifies an LLVM IR code.  This is useful to run after an optimization which is
 undergoing testing.  Note that llvm-as verifies its input before emitting
 bitcode, and also that malformed bitcode is likely to make LLVM crash.  All

include/llvm/InitializePasses.h

 void initializeIVUsersWrapperPassPass(PassRegistry&);
 void initializeIfConverterPass(PassRegistry&);
 void initializeImplicitNullChecksPass(PassRegistry&);
 void initializeIndVarSimplifyLegacyPassPass(PassRegistry&);
 void initializeIndirectBrExpandPassPass(PassRegistry&);
 void initializeInferAddressSpacesPass(PassRegistry&);
 void initializeInferFunctionAttrsLegacyPassPass(PassRegistry&);
 void initializeInlineCostAnalysisPass(PassRegistry&);
+void initializeInstAnonymizerPass(PassRegistry&);
 void initializeInstCountPass(PassRegistry&);
 void initializeInstNamerPass(PassRegistry&);
 void initializeInstSimplifyLegacyPassPass(PassRegistry &);
 void initializeInstrProfilingLegacyPassPass(PassRegistry&);
 void initializeInstructionCombiningPassPass(PassRegistry&);
 void initializeInstructionSelectPass(PassRegistry&);
 void initializeInterleavedAccessPass(PassRegistry&);
 void initializeInternalizeLegacyPassPass(PassRegistry&);

include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createGVNHoistPass();
       (void) llvm::createMergedLoadStoreMotionPass();
       (void) llvm::createGVNPass();
       (void) llvm::createNewGVNPass();
       (void) llvm::createMemCpyOptPass();
       (void) llvm::createLoopDeletionPass();
       (void) llvm::createPostDomTree();
       (void) llvm::createInstructionNamerPass();
+      (void) llvm::createInstructionAnonymizerPass();
       (void) llvm::createMetaRenamerPass();
       (void) llvm::createPostOrderFunctionAttrsLegacyPass();
       (void) llvm::createReversePostOrderFunctionAttrsPass();
       (void) llvm::createMergeFunctionsPass();
       (void) llvm::createMergeICmpsPass();
       (void) llvm::createExpandMemCmpPass();
       std::string buf;
       llvm::raw_string_ostream os(buf);

include/llvm/Transforms/Utils.h

 //
 // InstructionNamer - Give any unnamed non-void instructions "tmp" names.
 //
 FunctionPass *createInstructionNamerPass();
 extern char &InstructionNamerID;
 
 //===----------------------------------------------------------------------===//
 //
+// InstructionAnonymizer - Remove names from instructions.
+//
+FunctionPass *createInstructionAnonymizerPass();
+extern char &InstructionAnonymizerID;
+
+//===----------------------------------------------------------------------===//
+//
 // LowerSwitch - This pass converts SwitchInst instructions into a sequence of
 // chained binary branch instructions.
 //
 FunctionPass *createLowerSwitchPass();
 extern char &LowerSwitchID;
 
 //===----------------------------------------------------------------------===//
 //

lib/Transforms/Utils/CMakeLists.txt

add_llvm_library(LLVMTransformUtils
   Evaluator.cpp
   FlattenCFG.cpp
   FunctionComparator.cpp
   FunctionImportUtils.cpp
   GlobalStatus.cpp
   GuardUtils.cpp
   InlineFunction.cpp
   ImportedFunctionsInliningStatistics.cpp
+  InstructionAnonymizer.cpp
   InstructionNamer.cpp
   IntegerDivision.cpp
   LCSSA.cpp
   LibCallsShrinkWrap.cpp
   Local.cpp
   LoopRotationUtils.cpp
   LoopSimplify.cpp
   LoopUnroll.cpp

lib/Transforms/Utils/InstructionAnonymizer.cpp

+//===- InstructionAnonymizer.cpp - Remove names from instructions ---------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a little utility pass that removes names from instructions. This is
+// useful when building a library of bc files where the toolchain using the
+// library is sensitive to compile time.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/IR/Function.h"
+#include "llvm/IR/Type.h"
+#include "llvm/Pass.h"
+#include "llvm/Transforms/Utils.h"
+using namespace llvm;
+
+namespace {
+  struct InstAnonymizer : public FunctionPass {
+    static char ID; // Pass identification, replacement for typeid
+    InstAnonymizer() : FunctionPass(ID) {
+      initializeInstAnonymizerPass(*PassRegistry::getPassRegistry());
+    }
+
+    void getAnalysisUsage(AnalysisUsage &Info) const override {
+      Info.setPreservesAll();
+    }
+
+    bool runOnFunction(Function &F) override {
+      for (auto &Arg : F.args())
+        Arg.setName("");
+
+      for (BasicBlock &BB : F) {
+        BB.setName("");
+
+        for (Instruction &I : BB)
+          if (!I.getType()->isVoidTy())
+            I.setName("");
+      }
+      return true;
+    }
+  };
+
+  char InstAnonymizer::ID = 0;
+}
+
+INITIALIZE_PASS(InstAnonymizer, "instanonymizer",
+                "Remove names from instructions", false, false)
+char &llvm::InstructionAnonymizerID = InstAnonymizer::ID;
+//===----------------------------------------------------------------------===//
+//
+// InstructionAnonymizer - Remove names from instructions.
+//
+FunctionPass *llvm::createInstructionAnonymizerPass() {
+  return new InstAnonymizer();
+}
+

lib/Transforms/Utils/Utils.cpp

 using namespace llvm;
 
 /// initializeTransformUtils - Initialize all passes in the TransformUtils
 /// library.
 void llvm::initializeTransformUtils(PassRegistry &Registry) {
   initializeAddDiscriminatorsLegacyPassPass(Registry);
   initializeBreakCriticalEdgesPass(Registry);
   initializeInstNamerPass(Registry);
+  initializeInstAnonymizerPass(Registry);
   initializeLCSSAWrapperPassPass(Registry);
   initializeLibCallsShrinkWrapLegacyPassPass(Registry);
   initializeLoopSimplifyPass(Registry);
   initializeLowerInvokeLegacyPassPass(Registry);
   initializeLowerSwitchPass(Registry);
   initializeNameAnonGlobalLegacyPassPass(Registry);
   initializePromoteLegacyPassPass(Registry);
   initializeStripNonLineTableDebugInfoPass(Registry);

test/Transforms/InstAnonymizer/basic.ll

+; RUN: opt -S -instanonymizer < %s | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define i32 @f_0(i32 %arg) {
+; CHECK: @f_0(i32)
+; CHECK-NOT: bb:
+; CHECK-NEXT:   %2 = add i32 %0, 2
+; CHECK-NEXT:   br label %3
+; CHECK: ; <label>:3:
+; CHECK-NEXT:   ret i32 %2
+
+bb:
+  %tmp = add i32 %arg, 2
+  br label %bb1
+
+bb1:                                              ; preds = %bb
+  ret i32 %tmp
+}