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

 */

#include "Interpreter.h"

#include "Modules.h"

#include "Zone.h"

#include "Types.h"

#include "Array.h"

#include "Reference.h"

#include "Strings.h"

#include "Heap-inl.h"

using namespace ke;

#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;

}

// Generate an array with completely static sizes.

static Array *

GenerateArray(Zone *zone, Handle<ArrayMap> map)

{

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

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

    if (!array)

        return NULL;

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

        return array;

    Local<ArrayMap> contained(zone, map->contained());

    Local<Array> sub(zone);

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

        sub = GenerateArray(zone, 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;

}

static bool

InvokeNative(Zone *zone, Handle<Native> native, void *identity, LocalSlot *args, unsigned argc,

             int *result)

{

    NativeArgs guard;

    if (!zone->stack().pushNativeFrame(native, guard, argc + 1))

        return false;

    intptr_t *cells = guard.args();

    // params[0] == argc, in ISPE

    cells[0] = argc;

    // Pass the formal arguments.

    Local<Type> type(zone, native->type());

    Local<Type> param(zone);

    for (unsigned i = 0; i < type->parameters()->length(); i++) {

        param = type->parameterAt(i);

        // For floats, we rely on the aliasing of |i32| and |f|.

        LocalSlot &arg = args[-int(i) - 1];

        if (param->isInt32() || param->isFloat()) {

            cells[i + 1] = arg.i32;

        } else if (param->isReference()) {

            cells[i + 1] = reinterpret_cast<intptr_t>(arg.ref->location());

        } else {

            assert(param->isArray());

            cells[i + 1] = reinterpret_cast<intptr_t>(arg.array->vec());

        }

    }

    // For variadic arguments, the compiler left either arrays or references.

    for (unsigned i = type->parameters()->length(); i < argc; i++) {

        LocalSlot &arg = args[-int(i) - 1];

        if (arg.obj->is(MapKind_Reference)) {

            cells[i + 1] = reinterpret_cast<intptr_t>(arg.ref->location());

        } else {

            assert(arg.obj->is(MapKind_Array));

            cells[i + 1] = reinterpret_cast<intptr_t>(arg.array->vec());

        }

    }

    typedef intptr_t (*INVOKE)(void *, intptr_t *);

    INVOKE invoke = (INVOKE)native->function();

    *result = invoke(identity, cells);

    return !zone->hasPendingException();

}

bool

ke::Interpret(Zone *zone, Frame *entryFrame, LocalSlot *result)

{

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

    if (!entryFrame)

        entryFrame = top.fp;

    LocalSlot *locals = entryFrame->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:

case OP_RETURNVOID:

case OP_STOP:

{

    if (op == OP_RETURN)

        *result = *--top.sp;

    if (top.fp == entryFrame)

        goto done;

    // This must not GC.

    zone->stack().popInlineFrame();

    locals = top.fp->locals();

    if (op == OP_RETURN)

        *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) {

        zone->reportError(Message_IntegerDivideByZero);

        goto error;

    }

    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);

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

{

    zone->heap().reclaim();

    Local<Function> newFun(zone, top.sp[-1].fun);

    top.sp--;

    if (!zone->stack().pushInlineFrame(newFun))

        goto error;

    locals = top.fp->locals();

    continue;

}

case OP_GETARG:

{

    unsigned slot = READ_UINT32(top.pc);

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

    break;

}

case OP_SETARG:

{

    unsigned slot = READ_UINT32(top.pc);

    top.fp->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()) {

        zone->reportError(Message_ArrayIndexOutOfBounds, index, array->nelements());

        goto error;

    }

    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:

{

    Local<ArrayMap> map(zone, ArrayMap::cast(top.fp->code()->map(READ_UINT32(top.pc))));

    Array *array = GenerateArray(zone, map);

    if (!array)

        goto error;

    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))

        goto error;

    break;

}

case OP_ARGREF_LIFO:

{

    unsigned slot = READ_UINT32(top.pc);

    if (!PushNewRef(zone, top, &top.fp->arg(slot), Heap::Tenure_Stack))

        goto error;

    break;

}

case OP_ARRAYREF_LIFO:

{

    Local<Array> array(zone, top.sp[-2].array);

    Local<Reference> ref(zone, Reference::NewArray(zone, array, top.sp[-1].i32, Heap::Tenure_Stack));