![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hw_stack.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / libC / task|
Return to hw_stack.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / libC / task |
1.1 root 1: /*ident "%W%" */
2: /**************************************************************************
3: Copyright (c) 1984 AT&T
4: All Rights Reserved
5:
6: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T
7:
8: The copyright notice above does not evidence any
9: actual or intended publication of such source code.
10:
11: *****************************************************************************/
12: #include "hw_stack.h"
13:
14: /* Machine-dependent asms and functions for task library.
15: * Porting these requires intimate knowledge of the stack frame layout,
16: * call and return sequences for the machine.
17: */
18:
19: #ifdef PROC_3B
20:
21: asm(" .text");
22: asm(" .globl SAVE_REGS");
23: asm(" .align 4");
24: asm("SAVE_REGS:");
25: asm(" save &6");
26: asm(" movw 0(%ap),%r1 "); /* ptr to HW_REGS */
27: asm(" movw -24(%fp),0(%r1) "); /* move caller's r3 to arg.r3 */
28: asm(" movw -20(%fp),4(%r1) "); /* move caller's r4 to arg.r4 */
29: asm(" movw -16(%fp),8(%r1) "); /* move caller's r5 to arg.r5 */
30: asm(" movw -12(%fp),12(%r1) "); /* move caller's r6 to arg.r6 */
31: asm(" movw -8(%fp),16(%r1) "); /* move caller's r7 to arg.r7 */
32: asm(" movw -4(%fp),20(%r1) "); /* move caller's r8 to arg.r8 */
33: asm(" ret &6");
34:
35: /* save_saved_regs copies n_saved regs saved in stack frame defined by fp
36: * to a HW_REGS structure.
37: */
38: void
39: save_saved_regs(HW_REGS *regsp, int* fp)
40: {
41: FrameLayout layout(fp);
42: register int* p = FIRST_SAVED_REG_P(fp, layout.n_saved);
43: switch(layout.n_saved) {
44: case 6:
45: regsp->r3 = *p++;
46: /* FALLTHROUGH */
47: case 5:
48: regsp->r4 = *p++;
49: /* FALLTHROUGH */
50: case 4:
51: regsp->r5 = *p++;
52: /* FALLTHROUGH */
53: case 3:
54: regsp->r6 = *p++;
55: /* FALLTHROUGH */
56: case 2:
57: regsp->r7 = *p++;
58: /* FALLTHROUGH */
59: case 1:
60: regsp->r8 = *p++;
61: /* FALLTHROUGH */
62: default:
63: break;
64: }
65: }
66:
67: /* On the 3Bs, the current ap is the caller's sp, but we want caller's sp - 1
68: * to point to last used word in stack, to correspond with sp's on 386, vax,
69: * sun
70: */
71: asm(" .text");
72: asm(" .globl TOP");
73: asm(" .align 4");
74: asm("TOP:");
75: asm(" save &0");
76: asm(" movw %ap,%r0"); /* caller's sp */
77: asm(" addw2 &4,%r0"); /* caller's sp - 1 */
78: asm(" ret &0");
79:
80: /* These assembly language functions should be replaced by new-style
81: * asms, when (if) they are implemented for C++.
82: * for example:
83: * asm void
84: * set_r3(p)
85: * {
86: * % mem p;
87: * movw *p,%r3
88: * }
89: */
90:
91: asm(" .text");
92: asm(" .globl set_r3");
93: asm(" .align 4");
94: asm("set_r3:");
95: asm(" save &0");
96: asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
97: asm(" movw 0(%r1),%r3 ");
98: asm(" ret &0");
99:
100: asm(" .text");
101: asm(" .globl set_r4");
102: asm(" .align 4");
103: asm("set_r4:");
104: asm(" save &0");
105: asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
106: asm(" movw 0(%r1),%r4 ");
107: asm(" ret &0");
108:
109: asm(" .text");
110: asm(" .globl set_r5");
111: asm(" .align 4");
112: asm("set_r5:");
113: asm(" save &0");
114: asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
115: asm(" movw 0(%r1),%r5 ");
116: asm(" ret &0");
117:
118: asm(" .text");
119: asm(" .globl set_r6");
120: asm(" .align 4");
121: asm("set_r6:");
122: asm(" save &0");
123: asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
124: asm(" movw 0(%r1),%r6 ");
125: asm(" ret &0");
126:
127: asm(" .text");
128: asm(" .globl set_r7");
129: asm(" .align 4");
130: asm("set_r7:");
131: asm(" save &0");
132: asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
133: asm(" movw 0(%r1),%r7 ");
134: asm(" ret &0");
135:
136: asm(" .text");
137: asm(" .globl set_r8");
138: asm(" .align 4");
139: asm("set_r8:");
140: asm(" save &0");
141: asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
142: asm(" movw 0(%r1),%r8 ");
143: asm(" ret &0");
144:
145: #ifdef u3b
146:
147: asm(" .text");
148: asm(" .globl AP");
149: asm(" .align 4");
150: asm("AP:");
151: asm(" save &0");
152: asm(" movw -48(%fp),%r0"); /* r0 = caller's ap */
153: asm(" ret &0");
154:
155: asm(" .text");
156: asm(" .globl FP");
157: asm(" .align 4");
158: asm("FP:");
159: asm(" save &0");
160: asm(" movw -44(%fp),%r0"); /* r0 = caller's fp */
161: asm(" ret &0");
162:
163: /* On the 3B20 the sp is restored from the current ap on a return
164: * FUDGE_SP overwrites the saved ap with a new value (the 1st arg), causing
165: * the caller's ap to be changed to the new value.
166: * As a precaution, the 1st arg of caller is copied down to where new ap
167: * will point. (In case caller references 1st arg (implicit "this" arg)
168: * to set return value.)
169: * 2nd arg unnecessary on 3B20.
170: */
171: asm(" .text");
172: asm(" .globl FUDGE_SP");
173: asm(" .align 4");
174: asm("FUDGE_SP:");
175: asm(" save &0");
176: asm(" movw -48(%fp),%r1"); /* r1 = caller's ap */
177: asm(" movw 0(%ap),%r0"); /* r0 = 1st arg (de_ap) */
178: asm(" movw 0(%r1),0(%r0)"); /* *r0 = caller's 1st arg */
179: asm(" movw 0(%ap),-48(%fp)"); /* overwrite saved ap */
180: asm(" ret &0");
181:
182: #else /* BELLMAC_CHIP */
183:
184:
185: asm(" .text");
186: asm(" .globl AP");
187: asm(" .align 4");
188: asm("AP:");
189: asm(" save &0");
190: asm(" movw -32(%fp),%r0"); /* r0 = caller's ap */
191: asm(" ret &0");
192:
193: asm(" .text");
194: asm(" .globl FP");
195: asm(" .align 4");
196: asm("FP:");
197: asm(" save &0");
198: asm(" movw -28(%fp),%r0"); /* r0 = caller's fp */
199: asm(" ret &0");
200:
201: /* On BELLMAC_CHIP machines, sp is restored from current ap on return.
202: * FUDGE_SP overwrites the saved ap with a new value (the 1st arg), causing
203: * the caller's ap to be changed to the new value.
204: * As a precaution, the 1st arg of caller is copied down to where new ap
205: * will point. (In case caller references 1st arg (implicit "this" arg)
206: * to set return value.)
207: * 2nd arg unnecessary on BELLMAC_CHIP machines.
208: */
209: asm(" .text");
210: asm(" .globl FUDGE_SP");
211: asm(" .align 4");
212: asm("FUDGE_SP:");
213: asm(" save &0");
214: asm(" movw -32(%fp),%r1"); /* r1 = caller's ap */
215: asm(" movw 0(%ap),%r0"); /* r0 = 1st arg (de_ap) */
216: asm(" movw 0(%r1),0(%r0)"); /* *r0 = caller's 1st arg */
217: asm(" movw 0(%ap),-32(%fp)"); /* overwrite saved ap */
218: asm(" ret &0");
219: #endif /* BELLMAC_CHIP */
220: #endif /* PROC_3B */
221:
222:
223: #ifdef vax
224: /* save all caller regs in HW_REGS structure */
225: asm(" .globl _SAVE_REGS");
226: asm(" .align 1");
227: asm("_SAVE_REGS:");
228: asm(" .word 0xfc0 "); /* entry mask; save all user regs (r11-r6) */
229: asm(" movl 4(ap),r1 "); /* ptr to HW_REGS */
230: asm(" movl 20(fp),0(r1) "); /* move caller's r6 to arg.r6 */
231: asm(" movl 24(fp),4(r1) "); /* move caller's r7 to arg.r7 */
232: asm(" movl 28(fp),8(r1) "); /* move caller's r8 to arg.r8 */
233: asm(" movl 32(fp),12(r1) "); /* move caller's r9 to arg.r9 */
234: asm(" movl 36(fp),16(r1) "); /* move caller's r10 to arg.r10 */
235: asm(" movl 40(fp),20(r1) "); /* move caller's r11 to arg.r11 */
236: asm(" ret");
237:
238: asm(" .globl _FP");
239: asm(" .align 1");
240: asm("_FP:");
241: asm(" .word 0x0000"); /* entry mask; save no regs */
242: asm(" movl 12(fp),r0"); /* r0 = caller's fp */
243: asm(" ret");
244:
245: /* On the vax, when there are no args, the current ap is the caller's sp */
246: asm(" .globl _TOP");
247: asm(" .align 1");
248: asm("_TOP:");
249: asm(" .word 0x0000"); /* entry mask; save no regs */
250: asm(" movl ap,r0"); /* r0 = caller's sp */
251: asm(" ret");
252: /* More general (independent of #args) would be: addl3 $1,(ap),r0 # r0=nargs + 1
253: * ashl $2,r0,r0 # r0 = nargs * 4 (scale to bytes) addl2 ap,r0 #caller's sp
254: */
255:
256: asm(" .globl _set_r6");
257: asm(" .align 1");
258: asm("_set_r6:");
259: asm(" .word 0x0 "); /* save no regs */
260: asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
261: asm(" movl (r1),r6 ");
262: asm(" ret");
263:
264: asm(" .globl _set_r7");
265: asm(" .align 1");
266: asm("_set_r7:");
267: asm(" .word 0x0 "); /* save no regs */
268: asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
269: asm(" movl (r1),r7 ");
270: asm(" ret");
271:
272: asm(" .globl _set_r8");
273: asm(" .align 1");
274: asm("_set_r8:");
275: asm(" .word 0x0 "); /* save no regs */
276: asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
277: asm(" movl (r1),r8 ");
278: asm(" ret");
279:
280: asm(" .globl _set_r9");
281: asm(" .align 1");
282: asm("_set_r9:");
283: asm(" .word 0x0 "); /* save no regs */
284: asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
285: asm(" movl (r1),r9 ");
286: asm(" ret");
287:
288: asm(" .globl _set_r10");
289: asm(" .align 1");
290: asm("_set_r10:");
291: asm(" .word 0x0 "); /* save no regs */
292: asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
293: asm(" movl (r1),r10 ");
294: asm(" ret");
295:
296: asm(" .globl _set_r11");
297: asm(" .align 1");
298: asm("_set_r11:");
299: asm(" .word 0x0 "); /* save no regs */
300: asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
301: asm(" movl (r1),r11 ");
302: asm(" ret");
303:
304: #endif
305:
306: #ifdef mc68000 /* Really, ifdef sun--stack frame layout
307: * is different on a UNIX PC, for example
308: */
309: asm(" .text");
310: asm(" .globl _SAVE_REGS");
311: asm("_SAVE_REGS:");
312: asm(" link a6,#-40");
313: asm(" moveml #0x3cfc,sp@"); /* save d2-d7, a2-a5 */
314: asm(" movl a6@(8),a0"); /* a0 = arg--ptr to HW_REGS */
315: asm(" movl a6@(-40),a0@"); /* move caller's d2 to arg.d2 */
316: asm(" movl a6@(-36),a0@(4)"); /* move caller's d3 to arg.d3 */
317: asm(" movl a6@(-32),a0@(8)"); /* move caller's d4 to arg.d4 */
318: asm(" movl a6@(-28),a0@(12)"); /* move caller's d5 to arg.d5 */
319: asm(" movl a6@(-24),a0@(16)"); /* move caller's d6 to arg.d6 */
320: asm(" movl a6@(-20),a0@(20)"); /* move caller's d7 to arg.d7 */
321: asm(" movl a6@(-16),a0@(32)"); /* move caller's a2 to arg.a2 */
322: asm(" movl a6@(-12),a0@(36)"); /* move caller's a3 to arg.a3 */
323: asm(" movl a6@(-8),a0@(40)"); /* move caller's a4 to arg.a4 */
324: asm(" movl a6@(-4),a0@(44)"); /* move caller's a5 to arg.a5 */
325: asm(" moveml a6@(-40),#0x3cfc"); /* restore d2-d7, a2-a5 */
326: asm(" unlk a6");
327: asm(" rts");
328:
329: /* save_saved_regs copies regs saved in stack frame defined by fp
330: * to a HW_REGS structure. Uses FrameLayout() to find which regs are saved.
331: */
332: void
333: save_saved_regs(HW_REGS *regsp, int* fp)
334: {
335: FrameLayout layout(fp);
336: register int* p = FIRST_SAVED_REG_P(fp,layout.offset);
337: register int* rp = (int*)regsp;
338:
339: register unsigned short mask = layout.mask;
340: // start with d2, end with a5
341: for (register int m = 0x4; m != 0x2000; m <<=1) {
342: if (m & mask) {
343: *rp++ = *p++;
344: } else {
345: rp++;
346: }
347: }
348: }
349:
350: /* On the 68k, without a link inst, fp (a6) doesn't move on a call */
351: asm(" .text");
352: asm(" .globl _FP");
353: asm("_FP:");
354: asm(" lea a6@,a0");
355: asm(" movl a0,d0"); /* for compilers that return everything in d0*/
356: asm(" rts");
357:
358: /* On the 68k, a call (via jsr or bsr) pushes the pc on the stack;
359: the caller's sp is the current sp + 1 */
360: asm(" .text");
361: asm(" .globl _TOP");
362: asm("_TOP:");
363: asm(" lea sp@(4),a0");
364: asm(" movl a0,d0"); /* for compilers that return everything in d0*/
365: asm(" rts");
366:
367: /* On the 68k, immediately before the rts, the sp is pointing at the
368: * return pc on the stack. The rts pops the pc off the stack.
369: * To reset the sp correctly after fudging the stack, we'll save the
370: * pointer to "skip's" return-pc in Skip_pc_p, and fudge_return() will
371: * overwrite task::task's return pc with the address of fudge_sp,
372: * a function that will reset the sp to Skip_pc_p, and then do the rts.
373: * Ugly, but it should work.
374: */
375: // NOTE: The following definition of Skip_pc_p appears in fudge.c.68k,
376: // because of an apparent bug in the Sun-3 compiler. It seems to get
377: // confused by intermingling of definitions and asms.
378: // int* Skip_pc_p; // global to hold fudged return pc.
379: // Set in FUDGE_SP, used by fudge_sp a few instructions
380: // later. Be careful not to add intervening insts.
381: //Note: 1st arg unnecessary on Sun-2/3
382: void
383: FUDGE_SP(int*, int* de_fp)
384: {
385: Skip_pc_p = OLD_PC_P(de_fp);
386: }
387:
388: asm(" .text");
389: asm(" .globl _fudge_sp");
390: asm("_fudge_sp:");
391: asm(" movl _Skip_pc_p,a7");
392: asm(" rts");
393:
394: asm(" .text");
395: asm(" .globl _set_d2");
396: asm("_set_d2:");
397: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
398: asm(" movl a0@,d2");
399: asm(" rts");
400:
401: asm(" .text");
402: asm(" .globl _set_d3");
403: asm("_set_d3:");
404: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
405: asm(" movl a0@,d3");
406: asm(" rts");
407:
408: asm(" .text");
409: asm(" .globl _set_d4");
410: asm("_set_d4:");
411: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
412: asm(" movl a0@,d4");
413: asm(" rts");
414:
415: asm(" .text");
416: asm(" .globl _set_d5");
417: asm("_set_d5:");
418: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
419: asm(" movl a0@,d5");
420: asm(" rts");
421:
422: asm(" .text");
423: asm(" .globl _set_d6");
424: asm("_set_d6:");
425: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
426: asm(" movl a0@,d6");
427: asm(" rts");
428:
429: asm(" .text");
430: asm(" .globl _set_d7");
431: asm("_set_d7:");
432: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
433: asm(" movl a0@,d7");
434: asm(" rts");
435:
436: asm(" .text");
437: asm(" .globl _set_a2");
438: asm("_set_a2:");
439: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
440: asm(" movl a0@,a2");
441: asm(" rts");
442:
443: asm(" .text");
444: asm(" .globl _set_a3");
445: asm("_set_a3:");
446: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
447: asm(" movl a0@,a3");
448: asm(" rts");
449:
450: asm(" .text");
451: asm(" .globl _set_a4");
452: asm("_set_a4:");
453: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
454: asm(" movl a0@,a4");
455: asm(" rts");
456:
457: asm(" .text");
458: asm(" .globl _set_a5");
459: asm("_set_a5:");
460: asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
461: asm(" movl a0@,a5");
462: asm(" rts");
463:
464: #endif /* mc68000 */
465:
466: #ifdef i386
467:
468: asm(" .text");
469: asm(" .globl SAVE_REGS");
470: asm("SAVE_REGS:");
471: asm(" pushl %ebp"); /* save caller's fp */
472: asm(" movl %esp,%ebp"); /* fp = sp */
473: asm(" pushl %edi"); /* save edi */
474: asm(" pushl %esi"); /* save esi */
475: asm(" pushl %ebx"); /* save ebx */
476: asm(" movl 8(%ebp),%eax"); /* eax = arg--ptr to HW_REGS */
477: asm(" movl -4(%ebp),%ecx"); /* ecx = caller's edi */
478: asm(" movl %ecx,0(%eax)"); /* arg.edi = ecx */
479: asm(" movl -8(%ebp),%ecx"); /* ecx = caller's esi */
480: asm(" movl %ecx,4(%eax)"); /* arg.esi = ecx */
481: asm(" movl -12(%ebp),%ecx"); /* ecx = caller's ebx */
482: asm(" movl %ecx,8(%eax)"); /* arg.ebx = ecx */
483: asm(" popl %ebx");
484: asm(" popl %esi");
485: asm(" popl %edi");
486: asm(" leave");
487: asm(" ret");
488:
489: /* save_saved_regs copies regs saved in stack frame defined by fp
490: * to a HW_REGS structure. Uses FrameLayout() to find which regs are saved.
491: */
492: void
493: save_saved_regs(HW_REGS *regsp, int* fp)
494: {
495: FrameLayout layout(fp);
496: register int* p = FIRST_SAVED_REG_P(fp,layout.offset);
497: register int* rp = (int*)regsp;
498:
499: register unsigned short mask = layout.mask;
500: for (register short m = 1; m != 0x08; m <<=1) {
501: if (m & mask) {
502: *rp++ = *p--;
503: } else {
504: rp++;
505: }
506: }
507: }
508:
509: /* On the i386, without a specific inst, fp (ebp) doesn't move on a call */
510: asm(".text");
511: asm(".globl FP");
512: asm("FP:");
513: asm(" movl %ebp,%eax");
514: asm(" ret");
515:
516: /* On the i386, a call pushes the pc on the stack;
517: the caller's sp is the current sp + 1 */
518: asm(".text");
519: asm(".globl TOP");
520: asm("TOP:");
521: asm(" leal 4(%esp),%eax");
522: asm(" ret");
523:
524:
525: /* On the i386, immediately before the ret, the sp is pointing at the
526: * return pc on the stack. The ret pops the pc off the stack.
527: * To reset the sp correctly after fudging the stack, we'll save the
528: * pointer to "skip's" return-pc in Skip_pc_p, and fudge_return() will
529: * overwrite task::task's return pc with the address of fudge_sp,
530: * a function that will reset the sp to Skip_pc_p, and then do the ret.
531: * Ugly, but it should work.
532: */
533: // NOTE: The following definition of Skip_pc_p appears in fudge.c.386,
534: // because of an apparent bug in the Sun-3 compiler. It seems to get
535: // confused by intermingling of definitions and asms.
536: // int* Skip_pc_p; // global to hold fudged return pc.
537: // Set in FUDGE_SP, used by fudge_sp a few instructions
538: // later. Be careful not to add intervening insts.
539: //Note: 1st arg unnecessary on i386
540: void
541: FUDGE_SP(int*, int* de_fp)
542: {
543: Skip_pc_p = OLD_PC_P(de_fp);
544: }
545:
546: asm(" .text");
547: asm(" .globl fudge_sp");
548: asm("fudge_sp:");
549: asm(" movl Skip_pc_p,%esp");
550: asm(" ret");
551:
552: asm(".text");
553: asm(".globl set_edi");
554: asm("set_edi:");
555: asm(" movl 4(%esp),%eax");
556: asm(" movl 0(%eax),%edi");
557: asm(" ret");
558:
559: asm(".text");
560: asm(".globl set_esi");
561: asm("set_esi:");
562: asm(" movl 4(%esp),%eax");
563: asm(" movl 0(%eax),%esi");
564: asm(" ret");
565:
566: asm(".text");
567: asm(".globl set_ebx");
568: asm("set_ebx:");
569: asm(" movl 4(%esp),%eax");
570: asm(" movl 0(%eax),%ebx");
571: asm(" ret");
572:
573: #endif /* i386 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.