path: root/lib/fidlib/fidrf_jit.h

#error "JIT code is no longer maintained -- cmdlist is almost as fast on ix86"

//
//	JIT-compiled filter-running code.  
//
//        Copyright (c) 2002-2003 Jim Peters <http://uazu.net/>.  This
//        file is released under the GNU Lesser General Public License
//        (LGPL) version 2.1 as published by the Free Software
//        Foundation.  See the file COPYING_LIB for details, or visit
//	  <http://www.fsf.org/licenses/licenses.html>.
//
//	The aim of this version of the filter-running code is to go as
//	fast as possible (without flattening the sub-filters together)
//	by generating the necessary code at run-time.
//
//	This runs the filter exactly as specified, without convolving
//	the sub-filters together or changing their order.  The only
//	rearrangement performed is making the IIR first coefficient
//	1.0, and gathering any lone 1-coefficient FIR filters together
//	into a single initial gain adjustment.  For this reason, the
//	routine runs fastest if IIR and FIR sub-filters are grouped
//	together in IIR/FIR pairs, as these can then share common
//	working buffers.
//
//	The generated code is cached, and is reused for more than one
//	filter if possible.  This means that a bank of 1000s of
//	filters of similar types will probably all end up sharing the
//	same generated routine, which improves processor cache and
//	memory usage.
//
//	Probably the generated code could be improved, but it is not
//	too bad.  Copying the buffer values using 'rep movsl' turned
//	out to be much faster than loading and storing the floating
//	point values individually whilst working through the buffer.
//
//	The generated code was tested for speed on a Celeron-900 and
//	on a Pentium-133.  It always beats the RF_CMDLIST option.  It
//	can be slightly slower than the RF_COMBINED option, but only
//	where that option gets a big advantage from flattening the
//	sub-filters.  For pre-flattened filters, it is faster.
//
//	The generated code can be dumped out at any point in .s format
//	using fid_run_dump().  This can be assembled using 'gas' and
//	then disassembled with 'objdump -d' to see all the generated
//	code.
//
//	Things that could be improved:
//
//	- Don't keep the fir running total on the stack at all times.
//	Instead create it at the first FIR operation.  This means
//	generating about 10 new special-case macros.  This would save
//	an add for every filter stage, and some of the messing around
//	at start and end currently done to set up / clean up this
//	value on the FP stack.
//

typedef struct Routine Routine;
struct Routine {
   Routine *nxt;	// Next in list, or 0
   int ref;		// Reference count
   int hash;		// Hash of routine
   char *code;		// Routine itself
   int len;		// Length of code in bytes
};   

typedef struct Run {
   int magic;		// Magic: 0x64966325
   int n_buf;		// Length of working buffer required in doubles	
   double *coef;	// Coefficient list
   Routine *rout;	// Routine used
} Run;

typedef struct RunBuf {
   double *coef;	// Coefficient array
   int mov_cnt;		// Number of 4-byte chunks to copy from &buf[1] to &buf[0]
   double buf[0];	// Buffer itself
} RunBuf;

static unsigned long int do_hash(unsigned char *, unsigned long int, unsigned long int);
#define HASH(p,len) ((int)do_hash((unsigned char *)p, (unsigned long int)len, 0))


//	Code generation
//
//	%edx is the working buffer pointer
//	%eax is the coefficient pointer
//	%ecx is the loop counter
//	floating point stack contains working values at the top, then
//	  previous buffer value, then running iir total, then running
//	  fir total
//
//	Codes in the add() string:
//
//	  %C  4-byte long value count for loop
//	  %L  Label -- remember this address for looping back to
//	  %R  1-byte relative jump back to %L address
//	  %D  1-byte relative address of buffer value.  If zero, this adjusts the 
//		previous byte by ^=0x40 to make it a pure (%edx) form instead of 0(%edx)
//	  %D+ 1-byte relative address of buffer value as above, plus increment %edx 
//		if we are getting close to the end of the range
//	  %A  1-byte relative address of coefficient value.  If zero does same as for %D.
//	  %A+ 1-byte relative address of coefficient value, plus %eax inc 
//		if necessary
//	  %=  Insert code to update %edx and %eax to point to the given offsets
//	
//	Startup code
//
//	  pushl %ebp
//	  movl %esp,%ebp
//	  movl 8(%ebp),%edx
//	  movl (%edx),%eax
//	  movl 4(%edx),%ecx
//	  fldz
//	  fldl 12(%ebp)
//	  fldl 8(%edx)
//	  fmull (%eax)
//	  leal 8(%edx),%edi
//	  leal 16(%edx),%esi
//	  cld
//        rep movsl

#define STARTUP add("55 89E5 8B5508 8B02 8B4A04 D9EE DD450C DD4208 DC08 8D7A08 8D7210 FC F3A5")

//	Return
//
//	  fstp %st(0)	// pop
//	  fstp %st(1)
//	  leave
//	  ret

#define RETURN add("DDD8 DDD9 C9 C3")

//	Looping
//
//	  movl $100,%ecx
//	.LXX
//	  ...
//	  loop .LXX
//
//	//WAS  decl %ecx
//	//WAS  testl %ecx,%ecx
//	//WAS  jg .LXX

#define FOR(xx, nnd, nna) add("B9%C %= %L", xx, (nnd)*8, (nna)*8)
//WAS #define NEXT(nnd, nna) add("%= 49 85C9 7F%R", (nnd)*8, (nna)*8)
#define NEXT(nnd, nna) add("%= E2%R", (nnd)*8, (nna)*8)

//	Fetching/storing buffer values
//	
//	tmp= buf[n];
//	  fldl nn(%edx)
//	
//	buf[nn]= iir;
//	  fld %st(1)
//	  fstpl nn(%edx)

#define GETB(nn) add("DD42%D+", (nn)*8)
#define PUTB(nn) add("D9C1 DD5A%D+", (nn)*8)

//	FIR element with following IIR element
//	
//	fir -= 2 * tmp;
//	  fsub %st(0),%st(2)
//	  fsub %st(0),%st(2)
//	fir -= tmp;
//	  fsub %st(0),%st(2)
//	fir += tmp;
//	  fadd %st(0),%st(2)
//	fir += 2 * tmp;
//	  fadd %st(0),%st(2)
//	  fadd %st(0),%st(2)
//	fir += coef[nn] * tmp;
//	  fld %st(0)
//	  fmull nn(%eax)
//	  faddp %st(0),%st(3)

#define FIRc_M2 add("DCEA DCEA")
#define FIRc_M1 add("DCEA")
#define FIRc_P1 add("DCC2")
#define FIRc_P2 add("DCC2 DCC2")
#define FIRc(nn) add("D9C0 DC48%A+ DEC3", (nn)*8)

//	FIR element with no following IIR element
//	
//	fir -= 2 * tmp;
//	  fsub %st(0),%st(2)
//	  fsubp %st(0),%st(2)
//	fir -= tmp;
//	  fsubp %st(0),%st(2)
//	fir += 0 * tmp;
//	  fstp %st(0),%st(0)	// Really I just want to pop the top value
//	fir += tmp;
//	  faddp %st(0),%st(2)
//	fir += 2 * tmp;
//	  fadd %st(0),%st(2)
//	  faddp %st(0),%st(2)
//	fir += coef[0] * tmp;
//	  fmull nn(%eax)
//	  faddp %st(0),%st(2)

#define FIR_M2 add("DCEA DEEA")
#define FIR_M1 add("DEEA")
#define FIR_0 add("DDD8")
#define FIR_P1 add("DEC2")
#define FIR_P2 add("DCC2 DEC2")
#define FIR(nn) add("DC48%A+ DEC2", (nn)*8)

//	IIR element
//	
//	iir -= coef[nn] * tmp;
//	  fmull nn(%eax)
//	  fsubp %st(0),%st(1)

#define IIR(nn) add("DC48%A+ DEE9", (nn)*8)

//	Final FIR element of pure-FIR or mixed FIR-IIR stage
//	
//	iir= fir + coef[nn] * iir; fir= 0;
//	  fxch
//	  fmull nn(%eax)
//	  faddp %st(2)
//	  fldz
//	  fstp %st(3)
//	iir= fir + 1.0 * iir; fir= 0;
//	  fxch
//	  faddp %st(2)
//	  fldz
//	  fstp %st(3)
//	iir= fir - 1.0 * iir; fir= 0;
//	  fxch
//	  fsubp %st(2)
//	  fldz
//	  fstp %st(3)

#define FIREND(nn) add("D9C9 DC48%A+ DEC2 D9EE DDDB", (nn)*8)
#define FIREND_P1 add("D9C9 DEC2 D9EE DDDB")
#define FIREND_M1 add("D9C9 DEEA D9EE DDDB")

//
//	Globals for handling routines
//

static char *r_buf;	// Buffer address
static char *r_end;	// Current end of buffer
static char *r_cp;	// Current write-position
static char *r_lab;	// Current loop-back label, or 0
static int r_loop;	// Loop count
static int r_edx;	// %edx offset relative to initial position
static int r_eax;	// %eax offset relative to initial position
static Routine *r_list;	// List of routines or 0

//
//	Add code to the current routine.  This uses global variables,
//	and so is not thread-safe.
//

static void 
add(char *fmt, ...) {
   va_list ap;
   int ch, val;
   va_start(ap, fmt);

   if (r_end - r_cp < 32) 
      error("JIT error: routine buffer exceeded");

   while ((ch= *fmt++)) {
      if (isspace(ch)) continue;
      if (isdigit(ch) || (ch >= 'A' && ch <= 'F')) {
	 val= ch >= 'A' ? ch - 'A' + 10 : ch - '0';
	 ch= *fmt++;
	 if (!isdigit(ch) && !(ch >= 'A' && ch <= 'F')) 
	    error("JIT error: Bad format for add() routine");
	 val= (val*16) + (ch >= 'A' ? ch - 'A' + 10 : ch - '0');
	 *r_cp++= val;
	 continue;
      }
      if (ch != '%') 
	 error("JIT error: add() routine bad format string");
      switch (ch= *fmt++) {
       case 'C':
	  val= va_arg(ap, int);
	  r_loop= val;
	  *r_cp++= val;
	  *r_cp++= val>>8;
	  *r_cp++= val>>16;
	  *r_cp++= val>>24;
	  break;
       case 'L':
	  if (r_lab) error("JIT error: two stacked %L formats");
	  r_lab= r_cp;
	  break;
       case 'R':
	  if (!r_lab) error("JIT error: %R without matching %L");
	  val= r_lab - (r_cp+1);
	  if (val < -128) error("JIT error: %R too far from %L");
	  *r_cp++= val;
	  r_lab= 0;
	  break;
       case 'D':
	  val= va_arg(ap, int) - r_edx;
	  if (val < -128 || val >= 128) error("JIT error: