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/ALPHA32.prim.asm
ViewVC logotype

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

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

revision 223, Sat Apr 17 16:27:01 1999 UTC revision 239, Sat Apr 17 18:29:24 1999 UTC
# Line 12  Line 12 
12   *      $2         no           standard closure   *      $2         no           standard closure
13   *      $3         no           standard link register   *      $3         no           standard link register
14   *      $4         no           base address register   *      $4         no           base address register
15   *      $5         no           internal temporary (ptrtmp)   *      $5-$8      no           miscellaneous registers
  *      $6-$8      no           miscellaneous registers  
16   *      $9         yes          heap limit pointer   *      $9         yes          heap limit pointer
17   *      $10        yes          var pointer   *      $10        yes          var pointer
18   *      $11        yes          heap-limit comparison flag, and arith temporary   *      $11        yes          heap-limit comparison flag, and arith temporary
19   *      $12        yes          store list pointer  (not used)   *      $12        yes          store list pointer
20   *      $13        yes          allocation pointer   *      $13        yes          allocation pointer
21   *      $14        yes          exception continuation   *      $14        yes          exception continuation
22   *      $15        yes          instruction counter   *      $15        yes          miscellaneous register
23   *      $16-$26    no           miscellaneous registers   *      $16-$25    no           miscellaneous registers
24   *      $27        no           gc link register   *      $26        no           ml-pc
25     *      $27        no           miscellaneous register
26   *      $28        no           assembler temporary   *      $28        no           assembler temporary
27   *      $29         -           reserved for C (global pointer)   *      $29         -           reserved for C (global pointer)
28   *      $30         -           reserved for C (stack pointer)   *      $30         -           reserved for C (stack pointer)
29     *      $31         -           constant zero
30   */   */
31    
32  #include <regdef.h>  #include <regdef.h>
# Line 34  Line 35 
35  #include "ml-values.h"  #include "ml-values.h"
36  #include "tags.h"  #include "tags.h"
37  #include "ml-request.h"  #include "ml-request.h"
 #include "reg-mask.h"  
38  #include "ml-limits.h"  #include "ml-limits.h"
39  #include "mlstate-offsets.h"    /** this file is generated **/  #include "mlstate-offsets.h"    /** this file is generated **/
40    
# Line 43  Line 43 
43  #define STDCONT         $1      /* standard continuation (ml_cont)              */  #define STDCONT         $1      /* standard continuation (ml_cont)              */
44  #define STDCLOS         $2      /* standard closure (ml_closure)                */  #define STDCLOS         $2      /* standard closure (ml_closure)                */
45  #define STDLINK         $3      /* ptr to just-entered std function (ml_link)   */  #define STDLINK         $3      /* ptr to just-entered std function (ml_link)   */
46  #define BASEPTR         $4      /* pointer to base of code object - 4 */  #define MISCREG0        $5
47  #define PTRTMP          $5      /* internal temporary                           */  #define MISCREG1        $6
48  #define MISCREG0        $6  #define MISCREG2        $7
 #define MISCREG1        $7  
 #define MISCREG2        $8  
49  #define LIMITPTR        $9      /* end of heap - 4096  (ml_limitptr)            */  #define LIMITPTR        $9      /* end of heap - 4096  (ml_limitptr)            */
50  #define VARPTR          $10     /* per-thread var pointer (ml_varptr)           */  #define VARPTR          $10     /* per-thread var pointer (ml_varptr)           */
51  #define NEEDGC          $11     /* arith temp; also, heap-limit comparison flag */  #define NEEDGC          $11     /* arith temp; also, heap-limit comparison flag */
52  #define STOREPTR        $12     /* store pointer  (ml_storeptr)                 */  #define STOREPTR        $12     /* store pointer  (ml_storeptr)                 */
53  #define ALLOCPTR        $13     /* freespace pointer  (ml_allocptr)             */  #define ALLOCPTR        $13     /* freespace pointer  (ml_allocptr)             */
54  #define EXNCONT         $14     /* exception handler (ml_exncont)               */  #define EXNCONT         $14     /* exception handler (ml_exncont)               */
55  /* #define icountr              $15 */  #define PC              $26     /* address to return/goto in ML                 */
 #define MISCREG3        $16  
 #define MISCREG4        $17  
 #define MISCREG5        $18  
 #define MISCREG6        $19  
 #define MISCREG7        $20  
 #define MISCREG8        $21  
 #define MISCREG9        $22  
 #define MISCREG10       $23  
 #define MISCREG11       $24  
 #define MISCREG12       $25  
 #define GCLINK          $26     /* resumption point for restoreregs (ml_pc)     */  
 #define MISCREG13       $27  
56  /* assembler-temp $28                                                   */  /* assembler-temp $28                                                   */
57  /*      globalptr $29      reserved for C and assembler                 */  /*      globalptr $29      reserved for C and assembler                 */
58  /*       stackptr $30        stack pointer                              */  /*       stackptr $30        stack pointer                              */
# Line 79  Line 65 
65  #define ATMP2           $21  #define ATMP2           $21
66  #define ATMP3           $22  #define ATMP3           $22
67  #define ATMP4           $23  #define ATMP4           $23
68    #define PTRTMP          $24
 /* The root registers in the ML state vector have the following layout,  
  * where roots is guaranteed to be 8-byte aligned relative to the start  
  * of the ML state vector (see "ml-state.h"):  
  *  
  ******** THIS IS OUT OF DATE *******  
  *  
  *                      +-------------------+  
  *      roots:          |    ml_arg ($0)    |  
  *                      +-------------------+  
  *      roots+4:        |    ml_cont ($1)   |  
  *                      +-------------------+  
  *      roots+8:        |  ml_closure ($2)  |  
  *                      +-------------------+  
  *      roots+12:       |  ml_linkReg ($3)  |  
  *                      +-------------------+  
  *      roots+16:       |    ml_pc  ($27)   |  
  *                      +-------------------+  
  *      roots+20:       |  icount ($15)     |  
  *                      +-------------------+  
  *      roots+24:       | ($6,$7,$8,$16-26) |  
  *                      +-------------------+  
  *      roots+80:       |  ml_varReg ($10)  |  
  *                      +-------------------+  
  *      roots+84:       | ml_exncont ($14)  |  
  *                      +-------------------+  
  *      roots+88:       |  ml_baseReg ($4)  |  
  *                      +-------------------+  
  */  
   
69    
70  /* The  ML stack frame has the following layout (set up by restoreregs):  /* The  ML stack frame has the following layout (set up by restoreregs):
71   *                      +-------------------+   *                      +-------------------+
# Line 128  Line 85 
85   *                      +-------------------+   *                      +-------------------+
86   *      sp+80:          |     saved $29     |   *      sp+80:          |     saved $29     |
87   *                      +-------------------+   *                      +-------------------+
88   *      sp+72:          |     saved $26     |  is this needed??? - Ken Cline   *      sp+72:          |     saved $26     |
89   *                      +-------------------+   *                      +-------------------+
90   *      sp+64:          |     saved $15     |   *      sp+64:          |     saved $15     |
91   *                      +-------------------+   *                      +-------------------+
# Line 166  Line 123 
123  #  define ALLOCALIGN  #  define ALLOCALIGN
124  #endif  #endif
125    
 #if (CALLEESAVE > 0)  
126  #define CONTINUE                                                \  #define CONTINUE                                                \
127              ALLOCALIGN                                          \              ALLOCALIGN                                          \
128              cmplt       LIMITPTR,ALLOCPTR,NEEDGC;               \              cmplt       LIMITPTR,ALLOCPTR,NEEDGC;               \
129              jmp         (STDCONT);              jmp         (STDCONT);
 #else  
 #define CONTINUE                                                \  
             ldl         STDLINK,0(STDCONT);                     \  
             ALLOCALIGN                                          \  
             cmplt       LIMITPTR,ALLOCPTR,NEEDGC;               \  
             jmp         (STDLINK)  
 #endif  
130    
131  #define CHECKLIMIT(mask)                                        \  #define CHECKLIMIT                                      \
             mov         mask,PTRTMP;                            \  
132              beq         NEEDGC,3f;                              \              beq         NEEDGC,3f;                              \
133              mov         STDLINK,GCLINK;                 \              mov         STDLINK, PC;                    \
134              br          saveregs;                               \              br          saveregs;                               \
135           3:           3:
136    
# Line 199  Line 147 
147   * The return continuation for the ML signal handler.   * The return continuation for the ML signal handler.
148   */   */
149  ML_CODE_HDR(sigh_return_a)  ML_CODE_HDR(sigh_return_a)
         mov     RET_MASK,PTRTMP  
150          mov     REQ_SIG_RETURN,ATMP1          mov     REQ_SIG_RETURN,ATMP1
151            mov     ML_unit, STDLINK
152            mov     ML_unit, STDCLOS
153            mov     ML_unit, PC
154          br      set_request          br      set_request
155    
156    
# Line 209  Line 159 
159   * standard two-argument function, thus the closure is in ml_cont (%stdcont).   * standard two-argument function, thus the closure is in ml_cont (%stdcont).
160   */   */
161  ENTRY(sigh_resume)  ENTRY(sigh_resume)
         mov     RET_MASK,PTRTMP  
162          mov     REQ_SIG_RESUME,ATMP1          mov     REQ_SIG_RESUME,ATMP1
163            mov     ML_unit, STDLINK
164            mov     ML_unit, STDCLOS
165            mov     ML_unit, PC
166          br      set_request          br      set_request
167    
168  /* pollh_return_a  /* pollh_return_a
169   * The return continuation for the ML poll handler.   * The return continuation for the ML poll handler.
170   */   */
171  ML_CODE_HDR(pollh_return_a)  ML_CODE_HDR(pollh_return_a)
         mov     RET_MASK,PTRTMP  
172          mov     REQ_POLL_RESUME,ATMP1          mov     REQ_POLL_RESUME,ATMP1
173            mov     ML_unit, STDLINK
174            mov     ML_unit, STDCLOS
175            mov     ML_unit, PC
176          br      set_request          br      set_request
177    
178  /* pollh_resume:  /* pollh_resume:
179   * Resume execution at the point at which a poll event occurred.   * Resume execution at the point at which a poll event occurred.
180   */   */
181  ENTRY(pollh_resume)  ENTRY(pollh_resume)
         mov     RET_MASK,PTRTMP  
182          mov     REQ_POLL_RETURN,ATMP1          mov     REQ_POLL_RETURN,ATMP1
183            mov     ML_unit, STDLINK
184            mov     ML_unit, STDCLOS
185            mov     ML_unit, PC
186          br      set_request          br      set_request
187    
188  ML_CODE_HDR(handle_a)  ML_CODE_HDR(handle_a)
         mov     EXN_MASK,PTRTMP  
189          mov     REQ_EXN,ATMP1          mov     REQ_EXN,ATMP1
190            mov     STDLINK, PC
191          br      set_request          br      set_request
192    
193  ML_CODE_HDR(return_a)  ML_CODE_HDR(return_a)
         mov     RET_MASK,PTRTMP  
194          mov     REQ_RETURN,ATMP1          mov     REQ_RETURN,ATMP1
195            mov     ML_unit, STDLINK
196            mov     ML_unit, STDCLOS
197            mov     ML_unit, PC
198          br      set_request          br      set_request
199    
200  ENTRY(request_fault)  ENTRY(request_fault)
         mov     EXN_MASK,PTRTMP  
201          mov     REQ_FAULT,ATMP1          mov     REQ_FAULT,ATMP1
202            mov     STDLINK, PC
203          br      set_request          br      set_request
204    
205  /* bind_cfun : (string * string) -> c_function  /* bind_cfun : (string * string) -> c_function
206   */   */
207  ML_CODE_HDR(bind_cfun_a)  ML_CODE_HDR(bind_cfun_a)
208          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
         mov     FUN_MASK,PTRTMP  
209          mov     REQ_BIND_CFUN,ATMP1          mov     REQ_BIND_CFUN,ATMP1
210          br      set_request          br      set_request
211    
212  ML_CODE_HDR(build_literals_a)  ML_CODE_HDR(build_literals_a)
213          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
         mov     FUN_MASK,PTRTMP  
214          mov     REQ_BUILD_LITERALS,ATMP1          mov     REQ_BUILD_LITERALS,ATMP1
215          br      set_request          br      set_request
216    
217  ML_CODE_HDR(callc_a)  ML_CODE_HDR(callc_a)
218          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
         mov     FUN_MASK,PTRTMP  
219          mov     REQ_CALLC,ATMP1          mov     REQ_CALLC,ATMP1
220            br      set_request
221    
222            BEGIN_PROC(saveregs)
223    ENTRY(saveregs)
224            mov     REQ_GC,ATMP1
225    
226          /* fall through */          /* fall through */
227    
228  set_request:                    /* a quick return to run_ml(), ptrtmp holds */  set_request:
229                                  /* the request code, and atmp1 holds the  */          ldq     PTRTMP,MLSTATE_OFFSET(sp)       /* get the ML state ptr */
                                 /* live register mask. */  
   
         mov     PTRTMP,NEEDGC                   /* save the register mask */  
         ldq     PTRTMP,MLSTATE_OFFSET(sp)       /* get the ML state ptr from the stack */  
         stl     NEEDGC,MaskOffMSP(PTRTMP)  
230          ldq     NEEDGC,VProcOffMSP(PTRTMP)      /* use NEEDGC for VProcPtr */          ldq     NEEDGC,VProcOffMSP(PTRTMP)      /* use NEEDGC for VProcPtr */
231          stl     zero,InMLOffVSP(NEEDGC)         /* note that we have left ML */          stl     zero,InMLOffVSP(NEEDGC)         /* note that we have left ML */
232          stl     ALLOCPTR,AllocPtrOffMSP(PTRTMP)          stl     ALLOCPTR,AllocPtrOffMSP(PTRTMP)
233          stl     LIMITPTR,LimitPtrOffMSP(PTRTMP)          stl     LIMITPTR,LimitPtrOffMSP(PTRTMP)
234          stl     STOREPTR,StorePtrOffMSP(PTRTMP)          stl     STOREPTR,StorePtrOffMSP(PTRTMP)
235          stl     STDLINK,LinkRegOffMSP(PTRTMP)          stl     STDLINK,LinkRegOffMSP(PTRTMP)
236          stl     STDLINK,PCOffMSP(PTRTMP)        /* address of called function */          stl     PC,PCOffMSP(PTRTMP)
237          stl     STDARG,StdArgOffMSP(PTRTMP)          stl     STDARG,StdArgOffMSP(PTRTMP)
238          stl     STDCLOS,StdClosOffMSP(PTRTMP)          stl     STDCLOS,StdClosOffMSP(PTRTMP)
239          stl     STDCONT,StdContOffMSP(PTRTMP)          stl     STDCONT,StdContOffMSP(PTRTMP)
240          stl     VARPTR,VarPtrOffMSP(PTRTMP)          stl     VARPTR,VarPtrOffMSP(PTRTMP)
241          stl     EXNCONT,ExnPtrOffMSP(PTRTMP)          stl     EXNCONT,ExnPtrOffMSP(PTRTMP)
242          mov     ATMP1,CRESULT                           /* return request */          mov     ATMP1,CRESULT                           /* return request */
243  #if (CALLEESAVE > 0)          stl     MISCREG0,Misc0OffMSP(PTRTMP)
244          stl     MISCREG0,MiscRegOffMSP(0)(PTRTMP)          stl     MISCREG1,Misc1OffMSP(PTRTMP)
245  #if (CALLEESAVE > 1)          stl     MISCREG2,Misc2OffMSP(PTRTMP)
246          stl     MISCREG1,MiscRegOffMSP(1)(PTRTMP)          /* fall through */
247  #if (CALLEESAVE > 2)          .end saveregs
248          stl     MISCREG2,MiscRegOffMSP(2)(PTRTMP)  
 #if (CALLEESAVE > 3)  
         stl     MISCREG3,MiscRegOffMSP(3)(PTRTMP)  
 #if (CALLEESAVE > 4)  
         stl     MISCREG4,MiscRegOffMSP(4)(PTRTMP)  
 #if (CALLEESAVE > 5)  
         stl     MISCREG5,MiscRegOffMSP(5)(PTRTMP)  
 #if (CALLEESAVE > 6)  
         stl     MISCREG6,MiscRegOffMSP(6)(PTRTMP)  
 #if (CALLEESAVE > 7)  
         stl     MISCREG7,MiscRegOffMSP(7)(PTRTMP)  
 #if (CALLEESAVE > 8)  
         stl     MISCREG8,MiscRegOffMSP(8)(PTRTMP)  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
 #endif  
249                                          /* restore callee-save C registers */                                          /* restore callee-save C registers */
250  restore_c_regs:  restore_c_regs:
         ldl     ATMP1,PSEUDOREG_OFFSET(sp)  
         stl     ATMP1,PseudoReg1OffMSP(PTRTMP)  
         ldl     ATMP1,PSEUDOREG_OFFSET+4(sp)  
         stl     ATMP1,PseudoReg2OffMSP(PTRTMP)  
251          ldq     $30,REGSAVE_OFFSET+72(sp)          ldq     $30,REGSAVE_OFFSET+72(sp)
252          ldq     $29,REGSAVE_OFFSET+64(sp)          ldq     $29,REGSAVE_OFFSET+64(sp)
253          ldq     $26,REGSAVE_OFFSET+56(sp)          ldq     $26,REGSAVE_OFFSET+56(sp)
# Line 330  Line 261 
261          addq    sp,ML_FRAMESIZE                         /* discard the stack frame */          addq    sp,ML_FRAMESIZE                         /* discard the stack frame */
262          jmp     ($26)                           /* return to run_ml() */          jmp     ($26)                           /* return to run_ml() */
263    
         BEGIN_PROC(saveregs)  
 ENTRY(saveregs)  
         mov     PTRTMP,NEEDGC               /* save the register mask */  
         ldq     PTRTMP,MLSTATE_OFFSET(sp)   /* use ptrtmp to access ML state */  
         stl     NEEDGC,MaskOffMSP(PTRTMP)  
 1:  
         ldq     NEEDGC,VProcOffMSP(PTRTMP)  /* use NEEDGC for VProcPtr */  
         stl     zero,InMLOffVSP(NEEDGC)     /* note that we have left ML */  
         subl    BASEPTR,32764               /* adjust baseReg */  
         stl     ALLOCPTR,AllocPtrOffMSP(PTRTMP)  
         stl     LIMITPTR,LimitPtrOffMSP(PTRTMP)  
         stl     STOREPTR,StorePtrOffMSP(PTRTMP)  
         stl     STDARG,StdArgOffMSP(PTRTMP)  
         stl     STDCONT,StdContOffMSP(PTRTMP)  
         stl     STDCLOS,StdClosOffMSP(PTRTMP)  
         stl     GCLINK,PCOffMSP(PTRTMP)  
         stl     EXNCONT,ExnPtrOffMSP(PTRTMP)  
         stl     MISCREG0,MiscRegOffMSP(0)(PTRTMP)       /* save misc. roots */  
         stl     MISCREG1,MiscRegOffMSP(1)(PTRTMP)  
         stl     MISCREG2,MiscRegOffMSP(2)(PTRTMP)  
         stl     MISCREG3,MiscRegOffMSP(3)(PTRTMP)  
         stl     MISCREG4,MiscRegOffMSP(4)(PTRTMP)  
         stl     MISCREG5,MiscRegOffMSP(5)(PTRTMP)  
         stl     MISCREG6,MiscRegOffMSP(6)(PTRTMP)  
         stl     MISCREG7,MiscRegOffMSP(7)(PTRTMP)  
         stl     MISCREG8,MiscRegOffMSP(8)(PTRTMP)  
         stl     MISCREG9,MiscRegOffMSP(9)(PTRTMP)  
         stl     MISCREG10,MiscRegOffMSP(10)(PTRTMP)  
         stl     MISCREG11,MiscRegOffMSP(11)(PTRTMP)  
         stl     MISCREG12,MiscRegOffMSP(12)(PTRTMP)  
         stl     MISCREG13,MiscRegOffMSP(13)(PTRTMP)  
         stl     STDLINK,LinkRegOffMSP(PTRTMP)  
         stl     BASEPTR,BasePtrOffMSP(PTRTMP)           /* base reg */  
         stl     VARPTR,VarPtrOffMSP(PTRTMP)  
         mov     REQ_GC,CRESULT  
         br      restore_c_regs  
         .end    saveregs  
   
264    
265          BEGIN_PROC(restoreregs)          BEGIN_PROC(restoreregs)
266  ENTRY(restoreregs)  ENTRY(restoreregs)
# Line 394  Line 287 
287          stq     $9,REGSAVE_OFFSET(sp)          stq     $9,REGSAVE_OFFSET(sp)
288          mov     CARG0,PTRTMP                    /* put MLState ptr in ptrtmp */          mov     CARG0,PTRTMP                    /* put MLState ptr in ptrtmp */
289    
         ldl     ATMP1,PseudoReg1OffMSP(PTRTMP)  
         stl     ATMP1,PSEUDOREG_OFFSET(sp)  
         ldl     ATMP1,PseudoReg2OffMSP(PTRTMP)  
         stl     ATMP1,PSEUDOREG_OFFSET+4(sp)  
   
290          ldl     ALLOCPTR,AllocPtrOffMSP(PTRTMP)          ldl     ALLOCPTR,AllocPtrOffMSP(PTRTMP)
291          ldl     LIMITPTR,LimitPtrOffMSP(PTRTMP)          ldl     LIMITPTR,LimitPtrOffMSP(PTRTMP)
292          ldl     STOREPTR,StorePtrOffMSP(PTRTMP)          ldl     STOREPTR,StorePtrOffMSP(PTRTMP)
# Line 410  Line 298 
298          ldl     STDCONT,StdContOffMSP(PTRTMP)          ldl     STDCONT,StdContOffMSP(PTRTMP)
299          ldl     STDCLOS,StdClosOffMSP(PTRTMP)          ldl     STDCLOS,StdClosOffMSP(PTRTMP)
300          ldl     EXNCONT,ExnPtrOffMSP(PTRTMP)          ldl     EXNCONT,ExnPtrOffMSP(PTRTMP)
301          ldl     MISCREG0,MiscRegOffMSP(0)(PTRTMP)          ldl     MISCREG0,Misc0OffMSP(PTRTMP)
302          ldl     MISCREG1,MiscRegOffMSP(1)(PTRTMP)          ldl     MISCREG1,Misc1OffMSP(PTRTMP)
303          ldl     MISCREG2,MiscRegOffMSP(2)(PTRTMP)          ldl     MISCREG2,Misc2OffMSP(PTRTMP)
         ldl     MISCREG3,MiscRegOffMSP(3)(PTRTMP)  
         ldl     MISCREG4,MiscRegOffMSP(4)(PTRTMP)  
         ldl     MISCREG5,MiscRegOffMSP(5)(PTRTMP)  
         ldl     MISCREG6,MiscRegOffMSP(6)(PTRTMP)  
         ldl     MISCREG7,MiscRegOffMSP(7)(PTRTMP)  
         ldl     MISCREG8,MiscRegOffMSP(8)(PTRTMP)  
         ldl     MISCREG9,MiscRegOffMSP(9)(PTRTMP)  
         ldl     MISCREG10,MiscRegOffMSP(10)(PTRTMP)  
         ldl     MISCREG11,MiscRegOffMSP(11)(PTRTMP)  
         ldl     MISCREG12,MiscRegOffMSP(12)(PTRTMP)  
         ldl     MISCREG13,MiscRegOffMSP(13)(PTRTMP)  
304          ldl     STDLINK,LinkRegOffMSP(PTRTMP)          ldl     STDLINK,LinkRegOffMSP(PTRTMP)
305            ldl     PC,PCOffMSP(PTRTMP)
306          ldl     VARPTR,VarPtrOffMSP(PTRTMP)          ldl     VARPTR,VarPtrOffMSP(PTRTMP)
         ldl     BASEPTR,BasePtrOffMSP(PTRTMP)  
         addl    BASEPTR,32764                   /* adjust baseReg */  
         ldl     GCLINK,PCOffMSP(PTRTMP)  
307                                                  /* check for pending signals */                                                  /* check for pending signals */
308          ldl     PTRTMP,NPendingSysOffVSP(NEEDGC)          ldl     PTRTMP,NPendingSysOffVSP(NEEDGC)
309  .set    noat  .set    noat
# Line 441  Line 316 
316  ENTRY(ml_go)  ENTRY(ml_go)
317          ALLOCALIGN          ALLOCALIGN
318          cmplt   LIMITPTR,ALLOCPTR,NEEDGC          cmplt   LIMITPTR,ALLOCPTR,NEEDGC
319          jmp     (GCLINK)                        /* jump to ML code */          jmp     (PC)                    /* jump/return to ML code */
320          .end    ml_go          .end    ml_go
321    
322  pending_sigs:   /* there are pending signals */  pending_sigs:   /* there are pending signals */
# Line 502  Line 377 
377   * Allocate and initialize a new array.  This can cause GC.   * Allocate and initialize a new array.  This can cause GC.
378   */   */
379  ML_CODE_HDR(array_a)  ML_CODE_HDR(array_a)
380          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
381    
382          ldl     ATMP1,0(STDARG)             /* tmp1 := length in words */          ldl     ATMP1,0(STDARG)             /* tmp1 := length in words */
383          sra     ATMP1,1,ATMP2               /* tmp2 := length (untagged) */          sra     ATMP1,1,ATMP2               /* tmp2 := length (untagged) */
# Line 532  Line 407 
407          CONTINUE          CONTINUE
408    
409  2:      /* off-line allocation of big arrays */  2:      /* off-line allocation of big arrays */
         mov     FUN_MASK,PTRTMP  
410          mov     REQ_ALLOC_ARRAY,ATMP1          mov     REQ_ALLOC_ARRAY,ATMP1
411            mov     STDLINK, PC
412          br      set_request          br      set_request
413    
414  /* create_r : int -> realarray  /* create_r : int -> realarray
415   * Create a new realarray.   * Create a new realarray.
416   */   */
417  ML_CODE_HDR(create_r_a)  ML_CODE_HDR(create_r_a)
418          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
419    
420          sra     STDARG,1,ATMP2              /* atmp2 = length (untagged int) */          sra     STDARG,1,ATMP2              /* atmp2 = length (untagged int) */
421          sll     ATMP2,1,ATMP2               /* atmp2 = length in words */          sll     ATMP2,1,ATMP2               /* atmp2 = length in words */
# Line 569  Line 444 
444          CONTINUE          CONTINUE
445    
446  1:      /* off-line allocation of big realarrays */  1:      /* off-line allocation of big realarrays */
         mov     FUN_MASK,PTRTMP  
447          mov     REQ_ALLOC_REALDARRAY,ATMP1          mov     REQ_ALLOC_REALDARRAY,ATMP1
448            mov     STDLINK, PC
449          br      set_request          br      set_request
450    
451  /* create_b : int -> bytearray  /* create_b : int -> bytearray
452   * Create a bytearray of the given length.   * Create a bytearray of the given length.
453   */   */
454  ML_CODE_HDR(create_b_a)  ML_CODE_HDR(create_b_a)
455          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
456    
457          sra     STDARG,1,ATMP2            /* atmp2 = length (untagged int) */          sra     STDARG,1,ATMP2            /* atmp2 = length (untagged int) */
458          addq    ATMP2,3,ATMP2             /* atmp2 = length in words */          addq    ATMP2,3,ATMP2             /* atmp2 = length in words */
# Line 602  Line 477 
477          addq    ALLOCPTR,8                /* allocptr += 2 */          addq    ALLOCPTR,8                /* allocptr += 2 */
478          CONTINUE          CONTINUE
479  1:                                      /* off-line allocation of big bytearrays */  1:                                      /* off-line allocation of big bytearrays */
         mov     FUN_MASK,PTRTMP  
480          mov     REQ_ALLOC_BYTEARRAY,ATMP1          mov     REQ_ALLOC_BYTEARRAY,ATMP1
481            mov     STDLINK, PC
482          br      set_request          br      set_request
483    
484  /* create_s : int -> string  /* create_s : int -> string
485   * Create a string of the given length (assume length >0).   * Create a string of the given length (assume length >0).
486   */   */
487  ML_CODE_HDR(create_s_a)  ML_CODE_HDR(create_s_a)
488          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
489    
490          sra     STDARG,1,ATMP2                  /* tmp2 = length (untagged int) */          sra     STDARG,1,ATMP2                  /* tmp2 = length (untagged int) */
491          addq    ATMP2,4,ATMP2                   /* atmp2 = length in words */          addq    ATMP2,4,ATMP2                   /* atmp2 = length in words */
# Line 636  Line 511 
511          addq    ALLOCPTR,8          addq    ALLOCPTR,8
512          CONTINUE          CONTINUE
513  1:                                      /* off-line allocation of big strings */  1:                                      /* off-line allocation of big strings */
         mov     FUN_MASK,PTRTMP  
514          mov     REQ_ALLOC_STRING,ATMP1          mov     REQ_ALLOC_STRING,ATMP1
515            mov     STDLINK, PC
516          br      set_request          br      set_request
517    
518  /* create_v_a : (int * 'a list) -> 'a vector  /* create_v_a : (int * 'a list) -> 'a vector
# Line 645  Line 520 
520   * NOTE: the front-end ensures that list cannot be nil.   * NOTE: the front-end ensures that list cannot be nil.
521   */   */
522  ML_CODE_HDR(create_v_a)  ML_CODE_HDR(create_v_a)
523          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
524    
525          ldl     ATMP1,0(STDARG)         /* tmp1 := length (tagged int) */          ldl     ATMP1,0(STDARG)         /* tmp1 := length (tagged int) */
526          sra     ATMP1,1,ATMP2           /* tmp2 := length (untagged) */          sra     ATMP1,1,ATMP2           /* tmp2 := length (untagged) */
# Line 676  Line 551 
551          CONTINUE          CONTINUE
552    
553  1:      /* off-line allocation for large vectors */  1:      /* off-line allocation for large vectors */
         mov     FUN_MASK,PTRTMP  
554          mov     REQ_ALLOC_VECTOR,ATMP1          mov     REQ_ALLOC_VECTOR,ATMP1
555            mov     STDLINK, PC
556          br      set_request          br      set_request
557    
558  /* Floating exceptions raised (assuming ROP's are never passed to functions):  /* Floating exceptions raised (assuming ROP's are never passed to functions):
# Line 766  Line 641 
641          CONTINUE          CONTINUE
642    
643  ML_CODE_HDR(scalb_a)  ML_CODE_HDR(scalb_a)
644          CHECKLIMIT(FUN_MASK)          CHECKLIMIT
645          ldl     PTRTMP,0(STDARG)        /* address of float */          ldl     PTRTMP,0(STDARG)        /* address of float */
646          ldq     ATMP2,0(PTRTMP) /* get float */          ldq     ATMP2,0(PTRTMP) /* get float */
647          ldl     ATMP1,4(STDARG) /* get tagged n */          ldl     ATMP1,4(STDARG) /* get tagged n */

Legend:
Removed from v.223  
changed lines
  Added in v.239

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