[esan] EfficiencySanitizer base runtime library

[bruening]

Summary

Adds the initial version of a runtime library for the new
EfficiencySanitizer ("esan") family of tools. The library includes:

+ Slowpath code via callouts from the compiler instrumentation for

each memory access.

+ Registration of atexit() to call finalization code.

+ Runtime option flags controlled by the environment variable

ESAN_OPTIONS.  The common sanitizer flags are supported such as
verbosity and log_path.

Still TODO: common code for libc interceptors and shadow memory mapping,
and tool-specific code for shadow state updating.

[vitalybuka]

lib/esan/esan.cc

54

This looks inconsistent with functions below.
why it's SizeLog, not just Size and round up to the power of 2 here?

lib/esan/esan.h

41

I am new to this code, so is there a convention for this?
Why not enum or even: constexpr sizeLog(size_t size) {...}

[aizatsky]

cmake/config-ix.cmake

633

is CFI_SUPPORTED_ARCH expected here?

lib/esan/esan.cc

84

replace by a call to InitializeCommonFlags (sanitizer_flags.h)

lib/esan/esan_interface.cc

25

I'm not sure if it will help with inlining because you add calls during instrumentation.

47

any special reason why not kSizeLog16?

lib/esan/esan_interface.h

37

Is there a reason why you have lots of _N functions instead of

__esan_aligned_write(void* Addr, size_t sizeLog)?

Each one of these makes this kind of call anyway.

[bruening]

cmake/config-ix.cmake

633

No, that is an error: it should be ESAN_.

lib/esan/esan.cc

54

The log is passed from the compiler partly to simplify the indexing in its own code. We're not doing anything with the log in the runtime, so it would probably be cleaner to change this to Size. I'll do that.

84

Agreed.

lib/esan/esan.h

41

This is based on what tsan does. However, we are leaning toward just throwing these out here as the log is not used for anything.

lib/esan/esan_interface.cc

47

No, this is an artifact coming from tsan. For us we are not limited to 8 so this could become a single call (and as mentioned above we can move away from the log here). I will change it.

lib/esan/esan_interface.h

37

The initial reason was precedence: that's what asan and tsan do. A (maybe minor) reason not to change is that if profiling shows this slowpath time causing bottlenecks we can more easily write dedicated handlers for each size.

[bruening]

Addresses reviewer comments

[eugenis]

lib/esan/esan.h

22

typo: headers

33

sanitizer_internal_defs.h:# define GET_CALLER_PC() (uptr)__builtin_return_address(0)

lib/esan/esan_interface.h

15

If this is meant to be included by the instrumented program, it should go under include/sanitizer. And not use sanitizer_internal_defs.h.

[aizatsky]

lib/esan/esan_interface.h

15

Maybe this should be esan_internal_interface.h? I don't suppose any functions here should be called manually.

39

Please add a general comment about this group of functions: when are they called (and when they are not). Comments on interface between instrumenter/runtime are really helpful.

[bruening]

Address reviewer comments: rename header, fix typo.

lib/esan/esan_interface.h

15

Removing that comment line. It was based on lib/tsan/tsan_interface.h (which should be in include/sanitizer?) but our only use is insertion via instrumentation.

15

Will rename to esan_interface_internal.h to mirror asan and msan. Unfortunately that will likely make the prior comments not linked to the new file unless this review system is that advanced.

[filcab]

Thanks again, for working on this.
Please add tests so that we're always sure the current code is building+running correctly.

lib/esan/esan.cc

67

If you end up calling the "range access" function on both the above cases, then I see no reason to have it split from the other two.
processRangeAccess should be able to do everything.

It's trivial to think of occasions when this wouldn't happen. And I understand this is a skeleton, but I'd prefer (for now) to either:
Remove the processRangeAccess be called only when the others aren't. Or only have processRangeAccess.
(In the future, the "other path" will be added, I'm sure. But I don't think it's necessary for the current skeleton proposal, and it's very easy for some of this to fall into dead-code land)

lib/esan/esan.h

42

Mem vs Unaligned seems weird. Maybe Aligned vs Unaligned explains it better.

lib/esan/esan_interface.cc

24

__esan_init() will be called more than once.
We should make sure we're always called with the same tool as argument.

[aizatsky]

One nit. LG otherwise.

lib/esan/esan_interface_internal.h

38 ↗

(On Diff #54287)

Specify if it will insert call before or after the read/write.

[kubamracek]

lib/esan/esan.h

39–41

All the other sanitizers use capitalized function names (with the first letter capitalized as well). Can we do this in ESan as well? E.g. InitializeLibrary, FinalizeLibrary, ProcessMemAccess, etc.

[aizatsky]

lib/esan/esan.h

39–41

Chandler asked us specifically to adhere to LLVM coding and naming guidelines.

[bruening]

lib/esan/esan.h

39–41

Right, I talked to Kostya about this before and he asked for new files to use LLVM standards, while the existing files would remain internally consistent with their current style.

[bruening]

In D19168#406567, @filcab wrote:

Please add tests so that we're always sure the current code is building+running correctly.

The skeleton framework was split up for smaller reviews: libc interceptors, shadow mapping, and test infrastructure were deliberately not included here. I can merge test infra into here but there is not much that can be tested at this point.

[bruening]

Add test infrastructure

[filcab]

Almost LGTM with a few minor comments, now.
Thank you!

lib/esan/CMakeLists.txt

8

No need to have this variable if it's the same as ESAN_CFLAGS

lib/esan/esan.cc

32

EsanOptsEnv, to keep consistency with other abbreviations of Options
Since you're changing this line, why not the shorter static const char EsanOptsEnv[] = "..."?

lib/esan/esan_interface_internal.h

24 ↗

(On Diff #54432)

This is an internal definition of the interface, it should always be compiled as C++.

28 ↗

(On Diff #54432)

Pop this off to something like lib/esan/esan_internal_defs.h.

29 ↗

(On Diff #54432)

In the instrumentation pass, you get the function with an i32 argument.
Should we fix the size of this enum to be 32-bits (I don't know of any practical problems in a common arch with this as it is off the top of my head, though)?

lib/sanitizer_common/sanitizer_common_interceptors.inc

35

Please split this comment addition to a separate commit.

test/esan/lit.cfg

28 ↗

(On Diff #54432)

Since this is new and adhering to LLVM conventions, we can probably remove the .cc, right?

31 ↗

(On Diff #54432)

I really don't like testing host_os. ESan availability will depend on the target, not the host.
Right now there's no better option in lit, so let's do it this way.
But I'll ask you to try and keep test command lines to constructs that lit's shell knows how to parse, if possible/easy.

34 ↗

(On Diff #54432)

You can merge this with the above:

if config.host_os not in ['Linux'] or config.target_arch != 'x86_64':
  config.unsupported = True

[bruening]

lib/esan/esan_interface_internal.h

24 ↗

(On Diff #54432)

This is the interface between the compiler instrumentation and the runtime library. It is C for simplicity. This matches what all the existing sanitizers do.

28 ↗

(On Diff #54432)

To me that sounds like definitions internal to the runtime library and not shared with anything else, while these are part of the interface with the compiler instrumentation. (Having "internal" in the name of this file was not my first choice: requested as part of this review.) The parallel files tsan_interface.h and asan_interface_internal.h also have types in the same file.

29 ↗

(On Diff #54432)

You mean, make this a type-less enumerator and typedef u32 as ToolType? That is less appealing. I will add a static_assert on the sizeof to the .cc file.

lib/sanitizer_common/sanitizer_common_interceptors.inc

35

It is a continuation of this header comment about what macros the including file needs to define, making a comment on one of them. Probably it looks different only seeing this patch window of a few lines. Please take a look at the entire top of this file.

test/esan/lit.cfg

28 ↗

(On Diff #54432)

Hmm, I suppose the runtime library implementation files should be renamed from esan.cc to esan.cpp, etc. as well. That will churn the review diff but few comments are in the impl files.

31 ↗

(On Diff #54432)

Note that every existing sanitizer lit.cfg tests host_os.

[bruening]

Rename .cc to .cpp; add unusually-sized callouts.

[filcab]

Not much to do now except for some final problems. I'll LGTM since I might not be able to reply today and I only need minor fixes.

lib/esan/esan_interface_internal.h

25 ↗

(On Diff #54550)

Sorry, I have the annotation in the wrong line. I'm not complaining about the extern "C".
The #ifdef __cplusplus is always true, since this is the internal (for the library only) definition of the API, which we know will always be compiled as C++. (Check ASan's asan_interface_internal.h. TSan has the ifdefs because of one unit test. Otherwise, it wouldn't need the ifdef either)

29 ↗

(On Diff #54550)

My problem was with having the type defined twice, but it seems I messed up when looking for ESAN_CacheFrag.
The constants are only defined once inside compiler-rt, so it's good. Sorry about that.

30 ↗

(On Diff #54550)

No. It was more about fixing the underlying type:
http://en.cppreference.com/w/cpp/language/enum
Version (2) of "Unscoped enumeration".

lib/sanitizer_common/sanitizer_common_interceptors.inc

35

The problem is that later, when blaming that file, people will see this commit, and possibly spend time looking at it because of an unrelated change.
I'm totally ok with adding the comment, I think it's useful. But I don't think it belongs to the "Introduce ESan" commit.

test/esan/lit.cfg

29 ↗

(On Diff #54550)

Since these are all new files, probably it would be best to use .cpp to adhere more to llvm current practice.

32 ↗

(On Diff #54550)

Yeah, unfortunately this is what we have now.
No problems here, as there's no good solution you can start using. I ended up ranting a bit. Sorry about the noise.

[bruening]

lib/esan/esan_interface_internal.h

30 ↗

(On Diff #54550)

That is on the list of C++11 allowed in LLVM, but putting it inside the extern "C" feels wrong (hence why it seemed the only solution was what I mentioned). I suppose it's fine if there is no C program that includes the header, which is the case if we are able to remove the ifdef __cplusplus.

[bruening]

lib/sanitizer_common/sanitizer_common_interceptors.inc

35

Oh, I misread "to a separate commit" as "to a separate comment".

cmake/config-ix.cmake

 set(ALL_MSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64})
 set(ALL_PROFILE_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64} ${PPC64}
     ${MIPS32} ${MIPS64})
 set(ALL_TSAN_SUPPORTED_ARCH ${X86_64} ${MIPS64} ${ARM64} ${PPC64})
 set(ALL_UBSAN_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM32} ${ARM64}
     ${MIPS32} ${MIPS64} ${PPC64})
 set(ALL_SAFESTACK_SUPPORTED_ARCH ${X86} ${X86_64} ${ARM64} ${MIPS32} ${MIPS64})
 set(ALL_CFI_SUPPORTED_ARCH ${X86} ${X86_64})
+set(ALL_ESAN_SUPPORTED_ARCH ${X86_64})
 
 if(APPLE)
   include(CompilerRTDarwinUtils)
 
   # On Darwin if /usr/include doesn't exist, the user probably has Xcode but not
   # the command line tools. If this is the case, we need to find the OS X
   # sysroot to pass to clang.
   if(NOT EXISTS /usr/include)
list_intersect(UBSAN_SUPPORTED_ARCH
     ALL_UBSAN_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(SAFESTACK_SUPPORTED_ARCH
     ALL_SAFESTACK_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
   list_intersect(CFI_SUPPORTED_ARCH
     ALL_CFI_SUPPORTED_ARCH
     SANITIZER_COMMON_SUPPORTED_ARCH)
+  list_intersect(ESAN_SUPPORTED_ARCH
+    ALL_ESAN_SUPPORTED_ARCH
+    SANITIZER_COMMON_SUPPORTED_ARCH)
 else()
   # Architectures supported by compiler-rt libraries.
   filter_available_targets(BUILTIN_SUPPORTED_ARCH
     ${ALL_BUILTIN_SUPPORTED_ARCH})
   filter_available_targets(SANITIZER_COMMON_SUPPORTED_ARCH
     ${ALL_SANITIZER_COMMON_SUPPORTED_ARCH})
   # LSan and UBSan common files should be available on all architectures
   # supported by other sanitizers (even if they build into dummy object files).
   filter_available_targets(LSAN_COMMON_SUPPORTED_ARCH
     ${SANITIZER_COMMON_SUPPORTED_ARCH})
   filter_available_targets(UBSAN_COMMON_SUPPORTED_ARCH
     ${SANITIZER_COMMON_SUPPORTED_ARCH})
   filter_available_targets(ASAN_SUPPORTED_ARCH ${ALL_ASAN_SUPPORTED_ARCH})
   filter_available_targets(DFSAN_SUPPORTED_ARCH ${ALL_DFSAN_SUPPORTED_ARCH})
   filter_available_targets(LSAN_SUPPORTED_ARCH ${ALL_LSAN_SUPPORTED_ARCH})
   filter_available_targets(MSAN_SUPPORTED_ARCH ${ALL_MSAN_SUPPORTED_ARCH})
   filter_available_targets(PROFILE_SUPPORTED_ARCH ${ALL_PROFILE_SUPPORTED_ARCH})
   filter_available_targets(TSAN_SUPPORTED_ARCH ${ALL_TSAN_SUPPORTED_ARCH})
   filter_available_targets(UBSAN_SUPPORTED_ARCH ${ALL_UBSAN_SUPPORTED_ARCH})
   filter_available_targets(SAFESTACK_SUPPORTED_ARCH
     ${ALL_SAFESTACK_SUPPORTED_ARCH})
   filter_available_targets(CFI_SUPPORTED_ARCH ${ALL_CFI_SUPPORTED_ARCH})
+  filter_available_targets(ESAN_SUPPORTED_ARCH ${ALL_ESAN_SUPPORTED_ARCH})
 endif()
 
 if (MSVC)
   # See if the DIA SDK is available and usable.
   set(MSVC_DIA_SDK_DIR "$ENV{VSINSTALLDIR}DIA SDK")
   if (IS_DIRECTORY ${MSVC_DIA_SDK_DIR})
     set(CAN_SYMBOLIZE 1)
   else()

 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND CFI_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux")
   set(COMPILER_RT_HAS_CFI TRUE)
 else()
   set(COMPILER_RT_HAS_CFI FALSE)
 endif()
+
+if (COMPILER_RT_HAS_SANITIZER_COMMON AND CFI_SUPPORTED_ARCH AND
+    OS_NAME MATCHES "Linux")
+  set(COMPILER_RT_HAS_ESAN TRUE)
+else()
+  set(COMPILER_RT_HAS_ESAN FALSE)
+endif()

lib/CMakeLists.txt

if(COMPILER_RT_BUILD_SANITIZERS)
 
   if(COMPILER_RT_HAS_SAFESTACK)
     add_subdirectory(safestack)
   endif()
 
   if(COMPILER_RT_HAS_CFI)
     add_subdirectory(cfi)
   endif()
+
+  if(COMPILER_RT_HAS_ESAN)
+    add_subdirectory(esan)
+  endif()
 endif()

lib/esan/CMakeLists.txt

+# Build for the EfficiencySanitizer runtime support library.
+
+add_custom_target(esan)
+
+set(ESAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_rtti_flag(OFF ESAN_CFLAGS)
+set(ESAN_RTL_CFLAGS ${ESAN_CFLAGS})
+
+include_directories(..)
+
+set(ESAN_SOURCES
+  esan.cc
+  esan_interface.cc)
+
+foreach (arch ${ESAN_SUPPORTED_ARCH})
+  add_compiler_rt_runtime(clang_rt.esan
+    STATIC
+    ARCHS ${arch}
+    SOURCES ${ESAN_SOURCES}
+            $<TARGET_OBJECTS:RTInterception.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommon.${arch}>
+            $<TARGET_OBJECTS:RTSanitizerCommonLibc.${arch}>
+    CFLAGS ${ESAN_RTL_CFLAGS})
+  add_sanitizer_rt_symbols(clang_rt.esan
+    ARCHS ${arch}
+    EXTRA esan.syms.extra)
+  add_dependencies(esan
+    clang_rt.esan-${arch}
+    clang_rt.esan-${arch}-symbols)
+endforeach()
+
+add_dependencies(compiler-rt esan)
+
+if (COMPILER_RT_INCLUDE_TESTS)
+  # TODO(bruening): add tests via add_subdirectory(tests)
+endif()

lib/esan/esan.h

+//===-- esan.h --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of EfficiencySanitizer, a family of performance tuners.
+//
+// Main internal esan header file.
+//
+// Ground rules:
+//   - C++ run-time should not be used (static CTORs, RTTI, exceptions, static
+//     function-scope locals)
+//   - All functions/classes/etc reside in namespace __esan, except for those
+//     declared in esan_interface.h.
+//   - Platform-specific files should be used instead of ifdefs (*).
+//   - No system headers included in header files (*).
+//   - Platform specific headres included only into platform-specific files (*).
+//
+//  (*) Except when inlining is critical for performance.
+//===----------------------------------------------------------------------===//
+
+#ifndef ESAN_H
+#define ESAN_H
+
+#include "sanitizer_common/sanitizer_common.h"
+#include "esan_interface.h"
+
+#define CALLERPC ((uptr)__builtin_return_address(0))
+
+namespace __esan {
+
+extern bool EsanIsInitialized;
+
+extern ToolType WhichTool;
+
+const int kSizeLog1 = 0;
+const int kSizeLog2 = 1;
+const int kSizeLog4 = 2;
+const int kSizeLog8 = 3;
+
+void initializeLibrary();
+int finalizeLibrary();
+void processMemAccess(uptr PC, uptr Addr, int SizeLog, bool IsWrite);
+void processUnalignedAccess(uptr PC, uptr Addr, int Size, bool IsWrite);
+void processRangeAccess(uptr PC, uptr Addr, int Size, bool IsWrite);
+
+} // namespace __esan
+
+#endif  // ESAN_H

lib/esan/esan.cc

+//===-- esan.cc ----------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of EfficiencySanitizer, a family of performance tuners.
+//
+// Main file (entry points) for the Esan run-time.
+//===----------------------------------------------------------------------===//
+
+#include "esan.h"
+#include "esan_interface.h"
+#include "sanitizer_common/sanitizer_common.h"
+#include "sanitizer_common/sanitizer_flags.h"
+#include "sanitizer_common/sanitizer_flag_parser.h"
+
+// See comment below.
+extern "C" {
+  extern void __cxa_atexit(void (*function)(void));
+}
+
+namespace __esan {
+
+bool EsanIsInitialized;
+ToolType WhichTool;
+
+static const char * const kEsanOpsEnv = "ESAN_OPTIONS";
+
+// We are combining multiple performance tuning tools under the umbrella of
+// one EfficiencySanitizer super-tool.  Most of our tools have very similar
+// memory access instrumentation, shadow memory mapping, libc interception,
+// etc., and there is typically more shared code than distinct code.
+//
+// We are not willing to dispatch on tool dynamically in our fastpath
+// instrumentation: thus, which tool to use is a static option selected
+// at compile time and passed to __esan_init().
+//
+// We are willing to pay the overhead of tool dispatch in the slowpath to more
+// easily share code.  We expect to only come here rarely.
+// If this becomes a performance hit, we can add separate interface
+// routines for each subtool (e.g., __esan_cache_frag_aligned_read_4).
+// But for libc interceptors, we'll have to do one of the following:
+// A) Add multiple-include support to sanitizer_common_interceptors.inc,
+//    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.
+
+ALWAYS_INLINE USED
+void processMemAccess(uptr PC, uptr Addr, int SizeLog, bool IsWrite) {
+  VPrintf(4, "in esan::%s %p: %c %p %d\n", __FUNCTION__, PC,
+         IsWrite ? 'w' : 'r', Addr, 1 << SizeLog);
+  // We expect common accesses to be inlined so we go for simplicity here:
+  processRangeAccess(PC, Addr, 1 << SizeLog, IsWrite);
+}
+
+ALWAYS_INLINE USED
+void processUnalignedAccess(uptr PC, uptr Addr, int Size, bool IsWrite) {
+  VPrintf(4, "in esan::%s %p: %c %p %d\n", __FUNCTION__, PC,
+         IsWrite ? 'w' : 'r', Addr, Size);
+  processRangeAccess(PC, Addr, Size, IsWrite);
+}
+
+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) {
+    // TODO(bruening): add shadow mapping and update shadow bits here.
+    // We'll move this to cache_frag.cc once we have something.
+  }
+}
+
+static void initializeFlags() {
+  // Once we add our own flags we'll parse them here.
+  // For now the common ones are sufficient.
+  FlagParser parser;
+  SetCommonFlagsDefaults();
+  RegisterCommonFlags(&parser);
+  parser.ParseString(GetEnv(kEsanOpsEnv));
+  SetVerbosity(common_flags()->verbosity);
+  if (Verbosity())
+    ReportUnrecognizedFlags();
+  if (common_flags()->help)
+    parser.PrintFlagDescriptions();
+  __sanitizer_set_report_path(common_flags()->log_path);
+}
+
+void initializeLibrary() {
+  // We assume there is only one thread during init.
+  if (EsanIsInitialized)
+    return;
+  SanitizerToolName = "EfficiencySanitizer";
+  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_CacheFrag) {
+    Printf("ERROR: unknown tool %d requested\n", WhichTool);
+    Die();
+  }
+
+  EsanIsInitialized = true;
+}
+
+int finalizeLibrary() {
+  VPrintf(1, "in esan::%s\n", __FUNCTION__);
+  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.cc once we have something.
+    Report("%s is not finished: nothing yet to report\n", SanitizerToolName);
+  }
+  return 0;
+}
+
+} // namespace __esan

lib/esan/esan.syms.extra

+__esan_init
+__esan_aligned*
+__esan_unaligned*

lib/esan/esan_interface.h

+//===-- esan_interface.h ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of EfficiencySanitizer, a family of performance tuners.
+//
+// The functions declared in this header will be inserted by the instrumentation
+// module.
+// This header can be included by the instrumented program or by esan tests.
+//===----------------------------------------------------------------------===//
+#ifndef ESAN_INTERFACE_H
+#define ESAN_INTERFACE_H
+
+#include <sanitizer_common/sanitizer_internal_defs.h>
+
+// This header should NOT include any other headers.
+// All functions in this header are extern "C" and start with __esan_.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This should be kept consistent with LLVM's EfficiencySanitizerOptions.
+typedef enum Type {
+  ESAN_CacheFrag = 0,
+} 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_aligned_read1(void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_read2(void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_read4(void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_read8(void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_read16(void *Addr);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_write1(void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_write2(void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_write4(void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_write8(void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_aligned_write16(void *Addr);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_unaligned_read2(const void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_unaligned_read4(const void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_unaligned_read8(const void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_unaligned_read16(const void *Addr);
+
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_unaligned_write2(const void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_unaligned_write4(const void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_unaligned_write8(const void *Addr);
+SANITIZER_INTERFACE_ATTRIBUTE void __esan_unaligned_write16(const void *Addr);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // ESAN_INTERFACE_H

lib/esan/esan_interface.cc

+//===-- esan_interface.cc -------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of EfficiencySanitizer, a family of performance tuners.
+//
+//===----------------------------------------------------------------------===//
+
+#include "esan_interface.h"
+#include "esan.h"
+#include "sanitizer_common/sanitizer_internal_defs.h"
+
+using namespace __esan;  // NOLINT
+
+void __esan_init(ToolType Tool) {
+  WhichTool = Tool;
+  initializeLibrary();
+}
+
+// TODO(bruening): put all of these in a header to ensure inlining -- though
+// we expect calling these to be rare as our instrumentation-inlined fastpath
+// should handle all of the common cases.
+
+void __esan_aligned_read1(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog1, false);
+}
+
+void __esan_aligned_read2(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog2, false);
+}
+
+void __esan_aligned_read4(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog4, false);
+}
+
+void __esan_aligned_read8(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog8, false);
+}
+
+void __esan_aligned_read16(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog8, false);
+  processMemAccess(CALLERPC, (uptr)Addr + 8, kSizeLog8, false);
+}
+
+void __esan_aligned_write1(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog1, true);
+}
+
+void __esan_aligned_write2(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog2, true);
+}
+
+void __esan_aligned_write4(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog4, true);
+}
+
+void __esan_aligned_write8(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog8, true);
+}
+
+void __esan_aligned_write16(void *Addr) {
+  processMemAccess(CALLERPC, (uptr)Addr, kSizeLog8, true);
+  processMemAccess(CALLERPC, (uptr)Addr + 8, kSizeLog8, true);
+}
+
+void __esan_unaligned_read2(const void *Addr) {
+  processUnalignedAccess(CALLERPC, (uptr)Addr, 2, false);
+}
+
+void __esan_unaligned_read4(const void *Addr) {
+  processUnalignedAccess(CALLERPC, (uptr)Addr, 4, false);
+}
+
+void __esan_unaligned_read8(const void *Addr) {
+  processUnalignedAccess(CALLERPC, (uptr)Addr, 8, false);
+}
+
+void __esan_unaligned_read16(const void *Addr) {
+  processUnalignedAccess(CALLERPC, (uptr)Addr, 16, false);
+}
+
+void __esan_unaligned_write2(const void *Addr) {
+  processUnalignedAccess(CALLERPC, (uptr)Addr, 2, true);
+}
+
+void __esan_unaligned_write4(const void *Addr) {
+  processUnalignedAccess(CALLERPC, (uptr)Addr, 4, true);
+}
+
+void __esan_unaligned_write8(const void *Addr) {
+  processUnalignedAccess(CALLERPC, (uptr)Addr, 8, true);
+}
+
+void __esan_unaligned_write16(const void *Addr) {
+  processUnalignedAccess(CALLERPC, (uptr)Addr, 16, true);
+}

lib/sanitizer_common/sanitizer_common_interceptors.inc

 //   COMMON_INTERCEPTOR_ON_DLOPEN
 //   COMMON_INTERCEPTOR_ON_EXIT
 //   COMMON_INTERCEPTOR_MUTEX_LOCK
 //   COMMON_INTERCEPTOR_MUTEX_UNLOCK
 //   COMMON_INTERCEPTOR_MUTEX_REPAIR
 //   COMMON_INTERCEPTOR_SET_PTHREAD_NAME
 //   COMMON_INTERCEPTOR_HANDLE_RECVMSG
 //   COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED
+//
+// COMMON_INTERCEPTOR_ON_EXIT is only called if the app explicitly calls exit(),
+// not on a normal exit.
 //===----------------------------------------------------------------------===//
 
 #include "interception/interception.h"
 #include "sanitizer_addrhashmap.h"
 #include "sanitizer_placement_new.h"
 #include "sanitizer_platform_interceptors.h"
 #include "sanitizer_tls_get_addr.h"