// 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;
	}