/* 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 <stdlib.h>

#include <string.h>

#include "BytecodeEmitter.h"

#include "Utility.h"

#include "Types.h"

#include "Zone.h"

#include "Spaces-inl.h"

#include "Heap-inl.h"

using namespace ke;

BytecodeEmitter::BytecodeEmitter(PoolAllocator &pool)

  : pool_(pool),

    buffer_(inline_buffer_),

    buffer_pos_(buffer_),

    buffer_end_(buffer_pos_ + ARRAY_LENGTH(inline_buffer_)),

    oom_(false),

    maxStackDepth_(0)

{

    lastCodePosition_ = 0;

    firstLine_ = 1;

}

bool

BytecodeEmitter::growBuffer(size_t nbytes)

{

    if (oom_) {

        buffer_pos_ = buffer_;

        return false;

    }

    size_t newSize = size_t((buffer_end_ - buffer_) * 2);

    if (newSize >= MAX_LENGTH) {

        oom_ = true;

        buffer_pos_ = buffer_;

        ZONE()->reportOutOfMemory();

        return false;

    }

    bytecode *newBuffer;

    if (buffer_ == inline_buffer_)

        newBuffer = (bytecode *)malloc(newSize);

    else

        newBuffer = (bytecode *)realloc(buffer_, newSize);

    // If we can't allocate a buffer, reset the buffer to the start and set

    // a flag to indicate out-of-memory.

    if (!newBuffer) {

        oom_ = true;

        buffer_pos_ = buffer_;

        ZONE()->reportOutOfMemory();

        return false;

    }

    if (buffer_ == inline_buffer_)

        memcpy(newBuffer, inline_buffer_, (buffer_pos_ - inline_buffer_));

    buffer_pos_ = newBuffer + size_t(buffer_pos_ - buffer_);

    buffer_ = newBuffer;

    buffer_end_ = buffer_ + newSize;

    assert(buffer_pos_ + nbytes < buffer_end_);

    return true;

}

void

BytecodeEmitter::recordOops()

{

    OopRecord *record = new (pool_) OopRecord(oopMap_.length(), position());

    record->slots = (bool *)pool_.allocate(record->depth);

    if (!record->slots) {

        oom_ = true;

        return;

    }

    bool hadOops = false;

    for (size_t i = 0; i < oopMap_.length(); i++) {

        bool bit = oopMap_[i];

        record->slots[i] = bit;

        hadOops |= bit;

    }

    if (!hadOops)

        return;

    oom_ &= oopRecords_.append(record);

}

void

BytecodeEmitter::note_position(const SourcePosition &pos)

{

    assert(pos.line > 0);

    assert(unsigned(pos.line) >= firstLine_);

    unsigned lineDelta = unsigned(pos.line) - firstLine_;

    unsigned pcDelta = unsigned(position()) - lastCodePosition_;

    sourcemap_.writeUint32(pcDelta);

    sourcemap_.writeUint32(lineDelta);

    sourcemap_.writeUint32(pos.col);

    lastCodePosition_ = unsigned(position());

}