Remove DUX/OSF code
[openafs.git] / src / lwp / process.default.s
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #define IGNORE_STDS_H   1
11 #include <afs/param.h>
12
13 #if defined(__arm32__) || defined(__arm__)
14 #ifndef AFS_ARM_DARWIN_ENV
15         /* register definitions */
16        fp      .req    r11
17        ip      .req    r12
18        sp      .req    r13
19        lp      .req    r14
20        pc      .req    r15
21 #endif
22
23        /*
24           savecontext(f, area1, newsp)
25                int (*f)()#if defined(RIOS);
26                struct savearea *area1;
27                char *newsp;
28        */
29
30        /* Arguments appear as:     f in r0, area1 in r1, newsp in r2 */
31
32        .text
33        .align  0
34 #ifndef AFS_ARM_DARWIN_ENV
35        .globl  savecontext
36        .type   savecontext, #function
37 savecontext:
38 #else
39        .globl  _savecontext
40 _savecontext:
41 #endif
42         @ build the frame
43         mov     ip, sp
44         stmfd   sp!, {fp, ip, lr, pc}
45         sub     fp, ip, #4
46         @ stack r0 - r10, current fp
47         stmfd   sp!, {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, fp}
48         str     sp, [r1, #0]
49         @ check if newsp is zero
50         movs    r2, r2
51         movne   sp, r2
52         @ call function ...
53 #ifdef AFS_ARM_DARWIN_ENV
54         bx      r0
55 #else
56         mov     pc, r0
57 #endif
58
59        /*
60          returnto(area2)
61             struct savearea *area2;
62        */
63
64        /* area2 is in r0. */
65
66 #ifndef AFS_ARM_DARWIN_ENV
67        .globl returnto
68        .type  returnto, #function
69 returnto:
70 #else
71        .globl _returnto
72 _returnto:
73 #endif
74        @ restore r0-r10, fp
75        ldr     r0, [r0, #0]
76        ldmfd   r0, {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, fp}
77        @ return from function call
78        ldmea   fp, {fp, sp, pc}
79
80 #endif /* __arm32__ or __arm__ */
81
82 #if defined(RIOS)
83 /*                 I don't know if we have to save the TOC (R2) or not...
84  *                 Note that stack-frame is supposed to be aligned on 
85  *                 a double-word boundary.
86  *                 For details about RIOS calling conventions
87  *                 see the Assembler manual and /usr/include/sys/asdef.s
88  */
89
90
91 /*
92  * savecontext(f, area1, newsp)
93  *     int (*f)(); struct savearea *area1; char *newsp;
94  */
95         .set    topstack, 0
96         .set    cr0, 0
97         .set    toc, 2
98         .set    r0, 0
99         .set    r1, 1
100         .set    r2, 2
101         .set    r3, 3
102         .set    r4, 4
103         .set    r5, 5
104         .set    r6, 6
105         .set    r7, 7
106         .set    r12, 12
107         .set    a_f, r3
108         .set    a_area1, r4
109         .set    a_newsp, r5
110
111         .set    argarea,  32
112         .set    linkarea, 24
113         .set    nfprs,    18
114         .set    ngprs,    20
115         .set    szdsa,    8*nfprs+4*ngprs+linkarea+argarea
116
117         .csect .savecontext[PR]
118         .globl .savecontext[PR]
119
120         mflr    r0                      # save link register
121                 
122 /*
123  *  save floating point registers.  Interleave some other stuff for
124  *  timing reasons.  Set up conditions and registers for branches
125  *  early, so that processor can prefetch instructions.
126  */
127         stfd  14, -144(1)
128         stfd  15, -136(1)
129
130         mfcr    r12                     # save CR
131
132         stfd  16, -128(1)
133         stfd  17, -120(1)
134
135         l       11, 0(a_f)              # r11 <- *(a_f)
136
137         stfd  18, -112(1)
138         stfd  19, -104(1)
139
140         cmpi    cr0, a_newsp, 0         # cr0 <- (a_newsp :: 0)
141
142         stfd  20, -96(1)
143         stfd  21, -88(1)
144         stfd  22, -80(1)
145
146         mtlr    11                      # set up lr early so prefetch works
147
148         stfd  23, -72(1)
149         stfd  24, -64(1)
150         stfd  25, -56(1)
151
152         st      r0, 8(r1)               # save return addr
153
154         stfd  26, -48(1)
155         stfd  27, -40(1)
156         stfd  28, -32(1)
157
158         st      12, 4(r1)               # save CR
159
160         stfd  29, -24(1)
161         stfd  30, -16(1)
162         stfd  31, -8(1)
163
164 /*
165  *  save general-purpose registers
166  */
167         stm     12, -8*nfprs-4*ngprs(r1)# save the general-purpose regs
168         stu     r1, -szdsa(r1)          # dec SP and save back chain
169
170         l       r7,  PRE_Block.S(toc)   # r7 <- &PRE_Block
171         cal     r6, 1(r0)               # r6 <- #1
172         stb     r6, 0(r7)               # r6 -> PRE_Block
173
174         st      r1, topstack(a_area1)   # save old SP
175         
176         beq    L1                       # if (a_newsp == 0) goto L1
177
178         mr      r1, r5                  # r1 <- a_newsp -- load new SP
179
180 L1:     brl                             # pc <- lr      -- (*a_f)()
181
182 /*
183  * returnto(area2)   This is a little jumbled, I tried to interleave 
184  * memory accesses with simple instructions for speed, and I tried to 
185  * set up the link register and condition register reasonably early
186  * so that processor instruction prefetching might help us out a little.
187  */
188         .set    a_area2, r3
189
190         .csect  .returnto[PR]
191         .globl  .returnto[PR]
192
193         l       r1, topstack(a_area2)   # r1 <- a_area2->topstack
194         cal     r1,  szdsa(r1)          # pop off frame
195         l       r7, PRE_Block.S(toc)    # r7 <- &PRE_Block
196
197         l       8, 8(1)                 # restore lr
198         mtlr    8                       # do it early so prefetch works
199
200         lm      12,  -8*nfprs-4*ngprs(r1)
201         cal     r6, 0(r0)               # r6 <- #0
202         mtcrf   0x38, 12                # put back cr
203         stb     r6, 0(r7)               # r6 -> PRE_Block
204
205 /*
206  * restore FPRs here!
207  */
208         lfd  14, -144(1)
209         lfd  15, -136(1)
210         lfd  16, -128(1)
211         lfd  17, -120(1)
212         lfd  18, -112(1)
213         lfd  19, -104(1)
214         lfd  20, -96(1)
215         lfd  21, -88(1)
216         lfd  22, -80(1)
217         lfd  23, -72(1)
218         lfd  24, -64(1)
219         lfd  25, -56(1)
220         lfd  26, -48(1)
221         lfd  27, -40(1)
222         lfd  28, -32(1)
223         lfd  29, -24(1)
224         lfd  30, -16(1)
225         lfd  31, -8(1)
226
227         brl                             # pc <- lr      -- return
228
229         .toc
230
231 PRE_Block.S:
232         .tc     PRE_Block[tc], PRE_Block[ua]
233         .extern PRE_Block[ua]
234
235 #endif  /* RIOS */
236         
237 #ifdef mc68000
238 /*
239 #
240 #       Information Technology Center
241 #       Carnegie-Mellon University
242 #
243 #
244 */
245         .data
246
247 /*
248 #
249 #       Process assembly language assist for Suns.
250 #
251 */
252
253         .text
254         .even
255
256 /*
257 #
258 # struct savearea {
259 #       char    *topstack;
260 # }
261 #
262 */
263
264         .globl  _PRE_Block
265
266 topstack =      0
267
268 /* Stuff to allow saving/restoring registers */
269 nregs   =       13
270 regs    =       0x3ffe                  | d1-d7 & a0-a5
271
272 /*
273 # savecontext(f, area1, newsp)
274 #     int (*f)(); struct savearea *area1; char *newsp;
275 */
276
277 /* Stack offsets of arguments */
278 f       =       8
279 area1   =       12
280 newsp   =       16
281
282         .globl  _savecontext
283 _savecontext:
284         movb    #1,_PRE_Block           | Dont allow any interrupt finagling
285         link    a6,#-(nregs*4)          | Save frame pointer & ...
286                                         | ... allocate space for nregs registers
287 /* Save registers */
288         moveml  #regs,sp@
289
290         movl    a6@(area1),a0           | a0 = base of savearea
291         movl    sp,a0@(topstack)        | area->topstack = sp
292         movl    a6@(newsp),d0           | Get new sp
293         jeq     forw1                   | If newsp == 0, no stack switch
294         movl    d0,sp                   | Switch to new stack
295 forw1:
296         movl    a6@(f),a0               | a0 = f
297         jbsr    a0@                     | f()
298
299 /* It is impossible to be here, so abort() */
300
301         jbsr    _abort
302
303 /*
304 # returnto(area2)
305 #     struct savearea *area2;
306 */
307
308 /* Stack offset of argument */
309 area2   =       8
310
311         .globl _returnto
312 _returnto:
313         link    a6,#0
314         movl    a6@(area2),a0           | Base of savearea
315         movl    a0@(topstack),sp        | Restore sp
316 /* Restore registers */
317         moveml  sp@,#regs
318
319         addl    #(nregs*4),sp
320         movl    sp,a6                   | Argghh...be careful here
321         unlk    a6
322         clrb    _PRE_Block
323         rts                             | Return to previous process
324 #endif /* mc68000 */
325 #ifdef  sparc
326 #ifdef  AFS_SUN5_ENV
327 #define _ASM    1
328 #include        <sys/asm_linkage.h>
329 #include  <sys/trap.h>
330 #else
331 #ifdef AFS_XBSD_ENV
332 #include <machine/trap.h>
333 #define ST_FLUSH_WINDOWS ST_FLUSHWIN
334 #define MINFRAME 92
335 #define SA(x) (((x)+7)&~7)
336 #define STACK_ALIGN 8
337 #else /* SunOS 4: */
338 #include        <sun4/asm_linkage.h>
339 #include  <sun4/trap.h>
340 #endif
341 #endif
342         .data   
343 #ifdef  AFS_SUN5_ENV
344         .globl  PRE_Block
345 #else
346         .globl  _PRE_Block
347 #endif
348 topstack        = 0
349 globals = 4
350 /*
351 # savecontext(f, area1, newsp)
352 #     int (*f)(); struct savearea *area1; char *newsp;
353 */
354         .text
355 #ifdef  AFS_SUN5_ENV
356         .globl  savecontext
357 savecontext:
358 #else
359         .globl  _savecontext
360 _savecontext:
361 #endif
362         save    %sp, -SA(MINFRAME), %sp ! Get new window
363         ta      ST_FLUSH_WINDOWS                ! FLush all other active windows
364
365         /* The following 3 lines do the equivalent of: _PRE_Block = 1 */
366 #ifdef  AFS_SUN5_ENV
367         set     PRE_Block, %l0
368 #else
369         set     _PRE_Block, %l0
370 #endif
371         mov     1,%l1
372         stb     %l1, [%l0]
373
374         st      %fp,[%i1+topstack]              ! area1->topstack = sp
375         
376         st      %g1, [%i1 + globals + 0]                /* Save all globals just in case */
377         st      %g2, [%i1 + globals + 4]
378         st      %g3, [%i1 + globals + 8]
379         st      %g4, [%i1 + globals + 12]
380         st      %g5, [%i1 + globals + 16]
381         st      %g6, [%i1 + globals + 20]
382         st      %g7, [%i1 + globals + 24]
383         mov     %y, %g1
384         st      %g1, [%i1 + globals + 28]
385
386 #ifdef  save_allregs
387         st      %f0, [%i1 + globals + 32 + 0]           ! Save all floating point registers 
388         st      %f1, [%i1 + globals + 32 + 4]
389         st      %f2, [%i1 + globals + 32 + 8]
390         st      %f3, [%i1 + globals + 32 + 12]
391         st      %f4, [%i1 + globals + 32 + 16]
392         st      %f5, [%i1 + globals + 32 + 20]
393         st      %f6, [%i1 + globals + 32 + 24]
394         st      %f7, [%i1 + globals + 32 + 28]
395         st      %f8, [%i1 + globals + 64 + 0]
396         st      %f9, [%i1 + globals + 64 + 4]
397         st      %f10, [%i1 + globals + 64 + 8]
398         st      %f11, [%i1 + globals + 64 + 12]
399         st      %f12, [%i1 + globals + 64 + 16]
400         st      %f13, [%i1 + globals + 64 + 20]
401         st      %f14, [%i1 + globals + 64 + 24]
402         st      %f15, [%i1 + globals + 64 + 28]
403         st      %f16, [%i1 + globals + 64 + 32]
404         st      %f17, [%i1 + globals + 64 + 36]
405         st      %f18, [%i1 + globals + 64 + 40]
406         st      %f19, [%i1 + globals + 64 + 44]
407         st      %f20, [%i1 + globals + 64 + 48]
408         st      %f21, [%i1 + globals + 64 + 52]
409         st      %f22, [%i1 + globals + 64 + 56]
410         st      %f23, [%i1 + globals + 64 + 60]
411         st      %f24, [%i1 + globals + 64 + 64]
412         st      %f25, [%i1 + globals + 64 + 68]
413         st      %f26, [%i1 + globals + 64 + 72]
414         st      %f27, [%i1 + globals + 64 + 76]
415         st      %f28, [%i1 + globals + 64 + 80]
416         st      %f29, [%i1 + globals + 64 + 84]
417         st      %f30, [%i1 + globals + 64 + 88]
418         st      %f31, [%i1 + globals + 64 + 92]
419 #ifdef  notdef
420         mov     %fsr,%g1
421         st      %g1, [%i1 + globals + 64 + 96]
422         mov     %fq,%g1
423         st      %g1, [%i1 + globals + 64 + 100]
424 #endif
425
426         st      %c0, [%i1 + globals + 168 + 0]                  ! Save all coprocessor registers 
427         st      %c1, [%i1 + globals + 168 + 4]
428         st      %c2, [%i1 + globals + 168 + 8]
429         st      %c3, [%i1 + globals + 168 + 12]
430         st      %c4, [%i1 + globals + 168 + 16]
431         st      %c5, [%i1 + globals + 168 + 20]
432         st      %c6, [%i1 + globals + 168 + 24]
433         st      %c7, [%i1 + globals + 168 + 28]
434         st      %c8, [%i1 + globals + 200 + 0]
435         st      %c9, [%i1 + globals + 200 + 4]
436         st      %c10, [%i1 + globals + 200 + 8]
437         st      %c11, [%i1 + globals + 200 + 12]
438         st      %c12, [%i1 + globals + 200 + 16]
439         st      %c13, [%i1 + globals + 200 + 20]
440         st      %c14, [%i1 + globals + 200 + 24]
441         st      %c15, [%i1 + globals + 200 + 28]
442         st      %c16, [%i1 + globals + 200 + 32]
443         st      %c17, [%i1 + globals + 200 + 36]
444         st      %c18, [%i1 + globals + 200 + 40]
445         st      %c19, [%i1 + globals + 200 + 44]
446         st      %c20, [%i1 + globals + 200 + 48]
447         st      %c21, [%i1 + globals + 200 + 52]
448         st      %c22, [%i1 + globals + 200 + 56]
449         st      %c23, [%i1 + globals + 200 + 60]
450         st      %c24, [%i1 + globals + 200 + 64]
451         st      %c25, [%i1 + globals + 200 + 68]
452         st      %c26, [%i1 + globals + 200 + 72]
453         st      %c27, [%i1 + globals + 200 + 76]
454         st      %c28, [%i1 + globals + 200 + 80]
455         st      %c29, [%i1 + globals + 200 + 84]
456         st      %c30, [%i1 + globals + 200 + 88]
457         st      %c31, [%i1 + globals + 200 + 92]
458 #ifdef  notdef
459         mov     %csr,%g1
460         st      %g1, [%i1 + globals + 200 + 96]
461         mov     %cq,%g1
462         st      %g1, [%i1 + globals + 200 + 100]
463 #endif
464 #endif
465         cmp     %i2, 0
466         be,a    L1                              ! if (newsp == 0) no stack switch
467         nop
468 #ifdef  notdef
469         add     %i2, STACK_ALIGN - 1, %i2
470         and     %i2, ~(STACK_ALIGN - 1), %i2
471         sub     %i2, SA(MINFRAME), %fp
472         call    %i0
473         restore
474 #else
475         ! This used to compute a new stack frame base, write it into
476         ! FP, and restore to enter the new frame. But that left a window
477         ! in which FP could be written into the backing store for this
478         ! frame, to be tripped over later by returnto. So instead we do
479         ! the restore first, then modify SP to enter the new frame. We
480         ! can still refer to our argument as %02.
481         restore
482         add     %o2, STACK_ALIGN - 1, %o2
483         and     %o2, ~(STACK_ALIGN - 1), %o2    
484         call    %o0
485         sub     %o2, SA(MINFRAME), %sp
486 #endif  
487
488 L1:     call    %i0                     ! call f()
489         nop
490
491
492 ! returnto(area1)
493 !     struct savearea *area1;
494 #ifdef  AFS_SUN5_ENV
495         .globl returnto
496 returnto:
497 #else
498         .globl _returnto
499 _returnto:
500 #endif
501         ta      ST_FLUSH_WINDOWS                ! FLush all other active windows
502         ld      [%o0+topstack],%g1              ! sp = area1->topstack
503         sub     %g1, SA(MINFRAME), %fp  ! Adjust sp to the right place
504         sub     %fp, SA(MINFRAME), %sp
505
506 #ifdef  save_allregs
507         ld      [%o0 + globals + 32 + 0],%f0            ! Restore floating-point registers 
508         ld      [%o0 + globals + 32 + 4],%f1
509         ld      [%o0 + globals + 32 + 8],%f2
510         ld      [%o0 + globals + 32 + 12],%f3
511         ld      [%o0 + globals + 32 + 16],%f4
512         ld      [%o0 + globals + 32 + 20],%f5
513         ld      [%o0 + globals + 32 + 24],%f6
514         ld      [%o0 + globals + 32 + 28],%f7
515         ld      [%o0 + globals + 64 + 0],%f8
516         ld      [%o0 + globals + 64 + 4],%f9
517         ld      [%o0 + globals + 64 + 8],%f10
518         ld      [%o0 + globals + 64 + 12],%f11
519         ld      [%o0 + globals + 64 + 16],%f12
520         ld      [%o0 + globals + 64 + 20],%f13
521         ld      [%o0 + globals + 64 + 24],%f14
522         ld      [%o0 + globals + 64 + 28],%f15
523         ld      [%o0 + globals + 64 + 32],%f16
524         ld      [%o0 + globals + 64 + 36],%f17
525         ld      [%o0 + globals + 64 + 40],%f18
526         ld      [%o0 + globals + 64 + 44],%f19
527         ld      [%o0 + globals + 64 + 48],%f20
528         ld      [%o0 + globals + 64 + 52],%f21
529         ld      [%o0 + globals + 64 + 56],%f22
530         ld      [%o0 + globals + 64 + 60],%f23
531         ld      [%o0 + globals + 64 + 64],%f24
532         ld      [%o0 + globals + 64 + 68],%f25
533         ld      [%o0 + globals + 64 + 72],%f26
534         ld      [%o0 + globals + 64 + 76],%f27
535         ld      [%o0 + globals + 64 + 80],%f28
536         ld      [%o0 + globals + 64 + 84],%f29
537         ld      [%o0 + globals + 64 + 88],%f30
538         ld      [%o0 + globals + 64 + 92],%f31
539 #ifdef  notdef
540         ld      [%o0 + globals + 64 + 96],%g1
541         mov     %g1, %fsr
542         ld      [%o0 + globals + 64 + 100],%g1
543         mov     %g1, %fq
544 #endif
545
546         ld      [%o0 + globals + 168 + 0],%c0           ! Restore floating-point registers 
547         ld      [%o0 + globals + 168 + 4],%c1
548         ld      [%o0 + globals + 168 + 8],%c2
549         ld      [%o0 + globals + 168 + 12],%c3
550         ld      [%o0 + globals + 168 + 16],%c4
551         ld      [%o0 + globals + 168 + 20],%c5
552         ld      [%o0 + globals + 168 + 24],%c6
553         ld      [%o0 + globals + 168 + 28],%c7
554         ld      [%o0 + globals + 200 + 0],%c8
555         ld      [%o0 + globals + 200 + 4],%c9
556         ld      [%o0 + globals + 200 + 8],%c10
557         ld      [%o0 + globals + 200 + 12],%c11
558         ld      [%o0 + globals + 200 + 16],%c12
559         ld      [%o0 + globals + 200 + 20],%c13
560         ld      [%o0 + globals + 200 + 24],%c14
561         ld      [%o0 + globals + 200 + 28],%c15
562         ld      [%o0 + globals + 200 + 32],%c16
563         ld      [%o0 + globals + 200 + 36],%c17
564         ld      [%o0 + globals + 200 + 40],%c18
565         ld      [%o0 + globals + 200 + 44],%c19
566         ld      [%o0 + globals + 200 + 48],%c20
567         ld      [%o0 + globals + 200 + 52],%c21
568         ld      [%o0 + globals + 200 + 56],%c22
569         ld      [%o0 + globals + 200 + 60],%c23
570         ld      [%o0 + globals + 200 + 64],%c24
571         ld      [%o0 + globals + 200 + 68],%c25
572         ld      [%o0 + globals + 200 + 72],%c26
573         ld      [%o0 + globals + 200 + 76],%c27
574         ld      [%o0 + globals + 200 + 80],%c28
575         ld      [%o0 + globals + 200 + 84],%c29
576         ld      [%o0 + globals + 200 + 88],%c30
577         ld      [%o0 + globals + 200 + 92],%c31
578 #ifdef  notdef
579         ld      [%o0 + globals + 200 + 96],%g1
580         mov     %g1, %csr
581         ld      [%o0 + globals + 200 + 100],%g1
582         mov     %g1, %cq
583 #endif
584 #endif
585         ld      [%o0 + globals + 28], %g1               ! Restore global regs back
586         mov     %g1, %y
587         ld      [%o0 + globals + 0], %g1
588         ld      [%o0 + globals + 4], %g2
589         ld      [%o0 + globals + 8], %g3
590         ld      [%o0 + globals + 12],%g4
591         ld      [%o0 + globals + 16],%g5
592         ld      [%o0 + globals + 20],%g6
593         ld      [%o0 + globals + 24],%g7
594
595         /* The following 3 lines are equivalent to: _PRE_Block = 0 */
596 #ifdef  AFS_SUN5_ENV
597         set     PRE_Block, %l0
598 #else
599         set     _PRE_Block, %l0
600 #endif
601         mov     0,%l1
602         stb     %l1, [%l0]
603
604         restore                                 
605         restore
606
607         retl
608         nop
609
610 #endif /* sparc */
611 #ifdef ibm032
612 |
613 |       Information Technology Center
614 |       Carnegie-Mellon University
615 |
616 |
617         .data
618         .globl  .oVncs
619         .set            .oVncs,0
620
621         .globl  _savecontext
622 _savecontext:
623         .long           _.savecontext
624
625         .globl  _returnto
626 _returnto:
627         .long           _.returnto
628
629 |
630 |       Process assembly language assist for Sailboats.
631 |
632
633         .text
634         .align 2
635
636 |
637 | struct savearea {
638 |       char    *topstack;
639 | }
640 |
641
642 | Offsets of fields
643 .set topstack,0
644
645 | Stuff to allow saving/restoring registers
646 .set regspace,64
647 .set freg,0
648
649 |
650 | savecontext(f, area1, newsp)
651 |    int (*f)(); struct savearea *area1; char *newsp;
652 |
653
654         .globl  _.savecontext
655 _.savecontext:
656         ai      sp,sp,-regspace         | Save frame pointer & ...
657                                         | ... allocate space for 16 registers
658 | Save registers
659         stm     r0,0(sp)                        | Change this if save fewer regs.
660 | Set preemption semaphore
661         get     r6,$1
662         get     r7,$_PRE_Block
663         putc    r6,0(r7)                        | PRE_Block = 1
664 | r3 = base of savearea
665         put     sp,topstack(r3)         | area1->topstack = sp
666 | New sp is in r4.
667         cis     r4,0
668         be      L1                      | If newsp == 0, no stack switch
669         cas     sp,r4,r0                        | Switch to new stack
670 L1:
671         get     r6,0(r2)                        | r2 = _f
672         balrx   r15,r6                  | f()
673         cas     r0,r2,r0
674
675 |
676 | returnto(area2)
677 |     struct savearea *area2;
678 |
679
680         .globl _.returnto
681 _.returnto:
682         get     sp,topstack(r2)
683 | Now in the context of the savecontext stack to be restored.
684 | Start with the registers...
685 | Clear preemption semaphore
686         get     r6,$0
687         get     r7,$_PRE_Block
688         putc    r6,0(r7)                        | PRE_Block = 0
689         lm      r0,0(sp)                | Change if saving fewer regs.
690         brx     r15             | Return to previous process
691         ai      sp,sp,regspace
692  .data
693  .ltorg
694 #endif
695
696 #ifdef AFS_AIX22_ENV
697 /*
698 #
699 #       Information Technology Center
700 #       Carnegie-Mellon University
701 #
702 */
703 /*
704 #
705 #       Process assembly language assist for Sailboats.
706 #
707 */
708
709         .text
710         .globl  .savecontext
711         .align 1
712
713 /*
714 #
715 # struct savearea {
716 #       char    *topstack;
717 # }
718 #
719 */
720
721
722 /*# Offsets of fields*/
723 .set topstack,0
724
725 /*# Stuff to allow saving/restoring registers*/
726 .set regspace,64
727 .set freg,0
728
729 /*
730 #
731 # savecontext(f, area1, newsp)
732 #    int (*f)(); struct savearea *area1; char *newsp;
733 #
734 */
735
736 .savecontext:
737         ai      1,1,-regspace           # Save frame pointer & ...
738
739 /*# Save registers*/
740         stm     0,0(1)                  # Change this if save fewer regs.
741         lr      14,0
742 /*# Set preemption semaphore*/
743         lis     6,1
744         l       7,4(14)
745         stc     6,0(7)
746 /*# r3 = base of savearea*/
747         st      1,topstack(3)           # area1->topstack = sp
748 /*# New sp is in r4.*/
749         ci      4,0
750         beq     L1                      # If newsp == 0, no stack switch
751         cas     1,4,0                   # Switch to new stack
752 L1:
753         l       6,0(2)                  # r2 = _f
754         balrx   15,6                    # f()
755         cas     0,2,0
756         .data   3
757         .globl  _savecontext
758 _savecontext:
759         .long   .savecontext
760         .long   _PRE_Block
761 /*
762 #
763 # returnto(area2)
764 #     struct savearea *area2;
765 #
766 */
767
768         .text
769         .globl  .returnto
770         .align 1
771 .returnto:
772         l       1,topstack(2)
773 /*
774 # Now in the context of the savecontext stack to be restored.
775 # Start with the registers...
776 # Clear preemption semaphore
777 */
778         lr      14,0
779         lis     6,0
780         l       7,4(14)
781         stc     6,0(7)
782         lm      0,0(1)          # Change if saving fewer regs.
783         brx     15              # Return to previous process
784         ai      1,1,regspace
785         .data   3
786         .globl  _returnto
787 _returnto:
788         .long   .returnto
789         .long   _PRE_Block
790 #endif /* AFS_AIX_ENV */
791
792 #ifdef vax
793 /*
794 #
795 #       Information Technology Center
796 #       Carnegie-Mellon University
797 #
798 #
799 */
800         .data
801
802 /*
803 #
804 #       Algorithm: "Monkey see, monkey do"
805 #
806 */
807
808         .text
809
810 /*
811 #
812 # struct savearea {
813 #       char    *topstack;
814 # }
815 #
816 */
817
818         .set    topstack,0
819
820 /* Stuff to allow saving/restoring registers */
821
822 /*
823 # savecontext(f, area1, newsp)
824 #     int (*f)(); struct savearea *area1; char *newsp;
825 */
826
827 /* Stack offsets of arguments */
828         .set    f,4
829         .set    area1,8
830         .set    newsp,12
831
832 .globl  _PRE_Block
833 .globl  _savecontext
834
835 _savecontext:
836         .word 0x0ffc    # Save regs R2-R11
837         movb    $1,_PRE_Block           # Critical section for preemption code
838         pushl   ap                      # save old ap
839         pushl   fp                      # save old fp    
840         movl    area1(ap),r0            # r0 = base of savearea
841         movl    sp,topstack(r0)         # area->topstack = sp
842         movl    newsp(ap),r0            # Get new sp
843         beql    L1                      # if new sp is 0, dont change stacks
844         movl    r0,sp                   # else switch to new stack
845 L1:
846         movl    f(ap),r1                # r1 = f
847         calls   $0,0(r1)                # f()
848
849 /* It is impossible to be here, so abort() */
850
851         calls   $0,_abort
852
853 /*
854 # returnto(area2)
855 #     struct savearea *area2;
856 */
857
858 /* Stack offset of argument */
859         .set    area2,4
860
861         .globl _returnto
862 _returnto:
863         .word   0x0                     # Who cares about these regs?
864         movl    area2(ap),r0            # r0 = address of area2
865         movl    topstack(r0),sp         # Restore sp
866         movl    (sp)+,fp                # Restore fp
867         movl    (sp)+,ap                # ,,,,
868         clrb    _PRE_Block              # End of preemption critical section
869         ret
870
871         pushl   $1234                   # The author will gloat
872         calls   $0,_abort
873 #endif
874
875 #ifdef mips
876 #ifdef  sgi
877         .option pic2
878
879 #include <regdef.h> /* Allow use of symbolic names for registers. */
880 /* 9 sregs, ra, 6 fp regs, gp, pad to 8 byte boundary */
881 #define regspace 9 * 4 + 4 + 6 * 8 + 4 + 4
882 #define floats 0
883 #define registers floats + 6 * 8
884 #define returnaddr regspace - 4
885 #define topstack 0
886 #define GPOFF   regspace - 8
887         .globl savecontext /* MIPS' C compiler doesnt prepend underscores. */
888         .ent savecontext /* Insert debugger information. */
889 savecontext:
890         .set    noreorder
891         .cpload t9                      # set up gp for KPIC
892         .set    reorder
893         subu sp, regspace
894         .cprestore GPOFF                # trigger t9/jalr
895         .set    noreorder
896         li      t0, 1
897         .extern PRE_Block
898         sb      t0, PRE_Block
899         .set    reorder
900         .frame  sp, regspace, ra
901 /* Save registers. */
902         sw      s0, registers + 0(sp)
903         sw      s1, registers + 4(sp)
904         sw      s2, registers + 8(sp)
905         sw      s3, registers + 12(sp)
906         sw      s4, registers + 16(sp)
907         sw      s5, registers + 20(sp)
908         sw      s6, registers + 24(sp)
909         sw      s7, registers + 28(sp)
910         sw      s8, registers + 32(sp)
911 /* Save return address */
912         sw      ra, returnaddr(sp)
913         .mask   0xc0ff0000, -4
914 /* Need to save floating point registers? */
915         s.d     $f20, floats + 0(sp)
916         s.d     $f22, floats + 8(sp)
917         s.d     $f24, floats + 16(sp)
918         s.d     $f26, floats + 24(sp)
919         s.d     $f28, floats + 32(sp)
920         s.d     $f30, floats + 40(sp)
921         .fmask  0x55400000, regspace
922         sw      sp, topstack(a1)
923         beq     a2, $0, samestack
924         move    sp, a2
925 samestack:
926         move    t9, a0
927         j       t9
928         .end    savecontext
929
930         .globl  returnto
931         .ent    returnto
932 returnto:
933         .set    noreorder
934         .cpload t9                      # set up gp for KPIC
935         .set    reorder
936
937         lw      sp, topstack(a0)
938         lw      s0, registers + 0(sp)
939         lw      s1, registers + 4(sp)
940         lw      s2, registers + 8(sp)
941         lw      s3, registers + 12(sp)
942         lw      s4, registers + 16(sp)
943         lw      s5, registers + 20(sp)
944         lw      s6, registers + 24(sp)
945         lw      s7, registers + 28(sp)
946         lw      s8, registers + 32(sp)
947 /* Save return address */
948         lw      ra, returnaddr(sp)
949 /* Need to save floating point registers? */
950         l.d     $f20, floats + 0(sp)
951         l.d     $f22, floats + 8(sp)
952         l.d     $f24, floats + 16(sp)
953         l.d     $f26, floats + 24(sp)
954         l.d     $f28, floats + 32(sp)
955         l.d     $f30, floats + 40(sp)
956         .set    noreorder
957         addu    sp, regspace
958         la      t0, PRE_Block
959         j       ra
960         sb      zero, 0(t0)
961         .set    reorder
962         .end    returnto
963
964 #else
965 /* Code for MIPS R2000/R3000 architecture
966  * Written by Zalman Stern April 30th, 1989.
967  */
968 #include <regdef.h> /* Allow use of symbolic names for registers. */
969 #define regspace 9 * 4 + 4 + 6 * 8
970 #define floats 0
971 #define registers floats + 6 * 8
972 #define returnaddr regspace - 4
973 #define topstack 0
974         .globl savecontext /* MIPS' C compiler doesnt prepend underscores. */
975         .ent savecontext /* Insert debugger information. */
976 savecontext:
977         li      t0, 1
978         .extern PRE_Block
979         sb      t0, PRE_Block
980         subu    sp, regspace
981         .frame  sp, regspace, ra
982 /* Save registers. */
983         sw      s0, registers + 0(sp)
984         sw      s1, registers + 4(sp)
985         sw      s2, registers + 8(sp)
986         sw      s3, registers + 12(sp)
987         sw      s4, registers + 16(sp)
988         sw      s5, registers + 20(sp)
989         sw      s6, registers + 24(sp)
990         sw      s7, registers + 28(sp)
991         sw      s8, registers + 32(sp)
992 /* Save return address */
993         sw      ra, returnaddr(sp)
994         .mask   0xc0ff0000, -4
995 /* Need to save floating point registers? */
996         s.d     $f20, floats + 0(sp)
997         s.d     $f22, floats + 8(sp)
998         s.d     $f24, floats + 16(sp)
999         s.d     $f26, floats + 24(sp)
1000         s.d     $f28, floats + 32(sp)
1001         s.d     $f30, floats + 40(sp)
1002         .fmask  0x55400000, regspace
1003         sw      sp, topstack(a1)
1004         beq     a2, $0, samestack
1005         addu    sp, $0, a2
1006 samestack:
1007         jal     a0
1008         .end    savecontext
1009
1010         .globl  returnto
1011         .ent    returnto
1012 returnto:
1013         lw      sp, topstack(a0)
1014         lw      s0, registers + 0(sp)
1015         lw      s1, registers + 4(sp)
1016         lw      s2, registers + 8(sp)
1017         lw      s3, registers + 12(sp)
1018         lw      s4, registers + 16(sp)
1019         lw      s5, registers + 20(sp)
1020         lw      s6, registers + 24(sp)
1021         lw      s7, registers + 28(sp)
1022         lw      s8, registers + 32(sp)
1023 /* Save return address */
1024         lw      ra, returnaddr(sp)
1025 /* Need to save floating point registers? */
1026         l.d     $f20, floats + 0(sp)
1027         l.d     $f22, floats + 8(sp)
1028         l.d     $f24, floats + 16(sp)
1029         l.d     $f26, floats + 24(sp)
1030         l.d     $f28, floats + 32(sp)
1031         l.d     $f30, floats + 40(sp)
1032         addu    sp, regspace
1033         sb      $0, PRE_Block
1034         j       ra
1035         .end    returnto
1036 #endif  /* sgi */
1037 #endif
1038
1039 #ifdef AFS_HPUX_ENV
1040 #include "process.s.hpux"
1041 #endif /* AFS_HPUX_ENV */
1042
1043 #ifdef __alpha
1044 /* Code for DEC Alpha architecture */
1045 #if defined(AFS_XBSD_ENV)
1046 #include <machine/asm.h>
1047 #else   /* !XBSD */
1048 #include <mach/alpha/asm.h>
1049 #endif  /* !XBSD */
1050
1051 #define FRAMESIZE ((8*8)+8+(7*8))
1052 #define floats 0
1053 #define registers (floats+(8*8))
1054 #define returnaddr (FRAMESIZE-8)
1055 #define topstack 0
1056
1057 .align  4
1058 NESTED(savecontext,3,FRAMESIZE,ra,0x0400f700,0x000003fc)
1059         ldgp    gp,0(pv)
1060         lda     t0, 1(zero)
1061         stl     t0, PRE_Block
1062         lda     sp,-FRAMESIZE(sp)
1063 /* Save callee-saved registers. */
1064         stq     s0, (registers+0) (sp)
1065         stq     s1, (registers+8) (sp)
1066         stq     s2, (registers+16) (sp)
1067         stq     s3, (registers+24) (sp)
1068         stq     s4, (registers+32) (sp)
1069         stq     s5, (registers+40) (sp)
1070         stq     s6, (registers+48) (sp)
1071 /* Save return address */
1072         stq     ra, returnaddr(sp)
1073
1074         .mask   (M_S0|M_S1|M_S2|M_S3|M_S4|M_S5|M_S6|M_RA), -FRAMESIZE
1075
1076 /* Save floating point registers */
1077         stt     fs0, (floats+0) (sp)
1078         stt     fs1, (floats+8) (sp)
1079         stt     fs2, (floats+16) (sp)
1080         stt     fs3, (floats+24) (sp)
1081         stt     fs4, (floats+32) (sp)
1082         stt     fs5, (floats+40) (sp)
1083         stt     fs6, (floats+48) (sp)
1084         stt     fs7, (floats+56) (sp)
1085
1086         .prologue       1
1087         stq     sp, topstack(a1)
1088         or      a0,zero,pv              /* call point in pv */
1089         beq     a2, samestack
1090         or      a2,zero,sp              /* switch stack */
1091 samestack:
1092         jsr     ra,(pv),0               /* off we go */
1093         END(savecontext)
1094
1095 LEAF(returnto,1)
1096         ldgp    gp,0(pv)
1097
1098         .prologue       1
1099         ldq     sp, topstack(a0)
1100 /* Restore callee-saved regs */
1101         ldq     s0, (registers+0) (sp)
1102         ldq     s1, (registers+8) (sp)
1103         ldq     s2, (registers+16) (sp)
1104         ldq     s3, (registers+24) (sp)
1105         ldq     s4, (registers+32) (sp)
1106         ldq     s5, (registers+40) (sp)
1107         ldq     s6, (registers+48) (sp)
1108 /* Return address */
1109         ldq     ra, returnaddr(sp)
1110 /* Floating point registers */
1111         ldt     fs0, (floats+0) (sp)
1112         ldt     fs1, (floats+8) (sp)
1113         ldt     fs2, (floats+16) (sp)
1114         ldt     fs3, (floats+24) (sp)
1115         ldt     fs4, (floats+32) (sp)
1116         ldt     fs5, (floats+40) (sp)
1117         ldt     fs6, (floats+48) (sp)
1118         ldt     fs7, (floats+56) (sp)
1119         lda     sp, FRAMESIZE(sp)
1120         stl     zero, PRE_Block
1121         RET
1122         END(returnto)
1123 #endif
1124
1125 #ifdef AFS_PPC_ENV
1126 /* Comments:
1127  *    1. Registers R10..R31 and CR0..CR7 are saved
1128  *    2. "struct savearea" must hold at least 3 pointers (long)
1129  *    3. This code will only work on 32 bit machines (601..604), not 620
1130  *    4. No floating point registers are saved
1131  *    5. The save stack "frame" is bigger than absolutely necessary.  The
1132  *       PowerPC [AIX] ABI needs this extra space.
1133  */
1134
1135
1136 /* Mach-O assemblers */
1137 #if !defined(NeXT) && !defined(__APPLE__)
1138 #define r0    0
1139 #define r1    1
1140 #define r2    2
1141 #define r3    3
1142 #define r4    4
1143 #define r5    5
1144 #define r6    6
1145 #define r7    7
1146 #define r8    8
1147 #define r9    9
1148 #define r10   10
1149 #define r11   11
1150 #define r12   12
1151 #define r13   13
1152 #define r14   14
1153 #define r15   15
1154 #define r16   16
1155 #define r17   17
1156 #define r18   18
1157 #define r19   19
1158 #define r20   20
1159 #define r21   21
1160 #define r22   22
1161 #define r23   23
1162 #define r24   24
1163 #define r25   25
1164 #define r26   26
1165 #define r27   27
1166 #define r28   28
1167 #define r29   29
1168 #define r30   30
1169 #define r31   31
1170 #endif /* !NeXT && !__APPLE__ */
1171
1172
1173 /*
1174  * savecontext(int (*f)(), struct savearea *save, char *newsp)
1175  */
1176
1177 #define FRAME_SIZE    (32*4)+(8*4)
1178 #define FRAME_OFFSET  (8*4)
1179 #define TOP_OF_STACK  (0*4)
1180 #define RETURN                (1*4)
1181 #define CCR           (2*4)
1182
1183 #if defined(NeXT) || defined(__APPLE__)
1184       .globl  _savecontext
1185 _savecontext:
1186       lis     r9,ha16(_PRE_Block)     /* Disable interrupt fiddling */
1187       li      r8,1
1188       stb     r8,lo16(_PRE_Block)(r9)
1189 #else
1190       .globl  savecontext
1191 savecontext:
1192       lis     r9,PRE_Block@ha         /* Disable interrupt fiddling */
1193       li      r8,1
1194       stb     r8,PRE_Block@l(r9)
1195 #endif /* NeXT || __APPLE__ */
1196       subi    r1,r1,FRAME_SIZE
1197       mfcr    r9
1198       stw     r9,CCR(r4)
1199       stw     r10,10*4+FRAME_OFFSET(r1)       /* Save registers */
1200       stw     r11,11*4+FRAME_OFFSET(r1)
1201       stw     r12,12*4+FRAME_OFFSET(r1)
1202       stw     r13,13*4+FRAME_OFFSET(r1)
1203       stw     r14,14*4+FRAME_OFFSET(r1)
1204       stw     r15,15*4+FRAME_OFFSET(r1)
1205       stw     r16,16*4+FRAME_OFFSET(r1)
1206       stw     r17,17*4+FRAME_OFFSET(r1)
1207       stw     r18,18*4+FRAME_OFFSET(r1)
1208       stw     r19,19*4+FRAME_OFFSET(r1)
1209       stw     r20,20*4+FRAME_OFFSET(r1)
1210       stw     r21,21*4+FRAME_OFFSET(r1)
1211       stw     r22,22*4+FRAME_OFFSET(r1)
1212       stw     r23,23*4+FRAME_OFFSET(r1)
1213       stw     r24,24*4+FRAME_OFFSET(r1)
1214       stw     r25,25*4+FRAME_OFFSET(r1)
1215       stw     r26,26*4+FRAME_OFFSET(r1)
1216       stw     r27,27*4+FRAME_OFFSET(r1)
1217       stw     r28,28*4+FRAME_OFFSET(r1)
1218       stw     r29,29*4+FRAME_OFFSET(r1)
1219       stw     r30,30*4+FRAME_OFFSET(r1)
1220       stw     r31,31*4+FRAME_OFFSET(r1)
1221       stw     r1,TOP_OF_STACK(r4)
1222       cmpi    0,r5,0                          /* New stack specified? */
1223       mflr    r0
1224       stw     r0,RETURN(r4)
1225       mtlr    r3
1226       beq     L1                             /* No - don't muck with pointer */
1227
1228       mr      r1,r5
1229 L1:        blr                                     /* Return */
1230
1231 /*
1232  * returnto(struct savearea *area)
1233  */
1234 #if defined(NeXT) || defined(__APPLE__)
1235       .globl  _returnto
1236 _returnto:
1237 #else
1238       .globl  returnto
1239 returnto:
1240 #endif /* NeXT || __APPLE__ */
1241       lwz     r1,TOP_OF_STACK(r3)             /* Update stack pointer */
1242       lwz     r0,RETURN(r3)                   /* Get return address */
1243       mtlr    r0
1244       lwz     r4,CCR(r3)
1245       mtcrf   0xFF,r4
1246       lwz     r10,10*4+FRAME_OFFSET(r1)       /* Restore registers */
1247       lwz     r11,11*4+FRAME_OFFSET(r1)
1248       lwz     r12,12*4+FRAME_OFFSET(r1)
1249       lwz     r13,13*4+FRAME_OFFSET(r1)
1250       lwz     r14,14*4+FRAME_OFFSET(r1)
1251       lwz     r15,15*4+FRAME_OFFSET(r1)
1252       lwz     r16,16*4+FRAME_OFFSET(r1)
1253       lwz     r17,17*4+FRAME_OFFSET(r1)
1254       lwz     r18,18*4+FRAME_OFFSET(r1)
1255       lwz     r19,19*4+FRAME_OFFSET(r1)
1256       lwz     r20,20*4+FRAME_OFFSET(r1)
1257       lwz     r21,21*4+FRAME_OFFSET(r1)
1258       lwz     r22,22*4+FRAME_OFFSET(r1)
1259       lwz     r23,23*4+FRAME_OFFSET(r1)
1260       lwz     r24,24*4+FRAME_OFFSET(r1)
1261       lwz     r25,25*4+FRAME_OFFSET(r1)
1262       lwz     r26,26*4+FRAME_OFFSET(r1)
1263       lwz     r27,27*4+FRAME_OFFSET(r1)
1264       lwz     r28,28*4+FRAME_OFFSET(r1)
1265       lwz     r29,29*4+FRAME_OFFSET(r1)
1266       lwz     r30,30*4+FRAME_OFFSET(r1)
1267       lwz     r31,31*4+FRAME_OFFSET(r1)
1268 #if defined(NeXT) || defined(__APPLE__)
1269       lis     r9,ha16(_PRE_Block)         /* Re-enable interrupt fiddling */
1270       li      r8,0
1271       stb     r8,lo16(_PRE_Block)(r9)
1272 #else
1273       lis     r9,PRE_Block@ha         /* Re-enable interrupt fiddling */
1274       li      r8,0
1275       stb     r8,PRE_Block@l(r9)
1276 #endif /* NeXT || __APPLE__ */
1277       addi    r1,r1,FRAME_SIZE
1278       blr
1279 #endif
1280         
1281 #if defined(__linux__) && defined(__ELF__)
1282         .section .note.GNU-stack,"",%progbits
1283 #endif