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 # use the official gcc image, based on debian
# can use verions as well, like gcc:5.2 # can use verions as well, like gcc:5.2
# see https://hub.docker.com/_/gcc/ # 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 stage: test
script: 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_POINTER,
JIT_OPERAND_ABI_FLOAT, JIT_OPERAND_ABI_FLOAT,
JIT_OPERAND_ABI_DOUBLE, JIT_OPERAND_ABI_DOUBLE,
JIT_OPERAND_ABI_INTMAX = CHOOSE_32_64(JIT_OPERAND_ABI_INT32, JIT_OPERAND_ABI_WORD = CHOOSE_32_64(JIT_OPERAND_ABI_INT32,
JIT_OPERAND_ABI_INT64) JIT_OPERAND_ABI_INT64)
}; };
enum jit_operand_kind 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 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 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 /* Note that all functions that take jit_operand_t args[] use the args
as scratch space while shuffling values into position. */ as scratch space while shuffling values into position. */
JIT_API void jit_calli(jit_state_t *, jit_pointer_t f, 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. * This file is part of GNU lightning.
* *
@ -17,6 +17,12 @@
* Paulo Cesar Pereira de Andrade * 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_reg_p(i) ((i) >= 0 && (i) < 8)
#define jit_arg_f_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. * This file is part of GNU lightning.
* *
@ -17,6 +17,10 @@
* Paulo Cesar Pereira de Andrade * 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_reg_p(i) ((i) >= 0 && (i) < 6)
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 6) #define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 6)
#if __BYTE_ORDER == __LITTLE_ENDIAN #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. * This file is part of GNU lightning.
* *
@ -21,6 +21,16 @@
# include <stdio.h> # include <stdio.h>
#endif #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_reg_p(i) ((i) >= 0 && (i) < 4)
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 16) #define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 16)
#define jit_arg_d_reg_p(i) ((i) >= 0 && (i) < 15) #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. * This file is part of GNU lightning.
* *
@ -17,6 +17,10 @@
* Paulo Cesar Pereira de Andrade * 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 jit_arg_reg_p(i) (i >= 0 && i < 4)
#define PROTO 1 #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. * This file is part of GNU lightning.
* *
@ -17,6 +17,10 @@
* Paulo Cesar Pereira de Andrade * 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) #define jit_arg_reg_p(i) ((i) >= 0 && (i) < 8)
#if __BYTE_ORDER == __LITTLE_ENDIAN #if __BYTE_ORDER == __LITTLE_ENDIAN
# define C_DISP 0 # define C_DISP 0

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

@ -37,69 +37,6 @@
#define _NOREG 0xffff #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 union jit_pc
{ {
uint8_t *uc; 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, static void jit_try_shorten(jit_state_t *_jit, jit_reloc_t reloc,
jit_pointer_t addr); 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 jit_bool_t
init_jit(void) 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: case JIT_OPERAND_ABI_INT16:
jit_ldxi_s(_jit, dst, base, offset); jit_ldxi_s(_jit, dst, base, offset);
break; break;
#if __WORDSIZE == 32
case JIT_OPERAND_ABI_UINT32: case JIT_OPERAND_ABI_UINT32:
jit_ldxi_ui(_jit, dst, base, offset); case JIT_OPERAND_ABI_POINTER:
break; #endif
case JIT_OPERAND_ABI_INT32: case JIT_OPERAND_ABI_INT32:
jit_ldxi_i(_jit, dst, base, offset); jit_ldxi_i(_jit, dst, base, offset);
break; break;
case JIT_OPERAND_ABI_UINT64: #if __WORDSIZE == 64
jit_ldxi_l(_jit, dst, base, offset); case JIT_OPERAND_ABI_UINT32:
jit_ldxi_ui(_jit, dst, base, offset);
break; break;
case JIT_OPERAND_ABI_UINT64:
case JIT_OPERAND_ABI_POINTER:
case JIT_OPERAND_ABI_INT64: case JIT_OPERAND_ABI_INT64:
jit_ldxi_l(_jit, dst, base, offset); jit_ldxi_l(_jit, dst, base, offset);
break; break;
case JIT_OPERAND_ABI_POINTER: #endif
jit_ldxi_l(_jit, dst, base, offset);
break;
default: default:
abort(); abort();
} }
@ -612,7 +558,7 @@ abi_mem_to_fpr(jit_state_t *_jit, enum jit_operand_abi abi,
static void static void
abi_imm_to_mem(jit_state_t *_jit, enum jit_operand_abi abi, jit_gpr_t base, 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)); 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; size_t new_size = _jit->frame_size + expand;
// Align stack to double-word boundaries. This isn't really a // Align stack to double-word boundaries. This isn't really a
// principle but it does work for Aarch32, AArch64 and x86-64. // 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 aligned_size = (new_size + alignment - 1) & ~(alignment - 1);
size_t diff = aligned_size - _jit->frame_size; size_t diff = aligned_size - _jit->frame_size;
if (diff) if (diff)
@ -910,6 +856,107 @@ jit_shrink_stack(jit_state_t *_jit, size_t diff)
_jit->frame_size -= 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. // Precondition: stack is already aligned.
static size_t static size_t
prepare_call_args(jit_state_t *_jit, size_t argc, jit_operand_t args[]) 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; struct abi_arg_iterator iter;
reset_abi_arg_iterator(&iter, argc, args); reset_abi_arg_iterator(&iter, argc, args);
iter.stack_size += _jit->frame_size;
for (size_t i = 0; i < argc; i++) for (size_t i = 0; i < argc; i++)
next_abi_arg(&iter, &args[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. * This file is part of GNU lightning.
* *
@ -21,6 +21,12 @@
# include <sys/cachectl.h> # include <sys/cachectl.h>
#endif #endif
# define JIT_RA0 _A0
# define JIT_FA0 _F12
# define JIT_SP _SP
# define JIT_RET _V0
# define JIT_FRET _F0
#if NEW_ABI #if NEW_ABI
# define NUM_WORD_ARGS 8 # define NUM_WORD_ARGS 8
# define STACK_SLOT 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. * This file is part of GNU lightning.
* *
@ -17,6 +17,12 @@
* Paulo Cesar Pereira de Andrade * 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_reg_p(i) ((i) >= 0 && (i) < 8)
#define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 13) #define jit_arg_f_reg_p(i) ((i) >= 0 && (i) < 13)
#if __BYTE_ORDER == __LITTLE_ENDIAN #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. * This file is part of GNU lightning.
* *
@ -17,6 +17,10 @@
* Paulo Cesar Pereira de Andrade * Paulo Cesar Pereira de Andrade
*/ */
# define JIT_SP _R15
# define JIT_RET _R2
# define JIT_FRET _F0
#if __WORDSIZE == 32 #if __WORDSIZE == 32
# define NUM_FLOAT_REG_ARGS 2 # define NUM_FLOAT_REG_ARGS 2
#else #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. * 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 */ /* avoid using it due to partial stalls */
#define USE_INC_DEC 0 #define USE_INC_DEC 0
#if __X32 || __X64_32 #if __X32
# define WIDE 0 # define WIDE 0
# define IF_WIDE(wide, narrow) narrow # define IF_WIDE(wide, narrow) narrow
#else #else
@ -46,7 +46,7 @@
#define _R15_REGNO 15 #define _R15_REGNO 15
#define r7(reg) ((reg) & 7) #define r7(reg) ((reg) & 7)
#define r8(reg) ((reg) & 15) #define r8(reg) ((reg) & 15)
#if __X32 || __CYGWIN__ || __X64_32 #if __X32
# define reg8_p(rn) ((rn) >= _RAX_REGNO && (rn) <= _RBX_REGNO) # define reg8_p(rn) ((rn) >= _RAX_REGNO && (rn) <= _RBX_REGNO)
#else #else
# define reg8_p(rn) 1 # define reg8_p(rn) 1
@ -160,15 +160,13 @@ ii(jit_state_t *_jit, uint32_t i)
emit_u32(_jit, i); emit_u32(_jit, i);
} }
#if __X64
static inline void 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); emit_u64(_jit, l);
#else
ii(_jit, l);
#endif
} }
#endif
static void static void
rex(jit_state_t *_jit, int32_t l, int32_t w, 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 static void
pushr(jit_state_t *_jit, int32_t r0) pushr(jit_state_t *_jit, int32_t r0)
{ {
_jit->frame_size += __WORDSIZE; _jit->frame_size += __WORDSIZE / 8;
rex(_jit, 0, WIDE, 0, 0, r0); rex(_jit, 0, WIDE, 0, 0, r0);
ic(_jit, 0x50 | r7(r0)); ic(_jit, 0x50 | r7(r0));
} }
@ -262,7 +260,7 @@ pushr(jit_state_t *_jit, int32_t r0)
static void static void
popr(jit_state_t *_jit, int32_t r0) popr(jit_state_t *_jit, int32_t r0)
{ {
_jit->frame_size -= __WORDSIZE; _jit->frame_size -= __WORDSIZE / 8;
rex(_jit, 0, WIDE, 0, 0, r0); rex(_jit, 0, WIDE, 0, 0, r0);
ic(_jit, 0x58 | r7(r0)); ic(_jit, 0x58 | r7(r0));
} }
@ -275,8 +273,7 @@ get_temp_gpr(jit_state_t *_jit)
#ifdef JIT_RTMP #ifdef JIT_RTMP
return JIT_RTMP; return JIT_RTMP;
#else #else
pushr(_jit, _RBP_REGNO); return JIT_VTMP;
return _RBP;
#endif #endif
} }
@ -285,9 +282,6 @@ unget_temp_gpr(jit_state_t *_jit)
{ {
ASSERT(_jit->temp_gpr_saved); ASSERT(_jit->temp_gpr_saved);
_jit->temp_gpr_saved = 0; _jit->temp_gpr_saved = 0;
#ifndef JIT_RTMP
popr(_jit, _RBP_REGNO);
#endif
} }
static void static void
@ -410,19 +404,15 @@ static void
imovi(jit_state_t *_jit, int32_t r0, jit_word_t i0) imovi(jit_state_t *_jit, int32_t r0, jit_word_t i0)
{ {
#if __X64 #if __X64
# if !__X64_32
if (fits_uint32_p(i0)) { if (fits_uint32_p(i0)) {
# endif
rex(_jit, 0, 0, _NOREG, _NOREG, r0); rex(_jit, 0, 0, _NOREG, _NOREG, r0);
ic(_jit, 0xb8 | r7(r0)); ic(_jit, 0xb8 | r7(r0));
ii(_jit, i0); ii(_jit, i0);
# if !__X64_32
} else { } else {
rex(_jit, 0, 1, _NOREG, _NOREG, r0); rex(_jit, 0, 1, _NOREG, _NOREG, r0);
ic(_jit, 0xb8 | r7(r0)); ic(_jit, 0xb8 | r7(r0));
il(_jit, i0); il(_jit, i0);
} }
# endif
#else #else
ic(_jit, 0xb8 | r7(r0)); ic(_jit, 0xb8 | r7(r0));
ii(_jit, i0); ii(_jit, i0);
@ -1024,7 +1014,7 @@ ffsw(jit_word_t i)
return ffs(i); return ffs(i);
int bit = ffs((int)i); int bit = ffs((int)i);
if (bit == 0) { if (bit == 0) {
bit = ffs((int)((unsigned long)i >> 32)); bit = ffs((int)((uint64_t)i >> 32));
if (bit) if (bit)
bit += 32; bit += 32;
} }
@ -1494,7 +1484,7 @@ extr_us(jit_state_t *_jit, int32_t r0, int32_t r1)
return movsr_u(_jit, r0, r1); return movsr_u(_jit, r0, r1);
} }
#if __X64 && !__X64_32 #if __X64
static void static void
extr_i(jit_state_t *_jit, int32_t r0, int32_t r1) 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)); ic(_jit, 0xc8 | r7(r0));
} }
#if __X64 && !__X64_32 #if __X64
static void static void
bswapr_ul(jit_state_t *_jit, int32_t r0, int32_t r1) 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 static void
ldr_i(jit_state_t *_jit, int32_t r0, int32_t r1) 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); unget_temp_gpr(_jit);
} }
} }
#endif
#if __X64 #if __X64
static void static void
@ -1695,7 +1683,6 @@ ldi_ui(jit_state_t *_jit, int32_t r0, jit_word_t i0)
} }
} }
# if !__X64_32
static void static void
ldr_l(jit_state_t *_jit, int32_t r0, int32_t r1) 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); unget_temp_gpr(_jit);
} }
} }
# endif
#endif #endif
static void static void
ldxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); rex(_jit, 0, WIDE, r0, r1, r2);
ic(_jit, 0x0f); ic(_jit, 0x0f);
ic(_jit, 0xbe); ic(_jit, 0xbe);
rx(_jit, r0, 0, r2, r1, _SCL1); rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
} }
static void static void
@ -1754,15 +1735,10 @@ ldxi_c(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
static void static void
ldxr_uc(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); rex(_jit, 0, WIDE, r0, r1, r2);
ic(_jit, 0x0f); ic(_jit, 0x0f);
ic(_jit, 0xb6); ic(_jit, 0xb6);
rx(_jit, r0, 0, r2, r1, _SCL1); rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
} }
static void static void
@ -1784,15 +1760,10 @@ ldxi_uc(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
static void static void
ldxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); rex(_jit, 0, WIDE, r0, r1, r2);
ic(_jit, 0x0f); ic(_jit, 0x0f);
ic(_jit, 0xbf); ic(_jit, 0xbf);
rx(_jit, r0, 0, r2, r1, _SCL1); rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
} }
static void static void
@ -1814,15 +1785,10 @@ ldxi_s(jit_state_t *_jit, int32_t r0, int32_t r1, jit_word_t i0)
static void static void
ldxr_us(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); rex(_jit, 0, WIDE, r0, r1, r2);
ic(_jit, 0x0f); ic(_jit, 0x0f);
ic(_jit, 0xb7); ic(_jit, 0xb7);
rx(_jit, r0, 0, r2, r1, _SCL1); rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
} }
static void 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 static void
ldxr_i(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); unget_temp_gpr(_jit);
} }
} }
#endif
#if __X64 #if __X64
static void static void
ldxr_ui(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); rex(_jit, 0, 0, r0, r1, r2);
ic(_jit, 0x8b); ic(_jit, 0x8b);
rx(_jit, r0, 0, r2, r1, _SCL1); rx(_jit, r0, 0, r2, r1, _SCL1);
#endif
} }
static void 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 static void
ldxr_l(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); unget_temp_gpr(_jit);
} }
} }
# endif
#endif #endif
static void 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 static void
str_l(jit_state_t *_jit, int32_t r0, int32_t r1) 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 static void
stxr_c(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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)) { if (reg8_p(r2)) {
rex(_jit, 0, 0, r2, r1, r0); rex(_jit, 0, 0, r2, r1, r0);
ic(_jit, 0x88); 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); rx(_jit, jit_gpr_regno(reg), 0, r0, r1, _SCL1);
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
} }
#endif
} }
static void static void
@ -2095,17 +2044,10 @@ stxi_c(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
static void static void
stxr_s(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); ic(_jit, 0x66);
rex(_jit, 0, 0, r2, r1, r0); rex(_jit, 0, 0, r2, r1, r0);
ic(_jit, 0x89); ic(_jit, 0x89);
rx(_jit, r2, 0, r0, r1, _SCL1); rx(_jit, r2, 0, r0, r1, _SCL1);
#endif
} }
static void static void
@ -2127,16 +2069,9 @@ stxi_s(jit_state_t *_jit, jit_word_t i0, int32_t r0, int32_t r1)
static void static void
stxr_i(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); rex(_jit, 0, 0, r2, r1, r0);
ic(_jit, 0x89); ic(_jit, 0x89);
rx(_jit, r2, 0, r0, r1, _SCL1); rx(_jit, r2, 0, r0, r1, _SCL1);
#endif
} }
static void 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 static void
stxr_l(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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 static void
retval_c(jit_state_t *_jit, int32_t r0) 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 static void
retval_uc(jit_state_t *_jit, int32_t r0) 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 static void
retval_s(jit_state_t *_jit, int32_t r0) 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 static void
retval_us(jit_state_t *_jit, int32_t r0) 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 static void
retval_i(jit_state_t *_jit, int32_t r0) retval_i(jit_state_t *_jit, int32_t r0)
{ {
#if __X32 || __X64_32 #if __X32
movr(_jit, r0, jit_gpr_regno(JIT_RET)); movr(_jit, r0, _RAX_REGNO);
#else #else
extr_i(_jit, r0, jit_gpr_regno(JIT_RET)); extr_i(_jit, r0, _RAX_REGNO);
#endif #endif
} }
#if __X64 && !__X64_32 #if __X64
static void static void
retval_ui(jit_state_t *_jit, int32_t r0) 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 static void
retval_l(jit_state_t *_jit, int32_t r0) retval_l(jit_state_t *_jit, int32_t r0)
{ {
movr(_jit, r0, jit_gpr_regno(JIT_RET)); movr(_jit, r0, _RAX_REGNO);
} }
#endif #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 static void
sselxr(jit_state_t *_jit, int32_t p, int32_t c, int32_t r0, int32_t r1) 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); ic(_jit, p);
rex(_jit, 0, 1, r0, 0, r1); rex(_jit, 0, 1, r0, 0, r1);
ic(_jit, 0x0f); 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); ssexr(_jit, 0x66, X86_SSE_XOR, r0, r1);
} }
static void 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) pcmpeqlr(jit_state_t *_jit, int32_t r0, int32_t r1)
{ {
ssexr(_jit, 0x66, X86_SSE_EQD, r0, 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)) if (data.d == 0.0 && !(data.ii[1] & 0x80000000))
xorpdr(_jit, r0, r0); xorpdr(_jit, r0, r0);
else { else {
jit_gpr_t reg = get_temp_gpr(_jit); jit_gpr_t ireg = get_temp_gpr(_jit);
#if __X64 && !__X64_32 #if __X64
movi(_jit, jit_gpr_regno(reg), data.w); movi(_jit, jit_gpr_regno(ireg), data.w);
movdqxr(_jit, r0, jit_gpr_regno(reg)); movdqxr(_jit, r0, jit_gpr_regno(ireg));
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
#else #else
movi(_jit, jit_gpr_regno(reg), data.ii[0]); jit_fpr_t freg = get_temp_xpr(_jit);
stxi_i(CVT_OFFSET, _RBP_REGNO, jit_gpr_regno(reg)); movi(_jit, jit_gpr_regno(ireg), data.ii[1]);
movi(_jit, jit_gpr_regno(reg), data.ii[1]); movdlxr(_jit, jit_fpr_regno(freg), jit_gpr_regno(ireg));
stxi_i(CVT_OFFSET + 4, _RBP_REGNO, jit_gpr_regno(reg)); 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); unget_temp_gpr(_jit);
ldxi_d(_jit, r0, _RBP_REGNO, CVT_OFFSET);
#endif #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 static void
retval_f(jit_state_t *_jit, int32_t r0) retval_f(jit_state_t *_jit, int32_t r0)
{ {
#if __X64 #if __X32
movr_f(_jit, r0, jit_fpr_regno(JIT_FRET)); 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 #endif
} }
static void static void
retval_d(jit_state_t *_jit, int32_t r0) retval_d(jit_state_t *_jit, int32_t r0)
{ {
#if __X64 #if __X32
movr_d(_jit, r0, jit_fpr_regno(JIT_FRET)); 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 #endif
} }
static void static void
retr_f(jit_state_t *_jit, int32_t u) 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); ret(_jit);
} }
static void static void
retr_d(jit_state_t *_jit, int32_t u) 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); ret(_jit);
} }
@ -638,18 +705,10 @@ negr_d(jit_state_t *_jit, int32_t r0, int32_t r1)
unget_temp_gpr(_jit); 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 static void
ldi_f(jit_state_t *_jit, int32_t r0, jit_word_t i0) 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); movssmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
else { else {
jit_gpr_t reg = get_temp_gpr(_jit); 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 static void
ldxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); movssmr(_jit, 0, r1, r2, _SCL1, r0);
#endif
} }
static void 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); movssmr(_jit, i0, r1, _NOREG, _SCL1, r0);
else { else {
jit_gpr_t reg = get_temp_gpr(_jit); 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); movi(_jit, jit_gpr_regno(reg), i0);
ldxr_f(_jit, r0, r1, jit_gpr_regno(reg)); ldxr_f(_jit, r0, r1, jit_gpr_regno(reg));
#endif
unget_temp_gpr(_jit); 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 static void
sti_f(jit_state_t *_jit, jit_word_t i0, int32_t r0) 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); movssrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
else { else {
jit_gpr_t reg = get_temp_gpr(_jit); 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 static void
stxr_f(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); movssrm(_jit, r2, 0, r0, r1, _SCL1);
#endif
} }
static void 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); movssrm(_jit, r1, i0, r0, _NOREG, _SCL1);
else { else {
jit_gpr_t reg = get_temp_gpr(_jit); 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); movi(_jit, jit_gpr_regno(reg), i0);
stxr_f(_jit, jit_gpr_regno(reg), r0, r1); stxr_f(_jit, jit_gpr_regno(reg), r0, r1);
#endif
unget_temp_gpr(_jit); unget_temp_gpr(_jit);
} }
} }
@ -843,7 +878,7 @@ bunordr_f(jit_state_t *_jit, int32_t r0, int32_t r1)
static void static void
ldi_d(jit_state_t *_jit, int32_t r0, jit_word_t i0) 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); movsdmr(_jit, i0, _NOREG, _NOREG, _SCL1, r0);
else { else {
jit_gpr_t reg = get_temp_gpr(_jit); 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 static void
ldxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); movsdmr(_jit, 0, r1, r2, _SCL1, r0);
#endif
} }
static void 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); movsdmr(_jit, i0, r1, _NOREG, _SCL1, r0);
else { else {
jit_gpr_t reg = get_temp_gpr(_jit); 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); movi(_jit, jit_gpr_regno(reg), i0);
ldxr_d(_jit, r0, r1, jit_gpr_regno(reg)); ldxr_d(_jit, r0, r1, jit_gpr_regno(reg));
#endif
unget_temp_gpr(_jit); 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 static void
sti_d(jit_state_t *_jit, jit_word_t i0, int32_t r0) 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); movsdrm(_jit, r0, i0, _NOREG, _NOREG, _SCL1);
else { else {
jit_gpr_t reg = get_temp_gpr(_jit); 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 static void
stxr_d(jit_state_t *_jit, int32_t r0, int32_t r1, int32_t r2) 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); movsdrm(_jit, r2, 0, r0, r1, _SCL1);
#endif
} }
static void 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); movsdrm(_jit, r1, i0, r0, _NOREG, _SCL1);
else { else {
jit_gpr_t reg = get_temp_gpr(_jit); 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); movi(_jit, jit_gpr_regno(reg), i0);
stxr_d(_jit, jit_gpr_regno(reg), r0, r1); stxr_d(_jit, jit_gpr_regno(reg), r0, r1);
#endif
unget_temp_gpr(_jit); 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 * Paulo Cesar Pereira de Andrade
*/ */
/* typedef struct {
* Types /* x87 present */
*/ uint32_t fpu : 1;
#if __X32 || __CYGWIN__ /* cmpxchg8b instruction */
typedef jit_pointer_t jit_va_list_t; uint32_t cmpxchg8b : 1;
#else /* cmov and fcmov branchless conditional mov */
typedef struct jit_va_list { uint32_t cmov : 1;
int32_t gpoff; /* mmx registers/instructions available */
int32_t fpoff; uint32_t mmx : 1;
jit_pointer_t over; /* sse registers/instructions available */
jit_pointer_t save; uint32_t sse : 1;
/* Declared explicitly as int64 for the x32 abi */ /* sse2 registers/instructions available */
int64_t rdi; uint32_t sse2 : 1;
int64_t rsi; /* sse3 instructions available */
int64_t rdx; uint32_t sse3 : 1;
int64_t rcx; /* pcmulqdq instruction */
int64_t r8; uint32_t pclmulqdq : 1;
int64_t r9; /* ssse3 suplemental sse3 instructions available */
jit_float64_t xmm0; uint32_t ssse3 : 1;
jit_float64_t _up0; /* fused multiply/add using ymm state */
jit_float64_t xmm1; uint32_t fma : 1;
jit_float64_t _up1; /* cmpxchg16b instruction */
jit_float64_t xmm2; uint32_t cmpxchg16b : 1;
jit_float64_t _up2; /* sse4.1 instructions available */
jit_float64_t xmm3; uint32_t sse4_1 : 1;
jit_float64_t _up3; /* sse4.2 instructions available */
jit_float64_t xmm4; uint32_t sse4_2 : 1;
jit_float64_t _up4; /* movbe instruction available */
jit_float64_t xmm5; uint32_t movbe : 1;
jit_float64_t _up5; /* popcnt instruction available */
jit_float64_t xmm6; uint32_t popcnt : 1;
jit_float64_t _up6; /* aes instructions available */
jit_float64_t xmm7; uint32_t aes : 1;
jit_float64_t _up7; /* avx instructions available */
} jit_va_list_t; uint32_t avx : 1;
#endif /* 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-cpu.c"
#include "x86-sse.c" #include "x86-sse.c"
@ -159,7 +161,7 @@ jit_get_cpu(void)
/* i386 or i486 without cpuid */ /* i386 or i486 without cpuid */
if ((ac & (1 << 21)) == 0) if ((ac & (1 << 21)) == 0)
/* probably without x87 as well */ /* probably without x87 as well */
return false; return 0;
#endif #endif
/* query %eax = 1 function */ /* query %eax = 1 function */
@ -192,8 +194,8 @@ jit_get_cpu(void)
jit_cpu.avx = ecx.bits.avx; jit_cpu.avx = ecx.bits.avx;
/* query %eax = 0x80000001 function */ /* query %eax = 0x80000001 function */
__asm__ volatile (
#if __X64 #if __X64
__asm__ volatile (
# if __X64_32 # if __X64_32
"xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1" "xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1"
# else # else
@ -313,6 +315,12 @@ round_size_up_to_words(size_t bytes)
return words * word_size; return words * word_size;
} }
static size_t
jit_initial_frame_size (void)
{
return __WORDSIZE / 8; // Saved return address is on stack.
}
static void static void
reset_abi_arg_iterator(struct abi_arg_iterator *iter, size_t argc, reset_abi_arg_iterator(struct abi_arg_iterator *iter, size_t argc,
const jit_operand_t *args) 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 static void
jit_try_shorten(jit_state_t *_jit, jit_reloc_t reloc, jit_pointer_t addr) 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 #ifndef _jit_x86_h
#define _jit_x86_h #define _jit_x86_h
#define JIT_HASH_CONSTS 1
#define JIT_NUM_OPERANDS 2
/* /*
* Types * Types
*/ */
#define jit_sse2_p() jit_cpu.sse2
#define jit_x87_reg_p(reg) ((reg) >= _ST0 && (reg) <= _ST6)
#if __WORDSIZE == 32 #if __WORDSIZE == 32
# if defined(__x86_64__) # if defined(__x86_64__)
# define __X64 1 # define __X64 1
@ -138,6 +133,7 @@ jit_fpr_is_callee_save (jit_fpr_t reg)
# define JIT_V0 _RBX # define JIT_V0 _RBX
# define JIT_V1 _RSI # define JIT_V1 _RSI
# define JIT_V2 _RDI # define JIT_V2 _RDI
# define JIT_VTMP _RBP
# define JIT_F0 _XMM0 # define JIT_F0 _XMM0
# define JIT_F1 _XMM1 # define JIT_F1 _XMM1
# define JIT_F2 _XMM2 # define JIT_F2 _XMM2
@ -210,48 +206,4 @@ jit_fpr_is_callee_save (jit_fpr_t reg)
# define JIT_FTMP _XMM15 # define JIT_FTMP _XMM15
#endif #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 */ #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-%: CC = $(CC_IA32)
test-ia32-%: %.c lightening-ia32.o test.h 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: clean:
rm -f $(foreach TARGET,$(TARGETS),$(addprefix test-$(TARGET)-,$(TESTS))) 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0));
jit_absr_d(j, JIT_F0, JIT_F0); jit_absr_d(j, JIT_F0, JIT_F0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_d(j, JIT_F0); jit_retr_d(j, JIT_F0);
double (*f)(double) = jit_end(j, NULL); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_1(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0));
jit_absr_f(j, JIT_F0, JIT_F0); jit_absr_f(j, JIT_F0, JIT_F0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr_f(j, JIT_F0); jit_retr_f(j, JIT_F0);
float (*f)(float) = jit_end(j, NULL); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_addi(j, JIT_R0, JIT_R0, 69);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); jit_retr(j, JIT_R0);
size_t size = 0; 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_addr(j, JIT_R0, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); jit_retr(j, JIT_R0);
size_t size = 0; 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_addr_d(j, JIT_F0, JIT_F0, 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); jit_retr_d(j, JIT_F0);
size_t size = 0; 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_addr_f(j, JIT_F0, JIT_F0, 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); jit_retr_f(j, JIT_F0);
size_t size = 0; 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_movi(j, JIT_R2, 0);
jit_addcr(j, JIT_R0, JIT_R0, JIT_R1); jit_addcr(j, JIT_R0, JIT_R0, JIT_R1);
jit_addxi(j, JIT_R2, JIT_R2, 0); jit_addxi(j, JIT_R2, JIT_R2, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R2); jit_retr(j, JIT_R2);
size_t size = 0; size_t size = 0;
void* ret = jit_end(j, &size); 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); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_andi(j, JIT_R0, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); jit_retr(j, JIT_R0);
size_t size = 0; size_t size = 0;
void* ret = jit_end(j, &size); 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(0x7fffffff) == 1);
ASSERT(f(0x80000000) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_andr(j, JIT_R0, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); jit_retr(j, JIT_R0);
size_t size = 0; size_t size = 0;
void* ret = jit_end(j, &size); 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(0x7fffffff, 1) == 1);
ASSERT(f(1, 0x7fffffff) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_beqi(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 1);
ASSERT(f(1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_beqr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_beqr_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_beqr_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bgei(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 1);
ASSERT(f(1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bgei_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 1);
ASSERT(f(1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bger(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bger_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bger_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bger_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bgti(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 0);
ASSERT(f(1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bgti_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 0);
ASSERT(f(1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bgtr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bgtr_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bgtr_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bgtr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_blei(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 1);
ASSERT(f(1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_blei_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 1);
ASSERT(f(1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bler(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bler_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bler_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bler_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bltgtr_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bltgtr_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_blti(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 0);
ASSERT(f(1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_blti_u(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 0);
ASSERT(f(1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bltr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bltr_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bltr_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bltr_u(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bmci(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 1);
ASSERT(f(1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bmcr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bmsi(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 0);
ASSERT(f(1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bmsr(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bnei(j, JIT_R0, 0);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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(0) == 0);
ASSERT(f(1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bner(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 0); jit_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bner_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bner_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); ASSERT(f(0, 1) == 1);

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

@ -1,20 +1,23 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_boaddi(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); jit_retr(j, JIT_R0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(-1) == 0);
ASSERT(f(0) == 1); ASSERT(f(0) == 1);

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

@ -1,20 +1,23 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_boaddi_u(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); jit_retr(j, JIT_R0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(-1) == overflowed);
ASSERT(f(0) == 1); ASSERT(f(0) == 1);

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

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

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

@ -1,21 +1,24 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_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_retr(j, JIT_R0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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, 0) == 0);
ASSERT(f(1, 1) == 2); 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(0xffffffff, 0xffffffff) == overflowed);
ASSERT(f(0x7fffffff, 0) == 0x7fffffff); ASSERT(f(0x7fffffff, 0) == 0x7fffffff);
ASSERT(f(0x7fffffff, 1) == 0x80000000); ASSERT(f(0x7fffffff, 1) == 0x80000000);
ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffff + 0x7fffffff); ASSERT(f(0x7fffffff, 0x7fffffff) == 0x7fffffffu + 0x7fffffffu);
ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff); ASSERT(f(0x7fffffff, 0x80000000) == 0xffffffff);
ASSERT(f(0x80000000, 0x80000000) == overflowed); ASSERT(f(0x80000000, 0x80000000) == overflowed);
#else #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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bordr_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bordr_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 1); ASSERT(f(0, 1) == 1);

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

@ -1,20 +1,23 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bosubi(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); jit_retr(j, JIT_R0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(-1) == -2);
ASSERT(f(0) == -1); ASSERT(f(0) == -1);

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

@ -1,20 +1,23 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bosubi_u(j, JIT_R0, 1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); jit_retr(j, JIT_R0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(-1) == -2);
ASSERT(f(0) == overflowed); ASSERT(f(0) == overflowed);

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

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

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

@ -1,21 +1,24 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_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_retr(j, JIT_R0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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, 0) == 0);
ASSERT(f(1, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_bswapr_ui(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(0) == 0);
ASSERT(f(0x12345678) == 0x78563412); 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 #if __WORDSIZE > 32
jit_begin(j, arena_base, 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_ul(j, JIT_R0, JIT_R1); jit_bswapr_ul(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(0) == 0);
ASSERT(f(0x12345678) == 0x7856341200000000); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_bswapr_us(j, JIT_R0, JIT_R1);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(0) == 0);
ASSERT(f(0x12345678) == 0x7856); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_buneqr_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_buneqr_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bunger_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bunger_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 0); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bungtr_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bungtr_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bunler_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bunler_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 1);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bunltr_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bunltr_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 1); 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_DOUBLE, JIT_F1));
jit_reloc_t r = jit_bunordr_d(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_2(j, jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F0),
jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1)); jit_operand_fpr (JIT_OPERAND_ABI_FLOAT, JIT_F1));
jit_reloc_t r = jit_bunordr_f(j, JIT_F0, 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_reti(j, 0);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_reti(j, 1); 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, 0) == 0);
ASSERT(f(0, 1) == 0); ASSERT(f(0, 1) == 0);

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

@ -1,19 +1,21 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bxaddi(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(-1) == 0);
ASSERT(f(0) == 1); ASSERT(f(0) == 1);

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

@ -1,19 +1,21 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bxaddi_u(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(-1) == overflowed);
ASSERT(f(0) == 1); ASSERT(f(0) == 1);

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

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

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

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

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

@ -1,19 +1,21 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bxsubi(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(-1) == -2);
ASSERT(f(0) == -1); ASSERT(f(0) == -1);

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

@ -1,19 +1,21 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_reloc_t r = jit_bxsubi_u(j, JIT_R0, 1);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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(-1) == -2);
ASSERT(f(0) == overflowed); ASSERT(f(0) == overflowed);

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

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

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

@ -1,20 +1,22 @@
#include "test.h" #include "test.h"
static const intmax_t overflowed = 0xcabba9e5; static const jit_word_t overflowed = 0xcabba9e5;
static void static void
run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, arena_size); jit_begin(j, arena_base, arena_size);
jit_load_args_2(j, jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R0), size_t align = jit_enter_jit_abi(j, 0, 0, 0);
jit_operand_gpr (JIT_OPERAND_ABI_INTMAX, JIT_R1)); 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_reloc_t r = jit_bxsubr_u(j, JIT_R0, JIT_R1);
jit_movi(j, JIT_R0, overflowed); jit_movi(j, JIT_R0, overflowed);
jit_patch_here(j, r); jit_patch_here(j, r);
jit_leave_jit_abi(j, 0, 0, align);
jit_retr(j, JIT_R0); 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, 0) == 0);
ASSERT(f(1, 1) == 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) run_test(jit_state_t *j, uint8_t *arena_base, size_t arena_size)
{ {
jit_begin(j, arena_base, 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_load_args_1(j, jit_operand_gpr (JIT_OPERAND_ABI_POINTER, JIT_R0));
jit_operand_t args[10] = { 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_operand_mem(JIT_OPERAND_ABI_INT32, JIT_R0, 9 * sizeof(int32_t))
}; };
jit_calli(j, f, 10, args); jit_calli(j, f, 10, args);
jit_leave_jit_abi(j, 0, 0, align);
jit_ret(j); jit_ret(j);
size_t size = 0; 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