Changeset 25059 in vbox for trunk/src/VBox/Runtime/common

Timestamp:

Nov 27, 2009 6:17:44 PM (15 years ago)

Author:

vboxsync

Message:

RTHeapOffset: Initial conversion of RTHeapSimple.

File:

• trunk/src/VBox/Runtime/common/alloc/heapoffset.cpp (copied) (copied from trunk/src/VBox/Runtime/common/alloc/heapsimple.cpp ) (40 diffs)

trunk/src/VBox/Runtime/common/alloc/heapoffset.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * IPRT - A Simple Heap.
+ * IPRT - An Offset Based Heap.
  */
 
 /*
- * Copyright (C) 2006-2007 Sun Microsystems, Inc.
+ * Copyright (C) 2006-2009 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -51 +51 @@
 *******************************************************************************/
 /** Pointer to the heap anchor block. */
-typedef struct RTHEAPSIMPLEINTERNAL *PRTHEAPSIMPLEINTERNAL;
+typedef struct RTHEAPOFFSETINTERNAL *PRTHEAPOFFSETINTERNAL;
 /** Pointer to a heap block. */
-typedef struct RTHEAPSIMPLEBLOCK *PRTHEAPSIMPLEBLOCK;
+typedef struct RTHEAPOFFSETBLOCK *PRTHEAPOFFSETBLOCK;
 /** Pointer to a free heap block. */
-typedef struct RTHEAPSIMPLEFREE *PRTHEAPSIMPLEFREE;
-
-/**
- * Structure describing a simple heap block.
+typedef struct RTHEAPOFFSETFREE *PRTHEAPOFFSETFREE;
+
+/**
+ * Structure describing a block in an offset based heap.
+ *
  * If this block is allocated, it is followed by the user data.
- * If this block is free, see RTHEAPSIMPLEFREE.
- */
-typedef struct RTHEAPSIMPLEBLOCK
+ * If this block is free, see RTHEAPOFFSETFREE.
+ */
+typedef struct RTHEAPOFFSETBLOCK
 {
     /** The next block in the global block list. */
-    PRTHEAPSIMPLEBLOCK      pNext;
+    uint32_t /*PRTHEAPOFFSETBLOCK*/     offNext;
     /** The previous block in the global block list. */
-    PRTHEAPSIMPLEBLOCK      pPrev;
-    /** Pointer to the heap anchor block. */
-    PRTHEAPSIMPLEINTERNAL   pHeap;
+    uint32_t /*PRTHEAPOFFSETBLOCK*/     offPrev;
+    /** Offset into the heap of this block. Used to locate the anchor block. */
+    uint32_t /*PRTHEAPOFFSETINTERNAL*/  offSelf;
     /** Flags + magic. */
-    uintptr_t               fFlags;
-} RTHEAPSIMPLEBLOCK;
-AssertCompileSizeAlignment(RTHEAPSIMPLEBLOCK, 16);
+    uint32_t                            fFlags;
+} RTHEAPOFFSETBLOCK;
+AssertCompileSizeAlignment(RTHEAPOFFSETBLOCK, 16);
 
 /** The block is free if this flag is set. When cleared it's allocated. */
-#define RTHEAPSIMPLEBLOCK_FLAGS_FREE        ((uintptr_t)RT_BIT(0))
+#define RTHEAPOFFSETBLOCK_FLAGS_FREE        (RT_BIT_32(0))
 /** The magic value. */
-#define RTHEAPSIMPLEBLOCK_FLAGS_MAGIC       ((uintptr_t)0xabcdef00)
-/** The mask that needs to be applied to RTHEAPSIMPLEBLOCK::fFlags to obtain the magic value. */
-#define RTHEAPSIMPLEBLOCK_FLAGS_MAGIC_MASK  (~(uintptr_t)RT_BIT(0))
+#define RTHEAPOFFSETBLOCK_FLAGS_MAGIC       (UINT32_C(0xabcdef00))
+/** The mask that needs to be applied to RTHEAPOFFSETBLOCK::fFlags to obtain the magic value. */
+#define RTHEAPOFFSETBLOCK_FLAGS_MAGIC_MASK  (~RT_BIT_32(0))
 
 /**
  * Checks if the specified block is valid or not.
  * @returns boolean answer.
- * @param   pBlock      Pointer to a RTHEAPSIMPLEBLOCK structure.
- */
-#define RTHEAPSIMPLEBLOCK_IS_VALID(pBlock)  \
-    ( ((pBlock)->fFlags & RTHEAPSIMPLEBLOCK_FLAGS_MAGIC_MASK) == RTHEAPSIMPLEBLOCK_FLAGS_MAGIC )
+ * @param   pBlock      Pointer to a RTHEAPOFFSETBLOCK structure.
+ */
+#define RTHEAPOFFSETBLOCK_IS_VALID(pBlock)  \
+    ( ((pBlock)->fFlags & RTHEAPOFFSETBLOCK_FLAGS_MAGIC_MASK) == RTHEAPOFFSETBLOCK_FLAGS_MAGIC )
 
 /**
  * Checks if the specified block is valid and in use.
  * @returns boolean answer.
- * @param   pBlock      Pointer to a RTHEAPSIMPLEBLOCK structure.
- */
-#define RTHEAPSIMPLEBLOCK_IS_VALID_USED(pBlock)  \
-    ( ((pBlock)->fFlags & (RTHEAPSIMPLEBLOCK_FLAGS_MAGIC_MASK | RTHEAPSIMPLEBLOCK_FLAGS_FREE)) \
-       == RTHEAPSIMPLEBLOCK_FLAGS_MAGIC )
+ * @param   pBlock      Pointer to a RTHEAPOFFSETBLOCK structure.
+ */
+#define RTHEAPOFFSETBLOCK_IS_VALID_USED(pBlock)  \
+    ( ((pBlock)->fFlags & (RTHEAPOFFSETBLOCK_FLAGS_MAGIC_MASK | RTHEAPOFFSETBLOCK_FLAGS_FREE)) \
+       == RTHEAPOFFSETBLOCK_FLAGS_MAGIC )
 
 /**
  * Checks if the specified block is valid and free.
  * @returns boolean answer.
- * @param   pBlock      Pointer to a RTHEAPSIMPLEBLOCK structure.
- */
-#define RTHEAPSIMPLEBLOCK_IS_VALID_FREE(pBlock)  \
-    ( ((pBlock)->fFlags & (RTHEAPSIMPLEBLOCK_FLAGS_MAGIC_MASK | RTHEAPSIMPLEBLOCK_FLAGS_FREE)) \
-       == (RTHEAPSIMPLEBLOCK_FLAGS_MAGIC | RTHEAPSIMPLEBLOCK_FLAGS_FREE) )
+ * @param   pBlock      Pointer to a RTHEAPOFFSETBLOCK structure.
+ */
+#define RTHEAPOFFSETBLOCK_IS_VALID_FREE(pBlock)  \
+    ( ((pBlock)->fFlags & (RTHEAPOFFSETBLOCK_FLAGS_MAGIC_MASK | RTHEAPOFFSETBLOCK_FLAGS_FREE)) \
+       == (RTHEAPOFFSETBLOCK_FLAGS_MAGIC | RTHEAPOFFSETBLOCK_FLAGS_FREE) )
 
 /**
  * Checks if the specified block is free or not.
  * @returns boolean answer.
- * @param   pBlock      Pointer to a valid RTHEAPSIMPLEBLOCK structure.
- */
-#define RTHEAPSIMPLEBLOCK_IS_FREE(pBlock)   (!!((pBlock)->fFlags & RTHEAPSIMPLEBLOCK_FLAGS_FREE))
+ * @param   pBlock      Pointer to a valid RTHEAPOFFSETBLOCK structure.
+ */
+#define RTHEAPOFFSETBLOCK_IS_FREE(pBlock)   (!!((pBlock)->fFlags & RTHEAPOFFSETBLOCK_FLAGS_FREE))
 
 /**
  * A free heap block.
- * This is an extended version of RTHEAPSIMPLEBLOCK that takes the unused
+ * This is an extended version of RTHEAPOFFSETBLOCK that takes the unused
  * user data to store free list pointers and a cached size value.
  */
-typedef struct RTHEAPSIMPLEFREE
+typedef struct RTHEAPOFFSETFREE
 {
     /** Core stuff. */
-    RTHEAPSIMPLEBLOCK       Core;
+    RTHEAPOFFSETBLOCK               Core;
     /** Pointer to the next free block. */
-    PRTHEAPSIMPLEFREE       pNext;
+    uint32_t /*PRTHEAPOFFSETFREE*/  offNext;
     /** Pointer to the previous free block. */
-    PRTHEAPSIMPLEFREE       pPrev;
-    /** The size of the block (excluding the RTHEAPSIMPLEBLOCK part). */
-    size_t                  cb;
-    /** An alignment filler to make it a multiple of (sizeof(void *) * 2). */
-    size_t                  Alignment;
-} RTHEAPSIMPLEFREE;
+    uint32_t /*PRTHEAPOFFSETFREE*/  offPrev;
+    /** The size of the block (excluding the RTHEAPOFFSETBLOCK part). */
+    uint32_t                        cb;
+    /** An alignment filler to make it a multiple of 16 bytes. */
+    uint32_t                        Alignment;
+} RTHEAPOFFSETFREE;
+AssertCompileSizeAlignment(RTHEAPOFFSETFREE, 16);
 
 
 /**
  * The heap anchor block.
- * This structure is placed at the head of the memory block specified to RTHeapSimpleInit(),
- * which means that the first RTHEAPSIMPLEBLOCK appears immediately after this structure.
- */
-typedef struct RTHEAPSIMPLEINTERNAL
-{
-    /** The typical magic (RTHEAPSIMPLE_MAGIC). */
-    size_t                  uMagic;
+ * This structure is placed at the head of the memory block specified to RTHeapOffsetInit(),
+ * which means that the first RTHEAPOFFSETBLOCK appears immediately after this structure.
+ */
+typedef struct RTHEAPOFFSETINTERNAL
+{
+    /** The typical magic (RTHEAPOFFSET_MAGIC). */
+    uint32_t                        u32Magic;
     /** The heap size. (This structure is included!) */
-    size_t                  cbHeap;
-    /** Pointer to the end of the heap. */
-    void                   *pvEnd;
+    uint32_t                        cbHeap;
     /** The amount of free memory in the heap. */
-    size_t                  cbFree;
+    uint32_t                        cbFree;
     /** Free head pointer. */
-    PRTHEAPSIMPLEFREE       pFreeHead;
+    uint32_t /*PRTHEAPOFFSETFREE*/  offFreeHead;
     /** Free tail pointer. */
-    PRTHEAPSIMPLEFREE       pFreeTail;
+    uint32_t /*PRTHEAPOFFSETFREE*/  offFreeTail;
     /** Make the size of this structure is a multiple of 32. */
-    size_t                  auAlignment[2];
-} RTHEAPSIMPLEINTERNAL;
-AssertCompileSizeAlignment(RTHEAPSIMPLEINTERNAL, 32);
+    uint32_t                        au32Alignment[3];
+} RTHEAPOFFSETINTERNAL;
+AssertCompileSizeAlignment(RTHEAPOFFSETINTERNAL, 32);
 
 
 /** The minimum allocation size. */
-#define RTHEAPSIMPLE_MIN_BLOCK  (sizeof(RTHEAPSIMPLEBLOCK))
-AssertCompile(RTHEAPSIMPLE_MIN_BLOCK >= sizeof(RTHEAPSIMPLEBLOCK));
-AssertCompile(RTHEAPSIMPLE_MIN_BLOCK >= sizeof(RTHEAPSIMPLEFREE) - sizeof(RTHEAPSIMPLEBLOCK));
+#define RTHEAPOFFSET_MIN_BLOCK  (sizeof(RTHEAPOFFSETBLOCK))
+AssertCompile(RTHEAPOFFSET_MIN_BLOCK >= sizeof(RTHEAPOFFSETBLOCK));
+AssertCompile(RTHEAPOFFSET_MIN_BLOCK >= sizeof(RTHEAPOFFSETFREE) - sizeof(RTHEAPOFFSETBLOCK));
 
 /** The minimum and default alignment.  */
-#define RTHEAPSIMPLE_ALIGNMENT  (sizeof(RTHEAPSIMPLEBLOCK))
+#define RTHEAPOFFSET_ALIGNMENT  (sizeof(RTHEAPOFFSETBLOCK))
 
 
@@ -173 +173 @@
 *******************************************************************************/
 #ifdef RT_STRICT
-# define RTHEAPSIMPLE_STRICT 1
-#endif
-
-#define ASSERT_L(a, b)    AssertMsg((uintptr_t)(a) <  (uintptr_t)(b), ("a=%p b=%p\n", (uintptr_t)(a), (uintptr_t)(b)))
-#define ASSERT_LE(a, b)   AssertMsg((uintptr_t)(a) <= (uintptr_t)(b), ("a=%p b=%p\n", (uintptr_t)(a), (uintptr_t)(b)))
-#define ASSERT_G(a, b)    AssertMsg((uintptr_t)(a) >  (uintptr_t)(b), ("a=%p b=%p\n", (uintptr_t)(a), (uintptr_t)(b)))
-#define ASSERT_GE(a, b)   AssertMsg((uintptr_t)(a) >= (uintptr_t)(b), ("a=%p b=%p\n", (uintptr_t)(a), (uintptr_t)(b)))
-#define ASSERT_ALIGN(a)   AssertMsg(!((uintptr_t)(a) & (RTHEAPSIMPLE_ALIGNMENT - 1)), ("a=%p\n", (uintptr_t)(a)))
+# define RTHEAPOFFSET_STRICT 1
+#endif
+
+/**
+ * Converts RTHEAPOFFSETBLOCK::offSelf into a heap anchor block pointer.
+ *
+ * @returns Pointer of given type.
+ * @param   pBlock          The block to find the heap anchor block for.
+ */
+#define RTHEAPOFF_GET_ANCHOR(pBlock)    ( (PRTHEAPOFFSETINTERNAL)((uint8_t *)(pBlock) - (pBlock)->offSelf ) )
+
+
+/**
+ * Converts an offset to a pointer.
+ *
+ * All offsets are relative to the heap to make life simple.
+ *
+ * @returns Pointer of given type.
+ * @param   pHeapInt        Pointer to the heap anchor block.
+ * @param   off             The offset to convert.
+ * @param   type            The desired type.
+ */
+#ifdef RTHEAPOFFSET_STRICT
+# define RTHEAPOFF_TO_PTR(pHeapInt, off, type)   ( (type)rtHeapOffCheckedOffToPtr(pHeapInt, off) )
+#else
+# define RTHEAPOFF_TO_PTR(pHeapInt, off, type)   ( (type)((off) ? (uint8_t *)(pHeapInt) + (off) : NULL) )
+#endif
+
+/**
+ * Converts a pointer to an offset.
+ *
+ * All offsets are relative to the heap to make life simple.
+ *
+ * @returns Offset into the heap.
+ * @param   pHeapInt        Pointer to the heap anchor block.
+ * @param   ptr             The pointer to convert.
+ */
+#ifdef RTHEAPOFFSET_STRICT
+# define RTHEAPOFF_TO_OFF(pHeapInt, ptr)    rtHeapOffCheckedPtrToOff(pHeapInt, ptr)
+#else
+# define RTHEAPOFF_TO_OFF(pHeapInt, ptr)    ( (uint32_t)((ptr) ? (uintptr_t)(ptr) - (uintptr_t)(pHeapInt) : UINT32_C(0)) )
+#endif
+
+#define ASSERT_L(a, b)    AssertMsg((a) <  (b), ("a=%08x b=%08x\n", (a), (b)))
+#define ASSERT_LE(a, b)   AssertMsg((a) <= (b), ("a=%08x b=%08x\n", (a), (b)))
+#define ASSERT_G(a, b)    AssertMsg((a) >  (b), ("a=%08x b=%08x\n", (a), (b)))
+#define ASSERT_GE(a, b)   AssertMsg((a) >= (b), ("a=%08x b=%08x\n", (a), (b)))
+#define ASSERT_ALIGN(a)   AssertMsg(!((uintptr_t)(a) & (RTHEAPOFFSET_ALIGNMENT - 1)), ("a=%p\n", (uintptr_t)(a)))
 
 #define ASSERT_PREV(pHeapInt, pBlock)  \
-    do { ASSERT_ALIGN((pBlock)->pPrev); \
-         if ((pBlock)->pPrev) \
+    do { ASSERT_ALIGN((pBlock)->offPrev); \
+         if ((pBlock)->offPrev) \
          { \
-             ASSERT_L((pBlock)->pPrev, (pBlock)); \
-             ASSERT_GE((pBlock)->pPrev, (pHeapInt) + 1); \
+             ASSERT_L((pBlock)->offPrev, RTHEAPOFF_TO_OFF(pHeapInt, pBlock)); \
+             ASSERT_GE((pBlock)->offPrev, sizeof(RTHEAPOFFSETINTERNAL)); \
          } \
          else \
-             Assert((pBlock) == (PRTHEAPSIMPLEBLOCK)((pHeapInt) + 1)); \
+             Assert((pBlock) == (PRTHEAPOFFSETBLOCK)((pHeapInt) + 1)); \
     } while (0)
 
 #define ASSERT_NEXT(pHeap, pBlock) \
-    do { ASSERT_ALIGN((pBlock)->pNext); \
-         if ((pBlock)->pNext) \
+    do { ASSERT_ALIGN((pBlock)->offNext); \
+         if ((pBlock)->offNext) \
          { \
-             ASSERT_L((pBlock)->pNext, (pHeapInt)->pvEnd); \
-             ASSERT_G((pBlock)->pNext, (pBlock)); \
+             ASSERT_L((pBlock)->offNext, (pHeapInt)->cbHeap); \
+             ASSERT_G((pBlock)->offNext, RTHEAPOFF_TO_OFF(pHeapInt, pBlock)); \
          } \
     } while (0)
 
 #define ASSERT_BLOCK(pHeapInt, pBlock) \
-    do { AssertMsg(RTHEAPSIMPLEBLOCK_IS_VALID(pBlock), ("%#x\n", (pBlock)->fFlags)); \
-         AssertMsg((pBlock)->pHeap == (pHeapInt), ("%p != %p\n", (pBlock)->pHeap, (pHeapInt))); \
-         ASSERT_GE((pBlock), (pHeapInt) + 1); \
-         ASSERT_L((pBlock), (pHeapInt)->pvEnd); \
+    do { AssertMsg(RTHEAPOFFSETBLOCK_IS_VALID(pBlock), ("%#x\n", (pBlock)->fFlags)); \
+         AssertMsg(RTHEAPOFF_GET_ANCHOR(pBlock) == (pHeapInt), ("%p != %p\n", RTHEAPOFF_GET_ANCHOR(pBlock), (pHeapInt))); \
+         ASSERT_GE(RTHEAPOFF_TO_OFF(pHeapInt, pBlock), sizeof(RTHEAPOFFSETINTERNAL)); \
+         ASSERT_L( RTHEAPOFF_TO_OFF(pHeapInt, pBlock), (pHeapInt)->cbHeap); \
          ASSERT_NEXT(pHeapInt, pBlock); \
          ASSERT_PREV(pHeapInt, pBlock); \
@@ -212 +252 @@
 
 #define ASSERT_BLOCK_USED(pHeapInt, pBlock) \
-    do { AssertMsg(RTHEAPSIMPLEBLOCK_IS_VALID_USED((pBlock)), ("%#x\n", (pBlock)->fFlags)); \
-         AssertMsg((pBlock)->pHeap == (pHeapInt), ("%p != %p\n", (pBlock)->pHeap, (pHeapInt))); \
-         ASSERT_GE((pBlock), (pHeapInt) + 1); \
-         ASSERT_L((pBlock), (pHeapInt)->pvEnd); \
+    do { AssertMsg(RTHEAPOFFSETBLOCK_IS_VALID_USED((pBlock)), ("%#x\n", (pBlock)->fFlags)); \
+         AssertMsg(RTHEAPOFF_GET_ANCHOR(pBlock) == (pHeapInt), ("%p != %p\n", RTHEAPOFF_GET_ANCHOR(pBlock), (pHeapInt))); \
+         ASSERT_GE(RTHEAPOFF_TO_OFF(pHeapInt, pBlock), sizeof(RTHEAPOFFSETINTERNAL)); \
+         ASSERT_L( RTHEAPOFF_TO_OFF(pHeapInt, pBlock), (pHeapInt)->cbHeap); \
          ASSERT_NEXT(pHeapInt, pBlock); \
          ASSERT_PREV(pHeapInt, pBlock); \
@@ -221 +261 @@
 
 #define ASSERT_FREE_PREV(pHeapInt, pBlock) \
-    do { ASSERT_ALIGN((pBlock)->pPrev); \
-         if ((pBlock)->pPrev) \
+    do { ASSERT_ALIGN((pBlock)->offPrev); \
+         if ((pBlock)->offPrev) \
          { \
-             ASSERT_GE((pBlock)->pPrev, (pHeapInt)->pFreeHead); \
-             ASSERT_L((pBlock)->pPrev, (pBlock)); \
-             ASSERT_LE((pBlock)->pPrev, (pBlock)->Core.pPrev); \
+             ASSERT_GE((pBlock)->offPrev, (pHeapInt)->offFreeHead); \
+             ASSERT_L((pBlock)->offPrev, RTHEAPOFF_TO_OFF(pHeapInt, pBlock)); \
+             ASSERT_LE((pBlock)->offPrev, (pBlock)->Core.offPrev); \
          } \
          else \
-             Assert((pBlock) == (pHeapInt)->pFreeHead); \
+             Assert((pBlock) == RTHEAPOFF_TO_PTR(pHeapInt, (pHeapInt)->offFreeHead, PRTHEAPOFFSETFREE) ); \
     } while (0)
 
 #define ASSERT_FREE_NEXT(pHeapInt, pBlock) \
-    do { ASSERT_ALIGN((pBlock)->pNext); \
-         if ((pBlock)->pNext) \
+    do { ASSERT_ALIGN((pBlock)->offNext); \
+         if ((pBlock)->offNext) \
          { \
-             ASSERT_LE((pBlock)->pNext, (pHeapInt)->pFreeTail); \
-             ASSERT_G((pBlock)->pNext, (pBlock)); \
-             ASSERT_GE((pBlock)->pNext, (pBlock)->Core.pNext); \
+             ASSERT_LE((pBlock)->offNext, (pHeapInt)->offFreeTail); \
+             ASSERT_G((pBlock)->offNext, RTHEAPOFF_TO_OFF(pHeapInt, pBlock)); \
+             ASSERT_GE((pBlock)->offNext, (pBlock)->Core.offNext); \
          } \
          else \
-             Assert((pBlock) == (pHeapInt)->pFreeTail); \
+             Assert((pBlock) == RTHEAPOFF_TO_PTR(pHeapInt, (pHeapInt)->offFreeTail, PRTHEAPOFFSETFREE)); \
     } while (0)
 
-#ifdef RTHEAPSIMPLE_STRICT
+#ifdef RTHEAPOFFSET_STRICT
 # define ASSERT_FREE_CB(pHeapInt, pBlock) \
-    do { size_t cbCalc = ((pBlock)->Core.pNext ? (uintptr_t)(pBlock)->Core.pNext : (uintptr_t)(pHeapInt)->pvEnd) \
-                       - (uintptr_t)(pBlock) - sizeof(RTHEAPSIMPLEBLOCK); \
+    do { size_t cbCalc = ((pBlock)->Core.offNext ? (pBlock)->Core.offNext : (pHeapInt)->cbHeap) \
+                       - RTHEAPOFF_TO_OFF((pHeapInt), (pBlock)) - sizeof(RTHEAPOFFSETBLOCK); \
          AssertMsg((pBlock)->cb == cbCalc, ("cb=%#zx cbCalc=%#zx\n", (pBlock)->cb, cbCalc)); \
     } while (0)
@@ -257 +297 @@
 #define ASSERT_BLOCK_FREE(pHeapInt, pBlock) \
     do { ASSERT_BLOCK(pHeapInt, &(pBlock)->Core); \
-         Assert(RTHEAPSIMPLEBLOCK_IS_VALID_FREE(&(pBlock)->Core)); \
-         ASSERT_GE((pBlock), (pHeapInt)->pFreeHead); \
-         ASSERT_LE((pBlock), (pHeapInt)->pFreeTail); \
+         Assert(RTHEAPOFFSETBLOCK_IS_VALID_FREE(&(pBlock)->Core)); \
+         ASSERT_GE(RTHEAPOFF_TO_OFF(pHeapInt, pBlock), (pHeapInt)->offFreeHead); \
+         ASSERT_LE(RTHEAPOFF_TO_OFF(pHeapInt, pBlock), (pHeapInt)->offFreeTail); \
          ASSERT_FREE_NEXT(pHeapInt, pBlock); \
          ASSERT_FREE_PREV(pHeapInt, pBlock); \
@@ -268 +308 @@
 #define ASSERT_ANCHOR(pHeapInt) \
     do { AssertPtr(pHeapInt);\
-         Assert((pHeapInt)->uMagic == RTHEAPSIMPLE_MAGIC); \
+         Assert((pHeapInt)->u32Magic == RTHEAPOFFSET_MAGIC); \
     } while (0)
 
@@ -275 +315 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-#ifdef RTHEAPSIMPLE_STRICT
-static void rtHeapSimpleAssertAll(PRTHEAPSIMPLEINTERNAL pHeapInt);
-#endif
-static PRTHEAPSIMPLEBLOCK rtHeapSimpleAllocBlock(PRTHEAPSIMPLEINTERNAL pHeapInt, size_t cb, size_t uAlignment);
-static void rtHeapSimpleFreeBlock(PRTHEAPSIMPLEINTERNAL pHeapInt, PRTHEAPSIMPLEBLOCK pBlock);
-
-
-RTDECL(int) RTHeapSimpleInit(PRTHEAPSIMPLE phHeap, void *pvMemory, size_t cbMemory)
-{
-    PRTHEAPSIMPLEINTERNAL pHeapInt;
-    PRTHEAPSIMPLEFREE pFree;
+#ifdef RTHEAPOFFSET_STRICT
+static void rtHeapOffsetAssertAll(PRTHEAPOFFSETINTERNAL pHeapInt);
+#endif
+static PRTHEAPOFFSETBLOCK rtHeapOffsetAllocBlock(PRTHEAPOFFSETINTERNAL pHeapInt, size_t cb, size_t uAlignment);
+static void rtHeapOffsetFreeBlock(PRTHEAPOFFSETINTERNAL pHeapInt, PRTHEAPOFFSETBLOCK pBlock);
+
+#ifdef RTHEAPOFFSET_STRICT
+
+/** Checked version of RTHEAPOFF_TO_PTR. */
+DECLINLINE(void *) rtHeapOffCheckedOffToPtr(PRTHEAPOFFSETINTERNAL pHeapInt, uint32_t off)
+{
+    if (!off)
+        return NULL;
+    AssertMsg(off < pHeapInt->cbHeap,   ("%#x %#x\n", off, pHeapInt->cbHeap));
+    AssertMsg(off >= sizeof(*pHeapInt), ("%#x %#x\n", off, sizeof(*pHeapInt)));
+    return (uint8_t *)pHeapInt + off;
+}
+
+/** Checked version of RTHEAPOFF_TO_OFF. */
+DECLINLINE(uint32_t) rtHeapOffCheckedPtrToOff(PRTHEAPOFFSETINTERNAL pHeapInt, void *pv)
+{
+    if (!pv)
+        return 0;
+    uintptr_t off = (uintptr_t)pv - (uintptr_t)pHeapInt;
+    AssertMsg(off < pHeapInt->cbHeap,   ("%#x %#x\n", off, pHeapInt->cbHeap));
+    AssertMsg(off >= sizeof(*pHeapInt), ("%#x %#x\n", off, sizeof(*pHeapInt)));
+    return (uint32_t)off;
+}
+
+#endif /* RTHEAPOFFSET_STRICT */
+
+
+
+RTDECL(int) RTHeapOffsetInit(PRTHEAPOFFSET phHeap, void *pvMemory, size_t cbMemory)
+{
+    PRTHEAPOFFSETINTERNAL pHeapInt;
+    PRTHEAPOFFSETFREE pFree;
     unsigned i;
 
@@ -299 +365 @@
      * enforce 32 byte alignment of it. Also align the heap size correctly.
      */
-    pHeapInt = (PRTHEAPSIMPLEINTERNAL)pvMemory;
+    pHeapInt = (PRTHEAPOFFSETINTERNAL)pvMemory;
     if ((uintptr_t)pvMemory & 31)
     {
         const uintptr_t off = 32 - ((uintptr_t)pvMemory & 31);
         cbMemory -= off;
-        pHeapInt = (PRTHEAPSIMPLEINTERNAL)((uintptr_t)pvMemory + off);
-    }
-    cbMemory &= ~(RTHEAPSIMPLE_ALIGNMENT - 1);
+        pHeapInt = (PRTHEAPOFFSETINTERNAL)((uintptr_t)pvMemory + off);
+    }
+    cbMemory &= ~(RTHEAPOFFSET_ALIGNMENT - 1);
 
 
     /* Init the heap anchor block. */
-    pHeapInt->uMagic = RTHEAPSIMPLE_MAGIC;
-    pHeapInt->pvEnd = (uint8_t *)pHeapInt + cbMemory;
+    pHeapInt->u32Magic = RTHEAPOFFSET_MAGIC;
     pHeapInt->cbHeap = cbMemory;
     pHeapInt->cbFree = cbMemory
-                     - sizeof(RTHEAPSIMPLEBLOCK)
-                     - sizeof(RTHEAPSIMPLEINTERNAL);
-    pHeapInt->pFreeTail = pHeapInt->pFreeHead = (PRTHEAPSIMPLEFREE)(pHeapInt + 1);
-    for (i = 0; i < RT_ELEMENTS(pHeapInt->auAlignment); i++)
-        pHeapInt->auAlignment[i] = ~(size_t)0;
+                     - sizeof(RTHEAPOFFSETBLOCK)
+                     - sizeof(RTHEAPOFFSETINTERNAL);
+    pHeapInt->offFreeTail = pHeapInt->offFreeHead = sizeof(*pHeapInt);
+    for (i = 0; i < RT_ELEMENTS(pHeapInt->au32Alignment); i++)
+        pHeapInt->au32Alignment[i] = UINT32_MAX;
 
     /* Init the single free block. */
-    pFree = pHeapInt->pFreeHead;
-    pFree->Core.pNext = NULL;
-    pFree->Core.pPrev = NULL;
-    pFree->Core.pHeap = pHeapInt;
-    pFree->Core.fFlags = RTHEAPSIMPLEBLOCK_FLAGS_MAGIC | RTHEAPSIMPLEBLOCK_FLAGS_FREE;
-    pFree->pNext = NULL;
-    pFree->pPrev = NULL;
+    pFree = RTHEAPOFF_TO_PTR(pHeapInt, pHeapInt->offFreeHead, PRTHEAPOFFSETFREE);
+    pFree->Core.offNext = 0;
+    pFree->Core.offPrev = 0;
+    pFree->Core.offSelf = pHeapInt->offFreeHead;
+    pFree->Core.fFlags = RTHEAPOFFSETBLOCK_FLAGS_MAGIC | RTHEAPOFFSETBLOCK_FLAGS_FREE;
+    pFree->offNext = 0;
+    pFree->offPrev = 0;
     pFree->cb = pHeapInt->cbFree;
 
     *phHeap = pHeapInt;
 
-#ifdef RTHEAPSIMPLE_STRICT
-    rtHeapSimpleAssertAll(pHeapInt);
+#ifdef RTHEAPOFFSET_STRICT
+    rtHeapOffsetAssertAll(pHeapInt);
 #endif
     return VINF_SUCCESS;
 }
-RT_EXPORT_SYMBOL(RTHeapSimpleInit);
-
-
-RTDECL(int) RTHeapSimpleRelocate(RTHEAPSIMPLE hHeap, uintptr_t offDelta)
-{
-    PRTHEAPSIMPLEINTERNAL   pHeapInt = hHeap;
-    PRTHEAPSIMPLEFREE       pCur;
-
-    /*
-     * Validate input.
-     */
-    AssertPtrReturn(pHeapInt, VERR_INVALID_HANDLE);
-    AssertReturn(pHeapInt->uMagic == RTHEAPSIMPLE_MAGIC, VERR_INVALID_HANDLE);
-    AssertMsgReturn((uintptr_t)pHeapInt - (uintptr_t)pHeapInt->pvEnd + pHeapInt->cbHeap == offDelta,
-                    ("offDelta=%p, expected=%p\n", offDelta, (uintptr_t)pHeapInt->pvEnd - pHeapInt->cbHeap - (uintptr_t)pHeapInt),
-                    VERR_INVALID_PARAMETER);
-
-    /*
-     * Relocate the heap anchor block.
-     */
-#define RELOCATE_IT(var, type, offDelta)    do { if (RT_UNLIKELY((var) != NULL)) { (var) = (type)((uintptr_t)(var) + offDelta); } } while (0)
-    RELOCATE_IT(pHeapInt->pvEnd,     void *,            offDelta);
-    RELOCATE_IT(pHeapInt->pFreeHead, PRTHEAPSIMPLEFREE, offDelta);
-    RELOCATE_IT(pHeapInt->pFreeTail, PRTHEAPSIMPLEFREE, offDelta);
-
-    /*
-     * Walk the heap blocks.
-     */
-    for (pCur = (PRTHEAPSIMPLEFREE)(pHeapInt + 1);
-         pCur && (uintptr_t)pCur < (uintptr_t)pHeapInt->pvEnd;
-         pCur = (PRTHEAPSIMPLEFREE)pCur->Core.pNext)
-    {
-        RELOCATE_IT(pCur->Core.pNext, PRTHEAPSIMPLEBLOCK,    offDelta);
-        RELOCATE_IT(pCur->Core.pPrev, PRTHEAPSIMPLEBLOCK,    offDelta);
-        RELOCATE_IT(pCur->Core.pHeap, PRTHEAPSIMPLEINTERNAL, offDelta);
-        if (RTHEAPSIMPLEBLOCK_IS_FREE(&pCur->Core))
-        {
-            RELOCATE_IT(pCur->pNext, PRTHEAPSIMPLEFREE, offDelta);
-            RELOCATE_IT(pCur->pPrev, PRTHEAPSIMPLEFREE, offDelta);
-        }
-    }
-#undef RELOCATE_IT
-
-#ifdef RTHEAPSIMPLE_STRICT
-    /*
-     * Give it a once over before we return.
-     */
-    rtHeapSimpleAssertAll(pHeapInt);
-#endif
-    return VINF_SUCCESS;
-}
-RT_EXPORT_SYMBOL(RTHeapSimpleRelocate);
-
-
-RTDECL(void *) RTHeapSimpleAlloc(RTHEAPSIMPLE hHeap, size_t cb, size_t cbAlignment)
-{
-    PRTHEAPSIMPLEINTERNAL pHeapInt = hHeap;
-    PRTHEAPSIMPLEBLOCK pBlock;
+RT_EXPORT_SYMBOL(RTHeapOffsetInit);
+
+
+RTDECL(void *) RTHeapOffsetAlloc(RTHEAPOFFSET hHeap, size_t cb, size_t cbAlignment)
+{
+    PRTHEAPOFFSETINTERNAL pHeapInt = hHeap;
+    PRTHEAPOFFSETBLOCK pBlock;
 
     /*
@@ -400 +414 @@
      */
     AssertPtrReturn(pHeapInt, NULL);
-    if (cb < RTHEAPSIMPLE_MIN_BLOCK)
-        cb = RTHEAPSIMPLE_MIN_BLOCK;
+    if (cb < RTHEAPOFFSET_MIN_BLOCK)
+        cb = RTHEAPOFFSET_MIN_BLOCK;
     else
-        cb = RT_ALIGN_Z(cb, RTHEAPSIMPLE_ALIGNMENT);
+        cb = RT_ALIGN_Z(cb, RTHEAPOFFSET_ALIGNMENT);
     if (!cbAlignment)
-        cbAlignment = RTHEAPSIMPLE_ALIGNMENT;
+        cbAlignment = RTHEAPOFFSET_ALIGNMENT;
     else
     {
         Assert(!(cbAlignment & (cbAlignment - 1)));
         Assert((cbAlignment & ~(cbAlignment - 1)) == cbAlignment);
-        if (cbAlignment < RTHEAPSIMPLE_ALIGNMENT)
-            cbAlignment = RTHEAPSIMPLE_ALIGNMENT;
+        if (cbAlignment < RTHEAPOFFSET_ALIGNMENT)
+            cbAlignment = RTHEAPOFFSET_ALIGNMENT;
     }
 
@@ -417 +431 @@
      * Do the allocation.
      */
-    pBlock = rtHeapSimpleAllocBlock(pHeapInt, cb, cbAlignment);
+    pBlock = rtHeapOffsetAllocBlock(pHeapInt, cb, cbAlignment);
     if (RT_LIKELY(pBlock))
     {
@@ -425 +439 @@
     return NULL;
 }
-RT_EXPORT_SYMBOL(RTHeapSimpleAlloc);
-
-
-RTDECL(void *) RTHeapSimpleAllocZ(RTHEAPSIMPLE hHeap, size_t cb, size_t cbAlignment)
-{
-    PRTHEAPSIMPLEINTERNAL pHeapInt = hHeap;
-    PRTHEAPSIMPLEBLOCK pBlock;
+RT_EXPORT_SYMBOL(RTHeapOffsetAlloc);
+
+
+RTDECL(void *) RTHeapOffsetAllocZ(RTHEAPOFFSET hHeap, size_t cb, size_t cbAlignment)
+{
+    PRTHEAPOFFSETINTERNAL pHeapInt = hHeap;
+    PRTHEAPOFFSETBLOCK pBlock;
 
     /*
@@ -437 +451 @@
      */
     AssertPtrReturn(pHeapInt, NULL);
-    if (cb < RTHEAPSIMPLE_MIN_BLOCK)
-        cb = RTHEAPSIMPLE_MIN_BLOCK;
+    if (cb < RTHEAPOFFSET_MIN_BLOCK)
+        cb = RTHEAPOFFSET_MIN_BLOCK;
     else
-        cb = RT_ALIGN_Z(cb, RTHEAPSIMPLE_ALIGNMENT);
+        cb = RT_ALIGN_Z(cb, RTHEAPOFFSET_ALIGNMENT);
     if (!cbAlignment)
-        cbAlignment = RTHEAPSIMPLE_ALIGNMENT;
+        cbAlignment = RTHEAPOFFSET_ALIGNMENT;
     else
     {
         Assert(!(cbAlignment & (cbAlignment - 1)));
         Assert((cbAlignment & ~(cbAlignment - 1)) == cbAlignment);
-        if (cbAlignment < RTHEAPSIMPLE_ALIGNMENT)
-            cbAlignment = RTHEAPSIMPLE_ALIGNMENT;
+        if (cbAlignment < RTHEAPOFFSET_ALIGNMENT)
+            cbAlignment = RTHEAPOFFSET_ALIGNMENT;
     }
 
@@ -454 +468 @@
      * Do the allocation.
      */
-    pBlock = rtHeapSimpleAllocBlock(pHeapInt, cb, cbAlignment);
+    pBlock = rtHeapOffsetAllocBlock(pHeapInt, cb, cbAlignment);
     if (RT_LIKELY(pBlock))
     {
@@ -463 +477 @@
     return NULL;
 }
-RT_EXPORT_SYMBOL(RTHeapSimpleAllocZ);
+RT_EXPORT_SYMBOL(RTHeapOffsetAllocZ);
 
 
@@ -478 +492 @@
  * @param   uAlignment  The alignment specifications for the allocated block.
  */
-static PRTHEAPSIMPLEBLOCK rtHeapSimpleAllocBlock(PRTHEAPSIMPLEINTERNAL pHeapInt, size_t cb, size_t uAlignment)
-{
-    PRTHEAPSIMPLEBLOCK  pRet = NULL;
-    PRTHEAPSIMPLEFREE   pFree;
-
-#ifdef RTHEAPSIMPLE_STRICT
-    rtHeapSimpleAssertAll(pHeapInt);
+static PRTHEAPOFFSETBLOCK rtHeapOffsetAllocBlock(PRTHEAPOFFSETINTERNAL pHeapInt, size_t cb, size_t uAlignment)
+{
+    PRTHEAPOFFSETBLOCK  pRet = NULL;
+    PRTHEAPOFFSETFREE   pFree;
+
+    AssertReturn((pHeapInt)->u32Magic == RTHEAPOFFSET_MAGIC, NULL);
+#ifdef RTHEAPOFFSET_STRICT
+    rtHeapOffsetAssertAll(pHeapInt);
 #endif
 
@@ -490 +505 @@
      * Search for a fitting block from the lower end of the heap.
      */
-    for (pFree = pHeapInt->pFreeHead;
+    for (pFree = RTHEAPOFF_TO_PTR(pHeapInt, pHeapInt->offFreeHead, PRTHEAPOFFSETFREE);
          pFree;
-         pFree = pFree->pNext)
+         pFree = RTHEAPOFF_TO_PTR(pHeapInt, pFree->offNext, PRTHEAPOFFSETFREE))
     {
         uintptr_t offAlign;
@@ -505 +520 @@
         if (offAlign)
         {
-            RTHEAPSIMPLEFREE Free;
-            PRTHEAPSIMPLEBLOCK pPrev;
+            RTHEAPOFFSETFREE Free;
+            PRTHEAPOFFSETBLOCK pPrev;
 
             offAlign = uAlignment - offAlign;
@@ -516 +531 @@
              */
             Free = *pFree;
-            pFree = (PRTHEAPSIMPLEFREE)((uintptr_t)pFree + offAlign);
+            pFree = (PRTHEAPOFFSETFREE)((uintptr_t)pFree + offAlign);
 
             /*
@@ -527 +542 @@
              * for that.)
              */
-            pPrev = Free.Core.pPrev;
+            pPrev = RTHEAPOFF_TO_PTR(pHeapInt, Free.Core.offPrev, PRTHEAPOFFSETBLOCK);
             if (pPrev)
             {
-                AssertMsg(!RTHEAPSIMPLEBLOCK_IS_FREE(pPrev), ("Impossible!\n"));
-                pPrev->pNext = &pFree->Core;
+                AssertMsg(!RTHEAPOFFSETBLOCK_IS_FREE(pPrev), ("Impossible!\n"));
+                pPrev->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
             }
             else
             {
-                pPrev = (PRTHEAPSIMPLEBLOCK)(pHeapInt + 1);
+                pPrev = (PRTHEAPOFFSETBLOCK)(pHeapInt + 1);
                 Assert(pPrev == &pFree->Core);
-                pPrev->pPrev = NULL;
-                pPrev->pNext = &pFree->Core;
-                pPrev->pHeap = pHeapInt;
-                pPrev->fFlags = RTHEAPSIMPLEBLOCK_FLAGS_MAGIC;
+                pPrev->offPrev = 0;
+                pPrev->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
+                pPrev->offSelf = RTHEAPOFF_TO_OFF(pHeapInt, pPrev);
+                pPrev->fFlags = RTHEAPOFFSETBLOCK_FLAGS_MAGIC;
             }
             pHeapInt->cbFree -= offAlign;
@@ -548 +563 @@
              */
             *pFree = Free;
+            pFree->Core.offSelf = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
 
             /* the core */
-            if (pFree->Core.pNext)
-                pFree->Core.pNext->pPrev = &pFree->Core;
-            pFree->Core.pPrev = pPrev;
+            if (pFree->Core.offNext)
+                RTHEAPOFF_TO_PTR(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = pFree->Core.offSelf;
+            pFree->Core.offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pPrev);
 
             /* the free part */
             pFree->cb -= offAlign;
-            if (pFree->pNext)
-                pFree->pNext->pPrev = pFree;
+            if (pFree->offNext)
+                RTHEAPOFF_TO_PTR(pHeapInt, pFree->offNext, PRTHEAPOFFSETFREE)->offPrev = pFree->Core.offSelf;
             else
-                pHeapInt->pFreeTail = pFree;
-            if (pFree->pPrev)
-                pFree->pPrev->pNext = pFree;
+                pHeapInt->offFreeTail = pFree->Core.offSelf;
+            if (pFree->offPrev)
+                RTHEAPOFF_TO_PTR(pHeapInt, pFree->offPrev, PRTHEAPOFFSETFREE)->offNext = pFree->Core.offSelf;
             else
-                pHeapInt->pFreeHead = pFree;
+                pHeapInt->offFreeHead = pFree->Core.offSelf;
             ASSERT_BLOCK_FREE(pHeapInt, pFree);
             ASSERT_BLOCK_USED(pHeapInt, pPrev);
@@ -571 +587 @@
          * Split off a new FREE block?
          */
-        if (pFree->cb >= cb + RT_ALIGN_Z(sizeof(RTHEAPSIMPLEFREE), RTHEAPSIMPLE_ALIGNMENT))
+        if (pFree->cb >= cb + RT_ALIGN_Z(sizeof(RTHEAPOFFSETFREE), RTHEAPOFFSET_ALIGNMENT))
         {
             /*
              * Move the FREE block up to make room for the new USED block.
              */
-            PRTHEAPSIMPLEFREE   pNew = (PRTHEAPSIMPLEFREE)((uintptr_t)&pFree->Core + cb + sizeof(RTHEAPSIMPLEBLOCK));
-
-            pNew->Core.pNext = pFree->Core.pNext;
-            if (pFree->Core.pNext)
-                pFree->Core.pNext->pPrev = &pNew->Core;
-            pNew->Core.pPrev = &pFree->Core;
-            pNew->Core.pHeap = pHeapInt;
-            pNew->Core.fFlags = RTHEAPSIMPLEBLOCK_FLAGS_MAGIC | RTHEAPSIMPLEBLOCK_FLAGS_FREE;
-
-            pNew->pNext = pFree->pNext;
-            if (pNew->pNext)
-                pNew->pNext->pPrev = pNew;
+            PRTHEAPOFFSETFREE   pNew = (PRTHEAPOFFSETFREE)((uintptr_t)&pFree->Core + cb + sizeof(RTHEAPOFFSETBLOCK));
+
+            pNew->Core.offSelf = RTHEAPOFF_TO_OFF(pHeapInt, pNew);
+            pNew->Core.offNext = pFree->Core.offNext;
+            if (pFree->Core.offNext)
+                RTHEAPOFF_TO_PTR(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = pNew->Core.offSelf;
+            pNew->Core.offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
+            pNew->Core.fFlags = RTHEAPOFFSETBLOCK_FLAGS_MAGIC | RTHEAPOFFSETBLOCK_FLAGS_FREE;
+
+            pNew->offNext = pFree->offNext;
+            if (pNew->offNext)
+                RTHEAPOFF_TO_PTR(pHeapInt, pNew->offNext, PRTHEAPOFFSETFREE)->offPrev = pNew->Core.offSelf;
             else
-                pHeapInt->pFreeTail = pNew;
-            pNew->pPrev = pFree->pPrev;
-            if (pNew->pPrev)
-                pNew->pPrev->pNext = pNew;
+                pHeapInt->offFreeTail = pNew->Core.offSelf;
+            pNew->offPrev = pFree->offPrev;
+            if (pNew->offPrev)
+                RTHEAPOFF_TO_PTR(pHeapInt, pNew->offPrev, PRTHEAPOFFSETFREE)->offNext = pNew->Core.offSelf;
             else
-                pHeapInt->pFreeHead = pNew;
-            pNew->cb    = (pNew->Core.pNext ? (uintptr_t)pNew->Core.pNext : (uintptr_t)pHeapInt->pvEnd) \
-                        - (uintptr_t)pNew - sizeof(RTHEAPSIMPLEBLOCK);
+                pHeapInt->offFreeHead = pNew->Core.offSelf;
+            pNew->cb    = (pNew->Core.offNext ? pNew->Core.offNext : pHeapInt->cbHeap) \
+                        - pNew->Core.offSelf - sizeof(RTHEAPOFFSETBLOCK);
             ASSERT_BLOCK_FREE(pHeapInt, pNew);
 
@@ -602 +618 @@
              * Update the old FREE node making it a USED node.
              */
-            pFree->Core.fFlags &= ~RTHEAPSIMPLEBLOCK_FLAGS_FREE;
-            pFree->Core.pNext = &pNew->Core;
+            pFree->Core.fFlags &= ~RTHEAPOFFSETBLOCK_FLAGS_FREE;
+            pFree->Core.offNext = pNew->Core.offSelf;
             pHeapInt->cbFree -= pFree->cb;
             pHeapInt->cbFree += pNew->cb;
@@ -614 +630 @@
              * Link it out of the free list.
              */
-            if (pFree->pNext)
-                pFree->pNext->pPrev = pFree->pPrev;
+            if (pFree->offNext)
+                RTHEAPOFF_TO_PTR(pHeapInt, pFree->offNext, PRTHEAPOFFSETFREE)->offPrev = pFree->offPrev;
             else
-                pHeapInt->pFreeTail = pFree->pPrev;
-            if (pFree->pPrev)
-                pFree->pPrev->pNext = pFree->pNext;
+                pHeapInt->offFreeTail = pFree->offPrev;
+            if (pFree->offPrev)
+                RTHEAPOFF_TO_PTR(pHeapInt, pFree->offPrev, PRTHEAPOFFSETFREE)->offNext = pFree->offNext;
             else
-                pHeapInt->pFreeHead = pFree->pNext;
+                pHeapInt->offFreeHead = pFree->offNext;
 
             /*
@@ -627 +643 @@
              */
             pHeapInt->cbFree -= pFree->cb;
-            pFree->Core.fFlags &= ~RTHEAPSIMPLEBLOCK_FLAGS_FREE;
+            pFree->Core.fFlags &= ~RTHEAPOFFSETBLOCK_FLAGS_FREE;
             pRet = &pFree->Core;
             ASSERT_BLOCK_USED(pHeapInt, pRet);
@@ -634 +650 @@
     }
 
-#ifdef RTHEAPSIMPLE_STRICT
-    rtHeapSimpleAssertAll(pHeapInt);
+#ifdef RTHEAPOFFSET_STRICT
+    rtHeapOffsetAssertAll(pHeapInt);
 #endif
     return pRet;
@@ -641 +657 @@
 
 
-RTDECL(void) RTHeapSimpleFree(RTHEAPSIMPLE hHeap, void *pv)
-{
-    PRTHEAPSIMPLEINTERNAL pHeapInt;
-    PRTHEAPSIMPLEBLOCK pBlock;
+RTDECL(void) RTHeapOffsetFree(RTHEAPOFFSET hHeap, void *pv)
+{
+    PRTHEAPOFFSETINTERNAL pHeapInt;
+    PRTHEAPOFFSETBLOCK pBlock;
 
     /*
@@ -652 +668 @@
         return;
     AssertPtr(pv);
-    Assert(RT_ALIGN_P(pv, RTHEAPSIMPLE_ALIGNMENT) == pv);
+    Assert(RT_ALIGN_P(pv, RTHEAPOFFSET_ALIGNMENT) == pv);
 
     /*
      * Get the block and heap. If in strict mode, validate these.
      */
-    pBlock = (PRTHEAPSIMPLEBLOCK)pv - 1;
-    pHeapInt = pBlock->pHeap;
+    pBlock = (PRTHEAPOFFSETBLOCK)pv - 1;
+    pHeapInt = RTHEAPOFF_GET_ANCHOR(pBlock);
     ASSERT_BLOCK_USED(pHeapInt, pBlock);
     ASSERT_ANCHOR(pHeapInt);
-    Assert(pHeapInt == (PRTHEAPSIMPLEINTERNAL)hHeap || !hHeap);
-
-#ifdef RTHEAPSIMPLE_FREE_POISON
+    Assert(pHeapInt == (PRTHEAPOFFSETINTERNAL)hHeap || !hHeap);
+
+#ifdef RTHEAPOFFSET_FREE_POISON
     /*
      * Poison the block.
      */
     const size_t cbBlock = (pBlock->pNext ? (uintptr_t)pBlock->pNext : (uintptr_t)pHeapInt->pvEnd)
-                         - (uintptr_t)pBlock - sizeof(RTHEAPSIMPLEBLOCK);
-    memset(pBlock + 1, RTHEAPSIMPLE_FREE_POISON, cbBlock);
+                         - (uintptr_t)pBlock - sizeof(RTHEAPOFFSETBLOCK);
+    memset(pBlock + 1, RTHEAPOFFSET_FREE_POISON, cbBlock);
 #endif
 
@@ -675 +691 @@
      * Call worker which does the actual job.
      */
-    rtHeapSimpleFreeBlock(pHeapInt, pBlock);
-}
-RT_EXPORT_SYMBOL(RTHeapSimpleFree);
+    rtHeapOffsetFreeBlock(pHeapInt, pBlock);
+}
+RT_EXPORT_SYMBOL(RTHeapOffsetFree);
 
 
@@ -686 +702 @@
  * @param   pBlock         The memory block to free.
  */
-static void rtHeapSimpleFreeBlock(PRTHEAPSIMPLEINTERNAL pHeapInt, PRTHEAPSIMPLEBLOCK pBlock)
-{
-    PRTHEAPSIMPLEFREE   pFree = (PRTHEAPSIMPLEFREE)pBlock;
-    PRTHEAPSIMPLEFREE   pLeft;
-    PRTHEAPSIMPLEFREE   pRight;
-
-#ifdef RTHEAPSIMPLE_STRICT
-    rtHeapSimpleAssertAll(pHeapInt);
+static void rtHeapOffsetFreeBlock(PRTHEAPOFFSETINTERNAL pHeapInt, PRTHEAPOFFSETBLOCK pBlock)
+{
+    PRTHEAPOFFSETFREE   pFree = (PRTHEAPOFFSETFREE)pBlock;
+    PRTHEAPOFFSETFREE   pLeft;
+    PRTHEAPOFFSETFREE   pRight;
+
+#ifdef RTHEAPOFFSET_STRICT
+    rtHeapOffsetAssertAll(pHeapInt);
 #endif
 
@@ -702 +718 @@
     pLeft = NULL;
     pRight = NULL;
-    if (pHeapInt->pFreeTail)
-    {
-        pRight = (PRTHEAPSIMPLEFREE)pFree->Core.pNext;
-        while (pRight && !RTHEAPSIMPLEBLOCK_IS_FREE(&pRight->Core))
+    if (pHeapInt->offFreeTail)
+    {
+        pRight = RTHEAPOFF_TO_PTR(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETFREE);
+        while (pRight && !RTHEAPOFFSETBLOCK_IS_FREE(&pRight->Core))
         {
             ASSERT_BLOCK(pHeapInt, &pRight->Core);
-            pRight = (PRTHEAPSIMPLEFREE)pRight->Core.pNext;
+            pRight = RTHEAPOFF_TO_PTR(pHeapInt, pRight->Core.offNext, PRTHEAPOFFSETFREE);
         }
         if (!pRight)
-            pLeft = pHeapInt->pFreeTail;
+            pLeft = RTHEAPOFF_TO_PTR(pHeapInt, pHeapInt->offFreeTail, PRTHEAPOFFSETFREE);
         else
         {
             ASSERT_BLOCK_FREE(pHeapInt, pRight);
-            pLeft = pRight->pPrev;
+            pLeft = RTHEAPOFF_TO_PTR(pHeapInt, pRight->offPrev, PRTHEAPOFFSETFREE);
         }
         if (pLeft)
@@ -721 +737 @@
     }
     AssertMsgReturnVoid(pLeft != pFree, ("Freed twice! pv=%p (pBlock=%p)\n", pBlock + 1, pBlock));
-    ASSERT_L(pLeft, pFree);
+    ASSERT_L(RTHEAPOFF_TO_OFF(pHeapInt, pLeft), RTHEAPOFF_TO_OFF(pHeapInt, pFree));
     Assert(!pRight || (uintptr_t)pRight > (uintptr_t)pFree);
-    Assert(!pLeft || pLeft->pNext == pRight);
+    Assert(!pLeft || RTHEAPOFF_TO_PTR(pHeapInt, pLeft->offNext, PRTHEAPOFFSETFREE) == pRight);
 
     /*
@@ -730 +746 @@
     if (!pLeft)
     {
-        Assert(pRight == pHeapInt->pFreeHead);
-        pFree->Core.fFlags |= RTHEAPSIMPLEBLOCK_FLAGS_FREE;
-        pFree->pPrev = NULL;
-        pFree->pNext = pRight;
+        Assert(pRight == RTHEAPOFF_TO_PTR(pHeapInt, pHeapInt->offFreeHead, PRTHEAPOFFSETFREE));
+        pFree->Core.fFlags |= RTHEAPOFFSETBLOCK_FLAGS_FREE;
+        pFree->offPrev = 0;
+        pFree->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pRight);
         if (pRight)
-            pRight->pPrev = pFree;
+            pRight->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
         else
-            pHeapInt->pFreeTail = pFree;
-        pHeapInt->pFreeHead = pFree;
+            pHeapInt->offFreeTail = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
+        pHeapInt->offFreeHead = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
     }
     else
@@ -745 +761 @@
          * Can we merge with left hand free block?
          */
-        if (pLeft->Core.pNext == &pFree->Core)
+        if (pLeft->Core.offNext == RTHEAPOFF_TO_OFF(pHeapInt, pFree))
         {
-            pLeft->Core.pNext = pFree->Core.pNext;
-            if (pFree->Core.pNext)
-                pFree->Core.pNext->pPrev = &pLeft->Core;
+            pLeft->Core.offNext = pFree->Core.offNext;
+            if (pFree->Core.offNext)
+                RTHEAPOFF_TO_PTR(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pLeft);
             pHeapInt->cbFree -= pLeft->cb;
             pFree = pLeft;
@@ -758 +774 @@
         else
         {
-            pFree->Core.fFlags |= RTHEAPSIMPLEBLOCK_FLAGS_FREE;
-            pFree->pNext = pRight;
-            pFree->pPrev = pLeft;
-            pLeft->pNext = pFree;
+            pFree->Core.fFlags |= RTHEAPOFFSETBLOCK_FLAGS_FREE;
+            pFree->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pRight);
+            pFree->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pLeft);
+            pLeft->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
             if (pRight)
-                pRight->pPrev = pFree;
+                pRight->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
             else
-                pHeapInt->pFreeTail = pFree;
+                pHeapInt->offFreeTail = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
         }
     }
@@ -773 +789 @@
      */
     if (    pRight
-        &&  pRight->Core.pPrev == &pFree->Core)
+        &&  pRight->Core.offPrev == RTHEAPOFF_TO_OFF(pHeapInt, pFree))
     {
         /* core */
-        pFree->Core.pNext = pRight->Core.pNext;
-        if (pRight->Core.pNext)
-            pRight->Core.pNext->pPrev = &pFree->Core;
+        pFree->Core.offNext = pRight->Core.offNext;
+        if (pRight->Core.offNext)
+            RTHEAPOFF_TO_PTR(pHeapInt, pRight->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
 
         /* free */
-        pFree->pNext = pRight->pNext;
-        if (pRight->pNext)
-            pRight->pNext->pPrev = pFree;
+        pFree->offNext = pRight->offNext;
+        if (pRight->offNext)
+            RTHEAPOFF_TO_PTR(pHeapInt, pRight->offNext, PRTHEAPOFFSETFREE)->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
         else
-            pHeapInt->pFreeTail = pFree;
+            pHeapInt->offFreeTail = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
         pHeapInt->cbFree -= pRight->cb;
     }
@@ -792 +808 @@
      * Calculate the size and update free stats.
      */
-    pFree->cb = (pFree->Core.pNext ? (uintptr_t)pFree->Core.pNext : (uintptr_t)pHeapInt->pvEnd)
-              - (uintptr_t)pFree - sizeof(RTHEAPSIMPLEBLOCK);
+    pFree->cb = (pFree->Core.offNext ? pFree->Core.offNext : pHeapInt->cbHeap)
+              - RTHEAPOFF_TO_OFF(pHeapInt, pFree) - sizeof(RTHEAPOFFSETBLOCK);
     pHeapInt->cbFree += pFree->cb;
     ASSERT_BLOCK_FREE(pHeapInt, pFree);
 
-#ifdef RTHEAPSIMPLE_STRICT
-    rtHeapSimpleAssertAll(pHeapInt);
-#endif
-}
-
-
-#ifdef RTHEAPSIMPLE_STRICT
+#ifdef RTHEAPOFFSET_STRICT
+    rtHeapOffsetAssertAll(pHeapInt);
+#endif
+}
+
+
+#ifdef RTHEAPOFFSET_STRICT
 /**
  * Internal consistency check (relying on assertions).
  * @param   pHeapInt
  */
-static void rtHeapSimpleAssertAll(PRTHEAPSIMPLEINTERNAL pHeapInt)
-{
-    PRTHEAPSIMPLEFREE pPrev = NULL;
-    PRTHEAPSIMPLEFREE pPrevFree = NULL;
-    PRTHEAPSIMPLEFREE pBlock;
-    for (pBlock = (PRTHEAPSIMPLEFREE)(pHeapInt + 1);
+static void rtHeapOffsetAssertAll(PRTHEAPOFFSETINTERNAL pHeapInt)
+{
+    PRTHEAPOFFSETFREE pPrev = NULL;
+    PRTHEAPOFFSETFREE pPrevFree = NULL;
+    PRTHEAPOFFSETFREE pBlock;
+    for (pBlock = (PRTHEAPOFFSETFREE)(pHeapInt + 1);
          pBlock;
-         pBlock = (PRTHEAPSIMPLEFREE)pBlock->Core.pNext)
-    {
-        if (RTHEAPSIMPLEBLOCK_IS_FREE(&pBlock->Core))
+         pBlock = RTHEAPOFF_TO_PTR(pHeapInt, pBlock->Core.offNext, PRTHEAPOFFSETFREE))
+    {
+        if (RTHEAPOFFSETBLOCK_IS_FREE(&pBlock->Core))
         {
             ASSERT_BLOCK_FREE(pHeapInt, pBlock);
-            Assert(pBlock->pPrev == pPrevFree);
-            Assert(pPrevFree || pHeapInt->pFreeHead == pBlock);
+            Assert(pBlock->offPrev == RTHEAPOFF_TO_OFF(pHeapInt, pPrevFree));
+            Assert(pPrevFree || pHeapInt->offFreeHead == RTHEAPOFF_TO_OFF(pHeapInt, pBlock));
             pPrevFree = pBlock;
         }
         else
             ASSERT_BLOCK_USED(pHeapInt, &pBlock->Core);
-        Assert(!pPrev || pPrev == (PRTHEAPSIMPLEFREE)pBlock->Core.pPrev);
+        Assert(!pPrev || RTHEAPOFF_TO_OFF(pHeapInt, pPrev) == pBlock->Core.offPrev);
         pPrev = pBlock;
     }
-    Assert(pHeapInt->pFreeTail == pPrevFree);
-}
-#endif
-
-
-RTDECL(size_t) RTHeapSimpleSize(RTHEAPSIMPLE hHeap, void *pv)
-{
-    PRTHEAPSIMPLEINTERNAL pHeapInt;
-    PRTHEAPSIMPLEBLOCK pBlock;
+    Assert(pHeapInt->offFreeTail == RTHEAPOFF_TO_OFF(pHeapInt, pPrevFree));
+}
+#endif
+
+
+RTDECL(size_t) RTHeapOffsetSize(RTHEAPOFFSET hHeap, void *pv)
+{
+    PRTHEAPOFFSETINTERNAL pHeapInt;
+    PRTHEAPOFFSETBLOCK pBlock;
     size_t cbBlock;
 
@@ -846 +862 @@
         return 0;
     AssertPtrReturn(pv, 0);
-    AssertReturn(RT_ALIGN_P(pv, RTHEAPSIMPLE_ALIGNMENT) == pv, 0);
+    AssertReturn(RT_ALIGN_P(pv, RTHEAPOFFSET_ALIGNMENT) == pv, 0);
 
     /*
      * Get the block and heap. If in strict mode, validate these.
      */
-    pBlock = (PRTHEAPSIMPLEBLOCK)pv - 1;
-    pHeapInt = pBlock->pHeap;
+    pBlock = (PRTHEAPOFFSETBLOCK)pv - 1;
+    pHeapInt = RTHEAPOFF_GET_ANCHOR(pBlock);
     ASSERT_BLOCK_USED(pHeapInt, pBlock);
     ASSERT_ANCHOR(pHeapInt);
-    Assert(pHeapInt == (PRTHEAPSIMPLEINTERNAL)hHeap || !hHeap);
+    Assert(pHeapInt == (PRTHEAPOFFSETINTERNAL)hHeap || !hHeap);
 
     /*
      * Calculate the block size.
      */
-    cbBlock = (pBlock->pNext ? (uintptr_t)pBlock->pNext : (uintptr_t)pHeapInt->pvEnd)
-            - (uintptr_t)pBlock- sizeof(RTHEAPSIMPLEBLOCK);
+    cbBlock = (pBlock->offNext ? pBlock->offNext : pHeapInt->cbHeap)
+            - RTHEAPOFF_TO_OFF(pHeapInt, pBlock) - sizeof(RTHEAPOFFSETBLOCK);
     return cbBlock;
 }
-RT_EXPORT_SYMBOL(RTHeapSimpleSize);
-
-
-RTDECL(size_t) RTHeapSimpleGetHeapSize(RTHEAPSIMPLE hHeap)
-{
-    PRTHEAPSIMPLEINTERNAL pHeapInt;
-
-    if (hHeap == NIL_RTHEAPSIMPLE)
+RT_EXPORT_SYMBOL(RTHeapOffsetSize);
+
+
+RTDECL(size_t) RTHeapOffsetGetHeapSize(RTHEAPOFFSET hHeap)
+{
+    PRTHEAPOFFSETINTERNAL pHeapInt;
+
+    if (hHeap == NIL_RTHEAPOFFSET)
         return 0;
 
@@ -879 +895 @@
     return pHeapInt->cbHeap;
 }
-RT_EXPORT_SYMBOL(RTHeapSimpleGetHeapSize);
-
-
-RTDECL(size_t) RTHeapSimpleGetFreeSize(RTHEAPSIMPLE hHeap)
-{
-    PRTHEAPSIMPLEINTERNAL pHeapInt;
-
-    if (hHeap == NIL_RTHEAPSIMPLE)
+RT_EXPORT_SYMBOL(RTHeapOffsetGetHeapSize);
+
+
+RTDECL(size_t) RTHeapOffsetGetFreeSize(RTHEAPOFFSET hHeap)
+{
+    PRTHEAPOFFSETINTERNAL pHeapInt;
+
+    if (hHeap == NIL_RTHEAPOFFSET)
         return 0;
 
@@ -894 +910 @@
     return pHeapInt->cbFree;
 }
-RT_EXPORT_SYMBOL(RTHeapSimpleGetFreeSize);
-
-
-RTDECL(void) RTHeapSimpleDump(RTHEAPSIMPLE hHeap, PFNRTHEAPSIMPLEPRINTF pfnPrintf)
-{
-    PRTHEAPSIMPLEINTERNAL pHeapInt = (PRTHEAPSIMPLEINTERNAL)hHeap;
-    PRTHEAPSIMPLEFREE pBlock;
-
-    pfnPrintf("**** Dumping Heap %p - cbHeap=%zx cbFree=%zx ****\n",
+RT_EXPORT_SYMBOL(RTHeapOffsetGetFreeSize);
+
+
+RTDECL(void) RTHeapOffsetDump(RTHEAPOFFSET hHeap, PFNRTHEAPOFFSETPRINTF pfnPrintf)
+{
+    PRTHEAPOFFSETINTERNAL pHeapInt = (PRTHEAPOFFSETINTERNAL)hHeap;
+    PRTHEAPOFFSETFREE pBlock;
+
+    pfnPrintf("**** Dumping Heap %p - cbHeap=%x cbFree=%x ****\n",
               hHeap, pHeapInt->cbHeap, pHeapInt->cbFree);
 
-    for (pBlock = (PRTHEAPSIMPLEFREE)(pHeapInt + 1);
+    for (pBlock = (PRTHEAPOFFSETFREE)(pHeapInt + 1);
          pBlock;
-         pBlock = (PRTHEAPSIMPLEFREE)pBlock->Core.pNext)
-    {
-        size_t cb = (pBlock->pNext ? (uintptr_t)pBlock->Core.pNext : (uintptr_t)pHeapInt->pvEnd)
-                  - (uintptr_t)pBlock - sizeof(RTHEAPSIMPLEBLOCK);
-        if (RTHEAPSIMPLEBLOCK_IS_FREE(&pBlock->Core))
-            pfnPrintf("%p  %06x FREE pNext=%p pPrev=%p fFlags=%#x cb=%#06x : cb=%#06x pNext=%p pPrev=%p\n",
-                      pBlock, (uintptr_t)pBlock - (uintptr_t)(pHeapInt + 1), pBlock->Core.pNext, pBlock->Core.pPrev, pBlock->Core.fFlags, cb,
-                      pBlock->cb, pBlock->pNext, pBlock->pPrev);
+         pBlock = RTHEAPOFF_TO_PTR(pHeapInt, pBlock->Core.offNext, PRTHEAPOFFSETFREE))
+    {
+        size_t cb = (pBlock->offNext ? pBlock->Core.offNext : pHeapInt->cbHeap)
+                  - RTHEAPOFF_TO_OFF(pHeapInt, pBlock) - sizeof(RTHEAPOFFSETBLOCK);
+        if (RTHEAPOFFSETBLOCK_IS_FREE(&pBlock->Core))
+            pfnPrintf("%p  %06x FREE offNext=%06x offPrev=%06x fFlags=%#x cb=%#06x : cb=%#06x offNext=%06x offPrev=%06x\n",
+                      pBlock, pBlock->Core.offSelf, pBlock->Core.offNext, pBlock->Core.offPrev, pBlock->Core.fFlags, cb,
+                      pBlock->cb, pBlock->offNext, pBlock->offPrev);
         else
-            pfnPrintf("%p  %06x USED pNext=%p pPrev=%p fFlags=%#x cb=%#06x\n",
-                      pBlock, (uintptr_t)pBlock - (uintptr_t)(pHeapInt + 1), pBlock->Core.pNext, pBlock->Core.pPrev, pBlock->Core.fFlags, cb);
+            pfnPrintf("%p  %06x USED offNext=%06x offPrev=%06x fFlags=%#x cb=%#06x\n",
+                      pBlock, pBlock->Core.offSelf, pBlock->Core.offNext, pBlock->Core.offPrev, pBlock->Core.fFlags, cb);
     }
     pfnPrintf("**** Done dumping Heap %p ****\n", hHeap);
 }
-RT_EXPORT_SYMBOL(RTHeapSimpleDump);
-
+RT_EXPORT_SYMBOL(RTHeapOffsetDump);
+