// 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\epoc\direct\mcodeseg.cpp

// 

//

#include <memmodel.h>

#include <kernel/cache.h>

DCodeSeg* M::NewCodeSeg(TCodeSegCreateInfo&)

	{

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

	return new DMemModelCodeSeg;

	}

DEpocCodeSegMemory* DEpocCodeSegMemory::New(DEpocCodeSeg* aCodeSeg)

	{

	return new DMemModelCodeSegMemory(aCodeSeg);

	}

DMemModelCodeSegMemory::DMemModelCodeSegMemory(DEpocCodeSeg* aCodeSeg)

	: DEpocCodeSegMemory(aCodeSeg)

	{

	}

DMemModelCodeSeg::DMemModelCodeSeg()

	{

	}

DMemModelCodeSeg::~DMemModelCodeSeg()

//

// Destructor

//

	{

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

	if (!iXIP && iMemory)

		{

		SRamCodeInfo& ri=RamInfo();

		if (ri.iCodeLoadAddr)

			{

			TInt code_size=MM::RoundToBlockSize(ri.iCodeSize+ri.iDataSize);

			MM::FreeRegion(ri.iCodeLoadAddr, code_size);

			}

		if (iDataAlloc)

			{

			TInt data_size=MM::RoundToBlockSize(ri.iDataSize+ri.iBssSize);

			MM::FreeRegion(iDataAlloc, data_size);

			}

		}

	Kern::Free(iKernelData);

	DEpocCodeSeg::Destruct();

	}

TInt DMemModelCodeSeg::DoCreateRam(TCodeSegCreateInfo& aInfo, DProcess* aProcess)

	{

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

	DMemModelProcess* p=(DMemModelProcess*)aProcess;

	TBool kernel=( (iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == ECodeSegAttKernel );

	SRamCodeInfo& ri=RamInfo();

	iSize = MM::RoundToBlockSize(ri.iCodeSize+ri.iDataSize);

	TInt total_data_size=ri.iDataSize+ri.iBssSize;

	TInt r=MM::AllocRegion(ri.iCodeLoadAddr, iSize);

	if (r!=KErrNone)

		return r;

	ri.iCodeRunAddr=ri.iCodeLoadAddr;

	if (ri.iDataSize)

		ri.iDataLoadAddr=ri.iCodeLoadAddr+ri.iCodeSize;

	if (kernel)

		{

		if (total_data_size)

			{

			iKernelData=Kern::Alloc(total_data_size);

			if (!iKernelData)

				return KErrNoMemory;

			ri.iDataRunAddr=(TLinAddr)iKernelData;

			}

		return KErrNone;

		}

	if (total_data_size && p)

		SetAttachProcess(p);

	if (total_data_size && !IsExe())

		{

		TInt data_alloc_size=MM::RoundToBlockSize(total_data_size);

		TInt r=MM::AllocRegion(iDataAlloc, data_alloc_size);

		if (r!=KErrNone)

			return r;

		ri.iDataRunAddr=iDataAlloc;

		}

	return r;

	}

TInt DMemModelCodeSeg::DoCreateXIP(DProcess* aProcess)

	{

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

	DMemModelProcess* p=(DMemModelProcess*)aProcess;

	TInt r=KErrNone;

	TBool kernel=( (iAttr&(ECodeSegAttKernel|ECodeSegAttGlobal)) == ECodeSegAttKernel );

	const TRomImageHeader& rih=RomInfo();

	if (!kernel && aProcess)

		{

		// XIP images with static data are specific to a single process

		if (rih.iFlags&KRomImageFlagDataPresent)

			SetAttachProcess(p);

		}

	return r;

	}

TInt DMemModelCodeSeg::Loaded(TCodeSegCreateInfo& aInfo)

	{

	if (!iXIP)

		{

		// Clean DCache for specified area, Invalidate ICache/BTB for specified area

		TLinAddr code_base=RamInfo().iCodeRunAddr;

		Cache::IMB_Range(code_base, RamInfo().iCodeSize);

		}

	return DEpocCodeSeg::Loaded(aInfo);

	}

void DMemModelCodeSeg::ReadExportDir(TUint32* aDest)

	{

	__KTRACE_OPT(KDLL,Kern::Printf("DMemModelCodeSeg::ReadExportDir %08x",aDest));

	if (!iXIP)

		{

		SRamCodeInfo& ri=RamInfo();

		TInt size=(ri.iExportDirCount+1)*sizeof(TLinAddr);

		kumemput32(aDest, (const TUint32*)(ri.iExportDir-sizeof(TUint32)), size);

		}

	}

TBool DMemModelCodeSeg::OpenCheck(DProcess* aProcess)

	{

	return FindCheck(aProcess);

	}

TBool DMemModelCodeSeg::FindCheck(DProcess* aProcess)

	{

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

	if (!aProcess)

		return !iAttachProcess;	// can't reuse same code segment for a new instance of the process

	DMemModelProcess& p=*(DMemModelProcess*)aProcess;

	DCodeSeg* pPSeg=p.CodeSeg();

	if (iAttachProcess && iAttachProcess!=aProcess)

		return EFalse;

	if (iExeCodeSeg && iExeCodeSeg!=pPSeg)

		return EFalse;

	__ASSERT_DEBUG( (iAttachProcess || !(iMark & EMarkDataPresent)), MM::Panic(MM::ECodeSegCheckInconsistent));

	return ETrue;

	}