[ASan] Separate Initialization from AddressSanitizer Constructor

[leonardchan]

Summary

The AddressSanitizer initialization occurs on construction when it doesn't need to be initialized every time. The same sanitizer object can be used multiple times and initialized once. This makes AddressSanitizer a member of AddressSanitizerLegacyPass so the initialization only needs to be called once instead of on every function run.

[leonardchan]

Addressed in rC353985

llvm/lib/Transforms/Instrumentation/AddressSanitizer.cpp

static size_t RedzoneSizeForScale(int MappingScale) {
   // For scales 6 and 7, the redzone has to be 64 and 128 bytes respectively.
   return std::max(32U, 1U << MappingScale);
 }
 
 namespace {
 
 /// AddressSanitizer: instrument the code in module to find memory bugs.
 struct AddressSanitizer {
-  explicit AddressSanitizer(Module &M, DominatorTree *DT,
-                            bool CompileKernel = false, bool Recover = false,
+  explicit AddressSanitizer(bool CompileKernel = false, bool Recover = false,
                             bool UseAfterScope = false)
-      : UseAfterScope(UseAfterScope || ClUseAfterScope), DT(DT) {
+      : UseAfterScope(UseAfterScope || ClUseAfterScope) {
     this->Recover = ClRecover.getNumOccurrences() > 0 ? ClRecover : Recover;
     this->CompileKernel = ClEnableKasan.getNumOccurrences() > 0 ?
         ClEnableKasan : CompileKernel;
+  }
 
+  void doInitialization(Module &M) {
     // Initialize the private fields. No one has accessed them before.
     GlobalsMD.init(M);
     C = &(M.getContext());
     LongSize = M.getDataLayout().getPointerSizeInBits();
     IntptrTy = Type::getIntNTy(*C, LongSize);
     TargetTriple = Triple(M.getTargetTriple());
     Mapping = getShadowMapping(TargetTriple, LongSize, CompileKernel);
   }
 
+  void doFinalization(Module &M) { GlobalsMD.reset(); }
+
   uint64_t getAllocaSizeInBytes(const AllocaInst &AI) const {
     uint64_t ArraySize = 1;
     if (AI.isArrayAllocation()) {
       const ConstantInt *CI = dyn_cast<ConstantInt>(AI.getArraySize());
       assert(CI && "non-constant array size");
       ArraySize = CI->getZExtValue();
     }
     Type *Ty = AI.getAllocatedType();
struct AddressSanitizer {
   Value *memToShadow(Value *Shadow, IRBuilder<> &IRB);
   bool maybeInsertAsanInitAtFunctionEntry(Function &F);
   void maybeInsertDynamicShadowAtFunctionEntry(Function &F);
   void markEscapedLocalAllocas(Function &F);
 
   /// Return true if the function changed.
   bool instrument(Function &F, const TargetLibraryInfo *TLI);
 
-  DominatorTree &getDominatorTree() const { return *DT; }
-
 private:
   friend struct FunctionStackPoisoner;
 
   void initializeCallbacks(Module &M);
 
   bool LooksLikeCodeInBug11395(Instruction *I);
   bool GlobalIsLinkerInitialized(GlobalVariable *G);
   bool isSafeAccess(ObjectSizeOffsetVisitor &ObjSizeVis, Value *Addr,
private:
   LLVMContext *C;
   Triple TargetTriple;
   int LongSize;
   bool CompileKernel;
   bool Recover;
   bool UseAfterScope;
   Type *IntptrTy;
   ShadowMapping Mapping;
-  DominatorTree *DT;
   Function *AsanHandleNoReturnFunc;
   Function *AsanPtrCmpFunction, *AsanPtrSubFunction;
   Constant *AsanShadowGlobal;
 
   // These arrays is indexed by AccessIsWrite, Experiment and log2(AccessSize).
   Function *AsanErrorCallback[2][2][kNumberOfAccessSizes];
   Function *AsanMemoryAccessCallback[2][2][kNumberOfAccessSizes];
 
if (CallInst *CI = dyn_cast<CallInst>(I)) {
                               I != ASan.LocalDynamicShadow;
       HasReturnsTwiceCall |= CI->canReturnTwice();
     }
   }
 
   // ---------------------- Helpers.
   void initializeCallbacks(Module &M);
 
-  bool doesDominateAllExits(const Instruction *I) const {
-    for (auto Ret : RetVec) {
-      if (!ASan.getDominatorTree().dominates(I, Ret)) return false;
-    }
-    return true;
-  }
-
   /// Finds alloca where the value comes from.
   AllocaInst *findAllocaForValue(Value *V);
 
   // Copies bytes from ShadowBytes into shadow memory for indexes where
   // ShadowMask is not zero. If ShadowMask[i] is zero, we assume that
   // ShadowBytes[i] is constantly zero and doesn't need to be overwritten.
   void copyToShadow(ArrayRef<uint8_t> ShadowMask, ArrayRef<uint8_t> ShadowBytes,
                     IRBuilder<> &IRB, Value *ShadowBase);

 
 class AddressSanitizerLegacyPass : public FunctionPass {
 public:
   static char ID;
 
   explicit AddressSanitizerLegacyPass(bool CompileKernel = false,
                                       bool Recover = false,
                                       bool UseAfterScope = false)
-      : FunctionPass(ID), CompileKernel(CompileKernel), Recover(Recover),
-        UseAfterScope(UseAfterScope) {
+      : FunctionPass(ID), Sanitizer(CompileKernel, Recover, UseAfterScope) {
     initializeAddressSanitizerLegacyPassPass(*PassRegistry::getPassRegistry());
   }
 
   StringRef getPassName() const override {
     return "AddressSanitizerFunctionPass";
   }
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.addRequired<DominatorTreeWrapperPass>();
     AU.addRequired<TargetLibraryInfoWrapperPass>();
   }
 
+  bool doInitialization(Module &M) override {
+    Sanitizer.doInitialization(M);
+    return true;
+  }
+
+  bool doFinalization(Module &M) override {
+    Sanitizer.doFinalization(M);
+    return false;
+  }
+
   bool runOnFunction(Function &F) override {
-    DominatorTree *DTree =
-        &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     const TargetLibraryInfo *TLI =
         &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
-    AddressSanitizer Sanitizer(*F.getParent(), DTree, CompileKernel, Recover,
-                               UseAfterScope);
     return Sanitizer.instrument(F, TLI);
   }
 
 private:
-  bool CompileKernel;
-  bool Recover;
-  bool UseAfterScope;
+  AddressSanitizer Sanitizer;
 };
 
 class AddressSanitizerModuleLegacyPass : public ModulePass {
 public:
   static char ID;
 
   explicit AddressSanitizerModuleLegacyPass(bool CompileKernel = false,
                                             bool Recover = false,

 
 AddressSanitizerPass::AddressSanitizerPass(bool CompileKernel, bool Recover,
                                            bool UseAfterScope)
     : CompileKernel(CompileKernel), Recover(Recover),
       UseAfterScope(UseAfterScope) {}
 
 PreservedAnalyses AddressSanitizerPass::run(Function &F,
                                             AnalysisManager<Function> &AM) {
-  DominatorTree *DT = &AM.getResult<DominatorTreeAnalysis>(F);
   const TargetLibraryInfo *TLI = &AM.getResult<TargetLibraryAnalysis>(F);
-  AddressSanitizer Sanitizer(*F.getParent(), DT, CompileKernel, Recover,
-                             UseAfterScope);
-  if (Sanitizer.instrument(F, TLI))
-    return PreservedAnalyses::none();
-  return PreservedAnalyses::all();
+  AddressSanitizer Sanitizer(CompileKernel, Recover, UseAfterScope);
+  Sanitizer.doInitialization(*F.getParent());
+  PreservedAnalyses Result = Sanitizer.instrument(F, TLI)
+                                 ? PreservedAnalyses::none()
+                                 : PreservedAnalyses::all();
+  Sanitizer.doFinalization(*F.getParent());
+  return Result;
 }
 
 PreservedAnalyses AddressSanitizerPass::run(Module &M,
                                             AnalysisManager<Module> &AM) {
   AddressSanitizerModule Sanitizer(CompileKernel, Recover, UseAfterScope);
   if (Sanitizer.instrument(M))
     return PreservedAnalyses::none();
   return PreservedAnalyses::all();
 }
 
 char AddressSanitizerLegacyPass::ID = 0;
 
 INITIALIZE_PASS_BEGIN(
     AddressSanitizerLegacyPass, "asan",
     "AddressSanitizer: detects use-after-free and out-of-bounds bugs.", false,
     false)
-INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_END(
     AddressSanitizerLegacyPass, "asan",
     "AddressSanitizer: detects use-after-free and out-of-bounds bugs.", false,
     false)
 
 FunctionPass *llvm::createAddressSanitizerFunctionPass(bool CompileKernel,
                                                        bool Recover,