mirror/guile
mirror/guile
1
Fork 0
mirror of https://git.savannah.gnu.org/git/guile.git synced 2025-05-18 18:40:22 +02:00
Code Activity

Rename include to jit.h, move all files to jit/

Browse source 
This change is in anticipation of making this lightning fork into an
include-only library.
This commit is contained in:
Andy Wingo 2018-10-30 12:16:35 +01:00
parent a5263b6618
commit 796ec6c16d
65 changed files with 49 additions and 127 deletions
Download patch file Download diff file Expand all files Collapse all files

79
jit/Makefile.am Normal file
View file

@ -0,0 +1,79 @@
#
# Copyright 2000, 2001, 2002, 2012-2017 Free Software Foundation, Inc.
#
# This file is part of GNU lightning.
#
# GNU lightning 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 3, or (at your option)
# any later version.
#
# GNU lightning 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.
#
AM_CFLAGS = -I$(top_srcdir)/include -D_GNU_SOURCE $(LIGHTNING_CFLAGS)
liblightning_LTLIBRARIES = liblightning.la
liblightning_la_LDFLAGS = -version-info 1:0:0
if get_jit_size
JIT_SIZE_PATH = "$(top_builddir)/jit_$(cpu)-sz.c"
AM_CPPFLAGS=-DGET_JIT_SIZE=1 -DJIT_SIZE_PATH='$(JIT_SIZE_PATH)'
endif
liblightningdir = $(libdir)
liblightning_la_SOURCES = \
jit_disasm.c \
jit_memory.c \
jit_names.c \
jit_note.c \
jit_print.c \
jit_size.c \
lightning.c
EXTRA_DIST = \
jit_rewind.c \
jit_aarch64.c \
jit_aarch64-cpu.c \
jit_aarch64-fpu.c \
jit_aarch64-sz.c \
jit_alpha.c \
jit_alpha-cpu.c \
jit_alpha-fpu.c \
jit_alpha-sz.c \
jit_arm.c \
jit_arm-cpu.c \
jit_arm-swf.c \
jit_arm-vfp.c \
jit_arm-sz.c \
jit_hppa.c \
jit_hppa-cpu.c \
jit_hppa-fpu.c \
jit_hppa-sz.c \
jit_ia64.c \
jit_ia64-cpu.c \
jit_ia64-fpu.c \
jit_ia64-sz.c \
jit_mips.c \
jit_mips-cpu.c \
jit_mips-fpu.c \
jit_mips-sz.c \
jit_ppc.c \
jit_ppc-cpu.c \
jit_ppc-fpu.c \
jit_ppc-sz.c \
jit_s390.c \
jit_s390-cpu.c \
jit_s390-fpu.c \
jit_s390-sz.c \
jit_sparc.c \
jit_sparc-cpu.c \
jit_sparc-fpu.c \
jit_sparc-sz.c \
jit_x86.c \
jit_x86-cpu.c \
jit_x86-sse.c \
jit_x86-x87.c \
jit_x86-sz.c

2446
jit/jit_aarch64-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

914
jit/jit_aarch64-fpu.c Normal file
View file

@ -0,0 +1,914 @@
/*
* Copyright (C) 2013-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#if PROTO
# define A64_SCVTF 0x1e220000
# define A64_FMOVWV 0x1e260000
# define A64_FMOVVW 0x1e270000
# define A64_FMOVXV 0x9e260000
# define A64_FMOVVX 0x9e270000
# define A64_FCVTZS 0x1e380000
# define A64_FCMPE 0x1e202010
# define A64_FMOV 0x1e204000
# define A64_FABS 0x1e20c000
# define A64_FNEG 0x1e214000
# define A64_FSQRT 0x1e21c000
# define A64_FCVTS 0x1e224000
# define A64_FCVTD 0x1e22c000
# define A64_FMUL 0x1e200800
# define A64_FDIV 0x1e201800
# define A64_FADD 0x1e202800
# define A64_FSUB 0x1e203800
# define FCMPES(Rn,Rm) os_vv(A64_FCMPE,0,Rn,Rm)
# define FCMPED(Rn,Rm) os_vv(A64_FCMPE,1,Rn,Rm)
# define FMOVS(Rd,Rn) osvv_(A64_FMOV,0,Rd,Rn)
# define FMOVD(Rd,Rn) osvv_(A64_FMOV,1,Rd,Rn)
# define FMOVWS(Rd,Rn) osvv_(A64_FMOVWV,0,Rd,Rn)
# define FMOVSW(Rd,Rn) osvv_(A64_FMOVVW,0,Rd,Rn)
# define FMOVXD(Rd,Rn) osvv_(A64_FMOVXV,1,Rd,Rn)
# define FMOVDX(Rd,Rn) osvv_(A64_FMOVVX,1,Rd,Rn)
# define FCVT_SD(Rd,Rn) osvv_(A64_FCVTS,1,Rd,Rn)
# define FCVT_DS(Rd,Rn) osvv_(A64_FCVTD,0,Rd,Rn)
# define SCVTFS(Rd,Rn) osvv_(A64_SCVTF|XS,0,Rd,Rn)
# define SCVTFD(Rd,Rn) osvv_(A64_SCVTF|XS,1,Rd,Rn)
# define FCVTSZ_WS(Rd,Rn) osvv_(A64_FCVTZS,0,Rd,Rn)
# define FCVTSZ_WD(Rd,Rn) osvv_(A64_FCVTZS,1,Rd,Rn)
# define FCVTSZ_XS(Rd,Rn) osvv_(A64_FCVTZS|XS,0,Rd,Rn)
# define FCVTSZ_XD(Rd,Rn) osvv_(A64_FCVTZS|XS,1,Rd,Rn)
# define FABSS(Rd,Rn) osvv_(A64_FABS,0,Rd,Rn)
# define FABSD(Rd,Rn) osvv_(A64_FABS,1,Rd,Rn)
# define FNEGS(Rd,Rn) osvv_(A64_FNEG,0,Rd,Rn)
# define FNEGD(Rd,Rn) osvv_(A64_FNEG,1,Rd,Rn)
# define FSQRTS(Rd,Rn) osvv_(A64_FSQRT,0,Rd,Rn)
# define FSQRTD(Rd,Rn) osvv_(A64_FSQRT,1,Rd,Rn)
# define FADDS(Rd,Rn,Rm) osvvv(A64_FADD,0,Rd,Rn,Rm)
# define FADDD(Rd,Rn,Rm) osvvv(A64_FADD,1,Rd,Rn,Rm)
# define FSUBS(Rd,Rn,Rm) osvvv(A64_FSUB,0,Rd,Rn,Rm)
# define FSUBD(Rd,Rn,Rm) osvvv(A64_FSUB,1,Rd,Rn,Rm)
# define FMULS(Rd,Rn,Rm) osvvv(A64_FMUL,0,Rd,Rn,Rm)
# define FMULD(Rd,Rn,Rm) osvvv(A64_FMUL,1,Rd,Rn,Rm)
# define FDIVS(Rd,Rn,Rm) osvvv(A64_FDIV,0,Rd,Rn,Rm)
# define FDIVD(Rd,Rn,Rm) osvvv(A64_FDIV,1,Rd,Rn,Rm)
# define osvvv(Op,Sz,Rd,Rn,Rm) _osvvv(_jit,Op,Sz,Rd,Rn,Rm)
static void _osvvv(jit_state_t*,jit_int32_t,jit_int32_t,
jit_int32_t,jit_int32_t,jit_int32_t);
# define osvv_(Op,Sz,Rd,Rn) _osvv_(_jit,Op,Sz,Rd,Rn)
static void _osvv_(jit_state_t*,jit_int32_t,
jit_int32_t,jit_int32_t,jit_int32_t);
# define os_vv(Op,Sz,Rn,Rm) _os_vv(_jit,Op,Sz,Rn,Rm)
static void _os_vv(jit_state_t*,jit_int32_t,
jit_int32_t,jit_int32_t,jit_int32_t);
# define truncr_f_i(r0,r1) _truncr_f_i(_jit,r0,r1)
static void _truncr_f_i(jit_state_t*,jit_int32_t,jit_int32_t);
# define truncr_f_l(r0,r1) FCVTSZ_XS(r0,r1)
# define truncr_d_i(r0,r1) _truncr_d_i(_jit,r0,r1)
static void _truncr_d_i(jit_state_t*,jit_int32_t,jit_int32_t);
# define truncr_d_l(r0,r1) FCVTSZ_XD(r0,r1)
# define addr_f(r0,r1,r2) FADDS(r0,r1,r2)
# define addi_f(r0,r1,i0) _addi_f(_jit,r0,r1,i0)
static void _addi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
# define subr_f(r0,r1,r2) FSUBS(r0,r1,r2)
# define subi_f(r0,r1,i0) _subi_f(_jit,r0,r1,i0)
static void _subi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
# define rsbr_f(r0, r1, r2) subr_f(r0, r2, r1)
# define rsbi_f(r0, r1, i0) _rsbi_f(_jit, r0, r1, i0)
static void _rsbi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
# define mulr_f(r0,r1,r2) FMULS(r0,r1,r2)
# define muli_f(r0,r1,i0) _muli_f(_jit,r0,r1,i0)
static void _muli_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
# define divr_f(r0,r1,r2) FDIVS(r0,r1,r2)
# define divi_f(r0,r1,i0) _divi_f(_jit,r0,r1,i0)
static void _divi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
# define absr_f(r0,r1) FABSS(r0,r1)
# define negr_f(r0,r1) FNEGS(r0,r1)
# define sqrtr_f(r0,r1) FSQRTS(r0,r1)
# define extr_f(r0,r1) SCVTFS(r0,r1)
# define ldr_f(r0,r1) _ldr_f(_jit,r0,r1)
static void _ldr_f(jit_state_t*,jit_int32_t,jit_int32_t);
# define ldi_f(r0,i0) _ldi_f(_jit,r0,i0)
static void _ldi_f(jit_state_t*,jit_int32_t,jit_word_t);
# define ldxr_f(r0,r1,r2) _ldxr_f(_jit,r0,r1,r2)
static void _ldxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define ldxi_f(r0,r1,i0) _ldxi_f(_jit,r0,r1,i0)
static void _ldxi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
# define str_f(r0,r1) _str_f(_jit,r0,r1)
static void _str_f(jit_state_t*,jit_int32_t,jit_int32_t);
# define sti_f(i0,r0) _sti_f(_jit,i0,r0)
static void _sti_f(jit_state_t*,jit_word_t,jit_int32_t);
# define stxr_f(r0,r1,r2) _stxr_f(_jit,r0,r1,r2)
static void _stxr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define stxi_f(i0,r0,r1) _stxi_f(_jit,i0,r0,r1)
static void _stxi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
# define movr_f(r0,r1) _movr_f(_jit,r0,r1)
static void _movr_f(jit_state_t*,jit_int32_t,jit_int32_t);
# define movi_f(r0,i0) _movi_f(_jit,r0,i0)
static void _movi_f(jit_state_t*,jit_int32_t,jit_float32_t);
# define extr_d_f(r0,r1) FCVT_SD(r0,r1)
# define fccr(cc,r0,r1,r2) _fccr(_jit,cc,r0,r1,r2)
static void _fccr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
# define fcci(cc,r0,r1,i0) _fcci(_jit,cc,r0,r1,i0)
static void _fcci(jit_state_t*,
jit_int32_t,jit_int32_t,jit_int32_t,jit_float32_t);
# define ltr_f(r0,r1,r2) fccr(CC_MI,r0,r1,r2)
# define lti_f(r0,r1,i0) fcci(CC_MI,r0,r1,i0)
# define ler_f(r0,r1,r2) fccr(CC_LS,r0,r1,r2)
# define lei_f(r0,r1,i0) fcci(CC_LS,r0,r1,i0)
# define eqr_f(r0,r1,r2) fccr(CC_EQ,r0,r1,r2)
# define eqi_f(r0,r1,i0) fcci(CC_EQ,r0,r1,i0)
# define ger_f(r0,r1,r2) fccr(CC_GE,r0,r1,r2)
# define gei_f(r0,r1,i0) fcci(CC_GE,r0,r1,i0)
# define gtr_f(r0,r1,r2) fccr(CC_GT,r0,r1,r2)
# define gti_f(r0,r1,i0) fcci(CC_GT,r0,r1,i0)
# define ner_f(r0,r1,r2) fccr(CC_NE,r0,r1,r2)
# define nei_f(r0,r1,i0) fcci(CC_NE,r0,r1,i0)
# define unltr_f(r0,r1,r2) fccr(CC_LT,r0,r1,r2)
# define unlti_f(r0,r1,i0) fcci(CC_LT,r0,r1,i0)
# define unler_f(r0,r1,r2) fccr(CC_LE,r0,r1,r2)
# define unlei_f(r0,r1,i0) fcci(CC_LE,r0,r1,i0)
# define uneqr_f(r0,r1,r2) _uneqr_f(_jit,r0,r1,r2)
static void _uneqr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define uneqi_f(r0,r1,i0) _uneqi_f(_jit,r0,r1,i0)
static void _uneqi_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
# define unger_f(r0,r1,r2) fccr(CC_PL,r0,r1,r2)
# define ungei_f(r0,r1,i0) fcci(CC_PL,r0,r1,i0)
# define ungtr_f(r0,r1,r2) fccr(CC_HI,r0,r1,r2)
# define ungti_f(r0,r1,i0) fcci(CC_HI,r0,r1,i0)
# define ltgtr_f(r0,r1,r2) _ltgtr_f(_jit,r0,r1,r2)
static void _ltgtr_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define ltgti_f(r0,r1,i0) _ltgti_f(_jit,r0,r1,i0)
static void _ltgti_f(jit_state_t*,jit_int32_t,jit_int32_t,jit_float32_t);
# define ordr_f(r0,r1,r2) fccr(CC_VC,r0,r1,r2)
# define ordi_f(r0,r1,i0) fcci(CC_VC,r0,r1,i0)
# define unordr_f(r0,r1,r2) fccr(CC_VS,r0,r1,r2)
# define unordi_f(r0,r1,i0) fcci(CC_VS,r0,r1,i0)
#define fbccr(cc,i0,r0,r1) _fbccr(_jit,cc,i0,r0,r1)
static jit_word_t
_fbccr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
#define fbcci(cc,i0,r0,i1) _fbcci(_jit,cc,i0,r0,i1)
static jit_word_t
_fbcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float32_t);
# define bltr_f(i0,r0,r1) fbccr(BCC_MI,i0,r0,r1)
# define blti_f(i0,r0,i1) fbcci(BCC_MI,i0,r0,i1)
# define bler_f(i0,r0,r1) fbccr(BCC_LS,i0,r0,r1)
# define blei_f(i0,r0,i1) fbcci(BCC_LS,i0,r0,i1)
# define beqr_f(i0,r0,r1) fbccr(BCC_EQ,i0,r0,r1)
# define beqi_f(i0,r0,i1) fbcci(BCC_EQ,i0,r0,i1)
# define bger_f(i0,r0,r1) fbccr(BCC_GE,i0,r0,r1)
# define bgei_f(i0,r0,i1) fbcci(BCC_GE,i0,r0,i1)
# define bgtr_f(i0,r0,r1) fbccr(BCC_GT,i0,r0,r1)
# define bgti_f(i0,r0,i1) fbcci(BCC_GT,i0,r0,i1)
# define bner_f(i0,r0,r1) fbccr(BCC_NE,i0,r0,r1)
# define bnei_f(i0,r0,i1) fbcci(BCC_NE,i0,r0,i1)
# define bunltr_f(i0,r0,r1) fbccr(BCC_LT,i0,r0,r1)
# define bunlti_f(i0,r0,i1) fbcci(BCC_LT,i0,r0,i1)
# define bunler_f(i0,r0,r1) fbccr(BCC_LE,i0,r0,r1)
# define bunlei_f(i0,r0,i1) fbcci(BCC_LE,i0,r0,i1)
# define buneqr_f(i0,r0,r1) _buneqr_f(_jit,i0,r0,r1)
static jit_word_t _buneqr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
# define buneqi_f(i0,r0,i1) _buneqi_f(_jit,i0,r0,i1)
static jit_word_t _buneqi_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
# define bunger_f(i0,r0,r1) fbccr(BCC_PL,i0,r0,r1)
# define bungei_f(i0,r0,i1) fbcci(BCC_PL,i0,r0,i1)
# define bungtr_f(i0,r0,r1) fbccr(BCC_HI,i0,r0,r1)
# define bungti_f(i0,r0,i1) fbcci(BCC_HI,i0,r0,i1)
# define bltgtr_f(i0,r0,r1) _bltgtr_f(_jit,i0,r0,r1)
static jit_word_t _bltgtr_f(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
# define bltgti_f(i0,r0,i1) _bltgti_f(_jit,i0,r0,i1)
static jit_word_t _bltgti_f(jit_state_t*,jit_word_t,jit_int32_t,jit_float32_t);
# define bordr_f(i0,r0,r1) fbccr(BCC_VC,i0,r0,r1)
# define bordi_f(i0,r0,i1) fbcci(BCC_VC,i0,r0,i1)
# define bunordr_f(i0,r0,r1) fbccr(BCC_VS,i0,r0,r1)
# define bunordi_f(i0,r0,i1) fbcci(BCC_VS,i0,r0,i1)
# define addr_d(r0,r1,r2) FADDD(r0,r1,r2)
# define addi_d(r0,r1,i0) _addi_d(_jit,r0,r1,i0)
static void _addi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
# define subr_d(r0,r1,r2) FSUBD(r0,r1,r2)
# define subi_d(r0,r1,i0) _subi_d(_jit,r0,r1,i0)
static void _subi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
# define rsbr_d(r0, r1, r2) subr_d(r0, r2, r1)
# define rsbi_d(r0, r1, i0) _rsbi_d(_jit, r0, r1, i0)
static void _rsbi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
# define mulr_d(r0,r1,r2) FMULD(r0,r1,r2)
# define muli_d(r0,r1,i0) _muli_d(_jit,r0,r1,i0)
static void _muli_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
# define divr_d(r0,r1,r2) FDIVD(r0,r1,r2)
# define divi_d(r0,r1,i0) _divi_d(_jit,r0,r1,i0)
static void _divi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
# define absr_d(r0,r1) FABSD(r0,r1)
# define negr_d(r0,r1) FNEGD(r0,r1)
# define sqrtr_d(r0,r1) FSQRTD(r0,r1)
# define extr_d(r0,r1) SCVTFD(r0,r1)
# define ldr_d(r0,r1) _ldr_d(_jit,r0,r1)
static void _ldr_d(jit_state_t*,jit_int32_t,jit_int32_t);
# define ldi_d(r0,i0) _ldi_d(_jit,r0,i0)
static void _ldi_d(jit_state_t*,jit_int32_t,jit_word_t);
# define ldxr_d(r0,r1,r2) _ldxr_d(_jit,r0,r1,r2)
static void _ldxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define ldxi_d(r0,r1,i0) _ldxi_d(_jit,r0,r1,i0)
static void _ldxi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_word_t);
# define str_d(r0,r1) _str_d(_jit,r0,r1)
static void _str_d(jit_state_t*,jit_int32_t,jit_int32_t);
# define sti_d(i0,r0) _sti_d(_jit,i0,r0)
static void _sti_d(jit_state_t*,jit_word_t,jit_int32_t);
# define stxr_d(r0,r1,r2) _stxr_d(_jit,r0,r1,r2)
static void _stxr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define stxi_d(i0,r0,r1) _stxi_d(_jit,i0,r0,r1)
static void _stxi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
# define movr_d(r0,r1) _movr_d(_jit,r0,r1)
static void _movr_d(jit_state_t*,jit_int32_t,jit_int32_t);
# define movi_d(r0,i0) _movi_d(_jit,r0,i0)
static void _movi_d(jit_state_t*,jit_int32_t,jit_float64_t);
# define extr_f_d(r0,r1) FCVT_DS(r0,r1)
# define dccr(cc,r0,r1,r2) _dccr(_jit,cc,r0,r1,r2)
static void _dccr(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t,jit_int32_t);
# define dcci(cc,r0,r1,i0) _dcci(_jit,cc,r0,r1,i0)
static void _dcci(jit_state_t*,
jit_int32_t,jit_int32_t,jit_int32_t,jit_float64_t);
# define ltr_d(r0,r1,r2) dccr(CC_MI,r0,r1,r2)
# define lti_d(r0,r1,i0) dcci(CC_MI,r0,r1,i0)
# define ler_d(r0,r1,r2) dccr(CC_LS,r0,r1,r2)
# define lei_d(r0,r1,i0) dcci(CC_LS,r0,r1,i0)
# define eqr_d(r0,r1,r2) dccr(CC_EQ,r0,r1,r2)
# define eqi_d(r0,r1,i0) dcci(CC_EQ,r0,r1,i0)
# define ger_d(r0,r1,r2) dccr(CC_GE,r0,r1,r2)
# define gei_d(r0,r1,i0) dcci(CC_GE,r0,r1,i0)
# define gtr_d(r0,r1,r2) dccr(CC_GT,r0,r1,r2)
# define gti_d(r0,r1,i0) dcci(CC_GT,r0,r1,i0)
# define ner_d(r0,r1,r2) dccr(CC_NE,r0,r1,r2)
# define nei_d(r0,r1,i0) dcci(CC_NE,r0,r1,i0)
# define unltr_d(r0,r1,r2) dccr(CC_LT,r0,r1,r2)
# define unlti_d(r0,r1,i0) dcci(CC_LT,r0,r1,i0)
# define unler_d(r0,r1,r2) dccr(CC_LE,r0,r1,r2)
# define unlei_d(r0,r1,i0) dcci(CC_LE,r0,r1,i0)
# define uneqr_d(r0,r1,r2) _uneqr_d(_jit,r0,r1,r2)
static void _uneqr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define uneqi_d(r0,r1,i0) _uneqi_d(_jit,r0,r1,i0)
static void _uneqi_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
# define unger_d(r0,r1,r2) dccr(CC_PL,r0,r1,r2)
# define ungei_d(r0,r1,i0) dcci(CC_PL,r0,r1,i0)
# define ungtr_d(r0,r1,r2) dccr(CC_HI,r0,r1,r2)
# define ungti_d(r0,r1,i0) dcci(CC_HI,r0,r1,i0)
# define ltgtr_d(r0,r1,r2) _ltgtr_d(_jit,r0,r1,r2)
static void _ltgtr_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_int32_t);
# define ltgti_d(r0,r1,i0) _ltgti_d(_jit,r0,r1,i0)
static void _ltgti_d(jit_state_t*,jit_int32_t,jit_int32_t,jit_float64_t);
# define ordr_d(r0,r1,r2) dccr(CC_VC,r0,r1,r2)
# define ordi_d(r0,r1,i0) dcci(CC_VC,r0,r1,i0)
# define unordr_d(r0,r1,r2) dccr(CC_VS,r0,r1,r2)
# define unordi_d(r0,r1,i0) dcci(CC_VS,r0,r1,i0)
#define dbccr(cc,i0,r0,r1) _dbccr(_jit,cc,i0,r0,r1)
static jit_word_t
_dbccr(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_int32_t);
#define dbcci(cc,i0,r0,i1) _dbcci(_jit,cc,i0,r0,i1)
static jit_word_t
_dbcci(jit_state_t*,jit_int32_t,jit_word_t,jit_int32_t,jit_float64_t);
# define bltr_d(i0,r0,r1) dbccr(BCC_MI,i0,r0,r1)
# define blti_d(i0,r0,i1) dbcci(BCC_MI,i0,r0,i1)
# define bler_d(i0,r0,r1) dbccr(BCC_LS,i0,r0,r1)
# define blei_d(i0,r0,i1) dbcci(BCC_LS,i0,r0,i1)
# define beqr_d(i0,r0,r1) dbccr(BCC_EQ,i0,r0,r1)
# define beqi_d(i0,r0,i1) dbcci(BCC_EQ,i0,r0,i1)
# define bger_d(i0,r0,r1) dbccr(BCC_GE,i0,r0,r1)
# define bgei_d(i0,r0,i1) dbcci(BCC_GE,i0,r0,i1)
# define bgtr_d(i0,r0,r1) dbccr(BCC_GT,i0,r0,r1)
# define bgti_d(i0,r0,i1) dbcci(BCC_GT,i0,r0,i1)
# define bner_d(i0,r0,r1) dbccr(BCC_NE,i0,r0,r1)
# define bnei_d(i0,r0,i1) dbcci(BCC_NE,i0,r0,i1)
# define bunltr_d(i0,r0,r1) dbccr(BCC_LT,i0,r0,r1)
# define bunlti_d(i0,r0,i1) dbcci(BCC_LT,i0,r0,i1)
# define bunler_d(i0,r0,r1) dbccr(BCC_LE,i0,r0,r1)
# define bunlei_d(i0,r0,i1) dbcci(BCC_LE,i0,r0,i1)
# define buneqr_d(i0,r0,r1) _buneqr_d(_jit,i0,r0,r1)
static jit_word_t _buneqr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
# define buneqi_d(i0,r0,i1) _buneqi_d(_jit,i0,r0,i1)
static jit_word_t _buneqi_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
# define bunger_d(i0,r0,r1) dbccr(BCC_PL,i0,r0,r1)
# define bungei_d(i0,r0,i1) dbcci(BCC_PL,i0,r0,i1)
# define bungtr_d(i0,r0,r1) dbccr(BCC_HI,i0,r0,r1)
# define bungti_d(i0,r0,i1) dbcci(BCC_HI,i0,r0,i1)
# define bltgtr_d(i0,r0,r1) _bltgtr_d(_jit,i0,r0,r1)
static jit_word_t _bltgtr_d(jit_state_t*,jit_word_t,jit_int32_t,jit_int32_t);
# define bltgti_d(i0,r0,i1) _bltgti_d(_jit,i0,r0,i1)
static jit_word_t _bltgti_d(jit_state_t*,jit_word_t,jit_int32_t,jit_float64_t);
# define bordr_d(i0,r0,r1) dbccr(BCC_VC,i0,r0,r1)
# define bordi_d(i0,r0,i1) dbcci(BCC_VC,i0,r0,i1)
# define bunordr_d(i0,r0,r1) dbccr(BCC_VS,i0,r0,r1)
# define bunordi_d(i0,r0,i1) dbcci(BCC_VS,i0,r0,i1)
# define vaarg_d(r0, r1) _vaarg_d(_jit, r0, r1)
static void _vaarg_d(jit_state_t*, jit_int32_t, jit_int32_t);
#endif
#if CODE
static void
_osvvv(jit_state_t *_jit, jit_int32_t Op, jit_int32_t Sz,
jit_int32_t Rd, jit_int32_t Rn, jit_int32_t Rm)
{
instr_t i;
assert(!(Rd & ~0x1f));
assert(!(Rn & ~0x1f));
assert(!(Rm & ~0x1f));
assert(!(Sz & ~0x3));
assert(!(Op & ~0xffe0fc00));
i.w = Op;
i.size.b = Sz;
i.Rd.b = Rd;
i.Rn.b = Rn;
i.Rm.b = Rm;
ii(i.w);
}
static void
_osvv_(jit_state_t *_jit, jit_int32_t Op,
jit_int32_t Sz, jit_int32_t Rd, jit_int32_t Rn)
{
instr_t i;
assert(!(Rd & ~0x1f));
assert(!(Rn & ~0x1f));
assert(!(Sz & ~0x3));
assert(!(Op & ~0xfffffc00));
i.w = Op;
i.size.b = Sz;
i.Rd.b = Rd;
i.Rn.b = Rn;
ii(i.w);
}
static void
_os_vv(jit_state_t *_jit, jit_int32_t Op,
jit_int32_t Sz, jit_int32_t Rn, jit_int32_t Rm)
{
instr_t i;
assert(!(Rn & ~0x1f));
assert(!(Rm & ~0x1f));
assert(!(Sz & ~0x3));
assert(!(Op & ~0xff20fc1f));
i.w = Op;
i.size.b = Sz;
i.Rn.b = Rn;
i.Rm.b = Rm;
ii(i.w);
}
#define fopi(name) \
static void \
_##name##i_f(jit_state_t *_jit, \
jit_int32_t r0, jit_int32_t r1, jit_float32_t i0) \
{ \
jit_int32_t reg = jit_get_reg(jit_class_fpr); \
movi_f(rn(reg), i0); \
name##r_f(r0, r1, rn(reg)); \
jit_unget_reg(reg); \
}
#define dopi(name) \
static void \
_##name##i_d(jit_state_t *_jit, \
jit_int32_t r0, jit_int32_t r1, jit_float64_t i0) \
{ \
jit_int32_t reg = jit_get_reg(jit_class_fpr); \
movi_d(rn(reg), i0); \
name##r_d(r0, r1, rn(reg)); \
jit_unget_reg(reg); \
}
#define fbopi(name) \
static jit_word_t \
_b##name##i_f(jit_state_t *_jit, \
jit_word_t i0, jit_int32_t r0, jit_float32_t i1) \
{ \
jit_word_t word; \
jit_int32_t reg = jit_get_reg(jit_class_fpr| \
jit_class_nospill); \
movi_f(rn(reg), i1); \
word = b##name##r_f(i0, r0, rn(reg)); \
jit_unget_reg(reg); \
return (word); \
}
#define dbopi(name) \
static jit_word_t \
_b##name##i_d(jit_state_t *_jit, \
jit_word_t i0, jit_int32_t r0, jit_float64_t i1) \
{ \
jit_word_t word; \
jit_int32_t reg = jit_get_reg(jit_class_fpr| \
jit_class_nospill); \
movi_d(rn(reg), i1); \
word = b##name##r_d(i0, r0, rn(reg)); \
jit_unget_reg(reg); \
return (word); \
}
static void
_truncr_f_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
FCVTSZ_WS(r0, r1);
extr_i(r0, r0);
}
static void
_truncr_d_i(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
FCVTSZ_WD(r0, r1);
extr_i(r0, r0);
}
fopi(add)
fopi(sub)
fopi(rsb)
fopi(mul)
fopi(div)
static void
_ldr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
ldr_i(rn(reg), r1);
FMOVSW(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_ldi_f(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
ldi_i(rn(reg), i0);
FMOVSW(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_ldxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
ldxr_i(rn(reg), r1, r2);
FMOVSW(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_ldxi_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
ldxi_i(rn(reg), r1, i0);
FMOVSW(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_str_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
FMOVWS(rn(reg), r1);
str_i(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_sti_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
FMOVWS(rn(reg), r0);
sti_i(i0, rn(reg));
jit_unget_reg(reg);
}
static void
_stxr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
FMOVWS(rn(reg), r2);
stxr_i(r0, r1, rn(reg));
jit_unget_reg(reg);
}
static void
_stxi_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
FMOVWS(rn(reg), r1);
stxi_i(i0, r0, rn(reg));
jit_unget_reg(reg);
}
static void
_movr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
if (r0 != r1)
FMOVS(r0, r1);
}
static void
_movi_f(jit_state_t *_jit, jit_int32_t r0, jit_float32_t i0)
{
union {
jit_int32_t i;
jit_float32_t f;
} u;
jit_int32_t reg;
u.f = i0;
if (u.i == 0)
FMOVSW(r0, WZR_REGNO);
else {
reg = jit_get_reg(jit_class_gpr);
/* prevent generating unused top 32 bits */
movi(rn(reg), ((jit_word_t)u.i) & 0xffffffff);
FMOVSW(r0, rn(reg));
jit_unget_reg(reg);
}
}
static void
_fccr(jit_state_t *_jit, jit_int32_t cc,
jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
FCMPES(r1, r2);
CSET(r0, cc);
}
static void
_fcci(jit_state_t *_jit, jit_int32_t cc,
jit_int32_t r0, jit_int32_t r1, jit_float32_t i0)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_fpr);
movi_f(rn(reg), i0);
fccr(cc, r0, r1, rn(reg));
jit_unget_reg(reg);
}
static void
_uneqr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
jit_word_t w;
FCMPES(r1, r2);
CSET(r0, CC_VS);
w = _jit->pc.w;
B_C(BCC_VS, 1); /* unordered satisfies condition */
CSET(r0, CC_EQ); /* equal satisfies condition */
patch_at(w, _jit->pc.w);
}
fopi(uneq)
static void
_ltgtr_f(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
jit_word_t w;
FCMPES(r1, r2);
CSET(r0, CC_VC); /* set to 1 if ordered */
w = _jit->pc.w;
B_C(BCC_VS, 1); /* unordered does not satisfy condition */
CSET(r0, CC_NE); /* set to 1 if not equal */
patch_at(w, _jit->pc.w);
}
fopi(ltgt)
static jit_word_t
_fbccr(jit_state_t *_jit, jit_int32_t cc,
jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
jit_word_t w, d;
FCMPES(r0, r1);
w = _jit->pc.w;
d = (i0 - w) >> 2;
B_C(cc, d);
return (w);
}
static jit_word_t
_fbcci(jit_state_t *_jit, jit_int32_t cc,
jit_word_t i0, jit_int32_t r0, jit_float32_t i1)
{
jit_word_t w;
jit_int32_t reg;
reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
movi_f(rn(reg), i1);
w = fbccr(cc, i0, r0, rn(reg));
jit_unget_reg(reg);
return (w);
}
static jit_word_t
_buneqr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
jit_word_t u, v, w;
FCMPES(r0, r1);
u = _jit->pc.w;
B_C(BCC_VS, 1); /* unordered satisfies condition */
v = _jit->pc.w;
B_C(BCC_NE, 1); /* not equal (or unordered) does not satisfy */
patch_at(u, _jit->pc.w);
w = _jit->pc.w;
B((i0 - w) >> 2);
patch_at(v, _jit->pc.w);
return (w);
}
fbopi(uneq)
static jit_word_t
_bltgtr_f(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
jit_word_t u, v, w;
FCMPES(r0, r1);
u = _jit->pc.w;
B_C(BCC_VS, 2); /* jump over if unordered */
v = _jit->pc.w;
B_C(BCC_EQ, 1); /* jump over if equal */
w = _jit->pc.w;
B((i0 - w) >> 2);
patch_at(u, _jit->pc.w);
patch_at(v, _jit->pc.w);
return (w);
}
fbopi(ltgt)
dopi(add)
dopi(sub)
dopi(rsb)
dopi(mul)
dopi(div)
static void
_ldr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
ldr_l(rn(reg), r1);
FMOVDX(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_ldi_d(jit_state_t *_jit, jit_int32_t r0, jit_word_t i0)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
ldi_l(rn(reg), i0);
FMOVDX(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_ldxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
ldxr_l(rn(reg), r1, r2);
FMOVDX(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_ldxi_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_word_t i0)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
ldxi_l(rn(reg), r1, i0);
FMOVDX(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_str_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
FMOVXD(rn(reg), r1);
str_l(r0, rn(reg));
jit_unget_reg(reg);
}
static void
_sti_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
FMOVXD(rn(reg), r0);
sti_l(i0, rn(reg));
jit_unget_reg(reg);
}
static void
_stxr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
FMOVXD(rn(reg), r2);
stxr_l(r0, r1, rn(reg));
jit_unget_reg(reg);
}
static void
_stxi_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_gpr);
FMOVXD(rn(reg), r1);
stxi_l(i0, r0, rn(reg));
jit_unget_reg(reg);
}
static void
_movr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
if (r0 != r1)
FMOVD(r0, r1);
}
static void
_movi_d(jit_state_t *_jit, jit_int32_t r0, jit_float64_t i0)
{
union {
jit_int64_t l;
jit_float64_t d;
} u;
jit_int32_t reg;
u.d = i0;
if (u.l == 0)
FMOVDX(r0, XZR_REGNO);
else {
reg = jit_get_reg(jit_class_gpr);
movi(rn(reg), u.l);
FMOVDX(r0, rn(reg));
jit_unget_reg(reg);
}
}
static void
_dccr(jit_state_t *_jit, jit_int32_t cc,
jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
FCMPED(r1, r2);
CSET(r0, cc);
}
static void
_dcci(jit_state_t *_jit, jit_int32_t cc,
jit_int32_t r0, jit_int32_t r1, jit_float64_t i0)
{
jit_int32_t reg;
reg = jit_get_reg(jit_class_fpr);
movi_d(rn(reg), i0);
dccr(cc, r0, r1, rn(reg));
jit_unget_reg(reg);
}
static void
_uneqr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
jit_word_t w;
FCMPED(r1, r2);
CSET(r0, CC_VS);
w = _jit->pc.w;
B_C(BCC_VS, 1); /* unordered satisfies condition */
CSET(r0, CC_EQ); /* equal satisfies condition */
patch_at(w, _jit->pc.w);
}
dopi(uneq)
static void
_ltgtr_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1, jit_int32_t r2)
{
jit_word_t w;
FCMPED(r1, r2);
CSET(r0, CC_VC); /* set to 1 if ordered */
w = _jit->pc.w;
B_C(BCC_VS, 1); /* unordered does not satisfy condition */
CSET(r0, CC_NE); /* set to 1 if not equal */
patch_at(w, _jit->pc.w);
}
dopi(ltgt)
static jit_word_t
_dbccr(jit_state_t *_jit, jit_int32_t cc,
jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
jit_word_t w, d;
FCMPED(r0, r1);
w = _jit->pc.w;
d = (i0 - w) >> 2;
B_C(cc, d);
return (w);
}
static jit_word_t
_dbcci(jit_state_t *_jit, jit_int32_t cc,
jit_word_t i0, jit_int32_t r0, jit_float64_t i1)
{
jit_word_t w;
jit_int32_t reg;
reg = jit_get_reg(jit_class_fpr|jit_class_nospill);
movi_d(rn(reg), i1);
w = dbccr(cc, i0, r0, rn(reg));
jit_unget_reg(reg);
return (w);
}
static jit_word_t
_buneqr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
jit_word_t u, v, w;
FCMPED(r0, r1);
u = _jit->pc.w;
B_C(BCC_VS, 1); /* unordered satisfies condition */
v = _jit->pc.w;
B_C(BCC_NE, 1); /* not equal (or unordered) does not satisfy */
patch_at(u, _jit->pc.w);
w = _jit->pc.w;
B((i0 - w) >> 2);
patch_at(v, _jit->pc.w);
return (w);
}
dbopi(uneq)
static jit_word_t
_bltgtr_d(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
{
jit_word_t u, v, w;
FCMPED(r0, r1);
u = _jit->pc.w;
B_C(BCC_VS, 2); /* jump over if unordered */
v = _jit->pc.w;
B_C(BCC_EQ, 1); /* jump over if equal */
w = _jit->pc.w;
B((i0 - w) >> 2);
patch_at(u, _jit->pc.w);
patch_at(v, _jit->pc.w);
return (w);
}
dbopi(ltgt)
static void
_vaarg_d(jit_state_t *_jit, jit_int32_t r0, jit_int32_t r1)
{
jit_word_t ge_code;
jit_word_t lt_code;
jit_int32_t rg0, rg1;
assert(_jitc->function->self.call & jit_call_varargs);
rg0 = jit_get_reg(jit_class_gpr);
rg1 = jit_get_reg(jit_class_gpr);
/* Load the fp offset in save area in the first temporary. */
ldxi_i(rn(rg0), r1, offsetof(jit_va_list_t, fpoff));
/* Jump over if there are no remaining arguments in the save area. */
ge_code = bgei(_jit->pc.w, rn(rg0), 0);
/* Load the gp save pointer in the second temporary. */
ldxi(rn(rg1), r1, offsetof(jit_va_list_t, fptop));
/* Load the vararg argument in the first argument. */
ldxr_d(r0, rn(rg1), rn(rg0));
/* Update the fp offset. */
addi(rn(rg0), rn(rg0), 16);
stxi_i(offsetof(jit_va_list_t, fpoff), r1, rn(rg0));
/* Will only need one temporary register below. */
jit_unget_reg(rg1);
/* Jump over overflow code. */
lt_code = jmpi_p(_jit->pc.w);
/* Where to land if argument is in overflow area. */
patch_at(ge_code, _jit->pc.w);
/* Load stack pointer. */
ldxi(rn(rg0), r1, offsetof(jit_va_list_t, stack));
/* Load argument. */
ldr_d(r0, rn(rg0));
/* Update stack pointer. */
addi(rn(rg0), rn(rg0), 8);
stxi(offsetof(jit_va_list_t, stack), r1, rn(rg0));
/* Where to land if argument is in gp save area. */
patch_at(lt_code, _jit->pc.w);
jit_unget_reg(rg0);
}
#endif

402
jit/jit_aarch64-sz.c Normal file
View file

@ -0,0 +1,402 @@
#if __WORDSIZE == 64
#define JIT_INSTR_MAX 120
0, /* data */
0, /* live */
4, /* align */
0, /* save */
0, /* load */
0, /* #name */
0, /* #note */
0, /* label */
120, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
44, /* va_start */
64, /* va_arg */
72, /* va_arg_d */
0, /* va_end */
4, /* addr */
20, /* addi */
4, /* addcr */
12, /* addci */
4, /* addxr */
8, /* addxi */
4, /* subr */
20, /* subi */
4, /* subcr */
12, /* subci */
4, /* subxr */
8, /* subxi */
24, /* rsbi */
4, /* mulr */
20, /* muli */
12, /* qmulr */
20, /* qmuli */
12, /* qmulr_u */
20, /* qmuli_u */
4, /* divr */
20, /* divi */
4, /* divr_u */
12, /* divi_u */
20, /* qdivr */
16, /* qdivi */
20, /* qdivr_u */
16, /* qdivi_u */
12, /* remr */
28, /* remi */
12, /* remr_u */
20, /* remi_u */
4, /* andr */
20, /* andi */
4, /* orr */
20, /* ori */
4, /* xorr */
20, /* xori */
4, /* lshr */
4, /* lshi */
4, /* rshr */
4, /* rshi */
4, /* rshr_u */
4, /* rshi_u */
4, /* negr */
4, /* comr */
8, /* ltr */
8, /* lti */
8, /* ltr_u */
8, /* lti_u */
8, /* ler */
8, /* lei */
8, /* ler_u */
8, /* lei_u */
8, /* eqr */
8, /* eqi */
8, /* ger */
8, /* gei */
8, /* ger_u */
8, /* gei_u */
8, /* gtr */
8, /* gti */
8, /* gtr_u */
8, /* gti_u */
8, /* ner */
8, /* nei */
4, /* movr */
16, /* movi */
4, /* extr_c */
4, /* extr_uc */
4, /* extr_s */
4, /* extr_us */
4, /* extr_i */
4, /* extr_ui */
8, /* htonr_us */
8, /* htonr_ui */
4, /* htonr_ul */
4, /* ldr_c */
12, /* ldi_c */
4, /* ldr_uc */
12, /* ldi_uc */
4, /* ldr_s */
12, /* ldi_s */
4, /* ldr_us */
12, /* ldi_us */
4, /* ldr_i */
12, /* ldi_i */
4, /* ldr_ui */
12, /* ldi_ui */
4, /* ldr_l */
12, /* ldi_l */
8, /* ldxr_c */
20, /* ldxi_c */
4, /* ldxr_uc */
20, /* ldxi_uc */
4, /* ldxr_s */
16, /* ldxi_s */
4, /* ldxr_us */
16, /* ldxi_us */
4, /* ldxr_i */
20, /* ldxi_i */
4, /* ldxr_ui */
16, /* ldxi_ui */
4, /* ldxr_l */
20, /* ldxi_l */
4, /* str_c */
12, /* sti_c */
4, /* str_s */
12, /* sti_s */
4, /* str_i */
12, /* sti_i */
4, /* str_l */
12, /* sti_l */
4, /* stxr_c */
20, /* stxi_c */
4, /* stxr_s */
20, /* stxi_s */
4, /* stxr_i */
20, /* stxi_i */
4, /* stxr_l */
20, /* stxi_l */
8, /* bltr */
8, /* blti */
8, /* bltr_u */
8, /* blti_u */
8, /* bler */
8, /* blei */
8, /* bler_u */
8, /* blei_u */
8, /* beqr */
24, /* beqi */
8, /* bger */
8, /* bgei */
8, /* bger_u */
8, /* bgei_u */
8, /* bgtr */
8, /* bgti */
8, /* bgtr_u */
8, /* bgti_u */
8, /* bner */
24, /* bnei */
8, /* bmsr */
8, /* bmsi */
8, /* bmcr */
8, /* bmci */
8, /* boaddr */
8, /* boaddi */
8, /* boaddr_u */
8, /* boaddi_u */
8, /* bxaddr */
8, /* bxaddi */
8, /* bxaddr_u */
8, /* bxaddi_u */
8, /* bosubr */
8, /* bosubi */
8, /* bosubr_u */
8, /* bosubi_u */
8, /* bxsubr */
8, /* bxsubi */
8, /* bxsubr_u */
8, /* bxsubi_u */
4, /* jmpr */
20, /* jmpi */
4, /* callr */
20, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
96, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
4, /* addr_f */
12, /* addi_f */
4, /* subr_f */
12, /* subi_f */
12, /* rsbi_f */
4, /* mulr_f */
12, /* muli_f */
4, /* divr_f */
12, /* divi_f */
4, /* negr_f */
4, /* absr_f */
4, /* sqrtr_f */
8, /* ltr_f */
16, /* lti_f */
8, /* ler_f */
16, /* lei_f */
8, /* eqr_f */
16, /* eqi_f */
8, /* ger_f */
16, /* gei_f */
8, /* gtr_f */
16, /* gti_f */
8, /* ner_f */
16, /* nei_f */
8, /* unltr_f */
16, /* unlti_f */
8, /* unler_f */
16, /* unlei_f */
16, /* uneqr_f */
24, /* uneqi_f */
8, /* unger_f */
16, /* ungei_f */
8, /* ungtr_f */
16, /* ungti_f */
16, /* ltgtr_f */
24, /* ltgti_f */
8, /* ordr_f */
16, /* ordi_f */
8, /* unordr_f */
16, /* unordi_f */
8, /* truncr_f_i */
4, /* truncr_f_l */
4, /* extr_f */
4, /* extr_d_f */
4, /* movr_f */
8, /* movi_f */
8, /* ldr_f */
16, /* ldi_f */
8, /* ldxr_f */
24, /* ldxi_f */
8, /* str_f */
16, /* sti_f */
8, /* stxr_f */
24, /* stxi_f */
8, /* bltr_f */
16, /* blti_f */
8, /* bler_f */
16, /* blei_f */
8, /* beqr_f */
16, /* beqi_f */
8, /* bger_f */
16, /* bgei_f */
8, /* bgtr_f */
16, /* bgti_f */
8, /* bner_f */
16, /* bnei_f */
8, /* bunltr_f */
16, /* bunlti_f */
8, /* bunler_f */
16, /* bunlei_f */
16, /* buneqr_f */
24, /* buneqi_f */
8, /* bunger_f */
16, /* bungei_f */
8, /* bungtr_f */
16, /* bungti_f */
16, /* bltgtr_f */
24, /* bltgti_f */
8, /* bordr_f */
16, /* bordi_f */
8, /* bunordr_f */
16, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
4, /* addr_d */
12, /* addi_d */
4, /* subr_d */
12, /* subi_d */
12, /* rsbi_d */
4, /* mulr_d */
12, /* muli_d */
4, /* divr_d */
12, /* divi_d */
4, /* negr_d */
4, /* absr_d */
4, /* sqrtr_d */
8, /* ltr_d */
16, /* lti_d */
8, /* ler_d */
16, /* lei_d */
8, /* eqr_d */
16, /* eqi_d */
8, /* ger_d */
16, /* gei_d */
8, /* gtr_d */
16, /* gti_d */
8, /* ner_d */
16, /* nei_d */
8, /* unltr_d */
16, /* unlti_d */
8, /* unler_d */
16, /* unlei_d */
16, /* uneqr_d */
24, /* uneqi_d */
8, /* unger_d */
16, /* ungei_d */
8, /* ungtr_d */
16, /* ungti_d */
16, /* ltgtr_d */
24, /* ltgti_d */
8, /* ordr_d */
16, /* ordi_d */
8, /* unordr_d */
16, /* unordi_d */
8, /* truncr_d_i */
4, /* truncr_d_l */
4, /* extr_d */
4, /* extr_f_d */
4, /* movr_d */
12, /* movi_d */
8, /* ldr_d */
16, /* ldi_d */
8, /* ldxr_d */
24, /* ldxi_d */
8, /* str_d */
16, /* sti_d */
8, /* stxr_d */
24, /* stxi_d */
8, /* bltr_d */
16, /* blti_d */
8, /* bler_d */
16, /* blei_d */
8, /* beqr_d */
20, /* beqi_d */
8, /* bger_d */
16, /* bgei_d */
8, /* bgtr_d */
16, /* bgti_d */
8, /* bner_d */
16, /* bnei_d */
8, /* bunltr_d */
16, /* bunlti_d */
8, /* bunler_d */
16, /* bunlei_d */
16, /* buneqr_d */
24, /* buneqi_d */
8, /* bunger_d */
16, /* bungei_d */
8, /* bungtr_d */
16, /* bungti_d */
16, /* bltgtr_d */
24, /* bltgti_d */
8, /* bordr_d */
16, /* bordi_d */
8, /* bunordr_d */
16, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
0, /* movr_w_f */
0, /* movr_ww_d */
0, /* movr_w_d */
0, /* movr_f_w */
0, /* movi_f_w */
0, /* movr_d_ww */
0, /* movi_d_ww */
0, /* movr_d_w */
0, /* movi_d_w */
#endif /* __WORDSIZE */

1582
jit/jit_aarch64.c Normal file
View file

File diff suppressed because it is too large Load diff

89
jit/jit_aarch64.h Normal file
View file

@ -0,0 +1,89 @@
/*
* Copyright (C) 2013-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#ifndef _jit_aarch64_h
#define _jit_aarch64_h
#define JIT_HASH_CONSTS 0
#define JIT_NUM_OPERANDS 3
/*
* Types
*/
#define JIT_FP _R29
typedef enum {
#define jit_r(i) (_R9 + (i))
#define jit_r_num() 7
#define jit_v(i) (_R19 + (i))
#define jit_v_num() 10
#define jit_f(i) (_V8 + (i))
#define jit_f_num() 8
#define JIT_R0 _R9
#define JIT_R1 _R10
#define JIT_R2 _R11
#define JIT_R3 _R12
#define JIT_R4 _R13
#define JIT_R5 _R14
#define JIT_R6 _R15
_R8, /* indirect result */
_R18, /* platform register */
_R17, /* IP1 */
_R16, /* IP0 */
_R9, _R10, _R11, _R12, /* temporaries */
_R13, _R14, _R15,
#define JIT_V0 _R19
#define JIT_V1 _R20
#define JIT_V2 _R21
#define JIT_V3 _R22
#define JIT_V4 _R23
#define JIT_V5 _R24
#define JIT_V6 _R25
#define JIT_V7 _R26
#define JIT_V8 _R27
#define JIT_V9 _R28
_R19, _R20, _R21, _R22, /* callee save */
_R23, _R24, _R25, _R26,
_R27, _R28,
_SP, /* stack pointer */
_R30, /* link register */
_R29, /* frame pointer */
_R7, _R6, _R5, _R4,
_R3, _R2, _R1, _R0,
#define JIT_F0 _V8
#define JIT_F1 _V9
#define JIT_F2 _V10
#define JIT_F3 _V11
#define JIT_F4 _V12
#define JIT_F5 _V13
#define JIT_F6 _V14
#define JIT_F7 _V15
_V31, _V30, _V29, _V28, /* temporaries */
_V27, _V26, _V25, _V24,
_V23, _V22, _V21, _V20,
_V19, _V18, _V17, _V16,
/* callee save */
_V8, _V9, _V10, _V11,
_V12, _V13, _V14, _V15,
_V7, _V6, _V5, _V4, /* arguments */
_V3, _V2, _V1, _V0,
_NOREG,
#define JIT_NOREG _NOREG
} jit_reg_t;
#endif /* _jit_aarch64_h */

2792
jit/jit_alpha-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1588
jit/jit_alpha-fpu.c Normal file
View file

File diff suppressed because it is too large Load diff

402
jit/jit_alpha-sz.c Normal file
View file

@ -0,0 +1,402 @@
#if __WORDSIZE == 64
#define JIT_INSTR_MAX 76
0, /* data */
0, /* live */
4, /* align */
0, /* save */
0, /* load */
0, /* #name */
0, /* #note */
0, /* label */
76, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
0, /* va_start */
0, /* va_arg */
0, /* va_arg_d */
0, /* va_end */
4, /* addr */
32, /* addi */
12, /* addcr */
40, /* addci */
28, /* addxr */
28, /* addxi */
4, /* subr */
32, /* subi */
12, /* subcr */
40, /* subci */
28, /* subxr */
28, /* subxi */
36, /* rsbi */
4, /* mulr */
32, /* muli */
44, /* qmulr */
56, /* qmuli */
12, /* qmulr_u */
32, /* qmuli_u */
48, /* divr */
72, /* divi */
48, /* divr_u */
72, /* divi_u */
56, /* qdivr */
56, /* qdivi */
56, /* qdivr_u */
56, /* qdivi_u */
48, /* remr */
72, /* remi */
48, /* remr_u */
72, /* remi_u */
4, /* andr */
32, /* andi */
4, /* orr */
32, /* ori */
4, /* xorr */
32, /* xori */
4, /* lshr */
4, /* lshi */
4, /* rshr */
4, /* rshi */
4, /* rshr_u */
4, /* rshi_u */
4, /* negr */
4, /* comr */
4, /* ltr */
4, /* lti */
4, /* ltr_u */
8, /* lti_u */
4, /* ler */
8, /* lei */
4, /* ler_u */
4, /* lei_u */
4, /* eqr */
4, /* eqi */
4, /* ger */
8, /* gei */
4, /* ger_u */
8, /* gei_u */
4, /* gtr */
8, /* gti */
4, /* gtr_u */
8, /* gti_u */
8, /* ner */
12, /* nei */
4, /* movr */
32, /* movi */
8, /* extr_c */
8, /* extr_uc */
8, /* extr_s */
8, /* extr_us */
8, /* extr_i */
8, /* extr_ui */
16, /* htonr_us */
36, /* htonr_ui */
36, /* htonr_ul */
12, /* ldr_c */
40, /* ldi_c */
4, /* ldr_uc */
32, /* ldi_uc */
12, /* ldr_s */
40, /* ldi_s */
4, /* ldr_us */
32, /* ldi_us */
4, /* ldr_i */
32, /* ldi_i */
12, /* ldr_ui */
40, /* ldi_ui */
4, /* ldr_l */
32, /* ldi_l */
16, /* ldxr_c */
12, /* ldxi_c */
8, /* ldxr_uc */
4, /* ldxi_uc */
16, /* ldxr_s */
12, /* ldxi_s */
8, /* ldxr_us */
4, /* ldxi_us */
8, /* ldxr_i */
4, /* ldxi_i */
16, /* ldxr_ui */
12, /* ldxi_ui */
8, /* ldxr_l */
4, /* ldxi_l */
4, /* str_c */
32, /* sti_c */
4, /* str_s */
32, /* sti_s */
4, /* str_i */
32, /* sti_i */
4, /* str_l */
32, /* sti_l */
8, /* stxr_c */
4, /* stxi_c */
8, /* stxr_s */
4, /* stxi_s */
8, /* stxr_i */
4, /* stxi_i */
8, /* stxr_l */
4, /* stxi_l */
8, /* bltr */
8, /* blti */
8, /* bltr_u */
12, /* blti_u */
8, /* bler */
12, /* blei */
8, /* bler_u */
12, /* blei_u */
8, /* beqr */
40, /* beqi */
8, /* bger */
12, /* bgei */
8, /* bger_u */
12, /* bgei_u */
8, /* bgtr */
12, /* bgti */
8, /* bgtr_u */
12, /* bgti_u */
8, /* bner */
36, /* bnei */
8, /* bmsr */
8, /* bmsi */
8, /* bmcr */
8, /* bmci */
28, /* boaddr */
32, /* boaddi */
16, /* boaddr_u */
16, /* boaddi_u */
28, /* bxaddr */
32, /* bxaddi */
16, /* bxaddr_u */
16, /* bxaddi_u */
28, /* bosubr */
32, /* bosubi */
16, /* bosubr_u */
16, /* bosubi_u */
28, /* bxsubr */
32, /* bxsubi */
16, /* bxsubr_u */
16, /* bxsubi_u */
0, /* jmpr */
36, /* jmpi */
8, /* callr */
36, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
68, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
8, /* addr_f */
32, /* addi_f */
8, /* subr_f */
32, /* subi_f */
32, /* rsbi_f */
8, /* mulr_f */
32, /* muli_f */
8, /* divr_f */
32, /* divi_f */
4, /* negr_f */
4, /* absr_f */
8, /* sqrtr_f */
32, /* ltr_f */
56, /* lti_f */
32, /* ler_f */
56, /* lei_f */
32, /* eqr_f */
56, /* eqi_f */
32, /* ger_f */
56, /* gei_f */
32, /* gtr_f */
56, /* gti_f */
32, /* ner_f */
56, /* nei_f */
32, /* unltr_f */
56, /* unlti_f */
32, /* unler_f */
56, /* unlei_f */
32, /* uneqr_f */
56, /* uneqi_f */
32, /* unger_f */
56, /* ungei_f */
32, /* ungtr_f */
56, /* ungti_f */
32, /* ltgtr_f */
56, /* ltgti_f */
20, /* ordr_f */
44, /* ordi_f */
20, /* unordr_f */
44, /* unordi_f */
16, /* truncr_f_i */
16, /* truncr_f_l */
12, /* extr_f */
4, /* extr_d_f */
4, /* movr_f */
24, /* movi_f */
4, /* ldr_f */
32, /* ldi_f */
8, /* ldxr_f */
4, /* ldxi_f */
4, /* str_f */
32, /* sti_f */
8, /* stxr_f */
4, /* stxi_f */
24, /* bltr_f */
48, /* blti_f */
24, /* bler_f */
48, /* blei_f */
24, /* beqr_f */
48, /* beqi_f */
24, /* bger_f */
48, /* bgei_f */
24, /* bgtr_f */
48, /* bgti_f */
28, /* bner_f */
52, /* bnei_f */
28, /* bunltr_f */
52, /* bunlti_f */
28, /* bunler_f */
52, /* bunlei_f */
28, /* buneqr_f */
52, /* buneqi_f */
28, /* bunger_f */
52, /* bungei_f */
28, /* bungtr_f */
52, /* bungti_f */
28, /* bltgtr_f */
52, /* bltgti_f */
12, /* bordr_f */
36, /* bordi_f */
12, /* bunordr_f */
36, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
8, /* addr_d */
28, /* addi_d */
8, /* subr_d */
28, /* subi_d */
28, /* rsbi_d */
8, /* mulr_d */
28, /* muli_d */
8, /* divr_d */
28, /* divi_d */
4, /* negr_d */
4, /* absr_d */
8, /* sqrtr_d */
32, /* ltr_d */
52, /* lti_d */
32, /* ler_d */
52, /* lei_d */
32, /* eqr_d */
52, /* eqi_d */
32, /* ger_d */
52, /* gei_d */
32, /* gtr_d */
52, /* gti_d */
32, /* ner_d */
52, /* nei_d */
32, /* unltr_d */
52, /* unlti_d */
32, /* unler_d */
52, /* unlei_d */
32, /* uneqr_d */
52, /* uneqi_d */
32, /* unger_d */
52, /* ungei_d */
32, /* ungtr_d */
52, /* ungti_d */
32, /* ltgtr_d */
52, /* ltgti_d */
20, /* ordr_d */
40, /* ordi_d */
20, /* unordr_d */
40, /* unordi_d */
16, /* truncr_d_i */
16, /* truncr_d_l */
12, /* extr_d */
4, /* extr_f_d */
4, /* movr_d */
20, /* movi_d */
4, /* ldr_d */
32, /* ldi_d */
8, /* ldxr_d */
4, /* ldxi_d */
4, /* str_d */
32, /* sti_d */
8, /* stxr_d */
4, /* stxi_d */
24, /* bltr_d */
44, /* blti_d */
24, /* bler_d */
44, /* blei_d */
24, /* beqr_d */
44, /* beqi_d */
24, /* bger_d */
44, /* bgei_d */
24, /* bgtr_d */
44, /* bgti_d */
28, /* bner_d */
48, /* bnei_d */
28, /* bunltr_d */
48, /* bunlti_d */
28, /* bunler_d */
48, /* bunlei_d */
28, /* buneqr_d */
48, /* buneqi_d */
28, /* bunger_d */
48, /* bungei_d */
28, /* bungtr_d */
48, /* bungti_d */
28, /* bltgtr_d */
48, /* bltgti_d */
12, /* bordr_d */
32, /* bordi_d */
12, /* bunordr_d */
32, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
0, /* movr_w_f */
0, /* movr_ww_d */
0, /* movr_w_d */
0, /* movr_f_w */
0, /* movi_f_w */
0, /* movr_d_ww */
0, /* movi_d_ww */
0, /* movr_d_w */
0, /* movi_d_w */
#endif /* __WORDSIZE */

1551
jit/jit_alpha.c Normal file
View file

File diff suppressed because it is too large Load diff

105
jit/jit_alpha.h Normal file
View file

@ -0,0 +1,105 @@
/*
* Copyright (C) 2014-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#ifndef _jit_alpha_h
#define _jit_alpha_h
#define JIT_HASH_CONSTS 1
#define JIT_NUM_OPERANDS 3
/*
* Types
*/
#define JIT_FP _FP
typedef enum {
#define jit_r(i) (_S0 + (i))
#define jit_r_num() 3
#define jit_v(i) (_S3 + (i))
#define jit_v_num() 3
#define jit_f(i) (_F2 + (i))
#define jit_f_num() 8
/* Volatile - Assembly temporary register */
_AT,
/* Volatile - Return value register */
_V0,
/* Volatile - Temporary registers */
_T0, _T1, _T2, _T3,
_T4, _T5, _T6, _T7,
_T8, _T9, _T10, _T11,
/* FIXME Use callee save register for r0-r2 (instead of 12+ JIT_RN
* and 6 JIT_VN because division must call a function)
* FIX would be to create proper functions that do not clobber
* registers and inject/inline them in the jit */
#define JIT_R0 _S0
#define JIT_R1 _S1
#define JIT_R2 _S2
#define JIT_V0 _S3
#define JIT_V1 _S4
#define JIT_V2 _S5
/* Nonvolatile - Saved registers */
_S0, _S1, _S2, _S3,
_S4, _S5,
/* Nonvolatile - Frame pointer */
_FP,
/* Volatile - Argument registers */
_A5, _A4, _A3, _A2,
_A1, _A0,
/* Volatile - Return address register */
_RA,
/* Volatile - Temporary register */
_PV,
/* Nonvolatile - Global pointer */
_GP,
/* Nonvolatile - Stack pointer */
_SP,
/* Constant RAZ / writes ignored */
_ZERO,
#define JIT_F0 _F2
#define JIT_F1 _F3
#define JIT_F2 _F4
#define JIT_F3 _F5
#define JIT_F4 _F6
#define JIT_F5 _F7
#define JIT_F6 _F8
#define JIT_F7 _F9
/* Volatile - Return value register (real part) */
_F0,
/* Volatile - Return value register (imaginary part) */
_F1,
/* Nonvolatile - Saved registers */
_F2, _F3, _F4, _F5,
_F6, _F7, _F8, _F9,
/* Volatile - Temporary registers */
_F10, _F11, _F12, _F13,
_F14, _F15,
/* Volatile - Argument registers */
_F21, _F20, _F19, _F18,
_F17, _F16,
/* Volatile - Temporary registers */
_F22, _F23, _R24, _F25,
_F26, _F27, _F28, _F29,
_F30,
/* Constant - RAZ / writes ignored */
_F31,
/* Lightning internal invalid register identifier */
_NOREG,
#define JIT_NOREG _NOREG
} jit_reg_t;
#endif /* _jit_alpha_h */

3955
jit/jit_arm-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

2640
jit/jit_arm-swf.c Normal file
View file

File diff suppressed because it is too large Load diff

808
jit/jit_arm-sz.c Normal file
View file

@ -0,0 +1,808 @@
#if __WORDSIZE == 32
#if defined(__ARM_PCS_VFP)
#define JIT_INSTR_MAX 48
0, /* data */
0, /* live */
2, /* align */
0, /* save */
0, /* load */
2, /* #name */
0, /* #note */
0, /* label */
34, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
4, /* va_start */
8, /* va_arg */
16, /* va_arg_d */
0, /* va_end */
4, /* addr */
12, /* addi */
4, /* addcr */
8, /* addci */
4, /* addxr */
4, /* addxi */
4, /* subr */
12, /* subi */
4, /* subcr */
8, /* subci */
4, /* subxr */
4, /* subxi */
16, /* rsbi */
4, /* mulr */
12, /* muli */
4, /* qmulr */
12, /* qmuli */
4, /* qmulr_u */
8, /* qmuli_u */
40, /* divr */
48, /* divi */
40, /* divr_u */
44, /* divi_u */
34, /* qdivr */
38, /* qdivi */
34, /* qdivr_u */
38, /* qdivi_u */
40, /* remr */
48, /* remi */
40, /* remr_u */
44, /* remi_u */
4, /* andr */
12, /* andi */
4, /* orr */
12, /* ori */
4, /* xorr */
12, /* xori */
4, /* lshr */
4, /* lshi */
4, /* rshr */
4, /* rshi */
4, /* rshr_u */
4, /* rshi_u */
4, /* negr */
4, /* comr */
14, /* ltr */
14, /* lti */
14, /* ltr_u */
14, /* lti_u */
14, /* ler */
14, /* lei */
14, /* ler_u */
14, /* lei_u */
14, /* eqr */
14, /* eqi */
14, /* ger */
14, /* gei */
14, /* ger_u */
14, /* gei_u */
14, /* gtr */
14, /* gti */
14, /* gtr_u */
14, /* gti_u */
14, /* ner */
14, /* nei */
4, /* movr */
8, /* movi */
4, /* extr_c */
4, /* extr_uc */
4, /* extr_s */
4, /* extr_us */
0, /* extr_i */
0, /* extr_ui */
8, /* htonr_us */
4, /* htonr_ui */
0, /* htonr_ul */
4, /* ldr_c */
12, /* ldi_c */
4, /* ldr_uc */
12, /* ldi_uc */
4, /* ldr_s */
12, /* ldi_s */
4, /* ldr_us */
12, /* ldi_us */
4, /* ldr_i */
12, /* ldi_i */
0, /* ldr_ui */
0, /* ldi_ui */
0, /* ldr_l */
0, /* ldi_l */
4, /* ldxr_c */
12, /* ldxi_c */
4, /* ldxr_uc */
12, /* ldxi_uc */
4, /* ldxr_s */
12, /* ldxi_s */
4, /* ldxr_us */
12, /* ldxi_us */
4, /* ldxr_i */
12, /* ldxi_i */
0, /* ldxr_ui */
0, /* ldxi_ui */
0, /* ldxr_l */
0, /* ldxi_l */
4, /* str_c */
12, /* sti_c */
4, /* str_s */
12, /* sti_s */
4, /* str_i */
12, /* sti_i */
0, /* str_l */
0, /* sti_l */
4, /* stxr_c */
12, /* stxi_c */
4, /* stxr_s */
12, /* stxi_s */
4, /* stxr_i */
12, /* stxi_i */
0, /* stxr_l */
0, /* stxi_l */
8, /* bltr */
8, /* blti */
8, /* bltr_u */
8, /* blti_u */
8, /* bler */
8, /* blei */
8, /* bler_u */
8, /* blei_u */
8, /* beqr */
16, /* beqi */
8, /* bger */
8, /* bgei */
8, /* bger_u */
8, /* bgei_u */
8, /* bgtr */
8, /* bgti */
8, /* bgtr_u */
8, /* bgti_u */
8, /* bner */
16, /* bnei */
8, /* bmsr */
8, /* bmsi */
8, /* bmcr */
8, /* bmci */
8, /* boaddr */
8, /* boaddi */
8, /* boaddr_u */
8, /* boaddi_u */
8, /* bxaddr */
8, /* bxaddi */
8, /* bxaddr_u */
8, /* bxaddi_u */
8, /* bosubr */
8, /* bosubi */
8, /* bosubr_u */
8, /* bosubi_u */
8, /* bxsubr */
8, /* bxsubi */
8, /* bxsubr_u */
8, /* bxsubi_u */
4, /* jmpr */
8, /* jmpi */
4, /* callr */
20, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
24, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
4, /* addr_f */
8, /* addi_f */
4, /* subr_f */
8, /* subi_f */
8, /* rsbi_f */
4, /* mulr_f */
8, /* muli_f */
4, /* divr_f */
8, /* divi_f */
4, /* negr_f */
4, /* absr_f */
4, /* sqrtr_f */
18, /* ltr_f */
30, /* lti_f */
20, /* ler_f */
32, /* lei_f */
18, /* eqr_f */
30, /* eqi_f */
18, /* ger_f */
30, /* gei_f */
18, /* gtr_f */
30, /* gti_f */
18, /* ner_f */
30, /* nei_f */
18, /* unltr_f */
30, /* unlti_f */
18, /* unler_f */
30, /* unlei_f */
24, /* uneqr_f */
36, /* uneqi_f */
18, /* unger_f */
30, /* ungei_f */
18, /* ungtr_f */
30, /* ungti_f */
24, /* ltgtr_f */
36, /* ltgti_f */
18, /* ordr_f */
30, /* ordi_f */
18, /* unordr_f */
30, /* unordi_f */
8, /* truncr_f_i */
0, /* truncr_f_l */
8, /* extr_f */
4, /* extr_d_f */
4, /* movr_f */
12, /* movi_f */
4, /* ldr_f */
12, /* ldi_f */
8, /* ldxr_f */
16, /* ldxi_f */
4, /* str_f */
12, /* sti_f */
8, /* stxr_f */
16, /* stxi_f */
12, /* bltr_f */
24, /* blti_f */
12, /* bler_f */
24, /* blei_f */
12, /* beqr_f */
24, /* beqi_f */
12, /* bger_f */
24, /* bgei_f */
12, /* bgtr_f */
24, /* bgti_f */
12, /* bner_f */
24, /* bnei_f */
16, /* bunltr_f */
28, /* bunlti_f */
16, /* bunler_f */
28, /* bunlei_f */
20, /* buneqr_f */
32, /* buneqi_f */
16, /* bunger_f */
28, /* bungei_f */
12, /* bungtr_f */
24, /* bungti_f */
20, /* bltgtr_f */
32, /* bltgti_f */
12, /* bordr_f */
24, /* bordi_f */
12, /* bunordr_f */
24, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
4, /* addr_d */
20, /* addi_d */
4, /* subr_d */
20, /* subi_d */
20, /* rsbi_d */
4, /* mulr_d */
20, /* muli_d */
4, /* divr_d */
20, /* divi_d */
4, /* negr_d */
4, /* absr_d */
4, /* sqrtr_d */
18, /* ltr_d */
34, /* lti_d */
20, /* ler_d */
36, /* lei_d */
18, /* eqr_d */
34, /* eqi_d */
18, /* ger_d */
34, /* gei_d */
18, /* gtr_d */
34, /* gti_d */
18, /* ner_d */
34, /* nei_d */
18, /* unltr_d */
34, /* unlti_d */
18, /* unler_d */
34, /* unlei_d */
24, /* uneqr_d */
40, /* uneqi_d */
18, /* unger_d */
34, /* ungei_d */
18, /* ungtr_d */
34, /* ungti_d */
24, /* ltgtr_d */
40, /* ltgti_d */
18, /* ordr_d */
34, /* ordi_d */
18, /* unordr_d */
34, /* unordi_d */
8, /* truncr_d_i */
0, /* truncr_d_l */
8, /* extr_d */
4, /* extr_f_d */
4, /* movr_d */
16, /* movi_d */
4, /* ldr_d */
12, /* ldi_d */
8, /* ldxr_d */
16, /* ldxi_d */
4, /* str_d */
12, /* sti_d */
8, /* stxr_d */
16, /* stxi_d */
12, /* bltr_d */
28, /* blti_d */
12, /* bler_d */
28, /* blei_d */
12, /* beqr_d */
28, /* beqi_d */
12, /* bger_d */
28, /* bgei_d */
12, /* bgtr_d */
28, /* bgti_d */
12, /* bner_d */
28, /* bnei_d */
16, /* bunltr_d */
32, /* bunlti_d */
16, /* bunler_d */
32, /* bunlei_d */
20, /* buneqr_d */
36, /* buneqi_d */
16, /* bunger_d */
32, /* bungei_d */
12, /* bungtr_d */
28, /* bungti_d */
20, /* bltgtr_d */
36, /* bltgti_d */
12, /* bordr_d */
28, /* bordi_d */
12, /* bunordr_d */
28, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
0, /* movr_w_f */
4, /* movr_ww_d */
0, /* movr_w_d */
0, /* movr_f_w */
0, /* movi_f_w */
4, /* movr_d_ww */
12, /* movi_d_ww */
0, /* movr_d_w */
0, /* movi_d_w */
#endif /* __ARM_PCS_VFP */
#endif /* __WORDSIZE */
#if __WORDSIZE == 32
#if !defined(__ARM_PCS_VFP)
#define JIT_INSTR_MAX 160
0, /* data */
0, /* live */
2, /* align */
0, /* save */
0, /* load */
2, /* #name */
0, /* #note */
0, /* label */
30, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
4, /* va_start */
8, /* va_arg */
28, /* va_arg_d */
0, /* va_end */
4, /* addr */
12, /* addi */
4, /* addcr */
8, /* addci */
4, /* addxr */
4, /* addxi */
4, /* subr */
12, /* subi */
4, /* subcr */
8, /* subci */
4, /* subxr */
4, /* subxi */
16, /* rsbi */
8, /* mulr */
12, /* muli */
4, /* qmulr */
12, /* qmuli */
4, /* qmulr_u */
8, /* qmuli_u */
40, /* divr */
48, /* divi */
40, /* divr_u */
44, /* divi_u */
34, /* qdivr */
38, /* qdivi */
34, /* qdivr_u */
38, /* qdivi_u */
40, /* remr */
48, /* remi */
40, /* remr_u */
44, /* remi_u */
4, /* andr */
12, /* andi */
4, /* orr */
12, /* ori */
4, /* xorr */
12, /* xori */
4, /* lshr */
4, /* lshi */
4, /* rshr */
4, /* rshi */
4, /* rshr_u */
4, /* rshi_u */
4, /* negr */
4, /* comr */
14, /* ltr */
14, /* lti */
14, /* ltr_u */
14, /* lti_u */
14, /* ler */
14, /* lei */
14, /* ler_u */
14, /* lei_u */
14, /* eqr */
14, /* eqi */
14, /* ger */
14, /* gei */
14, /* ger_u */
14, /* gei_u */
14, /* gtr */
14, /* gti */
14, /* gtr_u */
14, /* gti_u */
14, /* ner */
14, /* nei */
4, /* movr */
8, /* movi */
8, /* extr_c */
4, /* extr_uc */
8, /* extr_s */
8, /* extr_us */
0, /* extr_i */
0, /* extr_ui */
20, /* htonr_us */
16, /* htonr_ui */
0, /* htonr_ul */
4, /* ldr_c */
12, /* ldi_c */
4, /* ldr_uc */
12, /* ldi_uc */
4, /* ldr_s */
12, /* ldi_s */
4, /* ldr_us */
12, /* ldi_us */
4, /* ldr_i */
12, /* ldi_i */
0, /* ldr_ui */
0, /* ldi_ui */
0, /* ldr_l */
0, /* ldi_l */
4, /* ldxr_c */
12, /* ldxi_c */
4, /* ldxr_uc */
12, /* ldxi_uc */
4, /* ldxr_s */
12, /* ldxi_s */
4, /* ldxr_us */
12, /* ldxi_us */
4, /* ldxr_i */
12, /* ldxi_i */
0, /* ldxr_ui */
0, /* ldxi_ui */
0, /* ldxr_l */
0, /* ldxi_l */
4, /* str_c */
12, /* sti_c */
4, /* str_s */
12, /* sti_s */
4, /* str_i */
12, /* sti_i */
0, /* str_l */
0, /* sti_l */
4, /* stxr_c */
12, /* stxi_c */
4, /* stxr_s */
12, /* stxi_s */
4, /* stxr_i */
12, /* stxi_i */
0, /* stxr_l */
0, /* stxi_l */
8, /* bltr */
8, /* blti */
8, /* bltr_u */
8, /* blti_u */
8, /* bler */
8, /* blei */
8, /* bler_u */
8, /* blei_u */
8, /* beqr */
16, /* beqi */
8, /* bger */
8, /* bgei */
8, /* bger_u */
8, /* bgei_u */
8, /* bgtr */
8, /* bgti */
8, /* bgtr_u */
8, /* bgti_u */
8, /* bner */
16, /* bnei */
8, /* bmsr */
8, /* bmsi */
8, /* bmcr */
8, /* bmci */
8, /* boaddr */
8, /* boaddi */
8, /* boaddr_u */
8, /* boaddi_u */
8, /* bxaddr */
8, /* bxaddi */
8, /* bxaddr_u */
8, /* bxaddi_u */
8, /* bosubr */
8, /* bosubi */
8, /* bosubr_u */
8, /* bosubi_u */
8, /* bxsubr */
8, /* bxsubi */
8, /* bxsubr_u */
8, /* bxsubi_u */
12, /* jmpr */
72, /* jmpi */
4, /* callr */
20, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
160, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
40, /* addr_f */
40, /* addi_f */
40, /* subr_f */
40, /* subi_f */
40, /* rsbi_f */
40, /* mulr_f */
40, /* muli_f */
40, /* divr_f */
40, /* divi_f */
12, /* negr_f */
12, /* absr_f */
36, /* sqrtr_f */
40, /* ltr_f */
44, /* lti_f */
40, /* ler_f */
44, /* lei_f */
40, /* eqr_f */
44, /* eqi_f */
40, /* ger_f */
44, /* gei_f */
40, /* gtr_f */
44, /* gti_f */
44, /* ner_f */
48, /* nei_f */
72, /* unltr_f */
80, /* unlti_f */
72, /* unler_f */
80, /* unlei_f */
72, /* uneqr_f */
80, /* uneqi_f */
72, /* unger_f */
80, /* ungei_f */
72, /* ungtr_f */
80, /* ungti_f */
76, /* ltgtr_f */
84, /* ltgti_f */
44, /* ordr_f */
48, /* ordi_f */
72, /* unordr_f */
80, /* unordi_f */
36, /* truncr_f_i */
0, /* truncr_f_l */
36, /* extr_f */
38, /* extr_d_f */
8, /* movr_f */
12, /* movi_f */
8, /* ldr_f */
16, /* ldi_f */
8, /* ldxr_f */
16, /* ldxi_f */
8, /* str_f */
16, /* sti_f */
8, /* stxr_f */
16, /* stxi_f */
44, /* bltr_f */
48, /* blti_f */
44, /* bler_f */
48, /* blei_f */
44, /* beqr_f */
52, /* beqi_f */
44, /* bger_f */
48, /* bgei_f */
44, /* bgtr_f */
48, /* bgti_f */
44, /* bner_f */
48, /* bnei_f */
44, /* bunltr_f */
48, /* bunlti_f */
44, /* bunler_f */
48, /* bunlei_f */
76, /* buneqr_f */
84, /* buneqi_f */
44, /* bunger_f */
48, /* bungei_f */
44, /* bungtr_f */
48, /* bungti_f */
76, /* bltgtr_f */
84, /* bltgti_f */
44, /* bordr_f */
48, /* bordi_f */
44, /* bunordr_f */
48, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
50, /* addr_d */
52, /* addi_d */
50, /* subr_d */
52, /* subi_d */
52, /* rsbi_d */
50, /* mulr_d */
52, /* muli_d */
50, /* divr_d */
52, /* divi_d */
20, /* negr_d */
20, /* absr_d */
42, /* sqrtr_d */
44, /* ltr_d */
48, /* lti_d */
44, /* ler_d */
48, /* lei_d */
44, /* eqr_d */
48, /* eqi_d */
44, /* ger_d */
48, /* gei_d */
44, /* gtr_d */
48, /* gti_d */
48, /* ner_d */
52, /* nei_d */
82, /* unltr_d */
88, /* unlti_d */
82, /* unler_d */
88, /* unlei_d */
82, /* uneqr_d */
88, /* uneqi_d */
82, /* unger_d */
88, /* ungei_d */
82, /* ungtr_d */
88, /* ungti_d */
86, /* ltgtr_d */
92, /* ltgti_d */
48, /* ordr_d */
52, /* ordi_d */
82, /* unordr_d */
88, /* unordi_d */
36, /* truncr_d_i */
0, /* truncr_d_l */
36, /* extr_d */
38, /* extr_f_d */
16, /* movr_d */
20, /* movi_d */
16, /* ldr_d */
24, /* ldi_d */
20, /* ldxr_d */
28, /* ldxi_d */
16, /* str_d */
24, /* sti_d */
20, /* stxr_d */
28, /* stxi_d */
48, /* bltr_d */
52, /* blti_d */
48, /* bler_d */
52, /* blei_d */
48, /* beqr_d */
60, /* beqi_d */
48, /* bger_d */
52, /* bgei_d */
48, /* bgtr_d */
52, /* bgti_d */
48, /* bner_d */
52, /* bnei_d */
48, /* bunltr_d */
52, /* bunlti_d */
48, /* bunler_d */
52, /* bunlei_d */
84, /* buneqr_d */
92, /* buneqi_d */
48, /* bunger_d */
52, /* bungei_d */
48, /* bungtr_d */
52, /* bungti_d */
84, /* bltgtr_d */
92, /* bltgti_d */
48, /* bordr_d */
52, /* bordi_d */
48, /* bunordr_d */
52, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
4, /* movr_w_f */
8, /* movr_ww_d */
0, /* movr_w_d */
8, /* movr_f_w */
8, /* movi_f_w */
16, /* movr_d_ww */
12, /* movi_d_ww */
0, /* movr_d_w */
0, /* movi_d_w */
#endif /* __ARM_PCS_VFP */
#endif /* __WORDSIZE */

2330
jit/jit_arm-vfp.c Normal file
View file

File diff suppressed because it is too large Load diff

2274
jit/jit_arm.c Normal file
View file

File diff suppressed because it is too large Load diff

127
jit/jit_arm.h Normal file
View file

@ -0,0 +1,127 @@
/*
* Copyright (C) 2012-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* 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_ldrt_strt_p() jit_cpu.ldrt_strt
#define JIT_FP _R11
typedef enum {
#define jit_r(i) (_R4 + (i))
#define jit_r_num() 3
#define jit_v(i) (_R7 + (i))
#define jit_v_num() 3
#define jit_f(i) (jit_cpu.abi ? _D8 + ((i)<<1) : _D0 - ((i)<<1))
#define jit_f_num() 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 */
_R3, /* r3 - argument/result */
_R2, /* r2 - argument/result */
_R1, /* r1 - argument/result */
_R0, /* r0 - argument/result */
#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,
_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;
/* use strt+offset instead of str.w?
* on special cases it causes a SIGILL at least on qemu, probably
* due to some memory ordering constraint not being respected, so,
* disable by default */
jit_uint32_t ldrt_strt : 1;
} jit_cpu_t;
/*
* Initialization
*/
extern jit_cpu_t jit_cpu;
#endif /* _jit_arm_h */

415
jit/jit_disasm.c Normal file
View file

@ -0,0 +1,415 @@
/*
* Copyright (C) 2012-2018 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#include "jit.h"
#include "jit/jit_private.h"
#if DISASSEMBLER
# include <dis-asm.h>
#endif
/*
* Prototypes
*/
#if DISASSEMBLER
static int
disasm_compare_symbols(const void *ap, const void *bp);
static void
disasm_print_address(bfd_vma addr, struct disassemble_info *info);
#define disassemble(u, v) _disassemble(_jit, u, v)
static void
_disassemble(jit_state_t *_jit, jit_pointer_t code, jit_int32_t length);
#endif
/*
* Initialization
*/
#if DISASSEMBLER
static bfd *disasm_bfd;
static disassemble_info disasm_info;
static disassembler_ftype disasm_print;
static asymbol **disasm_symbols;
static asymbol *disasm_synthetic;
static long disasm_num_symbols;
static long disasm_num_synthetic;
static jit_state_t *disasm_jit;
#define disasm_stream stdout
#endif
/*
* Implementation
*/
void
jit_init_debug(const char *progname)
{
#if DISASSEMBLER
bfd_init();
if (progname)
disasm_bfd = bfd_openr(progname, NULL);
if (disasm_bfd == NULL) {
#if defined(__linux__)
disasm_bfd = bfd_openr("/proc/self/exe", NULL);
if (disasm_bfd == NULL)
#endif
return;
}
bfd_check_format(disasm_bfd, bfd_object);
bfd_check_format(disasm_bfd, bfd_archive);
INIT_DISASSEMBLE_INFO(disasm_info, disasm_stream, fprintf);
# if defined(__i386__) || defined(__x86_64__)
disasm_info.arch = bfd_arch_i386;
# if defined(__x86_64__)
# if __WORDSIZE == 32
disasm_info.mach = bfd_mach_x64_32;
# else
disasm_info.mach = bfd_mach_x86_64;
# endif
# else
disasm_info.mach = bfd_mach_i386_i386;
# endif
# endif
# if defined(__powerpc__)
disasm_info.arch = bfd_arch_powerpc;
disasm_info.mach = bfd_mach_ppc64;
# if HAVE_DISASSEMBLE_INIT_FOR_TARGET
disassemble_init_for_target(&disasm_info);
# elif HAVE_DISASSEMBLE_INIT_POWERPC
disassemble_init_powerpc(&disasm_info);
# endif
# if defined(__powerpc64__)
disasm_info.disassembler_options = "64";
# endif
# if HAVE_DISASSEMBLE_INIT_FOR_TARGET
disassemble_init_for_target(&disasm_info);
# elif HAVE_DISASSEMBLE_INIT_POWERPC
disassemble_init_powerpc(&disasm_info);
# endif
# endif
# if defined(__sparc__)
disasm_info.endian = disasm_info.display_endian = BFD_ENDIAN_BIG;
# endif
# if defined(__s390__) || defined(__s390x__)
disasm_info.arch = bfd_arch_s390;
# if __WORDSIZE == 32
disasm_info.mach = bfd_mach_s390_31;
# else
disasm_info.mach = bfd_mach_s390_64;
# endif
disasm_info.endian = disasm_info.display_endian = BFD_ENDIAN_BIG;
disasm_info.disassembler_options = "zarch";
# endif
# if defined(__alpha__)
disasm_info.arch = bfd_arch_alpha;
disasm_info.mach = bfd_mach_alpha_ev6;
# endif
disasm_info.print_address_func = disasm_print_address;
# if BINUTILS_2_29
disasm_print = disassembler(disasm_info.arch, __BYTE_ORDER == __BIG_ENDIAN,
disasm_info.mach, disasm_bfd);
# else
disasm_print = disassembler(disasm_bfd);
# endif
assert(disasm_print);
if (bfd_get_file_flags(disasm_bfd) & HAS_SYMS) {
asymbol **in;
asymbol **out;
asymbol *symbol;
long offset;
long sym_count;
long dyn_count;
long sym_storage;
long dyn_storage;
if ((sym_storage = bfd_get_symtab_upper_bound(disasm_bfd)) >= 0) {
if (bfd_get_file_flags(disasm_bfd) & DYNAMIC) {
dyn_storage = bfd_get_dynamic_symtab_upper_bound(disasm_bfd);
# if defined(__alpha__)
/* XXX */
if (dyn_storage < 0)
dyn_storage = 0;
# else
assert(dyn_storage >= 0);
# endif
}
else
dyn_storage = 0;
jit_alloc((jit_pointer_t *)&disasm_symbols,
(sym_storage + dyn_storage) * sizeof(asymbol *));
sym_count = bfd_canonicalize_symtab(disasm_bfd, disasm_symbols);
assert(sym_count >= 0);
if (dyn_storage) {
dyn_count = bfd_canonicalize_dynamic_symtab(disasm_bfd,
disasm_symbols +
sym_count);
assert(dyn_count >= 0);
}
else
dyn_count = 0;
disasm_num_symbols = sym_count + dyn_count;
disasm_num_synthetic = bfd_get_synthetic_symtab(disasm_bfd,
sym_count,
disasm_symbols,
dyn_count,
disasm_symbols +
sym_count,
&disasm_synthetic);
if (disasm_num_synthetic > 0) {
jit_realloc((jit_pointer_t *)&disasm_symbols,
(sym_storage + dyn_storage) * sizeof(asymbol *),
(sym_storage + dyn_storage + disasm_num_synthetic) *
sizeof(asymbol *));
for (offset = 0; offset < disasm_num_synthetic; offset++)
disasm_symbols[disasm_num_symbols++] =
disasm_synthetic + offset;
}
/* remove symbols not useful for disassemble */
in = out = disasm_symbols;
for (offset = 0; offset < disasm_num_symbols; offset++) {
symbol = *in++;
if (symbol->name &&
symbol->name[0] != '\0' &&
!(symbol->flags & (BSF_DEBUGGING | BSF_SECTION_SYM)) &&
!bfd_is_und_section(symbol->section) &&
!bfd_is_com_section(symbol->section))
*out++ = symbol;
}
disasm_num_symbols = out - disasm_symbols;
qsort(disasm_symbols, disasm_num_symbols,
sizeof(asymbol *), disasm_compare_symbols);
}
}
#endif
}
void
jit_finish_debug(void)
{
#if DISASSEMBLER
if (disasm_synthetic)
jit_free((jit_pointer_t *)&disasm_synthetic);
if (disasm_symbols)
jit_free((jit_pointer_t *)&disasm_symbols);
#endif
}
void
_jit_disassemble(jit_state_t *_jit)
{
#if DISASSEMBLER
if (disasm_bfd) {
# if defined(__arm__)
/* FIXME add mapping for prolog switching to arm and possible jump
* before first prolog also in arm mode */
disasm_info.disassembler_options = jit_cpu.thumb ? "force-thumb" : "";
# endif
disassemble(_jit->code.ptr, _jit->pc.uc - _jit->code.ptr);
}
#endif
}
#if DISASSEMBLER
/* Based on objdump source */
static int
disasm_compare_symbols(const void *ap, const void *bp)
{
const asymbol *a = *(const asymbol **)ap;
const asymbol *b = *(const asymbol **)bp;
if (bfd_asymbol_value(a) > bfd_asymbol_value(b))
return (1);
if (bfd_asymbol_value(a) < bfd_asymbol_value(b))
return (-1);
return (0);
}
#if __WORDSIZE == 32
# define address_buffer_length 16
# define address_buffer_format "%llx"
#else
# define address_buffer_length 32
# define address_buffer_format "%lx"
#endif
static void
disasm_print_address(bfd_vma addr, struct disassemble_info *info)
{
char *name;
char *file;
int line;
char buffer[address_buffer_length];
sprintf(buffer, address_buffer_format, (long long)addr);
(*info->fprintf_func)(info->stream, "0x%s", buffer);
# define _jit disasm_jit
# undef jit_pointer_p
# define jit_pointer_p(u) \
((u) >= _jit->code.ptr && (u) < _jit->pc.uc)
if (jit_pointer_p((jit_uint8_t *)(jit_word_t)addr)) {
if (jit_get_note((jit_uint8_t *)(jit_word_t)addr, &name, &file, &line))
(*info->fprintf_func)(info->stream, " %s:%s:%d",
name ? name : "",
file ? file : "",
line);
}
# undef jit_pointer_p
# undef _jit
else if (disasm_num_symbols) {
long low;
long high;
long offset;
asymbol *symbol;
low = 0;
high = disasm_num_symbols;
do {
offset = (low + high) >> 1;
symbol = disasm_symbols[offset];
if (bfd_asymbol_value(symbol) > addr)
high = offset - 1;
else if (bfd_asymbol_value(symbol) < addr)
low = offset + 1;
else
break;
} while (low < high);
if (offset >= 0 && offset < disasm_num_symbols) {
if (bfd_asymbol_value(symbol) < addr) {
while (++offset < disasm_num_symbols) {
symbol = disasm_symbols[offset];
if (bfd_asymbol_value(symbol) >= addr)
break;
}
}
else if (bfd_asymbol_value(symbol) > addr) {
while (offset--) {
if (bfd_asymbol_value(disasm_symbols[offset]) < addr)
break;
symbol = disasm_symbols[offset];
}
}
if (bfd_asymbol_value(symbol) == addr)
(*info->fprintf_func)(info->stream, " # %s", symbol->name);
}
}
}
static void
_disassemble(jit_state_t *_jit, jit_pointer_t code, jit_int32_t length)
{
int bytes;
char *name, *old_name;
char *file, *old_file;
int line, old_line;
#if __arm__
jit_int32_t offset;
jit_bool_t data_info;
jit_int32_t data_offset;
#endif
bfd_vma pc = (jit_uword_t)code;
bfd_vma end = (jit_uword_t)code + length;
char buffer[address_buffer_length];
#if DEVEL_DISASSEMBLER
jit_node_t *node;
jit_uword_t prevw;
#endif
#if __arm__
data_info = _jitc && _jitc->data_info.ptr;
data_offset = 0;
#endif
disasm_info.buffer = code;
disasm_info.buffer_vma = (jit_uword_t)code;
disasm_info.buffer_length = length;
old_file = old_name = NULL;
old_line = 0;
disasm_jit = _jit;
#if DEVEL_DISASSEMBLER
node = _jitc->head;
prevw = pc;
#endif
while (pc < end) {
#if DEVEL_DISASSEMBLER
while (node && (jit_uword_t)(prevw + node->offset) < (jit_uword_t)pc) {
prevw += node->offset;
node = node->next;
}
while (node && (jit_uword_t)(prevw + node->offset) == (jit_uword_t)pc) {
jit_print_node(node);
fputc('\n', stdout);
prevw += node->offset;
node = node->next;
}
#endif
#if __arm__
again:
if (data_info) {
while (_jitc->data_info.ptr[data_offset].code < pc) {
if (++data_offset >= _jitc->data_info.length) {
data_info = 0;
goto again;
}
}
if (pc == _jitc->data_info.ptr[data_offset].code) {
offset = _jitc->data_info.ptr[data_offset].length;
for (; offset >= 4; offset -= 4, pc += 4) {
bytes = sprintf(buffer, address_buffer_format, pc);
(*disasm_info.fprintf_func)(disasm_stream,
"%*c0x%s\t.data\t0x%08x\n",
16 - bytes, ' ', buffer,
*(jit_uint32_t *)
(jit_uint32_t)pc);
}
/* reset disassemble information instead of attempting
* to hack the arm specific backend data structures to
* tell it to forward the required number of bytes. */
disasm_info.buffer = (jit_pointer_t)(jit_uint32_t)pc;
disasm_info.buffer_vma = (jit_uword_t)pc;
if ((disasm_info.buffer_length = end - pc) <= 0)
break;
}
}
#endif
if (jit_get_note((jit_uint8_t *)(jit_word_t)pc, &name, &file, &line) &&
(name != old_name || file != old_file || line != old_line)) {
(*disasm_info.fprintf_func)(disasm_stream, "# %s:%s:%d\n",
name ? name : "",
file ? file : "",
line);
old_name = name;
old_file = file;
old_line = line;
}
bytes = sprintf(buffer, address_buffer_format, (long long)pc);
(*disasm_info.fprintf_func)(disasm_stream, "%*c0x%s\t",
16 - bytes, ' ', buffer);
pc += (*disasm_print)(pc, &disasm_info);
putc('\n', disasm_stream);
}
}
#endif

2793
jit/jit_hppa-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1039
jit/jit_hppa-fpu.c Normal file
View file

File diff suppressed because it is too large Load diff

402
jit/jit_hppa-sz.c Normal file
View file

@ -0,0 +1,402 @@
#if __WORDSIZE == 32
#define JIT_INSTR_MAX 64
0, /* data */
0, /* live */
0, /* align */
0, /* save */
0, /* load */
0, /* #name */
0, /* #note */
0, /* label */
64, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
0, /* va_start */
0, /* va_arg */
0, /* va_arg_d */
0, /* va_end */
4, /* addr */
12, /* addi */
4, /* addcr */
12, /* addci */
4, /* addxr */
8, /* addxi */
4, /* subr */
12, /* subi */
4, /* subcr */
12, /* subci */
4, /* subxr */
8, /* subxi */
16, /* rsbi */
28, /* mulr */
36, /* muli */
40, /* qmulr */
44, /* qmuli */
32, /* qmulr_u */
40, /* qmuli_u */
36, /* divr */
40, /* divi */
36, /* divr_u */
40, /* divi_u */
40, /* qdivr */
40, /* qdivi */
40, /* qdivr_u */
40, /* qdivi_u */
36, /* remr */
40, /* remi */
36, /* remr_u */
40, /* remi_u */
4, /* andr */
12, /* andi */
4, /* orr */
12, /* ori */
4, /* xorr */
12, /* xori */
12, /* lshr */
4, /* lshi */
12, /* rshr */
4, /* rshi */
12, /* rshr_u */
4, /* rshi_u */
4, /* negr */
4, /* comr */
8, /* ltr */
8, /* lti */
8, /* ltr_u */
8, /* lti_u */
8, /* ler */
8, /* lei */
8, /* ler_u */
8, /* lei_u */
8, /* eqr */
12, /* eqi */
8, /* ger */
8, /* gei */
8, /* ger_u */
8, /* gei_u */
8, /* gtr */
8, /* gti */
8, /* gtr_u */
8, /* gti_u */
8, /* ner */
8, /* nei */
4, /* movr */
8, /* movi */
4, /* extr_c */
4, /* extr_uc */
4, /* extr_s */
4, /* extr_us */
0, /* extr_i */
0, /* extr_ui */
4, /* htonr_us */
4, /* htonr_ui */
0, /* htonr_l */
8, /* ldr_c */
12, /* ldi_c */
4, /* ldr_uc */
8, /* ldi_uc */
8, /* ldr_s */
12, /* ldi_s */
4, /* ldr_us */
8, /* ldi_us */
4, /* ldr_i */
8, /* ldi_i */
0, /* ldr_ui */
0, /* ldi_ui */
0, /* ldr_l */
0, /* ldi_l */
8, /* ldxr_c */
8, /* ldxi_c */
4, /* ldxr_uc */
4, /* ldxi_uc */
8, /* ldxr_s */
8, /* ldxi_s */
4, /* ldxr_us */
4, /* ldxi_us */
4, /* ldxr_i */
4, /* ldxi_i */
0, /* ldxr_ui */
0, /* ldxi_ui */
0, /* ldxr_l */
0, /* ldxi_l */
4, /* str_c */
8, /* sti_c */
4, /* str_s */
8, /* sti_s */
4, /* str_i */
8, /* sti_i */
0, /* str_l */
0, /* sti_l */
8, /* stxr_c */
4, /* stxi_c */
8, /* stxr_s */
4, /* stxi_s */
8, /* stxr_i */
4, /* stxi_i */
0, /* stxr_l */
0, /* stxi_l */
8, /* bltr */
8, /* blti */
8, /* bltr_u */
8, /* blti_u */
8, /* bler */
12, /* blei */
8, /* bler_u */
8, /* blei_u */
8, /* beqr */
16, /* beqi */
8, /* bger */
8, /* bgei */
8, /* bger_u */
8, /* bgei_u */
8, /* bgtr */
8, /* bgti */
8, /* bgtr_u */
8, /* bgti_u */
8, /* bner */
16, /* bnei */
12, /* bmsr */
16, /* bmsi */
12, /* bmcr */
16, /* bmci */
8, /* boaddr */
8, /* boaddi */
8, /* boaddr_u */
8, /* boaddi_u */
8, /* bxaddr */
8, /* bxaddi */
8, /* bxaddr_u */
8, /* bxaddi_u */
12, /* bosubr */
16, /* bosubi */
16, /* bosubr_u */
20, /* bosubi_u */
12, /* bxsubr */
16, /* bxsubi */
16, /* bxsubr_u */
20, /* bxsubi_u */
0, /* jmpr */
12, /* jmpi */
40, /* callr */
44, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
64, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
4, /* addr_f */
16, /* addi_f */
4, /* subr_f */
16, /* subi_f */
16, /* rsbi_f */
4, /* mulr_f */
16, /* muli_f */
4, /* divr_f */
16, /* divi_f */
4, /* negr_f */
4, /* absr_f */
4, /* sqrtr_f */
16, /* ltr_f */
28, /* lti_f */
16, /* ler_f */
28, /* lei_f */
16, /* eqr_f */
28, /* eqi_f */
16, /* ger_f */
28, /* gei_f */
16, /* gtr_f */
28, /* gti_f */
16, /* ner_f */
28, /* nei_f */
16, /* unltr_f */
28, /* unlti_f */
16, /* unler_f */
28, /* unlei_f */
16, /* uneqr_f */
28, /* uneqi_f */
16, /* unger_f */
28, /* ungei_f */
16, /* ungtr_f */
28, /* ungti_f */
16, /* ltgtr_f */
28, /* ltgti_f */
16, /* ordr_f */
28, /* ordi_f */
16, /* unordr_f */
28, /* unordi_f */
12, /* truncr_f_i */
0, /* truncr_f_l */
12, /* extr_f */
4, /* extr_d_f */
4, /* movr_f */
12, /* movi_f */
4, /* ldr_f */
12, /* ldi_f */
4, /* ldxr_f */
4, /* ldxi_f */
4, /* str_f */
12, /* sti_f */
8, /* stxr_f */
4, /* stxi_f */
16, /* bltr_f */
28, /* blti_f */
16, /* bler_f */
28, /* blei_f */
16, /* beqr_f */
28, /* beqi_f */
16, /* bger_f */
28, /* bgei_f */
16, /* bgtr_f */
28, /* bgti_f */
16, /* bner_f */
28, /* bnei_f */
16, /* bunltr_f */
28, /* bunlti_f */
16, /* bunler_f */
28, /* bunlei_f */
16, /* buneqr_f */
28, /* buneqi_f */
16, /* bunger_f */
28, /* bungei_f */
16, /* bungtr_f */
28, /* bungti_f */
16, /* bltgtr_f */
28, /* bltgti_f */
16, /* bordr_f */
28, /* bordi_f */
16, /* bunordr_f */
28, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
4, /* addr_d */
24, /* addi_d */
4, /* subr_d */
24, /* subi_d */
24, /* rsbi_d */
4, /* mulr_d */
24, /* muli_d */
4, /* divr_d */
24, /* divi_d */
4, /* negr_d */
4, /* absr_d */
4, /* sqrtr_d */
16, /* ltr_d */
36, /* lti_d */
16, /* ler_d */
36, /* lei_d */
16, /* eqr_d */
36, /* eqi_d */
16, /* ger_d */
36, /* gei_d */
16, /* gtr_d */
36, /* gti_d */
16, /* ner_d */
36, /* nei_d */
16, /* unltr_d */
36, /* unlti_d */
16, /* unler_d */
36, /* unlei_d */
16, /* uneqr_d */
36, /* uneqi_d */
16, /* unger_d */
36, /* ungei_d */
16, /* ungtr_d */
36, /* ungti_d */
16, /* ltgtr_d */
36, /* ltgti_d */
16, /* ordr_d */
36, /* ordi_d */
16, /* unordr_d */
36, /* unordi_d */
12, /* truncr_d_i */
0, /* truncr_d_l */
12, /* extr_d */
4, /* extr_f_d */
4, /* movr_d */
20, /* movi_d */
4, /* ldr_d */
12, /* ldi_d */
4, /* ldxr_d */
4, /* ldxi_d */
4, /* str_d */
12, /* sti_d */
8, /* stxr_d */
4, /* stxi_d */
16, /* bltr_d */
36, /* blti_d */
16, /* bler_d */
36, /* blei_d */
16, /* beqr_d */
36, /* beqi_d */
16, /* bger_d */
36, /* bgei_d */
16, /* bgtr_d */
36, /* bgti_d */
16, /* bner_d */
36, /* bnei_d */
16, /* bunltr_d */
36, /* bunlti_d */
16, /* bunler_d */
36, /* bunlei_d */
16, /* buneqr_d */
36, /* buneqi_d */
16, /* bunger_d */
36, /* bungei_d */
16, /* bungtr_d */
36, /* bungti_d */
16, /* bltgtr_d */
36, /* bltgti_d */
16, /* bordr_d */
36, /* bordi_d */
16, /* bunordr_d */
36, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
0, /* movr_w_f */
0, /* movr_ww_d */
0, /* movr_w_d */
0, /* movr_f_w */
0, /* movi_f_w */
0, /* movr_d_ww */
0, /* movi_d_ww */
0, /* movr_d_w */
0, /* movi_d_w */
#endif /* __WORDSIZE */

1585
jit/jit_hppa.c Normal file
View file

File diff suppressed because it is too large Load diff

134
jit/jit_hppa.h Normal file
View file

@ -0,0 +1,134 @@
/*
* Copyright (C) 2013-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#ifndef _jit_hppa_h
#define _jit_hppa_h
#define JIT_HASH_CONSTS 1
#define JIT_NUM_OPERANDS 3
/*
* Types
*/
typedef enum {
_R0, /* Always zero */
_R1, /* ADDIL implicit target */
_R2, /* B,L implicit target */
#define jit_r_num() 4
#define jit_r(n) ((n) < 3 ? _R4 + (n) : _R10 + (n) - 3)
#define jit_v_num() 11
#define jit_v(n) ((n) < 3 ? _R7 + (n) : _R11 + (n) - 3)
#define jit_f_num() 8
#define jit_f(n) (_F12 - (n))
#define JIT_FP _R3
#define JIT_R0 _R4
#define JIT_R1 _R5
#define JIT_R2 _R6
#define JIT_R3 _R10
#define JIT_V0 _R7
#define JIT_V1 _R8
#define JIT_V2 _R9
#define JIT_V3 _R11
#define JIT_V4 _R12
#define JIT_V5 _R13
#define JIT_V6 _R14
#define JIT_V7 _R15
#define JIT_V8 _R16
#define JIT_V9 _R17
#define JIT_V10 _R18
_R3,
_R19,
_R20,
_R21,
_R22,
_R29, /* ret1 */
_R28, /* ret0 */
_R4,
_R5,
_R6,
_R7,
_R8,
_R9,
_R10,
_R11,
_R12,
_R13,
_R14,
_R15,
_R16,
_R17,
_R18,
_R23, /* arg3 */
_R24, /* arg2 */
_R25, /* arg1 */
_R26, /* arg0 */
_R27, /* Data Pointer */
_R30, /* Stack Pointer */
_R31, /* Link register */
#define JIT_F0 _F12
#define JIT_F1 _F13
#define JIT_F2 _F14
#define JIT_F3 _F15
#define JIT_F4 _F16
#define JIT_F5 _F17
#define JIT_F6 _F18
#define JIT_F7 _F19
#define JIT_F8 _F20
#define JIT_F9 _F21
/* Caller Saves */
_F31,
_F30,
_F29,
_F28,
_F27,
_F26,
_F25,
_F24,
_F23,
_F22,
_F11,
_F10,
_F9,
_F8,
/* Arguments */
_F7, /* farg3 */
_F6, /* farg2 */
_F5, /* farg1 */
_F4, /* farg0 */
/* Callee Saves */
_F21,
_F20,
_F19,
_F18,
_F17,
_F16,
_F15,
_F14,
_F13,
_F12,
/* Floating-Pointer Status and Exception */
_F0,
_F1,
_F2,
_F3,
#define JIT_NOREG _NOREG
_NOREG,
} jit_reg_t;
#endif /* _jit_hppa */

5415
jit/jit_ia64-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1762
jit/jit_ia64-fpu.c Normal file
View file

File diff suppressed because it is too large Load diff

402
jit/jit_ia64-sz.c Normal file
View file

@ -0,0 +1,402 @@
#if __WORDSIZE == 64
#define JIT_INSTR_MAX 224
0, /* data */
0, /* live */
0, /* align */
0, /* save */
0, /* load */
0, /* #name */
0, /* #note */
0, /* label */
224, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
16, /* va_start */
32, /* va_arg */
32, /* va_arg_d */
0, /* va_end */
16, /* addr */
32, /* addi */
32, /* addcr */
48, /* addci */
64, /* addxr */
64, /* addxi */
16, /* subr */
32, /* subi */
32, /* subcr */
48, /* subci */
64, /* subxr */
64, /* subxi */
32, /* rsbi */
48, /* mulr */
64, /* muli */
112, /* qmulr */
112, /* qmuli */
112, /* qmulr_u */
112, /* qmuli_u */
80, /* divr */
96, /* divi */
80, /* divr_u */
96, /* divi_u */
144, /* qdivr */
144, /* qdivi */
144, /* qdivr_u */
144, /* qdivi_u */
80, /* remr */
96, /* remi */
80, /* remr_u */
96, /* remi_u */
16, /* andr */
32, /* andi */
16, /* orr */
32, /* ori */
16, /* xorr */
32, /* xori */
16, /* lshr */
16, /* lshi */
16, /* rshr */
16, /* rshi */
16, /* rshr_u */
16, /* rshi_u */
16, /* negr */
16, /* comr */
32, /* ltr */
32, /* lti */
32, /* ltr_u */
32, /* lti_u */
32, /* ler */
32, /* lei */
32, /* ler_u */
32, /* lei_u */
32, /* eqr */
32, /* eqi */
32, /* ger */
32, /* gei */
32, /* ger_u */
32, /* gei_u */
32, /* gtr */
32, /* gti */
32, /* gtr_u */
32, /* gti_u */
32, /* ner */
32, /* nei */
16, /* movr */
16, /* movi */
16, /* extr_c */
16, /* extr_uc */
16, /* extr_s */
16, /* extr_us */
16, /* extr_i */
16, /* extr_ui */
64, /* htonr_us */
160, /* htonr_ui */
16, /* htonr_ul */
16, /* ldr_c */
32, /* ldi_c */
16, /* ldr_uc */
32, /* ldi_uc */
16, /* ldr_s */
32, /* ldi_s */
16, /* ldr_us */
32, /* ldi_us */
16, /* ldr_i */
32, /* ldi_i */
16, /* ldr_ui */
32, /* ldi_ui */
16, /* ldr_l */
32, /* ldi_l */
32, /* ldxr_c */
48, /* ldxi_c */
16, /* ldxr_uc */
32, /* ldxi_uc */
32, /* ldxr_s */
48, /* ldxi_s */
16, /* ldxr_us */
32, /* ldxi_us */
32, /* ldxr_i */
48, /* ldxi_i */
16, /* ldxr_ui */
32, /* ldxi_ui */
16, /* ldxr_l */
32, /* ldxi_l */
16, /* str_c */
32, /* sti_c */
16, /* str_s */
32, /* sti_s */
16, /* str_i */
32, /* sti_i */
16, /* str_l */
32, /* sti_l */
16, /* stxr_c */
32, /* stxi_c */
16, /* stxr_s */
32, /* stxi_s */
16, /* stxr_i */
32, /* stxi_i */
16, /* stxr_l */
32, /* stxi_l */
32, /* bltr */
32, /* blti */
32, /* bltr_u */
32, /* blti_u */
32, /* bler */
32, /* blei */
32, /* bler_u */
32, /* blei_u */
32, /* beqr */
48, /* beqi */
32, /* bger */
32, /* bgei */
32, /* bger_u */
32, /* bgei_u */
32, /* bgtr */
32, /* bgti */
32, /* bgtr_u */
32, /* bgti_u */
32, /* bner */
48, /* bnei */
32, /* bmsr */
48, /* bmsi */
32, /* bmcr */
48, /* bmci */
96, /* boaddr */
112, /* boaddi */
64, /* boaddr_u */
64, /* boaddi_u */
96, /* bxaddr */
112, /* bxaddi */
64, /* bxaddr_u */
64, /* bxaddi_u */
112, /* bosubr */
112, /* bosubi */
64, /* bosubr_u */
64, /* bosubi_u */
112, /* bxsubr */
112, /* bxsubi */
64, /* bxsubr_u */
64, /* bxsubi_u */
16, /* jmpr */
16, /* jmpi */
32, /* callr */
48, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
128, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
16, /* addr_f */
48, /* addi_f */
16, /* subr_f */
48, /* subi_f */
48, /* rsbi_f */
16, /* mulr_f */
48, /* muli_f */
160, /* divr_f */
192, /* divi_f */
16, /* negr_f */
16, /* absr_f */
80, /* sqrtr_f */
32, /* ltr_f */
64, /* lti_f */
32, /* ler_f */
64, /* lei_f */
32, /* eqr_f */
64, /* eqi_f */
32, /* ger_f */
64, /* gei_f */
32, /* gtr_f */
64, /* gti_f */
32, /* ner_f */
64, /* nei_f */
32, /* unltr_f */
64, /* unlti_f */
32, /* unler_f */
64, /* unlei_f */
48, /* uneqr_f */
96, /* uneqi_f */
32, /* unger_f */
64, /* ungei_f */
32, /* ungtr_f */
64, /* ungti_f */
48, /* ltgtr_f */
96, /* ltgti_f */
32, /* ordr_f */
64, /* ordi_f */
32, /* unordr_f */
64, /* unordi_f */
32, /* truncr_f_i */
32, /* truncr_f_l */
48, /* extr_f */
16, /* extr_d_f */
16, /* movr_f */
32, /* movi_f */
16, /* ldr_f */
32, /* ldi_f */
16, /* ldxr_f */
32, /* ldxi_f */
16, /* str_f */
32, /* sti_f */
16, /* stxr_f */
32, /* stxi_f */
32, /* bltr_f */
64, /* blti_f */
32, /* bler_f */
64, /* blei_f */
32, /* beqr_f */
64, /* beqi_f */
32, /* bger_f */
64, /* bgei_f */
32, /* bgtr_f */
64, /* bgti_f */
32, /* bner_f */
64, /* bnei_f */
32, /* bunltr_f */
64, /* bunlti_f */
32, /* bunler_f */
64, /* bunlei_f */
80, /* buneqr_f */
112, /* buneqi_f */
32, /* bunger_f */
64, /* bungei_f */
32, /* bungtr_f */
64, /* bungti_f */
80, /* bltgtr_f */
112, /* bltgti_f */
32, /* bordr_f */
64, /* bordi_f */
32, /* bunordr_f */
64, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
16, /* addr_d */
48, /* addi_d */
16, /* subr_d */
48, /* subi_d */
48, /* rsbi_d */
16, /* mulr_d */
48, /* muli_d */
160, /* divr_d */
192, /* divi_d */
16, /* negr_d */
16, /* absr_d */
80, /* sqrtr_d */
32, /* ltr_d */
64, /* lti_d */
32, /* ler_d */
64, /* lei_d */
32, /* eqr_d */
64, /* eqi_d */
32, /* ger_d */
64, /* gei_d */
32, /* gtr_d */
64, /* gti_d */
32, /* ner_d */
64, /* nei_d */
32, /* unltr_d */
64, /* unlti_d */
32, /* unler_d */
64, /* unlei_d */
48, /* uneqr_d */
96, /* uneqi_d */
32, /* unger_d */
64, /* ungei_d */
32, /* ungtr_d */
64, /* ungti_d */
48, /* ltgtr_d */
96, /* ltgti_d */
32, /* ordr_d */
64, /* ordi_d */
32, /* unordr_d */
64, /* unordi_d */
32, /* truncr_d_i */
32, /* truncr_d_l */
48, /* extr_d */
16, /* extr_f_d */
16, /* movr_d */
32, /* movi_d */
16, /* ldr_d */
32, /* ldi_d */
16, /* ldxr_d */
32, /* ldxi_d */
16, /* str_d */
32, /* sti_d */
16, /* stxr_d */
32, /* stxi_d */
32, /* bltr_d */
64, /* blti_d */
32, /* bler_d */
64, /* blei_d */
32, /* beqr_d */
64, /* beqi_d */
32, /* bger_d */
64, /* bgei_d */
32, /* bgtr_d */
64, /* bgti_d */
32, /* bner_d */
64, /* bnei_d */
32, /* bunltr_d */
64, /* bunlti_d */
32, /* bunler_d */
64, /* bunlei_d */
80, /* buneqr_d */
112, /* buneqi_d */
32, /* bunger_d */
64, /* bungei_d */
32, /* bungtr_d */
64, /* bungti_d */
80, /* bltgtr_d */
112, /* bltgti_d */
32, /* bordr_d */
64, /* bordi_d */
32, /* bunordr_d */
64, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
0, /* movr_w_f */
0, /* movr_ww_d */
0, /* movr_w_d */
0, /* movr_f_w */
0, /* movi_f_w */
0, /* movr_d_ww */
0, /* movi_d_ww */
16, /* movr_d_w */
32, /* movi_d_w */
#endif /* __WORDSIZE */

1771
jit/jit_ia64.c Normal file
View file

File diff suppressed because it is too large Load diff

120
jit/jit_ia64.h Normal file
View file

@ -0,0 +1,120 @@
/*
* Copyright (C) 2013-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#ifndef _jit_ia64_h
#define _jit_ia64_h
#define JIT_HASH_CONSTS 1
#define JIT_NUM_OPERANDS 3
/*
* Types
*/
#define JIT_FP _R4 /* Not abi specific */
typedef enum {
#define JIT_R0 _R40
#define JIT_R1 _R41
#define JIT_R2 _R42
#define JIT_R3 _R43
#define JIT_V0 _R44
#define JIT_V1 _R45
#define JIT_V2 _R46
#define JIT_V3 _R47
#define jit_r_num() 4
#define jit_r(n) (_R40 + (n))
#define jit_v_num() 4
#define jit_v(n) (_R44 + (n))
_R0, /* constant - Always 0 */
_R1, /* special - Global Data pointer (gp) */
/* r2-r3 - scratch - Use with 22-bit immediate add - scratch */
_R2, _R3,
/* r4-r7 - preserved */
_R4, _R5, _R6, _R7,
_R8, /* scratch - Return value; structure/union return pointer */
/* r9-r11 - scratch - Return values */
_R9, _R10, _R11,
_R12, /* special - Memory stack pointer (sp) */
_R13, /* special - Reserved as a thread pointer (tp)*/
/* r14-r31 - scratch */
_R31, _R30,
_R29, _R28, _R27, _R26, _R25, _R24, _R23, _R22,
_R21, _R20, _R19, _R18, _R17, _R16, _R15, _R14,
/* r32-r39 - aka in0-in7 - Incoming register arguments */
_R32, _R33, _R34, _R35, _R36, _R37, _R38, _R39,
/* r40-r127 - loc0...locn,out0...outn */
_R40, _R41, _R42, _R43, _R44, _R45, _R46, _R47,
_R48, _R49, _R50, _R51, _R52, _R53, _R54, _R55,
_R56, _R57, _R58, _R59, _R60, _R61, _R62, _R63,
_R64, _R65, _R66, _R67, _R68, _R69, _R70, _R71,
_R72, _R73, _R74, _R75, _R76, _R77, _R78, _R79,
_R80, _R81, _R82, _R83, _R84, _R85, _R86, _R87,
_R88, _R89, _R90, _R91, _R92, _R93, _R94, _R95,
_R96, _R97, _R98, _R99, _R100, _R101, _R102, _R103,
_R104, _R105, _R106, _R107, _R108, _R109, _R110, _R111,
_R112, _R113, _R114, _R115, _R116, _R117, _R118, _R119,
_R120, _R121, _R122, _R123, _R124, _R125, _R126, _R127,
#define JIT_F0 _F16
#define JIT_F1 _F17
#define JIT_F2 _F18
#define JIT_F3 _F19
#define JIT_F4 _F20
#define JIT_F5 _F21
#define jit_f_num() 6
#define jit_f(n) (_F16 + (n))
_F0, /* constant - Always 0.0 */
_F1, /* constant - Always 1.0 */
/* f2-f5 - preserved */
_F2, _F3, _F4, _F5,
/* f6-f7 - scratch */
_F6, _F7,
/* f8-f15 - scratch - Argument/return registers */
_F8, _F9, _F10, _F11, _F12, _F13, _F14, _F15,
/* f16-f31 - preserved */
_F16, _F17, _F18, _F19, _F20, _F21, _F22, _F23,
_F24, _F25, _F26, _F27, _F28, _F29, _F30, _F31,
/* f32-f127 - scratch - Rotating registers or scratch */
_F32, _F33, _F34, _F35, _F36, _F37, _F38, _F39,
_F40, _F41, _F42, _F43, _F44, _F45, _F46, _F47,
_F48, _F49, _F50, _F51, _F52, _F53, _F54, _F55,
_F56, _F57, _F58, _F59, _F60, _F61, _F62, _F63,
_F64, _F65, _F66, _F67, _F68, _F69, _F70, _F71,
_F72, _F73, _F74, _F75, _F76, _F77, _F78, _F79,
_F80, _F81, _F82, _F83, _F84, _F85, _F86, _F87,
_F88, _F89, _F90, _F91, _F92, _F93, _F94, _F95,
_F96, _F97, _F98, _F99, _F100, _F101, _F102, _F103,
_F104, _F105, _F106, _F107, _F108, _F109, _F110, _F111,
_F112, _F113, _F114, _F115, _F116, _F117, _F118, _F119,
#if 0
/* Do not list these to not need an unique identifier larger
* than 255 for jit_regset_t */
_F120, _F121, _F122, _F123, _F124, _F125, _F126, _F127,
#endif
/* Fake registers. Required because while "in" parameters start at r32,
* "out" parameters start *after* registers allocated for temporaries,
* and that are supposed to kept alive (what is desirable, that is, to
* not spill/reload them in memory) */
_OUT0, _OUT1, _OUT2, _OUT3, _OUT4, _OUT5, _OUT6, _OUT7,
#define JIT_NOREG _NOREG
_NOREG,
} jit_reg_t;
#endif /* _jit_ia64_h */

124
jit/jit_memory.c Normal file
View file

@ -0,0 +1,124 @@
/*
* Copyright (C) 2013-2018 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#include <sys/mman.h>
#include "jit.h"
#include "jit/jit_private.h"
/*
* Prototypes
*/
static void *jit_default_alloc_func(size_t);
static void *jit_default_realloc_func(void*, size_t);
static void jit_default_free_func(void *);
/*
* Initialization
*/
static jit_alloc_func_ptr jit_alloc_ptr = jit_default_alloc_func;
static jit_realloc_func_ptr jit_realloc_ptr = jit_default_realloc_func;
static jit_free_func_ptr jit_free_ptr = jit_default_free_func;
/*
* Implementation
*/
jit_pointer_t
jit_memcpy(jit_pointer_t dst, const void * src, jit_word_t size)
{
if (size)
return (memcpy(dst, src, size));
return (dst);
}
jit_pointer_t
jit_memmove(jit_pointer_t dst, const void *src , jit_word_t size)
{
if (size)
return (memmove(dst, src, size));
return (dst);
}
void
jit_set_memory_functions(jit_alloc_func_ptr alloc_ptr,
jit_realloc_func_ptr realloc_ptr,
jit_free_func_ptr free_ptr)
{
if (alloc_ptr == NULL)
alloc_ptr = jit_default_alloc_func;
if (realloc_ptr == NULL)
realloc_ptr = jit_default_realloc_func;
if (free_ptr == NULL)
free_ptr = jit_default_free_func;
jit_alloc_ptr = alloc_ptr;
jit_realloc_ptr = realloc_ptr;
jit_free_ptr = free_ptr;
}
void
jit_get_memory_functions(jit_alloc_func_ptr *alloc_ptr,
jit_realloc_func_ptr *realloc_ptr,
jit_free_func_ptr *free_ptr)
{
*alloc_ptr = jit_alloc_ptr;
*realloc_ptr = jit_realloc_ptr;
*free_ptr = jit_free_ptr;
}
void
jit_alloc(jit_pointer_t *ptr, jit_word_t size)
{
*ptr = (*jit_alloc_ptr)(size);
memset(*ptr, 0, size);
}
void
jit_realloc(jit_pointer_t *ptr, jit_word_t old_size, jit_word_t new_size)
{
*ptr = (*jit_realloc_ptr)(*ptr, new_size);
if (old_size < new_size)
memset((jit_int8_t*)*ptr + old_size, 0, new_size - old_size);
}
void
jit_free(jit_pointer_t *ptr)
{
if (*ptr) {
(*jit_free_ptr)(*ptr);
*ptr = NULL;
}
}
static void *
jit_default_alloc_func(size_t size)
{
return (malloc(size));
}
static void *
jit_default_realloc_func(void *ptr, size_t size)
{
return (realloc(ptr, size));
}
static void
jit_default_free_func(void *ptr)
{
free(ptr);
}

3153
jit/jit_mips-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1844
jit/jit_mips-fpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1210
jit/jit_mips-sz.c Normal file
View file

File diff suppressed because it is too large Load diff

1929
jit/jit_mips.c Normal file
View file

File diff suppressed because it is too large Load diff

115
jit/jit_mips.h Normal file
View file

@ -0,0 +1,115 @@
/*
* Copyright (C) 2012-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#ifndef _jit_mips_h
#define _jit_mips_h
#define JIT_HASH_CONSTS 1
#define JIT_NUM_OPERANDS 3
#if _MIPS_SIM != _ABIO32
# define NEW_ABI 1
#endif
/*
* Types
*/
#define JIT_FP _FP
typedef enum {
#define jit_r(i) (_V0 + (i))
#if NEW_ABI
# define jit_r_num() 7
#else
# define jit_r_num() 11
#endif
#define jit_v(i) (_S0 + (i))
#define jit_v_num() 8
#define jit_f(i) (_F0 + (i))
#if NEW_ABI
# define jit_f_num() 6
#else
# define jit_f_num() 8
#endif
_AT,
#define JIT_R0 _V0
#define JIT_R1 _V1
#if NEW_ABI
# define JIT_R2 _T4
# define JIT_R3 _T5
# define JIT_R4 _T6
# define JIT_R5 _T7
# define JIT_R6 _T8
#else
# 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
#endif
_V0, _V1,
#if !NEW_ABI
_T0, _T1, _T2, _T3,
#endif
_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,
_SP, _FP,
#if NEW_ABI
_A7, _A6, _A5, _A4,
#endif
_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
#if !NEW_ABI
# define JIT_F6 _F16
# define JIT_F7 _F18
#endif
_F0, _F2, _F4, _F6, _F8, _F10,
/* callee save float registers */
#if !NEW_ABI
_F16, _F18,
#endif
_F20, _F22, _F24, _F26, _F28, _F30,
#if NEW_ABI
_F19, _F18, _F17, _F16, _F15, _F14, _F13, _F12,
#else
_F14, _F12,
#endif
#define JIT_NOREG _NOREG
_NOREG,
} jit_reg_t;
#endif /* _jit_mips_h */

230
jit/jit_names.c Normal file
View file

@ -0,0 +1,230 @@
/*
* Copyright (C) 2014-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
static char *code_name[] = {
"data",
"live", "align",
"save", "load",
"#name", "#note",
"label",
"prolog",
"ellipsis", "va_push",
"allocai", "allocar",
"arg",
"getarg_c", "getarg_uc",
"getarg_s", "getarg_us",
"getarg_i", "getarg_ui",
"getarg_l",
"putargr", "putargi",
"va_start",
"va_arg", "va_arg_d",
"va_end",
"addr", "addi",
"addcr", "addci",
"addxr", "addxi",
"subr", "subi",
"subcr", "subci",
"subxr", "subxi",
"rsbi",
"mulr", "muli",
"qmulr", "qmuli",
"qmulr_u", "qmuli_u",
"divr", "divi",
"divr_u", "divi_u",
"qdivr", "qdivi",
"qdivr_u", "qdivi_u",
"remr", "remi",
"remr_u", "remi_u",
"andr", "andi",
"orr", "ori",
"xorr", "xori",
"lshr", "lshi",
"rshr", "rshi",
"rshr_u", "rshi_u",
"negr", "comr",
"ltr", "lti",
"ltr_u", "lti_u",
"ler", "lei",
"ler_u", "lei_u",
"eqr", "eqi",
"ger", "gei",
"ger_u", "gei_u",
"gtr", "gti",
"gtr_u", "gti_u",
"ner", "nei",
"movr", "movi",
"extr_c", "extr_uc",
"extr_s", "extr_us",
"extr_i", "extr_ui",
"htonr_us",
"htonr_ui", "htonr_ul",
"ldr_c", "ldi_c",
"ldr_uc", "ldi_uc",
"ldr_s", "ldi_s",
"ldr_us", "ldi_us",
"ldr_i", "ldi_i",
"ldr_ui", "ldi_ui",
"ldr_l", "ldi_l",
"ldxr_c", "ldxi_c",
"ldxr_uc", "ldxi_uc",
"ldxr_s", "ldxi_s",
"ldxr_us", "ldxi_us",
"ldxr_i", "ldxi_i",
"ldxr_ui", "ldxi_ui",
"ldxr_l", "ldxi_l",
"str_c", "sti_c",
"str_s", "sti_s",
"str_i", "sti_i",
"str_l", "sti_l",
"stxr_c", "stxi_c",
"stxr_s", "stxi_s",
"stxr_i", "stxi_i",
"stxr_l", "stxi_l",
"bltr", "blti",
"bltr_u", "blti_u",
"bler", "blei",
"bler_u", "blei_u",
"beqr", "beqi",
"bger", "bgei",
"bger_u", "bgei_u",
"bgtr", "bgti",
"bgtr_u", "bgti_u",
"bner", "bnei",
"bmsr", "bmsi",
"bmcr", "bmci",
"boaddr", "boaddi",
"boaddr_u", "boaddi_u",
"bxaddr", "bxaddi",
"bxaddr_u", "bxaddi_u",
"bosubr", "bosubi",
"bosubr_u", "bosubi_u",
"bxsubr", "bxsubi",
"bxsubr_u", "bxsubi_u",
"jmpr", "jmpi",
"callr", "calli",
"prepare",
"pushargr", "pushargi",
"finishr", "finishi",
"ret",
"retr", "reti",
"retval_c", "retval_uc",
"retval_s", "retval_us",
"retval_i", "retval_ui",
"retval_l",
"epilog",
"arg_f", "getarg_f",
"putargr_f", "putargi_f",
"addr_f", "addi_f",
"subr_f", "subi_f",
"rsbi_f",
"mulr_f", "muli_f",
"divr_f", "divi_f",
"negr_f", "absr_f",
"sqrtr_f",
"ltr_f", "lti_f",
"ler_f", "lei_f",
"eqr_f", "eqi_f",
"ger_f", "gei_f",
"gtr_f", "gti_f",
"ner_f", "nei_f",
"unltr_f", "unlti_f",
"unler_f", "unlei_f",
"uneqr_f", "uneqi_f",
"unger_f", "ungei_f",
"ungtr_f", "ungti_f",
"ltgtr_f", "ltgti_f",
"ordr_f", "ordi_f",
"unordr_f", "unordi_f",
"truncr_f_i", "truncr_f_l",
"extr_f", "extr_d_f",
"movr_f", "movi_f",
"ldr_f", "ldi_f",
"ldxr_f", "ldxi_f",
"str_f", "sti_f",
"stxr_f", "stxi_f",
"bltr_f", "blti_f",
"bler_f", "blei_f",
"beqr_f", "beqi_f",
"bger_f", "bgei_f",
"bgtr_f", "bgti_f",
"bner_f", "bnei_f",
"bunltr_f", "bunlti_f",
"bunler_f", "bunlei_f",
"buneqr_f", "buneqi_f",
"bunger_f", "bungei_f",
"bungtr_f", "bungti_f",
"bltgtr_f", "bltgti_f",
"bordr_f", "bordi_f",
"bunordr_f", "bunordi_f",
"pushargr_f", "pushargi_f",
"retr_f", "reti_f",
"retval_f",
"arg_d", "getarg_d",
"putargr_d", "putargi_d",
"addr_d", "addi_d",
"subr_d", "subi_d",
"rsbi_d",
"mulr_d", "muli_d",
"divr_d", "divi_d",
"negr_d", "absr_d",
"sqrtr_d",
"ltr_d", "lti_d",
"ler_d", "lei_d",
"eqr_d", "eqi_d",
"ger_d", "gei_d",
"gtr_d", "gti_d",
"ner_d", "nei_d",
"unltr_d", "unlti_d",
"unler_d", "unlei_d",
"uneqr_d", "uneqi_d",
"unger_d", "ungei_d",
"ungtr_d", "ungti_d",
"ltgtr_d", "ltgti_d",
"ordr_d", "ordi_d",
"unordr_d", "unordi_d",
"truncr_d_i", "truncr_d_l",
"extr_d", "extr_f_d",
"movr_d", "movi_d",
"ldr_d", "ldi_d",
"ldxr_d", "ldxi_d",
"str_d", "sti_d",
"stxr_d", "stxi_d",
"bltr_d", "blti_d",
"bler_d", "blei_d",
"beqr_d", "beqi_d",
"bger_d", "bgei_d",
"bgtr_d", "bgti_d",
"bner_d", "bnei_d",
"bunltr_d", "bunlti_d",
"bunler_d", "bunlei_d",
"buneqr_d", "buneqi_d",
"bunger_d", "bungei_d",
"bungtr_d", "bungti_d",
"bltgtr_d", "bltgti_d",
"bordr_d", "bordi_d",
"bunordr_d", "bunordi_d",
"pushargr_d", "pushargi_d",
"retr_d", "reti_d",
"retval_d",
"movr_w_f", "movr_ww_d",
"movr_w_d",
"movr_f_w", "movi_f_w",
"movr_d_ww", "movi_d_ww",
"movr_d_w", "movi_d_w",
};

414
jit/jit_note.c Normal file
View file

@ -0,0 +1,414 @@
/*
* Copyright (C) 2013-2018 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#include "jit.h"
#include "jit/jit_private.h"
/*
* Prototypes
*/
#define new_note(u, v) _new_note(_jit, u, v)
static jit_note_t *_new_note(jit_state_t *, jit_uint8_t*, char*);
static void new_line(jit_int32_t,jit_note_t*,char*,jit_int32_t,jit_int32_t);
#define note_search_index(u) _note_search_index(_jit, u)
static jit_int32_t _note_search_index(jit_state_t*, jit_uint8_t*);
static jit_int32_t line_insert_index(jit_note_t*,jit_int32_t);
static jit_int32_t line_search_index(jit_note_t*,jit_int32_t);
static jit_int32_t offset_insert_index(jit_line_t*,jit_int32_t);
static jit_int32_t offset_search_index(jit_line_t*,jit_int32_t);
/*
* Implementation
*/
void
jit_init_note(void)
{
}
void
jit_finish_note(void)
{
}
jit_node_t *
_jit_name(jit_state_t *_jit, const char *name)
{
jit_node_t *node;
node = jit_new_node(jit_code_name);
if (name)
node->v.n = jit_data(name, strlen(name) + 1, 1);
else
node->v.p = NULL;
if (_jitc->note.head == NULL)
_jitc->note.head = _jitc->note.tail = node;
else {
_jitc->note.tail->link = node;
_jitc->note.tail = node;
}
++_jit->note.length;
_jitc->note.size += sizeof(jit_note_t);
/* remember previous note is invalid due to name change */
_jitc->note.note = NULL;
return (_jitc->note.name = node);
}
jit_node_t *
_jit_note(jit_state_t *_jit, const char *name, int line)
{
jit_node_t *node;
node = jit_new_node(jit_code_note);
if (name)
node->v.n = jit_data(name, strlen(name) + 1, 1);
else
node->v.p = NULL;
node->w.w = line;
if (_jitc->note.head == NULL)
_jitc->note.head = _jitc->note.tail = node;
else {
_jitc->note.tail->link = node;
_jitc->note.tail = node;
}
if (_jitc->note.note == NULL ||
(name == NULL && _jitc->note.note != NULL) ||
(name != NULL && _jitc->note.note == NULL) ||
(name != NULL && _jitc->note.note != NULL &&
strcmp(name, (char *)_jitc->data.ptr + _jitc->note.note->v.n->u.w)))
_jitc->note.size += sizeof(jit_line_t);
_jitc->note.size += sizeof(jit_int32_t) * 2;
return (_jitc->note.note = node);
}
void
_jit_annotate(jit_state_t *_jit)
{
jit_node_t *node;
jit_note_t *note;
jit_line_t *line;
jit_word_t length;
jit_word_t note_offset;
jit_word_t line_offset;
/* initialize pointers in mmaped data area */
_jit->note.ptr = (jit_note_t *)_jitc->note.base;
_jit->note.length = 0;
note = NULL;
for (node = _jitc->note.head; node; node = node->link) {
if (node->code == jit_code_name)
note = new_note(node->u.p, node->v.p ? node->v.n->u.p : NULL);
else if (node->v.p) {
if (note == NULL)
note = new_note(node->u.p, NULL);
jit_set_note(note, node->v.n->u.p, node->w.w,
(jit_uint8_t *)node->u.p - note->code);
}
}
/* last note */
if (note)
note->size = _jit->pc.uc - note->code;
/* annotations may be very complex with conditions to extend
* or ignore redundant notes, as well as add entries to earlier
* notes, so, relocate the information to the data buffer,
* with likely over allocated reserved space */
/* relocate jit_line_t objects */
for (note_offset = 0; note_offset < _jit->note.length; note_offset++) {
note = _jit->note.ptr + note_offset;
if ((length = sizeof(jit_line_t) * note->length) == 0)
continue;
assert(_jitc->note.base + length < _jit->data.ptr + _jit->data.length);
jit_memcpy(_jitc->note.base, note->lines, length);
jit_free((jit_pointer_t *)&note->lines);
note->lines = (jit_line_t *)_jitc->note.base;
_jitc->note.base += length;
}
/* relocate offset and line number information */
for (note_offset = 0; note_offset < _jit->note.length; note_offset++) {
note = _jit->note.ptr + note_offset;
for (line_offset = 0; line_offset < note->length; line_offset++) {
line = note->lines + line_offset;
length = sizeof(jit_int32_t) * line->length;
assert(_jitc->note.base + length <
_jit->data.ptr + _jit->data.length);
jit_memcpy(_jitc->note.base, line->linenos, length);
jit_free((jit_pointer_t *)&line->linenos);
line->linenos = (jit_int32_t *)_jitc->note.base;
_jitc->note.base += length;
assert(_jitc->note.base + length <
_jit->data.ptr + _jit->data.length);
jit_memcpy(_jitc->note.base, line->offsets, length);
jit_free((jit_pointer_t *)&line->offsets);
line->offsets = (jit_int32_t *)_jitc->note.base;
_jitc->note.base += length;
}
}
}
void
_jit_set_note(jit_state_t *_jit, jit_note_t *note,
char *file, int lineno, jit_int32_t offset)
{
jit_line_t *line;
jit_int32_t index;
index = line_insert_index(note, offset);
if (note->length && index == note->length &&
note->lines[index - 1].file == file)
--index;
if (index >= note->length || note->lines[index].file != file)
new_line(index, note, file, lineno, offset);
else {
line = note->lines + index;
index = offset_insert_index(line, offset);
if (index < line->length && line->offsets[index] == offset) {
/* common case if no code was generated for several source lines */
if (line->linenos[index] < lineno)
line->linenos[index] = lineno;
}
else if (index < line->length && line->linenos[index] == lineno) {
/* common case of extending entry */
if (line->offsets[index] > offset)
line->offsets[index] = offset;
}
else {
/* line or offset changed */
if ((line->length & 15) == 0) {
jit_realloc((jit_pointer_t *)&line->linenos,
line->length * sizeof(jit_int32_t),
(line->length + 17) * sizeof(jit_int32_t));
jit_realloc((jit_pointer_t *)&line->offsets,
line->length * sizeof(jit_int32_t),
(line->length + 17) * sizeof(jit_int32_t));
}
if (index < note->length) {
jit_memmove(line->linenos + index + 1, line->linenos + index,
sizeof(jit_int32_t) * (line->length - index));
jit_memmove(line->offsets + index + 1, line->offsets + index,
sizeof(jit_int32_t) * (line->length - index));
}
line->linenos[index] = lineno;
line->offsets[index] = offset;
++line->length;
}
}
}
jit_bool_t
_jit_get_note(jit_state_t *_jit, jit_pointer_t code,
char **name, char **file, jit_int32_t *lineno)
{
jit_note_t *note;
jit_line_t *line;
jit_int32_t index;
jit_int32_t offset;
if ((index = note_search_index((jit_uint8_t *)code)) >= _jit->note.length)
return (0);
note = _jit->note.ptr + index;
if ((jit_uint8_t *)code < note->code ||
(jit_uint8_t *)code >= note->code + note->size)
return (0);
offset = (jit_uint8_t *)code - note->code;
if ((index = line_search_index(note, offset)) >= note->length)
return (0);
if (index == 0 && offset < note->lines[0].offsets[0])
return (0);
line = note->lines + index;
if ((index = offset_search_index(line, offset)) >= line->length)
return (0);
if (name)
*name = note->name;
if (file)
*file = line->file;
if (lineno)
*lineno = line->linenos[index];
return (1);
}
static jit_note_t *
_new_note(jit_state_t *_jit, jit_uint8_t *code, char *name)
{
jit_note_t *note;
jit_note_t *prev;
if (_jit->note.length) {
prev = _jit->note.ptr + _jit->note.length - 1;
assert(code >= prev->code);
prev->size = code - prev->code;
}
note = (jit_note_t *)_jitc->note.base;
_jitc->note.base += sizeof(jit_note_t);
++_jit->note.length;
note->code = code;
note->name = name;
return (note);
}
static void
new_line(jit_int32_t index, jit_note_t *note,
char *file, jit_int32_t lineno, jit_int32_t offset)
{
jit_line_t *line;
if (note->lines == NULL)
jit_alloc((jit_pointer_t *)&note->lines, 16 * sizeof(jit_line_t));
else if ((note->length & 15) == 15)
jit_realloc((jit_pointer_t *)&note->lines,
note->length * sizeof(jit_line_t),
(note->length + 17) * sizeof(jit_line_t));
if (index < note->length)
jit_memmove(note->lines + index + 1, note->lines + index,
sizeof(jit_line_t) * (note->length - index));
line = note->lines + index;
++note->length;
line->file = file;
line->length = 1;
jit_alloc((jit_pointer_t *)&line->linenos, 16 * sizeof(jit_int32_t));
line->linenos[0] = lineno;
jit_alloc((jit_pointer_t *)&line->offsets, 16 * sizeof(jit_int32_t));
line->offsets[0] = offset;
}
static jit_int32_t
_note_search_index(jit_state_t *_jit, jit_uint8_t *code)
{
jit_int32_t bot;
jit_int32_t top;
jit_int32_t index;
jit_note_t *notes;
bot = 0;
top = _jit->note.length;
notes = _jit->note.ptr;
for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
if (code < notes[index].code)
top = index;
else if (code >= notes[index].code &&
code - notes[index].code < notes[index].size)
break;
else
bot = index + 1;
}
return (index);
}
static jit_int32_t
line_insert_index(jit_note_t *note, jit_int32_t offset)
{
jit_int32_t bot;
jit_int32_t top;
jit_int32_t index;
jit_line_t *lines;
bot = 0;
top = note->length;
if ((lines = note->lines) == NULL)
return (0);
for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
if (offset < *lines[index].offsets)
top = index;
else
bot = index + 1;
}
return ((bot + top) >> 1);
}
static jit_int32_t
line_search_index(jit_note_t *note, jit_int32_t offset)
{
jit_int32_t bot;
jit_int32_t top;
jit_int32_t index;
jit_line_t *lines;
bot = 0;
top = note->length;
if ((lines = note->lines) == NULL)
return (0);
for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
if (offset < *lines[index].offsets)
top = index;
/* offset should be already verified to be in range */
else if (index == note->length - 1 ||
(offset >= *lines[index].offsets &&
offset < *lines[index + 1].offsets))
break;
else
bot = index + 1;
}
return (index);
}
static jit_int32_t
offset_insert_index(jit_line_t *line, jit_int32_t offset)
{
jit_int32_t bot;
jit_int32_t top;
jit_int32_t index;
jit_int32_t *offsets;
bot = 0;
top = line->length;
offsets = line->offsets;
for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
if (offset < offsets[index])
top = index;
else
bot = index + 1;
}
return ((bot + top) >> 1);
}
static jit_int32_t
offset_search_index(jit_line_t *line, jit_int32_t offset)
{
jit_int32_t bot;
jit_int32_t top;
jit_int32_t index;
jit_int32_t *offsets;
bot = 0;
top = line->length;
offsets = line->offsets;
for (index = (bot + top) >> 1; bot < top; index = (bot + top) >> 1) {
if (offset < offsets[index])
top = index;
/* offset should be already verified to be in range */
else if (index == line->length - 1 ||
(offset >= offsets[index] && offset < offsets[index + 1]))
break;
else
bot = index + 1;
}
return (index);
}

3483
jit/jit_ppc-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1194
jit/jit_ppc-fpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1622
jit/jit_ppc-sz.c Normal file
View file

File diff suppressed because it is too large Load diff

1745
jit/jit_ppc.c Normal file
View file

File diff suppressed because it is too large Load diff

109
jit/jit_ppc.h Normal file
View file

@ -0,0 +1,109 @@
/*
* Copyright (C) 2012-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#ifndef _jit_ppc_h
#define _jit_ppc_h
#define JIT_HASH_CONSTS 1
#define JIT_NUM_OPERANDS 3
#if __powerpc__
# if _CALL_ELF == 2
/* __BYTE_ORDER == __LITTLE_ENDIAN */
# define ABI_ELFv2 1
# endif
#endif
/*
* Types
*/
typedef enum {
#if __ppc__
# define jit_r(i) (_R11 + (i))
#else
# define jit_r(i) (_R28 + (i))
#endif
#define jit_r_num() 3
#if __ppc__
# define jit_v(i) (_R30 - (i))
# define jit_v_num() 17
#else
# define jit_v(i) (_R27 - (i))
# define jit_v_num() 14
#endif
#define jit_f(i) (_F14 + (i))
#define jit_f_num() 8
_R0,
#if __ppc__
# define JIT_R0 _R11
# define JIT_R1 _R12
# define JIT_R2 _R13
#else
# define JIT_R0 _R28
# define JIT_R1 _R29
# define JIT_R2 _R30
#endif
_R11, _R12, _R13, _R2,
#define JIT_V0 jit_v(0)
#define JIT_V1 jit_v(1)
#define JIT_V2 jit_v(2)
#define JIT_V3 jit_v(3)
#define JIT_V4 jit_v(4)
#define JIT_V5 jit_v(5)
#define JIT_V6 jit_v(6)
#define JIT_V7 jit_v(7)
#define JIT_V8 jit_v(8)
#define JIT_V9 jit_v(9)
#define JIT_V10 jit_v(10)
#define JIT_V11 jit_v(11)
#define JIT_V12 jit_v(12)
#define JIT_V13 jit_v(13)
#if __ppc__
# define JIT_V14 jit_v(14)
# define JIT_V15 jit_v(15)
# define JIT_V16 jit_v(16)
#endif
_R14, _R15, _R16, _R17, _R18, _R19, _R20, _R21,
_R22, _R23, _R24, _R25, _R26, _R27, _R28, _R29,
_R30,
_R1,
#define JIT_FP _R31
_R31,
_R10, _R9, _R8, _R7, _R6, _R5, _R4, _R3,
_F0,
_F14, _F15, _F16, _F17, _F18, _F19, _F20, _F21,
#define JIT_F0 _F14
#define JIT_F1 _F15
#define JIT_F2 _F16
#define JIT_F3 _F17
#define JIT_F4 _F18
#define JIT_F5 _F19
#define JIT_F6 _F20
#define JIT_F7 _F21
/* FIXME _F20-_F31 not (easily) accessible and only _F14-_F21
* saved/restored (if used) */
_F22, _F23, _F24, _F25, _F26, _F27, _F28, _F29,
_F30, _F31,
_F13, _F12, _F11, _F10, _F9, _F8, _F7, _F6,
_F5, _F4, _F3, _F2, _F1,
_NOREG,
#define JIT_NOREG _NOREG
} jit_reg_t;
#endif /* _jit_ppc_h */

367
jit/jit_print.c Normal file
View file

@ -0,0 +1,367 @@
/*
* Copyright (C) 2012-2018 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#include "jit.h"
#include "jit/jit_private.h"
#define print_chr(value) fputc(value, stdout)
#define print_hex(value) fprintf(stdout, "0x%lx", value)
#define print_dec(value) fprintf(stdout, "%ld", value)
#define print_flt(value) fprintf(stdout, "%g", value)
#define print_str(value) fprintf(stdout, "%s", value)
#define print_ptr(value) fprintf(stdout, "%p", value)
#define print_reg(value) \
do { \
if ((value) & jit_regno_patch) \
print_chr('?'); \
print_str(_rvs[jit_regno(value)].name); \
} while (0)
#define print_arg(value) \
do { \
print_chr('#'); \
if (value) \
print_dec((value)->v.w); \
else \
print_chr('?'); \
} while (0)
/*
* Initialization
*/
#include "jit_names.c"
/*
* Implementation
*/
void
_jit_print(jit_state_t *_jit)
{
jit_node_t *node;
if ((node = _jitc->head)) {
jit_print_node(node);
for (node = node->next; node; node = node->next) {
print_chr('\n');
jit_print_node(node);
}
print_chr('\n');
}
}
void
_jit_print_node(jit_state_t *_jit, jit_node_t *node)
{
jit_block_t *block;
jit_int32_t value;
jit_int32_t offset;
if (node->code == jit_code_label ||
node->code == jit_code_prolog || node->code == jit_code_epilog) {
print_chr('L');
print_dec(node->v.w);
print_chr(':');
block = _jitc->blocks.ptr + node->v.w;
for (offset = 0; offset < _jitc->reglen; offset++) {
if (jit_regset_tstbit(&block->reglive, offset)) {
print_chr(' ');
print_reg(offset);
}
}
if (node->code == jit_code_prolog ||
node->code == jit_code_epilog) {
print_str(" /* ");
print_str(code_name[node->code]);
print_str(" */");
}
return;
}
value = jit_classify(node->code) &
(jit_cc_a0_int|jit_cc_a0_flt|jit_cc_a0_dbl|jit_cc_a0_jmp|
jit_cc_a0_reg|jit_cc_a0_rlh|jit_cc_a0_arg|
jit_cc_a1_reg|jit_cc_a1_int|jit_cc_a1_flt|jit_cc_a1_dbl|jit_cc_a1_arg|
jit_cc_a2_reg|jit_cc_a2_int|jit_cc_a2_flt|jit_cc_a2_dbl);
if (!(node->flag & jit_flag_synth) && ((value & jit_cc_a0_jmp) ||
node->code == jit_code_finishr ||
node->code == jit_code_finishi))
print_str(" ");
else
print_chr('\t');
if (node->flag & jit_flag_synth)
print_str(" \\__ ");
print_str(code_name[node->code]);
switch (node->code) {
r:
print_chr(' '); print_reg(node->u.w); return;
w:
print_chr(' '); print_hex(node->u.w); return;
f:
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float32_t *)node->u.n->u.w);
else
print_flt(node->u.f);
return;
d:
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float64_t *)node->u.n->u.w);
else
print_flt(node->u.d);
return;
n:
print_chr(' ');
if (!(node->flag & jit_flag_node))
print_ptr(node->u.p);
else {
print_chr('L');
print_dec(node->u.n->v.w);
}
return;
a:
print_chr(' '); print_arg(node); return;
r_r:
print_chr(' '); print_reg(node->u.w);
print_chr(' '); print_reg(node->v.w); return;
r_w:
print_chr(' '); print_reg(node->u.w);
print_chr(' '); print_hex(node->v.w); return;
r_f:
print_chr(' '); print_reg(node->u.w);
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float32_t *)node->v.n->u.w);
else
print_flt(node->v.f);
return;
r_d:
print_chr(' '); print_reg(node->u.w);
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float64_t *)node->v.n->u.w);
else
print_flt(node->v.d);
return;
r_a:
print_chr(' '); print_reg(node->u.w);
print_chr(' '); print_arg(node->v.n);
return;
w_r:
print_chr(' '); print_hex(node->u.w);
print_chr(' '); print_reg(node->v.w); return;
w_w:
print_chr(' '); print_hex(node->u.w);
print_chr(' '); print_hex(node->v.w); return;
w_a:
print_chr(' '); print_hex(node->u.w);
print_chr(' '); print_arg(node->v.n);
return;
f_a:
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float32_t *)node->u.n->u.w);
else
print_flt(node->u.f);
print_chr(' '); print_arg(node->v.n);
return;
d_a:
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float64_t *)node->u.n->u.w);
else
print_flt(node->u.d);
print_chr(' '); print_arg(node->v.n);
return;
r_r_r:
print_chr(' '); print_reg(node->u.w);
print_chr(' '); print_reg(node->v.w);
print_chr(' '); print_reg(node->w.w); return;
r_r_w:
print_chr(' '); print_reg(node->u.w);
print_chr(' '); print_reg(node->v.w);
print_chr(' '); print_hex(node->w.w); return;
q_r_r:
print_str(" ("); print_reg(node->u.q.l);
print_chr(' '); print_reg(node->u.q.h);
print_str(") "); print_reg(node->v.w);
print_chr(' '); print_reg(node->w.w); return;
q_r_w:
print_str(" ("); print_reg(node->u.q.l);
print_chr(' '); print_reg(node->u.q.h);
print_str(") "); print_reg(node->v.w);
print_chr(' '); print_hex(node->w.w); return;
r_r_f:
print_chr(' '); print_reg(node->u.w);
print_chr(' '); print_reg(node->v.w);
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float32_t *)node->w.n->u.w);
else
print_flt(node->w.f);
return;
r_r_d:
print_chr(' '); print_reg(node->u.w);
print_chr(' '); print_reg(node->v.w);
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float64_t *)node->w.n->u.w);
else
print_flt(node->w.d);
return;
w_r_r:
print_chr(' '); print_hex(node->u.w);
print_chr(' '); print_reg(node->v.w);
print_chr(' '); print_reg(node->w.w); return;
n_r_r:
print_chr(' ');
if (!(node->flag & jit_flag_node))
print_ptr(node->u.p);
else {
print_chr('L');
print_dec(node->u.n->v.w);
}
print_chr(' '); print_reg(node->v.w);
print_chr(' '); print_reg(node->w.w); return;
n_r_w:
print_chr(' ');
if (!(node->flag & jit_flag_node))
print_ptr(node->u.p);
else {
print_chr('L');
print_dec(node->u.n->v.w);
}
print_chr(' '); print_reg(node->v.w);
print_chr(' '); print_hex(node->w.w); return;
n_r_f:
print_chr(' ');
if (!(node->flag & jit_flag_node))
print_ptr(node->u.p);
else{
print_chr('L');
print_dec(node->u.n->v.w);
}
print_chr(' '); print_reg(node->v.w);
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float32_t *)node->w.n->u.w);
else
print_flt(node->w.f);
return;
n_r_d:
print_chr(' ');
if (!(node->flag & jit_flag_node))
print_ptr(node->u.p);
else {
print_chr('L');
print_dec(node->u.n->v.w);
}
print_chr(' '); print_reg(node->v.w);
print_chr(' ');
if (node->flag & jit_flag_data)
print_flt(*(jit_float64_t *)node->w.n->u.w);
else
print_flt(node->w.d);
return;
case jit_code_name:
print_chr(' ');
if (node->v.p && _jitc->emit)
print_str(node->v.n->u.p);
break;
case jit_code_note:
print_chr(' ');
if (node->v.p && _jitc->emit)
print_str(node->v.n->u.p);
if (node->v.p && _jitc->emit && node->w.w)
print_chr(':');
if (node->w.w)
print_dec(node->w.w);
break;
case jit_code_data:
case jit_code_label:
case jit_code_ellipsis:
case jit_code_prolog: case jit_code_epilog:
case jit_code_ret: case jit_code_prepare:
break;
case jit_code_save: case jit_code_load:
goto r;
default:
switch (value) {
case jit_cc_a0_reg:
case jit_cc_a0_reg|jit_cc_a0_chg:
case jit_cc_a0_reg|jit_cc_a0_jmp:
goto r;
case jit_cc_a0_int:
goto w;
case jit_cc_a0_flt:
goto f;
case jit_cc_a0_dbl:
goto d;
case jit_cc_a0_jmp:
goto n;
case jit_cc_a0_int|jit_cc_a0_arg:
goto a;
case jit_cc_a0_reg|jit_cc_a1_reg:
goto r_r;
case jit_cc_a0_reg|jit_cc_a1_int:
goto r_w;
case jit_cc_a0_reg|jit_cc_a1_flt:
goto r_f;
case jit_cc_a0_reg|jit_cc_a1_dbl:
goto r_d;
case jit_cc_a0_reg|jit_cc_a1_arg:
goto r_a;
case jit_cc_a0_int|jit_cc_a1_reg:
goto w_r;
case jit_cc_a0_int|jit_cc_a1_int:
goto w_w;
case jit_cc_a0_int|jit_cc_a1_arg:
goto w_a;
case jit_cc_a0_flt|jit_cc_a1_arg:
goto f_a;
case jit_cc_a0_dbl|jit_cc_a1_arg:
goto d_a;
case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_reg:
goto r_r_r;
case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_int:
goto r_r_w;
case jit_cc_a0_reg|jit_cc_a0_rlh|
jit_cc_a1_reg|jit_cc_a2_reg:
goto q_r_r;
case jit_cc_a0_reg|jit_cc_a0_rlh|
jit_cc_a1_reg|jit_cc_a2_int:
goto q_r_w;
case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_flt:
goto r_r_f;
case jit_cc_a0_reg|jit_cc_a1_reg|jit_cc_a2_dbl:
goto r_r_d;
case jit_cc_a0_int|jit_cc_a1_reg|jit_cc_a2_reg:
goto w_r_r;
case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_reg:
goto n_r_r;
case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_int:
goto n_r_w;
case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_flt:
goto n_r_f;
case jit_cc_a0_jmp|jit_cc_a1_reg|jit_cc_a2_dbl:
goto n_r_d;
default:
abort();
}
break;
}
}

762
jit/jit_private.h Normal file
View file

@ -0,0 +1,762 @@
/*
* Copyright (C) 2012-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#ifndef _jit_private_h
#define _jit_private_h
#if HAVE_CONFIG_H
# include "config.h"
#endif
#include <assert.h>
#include <limits.h>
#include <stdio.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 rc(value) jit_class_##value
#define rn(reg) (jit_regno(_rvs[jit_regno(reg)].spec))
#if defined(__i386__) || defined(__x86_64__)
# define JIT_SP _RSP
# define JIT_RET _RAX
# if __X32
# define JIT_FRET _ST0
typedef jit_uint32_t jit_regset_t;
# else
# if __CYGWIN__
# define JIT_RA0 _RCX
# else
# define JIT_RA0 _RDI
# endif
# define JIT_FA0 _XMM0
# define JIT_FRET _XMM0
typedef jit_uint64_t jit_regset_t;
# endif
#elif defined(__mips__)
# define JIT_RA0 _A0
# define JIT_FA0 _F12
# define JIT_SP _SP
# define JIT_RET _V0
# define JIT_FRET _F0
typedef jit_uint64_t jit_regset_t;
#elif defined(__arm__)
# define JIT_RA0 _R0
# define JIT_FA0 _D0
# define JIT_SP _R13
# define JIT_RET _R0
# if defined(__ARM_PCS_VFP)
# define JIT_FRET _D0
# else
# define JIT_FRET _R0
# endif
typedef jit_uint64_t jit_regset_t;
#elif defined(__ppc__) || defined(__powerpc__)
# define JIT_RA0 _R3
# define JIT_FA0 _F1
# define JIT_SP _R1
# define JIT_RET _R3
# define JIT_FRET _F1
typedef jit_uint64_t jit_regset_t;
#elif defined(__sparc__)
# define JIT_SP _SP
# define JIT_RET _I0
# define JIT_FRET _F0
# if __WORDSIZE == 32
typedef jit_uint64_t jit_regset_t;
# else
typedef struct {
jit_uint64_t rl;
jit_uint64_t rh;
} jit_regset_t;
# endif
#elif defined(__ia64__)
# define JIT_SP _R12
# define JIT_RET _R8
# define JIT_FRET _F8
typedef struct {
jit_uint64_t rl;
jit_uint64_t rh;
jit_uint64_t fl;
jit_uint64_t fh;
} jit_regset_t;
#elif defined(__hppa__)
# define JIT_SP _R30
# define JIT_RET _R28
# define JIT_FRET _F4
typedef jit_uint64_t jit_regset_t;
#elif defined(__aarch64__)
# define JIT_RA0 _R0
# define JIT_FA0 _V0
# define JIT_SP _SP
# define JIT_RET _R0
# define JIT_FRET _V0
typedef jit_uint64_t jit_regset_t;
#elif defined(__s390__) || defined(__s390x__)
# define JIT_SP _R15
# define JIT_RET _R2
# define JIT_FRET _F0
typedef jit_uint32_t jit_regset_t;
#elif defined(__alpha__)
# define JIT_SP _SP
# define JIT_RET _V0
# define JIT_FRET _F0
typedef jit_uint64_t jit_regset_t;
#endif
#define jit_data(u,v,w) _jit_data(_jit,u,v,w)
extern jit_node_t *_jit_data(jit_state_t*, const void*,
jit_word_t, jit_int32_t);
#define jit_size(vector) (sizeof(vector) / sizeof((vector)[0]))
#define jit_reg_free_p(regno) \
(!jit_regset_tstbit(&_jitc->reglive, regno) && \
!jit_regset_tstbit(&_jitc->regarg, regno) && \
!jit_regset_tstbit(&_jitc->regsav, regno))
#define jit_reg_free_if_spill_p(regno) \
(!jit_regset_tstbit(&_jitc->regarg, regno) && \
!jit_regset_tstbit(&_jitc->regsav, regno))
#define jit_inc_synth(code) \
do { \
(void)jit_new_node(jit_code_##code); \
jit_synth_inc(); \
} while (0)
#define jit_inc_synth_w(code, u) \
do { \
(void)jit_new_node_w(jit_code_##code, u); \
jit_synth_inc(); \
} while (0)
#define jit_inc_synth_f(code, u) \
do { \
(void)jit_new_node_f(jit_code_##code, u); \
jit_synth_inc(); \
} while (0)
#define jit_inc_synth_d(code, u) \
do { \
(void)jit_new_node_d(jit_code_##code, u); \
jit_synth_inc(); \
} while (0)
#define jit_inc_synth_ww(code, u, v) \
do { \
(void)jit_new_node_ww(jit_code_##code, u, v); \
jit_synth_inc(); \
} while (0)
#define jit_inc_synth_wp(code, u, v) \
do { \
(void)jit_new_node_wp(jit_code_##code, u, v); \
jit_synth_inc(); \
} while (0)
#define jit_inc_synth_fp(code, u, v) \
do { \
(void)jit_new_node_fp(jit_code_##code, u, v); \
jit_synth_inc(); \
} while (0)
#define jit_inc_synth_dp(code, u, v) \
do { \
(void)jit_new_node_dp(jit_code_##code, u, v); \
jit_synth_inc(); \
} while (0)
#define jit_dec_synth() jit_synth_dec()
#define jit_link_prolog() \
do { \
_jitc->tail->link = _jitc->function->prolog->link; \
_jitc->function->prolog->link = _jitc->tail; \
} while (0)
#define jit_link_prepare() \
do { \
_jitc->tail->link = _jitc->prepare->link; \
_jitc->prepare->link = _jitc->tail; \
} while (0)
#define jit_link_reverse(where) \
do { \
jit_node_t *tmp, *tail = 0; \
while (where) { \
tmp = (where)->link; \
(where)->link = tail; \
tail = where; \
where = tmp; \
} \
where = tail; \
} while (0);
/*
* Private jit_class bitmasks
*/
#define jit_class_named 0x00400000 /* hit must be the named reg */
#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 */
/* Used on sparc64 where %f0-%f31 can be encode for single float
* but %f32 to %f62 only as double precision */
#define jit_class_sng 0x10000000 /* Single precision float */
#define jit_class_dbl 0x20000000 /* Only double precision float */
#define jit_regno_patch 0x00008000 /* this is a register
* returned by a "user" call
* to jit_get_reg() */
#define jit_call_default 0
#define jit_call_varargs 1
#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_rlh 0x00000008 /* arg0 is a register pair */
#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_a0_arg 0x00000080 /* arg1 is an argument int id */
#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_a1_arg 0x00008000 /* arg1 is an argument node */
#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 */
#if __ia64__ || (__sparc__ && __WORDSIZE == 64)
extern void
jit_regset_com(jit_regset_t*, jit_regset_t*);
extern void
jit_regset_and(jit_regset_t*, jit_regset_t*, jit_regset_t*);
extern void
jit_regset_ior(jit_regset_t*, jit_regset_t*, jit_regset_t*);
extern void
jit_regset_xor(jit_regset_t*, jit_regset_t*, jit_regset_t*);
extern void
jit_regset_set(jit_regset_t*, jit_regset_t*);
extern void
jit_regset_set_mask(jit_regset_t*, jit_int32_t);
extern jit_bool_t
jit_regset_cmp_ui(jit_regset_t*, jit_word_t);
extern void
jit_regset_set_ui(jit_regset_t*, jit_word_t);
extern jit_bool_t
jit_regset_set_p(jit_regset_t*);
extern void
jit_regset_clrbit(jit_regset_t*, jit_int32_t);
extern void
jit_regset_setbit(jit_regset_t*, jit_int32_t);
extern jit_bool_t
jit_regset_tstbit(jit_regset_t*, jit_int32_t);
# if __sparc__ && __WORDSIZE == 64
# define jit_regset_new(set) \
do { (set)->rl = (set)->rh = 0; } while (0)
# define jit_regset_del(set) \
do { (set)->rl = (set)->rh = 0; } while (0)
# else
# define jit_regset_new(set) \
do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
# define jit_regset_del(set) \
do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
# endif
#else
# 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_set_mask(u, v) (*(u) = (1LL << (v)) - 1)
# 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)
# 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)))
# define jit_regset_new(set) (*(set) = 0)
# define jit_regset_del(set) (*(set) = 0)
#endif
extern unsigned long
jit_regset_scan1(jit_regset_t*, jit_int32_t);
#define jit_reglive_setup() \
do { \
jit_regset_set_ui(&_jitc->reglive, 0); \
jit_regset_set_ui(&_jitc->regmask, 0); \
} while (0)
/*
* Types
*/
typedef union jit_data jit_data_t;
typedef struct jit_note jit_note_t;
typedef struct jit_line jit_line_t;
typedef struct jit_block jit_block_t;
typedef struct jit_value jit_value_t;
typedef struct jit_compiler jit_compiler_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
} q;
jit_word_t w;
jit_float32_t f;
jit_float64_t d;
jit_pointer_t p;
jit_node_t *n;
};
struct jit_note {
jit_uint8_t *code;
char *name;
jit_line_t *lines;
jit_word_t length;
jit_word_t size; /* of code */
};
struct jit_line {
char *file;
jit_int32_t *linenos;
jit_int32_t *offsets;
jit_word_t length;
};
struct jit_node {
jit_node_t *next;
jit_code_t code;
jit_uint16_t flag;
jit_uint16_t offset; /* Used if DEVEL_DISASSEMBLER */
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;
jit_regset_t setmask; /* Used for forward second pass */
};
struct jit_value {
jit_int32_t kind;
jit_code_t code;
jit_data_t base;
jit_data_t disp;
};
typedef struct {
#if __arm__
jit_word_t kind;
#endif
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;
jit_int32_t call;
jit_int32_t argn; /* for debug output */
} self;
struct {
jit_int32_t argi;
jit_int32_t argf;
jit_int32_t size;
jit_int32_t call;
} call;
jit_node_t *prolog;
jit_node_t *epilog;
jit_int32_t *regoff;
jit_regset_t regset;
jit_int32_t stack;
/* Helper for common jit generation pattern, used in GNU Smalltalk
* and possibly others, where a static frame layout is required or
* assumed. */
jit_int32_t frame;
jit_uint32_t define_frame : 1;
jit_uint32_t assume_frame : 1;
/* alloca offset offset */
jit_int32_t aoffoff;
/* uses allocar flag */
jit_uint32_t allocar : 1;
/* varargs state offsets */
jit_int32_t vaoff; /* offset of jit_va_list */
jit_int32_t vagp; /* first gp va argument */
jit_int32_t vafp; /* first fp va argument */
};
/* data used only during jit generation */
struct jit_compiler {
#if __ia64__
struct {
jit_uint64_t i : 41;
jit_uint64_t t : 4;
} inst[3];
jit_regset_t regs; /* changed regs since last stop */
jit_int32_t pred; /* changed preds last stop */
jit_int32_t ioff; /* offset in inst vector */
jit_int32_t rout; /* first output register */
jit_int32_t breg; /* base register for prolog/epilog */
#endif
#if __mips__ || __ia64__ || __alpha__ || (__sparc__ && __WORDSIZE == 64)
jit_int32_t carry;
#define jit_carry _jitc->carry
#endif
jit_node_t *head;
jit_node_t *tail;
jit_node_t *prepare; /* inside prepare/finish* block */
jit_uint32_t realize : 1; /* jit_realize() called? */
jit_uint32_t dataset : 1; /* jit_dataset() called? */
jit_uint32_t done : 1; /* emit state finished */
jit_uint32_t emit : 1; /* emit state entered */
jit_uint32_t again : 1; /* start over emiting function */
jit_uint32_t synth : 8; /* emiting synthesized instructions */
#if DEBUG
jit_uint32_t getreg : 1;
#endif
jit_uint32_t no_data : 1;
jit_uint32_t no_note : 1;
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 */
struct {
jit_word_t *ptr;
jit_word_t length;
} blockmask; /* mask of visited basic blocks */
struct {
jit_uint8_t *end;
} code;
struct {
jit_uint8_t *ptr;
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 */
} 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;
struct {
jit_node_t *head; /* first note node */
jit_node_t *tail; /* linked list insertion */
/* fields to store temporary state information */
jit_word_t size;
jit_node_t *name;
jit_node_t *note;
jit_uint8_t *base;
} note;
#if __arm__
/* prevent using thumb instructions that set flags? */
jit_uint32_t no_set_flags : 1;
# if DISASSEMBLER
struct {
jit_data_info_t *ptr;
jit_word_t offset;
jit_word_t length;
} data_info; /* constant pools information */
# endif
/* Note that this field is somewhat hackish, but required by most
* ways to implement jit, unless implementing a pure one function
* per jit, as most times it needs to start the jit buffer with a
* jump where the "main" prolog starts, and because the initial
* code is in "arm mode", need to make an "arm mode" patch on that
* jump. A good example is the test suite assembler, where most
* test cases start with a "jmpi main" call. */
jit_uword_t thumb;
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;
#elif __powerpc__ || __ia64__
/* Keep track of prolog addresses, just for the sake of making
* jit that starts with a jump to a "main" label work like other
* backends. */
struct {
jit_word_t *ptr;
jit_word_t offset;
jit_word_t length;
} prolog;
jit_bool_t jump;
#endif
#if GET_JIT_SIZE
/* Temporary storage to calculate instructions length */
jit_word_t size;
/* Global flag for code buffer heuristic size computation */
jit_word_t mult;
/* Pointer to code to prevent miscalculation if reallocating buffer */
jit_uint8_t *cptr;
#endif
};
#define _jitc _jit->comp
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;
struct {
jit_uint8_t *ptr;
jit_word_t length;
} code;
struct {
jit_uint8_t *ptr;
jit_word_t length;
} data;
struct {
jit_note_t *ptr;
jit_word_t length;
} note;
jit_compiler_t *comp;
/* Flags to know if user did set the code and data buffers */
jit_uint32_t user_code : 1;
jit_uint32_t user_data : 1;
};
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_synth_inc() _jit_synth_inc(_jit)
extern void _jit_synth_inc(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_synth_dec() _jit_synth_dec(_jit)
extern void _jit_synth_dec(jit_state_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_trampoline(u,v) _jit_trampoline(_jit, u, v)
extern void _jit_trampoline(jit_state_t*, jit_int32_t, jit_bool_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_code() _emit_code(_jit)
extern jit_pointer_t
_emit_code(jit_state_t*);
extern void
jit_flush(void *fptr, void *tptr);
#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_d(_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(const char*);
extern void jit_finish_debug(void);
extern void jit_init_note(void);
extern void jit_finish_note(void);
#define jit_set_note(n,u,v,w) _jit_set_note(_jit, n, u, v, w)
extern void _jit_set_note(jit_state_t*, jit_note_t*, char*, int, jit_int32_t);
#define jit_annotate() _jit_annotate(_jit)
extern void _jit_annotate(jit_state_t*);
#define jit_print_node(u) _jit_print_node(_jit,u)
extern void _jit_print_node(jit_state_t*,jit_node_t*);
extern jit_pointer_t jit_memcpy(jit_pointer_t,const void*,jit_word_t);
extern jit_pointer_t jit_memmove(jit_pointer_t,const void*,jit_word_t);
extern void jit_alloc(jit_pointer_t*, jit_word_t);
extern void jit_realloc(jit_pointer_t*, jit_word_t, jit_word_t);
void jit_free(jit_pointer_t*);
extern void jit_init_size(void);
extern void jit_finish_size(void);
#if GET_JIT_SIZE
# define jit_size_prepare() _jit_size_prepare(_jit)
extern void
_jit_size_prepare(jit_state_t*);
# define jit_size_collect(node) _jit_size_collect(_jit, node)
extern void
_jit_size_collect(jit_state_t*, jit_node_t*);
#else
# define jit_get_size() _jit_get_size(_jit)
extern jit_word_t
_jit_get_size(jit_state_t*);
#endif
extern jit_word_t
jit_get_max_instr(void);
/*
* Externs
*/
extern jit_register_t _rvs[];
#endif /* _jit_private_h */

192
jit/jit_rewind.c Normal file
View file

@ -0,0 +1,192 @@
/*
* Copyright (C) 2015-2018 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#include "jit.h"
#include "jit/jit_private.h"
#if PROTO
# define free_synth_list(node) _free_synth_list(_jit,node)
static jit_node_t *_free_synth_list(jit_state_t*,jit_node_t*);
#define rewind_prolog() _rewind_prolog(_jit)
static void _rewind_prolog(jit_state_t*);
#define rewind_prepare() _rewind_prepare(_jit)
static void _rewind_prepare(jit_state_t*);
#endif
#if CODE
/*
* Implementation
*/
static jit_node_t *
_free_synth_list(jit_state_t *_jit, jit_node_t *node)
{
jit_node_t *next;
next = node->next;
free_node(node);
for (node = next; node && (node->flag & jit_flag_synth); node = next) {
next = node->next;
free_node(node);
}
return (next);
}
static void
_rewind_prolog(jit_state_t *_jit)
{
jit_node_t *node;
jit_node_t *next;
_jitc->function->self.size = stack_framesize;
#if __arm__
assert(jit_cpu.abi);
_jitc->function->self.size += 64;
#endif
#if __mips__ && NEW_ABI
/* Only add extra stack space if there are varargs
* arguments in registers. */
assert(jit_arg_reg_p(_jitc->function->self.argi));
_jitc->function->self.size += 64;
#endif
_jitc->function->self.argi =
_jitc->function->self.argf = _jitc->function->self.argn = 0;
_jitc->tail = _jitc->function->prolog;
node = _jitc->tail->next;
_jitc->tail->next = (jit_node_t *)0;
_jitc->tail->link = (jit_node_t *)0;
for (; node; node = next) {
next = node->next;
switch (node->code) {
case jit_code_arg:
node->next = (jit_node_t *)0;
jit_make_arg(node);
break;
case jit_code_arg_f:
node->next = (jit_node_t *)0;
jit_make_arg_f(node);
break;
case jit_code_arg_d:
node->next = (jit_node_t *)0;
jit_make_arg_d(node);
break;
case jit_code_getarg_c:
jit_getarg_c(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_getarg_uc:
jit_getarg_uc(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_getarg_s:
jit_getarg_s(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_getarg_us:
jit_getarg_us(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_getarg_i:
jit_getarg_i(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_getarg_f:
jit_getarg_f(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_getarg_d:
jit_getarg_d(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_putargr:
jit_putargr(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_putargi:
jit_putargi(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_putargr_f:
jit_putargr_f(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_putargi_f:
jit_putargi_f(node->u.f, node->v.n);
next = free_synth_list(node);
break;
case jit_code_putargr_d:
jit_putargr_d(node->u.w, node->v.n);
next = free_synth_list(node);
break;
case jit_code_putargi_d:
jit_putargi_d(node->u.d, node->v.n);
next = free_synth_list(node);
break;
default:
node->next = (jit_node_t *)0;
link_node(node);
break;
}
}
}
static void
_rewind_prepare(jit_state_t *_jit)
{
jit_node_t *node;
jit_node_t *next;
_jitc->function->call.argi =
_jitc->function->call.argf =
_jitc->function->call.size = 0;
_jitc->tail = _jitc->prepare;
node = _jitc->tail->next;
_jitc->tail->next = (jit_node_t *)0;
_jitc->tail->link = (jit_node_t *)0;
for (; node; node = next) {
next = node->next;
switch (node->code) {
case jit_code_pushargr:
jit_pushargr(node->u.w);
next = free_synth_list(node);
break;
case jit_code_pushargi:
jit_pushargi(node->u.w);
next = free_synth_list(node);
break;
case jit_code_pushargr_f:
jit_pushargr_f(node->u.w);
next = free_synth_list(node);
break;
case jit_code_pushargi_f:
jit_pushargi_f(node->u.f);
next = free_synth_list(node);
break;
case jit_code_pushargr_d:
jit_pushargr_d(node->u.w);
next = free_synth_list(node);
break;
case jit_code_pushargi_d:
jit_pushargi_d(node->u.d);
next = free_synth_list(node);
break;
default:
node->next = (jit_node_t *)0;
link_node(node);
break;
}
}
}
#endif

3848
jit/jit_s390-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1316
jit/jit_s390-fpu.c Normal file
View file

File diff suppressed because it is too large Load diff

804
jit/jit_s390-sz.c Normal file
View file

@ -0,0 +1,804 @@
#if __WORDSIZE == 32
#define JIT_INSTR_MAX 104
0, /* data */
0, /* live */
6, /* align */
0, /* save */
0, /* load */
0, /* #name */
0, /* #note */
2, /* label */
42, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
44, /* va_start */
104, /* va_arg */
100, /* va_arg_d */
0, /* va_end */
8, /* addr */
24, /* addi */
8, /* addcr */
20, /* addci */
8, /* addxr */
12, /* addxi */
12, /* subr */
24, /* subi */
12, /* subcr */
20, /* subci */
12, /* subxr */
12, /* subxi */
28, /* rsbi */
8, /* mulr */
24, /* muli */
60, /* qmulr */
68, /* qmuli */
16, /* qmulr_u */
32, /* qmuli_u */
12, /* divr */
28, /* divi */
16, /* divr_u */
32, /* divi_u */
16, /* qdivr */
20, /* qdivi */
20, /* qdivr_u */
24, /* qdivi_u */
12, /* remr */
28, /* remi */
16, /* remr_u */
32, /* remi_u */
8, /* andr */
20, /* andi */
8, /* orr */
20, /* ori */
8, /* xorr */
24, /* xori */
6, /* lshr */
10, /* lshi */
6, /* rshr */
10, /* rshi */
6, /* rshr_u */
10, /* rshi_u */
4, /* negr */
12, /* comr */
20, /* ltr */
24, /* lti */
20, /* ltr_u */
24, /* lti_u */
20, /* ler */
24, /* lei */
20, /* ler_u */
24, /* lei_u */
20, /* eqr */
24, /* eqi */
20, /* ger */
24, /* gei */
20, /* ger_u */
24, /* gei_u */
20, /* gtr */
24, /* gti */
20, /* gtr_u */
24, /* gti_u */
20, /* ner */
24, /* nei */
4, /* movr */
16, /* movi */
4, /* extr_c */
4, /* extr_uc */
4, /* extr_s */
4, /* extr_us */
4, /* extr_i */
4, /* extr_ui */
4, /* htonr_us */
4, /* htonr_ui */
4, /* htonr_ul */
6, /* ldr_c */
18, /* ldi_c */
6, /* ldr_uc */
18, /* ldi_uc */
6, /* ldr_s */
18, /* ldi_s */
6, /* ldr_us */
18, /* ldi_us */
6, /* ldr_i */
18, /* ldi_i */
6, /* ldr_ui */
18, /* ldi_ui */
6, /* ldr_l */
18, /* ldi_l */
14, /* ldxr_c */
26, /* ldxi_c */
14, /* ldxr_uc */
26, /* ldxi_uc */
14, /* ldxr_s */
26, /* ldxi_s */
14, /* ldxr_us */
26, /* ldxi_us */
14, /* ldxr_i */
26, /* ldxi_i */
14, /* ldxr_ui */
26, /* ldxi_ui */
14, /* ldxr_l */
26, /* ldxi_l */
4, /* str_c */
16, /* sti_c */
4, /* str_s */
16, /* sti_s */
4, /* str_i */
16, /* sti_i */
6, /* str_l */
18, /* sti_l */
12, /* stxr_c */
28, /* stxi_c */
12, /* stxr_s */
28, /* stxi_s */
12, /* stxr_i */
28, /* stxi_i */
14, /* stxr_l */
30, /* stxi_l */
10, /* bltr */
14, /* blti */
10, /* bltr_u */
14, /* blti_u */
10, /* bler */
14, /* blei */
10, /* bler_u */
14, /* blei_u */
10, /* beqr */
26, /* beqi */
10, /* bger */
14, /* bgei */
10, /* bger_u */
14, /* bgei_u */
10, /* bgtr */
14, /* bgti */
10, /* bgtr_u */
14, /* bgti_u */
10, /* bner */
26, /* bnei */
18, /* bmsr */
18, /* bmsi */
18, /* bmcr */
18, /* bmci */
10, /* boaddr */
14, /* boaddi */
10, /* boaddr_u */
14, /* boaddi_u */
10, /* bxaddr */
14, /* bxaddi */
10, /* bxaddr_u */
14, /* bxaddi_u */
10, /* bosubr */
14, /* bosubi */
10, /* bosubr_u */
14, /* bosubi_u */
10, /* bxsubr */
14, /* bxsubi */
10, /* bxsubr_u */
14, /* bxsubi_u */
2, /* jmpr */
18, /* jmpi */
2, /* callr */
18, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
40, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
6, /* addr_f */
26, /* addi_f */
8, /* subr_f */
26, /* subi_f */
28, /* rsbi_f */
6, /* mulr_f */
26, /* muli_f */
8, /* divr_f */
26, /* divi_f */
4, /* negr_f */
4, /* absr_f */
4, /* sqrtr_f */
16, /* ltr_f */
36, /* lti_f */
16, /* ler_f */
36, /* lei_f */
16, /* eqr_f */
36, /* eqi_f */
16, /* ger_f */
36, /* gei_f */
16, /* gtr_f */
36, /* gti_f */
16, /* ner_f */
36, /* nei_f */
16, /* unltr_f */
36, /* unlti_f */
16, /* unler_f */
36, /* unlei_f */
20, /* uneqr_f */
40, /* uneqi_f */
16, /* unger_f */
36, /* ungei_f */
16, /* ungtr_f */
36, /* ungti_f */
20, /* ltgtr_f */
40, /* ltgti_f */
16, /* ordr_f */
36, /* ordi_f */
16, /* unordr_f */
36, /* unordi_f */
4, /* truncr_f_i */
4, /* truncr_f_l */
4, /* extr_f */
4, /* extr_d_f */
2, /* movr_f */
20, /* movi_f */
4, /* ldr_f */
16, /* ldi_f */
12, /* ldxr_f */
24, /* ldxi_f */
4, /* str_f */
16, /* sti_f */
12, /* stxr_f */
24, /* stxi_f */
10, /* bltr_f */
30, /* blti_f */
10, /* bler_f */
30, /* blei_f */
10, /* beqr_f */
30, /* beqi_f */
10, /* bger_f */
30, /* bgei_f */
10, /* bgtr_f */
30, /* bgti_f */
10, /* bner_f */
30, /* bnei_f */
10, /* bunltr_f */
30, /* bunlti_f */
10, /* bunler_f */
30, /* bunlei_f */
18, /* buneqr_f */
38, /* buneqi_f */
10, /* bunger_f */
30, /* bungei_f */
10, /* bungtr_f */
30, /* bungti_f */
18, /* bltgtr_f */
38, /* bltgti_f */
10, /* bordr_f */
30, /* bordi_f */
10, /* bunordr_f */
30, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
6, /* addr_d */
26, /* addi_d */
8, /* subr_d */
26, /* subi_d */
28, /* rsbi_d */
6, /* mulr_d */
26, /* muli_d */
8, /* divr_d */
26, /* divi_d */
4, /* negr_d */
4, /* absr_d */
4, /* sqrtr_d */
16, /* ltr_d */
36, /* lti_d */
16, /* ler_d */
36, /* lei_d */
16, /* eqr_d */
36, /* eqi_d */
16, /* ger_d */
36, /* gei_d */
16, /* gtr_d */
36, /* gti_d */
16, /* ner_d */
36, /* nei_d */
16, /* unltr_d */
36, /* unlti_d */
16, /* unler_d */
36, /* unlei_d */
20, /* uneqr_d */
40, /* uneqi_d */
16, /* unger_d */
36, /* ungei_d */
16, /* ungtr_d */
36, /* ungti_d */
20, /* ltgtr_d */
40, /* ltgti_d */
16, /* ordr_d */
36, /* ordi_d */
16, /* unordr_d */
36, /* unordi_d */
4, /* truncr_d_i */
4, /* truncr_d_l */
4, /* extr_d */
4, /* extr_f_d */
2, /* movr_d */
24, /* movi_d */
4, /* ldr_d */
16, /* ldi_d */
12, /* ldxr_d */
24, /* ldxi_d */
4, /* str_d */
16, /* sti_d */
12, /* stxr_d */
24, /* stxi_d */
10, /* bltr_d */
30, /* blti_d */
10, /* bler_d */
30, /* blei_d */
10, /* beqr_d */
34, /* beqi_d */
10, /* bger_d */
30, /* bgei_d */
10, /* bgtr_d */
30, /* bgti_d */
10, /* bner_d */
30, /* bnei_d */
10, /* bunltr_d */
30, /* bunlti_d */
10, /* bunler_d */
30, /* bunlei_d */
18, /* buneqr_d */
38, /* buneqi_d */
10, /* bunger_d */
30, /* bungei_d */
10, /* bungtr_d */
30, /* bungti_d */
18, /* bltgtr_d */
38, /* bltgti_d */
10, /* bordr_d */
30, /* bordi_d */
10, /* bunordr_d */
30, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
0, /* movr_w_f */
0, /* movr_ww_d */
0, /* movr_w_d */
0, /* movr_f_w */
0, /* movi_f_w */
0, /* movr_d_ww */
0, /* movi_d_ww */
0, /* movr_d_w */
0, /* movi_d_w */
#endif /* __WORDSIZE */
#if __WORDSIZE == 64
#define JIT_INSTR_MAX 104
0, /* data */
0, /* live */
6, /* align */
0, /* save */
0, /* load */
0, /* #name */
0, /* #note */
2, /* label */
42, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
44, /* va_start */
104, /* va_arg */
100, /* va_arg_d */
0, /* va_end */
8, /* addr */
24, /* addi */
8, /* addcr */
20, /* addci */
8, /* addxr */
12, /* addxi */
12, /* subr */
24, /* subi */
12, /* subcr */
20, /* subci */
12, /* subxr */
12, /* subxi */
28, /* rsbi */
8, /* mulr */
24, /* muli */
60, /* qmulr */
68, /* qmuli */
16, /* qmulr_u */
32, /* qmuli_u */
12, /* divr */
28, /* divi */
16, /* divr_u */
32, /* divi_u */
16, /* qdivr */
20, /* qdivi */
20, /* qdivr_u */
24, /* qdivi_u */
12, /* remr */
28, /* remi */
16, /* remr_u */
32, /* remi_u */
8, /* andr */
20, /* andi */
8, /* orr */
20, /* ori */
8, /* xorr */
24, /* xori */
6, /* lshr */
10, /* lshi */
6, /* rshr */
10, /* rshi */
6, /* rshr_u */
10, /* rshi_u */
4, /* negr */
12, /* comr */
20, /* ltr */
24, /* lti */
20, /* ltr_u */
24, /* lti_u */
20, /* ler */
24, /* lei */
20, /* ler_u */
24, /* lei_u */
20, /* eqr */
24, /* eqi */
20, /* ger */
24, /* gei */
20, /* ger_u */
24, /* gei_u */
20, /* gtr */
24, /* gti */
20, /* gtr_u */
24, /* gti_u */
20, /* ner */
24, /* nei */
4, /* movr */
16, /* movi */
4, /* extr_c */
4, /* extr_uc */
4, /* extr_s */
4, /* extr_us */
4, /* extr_i */
4, /* extr_ui */
4, /* htonr_us */
4, /* htonr_ui */
4, /* htonr_ul */
6, /* ldr_c */
18, /* ldi_c */
6, /* ldr_uc */
18, /* ldi_uc */
6, /* ldr_s */
18, /* ldi_s */
6, /* ldr_us */
18, /* ldi_us */
6, /* ldr_i */
18, /* ldi_i */
6, /* ldr_ui */
18, /* ldi_ui */
6, /* ldr_l */
18, /* ldi_l */
14, /* ldxr_c */
26, /* ldxi_c */
14, /* ldxr_uc */
26, /* ldxi_uc */
14, /* ldxr_s */
26, /* ldxi_s */
14, /* ldxr_us */
26, /* ldxi_us */
14, /* ldxr_i */
26, /* ldxi_i */
14, /* ldxr_ui */
26, /* ldxi_ui */
14, /* ldxr_l */
26, /* ldxi_l */
4, /* str_c */
16, /* sti_c */
4, /* str_s */
16, /* sti_s */
4, /* str_i */
16, /* sti_i */
6, /* str_l */
18, /* sti_l */
12, /* stxr_c */
28, /* stxi_c */
12, /* stxr_s */
28, /* stxi_s */
12, /* stxr_i */
28, /* stxi_i */
14, /* stxr_l */
30, /* stxi_l */
10, /* bltr */
14, /* blti */
10, /* bltr_u */
14, /* blti_u */
10, /* bler */
14, /* blei */
10, /* bler_u */
14, /* blei_u */
10, /* beqr */
26, /* beqi */
10, /* bger */
14, /* bgei */
10, /* bger_u */
14, /* bgei_u */
10, /* bgtr */
14, /* bgti */
10, /* bgtr_u */
14, /* bgti_u */
10, /* bner */
26, /* bnei */
18, /* bmsr */
18, /* bmsi */
18, /* bmcr */
18, /* bmci */
10, /* boaddr */
14, /* boaddi */
10, /* boaddr_u */
14, /* boaddi_u */
10, /* bxaddr */
14, /* bxaddi */
10, /* bxaddr_u */
14, /* bxaddi_u */
10, /* bosubr */
14, /* bosubi */
10, /* bosubr_u */
14, /* bosubi_u */
10, /* bxsubr */
14, /* bxsubi */
10, /* bxsubr_u */
14, /* bxsubi_u */
2, /* jmpr */
18, /* jmpi */
2, /* callr */
18, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
40, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
6, /* addr_f */
26, /* addi_f */
8, /* subr_f */
26, /* subi_f */
28, /* rsbi_f */
6, /* mulr_f */
26, /* muli_f */
8, /* divr_f */
26, /* divi_f */
4, /* negr_f */
4, /* absr_f */
4, /* sqrtr_f */
16, /* ltr_f */
36, /* lti_f */
16, /* ler_f */
36, /* lei_f */
16, /* eqr_f */
36, /* eqi_f */
16, /* ger_f */
36, /* gei_f */
16, /* gtr_f */
36, /* gti_f */
16, /* ner_f */
36, /* nei_f */
16, /* unltr_f */
36, /* unlti_f */
16, /* unler_f */
36, /* unlei_f */
20, /* uneqr_f */
40, /* uneqi_f */
16, /* unger_f */
36, /* ungei_f */
16, /* ungtr_f */
36, /* ungti_f */
20, /* ltgtr_f */
40, /* ltgti_f */
16, /* ordr_f */
36, /* ordi_f */
16, /* unordr_f */
36, /* unordi_f */
4, /* truncr_f_i */
4, /* truncr_f_l */
4, /* extr_f */
4, /* extr_d_f */
2, /* movr_f */
20, /* movi_f */
4, /* ldr_f */
16, /* ldi_f */
12, /* ldxr_f */
24, /* ldxi_f */
4, /* str_f */
16, /* sti_f */
12, /* stxr_f */
24, /* stxi_f */
10, /* bltr_f */
30, /* blti_f */
10, /* bler_f */
30, /* blei_f */
10, /* beqr_f */
30, /* beqi_f */
10, /* bger_f */
30, /* bgei_f */
10, /* bgtr_f */
30, /* bgti_f */
10, /* bner_f */
30, /* bnei_f */
10, /* bunltr_f */
30, /* bunlti_f */
10, /* bunler_f */
30, /* bunlei_f */
18, /* buneqr_f */
38, /* buneqi_f */
10, /* bunger_f */
30, /* bungei_f */
10, /* bungtr_f */
30, /* bungti_f */
18, /* bltgtr_f */
38, /* bltgti_f */
10, /* bordr_f */
30, /* bordi_f */
10, /* bunordr_f */
30, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
6, /* addr_d */
26, /* addi_d */
8, /* subr_d */
26, /* subi_d */
28, /* rsbi_d */
6, /* mulr_d */
26, /* muli_d */
8, /* divr_d */
26, /* divi_d */
4, /* negr_d */
4, /* absr_d */
4, /* sqrtr_d */
16, /* ltr_d */
36, /* lti_d */
16, /* ler_d */
36, /* lei_d */
16, /* eqr_d */
36, /* eqi_d */
16, /* ger_d */
36, /* gei_d */
16, /* gtr_d */
36, /* gti_d */
16, /* ner_d */
36, /* nei_d */
16, /* unltr_d */
36, /* unlti_d */
16, /* unler_d */
36, /* unlei_d */
20, /* uneqr_d */
40, /* uneqi_d */
16, /* unger_d */
36, /* ungei_d */
16, /* ungtr_d */
36, /* ungti_d */
20, /* ltgtr_d */
40, /* ltgti_d */
16, /* ordr_d */
36, /* ordi_d */
16, /* unordr_d */
36, /* unordi_d */
4, /* truncr_d_i */
4, /* truncr_d_l */
4, /* extr_d */
4, /* extr_f_d */
2, /* movr_d */
24, /* movi_d */
4, /* ldr_d */
16, /* ldi_d */
12, /* ldxr_d */
24, /* ldxi_d */
4, /* str_d */
16, /* sti_d */
12, /* stxr_d */
24, /* stxi_d */
10, /* bltr_d */
30, /* blti_d */
10, /* bler_d */
30, /* blei_d */
10, /* beqr_d */
34, /* beqi_d */
10, /* bger_d */
30, /* bgei_d */
10, /* bgtr_d */
30, /* bgti_d */
10, /* bner_d */
30, /* bnei_d */
10, /* bunltr_d */
30, /* bunlti_d */
10, /* bunler_d */
30, /* bunlei_d */
18, /* buneqr_d */
38, /* buneqi_d */
10, /* bunger_d */
30, /* bungei_d */
10, /* bungtr_d */
30, /* bungti_d */
18, /* bltgtr_d */
38, /* bltgti_d */
10, /* bordr_d */
30, /* bordi_d */
10, /* bunordr_d */
30, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
0, /* movr_w_f */
0, /* movr_ww_d */
0, /* movr_w_d */
0, /* movr_f_w */
0, /* movi_f_w */
0, /* movr_d_ww */
0, /* movi_d_ww */
0, /* movr_d_w */
0, /* movi_d_w */
#endif /* __WORDSIZE */

1690
jit/jit_s390.c Normal file
View file

File diff suppressed because it is too large Load diff

68
jit/jit_s390.h Normal file
View file

@ -0,0 +1,68 @@
/*
* Copyright (C) 2013-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#ifndef _jit_s390_h
#define _jit_s390_h
#define JIT_HASH_CONSTS 1
#define JIT_NUM_OPERANDS 2
/*
* Types
*/
#define JIT_FP _R13
typedef enum {
#define jit_r(i) (_R12 + ((i) << 1))
#define jit_r_num() 3
#define jit_v(i) (_R11 + ((i) << 1))
#define jit_v_num() 3
#define jit_f(i) (_F8 + (i))
#define jit_f_num() 6
#define JIT_R0 _R12
#define JIT_R1 _R10
#define JIT_R2 _R8
#define JIT_V0 _R11
#define JIT_V1 _R9
#define JIT_V2 _R7
_R0, _R1, /* Volatile */
_R12, /* Saved, GOT */
_R11, _R10, _R9, _R8, /* Saved */
_R7, /* Saved */
_R6, /* Saved, parameter */
_R5, _R4, _R3, /* Parameter passing */
_R2, /* Volatile, parameter and return value */
_R13, /* Saved, literal pool pointer */
_R14, /* Volatile, return address */
_R15, /* Saved, stack pointer */
#define JIT_F0 _F8
#define JIT_F1 _F9
#define JIT_F2 _F10
#define JIT_F3 _F11
#define JIT_F4 _F12
#define JIT_F5 _F13
_F1, _F3, _F5, _F7, /* Volatile */
_F14, _F15, _F8, _F9, /* Saved */
_F10, _F11, _F12, _F13, /* Saved */
_F6, _F4, _F2, /* Volatile, parameter */
_F0, /* Volatile, parameter and return value */
_NOREG,
#define JIT_NOREG _NOREG
} jit_reg_t;
#endif /* _jit_s390_h */

130
jit/jit_size.c Normal file
View file

@ -0,0 +1,130 @@
/*
* Copyright (C) 2013-2018 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#include "jit.h"
#include "jit/jit_private.h"
#if GET_JIT_SIZE
# include <stdio.h>
#endif
/*
* Initialization
*/
static jit_int16_t _szs[jit_code_last_code] = {
#if GET_JIT_SIZE
# define JIT_INSTR_MAX 256
#else
# if defined(__i386__) || defined(__x86_64__)
# include "jit_x86-sz.c"
# elif defined(__mips__)
# include "jit_mips-sz.c"
# elif defined(__arm__)
# include "jit_arm-sz.c"
# elif defined(__ppc__) || defined(__powerpc__)
# include "jit_ppc-sz.c"
# elif defined(__sparc__)
# include "jit_sparc-sz.c"
# elif defined(__ia64__)
# include "jit_ia64-sz.c"
# elif defined(__hppa__)
# include "jit_hppa-sz.c"
# elif defined(__aarch64__)
# include "jit_aarch64-sz.c"
# elif defined(__s390__) || defined(__s390x__)
# include "jit_s390-sz.c"
# elif defined(__alpha__)
# include "jit_alpha-sz.c"
# endif
#endif
};
/*
* Implementation
*/
void
jit_init_size(void)
{
#if DEBUG
# if !GET_JIT_SIZE
jit_word_t offset;
for (offset = 0; offset < jit_size(_szs); offset++)
if (_szs[offset] != 0)
return;
/* Ensure data was collected */
abort();
# endif
#endif
}
#if GET_JIT_SIZE
void
_jit_size_prepare(jit_state_t *_jit)
{
_jitc->cptr = _jit->code.ptr;
_jitc->size = _jit->pc.w;
}
void
_jit_size_collect(jit_state_t *_jit, jit_node_t *node)
{
jit_word_t length;
if (_jitc->cptr == _jit->code.ptr) {
length = _jit->pc.w - _jitc->size;
if (_szs[node->code] < length)
_szs[node->code] = length;
}
}
#else
jit_word_t
_jit_get_size(jit_state_t *_jit)
{
jit_word_t size;
jit_node_t *node;
for (size = JIT_INSTR_MAX, node = _jitc->head; node; node = node->next)
size += _szs[node->code];
return ((size + 4095) & -4096);
}
#endif
jit_word_t
jit_get_max_instr(void)
{
return (JIT_INSTR_MAX >= 144 ? JIT_INSTR_MAX : 144);
}
void
jit_finish_size(void)
{
#if GET_JIT_SIZE
FILE *fp;
jit_word_t offset;
/* Define a single path */
fp = fopen(JIT_SIZE_PATH, "a");
assert(fp);
for (offset = 0; offset < jit_size(_szs); offset++)
fprintf(fp, "%d %d\n", offset, _szs[offset]);
fclose(fp);
#endif
}

2568
jit/jit_sparc-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1499
jit/jit_sparc-fpu.c Normal file
View file

File diff suppressed because it is too large Load diff

803
jit/jit_sparc-sz.c Normal file
View file

@ -0,0 +1,803 @@
#if __WORDSIZE == 32
#define JIT_INSTR_MAX 44
0, /* data */
0, /* live */
0, /* align */
0, /* save */
0, /* load */
0, /* #name */
0, /* #note */
0, /* label */
36, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
4, /* va_start */
8, /* va_arg */
8, /* va_arg_d */
0, /* va_end */
4, /* addr */
12, /* addi */
4, /* addcr */
12, /* addci */
4, /* addxr */
4, /* addxi */
4, /* subr */
12, /* subi */
4, /* subcr */
12, /* subci */
4, /* subxr */
4, /* subxi */
16, /* rsbi */
4, /* mulr */
12, /* muli */
8, /* qmulr */
16, /* qmuli */
8, /* qmulr_u */
16, /* qmuli_u */
12, /* divr */
20, /* divi */
8, /* divr_u */
16, /* divi_u */
28, /* qdivr */
24, /* qdivi */
24, /* qdivr_u */
20, /* qdivi_u */
20, /* remr */
28, /* remi */
16, /* remr_u */
24, /* remi_u */
4, /* andr */
12, /* andi */
4, /* orr */
12, /* ori */
4, /* xorr */
12, /* xori */
4, /* lshr */
4, /* lshi */
4, /* rshr */
4, /* rshi */
4, /* rshr_u */
4, /* rshi_u */
4, /* negr */
4, /* comr */
16, /* ltr */
16, /* lti */
16, /* ltr_u */
16, /* lti_u */
16, /* ler */
16, /* lei */
16, /* ler_u */
16, /* lei_u */
16, /* eqr */
16, /* eqi */
16, /* ger */
16, /* gei */
16, /* ger_u */
16, /* gei_u */
16, /* gtr */
16, /* gti */
16, /* gtr_u */
16, /* gti_u */
16, /* ner */
16, /* nei */
4, /* movr */
8, /* movi */
8, /* extr_c */
4, /* extr_uc */
8, /* extr_s */
8, /* extr_us */
0, /* extr_i */
0, /* extr_ui */
8, /* htonr_us */
4, /* htonr_ui */
0, /* htonr_ul */
4, /* ldr_c */
12, /* ldi_c */
4, /* ldr_uc */
12, /* ldi_uc */
4, /* ldr_s */
12, /* ldi_s */
4, /* ldr_us */
12, /* ldi_us */
4, /* ldr_i */
12, /* ldi_i */
0, /* ldr_ui */
0, /* ldi_ui */
0, /* ldr_l */
0, /* ldi_l */
4, /* ldxr_c */
8, /* ldxi_c */
4, /* ldxr_uc */
8, /* ldxi_uc */
4, /* ldxr_s */
8, /* ldxi_s */
4, /* ldxr_us */
8, /* ldxi_us */
4, /* ldxr_i */
8, /* ldxi_i */
0, /* ldxr_ui */
0, /* ldxi_ui */
0, /* ldxr_l */
0, /* ldxi_l */
4, /* str_c */
12, /* sti_c */
4, /* str_s */
12, /* sti_s */
4, /* str_i */
12, /* sti_i */
0, /* str_l */
0, /* sti_l */
4, /* stxr_c */
8, /* stxi_c */
4, /* stxr_s */
8, /* stxi_s */
4, /* stxr_i */
8, /* stxi_i */
0, /* stxr_l */
0, /* stxi_l */
12, /* bltr */
12, /* blti */
12, /* bltr_u */
12, /* blti_u */
12, /* bler */
12, /* blei */
12, /* bler_u */
12, /* blei_u */
12, /* beqr */
20, /* beqi */
12, /* bger */
12, /* bgei */
12, /* bger_u */
12, /* bgei_u */
12, /* bgtr */
12, /* bgti */
12, /* bgtr_u */
12, /* bgti_u */
12, /* bner */
20, /* bnei */
12, /* bmsr */
12, /* bmsi */
12, /* bmcr */
12, /* bmci */
12, /* boaddr */
12, /* boaddi */
12, /* boaddr_u */
12, /* boaddi_u */
12, /* bxaddr */
12, /* bxaddi */
12, /* bxaddr_u */
12, /* bxaddi_u */
12, /* bosubr */
12, /* bosubi */
12, /* bosubr_u */
12, /* bosubi_u */
12, /* bxsubr */
12, /* bxsubi */
12, /* bxsubr_u */
12, /* bxsubi_u */
8, /* jmpr */
16, /* jmpi */
8, /* callr */
16, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
44, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
4, /* addr_f */
16, /* addi_f */
4, /* subr_f */
16, /* subi_f */
16, /* rsbi_f */
4, /* mulr_f */
16, /* muli_f */
4, /* divr_f */
16, /* divi_f */
4, /* negr_f */
4, /* absr_f */
4, /* sqrtr_f */
16, /* ltr_f */
32, /* lti_f */
16, /* ler_f */
32, /* lei_f */
16, /* eqr_f */
32, /* eqi_f */
16, /* ger_f */
32, /* gei_f */
16, /* gtr_f */
32, /* gti_f */
16, /* ner_f */
32, /* nei_f */
16, /* unltr_f */
32, /* unlti_f */
16, /* unler_f */
32, /* unlei_f */
16, /* uneqr_f */
32, /* uneqi_f */
16, /* unger_f */
32, /* ungei_f */
16, /* ungtr_f */
32, /* ungti_f */
16, /* ltgtr_f */
32, /* ltgti_f */
16, /* ordr_f */
32, /* ordi_f */
16, /* unordr_f */
32, /* unordi_f */
12, /* truncr_f_i */
0, /* truncr_f_l */
12, /* extr_f */
4, /* extr_d_f */
4, /* movr_f */
16, /* movi_f */
4, /* ldr_f */
12, /* ldi_f */
4, /* ldxr_f */
8, /* ldxi_f */
4, /* str_f */
12, /* sti_f */
4, /* stxr_f */
8, /* stxi_f */
12, /* bltr_f */
24, /* blti_f */
12, /* bler_f */
24, /* blei_f */
12, /* beqr_f */
24, /* beqi_f */
12, /* bger_f */
24, /* bgei_f */
12, /* bgtr_f */
24, /* bgti_f */
12, /* bner_f */
28, /* bnei_f */
12, /* bunltr_f */
28, /* bunlti_f */
12, /* bunler_f */
28, /* bunlei_f */
12, /* buneqr_f */
28, /* buneqi_f */
12, /* bunger_f */
28, /* bungei_f */
12, /* bungtr_f */
28, /* bungti_f */
12, /* bltgtr_f */
24, /* bltgti_f */
12, /* bordr_f */
24, /* bordi_f */
12, /* bunordr_f */
28, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
4, /* addr_d */
24, /* addi_d */
4, /* subr_d */
24, /* subi_d */
24, /* rsbi_d */
4, /* mulr_d */
24, /* muli_d */
4, /* divr_d */
24, /* divi_d */
8, /* negr_d */
8, /* absr_d */
4, /* sqrtr_d */
16, /* ltr_d */
40, /* lti_d */
16, /* ler_d */
40, /* lei_d */
16, /* eqr_d */
40, /* eqi_d */
16, /* ger_d */
40, /* gei_d */
16, /* gtr_d */
40, /* gti_d */
16, /* ner_d */
40, /* nei_d */
16, /* unltr_d */
40, /* unlti_d */
16, /* unler_d */
40, /* unlei_d */
16, /* uneqr_d */
40, /* uneqi_d */
16, /* unger_d */
40, /* ungei_d */
16, /* ungtr_d */
40, /* ungti_d */
16, /* ltgtr_d */
40, /* ltgti_d */
16, /* ordr_d */
40, /* ordi_d */
16, /* unordr_d */
40, /* unordi_d */
12, /* truncr_d_i */
0, /* truncr_d_l */
16, /* extr_d */
4, /* extr_f_d */
8, /* movr_d */
24, /* movi_d */
4, /* ldr_d */
12, /* ldi_d */
4, /* ldxr_d */
8, /* ldxi_d */
4, /* str_d */
12, /* sti_d */
4, /* stxr_d */
8, /* stxi_d */
12, /* bltr_d */
32, /* blti_d */
12, /* bler_d */
32, /* blei_d */
12, /* beqr_d */
32, /* beqi_d */
12, /* bger_d */
32, /* bgei_d */
12, /* bgtr_d */
32, /* bgti_d */
12, /* bner_d */
36, /* bnei_d */
12, /* bunltr_d */
36, /* bunlti_d */
12, /* bunler_d */
36, /* bunlei_d */
12, /* buneqr_d */
36, /* buneqi_d */
12, /* bunger_d */
36, /* bungei_d */
12, /* bungtr_d */
36, /* bungti_d */
12, /* bltgtr_d */
32, /* bltgti_d */
12, /* bordr_d */
32, /* bordi_d */
12, /* bunordr_d */
36, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
0, /* movr_w_f */
0, /* movr_ww_d */
0, /* movr_w_d */
0, /* movr_f_w */
0, /* movi_f_w */
0, /* movr_d_ww */
0, /* movi_d_ww */
0, /* movr_d_w */
0, /* movi_d_w */
#endif /* __WORDSIZE */
#if __WORDSIZE == 64
#define JIT_INSTR_MAX 64
0, /* data */
0, /* live */
4, /* align */
0, /* save */
0, /* load */
0, /* #name */
0, /* #note */
4, /* label */
36, /* prolog */
0, /* ellipsis */
0, /* va_push */
0, /* allocai */
0, /* allocar */
0, /* arg */
0, /* getarg_c */
0, /* getarg_uc */
0, /* getarg_s */
0, /* getarg_us */
0, /* getarg_i */
0, /* getarg_ui */
0, /* getarg_l */
0, /* putargr */
0, /* putargi */
4, /* va_start */
8, /* va_arg */
8, /* va_arg_d */
0, /* va_end */
4, /* addr */
28, /* addi */
24, /* addcr */
48, /* addci */
52, /* addxr */
52, /* addxi */
4, /* subr */
28, /* subi */
24, /* subcr */
48, /* subci */
52, /* subxr */
52, /* subxi */
32, /* rsbi */
4, /* mulr */
28, /* muli */
48, /* qmulr */
64, /* qmuli */
48, /* qmulr_u */
64, /* qmuli_u */
4, /* divr */
28, /* divi */
4, /* divr_u */
28, /* divi_u */
20, /* qdivr */
16, /* qdivi */
20, /* qdivr_u */
16, /* qdivi_u */
12, /* remr */
36, /* remi */
12, /* remr_u */
36, /* remi_u */
4, /* andr */
28, /* andi */
4, /* orr */
28, /* ori */
4, /* xorr */
28, /* xori */
4, /* lshr */
4, /* lshi */
4, /* rshr */
4, /* rshi */
4, /* rshr_u */
4, /* rshi_u */
4, /* negr */
4, /* comr */
16, /* ltr */
16, /* lti */
16, /* ltr_u */
16, /* lti_u */
16, /* ler */
16, /* lei */
16, /* ler_u */
16, /* lei_u */
16, /* eqr */
16, /* eqi */
16, /* ger */
16, /* gei */
16, /* ger_u */
16, /* gei_u */
16, /* gtr */
16, /* gti */
16, /* gtr_u */
16, /* gti_u */
16, /* ner */
16, /* nei */
4, /* movr */
24, /* movi */
8, /* extr_c */
4, /* extr_uc */
8, /* extr_s */
8, /* extr_us */
8, /* extr_i */
8, /* extr_ui */
8, /* htonr_us */
8, /* htonr_ui */
4, /* htonr_ul */
4, /* ldr_c */
28, /* ldi_c */
4, /* ldr_uc */
28, /* ldi_uc */
4, /* ldr_s */
28, /* ldi_s */
4, /* ldr_us */
28, /* ldi_us */
4, /* ldr_i */
28, /* ldi_i */
4, /* ldr_ui */
28, /* ldi_ui */
4, /* ldr_l */
28, /* ldi_l */
4, /* ldxr_c */
24, /* ldxi_c */
4, /* ldxr_uc */
24, /* ldxi_uc */
4, /* ldxr_s */
24, /* ldxi_s */
4, /* ldxr_us */
24, /* ldxi_us */
4, /* ldxr_i */
24, /* ldxi_i */
4, /* ldxr_ui */
24, /* ldxi_ui */
4, /* ldxr_l */
24, /* ldxi_l */
4, /* str_c */
28, /* sti_c */
4, /* str_s */
28, /* sti_s */
4, /* str_i */
28, /* sti_i */
4, /* str_l */
28, /* sti_l */
4, /* stxr_c */
24, /* stxi_c */
4, /* stxr_s */
24, /* stxi_s */
4, /* stxr_i */
24, /* stxi_i */
4, /* stxr_l */
24, /* stxi_l */
12, /* bltr */
12, /* blti */
12, /* bltr_u */
12, /* blti_u */
12, /* bler */
12, /* blei */
12, /* bler_u */
12, /* blei_u */
12, /* beqr */
36, /* beqi */
12, /* bger */
12, /* bgei */
12, /* bger_u */
12, /* bgei_u */
12, /* bgtr */
12, /* bgti */
12, /* bgtr_u */
12, /* bgti_u */
12, /* bner */
36, /* bnei */
12, /* bmsr */
12, /* bmsi */
12, /* bmcr */
12, /* bmci */
12, /* boaddr */
12, /* boaddi */
12, /* boaddr_u */
12, /* boaddi_u */
12, /* bxaddr */
12, /* bxaddi */
12, /* bxaddr_u */
12, /* bxaddi_u */
12, /* bosubr */
12, /* bosubi */
12, /* bosubr_u */
12, /* bosubi_u */
12, /* bxsubr */
12, /* bxsubi */
12, /* bxsubr_u */
12, /* bxsubi_u */
8, /* jmpr */
32, /* jmpi */
8, /* callr */
32, /* calli */
0, /* prepare */
0, /* pushargr */
0, /* pushargi */
0, /* finishr */
0, /* finishi */
0, /* ret */
0, /* retr */
0, /* reti */
0, /* retval_c */
0, /* retval_uc */
0, /* retval_s */
0, /* retval_us */
0, /* retval_i */
0, /* retval_ui */
0, /* retval_l */
44, /* epilog */
0, /* arg_f */
0, /* getarg_f */
0, /* putargr_f */
0, /* putargi_f */
16, /* addr_f */
40, /* addi_f */
24, /* subr_f */
40, /* subi_f */
40, /* rsbi_f */
16, /* mulr_f */
40, /* muli_f */
16, /* divr_f */
40, /* divi_f */
12, /* negr_f */
12, /* absr_f */
12, /* sqrtr_f */
24, /* ltr_f */
48, /* lti_f */
24, /* ler_f */
48, /* lei_f */
24, /* eqr_f */
48, /* eqi_f */
24, /* ger_f */
48, /* gei_f */
24, /* gtr_f */
48, /* gti_f */
24, /* ner_f */
48, /* nei_f */
24, /* unltr_f */
48, /* unlti_f */
24, /* unler_f */
48, /* unlei_f */
24, /* uneqr_f */
48, /* uneqi_f */
24, /* unger_f */
48, /* ungei_f */
24, /* ungtr_f */
48, /* ungti_f */
24, /* ltgtr_f */
48, /* ltgti_f */
24, /* ordr_f */
48, /* ordi_f */
24, /* unordr_f */
48, /* unordi_f */
16, /* truncr_f_i */
16, /* truncr_f_l */
20, /* extr_f */
12, /* extr_d_f */
16, /* movr_f */
32, /* movi_f */
8, /* ldr_f */
32, /* ldi_f */
8, /* ldxr_f */
28, /* ldxi_f */
8, /* str_f */
32, /* sti_f */
8, /* stxr_f */
28, /* stxi_f */
20, /* bltr_f */
44, /* blti_f */
20, /* bler_f */
44, /* blei_f */
28, /* beqr_f */
60, /* beqi_f */
20, /* bger_f */
44, /* bgei_f */
20, /* bgtr_f */
44, /* bgti_f */
20, /* bner_f */
44, /* bnei_f */
20, /* bunltr_f */
44, /* bunlti_f */
20, /* bunler_f */
44, /* bunlei_f */
20, /* buneqr_f */
44, /* buneqi_f */
20, /* bunger_f */
44, /* bungei_f */
20, /* bungtr_f */
44, /* bungti_f */
20, /* bltgtr_f */
44, /* bltgti_f */
20, /* bordr_f */
44, /* bordi_f */
20, /* bunordr_f */
44, /* bunordi_f */
0, /* pushargr_f */
0, /* pushargi_f */
0, /* retr_f */
0, /* reti_f */
0, /* retval_f */
0, /* arg_d */
0, /* getarg_d */
0, /* putargr_d */
0, /* putargi_d */
4, /* addr_d */
32, /* addi_d */
4, /* subr_d */
32, /* subi_d */
32, /* rsbi_d */
4, /* mulr_d */
32, /* muli_d */
4, /* divr_d */
32, /* divi_d */
4, /* negr_d */
4, /* absr_d */
4, /* sqrtr_d */
16, /* ltr_d */
48, /* lti_d */
16, /* ler_d */
48, /* lei_d */
16, /* eqr_d */
48, /* eqi_d */
16, /* ger_d */
48, /* gei_d */
16, /* gtr_d */
48, /* gti_d */
16, /* ner_d */
48, /* nei_d */
16, /* unltr_d */
48, /* unlti_d */
16, /* unler_d */
48, /* unlei_d */
16, /* uneqr_d */
48, /* uneqi_d */
16, /* unger_d */
48, /* ungei_d */
16, /* ungtr_d */
48, /* ungti_d */
16, /* ltgtr_d */
48, /* ltgti_d */
16, /* ordr_d */
48, /* ordi_d */
16, /* unordr_d */
48, /* unordi_d */
16, /* truncr_d_i */
12, /* truncr_d_l */
12, /* extr_d */
8, /* extr_f_d */
4, /* movr_d */
32, /* movi_d */
4, /* ldr_d */
28, /* ldi_d */
4, /* ldxr_d */
24, /* ldxi_d */
4, /* str_d */
28, /* sti_d */
4, /* stxr_d */
24, /* stxi_d */
12, /* bltr_d */
40, /* blti_d */
12, /* bler_d */
40, /* blei_d */
12, /* beqr_d */
40, /* beqi_d */
12, /* bger_d */
40, /* bgei_d */
12, /* bgtr_d */
40, /* bgti_d */
12, /* bner_d */
44, /* bnei_d */
12, /* bunltr_d */
44, /* bunlti_d */
12, /* bunler_d */
44, /* bunlei_d */
12, /* buneqr_d */
44, /* buneqi_d */
12, /* bunger_d */
44, /* bungei_d */
12, /* bungtr_d */
44, /* bungti_d */
12, /* bltgtr_d */
40, /* bltgti_d */
12, /* bordr_d */
40, /* bordi_d */
12, /* bunordr_d */
44, /* bunordi_d */
0, /* pushargr_d */
0, /* pushargi_d */
0, /* retr_d */
0, /* reti_d */
0, /* retval_d */
0, /* movr_w_f */
0, /* movr_ww_d */
0, /* movr_w_d */
0, /* movr_f_w */
0, /* movi_f_w */
0, /* movr_d_ww */
0, /* movi_d_ww */
0, /* movr_d_w */
0, /* movi_d_w */
#endif /* __WORDSIZE */

1926
jit/jit_sparc.c Normal file
View file

File diff suppressed because it is too large Load diff

102
jit/jit_sparc.h Normal file
View file

@ -0,0 +1,102 @@
/*
* Copyright (C) 2013-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* Authors:
* Paulo Cesar Pereira de Andrade
*/
#ifndef _jit_sparc_h
#define _jit_sparc_h
#define JIT_HASH_CONSTS 1
#define JIT_NUM_OPERANDS 3
/*
* Types
*/
#define JIT_FP _FP
typedef enum {
#define jit_r(i) (_G2 + (i))
#define jit_r_num() 3
#define jit_v(i) (_L0 + (i))
#define jit_v_num() 8
#if __WORDSIZE == 32
# define jit_f(i) (_F0 + ((i) << 1))
# define jit_f_num() 8
#else
# define jit_f(i) (_F32 - (i))
# define jit_f_num() 16
#endif
#define JIT_R0 _G2
#define JIT_R1 _G3
#define JIT_R2 _G4
#define JIT_V0 _L0
#define JIT_V1 _L1
#define JIT_V2 _L2
#define JIT_V3 _L3
#define JIT_V4 _L4
#define JIT_V5 _L5
#define JIT_V6 _L6
#define JIT_V7 _L7
_G0, _G1, _G2, _G3, _G4, _G5, _G6, _G7,
_O0, _O1, _O2, _O3, _O4, _O5, _SP, _O7,
_L0, _L1, _L2, _L3, _L4, _L5, _L6, _L7,
_I0, _I1, _I2, _I3, _I4, _I5, _FP, _I7,
#if __WORDSIZE == 32
# define JIT_F0 _F0
# define JIT_F1 _F2
# define JIT_F2 _F4
# define JIT_F3 _F6
# define JIT_F4 _F8
# define JIT_F5 _F10
# define JIT_F6 _F12
# define JIT_F7 _F14
_F0, _F1, _F2, _F3, _F4, _F5, _F6, _F7,
_F8, _F9, _F10, _F11, _F12, _F13, _F14, _F15,
#else
/* All single precision operations have a high cost due to being
* stored on registers only encodable as double precision.
* The cost is due to needing to move values to a register with
* value <= 31.
* This is a limitation due to using fixed named registers in
* lightning. */
# define JIT_F0 _F32
# define JIT_F1 _F34
# define JIT_F2 _F36
# define JIT_F3 _F38
# define JIT_F4 _F40
# define JIT_F5 _F42
# define JIT_F6 _F44
# define JIT_F7 _F46
# define JIT_F8 _F48
# define JIT_F9 _F50
# define JIT_F10 _F52
# define JIT_F11 _F54
# define JIT_F12 _F56
# define JIT_F13 _F58
# define JIT_F14 _F60
# define JIT_F15 _F62
_F62, _F60, _F58, _F56, _F54, _F52, _F50, _F48,
_F46, _F44, _F42, _F40, _F38, _F36, _F34, _F32,
_F31, _F30, _F29, _F28, _F27, _F26, _F25, _F24,
_F23, _F22, _F21, _F20, _F19, _F18, _F17, _F16,
_F15, _F14, _F13, _F12, _F11, _F10, _F9, _F8,
_F7, _F6, _F5, _F4, _F3, _F2, _F1, _F0,
#endif
#define JIT_NOREG _NOREG
_NOREG,
} jit_reg_t;
#endif /* _jit_sparc_h */

3861
jit/jit_x86-cpu.c Normal file
View file

File diff suppressed because it is too large Load diff

1569
jit/jit_x86-sse.c Normal file
View file

File diff suppressed because it is too large Load diff

1610
jit/jit_x86-sz.c Normal file
View file

File diff suppressed because it is too large Load diff

1344
jit/jit_x86-x87.c Normal file
View file

File diff suppressed because it is too large Load diff

2264
jit/jit_x86.c Normal file
View file

File diff suppressed because it is too large Load diff

199
jit/jit_x86.h Normal file
View file

@ -0,0 +1,199 @@
/*
* Copyright (C) 2012-2017 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
* GNU lightning 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 3, or (at your option)
* any later version.
*
* GNU lightning 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.
*
* 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) <= _ST6)
#if __WORDSIZE == 32
# if defined(__x86_64__)
# define __X64_32 1
# define __X64 1
# else
# define __X32 1
# endif
#else
# define __X64 1
#endif
#define JIT_FP _RBP
typedef enum {
#if __X32
# define jit_r(i) (_RAX + (i))
# define jit_r_num() 3
# define jit_v(i) (_RBX + (i))
# define jit_v_num() 3
# define jit_f(i) (jit_cpu.sse2 ? _XMM0 + (i) : _ST0 + (i))
# define jit_f_num() (jit_cpu.sse2 ? 8 : 6)
# 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)
_XMM0, _XMM1, _XMM2, _XMM3, _XMM4, _XMM5, _XMM6, _XMM7,
# define jit_sse_reg_p(reg) ((reg) >= _XMM0 && (reg) <= _XMM7)
#else
# if __CYGWIN__
# define jit_r(i) (_RAX + (i))
# define jit_r_num() 3
# define jit_v(i) (_RBX + (i))
# define jit_v_num() 7
# define jit_f(index) (_XMM4 + (index))
# define jit_f_num() 12
# define JIT_R0 _RAX
# define JIT_R1 _R10
# define JIT_R2 _R11
# define JIT_V0 _RBX
# define JIT_V1 _RDI
# define JIT_V2 _RSI
# define JIT_V3 _R12
# define JIT_V4 _R13
# define JIT_V5 _R14
# define JIT_V6 _R15
/* Volatile - Return value register */
_RAX,
/* Volatile */
_R10, _R11,
/* Nonvolatile */
_RBX, _RDI, _RSI,
_R12, _R13, _R14, _R15,
/* Volatile - Integer arguments (4 to 1) */
_R9, _R8, _RDX, _RCX,
/* Nonvolatile */
_RSP, _RBP,
# define JIT_F0 _XMM4
# define JIT_F1 _XMM5
# define JIT_F2 _XMM6
# define JIT_F3 _XMM7
# define JIT_F4 _XMM8
# define JIT_F5 _XMM9
# define JIT_F6 _XMM10
# define JIT_F7 _XMM11
# define JIT_F8 _XMM12
# define JIT_F9 _XMM13
# define JIT_F10 _XMM14
# define JIT_F11 _XMM15
/* Volatile */
_XMM4, _XMM5,
/* Nonvolatile */
_XMM6, _XMM7, _XMM8, _XMM9, _XMM10,
_XMM11, _XMM12, _XMM13, _XMM14, _XMM15,
/* Volatile - FP arguments (4 to 1) */
_XMM3, _XMM2, _XMM1, _XMM0,
# define jit_sse_reg_p(reg) ((reg) >= _XMM4 && (reg) <= _XMM0)
# else
# define jit_r(i) (_RAX + (i))
# define jit_r_num() 4
# define jit_v(i) (_RBX + (i))
# define jit_v_num() 4
# define jit_f(index) (_XMM8 + (index))
# define jit_f_num() 8
# 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,
_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,
_XMM7, _XMM6, _XMM5, _XMM4, _XMM3, _XMM2, _XMM1, _XMM0,
# define jit_sse_reg_p(reg) ((reg) >= _XMM8 && (reg) <= _XMM0)
# endif
#endif
_ST0, _ST1, _ST2, _ST3, _ST4, _ST5, _ST6,
# 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;
/*
* Initialization
*/
extern jit_cpu_t jit_cpu;
#endif /* _jit_x86_h */

3424
jit/lightning.c Normal file
View file

File diff suppressed because it is too large Load diff