Implement closure for alpha. Use jsr instead of bsr in alpha_call. Clean up

prolog and epilog generation for alpha to be more readable. Add missing
ChangeLog entries.

diff --git a/ChangeLog b/ChangeLog
index fab1de6378d5b97c31ec00861f5dbc86e63b30c5..bda8e4fac39c47e730173ec74c066b805e35842e 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,16 @@
+2006-07-15  Thomas Cort  <linuxgeek@gmail.com>
+
+       * jit/jit-apply-alpha.c jit/jit-gen-alpha.h jit/jit-rules-alpha.h
+       jit/jit-rules-alpha.c: Implement closure for alpha. Use jsr 
+       instead of bsr in alpha_call. Clean up prolog and epilog 
+       generation for alpha to be more readable.
+
+2006-07-13  Thomas Cort  <linuxgeek@gmail.com>
+
+       * jit/jit-gen-alpha.h jit/jit-rules-alpha.c jit/jit-rules-alpha.h:
+       Added trap barrier macro alpha_trapb. Implemented 
+       _jit_gen_prolog and _jit_gen_epilog for alpha.
+
 2006-07-12  Aleksey Demakov  <ademakov@gmail.com>
 
        * jit/jit-insn.c (jit_insn_move_blocks_to_start): fix problem with
@@ -5,6 +18,15 @@
        the init_block and with disappearance of blocks after the empty
        init_block.
 
+2006-07-12  Thomas Cort  <linuxgeek@gmail.com>
+
+       * README.alpha jit/Makefile.am jit/jit-apply-alpha.c 
+       jit/jit-apply-alpha.h jit/jit-elf-defs.h jit/jit-gen-alpha.h
+       jit/jit-rules-alpha.c jit/jit-rules-alpha.h 
+       jit/jit-rules-alpha.ins /jit/jit-rules.h: Initial import of the
+       code for the alpha port.
+
+
 2006-07-06  Aleksey Demakov  <ademakov@gmail.com>
 
        * jit/jit-rules-x86.ins: fix division by power of two.

diff --git a/jit/jit-apply-alpha.c b/jit/jit-apply-alpha.c
index 0cf78229d93dbc644709be89b2f9503a3decf42d..3fa4ba1c93842fbe12821c055425e701fb8e5b17 100644 (file)
--- a/jit/jit-apply-alpha.c
+++ b/jit/jit-apply-alpha.c
@@ -27,13 +27,56 @@
 void _jit_create_closure(unsigned char *buf, void *func, void *closure, void *_type) {
        alpha_inst inst = (alpha_inst) buf;
 
-       /* NOT IMPLEMENTED YET! */
+       /* Compute and load the global pointer */
+       alpha_ldah(inst,ALPHA_GP,ALPHA_PV,0);
+       alpha_lda( inst,ALPHA_GP,ALPHA_GP,0);
+
+       /* Allocate space for a new stack frame. */
+       alpha_lda(inst,ALPHA_SP,ALPHA_SP,-(14*8));
+
+       /* Save the return address. */
+       alpha_stq(inst,ALPHA_RA,ALPHA_SP,0*8);
+
+       /* Save integer register arguments as local variables */
+       alpha_stq(inst,ALPHA_A0,ALPHA_SP,1*8);
+       alpha_stq(inst,ALPHA_A1,ALPHA_SP,2*8);
+       alpha_stq(inst,ALPHA_A2,ALPHA_SP,3*8);
+       alpha_stq(inst,ALPHA_A3,ALPHA_SP,4*8);
+       alpha_stq(inst,ALPHA_A4,ALPHA_SP,5*8);
+       alpha_stq(inst,ALPHA_A5,ALPHA_SP,6*8);
+
+       /* Save floating-point register arguments as local variables */
+       alpha_stt(inst,ALPHA_FA0,ALPHA_SP, 7*8);
+       alpha_stt(inst,ALPHA_FA1,ALPHA_SP, 8*8);
+       alpha_stt(inst,ALPHA_FA2,ALPHA_SP, 9*8);
+       alpha_stt(inst,ALPHA_FA3,ALPHA_SP,10*8);
+       alpha_stt(inst,ALPHA_FA4,ALPHA_SP,11*8);
+       alpha_stt(inst,ALPHA_FA5,ALPHA_SP,12*8);
 
-       /* Set up the local stack frame */
-       /* Create the apply argument block on the stack */
-       /* Push the arguments for calling "func" */
        /* Call the closure handling function */
+       alpha_call(inst,func);
+
+       /* Restore the return address */
+       alpha_ldq(inst,ALPHA_RA,ALPHA_SP,0*8);
+
+       /* Restore integer register arguments */
+       alpha_ldq(inst,ALPHA_A0,ALPHA_SP,1*8);
+       alpha_ldq(inst,ALPHA_A1,ALPHA_SP,2*8);
+       alpha_ldq(inst,ALPHA_A2,ALPHA_SP,3*8);
+       alpha_ldq(inst,ALPHA_A3,ALPHA_SP,4*8);
+       alpha_ldq(inst,ALPHA_A4,ALPHA_SP,5*8);
+       alpha_ldq(inst,ALPHA_A5,ALPHA_SP,6*8);
+
+       /* Restore floating-point register arguments */
+       alpha_ldt(inst,ALPHA_FA0,ALPHA_SP, 7*8);
+       alpha_ldt(inst,ALPHA_FA1,ALPHA_SP, 8*8);
+       alpha_ldt(inst,ALPHA_FA2,ALPHA_SP, 9*8);
+       alpha_ldt(inst,ALPHA_FA3,ALPHA_SP,10*8);
+       alpha_ldt(inst,ALPHA_FA4,ALPHA_SP,11*8);
+       alpha_ldt(inst,ALPHA_FA5,ALPHA_SP,12*8);
 
+       /* restore the stack pointer */
+       alpha_lda(inst,ALPHA_SP,ALPHA_SP,(8*13));
 }
 
 void *_jit_create_redirector(unsigned char *buf, void *func, void *user_data, int abi) {

diff --git a/jit/jit-gen-alpha.h b/jit/jit-gen-alpha.h
index 96dbd04b517052eb79e1870b78f74ba422ba7425..fffab31bdaf2b6888619b728ada29e88d4dd1d3a 100644 (file)
--- a/jit/jit-gen-alpha.h
+++ b/jit/jit-gen-alpha.h
@@ -687,10 +687,10 @@ do {                                                              \
  * Call a subroutine at a specific target location.
  */
 
-#define alpha_call(inst,target)                        \
-do {                                           \
-       int __call_offset = target - (inst+4);  \
-       alpha_bsr(inst,ALPHA_RA,__call_offset); \
+#define alpha_call(inst,target)                                        \
+do {                                                           \
+       alpha_li(inst,ALPHA_AT,(unsigned long)target);          \
+       alpha_jsr(inst,ALPHA_RA,ALPHA_AT,1);                    \
 } while (0)
 
 #ifdef __cplusplus

diff --git a/jit/jit-rules-alpha.c b/jit/jit-rules-alpha.c
index 63f94d1666da26ab54d4ad2d818574cb06fba135..24e48a14673a5566fe0878f31994bf6203ecddf6 100644 (file)
--- a/jit/jit-rules-alpha.c
+++ b/jit/jit-rules-alpha.c
@@ -114,31 +114,42 @@ void _jit_gen_get_elf_info(jit_elf_info_t *info) {
  */
 void *_jit_gen_prolog(jit_gencode_t gen, jit_function_t func, void *buf) {
        unsigned int prolog[JIT_PROLOG_SIZE];
-       unsigned int offset = 0;
        alpha_inst inst = prolog;
 
+       /* Compute and load the global pointer (2 instruction) */
+        alpha_ldah(inst,ALPHA_GP,ALPHA_PV,0);
+        alpha_lda( inst,ALPHA_GP,ALPHA_GP,0);
+
        /* Allocate space for a new stack frame. (1 instruction) */
-       alpha_lda(inst,ALPHA_SP,ALPHA_SP,-(64));
+       alpha_lda(inst,ALPHA_SP,ALPHA_SP,-(16*8));
 
        /* Save the return address. (1 instruction) */
-       alpha_stq(inst,ALPHA_RA,ALPHA_SP,offset); offset += 8;
+       alpha_stq(inst,ALPHA_RA,ALPHA_SP,0*8);
 
        /* Save the frame pointer. (1 instruction) */
-       alpha_stq(inst,ALPHA_FP,ALPHA_SP,offset); offset += 8;
+       alpha_stq(inst,ALPHA_FP,ALPHA_SP,1*8);
 
        /* Save the integer save registers (6 instructions) */
-       alpha_stq(inst,ALPHA_S0,ALPHA_SP,offset); offset += 8;
-       alpha_stq(inst,ALPHA_S1,ALPHA_SP,offset); offset += 8;
-       alpha_stq(inst,ALPHA_S2,ALPHA_SP,offset); offset += 8;
-       alpha_stq(inst,ALPHA_S3,ALPHA_SP,offset); offset += 8;
-       alpha_stq(inst,ALPHA_S4,ALPHA_SP,offset); offset += 8;
-       alpha_stq(inst,ALPHA_S5,ALPHA_SP,offset); offset += 8;
+       alpha_stq(inst,ALPHA_S0,ALPHA_SP,2*8);
+       alpha_stq(inst,ALPHA_S1,ALPHA_SP,3*8);
+       alpha_stq(inst,ALPHA_S2,ALPHA_SP,4*8);
+       alpha_stq(inst,ALPHA_S3,ALPHA_SP,5*8);
+       alpha_stq(inst,ALPHA_S4,ALPHA_SP,6*8);
+       alpha_stq(inst,ALPHA_S5,ALPHA_SP,7*8);
+
+       /* Save the floating point save registers (8 instructions) */
+       alpha_stt(inst,ALPHA_FS0,ALPHA_SP, 8*8);
+       alpha_stt(inst,ALPHA_FS1,ALPHA_SP, 9*8);
+       alpha_stt(inst,ALPHA_FS2,ALPHA_SP,10*8);
+       alpha_stt(inst,ALPHA_FS3,ALPHA_SP,11*8);
+       alpha_stt(inst,ALPHA_FS4,ALPHA_SP,12*8);
+       alpha_stt(inst,ALPHA_FS5,ALPHA_SP,13*8);
+       alpha_stt(inst,ALPHA_FS6,ALPHA_SP,14*8);
+       alpha_stt(inst,ALPHA_FS7,ALPHA_SP,15*8);
 
        /* Set the frame pointer (1 instruction) */
        alpha_mov(inst,ALPHA_SP,ALPHA_FP);
 
-       /* TODO: Save the floating point save registers ; requires fp support */
-
        /* Force any pending hardware exceptions to be raised. (1 instruction) */
        alpha_trapb(inst);
 
@@ -159,7 +170,6 @@ void *_jit_gen_prolog(jit_gencode_t gen, jit_function_t func, void *buf) {
 void _jit_gen_epilog(jit_gencode_t gen, jit_function_t func) {
        alpha_inst inst;
        void **fixup, **next;
-       unsigned int offset = 0;
 
        inst = (alpha_inst) gen->posn.ptr;
 
@@ -175,20 +185,31 @@ void _jit_gen_epilog(jit_gencode_t gen, jit_function_t func) {
        alpha_mov(inst,ALPHA_FP,ALPHA_SP);
 
        /* Restore the return address. (1 instruction) */
-       alpha_ldq(inst,ALPHA_RA,ALPHA_SP,offset); offset += 8;
+       alpha_ldq(inst,ALPHA_RA,ALPHA_SP,0*8);
 
        /* Restore the frame pointer. (1 instruction) */
-       alpha_ldq(inst,ALPHA_FP,ALPHA_SP,offset); offset += 8;
+       alpha_ldq(inst,ALPHA_FP,ALPHA_SP,1*8);
 
        /* Restore the integer save registers (6 instructions) */
-       alpha_ldq(inst,ALPHA_S0,ALPHA_SP,offset); offset += 8;
-       alpha_ldq(inst,ALPHA_S1,ALPHA_SP,offset); offset += 8;
-       alpha_ldq(inst,ALPHA_S2,ALPHA_SP,offset); offset += 8;
-       alpha_ldq(inst,ALPHA_S3,ALPHA_SP,offset); offset += 8;
-       alpha_ldq(inst,ALPHA_S4,ALPHA_SP,offset); offset += 8;
-       alpha_ldq(inst,ALPHA_S5,ALPHA_SP,offset); offset += 8;
-
-       /* TODO: Restore the floating point save registers ; requires fp support */
+       alpha_ldq(inst,ALPHA_S0,ALPHA_SP,2*8);
+       alpha_ldq(inst,ALPHA_S1,ALPHA_SP,3*8);
+       alpha_ldq(inst,ALPHA_S2,ALPHA_SP,4*8);
+       alpha_ldq(inst,ALPHA_S3,ALPHA_SP,5*8);
+       alpha_ldq(inst,ALPHA_S4,ALPHA_SP,6*8);
+       alpha_ldq(inst,ALPHA_S5,ALPHA_SP,7*8);
+
+       /* Restore the floating point save registers (8 instructions) */
+       alpha_ldt(inst,ALPHA_FS0,ALPHA_SP, 8*8);
+       alpha_ldt(inst,ALPHA_FS1,ALPHA_SP, 9*8);
+       alpha_ldt(inst,ALPHA_FS2,ALPHA_SP,10*8);
+       alpha_ldt(inst,ALPHA_FS3,ALPHA_SP,11*8);
+       alpha_ldt(inst,ALPHA_FS4,ALPHA_SP,12*8);
+       alpha_ldt(inst,ALPHA_FS5,ALPHA_SP,13*8);
+       alpha_ldt(inst,ALPHA_FS6,ALPHA_SP,14*8);
+       alpha_ldt(inst,ALPHA_FS7,ALPHA_SP,15*8);
+
+       /* Restore the stack pointer (1 instruction) */
+       alpha_lda(inst,ALPHA_SP,ALPHA_SP,16*8);
 
        /* Force any pending hardware exceptions to be raised. (1 instruction) */
        alpha_trapb(inst);

diff --git a/jit/jit-rules-alpha.h b/jit/jit-rules-alpha.h
index c6f79c0ea94538b175e079aacdec5d04788feccc..c196654e2e1627f0f0f5cd79b623589e69317a8a 100644 (file)
--- a/jit/jit-rules-alpha.h
+++ b/jit/jit-rules-alpha.h
@@ -153,7 +153,7 @@ extern      "C" {
  * The maximum number of bytes to allocate for the prolog.
  * This may be shortened once we know the true prolog size.
  */
-#define JIT_PROLOG_SIZE                        (13 /* instructions */ * 4 /* bytes per instruction */)
+#define JIT_PROLOG_SIZE                        (21 /* instructions */ * 4 /* bytes per instruction */)
 
 /*
  * Preferred alignment for the start of functions.