diff -r c1f20ce4abcf -r 3e88ff8f41d5 kernel/eka/common/heap_hybrid.cpp
--- a/kernel/eka/common/heap_hybrid.cpp	Tue Aug 31 16:34:26 2010 +0300
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,3319 +0,0 @@
-// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).
-// All rights reserved.
-// This component and the accompanying materials are made available
-// under the terms of the License "Eclipse Public License v1.0"
-// which accompanies this distribution, and is available
-// at the URL "http://www.eclipse.org/legal/epl-v10.html".
-//
-// Initial Contributors:
-// Nokia Corporation - initial contribution.
-//
-// Contributors:
-//
-// Description:
-// kernel\eka\common\heap_hybrid.cpp
-// 
-// Uses malloc (aka dlmalloc) written by Doug Lea version 2.8.4
-//
-
-#include "common.h"
-#ifdef __KERNEL_MODE__
-#include <kernel/kern_priv.h>
-#endif
-#include "dla.h"
-#ifndef __KERNEL_MODE__
-#include "slab.h"
-#include "page_alloc.h"
-#endif
-#include "heap_hybrid.h"
-
-// enables btrace code compiling into 
-#define ENABLE_BTRACE
-
-// if non zero this causes the iSlabs to be configured only when the chunk size exceeds this level
-#define DELAYED_SLAB_THRESHOLD (64*1024)		// 64KB seems about right based on trace data
-#define SLAB_CONFIG 0xabe						// Use slabs of size 48, 40, 32, 24, 20, 16, 12, and 8 bytes
-
-#ifdef _DEBUG
-#define __SIMULATE_ALLOC_FAIL(s)	if (CheckForSimulatedAllocFail()) {s}
-#define __ALLOC_DEBUG_HEADER(s)  	(s += EDebugHdrSize)
-#define __SET_DEBUG_DATA(p,n,c)   	(((SDebugCell*)(p))->nestingLevel = (n), ((SDebugCell*)(p))->allocCount = (c))
-#define __GET_USER_DATA_BFR(p)   	((p!=0) ? (TUint8*)(p) + EDebugHdrSize : NULL)
-#define __GET_DEBUG_DATA_BFR(p)   	((p!=0) ? (TUint8*)(p) - EDebugHdrSize : NULL)
-#define	__ZAP_CELL(p)				memset( (TUint8*)p, 0xde, (AllocLen(__GET_USER_DATA_BFR(p))+EDebugHdrSize))
-#define __DEBUG_SAVE(p)				TInt dbgNestLevel = ((SDebugCell*)p)->nestingLevel
-#define __DEBUG_RESTORE(p)			if (p) {((SDebugCell*)p)->nestingLevel = dbgNestLevel;}
-#define __DEBUG_HDR_SIZE			EDebugHdrSize
-#define __REMOVE_DBG_HDR(n) 		(n*EDebugHdrSize)
-#define __GET_AVAIL_BLOCK_SIZE(s)   ( (s<EDebugHdrSize) ? 0 : s-EDebugHdrSize )
-#define __UPDATE_ALLOC_COUNT(o,n,c)	if (o!=n && n) {((SDebugCell*)n)->allocCount = (c);}
-#define __INIT_COUNTERS(i)	        iCellCount=i,iTotalAllocSize=i
-#define __INCREMENT_COUNTERS(p)	    iCellCount++, iTotalAllocSize += AllocLen(p)
-#define __DECREMENT_COUNTERS(p)	    iCellCount--, iTotalAllocSize -= AllocLen(p)
-#define __UPDATE_TOTAL_ALLOC(p,s)	iTotalAllocSize += (AllocLen(__GET_USER_DATA_BFR(p)) - s)
-
-#else
-#define __SIMULATE_ALLOC_FAIL(s)
-#define __ALLOC_DEBUG_HEADER(s)
-#define __SET_DEBUG_DATA(p,n,c)
-#define __GET_USER_DATA_BFR(p)  (p)
-#define __GET_DEBUG_DATA_BFR(p) (p)
-#define	__ZAP_CELL(p)
-#define __DEBUG_SAVE(p)			
-#define __DEBUG_RESTORE(p)
-#define __DEBUG_HDR_SIZE		0
-#define __REMOVE_DBG_HDR(n) 	0
-#define __GET_AVAIL_BLOCK_SIZE(s)   (s)
-#define __UPDATE_ALLOC_COUNT(o,n,c)	
-#define __INIT_COUNTERS(i)	        iCellCount=i,iTotalAllocSize=i
-#define __INCREMENT_COUNTERS(p)
-#define __DECREMENT_COUNTERS(p)
-#define __UPDATE_TOTAL_ALLOC(p,s)
-
-#endif
-
-
-#define MEMORY_MONITORED  (iFlags & EMonitorMemory)
-#define GM  (&iGlobalMallocState)
-#define IS_FIXED_HEAP  (iFlags & EFixedSize)
-#define __INIT_COUNTERS(i)	iCellCount=i,iTotalAllocSize=i
-#define __POWER_OF_2(x)		(!((x)&((x)-1)))
-
-#define __DL_BFR_CHECK(M,P) \
-		  if ( MEMORY_MONITORED ) \
-             if ( !IS_ALIGNED(P) || ((TUint8*)(P)<M->iSeg.iBase) || ((TUint8*)(P)>(M->iSeg.iBase+M->iSeg.iSize))) \
-                  BTraceContext12(BTrace::EHeap, BTrace::EHeapCorruption, (TUint32)this, (TUint32)P, (TUint32)0), HEAP_PANIC(ETHeapBadCellAddress); \
-			 else DoCheckInuseChunk(M, MEM2CHUNK(P)) 
-
-#ifndef __KERNEL_MODE__
-
-#define __SLAB_BFR_CHECK(S,P,B) \
-	  if ( MEMORY_MONITORED ) \
-		  if ( ((TUint32)P & 0x3) || ((TUint8*)P<iMemBase) || ((TUint8*)(P)>(TUint8*)this))  \
-			   BTraceContext12(BTrace::EHeap, BTrace::EHeapCorruption, (TUint32)this, (TUint32)P, (TUint32)S), HEAP_PANIC(ETHeapBadCellAddress); \
-		  else DoCheckSlab(S, EPartialFullSlab, P), BuildPartialSlabBitmap(B,S,P) 					  
-#define __PAGE_BFR_CHECK(P) \
-		if ( MEMORY_MONITORED ) \
-			if ( ((TUint32)P &  ((1 << iPageSize)-1)) || ((TUint8*)P<iMemBase) || ((TUint8*)(P)>(TUint8*)this))  \
-				BTraceContext12(BTrace::EHeap, BTrace::EHeapCorruption, (TUint32)this, (TUint32)P, (TUint32)0), HEAP_PANIC(ETHeapBadCellAddress)
-
-#endif
-
-#ifdef _MSC_VER
-// This is required while we are still using VC6 to compile, so as to avoid warnings that cannot be fixed
-// without having to edit the original Doug Lea source.  The 4146 warnings are due to the original code having
-// a liking for negating unsigned numbers and the 4127 warnings are due to the original code using the RTCHECK
-// macro with values that are always defined as 1.  It is better to turn these warnings off than to introduce
-// diffs between the original Doug Lea implementation and our adaptation of it
-#pragma warning( disable : 4146 ) /* unary minus operator applied to unsigned type, result still unsigned */
-#pragma warning( disable : 4127 ) /* conditional expression is constant */
-#endif // _MSC_VER
-
-
-/**
-@SYMPatchable
-@publishedPartner
-@released
-
-Defines the minimum cell size of  a heap.
-
-The constant can be changed at ROM build time using patchdata OBY keyword.
-
-@deprecated Patching this constant no longer has any effect.
-*/
-#ifdef __X86GCC__	// For X86GCC we dont use the proper data import attribute
-#undef IMPORT_D		// since the constants are not really imported. GCC doesn't 
-#define IMPORT_D	// allow imports from self.
-#endif
-IMPORT_D extern const TInt KHeapMinCellSize;
-
-/**
-@SYMPatchable
-@publishedPartner
-@released
-
-This constant defines the ratio that determines the amount of hysteresis between heap growing and heap
-shrinking.
-It is a 32-bit fixed point number where the radix point is defined to be
-between bits 7 and 8 (where the LSB is bit 0) i.e. using standard notation, a Q8 or a fx24.8
-fixed point number.  For example, for a ratio of 2.0, set KHeapShrinkHysRatio=0x200.
-
-The heap shrinking hysteresis value is calculated to be:
-@code
-KHeapShrinkHysRatio*(iGrowBy>>8)
-@endcode
-where iGrowBy is a page aligned value set by the argument, aGrowBy, to the RHeap constructor.
-The default hysteresis value is iGrowBy bytes i.e. KHeapShrinkHysRatio=2.0.
-
-Memory usage may be improved by reducing the heap shrinking hysteresis
-by setting 1.0 < KHeapShrinkHysRatio < 2.0.  Heap shrinking hysteresis is disabled/removed
-when KHeapShrinkHysRatio <= 1.0.
-
-The constant can be changed at ROM build time using patchdata OBY keyword.
-*/
-IMPORT_D extern const TInt KHeapShrinkHysRatio;
-
-UEXPORT_C TInt RHeap::AllocLen(const TAny* aCell) const
-{
-	const MAllocator* m = this;
-	return m->AllocLen(aCell);
-}
-
-UEXPORT_C TAny* RHeap::Alloc(TInt aSize)
-{
-	const MAllocator* m = this;
-	return ((MAllocator*)m)->Alloc(aSize);
-}
-
-UEXPORT_C void RHeap::Free(TAny* aCell)
-{
-	const MAllocator* m = this;
-	((MAllocator*)m)->Free(aCell);
-}
-
-UEXPORT_C TAny* RHeap::ReAlloc(TAny* aCell, TInt aSize, TInt aMode)
-{
-	const MAllocator* m = this;
-	return ((MAllocator*)m)->ReAlloc(aCell, aSize, aMode);
-}
-
-UEXPORT_C TInt RHeap::DebugFunction(TInt aFunc, TAny* a1, TAny* a2)
-{
-	const MAllocator* m = this;
-	return ((MAllocator*)m)->DebugFunction(aFunc, a1, a2);
-}
-
-UEXPORT_C TInt RHeap::Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)
-{
-	const MAllocator* m = this;
-	return ((MAllocator*)m)->Extension_(aExtensionId, a0, a1);
-}
-
-#ifndef __KERNEL_MODE__
-
-EXPORT_C TInt RHeap::AllocSize(TInt& aTotalAllocSize) const
-{
-	const MAllocator* m = this;
-	return m->AllocSize(aTotalAllocSize);
-}
-
-EXPORT_C TInt RHeap::Available(TInt& aBiggestBlock) const
-{
-	const MAllocator* m = this;
-	return m->Available(aBiggestBlock);
-}
-
-EXPORT_C void RHeap::Reset()
-{
-	const MAllocator* m = this;
-	((MAllocator*)m)->Reset();
-}
-
-EXPORT_C TInt RHeap::Compress()
-{
-	const MAllocator* m = this;
-	return ((MAllocator*)m)->Compress();
-}
-#endif
-
-RHybridHeap::RHybridHeap()
-	{
-	// This initialisation cannot be done in RHeap() for compatibility reasons
-	iMaxLength = iChunkHandle = iNestingLevel = 0;
-	iTop = NULL;
-	iFailType = ENone;
-	iTestData = NULL;
-	}
-
-void RHybridHeap::operator delete(TAny*, TAny*) 
-/**
-Called if constructor issued by operator new(TUint aSize, TAny* aBase) throws exception.
-This is dummy as corresponding new operator does not allocate memory.
-*/
-{}
-
-
-#ifndef __KERNEL_MODE__
-void RHybridHeap::Lock() const
-   /**
-   @internalComponent
-*/
-   {((RFastLock&)iLock).Wait();}
-
-
-void RHybridHeap::Unlock() const
-   /**
-   @internalComponent
-*/
-   {((RFastLock&)iLock).Signal();}
-
-
-TInt RHybridHeap::ChunkHandle() const
-   /**
-   @internalComponent
-*/
-{
-	return iChunkHandle;
-}
-
-#else
-//
-//  This method is implemented in kheap.cpp
-//
-//void RHybridHeap::Lock() const
-   /**
-   @internalComponent
-*/
-//   {;}
-
-
-
-//
-//  This method is implemented in kheap.cpp
-//
-//void RHybridHeap::Unlock() const
-   /**
-   @internalComponent
-*/
-//   {;}
-
-
-TInt RHybridHeap::ChunkHandle() const
-   /**
-   @internalComponent
-*/
-{
-	return 0;
-}
-#endif
-
-RHybridHeap::RHybridHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign, TBool aSingleThread, TBool aDLOnly, TBool aUseAdjust)
-/**
-Constructor for a non fixed heap.  Unlike the fixed heap, this heap is quite flexible in terms of its minimum and
-maximum lengths and in that it can use the hybrid allocator if all of its requirements are met.
-*/
-	: iOffset(aOffset), iChunkSize(aMinLength)
-	{
-	__ASSERT_ALWAYS(iOffset>=0, HEAP_PANIC(ETHeapNewBadOffset));	
-
-	iChunkHandle = aChunkHandle;
-	iMinLength = aMinLength;
-	iMaxLength = aMaxLength;
-
-	// If the user has explicitly specified 0 as the aGrowBy value, set it to 1 so that it will be rounded up to the nearst page size
-	if (aGrowBy == 0)
-		aGrowBy = 1;
-	GET_PAGE_SIZE(iPageSize);
-	iGrowBy = _ALIGN_UP(aGrowBy, iPageSize);
-
-	Construct(aSingleThread, aDLOnly, aUseAdjust, aAlign);
-	}
-
-RHybridHeap::RHybridHeap(TInt aMaxLength, TInt aAlign, TBool aSingleThread)
-/**
-Constructor for a fixed heap.  We have restrictions in that we have fixed minimum and maximum lengths and cannot grow
-and we only use DL allocator.
-*/
-	: iOffset(0), iChunkSize(aMaxLength)
-	{
-	iChunkHandle = NULL;
-	iMinLength = aMaxLength;
-	iMaxLength = aMaxLength;
-	iGrowBy = 0;
-
-	Construct(aSingleThread, ETrue, ETrue, aAlign);
-	}
-
-TAny* RHybridHeap::operator new(TUint aSize, TAny* aBase) __NO_THROW
-{
-	__ASSERT_ALWAYS(aSize>=sizeof(RHybridHeap), HEAP_PANIC(ETHeapNewBadSize));
-	RHybridHeap* h = (RHybridHeap*)aBase;
-	h->iBase = ((TUint8*)aBase) + aSize;
-	return aBase;
-}
-
-void RHybridHeap::Construct(TBool aSingleThread, TBool aDLOnly, TBool aUseAdjust, TInt aAlign)
-{
-	iAlign = aAlign ? aAlign : RHybridHeap::ECellAlignment;
-	__ASSERT_ALWAYS((TUint32)iAlign>=sizeof(TAny*) && __POWER_OF_2(iAlign), HEAP_PANIC(ETHeapNewBadAlignment));
-
-	// This initialisation cannot be done in RHeap() for compatibility reasons
-	iTop = NULL;
-	iFailType = ENone;
-	iNestingLevel = 0;
-	iTestData = NULL;
-
-	iHighWaterMark = iMinLength;
-	iAllocCount = 0;
-	iFlags = aSingleThread ? ESingleThreaded : 0;
-	iGrowBy = _ALIGN_UP(iGrowBy, iPageSize);
-	
-	if ( iMinLength == iMaxLength )
-		{
-		iFlags |= EFixedSize;
-		aDLOnly = ETrue;
-		}
-#ifndef __KERNEL_MODE__
-#ifdef DELAYED_SLAB_THRESHOLD
-	iSlabInitThreshold = DELAYED_SLAB_THRESHOLD;
-#else
-	iSlabInitThreshold = 0;
-#endif // DELAYED_SLAB_THRESHOLD
-	iUseAdjust = aUseAdjust;
-	iDLOnly    = aDLOnly;
-#else
-	(void)aUseAdjust;	
-#endif 
-	// Initialise suballocators
-	// if DL only is required then it cannot allocate slab or page memory
-	// so these sub-allocators should be disabled. Otherwise initialise with default values
-	if ( aDLOnly )
-		{
-		Init(0, 0);
-		}
-	else
-		{
-		Init(SLAB_CONFIG, 16);
-		}
-	
-#ifdef ENABLE_BTRACE
-	
-	TUint32 traceData[4];
-	traceData[0] = iMinLength;
-	traceData[1] = iMaxLength;
-	traceData[2] = iGrowBy;
-	traceData[3] = iAlign;
-	BTraceContextN(BTrace::ETest1, 90, (TUint32)this, 11, traceData, sizeof(traceData));
-#endif
-	
-}
-
-#ifndef __KERNEL_MODE__
-TInt RHybridHeap::ConstructLock(TUint32 aMode)
-{
-	TBool duplicateLock = EFalse;
-	TInt r = KErrNone;
-	if (!(iFlags & ESingleThreaded))
-		{
-		duplicateLock = aMode & UserHeap::EChunkHeapSwitchTo;
-		r = iLock.CreateLocal(duplicateLock ? EOwnerThread : EOwnerProcess);
-		if( r != KErrNone)
-			{
-			iChunkHandle = 0;
-			return r;
-			}
-		}
-	
-	if ( aMode & UserHeap::EChunkHeapSwitchTo )
-		User::SwitchHeap(this);
-	
-	iHandles = &iChunkHandle;
-	if (!(iFlags & ESingleThreaded))
-		{
-		// now change the thread-relative chunk/semaphore handles into process-relative handles
-		iHandleCount = 2;
-		if(duplicateLock)
-			{
-			RHandleBase s = iLock;
-			r = iLock.Duplicate(RThread());
-			s.Close();
-			}
-		if (r==KErrNone && (aMode & UserHeap::EChunkHeapDuplicate))
-			{
-			r = ((RChunk*)&iChunkHandle)->Duplicate(RThread());
-			if (r!=KErrNone)
-				iLock.Close(), iChunkHandle=0;
-			}
-		}
-	else
-		{
-		iHandleCount = 1;
-		if (aMode & UserHeap::EChunkHeapDuplicate)
-			r = ((RChunk*)&iChunkHandle)->Duplicate(RThread(), EOwnerThread);
-		}
-	
-	return r;
-}
-#endif
-
-void RHybridHeap::Init(TInt aBitmapSlab, TInt aPagePower)
-{
-	/*Moved code which does initilization */
-	iTop  = (TUint8*)this + iMinLength;
-	iBase = Ceiling(iBase, ECellAlignment);	// Align iBase address 
-	
-    __INIT_COUNTERS(0);
-	//	memset(&mparams,0,sizeof(mparams));
-	
-	InitDlMalloc(iTop - iBase, 0);
-	
-#ifndef __KERNEL_MODE__	
-	SlabInit();
-	iSlabConfigBits = aBitmapSlab;
-	if ( iChunkSize > iSlabInitThreshold )
-		{
-		iSlabInitThreshold = KMaxTInt32;
-		SlabConfig(aBitmapSlab);   // Delayed slab configuration done
-		}
-	if ( aPagePower )
-		{
-		RChunk chunk;
-		chunk.SetHandle(iChunkHandle);
-		iMemBase = chunk.Base();    // Store base address for paged allocator
-		}
-
-	/*10-1K,11-2K,12-4k,13-8K,14-16K,15-32K,16-64K*/
-	PagedInit(aPagePower);
-
-#ifdef ENABLE_BTRACE
-	TUint32 traceData[3];
-	traceData[0] = aBitmapSlab;
-	traceData[1] = aPagePower;
-	traceData[2] = GM->iTrimCheck;
-	BTraceContextN(BTrace::ETest1, 90, (TUint32)this, 0, traceData, sizeof(traceData));
-#endif
-#else
-	(void)aBitmapSlab;
-	(void)aPagePower;
-#endif	// __KERNEL_MODE__
-	
-}
-
-
-TInt RHybridHeap::AllocLen(const TAny* aCell) const
-{
-	aCell = __GET_DEBUG_DATA_BFR(aCell);
-	
-	if (PtrDiff(aCell, this) >= 0)
-		{
-		mchunkptr m = MEM2CHUNK(aCell);
-		return CHUNKSIZE(m) - OVERHEAD_FOR(m) - __DEBUG_HDR_SIZE;
-		}
-#ifndef __KERNEL_MODE__		
-	if ( aCell )
-		{
-		if (LowBits(aCell, iPageSize) )
-			return SlabHeaderSize(slab::SlabFor(aCell)->iHeader) - __DEBUG_HDR_SIZE;
-		
-		return PagedSize((void*)aCell) - __DEBUG_HDR_SIZE;
-		}
-#endif	
-	return 0; // NULL pointer situation, should PANIC !!
-}
-
-#ifdef __KERNEL_MODE__
-TAny* RHybridHeap::Alloc(TInt aSize)
-{
-	__CHECK_THREAD_STATE;
-	__ASSERT_ALWAYS((TUint)aSize<(KMaxTInt/2),HEAP_PANIC(ETHeapBadAllocatedCellSize));
-	__SIMULATE_ALLOC_FAIL(return NULL;)
-	Lock();
-	__ALLOC_DEBUG_HEADER(aSize);
-	TAny* addr = DlMalloc(aSize);
-	if ( addr )
-		{
-//		iCellCount++;
-		__SET_DEBUG_DATA(addr, iNestingLevel, ++iAllocCount);
-		addr = __GET_USER_DATA_BFR(addr);
-		__INCREMENT_COUNTERS(addr);
-		memclr(addr, AllocLen(addr));
-		}
-	Unlock();
-#ifdef ENABLE_BTRACE
-	if (iFlags & ETraceAllocs)
-		{
-		if ( addr )
-			{
-			TUint32 traceData[3];
-			traceData[0] = AllocLen(addr);
-			traceData[1] = aSize - __DEBUG_HDR_SIZE;
-			traceData[2] = 0;
-			BTraceContextN(BTrace::EHeap, BTrace::EHeapAlloc, (TUint32)this, (TUint32)addr, traceData, sizeof(traceData));
-			}
-		else
-			BTraceContext8(BTrace::EHeap, BTrace::EHeapAllocFail, (TUint32)this, (TUint32)(aSize - __DEBUG_HDR_SIZE));			
-		}
-#endif
-	return addr;
-}
-#else
-
-TAny* RHybridHeap::Alloc(TInt aSize)
-{
-	__ASSERT_ALWAYS((TUint)aSize<(KMaxTInt/2),HEAP_PANIC(ETHeapBadAllocatedCellSize));
-	__SIMULATE_ALLOC_FAIL(return NULL;)
-			
-	TAny* addr;
-#ifdef ENABLE_BTRACE
-	TInt aSubAllocator=0;
-#endif
-	
-	Lock();
-	
-	__ALLOC_DEBUG_HEADER(aSize);
-	
-	if (aSize < iSlabThreshold)
-		{
-		TInt ix = iSizeMap[(aSize+3)>>2];
-		HEAP_ASSERT(ix != 0xff);
-		addr = SlabAllocate(iSlabAlloc[ix]);
-		if ( !addr )
-			{ // Slab allocation has failed, try to allocate from DL
-			addr = DlMalloc(aSize);
-			}
-#ifdef ENABLE_BTRACE
-		else
-			aSubAllocator=1;
-#endif
-		}else if((aSize >> iPageThreshold)==0)
-			{
-			addr = DlMalloc(aSize);
-			}
-		else
-			{
-			addr = PagedAllocate(aSize);
-			if ( !addr )
-				{ // Page allocation has failed, try to allocate from DL
-				addr = DlMalloc(aSize);
-				}
-#ifdef ENABLE_BTRACE
-			else
-	      		aSubAllocator=2;
-#endif
-			}
-	
-	if ( addr )
-		{
-//		iCellCount++;
-		__SET_DEBUG_DATA(addr, iNestingLevel, ++iAllocCount);
-		addr = __GET_USER_DATA_BFR(addr);
-		__INCREMENT_COUNTERS(addr);
-		}
-	Unlock();
-	
-#ifdef ENABLE_BTRACE
-	if (iFlags & ETraceAllocs)
-		{
-		if ( addr )
-			{
-		    TUint32 traceData[3];
-		    traceData[0] = AllocLen(addr);
-		    traceData[1] = aSize - __DEBUG_HDR_SIZE;
-			traceData[2] = aSubAllocator;
-		    BTraceContextN(BTrace::EHeap, BTrace::EHeapAlloc, (TUint32)this, (TUint32)addr, traceData, sizeof(traceData));
-			}
-		else
-			BTraceContext8(BTrace::EHeap, BTrace::EHeapAllocFail, (TUint32)this, (TUint32)(aSize - __DEBUG_HDR_SIZE));			
-		}
-#endif
-	
-	return addr;
-}
-#endif // __KERNEL_MODE__
-
-#ifndef __KERNEL_MODE__
-TInt RHybridHeap::Compress()
-{
-	if ( IS_FIXED_HEAP )
-		return 0;
-	
-	Lock();
-	TInt Reduced = SysTrim(GM, 0);
-	if (iSparePage)
-		{
-		Unmap(iSparePage, iPageSize);
-		iSparePage = 0;
-		Reduced += iPageSize;
-		}
-	Unlock();
-	return Reduced;
-}
-#endif
-
-void RHybridHeap::Free(TAny* aPtr)
-{
-	__CHECK_THREAD_STATE;
-	if ( !aPtr )
-		return;
-#ifdef ENABLE_BTRACE
-	TInt aSubAllocator=0;
-#endif
-	Lock();
-	
-	aPtr = __GET_DEBUG_DATA_BFR(aPtr);
-
-#ifndef __KERNEL_MODE__				
-	if (PtrDiff(aPtr, this) >= 0)
-		{
-#endif
-		__DL_BFR_CHECK(GM, aPtr);
-		__DECREMENT_COUNTERS(__GET_USER_DATA_BFR(aPtr));
-		__ZAP_CELL(aPtr);		
-		DlFree( aPtr);
-#ifndef __KERNEL_MODE__			
-		}
-
-	else if ( LowBits(aPtr, iPageSize) == 0 )
-		{
-#ifdef ENABLE_BTRACE
-		aSubAllocator = 2;
-#endif
-		__PAGE_BFR_CHECK(aPtr);	
-		__DECREMENT_COUNTERS(__GET_USER_DATA_BFR(aPtr));
-		PagedFree(aPtr);
-		}
-	else
-		{
-#ifdef ENABLE_BTRACE
-		aSubAllocator = 1;
-#endif
-		TUint32 bm[4];   		
-		__SLAB_BFR_CHECK(slab::SlabFor(aPtr),aPtr,bm);
-		__DECREMENT_COUNTERS(__GET_USER_DATA_BFR(aPtr));  
-		__ZAP_CELL(aPtr);		
-		SlabFree(aPtr);
-		}
-#endif  // __KERNEL_MODE__	
-//	iCellCount--;
-	Unlock();
-#ifdef ENABLE_BTRACE
-	if (iFlags & ETraceAllocs)
-		{
-		TUint32 traceData;
-		traceData = aSubAllocator;
-		BTraceContextN(BTrace::EHeap, BTrace::EHeapFree, (TUint32)this, (TUint32)__GET_USER_DATA_BFR(aPtr), &traceData, sizeof(traceData));
-		}
-#endif
-}
-
-#ifndef __KERNEL_MODE__
-void RHybridHeap::Reset()
-/**
-Frees all allocated cells on this heap.
-*/
-{
-	Lock();
-	if ( !IS_FIXED_HEAP )
-		{
-		if ( GM->iSeg.iSize > (iMinLength - sizeof(*this)) )
-			Unmap(GM->iSeg.iBase + (iMinLength - sizeof(*this)), (GM->iSeg.iSize - (iMinLength - sizeof(*this))));
-		ResetBitmap();
-		if ( !iDLOnly )
-			Init(iSlabConfigBits, iPageThreshold);
-		else
-			Init(0,0);		
-		}
-	else Init(0,0);
-	Unlock();	
-}
-#endif
-
-TAny* RHybridHeap::ReAllocImpl(TAny* aPtr, TInt aSize, TInt aMode)
-{
-	// First handle special case of calling reallocate with NULL aPtr
-	if (!aPtr)
-		{
-		if (( aMode & ENeverMove ) == 0 )
-			{
-			aPtr = Alloc(aSize - __DEBUG_HDR_SIZE);
-			aPtr = __GET_DEBUG_DATA_BFR(aPtr);
-			}
-		return aPtr;
-		}
-	
-	TInt oldsize = AllocLen(__GET_USER_DATA_BFR(aPtr)) + __DEBUG_HDR_SIZE;
-	
-	// Insist on geometric growth when reallocating memory, this reduces copying and fragmentation
-	// generated during arithmetic growth of buffer/array/vector memory
-	// Experiments have shown that 25% is a good threshold for this policy
-	if (aSize <= oldsize)
-		{
-		if (aSize >= oldsize - (oldsize>>2))
-			return aPtr;		// don't change if >75% original size
-		}
-	else
-		{
-		__SIMULATE_ALLOC_FAIL(return NULL;)
-		if (aSize < oldsize + (oldsize>>2))
-			{
-			aSize = _ALIGN_UP(oldsize + (oldsize>>2), 4);	// grow to at least 125% original size
-			}
-		}
-	__DEBUG_SAVE(aPtr);		
-	
-	TAny* newp;
-#ifdef __KERNEL_MODE__
-	Lock();
-	__DL_BFR_CHECK(GM, aPtr);				
-	newp = DlRealloc(aPtr, aSize, aMode);
-	Unlock();
-	if ( newp )
-		{
-	    if ( aSize > oldsize )
-			memclr(((TUint8*)newp) + oldsize, (aSize-oldsize)); // Buffer has grown in place, clear extra
-		__DEBUG_RESTORE(newp);
-		__UPDATE_ALLOC_COUNT(aPtr, newp, ++iAllocCount);
-		__UPDATE_TOTAL_ALLOC(newp, oldsize);
-		}
-#else
-	// Decide how to reallocate based on (a) the current cell location, (b) the mode requested and (c) the new size
-	if ( PtrDiff(aPtr, this) >= 0 )
-		{	// current cell in Doug Lea iArena
-		if ( (aMode & ENeverMove) 
-			 ||
-			 (!(aMode & EAllowMoveOnShrink) && (aSize < oldsize))
-			 ||
-			 ((aSize >= iSlabThreshold) && ((aSize >> iPageThreshold) == 0)) )
-			{
-			Lock();
-			__DL_BFR_CHECK(GM, aPtr);			
-			newp = DlRealloc(aPtr, aSize, aMode);			// old and new in DL allocator
-			Unlock();
-			__DEBUG_RESTORE(newp);
-			__UPDATE_ALLOC_COUNT(aPtr,newp, ++iAllocCount);
-			__UPDATE_TOTAL_ALLOC(newp, oldsize);
-			return newp;
-			}
-		}
-	else if (LowBits(aPtr, iPageSize) == 0)
-		{	// current cell in paged iArena
-		if ( (aMode & ENeverMove)     
-			 ||
-			 (!(aMode & EAllowMoveOnShrink) && (aSize < oldsize)) 
-			 ||
-			 ((aSize >> iPageThreshold) != 0) )
-			{
-			Lock();
-			__PAGE_BFR_CHECK(aPtr);			
-			newp = PagedReallocate(aPtr, aSize, aMode);		// old and new in paged allocator
-			Unlock();
-			__DEBUG_RESTORE(newp);
-			__UPDATE_ALLOC_COUNT(aPtr,newp, ++iAllocCount);
-			__UPDATE_TOTAL_ALLOC(newp, oldsize);
-			return newp;
-			}
-		}
-	else
-		{	// current cell in slab iArena
-		TUint32 bm[4];
-		Lock();
-		__SLAB_BFR_CHECK(slab::SlabFor(aPtr), aPtr, bm);
-		Unlock();
-		if ( aSize <= oldsize)
-			return aPtr;
-		if (aMode & ENeverMove)
-			return NULL;		// cannot grow in slab iArena
-		// just use alloc/copy/free...
-		}
-	
-	// fallback to allocate and copy
-	// shouldn't get here if we cannot move the cell
-	//  	__ASSERT(mode == emobile || (mode==efixshrink && size>oldsize));
-	
-	newp = Alloc(aSize - __DEBUG_HDR_SIZE);
-	newp = __GET_DEBUG_DATA_BFR(newp);
-	if (newp)
-		{
-		memcpy(newp, aPtr, oldsize<aSize ? oldsize : aSize);
-		__DEBUG_RESTORE(newp);
-		Free(__GET_USER_DATA_BFR(aPtr));
-		}
-	
-#endif	// __KERNEL_MODE__
-	return newp;
-}
-
-
-TAny* RHybridHeap::ReAlloc(TAny* aPtr, TInt aSize, TInt aMode )
-{
-	
-	aPtr = __GET_DEBUG_DATA_BFR(aPtr);
-	__ALLOC_DEBUG_HEADER(aSize);
-	
-	TAny* retval = ReAllocImpl(aPtr, aSize, aMode);
-	
-	retval = __GET_USER_DATA_BFR(retval);
-	
-#ifdef ENABLE_BTRACE
-	if (iFlags & ETraceAllocs)
-		{
-		if ( retval )
-			{
-			TUint32 traceData[3];
-			traceData[0] = AllocLen(retval);
-			traceData[1] = aSize - __DEBUG_HDR_SIZE;
-			traceData[2] = (TUint32)aPtr;
-			BTraceContextN(BTrace::EHeap, BTrace::EHeapReAlloc,(TUint32)this, (TUint32)retval, traceData, sizeof(traceData));
-			}
-  		else
-  		    BTraceContext12(BTrace::EHeap, BTrace::EHeapReAllocFail, (TUint32)this, (TUint32)aPtr, (TUint32)(aSize - __DEBUG_HDR_SIZE));
-		}
-#endif
-	return retval;
-}
-
-#ifndef __KERNEL_MODE__
-TInt RHybridHeap::Available(TInt& aBiggestBlock) const
-/**
-Gets the total free space currently available on the heap and the space
-available in the largest free block.
-
-Note that this function exists mainly for compatibility reasons.  In a modern
-heap implementation such as that present in Symbian it is not appropriate to
-concern oneself with details such as the amount of free memory available on a
-heap and its largeset free block, because the way that a modern heap implmentation
-works is not simple.  The amount of available virtual memory != physical memory
-and there are multiple allocation strategies used internally, which makes all
-memory usage figures "fuzzy" at best.
-
-In short, if you want to see if there is enough memory available to allocate a
-block of memory, call Alloc() and if it succeeds then there is enough memory!
-Messing around with functions like this is somewhat pointless with modern heap
-allocators.
-
-@param aBiggestBlock On return, contains the space available in the largest
-                     free block on the heap.  Due to the internals of modern
-                     heap implementations, you can probably still allocate a
-                     block larger than this!
-
-@return The total free space currently available on the heap.  Again, you can
-        probably still allocate more than this!
-*/
-{
-	struct HeapInfo info;
-	Lock();
-	TInt Biggest  = GetInfo(&info);
-	aBiggestBlock = __GET_AVAIL_BLOCK_SIZE(Biggest);
-	Unlock();
-	return __GET_AVAIL_BLOCK_SIZE(info.iFreeBytes);
-	
-}
-
-TInt RHybridHeap::AllocSize(TInt& aTotalAllocSize) const
-   /**
-   Gets the number of cells allocated on this heap, and the total space 
-   allocated to them.
-   
-   @param aTotalAllocSize On return, contains the total space allocated
-   to the cells.
-   
-   @return The number of cells allocated on this heap.
-*/   
-{
-	struct HeapInfo info;
-	Lock();
-	GetInfo(&info);
-	aTotalAllocSize = info.iAllocBytes - __REMOVE_DBG_HDR(info.iAllocN);
-	Unlock();
-	return info.iAllocN;
-}
-
-#endif
-
-TInt RHybridHeap::Extension_(TUint /* aExtensionId */, TAny*& /* a0 */, TAny* /* a1 */)
-{
-	return KErrNotSupported;
-}
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-// imported from dla.cpp
-///////////////////////////////////////////////////////////////////////////////
-
-//#include <unistd.h>
-//#define DEBUG_REALLOC
-#ifdef DEBUG_REALLOC
-#include <e32debug.h>
-#endif
-
-inline void RHybridHeap::InitBins(mstate m)
-{
-	/* Establish circular links for iSmallBins */
-	bindex_t i;
-	for (i = 0; i < NSMALLBINS; ++i) {
-		sbinptr bin = SMALLBIN_AT(m,i);
-		bin->iFd = bin->iBk = bin;
-		}
-	}
-/* ---------------------------- malloc support --------------------------- */
-
-/* allocate a large request from the best fitting chunk in a treebin */
-void* RHybridHeap::TmallocLarge(mstate m, size_t nb) {
-	tchunkptr v = 0;
-	size_t rsize = -nb; /* Unsigned negation */
-	tchunkptr t;
-	bindex_t idx;
-	ComputeTreeIndex(nb, idx);
-	
-	if ((t = *TREEBIN_AT(m, idx)) != 0)
-		{
-		/* Traverse tree for this bin looking for node with size == nb */
-		size_t sizebits = nb << LEFTSHIFT_FOR_TREE_INDEX(idx);
-		tchunkptr rst = 0;  /* The deepest untaken right subtree */
-		for (;;)
-			{
-			tchunkptr rt;
-			size_t trem = CHUNKSIZE(t) - nb;
-			if (trem < rsize)
-				{
-				v = t;
-				if ((rsize = trem) == 0)
-					break;
-				}
-			rt = t->iChild[1];
-			t = t->iChild[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1];
-			if (rt != 0 && rt != t)
-				rst = rt;
-			if (t == 0)
-				{
-				t = rst; /* set t to least subtree holding sizes > nb */
-				break;
-				}
-			sizebits <<= 1;
-			}
-		}
-	if (t == 0 && v == 0)
-		{ /* set t to root of next non-empty treebin */
-		binmap_t leftbits = LEFT_BITS(IDX2BIT(idx)) & m->iTreeMap;
-		if (leftbits != 0)
-			{
-			bindex_t i;
-			binmap_t leastbit = LEAST_BIT(leftbits);
-			ComputeBit2idx(leastbit, i);
-			t = *TREEBIN_AT(m, i);
-			}
-		}
-	while (t != 0)
-		{ /* Find smallest of tree or subtree */
-		size_t trem = CHUNKSIZE(t) - nb;
-		if (trem < rsize) {
-			rsize = trem;
-			v = t;
-			}
-		t = LEFTMOST_CHILD(t);
-		}
-	/*  If iDv is a better fit, return 0 so malloc will use it */
-	if (v != 0 && rsize < (size_t)(m->iDvSize - nb))
-		{
-		if (RTCHECK(OK_ADDRESS(m, v)))
-			{ /* split */
-			mchunkptr r = CHUNK_PLUS_OFFSET(v, nb);
-			HEAP_ASSERT(CHUNKSIZE(v) == rsize + nb);
-			if (RTCHECK(OK_NEXT(v, r)))
-				{
-				UnlinkLargeChunk(m, v);
-				if (rsize < MIN_CHUNK_SIZE)
-					SET_INUSE_AND_PINUSE(m, v, (rsize + nb));
-				else
-					{
-					SET_SIZE_AND_PINUSE_OF_INUSE_CHUNK(m, v, nb);
-					SET_SIZE_AND_PINUSE_OF_FREE_CHUNK(r, rsize);
-					InsertChunk(m, r, rsize);
-					}
-				return CHUNK2MEM(v);
-				}
-			}
-		//    CORRUPTION_ERROR_ACTION(m);
-		}
-	return 0;
-	}
-
-/* allocate a small request from the best fitting chunk in a treebin */
-void* RHybridHeap::TmallocSmall(mstate m, size_t nb)
-{
-	tchunkptr t, v;
-	size_t rsize;
-	bindex_t i;
-	binmap_t leastbit = LEAST_BIT(m->iTreeMap);
-	ComputeBit2idx(leastbit, i);
-	
-	v = t = *TREEBIN_AT(m, i);
-	rsize = CHUNKSIZE(t) - nb;
-	
-	while ((t = LEFTMOST_CHILD(t)) != 0)
-		{
-		size_t trem = CHUNKSIZE(t) - nb;
-		if (trem < rsize)
-			{
-			rsize = trem;
-			v = t;
-			}
-		}
-	
-	if (RTCHECK(OK_ADDRESS(m, v)))
-		{
-		mchunkptr r = CHUNK_PLUS_OFFSET(v, nb);
-		HEAP_ASSERT(CHUNKSIZE(v) == rsize + nb);
-		if (RTCHECK(OK_NEXT(v, r)))
-			{
-			UnlinkLargeChunk(m, v);
-			if (rsize < MIN_CHUNK_SIZE)
-				SET_INUSE_AND_PINUSE(m, v, (rsize + nb));
-			else
-				{
-				SET_SIZE_AND_PINUSE_OF_INUSE_CHUNK(m, v, nb);
-				SET_SIZE_AND_PINUSE_OF_FREE_CHUNK(r, rsize);
-				ReplaceDv(m, r, rsize);
-				}
-			return CHUNK2MEM(v);
-			}
-		}
-	//  CORRUPTION_ERROR_ACTION(m);
-	//  return 0;
-	}
-
-inline void RHybridHeap::InitTop(mstate m, mchunkptr p, size_t psize)
-{
-	/* Ensure alignment */
-	size_t offset = ALIGN_OFFSET(CHUNK2MEM(p));
-	p = (mchunkptr)((TUint8*)p + offset);
-	psize -= offset;
-	m->iTop = p;
-	m->iTopSize = psize;
-	p->iHead = psize | PINUSE_BIT;
-	/* set size of fake trailing chunk holding overhead space only once */
-	mchunkptr chunkPlusOff = CHUNK_PLUS_OFFSET(p, psize);
-	chunkPlusOff->iHead = TOP_FOOT_SIZE;
-	m->iTrimCheck = KHeapShrinkHysRatio*(iGrowBy>>8);
-}
-
-
-/* Unlink the first chunk from a smallbin */
-inline void RHybridHeap::UnlinkFirstSmallChunk(mstate M,mchunkptr B,mchunkptr P,bindex_t& I)
-{
-	mchunkptr F = P->iFd;
-	HEAP_ASSERT(P != B);
-	HEAP_ASSERT(P != F);
-	HEAP_ASSERT(CHUNKSIZE(P) == SMALL_INDEX2SIZE(I));
-	if (B == F)
-		CLEAR_SMALLMAP(M, I);
-	else if (RTCHECK(OK_ADDRESS(M, F)))
-		{
-		B->iFd = F;
-		F->iBk = B;
-		}
-	else
-		{
-		CORRUPTION_ERROR_ACTION(M);
-		}
-}
-/* Link a free chunk into a smallbin  */
-inline void RHybridHeap::InsertSmallChunk(mstate M,mchunkptr P, size_t S)
-{
-	bindex_t I  = SMALL_INDEX(S);
-	mchunkptr B = SMALLBIN_AT(M, I);
-	mchunkptr F = B;
-	HEAP_ASSERT(S >= MIN_CHUNK_SIZE);
-	if (!SMALLMAP_IS_MARKED(M, I))
-		MARK_SMALLMAP(M, I);
-	else if (RTCHECK(OK_ADDRESS(M, B->iFd)))
-		F = B->iFd;
-	else
-		{
-		CORRUPTION_ERROR_ACTION(M);
-		}
-	B->iFd = P;
-	F->iBk = P;
-	P->iFd = F;
-	P->iBk = B;
-}
-
-
-inline void RHybridHeap::InsertChunk(mstate M,mchunkptr P,size_t S)
-{
-	if (IS_SMALL(S))
-		InsertSmallChunk(M, P, S);
-	else
-		{
-		tchunkptr TP = (tchunkptr)(P); InsertLargeChunk(M, TP, S);
-		}
-}
-
-inline void RHybridHeap::UnlinkLargeChunk(mstate M,tchunkptr X)
-{
-	tchunkptr XP = X->iParent;
-	tchunkptr R;
-	if (X->iBk != X)
-		{
-		tchunkptr F = X->iFd;
-		R = X->iBk;
-		if (RTCHECK(OK_ADDRESS(M, F)))
-			{
-			F->iBk = R;
-			R->iFd = F;
-			}
-		else
-			{
-			CORRUPTION_ERROR_ACTION(M);
-			}
-		}
-	else
-		{
-		tchunkptr* RP;
-		if (((R = *(RP = &(X->iChild[1]))) != 0) ||
-			  ((R = *(RP = &(X->iChild[0]))) != 0))
-			{
-			tchunkptr* CP;
-			while ((*(CP = &(R->iChild[1])) != 0) ||
-				   (*(CP = &(R->iChild[0])) != 0))
-				{
-				R = *(RP = CP);
-				}
-			if (RTCHECK(OK_ADDRESS(M, RP)))
-				*RP = 0;
-			else
-				{
-				CORRUPTION_ERROR_ACTION(M);
-				}
-			}
-		}
-	if (XP != 0)
-		{
-		tbinptr* H = TREEBIN_AT(M, X->iIndex);
-		if (X == *H)
-			{
-			if ((*H = R) == 0)
-				CLEAR_TREEMAP(M, X->iIndex);
-			}
-		else if (RTCHECK(OK_ADDRESS(M, XP)))
-			{
-			if (XP->iChild[0] == X)
-				XP->iChild[0] = R;
-			else
-				XP->iChild[1] = R;
-			}
-		else
-			CORRUPTION_ERROR_ACTION(M);
-		if (R != 0)
-			{
-			if (RTCHECK(OK_ADDRESS(M, R)))
-				{
-				tchunkptr C0, C1;
-				R->iParent = XP;
-				if ((C0 = X->iChild[0]) != 0)
-					{
-					if (RTCHECK(OK_ADDRESS(M, C0)))
-						{
-						R->iChild[0] = C0;
-						C0->iParent = R;
-						}
-					else
-						CORRUPTION_ERROR_ACTION(M);
-					}
-				if ((C1 = X->iChild[1]) != 0)
-					{
-					if (RTCHECK(OK_ADDRESS(M, C1)))
-						{
-						R->iChild[1] = C1;
-						C1->iParent = R;
-						}
-					else
-						CORRUPTION_ERROR_ACTION(M);
-					}
-				}
-			else
-				CORRUPTION_ERROR_ACTION(M);
-			}
-		}
-}
-
-/* Unlink a chunk from a smallbin  */
-inline void RHybridHeap::UnlinkSmallChunk(mstate M, mchunkptr P,size_t S)
-{
-	mchunkptr F = P->iFd;
-	mchunkptr B = P->iBk;
-	bindex_t I = SMALL_INDEX(S);
-	HEAP_ASSERT(P != B);
-	HEAP_ASSERT(P != F);
-	HEAP_ASSERT(CHUNKSIZE(P) == SMALL_INDEX2SIZE(I));
-	if (F == B)
-		CLEAR_SMALLMAP(M, I);
-	else if (RTCHECK((F == SMALLBIN_AT(M,I) || OK_ADDRESS(M, F)) &&
-					 (B == SMALLBIN_AT(M,I) || OK_ADDRESS(M, B))))
-		{
-		F->iBk = B;
-		B->iFd = F;
-		}
-	else
-		{
-		CORRUPTION_ERROR_ACTION(M);
-		}
-}
-
-inline void RHybridHeap::UnlinkChunk(mstate M, mchunkptr P, size_t S)
-{
-	if (IS_SMALL(S))
-		UnlinkSmallChunk(M, P, S);
-	else
-		{
-		tchunkptr TP = (tchunkptr)(P); UnlinkLargeChunk(M, TP);
-		}
-}
-
-// For DL debug functions
-void RHybridHeap::DoComputeTreeIndex(size_t S, bindex_t& I)
-{
-	ComputeTreeIndex(S, I);
-}	
-
-inline void RHybridHeap::ComputeTreeIndex(size_t S, bindex_t& I)
-{
-	size_t X = S >> TREEBIN_SHIFT;
-	if (X == 0)
-		I = 0;
-	else if (X > 0xFFFF)
-		I = NTREEBINS-1;
-	else
-		{
-		unsigned int Y = (unsigned int)X;
-		unsigned int N = ((Y - 0x100) >> 16) & 8;
-		unsigned int K = (((Y <<= N) - 0x1000) >> 16) & 4;
-		N += K;
-		N += K = (((Y <<= K) - 0x4000) >> 16) & 2;
-		K = 14 - N + ((Y <<= K) >> 15);
-		I = (K << 1) + ((S >> (K + (TREEBIN_SHIFT-1)) & 1));
-		}
-}
-
-/* ------------------------- Operations on trees ------------------------- */
-
-/* Insert chunk into tree */
-inline void RHybridHeap::InsertLargeChunk(mstate M,tchunkptr X,size_t S)
-{
-	tbinptr* H;
-	bindex_t I;
-	ComputeTreeIndex(S, I);
-	H = TREEBIN_AT(M, I);
-	X->iIndex = I;
-	X->iChild[0] = X->iChild[1] = 0;
-	if (!TREEMAP_IS_MARKED(M, I))
-		{
-		MARK_TREEMAP(M, I);
-		*H = X;
-		X->iParent = (tchunkptr)H;
-		X->iFd = X->iBk = X;
-		}
-	else
-		{
-		tchunkptr T = *H;
-		size_t K = S << LEFTSHIFT_FOR_TREE_INDEX(I);
-		for (;;)
-			{
-			if (CHUNKSIZE(T) != S) {
-				tchunkptr* C = &(T->iChild[(K >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]);
-				K <<= 1;
-				if (*C != 0)
-					T = *C;
-				else if (RTCHECK(OK_ADDRESS(M, C)))
-					{
-					*C = X;
-					X->iParent = T;
-					X->iFd = X->iBk = X;
-					break;
-					}
-				else
-					{
-					CORRUPTION_ERROR_ACTION(M);
-					break;
-					}
-				}
-			else
-				{
-				tchunkptr F = T->iFd;
-				if (RTCHECK(OK_ADDRESS(M, T) && OK_ADDRESS(M, F)))
-					{
-					T->iFd = F->iBk = X;
-					X->iFd = F;
-					X->iBk = T;
-					X->iParent = 0;
-					break;
-					}
-				else
-					{
-					CORRUPTION_ERROR_ACTION(M);
-					break;
-					}
-				}
-			}
-		}
-}
-
-/*
-Unlink steps:
-
-1. If x is a chained node, unlink it from its same-sized iFd/iBk links
-and choose its iBk node as its replacement.
-2. If x was the last node of its size, but not a leaf node, it must
-be replaced with a leaf node (not merely one with an open left or
-right), to make sure that lefts and rights of descendents
-correspond properly to bit masks.  We use the rightmost descendent
-of x.  We could use any other leaf, but this is easy to locate and
-tends to counteract removal of leftmosts elsewhere, and so keeps
-paths shorter than minimally guaranteed.  This doesn't loop much
-because on average a node in a tree is near the bottom.
-3. If x is the base of a chain (i.e., has iParent links) relink
-x's iParent and children to x's replacement (or null if none).
-*/
-
-/* Replace iDv node, binning the old one */
-/* Used only when iDvSize known to be small */
-inline void RHybridHeap::ReplaceDv(mstate M, mchunkptr P, size_t S)
-{
-	size_t DVS = M->iDvSize;
-	if (DVS != 0)
-		{
-		mchunkptr DV = M->iDv;
-		HEAP_ASSERT(IS_SMALL(DVS));
-		InsertSmallChunk(M, DV, DVS);
-		}
-	M->iDvSize = S;
-	M->iDv = P;
-}
-
-
-inline void RHybridHeap::ComputeBit2idx(binmap_t X,bindex_t& I)
-{
-	unsigned int Y = X - 1;
-	unsigned int K = Y >> (16-4) & 16;
-	unsigned int N = K;        Y >>= K;
-	N += K = Y >> (8-3) &  8;  Y >>= K;
-	N += K = Y >> (4-2) &  4;  Y >>= K;
-	N += K = Y >> (2-1) &  2;  Y >>= K;
-	N += K = Y >> (1-0) &  1;  Y >>= K;
-	I = (bindex_t)(N + Y);
-}
-
-
-
-int RHybridHeap::SysTrim(mstate m, size_t pad)
-{
-	size_t extra = 0;
-	
-	if ( IS_INITIALIZED(m) )
-		{
-		pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */
-		
-		if (m->iTopSize > pad)
-			{
-			extra = Floor(m->iTopSize - pad, iPageSize);
-			if ( (m->iSeg.iSize - extra) < (iMinLength - sizeof(*this)) )			  
-				{
-				if ( m->iSeg.iSize > (iMinLength - sizeof(*this)) )				  
-					extra = Floor(m->iSeg.iSize - (iMinLength - sizeof(*this)), iPageSize); /* do not shrink heap below min length */
-				else extra = 0;
-				}
-			
-			if ( extra )
-				{
-				Unmap(m->iSeg.iBase + m->iSeg.iSize - extra, extra);
-				
-				m->iSeg.iSize -= extra;
-				InitTop(m, m->iTop, m->iTopSize - extra);
-				CHECK_TOP_CHUNK(m, m->iTop);
-				}
-			}
-		
-		}
-	
-	return extra;
-}
-
-/* Get memory from system using MORECORE */
-
-void* RHybridHeap::SysAlloc(mstate m, size_t nb)
-{
-	HEAP_ASSERT(m->iTop);
-	/* Subtract out existing available iTop space from MORECORE request. */
-//	size_t asize = _ALIGN_UP(nb - m->iTopSize + TOP_FOOT_SIZE + SIZE_T_ONE, iGrowBy);  
-  	TInt asize = _ALIGN_UP(nb - m->iTopSize + SYS_ALLOC_PADDING, iGrowBy);  // From DLA version 2.8.4
-	
-	char* br = (char*)Map(m->iSeg.iBase+m->iSeg.iSize, asize);
-	if (!br)
-		return 0;
-	HEAP_ASSERT(br == (char*)m->iSeg.iBase+m->iSeg.iSize);
-	
-	/* Merge with an existing segment */
-	m->iSeg.iSize += asize;
-	InitTop(m, m->iTop, m->iTopSize + asize);
-	
-	if (nb < m->iTopSize)
-		{ /* Allocate from new or extended iTop space */
-		size_t rsize = m->iTopSize -= nb;
-		mchunkptr p = m->iTop;
-		mchunkptr r = m->iTop = CHUNK_PLUS_OFFSET(p, nb);
-		r->iHead = rsize | PINUSE_BIT;
-		SET_SIZE_AND_PINUSE_OF_INUSE_CHUNK(m, p, nb);
-		CHECK_TOP_CHUNK(m, m->iTop);
-		CHECK_MALLOCED_CHUNK(m, CHUNK2MEM(p), nb);
-		return CHUNK2MEM(p);
-		}
-	
-	return 0;
-}	
-
-
-void RHybridHeap::InitDlMalloc(size_t capacity, int /*locked*/)
-{
-	memset(GM,0,sizeof(malloc_state));
-	// The maximum amount that can be allocated can be calculated as:-
-	// 2^sizeof(size_t) - sizeof(malloc_state) - TOP_FOOT_SIZE - page Size(all accordingly padded)
-	// If the capacity exceeds this, no allocation will be done.
-	GM->iSeg.iBase = iBase;
-	GM->iSeg.iSize = capacity;
-	InitBins(GM);
-	InitTop(GM, (mchunkptr)iBase, capacity - TOP_FOOT_SIZE);
-}
-
-void* RHybridHeap::DlMalloc(size_t bytes) 
-{
-	/*
-	Basic algorithm:
-	If a small request (< 256 bytes minus per-chunk overhead):
-	1. If one exists, use a remainderless chunk in associated smallbin.
-	(Remainderless means that there are too few excess bytes to
-	represent as a chunk.)
-	2. If it is big enough, use the iDv chunk, which is normally the
-	chunk adjacent to the one used for the most recent small request.
-	3. If one exists, split the smallest available chunk in a bin,
-	saving remainder in iDv.
-	4. If it is big enough, use the iTop chunk.
-	5. If available, get memory from system and use it
-	Otherwise, for a large request:
-	1. Find the smallest available binned chunk that fits, and use it
-	if it is better fitting than iDv chunk, splitting if necessary.
-	2. If better fitting than any binned chunk, use the iDv chunk.
-	3. If it is big enough, use the iTop chunk.
-	4. If request size >= mmap threshold, try to directly mmap this chunk.
-	5. If available, get memory from system and use it
-*/
-	void* mem;
-	size_t nb;
-	if (bytes <= MAX_SMALL_REQUEST)
-		{
-		bindex_t idx;
-		binmap_t smallbits;
-		nb = (bytes < MIN_REQUEST)? MIN_CHUNK_SIZE : PAD_REQUEST(bytes);
-		idx = SMALL_INDEX(nb);
-		smallbits = GM->iSmallMap >> idx;
-		
-		if ((smallbits & 0x3U) != 0)
-			{ /* Remainderless fit to a smallbin. */
-			mchunkptr b, p;
-			idx += ~smallbits & 1;			 /* Uses next bin if idx empty */
-			b = SMALLBIN_AT(GM, idx);
-			p = b->iFd;
-			HEAP_ASSERT(CHUNKSIZE(p) == SMALL_INDEX2SIZE(idx));
-			UnlinkFirstSmallChunk(GM, b, p, idx);
-			SET_INUSE_AND_PINUSE(GM, p, SMALL_INDEX2SIZE(idx));
-			mem = CHUNK2MEM(p);
-			CHECK_MALLOCED_CHUNK(GM, mem, nb);
-			return mem;
-			}
-		
-		else if (nb > GM->iDvSize)
-			{
-			if (smallbits != 0)
-				{ /* Use chunk in next nonempty smallbin */
-				mchunkptr b, p, r;
-				size_t rsize;
-				bindex_t i;
-				binmap_t leftbits = (smallbits << idx) & LEFT_BITS(IDX2BIT(idx));
-				binmap_t leastbit = LEAST_BIT(leftbits);
-				ComputeBit2idx(leastbit, i);
-				b = SMALLBIN_AT(GM, i);
-				p = b->iFd;
-				HEAP_ASSERT(CHUNKSIZE(p) == SMALL_INDEX2SIZE(i));
-				UnlinkFirstSmallChunk(GM, b, p, i);
-				rsize = SMALL_INDEX2SIZE(i) - nb;
-				/* Fit here cannot be remainderless if 4byte sizes */
-				if (SIZE_T_SIZE != 4 && rsize < MIN_CHUNK_SIZE)
-					SET_INUSE_AND_PINUSE(GM, p, SMALL_INDEX2SIZE(i));
-				else
-					{
-					SET_SIZE_AND_PINUSE_OF_INUSE_CHUNK(GM, p, nb);
-					r = CHUNK_PLUS_OFFSET(p, nb);
-					SET_SIZE_AND_PINUSE_OF_FREE_CHUNK(r, rsize);
-					ReplaceDv(GM, r, rsize);
-					}
-				mem = CHUNK2MEM(p);
-				CHECK_MALLOCED_CHUNK(GM, mem, nb);
-				return mem;
-				}
-			
-			else if (GM->iTreeMap != 0 && (mem = TmallocSmall(GM, nb)) != 0)
-				{
-				CHECK_MALLOCED_CHUNK(GM, mem, nb);
-				return mem;
-				}
-			}
-		}
-	else if (bytes >= MAX_REQUEST)
-		nb = MAX_SIZE_T; /* Too big to allocate. Force failure (in sys alloc) */
-	else
-		{
-		nb = PAD_REQUEST(bytes);
-		if (GM->iTreeMap != 0 && (mem = TmallocLarge(GM, nb)) != 0)
-			{
-			CHECK_MALLOCED_CHUNK(GM, mem, nb);
-			return mem;
-			}
-		}
-	
-	if (nb <= GM->iDvSize)
-		{
-		size_t rsize = GM->iDvSize - nb;
-		mchunkptr p = GM->iDv;
-		if (rsize >= MIN_CHUNK_SIZE)
-			{ /* split iDv */
-			mchunkptr r = GM->iDv = CHUNK_PLUS_OFFSET(p, nb);
-			GM->iDvSize = rsize;
-			SET_SIZE_AND_PINUSE_OF_FREE_CHUNK(r, rsize);
-			SET_SIZE_AND_PINUSE_OF_INUSE_CHUNK(GM, p, nb);
-			}
-		else
-			{ /* exhaust iDv */
-			size_t dvs = GM->iDvSize;
-			GM->iDvSize = 0;
-			GM->iDv = 0;
-			SET_INUSE_AND_PINUSE(GM, p, dvs);
-			}
-		mem = CHUNK2MEM(p);
-		CHECK_MALLOCED_CHUNK(GM, mem, nb);
-		return mem;
-		}
-	
-	else if (nb < GM->iTopSize)
-		{ /* Split iTop */
-		size_t rsize = GM->iTopSize -= nb;
-		mchunkptr p = GM->iTop;
-		mchunkptr r = GM->iTop = CHUNK_PLUS_OFFSET(p, nb);
-		r->iHead = rsize | PINUSE_BIT;
-		SET_SIZE_AND_PINUSE_OF_INUSE_CHUNK(GM, p, nb);
-		mem = CHUNK2MEM(p);
-		CHECK_TOP_CHUNK(GM, GM->iTop);
-		CHECK_MALLOCED_CHUNK(GM, mem, nb);
-		return mem;
-		}
-	
-	return SysAlloc(GM, nb);
-}
-
-
-void RHybridHeap::DlFree(void* mem)
-{
-	/*
-	Consolidate freed chunks with preceeding or succeeding bordering
-	free chunks, if they exist, and then place in a bin.	Intermixed
-	with special cases for iTop, iDv, mmapped chunks, and usage errors.
-*/
-	mchunkptr p	= MEM2CHUNK(mem);
-	CHECK_INUSE_CHUNK(GM, p);
-	if (RTCHECK(OK_ADDRESS(GM, p) && OK_CINUSE(p)))
-		{
-		size_t psize = CHUNKSIZE(p);
-		mchunkptr next = CHUNK_PLUS_OFFSET(p, psize);
-		if (!PINUSE(p))
-			{
-			size_t prevsize = p->iPrevFoot;
-			mchunkptr prev = CHUNK_MINUS_OFFSET(p, prevsize);
-			psize += prevsize;
-			p = prev;
-			if (RTCHECK(OK_ADDRESS(GM, prev)))
-				{ /* consolidate backward */
-				if (p != GM->iDv)
-					{
-					UnlinkChunk(GM, p, prevsize);
-					}
-				else if ((next->iHead & INUSE_BITS) == INUSE_BITS)
-					{
-					GM->iDvSize = psize;
-					SET_FREE_WITH_PINUSE(p, psize, next);
-					return;
-					}
-				}
-			else
-				{
-				USAGE_ERROR_ACTION(GM, p);
-				return;
-				}
-			}
-		
-		if (RTCHECK(OK_NEXT(p, next) && OK_PINUSE(next)))
-			{
-			if (!CINUSE(next))
-				{	/* consolidate forward */
-				if (next == GM->iTop)
-					{
-					size_t tsize = GM->iTopSize += psize;
-					GM->iTop = p;
-					p->iHead = tsize | PINUSE_BIT;
-					if (p == GM->iDv)
-						{
-						GM->iDv = 0;
-						GM->iDvSize = 0;
-						}
-					if ( !IS_FIXED_HEAP && SHOULD_TRIM(GM, tsize)  )					
-						SysTrim(GM, 0);
-					return;
-					}
-				else if (next == GM->iDv)
-					{
-					size_t dsize = GM->iDvSize += psize;
-					GM->iDv = p;
-					SET_SIZE_AND_PINUSE_OF_FREE_CHUNK(p, dsize);
-					return;
-					}
-				else
-					{
-					size_t nsize = CHUNKSIZE(next);
-					psize += nsize;
-					UnlinkChunk(GM, next, nsize);
-					SET_SIZE_AND_PINUSE_OF_FREE_CHUNK(p, psize);
-					if (p == GM->iDv)
-						{
-						GM->iDvSize = psize;
-						return;
-						}
-					}
-				}
-			else
-				SET_FREE_WITH_PINUSE(p, psize, next);
-			InsertChunk(GM, p, psize);
-			CHECK_FREE_CHUNK(GM, p);
-			return;
-			}
-		}
-}
-
-
-void* RHybridHeap::DlRealloc(void* oldmem, size_t bytes, TInt mode)
-{
-	mchunkptr oldp = MEM2CHUNK(oldmem);
-	size_t oldsize = CHUNKSIZE(oldp);
-	mchunkptr next = CHUNK_PLUS_OFFSET(oldp, oldsize);
-	mchunkptr newp = 0;
-	void* extra = 0;
-	
-	/* Try to either shrink or extend into iTop. Else malloc-copy-free */
-	
-	if (RTCHECK(OK_ADDRESS(GM, oldp) && OK_CINUSE(oldp) &&
-				OK_NEXT(oldp, next) && OK_PINUSE(next)))
-		{
-		size_t nb = REQUEST2SIZE(bytes);
-		if (oldsize >= nb) { /* already big enough */
-			size_t rsize = oldsize - nb;
-			newp = oldp;
-			if (rsize >= MIN_CHUNK_SIZE)
-				{     
-				mchunkptr remainder = CHUNK_PLUS_OFFSET(newp, nb);
-				SET_INUSE(GM, newp, nb);
-//				SET_INUSE(GM, remainder, rsize);
- 				SET_INUSE_AND_PINUSE(GM, remainder, rsize);  // corrected in original DLA version V2.8.4
-				extra = CHUNK2MEM(remainder);
-				}
-			}
-		else if (next == GM->iTop && oldsize + GM->iTopSize > nb)
-			{
-			/* Expand into iTop */
-			size_t newsize = oldsize + GM->iTopSize;
-			size_t newtopsize = newsize - nb;
-			mchunkptr newtop = CHUNK_PLUS_OFFSET(oldp, nb);
-			SET_INUSE(GM, oldp, nb);
-			newtop->iHead = newtopsize |PINUSE_BIT;
-			GM->iTop = newtop;
-			GM->iTopSize = newtopsize;
-			newp = oldp;
-			}
-		}
-	else
-		{
-		USAGE_ERROR_ACTION(GM, oldmem);
-		}
-	
-	if (newp != 0)
-		{
-		if (extra != 0)
-			{
-			DlFree(extra);
-			}
-		CHECK_INUSE_CHUNK(GM, newp);
-		return CHUNK2MEM(newp);
-		}
-	else
-		{
-		if ( mode & ENeverMove )
-			return 0;		// cannot move
-		void* newmem = DlMalloc(bytes);
-		if (newmem != 0)
-			{
-			size_t oc = oldsize - OVERHEAD_FOR(oldp);
-			memcpy(newmem, oldmem, (oc < bytes)? oc : bytes);
-			DlFree(oldmem);
-			}
-		return newmem;
-		}
-	//	return 0;
-}
-
-size_t RHybridHeap::DlInfo(struct HeapInfo* i, SWalkInfo* wi) const
-{
-	TInt max = ((GM->iTopSize-1) & ~CHUNK_ALIGN_MASK) - CHUNK_OVERHEAD;
-	if ( max < 0 )
-		max = 0;
-	else ++i->iFreeN;			// iTop always free
-	i->iFreeBytes += max;
-	
-	Walk(wi, GM->iTop, max, EGoodFreeCell, EDougLeaAllocator); // Introduce DL iTop buffer to the walk function 
-	
-	for (mchunkptr q = ALIGN_AS_CHUNK(GM->iSeg.iBase); q != GM->iTop; q = NEXT_CHUNK(q))
-		{
-		TInt sz = CHUNKSIZE(q);
-		if (!CINUSE(q))
-			{
-			if ( sz > max )
-				max = sz;
-			i->iFreeBytes += sz;
-			++i->iFreeN;
-			Walk(wi, CHUNK2MEM(q), sz, EGoodFreeCell, EDougLeaAllocator); // Introduce DL free buffer to the walk function 
-			}
-		else
-			{
-			i->iAllocBytes += sz - CHUNK_OVERHEAD;
-			++i->iAllocN;
-			Walk(wi, CHUNK2MEM(q), (sz- CHUNK_OVERHEAD), EGoodAllocatedCell, EDougLeaAllocator); // Introduce DL allocated buffer to the walk function 
-			}
-		}
-	return max;  // return largest available chunk size
-}
-
-//
-// get statistics about the state of the allocator
-//
-TInt RHybridHeap::GetInfo(struct HeapInfo* i, SWalkInfo* wi) const
-{
-	memset(i,0,sizeof(HeapInfo));
-	i->iFootprint = iChunkSize;
-	i->iMaxSize = iMaxLength;
-#ifndef __KERNEL_MODE__		
-	PagedInfo(i, wi);
-	SlabInfo(i, wi);
-#endif	
-	return DlInfo(i,wi);
-}
-
-//
-// Methods to commit/decommit memory pages from chunk
-//
-
-
-void* RHybridHeap::Map(void* p, TInt sz)
-//
-// allocate pages in the chunk
-// if p is NULL, Find an allocate the required number of pages (which must lie in the lower half)
-// otherwise commit the pages specified
-//
-{
-	HEAP_ASSERT(sz > 0);
-
-	if ( iChunkSize + sz > iMaxLength)
-		return 0;
-
-#ifdef __KERNEL_MODE__
-
-	TInt r = ((DChunk*)iChunkHandle)->Adjust(iChunkSize + iOffset + sz);
-	if (r < 0)
-		return 0;
-
-	iChunkSize += sz;
-	
-#else	
-
-	RChunk chunk;
-	chunk.SetHandle(iChunkHandle);
-	if ( p )
-		{
-		TInt r;
-		if ( iUseAdjust )
-			r = chunk.Adjust(iChunkSize + sz);
-		else
-			{
-			HEAP_ASSERT(sz == Ceiling(sz, iPageSize));
-			HEAP_ASSERT(p == Floor(p, iPageSize));
-			r = chunk.Commit(iOffset + PtrDiff(p, this),sz);
-			}			
-		if (r < 0)
-			return 0;
-		}
-	else
-		{
-		TInt r = chunk.Allocate(sz);
-		if (r < 0)
-			return 0;
-		if (r > iOffset)
-			{
-			// can't allow page allocations in DL zone
-			chunk.Decommit(r, sz);
-			return 0;
-			}
-		p = Offset(this, r - iOffset);
-		}
-	iChunkSize += sz;
-	
-	if (iChunkSize >= iSlabInitThreshold)
-		{	// set up slab system now that heap is large enough
-		SlabConfig(iSlabConfigBits);
-		iSlabInitThreshold = KMaxTInt32;
-		}
-
-#endif //	__KERNEL_MODE__
-	
-#ifdef ENABLE_BTRACE
-	if(iChunkSize > iHighWaterMark)
-		{
-		iHighWaterMark = Ceiling(iChunkSize,16*iPageSize);
-		TUint32 traceData[6];
-		traceData[0] = iChunkHandle;
-		traceData[1] = iMinLength;
-		traceData[2] = iMaxLength;
-		traceData[3] = sz;
-		traceData[4] = iChunkSize;
-		traceData[5] = iHighWaterMark;
-		BTraceContextN(BTrace::ETest1, 90, (TUint32)this, 33, traceData, sizeof(traceData));
-		}
-#endif
-
-	return p;
-}
-
-void RHybridHeap::Unmap(void* p, TInt sz)
-{
-	HEAP_ASSERT(sz > 0);
-	
-#ifdef __KERNEL_MODE__
-	
-	(void)p;
-	HEAP_ASSERT(sz == Ceiling(sz, iPageSize));
-#if defined(_DEBUG)		
-	TInt r =
-#endif				
-   ((DChunk*)iChunkHandle)->Adjust(iChunkSize + iOffset - sz);
-	HEAP_ASSERT(r >= 0);
-	
-#else
-
-	RChunk chunk;
-	chunk.SetHandle(iChunkHandle);
-	if ( iUseAdjust )
-		{
-		HEAP_ASSERT(sz == Ceiling(sz, iPageSize));
-#if defined(_DEBUG)		
-		TInt r =
-#endif				
-		chunk.Adjust(iChunkSize - sz);
-		HEAP_ASSERT(r >= 0);		
-		}
-	else
-		{
-		HEAP_ASSERT(sz == Ceiling(sz, iPageSize));
-		HEAP_ASSERT(p == Floor(p, iPageSize));
-#if defined(_DEBUG)		
-		TInt r =
-#endif
-		chunk.Decommit(PtrDiff(p, Offset(this,-iOffset)), sz);
-		HEAP_ASSERT(r >= 0);				
-		}			
-#endif  // __KERNEL_MODE__
-	
-	iChunkSize -= sz;
-}
-
-
-#ifndef __KERNEL_MODE__
-//
-// Slab allocator code
-//
-
-//inline slab* slab::SlabFor(void* p)
-slab* slab::SlabFor( const void* p)
-{
-	return (slab*)(Floor(p, SLABSIZE));
-}
-
-//
-// Remove slab s from its tree/heap (not necessarily the root), preserving the address order
-// invariant of the heap
-//
-void RHybridHeap::TreeRemove(slab* s)
-{
-	slab** r = s->iParent;
-	slab* c1 = s->iChild1;
-	slab* c2 = s->iChild2;
-	for (;;)
-		{
-		if (!c2)
-			{
-			*r = c1;
-			if (c1)
-				c1->iParent = r;
-			return;
-			}
-		if (!c1)
-			{
-			*r = c2;
-			c2->iParent = r;
-			return;
-			}
-		if (c1 > c2)
-			{
-			slab* c3 = c1;
-			c1 = c2;
-			c2 = c3;
-			}
-		slab* newc2 = c1->iChild2;
-		*r = c1;
-		c1->iParent = r;
-		c1->iChild2 = c2;
-		c2->iParent = &c1->iChild2;
-		s = c1;
-		c1 = s->iChild1;
-		c2 = newc2;
-		r = &s->iChild1;
-		}
-}
-//
-// Insert slab s into the tree/heap rooted at r, preserving the address ordering
-// invariant of the heap
-//
-void RHybridHeap::TreeInsert(slab* s,slab** r)
-{
-	slab* n = *r;
-	for (;;)
-		{
-		if (!n)
-			{	// tree empty
-			*r = s;
-			s->iParent = r;
-			s->iChild1 = s->iChild2 = 0;
-			break;
-			}
-		if (s < n)
-			{	// insert between iParent and n
-			*r = s;
-			s->iParent = r;
-			s->iChild1 = n;
-			s->iChild2 = 0;
-			n->iParent = &s->iChild1;
-			break;
-			}
-		slab* c1 = n->iChild1;
-		slab* c2 = n->iChild2;
-		if ((c1 - 1) > (c2 - 1))
-			{
-			r = &n->iChild1;
-			n = c1;
-			}
-		else
-			{
-			r = &n->iChild2;
-			n = c2;
-			}
-		}
-}
-
-void* RHybridHeap::AllocNewSlab(slabset& allocator)
-//
-// Acquire and initialise a new slab, returning a cell from the slab
-// The strategy is:
-// 1. Use the lowest address free slab, if available. This is done by using the lowest slab
-//    in the page at the root of the iPartialPage heap (which is address ordered). If the
-//    is now fully used, remove it from the iPartialPage heap.
-// 2. Allocate a new page for iSlabs if no empty iSlabs are available
-//
-{
-	page* p = page::PageFor(iPartialPage);
-	if (!p)
-		return AllocNewPage(allocator);
-	
-	unsigned h = p->iSlabs[0].iHeader;
-	unsigned pagemap = SlabHeaderPagemap(h);
-	HEAP_ASSERT(&p->iSlabs[HIBIT(pagemap)] == iPartialPage);
-	
-	unsigned slabix = LOWBIT(pagemap);
-	p->iSlabs[0].iHeader = h &~ (0x100<<slabix);
-	if (!(pagemap &~ (1<<slabix)))
-		{
-		TreeRemove(iPartialPage);	// last free slab in page
-		}
-	
-	return InitNewSlab(allocator, &p->iSlabs[slabix]);
-}
-
-/**Defination of this functionis not there in proto code***/
-#if 0
-void RHybridHeap::partial_insert(slab* s)
-{
-	// slab has had first cell freed and needs to be linked back into iPartial tree
-	slabset& ss = iSlabAlloc[iSizeMap[s->clz]];
-	
-	HEAP_ASSERT(s->used == slabfull);
-	s->used = ss.fulluse - s->clz;		// full-1 loading
-	TreeInsert(s,&ss.iPartial);
-	CHECKTREE(&ss.iPartial);
-}
-/**Defination of this functionis not there in proto code***/
-#endif
-
-void* RHybridHeap::AllocNewPage(slabset& allocator)
-//
-// Acquire and initialise a new page, returning a cell from a new slab
-// The iPartialPage tree is empty (otherwise we'd have used a slab from there)
-// The iPartialPage link is put in the highest addressed slab in the page, and the
-// lowest addressed slab is used to fulfill the allocation request
-//
-{
-	page* p	 = iSparePage;
-	if (p)
-		iSparePage = 0;
-	else
-		{
-		p = static_cast<page*>(Map(0, iPageSize));
-		if (!p)
-			return 0;
-		}
-	HEAP_ASSERT(p == Floor(p, iPageSize));
-	// Store page allocated for slab into paged_bitmap (for RHybridHeap::Reset())
-	if (!PagedSetSize(p, iPageSize))
-		{
-		Unmap(p, iPageSize);
-		return 0;
-		}
-	p->iSlabs[0].iHeader = ((1<<3) + (1<<2) + (1<<1))<<8;		// set pagemap
-	p->iSlabs[3].iParent = &iPartialPage;
-	p->iSlabs[3].iChild1 = p->iSlabs[3].iChild2 = 0;
-	iPartialPage = &p->iSlabs[3];
-	return InitNewSlab(allocator,&p->iSlabs[0]);
-}
-
-void RHybridHeap::FreePage(page* p)
-//
-// Release an unused page to the OS
-// A single page is cached for reuse to reduce thrashing
-// the OS allocator.
-//
-{
-	HEAP_ASSERT(Ceiling(p, iPageSize) == p);
-	if (!iSparePage)
-		{
-		iSparePage = p;
-		return;
-		}
-	
-	// unmapped slab page must be cleared from paged_bitmap, too
-	PagedZapSize(p, iPageSize);		// clear page map
-	
-	Unmap(p, iPageSize);
-}
-
-void RHybridHeap::FreeSlab(slab* s)
-//
-// Release an empty slab to the slab manager
-// The strategy is:
-// 1. The page containing the slab is checked to see the state of the other iSlabs in the page by
-//    inspecting the pagemap field in the iHeader of the first slab in the page.
-// 2. The pagemap is updated to indicate the new unused slab
-// 3. If this is the only unused slab in the page then the slab iHeader is used to add the page to
-//    the iPartialPage tree/heap
-// 4. If all the iSlabs in the page are now unused the page is release back to the OS
-// 5. If this slab has a higher address than the one currently used to track this page in
-//    the iPartialPage heap, the linkage is moved to the new unused slab
-//
-{
-	TreeRemove(s);
-	CHECKTREE(s->iParent);
-	HEAP_ASSERT(SlabHeaderUsedm4(s->iHeader) == SlabHeaderSize(s->iHeader)-4);
-
-	page* p = page::PageFor(s);
-	unsigned h = p->iSlabs[0].iHeader;
-	int slabix = s - &p->iSlabs[0];
-	unsigned pagemap = SlabHeaderPagemap(h);
-	p->iSlabs[0].iHeader = h | (0x100<<slabix);
-	if (pagemap == 0)
-		{	// page was full before, use this slab as link in empty heap
-		TreeInsert(s, &iPartialPage);
-		}
-	else
-		{	// Find the current empty-link slab
-		slab* sl = &p->iSlabs[HIBIT(pagemap)];
-		pagemap ^= (1<<slabix);
-		if (pagemap == 0xf)
-			{	// page is now empty so recycle page to os
-			TreeRemove(sl);
-			FreePage(p);
-			return;
-			}
-		// ensure the free list link is in highest address slab in page
-		if (s > sl)
-			{	// replace current link with new one. Address-order tree so position stays the same
-			slab** r = sl->iParent;
-			slab* c1 = sl->iChild1;
-			slab* c2 = sl->iChild2;
-			s->iParent = r;
-			s->iChild1 = c1;
-			s->iChild2 = c2;
-			*r = s;
-			if (c1)
-				c1->iParent = &s->iChild1;
-			if (c2)
-				c2->iParent = &s->iChild2;
-			}
-		CHECK(if (s < sl) s=sl);
-		}
-	HEAP_ASSERT(SlabHeaderPagemap(p->iSlabs[0].iHeader) != 0);
-	HEAP_ASSERT(HIBIT(SlabHeaderPagemap(p->iSlabs[0].iHeader)) == unsigned(s - &p->iSlabs[0]));
-}
-
-
-void RHybridHeap::SlabInit()
-{
-	iSlabThreshold=0;
-	iPartialPage = 0;
-	iFullSlab = 0;
-	iSparePage = 0;
-	memset(&iSizeMap[0],0xff,sizeof(iSizeMap));
-	memset(&iSlabAlloc[0],0,sizeof(iSlabAlloc));
-}
-
-void RHybridHeap::SlabConfig(unsigned slabbitmap)
-{
-	HEAP_ASSERT((slabbitmap & ~EOkBits) == 0);
-	HEAP_ASSERT(MAXSLABSIZE <= 60);
-	
-	unsigned int ix = 0xff;
-	unsigned int bit = 1<<((MAXSLABSIZE>>2)-1);
-	for (int sz = MAXSLABSIZE; sz >= 0; sz -= 4, bit >>= 1)
-		{
-		if (slabbitmap & bit)
-			{
-			if (ix == 0xff)
-				iSlabThreshold=sz+1;
-			ix = (sz>>2)-1;
-			}
-		iSizeMap[sz>>2] = (TUint8) ix;
-		}
-}
-
-
-void* RHybridHeap::SlabAllocate(slabset& ss)
-//
-// Allocate a cell from the given slabset
-// Strategy:
-// 1. Take the partially full slab at the iTop of the heap (lowest address).
-// 2. If there is no such slab, allocate from a new slab
-// 3. If the slab has a non-empty freelist, pop the cell from the front of the list and update the slab
-// 4. Otherwise, if the slab is not full, return the cell at the end of the currently used region of
-//    the slab, updating the slab
-// 5. Otherwise, release the slab from the iPartial tree/heap, marking it as 'floating' and go back to
-//    step 1
-//
-{
-	for (;;)
-		{
-		slab *s = ss.iPartial;
-		if (!s)
-			break;
-		unsigned h = s->iHeader;
-		unsigned free = h & 0xff;		// extract free cell positioning
-		if (free)
-			{
-			HEAP_ASSERT(((free<<2)-sizeof(slabhdr))%SlabHeaderSize(h) == 0);
-			void* p = Offset(s,free<<2);
-			free = *(unsigned char*)p;	// get next pos in free list
-			h += (h&0x3C000)<<6;		// update usedm4
-			h &= ~0xff;
-			h |= free;					// update freelist
-			s->iHeader = h;
-			HEAP_ASSERT(SlabHeaderFree(h) == 0 || ((SlabHeaderFree(h)<<2)-sizeof(slabhdr))%SlabHeaderSize(h) == 0);
-			HEAP_ASSERT(SlabHeaderUsedm4(h) <= 0x3F8u);
-			HEAP_ASSERT((SlabHeaderUsedm4(h)+4)%SlabHeaderSize(h) == 0);
-			return p;
-			}
-		unsigned h2 = h + ((h&0x3C000)<<6);
-//		if (h2 < 0xfc00000)
-  		if (h2 < MAXUSEDM4BITS)		
-			{
-			HEAP_ASSERT((SlabHeaderUsedm4(h2)+4)%SlabHeaderSize(h2) == 0);
-			s->iHeader = h2;
-			return Offset(s,(h>>18) + sizeof(unsigned) + sizeof(slabhdr));
-			}
-		h |= FLOATING_BIT;				// mark the slab as full-floating
-		s->iHeader = h;
-		TreeRemove(s);
-		slab* c = iFullSlab;			// add to full list
-		iFullSlab = s;
-		s->iParent = &iFullSlab;
-		s->iChild1 = c;
-		s->iChild2 = 0;
-		if (c)
-			c->iParent = &s->iChild1;
-		
-		CHECKTREE(&ss.iPartial);
-		// go back and try the next slab...
-		}
-	// no iPartial iSlabs found, so allocate from a new slab
-	return AllocNewSlab(ss);
-}
-
-void RHybridHeap::SlabFree(void* p)
-//
-// Free a cell from the slab allocator
-// Strategy:
-// 1. Find the containing slab (round down to nearest 1KB boundary)
-// 2. Push the cell into the slab's freelist, and update the slab usage count
-// 3. If this is the last allocated cell, free the slab to the main slab manager
-// 4. If the slab was full-floating then insert the slab in it's respective iPartial tree
-//
-{
-	HEAP_ASSERT(LowBits(p,3)==0);
-	slab* s = slab::SlabFor(p);
-	CHECKSLAB(s,ESlabAllocator,p);
-	CHECKSLABBFR(s,p);	
-
-	unsigned pos = LowBits(p, SLABSIZE);
-	unsigned h = s->iHeader;
-	HEAP_ASSERT(SlabHeaderUsedm4(h) != 0x3fC);		// slab is empty already
-	HEAP_ASSERT((pos-sizeof(slabhdr))%SlabHeaderSize(h) == 0);
-	*(unsigned char*)p = (unsigned char)h;
-	h &= ~0xFF;
-	h |= (pos>>2);
-	unsigned size = h & 0x3C000;
-	if (int(h) >= 0)
-		{
-		h -= size<<6;
-		if (int(h)>=0)
-			{
-			s->iHeader = h;
-			return;
-			}
-		FreeSlab(s);
-		return;
-		}
-	h -= size<<6;
-    h &= ~FLOATING_BIT;	
-	s->iHeader = h;
-	slab** full = s->iParent;		// remove from full list
-	slab* c = s->iChild1;
-	*full = c;
-	if (c)
-		c->iParent = full;
-	
-	slabset& ss = iSlabAlloc[iSizeMap[size>>14]];
-	TreeInsert(s,&ss.iPartial);
-	CHECKTREE(&ss.iPartial);
-}
-
-void* RHybridHeap::InitNewSlab(slabset& allocator, slab* s)
-//
-// initialise an empty slab for this allocator and return the fist cell
-// pre-condition: the slabset has no iPartial iSlabs for allocation
-//
-{
-	HEAP_ASSERT(allocator.iPartial==0);
-	TInt size = 4 + ((&allocator-&iSlabAlloc[0])<<2);	// infer size from slab allocator address
-	unsigned h = s->iHeader & 0xF00;	// preserve pagemap only
-	h |= (size<<12);					// set size
-	h |= (size-4)<<18;					// set usedminus4 to one object minus 4
-	s->iHeader = h;
-	allocator.iPartial = s;
-	s->iParent = &allocator.iPartial;
-	s->iChild1 = s->iChild2 = 0;
-	return Offset(s,sizeof(slabhdr));
-}
-
-const unsigned char slab_bitcount[16] = {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4};
-
-const unsigned char slab_ext_frag[16] =
-{
-	0,
-	16 + (1008 % 4),
-	16 + (1008 % 8),
-	16 + (1008 % 12),
-	16 + (1008 % 16),
-	16 + (1008 % 20),
-	16 + (1008 % 24),
-	16 + (1008 % 28),
-	16 + (1008 % 32),
-	16 + (1008 % 36),
-	16 + (1008 % 40),
-	16 + (1008 % 44),
-	16 + (1008 % 48),
-	16 + (1008 % 52),
-	16 + (1008 % 56),
-	16 + (1008 % 60)
-};
-
-void RHybridHeap::TreeWalk(slab* const* root, void (*f)(slab*, struct HeapInfo*, SWalkInfo*), struct HeapInfo* i, SWalkInfo* wi)
-{
-	// iterative walk around the tree at root
-	
-	slab* s = *root;
-	if (!s)
-		return;
-	
-	for (;;)
-		{
-		slab* c;
-		while ((c = s->iChild1) != 0)
-			s = c;		// walk down left side to end
-		for (;;)
-			{
-			f(s, i, wi);
-			c = s->iChild2;
-			if (c)
-				{	// one step down right side, now try and walk down left
-				s = c;
-				break;
-				}
-			for (;;)
-				{	// loop to walk up right side
-				slab** pp = s->iParent;
-				if (pp == root)
-					return;
-				s = slab::SlabFor(pp);
-				if (pp == &s->iChild1)
-					break;
-				}
-			}
-		}
-}
-
-void RHybridHeap::SlabEmptyInfo(slab* s, struct HeapInfo* i, SWalkInfo* wi)
-{
-	Walk(wi, s, SLABSIZE, EGoodFreeCell, EEmptySlab); // Introduce an empty slab to the walk function 
-	int nslab = slab_bitcount[SlabHeaderPagemap(page::PageFor(s)->iSlabs[0].iHeader)];
-	i->iFreeN += nslab;
-	i->iFreeBytes += nslab << SLABSHIFT;
-}
-
-void RHybridHeap::SlabPartialInfo(slab* s, struct HeapInfo* i, SWalkInfo* wi)
-{
-	Walk(wi, s, SLABSIZE, EGoodAllocatedCell, EPartialFullSlab); // Introduce a full slab to the walk function 
-	unsigned h = s->iHeader;
-	unsigned used = SlabHeaderUsedm4(h)+4;
-	unsigned size = SlabHeaderSize(h);
-	unsigned free = 1024 - slab_ext_frag[size>>2] - used;
-	i->iFreeN += (free/size);
-	i->iFreeBytes += free;
-	i->iAllocN += (used/size);
-	i->iAllocBytes += used;
-}
-
-void RHybridHeap::SlabFullInfo(slab* s, struct HeapInfo* i, SWalkInfo* wi)
-{
-	Walk(wi, s, SLABSIZE, EGoodAllocatedCell, EFullSlab); // Introduce a full slab to the walk function 
-	unsigned h = s->iHeader;
-	unsigned used = SlabHeaderUsedm4(h)+4;
-	unsigned size = SlabHeaderSize(h);
-	HEAP_ASSERT(1024 - slab_ext_frag[size>>2] - used == 0);
-	i->iAllocN += (used/size);
-	i->iAllocBytes += used;
-}
-
-void RHybridHeap::SlabInfo(struct HeapInfo* i, SWalkInfo* wi) const
-{
-	if (iSparePage)
-		{
-		i->iFreeBytes += iPageSize;
-		i->iFreeN = 4;
-		Walk(wi, iSparePage, iPageSize, EGoodFreeCell, ESlabSpare); // Introduce Slab spare page to the walk function 
-		}
-	TreeWalk(&iFullSlab, &SlabFullInfo, i, wi);
-	for (int ix = 0; ix < (MAXSLABSIZE>>2); ++ix)
-		TreeWalk(&iSlabAlloc[ix].iPartial, &SlabPartialInfo, i, wi);
-	TreeWalk(&iPartialPage, &SlabEmptyInfo, i, wi);
-}
-
-
-//
-// Bitmap class implementation for large page allocator 
-//
-inline unsigned char* paged_bitmap::Addr() const {return iBase;}
-inline unsigned paged_bitmap::Size() const {return iNbits;}
-//
-
-void paged_bitmap::Init(unsigned char* p, unsigned size, unsigned bit)
-{
-	iBase = p;
-	iNbits=size;
-	int bytes=Ceiling(size,8)>>3;
-	memset(p,bit?0xff:0,bytes);
-}
-
-inline void paged_bitmap::Set(unsigned ix, unsigned bit)
-{
-	if (bit)
-		iBase[ix>>3] |= (1<<(ix&7));
-	else
-		iBase[ix>>3] &= ~(1<<(ix&7));
-}
-
-inline unsigned paged_bitmap::operator[](unsigned ix) const
-{
-	return 1U&(iBase[ix>>3] >> (ix&7));
-}
-
-void paged_bitmap::Setn(unsigned ix, unsigned len, unsigned bit)
-{
-	int l=len;
-	while (--l>=0)
-		Set(ix++,bit);
-}
-
-void paged_bitmap::Set(unsigned ix, unsigned len, unsigned val)
-{
-	int l=len;
-	while (--l>=0)
-		{
-		Set(ix++,val&1);
-		val>>=1;
-		}
-}
-
-unsigned paged_bitmap::Bits(unsigned ix, unsigned len) const
-{
-	int l=len;
-	unsigned val=0;
-	unsigned bit=0;
-	while (--l>=0)
-		val |= (*this)[ix++]<<bit++;
-	return val;
-}
-
-bool paged_bitmap::Is(unsigned ix, unsigned len, unsigned bit) const
-{
-	unsigned i2 = ix+len;
-	if (i2 > iNbits)
-		return false;
-	for (;;)
-		{
-		if ((*this)[ix] != bit)
-			return false;
-		if (++ix==i2)
-			return true;
-		}
-}
-
-int paged_bitmap::Find(unsigned start, unsigned bit) const
-{
-	if (start<iNbits) do
-		{
-		if ((*this)[start]==bit)
-			return start;
-		} while (++start<iNbits);
-	return -1;
-}
-
-
-//
-// Page allocator code
-//
-void RHybridHeap::PagedInit(TInt aPagePower)
-{
-	if (aPagePower > 0)
-		{
-		if (aPagePower < MINPAGEPOWER)
-			aPagePower = MINPAGEPOWER;
-		}
-	else aPagePower = 31;
-
-	iPageThreshold = aPagePower;
-	/*-------------------------------------------------------------
-	 * Initialize page bitmap
-	 *-------------------------------------------------------------*/
-	iPageMap.Init((unsigned char*)&iBitMapBuffer, MAXSMALLPAGEBITS, 0);
-}
-
-void* RHybridHeap::PagedAllocate(unsigned size)
-{
-	TInt nbytes = Ceiling(size, iPageSize);
-	void* p = Map(0, nbytes);
-	if (!p)
-		return 0;
-	if (!PagedSetSize(p, nbytes))
-		{
-		Unmap(p, nbytes);
-		return 0;
-		}
-	return p;
-}
-
-void* RHybridHeap::PagedReallocate(void* p, unsigned size, TInt mode)
-{
-	
-	HEAP_ASSERT(Ceiling(p, iPageSize) == p);
-	unsigned nbytes = Ceiling(size, iPageSize);
-	
-	unsigned osize = PagedSize(p);
-	if ( nbytes == 0 )  // Special case to handle shrinking below min page threshold 
-		nbytes = Min((1 << MINPAGEPOWER), osize);
-	
-	if (osize == nbytes)
-		return p;
-	
-	if (nbytes < osize)
-		{	// shrink in place, unmap final pages and rewrite the pagemap
-		Unmap(Offset(p, nbytes), osize-nbytes);
-		// zap old code and then write new code (will not fail)
-		PagedZapSize(p, osize);
-
-		TBool check = PagedSetSize(p, nbytes);
-        __ASSERT_ALWAYS(check, HEAP_PANIC(ETHeapBadCellAddress));
-		
-		return p;
-		}
-	
-	// nbytes > osize
-	// try and extend current region first
-			
-	void* newp = Map(Offset(p, osize), nbytes-osize);
-	if (newp)
-		{	// In place growth. Possibility that pagemap may have to grow AND then fails
-		if (!PagedSetSize(p, nbytes))
-			{	// must release extra mapping
-			Unmap(Offset(p, osize), nbytes-osize);
-			return 0;
-			}
-		// if successful, the new length code will have overwritten the old one (it is at least as long)
-		return p;
-		}
-	
-	// fallback to  allocate/copy/free
-	if (mode & ENeverMove)
-		return 0;		// not allowed to move cell
-	
-	newp = PagedAllocate(nbytes);
-	if (!newp)
-		return 0;
-	memcpy(newp, p, osize);
-	PagedFree(p);
-	return newp;
-}
-
-void RHybridHeap::PagedFree(void* p)
-{
-	HEAP_ASSERT(Ceiling(p, iPageSize) == p);
-
-	
-	unsigned size = PagedSize(p);
-	
-	PagedZapSize(p, size);		// clear page map
-	Unmap(p, size);
-}
-
-void RHybridHeap::PagedInfo(struct HeapInfo* i, SWalkInfo* wi) const
-{
-	for (int ix = 0;(ix = iPageMap.Find(ix,1)) >= 0;)
-		{
-		int npage = PagedDecode(ix);
-		// Introduce paged buffer to the walk function 
-		TAny* bfr = Bitmap2addr(ix);
-		int len = npage << PAGESHIFT;
-		if ( len > iPageSize )
-			{ // If buffer is not larger than one page it must be a slab page mapped into bitmap
-			i->iAllocBytes += len;
-			++i->iAllocN;
-			Walk(wi, bfr, len, EGoodAllocatedCell, EPageAllocator);
-			}
-		ix += (npage<<1);
-		}
-}
-
-void RHybridHeap::ResetBitmap()
-/*---------------------------------------------------------
- * Go through paged_bitmap and unmap all buffers to system
- * This method is called from RHybridHeap::Reset() to unmap all page
- * allocated - and slab pages which are stored in bitmap, too
- *---------------------------------------------------------*/ 
-{
-	unsigned iNbits = iPageMap.Size();
-	if ( iNbits )
-		{
-		for (int ix = 0;(ix = iPageMap.Find(ix,1)) >= 0;)
-			{
-			int npage = PagedDecode(ix);
-			void* p = Bitmap2addr(ix);
-			unsigned size = PagedSize(p);
-			PagedZapSize(p, size);		// clear page map
-			Unmap(p, size);
-			ix += (npage<<1);
-			}
-		if ( (TInt)iNbits > MAXSMALLPAGEBITS )
-			{
-			// unmap page reserved for enlarged bitmap
-			Unmap(iPageMap.Addr(), (iNbits >> 3) );
-			}
-		}
-}
-
-TBool RHybridHeap::CheckBitmap(void* aBfr, TInt aSize, TUint32& aDummy, TInt& aNPages)
-/*---------------------------------------------------------
- * If aBfr = NULL
- *   Go through paged_bitmap and unmap all buffers to system
- *   and assure that by reading the first word of each page of aBfr
- *   that aBfr is still accessible
- * else  
- *   Assure that specified buffer is mapped with correct length in
- *   page map
- *---------------------------------------------------------*/ 
-{
-	TBool ret;
-	if ( aBfr )
-		{
-		__ASSERT_ALWAYS((Ceiling(aBfr, iPageSize) == aBfr), HEAP_PANIC(ETHeapBadCellAddress));		
-        ret = ( aSize == (TInt)PagedSize(aBfr));
-		}
-	else
-		{
-		ret = ETrue;
-		unsigned iNbits = iPageMap.Size();
-		if ( iNbits )
-			{
-			TInt npage;
-			aNPages = 0;
-			for (int ix = 0;(ix = iPageMap.Find(ix,1)) >= 0;)
-				{
-				npage = PagedDecode(ix);
-				aNPages += npage;
-				void* p = Bitmap2addr(ix);
-				__ASSERT_ALWAYS((Ceiling(p, iPageSize) == p), HEAP_PANIC(ETHeapBadCellAddress));						
-				unsigned s = PagedSize(p);
-				__ASSERT_ALWAYS((Ceiling(s, iPageSize) == s), HEAP_PANIC(ETHeapBadCellAddress));	
-				while ( s )
-					{
-					aDummy += *(TUint32*)((TUint8*)p + (s-iPageSize));
-					s -= iPageSize;
-					}
-				ix += (npage<<1);
-				}
-			if ( (TInt)iNbits > MAXSMALLPAGEBITS )
-				{
-				// add enlarged bitmap page(s) to total page count
-                npage = (iNbits >> 3); 
-				__ASSERT_ALWAYS((Ceiling(npage, iPageSize) == npage), HEAP_PANIC(ETHeapBadCellAddress));
-				aNPages += (npage / iPageSize);
-				}
-			}
-		}
-	
-	return ret;
-}
-
-
-// The paged allocations are tracked in a bitmap which has 2 bits per page
-// this allows us to store allocations as small as 4KB
-// The presence and size of an allocation is encoded as follows:
-// let N = number of pages in the allocation, then
-// 10            : N = 1			// 4KB
-// 110n			 : N = 2 + n		// 8-12KB
-// 1110nnnn      : N = nnnn			// 16-60KB
-// 1111n[18]	 : N = n[18]		// 64KB-1GB
-
-const struct etab { unsigned char offset, len, codelen, code;} encode_table[] =
-{
-	{1,2,2,0x1},
-	{2,4,3,0x3},
-	{0,8,4,0x7},
-	{0,22,4,0xf}
-};
-
-// Return code length for specified allocation Size(assumed to be aligned to pages)
-inline unsigned paged_codelen(unsigned size, unsigned pagesz)
-{
-	HEAP_ASSERT(size == Ceiling(size, pagesz));
-	
-	if (size == pagesz)
-		return 2;
-	else if (size < 4*pagesz)
-		return 4;
-	else if (size < 16*pagesz)
-		return 8;
-	else
-		return 22;
-}
-
-inline const etab& paged_coding(unsigned npage)
-{
-	if (npage < 4)
-		return encode_table[npage>>1];
-	else if (npage < 16)
-		return encode_table[2];
-	else
-		return encode_table[3];
-}
-
-bool RHybridHeap::PagedEncode(unsigned pos, unsigned npage)
-{
-	const etab& e = paged_coding(npage);
-	if (pos + e.len > iPageMap.Size())
-		{
-		// need to grow the page bitmap to fit the cell length into the map
-		// if we outgrow original bitmap buffer in RHybridHeap metadata, then just get enough pages to cover the full space:
-		// * initial 68 byte bitmap mapped (68*8*4kB):2 = 1,1MB
-		// * 4KB can Map(4096*8*4kB):2 = 64MB
-		unsigned maxsize = Ceiling(iMaxLength, iPageSize);
-		unsigned mapbits = maxsize >> (PAGESHIFT-1);
-		maxsize = Ceiling(mapbits>>3, iPageSize);
-		void* newb = Map(0, maxsize);
-		if (!newb)
-			return false;
-		
-		unsigned char* oldb = iPageMap.Addr();
-		iPageMap.Init((unsigned char*)newb, (maxsize<<3), 0);
-		memcpy(newb, oldb, Ceiling(MAXSMALLPAGEBITS,8)>>3);
-		}
-	// encode the allocation block size into the bitmap, starting at the bit for the start page
-	unsigned bits = e.code;
-	bits |= (npage - e.offset) << e.codelen;
-	iPageMap.Set(pos, e.len, bits);
-	return true;
-}
-
-unsigned RHybridHeap::PagedDecode(unsigned pos) const
-{
-	__ASSERT_ALWAYS(pos + 2 <= iPageMap.Size(), HEAP_PANIC(ETHeapBadCellAddress));
-	
-	unsigned bits = iPageMap.Bits(pos,2);
-	__ASSERT_ALWAYS(bits & 1, HEAP_PANIC(ETHeapBadCellAddress));
-	bits >>= 1;
-	if (bits == 0)
-		return 1;
-	__ASSERT_ALWAYS(pos + 4 <= iPageMap.Size(), HEAP_PANIC(ETHeapBadCellAddress));
-	bits = iPageMap.Bits(pos+2,2);
-	if ((bits & 1) == 0)
-		return 2 + (bits>>1);
-	else if ((bits>>1) == 0)
-		{
-		__ASSERT_ALWAYS(pos + 8 <= iPageMap.Size(), HEAP_PANIC(ETHeapBadCellAddress));
-		return iPageMap.Bits(pos+4, 4);
-		}
-	else
-		{
-		__ASSERT_ALWAYS(pos + 22 <= iPageMap.Size(), HEAP_PANIC(ETHeapBadCellAddress));
-		return iPageMap.Bits(pos+4, 18);
-		}
-}
-
-inline void RHybridHeap::PagedZapSize(void* p, unsigned size)
-{iPageMap.Setn(PtrDiff(p, iMemBase) >> (PAGESHIFT-1), paged_codelen(size, iPageSize) ,0);}
-
-inline unsigned RHybridHeap::PagedSize(void* p) const
-   { return PagedDecode(PtrDiff(p, iMemBase) >> (PAGESHIFT-1)) << PAGESHIFT; }
-
-inline bool RHybridHeap::PagedSetSize(void* p, unsigned size)
-{ return PagedEncode(PtrDiff(p, iMemBase) >> (PAGESHIFT-1), size >> PAGESHIFT); }
-
-inline void* RHybridHeap::Bitmap2addr(unsigned pos) const
-   { return iMemBase + (1 << (PAGESHIFT-1))*pos; }
-
-
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////
-/**
-Constructor where minimum and maximum length of the heap can be defined.
-It defaults the chunk heap to be created to have use a new local chunk, 
-to have a grow by value of KMinHeapGrowBy, to be unaligned, not to be 
-single threaded and not to have any mode flags set.
-
-@param aMinLength    The minimum length of the heap to be created.
-@param aMaxLength    The maximum length to which the heap to be created can grow.
-                     If the supplied value is less than a page size, then it
-                     is discarded and the page size is used instead.
-*/
-EXPORT_C TChunkHeapCreateInfo::TChunkHeapCreateInfo(TInt aMinLength, TInt aMaxLength) :
-   iVersionNumber(EVersion0), iMinLength(aMinLength), iMaxLength(aMaxLength),
-iAlign(0), iGrowBy(1), iSingleThread(EFalse), 
-iOffset(0), iPaging(EUnspecified), iMode(0), iName(NULL)
-{
-}
-
-
-/**
-Sets the chunk heap to create a new chunk with the specified name.
-
-This overriddes any previous call to TChunkHeapCreateInfo::SetNewChunkHeap() or
-TChunkHeapCreateInfo::SetExistingChunkHeap() for this TChunkHeapCreateInfo object.
-
-@param aName	The name to be given to the chunk heap to be created
-If NULL, the function constructs a local chunk to host the heap.
-If not NULL, a pointer to a descriptor containing the name to be 
-assigned to the global chunk hosting the heap.
-*/
-EXPORT_C void TChunkHeapCreateInfo::SetCreateChunk(const TDesC* aName)
-{
-	iName = (TDesC*)aName;
-	iChunk.SetHandle(KNullHandle);
-}
-
-
-/**
-Sets the chunk heap to be created to use the chunk specified.
-
-This overriddes any previous call to TChunkHeapCreateInfo::SetNewChunkHeap() or
-TChunkHeapCreateInfo::SetExistingChunkHeap() for this TChunkHeapCreateInfo object.
-
-@param aChunk	A handle to the chunk to use for the heap.
-*/
-EXPORT_C void TChunkHeapCreateInfo::SetUseChunk(const RChunk aChunk)
-{
-	iName = NULL;
-	iChunk = aChunk;
-}
-
-EXPORT_C RHeap* UserHeap::FixedHeap(TAny* aBase, TInt aMaxLength, TInt aAlign, TBool aSingleThread)
-/**
-Creates a fixed length heap at a specified location.
-
-On successful return from this function, the heap is ready to use.  This assumes that
-the memory pointed to by aBase is mapped and able to be used.  You must ensure that you
-pass in a large enough value for aMaxLength.  Passing in a value that is too small to
-hold the metadata for the heap (~1 KB) will result in the size being rounded up and the
-heap thereby running over the end of the memory assigned to it.  But then if you were to
-pass in such as small value then you would not be able to do any allocations from the
-heap anyway.  Moral of the story: Use a sensible value for aMaxLength!
-
-@param aBase         A pointer to the location where the heap is to be constructed.
-@param aMaxLength    The maximum length in bytes to which the heap can grow.  If the
-                     supplied value is too small to hold the heap's metadata, it
-                     will be increased.
-@param aAlign        From Symbian^4 onwards, this value is ignored but EABI 8
-                     byte alignment is guaranteed for all allocations 8 bytes or
-                     more in size.  4 byte allocations will be aligned to a 4
-                     byte boundary.  Best to pass in zero.
-@param aSingleThread EFalse if the heap is to be accessed from multiple threads.
-                     This will cause internal locks to be created, guaranteeing
-                     thread safety.
-
-@return A pointer to the new heap, or NULL if the heap could not be created.
-
-@panic USER 56 if aMaxLength is negative.
-*/
-{
-	__ASSERT_ALWAYS( aMaxLength>=0, ::Panic(ETHeapMaxLengthNegative));
-	if ( aMaxLength < (TInt)sizeof(RHybridHeap) )
-		aMaxLength = sizeof(RHybridHeap);
-	
-	RHybridHeap* h = new(aBase) RHybridHeap(aMaxLength, aAlign, aSingleThread);
-	
-	if (!aSingleThread)
-		{
-		TInt r = h->iLock.CreateLocal();
-		if (r!=KErrNone)
-			return NULL; // No need to delete the RHybridHeap instance as the new above is only a placement new
-		h->iHandles = (TInt*)&h->iLock;
-		h->iHandleCount = 1;
-		}
-	return h;
-}
-
-/**
-Creates a chunk heap of the type specified by the parameter aCreateInfo.
-
-@param aCreateInfo	A reference to a TChunkHeapCreateInfo object specifying the
-type of chunk heap to create.
-
-@return A pointer to the new heap or NULL if the heap could not be created.
-
-@panic USER 41 if the heap's specified minimum length is greater than the specified maximum length.
-@panic USER 55 if the heap's specified minimum length is negative.
-@panic USER 172 if the heap's specified alignment is not a power of 2 or is less than the size of a TAny*.
-*/
-EXPORT_C RHeap* UserHeap::ChunkHeap(const TChunkHeapCreateInfo& aCreateInfo)
-{
-	// aCreateInfo must have been configured to use a new chunk or an exiting chunk.
-	__ASSERT_ALWAYS(!(aCreateInfo.iMode & (TUint32)~EChunkHeapMask), ::Panic(EHeapCreateInvalidMode));
-	RHeap* h = NULL;
-	
-	if (aCreateInfo.iChunk.Handle() == KNullHandle)
-		{
-		// A new chunk is to be created for this heap.
-		
-		__ASSERT_ALWAYS(aCreateInfo.iMinLength >= 0, ::Panic(ETHeapMinLengthNegative));
-		__ASSERT_ALWAYS(aCreateInfo.iMaxLength >= aCreateInfo.iMinLength, ::Panic(ETHeapCreateMaxLessThanMin));
-
-		TInt maxLength = aCreateInfo.iMaxLength;
-		TInt page_size;
-		GET_PAGE_SIZE(page_size);
-
-		if (maxLength < page_size)
-			maxLength = page_size;
-		
-		TChunkCreateInfo chunkInfo;
-#if USE_HYBRID_HEAP
-		if ( aCreateInfo.iOffset )
-			chunkInfo.SetNormal(0, maxLength);  // Create DL only heap
-		else
-			{
-			maxLength = 2*maxLength;
-			chunkInfo.SetDisconnected(0, 0, maxLength); // Create hybrid heap
-			}
-#else
-		chunkInfo.SetNormal(0, maxLength);  // Create DL only heap		
-#endif			
-		chunkInfo.SetOwner((aCreateInfo.iSingleThread)? EOwnerThread : EOwnerProcess);
-		if (aCreateInfo.iName)
-			chunkInfo.SetGlobal(*aCreateInfo.iName);
-		// Set the paging attributes of the chunk.
-		if (aCreateInfo.iPaging == TChunkHeapCreateInfo::EPaged)
-			chunkInfo.SetPaging(TChunkCreateInfo::EPaged);
-		if (aCreateInfo.iPaging == TChunkHeapCreateInfo::EUnpaged)
-			chunkInfo.SetPaging(TChunkCreateInfo::EUnpaged);
-		// Create the chunk.
-		RChunk chunk;
-		if (chunk.Create(chunkInfo) != KErrNone)
-			return NULL;
-		// Create the heap using the new chunk.
-		TUint mode = aCreateInfo.iMode | EChunkHeapDuplicate;	// Must duplicate the handle.
-		h = OffsetChunkHeap(chunk, aCreateInfo.iMinLength, aCreateInfo.iOffset,
-							aCreateInfo.iGrowBy, maxLength, aCreateInfo.iAlign,
-							aCreateInfo.iSingleThread, mode);
-		chunk.Close();
-		}
-	else
-		{
-		h = OffsetChunkHeap(aCreateInfo.iChunk, aCreateInfo.iMinLength, aCreateInfo.iOffset,
-							aCreateInfo.iGrowBy, aCreateInfo.iMaxLength, aCreateInfo.iAlign,
-							aCreateInfo.iSingleThread, aCreateInfo.iMode);
-		}
-	return h;
-}
-
-
-
-EXPORT_C RHeap* UserHeap::ChunkHeap(const TDesC* aName, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign, TBool aSingleThread)
-/**
-Creates a heap in a local or global chunk.
-
-The chunk hosting the heap can be local or global.
-
-A local chunk is one which is private to the process creating it and is not
-intended for access by other user processes.  A global chunk is one which is
-visible to all processes.
-
-The hosting chunk is local, if the pointer aName is NULL, otherwise the
-hosting chunk is global and the descriptor *aName is assumed to contain
-the name to be assigned to it.
-
-Ownership of the host chunk is vested in the current process.
-
-A minimum and a maximum size for the heap can be specified. On successful
-return from this function, the size of the heap is at least aMinLength.
-If subsequent requests for allocation of memory from the heap cannot be
-satisfied by compressing the heap, the size of the heap is extended in
-increments of aGrowBy until the request can be satisfied.  Attempts to extend
-the heap causes the size of the host chunk to be adjusted.
-
-Note that the size of the heap cannot be adjusted by more than aMaxLength.
-
-@param aName         If NULL, the function constructs a local chunk to host
-                     the heap.  If not NULL, a pointer to a descriptor containing
-                     the name to be assigned to the global chunk hosting the heap.
-@param aMinLength    The minimum length of the heap in bytes.  This will be
-                     rounded up to the nearest page size by the allocator.
-@param aMaxLength    The maximum length in bytes to which the heap can grow.  This
-                     will be rounded up to the nearest page size by the allocator.
-@param aGrowBy       The number of bytes by which the heap will grow when more
-                     memory is required.  This will be rounded up to the nearest
-                     page size by the allocator.  If a value is not explicitly
-                     specified, the page size is taken by default.
-@param aAlign        From Symbian^4 onwards, this value is ignored but EABI 8
-                     byte alignment is guaranteed for all allocations 8 bytes or
-                     more in size.  4 byte allocations will be aligned to a 4
-                     byte boundary.  Best to pass in zero.
-@param aSingleThread EFalse if the heap is to be accessed from multiple threads.
-                     This will cause internal locks to be created, guaranteeing
-                     thread safety.
-
-@return A pointer to the new heap or NULL if the heap could not be created.
-
-@panic USER 41 if aMaxLength is < aMinLength.
-@panic USER 55 if aMinLength is negative.
-@panic USER 56 if aMaxLength is negative.
-*/
-	{
-	TInt page_size;
-	GET_PAGE_SIZE(page_size);
-	TInt minLength = _ALIGN_UP(aMinLength, page_size);
-	TInt maxLength = Max(aMaxLength, minLength);
-
-	TChunkHeapCreateInfo createInfo(minLength, maxLength);
-	createInfo.SetCreateChunk(aName);
-	createInfo.SetGrowBy(aGrowBy);
-	createInfo.SetAlignment(aAlign);
-	createInfo.SetSingleThread(aSingleThread);
-
-	return ChunkHeap(createInfo);
-	}
-
-EXPORT_C RHeap* UserHeap::ChunkHeap(RChunk aChunk, TInt aMinLength, TInt aGrowBy, TInt aMaxLength, TInt aAlign, TBool aSingleThread, TUint32 aMode)
-/**
-Creates a heap in an existing chunk.
-
-This function is intended to be used to create a heap in a user writable code
-chunk as created by a call to RChunk::CreateLocalCode().  This type of heap can
-be used to hold code fragments from a JIT compiler.
-
-@param aChunk        The chunk that will host the heap.
-@param aMinLength    The minimum length of the heap in bytes.  This will be
-                     rounded up to the nearest page size by the allocator.
-@param aGrowBy       The number of bytes by which the heap will grow when more
-                     memory is required.  This will be rounded up to the nearest
-                     page size by the allocator.  If a value is not explicitly
-                     specified, the page size is taken by default.
-@param aMaxLength    The maximum length in bytes to which the heap can grow.  This
-                     will be rounded up to the nearest page size by the allocator.
-                     If 0 is passed in, the maximum lengt of the chunk is used.
-@param aAlign        From Symbian^4 onwards, this value is ignored but EABI 8
-                     byte alignment is guaranteed for all allocations 8 bytes or
-                     more in size.  4 byte allocations will be aligned to a 4
-                     byte boundary.  Best to pass in zero.
-@param aSingleThread EFalse if the heap is to be accessed from multiple threads.
-                     This will cause internal locks to be created, guaranteeing
-                     thread safety.
-@param aMode         Flags controlling the heap creation.  See RAllocator::TFlags.
-
-@return A pointer to the new heap or NULL if the heap could not be created.
-
-@see UserHeap::OffsetChunkHeap()
-*/
-	{
-	return OffsetChunkHeap(aChunk, aMinLength, 0, aGrowBy, aMaxLength, aAlign, aSingleThread, aMode);
-	}
-
-EXPORT_C RHeap* UserHeap::OffsetChunkHeap(RChunk aChunk, TInt aMinLength, TInt aOffset, TInt aGrowBy, TInt aMaxLength, TInt aAlign, TBool aSingleThread, TUint32 aMode)
-/**
-Creates a heap in an existing chunk, offset from the beginning of the chunk.
-
-This function is intended to be used to create a heap using a chunk which has
-some of its memory already used, at the start of that that chunk.  The maximum
-length to which the heap can grow is the maximum size of the chunk, minus the
-data at the start of the chunk.
-
-The offset at which to create the heap is passed in as the aOffset parameter.
-Legacy heap implementations always respected the aOffset value, however more
-modern heap implementations are more sophisticated and cannot necessarily respect
-this value.  Therefore, if possible, you should always use an aOffset of 0 unless
-you have a very explicit requirement for using a non zero value.  Using a non zero
-value will result in a less efficient heap algorithm being used in order to respect
-the offset.
-
-Another issue to consider when using this function is the type of the chunk passed
-in.  In order for the most efficient heap algorithms to be used, the chunk passed
-in should always be a disconnected chunk.  Passing in a non disconnected chunk will
-again result in a less efficient heap algorithm being used.
-
-Finally, another requirement for the most efficient heap algorithms to be used is
-for the heap to be able to expand.  Therefore, unless you have a specific reason to
-do so, always specify aMaxLength > aMinLength.
-
-So, if possible, use aOffset == zero, aMaxLength > aMinLength and a disconnected
-chunk for best results!
-
-@param aChunk        The chunk that will host the heap.
-@param aMinLength    The minimum length of the heap in bytes.  This will be
-                     rounded up to the nearest page size by the allocator.
-@param aOffset       The offset in bytes from the start of the chunk at which to
-                     create the heap.  If used (and it shouldn't really be!)
-                     then it will be rounded up to a multiple of 8, to respect
-                     EABI 8 byte alignment requirements.
-@param aGrowBy       The number of bytes by which the heap will grow when more
-                     memory is required.  This will be rounded up to the nearest
-                     page size by the allocator.  If a value is not explicitly
-                     specified, the page size is taken by default.
-@param aMaxLength    The maximum length in bytes to which the heap can grow.  This
-                     will be rounded up to the nearest page size by the allocator.
-                     If 0 is passed in, the maximum length of the chunk is used.
-@param aAlign        From Symbian^4 onwards, this value is ignored but EABI 8
-                     byte alignment is guaranteed for all allocations 8 bytes or
-                     more in size.  4 byte allocations will be aligned to a 4
-                     byte boundary.  Best to pass in zero.
-@param aSingleThread EFalse if the heap is to be accessed from multiple threads.
-                     This will cause internal locks to be created, guaranteeing
-                     thread safety.
-@param aMode         Flags controlling the heap creation.  See RAllocator::TFlags.
-
-@return A pointer to the new heap or NULL if the heap could not be created.
-
-@panic USER 41 if aMaxLength is < aMinLength.
-@panic USER 55 if aMinLength is negative.
-@panic USER 56 if aMaxLength is negative.
-@panic USER 168 if aOffset is negative.
-*/
-	{
-	TBool dlOnly = EFalse;
-	TInt pageSize;
-	GET_PAGE_SIZE(pageSize);
-	TInt align = RHybridHeap::ECellAlignment; // Always use EABI 8 byte alignment
-
-	__ASSERT_ALWAYS(aMinLength>=0, ::Panic(ETHeapMinLengthNegative));
-	__ASSERT_ALWAYS(aMaxLength>=0, ::Panic(ETHeapMaxLengthNegative));
-
-	if ( aMaxLength > 0 ) 
-		__ASSERT_ALWAYS(aMaxLength>=aMinLength, ::Panic(ETHeapCreateMaxLessThanMin));
-
-	// Stick to EABI alignment for the start offset, if any
-	aOffset = _ALIGN_UP(aOffset, align);
-
-	// Using an aOffset > 0 means that we can't use the hybrid allocator and have to revert to Doug Lea only
-	if (aOffset > 0)
-		dlOnly = ETrue;
-
-	// Ensure that the minimum length is enough to hold the RHybridHeap object itself
-	TInt minCell = _ALIGN_UP(Max((TInt)RHybridHeap::EAllocCellSize, (TInt)RHybridHeap::EFreeCellSize), align);
-	TInt hybridHeapSize = (sizeof(RHybridHeap) + minCell);
-	if (aMinLength < hybridHeapSize)
-		aMinLength = hybridHeapSize;
-
-	// Round the minimum length up to a multiple of the page size, taking into account that the
-	// offset takes up a part of the chunk's memory
-	aMinLength = _ALIGN_UP((aMinLength + aOffset), pageSize);
-
-	// If aMaxLength is 0 then use the entire chunk
-	TInt chunkSize = aChunk.MaxSize();
-	if (aMaxLength == 0)
-		{
-		aMaxLength = chunkSize;
-		}
-	// Otherwise round the maximum length up to a multiple of the page size, taking into account that
-	// the offset takes up a part of the chunk's memory.  We also clip the maximum length to the chunk
-	// size, so the user may get a little less than requested if the chunk size is not large enough
-	else
-		{
-		aMaxLength = _ALIGN_UP((aMaxLength + aOffset), pageSize);
-		if (aMaxLength > chunkSize)
-			aMaxLength = chunkSize;
-		}
-	
-	// If the rounded up values don't make sense then a crazy aMinLength or aOffset must have been passed
-	// in, so fail the heap creation
-	if (aMinLength > aMaxLength)
-		return NULL;
-
-	// Adding the offset into the minimum and maximum length was only necessary for ensuring a good fit of
-	// the heap into the chunk.  Re-adjust them now back to non offset relative sizes
-	aMinLength -= aOffset;
-	aMaxLength -= aOffset;
-
-	// If we are still creating the hybrid allocator (call parameter
-	// aOffset is 0 and aMaxLength > aMinLength), we must reduce heap
-	// aMaxLength size to the value aMaxLength/2 and set the aOffset to point in the middle of chunk.
-	TInt offset = aOffset;
-	TInt maxLength = aMaxLength;
-	if (!dlOnly && (aMaxLength > aMinLength))
-		maxLength = offset = _ALIGN_UP(aMaxLength >> 1, pageSize);
-
-	// Try to use commit to map aMinLength physical memory for the heap, taking into account the offset.  If
-	// the operation fails, suppose that the chunk is not a disconnected heap and try to map physical memory
-	// with adjust.  In this case, we also can't use the hybrid allocator and have to revert to Doug Lea only
-	TBool useAdjust = EFalse;
-	TInt r = aChunk.Commit(offset, aMinLength);
-	if (r == KErrGeneral)
-		{
-		dlOnly = useAdjust = ETrue;
-		r = aChunk.Adjust(aMinLength);
-		if (r != KErrNone)
-			return NULL;
-		}
-	else if (r == KErrNone)
-		{
-		// We have a disconnected chunk reset aOffset and aMaxlength
-		aOffset = offset;
-		aMaxLength = maxLength;
-		}
-
-	else
-		return NULL;
-
-	// Parameters have been mostly verified and we know whether to use the hybrid allocator or Doug Lea only.  The
-	// constructor for the hybrid heap will automatically drop back to Doug Lea if it determines that aMinLength
-	// == aMaxLength, so no need to worry about that requirement here.  The user specified alignment is not used but
-	// is passed in so that it can be sanity checked in case the user is doing something totally crazy with it
-	RHybridHeap* h = new (aChunk.Base() + aOffset) RHybridHeap(aChunk.Handle(), aOffset, aMinLength, aMaxLength,
-		aGrowBy, aAlign, aSingleThread, dlOnly, useAdjust);
-
-	if (h->ConstructLock(aMode) != KErrNone)
-		return NULL;
-
-	// Return the heap address
-	return h;
-	}
-
-#define UserTestDebugMaskBit(bit) (TBool)(UserSvr::DebugMask(bit>>5) & (1<<(bit&31)))
-
-_LIT(KLitDollarHeap,"$HEAP");
-EXPORT_C TInt UserHeap::CreateThreadHeap(SStdEpocThreadCreateInfo& aInfo, RHeap*& aHeap, TInt aAlign, TBool aSingleThread)
-/**
-@internalComponent
-*/
-//
-// Create a user-side heap
-//
-{
-	TInt page_size;
-	GET_PAGE_SIZE(page_size);
-	TInt minLength = _ALIGN_UP(aInfo.iHeapInitialSize, page_size);
-	TInt maxLength = Max(aInfo.iHeapMaxSize, minLength);
-	if (UserTestDebugMaskBit(96)) // 96 == KUSERHEAPTRACE in nk_trace.h
-		aInfo.iFlags |= ETraceHeapAllocs;
-	// Create the thread's heap chunk.
-	RChunk c;
-	TChunkCreateInfo createInfo;
-
-	createInfo.SetThreadHeap(0, maxLength, KLitDollarHeap());	// Initialise with no memory committed.	
-#if USE_HYBRID_HEAP
-	//
-	// Create disconnected chunk for hybrid heap with double max length value
-	//
-	maxLength = 2*maxLength;
-	createInfo.SetDisconnected(0, 0, maxLength);
-#endif	
-	// Set the paging policy of the heap chunk based on the thread's paging policy.
-	TUint pagingflags = aInfo.iFlags & EThreadCreateFlagPagingMask;
-	switch (pagingflags)
-		{
-		case EThreadCreateFlagPaged:
-			createInfo.SetPaging(TChunkCreateInfo::EPaged);
-			break;
-		case EThreadCreateFlagUnpaged:
-			createInfo.SetPaging(TChunkCreateInfo::EUnpaged);
-			break;
-		case EThreadCreateFlagPagingUnspec:
-			// Leave the chunk paging policy unspecified so the process's 
-			// paging policy is used.
-			break;
-		}
-	
-	TInt r = c.Create(createInfo);
-	if (r!=KErrNone)
-		return r;
-	
-	aHeap = ChunkHeap(c, minLength, page_size, maxLength, aAlign, aSingleThread, EChunkHeapSwitchTo|EChunkHeapDuplicate);
-	c.Close();
-	
-	if ( !aHeap )
-		return KErrNoMemory;
-	
-	if (aInfo.iFlags & ETraceHeapAllocs)
-		{
-		aHeap->iFlags |= RHeap::ETraceAllocs;
-    	BTraceContext8(BTrace::EHeap, BTrace::EHeapCreate,(TUint32)aHeap, RHybridHeap::EAllocCellSize);
-		TInt chunkId = ((RHandleBase&)((RHybridHeap*)aHeap)->iChunkHandle).BTraceId();
-		BTraceContext8(BTrace::EHeap, BTrace::EHeapChunkCreate, (TUint32)aHeap, chunkId);
-		}
-	if (aInfo.iFlags & EMonitorHeapMemory)
-		aHeap->iFlags |= RHeap::EMonitorMemory;
-	
-	return KErrNone;
-}
-
-#endif  // __KERNEL_MODE__