/*

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

#include "Array.h"

#include "Reference.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

PushNewRef(Zone *zone, Top &top, void *location, Heap::Tenure tenure)

{

    Reference *ref = Reference::NewStack(zone, location, tenure);

    if (!ref)

        return false;

    top.sp->ref = ref;

    top.sp++;

    return true;

}

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;

}

// Generate an array with completely static sizes.

static Array *

GenerateArray(Zone *zone, ArrayMap *map)

{

    assert(map->type()->elements() != -1);

    // :TODO: use Local

    Array *array = Array::New(zone, map, map->type()->elements(), Heap::Tenure_Stack);

    if (!array)

        return NULL;

    if (map->type()->levels() == 1)

        return array;

    for (unsigned i = 0; i < unsigned(map->type()->elements()); i++) {

        Array *sub = GenerateArray(zone, map->contained());

        if (!sub)

            return NULL;

        array->writeObject(zone, i, sub);

    }

    return array;

}

static bool

CopyArray(Zone *zone, Array *source, Array *dest)

{

    assert(source->type()->levels() == 1);

    assert(dest->type()->levels() == 1);

    assert(source->type()->contained()->primitive() ==

           dest->type()->contained()->primitive());

    assert(source->nelements() >= dest->nelements());

    assert(dest->elementSize() == source->elementSize());

    memcpy(source->vec(), dest->vec(), dest->nelements() * dest->elementSize());

    return true;

}

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_SHL:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    int result = left << right;

    PUSH_I32(top, result);

    break;

}

case OP_SHR:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    int result = left >> right;

    PUSH_I32(top, result);

    break;

}

case OP_USHR:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    int result = unsigned(left) >> unsigned(right);

    PUSH_I32(top, result);

    break;

}

case OP_BITAND:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    int result = left & right;

    PUSH_I32(top, result);

    break;

}

case OP_BITOR:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    int result = left | right;

    PUSH_I32(top, result);

    break;

}

case OP_BITXOR:

{

    int right = POP_I32(top);

    int left = POP_I32(top);

    int result = left ^ right;

    PUSH_I32(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_BOUNDS:

{

    Array *array = top.sp[-2].array;

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

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

        return false;

    break;

}

case OP_GETARRAY_I:

{

    Array *array = top.sp[-2].array;

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

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

    top.sp--;

    break;

}

case OP_GETARRAY_F:

{

    Array *array = top.sp[-2].array;

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

    top.sp[-2].f = array->readFloat(index);

    top.sp--;

    break;

}

case OP_GETARRAY_C:

{

    Array *array = top.sp[-2].array;

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

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

    top.sp--;

    break;

}

case OP_SETARRAY_I:

{

    Array *array = top.sp[-3].array;

    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_SETARRAY_F:

{

    Array *array = top.sp[-3].array;

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

    array->writeFloat(index, top.sp[-1].f);

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

    top.sp -= 2;

    break;

}

case OP_SETARRAY_C:

{

    Array *array = top.sp[-3].array;

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

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

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

    top.sp -= 2;

    break;

}

case OP_GETARRAY_O:

{

    Array *array = top.sp[-2].array;

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

    top.sp[-2].array = Array::cast(array->readObject(index));

    top.sp--;

    break;

}

case OP_CVT_I2F:

{

    int ival = POP_I32(top);

    float fval = (float)ival;

    PUSH_F(top, fval);

    break;

}

case OP_NEWARRAY_LIFO:

{

    // :TODO: use Local

    ArrayMap *map = ArrayMap::cast(frame->code()->map(READ_UINT32(top.pc)));

    Array *array = GenerateArray(ZONE(), map);

    if (!array) {

        assert(false);

        return false;

    }

    top.sp->obj = array;

    top.sp++;

    break;

}

case OP_SAVELIFO:

{

    unsigned slot = READ_UINT32(top.pc);

    locals[slot].address = ZONE()->heap().lifoPosition();

    break;

}

case OP_UNWINDLIFO:

{

    unsigned slot = READ_UINT32(top.pc);

    ZONE()->heap().unwindLifo(locals[slot].address);

    break;

}

case OP_VARREF_LIFO:

{

    unsigned slot = READ_UINT32(top.pc);

    if (!PushNewRef(ZONE(), top, &locals[slot], Heap::Tenure_Stack)) {

        assert(false);

        return false;

    }

    break;

}

case OP_ARGREF_LIFO:

{

    unsigned slot = READ_UINT32(top.pc);

    if (!PushNewRef(ZONE(), top, &frame->arg(slot), Heap::Tenure_Stack)) {

        assert(false);

        return false;

    }

    break;

}

case OP_ARRAYREF_LIFO:

{

    Reference *ref = Reference::NewArray(ZONE(), top.sp[-2].array, top.sp[-1].i32, Heap::Tenure_Stack);

    if (!ref) {

        assert(false);

        return false;

    }

    top.sp[-2].ref = ref;

    top.sp--;

    break;

}

case OP_SLOTREF_LIFO:

{

    Reference *ref = Reference::NewStack(ZONE(), top.sp[-1], Heap::Tenure_Stack);

    if (!ref) {

        assert(false);

        return false;

    }

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

    break;

}

case OP_GETREF_I:

{

    top.sp[-1].i32 = top.sp[-1].ref->getInt();

    break;

}

case OP_SETREF_I:

{

    top.sp[-2].ref->setInt(top.sp[-1].i32);

    top.sp[-2].i32 = top.sp[-1].i32;

    top.sp--;

    break;

}

case OP_GETREF_F:

{

    top.sp[-1].f = top.sp[-1].ref->getFloat();

    break;

}

case OP_SETREF_F:

{

    top.sp[-2].ref->setFloat(top.sp[-1].f);

    top.sp[-2].f = top.sp[-1].f;

    break;

}

case OP_OBJECT:

{

    top.sp->obj = frame->code()->object(READ_UINT32(top.pc));

    top.sp++;

    break;

}

case OP_ARRAYCOPY:

{

    // Note for this assignment opcode, we return the left-hand side, not the

    // right, since in this case the result of the expression could be different.