Mercurial > pub > dyncall > dyncall
comparison doc/disas_examples/x86.plan9call.disas @ 447:97fff5d9cea1
- plan9/x86 struct by value passing disas example
author | Tassilo Philipp |
---|---|
date | Thu, 27 Jan 2022 11:14:11 +0100 |
parents | c0390dc85a07 |
children | e5820b7a3fbc |
comparison
equal
deleted
inserted
replaced
446:54c1dc2e6ea5 | 447:97fff5d9cea1 |
---|---|
1 ; void leaf_call(int a, int b, int c, int d, int e, int f) | 1 ; void leaf_call(int a, int b, int c, int d, int e, int f) |
2 ; { | 2 ; { |
3 ; } | 3 ; } |
4 ; | 4 ; |
5 ; int nonleaf_call(int a, int b, int c, int d, int e, int f, int g) | 5 ; int nonleaf_call(int a, int b, int c, int d, int e, int f, int g) |
6 ; { | 6 ; { |
7 ; leaf_call(b,c,d,e,f,g); | 7 ; leaf_call(b,c,d,e,f,g); |
8 ; return 'x'; | 8 ; return 'x'; |
9 ; } | 9 ; } |
10 ; | 10 ; |
11 ; int main() | 11 ; int main() |
12 ; { | 12 ; { |
13 ; nonleaf_call(0,1,2,3,4,5,6); | 13 ; nonleaf_call(0,1,2,3,4,5,6); |
14 ; return 0; | 14 ; return 0; |
15 ; } | 15 ; } |
33 00103f 8944240c (7) MOVL AX,12(SP) ; | | 33 00103f 8944240c (7) MOVL AX,12(SP) ; | |
34 001043 8b442434 (7) MOVL f+52(FP),AX ; | | 34 001043 8b442434 (7) MOVL f+52(FP),AX ; | |
35 001047 89442410 (7) MOVL AX,16(SP) ; | | 35 001047 89442410 (7) MOVL AX,16(SP) ; | |
36 00104b 8b442438 (7) MOVL g+56(FP),AX ; | | 36 00104b 8b442438 (7) MOVL g+56(FP),AX ; | |
37 00104f 89442414 (7) MOVL AX,20(SP) ; | | 37 00104f 89442414 (7) MOVL AX,20(SP) ; | |
38 001053 e8c8ffffff (7) CALL ,1020+leaf_call ; push return addrss and call | 38 001053 e8c8ffffff (7) CALL ,1020+leaf_call ; push return address and call |
39 001058 b878000000 (8) MOVL $120,AX ; return value: 'x' -> eax | 39 001058 b878000000 (8) MOVL $120,AX ; return value: 'x' -> eax |
40 00105d 83c41c (8) ADDL $28,SP ; | | 40 00105d 83c41c (8) ADDL $28,SP ; | |
41 001060 c3 (8) RET , ; | epilog | 41 001060 c3 (8) RET , ; | epilog |
42 | 42 |
43 001061 (11) TEXT main+0(SB),$32 | 43 001061 (11) TEXT main+0(SB),$32 |
53 00108b 89442410 (13) MOVL AX,16(SP) ; . | 53 00108b 89442410 (13) MOVL AX,16(SP) ; . |
54 00108f b805000000 (13) MOVL $5,AX ; . | 54 00108f b805000000 (13) MOVL $5,AX ; . |
55 001094 89442414 (13) MOVL AX,20(SP) ; . | 55 001094 89442414 (13) MOVL AX,20(SP) ; . |
56 001098 b806000000 (13) MOVL $6,AX ; arg 6 -> eax, then ... | 56 001098 b806000000 (13) MOVL $6,AX ; arg 6 -> eax, then ... |
57 00109d 89442418 (13) MOVL AX,24(SP) ; ... "pushed" onto stack | 57 00109d 89442418 (13) MOVL AX,24(SP) ; ... "pushed" onto stack |
58 0010a1 e87bffffff (13) CALL ,1021+nonleaf_call ; push return addrss and call | 58 0010a1 e87bffffff (13) CALL ,1021+nonleaf_call ; push return address and call |
59 0010a6 31c0 (14) MOVL $0,AX ; return value | 59 0010a6 31c0 (14) MOVL $0,AX ; return value |
60 0010a8 83c420 (14) ADDL $32,SP ; | | 60 0010a8 83c420 (14) ADDL $32,SP ; | |
61 0010ab c3 (14) RET , ; | epilog | 61 0010ab c3 (14) RET , ; | epilog |
62 | 62 |
63 | |
64 | |
65 ; ---------- structs by value ----------> | |
66 ; | |
67 ; struct A { int i, j; long long l; }; | |
68 ; | |
69 ; void leaf_call(int b, int c, int d, int e, struct A f, int g, int h) | |
70 ; { | |
71 ; } | |
72 ; | |
73 ; void nonleaf_call(int a, int b, int c, int d, int e, struct A f, int g, int h) | |
74 ; { | |
75 ; /* use some local data */ | |
76 ; char l[100] = 'L'; | |
77 ; leaf_call(b, c, d, e, f, g, h); | |
78 ; } | |
79 ; | |
80 ; int main() | |
81 ; { | |
82 ; nonleaf_call(0, 1, 2, 3, 4, (struct A){5, 6, 7ll}, 8, 9); | |
83 ; return 0; | |
84 ; } | |
85 | |
86 | |
87 | |
88 ; output from plan9-4th_edition-x86 w/ 8c x.c && 8l -a x.8 | |
89 | |
90 001020 (3) TEXT leaf_call+0(SB),$0 | |
91 001020 c3 (5) RET , | |
92 | |
93 001021 (7) TEXT nonleaf_call+0(SB),$148 | |
94 001021 81ec94000000 (7) SUBL $148,SP ; prolog (note, there is no register save area at all) | |
95 001027 8d842494000000 (10) LEAL l+148(SP),AX ; | | |
96 00102e 89442430 (10) MOVL AX,l+48(SP) ; | loop's write ptr (stored at beginning of char[100] space) | |
97 001032 83442430fc (10) ADDL $-4,l+48(SP) ; | decr loop ptr in memory | |
98 001037 8b442430 (10) MOVL l+48(SP),AX ; | ptr -> eax | |
99 00103b c70000000000 (10) MOVL $0,(AX) ; | zero-init char[100] space write a 0 | |
100 001041 837c243000 (10) CMPL l+48(SP),$0 ; | cmp if done | |
101 001046 75ea (10) JNE ,1032 ; | loop | |
102 001048 c64424304c (10) MOVB $76,l+48(SP) ; 'L' -> local area (beginning of char[100] space) | |
103 00104d 8b84249c000000 (11) MOVL b+156(FP),AX ; | | |
104 001054 890424 (11) MOVL AX,(SP) ; | | |
105 001057 8b8424a0000000 (11) MOVL c+160(FP),AX ; | | |
106 00105e 89442404 (11) MOVL AX,4(SP) ; | fetch in args (ints before struct) from prev frame's param area ... | |
107 001062 8b8424a4000000 (11) MOVL d+164(FP),AX ; | ... and "push" onto stack | |
108 001069 89442408 (11) MOVL AX,8(SP) ; | | |
109 00106d 8b8424a8000000 (11) MOVL e+168(FP),AX ; | | |
110 001074 8944240c (11) MOVL AX,12(SP) ; / | |
111 001078 8d7c2410 (11) LEAL 16(SP),DI ; \ dst ptr | |
112 00107c 8db424ac000000 (11) LEAL f+172(FP),SI ; | src ptr | |
113 001083 b904000000 (11) MOVL $4,CX ; | rep counter (4, for dwords = 16b = sizeof(struct A)) | |
114 001088 fc (11) CLD , ; | copy struct to next call's stack | |
115 001089 f3 (11) REP , ; | | |
116 00108a a5 (11) MOVSL , ; / | |
117 00108b 8b8424bc000000 (11) MOVL g+188(FP),AX ; \ | |
118 001092 89442420 (11) MOVL AX,32(SP) ; | fetch remaining in args (ints after struct) from prev frame's param area ... | |
119 001096 8b8424c0000000 (11) MOVL h+192(FP),AX ; | ... and "push" onto stack | |
120 00109d 89442424 (11) MOVL AX,36(SP) ; | | |
121 0010a1 e87affffff (11) CALL ,1020+leaf_call ; push return address and call | |
122 0010a6 81c494000000 (11) ADDL $148,SP ; | | |
123 0010ac c3 (11) RET , ; | epilog | |
124 | |
125 0010ad (14) TEXT main+0(SB),$52 | |
126 0010ad 83ec34 (14) SUBL $52,SP ; prolog (note, there is no register save area at all) | |
127 0010b0 c7042400000000 (16) MOVL $0,(SP) ; arg 0 -> "push" onto stack | |
128 0010b7 b801000000 (16) MOVL $1,AX ; arg 1 -> eax, then ... | |
129 0010bc 89442404 (16) MOVL AX,4(SP) ; ... "pushed" onto stack | |
130 0010c0 b802000000 (16) MOVL $2,AX ; arg 2 -> eax, then ... | |
131 0010c5 89442408 (16) MOVL AX,8(SP) ; ... "pushed" onto stack | |
132 0010c9 b803000000 (16) MOVL $3,AX ; . | |
133 0010ce 8944240c (16) MOVL AX,12(SP) ; . | |
134 0010d2 b804000000 (16) MOVL $4,AX ; . | |
135 0010d7 89442410 (16) MOVL AX,16(SP) ; . | |
136 0010db 8d442414 (16) LEAL 20(SP),AX ; get ptr to next (unused) stack bytes -> eax ... | |
137 0010df 89442430 (16) MOVL AX,.safe+48(SP) ; ... and write it to very top of stack (seems aligned and not adjacent to last arg) | looks like callconv keeps a ptr to | |
138 0010e3 8b442430 (16) MOVL .safe+48(SP),AX ; regetting of same ptr into eax (pointless as same as in eax) | each struct params in local area | |
139 0010e7 c70005000000 (16) MOVL $5,(AX) ; | | |
140 0010ed 8b442430 (16) MOVL .safe+48(SP),AX ; | | |
141 0010f1 c7400406000000 (16) MOVL $6,4(AX) ; | copy struct linearly to stack, adjacent to other args | |
142 0010f8 8b442430 (16) MOVL .safe+48(SP),AX ; | | |
143 0010fc c7400807000000 (16) MOVL $7,8(AX) ; | | |
144 001103 c7400c00000000 (16) MOVL $0,12(AX) ; | msbytes of long long | |
145 00110a b808000000 (16) MOVL $8,AX ; arg 6 -> eax, then ... | |
146 00110f 89442424 (16) MOVL AX,36(SP) ; ... "pushed" onto stack | |
147 001113 b809000000 (16) MOVL $9,AX ; arg 7 -> eax, then ... | |
148 001118 89442428 (16) MOVL AX,40(SP) ; ... "pushed" onto stack | |
149 00111c e800ffffff (16) CALL ,1021+nonleaf_call ; push return address and call | |
150 001121 31c0 (17) MOVL $0,AX ; return value | |
151 001123 83c434 (17) ADDL $52,SP ; | | |
152 001126 c3 (17) RET , ; | epilog | |
153 | |
154 | |
155 | |
156 ; ---------- structs by value, complex example (multiple structs) ----------> | |
157 ; | |
158 ; struct A { int i, j; float f; }; | |
159 ; struct B { double d; long long l; }; | |
160 ; | |
161 ; void leaf_call(int b, struct A c, struct B d, int e, int f, struct A g, struct B h, int i, int j) | |
162 ; { | |
163 ; } | |
164 ; | |
165 ; void nonleaf_call(int a, int b, struct A c, struct B d, int e, int f, struct A g, struct B h, int i, int j) | |
166 ; { | |
167 ; /* use some local data */ | |
168 ; char l[100] = 'L'; | |
169 ; leaf_call(b, c, d, e, f, g, h, i, j); | |
170 ; } | |
171 ; | |
172 ; int main() | |
173 ; { | |
174 ; nonleaf_call(0, 1, (struct A){2, 3, 4.f}, (struct B){5., 6ll}, 7, 8, (struct A){9, 10, 11.f}, (struct B){12., 13ll}, 14, 15); | |
175 ; return 0; | |
176 ; } | |
177 | |
178 | |
179 | |
180 ; output from plan9-4th_edition-x86 w/ 8c x.c && 8l -a x.8 | |
181 | |
182 001020 (4) TEXT leaf_call+0(SB),$0 | |
183 001020 c3 (6) RET , | |
184 | |
185 001021 (8) TEXT nonleaf_call+0(SB),$184 | |
186 001021 81ecb8000000 (8) SUBL $184,SP | |
187 001027 8d8424b8000000 (11) LEAL l+184(SP),AX | |
188 00102e 89442454 (11) MOVL AX,l+84(SP) | |
189 001032 83442454fc (11) ADDL $-4,l+84(SP) | |
190 001037 8b442454 (11) MOVL l+84(SP),AX | |
191 00103b c70000000000 (11) MOVL $0,(AX) | |
192 001041 837c245400 (11) CMPL l+84(SP),$0 | |
193 001046 75ea (11) JNE ,1032 | |
194 001048 c64424544c (11) MOVB $76,l+84(SP) | |
195 00104d 8b8424c0000000 (12) MOVL b+192(FP),AX | |
196 001054 890424 (12) MOVL AX,(SP) | |
197 001057 8d7c2404 (12) LEAL 4(SP),DI | |
198 00105b 8db424c4000000 (12) LEAL c+196(FP),SI | |
199 001062 b903000000 (12) MOVL $3,CX | |
200 001067 fc (12) CLD , | |
201 001068 f3 (12) REP , | |
202 001069 a5 (12) MOVSL , | |
203 00106a 8d7c2410 (12) LEAL 16(SP),DI | |
204 00106e 8db424d0000000 (12) LEAL d+208(FP),SI | |
205 001075 b904000000 (12) MOVL $4,CX | |
206 00107a fc (12) CLD , | |
207 00107b f3 (12) REP , | |
208 00107c a5 (12) MOVSL , | |
209 00107d 8b8424e0000000 (12) MOVL e+224(FP),AX | |
210 001084 89442420 (12) MOVL AX,32(SP) | |
211 001088 8b8424e4000000 (12) MOVL f+228(FP),AX | |
212 00108f 89442424 (12) MOVL AX,36(SP) | |
213 001093 8d7c2428 (12) LEAL 40(SP),DI | |
214 001097 8db424e8000000 (12) LEAL g+232(FP),SI | |
215 00109e b903000000 (12) MOVL $3,CX | |
216 0010a3 fc (12) CLD , | |
217 0010a4 f3 (12) REP , | |
218 0010a5 a5 (12) MOVSL , | |
219 0010a6 8d7c2434 (12) LEAL 52(SP),DI | |
220 0010aa 8db424f4000000 (12) LEAL h+244(FP),SI | |
221 0010b1 b904000000 (12) MOVL $4,CX | |
222 0010b6 fc (12) CLD , | |
223 0010b7 f3 (12) REP , | |
224 0010b8 a5 (12) MOVSL , | |
225 0010b9 8b842404010000 (12) MOVL i+260(FP),AX | |
226 0010c0 89442444 (12) MOVL AX,68(SP) | |
227 0010c4 8b842408010000 (12) MOVL j+264(FP),AX | |
228 0010cb 89442448 (12) MOVL AX,72(SP) | |
229 0010cf e84cffffff (12) CALL ,1020+leaf_call | |
230 0010d4 81c4b8000000 (12) ADDL $184,SP | |
231 0010da c3 (12) RET , | |
232 | |
233 0010db (15) TEXT main+0(SB),$100 | |
234 0010db 83ec64 (15) SUBL $100,SP | |
235 0010de c7042400000000 (17) MOVL $0,(SP) | |
236 0010e5 b801000000 (17) MOVL $1,AX | |
237 0010ea 89442404 (17) MOVL AX,4(SP) | |
238 0010ee 8d442408 (17) LEAL 8(SP),AX | |
239 0010f2 89442460 (17) MOVL AX,.safe+96(SP) | |
240 0010f6 8b442460 (17) MOVL .safe+96(SP),AX | |
241 0010fa c70002000000 (17) MOVL $2,(AX) | |
242 001100 8b442460 (17) MOVL .safe+96(SP),AX | |
243 001104 c7400403000000 (17) MOVL $3,4(AX) | |
244 00110b dd0500200000 (17) FMOVD $0.40100000+0(SB),F0 | |
245 001111 8b442460 (17) MOVL .safe+96(SP),AX | |
246 001115 d95808 (17) FMOVFP F0,8(AX) | |
247 001118 8d442414 (17) LEAL 20(SP),AX | |
248 00111c 8944245c (17) MOVL AX,.safe+92(SP) | |
249 001120 dd0508200000 (17) FMOVD $0.40140000+0(SB),F0 | |
250 001126 8b44245c (17) MOVL .safe+92(SP),AX | |
251 00112a dd18 (17) FMOVDP F0,(AX) | |
252 00112c 8b44245c (17) MOVL .safe+92(SP),AX | |
253 001130 c7400806000000 (17) MOVL $6,8(AX) | |
254 001137 c7400c00000000 (17) MOVL $0,12(AX) | |
255 00113e b807000000 (17) MOVL $7,AX | |
256 001143 89442424 (17) MOVL AX,36(SP) | |
257 001147 b808000000 (17) MOVL $8,AX | |
258 00114c 89442428 (17) MOVL AX,40(SP) | |
259 001150 8d44242c (17) LEAL 44(SP),AX | |
260 001154 89442458 (17) MOVL AX,.safe+88(SP) | |
261 001158 8b442458 (17) MOVL .safe+88(SP),AX | |
262 00115c c70009000000 (17) MOVL $9,(AX) | |
263 001162 8b442458 (17) MOVL .safe+88(SP),AX | |
264 001166 c740040a000000 (17) MOVL $10,4(AX) | |
265 00116d dd0510200000 (17) FMOVD $0.40260000+0(SB),F0 | |
266 001173 8b442458 (17) MOVL .safe+88(SP),AX | |
267 001177 d95808 (17) FMOVFP F0,8(AX) | |
268 00117a 8d442438 (17) LEAL 56(SP),AX | |
269 00117e 89442454 (17) MOVL AX,.safe+84(SP) | |
270 001182 dd0518200000 (17) FMOVD $0.40280000+0(SB),F0 | |
271 001188 8b442454 (17) MOVL .safe+84(SP),AX | |
272 00118c dd18 (17) FMOVDP F0,(AX) | |
273 00118e 8b442454 (17) MOVL .safe+84(SP),AX | |
274 001192 c740080d000000 (17) MOVL $13,8(AX) | |
275 001199 c7400c00000000 (17) MOVL $0,12(AX) | |
276 0011a0 b80e000000 (17) MOVL $14,AX | |
277 0011a5 89442448 (17) MOVL AX,72(SP) | |
278 0011a9 b80f000000 (17) MOVL $15,AX | |
279 0011ae 8944244c (17) MOVL AX,76(SP) | |
280 0011b2 e86afeffff (17) CALL ,1021+nonleaf_call | |
281 0011b7 31c0 (18) MOVL $0,AX | |
282 0011b9 83c464 (18) ADDL $100,SP | |
283 0011bc c3 (18) RET , | |
284 | |
285 002000 0000000000001040 (17) DATA $0.40100000+0(SB)/8,$(40100000,00000000) | |
286 002008 0000000000001440 (17) DATA $0.40140000+0(SB)/8,$(40140000,00000000) | |
287 002010 0000000000002640 (17) DATA $0.40260000+0(SB)/8,$(40260000,00000000) | |
288 002018 0000000000002840 (17) DATA $0.40280000+0(SB)/8,$(40280000,00000000) | |
289 | |
290 | |
291 | |
63 ; vim: ft=asm | 292 ; vim: ft=asm |
64 | 293 |