// vim: set ts=8 sts=2 sw=2 tw=99 et:

//

// This file is part of SourcePawn.

// 

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

// 

// SourcePawn 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 SourcePawn.  If not, see <http://www.gnu.org/licenses/>.

#include <limits.h>

#include <string.h>

#include "interpreter.h"

#include "opcodes.h"

#include "watchdog_timer.h"

#define STACK_MARGIN 64

using namespace SourcePawn;

static inline bool

IsValidOffset(uint32_t cip)

{

  return cip % 4 == 0;

}

static inline cell_t

Read(const sp_plugin_t *plugin, cell_t offset)

{

  return *reinterpret_cast<cell_t *>(plugin->memory + offset);

}

static inline void

Write(const sp_plugin_t *plugin, cell_t offset, cell_t value)

{

  *reinterpret_cast<cell_t *>(plugin->memory + offset) = value;

}

static inline cell_t *

Jump(const sp_plugin_t *plugin, sp_context_t *ctx, cell_t target)

{

  if (!IsValidOffset(target) || uint32_t(target) >= plugin->pcode_size) {

    ctx->err = SP_ERROR_INVALID_INSTRUCTION;

    return NULL;

  }

  return reinterpret_cast<cell_t *>(plugin->pcode + target);

}

static inline cell_t *

JumpTarget(const sp_plugin_t *plugin, sp_context_t *ctx, cell_t *cip, bool cond)

{

  if (!cond)

    return cip + 1;

  cell_t target = *cip;

  if (!IsValidOffset(target) || uint32_t(target) >= plugin->pcode_size) {

    ctx->err = SP_ERROR_INVALID_INSTRUCTION;

    return NULL;

  }

  cell_t *next = reinterpret_cast<cell_t *>(plugin->pcode + target);

  if (next < cip && !g_WatchdogTimer.HandleInterrupt()) {

    ctx->err = SP_ERROR_TIMEOUT;

    return NULL;

  }

  return next;

}

static inline bool

CheckAddress(const sp_plugin_t *plugin, sp_context_t *ctx, cell_t *stk, cell_t addr)

{

  if (uint32_t(addr) >= plugin->mem_size) {

    ctx->err = SP_ERROR_MEMACCESS;

    return false;

  }

  if (addr < ctx->hp)

    return true;

  if (reinterpret_cast<cell_t *>(plugin->memory + addr) < stk) {

    ctx->err = SP_ERROR_MEMACCESS;

    return false;

  }

  return true;

}

int

PopTrackerAndSetHeap(BaseRuntime *rt)

{

  sp_context_t *ctx = rt->GetBaseContext()->GetCtx();

  tracker_t *trk = ctx->tracker;

  assert(trk->pCur > trk->pBase);

  trk->pCur--;

  if (trk->pCur < trk->pBase)

    return SP_ERROR_TRACKER_BOUNDS;

  ucell_t amt = *trk->pCur;

  if (amt > (ctx->hp - rt->plugin()->data_size))

    return SP_ERROR_HEAPMIN;

  ctx->hp -= amt;

  return SP_ERROR_NONE;

}

int

PushTracker(sp_context_t *ctx, size_t amount)

{

  tracker_t *trk = ctx->tracker;

  if ((size_t)(trk->pCur - trk->pBase) >= trk->size)

    return SP_ERROR_TRACKER_BOUNDS;

  if (trk->pCur + 1 - (trk->pBase + trk->size) == 0) {

    size_t disp = trk->size - 1;

    trk->size *= 2;

    trk->pBase = (ucell_t *)realloc(trk->pBase, trk->size * sizeof(cell_t));

    if (!trk->pBase)

      return SP_ERROR_TRACKER_BOUNDS;

    trk->pCur = trk->pBase + disp;

  }

  *trk->pCur++ = amount;

  return SP_ERROR_NONE;

}

cell_t

NativeCallback(sp_context_t *ctx, ucell_t native_idx, cell_t *params)

{

  cell_t save_sp = ctx->sp;

  cell_t save_hp = ctx->hp;

  ctx->n_idx = native_idx;

  sp_native_t *native = &ctx->plugin->natives[native_idx];

  if (native->status == SP_NATIVE_UNBOUND) {

    ctx->n_err = SP_ERROR_INVALID_NATIVE;

    return 0;

  }

  cell_t result = native->pfn(ctx->basecx, params);

  if (ctx->n_err != SP_ERROR_NONE)

    return result;

  if (save_sp != ctx->sp) {

    ctx->n_err = SP_ERROR_STACKLEAK;

    return result;

  }

  if (save_hp != ctx->hp) {

    ctx->n_err = SP_ERROR_HEAPLEAK;

    return result;

  }

  return result;

}

static inline bool

GenerateArray(BaseRuntime *rt, sp_context_t *ctx, cell_t dims, cell_t *stk, bool autozero)

{

  if (dims == 1) {

    uint32_t size = *stk;

    if (size == 0 || !ke::IsUint32MultiplySafe(size, 4)) {

      ctx->err = SP_ERROR_ARRAY_TOO_BIG;

      return false;

    }

    *stk = ctx->hp;

    uint32_t bytes = size * 4;

    ctx->hp += bytes;

    if (uintptr_t(ctx->plugin->memory + ctx->hp) >= uintptr_t(stk)) {

      ctx->err = SP_ERROR_HEAPLOW;

      return false;

    }

    if ((ctx->err = PushTracker(ctx, bytes)) != SP_ERROR_NONE)

      return false;

    if (autozero)

      memset(ctx->plugin->memory + ctx->hp, 0, bytes);

    return true;

  }

  if ((ctx->err = GenerateFullArray(rt, dims, stk, autozero)) != SP_ERROR_NONE)

    return false;

  return true;

}

int

Interpret(BaseRuntime *rt, uint32_t aCodeStart, cell_t *rval)

{

  const sp_plugin_t *plugin = rt->plugin();

  cell_t *code = reinterpret_cast<cell_t *>(plugin->pcode);

  cell_t *codeend = reinterpret_cast<cell_t *>(plugin->pcode + plugin->pcode_size);

  if (!IsValidOffset(aCodeStart) || aCodeStart > plugin->pcode_size)

    return SP_ERROR_INVALID_INSTRUCTION;

  sp_context_t *ctx = rt->GetBaseContext()->GetCtx();

  ctx->err = SP_ERROR_NONE;

  // Save the original frm. BaseContext won't, and if we error, we won't hit

  // the stack unwinding code.

  cell_t orig_frm = ctx->frm;

  cell_t pri = 0;

  cell_t alt = 0;

  cell_t *cip = code + (aCodeStart / 4);

  cell_t *stk = reinterpret_cast<cell_t *>(plugin->memory + ctx->sp);

  for (;;) {

    if (cip >= codeend) {

      ctx->err = SP_ERROR_INVALID_INSTRUCTION;

      goto error;

    }

#if 0

    SpewOpcode(plugin, reinterpret_cast<cell_t *>(plugin->pcode + aCodeStart), cip);

#endif

    OPCODE op = (OPCODE)*cip++;

    switch (op) {

      case OP_MOVE_PRI:

        pri = alt;

        break;

      case OP_MOVE_ALT:

        alt = pri;

        break;

      case OP_XCHG:

      {

        cell_t tmp = pri;

        pri = alt;

        alt = tmp;

        break;

      }

      case OP_ZERO:

        Write(plugin, *cip++, 0);

        break;

      case OP_ZERO_S:

        Write(plugin, ctx->frm + *cip++, 0);

        break;

      case OP_PUSH_PRI:

        *--stk = pri;

        break;

      case OP_PUSH_ALT:

        *--stk = alt;

        break;

      case OP_PUSH_C:

      case OP_PUSH2_C:

      case OP_PUSH3_C:

      case OP_PUSH4_C:

      case OP_PUSH5_C:

      {

        int n = 1;

        if (op >= OP_PUSH2_C)

          n = ((op - OP_PUSH2_C) / 4) + 2;

        int i = 1;

        do {

          *--stk = *cip++;

        } while (i++ < n);

        break;

      }

      case OP_PUSH_ADR:

      case OP_PUSH2_ADR:

      case OP_PUSH3_ADR:

      case OP_PUSH4_ADR:

      case OP_PUSH5_ADR:

      {

        int n = 1;

        if (op >= OP_PUSH2_ADR)

          n = ((op - OP_PUSH2_ADR) / 4) + 2;

        int i = 1;

        do {

          cell_t addr = ctx->frm + *cip++;

          *--stk = addr;

        } while (i++ < n);

        break;

      }

      case OP_PUSH_S:

      case OP_PUSH2_S:

      case OP_PUSH3_S:

      case OP_PUSH4_S:

      case OP_PUSH5_S:

      {

        int n = 1;

        if (op >= OP_PUSH2_S)

          n = ((op - OP_PUSH2_S) / 4) + 2;

        int i = 1;

        do {

          cell_t value = Read(plugin, ctx->frm + *cip++);

          *--stk = value;

        } while (i++ < n);

        break;

      }

      case OP_PUSH:

      case OP_PUSH2:

      case OP_PUSH3:

      case OP_PUSH4:

      case OP_PUSH5:

      {

        int n = 1;

        if (op >= OP_PUSH2)

          n = ((op - OP_PUSH2) / 4) + 2;

        int i = 1;

        do {

          cell_t value = Read(plugin, *cip++);

          *--stk = value;

        } while (i++ < n);

        break;

      }

      case OP_ZERO_PRI:

        pri = 0;

        break;

      case OP_ZERO_ALT:

        alt = 0;

        break;

      case OP_ADD:

        pri += alt;

        break;

      case OP_SUB:

        pri -= alt;

        break;

      case OP_SUB_ALT:

        pri = alt - pri;

        break;

      case OP_PROC:

      {

        *--stk = ctx->frm;

        *--stk = 0;

        ctx->frm = uintptr_t(stk) - uintptr_t(plugin->memory);

        break;

      }

      case OP_IDXADDR_B:

        pri <<= *cip++;

        pri += alt;

        break;

      case OP_SHL:

        pri <<= alt;

        break;

      case OP_SHR:

        pri = unsigned(pri) >> unsigned(alt);

        break;

      case OP_SSHR:

        pri >>= alt;

        break;

      case OP_SHL_C_PRI:

        pri <<= *cip++;

        break;

      case OP_SHL_C_ALT:

        alt <<= *cip++;

        break;

      case OP_SHR_C_PRI:

        pri >>= *cip++;

        break;

      case OP_SHR_C_ALT:

        alt >>= *cip++;

        break;

      case OP_SMUL:

        pri *= alt;

        break;

      case OP_NOT:

        pri = pri ? 0 : 1;

        break;

      case OP_NEG:

        pri = -pri;

        break;

      case OP_XOR:

        pri ^= alt;

        break;

      case OP_OR:

        pri |= alt;

        break;

      case OP_AND:

        pri &= alt;

        break;

      case OP_INVERT:

        pri = ~pri;

        break;

      case OP_ADD_C:

        pri += *cip++;

        break;

      case OP_SMUL_C:

        pri *= *cip++;

        break;

      case OP_EQ:

        pri = pri == alt;

        break;

      case OP_NEQ:

        pri = pri != alt;

        break;

      case OP_SLESS:

        pri = pri < alt;

        break;

      case OP_SLEQ:

        pri = pri <= alt;

        break;

      case OP_SGRTR:

        pri = pri > alt;

        break;

      case OP_SGEQ:

        pri = pri >= alt;

        break;

      case OP_EQ_C_PRI:

        pri = pri == *cip++;

        break;

      case OP_EQ_C_ALT:

        pri = alt == *cip++;

        break;

      case OP_INC_PRI:

        pri++;

        break;

      case OP_INC_ALT:

        alt++;

        break;

      case OP_INC:

      {

        cell_t offset = *cip++;

        Write(plugin, offset, Read(plugin, offset) + 1);

        break;

      }

      case OP_INC_S:

      {

        cell_t offset = *cip++;

        cell_t value = Read(plugin, ctx->frm + offset);

        Write(plugin, ctx->frm + offset, value + 1);

        break;

      }

      case OP_INC_I:

        if (!CheckAddress(plugin, ctx, stk, pri))

          goto error;

        Write(plugin, pri, Read(plugin, pri) + 1);

        break;

      case OP_DEC_PRI:

        pri--;

        break;

      case OP_DEC_ALT:

        alt--;

        break;

      case OP_DEC:

      {

        cell_t offset = *cip++;

        Write(plugin, offset, Read(plugin, offset) - 1);

        break;

      }

      case OP_DEC_S:

      {

        cell_t offset = *cip++;

        cell_t value = Read(plugin, ctx->frm + offset);

        Write(plugin, ctx->frm + offset, value - 1);

        break;

      }

      case OP_DEC_I:

        if (!CheckAddress(plugin, ctx, stk, pri))

          goto error;

        Write(plugin, pri, Read(plugin, pri) - 1);

        break;

      case OP_LOAD_PRI:

        pri = Read(plugin, *cip++);

        break;

      case OP_LOAD_ALT:

        alt = Read(plugin, *cip++);

        break;

      case OP_LOAD_S_PRI:

        pri = Read(plugin, ctx->frm + *cip++);

        break;

      case OP_LOAD_S_ALT:

        alt = Read(plugin, ctx->frm + *cip++);

        break;

      case OP_LOAD_S_BOTH:

        pri = Read(plugin, ctx->frm + *cip++);

        alt = Read(plugin, ctx->frm + *cip++);

        break;

      case OP_LREF_S_PRI:

      {

        pri = Read(plugin, ctx->frm + *cip++);

        pri = Read(plugin, pri);

        break;

      }

      case OP_LREF_S_ALT:

      {

        alt = Read(plugin, ctx->frm + *cip++);

        alt = Read(plugin, alt);

        break;

      }

      case OP_CONST_PRI:

        pri = *cip++;

        break;

      case OP_CONST_ALT:

        alt = *cip++;

        break;

      case OP_ADDR_PRI:

        pri = ctx->frm + *cip++;