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

    }

}

Address

LargeObjectSpace::allocate(size_t nbytes)

{

    assert(IsAligned(nbytes, kObjectAlignment));

    if (last_) {

        if (Address addr = last_->allocate(nbytes))

            return addr;

    }

}