/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     init_Alloc.cpp

  Copyright (C)2009 Nintendo Co., Ltd.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Rev: 20442 $
 *---------------------------------------------------------------------------*/

//---------------------------------------------------------------------------

#include <new>
#include <nn/Result.h>
#include <nn/config.h>
#include <nn/assert.h>
#include <nn/fnd/fnd_ExpHeap.h>
#include <nn/init/init_Allocator.h>
#include <nn/os/os_LockPolicy.h>
#include <nn/os/os_Memory.h>
#include <nn/os/os_MemoryMapSelect.h>
#include <nn/os/os_CriticalSection.h>
#include <nn/svc/svc_stub.h>
#include <nn/util/util_Result.h>
#include <nn/util/util_TypeTraits.h>

using namespace nn::os;

typedef nn::fnd::ExpHeapTemplate<nn::os::LockPolicy::Object<nn::os::CriticalSection> > SystemExpHeap;

namespace 
{
    SystemExpHeap*              s_pSystemHeap = 0;       //!< システムヒープ
    nn::util::aligned_storage<sizeof(SystemExpHeap::Allocator), nn::util::alignment_of<SystemExpHeap::Allocator>::value >::type s_SystemAllocatorBuffer;
    SystemExpHeap::Allocator*   s_pSystemAllocator = 0;  //<! システムヒープ用アロケータ

#if NN_PLATFORM_HAS_MMU
    nnosMemoryBlock s_HeapMemoryBlock;
#endif  // if NN_PLATFORM_HAS_MMU
}

extern "C"{

// ABI のオーバーライド
NN_WEAK_SYMBOL void* malloc(size_t size)
{
    return s_pSystemHeap->Allocate(size);
}

// ABI のオーバーライド
NN_WEAK_SYMBOL void free(void* p)
{
    if (p)
    {
        s_pSystemHeap->Free(p);
    }
}

} // extern "C"


NN_WEAK_SYMBOL void* operator new (size_t size, const ::std::nothrow_t&) throw()
{
    return malloc(size);
}

NN_WEAK_SYMBOL void* operator new[] (size_t size, const ::std::nothrow_t&) throw()
{
    return operator new(size, ::std::nothrow_t());
}

NN_WEAK_SYMBOL void operator delete (void* p) throw()
{
    free(p);
}

NN_WEAK_SYMBOL void operator delete[] (void* p) throw()
{
    operator delete(p);
}

//NN_WEAK_SYMBOL void operator delete (void* p, const ::std::nothrow_t&) throw()
//{
//    if( p != 0 )
//    {
//        free(p);
//    }
//}

//NN_WEAK_SYMBOL void operator delete[] (void* p, const ::std::nothrow_t&) throw()
//{
//    if( p != 0 )
//    {
//        free(p);
//    }
//}

namespace nn { namespace init {

// 注意
// この周辺の関数は initStartup から呼ばれるものがある。
// initStartup は static initializer 以前に呼ばれる関数のため、
// この周辺の関数で non-POD クラスの static オブジェクトを初期化すると、
// static initializer で再初期化されてしまい、正常に動作しない。
// aligned_storage + placement new で実装すること。

// システムヒープを作成
void InitializeAllocator(uptr addr, size_t size)
{
    NN_TASSERT_(size >= sizeof(SystemExpHeap));
    const size_t alignment = nn::util::alignment_of<SystemExpHeap>::value;
    uptr heapAddr = (((addr - 1) / alignment) + 1) * alignment;
    uptr headAddr = heapAddr + sizeof(SystemExpHeap);
    s_pSystemHeap = new (reinterpret_cast<void*>(heapAddr)) SystemExpHeap(headAddr, addr + size - headAddr);
    s_pSystemAllocator = new (&s_SystemAllocatorBuffer) SystemExpHeap::Allocator(*s_pSystemHeap);
}

#if NN_PLATFORM_HAS_MMU
void InitializeAllocator(size_t size)
{
    nnosMemoryBlockAllocate(&s_HeapMemoryBlock, size);
    NN_TASSERT_(nnosMemoryBlockGetSize(&s_HeapMemoryBlock) == size);
    InitializeAllocator(nnosMemoryBlockGetAddress(&s_HeapMemoryBlock), size);
}
#endif  // if NN_PLATFORM_HAS_MMU

nn::fnd::IAllocator* GetAllocator(void)
{
    return s_pSystemAllocator;
}

}} // namespace nn::init