/*

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

 */

// Opcode macros:

//  NAME            NUMBER      TEXT                LENGTH  USES  DEFS   

//

// Type suffixes:

//  I = 32-bit integer

//  P = reference to the UnsafeHeap or UnsafeStack

// No operation.

OPDEF(OP_NOP,           0,          "nop",          1,      0,  0)

// Pushes a signed integer immediate onto the stack.

OPDEF(OP_INT,           1,          "int",          5,      0,  1)    

// Returns from the current routine, propagating the value at the top of the

// stack to the caller.

OPDEF(OP_RETURN,        2,          "return",       1,      1,  0)

// Stack transitions for these comparison ops:

// rhs = pop()

// lhs = pop()

// if (lhs COMPARE rhs)

//    goto target (immediate, relative to the beginning of the jump instruction)

OPDEF(OP_JL,            3,          "jl",           5,      2,  0)

OPDEF(OP_JLE,           4,          "jle",          5,      2,  0)

OPDEF(OP_JG,            5,          "jg",           5,      2,  0)

OPDEF(OP_JGE,           6,          "jge",          5,      2,  0)

OPDEF(OP_JEQ,           7,          "jeq",          5,      2,  0)

OPDEF(OP_JNE,           8,          "jne",          5,      2,  0)

// value = pop()

// if (value == [true, false])

//    goto target

OPDEF(OP_JT,            9,          "jt",           5,      1,  0)

OPDEF(OP_JF,            10,         "jf",           5,      1,  0)

// Unconditional jump.

OPDEF(OP_JUMP,          11,         "jump",         5,      0,  0)

// Gets or sets the value of a local variable onto the stack. The local

// variable is given by an immediate index.

OPDEF(OP_GETLOCAL,      12,         "getlocal",     5,      0,  1)

OPDEF(OP_SETLOCAL,      13,         "setlocal",     5,      1,  1)

// Stack transitions for these binary operators:

// rhs = pop()

// lhs = pop()

// push(lhs OP rhs)

OPDEF(OP_ADD,           14,         "add",          1,      2,  1)

OPDEF(OP_SUB,           15,         "sub",          1,      2,  1)

OPDEF(OP_MUL,           16,         "mul",          1,      2,  1)

OPDEF(OP_DIV,           17,         "div",          1,      2,  1)

OPDEF(OP_POP,           18,         "pop",          1,      1,  0)

// Unconditional terminator placed at the end of code.

OPDEF(OP_STOP,          19,         "stop",         1,      0,  0)

// Call a function with N arguments. Arguments are pushed in reverse order.

//

// CALLGLOBAL - followed by an extra immediate, containing the function index

// in the code's global.

OPDEF(OP_CALLGLOBAL,    20,         "callglobal",   9,      -1, 1)

// Similar to GET/LOCAL, except for arguments.

OPDEF(OP_GETARG,        21,         "getarg",       5,      0,  1)

OPDEF(OP_SETARG,        22,         "setarg",       5,      1,  1)

// Reads or writes an integer element to an unsafe array.

//  index = pop()

//  ref = pop()

//  ref[index]

//

OPDEF(OP_GETARRAY_I,    23,         "getarray.i",   1,      2,  1)

OPDEF(OP_SETARRAY_I,    24,         "setarray.i",   1,      3,  1)

OPDEF(OP_GETARRAY_F,    25,         "getarray.i",   1,      2,  1)

OPDEF(OP_SETARRAY_F,    26,         "setarray.i",   1,      3,  1)

OPDEF(OP_GETARRAY_P,    27,         "getarray.p",   1,      2,  1)

// Allocate an array of N dimensions into unsafe memory. Each dimension size

// is encoded as an immediate. For the dynamic variant, they are popped off

// the stack instead (sp[-1] == dimension 0, etc).

//

// Format:

//  [u8 op] [u8 width] [u8 dims] [imm32 ...]

//

// if (dynamic)

//    for (i = ndims - 1; i >= 0; i--)

//        dims[ndims - i - 1] = pop()

// 

// push(array pref)

//

OPDEF(OP_STACKARRAY,    28,         "stackarray",   -1,     0,  1)

// Unwinds the stack to its position before a local slot was allocated.

OPDEF(OP_UNWIND,        29,         "unwind",       5,      0,  0)

// Performs a bounds check on an unsafe array.

//

// index = pop()

// array = pop()

// push(array)

// push(index)

OPDEF(OP_BOUNDS_STA,    30,         "bounds.sta",   1,      2,  2)

// Pushes a 32-bit IEEE-754 floating point immediate onto the stack.

OPDEF(OP_FLOAT,         31,         "float",        5,      0,  1)

// Converts an integer to a 32-bit IEEE-754 floating point immediate.

OPDEF(OP_CVT_I2F,       32,         "cvt.i2f",      1,      1,  1)

// Stack transitions for these binary operators:

// rhs = pop()

// lhs = pop()

// push(lhs OP rhs)

OPDEF(OP_ADD_F,         33,         "add.f",        1,      2,  1)

OPDEF(OP_SUB_F,         34,         "sub.f",        1,      2,  1)

OPDEF(OP_MUL_F,         35,         "mul.f",        1,      2,  1)

OPDEF(OP_DIV_F,         36,         "div.f",        1,      2,  1)