/*

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

#include "Modules.h"

#include "Zone.h"

#include "Types.h"

using namespace jc;

#define PUSH_I32(top, value)    \

    do {                        \

        top.sp->i32 = value;    \

        top.sp++;               \

   } while (0)

#define PUSH_F(top, value)      \

    do {                        \

        top.sp->f = value;      \

        top.sp++;               \

   } while (0)

static inline int

POP_I32(Top &top)

{

    int value = top.sp[-1].i32;

    top.sp--;

    return value;

}

static inline float

POP_F(Top &top)

{

    float value = top.sp[-1].f;

    top.sp--;

    return value;

}

static inline bool

CheckDimensionSize(int size, unsigned width)

{

    if (size <= 0) {

        assert(false);

        return false;

    }

    // One  word, because we hide stuff below and need to add that in.

    if (unsigned(size) >= (INT_MAX / width) - sizeof(unsigned)) {

        assert(false);

        return false;

    }

    return true;

}

struct ArrayBuilder

{

    char *base;

    unsigned width;

    unsigned ndims;

    int *dims;

};

// Unlike the old SourcePawn VM, we do not allocate the final levels in one

// contiguous block. This might result in different cache behavior, but who

// knows. This algorithm is simpler and faster.

//

// In pawn, an array reference a[b][c]

//

//   (&a[b] + a[b])[c]

//

// That is, when hopping to the next array, the slot is relative to the

// current address, not absolute.

//

static unsigned

GenerateIndirectionVectors(const ArrayBuilder &builder, unsigned cursor, unsigned level)

{

    unsigned current = cursor;

    // Reserve space for this level.

    cursor += builder.dims[level] *

              ((level == builder.ndims - 1) ? builder.width : sizeof(unsigned));

    // If we're at the last level, we're done.

    if (level == builder.ndims - 1)

        return cursor;

    for (unsigned i = 0; i < unsigned(builder.dims[level]); i++) {

        // Hide the number of elements in the next vector, right behind it.

        *reinterpret_cast<unsigned *>(builder.base + cursor) = builder.dims[level + 1];

        cursor += sizeof(unsigned);

        // The next hop will be generated at |cursor|, which will be read from |current|.

        *reinterpret_cast<unsigned *>(builder.base + current) = cursor - current;

        cursor = GenerateIndirectionVectors(builder, cursor, level + 1);

        current += sizeof(unsigned);

    }

    return cursor;

}

UnsafeArray *

jc::AllocateUnsafeArray(unsigned width, unsigned ndims, int *dims)

{

    // Sanity check.

    if (!CheckDimensionSize(dims[ndims - 1], width))

        return NULL;

    // All innermost vectors must be this size.

    size_t nbytes = dims[ndims - 1] * width + sizeof(unsigned);

    if (ndims == 1) {

        // Fast path, no complicated indirection vectors.

        unsigned *ptr = (unsigned *)ZONE()->unsafeStack().allocate(nbytes);

        if (!ptr)

            return NULL;

        memset(ptr, 0, nbytes);

        *ptr = dims[0];

        UnsafeArray *array = reinterpret_cast<UnsafeArray *>(ptr + 1);

        return array;

    }

    // Add space from the innermost indrect array to the outermost. Each time,

    // we must also add space for the indirection slots.

    for (unsigned i = ndims - 2; i < ndims; i--) {

        if (!CheckDimensionSize(dims[ndims - 1], sizeof(unsigned) * 2))

            return NULL;

        if (!IsUint32MultiplySafe(nbytes, dims[i])) {

            assert(false);

            return NULL;

        }

        nbytes *= dims[i];

        // Add space for the indirection vectors at this level.

        if (!IsUint32AddSafe(nbytes, dims[i] * sizeof(unsigned) + sizeof(unsigned))) {

            assert(false);

            return NULL;

        }

        // Reserve space for each indirection vector.

        nbytes += dims[i] * sizeof(unsigned);

        // Reserve space for our own indirection vector.

        nbytes += sizeof(unsigned);

    }

    void *base = ZONE()->unsafeStack().allocate(nbytes);

    if (!base)

        return NULL;

    memset(base, 0, nbytes);

    ArrayBuilder array;

    array.base = (char *)base;

    array.dims = dims;

    array.ndims = ndims;

    array.width = width;

    unsigned cursor = 0;

    // Hide the length behind the array.

    *reinterpret_cast<unsigned *>(array.base + cursor) = dims[0];

    cursor += sizeof(unsigned);

    cursor = GenerateIndirectionVectors(array, cursor, 0);

    assert(cursor == nbytes);

    return reinterpret_cast<UnsafeArray *>(reinterpret_cast<unsigned *>(base) + 1);

}

bool

jc::Interpret(Frame *frame, LocalSlot *result)

{

    Top &top = *ZONE()->stack().top();

    LocalSlot *locals = frame->locals();

    for (;;) {

        Opcode op = Opcode(*top.pc);

        switch (op) {

case OP_NOP:

    break;

case OP_INT:

    PUSH_I32(top, READ_INT32(top.pc));

    break;

case OP_FLOAT:

    PUSH_F(top, READ_FLOAT(top.pc));

    break;

case OP_RETURN:

{

    *result = *--top.sp;

    if (!frame->prev())

        return true;

    frame = ZONE()->stack().popFrame(frame);

    locals = frame->locals();

    *top.sp++ = *result;

    top.pc += OpcodeInfo[*top.pc].length;

    continue;

}

#define RELATIONAL_JUMP(op)                 \

    {                                       \

        int right = POP_I32(top);           \

        int left = POP_I32(top);            \

        if (left op right) {                \

            top.pc += READ_INT32(top.pc);   \

            continue;                       \

        }                                   \

    }

case OP_JL:

    RELATIONAL_JUMP(<);

    break;

case OP_JLE:

    RELATIONAL_JUMP(<=);

    break;

case OP_JG:

    RELATIONAL_JUMP(>);

    break;

case OP_JGE:

    RELATIONAL_JUMP(>=);

    break;

case OP_JEQ:

    RELATIONAL_JUMP(==);

    break;

case OP_JNE:

    RELATIONAL_JUMP(!=);

    break;

case OP_JT:

{

    int value = POP_I32(top);

    if (value) {

        top.pc += READ_INT32(top.pc);

        continue;

    }

    break;

}

case OP_JF:

{

    int value = POP_I32(top);

    if (!value) {

        top.pc += READ_INT32(top.pc);

        continue;

    }

    break;

}

case OP_JUMP:

    top.pc += READ_INT32(top.pc);

    continue;

case OP_GETLOCAL:

{

    int slot = READ_INT32(top.pc);

    *top.sp++ = locals[slot];

    break;

}

case OP_SETLOCAL:

{

    int slot = READ_INT32(top.pc);

    locals[slot] = top.sp[-1];

    break;

}

case OP_ADD:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    int result = left + right;

    PUSH_I32(top, result);

    break;

}

case OP_SUB:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    int result = left - right;

    PUSH_I32(top, result);

    break;

}

case OP_MUL:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    int result = left * right;

   PUSH_I32(top, result);

    break;

}

case OP_DIV:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    if (!right)

        return false;

    int result = left / right;

    PUSH_I32(top, result);

    break;

}

case OP_ADD_F:

{

    float right = POP_F(top);

    float left = POP_F(top);

    float result = left + right;

    PUSH_F(top, result);

    break;

}

case OP_SUB_F:

{

    float right = POP_F(top);

    float left = POP_F(top);

    float result = left - right;

    PUSH_F(top, result);

    break;

}

case OP_MUL_F:

{

    float right = POP_F(top);

    float left = POP_F(top);

    float result = left * right;

    PUSH_F(top, result);

    break;

}

case OP_DIV_F:

{

    float right = POP_F(top);

    float left = POP_F(top);

    if (!right)

        return false;

    float result = left / right;

    PUSH_F(top, result);

    break;

}

case OP_POP:

    top.sp--;

    break;

case OP_STOP:

    assert(false);

    break;

case OP_CALLGLOBAL:

{

    unsigned argc = READ_UINT32(top.pc);

    unsigned index = READ_UINT32(top.pc + 4);

    Code *newCode = frame->code()->module()->getFunction(index);

    frame = ZONE()->stack().pushFrame(frame, newCode);

    assert(frame);

    assert(newCode->nargs() == argc);

    locals = frame->locals();

    continue;

}

case OP_GETARG:

{

    unsigned slot = READ_UINT32(top.pc);

    *top.sp++ = frame->arg(slot);

    break;

}

case OP_SETARG:

{

    unsigned slot = READ_UINT32(top.pc);

    frame->arg(slot) = *--top.sp;

    break;

}

case OP_STACKARRAY:

{

    unsigned width = top.pc[1];

    unsigned ndims = top.pc[2];

    UnsafeArray *ptr = AllocateUnsafeArray(width, ndims, reinterpret_cast<int *>(top.pc + 3));

    if (!ptr)

        return false;

    top.sp->unsafeArray = ptr;

    top.sp++;

    top.pc += 3 + ndims * sizeof(int);

    continue;

}

case OP_BOUNDS_STA:

{

    UnsafeArray *array = top.sp[-2].unsafeArray;

    int index = top.sp[-1].i32;

    if (index < 0 || unsigned(index) >= array->length())

        return false;

    break;

}

case OP_LD_STA_I:

{

    UnsafeArray *array = top.sp[-2].unsafeArray;

    int index = top.sp[-1].i32;

    top.sp[-2].i32 = array->readInt32(index);

    top.sp--;

    break;

}

case OP_ST_STA_I:

{

    UnsafeArray *array = top.sp[-3].unsafeArray;

    int index = top.sp[-2].i32;

    array->writeInt32(index, top.sp[-1].i32);

    top.sp[-3] = top.sp[-1];

    top.sp -= 2;

    break;

}

case OP_LD_STA_P:

{

    UnsafeArray *array = top.sp[-2].unsafeArray;

    int index = top.sp[-1].i32;

    top.sp[-2].unsafeArray = array->indirect(index);

    top.sp--;

    break;

}

case OP_CVT_I2F:

{

    int ival = POP_I32(top);

    float fval = (float)ival;

    PUSH_F(top, fval);

    break;

}

default:

    assert(false);

    return false;

        }

        top.pc += OpcodeInfo[op].length;

    }

    return true;

}