![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to swap.s 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 CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / libC / task |
1.1 ! root 1: .file "swap.s.vax" ! 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. If to_run is not a new child, it simply returns. ! 22: # If running_task is TERMINATED, then we don't need to do a save. ! 23: ! 24: .globl _swap ! 25: .align 1 ! 26: _swap: ! 27: .word 0xfc0 # entry mask; save all user regs (r11-r6) ! 28: movl 8(ap),r2 # r2 = to_run ! 29: movl 16(ap),r1 # r1 = running_is_terminated ! 30: cmpl $1,r1 # if running is TERMINATED ! 31: jeql .L_RESTORE # skip save ! 32: movl 4(ap),r1 # r1 = running ! 33: ! 34: # save state of running task ! 35: movl fp,20(r1) # running->t_framep = fp ! 36: movl 52(r1),r0 # r0 = running->t_mode ! 37: cmpl $2,r0 # if running->t_mode == SHARED ! 38: jneq .L_RESTORE ! 39: # the code here to save the t_size is the same as for sswap ! 40: ! 41: subl3 sp,32(r1),r0 # r0 = running->t_basep - sp ! 42: # (size in bytes) ! 43: divl3 $4,r0,36(r1) # running->t_size = r0 / 4 (int) ! 44: ! 45: .L_RESTORE: ! 46: movl 12(ap),r1 # r1 = is_new_child ! 47: ! 48: # restore state of to_run_task ! 49: movl 20(r2),fp # fp = to_run->t_framep ! 50: ! 51: # if is_new_child, restore registers ! 52: tstl r1 ! 53: jeql .L_RET ! 54: # new child task effectively returns from task::task, so we need ! 55: # to set the return value to "this" ! 56: movl 24(r2),r0 # r0 = to_run->th ! 57: moval _New_task_regs,r2 # r2 = address of New_task_regs ! 58: movl 0(r2),r6 ! 59: movl 4(r2),r7 ! 60: movl 8(r2),r8 ! 61: movl 12(r2),r9 ! 62: movl 16(r2),r10 ! 63: movl 20(r2),r11 ! 64: .L_RET: ! 65: ret ! 66: ! 67: # swap of SHARED ! 68: # sswap(*running, *prevOnStack, *to_run, is_new_child, running_is_terminated) ! 69: # This routine saves the fp in running's t_framep and the stack size in t_size. ! 70: # Then it copies out the target stack to prevOnStack's t_savearea. ! 71: # If to_run is not a new child, it then copies the saved stack of to_run ! 72: # (from t_savearea) to the target stack, and then restores to_run's t_framep ! 73: # to be the current fp. We don't need to restore state of a child ! 74: # to_run object, because it's already in place. ! 75: # If running_task is TERMINATED, then we don't need to do a save, ! 76: # and if running_task is TERMINATED and equals prevOnStack, then we don't ! 77: # have to do the stack copy. ! 78: .globl _sswap ! 79: .align 1 ! 80: _sswap: ! 81: .word 0xfc0 # entry mask; save all user regs (r11-r6) ! 82: movl 4(ap),r1 # r1 = running ! 83: movl 8(ap),r11 # r11 = prevOnStack ! 84: movl 20(ap),r0 # r0 = running_is_terminated ! 85: cmpl $1,r0 # if running is TERMINATED ! 86: jeql .L_SKIP # skip save ! 87: #save hw state of running ! 88: movl fp,20(r1) # running->t_framep = fp ! 89: subl3 sp,32(r1),r0 # r0 = running->t_basep - sp ! 90: # (size in bytes) ! 91: divl3 $4,r0,36(r1) # running->t_size = r0 / 4 (int) ! 92: jmp .L_SAVE ! 93: ! 94: .L_SKIP: #if running is TERMINATED and running == prevOnStack, ! 95: #then we can skip the stack copy too ! 96: cmpl r1,r11 # if running == prevOnStack ! 97: jeql .L_REST # skip save ! 98: ! 99: .L_SAVE: #copy out target stack to prevOnStack->t_savearea ! 100: movl 36(r11),r10 # r10 = prevOnStack->t_size (count) ! 101: pushl r10 ! 102: calls $1,_swap_call_new # get count bytes of storage ! 103: ashl $2,r10,r10 # scale r10 to bytes ! 104: addl2 r10,r0 # r0 = base of new space, plus 1 ! 105: subl2 $4,r0 # r0 = base of new stack (to) ! 106: movl r0,40(r11) # prevOnStack->t_savearea = r0 (to) ! 107: movl 32(r11),r2 # r2 = prevOnStack->t_basep (from) ! 108: movl 36(r11),r10 # r10 = prevOnStack->t_size (count) ! 109: .L1: #copy out loop ! 110: tstl r10 # while (count > 0) ! 111: jeql .L2 ! 112: decl r10 # count-- ! 113: movl (r2),(r0) # to = from ! 114: cmpl -(r2),-(r0) # to--, from-- ! 115: jmp .L1 ! 116: .L2: ! 117: .L_REST: ! 118: movl 16(ap),r1 # r1 = is_new_child ! 119: cmpl $1,r1 # if is_new_child == 1 ! 120: jeql .L6 # skip the copy-in loop ! 121: #copy into target stack from to_run->t_savearea ! 122: movl 12(ap),r11 # r11 = to_run ! 123: movl 32(r11),r0 # r0 = to_run->t_basep (to) ! 124: movl 36(r11),r10 # r10 = to_run->t_size (count) ! 125: # Kick up the %sp if new stack will be taller than current. ! 126: ashl $2,r10,r2 # r2 = new stack height in bytes. ! 127: subl3 r2,r0,r1 # r1 = target sp ! 128: subl2 sp,r1 # r1 = r1 - sp ! 129: cmpl r1,$0 # if r1 < 0, kick up sp ! 130: jgeq .L3 ! 131: addl2 r1,sp ! 132: .L3: movl 40(r11),r2 # r2 = to_run->t_savearea (from) ! 133: .L4: # copy in loop ! 134: tstl r10 # while (count > 0) ! 135: jeql .L5 ! 136: decl r10 # count-- ! 137: movl (r2),(r0) # to = from ! 138: cmpl -(r2),-(r0) # --to, --from ! 139: jmp .L4 ! 140: ! 141: .L5: # restore state of to_run ! 142: movl 20(r11),fp # fp = to_run->t_framep ! 143: # finally, delete to_run's t_savearea ! 144: movl 36(r11),r1 # r1 = to_run->t_size ! 145: ashl $2,r1,r1 # scale size to bytes ! 146: movl 40(r11),r2 # r2 = to_run->t_savearea ! 147: subl2 r1,r2 # get low address of savearea ! 148: addl2 $4,r2 ! 149: pushl r2 ! 150: calls $1,_swap_call_delete ! 151: movl $0,40(r11) # to_run->t_savearea = 0 ! 152: .L6: ret
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.