Remove obsolete 32 bit s390 backend.

6 files changed, 1 insertions, 1881 deletions

diff --git a/Makefile.am b/Makefile.am
index 0bedf77..e7700ed 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,4 +1,4 @@
-DIST_SUBDIRS = x86 ppc sparc arm s390 s390x amd64 ia64 mips
+DIST_SUBDIRS = x86 ppc sparc arm s390x amd64 ia64 mips
 
 AM_CPPFLAGS = $(GLIB_CFLAGS) -I$(top_srcdir)
 
diff --git a/s390/.gitignore b/s390/.gitignore
deleted file mode 100644
index 6abcd22..0000000
--- a/s390/.gitignore
+++ /dev/null
@@ -1,4 +0,0 @@
-/Makefile.in
-/Makefile
-/.deps
-/.cvsignore
diff --git a/s390/ChangeLog b/s390/ChangeLog
deleted file mode 100644
index 9b41109..0000000
--- a/s390/ChangeLog
+++ /dev/null
@@ -1,19 +0,0 @@
-2007-04-12	Neale Ferguson <neale@sinenomine.net>
-	
-	* tramp.c: Add MONO_TYPE_PTR case.
-
-2005-12-13	Neale Ferguson <neale@sinenomine.net>
-
-	* s390-codegen.h: Add some new instructions (conditional jumps)
-
-2004-12-15	Neale Ferguson <Neale.Ferguson@SoftwareAG-usa.com>
-
-	* s390-codegen.h: Add some new instructions (CS, CDS)
-
-2004-11-15	Neale Ferguson <Neale.Ferguson@SoftwareAG-usa.com>
-
-	* s390-codegen.h: Minor macro modifications
-
-2004-07-30	Neale Ferguson <Neale.Ferguson@SoftwareAG-usa.com>
-
-	* s390-codegen.h: reworked macros for code generation.
diff --git a/s390/Makefile.am b/s390/Makefile.am
deleted file mode 100644
index d8ebb6f..0000000
--- a/s390/Makefile.am
+++ /dev/null
@@ -1,7 +0,0 @@
-
-AM_CPPFLAGS = $(GLIB_CFLAGS) -I$(top_srcdir)
-
-noinst_LTLIBRARIES = libmonoarch-s390.la
-
-libmonoarch_s390_la_SOURCES = tramp.c s390-codegen.h
-
diff --git a/s390/s390-codegen.h b/s390/s390-codegen.h
deleted file mode 100644
index 6457357..0000000
--- a/s390/s390-codegen.h
+++ /dev/null
@@ -1,696 +0,0 @@
-/*
-   Copyright (C)  2001 Radek Doulik
-*/
-
-#ifndef S390_H
-#define S390_H
-#include <glib.h>
-#include <assert.h>
-
-#define FLOAT_REGS 	2	/* No. float registers for parms    */
-#define GENERAL_REGS 	5	/* No. general registers for parms  */
-
-#define ARG_BASE s390_r10	/* Register for addressing arguments*/
-#define STKARG \
-	(i*(sizeof(stackval)))	/* Displacement of ith argument     */
-
-#define MINV_POS  	96 	/* MonoInvocation stack offset      */
-#define STACK_POS 	(MINV_POS - sizeof (stackval) * sig->param_count)
-#define OBJ_POS   	8
-#define TYPE_OFFSET 	(G_STRUCT_OFFSET (stackval, type))
-
-#define MIN_CACHE_LINE 256
-
-/*------------------------------------------------------------------*/
-/* Sequence to add an int/long long to parameters to stack_from_data*/
-/*------------------------------------------------------------------*/
-#define ADD_ISTACK_PARM(r, i) \
-	if (reg_param < GENERAL_REGS-(r)) { \
-		s390_la (p, s390_r4, 0, STK_BASE, \
-		         local_start + (reg_param - this_flag) * sizeof(long)); \
-		reg_param += (i); \
-	} else { \
-		s390_la (p, s390_r4, 0, STK_BASE, \
-			 sz.stack_size + MINV_POS + stack_param * sizeof(long)); \
-		stack_param += (i); \
-	}
-
-/*------------------------------------------------------------------*/
-/* Sequence to add a float/double to parameters to stack_from_data  */
-/*------------------------------------------------------------------*/
-#define ADD_RSTACK_PARM(i) \
-	if (fpr_param < FLOAT_REGS) { \
-		s390_la (p, s390_r4, 0, STK_BASE, \
-		         float_pos + (fpr_param * sizeof(float) * (i))); \
-		fpr_param++; \
-	} else { \
-		stack_param += (stack_param % (i)); \
-		s390_la (p, s390_r4, 0, STK_BASE, \
-		         sz.stack_size + MINV_POS + stack_param * sizeof(float) * (i)); \
-		stack_param += (i); \
-	}
-
-/*------------------------------------------------------------------*/
-/* Sequence to add a structure ptr to parameters to stack_from_data */
-/*------------------------------------------------------------------*/
-#define ADD_TSTACK_PARM \
-	if (reg_param < GENERAL_REGS) { \
-		s390_l (p, s390_r4, 0, STK_BASE, \
-			local_start + (reg_param - this_flag) * sizeof(long)); \
-		reg_param++; \
-	} else { \
-		s390_l (p, s390_r4, 0, STK_BASE, \
-			sz.stack_size + MINV_POS + stack_param * sizeof(long)); \
-		stack_param++; \
-	}
-
-#define ADD_PSTACK_PARM(r, i) \
-	if (reg_param < GENERAL_REGS-(r)) { \
-		s390_la (p, s390_r4, 0, STK_BASE, \
-			 local_start + (reg_param - this_flag) * sizeof(long)); \
-		reg_param += (i); \
-	} else { \
-		s390_l (p, s390_r4, 0, STK_BASE, \
-			sz.stack_size + MINV_POS + stack_param * sizeof(long)); \
-		stack_param++; \
-	}
-typedef enum {
-	s390_r0 = 0,
-	s390_r1,
-	s390_r2,
-	s390_r3,
-	s390_r4,
-	s390_r5,
-	s390_r6,
-	s390_r7,
-	s390_r8,
-	s390_r9,
-	s390_r10,
-	s390_r11,
-	s390_r12,
-	s390_r13,
-	s390_r14,
-	s390_r15,
-} S390IntRegister;
-
-typedef enum {
-	s390_f0 = 0,
-	s390_f1,
-	s390_f2,
-	s390_f3,
-	s390_f4,
-	s390_f5,
-	s390_f6,
-	s390_f7,
-	s390_f8,
-	s390_f9,
-	s390_f10,
-	s390_f11,
-	s390_f12,
-	s390_f13,
-	s390_f14,
-	s390_f15,
-} S390FloatRegister;
-
-typedef enum {
-	s390_a0 = 0,
-	s390_a1,
-	s390_a2,
-	s390_a3,
-	s390_a4,
-	s390_a5,
-	s390_a6,
-	s390_a7,
-	s390_a8,
-	s390_a9,
-	s390_a10,
-	s390_a11,
-	s390_a12,
-	s390_a13,
-	s390_a14,
-	s390_a15,
-} S390AccRegister;
-
-typedef enum {
-	s390_fpc = 256,
-} S390SpecialRegister;
-
-#define s390_is_imm16(val) 		((gint)val >= (gint)-(1<<15) && \
-					 (gint)val <= (gint)((1<<15)-1))
-#define s390_is_uimm16(val) 		((gint)val >= 0 && (gint)val <= 32767)
-#define s390_is_imm12(val)		((gint)val >= (gint)-(1<<11) && \
-					 (gint)val <= (gint)((1<<11)-1))
-#define s390_is_uimm12(val)		((gint)val >= 0 && (gint)val <= 4095)
-
-#define STK_BASE			s390_r15
-#define S390_MINIMAL_STACK_SIZE		96
-#define S390_PARM_SAVE_OFFSET 		8
-#define S390_REG_SAVE_OFFSET 		24
-#define S390_RET_ADDR_OFFSET		56
-#define S390_FLOAT_SAVE_OFFSET		64
-
-#define S390_CC_ZR			8
-#define S390_CC_NE			7
-#define S390_CC_NZ			7
-#define S390_CC_LT			4
-#define S390_CC_GT			2
-#define S390_CC_GE			11
-#define S390_CC_NM			11
-#define S390_CC_LE			13
-#define S390_CC_OV			1
-#define S390_CC_NO			14
-#define S390_CC_CY			3
-#define S390_CC_NC			12
-#define S390_CC_UN			15
-
-#define s390_word(addr, value) do	 	\
-{						\
-	* (guint32 *) addr = (guint32) value;	\
-	addr += sizeof(guint32);		\
-} while (0)
-
-#define s390_float(addr, value)	do 		\
-{						\
-	* (gfloat *) addr = (gfloat) value;	\
-	addr += sizeof(gfloat);			\
-} while (0)
-
-#define s390_llong(addr, value)	do 		\
-{						\
-	* (guint64 *) addr = (guint64) value;	\
-	addr += sizeof(guint64);		\
-} while (0)
-
-#define s390_double(addr, value) do 		\
-{						\
-	* (gdouble *) addr = (gdouble) value;	\
-	addr += sizeof(gdouble);		\
-} while (0)
-
-typedef struct {
-	short 	op;
-} E_Format;
-
-typedef struct {
-	char	op;
-	int	im;
-} I_Format;
-
-typedef struct {
-	char 	op;
-	char	r1 : 4;
-	char 	r2 : 4;
-} RR_Format;
-
-typedef struct {
-	short	op;
-	char	xx;
-	char	r1 : 4;
-	char	r2 : 4;
-} RRE_Format;
-
-typedef struct {
-	short	op;
-	char	r1 : 4;
-	char	xx : 4;
-	char	r3 : 4;
-	char	r2 : 4;
-} RRF_Format_1;
-
-typedef struct {
-	short	op;
-	char	m3 : 4;
-	char	xx : 4;
-	char	r1 : 4;
-	char	r2 : 4;
-} RRF_Format_2;
-
-typedef struct {
-	short	op;
-	char	r3 : 4;
-	char	m4 : 4;
-	char	r1 : 4;
-	char	r2 : 4;
-} RRF_Format_3;
-
-typedef struct {
-	char	op;
-	char	r1 : 4;
-	char	x2 : 4;
-	char	b2 : 4;
-	short	d2 : 12;
-} RX_Format;
-
-typedef struct {
-	char 	op1;
-	char	r1 : 4;
-	char	x2 : 4;
-	char	b2 : 4;
-	int	d2 : 12;
-	char	xx;
-	char	op2;
-} RXE_Format;
-
-typedef struct {
-	char 	op1;
-	char	r3 : 4;
-	char	x2 : 4;
-	char	b2 : 4;
-	int	d2 : 12;
-	char	r1 : 4;
-	char	xx : 4;
-	char	op2;
-} RXF_Format;
-
-typedef struct __attribute__ ((packed)) {
-	char 	op1;
-	char	r1 : 4;
-	char	x2 : 4;
-	char	b2 : 4;
-	int	d2 : 20;
-	char	op2;
-} RXY_Format;
-
-typedef struct {
-	char 	op;
-	char	r1 : 4;
-	char	r3 : 4;
-	char	b2 : 4;
-	int	d2 : 12;
-} RS_Format_1;
-
-typedef struct {
-	char 	op;
-	char	r1 : 4;
-	char	m3 : 4;
-	char	b2 : 4;
-	int	d2 : 12;
-} RS_Format_2;
-
-typedef struct {
-	char 	op;
-	char	r1 : 4;
-	char	xx : 4;
-	char	b2 : 4;
-	int	d2 : 12;
-} RS_Format_3;
-
-typedef struct __attribute__ ((packed)) {
-	char 	op1;
-	char	r1 : 4;
-	char	r3 : 4;
-	char	b2 : 4;
-	int	d2 : 20;
-	char 	op2;
-} RSY_Format_1;
-
-typedef struct __attribute__ ((packed)) {
-	char 	op1;
-	char	r1 : 4;
-	char	m3 : 4;
-	char	b2 : 4;
-	int	d2 : 20;
-	char 	op2;
-} RSY_Format_2;
-
-typedef struct {
-	char 	op1;
-	char	l1 : 4;
-	char	xx : 4;
-	char	b1 : 4;
-	int 	d1 : 12;
-	char	yy;
-	char 	op2;
-} RSL_Format;
-
-typedef struct {
-	char 	op;
-	char	r1 : 4;
-	char	r3 : 4;
-	short	i2;
-} RSI_Format;
-
-typedef struct {
-	char 	op1;
-	char	r1 : 4;
-	char	op2 : 4;
-	short	i2;
-} RI_Format;
-
-typedef struct {
-	char 	op1;
-	char	r1 : 4;
-	char	r3 : 4;
-	short	i2;
-	char	xx;
-	char	op2;
-} RIE_Format;
-
-typedef struct __attribute__ ((packed)) {
-	char 	op1;
-	char	r1 : 4;
-	char	op2 : 4;
-	int	i2;
-} RIL_Format_1;
-
-typedef struct __attribute__ ((packed)) {
-	char 	op1;
-	char	m1 : 4;
-	char	op2 : 4;
-	int	i2;
-} RIL_Format_2;
-
-typedef struct {
-	char	op;
-	char	i2;
-	char	b1 : 4;
-	short	d1 : 12;
-} SI_Format;
-
-typedef struct __attribute__ ((packed)) {
-	char	op1;
-	char	i2;
-	char	b1 : 4;
-	int	d1 : 20;
-	char	op2;
-} SIY_Format;
-
-typedef struct {
-	short	op;
-	char	b2 : 4;
-	short	d2 : 12;
-} S_Format;
-
-typedef struct {
-	char	op;
-	char	ll;
-	char	b1 : 4;
-	short	d1 : 12;
-	char	b2 : 4;
-	short	d2 : 12;
-} SS_Format_1;
-
-typedef struct {
-	char	op;
-	char	l1 : 4;
-	char	l2 : 4;
-	char	b1 : 4;	
-	short	d1 : 12;
-	char	b2 : 4;
-	short	d2 : 12;
-} SS_Format_2;
-
-typedef struct {
-	char	op;
-	char	r1 : 4;
-	char	r3 : 4;
-	char	b1 : 4;	
-	short	d1 : 12;
-	char	b2 : 4;
-	short	d2 : 12;
-} SS_Format_3;	
-
-typedef struct {
-	char	op;
-	char	r1 : 4;
-	char	r3 : 4;
-	char	b2 : 4;	
-	short	d2 : 12;
-	char	b4 : 4;
-	short	d4 : 12;
-} SS_Format_4;	
-
-typedef struct __attribute__ ((packed)) {
-	short	op;
-	char	b1 : 4;
-	short	d1 : 12;
-	char	b2 : 4;
-	short	d2 : 12;
-} SSE_Format;
-
-#define s390_emit16(c, x) do 			\
-{						\
-	*((guint16 *) c) = x; 			\
-	c += sizeof(guint16);			\
-} while(0)
-
-#define s390_emit32(c, x) do 			\
-{						\
-	*((guint32 *) c) = x; 			\
-	c += sizeof(guint32);			\
-} while(0)
-
-#define S390_E(c,opc) 			s390_emit16(c,opc)
-
-#define S390_I(c,opc,imm) 		s390_emit16(c, (opc << 8 | imm))
-
-#define S390_RR(c,opc,g1,g2)		s390_emit16(c, (opc << 8 | (g1) << 4 | g2))
-
-#define S390_RRE(c,opc,g1,g2)		s390_emit32(c, (opc << 16 | (g1) << 4 | g2)) 
-
-#define S390_RRF_1(c,opc,g1,g2,g3)	s390_emit32(c, (opc << 16 | (g1) << 12 | (g3) << 4 | g2))
-
-#define S390_RRF_2(c,opc,g1,k3,g2)	s390_emit32(c, (opc << 16 | (k3) << 12 | (g1) << 4 | g2))
-
-#define S390_RRF_3(c,opc,g1,g2,k4,g3)	s390_emit32(c, (opc << 16 | (g3) << 12 | (k4) << 8 | (g1) << 4 | g2))
-
-#define S390_RX(c,opc,g1,n2,s2,p2)	s390_emit32(c, (opc << 24 | (g1) << 20 | (n2) << 16 | (s2) << 12 | ((p2) & 0xfff)))
-
-#define S390_RXE(c,opc,g1,n2,s2,p2) do  			\
-{								\
-	s390_emit16(c, ((opc & 0xff00) | (g1) << 4 | n2));	\
-	s390_emit32(c, ((s2) << 28 | (((p2) & 0xfff) << 16) | 	\
-			(opc & 0xff)));				\
-} while (0)
-
-#define S390_RXY(c,opc,g1,n2,s2,p2) do				\
-{								\
-	s390_emit16(c, ((opc & 0xff00) | (g1) << 4 | n2));	\
-	s390_emit32(c, ((s2) << 28 | (((p2) & 0xfffff) << 8) | 	\
-			(opc & 0xff)));				\
-} while (0)
-
-#define S390_RS_1(c,opc,g1,g3,s2,p2) 	s390_emit32(c, (opc << 24 | (g1) << 20 | (g3) << 16 | (s2) << 12 | ((p2) & 0xfff))) 
-
-#define S390_RS_2(c,opc,g1,k3,s2,p2)	s390_emit32(c, (opc << 24 | (g1) << 20 | (k3) << 16 | (s2) << 12 | ((p2) & 0xfff)))
-
-#define S390_RS_3(c,opc,g1,s2,p2)	s390_emit32(c, (opc << 24 | (g1) << 20 | (s2) << 12 | ((p2) & 0xfff)))
-
-#define S390_RSY_1(c,opc,g1,g3,s2,p2) do			\
-{								\
-	s390_emit16(c, ((opc & 0xff00) | (g1) << 4 | g3));	\
-	s390_emit32(c, ((s2) << 28 | (((p2) & 0xfffff) << 8) | 	\
-			(opc & 0xff)));				\
-} while (0)
-
-#define S390_RSY_2(c,opc,g1,k3,s2,p2) do			\
-{								\
-	s390_emit16(c, ((opc & 0xff00) | (g1) << 4 | k3));	\
-	s390_emit32(c, ((s2) << 28 | (((p2) & 0xfffff) << 8) | 	\
-			(opc & 0xff)));				\
-} while (0)
-
-#define S390_RSL(c,opc,ln,s1,p1) do 				\
-{								\
-	s390_emit16(c, ((opc & 0xff00) | (ln) << 4));		\
-	s390_emit32(c, ((s1) << 28 | ((s1 & 0xfff) << 16) | 	\
-			(opc & 0xff)));				\
-} while (0)
-
-#define S390_RSI(c,opc,g1,g3,m2) 	s390_emit32(c, (opc << 24 | (g1) << 20 | (g3) << 16 | (m2 & 0xffff)))
-
-#define S390_RI(c,opc,g1,m2)		s390_emit32(c, ((opc >> 4) << 24 | (g1) << 20 | (opc & 0x0f) << 16 | (m2 & 0xffff)))
-
-#define S390_RIE(c,opc,g1,g3,m2) do				\
-{								\
-	s390_emit16(c, ((opc & 0xff00) | (g1) << 4 | g3));	\
-	s390_emit32(c, ((m2) << 16 | (opc & 0xff)));		\
-} while (0)
-
-#define S390_RIL_1(c,opc,g1,m2) do					\
-{									\
-	s390_emit16(c, ((opc >> 4) << 8 | (g1) << 4 | (opc & 0xf)));	\
-	s390_emit32(c, m2);						\
-} while (0)
-
-#define S390_RIL_2(c,opc,k1,m2) do					\
-{									\
-	s390_emit16(c, ((opc >> 4) << 8 | (k1) << 4 | (opc & 0xf)));	\
-	s390_emit32(c, m2);						\
-} while (0)
-
-#define S390_SI(c,opc,s1,p1,m2)		s390_emit32(c, (opc << 24 | (m2) << 16 | (s1) << 12 | ((p1) & 0xfff)));
-
-#define S390_SIY(c,opc,s1,p1,m2) do				\
-{								\
-	s390_emit16(c, ((opc & 0xff00) | m2));			\
-	s390_emit32(c, ((s1) << 24 | (((p2) & 0xfffff) << 8) | 	\
-			(opc & 0xff)));				\
-} while (0)
-
-#define S390_S(c,opc,s2,p2)	s390_emit32(c, (opc << 16 | (s2) << 12 | ((p2) & 0xfff)))
-
-#define S390_SS_1(c,opc,ln,s1,p1,s2,p2) do			\
-{								\
-	s390_emit32(c, (opc << 24 | ((ln-1) & 0xff) << 16 |	\
-			(s1) << 12 | ((p1) & 0xfff)));		\
-	s390_emit16(c, ((s2) << 12 | ((p2) & 0xfff)));		\
-} while (0)
-
-#define S390_SS_2(c,opc,n1,n2,s1,p1,s2,p2) do			\
-{								\
-	s390_emit32(c, (opc << 24 | (n1) << 16 | (n2) << 12 |	\
-			(s1) << 12 | ((p1) & 0xfff)));		\
-	s390_emit16(c, ((s2) << 12 | ((p2) & 0xfff)));		\
-} while (0)
-
-#define S390_SS_3(c,opc,g1,g3,s1,p1,s2,p2) do			\
-{								\
-	s390_emit32(c, (opc << 24 | (g1) << 16 | (g3) << 12 |	\
-			(s1) << 12 | ((p1) & 0xfff)));		\
-	s390_emit16(c, ((s2) << 12 | ((p2) & 0xfff)));		\
-} while (0)
-
-#define S390_SS_4(c,opc,g1,g3,s2,p2,s4,p4) do			\
-{								\
-	s390_emit32(c, (opc << 24 | (g1) << 16 | (g3) << 12 |	\
-			(s2) << 12 | ((p2) & 0xfff)));		\
-	s390_emit16(c, ((s4) << 12 | ((p4) & 0xfff)));		\
-} while (0)
-
-#define S390_SSE(c,opc,s1,p1,s2,p2) do			\
-{							\
-	s390_emit16(c, opc);				\
-	s390_emit16(c, ((s1) << 12 | ((p1) & 0xfff)));	\
-	s390_emit16(c, ((s2) << 12 | ((p2) & 0xfff)));	\
-} while (0)
-
-#define s390_a(c, r, x, b, d)		S390_RX(c, 0x5a, r, x, b, d)
-#define s390_adb(c, r, x, b, d)		S390_RXE(c, 0xed1a, r, x, b, d)
-#define s390_adbr(c, r1, r2)		S390_RRE(c, 0xb31a, r1, r2)
-#define s390_aebr(c, r1, r2)		S390_RRE(c, 0xb30a, r1, r2)
-#define s390_ahi(c, r, v)		S390_RI(c, 0xa7a, r, v)
-#define s390_alc(c, r, x, b, d)		S390_RXY(c, 0xe398, r, x, b, d)
-#define s390_alcr(c, r1, r2)		S390_RRE(c, 0xb998, r1, r2)
-#define s390_al(c, r, x, b, d)		S390_RX(c, 0x5e, r, x, b, d)
-#define s390_alr(c, r1, r2)		S390_RR(c, 0x1e, r1, r2)
-#define s390_ar(c, r1, r2)		S390_RR(c, 0x1a, r1, r2)
-#define s390_basr(c, r1, r2)		S390_RR(c, 0x0d, r1, r2)
-#define s390_bctr(c, r1, r2)		S390_RR(c, 0x06, r1, r2)
-#define s390_bras(c, r, o)		S390_RI(c, 0xa75, r, o)
-#define s390_brasl(c, r, o)		S390_RIL_1(c, 0xc05, r, o)
-#define s390_brc(c, m, d)		S390_RI(c, 0xa74, m, d)
-#define s390_br(c, r)			S390_RR(c, 0x07, 0xf, r)
-#define s390_break(c)			S390_RR(c, 0, 0, 0)
-#define s390_c(c, r, x, b, d)		S390_RX(c, 0x59, r, x, b, d)
-#define s390_cdb(c, r, x, b, d)		S390_RXE(c, 0xed19, r, x, b, d)
-#define s390_cdbr(c, r1, r2)		S390_RRE(c, 0xb319, r1, r2)
-#define s390_cdfbr(c, r1, r2)		S390_RRE(c, 0xb395, r1, r2)
-#define s390_cds(c, r1, r2, b, d)	S390_RX(c, 0xbb, r1, r2, b, d)
-#define s390_cebr(c, r1, r2)		S390_RRE(c, 0xb309, r1, r2)
-#define s390_cfdbr(c, r1, m, r2)	S390_RRF_2(c, 0xb399, r1, m, r2)
-#define s390_chi(c, r, i)		S390_RI(c, 0xa7e, r, i)
-#define s390_cl(c, r, x, b, d)		S390_RX(c, 0x55, r, x, b, d)
-#define s390_clr(c, r1, r2)		S390_RR(c, 0x15, r1, r2)
-#define s390_cr(c, r1, r2)		S390_RR(c, 0x19, r1, r2)
-#define s390_cs(c, r1, r2, b, d)	S390_RX(c, 0xba, r1, r2, b, d)
-#define s390_ddbr(c, r1, r2)		S390_RRE(c, 0xb31d, r1, r2)
-#define s390_debr(c, r1, r2)		S390_RRE(c, 0xb30d, r1, r2)
-#define s390_didbr(c, r1, r2, m, r3)    S390_RRF_3(c, 0xb35b, r1, r2, m, r3)
-#define s390_dlr(c, r1, r2)		S390_RRE(c, 0xb997, r1, r2)
-#define s390_dr(c, r1, r2)		S390_RR(c, 0x1d, r1, r2)
-#define s390_ear(c, r1, r2)		S390_RRE(c, 0xb24f, r1, r2)
-#define s390_ic(c, r, x, b, d)		S390_RX(c, 0x43, r, x, b, d)
-#define s390_icm(c, r, m, b, d)		S390_RX(c, 0xbf, r, m, b, d)
-#define s390_jc(c, m, d)		s390_brc(c, m, d)
-#define s390_j(c,d)			s390_brc(c, S390_CC_UN, d)
-#define s390_jcl(c, m, d)		S390_RIL_2(c, 0xc04, m, d)
-#define s390_je(c, d)			s390_brc(c, S390_CC_EQ, d)
-#define s390_jeo(c, d)			s390_brc(c, S390_CC_ZR|S390_CC_OV, d)
-#define s390_jh(c, d)			s390_brc(c, S390_CC_GT, d)
-#define s390_jho(c, d)			s390_brc(c, S390_CC_GT|S390_CC_OV, d)
-#define s390_jl(c, d)			s390_brc(c, S390_CC_LT, d)
-#define s390_jlo(c, d)			s390_brc(c, S390_CC_LT|S390_CC_OV, d)
-#define s390_jm(c, d)			s390_brc(c, S390_CC_LT, d)
-#define s390_jne(c, d)			s390_brc(c, S390_CC_NZ, d)
-#define s390_jnh(c, d)			s390_brc(c, S390_CC_LE, d)
-#define s390_jnl(c, d)			s390_brc(c, S390_CC_GE, d)
-#define s390_jnz(c, d)			s390_brc(c, S390_CC_NZ, d)
-#define s390_jo(c, d)			s390_brc(c, S390_CC_OV, d)
-#define s390_jno(c, d)			s390_brc(c, S390_CC_NO, d)
-#define s390_jp(c, d)			s390_brc(c, S390_CC_GT, d)
-#define s390_jz(c, d)			s390_brc(c, S390_CC_ZR, d)
-#define s390_jcy(c, d)			s390_brc(c, S390_CC_CY, d)
-#define s390_jnc(c, d)			s390_brc(c, S390_CC_NC, d)
-#define s390_la(c, r, x, b, d)		S390_RX(c, 0x41, r, x, b, d)
-#define s390_lam(c, r1, r2, b, d)	S390_RS_1(c, 0x9a, r1, r2, b, d)
-#define s390_larl(c, r, o)		S390_RIL_1(c, 0xc00, r, o)
-#define s390_lcdbr(c, r1, r2)		S390_RRE(c, 0xb313, r1, r2)
-#define s390_lcr(c, r1, r2)		S390_RR(c, 0x13, r1, r2)
-#define s390_l(c, r, x, b, d)		S390_RX(c, 0x58, r, x, b, d)
-#define s390_ld(c, f, x, b, d)		S390_RX(c, 0x68, f, x, b, d)
-#define s390_ldeb(c, r, x, b, d)	S390_RXE(c, 0xed04, r, x, b, d)
-#define s390_ldebr(c, r1, r2)		S390_RRE(c, 0xb304, r1, r2)
-#define s390_ldr(c, r1, r2)		S390_RR(c, 0x28, r1, r2)
-#define s390_le(c, f, x, b, d)		S390_RX(c, 0x78, f, x, b, d)
-#define s390_ledbr(c, r1, r2)		S390_RRE(c, 0xb344, r1, r2)
-#define s390_ler(c, r1, r2)		S390_RR(c, 0x38, r1, r2)
-#define s390_lh(c, r, x, b, d)		S390_RX(c, 0x48, r, x, b, d)
-#define s390_lhi(c, r, v)		S390_RI(c, 0xa78, r, v)
-#define s390_lm(c, r1, r2, b, d)	S390_RS_1(c, 0x98, r1, r2, b, d)
-#define s390_lndbr(c, r1, r2)		S390_RRE(c, 0xb311, r1, r2)
-#define s390_lnr(c, r1, r2)		S390_RR(c, 0x11, r1, r2)
-#define s390_lpr(c, r1, r2)		S390_RR(c, 0x10, r1, r2)
-#define s390_lr(c, r1, r2)		S390_RR(c, 0x18, r1, r2)
-#define s390_ltr(c, r1, r2)		S390_RR(c, 0x12, r1, r2)
-#define s390_lzdr(c, r)    		S390_RRE(c, 0xb375, r, 0)
-#define s390_lzer(c, r)    		S390_RRE(c, 0xb374, r, 0)
-#define s390_m(c, r, x, b, d)		S390_RX(c, 0x5c, r, x, b, d)
-#define s390_mdbr(c, r1, r2)		S390_RRE(c, 0xb31c, r1, r2)
-#define s390_meebr(c, r1, r2)		S390_RRE(c, 0xb317, r1, r2)
-#define s390_mlr(c, r1, r2)		S390_RRE(c, 0xb996, r1, r2)
-#define s390_mr(c, r1, r2)		S390_RR(c, 0x1c, r1, r2)
-#define s390_ms(c, r, x, b, d)		S390_RX(c, 0x71, r, x, b, d)
-#define s390_msr(c, r1, r2)		S390_RRE(c, 0xb252, r1, r2)
-#define s390_mvc(c, l, b1, d1, b2, d2)	S390_SS_1(c, 0xd2, l, b1, d1, b2, d2)
-#define s390_mvcl(c, r1, r2)		S390_RR(c, 0x0e, r1, r2)
-#define s390_mvcle(c, r1, r3, d2, b2)	S390_RS_1(c, 0xa8, r1, r3, d2, b2)
-#define s390_n(c, r, x, b, d)		S390_RX(c, 0x54, r, x, b, d)
-#define s390_nilh(c, r, v)		S390_RI(c, 0xa56, r, v)
-#define s390_nill(c, r, v)		S390_RI(c, 0xa57, r, v)
-#define s390_nr(c, r1, r2)		S390_RR(c, 0x14, r1, r2)
-#define s390_o(c, r, x, b, d)		S390_RX(c, 0x56, r, x, b, d)
-#define s390_or(c, r1, r2)		S390_RR(c, 0x16, r1, r2)
-#define s390_s(c, r, x, b, d)		S390_RX(c, 0x5b, r, x, b, d)
-#define s390_sdb(c, r, x, b, d)		S390_RXE(c, 0xed1b, r, x, b, d)
-#define s390_sdbr(c, r1, r2)		S390_RRE(c, 0xb31b, r1, r2)
-#define s390_sebr(c, r1, r2)		S390_RRE(c, 0xb30b, r1, r2)
-#define s390_sla(c, r, b, d)		S390_RS_3(c, 0x8b, r, b, d) 
-#define s390_slb(c, r, x, b, d)		S390_RXY(c, 0xe399, r, x, b, d)
-#define s390_slbr(c, r1, r2)		S390_RRE(c, 0xb999, r1, r2)
-#define s390_sl(c, r, x, b, d)		S390_RX(c, 0x5f, r, x, b, d)
-#define s390_slda(c, r, b, d)		S390_RS_3(c, 0x8f, r, b, d) 
-#define s390_sldl(c, r, b, d)		S390_RS_3(c, 0x8d, r, b, d) 
-#define s390_sll(c, r, b, d)		S390_RS_3(c, 0x89, r, b, d) 
-#define s390_slr(c, r1, r2)		S390_RR(c, 0x1f, r1, r2)
-#define s390_sqdbr(c, r1, r2)		S390_RRE(c, 0xb315, r1, r2)
-#define s390_sqebr(c, r1, r2)		S390_RRE(c, 0xb314, r1, r2)
-#define s390_sra(c, r, b, d)		S390_RS_3(c, 0x8a, r, b, d) 
-#define s390_sr(c, r1, r2)		S390_RR(c, 0x1b, r1, r2)
-#define s390_srda(c, r, b, d)		S390_RS_3(c, 0x8e, r, b, d) 
-#define s390_srdl(c, r, b, d)		S390_RS_3(c, 0x8c, r, b, d) 
-#define s390_srl(c, r, b, d)		S390_RS_3(c, 0x88, r, b, d) 
-#define s390_stam(c, r1, r2, b, d)	S390_RS_1(c, 0x9b, r1, r2, b, d)
-#define s390_stc(c, r, x, b, d)		S390_RX(c, 0x42, r, x, b, d)
-#define s390_stcm(c, r, m, b, d)	S390_RX(c, 0xbe, r, m, b, d)
-#define s390_st(c, r, x, b, d)		S390_RX(c, 0x50, r, x, b, d)
-#define s390_std(c, f, x, b, d)		S390_RX(c, 0x60, f, x, b, d)
-#define s390_ste(c, f, x, b, d)		S390_RX(c, 0x70, f, x, b, d)
-#define s390_stfpc(c, b, d)		S390_S(c, 0xb29c, b, d)
-#define s390_sth(c, r, x, b, d)		S390_RX(c, 0x40, r, x, b, d)
-#define s390_stm(c, r1, r2, b, d)	S390_RS_1(c, 0x90, r1, r2, b, d)
-#define s390_tcdb(c, r, x, b, d)	S390_RXE(c, 0xed11, r, x, b, d)
-#define s390_tceb(c, r, x, b, d)	S390_RXE(c, 0xed10, r, x, b, d)
-#define s390_x(c, r, x, b, d)		S390_RX(c, 0x57, r, x, b, d)
-#define s390_xr(c, r1, r2)		S390_RR(c, 0x17, r1, r2)
-#endif
diff --git a/s390/tramp.c b/s390/tramp.c
deleted file mode 100644
index 475a4bf..0000000
--- a/s390/tramp.c
+++ /dev/null
@@ -1,1154 +0,0 @@
-/*------------------------------------------------------------------*/
-/* 								    */
-/* Name        - tramp.c					    */
-/* 								    */
-/* Function    - Create trampolines to invoke arbitrary functions.  */
-/* 								    */
-/* Name	       - Neale Ferguson.				    */
-/* 								    */
-/* Date        - October, 2002					    */
-/* 								    */
-/* 								    */
-/*------------------------------------------------------------------*/
-
-/*------------------------------------------------------------------*/
-/*                 D e f i n e s                                    */
-/*------------------------------------------------------------------*/
-
-#define PROLOG_INS 	24	/* Size of emitted prolog	    */
-#define CALL_INS   	4	/* Size of emitted call 	    */
-#define EPILOG_INS 	18	/* Size of emitted epilog	    */
-
-#define DEBUG(x)
-
-/*========================= End of Defines =========================*/
-
-/*------------------------------------------------------------------*/
-/*                 I n c l u d e s                                  */
-/*------------------------------------------------------------------*/
-
-#ifdef NEED_MPROTECT
-# include <sys/mman.h>
-# include <limits.h>    /* for PAGESIZE */
-# ifndef PAGESIZE
-#  define PAGESIZE 4096
-# endif
-#endif
-
-#include "config.h"
-#include <stdlib.h>
-#include <string.h>
-#include "s390-codegen.h"
-#include "mono/metadata/class.h"
-#include "mono/metadata/tabledefs.h"
-#include "mono/interpreter/interp.h"
-#include "mono/metadata/appdomain.h"
-#include "mono/metadata/marshal.h"
-
-/*========================= End of Includes ========================*/
-
-/*------------------------------------------------------------------*/
-/*                 T y p e d e f s                                  */
-/*------------------------------------------------------------------*/
-
-/*------------------------------------------------------------------*/
-/* Structure used to accummulate size of stack, code, and locals    */
-/*------------------------------------------------------------------*/
-typedef struct {
-	guint stack_size,
-	      local_size,
-	      code_size,
-	      retStruct;
-} size_data;	
-
-/*========================= End of Typedefs ========================*/
-
-/*------------------------------------------------------------------*/
-/*                                                                  */
-/* Name		- add_general                                       */
-/*                                                                  */
-/* Function	- Determine code and stack size incremements for a  */
-/* 		  parameter.                                        */
-/*                                                                  */
-/*------------------------------------------------------------------*/
-
-static void inline
-add_general (guint *gr, size_data *sz, gboolean simple)
-{
-	if (simple) {
-		if (*gr >= GENERAL_REGS) {
-			sz->stack_size += sizeof(long);
-			sz->code_size  += 12;    
-		} else {
-			sz->code_size += 8;    
-		}
-	} else {
-		if (*gr >= GENERAL_REGS - 1) {
-			sz->stack_size += 8 + (sz->stack_size % 8);
-			sz->code_size  += 10;   
-		} else {
-			sz->code_size += 8;
-		}
-		(*gr) ++;
-	}
-	(*gr) ++;
-}
-
-/*========================= End of Function ========================*/
-
-/*------------------------------------------------------------------*/
-/*                                                                  */
-/* Name		- calculate_sizes                                   */
-/*                                                                  */
-/* Function	- Determine the amount of space required for code   */
-/* 		  and stack. In addition determine starting points  */
-/*		  for stack-based parameters, and area for struct-  */
-/*		  ures being returned on the stack.		    */
-/*                                                                  */
-/*------------------------------------------------------------------*/
-
-static void inline
-calculate_sizes (MonoMethodSignature *sig, size_data *sz, 
-		 gboolean string_ctor)
-{
-	guint i, fr, gr, size;
-	guint32 simpletype, align;
-
-	fr             = 0;
-	gr             = 2;
-	sz->retStruct  = 0;
-	sz->stack_size = S390_MINIMAL_STACK_SIZE;
-	sz->code_size  = (PROLOG_INS + CALL_INS + EPILOG_INS);
-	sz->local_size = 0;
-
-	if (sig->hasthis) {
-		add_general (&gr, sz, TRUE);
-	}
-
-	/*----------------------------------------------------------*/
-	/* We determine the size of the return code/stack in case we*/
-	/* need to reserve a register to be used to address a stack */
-	/* area that the callee will use.			    */
-	/*----------------------------------------------------------*/
-
-	if (sig->ret->byref || string_ctor) {
-		sz->code_size += 8;
-	} else {
-		simpletype = sig->ret->type;
-enum_retvalue:
-		switch (simpletype) {
-		case MONO_TYPE_BOOLEAN:
-		case MONO_TYPE_I1:
-		case MONO_TYPE_U1:
-		case MONO_TYPE_I2:
-		case MONO_TYPE_U2:
-		case MONO_TYPE_CHAR:
-		case MONO_TYPE_I4:
-		case MONO_TYPE_U4:
-		case MONO_TYPE_I:
-		case MONO_TYPE_U:
-		case MONO_TYPE_CLASS:
-		case MONO_TYPE_OBJECT:
-		case MONO_TYPE_R4:
-		case MONO_TYPE_R8:
-		case MONO_TYPE_SZARRAY:
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_PTR:
-		case MONO_TYPE_STRING:
-			sz->code_size += 4;
-			break;
-		case MONO_TYPE_I8:
-			sz->code_size += 4;
-			break;
-		case MONO_TYPE_VALUETYPE:
-			if (sig->ret->data.klass->enumtype) {
-				simpletype = sig->ret->data.klass->enum_basetype->type;
-				goto enum_retvalue;
-			}
-			gr++;
-			if (sig->pinvoke)
-				size = mono_class_native_size (sig->ret->data.klass, &align);
-			else
-                        	size = mono_class_value_size (sig->ret->data.klass, &align);
-			if (align > 1)
-				sz->code_size += 10;
-			switch (size) {
-				/*----------------------------------*/
-				/* On S/390, structures of size 1,  */
-				/* 2, 4, and 8 bytes are returned   */
-				/* in (a) register(s).		    */
-				/*----------------------------------*/
-				case 1:
-				case 2:
-				case 4:
-				case 8:
-					sz->code_size  += 16;
-					sz->stack_size += 4;
-					break;
-				default:
-					sz->retStruct   = 1;
-					sz->code_size  += 32;
-			}
-                        break;
-		case MONO_TYPE_VOID:
-			break;
-		default:
-			g_error ("tramp: cannot handle as return value 0x%x", sig->ret->type);
-		}
-	}
-
-	/*----------------------------------------------------------*/
-	/* We determine the size of the parameter code and stack    */
-	/* requirements by checking the types and sizes of the      */
-	/* parameters.						    */
-	/*----------------------------------------------------------*/
-
-	for (i = 0; i < sig->param_count; ++i) {
-		if (sig->params [i]->byref) {
-			add_general (&gr, sz, TRUE);
-			continue;
-		}
-		simpletype = sig->params [i]->type;
-	enum_calc_size:
-		switch (simpletype) {
-		case MONO_TYPE_BOOLEAN:
-		case MONO_TYPE_CHAR:
-		case MONO_TYPE_I1:
-		case MONO_TYPE_U1:
-		case MONO_TYPE_I2:
-		case MONO_TYPE_U2:
-		case MONO_TYPE_I4:
-		case MONO_TYPE_U4:
-		case MONO_TYPE_I:
-		case MONO_TYPE_U:
-		case MONO_TYPE_PTR:
-		case MONO_TYPE_CLASS:
-		case MONO_TYPE_OBJECT:
-		case MONO_TYPE_STRING:
-			add_general (&gr, sz, TRUE);
-			break;
-		case MONO_TYPE_SZARRAY:
-			add_general (&gr, sz, TRUE);
-			break;
-		case MONO_TYPE_VALUETYPE:
-			if (sig->params [i]->data.klass->enumtype) {
-				simpletype = sig->params [i]->data.klass->enum_basetype->type;
-				goto enum_calc_size;
-			}
-			if (sig->pinvoke)
-				size = mono_class_native_size (sig->params [i]->data.klass, &align);
-			else
-				size = mono_class_value_size (sig->params [i]->data.klass, &align);
-			DEBUG(printf("%d typesize: %d (%d)\n",i,size,align));
-			switch (size) {
-				/*----------------------------------*/
-				/* On S/390, structures of size 1,  */
-				/* 2, 4, and 8 bytes are passed in  */
-				/* (a) register(s).		    */
-				/*----------------------------------*/
-				case 0:
-				case 1:
-				case 2:
-				case 4:
-					add_general(&gr, sz, TRUE);
-					break;
-				case 8:
-					add_general(&gr, sz, FALSE);
-					break;
-				default:
-					sz->local_size += (size + (size % align));
-					sz->code_size  += 40;
-			}
-			break;
-		case MONO_TYPE_I8:
-			add_general (&gr, sz, FALSE);
-			break;
-		case MONO_TYPE_R4:
-			if (fr < FLOAT_REGS) {
-				sz->code_size += 4;
-				fr++;
-			}
-			else {
-				sz->code_size  += 4;
-				sz->stack_size += 8;
-			}
-			break;
-		case MONO_TYPE_R8:
-			if (fr < FLOAT_REGS) {
-				sz->code_size += 4;
-				fr++;
-			} else {
-				sz->code_size  += 4;
-				sz->stack_size += 8 + (sz->stack_size % 8);
-			}
-			break;
-		default:
-			g_error ("Can't trampoline 0x%x", sig->params [i]->type);
-		}
-	}
-
-
-	/* align stack size to 8 */
-	DEBUG (printf ("      stack size: %d (%d)\n"
-		       "       code size: %d\n" 
-		       "      local size: %d\n",
-		      (sz->stack_size + 8) & ~8, sz->stack_size, 
-		      (sz->code_size),(sz->local_size + 8) & ~8));
-	sz->stack_size = (sz->stack_size + 8) & ~8;
-	sz->local_size = (sz->local_size + 8) & ~8;
-}
-
-/*========================= End of Function ========================*/
-
-/*------------------------------------------------------------------*/
-/*                                                                  */
-/* Name		- emit_prolog                                       */
-/*                                                                  */
-/* Function	- Create the instructions that implement the stand- */
-/* 		  ard function prolog according to the S/390 ABI.   */
-/*                                                                  */
-/*------------------------------------------------------------------*/
-
-static inline guint8 *
-emit_prolog (guint8 *p, MonoMethodSignature *sig, size_data *sz)
-{
-	guint stack_size;
-
-	stack_size = sz->stack_size + sz->local_size;
-
-	/* function prolog */
-	s390_stm (p, s390_r6, STK_BASE, STK_BASE, 24);
-	s390_l	 (p, s390_r7, 0, STK_BASE, MINV_POS);
-	s390_lr  (p, s390_r11, STK_BASE);
-	s390_ahi (p, STK_BASE, -stack_size);
-	s390_st	 (p, s390_r11, 0, STK_BASE, 0);
-
-	/*-----------------------------------------*/
-	/* Save:				   */
-	/* - address of "callme"                   */
-	/* - address of "retval"		   */
-	/* - address of "arguments"		   */
-	/*-----------------------------------------*/
-	s390_lr	 (p, s390_r9, s390_r2);
-	s390_lr  (p, s390_r8, s390_r3);
-	s390_lr  (p, s390_r10, s390_r5);
-
-	return p;
-}
-
-/*========================= End of Function ========================*/
-
-/*------------------------------------------------------------------*/
-/*                                                                  */
-/* Name		- emit_save_parameters                              */
-/*                                                                  */
-/* Function	- Create the instructions that load registers with  */ 
-/*		  parameters, place others on the stack according   */
-/* 		  to the S/390 ABI.				    */
-/*                                                                  */
-/*		  The resulting function takes the form:	    */
-/* 		  void func (void (*callme)(), void *retval, 	    */
-/*			     void *this_obj, stackval *arguments);  */
-/*                                                                  */
-/*------------------------------------------------------------------*/
-
-inline static guint8*
-emit_save_parameters (guint8 *p, MonoMethodSignature *sig, size_data *sz)
-{
-	guint i, fr, gr, act_strs, align, 
-	      stack_par_pos, size, local_pos;
-	guint32 simpletype;
-
-	/*----------------------------------------------------------*/
-	/* If a structure on stack is being returned, reserve r2    */ 
-	/* to point to an area where it can be passed.              */
-	/*----------------------------------------------------------*/
-	if (sz->retStruct)
-		gr    = 1;
-	else
-		gr    = 0;
-	fr            = 0;
-	act_strs      = 0;
-	stack_par_pos = S390_MINIMAL_STACK_SIZE;
-	local_pos     = sz->stack_size;
-
-	if (sig->hasthis) {
-		s390_lr (p, s390_r2 + gr, s390_r4);
-		gr++;
-	}
-
-	act_strs = 0;
-	for (i = 0; i < sig->param_count; ++i) {
-		DEBUG(printf("par: %d type: %d ref: %d\n",i,sig->params[i]->type,sig->params[i]->byref));
-		if (sig->params [i]->byref) {
-			if (gr < GENERAL_REGS) {
-				s390_l  (p, s390_r2 + gr, 0, ARG_BASE, STKARG);
-				gr ++;
-			} else {
-				s390_l  (p, s390_r0, 0, ARG_BASE, STKARG);
-				s390_st (p, s390_r0, 0, STK_BASE, stack_par_pos);
-				stack_par_pos += sizeof(long);
-			}
-			continue;
-		}
-		simpletype = sig->params [i]->type;
-	enum_calc_size:
-		switch (simpletype) {
-		case MONO_TYPE_BOOLEAN:
-		case MONO_TYPE_I1:
-		case MONO_TYPE_U1:
-		case MONO_TYPE_I2:
-		case MONO_TYPE_U2:
-		case MONO_TYPE_CHAR:
-		case MONO_TYPE_I4:
-		case MONO_TYPE_U4:
-		case MONO_TYPE_I:
-		case MONO_TYPE_U:
-		case MONO_TYPE_PTR:
-		case MONO_TYPE_CLASS:
-		case MONO_TYPE_OBJECT:
-		case MONO_TYPE_STRING:
-		case MONO_TYPE_SZARRAY:
-			if (gr < GENERAL_REGS) {
-				s390_l  (p, s390_r2 + gr, 0, ARG_BASE, STKARG);
-				gr ++;
-			} else {
-				s390_l  (p, s390_r0, 0, ARG_BASE, STKARG);
-				s390_st (p, s390_r0, 0, STK_BASE, stack_par_pos);
-			        stack_par_pos += sizeof(long);
-			}
-			break;
-		case MONO_TYPE_VALUETYPE:
-			if (sig->params [i]->data.klass->enumtype) {
-				simpletype = sig->params [i]->data.klass->enum_basetype->type;
-				goto enum_calc_size;
-			}
-			if (sig->pinvoke) 
-				size = mono_class_native_size (sig->params [i]->data.klass, &align);
-			else
-				size = mono_class_value_size (sig->params [i]->data.klass, &align);
-			DEBUG(printf("parStruct - size %d pinvoke: %d\n",size,sig->pinvoke));
-			switch (size) {
-				case 0:
-				case 1:
-				case 2:
-				case 4:
-					if (gr < GENERAL_REGS) {
-						s390_l  (p, s390_r2 + gr, 0,ARG_BASE, STKARG);
-						s390_l  (p, s390_r2 + gr, 0, s390_r2 + gr, 0);
-						gr++;
-					} else {
-						stack_par_pos += (stack_par_pos % align);
-						s390_l  (p, s390_r10, 0,ARG_BASE, STKARG);
-						s390_l  (p, s390_r10, 0, s390_r10, 0);
-						s390_st (p, s390_r10, 0, STK_BASE, stack_par_pos);
-						stack_par_pos += sizeof(long);
-					}
-					break;
-				case 8:
-					if (gr < GENERAL_REGS-1) {
-						s390_l  (p, s390_r2 + gr, 0, ARG_BASE, STKARG);
-						s390_lm (p, s390_r2 + gr, s390_r3 + gr, s390_r2 + gr, 0);
-					} else {
-						stack_par_pos += (stack_par_pos % align);
-						s390_l   (p, s390_r10, 0, ARG_BASE, STKARG);
-						s390_mvc (p, sizeof(long long), STK_BASE, stack_par_pos, s390_r10, 0);
-						stack_par_pos += sizeof(long long);
-					}
-					break;	
-				default:
-					if (size <= 256) {
-						local_pos += (local_pos % align);
-						s390_l   (p, s390_r13, 0, ARG_BASE, STKARG);
-						s390_mvc (p, size, STK_BASE, local_pos, s390_r13, 0);
-						s390_la	 (p, s390_r13, 0, STK_BASE, local_pos);
-						local_pos += size;
-					} else {
-						local_pos += (local_pos % align);
-						s390_bras (p, s390_r13, 4);
-						s390_word (p, size);
-						s390_l    (p, s390_r1, 0, s390_r13, 0);
-						s390_l    (p, s390_r0, 0, ARG_BASE, STKARG);
-						s390_lr	  (p, s390_r14, s390_r12);
-						s390_la   (p, s390_r12, 0, STK_BASE, local_pos);
-						s390_lr   (p, s390_r13, s390_r1);
-						s390_mvcl (p, s390_r12, s390_r0);
-						s390_lr	  (p, s390_r12, s390_r14);
-						s390_la	  (p, s390_r13, 0, STK_BASE, local_pos);
-						local_pos += size;
-					}
-					if (gr < GENERAL_REGS) {
-						s390_lr (p, s390_r2 + gr, s390_r13);
-						gr++;
-					} else {
-						s390_st (p, s390_r13, 0, STK_BASE, stack_par_pos);
-						stack_par_pos += sizeof(long);
-					}
-			}
-			break;
-		case MONO_TYPE_I8:
-			if (gr < GENERAL_REGS-1) {
-				s390_lm  (p, s390_r2 + gr, s390_r2 + gr + 1, ARG_BASE, STKARG); 
-				gr += 2;
-			} else {
-				*(guint32 *) p += 7;
-				*(guint32 *) p &= ~7;
-				s390_mvc (p, sizeof(long long), STK_BASE, stack_par_pos, ARG_BASE, STKARG); 
-				stack_par_pos += sizeof(long long) + (stack_par_pos % sizeof(long long));
-			}
-			break;
-		case MONO_TYPE_R4:
-			if (fr < FLOAT_REGS) {
-				s390_le  (p, s390_r0 + fr, 0, ARG_BASE, STKARG);
-				fr++;
-			} else {
-				s390_mvc  (p, sizeof(float), STK_BASE, stack_par_pos, ARG_BASE, STKARG);
-				stack_par_pos += sizeof(float);
-			}
-			break;
-		case MONO_TYPE_R8:
-			if (fr < FLOAT_REGS) {
-				s390_ld  (p, s390_r0 + fr, 0, ARG_BASE, STKARG);
-				fr++;
-			} else {
-				*(guint32 *) p += 7;
-				*(guint32 *) p &= ~7;
-				s390_mvc  (p, sizeof(double), STK_BASE, stack_par_pos, ARG_BASE, STKARG);
-				stack_par_pos += sizeof(long long) + (stack_par_pos % sizeof(long long));
-			}
-			break;
-		default:
-			g_error ("Can't trampoline 0x%x", sig->params [i]->type);
-		}
-	}
-
-	/*----------------------------------------------------------*/
-	/* If we're returning a structure but not in a register     */ 
-	/* then point the result area for the called routine        */
-	/*----------------------------------------------------------*/
-	if (sz->retStruct) {
-		s390_l  (p, s390_r2, 0, s390_r8, 0);
-	}
-
-	return p;
-}
-
-/*========================= End of Function ========================*/
-
-/*------------------------------------------------------------------*/
-/*                                                                  */
-/* Name		- alloc_code_memory				    */
-/*                                                                  */
-/* Function	- Allocate space to place the emitted code.	    */
-/*                                                                  */
-/*------------------------------------------------------------------*/
-
-static inline guint8 *
-alloc_code_memory (guint code_size)
-{
-	guint8 *p;
-
-#ifdef NEED_MPROTECT
-	p = g_malloc (code_size + PAGESIZE - 1);
-
-	/* Align to a multiple of PAGESIZE, assumed to be a power of two */
-	p = (char *)(((int) p + PAGESIZE-1) & ~(PAGESIZE-1));
-#else
-	p = g_malloc (code_size);
-#endif
-	DEBUG (printf ("           align: %p (%d)\n", p, (guint)p % 4));
-
-	return p;
-}
-
-/*========================= End of Function ========================*/
-
-/*------------------------------------------------------------------*/
-/*                                                                  */
-/* Name		- emit_call_and_store_retval			    */
-/*                                                                  */
-/* Function	- Emit code that will implement the call to the     */
-/*	          desired function, and unload the result according */
-/*		  to the S390 ABI for the type of value returned    */
-/*                                                                  */
-/*------------------------------------------------------------------*/
-
-static inline guint8 *
-emit_call_and_store_retval (guint8 *p, MonoMethodSignature *sig, 
-			    size_data *sz, gboolean string_ctor)
-{
-	guint32 simpletype;
-	guint   retSize, align;
-
-	/* call "callme" */
-	s390_basr (p, s390_r14, s390_r9); 
-
-	/* get return value */
-	if (sig->ret->byref || string_ctor) {
-		s390_st (p, s390_r2, 0, s390_r8, 0);
-	} else {
-		simpletype = sig->ret->type;
-enum_retvalue:
-		switch (simpletype) {
-		case MONO_TYPE_BOOLEAN:
-		case MONO_TYPE_I1:
-		case MONO_TYPE_U1:
-			s390_stc (p, s390_r2, 0, s390_r8, 0);
-			break;
-		case MONO_TYPE_I2:
-		case MONO_TYPE_U2:
-		case MONO_TYPE_CHAR:
-			s390_sth (p, s390_r2, 0, s390_r8, 0);
-			break;
-		case MONO_TYPE_I4:
-		case MONO_TYPE_U4:
-		case MONO_TYPE_I:
-		case MONO_TYPE_U:
-		case MONO_TYPE_CLASS:
-		case MONO_TYPE_OBJECT:
-		case MONO_TYPE_SZARRAY:
-		case MONO_TYPE_ARRAY:
-		case MONO_TYPE_STRING:
-			s390_st (p, s390_r2, 0, s390_r8, 0);
-			break;
-		case MONO_TYPE_R4:
-			s390_ste (p, s390_f0, 0, s390_r8, 0);
-			break;
-		case MONO_TYPE_R8:
-			s390_std (p, s390_f0, 0, s390_r8, 0);
-			break;
-		case MONO_TYPE_I8:
-			s390_stm (p, s390_r2, s390_r3, s390_r8, 0);
-			break;
-		case MONO_TYPE_VALUETYPE:
-			if (sig->ret->data.klass->enumtype) {
-				simpletype = sig->ret->data.klass->enum_basetype->type;
-				goto enum_retvalue;
-			}
-			if (sig->pinvoke) 
-				retSize = mono_class_native_size (sig->ret->data.klass, &align);
-			else
-				retSize = mono_class_value_size (sig->ret->data.klass, &align);
-printf("Returning %d bytes for type %d (%d)\n",retSize,simpletype,sig->pinvoke);
-			switch(retSize) {
-			case 0:
-				break;
-			case 1:
-				s390_stc (p, s390_r2, 0, s390_r8, 0);
-				break;
-			case 2:
-				s390_sth (p, s390_r2, 0, s390_r8, 0);
-				break;
-			case 4:
-				s390_st (p, s390_r2, 0, s390_r8, 0);
-				break;
-			case 8:
-				s390_stm (p, s390_r2, s390_r3, s390_r8, 0);
-				break;
-			default: ;
-				/*------------------------------------------*/
-				/* The callee has already placed the result */
-				/* in the required area			    */
-				/*------------------------------------------*/
-				break;
-			}
-			break;
-		case MONO_TYPE_VOID:
-			break;
-		default:
-			g_error ("Can't handle as return value 0x%x", 
-				 sig->ret->type);
-		}
-	}
-
-	return p;
-}
-
-/*========================= End of Function ========================*/
-
-/*------------------------------------------------------------------*/
-/*                                                                  */
-/* Name		- emit_epilog                                       */
-/*                                                                  */
-/* Function	- Create the instructions that implement the stand- */
-/* 		  ard function epilog according to the S/390 ABI.   */
-/*                                                                  */
-/*------------------------------------------------------------------*/
-
-static inline guint8 *
-emit_epilog (guint8 *p, MonoMethodSignature *sig, size_data *sz)
-{
-	/* function epilog */
-	s390_l   (p, STK_BASE, 0, STK_BASE, 0);
-	s390_l   (p, s390_r4, 0, STK_BASE, 56);
-	s390_lm  (p, s390_r6, STK_BASE, STK_BASE, 24);
-	s390_br  (p, s390_r4);
-
-	return p;
-}
-
-/*========================= End of Function ========================*/
-
-/*------------------------------------------------------------------*/
-/*                                                                  */
-/* Name		- mono_arch_create_trampoline.			    */
-/*                                                                  */
-/* Function	- Create the code that will allow a mono method to  */
-/* 		  invoke a system subroutine.			    */
-/*                                                                  */
-/*------------------------------------------------------------------*/
-
-MonoPIFunc
-mono_arch_create_trampoline (MonoMethodSignature *sig, gboolean string_ctor)
-{
-	guint8 *p, *code_buffer;
-	size_data sz;
-
-	DEBUG (printf ("\nPInvoke [start emiting]\n"));
-	calculate_sizes (sig, &sz, string_ctor);
-
-	p = code_buffer = alloc_code_memory (sz.code_size);
-	p = emit_prolog (p, sig, &sz);
-	p = emit_save_parameters (p, sig, &sz);
-	p = emit_call_and_store_retval (p, sig, &sz, string_ctor);
-	p = emit_epilog (p, sig, &sz);
-
-#ifdef NEED_MPROTECT
-	if (mprotect (code_buffer, 1024, PROT_READ | PROT_WRITE | PROT_EXEC)) {
-		g_error ("Cannot mprotect trampoline\n");
-	}
-#endif
-
-	DEBUG (printf ("emited code size: %d\n", p - code_buffer));
-
-	DEBUG (printf ("PInvoke [end emiting]\n"));
-
-	return (MonoPIFunc) code_buffer;
-}
-
-/*========================= End of Function ========================*/
-
-/*------------------------------------------------------------------*/
-/*                                                                  */
-/* Name		- mono_arch_create_method_pointer		    */
-/*                                                                  */
-/* Function	- Returns a pointer to a native function that can   */
-/* 		  be used to call the specified method. 	    */
-/*                                                                  */
-/*		  The function created will receive the arguments   */
-/*		  according to the calling convention specified in  */
-/*                in the method. 				    */
-/*		  						    */
-/*		  This function works by creating a MonoInvocation  */
-/*		  structure, filling the fields in and calling      */
-/*		  ves_exec_method() on it.			    */
-/*								    */
-/* Logic:							    */
-/* ------							    */
-/*  mono_arch_create_method_pointer (MonoMethod *method)	    */
-/*	create the unmanaged->managed wrapper		 	    */
-/*	register it with mono_jit_info_table_add()		    */
-/*								    */
-/*  What does the unmanaged->managed wrapper do?	   	    */
-/*	allocate a MonoInvocation structure (inv) on the stack	    */
-/*      allocate an array of stackval on the stack with length =    */
-/*          method->signature->param_count + 1 [call it stack_args] */
-/*	set inv->ex, inv->ex_handler, inv->parent to NULL	    */
-/*	set inv->method to method				    */
-/*	if method is an instance method, set inv->obj to the 	    */
-/*	    'this' argument (the first argument) else set to NULL   */
-/*	for each argument to the method call:			    */
-/*		stackval_from_data (sig->params[i], &stack_args[i], */
-/*				    arg, sig->pinvoke);		    */
-/*		Where:						    */
-/*		------						    */
-/*		sig 		- is method->signature		    */
-/*	        &stack_args[i]	- is the pointer to the ith element */
-/*				  in the stackval array		    */
-/*		arg		- is a pointer to the argument re-  */
-/*				  ceived by the function according  */
-/*				  to the call convention. If it     */
-/*				  gets passed in a register, save   */
-/*				  on the stack first.		    */
-/*								    */
-/*	set inv->retval to the address of the last element of       */
-/*	    stack_args [recall we allocated param_count+1 of them]  */
-/*	call ves_exec_method(inv)				    */
-/*	copy the returned value from inv->retval where the calling  */
-/* 	    convention expects to find it on return from the wrap-  */
-/*	    per [if it's a structure, use stackval_to_data]	    */
-/*                                                                  */
-/*------------------------------------------------------------------*/
-
-void *
-mono_arch_create_method_pointer (MonoMethod *method)
-{
-	MonoMethodSignature *sig;
-	MonoJitInfo *ji;
-	guint8 *p, *code_buffer;
-	guint i, align = 0, simple_type, retSize, reg_save = 0,
-		stackval_arg_pos, local_pos, float_pos,
-		local_start, reg_param = 0, stack_param,
-		this_flag, arg_pos, fpr_param, parSize;
-	guint32 simpletype;
-	size_data sz;
-	int *vtbuf, cpos, vt_cur;
-
-	sz.code_size   = 1024;
-	sz.stack_size  = 1024;
-	stack_param     = 0;
-	fpr_param       = 0;
-	arg_pos	        = 0;
-
-	sig = method->signature;
-
-	p = code_buffer = g_malloc (sz.code_size);
-
-	DEBUG (printf ("\nDelegate [start emiting] %s at 0x%08x\n", 
-		       method->name,p));
-
-	/*----------------------------------------------------------*/ 
-	/* prolog 					     	    */
-	/*----------------------------------------------------------*/ 
-	s390_stm (p, s390_r6, STK_BASE, STK_BASE, 24);
-	s390_l   (p, s390_r7, 0, STK_BASE, MINV_POS);
-	s390_lr  (p, s390_r0, STK_BASE);
-	s390_ahi (p, STK_BASE, -(sz.stack_size+MINV_POS));
-	s390_st  (p, s390_r0, 0, STK_BASE, 0);
-	s390_la	 (p, s390_r8, 0, STK_BASE, 4);
-	s390_lr  (p, s390_r10, s390_r8);
-	s390_lhi (p, s390_r9, sz.stack_size+92);
-	s390_lhi (p, s390_r11, 0);
-	s390_mvcl(p, s390_r8, s390_r10);
-
-	/*----------------------------------------------------------*/ 
-	/* Let's fill MonoInvocation - first zero some fields 	    */
-	/*----------------------------------------------------------*/ 
-	s390_lhi (p, s390_r0, 0);
-	s390_st  (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex)));
-	s390_st  (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, ex_handler)));
-	s390_st  (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, parent)));
-	s390_lhi (p, s390_r0, 1);
-	s390_st	 (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, invoke_trap)));
-
-	/*----------------------------------------------------------*/ 
-	/* set method pointer 					    */
-	/*----------------------------------------------------------*/ 
-	s390_bras (p, s390_r13, 4);
-	s390_word (p, method);
-	s390_l	  (p, s390_r0, 0, s390_r13, 0);
-	s390_st   (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, method)));
-
-	local_start = local_pos = MINV_POS + 
-		      sizeof (MonoInvocation) + (sig->param_count + 1) * sizeof (stackval);
-	this_flag   = (sig->hasthis ? 1 : 0);
-
-	/*----------------------------------------------------------*/
-	/* if we are returning a structure, checks it's length to   */
-	/* see if there's a "hidden" parameter that points to the   */
-	/* area. If necessary save this hidden parameter for later  */
-	/*----------------------------------------------------------*/
-	if (MONO_TYPE_ISSTRUCT(sig->ret)) {
-		if (sig->pinvoke) 
-			retSize = mono_class_native_size (sig->ret->data.klass, &align);
-		else
-			retSize = mono_class_value_size (sig->ret->data.klass, &align);
-		switch(retSize) {
-			case 0:
-			case 1:
-			case 2:
-			case 4:
-			case 8:
-				sz.retStruct = 0;
-				break;
-			default:
-				sz.retStruct = 1;
-				s390_lr(p, s390_r8, s390_r2);
-				reg_save = 1;
-		}
-	} else  {
-		reg_save = 0;
-	}
-
-	if (this_flag) {
-		s390_st  (p, s390_r2 + reg_save, 0, STK_BASE, 
-			  (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, obj)));
-		reg_param++;
-	} else {
-		s390_st (p, s390_r2 + reg_save, 0, STK_BASE, local_pos);
-		local_pos += sizeof(int);
-		s390_st (p, s390_r0, 0, STK_BASE, 
-			 (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, obj)));
-	}
-
-	s390_stm (p, s390_r3 + reg_param, s390_r6, STK_BASE, local_pos);
-	local_pos += 4 * sizeof(long);
-	float_pos  = local_pos;
-	s390_std (p, s390_f0, 0, STK_BASE, local_pos);
-	local_pos += sizeof(double);
-	s390_std (p, s390_f2, 0, STK_BASE, local_pos);
-	local_pos += sizeof(double);
-
-	/*----------------------------------------------------------*/ 
-	/* prepare space for valuetypes			     	    */
-	/*----------------------------------------------------------*/ 
-	vt_cur = local_pos;
-	vtbuf  = alloca (sizeof(int)*sig->param_count);
-	cpos   = 0;
-	for (i = 0; i < sig->param_count; i++) {
-		MonoType *type = sig->params [i];
-		vtbuf [i] = -1;
-		DEBUG(printf("par: %d type: %d ref: %d\n",i,type->type,type->byref));
-		if (type->type == MONO_TYPE_VALUETYPE) {
-			MonoClass *klass = type->data.klass;
-			gint size;
-
-			if (klass->enumtype)
-				continue;
-			size = mono_class_native_size (klass, &align);
-			cpos += align - 1;
-			cpos &= ~(align - 1);
-			vtbuf [i] = cpos;
-			cpos += size;
-		}
-	}
-	cpos += 3;
-	cpos &= ~3;
-
-	local_pos += cpos;
-
-	/*----------------------------------------------------------*/ 
-	/* set MonoInvocation::stack_args			    */
-	/*----------------------------------------------------------*/ 
-	stackval_arg_pos = MINV_POS + sizeof (MonoInvocation);
-	s390_la  (p, s390_r0, 0, STK_BASE, stackval_arg_pos);
-	s390_st  (p, s390_r0, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, stack_args)));
-
-	/*----------------------------------------------------------*/ 
-	/* add stackval arguments 				    */	
-	/*----------------------------------------------------------*/ 
-	for (i = 0; i < sig->param_count; ++i) {
-		if (sig->params [i]->byref) {
-			ADD_ISTACK_PARM(0, 1);
-		} else {
-			simple_type = sig->params [i]->type;
-		enum_savechk:
-			switch (simple_type) {
-			case MONO_TYPE_I8:
-				ADD_ISTACK_PARM(-1, 2);
-				break;
-			case MONO_TYPE_R4:
-				ADD_RSTACK_PARM(1);
-				break;
-			case MONO_TYPE_R8:
-				ADD_RSTACK_PARM(2);
-				break;
-			case MONO_TYPE_VALUETYPE:
-				if (sig->params [i]->data.klass->enumtype) {
-					simple_type = sig->params [i]->data.klass->enum_basetype->type;
-					goto enum_savechk;
-				}
-				if (sig->pinvoke)
-					parSize = mono_class_native_size (sig->params [i]->data.klass, &align);
-				else
-					parSize = mono_class_value_size (sig->params [i]->data.klass, &align);
-				switch(parSize) {
-				case 0:
-				case 1:
-				case 2:
-				case 4:
-					ADD_PSTACK_PARM(0, 1);
-					break;
-				case 8:
-					ADD_PSTACK_PARM(-1, 2);
-					break;
-				default:
-					ADD_TSTACK_PARM;
-				}
-				break;
-			default:
-				ADD_ISTACK_PARM(0, 1);
-			}
-		}
-				
-		if (vtbuf [i] >= 0) {
-			s390_la	 (p, s390_r3, 0, STK_BASE, vt_cur);
-			s390_st  (p, s390_r3, 0, STK_BASE, stackval_arg_pos);
-			s390_la	 (p, s390_r3, 0, STK_BASE, stackval_arg_pos);
-			vt_cur += vtbuf [i];
-		} else {
-			s390_la  (p, s390_r3, 0, STK_BASE, stackval_arg_pos);
-		}
-
-		/*--------------------------------------*/
-		/* Load the parameter registers for the */
-		/* call to stackval_from_data		*/
-		/*--------------------------------------*/
-		s390_bras (p, s390_r13, 8);
-		s390_word (p, sig->params [i]);
-		s390_word (p, sig->pinvoke);
-		s390_word (p, stackval_from_data);
-		s390_l	  (p, s390_r2, 0, s390_r13, 0);
-
-		s390_l	  (p, s390_r5, 0, s390_r13, 4);
-
-		s390_l	  (p, s390_r1, 0, s390_r13, 8);
-		s390_basr (p, s390_r14, s390_r1);
-
-		stackval_arg_pos += sizeof(stackval);
-
-		/* fixme: alignment */
-		DEBUG (printf ("arg_pos %d --> ", arg_pos));
-		if (sig->pinvoke)
-			arg_pos += mono_type_native_stack_size (sig->params [i], &align);
-		else
-			arg_pos += mono_type_stack_size (sig->params [i], &align);
-		
-		DEBUG (printf ("%d\n", stackval_arg_pos));
-	}
-
-	/*----------------------------------------------------------*/ 
-	/* Set return area pointer. 				    */
-	/*----------------------------------------------------------*/ 
-	s390_la (p, s390_r10, 0, STK_BASE, stackval_arg_pos);
-	s390_st (p, s390_r10, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, retval)));
-	if (sig->ret->type == MONO_TYPE_VALUETYPE && !sig->ret->byref) {
-		MonoClass *klass  = sig->ret->data.klass;
-		if (!klass->enumtype) {
-			s390_la (p, s390_r9, 0, s390_r10, sizeof(stackval));
-			s390_st (p, s390_r9, 0,STK_BASE, stackval_arg_pos);
-			stackval_arg_pos += sizeof(stackval);
-		}
-	}
-
-	/*----------------------------------------------------------*/ 
-	/* call ves_exec_method					    */
-	/*----------------------------------------------------------*/ 
-	s390_bras (p, s390_r13, 4);
-	s390_word (p, ves_exec_method);
-	s390_l	  (p, s390_r1, 0, s390_r13, 0);
-	s390_la	  (p, s390_r2, 0, STK_BASE, MINV_POS);
-	s390_basr (p, s390_r14, s390_r1);
-
-	/*----------------------------------------------------------*/ 
-	/* move retval from stackval to proper place (r3/r4/...)    */
-	/*----------------------------------------------------------*/ 
-	DEBUG(printf("retType: %d byRef: %d\n",sig->ret->type,sig->ret->byref));
-	if (sig->ret->byref) {
-		DEBUG (printf ("ret by ref\n"));
-		s390_st (p, s390_r2, 0, s390_r10, 0);
-	} else {
-	enum_retvalue:
-DEBUG(printf("Returns: %d\n",sig->ret->type));
-		switch (sig->ret->type) {
-		case MONO_TYPE_VOID:
-			break;
-		case MONO_TYPE_BOOLEAN:
-		case MONO_TYPE_U1:
-			s390_lhi (p, s390_r2, 0);
-			s390_ic  (p, s390_r2, 0, s390_r10, 0);
-			break;
-		case MONO_TYPE_I2:
-		case MONO_TYPE_U2:
-			s390_lh (p, s390_r2, 0,s390_r10, 0);
-			break;
-		case MONO_TYPE_I4:
-		case MONO_TYPE_U4:
-		case MONO_TYPE_I:
-		case MONO_TYPE_U:
-		case MONO_TYPE_OBJECT:
-		case MONO_TYPE_STRING:
-		case MONO_TYPE_CLASS:
-			s390_l (p, s390_r2, 0, s390_r10, 0);
-			break;
-		case MONO_TYPE_I8:
-			s390_lm (p, s390_r2, s390_r3, s390_r10, 0);
-			break;
-		case MONO_TYPE_R4:
-			s390_le (p, s390_f0, 0, s390_r10, 0);
-			break;
-		case MONO_TYPE_R8:
-			s390_ld (p, s390_f0, 0, s390_r10, 0);
-			break;
-		case MONO_TYPE_VALUETYPE:
-			if (sig->ret->data.klass->enumtype) {
-				simpletype = sig->ret->data.klass->enum_basetype->type;
-				goto enum_retvalue;
-			}
-			/*---------------------------------*/
-			/* Call stackval_to_data to return */
-			/* the structure		   */
-			/*---------------------------------*/
-			s390_bras (p, s390_r13, 8);
-			s390_word (p, sig->ret);
-			s390_word (p, sig->pinvoke);
-			s390_word (p, stackval_to_data);
-			s390_l	  (p, s390_r2, 0, s390_r13, 0);
-			s390_l 	  (p, s390_r3, 0, STK_BASE, (MINV_POS + G_STRUCT_OFFSET (MonoInvocation, retval)));
-			if (sz.retStruct) {	
-				/*------------------------------------------*/
-				/* Get stackval_to_data to set result area  */
-				/*------------------------------------------*/
-				s390_lr	(p, s390_r4, s390_r8);
-			} else {		
-				/*------------------------------------------*/
-				/* Give stackval_to_data a temp result area */
-				/*------------------------------------------*/ 
-				s390_la (p, s390_r4, 0, STK_BASE, stackval_arg_pos);
-			}
-			s390_l	  (p, s390_r5, 0,s390_r13, 4);
-			s390_l    (p, s390_r1, 0, s390_r13, 8);
-			s390_basr (p, s390_r14, s390_r1);
-			switch (retSize) {
-				case 0:
-					break;
-				case 1:
-					s390_lhi (p, s390_r2, 0);
-					s390_ic  (p, s390_r2, 0, s390_r10, 0);
-					break;
-				case 2:
-					s390_lh (p, s390_r2, 0, s390_r10, 0);
-					break;
-				case 4:
-					s390_l (p, s390_r2, 0, s390_r10, 0);
-					break;
-				case 8:
-					s390_lm (p, s390_r2, s390_r3, s390_r10, 0);
-					break;
-				default: ;
-					/*-------------------------------------------------*/
-					/* stackval_to_data has placed data in result area */
-					/*-------------------------------------------------*/
-					break;
-			}
-			break;
-		default:
-			g_error ("Type 0x%x not handled yet in thunk creation", 
-				 sig->ret->type);
-			break;
-		}
-	}
-
-	/*----------------------------------------------------------*/ 
-	/* epilog 						    */
-	/*----------------------------------------------------------*/ 
-	s390_l   (p, STK_BASE, 0, STK_BASE, 0);
-	s390_l   (p, s390_r4, 0, STK_BASE, S390_RET_ADDR_OFFSET);
-	s390_lm  (p, s390_r6, STK_BASE, STK_BASE, S390_REG_SAVE_OFFSET);
-	s390_br  (p, s390_r4);
-
-	DEBUG (printf ("emited code size: %d\n", p - code_buffer));
-
-	DEBUG (printf ("Delegate [end emiting]\n"));
-
-	ji = g_new0 (MonoJitInfo, 1);
-	ji->method = method;
-	ji->code_size = p - code_buffer;
-	ji->code_start = code_buffer;
-
-	mono_jit_info_table_add (mono_get_root_domain (), ji);
-
-	return ji->code_start;
-}
-
-/*========================= End of Function ========================*/