dvander@47: /* vim: set ts=4 sw=4 tw=99 et: dvander@47: * dvander@0: * Copyright (C) 2012 David Anderson dvander@0: * dvander@0: * This file is part of JITCraft. dvander@0: * dvander@0: * JITCraft is free software: you can redistribute it and/or modify it under dvander@0: * the terms of the GNU General Public License as published by the Free dvander@0: * Software Foundation, either version 3 of the License, or (at your option) dvander@0: * any later version. dvander@0: * dvander@0: * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY dvander@0: * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS dvander@0: * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. dvander@0: * dvander@0: * You should have received a copy of the GNU General Public License along with dvander@0: * JITCraft. If not, see http://www.gnu.org/licenses/. dvander@0: */ dvander@0: // Opcode macros: dvander@195: // NAME TEXT LENGTH USES DEFS dvander@0: // dvander@0: // Type suffixes: dvander@0: // I = 32-bit integer dvander@19: // F = 32-bit IEEE-754 float dvander@19: // O = object reference dvander@0: dvander@0: // No operation. dvander@195: OPDEF(OP_NOP, "nop", 1, 0, 0) dvander@0: dvander@0: // Pushes a signed integer immediate onto the stack. dvander@195: OPDEF(OP_INT, "int", 5, 0, 1) dvander@0: dvander@0: // Returns from the current routine, propagating the value at the top of the dvander@0: // stack to the caller. dvander@195: OPDEF(OP_RETURN, "return", 1, 1, 0) dvander@0: dvander@0: // value = pop() dvander@0: // if (value == [true, false]) dvander@0: // goto target dvander@195: OPDEF(OP_JT, "jt", 5, 1, 0) dvander@195: OPDEF(OP_JF, "jf", 5, 1, 0) dvander@74: dvander@0: // Unconditional jump. dvander@195: OPDEF(OP_JUMP, "jump", 5, 0, 0) dvander@0: dvander@230: // Aliases for JUMP, that automatically leave LR regions. dvander@230: OPDEF(OP_BREAK, "break", 5, 0, 0) dvander@230: OPDEF(OP_CONTINUE, "continue", 5, 0, 0) dvander@230: dvander@0: // Gets or sets the value of a local variable onto the stack. The local dvander@0: // variable is given by an immediate index. dvander@195: OPDEF(OP_GETLOCAL, "getlocal", 5, 0, 1) dvander@195: OPDEF(OP_SETLOCAL, "setlocal", 5, 1, 1) dvander@0: dvander@0: // Stack transitions for these binary operators: dvander@0: // rhs = pop() dvander@0: // lhs = pop() dvander@0: // push(lhs OP rhs) dvander@195: OPDEF(OP_ADD, "add", 1, 2, 1) dvander@195: OPDEF(OP_SUB, "sub", 1, 2, 1) dvander@195: OPDEF(OP_MUL, "mul", 1, 2, 1) dvander@195: OPDEF(OP_DIV, "div", 1, 2, 1) dvander@195: OPDEF(OP_MOD, "mod", 1, 2, 1) dvander@0: dvander@195: OPDEF(OP_LT, "lt", 1, 2, 1) dvander@195: OPDEF(OP_LE, "le", 1, 2, 1) dvander@195: OPDEF(OP_GE, "ge", 1, 2, 1) dvander@195: OPDEF(OP_GT, "gt", 1, 2, 1) dvander@195: OPDEF(OP_EQ, "eq", 1, 2, 1) dvander@195: OPDEF(OP_NE, "ne", 1, 2, 1) dvander@74: dvander@195: OPDEF(OP_NOT, "not", 1, 1, 1) dvander@195: OPDEF(OP_NEG, "neg", 1, 1, 1) dvander@79: dvander@195: OPDEF(OP_POP, "pop", 1, 1, 0) dvander@0: dvander@72: // Unconditional terminator placed at the end of code. If a function returns dvander@72: // void, this acts as a RETURNVOID. Otherwise, it must be unreachable. dvander@195: OPDEF(OP_STOP, "stop", 1, 0, 0) dvander@0: dvander@73: // Call a function with N arguments. The target function must be the last item dvander@73: // on the stack. dvander@195: OPDEF(OP_CALL, "call", 1, -1, 1) dvander@0: dvander@0: // Similar to GET/LOCAL, except for arguments. dvander@195: OPDEF(OP_GETARG, "getarg", 5, 0, 1) dvander@195: OPDEF(OP_SETARG, "setarg", 5, 1, 1) dvander@0: dvander@185: // Allocates either: dvander@185: // A fixed array, dvander@185: // A 0-length dynamic array, or dvander@185: // A dynamic array whose size is specified on the stack. dvander@185: // dvander@185: // The HeapTenure is stored as a byte following the pc. The ArrayMap to use dvander@185: // is specified as an index into the script's object table. dvander@157: // dvander@157: // Format: dvander@182: // [u8 op] [u8 tenure] [u32 index] dvander@195: OPDEF(OP_NEWFIXED, "newfixed", 6, 0, 1) dvander@195: OPDEF(OP_NEWEMPTY, "newempty", 6, 0, 1) dvander@195: OPDEF(OP_NEWSIZED, "newsized", 6, -1, 1) dvander@157: dvander@236: // Creates a duplicate copy of an array. This is a deep clone, rather than dvander@236: // COPYARRAY, which is shallow. dvander@234: OPDEF(OP_DUPARRAY, "duparray", 1, 1, 1) dvander@234: dvander@157: // Performs an array-to-array assignment. dvander@157: // Left = pop() dvander@157: // Right = pop() dvander@157: // copy(Left, Right) dvander@157: // push(Left) dvander@236: OPDEF(OP_COPYARRAY, "copyarray", 1, 2, 1) dvander@157: dvander@0: // Reads or writes an integer element to an unsafe array. dvander@0: // index = pop() dvander@0: // ref = pop() dvander@0: // ref[index] dvander@0: // dvander@195: OPDEF(OP_GETELEM, "getelem", 1, 2, 1) dvander@195: OPDEF(OP_SETELEM, "setelem", 1, 3, 1) dvander@0: dvander@4: // Pushes a 32-bit IEEE-754 floating point immediate onto the stack. dvander@195: OPDEF(OP_FLOAT, "float", 5, 0, 1) dvander@4: dvander@4: // Converts an integer to a 32-bit IEEE-754 floating point immediate. dvander@195: OPDEF(OP_CVT_I2F, "cvt.i2f", 1, 1, 1) dvander@208: OPDEF(OP_CVT_I2B, "cvt.i2b", 1, 1, 1) dvander@4: dvander@4: // Stack transitions for these binary operators: dvander@4: // rhs = pop() dvander@4: // lhs = pop() dvander@4: // push(lhs OP rhs) dvander@195: OPDEF(OP_ADD_F, "add.f", 1, 2, 1) dvander@195: OPDEF(OP_SUB_F, "sub.f", 1, 2, 1) dvander@195: OPDEF(OP_MUL_F, "mul.f", 1, 2, 1) dvander@195: OPDEF(OP_DIV_F, "div.f", 1, 2, 1) dvander@74: dvander@195: OPDEF(OP_LT_F, "lt.f", 1, 2, 1) dvander@195: OPDEF(OP_LE_F, "le.f", 1, 2, 1) dvander@195: OPDEF(OP_GE_F, "ge.f", 1, 2, 1) dvander@195: OPDEF(OP_GT_F, "gt.f", 1, 2, 1) dvander@195: OPDEF(OP_EQ_F, "eq.f", 1, 2, 1) dvander@195: OPDEF(OP_NE_F, "ne.f", 1, 2, 1) dvander@79: dvander@195: OPDEF(OP_NOT_F, "not.f", 1, 1, 1) dvander@195: OPDEF(OP_NEG_F, "neg.f", 1, 1, 1) dvander@4: dvander@8: // Bitwise operators. dvander@195: OPDEF(OP_SHL, "shl", 1, 2, 1) dvander@195: OPDEF(OP_SHR, "shr", 1, 2, 1) dvander@195: OPDEF(OP_USHR, "ushr", 1, 2, 1) dvander@195: OPDEF(OP_BITAND, "bitand", 1, 2, 1) dvander@195: OPDEF(OP_BITOR, "bitor", 1, 2, 1) dvander@195: OPDEF(OP_BITXOR, "bitxor", 1, 2, 1) dvander@195: OPDEF(OP_BITNOT, "bitnot", 1, 1, 1) dvander@12: dvander@12: // Saves or restores the position of the LIFO heap to/from a local slot. dvander@195: OPDEF(OP_SAVELIFO, "savelifo", 5, 0, 0) dvander@195: OPDEF(OP_UNWINDLIFO, "unwindlifo", 5, 0, 0) dvander@14: dvander@14: // Composes a variable reference to a stack slot or argument. dvander@195: OPDEF(OP_VARREF_LIFO, "varref.lifo", 5, 0, 1) dvander@195: OPDEF(OP_ARGREF_LIFO, "argref.lifo", 5, 0, 1) dvander@195: OPDEF(OP_SLOTREF_LIFO, "slotref.lifo", 1, 1, 1) dvander@195: OPDEF(OP_GETREF_I, "getref.i", 1, 1, 1) dvander@195: OPDEF(OP_SETREF_I, "setref.i", 1, 2, 1) dvander@195: OPDEF(OP_GETREF_F, "getref.f", 1, 1, 1) dvander@195: OPDEF(OP_SETREF_F, "setref.f", 1, 2, 1) dvander@21: dvander@21: // Pushes an object reference onto the stack. dvander@195: OPDEF(OP_OBJECT, "object", 5, 0, 1) dvander@22: dvander@22: // Duplicates the top item on the stack. dvander@195: OPDEF(OP_DUP, "dup", 1, 1, 2) dvander@22: dvander@22: // Duplicates the top two items on the stack. dvander@195: OPDEF(OP_DUP2, "dup2", 1, 2, 4) dvander@23: dvander@23: // Swaps the two items at the top of the stack. dvander@195: OPDEF(OP_SWAP, "swap", 1, 2, 2) dvander@23: dvander@23: // Roll operation is the same as Forth. It steals a value on the stack, dvander@23: // shifting all stack values down, and then places the stolen value back at dvander@23: // the top of the stack. dvander@23: // dvander@23: // p = sp[-3] dvander@23: // sp[-3] = sp[-2] dvander@23: // sp[-2] = sp[-1] dvander@23: // sp[-1] = p dvander@195: OPDEF(OP_ROLL3, "roll3", 1, 3, 3) dvander@23: dvander@23: // Pick operation is the same as Forth. It pushes a copy of a slot at a dvander@23: // specific depth. dvander@23: // dvander@23: // push(sp[-n]) dvander@195: OPDEF(OP_PICK2, "pick2", 1, 2, 3) dvander@195: OPDEF(OP_PICK3, "pick3", 1, 3, 4) dvander@68: dvander@68: // Calls a native function. During the course of calling a native, arguments dvander@68: // on the stack are re-pushed to match the cell-based native calling dvander@68: // convention expected by ISourcePawnEngine. dvander@68: // dvander@68: // Unlike the normal CALL instruction, natives take truly variadic arguments dvander@195: // and so we must specify the number of arguments. dvander@68: // dvander@195: // [u8 Opcode] [u32 ArgCount] dvander@68: // dvander@195: OPDEF(OP_CALLNATIVE, "callnative", 5, -1, 1) dvander@72: dvander@72: // Returns from a function that does return a value. dvander@195: OPDEF(OP_RETURNVOID, "returnvoid", 1, 0, 0) dvander@73: dvander@195: // Opcodes for accessing an environment slot in the global scope. The index dvander@195: // maps into the code object's string table, and represents the name of the dvander@195: // global variable. dvander@195: OPDEF(OP_SETGLOBAL, "setglobal", 5, 1, 1) dvander@195: OPDEF(OP_GETGLOBAL, "getglobal", 5, 0, 1) dvander@142: dvander@245: // Reinterpret casts from one 32-bit POD type to another. The new type pointer dvander@245: // is encoded into the object table, for the JITs' type flow. dvander@245: OPDEF(OP_BITCAST, "BITCAST", 5, 1, 1) dvander@142: dvander@143: // Pushes a boolean value. dvander@195: OPDEF(OP_TRUE, "true", 1, 0, 1) dvander@195: OPDEF(OP_FALSE, "false", 1, 0, 1) dvander@143: dvander@147: // Allocate a struct. The HeapTenure is stored as a byte following pc. The dvander@147: // StructMap to use is specified as an index into the script's Map table. dvander@147: // dvander@147: // Format: dvander@182: // [u8 op] [u8 tenure] [u32 index] dvander@195: OPDEF(OP_NEWSTRUCT, "newstruct", 6, 0, 1) dvander@147: dvander@152: // Performs a struct-to-struct assignment. dvander@152: // Left = pop() dvander@152: // Right = pop() dvander@152: // copy(Left, Right) dvander@152: // push(Left) dvander@195: OPDEF(OP_COPYSTRUCT, "structcopy", 1, 2, 1) dvander@152: dvander@157: // Sets or gets a property in a struct. The index of the field is specified as dvander@157: // a 32-bit integer. Note that these opcodes follow a new style of deriving dvander@157: // their types at runtime. dvander@195: OPDEF(OP_GETFIELD, "getfield", 5, 1, 1) dvander@195: OPDEF(OP_SETFIELD, "setfield", 5, 2, 1) dvander@164: dvander@172: // Table-based jump. dvander@172: // [u8 op] [i32 low] [i32 high] [u32 jump] [u32 jumps...] dvander@195: OPDEF(OP_TABLESWITCH, "tableswitch", 9, 1, 0) dvander@172: dvander@195: OPDEF(OP_SIZEOF, "sizeof", 1, 1, 1) dvander@194: dvander@195: // Registers a function as a publicly exported name. dvander@230: OPDEF(OP_PUBLIC, "public", 1, 1, 0) dvander@230: dvander@230: // Enter and leave loop bodies. This is to track positions in the LIFO stack. dvander@230: // This is only used for the outermost scope inside loop bodies. BREAK and dvander@230: // CONTINUE implicitly perform a LEAVELOOP. dvander@230: // dvander@230: // If the second byte to ENTERLOOP is 0, then no LIFO region is needed. dvander@230: OPDEF(OP_ENTERLOOP, "enterloop", 2, 0, 0) dvander@247: OPDEF(OP_LEAVELOOP, "leaveloop", 1, 0, 0) dvander@247: dvander@247: // Create a new dependent array. The type to use is encoded as an index. dvander@247: // index = POP() dvander@247: // base = POP() dvander@247: // PUSH(array) dvander@247: OPDEF(OP_DEPARRAY, "deparray", 5, 2, 1)