support of ia64 added, more stats added

2 files changed, 201 insertions, 0 deletions

diff --git a/translate/grt/config/ia64.S b/translate/grt/config/ia64.S
new file mode 100644
index 000000000..cd77d497a
--- /dev/null
+++ b/translate/grt/config/ia64.S
@@ -0,0 +1,193 @@
+	.file	"ia64.S"
+	.pred.safe_across_calls p1-p5,p16-p63
+	
+	.text
+	.align 16
+	.proc grt_stack_loop
+grt_stack_loop:
+	alloc r32 = ar.pfs, 0, 1, 1, 0
+	.body
+	;;
+1:	mov r33 = r4	
+	br.call.sptk.many b0 = b1
+	;;
+	br 1b
+	.endp
+	
+	.global grt_stack_switch#
+	.proc grt_stack_switch#
+	/* r32:	struct stack_context *TO, r33:  struct stack_context *FROM.  */
+	//  Registers to be saved:
+	//  ar.rsc, ar.bsp, ar.pfs, ar.lc, ar.rnat [5]
+	//  gp, r4-r7 (+ Nat)                      [6]
+	//  f2-f5, f16-f31                         [20]
+	//  p1-p5, p16-p63                         [1] ???
+	//  b1-b5                                  [5]
+grt_stack_switch:
+	.prologue 2, 2
+	.vframe r2
+	alloc r31=ar.pfs, 2, 0, 0, 0
+	adds r12 = -160, r12
+	.body
+	;;
+	// Save ar.rsc, ar.bsp, ar.pfs
+	{
+	mov r14 = ar.rsc
+	mov r15 = ar.bsp
+	adds r22 = (5*8), r12
+	}
+	;;
+	{
+	st8 [r12] = r14      		// sp + 0  <- ar.rsc
+	st8.spill [r22] = r1, 8		// sp + 40 <- r1
+	adds r20 = 8, r12
+	}
+	;;
+	st8 [r20] = r15, 8		// sp + 8  <- ar.bsp
+	st8.spill [r22] = r4, 8		// sp + 48 <- r4
+	;;
+	mov r15 = ar.lc
+	st8 [r20] = r31, 8		// sp + 16 <- ar.pfs
+	st8.spill [r22] = r5, 8		// sp + 56 <- r5
+	;;
+	mov r14 = b0
+	st8 [r20] = r15, 8		// sp + 24 <- ar.lc
+	//  Flush dirty registers to the backing store
+	flushrs
+	;;
+	//  Set the RSE in enforced lazy mode.
+	mov ar.rsc = 0
+	;; 
+	mov r15 = ar.rnat	
+	st8.spill [r22] = r6, 8		// sp + 64 <- r6
+	;;
+	mov r16 = b1
+	st8.spill [r22] = r7, 16	// sp + 72 <- r7
+	st8 [r20] = r15, 64		// sp + 32 <- ar.rnat
+	;;
+	mov r15 = b2
+	mov r17 = ar.unat
+	st8 [r20] = r14, 8		// sp + 96 <- b0
+	;;
+	mov r14 = b3
+	st8 [r22] = r17, 24		// sp + 88 <- ar.unat
+	st8 [r20] = r16, 16		// sp + 104 <- b1
+	;;
+	st8 [r22] = r15, 16		// sp + 112 <- b2
+	st8 [r20] = r14, 16		// sp + 120 <- b3
+	mov r16 = b4
+	;;
+	st8 [r22] = r16, 16		// sp + 128 <- b4
+	//  Read new sp.
+	ld8 r21 = [r32]
+	mov r15 = b5
+	;; 
+	mov r14 = pr
+	st8 [r20] = r15			// sp + 136 <- b5
+	;;
+	st8 [r22] = r14			// sp + 144 <- pr
+	adds r20 = 8, r21
+	;;
+	invala	
+	//  Save sp.
+	st8 [r33] = r12
+	ld8 r14 = [r21], 88		// sp + 0 (ar.rsc)
+	;; 
+	ld8 r15 = [r21], -56		// sp + 88 (ar.unat)
+	ld8 r16 = [r20], 8		// sp + 8 (ar.bsp)
+	;;
+	ld8 r17 = [r21], 8		// sp + 32 (ar.rnat)
+	ld8 r18 = [r20], 8		// sp + 16 (ar.pfs)
+	mov ar.unat = r15
+	;;
+	ld8 r15 = [r20], 72		// sp + 24 (ar.lc)
+	ld8.fill r1 = [r21], 8		// sp + 40 (r1)
+	mov ar.bspstore = r16
+	;; 
+	mov ar.rnat = r17
+	mov ar.pfs = r18
+	ld8.fill r4 = [r21], 8		// sp + 48 (r4)
+	;;
+	mov ar.rsc = r14
+	mov ar.lc = r15
+	ld8 r17 = [r20], 8		// sp + 96 (b0)
+	;;
+	mov b0 = r17
+	ld8.fill r5 = [r21], 8		// sp + 56 (r5)
+	ld8 r14 = [r20], 8		// sp + 104 (b1)
+	;;
+	mov b1 = r14
+	ld8.fill r6 = [r21], 8		// sp + 64 (r6)
+	ld8 r15 = [r20], 8		// sp + 112 (b2)
+	;;
+	mov b2 = r15
+	ld8.fill r7 = [r21], 8		// sp + 72 (r7)
+	ld8 r14 = [r20], 8		// sp + 120 (b3)
+	;;
+	mov b3 = r14
+	ld8 r15 = [r20], 8		// sp + 128 (b4)
+	;;
+	mov b4 = r15
+	ld8 r14 = [r20], 8		// sp + 136 (b5)
+	;;
+	mov b5 = r14
+	ld8 r15 = [r20], 8		// sp + 144 (pr)
+	mov r12 = r21
+	;;
+	mov pr = r15, -1
+	br.ret.sptk.many b0
+	;;
+	.endp grt_stack_switch#
+	
+	.align 16
+	// r32:	 func, r33: arg
+	.global grt_stack_create#
+	.proc grt_stack_create#
+grt_stack_create:
+	.prologue 14, 34
+	.save ar.pfs, r35
+	alloc r35 = ar.pfs, 2, 4, 0, 0
+	.save rp, r34
+	mov r34 = b0
+	;; 
+	.body
+	br.call.sptk.many b0 = grt_stack_allocate#
+	;;
+	//  Compute backing store.
+	movl r14=stack_max_size
+	ld8 r22 = [r32], 8	// read ip (-> b1)
+	adds r20 = -(160 + 16), r8
+	adds r21 = -(160 + 16) + 32, r8
+	;;
+	mov r18 = 0x0f		// ar.rsc: LE, PL=3, Eager
+	ld4 r14 = [r14]		// r16: bsp
+	st8 [r21] = r0, 8	// sp + 32 (ar.rnat = 0)
+	ld8 r23 = [r32]		// read r1 from func
+	st8 [r8] = r20		// Save cur_sp
+	;;
+	st8 [r20] = r18, 8	// sp + 0 (ar.rsc)
+	st8 [r21] = r23, 64	// sp + 40 (r1 = func.r1)
+	sub r14 = r8, r14	// Backing store base
+	;;
+	adds r14 = 16, r14	// Add sizeof (stack_context)
+	st8 [r21] = r22, -8	// sp + 104 (b1 = func.ip)
+	;; 
+	movl r15 = grt_stack_loop
+	mov r16 = (0 << 7) | 1	// CFM:	sol=0, sof=1
+	st8 [r20] = r14, 8	// sp + 8 (ar.bsp)
+	;; 
+	st8 [r21] = r15, -48	// sp + 96 (b0 = grt_stack_loop)
+	st8 [r20] = r16, 8	// sp + 16 (ar.pfs)
+	;;
+	st8 [r20] = r0, 8	// sp + 24 (ar.lc)
+	st8 [r21] = r33		// sp + 48 (r4 = arg)
+	;;
+	st8 [r20] = r0, 8	// sp + 32 (ar.rnat)
+	;; 
+	
+	mov ar.pfs = r35
+	mov b0 = r34
+	br.ret.sptk.many b0
+	;;
+	.endp grt_stack_create#
+	.ident	"GCC: (GNU) 4.0.2"
diff --git a/translate/grt/config/linux.c b/translate/grt/config/linux.c
index 047cfd1b4..3159cd613 100644
--- a/translate/grt/config/linux.c
+++ b/translate/grt/config/linux.c
@@ -22,6 +22,7 @@
 #include <signal.h>
 #include <fcntl.h>
 #include <sys/ucontext.h>
+#include <stdlib.h>
 //#include <stdint.h>
 
 /* On x86, the stack growns downward.  */
@@ -262,6 +263,13 @@ grt_stack_allocate (void)
   res = (struct stack_context *)(base + sizeof (struct stack_context));
 #endif
 
+#ifdef __ia64__
+  /* Also allocate BSP.  */
+  if (mmap (base, page_size, PROT_READ | PROT_WRITE,
+	    MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, MMAP_FILEDES, 0) != base)
+    return NULL;
+#endif
+
   res->cur_sp = (void *)res;
   res->cur_length = stack_size;
   return res;