[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET Just In Time compiler (l
|
From: |
Klaus Treichel |
|
Subject: |
[dotgnu-pnet-commits] [SCM] DotGNU Portable.NET Just In Time compiler (libjit) branch, master, updated. bcf9a2ff8bd47b798c41986eec527d96ea386317 |
|
Date: |
Tue, 03 Aug 2010 09:50:54 +0000 |
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "DotGNU Portable.NET Just In Time compiler (libjit)".
The branch, master has been updated
via bcf9a2ff8bd47b798c41986eec527d96ea386317 (commit)
from 1bd66609ae702b2df9bc8670a94ff9bcb153c312 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit/libjit.git/commit/?id=bcf9a2ff8bd47b798c41986eec527d96ea386317
commit bcf9a2ff8bd47b798c41986eec527d96ea386317
Author: Klaus Treichel <address@hidden>
Date: Tue Aug 3 11:44:07 2010 +0200
Add gen-ops tool for generation all opcode defintions ans tables from one
source.
Add sources for basic libjit opcodes and interpreter specific libjit
opcodes.
diff --git a/ChangeLog b/ChangeLog
index 0b8d9e3..9e29a4e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,51 @@
+2010-08-03 Klaus Treichel <address@hidden>
+
+ * 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 <address@hidden>
* jit/jit-block.c: allow empty block branch optimization for blocks
diff --git a/Makefile.am b/Makefile.am
index baf1fc5..16987e8 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,2 +1,2 @@
-SUBDIRS = include tools jit jitdynamic jitplus dpas tutorial tests doc
+SUBDIRS = config tools include jit jitdynamic jitplus dpas tutorial tests doc
diff --git a/config/Makefile.am b/config/Makefile.am
new file mode 100644
index 0000000..ffa4689
--- /dev/null
+++ b/config/Makefile.am
@@ -0,0 +1 @@
+EXTRA_DIST = jit-opcodes.ops jit-interp-opcodes.ops
diff --git a/config/jit-interp-opcodes.ops b/config/jit-interp-opcodes.ops
new file mode 100644
index 0000000..8b10f45
--- /dev/null
+++ b/config/jit-interp-opcodes.ops
@@ -0,0 +1,225 @@
+%{
+/*
+ * 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) */
+%}
diff --git a/config/jit-opcodes.ops b/config/jit-opcodes.ops
new file mode 100644
index 0000000..c156443
--- /dev/null
+++ b/config/jit-opcodes.ops
@@ -0,0 +1,630 @@
+%{
+/*
+ * 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 */
+%]
diff --git a/configure.ac b/configure.ac
index d84918e..c976915 100644
--- a/configure.ac
+++ b/configure.ac
@@ -478,6 +478,7 @@ AC_FUNC_ALLOCA
AC_CONFIG_FILES([
Makefile
+ config/Makefile
include/Makefile
include/jit/Makefile
include/jit/jit-defs.h
diff --git a/include/jit/Makefile.am b/include/jit/Makefile.am
index 4ec9bf1..f8f8359 100644
--- a/include/jit/Makefile.am
+++ b/include/jit/Makefile.am
@@ -1,6 +1,6 @@
ARCH_HEADER = address@hidden@.h
-BUILT_SOURCES = jit-arch.h
+BUILT_SOURCES = jit-arch.h jit-opcode.h
libjitincludedir = $(includedir)/jit
libjitinclude_HEADERS = \
@@ -33,8 +33,11 @@ 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
diff --git a/include/jit/jit-opcode.h b/include/jit/jit-opcode.h
deleted file mode 100644
index 4bb895e..0000000
--- a/include/jit/jit-opcode.h
+++ /dev/null
@@ -1,610 +0,0 @@
-/*
- * 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 */
diff --git a/jit/Makefile.am b/jit/Makefile.am
index 4dd0274..ef2af91 100644
--- a/jit/Makefile.am
+++ b/jit/Makefile.am
@@ -1,3 +1,4 @@
+BUILT_SOURCES = jit-opcode.c jit-interp-opcode.h jit-interp-opcode.c
lib_LTLIBRARIES = libjit.la
@@ -39,6 +40,8 @@ libjit_la_SOURCES = \
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 \
@@ -88,10 +91,10 @@ libjit_la_LDFLAGS = -version-info $(LIBJIT_VERSION)
-no-undefined
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
@@ -117,6 +120,15 @@ jit-rules-x86-64.inc: jit-rules-x86-64.ins
$(top_builddir)/tools/gen-rules$(EXEE
$(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 \
diff --git a/jit/jit-dump.c b/jit/jit-dump.c
index c9b7935..1147abd 100644
--- a/jit/jit-dump.c
+++ b/jit/jit-dump.c
@@ -534,8 +534,6 @@ void jit_dump_insn(FILE *stream, jit_function_t func,
jit_insn_t insn)
#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.
*/
diff --git a/jit/jit-interp.c b/jit/jit-interp.c
index 309bea2..16f5267 100644
--- a/jit/jit-interp.c
+++ b/jit/jit-interp.c
@@ -3525,7 +3525,7 @@ restart_tail:
}
VMBREAK;
- VMCASE(JIT_OP_IMPORT_LOCAL):
+ VMCASE(JIT_INTERP_OP_IMPORT_LOCAL):
{
/* TODO!!! */
/* Import the address of a local variable from an outer
scope */
@@ -3543,7 +3543,7 @@ restart_tail:
}
VMBREAK;
- VMCASE(JIT_OP_IMPORT_ARG):
+ VMCASE(JIT_INTERP_OP_IMPORT_ARG):
{
/* TODO!!! */
/* Import the address of an argument from an outer
scope */
@@ -4070,7 +4070,7 @@ restart_tail:
* 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);
@@ -4078,7 +4078,7 @@ restart_tail:
}
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);
@@ -4086,7 +4086,7 @@ restart_tail:
}
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);
@@ -4094,7 +4094,7 @@ restart_tail:
}
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);
@@ -4102,7 +4102,7 @@ restart_tail:
}
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);
@@ -4110,7 +4110,7 @@ restart_tail:
}
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);
@@ -4118,7 +4118,7 @@ restart_tail:
}
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);
@@ -4126,7 +4126,7 @@ restart_tail:
}
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);
@@ -4134,7 +4134,7 @@ restart_tail:
}
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);
@@ -4142,7 +4142,7 @@ restart_tail:
}
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);
@@ -4150,7 +4150,7 @@ restart_tail:
}
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);
@@ -4158,7 +4158,7 @@ restart_tail:
}
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);
@@ -4166,7 +4166,7 @@ restart_tail:
}
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);
@@ -4174,7 +4174,7 @@ restart_tail:
}
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);
@@ -4182,7 +4182,7 @@ restart_tail:
}
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);
@@ -4190,7 +4190,7 @@ restart_tail:
}
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);
@@ -4198,7 +4198,7 @@ restart_tail:
}
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);
@@ -4206,7 +4206,7 @@ restart_tail:
}
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);
@@ -4214,7 +4214,7 @@ restart_tail:
}
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);
@@ -4222,7 +4222,7 @@ restart_tail:
}
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);
@@ -4230,7 +4230,7 @@ restart_tail:
}
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);
@@ -4238,7 +4238,7 @@ restart_tail:
}
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);
@@ -4246,7 +4246,7 @@ restart_tail:
}
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);
@@ -4254,7 +4254,7 @@ restart_tail:
}
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);
@@ -4262,7 +4262,7 @@ restart_tail:
}
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);
@@ -4270,7 +4270,7 @@ restart_tail:
}
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);
@@ -4278,7 +4278,7 @@ restart_tail:
}
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);
@@ -4286,7 +4286,7 @@ restart_tail:
}
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);
@@ -4294,7 +4294,7 @@ restart_tail:
}
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);
@@ -4302,7 +4302,7 @@ restart_tail:
}
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);
@@ -4310,7 +4310,7 @@ restart_tail:
}
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;
@@ -4318,7 +4318,7 @@ restart_tail:
}
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;
@@ -4326,7 +4326,7 @@ restart_tail:
}
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;
@@ -4334,7 +4334,7 @@ restart_tail:
}
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;
@@ -4342,7 +4342,7 @@ restart_tail:
}
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;
@@ -4350,7 +4350,7 @@ restart_tail:
}
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;
@@ -4358,7 +4358,7 @@ restart_tail:
}
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;
@@ -4370,7 +4370,7 @@ restart_tail:
* 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);
@@ -4378,7 +4378,7 @@ restart_tail:
}
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);
@@ -4386,7 +4386,7 @@ restart_tail:
}
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);
@@ -4394,7 +4394,7 @@ restart_tail:
}
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);
@@ -4402,7 +4402,7 @@ restart_tail:
}
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);
@@ -4410,7 +4410,7 @@ restart_tail:
}
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);
@@ -4418,7 +4418,7 @@ restart_tail:
}
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);
@@ -4426,7 +4426,7 @@ restart_tail:
}
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);
@@ -4434,7 +4434,7 @@ restart_tail:
}
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);
@@ -4442,7 +4442,7 @@ restart_tail:
}
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);
@@ -4450,7 +4450,7 @@ restart_tail:
}
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);
@@ -4458,7 +4458,7 @@ restart_tail:
}
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);
@@ -4466,7 +4466,7 @@ restart_tail:
}
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);
@@ -4474,7 +4474,7 @@ restart_tail:
}
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);
@@ -4482,7 +4482,7 @@ restart_tail:
}
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);
@@ -4490,7 +4490,7 @@ restart_tail:
}
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);
@@ -4498,7 +4498,7 @@ restart_tail:
}
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);
@@ -4506,7 +4506,7 @@ restart_tail:
}
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);
@@ -4514,7 +4514,7 @@ restart_tail:
}
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);
@@ -4522,7 +4522,7 @@ restart_tail:
}
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);
@@ -4530,7 +4530,7 @@ restart_tail:
}
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);
@@ -4538,7 +4538,7 @@ restart_tail:
}
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);
@@ -4546,7 +4546,7 @@ restart_tail:
}
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);
@@ -4554,7 +4554,7 @@ restart_tail:
}
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);
@@ -4562,7 +4562,7 @@ restart_tail:
}
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);
@@ -4570,7 +4570,7 @@ restart_tail:
}
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);
@@ -4578,7 +4578,7 @@ restart_tail:
}
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);
@@ -4586,7 +4586,7 @@ restart_tail:
}
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);
@@ -4594,7 +4594,7 @@ restart_tail:
}
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);
@@ -4602,7 +4602,7 @@ restart_tail:
}
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);
@@ -4610,7 +4610,7 @@ restart_tail:
}
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;
@@ -4618,7 +4618,7 @@ restart_tail:
}
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;
@@ -4626,7 +4626,7 @@ restart_tail:
}
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;
@@ -4634,7 +4634,7 @@ restart_tail:
}
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;
@@ -4642,7 +4642,7 @@ restart_tail:
}
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;
@@ -4650,7 +4650,7 @@ restart_tail:
}
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;
@@ -4658,7 +4658,7 @@ restart_tail:
}
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;
@@ -4673,7 +4673,7 @@ restart_tail:
#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;
@@ -4681,7 +4681,7 @@ restart_tail:
}
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
@@ -4694,7 +4694,7 @@ restart_tail:
}
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));
@@ -4702,7 +4702,7 @@ restart_tail:
}
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));
@@ -4710,7 +4710,7 @@ restart_tail:
}
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));
@@ -4718,7 +4718,7 @@ restart_tail:
}
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;
@@ -4726,7 +4726,7 @@ restart_tail:
}
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
@@ -4739,7 +4739,7 @@ restart_tail:
}
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));
@@ -4747,7 +4747,7 @@ restart_tail:
}
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));
@@ -4755,7 +4755,7 @@ restart_tail:
}
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));
@@ -4763,7 +4763,7 @@ restart_tail:
}
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;
@@ -4771,7 +4771,7 @@ restart_tail:
}
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
@@ -4784,7 +4784,7 @@ restart_tail:
}
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));
@@ -4792,7 +4792,7 @@ restart_tail:
}
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));
@@ -4800,7 +4800,7 @@ restart_tail:
}
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));
@@ -4812,7 +4812,7 @@ restart_tail:
* 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;
@@ -4820,7 +4820,7 @@ restart_tail:
}
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;
@@ -4828,7 +4828,7 @@ restart_tail:
}
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;
@@ -4836,7 +4836,7 @@ restart_tail:
}
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;
@@ -4844,7 +4844,7 @@ restart_tail:
}
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;
@@ -4864,21 +4864,21 @@ restart_tail:
}
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);
diff --git a/jit/jit-interp.h b/jit/jit-interp.h
index 42768c3..bfa8116 100644
--- a/jit/jit-interp.h
+++ b/jit/jit-interp.h
@@ -25,6 +25,7 @@
#include "jit-internal.h"
#include "jit-apply-rules.h"
+#include "jit-interp-opcode.h"
#ifdef __cplusplus
extern "C" {
@@ -89,160 +90,6 @@ struct jit_function_interp
#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
diff --git a/jit/jit-opcode.c b/jit/jit-opcode.c
deleted file mode 100644
index 36b713c..0000000
--- a/jit/jit-opcode.c
+++ /dev/null
@@ -1,680 +0,0 @@
-/*
- * 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 */
diff --git a/jit/jit-rules-interp.c b/jit/jit-rules-interp.c
index e3f5d80..34b6a57 100644
--- a/jit/jit-rules-interp.c
+++ b/jit/jit-rules-interp.c
@@ -900,7 +900,7 @@ load_value(jit_gencode_t gen, jit_value_t value, int index)
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;
@@ -909,7 +909,7 @@ load_value(jit_gencode_t gen, jit_value_t value, int index)
{
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
@@ -922,7 +922,7 @@ load_value(jit_gencode_t gen, jit_value_t value, int index)
{
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;
}
@@ -931,7 +931,7 @@ load_value(jit_gencode_t gen, jit_value_t value, int index)
{
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;
}
@@ -940,7 +940,7 @@ load_value(jit_gencode_t gen, jit_value_t value, int index)
{
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;
}
@@ -958,13 +958,13 @@ load_value(jit_gencode_t gen, jit_value_t value, int
index)
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;
@@ -978,13 +978,13 @@ load_value(jit_gencode_t gen, jit_value_t value, int
index)
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;
@@ -1011,11 +1011,11 @@ store_value(jit_gencode_t gen, jit_value_t value)
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);
@@ -1276,13 +1276,13 @@ void _jit_gen_insn(jit_gencode_t gen, jit_function_t
func,
_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));
}
@@ -1346,28 +1346,28 @@ void _jit_gen_insn(jit_gencode_t gen, jit_function_t
func,
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;
}
@@ -1403,12 +1403,12 @@ void _jit_gen_insn(jit_gencode_t gen, jit_function_t
func,
_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);
@@ -1446,15 +1446,15 @@ void _jit_gen_insn(jit_gencode_t gen, jit_function_t
func,
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)
{
diff --git a/jit/mklabel.sh b/jit/mklabel.sh
index 21b0ba5..959780f 100755
--- a/jit/mklabel.sh
+++ b/jit/mklabel.sh
@@ -152,11 +152,11 @@ pic_table()
}
# 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 ''
@@ -270,11 +270,11 @@ non_pic_table()
}
# 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 ''
diff --git a/tools/.gitignore b/tools/.gitignore
index 0e470ed..6dc60bc 100644
--- a/tools/.gitignore
+++ b/tools/.gitignore
@@ -4,6 +4,8 @@ Makefile.in
.libs
gen-apply
gen-apply.exe
+gen-ops
+gen-ops.exe
gen-rules
gen-rules.exe
*.lo
@@ -13,3 +15,6 @@ gen-rules.exe
gen-rules-parser.c
gen-rules-parser.h
gen-rules-scanner.c
+gen-ops-parser.c
+gen-ops-parser.h
+gen-ops-scanner.c
diff --git a/tools/Makefile.am b/tools/Makefile.am
index d86ee3c..3c27e82 100644
--- a/tools/Makefile.am
+++ b/tools/Makefile.am
@@ -1,5 +1,5 @@
-noinst_PROGRAMS = gen-apply gen-rules
+noinst_PROGRAMS = gen-apply gen-rules gen-ops
noinst_HEADERS = gen-apply-macosx.h
@@ -7,10 +7,14 @@ gen_apply_SOURCES = gen-apply.c
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)
diff --git a/tools/gen-ops-parser.y b/tools/gen-ops-parser.y
new file mode 100644
index 0000000..35dc051
--- /dev/null
+++ b/tools/gen-ops-parser.y
@@ -0,0 +1,1119 @@
+%{
+/*
+ * 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;
+}
diff --git a/tools/gen-ops-scanner.l b/tools/gen-ops-scanner.l
new file mode 100644
index 0000000..25af607
--- /dev/null
+++ b/tools/gen-ops-scanner.l
@@ -0,0 +1,336 @@
+%{
+/*
+ * 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;
+}
-----------------------------------------------------------------------
Summary of changes:
ChangeLog | 48 +
Makefile.am | 2 +-
config/Makefile.am | 1 +
config/jit-interp-opcodes.ops | 225 +++++
config/jit-opcodes.ops | 630 ++++++++++++
configure.ac | 1 +
include/jit/Makefile.am | 7 +-
include/jit/jit-opcode.h | 610 ------------
jit/Makefile.am | 16 +-
jit/jit-dump.c | 2 -
jit/jit-interp.c | 198 ++--
jit/jit-interp.h | 155 +---
jit/jit-opcode.c | 680 -------------
jit/jit-rules-interp.c | 50 +-
jit/mklabel.sh | 12 +-
tools/.gitignore | 5 +
tools/Makefile.am | 6 +-
tools/gen-ops-parser.y | 1119 ++++++++++++++++++++++
tools/{gen-rules-scanner.l => gen-ops-scanner.l} | 164 ++--
19 files changed, 2288 insertions(+), 1643 deletions(-)
create mode 100644 config/Makefile.am
create mode 100644 config/jit-interp-opcodes.ops
create mode 100644 config/jit-opcodes.ops
delete mode 100644 include/jit/jit-opcode.h
delete mode 100644 jit/jit-opcode.c
create mode 100644 tools/gen-ops-parser.y
copy tools/{gen-rules-scanner.l => gen-ops-scanner.l} (58%)
hooks/post-receive
--
DotGNU Portable.NET Just In Time compiler (libjit)
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [dotgnu-pnet-commits] [SCM] DotGNU Portable.NET Just In Time compiler (libjit) branch, master, updated. bcf9a2ff8bd47b798c41986eec527d96ea386317,
Klaus Treichel <=