Commit | Line | Data |
---|---|---|
805e021f CE |
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 | #ifdef AFS_OSF_ENV | |
1046 | #include <machine/asm.h> | |
1047 | #include <machine/regdef.h> | |
1048 | #define fs0 $f2 | |
1049 | #define fs1 $f3 | |
1050 | #define fs2 $f4 | |
1051 | #define fs3 $f5 | |
1052 | #define fs4 $f6 | |
1053 | #define fs5 $f7 | |
1054 | #define fs6 $f8 | |
1055 | #define fs7 $f9 | |
1056 | #elif defined(AFS_XBSD_ENV) | |
1057 | #include <machine/asm.h> | |
1058 | #else /* !OSF && !XBSD */ | |
1059 | #include <mach/alpha/asm.h> | |
1060 | #endif /* OSF */ | |
1061 | ||
1062 | #define FRAMESIZE ((8*8)+8+(7*8)) | |
1063 | #define floats 0 | |
1064 | #define registers (floats+(8*8)) | |
1065 | #define returnaddr (FRAMESIZE-8) | |
1066 | #define topstack 0 | |
1067 | ||
1068 | #ifdef AFS_OSF_ENV | |
1069 | IMPORT(PRE_Block,4) | |
1070 | #endif | |
1071 | .align 4 | |
1072 | #ifdef AFS_OSF_ENV | |
1073 | NESTED(savecontext,FRAMESIZE,ra) | |
1074 | #else /* OSF */ | |
1075 | NESTED(savecontext,3,FRAMESIZE,ra,0x0400f700,0x000003fc) | |
1076 | #endif /* OSF */ | |
1077 | ldgp gp,0(pv) | |
1078 | lda t0, 1(zero) | |
1079 | stl t0, PRE_Block | |
1080 | lda sp,-FRAMESIZE(sp) | |
1081 | /* Save callee-saved registers. */ | |
1082 | stq s0, (registers+0) (sp) | |
1083 | stq s1, (registers+8) (sp) | |
1084 | stq s2, (registers+16) (sp) | |
1085 | stq s3, (registers+24) (sp) | |
1086 | stq s4, (registers+32) (sp) | |
1087 | stq s5, (registers+40) (sp) | |
1088 | stq s6, (registers+48) (sp) | |
1089 | /* Save return address */ | |
1090 | stq ra, returnaddr(sp) | |
1091 | ||
1092 | .mask (M_S0|M_S1|M_S2|M_S3|M_S4|M_S5|M_S6|M_RA), -FRAMESIZE | |
1093 | ||
1094 | /* Save floating point registers */ | |
1095 | stt fs0, (floats+0) (sp) | |
1096 | stt fs1, (floats+8) (sp) | |
1097 | stt fs2, (floats+16) (sp) | |
1098 | stt fs3, (floats+24) (sp) | |
1099 | stt fs4, (floats+32) (sp) | |
1100 | stt fs5, (floats+40) (sp) | |
1101 | stt fs6, (floats+48) (sp) | |
1102 | stt fs7, (floats+56) (sp) | |
1103 | ||
1104 | .prologue 1 | |
1105 | stq sp, topstack(a1) | |
1106 | or a0,zero,pv /* call point in pv */ | |
1107 | beq a2, samestack | |
1108 | or a2,zero,sp /* switch stack */ | |
1109 | samestack: | |
1110 | jsr ra,(pv),0 /* off we go */ | |
1111 | END(savecontext) | |
1112 | ||
1113 | #ifdef AFS_OSF_ENV | |
1114 | LEAF(returnto) | |
1115 | #else | |
1116 | LEAF(returnto,1) | |
1117 | #endif | |
1118 | ldgp gp,0(pv) | |
1119 | ||
1120 | .prologue 1 | |
1121 | ldq sp, topstack(a0) | |
1122 | /* Restore callee-saved regs */ | |
1123 | ldq s0, (registers+0) (sp) | |
1124 | ldq s1, (registers+8) (sp) | |
1125 | ldq s2, (registers+16) (sp) | |
1126 | ldq s3, (registers+24) (sp) | |
1127 | ldq s4, (registers+32) (sp) | |
1128 | ldq s5, (registers+40) (sp) | |
1129 | ldq s6, (registers+48) (sp) | |
1130 | /* Return address */ | |
1131 | ldq ra, returnaddr(sp) | |
1132 | /* Floating point registers */ | |
1133 | ldt fs0, (floats+0) (sp) | |
1134 | ldt fs1, (floats+8) (sp) | |
1135 | ldt fs2, (floats+16) (sp) | |
1136 | ldt fs3, (floats+24) (sp) | |
1137 | ldt fs4, (floats+32) (sp) | |
1138 | ldt fs5, (floats+40) (sp) | |
1139 | ldt fs6, (floats+48) (sp) | |
1140 | ldt fs7, (floats+56) (sp) | |
1141 | lda sp, FRAMESIZE(sp) | |
1142 | stl zero, PRE_Block | |
1143 | RET | |
1144 | END(returnto) | |
1145 | #endif | |
1146 | ||
1147 | #ifdef AFS_PPC_ENV | |
1148 | /* Comments: | |
1149 | * 1. Registers R10..R31 and CR0..CR7 are saved | |
1150 | * 2. "struct savearea" must hold at least 3 pointers (long) | |
1151 | * 3. This code will only work on 32 bit machines (601..604), not 620 | |
1152 | * 4. No floating point registers are saved | |
1153 | * 5. The save stack "frame" is bigger than absolutely necessary. The | |
1154 | * PowerPC [AIX] ABI needs this extra space. | |
1155 | */ | |
1156 | ||
1157 | ||
1158 | /* Mach-O assemblers */ | |
1159 | #if !defined(NeXT) && !defined(__APPLE__) | |
1160 | #define r0 0 | |
1161 | #define r1 1 | |
1162 | #define r2 2 | |
1163 | #define r3 3 | |
1164 | #define r4 4 | |
1165 | #define r5 5 | |
1166 | #define r6 6 | |
1167 | #define r7 7 | |
1168 | #define r8 8 | |
1169 | #define r9 9 | |
1170 | #define r10 10 | |
1171 | #define r11 11 | |
1172 | #define r12 12 | |
1173 | #define r13 13 | |
1174 | #define r14 14 | |
1175 | #define r15 15 | |
1176 | #define r16 16 | |
1177 | #define r17 17 | |
1178 | #define r18 18 | |
1179 | #define r19 19 | |
1180 | #define r20 20 | |
1181 | #define r21 21 | |
1182 | #define r22 22 | |
1183 | #define r23 23 | |
1184 | #define r24 24 | |
1185 | #define r25 25 | |
1186 | #define r26 26 | |
1187 | #define r27 27 | |
1188 | #define r28 28 | |
1189 | #define r29 29 | |
1190 | #define r30 30 | |
1191 | #define r31 31 | |
1192 | #endif /* !NeXT && !__APPLE__ */ | |
1193 | ||
1194 | ||
1195 | /* | |
1196 | * savecontext(int (*f)(), struct savearea *save, char *newsp) | |
1197 | */ | |
1198 | ||
1199 | #define FRAME_SIZE (32*4)+(8*4) | |
1200 | #define FRAME_OFFSET (8*4) | |
1201 | #define TOP_OF_STACK (0*4) | |
1202 | #define RETURN (1*4) | |
1203 | #define CCR (2*4) | |
1204 | ||
1205 | #if defined(NeXT) || defined(__APPLE__) | |
1206 | .globl _savecontext | |
1207 | _savecontext: | |
1208 | lis r9,ha16(_PRE_Block) /* Disable interrupt fiddling */ | |
1209 | li r8,1 | |
1210 | stb r8,lo16(_PRE_Block)(r9) | |
1211 | #else | |
1212 | .globl savecontext | |
1213 | savecontext: | |
1214 | lis r9,PRE_Block@ha /* Disable interrupt fiddling */ | |
1215 | li r8,1 | |
1216 | stb r8,PRE_Block@l(r9) | |
1217 | #endif /* NeXT || __APPLE__ */ | |
1218 | subi r1,r1,FRAME_SIZE | |
1219 | mfcr r9 | |
1220 | stw r9,CCR(r4) | |
1221 | stw r10,10*4+FRAME_OFFSET(r1) /* Save registers */ | |
1222 | stw r11,11*4+FRAME_OFFSET(r1) | |
1223 | stw r12,12*4+FRAME_OFFSET(r1) | |
1224 | stw r13,13*4+FRAME_OFFSET(r1) | |
1225 | stw r14,14*4+FRAME_OFFSET(r1) | |
1226 | stw r15,15*4+FRAME_OFFSET(r1) | |
1227 | stw r16,16*4+FRAME_OFFSET(r1) | |
1228 | stw r17,17*4+FRAME_OFFSET(r1) | |
1229 | stw r18,18*4+FRAME_OFFSET(r1) | |
1230 | stw r19,19*4+FRAME_OFFSET(r1) | |
1231 | stw r20,20*4+FRAME_OFFSET(r1) | |
1232 | stw r21,21*4+FRAME_OFFSET(r1) | |
1233 | stw r22,22*4+FRAME_OFFSET(r1) | |
1234 | stw r23,23*4+FRAME_OFFSET(r1) | |
1235 | stw r24,24*4+FRAME_OFFSET(r1) | |
1236 | stw r25,25*4+FRAME_OFFSET(r1) | |
1237 | stw r26,26*4+FRAME_OFFSET(r1) | |
1238 | stw r27,27*4+FRAME_OFFSET(r1) | |
1239 | stw r28,28*4+FRAME_OFFSET(r1) | |
1240 | stw r29,29*4+FRAME_OFFSET(r1) | |
1241 | stw r30,30*4+FRAME_OFFSET(r1) | |
1242 | stw r31,31*4+FRAME_OFFSET(r1) | |
1243 | stw r1,TOP_OF_STACK(r4) | |
1244 | cmpi 0,r5,0 /* New stack specified? */ | |
1245 | mflr r0 | |
1246 | stw r0,RETURN(r4) | |
1247 | mtlr r3 | |
1248 | beq L1 /* No - don't muck with pointer */ | |
1249 | ||
1250 | mr r1,r5 | |
1251 | L1: blr /* Return */ | |
1252 | ||
1253 | /* | |
1254 | * returnto(struct savearea *area) | |
1255 | */ | |
1256 | #if defined(NeXT) || defined(__APPLE__) | |
1257 | .globl _returnto | |
1258 | _returnto: | |
1259 | #else | |
1260 | .globl returnto | |
1261 | returnto: | |
1262 | #endif /* NeXT || __APPLE__ */ | |
1263 | lwz r1,TOP_OF_STACK(r3) /* Update stack pointer */ | |
1264 | lwz r0,RETURN(r3) /* Get return address */ | |
1265 | mtlr r0 | |
1266 | lwz r4,CCR(r3) | |
1267 | mtcrf 0xFF,r4 | |
1268 | lwz r10,10*4+FRAME_OFFSET(r1) /* Restore registers */ | |
1269 | lwz r11,11*4+FRAME_OFFSET(r1) | |
1270 | lwz r12,12*4+FRAME_OFFSET(r1) | |
1271 | lwz r13,13*4+FRAME_OFFSET(r1) | |
1272 | lwz r14,14*4+FRAME_OFFSET(r1) | |
1273 | lwz r15,15*4+FRAME_OFFSET(r1) | |
1274 | lwz r16,16*4+FRAME_OFFSET(r1) | |
1275 | lwz r17,17*4+FRAME_OFFSET(r1) | |
1276 | lwz r18,18*4+FRAME_OFFSET(r1) | |
1277 | lwz r19,19*4+FRAME_OFFSET(r1) | |
1278 | lwz r20,20*4+FRAME_OFFSET(r1) | |
1279 | lwz r21,21*4+FRAME_OFFSET(r1) | |
1280 | lwz r22,22*4+FRAME_OFFSET(r1) | |
1281 | lwz r23,23*4+FRAME_OFFSET(r1) | |
1282 | lwz r24,24*4+FRAME_OFFSET(r1) | |
1283 | lwz r25,25*4+FRAME_OFFSET(r1) | |
1284 | lwz r26,26*4+FRAME_OFFSET(r1) | |
1285 | lwz r27,27*4+FRAME_OFFSET(r1) | |
1286 | lwz r28,28*4+FRAME_OFFSET(r1) | |
1287 | lwz r29,29*4+FRAME_OFFSET(r1) | |
1288 | lwz r30,30*4+FRAME_OFFSET(r1) | |
1289 | lwz r31,31*4+FRAME_OFFSET(r1) | |
1290 | #if defined(NeXT) || defined(__APPLE__) | |
1291 | lis r9,ha16(_PRE_Block) /* Re-enable interrupt fiddling */ | |
1292 | li r8,0 | |
1293 | stb r8,lo16(_PRE_Block)(r9) | |
1294 | #else | |
1295 | lis r9,PRE_Block@ha /* Re-enable interrupt fiddling */ | |
1296 | li r8,0 | |
1297 | stb r8,PRE_Block@l(r9) | |
1298 | #endif /* NeXT || __APPLE__ */ | |
1299 | addi r1,r1,FRAME_SIZE | |
1300 | blr | |
1301 | #endif | |
1302 | ||
1303 | #if defined(__linux__) && defined(__ELF__) | |
1304 | .section .note.GNU-stack,"",%progbits | |
1305 | #endif |