[sanitizer] Further split private and public sanitizer headers.

And make msan_interface.h C-compatible.


git-svn-id: https://llvm.org/svn/llvm-project/compiler-rt/trunk@173928 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 32 insertions, 105 deletions

diff --git a/include/sanitizer/common_interface_defs.h b/include/sanitizer/common_interface_defs.h
index 9d8fa558..86338dcc 100644
--- a/include/sanitizer/common_interface_defs.h
+++ b/include/sanitizer/common_interface_defs.h
@@ -7,86 +7,32 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file is shared between AddressSanitizer and ThreadSanitizer.
-// It contains basic macro and types.
-// NOTE: This file may be included into user code.
+// Common part of the public sanitizer interface.
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_COMMON_INTERFACE_DEFS_H
 #define SANITIZER_COMMON_INTERFACE_DEFS_H
 
-// ----------- ATTENTION -------------
-// This header should NOT include any other headers to avoid portability issues.
-
-#if defined(_WIN32)
-// FIXME find out what we need on Windows. __declspec(dllexport) ?
-# define SANITIZER_INTERFACE_ATTRIBUTE
-# define SANITIZER_WEAK_ATTRIBUTE
-#elif defined(SANITIZER_GO)
-# define SANITIZER_INTERFACE_ATTRIBUTE
-# define SANITIZER_WEAK_ATTRIBUTE
-#else
-# define SANITIZER_INTERFACE_ATTRIBUTE __attribute__((visibility("default")))
-# define SANITIZER_WEAK_ATTRIBUTE  __attribute__((weak))
-#endif
-
-#ifdef __linux__
-# define SANITIZER_SUPPORTS_WEAK_HOOKS 1
-#else
-# define SANITIZER_SUPPORTS_WEAK_HOOKS 0
-#endif
-
-// __has_feature
-#if !defined(__has_feature)
-# define __has_feature(x) 0
-#endif
-
-// For portability reasons we do not include stddef.h, stdint.h or any other
-// system header, but we do need some basic types that are not defined
-// in a portable way by the language itself.
-namespace __sanitizer {
-
-#if defined(_WIN64)
-// 64-bit Windows uses LLP64 data model.
-typedef unsigned long long uptr;  // NOLINT
-typedef signed   long long sptr;  // NOLINT
-#else
-typedef unsigned long uptr;  // NOLINT
-typedef signed   long sptr;  // NOLINT
-#endif  // defined(_WIN64)
-#if defined(__x86_64__)
-// Since x32 uses ILP32 data model in 64-bit hardware mode,  we must use
-// 64-bit pointer to unwind stack frame.
-typedef unsigned long long uhwptr;  // NOLINT
-#else
-typedef uptr uhwptr;   // NOLINT
-#endif
-typedef unsigned char u8;
-typedef unsigned short u16;  // NOLINT
-typedef unsigned int u32;
-typedef unsigned long long u64;  // NOLINT
-typedef signed   char s8;
-typedef signed   short s16;  // NOLINT
-typedef signed   int s32;
-typedef signed   long long s64;  // NOLINT
-
-}  // namespace __sanitizer
+#include <stddef.h>
+#include <stdint.h>
 
+#ifdef __cplusplus
 extern "C" {
+#endif
   // Tell the tools to write their reports to "path.<pid>" instead of stderr.
-  void __sanitizer_set_report_path(const char *path)
-      SANITIZER_INTERFACE_ATTRIBUTE;
+  void __sanitizer_set_report_path(const char *path);
 
   // Tell the tools to write their reports to given file descriptor instead of
   // stderr.
-  void __sanitizer_set_report_fd(int fd)
-      SANITIZER_INTERFACE_ATTRIBUTE;
+  void __sanitizer_set_report_fd(int fd);
 
   // Notify the tools that the sandbox is going to be turned on. The reserved
   // parameter will be used in the future to hold a structure with functions
   // that the tools may call to bypass the sandbox.
-  void __sanitizer_sandbox_on_notify(void *reserved)
-      SANITIZER_WEAK_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE;
+  void __sanitizer_sandbox_on_notify(void *reserved);
+
+#ifdef __cplusplus
 }  // extern "C"
+#endif
 
 #endif  // SANITIZER_COMMON_INTERFACE_DEFS_H
diff --git a/include/sanitizer/msan_interface.h b/include/sanitizer/msan_interface.h
index 9887b61a..ceba6611 100644
--- a/include/sanitizer/msan_interface.h
+++ b/include/sanitizer/msan_interface.h
@@ -16,10 +16,6 @@
 
 #include <sanitizer/common_interface_defs.h>
 
-using __sanitizer::uptr;
-using __sanitizer::sptr;
-using __sanitizer::u32;
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -27,47 +23,37 @@ extern "C" {
 #if __has_feature(memory_sanitizer)
   /* Returns a string describing a stack origin.
      Return NULL if the origin is invalid, or is not a stack origin. */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  const char *__msan_get_origin_descr_if_stack(u32 id);
+  const char *__msan_get_origin_descr_if_stack(uint32_t id);
 
 
   /* Set raw origin for the memory range. */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  void __msan_set_origin(void *a, uptr size, u32 origin);
+  void __msan_set_origin(void *a, size_t size, uint32_t origin);
 
   /* Get raw origin for an address. */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  u32 __msan_get_origin(void *a);
+  uint32_t __msan_get_origin(void *a);
 
   /* Returns non-zero if tracking origins. */
-  SANITIZER_INTERFACE_ATTRIBUTE
   int __msan_get_track_origins();
 
   /* Returns the origin id of the latest UMR in the calling thread. */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  u32 __msan_get_umr_origin();
+  uint32_t __msan_get_umr_origin();
 
   /* Make memory region fully initialized (without changing its contents). */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  void __msan_unpoison(void *a, uptr size);
+  void __msan_unpoison(void *a, size_t size);
 
   /* Make memory region fully uninitialized (without changing its contents). */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  void __msan_poison(void *a, uptr size);
+  void __msan_poison(void *a, size_t size);
 
   /* Make memory region partially uninitialized (without changing its contents).
    */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  void __msan_partial_poison(void* data, void* shadow, uptr size);
+  void __msan_partial_poison(void* data, void* shadow, size_t size);
 
   /* Returns the offset of the first (at least partially) poisoned byte in the
      memory range, or -1 if the whole range is good. */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  sptr __msan_test_shadow(const void *x, uptr size);
+  intptr_t __msan_test_shadow(const void *x, size_t size);
 
   /* Set exit code when error(s) were detected.
      Value of 0 means don't change the program exit code. */
-  SANITIZER_INTERFACE_ATTRIBUTE
   void __msan_set_exit_code(int exit_code);
 
   /* For testing:
@@ -75,42 +61,37 @@ extern "C" {
      ... some buggy code ...
      __msan_set_expect_umr(0);
      The last line will verify that a UMR happened. */
-  SANITIZER_INTERFACE_ATTRIBUTE
   void __msan_set_expect_umr(int expect_umr);
 
   /* Print shadow and origin for the memory range to stdout in a human-readable
      format. */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  void __msan_print_shadow(const void *x, uptr size);
+  void __msan_print_shadow(const void *x, size_t size);
 
   /* Print current function arguments shadow and origin to stdout in a
      human-readable format. */
-  SANITIZER_INTERFACE_ATTRIBUTE
   void __msan_print_param_shadow();
 
   /* Returns true if running under a dynamic tool (DynamoRio-based). */
-  SANITIZER_INTERFACE_ATTRIBUTE
   int  __msan_has_dynamic_component();
 
   /* Tell MSan about newly allocated memory (ex.: custom allocator).
      Memory will be marked uninitialized, with origin at the call site. */
-  SANITIZER_INTERFACE_ATTRIBUTE
-  void __msan_allocated_memory(void* data, uptr size);
+  void __msan_allocated_memory(void* data, size_t size);
 
 #else  // __has_feature(memory_sanitizer)
 
-#define __msan_get_origin_descr_if_stack(u32 id) ((const char*)0)
-#define __msan_set_origin(void *a, uptr size, u32 origin)
-#define __msan_get_origin(void *a) ((u32)-1)
+#define __msan_get_origin_descr_if_stack(id) ((const char*)0)
+#define __msan_set_origin(a, size, origin)
+#define __msan_get_origin(a) ((uint32_t)-1)
 #define __msan_get_track_origins() (0)
-#define __msan_get_umr_origin() ((u32)-1)
-#define __msan_unpoison(void *a, uptr size)
-#define __msan_poison(void *a, uptr size)
-#define __msan_partial_poison(void* data, void* shadow, uptr size)
-#define __msan_test_shadow(const void *x, uptr size) ((sptr)-1)
-#define __msan_set_exit_code(int exit_code)
-#define __msan_set_expect_umr(int expect_umr)
-#define __msan_print_shadow(const void *x, uptr size)
+#define __msan_get_umr_origin() ((uint32_t)-1)
+#define __msan_unpoison(a, size)
+#define __msan_poison(a, size)
+#define __msan_partial_poison(data, shadow, size)
+#define __msan_test_shadow(x, size) ((intptr_t)-1)
+#define __msan_set_exit_code(exit_code)
+#define __msan_set_expect_umr(expect_umr)
+#define __msan_print_shadow(x, size)
 #define __msan_print_param_shadow()
 #define __msan_has_dynamic_component() (0)
 #define __msan_allocated_memory(data, size)