Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Diff of /sml/trunk/src/runtime/mach-dep/X86.prim.asm
ViewVC logotype

Diff of /sml/trunk/src/runtime/mach-dep/X86.prim.asm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 29, Thu Mar 12 01:05:59 1998 UTC revision 243, Sat Apr 17 18:41:51 1999 UTC
# Line 3  Line 3 
3   * COPYRIGHT (c) 1995 AT&T Bell Laboratories.   * COPYRIGHT (c) 1995 AT&T Bell Laboratories.
4   *   *
5   * This was derived from I386.prim.s, by Mark Leone (mleone@cs.cmu.edu)   * This was derived from I386.prim.s, by Mark Leone (mleone@cs.cmu.edu)
6     *
7     * Heavily modified and changed to use assyntax.h, by Lal George.
8   */   */
9    
10  #include "ml-base.h"  #include "ml-base.h"
# Line 10  Line 12 
12  #include "ml-values.h"  #include "ml-values.h"
13  #include "tags.h"  #include "tags.h"
14  #include "ml-request.h"  #include "ml-request.h"
 #include "reg-mask.h"  
15  #include "ml-limits.h"  #include "ml-limits.h"
16    
17  /* enable/disable virtual (memory-based) registers.  /* enable/disable virtual (memory-based) registers.
# Line 20  Line 21 
21   *      src/sml-nj/x86/x86.sml   *      src/sml-nj/x86/x86.sml
22   */   */
23    
24    /* XXX:  May no longer be needed */
25  #ifndef VREGS  #ifndef VREGS
26  #  define VREGS  #  define VREGS
27  #endif  #endif
# Line 29  Line 31 
31   * The 386 registers are used as follows:   * The 386 registers are used as follows:
32   *   *
33   * EAX - temp1 (see the code generator, x86/x86.sml)   * EAX - temp1 (see the code generator, x86/x86.sml)
34   * EBX - misc1   * EBX - misc0
35   * ECX - misc2   * ECX - misc1
36   * EDX - misc3   * EDX - misc2
37   * ESI - standard continuation (ml_cont, see ml_state.h)   * ESI - standard continuation (ml_cont, see ml_state.h)
38   * EBP - standard argument (ml_arg)   * EBP - standard argument (ml_arg)
39   * EDI - free space pointer (ml_allocptr)   * EDI - free space pointer (ml_allocptr)
# Line 41  Line 43 
43    
44  /* Registers (see x86/x86.sml): */  /* Registers (see x86/x86.sml): */
45  #define temp            %eax  #define temp            %eax
46  #define misc1           %ebx  #define misc0           %ebx
47  #define misc2           %ecx  #define misc1           %ecx
48  #define misc3           %edx  #define misc2           %edx
49  #define stdcont         %esi  #define stdcont         %esi
50  #define stdarg          %ebp  #define stdarg          %ebp
51  #define allocptr        %edi  #define allocptr        %edi
52    #define stackptr        %esp
53    
54  /* other reg uses */  /* other reg uses */
55  #define creturn         %eax  #define creturn         %eax
56    
57  /*          /* Stack frame */
  * Other values, which on most architectures would reside in registers,  
  * are stored on the stack:  
  *  
  * 0(ESP) - tempmem (used by the X86 code generator)  
  * 4(ESP) - tempmem2 (used by the X86 code generator)  
  * 8(ESP) - exception handler continuation (ml_exncont)  
  * 12(ESP) - data limit (ml_limitptr)  
  * 16(ESP) - standard closure (ml_closure)  
  * 20(ESP) - link register (ml_linkreg)  
  * 24(ESP) - store pointer (ml_storeptr)  
  * 28(ESP) - var pointer (ml_varptr)  
  *  
  */  
   
 /* Stack frame (see x86/x86.sml): */  
58  #define tempmem         0(%esp)  #define tempmem         0(%esp)
59  #define tempmem2        4(%esp)  #define baseptr         4(%esp)
60  #define exncont         8(%esp)  #define exncont         8(%esp)
61  #define limitptr        12(%esp)  #define limitptr        12(%esp)
62  #define stdclos         16(%esp)  #define pc              16(%esp)
63  #define stdlink         20(%esp)  #define unused_1        20(%esp)
64  #define storeptr        24(%esp)  #define storeptr        24(%esp)
65  #define varptr          28(%esp)  #define varptr          28(%esp)
66  #define start_gc        32(%esp)  #define start_gc        32(%esp)
67  #define mask            36(%esp)  #define unused_2        36(%esp)
68  #define vreg0           40(%esp)  #define eaxSpill        40(%esp) /* eax=0 */
69  #define vreg1           44(%esp)  #define ecxSpill        44(%esp) /* ecx=1 */
70  #define vreg2           48(%esp)  #define edxSpill        48(%esp) /* edx=2 */
71  #define vreg3           52(%esp)  #define ebxSpill        52(%esp) /* ebx=3 */
72  #define vreg4           56(%esp)  #define espSpill        56(%esp) /* esp=4 */
73  #define vreg5           60(%esp)  #define ebpSpill        60(%esp) /* ebp=5 */
74  #define vreg6           64(%esp)  #define esiSpill        64(%esp) /* esi=6 */
75  #define vreg7           68(%esp)  #define ediSpill        68(%esp) /* edi=7 */
76  #define vreg8           72(%esp)  #define stdlink         72(%esp)
77  #define vreg9           76(%esp)  #define stdclos         76(%esp)
78  #define vreg10          80(%esp)  
79  #define vreg11          84(%esp)  #define ML_STATE_OFFSET 176
80  #define vreg12          88(%esp)     /* unused */ /* used as pseudo reg */  #define mlstate_ptr     ML_STATE_OFFSET(%esp)
81  #define vreg13          92(%esp)     /* unused */ /* used as pseudo reg */  #define freg8           184          /* double word aligned */
82  #define vreg14          96(%esp)     /* unused */  #define freg9           192
83  #define vreg15          100(%esp)    /* unused */  #define freg31          368          /* 152 + (31-8)*8 */
84  #define mlstate_ptr     104(%esp)  #define fpTempMem       376          /* freg31 + 8 */
85  #define ML_STATE_OFFSET 104  #define SpillAreaStart  512          /* starting offset */
86  #define ML_FRAME_SIZE   (ML_STATE_OFFSET+4)  #define ML_FRAME_SIZE   (8192)
   
   
 #define PSEUDOREG_1     vreg12  
 #define PSEUDOREG_2     vreg13  
87    
88  #define via  #define via
89    
   
90          DATA          DATA
91          ALIGN4          ALIGN4
 tempmem_w:              /* temp word for the code generator */  
         .long 0  
 tempmem2_w:             /* another temp word for the code generator */  
         .long 0  
92  request_w:              /* place to put the request code */  request_w:              /* place to put the request code */
93          .long 0          .long 0
94          GLOBAL(ML_X86Frame)          GLOBAL(ML_X86Frame)
95  LABEL(CSYM(ML_X86Frame)) /* ptr to the ml frame (gives C access to limitptr) */  LABEL(CSYM(ML_X86Frame)) /* ptr to the ml frame (gives C access to limitptr) */
96          .long 0          .long 0
97    
98  /*  SavedSP:
99   * Note that the garbage collector only preserves root registers          .long 0         /* Value of stack pointer to restore */
  * (EBX, ECX, EDX, ESI, EBP, EIP).  
  */  
100    
101    
102  #include "mlstate-offsets.h"    /** this file is generated **/  #include "mlstate-offsets.h"    /** this file is generated **/
# Line 156  Line 133 
133          movl    src, tmp;       \          movl    src, tmp;       \
134          movl    tmp, dest          movl    tmp, dest
135    
 #if (CALLEESAVE > 0)  
136  #define CONTINUE                                                \  #define CONTINUE                                                \
         cmpl    limitptr, allocptr;                             \  
137          jmp     via stdcont          jmp     via stdcont
 #else  
 #define CONTINUE                                                        \  
         movl    (stdcont), temp;                                        \  
         movl    temp, stdlink;          /* Not really a register */     \  
         cmpl    limitptr, allocptr;                                     \  
         jmp     via temp  
 #endif  
138    
139  #define CHECKLIMIT(maskval)                                             \  #define CHECKLIMIT                              \
140   1:;                                                                    \   1:;                                                                    \
141            MOVE(stdlink, temp, pc) ;               \
142            cmpl    limitptr, allocptr;             \
143          jb      9f;                                                     \          jb      9f;                                                     \
144          lea     1b, temp;               /* temp holds resume address */ \          call    via CSYM(saveregs);             \
145          movl    IMMED(maskval), mask;                                   \          jmp     via 1b;                         \
         jmp     via CSYM(saveregs);                                     \  
146   9:   9:
147    
148  /**********************************************************************/  /**********************************************************************/
# Line 181  Line 150 
150          ALIGN4          ALIGN4
151    
152  ML_CODE_HDR(sigh_return_a)  ML_CODE_HDR(sigh_return_a)
153          movl    mlstate_ptr, temp          movl    IMMED(ML_unit),stdlink
154            movl    IMMED(ML_unit),stdclos
155            movl    IMMED(ML_unit),pc
156          movl    IMMED(REQ_SIG_RETURN), request_w          movl    IMMED(REQ_SIG_RETURN), request_w
         movl    IMMED(RET_MASK), mask  
157          jmp     CSYM(set_request)          jmp     CSYM(set_request)
158    
159  /* sigh_resume:  /* sigh_resume:
# Line 192  Line 162 
162   */   */
163    
164  ENTRY(sigh_resume)  ENTRY(sigh_resume)
         movl    mlstate_ptr, temp  
165          movl    IMMED(REQ_SIG_RESUME), request_w          movl    IMMED(REQ_SIG_RESUME), request_w
166  /*      movl    IMMED(RET_MASK), mask          movl    IMMED(ML_unit),stdlink
167   */          movl    IMMED(ML_unit),stdclos
168          movl    IMMED(FUN_MASK), mask          movl    IMMED(ML_unit),pc
169          jmp     CSYM(set_request)          jmp     CSYM(set_request)
170    
171  /* pollh_return_a:  /* pollh_return_a:
172   * The return continuation for the ML poll handler.   * The return continuation for the ML poll handler.
173   */   */
174  ML_CODE_HDR(pollh_return_a)  ML_CODE_HDR(pollh_return_a)
         movl    mlstate_ptr, temp  
175          movl    IMMED(REQ_POLL_RETURN), request_w          movl    IMMED(REQ_POLL_RETURN), request_w
176          movl    IMMED(RET_MASK), mask          movl    IMMED(ML_unit),stdlink
177            movl    IMMED(ML_unit),stdclos
178            movl    IMMED(ML_unit),pc
179          jmp     CSYM(set_request)          jmp     CSYM(set_request)
180    
181  /* pollh_resume:  /* pollh_resume:
182   * Resume execution at the point at which a poll event occurred.   * Resume execution at the point at which a poll event occurred.
183   */   */
184  ENTRY(pollh_resume)  ENTRY(pollh_resume)
         movl    mlstate_ptr, temp  
185          movl    IMMED(REQ_POLL_RESUME), request_w          movl    IMMED(REQ_POLL_RESUME), request_w
186  /*      movl    IMMED(RET_MASK), mask          movl    IMMED(ML_unit),stdlink
187   */          movl    IMMED(ML_unit),stdclos
188          movl    IMMED(FUN_MASK), mask          movl    IMMED(ML_unit),pc
189          jmp     CSYM(set_request)          jmp     CSYM(set_request)
190    
191  ML_CODE_HDR(handle_a)  ML_CODE_HDR(handle_a)
         movl    mlstate_ptr, temp  
192          movl    IMMED(REQ_EXN), request_w          movl    IMMED(REQ_EXN), request_w
193          movl    IMMED(EXN_MASK), mask          MOVE    (stdlink,temp,pc)
194          jmp     CSYM(set_request)          jmp     CSYM(set_request)
195    
196  ML_CODE_HDR(return_a)  ML_CODE_HDR(return_a)
         movl    mlstate_ptr, temp  
197          movl    IMMED(REQ_RETURN), request_w          movl    IMMED(REQ_RETURN), request_w
198          movl    IMMED(RET_MASK), mask          movl    IMMED(ML_unit),stdlink
199            movl    IMMED(ML_unit),stdclos
200            movl    IMMED(ML_unit),pc
201          jmp     CSYM(set_request)          jmp     CSYM(set_request)
202    
203  /* Request a fault.  The floating point coprocessor must be reset  /* Request a fault.  The floating point coprocessor must be reset
# Line 239  Line 208 
208   */   */
209  ENTRY(request_fault)  ENTRY(request_fault)
210          call    CSYM(FPEEnable)          /* Doesn't trash any general regs. */          call    CSYM(FPEEnable)          /* Doesn't trash any general regs. */
         movl    mlstate_ptr, temp  
211          movl    IMMED(REQ_FAULT), request_w          movl    IMMED(REQ_FAULT), request_w
212          movl    IMMED(EXN_MASK), mask          MOVE    (stdlink,temp,pc)
213          jmp     CSYM(set_request)          jmp     CSYM(set_request)
214    
215  /* bind_cfun : (string * string) -> c_function  /* bind_cfun : (string * string) -> c_function
216   */   */
217  ML_CODE_HDR(bind_cfun_a)  ML_CODE_HDR(bind_cfun_a)
218          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
         movl    mlstate_ptr, temp  
219          movl    IMMED(REQ_BIND_CFUN), request_w          movl    IMMED(REQ_BIND_CFUN), request_w
         movl    IMMED(FUN_MASK), mask  
220          jmp     CSYM(set_request)          jmp     CSYM(set_request)
221    
222  ML_CODE_HDR(build_literals_a)  ML_CODE_HDR(build_literals_a)
223          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
         movl    mlstate_ptr, temp  
224          movl    IMMED(REQ_BUILD_LITERALS), request_w          movl    IMMED(REQ_BUILD_LITERALS), request_w
         movl    IMMED(FUN_MASK), mask  
225          jmp     CSYM(set_request)          jmp     CSYM(set_request)
226    
227  ML_CODE_HDR(callc_a)  ML_CODE_HDR(callc_a)
228          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
         movl    mlstate_ptr, temp  
229          movl    IMMED(REQ_CALLC), request_w          movl    IMMED(REQ_CALLC), request_w
230          movl    IMMED(FUN_MASK), mask          jmp     CSYM(set_request)
231    
232    ENTRY(saveregs)
233            popl    pc
234            movl    IMMED(REQ_GC), request_w
235          /* fall into set_request */          /* fall into set_request */
236    
237  ENTRY(set_request)  ENTRY(set_request)
238          /* temp holds mlstate_ptr, valid request in request_w  */          /* temp holds mlstate_ptr, valid request in request_w  */
239          /* Save registers */          /* Save registers */
240            movl    mlstate_ptr, temp
241          movl    allocptr,AllocPtrOffMSP(temp)          movl    allocptr,AllocPtrOffMSP(temp)
242          movl    stdarg,StdArgOffMSP(temp)          movl    stdarg,StdArgOffMSP(temp)
243          movl    stdcont,StdContOffMSP(temp)          movl    stdcont,StdContOffMSP(temp)
# Line 279  Line 247 
247          movl    VProcOffMSP(temp),temp2          movl    VProcOffMSP(temp),temp2
248          movl    IMMED(0), InMLOffVSP(temp2)          movl    IMMED(0), InMLOffVSP(temp2)
249    
250  #if (CALLEESAVE > 0)          movl    misc0, Misc0OffMSP(temp)
251          movl    misc1, MiscRegOffMSP(0)(temp)          movl    misc1, Misc1OffMSP(temp)
252  #if (CALLEESAVE > 1)          movl    misc2, Misc2OffMSP(temp)
         movl    misc2, MiscRegOffMSP(1)(temp)  
 #if (CALLEESAVE > 2)  
         movl    misc3, MiscRegOffMSP(2)(temp)  
253    
254          /* Save vregs before the stack frame is popped. */          /* Save vregs before the stack frame is popped. */
   
 #if (CALLEESAVE > 3)  
         MOVE(vreg0, temp2, MiscRegOffMSP(3)(temp))  
 #if (CALLEESAVE > 4)  
         MOVE(vreg1, temp2, MiscRegOffMSP(4)(temp))  
 #if (CALLEESAVE > 5)  
         MOVE(vreg2, temp2, MiscRegOffMSP(5)(temp))  
 #if (CALLEESAVE > 6)  
         MOVE(vreg3, temp2, MiscRegOffMSP(6)(temp))  
 #if (CALLEESAVE > 7)  
         MOVE(vreg4, temp2, MiscRegOffMSP(7)(temp))  
 #if (CALLEESAVE > 8)  
         MOVE(vreg5, temp2, MiscRegOffMSP(8)(temp))  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
   
         MOVE(tempmem, temp2, tempmem_w)  
         MOVE(tempmem2,temp2, tempmem2_w)  
255          MOVE(limitptr,temp2, LimitPtrOffMSP(temp))          MOVE(limitptr,temp2, LimitPtrOffMSP(temp))
256          MOVE(exncont, temp2, ExnPtrOffMSP(temp))          MOVE(exncont, temp2, ExnPtrOffMSP(temp))
257          MOVE(stdclos, temp2, StdClosOffMSP(temp))          MOVE(stdclos, temp2, StdClosOffMSP(temp))
258          MOVE(stdlink, temp2, LinkRegOffMSP(temp))          MOVE(stdlink, temp2, LinkRegOffMSP(temp))
259          MOVE(stdlink, temp2, PCOffMSP(temp))          MOVE(pc, temp2, PCOffMSP(temp))
260          MOVE(storeptr,temp2, StorePtrOffMSP(temp))          MOVE(storeptr,temp2, StorePtrOffMSP(temp))
261          MOVE(varptr,  temp2, VarPtrOffMSP(temp))          MOVE(varptr,  temp2, VarPtrOffMSP(temp))
         MOVE(mask,    temp2, MaskOffMSP(temp))  
   
         /* pseudo regs */  
         MOVE(PSEUDOREG_1,temp2,PseudoReg1OffMSP(temp))  
         MOVE(PSEUDOREG_2,temp2,PseudoReg2OffMSP(temp))  
262  #undef  temp2  #undef  temp2
263    
264          /* return val of function is request code */          /* return val of function is request code */
265          movl    request_w,creturn          movl    request_w,creturn
266    
267          /* Pop the stack frame and return to run_ml(). */          /* Pop the stack frame and return to run_ml(). */
268          addl    IMMED(ML_FRAME_SIZE), %esp          movl    SavedSP, %esp
269          CALLEE_RESTORE          CALLEE_RESTORE
270          ret          ret
271    
272          TEXT          TEXT
273          ALIGN4          ALIGN4
   
 ENTRY(saveregs)  
         pushl   temp                    /* Contains "resume" address. */  
         movl    ML_STATE_OFFSET+4(%esp), temp  
         popl    PCOffMSP(temp)  
   
 #ifdef SOFT_POLL  
         /* free some regs */  
         movl    misc1, MiscRegOffMSP(0)(temp)  
         movl    misc2, MiscRegOffMSP(1)(temp)  
 #define tmpR    misc1  
 #define pfreq   misc2  
         /* check if polling enabled (PollFreq > 0) */  
         lea     CSYM(_PollFreq0),pfreq          /* load contents of ref */  
         movl    4(pfreq),pfreq  
         shrl    IMMED(1),pfreq                  /* strip integer tag */  
         jz      check_for_gc                    /* go check for real gc */  
         cmpl    IMMED(0),InPollHandlerOffMSP(temp)    /* if we're in the handler */  
         jne     reset_limit                     /* ignore poll events */  
         lea     CSYM(_PollEvent0),tmpR          /* load contents of ref */  
         movl    4(tmpR),tmpR  
         shrl    IMMED(1),tmpR  
         jz      reset_limit                     /* check for poll event */  
         /* event occurred, so set ml_pollHandlerPending */  
         movl    IMMED(1),PollPendingOffMSP(temp)  
         jmp     do_gc           /* and handle event in the C runtime */  
   
 reset_limit:    /* reset limit ptr */  
         shll    IMMED(POLL_GRAIN_BITS),pfreq            /* mult by POLL_GRAIN_CPSI */  
         movl    allocptr,limitptr  
         addl    pfreq,limitptr  
 #undef  pfreq  
   
 check_for_gc:  
         /* ensure real limit is >= limit */  
         movl    RealLimitOffMSP(temp),tmpR  
         cmpl    limitptr,tmpR  
         ja      ok_limit  
         movl    tmpR,limitptr  
 ok_limit:  
         addl    IMMED(-4096),limitptr  
         cmpl    limitptr,allocptr  
         jge     do_gc                   /* gc *//* should be a common case */  
         addl    IMMED(4096),limitptr  
         /* since a signal also sets limitptr == allocptr to force a trap, */  
         /* we need to disambiguate poll-events/signals here */  
 #define vsp     misc2  
         movl    IMMED(0),tmpR  
         addl    PollPendingOffMSP(temp),tmpR  
         movl    VProcOffMSP(temp),vsp  
         addl    NPendingOffVSP(vsp),tmpR  
         addl    NPendingSysOffVSP(vsp),tmpR  
         jnz     do_gc  
 #undef  vsp  
   
 no_gc:  /* an uneventful poll check, back to ML */  
         movl    MiscRegOffMSP(0)(temp),misc1  
         movl    MiscRegOffMSP(1)(temp),misc2  
         movl    PCOffMSP(temp),temp  
         cmpl    limitptr, allocptr  
         jmpl    temp  
   
 do_gc:  
         /* limitptr saved below */  
   
 #undef tmpR  
 #endif /* SOFT_POLL */  
   
   
         /* Save registers. */  
         movl    allocptr, AllocPtrOffMSP(temp)  
         movl    stdarg, StdArgOffMSP(temp)  
         movl    stdcont, StdContOffMSP(temp)  
 #ifndef SOFT_POLL  /* misc1 & misc2 saved above for SOFT_POLL */  
         movl    misc1, MiscRegOffMSP(0)(temp)  
         movl    misc2, MiscRegOffMSP(1)(temp)  
 #endif  
         movl    misc3, MiscRegOffMSP(2)(temp)  
   
 #define temp2 allocptr  
   
         /* note that we have left ML code */  
         movl    VProcOffMSP(temp),temp2  
         movl    IMMED(0), InMLOffVSP(temp2)  
   
         /* vregs */  
 #ifdef VREGS  
         MOVE(vreg0, temp2, MiscRegOffMSP(3)(temp))  
         MOVE(vreg1, temp2, MiscRegOffMSP(4)(temp))  
         MOVE(vreg2, temp2, MiscRegOffMSP(5)(temp))  
         MOVE(vreg3, temp2, MiscRegOffMSP(6)(temp))  
         MOVE(vreg4, temp2, MiscRegOffMSP(7)(temp))  
         MOVE(vreg5, temp2, MiscRegOffMSP(8)(temp))  
         MOVE(vreg6, temp2, MiscRegOffMSP(9)(temp))  
         MOVE(vreg7, temp2, MiscRegOffMSP(10)(temp))  
         MOVE(vreg8, temp2, MiscRegOffMSP(11)(temp))  
         MOVE(vreg9, temp2, MiscRegOffMSP(12)(temp))  
         MOVE(vreg10, temp2, MiscRegOffMSP(13)(temp))  
         MOVE(vreg11, temp2, MiscRegOffMSP(14)(temp))  
 #endif  
   
         MOVE(tempmem, temp2, tempmem_w)  
         MOVE(tempmem2,temp2, tempmem2_w)  
         MOVE(exncont, temp2, ExnPtrOffMSP(temp))  
         MOVE(stdclos, temp2, StdClosOffMSP(temp))  
         MOVE(stdlink, temp2, LinkRegOffMSP(temp))  
         MOVE(storeptr,temp2, StorePtrOffMSP(temp))  
         MOVE(limitptr,temp2, LimitPtrOffMSP(temp))  
         MOVE(varptr,  temp2, VarPtrOffMSP(temp))  
         MOVE(mask,    temp2, MaskOffMSP(temp))  
   
         /* pseudo regs */  
         MOVE(PSEUDOREG_1,temp2,PseudoReg1OffMSP(temp))  
         MOVE(PSEUDOREG_2,temp2,PseudoReg2OffMSP(temp))  
 #undef  temp2  
   
         /* Pop the stack frame and return to run_ml(). */  
         movl    IMMED(REQ_GC),creturn  
         addl    IMMED(ML_FRAME_SIZE), %esp  
         CALLEE_RESTORE  
         ret  
   
274  ENTRY(restoreregs)  ENTRY(restoreregs)
275          movl    4(%esp), temp           /* Get argument (MLState ptr). */          movl    4(%esp), temp           /* Get argument (MLState ptr). */
276          CALLEE_SAVE          CALLEE_SAVE
277    
278            movl    %esp, SavedSP           /* save stack pointer */
279    
280            /* Align on 8 byte boundary. Assumes that the stack
281             * starts out being at least word aligned. But who knows ...
282             */
283            orl     IMMED(4), %esp
284            subl    IMMED(4), %esp          /* stack grows from high to low */
285    
286  #define temp2   %ebx  #define temp2   %ebx
287          /* Allocate and initialize the ML stack frame. */          /* Allocate and initialize the ML stack frame. */
288          subl    IMMED(ML_FRAME_SIZE), %esp          subl    IMMED(ML_FRAME_SIZE), %esp
         MOVE(   tempmem_w,  temp2, tempmem)  
         MOVE(   tempmem2_w, temp2, tempmem2)  
289          MOVE(   ExnPtrOffMSP(temp),  temp2, exncont)          MOVE(   ExnPtrOffMSP(temp),  temp2, exncont)
290          MOVE(   LimitPtrOffMSP(temp), temp2, limitptr)          MOVE(   LimitPtrOffMSP(temp), temp2, limitptr)
         MOVE(   StdClosOffMSP(temp),  temp2, stdclos)  
         MOVE(   LinkRegOffMSP(temp),  temp2, stdlink)  
291          MOVE(   StorePtrOffMSP(temp), temp2, storeptr)          MOVE(   StorePtrOffMSP(temp), temp2, storeptr)
292          MOVE(   VarPtrOffMSP(temp),   temp2, varptr)          MOVE(   VarPtrOffMSP(temp),   temp2, varptr)
         MOVE(   MaskOffMSP(temp),   temp2, mask)  
293          lea     CSYM(saveregs), temp2          lea     CSYM(saveregs), temp2
294          movl    temp2,start_gc          movl    temp2,start_gc
295          movl    temp, mlstate_ptr          movl    temp, mlstate_ptr
296    
297          /* vregs */          /* vregs */
298  #ifdef VREGS          MOVE    (LinkRegOffMSP(temp),  temp2, stdlink)
299          MOVE(MiscRegOffMSP(3)(temp),temp2,vreg0)          MOVE    (StdClosOffMSP(temp),  temp2, stdclos)
         MOVE(MiscRegOffMSP(4)(temp),temp2,vreg1)  
         MOVE(MiscRegOffMSP(5)(temp),temp2,vreg2)  
         MOVE(MiscRegOffMSP(6)(temp),temp2,vreg3)  
         MOVE(MiscRegOffMSP(7)(temp), temp2, vreg4)  
         MOVE(MiscRegOffMSP(8)(temp), temp2, vreg5)  
         MOVE(MiscRegOffMSP(9)(temp), temp2, vreg6)  
         MOVE(MiscRegOffMSP(10)(temp), temp2, vreg7)  
         MOVE(MiscRegOffMSP(11)(temp), temp2, vreg8)  
         MOVE(MiscRegOffMSP(12)(temp), temp2, vreg9)  
         MOVE(MiscRegOffMSP(13)(temp), temp2, vreg10)  
         MOVE(MiscRegOffMSP(14)(temp), temp2, vreg11)  
 #endif  
         /* pseudo regs */  
         MOVE(PseudoReg1OffMSP(temp),temp2,PSEUDOREG_1)  
         MOVE(PseudoReg2OffMSP(temp),temp2,PSEUDOREG_2)  
   
300  #undef  temp2  #undef  temp2
301    
302          /* Load ML registers. */          /* Load ML registers. */
303          movl    AllocPtrOffMSP(temp), allocptr          movl    AllocPtrOffMSP(temp), allocptr
304          movl    StdContOffMSP(temp), stdcont          movl    StdContOffMSP(temp), stdcont
305          movl    StdArgOffMSP(temp), stdarg          movl    StdArgOffMSP(temp), stdarg
306          movl    MiscRegOffMSP(0)(temp), misc1          movl    Misc0OffMSP(temp), misc0
307          movl    MiscRegOffMSP(1)(temp), misc2          movl    Misc1OffMSP(temp), misc1
308          movl    MiscRegOffMSP(2)(temp), misc3          movl    Misc2OffMSP(temp), misc2
309    
310          movl    %esp,CSYM(ML_X86Frame)  /* frame ptr for signal handler. */          movl    %esp,CSYM(ML_X86Frame)  /* frame ptr for signal handler. */
311    
# Line 531  Line 331 
331          popl    misc2          popl    misc2
332    
333  jmp_ml:  jmp_ml:
         movl    PCOffMSP(temp),temp  
334          cmpl    limitptr, allocptr          cmpl    limitptr, allocptr
335          jmpl    temp                  /* Jump to ML code. */          jmpl    PCOffMSP(temp)                /* Jump to ML code. */
336    
337    
338  pending:  pending:
339          cmpl    IMMED(0),InSigHandlerOffVSP(vsp)   /* Currently handling signal? */          cmpl    IMMED(0),InSigHandlerOffVSP(vsp)   /* Currently handling signal? */
340          jne     restore_and_jmp_ml          jne     restore_and_jmp_ml
341          movl    IMMED(1),HandlerPendingOffVSP(vsp) /* handler trap is now pending */          movl    IMMED(1),HandlerPendingOffVSP(vsp) /* handler trap is now pending */
342    
343          /* must restore here because limitptr is on stack */          /* must restore here because limitptr is on stack */ /* XXX */
344          popl    temp                    /* restore temp to msp */          popl    temp                    /* restore temp to msp */
345          popl    misc2          popl    misc2
346    
347          movl    allocptr,limitptr          movl    allocptr,limitptr
348          jmp     jmp_ml                  /* Jump to ML code. */          jmp     jmp_ml                  /* Jump to ML code. */
   
349  #undef  vsp  #undef  vsp
350    
351  /* ----------------------------------------------------------------------  /* ----------------------------------------------------------------------
352   * array : (int * 'a) -> 'a array   * array : (int * 'a) -> 'a array
353   * Allocate and initialize a new array.  This can cause GC.   * Allocate and initialize a new array.  This can cause GC.
354   */   */
   
355  ML_CODE_HDR(array_a)  ML_CODE_HDR(array_a)
356          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
357          movl    0(stdarg),temp               /* desired length into temp */          movl    0(stdarg),temp               /* temp := length in words */
358          sarl    IMMED(1),temp                        /* untagged */          sarl    IMMED(1),temp                /* temp := length untagged */
359          cmpl    IMMED(SMALL_OBJ_SZW),temp          cmpl    IMMED(SMALL_OBJ_SZW),temp    /* is this a small object */
360          jge     3f          jge     3f
361    
362  #define tmpreg  misc1  #define temp1 misc0
363          pushl   tmpreg  #define temp2 misc1
364            pushl   misc0                        /* save misc0 */
365          movl    temp,tmpreg                  /* build descriptor in tmpreg */          pushl   misc1                        /* save misc1 */
366          sall    IMMED(TAG_SHIFTW),tmpreg  
367          orl     IMMED(MAKE_TAG(DTAG_array)),tmpreg          movl    temp, temp1
368          movl    tmpreg,0(allocptr)           /* write descriptor */          sall    IMMED(TAG_SHIFTW),temp1      /* build descriptor in temp1 */
369            orl     IMMED(MAKE_TAG(DTAG_arr_data)),temp1
370            movl    temp1,0(allocptr)            /* store descriptor */
371            addl    IMMED(4),allocptr            /* allocptr++ */
372            movl    allocptr, temp1              /* temp1 := array data ptr */
373            movl    4(stdarg), temp2             /* temp2 := initial value */
374    2:
375            movl    temp2,0(allocptr)            /* initialize array */
376          addl    IMMED(4),allocptr          addl    IMMED(4),allocptr
377          movl    4(stdarg),tmpreg             /* initial values */          subl    IMMED(1), temp
         movl    allocptr,stdarg              /* stdarg gets ptr to new array */  
         sall    IMMED(2),temp                        /* length in bytes */  
         addl    allocptr,temp  
         xchgl   tmpreg,temp                  /* tmpreg is end of array */  
 2:                                           /* loop: */  
         stosl                                   /* 0(allocptr++) <- temp  */  
         cmpl    allocptr,tmpreg                 /* check for end of array */  
378          jne     2b          jne     2b
379    
380          popl    tmpreg          /* Allocate array header */
381  #undef  tmpreg          movl    IMMED(DESC_polyarr),0(allocptr) /* descriptor in temp */
382            addl    IMMED(4), allocptr           /* allocptr++ */
383            movl    0(stdarg), temp              /* temp := length */
384            movl    allocptr, stdarg             /* result = header addr */
385            movl    temp1, 0(allocptr)           /* store pointer to data */
386            movl    temp, 4(allocptr)            /* store length */
387            addl    IMMED(8), allocptr
388    
389            popl    misc1
390            popl    misc0
391          CONTINUE          CONTINUE
392    #undef  temp1
393    #undef  temp2
394  3:  3:
         movl    mlstate_ptr, temp  
395          movl    IMMED(REQ_ALLOC_ARRAY), request_w          movl    IMMED(REQ_ALLOC_ARRAY), request_w
396          movl    IMMED(FUN_MASK), mask          MOVE    (stdlink, temp, pc)
397          jmp     CSYM(set_request)          jmp     CSYM(set_request)
398    
399    
400  /* create_r : int -> realarray */  /* create_r : int -> realarray */
401  ML_CODE_HDR(create_r_a)  ML_CODE_HDR(create_r_a)
402          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
403          movl    stdarg,temp               /* desired length into temp */  #define temp1 misc0
404          sarl    IMMED(1),temp                     /* untagged */          push    misc0                   /* free temp1 */
405          shll    IMMED(1),temp                     /* size in words */          movl    stdarg,temp             /* temp := length */
406            sarl    IMMED(1),temp           /* temp := untagged length */
407            shll    IMMED(1),temp           /* temp := length in words */
408          cmpl    IMMED(SMALL_OBJ_SZW),temp          cmpl    IMMED(SMALL_OBJ_SZW),temp
409          jge     2f          jge     2f
410    
411  #define tmpreg  misc1          orl     IMMED(4),allocptr       /* align allocptr */
         pushl   tmpreg  
412    
413          shrl    IMMED(1),temp                     /* size in reals */          /* allocate the data object */
414          movl    temp,tmpreg                  /* build descriptor in tmpreg */          movl    temp, temp1
415          sall    IMMED(TAG_SHIFTW),tmpreg          shll    IMMED(TAG_SHIFTW),temp1 /* temp1 := descriptor */
416          orl     IMMED(MAKE_TAG(DTAG_realdarray)),tmpreg          orl     IMMED(MAKE_TAG(DTAG_raw64)),temp1
417          movl    tmpreg,0(allocptr)           /* write descriptor */          movl    temp1,0(allocptr)       /* store descriptor */
418          addl    IMMED(4),allocptr          addl    IMMED(4), allocptr      /* allocptr++ */
419          movl    allocptr,stdarg              /* stdarg gets ptr to new array */          movl    allocptr, temp1         /* temp1 := data object */
420          sall    IMMED(3),temp                        /* length in bytes */          shll    IMMED(2),temp           /* temp := length in bytes */
421          addl    temp,allocptr                /* adjust allocptr past array */          addl    temp, allocptr          /* allocptr += length */
422    
423            /* allocate the header object */
424            movl    IMMED(DESC_real64arr),0(allocptr)/* header descriptor */
425            addl    IMMED(4), allocptr      /* allocptr++ */
426            movl    temp1, 0(allocptr)      /* header data field */
427            movl    stdarg, 4(allocptr)     /* header length field */
428            movl    allocptr, stdarg                /* stdarg := header object */
429            addl    IMMED(8), allocptr      /* allocptr += 2 */
430    
431          popl    tmpreg          popl    misc0                   /* restore temp1 */
 #undef  tmpreg  
432          CONTINUE          CONTINUE
433    
434  2:  2:
435          movl    mlstate_ptr, temp          popl    misc0                   /* restore temp1 */
436          movl    IMMED(REQ_ALLOC_REALDARRAY), request_w          movl    IMMED(REQ_ALLOC_REALDARRAY), request_w
437          movl    IMMED(FUN_MASK), mask          MOVE    (stdlink, temp, pc)
438          jmp     CSYM(set_request)          jmp     CSYM(set_request)
439    #undef temp1
440    
441    
442  /* create_b : int -> bytearray */  /* create_b : int -> bytearray */
443  ML_CODE_HDR(create_b_a)  ML_CODE_HDR(create_b_a)
444          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
445          movl    stdarg,temp                  /* the length */          movl    stdarg,temp             /* temp := length(tagged int) */
446          sarl    IMMED(1),temp                        /* untagged */          sarl    IMMED(1),temp           /* temp := length(untagged) */
447          addl    IMMED(3),temp                        /* round */          addl    IMMED(3),temp
448          sarl    IMMED(2),temp                        /* to words */          sarl    IMMED(2),temp           /* temp := length(words) */
449          cmpl    IMMED(SMALL_OBJ_SZW),temp          cmpl    IMMED(SMALL_OBJ_SZW),temp /* small object? */
450            jmp     2f
451          jge     2f          jge     2f
452    
453  #define tmpreg  misc1  #define temp1   misc0
454          pushl   tmpreg          pushl   misc0
   
         movl    stdarg,tmpreg                /* build descriptor in tmpreg */  
         sarl    IMMED(1),tmpreg  
         sall    IMMED(TAG_SHIFTW),tmpreg  
         orl     IMMED(MAKE_TAG(DTAG_bytearray)),tmpreg  
         movl    tmpreg,0(allocptr)           /* write descriptor */  
         addl    IMMED(4),allocptr  
         movl    allocptr,stdarg              /* stdarg gets ptr to new str */  
         sall    IMMED(2),temp                        /* length in bytes (untagged) */  
         addl    temp,allocptr                /* allocptr += total length */  
   
         popl    tmpreg  
 #undef  tmpreg  
455    
456            /* allocate teh data object */
457            movl    temp, temp1             /* temp1 :=  descriptor */
458            shll    IMMED(TAG_SHIFTW),temp1
459            orl     IMMED(MAKE_TAG(DTAG_raw32)),temp1
460            movl    temp1, 0(allocptr)      /* store descriptor */
461            addl    IMMED(4), allocptr      /* allocptr++ */
462            movl    allocptr, temp1         /* temp1 := data object */
463            shll    IMMED(2), temp          /* temp := length in bytes */
464            addl    temp, allocptr          /* allocptr += length */
465    
466            /* allocate the header object */
467            movl    IMMED(DESC_word8arr), 0(allocptr)/* header descriptor */
468            addl    IMMED(4),allocptr       /* allocptr++ */
469            movl    temp1, 0(allocptr)      /* header data field */
470            movl    stdarg,4(allocptr)      /* header length field */
471            movl    allocptr, stdarg        /* stdarg := header object */
472            addl    IMMED(8),allocptr       /* allocptr := 2 */
473            popl    misc0
474          CONTINUE          CONTINUE
475    #undef  temp1
476  2:  2:
         movl    mlstate_ptr, temp  
477          movl    IMMED(REQ_ALLOC_BYTEARRAY), request_w          movl    IMMED(REQ_ALLOC_BYTEARRAY), request_w
478          movl    IMMED(FUN_MASK), mask          MOVE    (stdlink, temp, pc)
479          jmp     CSYM(set_request)          jmp     CSYM(set_request)
480    
481    
482  /* create_s : int -> string */  /* create_s : int -> string */
483  ML_CODE_HDR(create_s_a)  ML_CODE_HDR(create_s_a)
484          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
485          movl    stdarg,temp                  /* the length */          movl    stdarg,temp
486          sarl    IMMED(1),temp                        /* untagged */          sarl    IMMED(1),temp           /* temp := length(untagged) */
487          addl    IMMED(4),temp                        /* round */          addl    IMMED(4),temp
488          sarl    IMMED(2),temp                        /* to words */          sarl    IMMED(2),temp           /* temp := length(words) */
489          cmpl    IMMED(SMALL_OBJ_SZW),temp          cmpl    IMMED(SMALL_OBJ_SZW),temp
490          jge     2f          jge     2f
491    
492  #define tmpreg  misc1          pushl   misc0                   /* free misc0 */
493          pushl   tmpreg  #define temp1   misc0
   
         movl    stdarg,tmpreg                /* build descriptor in tmpreg */  
         sarl    IMMED(1),tmpreg  
         sall    IMMED(TAG_SHIFTW),tmpreg  
         orl     IMMED(MAKE_TAG(DTAG_string)),tmpreg  
         movl    tmpreg,0(allocptr)           /* write descriptor */  
         addl    IMMED(4),allocptr  
         movl    allocptr,stdarg              /* stdarg gets ptr to new str */  
         sall    IMMED(2),temp                        /* length in bytes (untagged) */  
         addl    temp,allocptr                /* allocptr += total length */  
         movl    IMMED(0),-4(allocptr)                /* for fast strcmp */  
494    
495          popl    tmpreg          movl    temp, temp1
496  #undef  tmpreg          shll    IMMED(TAG_SHIFTW),temp1 /* build descriptor in temp1 */
497            orl     IMMED(MAKE_TAG(DTAG_raw32)), temp1
498            movl    temp1, 0(allocptr)      /* store the data pointer */
499            addl    IMMED(4),allocptr       /* allocptr++ */
500    
501            movl    allocptr, temp1         /* temp1 := data object */
502            shll    IMMED(2),temp           /* temp := length in bytes */
503            addl    temp, allocptr          /* allocptr += length */
504            movl    IMMED(0),-4(allocptr)   /* zero out the last word */
505    
506            /* allocate the header object */
507            movl    IMMED(DESC_string), temp        /* header descriptor */
508            movl    temp, 0(allocptr)
509            addl    IMMED(4), allocptr      /* allocptr++ */
510            movl    temp1, 0(allocptr)      /* header data field */
511            movl    stdarg, 4(allocptr)     /* header length field */
512            movl    allocptr, stdarg        /* stdarg := header object */
513            addl    IMMED(8), allocptr
514    
515            popl    misc0                   /* restore misc0 */
516    #undef  temp1
517          CONTINUE          CONTINUE
518  2:  2:
         movl    mlstate_ptr, temp  
519          movl    IMMED(REQ_ALLOC_STRING), request_w          movl    IMMED(REQ_ALLOC_STRING), request_w
520          movl    IMMED(FUN_MASK), mask          MOVE    (stdlink, temp, pc)
521          jmp     CSYM(set_request)          jmp     CSYM(set_request)
522    
523  /* create_v_a : int * 'a list -> 'a vector  /* create_v_a : int * 'a list -> 'a vector
# Line 695  Line 525 
525   *      n.b. The frontend ensures that list cannot be nil.   *      n.b. The frontend ensures that list cannot be nil.
526   */   */
527  ML_CODE_HDR(create_v_a)  ML_CODE_HDR(create_v_a)
528          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
529          movl    0(stdarg),temp               /* desired length into temp */          pushl   misc0
530          sarl    IMMED(1),temp                        /* untagged */          pushl   misc1
531          cmpl    IMMED(SMALL_OBJ_SZW),temp  #define temp1   misc0
532    #define temp2   misc1
533            movl    0(stdarg),temp          /* temp := length(tagged) */
534            movl    temp, temp1
535            sarl    IMMED(1),temp1          /* temp1 := length(untagged) */
536            cmpl    IMMED(SMALL_OBJ_SZW),temp1
537          jge     3f          jge     3f
538    
 #define tmpreg  misc1  
         pushl   tmpreg  
539    
540          movl    temp,tmpreg                  /* build descriptor in tmpreg */          shll    IMMED(TAG_SHIFTW),temp1 /* build descriptor in temp1 */
541          sall    IMMED(TAG_SHIFTW),tmpreg          orl     IMMED(MAKE_TAG(DTAG_vec_data)),temp1
542          orl     IMMED(MAKE_TAG(DTAG_vector)),tmpreg          movl    temp1,0(allocptr)       /* store descriptor */
543          movl    tmpreg,0(allocptr)           /* write descriptor */          addl    IMMED(4),allocptr       /* allocptr++ */
544          addl    IMMED(4),allocptr          movl    4(stdarg),temp1         /* temp1 := list */
545          movl    4(stdarg),tmpreg             /* list of initial values */          movl    allocptr,stdarg         /* stdarg := vector */
546          movl    allocptr,stdarg              /* stdarg gets ptr to new array */  
547  2:                                           /* loop: */  2:
548          movl    0(tmpreg),temp                  /* temp <- hd(tmpreg) */          movl    0(temp1),temp2          /* temp2 := hd(temp1) */
549          stosl                                   /* 0(allocptr++) <- temp */          movl    temp2, 0(allocptr)      /* store word in vector */
550          movl    4(tmpreg),tmpreg                /* tmpreg <- tl(tmpreg) */          addl    IMMED(4), allocptr      /* allocptr++ */
551          cmpl    IMMED(ML_nil),tmpreg                    /* end of list */          movl    4(temp1),temp1          /* temp1 := tl(temp1) */
552            cmpl    IMMED(ML_nil),temp1     /* temp1 = nil? */
553          jne     2b          jne     2b
554    
555          popl    tmpreg          /* allocate header object */
556  #undef  tmpreg          movl    IMMED(DESC_polyvec),temp1/* descriptor in temp1 */
557            movl    temp1, 0(allocptr)      /* store descriptor */
558            addl    IMMED(4),allocptr       /* allocptr++ */
559            movl    stdarg, 0(allocptr)     /* header data field */
560            movl    temp, 4(allocptr)       /* header length */
561            movl    allocptr, stdarg        /* result = header object */
562            addl    IMMED(8),allocptr       /* allocptr += 2 */
563    
564            popl    misc1
565            popl    misc0
566          CONTINUE          CONTINUE
567  3:  3:
568          movl    mlstate_ptr, temp          popl    misc1
569            popl    misc0
570          movl    IMMED(REQ_ALLOC_VECTOR), request_w          movl    IMMED(REQ_ALLOC_VECTOR), request_w
571          movl    IMMED(FUN_MASK), mask          MOVE    (stdlink, temp, pc)
572          jmp     CSYM(set_request)          jmp     CSYM(set_request)
573    #undef  temp1
574    #undef  temp2
575    
576  /* try_lock: spin_lock -> bool.  /* try_lock: spin_lock -> bool.
577   * low-level test-and-set style primitive for mutual-exclusion among   * low-level test-and-set style primitive for mutual-exclusion among
# Line 791  Line 636 
636          orw     IMMED(0x023f), (%esp)   /* Set fields (see above). */          orw     IMMED(0x023f), (%esp)   /* Set fields (see above). */
637          fldcw   (%esp)          /* Install new control word. */          fldcw   (%esp)          /* Install new control word. */
638          addl    IMMED(4), %esp          addl    IMMED(4), %esp
         fldz                    /* Push a zero onto the register stack. */  
         fld     %st             /* Copy it 6 times. */  
         fld     %st  
         fld     %st  
         fld     %st  
         fld     %st  
         fld     %st  
639          ret          ret
640    
641  #if (defined(OPSYS_LINUX) || defined(OPSYS_SOLARIS))  #if (defined(OPSYS_LINUX) || defined(OPSYS_SOLARIS))
# Line 878  Line 716 
716   * caller-save, so we can use it here (see x86/x86.sml). */   * caller-save, so we can use it here (see x86/x86.sml). */
717    
718  ML_CODE_HDR(scalb_a)  ML_CODE_HDR(scalb_a)
719          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
720          pushl   4(stdarg)               /* Get copy of scalar. */          pushl   4(stdarg)               /* Get copy of scalar. */
721          sarl    IMMED(1), (%esp)                /* Untag it. */          sarl    IMMED(1), (%esp)                /* Untag it. */
722          fildl   (%esp)                  /* Load it ... */          fildl   (%esp)                  /* Load it ... */
723          fstp    %st(1)                  /* ... into 1st FP reg. */  /*      fstp    %st(1) */               /* ... into 1st FP reg. */
         addl    IMMED(4), %esp          /* Discard copy of scalar. */  
   
724          movl    (stdarg), temp          /* Get pointer to real. */          movl    (stdarg), temp          /* Get pointer to real. */
725          fldl    (temp)                  /* Load it into temp. */          fldl    (temp)                  /* Load it into temp. */
726    
# Line 894  Line 730 
730          addl    IMMED(4), allocptr              /* Allocate word for tag. */          addl    IMMED(4), allocptr              /* Allocate word for tag. */
731          movl    allocptr, stdarg        /* Return a pointer to the float. */          movl    allocptr, stdarg        /* Return a pointer to the float. */
732          addl    IMMED(8), allocptr              /* Allocate room for float. */          addl    IMMED(8), allocptr              /* Allocate room for float. */
733            fstpl   (%esp)
734            addl    IMMED(4), %esp          /* Discard copy of scalar. */
735    
736          CONTINUE          CONTINUE
737    
738  /* end of X86.prim.asm */  /* end of X86.prim.asm */

Legend:
Removed from v.29  
changed lines
  Added in v.243

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0