FCL/sf/os/kernelhwsrv: comparison kernel/eka/include/e32cmn.h

equal deleted inserted replaced

-:ef2a444a7410
+:b3a1d9898418
 /**
 Structure for compile-time definition of a secure ID
 @internalComponent
 */
+#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000
+#pragma push
+#pragma diag_suppress 430
+#endif
 class SSecureId
 	{
 public:
 	inline const TSecureId* operator&() const;
 	inline operator const TSecureId&() const;
 	inline operator TUint32() const;
 	inline operator TUid() const;
 public:
 	TUint32 iId;
 	};
+#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000
+#pragma pop
+#endif
 /**
 Structure for compile-time definition of a vendor ID
 @internalComponent
 */
+#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000
+#pragma push
+#pragma diag_suppress 430
+#endif
 class SVendorId
 	{
 public:
 	inline const TVendorId* operator&() const;
 	inline operator const TVendorId&() const;
 	inline operator TUint32() const;
 	inline operator TUid() const;
 public:
 	TUint32 iId;
 	};
+#if defined(__ARMCC__) && __ARMCC_VERSION >= 400000
+#pragma pop
+#endif
 /**
 Macro for compile-time definition of a secure ID
 Base class for heaps.
 */
 class RAllocator : public MAllocator
 	{
 public:
+	/**
+	A set of heap allocation failure flags.
-/**
-A set of heap allocation failure flags.
+	This enumeration indicates how to simulate heap allocation failure.
-This enumeration indicates how to simulate heap allocation failure.
+	@see RAllocator::__DbgSetAllocFail()
+	*/
-@see RAllocator::__DbgSetAllocFail()
+	enum TAllocFail
-*/
+		{
-	enum TAllocFail {
+		/**
-/**
+		Attempts to allocate from this heap fail at a random rate;
-Attempts to allocate from this heap fail at a random rate;
+		however, the interval pattern between failures is the same
-however, the interval pattern between failures is the same
+		every time simulation is started.
-every time simulation is started.
+		*/
-*/
+		ERandom,
-	                ERandom,
+		/**
+		Attempts to allocate from this heap fail at a random rate.
-	/**
+		The interval pattern between failures may be different every
-	Attempts to allocate from this heap fail at a random rate.
+		time the simulation is started.
-	The interval pattern between failures may be different every
+		*/
-	time the simulation is started.
+		ETrueRandom,
-	*/
-	                ETrueRandom,
+		/**
+		Attempts to allocate from this heap fail at a rate aRate;
+		for example, if aRate is 3, allocation fails at every
-/**
+		third attempt.
-Attempts to allocate from this heap fail at a rate aRate;
+		*/
-for example, if aRate is 3, allocation fails at every
+		EDeterministic,
-third attempt.
-*/
+		/**
-	                EDeterministic,
+		Cancels simulated heap allocation failure.
+		*/
+		ENone,
-	                /**
-	                Cancels simulated heap allocation failure.
+		/**
-	                */
+		An allocation from this heap will fail after the next aRate - 1
-	                ENone,
+		allocation attempts. For example, if aRate = 1 then the next
+		attempt to allocate from this heap will fail.
+		*/
-	                /**
+		EFailNext,
-	                An allocation from this heap will fail after the next aRate - 1
-					allocation attempts. For example, if aRate = 1 then the next
+		/**
-					attempt to allocate from this heap will fail.
+		Cancels simulated heap allocation failure, and sets
-	                */
+		the nesting level for all allocated cells to zero.
-	                EFailNext,
+		*/
+		EReset,
-	                /**
-	                Cancels simulated heap allocation failure, and sets
+		/**
-	                the nesting level for all allocated cells to zero.
+		aBurst allocations from this heap fail at a random rate;
-	                */
+		however, the interval pattern between failures is the same
-	                EReset,
+		every time the simulation is started.
+		*/
-/**
+		EBurstRandom,
-aBurst allocations from this heap fail at a random rate;
-however, the interval pattern between failures is the same
+		/**
-every time the simulation is started.
+		aBurst allocations from this heap fail at a random rate.
-*/
+		The interval pattern between failures may be different every
-	                EBurstRandom,
+		time the simulation is started.
+		*/
+		EBurstTrueRandom,
-	/**
-	aBurst allocations from this heap fail at a random rate.
+		/**
-	The interval pattern between failures may be different every
+		aBurst allocations from this heap fail at a rate aRate.
-	time the simulation is started.
+		For example, if aRate is 10 and aBurst is 2, then 2 allocations
-	*/
+		will fail at every tenth attempt.
-	                EBurstTrueRandom,
+		*/
+		EBurstDeterministic,
-/**
+		/**
-aBurst allocations from this heap fail at a rate aRate.
+		aBurst allocations from this heap will fail after the next aRate - 1
-For example, if aRate is 10 and aBurst is 2, then 2 allocations
+		allocation attempts have occurred. For example, if aRate = 1 and
-					will fail at every tenth attempt.
+		aBurst = 3 then the next 3 attempts to allocate from this heap will fail.
-*/
+		*/
-	                EBurstDeterministic,
+		EBurstFailNext,
-	                /**
+		/**
-	                aBurst allocations from this heap will fail after the next aRate - 1
+		Use this to determine how many times the current debug
-					allocation attempts have occurred. For example, if aRate = 1 and
+		failure mode has failed so far.
-					aBurst = 3 then the next 3 attempts to allocate from this heap will fail.
+		@see RAllocator::__DbgCheckFailure()
-	                */
+		*/
-	                EBurstFailNext,
+		ECheckFailure,
+		};
-					/**
-					Use this to determine how many times the current debug
+	/**
-					failure mode has failed so far.
+	Heap debug checking type flag.
-					@see RAllocator::__DbgCheckFailure()
+	*/
-					*/
+	enum TDbgHeapType
-					ECheckFailure,
+		{
-	                };
+		/**
+		The heap is a user heap.
+		*/
-/**
+		EUser,
-Heap debug checking type flag.
-*/
+		/**
-	enum TDbgHeapType {
+		The heap is the Kernel heap.
-/**
+		*/
-The heap is a user heap.
+		EKernel
-*/
+		};
-	                  EUser,
+	enum TAllocDebugOp
-/**
+		{
-The heap is the Kernel heap.
+		ECount, EMarkStart, EMarkEnd, ECheck, ESetFail, ECopyDebugInfo, ESetBurstFail, EGetFail,
-*/
+		EGetSize=48, EGetMaxLength, EGetBase, EAlignInteger, EAlignAddr
-	                  EKernel
+		};
-	                  };
-	enum TAllocDebugOp {ECount, EMarkStart, EMarkEnd, ECheck, ESetFail, ECopyDebugInfo, ESetBurstFail};
 	/**
 	Flags controlling reallocation.
 	*/
-	enum TReAllocMode {
+	enum TReAllocMode
-	                  /**
+		{
-	                  A reallocation of a cell must not change
+		/**
-	                  the start address of the cell.
+		A reallocation of a cell must not change
-	                  */
+		the start address of the cell.
-	                  ENeverMove=1,
+		*/
+		ENeverMove=1,
-	                  /**
-	                  Allows the start address of the cell to change
+		/**
-	                  if the cell shrinks in size.
+		Allows the start address of the cell to change
-	                  */
+		if the cell shrinks in size.
-	                  EAllowMoveOnShrink=2
+		*/
-	                  };
+		EAllowMoveOnShrink=2
+		};
 	enum TFlags {ESingleThreaded=1, EFixedSize=2, ETraceAllocs=4, EMonitorMemory=8,};
 	struct SCheckInfo {TBool iAll; TInt iCount; const TDesC8* iFileName; TInt iLineNum;};
 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
 	struct SRAllocatorBurstFail {TInt iBurst; TInt iRate; TInt iUnused[2];};
 #endif
 	UIMPORT_C void __DbgMarkStart();
 	UIMPORT_C TUint32 __DbgMarkEnd(TInt aCount);
 	UIMPORT_C TInt __DbgMarkCheck(TBool aCountAll, TInt aCount, const TDesC8& aFileName, TInt aLineNum);
 	inline void __DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum);
 	UIMPORT_C void __DbgSetAllocFail(TAllocFail aType, TInt aRate);
+	UIMPORT_C TAllocFail __DbgGetAllocFail();
 	UIMPORT_C void __DbgSetBurstAllocFail(TAllocFail aType, TUint aRate, TUint aBurst);
 	UIMPORT_C TUint __DbgCheckFailure();
+	UIMPORT_C TInt Size() const;
+	UIMPORT_C TInt MaxLength() const;
+	UIMPORT_C TUint8* Base() const;
+	UIMPORT_C TInt Align(TInt a) const;
+	UIMPORT_C TAny* Align(TAny* a) const;
 protected:
 	UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
 #ifndef __KERNEL_MODE__
 	IMPORT_C virtual void DoClose();
 #endif
 protected:
-	TInt iAccessCount;
+	TInt	iAccessCount;		// Value of the allocator's access count (ie. Number of times RAllocator::Open() has been called)
-	TInt iHandleCount;
+	TInt	iHandleCount;		// Number of handles in the iHandles array
-	TInt* iHandles;
+	TInt*	iHandles;			// Array of handles to chunks used by the heap implementation
-	TUint32 iFlags;
+	TUint32	iFlags;				// Flags describing attributes of the heap; see RAllocator::TFlags
-	TInt iCellCount;
+	TInt	iCellCount;			// Internal debugger use only; use MAllocator::AllocSize() instead
-	TInt iTotalAllocSize;
+	TInt	iTotalAllocSize;	// Internal debugger use only; use MAllocator::AllocSize() instead
 	};
 class UserHeap;
+// This #define is for tools such as MemSpy that need to work across different versions of
+// Symbian and need to know whether they are working with the new or old heap
+#define __SYMBIAN_KERNEL_HYBRID_HEAP__
 /**
 @publishedAll
 @released
 Represents the default implementation for a heap.
 The default implementation uses an address-ordered first fit type algorithm.
 The heap itself is contained in a chunk and may be the only occupant of the
 chunk or may share the chunk with the program stack.
 The class contains member functions for allocating, adjusting, freeing individual
 cells and generally managing the heap.
 The class is not a handle in the same sense that RChunk is a handle; i.e.
 there is no Kernel object which corresponds to the heap.
 */
 class RHeap : public RAllocator
 	{
 public:
-/**
-The structure of a heap cell header for a heap cell on the free list.
-*/
-	struct SCell {
-	             /**
-	             The length of the cell, which includes the length of
-	             this header.
-	             */
-	             TInt len;
-	             /**
-	             A pointer to the next cell in the free list.
-	             */
-	             SCell* next;
-	             };
-	/**
-The structure of a heap cell header for an allocated heap cell in a debug build.
-*/
-	struct SDebugCell {
-	                  /**
-	                  The length of the cell, which includes the length of
-this header.
-	                  */
-	                  TInt len;
-	                  /**
-	                  The nested level.
-	                  */
-	                  TInt nestingLevel;
-	                  /**
-	                  The cumulative number of allocated cells
-	                  */
-	                  TInt allocCount;
-	                  };
-	/**
-@internalComponent
-*/
-	struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc;	TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; };
-	/**
-	@internalComponent
-	*/
-	struct _s_align {char c; double d;};
-	/**
-	The default cell alignment.
-	*/
-	enum {ECellAlignment = sizeof(_s_align)-sizeof(double)};
-	/**
-	Size of a free cell header.
-	*/
-	enum {EFreeCellSize = sizeof(SCell)};
-#ifdef _DEBUG
-/**
-Size of an allocated cell header in a debug build.
-*/
-	enum {EAllocCellSize = sizeof(SDebugCell)};
-#else
-/**
-Size of an allocated cell header in a release build.
-*/
-	enum {EAllocCellSize = sizeof(SCell*)};
-#endif
-/**
-@internalComponent
-*/
-	enum TDebugOp {EWalk=128};
-/**
-@internalComponent
-*/
-	enum TCellType
-		{EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress,
-		EBadFreeCellAddress, EBadFreeCellSize};
-/**
-@internalComponent
-*/
-	enum TDebugHeapId {EUser=0, EKernel=1};
-/**
-@internalComponent
-*/
-enum TDefaultShrinkRatios {EShrinkRatio1=256, EShrinkRatioDflt=512};
-#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
-	/**
-@internalComponent
-*/
-#else
-private:
-#endif
-typedef void (*TWalkFunc)(TAny*, TCellType, TAny*, TInt);
-public:
 	UIMPORT_C virtual TAny* Alloc(TInt aSize);
 	UIMPORT_C virtual void Free(TAny* aPtr);
 	UIMPORT_C virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0);
 	UIMPORT_C virtual TInt AllocLen(const TAny* aCell) const;
 #ifndef __KERNEL_MODE__
 	UIMPORT_C virtual TInt Available(TInt& aBiggestBlock) const;
 #endif
 	UIMPORT_C virtual TInt DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL);
 protected:
 	UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1);
-public:
+	inline RHeap() { }
-	UIMPORT_C RHeap(TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue);
-	UIMPORT_C RHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign=0, TBool aSingleThread=EFalse);
+public:
-	UIMPORT_C TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW;
-	inline void operator delete(TAny* aPtr, TAny* aBase);
+	/**
-	inline TUint8* Base() const;
+	@internalComponent
-	inline TInt Size() const;
-	inline TInt MaxLength() const;
+	The structure of a heap cell header for an allocated heap cell in a debug build.
-	inline TInt Align(TInt a) const;
+	*/
-	inline const TAny* Align(const TAny* a) const;
+	struct SDebugCell
-	inline TBool IsLastCell(const SCell* aCell) const;
+		{
-	inline void Lock() const;
+		/**
-	inline void Unlock() const;
+		The nested level.
-	inline TInt ChunkHandle() const;
+		*/
+		TInt nestingLevel;
+		/**
+		The cumulative number of allocated cells
+		*/
+		TInt allocCount;
+		};
+	/**
+	@internalComponent
+	*/
+	struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc;	TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; };
+	/**
+	Size of a free cell header.
+	*/
+	enum { EDebugHdrSize = sizeof(SDebugCell) };
+	/**
+	The default cell alignment.
+	*/
+	enum { ECellAlignment = 8 };
+	/**
+	Size of a free cell header.
+	*/
+	enum { EFreeCellSize = 4 };
+#ifdef _DEBUG
+	/**
+	Size of an allocated cell header in a debug build.
+	*/
+	enum { EAllocCellSize = (4 + EDebugHdrSize) };
+#else
+	/**
+	Size of an allocated cell header in a release build.
+	*/
+	enum { EAllocCellSize = 4 };
+#endif
+	/**
+	@internalComponent
+	*/
+	enum TDebugOp { EWalk = 128, EHybridHeap };
+	/**
+	@internalComponent
+	*/
+	enum TCellType
+		{
+		EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress,
+		EBadFreeCellAddress, EBadFreeCellSize
+		};
+	/**
+	@internalComponent
+	*/
+	enum TDebugHeapId { EUser = 0, EKernel = 1 };
+	/**
+	@internalComponent
+	*/
+	enum TDefaultShrinkRatios { EShrinkRatio1 = 256, EShrinkRatioDflt = 512 };
+	/**
+	@internalComponent
+	*/
+	typedef void (*TWalkFunc)(TAny*, TCellType, TAny*, TInt);
 protected:
-	inline RHeap();
-	void Initialise();
+	// These variables are present only for downwards binary compatibility.  Most are unused,
-	SCell* DoAlloc(TInt aSize, SCell*& aLastFree);
+	// but some must be present so that previously inline functions continue to work.  These
-	void DoFree(SCell* pC);
+	// old inline functions are now replaced with non inline versions so recompiling existing
-	TInt TryToGrowHeap(TInt aSize, SCell* aLastFree);
+	// code will automatically switch to the new versions and you should no longer access any
-	inline void FindFollowingFreeCell(SCell* aCell, SCell*& pPrev, SCell*& aNext);
+	// of the variables in here.
-	TInt TryToGrowCell(SCell* pC, SCell* pP, SCell* pE, TInt aSize);
+	//
-	TInt Reduce(SCell* aCell);
+	// These variables should now all be considered private and should NOT be accessed directly!
-	UIMPORT_C SCell* GetAddress(const TAny* aCell) const;
+	//
-	void CheckCell(const SCell* aCell) const;
+	TInt		iUnused1;		// Present for binary compatibility reasons only
-	void Walk(TWalkFunc aFunc, TAny* aPtr);
+	TInt		iMaxLength;		// Use RAllocator::MaxLength() to get this information now
-	static void WalkCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen);
+	TInt		iUnused2;		// Present for binary compatibility reasons only
-	TInt DoCountAllocFree(TInt& aFree);
+	TInt		iUnused3;		// Present for binary compatibility reasons only
-	TInt DoCheckHeap(SCheckInfo* aInfo);
+	// These next two variables must remain in this order for correct object destruction
-	void DoMarkStart();
+	TInt		iChunkHandle;	// Do not use; consider undocumented
-	TUint32 DoMarkEnd(TInt aExpected);
+	RFastLock	iLock;			// Do not use; consider undocumented
-	void DoSetAllocFail(TAllocFail aType, TInt aRate);
+	TUint8*		iBase;			// Use RAllocator::Base() to get this information now
-	TBool CheckForSimulatedAllocFail();
+	TUint8*		iTop;			// Do not use; consider undocumented
-	inline TInt SetBrk(TInt aBrk);
+	TInt		iAlign;			// Use RAllocator::Align() to get this information now
-	inline TAny* ReAllocImpl(TAny* aPtr, TInt aSize, TInt aMode);
-	void DoSetAllocFail(TAllocFail aType, TInt aRate, TUint aBurst);
+	// These variables are temporary to prevent source breaks from req417-52840.  They are deprecated in
-protected:
+	// favour of non hacky ways of determining this information but are required during the switchover to
-	TInt iMinLength;
+	// this method
-	TInt iMaxLength;
+	TAllocFail	iFailType;		// Use RAllocator::__DbgGetAllocFail() to get this information now
-	TInt iOffset;
+	TInt		iNestingLevel;	// Do not use; consider undocumented
-	TInt iGrowBy;
+	TAny*		iTestData;		// Do not use; consider undocumented
-	TInt iChunkHandle;
-	RFastLock iLock;
-	TUint8* iBase;
-	TUint8* iTop;
-	TInt iAlign;
-	TInt iMinCell;
-	TInt iPageSize;
-	SCell iFree;
-protected:
-	TInt iNestingLevel;
-	TInt iAllocCount;
-	TAllocFail iFailType;
-	TInt iFailRate;
-	TBool iFailed;
-	TInt iFailAllocCount;
-	TInt iRand;
-	TAny* iTestData;
 	friend class UserHeap;
 	};
 class OnlyCreateWithNull;
 /** @internalTechnology */
 typedef void (OnlyCreateWithNull::* __NullPMF)();

changeset 109	b3a1d9898418
parent 90	947f0dc9f7a8
child 148	31ea0f8e3c99