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