[esan] Specify which tool via a global variable

[bruening]

Summary

Adds a global variable to specify the tool, to support handling early
interceptors that invoke instrumented code, thus requiring shadow memory to
be initialized prior to __esan_init() being invoked.

compiler-rt/trunk/lib/esan/esan.h

 #include "interception/interception.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "esan_interface_internal.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();

compiler-rt/trunk/lib/esan/esan.cpp

 // See comment below.
 extern "C" {
 extern void __cxa_atexit(void (*function)(void));
 }
 
 namespace __esan {
 
 bool EsanIsInitialized;
-ToolType WhichTool;
 ShadowMapping Mapping;
 
 // Different tools use different scales within the same shadow mapping scheme.
 // The scale used here must match that used by the compiler instrumentation.
 // This array is indexed by the ToolType enum.
 static const uptr ShadowScale[] = {
   0, // ESAN_None.
   2, // ESAN_CacheFrag: 4B:1B, so 4 to 1 == >>2.

 //    instantiate it separately for each tool, and call the selected
 //    tool's intercept setup code.
 // B) Build separate static runtime libraries, one for each tool.
 // C) Completely split the tools into separate sanitizers.
 
 void processRangeAccess(uptr PC, uptr Addr, int Size, bool IsWrite) {
   VPrintf(3, "in esan::%s %p: %c %p %d\n", __FUNCTION__, PC,
           IsWrite ? 'w' : 'r', Addr, Size);
-  if (WhichTool == ESAN_CacheFrag) {
+  if (__esan_which_tool == ESAN_CacheFrag) {
     // TODO(bruening): add shadow mapping and update shadow bits here.
     // We'll move this to cache_frag.cpp once we have something.
-  } else if (WhichTool == ESAN_WorkingSet) {
+  } else if (__esan_which_tool == ESAN_WorkingSet) {
     processRangeAccessWorkingSet(PC, Addr, Size, IsWrite);
   }
 }
 
 bool processSignal(int SigNum, void (*Handler)(int), void (**Result)(int)) {
-  if (WhichTool == ESAN_WorkingSet)
+  if (__esan_which_tool == ESAN_WorkingSet)
     return processWorkingSetSignal(SigNum, Handler, Result);
   return true;
 }
 
 bool processSigaction(int SigNum, const void *Act, void *OldAct) {
-  if (WhichTool == ESAN_WorkingSet)
+  if (__esan_which_tool == ESAN_WorkingSet)
     return processWorkingSetSigaction(SigNum, Act, OldAct);
   return true;
 }
 
 #if SANITIZER_DEBUG
 static bool verifyShadowScheme() {
   // Sanity checks for our shadow mapping scheme.
   uptr AppStart, AppEnd;

 }
 #endif
 
 static void initializeShadow() {
   verifyAddressSpace();
 
   DCHECK(verifyShadowScheme());
 
-  Mapping.initialize(ShadowScale[WhichTool]);
+  Mapping.initialize(ShadowScale[__esan_which_tool]);
 
   VPrintf(1, "Shadow scale=%d offset=%p\n", Mapping.Scale, Mapping.Offset);
 
   uptr ShadowStart, ShadowEnd;
   for (int i = 0; getShadowRegion(i, &ShadowStart, &ShadowEnd); ++i) {
     VPrintf(1, "Shadow #%d: [%zx-%zx) (%zuGB)\n", i, ShadowStart, ShadowEnd,
             (ShadowEnd - ShadowStart) >> 30);
 
     uptr Map;
-    if (WhichTool == ESAN_WorkingSet) {
+    if (__esan_which_tool == ESAN_WorkingSet) {
       // We want to identify all shadow pages that are touched so we start
       // out inaccessible.
       Map = (uptr)MmapFixedNoAccess(ShadowStart, ShadowEnd- ShadowStart,
                                     "shadow");
     } else {
       Map = (uptr)MmapFixedNoReserve(ShadowStart, ShadowEnd - ShadowStart,
                                      "shadow");
     }
for (int i = 0; getShadowRegion(i, &ShadowStart, &ShadowEnd); ++i) {
 
     // TODO: Call MmapNoAccess() on in-between regions.
   }
 }
 
 void initializeLibrary(ToolType Tool) {
   // We assume there is only one thread during init.
   if (EsanIsInitialized) {
-    CHECK(Tool == WhichTool);
+    CHECK(Tool == __esan_which_tool);
     return;
   }
-  WhichTool = Tool;
   SanitizerToolName = "EfficiencySanitizer";
   CacheBinaryName();
   initializeFlags();
 
   // Intercepting libc _exit or exit via COMMON_INTERCEPTOR_ON_EXIT only
   // finalizes on an explicit exit call by the app.  To handle a normal
   // exit we register an atexit handler.
   ::__cxa_atexit((void (*)())finalizeLibrary);
 
   VPrintf(1, "in esan::%s\n", __FUNCTION__);
-  if (WhichTool <= ESAN_None || WhichTool >= ESAN_Max) {
-    Printf("ERROR: unknown tool %d requested\n", WhichTool);
+  if (__esan_which_tool <= ESAN_None || __esan_which_tool >= ESAN_Max) {
+    Printf("ERROR: unknown tool %d requested\n", __esan_which_tool);
     Die();
   }
 
   initializeShadow();
   initializeInterceptors();
 
-  if (WhichTool == ESAN_CacheFrag) {
+  if (__esan_which_tool == ESAN_CacheFrag) {
     initializeCacheFrag();
-  } else if (WhichTool == ESAN_WorkingSet) {
+  } else if (__esan_which_tool == ESAN_WorkingSet) {
     initializeWorkingSet();
   }
 
   EsanIsInitialized = true;
 }
 
 int finalizeLibrary() {
   VPrintf(1, "in esan::%s\n", __FUNCTION__);
-  if (WhichTool == ESAN_CacheFrag) {
+  if (__esan_which_tool == ESAN_CacheFrag) {
     return finalizeCacheFrag();
-  } else if (WhichTool == ESAN_WorkingSet) {
+  } else if (__esan_which_tool == ESAN_WorkingSet) {
     return finalizeWorkingSet();
   }
   return 0;
 }
 
 void processCompilationUnitInit(void *Ptr) {
   VPrintf(2, "in esan::%s\n", __FUNCTION__);
-  if (WhichTool == ESAN_CacheFrag) {
+  if (__esan_which_tool == ESAN_CacheFrag) {
     DCHECK(Ptr != nullptr);
     processCacheFragCompilationUnitInit(Ptr);
   } else {
     DCHECK(Ptr == nullptr);
   }
 }
 
 // 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__);
-  if (WhichTool == ESAN_CacheFrag) {
+  if (__esan_which_tool == ESAN_CacheFrag) {
     DCHECK(Ptr != nullptr);
     processCacheFragCompilationUnitExit(Ptr);
   } else {
     DCHECK(Ptr == nullptr);
   }
 }
 
 } // namespace __esan

compiler-rt/trunk/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 *Ptr) {
-  WhichTool = Tool;
+  if (Tool != __esan_which_tool) {
+    Printf("ERROR: tool mismatch: %d vs %d\n", Tool, __esan_which_tool);
+    Die();
+  }
   initializeLibrary(Tool);
   processCompilationUnitInit(Ptr);
 }
 
 void __esan_exit(void *Ptr) {
   processCompilationUnitExit(Ptr);
 }
 

compiler-rt/trunk/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,
   ESAN_WorkingSet,
   ESAN_Max,
 } ToolType;
 
+// To handle interceptors that invoke instrumented code prior to
+// __esan_init() being called, the instrumentation module creates this
+// global variable specifying the tool.
+extern ToolType __esan_which_tool;
+
 // 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, 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