![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fudge.c.3b CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / libC / otask|
Return to fudge.c.3b CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / libC / otask |
1.1 ! root 1: #include "task.h" ! 2: #include <assert.h> ! 3: #include <stdio.h> ! 4: ! 5: // 3B frame fudger ! 6: ! 7: //Frames not self-describing! ! 8: //STACK GROWS UP ! 9: ! 10: typedef unsigned char MACHINE_BYTE; ! 11: ! 12: #ifdef u3b ! 13: ! 14: #define OLD_FP(fp) ( *( (int*)(fp) - 11 ) ) ! 15: #define OLD_AP(fp) ( *( (int*)(fp) - 12 ) ) ! 16: #define OLD_PC(fp) ( *( (int*)(fp) - 13 ) ) ! 17: #define FIRST_SAVED_REG_P(fp) ( (int*)(fp) - 6 ) ! 18: ! 19: const CALL_OPCODE = ((MACHINE_BYTE)0x78); ! 20: /* SAK: really: 0x78 | 0x79 | 0xB9 | 0x77 */ ! 21: const SAVE_OPCODE = ((MACHINE_BYTE)0x7A); ! 22: const BYTE_DISPL = 0xC0; /* SAK: WRONG for u3b! */ ! 23: const HALFWORD_DISPL = 0xA0; /* SAK: WRONG for u3b! */ ! 24: const WORD_DISPL = 0x80; /* SAK: WRONG for u3b! */ ! 25: const ABSOLUTE = 0x70; /* SAK: WRONG for u3b! */ ! 26: ! 27: const N_CALL_INSTR_SIZES = 6; /* SAK: WRONG for u3b! */ ! 28: short call_size[N_CALL_INSTR_SIZES] = {5, 6, 7, 8, 9, 11}; /* SAK: WRONG for u3b! */ ! 29: ! 30: /* SAK: SAVE_OPERAND(instr) not needed for u3b */ ! 31: ! 32: /* Given a pointer to a save instruction, yield the number of registers saved */ ! 33: #define N_SAVED_REGS(instr) (((char *)(instr))[1] >> 4) ! 34: ! 35: /* CALL's src operand descriptor needed to determine size of src operand */ ! 36: #define SRC_OP_DESC(instr) (((char *)(instr))[1] & 0xf0) ! 37: #define SRC_OP_SIZE(desc) /* assumes sp-relative displacement */\ ! 38: (((desc) == BYTE_DISPL) ? 2 : \ ! 39: ((desc) == HALFWORD_DISPL) ? 3 : \ ! 40: ((desc) == WORD_DISPL) ? 5 : \ ! 41: ((((object*)0)->task_error(E_FRAMES))) \ ! 42: ) ! 43: const OPCODE_SIZE = 1; ! 44: const DESC_SIZE = 1; ! 45: ! 46: /* SAK: WRONG for u3b! */ ! 47: #define DST_OP_DESC(instr) \ ! 48: (((char *)(instr))[OPCODE_SIZE + SRC_OP_SIZE(SRC_OP_DESC(instr))] & 0xf0) ! 49: ! 50: /* SAK: WRONG for u3b! */ ! 51: #define IS_LEGAL_SRC_OP(desc) \ ! 52: (((desc) == BYTE_DISPL) || \ ! 53: ((desc) == HALFWORD_DISPL) || \ ! 54: ((desc) == WORD_DISPL) \ ! 55: ) ! 56: /* SAK: WRONG for u3b! */ ! 57: #define IS_LEGAL_DST_OP(desc) \ ! 58: (((desc) == BYTE_DISPL) || \ ! 59: ((desc) == HALFWORD_DISPL) || \ ! 60: ((desc) == WORD_DISPL) || \ ! 61: ((desc) == ABSOLUTE) \ ! 62: ) ! 63: ! 64: ! 65: #else /* m32: u3b2, u3b5, u3b15 */ ! 66: #define OLD_FP(fp) ( *( (int*)(fp) - 7 ) ) ! 67: #define OLD_AP(fp) ( *( (int*)(fp) - 8 ) ) ! 68: #define OLD_PC(fp) ( *( (int*)(fp) - 9 ) ) ! 69: #define FIRST_SAVED_REG_P(fp) ( (int*)(fp) - 6 ) ! 70: /* ! 71: * On the 3B2, the call instruction is CALL src,dst ! 72: * where src is the address of the new ap (where the args were ! 73: * already pushed on the stack) and dst is the address of the ! 74: * called function. src and dst can be various lengths: ! 75: * src will be a byte, halfword, or word displacement ! 76: * and dst will be absolute, or be a byte, halfword, or word displacement. ! 77: * Byte displacement = 2 bytes, halfword = 3, word = 5; the opcode = 1 byte; ! 78: * absolute = 5 bytes--12 possible combinations and 6 possible instr lengths. ! 79: */ ! 80: ! 81: ! 82: const CALL_OPCODE = ((MACHINE_BYTE)0x2c); ! 83: const SAVE_OPCODE = ((MACHINE_BYTE)0x10); ! 84: const BYTE_DISPL = 0xC0; ! 85: const HALFWORD_DISPL = 0xA0; ! 86: const WORD_DISPL = 0x80; ! 87: const ABSOLUTE = 0x70; ! 88: ! 89: const N_CALL_INSTR_SIZES = 6; ! 90: short call_size[N_CALL_INSTR_SIZES] = {5, 6, 7, 8, 9, 11}; ! 91: ! 92: #define SAVE_OPERAND(instr) (((char *)(instr))[1] & 0xf) ! 93: ! 94: /* Given a pointer to a save instruction, yield the number of registers saved */ ! 95: #define N_SAVED_REGS(instr) (8 - SAVE_OPERAND(instr) + 1) ! 96: ! 97: /* CALL's src operand descriptor needed to determine size of src operand */ ! 98: #define SRC_OP_DESC(instr) (((char *)(instr))[1] & 0xf0) ! 99: #define SRC_OP_SIZE(desc) /* assumes sp-relative displacement */\ ! 100: (((desc) == BYTE_DISPL) ? 2 : \ ! 101: ((desc) == HALFWORD_DISPL) ? 3 : \ ! 102: ((desc) == WORD_DISPL) ? 5 : \ ! 103: ((((object*)0)->task_error(E_FRAMES))) \ ! 104: ) ! 105: const OPCODE_SIZE = 1; ! 106: const DESC_SIZE = 1; ! 107: ! 108: #define DST_OP_DESC(instr) \ ! 109: (((char *)(instr))[OPCODE_SIZE + SRC_OP_SIZE(SRC_OP_DESC(instr))] & 0xf0) ! 110: ! 111: #define IS_LEGAL_SRC_OP(desc) \ ! 112: (((desc) == BYTE_DISPL) || \ ! 113: ((desc) == HALFWORD_DISPL) || \ ! 114: ((desc) == WORD_DISPL) \ ! 115: ) ! 116: #define IS_LEGAL_DST_OP(desc) \ ! 117: (((desc) == BYTE_DISPL) || \ ! 118: ((desc) == HALFWORD_DISPL) || \ ! 119: ((desc) == WORD_DISPL) || \ ! 120: ((desc) == ABSOLUTE) \ ! 121: ) ! 122: ! 123: /* Given a pointer to a call instruction, yield a pointer to the called function */ ! 124: unsigned int ! 125: call_dst_ptr(unsigned char* callp) ! 126: { ! 127: int sop_size = SRC_OP_SIZE(SRC_OP_DESC(callp)); ! 128: unsigned char* dst_op_p = /* points past the dst desc, to addr or offset */ ! 129: callp + OPCODE_SIZE + sop_size + DESC_SIZE; ! 130: int offset; // offset for displacement modes ! 131: switch(DST_OP_DESC(callp)) { ! 132: case BYTE_DISPL: ! 133: offset = dst_op_p[0]; ! 134: if(*dst_op_p & 0x80) { /* negative--do sign extension for offset */ ! 135: offset |= 0xffffff00; ! 136: } ! 137: return (unsigned int)(callp + offset); ! 138: case HALFWORD_DISPL: ! 139: // bytes are in reverse order, must flip positions ! 140: offset = dst_op_p[0] | dst_op_p[1] << 8; ! 141: if(dst_op_p[1] & 0x80) { /* negative--do sign extension for offset */ ! 142: offset |= 0xffff0000; ! 143: } ! 144: return (unsigned int)(callp + offset); ! 145: case WORD_DISPL: ! 146: // bytes are in reverse order, must flip positions ! 147: offset = dst_op_p[0] | ! 148: dst_op_p[1] << 8 | ! 149: dst_op_p[2] << 16 | ! 150: dst_op_p[3] << 24; ! 151: /* don't need sign extension */ ! 152: return (unsigned int)(callp + offset); ! 153: case ABSOLUTE: ! 154: return ! 155: dst_op_p[0] | ! 156: dst_op_p[1] << 8 | ! 157: dst_op_p[2] << 16 | ! 158: dst_op_p[3] << 24; ! 159: default: ! 160: ((object*)0)->task_error(E_FRAMES); ! 161: } ! 162: } ! 163: ! 164: ! 165: #endif ! 166: ! 167: ! 168: struct FrameLayout { ! 169: short n_saved; // number of registers saved in this frame. ! 170: // (3B's don't have masks of regs saved) ! 171: FrameLayout(int*); // called with frame pointer ! 172: }; ! 173: ! 174: FrameLayout::FrameLayout(int* fp) ! 175: { ! 176: /* ! 177: * Given a frame pointer, find the number of regs saved in the frame. ! 178: * The idea is that the instruction immediately before the return pc ! 179: * is the function call, and contains a pointer to the first instruction ! 180: * in the function denoted by the fp, which will be a save instruction. ! 181: * We can decode the save instruction to find how many registers ! 182: * were saved. ! 183: */ ! 184: ! 185: int* return_pc = (int*)OLD_PC(fp); ! 186: ! 187: char* callp = NULL; ! 188: /* Because this method is nondeterministic, try all combinations ! 189: instead of stopping when one fits */ ! 190: for(int i = 0; i < N_CALL_INSTR_SIZES; i++) { ! 191: char* poss_callp = (char *)return_pc - call_size[i]; ! 192: if ((*poss_callp == CALL_OPCODE) ! 193: && IS_LEGAL_SRC_OP((SRC_OP_DESC(poss_callp))) ! 194: && IS_LEGAL_DST_OP((DST_OP_DESC(poss_callp)))) { ! 195: if(!callp) callp = poss_callp; ! 196: else ((object*)0)->task_error(E_FRAMES); //ambiguous; can't tell which ! 197: //is real call. ! 198: } ! 199: } ! 200: if (callp == NULL) ((object*)0)->task_error(E_FRAMES); //No match! ! 201: assert( *(char *)(call_dst_ptr(callp)) == SAVE_OPCODE); ! 202: n_saved = N_SAVED_REGS(call_dst_ptr(callp)); ! 203: } ! 204: ! 205: /* ! 206: * fix a frame so that it returns like the arg ! 207: * The idea is that task_fp points to the task::task() stack frame which ! 208: * contains all the saved registers. t_framep points to the stack frame ! 209: * that contains the return address and old fp (and perhaps some registers). ! 210: * fill the frame pointed to by t_framep with the registers from task_fp. ! 211: */ ! 212: void ! 213: task::fudge_return(int* task_fp, int offset, task* next) ! 214: { ! 215: int* fp = t_framep + offset; ! 216: task_fp += offset; // in case this is SHARED ! 217: FrameLayout this_lo(fp); ! 218: FrameLayout task_lo(task_fp); ! 219: if (task_lo.n_saved != 6) // task::task() saves all regs ! 220: task_error(E_FUDGE); ! 221: // copy any saved registers from this to task frame ! 222: register int* task_rp = FIRST_SAVED_REG_P(task_fp) + ! 223: task_lo.n_saved - this_lo.n_saved; ! 224: register int* this_rp = FIRST_SAVED_REG_P(fp); ! 225: register int count; ! 226: for (count = this_lo.n_saved; count--; ) ! 227: *task_rp++ = *this_rp++; ! 228: // next copy all the registers from the task frame to this ! 229: task_rp = FIRST_SAVED_REG_P(task_fp); ! 230: this_rp = FIRST_SAVED_REG_P(fp); ! 231: for (count = task_lo.n_saved; count--; ) ! 232: *this_rp++ = *task_rp++; ! 233: if (next) next->restore(); ! 234: } ! 235: ! 236:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.