__sanitizer_cdecl -> SANITIZER_CDECL

Author: strega-nil

compiler-rt/include/sanitizer/allocator_interface.h

@@ -21,54 +21,54 @@ extern "C" {
    for request of "size" bytes. If allocator can't allocate that much
    memory, returns the maximal possible allocation size, otherwise returns
    "size". */
-size_t __sanitizer_cdecl __sanitizer_get_estimated_allocated_size(size_t size);
+size_t SANITIZER_CDECL __sanitizer_get_estimated_allocated_size(size_t size);
 
 /* Returns true if p was returned by the allocator and
    is not yet freed. */
-int __sanitizer_cdecl __sanitizer_get_ownership(const volatile void *p);
+int SANITIZER_CDECL __sanitizer_get_ownership(const volatile void *p);
 
 /* If a pointer lies within an allocation, it will return the start address
    of the allocation. Otherwise, it returns nullptr. */
-const void *__sanitizer_cdecl __sanitizer_get_allocated_begin(const void *p);
+const void *SANITIZER_CDECL __sanitizer_get_allocated_begin(const void *p);
 
 /* Returns the number of bytes reserved for the pointer p.
    Requires (get_ownership(p) == true) or (p == 0). */
-size_t __sanitizer_cdecl __sanitizer_get_allocated_size(const volatile void *p);
+size_t SANITIZER_CDECL __sanitizer_get_allocated_size(const volatile void *p);
 
 /* Returns the number of bytes reserved for the pointer p.
    Requires __sanitizer_get_allocated_begin(p) == p. */
-size_t __sanitizer_cdecl
+size_t SANITIZER_CDECL
 __sanitizer_get_allocated_size_fast(const volatile void *p);
 
 /* Number of bytes, allocated and not yet freed by the application. */
-size_t __sanitizer_cdecl __sanitizer_get_current_allocated_bytes(void);
+size_t SANITIZER_CDECL __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_cdecl __sanitizer_get_heap_size(void);
+size_t SANITIZER_CDECL __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_cdecl __sanitizer_get_free_bytes(void);
+size_t SANITIZER_CDECL __sanitizer_get_free_bytes(void);
 
 /* Number of bytes in unmapped pages, that are released to OS. Currently,
    always returns 0. */
-size_t __sanitizer_cdecl __sanitizer_get_unmapped_bytes(void);
+size_t SANITIZER_CDECL __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_cdecl __sanitizer_malloc_hook(const volatile void *ptr,
+void SANITIZER_CDECL __sanitizer_malloc_hook(const volatile void *ptr,
                                                size_t size);
-void __sanitizer_cdecl __sanitizer_free_hook(const volatile void *ptr);
+void SANITIZER_CDECL __sanitizer_free_hook(const volatile void *ptr);
 
 /* Installs a pair of hooks for malloc/free.
    Several (currently, 5) hook pairs may be installed, they are executed
@@ -82,16 +82,16 @@ void __sanitizer_cdecl __sanitizer_free_hook(const volatile void *ptr);
    Not thread-safe, should be called in the main thread before starting
    other threads.
 */
-int __sanitizer_cdecl __sanitizer_install_malloc_and_free_hooks(
-    void (*__sanitizer_cdecl malloc_hook)(const volatile void *, size_t),
-    void (*__sanitizer_cdecl free_hook)(const volatile void *));
+int SANITIZER_CDECL __sanitizer_install_malloc_and_free_hooks(
+    void (*SANITIZER_CDECL malloc_hook)(const volatile void *, size_t),
+    void (*SANITIZER_CDECL 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_cdecl __sanitizer_purge_allocator(void);
+void SANITIZER_CDECL __sanitizer_purge_allocator(void);
 #ifdef __cplusplus
 } // extern "C"
 #endif

compiler-rt/include/sanitizer/asan_interface.h

@@ -31,7 +31,7 @@ extern "C" {
 ///
 /// \param addr Start of memory region.
 /// \param size Size of memory region.
-void __sanitizer_cdecl __asan_poison_memory_region(void const volatile *addr,
+void SANITIZER_CDECL __asan_poison_memory_region(void const volatile *addr,
                                                    size_t size);
 
 /// Marks a memory region (<c>[addr, addr+size)</c>) as addressable.
@@ -46,7 +46,7 @@ void __sanitizer_cdecl __asan_poison_memory_region(void const volatile *addr,
 ///
 /// \param addr Start of memory region.
 /// \param size Size of memory region.
-void __sanitizer_cdecl __asan_unpoison_memory_region(void const volatile *addr,
+void SANITIZER_CDECL __asan_unpoison_memory_region(void const volatile *addr,
                                                      size_t size);
 
 // Macros provided for convenience.
@@ -85,7 +85,7 @@ void __sanitizer_cdecl __asan_unpoison_memory_region(void const volatile *addr,
 ///
 /// \retval 1 Address is poisoned.
 /// \retval 0 Address is not poisoned.
-int __sanitizer_cdecl __asan_address_is_poisoned(void const volatile *addr);
+int SANITIZER_CDECL __asan_address_is_poisoned(void const volatile *addr);
 
 /// Checks if a region is poisoned.
 ///
@@ -95,14 +95,14 @@ int __sanitizer_cdecl __asan_address_is_poisoned(void const volatile *addr);
 /// \param beg Start of memory region.
 /// \param size Start of memory region.
 /// \returns Address of first poisoned byte.
-void *__sanitizer_cdecl __asan_region_is_poisoned(void *beg, size_t size);
+void *SANITIZER_CDECL __asan_region_is_poisoned(void *beg, size_t size);
 
 /// Describes an address (useful for calling from the debugger).
 ///
 /// Prints the description of <c><i>addr</i></c>.
 ///
 /// \param addr Address to describe.
-void __sanitizer_cdecl __asan_describe_address(void *addr);
+void SANITIZER_CDECL __asan_describe_address(void *addr);
 
 /// Checks if an error has been or is being reported (useful for calling from
 /// the debugger to get information about an ASan error).
@@ -111,7 +111,7 @@ void __sanitizer_cdecl __asan_describe_address(void *addr);
 ///
 /// \returns 1 if an error has been (or is being) reported. Otherwise returns
 /// 0.
-int __sanitizer_cdecl __asan_report_present(void);
+int SANITIZER_CDECL __asan_report_present(void);
 
 /// Gets the PC (program counter) register value of an ASan error (useful for
 /// calling from the debugger).
@@ -120,7 +120,7 @@ int __sanitizer_cdecl __asan_report_present(void);
 /// Otherwise returns 0.
 ///
 /// \returns PC value.
-void *__sanitizer_cdecl __asan_get_report_pc(void);
+void *SANITIZER_CDECL __asan_get_report_pc(void);
 
 /// Gets the BP (base pointer) register value of an ASan error (useful for
 /// calling from the debugger).
@@ -129,7 +129,7 @@ void *__sanitizer_cdecl __asan_get_report_pc(void);
 /// Otherwise returns 0.
 ///
 /// \returns BP value.
-void *__sanitizer_cdecl __asan_get_report_bp(void);
+void *SANITIZER_CDECL __asan_get_report_bp(void);
 
 /// Gets the SP (stack pointer) register value of an ASan error (useful for
 /// calling from the debugger).
@@ -138,7 +138,7 @@ void *__sanitizer_cdecl __asan_get_report_bp(void);
 /// Otherwise returns 0.
 ///
 /// \returns SP value.
-void *__sanitizer_cdecl __asan_get_report_sp(void);
+void *SANITIZER_CDECL __asan_get_report_sp(void);
 
 /// Gets the address of the report buffer of an ASan error (useful for calling
 /// from the debugger).
@@ -147,31 +147,31 @@ void *__sanitizer_cdecl __asan_get_report_sp(void);
 /// reported. Otherwise returns 0.
 ///
 /// \returns Address of report buffer.
-void *__sanitizer_cdecl __asan_get_report_address(void);
+void *SANITIZER_CDECL __asan_get_report_address(void);
 
 /// Gets access type of an ASan error (useful for calling from the debugger).
 ///
 /// Returns access type (read or write) if an error has been (or is being)
 /// reported. Otherwise returns 0.
 ///
 /// \returns Access type (0 = read, 1 = write).
-int __sanitizer_cdecl __asan_get_report_access_type(void);
+int SANITIZER_CDECL __asan_get_report_access_type(void);
 
 /// Gets access size of an ASan error (useful for calling from the debugger).
 ///
 /// Returns access size if an error has been (or is being) reported. Otherwise
 /// returns 0.
 ///
 /// \returns Access size in bytes.
-size_t __sanitizer_cdecl __asan_get_report_access_size(void);
+size_t SANITIZER_CDECL __asan_get_report_access_size(void);
 
 /// Gets the bug description of an ASan error (useful for calling from a
 /// debugger).
 ///
 /// \returns Returns a bug description if an error has been (or is being)
 /// reported - for example, "heap-use-after-free". Otherwise returns an empty
 /// string.
-const char *__sanitizer_cdecl __asan_get_report_description(void);
+const char *SANITIZER_CDECL __asan_get_report_description(void);
 
 /// Gets information about a pointer (useful for calling from the debugger).
 ///
@@ -192,7 +192,7 @@ const char *__sanitizer_cdecl __asan_get_report_description(void);
 /// \param[out] region_size Size of the region in bytes.
 ///
 /// \returns Returns the category of the given pointer as a constant string.
-const char *__sanitizer_cdecl __asan_locate_address(void *addr, char *name,
+const char *SANITIZER_CDECL __asan_locate_address(void *addr, char *name,
                                                     size_t name_size,
                                                     void **region_address,
                                                     size_t *region_size);
@@ -209,7 +209,7 @@ const char *__sanitizer_cdecl __asan_locate_address(void *addr, char *name,
 /// \param[out] thread_id The thread ID of the address.
 ///
 /// \returns Returns the number of stored frames or 0 on error.
-size_t __sanitizer_cdecl __asan_get_alloc_stack(void *addr, void **trace,
+size_t SANITIZER_CDECL __asan_get_alloc_stack(void *addr, void **trace,
                                                 size_t size, int *thread_id);
 
 /// Gets the free stack trace and thread ID for a heap address (useful for
@@ -224,15 +224,15 @@ size_t __sanitizer_cdecl __asan_get_alloc_stack(void *addr, void **trace,
 /// \param[out] thread_id The thread ID of the address.
 ///
 /// \returns Returns the number of stored frames or 0 on error.
-size_t __sanitizer_cdecl __asan_get_free_stack(void *addr, void **trace,
+size_t SANITIZER_CDECL __asan_get_free_stack(void *addr, void **trace,
                                                size_t size, int *thread_id);
 
 /// Gets the current shadow memory mapping (useful for calling from the
 /// debugger).
 ///
 /// \param[out] shadow_scale Shadow scale value.
 /// \param[out] shadow_offset Offset value.
-void __sanitizer_cdecl __asan_get_shadow_mapping(size_t *shadow_scale,
+void SANITIZER_CDECL __asan_get_shadow_mapping(size_t *shadow_scale,
                                                  size_t *shadow_offset);
 
 /// This is an internal function that is called to report an error. However,
@@ -245,31 +245,31 @@ void __sanitizer_cdecl __asan_get_shadow_mapping(size_t *shadow_scale,
 /// \param addr Address of the ASan error.
 /// \param is_write True if the error is a write error; false otherwise.
 /// \param access_size Size of the memory access of the ASan error.
-void __sanitizer_cdecl __asan_report_error(void *pc, void *bp, void *sp,
+void SANITIZER_CDECL __asan_report_error(void *pc, void *bp, void *sp,
                                            void *addr, int is_write,
                                            size_t access_size);
 
 // Deprecated. Call __sanitizer_set_death_callback instead.
-void __sanitizer_cdecl __asan_set_death_callback(void (*callback)(void));
+void SANITIZER_CDECL __asan_set_death_callback(void (*callback)(void));
 
 /// Sets the callback function to be called during ASan error reporting.
 ///
 /// The callback provides a string pointer to the report.
 ///
 /// \param callback User-provided function.
-void __sanitizer_cdecl
+void SANITIZER_CDECL
 __asan_set_error_report_callback(void (*callback)(const char *));
 
 /// User-provided callback on ASan errors.
 ///
 /// You can provide a function that would be called immediately when ASan
 /// detects an error. This is useful in cases when ASan detects an error but
 /// your program crashes before the ASan report is printed.
-void __sanitizer_cdecl __asan_on_error(void);
+void SANITIZER_CDECL __asan_on_error(void);
 
 /// Prints accumulated statistics to <c>stderr</c> (useful for calling from the
 /// debugger).
-void __sanitizer_cdecl __asan_print_accumulated_stats(void);
+void SANITIZER_CDECL __asan_print_accumulated_stats(void);
 
 /// User-provided default option settings.
 ///
@@ -278,7 +278,7 @@ void __sanitizer_cdecl __asan_print_accumulated_stats(void);
 /// <c>verbosity=1:halt_on_error=0</c>).
 ///
 /// \returns Default options string.
-const char *__sanitizer_cdecl __asan_default_options(void);
+const char *SANITIZER_CDECL __asan_default_options(void);
 
 // The following two functions facilitate garbage collection in presence of
 // ASan's fake stack.
@@ -290,7 +290,7 @@ const char *__sanitizer_cdecl __asan_default_options(void);
 /// does not have a fake stack.
 ///
 /// \returns An opaque handler to the fake stack or NULL.
-void *__sanitizer_cdecl __asan_get_current_fake_stack(void);
+void *SANITIZER_CDECL __asan_get_current_fake_stack(void);
 
 /// Checks if an address belongs to a given fake stack.
 ///
@@ -310,7 +310,7 @@ void *__sanitizer_cdecl __asan_get_current_fake_stack(void);
 /// \param[out] beg Beginning of fake frame.
 /// \param[out] end End of fake frame.
 /// \returns Stack address or NULL.
-void *__sanitizer_cdecl __asan_addr_is_in_fake_stack(void *fake_stack,
+void *SANITIZER_CDECL __asan_addr_is_in_fake_stack(void *fake_stack,
                                                      void *addr, void **beg,
                                                      void **end);
 
@@ -319,11 +319,11 @@ void *__sanitizer_cdecl __asan_addr_is_in_fake_stack(void *fake_stack,
 ///
 /// To avoid false positives on the stack, must be called before no-return
 /// functions like <c>_exit()</c> and <c>execl()</c>.
-void __sanitizer_cdecl __asan_handle_no_return(void);
+void SANITIZER_CDECL __asan_handle_no_return(void);
 
 /// Update allocation stack trace for the given allocation to the current stack
 /// trace. Returns 1 if successful, 0 if not.
-int __sanitizer_cdecl __asan_update_allocation_context(void *addr);
+int SANITIZER_CDECL __asan_update_allocation_context(void *addr);
 
 #ifdef __cplusplus
 } // extern "C"