yap-6.3/C/alloc.c

/*************************************************************************
*									 *
*	 YAP Prolog 							 *
*									 *
*	Yap Prolog was developed at NCCUP - Universidade do Porto	 *
*									 *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997	 *
*									 *
**************************************************************************
*									 *
* File:		alloc.c							 *
* Last rev:								 *
* mods:									 *
* comments:	allocating space					 *
* version:$Id: alloc.c,v 1.95 2008-05-10 23:24:11 vsc Exp $		 *
*************************************************************************/
#ifdef SCCS
static char SccsId[] = "%W% %G%";

#endif

#include "Yap.h"


#include "alloc.h"
#include "YapHeap.h"
#include "Yatom.h"
#include "yapio.h"
#if HAVE_STRING_H
#include <string.h>
#endif
#if HAVE_MALLOC_H
#include <malloc.h>
#endif
#if USE_DL_MALLOC
#include "dlmalloc.h"
#endif
#if HAVE_MEMORY_H
#include <memory.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_FCNTL_H
#include <fcntl.h>
#endif
#if HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#include <stdio.h>
#include <stdlib.h>

#if __simplescalar__
#ifdef USE_SYSTEM_MMAP
#undef USE_SYSTEM_MMAP
#endif
#ifdef USE_SBRK
#undef USE_SBRK
#endif
#endif

/************************************************************************/
/* Yap workspace management                                             */

#define MASK 0x968e00
#if USE_SYSTEM_MALLOC

#if 1

#undef free
#undef malloc
#undef realloc

int write_malloc = 0;

void *my_malloc(size_t sz) {
  void *p;

  p = malloc(sz);
  //    Yap_DebugPuts(stderr,"gof\n");
  if (sz > 500 && write_malloc++ > 0)
    __android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "+ %d %p", write_malloc,
                        p);
  return p;
}

void *my_realloc(void *ptr, size_t sz) {
  void *p;

  p = realloc(ptr, sz);
  //    Yap_DebugPuts(stderr,"gof\n");
  if (sz > 500 && write_malloc++ > 0)
    __android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "* %d %p", write_malloc,
                        p);
  return p;
}

void my_free(void *p) {
  // printf("f %p\n",p);
  if (write_malloc && write_malloc++ > 0)
    __android_log_print(ANDROID_LOG_ERROR, "YAPDroid ", "- %d %p", write_malloc,
                        p);

  free(p);
  //    Yap_DebugPuts(stderr,"gof\n");
}

#endif

#else // USE_SYSTEM_MALLOC

#define my_malloc(sz) Yap_dlmalloc(sz)
#define my_realloc(ptr, sz) Yap_dlrealloc(ptr, sz)
#define my_free(sz) Yap_dlfree(sz)

static char *my_reallocl(char *ptr, UInt sz, UInt osz, int safe) {
  char *nptr;

restart:
  /* simple case */
  if (ptr < Yap_HeapBase || ptr > HeapTop) {
    /* we have enough room */
    nptr = Yap_dlmalloc(sz);
    if (nptr) {
      memmove(nptr, ptr, osz);
      free(ptr);
    }
  } else {
    nptr = Yap_dlrealloc(ptr, sz);
  }
  if (nptr) {
    return nptr;
  }
  /* we do not have enough room */
  if (safe) {
    if (Yap_growheap(FALSE, sz, NULL)) {
      /* now, we have room */
      goto restart;
    }
  }
  /* no room in Heap, gosh */
  if (ptr < Yap_HeapBase || ptr > HeapTop) {
    /* try expanding outside the heap */
    nptr = realloc(ptr, sz);
    if (nptr) {
      memmove(nptr, ptr, osz);
    }
  } else {
    /* try calling the outside world for help */
    nptr = malloc(sz);
    if (!nptr)
      return NULL;
    memmove(nptr, ptr, osz);
    Yap_dlfree(ptr);
  }
  /* did we suceed? at this point we could not care less */
  return nptr;
}
#endif

#if USE_SYSTEM_MALLOC || USE_DL_MALLOC

long long unsigned int mallocs, reallocs, frees;
long long unsigned int tmalloc;

#undef INSTRUMENT_MALLOC

static inline char *call_malloc(size_t size) {
  CACHE_REGS
  char *out;
#if USE_DL_MALLOC
  LOCK(DLMallocLock);
#endif
#if INSTRUMENT_MALLOC
  mallocs++;
  tmalloc += size;
  size += sizeof(CELL);
#endif
  LOCAL_PrologMode |= MallocMode;
  out = (char *)my_malloc(size);
#if INSTRUMENT_MALLOC
  *(CELL *)out = size - sizeof(CELL);
  out += sizeof(CELL);
#endif
  LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
  UNLOCK(DLMallocLock);
#endif
  return out;
}

void *Yap_AllocCodeSpace(size_t size) {
  size = AdjustSize(size);
  return call_malloc(size);
}

static inline char *call_realloc(char *p, size_t size) {
  CACHE_REGS
  char *out;
#if USE_DL_MALLOC
  LOCK(DLMallocLock);
#endif
#if INSTRUMENT_MALLOC
  reallocs++;
  tmalloc += size;
  size += sizeof(CELL);
  p -= sizeof(CELL);
  tmalloc -= *(CELL *)p;
#endif
  LOCAL_PrologMode |= MallocMode;
  out = (char *)my_realloc(p, size);
#if INSTRUMENT_MALLOC
  *(CELL *)out = size - sizeof(CELL);
  out += sizeof(CELL);
#endif
  LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
  UNLOCK(DLMallocLock);
#endif
  return out;
}

void *Yap_ReallocCodeSpace(void *p, size_t size) {
  size = AdjustSize(size);
  return call_realloc(p, size);
}

void Yap_FreeCodeSpace(void *p) {
  CACHE_REGS
#if USE_DL_MALLOC
  LOCK(DLMallocLock);
#endif
  LOCAL_PrologMode |= MallocMode;
#if INSTRUMENT_MALLOC
  p -= sizeof(CELL);
  tmalloc -= *(CELL *)p;
  frees++;
#endif
  my_free(p);
  LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
  UNLOCK(DLMallocLock);
#endif
}

void *Yap_AllocAtomSpace(size_t size) {
  size = AdjustSize(size);
  return call_malloc(size);
}

void Yap_FreeAtomSpace(void *p) {
  CACHE_REGS
#if USE_DL_MALLOC
  LOCK(DLMallocLock);
#endif
  LOCAL_PrologMode |= MallocMode;
#if INSTRUMENT_MALLOC
  p -= sizeof(CELL);
  tmalloc -= *(CELL *)p;
  frees++;
#endif
  my_free(p);
  LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
  UNLOCK(DLMallocLock);
#endif
}

#endif

/* If you need to dinamically allocate space from the heap, this is
 * the macro you should use */
ADDR Yap_InitPreAllocCodeSpace(int wid) {
  CACHE_REGS
  char *ptr;
  UInt sz = REMOTE_ScratchPad(wid).msz;

  if (REMOTE_ScratchPad(wid).ptr == NULL) {
#if USE_DL_MALLOC
    LOCK(DLMallocLock);
#endif
    REMOTE_PrologMode(wid) |= MallocMode;
#if INSTRUMENT_MALLOC
    mallocs++;
    tmalloc += sz;
    sz += sizeof(CELL);
#endif
    while (!(ptr =
#ifdef YAPOR_COPY
                 malloc(sz)
#else
                 my_malloc(sz)
#endif
                 )) {
      REMOTE_PrologMode(wid) &= ~MallocMode;
#if USE_DL_MALLOC
      UNLOCK(DLMallocLock);
#endif
      if (!Yap_growheap(FALSE, LOCAL_Error_Size, NULL)) {
        Yap_Error(RESOURCE_ERROR_HEAP, TermNil, LOCAL_ErrorMessage);
        return (NULL);
      }
#if INSTRUMENT_MALLOC
      sz -= sizeof(CELL);
      *(CELL *)ptr = sz;
      ptr += sizeof(CELL);
#endif
#if USE_DL_MALLOC
      LOCK(DLMallocLock);
#endif
      REMOTE_PrologMode(wid) |= MallocMode;
    }
    REMOTE_PrologMode(wid) &= ~MallocMode;
#if USE_DL_MALLOC
    UNLOCK(DLMallocLock);
#endif
    REMOTE_ScratchPad(wid).ptr = ptr;
  } else {
    ptr = REMOTE_ScratchPad(wid).ptr;
  }
  AuxBase = (ADDR)(ptr);
  AuxSp = (CELL *)(AuxTop = AuxBase + REMOTE_ScratchPad(wid).sz);
  return ptr;
}

ADDR Yap_ExpandPreAllocCodeSpace(UInt sz0, void *cip, int safe) {
  CACHE_REGS
  char *ptr;
  UInt sz;
  if (sz0 < SCRATCH_INC_SIZE)
    sz0 = SCRATCH_INC_SIZE;
  if (sz0 < LOCAL_ScratchPad.sz)
    sz = LOCAL_ScratchPad.sz + sz0;
  else
    sz = sz0;
  sz = AdjustLargePageSize(sz + sz / 4);

#if USE_DL_MALLOC
  LOCK(DLMallocLock);
#endif
  LOCAL_PrologMode |= MallocMode;
#if INSTRUMENT_MALLOC
  reallocs++;
  tmalloc -= LOCAL_ScratchPad.sz;
  tmalloc += sz;
#endif
  if (!(ptr = my_realloc(LOCAL_ScratchPad.ptr, sz))) {
    LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
    UNLOCK(DLMallocLock);
#endif
    return NULL;
  }
  LOCAL_PrologMode &= ~MallocMode;
#if USE_DL_MALLOC
  UNLOCK(DLMallocLock);
#endif
  LOCAL_ScratchPad.sz = LOCAL_ScratchPad.msz = sz;
  LOCAL_ScratchPad.ptr = ptr;
  AuxBase = ptr;
  AuxSp = (CELL *)(AuxTop = ptr + sz);
  return ptr;
}

#if USE_SYSTEM_MALLOC

struct various_codes *Yap_heap_regs;

static void InitHeap(void) {
  Yap_heap_regs =
      (struct various_codes *)calloc(1, sizeof(struct various_codes));
}

void Yap_InitHeap(void *heap_addr) {
  InitHeap();
  Yap_HoleSize = 0;
  HeapMax = 0;
}

static void InitExStacks(int wid, int Trail, int Stack) {
  CACHE_REGS
  UInt pm, sa;

  /* sanity checking for data areas */
  if (Trail < MinTrailSpace)
    Trail = MinTrailSpace;
  if (Stack < MinStackSpace)
    Stack = MinStackSpace;
  pm = (Trail + Stack) * K; /* memory to be
                             * requested         */
  sa = Stack * K;           /* stack area size   */

#ifdef THREADS
  if (wid)
    REMOTE_GlobalBase(wid) = (ADDR)REMOTE_ThreadHandle(wid).stack_address;
  else
    AuxSp = NULL;
#endif
  REMOTE_TrailTop(wid) = REMOTE_GlobalBase(wid) + pm;
  REMOTE_LocalBase(wid) = REMOTE_GlobalBase(wid) + sa;
  REMOTE_TrailBase(wid) = REMOTE_LocalBase(wid) + sizeof(CELL);

  REMOTE_ScratchPad(wid).ptr = NULL;
  REMOTE_ScratchPad(wid).sz = REMOTE_ScratchPad(wid).msz = SCRATCH_START_SIZE;

#if DEBUG
  if (Yap_output_msg) {
    UInt ta;

    fprintf(stderr,
            "HeapBase = %p  GlobalBase = %p\n  LocalBase = %p  TrailTop = %p\n",
            Yap_HeapBase, REMOTE_GlobalBase(wid), REMOTE_LocalBase(wid),
            REMOTE_TrailTop(wid));

    ta = Trail * K; /* trail area size   */
    fprintf(stderr, "Heap+Aux: %lu\tLocal+Global: %lu\tTrail: %lu\n",
            (long unsigned)(pm - sa - ta), (long unsigned)sa,
            (long unsigned)ta);
  }
#endif /* DEBUG */
}

void Yap_InitExStacks(int wid, int Trail, int Stack) {
  InitExStacks(wid, Trail, Stack);
}

#if defined(THREADS)
void Yap_KillStacks(int wid) {
  ADDR gb = REMOTE_ThreadHandle(wid).stack_address;
  if (gb) {
    free(gb);
    REMOTE_ThreadHandle(wid).stack_address = NULL;
  }
}
#else
void Yap_KillStacks(int wid) {
  if (LOCAL_GlobalBase) {
    free(LOCAL_GlobalBase);
    LOCAL_GlobalBase = NULL;
  }
}
#endif

void Yap_InitMemory(UInt Trail, UInt Heap, UInt Stack) { InitHeap(); }

int Yap_ExtendWorkSpace(Int s) {
  CACHE_REGS
  void *basebp = LOCAL_GlobalBase, *nbp;
  UInt s0 = LOCAL_TrailTop - LOCAL_GlobalBase;
  nbp = realloc(basebp, s + s0);
  if (nbp == NULL)
    return FALSE;
#if defined(THREADS)
  LOCAL_ThreadHandle.stack_address = (char *)nbp;
#endif
  LOCAL_GlobalBase = (char *)nbp;
  return TRUE;
}

size_t Yap_ExtendWorkSpaceThroughHole(size_t s) { return 0; }

void Yap_AllocHole(UInt actual_request, UInt total_size) {}

#if HAVE_MALLINFO
UInt Yap_givemallinfo(void) {
  struct mallinfo mi = mallinfo();
  return mi.uordblks;
}
#endif

#else

#if HAVE_SNPRINTF
#define snprintf3(A, B, C) snprintf(A, B, C)
#define snprintf4(A, B, C, D) snprintf(A, B, C, D)
#define snprintf5(A, B, C, D, E) snprintf(A, B, C, D, E)
#else
#define snprintf3(A, B, C) sprintf(A, C)
#define snprintf4(A, B, C, D) sprintf(A, C, D)
#define snprintf5(A, B, C, D, E) sprintf(A, C, D, E)
#endif

#ifdef LIGHT
#include <stdlib.h>
#endif

#if !USE_DL_MALLOC

static void FreeBlock(BlockHeader *);
static BlockHeader *GetBlock(unsigned long int);
static char *AllocHeap(unsigned long int);
static void RemoveFromFreeList(BlockHeader *);
static void AddToFreeList(BlockHeader *);

#define MinHGap 256 * K

static void RemoveFromFreeList(BlockHeader *b) {
  BlockHeader *p;

  p = b->b_next_size;
  LOCK(HeapUsedLock);
  HeapUsed += (b->b_size + 1) * sizeof(YAP_SEG_SIZE);
  UNLOCK(HeapUsedLock);

  if (p && b->b_size == p->b_size) {
    b = b->b_next;
    p->b_next = b;
    if (b)
      b->b_next_size = p;
  } else {
    BlockHeader **q = &FreeBlocks;

    while ((*q) != b)
      q = &((*q)->b_next_size);
    if (b->b_next) {
      p = b->b_next;
      *q = p;
      p->b_next_size = b->b_next_size;
    } else {
      *q = b->b_next_size;
    }
  }
}

static void AddToFreeList(BlockHeader *b) {
  BlockHeader **q, *p;
  YAP_SEG_SIZE *sp;

  /* insert on list of free blocks */
  q = &FreeBlocks;
  sp = &(b->b_size) + b->b_size;
  *sp = b->b_size;
  LOCK(HeapUsedLock);
  HeapUsed -= (b->b_size + 1) * sizeof(YAP_SEG_SIZE);
  UNLOCK(HeapUsedLock);

  while ((p = *q) && p->b_size < b->b_size)
    q = &p->b_next_size;
  if (p && p->b_size == b->b_size) {
    b->b_next = p;
    b->b_next_size = p->b_next_size;
    p->b_next_size = b;
  } else {
    b->b_next = NIL;
    b->b_next_size = p;
  }
  *q = b;
}

static void FreeBlock(BlockHeader *b) {
  BlockHeader *p;
  YAP_SEG_SIZE *sp;

  /*  {
    static long long int vsc_free_ops;

    vsc_free_ops++;
    BlockHeader *q = FreeBlocks;
    while (q) q = q->b_next_size;
    }*/

  /* sanity check */
  sp = &(b->b_size) + (b->b_size & ~InUseFlag);
  if (!(b->b_size & InUseFlag) || *sp != b->b_size) {
#if !SHORT_INTS
    fprintf(
        stderr,
        "%% YAP INTERNAL ERROR: sanity check failed in FreeBlock %p %x %x\n", b,
        b->b_size, Unsigned(*sp));
#else
    fprintf(
        stderr,
        "%% YAP INTERNAL ERROR: sanity check failed in FreeBlock %p %lx %lx\n",
        b, b->b_size, *sp);
#endif
    return;
  }
  b->b_size &= ~InUseFlag;
  LOCK(FreeBlocksLock);
  /* check if we can collapse with other blocsks */
  /* check previous */
  sp = &(b->b_size) - 1;
  if (!(*sp & InUseFlag)) { /* previous block is free */
    p = (BlockHeader *)(sp - *sp);
    RemoveFromFreeList(p);
    p->b_size += b->b_size + 1;
    b = p;
  }
  /* check following */
  sp = &(b->b_size) + b->b_size + 1;
  if (!(*sp & InUseFlag)) { /* following block is free */
    p = (BlockHeader *)sp;
    RemoveFromFreeList(p);
    b->b_size += p->b_size + 1;
  }
  LOCK(HeapTopLock);
  if (sp == (YAP_SEG_SIZE *)HeapTop) {
    LOCK(HeapUsedLock);
    HeapUsed -= (b->b_size + 1) * sizeof(YAP_SEG_SIZE);
    UNLOCK(HeapUsedLock);
    HeapTop = (ADDR)b;
    *((YAP_SEG_SIZE *)HeapTop) = InUseFlag;
  } else {
    /* insert on list of free blocks */
    AddToFreeList(b);
  }
  UNLOCK(HeapTopLock);
  UNLOCK(FreeBlocksLock);
}

static BlockHeader *
GetBlock(unsigned long int n) { /* get free block with size at least n */
  register BlockHeader **p, *b, *r;

  if (FreeBlocks == NIL)
    return (NIL);
  /* check for bugs */
  p = &FreeBlocks;
  /* end check for bugs */
  p = &FreeBlocks;
  while (((b = *p) != NIL) && b->b_size < n)
    p = &b->b_next_size;
  if (b == NIL || b->b_size < n)
    return (NIL);
  if ((r = b->b_next) == NIL)
    *p = b->b_next_size;
  else {
    r->b_next_size = b->b_next_size;
    *p = r;
  }
  LOCK(HeapUsedLock);
  HeapUsed += (b->b_size + 1) * sizeof(YAP_SEG_SIZE);
  if (HeapUsed > HeapMax)
    HeapMax = HeapUsed;
  UNLOCK(HeapUsedLock);
  return (b);
}

static char *AllocHeap(size_t size) {
  BlockHeader *b, *n;
  YAP_SEG_SIZE *sp;
  UInt align, extra;

  /*  {
    static long long int vsc_alloc_ops;
    vsc_alloc_ops++;
    BlockHeader *q = FreeBlocks;
    while (q) q = q->b_next_size;
    }*/

  extra = size / 16;
#if SIZEOF_INT_P == 4
  align = 2 * sizeof(CELL); /* size in dwords + 2 */
#endif
#if SIZEOF_INT_P == 8
  align = sizeof(CELL);
#endif
  while (align < extra)
    align *= 2;
  size = ALIGN_SIZE(size, align);
  if (size < sizeof(BlockHeader))
    size = sizeof(BlockHeader);
  size += sizeof(YAP_SEG_SIZE);
  /* change units to cells */
  size = size / sizeof(CELL);
  LOCK(FreeBlocksLock);
  if ((b = GetBlock(size))) {
    if (b->b_size >= size + 24 + 1) {
      n = (BlockHeader *)(((YAP_SEG_SIZE *)b) + size + 1);
      n->b_size = b->b_size - size - 1;
      b->b_size = size;
      AddToFreeList(n);
    }
    sp = &(b->b_size) + b->b_size;
    *sp = b->b_size | InUseFlag;
    b->b_size |= InUseFlag;
    UNLOCK(FreeBlocksLock);
    return (Addr(b) + sizeof(YAP_SEG_SIZE));
  }
  LOCK(HeapTopLock);
  UNLOCK(FreeBlocksLock);
  b = (BlockHeader *)HeapTop;
  HeapTop += size * sizeof(CELL) + sizeof(YAP_SEG_SIZE);
  LOCK(HeapUsedLock);
  HeapUsed += size * sizeof(CELL) + sizeof(YAP_SEG_SIZE);

#ifdef YAPOR
  if (HeapTop > Addr(LOCAL_GlobalBase) - MinHeapGap)
    Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "no heap left (AllocHeap)");
#else
  if (HeapTop > HeapLim - MinHeapGap) {
    HeapTop -= size * sizeof(CELL) + sizeof(YAP_SEG_SIZE);
    HeapUsed -= size * sizeof(CELL) + sizeof(YAP_SEG_SIZE);
    if (HeapTop > HeapLim) {
      UNLOCK(HeapUsedLock);
      UNLOCK(HeapTopLock);
      /* we destroyed the stack */
      Yap_Error(RESOURCE_ERROR_HEAP, TermNil, "Stack Crashed against Heap...");
      return (NULL);
    } else {
      if (HeapTop + size * sizeof(CELL) + sizeof(YAP_SEG_SIZE) < HeapLim) {
        /* small allocations, we can wait */
        HeapTop += size * sizeof(CELL) + sizeof(YAP_SEG_SIZE);
        HeapUsed += size * sizeof(CELL) + sizeof(YAP_SEG_SIZE);
        UNLOCK(HeapUsedLock);
        UNLOCK(HeapTopLock);
        Yap_signal(YAP_CDOVF_SIGNAL);
      } else {
        if (size > GLOBAL_SizeOfOverflow)
          GLOBAL_SizeOfOverflow = size * sizeof(CELL) + sizeof(YAP_SEG_SIZE);
        /* big allocations, the caller must handle the problem */
        UNLOCK(HeapUsedLock);
        UNLOCK(HeapTopLock);
        return (NULL);
      }
    }
  }
#endif /* YAPOR */
  *((YAP_SEG_SIZE *)HeapTop) = InUseFlag;
  if (HeapUsed > HeapMax)
    HeapMax = HeapUsed;
  UNLOCK(HeapUsedLock);
  b->b_size = size | InUseFlag;
  sp = &(b->b_size) + size;
  *sp = b->b_size;
  UNLOCK(HeapTopLock);
  return (Addr(b) + sizeof(YAP_SEG_SIZE));
}

/* If you need to dinamically allocate space from the heap, this is
 * the macro you should use */
static void FreeCodeSpace(char *p) {
  FreeBlock(((BlockHeader *)(p - sizeof(YAP_SEG_SIZE))));
}

static char *AllocCodeSpace(unsigned long int size) {
  if (size < SmallSize + 2 * OpCodeSize + 3 * CellSize)
    return (AllocHeap(SmallSize + 2 * OpCodeSize + 3 * CellSize));
  return (AllocHeap(size));
}

#if DEBUG_ALLOC
int vsc_mem_trace;
#endif

/* If you need to dinamically allocate space from the heap, this is
 * the macro you should use */
void Yap_FreeCodeSpace(char *p) {
#if DEBUG_ALLOC
  if (vsc_mem_trace)
    printf("-%p\n", p);
#endif
  FreeCodeSpace(p);
}

char *Yap_AllocAtomSpace(unsigned long int size) {
  char *out = AllocHeap(size);
#if DEBUG_ALLOC
  if (vsc_mem_trace)
    printf("+%p/%d\n", out, size);
#endif
  return out;
}

void Yap_FreeAtomSpace(char *p) {
#if DEBUG_ALLOC
  if (vsc_mem_trace)
    printf("-%p\n", p);
#endif
  FreeCodeSpace(p);
}

char *Yap_AllocCodeSpace(unsigned long int size) {
  char *out = AllocCodeSpace(size);
#if DEBUG_ALLOC
  if (vsc_mem_trace)
    printf("+%p/%d\n", out, size);
#endif
  return out;
}

#endif

/************************************************************************/
/* Workspace allocation                                                 */
/*                                                                      */
/* We provide four alternatives for workspace allocation.               */
/* - use 'mmap'                                                         */
/* - use 'shmat'                                                        */
/* - use 'sbrk' and provide a replacement to the 'malloc' library       */
/* - use 'malloc'                                                       */
/*                                                                      */
/*  In any of the alternatives the interface is through the following   */
/* functions:                                                           */
/*   void *InitWorkSpace(int s) - initial workspace allocation          */
/*   int ExtendWorkSpace(int s) - extend workspace                      */
/*   int Yap_FreeWorkSpace() - release workspace                            */
/************************************************************************/

#if defined(_WIN32) || defined(__CYGWIN__)

#undef DEBUG_WIN32_ALLO

#include "windows.h"

static LPVOID brk;

static int ExtendWorkSpace(Int s, int fixed_allocation) {
  LPVOID b = brk;
  prolog_exec_mode OldPrologMode = LOCAL_PrologMode;

  LOCAL_PrologMode = ExtendStackMode;

#if DEBUG_WIN32_ALLOC
  fprintf(stderr, "trying: %p (" Int_FORMAT "K) %d\n", b, s / 1024,
          fixed_allocation);
#endif
  if (fixed_allocation) {
    b = VirtualAlloc(b, s, MEM_RESERVE, PAGE_NOACCESS);
  } else {
    b = VirtualAlloc(NULL, s, MEM_RESERVE, PAGE_NOACCESS);
    if (b && b < brk) {
      return ExtendWorkSpace(s, fixed_allocation);
    }
  }
  if (!b) {
    LOCAL_PrologMode = OldPrologMode;
#if DEBUG_WIN32_ALLOC
    {
      char msg[256];
      FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                    NULL, GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), msg, 256, NULL);
      fprintf(stderr, "NOT OK1: %p %p %s\n", brk, b, msg);
    }
#endif
    return FALSE;
  }
  b = VirtualAlloc(b, s, MEM_COMMIT, PAGE_READWRITE);
  if (!b) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
    snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "VirtualAlloc could not commit %ld bytes", (long int)s);
    LOCAL_PrologMode = OldPrologMode;
#if DEBUG_WIN32_ALLOC
    fprintf(stderr, "NOT OK2: %p--%p\n", b, brk);
#endif
    return FALSE;
  }
  brk = (LPVOID)((Int)b + s);
#if DEBUG_WIN32_ALLOC
  fprintf(stderr, "OK: %p--%p " Int_FORMAT "\n", b, brk, s);
#endif
  LOCAL_PrologMode = OldPrologMode;
  return TRUE;
}

static MALLOC_T InitWorkSpace(Int s) {
  SYSTEM_INFO si;
  Int psz;

  GetSystemInfo(&si);
  psz = Yap_page_size = si.dwPageSize;
  brk = (LPVOID)psz;
  if (!ExtendWorkSpace(s, 0))
    return FALSE;
  return (MALLOC_T)brk - s;
}

int Yap_FreeWorkSpace(void) { return TRUE; }

#elif USE_SYSTEM_MMAP

#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif
#if HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#if HAVE_FCNTL_H
#include <fcntl.h>
#endif

#ifdef MMAP_ADDR
#define USE_FIXED 1
#endif

#ifndef MAP_FIXED
#define MAP_FIXED 1
#endif

static MALLOC_T WorkSpaceTop;

static MALLOC_T InitWorkSpace(Int s) {
  MALLOC_T a;
#if !defined(_AIX) && !defined(__APPLE__) && !__hpux
  int fd;
#endif
#if defined(_AIX)
  a = mmap(0, (size_t)s, PROT_READ | PROT_WRITE | PROT_EXEC,
           MAP_PRIVATE | MAP_ANONYMOUS | MAP_VARIABLE, -1, 0);
#elif __hpux
  a = mmap(((void *)MMAP_ADDR), (size_t)s, PROT_READ | PROT_WRITE | PROT_EXEC,
           MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
  if (a != (MALLOC_T)MMAP_ADDR) {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil,
              "mmap could not map ANON at %p, got %p", (void *)MMAP_ADDR, a);
    return (NULL);
  }
#elif defined(__APPLE__)
#ifdef MMAP_ADDR
  a = mmap(((void *)MMAP_ADDR), (size_t)s, PROT_READ | PROT_WRITE | PROT_EXEC,
           MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0);
  if (a != (MALLOC_T)MMAP_ADDR) {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil,
              "mmap could not map ANON at %p, got %p", (void *)MMAP_ADDR, a);
    return (NULL);
  }
#else
  a = mmap(NULL, (size_t)s, PROT_READ | PROT_WRITE | PROT_EXEC,
           MAP_PRIVATE | MAP_ANON, -1, 0);
#endif
#else
  fd = open("/dev/zero", O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
  if (fd < 0) {
#if HAVE_MKSTEMP
    char file[256];
    strncpy(file, "/tmp/YAP.TMPXXXXXX", 256);
    if (mkstemp(file) == -1) {
#if HAVE_STRERROR
      Yap_Error(SYSTEM_ERROR_FATAL, TermNil,
                "mkstemp could not create temporary file %s (%s)", file,
                strerror(errno));
#else
      Yap_Error(SYSTEM_ERROR_FATAL, TermNil,
                "mkstemp could not create temporary file %s", file);
#endif
      return NULL;
    }
#else
#if HAVE_TMPNAM
    char *file = tmpnam(NULL);
#else
    char file[YAP_FILENAME_MAX];
    strcpy(file, "/tmp/mapfile");
    itos(getpid(), &file[12]);
#endif /* HAVE_TMPNAM */
#endif /* HAVE_MKSTEMP */
    fd = open(file, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    if (fd < 0) {
      Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "mmap could not open %s", file);
      return NULL;
    }
    if (lseek(fd, s, SEEK_SET) < 0) {
      Yap_Error(SYSTEM_ERROR_FATAL, TermNil,
                "mmap could not lseek in mmapped file %s", file);
      close(fd);
      return FALSE;
    }
    if (write(fd, "", 1) < 0) {
      Yap_Error(SYSTEM_ERROR_FATAL, TermNil,
                "mmap could not write in mmapped file %s", file);
      close(fd);
      return NULL;
    }
    if (unlink(file) < 0) {
      Yap_Error(SYSTEM_ERROR_FATAL, TermNil,
                "mmap could not unlink mmapped file %s", file);
      close(fd);
      return NULL;
    }
  }
#if USE_FIXED
  a = mmap(((void *)MMAP_ADDR), (size_t)s, PROT_READ | PROT_WRITE | PROT_EXEC,
           MAP_PRIVATE | MAP_FIXED, fd, 0);
  if (a != (MALLOC_T)MMAP_ADDR) {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "mmap could not map at %p, got %p",
              (void *)MMAP_ADDR, a);
    return NULL;
  }
#else
  a = mmap(0, (size_t)s, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE, fd,
           0);
  if ((CELL)a & YAP_PROTECTED_MASK) {
    close(fd);
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil,
              "mmapped address %p collides with YAP tags", a);
    return NULL;
  }
  if (close(fd) == -1) {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "while closing mmaped file");
    return NULL;
  }
#endif
#endif
  if
#ifdef MMAP_FAILED
      (a == (MALLOC_T)MMAP_FAILED)
#else
      (a == (MALLOC_T)-1)
#endif
  {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "mmap cannot allocate memory ***");
    return (NULL);
  }
  WorkSpaceTop = (char *)a + s;
  return (void *)a;
}

#ifndef YAPOR
static MALLOC_T mmap_extension(Int s, MALLOC_T base, int fixed_allocation) {
  MALLOC_T a;

#if !defined(_AIX) && !defined(__hpux) && !defined(__APPLE__)
  int fd;
#endif
#if defined(_AIX) || defined(__hpux)
  a = mmap(base, (size_t)s, PROT_READ | PROT_WRITE | PROT_EXEC,
           MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

#elif defined(__APPLE__)
  a = mmap(base, (size_t)s, PROT_READ | PROT_WRITE | PROT_EXEC,
           MAP_PRIVATE | MAP_ANON | fixed_allocation, -1, 0);
#else
  fd = open("/dev/zero", O_RDWR);
  if (fd < 0) {
#if HAVE_MKSTEMP
    char file[256];
    strncpy(file, "/tmp/YAP.TMPXXXXXX", 256);
    if (mkstemp(file) == -1) {
      LOCAL_ErrorMessage = LOCAL_ErrorSay;
#if HAVE_STRERROR
      snprintf5(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
                "mkstemp could not create temporary file %s (%s)", file,
                strerror(errno));
#else
      snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
                "mkstemp could not create temporary file %s", file);
#endif /* HAVE_STRERROR */
      return (MALLOC_T)-1;
    }
#else
#if HAVE_TMPNAM
    char *file = tmpnam(NULL);
#else
    char file[YAP_FILENAME_MAX];
    strcpy(file, "/tmp/mapfile");
    itos(getpid(), &file[12]);
#endif /* HAVE_TMPNAM */
#endif /* HAVE_MKSTEMP */
    fd = open(file, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
    if (fd < 0) {
      LOCAL_ErrorMessage = LOCAL_ErrorSay;
      snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
                "mmap could not open %s", file);
      return (MALLOC_T)-1;
    }
    if (lseek(fd, s, SEEK_SET) < 0) {
      LOCAL_ErrorMessage = LOCAL_ErrorSay;
      snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
                "mmap could not lseek in mmapped file %s", file);
      close(fd);
      return (MALLOC_T)-1;
    }
    if (write(fd, "", 1) < 0) {
      LOCAL_ErrorMessage = LOCAL_ErrorSay;
      snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
                "mmap could not write in mmapped file %s", file);
      close(fd);
      return (MALLOC_T)-1;
    }
    if (unlink(file) < 0) {
      LOCAL_ErrorMessage = LOCAL_ErrorSay;
      snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
                "mmap could not unlink mmapped file %s", file);
      close(fd);
      return (MALLOC_T)-1;
    }
  }
  a = mmap(
      base, (size_t)s, PROT_READ | PROT_WRITE | PROT_EXEC,
      MAP_PRIVATE
#if !defined(__linux)
          /* use  MAP_FIXED, otherwise God knows where you will be placed */
          | fixed_allocation
#endif
      ,
      fd, 0);
  if (close(fd) == -1) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
#if HAVE_STRERROR
    snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "mmap could not close file (%s) ]\n", strerror(errno));
#else
    snprintf3(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "mmap could not close file ]\n");
#endif
    return (MALLOC_T)-1;
  }
#endif
  return a;
}
#endif /* !YAPOR */

/*
   s= how much memory we need;
   fixed_alloc = do we need to contiguously extend stack
   returns TRUE or FALSE

   updates WorkSpaceTop
*/
static int ExtendWorkSpace(Int s, int fixed_allocation) {
#ifdef YAPOR
  Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil,
            "cannot extend stacks (ExtendWorkSpace)");
  return (FALSE);
#else
  MALLOC_T a;
  prolog_exec_mode OldPrologMode = LOCAL_PrologMode;
  MALLOC_T base = WorkSpaceTop;

  if (fixed_allocation == MAP_FIXED)
    base = WorkSpaceTop;
  else
    base = 0L;
  LOCAL_PrologMode = ExtendStackMode;
  a = mmap_extension(s, base, fixed_allocation);
  LOCAL_PrologMode = OldPrologMode;
  if (a == (MALLOC_T)-1) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
#if HAVE_STRERROR
    snprintf5(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "could not allocate %d bytes (%s)", (int)s, strerror(errno));
#else
    snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "could not allocate %d bytes", (int)s);
#endif
    return FALSE;
  }
  if (fixed_allocation) {
    if (a != WorkSpaceTop) {
      munmap((void *)a, (size_t)s);
      LOCAL_ErrorMessage = LOCAL_ErrorSay;
      snprintf5(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
                "mmap could not grow memory at %p, got %p", WorkSpaceTop, a);
      LOCAL_PrologMode = OldPrologMode;
      return FALSE;
    }
  } else if (a < WorkSpaceTop) {
    /* try again */
    int res = ExtendWorkSpace(s, fixed_allocation);
    /* release memory back to system */
    munmap(a, s);
    return res;
  }
  WorkSpaceTop = (char *)a + s;
  LOCAL_PrologMode = OldPrologMode;
  return TRUE;
#endif /* YAPOR */
}

int Yap_FreeWorkSpace(void) { return 1; }

#elif USE_SYSTEM_SHM

#if HAVE_SYS_SHM_H
#include <sys/shm.h>
#endif

#ifndef MMAP_ADDR
#define MMAP_ADDR 0x0L
#endif

static MALLOC_T WorkSpaceTop;

static MALLOC_T InitWorkSpace(Int s) {
  MALLOC_T ptr;
  int shm_id;

  /* mapping heap area */
  if ((shm_id = shmget(IPC_PRIVATE, (size_t)s, SHM_R | SHM_W)) == -1) {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "could not shmget %d bytes", s);
    return (NULL);
  }
  if ((ptr = (MALLOC_T)shmat(shm_id, (void *)MMAP_ADDR, 0)) == (MALLOC_T)-1) {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "could not shmat at %p", MMAP_ADDR);
    return (NULL);
  }
  if (shmctl(shm_id, IPC_RMID, 0) != 0) {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "could not remove shm segment",
              shm_id);
    return (NULL);
  }
  WorkSpaceTop = (char *)ptr + s;
  return (ptr);
}

static int ExtendWorkSpace(Int s) {
  MALLOC_T ptr;
  int shm_id;
  prolog_exec_mode OldPrologMode = LOCAL_PrologMode;

  LOCAL_PrologMode = ExtendStackMode;
  /* mapping heap area */
  if ((shm_id = shmget(IPC_PRIVATE, (size_t)s, SHM_R | SHM_W)) == -1) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
    snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "could not shmget %d bytes", s);
    LOCAL_PrologMode = OldPrologMode;
    return (FALSE);
  }
  if ((ptr = (MALLOC_T)shmat(shm_id, WorkSpaceTop, 0)) == (MALLOC_T)-1) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
    snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE, "could not shmat at %p",
              MMAP_ADDR);
    LOCAL_PrologMode = OldPrologMode;
    return (FALSE);
  }
  if (shmctl(shm_id, IPC_RMID, 0) != 0) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
    snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "could not remove shm segment", shm_id);
    LOCAL_PrologMode = OldPrologMode;
    return (FALSE);
  }
  WorkSpaceTop = (char *)ptr + s;
  LOCAL_PrologMode = OldPrologMode;
  return (TRUE);
}

int Yap_FreeWorkSpace(void) { return TRUE; }

#elif USE_SBRK

/***********************************************************************\
* Worspace allocation based on 'sbrk'					*
*   We have to provide a replacement for the 'malloc' functions.        *
*   The situation is further complicated by the need to provide         *
* temporary 'malloc' space when restoring a previously saved state.	*
\***********************************************************************/

#ifdef _AIX
char *sbrk(int);

#endif

int in_limbo; /* non-zero when restoring a saved state */

#ifndef LIMBO_SIZE
#define LIMBO_SIZE 32 * K
#endif

static char limbo_space[LIMBO_SIZE]; /* temporary malloc space */
static char *limbo_p = limbo_space, *limbo_pp = 0;

static MALLOC_T InitWorkSpace(Int s) {
  MALLOC_T ptr = (MALLOC_T)sbrk(s);

  if (ptr == ((MALLOC_T)-1)) {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "could not allocate %d bytes", s);
    return (NULL);
  }
  return (ptr);
}

static int ExtendWorkSpace(Int s) {
  MALLOC_T ptr = (MALLOC_T)sbrk(s);
  prolog_exec_mode OldPrologMode = LOCAL_PrologMode;

  LOCAL_PrologMode = ExtendStackMode;
  if (ptr == ((MALLOC_T)-1)) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
    snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "could not expand stacks over %d bytes", s);
    LOCAL_PrologMode = OldPrologMode;
    return (FALSE);
  }
  LOCAL_PrologMode = OldPrologMode;
  return TRUE;
}

int Yap_FreeWorkSpace(void) { return TRUE; }

MALLOC_T
malloc(size_t size) {
  if (in_limbo) {
    limbo_pp = limbo_p;
    limbo_p += (size + 7) & 0xffff8;
    if (limbo_p >= &limbo_space[LIMBO_SIZE])
      return (NULL);
    return (limbo_pp);
  } else {
    CODEADDR codep = (CODEADDR)AllocCodeSpace(size + 2 * sizeof(void *));
    if (codep == NIL)
      return (NIL);
    else
      return (codep + 2 * sizeof(void *));
  }
}

void free(MALLOC_T ptr) {
  BlockHeader *b = (BlockHeader *)(((char *)ptr) - 2 * sizeof(void *) -
                                   sizeof(YAP_SEG_SIZE));

  if (ptr == limbo_pp) {
    limbo_p = limbo_pp;
    return;
  }
  if (!ptr)
    return;
  if ((char *)ptr < Yap_HeapBase || (char *)ptr > HeapTop)
    return;
  if (!(b->b_size & InUseFlag))
    return;
  FreeCodeSpace((char *)ptr - 2 * sizeof(void *));
}

MALLOC_T
XX realloc(MALLOC_T ptr, size_t size) {
  MALLOC_T new = malloc(size);

  if (ptr)
    memcpy(new, ptr, size);
  free(ptr);
  return (new);
}

MALLOC_T
calloc(size_t n, size_t e) {
  unsigned k = n * e;
  MALLOC_T p = malloc(k);

  memset(p, 0, k);
  return (p);
}

#ifdef M_MXFAST
int mallopt(cmd, value) { return (value); }

static struct mallinfo xmall;

struct mallinfo mallinfo(void) {
  return (xmall);
}
#endif

#else

/* use malloc to initiliase memory */

/* user should ask for a lot of memory first */

#ifdef __linux
#define MAX_SPACE 420 * 1024 * 1024
#else
#define MAX_SPACE 128 * 1024 * 1024
#endif

static int total_space;

static MALLOC_T InitWorkSpace(Int s) {
  MALLOC_T ptr;

#ifdef M_MMAP_MAX
  mallopt(M_MMAP_MAX, 0);
#endif
  ptr = (MALLOC_T)calloc(MAX_SPACE, 1);
  total_space = s;

  if (ptr == NULL) {
    Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "could not allocate %d bytes", s);
    return (NULL);
  }
  return (ptr);
}

static int ExtendWorkSpace(Int s) {
  MALLOC_T ptr;
  prolog_exec_mode OldPrologMode = LOCAL_PrologMode;

  LOCAL_PrologMode = ExtendStackMode;
  total_space += s;
  if (total_space < MAX_SPACE)
    return TRUE;
  ptr = (MALLOC_T)realloc((void *)Yap_HeapBase, total_space);
  if (ptr == NULL) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
    snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "could not allocate %d bytes", s);
    LOCAL_PrologMode = OldPrologMode;
    return FALSE;
  }
  if (ptr != (MALLOC_T)Yap_HeapBase) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
    snprintf4(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "could not expand contiguous stacks  %d bytes", s);
    LOCAL_PrologMode = OldPrologMode;
    return FALSE;
  }
#if MBIT
  if ((CELL)ptr & MBIT) {
    LOCAL_ErrorMessage = LOCAL_ErrorSay;
    snprintf5(LOCAL_ErrorMessage, MAX_ERROR_MSG_SIZE,
              "memory at %p conflicts with MBIT %lx", ptr, (unsigned long)MBIT);
    LOCAL_PrologMode = OldPrologMode;
    return FALSE;
  }
#endif
  LOCAL_PrologMode = OldPrologMode;
  return TRUE;
}

int Yap_FreeWorkSpace(void) { return TRUE; }
#endif

static void InitHeap(void *heap_addr) {
  /* allocate space */
  Yap_HeapBase = heap_addr;

  /* reserve space for specially allocated functors and atoms so that
     their values can be known statically */
  HeapTop = Yap_HeapBase + AdjustSize(sizeof(all_heap_codes));
  Yap_HoleSize = 0;
#if USE_DL_MALLOC
  Yap_initdlmalloc();
#else
  HeapMax = HeapUsed = HeapTop - Yap_HeapBase;
  /* notice that this forces odd addresses */
  *((YAP_SEG_SIZE *)HeapTop) = InUseFlag;
  HeapTop = HeapTop + sizeof(YAP_SEG_SIZE);
  *((YAP_SEG_SIZE *)HeapTop) = InUseFlag;
#endif

  FreeBlocks = NIL;
}

void Yap_InitHeap(void *heap_addr) { InitHeap(heap_addr); }

void Yap_InitMemory(UInt Trail, UInt Heap, UInt Stack) {
  UInt pm, sa, ta;
  void *addr;

#if defined(_WIN32) || defined(__CYGWIN__)
  Stack = ((Stack + (YAP_ALLOC_SIZE - 1)) / YAP_ALLOC_SIZE) * YAP_ALLOC_SIZE;
  Heap = ((Heap + (YAP_ALLOC_SIZE - 1)) / YAP_ALLOC_SIZE) * YAP_ALLOC_SIZE;
  Trail = ((Trail + (YAP_ALLOC_SIZE - 1)) / YAP_ALLOC_SIZE) * YAP_ALLOC_SIZE;
#endif
  pm = (Trail + Heap + Stack); /* memory to be
                                * requested         */
  sa = Stack;                  /* stack area size   */
  ta = Trail; /* trail area size   */

#if RANDOMIZE_START_ADDRESS
  srand(time(NULL));
  UInt x = (rand() % 100) * YAP_ALLOC_SIZE;
  pm += x;
#endif
  addr = InitWorkSpace(pm);
#if RANDOMIZE_START_ADDRESS
  addr = (char *)addr + x;
  pm -= x;
#endif

  InitHeap(addr);

  LOCAL_TrailTop = Yap_HeapBase + pm;
  LOCAL_LocalBase = LOCAL_TrailTop - ta;
  LOCAL_TrailBase = LOCAL_LocalBase + sizeof(CELL);

  LOCAL_GlobalBase = LOCAL_LocalBase - sa;
  HeapLim = LOCAL_GlobalBase; /* avoid confusions while
                                       * * restoring */
#if !USE_DL_MALLOC
  AuxTop = (ADDR)(AuxSp = (CELL *)LOCAL_GlobalBase);
#endif

#if DEBUG
#if SIZEOF_INT_P != SIZEOF_INT
  if (Yap_output_msg) {
    fprintf(stderr,
            "HeapBase = %p  GlobalBase = %p\n  LocalBase = %p  TrailTop = %p\n",
            Yap_HeapBase, LOCAL_GlobalBase, LOCAL_LocalBase, LOCAL_TrailTop);
#else
  if (Yap_output_msg) {
    fprintf(stderr,
            "HeapBase = %x  GlobalBase = %x\n  LocalBase = %x  TrailTop = %x\n",
            (UInt)Yap_HeapBase, (UInt)LOCAL_GlobalBase, (UInt)LOCAL_LocalBase,
            (UInt)LOCAL_TrailTop);
#endif

    fprintf(stderr, "Heap+Aux: " UInt_FORMAT "\tLocal+Global: " UInt_FORMAT
                    "\tTrail: " UInt_FORMAT "\n",
            pm - sa - ta, sa, ta);
  }
#endif /* DEBUG */
}

void Yap_InitExStacks(int wid, int Trail, int Stack) {
#if USE_DL_MALLOC
  REMOTE_ScratchPad(wid).ptr = NULL;
  REMOTE_ScratchPad(wid).sz = REMOTE_ScratchPad(wid).msz = SCRATCH_START_SIZE;
  AuxSp = NULL;
#endif
}

#if defined(_WIN32) || defined(__CYGWIN__)
#define WorkSpaceTop brk
#define MAP_FIXED 1
#endif

#if !USE_DL_MALLOC
/* dead code */
void Yap_add_memory_hole(ADDR Start, ADDR End) { Yap_HoleSize += Start - End; }
#endif

int Yap_ExtendWorkSpace(Int s) {
#if USE_SYSTEM_MMAP
  return ExtendWorkSpace(s, MAP_FIXED);
#elif defined(_WIN32)
  return ExtendWorkSpace(s, MAP_FIXED);
#else
  return ExtendWorkSpace(s);
#endif
}

size_t Yap_ExtendWorkSpaceThroughHole(size_t s) {
#if USE_SYSTEM_MMAP || defined(_WIN32) || defined(__CYGWIN__)
  MALLOC_T WorkSpaceTop0 = WorkSpaceTop;
#if SIZEOF_INT_P == 4
  while (WorkSpaceTop < (MALLOC_T)0xc0000000L) {
    /* progress 1 MB */
    WorkSpaceTop += 512 * 1024;
    if (ExtendWorkSpace(s, MAP_FIXED)) {
      Yap_add_memory_hole((ADDR)WorkSpaceTop0, (ADDR)WorkSpaceTop - s);
      LOCAL_ErrorMessage = NULL;
      return WorkSpaceTop - WorkSpaceTop0;
    }
#if defined(_WIN32)
    /* 487 happens when you step over someone else's memory */
    if (GetLastError() != 487) {
      WorkSpaceTop = WorkSpaceTop0;
      return 0;
    }
#endif
#elif SIZEOF_INT_P == 8
  {
    int n = 1024 * 1024;
    while (n--) {
      /* progress 1 MB */
      WorkSpaceTop += 512 * 1024;
      if (ExtendWorkSpace(s, MAP_FIXED)) {
        Yap_add_memory_hole((ADDR)WorkSpaceTop0, (ADDR)WorkSpaceTop - s);
        LOCAL_ErrorMessage = NULL;
        return WorkSpaceTop - WorkSpaceTop0;
      }
#if defined(_WIN32)
      /* 487 happens when you step over someone else's memory */
      if (GetLastError() != 487) {
        WorkSpaceTop = WorkSpaceTop0;
        return 0;
      }
#endif
    }
#endif
  }
  WorkSpaceTop = WorkSpaceTop0;
#endif
  return 0;
}

void Yap_AllocHole(UInt actual_request, UInt total_size) {
#if (USE_SYSTEM_MMAP || defined(_WIN32) || defined(__CYGWIN__)) &&             \
    !USE_DL_MALLOC
  /* where we were when the hole was created,
   also where is the hole store */
  ADDR WorkSpaceTop0 = WorkSpaceTop - total_size;
  BlockHeader *newb = (BlockHeader *)HeapTop;
  BlockHeader *endb = (BlockHeader *)(WorkSpaceTop0 - sizeof(YAP_SEG_SIZE));
  YAP_SEG_SIZE bsiz = (WorkSpaceTop0 - HeapTop) / sizeof(CELL) -
                      2 * sizeof(YAP_SEG_SIZE) / sizeof(CELL);

  /* push HeapTop to after hole */
  HeapTop = WorkSpaceTop - (actual_request - sizeof(YAP_SEG_SIZE));
  ((YAP_SEG_SIZE *)HeapTop)[0] = InUseFlag;
  /* now simulate a block */
  ((YAP_SEG_SIZE *)HeapTop)[-1] = endb->b_size =
      (HeapTop - WorkSpaceTop0) / sizeof(YAP_SEG_SIZE) | InUseFlag;
  newb->b_size = bsiz;
  AddToFreeList(newb);
#endif
}

#endif /* USE_SYSTEM_MALLOC */