// LAF Base Library

// Copyright (c) 2022-2024 Igara Studio S.A.

// Copyright (c) 2001-2016 David Capello

//

// This file is released under the terms of the MIT license.

// Read LICENSE.txt for more information.

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include "base/debug.h"

#include <cassert>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <mutex>

using namespace std;

#if !defined LAF_MEMLEAK // Without leak detection

void* base_malloc(size_t bytes)

{

return malloc(bytes);

}

void* base_malloc0(size_t bytes)

{

return calloc(1, bytes);

}

void* base_realloc(void* mem, size_t bytes)

{

return realloc(mem, bytes);

}

void base_free(void* mem)

{

assert(mem);

free(mem);

}

char* base_strdup(const char* string)

{

assert(string);

#ifdef _MSC_VER

return _strdup(string);

#else

return strdup(string);

#endif

}

#else // With leak detection

#define BACKTRACE_LEVELS 16

#ifdef _MSC_VER

#include <windows.h>

#include <dbghelp.h>

typedef USHORT(WINAPI* RtlCaptureStackBackTraceType)(ULONG, ULONG, PVOID*, PULONG);

static RtlCaptureStackBackTraceType pRtlCaptureStackBackTrace;

#endif

struct slot_t {

void* backtrace[BACKTRACE_LEVELS];

void* ptr;

size_t size;

struct slot_t* next;

};

static bool memleak_status = false;

static slot_t* headslot;

static std::mutex g_mutex;

void base_memleak_init()

{

#ifdef _MSC_VER

pRtlCaptureStackBackTrace = (RtlCaptureStackBackTraceType)(::GetProcAddress(

::LoadLibrary(L"kernel32.dll"),

"RtlCaptureStackBackTrace"));

#endif

assert(!memleak_status);

headslot = NULL;

memleak_status = true;

}

void base_memleak_exit()

{

assert(memleak_status);

memleak_status = false;

FILE* f = fopen("_ase_memlog.txt", "wt");

slot_t* it;

if (f != NULL) {

#ifdef _MSC_VER

struct SYMBOL_INFO_EX {

IMAGEHLP_SYMBOL64 header;

char filename[MAX_SYM_NAME];

} si;

si.header.SizeOfStruct = sizeof(SYMBOL_INFO_EX);

si.header.MaxNameLength = MAX_SYM_NAME;

IMAGEHLP_LINE64 line;

line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);

::SymSetOptions(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS);

HANDLE hproc = ::GetCurrentProcess();

if (!::SymInitialize(hproc, NULL, TRUE))

fprintf(f, "Error initializing SymInitialize()\nGetLastError = %d\n", ::GetLastError());

char filename[MAX_PATH];

::GetModuleFileNameA(NULL, filename, sizeof(filename) / sizeof(filename[0]));

::SymLoadModule64(hproc, NULL, filename, NULL, 0, 0);

#endif

// Memory leaks

for (it = headslot; it != NULL; it = it->next) {

fprintf(f, "\nLEAK address: %p, size: %lu\n", it->ptr, it->size);

for (int c = 0; c < BACKTRACE_LEVELS; ++c) {

#ifdef _MSC_VER

DWORD displacement;

if (::SymGetLineFromAddr64(hproc, (DWORD)it->backtrace[c], &displacement, &line)) {

si.header.Name[0] = 0;

::SymGetSymFromAddr64(hproc, (DWORD)it->backtrace[c], NULL, &si.header);

fprintf(f,

"%p : %s(%lu) [%s]\n",

it->backtrace[c],

line.FileName,

line.LineNumber,

si.header.Name);

}

else

#endif

fprintf(f, "%p\n", it->backtrace[c]);

}

}

fclose(f);

#ifdef _MSC_VER

::SymCleanup(hproc);

#endif

}

}

static void addslot(void* ptr, size_t size)

{

if (!memleak_status)

return;

slot_t* p = reinterpret_cast<slot_t*>(malloc(sizeof(slot_t)));

assert(ptr);

// __builtin_return_address is a GCC extension

#if defined(__GNUC__)

p->backtrace[0] = __builtin_return_address(4);

p->backtrace[1] = __builtin_return_address(3);

p->backtrace[2] = __builtin_return_address(2);

p->backtrace[3] = __builtin_return_address(1);

#elif defined(_MSC_VER)

{

for (int c = 0; c < BACKTRACE_LEVELS; ++c)

p->backtrace[c] = 0;

pRtlCaptureStackBackTrace(0, BACKTRACE_LEVELS, p->backtrace, NULL);

}

#else

#error Not supported

#endif

p->ptr = ptr;

p->size = size;

const std::lock_guard lock(g_mutex);

p->next = headslot;

headslot = p;

}

static void delslot(void* ptr)

{

if (!memleak_status)

return;

slot_t *it, *prev = NULL;

assert(ptr);

const std::lock_guard lock(g_mutex);

for (it = headslot; it != nullptr; prev = it, it = it->next) {

if (it->ptr == ptr) {

if (prev)

prev->next = it->next;

else

headslot = it->next;

free(it);

break;

}

}

}

void* base_malloc(size_t bytes)

{

void* mem = malloc(bytes);

if (mem) {

addslot(mem, bytes);

return mem;

}

else

return nullptr;

}

void* base_malloc0(size_t bytes)

{

void* mem = calloc(1, bytes);

if (mem) {

addslot(mem, bytes);

return mem;

}

else

return nullptr;

}

void* base_realloc(void* mem, size_t bytes)

{

void* newmem = realloc(mem, bytes);

if (newmem) {

if (mem)

delslot(mem);

addslot(newmem, bytes);

return newmem;

}

else

return nullptr;

}

void base_free(void* mem)

{

assert(mem);

if (mem) {

delslot(mem);

free(mem);

}

}

char* base_strdup(const char* string)

{

assert(string);

char* mem = strdup(string);

if (mem)

addslot(mem, strlen(mem) + 1);

return mem;

}

// C++ operators

void* operator new(std::size_t size)

{

void* ptr = base_malloc(size);

if (!ptr)

throw std::bad_alloc();

return ptr;

}

void* operator new[](std::size_t size)

{

void* ptr = base_malloc(size);

if (!ptr)

throw std::bad_alloc();

return ptr;

}

void operator delete(void* ptr) LAF_NOEXCEPT

{

if (!ptr)

return;

base_free(ptr);

}

void operator delete[](void* ptr) LAF_NOEXCEPT

{

if (!ptr)

return;

base_free(ptr);

}

#endif

void* base_aligned_alloc(std::size_t bytes, std::size_t alignment)

{

#if LAF_WINDOWS

return _aligned_malloc(bytes, alignment);

#else

ASSERT(alignment > 0);

std::size_t misaligned = (bytes % alignment);

if (misaligned > 0)

bytes += alignment - misaligned;

return aligned_alloc(alignment, bytes);

#endif

}

void base_aligned_free(void* mem)

{

#if LAF_WINDOWS

_aligned_free(mem);

#else

free(mem);

#endif

}