![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to swap.s.386 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 swap.s.386 CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / libC / task |
1.1 ! root 1: / .file "swap.s.386" ! 2: / ident "%W%" ! 3: /############################################################################## ! 4: / Copyright (c) 1984 AT&T ! 5: / All Rights Reserved ! 6: / ! 7: / THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T ! 8: / ! 9: / The copyright notice above does not evidence any ! 10: / actual or intended publication of such source code. ! 11: / ! 12: /############################################################################## ! 13: ! 14: / swap of DEDICATED ! 15: / call swap(*running_task, *to_run_task, is_new_child, running_is_terminated) ! 16: / This routine saves the fp in running's t_framep. ! 17: / If running is a SHARED task, we must save its stack size as well, ! 18: / although the stack does not need to be copied out here. ! 19: / It then restores to_run's t_framep to be the current fp. ! 20: / If to_run is a new child, it explicitly restores the registers from ! 21: / New_task_regs, and returns without restoring the regs saved in the stack. ! 22: / If to_run is not a new child, it restores all the registers saved in ! 23: / the frame on returning. ! 24: / If running_task is TERMINATED, then we don't need to do a save. ! 25: / NOTE: assumes all functions return values in eax. ! 26: ! 27: .text ! 28: .globl swap ! 29: swap: ! 30: pushl %ebp / save caller's fp ! 31: movl %esp,%ebp / fp = sp ! 32: pushl %edi / save all user regs: edi, esi, ebx ! 33: pushl %esi ! 34: pushl %ebx ! 35: movl 12(%ebp),%edx / edx = to_run ! 36: movl 20(%ebp),%eax / eax = running_is_terminated ! 37: cmpl $1,%eax / if eax == 1 ! 38: je .L_RESTORE / skip the save ! 39: movl 8(%ebp),%eax / eax = running ! 40: ! 41: / save state of running task ! 42: movl %ebp,20(%eax) / running->t_framep = fp (ebp) ! 43: movl 52(%eax),%ecx / %ecx = running->t_mode ! 44: cmpw $2,%ecx / if running-t_mode == SHARED ! 45: jne .L_RESTORE ! 46: / the code here to save the t_size is the same as for sswap ! 47: movl 32(%eax),%ecx / ecx = running->t_basep ! 48: subl %esp,%ecx / ecx = running->t_basep - sp ! 49: addl $4,%ecx / (size in bytes) ! 50: shrl $2,%ecx / ecx /= 4 (size in ints) ! 51: movl %ecx,36(%eax) / running->t_size = ecx ! 52: ! 53: .L_RESTORE: ! 54: movl 16(%ebp),%ecx / ecx = is_new_child ! 55: ! 56: / restore state of to_run task ! 57: movl 20(%edx),%ebp / ebp (fp) = to_run->t_framep ! 58: ! 59: / if is_new_child, restore registers ! 60: jcxz .L_RET / if ecx==0; go to .L_RET ! 61: / new child task effectively returns from task::task, so we need ! 62: / to set the return value to "this" ! 63: movl 24(%edx),%eax / eax = to_run->th ! 64: leal New_task_regs,%edx / edx = address of New_task_regs ! 65: movl 0(%edx),%edi ! 66: movl 4(%edx),%esi ! 67: movl 8(%edx),%ebx ! 68: / Note: leave resets sp relative to fp, so don't need to reset sp ! 69: / for NEW_CHILD case. ! 70: leave ! 71: ret ! 72: .L_RET: ! 73: / The i386 restores registers relative to sp, so we need to reset ! 74: / to-runs's sp. We add 3 words (n saved regs) to the fp to get the sp. ! 75: movl %ebp,%edx ! 76: sub $12,%edx ! 77: movl %edx,%esp ! 78: / restore all user regs: edi, esi, ebx ! 79: popl %ebx ! 80: popl %esi ! 81: popl %edi ! 82: leave ! 83: ret ! 84: ! 85: ! 86: / swap of SHARED ! 87: / sswap(*running, *prevOnStack, *to_run, is_new_child, running_is_terminated) ! 88: / This routine saves the fp in running's t_framep and the stack size in t_size. ! 89: / Then it copies out the target stack to prevOnStack's t_savearea. ! 90: / If to_run is not a new child, it then copies the saved stack of to_run ! 91: / (from t_savearea) to the target stack, and then restores to_run's t_framep ! 92: / to be the current fp. We don't need to restore state of a child ! 93: / to_run object, because it's already in place. ! 94: / If running_task is TERMINATED, then we don't need to do a save, ! 95: / NOTE: assumes all functions return values in eax. ! 96: / and if running_task is TERMINATED and equals prevOnStack, then we don't ! 97: / have to do the stack copy. ! 98: .text ! 99: .globl sswap ! 100: sswap: ! 101: pushl %ebp / save caller's fp ! 102: movl %esp,%ebp / fp = sp ! 103: pushl %edi / save all user regs: edi, esi, ebx ! 104: pushl %esi ! 105: pushl %ebx ! 106: ! 107: movl 8(%ebp),%eax / eax = running ! 108: movl 12(%ebp),%edi / edi = prevOnStack ! 109: movl 24(%ebp),%ecx / ecx = running_is_terminated ! 110: cmpl $1,%ecx / if ecx == 1 ! 111: je .L_SKIP / skip the save ! 112: /save hw state of running ! 113: movl %ebp,20(%eax) / running->t_framep = fp (ebp) ! 114: movl 32(%eax),%ecx / ecx = running->t_basep ! 115: subl %esp,%ecx / ecx = running->t_basep - sp ! 116: addl $4,%ecx / (size in bytes) ! 117: shrl $2,%ecx / ecx /= 4 (size in ints) ! 118: movl %ecx,36(%eax) / running->t_size = ecx ! 119: jmp .L_SAVE ! 120: ! 121: .L_SKIP: /if running is TERMINATED and running == prevOnStack, ! 122: /then we can skip the stack copy too ! 123: cmpl %eax,%edi / if running == prevOnStack ! 124: je .L_REST / skip save ! 125: ! 126: .L_SAVE: /copy out target stack to prevOnStack->t_savearea ! 127: movl 36(%edi),%ecx / ecx = prevOnStack->t_size (count) ! 128: pushl %ecx / push count arg on stack ! 129: call swap_call_new / get count bytes of storage ! 130: popl %ecx / pop arg off stack ! 131: sall $2,%ecx / scale ecx to bytes ! 132: addl %ecx,%eax / eax = base of new stack, plus 1 long ! 133: subl $4,%eax / eax = base of new stack (to) ! 134: movl %eax,40(%edi) / prevOnStack->t_savearea = eax (to) ! 135: movl 32(%edi),%edx / edx = prevOnStack->t_basep (from) ! 136: shrl $2,%ecx / ecx /= 4 = size in ints (count) ! 137: jmp .L2 ! 138: .L1: / copy out loop ! 139: movl (%edx),%edi / edi = *from ! 140: movl %edi,(%eax) / *to = edi ! 141: subl $4,%edx / from-- ! 142: subl $4,%eax / to-- ! 143: decl %ecx / count-- ! 144: .L2: ! 145: testl %ecx,%ecx / if count > 0 ! 146: jg .L1 / jmp .L1 ! 147: .L_REST: ! 148: movl 20(%ebp),%eax / eax = is_new_child ! 149: testl %eax,%eax / if is_new_child != 0 ! 150: jne .L6 / skip the copy-in loop ! 151: ! 152: /copy into target stack from to_run->t_savearea ! 153: movl 16(%ebp),%esi / esi = to_run ! 154: movl 32(%esi),%eax / eax = to_run->t_basep (to) ! 155: movl 36(%esi),%ecx / ecx = to_run->t_size (count) ! 156: / Kick up the sp if new stack will be taller than current. ! 157: sall $2,%ecx / ecx = new stack height in bytes ! 158: subl %ecx,%eax / eax = base - size = target sp (+ 1) ! 159: subl %esp,%eax / eax = eax - sp ! 160: testl %eax,%eax ! 161: jge .L3 / if eax < 0 ! 162: addl %eax,%esp / kick up sp ! 163: .L3: ! 164: movl 32(%esi),%eax / eax = to_run->t_basep (to) ! 165: movl 36(%esi),%ecx / ecx = to_run->t_size (count) ! 166: movl 40(%esi),%edx / edx = to_run->t_savearea (from) ! 167: jmp .L5 ! 168: .L4: / copy in loop ! 169: movl (%edx),%edi / edi = *from ! 170: movl %edi,(%eax) / *to = edi ! 171: subl $4,%edx / from-- ! 172: subl $4,%eax / to-- ! 173: decl %ecx / count-- ! 174: .L5: ! 175: testl %ecx,%ecx / if count > 0 ! 176: jg .L4 / jmp .L4 ! 177: ! 178: / restore state of to_run ! 179: movl 20(%esi),%ebp / fp (a6) = to_run->t_framep ! 180: / to (eax) points to one word beyond new sp ! 181: addl $4,%eax ! 182: movl %eax,%esp / reset sp, so regs can be restored ! 183: / finally, delete to_run's t_savearea ! 184: movl 36(%esi),%ecx / ecx = to_run->t_size ! 185: sall $2,%ecx / scale size to bytes ! 186: movl 40(%esi),%eax / eax = to_run->t_savearea ! 187: subl %ecx,%eax / get low address of savearea ! 188: addl $4,%eax ! 189: pushl %eax / push pointer to savearea on stack ! 190: call swap_call_delete / delete to_run->t_savearea ! 191: popl %eax / pop arg off stack ! 192: movl $0,40(%esi) / to_run->t_savearea = 0 ! 193: / sp should be correct here, for both is and is not new child cases ! 194: .L6: / restore all user regs: edi, esi, ebx ! 195: popl %ebx ! 196: popl %esi ! 197: popl %edi ! 198: leave ! 199: ret
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.