Move delarations of emscripten_builtin_malloc to heap.h. NFC

These functions are not specific to emmalloc so don't belong in
that header.

system/include/emscripten/emmalloc.h

@@ -16,13 +16,11 @@ void emmalloc_dump_memory_regions(void);
 // Allocates size bytes with the given pow-2 alignment.
 void *memalign(size_t alignment, size_t size);
 void *emmalloc_memalign(size_t alignment, size_t size);
-void *emscripten_builtin_memalign(size_t alignment, size_t size);
 void *aligned_alloc(size_t alignment, size_t size);
 
 // Allocates size bytes with default alignment (8 bytes)
 void *malloc(size_t size);
 void *emmalloc_malloc(size_t size);
-void *emscripten_builtin_malloc(size_t size);
 
 // Returns the number of bytes that are actually allocated to the given pointer ptr.
 // E.g. due to alignment or size requirements, the actual size of the allocation can be
@@ -36,7 +34,6 @@ size_t emmalloc_usable_size(void *ptr);
 // (emmalloc_)realloc, emmalloc_realloc_try, emmalloc_realloc_uninitialized, (emmalloc_)aligned_realloc
 void free(void *ptr);
 void emmalloc_free(void *ptr);
-void emscripten_builtin_free(void *ptr);
 
 // Performs a reallocation of the given memory pointer to a new size. If the memory region
 // pointed by ptr cannot be resized in place, a new memory region will be allocated, old

system/include/emscripten/heap.h

@@ -37,6 +37,13 @@ size_t emscripten_get_heap_size(void);
 // Returns the max size of the WebAssembly heap.
 size_t emscripten_get_heap_max(void);
 
+// Direct access to the system allocator.  Use these to access that underlying
+// allocator when intercepting/wrapping the allocator API.  Works with with both
+// dlmalloc and emmalloc.
+void *emscripten_builtin_memalign(size_t alignment, size_t size);
+void *emscripten_builtin_malloc(size_t size);
+void emscripten_builtin_free(void *ptr);
+
 #ifdef __cplusplus
 }
 #endif

system/lib/compiler-rt/lib/lsan/lsan_interceptors.cpp

@@ -32,6 +32,17 @@
 #include "lsan_common.h"
 #include "lsan_thread.h"
 
+#if SANITIZER_EMSCRIPTEN
+#define __ATTRP_C11_THREAD ((void*)(uptr)-1)
+#include <emscripten/heap.h>
+extern "C" {
+int emscripten_builtin_pthread_create(void *thread, void *attr,
+                                      void *(*callback)(void *), void *arg);
+int emscripten_builtin_pthread_join(void *th, void **ret);
+int emscripten_builtin_pthread_detach(void *th);
+}
+#endif
+
 #include <stddef.h>
 
 using namespace __lsan;
@@ -403,18 +414,6 @@ INTERCEPTOR(int, pthread_atfork, void (*prepare)(), void (*parent)(),
 #define LSAN_MAYBE_INTERCEPT_PTHREAD_ATFORK
 #endif
 
-#if SANITIZER_EMSCRIPTEN
-#define __ATTRP_C11_THREAD ((void*)(uptr)-1)
-extern "C" {
-  int emscripten_builtin_pthread_create(void *thread, void *attr,
-                                        void *(*callback)(void *), void *arg);
-  int emscripten_builtin_pthread_join(void *th, void **ret);
-  int emscripten_builtin_pthread_detach(void *th);
-  void *emscripten_builtin_malloc(size_t size);
-  void emscripten_builtin_free(void *);
-}
-#endif
-
 #if SANITIZER_INTERCEPT_STRERROR
 INTERCEPTOR(char *, strerror, int errnum) {
   __lsan::ScopedInterceptorDisabler disabler;

system/lib/libc/emscripten_mmap.c

@@ -13,7 +13,6 @@
 #include <sys/mman.h>
 
 #include <emscripten/heap.h>
-#include <emscripten/emmalloc.h>
 
 #include "lock.h"
 #include "syscall.h"

system/lib/libc/musl/src/env/__environ.c

@@ -8,9 +8,7 @@ weak_alias(__environ, environ);
 #ifdef __EMSCRIPTEN__
 #include <stdlib.h>
 #include <wasi/api.h>
-// Included for emscripten_builtin_free / emscripten_builtin_malloc
-// TODO(sbc): Should these be in their own header to avoid emmalloc here?
-#include <emscripten/emmalloc.h>
+#include <emscripten/heap.h>
 
 // We use emscripten_builtin_malloc here because this memory is never freed and
 // and we don't want LSan to consider this a leak.

system/lib/pthread/emscripten_tls_init.c

@@ -5,9 +5,7 @@
  * found in the LICENSE file.
  */
 
-// Included for emscripten_builtin_free / emscripten_builtin_malloc
-// TODO(sbc): Should these be in their own header to avoid emmalloc here?
-#include <emscripten/emmalloc.h>
+#include <emscripten/heap.h>
 #include <emscripten/threading.h>
 
 #include "pthread_impl.h"

system/lib/pthread/pthread_create.c

@@ -14,9 +14,7 @@
 #include <string.h>
 #include <threads.h>
 #include <unistd.h>
-// Included for emscripten_builtin_free / emscripten_builtin_malloc
-// TODO(sbc): Should these be in their own header to avoid emmalloc here?
-#include <emscripten/emmalloc.h>
+#include <emscripten/heap.h>
 
 #define STACK_ALIGN 16
 

system/lib/pthread/thread_profiler.c

@@ -10,9 +10,7 @@
 #include <stdbool.h>
 #include "pthread_impl.h"
 #include <emscripten/threading.h>
-// Included for emscripten_builtin_free / emscripten_builtin_malloc
-// TODO(sbc): Should these be in their own header to avoid emmalloc here?
-#include <emscripten/emmalloc.h>
+#include <emscripten/heap.h>
 
 static bool enabled = false;
 

tests/core/test_wrap_malloc.c

@@ -0,0 +1,48 @@
+// Copyright 2016 The Emscripten Authors.  All rights reserved.
+// Emscripten is available under two separate licenses, the MIT license and the
+// University of Illinois/NCSA Open Source License.  Both these licenses can be
+// found in the LICENSE file.
+
+#include <assert.h>
+#include <emscripten/console.h>
+#include <emscripten/heap.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static int totalAllocs;
+static int totalFrees;
+
+void *malloc(size_t size) {
+  ++totalAllocs;
+  void *ptr = emscripten_builtin_malloc(size);
+  emscripten_console_logf("Allocated %zu bytes, got %p. %d pointers allocated total.", size, ptr, totalAllocs);
+  return ptr;
+}
+
+void free(void *ptr) {
+  ++totalFrees;
+  emscripten_builtin_free(ptr);
+  emscripten_console_logf("Freed ptr %p, %d pointers freed total.", ptr, totalFrees);
+}
+
+int main() {
+  // Reset these globals here, to ignore any allocations during startup by the
+  // system
+  totalAllocs = 0;
+  totalFrees = 0;
+
+  for (int i = 0; i < 20; ++i) {
+    void *ptr = malloc(1024 * 1024);
+    // Make sure we do something with the pointer do ensure the optimizer
+    // doesn't completely remove the allocation.
+    emscripten_console_logf("alloacted: %p", ptr);
+    free(ptr);
+  }
+
+  emscripten_console_logf("totalAllocs: %d", totalAllocs);
+  emscripten_console_logf("totalFrees: %d", totalFrees);
+  assert(totalAllocs == 20);
+  assert(totalFrees == 20);
+  emscripten_console_logf("OK.");
+  return 0;
+}

tests/pthread/test_pthread_proxying_refcount.c

@@ -2,6 +2,7 @@
 #include <emscripten/console.h>
 #include <emscripten/emscripten.h>
 #include <emscripten/proxying.h>
+#include <emscripten/heap.h>
 #include <pthread.h>
 #include <stdbool.h>
 #include <unistd.h>
@@ -21,7 +22,6 @@ em_proxying_queue* queues[4];
 
 int queues_freed[4] = {};
 
-extern void emscripten_builtin_free(void* mem);
 void __attribute__((noinline)) free(void* ptr) {
   for (int i = 0; i < 4; i++) {
     if (ptr && queues[i] == ptr) {

tests/test_core.py

@@ -8475,7 +8475,7 @@ def test_mallinfo(self):
   @no_asan('cannot replace malloc/free with ASan')
   @no_lsan('cannot replace malloc/free with LSan')
   def test_wrap_malloc(self):
-    self.do_runf(test_file('wrap_malloc.cpp'), 'OK.')
+    self.do_runf(test_file('core/test_wrap_malloc.c'), 'OK.')
 
   def test_environment(self):
     self.set_setting('ASSERTIONS')