[esan] Add calls from the ctor/dtor to the runtime library

[zhaoqin]

Summary

Adds createEsanInitToolGV for creating a tool-specific variable passed
to the runtime library.

Adds dtor "esan.module_dtor" and inserts calls from the dtor to
"__esan_exit" in the runtime library.

Updates the EfficiencySanitizer test.

[aizatsky]

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

229

Please extract createDestructor function as well.

[zhaoqin]

PTAL

[zhaoqin]

fix the { position

[zhaoqin]

set createDestructor return void.

[vitalybuka]

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

186

this is always nullptr

[zhaoqin]

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

186

yes, xref the FIXME above. tool specific global variable to be added.
Next CL adds tool specific global variable creation, waiting for this CL to be landed before sending the next one.

[zhaoqin]

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

186

http://reviews.llvm.org/D20541

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

static cl::opt<bool> ClInstrumentMemIntrinsics(
     cl::desc("Instrument memintrinsics (memset/memcpy/memmove)"), cl::Hidden);
 
 STATISTIC(NumInstrumentedLoads, "Number of instrumented loads");
 STATISTIC(NumInstrumentedStores, "Number of instrumented stores");
 STATISTIC(NumFastpaths, "Number of instrumented fastpaths");
 STATISTIC(NumAccessesWithIrregularSize,
           "Number of accesses with a size outside our targeted callout sizes");
 
+static const uint64_t EsanCtorAndDtorPriority = 0;
 static const char *const EsanModuleCtorName = "esan.module_ctor";
+static const char *const EsanModuleDtorName = "esan.module_dtor";
 static const char *const EsanInitName = "__esan_init";
+static const char *const EsanExitName = "__esan_exit";
 
 namespace {
 
 static EfficiencySanitizerOptions
 OverrideOptionsFromCL(EfficiencySanitizerOptions Options) {
   if (ClToolCacheFrag)
     Options.ToolType = EfficiencySanitizerOptions::ESAN_CacheFrag;
 
EfficiencySanitizer(
       : ModulePass(ID), Options(OverrideOptionsFromCL(Opts)) {}
   const char *getPassName() const override;
   bool runOnModule(Module &M) override;
   static char ID;
 
 private:
   bool initOnModule(Module &M);
   void initializeCallbacks(Module &M);
+  GlobalVariable *createEsanInitToolGV(Module &M);
+  bool createDestructor(Module &M, GlobalVariable *GV);
   bool runOnFunction(Function &F, Module &M);
   bool instrumentLoadOrStore(Instruction *I, const DataLayout &DL);
   bool instrumentMemIntrinsic(MemIntrinsic *MI);
   bool shouldIgnoreMemoryAccess(Instruction *I);
   int getMemoryAccessFuncIndex(Value *Addr, const DataLayout &DL);
   bool instrumentFastpath(Instruction *I, const DataLayout &DL, bool IsStore,
                           Value *Addr, unsigned Alignment);
   // Each tool has its own fastpath routine:
private:
   Function *EsanAlignedLoad[NumberOfAccessSizes];
   Function *EsanAlignedStore[NumberOfAccessSizes];
   Function *EsanUnalignedLoad[NumberOfAccessSizes];
   Function *EsanUnalignedStore[NumberOfAccessSizes];
   // For irregular sizes of any alignment:
   Function *EsanUnalignedLoadN, *EsanUnalignedStoreN;
   Function *MemmoveFn, *MemcpyFn, *MemsetFn;
   Function *EsanCtorFunction;
+  Function *EsanDtorFunction;
 };
 } // namespace
 
 char EfficiencySanitizer::ID = 0;
 INITIALIZE_PASS(EfficiencySanitizer, "esan",
                 "EfficiencySanitizer: finds performance issues.", false, false)
 
 const char *EfficiencySanitizer::getPassName() const {
void EfficiencySanitizer::initializeCallbacks(Module &M) {
   MemcpyFn = checkSanitizerInterfaceFunction(
       M.getOrInsertFunction("memcpy", IRB.getInt8PtrTy(), IRB.getInt8PtrTy(),
                             IRB.getInt8PtrTy(), IntptrTy, nullptr));
   MemsetFn = checkSanitizerInterfaceFunction(
       M.getOrInsertFunction("memset", IRB.getInt8PtrTy(), IRB.getInt8PtrTy(),
                             IRB.getInt32Ty(), IntptrTy, nullptr));
 }
 
+// Create the tool-specific global variable passed to EsanInit and EsanExit.
+GlobalVariable *EfficiencySanitizer::createEsanInitToolGV(Module &M) {
+  GlobalVariable *GV = nullptr;
+  // FIXME: create the tool specific global variable.
+  if (GV == nullptr) {
+    GV = new GlobalVariable(M, IntptrTy, true, GlobalVariable::InternalLinkage,
+                            Constant::getNullValue(IntptrTy));
+  }
+  return GV;
+}
+
+bool EfficiencySanitizer::createDestructor(Module &M, GlobalVariable *GV) {
+  EsanDtorFunction = Function::Create(FunctionType::get(Type::getVoidTy(*Ctx),
+                                                        false),
+                                      GlobalValue::InternalLinkage,
+                                      EsanModuleDtorName, &M);
+  ReturnInst::Create(*Ctx, BasicBlock::Create(*Ctx, "", EsanDtorFunction));
+  IRBuilder<> IRB_Dtor(EsanDtorFunction->getEntryBlock().getTerminator());
+  Function *EsanExit = checkSanitizerInterfaceFunction(
+      M.getOrInsertFunction(EsanExitName, IRB_Dtor.getVoidTy(),
+                            IntptrTy, nullptr));
+  EsanExit->setLinkage(Function::ExternalLinkage);
+  IRB_Dtor.CreateCall(EsanExit,
+                      {IRB_Dtor.CreatePointerCast(GV, IntptrTy)});
+  appendToGlobalDtors(M, EsanDtorFunction, EsanCtorAndDtorPriority);
+}
+
 bool EfficiencySanitizer::initOnModule(Module &M) {
   Ctx = &M.getContext();
   const DataLayout &DL = M.getDataLayout();
   IRBuilder<> IRB(M.getContext());
   IntegerType *OrdTy = IRB.getInt32Ty();
   IntptrTy = DL.getIntPtrType(M.getContext());
+  // Create the variable passed to EsanInit and EsanExit.
+  GlobalVariable *GV = createEsanInitToolGV(M);
+  // Constructor
   std::tie(EsanCtorFunction, std::ignore) = createSanitizerCtorAndInitFunctions(
-      M, EsanModuleCtorName, EsanInitName, /*InitArgTypes=*/{OrdTy},
+      M, EsanModuleCtorName, EsanInitName, /*InitArgTypes=*/{OrdTy, IntptrTy},
       /*InitArgs=*/{
-          ConstantInt::get(OrdTy, static_cast<int>(Options.ToolType))});
-
-  appendToGlobalCtors(M, EsanCtorFunction, 0);
+        ConstantInt::get(OrdTy, static_cast<int>(Options.ToolType)),
+        ConstantExpr::getPointerCast(GV, IntptrTy)});
+  appendToGlobalCtors(M, EsanCtorFunction, EsanCtorAndDtorPriority);
 
+  createDestructor(M, GV);
   return true;
 }
 
 bool EfficiencySanitizer::shouldIgnoreMemoryAccess(Instruction *I) {
   if (Options.ToolType == EfficiencySanitizerOptions::ESAN_CacheFrag) {
     // We'd like to know about cache fragmentation in vtable accesses and
     // constant data references, so we do not currently ignore anything.
     return false;
   }
   // TODO(bruening): future tools will be returning true for some cases.
   return false;
 }

 bool EfficiencySanitizer::runOnFunction(Function &F, Module &M) {
   // This is required to prevent instrumenting the call to __esan_init from
   // within the module constructor.
   if (&F == EsanCtorFunction)
     return false;
   SmallVector<Instruction *, 8> LoadsAndStores;
   SmallVector<Instruction *, 8> MemIntrinCalls;
   bool Res = false;
-  const DataLayout &DL = F.getParent()->getDataLayout();
+  const DataLayout &DL = M.getDataLayout();
 
   for (auto &BB : F) {
     for (auto &Inst : BB) {
       if ((isa<LoadInst>(Inst) || isa<StoreInst>(Inst) ||
            isa<AtomicRMWInst>(Inst) || isa<AtomicCmpXchgInst>(Inst)) &&
           !shouldIgnoreMemoryAccess(&Inst))
         LoadsAndStores.push_back(&Inst);
       else if (isa<MemIntrinsic>(Inst))

test/Instrumentation/EfficiencySanitizer/cache_frag_basic.ll

 ; CHECK: call i8* @memset
 ; CHECK: ret void
 }
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; Top-level:
 
 ; CHECK: define internal void @esan.module_ctor()
-; CHECK: call void @__esan_init(i32 1)
+; CHECK: call void @__esan_init(i32 1, i64 ptrtoint (i64* @0 to i64))
+; CHECK: define internal void @esan.module_dtor()
+; CHECK: call void @__esan_exit(i64 ptrtoint (i64* @0 to i64))