Add basic Itanium port infrastructure.

* include/lightning/jit_ia64.h, lib/jit_ia64-cpu.c,
	lib/jit_ia64-fpu.c, lib/jit_ia64.c: New files implementing
	the basic infrastructure of an Itanium port. The code
	compiles and can generate jit for basic hello world like
	functions.

	* check/lightning.c, configure.ac, include/lightning.h,
	include/lightning/Makefile.am, include/lightning/jit_private.h,
	lib/Makefile.am, lib/lightning.c: Update for the Itanium
	port.

	* lib/jit_mips-cpu.c, lib/jit_mips.c: Correct typo and
	make the jit_carry register local to the jit_state_t.
	This matches code reviewed in the Itanium port, that
	should use the same base logic to handle carry/borrow.

ChangeLog

@@ -1,3 +1,21 @@
+2013-04-25 Paulo Andrade <pcpa@gnu.org>
+
+	* include/lightning/jit_ia64.h, lib/jit_ia64-cpu.c,
+	lib/jit_ia64-fpu.c, lib/jit_ia64.c: New files implementing
+	the basic infrastructure of an Itanium port. The code
+	compiles and can generate jit for basic hello world like
+	functions.
+
+	* check/lightning.c, configure.ac, include/lightning.h,
+	include/lightning/Makefile.am, include/lightning/jit_private.h,
+	lib/Makefile.am, lib/lightning.c: Update for the Itanium
+	port.
+
+	* lib/jit_mips-cpu.c, lib/jit_mips.c: Correct typo and
+	make the jit_carry register local to the jit_state_t.
+	This matches code reviewed in the Itanium port, that
+	should use the same base logic to handle carry/borrow.
+
 2013-04-10 Paulo Andrade <pcpa@gnu.org>
 
 	* include/lightning/jit_private.h, lib/jit_arm.c,

check/lightning.c

@@ -522,6 +522,9 @@ static void rehash(hash_t *hash);
 /*
  * Initialization
  */
+#if __ia64__
+extern int missing_count;
+#endif
 static jit_state_t	 *_jit;
 static int		  flag_verbose;
 static int		  flag_disasm;
@@ -3566,6 +3569,10 @@ execute(int argc, char *argv[])
     }
 
     function = jit_emit();
+#if __ia64__
+    if (missing_count)
+	flag_disasm = 1;
+#endif
     if (flag_verbose > 1 || flag_disasm) {
 	jit_print();
 	fprintf(stdout, "  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");

configure.ac

@@ -73,6 +73,7 @@ case "$target_cpu" in
     *mips*)		cpu=mips	;;
     *powerpc*)		cpu=ppc		;;
     *sparc*)		cpu=sparc	;;
+    ia64)		cpu=ia64	;;
     *)					;;
 esac
 AM_CONDITIONAL(cpu_arm,    [test cpu-$cpu = cpu-arm])
@@ -80,6 +81,7 @@ AM_CONDITIONAL(cpu_mips,   [test cpu-$cpu = cpu-mips])
 AM_CONDITIONAL(cpu_ppc,    [test cpu-$cpu = cpu-ppc])
 AM_CONDITIONAL(cpu_sparc,  [test cpu-$cpu = cpu-sparc])
 AM_CONDITIONAL(cpu_x86,    [test cpu-$cpu = cpu-x86])
+AM_CONDITIONAL(cpu_ia64,   [test cpu-$cpu = cpu-ia64])
 
 # Test x87 if both, x87 and sse2 available
 ac_cv_test_x86_x87=

include/lightning.h

@@ -74,6 +74,8 @@ typedef jit_int32_t		jit_fpr_t;
 #  include <lightning/jit_ppc.h>
 #elif defined(__sparc__)
 #  include <lightning/jit_sparc.h>
+#elif defined(__ia64__)
+#  include <lightning/jit_ia64.h>
 #endif
 
 #define jit_flag_node		0x00000001 /* patch node not absolute */

include/lightning/Makefile.am

@@ -37,3 +37,7 @@ if cpu_x86
 lightning_include_HEADERS = 	\
 	jit_x86.h
 endif
+if cpu_ia64
+lightning_include_HEADERS = 	\
+	jit_ia64.h
+endif

include/lightning/jit_ia64.h

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

include/lightning/jit_private.h

@@ -73,6 +73,10 @@
 #  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
 #endif
 
 #define jit_size(vector)	(sizeof(vector) / sizeof((vector)[0]))
@@ -121,20 +125,62 @@
 #define jit_cc_a2_flt		0x00200000	/* arg2 is immediate float */
 #define jit_cc_a2_dbl		0x00400000	/* arg2 is immediate double */
 
-#define jit_regset_com(u, v)		(*(u) = ~*(v))
-#define jit_regset_and(u, v, w)		(*(u) = *(v) & *(w))
-#define jit_regset_ior(u, v, w)		(*(u) = *(v) | *(w))
-#define jit_regset_xor(u, v, w)		(*(u) = *(v) ^ *(w))
-#define jit_regset_set(u, v)		(*(u) = *(v))
-#define jit_regset_set_mask(u, v)	(*(u) = (1LL << (v)) - 1)
-#define jit_regset_cmp_ui(u, v)		(*(u) != (v))
-#define jit_regset_set_ui(u, v)		(*(u) = (v))
-#define jit_regset_set_p(set)		(*set)
-#define jit_regset_clrbit(set, bit)	(*(set) &= ~(1LL << (bit)))
-#define jit_regset_setbit(set, bit)	(*(set) |= 1LL << (bit))
-#define jit_regset_tstbit(set, bit)	(*(set) & (1LL << (bit)))
-#define jit_regset_new(set)		(*(set) = 0)
-#define jit_regset_del(set)		(*(set) = 0)
+#if __ia64__
+extern void
+jit_regset_com(jit_regset_t*, jit_regset_t*);
+
+extern void
+jit_regset_and(jit_regset_t*, jit_regset_t*, jit_regset_t*);
+
+extern void
+jit_regset_ior(jit_regset_t*, jit_regset_t*, jit_regset_t*);
+
+extern void
+jit_regset_xor(jit_regset_t*, jit_regset_t*, jit_regset_t*);
+
+extern void
+jit_regset_set(jit_regset_t*, jit_regset_t*);
+
+extern void
+jit_regset_set_mask(jit_regset_t*, jit_int32_t);
+
+extern jit_bool_t
+jit_regset_cmp_ui(jit_regset_t*, jit_word_t);
+
+extern void
+jit_regset_set_ui(jit_regset_t*, jit_word_t);
+
+extern jit_bool_t
+jit_regset_set_p(jit_regset_t*);
+
+extern void
+jit_regset_clrbit(jit_regset_t*, jit_int32_t);
+
+extern void
+jit_regset_setbit(jit_regset_t*, jit_int32_t);
+
+extern jit_bool_t
+jit_regset_tstbit(jit_regset_t*, jit_int32_t);
+#  define jit_regset_new(set)						\
+    do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
+#  define jit_regset_del(set)						\
+    do { (set)->rl = (set)->rh = (set)->fl = (set)->fh = 0; } while (0)
+#else
+#  define jit_regset_com(u, v)		(*(u) = ~*(v))
+#  define jit_regset_and(u, v, w)	(*(u) = *(v) & *(w))
+#  define jit_regset_ior(u, v, w)	(*(u) = *(v) | *(w))
+#  define jit_regset_xor(u, v, w)	(*(u) = *(v) ^ *(w))
+#  define jit_regset_set(u, v)		(*(u) = *(v))
+#  define jit_regset_set_mask(u, v)	(*(u) = (1LL << (v)) - 1)
+#  define jit_regset_cmp_ui(u, v)	(*(u) != (v))
+#  define jit_regset_set_ui(u, v)	(*(u) = (v))
+#  define jit_regset_set_p(set)		(*set)
+#  define jit_regset_clrbit(set, bit)	(*(set) &= ~(1LL << (bit)))
+#  define jit_regset_setbit(set, bit)	(*(set) |= 1LL << (bit))
+#  define jit_regset_tstbit(set, bit)	(*(set) & (1LL << (bit)))
+#  define jit_regset_new(set)		(*(set) = 0)
+#  define jit_regset_del(set)		(*(set) = 0)
+#endif
 extern unsigned long
 jit_regset_scan1(jit_regset_t*, jit_int32_t);
 
@@ -255,12 +301,30 @@ struct jit_function {
 
 /* data used only during jit generation */
 struct jit_compiler {
+#if __ia64__
+    struct {
+	jit_uint64_t	  i : 41;
+	jit_uint64_t	  t :  4;
+    } inst[3];
+    jit_regset_t	  gprs;		/* changed gprs since last stop */
+    jit_regset_t	  fprs;		/* changed fprs since last stop */
+    jit_int32_t		  ioff;		/* offset in inst vector */
+    jit_int32_t		  rout;		/* first output register */
+    jit_int32_t		  breg;		/* base register for prolog/epilog */
+#endif
+#if __mips__ || __ia64__
+    jit_int32_t		  carry;
+#define jit_carry	  _jitc->carry
+#endif
     jit_node_t		 *head;
     jit_node_t		 *tail;
     jit_uint32_t	  done	: 1;	/* emit state finished */
     jit_uint32_t	  emit	: 1;	/* emit state entered */
     jit_uint32_t	  again	: 1;	/* start over emiting function */
     jit_uint32_t	  prepare : 1;	/* inside prepare/finish* block */
+#if DEBUG
+    jit_uint32_t	  getreg : 1;
+#endif
     jit_int32_t		  reglen;	/* number of registers */
     jit_regset_t	  regarg;	/* cannot allocate */
     jit_regset_t	  regsav;	/* automatic spill only once */
@@ -307,7 +371,6 @@ struct jit_compiler {
     struct {
 	jit_node_t	 *head;		/* first note node */
 	jit_node_t	 *tail;		/* linked list insertion */
-
 	/* fields to store temporary state information */
 	jit_word_t	  size;
 	jit_node_t	 *name;
@@ -338,7 +401,7 @@ struct jit_compiler {
 	jit_int32_t	  values[1024];	/* pending constants */
 	jit_word_t	  patches[2048];
     } consts;
-#elif __powerpc64__
+#elif __powerpc64__ || __ia64__
     /* Keep track of prolog addresses, just for the sake of making
      * jit that starts with a jump to a "main" label work like other
      * backends. */
@@ -488,5 +551,8 @@ extern jit_bool_t _jit_remap(jit_state_t*);
  */
 extern jit_register_t	 _rvs[];
 extern const char	*jit_progname;
+#if __ia64__
+extern int missing_count;
+#endif
 
 #endif /* _jit_private_h */

lib/Makefile.am

@@ -28,6 +28,9 @@ EXTRA_DIST =			\
 	jit_arm-cpu.c		\
 	jit_arm-swf.c		\
 	jit_arm-vfp.c		\
+	jit_ia64.c		\
+	jit_ia64-cpu.c		\
+	jit_ia64-fpu.c		\
 	jit_mips.c		\
 	jit_mips-cpu.c		\
 	jit_mips-fpu.c		\

lib/jit_mips-cpu.c

@@ -2578,7 +2578,7 @@ _bxsubr(jit_state_t *_jit, jit_word_t i0, jit_int32_t r0, jit_int32_t r1)
     SUBU(rn(t1), r0, r1);		/* t1 = r0 - r1 */
     SLT(rn(t2), rn(t1), r0);		/* t2 = t1 < r0 */
     SLT(rn(t1), r0, rn(t1));		/* t1 = r0 < t1 */
-    MOVZ(rn(t1), rn(t2), rn(t0));	/* if (r0 == 0) t1 = t2 */
+    MOVZ(rn(t1), rn(t2), rn(t0));	/* if (t0 == 0) t1 = t2 */
     w = _jit->pc.w;
     BEQ(rn(t1), _ZERO_REGNO, ((i0 - w) >> 2) - 1);
     /* delay slot */

lib/jit_mips.c

@@ -90,14 +90,6 @@ jit_register_t		_rvs[] = {
     { _NOREG,				"<none>" },
 };
 
-/* Could also:
- *	o reserve a register for carry	(overkill)
- *	o use MTLO/MFLO			(performance hit)
- * So, keep a register allocated after setting carry, and implicitly
- * deallocate it if it can no longer be tracked
- */
-static jit_int32_t	jit_carry;
-
 /*
  * Implementation
  */
@@ -110,6 +102,12 @@ void
 _jit_init(jit_state_t *_jit)
 {
     _jitc->reglen = jit_size(_rvs) - 1;
+/* Could also:
+ *	o reserve a register for carry	(overkill)
+ *	o use MTLO/MFLO			(performance hit)
+ * So, keep a register allocated after setting carry, and implicitly
+ * deallocate it if it can no longer be tracked
+ */
     jit_carry = _NOREG;
 }
 

lib/lightning.c

@@ -224,7 +224,15 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec)
 			    jit_allocai(sizeof(jit_word_t));
 			_jitc->again = 1;
 		    }
+#if DEBUG
+		    /* emit_stxi must not need temporary registers */
+		    assert(!_jitc->getreg);
+		    _jitc->getreg = 1;
+#endif
 		    emit_stxi(_jitc->function->regoff[regno], JIT_FP, regno);
+#if DEBUG
+		    _jitc->getreg = 0;
+#endif
 		}
 		else {
 		    if (!_jitc->function->regoff[regno]) {
@@ -232,7 +240,15 @@ _jit_get_reg(jit_state_t *_jit, jit_int32_t regspec)
 			    jit_allocai(sizeof(jit_float64_t));
 			_jitc->again = 1;
 		    }
+#if DEBUG
+		    /* emit_stxi must not need temporary registers */
+		    assert(!_jitc->getreg);
+		    _jitc->getreg = 1;
+#endif
 		    emit_stxi_d(_jitc->function->regoff[regno], JIT_FP, regno);
+#if DEBUG
+		    _jitc->getreg = 0;
+#endif
 		}
 		jit_regset_setbit(&_jitc->regsav, regno);
 	    regarg:
@@ -277,10 +293,19 @@ _jit_unget_reg(jit_state_t *_jit, jit_int32_t regno)
     regno = jit_regno(regno);
     if (jit_regset_tstbit(&_jitc->regsav, regno)) {
 	if (_jitc->emit) {
+#if DEBUG
+	    /* emit_ldxi must not need a temporary register */
+	    assert(!_jitc->getreg);
+	    _jitc->getreg = 1;
+#endif
 	    if (jit_class(_rvs[regno].spec) & jit_class_gpr)
 		emit_ldxi(regno, JIT_FP, _jitc->function->regoff[regno]);
 	    else
 		emit_ldxi_d(regno, JIT_FP, _jitc->function->regoff[regno]);
+#if DEBUG
+	    /* emit_ldxi must not need a temporary register */
+	    _jitc->getreg = 0;
+#endif
 	}
 	else
 	    jit_load(regno);
@@ -290,6 +315,153 @@ _jit_unget_reg(jit_state_t *_jit, jit_int32_t regno)
     jit_regset_clrbit(&_jitc->regarg, regno);
 }
 
+#if __ia64__
+void
+jit_regset_com(jit_regset_t *u, jit_regset_t *v)
+{
+    u->rl = ~v->rl;		u->rh = ~v->rh;
+    u->fl = ~v->fl;		u->fh = ~v->fh;
+}
+
+void
+jit_regset_and(jit_regset_t *u, jit_regset_t *v, jit_regset_t *w)
+{
+    u->rl = v->rl & w->rl;	u->rh = v->rh & w->rh;
+    u->fl = v->fl & w->fl;	u->fh = v->fh & w->fh;
+}
+
+void
+jit_regset_ior(jit_regset_t *u, jit_regset_t *v, jit_regset_t *w)
+{
+    u->rl = v->rl | w->rl;	u->rh = v->rh | w->rh;
+    u->fl = v->fl | w->fl;	u->fh = v->fh | w->fh;
+}
+
+void
+jit_regset_xor(jit_regset_t *u, jit_regset_t *v, jit_regset_t *w)
+{
+    u->rl = v->rl ^ w->rl;	u->rh = v->rh ^ w->rh;
+    u->fl = v->fl ^ w->fl;	u->fh = v->fh ^ w->fh;
+}
+
+void
+jit_regset_set(jit_regset_t *u, jit_regset_t *v)
+{
+    u->rl = v->rl;		u->rh = v->rh;
+    u->fl = v->fl;		u->fh = v->fh;
+}
+
+void
+jit_regset_set_mask(jit_regset_t *u, jit_int32_t v)
+{
+    jit_bool_t		w = !!(v & (v - 1));
+
+    assert(v >= 0 && v <= 256);
+    if (v == 0)
+	u->rl = u->rh = u->fl = u->fh = -1LL;
+    else if (v <= 64) {
+	u->rl = w ? (1LL << v) - 1 : -1LL;
+	u->rh = u->fl = u->fh = 0;
+    }
+    else if (v <= 128) {
+	u->rl = -1LL;
+	u->rh = w ? (1LL << (v - 64)) - 1 : -1LL;
+	u->fl = u->fh = 0;
+    }
+    else if (v <= 192) {
+	u->rl = u->rh = -1LL;
+	u->fl = w ? (1LL << (v - 128)) - 1 : -1LL;
+	u->fh = 0;
+    }
+    else {
+	u->rl = u->rh = u->fl = -1LL;
+	u->fh = w ? (1LL << (v - 128)) - 1 : -1LL;
+    }
+}
+
+jit_bool_t
+jit_regset_cmp_ui(jit_regset_t *u, jit_word_t v)
+{
+    return !((u->rl == v && u->rh == 0 && u->fl == 0 && u->fh == 0));
+}
+
+void
+jit_regset_set_ui(jit_regset_t *u, jit_word_t v)
+{
+    u->rl = v;
+    u->rh = u->fl = u->fh = 0;
+}
+
+jit_bool_t
+jit_regset_set_p(jit_regset_t *u)
+{
+    return (u->rl || u->rh || u->fl || u->fh);
+}
+
+void
+jit_regset_clrbit(jit_regset_t *set, jit_int32_t bit)
+{
+    assert(bit >= 0 && bit <= 255);
+    if (bit < 64)
+	set->rl &= ~(1LL << bit);
+    else if (bit < 128)
+	set->rh &= ~(1LL << (bit - 64));
+    else if (bit < 192)
+	set->fl &= ~(1LL << (bit - 128));
+    else
+	set->fh &= ~(1LL << (bit - 192));
+}
+
+void
+jit_regset_setbit(jit_regset_t *set, jit_int32_t bit)
+{
+    assert(bit >= 0 && bit <= 255);
+    if (bit < 64)
+	set->rl |= 1LL << bit;
+    else if (bit < 128)
+	set->rh |= 1LL << (bit - 64);
+    else if (bit < 192)
+	set->fl |= 1LL << (bit - 128);
+    else
+	set->fh |= 1LL << (bit - 192);
+}
+
+jit_bool_t
+jit_regset_tstbit(jit_regset_t *set, jit_int32_t bit)
+{
+    assert(bit >= 0 && bit <= 255);
+    if (bit < 64)
+	return (!!(set->rl & (1LL << bit)));
+    else if (bit < 128)
+	return (!!(set->rh & (1LL << (bit - 64))));
+    else if (bit < 192)
+	return (!!(set->fl & (1LL << (bit - 128))));
+    return (!!(set->fh & (1LL << (bit - 192))));
+}
+
+unsigned long
+jit_regset_scan1(jit_regset_t *set, jit_int32_t offset)
+{
+    assert(offset >= 0 && offset <= 255);
+    for (; offset < 64; offset++) {
+	if (set->rl & (1LL << offset))
+	    return (offset);
+    }
+    for (; offset < 128; offset++) {
+	if (set->rh & (1LL << (offset - 64)))
+	    return (offset);
+    }
+    for (; offset < 192; offset++) {
+	if (set->fl & (1LL << (offset - 128)))
+	    return (offset);
+    }
+    for (; offset < 256; offset++) {
+	if (set->fh & (1LL << (offset - 192)))
+	    return (offset);
+    }
+    return (ULONG_MAX);
+}
+#else
 unsigned long
 jit_regset_scan1(jit_regset_t *set, jit_int32_t offset)
 {
@@ -300,6 +472,7 @@ jit_regset_scan1(jit_regset_t *set, jit_int32_t offset)
     }
     return (ULONG_MAX);
 }
+#endif
 
 void
 _jit_save(jit_state_t *_jit, jit_int32_t reg)
@@ -661,10 +834,15 @@ _jit_clear_state(jit_state_t *_jit)
     jit_free((jit_pointer_t *)&_jitc->data_info.ptr);
 #endif
 
-#if __powerpc64__
+#if __powerpc64__ || __ia64__
     jit_free((jit_pointer_t *)&_jitc->prolog.ptr);
 #endif
 
+#if __ia64__
+    jit_regset_del(&_jitc->gprs);
+    jit_regset_del(&_jitc->fprs);
+#endif
+
     jit_free((jit_pointer_t *)&_jitc);
 }
 
@@ -2689,4 +2867,6 @@ _patch_register(jit_state_t *_jit, jit_node_t *node, jit_node_t *link,
 #  include "jit_ppc.c"
 #elif defined(__sparc__)
 #  include "jit_sparc.c"
+#elif defined(__ia64__)
+#  include "jit_ia64.c"
 #endif