/* vim: set ts=4 sw=4 tw=99 et:

  *

  * Copyright (C) 2012 David Anderson

  *

  * This file is part of JITCraft.

  *

  * JITCraft is free software: you can redistribute it and/or modify it under

  * the terms of the GNU General Public License as published by the Free

  * Software Foundation, either version 3 of the License, or (at your option)

  * any later version.

  * 

  * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License along with

  * JITCraft. If not, see http://www.gnu.org/licenses/.

  */

 #include "Spaces.h"

 #include "Platform.h"

 #include "Spaces-inl.h"

 using namespace jc;

 HeapStack::HeapStack()

   : buffer_(NULL),

     pos_(NULL),

     end_(NULL)

 {

 }

 HeapStack::~HeapStack()

 {

     if (buffer_)

         OS::UnmapAlignedMemory(map_.base(), map_.size());

 }

 bool

 HeapStack::initialize()

 {

     map_ = OS::MapAlignedMemory(kStackSize, kStackSize, OS::Map_Commit);

     if (!map_.base())

         return false;

     buffer_ = map_.aligned();

     pos_ = buffer_;

     end_ = buffer_ + kStackSize;

     mask_ = kStackSize - 1;

     return true;

 }

 HeapChunk *

 HeapChunk::New(HeapChunk *prev, size_t size)

 {

     OS::AlignableMapping map = 

         OS::MapAlignedMemory(size, HeapChunk::kAlignment, OS::Map_Commit);

     if (!map.base())

         return NULL;

     HeapChunk *chunk = reinterpret_cast<HeapChunk *>(map.aligned());

     chunk->base_ = map.base();

     chunk->end_ = map.base() + map.size();

     chunk->cursor_ = chunk->first();

     if (prev)

         prev->next_ = chunk;

     return chunk;

 }

 void

 HeapChunk::Destroy(HeapChunk *chunk)

 {

     OS::UnmapAlignedMemory(chunk->base(), chunk->size());

 }

 OldSpace::OldSpace()

   : first_(NULL),

     last_(NULL)

 {

 }

 bool

 OldSpace::initialize()

 {

     first_ = HeapChunk::New(first_, HeapChunk::kDefaultSize);

     last_ = first_;

     return !!first_;

 }

 Address

 OldSpace::allocateSlow(size_t nbytes)

 {

     HeapChunk *chunk = HeapChunk::New(last_, HeapChunk::kDefaultSize);

     if (!chunk)

         return NULL;

     return chunk->allocate(nbytes);

 }

 OldSpace::~OldSpace()

 {

     while (first_) {

         HeapChunk *temp = first_->next();

         HeapChunk::Destroy(first_);

         first_ = temp;

     }

 }

 LargeObjectSpace::LargeObjectSpace()

   : first_(NULL),

     last_(NULL)

 {

 }

 LargeObjectSpace::~LargeObjectSpace()

 {

     while (first_) {

         HeapChunk *temp = first_->next();

         HeapChunk::Destroy(first_);

         first_ = temp;

     }

 }

 bool

 LargeObjectSpace::initialize()

 {

     return true;

 }

 Address

 LargeObjectSpace::allocate(size_t nbytes)

 {

     assert(IsAligned(nbytes, kObjectAlignment));

     // Always allocate a new chunk for large objects.

     HeapChunk *chunk = HeapChunk::New(last_, nbytes);

     if (!chunk)

         return NULL;

     if (!first_)

         first_ = chunk;

     last_ = chunk;

     Address address = chunk->allocate(nbytes);

     assert(address);

     return address;

 }