1 /* vim: set ts=4 sw=4 tw=99 et:
3 * Copyright (C) 2012 David Anderson
5 * This file is part of JITCraft.
7 * JITCraft is free software: you can redistribute it and/or modify it under
8 * the terms of the GNU General Public License as published by the Free
9 * Software Foundation, either version 3 of the License, or (at your option)
12 * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY
13 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
14 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License along with
17 * JITCraft. If not, see http://www.gnu.org/licenses/.
20 // NAME NUMBER TEXT LENGTH USES DEFS
24 // F = 32-bit IEEE-754 float
25 // O = object reference
28 OPDEF(OP_NOP, 0, "nop", 1, 0, 0)
30 // Pushes a signed integer immediate onto the stack.
31 OPDEF(OP_INT, 1, "int", 5, 0, 1)
33 // Returns from the current routine, propagating the value at the top of the
34 // stack to the caller.
35 OPDEF(OP_RETURN, 2, "return", 1, 1, 0)
37 // Stack transitions for these comparison ops:
40 // if (lhs COMPARE rhs)
41 // goto target (immediate, relative to the beginning of the jump instruction)
42 OPDEF(OP_JL, 3, "jl", 5, 2, 0)
43 OPDEF(OP_JLE, 4, "jle", 5, 2, 0)
44 OPDEF(OP_JG, 5, "jg", 5, 2, 0)
45 OPDEF(OP_JGE, 6, "jge", 5, 2, 0)
46 OPDEF(OP_JEQ, 7, "jeq", 5, 2, 0)
47 OPDEF(OP_JNE, 8, "jne", 5, 2, 0)
50 // if (value == [true, false])
52 OPDEF(OP_JT, 9, "jt", 5, 1, 0)
53 OPDEF(OP_JF, 10, "jf", 5, 1, 0)
55 OPDEF(OP_JL_F, 11, "jl.f", 5, 2, 0)
56 OPDEF(OP_JLE_F, 12, "jle.f", 5, 2, 0)
57 OPDEF(OP_JG_F, 13, "jg.f", 5, 2, 0)
58 OPDEF(OP_JGE_F, 14, "jge.f", 5, 2, 0)
59 OPDEF(OP_JEQ_F, 15, "jeq.f", 5, 2, 0)
60 OPDEF(OP_JNE_F, 16, "jne.f", 5, 2, 0)
61 OPDEF(OP_JT_F, 17, "jt.f", 5, 1, 0)
62 OPDEF(OP_JF_F, 18, "jf.f", 5, 1, 0)
64 // Unconditional jump.
65 OPDEF(OP_JUMP, 19, "jump", 5, 0, 0)
67 // Gets or sets the value of a local variable onto the stack. The local
68 // variable is given by an immediate index.
69 OPDEF(OP_GETLOCAL, 20, "getlocal", 5, 0, 1)
70 OPDEF(OP_SETLOCAL, 21, "setlocal", 5, 1, 1)
72 // Stack transitions for these binary operators:
76 OPDEF(OP_ADD, 22, "add", 1, 2, 1)
77 OPDEF(OP_SUB, 23, "sub", 1, 2, 1)
78 OPDEF(OP_MUL, 24, "mul", 1, 2, 1)
79 OPDEF(OP_DIV, 25, "div", 1, 2, 1)
80 OPDEF(OP_MOD, 26, "mod", 1, 2, 1)
82 OPDEF(OP_LT, 27, "lt", 1, 2, 1)
83 OPDEF(OP_LE, 28, "le", 1, 2, 1)
84 OPDEF(OP_GE, 29, "ge", 1, 2, 1)
85 OPDEF(OP_GT, 30, "gt", 1, 2, 1)
86 OPDEF(OP_EQ, 31, "eq", 1, 2, 1)
87 OPDEF(OP_NE, 32, "ne", 1, 2, 1)
89 OPDEF(OP_NOT, 33, "not", 1, 1, 1)
90 OPDEF(OP_NEG, 34, "neg", 1, 1, 1)
92 OPDEF(OP_POP, 35, "pop", 1, 1, 0)
94 // Unconditional terminator placed at the end of code. If a function returns
95 // void, this acts as a RETURNVOID. Otherwise, it must be unreachable.
96 OPDEF(OP_STOP, 36, "stop", 1, 0, 0)
98 // Call a function with N arguments. The target function must be the last item
100 OPDEF(OP_CALL, 37, "call", 1, -1, 1)
102 // Similar to GET/LOCAL, except for arguments.
103 OPDEF(OP_GETARG, 38, "getarg", 5, 0, 1)
104 OPDEF(OP_SETARG, 39, "setarg", 5, 1, 1)
108 // A 0-length dynamic array, or
109 // A dynamic array whose size is specified on the stack.
111 // The HeapTenure is stored as a byte following the pc. The ArrayMap to use
112 // is specified as an index into the script's object table.
115 // [u8 op] [u8 tenure] [u32 index]
116 OPDEF(OP_NEWFIXED, 40, "newfixed", 6, 0, 1)
117 OPDEF(OP_NEWEMPTY, 41, "newempty", 6, 0, 1)
118 OPDEF(OP_NEWSIZED, 42, "newsized", 6, -1, 1)
120 // Performs an array-to-array assignment.
125 OPDEF(OP_COPYARRAY, 43, "arraycopy", 1, 2, 1)
127 // Reads or writes an integer element to an unsafe array.
132 OPDEF(OP_GETELEM, 44, "getelem", 1, 2, 1)
133 OPDEF(OP_SETELEM, 45, "setelem", 1, 3, 1)
135 // Pushes a 32-bit IEEE-754 floating point immediate onto the stack.
136 OPDEF(OP_FLOAT, 46, "float", 5, 0, 1)
138 // Converts an integer to a 32-bit IEEE-754 floating point immediate.
139 OPDEF(OP_CVT_I2F, 47, "cvt.i2f", 1, 1, 1)
141 // Stack transitions for these binary operators:
145 OPDEF(OP_ADD_F, 48, "add.f", 1, 2, 1)
146 OPDEF(OP_SUB_F, 49, "sub.f", 1, 2, 1)
147 OPDEF(OP_MUL_F, 50, "mul.f", 1, 2, 1)
148 OPDEF(OP_DIV_F, 51, "div.f", 1, 2, 1)
150 OPDEF(OP_LT_F, 52, "lt.f", 1, 2, 1)
151 OPDEF(OP_LE_F, 53, "le.f", 1, 2, 1)
152 OPDEF(OP_GE_F, 54, "ge.f", 1, 2, 1)
153 OPDEF(OP_GT_F, 55, "gt.f", 1, 2, 1)
154 OPDEF(OP_EQ_F, 56, "eq.f", 1, 2, 1)
155 OPDEF(OP_NE_F, 57, "ne.f", 1, 2, 1)
157 OPDEF(OP_NOT_F, 58, "not.f", 1, 1, 1)
158 OPDEF(OP_NEG_F, 59, "neg.f", 1, 1, 1)
160 // Bitwise operators.
161 OPDEF(OP_SHL, 60, "shl", 1, 2, 1)
162 OPDEF(OP_SHR, 61, "shr", 1, 2, 1)
163 OPDEF(OP_USHR, 62, "ushr", 1, 2, 1)
164 OPDEF(OP_BITAND, 63, "bitand", 1, 2, 1)
165 OPDEF(OP_BITOR, 64, "bitor", 1, 2, 1)
166 OPDEF(OP_BITXOR, 65, "bitxor", 1, 2, 1)
167 OPDEF(OP_BITNOT, 66, "bitnot", 1, 1, 1)
169 // Saves or restores the position of the LIFO heap to/from a local slot.
170 OPDEF(OP_SAVELIFO, 67, "savelifo", 5, 0, 0)
171 OPDEF(OP_UNWINDLIFO, 68, "unwindlifo", 5, 0, 0)
173 // Composes a variable reference to a stack slot or argument.
174 OPDEF(OP_VARREF_LIFO, 69, "varref.lifo", 5, 0, 1)
175 OPDEF(OP_ARGREF_LIFO, 70, "argref.lifo", 5, 0, 1)
176 OPDEF(OP_SLOTREF_LIFO, 71, "slotref.lifo", 1, 1, 1)
177 OPDEF(OP_ARRAYREF_LIFO, 72, "arrayref.lifo",1, 2, 1)
178 OPDEF(OP_GETREF_I, 73, "getref.i", 1, 1, 1)
179 OPDEF(OP_SETREF_I, 74, "setref.i", 1, 2, 1)
180 OPDEF(OP_GETREF_F, 75, "getref.f", 1, 1, 1)
181 OPDEF(OP_SETREF_F, 76, "setref.f", 1, 2, 1)
183 // Pushes an object reference onto the stack.
184 OPDEF(OP_OBJECT, 77, "object", 5, 0, 1)
186 // Duplicates the top item on the stack.
187 OPDEF(OP_DUP, 78, "dup", 1, 1, 2)
189 // Duplicates the top two items on the stack.
190 OPDEF(OP_DUP2, 79, "dup2", 1, 2, 4)
192 // Swaps the two items at the top of the stack.
193 OPDEF(OP_SWAP, 80, "swap", 1, 2, 2)
195 // Roll operation is the same as Forth. It steals a value on the stack,
196 // shifting all stack values down, and then places the stolen value back at
197 // the top of the stack.
203 OPDEF(OP_ROLL3, 81, "roll3", 1, 3, 3)
205 // Pick operation is the same as Forth. It pushes a copy of a slot at a
209 OPDEF(OP_PICK2, 82, "pick2", 1, 2, 3)
210 OPDEF(OP_PICK3, 83, "pick3", 1, 3, 4)
212 // Calls a native function. During the course of calling a native, arguments
213 // on the stack are re-pushed to match the cell-based native calling
214 // convention expected by ISourcePawnEngine.
216 // Unlike the normal CALL instruction, natives take truly variadic arguments
217 // and so we must specify the number of arguments. The format is:
219 // [u8 Opcode] [u32 Index] [u32 ArgCount]
221 OPDEF(OP_CALLNATIVE, 84, "callnative", 9, -1, 1)
223 // Returns from a function that does return a value.
224 OPDEF(OP_RETURNVOID, 85, "returnvoid", 1, 0, 0)
226 // Loads the module of the running function.
227 OPDEF(OP_MODULE, 86, "module", 1, 0, 1)
229 // Loads a function from a module object. The operand is the slot number
231 OPDEF(OP_GETMODULE_FN, 87, "getmodule.fn", 5, 1, 1)
233 // Opcodes for accessing an environment slot in the global scope.
234 OPDEF(OP_SETGLOBAL_I, 88, "setglobal.i", 5, 1, 1)
235 OPDEF(OP_SETGLOBAL_F, 89, "setglobal.f", 5, 1, 1)
236 OPDEF(OP_SETGLOBAL_O, 90, "setglobal.o", 5, 1, 1)
237 OPDEF(OP_GETGLOBAL_I, 91, "getglobal.i", 5, 0, 1)
238 OPDEF(OP_GETGLOBAL_F, 92, "getglobal.f", 5, 0, 1)
239 OPDEF(OP_GETGLOBAL_O, 93, "getglobal.o", 5, 0, 1)
241 // Reinterprets a 32-bit integer as a float, or vice-versa.
242 OPDEF(OP_BITS_I2F, 94, "bits.i2f", 1, 1, 1)
243 OPDEF(OP_BITS_F2I, 95, "bits.f2i", 1, 1, 1)
245 // Pushes a boolean value.
246 OPDEF(OP_TRUE, 96, "true", 1, 0, 1)
247 OPDEF(OP_FALSE, 97, "false", 1, 0, 1)
249 // Allocate a struct. The HeapTenure is stored as a byte following pc. The
250 // StructMap to use is specified as an index into the script's Map table.
253 // [u8 op] [u8 tenure] [u32 index]
254 OPDEF(OP_NEWSTRUCT, 98, "newstruct", 6, 0, 1)
256 // Performs a struct-to-struct assignment.
261 OPDEF(OP_COPYSTRUCT, 99, "structcopy", 1, 2, 1)
263 // Sets or gets a property in a struct. The index of the field is specified as
264 // a 32-bit integer. Note that these opcodes follow a new style of deriving
265 // their types at runtime.
266 OPDEF(OP_GETFIELD, 100, "getfield", 5, 1, 1)
267 OPDEF(OP_SETFIELD, 101, "setfield", 5, 2, 1)
269 OPDEF(OP_FIELDREF_LIFO, 102, "fieldref.lifo", 5, 1, 1)
272 // [u8 op] [i32 low] [i32 high] [u32 jump] [u32 jumps...]
273 OPDEF(OP_TABLESWITCH, 103, "tableswitch", 9, 1, 0)
