/*

  * 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_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_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_GETARRAY_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_GETARRAY_F:

 {

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

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

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

     top.sp--;

     break;

 }

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

 {

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

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

 }