asdf

2 files changed, 108 insertions, 30 deletions

diff --git a/Makefile b/Makefile
index 215ac9e..6092fc1 100644
--- a/Makefile
+++ b/Makefile
@@ -18,7 +18,7 @@ COMMON_HEADERS =	\
 	crc32.h		\
 	stack-man.c
 
-all: genrender blitter testsuite regscope
+all: genrender blitter testsuite iterjit
 
 genrender: $(COMMON) main.c
 	$(CC) $(CFLAGS) -o genrender $(COMMON_SOURCES) main.c simple-reg.c $(LDFLAGS)
diff --git a/iterjit.c b/iterjit.c
index 76bd147..369ad1f 100644
--- a/iterjit.c
+++ b/iterjit.c
@@ -5,7 +5,7 @@
 #include <string.h>
 #include "simplex86.h"
 #include "stack-man.h"
-#include "reggroups.h"
+#include "regscope.h"
 #include "crc32.h"
 
 typedef struct
@@ -201,6 +201,52 @@ struct jit_t
     reg_alloc_t xmm_allocator;
 };
 
+/*
+ * The structure of a composite loop:
+ *
+ *         [prologue]
+ *   outer:
+ *         [pre-line]
+ *
+ *   inner_1:
+ *         [mask.load_pixels]
+ *         [mask.advance_pixels]
+ *
+ *         [src.load_pixels]
+ *         [src.advance_pixels]
+ *
+ *         [dest.load_pixels]
+ *         
+ *         [combine]
+ *
+ *         [dest.store_pixels]
+ *         [dest.advance_pixels]
+ *         jcc inner1
+ *
+ *   ...
+ *
+ *   inner_n:
+ *         [src.load_pixels]
+ *         [src.advance_pixels]
+ *
+ *         [dest.load_pixels]
+ *         
+ *         [combine]
+ *
+ *         [dest.store_pixels]
+ *         [dest.advance_pixels]
+ *         jcc inner_n
+ *
+ *         [post-line]
+ *
+ *         jcc outer
+ *
+ * The methods that can be called more than once per line need to have
+ * "first" and "last" arguments so that they can allocate and free as
+ * required. It's not good enough to do this in pre-line and post-line
+ * because that will potentially lead to too much spilling/restoring.
+ */
+
 struct jit_src_iter_t
 {
     void (* begin) (jit_src_iter_t *src, jit_t *jit, reg_t info);
@@ -210,9 +256,9 @@ struct jit_src_iter_t
     void (* end_line) (jit_src_iter_t *src, jit_t *jit);
     void (* end) (jit_src_iter_t *src, jit_t *jit);
 
-    reg_t line;
-    reg_t stride;
-    reg_t s;
+    reg_t line;	int *line_save;
+    reg_t stride; int *stride_save;
+    reg_t s; int *s_save;
 };
 
 struct jit_combiner_t
@@ -273,8 +319,8 @@ jit_new (void)
     
     stack_manager_init (&jit->stack_man);
 
-    reg_alloc_init (&jit->xmm_allocator, &jit->stack_man, &xmm_pool);
-    reg_alloc_init (&jit->gp_allocator, &jit->stack_man, &gp64_pool);
+    reg_alloc_init (&jit->xmm_allocator, jit->fragment, &jit->stack_man, &xmm_pool);
+    reg_alloc_init (&jit->gp_allocator, jit->fragment, &jit->stack_man, &gp64_pool);
 
     return jit;
 }
@@ -295,7 +341,7 @@ reg_t jit_alloc_xmm (jit_t *jit);
 
 reg_t jit_preserve_gp (jit_t *jit, reg_t reg)
 {
-    return reg_alloc_preserve (&jit->gp_allocator, reg);
+    return reg_alloc_alloc_preserve (&jit->gp_allocator, reg);
 }
 
 void jit_free_gp (jit_t *jit, reg_t reg)
@@ -303,8 +349,6 @@ void jit_free_gp (jit_t *jit, reg_t reg)
     reg_alloc_free (&jit->gp_allocator, reg);
 }
 
-void jit_reload_gp (jit_t *jit, reg_t reg);
-void jit_reload_xmm (jit_t *jit, reg_t reg);
 void jit_free_gp (jit_t *jit, reg_t reg);
 void jit_free_xmm (jit_t *jit, reg_t reg);
 
@@ -342,20 +386,33 @@ src_a8r8g8b8_begin (jit_src_iter_t *src,
     jit_free_gp (jit, info);
     jit_free_gp (jit, image);
     jit_free_gp (jit, tmp);
+
+    jit_save_gp (jit,
+		 src->line, &src->line_save,
+		 src->stride, &src->stride_save,
+		 0);
 }
 
 static void
 src_a8r8g8b8_begin_line (jit_src_iter_t *src, jit_t *jit)
 {
-    jit_switch_group (jit, "src");
     src->s = jit_alloc_gp (jit);
 
-    jit_reload_gp (jit, src->line);
-    jit_reload_gp (jit, src->stride);
+    jit_restore_gp (jit,
+		    src->line, src->line_save,
+		    src->stride, src->stride_save,
+		    0);
+
     BEGIN_ASM (jit->fragment)
 	I_mov, src->s, src->line,
 	I_add, src->line, src->stride,
     END_ASM ();
+
+    jit_save_gp (jit,
+		 src->line, src->line_save,
+		 src->stride, src->stride_save,
+		 src->s, src->s_save,
+		 0);
 }
 
 static reg_t
@@ -364,8 +421,6 @@ src_a8r8g8b8_load_pixels (jit_src_iter_t *src, jit_t *jit, int n_pixels)
     instruction_t move;
     reg_t r;
 
-    jit_switch_group (jit, "src");
-    
     r = jit_alloc_xmm (jit);
 
     switch (n_pixels)
@@ -383,10 +438,18 @@ src_a8r8g8b8_load_pixels (jit_src_iter_t *src, jit_t *jit, int n_pixels)
 	break;
     }
 
+    jit_restore_gp (jit,
+		    src->s, src->s_save,
+		    0);
+
     BEGIN_ASM (jit->fragment)
 	move, r, PTR (src->s),
     END_ASM ();
 
+    jit_save_gp (jit,
+		 src->s, src->s_save,
+		 0);
+
     jit_free_xmm (jit, r);
 
     return r;
@@ -397,18 +460,33 @@ src_a8r8g8b8_advance_pixels (jit_src_iter_t *src, jit_t *jit, int n_pixels)
 {
     int n_bytes = n_pixels * 4;
 
-    jit_switch_group (jit, "src");
-    jit_reload_gp (jit, src->s);
+    jit_reload_gp (jit,
+		   src->s, src->s_save,
+		   0);
     
     BEGIN_ASM (jit->fragment)
 	I_add, src->s, IMM (n_bytes),
     END_ASM ();
+
+    jit_save_gp (jit,
+		 src->s, src->s_save,
+		 0);
 }
 
 static void
 src_a8r8g8b8_end_line (jit_src_iter_t *src, jit_t *jit)
 {
     jit_switch_group (jit, "src");
+    /* FIXME: This may result in a dead load from memory.
+     * We may need a "restore_and_throw_away" call that 
+     * doesn't emit the load.
+     * Though, then we don't need the save either ...
+     */
+    jit_restore_gp (jit,
+		    src->s, src->s_save,
+		    src->line, src->line_save,
+		    src->stride, src->stride_save,
+		    0);
     jit_free_gp (jit, src->s);
 }
 
@@ -773,9 +851,9 @@ combiner_create_over (void)
 
 void
 generate_kernel (jit_t *jit,
-		 jit_src_iter_t *src_iter,
-		 jit_src_iter_t *mask_iter,
-		 jit_dest_iter_t *dest_iter,
+		 jit_src_iter_t *src,
+		 jit_src_iter_t *mask,
+		 jit_dest_iter_t *dest,
 		 jit_combiner_t *combiner)
 {
     reg_t h, composite_info;
@@ -810,18 +888,18 @@ generate_kernel (jit_t *jit,
     jit_free_gp (jit, composite_info);
 
     /* begin */
-    src_iter->begin (src_iter, jit, composite_info);
-    if (mask_iter)
-	mask_iter->begin (mask_iter, jit, composite_info);
-    dest_iter->begin (dest_iter, jit, composite_info);
+    src->begin (src, jit, composite_info);
+    if (mask)
+	mask->begin (mask, jit, composite_info);
+    dest->begin (dest, jit, composite_info);
 
     /* loop */
     BEGIN_ASM (jit->fragment)
 	DEFINE_LABEL ("vertical_loop"),
     END_ASM ();
 
-    dest_iter->process_line (
-	dest_iter, jit, src_iter, mask_iter, combiner);
+    dest->process_line (
+	dest, jit, src, mask, combiner);
 
     jit_switch_group (jit, "outer");
     jit_reload_gp (jit, h);
@@ -833,10 +911,10 @@ generate_kernel (jit_t *jit,
     jit_free_gp (jit, h);
     
     /* end */
-    dest_iter->end (dest_iter, jit);
-    if (mask_iter)
-	mask_iter->end (mask_iter, jit);
-    src_iter->end (src_iter, jit);
+    dest->end (dest, jit);
+    if (mask)
+	mask->end (mask, jit);
+    src->end (src, jit);
 
     jit_switch_group (jit, "outer");