Home - sourcepawn2 - file revision - jitcraft/Opcodes.tbl@0784ac5cc347 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
jitcraft/Opcodes.tbl
author David Anderson <dvander@alliedmods.net>
Sat Jun 30 22:31:14 2012 -0700 (2012-06-30)
changeset 14 0784ac5cc347
parent 12 75e385f68b7e
child 17 8aa89dd41e25
permissions -rw-r--r--
Added support for non-array references. 
     1 /*
     2  * Copyright (C) 2012 David Anderson
     3  *
     4  * This file is part of JITCraft.
     5  *
     6  * JITCraft is free software: you can redistribute it and/or modify it under
     7  * the terms of the GNU General Public License as published by the Free
     8  * Software Foundation, either version 3 of the License, or (at your option)
     9  * any later version.
    10  * 
    11  * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY
    12  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    13  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
    14  *
    15  * You should have received a copy of the GNU General Public License along with
    16  * JITCraft. If not, see http://www.gnu.org/licenses/.
    17  */
    18 // Opcode macros:
    19 //  NAME            NUMBER      TEXT                LENGTH  USES  DEFS   
    20 //
    21 // Type suffixes:
    22 //  I = 32-bit integer
    23 //  P = reference to the UnsafeHeap or UnsafeStack
    24 
    25 // No operation.
    26 OPDEF(OP_NOP,           0,          "nop",          1,      0,  0)
    27 
    28 // Pushes a signed integer immediate onto the stack.
    29 OPDEF(OP_INT,           1,          "int",          5,      0,  1)    
    30 
    31 // Returns from the current routine, propagating the value at the top of the
    32 // stack to the caller.
    33 OPDEF(OP_RETURN,        2,          "return",       1,      1,  0)
    34 
    35 // Stack transitions for these comparison ops:
    36 // rhs = pop()
    37 // lhs = pop()
    38 // if (lhs COMPARE rhs)
    39 //    goto target (immediate, relative to the beginning of the jump instruction)
    40 OPDEF(OP_JL,            3,          "jl",           5,      2,  0)
    41 OPDEF(OP_JLE,           4,          "jle",          5,      2,  0)
    42 OPDEF(OP_JG,            5,          "jg",           5,      2,  0)
    43 OPDEF(OP_JGE,           6,          "jge",          5,      2,  0)
    44 OPDEF(OP_JEQ,           7,          "jeq",          5,      2,  0)
    45 OPDEF(OP_JNE,           8,          "jne",          5,      2,  0)
    46 
    47 // value = pop()
    48 // if (value == [true, false])
    49 //    goto target
    50 OPDEF(OP_JT,            9,          "jt",           5,      1,  0)
    51 OPDEF(OP_JF,            10,         "jf",           5,      1,  0)
    52 
    53 // Unconditional jump.
    54 OPDEF(OP_JUMP,          11,         "jump",         5,      0,  0)
    55 
    56 // Gets or sets the value of a local variable onto the stack. The local
    57 // variable is given by an immediate index.
    58 OPDEF(OP_GETLOCAL,      12,         "getlocal",     5,      0,  1)
    59 OPDEF(OP_SETLOCAL,      13,         "setlocal",     5,      1,  1)
    60 
    61 // Stack transitions for these binary operators:
    62 // rhs = pop()
    63 // lhs = pop()
    64 // push(lhs OP rhs)
    65 OPDEF(OP_ADD,           14,         "add",          1,      2,  1)
    66 OPDEF(OP_SUB,           15,         "sub",          1,      2,  1)
    67 OPDEF(OP_MUL,           16,         "mul",          1,      2,  1)
    68 OPDEF(OP_DIV,           17,         "div",          1,      2,  1)
    69 
    70 OPDEF(OP_POP,           18,         "pop",          1,      1,  0)
    71 
    72 // Unconditional terminator placed at the end of code.
    73 OPDEF(OP_STOP,          19,         "stop",         1,      0,  0)
    74 
    75 // Call a function with N arguments. Arguments are pushed in reverse order.
    76 //
    77 // CALLGLOBAL - followed by an extra immediate, containing the function index
    78 // in the code's global.
    79 OPDEF(OP_CALLGLOBAL,    20,         "callglobal",   9,      -1, 1)
    80 
    81 // Similar to GET/LOCAL, except for arguments.
    82 OPDEF(OP_GETARG,        21,         "getarg",       5,      0,  1)
    83 OPDEF(OP_SETARG,        22,         "setarg",       5,      1,  1)
    84 
    85 // Reads or writes an integer element to an unsafe array.
    86 //  index = pop()
    87 //  ref = pop()
    88 //  ref[index]
    89 //
    90 OPDEF(OP_GETARRAY_I,    23,         "getarray.i",   1,      2,  1)
    91 OPDEF(OP_SETARRAY_I,    24,         "setarray.i",   1,      3,  1)
    92 OPDEF(OP_GETARRAY_F,    25,         "getarray.f",   1,      2,  1)
    93 OPDEF(OP_SETARRAY_F,    26,         "setarray.f",   1,      3,  1)
    94 OPDEF(OP_GETARRAY_P,    27,         "getarray.p",   1,      2,  1)
    95 
    96 // Allocate an array, info LIFO space if possible. The ArrayMap to use is
    97 // specified as an index into the script's Map table.
    98 //
    99 // Format:
   100 //  [u8 op] [u32 index]
   101 OPDEF(OP_LIFOARRAY,     28,         "lifoarray",    5,      0,  1)
   102 
   103 // Performs a bounds check on an unsafe array.
   104 //
   105 // index = pop()
   106 // array = pop()
   107 // push(array)
   108 // push(index)
   109 OPDEF(OP_BOUNDS_STA,    29,         "bounds.sta",   1,      2,  2)
   110 
   111 // Pushes a 32-bit IEEE-754 floating point immediate onto the stack.
   112 OPDEF(OP_FLOAT,         30,         "float",        5,      0,  1)
   113 
   114 // Converts an integer to a 32-bit IEEE-754 floating point immediate.
   115 OPDEF(OP_CVT_I2F,       31,         "cvt.i2f",      1,      1,  1)
   116 
   117 // Stack transitions for these binary operators:
   118 // rhs = pop()
   119 // lhs = pop()
   120 // push(lhs OP rhs)
   121 OPDEF(OP_ADD_F,         32,         "add.f",        1,      2,  1)
   122 OPDEF(OP_SUB_F,         33,         "sub.f",        1,      2,  1)
   123 OPDEF(OP_MUL_F,         34,         "mul.f",        1,      2,  1)
   124 OPDEF(OP_DIV_F,         35,         "div.f",        1,      2,  1)
   125 
   126 // Bitwise operators.
   127 OPDEF(OP_SHL,           36,         "shl",          1,      2,  1)
   128 OPDEF(OP_SHR,           37,         "shr",          1,      2,  1)
   129 OPDEF(OP_USHR,          38,         "ushr",         1,      2,  1)
   130 OPDEF(OP_BITAND,        39,         "bitand",       1,      2,  1)
   131 OPDEF(OP_BITOR,         40,         "bitor",        1,      2,  1)
   132 OPDEF(OP_BITXOR,        41,         "bitxor",       1,      2,  1)
   133 
   134 // Saves or restores the position of the LIFO heap to/from a local slot.
   135 OPDEF(OP_SAVELIFO,      42,         "savelifo",     5,      0,  0)
   136 OPDEF(OP_UNWINDLIFO,    43,         "unwindlifo",   5,      0,  0)
   137 
   138 // Composes a variable reference to a stack slot or argument.
   139 OPDEF(OP_VARREF_LIFO,   44,         "varref.lifo",  5,      0,  1)
   140 OPDEF(OP_ARGREF_LIFO,   45,         "argref.lifo",  5,      0,  1)
   141 OPDEF(OP_SLOTREF_LIFO,  46,         "slotref.lifo", 1,      1,  1)
   142 OPDEF(OP_GETREF_I,      47,         "getref.i",     1,      1,  1)
   143 OPDEF(OP_SETREF_I,      48,         "setref.i",     1,      2,  1)
   144 OPDEF(OP_GETREF_F,      49,         "getref.f",     1,      1,  1)
   145 OPDEF(OP_SETREF_F,      50,         "setref.f",     1,      2,  1)
sourcepawn2
Feed