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

 */

// Opcode macros:

//  NAME                TEXT            LENGTH  USES  DEFS   

//

// Type suffixes:

//  I = 32-bit integer

//  F = 32-bit IEEE-754 float

//  O = object reference

// No operation.

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

// Pushes a signed integer immediate onto the stack.

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

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

// stack to the caller.

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

// value = pop()

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

//    goto target

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

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

// Unconditional jump.

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

// Aliases for JUMP, that automatically leave LR regions.

OPDEF(OP_BREAK,         "break",        5,      0,  0)

OPDEF(OP_CONTINUE,      "continue",     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,      "getlocal",     5,      0,  1)

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

// Stack transitions for these binary operators:

// rhs = pop()

// lhs = pop()

// push(lhs OP rhs)

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

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

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

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

OPDEF(OP_MOD,           "mod",          1,      2,  1)

OPDEF(OP_LT,            "lt",           1,      2,  1)

OPDEF(OP_LE,            "le",           1,      2,  1)

OPDEF(OP_GE,            "ge",           1,      2,  1)

OPDEF(OP_GT,            "gt",           1,      2,  1)

OPDEF(OP_EQ,            "eq",           1,      2,  1)

OPDEF(OP_NE,            "ne",           1,      2,  1)

OPDEF(OP_NOT,           "not",          1,      1,  1)

OPDEF(OP_NEG,           "neg",          1,      1,  1)

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

// Unconditional terminator placed at the end of code. If a function returns

// void, this acts as a RETURNVOID. Otherwise, it must be unreachable.

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

// Call a function with N arguments. The target function must be the last item

// on the stack.

OPDEF(OP_CALL,          "call",         1,      -1, 1)

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

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

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

// Allocates either:

//   A fixed array, 

//   A 0-length dynamic array, or

//   A dynamic array whose size is specified on the stack.

//

// The HeapTenure is stored as a byte following the pc. The ArrayMap to use

// is specified as an index into the script's object table.

//

// Format:

//  [u8 op] [u8 tenure] [u32 index]

OPDEF(OP_NEWFIXED,      "newfixed",     6,      0, 1)

OPDEF(OP_NEWEMPTY,      "newempty",     6,      0, 1)

OPDEF(OP_NEWSIZED,      "newsized",     6,     -1, 1)

// Performs an array-to-array assignment.

//   Left = pop()

//   Right = pop()

//   copy(Left, Right)

//   push(Left)

OPDEF(OP_COPYARRAY,     "arraycopy",    1,      2,  1)

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

//  index = pop()

//  ref = pop()

//  ref[index]

//

OPDEF(OP_GETELEM,       "getelem",      1,      2,  1)

OPDEF(OP_SETELEM,       "setelem",      1,      3,  1)

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

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

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

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

OPDEF(OP_CVT_I2B,       "cvt.i2b",      1,      1,  1)

// Stack transitions for these binary operators:

// rhs = pop()

// lhs = pop()

// push(lhs OP rhs)

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

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

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

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

OPDEF(OP_LT_F,          "lt.f",         1,      2,  1)

OPDEF(OP_LE_F,          "le.f",         1,      2,  1)

OPDEF(OP_GE_F,          "ge.f",         1,      2,  1)

OPDEF(OP_GT_F,          "gt.f",         1,      2,  1)

OPDEF(OP_EQ_F,          "eq.f",         1,      2,  1)

OPDEF(OP_NE_F,          "ne.f",         1,      2,  1)

OPDEF(OP_NOT_F,         "not.f",        1,      1,  1)

OPDEF(OP_NEG_F,         "neg.f",        1,      1,  1)

// Bitwise operators.

OPDEF(OP_SHL,           "shl",          1,      2,  1)

OPDEF(OP_SHR,           "shr",          1,      2,  1)

OPDEF(OP_USHR,          "ushr",         1,      2,  1)

OPDEF(OP_BITAND,        "bitand",       1,      2,  1)

OPDEF(OP_BITOR,         "bitor",        1,      2,  1)

OPDEF(OP_BITXOR,        "bitxor",       1,      2,  1)

OPDEF(OP_BITNOT,        "bitnot",       1,      1,  1)

// Saves or restores the position of the LIFO heap to/from a local slot.

OPDEF(OP_SAVELIFO,      "savelifo",     5,      0,  0)

OPDEF(OP_UNWINDLIFO,    "unwindlifo",   5,      0,  0)

// Composes a variable reference to a stack slot or argument.

OPDEF(OP_VARREF_LIFO,   "varref.lifo",  5,      0,  1)

OPDEF(OP_ARGREF_LIFO,   "argref.lifo",  5,      0,  1)

OPDEF(OP_SLOTREF_LIFO,  "slotref.lifo", 1,      1,  1)

OPDEF(OP_GETREF_I,      "getref.i",     1,      1,  1)

OPDEF(OP_SETREF_I,      "setref.i",     1,      2,  1)

OPDEF(OP_GETREF_F,      "getref.f",     1,      1,  1)

OPDEF(OP_SETREF_F,      "setref.f",     1,      2,  1)

// Pushes an object reference onto the stack.

OPDEF(OP_OBJECT,        "object",       5,      0,  1)

// Duplicates the top item on the stack.

OPDEF(OP_DUP,           "dup",          1,      1,  2)

// Duplicates the top two items on the stack.

OPDEF(OP_DUP2,          "dup2",         1,      2,  4)

// Swaps the two items at the top of the stack.

OPDEF(OP_SWAP,          "swap",         1,      2,  2)

// Roll operation is the same as Forth. It steals a value on the stack,

// shifting all stack values down, and then places the stolen value back at

// the top of the stack.

//

//  p = sp[-3]

//  sp[-3] = sp[-2]

//  sp[-2] = sp[-1]

//  sp[-1] = p

OPDEF(OP_ROLL3,         "roll3",        1,      3, 3)

// Pick operation is the same as Forth. It pushes a copy of a slot at a

// specific depth.

//

// push(sp[-n])

OPDEF(OP_PICK2,         "pick2",        1,      2, 3)

OPDEF(OP_PICK3,         "pick3",        1,      3, 4)

// Calls a native function. During the course of calling a native, arguments

// on the stack are re-pushed to match the cell-based native calling

// convention expected by ISourcePawnEngine.

//

// Unlike the normal CALL instruction, natives take truly variadic arguments

// and so we must specify the number of arguments.

//

// [u8 Opcode] [u32 ArgCount]

//

OPDEF(OP_CALLNATIVE,    "callnative",   5,     -1, 1)

// Returns from a function that does return a value.

OPDEF(OP_RETURNVOID,    "returnvoid",   1,      0, 0)

// Opcodes for accessing an environment slot in the global scope. The index

// maps into the code object's string table, and represents the name of the

// global variable.

OPDEF(OP_SETGLOBAL,     "setglobal",    5,      1, 1)

OPDEF(OP_GETGLOBAL,     "getglobal",    5,      0, 1)

// Reinterprets a 32-bit integer as a float, or vice-versa.

OPDEF(OP_BITS_I2F,      "bits.i2f",     1,      1, 1)

OPDEF(OP_BITS_F2I,      "bits.f2i",     1,      1, 1)

// Pushes a boolean value.

OPDEF(OP_TRUE,          "true",         1,      0, 1)

OPDEF(OP_FALSE,         "false",        1,      0, 1)

// Allocate a struct. The HeapTenure is stored as a byte following pc. The

// StructMap to use is specified as an index into the script's Map table.

//

// Format:

//  [u8 op] [u8 tenure] [u32 index]

OPDEF(OP_NEWSTRUCT,     "newstruct",    6,      0, 1)

// Performs a struct-to-struct assignment.

//   Left = pop()

//   Right = pop()

//   copy(Left, Right)

//   push(Left)

OPDEF(OP_COPYSTRUCT,    "structcopy",   1,      2, 1)

// Sets or gets a property in a struct. The index of the field is specified as

// a 32-bit integer. Note that these opcodes follow a new style of deriving

// their types at runtime.

OPDEF(OP_GETFIELD,      "getfield",     5,      1, 1)

OPDEF(OP_SETFIELD,      "setfield",     5,      2, 1)

// Table-based jump.

// [u8 op] [i32 low] [i32 high] [u32 jump] [u32 jumps...]

OPDEF(OP_TABLESWITCH,   "tableswitch",  9,      1, 0)

OPDEF(OP_SIZEOF,        "sizeof",       1,      1, 1)

// Registers a function as a publicly exported name.

OPDEF(OP_PUBLIC,        "public",       1,      1, 0)

// Enter and leave loop bodies. This is to track positions in the LIFO stack.

// This is only used for the outermost scope inside loop bodies. BREAK and

// CONTINUE implicitly perform a LEAVELOOP.

//

// If the second byte to ENTERLOOP is 0, then no LIFO region is needed.

OPDEF(OP_ENTERLOOP,     "enterloop",    2,      0, 0)

OPDEF(OP_LEAVELOOP,     "leaveloop",    1,      0, 0)