Introduce libc/mem/tinymalloc.inc

This allocator shaves ~20kb off single-threaded tool programs and is
slightly faster than proper malloc for simple non-demanding programs

Author: jart

libc/mem/BUILD.mk

@@ -8,6 +8,7 @@ LIBC_MEM = $(LIBC_MEM_A_DEPS) $(LIBC_MEM_A)
 LIBC_MEM_A = o/$(MODE)/libc/mem/mem.a
 LIBC_MEM_A_FILES := $(wildcard libc/mem/*)
 LIBC_MEM_A_HDRS = $(filter %.h,$(LIBC_MEM_A_FILES))
+LIBC_MEM_A_INCS = $(filter %.inc,$(LIBC_MEM_A_FILES))
 LIBC_MEM_A_SRCS = $(filter %.c,$(LIBC_MEM_A_FILES))
 LIBC_MEM_A_OBJS = $(LIBC_MEM_A_SRCS:%.c=o/$(MODE)/%.o)
 
@@ -46,6 +47,7 @@ $(LIBC_MEM_A_OBJS): private				\
 LIBC_MEM_LIBS = $(foreach x,$(LIBC_MEM_ARTIFACTS),$($(x)))
 LIBC_MEM_SRCS = $(foreach x,$(LIBC_MEM_ARTIFACTS),$($(x)_SRCS))
 LIBC_MEM_HDRS = $(foreach x,$(LIBC_MEM_ARTIFACTS),$($(x)_HDRS))
+LIBC_MEM_INCS = $(foreach x,$(LIBC_MEM_ARTIFACTS),$($(x)_INCS))
 LIBC_MEM_BINS = $(foreach x,$(LIBC_MEM_ARTIFACTS),$($(x)_BINS))
 LIBC_MEM_CHECKS = $(foreach x,$(LIBC_MEM_ARTIFACTS),$($(x)_CHECKS))
 LIBC_MEM_OBJS = $(foreach x,$(LIBC_MEM_ARTIFACTS),$($(x)_OBJS))

libc/mem/tinymalloc.inc

@@ -0,0 +1,160 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "libc/assert.h"
+#include "libc/errno.h"
+#include "libc/mem/mem.h"
+#include "libc/stdckdint.h"
+#include "libc/str/str.h"
+
+#ifndef MODE_DBG /* don't interfere with asan dlmalloc hooking */
+
+_Alignas(65536) static struct {
+  char memory[1024 * 1024 * 1024];
+  unsigned used, last, free;
+} heap;
+
+static inline bool isheap(char *mem) {
+  return heap.memory <= mem && mem < heap.memory + heap.used;
+}
+
+void free(void *ptr) {
+  char *mem;
+  unsigned base;
+  if (ptr) {
+    mem = (char *)ptr;
+    unassert(isheap(mem));
+    base = mem - heap.memory;
+    *(unsigned *)mem = heap.free;
+    heap.free = base;
+  }
+}
+
+size_t malloc_usable_size(void *ptr) {
+  char *mem = (char *)ptr;
+  unassert(isheap(mem));
+  return ((unsigned *)mem)[-1];
+}
+
+void *memalign(size_t align, size_t need) {
+  char *res;
+  unsigned next, next2, base, toto, *link, *link2;
+
+  // normalize arguments
+  while (align & (align - 1))
+    ++align;
+  if (need < sizeof(unsigned))
+    need = sizeof(unsigned);
+  if (align < sizeof(unsigned))
+    align = sizeof(unsigned);
+  if (align > 65536)
+    goto InvalidArgument;
+  if (ckd_add(&need, need, sizeof(unsigned) - 1))
+    goto OutOfMemory;
+  need &= -sizeof(unsigned);
+
+  // allocate from free list
+  next = heap.free;
+  link = &heap.free;
+  while (next) {
+    next2 = *(unsigned *)(heap.memory + next);
+    link2 = (unsigned *)(heap.memory + next);
+    if (need <= ((unsigned *)(heap.memory + next))[-1]) {
+      *link = next2;
+      return (void *)(heap.memory + next);
+    }
+    next = next2;
+    link = link2;
+  }
+
+  // allocate new static memory
+  base = heap.used;
+  base += sizeof(unsigned);
+  base += align - 1;
+  base &= -align;
+  if (ckd_add(&toto, base, need))
+    goto OutOfMemory;
+  if (toto > sizeof(heap.memory))
+    goto OutOfMemory;
+  res = heap.memory + base;
+  ((unsigned *)res)[-1] = need;
+  heap.used = toto;
+  heap.last = base;
+  return res;
+
+  // we require more vespene gas
+OutOfMemory:
+  errno = ENOMEM;
+  return 0;
+InvalidArgument:
+  errno = EINVAL;
+  return 0;
+}
+
+void *malloc(size_t need) {
+  return memalign(sizeof(max_align_t), need);
+}
+
+void *calloc(size_t count, size_t size) {
+  char *res;
+  unsigned need, used;
+  if (ckd_mul(&need, count, size))
+    need = -1;
+  used = heap.used;
+  if ((res = (char *)malloc(need)))
+    if (res - heap.memory < used)
+      bzero(res, need);
+  return res;
+}
+
+void *realloc(void *ptr, size_t need) {
+  char *res, *mem;
+  unsigned base, have, toto;
+  if (!ptr) {
+    res = (char *)malloc(need);
+  } else {
+    mem = (char *)ptr;
+    unassert(isheap(mem));
+    have = ((unsigned *)mem)[-1];
+    base = mem - heap.memory;
+    if (need < have) {
+      res = mem;
+    } else if (base == heap.last) {
+      if (need < sizeof(unsigned))
+        need = sizeof(unsigned);
+      if (ckd_add(&need, need, sizeof(unsigned) - 1))
+        goto OutOfMemory;
+      need &= -sizeof(unsigned);
+      if (ckd_add(&toto, base, need))
+        goto OutOfMemory;
+      if (toto > sizeof(heap.memory))
+        goto OutOfMemory;
+      ((unsigned *)mem)[-1] = need;
+      heap.used = toto;
+      res = mem;
+    } else if ((res = (char *)malloc(need))) {
+      if (have > need)
+        have = need;
+      memcpy(res, mem, have);
+      free(mem);
+    }
+  }
+  return res;
+OutOfMemory:
+  errno = ENOMEM;
+  return 0;
+}
+
+#endif /* MODE_DBG */

tool/build/apelink.c

@@ -259,6 +259,8 @@ static Elf64_Xword notesize;
 
 static char *r_off32_e_lfanew;
 
+#include "libc/mem/tinymalloc.inc"
+
 static wontreturn void Die(const char *thing, const char *reason) {
   tinyprint(2, thing, ": ", reason, "\n", NULL);
   exit(1);

tool/build/assimilate.c

@@ -67,6 +67,8 @@
 #define FORMAT_MACHO  2
 #define FORMAT_PE     3
 
+#include "libc/mem/tinymalloc.inc"
+
 static int g_arch;
 static int g_format;
 static bool g_force;

tool/build/compile.c

@@ -226,6 +226,8 @@ const char *const kSafeEnv[] = {
     "SYSTEMROOT",  // needed by socket()
 };
 
+#include "libc/mem/tinymalloc.inc"
+
 void OnAlrm(int sig) {
   ++gotalrm;
 }

tool/build/cp.c

@@ -69,6 +69,8 @@ char linkbuf[PATH_MAX];
 
 void Cp(char *, char *);
 
+#include "libc/mem/tinymalloc.inc"
+
 bool IsDirectory(const char *path) {
   int e;
   bool res;

tool/build/elf2pe.c

@@ -158,6 +158,8 @@ static const char *stubpath;
 static long FLAG_SizeOfStackCommit = 64 * 1024;
 static long FLAG_SizeOfStackReserve = 8 * 1024 * 1024;
 
+#include "libc/mem/tinymalloc.inc"
+
 static wontreturn void Die(const char *thing, const char *reason) {
   tinyprint(2, thing, ": ", reason, "\n", NULL);
   exit(1);

tool/build/fixupobj.c

@@ -67,6 +67,8 @@ static Elf64_Ehdr *elf;
 static const char *epath;
 static Elf64_Xword symcount;
 
+#include "libc/mem/tinymalloc.inc"
+
 static wontreturn void Die(const char *reason) {
   tinyprint(2, epath, ": ", reason, "\n", NULL);
   exit(1);

tool/build/gzip.c

@@ -71,6 +71,8 @@ const char *prog;
 char databuf[32768];
 char pathbuf[PATH_MAX];
 
+#include "libc/mem/tinymalloc.inc"
+
 wontreturn void PrintUsage(int rc, FILE *f) {
   fputs("usage: ", f);
   fputs(prog, f);

tool/build/killall.c

@@ -50,6 +50,8 @@ static const char *prog;
 static char16_t **filters;
 static uint32_t pids[10000];
 
+#include "libc/mem/tinymalloc.inc"
+
 static wontreturn void PrintUsage(int rc, FILE *f) {
   fprintf(f,
           "Usage: %s [-nshv] NAME...\n"