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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 9 - (view) (download)

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

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