![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to swap.s.68k 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.68k CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / libC / task |
1.1 root 1: | .file "swap.s.68k"
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 movem to restore the regs saved in
22: | the stack.
23: | If to_run is not a new child, it restores all the registers saved in
24: | the frame on returning.
25: | If running_task is TERMINATED, then we don't need to do a save.
26: | NOTE: assumes all functions return values in d0.
27:
28: | The following constants are displacements of elements in class task:
29: | t_framep, th, t_basep, t_size, t_savearea, and t_mode.
30: TFRAME = 20
31: TH = 24
32: TBASEP = 32
33: TSIZE = 36
34: TSAVE = 40
35: TMODE = 52
36:
37: | The following constants are displacements from the fp to function args.
38: ARG1 = 8
39: ARG2 = 12
40: ARG3 = 16
41: ARG4 = 20
42: ARG5 = 24
43:
44: .text
45: .globl _swap
46: _swap:
47: link a6,#-40
48: moveml #0x3cfc,sp@ | save all user regs (d2-d7, a2-a5)
49: movl a6@(ARG2),a1 | a1 = to_run
50: movl a6@(ARG4),d0 | d0 = running_is_terminated
51: bnes L_RESTORE | if running is TERMINATED
52: | skip the save
53: movl a6@(ARG1),a0 | a0 = running
54:
55: | save state of running task
56: movl a6,a0@(TFRAME) | running->t_framep = fp (a6)
57: movl a0@(TMODE),d0 | d0 = running->t_mode
58: cmpl #2,d0 | if running->t_mode == SHARED
59: bnes L_RESTORE
60: | the code here to save the t_size is the same as for sswap
61: movl a0@(TBASEP),d0 | d0 = running->t_basep
62: subl sp,d0 | d0 = running->t_basep - sp
63: addql #4,d0 | (size in bytes)
64: asrl #2,d0 | d0 /= 4 (size in ints)
65: movl d0,a0@(TSIZE) | running->t_size = d0
66:
67: L_RESTORE:
68: movl a6@(ARG3),d1 | d1 = is_new_child
69:
70: | restore state of to_run task
71: movl a1@(TFRAME),a6 | a6 (fp) = to_run->t_framep
72:
73: | if is_new_child, restore registers
74: tstl d1
75: beqs L_RET
76: | new child task effectively returns from task::task, so we need
77: | to set the return value to "this"
78: movl a1@(TH),d0 | d0 = to_run->th
79: lea _New_task_regs,a1 | a1 = address of New_task_regs
80: movl a1@,d2
81: movl a1@(4),d3
82: movl a1@(8),d4
83: movl a1@(12),d5
84: movl a1@(16),d6
85: movl a1@(20),d7
86: movl a1@(32),a2
87: movl a1@(36),a3
88: movl a1@(40),a4
89: movl a1@(44),a5
90: unlk a6 | NOTE: movem not needed here.
91: rts
92: L_RET:
93: moveml a6@(-40),#0x3cfc | restore all user regs (d2-d7, a2-a5)
94: unlk a6
95: rts
96:
97:
98: | swap of SHARED
99: | sswap(*running, *prevOnStack, *to_run, is_new_child, running_is_terminated)
100: | This routine saves the fp in running's t_framep and the stack size in t_size.
101: | Then it copies out the target stack to prevOnStack's t_savearea.
102: | If to_run is not a new child, it then copies the saved stack of to_run
103: | (from t_savearea) to the target stack, and then restores to_run's t_framep
104: | to be the current fp. We don't need to restore state of a child
105: | to_run object, because it's already in place.
106: | If running_task is TERMINATED, then we don't need to do a save,
107: | and if running_task is TERMINATED and equals prevOnStack, then we don't
108: | have to do the stack copy.
109: | NOTE: assumes all functions return values in d0.
110: .text
111: .globl _sswap
112: _sswap:
113: link a6,#-40
114: moveml #0x3cfc,sp@ | save all user regs (d2-d7, a2-a5)
115:
116: movl a6@(ARG1),a1 | a1 = running
117: movl a6@(ARG2),a2 | a2 = prevOnStack
118: movl a6@(ARG5),d0 | d0 = running_is_terminated
119: bnes L_SKIP | if running is TERMINATED
120: | skip the save
121: |save hw state of running
122: movl a6,a1@(TFRAME) | running->t_framep = fp (a6)
123: movl a1@(TBASEP),d0 | d0 = running->t_basep
124: subl sp,d0 | d0 = running->t_basep - sp
125: addql #4,d0 | (size in bytes)
126: asrl #2,d0 | d0 /= 4 (size in ints)
127: movl d0,a1@(TSIZE) | running->t_size = d0
128: bra L_SAVE
129: L_SKIP:
130: cmpl a1,a2 | if running == prevOnStack
131: beq L_REST | skip prevOnStack save
132:
133: L_SAVE: |copy out target stack to prevOnStack->t_savearea
134: movl a2@(TSIZE),d2 | d2 = prevOnStack->t_size (count)
135: movl d2,sp@- | push count arg on stack
136: jsr _swap_call_new | get count bytes of storage
137: addql #4,sp | pop arg off stack
138: asll #2,d2 | scale d2 to bytes
139: addl d2,d0 | d0 = base of new stack, plus 1 long
140: subql #4,d0 | d0 = base of new stack
141: movl d0,a0 | a0 = base of new stack (to)
142: movl a0,a2@(TSAVE) | prevOnStack->t_savearea = a0 (to)
143: movl a2@(TBASEP),a1 | a1 = prevOnStack->t_basep (from)
144: addql #4,a0 | prepare for predecrement
145: addql #4,a1 | ditto
146: movl a2@(TSIZE),d0 | d0 = prevOnStack->t_size (count)
147: tstl d0
148: beqs L2 | if size == 0, goto L2
149: subql #1,d0 | for dbra
150: L1: | copy out loop
151: movl a1@-,a0@- | *--to = *--from
152: dbra d0,L1 | if --d0 != 0, goto L1
153: L2:
154: L_REST:
155: movl a6@(ARG4),d0 | d0 = is_new_child
156: bnes L6 | if is_new_child != 0
157: | skip the copy-in loop
158: |copy into target stack from to_run->t_savearea
159: movl a6@(ARG3),a2 | a2 = to_run
160: movl a2@(TBASEP),a0 | a0 = to_run->t_basep (to)
161: movl a2@(TSIZE),d0 | d0 = to_run->t_size (count)
162: | Kick up the sp if new stack will be taller than current.
163: asll #2,d0 | d0 = new stack height in bytes
164: subl d0,a0 | a0 = target sp
165: subl sp,a0 | a0 = a0 - sp
166: tstl a0
167: bges L3 | if a0 < 0
168: addl a0,sp | kick up sp
169: L3: movl a2@(TBASEP),a0 | a0 = to_run->t_basep (to)
170: movl a2@(TSAVE),a1 | a1 = to_run->t_savearea (from)
171: addql #4,a1 | prepare for predecrement
172: addql #4,a0 | ditto
173: movl a2@(TSIZE),d0 | d0 = to_run->t_size (count)
174: tstl d0
175: beqs L5 | if size == 0, goto L5
176: subql #1,d0 | for dbra
177: L4: | copy in loop
178: movl a1@-,a0@- | *--to = *--from
179: dbra d0,L4 | if --d0 != 0, goto L4
180: L5:
181: | restore state of to_run
182: movl a2@(TFRAME),a6 | fp (a6) = to_run->t_framep
183: | finally, delete to_run's t_savearea
184: movl a2@(TSIZE),d1 | d1 = to_run->t_size
185: asll #2,d1 | scale size to bytes
186: movl a2@(TSAVE),a0 | a0 = to_run->t_savearea
187: subl d1,a0 | get low address of savearea
188: addql #4,a0
189: movl a0,sp@- | push pointer to savearea on stack
190: jsr _swap_call_delete | delete to_run->t_savearea
191: addql #4,sp | pop arg off stack
192: movl #0,a2@(TSAVE) | to_run->t_savearea = 0
193: L6: moveml a6@(-40),#0x3cfc | restore all user regs (d2-d7, a2-a5)
194: unlk a6
195: rts
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.