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

Merge from upstream lightening

Browse source
This commit is contained in:
Andy Wingo 2019-04-28 13:53:16 +02:00
commit 51618e7e83
213 changed files with 1249 additions and 2116 deletions
Download patch file Download diff file Expand all files Collapse all files

16
libguile/lightening/.gitlab-ci.yml
View file

@ -1,9 +1,19 @@
# use the official gcc image, based on debian
# can use verions as well, like gcc:5.2
# see https://hub.docker.com/_/gcc/
image: gcc
image: debian
test:
before_script:
- dpkg --add-architecture i386
- apt-get update -qq
- apt-get install -y libc6-dev:amd64 libc6-dev:i386 gcc gcc-multilib make
x86-64:
stage: test
script:
- make -C tests check
- make -C tests test-native
i686:
stage: test
script:
- make -C tests test-ia32

9
libguile/lightening/lightening.h
View file

@ -124,8 +124,8 @@ enum jit_operand_abi
JIT_OPERAND_ABI_POINTER,
JIT_OPERAND_ABI_FLOAT,
JIT_OPERAND_ABI_DOUBLE,
JIT_OPERAND_ABI_INTMAX = CHOOSE_32_64(JIT_OPERAND_ABI_INT32,
JIT_OPERAND_ABI_INT64)
JIT_OPERAND_ABI_WORD = CHOOSE_32_64(JIT_OPERAND_ABI_INT32,
JIT_OPERAND_ABI_INT64)
};
enum jit_operand_kind
@ -228,6 +228,11 @@ JIT_API void jit_move_operands (jit_state_t *_jit, jit_operand_t *dst,
JIT_API size_t jit_align_stack (jit_state_t *_jit, size_t expand);
JIT_API void jit_shrink_stack (jit_state_t *_jit, size_t diff);
JIT_API size_t jit_enter_jit_abi (jit_state_t *_jit,
size_t v, size_t vf, size_t frame_size);
JIT_API void jit_leave_jit_abi (jit_state_t *_jit,
size_t v, size_t vf, size_t frame_size);
/* Note that all functions that take jit_operand_t args[] use the args
as scratch space while shuffling values into position. */
JIT_API void jit_calli(jit_state_t *, jit_pointer_t f,

8
libguile/lightening/lightening/aarch64.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2013-2018 Free Software Foundation, Inc.
* Copyright (C) 2013-2019 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
@ -17,6 +17,12 @@
* Paulo Cesar Pereira de Andrade
*/
# define JIT_RA0 _R0
# define JIT_FA0 _V0
# define JIT_SP _SP
# define JIT_RET _R0
# define JIT_FRET _V0
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 8)
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 8)

6
libguile/lightening/lightening/alpha.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2014-2018 Free Software Foundation, Inc.
* Copyright (C) 2014-2019 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
@ -17,6 +17,10 @@
* Paulo Cesar Pereira de Andrade
*/
# define JIT_SP _SP
# define JIT_RET _V0
# define JIT_FRET _F0
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 6)
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 6)
#if __BYTE_ORDER == __LITTLE_ENDIAN

12
libguile/lightening/lightening/arm.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2012-2018 Free Software Foundation, Inc.
* Copyright (C) 2012-2019 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
@ -21,6 +21,16 @@
# include <stdio.h>
#endif
# 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
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 4)
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 16)
#define jit_arg_d_reg_p(i) ((i) >= 0 && (i) < 15)

6
libguile/lightening/lightening/hppa.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2013-2018 Free Software Foundation, Inc.
* Copyright (C) 2013-2019 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
@ -17,6 +17,10 @@
* Paulo Cesar Pereira de Andrade
*/
# define JIT_SP _R30
# define JIT_RET _R28
# define JIT_FRET _F4
#define jit_arg_reg_p(i) (i >= 0 && i < 4)
#define PROTO 1

6
libguile/lightening/lightening/ia64.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2013-2018 Free Software Foundation, Inc.
* Copyright (C) 2013-2019 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
@ -17,6 +17,10 @@
* Paulo Cesar Pereira de Andrade
*/
# define JIT_SP _R12
# define JIT_RET _R8
# define JIT_FRET _F8
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 8)
#if __BYTE_ORDER == __LITTLE_ENDIAN
# define C_DISP 0

192
libguile/lightening/lightening/lightening.c
View file

@ -37,69 +37,6 @@
#define _NOREG 0xffff
#if defined(__i386__) || defined(__x86_64__)
# define JIT_RET _RAX
# if __X32
# define JIT_FRET _ST0
# else
# if __CYGWIN__
# define JIT_RA0 _RCX
# else
# define JIT_RA0 _RDI
# endif
# define JIT_FA0 _XMM0
# define JIT_FRET _XMM0
# endif
#elif defined(__mips__)
# define JIT_RA0 _A0
# define JIT_FA0 _F12
# define JIT_SP _SP
# define JIT_RET _V0
# define JIT_FRET _F0
#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
#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
#elif defined(__sparc__)
# define JIT_SP _SP
# define JIT_RET _I0
# define JIT_FRET _F0
#elif defined(__ia64__)
# define JIT_SP _R12
# define JIT_RET _R8
# define JIT_FRET _F8
#elif defined(__hppa__)
# define JIT_SP _R30
# define JIT_RET _R28
# define JIT_FRET _F4
#elif defined(__aarch64__)
# define JIT_RA0 _R0
# define JIT_FA0 _V0
# define JIT_SP _SP
# define JIT_RET _R0
# define JIT_FRET _V0
#elif defined(__s390__) || defined(__s390x__)
# define JIT_SP _R15
# define JIT_RET _R2
# define JIT_FRET _F0
#elif defined(__alpha__)
# define JIT_SP _SP
# define JIT_RET _V0
# define JIT_FRET _F0
#endif
union jit_pc
{
uint8_t *uc;
@ -137,6 +74,13 @@ static void jit_flush(void *fptr, void *tptr);
static void jit_try_shorten(jit_state_t *_jit, jit_reloc_t reloc,
jit_pointer_t addr);
struct abi_arg_iterator;
static void reset_abi_arg_iterator(struct abi_arg_iterator *iter, size_t argc,
const jit_operand_t *args);
static void next_abi_arg(struct abi_arg_iterator *iter,
jit_operand_t *arg);
jit_bool_t
init_jit(void)
{
@ -574,21 +518,23 @@ abi_mem_to_gpr(jit_state_t *_jit, enum jit_operand_abi abi,
case JIT_OPERAND_ABI_INT16:
jit_ldxi_s(_jit, dst, base, offset);
break;
#if __WORDSIZE == 32
case JIT_OPERAND_ABI_UINT32:
jit_ldxi_ui(_jit, dst, base, offset);
break;
case JIT_OPERAND_ABI_POINTER:
#endif
case JIT_OPERAND_ABI_INT32:
jit_ldxi_i(_jit, dst, base, offset);
break;
case JIT_OPERAND_ABI_UINT64:
jit_ldxi_l(_jit, dst, base, offset);
#if __WORDSIZE == 64
case JIT_OPERAND_ABI_UINT32:
jit_ldxi_ui(_jit, dst, base, offset);
break;
case JIT_OPERAND_ABI_UINT64:
case JIT_OPERAND_ABI_POINTER:
case JIT_OPERAND_ABI_INT64:
jit_ldxi_l(_jit, dst, base, offset);
break;
case JIT_OPERAND_ABI_POINTER:
jit_ldxi_l(_jit, dst, base, offset);
break;
#endif
default:
abort();
}
@ -612,7 +558,7 @@ abi_mem_to_fpr(jit_state_t *_jit, enum jit_operand_abi abi,
static void
abi_imm_to_mem(jit_state_t *_jit, enum jit_operand_abi abi, jit_gpr_t base,
ptrdiff_t offset, intmax_t imm)
ptrdiff_t offset, jit_imm_t imm)
{
ASSERT(!is_fpr_arg(abi));
@ -893,7 +839,7 @@ jit_align_stack(jit_state_t *_jit, size_t expand)
size_t new_size = _jit->frame_size + expand;
// Align stack to double-word boundaries. This isn't really a
// principle but it does work for Aarch32, AArch64 and x86-64.
size_t alignment = __WORDSIZE * 2;
size_t alignment = jit_stack_alignment ();
size_t aligned_size = (new_size + alignment - 1) & ~(alignment - 1);
size_t diff = aligned_size - _jit->frame_size;
if (diff)
@ -910,6 +856,107 @@ jit_shrink_stack(jit_state_t *_jit, size_t diff)
_jit->frame_size -= diff;
}
static const jit_gpr_t V[] = {
#ifdef JIT_VTMP
JIT_VTMP ,
#endif
JIT_V0, JIT_V1, JIT_V2
#ifdef JIT_V3
, JIT_V3
#endif
#ifdef JIT_V4
, JIT_V4
#endif
#ifdef JIT_V5
, JIT_V5
#endif
#ifdef JIT_V6
, JIT_V6
#endif
#ifdef JIT_V7
, JIT_V7
#endif
};
static const jit_fpr_t VF[] = {
#ifdef JIT_VFTMP
JIT_VFTMP ,
#endif
#ifdef JIT_VF0
JIT_VF0
#endif
#ifdef JIT_VF1
, JIT_VF1
#endif
#ifdef JIT_VF2
, JIT_VF2
#endif
#ifdef JIT_VF3
, JIT_VF3
#endif
#ifdef JIT_VF4
, JIT_VF4
#endif
#ifdef JIT_VF5
, JIT_VF5
#endif
#ifdef JIT_VF6
, JIT_VF6
#endif
#ifdef JIT_VF7
, JIT_VF7
#endif
};
static const size_t v_count = sizeof(V) / sizeof(V[0]);
static const size_t vf_count = sizeof(VF) / sizeof(VF[0]);
size_t
jit_enter_jit_abi(jit_state_t *_jit, size_t v, size_t vf, size_t frame_size)
{
#ifdef JIT_VTMP
v++;
#endif
#ifdef JIT_VFTMP
vf++;
#endif
ASSERT(v <= v_count);
ASSERT(vf <= vf_count);
ASSERT(_jit->frame_size == 0);
_jit->frame_size = jit_initial_frame_size();
/* Save values of callee-save registers. */
for (size_t i = 0; i < v; i++)
jit_pushr (_jit, V[i]);
for (size_t i = 0; i < vf; i++)
jit_pushr_d (_jit, VF[i]);
return jit_align_stack(_jit, frame_size);
}
void
jit_leave_jit_abi(jit_state_t *_jit, size_t v, size_t vf, size_t frame_size)
{
#ifdef JIT_VTMP
v++;
#endif
#ifdef JIT_VFTMP
vf++;
#endif
jit_shrink_stack(_jit, frame_size);
/* Restore callee-save registers. */
for (size_t i = 0; i < vf; i++)
jit_popr_d (_jit, VF[vf - i - 1]);
for (size_t i = 0; i < v; i++)
jit_popr (_jit, V[v - i - 1]);
}
// Precondition: stack is already aligned.
static size_t
prepare_call_args(jit_state_t *_jit, size_t argc, jit_operand_t args[])
@ -972,6 +1019,7 @@ jit_locate_args(jit_state_t *_jit, size_t argc, jit_operand_t args[])
struct abi_arg_iterator iter;
reset_abi_arg_iterator(&iter, argc, args);
iter.stack_size += _jit->frame_size;
for (size_t i = 0; i < argc; i++)
next_abi_arg(&iter, &args[i]);
}

8
libguile/lightening/lightening/mips.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2012-2018 Free Software Foundation, Inc.
* Copyright (C) 2012-2019 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
@ -21,6 +21,12 @@
# include <sys/cachectl.h>
#endif
# define JIT_RA0 _A0
# define JIT_FA0 _F12
# define JIT_SP _SP
# define JIT_RET _V0
# define JIT_FRET _F0
#if NEW_ABI
# define NUM_WORD_ARGS 8
# define STACK_SLOT 8

8
libguile/lightening/lightening/ppc.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2012-2018 Free Software Foundation, Inc.
* Copyright (C) 2012-2019 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
@ -17,6 +17,12 @@
* Paulo Cesar Pereira de Andrade
*/
# define JIT_RA0 _R3
# define JIT_FA0 _F1
# define JIT_SP _R1
# define JIT_RET _R3
# define JIT_FRET _F1
#define jit_arg_reg_p(i) ((i) >= 0 && (i) < 8)
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 13)
#if __BYTE_ORDER == __LITTLE_ENDIAN

6
libguile/lightening/lightening/s390.c
View file

@ -1,5 +1,5 @@
/*
* Copyright (C) 2013-2018 Free Software Foundation, Inc.
* Copyright (C) 2013-2019 Free Software Foundation, Inc.
*
* This file is part of GNU lightning.
*
@ -17,6 +17,10 @@
* Paulo Cesar Pereira de Andrade
*/
# define JIT_SP _R15
# define JIT_RET _R2
# define JIT_FRET _F0
#if __WORDSIZE == 32
# define NUM_FLOAT_REG_ARGS 2
#else

22
libguile/lightening/lightening/sparc.c
View file

@ -1,3 +1,25 @@
/*
* Copyright (C) 2013-2019 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
*/
# define JIT_SP _SP
# define JIT_RET _I0
# define JIT_FRET _F0
/*
* Copyright (C) 2013-2018 Free Software Foundation, Inc.
*

111
libguile/lightening/lightening/x86-cpu.c
View file

@ -20,7 +20,7 @@
/* avoid using it due to partial stalls */
#define USE_INC_DEC 0
#if __X32 || __X64_32
#if __X32
# define WIDE 0
# define IF_WIDE(wide, narrow) narrow
#else
@ -46,7 +46,7 @@
#define _R15_REGNO 15
#define r7(reg) ((reg) & 7)
#define r8(reg) ((reg) & 15)
#if __X32 || __CYGWIN__ || __X64_32
#if __X32
# define reg8_p(rn) ((rn) >= _RAX_REGNO && (rn) <= _RBX_REGNO)
#else
# define reg8_p(rn) 1
@ -160,15 +160,13 @@ ii(jit_state_t *_jit, uint32_t i)
emit_u32(_jit, i);
}
#if __X64
static inline void
il(jit_state_t *_jit, unsigned long l)
il(jit_state_t *_jit, uint64_t l)
{
#if __X64 && !__X64_32
emit_u64(_jit, l);
#else
ii(_jit, l);
#endif
}
#endif
static void
rex(jit_state_t *_jit, int32_t l, int32_t w,
@ -254,7 +252,7 @@ rx(jit_state_t *_jit, int32_t rd, int32_t md,
static void
pushr(jit_state_t *_jit, int32_t r0)
{
_jit->frame_size += __WORDSIZE;
_jit->frame_size += __WORDSIZE / 8;
rex(_jit, 0, WIDE, 0, 0, r0);
ic(_jit, 0x50 | r7(r0));
}
@ -262,7 +260,7 @@ pushr(jit_state_t *_jit, int32_t r0)
static void
popr(jit_state_t *_jit, int32_t r0)
{
_jit->frame_size -= __WORDSIZE;
_jit->frame_size -= __WORDSIZE / 8;
rex(_jit, 0, WIDE, 0, 0, r0);
ic(_jit, 0x58 | r7(r0));
}
@ -275,8 +273,7 @@ get_temp_gpr(jit_state_t *_jit)
#ifdef JIT_RTMP
return JIT_RTMP;
#else
pushr(_jit, _RBP_REGNO);
return _RBP;
return JIT_VTMP;
#endif
}
@ -285,9 +282,6 @@ unget_temp_gpr(jit_state_t *_jit)
{
ASSERT(_jit->temp_gpr_saved);
_jit->temp_gpr_saved = 0;
#ifndef JIT_RTMP
popr(_jit, _RBP_REGNO);
#endif
}
static void
@ -410,19 +404,15 @@ static void
imovi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
{
#if __X64
# if !__X64_32
if (fits_uint32_p(i0)) {
# endif
rex(_jit, 0, 0, _NOREG, _NOREG, r0);
ic(_jit, 0xb8 | r7(r0));
ii(_jit, i0);
# if !__X64_32
} else {
rex(_jit, 0, 1, _NOREG, _NOREG, r0);
ic(_jit, 0xb8 | r7(r0));
il(_jit, i0);
}
# endif
#else
ic(_jit, 0xb8 | r7(r0));
ii(_jit, i0);
@ -1024,7 +1014,7 @@ ffsw(jit_word_t i)
return ffs(i);
int bit = ffs((int)i);
if (bit == 0) {
bit = ffs((int)((unsigned long)i >> 32));
bit = ffs((int)((uint64_t)i >> 32));
if (bit)
bit += 32;
}
@ -1494,7 +1484,7 @@ extr_us(jit_state_t *_jit, int32_t r0, int32_t r1)
return movsr_u(_jit, r0, r1);
}
#if __X64 && !__X64_32
#if __X64
static void
extr_i(jit_state_t *_jit, int32_t r0, int32_t r1)
{
@ -1527,7 +1517,7 @@ bswapr_ui(jit_state_t *_jit, int32_t r0, int32_t r1)
ic(_jit, 0xc8 | r7(r0));
}
#if __X64 && !__X64_32
#if __X64
static void
bswapr_ul(jit_state_t *_jit, int32_t r0, int32_t r1)
{
@ -1638,7 +1628,6 @@ ldi_us(jit_state_t *_jit, int32_t r0, jit_word_t i0)
}
}
#if __X32 || !__X64_32
static void
ldr_i(jit_state_t *_jit, int32_t r0, int32_t r1)
{
@ -1669,7 +1658,6 @@ ldi_i(jit_state_t *_jit, int32_t r0, jit_word_t i0)
unget_temp_gpr(_jit);
}
}
#endif
#if __X64
static void
@ -1695,7 +1683,6 @@ ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
}
}
# if !__X64_32
static void
ldr_l(jit_state_t *_jit, int32_t r0, int32_t r1)
{
@ -1718,21 +1705,15 @@ ldi_l(jit_state_t *_jit, int32_t r0, jit_word_t i0)
unget_temp_gpr(_jit);
}
}
# endif
#endif
static void
ldxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
addr(_jit, r0, r1, r2);
ldr_c(r0, r0);
#else
rex(_jit, 0, WIDE, r0, r1, r2);
ic(_jit, 0x0f);
ic(_jit, 0xbe);
rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
}
static void
@ -1754,15 +1735,10 @@ ldxi_c(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
static void
ldxr_uc(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
addr(_jit, r0, r1, r2);
ldr_uc(_jit, r0, r0);
#else
rex(_jit, 0, WIDE, r0, r1, r2);
ic(_jit, 0x0f);
ic(_jit, 0xb6);
rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
}
static void
@ -1784,15 +1760,10 @@ ldxi_uc(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
static void
ldxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
addr(_jit, r0, r1, r2);
ldr_s(_jit, r0, r0);
#else
rex(_jit, 0, WIDE, r0, r1, r2);
ic(_jit, 0x0f);
ic(_jit, 0xbf);
rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
}
static void
@ -1814,15 +1785,10 @@ ldxi_s(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
static void
ldxr_us(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
addr(_jit, r0, r1, r2);
ldr_us(_jit, r0, r0);
#else
rex(_jit, 0, WIDE, r0, r1, r2);
ic(_jit, 0x0f);
ic(_jit, 0xb7);
rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
}
static void
@ -1841,7 +1807,6 @@ ldxi_us(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
}
}
#if __X64 || !__X64_32
static void
ldxr_i(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
@ -1872,21 +1837,14 @@ ldxi_i(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
unget_temp_gpr(_jit);
}
}
#endif
#if __X64
static void
ldxr_ui(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
addr(_jit, r0, r1, r2);
/* to avoid confusion with macro renames */
_ldr_ui(_jit, r0, r0);
#else
rex(_jit, 0, 0, r0, r1, r2);
ic(_jit, 0x8b);
rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
}
static void
@ -1904,7 +1862,6 @@ ldxi_ui(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
}
}
# if !__X64_32
static void
ldxr_l(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
@ -1927,7 +1884,6 @@ ldxi_l(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
unget_temp_gpr(_jit);
}
}
# endif
#endif
static void
@ -2019,7 +1975,7 @@ sti_i(jit_state_t *_jit, jit_word_t i0, int32_t r0)
}
}
#if __X64 && !__X64_32
#if __X64
static void
str_l(jit_state_t *_jit, int32_t r0, int32_t r1)
{
@ -2047,12 +2003,6 @@ sti_l(jit_state_t *_jit, jit_word_t i0, int32_t r0)
static void
stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, jit_gpr_regno(reg), r0, r1);
str_c(_jit, jit_gpr_regno(reg), r2);
unget_temp_gpr(_jit);
#else
if (reg8_p(r2)) {
rex(_jit, 0, 0, r2, r1, r0);
ic(_jit, 0x88);
@ -2065,7 +2015,6 @@ stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
rx(_jit, jit_gpr_regno(reg), 0, r0, r1, _SCL1);
unget_temp_gpr(_jit);
}
#endif
}
static void
@ -2095,17 +2044,10 @@ stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
static void
stxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, jit_gpr_regno(reg), r0, r1);
str_s(_jit, jit_gpr_regno(reg), r2);
unget_temp_gpr(_jit);
#else
ic(_jit, 0x66);
rex(_jit, 0, 0, r2, r1, r0);
ic(_jit, 0x89);
rx(_jit, r2, 0, r0, r1, _SCL1);
#endif
}
static void
@ -2127,16 +2069,9 @@ stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
static void
stxr_i(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, jit_gpr_regno(reg), r0, r1);
str_i(jit_gpr_regno(reg), r2);
unget_temp_gpr(_jit);
#else
rex(_jit, 0, 0, r2, r1, r0);
ic(_jit, 0x89);
rx(_jit, r2, 0, r0, r1, _SCL1);
#endif
}
static void
@ -2154,7 +2089,7 @@ stxi_i(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
}
}
#if __X64 && !__X64_32
#if __X64
static void
stxr_l(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
@ -2664,47 +2599,47 @@ reti(jit_state_t *_jit, jit_word_t i0)
static void
retval_c(jit_state_t *_jit, int32_t r0)
{
extr_c(_jit, r0, jit_gpr_regno(JIT_RET));
extr_c(_jit, r0, _RAX_REGNO);
}
static void
retval_uc(jit_state_t *_jit, int32_t r0)
{
extr_uc(_jit, r0, jit_gpr_regno(JIT_RET));
extr_uc(_jit, r0, _RAX_REGNO);
}
static void
retval_s(jit_state_t *_jit, int32_t r0)
{
extr_s(_jit, r0, jit_gpr_regno(JIT_RET));
extr_s(_jit, r0, _RAX_REGNO);
}
static void
retval_us(jit_state_t *_jit, int32_t r0)
{
extr_us(_jit, r0, jit_gpr_regno(JIT_RET));
extr_us(_jit, r0, _RAX_REGNO);
}
static void
retval_i(jit_state_t *_jit, int32_t r0)
{
#if __X32 || __X64_32
movr(_jit, r0, jit_gpr_regno(JIT_RET));
#if __X32
movr(_jit, r0, _RAX_REGNO);
#else
extr_i(_jit, r0, jit_gpr_regno(JIT_RET));
extr_i(_jit, r0, _RAX_REGNO);
#endif
}
#if __X64 && !__X64_32
#if __X64
static void
retval_ui(jit_state_t *_jit, int32_t r0)
{
extr_ui(_jit, r0, jit_gpr_regno(JIT_RET));
extr_ui(_jit, r0, _RAX_REGNO);
}
static void
retval_l(jit_state_t *_jit, int32_t r0)
{
movr(_jit, r0, jit_gpr_regno(JIT_RET));
movr(_jit, r0, _RAX_REGNO);
}
#endif

163
libguile/lightening/lightening/x86-sse.c
View file

@ -101,7 +101,7 @@ ssexi(jit_state_t *_jit, int32_t c, int32_t r0,
static void
sselxr(jit_state_t *_jit, int32_t p, int32_t c, int32_t r0, int32_t r1)
{
if (__X64 && !__X64_32) {
if (__X64) {
ic(_jit, p);
rex(_jit, 0, 1, r0, 0, r1);
ic(_jit, 0x0f);
@ -316,6 +316,11 @@ xorpdr(jit_state_t *_jit, int32_t r0, int32_t r1)
ssexr(_jit, 0x66, X86_SSE_XOR, r0, r1);
}
static void
orpdr(jit_state_t *_jit, int32_t r0, int32_t r1)
{
ssexr(_jit, 0x66, X86_SSE_OR, r0, r1);
}
static void
pcmpeqlr(jit_state_t *_jit, int32_t r0, int32_t r1)
{
ssexr(_jit, 0x66, X86_SSE_EQD, r0, r1);
@ -398,49 +403,111 @@ movi_d(jit_state_t *_jit, int32_t r0, jit_float64_t i0)
if (data.d == 0.0 && !(data.ii[1] & 0x80000000))
xorpdr(_jit, r0, r0);
else {
jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64 && !__X64_32
movi(_jit, jit_gpr_regno(reg), data.w);
movdqxr(_jit, r0, jit_gpr_regno(reg));
jit_gpr_t ireg = get_temp_gpr(_jit);
#if __X64
movi(_jit, jit_gpr_regno(ireg), data.w);
movdqxr(_jit, r0, jit_gpr_regno(ireg));
unget_temp_gpr(_jit);
#else
movi(_jit, jit_gpr_regno(reg), data.ii[0]);
stxi_i(CVT_OFFSET, _RBP_REGNO, jit_gpr_regno(reg));
movi(_jit, jit_gpr_regno(reg), data.ii[1]);
stxi_i(CVT_OFFSET + 4, _RBP_REGNO, jit_gpr_regno(reg));
jit_fpr_t freg = get_temp_xpr(_jit);
movi(_jit, jit_gpr_regno(ireg), data.ii[1]);
movdlxr(_jit, jit_fpr_regno(freg), jit_gpr_regno(ireg));
pslq(_jit, jit_fpr_regno(freg), 32);
movi(_jit, jit_gpr_regno(ireg), data.ii[0]);
movdlxr(_jit, r0, jit_gpr_regno(ireg));
orpdr(_jit, r0, jit_fpr_regno(freg));
unget_temp_xpr(_jit);
unget_temp_gpr(_jit);
ldxi_d(_jit, r0, _RBP_REGNO, CVT_OFFSET);
#endif
}
}
#if __X32
static void
x87rx(jit_state_t *_jit, int32_t code, int32_t md,
int32_t rb, int32_t ri, int32_t ms)
{
rex(_jit, 0, 1, rb, ri, _NOREG);
ic(_jit, 0xd8 | (code >> 3));
rx(_jit, (code & 7), md, rb, ri, ms);
}
static void
fldsm(jit_state_t *_jit, int32_t md, int32_t rb, int32_t ri, int32_t ms)
{
return x87rx(_jit, 010, md, rb, ri, ms);
}
static void
fstsm(jit_state_t *_jit, int32_t md, int32_t rb, int32_t ri, int32_t ms)
{
return x87rx(_jit, 012, md, rb, ri, ms);
}
static void
fldlm(jit_state_t *_jit, int32_t md, int32_t rb, int32_t ri, int32_t ms)
{
return x87rx(_jit, 050, md, rb, ri, ms);
}
static void
fstlm(jit_state_t *_jit, int32_t md, int32_t rb, int32_t ri, int32_t ms)
{
return x87rx(_jit, 052, md, rb, ri, ms);
}
#endif
static void
retval_f(jit_state_t *_jit, int32_t r0)
{
#if __X64
movr_f(_jit, r0, jit_fpr_regno(JIT_FRET));
#if __X32
subi(_jit, _RSP_REGNO, _RSP_REGNO, 4);
fstsm(_jit, 0, _RSP_REGNO, _NOREG, _SCL1);
ldr_f(_jit, r0, _RSP_REGNO);
addi(_jit, _RSP_REGNO, _RSP_REGNO, 4);
#else
movr_f(_jit, r0, _XMM0_REGNO);
#endif
}
static void
retval_d(jit_state_t *_jit, int32_t r0)
{
#if __X64
movr_d(_jit, r0, jit_fpr_regno(JIT_FRET));
#if __X32
subi(_jit, _RSP_REGNO, _RSP_REGNO, 8);
fstlm(_jit, 0, _RSP_REGNO, _NOREG, _SCL1);
ldr_d(_jit, r0, _RSP_REGNO);
addi(_jit, _RSP_REGNO, _RSP_REGNO, 8);
#else
movr_d(_jit, r0, _XMM0_REGNO);
#endif
}
static void
retr_f(jit_state_t *_jit, int32_t u)
{
movr_f(_jit, jit_fpr_regno(JIT_FRET), u);
#if __X32
subi(_jit, _RSP_REGNO, _RSP_REGNO, 4);
str_f(_jit, _RSP_REGNO, u);
fldsm(_jit, 0, _RSP_REGNO, _NOREG, _SCL1);
addi(_jit, _RSP_REGNO, _RSP_REGNO, 4);
#else
movr_f(_jit, _XMM0_REGNO, u);
#endif
ret(_jit);
}
static void
retr_d(jit_state_t *_jit, int32_t u)
{
movr_d(_jit, jit_fpr_regno(JIT_FRET), u);
#if __X32
subi(_jit, _RSP_REGNO, _RSP_REGNO, 8);
str_d(_jit, _RSP_REGNO, u);
fldlm(_jit, 0, _RSP_REGNO, _NOREG, _SCL1);
addi(_jit, _RSP_REGNO, _RSP_REGNO, 8);
#else
movr_d(_jit, _XMM0_REGNO, u);
#endif
ret(_jit);
}
@ -638,18 +705,10 @@ negr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
unget_temp_gpr(_jit);
}
#if __X32
# define sse_address_p(i0) 1
#elif __X64_32
# define sse_address_p(i0) ((jit_word_t)(i0) >= 0)
# else
# define sse_address_p(i0) can_sign_extend_int_p(i0)
#endif
static void
ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
{
if (sse_address_p(i0))
if (can_sign_extend_int_p(i0))
movssmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
else {
jit_gpr_t reg = get_temp_gpr(_jit);
@ -662,14 +721,7 @@ ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0)
static void
ldxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, jit_gpr_regno(reg), r1, r2);
ldr_f(_jit, r0, jit_gpr_regno(reg));
unget_temp_gpr(_jit);
#else
movssmr(_jit, 0, r1, r2, _SCL1, r0);
#endif
}
static void
@ -679,13 +731,8 @@ ldxi_f(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
movssmr(_jit, i0, r1, _NOREG, _SCL1, r0);
else {
jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64_32
addi(jit_gpr_regno(reg), r1, i0);
ldr_f(_jit, r0, jit_gpr_regno(reg));
#else
movi(_jit, jit_gpr_regno(reg), i0);
ldxr_f(_jit, r0, r1, jit_gpr_regno(reg));
#endif
unget_temp_gpr(_jit);
}
}
@ -693,7 +740,7 @@ ldxi_f(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
static void
sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
{
if (sse_address_p(i0))
if (can_sign_extend_int_p(i0))
movssrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
else {
jit_gpr_t reg = get_temp_gpr(_jit);
@ -706,14 +753,7 @@ sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0)
static void
stxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, jit_gpr_regno(reg), r0, r1);
str_f(_jit, jit_gpr_regno(reg), r2);
unget_temp_gpr(_jit);
#else
movssrm(_jit, r2, 0, r0, r1, _SCL1);
#endif
}
static void
@ -723,13 +763,8 @@ stxi_f(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
movssrm(_jit, r1, i0, r0, _NOREG, _SCL1);
else {
jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64_32
addi(jit_gpr_regno(reg), r0, i0);
str_f(_jit, jit_gpr_regno(reg), r1);
#else
movi(_jit, jit_gpr_regno(reg), i0);
stxr_f(_jit, jit_gpr_regno(reg), r0, r1);
#endif
unget_temp_gpr(_jit);
}
}
@ -843,7 +878,7 @@ bunordr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
static void
ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
{
if (sse_address_p(i0))
if (can_sign_extend_int_p(i0))
movsdmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
else {
jit_gpr_t reg = get_temp_gpr(_jit);
@ -856,14 +891,7 @@ ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0)
static void
ldxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, jit_gpr_regno(reg), r1, r2);
ldr_d(_jit, r0, jit_gpr_regno(reg));
unget_temp_gpr(_jit);
#else
movsdmr(_jit, 0, r1, r2, _SCL1, r0);
#endif
}
static void
@ -873,13 +901,8 @@ ldxi_d(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
movsdmr(_jit, i0, r1, _NOREG, _SCL1, r0);
else {
jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64_32
addi(jit_gpr_regno(reg), r1, i0);
ldr_d(_jit, r0, jit_gpr_regno(reg));
#else
movi(_jit, jit_gpr_regno(reg), i0);
ldxr_d(_jit, r0, r1, jit_gpr_regno(reg));
#endif
unget_temp_gpr(_jit);
}
}
@ -887,7 +910,7 @@ ldxi_d(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
static void
sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
{
if (sse_address_p(i0))
if (can_sign_extend_int_p(i0))
movsdrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
else {
jit_gpr_t reg = get_temp_gpr(_jit);
@ -900,14 +923,7 @@ sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0)
static void
stxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2)
{
#if __X64_32
jit_gpr_t reg = get_temp_gpr(_jit);
addr(_jit, jit_gpr_regno(reg), r0, r1);
str_d(_jit, jit_gpr_regno(reg), r2);
unget_temp_gpr(_jit);
#else
movsdrm(_jit, r2, 0, r0, r1, _SCL1);
#endif
}
static void
@ -917,13 +933,8 @@ stxi_d(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
movsdrm(_jit, r1, i0, r0, _NOREG, _SCL1);
else {
jit_gpr_t reg = get_temp_gpr(_jit);
#if __X64_32
addi(jit_gpr_regno(reg), r0, i0);
str_d(_jit, jit_gpr_regno(reg), r1);
#else
movi(_jit, jit_gpr_regno(reg), i0);
stxr_d(_jit, jit_gpr_regno(reg), r0, r1);
#endif
unget_temp_gpr(_jit);
}
}

1344
libguile/lightening/lightening/x86-x87.c
View file

File diff suppressed because it is too large Load diff

96
libguile/lightening/lightening/x86.c
View file

@ -17,44 +17,46 @@
* Paulo Cesar Pereira de Andrade
*/
/*
* Types
*/
#if __X32 || __CYGWIN__
typedef jit_pointer_t jit_va_list_t;
#else
typedef struct jit_va_list {
int32_t gpoff;
int32_t fpoff;
jit_pointer_t over;
jit_pointer_t save;
/* Declared explicitly as int64 for the x32 abi */
int64_t rdi;
int64_t rsi;
int64_t rdx;
int64_t rcx;
int64_t r8;
int64_t r9;
jit_float64_t xmm0;
jit_float64_t _up0;
jit_float64_t xmm1;
jit_float64_t _up1;
jit_float64_t xmm2;
jit_float64_t _up2;
jit_float64_t xmm3;
jit_float64_t _up3;
jit_float64_t xmm4;
jit_float64_t _up4;
jit_float64_t xmm5;
jit_float64_t _up5;
jit_float64_t xmm6;
jit_float64_t _up6;
jit_float64_t xmm7;
jit_float64_t _up7;
} jit_va_list_t;
#endif
typedef struct {
/* x87 present */
uint32_t fpu : 1;
/* cmpxchg8b instruction */
uint32_t cmpxchg8b : 1;
/* cmov and fcmov branchless conditional mov */
uint32_t cmov : 1;
/* mmx registers/instructions available */
uint32_t mmx : 1;
/* sse registers/instructions available */
uint32_t sse : 1;
/* sse2 registers/instructions available */
uint32_t sse2 : 1;
/* sse3 instructions available */
uint32_t sse3 : 1;
/* pcmulqdq instruction */
uint32_t pclmulqdq : 1;
/* ssse3 suplemental sse3 instructions available */
uint32_t ssse3 : 1;
/* fused multiply/add using ymm state */
uint32_t fma : 1;
/* cmpxchg16b instruction */
uint32_t cmpxchg16b : 1;
/* sse4.1 instructions available */
uint32_t sse4_1 : 1;
/* sse4.2 instructions available */
uint32_t sse4_2 : 1;
/* movbe instruction available */
uint32_t movbe : 1;
/* popcnt instruction available */
uint32_t popcnt : 1;
/* aes instructions available */
uint32_t aes : 1;
/* avx instructions available */
uint32_t avx : 1;
/* lahf/sahf available in 64 bits mode */
uint32_t lahf : 1;
} jit_cpu_t;
jit_cpu_t jit_cpu;
static jit_cpu_t jit_cpu;
#include "x86-cpu.c"
#include "x86-sse.c"
@ -159,7 +161,7 @@ jit_get_cpu(void)
/* i386 or i486 without cpuid */
if ((ac & (1 << 21)) == 0)
/* probably without x87 as well */
return false;
return 0;
#endif
/* query %eax = 1 function */
@ -192,8 +194,8 @@ jit_get_cpu(void)
jit_cpu.avx = ecx.bits.avx;
/* query %eax = 0x80000001 function */
__asm__ volatile (
#if __X64
__asm__ volatile (
# if __X64_32
"xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1"
# else
@ -313,6 +315,12 @@ round_size_up_to_words(size_t bytes)
return words * word_size;
}
static size_t
jit_initial_frame_size (void)
{
return __WORDSIZE / 8; // Saved return address is on stack.
}
static void
reset_abi_arg_iterator(struct abi_arg_iterator *iter, size_t argc,
const jit_operand_t *args)
@ -350,6 +358,16 @@ jit_flush(void *fptr, void *tptr)
{
}
static inline size_t
jit_stack_alignment(void)
{
#if __X64
return 16;
#else
return 4;
#endif
}
static void
jit_try_shorten(jit_state_t *_jit, jit_reloc_t reloc, jit_pointer_t addr)
{

50
libguile/lightening/lightening/x86.h
View file

@ -20,14 +20,9 @@
#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 1
@ -138,6 +133,7 @@ jit_fpr_is_callee_save (jit_fpr_t reg)
# define JIT_V0 _RBX
# define JIT_V1 _RSI
# define JIT_V2 _RDI
# define JIT_VTMP _RBP
# define JIT_F0 _XMM0
# define JIT_F1 _XMM1
# define JIT_F2 _XMM2
@ -210,48 +206,4 @@ jit_fpr_is_callee_save (jit_fpr_t reg)
# define JIT_FTMP _XMM15
#endif
typedef struct {
/* x87 present */
uint32_t fpu : 1;
/* cmpxchg8b instruction */
uint32_t cmpxchg8b : 1;
/* cmov and fcmov branchless conditional mov */
uint32_t cmov : 1;
/* mmx registers/instructions available */
uint32_t mmx : 1;
/* sse registers/instructions available */
uint32_t sse : 1;
/* sse2 registers/instructions available */
uint32_t sse2 : 1;
/* sse3 instructions available */
uint32_t sse3 : 1;
/* pcmulqdq instruction */
uint32_t pclmulqdq : 1;
/* ssse3 suplemental sse3 instructions available */
uint32_t ssse3 : 1;
/* fused multiply/add using ymm state */
uint32_t fma : 1;
/* cmpxchg16b instruction */
uint32_t cmpxchg16b : 1;
/* sse4.1 instructions available */
uint32_t sse4_1 : 1;
/* sse4.2 instructions available */
uint32_t sse4_2 : 1;
/* movbe instruction available */
uint32_t movbe : 1;
/* popcnt instruction available */
uint32_t popcnt : 1;
/* aes instructions available */
uint32_t aes : 1;
/* avx instructions available */
uint32_t avx : 1;
/* lahf/sahf available in 64 bits mode */
uint32_t lahf : 1;
} jit_cpu_t;
/*
* Initialization
*/
JIT_API jit_cpu_t jit_cpu;
#endif /* _jit_x86_h */

5
libguile/lightening/tests/Makefile
View file

@ -27,7 +27,10 @@ test-native-%: %.c lightening-native.o test.h
test-ia32-%: CC = $(CC_IA32)
test-ia32-%: %.c lightening-ia32.o test.h
$(CC) -m32 $(CFLAGS) $(CPPFLAGS) -I.. -o $@ lightening-ia32.o $<
$(CC) $(CFLAGS) $(CPPFLAGS) -I.. -o $@ lightening-ia32.o $<
.PRECIOUS: $(foreach TARGET,$(TARGETS),$(addprefix test-$(TARGET)-,$(TESTS)))
.PRECIOUS: $(foreach TARGET,$(TARGETS),lightening-$(TARGET).o)
clean:
rm -f $(foreach TARGET,$(TARGETS),$(addprefix test-$(TARGET)-,$(TESTS)))

2
libguile/lightening/tests/absr_d.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
jit_absr_d(j, JIT_F0, JIT_F0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_d(j, JIT_F0);
double (*f)(double) = jit_end(j, NULL);

2
libguile/lightening/tests/absr_f.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
jit_absr_f(j, JIT_F0, JIT_F0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_f(j, JIT_F0);
float (*f)(float) = jit_end(j, NULL);

4
libguile/lightening/tests/addi.c
View file

@ -4,9 +4,11 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_addi(j, JIT_R0, JIT_R0, 69);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;

6
libguile/lightening/tests/addr.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_addr(j, JIT_R0, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;

2
libguile/lightening/tests/addr_d.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_addr_d(j, JIT_F0, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_d(j, JIT_F0);
size_t size = 0;

2
libguile/lightening/tests/addr_f.c
View file

@ -4,10 +4,12 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_addr_f(j, JIT_F0, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_f(j, JIT_F0);
size_t size = 0;

8
libguile/lightening/tests/addx.c
View file

@ -4,18 +4,20 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_movi(j, JIT_R2, 0);
jit_addcr(j, JIT_R0, JIT_R0, JIT_R1);
jit_addxi(j, JIT_R2, JIT_R2, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R2);
size_t size = 0;
void* ret = jit_end(j, &size);
intmax_t (*f)(intmax_t, intmax_t) = ret;
jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
ASSERT(f(0, 0) == 0);

6
libguile/lightening/tests/andi.c
View file

@ -4,15 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_andi(j, JIT_R0, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;
void* ret = jit_end(j, &size);
intmax_t (*f)(intmax_t) = ret;
jit_word_t (*f)(jit_word_t) = ret;
ASSERT(f(0x7fffffff) == 1);
ASSERT(f(0x80000000) == 0);

8
libguile/lightening/tests/andr.c
View file

@ -4,16 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_andr(j, JIT_R0, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;
void* ret = jit_end(j, &size);
intmax_t (*f)(intmax_t, intmax_t) = ret;
jit_word_t (*f)(jit_word_t, jit_word_t) = ret;
ASSERT(f(0x7fffffff, 1) == 1);
ASSERT(f(1, 0x7fffffff) == 1);

7
libguile/lightening/tests/beqi.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_beqi(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 0);

9
libguile/lightening/tests/beqr.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_beqr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/beqr_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_beqr_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/beqr_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_beqr_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

7
libguile/lightening/tests/bgei.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bgei(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 1);

7
libguile/lightening/tests/bgei_u.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bgei_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 1);

9
libguile/lightening/tests/bger.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bger(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bger_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bger_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bger_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bger_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

9
libguile/lightening/tests/bger_u.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bger_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

7
libguile/lightening/tests/bgti.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bgti(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

7
libguile/lightening/tests/bgti_u.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bgti_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

9
libguile/lightening/tests/bgtr.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bgtr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bgtr_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bgtr_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bgtr_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bgtr_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

9
libguile/lightening/tests/bgtr_u.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bgtr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

7
libguile/lightening/tests/blei.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_blei(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 0);

7
libguile/lightening/tests/blei_u.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_blei_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 0);

9
libguile/lightening/tests/bler.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bler(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bler_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bler_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bler_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bler_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

9
libguile/lightening/tests/bler_u.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bler_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bltgtr_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bltgtr_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bltgtr_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bltgtr_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

7
libguile/lightening/tests/blti.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_blti(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 0);

7
libguile/lightening/tests/blti_u.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_blti_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 0);

9
libguile/lightening/tests/bltr.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bltr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bltr_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bltr_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bltr_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bltr_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

9
libguile/lightening/tests/bltr_u.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bltr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

7
libguile/lightening/tests/bmci.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bmci(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 1);
ASSERT(f(1) == 0);

9
libguile/lightening/tests/bmcr.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bmcr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

7
libguile/lightening/tests/bmsi.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bmsi(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

9
libguile/lightening/tests/bmsr.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bmsr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

7
libguile/lightening/tests/bnei.c
View file

@ -4,14 +4,17 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bnei(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(1) == 1);

9
libguile/lightening/tests/bner.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bner(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bner_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bner_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bner_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bner_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

9
libguile/lightening/tests/boaddi.c
View file

@ -1,20 +1,23 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_boaddi(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == 0);
ASSERT(f(0) == 1);

9
libguile/lightening/tests/boaddi_u.c
View file

@ -1,20 +1,23 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_boaddi_u(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == overflowed);
ASSERT(f(0) == 1);

11
libguile/lightening/tests/boaddr.c
View file

@ -1,21 +1,24 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_boaddr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 2);

13
libguile/lightening/tests/boaddr_u.c
View file

@ -1,21 +1,24 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_boaddr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 2);
@ -24,7 +27,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
ASSERT(f(0xffffffff, 0xffffffff) == overflowed);
ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
ASSERT(f(0x7fffffff, 1) == 0x80000000);
ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffff + 0x7fffffff);
ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffu + 0x7fffffffu);
ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
ASSERT(f(0x80000000, 0x80000000) == overflowed);
#else

5
libguile/lightening/tests/bordr_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bordr_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bordr_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bordr_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

9
libguile/lightening/tests/bosubi.c
View file

@ -1,20 +1,23 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bosubi(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == -1);

9
libguile/lightening/tests/bosubi_u.c
View file

@ -1,20 +1,23 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bosubi_u(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == overflowed);

11
libguile/lightening/tests/bosubr.c
View file

@ -1,21 +1,24 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bosubr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == -1);

11
libguile/lightening/tests/bosubr_u.c
View file

@ -1,21 +1,24 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bosubr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 0);

6
libguile/lightening/tests/bswapr_ui.c
View file

@ -4,12 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_bswapr_ui(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(0x12345678) == 0x78563412);

6
libguile/lightening/tests/bswapr_ul.c
View file

@ -5,12 +5,14 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
#if __WORDSIZE > 32
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_bswapr_ul(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(0x12345678) == 0x7856341200000000);

6
libguile/lightening/tests/bswapr_us.c
View file

@ -4,12 +4,14 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_bswapr_us(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
uintmax_t (*f)(uintmax_t) = jit_end(j, NULL);
jit_uword_t (*f)(jit_uword_t) = jit_end(j, NULL);
ASSERT(f(0) == 0);
ASSERT(f(0x12345678) == 0x7856);

5
libguile/lightening/tests/buneqr_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_buneqr_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/buneqr_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_buneqr_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bunger_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bunger_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bunger_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bunger_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bungtr_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bungtr_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bungtr_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bungtr_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bunler_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bunler_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bunler_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bunler_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 1);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bunltr_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bunltr_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bunltr_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bunltr_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 1);

5
libguile/lightening/tests/bunordr_d.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bunordr_d(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(double, double) = jit_end(j, NULL);
jit_word_t (*f)(double, double) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

5
libguile/lightening/tests/bunordr_f.c
View file

@ -4,15 +4,18 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bunordr_f(j, JIT_F0, JIT_F1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1);
intmax_t (*f)(float, float) = jit_end(j, NULL);
jit_word_t (*f)(float, float) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == 0);

8
libguile/lightening/tests/bxaddi.c
View file

@ -1,19 +1,21 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bxaddi(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == 0);
ASSERT(f(0) == 1);

8
libguile/lightening/tests/bxaddi_u.c
View file

@ -1,19 +1,21 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bxaddi_u(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == overflowed);
ASSERT(f(0) == 1);

10
libguile/lightening/tests/bxaddr.c
View file

@ -1,20 +1,22 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bxaddr(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 2);

12
libguile/lightening/tests/bxaddr_u.c
View file

@ -1,20 +1,22 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bxaddr_u(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 2);
@ -23,7 +25,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
ASSERT(f(0xffffffff, 0xffffffff) == overflowed);
ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
ASSERT(f(0x7fffffff, 1) == 0x80000000);
ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffff + 0x7fffffff);
ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffu + 0x7fffffffu);
ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
ASSERT(f(0x80000000, 0x80000000) == overflowed);
#else

8
libguile/lightening/tests/bxsubi.c
View file

@ -1,19 +1,21 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bxsubi(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == -1);

8
libguile/lightening/tests/bxsubi_u.c
View file

@ -1,19 +1,21 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0));
jit_reloc_t r = jit_bxsubi_u(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t) = jit_end(j, NULL);
ASSERT(f(-1) == -2);
ASSERT(f(0) == overflowed);

10
libguile/lightening/tests/bxsubr.c
View file

@ -1,20 +1,22 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bxsubr(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(0, 1) == -1);

10
libguile/lightening/tests/bxsubr_u.c
View file

@ -1,20 +1,22 @@
#include "test.h"
static const intmax_t overflowed = 0xcabba9e5;
static const jit_word_t overflowed = 0xcabba9e5;
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1));
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R0),
jit_operand_gpr (JIT_OPERAND_ABI_WORD, JIT_R1));
jit_reloc_t r = jit_bxsubr_u(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0);
intmax_t (*f)(intmax_t, intmax_t) = jit_end(j, NULL);
jit_word_t (*f)(jit_word_t, jit_word_t) = jit_end(j, NULL);
ASSERT(f(0, 0) == 0);
ASSERT(f(1, 1) == 0);

2
libguile/lightening/tests/call_10.c
View file

@ -19,6 +19,7 @@ static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0));
jit_operand_t args[10] = {
@ -34,6 +35,7 @@ run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
jit_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0, 9 * sizeof(int32_t))
};
jit_calli(j, f, 10, args);
jit_leave_jit_abi(j, 0, 0, align);
jit_ret(j);
size_t size = 0;

68
libguile/lightening/tests/callee_9.c Normal file
View file

@ -0,0 +1,68 @@
#include "test.h"
struct args
{
int8_t a;
int16_t b;
int32_t c;
jit_word_t d;
uint16_t e;
float f;
double g;
float h;
};
static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{
jit_begin(j, arena_base, arena_size);
size_t align = jit_enter_jit_abi(j, 3, 0, 0);
jit_operand_t args[9] = {
jit_operand_gpr(JIT_OPERAND_ABI_POINTER, JIT_R0),
jit_operand_gpr(JIT_OPERAND_ABI_INT8, JIT_R1),
jit_operand_gpr(JIT_OPERAND_ABI_INT16, JIT_R2),
jit_operand_gpr(JIT_OPERAND_ABI_INT32, JIT_V0),
jit_operand_gpr(JIT_OPERAND_ABI_WORD, JIT_V1),
jit_operand_gpr(JIT_OPERAND_ABI_UINT16, JIT_V2),
jit_operand_fpr(JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr(JIT_OPERAND_ABI_DOUBLE, JIT_F1),
jit_operand_fpr(JIT_OPERAND_ABI_FLOAT, JIT_F2),
};
jit_load_args(j, 9, args);
jit_stxi_c(j, offsetof(struct args, a), JIT_R0, JIT_R1); // a
jit_stxi_s(j, offsetof(struct args, b), JIT_R0, JIT_R2); // b
jit_stxi_i(j, offsetof(struct args, c), JIT_R0, JIT_V0); // c
jit_stxi(j, offsetof(struct args, d), JIT_R0, JIT_V1); // d
jit_stxi_s(j, offsetof(struct args, e), JIT_R0, JIT_V2); // e
jit_stxi_f(j, offsetof(struct args, f), JIT_R0, JIT_F0); // f
jit_stxi_d(j, offsetof(struct args, g), JIT_R0, JIT_F1); // g
jit_stxi_f(j, offsetof(struct args, h), JIT_R0, JIT_F2); // h
jit_leave_jit_abi(j, 3, 0, align);
jit_retr(j, JIT_R0);
size_t size = 0;
void* ret = jit_end(j, &size);
struct args* (*f)(struct args*, int8_t, int16_t, int32_t, jit_word_t,
uint16_t, float, double, float) = ret;
struct args in = { 0, 1, 2, 3, 4, 5, 6, 7 };
struct args out;
ASSERT(f(&out, in.a, in.b, in.c, in.d, in.e, in.f, in.g, in.h) == &out);
ASSERT(in.a == out.a);
ASSERT(in.b == out.b);
ASSERT(in.c == out.c);
ASSERT(in.d == out.d);
ASSERT(in.e == out.e);
ASSERT(in.f == out.f);
ASSERT(in.g == out.g);
ASSERT(in.h == out.h);
}
int
main (int argc, char *argv[])
{
return main_helper(argc, argv, run_test);
}

Some files were not shown because too many files have changed in this diff Show more