source.
Add sources for basic libjit opcodes and interpreter specific libjit
opcodes.
+2010-08-03 Klaus Treichel <ktreichel@web.de>
+
+ * Makefile.am: Add config to the subdirectories.
+
+ * configure.ac: Add config/Makefile the the makefiles to generate.
+
+ * include/jit/Makefile.am: Add jit-opcode.h to BUILT_SOURCES and
+ DISTCLEANFILES. Add the rule to generate jit-opcodes.h.
+
+ * include/jit/jit-opcode.h: Delete because it will be generated.
+
+ * jit/Makefile.am: Add jit-opcode.c, jit-interp-opcode.c and
+ jit-interp-opcode.h to BUILT_SOURCES.
+ Add jit-interp-opcode.c and jit-interp-opcode.h to libjit_la_SOURCES.
+ Add rules to generate jit-opcode.c, jit-interp-opcode.c and
+ jit-interp-opcode.h.
+ Adjust rule to generate jit-interp-labels.h.
+
+ * jit/jit-dump.c: Remove the extern declaration of the interpreter
+ opcode table.
+
+ * jit/jit-interp.h: Replace the opcode declaration by including
+ the generated file.
+
+ * jit/jit-opcode.c: Delete because its generated now.
+
+ * jit/jit-interp.c: Adjust names of interpreter specific opcodes.
+
+ * jit/jit-rules-interp.c: Likewise.
+
+ * jit/mklabel.sh: Adjust for opcode name change of interpreter
+ specific opcodes.
+
+ * tools/.gitignore: Add new built files.
+
+ * tools/Makefile.am: Add rules to build gen-ops.
+
+ * tools/gen-ops-parser.y, tools/gen-ops-scanner.l: Add opcode table
+ generator.
+
+ * config/Makefile.am: Added
+
+ * config/jit-opcodes.ops: Add definition source of the bastic
+ libjit opcodes.
+
+ * config/jit-interp-opcodes.ops: Add definition source of the
+ interpreter specific libjit opcodes.
+
2010-05-31 Aleksey Demakov <ademakov@gmail.com>
* jit/jit-block.c: allow empty block branch optimization for blocks
-SUBDIRS = include tools jit jitdynamic jitplus dpas tutorial tests doc
+SUBDIRS = config tools include jit jitdynamic jitplus dpas tutorial tests doc
--- /dev/null
+EXTRA_DIST = jit-opcodes.ops jit-interp-opcodes.ops
--- /dev/null
+%{
+/*
+ * jit-interp-opcode.c - Information about interpreter specific JIT opcodes.
+ *
+ * Copyright (C) 2004 Southern Storm Software, Pty Ltd.
+ *
+ * This file is part of the libjit library.
+ *
+ * The libjit library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * The libjit library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the libjit library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include "jit-internal.h"
+#include "jit-interp-opcode.h"
+#include "jit-rules.h"
+
+#if defined(JIT_BACKEND_INTERP)
+
+%}
+
+%[
+/*
+ * jit-interp-opcode.h - List of interpreter specific opcodes for
+ * JIT instructions.
+ *
+ * Copyright (C) 2004 Southern Storm Software, Pty Ltd.
+ *
+ * The libjit library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * The libjit library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the libjit library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _JIT_INTERP_OPCODE_H
+#define _JIT_INTERP_OPCODE_H
+
+#include <jit/jit-defs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+%]
+
+opcodes(JIT_INTERP_OP_,
+ "jit_opcode_info_t const _jit_interp_opcodes[JIT_INTERP_OP_NUM_OPCODES]",
+ "JIT_OP_NUM_OPCODES")
+{
+ /*
+ * Argument variable access opcodes.
+ */
+ op_def("lda_0_sbyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_0_ubyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_0_short") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_0_ushort") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_0_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_0_long") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_0_float32") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_0_float64") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_0_nfloat") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldaa_0") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_1_sbyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_1_ubyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_1_short") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_1_ushort") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_1_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_1_long") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_1_float32") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_1_float64") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_1_nfloat") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldaa_1") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_2_sbyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_2_ubyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_2_short") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_2_ushort") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_2_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_2_long") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_2_float32") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_2_float64") { "JIT_OPCODE_NINT_ARG" }
+ op_def("lda_2_nfloat") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldaa_2") { "JIT_OPCODE_NINT_ARG" }
+ op_def("sta_0_byte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("sta_0_short") { "JIT_OPCODE_NINT_ARG" }
+ op_def("sta_0_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("sta_0_long") { "JIT_OPCODE_NINT_ARG" }
+ op_def("sta_0_float32") { "JIT_OPCODE_NINT_ARG" }
+ op_def("sta_0_float64") { "JIT_OPCODE_NINT_ARG" }
+ op_def("sta_0_nfloat") { "JIT_OPCODE_NINT_ARG" }
+ /*
+ * Local variable frame access opcodes.
+ */
+ op_def("ldl_0_sbyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_0_ubyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_0_short") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_0_ushort") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_0_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_0_long") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_0_float32") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_0_float64") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_0_nfloat") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldla_0") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_1_sbyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_1_ubyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_1_short") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_1_ushort") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_1_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_1_long") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_1_float32") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_1_float64") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_1_nfloat") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldla_1") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_2_sbyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_2_ubyte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_2_short") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_2_ushort") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_2_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_2_long") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_2_float32") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_2_float64") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldl_2_nfloat") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldla_2") { "JIT_OPCODE_NINT_ARG" }
+ op_def("stl_0_byte") { "JIT_OPCODE_NINT_ARG" }
+ op_def("stl_0_short") { "JIT_OPCODE_NINT_ARG" }
+ op_def("stl_0_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("stl_0_long") { "JIT_OPCODE_NINT_ARG" }
+ op_def("stl_0_float32") { "JIT_OPCODE_NINT_ARG" }
+ op_def("stl_0_float64") { "JIT_OPCODE_NINT_ARG" }
+ op_def("stl_0_nfloat") { "JIT_OPCODE_NINT_ARG" }
+ /*
+ * Load constant values.
+ */
+ op_def("ldc_0_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldc_1_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldc_2_int") { "JIT_OPCODE_NINT_ARG" }
+ op_def("ldc_0_long") { "JIT_OPCODE_CONST_LONG" }
+ op_def("ldc_1_long") { "JIT_OPCODE_CONST_LONG" }
+ op_def("ldc_2_long") { "JIT_OPCODE_CONST_LONG" }
+ op_def("ldc_0_float32") { "JIT_OPCODE_CONST_FLOAT32" }
+ op_def("ldc_1_float32") { "JIT_OPCODE_CONST_FLOAT32" }
+ op_def("ldc_2_float32") { "JIT_OPCODE_CONST_FLOAT32" }
+ op_def("ldc_0_float64") { "JIT_OPCODE_CONST_FLOAT64" }
+ op_def("ldc_1_float64") { "JIT_OPCODE_CONST_FLOAT64" }
+ op_def("ldc_2_float64") { "JIT_OPCODE_CONST_FLOAT64" }
+ op_def("ldc_0_nfloat") { "JIT_OPCODE_CONST_NFLOAT" }
+ op_def("ldc_1_nfloat") { "JIT_OPCODE_CONST_NFLOAT" }
+ op_def("ldc_2_nfloat") { "JIT_OPCODE_CONST_NFLOAT" }
+ /*
+ * Load return value.
+ */
+ op_def("ldr_0_int") { }
+ op_def("ldr_0_long") { }
+ op_def("ldr_0_float32") { }
+ op_def("ldr_0_float64") { }
+ op_def("ldr_0_nfloat") { }
+ /*
+ * Stack management.
+ */
+ op_def("pop") { }
+ op_def("pop_2") { }
+ op_def("pop_3") { }
+ /*
+ * Nested function call handling.
+ */
+ op_def("import_local") { "JIT_OPCODE_NINT_ARG_TWO" }
+ op_def("import_arg") { "JIT_OPCODE_NINT_ARG_TWO" }
+ /*
+ * Marker opcode for the end of a function.
+ */
+ op_def("end_marker") { }
+}
+
+%[
+
+/*
+ * Opcode version. Should be increased whenever new opcodes
+ * are added to this list or the public list in "jit-opcode.h".
+ * This value is written to ELF binaries, to ensure that code
+ * for one version of libjit is not inadvertantly used in another.
+ */
+#define JIT_OPCODE_VERSION 0
+
+/*
+ * Additional opcode definition flags.
+ */
+#define JIT_OPCODE_INTERP_ARGS_MASK 0x7E000000
+#define JIT_OPCODE_NINT_ARG 0x02000000
+#define JIT_OPCODE_NINT_ARG_TWO 0x04000000
+#define JIT_OPCODE_CONST_LONG 0x06000000
+#define JIT_OPCODE_CONST_FLOAT32 0x08000000
+#define JIT_OPCODE_CONST_FLOAT64 0x0A000000
+#define JIT_OPCODE_CONST_NFLOAT 0x0C000000
+#define JIT_OPCODE_CALL_INDIRECT_ARGS 0x0E000000
+
+extern jit_opcode_info_t const _jit_interp_opcodes[JIT_INTERP_OP_NUM_OPCODES];
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* _JIT_INTERP_OPCODE_H */
+%]
+
+%{
+#endif /* defined(JIT_BACKEND_INTERP) */
+%}
--- /dev/null
+%{
+/*
+ * jit-opcode.c - Information about all of the JIT opcodes.
+ *
+ * Copyright (C) 2004 Southern Storm Software, Pty Ltd.
+ *
+ * This file is part of the libjit library.
+ *
+ * The libjit library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * The libjit library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the libjit library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include "jit-internal.h"
+#include "jit-rules.h"
+
+#if defined(JIT_BACKEND_INTERP)
+ #define NINT_ARG JIT_OPCODE_NINT_ARG
+ #define NINT_ARG_TWO JIT_OPCODE_NINT_ARG_TWO
+ #define INDIRECT_ARGS JIT_OPCODE_CALL_INDIRECT_ARGS
+#else
+ #define NINT_ARG 0
+ #define NINT_ARG_TWO 0
+ #define INDIRECT_ARGS 0
+#endif
+
+%}
+
+%[
+/*
+ * jit-opcode.h - List of primitive opcodes for JIT instructions.
+ *
+ * Copyright (C) 2004 Southern Storm Software, Pty Ltd.
+ *
+ * The libjit library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * The libjit library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the libjit library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _JIT_OPCODE_H
+#define _JIT_OPCODE_H
+
+#include <jit/jit-defs.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+%]
+
+opcodes(JIT_OP_, "jit_opcode_info_t const jit_opcodes[JIT_OP_NUM_OPCODES]")
+{
+ op_def("nop") { }
+ /*
+ * Conversion opcodes
+ */
+ op_def("trunc_sbyte") { op_values(int, int) }
+ op_def("trunc_ubyte") { op_values(int, int) }
+ op_def("trunc_short") { op_values(int, int) }
+ op_def("trunc_ushort") { op_values(int, int) }
+ op_def("trunc_int") { op_values(int, int) }
+ op_def("trunc_uint") { op_values(int, int) }
+ op_def("check_sbyte") { op_values(int, int) }
+ op_def("check_ubyte") { op_values(int, int) }
+ op_def("check_short") { op_values(int, int) }
+ op_def("check_ushort") { op_values(int, int) }
+ op_def("check_int") { op_values(int, int) }
+ op_def("check_uint") { op_values(int, int) }
+ op_def("low_word") { op_values(int, long) }
+ op_def("expand_int") { op_values(long, int) }
+ op_def("expand_uint") { op_values(long, int) }
+ op_def("check_low_word") { op_values(int, long) }
+ op_def("check_signed_low_word") { op_values(int, long) }
+ op_def("check_long") { op_values(long, long) }
+ op_def("check_ulong") { op_values(long, long) }
+ op_def("nfloat_to_int") { op_values(int, nfloat) }
+ op_def("nfloat_to_uint") { op_values(int, nfloat) }
+ op_def("nfloat_to_long") { op_values(long, nfloat) }
+ op_def("nfloat_to_ulong") { op_values(long, nfloat) }
+ op_def("check_nfloat_to_int") { op_values(int, nfloat) }
+ op_def("check_nfloat_to_uint") { op_values(int, nfloat) }
+ op_def("check_nfloat_to_long") { op_values(long, nfloat) }
+ op_def("check_nfloat_to_ulong") { op_values(long, nfloat) }
+ op_def("int_to_nfloat") { op_values(nfloat, int) }
+ op_def("uint_to_nfloat") { op_values(nfloat, int) }
+ op_def("long_to_nfloat") { op_values(nfloat, long) }
+ op_def("ulong_to_nfloat") { op_values(nfloat, long) }
+ op_def("nfloat_to_float32") { op_values(float32, nfloat) }
+ op_def("nfloat_to_float64") { op_values(float64, nfloat) }
+ op_def("float32_to_nfloat") { op_values(nfloat, float32) }
+ op_def("float64_to_nfloat") { op_values(nfloat, float64) }
+ /*
+ * Arithmetic opcodes.
+ */
+ op_def("iadd", +) { op_values(int, int, int) }
+ op_def("iadd_ovf") { op_values(int, int, int) }
+ op_def("iadd_ovf_un") { op_values(int, int, int) }
+ op_def("isub", -) { op_values(int, int, int) }
+ op_def("isub_ovf") { op_values(int, int, int) }
+ op_def("isub_ovf_un") { op_values(int, int, int) }
+ op_def("imul", *) { op_values(int, int, int) }
+ op_def("imul_ovf") { op_values(int, int, int) }
+ op_def("imul_ovf_un") { op_values(int, int, int) }
+ op_def("idiv", /) { op_values(int, int, int) }
+ op_def("idiv_un") { op_values(int, int, int) }
+ op_def("irem", %) { op_values(int, int, int) }
+ op_def("irem_un") { op_values(int, int, int) }
+ op_def("ineg", neg) { op_values(int, int) }
+ op_def("ladd", +) { op_values(long, long, long) }
+ op_def("ladd_ovf") { op_values(long, long, long) }
+ op_def("ladd_ovf_un") { op_values(long, long, long) }
+ op_def("lsub", -) { op_values(long, long, long) }
+ op_def("lsub_ovf") { op_values(long, long, long) }
+ op_def("lsub_ovf_un") { op_values(long, long, long) }
+ op_def("lmul", *) { op_values(long, long, long) }
+ op_def("lmul_ovf") { op_values(long, long, long) }
+ op_def("lmul_ovf_un") { op_values(long, long, long) }
+ op_def("ldiv", /) { op_values(long, long, long) }
+ op_def("ldiv_un") { op_values(long, long, long) }
+ op_def("lrem", %) { op_values(long, long, long) }
+ op_def("lrem_un") { op_values(long, long, long) }
+ op_def("lneg", neg) { op_values(long, long) }
+ op_def("fadd", +) { op_values(float32, float32, float32) }
+ op_def("fsub", -) { op_values( float32, float32, float32) }
+ op_def("fmul", *) { op_values(float32, float32, float32) }
+ op_def("fdiv", /) { op_values(float32, float32, float32) }
+ op_def("frem", %) { op_values(float32, float32, float32) }
+ op_def("frem_ieee") { op_values(float32, float32, float32) }
+ op_def("fneg", neg) { op_values(float32, float32) }
+ op_def("dadd", +) { op_values(float64, float64, float64) }
+ op_def("dsub", -) { op_values(float64, float64, float64) }
+ op_def("dmul", *) { op_values(float64, float64, float64) }
+ op_def("ddiv", /) { op_values(float64, float64, float64) }
+ op_def("drem", %) { op_values(float64, float64, float64) }
+ op_def("drem_ieee") { op_values(float64, float64, float64) }
+ op_def("dneg", neg) { op_values(float64, float64) }
+ op_def("nfadd", +) { op_values(nfloat, nfloat, nfloat) }
+ op_def("nfsub", -) { op_values(nfloat, nfloat, nfloat) }
+ op_def("nfmul", *) { op_values(nfloat, nfloat, nfloat) }
+ op_def("nfdiv", /) { op_values(nfloat, nfloat, nfloat) }
+ op_def("nfrem", %) { op_values(nfloat, nfloat, nfloat) }
+ op_def("nfrem_ieee") { op_values(nfloat, nfloat, nfloat) }
+ op_def("nfneg", neg) { op_values(nfloat, nfloat) }
+ /*
+ * Bitwise opcodes.
+ */
+ op_def("iand", &) { op_values(int, int, int) }
+ op_def("ior", |) { op_values(int, int, int) }
+ op_def("ixor", ^) { op_values(int, int, int) }
+ op_def("inot", ~) { op_values(int, int) }
+ op_def("ishl", <<) { op_values(int, int, int) }
+ op_def("ishr", >>) { op_values(int, int, int) }
+ op_def("ishr_un", shr_un) { op_values(int, int, int) }
+ op_def("land", &) { op_values(long, long, long) }
+ op_def("lor", |) { op_values(long, long, long) }
+ op_def("lxor", ^) { op_values(long, long, long) }
+ op_def("lnot", ~) { op_values(long, long) }
+ op_def("lshl", <<) { op_values(long, long, int) }
+ op_def("lshr", >>) { op_values(long, long, int) }
+ op_def("lshr_un", shr_un) { op_values(long, long, int) }
+ /*
+ * Branch opcodes.
+ */
+ op_def("br") { op_type(branch) }
+ op_def("br_ifalse") { op_type(branch), op_values(empty, int) }
+ op_def("br_itrue") { op_type(branch), op_values(empty, int) }
+ op_def("br_ieq", ==) { op_type(branch), op_values(empty, int, int) }
+ op_def("br_ine", !=) { op_type(branch), op_values(empty, int, int) }
+ op_def("br_ilt", <) { op_type(branch), op_values(empty, int, int) }
+ op_def("br_ilt_un") { op_type(branch), op_values(empty, int, int) }
+ op_def("br_ile", <=) { op_type(branch), op_values(empty, int, int) }
+ op_def("br_ile_un") { op_type(branch), op_values(empty, int, int) }
+ op_def("br_igt", >) { op_type(branch), op_values(empty, int, int) }
+ op_def("br_igt_un") { op_type(branch), op_values(empty, int, int) }
+ op_def("br_ige", >=) { op_type(branch), op_values(empty, int, int) }
+ op_def("br_ige_un") { op_type(branch), op_values(empty, int, int) }
+ op_def("br_lfalse") { op_type(branch), op_values(empty, long) }
+ op_def("br_ltrue") { op_type(branch), op_values(empty, long) }
+ op_def("br_leq", ==) { op_type(branch), op_values(empty, long, long) }
+ op_def("br_lne", !=) { op_type(branch), op_values(empty, long, long) }
+ op_def("br_llt", <) { op_type(branch), op_values(empty, long, long) }
+ op_def("br_llt_un") { op_type(branch), op_values(empty, long, long) }
+ op_def("br_lle", <=) { op_type(branch), op_values(empty, long, long) }
+ op_def("br_lle_un") { op_type(branch), op_values(empty, long, long) }
+ op_def("br_lgt", >) { op_type(branch), op_values(empty, long, long) }
+ op_def("br_lgt_un") { op_type(branch), op_values(empty, long, long) }
+ op_def("br_lge", >=) { op_type(branch), op_values(empty, long, long) }
+ op_def("br_lge_un") { op_type(branch), op_values(empty, long, long) }
+ op_def("br_feq", ==) { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_fne", !=) { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_flt", <) { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_fle", <=) { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_fgt", >) { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_fge", >=) { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_feq_inv") { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_fne_inv") { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_flt_inv") { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_fle_inv") { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_fgt_inv") { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_fge_inv") { op_type(branch), op_values(empty, float32, float32) }
+ op_def("br_deq", ==) { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dne", !=) { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dlt", <) { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dle", <=) { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dgt", >) { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dge", >=) { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_deq_inv") { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dne_inv") { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dlt_inv") { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dle_inv") { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dgt_inv") { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_dge_inv") { op_type(branch), op_values(empty, float64, float64) }
+ op_def("br_nfeq", ==) { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nfne", !=) { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nflt", <) { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nfle", <=) { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nfgt", >) { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nfge", >=) { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nfeq_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nfne_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nflt_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nfle_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nfgt_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
+ op_def("br_nfge_inv") { op_type(branch), op_values(empty, nfloat, nfloat) }
+ /*
+ * Comparison opcodes.
+ */
+ op_def("icmp") { op_values(int, int, int) }
+ op_def("icmp_un") { op_values(int, int, int) }
+ op_def("lcmp") { op_values(int, long, long) }
+ op_def("lcmp_un") { op_values(int, long, long) }
+ op_def("fcmpl") { op_values(int, float32, float32) }
+ op_def("fcmpg") { op_values(int, float32, float32) }
+ op_def("dcmpl") { op_values(int, float64, float64) }
+ op_def("dcmpg") { op_values(int, float64, float64) }
+ op_def("nfcmpl") { op_values(int, nfloat, nfloat) }
+ op_def("nfcmpg") { op_values(int, nfloat, nfloat) }
+ op_def("ieq", ==) { op_values(int, int, int) }
+ op_def("ine", !=) { op_values(int, int, int) }
+ op_def("ilt", <) { op_values(int, int, int) }
+ op_def("ilt_un") { op_values(int, int, int) }
+ op_def("ile", <=) { op_values(int, int, int) }
+ op_def("ile_un") { op_values(int, int, int) }
+ op_def("igt", >) { op_values(int, int, int) }
+ op_def("igt_un") { op_values(int, int, int) }
+ op_def("ige", >=) { op_values(int, int, int) }
+ op_def("ige_un") { op_values(int, int, int) }
+ op_def("leq", ==) { op_values(int, long, long) }
+ op_def("lne", !=) { op_values(int, long, long) }
+ op_def("llt", <) { op_values(int, long, long) }
+ op_def("llt_un") { op_values(int, long, long) }
+ op_def("lle", <=) { op_values(int, long, long) }
+ op_def("lle_un") { op_values(int, long, long) }
+ op_def("lgt", >) { op_values(int, long, long) }
+ op_def("lgt_un") { op_values(int, long, long) }
+ op_def("lge", >=) { op_values(int, long, long) }
+ op_def("lge_un") { op_values(int, long, long) }
+ op_def("feq", ==) { op_values(int, float32, float32) }
+ op_def("fne", !=) { op_values(int, float32, float32) }
+ op_def("flt", <) { op_values(int, float32, float32) }
+ op_def("fle", <=) { op_values(int, float32, float32) }
+ op_def("fgt", >) { op_values(int, float32, float32) }
+ op_def("fge", >=) { op_values(int, float32, float32) }
+ op_def("feq_inv") { op_values(int, float32, float32) }
+ op_def("fne_inv") { op_values(int, float32, float32) }
+ op_def("flt_inv") { op_values(int, float32, float32) }
+ op_def("fle_inv") { op_values(int, float32, float32) }
+ op_def("fgt_inv") { op_values(int, float32, float32) }
+ op_def("fge_inv") { op_values(int, float32, float32) }
+ op_def("deq", ==) { op_values(int, float64, float64) }
+ op_def("dne", !=) { op_values(int, float64, float64) }
+ op_def("dlt", <) { op_values(int, float64, float64) }
+ op_def("dle", <=) { op_values(int, float64, float64) }
+ op_def("dgt", >) { op_values(int, float64, float64) }
+ op_def("dge", >=) { op_values(int, float64, float64) }
+ op_def("deq_inv") { op_values(int, float64, float64) }
+ op_def("dne_inv") { op_values(int, float64, float64) }
+ op_def("dlt_inv") { op_values(int, float64, float64) }
+ op_def("dle_inv") { op_values(int, float64, float64) }
+ op_def("dgt_inv") { op_values(int, float64, float64) }
+ op_def("dge_inv") { op_values(int, float64, float64) }
+ op_def("nfeq", ==) { op_values(int, nfloat, nfloat) }
+ op_def("nfne", !=) { op_values(int, nfloat, nfloat) }
+ op_def("nflt", <) { op_values(int, nfloat, nfloat) }
+ op_def("nfle", <=) { op_values(int, nfloat, nfloat) }
+ op_def("nfgt", >) { op_values(int, nfloat, nfloat) }
+ op_def("nfge", >=) { op_values(int, nfloat, nfloat) }
+ op_def("nfeq_inv") { op_values(int, nfloat, nfloat) }
+ op_def("nfne_inv") { op_values(int, nfloat, nfloat) }
+ op_def("nflt_inv") { op_values(int, nfloat, nfloat) }
+ op_def("nfle_inv") { op_values(int, nfloat, nfloat) }
+ op_def("nfgt_inv") { op_values(int, nfloat, nfloat) }
+ op_def("nfge_inv") { op_values(int, nfloat, nfloat) }
+ op_def("is_fnan") { op_values(int, float32) }
+ op_def("is_finf") { op_values(int, float32) }
+ op_def("is_ffinite") { op_values(int, float32) }
+ op_def("is_dnan") { op_values(int, float64) }
+ op_def("is_dinf") { op_values(int, float64) }
+ op_def("is_dfinite") { op_values(int, float64) }
+ op_def("is_nfnan") { op_values(int, nfloat) }
+ op_def("is_nfinf") { op_values(int, nfloat) }
+ op_def("is_nffinite") { op_values(int, nfloat) }
+ /*
+ * Mathematical functions.
+ */
+ op_def("facos") { op_values(float32, float32) }
+ op_def("fasin") { op_values(float32, float32) }
+ op_def("fatan") { op_values(float32, float32) }
+ op_def("fatan2") { op_values(float32, float32, float32) }
+ op_def("fceil") { op_values(float32, float32) }
+ op_def("fcos") { op_values(float32, float32) }
+ op_def("fcosh") { op_values(float32, float32) }
+ op_def("fexp") { op_values(float32, float32) }
+ op_def("ffloor") { op_values(float32, float32) }
+ op_def("flog") { op_values(float32, float32) }
+ op_def("flog10") { op_values(float32, float32) }
+ op_def("fpow") { op_values(float32, float32, float32) }
+ op_def("frint") { op_values(float32, float32) }
+ op_def("fround") { op_values(float32, float32) }
+ op_def("fsin") { op_values(float32, float32) }
+ op_def("fsinh") { op_values(float32, float32) }
+ op_def("fsqrt") { op_values(float32, float32) }
+ op_def("ftan") { op_values(float32, float32) }
+ op_def("ftanh") { op_values(float32, float32) }
+ op_def("dacos") { op_values(float64, float64) }
+ op_def("dasin") { op_values(float64, float64) }
+ op_def("datan") { op_values(float64, float64) }
+ op_def("datan2") { op_values(float64, float64, float64)}
+ op_def("dceil") { op_values(float64, float64) }
+ op_def("dcos") { op_values(float64, float64) }
+ op_def("dcosh") { op_values(float64, float64) }
+ op_def("dexp") { op_values(float64, float64) }
+ op_def("dfloor") { op_values(float64, float64) }
+ op_def("dlog") { op_values(float64, float64) }
+ op_def("dlog10") { op_values(float64, float64) }
+ op_def("dpow") { op_values(float64, float64, float64) }
+ op_def("drint") { op_values(float64, float64) }
+ op_def("dround") { op_values(float64, float64) }
+ op_def("dsin") { op_values(float64, float64) }
+ op_def("dsinh") { op_values(float64, float64) }
+ op_def("dsqrt") { op_values(float64, float64) }
+ op_def("dtan") { op_values(float64, float64) }
+ op_def("dtanh") { op_values(float64, float64) }
+ op_def("nfacos") { op_values(nfloat, nfloat) }
+ op_def("nfasin") { op_values(nfloat, nfloat) }
+ op_def("nfatan") { op_values(nfloat, nfloat) }
+ op_def("nfatan2") { op_values(nfloat, nfloat, nfloat) }
+ op_def("nfceil") { op_values(nfloat, nfloat) }
+ op_def("nfcos") { op_values(nfloat, nfloat) }
+ op_def("nfcosh") { op_values(nfloat, nfloat) }
+ op_def("nfexp") { op_values(nfloat, nfloat) }
+ op_def("nffloor") { op_values(nfloat, nfloat) }
+ op_def("nflog") { op_values(nfloat, nfloat) }
+ op_def("nflog10") { op_values(nfloat, nfloat) }
+ op_def("nfpow") { op_values(nfloat, nfloat, nfloat) }
+ op_def("nfrint") { op_values(nfloat, nfloat) }
+ op_def("nfround") { op_values(nfloat, nfloat) }
+ op_def("nfsin") { op_values(nfloat, nfloat) }
+ op_def("nfsinh") { op_values(nfloat, nfloat) }
+ op_def("nfsqrt") { op_values(nfloat, nfloat) }
+ op_def("nftan") { op_values(nfloat, nfloat) }
+ op_def("nftanh") { op_values(nfloat, nfloat) }
+ /*
+ * Absolute, minimum, maximum, and sign.
+ */
+ op_def("iabs") { op_values(int, int) }
+ op_def("labs") { op_values(long, long) }
+ op_def("fabs") { op_values(float32, float32) }
+ op_def("dabs") { op_values(float64, float64) }
+ op_def("nfabs") { op_values(nfloat, nfloat) }
+ op_def("imin") { op_values(int, int, int) }
+ op_def("imin_un") { op_values(int, int, int) }
+ op_def("lmin") { op_values(long, long, long) }
+ op_def("lmin_un") { op_values(long, long, long) }
+ op_def("fmin") { op_values(float32, float32, float32) }
+ op_def("dmin") { op_values(float64, float64, float64) }
+ op_def("nfmin") { op_values(nfloat, nfloat, nfloat) }
+ op_def("imax") { op_values(int, int, int) }
+ op_def("imax_un") { op_values(int, int, int) }
+ op_def("lmax") { op_values(long, long, long) }
+ op_def("lmax_un") { op_values(long, long, long) }
+ op_def("fmax") { op_values(float32, float32, float32) }
+ op_def("dmax") { op_values(float64, float64, float64) }
+ op_def("nfmax") { op_values(nfloat, nfloat, nfloat) }
+ op_def("isign") { op_values(int, int) }
+ op_def("lsign") { op_values(int, long) }
+ op_def("fsign") { op_values(int, float32) }
+ op_def("dsign") { op_values(int, float64) }
+ op_def("nfsign") { op_values(int, nfloat) }
+ /*
+ * Pointer check opcodes.
+ */
+ op_def("check_null") { op_values(empty, ptr) }
+ /*
+ * Function calls.
+ */
+ op_def("call") { op_type(call) }
+ op_def("call_tail") { op_type(call) }
+ op_def("call_indirect") { op_values(empty, ptr), "INDIRECT_ARGS" }
+ op_def("call_indirect_tail") { op_values(empty, ptr), "INDIRECT_ARGS" }
+ op_def("call_vtable_ptr") { op_values(empty, ptr) }
+ op_def("call_vtable_ptr_tail") { op_values(empty, ptr) }
+ op_def("call_external") { op_type(call_external) }
+ op_def("call_external_tail") { op_type(call_external) }
+ op_def("return") { }
+ op_def("return_int") { op_values(empty, int) }
+ op_def("return_long") { op_values(empty, long) }
+ op_def("return_float32") { op_values(empty, float32) }
+ op_def("return_float64") { op_values(empty, float64) }
+ op_def("return_nfloat") { op_values(empty, nfloat) }
+ op_def("return_small_struct") { op_values(empty, ptr, ptr), "NINT_ARG" }
+ op_def("setup_for_nested") { op_values(empty, int) }
+ op_def("setup_for_sibling") { op_values(empty, int, int), "NINT_ARG" }
+ op_def("import") { op_values(ptr, any, int) }
+ /*
+ * Exception handling.
+ */
+ op_def("throw") { op_values(empty, ptr) }
+ op_def("rethrow") { op_values(empty, ptr) }
+ op_def("load_pc") { op_values(ptr) }
+ op_def("load_exception_pc") { op_values(ptr) }
+ op_def("enter_finally") { }
+ op_def("leave_finally") { }
+ op_def("call_finally") { op_type(branch) }
+ op_def("enter_filter") { op_values(any) }
+ op_def("leave_filter") { op_values(empty, any) }
+ op_def("call_filter") { op_type(branch), op_values(empty, any) }
+ op_def("call_filter_return") { op_values(any) }
+ op_def("address_of_label") { op_type(address_of_label) }
+ /*
+ * Data manipulation.
+ */
+ op_def("copy_load_sbyte") { op_values(int, int) }
+ op_def("copy_load_ubyte") { op_values(int, int) }
+ op_def("copy_load_short") { op_values(int, int) }
+ op_def("copy_load_ushort") { op_values(int, int) }
+ op_def("copy_int", =) { op_values(int, int) }
+ op_def("copy_long", =) { op_values(long, long) }
+ op_def("copy_float32", =) { op_values(float32, float32) }
+ op_def("copy_float64", =) { op_values(float64, float64) }
+ op_def("copy_nfloat", =) { op_values(nfloat, nfloat) }
+ op_def("copy_struct", =) { op_values(ptr, ptr), "NINT_ARG" }
+ op_def("copy_store_byte") { op_values(int, int) }
+ op_def("copy_store_short") { op_values(int, int) }
+ op_def("address_of", address_of) { op_values(ptr) }
+ /*
+ * Incoming registers, outgoing registers, and stack pushes.
+ */
+ op_def("incoming_reg") { op_type(reg) }
+ op_def("incoming_frame_posn") { op_values(empty, any, int) }
+ op_def("outgoing_reg") { op_type(reg) }
+ op_def("outgoing_frame_posn") { op_values(empty, any, int) }
+ op_def("return_reg") { op_type(reg) }
+ op_def("push_int") { op_values(empty, int) }
+ op_def("push_long") { op_values(empty, long) }
+ op_def("push_float32") { op_values(empty, float32) }
+ op_def("push_float64") { op_values(empty, float64) }
+ op_def("push_nfloat") { op_values(empty, nfloat) }
+ op_def("push_struct") { op_values(empty, any, ptr), "NINT_ARG" }
+ op_def("pop_stack") { op_values(empty, int), "NINT_ARG" }
+ op_def("flush_small_struct") { op_values(empty, any), "NINT_ARG" }
+ op_def("set_param_int") { op_values(empty, int, ptr) }
+ op_def("set_param_long") { op_values(empty, long, ptr) }
+ op_def("set_param_float32") { op_values(empty, float32, ptr) }
+ op_def("set_param_float64") { op_values(empty, float64, ptr) }
+ op_def("set_param_nfloat") { op_values(empty, nfloat, ptr) }
+ op_def("set_param_struct") { op_values(ptr, ptr, ptr) }
+ op_def("push_return_area_ptr") { }
+ /*
+ * Pointer-relative loads and stores.
+ */
+ op_def("load_relative_sbyte") { op_values(int, ptr, int), "NINT_ARG" }
+ op_def("load_relative_ubyte") { op_values(int, ptr, int), "NINT_ARG" }
+ op_def("load_relative_short") { op_values(int, ptr, int), "NINT_ARG" }
+ op_def("load_relative_ushort") { op_values(int, ptr, int), "NINT_ARG" }
+ op_def("load_relative_int") { op_values(int, ptr, int), "NINT_ARG" }
+ op_def("load_relative_long") { op_values(long, ptr, int), "NINT_ARG" }
+ op_def("load_relative_float32") { op_values(float32, ptr, int), "NINT_ARG" }
+ op_def("load_relative_float64") { op_values(float64, ptr, int), "NINT_ARG" }
+ op_def("load_relative_nfloat") { op_values(nfloat, ptr, int), "NINT_ARG" }
+ op_def("load_relative_struct") { op_values(any, ptr, int), "NINT_ARG_TWO" }
+ op_def("store_relative_byte") { op_values(ptr, int, int), "NINT_ARG" }
+ op_def("store_relative_short") { op_values(ptr, int, int), "NINT_ARG" }
+ op_def("store_relative_int") { op_values(ptr, int, int), "NINT_ARG"}
+ op_def("store_relative_long") { op_values(ptr, long, int), "NINT_ARG" }
+ op_def("store_relative_float32") { op_values(ptr, float32, int), "NINT_ARG" }
+ op_def("store_relative_float64") { op_values(ptr, float64, int), "NINT_ARG" }
+ op_def("store_relative_nfloat") { op_values(ptr, nfloat, int), "NINT_ARG" }
+ op_def("store_relative_struct") { op_values(ptr, any, int), "NINT_ARG_TWO" }
+ op_def("add_relative") { op_values(ptr, ptr, int), "NINT_ARG" }
+ /*
+ * Array element loads and stores.
+ */
+ op_def("load_element_sbyte") { op_values(int, ptr, int) }
+ op_def("load_element_ubyte") { op_values(int, ptr, int) }
+ op_def("load_element_short") { op_values(int, ptr, int) }
+ op_def("load_element_ushort") { op_values(int, ptr, int) }
+ op_def("load_element_int") { op_values(int, ptr, int) }
+ op_def("load_element_long") { op_values(long, ptr, int) }
+ op_def("load_element_float32") { op_values(float32, ptr, int) }
+ op_def("load_element_float64") { op_values(float64, ptr, int) }
+ op_def("load_element_nfloat") { op_values(nfloat, ptr, int) }
+ op_def("store_element_byte") { op_values(ptr, int, int) }
+ op_def("store_element_short") { op_values(ptr, int, int) }
+ op_def("store_element_int") { op_values(ptr, int, int) }
+ op_def("store_element_long") { op_values(ptr, int, long) }
+ op_def("store_element_float32") { op_values(ptr, int, float32) }
+ op_def("store_element_float64") { op_values(ptr, int, float64) }
+ op_def("store_element_nfloat") { op_values(ptr, int, nfloat) }
+ /*
+ * Block operations.
+ */
+ op_def("memcpy") { op_values(ptr, ptr, ptr) }
+ op_def("memmove") { op_values(ptr, ptr, ptr) }
+ op_def("memset") { op_values(ptr, int, ptr) }
+ /*
+ * Allocate memory from the stack.
+ */
+ op_def("alloca") { op_values(ptr, ptr) }
+ /*
+ * Debugging support.
+ */
+ op_def("mark_offset") { op_values(empty, int) }
+ op_def("mark_breakpoint") { op_values(empty, ptr, ptr) }
+ /*
+ * Switch statement support.
+ */
+ op_def("jump_table") { op_type(jump_table), op_values(empty, ptr, int) }
+}
+
+%[
+/*
+ * Opcode information.
+ */
+typedef struct jit_opcode_info jit_opcode_info_t;
+struct jit_opcode_info
+{
+ const char *name;
+ int flags;
+};
+#define JIT_OPCODE_DEST_MASK 0x0000000F
+#define JIT_OPCODE_DEST_EMPTY 0x00000000
+#define JIT_OPCODE_DEST_INT 0x00000001
+#define JIT_OPCODE_DEST_LONG 0x00000002
+#define JIT_OPCODE_DEST_FLOAT32 0x00000003
+#define JIT_OPCODE_DEST_FLOAT64 0x00000004
+#define JIT_OPCODE_DEST_NFLOAT 0x00000005
+#define JIT_OPCODE_DEST_ANY 0x00000006
+#define JIT_OPCODE_SRC1_MASK 0x000000F0
+#define JIT_OPCODE_SRC1_EMPTY 0x00000000
+#define JIT_OPCODE_SRC1_INT 0x00000010
+#define JIT_OPCODE_SRC1_LONG 0x00000020
+#define JIT_OPCODE_SRC1_FLOAT32 0x00000030
+#define JIT_OPCODE_SRC1_FLOAT64 0x00000040
+#define JIT_OPCODE_SRC1_NFLOAT 0x00000050
+#define JIT_OPCODE_SRC1_ANY 0x00000060
+#define JIT_OPCODE_SRC2_MASK 0x00000F00
+#define JIT_OPCODE_SRC2_EMPTY 0x00000000
+#define JIT_OPCODE_SRC2_INT 0x00000100
+#define JIT_OPCODE_SRC2_LONG 0x00000200
+#define JIT_OPCODE_SRC2_FLOAT32 0x00000300
+#define JIT_OPCODE_SRC2_FLOAT64 0x00000400
+#define JIT_OPCODE_SRC2_NFLOAT 0x00000500
+#define JIT_OPCODE_SRC2_ANY 0x00000600
+#define JIT_OPCODE_IS_BRANCH 0x00001000
+#define JIT_OPCODE_IS_CALL 0x00002000
+#define JIT_OPCODE_IS_CALL_EXTERNAL 0x00004000
+#define JIT_OPCODE_IS_REG 0x00008000
+#define JIT_OPCODE_IS_ADDROF_LABEL 0x00010000
+#define JIT_OPCODE_IS_JUMP_TABLE 0x00020000
+#define JIT_OPCODE_OPER_MASK 0x01F00000
+#define JIT_OPCODE_OPER_NONE 0x00000000
+#define JIT_OPCODE_OPER_ADD 0x00100000
+#define JIT_OPCODE_OPER_SUB 0x00200000
+#define JIT_OPCODE_OPER_MUL 0x00300000
+#define JIT_OPCODE_OPER_DIV 0x00400000
+#define JIT_OPCODE_OPER_REM 0x00500000
+#define JIT_OPCODE_OPER_NEG 0x00600000
+#define JIT_OPCODE_OPER_AND 0x00700000
+#define JIT_OPCODE_OPER_OR 0x00800000
+#define JIT_OPCODE_OPER_XOR 0x00900000
+#define JIT_OPCODE_OPER_NOT 0x00A00000
+#define JIT_OPCODE_OPER_EQ 0x00B00000
+#define JIT_OPCODE_OPER_NE 0x00C00000
+#define JIT_OPCODE_OPER_LT 0x00D00000
+#define JIT_OPCODE_OPER_LE 0x00E00000
+#define JIT_OPCODE_OPER_GT 0x00F00000
+#define JIT_OPCODE_OPER_GE 0x01000000
+#define JIT_OPCODE_OPER_SHL 0x01100000
+#define JIT_OPCODE_OPER_SHR 0x01200000
+#define JIT_OPCODE_OPER_SHR_UN 0x01300000
+#define JIT_OPCODE_OPER_COPY 0x01400000
+#define JIT_OPCODE_OPER_ADDRESS_OF 0x01500000
+#ifdef JIT_NATIVE_INT32
+#define JIT_OPCODE_DEST_PTR JIT_OPCODE_DEST_INT
+#define JIT_OPCODE_SRC1_PTR JIT_OPCODE_SRC1_INT
+#define JIT_OPCODE_SRC2_PTR JIT_OPCODE_SRC2_INT
+#else
+#define JIT_OPCODE_DEST_PTR JIT_OPCODE_DEST_LONG
+#define JIT_OPCODE_SRC1_PTR JIT_OPCODE_SRC1_LONG
+#define JIT_OPCODE_SRC2_PTR JIT_OPCODE_SRC2_LONG
+#endif
+JIT_EXPORT_DATA jit_opcode_info_t const jit_opcodes[JIT_OP_NUM_OPCODES];
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif /* _JIT_OPCODE_H */
+%]
AC_CONFIG_FILES([
Makefile
+ config/Makefile
include/Makefile
include/jit/Makefile
include/jit/jit-defs.h
ARCH_HEADER = jit-arch-@JIT_ARCH@.h
-BUILT_SOURCES = jit-arch.h
+BUILT_SOURCES = jit-arch.h jit-opcode.h
libjitincludedir = $(includedir)/jit
libjitinclude_HEADERS = \
noinst_HEADERS = jit-arch-generic.h jit-arch-x86.h jit-arch-x86-64.h
-DISTCLEANFILES = jit-arch.h jit-defs.h
+DISTCLEANFILES = jit-arch.h jit-defs.h jit-opcode.h
jit-arch.h: $(ARCH_HEADER)
rm -f $@
$(LN_S) $(srcdir)/$(ARCH_HEADER) $@
+
+jit-opcode.h: $(top_srcdir)/config/jit-opcodes.ops
+ $(top_builddir)/tools/gen-ops -H $(top_srcdir)/config/jit-opcodes.ops >jit-opcode.h
+++ /dev/null
-/*
- * jit-opcode.h - List of primitive opcodes for JIT instructions.
- *
- * Copyright (C) 2004 Southern Storm Software, Pty Ltd.
- *
- * The libjit library is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * The libjit library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with the libjit library. If not, see
- * <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _JIT_OPCODE_H
-#define _JIT_OPCODE_H
-
-#include <jit/jit-defs.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Simple opcodes.
- */
-#define JIT_OP_NOP 0x0000
-
-/*
- * Conversion opcodes.
- */
-#define JIT_OP_TRUNC_SBYTE 0x0001
-#define JIT_OP_TRUNC_UBYTE 0x0002
-#define JIT_OP_TRUNC_SHORT 0x0003
-#define JIT_OP_TRUNC_USHORT 0x0004
-#define JIT_OP_TRUNC_INT 0x0005
-#define JIT_OP_TRUNC_UINT 0x0006
-#define JIT_OP_CHECK_SBYTE 0x0007
-#define JIT_OP_CHECK_UBYTE 0x0008
-#define JIT_OP_CHECK_SHORT 0x0009
-#define JIT_OP_CHECK_USHORT 0x000A
-#define JIT_OP_CHECK_INT 0x000B
-#define JIT_OP_CHECK_UINT 0x000C
-#define JIT_OP_LOW_WORD 0x000D
-#define JIT_OP_EXPAND_INT 0x000E
-#define JIT_OP_EXPAND_UINT 0x000F
-#define JIT_OP_CHECK_LOW_WORD 0x0010
-#define JIT_OP_CHECK_SIGNED_LOW_WORD 0x0011
-#define JIT_OP_CHECK_LONG 0x0012
-#define JIT_OP_CHECK_ULONG 0x0013
-#define JIT_OP_NFLOAT_TO_INT 0x0014
-#define JIT_OP_NFLOAT_TO_UINT 0x0015
-#define JIT_OP_NFLOAT_TO_LONG 0x0016
-#define JIT_OP_NFLOAT_TO_ULONG 0x0017
-#define JIT_OP_CHECK_NFLOAT_TO_INT 0x0018
-#define JIT_OP_CHECK_NFLOAT_TO_UINT 0x0019
-#define JIT_OP_CHECK_NFLOAT_TO_LONG 0x001A
-#define JIT_OP_CHECK_NFLOAT_TO_ULONG 0x001B
-#define JIT_OP_INT_TO_NFLOAT 0x001C
-#define JIT_OP_UINT_TO_NFLOAT 0x001D
-#define JIT_OP_LONG_TO_NFLOAT 0x001E
-#define JIT_OP_ULONG_TO_NFLOAT 0x001F
-#define JIT_OP_NFLOAT_TO_FLOAT32 0x0020
-#define JIT_OP_NFLOAT_TO_FLOAT64 0x0021
-#define JIT_OP_FLOAT32_TO_NFLOAT 0x0022
-#define JIT_OP_FLOAT64_TO_NFLOAT 0x0023
-
-/*
- * Arithmetic opcodes.
- */
-#define JIT_OP_IADD 0x0024
-#define JIT_OP_IADD_OVF 0x0025
-#define JIT_OP_IADD_OVF_UN 0x0026
-#define JIT_OP_ISUB 0x0027
-#define JIT_OP_ISUB_OVF 0x0028
-#define JIT_OP_ISUB_OVF_UN 0x0029
-#define JIT_OP_IMUL 0x002A
-#define JIT_OP_IMUL_OVF 0x002B
-#define JIT_OP_IMUL_OVF_UN 0x002C
-#define JIT_OP_IDIV 0x002D
-#define JIT_OP_IDIV_UN 0x002E
-#define JIT_OP_IREM 0x002F
-#define JIT_OP_IREM_UN 0x0030
-#define JIT_OP_INEG 0x0031
-#define JIT_OP_LADD 0x0032
-#define JIT_OP_LADD_OVF 0x0033
-#define JIT_OP_LADD_OVF_UN 0x0034
-#define JIT_OP_LSUB 0x0035
-#define JIT_OP_LSUB_OVF 0x0036
-#define JIT_OP_LSUB_OVF_UN 0x0037
-#define JIT_OP_LMUL 0x0038
-#define JIT_OP_LMUL_OVF 0x0039
-#define JIT_OP_LMUL_OVF_UN 0x003A
-#define JIT_OP_LDIV 0x003B
-#define JIT_OP_LDIV_UN 0x003C
-#define JIT_OP_LREM 0x003D
-#define JIT_OP_LREM_UN 0x003E
-#define JIT_OP_LNEG 0x003F
-#define JIT_OP_FADD 0x0040
-#define JIT_OP_FSUB 0x0041
-#define JIT_OP_FMUL 0x0042
-#define JIT_OP_FDIV 0x0043
-#define JIT_OP_FREM 0x0044
-#define JIT_OP_FREM_IEEE 0x0045
-#define JIT_OP_FNEG 0x0046
-#define JIT_OP_DADD 0x0047
-#define JIT_OP_DSUB 0x0048
-#define JIT_OP_DMUL 0x0049
-#define JIT_OP_DDIV 0x004A
-#define JIT_OP_DREM 0x004B
-#define JIT_OP_DREM_IEEE 0x004C
-#define JIT_OP_DNEG 0x004D
-#define JIT_OP_NFADD 0x004E
-#define JIT_OP_NFSUB 0x004F
-#define JIT_OP_NFMUL 0x0050
-#define JIT_OP_NFDIV 0x0051
-#define JIT_OP_NFREM 0x0052
-#define JIT_OP_NFREM_IEEE 0x0053
-#define JIT_OP_NFNEG 0x0054
-
-/*
- * Bitwise opcodes.
- */
-#define JIT_OP_IAND 0x0055
-#define JIT_OP_IOR 0x0056
-#define JIT_OP_IXOR 0x0057
-#define JIT_OP_INOT 0x0058
-#define JIT_OP_ISHL 0x0059
-#define JIT_OP_ISHR 0x005A
-#define JIT_OP_ISHR_UN 0x005B
-#define JIT_OP_LAND 0x005C
-#define JIT_OP_LOR 0x005D
-#define JIT_OP_LXOR 0x005E
-#define JIT_OP_LNOT 0x005F
-#define JIT_OP_LSHL 0x0060
-#define JIT_OP_LSHR 0x0061
-#define JIT_OP_LSHR_UN 0x0062
-
-/*
- * Branch opcodes.
- */
-#define JIT_OP_BR 0x0063
-#define JIT_OP_BR_IFALSE 0x0064
-#define JIT_OP_BR_ITRUE 0x0065
-#define JIT_OP_BR_IEQ 0x0066
-#define JIT_OP_BR_INE 0x0067
-#define JIT_OP_BR_ILT 0x0068
-#define JIT_OP_BR_ILT_UN 0x0069
-#define JIT_OP_BR_ILE 0x006A
-#define JIT_OP_BR_ILE_UN 0x006B
-#define JIT_OP_BR_IGT 0x006C
-#define JIT_OP_BR_IGT_UN 0x006D
-#define JIT_OP_BR_IGE 0x006E
-#define JIT_OP_BR_IGE_UN 0x006F
-#define JIT_OP_BR_LFALSE 0x0070
-#define JIT_OP_BR_LTRUE 0x0071
-#define JIT_OP_BR_LEQ 0x0072
-#define JIT_OP_BR_LNE 0x0073
-#define JIT_OP_BR_LLT 0x0074
-#define JIT_OP_BR_LLT_UN 0x0075
-#define JIT_OP_BR_LLE 0x0076
-#define JIT_OP_BR_LLE_UN 0x0077
-#define JIT_OP_BR_LGT 0x0078
-#define JIT_OP_BR_LGT_UN 0x0079
-#define JIT_OP_BR_LGE 0x007A
-#define JIT_OP_BR_LGE_UN 0x007B
-#define JIT_OP_BR_FEQ 0x007C
-#define JIT_OP_BR_FNE 0x007D
-#define JIT_OP_BR_FLT 0x007E
-#define JIT_OP_BR_FLE 0x007F
-#define JIT_OP_BR_FGT 0x0080
-#define JIT_OP_BR_FGE 0x0081
-#define JIT_OP_BR_FEQ_INV 0x0082
-#define JIT_OP_BR_FNE_INV 0x0083
-#define JIT_OP_BR_FLT_INV 0x0084
-#define JIT_OP_BR_FLE_INV 0x0085
-#define JIT_OP_BR_FGT_INV 0x0086
-#define JIT_OP_BR_FGE_INV 0x0087
-#define JIT_OP_BR_DEQ 0x0088
-#define JIT_OP_BR_DNE 0x0089
-#define JIT_OP_BR_DLT 0x008A
-#define JIT_OP_BR_DLE 0x008B
-#define JIT_OP_BR_DGT 0x008C
-#define JIT_OP_BR_DGE 0x008D
-#define JIT_OP_BR_DEQ_INV 0x008E
-#define JIT_OP_BR_DNE_INV 0x008F
-#define JIT_OP_BR_DLT_INV 0x0090
-#define JIT_OP_BR_DLE_INV 0x0091
-#define JIT_OP_BR_DGT_INV 0x0092
-#define JIT_OP_BR_DGE_INV 0x0093
-#define JIT_OP_BR_NFEQ 0x0094
-#define JIT_OP_BR_NFNE 0x0095
-#define JIT_OP_BR_NFLT 0x0096
-#define JIT_OP_BR_NFLE 0x0097
-#define JIT_OP_BR_NFGT 0x0098
-#define JIT_OP_BR_NFGE 0x0099
-#define JIT_OP_BR_NFEQ_INV 0x009A
-#define JIT_OP_BR_NFNE_INV 0x009B
-#define JIT_OP_BR_NFLT_INV 0x009C
-#define JIT_OP_BR_NFLE_INV 0x009D
-#define JIT_OP_BR_NFGT_INV 0x009E
-#define JIT_OP_BR_NFGE_INV 0x009F
-
-/*
- * Comparison opcodes.
- */
-#define JIT_OP_ICMP 0x00A0
-#define JIT_OP_ICMP_UN 0x00A1
-#define JIT_OP_LCMP 0x00A2
-#define JIT_OP_LCMP_UN 0x00A3
-#define JIT_OP_FCMPL 0x00A4
-#define JIT_OP_FCMPG 0x00A5
-#define JIT_OP_DCMPL 0x00A6
-#define JIT_OP_DCMPG 0x00A7
-#define JIT_OP_NFCMPL 0x00A8
-#define JIT_OP_NFCMPG 0x00A9
-#define JIT_OP_IEQ 0x00AA
-#define JIT_OP_INE 0x00AB
-#define JIT_OP_ILT 0x00AC
-#define JIT_OP_ILT_UN 0x00AD
-#define JIT_OP_ILE 0x00AE
-#define JIT_OP_ILE_UN 0x00AF
-#define JIT_OP_IGT 0x00B0
-#define JIT_OP_IGT_UN 0x00B1
-#define JIT_OP_IGE 0x00B2
-#define JIT_OP_IGE_UN 0x00B3
-#define JIT_OP_LEQ 0x00B4
-#define JIT_OP_LNE 0x00B5
-#define JIT_OP_LLT 0x00B6
-#define JIT_OP_LLT_UN 0x00B7
-#define JIT_OP_LLE 0x00B8
-#define JIT_OP_LLE_UN 0x00B9
-#define JIT_OP_LGT 0x00BA
-#define JIT_OP_LGT_UN 0x00BB
-#define JIT_OP_LGE 0x00BC
-#define JIT_OP_LGE_UN 0x00BD
-#define JIT_OP_FEQ 0x00BE
-#define JIT_OP_FNE 0x00BF
-#define JIT_OP_FLT 0x00C0
-#define JIT_OP_FLE 0x00C1
-#define JIT_OP_FGT 0x00C2
-#define JIT_OP_FGE 0x00C3
-#define JIT_OP_FEQ_INV 0x00C4
-#define JIT_OP_FNE_INV 0x00C5
-#define JIT_OP_FLT_INV 0x00C6
-#define JIT_OP_FLE_INV 0x00C7
-#define JIT_OP_FGT_INV 0x00C8
-#define JIT_OP_FGE_INV 0x00C9
-#define JIT_OP_DEQ 0x00CA
-#define JIT_OP_DNE 0x00CB
-#define JIT_OP_DLT 0x00CC
-#define JIT_OP_DLE 0x00CD
-#define JIT_OP_DGT 0x00CE
-#define JIT_OP_DGE 0x00CF
-#define JIT_OP_DEQ_INV 0x00D0
-#define JIT_OP_DNE_INV 0x00D1
-#define JIT_OP_DLT_INV 0x00D2
-#define JIT_OP_DLE_INV 0x00D3
-#define JIT_OP_DGT_INV 0x00D4
-#define JIT_OP_DGE_INV 0x00D5
-#define JIT_OP_NFEQ 0x00D6
-#define JIT_OP_NFNE 0x00D7
-#define JIT_OP_NFLT 0x00D8
-#define JIT_OP_NFLE 0x00D9
-#define JIT_OP_NFGT 0x00DA
-#define JIT_OP_NFGE 0x00DB
-#define JIT_OP_NFEQ_INV 0x00DC
-#define JIT_OP_NFNE_INV 0x00DD
-#define JIT_OP_NFLT_INV 0x00DE
-#define JIT_OP_NFLE_INV 0x00DF
-#define JIT_OP_NFGT_INV 0x00E0
-#define JIT_OP_NFGE_INV 0x00E1
-#define JIT_OP_IS_FNAN 0x00E2
-#define JIT_OP_IS_FINF 0x00E3
-#define JIT_OP_IS_FFINITE 0x00E4
-#define JIT_OP_IS_DNAN 0x00E5
-#define JIT_OP_IS_DINF 0x00E6
-#define JIT_OP_IS_DFINITE 0x00E7
-#define JIT_OP_IS_NFNAN 0x00E8
-#define JIT_OP_IS_NFINF 0x00E9
-#define JIT_OP_IS_NFFINITE 0x00EA
-
-/*
- * Mathematical functions.
- */
-#define JIT_OP_FACOS 0x00EB
-#define JIT_OP_FASIN 0x00EC
-#define JIT_OP_FATAN 0x00ED
-#define JIT_OP_FATAN2 0x00EE
-#define JIT_OP_FCEIL 0x00EF
-#define JIT_OP_FCOS 0x00F0
-#define JIT_OP_FCOSH 0x00F1
-#define JIT_OP_FEXP 0x00F2
-#define JIT_OP_FFLOOR 0x00F3
-#define JIT_OP_FLOG 0x00F4
-#define JIT_OP_FLOG10 0x00F5
-#define JIT_OP_FPOW 0x00F6
-#define JIT_OP_FRINT 0x00F7
-#define JIT_OP_FROUND 0x00F8
-#define JIT_OP_FSIN 0x00F9
-#define JIT_OP_FSINH 0x00FA
-#define JIT_OP_FSQRT 0x00FB
-#define JIT_OP_FTAN 0x00FC
-#define JIT_OP_FTANH 0x00FD
-#define JIT_OP_DACOS 0x00FE
-#define JIT_OP_DASIN 0x00FF
-#define JIT_OP_DATAN 0x0100
-#define JIT_OP_DATAN2 0x0101
-#define JIT_OP_DCEIL 0x0102
-#define JIT_OP_DCOS 0x0103
-#define JIT_OP_DCOSH 0x0104
-#define JIT_OP_DEXP 0x0105
-#define JIT_OP_DFLOOR 0x0106
-#define JIT_OP_DLOG 0x0107
-#define JIT_OP_DLOG10 0x0108
-#define JIT_OP_DPOW 0x0109
-#define JIT_OP_DRINT 0x010A
-#define JIT_OP_DROUND 0x010B
-#define JIT_OP_DSIN 0x010C
-#define JIT_OP_DSINH 0x010D
-#define JIT_OP_DSQRT 0x010E
-#define JIT_OP_DTAN 0x010F
-#define JIT_OP_DTANH 0x0110
-#define JIT_OP_NFACOS 0x0111
-#define JIT_OP_NFASIN 0x0112
-#define JIT_OP_NFATAN 0x0113
-#define JIT_OP_NFATAN2 0x0114
-#define JIT_OP_NFCEIL 0x0115
-#define JIT_OP_NFCOS 0x0116
-#define JIT_OP_NFCOSH 0x0117
-#define JIT_OP_NFEXP 0x0118
-#define JIT_OP_NFFLOOR 0x0119
-#define JIT_OP_NFLOG 0x011A
-#define JIT_OP_NFLOG10 0x011B
-#define JIT_OP_NFPOW 0x011C
-#define JIT_OP_NFRINT 0x011D
-#define JIT_OP_NFROUND 0x011E
-#define JIT_OP_NFSIN 0x011F
-#define JIT_OP_NFSINH 0x0120
-#define JIT_OP_NFSQRT 0x0121
-#define JIT_OP_NFTAN 0x0122
-#define JIT_OP_NFTANH 0x0123
-
-/*
- * Absolute, minimum, maximum, and sign.
- */
-#define JIT_OP_IABS 0x0124
-#define JIT_OP_LABS 0x0125
-#define JIT_OP_FABS 0x0126
-#define JIT_OP_DABS 0x0127
-#define JIT_OP_NFABS 0x0128
-#define JIT_OP_IMIN 0x0129
-#define JIT_OP_IMIN_UN 0x012A
-#define JIT_OP_LMIN 0x012B
-#define JIT_OP_LMIN_UN 0x012C
-#define JIT_OP_FMIN 0x012D
-#define JIT_OP_DMIN 0x012E
-#define JIT_OP_NFMIN 0x012F
-#define JIT_OP_IMAX 0x0130
-#define JIT_OP_IMAX_UN 0x0131
-#define JIT_OP_LMAX 0x0132
-#define JIT_OP_LMAX_UN 0x0133
-#define JIT_OP_FMAX 0x0134
-#define JIT_OP_DMAX 0x0135
-#define JIT_OP_NFMAX 0x0136
-#define JIT_OP_ISIGN 0x0137
-#define JIT_OP_LSIGN 0x0138
-#define JIT_OP_FSIGN 0x0139
-#define JIT_OP_DSIGN 0x013A
-#define JIT_OP_NFSIGN 0x013B
-
-/*
- * Pointer check opcodes.
- */
-#define JIT_OP_CHECK_NULL 0x013C
-
-/*
- * Function calls.
- */
-#define JIT_OP_CALL 0x013D
-#define JIT_OP_CALL_TAIL 0x013E
-#define JIT_OP_CALL_INDIRECT 0x013F
-#define JIT_OP_CALL_INDIRECT_TAIL 0x0140
-#define JIT_OP_CALL_VTABLE_PTR 0x0141
-#define JIT_OP_CALL_VTABLE_PTR_TAIL 0x0142
-#define JIT_OP_CALL_EXTERNAL 0x0143
-#define JIT_OP_CALL_EXTERNAL_TAIL 0x0144
-#define JIT_OP_RETURN 0x0145
-#define JIT_OP_RETURN_INT 0x0146
-#define JIT_OP_RETURN_LONG 0x0147
-#define JIT_OP_RETURN_FLOAT32 0x0148
-#define JIT_OP_RETURN_FLOAT64 0x0149
-#define JIT_OP_RETURN_NFLOAT 0x014A
-#define JIT_OP_RETURN_SMALL_STRUCT 0x014B
-#define JIT_OP_SETUP_FOR_NESTED 0x014C
-#define JIT_OP_SETUP_FOR_SIBLING 0x014D
-#define JIT_OP_IMPORT 0x014E
-
-/*
- * Exception handling.
- */
-#define JIT_OP_THROW 0x014F
-#define JIT_OP_RETHROW 0x0150
-#define JIT_OP_LOAD_PC 0x0151
-#define JIT_OP_LOAD_EXCEPTION_PC 0x0152
-#define JIT_OP_ENTER_FINALLY 0x0153
-#define JIT_OP_LEAVE_FINALLY 0x0154
-#define JIT_OP_CALL_FINALLY 0x0155
-#define JIT_OP_ENTER_FILTER 0x0156
-#define JIT_OP_LEAVE_FILTER 0x0157
-#define JIT_OP_CALL_FILTER 0x0158
-#define JIT_OP_CALL_FILTER_RETURN 0x0159
-#define JIT_OP_ADDRESS_OF_LABEL 0x015A
-
-/*
- * Data manipulation.
- */
-#define JIT_OP_COPY_LOAD_SBYTE 0x015B
-#define JIT_OP_COPY_LOAD_UBYTE 0x015C
-#define JIT_OP_COPY_LOAD_SHORT 0x015D
-#define JIT_OP_COPY_LOAD_USHORT 0x015E
-#define JIT_OP_COPY_INT 0x015F
-#define JIT_OP_COPY_LONG 0x0160
-#define JIT_OP_COPY_FLOAT32 0x0161
-#define JIT_OP_COPY_FLOAT64 0x0162
-#define JIT_OP_COPY_NFLOAT 0x0163
-#define JIT_OP_COPY_STRUCT 0x0164
-#define JIT_OP_COPY_STORE_BYTE 0x0165
-#define JIT_OP_COPY_STORE_SHORT 0x0166
-#define JIT_OP_ADDRESS_OF 0x0167
-
-/*
- * Incoming registers, outgoing registers, and stack pushes.
- */
-#define JIT_OP_INCOMING_REG 0x0168
-#define JIT_OP_INCOMING_FRAME_POSN 0x0169
-#define JIT_OP_OUTGOING_REG 0x016A
-#define JIT_OP_OUTGOING_FRAME_POSN 0x016B
-#define JIT_OP_RETURN_REG 0x016C
-#define JIT_OP_PUSH_INT 0x016D
-#define JIT_OP_PUSH_LONG 0x016E
-#define JIT_OP_PUSH_FLOAT32 0x016F
-#define JIT_OP_PUSH_FLOAT64 0x0170
-#define JIT_OP_PUSH_NFLOAT 0x0171
-#define JIT_OP_PUSH_STRUCT 0x0172
-#define JIT_OP_POP_STACK 0x0173
-#define JIT_OP_FLUSH_SMALL_STRUCT 0x0174
-#define JIT_OP_SET_PARAM_INT 0x0175
-#define JIT_OP_SET_PARAM_LONG 0x0176
-#define JIT_OP_SET_PARAM_FLOAT32 0x0177
-#define JIT_OP_SET_PARAM_FLOAT64 0x0178
-#define JIT_OP_SET_PARAM_NFLOAT 0x0179
-#define JIT_OP_SET_PARAM_STRUCT 0x017A
-#define JIT_OP_PUSH_RETURN_AREA_PTR 0x017B
-
-/*
- * Pointer-relative loads and stores.
- */
-#define JIT_OP_LOAD_RELATIVE_SBYTE 0x017C
-#define JIT_OP_LOAD_RELATIVE_UBYTE 0x017D
-#define JIT_OP_LOAD_RELATIVE_SHORT 0x017E
-#define JIT_OP_LOAD_RELATIVE_USHORT 0x017F
-#define JIT_OP_LOAD_RELATIVE_INT 0x0180
-#define JIT_OP_LOAD_RELATIVE_LONG 0x0181
-#define JIT_OP_LOAD_RELATIVE_FLOAT32 0x0182
-#define JIT_OP_LOAD_RELATIVE_FLOAT64 0x0183
-#define JIT_OP_LOAD_RELATIVE_NFLOAT 0x0184
-#define JIT_OP_LOAD_RELATIVE_STRUCT 0x0185
-#define JIT_OP_STORE_RELATIVE_BYTE 0x0186
-#define JIT_OP_STORE_RELATIVE_SHORT 0x0187
-#define JIT_OP_STORE_RELATIVE_INT 0x0188
-#define JIT_OP_STORE_RELATIVE_LONG 0x0189
-#define JIT_OP_STORE_RELATIVE_FLOAT32 0x018A
-#define JIT_OP_STORE_RELATIVE_FLOAT64 0x018B
-#define JIT_OP_STORE_RELATIVE_NFLOAT 0x018C
-#define JIT_OP_STORE_RELATIVE_STRUCT 0x018D
-#define JIT_OP_ADD_RELATIVE 0x018E
-
-/*
- * Array element loads and stores.
- */
-#define JIT_OP_LOAD_ELEMENT_SBYTE 0x018F
-#define JIT_OP_LOAD_ELEMENT_UBYTE 0x0190
-#define JIT_OP_LOAD_ELEMENT_SHORT 0x0191
-#define JIT_OP_LOAD_ELEMENT_USHORT 0x0192
-#define JIT_OP_LOAD_ELEMENT_INT 0x0193
-#define JIT_OP_LOAD_ELEMENT_LONG 0x0194
-#define JIT_OP_LOAD_ELEMENT_FLOAT32 0x0195
-#define JIT_OP_LOAD_ELEMENT_FLOAT64 0x0196
-#define JIT_OP_LOAD_ELEMENT_NFLOAT 0x0197
-#define JIT_OP_STORE_ELEMENT_BYTE 0x0198
-#define JIT_OP_STORE_ELEMENT_SHORT 0x0199
-#define JIT_OP_STORE_ELEMENT_INT 0x019A
-#define JIT_OP_STORE_ELEMENT_LONG 0x019B
-#define JIT_OP_STORE_ELEMENT_FLOAT32 0x019C
-#define JIT_OP_STORE_ELEMENT_FLOAT64 0x019D
-#define JIT_OP_STORE_ELEMENT_NFLOAT 0x019E
-
-/*
- * Block operations.
- */
-#define JIT_OP_MEMCPY 0x019F
-#define JIT_OP_MEMMOVE 0x01A0
-#define JIT_OP_MEMSET 0x01A1
-
-/*
- * Allocate memory from the stack.
- */
-#define JIT_OP_ALLOCA 0x01A2
-
-/*
- * Debugging support.
- */
-#define JIT_OP_MARK_OFFSET 0x01A3
-#define JIT_OP_MARK_BREAKPOINT 0x01A4
-
-/*
- * Switch statement support.
- */
-#define JIT_OP_JUMP_TABLE 0x01A5
-
-/*
- * The number of opcodes in the above list.
- */
-#define JIT_OP_NUM_OPCODES 0x01A6
-
-/*
- * Opcode information.
- */
-typedef struct jit_opcode_info jit_opcode_info_t;
-struct jit_opcode_info
-{
- const char *name;
- int flags;
-};
-#define JIT_OPCODE_DEST_MASK 0x0000000F
-#define JIT_OPCODE_DEST_EMPTY 0x00000000
-#define JIT_OPCODE_DEST_INT 0x00000001
-#define JIT_OPCODE_DEST_LONG 0x00000002
-#define JIT_OPCODE_DEST_FLOAT32 0x00000003
-#define JIT_OPCODE_DEST_FLOAT64 0x00000004
-#define JIT_OPCODE_DEST_NFLOAT 0x00000005
-#define JIT_OPCODE_DEST_ANY 0x00000006
-#define JIT_OPCODE_SRC1_MASK 0x000000F0
-#define JIT_OPCODE_SRC1_EMPTY 0x00000000
-#define JIT_OPCODE_SRC1_INT 0x00000010
-#define JIT_OPCODE_SRC1_LONG 0x00000020
-#define JIT_OPCODE_SRC1_FLOAT32 0x00000030
-#define JIT_OPCODE_SRC1_FLOAT64 0x00000040
-#define JIT_OPCODE_SRC1_NFLOAT 0x00000050
-#define JIT_OPCODE_SRC1_ANY 0x00000060
-#define JIT_OPCODE_SRC2_MASK 0x00000F00
-#define JIT_OPCODE_SRC2_EMPTY 0x00000000
-#define JIT_OPCODE_SRC2_INT 0x00000100
-#define JIT_OPCODE_SRC2_LONG 0x00000200
-#define JIT_OPCODE_SRC2_FLOAT32 0x00000300
-#define JIT_OPCODE_SRC2_FLOAT64 0x00000400
-#define JIT_OPCODE_SRC2_NFLOAT 0x00000500
-#define JIT_OPCODE_SRC2_ANY 0x00000600
-#define JIT_OPCODE_IS_BRANCH 0x00001000
-#define JIT_OPCODE_IS_CALL 0x00002000
-#define JIT_OPCODE_IS_CALL_EXTERNAL 0x00004000
-#define JIT_OPCODE_IS_REG 0x00008000
-#define JIT_OPCODE_IS_ADDROF_LABEL 0x00010000
-#define JIT_OPCODE_IS_JUMP_TABLE 0x00020000
-#define JIT_OPCODE_OPER_MASK 0x01F00000
-#define JIT_OPCODE_OPER_NONE 0x00000000
-#define JIT_OPCODE_OPER_ADD 0x00100000
-#define JIT_OPCODE_OPER_SUB 0x00200000
-#define JIT_OPCODE_OPER_MUL 0x00300000
-#define JIT_OPCODE_OPER_DIV 0x00400000
-#define JIT_OPCODE_OPER_REM 0x00500000
-#define JIT_OPCODE_OPER_NEG 0x00600000
-#define JIT_OPCODE_OPER_AND 0x00700000
-#define JIT_OPCODE_OPER_OR 0x00800000
-#define JIT_OPCODE_OPER_XOR 0x00900000
-#define JIT_OPCODE_OPER_NOT 0x00A00000
-#define JIT_OPCODE_OPER_EQ 0x00B00000
-#define JIT_OPCODE_OPER_NE 0x00C00000
-#define JIT_OPCODE_OPER_LT 0x00D00000
-#define JIT_OPCODE_OPER_LE 0x00E00000
-#define JIT_OPCODE_OPER_GT 0x00F00000
-#define JIT_OPCODE_OPER_GE 0x01000000
-#define JIT_OPCODE_OPER_SHL 0x01100000
-#define JIT_OPCODE_OPER_SHR 0x01200000
-#define JIT_OPCODE_OPER_SHR_UN 0x01300000
-#define JIT_OPCODE_OPER_COPY 0x01400000
-#define JIT_OPCODE_OPER_ADDRESS_OF 0x01500000
-#ifdef JIT_NATIVE_INT32
-#define JIT_OPCODE_DEST_PTR JIT_OPCODE_DEST_INT
-#define JIT_OPCODE_SRC1_PTR JIT_OPCODE_SRC1_INT
-#define JIT_OPCODE_SRC2_PTR JIT_OPCODE_SRC2_INT
-#else
-#define JIT_OPCODE_DEST_PTR JIT_OPCODE_DEST_LONG
-#define JIT_OPCODE_SRC1_PTR JIT_OPCODE_SRC1_LONG
-#define JIT_OPCODE_SRC2_PTR JIT_OPCODE_SRC2_LONG
-#endif
-JIT_EXPORT_DATA jit_opcode_info_t const jit_opcodes[JIT_OP_NUM_OPCODES];
-
-#ifdef __cplusplus
-};
-#endif
-
-#endif /* _JIT_OPCODE_H */
+BUILT_SOURCES = jit-opcode.c jit-interp-opcode.h jit-interp-opcode.c
lib_LTLIBRARIES = libjit.la
jit-internal.h \
jit-interp.h \
jit-interp.c \
+ jit-interp-opcode.h \
+ jit-interp-opcode.c \
jit-intrinsic.c \
jit-live.c \
jit-memory.c \
jit-interp.lo: jit-interp-labels.h
jit-interp-labels.h: $(top_srcdir)/include/jit/jit-opcode.h \
- $(top_srcdir)/jit/jit-interp.h $(srcdir)/mklabel.sh
+ $(top_srcdir)/jit/jit-interp-opcode.h $(srcdir)/mklabel.sh
$(SHELL) $(srcdir)/mklabel.sh "$(AWK)" \
$(top_srcdir)/include/jit/jit-opcode.h \
- $(top_srcdir)/jit/jit-interp.h >jit-interp-labels.h
+ $(top_srcdir)/jit/jit-interp-opcode.h >jit-interp-labels.h
jit-rules-x86.lo: jit-rules-x86.inc
$(top_builddir)/tools/gen-rules$(EXEEXT) $(srcdir)/jit-rules-x86-64.ins \
>jit-rules-x86-64.inc
+jit-opcode.c: $(top_srcdir)/config/jit-opcodes.ops
+ $(top_builddir)/tools/gen-ops -T $(top_srcdir)/config/jit-opcodes.ops >jit-opcode.c
+
+jit-interp-opcode.h: $(top_srcdir)/config/jit-interp-opcodes.ops
+ $(top_builddir)/tools/gen-ops -H $(top_srcdir)/config/jit-interp-opcodes.ops >jit-interp-opcode.h
+
+jit-interp-opcode.c: $(top_srcdir)/config/jit-interp-opcodes.ops
+ $(top_builddir)/tools/gen-ops -T $(top_srcdir)/config/jit-interp-opcodes.ops >jit-interp-opcode.c
+
CLEANFILES = \
jit-interp-labels.h \
jit-rules-alpha.inc \
#if defined(JIT_BACKEND_INTERP)
-extern jit_opcode_info_t const _jit_interp_opcodes[JIT_OP_NUM_INTERP_OPCODES];
-
/*
* Dump the interpreted bytecode representation of a function.
*/
}
VMBREAK;
- VMCASE(JIT_OP_IMPORT_LOCAL):
+ VMCASE(JIT_INTERP_OP_IMPORT_LOCAL):
{
/* TODO!!! */
/* Import the address of a local variable from an outer scope */
}
VMBREAK;
- VMCASE(JIT_OP_IMPORT_ARG):
+ VMCASE(JIT_INTERP_OP_IMPORT_ARG):
{
/* TODO!!! */
/* Import the address of an argument from an outer scope */
* Argument variable access opcodes.
******************************************************************/
- VMCASE(JIT_OP_LDA_0_SBYTE):
+ VMCASE(JIT_INTERP_OP_LDA_0_SBYTE):
{
/* Load a signed 8-bit integer argument into the register 0 */
VM_R0_INT = *VM_ARG(jit_sbyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_0_UBYTE):
+ VMCASE(JIT_INTERP_OP_LDA_0_UBYTE):
{
/* Load an unsigned 8-bit integer argument into the register 0 */
VM_R0_INT = *VM_ARG(jit_ubyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_0_SHORT):
+ VMCASE(JIT_INTERP_OP_LDA_0_SHORT):
{
/* Load a signed 16-bit integer argument into the register 0 */
VM_R0_INT = *VM_ARG(jit_short);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_0_USHORT):
+ VMCASE(JIT_INTERP_OP_LDA_0_USHORT):
{
/* Load am unsigned 16-bit argument local into the register 0 */
VM_R0_INT = *VM_ARG(jit_ushort);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_0_INT):
+ VMCASE(JIT_INTERP_OP_LDA_0_INT):
{
/* Load a 32-bit integer argument into the register 0 */
VM_R0_INT = *VM_ARG(jit_int);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_0_LONG):
+ VMCASE(JIT_INTERP_OP_LDA_0_LONG):
{
/* Load a 64-bit integer argument into the register 0 */
VM_R0_LONG = *VM_ARG(jit_long);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_0_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDA_0_FLOAT32):
{
/* Load a 32-bit float argument into the register 0 */
VM_R0_FLOAT32 = *VM_ARG(jit_float32);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_0_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDA_0_FLOAT64):
{
/* Load a 64-bit float argument into the register 0 */
VM_R0_FLOAT64 = *VM_ARG(jit_float64);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_0_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDA_0_NFLOAT):
{
/* Load a native float argument into the register 0 */
VM_R0_NFLOAT = *VM_ARG(jit_nfloat);
}
VMBREAK;
- VMCASE(JIT_OP_LDAA_0):
+ VMCASE(JIT_INTERP_OP_LDAA_0):
{
/* Load the address of an argument into the register 0 */
VM_R0_PTR = VM_ARG(void);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_1_SBYTE):
+ VMCASE(JIT_INTERP_OP_LDA_1_SBYTE):
{
/* Load a signed 8-bit integer argument into the register 1 */
VM_R1_INT = *VM_ARG(jit_sbyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_1_UBYTE):
+ VMCASE(JIT_INTERP_OP_LDA_1_UBYTE):
{
/* Load an unsigned 8-bit integer argument into the register 1 */
VM_R1_INT = *VM_ARG(jit_ubyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_1_SHORT):
+ VMCASE(JIT_INTERP_OP_LDA_1_SHORT):
{
/* Load a signed 16-bit integer argument into the register 1 */
VM_R1_INT = *VM_ARG(jit_short);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_1_USHORT):
+ VMCASE(JIT_INTERP_OP_LDA_1_USHORT):
{
/* Load am unsigned 16-bit argument local into the register 1 */
VM_R1_INT = *VM_ARG(jit_ushort);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_1_INT):
+ VMCASE(JIT_INTERP_OP_LDA_1_INT):
{
/* Load a 32-bit integer argument into the register 1 */
VM_R1_INT = *VM_ARG(jit_int);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_1_LONG):
+ VMCASE(JIT_INTERP_OP_LDA_1_LONG):
{
/* Load a 64-bit integer argument into the register 1 */
VM_R1_LONG = *VM_ARG(jit_long);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_1_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDA_1_FLOAT32):
{
/* Load a 32-bit float argument into the register 1 */
VM_R1_FLOAT32 = *VM_ARG(jit_float32);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_1_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDA_1_FLOAT64):
{
/* Load a 64-bit float argument into the register 1 */
VM_R1_FLOAT64 = *VM_ARG(jit_float64);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_1_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDA_1_NFLOAT):
{
/* Load a native float argument into the register 1 */
VM_R1_NFLOAT = *VM_ARG(jit_nfloat);
}
VMBREAK;
- VMCASE(JIT_OP_LDAA_1):
+ VMCASE(JIT_INTERP_OP_LDAA_1):
{
/* Load the address of an argument into the register 1 */
VM_R1_PTR = VM_ARG(void);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_2_SBYTE):
+ VMCASE(JIT_INTERP_OP_LDA_2_SBYTE):
{
/* Load a signed 8-bit integer argument into the register 2 */
VM_R2_INT = *VM_ARG(jit_sbyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_2_UBYTE):
+ VMCASE(JIT_INTERP_OP_LDA_2_UBYTE):
{
/* Load an unsigned 8-bit integer argument into the register 2 */
VM_R2_INT = *VM_ARG(jit_ubyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_2_SHORT):
+ VMCASE(JIT_INTERP_OP_LDA_2_SHORT):
{
/* Load a signed 16-bit integer argument into the register 2 */
VM_R2_INT = *VM_ARG(jit_short);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_2_USHORT):
+ VMCASE(JIT_INTERP_OP_LDA_2_USHORT):
{
/* Load am unsigned 16-bit argument local into the register 2 */
VM_R2_INT = *VM_ARG(jit_ushort);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_2_INT):
+ VMCASE(JIT_INTERP_OP_LDA_2_INT):
{
/* Load a 32-bit integer argument into the register 2 */
VM_R2_INT = *VM_ARG(jit_int);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_2_LONG):
+ VMCASE(JIT_INTERP_OP_LDA_2_LONG):
{
/* Load a 64-bit integer argument into the register 2 */
VM_R2_LONG = *VM_ARG(jit_long);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_2_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDA_2_FLOAT32):
{
/* Load a 32-bit float argument into the register 2 */
VM_R2_FLOAT32 = *VM_ARG(jit_float32);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_2_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDA_2_FLOAT64):
{
/* Load a 64-bit float argument into the register 2 */
VM_R2_FLOAT64 = *VM_ARG(jit_float64);
}
VMBREAK;
- VMCASE(JIT_OP_LDA_2_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDA_2_NFLOAT):
{
/* Load a native float argument into the register 2 */
VM_R2_NFLOAT = *VM_ARG(jit_nfloat);
}
VMBREAK;
- VMCASE(JIT_OP_LDAA_2):
+ VMCASE(JIT_INTERP_OP_LDAA_2):
{
/* Load the address of an argument into the register 2 */
VM_R2_PTR = VM_ARG(void);
}
VMBREAK;
- VMCASE(JIT_OP_STA_0_BYTE):
+ VMCASE(JIT_INTERP_OP_STA_0_BYTE):
{
/* Store an 8-bit integer into an argument */
*VM_ARG(jit_sbyte) = (jit_sbyte)VM_R0_INT;
}
VMBREAK;
- VMCASE(JIT_OP_STA_0_SHORT):
+ VMCASE(JIT_INTERP_OP_STA_0_SHORT):
{
/* Store an 16-bit integer into an argument */
*VM_ARG(jit_short) = (jit_short)VM_R0_INT;
}
VMBREAK;
- VMCASE(JIT_OP_STA_0_INT):
+ VMCASE(JIT_INTERP_OP_STA_0_INT):
{
/* Store an 32-bit integer into an argument */
*VM_ARG(jit_int) = (jit_int)VM_R0_INT;
}
VMBREAK;
- VMCASE(JIT_OP_STA_0_LONG):
+ VMCASE(JIT_INTERP_OP_STA_0_LONG):
{
/* Store an 64-bit integer into an argument */
*VM_ARG(jit_long) = (jit_long)VM_R0_LONG;
}
VMBREAK;
- VMCASE(JIT_OP_STA_0_FLOAT32):
+ VMCASE(JIT_INTERP_OP_STA_0_FLOAT32):
{
/* Store a 32-bit float into an argument */
*VM_ARG(jit_float32) = VM_R0_FLOAT32;
}
VMBREAK;
- VMCASE(JIT_OP_STA_0_FLOAT64):
+ VMCASE(JIT_INTERP_OP_STA_0_FLOAT64):
{
/* Store a 64-bit float into an argument */
*VM_ARG(jit_float64) = VM_R0_FLOAT64;
}
VMBREAK;
- VMCASE(JIT_OP_STA_0_NFLOAT):
+ VMCASE(JIT_INTERP_OP_STA_0_NFLOAT):
{
/* Store a native float into an argument */
*VM_ARG(jit_nfloat) = VM_R0_NFLOAT;
* Local variable frame access opcodes.
******************************************************************/
- VMCASE(JIT_OP_LDL_0_SBYTE):
+ VMCASE(JIT_INTERP_OP_LDL_0_SBYTE):
{
/* Load a signed 8-bit integer local into the register 0 */
VM_R0_INT = *VM_LOC(jit_sbyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_0_UBYTE):
+ VMCASE(JIT_INTERP_OP_LDL_0_UBYTE):
{
/* Load an unsigned 8-bit integer local into the register 0 */
VM_R0_INT = *VM_LOC(jit_ubyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_0_SHORT):
+ VMCASE(JIT_INTERP_OP_LDL_0_SHORT):
{
/* Load a signed 16-bit integer local into the register 0 */
VM_R0_INT = *VM_LOC(jit_short);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_0_USHORT):
+ VMCASE(JIT_INTERP_OP_LDL_0_USHORT):
{
/* Load am unsigned 16-bit integer local into the register 0 */
VM_R0_INT = *VM_LOC(jit_ushort);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_0_INT):
+ VMCASE(JIT_INTERP_OP_LDL_0_INT):
{
/* Load a 32-bit integer local into the register 0 */
VM_R0_INT = *VM_LOC(jit_int);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_0_LONG):
+ VMCASE(JIT_INTERP_OP_LDL_0_LONG):
{
/* Load a 64-bit integer local into the register 0 */
VM_R0_LONG = *VM_LOC(jit_long);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_0_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDL_0_FLOAT32):
{
/* Load a 32-bit float local into the register 0 */
VM_R0_FLOAT32 = *VM_LOC(jit_float32);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_0_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDL_0_FLOAT64):
{
/* Load a 64-bit float local into the register 0 */
VM_R0_FLOAT64 = *VM_LOC(jit_float64);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_0_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDL_0_NFLOAT):
{
/* Load a native float local into the register 0 */
VM_R0_NFLOAT = *VM_LOC(jit_nfloat);
}
VMBREAK;
- VMCASE(JIT_OP_LDLA_0):
+ VMCASE(JIT_INTERP_OP_LDLA_0):
{
/* Load the address of a local into the register 0 */
VM_R0_PTR = VM_LOC(void);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_1_SBYTE):
+ VMCASE(JIT_INTERP_OP_LDL_1_SBYTE):
{
/* Load a signed 8-bit integer local into the register 1 */
VM_R1_INT = *VM_LOC(jit_sbyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_1_UBYTE):
+ VMCASE(JIT_INTERP_OP_LDL_1_UBYTE):
{
/* Load an unsigned 8-bit integer local into the register 1 */
VM_R1_INT = *VM_LOC(jit_ubyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_1_SHORT):
+ VMCASE(JIT_INTERP_OP_LDL_1_SHORT):
{
/* Load a signed 16-bit integer local into the register 1 */
VM_R1_INT = *VM_LOC(jit_short);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_1_USHORT):
+ VMCASE(JIT_INTERP_OP_LDL_1_USHORT):
{
/* Load am unsigned 16-bit integer local into the register 1 */
VM_R1_INT = *VM_LOC(jit_ushort);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_1_INT):
+ VMCASE(JIT_INTERP_OP_LDL_1_INT):
{
/* Load a 32-bit integer local into the register 1 */
VM_R1_INT = *VM_LOC(jit_int);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_1_LONG):
+ VMCASE(JIT_INTERP_OP_LDL_1_LONG):
{
/* Load a 64-bit integer local into the register 1 */
VM_R1_LONG = *VM_LOC(jit_long);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_1_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDL_1_FLOAT32):
{
/* Load a 32-bit float local into the register 1 */
VM_R1_FLOAT32 = *VM_LOC(jit_float32);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_1_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDL_1_FLOAT64):
{
/* Load a 64-bit float local into the register 1 */
VM_R1_FLOAT64 = *VM_LOC(jit_float64);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_1_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDL_1_NFLOAT):
{
/* Load a native float local into the register 1 */
VM_R1_NFLOAT = *VM_LOC(jit_nfloat);
}
VMBREAK;
- VMCASE(JIT_OP_LDLA_1):
+ VMCASE(JIT_INTERP_OP_LDLA_1):
{
/* Load the address of a local into the register 1 */
VM_R1_PTR = VM_LOC(void);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_2_SBYTE):
+ VMCASE(JIT_INTERP_OP_LDL_2_SBYTE):
{
/* Load a signed 8-bit integer local into the register 2 */
VM_R2_INT = *VM_LOC(jit_sbyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_2_UBYTE):
+ VMCASE(JIT_INTERP_OP_LDL_2_UBYTE):
{
/* Load an unsigned 8-bit integer local into the register 2 */
VM_R2_INT = *VM_LOC(jit_ubyte);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_2_SHORT):
+ VMCASE(JIT_INTERP_OP_LDL_2_SHORT):
{
/* Load a signed 16-bit integer local into the register 2 */
VM_R2_INT = *VM_LOC(jit_short);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_2_USHORT):
+ VMCASE(JIT_INTERP_OP_LDL_2_USHORT):
{
/* Load am unsigned 16-bit integer local into the register 2 */
VM_R2_INT = *VM_LOC(jit_ushort);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_2_INT):
+ VMCASE(JIT_INTERP_OP_LDL_2_INT):
{
/* Load a 32-bit integer local into the register 2 */
VM_R2_INT = *VM_LOC(jit_int);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_2_LONG):
+ VMCASE(JIT_INTERP_OP_LDL_2_LONG):
{
/* Load a 64-bit integer local into the register 2 */
VM_R2_LONG = *VM_LOC(jit_long);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_2_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDL_2_FLOAT32):
{
/* Load a 32-bit float local into the register 2 */
VM_R2_FLOAT32 = *VM_LOC(jit_float32);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_2_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDL_2_FLOAT64):
{
/* Load a 64-bit float local into the register 2 */
VM_R2_FLOAT64 = *VM_LOC(jit_float64);
}
VMBREAK;
- VMCASE(JIT_OP_LDL_2_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDL_2_NFLOAT):
{
/* Load a native float local into the register 2 */
VM_R2_NFLOAT = *VM_LOC(jit_nfloat);
}
VMBREAK;
- VMCASE(JIT_OP_LDLA_2):
+ VMCASE(JIT_INTERP_OP_LDLA_2):
{
/* Load the address of a local into the register 2 */
VM_R2_PTR = VM_LOC(void);
}
VMBREAK;
- VMCASE(JIT_OP_STL_0_BYTE):
+ VMCASE(JIT_INTERP_OP_STL_0_BYTE):
{
/* Store an 8-bit integer into a local */
*VM_LOC(jit_sbyte) = (jit_sbyte)VM_R0_INT;
}
VMBREAK;
- VMCASE(JIT_OP_STL_0_SHORT):
+ VMCASE(JIT_INTERP_OP_STL_0_SHORT):
{
/* Store an 16-bit integer into a local */
*VM_LOC(jit_short) = (jit_short)VM_R0_INT;
}
VMBREAK;
- VMCASE(JIT_OP_STL_0_INT):
+ VMCASE(JIT_INTERP_OP_STL_0_INT):
{
/* Store an 32-bit integer into a local */
*VM_LOC(jit_int) = (jit_int)VM_R0_INT;
}
VMBREAK;
- VMCASE(JIT_OP_STL_0_LONG):
+ VMCASE(JIT_INTERP_OP_STL_0_LONG):
{
/* Store an 64-bit integer into a local */
*VM_LOC(jit_long) = (jit_long)VM_R0_LONG;
}
VMBREAK;
- VMCASE(JIT_OP_STL_0_FLOAT32):
+ VMCASE(JIT_INTERP_OP_STL_0_FLOAT32):
{
/* Store a 32-bit float into a local */
*VM_LOC(jit_float32) = VM_R0_FLOAT32;
}
VMBREAK;
- VMCASE(JIT_OP_STL_0_FLOAT64):
+ VMCASE(JIT_INTERP_OP_STL_0_FLOAT64):
{
/* Store a 64-bit float into a local */
*VM_LOC(jit_float64) = VM_R0_FLOAT64;
}
VMBREAK;
- VMCASE(JIT_OP_STL_0_NFLOAT):
+ VMCASE(JIT_INTERP_OP_STL_0_NFLOAT):
{
/* Store a native float into a local */
*VM_LOC(jit_nfloat) = VM_R0_NFLOAT;
#define JIT_WORDS_PER_TYPE(type) \
((sizeof(type) + sizeof(void *) - 1) / sizeof(void *))
- VMCASE(JIT_OP_LDC_0_INT):
+ VMCASE(JIT_INTERP_OP_LDC_0_INT):
{
/* Load an integer constant into the register 0 */
VM_R0_INT = (jit_int)VM_NINT_ARG;
}
VMBREAK;
- VMCASE(JIT_OP_LDC_0_LONG):
+ VMCASE(JIT_INTERP_OP_LDC_0_LONG):
{
/* Load a long constant into the register 0 */
#ifdef JIT_NATIVE_INT64
}
VMBREAK;
- VMCASE(JIT_OP_LDC_0_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDC_0_FLOAT32):
{
/* Load a 32-bit float constant into the register 0 */
jit_memcpy(&r0.float32_value, pc + 1, sizeof(jit_float32));
}
VMBREAK;
- VMCASE(JIT_OP_LDC_0_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDC_0_FLOAT64):
{
/* Load a 64-bit float constant into the register 0 */
jit_memcpy(&r0.float64_value, pc + 1, sizeof(jit_float64));
}
VMBREAK;
- VMCASE(JIT_OP_LDC_0_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDC_0_NFLOAT):
{
/* Load a native float constant into the registre 0 */
jit_memcpy(&r0.nfloat_value, pc + 1, sizeof(jit_nfloat));
}
VMBREAK;
- VMCASE(JIT_OP_LDC_1_INT):
+ VMCASE(JIT_INTERP_OP_LDC_1_INT):
{
/* Load an integer constant into the register 1 */
VM_R1_INT = (jit_int)VM_NINT_ARG;
}
VMBREAK;
- VMCASE(JIT_OP_LDC_1_LONG):
+ VMCASE(JIT_INTERP_OP_LDC_1_LONG):
{
/* Load a long constant into the register 1 */
#ifdef JIT_NATIVE_INT64
}
VMBREAK;
- VMCASE(JIT_OP_LDC_1_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDC_1_FLOAT32):
{
/* Load a 32-bit float constant into the register 1 */
jit_memcpy(&r1.float32_value, pc + 1, sizeof(jit_float32));
}
VMBREAK;
- VMCASE(JIT_OP_LDC_1_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDC_1_FLOAT64):
{
/* Load a 64-bit float constant into the register 1 */
jit_memcpy(&r1.float64_value, pc + 1, sizeof(jit_float64));
}
VMBREAK;
- VMCASE(JIT_OP_LDC_1_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDC_1_NFLOAT):
{
/* Load a native float constant into the registre 1 */
jit_memcpy(&r1.nfloat_value, pc + 1, sizeof(jit_nfloat));
}
VMBREAK;
- VMCASE(JIT_OP_LDC_2_INT):
+ VMCASE(JIT_INTERP_OP_LDC_2_INT):
{
/* Load an integer constant into the register 2 */
VM_R2_INT = (jit_int)VM_NINT_ARG;
}
VMBREAK;
- VMCASE(JIT_OP_LDC_2_LONG):
+ VMCASE(JIT_INTERP_OP_LDC_2_LONG):
{
/* Load a long constant into the register 2 */
#ifdef JIT_NATIVE_INT64
}
VMBREAK;
- VMCASE(JIT_OP_LDC_2_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDC_2_FLOAT32):
{
/* Load a 32-bit float constant into the register 2 */
jit_memcpy(&r2.float32_value, pc + 1, sizeof(jit_float32));
}
VMBREAK;
- VMCASE(JIT_OP_LDC_2_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDC_2_FLOAT64):
{
/* Load a 64-bit float constant into the register 2 */
jit_memcpy(&r2.float64_value, pc + 1, sizeof(jit_float64));
}
VMBREAK;
- VMCASE(JIT_OP_LDC_2_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDC_2_NFLOAT):
{
/* Load a native float constant into the registre 2 */
jit_memcpy(&r2.nfloat_value, pc + 1, sizeof(jit_nfloat));
* Load return value.
******************************************************************/
- VMCASE(JIT_OP_LDR_0_INT):
+ VMCASE(JIT_INTERP_OP_LDR_0_INT):
{
/* Load an integer return value into the register 0 */
VM_R0_INT = return_area->int_value;
}
VMBREAK;
- VMCASE(JIT_OP_LDR_0_LONG):
+ VMCASE(JIT_INTERP_OP_LDR_0_LONG):
{
/* Load a long integer return value into the register 0 */
VM_R0_LONG = return_area->long_value;
}
VMBREAK;
- VMCASE(JIT_OP_LDR_0_FLOAT32):
+ VMCASE(JIT_INTERP_OP_LDR_0_FLOAT32):
{
/* Load a 32-bit float return value into the register 0 */
VM_R0_FLOAT32 = return_area->float32_value;
}
VMBREAK;
- VMCASE(JIT_OP_LDR_0_FLOAT64):
+ VMCASE(JIT_INTERP_OP_LDR_0_FLOAT64):
{
/* Load a 64-bit float return value into the register 0 */
VM_R0_FLOAT64 = return_area->float64_value;
}
VMBREAK;
- VMCASE(JIT_OP_LDR_0_NFLOAT):
+ VMCASE(JIT_INTERP_OP_LDR_0_NFLOAT):
{
/* Load a native float return value into the register 0 */
VM_R0_NFLOAT = return_area->nfloat_value;
}
VMBREAK;
- VMCASE(JIT_OP_POP):
+ VMCASE(JIT_INTERP_OP_POP):
{
/* Pop a single item from the stack */
VM_MODIFY_PC_AND_STACK(1, 1);
}
VMBREAK;
- VMCASE(JIT_OP_POP_2):
+ VMCASE(JIT_INTERP_OP_POP_2):
{
/* Pop two items from the stack */
VM_MODIFY_PC_AND_STACK(1, 2);
}
VMBREAK;
- VMCASE(JIT_OP_POP_3):
+ VMCASE(JIT_INTERP_OP_POP_3):
{
/* Pop three items from the stack */
VM_MODIFY_PC_AND_STACK(1, 3);
#include "jit-internal.h"
#include "jit-apply-rules.h"
+#include "jit-interp-opcode.h"
#ifdef __cplusplus
extern "C" {
#define jit_function_interp_entry_pc(info) \
((void **)(((unsigned char *)(info)) + jit_function_interp_size))
-/*
- * Argument variable access opcodes.
- */
-#define JIT_OP_LDA_0_SBYTE (JIT_OP_NUM_OPCODES + 0x0000)
-#define JIT_OP_LDA_0_UBYTE (JIT_OP_NUM_OPCODES + 0x0001)
-#define JIT_OP_LDA_0_SHORT (JIT_OP_NUM_OPCODES + 0x0002)
-#define JIT_OP_LDA_0_USHORT (JIT_OP_NUM_OPCODES + 0x0003)
-#define JIT_OP_LDA_0_INT (JIT_OP_NUM_OPCODES + 0x0004)
-#define JIT_OP_LDA_0_LONG (JIT_OP_NUM_OPCODES + 0x0005)
-#define JIT_OP_LDA_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0006)
-#define JIT_OP_LDA_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0007)
-#define JIT_OP_LDA_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x0008)
-#define JIT_OP_LDAA_0 (JIT_OP_NUM_OPCODES + 0x0009)
-#define JIT_OP_LDA_1_SBYTE (JIT_OP_NUM_OPCODES + 0x000a)
-#define JIT_OP_LDA_1_UBYTE (JIT_OP_NUM_OPCODES + 0x000b)
-#define JIT_OP_LDA_1_SHORT (JIT_OP_NUM_OPCODES + 0x000c)
-#define JIT_OP_LDA_1_USHORT (JIT_OP_NUM_OPCODES + 0x000d)
-#define JIT_OP_LDA_1_INT (JIT_OP_NUM_OPCODES + 0x000e)
-#define JIT_OP_LDA_1_LONG (JIT_OP_NUM_OPCODES + 0x000f)
-#define JIT_OP_LDA_1_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0010)
-#define JIT_OP_LDA_1_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0011)
-#define JIT_OP_LDA_1_NFLOAT (JIT_OP_NUM_OPCODES + 0x0012)
-#define JIT_OP_LDAA_1 (JIT_OP_NUM_OPCODES + 0x0013)
-#define JIT_OP_LDA_2_SBYTE (JIT_OP_NUM_OPCODES + 0x0014)
-#define JIT_OP_LDA_2_UBYTE (JIT_OP_NUM_OPCODES + 0x0015)
-#define JIT_OP_LDA_2_SHORT (JIT_OP_NUM_OPCODES + 0x0016)
-#define JIT_OP_LDA_2_USHORT (JIT_OP_NUM_OPCODES + 0x0017)
-#define JIT_OP_LDA_2_INT (JIT_OP_NUM_OPCODES + 0x0018)
-#define JIT_OP_LDA_2_LONG (JIT_OP_NUM_OPCODES + 0x0019)
-#define JIT_OP_LDA_2_FLOAT32 (JIT_OP_NUM_OPCODES + 0x001a)
-#define JIT_OP_LDA_2_FLOAT64 (JIT_OP_NUM_OPCODES + 0x001b)
-#define JIT_OP_LDA_2_NFLOAT (JIT_OP_NUM_OPCODES + 0x001c)
-#define JIT_OP_LDAA_2 (JIT_OP_NUM_OPCODES + 0x001d)
-#define JIT_OP_STA_0_BYTE (JIT_OP_NUM_OPCODES + 0x001e)
-#define JIT_OP_STA_0_SHORT (JIT_OP_NUM_OPCODES + 0x001f)
-#define JIT_OP_STA_0_INT (JIT_OP_NUM_OPCODES + 0x0020)
-#define JIT_OP_STA_0_LONG (JIT_OP_NUM_OPCODES + 0x0021)
-#define JIT_OP_STA_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0022)
-#define JIT_OP_STA_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0023)
-#define JIT_OP_STA_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x0024)
-
-/*
- * Local variable frame access opcodes.
- */
-#define JIT_OP_LDL_0_SBYTE (JIT_OP_NUM_OPCODES + 0x0025)
-#define JIT_OP_LDL_0_UBYTE (JIT_OP_NUM_OPCODES + 0x0026)
-#define JIT_OP_LDL_0_SHORT (JIT_OP_NUM_OPCODES + 0x0027)
-#define JIT_OP_LDL_0_USHORT (JIT_OP_NUM_OPCODES + 0x0028)
-#define JIT_OP_LDL_0_INT (JIT_OP_NUM_OPCODES + 0x0029)
-#define JIT_OP_LDL_0_LONG (JIT_OP_NUM_OPCODES + 0x002a)
-#define JIT_OP_LDL_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x002b)
-#define JIT_OP_LDL_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x002c)
-#define JIT_OP_LDL_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x002d)
-#define JIT_OP_LDLA_0 (JIT_OP_NUM_OPCODES + 0x002e)
-#define JIT_OP_LDL_1_SBYTE (JIT_OP_NUM_OPCODES + 0x002f)
-#define JIT_OP_LDL_1_UBYTE (JIT_OP_NUM_OPCODES + 0x0030)
-#define JIT_OP_LDL_1_SHORT (JIT_OP_NUM_OPCODES + 0x0031)
-#define JIT_OP_LDL_1_USHORT (JIT_OP_NUM_OPCODES + 0x0032)
-#define JIT_OP_LDL_1_INT (JIT_OP_NUM_OPCODES + 0x0033)
-#define JIT_OP_LDL_1_LONG (JIT_OP_NUM_OPCODES + 0x0034)
-#define JIT_OP_LDL_1_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0035)
-#define JIT_OP_LDL_1_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0036)
-#define JIT_OP_LDL_1_NFLOAT (JIT_OP_NUM_OPCODES + 0x0037)
-#define JIT_OP_LDLA_1 (JIT_OP_NUM_OPCODES + 0x0038)
-#define JIT_OP_LDL_2_SBYTE (JIT_OP_NUM_OPCODES + 0x0039)
-#define JIT_OP_LDL_2_UBYTE (JIT_OP_NUM_OPCODES + 0x003a)
-#define JIT_OP_LDL_2_SHORT (JIT_OP_NUM_OPCODES + 0x003b)
-#define JIT_OP_LDL_2_USHORT (JIT_OP_NUM_OPCODES + 0x003c)
-#define JIT_OP_LDL_2_INT (JIT_OP_NUM_OPCODES + 0x003d)
-#define JIT_OP_LDL_2_LONG (JIT_OP_NUM_OPCODES + 0x003e)
-#define JIT_OP_LDL_2_FLOAT32 (JIT_OP_NUM_OPCODES + 0x003f)
-#define JIT_OP_LDL_2_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0040)
-#define JIT_OP_LDL_2_NFLOAT (JIT_OP_NUM_OPCODES + 0x0041)
-#define JIT_OP_LDLA_2 (JIT_OP_NUM_OPCODES + 0x0042)
-#define JIT_OP_STL_0_BYTE (JIT_OP_NUM_OPCODES + 0x0043)
-#define JIT_OP_STL_0_SHORT (JIT_OP_NUM_OPCODES + 0x0044)
-#define JIT_OP_STL_0_INT (JIT_OP_NUM_OPCODES + 0x0045)
-#define JIT_OP_STL_0_LONG (JIT_OP_NUM_OPCODES + 0x0046)
-#define JIT_OP_STL_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0047)
-#define JIT_OP_STL_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0048)
-#define JIT_OP_STL_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x0049)
-
-/*
- * Load constant values.
- */
-#define JIT_OP_LDC_0_INT (JIT_OP_NUM_OPCODES + 0x004a)
-#define JIT_OP_LDC_1_INT (JIT_OP_NUM_OPCODES + 0x004b)
-#define JIT_OP_LDC_2_INT (JIT_OP_NUM_OPCODES + 0x004c)
-#define JIT_OP_LDC_0_LONG (JIT_OP_NUM_OPCODES + 0x004d)
-#define JIT_OP_LDC_1_LONG (JIT_OP_NUM_OPCODES + 0x004e)
-#define JIT_OP_LDC_2_LONG (JIT_OP_NUM_OPCODES + 0x004f)
-#define JIT_OP_LDC_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0050)
-#define JIT_OP_LDC_1_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0051)
-#define JIT_OP_LDC_2_FLOAT32 (JIT_OP_NUM_OPCODES + 0x0052)
-#define JIT_OP_LDC_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0053)
-#define JIT_OP_LDC_1_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0054)
-#define JIT_OP_LDC_2_FLOAT64 (JIT_OP_NUM_OPCODES + 0x0055)
-#define JIT_OP_LDC_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x0056)
-#define JIT_OP_LDC_1_NFLOAT (JIT_OP_NUM_OPCODES + 0x0057)
-#define JIT_OP_LDC_2_NFLOAT (JIT_OP_NUM_OPCODES + 0x0058)
-
-/*
- * Load return value.
- */
-#define JIT_OP_LDR_0_INT (JIT_OP_NUM_OPCODES + 0x0059)
-#define JIT_OP_LDR_0_LONG (JIT_OP_NUM_OPCODES + 0x005a)
-#define JIT_OP_LDR_0_FLOAT32 (JIT_OP_NUM_OPCODES + 0x005b)
-#define JIT_OP_LDR_0_FLOAT64 (JIT_OP_NUM_OPCODES + 0x005c)
-#define JIT_OP_LDR_0_NFLOAT (JIT_OP_NUM_OPCODES + 0x005d)
-
-/*
- * Stack management.
- */
-#define JIT_OP_POP (JIT_OP_NUM_OPCODES + 0x005e)
-#define JIT_OP_POP_2 (JIT_OP_NUM_OPCODES + 0x005f)
-#define JIT_OP_POP_3 (JIT_OP_NUM_OPCODES + 0x0060)
-
-/*
- * Nested function call handling.
- */
-#define JIT_OP_IMPORT_LOCAL (JIT_OP_NUM_OPCODES + 0x0061)
-#define JIT_OP_IMPORT_ARG (JIT_OP_NUM_OPCODES + 0x0062)
-
-/*
- * Marker opcode for the end of the interpreter-specific opcodes.
- */
-#define JIT_OP_END_MARKER (JIT_OP_NUM_OPCODES + 0x0063)
-
-/*
- * Number of interpreter-specific opcodes.
- */
-#define JIT_OP_NUM_INTERP_OPCODES \
- (JIT_OP_END_MARKER + 1 - JIT_OP_NUM_OPCODES)
-
-/*
- * Opcode version. Should be increased whenever new opcodes
- * are added to this list or the public list in "jit-opcode.h".
- * This value is written to ELF binaries, to ensure that code
- * for one version of libjit is not inadvertantly used in another.
- */
-#define JIT_OPCODE_VERSION 0
-
-/*
- * Additional opcode definition flags.
- */
-#define JIT_OPCODE_INTERP_ARGS_MASK 0x7E000000
-#define JIT_OPCODE_NINT_ARG 0x02000000
-#define JIT_OPCODE_NINT_ARG_TWO 0x04000000
-#define JIT_OPCODE_CONST_LONG 0x06000000
-#define JIT_OPCODE_CONST_FLOAT32 0x08000000
-#define JIT_OPCODE_CONST_FLOAT64 0x0A000000
-#define JIT_OPCODE_CONST_NFLOAT 0x0C000000
-#define JIT_OPCODE_CALL_INDIRECT_ARGS 0x0E000000
-
#ifdef __cplusplus
};
#endif
+++ /dev/null
-/*
- * jit-opcode.c - Information about all of the JIT opcodes.
- *
- * Copyright (C) 2004 Southern Storm Software, Pty Ltd.
- *
- * This file is part of the libjit library.
- *
- * The libjit library is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * as published by the Free Software Foundation, either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * The libjit library 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
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with the libjit library. If not, see
- * <http://www.gnu.org/licenses/>.
- */
-
-#include "jit-internal.h"
-#include "jit-rules.h"
-
-#define F_(dest,src1,src2) \
- (JIT_OPCODE_DEST_##dest | JIT_OPCODE_SRC1_##src1 | JIT_OPCODE_SRC2_##src2)
-#define O_(dest,src1,src2,oper) \
- (JIT_OPCODE_DEST_##dest | JIT_OPCODE_SRC1_##src1 | \
- JIT_OPCODE_SRC2_##src2 | JIT_OPCODE_OPER_##oper)
-#define B_(src1,src2) \
- (JIT_OPCODE_IS_BRANCH | JIT_OPCODE_SRC1_##src1 | JIT_OPCODE_SRC2_##src2)
-#define A_(src1,src2,oper) \
- (JIT_OPCODE_IS_BRANCH | JIT_OPCODE_SRC1_##src1 | \
- JIT_OPCODE_SRC2_##src2 | JIT_OPCODE_OPER_##oper)
-#if defined(JIT_BACKEND_INTERP)
- #define NINT_ARG JIT_OPCODE_NINT_ARG
- #define NINT_ARG_TWO JIT_OPCODE_NINT_ARG_TWO
- #define INDIRECT_ARGS JIT_OPCODE_CALL_INDIRECT_ARGS
-#else
- #define NINT_ARG 0
- #define NINT_ARG_TWO 0
- #define INDIRECT_ARGS 0
-#endif
-
-jit_opcode_info_t const jit_opcodes[JIT_OP_NUM_OPCODES] = {
-
- /*
- * Simple opcodes.
- */
- {"nop", F_(EMPTY, EMPTY, EMPTY)},
-
- /*
- * Conversion opcodes.
- */
- {"trunc_sbyte", F_(INT, INT, EMPTY)},
- {"trunc_ubyte", F_(INT, INT, EMPTY)},
- {"trunc_short", F_(INT, INT, EMPTY)},
- {"trunc_ushort", F_(INT, INT, EMPTY)},
- {"trunc_int", F_(INT, INT, EMPTY)},
- {"trunc_uint", F_(INT, INT, EMPTY)},
- {"check_sbyte", F_(INT, INT, EMPTY)},
- {"check_ubyte", F_(INT, INT, EMPTY)},
- {"check_short", F_(INT, INT, EMPTY)},
- {"check_ushort", F_(INT, INT, EMPTY)},
- {"check_int", F_(INT, INT, EMPTY)},
- {"check_uint", F_(INT, INT, EMPTY)},
- {"low_word", F_(INT, LONG, EMPTY)},
- {"expand_int", F_(LONG, INT, EMPTY)},
- {"expand_uint", F_(LONG, INT, EMPTY)},
- {"check_low_word", F_(INT, LONG, EMPTY)},
- {"check_signed_low_word", F_(INT, LONG, EMPTY)},
- {"check_long", F_(LONG, LONG, EMPTY)},
- {"check_ulong", F_(LONG, LONG, EMPTY)},
- {"nfloat_to_int", F_(INT, NFLOAT, EMPTY)},
- {"nfloat_to_uint", F_(INT, NFLOAT, EMPTY)},
- {"nfloat_to_long", F_(LONG, NFLOAT, EMPTY)},
- {"nfloat_to_ulong", F_(LONG, NFLOAT, EMPTY)},
- {"check_nfloat_to_int", F_(INT, NFLOAT, EMPTY)},
- {"check_nfloat_to_uint", F_(INT, NFLOAT, EMPTY)},
- {"check_nfloat_to_long", F_(LONG, NFLOAT, EMPTY)},
- {"check_nfloat_to_ulong", F_(LONG, NFLOAT, EMPTY)},
- {"int_to_nfloat", F_(NFLOAT, INT, EMPTY)},
- {"uint_to_nfloat", F_(NFLOAT, INT, EMPTY)},
- {"long_to_nfloat", F_(NFLOAT, LONG, EMPTY)},
- {"ulong_to_nfloat", F_(NFLOAT, LONG, EMPTY)},
- {"nfloat_to_float32", F_(FLOAT32, NFLOAT, EMPTY)},
- {"nfloat_to_float64", F_(FLOAT64, NFLOAT, EMPTY)},
- {"float32_to_nfloat", F_(NFLOAT, FLOAT32, EMPTY)},
- {"float64_to_nfloat", F_(NFLOAT, FLOAT64, EMPTY)},
-
- /*
- * Arithmetic opcodes.
- */
- {"iadd", O_(INT, INT, INT, ADD)},
- {"iadd_ovf", F_(INT, INT, INT)},
- {"iadd_ovf_un", F_(INT, INT, INT)},
- {"isub", O_(INT, INT, INT, SUB)},
- {"isub_ovf", F_(INT, INT, INT)},
- {"isub_ovf_un", F_(INT, INT, INT)},
- {"imul", O_(INT, INT, INT, MUL)},
- {"imul_ovf", F_(INT, INT, INT)},
- {"imul_ovf_un", F_(INT, INT, INT)},
- {"idiv", O_(INT, INT, INT, DIV)},
- {"idiv_un", F_(INT, INT, INT)},
- {"irem", O_(INT, INT, INT, REM)},
- {"irem_un", F_(INT, INT, INT)},
- {"ineg", O_(INT, INT, EMPTY, NEG)},
- {"ladd", O_(LONG, LONG, LONG, ADD)},
- {"ladd_ovf", F_(LONG, LONG, LONG)},
- {"ladd_ovf_un", F_(LONG, LONG, LONG)},
- {"lsub", O_(LONG, LONG, LONG, SUB)},
- {"lsub_ovf", F_(LONG, LONG, LONG)},
- {"lsub_ovf_un", F_(LONG, LONG, LONG)},
- {"lmul", O_(LONG, LONG, LONG, MUL)},
- {"lmul_ovf", F_(LONG, LONG, LONG)},
- {"lmul_ovf_un", F_(LONG, LONG, LONG)},
- {"ldiv", O_(LONG, LONG, LONG, DIV)},
- {"ldiv_un", F_(LONG, LONG, LONG)},
- {"lrem", O_(LONG, LONG, LONG, REM)},
- {"lrem_un", F_(LONG, LONG, LONG)},
- {"lneg", O_(LONG, LONG, EMPTY, NEG)},
- {"fadd", O_(FLOAT32, FLOAT32, FLOAT32, ADD)},
- {"fsub", O_(FLOAT32, FLOAT32, FLOAT32, SUB)},
- {"fmul", O_(FLOAT32, FLOAT32, FLOAT32, MUL)},
- {"fdiv", O_(FLOAT32, FLOAT32, FLOAT32, DIV)},
- {"frem", O_(FLOAT32, FLOAT32, FLOAT32, REM)},
- {"frem_ieee", F_(FLOAT32, FLOAT32, FLOAT32)},
- {"fneg", O_(FLOAT32, FLOAT32, EMPTY, NEG)},
- {"dadd", O_(FLOAT64, FLOAT64, FLOAT64, ADD)},
- {"dsub", O_(FLOAT64, FLOAT64, FLOAT64, SUB)},
- {"dmul", O_(FLOAT64, FLOAT64, FLOAT64, MUL)},
- {"ddiv", O_(FLOAT64, FLOAT64, FLOAT64, DIV)},
- {"drem", O_(FLOAT64, FLOAT64, FLOAT64, REM)},
- {"drem_ieee", F_(FLOAT64, FLOAT64, FLOAT64)},
- {"dneg", O_(FLOAT64, FLOAT64, EMPTY, NEG)},
- {"nfadd", O_(NFLOAT, NFLOAT, NFLOAT, ADD)},
- {"nfsub", O_(NFLOAT, NFLOAT, NFLOAT, SUB)},
- {"nfmul", O_(NFLOAT, NFLOAT, NFLOAT, MUL)},
- {"nfdiv", O_(NFLOAT, NFLOAT, NFLOAT, DIV)},
- {"nfrem", O_(NFLOAT, NFLOAT, NFLOAT, REM)},
- {"nfrem_ieee", F_(NFLOAT, NFLOAT, NFLOAT)},
- {"nfneg", O_(NFLOAT, NFLOAT, EMPTY, NEG)},
-
- /*
- * Bitwise opcodes.
- */
- {"iand", O_(INT, INT, INT, AND)},
- {"ior", O_(INT, INT, INT, OR)},
- {"ixor", O_(INT, INT, INT, XOR)},
- {"inot", O_(INT, INT, EMPTY, NOT)},
- {"ishl", O_(INT, INT, INT, SHL)},
- {"ishr", O_(INT, INT, INT, SHR)},
- {"ishr_un", O_(INT, INT, INT, SHR_UN)},
- {"land", O_(LONG, LONG, LONG, AND)},
- {"lor", O_(LONG, LONG, LONG, OR)},
- {"lxor", O_(LONG, LONG, LONG, XOR)},
- {"lnot", O_(LONG, LONG, EMPTY, NOT)},
- {"lshl", O_(LONG, LONG, INT, SHL)},
- {"lshr", O_(LONG, LONG, INT, SHR)},
- {"lshr_un", O_(LONG, LONG, INT, SHR_UN)},
-
- /*
- * Branch opcodes.
- */
- {"br", B_(EMPTY, EMPTY)},
- {"br_ifalse", B_(INT, EMPTY)},
- {"br_itrue", B_(INT, EMPTY)},
- {"br_ieq", A_(INT, INT, EQ)},
- {"br_ine", A_(INT, INT, NE)},
- {"br_ilt", A_(INT, INT, LT)},
- {"br_ilt_un", B_(INT, INT)},
- {"br_ile", A_(INT, INT, LE)},
- {"br_ile_un", B_(INT, INT)},
- {"br_igt", A_(INT, INT, GT)},
- {"br_igt_un", B_(INT, INT)},
- {"br_ige", A_(INT, INT, GE)},
- {"br_ige_un", B_(INT, INT)},
- {"br_lfalse", B_(LONG, EMPTY)},
- {"br_ltrue", B_(LONG, EMPTY)},
- {"br_leq", A_(LONG, LONG, EQ)},
- {"br_lne", A_(LONG, LONG, NE)},
- {"br_llt", A_(LONG, LONG, LT)},
- {"br_llt_un", B_(LONG, LONG)},
- {"br_lle", A_(LONG, LONG, LE)},
- {"br_lle_un", B_(LONG, LONG)},
- {"br_lgt", A_(LONG, LONG, GT)},
- {"br_lgt_un", B_(LONG, LONG)},
- {"br_lge", A_(LONG, LONG, GE)},
- {"br_lge_un", B_(LONG, LONG)},
- {"br_feq", A_(FLOAT32, FLOAT32, EQ)},
- {"br_fne", A_(FLOAT32, FLOAT32, NE)},
- {"br_flt", A_(FLOAT32, FLOAT32, LT)},
- {"br_fle", A_(FLOAT32, FLOAT32, LE)},
- {"br_fgt", A_(FLOAT32, FLOAT32, GT)},
- {"br_fge", A_(FLOAT32, FLOAT32, GE)},
- {"br_feq_inv", B_(FLOAT32, FLOAT32)},
- {"br_fne_inv", B_(FLOAT32, FLOAT32)},
- {"br_flt_inv", B_(FLOAT32, FLOAT32)},
- {"br_fle_inv", B_(FLOAT32, FLOAT32)},
- {"br_fgt_inv", B_(FLOAT32, FLOAT32)},
- {"br_fge_inv", B_(FLOAT32, FLOAT32)},
- {"br_deq", A_(FLOAT64, FLOAT64, EQ)},
- {"br_dne", A_(FLOAT64, FLOAT64, NE)},
- {"br_dlt", A_(FLOAT64, FLOAT64, LT)},
- {"br_dle", A_(FLOAT64, FLOAT64, LE)},
- {"br_dgt", A_(FLOAT64, FLOAT64, GT)},
- {"br_dge", A_(FLOAT64, FLOAT64, GE)},
- {"br_deq_inv", B_(FLOAT64, FLOAT64)},
- {"br_dne_inv", B_(FLOAT64, FLOAT64)},
- {"br_dlt_inv", B_(FLOAT64, FLOAT64)},
- {"br_dle_inv", B_(FLOAT64, FLOAT64)},
- {"br_dgt_inv", B_(FLOAT64, FLOAT64)},
- {"br_dge_inv", B_(FLOAT64, FLOAT64)},
- {"br_nfeq", A_(NFLOAT, NFLOAT, EQ)},
- {"br_nfne", A_(NFLOAT, NFLOAT, NE)},
- {"br_nflt", A_(NFLOAT, NFLOAT, LT)},
- {"br_nfle", A_(NFLOAT, NFLOAT, LE)},
- {"br_nfgt", A_(NFLOAT, NFLOAT, GT)},
- {"br_nfge", A_(NFLOAT, NFLOAT, GE)},
- {"br_nfeq_inv", B_(NFLOAT, NFLOAT)},
- {"br_nfne_inv", B_(NFLOAT, NFLOAT)},
- {"br_nflt_inv", B_(NFLOAT, NFLOAT)},
- {"br_nfle_inv", B_(NFLOAT, NFLOAT)},
- {"br_nfgt_inv", B_(NFLOAT, NFLOAT)},
- {"br_nfge_inv", B_(NFLOAT, NFLOAT)},
-
- /*
- * Comparison opcodes.
- */
- {"icmp", F_(INT, INT, INT)},
- {"icmp_un", F_(INT, INT, INT)},
- {"lcmp", F_(INT, LONG, LONG)},
- {"lcmp_un", F_(INT, LONG, LONG)},
- {"fcmpl", F_(INT, FLOAT32, FLOAT32)},
- {"fcmpg", F_(INT, FLOAT32, FLOAT32)},
- {"dcmpl", F_(INT, FLOAT64, FLOAT64)},
- {"dcmpg", F_(INT, FLOAT64, FLOAT64)},
- {"nfcmpl", F_(INT, NFLOAT, NFLOAT)},
- {"nfcmpg", F_(INT, NFLOAT, NFLOAT)},
- {"ieq", O_(INT, INT, INT, EQ)},
- {"ine", O_(INT, INT, INT, NE)},
- {"ilt", O_(INT, INT, INT, LT)},
- {"ilt_un", F_(INT, INT, INT)},
- {"ile", O_(INT, INT, INT, LE)},
- {"ile_un", F_(INT, INT, INT)},
- {"igt", O_(INT, INT, INT, GT)},
- {"igt_un", F_(INT, INT, INT)},
- {"ige", O_(INT, INT, INT, GE)},
- {"ige_un", F_(INT, INT, INT)},
- {"leq", O_(INT, LONG, LONG, EQ)},
- {"lne", O_(INT, LONG, LONG, NE)},
- {"llt", O_(INT, LONG, LONG, LT)},
- {"llt_un", F_(INT, LONG, LONG)},
- {"lle", O_(INT, LONG, LONG, LE)},
- {"lle_un", F_(INT, LONG, LONG)},
- {"lgt", O_(INT, LONG, LONG, GT)},
- {"lgt_un", F_(INT, LONG, LONG)},
- {"lge", O_(INT, LONG, LONG, GE)},
- {"lge_un", F_(INT, LONG, LONG)},
- {"feq", O_(INT, FLOAT32, FLOAT32, EQ)},
- {"fne", O_(INT, FLOAT32, FLOAT32, NE)},
- {"flt", O_(INT, FLOAT32, FLOAT32, LT)},
- {"fle", O_(INT, FLOAT32, FLOAT32, LE)},
- {"fgt", O_(INT, FLOAT32, FLOAT32, GT)},
- {"fge", O_(INT, FLOAT32, FLOAT32, GE)},
- {"feq_inv", F_(INT, FLOAT32, FLOAT32)},
- {"fne_inv", F_(INT, FLOAT32, FLOAT32)},
- {"flt_inv", F_(INT, FLOAT32, FLOAT32)},
- {"fle_inv", F_(INT, FLOAT32, FLOAT32)},
- {"fgt_inv", F_(INT, FLOAT32, FLOAT32)},
- {"fge_inv", F_(INT, FLOAT32, FLOAT32)},
- {"deq", O_(INT, FLOAT64, FLOAT64, EQ)},
- {"dne", O_(INT, FLOAT64, FLOAT64, NE)},
- {"dlt", O_(INT, FLOAT64, FLOAT64, LT)},
- {"dle", O_(INT, FLOAT64, FLOAT64, LE)},
- {"dgt", O_(INT, FLOAT64, FLOAT64, GT)},
- {"dge", O_(INT, FLOAT64, FLOAT64, GE)},
- {"deq_inv", F_(INT, FLOAT64, FLOAT64)},
- {"dne_inv", F_(INT, FLOAT64, FLOAT64)},
- {"dlt_inv", F_(INT, FLOAT64, FLOAT64)},
- {"dle_inv", F_(INT, FLOAT64, FLOAT64)},
- {"dgt_inv", F_(INT, FLOAT64, FLOAT64)},
- {"dge_inv", F_(INT, FLOAT64, FLOAT64)},
- {"nfeq", O_(INT, NFLOAT, NFLOAT, EQ)},
- {"nfne", O_(INT, NFLOAT, NFLOAT, NE)},
- {"nflt", O_(INT, NFLOAT, NFLOAT, LT)},
- {"nfle", O_(INT, NFLOAT, NFLOAT, LE)},
- {"nfgt", O_(INT, NFLOAT, NFLOAT, GT)},
- {"nfge", O_(INT, NFLOAT, NFLOAT, GE)},
- {"nfeq_inv", F_(INT, NFLOAT, NFLOAT)},
- {"nfne_inv", F_(INT, NFLOAT, NFLOAT)},
- {"nflt_inv", F_(INT, NFLOAT, NFLOAT)},
- {"nfle_inv", F_(INT, NFLOAT, NFLOAT)},
- {"nfgt_inv", F_(INT, NFLOAT, NFLOAT)},
- {"nfge_inv", F_(INT, NFLOAT, NFLOAT)},
- {"is_fnan", F_(INT, FLOAT32, EMPTY)},
- {"is_finf", F_(INT, FLOAT32, EMPTY)},
- {"is_ffinite", F_(INT, FLOAT32, EMPTY)},
- {"is_dnan", F_(INT, FLOAT64, EMPTY)},
- {"is_dinf", F_(INT, FLOAT64, EMPTY)},
- {"is_dfinite", F_(INT, FLOAT64, EMPTY)},
- {"is_nfnan", F_(INT, NFLOAT, EMPTY)},
- {"is_nfinf", F_(INT, NFLOAT, EMPTY)},
- {"is_nffinite", F_(INT, NFLOAT, EMPTY)},
-
- /*
- * Mathematical functions.
- */
- {"facos", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fasin", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fatan", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fatan2", F_(FLOAT32, FLOAT32, FLOAT32)},
- {"fceil", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fcos", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fcosh", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fexp", F_(FLOAT32, FLOAT32, EMPTY)},
- {"ffloor", F_(FLOAT32, FLOAT32, EMPTY)},
- {"flog", F_(FLOAT32, FLOAT32, EMPTY)},
- {"flog10", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fpow", F_(FLOAT32, FLOAT32, FLOAT32)},
- {"frint", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fround", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fsin", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fsinh", F_(FLOAT32, FLOAT32, EMPTY)},
- {"fsqrt", F_(FLOAT32, FLOAT32, EMPTY)},
- {"ftan", F_(FLOAT32, FLOAT32, EMPTY)},
- {"ftanh", F_(FLOAT32, FLOAT32, EMPTY)},
- {"dacos", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dasin", F_(FLOAT64, FLOAT64, EMPTY)},
- {"datan", F_(FLOAT64, FLOAT64, EMPTY)},
- {"datan2", F_(FLOAT64, FLOAT64, FLOAT64)},
- {"dceil", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dcos", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dcosh", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dexp", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dfloor", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dlog", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dlog10", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dpow", F_(FLOAT64, FLOAT64, FLOAT64)},
- {"drint", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dround", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dsin", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dsinh", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dsqrt", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dtan", F_(FLOAT64, FLOAT64, EMPTY)},
- {"dtanh", F_(FLOAT64, FLOAT64, EMPTY)},
- {"nfacos", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfasin", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfatan", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfatan2", F_(NFLOAT, NFLOAT, NFLOAT)},
- {"nfceil", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfcos", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfcosh", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfexp", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nffloor", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nflog", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nflog10", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfpow", F_(NFLOAT, NFLOAT, NFLOAT)},
- {"nfrint", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfround", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfsin", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfsinh", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nfsqrt", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nftan", F_(NFLOAT, NFLOAT, EMPTY)},
- {"nftanh", F_(NFLOAT, NFLOAT, EMPTY)},
-
- /*
- * Absolute, minimum, maximum, and sign.
- */
- {"iabs", F_(INT, INT, EMPTY)},
- {"labs", F_(LONG, LONG, EMPTY)},
- {"fabs", F_(FLOAT32, FLOAT32, EMPTY)},
- {"dabs", F_(FLOAT64, FLOAT64, EMPTY)},
- {"nfabs", F_(NFLOAT, NFLOAT, EMPTY)},
- {"imin", F_(INT, INT, INT)},
- {"imin_un", F_(INT, INT, INT)},
- {"lmin", F_(LONG, LONG, LONG)},
- {"lmin_un", F_(LONG, LONG, LONG)},
- {"fmin", F_(FLOAT32, FLOAT32, FLOAT32)},
- {"dmin", F_(FLOAT64, FLOAT64, FLOAT64)},
- {"nfmin", F_(NFLOAT, NFLOAT, NFLOAT)},
- {"imax", F_(INT, INT, INT)},
- {"imax_un", F_(INT, INT, INT)},
- {"lmax", F_(LONG, LONG, LONG)},
- {"lmax_un", F_(LONG, LONG, LONG)},
- {"fmax", F_(FLOAT32, FLOAT32, FLOAT32)},
- {"dmax", F_(FLOAT64, FLOAT64, FLOAT64)},
- {"nfmax", F_(NFLOAT, NFLOAT, NFLOAT)},
- {"isign", F_(INT, INT, EMPTY)},
- {"lsign", F_(INT, LONG, EMPTY)},
- {"fsign", F_(INT, FLOAT32, EMPTY)},
- {"dsign", F_(INT, FLOAT64, EMPTY)},
- {"nfsign", F_(INT, NFLOAT, EMPTY)},
-
- /*
- * Pointer check opcodes.
- */
- {"check_null", F_(EMPTY, PTR, EMPTY)},
-
- /*
- * Function calls.
- */
- {"call", JIT_OPCODE_IS_CALL},
- {"call_tail", JIT_OPCODE_IS_CALL},
- {"call_indirect", F_(EMPTY, PTR, EMPTY) | INDIRECT_ARGS},
- {"call_indirect_tail", F_(EMPTY, PTR, EMPTY) | INDIRECT_ARGS},
- {"call_vtable_ptr", F_(EMPTY, PTR, EMPTY)},
- {"call_vtable_ptr_tail", F_(EMPTY, PTR, EMPTY)},
- {"call_external", JIT_OPCODE_IS_CALL_EXTERNAL},
- {"call_external_tail", JIT_OPCODE_IS_CALL_EXTERNAL},
- {"return", F_(EMPTY, EMPTY, EMPTY)},
- {"return_int", F_(EMPTY, INT, EMPTY)},
- {"return_long", F_(EMPTY, LONG, EMPTY)},
- {"return_float32", F_(EMPTY, FLOAT32, EMPTY)},
- {"return_float64", F_(EMPTY, FLOAT64, EMPTY)},
- {"return_nfloat", F_(EMPTY, NFLOAT, EMPTY)},
- {"return_small_struct", F_(EMPTY, PTR, PTR) | NINT_ARG},
- {"setup_for_nested", F_(EMPTY, INT, EMPTY)},
- {"setup_for_sibling", F_(EMPTY, INT, INT) | NINT_ARG},
- {"import", F_(PTR, ANY, INT)},
-
- /*
- * Exception handling.
- */
- {"throw", F_(EMPTY, PTR, EMPTY)},
- {"rethrow", F_(EMPTY, PTR, EMPTY)},
- {"load_pc", F_(PTR, EMPTY, EMPTY)},
- {"load_exception_pc", F_(PTR, EMPTY, EMPTY)},
- {"enter_finally", F_(EMPTY, EMPTY, EMPTY)},
- {"leave_finally", F_(EMPTY, EMPTY, EMPTY)},
- {"call_finally", B_(EMPTY, EMPTY)},
- {"enter_filter", F_(ANY, EMPTY, EMPTY)},
- {"leave_filter", F_(EMPTY, ANY, EMPTY)},
- {"call_filter", B_(ANY, EMPTY)},
- {"call_filter_return", F_(ANY, EMPTY, EMPTY)},
- {"address_of_label", JIT_OPCODE_IS_ADDROF_LABEL},
-
- /*
- * Data manipulation.
- */
- {"copy_load_sbyte", F_(INT, INT, EMPTY)},
- {"copy_load_ubyte", F_(INT, INT, EMPTY)},
- {"copy_load_short", F_(INT, INT, EMPTY)},
- {"copy_load_ushort", F_(INT, INT, EMPTY)},
- {"copy_int", O_(INT, INT, EMPTY, COPY)},
- {"copy_long", O_(LONG, LONG, EMPTY, COPY)},
- {"copy_float32", O_(FLOAT32, FLOAT32, EMPTY, COPY)},
- {"copy_float64", O_(FLOAT64, FLOAT64, EMPTY, COPY)},
- {"copy_nfloat", O_(NFLOAT, NFLOAT, EMPTY, COPY)},
- {"copy_struct", O_(PTR, PTR, EMPTY, COPY) | NINT_ARG},
- {"copy_store_byte", F_(INT, INT, EMPTY)},
- {"copy_store_short", F_(INT, INT, EMPTY)},
- {"address_of", O_(PTR, ANY, EMPTY, ADDRESS_OF)},
-
- /*
- * Incoming registers, outgoing registers, and stack pushes.
- */
- {"incoming_reg", JIT_OPCODE_IS_REG},
- {"incoming_frame_posn", F_(EMPTY, ANY, INT)},
- {"outgoing_reg", JIT_OPCODE_IS_REG},
- {"outgoing_frame_posn", F_(EMPTY, ANY, INT)},
- {"return_reg", JIT_OPCODE_IS_REG},
- {"push_int", F_(EMPTY, INT, EMPTY)},
- {"push_long", F_(EMPTY, LONG, EMPTY)},
- {"push_float32", F_(EMPTY, FLOAT32, EMPTY)},
- {"push_float64", F_(EMPTY, FLOAT64, EMPTY)},
- {"push_nfloat", F_(EMPTY, NFLOAT, EMPTY)},
- {"push_struct", F_(EMPTY, ANY, PTR) | NINT_ARG},
- {"pop_stack", F_(EMPTY, INT, EMPTY) | NINT_ARG},
- {"flush_small_struct", F_(EMPTY, ANY, EMPTY) | NINT_ARG},
- {"set_param_int", F_(EMPTY, INT, PTR)},
- {"set_param_long", F_(EMPTY, LONG, PTR)},
- {"set_param_float32", F_(EMPTY, FLOAT32, PTR)},
- {"set_param_float64", F_(EMPTY, FLOAT64, PTR)},
- {"set_param_nfloat", F_(EMPTY, NFLOAT, PTR)},
- {"set_param_struct", F_(PTR, PTR, PTR)},
- {"push_return_area_ptr", F_(EMPTY, EMPTY, EMPTY)},
-
- /*
- * Pointer-relative loads and stores.
- */
- {"load_relative_sbyte", F_(INT, PTR, INT) | NINT_ARG},
- {"load_relative_ubyte", F_(INT, PTR, INT) | NINT_ARG},
- {"load_relative_short", F_(INT, PTR, INT) | NINT_ARG},
- {"load_relative_ushort", F_(INT, PTR, INT) | NINT_ARG},
- {"load_relative_int", F_(INT, PTR, INT) | NINT_ARG},
- {"load_relative_long", F_(LONG, PTR, INT) | NINT_ARG},
- {"load_relative_float32", F_(FLOAT32, PTR, INT) | NINT_ARG},
- {"load_relative_float64", F_(FLOAT64, PTR, INT) | NINT_ARG},
- {"load_relative_nfloat", F_(NFLOAT, PTR, INT) | NINT_ARG},
- {"load_relative_struct", F_(ANY, PTR, INT) | NINT_ARG_TWO},
- {"store_relative_byte", F_(PTR, INT, INT) | NINT_ARG},
- {"store_relative_short", F_(PTR, INT, INT) | NINT_ARG},
- {"store_relative_int", F_(PTR, INT, INT) | NINT_ARG},
- {"store_relative_long", F_(PTR, LONG, INT) | NINT_ARG},
- {"store_relative_float32", F_(PTR, FLOAT32, INT) | NINT_ARG},
- {"store_relative_float64", F_(PTR, FLOAT64, INT) | NINT_ARG},
- {"store_relative_nfloat", F_(PTR, NFLOAT, INT) | NINT_ARG},
- {"store_relative_struct", F_(PTR, ANY, INT) | NINT_ARG_TWO},
- {"add_relative", F_(PTR, PTR, INT) | NINT_ARG},
-
- /*
- * Array element loads and stores.
- */
- {"load_element_sbyte", F_(INT, PTR, INT)},
- {"load_element_ubyte", F_(INT, PTR, INT)},
- {"load_element_short", F_(INT, PTR, INT)},
- {"load_element_ushort", F_(INT, PTR, INT)},
- {"load_element_int", F_(INT, PTR, INT)},
- {"load_element_long", F_(LONG, PTR, INT)},
- {"load_element_float32", F_(FLOAT32, PTR, INT)},
- {"load_element_float64", F_(FLOAT64, PTR, INT)},
- {"load_element_nfloat", F_(NFLOAT, PTR, INT)},
- {"store_element_byte", F_(PTR, INT, INT)},
- {"store_element_short", F_(PTR, INT, INT)},
- {"store_element_int", F_(PTR, INT, INT)},
- {"store_element_long", F_(PTR, INT, LONG)},
- {"store_element_float32", F_(PTR, INT, FLOAT32)},
- {"store_element_float64", F_(PTR, INT, FLOAT64)},
- {"store_element_nfloat", F_(PTR, INT, NFLOAT)},
-
- /*
- * Block operations.
- */
- {"memcpy", F_(PTR, PTR, PTR)},
- {"memmove", F_(PTR, PTR, PTR)},
- {"memset", F_(PTR, INT, PTR)},
-
- /*
- * Allocate memory from the stack.
- */
- {"alloca", F_(PTR, PTR, EMPTY)},
-
- /*
- * Debugging support.
- */
- {"mark_offset", F_(EMPTY, INT, EMPTY)},
- {"mark_breakpoint", F_(EMPTY, PTR, PTR)},
-
- /*
- * Switch statement support.
- */
- {"jump_table", F_(ANY, PTR, INT)|JIT_OPCODE_IS_JUMP_TABLE},
-};
-
-#if defined(JIT_BACKEND_INTERP)
-
-jit_opcode_info_t const _jit_interp_opcodes[JIT_OP_NUM_INTERP_OPCODES] = {
-
- /*
- * Argument variable access opcodes.
- */
- {"lda_0_sbyte", JIT_OPCODE_NINT_ARG},
- {"lda_0_ubyte", JIT_OPCODE_NINT_ARG},
- {"lda_0_short", JIT_OPCODE_NINT_ARG},
- {"lda_0_ushort", JIT_OPCODE_NINT_ARG},
- {"lda_0_int", JIT_OPCODE_NINT_ARG},
- {"lda_0_long", JIT_OPCODE_NINT_ARG},
- {"lda_0_float32", JIT_OPCODE_NINT_ARG},
- {"lda_0_float64", JIT_OPCODE_NINT_ARG},
- {"lda_0_nfloat", JIT_OPCODE_NINT_ARG},
- {"ldaa_0", JIT_OPCODE_NINT_ARG},
- {"lda_1_sbyte", JIT_OPCODE_NINT_ARG},
- {"lda_1_ubyte", JIT_OPCODE_NINT_ARG},
- {"lda_1_short", JIT_OPCODE_NINT_ARG},
- {"lda_1_ushort", JIT_OPCODE_NINT_ARG},
- {"lda_1_int", JIT_OPCODE_NINT_ARG},
- {"lda_1_long", JIT_OPCODE_NINT_ARG},
- {"lda_1_float32", JIT_OPCODE_NINT_ARG},
- {"lda_1_float64", JIT_OPCODE_NINT_ARG},
- {"lda_1_nfloat", JIT_OPCODE_NINT_ARG},
- {"ldaa_1", JIT_OPCODE_NINT_ARG},
- {"lda_2_sbyte", JIT_OPCODE_NINT_ARG},
- {"lda_2_ubyte", JIT_OPCODE_NINT_ARG},
- {"lda_2_short", JIT_OPCODE_NINT_ARG},
- {"lda_2_ushort", JIT_OPCODE_NINT_ARG},
- {"lda_2_int", JIT_OPCODE_NINT_ARG},
- {"lda_2_long", JIT_OPCODE_NINT_ARG},
- {"lda_2_float32", JIT_OPCODE_NINT_ARG},
- {"lda_2_float64", JIT_OPCODE_NINT_ARG},
- {"lda_2_nfloat", JIT_OPCODE_NINT_ARG},
- {"ldaa_2", JIT_OPCODE_NINT_ARG},
- {"sta_0_byte", JIT_OPCODE_NINT_ARG},
- {"sta_0_short", JIT_OPCODE_NINT_ARG},
- {"sta_0_int", JIT_OPCODE_NINT_ARG},
- {"sta_0_long", JIT_OPCODE_NINT_ARG},
- {"sta_0_float32", JIT_OPCODE_NINT_ARG},
- {"sta_0_float64", JIT_OPCODE_NINT_ARG},
- {"sta_0_nfloat", JIT_OPCODE_NINT_ARG},
-
- /*
- * Local variable frame access opcodes.
- */
- {"ldl_0_sbyte", JIT_OPCODE_NINT_ARG},
- {"ldl_0_ubyte", JIT_OPCODE_NINT_ARG},
- {"ldl_0_short", JIT_OPCODE_NINT_ARG},
- {"ldl_0_ushort", JIT_OPCODE_NINT_ARG},
- {"ldl_0_int", JIT_OPCODE_NINT_ARG},
- {"ldl_0_long", JIT_OPCODE_NINT_ARG},
- {"ldl_0_float32", JIT_OPCODE_NINT_ARG},
- {"ldl_0_float64", JIT_OPCODE_NINT_ARG},
- {"ldl_0_nfloat", JIT_OPCODE_NINT_ARG},
- {"ldla_0", JIT_OPCODE_NINT_ARG},
- {"ldl_1_sbyte", JIT_OPCODE_NINT_ARG},
- {"ldl_1_ubyte", JIT_OPCODE_NINT_ARG},
- {"ldl_1_short", JIT_OPCODE_NINT_ARG},
- {"ldl_1_ushort", JIT_OPCODE_NINT_ARG},
- {"ldl_1_int", JIT_OPCODE_NINT_ARG},
- {"ldl_1_long", JIT_OPCODE_NINT_ARG},
- {"ldl_1_float32", JIT_OPCODE_NINT_ARG},
- {"ldl_1_float64", JIT_OPCODE_NINT_ARG},
- {"ldl_1_nfloat", JIT_OPCODE_NINT_ARG},
- {"ldla_1", JIT_OPCODE_NINT_ARG},
- {"ldl_2_sbyte", JIT_OPCODE_NINT_ARG},
- {"ldl_2_ubyte", JIT_OPCODE_NINT_ARG},
- {"ldl_2_short", JIT_OPCODE_NINT_ARG},
- {"ldl_2_ushort", JIT_OPCODE_NINT_ARG},
- {"ldl_2_int", JIT_OPCODE_NINT_ARG},
- {"ldl_2_long", JIT_OPCODE_NINT_ARG},
- {"ldl_2_float32", JIT_OPCODE_NINT_ARG},
- {"ldl_2_float64", JIT_OPCODE_NINT_ARG},
- {"ldl_2_nfloat", JIT_OPCODE_NINT_ARG},
- {"ldla_2", JIT_OPCODE_NINT_ARG},
- {"stl_0_byte", JIT_OPCODE_NINT_ARG},
- {"stl_0_short", JIT_OPCODE_NINT_ARG},
- {"stl_0_int", JIT_OPCODE_NINT_ARG},
- {"stl_0_long", JIT_OPCODE_NINT_ARG},
- {"stl_0_float32", JIT_OPCODE_NINT_ARG},
- {"stl_0_float64", JIT_OPCODE_NINT_ARG},
- {"stl_0_nfloat", JIT_OPCODE_NINT_ARG},
-
- /*
- * Load constant values.
- */
- {"ldc_0_int", JIT_OPCODE_NINT_ARG},
- {"ldc_1_int", JIT_OPCODE_NINT_ARG},
- {"ldc_2_int", JIT_OPCODE_NINT_ARG},
- {"ldc_0_long", JIT_OPCODE_CONST_LONG},
- {"ldc_1_long", JIT_OPCODE_CONST_LONG},
- {"ldc_2_long", JIT_OPCODE_CONST_LONG},
- {"ldc_0_float32", JIT_OPCODE_CONST_FLOAT32},
- {"ldc_1_float32", JIT_OPCODE_CONST_FLOAT32},
- {"ldc_2_float32", JIT_OPCODE_CONST_FLOAT32},
- {"ldc_0_float64", JIT_OPCODE_CONST_FLOAT64},
- {"ldc_1_float64", JIT_OPCODE_CONST_FLOAT64},
- {"ldc_2_float64", JIT_OPCODE_CONST_FLOAT64},
- {"ldc_0_nfloat", JIT_OPCODE_CONST_NFLOAT},
- {"ldc_1_nfloat", JIT_OPCODE_CONST_NFLOAT},
- {"ldc_2_nfloat", JIT_OPCODE_CONST_NFLOAT},
-
- /*
- * Load return value.
- */
- {"ldr_0_int", 0},
- {"ldr_0_long", 0},
- {"ldr_0_float32", 0},
- {"ldr_0_float64", 0},
- {"ldr_0_nfloat", 0},
-
- /*
- * Stack management.
- */
- {"pop", 0},
- {"pop_2", 0},
- {"pop_3", 0},
-
- /*
- * Nested function call handling.
- */
- {"import_local", JIT_OPCODE_NINT_ARG_TWO},
- {"import_arg", JIT_OPCODE_NINT_ARG_TWO},
-
- /*
- * Marker opcode for the end of a function.
- */
- {"end_marker", 0},
-};
-
-#endif /* JIT_BACKEND_INTERP */
case JIT_TYPE_USHORT:
case JIT_TYPE_INT:
case JIT_TYPE_UINT:
- jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_INT + index);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDC_0_INT + index);
jit_cache_native(&(gen->posn), (jit_nint)(value->address));
break;
{
jit_long long_value;
long_value = jit_value_get_long_constant(value);
- jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_LONG + index);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDC_0_LONG + index);
#ifdef JIT_NATIVE_INT64
jit_cache_native(&(gen->posn), long_value);
#else
{
jit_float32 float32_value;
float32_value = jit_value_get_float32_constant(value);
- jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_FLOAT32 + index);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDC_0_FLOAT32 + index);
jit_cache_add_n(&(gen->posn), &float32_value, sizeof(float32_value));
break;
}
{
jit_float64 float64_value;
float64_value = jit_value_get_float64_constant(value);
- jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_FLOAT64 + index);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDC_0_FLOAT64 + index);
jit_cache_add_n (&(gen->posn), &float64_value, sizeof(float64_value));
break;
}
{
jit_nfloat nfloat_value;
nfloat_value = jit_value_get_nfloat_constant(value);
- jit_cache_opcode(&(gen->posn), JIT_OP_LDC_0_NFLOAT + index);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDC_0_NFLOAT + index);
jit_cache_add_n (&(gen->posn), &nfloat_value, sizeof(nfloat_value));
break;
}
switch(index)
{
case 0:
- opcode = JIT_OP_LDL_0_SBYTE;
+ opcode = JIT_INTERP_OP_LDL_0_SBYTE;
break;
case 1:
- opcode = JIT_OP_LDL_1_SBYTE;
+ opcode = JIT_INTERP_OP_LDL_1_SBYTE;
break;
case 2:
- opcode = JIT_OP_LDL_2_SBYTE;
+ opcode = JIT_INTERP_OP_LDL_2_SBYTE;
break;
default:
return;
switch(index)
{
case 0:
- opcode = JIT_OP_LDA_0_SBYTE;
+ opcode = JIT_INTERP_OP_LDA_0_SBYTE;
break;
case 1:
- opcode = JIT_OP_LDA_1_SBYTE;
+ opcode = JIT_INTERP_OP_LDA_1_SBYTE;
break;
case 2:
- opcode = JIT_OP_LDA_2_SBYTE;
+ opcode = JIT_INTERP_OP_LDA_2_SBYTE;
break;
default:
return;
offset = value->frame_offset;
if(offset >= 0)
{
- opcode = _jit_store_opcode(JIT_OP_STL_0_BYTE, 0, value->type);
+ opcode = _jit_store_opcode(JIT_INTERP_OP_STL_0_BYTE, 0, value->type);
}
else
{
- opcode = _jit_store_opcode(JIT_OP_STA_0_BYTE, 0, value->type);
+ opcode = _jit_store_opcode(JIT_INTERP_OP_STA_0_BYTE, 0, value->type);
offset = -(offset + 1);
}
jit_cache_opcode(&(gen->posn), opcode);
_jit_gen_fix_value(insn->value1);
if(insn->value1->frame_offset >= 0)
{
- jit_cache_opcode(&(gen->posn), JIT_OP_IMPORT_LOCAL);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_IMPORT_LOCAL);
jit_cache_native(&(gen->posn), insn->value1->frame_offset);
jit_cache_native(&(gen->posn), jit_value_get_nint_constant(insn->value2));
}
else
{
- jit_cache_opcode(&(gen->posn), JIT_OP_IMPORT_ARG);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_IMPORT_ARG);
jit_cache_native(&(gen->posn), -(insn->value1->frame_offset + 1));
jit_cache_native(&(gen->posn), jit_value_get_nint_constant(insn->value2));
}
case JIT_TYPE_USHORT:
case JIT_TYPE_INT:
case JIT_TYPE_UINT:
- jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_INT);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDR_0_INT);
store_value(gen, insn->value1);
break;
case JIT_TYPE_LONG:
case JIT_TYPE_ULONG:
- jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_LONG);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDR_0_LONG);
store_value(gen, insn->value1);
break;
case JIT_TYPE_FLOAT32:
- jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_FLOAT32);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDR_0_FLOAT32);
store_value(gen, insn->value1);
break;
case JIT_TYPE_FLOAT64:
- jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_FLOAT64);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDR_0_FLOAT64);
store_value(gen, insn->value1);
break;
case JIT_TYPE_NFLOAT:
- jit_cache_opcode(&(gen->posn), JIT_OP_LDR_0_NFLOAT);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDR_0_NFLOAT);
store_value(gen, insn->value1);
break;
}
_jit_gen_fix_value(insn->value1);
if(insn->value1->frame_offset >= 0)
{
- jit_cache_opcode(&(gen->posn), JIT_OP_LDLA_0);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDLA_0);
jit_cache_native(&(gen->posn), insn->value1->frame_offset);
}
else
{
- jit_cache_opcode(&(gen->posn), JIT_OP_LDAA_0);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_LDAA_0);
jit_cache_native(&(gen->posn), -(insn->value1->frame_offset + 1));
}
store_value(gen, insn->dest);
size = jit_value_get_nint_constant(insn->value1);
if(size == 1)
{
- jit_cache_opcode(&(gen->posn), JIT_OP_POP);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_POP);
}
else if(size == 2)
{
- jit_cache_opcode(&(gen->posn), JIT_OP_POP_2);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_POP_2);
}
else if(size == 3)
{
- jit_cache_opcode(&(gen->posn), JIT_OP_POP_3);
+ jit_cache_opcode(&(gen->posn), JIT_INTERP_OP_POP_3);
}
else if(size != 0)
{
}
# Output the label table (PIC version).
-echo 'static int const main_label_table[JIT_OP_END_MARKER] = {'
+echo 'static int const main_label_table[JIT_INTERP_OP_END_MARKER] = {'
grep '^#define[ ]*JIT_OP_' "$2" | grep -v 'JIT_OP_NUM_OPCODES' | \
pic_table "$1" JIT_OP_NOP_label
-grep '^#define[ ]*JIT_OP_' "$3" | grep -v 'JIT_OP_NUM_INTERP_OPCODES' | \
- grep -v 'JIT_OP_END_MARKER' | pic_table "$1" JIT_OP_NOP_label
+grep '^#define[ ]*JIT_INTERP_OP_' "$3" | grep -v 'JIT_INTERP_OP_NUM_OPCODES' | \
+ grep -v 'JIT_INTERP_OP_END_MARKER' | pic_table "$1" JIT_OP_NOP_label
echo '};'
echo ''
}
# Output the label table (non-PIC).
-echo 'static void * main_label_table[JIT_OP_END_MARKER] = {'
+echo 'static void * main_label_table[JIT_INTERP_OP_END_MARKER] = {'
grep '^#define[ ]*JIT_OP_' "$2" | grep -v 'JIT_OP_NUM_OPCODES' | \
non_pic_table "$1" JIT_OP_NOP_label
-grep '^#define[ ]*JIT_OP_' "$3" | grep -v 'JIT_OP_NUM_INTERP_OPCODES' | \
- grep -v 'JIT_OP_END_MARKER' | non_pic_table "$1" JIT_OP_NOP_label
+grep '^#define[ ]*JIT_INTERP_OP_' "$3" | grep -v 'JIT_INTERP_OP_NUM_OPCODES' | \
+ grep -v 'JIT_INTERP_OP_END_MARKER' | non_pic_table "$1" JIT_OP_NOP_label
echo '};'
echo ''
.libs
gen-apply
gen-apply.exe
+gen-ops
+gen-ops.exe
gen-rules
gen-rules.exe
*.lo
gen-rules-parser.c
gen-rules-parser.h
gen-rules-scanner.c
+gen-ops-parser.c
+gen-ops-parser.h
+gen-ops-scanner.c
-noinst_PROGRAMS = gen-apply gen-rules
+noinst_PROGRAMS = gen-apply gen-rules gen-ops
noinst_HEADERS = gen-apply-macosx.h
gen_rules_SOURCES = gen-rules-parser.y gen-rules-scanner.l
+gen_ops_SOURCES = gen-ops-scanner.l gen-ops-parser.y
+
AM_YFLAGS = -d
gen-rules-scanner.l: gen-rules-parser.c
+gen-ops-scanner.l: gen-ops-parser.c
+
all-local: $(top_builddir)/jit/jit-apply-rules.h
$(top_builddir)/jit/jit-apply-rules.h: gen-apply$(EXEEXT)
--- /dev/null
+%{
+/*
+ * gen-ops-parser.y - Bison grammar for the "gen-ops" program.
+ *
+ * Copyright (C) 2010 Southern Storm Software, Pty Ltd.
+ *
+ * This file is part of the libjit library.
+ *
+ * The libjit library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * The libjit library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the libjit library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <ctype.h>
+#include <stdio.h>
+#ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+#endif
+#ifdef HAVE_STRING_H
+# include <string.h>
+#elif defined(HAVE_STRINGS_H)
+# include <strings.h>
+#endif
+
+/*
+ * Imports from the lexical analyser.
+ */
+extern int yylex(void);
+extern void yyrestart(FILE *file);
+#ifdef YYTEXT_POINTER
+extern char *yytext;
+#else
+extern char yytext[];
+#endif
+
+/*
+ * The task to execute
+ */
+#define TASK_GEN_NONE 0
+#define TASK_GEN_HEADER 1
+#define TASK_GEN_TABLE 2
+
+/*
+ * Value Flags
+ */
+#define VALUE_FLAG_EMPTY 0
+#define VALUE_FLAG_INT 1
+#define VALUE_FLAG_LONG 2
+#define VALUE_FLAG_FLOAT32 3
+#define VALUE_FLAG_FLOAT64 4
+#define VALUE_FLAG_NFLOAT 5
+#define VALUE_FLAG_ANY 6
+#define VALUE_FLAG_PTR 7
+
+/*
+ * Opcode type flags
+ */
+#define OP_TYPE_BRANCH 0x0001
+#define OP_TYPE_CALL 0x0002
+#define OP_TYPE_CALL_EXTERNAL 0x0004
+#define OP_TYPE_ADDRESS_OF_LABEL 0x0008
+#define OP_TYPE_JUMP_TABLE 0x0010
+#define OP_TYPE_REG 0x0020
+
+/*
+ * Operations
+ */
+#define OP_NONE 0x00
+#define OP_ADD 0x01
+#define OP_SUB 0x02
+#define OP_MUL 0x03
+#define OP_DIV 0x04
+#define OP_REM 0x05
+#define OP_NEG 0x06
+#define OP_AND 0x07
+#define OP_OR 0x08
+#define OP_XOR 0x09
+#define OP_NOT 0x0A
+#define OP_EQ 0x0B
+#define OP_NE 0x0C
+#define OP_LT 0x0D
+#define OP_LE 0x0E
+#define OP_GT 0x0F
+#define OP_GE 0x10
+#define OP_SHL 0x11
+#define OP_SHR 0x12
+#define OP_SHR_UN 0x13
+#define OP_COPY 0x14
+#define OP_ADDRESS_OF 0x15
+
+/*
+ * Current file and line number.
+ */
+extern char *genops_filename;
+extern long genops_linenum;
+
+struct genops_opcode
+{
+ struct genops_opcode *next;
+ const char *name;
+ int type;
+ int oper;
+ int dest_flags;
+ int input1_flags;
+ int input2_flags;
+ const char *expression;
+};
+
+/*
+ * Opcode declaration list header
+ */
+struct genops_opcode_list
+{
+ const char *declaration;
+ const char *define_start;
+ const char *counter_prefix_expr;
+ struct genops_opcode *first_opcode;
+ struct genops_opcode *last_opcode;
+};
+
+/*
+ * The task to execute.
+ */
+static int genops_task = TASK_GEN_NONE;
+
+/*
+ * The file to execute
+ */
+static FILE *genops_file = 0;
+static int genops_file_needs_close = 0;
+
+/*
+ * Blocks coppied to the resulting file.
+ */
+static const char *start_code_block = 0;
+static const char *start_header_block = 0;
+static const char *end_code_block = 0;
+static const char *end_header_block = 0;
+
+/*
+ * Current opcode declaration header
+ */
+static struct genops_opcode_list *opcode_header = 0;
+
+/*
+ * Report error message.
+ */
+static void
+genops_error_message(char *filename, long linenum, char *msg)
+{
+ fprintf(stderr, "%s(%ld): %s\n", filename, linenum, msg);
+}
+
+/*
+ * Report error messages from the parser.
+ */
+static void
+yyerror(char *msg)
+{
+ genops_error_message(genops_filename, genops_linenum, msg);
+}
+
+/*
+ * Create an opcode declaration header.
+ */
+static void
+genops_create_opcode_header(const char *define_start, const char *declaration,
+ const char *counter_prefix_expr)
+{
+ struct genops_opcode_list *header;
+
+ header = (struct genops_opcode_list *)malloc(sizeof(struct genops_opcode_list));
+ if(!header)
+ {
+ exit(1);
+ }
+ if(counter_prefix_expr && (strlen(counter_prefix_expr) == 0))
+ {
+ counter_prefix_expr = 0;
+ }
+ header->declaration = declaration;
+ header->define_start = define_start;
+ header->counter_prefix_expr = counter_prefix_expr;
+ header->first_opcode = 0;
+ header->last_opcode = 0;
+ opcode_header = header;
+}
+
+/*
+ * Create an opcode entry
+ */
+static struct genops_opcode *
+genops_add_opcode(const char *name, int type, int oper, int dest_flags, int input1_flags, int input2_flags, const char *expression)
+{
+ struct genops_opcode *opcode;
+
+ opcode = (struct genops_opcode *) malloc(sizeof(struct genops_opcode));
+ if(!opcode)
+ {
+ exit(1);
+ }
+
+ if(opcode_header->first_opcode == 0)
+ {
+ opcode_header->first_opcode = opcode;
+ }
+ if(opcode_header->last_opcode != 0)
+ {
+ opcode_header->last_opcode->next = opcode;
+ }
+ opcode_header->last_opcode = opcode;
+
+ opcode->next = 0;
+ opcode->name = name;
+ opcode->type = type;
+ opcode->oper = oper;
+ opcode->dest_flags = dest_flags;
+ opcode->input1_flags= input1_flags;
+ opcode->input2_flags= input2_flags;
+ opcode->expression = expression;
+
+ return opcode;
+}
+
+static int
+genops_output_flag(const char *flag, int needs_or)
+{
+ if(needs_or) printf(" | ");
+ printf(flag);
+ return 1;
+}
+
+static int
+genops_output_prefix_flag(const char *prefix, const char *flag, int needs_or)
+{
+ if(needs_or) printf(" | ");
+ printf("%s%s", prefix, flag);
+ return 1;
+}
+
+static int
+genops_output_type(int type, int needs_or)
+{
+
+ if(type & OP_TYPE_BRANCH)
+ {
+ needs_or = genops_output_flag("JIT_OPCODE_IS_BRANCH", needs_or);
+ }
+ if(type & OP_TYPE_CALL)
+ {
+ needs_or = genops_output_flag("JIT_OPCODE_IS_CALL", needs_or);
+ }
+ if(type & OP_TYPE_CALL_EXTERNAL)
+ {
+ needs_or = genops_output_flag("JIT_OPCODE_IS_CALL_EXTERNAL", needs_or);
+ }
+ if(type & OP_TYPE_ADDRESS_OF_LABEL)
+ {
+ needs_or = genops_output_flag("JIT_OPCODE_IS_ADDROF_LABEL", needs_or);
+ }
+ if(type & OP_TYPE_JUMP_TABLE)
+ {
+ needs_or = genops_output_flag("JIT_OPCODE_IS_JUMP_TABLE", needs_or);
+ }
+ if(type & OP_TYPE_REG)
+ {
+ needs_or = genops_output_flag("JIT_OPCODE_IS_REG", needs_or);
+ }
+
+ return needs_or;
+}
+
+static int
+genops_output_expression(const char *expression, int needs_or)
+{
+ if(expression && (strlen(expression) > 0))
+ {
+ needs_or = genops_output_flag(expression, needs_or);
+ }
+ return needs_or;
+}
+
+static int
+genops_output_oper(int oper, int needs_or)
+{
+ switch(oper)
+ {
+ case OP_ADD:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_ADD", needs_or);
+ }
+ break;
+
+ case OP_SUB:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_SUB", needs_or);
+ }
+ break;
+
+ case OP_MUL:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_MUL", needs_or);
+ }
+ break;
+
+ case OP_DIV:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_DIV", needs_or);
+ }
+ break;
+
+ case OP_REM:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_REM", needs_or);
+ }
+ break;
+
+ case OP_NEG:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_NEG", needs_or);
+ }
+ break;
+
+ case OP_AND:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_AND", needs_or);
+ }
+ break;
+
+ case OP_OR:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_OR", needs_or);
+ }
+ break;
+
+ case OP_XOR:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_XOR", needs_or);
+ }
+ break;
+
+ case OP_NOT:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_NOT", needs_or);
+ }
+ break;
+
+ case OP_EQ:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_EQ", needs_or);
+ }
+ break;
+
+ case OP_NE:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_NE", needs_or);
+ }
+ break;
+
+ case OP_LT:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_LT", needs_or);
+ }
+ break;
+
+ case OP_LE:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_LE", needs_or);
+ }
+ break;
+
+ case OP_GT:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_GT", needs_or);
+ }
+ break;
+
+ case OP_GE:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_GE", needs_or);
+ }
+ break;
+
+ case OP_SHL:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_SHL", needs_or);
+ }
+ break;
+
+ case OP_SHR:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_SHR", needs_or);
+ }
+ break;
+
+ case OP_SHR_UN:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_SHR_UN", needs_or);
+ }
+ break;
+
+ case OP_COPY:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_COPY", needs_or);
+ }
+ break;
+
+ case OP_ADDRESS_OF:
+ {
+ return genops_output_flag
+ ("JIT_OPCODE_OPER_ADDRESS_OF", needs_or);
+ }
+ break;
+ }
+ return needs_or;
+}
+
+static int
+genops_output_value_flags(const char *prefix, int flags, int needs_or)
+{
+ switch(flags)
+ {
+ case VALUE_FLAG_EMPTY:
+ {
+ /* Nothing to do here */
+ }
+ break;
+
+ case VALUE_FLAG_INT:
+ {
+ return genops_output_prefix_flag
+ (prefix, "_INT", needs_or);
+ }
+ break;
+
+ case VALUE_FLAG_LONG:
+ {
+ return genops_output_prefix_flag
+ (prefix, "_LONG", needs_or);
+ }
+ break;
+
+ case VALUE_FLAG_FLOAT32:
+ {
+ return genops_output_prefix_flag
+ (prefix, "_FLOAT32", needs_or);
+ }
+ break;
+
+ case VALUE_FLAG_FLOAT64:
+ {
+ return genops_output_prefix_flag
+ (prefix, "_FLOAT64", needs_or);
+ }
+ break;
+
+ case VALUE_FLAG_NFLOAT:
+ {
+ return genops_output_prefix_flag
+ (prefix, "_NFLOAT", needs_or);
+ }
+ break;
+
+ case VALUE_FLAG_ANY:
+ {
+ return genops_output_prefix_flag
+ (prefix, "_ANY", needs_or);
+ }
+ break;
+
+ case VALUE_FLAG_PTR:
+ {
+ return genops_output_prefix_flag
+ (prefix, "_PTR", needs_or);
+ }
+ break;
+ }
+ return needs_or;
+}
+
+/*
+ * Create an upper-case copy of a string.
+ */
+static char *
+genops_string_upper(const char *string)
+{
+ if(string)
+ {
+ char *cp;
+ char *new_string;
+
+ new_string = strdup(string);
+ for(cp = new_string; *cp; cp++)
+ {
+ *cp = toupper(*cp);
+ }
+ return new_string;
+ }
+ return 0;
+}
+
+%}
+
+/*
+ * Define the structure of yylval.
+ */
+%union {
+ int value;
+ char *name;
+ struct
+ {
+ const char *header;
+ const char *code;
+ } blocks;
+ struct
+ {
+ const char *declaration;
+ const char *define_start;
+ const char *counter_prefix_expr;
+ } opcode_list_header;
+ struct
+ {
+ const char *name;
+ int oper;
+ } opcode_header;
+ struct
+ {
+ int dest_flags;
+ int input1_flags;
+ int input2_flags;
+ } opcode_values;
+ struct
+ {
+ int type;
+ int dest_flags;
+ int input1_flags;
+ int input2_flags;
+ const char *expression;
+ } opcode_properties;
+ struct
+ {
+ const char *name;
+ int type;
+ int oper;
+ int dest_flags;
+ int input1_flags;
+ int input2_flags;
+ const char *expression;
+ } opcode;
+}
+
+/*
+ * Primitive lexical tokens and keywords.
+ */
+%token IDENTIFIER "an identifier"
+%token CODE_BLOCK "a block copied to the code"
+%token HEADER_BLOCK "a block copied to the header"
+%token LITERAL "literal string"
+%token K_EMPTY "empty"
+%token K_ANY "any"
+%token K_INT "int"
+%token K_LONG "long"
+%token K_PTR "ptr"
+%token K_FLOAT32 "float32"
+%token K_FLOAT64 "float64"
+%token K_NFLOAT "nfloat"
+%token K_NEG "neg"
+%token K_EQ "=="
+%token K_NE "!="
+%token K_LT "lt"
+%token K_LE "<="
+%token K_GT "gt"
+%token K_GE ">="
+%token K_SHL "<<"
+%token K_SHR ">>"
+%token K_SHR_UN "shr_un"
+%token K_ADDRESS_OF "address_of"
+%token K_ADDRESS_OF_LABEL "address_of_label"
+%token K_BRANCH "branch"
+%token K_CALL "call"
+%token K_CALL_EXTERNAL "call_external"
+%token K_JUMP_TABLE "jump_table"
+%token K_OP_DEF "op_def"
+%token K_OP_TYPE "op_type"
+%token K_OP_VALUES "op_values"
+%token K_OPCODES "opcodes"
+%token K_REG "reg"
+
+/*
+ * Define the yylval types of the various non-terminals.
+ */
+%type <name> CODE_BLOCK HEADER_BLOCK
+%type <name> IDENTIFIER LITERAL Literal
+%type <blocks> Blocks
+%type <opcode_list_header> OpcodeListHeader
+%type <value> ValueFlag Op
+%type <value> OpcodeType OpcodeTypeFlag
+%type <name> OpcodeExpression
+%type <opcode> Opcode
+%type <opcode_header> OpcodeHeader
+%type <opcode_properties> OpcodeProperties
+%type <opcode_values> OpcodeValues
+
+%expect 0
+
+%error-verbose
+
+%start Start
+%%
+
+Start
+ : Blocks OpcodeDeclarations Blocks {
+ start_code_block = ($1).code;
+ start_header_block = ($1).header;
+ end_code_block = ($3).code;;
+ end_header_block = ($3).header;
+ }
+ ;
+
+Blocks
+ : /* empty */ { ($$).header = 0; ($$).code = 0; }
+ | CODE_BLOCK { ($$).header = 0; ($$).code = $1; }
+ | HEADER_BLOCK { ($$).header = $1; ($$).code = 0; }
+ | CODE_BLOCK HEADER_BLOCK {
+ ($$).code = $1;
+ ($$).header = $2;
+ }
+ | HEADER_BLOCK CODE_BLOCK {
+ ($$).code = $2;
+ ($$).header = $1;
+ }
+ ;
+
+OpcodeDeclarations
+ : OpcodeListHeader {
+ genops_create_opcode_header(($1).declaration,
+ ($1).define_start,
+ ($1).counter_prefix_expr);
+ }
+ '{' Opcodes '}'
+ ;
+
+OpcodeListHeader
+ : K_OPCODES '(' IDENTIFIER ',' Literal ')' {
+ ($$).declaration = $3;
+ ($$).define_start = $5;
+ ($$).counter_prefix_expr = 0;
+ }
+ | K_OPCODES '(' IDENTIFIER ',' Literal ',' Literal ')' {
+ ($$).declaration = $3;
+ ($$).define_start = $5;
+ ($$).counter_prefix_expr = $7;
+ }
+ ;
+
+Opcodes
+ : Opcode {
+ genops_add_opcode(($1).name, ($1).type,
+ ($1).oper, ($1).dest_flags,
+ ($1).input1_flags,
+ ($1).input2_flags,
+ ($1).expression);
+ }
+ | Opcodes Opcode {
+ genops_add_opcode(($2).name, ($2).type,
+ ($2).oper, ($2).dest_flags,
+ ($2).input1_flags,
+ ($2).input2_flags,
+ ($2).expression);
+ }
+ ;
+
+Opcode
+ : OpcodeHeader '{' '}' {
+ ($$).name = ($1).name;
+ ($$).type = 0;
+ ($$).oper = ($1).oper;
+ ($$).dest_flags = VALUE_FLAG_EMPTY;
+ ($$).input1_flags = VALUE_FLAG_EMPTY;
+ ($$).input2_flags = VALUE_FLAG_EMPTY;
+ ($$).expression = 0;
+ }
+ | OpcodeHeader '{' OpcodeProperties '}' {
+ ($$).name = ($1).name;
+ ($$).type = ($3).type;
+ ($$).oper = ($1).oper;
+ ($$).dest_flags = ($3).dest_flags;
+ ($$).input1_flags = ($3).input1_flags;
+ ($$).input2_flags = ($3).input2_flags;
+ ($$).expression = ($3).expression;
+ }
+ ;
+
+OpcodeHeader
+ : K_OP_DEF '(' LITERAL ')' {
+ ($$).name = $3;
+ ($$).oper = OP_NONE;
+ }
+ | K_OP_DEF '(' LITERAL ',' Op ')' {
+ ($$).name = $3;
+ ($$).oper = $5;
+ }
+ ;
+
+OpcodeProperties
+ : OpcodeType {
+ ($$).type = $1;
+ ($$).dest_flags = VALUE_FLAG_EMPTY;
+ ($$).input1_flags = VALUE_FLAG_EMPTY;
+ ($$).input2_flags = VALUE_FLAG_EMPTY;
+ ($$).expression = 0;
+ }
+ | OpcodeValues {
+ ($$).type = 0;
+ ($$).dest_flags = ($1).dest_flags;
+ ($$).input1_flags = ($1).input1_flags;
+ ($$).input2_flags = ($1).input2_flags;
+ ($$).expression = 0;
+ }
+ | OpcodeExpression {
+ ($$).type = 0;
+ ($$).dest_flags = VALUE_FLAG_EMPTY;
+ ($$).input1_flags = VALUE_FLAG_EMPTY;
+ ($$).input2_flags = VALUE_FLAG_EMPTY;
+ ($$).expression = $1;
+ }
+ | OpcodeProperties ',' OpcodeType {
+ ($$).type = $3;
+ ($$).dest_flags = ($1).dest_flags;
+ ($$).input1_flags = ($1).input1_flags;
+ ($$).input2_flags = ($1).input2_flags;
+ ($$).expression = ($1).expression;
+ }
+ | OpcodeProperties ',' OpcodeValues {
+ ($$).type = ($1).type;
+ ($$).dest_flags = ($3).dest_flags;
+ ($$).input1_flags = ($3).input1_flags;
+ ($$).input2_flags = ($3).input2_flags;
+ ($$).expression = ($1).expression;
+ }
+ | OpcodeProperties ',' OpcodeExpression {
+ ($$).type = ($1).type;
+ ($$).dest_flags = ($1).dest_flags;
+ ($$).input1_flags = ($1).input1_flags;
+ ($$).input2_flags = ($1).input2_flags;
+ ($$).expression = $3;
+ }
+ ;
+
+OpcodeType
+ : K_OP_TYPE '(' OpcodeTypeFlag ')' { $$ = $3; }
+ ;
+
+OpcodeTypeFlag
+ : K_ADDRESS_OF_LABEL { $$ = OP_TYPE_ADDRESS_OF_LABEL; }
+ | K_BRANCH { $$ = OP_TYPE_BRANCH; }
+ | K_CALL { $$ = OP_TYPE_CALL; }
+ | K_CALL_EXTERNAL { $$ = OP_TYPE_CALL_EXTERNAL; }
+ | K_JUMP_TABLE { $$ = OP_TYPE_JUMP_TABLE; }
+ | K_REG { $$ = OP_TYPE_REG; }
+ ;
+
+OpcodeValues
+ : K_OP_VALUES '(' ValueFlag ')' {
+ ($$).dest_flags = $3;
+ ($$).input1_flags = VALUE_FLAG_EMPTY;
+ ($$).input2_flags = VALUE_FLAG_EMPTY;
+ }
+ | K_OP_VALUES '(' ValueFlag ',' ValueFlag ')' {
+ ($$).dest_flags = $3;
+ ($$).input1_flags = $5;
+ ($$).input2_flags = VALUE_FLAG_EMPTY;
+ }
+ | K_OP_VALUES '(' ValueFlag ',' ValueFlag ',' ValueFlag ')' {
+ ($$).dest_flags = $3;
+ ($$).input1_flags = $5;
+ ($$).input2_flags = $7;
+ }
+ ;
+
+OpcodeExpression
+ : Literal { $$ = $1; }
+ ;
+
+Op
+ : /* empty */ { $$ = OP_NONE; }
+ | '+' { $$ = OP_ADD; }
+ | '-' { $$ = OP_SUB; }
+ | '*' { $$ = OP_MUL; }
+ | '/' { $$ = OP_DIV; }
+ | '%' { $$ = OP_REM; }
+ | K_NEG { $$ = OP_NEG; }
+ | '&' { $$ = OP_AND; }
+ | '|' { $$ = OP_OR; }
+ | '^' { $$ = OP_XOR; }
+ | '~' { $$ = OP_NOT; }
+ | K_SHL { $$ = OP_SHL; }
+ | K_SHR { $$ = OP_SHR; }
+ | K_SHR_UN { $$ = OP_SHR_UN; }
+ | K_EQ { $$ = OP_EQ; }
+ | K_NE { $$ = OP_NE; }
+ | K_LE { $$ = OP_LE; }
+ | '<' { $$ = OP_LT; }
+ | K_GE { $$ = OP_GE; }
+ | '>' { $$ = OP_GT; }
+ | '=' { $$ = OP_COPY; }
+ | K_ADDRESS_OF { $$ = OP_ADDRESS_OF; }
+ ;
+
+ValueFlag
+ : K_EMPTY { $$ = VALUE_FLAG_EMPTY; }
+ | K_INT { $$ = VALUE_FLAG_INT; }
+ | K_LONG { $$ = VALUE_FLAG_LONG; }
+ | K_PTR { $$ = VALUE_FLAG_PTR; }
+ | K_FLOAT32 { $$ = VALUE_FLAG_FLOAT32; }
+ | K_FLOAT64 { $$ = VALUE_FLAG_FLOAT64; }
+ | K_NFLOAT { $$ = VALUE_FLAG_NFLOAT; }
+ | K_ANY { $$ = VALUE_FLAG_ANY; }
+ ;
+
+Literal
+ : LITERAL { $$ = $1; }
+ | Literal LITERAL {
+ char *cp = malloc(strlen($1) + strlen($2) + 1);
+ if(!cp)
+ {
+ exit(1);
+ }
+ strcpy(cp, $1);
+ strcat(cp, $2);
+ free($1);
+ free($2);
+ $$ = cp;
+ }
+ ;
+
+%%
+
+/*
+ * Parse the commandline arguments
+ */
+static int
+genops_parseargs(int argc, char *argv[])
+{
+ int current;
+
+ current = 1;
+ while(current < argc - 1)
+ {
+ if(!strcmp(argv[current], "-H") ||
+ !strcmp(argv[current], "--header"))
+ {
+ genops_task = TASK_GEN_HEADER;
+ }
+ else if(!strcmp(argv[current], "-T") ||
+ !strcmp(argv[current], "--table"))
+ {
+ genops_task = TASK_GEN_TABLE;
+ }
+ else if(!strcmp(argv[current], "--help"))
+ {
+ return 1;
+ }
+ else
+ {
+ fprintf(stderr, "Invalid commandline option %s\n",
+ argv[current]);
+ return 1;
+ }
+ ++current;
+ }
+ if(genops_task == TASK_GEN_NONE)
+ {
+ return 1;
+ }
+ if(argc > 1)
+ {
+ if(strcmp(argv[argc - 1], "-"))
+ {
+ genops_file = fopen(argv[argc - 1], "r");
+ if(!genops_file)
+ {
+ perror(argv[argc - 1]);
+ return 1;
+ }
+ genops_file_needs_close = 1;
+ }
+ else
+ {
+ genops_file = stdin;
+ }
+ }
+ else
+ {
+ return 1;
+ }
+ return 0;
+}
+
+/*
+ * Output the opcode declaration header
+ */
+static void
+genops_output_defines(const char *define_start, const char *counter_prefix_expr)
+{
+ struct genops_opcode *current;
+ int start_len;
+ int opcode_no;
+ int name_len;
+ int num_tabs;
+
+ start_len = strlen(define_start);
+ opcode_no = 0;
+ current = opcode_header->first_opcode;
+ while(current)
+ {
+ char *upper_name;
+
+ upper_name = genops_string_upper(current->name);
+ if(upper_name == 0)
+ {
+ /* Out of memory */
+ perror(genops_filename);
+ exit(1);
+ }
+ printf("#define\t%s%s", define_start, upper_name);
+ name_len = strlen(upper_name) + 8 + start_len;
+ num_tabs = 8 - name_len / 8;
+ while(num_tabs > 0)
+ {
+ printf("\t");
+ --num_tabs;
+ }
+ if(counter_prefix_expr)
+ {
+ printf("(%s + 0x%04X)\n", counter_prefix_expr, opcode_no);
+ }
+ else
+ {
+ printf("0x%04X\n", opcode_no);
+ }
+ free(upper_name);
+ current = current->next;
+ ++opcode_no;
+ }
+ /*
+ * Print the definition for the number of opcodes
+ */
+ printf("#define\t%s%s", define_start, "NUM_OPCODES");
+ name_len = 11 + 8 + start_len;
+ num_tabs = 8 - name_len / 8;
+ while(num_tabs > 0)
+ {
+ printf("\t");
+ --num_tabs;
+ }
+ printf("0x%04X\n", opcode_no);
+}
+
+static void
+genops_output_defs(const char *filename)
+{
+ printf("/%c Automatically generated from %s - DO NOT EDIT %c/\n",
+ '*', filename, '*');
+ if(start_header_block)
+ {
+ printf("%s", start_header_block);
+ }
+ genops_output_defines(opcode_header->define_start,
+ opcode_header->counter_prefix_expr);
+ if(end_header_block)
+ {
+ printf("%s", end_header_block);
+ }
+}
+
+/*
+ * Output the opcode description table.
+ */
+static void
+genops_output_ops(void)
+{
+ struct genops_opcode *current;
+
+ printf("%s = {\n", opcode_header->declaration);
+ current = opcode_header->first_opcode;
+ while(current)
+ {
+ int needs_or = 0;
+
+ printf("\t{\"%s\"", current->name);
+ if(current->type || current->oper || current->dest_flags ||
+ current->input1_flags || current->input2_flags||
+ current->expression)
+ printf(", ");
+ needs_or = genops_output_type(current->type, 0);
+ needs_or = genops_output_oper(current->oper, needs_or);
+ needs_or = genops_output_value_flags("JIT_OPCODE_DEST", current->dest_flags, needs_or);
+ needs_or = genops_output_value_flags("JIT_OPCODE_SRC1", current->input1_flags, needs_or);
+ needs_or = genops_output_value_flags("JIT_OPCODE_SRC2", current->input2_flags, needs_or);
+ needs_or = genops_output_expression(current->expression, needs_or);
+ if(!needs_or)
+ {
+ /*
+ * None of the above flags needed to be printed so
+ * we have to add the 0 value here.
+ */
+ printf(", 0");
+ }
+ printf("}");
+ current = current->next;
+ if(current)
+ {
+ printf(",\n");
+ }
+ else
+ {
+ printf("\n");
+ }
+ }
+ printf("};\n");
+}
+
+static void
+genops_output_opcode_table(const char *filename)
+{
+ printf("/%c Automatically generated from %s - DO NOT EDIT %c/\n",
+ '*', filename, '*');
+ if(start_code_block)
+ {
+ printf("%s", start_code_block);
+ }
+ genops_output_ops();
+ if(end_code_block)
+ {
+ printf("%s", end_code_block);
+ }
+}
+
+#define USAGE \
+"Usage: %s option file\n" \
+"Generates an opcode header or table from opcode definitions\n" \
+"and writes the result to standard output\n\n" \
+"Options:\n" \
+" -H, --header\tgenerate a header file\n" \
+" -T, --table\tgenerate a file with the opcode table\n" \
+" --help\tdisplay this information\n" \
+"\nExactly one of header or table option must be supplied.\n" \
+"If file is - standard input is used.\n"
+
+int main(int argc, char *argv[])
+{
+ if(genops_parseargs(argc, argv))
+ {
+ fprintf(stderr, USAGE, argv[0]);
+ return 1;
+ }
+ genops_filename = argv[argc - 1];
+ genops_linenum = 1;
+ yyrestart(genops_file);
+ if(yyparse())
+ {
+ if(genops_file_needs_close)
+ {
+ fclose(genops_file);
+ }
+ return 1;
+ }
+ if(genops_file_needs_close)
+ {
+ fclose(genops_file);
+ }
+ switch(genops_task)
+ {
+ case TASK_GEN_HEADER:
+ {
+ genops_output_defs(genops_filename);
+ }
+ break;
+
+ case TASK_GEN_TABLE:
+ {
+ genops_output_opcode_table(genops_filename);
+ }
+ break;
+ }
+ return 0;
+}
--- /dev/null
+%{
+/*
+ * gen-ops-scanner.l - Lex input file for the "gen-ops" scanner.
+ *
+ * Copyright (C) 2010 Southern Storm Software, Pty Ltd.
+ *
+ * This file is part of the libjit library.
+ *
+ * The libjit library is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation, either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * The libjit library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the libjit library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#include "gen-ops-parser.h"
+#include <config.h>
+#include <stdio.h>
+#ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+#endif
+#ifdef HAVE_STRING_H
+# include <string.h>
+#elif defined(HAVE_STRINGS_H)
+# include <strings.h>
+#endif
+
+#ifndef HAVE_UNISTD_H
+# define YY_NO_UNISTD_H
+#endif
+
+extern YYSTYPE yylval;
+
+/*
+ * Current file and line number.
+ */
+char *genops_filename = "";
+long genops_linenum = 1;
+
+/*
+ * Return a token code from the lexical analyser.
+ */
+#define RETURNTOK(x) return (x)
+
+/*
+ * Forward declarations.
+ */
+static void genops_skip_comment(void);
+static char *genops_read_code_block(void);
+static char *genops_read_header_block(void);
+static char *genops_read_literal(void);
+
+/*
+ * Duplicate a string.
+ */
+static char *genops_strdup(const char *str)
+{
+ char *new_str;
+ if(!str)
+ {
+ return 0;
+ }
+ new_str = (char *)malloc(strlen(str) + 1);
+ if(!new_str)
+ {
+ return 0;
+ }
+ strcpy(new_str, str);
+ return new_str;
+}
+
+%}
+
+%option outfile="lex.yy.c"
+%option noyywrap
+%option nounput
+
+DIGIT [0-9]
+IDALPHA [a-zA-Z_]
+WHITE [ \t\v\r\f]
+
+%%
+
+"empty" { RETURNTOK(K_EMPTY); }
+"int" { RETURNTOK(K_INT); }
+"long" { RETURNTOK(K_LONG); }
+"ptr" { RETURNTOK(K_PTR); }
+"float32" { RETURNTOK(K_FLOAT32); }
+"float64" { RETURNTOK(K_FLOAT64); }
+"nfloat" { RETURNTOK(K_NFLOAT); }
+"any" { RETURNTOK(K_ANY); }
+"neg" { RETURNTOK(K_NEG); }
+"<<" { RETURNTOK(K_SHL); }
+">>" { RETURNTOK(K_SHR); }
+"shr_un" { RETURNTOK(K_SHR_UN); }
+"==" { RETURNTOK(K_EQ); }
+"!=" { RETURNTOK(K_NE); }
+"<=" { RETURNTOK(K_LE); }
+">=" { RETURNTOK(K_GE); }
+"address_of" { RETURNTOK(K_ADDRESS_OF); }
+"address_of_label" { RETURNTOK(K_ADDRESS_OF_LABEL); }
+"branch" { RETURNTOK(K_BRANCH); }
+"call" { RETURNTOK(K_CALL); }
+"call_external" { RETURNTOK(K_CALL_EXTERNAL); }
+"jump_table" { RETURNTOK(K_JUMP_TABLE); }
+"op_def" { RETURNTOK(K_OP_DEF); }
+"op_type" { RETURNTOK(K_OP_TYPE); }
+"op_values" { RETURNTOK(K_OP_VALUES); }
+"opcodes" { RETURNTOK(K_OPCODES); }
+"reg" { RETURNTOK(K_REG); }
+
+"!"?{IDALPHA}({DIGIT}|{IDALPHA})* {
+ yylval.name = genops_strdup(yytext);
+ if(!(yylval.name))
+ {
+ exit(1);
+ }
+ RETURNTOK(IDENTIFIER);
+ }
+
+{WHITE}+ ;
+
+\n { ++genops_linenum; }
+
+\" { yylval.name = genops_read_literal();
+ RETURNTOK(LITERAL); }
+
+"%{" { yylval.name = genops_read_code_block();
+ RETURNTOK(CODE_BLOCK); }
+
+"%[" { yylval.name = genops_read_header_block();
+ RETURNTOK(HEADER_BLOCK); }
+
+"/*" { genops_skip_comment(); }
+
+. { RETURNTOK(((int)(yytext[0])) & 0xFF); }
+
+%%
+
+/*
+ * Skip a comment in the input stream.
+ */
+static void genops_skip_comment(void)
+{
+ int ch;
+ for(;;)
+ {
+ ch = input();
+ if(ch == EOF)
+ {
+ break;
+ }
+ else if(ch == '*')
+ {
+ ch = input();
+ while(ch == '*')
+ {
+ ch = input();
+ }
+ if(ch == EOF || ch == '/')
+ {
+ break;
+ }
+ else if(ch == '\n')
+ {
+ ++genops_linenum;
+ }
+ }
+ else if(ch == '\n')
+ {
+ ++genops_linenum;
+ }
+ }
+}
+
+/*
+ * Add a character to a reallocatable buffer.
+ */
+#define ADD_CH(c) \
+ do { \
+ if((buflen + 1) >= bufmax) \
+ { \
+ buf = (char *)realloc(buf, bufmax + 64); \
+ if(!buf) \
+ { \
+ exit(1); \
+ } \
+ bufmax += 64; \
+ } \
+ buf[buflen++] = (char)c; \
+ buf[buflen] = (char)'\0'; \
+ } while (0)
+
+/*
+ * Read a literal code block from the input stream.
+ */
+static char *genops_read_code_block(void)
+{
+ char *buf = 0;
+ int buflen = 0;
+ int bufmax = 0;
+ int ch;
+
+ ch = input();
+ for(;;)
+ {
+ if(ch == EOF)
+ {
+ fprintf(stderr, "Unexpected EOF in code block\n");
+ exit(1);
+ }
+ if(ch == '\n')
+ {
+ ADD_CH(ch);
+ ++genops_linenum;
+ }
+ else if(ch == '%')
+ {
+ ch = input();
+ if(ch == '}')
+ {
+ break;
+ }
+ ADD_CH('%');
+ continue;
+ }
+ else
+ {
+ ADD_CH(ch);
+ }
+ ch = input();
+ }
+ return buf;
+}
+
+/*
+ * Read a literal header block from the input stream.
+ */
+static char *genops_read_header_block(void)
+{
+ char *buf = 0;
+ int buflen = 0;
+ int bufmax = 0;
+ int ch;
+
+ ch = input();
+ for(;;)
+ {
+ if(ch == EOF)
+ {
+ fprintf(stderr, "Unexpected EOF in code block\n");
+ exit(1);
+ }
+ if(ch == '\n')
+ {
+ ADD_CH(ch);
+ ++genops_linenum;
+ }
+ else if(ch == '%')
+ {
+ ch = input();
+ if(ch == ']')
+ {
+ break;
+ }
+ ADD_CH('%');
+ continue;
+ }
+ else
+ {
+ ADD_CH(ch);
+ }
+ ch = input();
+ }
+ return buf;
+}
+
+/*
+ * Read a literal string from the input stream.
+ */
+static char *genops_read_literal()
+{
+ char *buf = 0;
+ int buflen = 0;
+ int bufmax = 0;
+ int escape = 0;
+ int ch;
+ for(;;)
+ {
+ ch = input();
+ if(ch == EOF)
+ {
+ fprintf(stderr, "Unexpected EOF in string literal\n");
+ exit(1);
+ }
+ if(ch == '\n')
+ {
+ fprintf(stderr, "Unexpected newline in string literal\n");
+ exit(1);
+ }
+ if(escape)
+ {
+ escape = 0;
+ if(ch == 'n')
+ {
+ ch = '\n';
+ }
+ else if(ch == 't')
+ {
+ ch = '\t';
+ }
+ }
+ else
+ {
+ if(ch == '\\')
+ {
+ escape = 1;
+ continue;
+ }
+ if(ch == '"')
+ {
+ break;
+ }
+ }
+ ADD_CH(ch);
+ }
+ return buf;
+}
projects / francis / libjit.git / commitdiff