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

 #include "Interpreter.h"

 #include "Modules.h"

 #include "Zone.h"

 #include "Types.h"

 #include "Array.h"

 #include "Reference.h"

 #include "Strings.h"

 #include "Environments.h"

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

 }

 // Pawn's original semantics specify some kind of floor operation, so

 // (8 / -3 == -3) and (-8 / 3 == -1). The SourcePawn 1 compiler (spcomp) uses

 // the upstream algorithm when constant folding. However the SourcePawn 1 JIT

 // does not. My guess is that Borja freaked out seeing the 13-instruction x86

 // sequence necessary to get this functionality (I vaguely recall a thread

 // where we discussed this with Mark Peter? But the ITB forums are gone...),

 // and we just decided to break the damn thing. So SP1 was inconsistent, but

 // we are not. And for completeness, we assert that the C compiler does the

 // right thing, since C89 leaves it unspecified.

 STATIC_ASSERT(8 / -3 == -2);

 STATIC_ASSERT(-8 / 3 == -2);

 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 bool CopyStruct(Zone *zone, Handle<Struct> left, Handle<Struct> right);

 static bool

 ChangeArrayLength(Zone *zone, Handle<Array> source, Handle<Array> dest)

 {

     return true;

 }

 // Even though this function can fail, we immediately bail out, so it doesn't

 // matter if we've leaving things unrooted.

 static bool

 CopyArray(Zone *zone, Handle<Array> dest, Handle<Array> source)

 {

     if (source->length() != dest->length()) {

         if (!ChangeArrayLength(zone, source, dest))

             return false;

     }

     Local<Type> contained(zone, source->type()->contained());

     if (contained->isArray() && contained->isFixedLength()) {

         assert(dest->type()->contained()->isArray());

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

         Local<Array> left(zone);

         Local<Array> right(zone);

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

             left = Array::cast(dest->readObject(i));

             right = Array::cast(source->readObject(i));

             if (!CopyArray(zone, left, right))

                 return false;

         }

         return true;

     }

     if (contained->isStruct()) {

         assert(dest->type()->contained() == contained);

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

         Local<Struct> left(zone);

         Local<Struct> right(zone);

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

             left = Struct::cast(dest->readObject(i));

             right = Struct::cast(source->readObject(i));

             if (!CopyStruct(zone, left, right))

                 return false;

         }

         return true;

     }

     if (contained->isTraceable()) {

         for (unsigned i = 0; i < source->length(); i++)

             dest->writeObject(zone, i, source->readObject(i));

         return true;

     }

     assert(contained->pod() == dest->type()->contained()->pod());

     assert(contained->pod() == PrimitiveType_Char

            ? source->length() <= dest->length()

            : source->length() == dest->length());

     assert(dest->length());

     memcpy(dest->bytes(), source->bytes(), source->length() * Array::SizeForElement(dest->type()));

     return true;

 }

 static void

 GetElement(Array *array, int index, LocalSlot *vp)

 {

     if (array->type()->contained()->isTraceable()) {

         vp->obj = array->readObject(index);

         return;

     }

     switch (array->type()->contained()->pod()) {

       case PrimitiveType_Float:

         vp->f = array->readFloat(index);

         break;

       case PrimitiveType_Char:

         vp->i32 = array->readChar(index);

         break;

       default:

         assert(array->type()->contained()->pod() == PrimitiveType_Int32);

         vp->i32 = array->readInt32(index);

         break;

     }

 }

 static void

 SetElement(Zone *zone, Array *array, int index, const LocalSlot &v)

 {

     if (array->type()->contained()->isTraceable()) {

         array->writeObject(zone, index, v.obj);

         return;

     }

     switch (array->type()->contained()->pod()) {

       case PrimitiveType_Float:

         array->writeFloat(index, v.f);

         break;

       case PrimitiveType_Char:

         array->writeChar(index, v.i32);

         break;

       default:

         assert(array->type()->contained()->pod() == PrimitiveType_Int32);

         array->writeInt32(index, v.i32);

         break;

     }

 }

 static void

 GetField(Struct *obj, Descriptor *desc, LocalSlot *vp)

 {

     // :TODO: assert no GC.

     if (desc->type()->isTraceable()) {

         vp->obj = obj->get<Object *>(desc);

         return;

     }

     switch (desc->type()->pod()) {

       case PrimitiveType_Float:

         vp->f = obj->get<float>(desc);

         break;

       default:

         assert(desc->type()->pod() == PrimitiveType_Int32);

         vp->i32 = obj->get<int>(desc);

         break;

     }

 }

 static void

 GetField(Struct *obj, unsigned index, LocalSlot *vp)

 {

     Descriptor *desc = Descriptor::cast(obj->map()->type()->fields()->at(index));

     GetField(obj, desc, vp);

 }

 static void

 SetField(Zone *zone, Struct *obj, Descriptor *desc, const LocalSlot &v)

 {

     // :TODO: assert no GC.

     if (desc->type()->isTraceable()) {

         obj->set(zone, desc, v.obj);

         return;

     }

     switch (desc->type()->pod()) {

       case PrimitiveType_Float:

         obj->set<float>(desc, v.f);

         break;

       default:

         assert(desc->type()->pod() == PrimitiveType_Int32);

         obj->set<int>(desc, v.i32);

         break;

     }

 }

 static void

 SetField(Zone *zone, Struct *obj, unsigned index, const LocalSlot &v)

 {

     Descriptor *desc = Descriptor::cast(obj->map()->type()->fields()->at(index));

     SetField(zone, obj, desc, v);

 }

 // Even though this function can fail, we immediately bail out, so it doesn't

 // matter if we've leaving things unrooted.

 static bool

 CopyStruct(Zone *zone, Handle<Struct> left, Handle<Struct> right)

 {

     assert(left->map()->type() == right->map()->type());

     Local<Type> type(zone, left->map()->type());

     Local<Struct> leftStruct(zone);

     Local<Struct> rightStruct(zone);

     Local<Array> leftArray(zone);

     Local<Array> rightArray(zone);

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

         Descriptor *desc = Descriptor::cast(type->fields()->at(i));

         LocalSlot rval;

         GetField(right, desc, &rval);

         // If the field is a struct, we need to deep-copy.

         if (desc->type()->isStruct()) {

             LocalSlot lval;

             GetField(left, desc, &lval);

             leftStruct = Struct::cast(lval.obj);

             rightStruct = Struct::cast(rval.obj);

             if (!CopyStruct(zone, leftStruct, rightStruct))

                 return false;

         } else if (desc->type()->isArray()) {

             LocalSlot lval;

             GetField(left, desc, &lval);

             leftArray = Array::cast(lval.obj);

             rightArray = Array::cast(rval.obj);

             if (!CopyArray(zone, leftArray, rightArray))

                 return false;

         } else {

             SetField(zone, left, desc, rval);

         }

     }

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

         }

     }

     // 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->bytes());

         }

     }

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

         if (OpcodeInfo[op].nuses > 0)

             assert(top.sp - OpcodeInfo[op].nuses >= top.fp->stackBase());

         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;

 }

 case OP_POP:

 {

     top.sp--;

     break;

 }

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

 #undef RELATIONAL_JUMP

 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;

 }

 #define RELATIONAL_JUMP_F(op)               \

     {                                       \

         float right = POP_F(top);           \

         float left = POP_F(top);            \

         if (left op right) {                \

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

             continue;                       \

         }                                   \

     }

 case OP_JL_F:

     RELATIONAL_JUMP_F(<);

     break;

 case OP_JLE_F:

     RELATIONAL_JUMP_F(<=);

     break;

 case OP_JG_F:

     RELATIONAL_JUMP_F(>);

     break;

 case OP_JGE_F:

     RELATIONAL_JUMP_F(>=);

     break;

 case OP_JEQ_F:

     RELATIONAL_JUMP_F(==);

     break;

 case OP_JNE_F:

     RELATIONAL_JUMP_F(!=);

     break;

 case OP_JT_F:

 {

     float value = POP_F(top);

     if (value) {

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

         continue;

     }

     break;

 }

 case OP_JF_F:

 {

     float value = POP_F(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:

 {

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

     top.sp--;

     break;

 }

 case OP_SUB:

 {

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

     top.sp--;

     break;

 }

 case OP_MUL:

 {

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

     top.sp--;

     break;

 }

 case OP_DIV:

 {

     if (top.sp[-1].i32 == 0) {

         zone->reportError(Message_IntegerDivideByZero);

         goto error;

     }

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

     top.sp--;

     break;

 }

 case OP_MOD:

 {

     if (top.sp[-1].i32 == 0) {

         zone->reportError(Message_IntegerDivideByZero);

         goto error;

     }

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

     top.sp--;

     break;

 }

 case OP_LT:

 {

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

     top.sp--;

     break;

 }

 case OP_LE:

 {

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

     top.sp--;

     break;

 }

 case OP_GT:

 {

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

     top.sp--;

     break;

 }

 case OP_GE:

 {

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

     top.sp--;

     break;

 }

 case OP_EQ:

 {

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

     top.sp--;

     break;

 }

 case OP_NE:

 {

     top.sp[-2].i32 = (top.sp[-2].i32 != top.sp[-1].i32);

     top.sp--;

     break;

 }

 case OP_ADD_F:

 {

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

     top.sp--;

     break;

 }

 case OP_SUB_F:

 {

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

     top.sp--;

     break;

 }

 case OP_MUL_F:

 {

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

     top.sp--;

     break;

 }

 case OP_DIV_F:

 {

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

     top.sp--;

     break;

 }

 case OP_LT_F:

 {

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

     top.sp--;

     break;

 }

 case OP_LE_F:

 {

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

     top.sp--;

     break;

 }

 case OP_GT_F:

 {

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

     top.sp--;

     break;

 }

 case OP_GE_F:

 {

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

     top.sp--;

     break;

 }

 case OP_EQ_F:

 {

     top.sp[-2].i32 = (top.sp[-2].f == top.sp[-1].f);

     top.sp--;

     break;

 }

 case OP_NE_F:

 {

     top.sp[-2].i32 = (top.sp[-2].f != top.sp[-1].f);

     top.sp--;

     break;

 }

 case OP_SHL:

 {

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

     top.sp--;

     break;

 }

 case OP_SHR:

 {

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

     top.sp--;

     break;

 }

 case OP_USHR:

 {

     top.sp[-2].i32 = unsigned(top.sp[-2].i32) << unsigned(top.sp[-1].i32);

     top.sp--;

     break;

 }

 case OP_BITAND:

 {

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

     top.sp--;

     break;

 }

 case OP_BITOR:

 {

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

     top.sp--;

     break;

 }

 case OP_BITXOR:

 {

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

     top.sp--;

     break;

 }

 case OP_BITNOT:

 {

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

     break;

 }

 case OP_NOT:

 {

     top.sp[-1].i32 = top.sp[-1].i32 ? 0 : 1;

     break;

 }

 case OP_NOT_F:

 {

     top.sp[-1].i32 = top.sp[-1].f ? 0 : 1;

     break;

 }

 case OP_NEG:

 {

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

     break;

 }

 case OP_NEG_F:

 {

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

     break;

 }

 case OP_CALL:

 {

     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[-1];

     break;

 }

 case OP_GETELEM:

 {

     Array *array = Array::cast(top.sp[-2].obj);

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

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

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

         goto error;

     }

     GetElement(array, index, &top.sp[-2]);

     top.sp--;

     break;

 }

 case OP_SETELEM:

 {

     Array *array = Array::cast(top.sp[-3].obj);

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

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

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

         goto error;

     }

     SetElement(zone, array, index, top.sp[-1]);

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

     top.sp -= 2;

     break;

 }

 case OP_CVT_I2F:

 {

     int ival = POP_I32(top);

     float fval = (float)ival;

     PUSH_F(top, fval);

     break;

 }

 case OP_NEWFIXED:

 {

     Heap::Tenure tenure = (Heap::Tenure)top.pc[1];

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

     Array *array = Array::NewFixed(zone, map, tenure);

     if (!array)

         goto error;

     top.sp->obj = array;

     top.sp++;

     break;

 }

 case OP_NEWEMPTY:

 {

     Heap::Tenure tenure = (Heap::Tenure)top.pc[1];

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

     Array *array = Array::NewEmpty(zone, map, tenure);

     if (!array)

         goto error;

     top.sp->obj = array;

     top.sp++;

     break;

 }

 case OP_NEWSIZED:

 {

     Heap::Tenure tenure = (Heap::Tenure)top.pc[1];

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

     assert(map->type()->levels() < MAX_ARRAY_DEPTH);

     int dims[MAX_ARRAY_DEPTH];

     for (unsigned i = map->type()->levels() - 1; i < map->type()->levels(); i--)

         dims[i] = POP_I32(top);