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

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

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

revision 7, Sun Jan 18 00:59:30 1998 UTC revision 8, Sun Jan 18 01:01:29 1998 UTC
# Line 146  Line 146 
146  #define CONTINUE                                        \  #define CONTINUE                                        \
147              cmpl        CR0,limitptr,allocptr;          \              cmpl        CR0,limitptr,allocptr;          \
148              mtlr        stdcont;                        \              mtlr        stdcont;                        \
149              blr              br
150  #endif  #endif
151    
152  #define CHECKLIMIT(mask,label)                          \  #define CHECKLIMIT(mask,label)                          \
153              bt          CR0_GT, label;                  \              bbt         CR0_GT, label;                  \
154              lwz         atmp2,STARTGC_OFFSET(stackptr); \              l           atmp2,STARTGC_OFFSET(stackptr); \
155              li          atmp1,mask;                     \              lil         atmp1,mask;                     \
156              mtspr       SPR_LR, atmp2;                  \              mtspr       SPR_LR, atmp2;                  \
157              addi        gclink,stdlink,0;               \              ai          gclink,stdlink,0;               \
158              blr         ;                               \              br          ;                               \
159      label:      label:
160    
161          .extern         CSYM(_PollFreq0)  /** A comment explaining what this does would be nice!! **/
162          .extern         CSYM(_PollEvent0)          .extern         CSYM(_PollFreq0{UA})
163          .extern         CSYM(saveregs)          .extern         CSYM(_PollEvent0{UA})
164    
 #if defined (USE_TOC)  
 /* create table of contents entries for things we need the address of. */  
165          .toc          .toc
166  T._PollFreq0:  T._PollFreq0:
167          .tc     H._PollFreq0[TC],CSYM(_PollFreq0)          .tc     H._PollFreq0{TC},_PollFreq0{UA}
168  T._PollEvent0:  T._PollEvent0:
169          .tc     H._PollEvent0[TC],CSYM(_PollEvent0)          .tc     H._PollEvent0{TC},_PollEvent0{UA}
170  T.saveregs:  
171          .tc     H.saveregs[TC],CSYM(saveregs)  /* create table of contents entries. */
172  T.cvti2d_CONST:          .toc
173          .tc     H.cvti2d_CONST[TC],cvti2d_CONST          .csect  prim.s[BS]
174  #endif          .extern .saveregs
175          RO_DATA  
176          ALIGN8          .csect  [RO]
177            .toc
178  cvti2d_CONST:  cvti2d_CONST:
179          DOUBLE(4503601774854144.0)          .tc     fd43300000_80000000[TC],1127219200,-2147483648
180    T.saveregs:
181            .tc     saveregs[TC],.saveregs
182    
183          TEXT          .csect  [PR]
184  /* sig_return : ('a cont * 'a) -> 'b  /* sig_return : ('a cont * 'a) -> 'b
185   */   */
186  ML_CODE_HDR(sigh_return_a)  ML_CODE_HDR(sigh_return_a)
187          li      atmp1,RET_MASK          lil     atmp1,RET_MASK
188          li      atmp4,REQ_SIG_RETURN          lil     atmp4,REQ_SIG_RETURN
189          b       set_request          b       set_request
190    
191  ENTRY(sigh_resume)  GLOBAL(sigh_resume)
192          li      atmp1,FUN_MASK  sigh_resume:
193          li      atmp4, REQ_SIG_RESUME          lil     atmp1,FUN_MASK
194            lil     atmp4, REQ_SIG_RESUME
195          b       set_request          b       set_request
196    
197  /* pollh_return_a:  /* pollh_return_a:
198   * The return continuation for the ML poll handler.   * The return continuation for the ML poll handler.
199   */   */
200  ML_CODE_HDR(pollh_return_a)  ML_CODE_HDR(pollh_return_a)
201          li      atmp1,RET_MASK          lil     atmp1,RET_MASK
202          li      atmp4,REQ_POLL_RETURN          lil     atmp4,REQ_POLL_RETURN
203          b       set_request          b       set_request
204    
205  /* pollh_resume:  /* pollh_resume:
206   * Resume execution at the point at which a poll event occurred.   * Resume execution at the point at which a poll event occurred.
207   */   */
208  ENTRY(pollh_resume)  ENTRY(pollh_resume)
209          li      atmp1,FUN_MASK          lil     atmp1,FUN_MASK
210          li      atmp4,REQ_POLL_RESUME          lil     atmp4,REQ_POLL_RESUME
211          b       set_request          b       set_request
212    
213                   /* exception handler for ML functions called from C */                   /* exception handler for ML functions called from C */
214  ML_CODE_HDR(handle_a)  ML_CODE_HDR(handle_a)
215          li      atmp1,EXN_MASK          lil     atmp1,EXN_MASK
216          li      atmp4,REQ_EXN          lil     atmp4,REQ_EXN
217          b       set_request          b       set_request
218    
219    
220                  /* continuation for ML functions called from C */                  /* continuation for ML functions called from C */
221  ML_CODE_HDR(return_a)  ML_CODE_HDR(return_a)
222          li      atmp1,RET_MASK          lil     atmp1,RET_MASK
223          li      atmp4,REQ_RETURN          lil     atmp4,REQ_RETURN
224          b       set_request          b       set_request
225    
226    
227  ENTRY(request_fault)  GLOBAL(request_fault)
228          li      atmp1,EXN_MASK  
229          li      atmp4,REQ_FAULT  request_fault:
230            lil     atmp1,EXN_MASK
231            lil     atmp4,REQ_FAULT
232          b       set_request          b       set_request
233    
234    
# Line 232  Line 236 
236   */   */
237  ML_CODE_HDR(bind_cfun_a)  ML_CODE_HDR(bind_cfun_a)
238          CHECKLIMIT(FUN_MASK,bind_cfun_v_limit)          CHECKLIMIT(FUN_MASK,bind_cfun_v_limit)
239          li      atmp1,FUN_MASK          lil     atmp1,FUN_MASK
240          li      atmp4,REQ_BIND_CFUN          lil     atmp4,REQ_BIND_CFUN
241          b       set_request          b       set_request
242    
243  ML_CODE_HDR(build_literals_a)  ML_CODE_HDR(build_literals_a)
244          CHECKLIMIT(FUN_MASK,build_literals_v_limit)          CHECKLIMIT(FUN_MASK,build_literals_v_limit)
245          li      atmp1,FUN_MASK          lil     atmp1,FUN_MASK
246          li      atmp4,REQ_BUILD_LITERALS          lil     atmp4,REQ_BUILD_LITERALS
247          b       set_request          b       set_request
248    
249  ML_CODE_HDR(callc_a)  ML_CODE_HDR(callc_a)
250          CHECKLIMIT(FUN_MASK,callc_v_limit)          CHECKLIMIT(FUN_MASK,callc_v_limit)
251          li      atmp1,FUN_MASK          lil     atmp1,FUN_MASK
252          li      atmp4,REQ_CALLC          lil     atmp4,REQ_CALLC
253          /* fall through */          /* fall through */
254    
255  set_request:  set_request:
256          lwz     atmp3,MLSTATE_OFFSET(sp)        /* save the minimal ML state */          l       atmp3,MLSTATE_OFFSET(sp)        /* save the minimal ML state */
257          stw     atmp1,MaskOffMSP(atmp3)         /* mask */          st      atmp1,MaskOffMSP(atmp3)         /* mask */
258          lwz     atmp2,VProcOffMSP(atmp3)        /* atmp2 := VProc State ptr */          l       atmp2,VProcOffMSP(atmp3)        /* atmp2 := VProc State ptr */
259          li      0,0          lil     0,0
260          stw     0,InMLOffVSP(atmp2)             /* note that we have left ML */          st      0,InMLOffVSP(atmp2)             /* note that we have left ML */
261          stw     allocptr,AllocPtrOffMSP(atmp3)          st      allocptr,AllocPtrOffMSP(atmp3)
262          stw     limitptr,LimitPtrOffMSP(atmp3)          st      limitptr,LimitPtrOffMSP(atmp3)
263          stw     storeptr,StorePtrOffMSP(atmp3)          st      storeptr,StorePtrOffMSP(atmp3)
264          stw     stdlink,LinkRegOffMSP(atmp3)          st      stdlink,LinkRegOffMSP(atmp3)
265          stw     stdlink,PCOffMSP(atmp3)          st      stdlink,PCOffMSP(atmp3)
266          stw     stdarg,StdArgOffMSP(atmp3)          st      stdarg,StdArgOffMSP(atmp3)
267          stw     stdcont,StdContOffMSP(atmp3)          st      stdcont,StdContOffMSP(atmp3)
268          stw     stdclos,StdClosOffMSP(atmp3)          st      stdclos,StdClosOffMSP(atmp3)
269          stw     varptr,VarPtrOffMSP(atmp3)          st      varptr,VarPtrOffMSP(atmp3)
270          stw     exncont,ExnPtrOffMSP(atmp3)          st      exncont,ExnPtrOffMSP(atmp3)
271  #if CALLEESAVE > 0  #if CALLEESAVE > 0
272          stw     miscreg0,MiscRegOffMSP(0)(atmp3)          st      miscreg0,MiscRegOffMSP(0)(atmp3)
273  #if CALLEESAVE > 1  #if CALLEESAVE > 1
274          stw     miscreg1,MiscRegOffMSP(1)(atmp3)          st      miscreg1,MiscRegOffMSP(1)(atmp3)
275  #if CALLEESAVE > 2  #if CALLEESAVE > 2
276          stw     miscreg2,MiscRegOffMSP(2)(atmp3)          st      miscreg2,MiscRegOffMSP(2)(atmp3)
277  #if CALLEESAVE > 3  #if CALLEESAVE > 3
278          ??          ??
279  #endif  #endif
280  #endif  #endif
281  #endif  #endif
282  #endif  #endif
283          addi    3,atmp4,0                       /* request as argument */          ai      3,atmp4,0                       /* request as argument */
284    
285  restore_c_regs:  restore_c_regs:
286          lwz     atmp1,PSEUDOREG_OFFSET(sp)     /* restore pseudo registers */          l       atmp1,PSEUDOREG_OFFSET(sp)     /* restore pseudo registers */
287          stw     atmp1,PseudoReg1OffMSP(atmp3)          st      atmp1,PseudoReg1OffMSP(atmp3)
288          lwz     atmp1,PSEUDOREG_OFFSET+4(sp)          l       atmp1,PSEUDOREG_OFFSET+4(sp)
289          stw     atmp1,PseudoReg2OffMSP(atmp3)          st      atmp1,PseudoReg2OffMSP(atmp3)
290          lwz     2, (argblock+4)(sp)          l       2, (argblock+4)(sp)
291          lwz     13, (argblock+8)(sp)          l       13, (argblock+8)(sp)
292          lwz     14, (argblock+12)(sp)          l       14, (argblock+12)(sp)
293          lwz     15, (argblock+16)(sp)          l       15, (argblock+16)(sp)
294          lwz     16, (argblock+20)(sp)          l       16, (argblock+20)(sp)
295          lwz     17, (argblock+24)(sp)          l       17, (argblock+24)(sp)
296          lwz     18, (argblock+28)(sp)          l       18, (argblock+28)(sp)
297          lwz     19, (argblock+32)(sp)          l       19, (argblock+32)(sp)
298          lwz     20, (argblock+36)(sp)          l       20, (argblock+36)(sp)
299          lwz     21, (argblock+40)(sp)          l       21, (argblock+40)(sp)
300          lwz     22, (argblock+44)(sp)          l       22, (argblock+44)(sp)
301          lwz     23, (argblock+48)(sp)          l       23, (argblock+48)(sp)
302          lwz     24, (argblock+52)(sp)          l       24, (argblock+52)(sp)
303          lwz     25, (argblock+56)(sp)          l       25, (argblock+56)(sp)
304          lwz     26, (argblock+60)(sp)          l       26, (argblock+60)(sp)
305          lwz     27, (argblock+64)(sp)          l       27, (argblock+64)(sp)
306          lwz     28, (argblock+68)(sp)          l       28, (argblock+68)(sp)
307          lwz     29, (argblock+72)(sp)          l       29, (argblock+72)(sp)
308          lwz     30, (argblock+76)(sp)          l       30, (argblock+76)(sp)
309          lwz     31, (argblock+80)(sp)          l       31, (argblock+80)(sp)
310          lwz     0, (argblock+84)(sp)          l       0, (argblock+84)(sp)
311          mtlr    0          mtlr    0
312          lwz     0, (argblock+88)(sp)          l       0, (argblock+88)(sp)
313          mtcrf   0x80, 0          mtcrf   0x80, 0
314          addi    sp,sp,framesize          ai      sp,sp,framesize
315          blr          br
316    
317          TEXT  GLOBAL(.saveregs)
318  ENTRY(saveregs)          .csect [PR]
319          lwz     atmp3,MLSTATE_OFFSET(sp)  .saveregs:
320          stw     atmp1,MaskOffMSP(atmp3)          l       atmp3,MLSTATE_OFFSET(sp)
321            st      atmp1,MaskOffMSP(atmp3)
322    
323  #ifdef SOFT_POLL  #ifdef SOFT_POLL
324          /* free some regs */          /* free some regs */
325          stw     miscreg0,MiscRegOffMSP(0)(atmp3)        /* use as tmp */          st      miscreg0,MiscRegOffMSP(0)(atmp3)        /* use as tmp */
326          stw     miscreg1,MiscRegOffMSP(1)(atmp3)        /* use as tmp */          st      miscreg1,MiscRegOffMSP(1)(atmp3)        /* use as tmp */
327  #define pfreq   atmp1  #define pfreq   atmp1
328  #define pevent  miscreg0  #define pevent  miscreg0
329  #define ptmp    miscreg1  #define ptmp    miscreg1
330    
331          /* check if polling enabled (PollFreq > 0) */          /* check if polling enabled (PollFreq > 0) */
332          lwz     pfreq,T._PollFreq0(2)           /* address of PollFreq */          l       pfreq,T._PollFreq0(2)           /* address of PollFreq */
333          lwz     pfreq,4(pfreq)                  /* contents of PollFreq */          l       pfreq,4(pfreq)                  /* contents of PollFreq */
334          sri     pfreq,pfreq,1                   /* strip integer tag */          sri     pfreq,pfreq,1                   /* strip integer tag */
335          cmpi    CR0,pfreq,0          cmpi    CR0,pfreq,0
336          bt      CR0_EQ,check_for_gc             /* go check for real gc */          bbt     CR0_EQ,check_for_gc             /* go check for real gc */
337          lwz     ptmp,InPollHandlerOffMSP(atmp3) /* if we're in the handler */          l       ptmp,InPollHandlerOffMSP(atmp3) /* if we're in the handler */
338          cmpi    CR0,ptmp,0          cmpi    CR0,ptmp,0
339          bt      CR0_GT,reset_limit              /* ignore poll events */          bbt     CR0_GT,reset_limit              /* ignore poll events */
340          lwz     ptmp,T._PollEvent0(2)           /* address of PollEvent */          l       ptmp,T._PollEvent0(2)           /* address of PollEvent */
341          lwz     pevent,4(ptmp)                  /* contents of PollEvent */          l       pevent,4(ptmp)                  /* contents of PollEvent */
342          sri     pevent,pevent,1          sri     pevent,pevent,1
343          cmpi    CR0,pevent,0          cmpi    CR0,pevent,0
344          bt      CR0_EQ,reset_limit          bbt     CR0_EQ,reset_limit
345          /* event occurred, so set ml_pollHandlerPending */          /* event occurred, so set ml_pollHandlerPending */
346          li      ptmp,1          lil     ptmp,1
347          stw     ptmp,PollPendingOffMSP(atmp3)          st      ptmp,PollPendingOffMSP(atmp3)
348          b       do_gc           /* and handle event in the C runtime */          b       do_gc           /* and handle event in the C runtime */
349    
350  reset_limit:                            /* reset limit ptr */  reset_limit:                            /* reset limit ptr */
351          slwi    pfreq,pfreq,POLL_GRAIN_BITS     /* mult by POLL_GRAIN_CPSI */          sli     pfreq,pfreq,POLL_GRAIN_BITS     /* mult by POLL_GRAIN_CPSI */
352          add     limitptr,pfreq,allocptr          a       limitptr,pfreq,allocptr
353    
354  check_for_gc:  check_for_gc:
355  #define ptmp2   pfreq  #define ptmp2   pfreq
356  #define vsp     pevent  #define vsp     pevent
357          /* ensure real limit is >= limit */          /* ensure real limit is >= limit */
358          lwz     ptmp,RealLimitOffMSP(atmp3)          l       ptmp,RealLimitOffMSP(atmp3)
359          cmpl    CR0,ptmp,limitptr          cmpl    CR0,ptmp,limitptr
360          bt      CR0_GT,ok_limit          bbt     CR0_GT,ok_limit
361          addi    limitptr,ptmp,0           /* move ptmp into limit */          ai      limitptr,ptmp,0           /* move ptmp into limit */
362  ok_limit:  ok_limit:
363          addi    ptmp,limitptr,-4096          ai      ptmp,limitptr,-4096
364          cmpl    CR0,ptmp,allocptr          cmpl    CR0,ptmp,allocptr
365          bf      CR0_GT,do_gc            /* gc *//* should be a common case */          bbf     CR0_GT,do_gc            /* gc *//* should be a common case */
366          /* since a signal also sets limitptr == allocptr to force a trap, */          /* since a signal also sets limitptr == allocptr to force a trap, */
367          /* we need to disambiguate poll-events/signals here */          /* we need to disambiguate poll-events/signals here */
368          lwz     vsp,VProcOffMSP(atmp3)          /* get the vsp */          l       vsp,VProcOffMSP(atmp3)          /* get the vsp */
369          lwz     ptmp,PollPendingOffMSP(atmp3)          l       ptmp,PollPendingOffMSP(atmp3)
370          lwz     ptmp2,NPendingOffVSP(vsp)          l       ptmp2,NPendingOffVSP(vsp)
371          add     ptmp,ptmp,ptmp2          a       ptmp,ptmp,ptmp2
372          lwz     ptmp2,NPendingSysOffVSP(vsp)          l       ptmp2,NPendingSysOffVSP(vsp)
373          add     ptmp,ptmp,ptmp2          a       ptmp,ptmp,ptmp2
374          cmpi    CR0,ptmp,0          cmpi    CR0,ptmp,0
375          bt      CR0_GT,do_gc          bbt     CR0_GT,do_gc
376  #undef  vsp  #undef  vsp
377  #undef  ptmp2  #undef  ptmp2
378    
379  no_gc:  /* an uneventful poll check, back to ML */  no_gc:  /* an uneventful poll check, back to ML */
380          lwz     miscreg0,MiscRegOffMSP(0)(atmp3)  /* reload miscregs */          l       miscreg0,MiscRegOffMSP(0)(atmp3)  /* reload miscregs */
381          lwz     miscreg1,MiscRegOffMSP(1)(atmp3)          l       miscreg1,MiscRegOffMSP(1)(atmp3)
382          b       CSYM(ml_go)          b       ml_go
383    
384  do_gc:  do_gc:
385          stw     limitptr,LimitPtrOffMSP(atmp3)          st      limitptr,LimitPtrOffMSP(atmp3)
386    
387  #undef pfreq  #undef pfreq
388  #undef pevent  #undef pevent
389  #undef ptmp  #undef ptmp
390  #endif /* SOFT_POLL */  #endif /* SOFT_POLL */
391    
392          lwz     atmp2,VProcOffMSP(atmp3)        /* atmp2 := VProc State ptr */          l       atmp2,VProcOffMSP(atmp3)        /* atmp2 := VProc State ptr */
393          li      0,0          lil     0,0
394          stw     0,InMLOffVSP(atmp2)             /* note that we have left ML */          st      0,InMLOffVSP(atmp2)             /* note that we have left ML */
395          addi    basereg, basereg, -32764          ai      basereg, basereg, -32764
396          stw     allocptr,AllocPtrOffMSP(atmp3)          st      allocptr,AllocPtrOffMSP(atmp3)
397          stw     storeptr,StorePtrOffMSP(atmp3)          st      storeptr,StorePtrOffMSP(atmp3)
398          stw     stdarg,StdArgOffMSP(atmp3)          st      stdarg,StdArgOffMSP(atmp3)
399          stw     stdcont,StdContOffMSP(atmp3)          st      stdcont,StdContOffMSP(atmp3)
400          stw     stdclos,StdClosOffMSP(atmp3)          st      stdclos,StdClosOffMSP(atmp3)
401          stw     gclink,PCOffMSP(atmp3)          st      gclink,PCOffMSP(atmp3)
402          stw     exncont,ExnPtrOffMSP(atmp3)          st      exncont,ExnPtrOffMSP(atmp3)
403          /* save misc. roots */          /* save misc. roots */
404  #ifndef SOFT_POLL   /* miscreg0 & miscreg1 saved above for SOFT_POLL */  #ifndef SOFT_POLL   /* miscreg0 & miscreg1 saved above for SOFT_POLL */
405          stw     miscreg0,MiscRegOffMSP(0)(atmp3)          st      miscreg0,MiscRegOffMSP(0)(atmp3)
406          stw     miscreg1,MiscRegOffMSP(1)(atmp3)          st      miscreg1,MiscRegOffMSP(1)(atmp3)
407  #endif  #endif
408          stw     miscreg2,MiscRegOffMSP(2)(atmp3)          st      miscreg2,MiscRegOffMSP(2)(atmp3)
409          stw     miscreg3,MiscRegOffMSP(3)(atmp3)          st      miscreg3,MiscRegOffMSP(3)(atmp3)
410          stw     miscreg4,MiscRegOffMSP(4)(atmp3)          st      miscreg4,MiscRegOffMSP(4)(atmp3)
411          stw     miscreg5,MiscRegOffMSP(5)(atmp3)          st      miscreg5,MiscRegOffMSP(5)(atmp3)
412          stw     miscreg6,MiscRegOffMSP(6)(atmp3)          st      miscreg6,MiscRegOffMSP(6)(atmp3)
413          stw     miscreg7,MiscRegOffMSP(7)(atmp3)          st      miscreg7,MiscRegOffMSP(7)(atmp3)
414          stw     miscreg8,MiscRegOffMSP(8)(atmp3)          st      miscreg8,MiscRegOffMSP(8)(atmp3)
415          stw     miscreg9,MiscRegOffMSP(9)(atmp3)          st      miscreg9,MiscRegOffMSP(9)(atmp3)
416          stw     miscreg10,MiscRegOffMSP(10)(atmp3)          st      miscreg10,MiscRegOffMSP(10)(atmp3)
417          stw     miscreg11,MiscRegOffMSP(11)(atmp3)          st      miscreg11,MiscRegOffMSP(11)(atmp3)
418          stw     miscreg12,MiscRegOffMSP(12)(atmp3)          st      miscreg12,MiscRegOffMSP(12)(atmp3)
419          stw     miscreg13,MiscRegOffMSP(13)(atmp3)          st      miscreg13,MiscRegOffMSP(13)(atmp3)
420          stw     miscreg14,MiscRegOffMSP(14)(atmp3)          st      miscreg14,MiscRegOffMSP(14)(atmp3)
421          stw     stdlink,LinkRegOffMSP(atmp3)          st      stdlink,LinkRegOffMSP(atmp3)
422          stw     basereg,BasePtrOffMSP(atmp3)            /* base reg */          st      basereg,BasePtrOffMSP(atmp3)            /* base reg */
423          stw     varptr,VarPtrOffMSP(atmp3)          st      varptr,VarPtrOffMSP(atmp3)
424          li      CARG1,REQ_GC          lil     CARG1,REQ_GC
425          b       restore_c_regs          b       restore_c_regs
426    
427    
428  CENTRY(restoreregs)  GLOBAL(.restoreregs)
429          addi    sp,sp,-framesize  .restoreregs:
430  #if defined(USE_TOC)          ai      sp,sp,-framesize
431          lwz     0,T.saveregs(2)          l       0,T.saveregs(2)
432  #else          st      3, MLSTATE_OFFSET(sp)
433          lis     0, CSYM(saveregs)@ha            /* GPR0 <- addrof(saveregs) */          st      0, STARTGC_OFFSET(sp)
434          addi    0, 0, CSYM(saveregs)@l          lfd     0, cvti2d_CONST(2)
 #endif  
         stw     3, MLSTATE_OFFSET(sp)  
         stw     0, STARTGC_OFFSET(sp)  
 #if defined(USE_TOC)  
         lwz     4, T.cvti2d_CONST(2)            /* GPR2 is RTOC */  
         lfd     0, 0(4)  
 #else  
         lis     4, cvti2d_CONST@ha  
         lfd     0, cvti2d_CONST@l(4)  
 #endif  
435          stfd    0, CVTI2D_OFFSET(sp)          stfd    0, CVTI2D_OFFSET(sp)
436    
437          stw     2, argblock+4(sp)          st      2, argblock+4(sp)
438          stw     13, argblock+8(sp)          st      13, argblock+8(sp)
439          stw     14, argblock+12(sp)          st      14, argblock+12(sp)
440          stw     15, argblock+16(sp)          st      15, argblock+16(sp)
441          stw     16, argblock+20(sp)          st      16, argblock+20(sp)
442          stw     17, argblock+24(sp)          st      17, argblock+24(sp)
443          stw     18, argblock+28(sp)          st      18, argblock+28(sp)
444          stw     19, argblock+32(sp)          st      19, argblock+32(sp)
445          stw     20, argblock+36(sp)          st      20, argblock+36(sp)
446          stw     21, argblock+40(sp)          st      21, argblock+40(sp)
447          stw     22, argblock+44(sp)          st      22, argblock+44(sp)
448          stw     23, argblock+48(sp)          st      23, argblock+48(sp)
449          stw     24, argblock+52(sp)          st      24, argblock+52(sp)
450          stw     25, argblock+56(sp)          st      25, argblock+56(sp)
451          stw     26, argblock+60(sp)          st      26, argblock+60(sp)
452          stw     27, argblock+64(sp)          st      27, argblock+64(sp)
453          stw     28, argblock+68(sp)          st      28, argblock+68(sp)
454          stw     29, argblock+72(sp)          st      29, argblock+72(sp)
455          stw     30, argblock+76(sp)          st      30, argblock+76(sp)
456          stw     31, argblock+80(sp)          st      31, argblock+80(sp)
457          mflr    0          mflr    0
458          stw     0,  argblock+84(sp)          st      0,  argblock+84(sp)
459          mfcr    0          mfcr    0
460          stw     0,  argblock+88(sp)          st      0,  argblock+88(sp)
461    
462          and     atmp1,3,3                       /* atmp1 := MLState pointer */          and     atmp1,3,3                       /* atmp1 := MLState pointer */
463    
464          lwz     allocptr,AllocPtrOffMSP(atmp1)          l       allocptr,AllocPtrOffMSP(atmp1)
465          lwz     limitptr,LimitPtrOffMSP(atmp1)          l       limitptr,LimitPtrOffMSP(atmp1)
466          lwz     storeptr,StorePtrOffMSP(atmp1)          l       storeptr,StorePtrOffMSP(atmp1)
467          lwz     atmp2,PseudoReg1OffMSP(atmp1)   /* restore pseudo registers */          l       atmp2,PseudoReg1OffMSP(atmp1)   /* restore pseudo registers */
468          lwz     atmp3,PseudoReg2OffMSP(atmp1)          l       atmp3,PseudoReg2OffMSP(atmp1)
469          stw     atmp2,PSEUDOREG_OFFSET(sp)          st      atmp2,PSEUDOREG_OFFSET(sp)
470          stw     atmp3,PSEUDOREG_OFFSET+4(sp)          st      atmp3,PSEUDOREG_OFFSET+4(sp)
471          lwz     atmp2,VProcOffMSP(atmp1)        /* atmp2 := VProc State ptr */          l       atmp2,VProcOffMSP(atmp1)        /* atmp2 := VProc State ptr */
472          li      atmp3,1          lil     atmp3,1
473          stw     atmp3,InMLOffVSP(atmp2)         /* we are entering ML code */          st      atmp3,InMLOffVSP(atmp2)         /* we are entering ML code */
474          lwz     stdarg,StdArgOffMSP(atmp1)          l       stdarg,StdArgOffMSP(atmp1)
475          lwz     stdcont,StdContOffMSP(atmp1)          l       stdcont,StdContOffMSP(atmp1)
476          lwz     stdclos,StdClosOffMSP(atmp1)          l       stdclos,StdClosOffMSP(atmp1)
477          lwz     exncont,ExnPtrOffMSP(atmp1)          l       exncont,ExnPtrOffMSP(atmp1)
478          lwz     miscreg0,MiscRegOffMSP(0)(atmp1)          l       miscreg0,MiscRegOffMSP(0)(atmp1)
479          lwz     miscreg1,MiscRegOffMSP(1)(atmp1)          l       miscreg1,MiscRegOffMSP(1)(atmp1)
480          lwz     miscreg2,MiscRegOffMSP(2)(atmp1)          l       miscreg2,MiscRegOffMSP(2)(atmp1)
481          lwz     miscreg3,MiscRegOffMSP(3)(atmp1)          l       miscreg3,MiscRegOffMSP(3)(atmp1)
482          lwz     miscreg4,MiscRegOffMSP(4)(atmp1)          l       miscreg4,MiscRegOffMSP(4)(atmp1)
483          lwz     miscreg5,MiscRegOffMSP(5)(atmp1)          l       miscreg5,MiscRegOffMSP(5)(atmp1)
484          lwz     miscreg6,MiscRegOffMSP(6)(atmp1)          l       miscreg6,MiscRegOffMSP(6)(atmp1)
485          lwz     miscreg7,MiscRegOffMSP(7)(atmp1)          l       miscreg7,MiscRegOffMSP(7)(atmp1)
486          lwz     miscreg8,MiscRegOffMSP(8)(atmp1)          l       miscreg8,MiscRegOffMSP(8)(atmp1)
487          lwz     miscreg9,MiscRegOffMSP(9)(atmp1)          l       miscreg9,MiscRegOffMSP(9)(atmp1)
488          lwz     miscreg10,MiscRegOffMSP(10)(atmp1)          l       miscreg10,MiscRegOffMSP(10)(atmp1)
489          lwz     miscreg11,MiscRegOffMSP(11)(atmp1)          l       miscreg11,MiscRegOffMSP(11)(atmp1)
490          lwz     miscreg12,MiscRegOffMSP(12)(atmp1)          l       miscreg12,MiscRegOffMSP(12)(atmp1)
491          lwz     miscreg13,MiscRegOffMSP(13)(atmp1)          l       miscreg13,MiscRegOffMSP(13)(atmp1)
492          lwz     miscreg14,MiscRegOffMSP(14)(atmp1)          l       miscreg14,MiscRegOffMSP(14)(atmp1)
493          lwz     stdlink,LinkRegOffMSP(atmp1)          l       stdlink,LinkRegOffMSP(atmp1)
494          lwz     varptr,VarPtrOffMSP(atmp1)          l       varptr,VarPtrOffMSP(atmp1)
495          lwz     basereg,BasePtrOffMSP(atmp1)          l       basereg,BasePtrOffMSP(atmp1)
496          lwz     gclink,PCOffMSP(atmp1)          l       gclink,PCOffMSP(atmp1)
497          addi    basereg,basereg,32764           /* adjust baseReg */          ai      basereg,basereg,32764           /* adjust baseReg */
498                                                  /* check for pending signals */                                                  /* check for pending signals */
499          lwz     atmp1,NPendingSysOffVSP(atmp2)          l       atmp1,NPendingSysOffVSP(atmp2)
500          lwz     atmp3,NPendingOffVSP(atmp2)          l       atmp3,NPendingOffVSP(atmp2)
501          add     atmp1,atmp1,atmp3          a       atmp1,atmp1,atmp3
502          cmpi    CR0,atmp1,0          cmpi    CR0,atmp1,0
503          bf      CR0_EQ,pending_sigs          bbf     CR0_EQ,pending_sigs
504    
505    
506  ENTRY(ml_go)  GLOBAL(ml_go)
507    ml_go:
508          cmpl    CR0,limitptr,allocptr          cmpl    CR0,limitptr,allocptr
509          mtlr    gclink          mtlr    gclink
510    
# Line 516  Line 512 
512          mtfsfi  2,0          mtfsfi  2,0
513          mtfsfi  1,0          mtfsfi  1,0
514          mtfsfi  0,0          mtfsfi  0,0
515          li      0,0          lil     0,0
516          mtxer   0          mtxer   0
517          blr                             /* jump to ML code */          br                              /* jump to ML code */
518    
519  pending_sigs:                           /* there are pending signals */  pending_sigs:                           /* there are pending signals */
520          lwz     atmp1,InSigHandlerOffVSP(atmp2)          l       atmp1,InSigHandlerOffVSP(atmp2)
521          cmpi    CR0,atmp1,0          cmpi    CR0,atmp1,0
522          bf      CR0_EQ,CSYM(ml_go)          bbf     CR0_EQ,ml_go
523                                          /* check if currently handling a signal */                                          /* check if currently handling a signal */
524          lwz     atmp1,InSigHandlerOffVSP(atmp2)          l       atmp1,InSigHandlerOffVSP(atmp2)
525          cmpi    CR0,atmp1,0          cmpi    CR0,atmp1,0
526          bf      CR0_EQ,CSYM(ml_go)          bbf     CR0_EQ,ml_go
527    
528            lil     0,1
529            st      0,HandlerPendingOffVSP(atmp2)
530            ai      limitptr,allocptr,0
531            b       ml_go
532    
         li      0,1  
         stw     0,HandlerPendingOffVSP(atmp2)  
         addi    limitptr,allocptr,0  
         b       CSYM(ml_go)  
533    
534    GLOBAL(.SaveFPRegs)
535            .align 2
536    
537  ML_CODE_HDR(array_a)  ML_CODE_HDR(array_a)
538          CHECKLIMIT(FUN_MASK,array_a_limit)          CHECKLIMIT(FUN_MASK,array_a_limit)
539          lwz     atmp2,0(stdarg)         /* atmp2 := tagged length */          l       atmp2,0(stdarg)         /* atmp2 := tagged length */
540          srawi   atmp2,atmp2,1           /* atmp2 := untagged length */          srai    atmp2,atmp2,1           /* atmp2 := untagged length */
541          cmpi    CR0,atmp2,SMALL_OBJ_SZW /* is this a large object */          cmpi    CR0,atmp2,SMALL_OBJ_SZW /* is this a large object */
542          bf      CR0_LT,array_a_large          bbf     CR0_LT,array_a_large
543          slwi    atmp3,atmp2,TAG_SHIFTW  /* atmp3 := build descriptor */          sli     atmp3,atmp2,TAG_SHIFTW  /* atmp3 := build descriptor */
544          ori     atmp3,atmp3,MAKE_TAG(DTAG_array)          oril    atmp3,atmp3,MAKE_TAG(DTAG_array)
545          stw     atmp3,0(allocptr)       /* store the descriptor */          st      atmp3,0(allocptr)       /* store the descriptor */
546          addi    allocptr,allocptr,4     /* points to new object */          ai      allocptr,allocptr,4     /* points to new object */
547          lwz     atmp4,4(stdarg)         /* atmp4 := get initial value */          l       atmp4,4(stdarg)         /* atmp4 := get initial value */
548          addi    stdarg,allocptr,0       /* put ptr in return register */          ai      stdarg,allocptr,0       /* put ptr in return register */
549          slwi    atmp2,atmp2,2           /* atmp2 := length in bytes */          sli     atmp2,atmp2,2           /* atmp2 := length in bytes */
550          add     atmp1,atmp2,allocptr    /* beyond last word of new array */          a       atmp1,atmp2,allocptr    /* beyond last word of new array */
551  array_a_2:                              /* loop */  array_a_2:                              /* loop */
552          addi    allocptr,allocptr,4     /* on to the next word */          ai      allocptr,allocptr,4     /* on to the next word */
553          cmp     CR0,allocptr,atmp1          cmp     CR0,allocptr,atmp1
554          stw     atmp4,-4(allocptr)      /* store the value */          st      atmp4,-4(allocptr)      /* store the value */
555          bf      CR0_EQ, array_a_2       /* if not off the end, repeat */          bbf     CR0_EQ, array_a_2       /* if not off the end, repeat */
556                                          /* end loop */                                          /* end loop */
557          CONTINUE          CONTINUE
558  array_a_large:                          /* off-line allocation */  array_a_large:                          /* off-line allocation */
559          li      atmp1,FUN_MASK          lil     atmp1,FUN_MASK
560          li      atmp4,REQ_ALLOC_ARRAY          lil     atmp4,REQ_ALLOC_ARRAY
561          b       set_request          b       set_request
562    
563    
564  ML_CODE_HDR(create_b_a)  ML_CODE_HDR(create_b_a)
565          CHECKLIMIT(FUN_MASK,create_b_a_limit)          CHECKLIMIT(FUN_MASK,create_b_a_limit)
566          srawi   atmp2,stdarg,1          /* atmp1 = length */          srai    atmp2,stdarg,1          /* atmp1 = length */
567          addi    atmp2,atmp2,3          ai      atmp2,atmp2,3
568          srawi   atmp2,atmp2,2           /* length in words (including desc) */          srai    atmp2,atmp2,2           /* length in words (including desc) */
569          cmpi    CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */          cmpi    CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */
570          bf     CR0_LT,create_b_a_large          bbf     CR0_LT,create_b_a_large
571    
572          srawi   atmp3,stdarg,1          /* build descriptor in atmp3 */          srai    atmp3,stdarg,1          /* build descriptor in atmp3 */
573          slwi    atmp3,atmp3,TAG_SHIFTW          sli     atmp3,atmp3,TAG_SHIFTW
574          ori     atmp3,atmp3,MAKE_TAG(DTAG_bytearray)          oril    atmp3,atmp3,MAKE_TAG(DTAG_bytearray)
575          stw     atmp3,0(allocptr)       /* store descriptor */          st      atmp3,0(allocptr)       /* store descriptor */
576          addi    stdarg,allocptr,4       /* pointer to new string */          ai      stdarg,allocptr,4       /* pointer to new string */
577          slwi    atmp2,atmp2,2           /* length in bytes */          sli     atmp2,atmp2,2           /* length in bytes */
578          addi    atmp2,atmp2,4           /* length + tag */          ai      atmp2,atmp2,4           /* length + tag */
579          add     allocptr,allocptr,atmp2 /* advance allocptr */          a       allocptr,allocptr,atmp2 /* advance allocptr */
580          CONTINUE          CONTINUE
581    
582  create_b_a_large:  create_b_a_large:
583          li      atmp1,FUN_MASK          lil     atmp1,FUN_MASK
584          li      atmp4,REQ_ALLOC_BYTEARRAY          lil     atmp4,REQ_ALLOC_BYTEARRAY
585          b       set_request          b       set_request
586    
587    
# Line 591  Line 590 
590  */  */
591  ML_CODE_HDR(create_s_a)  ML_CODE_HDR(create_s_a)
592          CHECKLIMIT(FUN_MASK,create_s_a_limit)          CHECKLIMIT(FUN_MASK,create_s_a_limit)
593          srawi   atmp2,stdarg,1          /* atmp1 = length */          srai    atmp2,stdarg,1          /* atmp1 = length */
594          addi    atmp2,atmp2,4          ai      atmp2,atmp2,4
595          srawi   atmp2,atmp2,2           /* length in words (including desc) */          srai    atmp2,atmp2,2           /* length in words (including desc) */
596          cmpi    CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */          cmpi    CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */
597          bf      CR0_LT,create_s_a_large          bbf     CR0_LT,create_s_a_large
598    
599          srawi   atmp1,stdarg,1          /* build descriptor in atmp1 */          srai    atmp1,stdarg,1          /* build descriptor in atmp1 */
600          slwi    atmp1,atmp1,TAG_SHIFTW          sli     atmp1,atmp1,TAG_SHIFTW
601          ori     atmp1,atmp1,MAKE_TAG(DTAG_string)          oril    atmp1,atmp1,MAKE_TAG(DTAG_string)
602          stw     atmp1,0(allocptr)       /* store descriptor */          st      atmp1,0(allocptr)       /* store descriptor */
603          addi    stdarg,allocptr,4       /* pointer to new string */          ai      stdarg,allocptr,4       /* pointer to new string */
604          slwi    atmp2,atmp2,2           /* length in bytes */          sli     atmp2,atmp2,2           /* length in bytes */
605          addi    atmp2,atmp2,4           /* + tag */          ai      atmp2,atmp2,4           /* + tag */
606          add     allocptr,allocptr,atmp2 /* advance allocptr */          a       allocptr,allocptr,atmp2 /* advance allocptr */
607          li      0,0          lil     0,0
608          stw     0,-4(allocptr)          /* zero in last word */          st      0,-4(allocptr)          /* zero in last word */
609          CONTINUE          CONTINUE
610    
611  create_s_a_large:  create_s_a_large:
612          li      atmp1,FUN_MASK          lil     atmp1,FUN_MASK
613          li      atmp4,REQ_ALLOC_STRING          lil     atmp4,REQ_ALLOC_STRING
614          b       set_request          b       set_request
615    
616    
617    
618  ML_CODE_HDR(create_r_a)  ML_CODE_HDR(create_r_a)
619          CHECKLIMIT(FUN_MASK,create_r_a_limit)          CHECKLIMIT(FUN_MASK,create_r_a_limit)
620          srawi   atmp2,stdarg,1          /* atmp1 = length */          srai    atmp2,stdarg,1          /* atmp1 = length */
621          slwi    atmp2,atmp2,1           /* length in words */          sli     atmp2,atmp2,1           /* length in words */
622          cmpi    CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */          cmpi    CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */
623          bf      CR0_LT,create_r_a_large          bbf     CR0_LT,create_r_a_large
624    
625          srawi   atmp3,stdarg,1          /* descriptor in atmp3 */          srai    atmp3,stdarg,1          /* descriptor in atmp3 */
626          slwi    atmp3,atmp3,TAG_SHIFTW          sli     atmp3,atmp3,TAG_SHIFTW
627          ori     atmp3,atmp3,MAKE_TAG(DTAG_realdarray)          oril    atmp3,atmp3,MAKE_TAG(DTAG_realdarray)
628  #ifdef ALIGN_REALDS  #ifdef ALIGN_REALDS
629          ori     allocptr,allocptr,4          oril    allocptr,allocptr,4
630  #endif  #endif
631          stw     atmp3,0(allocptr)          st      atmp3,0(allocptr)
632          addi    stdarg,allocptr,4       /* pointer to new realarray */          ai      stdarg,allocptr,4       /* pointer to new realarray */
633          slwi    atmp2,atmp2,2           /* length in bytes */          sli     atmp2,atmp2,2           /* length in bytes */
634          addi    atmp2,atmp2,4           /* plus tag */          ai      atmp2,atmp2,4           /* plus tag */
635          add     allocptr,allocptr,atmp2 /* new allocptr */          a       allocptr,allocptr,atmp2 /* new allocptr */
636          CONTINUE          CONTINUE
637  create_r_a_large:  create_r_a_large:
638          li      atmp1,FUN_MASK          lil     atmp1,FUN_MASK
639          li      atmp4,REQ_ALLOC_REALDARRAY          lil     atmp4,REQ_ALLOC_REALDARRAY
640          b       set_request          b       set_request
641    
642    
643  ML_CODE_HDR(create_v_a)  ML_CODE_HDR(create_v_a)
644          CHECKLIMIT(FUN_MASK,create_v_a_limit)          CHECKLIMIT(FUN_MASK,create_v_a_limit)
645          lwz     atmp1,0(stdarg)         /* atmp1 := tagged length */          l       atmp1,0(stdarg)         /* atmp1 := tagged length */
646          srawi   atmp1,atmp1,1           /* untagged length */          srai    atmp1,atmp1,1           /* untagged length */
647          cmpi    CR0,atmp1,SMALL_OBJ_SZW /* is this a small object */          cmpi    CR0,atmp1,SMALL_OBJ_SZW /* is this a small object */
648          bf      CR0_LT,create_v_a_large          bbf     CR0_LT,create_v_a_large
649    
650          slwi    atmp2,atmp1,TAG_SHIFTW  /* build descriptor in atmp2 */          sli     atmp2,atmp1,TAG_SHIFTW  /* build descriptor in atmp2 */
651          ori     atmp2,atmp2,MAKE_TAG(DTAG_vector)          oril    atmp2,atmp2,MAKE_TAG(DTAG_vector)
652          stw     atmp2,0(allocptr)          st      atmp2,0(allocptr)
653          addi    allocptr,allocptr,4          ai      allocptr,allocptr,4
654          lwz     atmp2,4(stdarg)         /* atmp2 := list */          l       atmp2,4(stdarg)         /* atmp2 := list */
655          addi    stdarg,allocptr,0       /* stdarg := vector */          ai      stdarg,allocptr,0       /* stdarg := vector */
656          li      atmp3,ML_nil          lil     atmp3,ML_nil
657    
658  create_v_a_1:  create_v_a_1:
659          lwz     atmp1,0(atmp2)          /* atmp1:=hd(atmp2) */          l       atmp1,0(atmp2)          /* atmp1:=hd(atmp2) */
660          lwz     atmp2,4(atmp2)          /* atmp2:=tl(atmp2) */          l       atmp2,4(atmp2)          /* atmp2:=tl(atmp2) */
661          cmp     CR0,atmp2,atmp3          cmp     CR0,atmp2,atmp3
662          stw     atmp1,0(allocptr)       /* store word */          st      atmp1,0(allocptr)       /* store word */
663          addi    allocptr,allocptr,4          ai      allocptr,allocptr,4
664          bf      CR0_EQ,create_v_a_1          bbf     CR0_EQ,create_v_a_1
665    
666          CONTINUE          CONTINUE
667    
668  create_v_a_large:  create_v_a_large:
669          li      atmp1,FUN_MASK          lil     atmp1,FUN_MASK
670          li      atmp4,REQ_ALLOC_VECTOR          lil     atmp4,REQ_ALLOC_VECTOR
671          b       set_request          b       set_request
672    
673    
674  #if defined(USE_TOC)          .csect  [RO]
675          .toc          .toc
676  T.floor_CONST:  floor_CONST:    .tc     fd43300800_0[TC],0x43300800, 0
         .tc     H.floor_CONST[TC],floor_CONST  
 T.floor_MAXINT:  
         .tc     H.floor_MAXINT[TC],floor_MAXINT  
 #endif  
         RO_DATA  
         ALIGN8  
 floor_CONST:  
         DOUBLE(4512395720392704.0)  
 floor_MAXINT:  
         DOUBLE(1073741824.0)  
677    
678          TEXT          .csect  [PR]
679          /*          /*
680          ** floor_a : real -> int          ** floor_a : real -> int
681          **      The overflow test here is not quite          **  Caller must ensure arg in range.
         **      accurate. MINIT = -MAXINT instead of  
         **      MININT = -(MAXINT + 1). Should fix this  
         **      eventually!!  
         **  
682          **      This code essentially loads 1.0*2^52 into          **      This code essentially loads 1.0*2^52 into
683          **      register f3. A floating add will internally          **      register f3. A floating add will internally
684          **      perform an exponent alignment, which will          **      perform an exponent alignment, which will
# Line 701  Line 686 
686          */          */
687  ML_CODE_HDR(floor_a)  ML_CODE_HDR(floor_a)
688          lfd     1, 0(stdarg)          lfd     1, 0(stdarg)
 #ifdef USE_TOC  
         lwz     atmp1, T.floor_MAXINT(2)  
         lfd     0, 0(atmp1)  
 #else  
         lis     atmp1, floor_MAXINT@ha  
         lfd     0, floor_MAXINT@l(atmp1)  
 #endif  
         fabs    5, 1  
         fcmpo   CR0,5,0  
         bt      CR0_GT,floor_overflow  
   
689          /*          /*
690          ** Neat thing here is that this code works for          ** Neat thing here is that this code works for
691          ** both +ve and -ve floating point numbers.          ** both +ve and -ve floating point numbers.
692          */          */
693          mffs    0          mffs    0
694          stfd    0,0(allocptr)   /* steal the allocptr for a second */          stfd    0,0(allocptr)   /* steal the allocptr for a second */
695          lwz     0, 4(allocptr)          l       0, 4(allocptr)
696          mtfsb1  30          mtfsb1  30
697          mtfsb1  31          mtfsb1  31
698  #ifdef USE_TOC          lfd     3,floor_CONST(2)
699          lwz     atmp1, T.floor_CONST(2)          fa      6,1,3
         lfd     3, 0(atmp1)  
 #else  
         lis     atmp1, floor_CONST@ha  
         lfd     3, floor_CONST@l(atmp1)  
 #endif  
         fadd    6,1,3  
700          stfd    6,FLOOR_OFFSET(sp)          stfd    6,FLOOR_OFFSET(sp)
701          lwz     stdarg,FLOOR_OFFSET+4(sp)          l       stdarg,FLOOR_OFFSET+4(sp)
702          add     stdarg,stdarg,stdarg          a       stdarg,stdarg,stdarg
703          addi    stdarg,stdarg,1          ai      stdarg,stdarg,1
704    
705          andi.   0,0, 0xf          andil.  0,0, 0xf
706          mtfsf   0xff,0          mtfsf   0xff,0
707          CONTINUE          CONTINUE
708    
 floor_overflow:  
         tweq    0,0  
   
709    
710    
711  ML_CODE_HDR(logb_a)  ML_CODE_HDR(logb_a)
712          lwz     stdarg,0(stdarg)        /* most significant part */          l       stdarg,0(stdarg)        /* most significant part */
713          srawi   stdarg,stdarg,20        /* throw out 20 low bits */          srai    stdarg,stdarg,20        /* throw out 20 low bits */
714          andi.   stdarg,stdarg,0x07ff    /* clear all but 11 low bits */          andil.  stdarg,stdarg,0x07ff    /* clear all but 11 low bits */
715          addi    stdarg,stdarg,-1023     /* subtract 1023 */          ai      stdarg,stdarg,-1023     /* subtract 1023 */
716          slwi    stdarg,stdarg,1         /* make room for tag bit */          sli     stdarg,stdarg,1         /* make room for tag bit */
717          addi    stdarg,stdarg,1         /* add the tag bit */          ai      stdarg,stdarg,1         /* add the tag bit */
718          CONTINUE          CONTINUE
719    
720    
# Line 759  Line 724 
724  */  */
725  ML_CODE_HDR(scalb_a)  ML_CODE_HDR(scalb_a)
726          CHECKLIMIT(FUN_MASK,scalb_v_limit)          CHECKLIMIT(FUN_MASK,scalb_v_limit)
727          lwz     atmp1,4(stdarg)         /* atmp1 := y */          l       atmp1,4(stdarg)         /* atmp1 := y */
728          srawi   atmp1,atmp1,1           /* atmp1 := machine int y */          srai    atmp1,atmp1,1           /* atmp1 := machine int y */
729          lwz     stdarg,0(stdarg)        /* stdarg := x */          l       stdarg,0(stdarg)        /* stdarg := x */
730          lwz     atmp2,0(stdarg)         /* atmp2 := MSW(x) */          l       atmp2,0(stdarg)         /* atmp2 := MSW(x) */
731          lis     0,0x7ff0                /* r0 := 0x7ff0,0000 */          liu     0,0x7ff0                /* r0 := 0x7ff0,0000 */
732          and.    atmp3,atmp2,0           /* atmp3 := atmp2 & 0x7ff00000 */          and.    atmp3,atmp2,0           /* atmp3 := atmp2 & 0x7ff00000 */
733          bt      CR0_EQ,scalb_all_done          bbt     CR0_EQ,scalb_all_done
734    
735          srawi   atmp3,atmp3,20          /* atmp3 := ieee(exp) */          srai    atmp3,atmp3,20          /* atmp3 := ieee(exp) */
736          add.    atmp1,atmp1,atmp3       /* scale exponent */          a.      atmp1,atmp1,atmp3       /* scale exponent */
737          bt      CR0_LT,scalb_underflow          bbt     CR0_LT,scalb_underflow
738    
739          cmpi    CR0,atmp1,2047          /* max. ieee(exp) */          cmpi    CR0,atmp1,2047          /* max. ieee(exp) */
740          bf      CR0_LT,scalb_overflow          bbf     CR0_LT,scalb_overflow
741    
742          not     0,0                     /* r0 := not(r0) */          sfi     0,0,-1                  /* r0 := not(r0) */
743          and     atmp2,atmp2,0           /* atmp2 := high mantessa bits + sign */          and     atmp2,atmp2,0           /* atmp2 := high mantessa bits + sign */
744          slwi    atmp1,atmp1,20          /* atmp1 := new exponent */          sli     atmp1,atmp1,20          /* atmp1 := new exponent */
745          or      atmp1,atmp1,atmp2       /* atmp1 := new MSB(x) */          or      atmp1,atmp1,atmp2       /* atmp1 := new MSB(x) */
746          lwz     atmp2, 4(stdarg)          l       atmp2, 4(stdarg)
747    
748  scalb_write_out:  scalb_write_out:
749          stw     atmp1, 4(allocptr)          st      atmp1, 4(allocptr)
750          stw     atmp2, 8(allocptr)          st      atmp2, 8(allocptr)
751          li      atmp3, DESC_reald          lil     atmp3, DESC_reald
752          stw     atmp3, 0(allocptr)          st      atmp3, 0(allocptr)
753          addi    stdarg,allocptr,4          ai      stdarg,allocptr,4
754          addi    allocptr,allocptr,12          ai      allocptr,allocptr,12
755    
756  scalb_all_done:  scalb_all_done:
757          CONTINUE          CONTINUE
758    
759  scalb_underflow:  scalb_underflow:
760          li      atmp1,0          lil     atmp1,0
761          li      atmp2,0          lil     atmp2,0
762          b       scalb_write_out          b       scalb_write_out
763    
764  LABEL(scalb_overflow)  LABEL(scalb_overflow)
# Line 802  Line 767 
767    
768    
769  ML_CODE_HDR(try_lock_a)  ML_CODE_HDR(try_lock_a)
770          lwz     atmp1,0(stdarg)          l       atmp1,0(stdarg)
771          li      atmp2,1                 /* ML_false */          lil     atmp2,1                 /* ML_false */
772          stw     atmp2,0(stdarg)          st      atmp2,0(stdarg)
773          addi    stdarg,atmp1,0          ai      stdarg,atmp1,0
774          CONTINUE          CONTINUE
775    
776    
777  ML_CODE_HDR(unlock_a)  ML_CODE_HDR(unlock_a)
778          li      atmp1,3                 /* ML_true */          lil     atmp1,3                 /* ML_true */
779          stw     atmp1,0(stdarg)          st      atmp1,0(stdarg)
780          li      stdarg,1                /* just return unit */          lil     stdarg,1                /* just return unit */
781          CONTINUE          CONTINUE
782    
783    
# Line 823  Line 788 
788  #define ctmp3 10  #define ctmp3 10
789    
790    
791  CENTRY(SaveFPRegs)  LABEL(.SaveFPRegs)
792          stfd    14, 4(3)          stfd    14, 4(3)
793          stfd    15, 12(3)          stfd    15, 12(3)
794          stfd    16, 20(3)          stfd    16, 20(3)
# Line 843  Line 808 
808          stfd    30, 132(3)          stfd    30, 132(3)
809          stfd    31, 140(3)          stfd    31, 140(3)
810    
811          blr          br
812    
813  CENTRY(RestoreFPRegs)  GLOBAL(.RestoreFPRegs)
814            .align 2
815    LABEL(.RestoreFPRegs)
816          lfd     14, 0(3)          lfd     14, 0(3)
817          lfd     15, 8(3)          lfd     15, 8(3)
818          lfd     16, 16(3)          lfd     16, 16(3)
# Line 864  Line 831 
831          lfd     29, 120(3)          lfd     29, 120(3)
832          lfd     30, 128(3)          lfd     30, 128(3)
833          lfd     31, 136(3)          lfd     31, 136(3)
834          blr          br
   
 #if defined(OPSYS_MKLINUX)  
   
 #define CACHE_LINE_SZB          32  
 #define CACHE_LINE_MASK         (CACHE_LINE_SZB-1)  
 #define CACHE_LINE_BITS         26  
   
 /* FlushICache:  
  *  
  *   void FlushICache (Addr_t addr, Addr_t nbytes)  
  */  
 CENTRY(FlushICache)  
         add     4,3,4                   /* stop := addr+nbytes */  
         addic   4,4,CACHE_LINE_MASK     /* stop := stop + CACHE_LINE_MASK */  
         rlwinm  4,4,0,0,CACHE_LINE_BITS /* stop := stop & ~CACHE_LINE_MASK */  
 L_FlushICache_1:  
         cmplw   1,3,4                   /* while (addr < stop) */  
         bc      4,4,L_FlushICache_2  
         dcbf    0,3                     /*   flush addr */  
         icbi    0,3                     /*   invalidate addr */  
         addi    3,3,CACHE_LINE_SZB      /*   addr := addr + CACHE_LINE_SZB */  
         b       L_FlushICache_1         /* end while */  
 L_FlushICache_2:  
         blr  
   
 #endif  
835    

Legend:
Removed from v.7  
changed lines
  Added in v.8

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