FEX-Emu--FEX/ThunkLibs/libfex_malloc/Host.cpp

/*
$info$
tags: thunklibs|fex_malloc
desc: Handles allocations between guest and host thunks
$end_info$
*/

#include <cstring>
#include <cstdlib>
#include <stdio.h>
#include <memory.h>

#include "common/Host.h"
#include <dlfcn.h>

#include "Types.h"

#include "thunkgen_host_libfex_malloc.inl"

void fexfn_impl_libfex_malloc_fex_get_allocation_ptrs(AllocationPtrs *Ptrs);

extern "C" {
  // FEX allocation routines
  extern MallocPtr FEX_Malloc_Ptr;
  extern FreePtr FEX_Free_Ptr;
  extern CallocPtr FEX_Calloc_Ptr;
  extern MemalignPtr FEX_Memalign_Ptr;
  extern ReallocPtr FEX_Realloc_Ptr;
  extern VallocPtr FEX_Valloc_Ptr;
  extern PosixMemalignPtr FEX_PosixMemalign_Ptr;
  extern AlignedAllocPtr FEX_AlignedAlloc_Ptr;
  extern MallocUsablePtr FEX_MallocUsable_Ptr;
}

extern "C" {
  AllocationPtrs AllocationPointers {
    .Malloc = FEX_Malloc_Ptr,
    .Free = FEX_Free_Ptr,
    .Calloc = FEX_Calloc_Ptr,
    .Memalign = FEX_Memalign_Ptr,
    .Realloc = FEX_Realloc_Ptr,
    .Valloc = FEX_Valloc_Ptr,
    .PosixMemalign = FEX_PosixMemalign_Ptr,
    .AlignedAlloc = FEX_AlignedAlloc_Ptr,
    .MallocUsable = FEX_MallocUsable_Ptr,
  };

  // Our allocators
#    define ALIAS(fn)	__attribute__((alias (#fn), used))
#    define PREALIAS(fn)	ALIAS(fn)

  void *fex_malloc(size_t Size) {
    return AllocationPointers.Malloc(Size);
  }
  void *__libc_malloc (size_t Size) __attribute__((alias ("fex_malloc"), used));
  void *malloc (size_t Size) __attribute__((alias ("fex_malloc"), used));

  void fex_free(void *p) {
    AllocationPointers.Free(p);
  }
  void __libc_free(void* ptr) PREALIAS(fex_free);
  void __GI___libc_free(void* ptr) PREALIAS(fex_free);
  void free(void* ptr) PREALIAS(fex_free);

  void *fex_calloc(size_t n, size_t size) {
    return AllocationPointers.Calloc(n, size);
  }
  void *__libc_calloc(size_t n, size_t size) PREALIAS(fex_calloc);
  void *calloc(size_t n, size_t size) PREALIAS(fex_calloc);

  void *fex_memalign(size_t align, size_t s) {
    return AllocationPointers.Memalign(align, s);
  }
  void *__libc_memalign(size_t align, size_t s) PREALIAS(fex_memalign);
  void *memalign(size_t align, size_t s) PREALIAS(fex_memalign);

  void *fex_realloc(void* ptr, size_t size) {
    return AllocationPointers.Realloc(ptr, size);
  }
  void *__libc_realloc(void* ptr, size_t size) PREALIAS(fex_realloc);
  void *realloc(void* ptr, size_t size) PREALIAS(fex_realloc);

  void *fex_valloc(size_t size) {
    return AllocationPointers.Valloc(size);
  }
  void *__libc_valloc(size_t size) PREALIAS(fex_valloc);
  void *valloc(size_t size) PREALIAS(fex_valloc);

  int fex_posix_memalign(void** r, size_t a, size_t s) {
    return AllocationPointers.PosixMemalign(r, a, s);
  }
  int __posix_memalign(void** r, size_t a, size_t s) PREALIAS(fex_posix_memalign);
  int posix_memalign(void** r, size_t a, size_t s) PREALIAS(fex_posix_memalign);

  void *fex_aligned_alloc(size_t a, size_t s) {
    return AllocationPointers.AlignedAlloc(a, s);
  }
  void *aligned_alloc(size_t a, size_t s) PREALIAS(fex_aligned_alloc);

  size_t fex_malloc_usable_size(void *ptr) {
    return AllocationPointers.MallocUsable(ptr);
  }

  size_t __malloc_usable_size(void *ptr) {
    return fex_malloc_usable_size(ptr);
  }
  size_t malloc_usable_size(void *ptr) {
    return fex_malloc_usable_size(ptr);
  }

  static void fexfn_unpack_libfex_malloc_malloc(void *argsv) {
    struct arg_t {size_t a_0;void * rv;};
    auto args = (arg_t*)argsv;
    args->rv = AllocationPointers.Malloc(args->a_0);
  }

  static void fexfn_unpack_libfex_malloc_free(void *argsv){
    struct arg_t {void* a_0;};
    auto args = (arg_t*)argsv;
    AllocationPointers.Free(args->a_0);
  }

  static void fexfn_unpack_libfex_malloc_calloc(void *argsv){
    struct arg_t {size_t a_0;size_t a_1;void * rv;};
    auto args = (arg_t*)argsv;
    args->rv =
      AllocationPointers.Calloc
      (args->a_0,args->a_1);
  }
  static void fexfn_unpack_libfex_malloc_memalign(void *argsv){
    struct arg_t {size_t a_0;size_t a_1;void * rv;};
    auto args = (arg_t*)argsv;
    args->rv =
      AllocationPointers.Memalign
      (args->a_0,args->a_1);
  }
  static void fexfn_unpack_libfex_malloc_realloc(void *argsv){
    struct arg_t {void* a_0;size_t a_1;void * rv;};
    auto args = (arg_t*)argsv;
    args->rv =
      AllocationPointers.Realloc
      (args->a_0,args->a_1);
  }
  static void fexfn_unpack_libfex_malloc_valloc(void *argsv){
    struct arg_t {size_t a_0;void * rv;};
    auto args = (arg_t*)argsv;

    args->rv =
      AllocationPointers.Valloc
      (args->a_0);
  }
  static void fexfn_unpack_libfex_malloc_posix_memalign(void *argsv){
    struct arg_t {void** a_0;size_t a_1;size_t a_2;int rv;};
    auto args = (arg_t*)argsv;

    args->rv =
      AllocationPointers.PosixMemalign
      (args->a_0,args->a_1,args->a_2);
  }
  static void fexfn_unpack_libfex_malloc_aligned_alloc(void *argsv){
    struct arg_t {size_t a_0;size_t a_1;void * rv;};
    auto args = (arg_t*)argsv;

    args->rv =
      AllocationPointers.AlignedAlloc
      (args->a_0,args->a_1);
  }
  static void fexfn_unpack_libfex_malloc_malloc_usable_size(void *argsv){
    struct arg_t {void * a_0;size_t rv;};
    auto args = (arg_t*)argsv;

    args->rv =
      AllocationPointers.MallocUsable
      (args->a_0);
  }

void (*__free_hook)(void *ptr) = fex_free;
void *(*__malloc_hook)(size_t size) = fex_malloc;
void *(*__realloc_hook)(void *ptr, size_t size) = fex_realloc;
void *(*__memalign_hook)(size_t alignment, size_t size) =
    fex_memalign;
}

void fexfn_impl_libfex_malloc_fex_get_allocation_ptrs(AllocationPtrs *Ptrs) {
  *Ptrs = AllocationPointers;
}

static void init_lib() {
  // Set pointers
  AllocationPointers.Malloc = FEX_Malloc_Ptr;
  AllocationPointers.Free = FEX_Free_Ptr;
  AllocationPointers.Calloc = FEX_Calloc_Ptr;
  AllocationPointers.Memalign = FEX_Memalign_Ptr;
  AllocationPointers.Realloc = FEX_Realloc_Ptr;
  AllocationPointers.Valloc = FEX_Valloc_Ptr;
  AllocationPointers.PosixMemalign = FEX_PosixMemalign_Ptr;
  AllocationPointers.AlignedAlloc = FEX_AlignedAlloc_Ptr;
  AllocationPointers.MallocUsable = FEX_MallocUsable_Ptr;
}

EXPORTS(libfex_malloc)
LOAD_LIB_INIT(init_lib)