[sanitizer] Make function declarations C-compatible

[mcgrathr]

Summary

The public sanitizer headers are intended to be usable from either
C++ or C, but they declare no-argument functions with the syntax that
is not a proper prototype declaration in C. This goes unnoticed until
someone uses -Wsystem-headers.

include/sanitizer/allocator_interface.h

/* Returns true if p was returned by the allocator and
      is not yet freed. */
   int __sanitizer_get_ownership(const volatile void *p);
 
   /* Returns the number of bytes reserved for the pointer p.
      Requires (get_ownership(p) == true) or (p == 0). */
   size_t __sanitizer_get_allocated_size(const volatile void *p);
 
   /* Number of bytes, allocated and not yet freed by the application. */
-  size_t __sanitizer_get_current_allocated_bytes();
+  size_t __sanitizer_get_current_allocated_bytes(void);
 
   /* Number of bytes, mmaped by the allocator to fulfill allocation requests.
      Generally, for request of X bytes, allocator can reserve and add to free
      lists a large number of chunks of size X to use them for future requests.
      All these chunks count toward the heap size. Currently, allocator never
      releases memory to OS (instead, it just puts freed chunks to free
      lists). */
-  size_t __sanitizer_get_heap_size();
+  size_t __sanitizer_get_heap_size(void);
 
   /* Number of bytes, mmaped by the allocator, which can be used to fulfill
      allocation requests. When a user program frees memory chunk, it can first
      fall into quarantine and will count toward __sanitizer_get_free_bytes()
      later. */
-  size_t __sanitizer_get_free_bytes();
+  size_t __sanitizer_get_free_bytes(void);
 
   /* Number of bytes in unmapped pages, that are released to OS. Currently,
      always returns 0. */
-  size_t __sanitizer_get_unmapped_bytes();
+  size_t __sanitizer_get_unmapped_bytes(void);
 
   /* Malloc hooks that may be optionally provided by user.
      __sanitizer_malloc_hook(ptr, size) is called immediately after
        allocation of "size" bytes, which returned "ptr".
      __sanitizer_free_hook(ptr) is called immediately before
        deallocation of "ptr". */
   void __sanitizer_malloc_hook(const volatile void *ptr, size_t size);
   void __sanitizer_free_hook(const volatile void *ptr);
int __sanitizer_install_malloc_and_free_hooks(
       void (*malloc_hook)(const volatile void *, size_t),
       void (*free_hook)(const volatile void *));
 
   /* Drains allocator quarantines (calling thread's and global ones), returns
      freed memory back to OS and releases other non-essential internal allocator
      resources in attempt to reduce process RSS.
      Currently available with ASan only.
   */
-  void __sanitizer_purge_allocator();
+  void __sanitizer_purge_allocator(void);
 
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif

include/sanitizer/asan_interface.h

#endif
   // of the first such byte. Otherwise return 0.
   void *__asan_region_is_poisoned(void *beg, size_t size);
 
   // Print the description of addr (useful when debugging in gdb).
   void __asan_describe_address(void *addr);
 
   // Useful for calling from a debugger to get information about an ASan error.
   // Returns 1 if an error has been (or is being) reported, otherwise returns 0.
-  int __asan_report_present();
+  int __asan_report_present(void);
 
   // Useful for calling from a debugger to get information about an ASan error.
   // If an error has been (or is being) reported, the following functions return
   // the pc, bp, sp, address, access type (0 = read, 1 = write), access size and
   // bug description (e.g. "heap-use-after-free"). Otherwise they return 0.
-  void *__asan_get_report_pc();
-  void *__asan_get_report_bp();
-  void *__asan_get_report_sp();
-  void *__asan_get_report_address();
-  int __asan_get_report_access_type();
-  size_t __asan_get_report_access_size();
-  const char *__asan_get_report_description();
+  void *__asan_get_report_pc(void);
+  void *__asan_get_report_bp(void);
+  void *__asan_get_report_sp(void);
+  void *__asan_get_report_address(void);
+  int __asan_get_report_access_type(void);
+  size_t __asan_get_report_access_size(void);
+  const char *__asan_get_report_description(void);
 
   // Useful for calling from the debugger to get information about a pointer.
   // Returns the category of the given pointer as a constant string.
   // Possible return values are "global", "stack", "stack-fake", "heap",
   // "heap-invalid", "shadow-low", "shadow-gap", "shadow-high", "unknown".
   // If global or stack, tries to also return the variable name, address and
   // size. If heap, tries to return the chunk address and size. 'name' should
   // point to an allocated buffer of size 'name_size'.
#endif
   // Deprecated. Call __sanitizer_set_death_callback instead.
   void __asan_set_death_callback(void (*callback)(void));
 
   void __asan_set_error_report_callback(void (*callback)(const char*));
 
   // User may provide function that would be called right when ASan detects
   // an error. This can be used to notice cases when ASan detects an error, but
   // the program crashes before ASan report is printed.
-  void __asan_on_error();
+  void __asan_on_error(void);
 
   // Prints accumulated stats to stderr. Used for debugging.
-  void __asan_print_accumulated_stats();
+  void __asan_print_accumulated_stats(void);
 
   // This function may be optionally provided by user and should return
   // a string containing ASan runtime options. See asan_flags.h for details.
-  const char* __asan_default_options();
+  const char* __asan_default_options(void);
 
   // The following 2 functions facilitate garbage collection in presence of
   // asan's fake stack.
 
   // Returns an opaque handler to be used later in __asan_addr_is_in_fake_stack.
   // Returns NULL if the current thread does not have a fake stack.
-  void *__asan_get_current_fake_stack();
+  void *__asan_get_current_fake_stack(void);
 
   // If fake_stack is non-NULL and addr belongs to a fake frame in
   // fake_stack, returns the address on real stack that corresponds to
   // the fake frame and sets beg/end to the boundaries of this fake frame.
   // Otherwise returns NULL and does not touch beg/end.
   // If beg/end are NULL, they are not touched.
   // This function may be called from a thread other than the owner of
   // fake_stack, but the owner thread need to be alive.

include/sanitizer/common_interface_defs.h

#endif
 
   // Similar to __sanitizer_verify_contiguous_container but returns the address
   // of the first improperly poisoned byte otherwise. Returns null if the area
   // is poisoned properly.
   const void *__sanitizer_contiguous_container_find_bad_address(
       const void *beg, const void *mid, const void *end);
 
   // Print the stack trace leading to this call. Useful for debugging user code.
-  void __sanitizer_print_stack_trace();
+  void __sanitizer_print_stack_trace(void);
 
   // Symbolizes the supplied 'pc' using the format string 'fmt'.
   // Outputs at most 'out_buf_size' bytes into 'out_buf'.
   // The format syntax is described in
   // lib/sanitizer_common/sanitizer_stacktrace_printer.h.
   void __sanitizer_symbolize_pc(void *pc, const char *fmt, char *out_buf,
                                 size_t out_buf_size);
   // Same as __sanitizer_symbolize_pc, but for data section (i.e. globals).

include/sanitizer/coverage_interface.h

 
 #include <sanitizer/common_interface_defs.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
   // Record and dump coverage info.
-  void __sanitizer_cov_dump();
+  void __sanitizer_cov_dump(void);
 
   // Clear collected coverage info.
-  void __sanitizer_cov_reset();
+  void __sanitizer_cov_reset(void);
 
   // Dump collected coverage info. Sorts pcs by module into individual .sancov
   // files.
   void __sanitizer_dump_coverage(const uintptr_t *pcs, uintptr_t len);
 
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // SANITIZER_COVERAG_INTERFACE_H

include/sanitizer/esan_interface.h

 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 // This function can be called mid-run (or at the end of a run for
 // a server process that doesn't shut down normally) to request that
 // data for that point in the run be reported from the tool.
-void COMPILER_RT_WEAK __esan_report();
+void COMPILER_RT_WEAK __esan_report(void);
 
 // This function returns the number of samples that the esan tool has collected
 // to this point.  This is useful for testing.
-unsigned int COMPILER_RT_WEAK __esan_get_sample_count();
+unsigned int COMPILER_RT_WEAK __esan_get_sample_count(void);
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
 #endif // SANITIZER_ESAN_INTERFACE_H

include/sanitizer/hwasan_interface.h

 
 #include <sanitizer/common_interface_defs.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
   // This function may be optionally provided by user and should return
   // a string containing HWASan runtime options. See asan_flags.h for details.
-  const char* __hwasan_default_options();
+  const char* __hwasan_default_options(void);
 
-  void __hwasan_enable_allocator_tagging();
-  void __hwasan_disable_allocator_tagging();
+  void __hwasan_enable_allocator_tagging(void);
+  void __hwasan_disable_allocator_tagging(void);
 
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // SANITIZER_HWASAN_INTERFACE_H

include/sanitizer/lsan_interface.h

 
 #include <sanitizer/common_interface_defs.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
   // Allocations made between calls to __lsan_disable() and __lsan_enable() will
   // be treated as non-leaks. Disable/enable pairs may be nested.
-  void __lsan_disable();
-  void __lsan_enable();
+  void __lsan_disable(void);
+  void __lsan_enable(void);
 
   // The heap object into which p points will be treated as a non-leak.
   void __lsan_ignore_object(const void *p);
 
   // Memory regions registered through this interface will be treated as sources
   // of live pointers during leak checking. Useful if you store pointers in
   // mapped memory.
   // Points of note:
#endif
   // Check for leaks now. This function behaves identically to the default
   // end-of-process leak check. In particular, it will terminate the process if
   // leaks are found and the exitcode runtime flag is non-zero.
   // Subsequent calls to this function will have no effect and end-of-process
   // leak check will not run. Effectively, end-of-process leak check is moved to
   // the time of first invocation of this function.
   // By calling this function early during process shutdown, you can instruct
   // LSan to ignore shutdown-only leaks which happen later on.
-  void __lsan_do_leak_check();
+  void __lsan_do_leak_check(void);
 
   // Check for leaks now. Returns zero if no leaks have been found or if leak
   // detection is disabled, non-zero otherwise.
   // This function may be called repeatedly, e.g. to periodically check a
   // long-running process. It prints a leak report if appropriate, but does not
   // terminate the process. It does not affect the behavior of
   // __lsan_do_leak_check() or the end-of-process leak check, and is not
   // affected by them.
-  int __lsan_do_recoverable_leak_check();
+  int __lsan_do_recoverable_leak_check(void);
 
   // The user may optionally provide this function to disallow leak checking
   // for the program it is linked into (if the return value is non-zero). This
   // function must be defined as returning a constant value; any behavior beyond
   // that is unsupported.
   // To avoid dead stripping, you may need to define this function with
   // __attribute__((used))
-  int __lsan_is_turned_off();
+  int __lsan_is_turned_off(void);
 
   // This function may be optionally provided by user and should return
   // a string containing LSan runtime options. See lsan_flags.inc for details.
-  const char *__lsan_default_options();
+  const char *__lsan_default_options(void);
 
   // This function may be optionally provided by the user and should return
   // a string containing LSan suppressions.
-  const char *__lsan_default_suppressions();
+  const char *__lsan_default_suppressions(void);
 #ifdef __cplusplus
 }  // extern "C"
 
 namespace __lsan {
 class ScopedDisabler {
  public:
   ScopedDisabler() { __lsan_disable(); }
   ~ScopedDisabler() { __lsan_enable(); }
 };
 }  // namespace __lsan
 #endif
 
 #endif  // SANITIZER_LSAN_INTERFACE_H

include/sanitizer/msan_interface.h

#endif
   uint32_t __msan_get_origin(const volatile void *a);
 
   /* Test that this_id is a descendant of prev_id (or they are simply equal).
    * "descendant" here means they are part of the same chain, created with
    * __msan_chain_origin. */
   int __msan_origin_is_descendant_or_same(uint32_t this_id, uint32_t prev_id);
 
   /* Returns non-zero if tracking origins. */
-  int __msan_get_track_origins();
+  int __msan_get_track_origins(void);
 
   /* Returns the origin id of the latest UMR in the calling thread. */
-  uint32_t __msan_get_umr_origin();
+  uint32_t __msan_get_umr_origin(void);
 
   /* Make memory region fully initialized (without changing its contents). */
   void __msan_unpoison(const volatile void *a, size_t size);
 
   /* Make a null-terminated string fully initialized (without changing its
      contents). */
   void __msan_unpoison_string(const volatile char *a);
 
/* Print shadow and origin for the memory range to stderr in a human-readable
      format. */
   void __msan_print_shadow(const volatile void *x, size_t size);
 
   /* Print shadow for the memory range to stderr in a minimalistic
      human-readable format. */
   void __msan_dump_shadow(const volatile void *x, size_t size);
 
   /* Returns true if running under a dynamic tool (DynamoRio-based). */
-  int  __msan_has_dynamic_component();
+  int  __msan_has_dynamic_component(void);
 
   /* Tell MSan about newly allocated memory (ex.: custom allocator).
      Memory will be marked uninitialized, with origin at the call site. */
   void __msan_allocated_memory(const volatile void* data, size_t size);
 
   /* Tell MSan about newly destroyed memory. Mark memory as uninitialized. */
   void __sanitizer_dtor_callback(const volatile void* data, size_t size);
 
   /* This function may be optionally provided by user and should return
      a string containing Msan runtime options. See msan_flags.h for details. */
-  const char* __msan_default_options();
+  const char* __msan_default_options(void);
 
   /* Deprecated. Call __sanitizer_set_death_callback instead. */
   void __msan_set_death_callback(void (*callback)(void));
 
   /* Update shadow for the application copy of size bytes from src to dst.
      Src and dst are application addresses. This function does not copy the
      actual application memory, it only updates shadow and origin for such
      copy. Source and destination regions can overlap. */
   void __msan_copy_shadow(const volatile void *dst, const volatile void *src,
                           size_t size);
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif

include/sanitizer/scudo_interface.h

 
 #include <sanitizer/common_interface_defs.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
   // This function may be optionally provided by a user and should return
   // a string containing Scudo runtime options. See scudo_flags.h for details.
-  const char* __scudo_default_options();
+  const char* __scudo_default_options(void);
 
   // This function allows to set the RSS limit at runtime. This can be either
   // the hard limit (HardLimit=1) or the soft limit (HardLimit=0). The limit
   // can be removed by setting LimitMb to 0. This function's parameters should
   // be fully trusted to avoid security mishaps.
   void __scudo_set_rss_limit(unsigned long LimitMb, int HardLimit);
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // SANITIZER_SCUDO_INTERFACE_H_