mirror of
https://git.savannah.gnu.org/git/guile.git
synced 2025-06-28 05:50:30 +02:00
Big merge with new lightning semantics aiming for lightning 2.0.
2012-12-02 Paulo Andrade <pcpa@gnu.org> * tests/Makefile.am, tests/3to2.c, tests/3to2.ok, tests/add.c, tests/add.ok, tests/allocai.c, tests/allocai.ok, tests/bp.c, tests/bp.ok, tests/divi.c, tests/divi.ok, tests/fib.c, tests/fib.ok, tests/fibdelay.c, tests/fibdelay.ok, tests/fibit.c, tests/fibit.ok, tests/funcfp.c, tests/funcfp.ok, tests/incr.c, tests/incr.ok, tests/ldst.c, tests/ldst.ok, tests/ldxi.c, tests/ldxi.ok, tests/modi.c, tests/modi.ok, tests/movi.c, tests/movi.ok, tests/printf.c, tests/printf.ok, tests/printf2.c, tests/printf2.ok, tests/ret.c, tests/ret.ok, tests/rpn.c, tests/rpn.ok, tests/rpnfp.c, tests/rpnfp.ok, tests/sete.c, tests/sete.ok, tests/testfp.c, tests/testfp.ok, tests-run-test: Removed previous test suite, in favor of a newer one in the check subdirectory. * check/3to2.ok, check/3to2.tst, check/add.ok, check/add.tst, check/allocai.ok, check/allocai.tst, check/bp.ok, check/bp.tst, check/divi.ok, check/divi.tst, check/fib.ok, check/fib.tst: New sample input for the new test program, loosely matching several of the previous test cases. * check/Makefile.am: New test suite makefile. * check/check.sh, check/run-test: New wrapper files for the new test suite. * check/lightning.c: New file. The main driver of the new test suite, that compiles to a parser of a very simple assembly like language, generates jit and executes it. * check/all.tst: New file. A generic debug and sample test file with a directive to prevent it from being executed, and useful to read disassembly of all possible instructions, using a fixed set of registers. * include/Makefile.am, include/lightning.h, include/lightning/Makefile.am, include/lightning/jit_arm.h, include/lightning/jit_mips.h, include/lightning/jit_ppc.h, include/lightning/jit_private.h, include/lightning/jit_x86.h, lib/Makefile.am, lib/jit_disasm.c, lib/jit_print.c, lib/jit_x86-cpu.c, lib/jit_x86-sse.c, lib/jit_x86-x87.c, lib/jit_x86.c, lib/lightning.c: New files. These files are written from scratch, only by <pcpa@gnu.org>, and have now copyright assignment to the FSF. This is the core of the new lightning rework. Previously it was integrated in code with a garbage collector and several custom types like vectors and hash tables, so this first code merge with lightning converts that code into a library extracting only the jit bits, and at first only for x86_64 GNU/Linux. * lightning.h, m4/lightning.m4: Removed. These are no longer required in the new lightning code. .gitignore, Makefile.am, configure.ac: Update for the new lightning code.
This commit is contained in:
pcpa
parent
75d99beb21
commit
7a1c455237
77 changed files with 17194 additions and 8221 deletions
17
include/Makefile.am
Normal file
17
include/Makefile.am
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
#
|
||||
# Copyright 2000, 2001, 2002, 2012 Free Software Foundation, Inc.
|
||||
#
|
||||
# This is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This software 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 General Public License for more details.
|
||||
#
|
||||
|
||||
include_HEADERS = lightning.h
|
||||
SUBDIRS = \
|
||||
lightning
|
||||
852
include/lightning.h
Normal file
852
include/lightning.h
Normal file
|
|
@ -0,0 +1,852 @@
|
|||
/*
|
||||
* Copyright (C) 2012 Free Software Foundation, Inc.
|
||||
*
|
||||
* This is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This software 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 General Public License for more details.
|
||||
*
|
||||
* Authors:
|
||||
* Paulo Cesar Pereira de Andrade
|
||||
*/
|
||||
|
||||
#ifndef _lightning_h
|
||||
#define _lightning_h
|
||||
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifndef __WORDSIZE
|
||||
# define __WORDSIZE WORDSIZE
|
||||
#endif
|
||||
#ifndef __BYTE_ORDER
|
||||
# define __BYTE_ORDER BYTE_ORDER
|
||||
#endif
|
||||
#ifndef __LITTLE_ENDIAN
|
||||
# define __LITTLE_ENDIAN LITTLE_ENDIAN
|
||||
#endif
|
||||
#ifndef __BIG_ENDIAN
|
||||
# define __BIG_ENDIAN BIG_ENDIAN
|
||||
#endif
|
||||
|
||||
typedef signed char jit_int8_t;
|
||||
typedef unsigned char jit_uint8_t;
|
||||
typedef signed short jit_int16_t;
|
||||
typedef unsigned short jit_uint16_t;
|
||||
typedef signed int jit_int32_t;
|
||||
typedef unsigned int jit_uint32_t;
|
||||
#if __WORDSIZE == 32
|
||||
typedef signed long long jit_int64_t;
|
||||
typedef unsigned long long jit_uint64_t;
|
||||
typedef jit_int32_t jit_word_t;
|
||||
typedef jit_uint32_t jit_uword_t;
|
||||
#else
|
||||
typedef signed long jit_int64_t;
|
||||
typedef unsigned long jit_uint64_t;
|
||||
typedef jit_int64_t jit_word_t;
|
||||
typedef jit_uint64_t jit_uword_t;
|
||||
#endif
|
||||
typedef float jit_float32_t;
|
||||
typedef double jit_float64_t;
|
||||
typedef void* jit_pointer_t;
|
||||
typedef jit_int32_t jit_bool_t;
|
||||
typedef jit_int32_t jit_gpr_t;
|
||||
typedef jit_int32_t jit_fpr_t;
|
||||
|
||||
#if defined(__i386__) || defined(__x86_64__)
|
||||
# include <lightning/jit_x86.h>
|
||||
#elif defined(__mips__)
|
||||
# include <lightning/jit_mips.h>
|
||||
#elif defined(__arm__)
|
||||
# include <lightning/jit_arm.h>
|
||||
#elif defined(__ppc__)
|
||||
# include <lightning/jit_ppc.h>
|
||||
#endif
|
||||
|
||||
#define jit_flag_node 0x00000001 /* patch node not absolute */
|
||||
#define jit_flag_patch 0x00000002 /* jump already patched */
|
||||
#define jit_flag_data 0x00000004 /* data in the constant pool */
|
||||
#define jit_flag_use 0x00000008 /* do not remove marker label */
|
||||
#define jit_flag_head 0x00100000 /* label reached by normal flow */
|
||||
|
||||
#define JIT_R(index) jit_r(index)
|
||||
#define JIT_V(index) jit_v(index)
|
||||
#define JIT_F(index) jit_f(index)
|
||||
#define JIT_R_NUM jit_r_num()
|
||||
#define JIT_V_NUM jit_v_num()
|
||||
#define JIT_F_NUM jit_f_num()
|
||||
|
||||
#define jit_class_chk 0x02000000 /* just checking */
|
||||
#define jit_class_arg 0x08000000 /* argument register */
|
||||
#define jit_class_sav 0x10000000 /* callee save */
|
||||
#define jit_class_gpr 0x20000000 /* general purpose */
|
||||
#define jit_class_fpr 0x40000000 /* float */
|
||||
#define jit_class(reg) ((reg) & 0xffff0000)
|
||||
#define jit_regno(reg) ((reg) & 0x00007fff)
|
||||
|
||||
#define jit_call_default 0
|
||||
/* assume only varags functions called are printf like, that is,
|
||||
* without a declared float/double argument */
|
||||
/* FIXME currently no way to create a varargs (or non varargs) jit function
|
||||
* if calling sequence changes for float/double arguments */
|
||||
#define jit_call_varargs 1
|
||||
|
||||
typedef struct jit_node jit_node_t;
|
||||
typedef struct jit_state jit_state_t;
|
||||
|
||||
typedef enum {
|
||||
#define jit_data(u,v) _jit_data(_jit,u,v)
|
||||
jit_code_data,
|
||||
jit_code_save, jit_code_load,
|
||||
#define jit_note(u) jit_new_node_ww(jit_code_note,0,(jit_word_t)u)
|
||||
#define jit_label() _jit_label(_jit)
|
||||
#define jit_forward() _jit_forward(_jit)
|
||||
#define jit_link(u) _jit_link(_jit,u)
|
||||
jit_code_note, jit_code_label,
|
||||
|
||||
#define jit_prolog() _jit_prolog(_jit)
|
||||
jit_code_prolog,
|
||||
|
||||
#define jit_allocai(u) _jit_allocai(_jit,u)
|
||||
|
||||
#define jit_arg() _jit_arg(_jit)
|
||||
#define jit_getarg_c(u,v) _jit_getarg_c(_jit,u,v)
|
||||
#define jit_getarg_uc(u,v) _jit_getarg_uc(_jit,u,v)
|
||||
#define jit_getarg_s(u,v) _jit_getarg_s(_jit,u,v)
|
||||
#define jit_getarg_us(u,v) _jit_getarg_us(_jit,u,v)
|
||||
#define jit_getarg_i(u,v) _jit_getarg_i(_jit,u,v)
|
||||
/* >> 64 bit */
|
||||
#define jit_getarg_ui(u,v) _jit_getarg_ui(_jit,u,v)
|
||||
#define jit_getarg_l(u,v) _jit_getarg_l(_jit,u,v)
|
||||
/* << 64 bit */
|
||||
#if __WORDSIZE == 32
|
||||
# define jit_getarg(u,v) jit_getarg_i(u,v)
|
||||
#else
|
||||
# define jit_getarg(u,v) jit_getarg_l(u,v)
|
||||
#endif
|
||||
|
||||
#define jit_addr(u,v,w) jit_new_node_www(jit_code_addr,u,v,w)
|
||||
#define jit_addi(u,v,w) jit_new_node_www(jit_code_addi,u,v,w)
|
||||
jit_code_addr, jit_code_addi,
|
||||
#define jit_addxr(u,v,w) jit_new_node_www(jit_code_addxr,u,v,w)
|
||||
#define jit_addxi(u,v,w) jit_new_node_www(jit_code_addxi,u,v,w)
|
||||
jit_code_addxr, jit_code_addxi,
|
||||
#define jit_addcr(u,v,w) jit_new_node_www(jit_code_addcr,u,v,w)
|
||||
#define jit_addci(u,v,w) jit_new_node_www(jit_code_addci,u,v,w)
|
||||
jit_code_addcr, jit_code_addci,
|
||||
#define jit_subr(u,v,w) jit_new_node_www(jit_code_subr,u,v,w)
|
||||
#define jit_subi(u,v,w) jit_new_node_www(jit_code_subi,u,v,w)
|
||||
jit_code_subr, jit_code_subi,
|
||||
#define jit_subxr(u,v,w) jit_new_node_www(jit_code_subxr,u,v,w)
|
||||
#define jit_subxi(u,v,w) jit_new_node_www(jit_code_subxi,u,v,w)
|
||||
jit_code_subxr, jit_code_subxi,
|
||||
#define jit_subcr(u,v,w) jit_new_node_www(jit_code_subcr,u,v,w)
|
||||
#define jit_subci(u,v,w) jit_new_node_www(jit_code_subci,u,v,w)
|
||||
jit_code_subcr, jit_code_subci,
|
||||
|
||||
#define jit_mulr(u,v,w) jit_new_node_www(jit_code_mulr,u,v,w)
|
||||
#define jit_muli(u,v,w) jit_new_node_www(jit_code_muli,u,v,w)
|
||||
jit_code_mulr, jit_code_muli,
|
||||
#define jit_divr(u,v,w) jit_new_node_www(jit_code_divr,u,v,w)
|
||||
#define jit_divi(u,v,w) jit_new_node_www(jit_code_divi,u,v,w)
|
||||
jit_code_divr, jit_code_divi,
|
||||
#define jit_divr_u(u,v,w) jit_new_node_www(jit_code_divr_u,u,v,w)
|
||||
#define jit_divi_u(u,v,w) jit_new_node_www(jit_code_divi_u,u,v,w)
|
||||
jit_code_divr_u, jit_code_divi_u,
|
||||
#define jit_remr(u,v,w) jit_new_node_www(jit_code_remr,u,v,w)
|
||||
#define jit_remi(u,v,w) jit_new_node_www(jit_code_remi,u,v,w)
|
||||
jit_code_remr, jit_code_remi,
|
||||
#define jit_remr_u(u,v,w) jit_new_node_www(jit_code_remr_u,u,v,w)
|
||||
#define jit_remi_u(u,v,w) jit_new_node_www(jit_code_remi_u,u,v,w)
|
||||
jit_code_remr_u, jit_code_remi_u,
|
||||
|
||||
#define jit_andr(u,v,w) jit_new_node_www(jit_code_andr,u,v,w)
|
||||
#define jit_andi(u,v,w) jit_new_node_www(jit_code_andi,u,v,w)
|
||||
jit_code_andr, jit_code_andi,
|
||||
#define jit_orr(u,v,w) jit_new_node_www(jit_code_orr,u,v,w)
|
||||
#define jit_ori(u,v,w) jit_new_node_www(jit_code_ori,u,v,w)
|
||||
jit_code_orr, jit_code_ori,
|
||||
#define jit_xorr(u,v,w) jit_new_node_www(jit_code_xorr,u,v,w)
|
||||
#define jit_xori(u,v,w) jit_new_node_www(jit_code_xori,u,v,w)
|
||||
jit_code_xorr, jit_code_xori,
|
||||
|
||||
#define jit_lshr(u,v,w) jit_new_node_www(jit_code_lshr,u,v,w)
|
||||
#define jit_lshi(u,v,w) jit_new_node_www(jit_code_lshi,u,v,w)
|
||||
jit_code_lshr, jit_code_lshi,
|
||||
#define jit_rshr(u,v,w) jit_new_node_www(jit_code_rshr,u,v,w)
|
||||
#define jit_rshi(u,v,w) jit_new_node_www(jit_code_rshi,u,v,w)
|
||||
jit_code_rshr, jit_code_rshi,
|
||||
#define jit_rshr_u(u,v,w) jit_new_node_www(jit_code_rshr_u,u,v,w)
|
||||
#define jit_rshi_u(u,v,w) jit_new_node_www(jit_code_rshi_u,u,v,w)
|
||||
jit_code_rshr_u, jit_code_rshi_u,
|
||||
|
||||
#define jit_negr(u,v) jit_new_node_ww(jit_code_negr,u,v)
|
||||
#define jit_comr(u,v) jit_new_node_ww(jit_code_comr,u,v)
|
||||
jit_code_negr, jit_code_comr,
|
||||
|
||||
#define jit_ltr(u,v,w) jit_new_node_www(jit_code_ltr,u,v,w)
|
||||
#define jit_lti(u,v,w) jit_new_node_www(jit_code_lti,u,v,w)
|
||||
jit_code_ltr, jit_code_lti,
|
||||
#define jit_ltr_u(u,v,w) jit_new_node_www(jit_code_ltr_u,u,v,w)
|
||||
#define jit_lti_u(u,v,w) jit_new_node_www(jit_code_lti_u,u,v,w)
|
||||
jit_code_ltr_u, jit_code_lti_u,
|
||||
#define jit_ler(u,v,w) jit_new_node_www(jit_code_ler,u,v,w)
|
||||
#define jit_lei(u,v,w) jit_new_node_www(jit_code_lei,u,v,w)
|
||||
jit_code_ler, jit_code_lei,
|
||||
#define jit_ler_u(u,v,w) jit_new_node_www(jit_code_ler_u,u,v,w)
|
||||
#define jit_lei_u(u,v,w) jit_new_node_www(jit_code_lei_u,u,v,w)
|
||||
jit_code_ler_u, jit_code_lei_u,
|
||||
#define jit_eqr(u,v,w) jit_new_node_www(jit_code_eqr,u,v,w)
|
||||
#define jit_eqi(u,v,w) jit_new_node_www(jit_code_eqi,u,v,w)
|
||||
jit_code_eqr, jit_code_eqi,
|
||||
#define jit_ger(u,v,w) jit_new_node_www(jit_code_ger,u,v,w)
|
||||
#define jit_gei(u,v,w) jit_new_node_www(jit_code_gei,u,v,w)
|
||||
jit_code_ger, jit_code_gei,
|
||||
#define jit_ger_u(u,v,w) jit_new_node_www(jit_code_ger_u,u,v,w)
|
||||
#define jit_gei_u(u,v,w) jit_new_node_www(jit_code_gei_u,u,v,w)
|
||||
jit_code_ger_u, jit_code_gei_u,
|
||||
#define jit_gtr(u,v,w) jit_new_node_www(jit_code_gtr,u,v,w)
|
||||
#define jit_gti(u,v,w) jit_new_node_www(jit_code_gti,u,v,w)
|
||||
jit_code_gtr, jit_code_gti,
|
||||
#define jit_gtr_u(u,v,w) jit_new_node_www(jit_code_gtr_u,u,v,w)
|
||||
#define jit_gti_u(u,v,w) jit_new_node_www(jit_code_gti_u,u,v,w)
|
||||
jit_code_gtr_u, jit_code_gti_u,
|
||||
#define jit_ner(u,v,w) jit_new_node_www(jit_code_ner,u,v,w)
|
||||
#define jit_nei(u,v,w) jit_new_node_www(jit_code_nei,u,v,w)
|
||||
jit_code_ner, jit_code_nei,
|
||||
|
||||
#define jit_movr(u,v) jit_new_node_ww(jit_code_movr,u,v)
|
||||
#define jit_movi(u,v) jit_new_node_ww(jit_code_movi,u,v)
|
||||
jit_code_movr, jit_code_movi,
|
||||
#define jit_extr_c(u,v) jit_new_node_ww(jit_code_extr_c,u,v)
|
||||
#define jit_extr_uc(u,v) jit_new_node_ww(jit_code_extr_uc,u,v)
|
||||
jit_code_extr_c, jit_code_extr_uc,
|
||||
#define jit_extr_s(u,v) jit_new_node_ww(jit_code_extr_s,u,v)
|
||||
#define jit_extr_us(u,v) jit_new_node_ww(jit_code_extr_us,u,v)
|
||||
jit_code_extr_s, jit_code_extr_us,
|
||||
/* >> 64 bit */
|
||||
#define jit_extr_i(u,v) jit_new_node_ww(jit_code_extr_i,u,v)
|
||||
#define jit_extr_ui(u,v) jit_new_node_ww(jit_code_extr_ui,u,v)
|
||||
jit_code_extr_i, jit_code_extr_ui,
|
||||
/* << 64 bit */
|
||||
#define jit_htonr(u,v) jit_new_node_ww(jit_code_htonr,u,v)
|
||||
#define jit_ntohr(u,v) jit_new_node_ww(jit_code_htonr,u,v)
|
||||
jit_code_htonr,
|
||||
|
||||
#define jit_ldr_c(u,v) jit_new_node_ww(jit_code_ldr_c,u,v)
|
||||
#define jit_ldi_c(u,v) jit_new_node_ww(jit_code_ldi_c,u,v)
|
||||
jit_code_ldr_c, jit_code_ldi_c,
|
||||
#define jit_ldr_uc(u,v) jit_new_node_ww(jit_code_ldr_uc,u,v)
|
||||
#define jit_ldi_uc(u,v) jit_new_node_ww(jit_code_ldi_uc,u,v)
|
||||
jit_code_ldr_uc, jit_code_ldi_uc,
|
||||
#define jit_ldr_s(u,v) jit_new_node_ww(jit_code_ldr_s,u,v)
|
||||
#define jit_ldi_s(u,v) jit_new_node_ww(jit_code_ldi_s,u,v)
|
||||
jit_code_ldr_s, jit_code_ldi_s,
|
||||
#define jit_ldr_us(u,v) jit_new_node_ww(jit_code_ldr_us,u,v)
|
||||
#define jit_ldi_us(u,v) jit_new_node_ww(jit_code_ldi_us,u,v)
|
||||
jit_code_ldr_us, jit_code_ldi_us,
|
||||
#define jit_ldr_i(u,v) jit_new_node_ww(jit_code_ldr_i,u,v)
|
||||
#define jit_ldi_i(u,v) jit_new_node_ww(jit_code_ldi_i,u,v)
|
||||
jit_code_ldr_i, jit_code_ldi_i,
|
||||
#if __WORDSIZE == 32
|
||||
# define jit_ldr(u,v) jit_ldr_i(u,v)
|
||||
# define jit_ldi(u,v) jit_ldi_i(u,v)
|
||||
#else
|
||||
# define jit_ldr(u,v) jit_ldr_l(u,v)
|
||||
# define jit_ldi(u,v) jit_ldi_l(u,v)
|
||||
#endif
|
||||
/* >> 64 bit */
|
||||
#define jit_ldr_ui(u,v) jit_new_node_ww(jit_code_ldr_ui,u,v)
|
||||
#define jit_ldi_ui(u,v) jit_new_node_ww(jit_code_ldi_ui,u,v)
|
||||
jit_code_ldr_ui, jit_code_ldi_ui,
|
||||
#define jit_ldr_l(u,v) jit_new_node_ww(jit_code_ldr_l,u,v)
|
||||
#define jit_ldi_l(u,v) jit_new_node_ww(jit_code_ldi_l,u,v)
|
||||
jit_code_ldr_l, jit_code_ldi_l,
|
||||
/* << 64 bit */
|
||||
|
||||
#define jit_ldxr_c(u,v,w) jit_new_node_www(jit_code_ldxr_c,u,v,w)
|
||||
#define jit_ldxi_c(u,v,w) jit_new_node_www(jit_code_ldxi_c,u,v,w)
|
||||
jit_code_ldxr_c, jit_code_ldxi_c,
|
||||
#define jit_ldxr_uc(u,v,w) jit_new_node_www(jit_code_ldxr_uc,u,v,w)
|
||||
#define jit_ldxi_uc(u,v,w) jit_new_node_www(jit_code_ldxi_uc,u,v,w)
|
||||
jit_code_ldxr_uc, jit_code_ldxi_uc,
|
||||
#define jit_ldxr_s(u,v,w) jit_new_node_www(jit_code_ldxr_s,u,v,w)
|
||||
#define jit_ldxi_s(u,v,w) jit_new_node_www(jit_code_ldxi_s,u,v,w)
|
||||
jit_code_ldxr_s, jit_code_ldxi_s,
|
||||
#define jit_ldxr_us(u,v,w) jit_new_node_www(jit_code_ldxr_us,u,v,w)
|
||||
#define jit_ldxi_us(u,v,w) jit_new_node_www(jit_code_ldxi_us,u,v,w)
|
||||
jit_code_ldxr_us, jit_code_ldxi_us,
|
||||
#define jit_ldxr_i(u,v,w) jit_new_node_www(jit_code_ldxr_i,u,v,w)
|
||||
#define jit_ldxi_i(u,v,w) jit_new_node_www(jit_code_ldxi_i,u,v,w)
|
||||
jit_code_ldxr_i, jit_code_ldxi_i,
|
||||
#if __WORDSIZE == 32
|
||||
# define jit_ldxr(u,v,w) jit_ldxr_i(u,v,w)
|
||||
# define jit_ldxi(u,v,w) jit_ldxi_i(u,v,w)
|
||||
#else
|
||||
# define jit_ldxr_ui(u,v,w) jit_new_node_www(jit_code_ldxr_ui,u,v,w)
|
||||
# define jit_ldxi_ui(u,v,w) jit_new_node_www(jit_code_ldxi_ui,u,v,w)
|
||||
# define jit_ldxr_l(u,v,w) jit_new_node_www(jit_code_ldxr_l,u,v,w)
|
||||
# define jit_ldxi_l(u,v,w) jit_new_node_www(jit_code_ldxi_l,u,v,w)
|
||||
# define jit_ldxr(u,v,w) jit_ldxr_l(u,v,w)
|
||||
# define jit_ldxi(u,v,w) jit_ldxi_l(u,v,w)
|
||||
#endif
|
||||
jit_code_ldxr_ui, jit_code_ldxi_ui,
|
||||
jit_code_ldxr_l, jit_code_ldxi_l,
|
||||
|
||||
#define jit_str_c(u,v) jit_new_node_ww(jit_code_str_c,u,v)
|
||||
#define jit_sti_c(u,v) jit_new_node_ww(jit_code_sti_c,u,v)
|
||||
jit_code_str_c, jit_code_sti_c,
|
||||
#define jit_str_s(u,v) jit_new_node_ww(jit_code_str_s,u,v)
|
||||
#define jit_sti_s(u,v) jit_new_node_ww(jit_code_sti_s,u,v)
|
||||
jit_code_str_s, jit_code_sti_s,
|
||||
#define jit_str_i(u,v) jit_new_node_ww(jit_code_str_i,u,v)
|
||||
#define jit_sti_i(u,v) jit_new_node_ww(jit_code_sti_i,u,v)
|
||||
jit_code_str_i, jit_code_sti_i,
|
||||
#if __WORDSIZE == 32
|
||||
# define jit_str(u,v) jit_str_i(u,v)
|
||||
# define jit_sti(u,v) jit_sti_i(u,v)
|
||||
#else
|
||||
#define jit_str(u,v) jit_str_l(u,v)
|
||||
#define jit_sti(u,v) jit_sti_l(u,v)
|
||||
#endif
|
||||
/* >> 64 bit */
|
||||
#define jit_str_l(u,v) jit_new_node_ww(jit_code_str_l,u,v)
|
||||
#define jit_sti_l(u,v) jit_new_node_ww(jit_code_sti_l,u,v)
|
||||
jit_code_str_l, jit_code_sti_l,
|
||||
/* << 64 bit */
|
||||
|
||||
#define jit_stxr_c(u,v,w) jit_new_node_www(jit_code_stxr_c,u,v,w)
|
||||
#define jit_stxi_c(u,v,w) jit_new_node_www(jit_code_stxi_c,u,v,w)
|
||||
jit_code_stxr_c, jit_code_stxi_c,
|
||||
#define jit_stxr_s(u,v,w) jit_new_node_www(jit_code_stxr_s,u,v,w)
|
||||
#define jit_stxi_s(u,v,w) jit_new_node_www(jit_code_stxi_s,u,v,w)
|
||||
jit_code_stxr_s, jit_code_stxi_s,
|
||||
#define jit_stxr_i(u,v,w) jit_new_node_www(jit_code_stxr_i,u,v,w)
|
||||
#define jit_stxi_i(u,v,w) jit_new_node_www(jit_code_stxi_i,u,v,w)
|
||||
jit_code_stxr_i, jit_code_stxi_i,
|
||||
#if __WORDSIZE == 32
|
||||
# define jit_stxr(u,v,w) jit_stxr_i(u,v,w)
|
||||
# define jit_stxi(u,v,w) jit_stxi_i(u,v,w)
|
||||
#else
|
||||
# define jit_stxr_l(u,v,w) jit_new_node_www(jit_code_stxr_l,u,v,w)
|
||||
# define jit_stxi_l(u,v,w) jit_new_node_www(jit_code_stxi_l,u,v,w)
|
||||
#endif
|
||||
/* >> 64 bit */
|
||||
#define jit_stxr(u,v,w) jit_stxr_l(u,v,w)
|
||||
#define jit_stxi(u,v,w) jit_stxi_l(u,v,w)
|
||||
jit_code_stxr_l, jit_code_stxi_l,
|
||||
/* << 64 bit */
|
||||
|
||||
#define jit_bltr(v,w) jit_new_node_pww(jit_code_bltr,NULL,v,w)
|
||||
#define jit_blti(v,w) jit_new_node_pww(jit_code_blti,NULL,v,w)
|
||||
jit_code_bltr, jit_code_blti,
|
||||
#define jit_bltr_u(v,w) jit_new_node_pww(jit_code_bltr_u,NULL,v,w)
|
||||
#define jit_blti_u(v,w) jit_new_node_pww(jit_code_blti_u,NULL,v,w)
|
||||
jit_code_bltr_u, jit_code_blti_u,
|
||||
#define jit_bler(v,w) jit_new_node_pww(jit_code_bler,NULL,v,w)
|
||||
#define jit_blei(v,w) jit_new_node_pww(jit_code_blei,NULL,v,w)
|
||||
jit_code_bler, jit_code_blei,
|
||||
#define jit_bler_u(v,w) jit_new_node_pww(jit_code_bler_u,NULL,v,w)
|
||||
#define jit_blei_u(v,w) jit_new_node_pww(jit_code_blei_u,NULL,v,w)
|
||||
jit_code_bler_u, jit_code_blei_u,
|
||||
#define jit_beqr(v,w) jit_new_node_pww(jit_code_beqr,NULL,v,w)
|
||||
#define jit_beqi(v,w) jit_new_node_pww(jit_code_beqi,NULL,v,w)
|
||||
jit_code_beqr, jit_code_beqi,
|
||||
#define jit_bger(v,w) jit_new_node_pww(jit_code_bger,NULL,v,w)
|
||||
#define jit_bgei(v,w) jit_new_node_pww(jit_code_bgei,NULL,v,w)
|
||||
jit_code_bger, jit_code_bgei,
|
||||
#define jit_bger_u(v,w) jit_new_node_pww(jit_code_bger_u,NULL,v,w)
|
||||
#define jit_bgei_u(v,w) jit_new_node_pww(jit_code_bgei_u,NULL,v,w)
|
||||
jit_code_bger_u, jit_code_bgei_u,
|
||||
#define jit_bgtr(v,w) jit_new_node_pww(jit_code_bgtr,NULL,v,w)
|
||||
#define jit_bgti(v,w) jit_new_node_pww(jit_code_bgti,NULL,v,w)
|
||||
jit_code_bgtr, jit_code_bgti,
|
||||
#define jit_bgtr_u(v,w) jit_new_node_pww(jit_code_bgtr_u,NULL,v,w)
|
||||
#define jit_bgti_u(v,w) jit_new_node_pww(jit_code_bgti_u,NULL,v,w)
|
||||
jit_code_bgtr_u, jit_code_bgti_u,
|
||||
#define jit_bner(v,w) jit_new_node_pww(jit_code_bner,NULL,v,w)
|
||||
#define jit_bnei(v,w) jit_new_node_pww(jit_code_bnei,NULL,v,w)
|
||||
jit_code_bner, jit_code_bnei,
|
||||
|
||||
#define jit_bmsr(v,w) jit_new_node_pww(jit_code_bmsr,NULL,v,w)
|
||||
#define jit_bmsi(v,w) jit_new_node_pww(jit_code_bmsi,NULL,v,w)
|
||||
jit_code_bmsr, jit_code_bmsi,
|
||||
#define jit_bmcr(v,w) jit_new_node_pww(jit_code_bmcr,NULL,v,w)
|
||||
#define jit_bmci(v,w) jit_new_node_pww(jit_code_bmci,NULL,v,w)
|
||||
jit_code_bmcr, jit_code_bmci,
|
||||
|
||||
#define jit_boaddr(v,w) jit_new_node_pww(jit_code_boaddr,NULL,v,w)
|
||||
#define jit_boaddi(v,w) jit_new_node_pww(jit_code_boaddi,NULL,v,w)
|
||||
jit_code_boaddr, jit_code_boaddi,
|
||||
#define jit_boaddr_u(v,w) jit_new_node_pww(jit_code_boaddr_u,NULL,v,w)
|
||||
#define jit_boaddi_u(v,w) jit_new_node_pww(jit_code_boaddi_u,NULL,v,w)
|
||||
jit_code_boaddr_u, jit_code_boaddi_u,
|
||||
#define jit_bxaddr(v,w) jit_new_node_pww(jit_code_bxaddr,NULL,v,w)
|
||||
#define jit_bxaddi(v,w) jit_new_node_pww(jit_code_bxaddi,NULL,v,w)
|
||||
jit_code_bxaddr, jit_code_bxaddi,
|
||||
#define jit_bxaddr_u(v,w) jit_new_node_pww(jit_code_bxaddr_u,NULL,v,w)
|
||||
#define jit_bxaddi_u(v,w) jit_new_node_pww(jit_code_bxaddi_u,NULL,v,w)
|
||||
jit_code_bxaddr_u, jit_code_bxaddi_u,
|
||||
#define jit_bosubr(v,w) jit_new_node_pww(jit_code_bosubr,NULL,v,w)
|
||||
#define jit_bosubi(v,w) jit_new_node_pww(jit_code_bosubi,NULL,v,w)
|
||||
jit_code_bosubr, jit_code_bosubi,
|
||||
#define jit_bosubr_u(v,w) jit_new_node_pww(jit_code_bosubr_u,NULL,v,w)
|
||||
#define jit_bosubi_u(v,w) jit_new_node_pww(jit_code_bosubi_u,NULL,v,w)
|
||||
jit_code_bosubr_u, jit_code_bosubi_u,
|
||||
#define jit_bxsubr(v,w) jit_new_node_pww(jit_code_bxsubr,NULL,v,w)
|
||||
#define jit_bxsubi(v,w) jit_new_node_pww(jit_code_bxsubi,NULL,v,w)
|
||||
jit_code_bxsubr, jit_code_bxsubi,
|
||||
#define jit_bxsubr_u(v,w) jit_new_node_pww(jit_code_bxsubr_u,NULL,v,w)
|
||||
#define jit_bxsubi_u(v,w) jit_new_node_pww(jit_code_bxsubi_u,NULL,v,w)
|
||||
jit_code_bxsubr_u, jit_code_bxsubi_u,
|
||||
|
||||
#define jit_jmpr(u) jit_new_node_w(jit_code_jmpr,u)
|
||||
#define jit_jmpi() jit_new_node_p(jit_code_jmpi,NULL)
|
||||
jit_code_jmpr, jit_code_jmpi,
|
||||
#define jit_callr(u) jit_new_node_w(jit_code_callr,u)
|
||||
#define jit_calli(u) jit_new_node_p(jit_code_calli,u)
|
||||
jit_code_callr, jit_code_calli,
|
||||
|
||||
#define jit_prepare(u) _jit_prepare(_jit,u)
|
||||
#define jit_pushargr(u) _jit_pushargr(_jit,u)
|
||||
#define jit_pushargi(u) _jit_pushargi(_jit,u)
|
||||
#define jit_finishr(u) _jit_finishr(_jit,u)
|
||||
#define jit_finishi(u) _jit_finishi(_jit,u)
|
||||
#define jit_ret() _jit_ret(_jit)
|
||||
#define jit_retr(u) _jit_retr(_jit,u)
|
||||
#define jit_reti(u) _jit_reti(_jit,u)
|
||||
#define jit_retval_c(u) _jit_retval_c(_jit,u)
|
||||
#define jit_retval_uc(u) _jit_retval_uc(_jit,u)
|
||||
#define jit_retval_s(u) _jit_retval_s(_jit,u)
|
||||
#define jit_retval_us(u) _jit_retval_us(_jit,u)
|
||||
#define jit_retval_i(u) _jit_retval_i(_jit,u)
|
||||
/* >> 64 bit */
|
||||
#define jit_retval_ui(u) _jit_retval_ui(_jit,u)
|
||||
#define jit_retval_l(u) _jit_retval_l(_jit,u)
|
||||
/* << 64 bit */
|
||||
#if __WORDSIZE == 32
|
||||
# define jit_retval(u) jit_retval_i(u)
|
||||
#else
|
||||
# define jit_retval(u) jit_retval_l(u)
|
||||
#endif
|
||||
/* Usually should not need to call directly, but useful if need
|
||||
* to get a label just before a jit_prolog() call */
|
||||
#define jit_epilog() _jit_epilog(_jit)
|
||||
jit_code_epilog,
|
||||
|
||||
#define jit_arg_f() _jit_arg_f(_jit)
|
||||
#define jit_getarg_f(u,v) _jit_getarg_f(_jit,u,v)
|
||||
|
||||
#define jit_addr_f(u,v,w) jit_new_node_www(jit_code_addr_f,u,v,w)
|
||||
#define jit_addi_f(u,v,w) jit_new_node_wwf(jit_code_addi_f,u,v,w)
|
||||
jit_code_addr_f, jit_code_addi_f,
|
||||
#define jit_subr_f(u,v,w) jit_new_node_www(jit_code_subr_f,u,v,w)
|
||||
#define jit_subi_f(u,v,w) jit_new_node_wwf(jit_code_subi_f,u,v,w)
|
||||
jit_code_subr_f, jit_code_subi_f,
|
||||
#define jit_mulr_f(u,v,w) jit_new_node_www(jit_code_mulr_f,u,v,w)
|
||||
#define jit_muli_f(u,v,w) jit_new_node_wwf(jit_code_muli_f,u,v,w)
|
||||
jit_code_mulr_f, jit_code_muli_f,
|
||||
#define jit_divr_f(u,v,w) jit_new_node_www(jit_code_divr_f,u,v,w)
|
||||
#define jit_divi_f(u,v,w) jit_new_node_wwf(jit_code_divi_f,u,v,w)
|
||||
jit_code_divr_f, jit_code_divi_f,
|
||||
#define jit_negr_f(u,v) jit_new_node_ww(jit_code_negr_f,u,v)
|
||||
#define jit_absr_f(u,v) jit_new_node_ww(jit_code_absr_f,u,v)
|
||||
#define jit_sqrtr_f(u,v) jit_new_node_ww(jit_code_sqrtr_f,u,v)
|
||||
jit_code_negr_f, jit_code_absr_f, jit_code_sqrtr_f,
|
||||
|
||||
#define jit_ltr_f(u,v,w) jit_new_node_www(jit_code_ltr_f,u,v,w)
|
||||
#define jit_lti_f(u,v,w) jit_new_node_wwf(jit_code_lti_f,u,v,w)
|
||||
jit_code_ltr_f, jit_code_lti_f,
|
||||
#define jit_ler_f(u,v,w) jit_new_node_www(jit_code_ler_f,u,v,w)
|
||||
#define jit_lei_f(u,v,w) jit_new_node_wwf(jit_code_lei_f,u,v,w)
|
||||
jit_code_ler_f, jit_code_lei_f,
|
||||
#define jit_eqr_f(u,v,w) jit_new_node_www(jit_code_eqr_f,u,v,w)
|
||||
#define jit_eqi_f(u,v,w) jit_new_node_wwf(jit_code_eqi_f,u,v,w)
|
||||
jit_code_eqr_f, jit_code_eqi_f,
|
||||
#define jit_ger_f(u,v,w) jit_new_node_www(jit_code_ger_f,u,v,w)
|
||||
#define jit_gei_f(u,v,w) jit_new_node_wwf(jit_code_gei_f,u,v,w)
|
||||
jit_code_ger_f, jit_code_gei_f,
|
||||
#define jit_gtr_f(u,v,w) jit_new_node_www(jit_code_gtr_f,u,v,w)
|
||||
#define jit_gti_f(u,v,w) jit_new_node_wwf(jit_code_gti_f,u,v,w)
|
||||
jit_code_gtr_f, jit_code_gti_f,
|
||||
#define jit_ner_f(u,v,w) jit_new_node_www(jit_code_ner_f,u,v,w)
|
||||
#define jit_nei_f(u,v,w) jit_new_node_wwf(jit_code_nei_f,u,v,w)
|
||||
jit_code_ner_f, jit_code_nei_f,
|
||||
#define jit_unltr_f(u,v,w) jit_new_node_www(jit_code_unltr_f,u,v,w)
|
||||
#define jit_unlti_f(u,v,w) jit_new_node_wwf(jit_code_unlti_f,u,v,w)
|
||||
jit_code_unltr_f, jit_code_unlti_f,
|
||||
#define jit_unler_f(u,v,w) jit_new_node_www(jit_code_unler_f,u,v,w)
|
||||
#define jit_unlei_f(u,v,w) jit_new_node_wwf(jit_code_unlei_f,u,v,w)
|
||||
jit_code_unler_f, jit_code_unlei_f,
|
||||
#define jit_uneqr_f(u,v,w) jit_new_node_www(jit_code_uneqr_f,u,v,w)
|
||||
#define jit_uneqi_f(u,v,w) jit_new_node_wwf(jit_code_uneqi_f,u,v,w)
|
||||
jit_code_uneqr_f, jit_code_uneqi_f,
|
||||
#define jit_unger_f(u,v,w) jit_new_node_www(jit_code_unger_f,u,v,w)
|
||||
#define jit_ungei_f(u,v,w) jit_new_node_wwf(jit_code_ungei_f,u,v,w)
|
||||
jit_code_unger_f, jit_code_ungei_f,
|
||||
#define jit_ungtr_f(u,v,w) jit_new_node_www(jit_code_ungtr_f,u,v,w)
|
||||
#define jit_ungti_f(u,v,w) jit_new_node_wwf(jit_code_ungti_f,u,v,w)
|
||||
jit_code_ungtr_f, jit_code_ungti_f,
|
||||
#define jit_ltgtr_f(u,v,w) jit_new_node_www(jit_code_ltgtr_f,u,v,w)
|
||||
#define jit_ltgti_f(u,v,w) jit_new_node_wwf(jit_code_ltgti_f,u,v,w)
|
||||
jit_code_ltgtr_f, jit_code_ltgti_f,
|
||||
#define jit_ordr_f(u,v,w) jit_new_node_www(jit_code_ordr_f,u,v,w)
|
||||
#define jit_ordi_f(u,v,w) jit_new_node_wwf(jit_code_ordi_f,u,v,w)
|
||||
jit_code_ordr_f, jit_code_ordi_f,
|
||||
#define jit_unordr_f(u,v,w) jit_new_node_www(jit_code_unordr_f,u,v,w)
|
||||
#define jit_unordi_f(u,v,w) jit_new_node_wwf(jit_code_unordi_f,u,v,w)
|
||||
jit_code_unordr_f, jit_code_unordi_f,
|
||||
|
||||
#define jit_truncr_f_i(u,v) jit_new_node_ww(jit_code_truncr_f_i,u,v)
|
||||
jit_code_truncr_f_i,
|
||||
#if __WODSIZE == 32
|
||||
# define jit_truncr_f(u,v) jit_truncr_f_i(u,v)
|
||||
#else
|
||||
# define jit_truncr_f(u,v) jit_truncr_f_l(u,v)
|
||||
#endif
|
||||
/* >> 64 bit */
|
||||
#define jit_truncr_f_l(u,v) jit_new_node_ww(jit_code_truncr_f_l,u,v)
|
||||
jit_code_truncr_f_l,
|
||||
/* << 64 bit */
|
||||
#define jit_extr_f(u,v) jit_new_node_ww(jit_code_extr_f,u,v)
|
||||
#define jit_extr_d_f(u,v) jit_new_node_ww(jit_code_extr_d_f,u,v)
|
||||
jit_code_extr_f, jit_code_extr_d_f,
|
||||
#define jit_movr_f(u,v) jit_new_node_ww(jit_code_movr_f,u,v)
|
||||
#define jit_movi_f(u,v) jit_new_node_wf(jit_code_movi_f,u,v)
|
||||
jit_code_movr_f, jit_code_movi_f,
|
||||
|
||||
#define jit_ldr_f(u,v) jit_new_node_ww(jit_code_ldr_f,u,v)
|
||||
#define jit_ldi_f(u,v) jit_new_node_ww(jit_code_ldi_f,u,v)
|
||||
jit_code_ldr_f, jit_code_ldi_f,
|
||||
#define jit_ldxr_f(u,v,w) jit_new_node_www(jit_code_ldxr_f,u,v,w)
|
||||
#define jit_ldxi_f(u,v,w) jit_new_node_www(jit_code_ldxi_f,u,v,w)
|
||||
jit_code_ldxr_f, jit_code_ldxi_f,
|
||||
#define jit_str_f(u,v) jit_new_node_ww(jit_code_str_f,u,v)
|
||||
#define jit_sti_f(u,v) jit_new_node_ww(jit_code_sti_f,u,v)
|
||||
jit_code_str_f, jit_code_sti_f,
|
||||
#define jit_stxr_f(u,v,w) jit_new_node_www(jit_code_stxr_f,u,v,w)
|
||||
#define jit_stxi_f(u,v,w) jit_new_node_www(jit_code_stxi_f,u,v,w)
|
||||
jit_code_stxr_f, jit_code_stxi_f,
|
||||
|
||||
#define jit_bltr_f(v,w) jit_new_node_pww(jit_code_bltr_f,NULL,v,w)
|
||||
#define jit_blti_f(v,w) jit_new_node_pwf(jit_code_blti_f,NULL,v,w)
|
||||
jit_code_bltr_f, jit_code_blti_f,
|
||||
#define jit_bler_f(v,w) jit_new_node_pww(jit_code_bler_f,NULL,v,w)
|
||||
#define jit_blei_f(v,w) jit_new_node_pwf(jit_code_blei_f,NULL,v,w)
|
||||
jit_code_bler_f, jit_code_blei_f,
|
||||
#define jit_beqr_f(v,w) jit_new_node_pww(jit_code_beqr_f,NULL,v,w)
|
||||
#define jit_beqi_f(v,w) jit_new_node_pwf(jit_code_beqi_f,NULL,v,w)
|
||||
jit_code_beqr_f, jit_code_beqi_f,
|
||||
#define jit_bger_f(v,w) jit_new_node_pww(jit_code_bger_f,NULL,v,w)
|
||||
#define jit_bgei_f(v,w) jit_new_node_pwf(jit_code_bgei_f,NULL,v,w)
|
||||
jit_code_bger_f, jit_code_bgei_f,
|
||||
#define jit_bgtr_f(v,w) jit_new_node_pww(jit_code_bgtr_f,NULL,v,w)
|
||||
#define jit_bgti_f(v,w) jit_new_node_pwf(jit_code_bgti_f,NULL,v,w)
|
||||
jit_code_bgtr_f, jit_code_bgti_f,
|
||||
#define jit_bner_f(v,w) jit_new_node_pww(jit_code_bner_f,NULL,v,w)
|
||||
#define jit_bnei_f(v,w) jit_new_node_pwf(jit_code_bnei_f,NULL,v,w)
|
||||
jit_code_bner_f, jit_code_bnei_f,
|
||||
#define jit_bunltr_f(v,w) jit_new_node_pww(jit_code_bunltr_f,NULL,v,w)
|
||||
#define jit_bunlti_f(v,w) jit_new_node_pwf(jit_code_bunlti_f,NULL,v,w)
|
||||
jit_code_bunltr_f, jit_code_bunlti_f,
|
||||
#define jit_bunler_f(v,w) jit_new_node_pww(jit_code_bunler_f,NULL,v,w)
|
||||
#define jit_bunlei_f(v,w) jit_new_node_pwf(jit_code_bunlei_f,NULL,v,w)
|
||||
jit_code_bunler_f, jit_code_bunlei_f,
|
||||
#define jit_buneqr_f(v,w) jit_new_node_pww(jit_code_buneqr_f,NULL,v,w)
|
||||
#define jit_buneqi_f(v,w) jit_new_node_pwf(jit_code_buneqi_f,NULL,v,w)
|
||||
jit_code_buneqr_f, jit_code_buneqi_f,
|
||||
#define jit_bunger_f(v,w) jit_new_node_pww(jit_code_bunger_f,NULL,v,w)
|
||||
#define jit_bungei_f(v,w) jit_new_node_pwf(jit_code_bungei_f,NULL,v,w)
|
||||
jit_code_bunger_f, jit_code_bungei_f,
|
||||
#define jit_bungtr_f(v,w) jit_new_node_pww(jit_code_bungtr_f,NULL,v,w)
|
||||
#define jit_bungti_f(v,w) jit_new_node_pwf(jit_code_bungti_f,NULL,v,w)
|
||||
jit_code_bungtr_f, jit_code_bungti_f,
|
||||
#define jit_bltgtr_f(v,w) jit_new_node_pww(jit_code_bltgtr_f,NULL,v,w)
|
||||
#define jit_bltgti_f(v,w) jit_new_node_pwf(jit_code_bltgti_f,NULL,v,w)
|
||||
jit_code_bltgtr_f, jit_code_bltgti_f,
|
||||
#define jit_bordr_f(v,w) jit_new_node_pww(jit_code_bordr_f,NULL,v,w)
|
||||
#define jit_bordi_f(v,w) jit_new_node_pwf(jit_code_bordi_f,NULL,v,w)
|
||||
jit_code_bordr_f, jit_code_bordi_f,
|
||||
#define jit_bunordr_f(v,w) jit_new_node_pww(jit_code_bunordr_f,NULL,v,w)
|
||||
#define jit_bunordi_f(v,w) jit_new_node_pwf(jit_code_bunordi_f,NULL,v,w)
|
||||
jit_code_bunordr_f, jit_code_bunordi_f,
|
||||
|
||||
#define jit_pushargr_f(u) _jit_pushargr_f(_jit,u)
|
||||
#define jit_pushargi_f(u) _jit_pushargi_f(_jit,u)
|
||||
#define jit_retr_f(u) _jit_retr_f(_jit,u)
|
||||
#define jit_reti_f(u) _jit_reti_f(_jit,u)
|
||||
#define jit_retval_f(u) _jit_retval_f(_jit,u)
|
||||
jit_code_retval_f,
|
||||
|
||||
#define jit_arg_d() _jit_arg_d(_jit)
|
||||
#define jit_getarg_d(u,v) _jit_getarg_d(_jit,u,v)
|
||||
|
||||
#define jit_addr_d(u,v,w) jit_new_node_www(jit_code_addr_d,u,v,w)
|
||||
#define jit_addi_d(u,v,w) jit_new_node_wwd(jit_code_addi_d,u,v,w)
|
||||
jit_code_addr_d, jit_code_addi_d,
|
||||
#define jit_subr_d(u,v,w) jit_new_node_www(jit_code_subr_d,u,v,w)
|
||||
#define jit_subi_d(u,v,w) jit_new_node_wwd(jit_code_subi_d,u,v,w)
|
||||
jit_code_subr_d, jit_code_subi_d,
|
||||
#define jit_mulr_d(u,v,w) jit_new_node_www(jit_code_mulr_d,u,v,w)
|
||||
#define jit_muli_d(u,v,w) jit_new_node_wwd(jit_code_muli_d,u,v,w)
|
||||
jit_code_mulr_d, jit_code_muli_d,
|
||||
#define jit_divr_d(u,v,w) jit_new_node_www(jit_code_divr_d,u,v,w)
|
||||
#define jit_divi_d(u,v,w) jit_new_node_wwd(jit_code_divi_d,u,v,w)
|
||||
jit_code_divr_d, jit_code_divi_d,
|
||||
|
||||
#define jit_negr_d(u,v) jit_new_node_ww(jit_code_negr_d,u,v)
|
||||
#define jit_absr_d(u,v) jit_new_node_ww(jit_code_absr_d,u,v)
|
||||
#define jit_sqrtr_d(u,v) jit_new_node_ww(jit_code_sqrtr_d,u,v)
|
||||
jit_code_negr_d, jit_code_absr_d, jit_code_sqrtr_d,
|
||||
|
||||
#define jit_ltr_d(u,v,w) jit_new_node_www(jit_code_ltr_d,u,v,w)
|
||||
#define jit_lti_d(u,v,w) jit_new_node_wwd(jit_code_lti_d,u,v,w)
|
||||
jit_code_ltr_d, jit_code_lti_d,
|
||||
#define jit_ler_d(u,v,w) jit_new_node_www(jit_code_ler_d,u,v,w)
|
||||
#define jit_lei_d(u,v,w) jit_new_node_wwd(jit_code_lei_d,u,v,w)
|
||||
jit_code_ler_d, jit_code_lei_d,
|
||||
#define jit_eqr_d(u,v,w) jit_new_node_www(jit_code_eqr_d,u,v,w)
|
||||
#define jit_eqi_d(u,v,w) jit_new_node_wwd(jit_code_eqi_d,u,v,w)
|
||||
jit_code_eqr_d, jit_code_eqi_d,
|
||||
#define jit_ger_d(u,v,w) jit_new_node_www(jit_code_ger_d,u,v,w)
|
||||
#define jit_gei_d(u,v,w) jit_new_node_wwd(jit_code_gei_d,u,v,w)
|
||||
jit_code_ger_d, jit_code_gei_d,
|
||||
#define jit_gtr_d(u,v,w) jit_new_node_www(jit_code_gtr_d,u,v,w)
|
||||
#define jit_gti_d(u,v,w) jit_new_node_wwd(jit_code_gti_d,u,v,w)
|
||||
jit_code_gtr_d, jit_code_gti_d,
|
||||
#define jit_ner_d(u,v,w) jit_new_node_www(jit_code_ner_d,u,v,w)
|
||||
#define jit_nei_d(u,v,w) jit_new_node_wwd(jit_code_nei_d,u,v,w)
|
||||
jit_code_ner_d, jit_code_nei_d,
|
||||
#define jit_unltr_d(u,v,w) jit_new_node_www(jit_code_unltr_d,u,v,w)
|
||||
#define jit_unlti_d(u,v,w) jit_new_node_wwd(jit_code_unlti_d,u,v,w)
|
||||
jit_code_unltr_d, jit_code_unlti_d,
|
||||
#define jit_unler_d(u,v,w) jit_new_node_www(jit_code_unler_d,u,v,w)
|
||||
#define jit_unlei_d(u,v,w) jit_new_node_wwd(jit_code_unlei_d,u,v,w)
|
||||
jit_code_unler_d, jit_code_unlei_d,
|
||||
#define jit_uneqr_d(u,v,w) jit_new_node_www(jit_code_uneqr_d,u,v,w)
|
||||
#define jit_uneqi_d(u,v,w) jit_new_node_wwd(jit_code_uneqi_d,u,v,w)
|
||||
jit_code_uneqr_d, jit_code_uneqi_d,
|
||||
#define jit_unger_d(u,v,w) jit_new_node_www(jit_code_unger_d,u,v,w)
|
||||
#define jit_ungei_d(u,v,w) jit_new_node_wwd(jit_code_ungei_d,u,v,w)
|
||||
jit_code_unger_d, jit_code_ungei_d,
|
||||
#define jit_ungtr_d(u,v,w) jit_new_node_www(jit_code_ungtr_d,u,v,w)
|
||||
#define jit_ungti_d(u,v,w) jit_new_node_wwd(jit_code_ungti_d,u,v,w)
|
||||
jit_code_ungtr_d, jit_code_ungti_d,
|
||||
#define jit_ltgtr_d(u,v,w) jit_new_node_www(jit_code_ltgtr_d,u,v,w)
|
||||
#define jit_ltgti_d(u,v,w) jit_new_node_wwd(jit_code_ltgti_d,u,v,w)
|
||||
jit_code_ltgtr_d, jit_code_ltgti_d,
|
||||
#define jit_ordr_d(u,v,w) jit_new_node_www(jit_code_ordr_d,u,v,w)
|
||||
#define jit_ordi_d(u,v,w) jit_new_node_wwd(jit_code_ordi_d,u,v,w)
|
||||
jit_code_ordr_d, jit_code_ordi_d,
|
||||
#define jit_unordr_d(u,v,w) jit_new_node_www(jit_code_unordr_d,u,v,w)
|
||||
#define jit_unordi_d(u,v,w) jit_new_node_wwd(jit_code_unordi_d,u,v,w)
|
||||
jit_code_unordr_d, jit_code_unordi_d,
|
||||
|
||||
#define jit_truncr_d_i(u,v) jit_new_node_ww(jit_code_truncr_d_i,u,v)
|
||||
jit_code_truncr_d_i,
|
||||
#if __WODSIZE == 32
|
||||
# define jit_truncr_d(u,v) jit_truncr_d_i(u,v)
|
||||
#else
|
||||
# define jit_truncr_d(u,v) jit_truncr_d_l(u,v)
|
||||
#endif
|
||||
/* >> 64 bit */
|
||||
#define jit_truncr_d_l(u,v) jit_new_node_ww(jit_code_truncr_d_l,u,v)
|
||||
jit_code_truncr_d_l,
|
||||
/* << 64 bit */
|
||||
#define jit_extr_d(u,v) jit_new_node_ww(jit_code_extr_f,u,v)
|
||||
#define jit_extr_f_d(u,v) jit_new_node_ww(jit_code_extr_f_d,u,v)
|
||||
jit_code_extr_d, jit_code_extr_f_d,
|
||||
#define jit_movr_d(u,v) jit_new_node_ww(jit_code_movr_d,u,v)
|
||||
#define jit_movi_d(u,v) jit_new_node_wd(jit_code_movi_d,u,v)
|
||||
jit_code_movr_d, jit_code_movi_d,
|
||||
|
||||
#define jit_ldr_d(u,v) jit_new_node_ww(jit_code_ldr_d,u,v)
|
||||
#define jit_ldi_d(u,v) jit_new_node_ww(jit_code_ldi_d,u,v)
|
||||
jit_code_ldr_d, jit_code_ldi_d,
|
||||
#define jit_ldxr_d(u,v,w) jit_new_node_www(jit_code_ldxr_d,u,v,w)
|
||||
#define jit_ldxi_d(u,v,w) jit_new_node_www(jit_code_ldxi_d,u,v,w)
|
||||
jit_code_ldxr_d, jit_code_ldxi_d,
|
||||
#define jit_str_d(u,v) jit_new_node_ww(jit_code_str_d,u,v)
|
||||
#define jit_sti_d(u,v) jit_new_node_ww(jit_code_sti_d,u,v)
|
||||
jit_code_str_d, jit_code_sti_d,
|
||||
#define jit_stxr_d(u,v,w) jit_new_node_www(jit_code_stxr_d,u,v,w)
|
||||
#define jit_stxi_d(u,v,w) jit_new_node_www(jit_code_stxi_d,u,v,w)
|
||||
jit_code_stxr_d, jit_code_stxi_d,
|
||||
|
||||
#define jit_bltr_d(v,w) jit_new_node_pww(jit_code_bltr_d,NULL,v,w)
|
||||
#define jit_blti_d(v,w) jit_new_node_pwd(jit_code_blti_d,NULL,v,w)
|
||||
jit_code_bltr_d, jit_code_blti_d,
|
||||
#define jit_bler_d(v,w) jit_new_node_pww(jit_code_bler_d,NULL,v,w)
|
||||
#define jit_blei_d(v,w) jit_new_node_pwd(jit_code_blei_d,NULL,v,w)
|
||||
jit_code_bler_d, jit_code_blei_d,
|
||||
#define jit_beqr_d(v,w) jit_new_node_pww(jit_code_beqr_d,NULL,v,w)
|
||||
#define jit_beqi_d(v,w) jit_new_node_pwd(jit_code_beqi_d,NULL,v,w)
|
||||
jit_code_beqr_d, jit_code_beqi_d,
|
||||
#define jit_bger_d(v,w) jit_new_node_pww(jit_code_bger_d,NULL,v,w)
|
||||
#define jit_bgei_d(v,w) jit_new_node_pwd(jit_code_bgei_d,NULL,v,w)
|
||||
jit_code_bger_d, jit_code_bgei_d,
|
||||
#define jit_bgtr_d(v,w) jit_new_node_pww(jit_code_bgtr_d,NULL,v,w)
|
||||
#define jit_bgti_d(v,w) jit_new_node_pwd(jit_code_bgti_d,NULL,v,w)
|
||||
jit_code_bgtr_d, jit_code_bgti_d,
|
||||
#define jit_bner_d(v,w) jit_new_node_pww(jit_code_bner_d,NULL,v,w)
|
||||
#define jit_bnei_d(v,w) jit_new_node_pwd(jit_code_bnei_d,NULL,v,w)
|
||||
jit_code_bner_d, jit_code_bnei_d,
|
||||
#define jit_bunltr_d(v,w) jit_new_node_pww(jit_code_bunltr_d,NULL,v,w)
|
||||
#define jit_bunlti_d(v,w) jit_new_node_pwd(jit_code_bunlti_d,NULL,v,w)
|
||||
jit_code_bunltr_d, jit_code_bunlti_d,
|
||||
#define jit_bunler_d(v,w) jit_new_node_pww(jit_code_bunler_d,NULL,v,w)
|
||||
#define jit_bunlei_d(v,w) jit_new_node_pwd(jit_code_bunlei_d,NULL,v,w)
|
||||
jit_code_bunler_d, jit_code_bunlei_d,
|
||||
#define jit_buneqr_d(v,w) jit_new_node_pww(jit_code_buneqr_d,NULL,v,w)
|
||||
#define jit_buneqi_d(v,w) jit_new_node_pwd(jit_code_buneqi_d,NULL,v,w)
|
||||
jit_code_buneqr_d, jit_code_buneqi_d,
|
||||
#define jit_bunger_d(v,w) jit_new_node_pww(jit_code_bunger_d,NULL,v,w)
|
||||
#define jit_bungei_d(v,w) jit_new_node_pwd(jit_code_bungei_d,NULL,v,w)
|
||||
jit_code_bunger_d, jit_code_bungei_d,
|
||||
#define jit_bungtr_d(v,w) jit_new_node_pww(jit_code_bungtr_d,NULL,v,w)
|
||||
#define jit_bungti_d(v,w) jit_new_node_pwd(jit_code_bungti_d,NULL,v,w)
|
||||
jit_code_bungtr_d, jit_code_bungti_d,
|
||||
#define jit_bltgtr_d(v,w) jit_new_node_pww(jit_code_bltgtr_d,NULL,v,w)
|
||||
#define jit_bltgti_d(v,w) jit_new_node_pwd(jit_code_bltgti_d,NULL,v,w)
|
||||
jit_code_bltgtr_d, jit_code_bltgti_d,
|
||||
#define jit_bordr_d(v,w) jit_new_node_pww(jit_code_bordr_d,NULL,v,w)
|
||||
#define jit_bordi_d(v,w) jit_new_node_pwd(jit_code_bordi_d,NULL,v,w)
|
||||
jit_code_bordr_d, jit_code_bordi_d,
|
||||
#define jit_bunordr_d(v,w) jit_new_node_pww(jit_code_bunordr_d,NULL,v,w)
|
||||
#define jit_bunordi_d(v,w) jit_new_node_pwd(jit_code_bunordi_d,NULL,v,w)
|
||||
jit_code_bunordr_d, jit_code_bunordi_d,
|
||||
|
||||
#define jit_pushargr_d(u) _jit_pushargr_d(_jit,u)
|
||||
#define jit_pushargi_d(u) _jit_pushargi_d(_jit,u)
|
||||
#define jit_retr_d(u) _jit_retr_d(_jit,u)
|
||||
#define jit_reti_d(u) _jit_reti_d(_jit,u)
|
||||
#define jit_retval_d(u) _jit_retval_d(_jit,u)
|
||||
jit_code_retval_d,
|
||||
} jit_code_t;
|
||||
|
||||
/*
|
||||
* Prototypes
|
||||
*/
|
||||
extern void init_jit(void);
|
||||
extern void finish_jit(void);
|
||||
|
||||
extern jit_state_t *jit_new_state(void);
|
||||
|
||||
extern jit_node_t *_jit_data(jit_state_t*, jit_pointer_t, jit_word_t);
|
||||
extern jit_node_t *_jit_note(jit_state_t*, jit_pointer_t);
|
||||
|
||||
extern jit_node_t *_jit_label(jit_state_t*);
|
||||
extern jit_node_t *_jit_forward(jit_state_t*);
|
||||
extern void _jit_link(jit_state_t*, jit_node_t*);
|
||||
|
||||
extern void _jit_prolog(jit_state_t*);
|
||||
|
||||
extern jit_int32_t _jit_allocai(jit_state_t*, jit_int32_t);
|
||||
|
||||
extern jit_int32_t _jit_arg(jit_state_t*);
|
||||
extern void _jit_getarg_c(jit_state_t*, jit_gpr_t, jit_int32_t);
|
||||
extern void _jit_getarg_uc(jit_state_t*, jit_gpr_t, jit_int32_t);
|
||||
extern void _jit_getarg_s(jit_state_t*, jit_gpr_t, jit_int32_t);
|
||||
extern void _jit_getarg_us(jit_state_t*, jit_gpr_t, jit_int32_t);
|
||||
extern void _jit_getarg_i(jit_state_t*, jit_gpr_t, jit_int32_t);
|
||||
#if __WORDSIZE == 64
|
||||
extern void _jit_getarg_ui(jit_state_t*, jit_gpr_t, jit_int32_t);
|
||||
extern void _jit_getarg_l(jit_state_t*, jit_gpr_t, jit_int32_t);
|
||||
#endif
|
||||
|
||||
extern void _jit_prepare(jit_state_t*, jit_int32_t);
|
||||
extern void _jit_pushargr(jit_state_t*, jit_gpr_t);
|
||||
extern void _jit_pushargi(jit_state_t*, jit_word_t);
|
||||
extern void _jit_finishr(jit_state_t*, jit_gpr_t);
|
||||
extern jit_node_t *_jit_finishi(jit_state_t*, jit_pointer_t);
|
||||
extern void _jit_ret(jit_state_t*);
|
||||
extern void _jit_retr(jit_state_t*, jit_gpr_t);
|
||||
extern void _jit_reti(jit_state_t*, jit_word_t);
|
||||
extern void _jit_retval_c(jit_state_t*, jit_gpr_t);
|
||||
extern void _jit_retval_uc(jit_state_t*, jit_gpr_t);
|
||||
extern void _jit_retval_s(jit_state_t*, jit_gpr_t);
|
||||
extern void _jit_retval_us(jit_state_t*, jit_gpr_t);
|
||||
extern void _jit_retval_i(jit_state_t*, jit_gpr_t);
|
||||
#if __WORDSIZE == 64
|
||||
extern void _jit_retval_ui(jit_state_t*, jit_gpr_t);
|
||||
extern void _jit_retval_l(jit_state_t*, jit_gpr_t);
|
||||
#endif
|
||||
extern void _jit_epilog(jit_state_t*);
|
||||
|
||||
#define jit_patch(u) _jit_patch(_jit,u)
|
||||
extern void _jit_patch(jit_state_t*, jit_node_t*);
|
||||
#define jit_patch_at(u,v) _jit_patch_at(_jit,u,v)
|
||||
extern void _jit_patch_at(jit_state_t*, jit_node_t*, jit_node_t*);
|
||||
#define jit_patch_abs(u,v) _jit_patch_abs(_jit,u,v)
|
||||
extern void _jit_patch_abs(jit_state_t*, jit_node_t*, jit_pointer_t);
|
||||
#define jit_emit() _jit_emit(_jit)
|
||||
extern jit_pointer_t _jit_emit(jit_state_t*);
|
||||
|
||||
#define jit_print() _jit_print(_jit)
|
||||
extern void _jit_print(jit_state_t*);
|
||||
|
||||
extern jit_int32_t _jit_arg_f(jit_state_t*);
|
||||
extern void _jit_getarg_f(jit_state_t*, jit_fpr_t, jit_int32_t);
|
||||
|
||||
extern void _jit_pushargr_f(jit_state_t*, jit_fpr_t);
|
||||
extern void _jit_pushargi_f(jit_state_t*, jit_float32_t);
|
||||
extern void _jit_retr_f(jit_state_t*, jit_fpr_t);
|
||||
extern void _jit_reti_f(jit_state_t*, jit_float32_t);
|
||||
extern void _jit_retval_f(jit_state_t*, jit_fpr_t);
|
||||
|
||||
extern jit_int32_t _jit_arg_d(jit_state_t*);
|
||||
extern void _jit_getarg_d(jit_state_t*, jit_fpr_t, jit_int32_t);
|
||||
|
||||
extern void _jit_pushargr_d(jit_state_t*, jit_fpr_t);
|
||||
extern void _jit_pushargi_d(jit_state_t*, jit_float64_t);
|
||||
extern void _jit_retr_d(jit_state_t*, jit_fpr_t);
|
||||
extern void _jit_reti_d(jit_state_t*, jit_float64_t);
|
||||
extern void _jit_retval_d(jit_state_t*, jit_fpr_t);
|
||||
|
||||
#define jit_new_node(c) _jit_new_node(_jit,c)
|
||||
extern jit_node_t *_jit_new_node(jit_state_t*, jit_code_t);
|
||||
#define jit_new_node_w(c,u) _jit_new_node_w(_jit,c,u)
|
||||
extern jit_node_t *_jit_new_node_w(jit_state_t*, jit_code_t,
|
||||
jit_word_t);
|
||||
#define jit_new_node_p(c,u) _jit_new_node_p(_jit,c,u)
|
||||
extern jit_node_t *_jit_new_node_p(jit_state_t*, jit_code_t,
|
||||
jit_pointer_t);
|
||||
#define jit_new_node_ww(c,u,v) _jit_new_node_ww(_jit,c,u,v)
|
||||
extern jit_node_t *_jit_new_node_ww(jit_state_t*,jit_code_t,
|
||||
jit_word_t, jit_word_t);
|
||||
#define jit_new_node_wf(c,u,v) _jit_new_node_wf(_jit,c,u,v)
|
||||
extern jit_node_t *_jit_new_node_wf(jit_state_t*, jit_code_t,
|
||||
jit_word_t, jit_float32_t);
|
||||
#define jit_new_node_wd(c,u,v) _jit_new_node_wd(_jit,c,u,v)
|
||||
extern jit_node_t *_jit_new_node_wd(jit_state_t*, jit_code_t,
|
||||
jit_word_t, jit_float64_t);
|
||||
#define jit_new_node_www(c,u,v,w) _jit_new_node_www(_jit,c,u,v,w)
|
||||
extern jit_node_t *_jit_new_node_www(jit_state_t*, jit_code_t,
|
||||
jit_word_t, jit_word_t, jit_word_t);
|
||||
#define jit_new_node_wwf(c,u,v,w) _jit_new_node_wwf(_jit,c,u,v,w)
|
||||
extern jit_node_t *_jit_new_node_wwf(jit_state_t*, jit_code_t,
|
||||
jit_word_t, jit_word_t, jit_float32_t);
|
||||
#define jit_new_node_wwd(c,u,v,w) _jit_new_node_wwd(_jit,c,u,v,w)
|
||||
extern jit_node_t *_jit_new_node_wwd(jit_state_t*, jit_code_t,
|
||||
jit_word_t, jit_word_t, jit_float64_t);
|
||||
#define jit_new_node_pww(c,u,v,w) _jit_new_node_pww(_jit,c,u,v,w)
|
||||
extern jit_node_t *_jit_new_node_pww(jit_state_t*, jit_code_t,
|
||||
jit_pointer_t, jit_word_t, jit_word_t);
|
||||
#define jit_new_node_pwf(c,u,v,w) _jit_new_node_pwf(_jit,c,u,v,w)
|
||||
extern jit_node_t *_jit_new_node_pwf(jit_state_t*, jit_code_t,
|
||||
jit_pointer_t, jit_word_t, jit_float32_t);
|
||||
#define jit_new_node_pwd(c,u,v,w) _jit_new_node_pwd(_jit,c,u,v,w)
|
||||
extern jit_node_t *_jit_new_node_pwd(jit_state_t*, jit_code_t,
|
||||
jit_pointer_t, jit_word_t, jit_float64_t);
|
||||
|
||||
#define jit_disassemble() _jit_disassemble(_jit)
|
||||
extern void _jit_disassemble(jit_state_t*);
|
||||
|
||||
#endif /* _lightning_h */
|
||||
23
include/lightning/Makefile.am
Normal file
23
include/lightning/Makefile.am
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
#
|
||||
# Copyright 2000, 2001, 2002, 2012 Free Software Foundation, Inc.
|
||||
#
|
||||
# This is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This software 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 General Public License for more details.
|
||||
#
|
||||
|
||||
includedir = $(includedir)/lightning
|
||||
|
||||
EXTRA_DIST = \
|
||||
jit_private.h
|
||||
|
||||
if cpu_x86
|
||||
include_HEADERS = \
|
||||
jit_x86.h
|
||||
endif
|
||||
147
include/lightning/jit_arm.h
Normal file
147
include/lightning/jit_arm.h
Normal file
|
|
@ -0,0 +1,147 @@
|
|||
/*
|
||||
* Copyright (C) 2012 Free Software Foundation, Inc.
|
||||
*
|
||||
* This is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This software 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 General Public License for more details.
|
||||
*
|
||||
* Authors:
|
||||
* Paulo Cesar Pereira de Andrade
|
||||
*/
|
||||
|
||||
#ifndef _jit_arm_h
|
||||
#define _jit_arm_h
|
||||
|
||||
#define JIT_HASH_CONSTS 0
|
||||
#define JIT_NUM_OPERANDS 3
|
||||
|
||||
/*
|
||||
* Types
|
||||
*/
|
||||
#define jit_swf_p() (jit_cpu.vfp == 0)
|
||||
#define jit_hardfp_p() jit_cpu.abi
|
||||
|
||||
#define JIT_RET _R0
|
||||
#define JIT_SP _R13
|
||||
#define JIT_FP _R11
|
||||
typedef enum {
|
||||
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 4)
|
||||
#define jit_r(i) (_R4 + (i))
|
||||
#define jit_r_num() 3
|
||||
#define jit_v(i) (_R7 + (i))
|
||||
#define jit_v_num() 3
|
||||
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 4)
|
||||
#define jit_f(i) (jit_cpu.abi ? _D8 + (i) : _D7 + (i))
|
||||
#define jit_f_num() (jit_cpu.vfp ? 16 : 8)
|
||||
_R12, /* ip - temporary */
|
||||
#define JIT_R0 _R4
|
||||
#define JIT_R1 _R5
|
||||
#define JIT_R2 _R6
|
||||
_R4, /* r4 - variable */
|
||||
_R5, /* r5 - variable */
|
||||
_R6, /* r6 - variable */
|
||||
#define JIT_V0 _R7
|
||||
#define JIT_V1 _R8
|
||||
#define JIT_V2 _R9
|
||||
_R7, /* r7 - variable */
|
||||
_R8, /* r8 - variable */
|
||||
_R9, /* r9 - variable */
|
||||
_R10, /* sl - stack limit */
|
||||
_R11, /* fp - frame pointer */
|
||||
_R13, /* sp - stack pointer */
|
||||
_R14, /* lr - link register */
|
||||
_R15, /* pc - program counter */
|
||||
#define JIT_RA0 _R0
|
||||
#define JIT_RA1 _R1
|
||||
#define JIT_RA2 _R2
|
||||
#define JIT_RA3 _R3
|
||||
_R3, /* r3 - argument/result */
|
||||
_R2, /* r2 - argument/result */
|
||||
_R1, /* r1 - argument/result */
|
||||
_R0, /* r0 - argument/result */
|
||||
#if defined(__ARM_PCS_VFP)
|
||||
# define JIT_FRET _D0
|
||||
#else
|
||||
# define JIT_FRET _R0
|
||||
#endif
|
||||
#define JIT_F0 (jit_hardfp_p() ? _D8 : _D0)
|
||||
#define JIT_F1 (jit_hardfp_p() ? _D9 : _D1)
|
||||
#define JIT_F2 (jit_hardfp_p() ? _D10 : _D2)
|
||||
#define JIT_F3 (jit_hardfp_p() ? _D11 : _D3)
|
||||
#define JIT_F4 (jit_hardfp_p() ? _D12 : _D4)
|
||||
#define JIT_F5 (jit_hardfp_p() ? _D13 : _D5)
|
||||
#define JIT_F6 (jit_hardfp_p() ? _D14 : _D6)
|
||||
#define JIT_F7 (jit_hardfp_p() ? _D15 : _D7)
|
||||
_S16, _D8 = _S16, _Q4 = _D8,
|
||||
_S17,
|
||||
_S18, _D9 = _S18,
|
||||
_S19,
|
||||
_S20, _D10 = _S20, _Q5 = _D10,
|
||||
_S21,
|
||||
_S22, _D11 = _S22,
|
||||
_S23,
|
||||
_S24, _D12 = _S24, _Q6 = _D12,
|
||||
_S25,
|
||||
_S26, _D13 = _S26,
|
||||
_S27,
|
||||
_S28, _D14 = _S28, _Q7 = _D14,
|
||||
_S29,
|
||||
_S30, _D15 = _S30,
|
||||
_S31,
|
||||
#define JIT_FA0 _D0
|
||||
#define JIT_FA1 _D1
|
||||
#define JIT_FA2 _D2
|
||||
#define JIT_FA3 _D3
|
||||
#define JIT_FA4 _D4
|
||||
#define JIT_FA5 _D5
|
||||
#define JIT_FA6 _D6
|
||||
#define JIT_FA7 _D7
|
||||
_S15,
|
||||
_S14, _D7 = _S14,
|
||||
_S13,
|
||||
_S12, _D6 = _S12, _Q3 = _D6,
|
||||
_S11,
|
||||
_S10, _D5 = _S10,
|
||||
_S9,
|
||||
_S8, _D4 = _S8, _Q2 = _D4,
|
||||
_S7,
|
||||
_S6, _D3 = _S6,
|
||||
_S5,
|
||||
_S4, _D2 = _S4, _Q1 = _D2,
|
||||
_S3,
|
||||
_S2, _D1 = _S2,
|
||||
_S1,
|
||||
_S0, _D0 = _S0, _Q0 = _D0,
|
||||
_NOREG,
|
||||
#define JIT_NOREG _NOREG
|
||||
} jit_reg_t;
|
||||
|
||||
typedef struct {
|
||||
jit_uint32_t version : 4;
|
||||
jit_uint32_t extend : 1;
|
||||
/* only generate thumb instructions for thumb2 */
|
||||
jit_uint32_t thumb : 1;
|
||||
jit_uint32_t vfp : 3;
|
||||
jit_uint32_t neon : 1;
|
||||
jit_uint32_t abi : 2;
|
||||
} jit_cpu_t;
|
||||
|
||||
typedef struct {
|
||||
/* prevent using thumb instructions that set flags? */
|
||||
jit_uint32_t no_set_flags : 1;
|
||||
} jit_flags_t;
|
||||
|
||||
typedef jit_int64_t jit_regset_t;
|
||||
|
||||
/*
|
||||
* Initialization
|
||||
*/
|
||||
extern jit_cpu_t jit_cpu;
|
||||
|
||||
#endif /* _jit_arm_h */
|
||||
98
include/lightning/jit_mips.h
Normal file
98
include/lightning/jit_mips.h
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
/*
|
||||
* Copyright (C) 2012 Free Software Foundation, Inc.
|
||||
*
|
||||
* This is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This software 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 General Public License for more details.
|
||||
*
|
||||
* Authors:
|
||||
* Paulo Cesar Pereira de Andrade
|
||||
*/
|
||||
|
||||
#ifndef _jit_mips_h
|
||||
#define _jit_mips_h
|
||||
|
||||
#define JIT_HASH_CONSTS 1
|
||||
#define JIT_NUM_OPERANDS 3
|
||||
|
||||
/*
|
||||
* Types
|
||||
*/
|
||||
#define JIT_RET _V0
|
||||
#define JIT_FRET _F0
|
||||
#define JIT_SP _SP
|
||||
#define JIT_FP _FP
|
||||
typedef enum {
|
||||
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 4)
|
||||
#define jit_r(i) (_V0 + (i))
|
||||
#define jit_r_num() 12
|
||||
#define jit_v(i) (_S0 + (i))
|
||||
#define jit_r_num() 8
|
||||
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 4)
|
||||
#define jit_f(i) (_F0 + (i))
|
||||
#define jit_f_num() 14
|
||||
_AT,
|
||||
#define JIT_R0 _V0
|
||||
#define JIT_R1 _V1
|
||||
#define JIT_R2 _T0
|
||||
#define JIT_R3 _T1
|
||||
#define JIT_R4 _T2
|
||||
#define JIT_R5 _T3
|
||||
#define JIT_R6 _T4
|
||||
#define JIT_R7 _T5
|
||||
#define JIT_R8 _T6
|
||||
#define JIT_R9 _T7
|
||||
#define JIT_R10 _T8
|
||||
#define JIT_R11 _T9 /* must point to PIC function */
|
||||
_V0, _V1, _T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9,
|
||||
#define JIT_V0 _S0
|
||||
#define JIT_V1 _S1
|
||||
#define JIT_V2 _S2
|
||||
#define JIT_V3 _S3
|
||||
#define JIT_V4 _S4
|
||||
#define JIT_V5 _S5
|
||||
#define JIT_V6 _S6
|
||||
#define JIT_V7 _S7
|
||||
_S0, _S1, _S2, _S3, _S4, _S5, _S6, _S7,
|
||||
_ZERO, _K0, _K1, _RA,
|
||||
_GP, /* FIXME use to point to jit data */
|
||||
_SP, _FP,
|
||||
# define JIT_RA0 _A0
|
||||
# define JIT_RA1 _A1
|
||||
# define JIT_RA2 _A2
|
||||
# define JIT_RA3 _A3
|
||||
_A3, _A2, _A1, _A0,
|
||||
|
||||
#define JIT_F0 _F0
|
||||
#define JIT_F1 _F2
|
||||
#define JIT_F2 _F4
|
||||
#define JIT_F3 _F6
|
||||
#define JIT_F4 _F8
|
||||
#define JIT_F5 _F10
|
||||
_F0, _F2, _F4, _F6, _F8, _F10,
|
||||
/* callee save float registers */
|
||||
#define JIT_FS0 _F16
|
||||
#define JIT_FS1 _F18
|
||||
#define JIT_FS2 _F20
|
||||
#define JIT_FS3 _F22
|
||||
#define JIT_FS4 _F24
|
||||
#define JIT_FS5 _F26
|
||||
#define JIT_FS6 _F28
|
||||
#define JIT_FS7 _F30
|
||||
_F16, _F18, _F20, _F22, _F24, _F26, _F28, _F30,
|
||||
#define JIT_FA0 _F12
|
||||
#define JIT_FA1 _F14
|
||||
_F12, _F14,
|
||||
#define JIT_NOREG _NOREG
|
||||
_NOREG,
|
||||
} jit_reg_t;
|
||||
|
||||
typedef jit_int64_t jit_regset_t;
|
||||
|
||||
#endif /* _jit_mips_h */
|
||||
120
include/lightning/jit_ppc.h
Normal file
120
include/lightning/jit_ppc.h
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
/*
|
||||
* Copyright (C) 2012 Free Software Foundation, Inc.
|
||||
*
|
||||
* This is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This software 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 General Public License for more details.
|
||||
*
|
||||
* Authors:
|
||||
* Paulo Cesar Pereira de Andrade
|
||||
*/
|
||||
|
||||
#ifndef _jit_ppc_h
|
||||
#define _jit_ppc_h
|
||||
|
||||
#define JIT_HASH_CONSTS 1
|
||||
#define JIT_NUM_OPERANDS 3
|
||||
|
||||
/*
|
||||
* Types
|
||||
*/
|
||||
typedef enum {
|
||||
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 8)
|
||||
#define jit_r(i) (_R11 + (i))
|
||||
#define jit_r_num() 3
|
||||
#define jit_v(i) (_R30 - (i))
|
||||
#define jit_r_num() 17
|
||||
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 8)
|
||||
#define jit_f(i) (_F0 + (i))
|
||||
#define jit_f_num() 6
|
||||
_R0,
|
||||
#define JIT_R0 _R11
|
||||
#define JIT_R1 _R12
|
||||
#define JIT_R2 _R13
|
||||
#define JIT_R3 _R2
|
||||
_R11, _R12, _R13, _R2,
|
||||
#define JIT_V0 _R30
|
||||
#define JIT_V1 _R29
|
||||
#define JIT_V2 _R28
|
||||
#define JIT_V3 _R28
|
||||
#define JIT_V4 _R26
|
||||
#define JIT_V5 _R25
|
||||
#define JIT_V6 _R24
|
||||
#define JIT_V7 _R23
|
||||
#define JIT_V8 _R22
|
||||
#define JIT_V9 _R21
|
||||
#define JIT_V10 _R20
|
||||
#define JIT_V11 _R19
|
||||
#define JIT_V12 _R18
|
||||
#define JIT_V13 _R17
|
||||
#define JIT_V14 _R16
|
||||
#define JIT_V15 _R15
|
||||
#define JIT_V16 _R14
|
||||
_R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21,
|
||||
_R22, _R23, _R24, _R25, _R26, _R27, _R28, _R29,
|
||||
_R30,
|
||||
#define JIT_SP _R1
|
||||
_R1,
|
||||
#define JIT_FP _R31
|
||||
_R31,
|
||||
#define JIT_RET _R3
|
||||
#define JIT_RA0 _R3
|
||||
#define JIT_RA1 _R4
|
||||
#define JIT_RA2 _R5
|
||||
#define JIT_RA3 _R6
|
||||
#define JIT_RA4 _R7
|
||||
#define JIT_RA5 _R8
|
||||
#define JIT_RA6 _R9
|
||||
#define JIT_RA7 _R10
|
||||
_R10, _R9, _R8, _R7, _R6, _R5, _R4, _R3,
|
||||
# define JIT_F0 _F0
|
||||
# define JIT_F1 _F8
|
||||
# define JIT_F2 _F9
|
||||
# define JIT_F3 _F10
|
||||
# define JIT_F4 _F11
|
||||
# define JIT_F5 _F12
|
||||
_F0, _F9, _F10, _F11, _F12, _F13,
|
||||
#define JIT_FS0 _F14
|
||||
#define JIT_FS1 _F15
|
||||
#define JIT_FS2 _F16
|
||||
#define JIT_FS3 _F17
|
||||
#define JIT_FS4 _F18
|
||||
#define JIT_FS5 _F19
|
||||
#define JIT_FS6 _F20
|
||||
#define JIT_FS7 _F21
|
||||
#define JIT_FS8 _F22
|
||||
#define JIT_FS9 _F23
|
||||
#define JIT_FS10 _F24
|
||||
#define JIT_FS11 _F25
|
||||
#define JIT_FS12 _F26
|
||||
#define JIT_FS13 _F27
|
||||
#define JIT_FS14 _F28
|
||||
#define JIT_FS15 _F29
|
||||
#define JIT_FS16 _F30
|
||||
#define JIT_FS17 _F31
|
||||
_F14, _F15, _F16, _F17, _F18, _F19, _F20,
|
||||
_F21, _F22, _F23, _F24, _F25, _F26, _F27,
|
||||
_F28, _F29, _F30, _F31,
|
||||
#define JIT_FRET _F1
|
||||
#define JIT_FA0 _F1
|
||||
#define JIT_FA1 _F2
|
||||
#define JIT_FA2 _F3
|
||||
#define JIT_FA3 _F4
|
||||
#define JIT_FA4 _F5
|
||||
#define JIT_FA5 _F6
|
||||
#define JIT_FA6 _F7
|
||||
#define JIT_FA7 _F8
|
||||
_F8, _F7, _F6, _F5, _F4, _F3, _F2, _F1,
|
||||
_NOREG,
|
||||
#define JIT_NOREG _NOREG
|
||||
} jit_reg_t;
|
||||
|
||||
typedef jit_int64_t jit_regset_t;
|
||||
|
||||
#endif /* _jit_ppc_h */
|
||||
363
include/lightning/jit_private.h
Normal file
363
include/lightning/jit_private.h
Normal file
|
|
@ -0,0 +1,363 @@
|
|||
/*
|
||||
* Copyright (C) 2012 Free Software Foundation, Inc.
|
||||
*
|
||||
* This is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This software 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 General Public License for more details.
|
||||
*
|
||||
* Authors:
|
||||
* Paulo Cesar Pereira de Andrade
|
||||
*/
|
||||
|
||||
#ifndef _jit_private_h
|
||||
#define _jit_private_h
|
||||
|
||||
#include <assert.h>
|
||||
#include <limits.h>
|
||||
#include <stdio.h>
|
||||
#include <gmp.h>
|
||||
|
||||
#if defined(__GNUC__)
|
||||
# define maybe_unused __attribute__ ((unused))
|
||||
# define unlikely(exprn) __builtin_expect(!!(exprn), 0)
|
||||
# define likely(exprn) __builtin_expect(!!(exprn), 1)
|
||||
# if (__GNUC__ >= 4)
|
||||
# define PUBLIC __attribute__ ((visibility("default")))
|
||||
# define HIDDEN __attribute__ ((visibility("hidden")))
|
||||
# else
|
||||
# define PUBLIC /**/
|
||||
# define HIDDEN /**/
|
||||
# endif
|
||||
#else
|
||||
# define maybe_unused /**/
|
||||
# define unlikely(exprn) exprn
|
||||
# define likely(exprn) exprn
|
||||
# define PUBLIC /**/
|
||||
# define HIDDEN /**/
|
||||
#endif
|
||||
|
||||
#define jit_size(vector) (sizeof(vector) / sizeof((vector)[0]))
|
||||
|
||||
/*
|
||||
* Private jit_class bitmasks
|
||||
*/
|
||||
#define jit_class_nospill 0x00800000 /* hint to fail if need spill */
|
||||
#define jit_class_sft 0x01000000 /* not a hardware register */
|
||||
#define jit_class_rg8 0x04000000 /* x86 8 bits */
|
||||
#define jit_class_xpr 0x80000000 /* float / vector */
|
||||
#define jit_regno_patch 0x00008000 /* this is a register
|
||||
* returned by a "user" call
|
||||
* to jit_get_reg() */
|
||||
|
||||
#define jit_kind_register 1
|
||||
#define jit_kind_code 2
|
||||
#define jit_kind_word 3
|
||||
#define jit_kind_float32 4
|
||||
#define jit_kind_float64 5
|
||||
|
||||
#define jit_cc_a0_reg 0x00000001 /* arg0 is a register */
|
||||
#define jit_cc_a0_chg 0x00000002 /* arg0 is modified */
|
||||
#define jit_cc_a0_jmp 0x00000004 /* arg0 is a jump target */
|
||||
#define jit_cc_a0_int 0x00000010 /* arg0 is immediate word */
|
||||
#define jit_cc_a0_flt 0x00000020 /* arg0 is immediate float */
|
||||
#define jit_cc_a0_dbl 0x00000040 /* arg0 is immediate double */
|
||||
#define jit_cc_a1_reg 0x00000100 /* arg1 is a register */
|
||||
#define jit_cc_a1_chg 0x00000200 /* arg1 is modified */
|
||||
#define jit_cc_a1_int 0x00001000 /* arg1 is immediate word */
|
||||
#define jit_cc_a1_flt 0x00002000 /* arg1 is immediate float */
|
||||
#define jit_cc_a1_dbl 0x00004000 /* arg1 is immediate double */
|
||||
#define jit_cc_a2_reg 0x00010000 /* arg2 is a register */
|
||||
#define jit_cc_a2_chg 0x00020000 /* arg2 is modified */
|
||||
#define jit_cc_a2_int 0x00100000 /* arg2 is immediate word */
|
||||
#define jit_cc_a2_flt 0x00200000 /* arg2 is immediate float */
|
||||
#define jit_cc_a2_dbl 0x00400000 /* arg2 is immediate double */
|
||||
|
||||
#define jit_regset_com(u, v) ((u) = ~(v))
|
||||
#define jit_regset_and(u, v, w) ((u) = (v) & (w))
|
||||
#define jit_regset_ior(u, v, w) ((u) = (v) | (w))
|
||||
#define jit_regset_xor(u, v, w) ((u) = (v) ^ (w))
|
||||
#define jit_regset_set(u, v) ((u) = (v))
|
||||
#define jit_regset_cmp_ui(u, v) ((u) != (v))
|
||||
#define jit_regset_set_ui(u, v) ((u) = (v))
|
||||
#define jit_regset_set_p(set) (set)
|
||||
#if DEBUG
|
||||
# define jit_regset_clrbit(set, bit) \
|
||||
(assert(bit >= 0 && bit < (sizeof(jit_regset_t) << 3)), \
|
||||
(set) &= ~(1LL << (bit)))
|
||||
# define jit_regset_setbit(set, bit) \
|
||||
(assert(bit >= 0 && bit < (sizeof(jit_regset_t) << 3)), \
|
||||
(set) |= 1LL << (bit))
|
||||
# define jit_regset_tstbit(set, bit) \
|
||||
(assert(bit >= 0 && bit < (sizeof(jit_regset_t) << 3)), \
|
||||
(set) & (1LL << (bit)))
|
||||
#else
|
||||
# define jit_regset_clrbit(set, bit) ((set) &= ~(1LL << (bit)))
|
||||
# define jit_regset_setbit(set, bit) ((set) |= 1LL << (bit))
|
||||
# define jit_regset_tstbit(set, bit) ((set) & (1LL << (bit)))
|
||||
#endif
|
||||
#define jit_regset_new(set) ((set) = 0)
|
||||
#define jit_regset_del(set) ((set) = 0)
|
||||
extern unsigned long
|
||||
jit_regset_scan1(jit_regset_t, jit_int32_t);
|
||||
|
||||
#define jit_reglive_setup() \
|
||||
do { \
|
||||
jit_regset_set_ui(_jit->reglive, 0); \
|
||||
jit_regset_set_ui(_jit->regmask, 0); \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Types
|
||||
*/
|
||||
typedef union jit_data jit_data_t;
|
||||
typedef struct jit_block jit_block_t;
|
||||
typedef struct jit_value jit_value_t;
|
||||
typedef struct jit_function jit_function_t;
|
||||
typedef struct jit_register jit_register_t;
|
||||
#if __arm__
|
||||
# if DISASSEMBLER
|
||||
typedef struct jit_data_info jit_data_info_t;
|
||||
# endif
|
||||
#endif
|
||||
|
||||
union jit_data {
|
||||
struct {
|
||||
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
||||
jit_int32_t l;
|
||||
jit_int32_t h;
|
||||
#else
|
||||
jit_int32_t h;
|
||||
jit_int32_t l;
|
||||
#endif
|
||||
} pair;
|
||||
jit_word_t w;
|
||||
jit_float32_t f;
|
||||
jit_float64_t d;
|
||||
jit_pointer_t p;
|
||||
jit_node_t *n;
|
||||
};
|
||||
|
||||
struct jit_node {
|
||||
jit_node_t *next;
|
||||
jit_code_t code;
|
||||
jit_int32_t flag;
|
||||
jit_data_t u;
|
||||
jit_data_t v;
|
||||
jit_data_t w;
|
||||
jit_node_t *link;
|
||||
};
|
||||
|
||||
struct jit_block {
|
||||
jit_node_t *label;
|
||||
jit_regset_t reglive;
|
||||
jit_regset_t regmask;
|
||||
};
|
||||
|
||||
struct jit_value {
|
||||
jit_int32_t kind;
|
||||
jit_code_t code;
|
||||
jit_data_t base;
|
||||
jit_data_t disp;
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
jit_word_t inst;
|
||||
jit_node_t *node;
|
||||
} jit_patch_t;
|
||||
|
||||
#if __arm__ && DISASSEMBLER
|
||||
struct jit_data_info {
|
||||
jit_uword_t code; /* pointer in code buffer */
|
||||
jit_word_t length; /* length of constant vector */
|
||||
};
|
||||
#endif
|
||||
|
||||
struct jit_function {
|
||||
struct {
|
||||
jit_int32_t argi;
|
||||
jit_int32_t argf;
|
||||
jit_int32_t size;
|
||||
jit_int32_t aoff;
|
||||
jit_int32_t alen;
|
||||
} self;
|
||||
struct {
|
||||
jit_int32_t argi;
|
||||
jit_int32_t argf;
|
||||
jit_int32_t size;
|
||||
jit_int32_t kind;
|
||||
} call;
|
||||
jit_node_t *prolog;
|
||||
jit_node_t *epilog;
|
||||
jit_int32_t *regoff;
|
||||
jit_regset_t regset;
|
||||
jit_int32_t stack;
|
||||
};
|
||||
|
||||
struct jit_state {
|
||||
union {
|
||||
jit_uint8_t *uc;
|
||||
jit_uint16_t *us;
|
||||
jit_uint32_t *ui;
|
||||
jit_uint64_t *ul;
|
||||
jit_word_t w;
|
||||
} pc;
|
||||
jit_node_t *head;
|
||||
jit_node_t *tail;
|
||||
jit_uint32_t emit : 1; /* emit state entered */
|
||||
jit_uint32_t again : 1; /* start over emiting function */
|
||||
jit_int32_t reglen; /* number of registers */
|
||||
jit_regset_t regarg; /* cannot allocate */
|
||||
jit_regset_t regsav; /* automatic spill only once */
|
||||
jit_regset_t reglive; /* known live registers at some point */
|
||||
jit_regset_t regmask; /* register mask to update reglive */
|
||||
mpz_t blockmask; /* mask of visited basic blocks */
|
||||
struct {
|
||||
jit_uint8_t *ptr;
|
||||
jit_word_t length;
|
||||
} code;
|
||||
struct {
|
||||
jit_uint8_t *ptr; /* constant pool */
|
||||
jit_node_t **table; /* very simple hash table */
|
||||
jit_word_t size; /* number of vectors in table */
|
||||
jit_word_t count; /* number of hash table entries */
|
||||
jit_word_t offset; /* offset in bytes in ptr */
|
||||
jit_word_t length; /* length in bytes of ptr */
|
||||
} data;
|
||||
jit_node_t **spill;
|
||||
jit_int32_t *gen; /* ssa like "register version" */
|
||||
jit_value_t *values; /* temporary jit_value_t vector */
|
||||
struct {
|
||||
jit_block_t *ptr;
|
||||
jit_word_t offset;
|
||||
jit_word_t length;
|
||||
} blocks; /* basic blocks */
|
||||
struct {
|
||||
jit_patch_t *ptr;
|
||||
jit_word_t offset;
|
||||
jit_word_t length;
|
||||
} patches; /* forward patch information */
|
||||
jit_function_t *function; /* current function */
|
||||
struct {
|
||||
jit_function_t *ptr;
|
||||
jit_word_t offset;
|
||||
jit_word_t length;
|
||||
} functions; /* prolog/epilogue offsets in code */
|
||||
struct {
|
||||
jit_node_t **ptr;
|
||||
jit_word_t offset;
|
||||
jit_word_t length;
|
||||
} pool;
|
||||
jit_node_t *list;
|
||||
#if __arm__
|
||||
# if DISASSEMBLER
|
||||
struct {
|
||||
jit_data_info_t *ptr;
|
||||
it_word_t offset;
|
||||
jit_word_t length;
|
||||
} data_info; /* constant pools information */
|
||||
# endif
|
||||
struct {
|
||||
jit_uint8_t *data; /* pointer to code */
|
||||
jit_word_t size; /* size data */
|
||||
jit_word_t offset; /* pending patches */
|
||||
jit_word_t length; /* number of pending constants */
|
||||
jit_int32_t values[1024]; /* pending constants */
|
||||
jit_word_t patches[2048];
|
||||
} consts;
|
||||
#endif
|
||||
};
|
||||
|
||||
struct jit_register {
|
||||
jit_reg_t spec;
|
||||
char *name;
|
||||
};
|
||||
|
||||
/*
|
||||
* Prototypes
|
||||
*/
|
||||
extern void jit_get_cpu(void);
|
||||
|
||||
#define jit_init() _jit_init(_jit)
|
||||
extern void _jit_init(jit_state_t*);
|
||||
|
||||
#define jit_new_node_no_link(u) _jit_new_node_no_link(_jit, u)
|
||||
extern jit_node_t *_jit_new_node_no_link(jit_state_t*, jit_code_t);
|
||||
|
||||
#define jit_link_node(u) _jit_link_node(_jit, u)
|
||||
extern void _jit_link_node(jit_state_t*, jit_node_t*);
|
||||
|
||||
#define jit_link_label(l) _jit_link_label(_jit,l)
|
||||
extern void
|
||||
_jit_link_label(jit_state_t*,jit_node_t*);
|
||||
|
||||
#define jit_reglive(node) _jit_reglive(_jit, node)
|
||||
extern void
|
||||
_jit_reglive(jit_state_t*, jit_node_t*);
|
||||
|
||||
#define jit_regarg_set(n,v) _jit_regarg_set(_jit,n,v)
|
||||
extern void
|
||||
_jit_regarg_set(jit_state_t*, jit_node_t*, jit_int32_t);
|
||||
|
||||
#define jit_regarg_clr(n,v) _jit_regarg_clr(_jit,n,v)
|
||||
extern void
|
||||
_jit_regarg_clr(jit_state_t*, jit_node_t*, jit_int32_t);
|
||||
|
||||
#define jit_get_reg(s) _jit_get_reg(_jit,s)
|
||||
extern jit_int32_t
|
||||
_jit_get_reg(jit_state_t*, jit_int32_t);
|
||||
|
||||
#define jit_unget_reg(r) _jit_unget_reg(_jit,r)
|
||||
extern void
|
||||
_jit_unget_reg(jit_state_t*, jit_int32_t);
|
||||
|
||||
#define jit_save(reg) _jit_save(_jit, reg)
|
||||
extern void
|
||||
_jit_save(jit_state_t*, jit_int32_t);
|
||||
|
||||
#define jit_load(reg) _jit_load(_jit, reg)
|
||||
extern void
|
||||
_jit_load(jit_state_t*, jit_int32_t);
|
||||
|
||||
#define jit_optimize() _jit_optimize(_jit)
|
||||
extern void
|
||||
_jit_optimize(jit_state_t*);
|
||||
|
||||
#define jit_classify(code) _jit_classify(_jit, code)
|
||||
extern jit_int32_t
|
||||
_jit_classify(jit_state_t*, jit_code_t);
|
||||
|
||||
#define jit_regarg_p(n, r) _jit_regarg_p(_jit, n, r)
|
||||
extern jit_bool_t
|
||||
_jit_regarg_p(jit_state_t*, jit_node_t*, jit_int32_t);
|
||||
|
||||
#define emit_ldxi(r0, r1, i0) _emit_ldxi(_jit, r0, r1, i0)
|
||||
extern void
|
||||
_emit_ldxi(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
|
||||
|
||||
#define emit_stxi(i0, r0, r1) _emit_stxi(_jit, i0, r0, r1)
|
||||
extern void
|
||||
_emit_stxi(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
|
||||
|
||||
#define emit_ldxi_d(r0, r1, i0) _emit_ldxi_d(_jit, r0, r1, i0)
|
||||
extern void
|
||||
_emit_ldxi_d(jit_state_t*, jit_int32_t, jit_int32_t, jit_word_t);
|
||||
|
||||
#define emit_stxi_d(i0, r0, r1) _emit_stxi(_jit, i0, r0, r1)
|
||||
extern void
|
||||
_emit_stxi_d(jit_state_t*, jit_word_t, jit_int32_t, jit_int32_t);
|
||||
|
||||
extern void jit_init_debug();
|
||||
extern void jit_finish_debug();
|
||||
|
||||
/*
|
||||
* Externs
|
||||
*/
|
||||
extern jit_register_t _rvs[];
|
||||
|
||||
#endif /* _jit_private_h */
|
||||
166
include/lightning/jit_x86.h
Normal file
166
include/lightning/jit_x86.h
Normal file
|
|
@ -0,0 +1,166 @@
|
|||
/*
|
||||
* Copyright (C) 2012 Free Software Foundation, Inc.
|
||||
*
|
||||
* This is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This software 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 General Public License for more details.
|
||||
*
|
||||
* Authors:
|
||||
* Paulo Cesar Pereira de Andrade
|
||||
*/
|
||||
|
||||
#ifndef _jit_x86_h
|
||||
#define _jit_x86_h
|
||||
|
||||
#define JIT_HASH_CONSTS 1
|
||||
#define JIT_NUM_OPERANDS 2
|
||||
|
||||
/*
|
||||
* Types
|
||||
*/
|
||||
#define jit_sse2_p() jit_cpu.sse2
|
||||
#define jit_x87_reg_p(reg) ((reg) >= _ST0 && (reg) <= _ST7)
|
||||
|
||||
#define JIT_RET _RAX
|
||||
#define JIT_SP _RSP
|
||||
#define JIT_FP _RBP
|
||||
typedef enum {
|
||||
#if __WORDSIZE == 32
|
||||
# define jit_arg_reg_p(i) 0
|
||||
# define jit_r(i) (_RAX + (i))
|
||||
# define jit_r_num() 3
|
||||
# define jit_v(i) (_RBX + (i))
|
||||
# define jit_v_num() 3
|
||||
# define jit_arg_reg_p(i) 0
|
||||
# define jit_f(i) (jit_cpu.sse2 ? _XMM0 + (i) : _ST0 + (i))
|
||||
# define jit_f_num() (jit_cpu.sse2 ? 8 : 6)
|
||||
# define JIT_FRET _ST0
|
||||
# define JIT_R0 _RAX
|
||||
# define JIT_R1 _RCX
|
||||
# define JIT_R2 _RDX
|
||||
_RAX, _RCX, _RDX,
|
||||
# define JIT_V0 _RBX
|
||||
# define JIT_V1 _RSI
|
||||
# define JIT_V2 _RDI
|
||||
_RBX, _RSI, _RDI,
|
||||
_RSP, _RBP,
|
||||
# define JIT_F0 (jit_sse2_p() ? _XMM0 : _ST0)
|
||||
# define JIT_F1 (jit_sse2_p() ? _XMM1 : _ST1)
|
||||
# define JIT_F2 (jit_sse2_p() ? _XMM2 : _ST2)
|
||||
# define JIT_F3 (jit_sse2_p() ? _XMM3 : _ST3)
|
||||
# define JIT_F4 (jit_sse2_p() ? _XMM4 : _ST4)
|
||||
# define JIT_F5 (jit_sse2_p() ? _XMM5 : _ST5)
|
||||
# define JIT_F6 (jit_sse2_p() ? _XMM6 : _ST6)
|
||||
# define JIT_F7 (jit_sse2_p() ? _XMM7 : _ST7)
|
||||
_XMM0, _XMM1, _XMM2, _XMM3, _XMM4, _XMM5, _XMM6, _XMM7,
|
||||
# define jit_sse_reg_p(reg) ((reg) >= _XMM0 && (reg) <= _XMM7)
|
||||
#else
|
||||
# define jit_arg_reg_p(i) ((i) >= 0 && (i) < 6)
|
||||
# define jit_r(i) (_RAX + (i))
|
||||
# define jit_r_num() 4
|
||||
# define jit_v(i) (_RBX + (i))
|
||||
# define jit_v_num() 4
|
||||
# define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 8)
|
||||
# define jit_f(index) (_XMM0 + (index))
|
||||
# define jit_f_num() 8
|
||||
# define JIT_FRET _XMM0
|
||||
# define JIT_R0 _RAX
|
||||
# define JIT_R1 _R10
|
||||
# define JIT_R2 _R11
|
||||
# define JIT_R3 _R12
|
||||
_RAX, _R10, _R11, _R12,
|
||||
# define JIT_V0 _RBX
|
||||
# define JIT_V1 _R13
|
||||
# define JIT_V2 _R14
|
||||
# define JIT_V3 _R15
|
||||
_RBX, _R13, _R14, _R15,
|
||||
# define JIT_RA0 _RDI
|
||||
# define JIT_RA1 _RSI
|
||||
# define JIT_RA2 _RDX
|
||||
# define JIT_RA3 _RCX
|
||||
# define JIT_RA4 _R8
|
||||
# define JIT_RA5 _R9
|
||||
_R9, _R8, _RCX, _RDX, _RSI, _RDI,
|
||||
_RSP, _RBP,
|
||||
# define JIT_F0 _XMM8
|
||||
# define JIT_F1 _XMM9
|
||||
# define JIT_F2 _XMM10
|
||||
# define JIT_F3 _XMM11
|
||||
# define JIT_F4 _XMM12
|
||||
# define JIT_F5 _XMM13
|
||||
# define JIT_F6 _XMM14
|
||||
# define JIT_F7 _XMM15
|
||||
_XMM8, _XMM9, _XMM10, _XMM11, _XMM12, _XMM13, _XMM14, _XMM15,
|
||||
# define JIT_FA0 _XMM0
|
||||
# define JIT_FA1 _XMM1
|
||||
# define JIT_FA2 _XMM2
|
||||
# define JIT_FA3 _XMM3
|
||||
# define JIT_FA4 _XMM4
|
||||
# define JIT_FA5 _XMM5
|
||||
# define JIT_FA6 _XMM6
|
||||
# define JIT_FA7 _XMM7
|
||||
_XMM7, _XMM6, _XMM5, _XMM4, _XMM3, _XMM2, _XMM1, _XMM0,
|
||||
# define jit_sse_reg_p(reg) ((reg) >= _XMM8 && (reg) <= _XMM0)
|
||||
#endif
|
||||
_ST0, _ST1, _ST2, _ST3, _ST4, _ST5, _ST6, _ST7,
|
||||
# define JIT_NOREG _NOREG
|
||||
_NOREG,
|
||||
} jit_reg_t;
|
||||
|
||||
typedef struct {
|
||||
/* x87 present */
|
||||
jit_uint32_t fpu : 1;
|
||||
/* cmpxchg8b instruction */
|
||||
jit_uint32_t cmpxchg8b : 1;
|
||||
/* cmov and fcmov branchless conditional mov */
|
||||
jit_uint32_t cmov : 1;
|
||||
/* mmx registers/instructions available */
|
||||
jit_uint32_t mmx : 1;
|
||||
/* sse registers/instructions available */
|
||||
jit_uint32_t sse : 1;
|
||||
/* sse2 registers/instructions available */
|
||||
jit_uint32_t sse2 : 1;
|
||||
/* sse3 instructions available */
|
||||
jit_uint32_t sse3 : 1;
|
||||
/* pcmulqdq instruction */
|
||||
jit_uint32_t pclmulqdq : 1;
|
||||
/* ssse3 suplemental sse3 instructions available */
|
||||
jit_uint32_t ssse3 : 1;
|
||||
/* fused multiply/add using ymm state */
|
||||
jit_uint32_t fma : 1;
|
||||
/* cmpxchg16b instruction */
|
||||
jit_uint32_t cmpxchg16b : 1;
|
||||
/* sse4.1 instructions available */
|
||||
jit_uint32_t sse4_1 : 1;
|
||||
/* sse4.2 instructions available */
|
||||
jit_uint32_t sse4_2 : 1;
|
||||
/* movbe instruction available */
|
||||
jit_uint32_t movbe : 1;
|
||||
/* popcnt instruction available */
|
||||
jit_uint32_t popcnt : 1;
|
||||
/* aes instructions available */
|
||||
jit_uint32_t aes : 1;
|
||||
/* avx instructions available */
|
||||
jit_uint32_t avx : 1;
|
||||
/* lahf/sahf available in 64 bits mode */
|
||||
jit_uint32_t lahf : 1;
|
||||
} jit_cpu_t;
|
||||
|
||||
#if __WORDSIZE == 32
|
||||
typedef jit_int32_t jit_regset_t;
|
||||
#else
|
||||
typedef jit_int64_t jit_regset_t;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Initialization
|
||||
*/
|
||||
extern jit_cpu_t jit_cpu;
|
||||
|
||||
#endif /* _jit_x86_h */
|
||||
Loading…
Add table
Add a link
Reference in a new issue