/*

 * 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_