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

#define _include_bytecode_emitter_h_

#include <assert.h>

#include <limits.h>

#include "Opcodes.h"

#include "NameBinding.h"

#include "Handles.h"

namespace ke {

class Type;

class Map;

typedef PoolList<ScopedRoot<Object>> ObjectList;

struct OopRecord : public PoolObject

{

    unsigned depth;

    unsigned offset;

    bool *slots;

    OopRecord(unsigned length, unsigned offset)

      : depth(length),

        offset(offset),

        slots(NULL)

    {

    }

};

class BytecodeEmitter

{

  private:

    PoolAllocator &pool_;

    bytecode *buffer_;

    bytecode *buffer_pos_;

    bytecode *buffer_end_;

    bytecode inline_buffer_[512];

    bool oom_;

    unsigned maxStackDepth_;

    ObjectList objects_;

    PoolList<bool> oopMap_;

    PoolList<OopRecord *> oopRecords_;

  private:

    // The maximum size of a code object must be such that the distance between

    // two instructions fits into a signed, 31-bit integer. This ensures that

    // all code-bounded buffers (like the number of object literals or

    // safepoints) does not need to be bounds checked. It also means we can add

    // any two offsets and be guaranteed that they don't overflow.

    static const size_t MAX_LENGTH = INT_MAX / 2;

  private:

    bool growBuffer(size_t bytes);

    // Checking the return value is not necessary, since the inline buffer is

    // used as a ballast.

    bool ensure(size_t bytes) {

        if (buffer_pos_ + bytes > buffer_end_)

            return growBuffer(bytes);

        return true;

    }

    void writeUint8(unsigned value) {

        assert(value <= UCHAR_MAX);

        *buffer_pos_++ = value;

    }

    void writeFloat(float value) {

        *(float *)buffer_pos_ = value;

        buffer_pos_ += sizeof(float);

    }

    void writeInt32(int value) {

        *(int *)buffer_pos_ = value;

        buffer_pos_ += sizeof(int);

    }

    void writeUint32(unsigned value) {

        *(unsigned *)buffer_pos_ = value;

        buffer_pos_ += sizeof(unsigned);

    }

    void writeOp(Opcode op) {

        if (oom_)

            return;

        writeUint8(op);

        for (int i = 0; i < OpcodeInfo[op].nuses; i++)

            oopMap_.pop();

        for (int i = 0; i < OpcodeInfo[op].ndefs; i++)

            oopMap_.append(false);

        if (oopMap_.length() > maxStackDepth_)

            maxStackDepth_ = oopMap_.length();

    }

    void writeObject(Object *obj) {

        writeUint32(objects_.length());

        ScopedRoot<Object> root(obj);

        if (!root)

            oom_ = true;

        oom_ &= objects_.append(root);

    }

    int position() const {

        assert(buffer_pos_ - buffer_ < INT_MAX / 2);

        return int(buffer_pos_ - buffer_);

    }

  public:

    BytecodeEmitter(PoolAllocator &pool);

    bytecode *buffer() const {

        return buffer_;

    }

    unsigned length() const {

        return unsigned(buffer_pos_ - buffer_);

    }

    bool oom() const {

        return oom_;

    }

    unsigned stackDepth() const {

        return oopMap_.length();

    }

    unsigned maxStackDepth() const {

        return maxStackDepth_;

    }

    const ObjectList *objects() const {

        return &objects_;

    }

    PoolList<OopRecord *> *oopRecords() {

        return &oopRecords_;

    }

    void drop(unsigned amt) {

        assert(amt <= stackDepth());

        for (unsigned i = 0; i < amt; i++)

            oopMap_.pop();

    }

  public:

    // A label represents a local control-flow target in the bytecode. A label

    // may be in three states:

    //

    // (1) Empty - the label is not used yet.

    // (2) Pending - the label has incoming jumps, but the actual location of

    //               is not yet known. The list of jumps is threaded through

    //               the four bytes reserved for each emitted jump target. In

    //               this case, the offset field is the location of the most

    //               recently emitted incoming jump.

    // (3) Bound   - the label's position has been pinned.

    //

    // A jump can be emitted to a label in any state. Binding a label

    // immediately backpatches all pending incoming jumps. A label must be

    // bound if it is used.

    class Label

    {

        int offset_ : 31;

        bool bound_ : 1;

        void setOffset(int offset) {

            offset_ = offset;

            assert(offset_ == offset);

        }

      public:

        static const int INVALID_OFFSET = -1;

      public:

        Label()

          : offset_(INVALID_OFFSET),

            bound_(false)

        {

        }

        ~Label()

        {

            assert(bound_ || offset_ == INVALID_OFFSET);

        }

        bool bound() const {

            return bound_;

        }

        int offset() const {

            return offset_;

        }

        void bind(int offset) {

            assert(!bound_);

            setOffset(offset);

            bound_ = true;

        }

        int link(int offset) {

            assert(!bound_);

            int old = offset_;

            setOffset(offset);

            return old;

        }

    };

  private:

    int patchJumpAt(int at, int to) {

        assert(at >= 0 && at < position());

        int old = *(int *)(buffer_ + at + 1);

        *(int *)(buffer_ + at + 1) = (to - at);

        return old;

    }

    void singleByteOp(Opcode op) {

        assert(OpcodeInfo[op].length == 1);

        ensure(OpcodeInfo[op].length);

        writeOp(op);

    }

    // Mark a stack slot as having an object pointer.

    void markOop(unsigned depth, bool oop = true) {

        if (oom_)

            return;

        oopMap_[oopMap_.length() - depth] = oop;

    }

    bool getOop(unsigned depth) {

        if (oom_)

            return false;

        return oopMap_[oopMap_.length() - depth];

    }

    // Mark the current bytecode position as either re-entrant (meaning, it

    // can leave the interpreter or call to another function), or causing GC.

    // This will record which stack slots have objects and associate that

    // information with the current pc.

    void recordOops();

  public:

    void int_(int value) {

        ensure(OP_INT);

        writeOp(OP_INT);

        writeInt32(value);

    }

    void return_() {

        ensure(OP_RETURN);

        writeOp(OP_RETURN);

    }

    void getlocal(Variable *var) {

        ensure(OP_GETLOCAL_LENGTH);

        writeOp(OP_GETLOCAL);

        writeUint32(var->slot());

        if (var->type()->isTraceable())

            markOop(1);

    }

    void setlocal(Variable *var) {

        ensure(OP_SETLOCAL_LENGTH);

        writeOp(OP_SETLOCAL);

        writeUint32(var->slot());

        if (var->type()->isTraceable())

            markOop(1);

    }

    void getarg(Variable *var) {

        ensure(OP_GETARG_LENGTH);

        writeOp(OP_GETARG);

        writeUint32(var->slot());

        if (var->type()->isTraceable())

            markOop(1);

    }

    void setarg(Variable *var) {

        ensure(OP_SETARG_LENGTH);

        writeOp(OP_SETARG);

        writeUint32(var->slot());

        if (var->type()->isTraceable())

            markOop(1);

    }

    void j(Opcode op, Label *label) {

        // Since jumps can skip around the stream, do not try to do anything

        // in a potentially truncated state.

        if (oom())

            return;

        assert(op >= OP_JL && op <= OP_JUMP);

        ensure(OP_JUMP_LENGTH);

        if (label->bound()) {

            // We can immediately emit this jump.

            int distance = label->offset() - position();

            writeOp(op);

            writeInt32(distance);

        } else {

            // We can't emit this jump yet. Add a placeholder.

            int old = label->link(position());

            writeOp(op);

            writeInt32(old);

        }

    }

    void bind(Label *label) {

        if (oom())

            return;

        assert(!label->bound());

        int offset = label->offset();

        while (offset != Label::INVALID_OFFSET)

            offset = patchJumpAt(offset, position());

        label->bind(position());

    }

    void jump(Label *label) {

        j(OP_JUMP, label);

    }

    void binary(Opcode op) {

        singleByteOp(op);

    }

    void pop() {

        singleByteOp(OP_POP);

    }

    void stop() {

        singleByteOp(OP_STOP);

    }

    void callglobal(unsigned index) {

        recordOops();

        ensure(OP_CALLGLOBAL_LENGTH);

        writeOp(OP_CALLGLOBAL);

        writeUint32(index);

    }

    void getarray(PrimitiveType type) {

        switch (type) {

          case PrimitiveType_Float:

            singleByteOp(OP_GETARRAY_F);

            break;

          case PrimitiveType_Int32:

            singleByteOp(OP_GETARRAY_I);

            break;

          default:

            assert(type == PrimitiveType_Char);

            singleByteOp(OP_GETARRAY_C);

            break;

        }

    }

    void setarray(PrimitiveType type) {

        switch (type) {

          case PrimitiveType_Float:

            singleByteOp(OP_SETARRAY_F);

            break;

          case PrimitiveType_Int32:

            singleByteOp(OP_SETARRAY_I);

            break;

          default:

            assert(type == PrimitiveType_Char);

            singleByteOp(OP_SETARRAY_C);

            break;

        }

    }

    void getarray_o() {

        singleByteOp(OP_GETARRAY_O);

        markOop(1);

    }

    void bounds() {

        singleByteOp(OP_BOUNDS);

        markOop(2);

    }

    void float_(float value) {

        ensure(OP_FLOAT_LENGTH);

        writeOp(OP_FLOAT);

        writeFloat(value);

    }

    void cvt_i2f() {

        singleByteOp(OP_CVT_I2F);

    }

    void newarray_lifo(Handle<Map> map) {

        recordOops();

        ensure(OP_NEWARRAY_LIFO_LENGTH);

        writeOp(OP_NEWARRAY_LIFO);

        writeObject(map);

        markOop(1);

    }

    void savelifo(unsigned slot) {

        ensure(OP_SAVELIFO_LENGTH);

        writeOp(OP_SAVELIFO);

        writeUint32(slot);

    }

    void unwindlifo(unsigned slot) {

        ensure(OP_UNWINDLIFO_LENGTH);

        writeOp(OP_UNWINDLIFO);

        writeUint32(slot);

    }

    void newref(Variable *var) {

        recordOops();

        if (var->location() == Variable::STACK) {

            ensure(OP_VARREF_LIFO_LENGTH);

            writeOp(OP_VARREF_LIFO);

        } else {

            assert(var->location() == Variable::PARAMETER);

            ensure(OP_ARGREF_LIFO_LENGTH);

            writeOp(OP_ARGREF_LIFO);

        }

        writeUint32(var->slot());

        markOop(1);

    }

    void slotref_lifo() {

        recordOops();

        singleByteOp(OP_SLOTREF_LIFO);

        markOop(1);

    }

    void arrayref_lifo() {

        recordOops();

        singleByteOp(OP_ARRAYREF_LIFO);

        markOop(1);

    }

    void getref(PrimitiveType type) {

        if (type == PrimitiveType_Int32) {

            singleByteOp(OP_GETREF_I);

        } else {

            assert(type == PrimitiveType_Float);

            singleByteOp(OP_GETREF_F);

        }

    }

    void setref(PrimitiveType type) {

        if (type == PrimitiveType_Int32) {

            singleByteOp(OP_SETREF_I);

        } else {

            assert(type == PrimitiveType_Float);

            singleByteOp(OP_SETREF_F);

        }

    }

    void object(Handle<Object> obj) {

        ensure(OP_OBJECT_LENGTH);

        writeOp(OP_OBJECT);

        writeObject(obj);

        markOop(1);

    }

    void arraycopy() {

        singleByteOp(OP_ARRAYCOPY);

        markOop(1);

    }

    void dup() {

        bool oop = getOop(1);

        singleByteOp(OP_DUP);

        markOop(1, oop);

    }

    void dup2() {

        bool oop2 = getOop(2);

        bool oop1 = getOop(1);

        singleByteOp(OP_DUP2);

        markOop(2, oop2);

        markOop(1, oop1);

    }

    void swap() {

        bool oop2 = getOop(2);

        bool oop1 = getOop(1);

        singleByteOp(OP_SWAP);

        markOop(2, oop1);

        markOop(1, oop2);

    }

    void roll3() {

        bool oop3 = getOop(3);

        bool oop2 = getOop(2);

        bool oop1 = getOop(1);

        singleByteOp(OP_ROLL3);

        markOop(3, oop2);

        markOop(2, oop1);

        markOop(1, oop3);

    }

    void pick2() {

        bool oop2 = getOop(2);

        bool oop1 = getOop(1);

        singleByteOp(OP_PICK2);

        markOop(3, oop2);

        markOop(2, oop1);

        markOop(1, oop2);

    }

    void pick3() {

        bool oop3 = getOop(3);

        bool oop2 = getOop(2);

        bool oop1 = getOop(1);

        singleByteOp(OP_PICK3);

        markOop(4, oop3);

        markOop(3, oop2);

        markOop(2, oop1);

        markOop(1, oop3);

    }

    // Helpers.

    void get(Variable *var) {

        if (var->location() == Variable::STACK) {

            getlocal(var);

        } else {

            assert(var->location() == Variable::PARAMETER);

            getarg(var);

        }

    }

    void set(Variable *var) {

        assert(!var->type()->isReference());

        if (var->location() == Variable::STACK) {

            setlocal(var);

        } else {

            assert(var->location() == Variable::PARAMETER);

            setarg(var);

        }

    }

};

}

#endif // _include_bytecode_emitter_h_