/*

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

 namespace jc {

 union LocalSlot

 {

     int i32;

     float f;

     void *p;

     UnsafeArray *unsafeArray;

 };

 struct Top

 {

     LocalSlot *sp;

     bytecode *pc;

     Top(LocalSlot *sp, bytecode *pc)

       : sp(sp), pc(pc)

     {

     }

     Top(LocalSlot *sp)

       : sp(sp), pc(NULL)

     {

     }

 };

 class Frame

 {

     friend class Stack;

     Frame *prev_;

     bytecode *prevpc_;

     Code *code_;

     void *prevUnsafeStack_;

   public:

     Frame(Frame *prev, bytecode *prevpc, Code *code, void *prevUnsafeStack)

       : prev_(prev),

         prevpc_(prevpc),

         code_(code),

         prevUnsafeStack_(prevUnsafeStack)

     {

     }

     LocalSlot *locals() {

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

     }

     LocalSlot *stackBase() {

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

     }

     Code *code() const {

         return code_;

     }

     Frame *prev() const {

         return prev_;

     }

     bytecode *prevpc() const {

         return prevpc_;

     }

     void *prevUnsafeStack() const {

         return prevUnsafeStack_;

     }

     LocalSlot &arg(unsigned slot) {

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

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

     }

 };

 class Stack

 {

     char *buffer_;

     char *end_;

     Top *top_;

   private:

     static const size_t STACK_SIZE = 1024 * 1024;

   public:

     Stack();

     ~Stack();

     bool initialize();

   public:

     Frame *pushFrame(Frame *prev, Code *code);

     Frame *popFrame(Frame *frame);

     Top *top() {

         return top_;

     }

     void setTop(Top *top) {

         top_ = top;

     }

     Top begin() {

         return Top((LocalSlot *)buffer_);

     }

 };

 // The unsafe stack is designed for structures which interop unsafely with C++.

 // In this stack, buffers can be overrun, even inside the VM - but with two

 // caveats:

 //

 //  The unsafe stack cannot hold safe references.

 //  Indirect reads and writes from the unsafe stack cannot escape the unsafe

 //  stack.

 class UnsafeStack

 {

     char *buffer_;

     char *pos_;

     char *end_;

   private:

     static const size_t STACK_SIZE = 1024 * 1024;

   public:

     UnsafeStack();

     ~UnsafeStack();

     bool initialize();

   public:

     void *position() const {

         return pos_;

     }

     void *allocate(size_t nbytes) {

         nbytes = Align(nbytes, kMallocAlignment);

         if (pos_ + nbytes > end_) {

             assert(false);

             return NULL;

         }

         void *ptr = buffer_;

         pos_ += nbytes;

         return ptr;

     }

     void unwind(void *to) {

         char *p = (char *)to;

         assert(p < pos_ && p >= buffer_);

         pos_ = p;

     }

 };

 }

 #endif // _include_jc_stack_h_