std.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <derive-c/alloc/trait.h>
#include <derive-c/core/prelude.h>
#include <derive-c/core/debug/memory_tracker.h>

Go to the source code of this file.

Functions
	DC_ZERO_SIZED (stdalloc)
	An allocator for the standard allocator, which only has global state,.
	DC_TRAIT_REFERENCABLE_SINGLETON (stdalloc, stdalloc_instance)
static DC_PUBLIC void *	allocate_uninit (stdalloc_ref, size_t size)
static DC_PUBLIC void *	allocate_zeroed (stdalloc_ref, size_t size)
static DC_PUBLIC void *	reallocate (stdalloc_ref, void *ptr, size_t old_size, size_t new_size)
static DC_PUBLIC void	deallocate (stdalloc_ref, void *ptr, size_t size)
static DC_PUBLIC void	debug (stdalloc const *self, dc_debug_fmt fmt, FILE *stream)
static DC_PUBLIC void	delete (stdalloc *self)
	DC_TRAIT_ALLOC (stdalloc)

Variables
static stdalloc	stdalloc_instance = {}

Function Documentation

allocate_uninit()

DC_PUBLIC void * allocate_uninit ( stdalloc_ref , size_t size )

static

Definition at line 17 of file std.h.

                                                                                  {
    DC_ASSERT(size > 0, "Cannot allocate zero sized");
    void* alloc = malloc(size);
 
    // JUSTIFY: Setting memory capabilities
    //  - Flakiness observed for tests running under msan with uninstrumented glibc
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_WRITE, alloc, size);
    DC_ASSERT(alloc != NULL, "Standard allocator failed to malloc");
    return alloc;
}

allocate_zeroed()

DC_PUBLIC void * allocate_zeroed ( stdalloc_ref , size_t size )

static

Definition at line 28 of file std.h.

                                                                                  {
    DC_ASSERT(size > 0, "Cannot allocate zero sized");
    void* alloc = calloc(size, 1);
 
    // JUSTIFY: Setting memory capabilities
    //  - Flakiness observed for tests running under msan with uninstrumented glibc
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_READ_WRITE, alloc,
                          size);
 
    DC_ASSERT(alloc != NULL, "Standard allocator failed to calloc");
    return alloc;
}

DC_TRAIT_ALLOC()

DC_TRAIT_ALLOC

(

stdalloc

)

DC_TRAIT_REFERENCABLE_SINGLETON()

DC_TRAIT_REFERENCABLE_SINGLETON	(	stdalloc	,
		stdalloc_instance	)

DC_ZERO_SIZED()

DC_ZERO_SIZED

(

stdalloc

)

An allocator for the standard allocator, which only has global state,.

deallocate()

DC_PUBLIC void deallocate ( stdalloc_ref , void * ptr, size_t size )

static

Definition at line 68 of file std.h.

                                                                                       {
    DC_ASSUME(ptr);
 
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_WRITE, ptr, size);
 
    // JUSTIFY: Ignoring malloc clang static analyser warnings in this branch
    // To make this safe we need to prove:
    //  1. the ptr was allocated by self
    //
    // Allocators such as the hybridstatic allocator make it harder it harder
    //  - provenance: clang static analyser cannot prove a pointer's origin
    //  - can be shown by wrapping allocator's returns, but this adds substantial
    //    complexity, and makes the returned ptr-types less easy to use
    //  - can also use special headers on allocations, but this adds complexity
    // So we settle for ignoring here:
    //
    // GCC's -Wfree-nonheap-object can also trigger false positives with wrapper
    // allocators like hybridstatic that conditionally use heap vs stack storage.
    // The runtime check (contains_ptr) prevents actual issues, but GCC's
    // interprocedural analysis doesn't understand this.
 
    free(ptr);
}

debug()

DC_PUBLIC void debug ( stdalloc const * self, dc_debug_fmt fmt, FILE * stream )

static

Definition at line 92 of file std.h.

                                                                                                {
    DC_ASSUME(self);
    (void)fmt;
    fprintf(stream, "stdalloc@%p { }", (void*)self);
}

delete()

DC_PUBLIC void delete ( stdalloc * self )

static

Definition at line 98 of file std.h.

{ DC_ASSUME(self); }

reallocate()

DC_PUBLIC void * reallocate ( stdalloc_ref , void * ptr, size_t old_size, size_t new_size )

static

Definition at line 41 of file std.h.

                                                                 {
    DC_ASSERT(new_size > 0, "Cannot allocate zero sized");
    DC_ASSERT(ptr, "Cannot reallocate a null pointer");
    DC_ASSUME(old_size > 0, "Could never have allocated zero sized");
 
    if (new_size < old_size) {
        // JUSTIFY: We poison the memory we will no longer use.
        //  - When reallocating by reducing allocation size, msan does not automatically poison the
        //    bytes that are no longer part of the allocation
        //  - We need this in order to pass alloc fuzz tests: we want the strong property that
        //  deallocate memory is poisoned.
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_WRITE,
                              (char const*)ptr + new_size, old_size - new_size);
    }
 
    void* new_ptr = realloc(ptr, new_size);
    DC_ASSERT(new_ptr != NULL, "Standard allocator failed to realloc");
 
    if (new_size > old_size) {
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_ALLOC, DC_MEMORY_TRACKER_CAP_WRITE,
                              (char*)new_ptr + old_size, new_size - old_size);
    }
 
    return new_ptr;
}

Variable Documentation

stdalloc_instance

stdalloc stdalloc_instance = {}

static

Definition at line 14 of file std.h.

{};