wrappers_c.inc | Explore in Territory

//===-- wrappers_c.inc ------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef SCUDO_PREFIX
#error "Define SCUDO_PREFIX prior to including this file!"
#endif

// malloc-type functions have to be aligned to std::max_align_t. This is
// distinct from (1U << SCUDO_MIN_ALIGNMENT_LOG), since C++ new-type functions
// do not have to abide by the same requirement.
#ifndef SCUDO_MALLOC_ALIGNMENT
#define SCUDO_MALLOC_ALIGNMENT …
#endif

static void reportAllocation(void *ptr, size_t size) { … }
static void reportDeallocation(void *ptr) { … }
static void reportReallocAllocation(void *old_ptr, void *new_ptr, size_t size) { … }
static void reportReallocDeallocation(void *old_ptr) { … }

extern "C" {

INTERFACE WEAK void *SCUDO_PREFIX(calloc)(size_t nmemb, size_t size) { … }

INTERFACE WEAK void SCUDO_PREFIX(free)(void *ptr) { … }

INTERFACE WEAK struct SCUDO_MALLINFO SCUDO_PREFIX(mallinfo)(void) { … }

// On Android, mallinfo2 is an alias of mallinfo, so don't define both.
#if !SCUDO_ANDROID
INTERFACE WEAK struct __scudo_mallinfo2 SCUDO_PREFIX(mallinfo2)(void) { … }
#endif

INTERFACE WEAK void *SCUDO_PREFIX(malloc)(size_t size) { … }

#if SCUDO_ANDROID
INTERFACE WEAK size_t SCUDO_PREFIX(malloc_usable_size)(const void *ptr) {
#else
INTERFACE WEAK size_t SCUDO_PREFIX(malloc_usable_size)(void *ptr) { … }

INTERFACE WEAK void *SCUDO_PREFIX(memalign)(size_t alignment, size_t size) { … }

INTERFACE WEAK int SCUDO_PREFIX(posix_memalign)(void **memptr, size_t alignment,
                                                size_t size) { … }

INTERFACE WEAK void *SCUDO_PREFIX(pvalloc)(size_t size) { … }

INTERFACE WEAK void *SCUDO_PREFIX(realloc)(void *ptr, size_t size) { … }

INTERFACE WEAK void *SCUDO_PREFIX(valloc)(size_t size) { … }

INTERFACE WEAK int SCUDO_PREFIX(malloc_iterate)(
    uintptr_t base, size_t size,
    void (*callback)(uintptr_t base, size_t size, void *arg), void *arg) { … }

INTERFACE WEAK void SCUDO_PREFIX(malloc_enable)() { … }

INTERFACE WEAK void SCUDO_PREFIX(malloc_disable)() { … }

void SCUDO_PREFIX(malloc_postinit)() { … }

INTERFACE WEAK int SCUDO_PREFIX(mallopt)(int param, int value) { … }

INTERFACE WEAK void *SCUDO_PREFIX(aligned_alloc)(size_t alignment,
                                                 size_t size) { … }

INTERFACE WEAK int SCUDO_PREFIX(malloc_info)(UNUSED int options, FILE *stream) { … }

// Disable memory tagging for the heap. The caller must disable memory tag
// checks globally (e.g. by clearing TCF0 on aarch64) before calling this
// function, and may not re-enable them after calling the function.
INTERFACE WEAK void SCUDO_PREFIX(malloc_disable_memory_tagging)() { … }

// Sets whether scudo records stack traces and other metadata for allocations
// and deallocations. This function only has an effect if the allocator and
// hardware support memory tagging.
INTERFACE WEAK void
SCUDO_PREFIX(malloc_set_track_allocation_stacks)(int track) { … }

// Sets whether scudo zero-initializes all allocated memory.
INTERFACE WEAK void SCUDO_PREFIX(malloc_set_zero_contents)(int zero_contents) { … }

// Sets whether scudo pattern-initializes all allocated memory.
INTERFACE WEAK void
SCUDO_PREFIX(malloc_set_pattern_fill_contents)(int pattern_fill_contents) { … }

// Sets whether scudo adds a small amount of slack at the end of large
// allocations, before the guard page. This can be enabled to work around buggy
// applications that read a few bytes past the end of their allocation.
INTERFACE WEAK void
SCUDO_PREFIX(malloc_set_add_large_allocation_slack)(int add_slack) { … }

} // extern "C"
llvm/compiler-rt/lib/scudo/standalone/wrappers_c.inc
