// Copyright (c) 1995-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:

 // e32\memmodel\emul\win32\mcodeseg.cpp

 // 

 //

 #define __INCLUDE_ALL_SUPPORTED_CAPABILITIES__

 #include "memmodel.h"

 #include <property.h>

 #include <emulator.h>

 #include <wchar.h>

 #define __CHECKHEAP()	((RHeapK*)K::Allocator)->Check()

 static TBool BootComplete;	// flag set when boot EXE is loaded as an EPOC process

 static DWin32CodeSeg* KernelCodeSeg;

 static HMODULE KernelModuleHandle;

 GLREF_C TInt CompareCodeSegsByName(const DCodeSeg& aA, const DCodeSeg& aB);

 void TruncToNarrow(TUint8* aDes, const TUint16* aSrc, int aLen)

 	{

 	//converts to narrow by dumping the high order byte

 	if(aDes && aSrc)

 		{

 		if(aLen==-1)

 			{

 			for(int index=0;*aSrc;index++)

 				*aDes++ = (TUint8)*aSrc++;

 			*aDes = '\0';

 			}

 		else

 			for(int index=0;index<aLen;index++)

 				*aDes++ = (TUint8)*aSrc++;

 		}

 	}

 void ExpandToWide(TUint16* aDes, const TUint8* aSrc, int aLen)

 	{

 	if(aDes && aSrc)

 		{

 		for(int index=0;index<aLen;index++)

 			*aDes++ = (TUint16)*aSrc++;

 		}

 	}

 #ifdef KDLL

 void DumpWin32CodeSeg(DWin32CodeSeg& a)

 	{

 	const TUint32* uid=(const TUint32*)&a.iUids;

 	Kern::Printf("DWin32CodeSeg@%08x:",&a);

 	Kern::Printf("iLink = %08x %08x", a.iLink.iNext, a.iLink.iPrev);

 	Kern::Printf("iTempLink = %08x %08x", a.iTempLink.iNext, a.iTempLink.iPrev);

 	Kern::Printf("iGbgLink = %08x %08x", a.iGbgLink.iNext, a.iGbgLink.iPrev);

 	Kern::Printf("iAccessCount = %d", a.iAccessCount);

 	Kern::Printf("iEntryPtVeneer = %08x", a.iEntryPtVeneer);

 	Kern::Printf("iFileEntryPoint = %08x", a.iFileEntryPoint);

 	Kern::Printf("iFileName = %lS", a.iFileName);

 	Kern::Printf("iRootName = %lS", &a.iRootName);

 	Kern::Printf("iExtOffset = %d", a.iExtOffset);

 	Kern::Printf("iModuleVersion = %08x", a.iModuleVersion);

 	Kern::Printf("iUids = %08x %08x %08x", uid[0], uid[1], uid[2]);

 	Kern::Printf("iDepCount=%d iDeps=%08x", a.iDepCount, a.iDeps);

 	Kern::Printf("iNextDep=%d, iMark=%08x, iAttr=%08x", a.iNextDep, a.iMark, a.iAttr);

 	Kern::Printf("iExeCodeSeg=%08x, iAttachProcess=%O", a.iExeCodeSeg, a.iAttachProcess);

 	Kern::Printf("iWinInstance = %08x", a.iWinInstance);

 	Kern::Printf("iModuleHandle = %08x", a.iModuleHandle);

 	Kern::Printf("iModuleFile = %08x", a.iModuleFile);

 	Kern::Printf("iAlwaysLoaded = %08x", a.iAlwaysLoaded);

 	Kern::Printf("iModuleList = %08x", a.iModuleList);

 	}

 #endif

 void ExecInEntryPoint()

 	{

 	// This function will be called if an Exec:: call is attempted in the entry

 	// point of a DLL which didn't specify 'epocallowdlldata'

 	Kern::Fault("BAD DLL STATIC",0);

 	}

 static const SFastExecTable DummyFastExecTable={0,{0}};

 static const SSlowExecTable DummySlowExecTable={0,(TLinAddr)ExecInEntryPoint,0,{{0,0}}};

 // Force a call to a DLL entry point to initialise any gratuitous writeable data

 // generated by the compiler.

 // Change exec table to prevent any executive calls in case someone forgot to

 // use the 'epocallowdlldata' option.

 void ForceEntryPointCall(TLinAddr aEntryPoint)

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("ForceEntryPoint %08x", aEntryPoint));

 	NKern::Lock();

 	NThread* nthrd = NKern::CurrentThread();

 	const SFastExecTable* fast = nthrd->iFastExecTable;

 	const SSlowExecEntry* slow = nthrd->iSlowExecTable;

 	nthrd->iFastExecTable = (SFastExecTable*)&DummyFastExecTable;

 	nthrd->iSlowExecTable = DummySlowExecTable.iEntries;

 	TLibraryEntry ep = (TLibraryEntry)aEntryPoint;

 	(*ep)(KModuleEntryReasonProcessAttach);

 	nthrd->iFastExecTable = fast;

 	nthrd->iSlowExecTable = slow;

 	NKern::Unlock();

 	}

 class TWin32Filename

 	{

 public:

 	inline TWin32Filename()

 		{iBuf[0] = '\0';}

 	inline TWin32Filename(const TDesC& aFilename)

 		{Set(aFilename);}

 	inline TWin32Filename& operator=(const TDesC& aFilename)

 		{Set(aFilename);return *this;}

 	inline operator LPCWSTR() const

 		{return iBuf;}

 private:

 	void Set(const TDesC& aFilename);

 private:

 	WCHAR iBuf[KMaxFileName + 1];

 	};

 void TWin32Filename::Set(const TDesC& aFilename)

 	{

 	TUint16 fileName[KMaxFileName];

 	ExpandToWide(fileName, aFilename.Ptr(), aFilename.Length());

 	TPtr p((TUint8*)iBuf,KMaxFileName<<1);

 	Property::MapFilename(p, TPtrC((TUint8*)fileName,aFilename.Length()<<1));

 	iBuf[p.Length()>>1] = '\0';

 	}

 class DModuleList : public DBase

 	{

 public:

 	enum TFlags

 		{

 		EFlagData=0x01,

 		EFlagDataPresent=0x02,

 		EFlagAlreadyLoaded=0x04,

 		EFlagMark=0x08,

 		EFlagExe=0x10,

 		EFlagAlwaysLoaded=0x20,

 		EFlagExeInTree=0x40,

 		};

 	struct SModule

 		{

 		TLinAddr iModuleHandle;

 		DWin32CodeSeg* iCodeSeg;

 		TUint32 iFlags;

 		SSecurityInfo iS;

 		TUint32 iModuleVersion;

 		TInt iDepCount;

 		TInt* iDepList;

 		};

 public:

 	DModuleList(DWin32CodeSeg* aMainSeg, DProcess* aProcess);

 	virtual ~DModuleList();

 	TInt Find(TInt aModule);

 	TInt GatherDependencies(HMODULE aModule);

 	TInt CompileDepLists();

 	void SetFlags();

 	TUint32 Flags(SModule* aM);

 	TInt LoadDependencies();

 	void LinkDependencies();

 	TInt Loaded();

 public:

 	DWin32CodeSeg* iMain;

 	DProcess* iAttachProcess;

 	RArray<SModule> iModules;

 	};

 DModuleList::DModuleList(DWin32CodeSeg* aMainSeg, DProcess* aProcess)

 	:	iMain(aMainSeg), iAttachProcess(aProcess),

 		iModules(8, _FOFF(SModule,iModuleHandle), 2*256)

 	{

 	}

 DModuleList::~DModuleList()

 	{

 	TInt c = iModules.Count();

 	if (c)

 		{

 		SModule* pM = (SModule*)&iModules[0];

 		SModule* pE = pM + c;

 		for (; pM<pE; ++pM)

 			{

 			Kern::Free(pM->iDepList);

 			}

 		}

 	iModules.Close();

 	}

 TInt DModuleList::Find(TInt aModule)

 	{

 	SModule mod;

 	mod.iModuleHandle=(TLinAddr)aModule;

 	return iModules.FindInUnsignedKeyOrder(mod);

 	}

 /**

 Populate iModules with SModule entries corresponding to supplied HModule and all of its dependencies,

 direct and indirect.  

 @param aModule A Windows module handle

 @return KErrNone if successful

 */

 TInt DModuleList::GatherDependencies(HMODULE aModule)

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf(">DModuleList::GatherDependencies %08x %08x %C", aModule, iMain, iMain));

 	Emulator::TModule etm(aModule);

 	SModule mod;

 	mod.iModuleHandle=(TLinAddr)aModule;

 	mod.iCodeSeg=NULL;

 	mod.iDepList=NULL;

 	TUint32 uid[3];

 	TUidType& uidref=*(TUidType*)uid;

 	const TEmulatorImageHeader* hdr = (const TEmulatorImageHeader*)etm.Section(KWin32SectionName_Symbian);

 	if (!hdr)

 		return KErrNotSupported;

 	__KTRACE_OPT(KDLL,Kern::Printf("Module flags %08x, cap %08x %08x, sid %08x", hdr->iFlags, hdr->iS.iCaps[1], hdr->iS.iCaps[0], hdr->iS.iSecureId));

 	mod.iS = hdr->iS;

 	// Overide capabilities in image

 	const SCapabilitySet& disabledCaps = *(SCapabilitySet*)&TheSuperPage().iDisabledCapabilities;

 	for(TInt i=0; i<SCapabilitySet::ENCapW; i++)

 		{

 		mod.iS.iCaps[i] |= disabledCaps[i];

 		mod.iS.iCaps[i] &= AllSupportedCapabilities[i];

 		}

 	mod.iModuleVersion = hdr->iModuleVersion;

 	mod.iFlags = (hdr->iFlags & KEmulatorImageFlagAllowDllData) ? EFlagData|EFlagDataPresent : 0;

 	uidref = *(const TUidType*)&hdr->iUids[0];

 	TBool isExe = (uid[0]==KExecutableImageUidValue);

 	TBool data_section_present = (etm.Section(KWin32SectionName_EpocData) != NULL);

 	if (data_section_present && isExe)

 		mod.iFlags = EFlagData|EFlagDataPresent;

 	__KTRACE_OPT(KDLL,Kern::Printf("DataSectionPresent = %x", data_section_present));

 	// Can't do this for CodeWarrior since it sticks everything in .data, even constants

 	// On VC6 this check works for Base code, but not for some other code.

 //	if (data_section_present && !isExe && !(hdr->iFlags & KEmulatorImageFlagAllowDllData))

 //		return KErrNotSupported;

 	if (!data_section_present)

 		mod.iFlags = 0;

 	if (isExe)

 		mod.iFlags |= EFlagExe|EFlagExeInTree;

 	SWin32Module w32m;

 	w32m.iWin32ModuleHandle=(TLinAddr)aModule;

 	w32m.iCodeSeg=NULL;

 	TInt ix=MM::Win32Modules.FindInUnsignedKeyOrder(w32m);

 	__KTRACE_OPT(KDLL, Kern::Printf("GlobalIx=%d", ix));

 	if ((ix>=0 && !MM::Win32Modules[ix].iCodeSeg) || aModule==KernelModuleHandle)

 		mod.iFlags|=EFlagAlwaysLoaded;

 	TInt r=iModules.InsertInUnsignedKeyOrder(mod);

 	__KTRACE_OPT(KDLL, Kern::Printf("Flags=%08x, InsertRes=%d", mod.iFlags, r));

 	if (r==KErrAlreadyExists)

 		return KErrNone;

 	if (r!=KErrNone)

 		return r;

 	if (mod.iFlags & EFlagAlwaysLoaded)

 		return KErrNone;	// stop if we reach an extension or variant

 	if (data_section_present && (mod.iFlags & EFlagData)==0)

 		{

 		// DLL, .data present but 'epocallowdlldata' not specified

 		// - either the compiler forgetting that something's constant or

 		// developer forgetting to specify 'epocallowdlldata'.

 		// call entry point from here to keep the compiler happy

 		const char* entry_name = "_E32Dll" ;

 		TLinAddr ep = (TLinAddr)Emulator::GetProcAddress(aModule, entry_name);

 		__NK_ASSERT_ALWAYS(ep!=0);

 		ForceEntryPointCall(ep);

 		}

 	const IMAGE_IMPORT_DESCRIPTOR* imports = etm.Imports();

 	if (imports)

 		{

 	    for (; imports->Characteristics; ++imports )

 			{

 			__KTRACE_OPT(KDLL, { TPtrC8 n((const TText8*)etm.Translate(imports->Name)); Kern::Printf("Importing from %S", &n);} );

 			Emulator::TModule imp_etm((PCSTR)etm.Translate(imports->Name));

 			if (!imp_etm.IsValid())

 				{

 				__KTRACE_OPT(KDLL, Kern::Printf("Spurious import"));

 				continue;

 				}

 			if (imp_etm.Section(KWin32SectionName_Symbian) == 0)

 				{

 				__KTRACE_OPT(KDLL, Kern::Printf("Not EPOC Module"));

 				continue;		// not an epoc DLL

 				}

 			r=GatherDependencies(imp_etm.iModule);

 			if (r!=KErrNone)

 				return r;

 			}

 		}

 	__KTRACE_OPT(KDLL, Kern::Printf("<DModuleList::GatherDependencies %08x %08x %C", aModule, iMain, iMain));

 	return KErrNone;

 	}

 #ifdef __VC32__

 #pragma warning( disable : 4701 )   // disable warning C4701: local variable 'missingCaps' may be used without having been initialized

 #endif

 /**

 Iterate through imports (if any) of each SModule in list. Populate iDepList with the indicies (in iModules)

 of directly required modules. Checks that dependencies are legal under platsec.

 @return KErrNone on success.

 */

 TInt DModuleList::CompileDepLists()

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf(">DModuleList::CompileDepLists"));

 	TInt result=KErrNone;

 	TInt c=iModules.Count();

 	SModule* pM=(SModule*)&iModules[0];

 	SModule* pE=pM+c;

 	for (; pM<pE; ++pM)

 		{

 		pM->iDepList=(TInt*)Kern::Alloc(c*sizeof(TInt));

 		if (!pM->iDepList)

 			return KErrNoMemory;

 		memset(pM->iDepList, 0xff, c*sizeof(TInt));

 		Emulator::TModule etm((HINSTANCE)pM->iModuleHandle);

 		const IMAGE_IMPORT_DESCRIPTOR* imports = etm.Imports();

 		__KTRACE_OPT(KDLL, Kern::Printf("Module %08x, imports=%08x flags=%08x", pM->iModuleHandle, imports, pM->iFlags));

 		if (!imports || (pM->iFlags&EFlagAlwaysLoaded))

 			continue;

 		const SCapabilitySet& cap = pM->iS.iCaps;

 		const SCapabilitySet& disabledCaps=*(SCapabilitySet*)&TheSuperPage().iDisabledCapabilities;

 		TInt* pI=pM->iDepList;

 		for (; imports->Characteristics; ++imports )

 			{

 			Emulator::TModule imp_etm((PCSTR)etm.Translate(imports->Name));

 			if (!imp_etm.IsValid())

 				continue;		// spurious import

 			if (imp_etm.Section(KWin32SectionName_Symbian) == 0)

 				continue;		// not an epoc DLL

 			TInt ix=Find((TInt)imp_etm.iModule);

 			__ASSERT_ALWAYS(ix>=0, MM::Panic(MM::ECompileDepLists));

 			*pI++=ix;

 			__KTRACE_OPT(KDLL, Kern::Printf("Depends on %08x, ix=%d", imp_etm.iModule, ix));

 			const SModule& dep = iModules[ix];

 			SCapabilitySet missingCaps;

 			SCapabilitySet depCaps = dep.iS.iCaps;

 			TUint32 checkFail = 0;

 			for (TInt i=0; i<SCapabilitySet::ENCapW; ++i)

 				{

 				depCaps[i] = dep.iS.iCaps[i]|disabledCaps[i];

 				TUint32 missing = cap[i] & ~depCaps[i];

 				missingCaps[i] = missing;

 				checkFail |= missing;

 				}

 			__KTRACE_OPT(KDLL, Kern::Printf("Cap=%08x %08x, DepCap=%08x %08x", cap[1], cap[0], depCaps[1], depCaps[0]));

 			if (checkFail)

 				{

 				TUint8	mainBuf8[MAX_PATH];

 				TInt	mainlen;

 				{

 				TUint16 mainBuf[MAX_PATH];

 				mainlen=Emulator::GetModuleFileName(reinterpret_cast<HMODULE>(pM->iModuleHandle),(LPWSTR)mainBuf);

 				TruncToNarrow(mainBuf8, mainBuf, mainlen);

 				}

 				TPtrC mainp(mainBuf8,mainlen);

 				TInt ix=mainp.LocateReverse('\\');

 				if (ix>=0)

 					mainp.Set(mainp.Mid(ix+1));

 				if (mainp.Length() && mainp[mainp.Length()-1]==')' && (ix=mainp.LocateReverse('('))>=0)

 					mainp.Set(mainp.Left(ix));

 				TUint8	depBuf8[MAX_PATH];

 				TInt	deplen;

 				{

 				TUint16 depBuf[MAX_PATH];

 				deplen=Emulator::GetModuleFileName(reinterpret_cast<HMODULE>(dep.iModuleHandle),(LPWSTR)depBuf);

 				TruncToNarrow(depBuf8, depBuf, deplen);

 				}

 				TPtrC depp(depBuf8,deplen);

 				if ((ix=depp.LocateReverse('\\'))>=0)

 					depp.Set(depp.Mid(ix+1));

 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__

 				TInt r = PlatSec::LoaderCapabilityViolation(mainp, depp, missingCaps);

 #else //__REMOVE_PLATSEC_DIAGNOSTICS__

 				TInt r = PlatSec::EmitDiagnostic();

 #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__

 				if(r!=KErrNone)

 					result=r;

 				}

 			}

 		}

 	return result;

 	}

 #ifdef __VC32__

 #pragma warning( default : 4701 )   // enable warning C4701: local variable 'missingCaps' may be used without having been initialized

 #endif

 void DModuleList::SetFlags()

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("DModuleList::SetFlags"));

 	TInt c=iModules.Count();

 	SModule* pM=(SModule*)&iModules[0];

 	SModule* pE=pM+c;

 	for (; pM<pE; ++pM)

 		{

 		SModule* pM2=(SModule*)&iModules[0];

 		for (; pM2<pE; ++pM2)

 			pM2->iFlags &= ~EFlagMark;

 		TUint32 flags=Flags(pM);

 		if (flags & EFlagData)

 			pM->iFlags|=EFlagDataPresent;

 		if (flags & EFlagExe)

 			pM->iFlags|=EFlagExeInTree;

 		__KTRACE_OPT(KDLL, Kern::Printf("Module %08x Flags=%08x", pM->iModuleHandle, pM->iFlags));

 		}

 	pM=(SModule*)&iModules[0];

 	for (; pM<pE; ++pM)

 		{	

 		TInt dc=0;

 		const TInt* pI=pM->iDepList;

 		const TInt* pIE=pI+c;

 		while (pI<pIE)

 			{

 			TInt ix=*pI++;

 			if (ix<0)

 				break;

 			TUint32 mflags=iModules[ix].iFlags;

 			if ( (mflags&(EFlagDataPresent|EFlagExeInTree)) && !(mflags&EFlagAlwaysLoaded))

 				++dc;

 			}

 		pM->iDepCount=dc;

 		__KTRACE_OPT(KDLL, Kern::Printf("Module %08x DepCount=%d", pM->iModuleHandle, pM->iDepCount));

 		}

 	}

 TUint32 DModuleList::Flags(SModule* aM)

 	{

 	TUint32 flags=aM->iFlags;

 	__KTRACE_OPT(KDLL, Kern::Printf(">DModuleList::Flags %08x", aM->iModuleHandle));

 	if ((aM->iFlags & EFlagMark)==0)

 		{

 		aM->iFlags |= EFlagMark;

 		const TInt* pI=aM->iDepList;

 		const TInt* pE=pI+iModules.Count();

 		while (pI<pE)

 			{

 			TInt ix=*pI++;

 			if (ix<0)

 				break;

 			TUint32 mflags=Flags(&iModules[ix]);

 			if (mflags&EFlagExe)

 				mflags&=~EFlagData;

 			flags |= mflags;

 			}

 		}

 	__KTRACE_OPT(KDLL, Kern::Printf("<DModuleList::Flags %08x = %08x", aM->iModuleHandle, flags));

 	return flags;

 	}

 TInt DModuleList::LoadDependencies()

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("DModuleList::LoadDependencies"));

 	TInt c=iModules.Count();

 	SModule* pM=(SModule*)&iModules[0];

 	SModule* pE=pM+c;

 	for (; pM<pE; ++pM)

 		{

 		DWin32CodeSeg* pS;

 		TUint32 flags=pM->iFlags;

 		__KTRACE_OPT(KDLL, Kern::Printf("ModuleHandle %08x flags %08x", pM->iModuleHandle, flags));

 		if (!(flags & (EFlagDataPresent|EFlagExeInTree)) || (flags&EFlagAlwaysLoaded))

 			continue;

 		SWin32Module w32m;

 		w32m.iWin32ModuleHandle=(TLinAddr)pM->iModuleHandle;

 		w32m.iCodeSeg=NULL;

 		TInt ix=MM::Win32Modules.FindInUnsignedKeyOrder(w32m);

 		__KTRACE_OPT(KDLL, Kern::Printf("GlobalIndex=%d", ix));

 		if (ix<0 && (flags & EFlagExe))

 			return KErrNotSupported;	// we never implicitly load an EXE

 		if (ix>=0)

 			{

 			pS=MM::Win32Modules[ix].iCodeSeg;

 			__KTRACE_OPT(KDLL, Kern::Printf("Already loaded; CSEG=%08x %C", pS, pS));

 			if (pS==iMain)

 				{

 				pS->iDepCount=pM->iDepCount;

 				if (pS->iDepCount)

 					{

 					pS->iDeps=(DCodeSeg**)Kern::AllocZ(pS->iDepCount*sizeof(DCodeSeg*));

 					if (!pS->iDeps)

 						return KErrNoMemory;

 					}

 				}

 			else

 				{

 				if (!(pS->iMark & DCodeSeg::EMarkLdr))

 					{

 					pS->iMark |= DCodeSeg::EMarkLdr;

 					pS->CheckedOpen();

 					}

 				pM->iFlags|=EFlagAlreadyLoaded;

 				}

 			pM->iCodeSeg=pS;

 			continue;

 			}

 		__KTRACE_OPT(KDLL, Kern::Printf("Create new, depcount=%d", pM->iDepCount));

 		pS=new DWin32CodeSeg;

 		if (!pS)

 			return KErrNoMemory;

 		TInt r=pS->CreateAlreadyLoaded((HMODULE)pM->iModuleHandle, pM->iDepCount);

 		if (r!=KErrNone)

 			{

 			delete pS;

 			return r;

 			}

 		pM->iCodeSeg=pS;

 		pS->iS = pM->iS;

 		pS->iModuleVersion = pM->iModuleVersion;

 		if (iMain->iAttr & ECodeSegAttKernel)

 			pS->iAttr |= ECodeSegAttKernel;

 		if (flags & EFlagData)

 			{

 			pS->iMark |= DCodeSeg::EMarkData|DCodeSeg::EMarkDataPresent;

 			if (!(flags&EFlagExe))

 				pS->iMark |= DCodeSeg::EMarkDataInit;

 			}

 		if ( (flags & EFlagData) || ((flags&(EFlagExe|EFlagExeInTree))==EFlagExeInTree) )

 			{

 			if (iAttachProcess)

 				{

 				pS->iExeCodeSeg = iAttachProcess->CodeSeg();

 				pS->SetAttachProcess(iAttachProcess);

 				}

 			}

 		}

 	return KErrNone;

 	}

 void DModuleList::LinkDependencies()

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("DModuleList::LinkDependencies"));

 	TInt c=iModules.Count();

 	SModule* pM=(SModule*)&iModules[0];

 	SModule* pE=pM+c;

 	for (; pM<pE; ++pM)

 		{

 		DWin32CodeSeg* pS=pM->iCodeSeg;

 		if (!pS || (pM->iFlags&EFlagAlreadyLoaded))

 			continue;

 		const TInt* pI=pM->iDepList;

 		const TInt* pIE=pI+c;

 		while (pI<pIE)

 			{

 			TInt ix=*pI++;

 			if (ix<0)

 				break;

 			DWin32CodeSeg* pD=iModules[ix].iCodeSeg;

 			if (pD)

 				pS->iDeps[pS->iNextDep++]=pD;

 			}

 		}

 	pM=(SModule*)&iModules[0];

 	}

 TInt DModuleList::Loaded()

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("DModuleList::Loaded()"));

 	TInt c=iModules.Count();

 	SModule* pM=(SModule*)&iModules[0];

 	SModule* pE=pM+c;

 	TInt r=KErrNone;

 	for (; pM<pE && r==KErrNone; ++pM)

 		{

 		DWin32CodeSeg* pS=pM->iCodeSeg;

 		if (pS && pS!=iMain)

 			{

 			pS->FinaliseRecursiveFlags();

 			pS->iMark |= DCodeSeg::EMarkLoaded;

 			}

 		}

 	if (r==KErrNone)

 		{

 		pM=(SModule*)&iModules[0];

 		for (; pM<pE; ++pM)

 			pM->iCodeSeg=NULL;	// cleanup will occur by EMarkLdr if needed

 		}

 	return r;

 	}

 TInt MakeDll(HANDLE aFile)

 	{

 	IMAGE_DOS_HEADER dosh;

 	DWORD bytes;

 	ReadFile(aFile, &dosh, sizeof(dosh), &bytes, NULL);

 	if ( IMAGE_DOS_SIGNATURE != dosh.e_magic )

 		return KErrArgument;

 	if (dosh.e_lfarlc < sizeof(dosh))

 		return KErrArgument;

 	SetFilePointer(aFile,dosh.e_lfanew,NULL,FILE_BEGIN);

 	IMAGE_NT_HEADERS32 peh;

 	ReadFile(aFile, &peh, sizeof(peh), &bytes, NULL);

     if ( peh.Signature != IMAGE_NT_SIGNATURE )

 		return KErrArgument;

 	peh.FileHeader.Characteristics |= IMAGE_FILE_DLL;

 	peh.OptionalHeader.AddressOfEntryPoint = 0;

 	SetFilePointer(aFile,dosh.e_lfanew,NULL,FILE_BEGIN);

 	WriteFile(aFile, &peh, sizeof(peh), &bytes, NULL);

 	return KErrNone;

 	}

 wchar_t* TempModuleName(const wchar_t* aExe)

 	{

 	static TInt ModuleGeneration = 0;

 	static TInt Time = 0;

 	WCHAR ex_[KMaxFileName + 1];

 	if (!Time)

 		{

 		SYSTEMTIME st;

 		GetSystemTime(&st);

 		Time = st.wSecond + st.wMinute*60 + st.wHour*3600;

 		}

 	const char* imagePath = Property::GetString("EmulatorImagePath");

 	WCHAR* p = ex_;

 	while ((*p++ = *imagePath++) != 0)

 		;

 	wcscpy(p-1, wcsrchr(aExe, '\\') + 1);

 	p = ex_ + wcslen(ex_);

 	*p++ = '(';

 	_itow(Time, p, 36);

 	p += wcslen(p);

 	*p++ = '-';

 	_itow(ModuleGeneration++, p, 10);

 	p += wcslen(p);

 	*p++ = ')';

 	*p++ = '\0';

 	wchar_t* file = (wchar_t*)Kern::Alloc((p-ex_)*sizeof(WCHAR));

 	if (file)

 		wcscpy(file, ex_);

 	return file;

 	}

 DCodeSeg* M::NewCodeSeg(TCodeSegCreateInfo&)

 //

 // Create a new instance of this class.

 //

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("M::NewCodeSeg"));

 	return new DWin32CodeSeg;

 	}

 DWin32CodeSeg::DWin32CodeSeg()

 //

 // Constructor

 //

 	{

 	}

 DWin32CodeSeg::~DWin32CodeSeg()

 //

 // Destructor

 //

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("DWin32CodeSeg::Destruct %C", this));

 	DBase::Delete(iModuleList);

 	if (iWinInstance)

 		{

 		DCodeSeg::Wait();

 		SWin32Module w32m;

 		w32m.iWin32ModuleHandle=(TLinAddr)iModuleHandle;

 		w32m.iCodeSeg=NULL;

 		TInt ix=MM::Win32Modules.FindInUnsignedKeyOrder(w32m);

 		if (ix>=0)

 			{

 			if (iAlwaysLoaded)

 				MM::Win32Modules[ix].iCodeSeg=NULL;

 			else

 				MM::Win32Modules.Remove(ix);

 			}

 		// Kernel process has to be told to unmap code seg to work round

 		// a problem where failed driver code seg is not unmapped before delete

 		K::TheKernelProcess->UnmapCodeSeg(this);

 		Emulator::FreeLibrary(iWinInstance);

 		DCodeSeg::Signal();

 		}

 	if (iModuleFile)

 		{

 		Emulator::DeleteFile(iModuleFile);

 		Kern::Free(iModuleFile);

 		}

 	Kern::Free(iDataCopy);

 	DCodeSeg::Destruct();

 	}

 TInt DWin32CodeSeg::DoCreate(TCodeSegCreateInfo& aInfo, DProcess* aProcess)

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("DWin32CodeSeg::DoCreate %C proc %O", this, aProcess));

 	TBool exe=(iExeCodeSeg==this);

 	if (exe && (iAttr&ECodeSegAttKernel))

 		{

 		// loading EKERN.EXE

 		__KTRACE_OPT(KDLL,Kern::Printf("W32CodeSeg : EKERN"));

 		TUint16 fileNameW[KMaxFileName];

 		ExpandToWide(fileNameW, iFileName->Ptr(), iFileName->Length());

 		fileNameW[iFileName->Length()] = '\0';

 		iWinInstance = Emulator::LoadLibrary((LPCWSTR)fileNameW);

 		__KTRACE_OPT(KDLL,Kern::Printf("W32CodeSeg : EKERN %08x", iWinInstance));

 		if (!iWinInstance)

 			return KErrGeneral;

 		if (aInfo.iTotalDataSize)

 			iMark|=EMarkData|EMarkDataPresent;

 		KernelCodeSeg=this;

 		KernelModuleHandle=Emulator::GetModuleHandle((LPCWSTR)fileNameW);

 		return RegisterCodeSeg(KernelModuleHandle);

 		}

 	TWin32Filename w32fn(*iFileName);

 	__KTRACE_OPT(KDLL,Kern::Printf("W32CodeSeg : w32fn=%S",iFileName))

 	DWin32Process* p=(DWin32Process*)aProcess;

 	TInt r=KErrNone;

 	DCodeSeg::Wait();

 	HMODULE h = Emulator::GetModuleHandle(w32fn);

 	__KTRACE_OPT(KDLL,Kern::Printf("W32CodeSeg : h=%08x exe=%08x",h,exe));

 	if (h && exe)

 		{

 		if (h == GetModuleHandleA(NULL))

 			{

 			// This was the executable that was used to run the emulator

 			// so all relocations will be valid and we can use it

 			__KTRACE_OPT(KDLL,Kern::Printf("W32CodeSeg : initial exe"));

 			if (BootComplete)

 				goto makecopy;	// we can only do this once however

 			iWinInstance = Emulator::LoadLibrary(w32fn);

 			BootComplete = ETrue;

 			}

 		else

 			r=KErrAlreadyExists;		// can't load same EXEXP twice

 		}

 	else if (h)

 		{

 		// Already loaded DLL

 		// Code segment doesn't exist so create it

 		__KTRACE_OPT(KDLL,Kern::Printf("Already loaded, module %08x",h));

 		iWinInstance = Emulator::LoadLibrary(w32fn);

 		}

 	else if (iAttr & ECodeSegAttHDll)

 		{

 		// EXE with exports (EXEXP target) - can only have one instance

 		// or DLL not already loaded

 		__KTRACE_OPT(KDLL,Kern::Printf("W32CodeSeg : EXEXP or new DLL"));

 		iWinInstance = Emulator::LoadLibrary(w32fn);

 		if (iWinInstance)

 			h=Emulator::GetModuleHandle(w32fn);

 		}

 	else

 		{

 		// EXE with no exports. In order that multiple instances of the EXE may be run,

 		// we make a copy of the EXE file to a name which is unique across instances,

 		// set the DLL flag and load it as a DLL.

 makecopy:

 		__KTRACE_OPT(KDLL,Kern::Printf("W32CodeSeg : MakeCopy"));

 		h=0;

 		iModuleFile = TempModuleName(w32fn);

 		if (!iModuleFile)

 			r=KErrNoMemory;

 		else if (Emulator::CopyFile(w32fn,iModuleFile,FALSE))

 			{

 			DWORD fattr = Emulator::GetFileAttributes(iModuleFile);

 			if (fattr != 0xffffffff && Emulator::SetFileAttributes(iModuleFile, fattr & ~FILE_ATTRIBUTE_READONLY))

 				{

 				HANDLE f = Emulator::CreateFile(iModuleFile,GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_FLAG_RANDOM_ACCESS,NULL);

 				if (INVALID_HANDLE_VALUE != f)

 					{

 					r = MakeDll(f);

 					CloseHandle(f);

 					if (r==KErrNone)

 						{

 						iWinInstance = Emulator::LoadLibrary(iModuleFile);

 						if (iWinInstance)

 							h=Emulator::GetModuleHandle(iModuleFile);

 						}

 					}

 				}

 			}

 		}

 	__KTRACE_OPT(KDLL,Kern::Printf("W32CodeSeg : line %d r=%d iWinInstance=%08x",__LINE__,r,iWinInstance));

 	if (r==KErrNone && !iWinInstance)

 		r=Emulator::LastError();

 	__KTRACE_OPT(KDLL,Kern::Printf("W32CodeSeg : line %d r=%d",__LINE__,r));

 	if (r==KErrNone)

 		{

 		const char* entry_name = exe ? "_E32Startup" : "_E32Dll" ;

 		aInfo.iFileEntryPoint = (TLinAddr)Emulator::GetProcAddress(iWinInstance, entry_name);

 		if (!aInfo.iFileEntryPoint)

          {

 			r=KErrNotSupported;

          }

 		else

          {

 			r=RegisterCodeSeg(h);

          }

 		if (r == KErrNone)

          {

 			r = CopyDataBss();

          }

 		}

 	if (r==KErrNone && aInfo.iTotalDataSize && !iAlwaysLoaded)

 		{

 		iMark|=EMarkData|EMarkDataPresent;

 		if (!exe)

 			iMark|=EMarkDataInit;

 		}

 	if (r==KErrNone)

 		r=ProcessImports(p);

 	__KTRACE_OPT(KDLL, DumpWin32CodeSeg(*this));

 	DCodeSeg::Signal();

 	return r;

 	}

 TInt DWin32CodeSeg::RegisterCodeSeg(HMODULE aModule)

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("DWin32CodeSeg %C RegisterCodeSeg(%08x)", this, aModule));

 	Emulator::TModule etm(aModule);

 	const IMAGE_NT_HEADERS32* nth=etm.NtHeader();

 	iRunAddress = (TLinAddr)aModule;

 	iSize = nth->OptionalHeader.SizeOfImage;

 	SWin32Module w32m;

 	w32m.iWin32ModuleHandle=(TLinAddr)aModule;

 	w32m.iCodeSeg=this;

 	TInt r=KErrNone;

 	TInt ix=MM::Win32Modules.FindInUnsignedKeyOrder(w32m);

 	if (ix>=0)

 		{

 		SWin32Module& wmr=MM::Win32Modules[ix];

 		__ASSERT_ALWAYS(!wmr.iCodeSeg, MM::Panic(MM::EInvalidSharedModule));

 		wmr.iCodeSeg=this;

 		iAlwaysLoaded=ETrue;

 		}

 	else

 		r=MM::Win32Modules.InsertInUnsignedKeyOrder(w32m);

 	if (r==KErrNone)

 		{

 		iModuleHandle=aModule;

 		iCodeSegId=++MM::NextCodeSegId;

 		}

 	return r;

 	}

 TInt DWin32CodeSeg::CreateAlreadyLoaded(HMODULE aModule, TInt aDepCount)

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("DWin32CodeSeg %08x CreateAlreadyLoaded(%08x,%d)", this, aModule, aDepCount));

 	Emulator::TModule etm(aModule);

 	etm.GetUids(iUids);

 	TInt32 uid1=iUids.iUid[0].iUid;

 	if (uid1!=KDynamicLibraryUidValue)	// only implicitly load DLLs

 		return KErrNotSupported;

 	WCHAR name[MAX_PATH+1];

 	TInt r=Emulator::GetModuleFileName(aModule, name);

 	if (!r)

 		return Emulator::LastError();

 	TUint8 name8[MAX_PATH+1];

 	TruncToNarrow(name8,(const TUint16*)name,-1);

    //SL:

    __KTRACE_OPT(KDLL, Kern::Printf("Loading library %s", name8));

 	TPtrC fpptr((const TText*)name8);

 	TInt slash=fpptr.LocateReverse('\\');

 	TPtrC nptr=fpptr.Mid(slash+1);

 	iFileName=HBuf::New(nptr);

 	if (!iFileName)

 		return KErrNoMemory;

 	iRootName.Set(*iFileName);

 	iExtOffset = iFileName->LocateReverse('.');

 	if (iExtOffset==KErrNotFound)

 		iExtOffset = iFileName->Length();

 	iModuleVersion = 0x00010000u;

 	iDepCount=aDepCount;

 	if (iDepCount)

 		{

 		iDeps=(DCodeSeg**)Kern::AllocZ(iDepCount*sizeof(DCodeSeg*));

 		if (!iDeps)

 			return KErrNoMemory;

 		}

 	iWinInstance = Emulator::LoadLibrary(name);

 	if (!iWinInstance)

 		return Emulator::LastError();

 	iFileEntryPoint = (TLinAddr)Emulator::GetProcAddress(iWinInstance, "_E32Dll");

 	if (!iFileEntryPoint)

 		return KErrNotSupported;

 	iEntryPtVeneer = iFileEntryPoint;

 	r=RegisterCodeSeg(aModule);

 	if (r == KErrNone)

 		r = CopyDataBss();

 	if (r == KErrNone)

 		r = CodeSegsByName.InsertInOrderAllowRepeats(this, &CompareCodeSegsByName);

 	if (r == KErrNone)

 		r = CodeSegsByAddress.Add(this);

 	if (r==KErrNone)

 		{

 		GlobalList.Add(&iLink);

 		iAsyncDeleteNext=this;

 		}

 	__KTRACE_OPT(KDLL, DumpWin32CodeSeg(*this));

 	return r;

 	}

 TInt DWin32CodeSeg::CopyDataBss()

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("DWin32CodeSeg::CopyDataBss()"));

 	Emulator::TModule etm(iModuleHandle);

 	const TEmulatorImageHeader* hdr = (const TEmulatorImageHeader*)etm.Section(KWin32SectionName_Symbian);

 	if (!(hdr->iFlags & KEmulatorImageFlagAllowDllData))

 		return KErrNone;

 	const IMAGE_SECTION_HEADER* data=etm.SectionHeader(KWin32SectionName_EpocData);

 	const IMAGE_SECTION_HEADER* bss=etm.SectionHeader(KWin32SectionName_EpocBss);

 	if (data)

 		{

 		iRealDataSize = data->Misc.VirtualSize;

 		iDataDest = (TLinAddr)etm.Translate(data->VirtualAddress);

 		iDataCopy = Kern::Alloc(iRealDataSize);

 		if (!iDataCopy)

 			return KErrNoMemory;

 		memcpy(iDataCopy, (const TAny*)iDataDest, iRealDataSize);

 		}

 	if (bss)

 		{

 		iRealBssSize = bss->Misc.VirtualSize;

 		iBssDest = (TLinAddr)etm.Translate(bss->VirtualAddress);

 		}

 	return KErrNone;

 	}

 TInt DWin32CodeSeg::ProcessImports(DProcess* aProcess)

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("DWin32CodeSeg::ProcessImports(%O)", aProcess));

 	iModuleList=new DModuleList(this, aProcess);

 	if (!iModuleList)

 		return KErrNoMemory;

 	TInt r=iModuleList->GatherDependencies(iModuleHandle);

 	if (r!=KErrNone)

 		return r;

 	TInt ix=iModuleList->Find((TInt)iModuleHandle);

 	DModuleList::SModule& mm=iModuleList->iModules[ix];

 	r=iModuleList->CompileDepLists();

 	if (r==KErrNone)

 		{

 		iModuleList->SetFlags();

 		r=iModuleList->LoadDependencies();

 		if (r==KErrNone)

 			{

 			if ((mm.iFlags&(DModuleList::EFlagDataPresent|DModuleList::EFlagExeInTree)) && !(mm.iFlags&DModuleList::EFlagAlwaysLoaded))

 				{

 				if (aProcess)

 					{

 					iExeCodeSeg=aProcess->CodeSeg();

 					SetAttachProcess(aProcess);

 					}

 				}

 			iModuleList->LinkDependencies();

 			}

 		}

 	return r;

 	}

 TInt DWin32CodeSeg::Loaded(TCodeSegCreateInfo& aInfo)

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("DWin32CodeSeg::Loaded()"));

 	TInt r=KErrNone;

 	if (iModuleList)

 		{

 		r=iModuleList->Loaded();

 		if (r==KErrNone)

 			{

 			DBase::Delete(iModuleList);

 			iModuleList=NULL;

 			}

 		}

 	if (r==KErrNone)

 		r=DCodeSeg::Loaded(aInfo);

 	__KTRACE_OPT(KDLL, Kern::Printf("DWin32CodeSeg::Loaded() - %d", r));

 	return r;

 	}

 void DWin32CodeSeg::ReadExportDir(TUint32*)

 	{

 	// not needed

 	}

 TBool DWin32CodeSeg::FindCheck(DProcess* /*aProcess*/)

 	{

 	// We never create multiple copies of the same code segment,

 	// so if code segment exists, allow it to be found.

 	// CodeSegOpen will fail if it is incompatible.

 	return ETrue;

 	}

 TBool DWin32CodeSeg::OpenCheck(DProcess* aProcess)

 	{

 	__KTRACE_OPT(KDLL,Kern::Printf("CSEG:%08x Compat? proc=%O",this,aProcess));

 	if (!aProcess)

 		return EFalse;	// never reuse EXE code segments

 	return ETrue;

 	}

 TLibraryFunction DWin32CodeSeg::Lookup(TInt aOrdinal)

 //

 // Find an exported function by ordinal

 //

 	{

 	TLibraryFunction f = NULL;

 	if (aOrdinal != 0)

 		{

 		f = (TLibraryFunction)Emulator::GetProcAddress(iWinInstance, (const char *)aOrdinal);

 		if ((TLinAddr)f == iFileEntryPoint)

 			f = NULL;

 		}

 	else

 		{

 		// Find 0th Ordinal, which should be named symbol export data, from named data segment

 		Emulator::TModule etm(iModuleHandle);

 		f  = (TLibraryFunction)etm.Section(KWin32SectionName_NmdExpData);

 		}

  	__KTRACE_OPT(KDLL,Kern::Printf("DWin32CodeSeg::Lookup(%d)->%08x",aOrdinal,f));

 	return f;

 	}

 DCodeSeg* DCodeSeg::FindRomCode(const TAny*)

 	{

 	// never used

 	return NULL;

 	}

 void DWin32CodeSeg::InitData()

 	{

 	}

 TInt DWin32CodeSeg::GetMemoryInfo(TModuleMemoryInfo&, DProcess*)

 	{

 	return KErrNotSupported;

 	}

 void DWin32CodeSeg::Info(TCodeSegCreateInfo& aInfo)

 	{

 	Emulator::TModule etm(iModuleHandle);

 	const IMAGE_NT_HEADERS32* nth=etm.NtHeader();

 	const IMAGE_EXPORT_DIRECTORY* exd=

 		(const IMAGE_EXPORT_DIRECTORY*)etm.Translate(nth->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

 	const TEmulatorImageHeader* hdr = (const TEmulatorImageHeader*)etm.Section(KWin32SectionName_Symbian);

 	TBool isExe = hdr && hdr->iUids[0].iUid==KExecutableImageUidValue;

 	const IMAGE_SECTION_HEADER* text=etm.SectionHeader(KWin32SectionName_Text);

 	const IMAGE_SECTION_HEADER* rdata=etm.SectionHeader(KWin32SectionName_RData);

 	const IMAGE_SECTION_HEADER* data=etm.SectionHeader(KWin32SectionName_EpocData);

 	if (!isExe && !(hdr->iFlags & KEmulatorImageFlagAllowDllData))

 		data = NULL;

 	aInfo.iTextSize=text->Misc.VirtualSize;

 	aInfo.iCodeSize=text->Misc.VirtualSize;

 	if (rdata)

 		aInfo.iCodeSize+=rdata->Misc.VirtualSize;

 	aInfo.iDataSize=data ? (data->SizeOfRawData) : 0;

 	aInfo.iBssSize=data ? (data->Misc.VirtualSize-data->SizeOfRawData) : 0;

 	aInfo.iTotalDataSize=aInfo.iDataSize+aInfo.iBssSize;

 	aInfo.iExportDir=(TLinAddr)exd;

 	aInfo.iExportDirCount=exd ? exd->NumberOfFunctions : 0;

 	aInfo.iCodeLoadAddress=(TLinAddr)etm.Translate(text->VirtualAddress);

 	aInfo.iCodeRunAddress=aInfo.iCodeLoadAddress;

 	aInfo.iDataLoadAddress=data ? (TLinAddr)etm.Translate(data->VirtualAddress) : 0;

 	aInfo.iDataRunAddress=aInfo.iDataLoadAddress;

 	DCodeSeg::Info(aInfo);

 	}

 TLinAddr DCodeSeg::ExceptionDescriptor()

 	{

 	return 0;	// not used on emulator

 	}

 TInt MM::RegisterModule(HMODULE aModule)

 	{

 	__KTRACE_OPT(KBOOT, Kern::Printf("MM::RegisterModule %08x",aModule));

 	SWin32Module w32m;

 	w32m.iWin32ModuleHandle=(TLinAddr)aModule;

 	w32m.iCodeSeg=NULL;

 	TInt r=MM::Win32Modules.InsertInUnsignedKeyOrder(w32m);

 	__KTRACE_OPT(KBOOT, Kern::Printf("MM::RegisterModule ret %d",r));

 	return r;

 	}

 _LIT(KRomSysBin, "Z:\\sys\\bin");

 // Massage file names returned for stuff in EPOCROOT\epoc32\release\wins\xxxx\

 // in order to make them appear to be in z:\system\libs

 void P::NormalizeExecutableFileName(TDes& a)

 	{

 	__KTRACE_OPT(KDLL, Kern::Printf("NormalizeExecutableFileName %lS", &a));

 	if (a.Length()<3 || a[1]!=':' || a[2]!='\\')

 		{

 		// don't have a drive so assume in 'ROM'

 		TFileName initial(a);

 		a=KRomSysBin();

 		if (initial.Length()==0 || initial[0]!='\\')

 			a.Append('\\');

 		a+=initial;

 		__KTRACE_OPT(KDLL, Kern::Printf("NormalizeExecutableFileName -> %lS", &a));

 		}

 	}

 TInt LookupDllUid(TInt aModule)

 	{

 	TInt r = KDllUid_Default;

 	Kern::AccessCode();

 	SWin32Module w32m;

 	w32m.iWin32ModuleHandle=(TLinAddr)aModule;

 	TInt ix;

 	MM::Win32Modules.SpecificFindInUnsignedKeyOrder(w32m, ix, EArrayFindMode_Last);

 	if (ix>0)

 		{

 		DWin32CodeSeg* pS = MM::Win32Modules[ix-1].iCodeSeg;

 		if (pS && pS->iFileEntryPoint==(TLinAddr)aModule)

 			r = pS->iCodeSegId;

 		}

 	Kern::EndAccessCode();

 	return r;

 	}