From: Klaus Treichel Date: Tue, 3 Aug 2010 09:44:07 +0000 (+0200) Subject: Add gen-ops tool for generation all opcode defintions ans tables from one X-Git-Url: https://git.unchartedbackwaters.co.uk/w/?a=commitdiff_plain;h=bcf9a2ff8bd47b798c41986eec527d96ea386317;p=francis%2Flibjit.git 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 + + * 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 * 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 + * . + */ + +#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 + * . + */ + +#ifndef _JIT_INTERP_OPCODE_H +#define _JIT_INTERP_OPCODE_H + +#include + +#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 + * . + */ + +#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 + * . + */ + +#ifndef _JIT_OPCODE_H +#define _JIT_OPCODE_H + +#include + +#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 = jit-arch-@JIT_ARCH@.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 - * . - */ - -#ifndef _JIT_OPCODE_H -#define _JIT_OPCODE_H - -#include - -#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 - * . - */ - -#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 + * . + */ + +#include +#include +#include +#ifdef HAVE_STDLIB_H +# include +#endif +#ifdef HAVE_STRING_H +# include +#elif defined(HAVE_STRINGS_H) +# include +#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 CODE_BLOCK HEADER_BLOCK +%type IDENTIFIER LITERAL Literal +%type Blocks +%type OpcodeListHeader +%type ValueFlag Op +%type OpcodeType OpcodeTypeFlag +%type OpcodeExpression +%type Opcode +%type OpcodeHeader +%type OpcodeProperties +%type 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 + * . + */ + +#include "gen-ops-parser.h" +#include +#include +#ifdef HAVE_STDLIB_H +# include +#endif +#ifdef HAVE_STRING_H +# include +#elif defined(HAVE_STRINGS_H) +# include +#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; +}