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

 #include "Zone.h"

 #include "Strings.h"

 #include "Modules.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(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::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::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 fp_->native()->name()->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()->file()

            ? fp_->code()->module()->file()->chars()

            : "(anonymous)";

 }

 void

 StackIter::prev()

 {

     pc_ = fp_->prevpc();

     fp_ = fp_->prev();

 }