Ignore:
Timestamp:
Dec 8, 2008, 1:18:20 PM (11 years ago)
Author:
gb
Message:

Deprecate versions of poweropen_ffcall, poweropen_callback that were
supposed to save/restore Mach exception ports.
Do all ff-call epilogs inline, so that ObjC exception-handling code
can be added for DarwinPPC64.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/lisp-kernel/ppc-spentry.s

    r11319 r11478  
    14791479       
    14801480_spentry(poweropen_ffcall)
     1481LocalLabelPrefix[]ffcall:               
    14811482        __(mflr loc_pc)
    14821483        __(vpush_saveregs())            /* Now we can use save0-save7 to point to stacks  */
     
    15141515         __(li rcontext,0)
    15151516        __endif
     1517LocalLabelPrefix[]ffcall_setup:
    15161518        __(mtctr nargs)
    15171519        __(ldr(r3,c_frame.param0(sp)))
     
    15261528        /* to the function on entry.  */
    15271529        __(mr r12,nargs)
     1530LocalLabelPrefix[]ffcall_setup_end:
     1531LocalLabelPrefix[]ffcall_call:
    15281532        __(bctrl)
    1529         __(b FF_call_return_common)
     1533LocalLabelPrefix[]ffcall_call_end:
     1534        /* C should have preserved save0 (= rcontext) for us.  */
     1535        __(ldr(sp,0(sp)))
     1536        __(mr imm2,save0)
     1537        __(ldr(vsp,lisp_frame.savevsp(sp)))
     1538        __(li rzero,0)
     1539        __(mr loc_pc,rzero)
     1540        __(li arg_x,nil_value)
     1541        __(li arg_y,nil_value)
     1542        __(li arg_z,nil_value)
     1543        __(li temp0,nil_value)
     1544        __(li temp1,nil_value)
     1545        __(li temp2,nil_value)
     1546        __(li temp3,nil_value)
     1547        __(li fn,nil_value)
     1548        __(mr rcontext,imm2)
     1549        __(li imm2,TCR_STATE_LISP)
     1550        __(ldr(tsp,tcr.save_tsp(rcontext)))
     1551        __(li save0,0)
     1552        __(li save1,0)
     1553        __(li save2,0)
     1554        __(li save3,0)
     1555        __(li save4,0)
     1556        __(li save5,0)
     1557        __(li save6,0)
     1558        __(li save7,0)
     1559        __(li allocptr,-dnode_size)
     1560        __(li allocbase,-dnode_size)
     1561        __(str(imm2,tcr.valence(rcontext)))     
     1562        __(vpop_saveregs())
     1563        __(ldr(allocptr,tcr.save_allocptr(rcontext)))
     1564        __(ldr(allocbase,tcr.save_allocbase(rcontext)))
     1565        __(ldr(loc_pc,lisp_frame.savelr(sp)))
     1566        __(mtlr loc_pc)
     1567        __(ldr(fn,lisp_frame.savefn(sp)))
     1568        __(mffs f0)
     1569        __(stfd f0,8(sp))
     1570        __(lwz imm3,12(sp))     /* imm3 = FPSCR after call  */
     1571        __(clrrwi imm2,imm3,8)
     1572        __(discard_lisp_frame())
     1573        __(str(imm2,tcr.ffi_exception(rcontext)))
     1574        __(lfd f0,tcr.lisp_fpscr(rcontext))
     1575        __(mtfsf 0xff,f0)
     1576        __(check_pending_interrupt([cr1]))
     1577        __(mtxer rzero)
     1578        __(mtctr rzero)
     1579        __(blr)
     1580
    15301581
    15311582/* Just like poweropen_ffcall, only we save all argument(result)
     
    16041655        __(stfd f12,((8*node_size)+(11*8))(save7))
    16051656        __(stfd f13,((8*node_size)+(12*8))(save7))
    1606         __(b FF_call_return_common)
     1657        /* C should have preserved save0 (= rcontext) for us.  */
     1658        __(ldr(sp,0(sp)))
     1659        __(mr imm2,save0)
     1660        __(ldr(vsp,lisp_frame.savevsp(sp)))
     1661        __(li rzero,0)
     1662        __(mr loc_pc,rzero)
     1663        __(li arg_x,nil_value)
     1664        __(li arg_y,nil_value)
     1665        __(li arg_z,nil_value)
     1666        __(li temp0,nil_value)
     1667        __(li temp1,nil_value)
     1668        __(li temp2,nil_value)
     1669        __(li temp3,nil_value)
     1670        __(li fn,nil_value)
     1671        __(mr rcontext,imm2)
     1672        __(li imm2,TCR_STATE_LISP)
     1673        __(ldr(tsp,tcr.save_tsp(rcontext)))
     1674        __(li save0,0)
     1675        __(li save1,0)
     1676        __(li save2,0)
     1677        __(li save3,0)
     1678        __(li save4,0)
     1679        __(li save5,0)
     1680        __(li save6,0)
     1681        __(li save7,0)
     1682        __(li allocptr,-dnode_size)
     1683        __(li allocbase,-dnode_size)
     1684        __(str(imm2,tcr.valence(rcontext)))     
     1685        __(vpop_saveregs())
     1686        __(ldr(allocptr,tcr.save_allocptr(rcontext)))
     1687        __(ldr(allocbase,tcr.save_allocbase(rcontext)))
     1688        __(ldr(loc_pc,lisp_frame.savelr(sp)))
     1689        __(mtlr loc_pc)
     1690        __(ldr(fn,lisp_frame.savefn(sp)))
     1691        __(mffs f0)
     1692        __(stfd f0,8(sp))
     1693        __(lwz imm3,12(sp))     /* imm3 = FPSCR after call  */
     1694        __(clrrwi imm2,imm3,8)
     1695        __(discard_lisp_frame())
     1696        __(str(imm2,tcr.ffi_exception(rcontext)))
     1697        __(lfd f0,tcr.lisp_fpscr(rcontext))
     1698        __(mtfsf 0xff,f0)
     1699        __(check_pending_interrupt([cr1]))
     1700        __(mtxer rzero)
     1701        __(mtctr rzero)
     1702        __(blr)
     1703
    16071704
    16081705               
     
    16561753        __(b _SPheap_cons_rest_arg)
    16571754
    1658 
    1659 _spentry(poweropen_callbackX)       
    1660         /* Save C argument registers  */
    1661         __(str(r3,c_frame.param0(sp)))
    1662         __(str(r4,c_frame.param1(sp)))
    1663         __(str(r5,c_frame.param2(sp)))
    1664         __(str(r6,c_frame.param3(sp)))
    1665         __(str(r7,c_frame.param4(sp)))
    1666         __(str(r8,c_frame.param5(sp)))
    1667         __(str(r9,c_frame.param6(sp)))
    1668         __(str(r10,c_frame.param7(sp)))
    1669         __(mflr imm3)
    1670         __(str(imm3,c_frame.savelr(sp)))
    1671         __(mfcr imm0)
    1672         __(str(imm0,c_frame.crsave(sp)))
    1673 
    1674         /* Save the non-volatile registers on the sp stack  */
    1675         /* This is a non-standard stack frame, but noone will ever see it,  */
    1676         /* so it doesn't matter. It will look like more of the stack  */
    1677         /* frame pushed below.  */
    1678         __(stru(sp,-(stack_align(c_reg_save.size))(sp)))
    1679         __(str(r13,c_reg_save.save_gprs+(0*node_size)(sp)))
    1680         __(str(r14,c_reg_save.save_gprs+(1*node_size)(sp)))
    1681         __(str(r15,c_reg_save.save_gprs+(2*node_size)(sp)))
    1682         __(str(r16,c_reg_save.save_gprs+(3*node_size)(sp)))
    1683         __(str(r17,c_reg_save.save_gprs+(4*node_size)(sp)))
    1684         __(str(r18,c_reg_save.save_gprs+(5*node_size)(sp)))
    1685         __(str(r19,c_reg_save.save_gprs+(6*node_size)(sp)))
    1686         __(str(r20,c_reg_save.save_gprs+(7*node_size)(sp)))
    1687         __(str(r21,c_reg_save.save_gprs+(8*node_size)(sp)))
    1688         __(str(r22,c_reg_save.save_gprs+(9*node_size)(sp)))
    1689         __(str(r23,c_reg_save.save_gprs+(10*node_size)(sp)))
    1690         __(str(r24,c_reg_save.save_gprs+(11*node_size)(sp)))
    1691         __(str(r25,c_reg_save.save_gprs+(12*node_size)(sp)))
    1692         __(str(r26,c_reg_save.save_gprs+(13*node_size)(sp)))
    1693         __(str(r27,c_reg_save.save_gprs+(14*node_size)(sp)))
    1694         __(str(r28,c_reg_save.save_gprs+(15*node_size)(sp)))
    1695         __(str(r29,c_reg_save.save_gprs+(16*node_size)(sp)))
    1696         __(str(r30,c_reg_save.save_gprs+(17*node_size)(sp)))
    1697         __(str(r31,c_reg_save.save_gprs+(18*node_size)(sp)))
    1698         __(stfd f1,c_reg_save.save_fprs+(0*8)(sp))
    1699         __(stfd f2,c_reg_save.save_fprs+(1*8)(sp))
    1700         __(stfd f3,c_reg_save.save_fprs+(2*8)(sp))
    1701         __(stfd f4,c_reg_save.save_fprs+(3*8)(sp))
    1702         __(stfd f5,c_reg_save.save_fprs+(4*8)(sp))
    1703         __(stfd f6,c_reg_save.save_fprs+(5*8)(sp))
    1704         __(stfd f7,c_reg_save.save_fprs+(6*8)(sp))
    1705         __(stfd f8,c_reg_save.save_fprs+(7*8)(sp))
    1706         __(stfd f9,c_reg_save.save_fprs+(8*8)(sp))
    1707         __(stfd f10,c_reg_save.save_fprs+(9*8)(sp))
    1708         __(stfd f11,c_reg_save.save_fprs+(10*8)(sp))
    1709         __(stfd f12,c_reg_save.save_fprs+(11*8)(sp))
    1710         __(stfd f13,c_reg_save.save_fprs+(12*8)(sp))
    1711         __(check_stack_alignment(r0))
    1712         __(mffs f0)
    1713         __(stfd f0,c_reg_save.save_fp_zero(sp))
    1714         __(ldr(r31,c_reg_save.save_fp_zero+4(sp)))      /* recover FPSCR image  */
    1715         __(str(r31,c_reg_save.save_fpscr(sp)))
    1716         __(lwi(r30,0x43300000))
    1717         __(lwi(r31,0x80000000))
    1718         __(stw r30,c_reg_save.save_fp_zero(sp))
    1719         __(stw r31,c_reg_save.save_fp_zero+4(sp))
    1720         __(stfd fp_s32conv,c_reg_save.save_fps32conv(sp))
    1721         __(lfd fp_s32conv,c_reg_save.save_fp_zero(sp))
    1722         __(stfd fp_zero,c_reg_save.save_fp_zero(sp))
    1723         __(lfs fp_zero,lisp_globals.short_float_zero(0))        /* ensure that fp_zero contains 0.0  */
    1724 
    1725 /* Restore rest of Lisp context.  */
    1726 /* Could spread out the memory references here to gain a little speed  */
    1727 
    1728         __(li loc_pc,0)
    1729         __(li fn,0)                     /* subprim, not a lisp function  */
    1730         __(li temp3,0)
    1731         __(li temp2,0)
    1732         __(li temp1,0)
    1733         __(li temp0,0)
    1734         __(li arg_x,0)
    1735         __(box_fixnum(arg_y,r11))       /* callback-index  */
    1736         __(la arg_z,c_reg_save.save_fprs(sp))
    1737         __(str(arg_z,stack_align(c_reg_save.size)+c_frame.unused(sp)))
    1738         __(la arg_z,stack_align(c_reg_save.size)+c_frame.param0(sp))    /* parameters (tagged as a fixnum)  */
    1739 
    1740         /* Recover lisp thread context. Have to call C code to do so.  */
    1741         __(ref_global(r12,get_tcr))
    1742         __(mtctr r12)
    1743         __(li r3,1)
    1744         __(stru(sp,-(stack_align(c_frame.minsiz))(sp)))
    1745         __(bctrl)
    1746         __(la rcontext,TCR_BIAS(r3))
    1747         /* re-establish lisp exception handling  */
    1748         __(ref_global(r12,lisp_return_hook))
    1749         __(mtctr r12)
    1750         __(bctrl)
    1751         __(la sp,(stack_align(c_frame.minsiz))(sp))
    1752 
    1753         __(ldr(vsp,tcr.save_vsp(rcontext)))
    1754         __(ldr(tsp,tcr.save_tsp(rcontext)))             
    1755         __(li rzero,0)
    1756         __(mtxer rzero) /* lisp wants the overflow bit clear  */
    1757         __(mtctr rzero)
    1758         __(li imm0,TCR_STATE_LISP)
    1759         __(li save0,0)
    1760         __(li save1,0)
    1761         __(li save2,0)
    1762         __(li save3,0)
    1763         __(li save4,0)
    1764         __(li save5,0)
    1765         __(li save6,0)
    1766         __(li save7,0)
    1767         __(lfd f0,tcr.lisp_fpscr(rcontext))
    1768         __(mtfsf 0xff,f0)
    1769         __(li allocptr,0)
    1770         __(li allocbase,0)
    1771         __(str(imm0,tcr.valence(rcontext)))
    1772         __(ldr(allocptr,tcr.save_allocptr(rcontext)))
    1773         __(ldr(allocbase,tcr.save_allocbase(rcontext)))
    1774        
    1775         __(restore_saveregs(vsp))
    1776         /* load nargs and callback to the lisp  */
    1777         __(set_nargs(2))
    1778         __(ldr(imm2,tcr.cs_area(rcontext)))
    1779         __(ldr(imm4,area.active(imm2)))
    1780         __(stru(imm4,-lisp_frame.size(sp)))
    1781         __(str(imm3,lisp_frame.savelr(sp)))
    1782         __(li fname,nrs.callbacks)      /* %pascal-functions%  */
    1783         __(call_fname)
    1784         __(ldr(imm2,lisp_frame.backlink(sp)))
    1785         __(ldr(imm3,tcr.cs_area(rcontext)))
    1786         __(str(imm2,area.active(imm3)))
    1787         __(discard_lisp_frame())
    1788         /* save_vsp will be restored from ff_call's stack frame, but  */
    1789         /* I included it here for consistency.  */
    1790         /* save_tsp is set below after we exit Lisp context.  */
    1791         __(str(allocptr,tcr.save_allocptr(rcontext)))
    1792         __(str(allocbase,tcr.save_allocbase(rcontext)))
    1793         __(str(vsp,tcr.save_vsp(rcontext)))
    1794         __(str(tsp,tcr.save_tsp(rcontext)))
    1795 
    1796         __(li imm1,TCR_STATE_FOREIGN)
    1797         __(str(imm1,tcr.valence(rcontext)))
    1798         __(mr r3,rcontext)
    1799         __(ldr(r4,tcr.foreign_exception_status(rcontext)))
    1800         __(cmpri(r4,0))
    1801         /* Restore the non-volatile registers & fpscr  */
    1802         __(lfd fp_zero,c_reg_save.save_fp_zero(sp))
    1803         __(ldr(r31,c_reg_save.save_fpscr(sp)))
    1804         __(str(r31,c_reg_save.save_fp_zero+4(sp)))
    1805         __(lfd f0,c_reg_save.save_fp_zero(sp))
    1806         __(mtfsf 0xff,f0)
    1807         __(ldr(r13,c_reg_save.save_gprs+(0*node_size)(sp)))
    1808         __(ldr(r14,c_reg_save.save_gprs+(1*node_size)(sp)))
    1809         __(ldr(r15,c_reg_save.save_gprs+(2*node_size)(sp)))
    1810         __(ldr(r16,c_reg_save.save_gprs+(3*node_size)(sp)))
    1811         __(ldr(r17,c_reg_save.save_gprs+(4*node_size)(sp)))
    1812         __(ldr(r18,c_reg_save.save_gprs+(5*node_size)(sp)))
    1813         __(ldr(r19,c_reg_save.save_gprs+(6*node_size)(sp)))
    1814         __(ldr(r20,c_reg_save.save_gprs+(7*node_size)(sp)))
    1815         __(ldr(r21,c_reg_save.save_gprs+(8*node_size)(sp)))
    1816         __(ldr(r22,c_reg_save.save_gprs+(9*node_size)(sp)))
    1817         __(ldr(r23,c_reg_save.save_gprs+(10*node_size)(sp)))
    1818         __(ldr(r24,c_reg_save.save_gprs+(11*node_size)(sp)))
    1819         __(ldr(r25,c_reg_save.save_gprs+(12*node_size)(sp)))
    1820         __(ldr(r26,c_reg_save.save_gprs+(13*node_size)(sp)))
    1821         __(ldr(r27,c_reg_save.save_gprs+(14*node_size)(sp)))
    1822         __(ldr(r28,c_reg_save.save_gprs+(15*node_size)(sp)))
    1823         __(ldr(r29,c_reg_save.save_gprs+(16*node_size)(sp)))
    1824         __(ldr(r30,c_reg_save.save_gprs+(17*node_size)(sp)))
    1825         __(ldr(r31,c_reg_save.save_gprs+(18*node_size)(sp)))
    1826         __(lfd fp_s32conv,c_reg_save.save_fps32conv(sp))
    1827         __(beq 9f)
    1828         __(ref_global(r12,lisp_exit_hook))
    1829         __(mtctr r12)
    1830         __(bctrl)
    1831 9:
    1832         __(lfd f1,c_reg_save.save_fprs+(0*8)(sp))
    1833         __(lfd f2,c_reg_save.save_fprs+(1*8)(sp))
    1834         __(lfd f3,c_reg_save.save_fprs+(2*8)(sp))
    1835         __(lfd f4,c_reg_save.save_fprs+(3*8)(sp))
    1836         __(lfd f5,c_reg_save.save_fprs+(4*8)(sp))
    1837         __(lfd f6,c_reg_save.save_fprs+(5*8)(sp))
    1838         __(lfd f7,c_reg_save.save_fprs+(6*8)(sp))
    1839         __(lfd f8,c_reg_save.save_fprs+(7*8)(sp))
    1840         __(lfd f9,c_reg_save.save_fprs+(8*8)(sp))
    1841         __(lfd f10,c_reg_save.save_fprs+(9*8)(sp))
    1842         __(lfd f11,c_reg_save.save_fprs+(10*8)(sp))
    1843         __(lfd f12,c_reg_save.save_fprs+(11*8)(sp))
    1844         __(lfd f13,c_reg_save.save_fprs+(12*8)(sp))
    1845         __(ldr(sp,0(sp)))
    1846         __(ldr(r3,c_frame.param0(sp)))
    1847         __(ldr(r4,c_frame.param1(sp)))
    1848         __(ldr(r5,c_frame.param2(sp)))
    1849         __(ldr(r6,c_frame.param3(sp)))
    1850         __(ldr(r7,c_frame.param4(sp)))
    1851         __(ldr(r8,c_frame.param5(sp)))
    1852         __(ldr(r9,c_frame.param6(sp)))
    1853         __(ldr(r10,c_frame.param7(sp)))
    1854         __(ldr(r11,c_frame.savelr(sp)))
    1855         __(mtlr r11)
    1856         __(ldr(r12,c_frame.crsave(sp)))
    1857         __(mtcr r12)
    1858         __(blr)
     1755/* This was trying to swap exception ports to work around Darwin JNI lossage.
     1756   It's tended to bitrot, and we have another way to do that now.
     1757*/       
     1758_spentry(poweropen_callbackX)
     1759        .long 0x7c800008        /* debug trap */
    18591760       
    18601761/* Prepend all but the first two (closure code, fn) and last two  */
     
    32523153/* almost exactly as above, but "swap exception handling info" */
    32533154/* on exit and return  */
     3155/* Deprecated */       
    32543156_spentry(poweropen_ffcallX)
    3255         __(mflr loc_pc)
    3256         __(vpush_saveregs())            /* Now we can use save0-save7 to point to stacks  */
    3257         __(mr save0,rcontext)   /* or address globals.  */
    3258         __(extract_typecode(imm0,arg_z))
    3259         __(cmpri(cr7,imm0,subtag_macptr))
    3260         __(ldr(save1,c_frame.backlink(sp)))     /* bottom of reserved lisp frame  */
    3261         __(la save2,-lisp_frame.size(save1))    /* top of lisp frame */
    3262         __(zero_doublewords save2,0,lisp_frame.size)
    3263         __(str(save1,lisp_frame.backlink(save2)))
    3264         __(str(save2,c_frame.backlink(sp)))
    3265         __(str(fn,lisp_frame.savefn(save2)))
    3266         __(str(loc_pc,lisp_frame.savelr(save2)))
    3267         __(str(vsp,lisp_frame.savevsp(save2)))
    3268         __(bne cr7,1f)
    3269         __(ldr(arg_z,macptr.address(arg_z)))
    3270 1:
    3271         __(ldr(save3,tcr.cs_area(rcontext)))
    3272         __(str(save2,area.active(save3)))
    3273         __(str(allocptr,tcr.save_allocptr(rcontext)))
    3274         __(str(allocbase,tcr.save_allocbase(rcontext)))
    3275         __(str(tsp,tcr.save_tsp(rcontext)))
    3276         __(str(vsp,tcr.save_vsp(rcontext)))
    3277         __(str(rzero,tcr.ffi_exception(rcontext)))
    3278         __(mffs f0)
    3279         __(stfd f0,tcr.lisp_fpscr(rcontext))    /* remember lisp's fpscr  */
    3280         __(mtfsf 0xff,fp_zero)  /* zero foreign fpscr  */
    3281         __(ldr(r3,tcr.foreign_exception_status(rcontext)))
    3282         __(cmpri(r3,0))
    3283         __(ref_global(r12,lisp_exit_hook))
    3284         __(mtctr r12)
    3285         __(beq+ 1f)
    3286         __(stru(sp,-(stack_align(c_frame.minsiz))(sp)))
    3287         __(bctrl)
    3288         __(la sp,(stack_align(c_frame.minsiz))(sp))
    3289 1:     
    3290         __(li rcontext,0)
    3291         __(mtctr arg_z)
    3292         __(ldr(r3,c_frame.param0(sp)))
    3293         __(ldr(r4,c_frame.param1(sp)))
    3294         __(ldr(r5,c_frame.param2(sp)))
    3295         __(ldr(r6,c_frame.param3(sp)))
    3296         __(ldr(r7,c_frame.param4(sp)))
    3297         __(ldr(r8,c_frame.param5(sp)))
    3298         __(ldr(r9,c_frame.param6(sp)))
    3299         __(ldr(r10,c_frame.param7(sp)))
    3300         /* Darwin is allegedly very picky about what register points */
    3301         /* to the function on entry.  */
    3302         __(mr r12,arg_z)
    3303         __(bctrl)
    3304         __(ref_global(r12,lisp_return_hook))
    3305         __(mtctr r12)
    3306         __(str(r3,c_frame.param0(sp)))
    3307         __(str(r4,c_frame.param1(sp)))
    3308         __(stfd f1,c_frame.param2(sp))
    3309         __(stru(sp,-(stack_align(c_frame.minsiz))(sp)))
    3310         __(mr r3,save0)
    3311         __(bctrl)
    3312         __(la sp,(stack_align(c_frame.minsiz))(sp))
    3313         __(ldr(r3,c_frame.param0(sp)))
    3314         __(ldr(r4,c_frame.param1(sp)))
    3315         __(lfd f1,c_frame.param2(sp))
    3316         __(b FF_call_return_common)     
    3317        
     3157        .long 0x7c800008        /* debug trap */
    33183158
    33193159
     
    58335673        __(crset 6)
    58345674        __(bctrl)
    5835         _endsubp(eabi_ff_call)
    5836        
    5837         _startfn(FF_call_return_common)
    58385675        /* C should have preserved save0 (= rcontext) for us.  */
    58395676        __(ldr(sp,0(sp)))
     
    58645701        __(li allocbase,-dnode_size)
    58655702        __(str(imm2,tcr.valence(rcontext)))     
    5866         .globl C(ffcall_return_window)
    5867 C(ffcall_return_window):               
    58685703        __(vpop_saveregs())
    58695704        __(ldr(allocptr,tcr.save_allocptr(rcontext)))
    58705705        __(ldr(allocbase,tcr.save_allocbase(rcontext)))
    5871         .globl C(ffcall_return_window_end)
    5872 C(ffcall_return_window_end):               
    58735706        __(ldr(loc_pc,lisp_frame.savelr(sp)))
    58745707        __(mtlr loc_pc)
Note: See TracChangeset for help on using the changeset viewer.