1 // Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\common\heap.cpp

    15 // 

    16 //

    17 

    18 #include "common.h"

    19 #ifdef __KERNEL_MODE__

    20 #include <kernel/kern_priv.h>

    21 #endif

    22 

    23 #ifdef _DEBUG

    24 #define __SIMULATE_ALLOC_FAIL(s)	if (CheckForSimulatedAllocFail()) {s}

    25 #define	__CHECK_CELL(p)				CheckCell(p)

    26 #define	__ZAP_CELL(p)				memset( ((TUint8*)p) + RHeap::EAllocCellSize, 0xde, p->len - RHeap::EAllocCellSize)

    27 #define __DEBUG_SAVE(p)				TInt dbgNestLevel = ((SDebugCell*)p)->nestingLevel

    28 #define __DEBUG_RESTORE(p)			((SDebugCell*)(((TUint8*)p)-EAllocCellSize))->nestingLevel = dbgNestLevel

    29 #else

    30 #define __SIMULATE_ALLOC_FAIL(s)

    31 #define	__CHECK_CELL(p)

    32 #define	__ZAP_CELL(p)

    33 #define __DEBUG_SAVE(p)

    34 #define __DEBUG_RESTORE(p)

    35 #endif

    36 

    37 #define __NEXT_CELL(p)				((SCell*)(((TUint8*)p)+p->len))

    38 

    39 #define __POWER_OF_2(x)				((TUint32)((x)^((x)-1))>=(TUint32)(x))

    40 

    41 #define __MEMORY_MONITOR_CHECK_CELL(p) \

    42 					{ \

    43 					TLinAddr m = TLinAddr(iAlign-1); \

    44 					SCell* c = (SCell*)(((TUint8*)p)-EAllocCellSize); \

    45 					if((c->len & m) || (c->len<iMinCell) || ((TUint8*)c<iBase) || ((TUint8*)__NEXT_CELL(c)>iTop)) \

    46 						BTraceContext12(BTrace::EHeap, BTrace::EHeapCorruption, (TUint32)this, (TUint32)p, (TUint32)c->len-EAllocCellSize); \

    47 					}

    48 					

    49 /**

    50 @SYMPatchable

    51 @publishedPartner

    52 @released

    53 

    54 Defines the minimum cell size of  a heap.

    55 

    56 The constant can be changed at ROM build time using patchdata OBY keyword.

    57 */

    58 #ifdef __X86GCC__	// For X86GCC we dont use the proper data import attribute

    59 #undef IMPORT_D		// since the constant is not really imported. GCC doesn't 

    60 #define IMPORT_D	// allow imports from self.

    61 #endif

    62 IMPORT_D extern const TInt KHeapMinCellSize;

    63 

    64 /**

    65 @SYMPatchable

    66 @publishedPartner

    67 @released

    68 

    69 This constant defines the ratio that determines the amount of hysteresis between heap growing and heap

    70 shrinking.

    71 It is a 32-bit fixed point number where the radix point is defined to be

    72 between bits 7 and 8 (where the LSB is bit 0) i.e. using standard notation, a Q8 or a fx24.8

    73 fixed point number.  For example, for a ratio of 2.0, set KHeapShrinkHysRatio=0x200.

    74 

    75 The heap shrinking hysteresis value is calculated to be:

    76 @code

    77 KHeapShrinkHysRatio*(iGrowBy>>8)

    78 @endcode

    79 where iGrowBy is a page aligned value set by the argument, aGrowBy, to the RHeap constructor.

    80 The default hysteresis value is iGrowBy bytes i.e. KHeapShrinkHysRatio=2.0.

    81 

    82 Memory usage may be improved by reducing the heap shrinking hysteresis

    83 by setting 1.0 < KHeapShrinkHysRatio < 2.0.  Heap shrinking hysteresis is disabled/removed

    84 when KHeapShrinkHysRatio <= 1.0.

    85 

    86 The constant can be changed at ROM build time using patchdata OBY keyword.

    87 */

    88 IMPORT_D extern const TInt KHeapShrinkHysRatio;

    89 

    90 #pragma warning( disable : 4705 )	// statement has no effect

    91 UEXPORT_C RHeap::RHeap(TInt aMaxLength, TInt aAlign, TBool aSingleThread)

    92 /**

    93 @internalComponent

    94 */

    95 //

    96 // Constructor for fixed size heap

    97 //

    98 	:	iMinLength(aMaxLength), iMaxLength(aMaxLength), iOffset(0), iGrowBy(0), iChunkHandle(0),

    99 		iNestingLevel(0), iAllocCount(0), iFailType(ENone), iTestData(NULL)

   100 	{

   101 	iAlign = aAlign ? aAlign : ECellAlignment;

   102 	iPageSize = 0;

   103 	iFlags = aSingleThread ? (ESingleThreaded|EFixedSize) : EFixedSize;

   104 	Initialise();

   105 	}

   106 #pragma warning( default : 4705 )

   107 

   108 

   109 

   110 

   111 UEXPORT_C RHeap::RHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign, TBool aSingleThread)

   112 /**

   113 @internalComponent

   114 */

   115 //

   116 // Constructor for chunk heaps.

   117 //

   118 	:	iOffset(aOffset), iChunkHandle(aChunkHandle),

   119 		iNestingLevel(0), iAllocCount(0), iFailType(ENone), iTestData(NULL)

   120 	{

   121 	TInt sz = iBase - ((TUint8*)this - iOffset);

   122 	GET_PAGE_SIZE(iPageSize);

   123 	__ASSERT_ALWAYS(iOffset>=0, HEAP_PANIC(ETHeapNewBadOffset));

   124 	iMinLength = Max(aMinLength, sz + EAllocCellSize);

   125 	iMinLength = _ALIGN_UP(iMinLength, iPageSize);

   126 	iMaxLength = Max(aMaxLength, iMinLength);

   127 	iMaxLength = _ALIGN_UP(iMaxLength, iPageSize);

   128 	iGrowBy = _ALIGN_UP(aGrowBy, iPageSize);

   129 	iFlags = aSingleThread ? ESingleThreaded : 0;

   130 	iAlign = aAlign ? aAlign : ECellAlignment;

   131 	Initialise();

   132 	}

   133 

   134 

   135 

   136 

   137 UEXPORT_C TAny* RHeap::operator new(TUint aSize, TAny* aBase) __NO_THROW

   138 /**

   139 @internalComponent

   140 */

   141 	{

   142 	__ASSERT_ALWAYS(aSize>=sizeof(RHeap), HEAP_PANIC(ETHeapNewBadSize));

   143 	RHeap* h = (RHeap*)aBase;

   144 	h->iAlign = 0x80000000;	// garbage value

   145 	h->iBase = ((TUint8*)aBase) + aSize;

   146 	return aBase;

   147 	}

   148 

   149 void RHeap::Initialise()

   150 //

   151 // Initialise the heap.

   152 //

   153 	{

   154 

   155 	__ASSERT_ALWAYS((TUint32)iAlign>=sizeof(TAny*) && __POWER_OF_2(iAlign), HEAP_PANIC(ETHeapNewBadAlignment));

   156 	iCellCount = 0;

   157 	iTotalAllocSize = 0;

   158 	iBase = (TUint8*)Align(iBase + EAllocCellSize);

   159 	iBase -= EAllocCellSize;

   160 	TInt b = iBase - ((TUint8*)this - iOffset);

   161 	TInt len = _ALIGN_DOWN(iMinLength - b, iAlign);

   162 	iTop = iBase + len;

   163 	iMinLength = iTop - ((TUint8*)this - iOffset);

   164 	iMinCell = Align(KHeapMinCellSize + Max((TInt)EAllocCellSize, (TInt)EFreeCellSize));

   165 #ifdef _DEBUG

   166 	memset(iBase, 0xa5, len);

   167 #endif

   168 	SCell* pM=(SCell*)iBase; // First free cell

   169 	iFree.next=pM; // Free list points to first free cell

   170 	iFree.len=0; // Stop free from joining this with a free block

   171 	pM->next=NULL; // Terminate the free list

   172 	pM->len=len; // Set the size of the free cell

   173 	}

   174 

   175 #ifdef _DEBUG

   176 void RHeap::CheckCell(const SCell* aCell) const

   177 	{

   178 	TLinAddr m = TLinAddr(iAlign - 1);

   179 

   180 	__ASSERT_DEBUG(!(aCell->len & m), HEAP_PANIC(ETHeapBadCellAddress));

   181 	__ASSERT_DEBUG(aCell->len >= iMinCell, HEAP_PANIC(ETHeapBadCellAddress));

   182 	__ASSERT_DEBUG((TUint8*)aCell>=iBase, HEAP_PANIC(ETHeapBadCellAddress));

   183 	__ASSERT_DEBUG((TUint8*)__NEXT_CELL(aCell)<=iTop, HEAP_PANIC(ETHeapBadCellAddress));

   184 	}

   185 #endif

   186 

   187 UEXPORT_C RHeap::SCell* RHeap::GetAddress(const TAny* aCell) const

   188 //

   189 // As much as possible, check a cell address and backspace it

   190 // to point at the cell header.

   191 //

   192 	{

   193 

   194 	TLinAddr m = TLinAddr(iAlign - 1);

   195 	__ASSERT_ALWAYS(!(TLinAddr(aCell)&m), HEAP_PANIC(ETHeapBadCellAddress));

   196 

   197 	SCell* pC = (SCell*)(((TUint8*)aCell)-EAllocCellSize);

   198 	__CHECK_CELL(pC);

   199 

   200 	return pC;

   201 	}

   202 

   203 

   204 

   205 

   206 UEXPORT_C TInt RHeap::AllocLen(const TAny* aCell) const

   207 /**

   208 Gets the length of the available space in the specified allocated cell.

   209 

   210 @param aCell A pointer to the allocated cell.

   211 

   212 @return The length of the available space in the allocated cell.

   213 

   214 @panic USER 42 if aCell does not point to  a valid cell.

   215 */

   216 	{

   217 

   218 	SCell* pC = GetAddress(aCell);

   219 	return pC->len - EAllocCellSize;

   220 	}

   221 

   222 

   223 

   224 

   225 

   226 #if !defined(__HEAP_MACHINE_CODED__) || defined(_DEBUG)

   227 RHeap::SCell* RHeap::DoAlloc(TInt aSize, SCell*& aLastFree)

   228 //

   229 // Allocate without growing. aSize includes cell header and alignment.

   230 // Lock already held.

   231 //

   232 	{

   233 	SCell* pP = &iFree;

   234 	SCell* pC = pP->next;

   235 	for (; pC; pP=pC, pC=pC->next) // Scan the free list

   236 		{

   237 		__CHECK_CELL(pC);

   238 		SCell* pE;

   239 		if (pC->len >= aSize)				// Block size bigger than request

   240 			{

   241 			if (pC->len - aSize < iMinCell)	// Leftover must be large enough to hold an SCell

   242 			   	{

   243 			   	aSize = pC->len;			// It isn't, so take it all

   244 			   	pE = pC->next;				// Set the next field

   245 			   	}

   246 			else

   247 			   	{

   248 			   	pE = (SCell*)(((TUint8*)pC)+aSize); // Take amount required

   249 			   	pE->len = pC->len - aSize;	// Initialize new free cell

   250 			   	pE->next = pC->next;

   251 			   	}

   252 			pP->next = pE;					// Update previous pointer

   253 			pC->len = aSize;				// Set control size word

   254 #if defined(_DEBUG)														

   255 			((SDebugCell*)pC)->nestingLevel = iNestingLevel;

   256 			((SDebugCell*)pC)->allocCount = ++iAllocCount;

   257 #endif

   258 			return pC;

   259 			}

   260 		}

   261 	aLastFree = pP;

   262 	return NULL;

   263 	}

   264 #endif

   265 

   266 

   267 

   268 

   269 UEXPORT_C TAny* RHeap::Alloc(TInt aSize)

   270 /**

   271 Allocates a cell of the specified size from the heap.

   272 

   273 If there is insufficient memory available on the heap from which to allocate

   274 a cell of the required size, the function returns NULL.

   275 

   276 The cell is aligned according to the alignment value specified at construction,

   277 or the default alignment value, if an explict value was not specified.

   278 

   279 The resulting size of the allocated cell may be rounded up to a

   280 value greater than aSize, but is guaranteed to be not less than aSize.

   281 

   282 @param aSize The 

   283 size of the cell to be allocated from the heap

   284 

   285 @return A pointer to the allocated cell. NULL if there is insufficient memory 

   286         available.

   287         

   288 @panic USER 47 if the maximum unsigned value of aSize is greater than or equal

   289        to the value of KMaxTInt/2; for example, calling Alloc(-1) raises

   290        this panic.

   291        

   292 @see KMaxTInt        

   293 */

   294 	{

   295 

   296 	__CHECK_THREAD_STATE;

   297 	__ASSERT_ALWAYS((TUint)aSize<(KMaxTInt/2),HEAP_PANIC(ETHeapBadAllocatedCellSize));

   298 	__SIMULATE_ALLOC_FAIL(return NULL;)

   299 	

   300 	TInt origSize = aSize;

   301 	aSize = Max(Align(aSize + EAllocCellSize), iMinCell);

   302 	SCell* pL = NULL;

   303 	Lock();

   304 	SCell* pC = (SCell*)DoAlloc(aSize, pL);

   305 	if (!pC && !(iFlags & EFixedSize))

   306 		{

   307 		// try to grow chunk heap

   308 		TInt r = TryToGrowHeap(aSize, pL);

   309 		if (r==KErrNone)

   310 			pC = DoAlloc(aSize, pL);

   311 		}

   312 	if (pC)

   313 		++iCellCount, iTotalAllocSize += (pC->len - EAllocCellSize);

   314 	Unlock();

   315 	if (pC)

   316 		{

   317 		TAny* result=((TUint8*)pC) + EAllocCellSize;

   318 		if (iFlags & ETraceAllocs)

   319 			{

   320 			TUint32 traceData[2];

   321 			traceData[0] = AllocLen(result);

   322 			traceData[1] = origSize;

   323 			BTraceContextN(BTrace::EHeap, BTrace::EHeapAlloc, (TUint32)this, (TUint32)result, traceData, sizeof(traceData));

   324 			}

   325 #ifdef __KERNEL_MODE__

   326 		memclr(result, pC->len - EAllocCellSize);

   327 #endif		

   328 		return result;

   329 		}

   330 	if (iFlags & ETraceAllocs)						

   331 			BTraceContext8(BTrace::EHeap, BTrace::EHeapAllocFail, (TUint32)this, (TUint32)origSize);

   332 	return NULL;

   333 	}

   334 

   335 

   336 

   337 

   338 TInt RHeap::TryToGrowHeap(TInt aSize, SCell* aLastFree)

   339 	{

   340 	TBool at_end = IsLastCell(aLastFree);

   341 	TInt extra = at_end ? aSize - aLastFree->len : aSize;

   342 	extra = (extra + iGrowBy - 1) / iGrowBy;

   343 	extra *= iGrowBy;

   344 	TInt cur_len = _ALIGN_UP(iTop - ((TUint8*)this - iOffset), iPageSize);

   345 	TInt new_len = cur_len + extra;

   346 	TInt r = KErrNoMemory;

   347 	if (new_len <= iMaxLength)

   348 		{

   349 		r = SetBrk(new_len);

   350 		if (r == KErrNone)

   351 			{

   352 			if (at_end)

   353 				aLastFree->len += extra;

   354 			else

   355 				{

   356 				SCell* pC = (SCell*)iTop;

   357 				pC->len = extra;

   358 				pC->next = NULL;

   359 				aLastFree->next = pC;

   360 				}

   361 			iTop += extra;

   362 			}

   363 		}

   364 	return r;

   365 	}

   366 

   367 

   368 

   369 

   370 #ifndef __KERNEL_MODE__

   371 EXPORT_C TInt RHeap::Compress()

   372 /**

   373 Compresses the heap.

   374 

   375 The function frees excess committed space from the top 

   376 of the heap. The size of the heap is never reduced below the minimum size 

   377 specified during creation of the heap.

   378 

   379 @return The space reclaimed. If no space can be reclaimed, then this value 

   380         is zero.

   381 */

   382 	{

   383 

   384 	if (iFlags & EFixedSize)

   385 		return 0;

   386 	TInt r = 0;

   387 	Lock();

   388 	SCell* pC = &iFree;

   389 	for (; pC->next; pC=pC->next) {}

   390 	if (pC!=&iFree)

   391 		{

   392 		__CHECK_CELL(pC);

   393 		if (IsLastCell(pC))

   394 			r = Reduce(pC);

   395 		}

   396 	Unlock();

   397 	return r;

   398 	}

   399 #endif

   400 

   401 

   402 

   403 

   404 #if !defined(__HEAP_MACHINE_CODED__) || defined(_DEBUG)

   405 void RHeap::DoFree(SCell* pC)

   406 	{

   407 	__ZAP_CELL(pC);

   408 

   409 	SCell* pP = &iFree;

   410 	SCell* pE = pP->next;

   411 	for (; pE && pE<pC; pP=pE, pE=pE->next) {}

   412 	if (pE)			// Is there a following free cell?

   413 		{

   414 		SCell* pN = __NEXT_CELL(pC);

   415 		__ASSERT_ALWAYS(pN<=pE, HEAP_PANIC(ETHeapFreeBadNextCell)); // Following cell overlaps

   416 		if (pN==pE) // Is it adjacent

   417 			{

   418 			pC->len += pE->len; // Yes - coalesce adjacent free cells

   419 			pC->next = pE->next;

   420 			}

   421 		else					// pN<pE, non-adjacent free cells

   422 			pC->next = pE;		// Otherwise just point to it

   423 		}

   424 	else

   425 		pC->next = NULL;		// No following free cell

   426 	SCell* pN = __NEXT_CELL(pP);	// pN=pP=&iFree if no preceding free cell

   427 	__ASSERT_ALWAYS(pN<=pC, HEAP_PANIC(ETHeapFreeBadPrevCell)); // Previous cell overlaps

   428 	if (pN==pC) // Is it adjacent

   429 		{

   430 		pP->len += pC->len;		// Yes - coalesce adjacent free cells

   431 		pP->next = pC->next;

   432 		pC = pP;				// for size reduction check

   433 		}

   434 	else						// pN<pC, non-adjacent free cells

   435 		pP->next = pC;			// point previous cell to the one being freed

   436 	pN = __NEXT_CELL(pC);		// End of amalgamated free cell

   437 	if ((TUint8*)pN==iTop && !(iFlags & EFixedSize) && 

   438 		pC->len >= KHeapShrinkHysRatio*(iGrowBy>>8))

   439 		Reduce(pC);

   440 	}

   441 #endif

   442 

   443 

   444 

   445 

   446 UEXPORT_C void RHeap::Free(TAny* aCell)

   447 /**

   448 Frees the specified cell and returns it to the heap.

   449 

   450 @param aCell A pointer to a valid cell; this pointer can also be NULL,

   451              in which case the function does nothing and just returns.

   452 

   453 @panic USER 42 if aCell points to an invalid cell.

   454 */

   455 	{

   456 	__CHECK_THREAD_STATE;

   457 	if (!aCell)

   458 		return;

   459 	Lock();

   460 	if (iFlags & EMonitorMemory)

   461 		__MEMORY_MONITOR_CHECK_CELL(aCell);

   462 	SCell* pC = GetAddress(aCell);

   463 	--iCellCount;

   464 	iTotalAllocSize -= (pC->len - EAllocCellSize);

   465 	DoFree(pC);

   466 	if (iFlags & ETraceAllocs)

   467 		BTraceContext8(BTrace::EHeap, BTrace::EHeapFree, (TUint32)this, (TUint32)aCell);

   468 	Unlock();

   469 	}

   470 

   471 

   472 

   473 

   474 TInt RHeap::Reduce(SCell* aCell)

   475 	{

   476 	TInt reduce=0;

   477 	TInt offset=((TUint8*)aCell)-((TUint8*)this - iOffset);

   478 	if (offset>=iMinLength)

   479 		reduce = aCell->len;						// length of entire free cell

   480 	else

   481 		reduce = offset + aCell->len - iMinLength;	// length of free cell past minimum heap size

   482 	reduce = _ALIGN_DOWN(reduce, iPageSize);		// round down to page multiple

   483 	if (reduce<=0)

   484 		return 0;									// can't reduce this heap

   485 	TInt new_cell_len = aCell->len - reduce;		// length of last free cell after reduction

   486 	if (new_cell_len == 0)

   487 		{

   488 		// the free cell can be entirely eliminated

   489 		SCell* pP = &iFree;

   490 		for (; pP->next!=aCell; pP=pP->next) {}

   491 		pP->next = NULL;

   492 		}

   493 	else

   494 		{

   495 		if (new_cell_len < iMinCell)

   496 			{

   497 			// max reduction would leave a cell too small

   498 			reduce -= iPageSize;

   499 			new_cell_len += iPageSize;

   500 			}

   501 		aCell->len = new_cell_len;	// reduce the cell length

   502 		}

   503 	iTop -= reduce;

   504 	TInt new_len = _ALIGN_UP(iTop - ((TUint8*)this - iOffset), iPageSize);

   505 	TInt r = SetBrk(new_len);

   506 	__ASSERT_ALWAYS(r==KErrNone, HEAP_PANIC(ETHeapReduceFailed));

   507 	return reduce;

   508 	}

   509 

   510 

   511 

   512 

   513 #ifndef __KERNEL_MODE__

   514 EXPORT_C void RHeap::Reset()

   515 /**

   516 Frees all allocated cells on this heap.

   517 */

   518 	{

   519 

   520 	Lock();

   521 	if (!(iFlags & EFixedSize))

   522 		{

   523 		TInt r = SetBrk(iMinLength);

   524 		__ASSERT_ALWAYS(r==KErrNone, HEAP_PANIC(ETHeapResetFailed));

   525 		}

   526 	Initialise();

   527 	Unlock();

   528 	}

   529 #endif

   530 

   531 

   532 

   533 

   534 inline void RHeap::FindFollowingFreeCell(SCell* aCell, SCell*& aPrev, SCell*& aNext)

   535 //

   536 // Find the free cell that immediately follows aCell, if one exists

   537 // If found, aNext is set to point to it, else it is set to NULL.

   538 // aPrev is set to the free cell before aCell or the dummy free cell where there are no free cells before aCell.

   539 // Called with lock enabled.

   540 //

   541 	{

   542 	aPrev = &iFree;

   543 	aNext = aPrev->next;

   544 	for (; aNext && aNext<aCell; aPrev=aNext, aNext=aNext->next) {}	

   545 	

   546 	if (aNext) // If there is a following free cell, check its directly after aCell.

   547 		{

   548 			SCell* pNextCell = __NEXT_CELL(aCell);			// end of this cell

   549 			__ASSERT_ALWAYS(pNextCell<=aNext, (Unlock(), HEAP_PANIC(ETHeapReAllocBadNextCell)));	// Following free cell overlaps

   550 			if (pNextCell!=aNext) 

   551 				aNext=NULL;		

   552 		}

   553 	}

   554 

   555 

   556 

   557 

   558 TInt RHeap::TryToGrowCell(SCell* aCell,SCell* aPrev, SCell* aNext, TInt aSize)

   559 //

   560 // Try to grow the heap cell 'aCell' in place, to size 'aSize'.

   561 // Requires the free cell immediately after aCell (aNext), and the free cell prior to

   562 // that (aPrev), to be provided.  (As found by FindFollowingFreeCell)

   563 //

   564 

   565 	{

   566 	TInt extra = aSize - aCell->len;

   567 	if (aNext && (aNext->len>=extra)) // Is there a following free cell big enough?

   568 		{

   569 		if (aNext->len - extra >= iMinCell)	// take part of free cell ?

   570 			{

   571 			SCell* pX = (SCell*)((TUint8*)aNext + extra);	// remainder of free cell

   572 			pX->next = aNext->next;			// remainder->next = original free cell->next

   573 			pX->len = aNext->len - extra;		// remainder length = original free cell length - extra

   574 			aPrev->next = pX;					// put remainder into free chain

   575 			}

   576 		else

   577 			{

   578 			extra = aNext->len;					// Take whole free cell

   579 			aPrev->next = aNext->next;			// remove from free chain

   580 			}

   581 #ifdef __KERNEL_MODE__

   582 		memclr(((TUint8*)aCell) + aCell->len, extra);

   583 #endif		

   584 		aCell->len += extra;					// update reallocated cell length

   585 		iTotalAllocSize += extra;

   586 		return KErrNone;

   587 		}

   588 	return KErrGeneral;  // No space to grow cell

   589 	}

   590 

   591 

   592 

   593 

   594 // UEXPORT_C TAny* RHeap::ReAlloc(TAny* aCell, TInt aSize, TInt aMode)

   595 /**

   596 Increases or decreases the size of an existing cell in the heap.

   597 

   598 If the cell is being decreased in size, then it is guaranteed not to move,

   599 and the function returns the pointer originally passed in aCell. Note that the

   600 length of the cell will be the same if the difference between the old size

   601 and the new size is smaller than the minimum cell size.

   602 

   603 If the cell is being increased in size, i.e. aSize is bigger than its

   604 current size, then the function tries to grow the cell in place.

   605 If successful, then the function returns the pointer originally

   606 passed in aCell. If unsuccessful, then:

   607 

   608 1. if the cell cannot be moved, i.e. aMode has the ENeverMove bit set, then

   609    the function returns NULL.

   610 2. if the cell can be moved, i.e. aMode does not have the ENeverMove bit set,

   611    then the function tries to allocate a new replacement cell, and, if

   612    successful, returns a pointer to the new cell; if unsuccessful, it

   613    returns NULL.

   614 

   615 Note that in debug mode, the function returns NULL if the cell cannot be grown

   616 in place, regardless of whether the ENeverMove bit is set.

   617 

   618 If the reallocated cell is at a different location from the original cell, then

   619 the content of the original cell is copied to the reallocated cell.

   620 

   621 If the supplied pointer, aCell is NULL, then the function attempts to allocate

   622 a new cell, but only if the cell can be moved, i.e. aMode does not have

   623 the ENeverMove bit set.

   624 

   625 Note the following general points:

   626 

   627 1. If reallocation fails, the content of the original cell is preserved.

   628 

   629 2. The resulting size of the re-allocated cell may be rounded up to a value

   630    greater than aSize, but is guaranteed to be not less than aSize.

   631  

   632 @param aCell A pointer to the cell to be reallocated. This may be NULL.

   633 

   634 @param aSize The new size of the cell. This may be bigger or smaller than the

   635              size of the original cell.

   636              

   637 @param aMode Flags controlling the reallocation. The only bit which has any

   638              effect on this function is that defined by the enumeration

   639              ENeverMove of the enum RAllocator::TReAllocMode.

   640              If this is set, then any successful reallocation guarantees not

   641              to have changed the start address of the cell.

   642              By default, this parameter is zero.

   643 

   644 @return A pointer to the reallocated cell. This may be the same as the original

   645         pointer supplied through aCell. NULL if there is insufficient memory to

   646         reallocate the cell, or to grow it in place.

   647 

   648 @panic USER 42, if aCell is not NULL, and does not point to a valid cell.

   649 @panic USER 47, if the maximum unsigned value of aSize is greater

   650                 than or equal to KMaxTInt/2. For example,

   651                 calling ReAlloc(someptr,-1) raises this panic.

   652 

   653 @see RAllocator::TReAllocMode

   654 */

   655 UEXPORT_C TAny* RHeap::ReAlloc(TAny* aCell, TInt aSize, TInt aMode)

   656 	{

   657 	if (aCell && iFlags&EMonitorMemory)

   658 		__MEMORY_MONITOR_CHECK_CELL(aCell);

   659 	TAny* retval = ReAllocImpl(aCell, aSize, aMode);

   660 	if (iFlags & ETraceAllocs)

   661 		{

   662 		if (retval)

   663 			{

   664 			TUint32 traceData[3];

   665 			traceData[0] = AllocLen(retval);

   666 			traceData[1] = aSize;

   667 			traceData[2] = (TUint32)aCell;

   668 			BTraceContextN(BTrace::EHeap, BTrace::EHeapReAlloc,(TUint32)this, (TUint32)retval,traceData, sizeof(traceData));

   669 			}

   670 		else

   671 			BTraceContext12(BTrace::EHeap, BTrace::EHeapReAllocFail, (TUint32)this, (TUint32)aCell, (TUint32)aSize);

   672 		}

   673 	return retval;

   674 	}

   675 inline TAny* RHeap::ReAllocImpl(TAny* aCell, TInt aSize, TInt aMode)

   676 	{

   677 	__CHECK_THREAD_STATE;

   678 	if (!aCell)

   679 		return (aMode & ENeverMove) ? NULL : Alloc(aSize);

   680 	__ASSERT_ALWAYS((TUint)aSize<(KMaxTInt/2),HEAP_PANIC(ETHeapBadAllocatedCellSize));

   681 	Lock();

   682 	SCell* pC = GetAddress(aCell);

   683 	TInt old_len = pC->len;

   684 	__DEBUG_SAVE(pC);

   685 	aSize = Max(Align(aSize + EAllocCellSize), iMinCell);

   686 	if (aSize > old_len)	// Trying to grow cell

   687 		{

   688 		__SIMULATE_ALLOC_FAIL({	Unlock(); return NULL;})			

   689 		

   690 		// Try to grow cell in place, without reallocation

   691 		SCell* pPrev;

   692 		SCell* pNext;

   693 		FindFollowingFreeCell(pC,pPrev, pNext);

   694 		TInt r = TryToGrowCell(pC, pPrev, pNext, aSize);

   695 		

   696 		if (r==KErrNone) 

   697 			{

   698 			Unlock();

   699 			return aCell;

   700 			}

   701 

   702 		if (!(aMode & ENeverMove))

   703 		// If moving allowed, try re-alloc. 

   704 		// If we need to extend heap,and cell is at the end, try and grow in place

   705 			{

   706 			SCell* pLastFree;

   707 			SCell* pNewCell = (SCell*)DoAlloc(aSize, pLastFree);

   708 			if (!pNewCell && !(iFlags & EFixedSize))

   709 			// if we need to extend the heap to alloc

   710 				{

   711 				if (IsLastCell(pC) || (pNext && IsLastCell(pNext)))

   712 				// if last used Cell, try and extend heap and then cell 

   713 					{

   714 					TInt r = TryToGrowHeap(aSize - old_len, pLastFree);

   715 					if (r==KErrNone)

   716 						{

   717 						r = TryToGrowCell(pC, pPrev, pPrev->next, aSize);

   718 						Unlock();

   719 						__ASSERT_DEBUG(r == KErrNone, HEAP_PANIC(ETHeapCellDidntGrow));						

   720 						return aCell;

   721 						}

   722 					}

   723 				else

   724 				// try to grow chunk heap and Alloc on it

   725 					{

   726 					TInt r = TryToGrowHeap(aSize, pLastFree);

   727 					if (r==KErrNone)

   728 						pNewCell = DoAlloc(aSize, pLastFree);

   729 					}

   730 				}

   731 

   732 			if (pNewCell)

   733 			// if we created a new cell, adjust tellies, copy the contents and delete old cell.

   734 				{

   735 				iCellCount++;

   736 				iTotalAllocSize += (pNewCell->len - EAllocCellSize);

   737 

   738 				Unlock();

   739 				TUint8* raw = ((TUint8*) pNewCell);

   740 				

   741 				memcpy(raw + EAllocCellSize, aCell, old_len - EAllocCellSize);

   742 #ifdef __KERNEL_MODE__

   743 				memclr(raw + old_len, pNewCell->len - old_len);

   744 #endif		

   745 				Free(aCell);

   746 				__DEBUG_RESTORE(raw + EAllocCellSize);

   747 				return raw + EAllocCellSize;

   748 				}

   749 			}

   750 		else 

   751 		// No moving, but still posible to extend the heap (if heap extendable)

   752 			{

   753 			if (!(iFlags & EFixedSize) && (IsLastCell(pC) || (pNext && IsLastCell(pNext))))

   754 				{

   755 				SCell* pLastFree = pNext ? pNext : pPrev;

   756 				TInt r = TryToGrowHeap(aSize - old_len, pLastFree);

   757 				if (r==KErrNone)

   758 					{

   759 					r = TryToGrowCell(pC, pPrev, pPrev->next, aSize);

   760 					Unlock();

   761 					__ASSERT_DEBUG(r==KErrNone, HEAP_PANIC(ETHeapCellDidntGrow));					

   762 					return aCell;

   763 					}

   764 				}

   765 			}			

   766 		Unlock();

   767 		return NULL;

   768 		}

   769 	if (old_len - aSize >= iMinCell)

   770 		{

   771 		// cell shrinking, remainder big enough to form a new free cell

   772 		SCell* pX = (SCell*)((TUint8*)pC + aSize);	// pointer to new free cell

   773 		pC->len = aSize;			// update cell size

   774 		pX->len = old_len - aSize;	// size of remainder

   775 		iTotalAllocSize -= pX->len;

   776 		DoFree(pX);					// link new free cell into chain, shrink heap if necessary

   777 		}

   778 	Unlock();

   779 	return aCell;

   780 	}

   781 

   782 

   783 

   784 

   785 #ifndef __KERNEL_MODE__

   786 

   787 EXPORT_C TInt RHeap::Available(TInt& aBiggestBlock) const

   788 /**

   789 Gets the total free space currently available on the heap and the space 

   790 available in the largest free block.

   791 

   792 The space available represents the total space which can be allocated.

   793 

   794 Note that compressing the heap may reduce the total free space available and 

   795 the space available in the largest free block.

   796 

   797 @param aBiggestBlock On return, contains the space available 

   798                      in the largest free block on the heap.

   799                      

   800 @return The total free space currently available on the heap.

   801 */

   802 	{

   803 

   804 	TInt total = 0;

   805 	TInt max = 0;

   806 	Lock();

   807 	SCell* pC = iFree.next;

   808 	for (; pC; pC=pC->next)

   809 		{

   810 		TInt l = pC->len - EAllocCellSize;

   811 		if (l > max)

   812 			max = l;

   813 		total += l;

   814 		}

   815 	Unlock();

   816 	aBiggestBlock = max;

   817 	return total;

   818 	}

   819 

   820 

   821 

   822 

   823 EXPORT_C TInt RHeap::AllocSize(TInt& aTotalAllocSize) const

   824 /**

   825 Gets the number of cells allocated on this heap, and the total space 

   826 allocated to them.

   827 

   828 @param aTotalAllocSize On return, contains the total space allocated

   829                        to the cells.

   830 

   831 @return The number of cells allocated on this heap.

   832 */

   833 	{

   834 	Lock();

   835 	TInt c = iCellCount;

   836 	aTotalAllocSize = iTotalAllocSize;

   837 	Unlock();

   838 	return c;

   839 	}

   840 

   841 

   842 

   843 

   844 EXPORT_C RHeap* UserHeap::FixedHeap(TAny* aBase, TInt aMaxLength, TInt aAlign, TBool aSingleThread)

   845 /**

   846 Creates a fixed length heap at a specified location.

   847 

   848 On successful return from this function, aMaxLength bytes are committed by the chunk.

   849 The heap cannot be extended.

   850 

   851 @param aBase         A pointer to the location where the heap is to be constructed.

   852 @param aMaxLength    The length of the heap. If the supplied value is less

   853                      than KMinHeapSize, it is discarded and the value KMinHeapSize

   854                      is used instead.

   855 @param aAlign        The alignment of heap cells.

   856 @param aSingleThread Indicates whether single threaded or not.

   857 

   858 @return A pointer to the new heap, or NULL if the heap could not be created.

   859 

   860 @panic USER 56 if aMaxLength is negative.

   861 @panic USER 172 if aAlign is not a power of 2 or is less than the size of a TAny*.

   862 */

   863 //

   864 // Force construction of the fixed memory.

   865 //

   866 	{

   867 

   868 	__ASSERT_ALWAYS(aMaxLength>=0, ::Panic(ETHeapMaxLengthNegative));

   869 	if (aMaxLength<KMinHeapSize)

   870 		aMaxLength=KMinHeapSize;

   871 	RHeap* h = new(aBase) RHeap(aMaxLength, aAlign, aSingleThread);

   872 	if (!aSingleThread)

   873 		{

   874 		TInt r = h->iLock.CreateLocal();

   875 		if (r!=KErrNone)

   876 			return NULL;

   877 		h->iHandles = (TInt*)&h->iLock;

   878 		h->iHandleCount = 1;

   879 		}

   880 	return h;

   881 	}

   882 

   883 

   884 /**

   885 Constructor where minimum and maximum length of the heap can be defined.

   886 It defaults the chunk heap to be created to have use a new local chunk, 

   887 to have a grow by value of KMinHeapGrowBy, to be unaligned, not to be 

   888 single threaded and not to have any mode flags set.

   889 

   890 @param aMinLength    The minimum length of the heap to be created.

   891 @param aMaxLength    The maximum length to which the heap to be created can grow.

   892                      If the supplied value is less than KMinHeapSize, then it

   893                      is discarded and the value KMinHeapSize used instead.

   894 */

   895 EXPORT_C TChunkHeapCreateInfo::TChunkHeapCreateInfo(TInt aMinLength, TInt aMaxLength) :

   896 	iVersionNumber(EVersion0), iMinLength(aMinLength), iMaxLength(aMaxLength),

   897 	iAlign(0), iGrowBy(1), iSingleThread(EFalse), 

   898 	iOffset(0), iPaging(EUnspecified), iMode(0), iName(NULL)

   899 	{

   900 	}

   901 

   902 

   903 /**

   904 Sets the chunk heap to create a new chunk with the specified name.

   905 

   906 This overriddes any previous call to TChunkHeapCreateInfo::SetNewChunkHeap() or

   907 TChunkHeapCreateInfo::SetExistingChunkHeap() for this TChunkHeapCreateInfo object.

   908 

   909 @param aName	The name to be given to the chunk heap to be created

   910 				If NULL, the function constructs a local chunk to host the heap.

   911 				If not NULL, a pointer to a descriptor containing the name to be 

   912 				assigned to the global chunk hosting the heap.

   913 */

   914 EXPORT_C void TChunkHeapCreateInfo::SetCreateChunk(const TDesC* aName)

   915 	{

   916 	iName = (TDesC*)aName;

   917 	iChunk.SetHandle(KNullHandle);

   918 	}

   919 

   920 

   921 /**

   922 Sets the chunk heap to be created to use the chunk specified.

   923 

   924 This overriddes any previous call to TChunkHeapCreateInfo::SetNewChunkHeap() or

   925 TChunkHeapCreateInfo::SetExistingChunkHeap() for this TChunkHeapCreateInfo object.

   926 

   927 @param aChunk	A handle to the chunk to use for the heap.

   928 */

   929 EXPORT_C void TChunkHeapCreateInfo::SetUseChunk(const RChunk aChunk)

   930 	{

   931 	iName = NULL;

   932 	iChunk = aChunk;

   933 	}

   934 

   935 

   936 /**

   937 Creates a chunk heap of the type specified by the parameter aCreateInfo.

   938 

   939 @param aCreateInfo	A reference to a TChunkHeapCreateInfo object specifying the

   940 					type of chunk heap to create.

   941 

   942 @return A pointer to the new heap or NULL if the heap could not be created.

   943 

   944 @panic USER 41 if the heap's specified minimum length is greater than the specified maximum length.

   945 @panic USER 55 if the heap's specified minimum length is negative.

   946 @panic USER 172 if the heap's specified alignment is not a power of 2 or is less than the size of a TAny*.

   947 */

   948 EXPORT_C RHeap* UserHeap::ChunkHeap(const TChunkHeapCreateInfo& aCreateInfo)

   949 	{

   950 	// aCreateInfo must have been configured to use a new chunk or an exiting chunk.

   951 	__ASSERT_ALWAYS(!(aCreateInfo.iMode & (TUint32)~EChunkHeapMask), ::Panic(EHeapCreateInvalidMode));

   952 	RHeap* h = NULL;

   953 

   954 	if (aCreateInfo.iChunk.Handle() == KNullHandle)

   955 		{// A new chunk is to be created for this heap.

   956 		__ASSERT_ALWAYS(aCreateInfo.iMinLength >= 0, ::Panic(ETHeapMinLengthNegative));

   957 		__ASSERT_ALWAYS(aCreateInfo.iMaxLength >= aCreateInfo.iMinLength, ::Panic(ETHeapCreateMaxLessThanMin));

   958 

   959 		TInt maxLength = aCreateInfo.iMaxLength;

   960 		if (maxLength < KMinHeapSize)

   961 			maxLength = KMinHeapSize;

   962 

   963 		TChunkCreateInfo chunkInfo;

   964 		chunkInfo.SetNormal(0, maxLength);

   965 		chunkInfo.SetOwner((aCreateInfo.iSingleThread)? EOwnerThread : EOwnerProcess);

   966 		if (aCreateInfo.iName)

   967 			chunkInfo.SetGlobal(*aCreateInfo.iName);

   968 		// Set the paging attributes of the chunk.

   969 		if (aCreateInfo.iPaging == TChunkHeapCreateInfo::EPaged)

   970 			chunkInfo.SetPaging(TChunkCreateInfo::EPaged);

   971 		if (aCreateInfo.iPaging == TChunkHeapCreateInfo::EUnpaged)

   972 			chunkInfo.SetPaging(TChunkCreateInfo::EUnpaged);

   973 		// Create the chunk.

   974 		RChunk chunk;

   975 		if (chunk.Create(chunkInfo) != KErrNone)

   976 			return NULL;

   977 		// Create the heap using the new chunk.

   978 		TUint mode = aCreateInfo.iMode | EChunkHeapDuplicate;	// Must duplicate the handle.

   979 		h = OffsetChunkHeap(chunk, aCreateInfo.iMinLength, aCreateInfo.iOffset,

   980 							aCreateInfo.iGrowBy, maxLength, aCreateInfo.iAlign,

   981 							aCreateInfo.iSingleThread, mode);

   982 		chunk.Close();

   983 		}

   984 	else

   985 		{

   986 		h = OffsetChunkHeap(aCreateInfo.iChunk, aCreateInfo.iMinLength, aCreateInfo.iOffset,

   987 							aCreateInfo.iGrowBy, aCreateInfo.iMaxLength, aCreateInfo.iAlign,

   988 							aCreateInfo.iSingleThread, aCreateInfo.iMode);

   989 		}

   990 	return h;

   991 	}

   992 

   993 

   994 EXPORT_C RHeap* UserHeap::ChunkHeap(const TDesC* aName, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign, TBool aSingleThread)

   995 /**

   996 Creates a heap in a local or global chunk.

   997 

   998 The chunk hosting the heap can be local or global.

   999 

  1000 A local chunk is one which is private to the process creating it and is not

  1001 intended for access by other user processes.

  1002 A global chunk is one which is visible to all processes.

  1003 

  1004 The hosting chunk is local, if the pointer aName is NULL, otherwise

  1005 the hosting chunk is global and the descriptor *aName is assumed to contain

  1006 the name to be assigned to it.

  1007 

  1008 Ownership of the host chunk is vested in the current process.

  1009 

  1010 A minimum and a maximum size for the heap can be specified. On successful

  1011 return from this function, the size of the heap is at least aMinLength.

  1012 If subsequent requests for allocation of memory from the heap cannot be

  1013 satisfied by compressing the heap, the size of the heap is extended in

  1014 increments of aGrowBy until the request can be satisfied. Attempts to extend

  1015 the heap causes the size of the host chunk to be adjusted.

  1016 

  1017 Note that the size of the heap cannot be adjusted by more than aMaxLength.

  1018 

  1019 @param aName         If NULL, the function constructs a local chunk to host

  1020                      the heap.

  1021                      If not NULL, a pointer to a descriptor containing the name

  1022                      to be assigned to the global chunk hosting the heap.

  1023 @param aMinLength    The minimum length of the heap.

  1024 @param aMaxLength    The maximum length to which the heap can grow.

  1025                      If the supplied value is less than KMinHeapSize, then it

  1026                      is discarded and the value KMinHeapSize used instead.

  1027 @param aGrowBy       The increments to the size of the host chunk. If a value is

  1028                      not explicitly specified, the value KMinHeapGrowBy is taken

  1029                      by default

  1030 @param aAlign        The alignment of heap cells.

  1031 @param aSingleThread Indicates whether single threaded or not.

  1032 

  1033 @return A pointer to the new heap or NULL if the heap could not be created.

  1034 

  1035 @panic USER 41 if aMinLength is greater than the supplied value of aMaxLength.

  1036 @panic USER 55 if aMinLength is negative.

  1037 @panic USER 172 if aAlign is not a power of 2 or is less than the size of a TAny*.

  1038 */

  1039 //

  1040 // Allocate a Chunk of the requested size and force construction.

  1041 //

  1042 	{

  1043 	TChunkHeapCreateInfo createInfo(aMinLength, aMaxLength);

  1044 	createInfo.SetCreateChunk(aName);

  1045 	createInfo.SetGrowBy(aGrowBy);

  1046 	createInfo.SetAlignment(aAlign);

  1047 	createInfo.SetSingleThread(aSingleThread);

  1048 	return ChunkHeap(createInfo);

  1049 	}

  1050 

  1051 

  1052 

  1053 

  1054 EXPORT_C RHeap* UserHeap::ChunkHeap(RChunk aChunk, TInt aMinLength, TInt aGrowBy, TInt aMaxLength, TInt aAlign, TBool aSingleThread, TUint32 aMode)

  1055 /**

  1056 Creates a heap in an existing chunk.

  1057 

  1058 This function is intended to be used to create a heap in a user writable code

  1059 chunk as created by a call to RChunk::CreateLocalCode().

  1060 This type of heap can be used to hold code fragments from a JIT compiler.

  1061 

  1062 The maximum length to which the heap can grow is the same as

  1063 the maximum size of the chunk.

  1064 

  1065 @param aChunk        The chunk that will host the heap.

  1066 @param aMinLength    The minimum length of the heap.

  1067 @param aGrowBy       The increments to the size of the host chunk. 

  1068 @param aMaxLength    The maximum length to which the heap can grow.

  1069 @param aAlign        The alignment of heap cells.

  1070 @param aSingleThread Indicates whether single threaded or not.

  1071 @param aMode         Flags controlling the heap creation.  This should be set 

  1072 					 from one or more of the values in TChunkHeapCreateMode.

  1073                      

  1074 @return A pointer to the new heap or NULL if the heap could not be created.

  1075 

  1076 @panic USER 172 if aAlign is not a power of 2 or is less than the size of a TAny*.

  1077 */

  1078 //

  1079 // Construct a heap in an already existing chunk

  1080 //

  1081 	{

  1082 	

  1083 	return OffsetChunkHeap(aChunk, aMinLength, 0, aGrowBy, aMaxLength, aAlign, aSingleThread, aMode);

  1084 	}

  1085 

  1086 

  1087 

  1088 

  1089 EXPORT_C RHeap* UserHeap::OffsetChunkHeap(RChunk aChunk, TInt aMinLength, TInt aOffset, TInt aGrowBy, TInt aMaxLength, TInt aAlign, TBool aSingleThread, TUint32 aMode)

  1090 /**

  1091 Creates a heap in an existing chunk, offset from the beginning of the chunk.

  1092 

  1093 This function is intended to be used to create a heap where a fixed amount of

  1094 additional data must be stored at a known location. The additional data can be

  1095 placed at the base address of the chunk, allowing it to be located without

  1096 depending on the internals of the heap structure.

  1097 

  1098 The maximum length to which the heap can grow is the maximum size of the chunk,

  1099 minus the offset.

  1100 

  1101 @param aChunk        The chunk that will host the heap.

  1102 @param aMinLength    The minimum length of the heap.

  1103 @param aOffset       The offset from the start of the chunk, to the start of the heap.

  1104 @param aGrowBy       The increments to the size of the host chunk. 

  1105 @param aMaxLength    The maximum length to which the heap can grow.

  1106 @param aAlign        The alignment of heap cells.

  1107 @param aSingleThread Indicates whether single threaded or not.

  1108 @param aMode         Flags controlling the heap creation.  This should be set 

  1109 					 from one or more of the values in TChunkHeapCreateMode.

  1110                      

  1111 @return A pointer to the new heap or NULL if the heap could not be created.

  1112 

  1113 @panic USER 172 if aAlign is not a power of 2 or is less than the size of a TAny*.

  1114 */

  1115 //

  1116 // Construct a heap in an already existing chunk

  1117 //

  1118 	{

  1119 

  1120 	TInt page_size;

  1121 	UserHal::PageSizeInBytes(page_size);

  1122 	if (!aAlign)

  1123 		aAlign = RHeap::ECellAlignment;

  1124 	TInt maxLength = aChunk.MaxSize();

  1125 	TInt round_up = Max(aAlign, page_size);

  1126 	TInt min_cell = _ALIGN_UP(Max((TInt)RHeap::EAllocCellSize, (TInt)RHeap::EFreeCellSize), aAlign);

  1127 	aOffset = _ALIGN_UP(aOffset, 8);

  1128 	if (aMaxLength && aMaxLength+aOffset<maxLength)

  1129 		maxLength = _ALIGN_UP(aMaxLength+aOffset, round_up);

  1130 	__ASSERT_ALWAYS(aMinLength>=0, ::Panic(ETHeapMinLengthNegative));

  1131 	__ASSERT_ALWAYS(maxLength>=aMinLength, ::Panic(ETHeapCreateMaxLessThanMin));

  1132 	aMinLength = _ALIGN_UP(Max(aMinLength, (TInt)sizeof(RHeap) + min_cell) + aOffset, round_up);

  1133 	TInt r=aChunk.Adjust(aMinLength);

  1134 	if (r!=KErrNone)

  1135 		return NULL;