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/branches/SMLNJ/src/runtime/mach-dep/SPARC.prim.asm
ViewVC logotype

Diff of /sml/branches/SMLNJ/src/runtime/mach-dep/SPARC.prim.asm

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

revision 138, Mon Sep 7 21:11:35 1998 UTC revision 139, Mon Sep 7 21:11:35 1998 UTC
# Line 60  Line 60 
60   *                +-------------------+   *                +-------------------+
61   *      roots+72: |        %i4        |   *      roots+72: |        %i4        |
62   *                +-------------------+   *                +-------------------+
63     *      roots+76: |        %o3-%o4    |
64     *                +-------------------+
65   */   */
66    
67    
# Line 104  Line 106 
106  #define MISCREG10 %l6  #define MISCREG10 %l6
107  #define MISCREG11 %l7  #define MISCREG11 %l7
108  #define MISCREG12 %i4  #define MISCREG12 %i4
109  #define   TMPREG1 %o2  #define MISCREG13 %o3
110  #define   TMPREG2 %o3  #define MISCREG14 %o4
111    #define   ASMTMP  %o2   /* assembly temporary used in ML */
112    #define   MASKREG %o5   /* also used to pass register mask to g.c. */
113    #define   TMPREG1 ASMTMP
114    #define   TMPREG2 %o3   /* %o3-%o4 are part of GC root set; use with care!!! */
115  #define   TMPREG3 %o4  #define   TMPREG3 %o4
116  #define   TMPREG4 %o5   /* also used to pass register mask to g.c. */  #define   TMPREG4 MASKREG
117  #define    GCLINK %o7   /* link register for return from g.c.  (ml_pc) */  #define    GCLINK %o7   /* link register for return from g.c.  (ml_pc) */
118    
119  /* %o2 and %o3 are also used as for multiply and divide */  /* %o2 and %o3 are also used as for multiply and divide */
# Line 119  Line 125 
125   *   *
126   * The ML stack frame has the following layout (set up by restoreregs):   * The ML stack frame has the following layout (set up by restoreregs):
127   *   *
128   *                      +-------------------+   *                      |                   |
129   *      %fp = %sp+112:  |  empty            |   *      %fp = %sp+112:  |  spill area       |
130   *                      +-------------------+   *                      +-------------------+
131   *      %sp+108:        |   pseudo reg 2    |   *      %sp+108:        |   pseudo reg 2    |
132   *                      +-------------------+   *                      +-------------------+
# Line 154  Line 160 
160   * Note that this must be a multiple of 8 bytes.  The size of the   * Note that this must be a multiple of 8 bytes.  The size of the
161   * stack frame is:   * stack frame is:
162   */   */
163  #define ML_FRAMESIZE (WINDOWSIZE+48)  /* ##define ML_FRAMESIZE (WINDOWSIZE+48+4096) */
164    #define ML_FRAMESIZE 4096
165    
166  #define MUL_OFFSET 72  #define MUL_OFFSET 72
167  #define DIV_OFFSET 76  #define DIV_OFFSET 76
# Line 177  Line 184 
184  #endif  #endif
185    
186  #define CHECKLIMIT(mask,label)                  \  #define CHECKLIMIT(mask,label)                  \
187                  bl      label;                  \                  blu     label;                  \
188                  nop;                            \                  nop;                            \
189                  set     mask,TMPREG4;           \                  set     mask,MASKREG;           \
190                  mov     STDLINK,GCLINK;         \                  mov     STDLINK,GCLINK;         \
191                  ba      CSYM(saveregs);         \                  ba      CSYM(saveregs);         \
192                  nop;                            \                  nop;                            \
# Line 192  Line 199 
199   * The return continuation for the ML signal handler.   * The return continuation for the ML signal handler.
200   */   */
201  ML_CODE_HDR(sigh_return_a)  ML_CODE_HDR(sigh_return_a)
202          set     RET_MASK,TMPREG4          set     RET_MASK,MASKREG
203          ba      set_request          ba      set_request
204          set     REQ_SIG_RETURN,TMPREG3  /* (delay slot) */          set     REQ_SIG_RETURN,TMPREG3  /* (delay slot) */
205    
# Line 201  Line 208 
208   * standard two-argument function, thus the closure is in ml_cont (stdcont).   * standard two-argument function, thus the closure is in ml_cont (stdcont).
209   */   */
210  ENTRY(sigh_resume)  ENTRY(sigh_resume)
211          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
212          ba      set_request          ba      set_request
213          set     REQ_SIG_RESUME,TMPREG3  /* (delay slot) */          set     REQ_SIG_RESUME,TMPREG3  /* (delay slot) */
214    
# Line 209  Line 216 
216   * The return continuation for the ML poll handler.   * The return continuation for the ML poll handler.
217   */   */
218  ML_CODE_HDR(pollh_return_a)  ML_CODE_HDR(pollh_return_a)
219          set     RET_MASK,TMPREG4          set     RET_MASK,MASKREG
220          ba      set_request          ba      set_request
221          set     REQ_POLL_RETURN,TMPREG3 /* (delay slot) */          set     REQ_POLL_RETURN,TMPREG3 /* (delay slot) */
222    
# Line 217  Line 224 
224   * Resume execution at the point at which a poll event occurred.   * Resume execution at the point at which a poll event occurred.
225   */   */
226  ENTRY(pollh_resume)  ENTRY(pollh_resume)
227          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
228          ba      set_request          ba      set_request
229          set     REQ_POLL_RESUME,TMPREG3 /* (delay slot) */          set     REQ_POLL_RESUME,TMPREG3 /* (delay slot) */
230    
231  ML_CODE_HDR(handle_a)  ML_CODE_HDR(handle_a)
232          set     EXN_MASK,TMPREG4          set     EXN_MASK,MASKREG
233          ba      set_request          ba      set_request
234          set     REQ_EXN,TMPREG3         /* (delay slot) */          set     REQ_EXN,TMPREG3         /* (delay slot) */
235    
236  ML_CODE_HDR(return_a)  ML_CODE_HDR(return_a)
237          set     RET_MASK,TMPREG4          set     RET_MASK,MASKREG
238          ba      set_request          ba      set_request
239          set     REQ_RETURN,TMPREG3              /* (delay slot) */          set     REQ_RETURN,TMPREG3              /* (delay slot) */
240    
241  ENTRY(request_fault)  ENTRY(request_fault)
242          set     EXN_MASK,TMPREG4          set     EXN_MASK,MASKREG
243          ba      set_request          ba      set_request
244          set     REQ_FAULT,TMPREG3               /* (delay slot) */          set     REQ_FAULT,TMPREG3               /* (delay slot) */
245    
# Line 240  Line 247 
247   */   */
248  ML_CODE_HDR(bind_cfun_a)  ML_CODE_HDR(bind_cfun_a)
249          CHECKLIMIT(FUN_MASK,bind_cfun_v_limit)          CHECKLIMIT(FUN_MASK,bind_cfun_v_limit)
250          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
251          ba      set_request          ba      set_request
252          set     REQ_BIND_CFUN,TMPREG3           /* (delay slot) */          set     REQ_BIND_CFUN,TMPREG3           /* (delay slot) */
253    
254  ML_CODE_HDR(build_literals_a)  ML_CODE_HDR(build_literals_a)
255          CHECKLIMIT(FUN_MASK,build_literals_a_limit)          CHECKLIMIT(FUN_MASK,build_literals_a_limit)
256          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
257          ba      set_request          ba      set_request
258          set     REQ_BUILD_LITERALS,TMPREG3      /* (delay slot) */          set     REQ_BUILD_LITERALS,TMPREG3      /* (delay slot) */
259    
260  ML_CODE_HDR(callc_a)  ML_CODE_HDR(callc_a)
261          CHECKLIMIT(FUN_MASK,callc_a_limit)          CHECKLIMIT(FUN_MASK,callc_a_limit)
262          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
263          set     REQ_CALLC,TMPREG3          set     REQ_CALLC,TMPREG3
264          /* fall through */          /* fall through */
265    
# Line 260  Line 267 
267                                          /* the request code. */                                          /* the request code. */
268          ld      [%sp+MLSTATE_OFFSET],TMPREG2    /* get MLState ptr from stack */          ld      [%sp+MLSTATE_OFFSET],TMPREG2    /* get MLState ptr from stack */
269          ld      [TMPREG2+VProcOffMSP],TMPREG1   /* TMPREG1 := VProcPtr */          ld      [TMPREG2+VProcOffMSP],TMPREG1   /* TMPREG1 := VProcPtr */
270          st      TMPREG4,[TMPREG2+MaskOffMSP]    /* save the register mask */          st      MASKREG,[TMPREG2+MaskOffMSP]    /* save the register mask */
271          st      %g0,[TMPREG1+InMLOffVSP]        /* note that we have left ML code */          st      %g0,[TMPREG1+InMLOffVSP]        /* note that we have left ML code */
272          st      ALLOCPTR,[TMPREG2+AllocPtrOffMSP]          st      ALLOCPTR,[TMPREG2+AllocPtrOffMSP]
273          st      STOREPTR,[TMPREG2+StorePtrOffMSP]/* save storeptr */          st      STOREPTR,[TMPREG2+StorePtrOffMSP]/* save storeptr */
# Line 296  Line 303 
303          ret          ret
304          restore                             /* restore C register window (delay slot) */          restore                             /* restore C register window (delay slot) */
305    
306    /* ------------------------------------------------------------------- */
307    /*
308     * This is the entry point for starting gc called from ML's code.
309     * I've added an adjustment to the return address.  The generated ML code
310     * uses the JMPL instruction, which does not add an offset of 8 to the
311     * correct return address.
312     *
313     * Allen (Jun 5 1998)
314     */
315    ENTRY(saveregs0)
316            add     GCLINK, 8, GCLINK
317  ENTRY(saveregs)  ENTRY(saveregs)
318          ld      [%sp+MLSTATE_OFFSET],TMPREG2  /* get MLState ptr from stack */  #define MLState ASMTMP
319          st      TMPREG4,[TMPREG2+MaskOffMSP]    /* save register mask */          ld      [%sp+MLSTATE_OFFSET],MLState  /* get MLState ptr from stack */
320            st      MASKREG,[MLState+MaskOffMSP]    /* save register mask */
321  #ifdef SOFT_POLL  #ifdef SOFT_POLL
322          /* free some regs */          /* free some regs */
323          std     MISCREG0,[TMPREG2+MiscRegOffMSP(0)]  /* save miscreg0,misreg1 */          std     MISCREG0,[MLState+MiscRegOffMSP(0)]  /* save miscreg0,misreg1 */
324  #define p0      MISCREG0  #define p0      MISCREG0
325  #define p1      MISCREG1  #define p1      MISCREG1
326  #define pfreq   TMPREG4  #define pfreq   TMPREG4
# Line 312  Line 331 
331          tst     pfreq          tst     pfreq
332          be      check_for_gc                    /* go check for real gc */          be      check_for_gc                    /* go check for real gc */
333          nop     /* (delay slot) */          nop     /* (delay slot) */
334          ld      [TMPREG2+InPollHandlerOffMSP],p0        /* if we're in the handler */          ld      [MLState+InPollHandlerOffMSP],p0        /* if we're in the handler */
335          tst     p0          tst     p0
336          bne     reset_limit                     /* ignore poll events */          bne     reset_limit                     /* ignore poll events */
337          nop     /* (delay slot) */          nop     /* (delay slot) */
# Line 324  Line 343 
343          nop     /* (delay slot) */          nop     /* (delay slot) */
344          /* event occurred, so set ml_pollHandlerPending */          /* event occurred, so set ml_pollHandlerPending */
345          set     1,p0          set     1,p0
346          st      p0,[TMPREG2+PollPendingOffMSP]          st      p0,[MLState+PollPendingOffMSP]
347          ba      do_gc           /* and handle event in the C runtime */          ba      do_gc           /* and handle event in the C runtime */
348    
349  reset_limit:                            /* reset limit ptr */  reset_limit:                            /* reset limit ptr */
# Line 333  Line 352 
352    
353  check_for_gc:  check_for_gc:
354          /* ensure real limit is >= limit */          /* ensure real limit is >= limit */
355          ld      [TMPREG2+RealLimitOffMSP],p0          ld      [MLState+RealLimitOffMSP],p0
356          sub     p0,LIMITPTR,p1          sub     p0,LIMITPTR,p1
357          tst     p1          tst     p1
358          bge     ok_limit          bgeu    ok_limit
359          nop     /* (delay slot) */          nop     /* (delay slot) */
360          mov     p0,LIMITPTR          mov     p0,LIMITPTR
361  ok_limit:  ok_limit:
362          add     p0,-4096,LIMITPTR          add     p0,-4096,LIMITPTR
363  /*      cmp     p0,ALLOCPTR  */  /*      cmp     p0,ALLOCPTR  */
364          cmp     LIMITPTR,ALLOCPTR          cmp     LIMITPTR,ALLOCPTR
365          ble     do_gc                   /* gc *//* should be a common case */          bleu    do_gc                   /* gc *//* should be a common case */
366          nop                             /* (delay slot) */          nop                             /* (delay slot) */
367      /* since a signal also sets limitptr == allocptr to force a trap, */      /* since a signal also sets limitptr == allocptr to force a trap, */
368      /* we need to disambiguate poll-events/signals here */      /* we need to disambiguate poll-events/signals here */
369  #undef  pfreq  #undef  pfreq
370  #define vsp     TMPREG4  #define vsp     TMPREG4
371          ld      [TMPREG2+VProcOffMSP],vsp          ld      [MLState+VProcOffMSP],vsp
372          ld      [TMPREG2+PollPendingOffMSP],p0          ld      [MLState+PollPendingOffMSP],p0
373          ld      [vsp+NPendingOffVSP],p1          ld      [vsp+NPendingOffVSP],p1
374          add     p0,p1,p0          add     p0,p1,p0
375          ld      [vsp+NPendingSysOffVSP],p1          ld      [vsp+NPendingSysOffVSP],p1
# Line 360  Line 379 
379          nop     /* (delay slot) */          nop     /* (delay slot) */
380    
381  no_gc:  /* an uneventful poll check, back to ML */  no_gc:  /* an uneventful poll check, back to ML */
382          ldd     [TMPREG2+MiscRegOffMSP(0)],MISCREG0  /* reload miscregs */          ldd     [MLState+MiscRegOffMSP(0)],MISCREG0  /* reload miscregs */
383          jmp     GCLINK          jmp     GCLINK
384          subcc   ALLOCPTR,LIMITPTR,%g0       /* Heap limit test (delay slot) */          subcc   ALLOCPTR,LIMITPTR,%g0       /* Heap limit test (delay slot) */
385    
386  do_gc:  do_gc:
387          st      LIMITPTR,[TMPREG2+LimitPtrOffMSP]          st      LIMITPTR,[MLState+LimitPtrOffMSP]
388    
389  #undef  vsp  #undef  vsp
390  #undef  p0  #undef  p0
391  #undef  p1  #undef  p1
392  #endif /* SOFT_POLL */  #endif /* SOFT_POLL */
393    #define VProcPtr TMPREG4
394          ld      [TMPREG2+VProcOffMSP],TMPREG1   /* TMPREG1 := VProcPtr */          ld      [MLState+VProcOffMSP],VProcPtr  /* TMPREG4 := VProcPtr */
395          st      %g0,[TMPREG1+InMLOffVSP]        /* note that we have left ML code */          st      %g0,[VProcPtr+InMLOffVSP]       /* note that we have left ML code */
396          st      GCLINK,[TMPREG2+PCOffMSP]       /* resume pc */  #undef VProcPtr
397            st      GCLINK,[MLState+PCOffMSP]       /* resume pc */
398          add     BASEPTR,-4096,BASEPTR           /* adjust the base code ptr (sub 4096) */          add     BASEPTR,-4096,BASEPTR           /* adjust the base code ptr (sub 4096) */
399          st      ALLOCPTR,[TMPREG2+AllocPtrOffMSP] /* save allocptr */          st      ALLOCPTR,[MLState+AllocPtrOffMSP] /* save allocptr */
400          st      STOREPTR,[TMPREG2+StorePtrOffMSP] /* save storeptr */          st      STOREPTR,[MLState+StorePtrOffMSP] /* save storeptr */
401          std     STDARG,[TMPREG2+StdArgOffMSP]   /* save STDARG, stdcont */          std     STDARG,[MLState+StdArgOffMSP]   /* save STDARG, stdcont */
402          std     STDCLOS,[TMPREG2+StdClosOffMSP] /* save stdclos, baseptr */          std     STDCLOS,[MLState+StdClosOffMSP] /* save stdclos, baseptr */
403          st      VARPTR,[TMPREG2+VarPtrOffMSP]          st      VARPTR,[MLState+VarPtrOffMSP]
404          st      STDLINK,[TMPREG2+LinkRegOffMSP]          st      STDLINK,[MLState+LinkRegOffMSP]
405          st      EXNCONT,[TMPREG2+ExnPtrOffMSP]          st      EXNCONT,[MLState+ExnPtrOffMSP]
406  #ifndef SOFT_POLL  /* miscreg0 & miscreg1 saved above for SOFT_POLL */  #ifndef SOFT_POLL  /* miscreg0 & miscreg1 saved above for SOFT_POLL */
407          std     MISCREG0,[TMPREG2+MiscRegOffMSP(0)]          std     MISCREG0,[MLState+MiscRegOffMSP(0)]
408  #endif  #endif
409          std     MISCREG2,[TMPREG2+MiscRegOffMSP(2)]          std     MISCREG2,[MLState+MiscRegOffMSP(2)]
410          std     MISCREG4,[TMPREG2+MiscRegOffMSP(4)]          std     MISCREG4,[MLState+MiscRegOffMSP(4)]
411          std     MISCREG6,[TMPREG2+MiscRegOffMSP(6)]          std     MISCREG6,[MLState+MiscRegOffMSP(6)]
412          std     MISCREG8,[TMPREG2+MiscRegOffMSP(8)]          std     MISCREG8,[MLState+MiscRegOffMSP(8)]
413          std     MISCREG10,[TMPREG2+MiscRegOffMSP(10)]          std     MISCREG10,[MLState+MiscRegOffMSP(10)]
414          st      MISCREG12,[TMPREG2+MiscRegOffMSP(12)]          st      MISCREG12,[MLState+MiscRegOffMSP(12)]
415            st      MISCREG13,[MLState+MiscRegOffMSP(13)]
416            st      MISCREG14,[MLState+MiscRegOffMSP(14)]
417          ld      [%sp+PSEUDOREG_OFFSET],%g6   /* save pseduo registers */          ld      [%sp+PSEUDOREG_OFFSET],%g6   /* save pseduo registers */
418          ld      [%sp+PSEUDOREG_OFFSET+4],%g7          ld      [%sp+PSEUDOREG_OFFSET+4],%g7
419          st      %g6,[TMPREG2+PseudoReg1OffMSP]          st      %g6,[MLState+PseudoReg1OffMSP]
420          st      %g7,[TMPREG2+PseudoReg2OffMSP]          st      %g7,[MLState+PseudoReg2OffMSP]
421          ldd     [%sp+64],%g6              /* restore C registers %g6 & %g7. */          ldd     [%sp+64],%g6              /* restore C registers %g6 & %g7. */
422          set     REQ_GC,%i0                /* request GC */          set     REQ_GC,%i0                /* request GC */
423          ret          ret
424          restore             /* restore C register window (delay slot) */          restore             /* restore C register window (delay slot) */
425    #undef MLState
426    
427    /* ------------------------------------------------------------------- */
428    
429    #define MLState ASMTMP
430    #define VProcPtr TMPREG4
431  ENTRY(restoreregs)  ENTRY(restoreregs)
432          save    %sp,-SA(ML_FRAMESIZE),%sp          save    %sp,-SA(ML_FRAMESIZE),%sp
433          st      %i0,[%sp+MLSTATE_OFFSET]        /* save MLState ptr on stack */          st      %i0,[%sp+MLSTATE_OFFSET]        /* save MLState ptr on stack */
434          set     CSYM(saveregs),TMPREG2          set     CSYM(saveregs0),ASMTMP
435          st      TMPREG2,[%sp+STARTGC_OFFSET]          st      ASMTMP,[%sp+STARTGC_OFFSET]
436          mov     %i0,TMPREG2                     /* transfer MLState ptr to tmpreg2 */          mov     %i0,MLState                     /* transfer MLState ptr to tmpreg4 */
437          std     ALLOCPTR,[%sp+64]               /* save C registers %g6 & %g7 */          std     ALLOCPTR,[%sp+64]               /* save C registers %g6 & %g7 */
438          set     _ml_mul,TMPREG1                 /* set pointer to ml_mul */          set     _ml_mul,TMPREG4                 /* set pointer to ml_mul */
439          st      TMPREG1,[%sp+MUL_OFFSET]          st      TMPREG4,[%sp+MUL_OFFSET]
440          set     _ml_div,TMPREG1                 /* set pointer to ml_div */          set     _ml_div,TMPREG4                 /* set pointer to ml_div */
441          st      TMPREG1,[%sp+DIV_OFFSET]          st      TMPREG4,[%sp+DIV_OFFSET]
442          set     _ml_umul,TMPREG1                /* set pointer to ml_umul */          set     _ml_umul,TMPREG4                /* set pointer to ml_umul */
443          st      TMPREG1,[%sp+UMUL_OFFSET]          st      TMPREG4,[%sp+UMUL_OFFSET]
444          set     _ml_udiv,TMPREG1                /* set pointer to ml_udiv */          set     _ml_udiv,TMPREG4                /* set pointer to ml_udiv */
445          st      TMPREG1,[%sp+UDIV_OFFSET]          st      TMPREG4,[%sp+UDIV_OFFSET]
446          ld      [TMPREG2+AllocPtrOffMSP],ALLOCPTR          ld      [MLState+AllocPtrOffMSP],ALLOCPTR
447          ld      [TMPREG2+LimitPtrOffMSP],LIMITPTR          ld      [MLState+LimitPtrOffMSP],LIMITPTR
448          ld      [TMPREG2+StorePtrOffMSP],STOREPTR          ld      [MLState+StorePtrOffMSP],STOREPTR
449          ld      [TMPREG2+PCOffMSP],GCLINK          ld      [MLState+PCOffMSP],GCLINK
450          ldd     [TMPREG2+StdArgOffMSP],STDARG      /* stdarg and stdcont */          ldd     [MLState+StdArgOffMSP],STDARG      /* stdarg and stdcont */
451          ldd     [TMPREG2+StdClosOffMSP],STDCLOS     /* stdclos and baseptr */          ldd     [MLState+StdClosOffMSP],STDCLOS     /* stdclos and baseptr */
452          ld      [TMPREG2+VarPtrOffMSP],VARPTR          ld      [MLState+VarPtrOffMSP],VARPTR
453          ld      [TMPREG2+LinkRegOffMSP],STDLINK          ld      [MLState+LinkRegOffMSP],STDLINK
454          ld      [TMPREG2+ExnPtrOffMSP],EXNCONT  /* restore exnptr */          ld      [MLState+ExnPtrOffMSP],EXNCONT  /* restore exnptr */
455          ld      [TMPREG2+PseudoReg1OffMSP],MISCREG2 /* save pseduo registers */          ld      [MLState+PseudoReg1OffMSP],MISCREG2 /* save pseduo registers */
456          ld      [TMPREG2+PseudoReg2OffMSP],MISCREG3          ld      [MLState+PseudoReg2OffMSP],MISCREG3
457          st      MISCREG2,[%sp+PSEUDOREG_OFFSET]          st      MISCREG2,[%sp+PSEUDOREG_OFFSET]
458          st      MISCREG3,[%sp+PSEUDOREG_OFFSET+4]          st      MISCREG3,[%sp+PSEUDOREG_OFFSET+4]
459          ldd     [TMPREG2+MiscRegOffMSP(0)],MISCREG0          ldd     [MLState+MiscRegOffMSP(0)],MISCREG0
460          ldd     [TMPREG2+MiscRegOffMSP(2)],MISCREG2          ldd     [MLState+MiscRegOffMSP(2)],MISCREG2
461          ldd     [TMPREG2+MiscRegOffMSP(4)],MISCREG4          ldd     [MLState+MiscRegOffMSP(4)],MISCREG4
462          ldd     [TMPREG2+MiscRegOffMSP(6)],MISCREG6          ldd     [MLState+MiscRegOffMSP(6)],MISCREG6
463          ldd     [TMPREG2+MiscRegOffMSP(8)],MISCREG8          ldd     [MLState+MiscRegOffMSP(8)],MISCREG8
464          ldd     [TMPREG2+MiscRegOffMSP(10)],MISCREG10          ldd     [MLState+MiscRegOffMSP(10)],MISCREG10
465          ld      [TMPREG2+MiscRegOffMSP(12)],MISCREG12          ld      [MLState+MiscRegOffMSP(12)],MISCREG12
466    
467          sub     BASEPTR,-4096,BASEPTR   /* adjust the base code ptr (add 4096) */          sub     BASEPTR,-4096,BASEPTR   /* adjust the base code ptr (add 4096) */
468          ld      [TMPREG2+VProcOffMSP],TMPREG1   /* TMPREG1 := VProcPtr */          ld      [MLState+VProcOffMSP],VProcPtr  /* TMPREG4 := VProcPtr */
469          set     1,TMPREG2                       /* note that we have entered ML code */          set     1,TMPREG2                       /* note that we have entered ML code */
470          st      TMPREG2,[TMPREG1+InMLOffVSP]          st      TMPREG2,[VProcPtr+InMLOffVSP]
471          ld      [TMPREG1+NPendingSysOffVSP],TMPREG2     /* check for pending signals */          ld      [VProcPtr+NPendingSysOffVSP],TMPREG2    /* check for pending signals */
472          ld      [TMPREG1+NPendingOffVSP],TMPREG3          ld      [VProcPtr+NPendingOffVSP],TMPREG3
473          addcc   TMPREG2,TMPREG3,%g0          addcc   TMPREG2,TMPREG3,%g0
474          bne     pending_sigs          bne     pending_sigs
475          nop          nop
476    ml_go0:
477            /* Restore MISCREG13/14 before going; these are aliased to
478             * TMPREG2 and TMPREG3
479             */
480            ld      [MLState+MiscRegOffMSP(13)],MISCREG13
481            ld      [MLState+MiscRegOffMSP(14)],MISCREG14
482  CSYM(ml_go):                                    /* invoke the ML code */  CSYM(ml_go):                                    /* invoke the ML code */
483          jmp     GCLINK          jmp     GCLINK
484          subcc   ALLOCPTR,LIMITPTR,%g0       /* Heap limit test (delay slot) */          subcc   ALLOCPTR,LIMITPTR,%g0       /* Heap limit test (delay slot) */
485    
486  pending_sigs:   /* there are pending signals */  pending_sigs:   /* there are pending signals */
487                                          /* check if we are currently handling a signal */                                          /* check if we are currently handling a signal */
488          ld      [TMPREG1+InSigHandlerOffVSP],TMPREG2          ld      [VProcPtr+InSigHandlerOffVSP],TMPREG2
489          tst     TMPREG2          tst     TMPREG2
490          bne     CSYM(ml_go)          bne     ml_go0
491          set     1,TMPREG2                           /* (delay slot) */          set     1,TMPREG2                           /* (delay slot) */
492                                          /* note that a handler trap is pending */                                          /* note that a handler trap is pending */
493          st      TMPREG2,[TMPREG1+HandlerPendingOffVSP]          st      TMPREG2,[VProcPtr+HandlerPendingOffVSP]
494          ba      CSYM(ml_go)          ba      ml_go0
495          mov     ALLOCPTR,LIMITPTR           /* (delay slot) */          mov     ALLOCPTR,LIMITPTR           /* (delay slot) */
496    
497    
# Line 508  Line 541 
541          CONTINUE          CONTINUE
542    
543  3:      /* here we do off-line allocation for big arrays */  3:      /* here we do off-line allocation for big arrays */
544          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
545          ba      set_request          ba      set_request
546          set     REQ_ALLOC_ARRAY,TMPREG3     /* (delayslot) */          set     REQ_ALLOC_ARRAY,TMPREG3     /* (delayslot) */
547    
# Line 535  Line 568 
568          CONTINUE          CONTINUE
569    
570  1:      /* off-line allocation of big realarrays */  1:      /* off-line allocation of big realarrays */
571          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
572          ba      set_request          ba      set_request
573          set     REQ_ALLOC_REALDARRAY,TMPREG3    /* (delayslot) */          set     REQ_ALLOC_REALDARRAY,TMPREG3    /* (delayslot) */
574    
# Line 560  Line 593 
593          CONTINUE          CONTINUE
594    
595  1:      /* here we do off-line allocation for big bytearrays */  1:      /* here we do off-line allocation for big bytearrays */
596          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
597          ba      set_request          ba      set_request
598          set     REQ_ALLOC_BYTEARRAY,TMPREG3     /* (delayslot) */          set     REQ_ALLOC_BYTEARRAY,TMPREG3     /* (delayslot) */
599    
# Line 586  Line 619 
619          CONTINUE          CONTINUE
620    
621  1:      /* here we do off-line allocation for big strings */  1:      /* here we do off-line allocation for big strings */
622          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
623          ba      set_request          ba      set_request
624          set     REQ_ALLOC_STRING,TMPREG3        /* (delayslot) */          set     REQ_ALLOC_STRING,TMPREG3        /* (delayslot) */
625    
# Line 618  Line 651 
651          CONTINUE          CONTINUE
652    
653  1:      /* off-line allocation of big vectors */  1:      /* off-line allocation of big vectors */
654          set     FUN_MASK,TMPREG4          set     FUN_MASK,MASKREG
655          ba      set_request          ba      set_request
656          set     REQ_ALLOC_VECTOR,TMPREG3        /* (delayslot) */          set     REQ_ALLOC_VECTOR,TMPREG3        /* (delayslot) */
657    
# Line 834  Line 867 
867          ???          ???
868  #else (MAX_PROCS == 1)  #else (MAX_PROCS == 1)
869          ld      [STDARG],TMPREG1        /* load previous value into tmpreg1 */          ld      [STDARG],TMPREG1        /* load previous value into tmpreg1 */
870          set     ML_false,TMPREG2        /* ML_false */          set     ML_false,TMPREG4        /* ML_false */
871          st      TMPREG2,[STDARG]        /* store ML_false into the lock */          st      TMPREG4,[STDARG]        /* store ML_false into the lock */
872          mov     TMPREG1,STDARG          /* return previous value of lock */          mov     TMPREG1,STDARG          /* return previous value of lock */
873          CONTINUE          CONTINUE
874  #endif  #endif

Legend:
Removed from v.138  
changed lines
  Added in v.139

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