rbdc 0.9.0 → 1.0.0

data/dyncall/dyncallback/dyncall_callback_mips.c

@@ -6,7 +6,7 @@
  Description: Callback - Implementation Header for MIPS
  License:
 
-   Copyright (c) 2013-2015 Daniel Adler <dadler@uni-goettingen.de>,
+   Copyright (c) 2013-2018 Daniel Adler <dadler@uni-goettingen.de>,
                            Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
@@ -25,31 +25,49 @@
 
 
 #include "dyncall_callback.h"
-#include "dyncall_callback_mips.h"
+#include "dyncall_alloc_wx.h"
+#include "dyncall_thunk.h"
+
+/* Callback symbol. */
+extern void dcCallbackThunkEntry();
+
+/* might want to make use of __packed__ or so @@@ */
+struct DCCallback              /*       mips32      |       mips64      */
+{                              /* ------------------+------------------ */
+  DCThunk            thunk;    /* offset  0 size 20 | offset  0 size 56 */
+  DCCallbackHandler* handler;  /* offset 20 size  4 | offset 56 size  8 */
+  void*              userdata; /* offset 24 size  4 | offset 64 size  8 */
+};
+
 
 void dcbInitCallback(DCCallback* pcb, const char* signature, DCCallbackHandler* handler, void* userdata)
 {
-  const char* ptr;
-  char ch;
-
   pcb->handler  = handler;
   pcb->userdata = userdata;
 }
 
-extern void dcCallbackThunkEntry();
 
 DCCallback* dcbNewCallback(const char* signature, DCCallbackHandler* handler, void* userdata)
 {
+  int err;
   DCCallback* pcb;
-  int err = dcAllocWX(sizeof(DCCallback), (void**)&pcb);
-  if (err != 0) return 0;
+  err = dcAllocWX(sizeof(DCCallback), (void**)&pcb);
+  if(err)
+    return NULL;
 
   dcbInitThunk(&pcb->thunk, dcCallbackThunkEntry);
   dcbInitCallback(pcb, signature, handler, userdata);
 
+  err = dcInitExecWX(pcb, sizeof(DCCallback));
+  if(err) {
+    dcFreeWX(pcb, sizeof(DCCallback));
+    return NULL;
+  }
+
   return pcb;
 }
 
+
 void dcbFreeCallback(DCCallback* pcb)
 {
   dcFreeWX(pcb, sizeof(DCCallback));
@@ -59,4 +77,3 @@ void* dcbGetUserData(DCCallback* pcb)
 {
   return pcb->userdata;
 }
-

data/dyncall/dyncallback/dyncall_callback_mips_eabi_gas.s

@@ -0,0 +1,99 @@
+/*
+
+ Package: dyncall
+ Library: dyncallback
+ File: dyncallback/dyncall_callback_mips_eabi_gas.s
+ Description: Callback Thunk - Implementation for mips32 eabi
+ License:
+
+   Copyright (c) 2016 Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+/* input:
+	$t4    -> thunk
+	$t4+20 -> cb handler
+	$t4+24 -> userdata
+*/
+
+.text
+.globl dcCallbackThunkEntry
+.ent   dcCallbackThunkEntry
+
+/* Called by thunk - thunk stores pointer to DCCallback in $12 ($t4), and */
+/* pointer to called function in $25 ($t9, required for PIC)              */
+dcCallbackThunkEntry:
+	.set    noreorder
+
+	/* Prolog. */
+	/* Frame size of 88b comes from following: */
+	/*   DCargs(fregs:32 + iregs:32 + regcounts:4 + stackptr:4) + retval:8 + ra:4 (+ pad:4) */
+	subu  $sp, 88       /* open frame */
+	sw    $ra, 84($sp)  /* save link register */
+
+	.frame $fp,88,$31   /* specify our frame: fp,size,lr; creates virt $fp */
+	                    /* code below doesn't use $fp though, as n/a with -O1 */
+	/* Init return value */
+	sw $zero, 72($sp)
+	sw $zero, 76($sp)
+
+	/* Store float and int args where our DCargs member arrays are, in local area. */
+	sw  $4,    0($sp)
+	sw  $5,    4($sp)
+	sw  $6,    8($sp)
+	sw  $7,   12($sp)
+	sw  $8,   16($sp)
+	sw  $9,   20($sp)
+	sw $10,   24($sp)
+	sw $11,   28($sp)
+	s.s $f12, 32($sp)
+	s.s $f13, 36($sp)
+	s.s $f14, 40($sp)
+	s.s $f15, 44($sp)
+	s.s $f16, 48($sp)
+	s.s $f17, 52($sp)
+	s.s $f18, 56($sp)
+	s.s $f19, 60($sp)
+
+	/* Init DCarg's reg_counts and stackptr. */
+	sw $zero, 64($sp) /* reg_count */
+	addiu $4, $sp, 88
+	sw    $4, 68($sp) /* stackptr */
+
+	/* Prepare callback handler call. */
+	move  $4, $12       /* Param 0 = DCCallback*, $12 ($t4) holds pointer to thunk */
+	move  $5, $sp       /* Param 1 = DCArgs*, pointer to where pointer to args is stored */
+	addiu $6, $sp, 72   /* Param 2 = results pointer to 8b of local data on stack */
+	lw    $7, 24($12)   /* Param 3 = userdata pointer */
+
+	lw    $25, 20($12)  /* store handler entry in $25 ($t9), required for PIC */
+	jalr  $25           /* jump */
+	nop                 /* branch delay nop */
+
+	/* Copy result in corresponding registers $2-$3 ($v0-$v1) and $f0 */
+	lw     $2, 72($sp)
+	lw     $3, 76($sp)
+	l.d   $f0, 72($sp)
+
+	/* Epilog. Tear down frame and return. */
+	lw    $ra, 84($sp)  /* restore return address */
+	addiu $sp, $sp, 88  /* close frame */
+	j     $ra           /* return */
+	nop                 /* branch delay nop */
+
+	.set    reorder
+	.end    dcCallbackThunkEntry
+	.ident  "handwritten"
+

data/dyncall/dyncallback/{dyncall_args_arm32_thumb.h → dyncall_callback_mips_gas.S}

@@ -2,12 +2,11 @@
 
  Package: dyncall
  Library: dyncallback
- File: dyncallback/dyncall_args_arm32_thumb.h
- Description: Callback's Arguments VM - Header for ARM32 (THUMB mode)
+ File: dyncallback/dyncall_callback_mips_gas.S
+ Description: auto-select (via C preprocessor) mips abi callback implementation
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>,
-                           Tassilo Philipp <tphilipp@potion-studios.com>
+   Copyright (c) 2016-2018 Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
    purpose with or without fee is hereby granted, provided that the above
@@ -24,10 +23,16 @@
 */
 
 
-#ifndef DYNCALLBACK_ARGS_ARM32_THUMB_H
-#define DYNCALLBACK_ARGS_ARM32_THUMB_H
 
-#include "dyncall_args_arm32_arm.h"	/* Uses same code as ARM mode. */
-
-#endif /* DYNCALLBACK_ARGS_ARM32_THUMB_H */
+#if defined(DC__ABI_MIPS_EABI)
+#  include "dyncall_callback_mips_eabi_gas.s"
+#elif defined(DC__ABI_MIPS_O32)
+#  include "dyncall_callback_mips_o32_gas.s"
+#elif defined(DC__ABI_MIPS_N64)
+#  include "dyncall_callback_mips_n64_gas.s"
+#elif defined(DC__ABI_MIPS_N32)
+#  include "dyncall_callback_mips_n32_gas.s"
+#else
+#  error Unknown MIPS ABI.
+#endif
 

data/dyncall/dyncallback/{dyncall_callback_arm32_thumb.c → dyncall_callback_mips_n32_gas.s}

@@ -2,12 +2,11 @@
 
  Package: dyncall
  Library: dyncallback
- File: dyncallback/dyncall_callback_arm32_thumb.c
- Description: Callback - Implementation for ARM32 (THUMB mode)
+ File: dyncallback/dyncall_callback_mips_n32_gas.s
+ Description: Callback Thunk - Implementation for mips64 n32
  License:
 
-   Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>,
-                           Tassilo Philipp <tphilipp@potion-studios.com>
+   Copyright (c) 2016 Tassilo Philipp <tphilipp@potion-studios.com>
 
    Permission to use, copy, modify, and distribute this software for any
    purpose with or without fee is hereby granted, provided that the above
@@ -23,8 +22,14 @@
 
 */
 
+	.section .mdebug.abiN32
+	.previous
+	.abicalls
+	.text
+	.align  2
+	.globl dcCallbackThunkEntry
+	.ent   dcCallbackThunkEntry
+dcCallbackThunkEntry:
 
-
-#include "dyncall_callback_arm32_thumb.h"
-#include "dyncall_callback_arm32_arm.c" /* Uses same code as ARM mode. */
+	.end dcCallbackThunkEntry
 

data/dyncall/dyncallback/dyncall_callback_mips_n64_gas.s

@@ -0,0 +1,98 @@
+/*
+
+ Package: dyncall
+ Library: dyncallback
+ File: dyncallback/dyncall_callback_mips_n64_gas.s
+ Description: Callback Thunk - Implementation for mips64 n64
+ License:
+
+   Copyright (c) 2016 Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+	/* input:
+		$t8    -> thunk
+		$t8+56 -> cb handler
+		$t8+64 -> userdata
+	*/
+
+	.section .mdebug.abi64
+	.previous
+	.abicalls
+	.text
+	.align  2
+	.globl dcCallbackThunkEntry
+	.ent   dcCallbackThunkEntry
+dcCallbackThunkEntry:
+	.set    noreorder
+
+	/* Prolog. */
+	/* Frame size of 160b comes from following: */
+	/*   DCargs(fregs:64 + iregs:64 + regcounts:8 + stackptr:8) + retval:8 + ra:8 */
+	daddiu $sp, $sp, -160 /* open frame */
+	sd     $ra, 152($sp)  /* save link register */
+
+	.frame $fp,160,$31    /* specify our frame: fp,size,lr; creates virt $fp */
+	                      /* code below doesn't use $fp though, as n/a with -O1 */
+	/* Init return value */
+	sd $zero, 144($sp)
+
+	/* Store float and int args where our DCargs member arrays are, in local area. */
+	sd  $4,     0($sp)
+	sd  $5,     8($sp)
+	sd  $6,    16($sp)
+	sd  $7,    24($sp)
+	sd  $8,    32($sp)
+	sd  $9,    40($sp)
+	sd $10,    48($sp)
+	sd $11,    56($sp)
+	s.d $f12,  64($sp)
+	s.d $f13,  72($sp)
+	s.d $f14,  80($sp)
+	s.d $f15,  88($sp)
+	s.d $f16,  96($sp)
+	s.d $f17, 104($sp)
+	s.d $f18, 112($sp)
+	s.d $f19, 120($sp)
+
+	/* Init DCarg's reg_counts and stackptr. */
+	sd $zero, 128($sp)    /* reg_count */
+	daddiu $4, $sp, 160
+	sd     $4, 136($sp)   /* stackptr */
+
+	/* Prepare callback handler call. */
+	move   $4, $24        /* Param 0 = DCCallback*, $24 ($t8) holds pointer to thunk */
+	move   $5, $sp        /* Param 1 = DCArgs*, pointer to where pointer to args is stored */
+	daddiu $6, $sp, 144   /* Param 2 = results pointer to 8b of local data on stack */
+	ld     $7, 64($24)    /* Param 3 = userdata pointer */
+
+	ld     $25, 56($24)   /* store handler entry in $25 ($t9), required for PIC */
+	jalr   $25            /* jump */
+	nop                   /* branch delay nop */
+
+	/* Copy result in corresponding registers $2-$3 ($v0-$v1) and $f0 */
+	ld     $2, 144($sp)   /* note: ignoring second possible retval in $3, here */
+	l.d   $f0, 144($sp)
+
+	/* Epilog. Tear down frame and return. */
+	ld    $ra, 152($sp)   /* restore return address */
+	daddiu $sp, $sp, 160  /* close frame */
+	j     $ra             /* return */
+	nop                   /* branch delay nop */
+
+	.set    reorder
+	.end    dcCallbackThunkEntry
+	.ident  "handwritten"
+

data/dyncall/dyncallback/dyncall_callback_mips_o32_gas.s

@@ -0,0 +1,100 @@
+/*
+
+ Package: dyncall
+ Library: dyncallback
+ File: dyncallback/dyncall_callback_mips_o32_gas.s
+ Description: Callback Thunk - Implementation mips32 o32
+ License:
+
+   Copyright (c) 2016 Tassilo Philipp <tphilipp@potion-studios.com>
+
+   Permission to use, copy, modify, and distribute this software for any
+   purpose with or without fee is hereby granted, provided that the above
+   copyright notice and this permission notice appear in all copies.
+
+   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*/
+
+	/* input:
+		$t4    -> thunk
+		$t4+20 -> cb handler
+		$t4+24 -> userdata
+	*/
+
+	.section .mdebug.abi32
+	.previous
+	.abicalls
+	.text
+	.align  2
+	.globl dcCallbackThunkEntry
+	.ent   dcCallbackThunkEntry
+	.type  dcCallbackThunkEntry, @function
+
+/* Called by thunk - thunk stores pointer to DCCallback in $12 ($t4), and */
+/* pointer to called function in $25 ($t9, required for PIC)              */
+dcCallbackThunkEntry:
+	.set    noreorder
+
+	/* Prolog. Just store the minimum, return address, spill area.     */
+	/* Frame size of 56b comes from following areas (each 8b aligned): */
+	/*   local: fpregs:16 + retval:8 + DCArgs:8 */
+	/*   save:  ra:4 (+ pad:4)                  */
+	/*   param: spill:16                        */
+	subu  $sp, 56       /* open frame */
+	sw    $ra, 20($sp)  /* save link register */
+
+	.frame $fp,56,$31   /* specify our frame: fp,size,lr; creates virt $fp */
+	                    /* code below doesn't use $fp though, as n/a with -O1 */
+	/* Init return value */
+	sw $zero, 32($sp)
+	sw $zero, 36($sp)
+
+	/* Store the arguments passed via registers somewhere for dcArg* to access. */
+	/* For $4-$7 ($a0-$a3), use dedicated spill area (caller doesn't spill, but */
+	/* provides it at end of _caller's_ frame, so $fp points right to it).      */
+	/* For $f12 and $f14 use our space (in local data), which is adjacent.      */
+	s.d $f12, 40($sp) /* -16($fp) */
+	s.d $f14, 48($sp) /*  -8($fp) */
+	sw $4,    56($sp) /*   0($fp) */
+	sw $5,    60($sp) /*   4($fp) */
+	sw $6,    64($sp) /*   8($fp) */
+	sw $7,    68($sp) /*  12($fp) */
+
+	/* Init DCArg, which contains reg_count and stackptr* to the args. Point  */
+	/* stackptr to the area where the non-float args start (which is at $fp). */
+	addiu $4, $sp, 56 /* non-$fp replacement for: */
+	sw    $4, 28($sp) /*   sw $fp, 28($sp) */
+	sw $zero, 24($sp)
+
+	/* Prepare callback handler call. */
+	move  $4, $12       /* Param 0 = DCCallback*, $12 ($t4) holds pointer to thunk */
+	addiu $5, $sp, 24   /* Param 1 = DCArgs*, pointer to where pointer to args is stored */
+	addiu $6, $sp, 32   /* Param 2 = results pointer to 8b of local data on stack */
+	lw    $7, 24($12)   /* Param 3 = userdata pointer */
+
+	lw    $25, 20($12)  /* store handler entry in $25 ($t9), required for PIC */
+	jalr  $25           /* jump */
+	nop                 /* branch delay nop */
+
+	/* Copy result in corresponding registers $2-$3 ($v0-$v1) and $f0 */
+	lw     $2, 32($sp)
+	lw     $3, 36($sp)
+	l.d   $f0, 32($sp)
+
+	/* Epilog. Tear down frame and return. */
+	lw    $ra, 20($sp)  /* restore return address */
+	addiu $sp, $sp, 56  /* close frame */
+	j     $ra           /* return */
+	nop                 /* branch delay nop */
+
+	.set    reorder
+	.end    dcCallbackThunkEntry
+	.ident  "handwritten"
+

data/dyncall/dyncallback/dyncall_callback_ppc32.S

@@ -6,7 +6,7 @@
  Description: Callback Thunk Entry for PowerPC 32-bit System V Big-Endian ABI
  License:
 
-   Copyright (c) 2015 Daniel Adler <dadler@uni-goettingen.de>
+   Copyright (c) 2015-2018 Daniel Adler <dadler@uni-goettingen.de>
 
    Permission to use, copy, modify, and distribute this software for any
    purpose with or without fee is hereby granted, provided that the above
@@ -25,16 +25,16 @@
 
 #include "../portasm/portasm-ppc.S"
 
-	.machine ppc
-	.text
-	.align 2
+.machine ppc
+.text
+.align 2
 
 /* Struct DCCallback */
 
-DCB_THUNK 	= 0
-DCB_HANDLER     = 24
-DCB_CLEANUP     = 28
-DCB_USERDATA    = 32
+DCB_THUNK    = 0
+DCB_HANDLER  = 24
+DCB_CLEANUP  = 28
+DCB_USERDATA = 32
 
 /* Struct DCArgs */
 
@@ -74,30 +74,30 @@ ENTRY_C(dcCallbackThunkEntry)
 /* --------------------------------------------------------------------------
 
 Input:
-	r1    	Stack Pointer            
-	r3-r10	Integer Arguments        
-	f1-f8 	Floating-point Arguments 
-	r11 	Thunk Pointer            
+	r1      Stack Pointer            
+	r3-r10  Integer Arguments        
+	f1-f8   Floating-point Arguments 
+	r11     Thunk Pointer            
 
 */
-	
+
 	/* prolog */
 
-	mflr	r0			
-	stw	r0,      SP_LR(r1)	/* store return address */
-	addi	r12, r1, SP_PAR         /* temporary r12: parameter area on callers stack frame */
+	mflr    r0
+	stw     r0,     SP_LR(r1)  /* store return address */
+	addi    r12,r1, SP_PAR     /* temporary r12: parameter area on callers stack frame */
 	stwu    r1, -FRAMESIZE(r1)
-	
-	stw	r3, SP_IREGS + 0*4(r1)	/* spill 8 integer parameter registers */
-	stw	r4, SP_IREGS + 1*4(r1)
-	stw	r5, SP_IREGS + 2*4(r1)
+
+	stw     r3, SP_IREGS + 0*4(r1)  /* spill 8 integer parameter registers */
+	stw     r4, SP_IREGS + 1*4(r1)
+	stw     r5, SP_IREGS + 2*4(r1)
 	stw     r6, SP_IREGS + 3*4(r1)
 	stw     r7, SP_IREGS + 4*4(r1)
 	stw     r8, SP_IREGS + 5*4(r1)
 	stw     r9, SP_IREGS + 6*4(r1)
 	stw     r10,SP_IREGS + 7*4(r1)
-	
-        stfd    f1, SP_FREGS + 0*8(r1)	/* spill 8 (of 13) float parameter registers */
+
+	stfd    f1, SP_FREGS + 0*8(r1)  /* spill 8 (of 13) float parameter registers */
 	stfd    f2, SP_FREGS + 1*8(r1)
 	stfd    f3, SP_FREGS + 2*8(r1)
 	stfd    f4, SP_FREGS + 3*8(r1)
@@ -106,39 +106,39 @@ Input:
 	stfd    f7, SP_FREGS + 6*8(r1)
 	stfd    f8, SP_FREGS + 7*8(r1)
 
-	stw	r12, SP_SP(r1)		/* init stack pointer */
-	xor	r0, r0, r0		/* init register counters */
-	stw	r0, SP_ICNT(r1)
-	stw	r0, SP_FCNT(r1)
-	stw     r0, SP_RESULT(r1)	/* init result object */
-        stw     r0, SP_RESULT + 4(r1)
-					/* invoke callback handler */
-	mr	r3, r11	                /* arg 1: DCCallback* pcb (r11 is thunk pointer) */
-	addi	r4, r1, SP_ARGS		/* arg 2: DCArgs* args 		*/
-	addi	r5, r1, SP_RESULT	/* arg 3: DCValue* result	*/
-	lwz	r6, DCB_USERDATA(r11)   /* arg 4: void* userdata 	*/
-
-					/* branch-and-link to DCCallback.handler */
-	lwz	r12,  DCB_HANDLER(r11)
-	mtctr	r12
+	stw     r12,SP_SP(r1)         /* init stack pointer */
+	xor     r0, r0, r0            /* init register counters */
+	stw     r0, SP_ICNT(r1)
+	stw     r0, SP_FCNT(r1)
+	stw     r0, SP_RESULT(r1)     /* init result object */
+	stw     r0, SP_RESULT + 4(r1)
+	/* invoke callback handler */
+	mr      r3, r11               /* arg 1: DCCallback* pcb (r11 = thunk ptr) */
+	addi    r4, r1, SP_ARGS       /* arg 2: DCArgs* args    */
+	addi    r5, r1, SP_RESULT     /* arg 3: DCValue* result */
+	lwz     r6, DCB_USERDATA(r11) /* arg 4: void* userdata  */
+
+	/* branch-and-link to DCCallback.handler */
+	lwz     r12,  DCB_HANDLER(r11)
+	mtctr   r12
 	bctrl
-					/* check result type */	
-	cmpi	cr0, r3, 'f
-	beq	.f32
-	cmpi	cr0, r3, 'd
-	beq	.f64
+	/* check result type */
+	cmpi    cr0, r3, 0x66 /* 'f */
+	beq .f32
+	cmpi    cr0, r3, 0x64 /* 'd */
+	beq .f64
 .i64:
-	lwz    r3, SP_RESULT     (r1)
-	lwz    r4, SP_RESULT + 4 (r1) 
+	lwz     r3, SP_RESULT     (r1)
+	lwz     r4, SP_RESULT + 4 (r1) 
 .end:
-	lwz    r1, SP_PREV(r1)	/* restore stack pointer */
-	lwz    r0, SP_LR(r1)	/* load link register with return address */
-	mtlr   r0
-	blr			/* branch back to link register */
-.f32:	
-	lfs	f1, SP_RESULT(r1)
-	b	.end
+	lwz     r1, SP_PREV(r1)  /* restore stack pointer */
+	lwz     r0, SP_LR(r1)    /* load link register with return address */
+	mtlr    r0
+	blr                      /* branch back to link register */
+.f32:
+	lfs     f1, SP_RESULT(r1)
+	b .end
 .f64:
-	lfd	f1, SP_RESULT(r1)
-	b	.end
-	
+	lfd     f1, SP_RESULT(r1)
+	b .end
+