/*ident "@(#)cls4:lib/task/task/hw_stack.c 1.4" */
/*******************************************************************************
C++ source for the C++ Language System, Release 3.0. This product
is a new release of the original cfront developed in the computer
science research center of AT&T Bell Laboratories.
Copyright (c) 1993 UNIX System Laboratories, Inc.
Copyright (c) 1991, 1992 AT&T and UNIX System Laboratories, Inc.
Copyright (c) 1984, 1989, 1990 AT&T. All Rights Reserved.
THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE of AT&T and UNIX System
Laboratories, Inc. The copyright notice above does not evidence
any actual or intended publication of such source code.
*******************************************************************************/
#include "hw_stack.h"
/* Machine-dependent asms and functions for task library.
* Porting these requires intimate knowledge of the stack frame layout,
* call and return sequences for the machine.
*/
#ifdef PROC_3B
asm(" .text");
asm(" .globl SAVE_REGS");
asm(" .align 4");
asm("SAVE_REGS:");
asm(" save &6");
asm(" movw 0(%ap),%r1 "); /* ptr to HW_REGS */
asm(" movw -24(%fp),0(%r1) "); /* move caller's r3 to arg.r3 */
asm(" movw -20(%fp),4(%r1) "); /* move caller's r4 to arg.r4 */
asm(" movw -16(%fp),8(%r1) "); /* move caller's r5 to arg.r5 */
asm(" movw -12(%fp),12(%r1) "); /* move caller's r6 to arg.r6 */
asm(" movw -8(%fp),16(%r1) "); /* move caller's r7 to arg.r7 */
asm(" movw -4(%fp),20(%r1) "); /* move caller's r8 to arg.r8 */
asm(" ret &6");
/* save_saved_regs copies n_saved regs saved in stack frame defined by fp
* to a HW_REGS structure.
*/
void
save_saved_regs(HW_REGS *regsp, int* fp)
{
FrameLayout layout(fp);
register int* p = FIRST_SAVED_REG_P(fp, layout.n_saved);
switch(layout.n_saved) {
case 6:
regsp->r3 = *p++;
/* FALLTHROUGH */
case 5:
regsp->r4 = *p++;
/* FALLTHROUGH */
case 4:
regsp->r5 = *p++;
/* FALLTHROUGH */
case 3:
regsp->r6 = *p++;
/* FALLTHROUGH */
case 2:
regsp->r7 = *p++;
/* FALLTHROUGH */
case 1:
regsp->r8 = *p++;
/* FALLTHROUGH */
default:
break;
}
}
/* On the 3Bs, the current ap is the caller's sp, but we want caller's sp - 1
* to point to last used word in stack, to correspond with sp's on 386, vax,
* sun
*/
asm(" .text");
asm(" .globl TOP");
asm(" .align 4");
asm("TOP:");
asm(" save &0");
asm(" movw %ap,%r0"); /* caller's sp */
asm(" addw2 &4,%r0"); /* caller's sp - 1 */
asm(" ret &0");
/* These assembly language functions should be replaced by new-style
* asms, when (if) they are implemented for C++.
* for example:
* asm void
* set_r3(p)
* {
* % mem p;
* movw *p,%r3
* }
*/
asm(" .text");
asm(" .globl set_r3");
asm(" .align 4");
asm("set_r3:");
asm(" save &0");
asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
asm(" movw 0(%r1),%r3 ");
asm(" ret &0");
asm(" .text");
asm(" .globl set_r4");
asm(" .align 4");
asm("set_r4:");
asm(" save &0");
asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
asm(" movw 0(%r1),%r4 ");
asm(" ret &0");
asm(" .text");
asm(" .globl set_r5");
asm(" .align 4");
asm("set_r5:");
asm(" save &0");
asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
asm(" movw 0(%r1),%r5 ");
asm(" ret &0");
asm(" .text");
asm(" .globl set_r6");
asm(" .align 4");
asm("set_r6:");
asm(" save &0");
asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
asm(" movw 0(%r1),%r6 ");
asm(" ret &0");
asm(" .text");
asm(" .globl set_r7");
asm(" .align 4");
asm("set_r7:");
asm(" save &0");
asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
asm(" movw 0(%r1),%r7 ");
asm(" ret &0");
asm(" .text");
asm(" .globl set_r8");
asm(" .align 4");
asm("set_r8:");
asm(" save &0");
asm(" movw 0(%ap),%r1 "); /* ptr to register saved in stack */
asm(" movw 0(%r1),%r8 ");
asm(" ret &0");
#ifdef u3b
asm(" .text");
asm(" .globl AP");
asm(" .align 4");
asm("AP:");
asm(" save &0");
asm(" movw -48(%fp),%r0"); /* r0 = caller's ap */
asm(" ret &0");
asm(" .text");
asm(" .globl FP");
asm(" .align 4");
asm("FP:");
asm(" save &0");
asm(" movw -44(%fp),%r0"); /* r0 = caller's fp */
asm(" ret &0");
/* On the 3B20 the sp is restored from the current ap on a return
* FUDGE_SP overwrites the saved ap with a new value (the 1st arg), causing
* the caller's ap to be changed to the new value.
* As a precaution, the 1st arg of caller is copied down to where new ap
* will point. (In case caller references 1st arg (implicit "this" arg)
* to set return value.)
* 2nd arg unnecessary on 3B20.
*/
asm(" .text");
asm(" .globl FUDGE_SP");
asm(" .align 4");
asm("FUDGE_SP:");
asm(" save &0");
asm(" movw -48(%fp),%r1"); /* r1 = caller's ap */
asm(" movw 0(%ap),%r0"); /* r0 = 1st arg (de_ap) */
asm(" movw 0(%r1),0(%r0)"); /* *r0 = caller's 1st arg */
asm(" movw 0(%ap),-48(%fp)"); /* overwrite saved ap */
asm(" ret &0");
#else /* BELLMAC_CHIP */
asm(" .text");
asm(" .globl AP");
asm(" .align 4");
asm("AP:");
asm(" save &0");
asm(" movw -32(%fp),%r0"); /* r0 = caller's ap */
asm(" ret &0");
asm(" .text");
asm(" .globl FP");
asm(" .align 4");
asm("FP:");
asm(" save &0");
asm(" movw -28(%fp),%r0"); /* r0 = caller's fp */
asm(" ret &0");
/* On BELLMAC_CHIP machines, sp is restored from current ap on return.
* FUDGE_SP overwrites the saved ap with a new value (the 1st arg), causing
* the caller's ap to be changed to the new value.
* As a precaution, the 1st arg of caller is copied down to where new ap
* will point. (In case caller references 1st arg (implicit "this" arg)
* to set return value.)
* 2nd arg unnecessary on BELLMAC_CHIP machines.
*/
asm(" .text");
asm(" .globl FUDGE_SP");
asm(" .align 4");
asm("FUDGE_SP:");
asm(" save &0");
asm(" movw -32(%fp),%r1"); /* r1 = caller's ap */
asm(" movw 0(%ap),%r0"); /* r0 = 1st arg (de_ap) */
asm(" movw 0(%r1),0(%r0)"); /* *r0 = caller's 1st arg */
asm(" movw 0(%ap),-32(%fp)"); /* overwrite saved ap */
asm(" ret &0");
#endif /* BELLMAC_CHIP */
#endif /* PROC_3B */
#ifdef vax
/* save all caller regs in HW_REGS structure */
asm(" .globl _SAVE_REGS");
asm(" .align 1");
asm("_SAVE_REGS:");
asm(" .word 0xfc0 "); /* entry mask; save all user regs (r11-r6) */
asm(" movl 4(ap),r1 "); /* ptr to HW_REGS */
asm(" movl 20(fp),0(r1) "); /* move caller's r6 to arg.r6 */
asm(" movl 24(fp),4(r1) "); /* move caller's r7 to arg.r7 */
asm(" movl 28(fp),8(r1) "); /* move caller's r8 to arg.r8 */
asm(" movl 32(fp),12(r1) "); /* move caller's r9 to arg.r9 */
asm(" movl 36(fp),16(r1) "); /* move caller's r10 to arg.r10 */
asm(" movl 40(fp),20(r1) "); /* move caller's r11 to arg.r11 */
asm(" ret");
asm(" .globl _FP");
asm(" .align 1");
asm("_FP:");
asm(" .word 0x0000"); /* entry mask; save no regs */
asm(" movl 12(fp),r0"); /* r0 = caller's fp */
asm(" ret");
/* On the vax, when there are no args, the current ap is the caller's sp */
asm(" .globl _TOP");
asm(" .align 1");
asm("_TOP:");
asm(" .word 0x0000"); /* entry mask; save no regs */
asm(" movl ap,r0"); /* r0 = caller's sp */
asm(" ret");
/* More general (independent of #args) would be: addl3 $1,(ap),r0 # r0=nargs + 1
* ashl $2,r0,r0 # r0 = nargs * 4 (scale to bytes) addl2 ap,r0 #caller's sp
*/
asm(" .globl _set_r6");
asm(" .align 1");
asm("_set_r6:");
asm(" .word 0x0 "); /* save no regs */
asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
asm(" movl (r1),r6 ");
asm(" ret");
asm(" .globl _set_r7");
asm(" .align 1");
asm("_set_r7:");
asm(" .word 0x0 "); /* save no regs */
asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
asm(" movl (r1),r7 ");
asm(" ret");
asm(" .globl _set_r8");
asm(" .align 1");
asm("_set_r8:");
asm(" .word 0x0 "); /* save no regs */
asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
asm(" movl (r1),r8 ");
asm(" ret");
asm(" .globl _set_r9");
asm(" .align 1");
asm("_set_r9:");
asm(" .word 0x0 "); /* save no regs */
asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
asm(" movl (r1),r9 ");
asm(" ret");
asm(" .globl _set_r10");
asm(" .align 1");
asm("_set_r10:");
asm(" .word 0x0 "); /* save no regs */
asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
asm(" movl (r1),r10 ");
asm(" ret");
asm(" .globl _set_r11");
asm(" .align 1");
asm("_set_r11:");
asm(" .word 0x0 "); /* save no regs */
asm(" movl 4(ap),r1 "); /* ptr to register saved in stack */
asm(" movl (r1),r11 ");
asm(" ret");
#endif
#ifdef mc68000 /* Really, ifdef sun--stack frame layout
* is different on a UNIX PC, for example
*/
asm(" .text");
asm(" .globl _SAVE_REGS");
asm("_SAVE_REGS:");
asm(" link a6,#-40");
asm(" moveml #0x3cfc,sp@"); /* save d2-d7, a2-a5 */
asm(" movl a6@(8),a0"); /* a0 = arg--ptr to HW_REGS */
asm(" movl a6@(-40),a0@"); /* move caller's d2 to arg.d2 */
asm(" movl a6@(-36),a0@(4)"); /* move caller's d3 to arg.d3 */
asm(" movl a6@(-32),a0@(8)"); /* move caller's d4 to arg.d4 */
asm(" movl a6@(-28),a0@(12)"); /* move caller's d5 to arg.d5 */
asm(" movl a6@(-24),a0@(16)"); /* move caller's d6 to arg.d6 */
asm(" movl a6@(-20),a0@(20)"); /* move caller's d7 to arg.d7 */
asm(" movl a6@(-16),a0@(32)"); /* move caller's a2 to arg.a2 */
asm(" movl a6@(-12),a0@(36)"); /* move caller's a3 to arg.a3 */
asm(" movl a6@(-8),a0@(40)"); /* move caller's a4 to arg.a4 */
asm(" movl a6@(-4),a0@(44)"); /* move caller's a5 to arg.a5 */
asm(" moveml a6@(-40),#0x3cfc"); /* restore d2-d7, a2-a5 */
asm(" unlk a6");
asm(" rts");
/* save_saved_regs copies regs saved in stack frame defined by fp
* to a HW_REGS structure. Uses FrameLayout() to find which regs are saved.
*/
void
save_saved_regs(HW_REGS *regsp, int* fp)
{
FrameLayout layout(fp);
register int* p = FIRST_SAVED_REG_P(fp,layout.offset);
register int* rp = (int*)regsp;
register unsigned short mask = layout.mask;
// start with d2, end with a5
for (register int m = 0x4; m != 0x2000; m <<=1) {
if (m & mask) {
*rp++ = *p++;
} else {
rp++;
}
}
}
/* On the 68k, without a link inst, fp (a6) doesn't move on a call */
asm(" .text");
asm(" .globl _FP");
asm("_FP:");
asm(" lea a6@,a0");
asm(" movl a0,d0"); /* for compilers that return everything in d0*/
asm(" rts");
/* On the 68k, a call (via jsr or bsr) pushes the pc on the stack;
the caller's sp is the current sp + 1 */
asm(" .text");
asm(" .globl _TOP");
asm("_TOP:");
asm(" lea sp@(4),a0");
asm(" movl a0,d0"); /* for compilers that return everything in d0*/
asm(" rts");
/* On the 68k, immediately before the rts, the sp is pointing at the
* return pc on the stack. The rts pops the pc off the stack.
* To reset the sp correctly after fudging the stack, we'll save the
* pointer to "skip's" return-pc in Skip_pc_p, and fudge_return() will
* overwrite task::task's return pc with the address of fudge_sp,
* a function that will reset the sp to Skip_pc_p, and then do the rts.
* Ugly, but it should work.
*/
// NOTE: The following definition of Skip_pc_p appears in fudge.c.68k,
// because of an apparent bug in the Sun-3 compiler. It seems to get
// confused by intermingling of definitions and asms.
// int* Skip_pc_p; // global to hold fudged return pc.
// Set in FUDGE_SP, used by fudge_sp a few instructions
// later. Be careful not to add intervening insts.
//Note: 1st arg unnecessary on Sun-2/3
void
FUDGE_SP(int*, int* de_fp)
{
Skip_pc_p = OLD_PC_P(de_fp);
}
asm(" .text");
asm(" .globl _fudge_sp");
asm("_fudge_sp:");
asm(" movl _Skip_pc_p,a7");
asm(" rts");
asm(" .text");
asm(" .globl _set_d2");
asm("_set_d2:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,d2");
asm(" rts");
asm(" .text");
asm(" .globl _set_d3");
asm("_set_d3:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,d3");
asm(" rts");
asm(" .text");
asm(" .globl _set_d4");
asm("_set_d4:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,d4");
asm(" rts");
asm(" .text");
asm(" .globl _set_d5");
asm("_set_d5:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,d5");
asm(" rts");
asm(" .text");
asm(" .globl _set_d6");
asm("_set_d6:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,d6");
asm(" rts");
asm(" .text");
asm(" .globl _set_d7");
asm("_set_d7:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,d7");
asm(" rts");
asm(" .text");
asm(" .globl _set_a2");
asm("_set_a2:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,a2");
asm(" rts");
asm(" .text");
asm(" .globl _set_a3");
asm("_set_a3:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,a3");
asm(" rts");
asm(" .text");
asm(" .globl _set_a4");
asm("_set_a4:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,a4");
asm(" rts");
asm(" .text");
asm(" .globl _set_a5");
asm("_set_a5:");
asm(" movl sp@(4),a0"); /* arg is ptr to register saved in stack */
asm(" movl a0@,a5");
asm(" rts");
#endif /* mc68000 */
#ifdef i386
asm(" .text");
asm(" .globl SAVE_REGS");
asm("SAVE_REGS:");
asm(" pushl %ebp"); /* save caller's fp */
asm(" movl %esp,%ebp"); /* fp = sp */
asm(" pushl %edi"); /* save edi */
asm(" pushl %esi"); /* save esi */
asm(" pushl %ebx"); /* save ebx */
asm(" movl 8(%ebp),%eax"); /* eax = arg--ptr to HW_REGS */
asm(" movl -4(%ebp),%ecx"); /* ecx = caller's edi */
asm(" movl %ecx,0(%eax)"); /* arg.edi = ecx */
asm(" movl -8(%ebp),%ecx"); /* ecx = caller's esi */
asm(" movl %ecx,4(%eax)"); /* arg.esi = ecx */
asm(" movl -12(%ebp),%ecx"); /* ecx = caller's ebx */
asm(" movl %ecx,8(%eax)"); /* arg.ebx = ecx */
asm(" popl %ebx");
asm(" popl %esi");
asm(" popl %edi");
asm(" leave");
asm(" ret");
/* save_saved_regs copies regs saved in stack frame defined by fp
* to a HW_REGS structure. Uses FrameLayout() to find which regs are saved.
*/
void
save_saved_regs(HW_REGS *regsp, int* fp)
{
FrameLayout layout(fp);
register int* p = FIRST_SAVED_REG_P(fp,layout.offset);
register int* rp = (int*)regsp;
register unsigned short mask = layout.mask;
for (register short m = 1; m != 0x08; m <<=1) {
if (m & mask) {
*rp++ = *p--;
} else {
rp++;
}
}
}
/* On the i386, without a specific inst, fp (ebp) doesn't move on a call */
asm(".text");
asm(".globl FP");
asm("FP:");
asm(" movl %ebp,%eax");
asm(" ret");
/* On the i386, a call pushes the pc on the stack;
the caller's sp is the current sp + 1 */
asm(".text");
asm(".globl TOP");
asm("TOP:");
asm(" leal 4(%esp),%eax");
asm(" ret");
/* On the i386, immediately before the ret, the sp is pointing at the
* return pc on the stack. The ret pops the pc off the stack.
* To reset the sp correctly after fudging the stack, we'll save the
* pointer to "skip's" return-pc in Skip_pc_p, and fudge_return() will
* overwrite task::task's return pc with the address of fudge_sp,
* a function that will reset the sp to Skip_pc_p, and then do the ret.
* Ugly, but it should work.
*/
// NOTE: The following definition of Skip_pc_p appears in fudge.c.386,
// because of an apparent bug in the Sun-3 compiler. It seems to get
// confused by intermingling of definitions and asms.
// int* Skip_pc_p; // global to hold fudged return pc.
// Set in FUDGE_SP, used by fudge_sp a few instructions
// later. Be careful not to add intervening insts.
//Note: 1st arg unnecessary on i386
void
FUDGE_SP(int*, int* de_fp)
{
Skip_pc_p = OLD_PC_P(de_fp);
}
asm(" .text");
asm(" .globl fudge_sp");
asm("fudge_sp:");
asm(" movl Skip_pc_p,%esp");
asm(" ret");
asm(".text");
asm(".globl set_edi");
asm("set_edi:");
asm(" movl 4(%esp),%eax");
asm(" movl 0(%eax),%edi");
asm(" ret");
asm(".text");
asm(".globl set_esi");
asm("set_esi:");
asm(" movl 4(%esp),%eax");
asm(" movl 0(%eax),%esi");
asm(" ret");
asm(".text");
asm(".globl set_ebx");
asm("set_ebx:");
asm(" movl 4(%esp),%eax");
asm(" movl 0(%eax),%ebx");
asm(" ret");
#endif /* i386 */
#ifdef uts
/*
* FP() and AP() return the frame/arg pointer of the caller. In both
* cases, this is the old value of r12.
*
* uts allows asm only inside functions.
* Ordinarily we could simply load r0 and return, but because we're
* in a C function, we have to make the compiler happy. A value is
* returned through a redundant auto, which is assigned a dummy value
* to make the compiler shut up about "used but not set."
* (Assignment is used instead of initialization, due to a cfront quirk
* which will delay initialization until right before use, overwriting
* the asm work with 0).
*
*/
extern "C" {
int *
FP()
{
int *fp;
fp = 0;
/*
* return the saved r12
*/
asm(" l 0, 48(12)");
asm(" st 0, -4+$FP_len(13)");
return fp;
}
int *
AP()
{
int *ap;
ap = 0;
/*
* return the saved r12
*/
asm(" l 0, 48(12)");
asm(" st 0, -4+$AP_len(13)");
return ap;
}
int *
TOP()
{
int *sp;
sp = 0;
/*
* return the saved r13
*/
asm(" l 0, 52(12)");
asm(" st 0, -4+$TOP_len(13)");
return sp;
}
void
set_r2(int*)
{
asm(" l 2, 64(12)"); // get loc
asm(" l 2, 0(2)"); // load r2 with contents
asm(" st 2, 8(12)"); // overwrite save area
};
void
set_r3(int*)
{
asm(" l 3, 64(12)");
asm(" l 3, 0(3)");
asm(" st 3, 12(12)");
}
void
set_r4(int*)
{
asm(" l 4, 64(12)");
asm(" l 4, 0(4)");
asm(" st 4, 16(12)");
}
void
set_r5(int*)
{
asm(" l 5, 64(12)");
asm(" l 5, 0(5)");
asm(" st 5, 20(12)");
}
void
set_r6(int*)
{
asm(" l 6, 64(12)");
asm(" l 6, 0(6)");
asm(" st 6, 24(12)");
}
void
set_r7(int*)
{
asm(" l 7, 64(12)");
asm(" l 7, 0(7)");
asm(" st 7, 28(12)");
};
void
set_r8(int*)
{
asm(" l 8, 64(12)");
asm(" l 8, 0(8)");
asm(" st 8, 32(12)");
}
void
set_r9(int*)
{
asm(" l 9, 64(12)");
asm(" l 9, 0(9)");
asm(" st 9, 36(12)");
}
void
set_r10(int*)
{
asm(" l 10, 64(12)");
asm(" l 10, 0(10)");
asm(" st 10, 40(12)");
}
};
/*
* saved_saved_regs copies regs saved in stack frame defined by fp
* to a HW_REGS structure. Uses FrameLayout() to find which regs are saved.
*/
void
save_saved_regs(HW_REGS *regsp, int* fp)
{
FrameLayout layout(fp);
register int* p = FIRST_SAVED_REG_P(fp);
register int* rp = (int*)regsp;
register int r;
for (r = 0; r < 16; r++, rp++, p++) {
if (layout.begreg <= r && r <= layout.endreg) {
*rp = *p;
}
}
}
#endif
|
