More work on malloc override and tbbmalloc wrapping

12 files changed, 345 insertions, 61 deletions

diff --git a/src/library_list.h b/src/library_list.h
index 8fdcab7a..d830bc6b 100755
--- a/src/library_list.h
+++ b/src/library_list.h
@@ -160,6 +160,7 @@ GO("libtinfo.so.5", libtinfo)
 GO("libpanel.so.5", libpanel)
 GO("libncurses.so.6", libncurses6)
 GO("libtinfo.so.6", libtinfo6)
+GO("libtbbmalloc.so.2", tbbmalloc)
 GO("libtbbmalloc_proxy.so.2", tbbmallocproxy)
 GO("libtcmalloc_minimal.so.0", tcmallocminimal)
 GO("libtcmalloc_minimal.so.4", tcmallocminimal)
diff --git a/src/mallochook.c b/src/mallochook.c
index ac9d229f..7f4c3b01 100644
--- a/src/mallochook.c
+++ b/src/mallochook.c
@@ -44,63 +44,71 @@
 #include "wrapper.h"
 
 #define SUPER()                 \
-GO(malloc, pFL);                \
-GO(free, vFp);                  \
-GO(calloc, pFLL);               \
-GO(realloc, pFpL);              \
-GO(aligned_alloc, pFLL);        \
-GO(memalign, pFLL);             \
-GO(posix_memalign, iFpLL);      \
-GO(pvalloc, pFL);               \
-GO(valloc, pFL);                \
-GO(cfree, vFp);                 \
-GO(malloc_usable_size, LFp) ;   \
-GO2(_Znwm, pFL);                \
-GO2(_ZnwmRKSt9nothrow_t, pFLp); \
-GO2(_Znam, pFL);                \
-GO2(_ZnamRKSt9nothrow_t, pFLp); \
-GO2(_ZdaPv, vFp);               \
-GO2(_ZdaPvm, vFpL);             \
-GO2(_ZdaPvmSt11align_val_t, vFpLL);             \
-GO2(_ZdlPv, vFp);                               \
-GO2(_ZdlPvm, vFpL);                             \
-GO2(_ZnwmSt11align_val_t, pFLL);                \
-GO2(_ZnwmSt11align_val_tRKSt9nothrow_t, pFLLp); \
-GO2(_ZnamSt11align_val_t, pFLL);                \
-GO2(_ZnamSt11align_val_tRKSt9nothrow_t, pFLLp); \
-GO2(_ZdlPvRKSt9nothrow_t, vFpp);                \
-GO2(_ZdaPvSt11align_val_tRKSt9nothrow_t, vFpLp);\
-GO2(_ZdlPvmSt11align_val_t, vFpLL);             \
-GO2(_ZdaPvRKSt9nothrow_t, vFpp);                \
-GO2(_ZdaPvSt11align_val_t, vFpL);               \
-GO2(_ZdlPvSt11align_val_t, vFpL);               \
-GO2(_ZdlPvSt11align_val_tRKSt9nothrow_t, vFpLp);\
-GO2(tc_calloc, pFLL);           \
-GO2(tc_cfree, vFp);             \
-GO2(tc_delete, vFp);            \
-GO2(tc_deletearray, vFp);       \
-GO2(tc_deletearray_nothrow, vFpp);              \
-GO2(tc_delete_nothrow, vFpp);   \
-GO2(tc_free, vFp);              \
-GO2(tc_malloc, pFL);            \
-GO2(tc_malloc_size, LFp);       \
-GO2(tc_new, pFL);               \
-GO2(tc_new_nothrow, pFLp);      \
-GO2(tc_newarray, pFL);          \
-GO2(tc_newarray_nothrow, pFLp); \
-GO2(tc_pvalloc, pFL);           \
-GO2(tc_valloc, pFL);            \
-GO2(tc_memalign, pFLL);         \
-GO2(tc_malloc_skip_new_handler_weak, pFL);      \
-GO2(tc_mallocopt, iFii);        \
-GO2(tc_malloc_stats, vFv);      \
-GO2(tc_malloc_skip_new_handler, pFL);           \
-GO2(tc_mallinfo, pFp);          \
-GO2(tc_posix_memalign, iFpLL);  \
-GO2(tc_realloc, pFpL);          \
-
-//GO2(tc_set_new_mode, iFi);
-//GO2(tc_version, iFi);
+GO(malloc, pFL)                 \
+GO(free, vFp)                   \
+GO(calloc, pFLL)                \
+GO(realloc, pFpL)               \
+GO(aligned_alloc, pFLL)         \
+GO(memalign, pFLL)              \
+GO(posix_memalign, iFpLL)       \
+GO(pvalloc, pFL)                \
+GO(valloc, pFL)                 \
+GO(cfree, vFp)                  \
+GO(malloc_usable_size, LFp)     \
+GO2(_Znwm, pFL)                 \
+GO2(_ZnwmRKSt9nothrow_t, pFLp)  \
+GO2(_Znam, pFL)                 \
+GO2(_ZnamRKSt9nothrow_t, pFLp)  \
+GO2(_ZdaPv, vFp)                \
+GO2(_ZdaPvm, vFpL)              \
+GO2(_ZdaPvmSt11align_val_t, vFpLL)              \
+GO2(_ZdlPv, vFp)                                \
+GO2(_ZdlPvm, vFpL)                              \
+GO2(_ZnwmSt11align_val_t, pFLL)                 \
+GO2(_ZnwmSt11align_val_tRKSt9nothrow_t, pFLLp)  \
+GO2(_ZnamSt11align_val_t, pFLL)                 \
+GO2(_ZnamSt11align_val_tRKSt9nothrow_t, pFLLp)  \
+GO2(_ZdlPvRKSt9nothrow_t, vFpp)                 \
+GO2(_ZdaPvSt11align_val_tRKSt9nothrow_t, vFpLp) \
+GO2(_ZdlPvmSt11align_val_t, vFpLL)              \
+GO2(_ZdaPvRKSt9nothrow_t, vFpp)                 \
+GO2(_ZdaPvSt11align_val_t, vFpL)                \
+GO2(_ZdlPvSt11align_val_t, vFpL)                \
+GO2(_ZdlPvSt11align_val_tRKSt9nothrow_t, vFpLp) \
+GO2(tc_calloc, pFLL)            \
+GO2(tc_cfree, vFp)              \
+GO2(tc_delete, vFp)             \
+GO2(tc_deletearray, vFp)        \
+GO2(tc_deletearray_nothrow, vFpp)               \
+GO2(tc_delete_nothrow, vFpp)    \
+GO2(tc_free, vFp)               \
+GO2(tc_malloc, pFL)             \
+GO2(tc_malloc_size, LFp)        \
+GO2(tc_new, pFL)                \
+GO2(tc_new_nothrow, pFLp)       \
+GO2(tc_newarray, pFL)           \
+GO2(tc_newarray_nothrow, pFLp)  \
+GO2(tc_pvalloc, pFL)            \
+GO2(tc_valloc, pFL)             \
+GO2(tc_memalign, pFLL)          \
+GO2(tc_malloc_skip_new_handler_weak, pFL)       \
+GO2(tc_mallocopt, iFii)         \
+GO2(tc_malloc_stats, vFv)       \
+GO2(tc_malloc_skip_new_handler, pFL)            \
+GO2(tc_mallinfo, pFp)           \
+GO2(tc_posix_memalign, iFpLL)   \
+GO2(tc_realloc, pFpL)           \
+GO2(safer_scalable_aligned_realloc, pFpLLp)     \
+GO2(safer_scalable_free, vFpp)  \
+GO2(safer_scalable_msize, LFpp) \
+GO2(safer_scalable_realloc, pFpLp)              \
+GO2(scalable_aligned_free, vFp)                 \
+GO2(scalable_aligned_malloc, pFLL)              \
+GO2(scalable_msize, LFp)        \
+
+
+//GO2(tc_set_new_mode, iFi) 
+//GO2(tc_version, iFi) 
 
 typedef void  (vFv_t)   (void);
 typedef int   (iFv_t)   (void);
@@ -112,11 +120,14 @@ typedef void* (*pFp_t)  (void*);
 typedef size_t(*LFp_t)  (void*);
 typedef int   (*iFii_t) (int, int);
 typedef void  (*vFpp_t) (void*, void*);
+typedef size_t(*LFpp_t) (void*, void*);
 typedef void  (*vFpL_t) (void*, size_t);
 typedef void* (*pFLL_t) (size_t, size_t);
 typedef void* (*pFLLp_t)(size_t, size_t, void* p);
 typedef void  (*vFpLp_t)(void*, size_t, void*);
+typedef void* (*pFpLp_t)(void*, size_t, void*);
 typedef void  (*vFpLL_t)(void*, size_t, size_t);
+typedef void* (*pFpLLp_t)(void*, size_t, size_t, void*);
 
 #ifdef ANDROID
 void*(*__libc_malloc)(size_t) = NULL;
@@ -159,6 +170,10 @@ static size_t pot(size_t l) {
     return 1<<ret;
 }
 
+static int ispot(size_t l) {
+    return pot(l)==l;
+}
+
 // redefining all libc memory allocation routines
 EXPORT void* malloc(size_t l)
 {
@@ -461,7 +476,75 @@ EXPORT int my_tc_version(int i)
 }
 */
 
+EXPORT void* my_safer_scalable_aligned_realloc(void* p, size_t size, size_t align, void *old)
+{
+    if(!ispot(align)) {
+        errno = EINVAL;
+        return NULL;
+    }
+    if(align <= 8)
+        return box_realloc(p, size);
+    size_t old_size = box_malloc_usable_size(p);
+    if(old_size>=size)
+        return p;
+    void* new_p = box_memalign(align, size);
+    memcpy(new_p, p, (old_size<size)?old_size:size);
+    box_free(p);
+    return p;
+}
+
+EXPORT void my_safer_scalable_free(void*p , void* old)
+{
+    box_free(p);
+}
+
+EXPORT size_t my_safer_scalable_msize(void* p, void* old)
+{
+    return box_malloc_usable_size(p);
+}
+
+EXPORT void* my_safer_scalable_realloc(void* p, size_t size, void* old)
+{
+    return box_realloc(p, size);
+}
 
+EXPORT void my_scalable_aligned_free(void* p)
+{
+    box_free(p);
+}
+
+EXPORT void* my_scalable_aligned_malloc(size_t size, size_t align)
+{
+    if(!ispot(align)) {
+        errno = EINVAL;
+        return NULL;
+    }
+    if(align <= 8)
+        return box_malloc(size);
+    return box_memalign(align, size);
+}
+
+EXPORT void* my_scalable_aligned_realloc(void* p, size_t size, size_t align)
+{
+    if(!ispot(align)) {
+        errno = EINVAL;
+        return NULL;
+    }
+    if(align <= 8)
+        return box_realloc(p, size);
+    size_t old_size = box_malloc_usable_size(p);
+    if(old_size>=size)
+        return p;
+    void* new_p = box_memalign(align, size);
+    memcpy(new_p, p, (old_size<size)?old_size:size);
+    box_free(p);
+    return p;
+}
+
+EXPORT size_t my_scalable_msize(void* p)
+{
+    return box_malloc_usable_size(p);
+}
 
 
 #pragma pack(push, 1)
@@ -517,7 +600,7 @@ void checkHookedSymbols(lib_t *maplib, elfheader_t* h)
             uintptr_t offs = h->DynSym[i].st_value + h->delta;
             size_t sz = h->DynSym[i].st_size;
             if(bind!=STB_LOCAL && bind!=STB_WEAK && sz>=sizeof(reloc_jmp_t)) {
-                #define GO(A, B) if(!strcmp(symname, #A)) ++hooked;
+                #define GO(A, B) if(!strcmp(symname, #A)) ++hooked; if(!strcmp(symname, "scalable_" #A)) ++hooked; if(!strcmp(symname, "__TBB_internal_" #A)) ++hooked;
                 #define GO2(A, B)
                 SUPER()
                 #undef GO
@@ -543,6 +626,16 @@ void checkHookedSymbols(lib_t *maplib, elfheader_t* h)
                 SUPER()
                 #undef GO
                 #undef GO2
+                #define GO(A, B) if(!strcmp(symname, "scalable_" #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, #A);}
+                #define GO2(A, B)
+                SUPER()
+                #undef GO
+                #undef GO2
+                #define GO(A, B) if(!strcmp(symname, "__TBB_internal_" #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, #A);}
+                #define GO2(A, B)
+                SUPER()
+                #undef GO
+                #undef GO2
                 #define GO(A, B) if(!strcmp(symname, #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, A, 0, #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, #A);}
                 #define GO2(A, B) if(!strcmp(symname, #A)) {uintptr_t alt = AddCheckBridge(my_context->system, B, my_##A, 0, #A); printf_log(LOG_DEBUG, "Redirecting %s function from %p (%s)\n", symname, (void*)offs, ElfName(h)); addRelocJmp((void*)offs, (void*)alt, sz, #A);}
                 SUPER()
@@ -553,6 +646,42 @@ void checkHookedSymbols(lib_t *maplib, elfheader_t* h)
     }
 }
 
+EXPORT int my___TBB_internal_find_original_malloc(int n, char* names[], void* ptr[])
+{
+    int ret = 1;
+    #define GO(A, B) else if(!strcmp(names[i], #A)) {ptr[i] = A;}
+    #define GO2(A, B) 
+    for (int i=0; i<n; ++i)
+        if (0) {}
+        SUPER()
+        else ret = 0;
+    return ret;
+    #undef GO
+    #undef GO2
+}
+
+EXPORT void my___TBB_call_with_my_server_info(void* cb, void* server)
+{
+    // nothing
+}
+
+EXPORT int my___TBB_make_rml_server(void* factory, void* server, void* client)
+{
+    // nothing
+    return 0;
+}
+
+EXPORT void my___RML_close_factory(void* server)
+{
+    // nothing
+}
+
+EXPORT int my___RML_open_factory(void* factory, void* server_version, int client_version)
+{
+    // nothing
+    return 0;
+}
+
 void init_malloc_hook() {
 #ifdef ANDROID
     __libc_malloc = dlsym(RTLD_NEXT, "malloc");
diff --git a/src/wrapped/generated/functions_list.txt b/src/wrapped/generated/functions_list.txt
index 2ac6a602..5be9252d 100644
--- a/src/wrapped/generated/functions_list.txt
+++ b/src/wrapped/generated/functions_list.txt
@@ -972,6 +972,7 @@
 #() pFplpl
 #() pFplpp
 #() pFpLip
+#() pFpLLp
 #() pFpLpL
 #() pFppii
 #() pFppiu
@@ -2654,6 +2655,7 @@ wrappedgnutls:
   - gnutls_global_set_log_function
 - vFpp:
   - gnutls_transport_set_pull_function
+  - gnutls_transport_set_pull_timeout_function
   - gnutls_transport_set_push_function
 wrappedgobject2:
 - pFp:
@@ -4063,19 +4065,45 @@ wrappedsmpeg2:
   - SMPEG_new_rwops
 wrappedsoftokn3:
 wrappedssl3:
+wrappedtbbmalloc:
+- vFp:
+  - scalable_aligned_free
+- LFp:
+  - scalable_msize
+- LFpp:
+  - safer_scalable_msize
+- pFLL:
+  - scalable_aligned_malloc
+  - scalable_calloc
+- pFpp:
+  - safer_scalable_free
+- pFpLL:
+  - scalable_aligned_realloc
+- pFpLp:
+  - safer_scalable_realloc
+- pFpLLp:
+  - safer_scalable_aligned_realloc
 wrappedtbbmallocproxy:
 - vFp:
   - _ZdaPv
   - _ZdlPv
+  - __RML_close_factory
 - pFL:
   - _Znam
   - _Znwm
 - vFpp:
   - _ZdaPvRKSt9nothrow_t
   - _ZdlPvRKSt9nothrow_t
+  - __TBB_call_with_my_server_info
 - pFLp:
   - _ZnamRKSt9nothrow_t
   - _ZnwmRKSt9nothrow_t
+- iFipp:
+  - __TBB_internal_find_original_malloc
+- iFppi:
+  - __RML_open_factory
+- iFppp:
+  - __TBB_make_rml_server
 wrappedtcmallocminimal:
 - pFp:
   - mallinfo
diff --git a/src/wrapped/generated/wrappedtbbmallocdefs.h b/src/wrapped/generated/wrappedtbbmallocdefs.h
new file mode 100644
index 00000000..e7022f6b
--- /dev/null
+++ b/src/wrapped/generated/wrappedtbbmallocdefs.h
@@ -0,0 +1,8 @@
+/*******************************************************************
+ * File automatically generated by rebuild_wrappers.py (v2.1.0.16) *
+ *******************************************************************/
+#ifndef __wrappedtbbmallocDEFS_H_
+#define __wrappedtbbmallocDEFS_H_
+
+
+#endif // __wrappedtbbmallocDEFS_H_
diff --git a/src/wrapped/generated/wrappedtbbmallocproxytypes.h b/src/wrapped/generated/wrappedtbbmallocproxytypes.h
index 41d5a922..1cab4bdc 100644
--- a/src/wrapped/generated/wrappedtbbmallocproxytypes.h
+++ b/src/wrapped/generated/wrappedtbbmallocproxytypes.h
@@ -15,15 +15,23 @@ typedef void (*vFp_t)(void*);
 typedef void* (*pFL_t)(uintptr_t);
 typedef void (*vFpp_t)(void*, void*);
 typedef void* (*pFLp_t)(uintptr_t, void*);
+typedef int64_t (*iFipp_t)(int64_t, void*, void*);
+typedef int64_t (*iFppi_t)(void*, void*, int64_t);
+typedef int64_t (*iFppp_t)(void*, void*, void*);
 
 #define SUPER() ADDED_FUNCTIONS() \
 	GO(_ZdaPv, vFp_t) \
 	GO(_ZdlPv, vFp_t) \
+	GO(__RML_close_factory, vFp_t) \
 	GO(_Znam, pFL_t) \
 	GO(_Znwm, pFL_t) \
 	GO(_ZdaPvRKSt9nothrow_t, vFpp_t) \
 	GO(_ZdlPvRKSt9nothrow_t, vFpp_t) \
+	GO(__TBB_call_with_my_server_info, vFpp_t) \
 	GO(_ZnamRKSt9nothrow_t, pFLp_t) \
-	GO(_ZnwmRKSt9nothrow_t, pFLp_t)
+	GO(_ZnwmRKSt9nothrow_t, pFLp_t) \
+	GO(__TBB_internal_find_original_malloc, iFipp_t) \
+	GO(__RML_open_factory, iFppi_t) \
+	GO(__TBB_make_rml_server, iFppp_t)
 
 #endif // __wrappedtbbmallocproxyTYPES_H_
diff --git a/src/wrapped/generated/wrappedtbbmalloctypes.h b/src/wrapped/generated/wrappedtbbmalloctypes.h
new file mode 100644
index 00000000..7ceb729a
--- /dev/null
+++ b/src/wrapped/generated/wrappedtbbmalloctypes.h
@@ -0,0 +1,34 @@
+/*******************************************************************
+ * File automatically generated by rebuild_wrappers.py (v2.1.0.16) *
+ *******************************************************************/
+#ifndef __wrappedtbbmallocTYPES_H_
+#define __wrappedtbbmallocTYPES_H_
+
+#ifndef LIBNAME
+#error You should only #include this file inside a wrapped*.c file
+#endif
+#ifndef ADDED_FUNCTIONS
+#define ADDED_FUNCTIONS() 
+#endif
+
+typedef void (*vFp_t)(void*);
+typedef uintptr_t (*LFp_t)(void*);
+typedef uintptr_t (*LFpp_t)(void*, void*);
+typedef void* (*pFLL_t)(uintptr_t, uintptr_t);
+typedef void* (*pFpp_t)(void*, void*);
+typedef void* (*pFpLL_t)(void*, uintptr_t, uintptr_t);
+typedef void* (*pFpLp_t)(void*, uintptr_t, void*);
+typedef void* (*pFpLLp_t)(void*, uintptr_t, uintptr_t, void*);
+
+#define SUPER() ADDED_FUNCTIONS() \
+	GO(scalable_aligned_free, vFp_t) \
+	GO(scalable_msize, LFp_t) \
+	GO(safer_scalable_msize, LFpp_t) \
+	GO(scalable_aligned_malloc, pFLL_t) \
+	GO(scalable_calloc, pFLL_t) \
+	GO(safer_scalable_free, pFpp_t) \
+	GO(scalable_aligned_realloc, pFpLL_t) \
+	GO(safer_scalable_realloc, pFpLp_t) \
+	GO(safer_scalable_aligned_realloc, pFpLLp_t)
+
+#endif // __wrappedtbbmallocTYPES_H_
diff --git a/src/wrapped/generated/wrappedtbbmallocundefs.h b/src/wrapped/generated/wrappedtbbmallocundefs.h
new file mode 100644
index 00000000..6edc1b18
--- /dev/null
+++ b/src/wrapped/generated/wrappedtbbmallocundefs.h
@@ -0,0 +1,8 @@
+/*******************************************************************
+ * File automatically generated by rebuild_wrappers.py (v2.1.0.16) *
+ *******************************************************************/
+#ifndef __wrappedtbbmallocUNDEFS_H_
+#define __wrappedtbbmallocUNDEFS_H_
+
+
+#endif // __wrappedtbbmallocUNDEFS_H_
diff --git a/src/wrapped/generated/wrapper.c b/src/wrapped/generated/wrapper.c
index 23d4f8a0..89e285b8 100644
--- a/src/wrapped/generated/wrapper.c
+++ b/src/wrapped/generated/wrapper.c
@@ -1006,6 +1006,7 @@ typedef void* (*pFpdIU_t)(void*, double, int64_t, uint64_t);
 typedef void* (*pFplpl_t)(void*, intptr_t, void*, intptr_t);
 typedef void* (*pFplpp_t)(void*, intptr_t, void*, void*);
 typedef void* (*pFpLip_t)(void*, uintptr_t, int64_t, void*);
+typedef void* (*pFpLLp_t)(void*, uintptr_t, uintptr_t, void*);
 typedef void* (*pFpLpL_t)(void*, uintptr_t, void*, uintptr_t);
 typedef void* (*pFppii_t)(void*, void*, int64_t, int64_t);
 typedef void* (*pFppiu_t)(void*, void*, int64_t, uint64_t);
@@ -3270,6 +3271,7 @@ void pFpdIU(x64emu_t *emu, uintptr_t fcn) { pFpdIU_t fn = (pFpdIU_t)fcn; R_RAX=(
 void pFplpl(x64emu_t *emu, uintptr_t fcn) { pFplpl_t fn = (pFplpl_t)fcn; R_RAX=(uintptr_t)fn((void*)R_RDI, (intptr_t)R_RSI, (void*)R_RDX, (intptr_t)R_RCX); }
 void pFplpp(x64emu_t *emu, uintptr_t fcn) { pFplpp_t fn = (pFplpp_t)fcn; R_RAX=(uintptr_t)fn((void*)R_RDI, (intptr_t)R_RSI, (void*)R_RDX, (void*)R_RCX); }
 void pFpLip(x64emu_t *emu, uintptr_t fcn) { pFpLip_t fn = (pFpLip_t)fcn; R_RAX=(uintptr_t)fn((void*)R_RDI, (uintptr_t)R_RSI, (int64_t)R_RDX, (void*)R_RCX); }
+void pFpLLp(x64emu_t *emu, uintptr_t fcn) { pFpLLp_t fn = (pFpLLp_t)fcn; R_RAX=(uintptr_t)fn((void*)R_RDI, (uintptr_t)R_RSI, (uintptr_t)R_RDX, (void*)R_RCX); }
 void pFpLpL(x64emu_t *emu, uintptr_t fcn) { pFpLpL_t fn = (pFpLpL_t)fcn; R_RAX=(uintptr_t)fn((void*)R_RDI, (uintptr_t)R_RSI, (void*)R_RDX, (uintptr_t)R_RCX); }
 void pFppii(x64emu_t *emu, uintptr_t fcn) { pFppii_t fn = (pFppii_t)fcn; R_RAX=(uintptr_t)fn((void*)R_RDI, (void*)R_RSI, (int64_t)R_RDX, (int64_t)R_RCX); }
 void pFppiu(x64emu_t *emu, uintptr_t fcn) { pFppiu_t fn = (pFppiu_t)fcn; R_RAX=(uintptr_t)fn((void*)R_RDI, (void*)R_RSI, (int64_t)R_RDX, (uint64_t)R_RCX); }
@@ -5398,6 +5400,7 @@ int isSimpleWrapper(wrapper_t fun) {
 	if (fun == &pFplpl) return 1;
 	if (fun == &pFplpp) return 1;
 	if (fun == &pFpLip) return 1;
+	if (fun == &pFpLLp) return 1;
 	if (fun == &pFpLpL) return 1;
 	if (fun == &pFppii) return 1;
 	if (fun == &pFppiu) return 1;
diff --git a/src/wrapped/generated/wrapper.h b/src/wrapped/generated/wrapper.h
index c509113b..140ea38e 100644
--- a/src/wrapped/generated/wrapper.h
+++ b/src/wrapped/generated/wrapper.h
@@ -1005,6 +1005,7 @@ void pFpdIU(x64emu_t *emu, uintptr_t fnc);
 void pFplpl(x64emu_t *emu, uintptr_t fnc);
 void pFplpp(x64emu_t *emu, uintptr_t fnc);
 void pFpLip(x64emu_t *emu, uintptr_t fnc);
+void pFpLLp(x64emu_t *emu, uintptr_t fnc);
 void pFpLpL(x64emu_t *emu, uintptr_t fnc);
 void pFppii(x64emu_t *emu, uintptr_t fnc);
 void pFppiu(x64emu_t *emu, uintptr_t fnc);
diff --git a/src/wrapped/wrappedtbbmalloc.c b/src/wrapped/wrappedtbbmalloc.c
new file mode 100644
index 00000000..f2618999
--- /dev/null
+++ b/src/wrapped/wrappedtbbmalloc.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#define _GNU_SOURCE         /* See feature_test_macros(7) */
+#include <dlfcn.h>
+
+#include "wrappedlibs.h"
+
+#include "wrapper.h"
+#include "bridge.h"
+#include "librarian/library_private.h"
+#include "x64emu.h"
+
+// Fake the lib for now, don't load it
+const char* tbbmallocName = "libtbbmalloc.so.2";
+#define LIBNAME tbbmalloc
+
+// this preinit basically open "box64" as dlopen
+#define PRE_INIT\
+    lib->w.lib = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);    \
+    if(0)
+
+#include "wrappedlib_init.h"
diff --git a/src/wrapped/wrappedtbbmalloc_private.h b/src/wrapped/wrappedtbbmalloc_private.h
new file mode 100644
index 00000000..042151cf
--- /dev/null
+++ b/src/wrapped/wrappedtbbmalloc_private.h
@@ -0,0 +1,34 @@
+#if !(defined(GO) && defined(GOM) && defined(GO2) && defined(DATA))
+#error Meh...
+#endif
+
+GOM(safer_scalable_aligned_realloc, pFpLLp) //%noE
+GOM(safer_scalable_free, pFpp) //%noE
+GOM(safer_scalable_msize, LFpp) //%noE
+GOM(safer_scalable_realloc, pFpLp)  //%noE
+GOM(scalable_aligned_free, vFp) //%noE
+GOM(scalable_aligned_malloc, pFLL)  //%noE
+GOM(scalable_aligned_realloc, pFpLL)    //%noE
+//GO(scalable_allocation_command, 
+//GO(scalable_allocation_mode, 
+GOM(scalable_calloc, pFLL)  //%noE
+GO2(scalable_free, vFp, free)
+GO2(scalable_malloc, pFL, malloc)
+GOM(scalable_msize, LFp)    //%noE
+GO2(scalable_posix_memalign, iFpLL, posix_memalign)
+GO2(scalable_realloc, pFpL, realloc)
+GO2(__TBB_internal_calloc, pFLL, calloc)
+GO2(__TBB_internal_free, vFp, free)
+GO2(__TBB_internal_malloc, pFL, malloc)
+GO2(__TBB_internal_malloc_usable_size, LFp, malloc_usable_size)
+GO2(__TBB_internal_posix_memalign, iFpLL, posix_memalign)
+GO2(__TBB_internal_realloc, pFpL, realloc)
+//GO(_ZN3rml10pool_resetEPNS_10MemoryPoolE, 
+//GO(_ZN3rml11pool_createElPKNS_13MemPoolPolicyE, 
+//GO(_ZN3rml11pool_mallocEPNS_10MemoryPoolEm, 
+//GO(_ZN3rml12pool_destroyEPNS_10MemoryPoolE, 
+//GO(_ZN3rml12pool_reallocEPNS_10MemoryPoolEPvm, 
+//GO(_ZN3rml14pool_create_v1ElPKNS_13MemPoolPolicyEPPNS_10MemoryPoolE, 
+//GO(_ZN3rml19pool_aligned_mallocEPNS_10MemoryPoolEmm, 
+//GO(_ZN3rml20pool_aligned_reallocEPNS_10MemoryPoolEPvmm, 
+//GO(_ZN3rml9pool_freeEPNS_10MemoryPoolEPv, 
diff --git a/src/wrapped/wrappedtbbmallocproxy_private.h b/src/wrapped/wrappedtbbmallocproxy_private.h
index 08ef1a97..f85d9e13 100644
--- a/src/wrapped/wrappedtbbmallocproxy_private.h
+++ b/src/wrapped/wrappedtbbmallocproxy_private.h
@@ -21,8 +21,7 @@
 //GO(posix_memalign, 
 //GO(pvalloc, 
 //GO(realloc, 
-//GO(__TBB_internal_find_original_malloc, 
-//GO(__TBB_malloc_proxy, 
+GO2(__TBB_malloc_proxy, pFL, my_malloc)
 //GO(valloc, 
 GOM(_ZdaPv, vFp)                //%noE
 GOM(_ZdaPvRKSt9nothrow_t, vFpp) //%noE
@@ -32,3 +31,11 @@ GOM(_Znam, pFL)                 //%noE
 GOM(_ZnamRKSt9nothrow_t, pFLp)  //%noE
 GOM(_Znwm, pFL)                 //%noE
 GOM(_ZnwmRKSt9nothrow_t, pFLp)  //%noE
+
+GOM(__TBB_internal_find_original_malloc, iFipp) //%noE
+GOM(__TBB_call_with_my_server_info, vFpp)   //%noE
+GOM(__TBB_make_rml_server, iFppp)   //%noE
+GOM(__RML_close_factory, vFp)   //%noE
+GOM(__RML_open_factory, iFppi)  //%noE
+
+GO(dummy_pFpLLp, pFpLLp)    // dummy to have pFpLLp for mallochook
\ No newline at end of file