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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 250 - (view) (download)

1 : monnier 249 /* PPC.prim.asm
2 :     *
3 :     * COPYRIGHT (c) 1997 Bell Labs, Lucent Technologies.
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 "ml-limits.h"
16 :     #include "mlstate-offsets.h" /** this file is generated **/
17 :    
18 :     /** register usage **/
19 :    
20 :     #define sp 1
21 :     #define stackptr sp
22 :    
23 :     #define allocptr 14
24 :     #define limitptr 15
25 :     #define storeptr 16
26 :     #define stdlink 17
27 :     #define stdclos 18
28 :     #define stdarg 19
29 :     #define stdcont 20
30 :     #define exncont 21
31 :     #define varptr 22
32 :     #define miscreg0 24
33 :     #define miscreg1 25
34 :     #define miscreg2 26
35 :    
36 :     #define pc 28
37 :    
38 :    
39 :     #define atmp1 29
40 :     #define atmp2 30
41 :     #define atmp3 31
42 :     #define atmp4 13
43 :    
44 :     /* stackframe layout:
45 :     * Note: 1. The offset of cvti2d tmp is used in rs6000.sml
46 :     * float load/store offset is hardwired in rs6000instr.sml
47 :     *
48 :     * +-------------------+
49 :     * sp--> 0(sp) | mlstate addr |
50 :     * +-------------------+
51 :     * 4(sp) | _startgc addr |
52 :     * +-------------------+
53 :     * 8(sp) | cvti2d const |
54 :     * +-------------------+
55 :     * 16(sp) | cvti2d tmp2 |
56 :     * +-------------------+
57 :     * 24(sp) | float load/store |
58 :     * +-------------------+
59 :     * 32(sp) | floor tmp |
60 :     * +-------------------+
61 :     * 40(sp) | unused |
62 :     * +-------------------+
63 :     * 44(sp) | unused |
64 :     * +-------------------+
65 :     * argblock(sp) | C calleesave regs |
66 :     * . .
67 :     * . .
68 :     * +-------------------+
69 :     * argblock+92(sp) | |
70 :     */
71 :    
72 :    
73 :     /** MLState offsets **/
74 :     #define argblock 48
75 :     #define savearea (23*4+4) /* lr,cr,1,2,13-31,padding */
76 :     #define framesize 4096
77 :     #define MLSTATE_OFFSET 0
78 :     #define STARTGC_OFFSET 4
79 :     #define CVTI2D_OFFSET 8
80 :     #define FLOOR_OFFSET 32
81 :    
82 :     /** offsets in condition register CR.0 **/
83 :    
84 :     #define CR0_LT 0
85 :     #define CR0_GT 1
86 :     #define CR0_EQ 2
87 :     #define CR0_SO 3
88 :    
89 :     #define CR0 0
90 :    
91 :     /** special registers **/
92 :    
93 :     #define SPR_LR 8
94 :    
95 :     /** C parameter passing conventions **/
96 :     #define CARG1 3
97 :     #define CRESULT1 3
98 :    
99 :    
100 :     #define CONTINUE \
101 :     cmpl CR0,allocptr,limitptr; \
102 :     mtlr stdcont; \
103 :     blr
104 :    
105 :     #define CHECKLIMIT(label) \
106 :     bt CR0_LT, label; \
107 :     addi pc, stdlink,0; \
108 :     b saveregs; \
109 :     label:
110 :    
111 :     .extern CSYM(_PollFreq0)
112 :     .extern CSYM(_PollEvent0)
113 :     .extern CSYM(saveregs)
114 :    
115 :     #if defined (USE_TOC)
116 :     /* create table of contents entries for things we need the address of. */
117 :     .toc
118 :     T._PollFreq0:
119 :     .tc H._PollFreq0[TC],CSYM(_PollFreq0)
120 :     T._PollEvent0:
121 :     .tc H._PollEvent0[TC],CSYM(_PollEvent0)
122 :     T.saveregs:
123 :     .tc H.saveregs[TC],CSYM(saveregs)
124 :     T.cvti2d_CONST:
125 :     .tc H.cvti2d_CONST[TC],cvti2d_CONST
126 :     #endif
127 :     RO_DATA
128 :     ALIGN8
129 :     cvti2d_CONST:
130 :     DOUBLE(4503601774854144.0)
131 :    
132 :     TEXT
133 :     /* sig_return : ('a cont * 'a) -> 'b
134 :     */
135 :     ML_CODE_HDR(sigh_return_a)
136 :     li atmp4,REQ_SIG_RETURN
137 :     li stdlink, ML_unit
138 :     li stdclos, ML_unit
139 :     li pc, ML_unit
140 :     b set_request
141 :    
142 :     ENTRY(sigh_resume)
143 :     li atmp4, REQ_SIG_RESUME
144 :     li stdlink, ML_unit
145 :     li stdclos, ML_unit
146 :     li pc, ML_unit
147 :     b set_request
148 :    
149 :     /* pollh_return_a:
150 :     * The return continuation for the ML poll handler.
151 :     */
152 :     ML_CODE_HDR(pollh_return_a)
153 :     li atmp4,REQ_POLL_RETURN
154 :     li stdlink, ML_unit
155 :     li stdclos, ML_unit
156 :     li pc, ML_unit
157 :     b set_request
158 :    
159 :     /* pollh_resume:
160 :     * Resume execution at the point at which a poll event occurred.
161 :     */
162 :     ENTRY(pollh_resume)
163 :     li atmp4,REQ_POLL_RESUME
164 :     li stdlink, ML_unit
165 :     li stdclos, ML_unit
166 :     li pc, ML_unit
167 :     b set_request
168 :    
169 :     /* exception handler for ML functions called from C */
170 :     ML_CODE_HDR(handle_a)
171 :     li atmp4,REQ_EXN
172 :     addi pc, stdlink, 0
173 :     b set_request
174 :    
175 :    
176 :     /* continuation for ML functions called from C */
177 :     ML_CODE_HDR(return_a)
178 :     li atmp4,REQ_RETURN
179 :     li stdlink, ML_unit
180 :     li stdclos, ML_unit
181 :     li pc, ML_unit
182 :     b set_request
183 :    
184 :    
185 :     ENTRY(request_fault)
186 :     li atmp4,REQ_FAULT
187 :     addi pc, stdlink, 0
188 :     b set_request
189 :    
190 :    
191 :     /* bind_cfun : (string * string) -> c_function
192 :     */
193 :     ML_CODE_HDR(bind_cfun_a)
194 :     CHECKLIMIT(bind_cfun_v_limit)
195 :     li atmp4,REQ_BIND_CFUN
196 :     b set_request
197 :    
198 :     ML_CODE_HDR(build_literals_a)
199 :     CHECKLIMIT(build_literals_v_limit)
200 :     li atmp4,REQ_BUILD_LITERALS
201 :     b set_request
202 :    
203 :     ML_CODE_HDR(callc_a)
204 :     CHECKLIMIT(callc_v_limit)
205 :     li atmp4,REQ_CALLC
206 :     b set_request
207 :    
208 :    
209 :     ENTRY(saveregs)
210 :     li atmp4, REQ_GC
211 :     mflr pc
212 :     /* fall through */
213 :    
214 :     set_request:
215 :     lwz atmp3,MLSTATE_OFFSET(sp) /* save the minimal ML state */
216 :     lwz atmp2,VProcOffMSP(atmp3) /* atmp2 := VProc State ptr */
217 :     li 0,0
218 :     stw 0,InMLOffVSP(atmp2) /* note that we have left ML */
219 :     stw allocptr,AllocPtrOffMSP(atmp3)
220 :     stw limitptr,LimitPtrOffMSP(atmp3)
221 :     stw storeptr,StorePtrOffMSP(atmp3)
222 :     stw stdlink,LinkRegOffMSP(atmp3)
223 :     stw pc,PCOffMSP(atmp3)
224 :     stw stdarg,StdArgOffMSP(atmp3)
225 :     stw stdcont,StdContOffMSP(atmp3)
226 :     stw stdclos,StdClosOffMSP(atmp3)
227 :     stw varptr,VarPtrOffMSP(atmp3)
228 :     stw exncont,ExnPtrOffMSP(atmp3)
229 :     stw miscreg0,Misc0OffMSP(atmp3)
230 :     stw miscreg1,Misc1OffMSP(atmp3)
231 :     stw miscreg2,Misc2OffMSP(atmp3)
232 :    
233 :     addi 3,atmp4,0 /* request as argument */
234 :    
235 :     restore_c_regs:
236 :     lwz 2, (argblock+4)(sp)
237 :     lwz 13, (argblock+8)(sp)
238 :     lwz 14, (argblock+12)(sp)
239 :     lwz 15, (argblock+16)(sp)
240 :     lwz 16, (argblock+20)(sp)
241 :     lwz 17, (argblock+24)(sp)
242 :     lwz 18, (argblock+28)(sp)
243 :     lwz 19, (argblock+32)(sp)
244 :     lwz 20, (argblock+36)(sp)
245 :     lwz 21, (argblock+40)(sp)
246 :     lwz 22, (argblock+44)(sp)
247 :     lwz 23, (argblock+48)(sp)
248 :     lwz 24, (argblock+52)(sp)
249 :     lwz 25, (argblock+56)(sp)
250 :     lwz 26, (argblock+60)(sp)
251 :     lwz 27, (argblock+64)(sp)
252 :     lwz 28, (argblock+68)(sp)
253 :     lwz 29, (argblock+72)(sp)
254 :     lwz 30, (argblock+76)(sp)
255 :     lwz 31, (argblock+80)(sp)
256 :     lwz 0, (argblock+84)(sp)
257 :     mtlr 0
258 :     lwz 0, (argblock+88)(sp)
259 :     mtcrf 0x80, 0
260 :     addi sp,sp,framesize
261 :     blr
262 :    
263 :    
264 :    
265 :     CENTRY(restoreregs)
266 :     addi sp,sp,-framesize
267 :     #if defined(USE_TOC)
268 :     lwz 0,T.saveregs(2)
269 :     #else
270 :     lis 0, CSYM(saveregs)@ha /* GPR0 <- addrof(saveregs) */
271 :     addi 0, 0, CSYM(saveregs)@l
272 :     #endif
273 :     stw 3, MLSTATE_OFFSET(sp)
274 :     stw 0, STARTGC_OFFSET(sp)
275 :     #if defined(USE_TOC)
276 :     lwz 4, T.cvti2d_CONST(2) /* GPR2 is RTOC */
277 :     lfd 0, 0(4)
278 :     #else
279 :     lis 4, cvti2d_CONST@ha
280 :     lfd 0, cvti2d_CONST@l(4)
281 :     #endif
282 :     stfd 0, CVTI2D_OFFSET(sp)
283 :    
284 :     stw 2, argblock+4(sp)
285 :     stw 13, argblock+8(sp)
286 :     stw 14, argblock+12(sp)
287 :     stw 15, argblock+16(sp)
288 :     stw 16, argblock+20(sp)
289 :     stw 17, argblock+24(sp)
290 :     stw 18, argblock+28(sp)
291 :     stw 19, argblock+32(sp)
292 :     stw 20, argblock+36(sp)
293 :     stw 21, argblock+40(sp)
294 :     stw 22, argblock+44(sp)
295 :     stw 23, argblock+48(sp)
296 :     stw 24, argblock+52(sp)
297 :     stw 25, argblock+56(sp)
298 :     stw 26, argblock+60(sp)
299 :     stw 27, argblock+64(sp)
300 :     stw 28, argblock+68(sp)
301 :     stw 29, argblock+72(sp)
302 :     stw 30, argblock+76(sp)
303 :     stw 31, argblock+80(sp)
304 :     mflr 0
305 :     stw 0, argblock+84(sp)
306 :     mfcr 0
307 :     stw 0, argblock+88(sp)
308 :    
309 :     and atmp1,3,3 /* atmp1 := MLState pointer */
310 :    
311 :     lwz allocptr,AllocPtrOffMSP(atmp1)
312 :     lwz limitptr,LimitPtrOffMSP(atmp1)
313 :     lwz storeptr,StorePtrOffMSP(atmp1)
314 :     lwz atmp2,VProcOffMSP(atmp1) /* atmp2 := VProc State ptr */
315 :     li atmp3,1
316 :     stw atmp3,InMLOffVSP(atmp2) /* we are entering ML code */
317 :     lwz stdarg,StdArgOffMSP(atmp1)
318 :     lwz stdcont,StdContOffMSP(atmp1)
319 :     lwz stdclos,StdClosOffMSP(atmp1)
320 :     lwz exncont,ExnPtrOffMSP(atmp1)
321 :     lwz miscreg0,Misc0OffMSP(atmp1)
322 :     lwz miscreg1,Misc1OffMSP(atmp1)
323 :     lwz miscreg2,Misc2OffMSP(atmp1)
324 :     lwz stdlink,LinkRegOffMSP(atmp1)
325 :     lwz varptr,VarPtrOffMSP(atmp1)
326 :     lwz atmp3,PCOffMSP(atmp1)
327 :     mtlr atmp3
328 :     /* check for pending signals */
329 :     lwz atmp1,NPendingSysOffVSP(atmp2)
330 :     lwz atmp3,NPendingOffVSP(atmp2)
331 :     add atmp1,atmp1,atmp3
332 :     cmpi CR0,atmp1,0
333 :     bf CR0_EQ,pending_sigs
334 :    
335 :    
336 :     ENTRY(ml_go)
337 :     cmpl CR0,allocptr,limitptr
338 :     mtfsfi 3,0 /* Ensure that no exceptions are set */
339 :     mtfsfi 2,0
340 :     mtfsfi 1,0
341 :     mtfsfi 0,0
342 :     li 0,0
343 :     mtxer 0
344 :     blr /* jump to ML code */
345 :    
346 :     pending_sigs: /* there are pending signals */
347 :     lwz atmp1,InSigHandlerOffVSP(atmp2)
348 :     cmpi CR0,atmp1,0
349 :     bf CR0_EQ,CSYM(ml_go)
350 :     /* check if currently handling a signal */
351 :     lwz atmp1,InSigHandlerOffVSP(atmp2)
352 :     cmpi CR0,atmp1,0
353 :     bf CR0_EQ,CSYM(ml_go)
354 :    
355 :     li 0,1
356 :     stw 0,HandlerPendingOffVSP(atmp2)
357 :     addi limitptr,allocptr,0
358 :     b CSYM(ml_go)
359 :    
360 :     /* array : (int * 'a) -> 'a array
361 :     * Allocate and initialize a new array. This can cause GC.
362 :     */
363 :     ML_CODE_HDR(array_a)
364 :     CHECKLIMIT(array_a_limit)
365 :    
366 :     lwz atmp1,0(stdarg) /* atmp1 := length in words */
367 :     srawi atmp2, atmp1, 1 /* atmp2 := length (untagged) */
368 :     cmpi CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */
369 :     bf CR0_LT, array_a_large
370 :    
371 :     lwz stdarg,4(stdarg) /* initial value */
372 :     slwi atmp3,atmp2,TAG_SHIFTW /* build descriptor in tmp3 */
373 :     ori atmp3,atmp3,MAKE_TAG(DTAG_arr_data)
374 :     stw atmp3,0(allocptr) /* store descriptor */
375 :     addi allocptr,allocptr,4 /* points to new object */
376 :     addi atmp3,allocptr,0 /* array data ptr in atmp3 */
377 :    
378 :     array_a_1:
379 :     stw stdarg,0(allocptr) /* initialize array */
380 :     addi atmp2,atmp2,-1
381 :     addi allocptr,allocptr,4
382 :     cmpi CR0,atmp2,0
383 :     bf CR0_EQ,array_a_1
384 :    
385 :     /* allocate array header */
386 :     li atmp2,DESC_polyarr /* descriptor in tmp2 */
387 :     stw atmp2,0(allocptr) /* store descriptor */
388 :     addi allocptr, allocptr, 4 /* allocptr++ */
389 :     addi stdarg, allocptr, 0 /* result = header addr */
390 :     stw atmp3,0(allocptr) /* store pointer to data */
391 :     stw atmp1,4(allocptr)
392 :     addi allocptr,allocptr,8
393 :     CONTINUE
394 :     array_a_large: /* off-line allocation */
395 :     li atmp4,REQ_ALLOC_ARRAY
396 :     addi pc, stdlink,0
397 :     b set_request
398 :    
399 :     /* create_b : int -> bytearray
400 :     * Create a bytearray of the given length.
401 :     */
402 :     ML_CODE_HDR(create_b_a)
403 :     CHECKLIMIT(create_b_a_limit)
404 :    
405 :     srawi atmp2,stdarg,1 /* atmp2 = length (untagged int) */
406 :     addi atmp2,atmp2,3 /* atmp2 = length in words */
407 :     srawi atmp2,atmp2,2
408 :     cmpi CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */
409 :     bf CR0_LT,create_b_a_large
410 :    
411 :     /* allocate the data object */
412 :     slwi atmp1,atmp2,TAG_SHIFTW /* build descriptor in atmp1 */
413 :     ori atmp1,atmp1,MAKE_TAG(DTAG_raw32)
414 :     stw atmp1,0(allocptr) /* store the data descriptor */
415 :     addi allocptr,allocptr,4 /* allocptr++ */
416 :     addi atmp3, allocptr, 0 /* atmp3 = data object */
417 :     slwi atmp2, atmp2, 2 /* atmp2 = length in bytes */
418 :     add allocptr,allocptr,atmp2 /* allocptr += total length */
419 :    
420 :     /* allocate the header object */
421 :     li atmp1, DESC_word8arr /* header descriptor */
422 :     stw atmp1,0(allocptr)
423 :     addi allocptr, allocptr, 4 /* allocptr++ */
424 :     stw atmp3,0(allocptr) /* header data field */
425 :     stw stdarg,4(allocptr) /* header length field */
426 :     addi stdarg, allocptr, 0 /* stdarg = header object */
427 :     addi allocptr,allocptr,8 /* allocptr += 2 */
428 :     CONTINUE
429 :    
430 :     create_b_a_large: /* off-line allocation */
431 :     li atmp4,REQ_ALLOC_BYTEARRAY
432 :     addi pc, stdlink,0
433 :     b set_request
434 :    
435 :    
436 :     /*
437 :     ** create_s_a: int -> string
438 :     */
439 :     ML_CODE_HDR(create_s_a)
440 :     CHECKLIMIT(create_s_a_limit)
441 :    
442 :     srawi atmp2,stdarg,1 /* atmp2 = length(untagged int) */
443 :     addi atmp2,atmp2,4
444 :     srawi atmp2,atmp2,2 /* length in words (including desc) */
445 :     cmpi CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */
446 :     bf CR0_LT,create_s_a_large
447 :    
448 :     slwi atmp1,atmp2,TAG_SHIFTW /* build descriptor in atmp3 */
449 :     ori atmp1,atmp1,MAKE_TAG(DTAG_raw32)
450 :     stw atmp1,0(allocptr) /* store descriptor */
451 :     addi allocptr,allocptr,4 /* allocptr++ */
452 :     addi atmp3,allocptr,0 /* atmp3 = data object */
453 :     slwi atmp2,atmp2,2 /* atmp2 = length in bytes */
454 :     add allocptr,atmp2,allocptr /* allocptr += total length */
455 :     stw 0,-4(allocptr) /* store zero in last word */
456 :    
457 :     /* Allocate the header object */
458 :     li atmp1, DESC_string /* header descriptor */
459 :     stw atmp1, 0(allocptr)
460 :     addi allocptr,allocptr,4 /* allocptr++ */
461 :     stw atmp3,0(allocptr) /* header data field */
462 :     stw stdarg,4(allocptr) /* header length field */
463 :     addi stdarg,allocptr,0 /* stdarg = header object */
464 :     addi allocptr,allocptr,8 /* allocptr += 2 */
465 :     CONTINUE
466 :    
467 :     create_s_a_large: /* off-line allocation */
468 :     li atmp4,REQ_ALLOC_STRING
469 :     addi pc, stdlink,0
470 :     b set_request
471 :    
472 :    
473 :    
474 :     ML_CODE_HDR(create_r_a)
475 :     CHECKLIMIT(create_r_a_limit)
476 :    
477 :     srawi atmp2,stdarg,1 /* atmp2 = length (untagged int) */
478 :     slwi atmp2,atmp2,1 /* length in words */
479 :     cmpi CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */
480 :     bf CR0_LT,create_r_a_large
481 :    
482 :     /* allocate the data object */
483 :     slwi atmp1, atmp2, TAG_SHIFTW /* descriptor in atmp1 */
484 :     ori atmp1, atmp1, MAKE_TAG(DTAG_raw64)
485 :     #ifdef ALIGN_REALDS
486 :     ori allocptr,allocptr,4
487 :     #endif
488 :     stw atmp1,0(allocptr) /* store the descriptor */
489 :     addi allocptr, allocptr, 4 /* allocptr++ */
490 :     addi atmp3, allocptr, 0 /* atmp3 = data object */
491 :     slwi atmp2, atmp2, 2 /* tmp2 = length in bytes */
492 :     add allocptr,allocptr,atmp2 /* allocptr += length */
493 :    
494 :     /* allocate the header object */
495 :     li atmp1, DESC_real64arr
496 :     stw atmp1, 0(allocptr) /* header descriptor */
497 :     addi allocptr,allocptr,4 /* allocptr++ */
498 :     stw atmp3,0(allocptr) /* header data field */
499 :     stw stdarg,4(allocptr) /* header length field */
500 :     addi stdarg,allocptr,0 /* stdarg = header object */
501 :     addi allocptr,allocptr,8 /* allocptr += 2 */
502 :     CONTINUE
503 :     create_r_a_large: /* offline allocation */
504 :     li atmp4,REQ_ALLOC_REALDARRAY
505 :     addi pc, stdlink,0
506 :     b set_request
507 :    
508 :    
509 :     /* create_v_a : (int * 'a list) -> 'a vector
510 :     * Create a vector with elements taken from a list.
511 :     * NOTE: the front-end ensures that list cannot be nil.
512 :     */
513 :     ML_CODE_HDR(create_v_a)
514 :     CHECKLIMIT(create_v_a_limit)
515 :    
516 :     lwz atmp1,0(stdarg) /* atmp1 = tagged length */
517 :     srawi atmp2,atmp1,1 /* atmp2 = untagged length */
518 :     cmpi CR0,atmp2,SMALL_OBJ_SZW /* is this a small object */
519 :     bf CR0_LT,create_v_a_large
520 :    
521 :     slwi atmp2,atmp2,TAG_SHIFTW /* build descriptor in atmp2 */
522 :     ori atmp2,atmp2,MAKE_TAG(DTAG_vec_data)
523 :     stw atmp2,0(allocptr) /* store descriptor */
524 :     addi allocptr,allocptr,4 /* allocptr++ */
525 :     lwz atmp2,4(stdarg) /* atmp2 := list */
526 :     addi stdarg,allocptr,0 /* stdarg := vector */
527 :    
528 :     create_v_a_1:
529 :     lwz atmp3,0(atmp2) /* atmp3:=hd(atmp2) */
530 :     lwz atmp2,4(atmp2) /* atmp2:=tl(atmp2) */
531 :     stw atmp3,0(allocptr) /* store word */
532 :     addi allocptr,allocptr,4 /* allocptr++ */
533 :     cmpi CR0,atmp2,ML_nil
534 :     bf CR0_EQ,create_v_a_1
535 :    
536 :     /* allocate header object */
537 :     li atmp3, DESC_polyvec /* descriptor in tmp3 */
538 :     stw atmp3,0(allocptr) /* store descriptor */
539 :     addi allocptr,allocptr,4 /* allocptr++ */
540 :     stw stdarg,0(allocptr) /* header data field */
541 :     stw atmp1,4(allocptr) /* header length */
542 :     addi stdarg, allocptr, 0 /* result = header object */
543 :     addi allocptr,allocptr,8 /* allocptr += 2 */
544 :     CONTINUE
545 :    
546 :     create_v_a_large:
547 :     li atmp4,REQ_ALLOC_VECTOR
548 :     addi pc, stdlink,0
549 :     b set_request
550 :    
551 :    
552 :     #if defined(USE_TOC)
553 :     .toc
554 :     T.floor_CONST:
555 :     .tc H.floor_CONST[TC],floor_CONST
556 :     #endif
557 :     RO_DATA
558 :     ALIGN8
559 :     floor_CONST:
560 :     DOUBLE(4512395720392704.0)
561 :    
562 :     TEXT
563 :     /*
564 :     ** floor_a : real -> int
565 :     ** Do not test for overflow, it's the caller's
566 :     ** responsibility to be in range.
567 :     **
568 :     ** This code essentially loads 1.0*2^52 into
569 :     ** register f3. A floating add will internally
570 :     ** perform an exponent alignment, which will
571 :     ** bring the required bits into the mantissa.
572 :     */
573 :     ML_CODE_HDR(floor_a)
574 :     lfd 1, 0(stdarg)
575 :     /*
576 :     ** Neat thing here is that this code works for
577 :     ** both +ve and -ve floating point numbers.
578 :     */
579 :     mffs 0
580 :     stfd 0,0(allocptr) /* steal the allocptr for a second */
581 :     lwz 0, 4(allocptr)
582 :     mtfsb1 30
583 :     mtfsb1 31
584 :     #ifdef USE_TOC
585 :     lwz atmp1, T.floor_CONST(2)
586 :     lfd 3, 0(atmp1)
587 :     #else
588 :     lis atmp1, floor_CONST@ha
589 :     lfd 3, floor_CONST@l(atmp1)
590 :     #endif
591 :     fadd 6,1,3
592 :     stfd 6,FLOOR_OFFSET(sp)
593 :     lwz stdarg,FLOOR_OFFSET+4(sp)
594 :     add stdarg,stdarg,stdarg
595 :     addi stdarg,stdarg,1
596 :    
597 :     andi. 0,0, 0xf
598 :     mtfsf 0xff,0
599 :     CONTINUE
600 :    
601 :    
602 :     ML_CODE_HDR(logb_a)
603 :     lwz stdarg,0(stdarg) /* most significant part */
604 :     srawi stdarg,stdarg,20 /* throw out 20 low bits */
605 :     andi. stdarg,stdarg,0x07ff /* clear all but 11 low bits */
606 :     addi stdarg,stdarg,-1023 /* subtract 1023 */
607 :     slwi stdarg,stdarg,1 /* make room for tag bit */
608 :     addi stdarg,stdarg,1 /* add the tag bit */
609 :     CONTINUE
610 :    
611 :    
612 :     /*
613 :     ** scalb : real * int -> real
614 :     ** scalb(x,y) = x * 2^y
615 :     */
616 :     ML_CODE_HDR(scalb_a)
617 :     CHECKLIMIT(scalb_v_limit)
618 :     lwz atmp1,4(stdarg) /* atmp1 := y */
619 :     srawi atmp1,atmp1,1 /* atmp1 := machine int y */
620 :     lwz stdarg,0(stdarg) /* stdarg := x */
621 :     lwz atmp2,0(stdarg) /* atmp2 := MSW(x) */
622 :     lis 0,0x7ff0 /* r0 := 0x7ff0,0000 */
623 :     and. atmp3,atmp2,0 /* atmp3 := atmp2 & 0x7ff00000 */
624 :     bt CR0_EQ,scalb_all_done
625 :    
626 :     srawi atmp3,atmp3,20 /* atmp3 := ieee(exp) */
627 :     add. atmp1,atmp1,atmp3 /* scale exponent */
628 :     bt CR0_LT,scalb_underflow
629 :    
630 :     cmpi CR0,atmp1,2047 /* max. ieee(exp) */
631 :     bf CR0_LT,scalb_overflow
632 :    
633 :     not 0,0 /* r0 := not(r0) */
634 :     and atmp2,atmp2,0 /* atmp2 := high mantessa bits + sign */
635 :     slwi atmp1,atmp1,20 /* atmp1 := new exponent */
636 :     or atmp1,atmp1,atmp2 /* atmp1 := new MSB(x) */
637 :     lwz atmp2, 4(stdarg)
638 :    
639 :     scalb_write_out:
640 :     stw atmp1, 4(allocptr)
641 :     stw atmp2, 8(allocptr)
642 :     li atmp3, DESC_reald
643 :     stw atmp3, 0(allocptr)
644 :     addi stdarg,allocptr,4
645 :     addi allocptr,allocptr,12
646 :    
647 :     scalb_all_done:
648 :     CONTINUE
649 :    
650 :     scalb_underflow:
651 :     li atmp1,0
652 :     li atmp2,0
653 :     b scalb_write_out
654 :    
655 :     LABEL(scalb_overflow)
656 :     mtfsb1 3
657 :    
658 :    
659 :    
660 :     ML_CODE_HDR(try_lock_a)
661 :     lwz atmp1,0(stdarg)
662 :     li atmp2,1 /* ML_false */
663 :     stw atmp2,0(stdarg)
664 :     addi stdarg,atmp1,0
665 :     CONTINUE
666 :    
667 :    
668 :     ML_CODE_HDR(unlock_a)
669 :     li atmp1,3 /* ML_true */
670 :     stw atmp1,0(stdarg)
671 :     li stdarg,1 /* just return unit */
672 :     CONTINUE
673 :    
674 :    
675 :    
676 :     CENTRY(set_fsr)
677 :     mtfsb0 24 /* disable invalid exception */
678 :     mtfsb0 25 /* disable overflow exception */
679 :     mtfsb0 26 /* disable underflow exception */
680 :     mtfsb0 28 /* disable inexact exception */
681 :     mtfsb0 30 /* round to nearest */
682 :     mtfsb0 31
683 :     blr /* return */
684 :    
685 :     /* saveFPRegs and restoreFPRegs are called from C only. */
686 :     #define ctmp1 12
687 :     #define ctmp2 11
688 :     #define ctmp3 10
689 :    
690 :    
691 :     CENTRY(SaveFPRegs)
692 :     stfd 14, 4(3)
693 :     stfd 15, 12(3)
694 :     stfd 16, 20(3)
695 :     stfd 17, 28(3)
696 :     stfd 18, 36(3)
697 :     stfd 19, 44(3)
698 :     stfd 20, 52(3)
699 :     stfd 21, 60(3)
700 :     stfd 22, 68(3)
701 :     stfd 23, 76(3)
702 :     stfd 24, 84(3)
703 :     stfd 25, 92(3)
704 :     stfd 26, 100(3)
705 :     stfd 27, 108(3)
706 :     stfd 28, 116(3)
707 :     stfd 29, 124(3)
708 :     stfd 30, 132(3)
709 :     stfd 31, 140(3)
710 :    
711 :     blr
712 :    
713 :     CENTRY(RestoreFPRegs)
714 :     lfd 14, 0(3)
715 :     lfd 15, 8(3)
716 :     lfd 16, 16(3)
717 :     lfd 17, 24(3)
718 :     lfd 18, 32(3)
719 :     lfd 19, 40(3)
720 :     lfd 20, 48(3)
721 :     lfd 21, 56(3)
722 :     lfd 22, 64(3)
723 :     lfd 23, 72(3)
724 :     lfd 24, 80(3)
725 :     lfd 25, 88(3)
726 :     lfd 26, 96(3)
727 :     lfd 27, 104(3)
728 :     lfd 28, 112(3)
729 :     lfd 29, 120(3)
730 :     lfd 30, 128(3)
731 :     lfd 31, 136(3)
732 :     blr
733 :    
734 :     #if defined(OPSYS_MKLINUX)
735 :    
736 :     #define CACHE_LINE_SZB 32
737 :     #define CACHE_LINE_MASK (CACHE_LINE_SZB-1)
738 :     #define CACHE_LINE_BITS 26
739 :    
740 :     /* FlushICache:
741 :     *
742 :     * void FlushICache (Addr_t addr, Addr_t nbytes)
743 :     */
744 :     CENTRY(FlushICache)
745 :     add 4,3,4 /* stop := addr+nbytes */
746 :     addic 4,4,CACHE_LINE_MASK /* stop := stop + CACHE_LINE_MASK */
747 :     rlwinm 4,4,0,0,CACHE_LINE_BITS /* stop := stop & ~CACHE_LINE_MASK */
748 :     L_FlushICache_1:
749 :     cmplw 1,3,4 /* while (addr < stop) */
750 :     bc 4,4,L_FlushICache_2
751 :     dcbf 0,3 /* flush addr */
752 :     icbi 0,3 /* invalidate addr */
753 :     addi 3,3,CACHE_LINE_SZB /* addr := addr + CACHE_LINE_SZB */
754 :     b L_FlushICache_1 /* end while */
755 :     L_FlushICache_2:
756 :     blr
757 :    
758 :     #endif
759 :    

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