[pcsx_rearmed.git] / deps / lightning / check / gen_cbit.c

#include <stdio.h>

/*   Test that jit_extr(), jit_extr_u() and jit_depr() work correctly with
 * C bitfields.
 *   Note that to be compatible with C bitfields, behavior is different
 * for big endian and little endian. For big endian, the bitfield
 * offset is changed to (__WORDSIZE - offset).
 *   The logic is to create a C function that receives a pointer to
 * a single word union (that has a bitfield and a word) and a jit function
 * pointer that knows about the bitfield. The C function calls the jit
 * function passing the pointer to the bitfield, and the jit function
 * changes the bitfield with a computed known value specific for the test.
 *   After calling the jit function, the C function validates that the
 * bitfield has the expected value, and also validates no bits outside of
 * the bitfield were modified.
 *   The test is done for signed and unsigned bitfields.
 *   The test does a brute force validation that all possible bitfields
 * using a machine word work as expected.
 *   Tests for possible register clobber is done in check/ext.tst.
 *   The test is dynamically generated because the generated source file
 * is too large to be kept under version control.
 */

int
main(int argc, char *argv[])
{
    int			i, j;
    puts("\
#include <stdio.h>\n\
#include <lightning.h>\n\
\n\
#  if __WORDSIZE == 64 && _WIN32\n\
#    define ONE				1LL\n\
#  else\n\
#    define ONE				1L\n\
#  endif\n\
/* Avoid clang running out of memory on OpenBSD mips64 */\n\
#define SKIP_64_BITS	(__mips__ && __clang__)\n\
\n\
#define GENMASK1()		GENMASK(1)\n\
#define GENMASK2()		GENMASK(2)\n\
#define GENMASK3()		GENMASK(3)\n\
#define GENMASK4()		GENMASK(4)\n\
#define GENMASK5()		GENMASK(5)\n\
#define GENMASK6()		GENMASK(6)\n\
#define GENMASK7()		GENMASK(7)\n\
#define GENMASK8()		GENMASK(8)\n\
#define GENMASK9()		GENMASK(9)\n\
#define GENMASK10()		GENMASK(10)\n\
#define GENMASK11()		GENMASK(11)\n\
#define GENMASK12()		GENMASK(12)\n\
#define GENMASK13()		GENMASK(13)\n\
#define GENMASK14()		GENMASK(14)\n\
#define GENMASK15()		GENMASK(15)\n\
#define GENMASK16()		GENMASK(16)\n\
#define GENMASK17()		GENMASK(17)\n\
#define GENMASK18()		GENMASK(18)\n\
#define GENMASK19()		GENMASK(19)\n\
#define GENMASK20()		GENMASK(20)\n\
#define GENMASK21()		GENMASK(21)\n\
#define GENMASK22()		GENMASK(22)\n\
#define GENMASK23()		GENMASK(23)\n\
#define GENMASK24()		GENMASK(24)\n\
#define GENMASK25()		GENMASK(25)\n\
#define GENMASK26()		GENMASK(26)\n\
#define GENMASK27()		GENMASK(27)\n\
#define GENMASK28()		GENMASK(28)\n\
#define GENMASK29()		GENMASK(29)\n\
#define GENMASK30()		GENMASK(30)\n\
#define GENMASK31()		GENMASK(31)\n\
#if __WORDSIZE == 32\n\
#  define MININT		0x80000000L\n\
#  define GENMASK32()						\\\n\
    do {							\\\n\
	m = -1;							\\\n\
	t = 0;							\\\n\
    } while (0)\n\
#else\n\
#  define GENMASK32()		GENMASK(32)\n\
#  define GENMASK33()		GENMASK(33)\n\
#  define GENMASK34()		GENMASK(34)\n\
#  define GENMASK35()		GENMASK(35)\n\
#  define GENMASK36()		GENMASK(36)\n\
#  define GENMASK37()		GENMASK(37)\n\
#  define GENMASK38()		GENMASK(38)\n\
#  define GENMASK39()		GENMASK(39)\n\
#  define GENMASK40()		GENMASK(40)\n\
#  define GENMASK41()		GENMASK(41)\n\
#  define GENMASK42()		GENMASK(42)\n\
#  define GENMASK43()		GENMASK(43)\n\
#  define GENMASK44()		GENMASK(44)\n\
#  define GENMASK45()		GENMASK(45)\n\
#  define GENMASK46()		GENMASK(46)\n\
#  define GENMASK47()		GENMASK(47)\n\
#  define GENMASK48()		GENMASK(48)\n\
#  define GENMASK49()		GENMASK(49)\n\
#  define GENMASK50()		GENMASK(50)\n\
#  define GENMASK51()		GENMASK(51)\n\
#  define GENMASK52()		GENMASK(52)\n\
#  define GENMASK53()		GENMASK(53)\n\
#  define GENMASK54()		GENMASK(54)\n\
#  define GENMASK55()		GENMASK(55)\n\
#  define GENMASK56()		GENMASK(56)\n\
#  define GENMASK57()		GENMASK(57)\n\
#  define GENMASK58()		GENMASK(58)\n\
#  define GENMASK59()		GENMASK(59)\n\
#  define GENMASK60()		GENMASK(60)\n\
#  define GENMASK61()		GENMASK(61)\n\
#  define GENMASK62()		GENMASK(62)\n\
#  define GENMASK63()		GENMASK(63)\n\
#  if _WIN32\n\
#    define MININT		0x8000000000000000LL\n\
#  else\n\
#    define MININT		0x8000000000000000L\n\
#  endif\n\
#  define GENMASK64()						\\\n\
    do {							\\\n\
	m = -1;							\\\n\
	t = 0;							\\\n\
    } while (0)\n\
#endif\n\
#if __BYTE_ORDER == __LITTLE_ENDIAN\n\
#  define GENMASK(L)						\\\n\
    do {							\\\n\
	m = (ONE << L) - 1;					\\\n\
	t = m ^ 1;						\\\n\
    } while (0)\n\
#  define SHIFTMASK(B)		m = ~(m << (B))\n\
#else\n\
#  define GENMASK(L)						\\\n\
    do {							\\\n\
	m = (ONE << L) - 1;					\\\n\
	t = m ^ 1;						\\\n\
	m = ((jit_word_t)MININT >> (L - 1));			\\\n\
    } while (0)\n\
#  define SHIFTMASK(B)		m = ~(m >> ((B) - 1))\n\
#endif\n\
\n\
#define	S			jit_word_t\n\
#define	U			jit_uword_t\n\
\n\
#define deftypeSL(L)						\\\n\
typedef union {							\\\n\
    struct {							\\\n\
	S	f: L;						\\\n\
    } b;							\\\n\
    S		s;						\\\n\
} S##L;								\\\n\
static void							\\\n\
CS##L(S##L *u, S (*JS##L)(S##L*)) {				\\\n\
    S t, j, m;							\\\n\
    GENMASK##L();						\\\n\
    m = ~m;							\\\n\
    t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L));		\\\n\
    u->s = 0;							\\\n\
    j = (*JS##L)(u);						\\\n\
    if (u->b.f != t || t != j || (u->s & m))			\\\n\
	abort();						\\\n\
}\n\
\n\
#define deftypeSBL(B, L)					\\\n\
typedef union {							\\\n\
    struct {							\\\n\
	S	_: B;						\\\n\
	S	f: L;						\\\n\
    } b;							\\\n\
    S		s;						\\\n\
} S##B##_##L;							\\\n\
static void							\\\n\
CS##B##_##L(S##B##_##L *u, S (*JS##B##_##L)(S##B##_##L*)) {	\\\n\
    S t, j, m;							\\\n\
    GENMASK##L();						\\\n\
    SHIFTMASK(B);						\\\n\
    t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L));		\\\n\
    u->s = 0;							\\\n\
    j = (*JS##B##_##L)(u);					\\\n\
    if (u->b.f != t || t != j || (u->s & m))			\\\n\
	abort();						\\\n\
}\n\
\n\
#define deftypeUL(L)						\\\n\
typedef union {							\\\n\
    struct {							\\\n\
	U	f: L;						\\\n\
    } b;							\\\n\
    U		u;						\\\n\
} U##L;								\\\n\
static void							\\\n\
CU##L(U##L *u, U (*JU##L)(U##L*)) {				\\\n\
    U t, j, m;							\\\n\
    GENMASK##L();						\\\n\
    m = ~m;							\\\n\
    t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L));		\\\n\
    u->u = 0;							\\\n\
    j = (*JU##L)(u);						\\\n\
    if (u->b.f != t || t != j || (u->u & m))			\\\n\
	abort();						\\\n\
}\n\
\n\
#define deftypeUBL(B, L)					\\\n\
typedef union {							\\\n\
    struct {							\\\n\
	U	_: B;						\\\n\
	U	f: L;						\\\n\
    } b;							\\\n\
    U		u;						\\\n\
} U##B##_##L;							\\\n\
static void							\\\n\
CU##B##_##L(U##B##_##L *u, U (*JU##B##_##L)(U##B##_##L*)) {	\\\n\
    U t, j, m;							\\\n\
    GENMASK##L();						\\\n\
    SHIFTMASK(B);						\\\n\
    t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L));		\\\n\
    u->u = 0;							\\\n\
    j = (*JU##B##_##L)(u);					\\\n\
    if (u->b.f != t || t != j || (u->u & m))			\\\n\
	abort();						\\\n\
}");
    puts("\n/* Define signed bitfields at offset 0 */");
    for (i = 1; i <= 32; i++)
	printf("deftypeSL(%d)\n", i);
    /* Avoid clang running out of memory on OpenBSD mips64 */
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (; i <= 64; i++)
	printf("deftypeSL(%d)\n", i);
    puts("#endif");
    puts("/* Define unsigned bitfields at offset 0 */");
    for (i = 1; i <= 32; i++)
	printf("deftypeUL(%d)\n", i);
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (; i <= 64; i++)
	printf("deftypeUL(%d)\n", i);
    puts("#endif");
    for (i = 1; i <= 31; i++) {
	printf("/* Define signed bitfields at offset %d */\n", i);
	for (j = 1; j <= 32 - i; j++)
	    printf("deftypeSBL(%d, %d)\n", i, j);
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (i = 1; i < 64; i++) {
	printf("/* Define signed bitfields at offset %d */\n", i);
	for (j = 1; j <= 64 - i; j++) {
	    if (i + j > 32)
		printf("deftypeSBL(%d, %d)\n", i, j);
	}
    }
    puts("#endif");
    for (i = 1; i <= 31; i++) {
	printf("/* Define unsigned bitfields at offset %d */\n", i);
	for (j = 1; j <= 32 - i; j++)
	    printf("deftypeUBL(%d, %d)\n", i, j);
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (i = 1; i < 64; i++) {
	printf("/* Define unsigned bitfields at offset %d */\n", i);
	for (j = 1; j <= 64 - i; j++) {
	    if (i + j > 32)
		printf("deftypeUBL(%d, %d)\n", i, j);
	}
    }
    puts("#endif");

    puts("\n\
int\n\
main(int argc, char *argv[])\n\
{\n\
    jit_node_t		 *arg;\n\
    jit_node_t		 *jmpi_main;\n\
    jit_state_t		 *_jit;\n\
    void		(*code)(void);");
    puts("    /* Declare signed bitfields at offset 0 */");
    for (i = 1; i <= 32; i++) {
	printf("    S%d			 pS%d;\n", i, i);
	printf("    jit_node_t		*nS%d;\n", i);
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (; i <= 64; i++) {
	printf("    S%d			 pS%d;\n", i, i);
	printf("    jit_node_t		*nS%d;\n", i);
    }
    puts("#endif");
    puts("    /* Declare unsigned bitfields at offset 0 */");
    for (i = 1; i <= 32; i++) {
	printf("    U%d			 pU%d;\n", i, i);
	printf("    jit_node_t		*nU%d;\n", i);
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (; i <= 64; i++) {
	printf("    U%d			 pU%d;\n", i, i);
	printf("    jit_node_t		*nU%d;\n", i);
    }
    puts("#endif");

    for (i = 1; i <= 31; i++) {
	printf("    /* Declare signed bitfields at offset %d */\n", i);
	for (j = 1; j <= 32 - i; j++) {
	    printf("    S%d_%d		 pS%d_%d;\n", i, j, i, j);
	    printf("    jit_node_t\t	*nS%d_%d;\n", i, j);
	}
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (i = 1; i < 64; i++) {
	printf("    /* Declare signed bitfields at offset %d */\n", i);
	for (j = 1; j <= 64 - i; j++) {
	    if (i + j > 32) {
		printf("    S%d_%d		 pS%d_%d;\n", i, j, i, j);
		printf("    jit_node_t\t	*nS%d_%d;\n", i, j);
	    }
	}
    }
    puts("#endif");
    for (i = 1; i <= 31; i++) {
	printf("    /* Declare unsigned bitfields at offset %d */\n", i);
	for (j = 1; j <= 32 - i; j++) {
	    printf("    U%d_%d		 pU%d_%d;\n", i, j, i, j);
	    printf("    jit_node_t\t	*nU%d_%d;\n", i, j);
	}
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (i = 1; i < 64; i++) {
	printf("    /* Declare unsigned bitfields at offset %d */\n", i);
	for (j = 1; j <= 64 - i; j++) {
	    if (i + j > 32) {
		printf("    U%d_%d		 pU%d_%d;\n", i, j, i, j);
		printf("    jit_node_t\t	*nU%d_%d;\n", i, j);
	    }
	}
    }
    puts("#endif\n");

    puts("\
    init_jit(argv[0]);\n\
    _jit = jit_new_state();\n\
\n\
    jmpi_main = jit_jmpi();\n");

    puts("    /* Define jit functions for signed bitfields at offset 0 */");
    for (i = 1; i <= 32; i++) {
	printf("\
    nS%d = jit_label();\n\
    jit_prolog();\n\
    arg = jit_arg();\n\
    jit_getarg(JIT_R0, arg);\n\
    jit_ldr(JIT_R2, JIT_R0);\n", i);
	if ((i >> 3) < sizeof(void*))
	    printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i);
	else
	    printf("jit_movi(JIT_R1, 0);\n");
	printf("\
    jit_depr(JIT_R2, JIT_R1, 0, %d);\n\
    jit_extr(JIT_R1, JIT_R2, 0, %d);\n\
    jit_str(JIT_R0, JIT_R2);\n\
    jit_retr(JIT_R1);\n\
    jit_epilog();\n", i, i);
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (; i <= 64; i++) {
	printf("\
    nS%d = jit_label();\n\
    jit_prolog();\n\
    arg = jit_arg();\n\
    jit_getarg(JIT_R0, arg);\n\
    jit_ldr(JIT_R2, JIT_R0);\n", i);
	if ((i >> 3) < sizeof(void*))
	    printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i);
	else
	    printf("jit_movi(JIT_R1, 0);\n");
	printf("\
    jit_depr(JIT_R2, JIT_R1, 0, %d);\n\
    jit_extr(JIT_R1, JIT_R2, 0, %d);\n\
    jit_str(JIT_R0, JIT_R2);\n\
    jit_retr(JIT_R1);\n\
    jit_epilog();\n", i, i);
    }
    puts("#endif");

    puts("    /* Define jit functions for unsigned bitfields at offset 0 */");
    for (i = 1; i <= 32; i++) {
	printf("\
    nU%d = jit_label();\n\
    jit_prolog();\n\
    arg = jit_arg();\n\
    jit_getarg(JIT_R0, arg);\n\
    jit_ldr(JIT_R2, JIT_R0);\n", i);
	if ((i >> 3) < sizeof(void*))
	    printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i);
	else
	    printf("jit_movi(JIT_R1, 0);\n");
	printf("\
    jit_depr(JIT_R2, JIT_R1, 0, %d);\n\
    jit_extr_u(JIT_R1, JIT_R2, 0, %d);\n\
    jit_str(JIT_R0, JIT_R2);\n\
    jit_retr(JIT_R1);\n\
    jit_epilog();\n", i, i);
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (; i <= 64; i++) {
	printf("\
    nU%d = jit_label();\n\
    jit_prolog();\n\
    arg = jit_arg();\n\
    jit_getarg(JIT_R0, arg);\n\
    jit_ldr(JIT_R2, JIT_R0);\n", i);
	if ((i >> 3) < sizeof(void*))
	    printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i);
	else
	    printf("jit_movi(JIT_R1, 0);\n");
	printf("\
    jit_depr(JIT_R2, JIT_R1, 0, %d);\n\
    jit_extr_u(JIT_R1, JIT_R2, 0, %d);\n\
    jit_str(JIT_R0, JIT_R2);\n\
    jit_retr(JIT_R1);\n\
    jit_epilog();\n", i, i);
    }
    puts("#endif");

    for (i = 1; i <= 31; i++) {
	printf("    /* Define jit functions for signed bitfields at offset %d */\n", i);
	for (j = 1; j <= 32 - i; j++) {
	printf("\
    nS%d_%d = jit_label();\n\
    jit_prolog();\n\
    arg = jit_arg();\n\
    jit_getarg(JIT_R0, arg);\n\
    jit_ldr(JIT_R2, JIT_R0);\n\
    jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\
    jit_depr(JIT_R2, JIT_R1, %d, %d);\n\
    jit_extr(JIT_R1, JIT_R2, %d, %d);\n\
    jit_str(JIT_R0, JIT_R2);\n\
    jit_retr(JIT_R1);\n\
    jit_epilog();\n", i, j, j, i, j, i, j);
	}
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (i = 1; i < 64; i++) {
	printf("    /* Declare jit functions for signed bitfields at offset %d */\n", i);
	for (j = 1; j <= 64 - i; j++) {
	    if (i + j > 32)
		printf("\
    nS%d_%d = jit_label();\n\
    jit_prolog();\n\
    arg = jit_arg();\n\
    jit_getarg(JIT_R0, arg);\n\
    jit_ldr(JIT_R2, JIT_R0);\n\
    jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\
    jit_depr(JIT_R2, JIT_R1, %d, %d);\n\
    jit_extr(JIT_R1, JIT_R2, %d, %d);\n\
    jit_str(JIT_R0, JIT_R2);\n\
    jit_retr(JIT_R1);\n\
    jit_epilog();\n", i, j, j, i, j, i, j);
	}
    }
    puts("#endif");

    for (i = 1; i <= 31; i++) {
	printf("    /* Define jit functions for unsigned bitfields at offset %d */\n", i);
	for (j = 1; j <= 32 - i; j++) {
	printf("\
    nU%d_%d = jit_label();\n\
    jit_prolog();\n\
    arg = jit_arg();\n\
    jit_getarg(JIT_R0, arg);\n\
    jit_ldr(JIT_R2, JIT_R0);\n\
    jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\
    jit_depr(JIT_R2, JIT_R1, %d, %d);\n\
    jit_extr_u(JIT_R1, JIT_R2, %d, %d);\n\
    jit_str(JIT_R0, JIT_R2);\n\
    jit_retr(JIT_R1);\n\
    jit_epilog();\n", i, j, j, i, j, i, j);
	}
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (i = 1; i < 64; i++) {
	printf("    /* Declare jit functions for unsigned bitfields at offset %d */\n", i);
	for (j = 1; j <= 64 - i; j++) {
	    if (i + j > 32)
		printf("\
    nU%d_%d = jit_label();\n\
    jit_prolog();\n\
    arg = jit_arg();\n\
    jit_getarg(JIT_R0, arg);\n\
    jit_ldr(JIT_R2, JIT_R0);\n\
    jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\
    jit_depr(JIT_R2, JIT_R1, %d, %d);\n\
    jit_extr_u(JIT_R1, JIT_R2, %d, %d);\n\
    jit_str(JIT_R0, JIT_R2);\n\
    jit_retr(JIT_R1);\n\
    jit_epilog();\n", i, j, j, i, j, i, j);
	}
    }
    puts("#endif");

    puts("\n\
    jit_patch(jmpi_main);\n\
    jit_name(\"main\");\n\
    jit_note(\"cbit.c\", __LINE__);\n\
    jit_prolog();\n");

    puts("    /* Call C functions for signed bitfields at offset 0 */");
    for (i = 1; i <= 32; i++)
	printf("\
    jit_patch_at(jit_movi(JIT_R0, 0), nS%d);\n\
    jit_prepare();\n\
    jit_pushargi((jit_word_t)&pS%d);\n\
    jit_pushargr(JIT_R0);\n\
    jit_finishi((jit_word_t*)CS%d);\n", i, i, i);
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (; i <= 64; i++)
	printf("\
    jit_patch_at(jit_movi(JIT_R0, 0), nS%d);\n\
    jit_prepare();\n\
    jit_pushargi((jit_word_t)&pS%d);\n\
    jit_pushargr(JIT_R0);\n\
    jit_finishi((jit_word_t*)CS%d);\n", i, i, i);
    puts("#endif");
    puts("    /* Call C functions for unsigned bitfields at offset 0 */");
    for (i = 1; i <= 32; i++)
	printf("\
    jit_patch_at(jit_movi(JIT_R0, 0), nU%d);\n\
    jit_prepare();\n\
    jit_pushargi((jit_word_t)&pU%d);\n\
    jit_pushargr(JIT_R0);\n\
    jit_finishi((jit_word_t*)CU%d);\n", i, i, i);
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (; i <= 64; i++)
	printf("\
    jit_patch_at(jit_movi(JIT_R0, 0), nU%d);\n\
    jit_prepare();\n\
    jit_pushargi((jit_word_t)&pU%d);\n\
    jit_pushargr(JIT_R0);\n\
    jit_finishi((jit_word_t*)CU%d);\n", i, i, i);
    puts("#endif");

    for (i = 1; i <= 31; i++) {
	printf("    /* Call C functions for signed bitfields at offset %d */\n", i);
	for (j = 1; j <= 32 - i; j++) {
	    printf("\
    jit_patch_at(jit_movi(JIT_R0, 0), nS%d_%d);\n\
    jit_prepare();\n\
    jit_pushargi((jit_word_t)&pS%d_%d);\n\
    jit_pushargr(JIT_R0);\n\
    jit_finishi((jit_word_t*)CS%d_%d);\n", i, j, i, j, i, j);
	}
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (i = 1; i < 64; i++) {
	printf("    /* Call C functions for signed bitfields at offset %d */\n", i);
	for (j = 1; j <= 64 - i; j++) {
	    if (i + j > 32)
		printf("\
    jit_patch_at(jit_movi(JIT_R0, 0), nS%d_%d);\n\
    jit_prepare();\n\
    jit_pushargi((jit_word_t)&pS%d_%d);\n\
    jit_pushargr(JIT_R0);\n\
    jit_finishi((jit_word_t*)CS%d_%d);\n", i, j, i, j, i, j);
	}
    }
    puts("#endif");

    for (i = 1; i <= 31; i++) {
	printf("    /* Call C functions for unsigned bitfields at offset %d */\n", i);
	for (j = 1; j <= 32 - i; j++) {
	    printf("\
    jit_patch_at(jit_movi(JIT_R0, 0), nU%d_%d);\n\
    jit_prepare();\n\
    jit_pushargi((jit_word_t)&pU%d_%d);\n\
    jit_pushargr(JIT_R0);\n\
    jit_finishi((jit_word_t*)CU%d_%d);\n", i, j, i, j, i, j);
	}
    }
    puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
    for (i = 1; i < 64; i++) {
	printf("    /* Call C functions for unsigned bitfields at offset %d */\n", i);
	for (j = 1; j <= 64 - i; j++) {
	    if (i + j > 32)
		printf("\
    jit_patch_at(jit_movi(JIT_R0, 0), nU%d_%d);\n\
    jit_prepare();\n\
    jit_pushargi((jit_word_t)&pU%d_%d);\n\
    jit_pushargr(JIT_R0);\n\
    jit_finishi((jit_word_t*)CU%d_%d);\n", i, j, i, j, i, j);
	}
    }
    puts("#endif");

    puts("\n\
    jit_ret();\n\
    jit_epilog();\n\
\n\
    code = jit_emit();\n\
\n\
    jit_clear_state();\n\
\n\
    (*code)();\n\
    jit_destroy_state();\n\
\n\
    finish_jit();\n\
\n\
    return (0);\n\
}");

    return (0);
}
Commit	Line	Data
ba86ff93 PC	1	#include <stdio.h>
	2
	3	/* Test that jit_extr(), jit_extr_u() and jit_depr() work correctly with
	4	* C bitfields.
	5	* Note that to be compatible with C bitfields, behavior is different
	6	* for big endian and little endian. For big endian, the bitfield
	7	* offset is changed to (__WORDSIZE - offset).
	8	* The logic is to create a C function that receives a pointer to
	9	* a single word union (that has a bitfield and a word) and a jit function
	10	* pointer that knows about the bitfield. The C function calls the jit
	11	* function passing the pointer to the bitfield, and the jit function
	12	* changes the bitfield with a computed known value specific for the test.
	13	* After calling the jit function, the C function validates that the
	14	* bitfield has the expected value, and also validates no bits outside of
	15	* the bitfield were modified.
	16	* The test is done for signed and unsigned bitfields.
	17	* The test does a brute force validation that all possible bitfields
	18	* using a machine word work as expected.
	19	* Tests for possible register clobber is done in check/ext.tst.
	20	* The test is dynamically generated because the generated source file
	21	* is too large to be kept under version control.
	22	*/
	23
	24	int
	25	main(int argc, char *argv[])
	26	{
	27	int i, j;
	28	puts("\
	29	#include <stdio.h>\n\
	30	#include <lightning.h>\n\
	31	\n\
	32	# if __WORDSIZE == 64 && _WIN32\n\
	33	# define ONE 1LL\n\
	34	# else\n\
	35	# define ONE 1L\n\
	36	# endif\n\
	37	/* Avoid clang running out of memory on OpenBSD mips64 */\n\
	38	#define SKIP_64_BITS (__mips__ && __clang__)\n\
	39	\n\
	40	#define GENMASK1() GENMASK(1)\n\
	41	#define GENMASK2() GENMASK(2)\n\
	42	#define GENMASK3() GENMASK(3)\n\
	43	#define GENMASK4() GENMASK(4)\n\
	44	#define GENMASK5() GENMASK(5)\n\
	45	#define GENMASK6() GENMASK(6)\n\
	46	#define GENMASK7() GENMASK(7)\n\
	47	#define GENMASK8() GENMASK(8)\n\
	48	#define GENMASK9() GENMASK(9)\n\
	49	#define GENMASK10() GENMASK(10)\n\
	50	#define GENMASK11() GENMASK(11)\n\
	51	#define GENMASK12() GENMASK(12)\n\
	52	#define GENMASK13() GENMASK(13)\n\
	53	#define GENMASK14() GENMASK(14)\n\
	54	#define GENMASK15() GENMASK(15)\n\
	55	#define GENMASK16() GENMASK(16)\n\
	56	#define GENMASK17() GENMASK(17)\n\
	57	#define GENMASK18() GENMASK(18)\n\
	58	#define GENMASK19() GENMASK(19)\n\
	59	#define GENMASK20() GENMASK(20)\n\
	60	#define GENMASK21() GENMASK(21)\n\
	61	#define GENMASK22() GENMASK(22)\n\
	62	#define GENMASK23() GENMASK(23)\n\
	63	#define GENMASK24() GENMASK(24)\n\
	64	#define GENMASK25() GENMASK(25)\n\
65	#define GENMASK26() GENMASK(26)\n\
66	#define GENMASK27() GENMASK(27)\n\
67	#define GENMASK28() GENMASK(28)\n\
68	#define GENMASK29() GENMASK(29)\n\
69	#define GENMASK30() GENMASK(30)\n\
70	#define GENMASK31() GENMASK(31)\n\
71	#if __WORDSIZE == 32\n\
72	# define MININT 0x80000000L\n\
73	# define GENMASK32() \\\n\
74	do { \\\n\
75	m = -1; \\\n\
76	t = 0; \\\n\
77	} while (0)\n\
78	#else\n\
79	# define GENMASK32() GENMASK(32)\n\
80	# define GENMASK33() GENMASK(33)\n\
81	# define GENMASK34() GENMASK(34)\n\
82	# define GENMASK35() GENMASK(35)\n\
83	# define GENMASK36() GENMASK(36)\n\
84	# define GENMASK37() GENMASK(37)\n\
85	# define GENMASK38() GENMASK(38)\n\
86	# define GENMASK39() GENMASK(39)\n\
87	# define GENMASK40() GENMASK(40)\n\
88	# define GENMASK41() GENMASK(41)\n\
89	# define GENMASK42() GENMASK(42)\n\
90	# define GENMASK43() GENMASK(43)\n\
91	# define GENMASK44() GENMASK(44)\n\
92	# define GENMASK45() GENMASK(45)\n\
93	# define GENMASK46() GENMASK(46)\n\
94	# define GENMASK47() GENMASK(47)\n\
95	# define GENMASK48() GENMASK(48)\n\
96	# define GENMASK49() GENMASK(49)\n\
97	# define GENMASK50() GENMASK(50)\n\
98	# define GENMASK51() GENMASK(51)\n\
99	# define GENMASK52() GENMASK(52)\n\
100	# define GENMASK53() GENMASK(53)\n\
101	# define GENMASK54() GENMASK(54)\n\
102	# define GENMASK55() GENMASK(55)\n\
103	# define GENMASK56() GENMASK(56)\n\
104	# define GENMASK57() GENMASK(57)\n\
105	# define GENMASK58() GENMASK(58)\n\
106	# define GENMASK59() GENMASK(59)\n\
107	# define GENMASK60() GENMASK(60)\n\
108	# define GENMASK61() GENMASK(61)\n\
109	# define GENMASK62() GENMASK(62)\n\
110	# define GENMASK63() GENMASK(63)\n\
111	# if _WIN32\n\
112	# define MININT 0x8000000000000000LL\n\
113	# else\n\
114	# define MININT 0x8000000000000000L\n\
115	# endif\n\
116	# define GENMASK64() \\\n\
117	do { \\\n\
118	m = -1; \\\n\
119	t = 0; \\\n\
120	} while (0)\n\
121	#endif\n\
122	#if __BYTE_ORDER == __LITTLE_ENDIAN\n\
123	# define GENMASK(L) \\\n\
124	do { \\\n\
125	m = (ONE << L) - 1; \\\n\
126	t = m ^ 1; \\\n\
127	} while (0)\n\
128	# define SHIFTMASK(B) m = ~(m << (B))\n\
129	#else\n\
130	# define GENMASK(L) \\\n\
131	do { \\\n\
132	m = (ONE << L) - 1; \\\n\
133	t = m ^ 1; \\\n\
134	m = ((jit_word_t)MININT >> (L - 1)); \\\n\
135	} while (0)\n\
136	# define SHIFTMASK(B) m = ~(m >> ((B) - 1))\n\
137	#endif\n\
138	\n\
139	#define S jit_word_t\n\
140	#define U jit_uword_t\n\
141	\n\
142	#define deftypeSL(L) \\\n\
143	typedef union { \\\n\
144	struct { \\\n\
145	S f: L; \\\n\
146	} b; \\\n\
147	S s; \\\n\
148	} S##L; \\\n\
149	static void \\\n\
150	CS##L(S##L u, S (JS##L)(S##L*)) { \\\n\
151	S t, j, m; \\\n\
152	GENMASK##L(); \\\n\
153	m = ~m; \\\n\
154	t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L)); \\\n\
155	u->s = 0; \\\n\
156	j = (*JS##L)(u); \\\n\
157	if (u->b.f != t \|\| t != j \|\| (u->s & m)) \\\n\
158	abort(); \\\n\
159	}\n\
160	\n\
161	#define deftypeSBL(B, L) \\\n\
162	typedef union { \\\n\
163	struct { \\\n\
164	S _: B; \\\n\
165	S f: L; \\\n\
166	} b; \\\n\
167	S s; \\\n\
168	} S##B##_##L; \\\n\
169	static void \\\n\
170	CS##B##_##L(S##B##_##L u, S (JS##B##_##L)(S##B##_##L*)) { \\\n\
171	S t, j, m; \\\n\
172	GENMASK##L(); \\\n\
173	SHIFTMASK(B); \\\n\
174	t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L)); \\\n\
175	u->s = 0; \\\n\
176	j = (*JS##B##_##L)(u); \\\n\
177	if (u->b.f != t \|\| t != j \|\| (u->s & m)) \\\n\
178	abort(); \\\n\
179	}\n\
180	\n\
181	#define deftypeUL(L) \\\n\
182	typedef union { \\\n\
183	struct { \\\n\
184	U f: L; \\\n\
185	} b; \\\n\
186	U u; \\\n\
187	} U##L; \\\n\
188	static void \\\n\
189	CU##L(U##L u, U (JU##L)(U##L*)) { \\\n\
190	U t, j, m; \\\n\
191	GENMASK##L(); \\\n\
192	m = ~m; \\\n\
193	t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L)); \\\n\
194	u->u = 0; \\\n\
195	j = (*JU##L)(u); \\\n\
196	if (u->b.f != t \|\| t != j \|\| (u->u & m)) \\\n\
197	abort(); \\\n\
198	}\n\
199	\n\
200	#define deftypeUBL(B, L) \\\n\
201	typedef union { \\\n\
202	struct { \\\n\
203	U _: B; \\\n\
204	U f: L; \\\n\
205	} b; \\\n\
206	U u; \\\n\
207	} U##B##_##L; \\\n\
208	static void \\\n\
209	CU##B##_##L(U##B##_##L u, U (JU##B##_##L)(U##B##_##L*)) { \\\n\
210	U t, j, m; \\\n\
211	GENMASK##L(); \\\n\
212	SHIFTMASK(B); \\\n\
213	t = ((t << (__WORDSIZE - L)) >> (__WORDSIZE - L)); \\\n\
214	u->u = 0; \\\n\
215	j = (*JU##B##_##L)(u); \\\n\
216	if (u->b.f != t \|\| t != j \|\| (u->u & m)) \\\n\
217	abort(); \\\n\
218	}");
219	puts("\n/* Define signed bitfields at offset 0 */");
220	for (i = 1; i <= 32; i++)
221	printf("deftypeSL(%d)\n", i);
222	/* Avoid clang running out of memory on OpenBSD mips64 */
223	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
224	for (; i <= 64; i++)
225	printf("deftypeSL(%d)\n", i);
226	puts("#endif");
227	puts("/* Define unsigned bitfields at offset 0 */");
228	for (i = 1; i <= 32; i++)
229	printf("deftypeUL(%d)\n", i);
230	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
231	for (; i <= 64; i++)
232	printf("deftypeUL(%d)\n", i);
233	puts("#endif");
234	for (i = 1; i <= 31; i++) {
235	printf("/* Define signed bitfields at offset %d */\n", i);
236	for (j = 1; j <= 32 - i; j++)
237	printf("deftypeSBL(%d, %d)\n", i, j);
238	}
239	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
240	for (i = 1; i < 64; i++) {
241	printf("/* Define signed bitfields at offset %d */\n", i);
242	for (j = 1; j <= 64 - i; j++) {
243	if (i + j > 32)
244	printf("deftypeSBL(%d, %d)\n", i, j);
245	}
246	}
247	puts("#endif");
248	for (i = 1; i <= 31; i++) {
249	printf("/* Define unsigned bitfields at offset %d */\n", i);
250	for (j = 1; j <= 32 - i; j++)
251	printf("deftypeUBL(%d, %d)\n", i, j);
252	}
253	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
254	for (i = 1; i < 64; i++) {
255	printf("/* Define unsigned bitfields at offset %d */\n", i);
256	for (j = 1; j <= 64 - i; j++) {
257	if (i + j > 32)
258	printf("deftypeUBL(%d, %d)\n", i, j);
259	}
260	}
261	puts("#endif");
262
263	puts("\n\
264	int\n\
265	main(int argc, char *argv[])\n\
266	{\n\
267	jit_node_t *arg;\n\
268	jit_node_t *jmpi_main;\n\
269	jit_state_t *_jit;\n\
270	void (*code)(void);");
271	puts(" /* Declare signed bitfields at offset 0 */");
272	for (i = 1; i <= 32; i++) {
273	printf(" S%d pS%d;\n", i, i);
274	printf(" jit_node_t *nS%d;\n", i);
275	}
276	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
277	for (; i <= 64; i++) {
278	printf(" S%d pS%d;\n", i, i);
279	printf(" jit_node_t *nS%d;\n", i);
280	}
281	puts("#endif");
282	puts(" /* Declare unsigned bitfields at offset 0 */");
283	for (i = 1; i <= 32; i++) {
284	printf(" U%d pU%d;\n", i, i);
285	printf(" jit_node_t *nU%d;\n", i);
286	}
287	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
288	for (; i <= 64; i++) {
289	printf(" U%d pU%d;\n", i, i);
290	printf(" jit_node_t *nU%d;\n", i);
291	}
292	puts("#endif");
293
294	for (i = 1; i <= 31; i++) {
295	printf(" /* Declare signed bitfields at offset %d */\n", i);
296	for (j = 1; j <= 32 - i; j++) {
297	printf(" S%d_%d pS%d_%d;\n", i, j, i, j);
298	printf(" jit_node_t\t *nS%d_%d;\n", i, j);
299	}
300	}
301	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
302	for (i = 1; i < 64; i++) {
303	printf(" /* Declare signed bitfields at offset %d */\n", i);
304	for (j = 1; j <= 64 - i; j++) {
305	if (i + j > 32) {
306	printf(" S%d_%d pS%d_%d;\n", i, j, i, j);
307	printf(" jit_node_t\t *nS%d_%d;\n", i, j);
308	}
309	}
310	}
311	puts("#endif");
312	for (i = 1; i <= 31; i++) {
313	printf(" /* Declare unsigned bitfields at offset %d */\n", i);
314	for (j = 1; j <= 32 - i; j++) {
315	printf(" U%d_%d pU%d_%d;\n", i, j, i, j);
316	printf(" jit_node_t\t *nU%d_%d;\n", i, j);
317	}
318	}
319	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
320	for (i = 1; i < 64; i++) {
321	printf(" /* Declare unsigned bitfields at offset %d */\n", i);
322	for (j = 1; j <= 64 - i; j++) {
323	if (i + j > 32) {
324	printf(" U%d_%d pU%d_%d;\n", i, j, i, j);
325	printf(" jit_node_t\t *nU%d_%d;\n", i, j);
326	}
327	}
328	}
329	puts("#endif\n");
330
331	puts("\
332	init_jit(argv[0]);\n\
333	_jit = jit_new_state();\n\
334	\n\
335	jmpi_main = jit_jmpi();\n");
336
337	puts(" /* Define jit functions for signed bitfields at offset 0 */");
338	for (i = 1; i <= 32; i++) {
339	printf("\
340	nS%d = jit_label();\n\
341	jit_prolog();\n\
342	arg = jit_arg();\n\
343	jit_getarg(JIT_R0, arg);\n\
344	jit_ldr(JIT_R2, JIT_R0);\n", i);
345	if ((i >> 3) < sizeof(void*))
346	printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i);
347	else
348	printf("jit_movi(JIT_R1, 0);\n");
349	printf("\
350	jit_depr(JIT_R2, JIT_R1, 0, %d);\n\
351	jit_extr(JIT_R1, JIT_R2, 0, %d);\n\
352	jit_str(JIT_R0, JIT_R2);\n\
353	jit_retr(JIT_R1);\n\
354	jit_epilog();\n", i, i);
355	}
356	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
357	for (; i <= 64; i++) {
358	printf("\
359	nS%d = jit_label();\n\
360	jit_prolog();\n\
361	arg = jit_arg();\n\
362	jit_getarg(JIT_R0, arg);\n\
363	jit_ldr(JIT_R2, JIT_R0);\n", i);
364	if ((i >> 3) < sizeof(void*))
365	printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i);
366	else
367	printf("jit_movi(JIT_R1, 0);\n");
368	printf("\
369	jit_depr(JIT_R2, JIT_R1, 0, %d);\n\
370	jit_extr(JIT_R1, JIT_R2, 0, %d);\n\
371	jit_str(JIT_R0, JIT_R2);\n\
372	jit_retr(JIT_R1);\n\
373	jit_epilog();\n", i, i);
374	}
375	puts("#endif");
376
377	puts(" /* Define jit functions for unsigned bitfields at offset 0 */");
378	for (i = 1; i <= 32; i++) {
379	printf("\
380	nU%d = jit_label();\n\
381	jit_prolog();\n\
382	arg = jit_arg();\n\
383	jit_getarg(JIT_R0, arg);\n\
384	jit_ldr(JIT_R2, JIT_R0);\n", i);
385	if ((i >> 3) < sizeof(void*))
386	printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i);
387	else
388	printf("jit_movi(JIT_R1, 0);\n");
389	printf("\
390	jit_depr(JIT_R2, JIT_R1, 0, %d);\n\
391	jit_extr_u(JIT_R1, JIT_R2, 0, %d);\n\
392	jit_str(JIT_R0, JIT_R2);\n\
393	jit_retr(JIT_R1);\n\
394	jit_epilog();\n", i, i);
395	}
396	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
397	for (; i <= 64; i++) {
398	printf("\
399	nU%d = jit_label();\n\
400	jit_prolog();\n\
401	arg = jit_arg();\n\
402	jit_getarg(JIT_R0, arg);\n\
403	jit_ldr(JIT_R2, JIT_R0);\n", i);
404	if ((i >> 3) < sizeof(void*))
405	printf("jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n", i);
406	else
407	printf("jit_movi(JIT_R1, 0);\n");
408	printf("\
409	jit_depr(JIT_R2, JIT_R1, 0, %d);\n\
410	jit_extr_u(JIT_R1, JIT_R2, 0, %d);\n\
411	jit_str(JIT_R0, JIT_R2);\n\
412	jit_retr(JIT_R1);\n\
413	jit_epilog();\n", i, i);
414	}
415	puts("#endif");
416
417	for (i = 1; i <= 31; i++) {
418	printf(" /* Define jit functions for signed bitfields at offset %d */\n", i);
419	for (j = 1; j <= 32 - i; j++) {
420	printf("\
421	nS%d_%d = jit_label();\n\
422	jit_prolog();\n\
423	arg = jit_arg();\n\
424	jit_getarg(JIT_R0, arg);\n\
425	jit_ldr(JIT_R2, JIT_R0);\n\
426	jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\
427	jit_depr(JIT_R2, JIT_R1, %d, %d);\n\
428	jit_extr(JIT_R1, JIT_R2, %d, %d);\n\
429	jit_str(JIT_R0, JIT_R2);\n\
430	jit_retr(JIT_R1);\n\
431	jit_epilog();\n", i, j, j, i, j, i, j);
432	}
433	}
434	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
435	for (i = 1; i < 64; i++) {
436	printf(" /* Declare jit functions for signed bitfields at offset %d */\n", i);
437	for (j = 1; j <= 64 - i; j++) {
438	if (i + j > 32)
439	printf("\
440	nS%d_%d = jit_label();\n\
441	jit_prolog();\n\
442	arg = jit_arg();\n\
443	jit_getarg(JIT_R0, arg);\n\
444	jit_ldr(JIT_R2, JIT_R0);\n\
445	jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\
446	jit_depr(JIT_R2, JIT_R1, %d, %d);\n\
447	jit_extr(JIT_R1, JIT_R2, %d, %d);\n\
448	jit_str(JIT_R0, JIT_R2);\n\
449	jit_retr(JIT_R1);\n\
450	jit_epilog();\n", i, j, j, i, j, i, j);
451	}
452	}
453	puts("#endif");
454
455	for (i = 1; i <= 31; i++) {
456	printf(" /* Define jit functions for unsigned bitfields at offset %d */\n", i);
457	for (j = 1; j <= 32 - i; j++) {
458	printf("\
459	nU%d_%d = jit_label();\n\
460	jit_prolog();\n\
461	arg = jit_arg();\n\
462	jit_getarg(JIT_R0, arg);\n\
463	jit_ldr(JIT_R2, JIT_R0);\n\
464	jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\
465	jit_depr(JIT_R2, JIT_R1, %d, %d);\n\
466	jit_extr_u(JIT_R1, JIT_R2, %d, %d);\n\
467	jit_str(JIT_R0, JIT_R2);\n\
468	jit_retr(JIT_R1);\n\
469	jit_epilog();\n", i, j, j, i, j, i, j);
470	}
471	}
472	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
473	for (i = 1; i < 64; i++) {
474	printf(" /* Declare jit functions for unsigned bitfields at offset %d */\n", i);
475	for (j = 1; j <= 64 - i; j++) {
476	if (i + j > 32)
477	printf("\
478	nU%d_%d = jit_label();\n\
479	jit_prolog();\n\
480	arg = jit_arg();\n\
481	jit_getarg(JIT_R0, arg);\n\
482	jit_ldr(JIT_R2, JIT_R0);\n\
483	jit_movi(JIT_R1, ((ONE << %d) - 1) ^ 1);\n\
484	jit_depr(JIT_R2, JIT_R1, %d, %d);\n\
485	jit_extr_u(JIT_R1, JIT_R2, %d, %d);\n\
486	jit_str(JIT_R0, JIT_R2);\n\
487	jit_retr(JIT_R1);\n\
488	jit_epilog();\n", i, j, j, i, j, i, j);
489	}
490	}
491	puts("#endif");
492
493	puts("\n\
494	jit_patch(jmpi_main);\n\
495	jit_name(\"main\");\n\
496	jit_note(\"cbit.c\", __LINE__);\n\
497	jit_prolog();\n");
498
499	puts(" /* Call C functions for signed bitfields at offset 0 */");
500	for (i = 1; i <= 32; i++)
501	printf("\
502	jit_patch_at(jit_movi(JIT_R0, 0), nS%d);\n\
503	jit_prepare();\n\
504	jit_pushargi((jit_word_t)&pS%d);\n\
505	jit_pushargr(JIT_R0);\n\
506	jit_finishi((jit_word_t*)CS%d);\n", i, i, i);
507	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
508	for (; i <= 64; i++)
509	printf("\
510	jit_patch_at(jit_movi(JIT_R0, 0), nS%d);\n\
511	jit_prepare();\n\
512	jit_pushargi((jit_word_t)&pS%d);\n\
513	jit_pushargr(JIT_R0);\n\
514	jit_finishi((jit_word_t*)CS%d);\n", i, i, i);
515	puts("#endif");
516	puts(" /* Call C functions for unsigned bitfields at offset 0 */");
517	for (i = 1; i <= 32; i++)
518	printf("\
519	jit_patch_at(jit_movi(JIT_R0, 0), nU%d);\n\
520	jit_prepare();\n\
521	jit_pushargi((jit_word_t)&pU%d);\n\
522	jit_pushargr(JIT_R0);\n\
523	jit_finishi((jit_word_t*)CU%d);\n", i, i, i);
524	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
525	for (; i <= 64; i++)
526	printf("\
527	jit_patch_at(jit_movi(JIT_R0, 0), nU%d);\n\
528	jit_prepare();\n\
529	jit_pushargi((jit_word_t)&pU%d);\n\
530	jit_pushargr(JIT_R0);\n\
531	jit_finishi((jit_word_t*)CU%d);\n", i, i, i);
532	puts("#endif");
533
534	for (i = 1; i <= 31; i++) {
535	printf(" /* Call C functions for signed bitfields at offset %d */\n", i);
536	for (j = 1; j <= 32 - i; j++) {
537	printf("\
538	jit_patch_at(jit_movi(JIT_R0, 0), nS%d_%d);\n\
539	jit_prepare();\n\
540	jit_pushargi((jit_word_t)&pS%d_%d);\n\
541	jit_pushargr(JIT_R0);\n\
542	jit_finishi((jit_word_t*)CS%d_%d);\n", i, j, i, j, i, j);
543	}
544	}
545	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
546	for (i = 1; i < 64; i++) {
547	printf(" /* Call C functions for signed bitfields at offset %d */\n", i);
548	for (j = 1; j <= 64 - i; j++) {
549	if (i + j > 32)
550	printf("\
551	jit_patch_at(jit_movi(JIT_R0, 0), nS%d_%d);\n\
552	jit_prepare();\n\
553	jit_pushargi((jit_word_t)&pS%d_%d);\n\
554	jit_pushargr(JIT_R0);\n\
555	jit_finishi((jit_word_t*)CS%d_%d);\n", i, j, i, j, i, j);
556	}
557	}
558	puts("#endif");
559
560	for (i = 1; i <= 31; i++) {
561	printf(" /* Call C functions for unsigned bitfields at offset %d */\n", i);
562	for (j = 1; j <= 32 - i; j++) {
563	printf("\
564	jit_patch_at(jit_movi(JIT_R0, 0), nU%d_%d);\n\
565	jit_prepare();\n\
566	jit_pushargi((jit_word_t)&pU%d_%d);\n\
567	jit_pushargr(JIT_R0);\n\
568	jit_finishi((jit_word_t*)CU%d_%d);\n", i, j, i, j, i, j);
569	}
570	}
571	puts("#if __WORDSIZE == 64 && !SKIP_64_BITS");
572	for (i = 1; i < 64; i++) {
573	printf(" /* Call C functions for unsigned bitfields at offset %d */\n", i);
574	for (j = 1; j <= 64 - i; j++) {
575	if (i + j > 32)
576	printf("\
577	jit_patch_at(jit_movi(JIT_R0, 0), nU%d_%d);\n\
578	jit_prepare();\n\
579	jit_pushargi((jit_word_t)&pU%d_%d);\n\
580	jit_pushargr(JIT_R0);\n\
581	jit_finishi((jit_word_t*)CU%d_%d);\n", i, j, i, j, i, j);
582	}
583	}
584	puts("#endif");
585
586	puts("\n\
587	jit_ret();\n\
588	jit_epilog();\n\
589	\n\
590	code = jit_emit();\n\
591	\n\
592	jit_clear_state();\n\
593	\n\
594	(*code)();\n\
595	jit_destroy_state();\n\
596	\n\
597	finish_jit();\n\
598	\n\
599	return (0);\n\
600	}");
601
602	return (0);
603	}