[esan] Add compilation unit init/exit routines.

[zhaoqin]

Summary

Adds processCompilationUnitInit and processCompilationUnitExit
for compilation unit init/exit.

Adds a tool-specific argument passed to esan_init.

Adds the dtor and esan_exit called from the dtor.

Adds struct-simple.cpp for a multi-unit separate compilation test.

[aizatsky]

Does this CL miss something?

I do not see esan_exit calls.
Plus you probably need to add it to esan.syms?

[zhaoqin]

Update esan.syms.extra

[aizatsky]

lib/esan/esan.h

40

Document Ptr.

lib/esan/esan_interface.cpp

26

Do you want to pass Tool in as well?

[zhaoqin]

In D20486#435886, @aizatsky wrote:

Does this CL miss something?

I do not see esan_exit calls.

The calls is inserted from the ESan instrumentation at http://reviews.llvm.org/D20488

Plus you probably need to add it to esan.syms?

done

[zhaoqin]

PTAL

[zhaoqin]

lib/esan/esan_interface.cpp

26

the Tool is set to a global variable, so we do not need update it.

[aizatsky]

Comment nit. LG otherwise.

lib/esan/esan.h

40

Should it be "variable per tool per compilation unit"?

[zhaoqin]

update comment for Ptr

[zhaoqin]

Remove struct-simple.cpp to avoid test bot failure.

The correct CL landing order:
D20486: implement esan_exit
D20488: add calls to esan_exit
Add test struct-simple.cpp: check printout from __esan_exit.

[bruening]

My apologies, I failed to add the "Patch by Qin Zhao" to the commit message.

lib/esan/esan.h

 namespace __esan {
 
 extern bool EsanIsInitialized;
 
 extern ToolType WhichTool;
 
 void initializeLibrary(ToolType Tool);
 int finalizeLibrary();
+// Esan creates the variable per tool per compilation unit at compile time
+// and passes its pointer Ptr to the runtime library.
+void processCompilationUnitInit(void *Ptr);
+void processCompilationUnitExit(void *Ptr);
 void processRangeAccess(uptr PC, uptr Addr, int Size, bool IsWrite);
 void initializeInterceptors();
 
 } // namespace __esan
 
 #endif // ESAN_H

lib/esan/esan.cpp

if (WhichTool == ESAN_CacheFrag) {
     // FIXME NYI: we need to add sampling + callstack gathering and have a
     // strategy for how to generate a final report.
     // We'll move this to cache_frag.cpp once we have something.
     Report("%s is not finished: nothing yet to report\n", SanitizerToolName);
   }
   return 0;
 }
 
+void processCompilationUnitInit(void *Ptr) {
+  VPrintf(2, "in esan::%s\n", __FUNCTION__);
+}
+
+// This is called when the containing module is unloaded.
+// For the main executable module, this is called after finalizeLibrary.
+void processCompilationUnitExit(void *Ptr) {
+  VPrintf(2, "in esan::%s\n", __FUNCTION__);
+}
+
 } // namespace __esan

lib/esan/esan.syms.extra

 __esan_init
+__esan_exit
 __esan_aligned*
 __esan_unaligned*

lib/esan/esan_interface.cpp

 //===----------------------------------------------------------------------===//
 
 #include "esan_interface_internal.h"
 #include "esan.h"
 #include "sanitizer_common/sanitizer_internal_defs.h"
 
 using namespace __esan; // NOLINT
 
-void __esan_init(ToolType Tool) {
+void __esan_init(ToolType Tool, void *Ptr) {
+  WhichTool = Tool;
   initializeLibrary(Tool);
+  processCompilationUnitInit(Ptr);
+}
+
+void __esan_exit(void *Ptr) {
+  processCompilationUnitExit(Ptr);
 }
 
 void __esan_aligned_load1(void *Addr) {
   processRangeAccess(GET_CALLER_PC(), (uptr)Addr, 1, false);
 }
 
 void __esan_aligned_load2(void *Addr) {
   processRangeAccess(GET_CALLER_PC(), (uptr)Addr, 2, false);

lib/esan/esan_interface_internal.h

 // The value is passed as a 32-bit integer by the compiler.
 typedef enum Type : u32 {
   ESAN_None = 0,
   ESAN_CacheFrag,
 } ToolType;
 
 // This function should be called at the very beginning of the process,
 // before any instrumented code is executed and before any call to malloc.
-SANITIZER_INTERFACE_ATTRIBUTE void __esan_init(ToolType Tool);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_init(ToolType Tool, void *Ptr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_exit(void *Ptr);
 
 // The instrumentation module will insert a call to one of these routines prior
 // to each load and store instruction for which we do not have "fastpath"
 // inlined instrumentation.  These calls constitute the "slowpath" for our
 // tools.  We have separate routines for each type of memory access to enable
 // targeted optimization.
 SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_load1(void *Addr);
 SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_load2(void *Addr);

test/esan/TestCases/struct-simple.cpp

+// RUN: %clang_esan_frag -O0 %s -DPART -c -o %t-part.o 2>&1
+// RUN: %clang_esan_frag -O0 %s -DMAIN -c -o %t-main.o 2>&1
+// RUN: %clang_esan_frag -O0 %t-part.o %t-main.o -o %t 2>&1
+// RUN: %env_esan_opts=verbosity=2 %run %t 2>&1 | FileCheck %s
+
+// We generate two different object files from this file with different
+// macros, and then link them together. We do this to test how we handle
+// separate compilation with multiple compilation units.
+
+#include <stdio.h>
+
+extern "C" {
+  void part();
+}
+
+//===-- compilation unit without main function ----------------------------===//
+
+#ifdef PART
+void part()
+{
+}
+#endif // PART
+
+//===-- compilation unit with main function -------------------------------===//
+
+#ifdef MAIN
+int main(int argc, char **argv) {
+  // CHECK:      in esan::initializeLibrary
+  // CHECK:      in esan::processCompilationUnitInit
+  // CHECK:      in esan::processCompilationUnitInit
+  part();
+  return 0;
+  // CHECK-NEXT: in esan::finalizeLibrary
+  // CHECK-NEXT: {{.*}}EfficiencySanitizer is not finished: nothing yet to report
+  // CHECK:      in esan::processCompilationUnitExit
+  // CHECK:      in esan::processCompilationUnitExit
+}
+#endif // MAIN