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

  */

 #ifndef _include_jc_stack_h_

 #define _include_jc_stack_h_

 #include <stddef.h>

 #include "Utility.h"

 #include "Code.h"

 #include "Functions.h"

 #include "VirtualObjectVisitor.h"

 namespace ke {

 class Object;

 class Array;

 class Reference;

 class Frame;

 class Stack;

 class Zone;

 class Module;

 union LocalSlot

 {

     int i32;

     float f;

     Address address;

     Object *obj;

     Array *array;

     Reference *ref;

     Function *fun;

     Module *module;

 };

 struct Top

 {

     LocalSlot *sp;

     bytecode *pc;

     Frame *fp;

 };

 class Frame

 {

     friend class Stack;

     Frame *prev_;

     bytecode *prevpc_;

     union {

         Function *fun_;

         Native *native_;

         Object *callee_;

     };

     Code *code_;

     // Position of the LIFO stack at function entry.

     Address lifoPosition_;

     // Loop nesting level, for LIFO stack balancing. LIFO stack balancing

     // is not strictly required, but it helps to avoid unnecessary waste,

     // since once the LIFO stack is depleted, we must use the heap instead.

     unsigned loopDepth_;

   public:

     Frame(Frame *prev, bytecode *prevpc, Function *fun, Code *code, Address lifoPosition)

       : prev_(prev),

         prevpc_(prevpc),

         fun_(fun),

         code_(code),

         lifoPosition_(lifoPosition),

         loopDepth_(0)

     {

     }

     Frame(Frame *prev, bytecode *prevpc, Native *native, Address lifoPosition)

       : prev_(prev),

         prevpc_(prevpc),

         native_(native),

         code_(NULL),

         lifoPosition_(lifoPosition)

     {

     }

     Address *loopStack() {

         return reinterpret_cast<Address *>(this + 1);

     }

     LocalSlot *locals() {

         return reinterpret_cast<LocalSlot *>(loopStack() + code_->maxLoopDepth());

     }

     LocalSlot *stackBase() {

         return locals() + code_->nlocals();

     }

     Function *fun() const {

         assert(fun_ && callee_->is(MapKind_Function));

         return fun_;

     }

     Function *maybeFun() const {

         return (fun_ && callee_->is(MapKind_Function)) ? fun_ : NULL;

     }

     bool isNative() const {

         return callee_ && callee_->is(MapKind_Native);

     }

     Native *native() const {

         assert(isNative());

         return native_;

     }

     Code *code() const {

         assert(code_);

         return code_;

     }

     Frame *prev() const {

         return prev_;

     }

     bytecode *prevpc() const {

         return prevpc_;

     }

     Address lifoPosition() const {

         return lifoPosition_;

     }

     LocalSlot &arg(unsigned slot) {

         assert(slot < fun()->nargs());

         return *(reinterpret_cast<LocalSlot *>(this) - slot - 1);

     }

     void enterLoop(Zone *zone);

     void leaveLoop(Zone *zone);

     void accept(VirtualObjectVisitor *visitor);

 };

 // RAII object for calling a function from C++.

 class InvokeArgs

 {

     friend class Stack;

     Stack *stack_;

     LocalSlot *args_;

     unsigned nargs_;

   public:

     InvokeArgs()

       : stack_(NULL),

         args_(NULL),

         nargs_(0)

     {

     }

     ~InvokeArgs();

     LocalSlot &arg(unsigned index) {

         assert(index < nargs_);

         return args_[nargs_ - index - 1];

     }

 };

 // RAII object for calling a native from C++.

 class NativeArgs

 {

     friend class Stack;

     Stack *stack_;

     LocalSlot *argsBase_;

   public:

     NativeArgs()

       : stack_(NULL),

         argsBase_(NULL)

     {

     }

     ~NativeArgs();

     intptr_t *args() {

         return reinterpret_cast<intptr_t *>(argsBase_);

     }

 };

 class Stack

 {

     friend class InvokeArgs;

     friend class NativeArgs;

   private:

     static const size_t STACK_SIZE = 1024 * 1024;

   public:

     Stack(Zone *zone);

     ~Stack();

     bool initialize();

   public:

     Frame *pushInlineFrame(Handle<Function> fun);

     Frame *popInlineFrame();

     bool pushInvokeFrame(Handle<Function> fun, InvokeArgs &args);

     bool pushModuleFrame(Handle<Module> module, InvokeArgs &args);

     bool pushNativeFrame(Handle<Native> native, NativeArgs &args, unsigned argc);

     Top *top() {

         return &top_;

     }

     bool isInCallStack(Handle<Module> module);

     void accept(VirtualObjectVisitor *visitor);

   private:

     void popInvokeFrame(InvokeArgs &args);

     void popNativeFrame(NativeArgs &args);

   private:

     Zone *zone_;

     char *buffer_;

     char *end_;

     Top top_;

 };

 class StackIter

 {

     bytecode *pc_;

     Frame *fp_;

   public:

     StackIter(Zone *zone);

     bool done() const;

     const char *function() const;

     unsigned lineNumber() const;

     const char *source() const;

     void prev();

 };

 }

 #endif // _include_jc_stack_h_