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

#include "../Types.h"

#include "../Zone.h"

#include "../Strings.h"

#include "../Zone.h"

#include "BytecodeEmitter.h"

#include "Symbols.h"

#include "Scopes.h"

#include "../Spaces-inl.h"

#include "../Heap-inl.h"

using namespace ke;

StringTable::StringTable()

  : set_(ZoneAllocatorPolicy()),

    initialized_(false)

{

}

bool

StringTable::initialize()

{

    assert(!initialized_);

    initialized_ = true;

    if (!set_.init(16))

        return false;

    return true;

}

bool

StringTable::add(Handle<String> name, unsigned *indexp)

{

    if (!initialized_ && !initialize())

        return false;

    Set::Insert p = set_.findForAdd(*name);

    if (p.found()) {

        *indexp = p->index;

        return true;

    }

    if (strings_.length() > INT_MAX) {

        ZONE()->reportAllocationOverflow();

        return false;

    }

    Entry e(name, strings_.length());

    if (!strings_.append(e))

        return false;

    if (!set_.add(p, e))

        return false;

    *indexp = e.index;

    return true;

}

void

StringTable::accept(VirtualObjectVisitor *visitor)

{

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

        visitor->visit(reinterpret_cast<Object **>(&strings_[i].string));

}

BytecodeEmitter::BytecodeEmitter(PoolAllocator &pool)

  : AutoRooted(ZONE()),

    pool_(pool),

    buffer_(inline_buffer_),

    buffer_pos_(buffer_),

    buffer_end_(buffer_pos_ + ARRAY_LENGTH(inline_buffer_)),

    oom_(false),

    maxStackDepth_(0),

    loopDepth_(0),

    maxLoopDepth_(0)

{

    lastCodePosition_ = 0;

    firstLine_ = 1;

}

BytecodeEmitter::~BytecodeEmitter()

{

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

        delete oopRecords_[i];

}

void

BytecodeEmitter::accept(VirtualObjectVisitor *visitor)

{

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

        visitor->visit(&objects_[i]);

    strings_.accept(visitor);

}

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 OopRecord(oopMap_.length(), position());

    if (!record->slots.ensure(record->depth)) {

        oom_ = true;

        return;

    }

    bool hadOops = false;

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

        bool bit = oopMap_[i];

        record->slots.infallibleAppend(bit);

        hadOops |= bit;

    }

    if (!hadOops) {

        delete record;

        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());

}

void

BytecodeEmitter::getglobal(Symbol *sym)

{

    ensure(OP_GETGLOBAL_LENGTH);

    writeOp(OP_GETGLOBAL);

    writeUint32(addString(sym->name()));

    if (sym->type()->isTraceable())

        markOop(1);

}

void

BytecodeEmitter::setglobal(Symbol *sym)

{

    ensure(OP_SETGLOBAL_LENGTH);

    writeOp(OP_SETGLOBAL);

    writeUint32(addString(sym->name()));

    if (sym->type()->isTraceable())

        markOop(1);

}

void

BytecodeEmitter::getlocal(VariableSymbol *var)

{

    assert(var->storage() == VariableSymbol::Local);

    ensure(OP_GETLOCAL_LENGTH);

    writeOp(OP_GETLOCAL);

    writeUint32(var->slot());

    if (var->type()->isTraceable())

        markOop(1);

}

void

BytecodeEmitter::setlocal(VariableSymbol *var)

{

    assert(var->storage() == VariableSymbol::Local);

    ensure(OP_SETLOCAL_LENGTH);

    writeOp(OP_SETLOCAL);

    writeUint32(var->slot());

    if (var->type()->isTraceable())

        markOop(1);

}

void

BytecodeEmitter::getarg(VariableSymbol *var)

{

    assert(var->storage() == VariableSymbol::Arg);

    ensure(OP_GETARG_LENGTH);

    writeOp(OP_GETARG);

    writeUint32(var->slot());

    if (var->type()->isTraceable())

        markOop(1);

}

void

BytecodeEmitter::setarg(VariableSymbol *var)

{

    assert(var->storage() == VariableSymbol::Arg);

    ensure(OP_SETARG_LENGTH);

    writeOp(OP_SETARG);

    writeUint32(var->slot());

    if (var->type()->isTraceable())

        markOop(1);

}

bool

BytecodeEmitter::allocate(VariableSymbol *sym)

{

    assert(sym->isVariable());

    assert(sym->scope()->kind() == Scope::BLOCK);

    switch (sym->scope()->kind()) {

      case Scope::BLOCK:

      {

        // See overall comment on overflows.

        assert(locals_.length() < UINT_MAX);

        sym->allocate(VariableSymbol::Local, locals_.length());

        if (!locals_.append(sym))

            return false;

        break;

      }

      default:

        assert(false);

        return false;

    }

    return true;

}

void

BytecodeEmitter::newref(VariableSymbol *var)

{

    recordOops();

    if (var->storage() == VariableSymbol::Local) {

        ensure(OP_VARREF_LIFO_LENGTH);

        writeOp(OP_VARREF_LIFO);

    } else {

        assert(var->storage() == VariableSymbol::Arg);

        ensure(OP_ARGREF_LIFO_LENGTH);

        writeOp(OP_ARGREF_LIFO);

    }

    writeUint32(var->slot());

    markOop(1);

}

Code *

BytecodeEmitter::finish()

{

    stop();

    Zone *zone = ZONE();

    if (oom() || zone->hasPendingException())

        return NULL;

    Local<ByteArray> bytes(zone, ByteArray::New(zone, length(), Heap::Tenure_Old));

    if (!bytes)

        return NULL;

    memcpy(bytes->raw(), buffer(), length());

    Local<FixedArray> objects(zone, FixedArray::New(zone, objects_.length(), Heap::Tenure_Old));

    if (!objects)

        return NULL;

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

        objects->set(zone, i, objects_[i]);

    // If any stack slots hold gc pointers at potential failure points in the

    // bytecode, record them now. We do this by building a list of tuples;

    // each tuple contains the pc offset, and a bitset containing which stack

    // slots must be scanned by the gc.

    Local<ByteArray> safepoints(zone);

    if (oopRecords_.length()) {

        size_t bytesPerSafepoint = Code::BytesPerSafepoint(maxStackDepth());

        size_t gcmapSize = bytesPerSafepoint * oopRecords_.length();

        safepoints = ByteArray::New(zone, gcmapSize, Heap::Tenure_Old);

        if (!safepoints)

            return NULL;

        Address cursor = safepoints->raw();

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

            OopRecord *record = oopRecords_[i];

            assert(record->depth <= maxStackDepth());

            *reinterpret_cast<unsigned *>(cursor) = record->offset;

            unsigned char *bits = reinterpret_cast<unsigned char *>(cursor + sizeof(unsigned));

            for (unsigned i = 0; i < record->depth; i++)

                bits[i / 8] |= (1 << (i % 8));

            cursor += bytesPerSafepoint;

        }

        assert(cursor == safepoints->raw() + gcmapSize);

    }

    Local<ByteArray> sourcemap(zone);

    if (sourcemap_.length()) {

        sourcemap = ByteArray::New(zone, sourcemap_.length(), Heap::Tenure_Old);

        if (!sourcemap)

            return NULL;

        memcpy(sourcemap->raw(), sourcemap_.buffer(), sourcemap_.length());

    }

    Local<FixedArray> strings(zone, FixedArray::New(zone, strings_.stringCount(), Heap::Tenure_Old));

    if (!strings)

        return NULL;

    for (size_t i = 0; i < strings_.stringCount(); i++)

        strings->set(zone, i, strings_.stringAt(i));

    Local<FixedArray> locals(zone, FixedArray::New(zone, locals_.length(), Heap::Tenure_Old));

    if (!locals)

        return NULL;

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

        locals->set(zone, i, locals_[i]->type());

    Local<Code> code(zone);

    code = Code::New(zone,

                     bytes,

                     locals,

                     objects,

                     strings,

                     maxStackDepth(),

                     maxLoopDepth_,

                     safepoints,

                     sourcemap);

    return code;

}