Added saved conservative to ensure all registers saved for arbitrary code
[dyninst.git] / dyninstAPI_RT / src / RTsave_alpha.S
1
2 /*
3  #      Do not save or restore register 26 - the return address register
4  #      This will only get clobbered if a function call is added
5  #      Instrumentation code will be generated in that case
6  #      register 26 can't be restored - that would clobber the return address
7  #      in DYNINSTrestore               
8  #
9  #      Added save/restore of $fp.  This is required for inferrior RPC to work.
10  #              - jkh 11/5/98
11 */
12
13 #define LONG_4 .long 0 ; .long 0 ; .long 0 ; .long 0
14 #define LONG_16 LONG_4 ; LONG_4 ; LONG_4 ; LONG_4
15 #define LONG_64 LONG_16 ; LONG_16 ; LONG_16 ; LONG_16
16 #define LONG_256 LONG_64 ; LONG_64 ; LONG_64 ; LONG_64
17 #define LONG_1024 LONG_256 ; LONG_256 ; LONG_256 ; LONG_256
18 #define LONG_4096 LONG_1024 ; LONG_1024 ; LONG_1024 ; LONG_1024
19 #define LONG_16k LONG_4096 ; LONG_4096 ; LONG_4096 ; LONG_4096
20 #define LONG_64k LONG_16k ; LONG_16k ;  LONG_16k ; LONG_16k
21         
22 #define STACK_AREA              (112)
23 #define CONSERVATIVE_STACK_AREA (256+31*8)
24
25         .set noat
26         .text
27
28         .globl DYNINSTcode
29         .ent DYNINSTcode 2      
30 DYNINSTcode:
31         LONG_64k                ; 
32         LONG_16k                ;
33         .end DYNINSTcode
34         
35         .globl DYNINSTsave_temp
36         .ent DYNINSTsave_temp 2 
37 DYNINSTsave_temp:
38         lda $sp, -STACK_AREA($sp)
39         stq $1, 0($sp)
40         stq $2, 8($sp)
41         stq $3, 16($sp)
42         stq $4, 24($sp)
43         stq $5, 32($sp)
44         stq $6, 40($sp)
45         stq $7, 48($sp)
46         stq $8, 56($sp)
47         stq $22, 64($sp)
48         stq $23, 72($sp)
49         stq $24, 80($sp)
50         stq $25, 88($sp)
51         stq $0, 96($sp) /* Save v0 - see note after DYNINSTrestore_temp */
52         stq $15, 104($sp) /* save frame pointer */
53         ret $31, ($26), 1
54         .end DYNINSTsave_temp
55         
56         .globl DYNINSTrestore_temp
57         .ent DYNINSTrestore_temp 2
58 DYNINSTrestore_temp:    
59         ldq $1, 0($sp)
60         ldq $2, 8($sp)
61         ldq $3, 16($sp)
62         ldq $4, 24($sp)
63         ldq $5, 32($sp)
64         ldq $6, 40($sp)
65         ldq $7, 48($sp)
66         ldq $8, 56($sp)
67         ldq $22, 64($sp)
68         ldq $23, 72($sp)
69         ldq $24, 80($sp)
70         ldq $25, 88($sp)
71         ldq $0, 96($sp) /* Restore v0 - see note after this function */
72         ldq $15, 104($sp) /* restore frame pointer */
73         lda $sp, STACK_AREA($sp)        
74         ret $31, ($26), 1
75         .end DYNINSTrestore_temp
76
77 /*
78  * This version is conservative and saves everything for arbitrary inst points.
79  *
80  */
81         .globl DYNINSTsave_conservative
82         .ent DYNINSTsave_conservative 2 
83 DYNINSTsave_conservative:
84         lda $sp, -CONSERVATIVE_STACK_AREA($sp)
85         stq $1, 0($sp)
86         stq $2, 8($sp)
87         stq $3, 16($sp)
88         stq $4, 24($sp)
89         stq $5, 32($sp)
90         stq $6, 40($sp)
91         stq $7, 48($sp)
92         stq $8, 56($sp)
93         stq $9, 64($sp)
94         stq $10, 72($sp)
95         stq $11, 80($sp)
96         stq $12, 88($sp)
97         stq $13, 96($sp)
98         stq $14, 104($sp)
99
100         /* 15 - 21 saved by saveMisc if used */
101
102         stq $22, 168($sp)
103         stq $23, 176($sp)
104         stq $24, 184($sp)
105         stq $25, 192($sp)
106
107         /* skip $26 - return address */
108
109         /* save misc saves 27-28 */
110
111         stq $0, 240($sp) /* Save v0 - see note after DYNINSTrestore_temp */
112
113         /* now the FP registers */
114         stt $f0, 248($sp)
115         stt $f1, 256($sp)
116         stt $f2, 264($sp)
117         stt $f3, 272($sp)
118         stt $f4, 280($sp)
119         stt $f5, 288($sp)
120         stt $f6, 296($sp)
121         stt $f7, 304($sp)
122         stt $f8, 312($sp)
123         stt $f9, 320($sp)
124         stt $f10, 328($sp)
125         stt $f11, 336($sp)
126         stt $f12, 344($sp)
127         stt $f13, 352($sp)
128         stt $f14, 360($sp)
129         stt $f15, 368($sp)
130         stt $f16, 376($sp)
131         stt $f17, 384($sp)
132         stt $f18, 392($sp)
133         stt $f19, 400($sp)
134         stt $f20, 408($sp)
135         stt $f21, 416($sp)
136         stt $f22, 424($sp)
137         stt $f23, 432($sp)
138         stt $f24, 440($sp)
139         stt $f25, 448($sp)
140         stt $f26, 456($sp)
141         stt $f27, 464($sp)
142         stt $f28, 472($sp)
143         stt $f29, 480($sp)
144         stt $f30, 488($sp)
145
146         /* leave extra gap */
147         lda $sp, -CONSERVATIVE_STACK_AREA($sp)
148         ret $31,($26), 1
149         .end DYNINSTsave_conservative
150         
151         .globl DYNINSTrestore_conservative
152         .ent DYNINSTrestore_conservative 2
153 DYNINSTrestore_conservative:    
154         /* remove extra gap */
155         lda $sp, CONSERVATIVE_STACK_AREA($sp)   
156
157         ldq $1, 0($sp)
158         ldq $2, 8($sp)
159         ldq $3, 16($sp)
160         ldq $4, 24($sp)
161         ldq $5, 32($sp)
162         ldq $6, 40($sp)
163         ldq $7, 48($sp)
164         ldq $8, 56($sp)
165         ldq $9, 64($sp)
166         ldq $10, 72($sp)
167         ldq $11, 80($sp)
168         ldq $12, 88($sp)
169         ldq $13, 96($sp)
170         ldq $14, 104($sp)
171
172         /* 15 - 21 restored by saveMisc */
173
174         ldq $22, 168($sp)
175         ldq $23, 176($sp)
176         ldq $24, 184($sp)
177         ldq $25, 192($sp)
178
179         /* 26-29 restored by restoreMisc */
180                 
181         /* skip r30 it's the stack pointer */
182
183         ldq $0, 240($sp) /* Restore v0 - see note after this function */
184
185         /* now the FP registers */
186         ldt $f0, 248($sp)
187         ldt $f1, 256($sp)
188         ldt $f2, 264($sp)
189         ldt $f3, 272($sp)
190         ldt $f4, 280($sp)
191         ldt $f5, 288($sp)
192         ldt $f6, 296($sp)
193         ldt $f7, 304($sp)
194         ldt $f8, 312($sp)
195         ldt $f9, 320($sp)
196         ldt $f10, 328($sp)
197         ldt $f11, 336($sp)
198         ldt $f12, 344($sp)
199         ldt $f13, 352($sp)
200         ldt $f14, 360($sp)
201         ldt $f15, 368($sp)
202         ldt $f16, 376($sp)
203         ldt $f17, 384($sp)
204         ldt $f18, 392($sp)
205         ldt $f19, 400($sp)
206         ldt $f20, 408($sp)
207         ldt $f21, 416($sp)
208         ldt $f22, 424($sp)
209         ldt $f23, 432($sp)
210         ldt $f24, 440($sp)
211         ldt $f25, 448($sp)
212         ldt $f26, 456($sp)
213         ldt $f27, 464($sp)
214         ldt $f28, 472($sp)
215         ldt $f29, 480($sp)
216         ldt $f30, 488($sp)
217
218         lda $sp, CONSERVATIVE_STACK_AREA($sp)   
219         ret $31, ($26), 1
220         .end DYNINSTrestore_conservative
221
222 /*
223  * XXX Note about saving and restoring v0 above: We don't necessarily
224  * need to save and restore v0 in the base tramp.  We're only doing it
225  * there now because it makes it easier for us to get the return value
226  * of a function without having to generate code on the fly to selectively
227  * save and restore registers.  Basically, we save and restore all scratch
228  * registers before and after calling a function from a mini-tramp.  We don't
229  * want to have to save and restore v0 there, because we'd like to call
230  * DYNINSTrestore_misc and then, *after* the restore, we want to read the
231  * return value out of v0.  If we work out some alternative way to store the
232  * return value *before* the restore so that it doesn't get wiped out by the
233  * restore, then we won't need to do anything with v0 in the base tramp.
234  */
235
236
237 /*
238  * XXX These are the new versions of the save_misc functions.  They save all
239  * scratch registers that we may potentially be using in a mini-tramp.
240  */
241         .globl DYNINSTsave_misc
242         .ent DYNINSTsave_misc 2
243 DYNINSTsave_misc:       
244         lda $sp, -144($sp)
245         stq $1, 0($sp)
246         stq $2, 8($sp)
247         stq $3, 16($sp)
248         stq $4, 24($sp)
249         stq $5, 32($sp)
250         stq $6, 40($sp)
251         stq $7, 48($sp)
252         stq $8, 56($sp)
253
254         stq $15, 136($sp)       /* 15 == $fp */
255         stq $16, 64($sp)
256         stq $17, 72($sp)
257         stq $18, 80($sp)
258         stq $19, 88($sp)
259         stq $20, 96($sp)
260         stq $21, 104($sp)
261
262         stq $27, 112($sp)       
263         stq $28, 120($sp)       /* 28 == $at */
264         stq $29, 128($sp)       /* 29 == $gp */
265         stq $30, 144($sp)       /* $30 == $sp */
266         ret $31, ($26), 1
267         .end DYNINSTsave_misc
268
269         .globl DYNINSTrestore_misc
270         .ent DYNINSTrestore_misc 2
271 DYNINSTrestore_misc:
272         ldq $1, 0($sp)
273         ldq $2, 8($sp)
274         ldq $3, 16($sp)
275         ldq $4, 24($sp)
276         ldq $5, 32($sp)
277         ldq $6, 40($sp)
278         ldq $7, 48($sp)
279         ldq $8, 56($sp)
280
281         ldq $15, 136($sp)       /* $15 == $fp */
282         ldq $16, 64($sp)
283         ldq $17, 72($sp)
284         ldq $18, 80($sp)
285         ldq $19, 88($sp)
286         ldq $20, 96($sp)
287         ldq $21, 104($sp)
288
289         /* $26 == $ra, skip this one */
290
291         ldq $27, 112($sp)
292         ldq $28, 120($sp)
293         ldq $29, 128($sp)
294         lda $30, 144($sp)       /* $30 == $sp */
295         ret $31, ($26), 1
296         .end DYNINSTrestore_misc