{

// race is OK here, as different threads found same functions

if (!origFuncSearched.load(std::memory_order_acquire)) {

orig_free = dlsym(RTLD_NEXT, "free");

orig_realloc = dlsym(RTLD_NEXT, "realloc");

orig_msize = dlsym(RTLD_NEXT, "malloc_usable_size");

orig_libc_free = dlsym(RTLD_NEXT, "__libc_free");

orig_libc_realloc = dlsym(RTLD_NEXT, "__libc_realloc");

origFuncSearched.store(true, std::memory_order_release);

}

#endif

{

InitOrigPointers();

return __TBB_malloc_safer_msize(const_cast<void*>(ptr), (size_t (*)(void*))orig_msize);

{

struct mallinfo m;

memset(&m, 0, sizeof(struct mallinfo));

return m;

{

InitOrigPointers();

__TBB_malloc_safer_free(ptr, (void (*)(void*))orig_libc_free);

//char *_module;

const char *_func;

FUNCPTR _fptr;

FRR_ON_ERROR _on_error;

{

const char *funcName[] = {"free", "_msize", "_aligned_free", "_aligned_msize", 0};

HMODULE module = GetModuleHandle(dllName);

if (!module)

return false;

for (int i=0; funcName[i]; i++)

if (! IsPrologueKnown(dllName, funcName[i], known_bytecodes, module)) {

fprintf(stderr, "TBBmalloc: skip allocation functions replacement in " WCHAR_SPEC

": unknown prologue for function " WCHAR_SPEC "\n", dllName, funcName[i]);

return false;

}

return true;

{

#ifndef UNICODE

const char *dllStr = dllName;

#else

const size_t sz = 128; // all DLL name must fit

char buffer[sz];

size_t real_sz;

char *dllStr = buffer;

errno_t ret = wcstombs_s(&real_sz, dllStr, sz, dllName, sz-1);

__TBB_ASSERT(!ret, "Dll name conversion failed");

#endif

for (size_t i=0; i<arrayLength(modules_to_replace); i++)

if (!strcmp(modules_to_replace[i].name, dllStr)) {

modules_to_replace[i].doFuncReplacement = false;

break;

}

{

FRR_TYPE res = ReplaceFunction( dllName, funcName, newFunc, opcodes, origFunc );

if (res == FRR_OK || res == FRR_NODLL || (res == FRR_NOFUNC && on_error == FRR_IGNORE))

return;

fprintf(stderr, "Failed to %s function %s in module %s\n",

res==FRR_NOFUNC? "find" : "replace", funcName, dllName);

// Unable to replace a required function

// Aborting because incomplete replacement of memory management functions

// may leave the program in an invalid state

abort();

{

// Replace functions and keep backup of original code (separate for each runtime)

#if __TBB_OVERLOAD_OLD_MSVCR

__TBB_ORIG_ALLOCATOR_REPLACEMENT_CALL(msvcr70)

__TBB_ORIG_ALLOCATOR_REPLACEMENT_CALL(msvcr71)

__TBB_ORIG_ALLOCATOR_REPLACEMENT_CALL(msvcr80)

__TBB_ORIG_ALLOCATOR_REPLACEMENT_CALL(msvcr90)

#endif

__TBB_ORIG_ALLOCATOR_REPLACEMENT_CALL(msvcr100)

__TBB_ORIG_ALLOCATOR_REPLACEMENT_CALL(msvcr110)

__TBB_ORIG_ALLOCATOR_REPLACEMENT_CALL(msvcr120)

__TBB_ORIG_ALLOCATOR_REPLACEMENT_CALL_RELEASE(ucrtbase)

// Replace functions without storing original code

for (size_t j = 0; j < arrayLength(modules_to_replace); j++) {

if (!modules_to_replace[j].doFuncReplacement)

continue;

for (size_t i = 0; i < arrayLength(c_routines_to_replace); i++)

{

ReplaceFunctionWithStore( modules_to_replace[j].name, c_routines_to_replace[i]._func, c_routines_to_replace[i]._fptr, nullptr, nullptr, c_routines_to_replace[i]._on_error );

}

if ( strcmp(modules_to_replace[j].name, "ucrtbase.dll") == 0 ) {

HMODULE ucrtbase_handle = GetModuleHandle("ucrtbase.dll");

if (!ucrtbase_handle)

continue;

// If _o_free function is present and patchable, redirect it to tbbmalloc as well

// This prevents issues with other _o_* functions which might allocate memory with malloc

if ( IsPrologueKnown("ucrtbase.dll", "_o_free", known_bytecodes, ucrtbase_handle)) {

ReplaceFunctionWithStore( "ucrtbase.dll", "_o_free", (FUNCPTR)__TBB_malloc__o_free, known_bytecodes, (FUNCPTR*)&orig__o_free, FRR_FAIL );

}

// Similarly for _free_base

if (IsPrologueKnown("ucrtbase.dll", "_free_base", known_bytecodes, ucrtbase_handle)) {

ReplaceFunctionWithStore("ucrtbase.dll", "_free_base", (FUNCPTR)__TBB_malloc__free_base, known_bytecodes, (FUNCPTR*)&orig__free_base, FRR_FAIL);

}

// ucrtbase.dll does not export operator new/delete, so skip the rest of the loop.

continue;

}

for (size_t i = 0; i < arrayLength(cxx_routines_to_replace); i++)

{

#if !_WIN64

// in Microsoft* Visual Studio* 2012 and 2013 32-bit operator delete consists of 2 bytes only: short jump to free(ptr);

// replacement should be skipped for this particular case.

if ( ((strcmp(modules_to_replace[j].name, "msvcr110.dll") == 0) || (strcmp(modules_to_replace[j].name, "msvcr120.dll") == 0)) && (strcmp(cxx_routines_to_replace[i]._func, "??3@YAXPAX@Z") == 0) ) continue;

// in Microsoft* Visual Studio* 2013 32-bit operator delete[] consists of 2 bytes only: short jump to free(ptr);

// replacement should be skipped for this particular case.

if ( (strcmp(modules_to_replace[j].name, "msvcr120.dll") == 0) && (strcmp(cxx_routines_to_replace[i]._func, "??_V@YAXPAX@Z") == 0) ) continue;

#endif

ReplaceFunctionWithStore( modules_to_replace[j].name, cxx_routines_to_replace[i]._func, cxx_routines_to_replace[i]._fptr, nullptr, nullptr, cxx_routines_to_replace[i]._on_error );

}

}

{

if ( callReason==DLL_PROCESS_ATTACH && reserved && hInst ) {

#if !__TBB_WIN8UI_SUPPORT

if (!tbb::detail::r1::GetBoolEnvironmentVariable("TBB_MALLOC_DISABLE_REPLACEMENT"))

{

doMallocReplacement();

}

#endif // !__TBB_WIN8UI_SUPPORT

}

return TRUE;