source: branches/working-0711/ccl/lisp-kernel/ppc-macros.s @ 7624

Last change on this file since 7624 was 7624, checked in by gb, 13 years ago

Merge changes form working-0710 branch.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 18.8 KB
Line 
1/*   Copyright (C) 1994-2001 Digitool, Inc */
2/*   This file is part of OpenMCL.  */
3
4/*   OpenMCL is licensed under the terms of the Lisp Lesser GNU Public */
5/*   License , known as the LLGPL and distributed with OpenMCL as the */
6/*   file "LICENSE".  The LLGPL consists of a preamble and the LGPL, */
7/*   which is distributed with OpenMCL as the file "LGPL".  Where these */
8/*   conflict, the preamble takes precedence.   */
9
10/*   OpenMCL is referenced in the preamble as the "LIBRARY." */
11
12/*   The LLGPL is also available online at */
13/*   http://opensource.franz.com/preamble.html */
14
15/* The assembler has to do the arithmetic here:  the expression */
16/*   may not be evaluable by m4. */
17define([lwi],[ifdef([DARWIN],[
18        .if ((($2) & 0xffff8000) == 0xffff8000)
19         li $1,($2)
20        .elseif ((($2) & 0xffff8000) == 0)
21         li $1,$2
22        .else
23         lis $1,(($2)>>16)
24         .if (($2) & 0xffff) <> 0
25          ori $1,$1,(($2) & 0xffff)
26         .endif
27        .endif],[
28        .ifeq (($2) & 0xffff8000)-0xffff8000
29         li $1,$2
30        .else
31         .ifeq (($2) & 0xffff8000)
32          li $1,$2
33         .else
34          lis $1,($2>>16)
35          .ifne ($2 & 0xffff)
36           ori $1,$1,$2 & 0xffff
37          .endif
38         .endif
39        .endif
40])])
41
42ifdef([PPC64],[
43        define([clrrri],[
44        clrrdi $@
45        ])       
46        define([clrlri],[
47        clrldi $@
48        ])
49        define([clrlri_],[
50        clrldi. $@
51        ])
52        define([ldr],[
53        ld $@
54        ])
55        define([ldrx],[
56        ldx $@
57        ])
58        define([ldru],[
59        ldu $@
60        ])
61        define([str],[
62        std $@
63        ])
64        define([strx],[
65        stdx $@
66        ])
67        define([stru],[
68        stdu $@
69        ])
70        define([strux],[
71        stdux $@
72        ])     
73        define([cmpr],[
74        cmpd $@
75        ])
76        define([cmpri],[
77        cmpdi $@
78        ])
79        define([cmplr],[
80        cmpld $@
81        ])
82        define([cmplri],[
83        cmpldi $@
84        ])
85        define([trlge],[
86        tdlge $@
87        ])
88        define([trllt],[
89        tdllt $@
90        ])
91        define([trlt],[
92        tdlt $@
93        ])
94        define([trlle],[
95        tdlle $@
96        ])
97        define([treqi],[
98        tdeqi $@
99        ])
100        define([trnei],[
101        tdnei $@
102        ])
103        define([trgti],[
104        tdgti $@
105        ])
106        define([srari],[
107        sradi $@
108        ])
109        define([srri],[
110        srdi $@
111        ])
112        define([srr],[
113        srd $@
114        ])
115        define([slri],[
116        sldi $@
117        ])
118        define([lrarx],[
119        ldarx $@
120        ])
121        define([strcx],[
122        stdcx. $@
123        ])
124        define([load_highbit],[
125        lis $1,0x8000
126        sldi $1,$1,32
127        ])
128        define([extract_bit_shift_count],[
129        clrldi $1,$2,64-bitmap_shift
130        ])
131        define([alloc_trap],[
132        tdlt allocptr,allocbase
133        ])
134        define([mullr],[
135        mulld $@
136        ])
137],[
138        define([clrrri],[
139        clrrwi $@
140        ])
141        define([clrlri],[
142        clrlwi $@
143        ])
144        define([clrlri_],[
145        clrlwi. $@
146        ])
147        define([ldr],[
148        lwz $@
149        ])
150        define([ldrx],[
151        lwzx $@
152        ])
153        define([ldru],[
154        lwzu $@
155        ])
156        define([str],[
157        stw $@
158        ])
159        define([strx],[
160        stwx $@
161        ])
162        define([stru],[
163        stwu $@
164        ])
165        define([strux],[
166        stwux $@
167        ])
168        define([cmpr],[
169        cmpw $@
170        ])
171        define([cmpri],[
172        cmpwi $@
173        ])
174        define([cmplr],[
175        cmplw $@
176        ])
177        define([cmplri],[
178        cmplwi $@
179        ])
180        define([trlge],[
181        twlge $@
182        ])
183        define([trllt],[
184        twllt $@
185        ])
186        define([trlt],[
187        twlt $@
188        ])
189        define([trlle],[
190        twlle $@
191        ])       
192        define([treqi],[
193        tweqi $@
194        ])
195        define([trnei],[
196        twnei $@
197        ])
198        define([trgti],[
199        twgti $@
200        ])
201        define([srari],[
202        srawi $@
203        ])
204        define([srri],[
205        srwi $@
206        ])
207        define([srr],[
208        srw $@
209        ])
210        define([slri],[
211        slwi $@
212        ])
213        define([lrarx],[
214        lwarx $@
215        ])
216        define([strcx],[
217        stwcx. $@
218        ])
219        define([load_highbit],[
220        lis $1,0x8000
221        ])
222        define([extract_bit_shift_count],[
223        clrlwi $1,$2,32-bitmap_shift
224        ])
225        define([alloc_trap],[
226        twllt allocptr,allocbase
227        ])
228        define([mullr],[
229        mullw $@
230        ])
231])
232
233/* dnode_align(dest,src,delta) */
234        define([dnode_align],[
235        la $1,($3+(dnode_size-1))($2)
236        clrrri($1,$1,dnode_align_bits)
237])
238
239define([extract_fulltag],[
240        clrlri($1,$2,nbits_in_word-ntagbits)
241        ])
242
243define([extract_lisptag],[
244        clrlri($1,$2,nbits_in_word-nlisptagbits)
245        ])
246
247define([extract_lisptag_],[
248        clrlri_($1,$2,nbits_in_word-nlisptagbits)
249        ])
250
251define([extract_subtag],[
252        lbz $1,misc_subtag_offset($2)])
253
254ifdef([PPC64],[
255define([extract_lowtag],[
256        clrldi $1,$2,nbits_in_word-nlowtagbits
257])
258define([trap_unless_lowtag_equal],[
259        clrldi $3,$1,nbits_in_word-nlowtagbits
260        tdnei $3,$2
261])               
262        ])
263                               
264define([extract_lowbyte],[
265        clrlri($1,$2,nbits_in_word-num_subtag_bits)
266        ])
267
268define([extract_header],[
269        ldr($1,misc_header_offset($2))])
270
271
272ifdef([PPC64],[
273define([extract_typecode],[
274        new_macro_labels()
275        extract_fulltag($1,$2)
276        cmpdi cr0,$1,fulltag_misc
277        extract_lisptag($1,$1)
278        bne cr0,macro_label(not_misc)
279        extract_subtag($1,$2)
280macro_label(not_misc):
281])],[   
282define([extract_typecode],[
283        new_macro_labels()
284        extract_lisptag($1,$2)
285        cmpwi cr0,$1,tag_misc
286        bne cr0,macro_label(not_misc)
287        extract_subtag($1,$2)
288macro_label(not_misc):
289])])
290
291define([box_fixnum],[
292        slri($1,$2,fixnumshift)])
293
294define([unbox_fixnum],[ 
295        srari($1,$2,fixnumshift)])
296
297define([loaddf],[
298        lfd $1,dfloat.value($2)])
299       
300define([storedf],[
301        stfd $1,dfloat.value($2)])
302
303define([push],[
304        stru($1,-node_size($2))])
305       
306        /* Generally not a great idea. */
307define([pop],[
308        ldr($1,0($2))
309        la $2,node_size($2)])
310       
311define([vpush],[
312        push($1,vsp)])
313       
314define([vpop],[
315        pop($1,vsp)])
316       
317               
318define([unlink],[
319        ldr($1,0($1))
320 ])
321
322       
323define([set_nargs],[
324        lwi(nargs,($1)<<fixnumshift)])
325       
326define([bitclr],[
327        rlwinm $1,$2,0,0x1f&((31-($3))+1),0x1f&((31-($3))-1)])
328       
329
330define([vref32],[
331        lwz $1,misc_data_offset+(($3)<<2)($2)])
332       
333define([vref16],[/* dest,src,n*/
334        lhz $1,misc_data_offset+(($3)<<1)($2)])
335       
336ifdef([PPC64],[
337        define([vref64],[
338        ld $1,misc_data_offset+(($3)<<3)($2)])
339
340        define([vrefr],[
341        vref64($1,$2,$3)])
342],[
343        define([vrefr],[
344        vref32($1,$2,$3)])
345])
346       
347                       
348define([getvheader],[
349        ldr($1,vector.header($2))])
350       
351        /* Size is unboxed element count */
352define([header_size],[
353        srri($1,$2,num_subtag_bits)])
354       
355        /* "Length" is fixnum element count */
356define([header_length],[
357ifdef([PPC64],[
358        rldicr $1,$2,nbits_in_word-(num_subtag_bits-nfixnumtagbits),63-nfixnumtagbits
359        clrldi $1,$1,(num_subtag_bits-nfixnumtagbits)
360        ],[               
361        rlwinm $1,$2,nbits_in_word-(num_subtag_bits-nfixnumtagbits),(num_subtag_bits-nfixnumtagbits),31-nfixnumtagbits
362        ])
363])       
364
365
366define([vector_size],[
367        getvheader(ifelse($3.[],$1,$3),$2)
368        header_size($1,ifelse($3.[],$1,$3))])
369       
370define([vector_length],[
371        getvheader($3,$2)
372        header_length($1,$3)])
373
374       
375define([ref_global],[
376        ldr($1,lisp_globals.$2(0))
377])
378
379define([set_global],[
380        str($1,lisp_globals.$2(0))
381])
382
383define([ref_nrs_value],[
384        ldr($1,((nrs.$2)+(symbol.vcell))(0))
385])
386       
387define([set_nrs_value],[
388        str($1,((nrs.$2)+(symbol.vcell))(0))
389])
390
391define([extract_unsigned_byte_bits],[
392ifdef([PPC64],[
393        rldicr $1,$2,64-fixnumshift,63-$3
394],[               
395        rlwinm $1,$2,0,32-fixnumshift,31-($3+fixnumshift)
396])       
397])
398
399define([extract_unsigned_byte_bits_],[
400ifdef([PPC64],[
401        rldicr. $1,$2,64-fixnumshift,63-$3
402],[               
403        rlwinm. $1,$2,0,32-fixnumshift,31-($3+fixnumshift)
404])       
405])
406
407        /* vpop argregs - nargs is known to be non-zero */
408define([vpop_argregs_nz],[
409        new_macro_labels()
410        cmplri(cr1,nargs,node_size*2)
411        vpop(arg_z)
412        blt cr1,macro_label(l0)
413        vpop(arg_y)
414        bne cr1,macro_label(l0)
415        vpop(arg_x)
416macro_label(l0):])
417
418               
419        /* vpush argregs */
420define([vpush_argregs],[
421        new_macro_labels()
422        cmplri(cr0,nargs,0)
423        cmplri(cr1,nargs,node_size*2)
424        beq cr0,macro_label(done)
425        blt cr1,macro_label(z)
426        beq cr1,macro_label(yz)
427        vpush(arg_x)
428macro_label(yz):
429        vpush(arg_y)
430macro_label(z):
431        vpush(arg_z)
432macro_label(done):
433])
434
435define([create_lisp_frame],[
436        stru(sp,-lisp_frame.size(sp))
437])
438
439               
440define([build_lisp_frame],[
441        create_lisp_frame()
442        str(ifelse($1,[],fn,$1),lisp_frame.savefn(sp))
443        str(ifelse($2,[],loc_pc,$2),lisp_frame.savelr(sp))
444        str(ifelse($3,[],vsp,$3),lisp_frame.savevsp(sp))
445])
446
447               
448define([discard_lisp_frame],[
449        la sp,lisp_frame.size(sp)])
450       
451       
452define([_car],[
453        ldr($1,cons.car($2))
454])
455       
456define([_cdr],[
457        ldr($1,cons.cdr($2))])
458       
459define([_rplaca],[
460        str($2,cons.car($1))])
461       
462define([_rplacd],[
463        str($2,cons.cdr($1))])
464
465define([vpush_saveregs],[
466        vpush(save7)
467        vpush(save6)
468        vpush(save5)
469        vpush(save4)
470        vpush(save3)
471        vpush(save2)
472        vpush(save1)
473        vpush(save0)])
474       
475define([restore_saveregs],[
476        ldr(save0,node_size*0($1))
477        ldr(save1,node_size*1($1))
478        ldr(save2,node_size*2($1))
479        ldr(save3,node_size*3($1))
480        ldr(save4,node_size*4($1))
481        ldr(save5,node_size*5($1))
482        ldr(save6,node_size*6($1))
483        ldr(save7,node_size*7($1))
484])
485
486define([vpop_saveregs],[
487        restore_saveregs(vsp)
488        la vsp,node_size*8(vsp)
489])
490
491define([trap_unless_lisptag_equal],[
492        extract_lisptag($3,$1)
493        trnei($3,$2)
494])
495
496ifdef([PPC64],[
497define([trap_unless_list],[
498        new_macro_labels()
499        cmpdi ifelse($3,$3,cr0),$1,nil_value
500        extract_fulltag($2,$1)
501        beq ifelse($3,$3,cr0),macro_label(is_list)
502        tdnei $2,fulltag_cons
503macro_label(is_list):   
504
505])],[   
506define([trap_unless_list],[
507        trap_unless_lisptag_equal($1,tag_list,$2)
508])
509])
510
511define([trap_unless_fulltag_equal],[
512        extract_fulltag($3,$1)
513        trnei($3,$2)
514])
515       
516define([trap_unless_typecode_equal],[
517        extract_typecode($3,$1)
518        trnei($3,$2)
519])
520       
521/* "jump" to the code-vector of the function in nfn. */
522define([jump_nfn],[
523        ldr(temp0,_function.codevector(nfn))
524        mtctr temp0
525        bctr
526])
527
528/* "call the code-vector of the function in nfn. */
529define([call_nfn],[
530        ldr(temp0,_function.codevector(nfn))
531        mtctr temp0
532        bctrl
533])
534       
535
536/* "jump" to the function in fnames function cell. */
537define([jump_fname],[
538        ldr(nfn,symbol.fcell(fname))
539        jump_nfn()
540])
541
542/* call the function in fnames function cell. */
543define([call_fname],[
544        ldr(nfn,symbol.fcell(fname))
545        call_nfn()
546])
547
548define([do_funcall],[
549        new_macro_labels()
550        extract_fulltag(imm0,temp0)
551        cmpri(imm0,fulltag_misc)
552        mr nfn,temp0
553        bne- macro_label(bad)
554        extract_subtag(imm0,temp0)
555        cmpri(imm0,subtag_function)
556        cmpri(cr1,imm0,subtag_symbol)
557        bne cr0,macro_label(_sym)
558        jump_nfn()
559macro_label(_sym):             
560        mr fname,temp0
561        bne cr1,macro_label(bad)
562        jump_fname()
563macro_label(bad):
564        uuo_interr(error_cant_call,temp0)
565])     
566
567define([mkcatch],[
568        mflr loc_pc
569        ldr(imm0,tcr.catch_top(rcontext))
570        lwz imm1,0(loc_pc) /* a forward branch to the catch/unwind cleanup */
571        rlwinm imm1,imm1,0,6,29 /* extract LI */
572        add loc_pc,loc_pc,imm1
573        build_lisp_frame(fn,loc_pc,vsp)
574        sub loc_pc,loc_pc,imm1
575        la loc_pc,4(loc_pc)     /* skip over the forward branch */
576        mtlr loc_pc
577        lwi(imm4,(catch_frame.element_count<<num_subtag_bits)|subtag_catch_frame)
578        ldr(imm3,tcr.xframe(rcontext))
579        ldr(imm1,tcr.db_link(rcontext))
580        TSP_Alloc_Fixed_Unboxed(catch_frame.size)
581        la nargs,tsp_frame.data_offset+fulltag_misc(tsp)
582        str(imm4,catch_frame.header(nargs))
583        str(arg_z,catch_frame.catch_tag(nargs))
584        str(imm0,catch_frame.link(nargs))
585        str(imm2,catch_frame.mvflag(nargs))
586        str(sp,catch_frame.csp(nargs))
587        str(imm1,catch_frame.db_link(nargs))
588        str(first_nvr,catch_frame.regs+0*node_size(nargs))
589        str(second_nvr,catch_frame.regs+1*node_size(nargs))
590        str(third_nvr,catch_frame.regs+2*node_size(nargs))
591        str(fourth_nvr,catch_frame.regs+3*node_size(nargs))
592        str(fifth_nvr,catch_frame.regs+4*node_size(nargs))
593        str(sixth_nvr,catch_frame.regs+5*node_size(nargs))
594        str(seventh_nvr,catch_frame.regs+6*node_size(nargs))
595        str(eighth_nvr,catch_frame.regs+7*node_size(nargs))
596        str(imm3,catch_frame.xframe(nargs))
597        str(rzero,catch_frame.tsp_segment(nargs))
598        Set_TSP_Frame_Boxed()
599        str(nargs,tcr.catch_top(rcontext))
600        li nargs,0
601
602])     
603
604define([restore_catch_nvrs],[
605        ldr(first_nvr,catch_frame.regs+(node_size*0)($1))
606        ldr(second_nvr,catch_frame.regs+(node_size*1)($1))
607        ldr(third_nvr,catch_frame.regs+(node_size*2)($1))
608        ldr(fourth_nvr,catch_frame.regs+(node_size*3)($1))
609        ldr(fifth_nvr,catch_frame.regs+(node_size*4)($1))
610        ldr(sixth_nvr,catch_frame.regs+(node_size*5)($1))
611        ldr(seventh_nvr,catch_frame.regs+(node_size*6)($1))
612        ldr(eighth_nvr,catch_frame.regs+(node_size*7)($1))
613])               
614
615define([DCBZL],[
616        .long (31<<26)+(1<<21)+($1<<16)+($2<<11)+(1014<<1)
617])
618       
619define([check_stack_alignment],[
620        new_macro_labels()
621        andi. $1,sp,STACK_ALIGN_MASK
622        beq+ macro_label(stack_ok)
623        .long 0
624macro_label(stack_ok):
625])
626
627define([stack_align],[((($1)+STACK_ALIGN_MASK)&~STACK_ALIGN_MASK)])
628
629define([clear_alloc_tag],[
630        clrrri(allocptr,allocptr,ntagbits)
631])
632
633/* If the GC interrupts the current thread (after the trap), it needs */
634/*   to ensure that the cons cell that's been "reserved" stays reserved */
635/*   (e.g. the tagged allocptr has to be treated as a node.)  If that */
636/*   reserved cons cell gets tenured, the car and cdr are of a generation */
637/*   that's at least as old (so memoization isn't an issue.) */
638
639/*   More generally, if the GC interrupts a thread when allocptr is */
640/*   tagged as a cons: */
641
642/*    a) if the trap hasn't been taken (yet), the GC should force the */
643/*       thread to resume in such a way that the trap will be taken ; */
644/*       the segment allocator should worry about allocating the object. */
645
646/*    b) If the trap has been taken, allocptr is treated as a node as */
647/*       described above.  Allocbase is made to point to the base of the */
648/*       cons cell, so that the thread's next allocation attempt will */
649/*       invoke the segment allocator. */
650       
651define([Cons],[
652        la allocptr,(-cons.size+fulltag_cons)(allocptr)
653        alloc_trap()
654        str($3,cons.cdr(allocptr))
655        str($2,cons.car(allocptr))
656        mr $1,allocptr
657        clear_alloc_tag()
658])
659
660
661/* This is probably only used once or twice in the entire kernel, but */
662/* I wanted a place to describe the constraints on the mechanism. */
663
664/* Those constaints are (not surprisingly) similar to those which apply */
665/* to cons cells, except for the fact that the header (and any length */
666/* field that might describe large arrays) has to have been stored in */
667/* the object if the trap has succeeded on entry to the GC.  It follows */
668/* that storing the register containing the header must immediately */
669/* follow the allocation trap (and an auxiliary length register must */
670/* be stored immediately after the header.)  Successfully falling */
671/* through the trap must emulate any header initialization: it would */
672/* be a bad idea to have allocptr pointing to a zero header ... */
673
674
675
676/* Parameters: */
677
678/* $1 = dest reg */
679/* $2 = header.  (For now, assume that this always encodes length ; */
680/* that may change with "large vector" support.) */
681/* $3 = register containing size in bytes.  (We're going to subtract */
682/* fulltag_misc from this; do it in the macro body, rather than force the
683/* (1 ?) caller to do it. */
684
685
686define([Misc_Alloc],[
687        la $3,-fulltag_misc($3)
688        sub allocptr,allocptr,$3
689        alloc_trap()
690        str($2,misc_header_offset(allocptr))
691        mr $1,allocptr
692        clear_alloc_tag()
693])
694
695/*  Parameters $1, $2 as above; $3 = physical size constant. */
696define([Misc_Alloc_Fixed],[
697        la allocptr,(-$3)+fulltag_misc(allocptr)
698        alloc_trap()
699        str($2,misc_header_offset(allocptr))
700        mr $1,allocptr
701        clear_alloc_tag()
702])
703
704
705/*  Zero $3 bytes worth of doublewords, starting at offset $2 relative */
706/* to the base register $1. */
707
708
709ifdef([DARWIN],[
710        .macro zero_doublewords
711        .if $2
712        stfd fp_zero,$1($0)
713        zero_doublewords $0,$1+8,$2-8
714        .endif
715        .endmacro
716])
717
718ifdef([LINUX],[
719        .macro zero_doublewords base,disp,nbytes
720        .if \nbytes
721        stfd fp_zero,\disp(\base)
722        zero_doublewords \base,\disp+8,\nbytes-8
723        .endif
724        .endm
725])     
726
727define([Set_TSP_Frame_Unboxed],[
728        str(tsp,tsp_frame.type(tsp))
729])
730
731define([Set_TSP_Frame_Boxed],[
732        str(rzero,tsp_frame.type(tsp))
733])
734               
735/* A newly allocated TSP frame is always "raw" (has non-zero type, indicating */
736/* that it doesn't contain tagged data. */
737
738define([TSP_Alloc_Fixed_Unboxed],[
739        stru(tsp,-($1+tsp_frame.data_offset)(tsp))
740        Set_TSP_Frame_Unboxed()
741])
742
743define([TSP_Alloc_Fixed_Unboxed_Zeroed],[
744        TSP_Alloc_Fixed_Unboxed($1)
745        zero_doublewords tsp,tsp_frame.fixed_overhead,$1
746])
747
748define([TSP_Alloc_Fixed_Boxed],[
749        TSP_Alloc_Fixed_Unboxed_Zeroed($1)
750        Set_TSP_Frame_Boxed()
751])
752
753
754       
755       
756
757/* This assumes that the backpointer points  to the first byte beyond */
758/* each frame.  If we allow segmented tstacks, that constraint might */
759/* complicate  their implementation. */
760/* We don't need to know the size of the frame (positive or negative, */
761/* with or without header).  $1 and $2 are temp registers, $3 is an */
762/* optional CR field. */
763
764
765/* Handle the general case, where the frame might be empty */
766define([Zero_TSP_Frame],[
767        new_macro_labels()
768        la $1,tsp_frame.size-8(tsp)
769        ldr($2,tsp_frame.backlink(tsp))
770        la $2,-8($2)
771        b macro_label(zero_tsp_test)
772macro_label(zero_tsp_loop):
773        stfdu fp_zero,8($1)
774macro_label(zero_tsp_test):     
775        cmpr(ifelse($3,[],[cr0],$3),$1,$2)
776        bne ifelse($3,[],[cr0],$3),macro_label(zero_tsp_loop)
777])
778
779/* Save some branching when we know that the frame can't be empty.*/
780define([Zero_TSP_Frame_nz],[
781        new_macro_labels()
782        la $1,tsp_frame.size-8(tsp)
783        ldr($2,tsp_frame.backlink(tsp))
784        la $2,-8($2)
785macro_label(zero_tsp_loop):
786        stfdu fp_zero,8($1)
787        cmpr(ifelse($3,[],[cr0],$3),$1,$2)
788        bne ifelse($3,[],[cr0],$3),macro_label(zero_tsp_loop)
789])
790       
791/* $1 = 8-byte-aligned size, positive.  $2 (optiional) set */
792/* to negated size. */
793define([TSP_Alloc_Var_Unboxed],[
794        neg ifelse($2,[],$1,$2),$1
795        strux(tsp,tsp,ifelse($2,[],$1,$2))
796        Set_TSP_Frame_Unboxed()
797])
798
799define([TSP_Alloc_Var_Boxed],[
800        TSP_Alloc_Var_Unboxed($1)
801        Zero_TSP_Frame($1,$2)
802        Set_TSP_Frame_Boxed()
803])             
804
805
806define([TSP_Alloc_Var_Boxed_nz],[
807        TSP_Alloc_Var_Unboxed($1)
808        Zero_TSP_Frame_nz($1,$2)
809        Set_TSP_Frame_Boxed()
810])             
811
812define([check_pending_interrupt],[
813        new_macro_labels()
814        ldr(nargs,tcr.tlb_pointer(rcontext))
815        ldr(nargs,INTERRUPT_LEVEL_BINDING_INDEX(nargs))
816        cmpri(ifelse($1,[],[cr0],$1),nargs,0)
817        blt ifelse($1,[],[cr0],$1),macro_label(done)
818        bgt ifelse($1,[],[cr0],$1),macro_label(trap)
819        ldr(nargs,tcr.interrupt_pending(rcontext))
820macro_label(trap):
821        trgti(nargs,0)
822macro_label(done):
823])
824
825/* $1 = ndigits.  Assumes 4-byte digits */       
826define([aligned_bignum_size],[((~(dnode_size-1)&(node_size+(dnode_size-1)+(4*$1))))])
827
828define([suspend_now],[
829        uuo_interr(error_propagate_suspend,rzero)
830])
Note: See TracBrowser for help on using the repository browser.