/* 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 <new>
#include <stdlib.h>
#include <string.h>
#include "Stack.h"
#include "Zone.h"
#include "Strings.h"
#include "Modules.h"
#include "NativeTable.h"
#include "Heap-inl.h"

using namespace ke;

Stack::Stack(Zone *zone)
  : zone_(zone),
    buffer_(NULL),
    end_(NULL)
{
}

Stack::~Stack()
{
    free(buffer_);
}

bool
Stack::initialize()
{
    buffer_ = (char *)malloc(STACK_SIZE);
    if (!buffer_)
        return false;

    top_.sp = reinterpret_cast<LocalSlot *>(buffer_);
    top_.pc = NULL;
    top_.fp = NULL;
    end_ = buffer_ + STACK_SIZE;
    return true;
}

InvokeArgs::~InvokeArgs()
{
    stack_->popInvokeFrame(*this);
}

NativeArgs::~NativeArgs()
{
    stack_->popNativeFrame(*this);
}

static inline size_t
SizeForCodeFrame(Code *code)
{
    return sizeof(Frame) + 
           sizeof(void *) * (code->maxLoopDepth()) +
           sizeof(LocalSlot) * (code->nlocals() + code->maxStackDepth());
}

bool
Stack::pushInvokeFrame(Handle<Function> fun, InvokeArgs &args)
{
    size_t nbytes = SizeForCodeFrame(fun->code()) +
                    sizeof(LocalSlot) * fun->nargs();
    if (reinterpret_cast<char *>(top_.sp) + nbytes >= end_) {
        assert(false);
        return false;
    }

    memset(top_.sp, 0, sizeof(LocalSlot) * fun->nargs());
    args.args_ = top_.sp;
    args.nargs_ = fun->nargs();
    args.stack_ = this;
    top_.sp += fun->nargs();
    
    Frame *frame = reinterpret_cast<Frame *>(top_.sp);
    new (frame) Frame(top_.fp, top_.pc, fun, fun->code(), zone_->heap().lifoPosition());
    
    top_.pc = frame->code()->start();
    top_.sp = frame->stackBase();
    top_.fp = frame;

    return true;
}

bool
Stack::pushModuleFrame(Handle<Module> module, InvokeArgs &args)
{
    size_t nbytes = SizeForCodeFrame(module->code());
    if (reinterpret_cast<char *>(top_.sp) + nbytes >= end_) {
        assert(false);
        return false;
    }

    args.args_ = top_.sp;
    args.nargs_ = 0;
    args.stack_ = this;
    
    Frame *frame = reinterpret_cast<Frame *>(top_.sp);
    new (frame) Frame(top_.fp, top_.pc, NULL, module->code(), zone_->heap().lifoPosition());
    
    top_.pc = frame->code()->start();
    top_.sp = frame->stackBase();
    top_.fp = frame;

    return true;
}

bool
Stack::pushNativeFrame(Handle<Native> native, NativeArgs &args, unsigned argc)
{
    size_t nbytes = sizeof(intptr_t) * argc + sizeof(Frame);
    if (reinterpret_cast<char *>(top_.sp) + nbytes >= end_) {
        assert(false);
        return false;
    }

    memset(top_.sp, 0, sizeof(intptr_t) * argc);
    args.argsBase_ = top_.sp;
    args.stack_ = this;
    top_.sp = reinterpret_cast<LocalSlot *>(reinterpret_cast<intptr_t *>(top_.sp) + argc);

    Frame *frame = reinterpret_cast<Frame *>(top_.sp);
    new (frame) Frame(top_.fp, top_.pc, native, zone_->heap().lifoPosition());

    top_.pc = NULL;
    top_.sp = reinterpret_cast<LocalSlot *>(frame + 1);
    top_.fp = frame;

    return true;
}

Frame *
Stack::pushInlineFrame(Handle<Function> fun)
{
    Code *code = fun->code();
    size_t nbytes = SizeForCodeFrame(code);
    if (reinterpret_cast<char *>(top_.sp) + nbytes >= end_) {
        zone_->reportError(Message_TooMuchRecursion);
        return NULL;
    }

    Frame *frame = reinterpret_cast<Frame *>(top_.sp);
    new (frame) Frame(top_.fp, top_.pc, fun, code, zone_->heap().lifoPosition());
    memset(frame->locals(), 0, sizeof(LocalSlot) * code->nlocals());

    top_.pc = frame->code()->start();
    top_.sp = frame->stackBase();
    top_.fp = frame;

    return frame;
}


Frame *
Stack::popInlineFrame()
{
    zone_->heap().unwindLifo(top_.fp->lifoPosition());

    Frame *prev = top_.fp->prev();
    Function *fun = top_.fp->fun();

    top_.pc = top_.fp->prevpc();
    top_.sp = reinterpret_cast<LocalSlot *>(top_.fp) - fun->nargs();
    top_.fp = prev;
    return prev;
}

void
Stack::popInvokeFrame(InvokeArgs &args)
{
    zone_->heap().unwindLifo(top_.fp->lifoPosition());

    top_.pc = top_.fp->prevpc();
    top_.sp = args.args_;
    top_.fp = top_.fp->prev();
}

void
Stack::popNativeFrame(NativeArgs &args)
{
    zone_->heap().unwindLifo(top_.fp->lifoPosition());

    top_.pc = top_.fp->prevpc();
    top_.sp = args.argsBase_;
    top_.fp = top_.fp->prev();
}

void
Frame::enterLoop(Zone *zone)
{
    assert(loopDepth_ < code_->maxLoopDepth());
    loopStack()[loopDepth_] = zone->heap().lifoPosition();
    loopDepth_++;
}

void
Frame::leaveLoop(Zone *zone)
{
    assert(loopDepth_ > 0);
    loopDepth_--;
    zone->heap().unwindLifo(loopStack()[loopDepth_]);
}

void
Frame::accept(VirtualObjectVisitor *visitor)
{
    visitor->visit(reinterpret_cast<Object **>(&callee_));
    visitor->visit(reinterpret_cast<Object **>(&code_));
}

static void
TraceFunctionFrame(VirtualObjectVisitor *visitor, Frame *fp, LocalSlot *sp, bytecode *pc)
{
    Code *code = fp->code();
    LocalSlot *slots = fp->locals();

    // Trace local variables.
    for (unsigned i = 0; i < code->nlocals(); i++) {
        Type *type = code->localType(i);
        if (type->isTraceable())
            visitor->visit(&slots[i].obj);
    }

    // Trace arguments, if a function call. Note that this means we usually
    // mark arguments twice, once on the caller side and once on the callee.
    // This makes it easier to deal with invoke frames which have no caller.
    if (Function *fun = fp->maybeFun()) {
        for (unsigned i = 0; i < fun->nargs(); i++) {
            Type *type = fun->argType(i);
            if (type->isTraceable())
                visitor->visit(&fp->arg(i).obj);
        }
    }

    // Finally, trace stack slots. Not every gc-point in the bytecode will
    // have a safepoint; since they are actually uncommon, we don't emit
    // them unless at least one stack slot would be marked.
    if (uint8 *safepoint = code->safepointAt(code->pcToOffset(pc))) {
        LocalSlot *base = fp->stackBase();
        unsigned stackDepth = unsigned(sp - fp->stackBase());
        assert(stackDepth <= code->maxStackDepth());

        for (unsigned i = 0; i < stackDepth; i++) {
            if (safepoint[i / 8] & (1 << (i % 8)))
                visitor->visit(&base[i].obj);
        }
    }
}

void
Stack::accept(VirtualObjectVisitor *visitor)
{
    LocalSlot *sp = top_.sp;
    bytecode *pc = top_.pc;

    for (Frame *frame = top_.fp; frame; frame = frame->prev()) {
        if (!frame->isNative())
            TraceFunctionFrame(visitor, frame, sp, pc);
        frame->accept(visitor);

        sp = reinterpret_cast<LocalSlot *>(frame);
        pc = frame->prevpc();
    }
}

bool
Stack::isInCallStack(Handle<Module> module)
{
    for (Frame *frame = top_.fp; frame; frame = frame->prev()) {
        if (frame->code()->module() == module)
            return true;
    }
    return false;
}

StackIter::StackIter(Zone *zone)
  : pc_(zone->stack().top()->pc),
    fp_(zone->stack().top()->fp)
{
}

bool
StackIter::done() const
{
    return !fp_;
}

const char *
StackIter::function() const
{
    if (fp_->isNative())
        return ZONE()->nativeTable()->name(fp_->native()->index())->chars();
    if (Function *fun = fp_->maybeFun())
        return fun->name()->chars();
    return "<toplevel>";
}

unsigned
StackIter::lineNumber() const
{
    if (fp_->isNative())
        return 0;
    if (fp_->maybeFun()) {
        unsigned offs = fp_->code()->pcToOffset(pc_);
        return fp_->code()->pcToSource(offs).line;
    }
    return fp_->code()->lineNumber();
}

const char *
StackIter::source() const
{
    if (fp_->isNative())
        return "<native>";
    return fp_->code()->module()->path()
           ? fp_->code()->module()->path()->chars()
           : "(anonymous)";
}

void
StackIter::prev()
{
    pc_ = fp_->prevpc();
    fp_ = fp_->prev();
}