// 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\include\dla.h

// 

// Uses malloc (aka dlmalloc) written by Doug Lea version 2.8.4

//

#ifndef __DLA__

#define __DLA__

#define DEFAULT_TRIM_THRESHOLD ((size_t)4U * (size_t)1024U)

#define MSPACES 0

#define HAVE_MORECORE 1

#define	MORECORE_CONTIGUOUS 1

#define	HAVE_MMAP 0

#define HAVE_MREMAP 0

#define DEFAULT_GRANULARITY (4096U)

#define FOOTERS 0

#define USE_LOCKS 0

#define INSECURE 1

#define NO_MALLINFO 0

#define LACKS_SYS_TYPES_H

#ifndef LACKS_SYS_TYPES_H

#include <sys/types.h>  /* For size_t */

#else

#ifndef _SIZE_T_DECLARED

typedef unsigned int size_t;

#define	_SIZE_T_DECLARED

#endif

#endif  /* LACKS_SYS_TYPES_H */

/* The maximum possible size_t value has all bits set */

#define MAX_SIZE_T           (~(size_t)0)

#ifndef ONLY_MSPACES

	#define ONLY_MSPACES 0

#endif  /* ONLY_MSPACES */

#ifndef MSPACES

	#if ONLY_MSPACES

		#define MSPACES 1

	#else   /* ONLY_MSPACES */

		#define MSPACES 0

	#endif  /* ONLY_MSPACES */

#endif  /* MSPACES */

//#ifndef MALLOC_ALIGNMENT

//	#define MALLOC_ALIGNMENT ((size_t)8U)

//#endif  /* MALLOC_ALIGNMENT */

#ifndef FOOTERS

	#define FOOTERS 0

#endif  /* FOOTERS */

#ifndef ABORT

//	#define ABORT  abort()

//	#define ABORT  User::Invariant()// redefined so euser isn't dependant on oe

  	#define ABORT  HEAP_PANIC(ETHeapBadCellAddress)

#endif  /* ABORT */

#ifndef PROCEED_ON_ERROR

	#define PROCEED_ON_ERROR 0

#endif  /* PROCEED_ON_ERROR */

#ifndef USE_LOCKS

	#define USE_LOCKS 0

#endif  /* USE_LOCKS */

#ifndef INSECURE

	#define INSECURE 0

#endif  /* INSECURE */

#ifndef HAVE_MMAP

	#define HAVE_MMAP 1

#endif  /* HAVE_MMAP */

#ifndef MMAP_CLEARS

	#define MMAP_CLEARS 1

#endif  /* MMAP_CLEARS */

#ifndef HAVE_MREMAP

	#ifdef linux

		#define HAVE_MREMAP 1

	#else   /* linux */

		#define HAVE_MREMAP 0

	#endif  /* linux */

#endif  /* HAVE_MREMAP */

#ifndef MALLOC_FAILURE_ACTION

	//#define MALLOC_FAILURE_ACTION  errno = ENOMEM;

	#define MALLOC_FAILURE_ACTION ;

#endif  /* MALLOC_FAILURE_ACTION */

#ifndef HAVE_MORECORE

	#if ONLY_MSPACES

		#define HAVE_MORECORE 1 /*AMOD: has changed */

	#else   /* ONLY_MSPACES */

		#define HAVE_MORECORE 1

	#endif  /* ONLY_MSPACES */

#endif  /* HAVE_MORECORE */

#if !HAVE_MORECORE

	#define MORECORE_CONTIGUOUS 0

#else   /* !HAVE_MORECORE */

	#ifndef MORECORE

		#define MORECORE DLAdjust

	#endif  /* MORECORE */

	#ifndef MORECORE_CONTIGUOUS

		#define MORECORE_CONTIGUOUS 0

	#endif  /* MORECORE_CONTIGUOUS */

#endif  /* !HAVE_MORECORE */

#ifndef DEFAULT_GRANULARITY

	#if MORECORE_CONTIGUOUS

		#define DEFAULT_GRANULARITY 4096  /* 0 means to compute in init_mparams */

	#else   /* MORECORE_CONTIGUOUS */

		#define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)

	#endif  /* MORECORE_CONTIGUOUS */

#endif  /* DEFAULT_GRANULARITY */

#ifndef DEFAULT_TRIM_THRESHOLD

	#ifndef MORECORE_CANNOT_TRIM

		#define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)

	#else   /* MORECORE_CANNOT_TRIM */

		#define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T

	#endif  /* MORECORE_CANNOT_TRIM */	

#endif  /* DEFAULT_TRIM_THRESHOLD */

#ifndef DEFAULT_MMAP_THRESHOLD

	#if HAVE_MMAP

		#define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)

	#else   /* HAVE_MMAP */

		#define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T

	#endif  /* HAVE_MMAP */

#endif  /* DEFAULT_MMAP_THRESHOLD */

#ifndef USE_BUILTIN_FFS

	#define USE_BUILTIN_FFS 0

#endif  /* USE_BUILTIN_FFS */

#ifndef USE_DEV_RANDOM

	#define USE_DEV_RANDOM 0

#endif  /* USE_DEV_RANDOM */

#ifndef NO_MALLINFO

	#define NO_MALLINFO 0

#endif  /* NO_MALLINFO */

#ifndef MALLINFO_FIELD_TYPE

	#define MALLINFO_FIELD_TYPE size_t

#endif  /* MALLINFO_FIELD_TYPE */

/*

  mallopt tuning options.  SVID/XPG defines four standard parameter

  numbers for mallopt, normally defined in malloc.h.  None of these

  are used in this malloc, so setting them has no effect. But this

  malloc does support the following options.

*/

#define M_TRIM_THRESHOLD     (-1)

#define M_GRANULARITY        (-2)

#define M_MMAP_THRESHOLD     (-3)

#if !NO_MALLINFO

/*

  This version of malloc supports the standard SVID/XPG mallinfo

  routine that returns a struct containing usage properties and

  statistics. It should work on any system that has a

  /usr/include/malloc.h defining struct mallinfo.  The main

  declaration needed is the mallinfo struct that is returned (by-copy)

  by mallinfo().  The malloinfo struct contains a bunch of fields that

  are not even meaningful in this version of malloc.  These fields are

  are instead filled by mallinfo() with other numbers that might be of

  interest.

  HAVE_USR_INCLUDE_MALLOC_H should be set if you have a

  /usr/include/malloc.h file that includes a declaration of struct

  mallinfo.  If so, it is included; else a compliant version is

  declared below.  These must be precisely the same for mallinfo() to

  work.  The original SVID version of this struct, defined on most

  systems with mallinfo, declares all fields as ints. But some others

  define as unsigned long. If your system defines the fields using a

  type of different width than listed here, you MUST #include your

  system version and #define HAVE_USR_INCLUDE_MALLOC_H.

*/

/* #define HAVE_USR_INCLUDE_MALLOC_H */

#ifdef HAVE_USR_INCLUDE_MALLOC_H

#include "/usr/include/malloc.h"

#else /* HAVE_USR_INCLUDE_MALLOC_H */

struct mallinfo {

  MALLINFO_FIELD_TYPE iArena;    /* non-mmapped space allocated from system */

  MALLINFO_FIELD_TYPE iOrdblks;  /* number of free chunks */

  MALLINFO_FIELD_TYPE iSmblks;   /* always 0 */

  MALLINFO_FIELD_TYPE iHblks;    /* always 0 */

  MALLINFO_FIELD_TYPE iHblkhd;   /* space in mmapped regions */

  MALLINFO_FIELD_TYPE iUsmblks;  /* maximum total allocated space */

  MALLINFO_FIELD_TYPE iFsmblks;  /* always 0 */

  MALLINFO_FIELD_TYPE iUordblks; /* total allocated space */

  MALLINFO_FIELD_TYPE iFordblks; /* total free space */

  MALLINFO_FIELD_TYPE iKeepcost; /* releasable (via malloc_trim) space */

  MALLINFO_FIELD_TYPE iCellCount;/* Number of chunks allocated*/

};

#endif /* HAVE_USR_INCLUDE_MALLOC_H */

#endif /* NO_MALLINFO */

#if MSPACES

	typedef void* mspace;

#endif /* MSPACES */

#if 0

#include <stdio.h>/* for printing in malloc_stats */

#ifndef LACKS_ERRNO_H

	#include <errno.h>       /* for MALLOC_FAILURE_ACTION */

#endif /* LACKS_ERRNO_H */

#if FOOTERS

	#include <time.h>        /* for iMagic initialization */

#endif /* FOOTERS */

#ifndef LACKS_STDLIB_H

	#include <stdlib.h>      /* for abort() */

#endif /* LACKS_STDLIB_H */

#if !defined(ASSERT)

#define ASSERT(x) __ASSERT_DEBUG(x, HEAP_PANIC(ETHeapBadCellAddress))

#endif

#ifndef LACKS_STRING_H

	#include <string.h>      /* for memset etc */

#endif  /* LACKS_STRING_H */

#if USE_BUILTIN_FFS

	#ifndef LACKS_STRINGS_H

		#include <strings.h>     /* for ffs */

	#endif /* LACKS_STRINGS_H */

#endif /* USE_BUILTIN_FFS */

#if HAVE_MMAP

	#ifndef LACKS_SYS_MMAN_H

		#include <sys/mman.h>    /* for mmap */

	#endif /* LACKS_SYS_MMAN_H */

	#ifndef LACKS_FCNTL_H

		#include <fcntl.h>

	#endif /* LACKS_FCNTL_H */

#endif /* HAVE_MMAP */

#if HAVE_MORECORE

	#ifndef LACKS_UNISTD_H

		#include <unistd.h>     /* for sbrk */

	extern void*     sbrk(size_t);

	#else /* LACKS_UNISTD_H */

		#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__)

			extern void*     sbrk(ptrdiff_t);			

			/*Amod sbrk is not defined in WIN32 need to check in symbian*/

		#endif /* FreeBSD etc */

	#endif /* LACKS_UNISTD_H */

#endif /* HAVE_MORECORE */

#endif

/*AMOD: For MALLOC_GETPAGESIZE*/

#if 0	// replaced with GET_PAGE_SIZE() defined in heap.cpp

#ifndef WIN32

	#ifndef MALLOC_GETPAGESIZE

		#ifdef _SC_PAGESIZE         /* some SVR4 systems omit an underscore */

			#ifndef _SC_PAGE_SIZE

				#define _SC_PAGE_SIZE _SC_PAGESIZE

			#endif

		#endif

		#ifdef _SC_PAGE_SIZE

			#define MALLOC_GETPAGESIZE sysconf(_SC_PAGE_SIZE)

		#else

			#if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)

				extern size_t getpagesize();

				#define MALLOC_GETPAGESIZE getpagesize()

			#else

				#ifdef WIN32 /* use supplied emulation of getpagesize */

					#define MALLOC_GETPAGESIZE getpagesize()

				#else

					#ifndef LACKS_SYS_PARAM_H

						#include <sys/param.h>

					#endif

					#ifdef EXEC_PAGESIZE

						#define MALLOC_GETPAGESIZE EXEC_PAGESIZE

					#else

						#ifdef NBPG

							#ifndef CLSIZE

								#define MALLOC_GETPAGESIZE NBPG

							#else

								#define MALLOC_GETPAGESIZE (NBPG * CLSIZE)

							#endif

						#else

							#ifdef NBPC

								#define MALLOC_GETPAGESIZE NBPC

							#else

								#ifdef PAGESIZE

									#define MALLOC_GETPAGESIZE PAGESIZE

								#else /* just guess */

									#define MALLOC_GETPAGESIZE ((size_t)4096U)

								#endif

							#endif

						#endif

					#endif

				#endif

			#endif

		#endif

	#endif

#endif

#endif

/*AMOD: For MALLOC_GETPAGESIZE*/

/* ------------------- size_t and alignment properties -------------------- */

/* The byte and bit size of a size_t */

#define SIZE_T_SIZE         (sizeof(size_t))

#define SIZE_T_BITSIZE      (sizeof(size_t) << 3)

/* Some constants coerced to size_t */

/* Annoying but necessary to avoid errors on some plaftorms */

#define SIZE_T_ZERO         ((size_t)0)

#define SIZE_T_ONE          ((size_t)1)

#define SIZE_T_TWO          ((size_t)2)

#define TWO_SIZE_T_SIZES    (SIZE_T_SIZE<<1)

#define FOUR_SIZE_T_SIZES   (SIZE_T_SIZE<<2)

#define SIX_SIZE_T_SIZES    (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES)

#define HALF_MAX_SIZE_T     (MAX_SIZE_T / 2U)

/* The bit mask value corresponding to MALLOC_ALIGNMENT */

#define CHUNK_ALIGN_MASK    (MALLOC_ALIGNMENT - SIZE_T_ONE)

/* True if address a has acceptable alignment */

//#define IS_ALIGNED(A)       (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0)

#define IS_ALIGNED(A)       (((unsigned int)((A)) & (CHUNK_ALIGN_MASK)) == 0)

/* the number of bytes to offset an address to align it */

#define ALIGN_OFFSET(A)\

	((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\

	((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK))

/* -------------------------- MMAP preliminaries ------------------------- */

/*

   If HAVE_MORECORE or HAVE_MMAP are false, we just define calls and

   checks to fail so compiler optimizer can delete code rather than

   using so many "#if"s.

*/

/* MORECORE and MMAP must return MFAIL on failure */

#define MFAIL                ((void*)(MAX_SIZE_T))

#define CMFAIL               ((TUint8*)(MFAIL)) /* defined for convenience */

#if !HAVE_MMAP

	#define IS_MMAPPED_BIT       (SIZE_T_ZERO)

	#define USE_MMAP_BIT         (SIZE_T_ZERO)

	#define CALL_MMAP(s)         MFAIL

	#define CALL_MUNMAP(a, s)    (-1)

	#define DIRECT_MMAP(s)       MFAIL

#else /* !HAVE_MMAP */

	#define IS_MMAPPED_BIT       (SIZE_T_ONE)

	#define USE_MMAP_BIT         (SIZE_T_ONE)

		#ifndef WIN32

			#define CALL_MUNMAP(a, s)    DLUMMAP((a),(s)) /*munmap((a), (s))*/

			#define MMAP_PROT            (PROT_READ|PROT_WRITE)

			#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)

				#define MAP_ANONYMOUS        MAP_ANON

			#endif /* MAP_ANON */

			#ifdef MAP_ANONYMOUS       

				#define MMAP_FLAGS           (MAP_PRIVATE|MAP_ANONYMOUS)

				#define CALL_MMAP(s)         mmap(0, (s), MMAP_PROT, (int)MMAP_FLAGS, -1, 0)

			#else /* MAP_ANONYMOUS */

				/*

				   Nearly all versions of mmap support MAP_ANONYMOUS, so the following

				   is unlikely to be needed, but is supplied just in case.

				*/

				#define MMAP_FLAGS           (MAP_PRIVATE)

				//static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */

				#define CALL_MMAP(s) DLMMAP(s)

				/*#define CALL_MMAP(s) ((dev_zero_fd < 0) ? \

			           (dev_zero_fd = open("/dev/zero", O_RDWR), \

			            mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \

			            mmap(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0))

			            */

				#define CALL_REMAP(a, s, d)    DLREMAP((a),(s),(d))

			#endif /* MAP_ANONYMOUS */

			#define DIRECT_MMAP(s)       CALL_MMAP(s)

		#else /* WIN32 */

			#define CALL_MMAP(s)         win32mmap(s)

			#define CALL_MUNMAP(a, s)    win32munmap((a), (s))

			#define DIRECT_MMAP(s)       win32direct_mmap(s)

		#endif /* WIN32 */

#endif /* HAVE_MMAP */

#if HAVE_MMAP && HAVE_MREMAP

	#define CALL_MREMAP(addr, osz, nsz, mv) mremap((addr), (osz), (nsz), (mv))

#else  /* HAVE_MMAP && HAVE_MREMAP */

	#define CALL_MREMAP(addr, osz, nsz, mv) MFAIL

#endif /* HAVE_MMAP && HAVE_MREMAP */

#if HAVE_MORECORE

	#define CALL_MORECORE(S)     SetBrk(S)

#else  /* HAVE_MORECORE */

	#define CALL_MORECORE(S)     MFAIL

#endif /* HAVE_MORECORE */

/* mstate bit set if continguous morecore disabled or failed */

#define USE_NONCONTIGUOUS_BIT (4U)

/* segment bit set in create_mspace_with_base */

#define EXTERN_BIT            (8U)

#if USE_LOCKS

/*

  When locks are defined, there are up to two global locks:

  * If HAVE_MORECORE, iMorecoreMutex protects sequences of calls to

    MORECORE.  In many cases sys_alloc requires two calls, that should

    not be interleaved with calls by other threads.  This does not

    protect against direct calls to MORECORE by other threads not

    using this lock, so there is still code to cope the best we can on

    interference.

  * iMagicInitMutex ensures that mparams.iMagic and other

    unique mparams values are initialized only once.

*/

	#ifndef WIN32

		/* By default use posix locks */

		#include <pthread.h>

		#define MLOCK_T pthread_mutex_t

		#define INITIAL_LOCK(l)      pthread_mutex_init(l, NULL)

		#define ACQUIRE_LOCK(l)      pthread_mutex_lock(l)

		#define RELEASE_LOCK(l)      pthread_mutex_unlock(l)

		#if HAVE_MORECORE

			//static MLOCK_T iMorecoreMutex = PTHREAD_MUTEX_INITIALIZER;

		#endif /* HAVE_MORECORE */

			//static MLOCK_T iMagicInitMutex = PTHREAD_MUTEX_INITIALIZER;

	#else /* WIN32 */

		#define MLOCK_T long

		#define INITIAL_LOCK(l)      *(l)=0

		#define ACQUIRE_LOCK(l)      win32_acquire_lock(l)

		#define RELEASE_LOCK(l)      win32_release_lock(l)

		#if HAVE_MORECORE

			static MLOCK_T iMorecoreMutex;

		#endif /* HAVE_MORECORE */

		static MLOCK_T iMagicInitMutex;

	#endif /* WIN32 */

	#define USE_LOCK_BIT               (2U)

#else  /* USE_LOCKS */

	#define USE_LOCK_BIT               (0U)

	#define INITIAL_LOCK(l)

#endif /* USE_LOCKS */

#if USE_LOCKS && HAVE_MORECORE

	#define ACQUIRE_MORECORE_LOCK(M)    ACQUIRE_LOCK((M->iMorecoreMutex)/*&iMorecoreMutex*/);

	#define RELEASE_MORECORE_LOCK(M)    RELEASE_LOCK((M->iMorecoreMutex)/*&iMorecoreMutex*/);

#else /* USE_LOCKS && HAVE_MORECORE */

	#define ACQUIRE_MORECORE_LOCK(M)

	#define RELEASE_MORECORE_LOCK(M)

#endif /* USE_LOCKS && HAVE_MORECORE */

#if USE_LOCKS

		/*Currently not suporting this*/				

	#define ACQUIRE_MAGIC_INIT_LOCK(M)  ACQUIRE_LOCK(((M)->iMagicInitMutex));

	//AMOD: changed #define ACQUIRE_MAGIC_INIT_LOCK()

	//#define RELEASE_MAGIC_INIT_LOCK()

	#define RELEASE_MAGIC_INIT_LOCK(M)  RELEASE_LOCK(((M)->iMagicInitMutex));

#else  /* USE_LOCKS */

	#define ACQUIRE_MAGIC_INIT_LOCK(M)

	#define RELEASE_MAGIC_INIT_LOCK(M)

#endif /* USE_LOCKS */

/*CHUNK representation*/

struct malloc_chunk {

  size_t               iPrevFoot;  /* Size of previous chunk (if free).  */

  size_t               iHead;       /* Size and inuse bits. */

  struct malloc_chunk* iFd;         /* double links -- used only if free. */

  struct malloc_chunk* iBk;

};

typedef struct malloc_chunk  mchunk;

typedef struct malloc_chunk* mchunkptr;

typedef struct malloc_chunk* sbinptr;  /* The type of bins of chunks */

typedef unsigned int bindex_t;         /* Described below */

typedef unsigned int binmap_t;         /* Described below */

typedef unsigned int flag_t;           /* The type of various bit flag sets */

/* ------------------- Chunks sizes and alignments ----------------------- */

#define MCHUNK_SIZE         (sizeof(mchunk))

//#if FOOTERS

//	#define CHUNK_OVERHEAD      (TWO_SIZE_T_SIZES)

//#else /* FOOTERS */

//	#define CHUNK_OVERHEAD      (SIZE_T_SIZE)

//#endif /* FOOTERS */

/* MMapped chunks need a second word of overhead ... */

#define MMAP_CHUNK_OVERHEAD (TWO_SIZE_T_SIZES)

/* ... and additional padding for fake next-chunk at foot */

#define MMAP_FOOT_PAD       (FOUR_SIZE_T_SIZES)

/* The smallest size we can malloc is an aligned minimal chunk */

#define MIN_CHUNK_SIZE ((MCHUNK_SIZE + CHUNK_ALIGN_MASK) & ~CHUNK_ALIGN_MASK)

/* conversion from malloc headers to user pointers, and back */

#define CHUNK2MEM(p)        ((void*)((TUint8*)(p)       + TWO_SIZE_T_SIZES))

#define MEM2CHUNK(mem)      ((mchunkptr)((TUint8*)(mem) - TWO_SIZE_T_SIZES))

/* chunk associated with aligned address A */

#define ALIGN_AS_CHUNK(A)   (mchunkptr)((A) + ALIGN_OFFSET(CHUNK2MEM(A)))

/* Bounds on request (not chunk) sizes. */